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)
{
ilgen.Emit(OpCodes.Ldloc, (CodeEmitterLocal)context[Name]);
}
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)
{
ilgen.Emit(OpCodes.Ldstr, Value);
}
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 abstract void Generate(CodeGenContext context, CodeEmitter 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)
{
ilgen.LazyEmitPop();
}
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)
{
context.ClassLoader.LoadClassByDottedName(Class).EmitRunClassConstructor(ilgen);
}
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)
{
CompilerClassLoader.ExceptionMapEmitter emitter = new CompilerClassLoader.ExceptionMapEmitter(mapping);
emitter.Emit(context, ilgen);
}
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 sealed override void Generate(CodeGenContext context, CodeEmitter ilgen)
{
ilgen.Emit(opcode);
}
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.Castclass, context.ClassLoader.LoadClassByDottedName(Class).TypeAsBaseType);
}
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);
}
internal override void Generate(CodeGenContext context, CodeEmitter ilgen)
{
ilgen.Emit(OpCodes.Ldtoken, StaticCompiler.GetType(context.ClassLoader, type));
}
