Esempi in C# (CSharp) per IXamlILEmitter.Emit

Esempio n. 1

File: ILEmitHelpers.cs Progetto: workgroupengineering/XamlX

        public static void EmitFieldLiteral(IXamlField field, IXamlILEmitter codeGen)
        {
            var ftype = field.FieldType.IsEnum ? field.FieldType.GetEnumUnderlyingType() : field.FieldType;

            if (ftype.Name == "UInt64" || ftype.Name == "Int64")
            {
                codeGen.Emit(OpCodes.Ldc_I8,
                             TypeSystemHelpers.ConvertLiteralToLong(field.GetLiteralValue()));
            }
            else if (ftype.Name == "Double")
            {
                codeGen.Emit(OpCodes.Ldc_R8, (double)field.GetLiteralValue());
            }
            else if (ftype.Name == "Single")
            {
                codeGen.Emit(OpCodes.Ldc_R4, (float)field.GetLiteralValue());
            }
            else if (ftype.Name == "String")
            {
                codeGen.Emit(OpCodes.Ldstr, (string)field.GetLiteralValue());
            }
            else
            {
                codeGen.Emit(OpCodes.Ldc_I4,
                             TypeSystemHelpers.ConvertLiteralToInt(field.GetLiteralValue()));
            }
        }

Esempio n. 2

        public static IXamlILEmitter DebugHatch(this IXamlILEmitter emitter, string message)
        {
#if DEBUG
            var debug = emitter.TypeSystem.GetType("XamlX.XamlDebugHatch").FindMethod(m => m.Name == "Debug");
            emitter.Emit(OpCodes.Ldstr, message);
            emitter.Emit(OpCodes.Call, debug);
#endif
            return(emitter);
        }

Esempio n. 3

File: HotReloadExtensions.cs Progetto: notanaverageman/XamlX

        private static IDisposable EmitMarker(
            this IXamlILEmitter emitter,
            string startMethodName,
            string endMethodName = null,
            params string[] parameters)
        {
            var markers = emitter.TypeSystem.FindType("Avalonia.Markup.Xaml.HotReload.XamlMarkers");

            if (markers == null)
            {
                return(EmptyDisposable.Instance);
            }

            var startMarker = markers.FindMethod(m => m.Name == startMethodName);

            foreach (string parameter in parameters)
            {
                emitter.Emit(OpCodes.Ldstr, parameter);
            }

            emitter.EmitCall(startMarker);

            if (endMethodName != null)
            {
                var endMarker = markers.FindMethod(m => m.Name == endMethodName);
                return(new ActionDisposable(() => emitter.EmitCall(endMarker)));
            }

            return(EmptyDisposable.Instance);
        }

Esempio n. 4

File: RXamlVecLikeConstAstNode.cs Progetto: tmtmtl30/RobustToolbox

        public override XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context,
                                                  IXamlILEmitter codeGen)
        {
            foreach (var value in Values)
            {
                codeGen.Emit(OpCodes.Ldc_I4, value);
            }

            return(base.Emit(context, codeGen));
        }

Esempio n. 5

        public static IXamlILEmitter EmitCall(this IXamlILEmitter emitter, IXamlMethod method, bool swallowResult = false)
        {
            if (method is IXamlCustomEmitMethod <IXamlILEmitter> custom)
            {
                custom.EmitCall(emitter);
            }
            else
            {
                emitter.Emit(method.IsStatic ? OpCodes.Call : OpCodes.Callvirt, method);
            }

            if (swallowResult && !(method.ReturnType.Namespace == "System" && method.ReturnType.Name == "Void"))
            {
                emitter.Pop();
            }
            return(emitter);
        }

Esempio n. 6

File: RecordingIlEmitter.cs Progetto: workgroupengineering/XamlX

 public IXamlILEmitter Emit(OpCode code)
 {
     Record(code, null);
     _inner.Emit(code);
     return(this);
 }

Esempio n. 7

 public static IXamlILEmitter Ldarg(this IXamlILEmitter emitter, int arg)
 => emitter.Emit(OpCodes.Ldarg, arg);

Esempio n. 8

 public static IXamlILEmitter Ldlen(this IXamlILEmitter emitter) => emitter.Emit(OpCodes.Ldlen);

Esempio n. 9

 public static IXamlILEmitter Add(this IXamlILEmitter emitter) => emitter.Emit(OpCodes.Add);

Esempio n. 10

 public static IXamlILEmitter Ldc_R8(this IXamlILEmitter emitter, double arg)
 => emitter.Emit(OpCodes.Ldc_R8, arg);

Esempio n. 11

 public static IXamlILEmitter Ret(this IXamlILEmitter emitter)
 => emitter.Emit(OpCodes.Ret);

Esempio n. 12

 public static IXamlILEmitter Ldnull(this IXamlILEmitter emitter) => emitter.Emit(OpCodes.Ldnull);

Esempio n. 13

 public static IXamlILEmitter Throw(this IXamlILEmitter emitter)
 => emitter.Emit(OpCodes.Throw);

Esempio n. 14

 public static IXamlILEmitter Ldarg_0(this IXamlILEmitter emitter)
 => emitter.Emit(OpCodes.Ldarg_0);

Esempio n. 15

 public static IXamlILEmitter Ldloca(this IXamlILEmitter emitter, IXamlLocal local)
 => emitter.Emit(OpCodes.Ldloca, local);

Esempio n. 16

 public static IXamlILEmitter Isinst(this IXamlILEmitter emitter, IXamlType type)
 => emitter.Emit(OpCodes.Isinst, type);

Esempio n. 17

 public static IXamlILEmitter Ldftn(this IXamlILEmitter emitter, IXamlMethod method)
 => emitter.Emit(OpCodes.Ldftn, method);

Esempio n. 18

 public static IXamlILEmitter Ldtoken(this IXamlILEmitter emitter, IXamlType type)
 => emitter.Emit(OpCodes.Ldtoken, type);

Esempio n. 19

 public static IXamlILEmitter Pop(this IXamlILEmitter emitter)
 => emitter.Emit(OpCodes.Pop);

Esempio n. 20

 public static IXamlILEmitter Dup(this IXamlILEmitter emitter)
 => emitter.Emit(OpCodes.Dup);

Esempio n. 21

 public static IXamlILEmitter Stsfld(this IXamlILEmitter emitter, IXamlField field)
 => emitter.Emit(OpCodes.Stsfld, field);

Esempio n. 22

 public static IXamlILEmitter Castclass(this IXamlILEmitter emitter, IXamlType type)
 => emitter.Emit(OpCodes.Castclass, type);

Esempio n. 23

 public static IXamlILEmitter Stloc(this IXamlILEmitter emitter, IXamlLocal local)
 => emitter.Emit(OpCodes.Stloc, local);

Esempio n. 24

 public static IXamlILEmitter Unbox(this IXamlILEmitter emitter, IXamlType type)
 => emitter.Emit(OpCodes.Unbox, type);

Esempio n. 25

 public static IXamlILEmitter Ldstr(this IXamlILEmitter emitter, string arg)
 => arg == null?emitter.Ldnull() : emitter.Emit(OpCodes.Ldstr, arg);

Esempio n. 26

 public static IXamlILEmitter Newobj(this IXamlILEmitter emitter, IXamlConstructor ctor)
 => emitter.Emit(OpCodes.Newobj, ctor);

Esempio n. 27

 public static IXamlILEmitter Ldc_I4(this IXamlILEmitter emitter, int arg)
 => arg == 0
         ? emitter.Emit(OpCodes.Ldc_I4_0)
         : arg == 1
             ? emitter.Emit(OpCodes.Ldc_I4_1)
             : emitter.Emit(OpCodes.Ldc_I4, arg);

Esempio n. 28

 public static IXamlILEmitter Newarr(this IXamlILEmitter emitter, IXamlType type)
 => emitter.Emit(OpCodes.Newarr, type);

Esempio n. 29

 public static IXamlILEmitter Ble(this IXamlILEmitter emitter, IXamlLabel label)
 => emitter.Emit(OpCodes.Ble, label);

Esempio n. 30

 public static IXamlILEmitter Stelem_ref(this IXamlILEmitter emitter) => emitter.Emit(OpCodes.Stelem_Ref);