internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Ldloc, (CodeEmitterLocal)context[Name]); }
internal abstract void Generate(CodeGenContext context, CodeEmitter ilgen);
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { // we don't use fw.EmitSet because we don't want automatic unboxing and whatever ilgen.Emit(OpCodes.Stsfld, StaticCompiler.GetFieldForMapXml(context.ClassLoader, Class, Name, Sig).GetField()); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { CodeEmitterLabel l; if(context[Name] == null) { l = ilgen.DefineLabel(); context[Name] = l; } else { l = (CodeEmitterLabel)context[Name]; } ilgen.MarkLabel(l); }
internal sealed override void Generate(CodeGenContext context, CodeEmitter ilgen) { Debug.Assert(Name != null); if (Name == ".ctor") { Debug.Assert(Class == null && type != null); Type[] argTypes = context.ClassLoader.ArgTypeListFromSig(Sig); ConstructorInfo ci = StaticCompiler.GetTypeForMapXml(context.ClassLoader, type).GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, CallingConventions.Standard, argTypes, null); if (ci == null) { throw new InvalidOperationException("Missing .ctor: " + type + "..ctor" + Sig); } ilgen.Emit(opcode, ci); } else { Debug.Assert(Class == null ^ type == null); if (Class != null) { Debug.Assert(Sig != null); MethodWrapper method = context.ClassLoader.LoadClassByDottedName(Class).GetMethodWrapper(Name, Sig, false); if (method == null) { throw new InvalidOperationException("method not found: " + Class + "." + Name + Sig); } method.Link(); // TODO this code is part of what Compiler.CastInterfaceArgs (in compiler.cs) does, // it would be nice if we could avoid this duplication... TypeWrapper[] argTypeWrappers = method.GetParameters(); for (int i = 0; i < argTypeWrappers.Length; i++) { if (argTypeWrappers[i].IsGhost) { CodeEmitterLocal[] temps = new CodeEmitterLocal[argTypeWrappers.Length + (method.IsStatic ? 0 : 1)]; for (int j = temps.Length - 1; j >= 0; j--) { TypeWrapper tw; if (method.IsStatic) { tw = argTypeWrappers[j]; } else { if (j == 0) { tw = method.DeclaringType; } else { tw = argTypeWrappers[j - 1]; } } if (tw.IsGhost) { tw.EmitConvStackTypeToSignatureType(ilgen, null); } temps[j] = ilgen.DeclareLocal(tw.TypeAsSignatureType); ilgen.Emit(OpCodes.Stloc, temps[j]); } for (int j = 0; j < temps.Length; j++) { ilgen.Emit(OpCodes.Ldloc, temps[j]); } break; } } if (opcode.Value == OpCodes.Call.Value) { method.EmitCall(ilgen); } else if (opcode.Value == OpCodes.Callvirt.Value) { method.EmitCallvirt(ilgen); } else if (opcode.Value == OpCodes.Newobj.Value) { method.EmitNewobj(ilgen); } else { // ldftn or ldvirtftn ilgen.Emit(opcode, (MethodInfo)method.GetMethod()); } } else { Type[] argTypes; if (Sig.StartsWith("(")) { argTypes = context.ClassLoader.ArgTypeListFromSig(Sig); } else if (Sig == "") { argTypes = Type.EmptyTypes; } else { string[] types = Sig.Split(';'); argTypes = new Type[types.Length]; for (int i = 0; i < types.Length; i++) { argTypes[i] = StaticCompiler.GetTypeForMapXml(context.ClassLoader, types[i]); } } MethodInfo mi = StaticCompiler.GetTypeForMapXml(context.ClassLoader, type).GetMethod(Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, null, argTypes, null); if (mi == null) { throw new InvalidOperationException("Missing method: " + type + "." + Name + Sig); } ilgen.Emit(opcode, mi); } } }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { FieldWrapper fw = ClassLoaderWrapper.LoadClassCritical(Class).GetFieldWrapper(Name, Sig); fw.Link(); // we don't use fw.EmitSet because we don't want automatic unboxing and whatever ilgen.Emit(OpCodes.Stsfld, fw.GetField()); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Ldstr, Value); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.LazyEmitPop(); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { FieldWrapper fw = ClassLoaderWrapper.LoadClassCritical(Class).GetFieldWrapper(Name, Sig); fw.Link(); ilgen.Emit(OpCodes.Ldflda, fw.GetField()); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Ldtoken, StaticCompiler.GetType(context.ClassLoader, type)); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Ldelema, context.ClassLoader.FieldTypeWrapperFromSig(Sig).TypeAsArrayType); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Ldarga, (short)ArgNum); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { if(Type != null) { ilgen.Emit(OpCodes.Ldsfld, StaticCompiler.GetTypeForMapXml(context.ClassLoader, Type).GetField(Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)); } else { FieldWrapper fw = StaticCompiler.GetClassForMapXml(context.ClassLoader, Class).GetFieldWrapper(Name, Sig); fw.Link(); // we don't use fw.EmitGet because we don't want automatic unboxing and whatever ilgen.Emit(OpCodes.Ldsfld, fw.GetField()); } }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Unaligned, (byte)Alignment); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Ldc_I4, val); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { context.ClassLoader.LoadClassByDottedName(Class).EmitRunClassConstructor(ilgen); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.BeginExceptionBlock(); @try.Generate(context, ilgen); if(@catch != null) { Type type; if(@catch.type != null) { type = StaticCompiler.GetTypeForMapXml(context.ClassLoader, @catch.type); } else { type = context.ClassLoader.LoadClassByDottedName(@catch.Class).TypeAsExceptionType; } ilgen.BeginCatchBlock(type); @catch.Generate(context, ilgen); } if(@finally != null) { ilgen.BeginFinallyBlock(); @finally.Generate(context, ilgen); } ilgen.EndExceptionBlock(); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Pop); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { if (Environment.Version.ToString().StartsWith(framework)) { code.Generate(context, ilgen); } }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Newarr, context.ClassLoader.FieldTypeWrapperFromSig(Sig).TypeAsArrayType); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { if (!Validate()) { return; } MemberInfo member = Resolve(context); Type type = member as Type; MethodInfo method = member as MethodInfo; ConstructorInfo constructor = member as ConstructorInfo; FieldInfo field = member as FieldInfo; if (type != null) { ilgen.Emit(OpCodes.Ldtoken, type); } else if (method != null) { ilgen.Emit(OpCodes.Ldtoken, method); } else if (constructor != null) { ilgen.Emit(OpCodes.Ldtoken, constructor); } else if (field != null) { ilgen.Emit(OpCodes.Ldtoken, field); } else { StaticCompiler.IssueMessage(Message.MapXmlUnableToResolveOpCode, ToString()); } }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { CodeEmitterLocal lb = (CodeEmitterLocal)context[Name]; if(lb == null) { if(typeWrapper == null && typeType == null) { Debug.Assert(Class == null ^ type == null); if(type != null) { typeType = StaticCompiler.GetTypeForMapXml(context.ClassLoader, type); } else { typeWrapper = context.ClassLoader.LoadClassByDottedName(Class); } } lb = ilgen.DeclareLocal(typeType != null ? typeType : typeWrapper.TypeAsTBD); context[Name] = lb; } ilgen.Emit(OpCodes.Stloc, lb); }
private MemberInfo Resolve(CodeGenContext context) { if (type != null) { if (Class != null || Method != null || Field != null || Sig != null) { throw new NotImplementedException(); } return StaticCompiler.GetTypeForMapXml(context.ClassLoader, type); } else if (Class != null) { TypeWrapper tw = context.ClassLoader.LoadClassByDottedNameFast(Class); if (tw == null) { return null; } else if (Method != null) { MethodWrapper mw = tw.GetMethodWrapper(Method, Sig, false); if (mw == null) { return null; } return mw.GetMethod(); } else if (Field != null) { FieldWrapper fw = tw.GetFieldWrapper(Field, Sig); if (fw == null) { return null; } return fw.GetField(); } else { return tw.TypeAsBaseType; } } else { return null; } }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Ldarg_S, ArgNum); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { FieldWrapper fw = StaticCompiler.GetClassForMapXml(context.ClassLoader, Class).GetFieldWrapper(Name, Sig); fw.Link(); ilgen.Emit(OpCodes.Ldflda, fw.GetField()); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { CompilerClassLoader.ExceptionMapEmitter emitter = new CompilerClassLoader.ExceptionMapEmitter(mapping); emitter.Emit(context, ilgen); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { FieldWrapper fw = StaticCompiler.GetClassForMapXml(context.ClassLoader, Class).GetFieldWrapper(Name, Sig); fw.Link(); // we don't use fw.EmitSet because we don't want automatic unboxing and whatever ilgen.Emit(OpCodes.Stsfld, fw.GetField()); }
internal void Generate(CodeGenContext context, CodeEmitter ilgen) { if(invoke != null) { for(int i = 0; i < invoke.Length; i++) { if(invoke[i].LineNumber != -1) { ilgen.SetLineNumber((ushort)invoke[i].LineNumber); } invoke[i].Generate(context, ilgen); } } }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.EmitUnaligned((byte)Alignment); }
internal sealed override void Generate(CodeGenContext context, CodeEmitter ilgen) { Debug.Assert(Name != null); if(Name == ".ctor") { Debug.Assert(Class == null && type != null); Type[] argTypes = context.ClassLoader.ArgTypeListFromSig(Sig); ConstructorInfo ci = StaticCompiler.GetTypeForMapXml(context.ClassLoader, type).GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, CallingConventions.Standard, argTypes, null); if(ci == null) { throw new InvalidOperationException("Missing .ctor: " + type + "..ctor" + Sig); } ilgen.Emit(opcode, ci); } else { Debug.Assert(Class == null ^ type == null); if(Class != null) { Debug.Assert(Sig != null); MethodWrapper method = context.ClassLoader.LoadClassByDottedName(Class).GetMethodWrapper(Name, Sig, false); if(method == null) { throw new InvalidOperationException("method not found: " + Class + "." + Name + Sig); } method.Link(); // TODO this code is part of what Compiler.CastInterfaceArgs (in compiler.cs) does, // it would be nice if we could avoid this duplication... TypeWrapper[] argTypeWrappers = method.GetParameters(); for(int i = 0; i < argTypeWrappers.Length; i++) { if(argTypeWrappers[i].IsGhost) { CodeEmitterLocal[] temps = new CodeEmitterLocal[argTypeWrappers.Length + (method.IsStatic ? 0 : 1)]; for(int j = temps.Length - 1; j >= 0; j--) { TypeWrapper tw; if(method.IsStatic) { tw = argTypeWrappers[j]; } else { if(j == 0) { tw = method.DeclaringType; } else { tw = argTypeWrappers[j - 1]; } } if(tw.IsGhost) { tw.EmitConvStackTypeToSignatureType(ilgen, null); } temps[j] = ilgen.DeclareLocal(tw.TypeAsSignatureType); ilgen.Emit(OpCodes.Stloc, temps[j]); } for(int j = 0; j < temps.Length; j++) { ilgen.Emit(OpCodes.Ldloc, temps[j]); } break; } } if(opcode.Value == OpCodes.Call.Value) { method.EmitCall(ilgen); } else if(opcode.Value == OpCodes.Callvirt.Value) { method.EmitCallvirt(ilgen); } else if(opcode.Value == OpCodes.Newobj.Value) { method.EmitNewobj(ilgen); } else { // ldftn or ldvirtftn ilgen.Emit(opcode, (MethodInfo)method.GetMethod()); } } else { Type[] argTypes; if(Sig.StartsWith("(")) { argTypes = context.ClassLoader.ArgTypeListFromSig(Sig); } else if(Sig == "") { argTypes = Type.EmptyTypes; } else { string[] types = Sig.Split(';'); argTypes = new Type[types.Length]; for(int i = 0; i < types.Length; i++) { argTypes[i] = StaticCompiler.GetTypeForMapXml(context.ClassLoader, types[i]); } } MethodInfo mi = StaticCompiler.GetTypeForMapXml(context.ClassLoader, type).GetMethod(Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, null, argTypes, null); if(mi == null) { throw new InvalidOperationException("Missing method: " + type + "." + Name + Sig); } ilgen.Emit(opcode, mi); } } }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Newarr, context.ClassLoader.FieldTypeWrapperFromSig(Sig, LoadMode.LoadOrThrow).TypeAsArrayType); }
internal sealed override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(opcode); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { if(typeWrapper == null && typeType == null) { Debug.Assert(Class == null ^ type == null); if(Class != null) { typeWrapper = context.ClassLoader.LoadClassByDottedName(Class); } else { typeType = StaticCompiler.GetTypeForMapXml(context.ClassLoader, type); } } }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { base.Generate(context, ilgen); if(typeType != null) { ilgen.Emit(OpCodes.Isinst, typeType); } else { if(typeWrapper.IsGhost || typeWrapper.IsGhostArray) { ilgen.Emit(OpCodes.Dup); // NOTE we pass a null context, but that shouldn't be a problem, because // typeWrapper should never be an UnloadableTypeWrapper typeWrapper.EmitInstanceOf(null, ilgen); CodeEmitterLabel endLabel = ilgen.DefineLabel(); ilgen.Emit(OpCodes.Brtrue_S, endLabel); ilgen.Emit(OpCodes.Pop); ilgen.Emit(OpCodes.Ldnull); ilgen.MarkLabel(endLabel); } else { ilgen.Emit(OpCodes.Isinst, typeWrapper.TypeAsTBD); } } }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Castclass, context.ClassLoader.LoadClassByDottedName(Class).TypeAsBaseType); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { base.Generate(context, ilgen); if(typeType != null) { ilgen.Emit(OpCodes.Castclass, typeType); } else { // NOTE we pass a null context, but that shouldn't be a problem, because // typeWrapper should never be an UnloadableTypeWrapper typeWrapper.EmitCheckcast(null, ilgen); } }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.EmitLdarg(ArgNum); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.Emit(OpCodes.Ldflda, StaticCompiler.GetFieldForMapXml(context.ClassLoader, Class, Name, Sig).GetField()); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { if(typeType == null) { Debug.Assert(type != null); typeType = StaticCompiler.GetTypeForMapXml(context.ClassLoader, type); } ilgen.Emit(opcode, typeType); }
internal override void Generate(CodeGenContext context, CodeEmitter ilgen) { ilgen.EmitLdc_I4(val); }