C# ILGenerator.MarkLabel方法代码示例

        public override void GenerateCode(ILGenerator codeGenerator, TypeBuilder typeBuilder, ModuleBuilder moduleBuilder)
        {
            Label forStart = codeGenerator.DefineLabel();
            Label forEnd = codeGenerator.DefineLabel();
            EndLabel = forEnd;

            InitExp.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);

            UpperBoundExp.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);

            codeGenerator.MarkLabel(forStart);

            codeGenerator.Emit(OpCodes.Dup);
            codeGenerator.Emit(OpCodes.Ldsfld, InitExp.ForVariableBuilder);
            codeGenerator.Emit(OpCodes.Blt, forEnd);

            BodyExp.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);

            codeGenerator.Emit(OpCodes.Ldsfld, InitExp.ForVariableBuilder);
            codeGenerator.Emit(OpCodes.Ldc_I4_1);
            codeGenerator.Emit(OpCodes.Add);
            codeGenerator.Emit(OpCodes.Stsfld, InitExp.ForVariableBuilder);
            codeGenerator.Emit(OpCodes.Br, forStart);

            codeGenerator.MarkLabel(forEnd);

            codeGenerator.Emit(OpCodes.Pop);
            InitExp.RestoreVariable(codeGenerator);
        }

        public override void GenerateCode(ILGenerator codeGenerator, TypeBuilder typeBuilder, ModuleBuilder moduleBuilder)
        {
            LeftOperand.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);
            RightOperand.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);

            Label endLabel = codeGenerator.DefineLabel();
            Label trueLabel = codeGenerator.DefineLabel();

            if (LeftOperand.ReturnType == StringType.StringInstance)
            {
                codeGenerator.Emit(OpCodes.Call, typeof(String).GetMethod("CompareTo", new Type[] { typeof(string) }));
                codeGenerator.Emit(OpCodes.Ldc_I4_0);
                codeGenerator.Emit(OpCodes.Bne_Un, trueLabel);
            }
            else
                codeGenerator.Emit(OpCodes.Bne_Un, trueLabel);

            codeGenerator.Emit(OpCodes.Ldc_I4_0);
            codeGenerator.Emit(OpCodes.Br, endLabel);

            codeGenerator.MarkLabel(trueLabel);
            codeGenerator.Emit(OpCodes.Ldc_I4_1);

            codeGenerator.MarkLabel(endLabel);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="context"></param>
        /// <param name="typeToBuild"></param>
        /// <param name="existing"></param>
        /// <param name="idToBuild"></param>
        /// <param name="il"></param>
        protected override void BuildUp(IBuilderContext context, Type typeToBuild, object existing, string idToBuild,
		                                ILGenerator il)
        {
            IConstructorChooserPolicy ctorChooser = GetConstructorChooser(context, typeToBuild, idToBuild);
            ConstructorInfo ctor = ctorChooser.ChooseConstructor(typeToBuild);
            Label existingObjectNotNull = il.DefineLabel();
            Label done = il.DefineLabel();

            // If existing object (arg 2) is null, call the constructor
            il.Emit(OpCodes.Ldarg_2);
            il.Emit(OpCodes.Ldnull);
            il.Emit(OpCodes.Ceq);
            il.Emit(OpCodes.Brfalse, existingObjectNotNull);

            // resolve all constructor parameters...
            if (ctor != null)
            {
                foreach (ParameterInfo parameter in ctor.GetParameters())
                {
                    EmitResolveParameter(il, parameter);
                    FixupParameterType(il, parameter.ParameterType);
                }
            }
            // invoke constructor, leaving the new object on the top of the stack...
            EmitCallConstructor(il, ctor, typeToBuild);

            // And skip around the else clause
            il.Emit(OpCodes.Br_S, done);

            // We have an existing object, just get it on top of the stack
            il.MarkLabel(existingObjectNotNull);
            il.Emit(OpCodes.Ldarg_2);
            il.MarkLabel(done);
        }

        public override void Generate(ILGenerator generator, Symbols s)
        {
            var Is_False = generator.DefineLabel();
            var End = generator.DefineLabel();

            LeftOperand.Generate(generator, s);
            //Pregunto si hay un 0 en el tope d la pila
            generator.Emit(OpCodes.Ldc_I4_0);
            //Si es verdad salto para la etiqueta es falso
            generator.Emit(OpCodes.Beq, Is_False);

            RightOperand.Generate(generator, s);
            //Pregunto si hay un 0 en el tope d la pila
            generator.Emit(OpCodes.Ldc_I4_0);
            //Si es verdad salto para la etiqueta es falso
            generator.Emit(OpCodes.Beq, Is_False);
            //Si hay un 1 en el tope es porque no salte para el label que me dice si hay algun false ,
            //por lo q el primer operando es true y entonces es true el and
            generator.Emit(OpCodes.Ldc_I4_1);

            generator.Emit(OpCodes.Br, End);

            generator.MarkLabel(Is_False);

            generator.Emit(OpCodes.Ldc_I4_0);
            generator.MarkLabel(End);
        }

		public void GenerateWriterMethod(Type obtype, CodeGenContext ctx, ILGenerator il)
		{
			var getTypeIDMethodInfo = typeof(Serializer).GetMethod("GetTypeID", BindingFlags.NonPublic | BindingFlags.Instance, null,
				new Type[] { typeof(object) }, null);

			var map = ctx.TypeMap;

			// arg0: Serializer, arg1: Stream, arg2: object

			var idLocal = il.DeclareLocal(typeof(ushort));

			// get TypeID from object's Type
			il.Emit(OpCodes.Ldarg_0);
			il.Emit(OpCodes.Ldarg_2);
			il.Emit(OpCodes.Call, getTypeIDMethodInfo);
			il.Emit(OpCodes.Stloc_S, idLocal);

			// write typeID
			il.Emit(OpCodes.Ldarg_1);
			il.Emit(OpCodes.Ldloc_S, idLocal);
			il.Emit(OpCodes.Call, ctx.GetWriterMethodInfo(typeof(ushort)));

			// +1 for 0 (null)
			var jumpTable = new Label[map.Count + 1];
			jumpTable[0] = il.DefineLabel();
			foreach (var kvp in map)
				jumpTable[kvp.Value.TypeID] = il.DefineLabel();

			il.Emit(OpCodes.Ldloc_S, idLocal);
			il.Emit(OpCodes.Switch, jumpTable);

			il.Emit(OpCodes.Newobj, Helpers.ExceptionCtorInfo);
			il.Emit(OpCodes.Throw);

			/* null case */
			il.MarkLabel(jumpTable[0]);
			il.Emit(OpCodes.Ret);

			/* cases for types */
			foreach (var kvp in map)
			{
				var type = kvp.Key;
				var data = kvp.Value;

				il.MarkLabel(jumpTable[data.TypeID]);

				if (data.NeedsInstanceParameter)
					il.Emit(OpCodes.Ldarg_0);

				il.Emit(OpCodes.Ldarg_1);
				il.Emit(OpCodes.Ldarg_2);
				il.Emit(type.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, type);

				il.Emit(OpCodes.Tailcall);
				il.Emit(OpCodes.Call, data.WriterMethodInfo);

				il.Emit(OpCodes.Ret);
			}
		}

 internal override void TranslateToIL(ILGenerator il, Type rtype){
   Label else_label = il.DefineLabel();
   Label endif_label = il.DefineLabel();
   this.condition.TranslateToConditionalBranch(il, false, else_label, false);
   this.operand1.TranslateToIL(il, rtype);
   il.Emit(OpCodes.Br, endif_label);
   il.MarkLabel(else_label);
   this.operand2.TranslateToIL(il, rtype);
   il.MarkLabel(endif_label);
 }

        public override void GenerateIL(ILGenerator il, SymbolTable st)
        {
            Label beginLoop = il.DefineLabel();
            Label endLoop = il.DefineLabel();
            il.MarkLabel(beginLoop);
            var newTable = new SymbolTable(st, endLoop);
            Block.GenerateIL(il, newTable);

            il.Emit(OpCodes.Br, beginLoop);
            il.MarkLabel(endLoop);
        }

        public override void GenerateCode(ILGenerator codeGenerator, TypeBuilder typeBuilder, ModuleBuilder moduleBuilder)
        {
            Label thenLabel = codeGenerator.DefineLabel();
            Label endLabel = codeGenerator.DefineLabel();

            ConditionExp.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);
            codeGenerator.Emit(OpCodes.Brfalse, thenLabel);
            ThenExp.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);
            codeGenerator.Emit(OpCodes.Br, endLabel);
            codeGenerator.MarkLabel(thenLabel);
            ElseExp.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);
            codeGenerator.MarkLabel(endLabel);
        }

		public override void Generate (ILGenerator gen)
		{
			Label falseLabel = gen.DefineLabel ();
			Label endLabel = gen.DefineLabel ();
			
			GenerateCondition (gen, falseLabel);
			trueBlock.Generate (gen);
			gen.Emit (OpCodes.Br, endLabel);
			gen.MarkLabel(falseLabel);
			falseBlock.Generate (gen);
			
			gen.MarkLabel(endLabel);
		}

        static void WriteDeserializerArray(TypeBuilder typeBuilder, ILGenerator il, Type type, int tag, MethodInfo setMethod,
            int? itemLocalIndex = null)
        {
            var itemType = type.GetElementType();

            var lengthLocal = il.DeclareLocal(typeof(int));
            var arrayLocal = il.DeclareLocal(type);
            var itemLocal = il.DeclareLocal(itemType);
            var indexLocal = il.DeclareLocal(typeof(int));
            var startLabel = il.DefineLabel();
            var endLabel = il.DefineLabel();

            il.Emit(OpCodes.Ldarg_2);
            il.Emit(OpCodes.Ldarg_3);
            il.Emit(OpCodes.Ldc_I4, tag);
            il.Emit(OpCodes.Call, GetCollectionLengthMethod);
            il.Emit(OpCodes.Stloc, lengthLocal);
            il.Emit(OpCodes.Ldloc, lengthLocal.LocalIndex);
            il.Emit(OpCodes.Newarr, itemType);
            il.Emit(OpCodes.Stloc, arrayLocal.LocalIndex);

            il.Emit(OpCodes.Ldc_I4_0);
            il.Emit(OpCodes.Stloc, indexLocal.LocalIndex);
            il.Emit(OpCodes.Br, startLabel);
            il.MarkLabel(endLabel);

            WriteDeserializerReadValue(typeBuilder, il, itemType, 1, itemLocal.LocalIndex);

            il.Emit(OpCodes.Ldloc, arrayLocal.LocalIndex);
            il.Emit(OpCodes.Ldloc, indexLocal.LocalIndex);
            il.Emit(OpCodes.Ldloc, itemLocal.LocalIndex);
            il.Emit(OpCodes.Stelem, itemType);

            il.Emit(OpCodes.Ldloc, indexLocal.LocalIndex);
            il.Emit(OpCodes.Ldc_I4_1);
            il.Emit(OpCodes.Add);
            il.Emit(OpCodes.Stloc, indexLocal.LocalIndex);
            il.MarkLabel(startLabel);
            il.Emit(OpCodes.Ldloc, indexLocal.LocalIndex);
            il.Emit(OpCodes.Ldloc, lengthLocal.LocalIndex);
            il.Emit(OpCodes.Blt, endLabel);

            if (itemLocalIndex == null) {
                il.Emit(OpCodes.Ldarg_1);
                il.Emit(OpCodes.Ldloc, arrayLocal.LocalIndex);
                il.Emit(OpCodes.Callvirt, setMethod);
            } else {
                il.Emit(OpCodes.Ldloc, arrayLocal.LocalIndex);
                il.Emit(OpCodes.Stloc, itemLocalIndex.Value);
            }
        }

        public static void GenerateSerializerSwitch(CodeGenContext ctx, ILGenerator il, IDictionary<Type, TypeData> map)
        {
            // arg0: Stream, arg1: object

            var idLocal = il.DeclareLocal(typeof(ushort));

            // get TypeID from object's Type
            var getTypeIDMethod = typeof(Serializer).GetMethod("GetTypeID", BindingFlags.NonPublic | BindingFlags.Static, null, new Type[] { typeof(object) }, null);
            il.Emit(OpCodes.Ldarg_1);
            il.EmitCall(OpCodes.Call, getTypeIDMethod, null);
            il.Emit(OpCodes.Stloc_S, idLocal);

            // write typeID
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldloc_S, idLocal);
            il.EmitCall(OpCodes.Call, ctx.GetWriterMethodInfo(typeof(ushort)), null);

            // +1 for 0 (null)
            var jumpTable = new Label[map.Count + 1];
            jumpTable[0] = il.DefineLabel();
            foreach (var kvp in map)
                jumpTable[kvp.Value.TypeID] = il.DefineLabel();

            il.Emit(OpCodes.Ldloc_S, idLocal);
            il.Emit(OpCodes.Switch, jumpTable);

            ConstructorInfo exceptionCtor = typeof(Exception).GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, new Type[0], null);
            il.Emit(OpCodes.Newobj, exceptionCtor);
            il.Emit(OpCodes.Throw);

            /* null case */
            il.MarkLabel(jumpTable[0]);
            il.Emit(OpCodes.Ret);

            /* cases for types */
            foreach (var kvp in map)
            {
                var type = kvp.Key;
                var data = kvp.Value;

                il.MarkLabel(jumpTable[data.TypeID]);

                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldarg_1);
                il.Emit(type.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, type);

                il.EmitCall(OpCodes.Call, data.WriterMethodInfo, null);

                il.Emit(OpCodes.Ret);
            }
        }

 public override void GenerateCode(ILGenerator codeGenerator, TypeBuilder typeBuilder, ModuleBuilder moduleBuilder)
 {
     Label trueLabel = codeGenerator.DefineLabel();
     Label endLabel = codeGenerator.DefineLabel();
     LeftOperand.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);
     codeGenerator.Emit(OpCodes.Brtrue, trueLabel);
     RightOperand.GenerateCode(codeGenerator, typeBuilder, moduleBuilder);
     codeGenerator.Emit(OpCodes.Brtrue, trueLabel);
     codeGenerator.Emit(OpCodes.Ldc_I4_0);
     codeGenerator.Emit(OpCodes.Br, endLabel);
     codeGenerator.MarkLabel(trueLabel);
     codeGenerator.Emit(OpCodes.Ldc_I4_1);
     codeGenerator.MarkLabel(endLabel);
 }

 public void IfNull(ILGenerator il, Emitter isTrue, Emitter isFalse)
 {
     Label nope = il.DefineLabel();
       Label done = il.DefineLabel();
       il.Emit(OpCodes.Ldnull);
       il.Emit(OpCodes.Ceq); // Has 1 if NULL
       il.Emit(OpCodes.Ldc_I4_0);
       il.Emit(OpCodes.Ceq); // Has 1 if NOT NULL
       il.Emit(OpCodes.Brtrue, nope);
       isTrue();
       il.Emit(OpCodes.Br, done);
       il.MarkLabel(nope);
       isFalse();
       il.MarkLabel(done);
 }

		public void GenerateWriterMethod(Serializer serializer, Type type, ILGenerator il)
		{
			var valueType = type.GetGenericArguments()[0];

			var noValueLabel = il.DefineLabel();

			MethodInfo getHasValue = type.GetProperty("HasValue").GetGetMethod();
			MethodInfo getValue = type.GetProperty("Value").GetGetMethod();

			var data = serializer.GetIndirectData(valueType);

			il.Emit(OpCodes.Ldarg_1);       // Stream
			il.Emit(OpCodes.Ldarga_S, 2);   // &value
			il.Emit(OpCodes.Call, getHasValue);
			il.Emit(OpCodes.Call, serializer.GetDirectWriter(typeof(bool)));

			il.Emit(OpCodes.Ldarga_S, 2);   // &value
			il.Emit(OpCodes.Call, getHasValue);
			il.Emit(OpCodes.Brfalse_S, noValueLabel);

			if (data.WriterNeedsInstance)
				il.Emit(OpCodes.Ldarg_0);   // Serializer
			il.Emit(OpCodes.Ldarg_1);       // Stream
			il.Emit(OpCodes.Ldarga_S, 2);   // &value
			il.Emit(OpCodes.Call, getValue);

			// XXX for some reason Tailcall causes huge slowdown, at least with "decimal?"
			//il.Emit(OpCodes.Tailcall);
			il.Emit(OpCodes.Call, data.WriterMethodInfo);

			il.MarkLabel(noValueLabel);
			il.Emit(OpCodes.Ret);
		}

 void CopyLabels(ILGenerator Gen, int i, Dictionary<int, Label> LateLabels)
 {
     if(!LateLabels.ContainsKey(i)) return;
     
     Gen.MarkLabel(LateLabels[i]);
     LateLabels.Remove(i);
 }