Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

1226 lines
40 KiB
C#

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
// ***NOTE*** If this code is changed, make corresponding changes in System.Runtime.Serialization.CodeGenerator also
namespace System.ServiceModel.Dispatcher
{
using System;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime;
using System.Security;
using System.ServiceModel.Diagnostics;
[Fx.Tag.SecurityNote(Critical = "Generates IL into an ILGenerator that was created under an Assert."
+ "Generated IL must be correct and must not subvert the type system.")]
#pragma warning disable 618 // have not moved to the v4 security model yet
[SecurityCritical(SecurityCriticalScope.Everything)]
#pragma warning restore 618
internal class CodeGenerator
{
static MethodInfo getTypeFromHandle;
static MethodInfo stringConcat2;
static MethodInfo objectToString;
static MethodInfo boxPointer;
static MethodInfo unboxPointer;
#if USE_REFEMIT
AssemblyBuilder assemblyBuilder;
ModuleBuilder moduleBuilder;
TypeBuilder typeBuilder;
static int typeCounter;
MethodBuilder methodBuilder;
#else
static Module SerializationModule = typeof(CodeGenerator).Module; // Can be replaced by different assembly with SkipVerification set to false
DynamicMethod dynamicMethod;
#if DEBUG
bool allowPrivateMemberAccess;
#endif
#endif
Type delegateType;
ILGenerator ilGen;
ArrayList argList;
Stack blockStack;
Label methodEndLabel;
Hashtable localNames;
int lineNo = 1;
enum CodeGenTrace { None, Save, Tron };
CodeGenTrace codeGenTrace;
internal CodeGenerator()
{
SourceSwitch codeGenSwitch = OperationInvokerTrace.CodeGenerationSwitch;
if ((codeGenSwitch.Level & SourceLevels.Verbose) == SourceLevels.Verbose)
codeGenTrace = CodeGenTrace.Tron;
else if ((codeGenSwitch.Level & SourceLevels.Information) == SourceLevels.Information)
codeGenTrace = CodeGenTrace.Save;
else
codeGenTrace = CodeGenTrace.None;
}
static MethodInfo GetTypeFromHandle
{
get
{
if (getTypeFromHandle == null)
getTypeFromHandle = typeof(Type).GetMethod("GetTypeFromHandle");
return getTypeFromHandle;
}
}
static MethodInfo StringConcat2
{
get
{
if (stringConcat2 == null)
stringConcat2 = typeof(string).GetMethod("Concat", new Type[] { typeof(string), typeof(string) });
return stringConcat2;
}
}
static MethodInfo ObjectToString
{
get
{
if (objectToString == null)
objectToString = typeof(object).GetMethod("ToString", new Type[0]);
return objectToString;
}
}
static MethodInfo BoxPointer
{
get
{
if (boxPointer == null)
boxPointer = typeof(Pointer).GetMethod("Box");
return boxPointer;
}
}
static MethodInfo UnboxPointer
{
get
{
if (unboxPointer == null)
unboxPointer = typeof(Pointer).GetMethod("Unbox");
return unboxPointer;
}
}
internal void BeginMethod(string methodName, Type delegateType, bool allowPrivateMemberAccess)
{
MethodInfo signature = delegateType.GetMethod("Invoke");
ParameterInfo[] parameters = signature.GetParameters();
Type[] paramTypes = new Type[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
paramTypes[i] = parameters[i].ParameterType;
BeginMethod(signature.ReturnType, methodName, paramTypes, allowPrivateMemberAccess);
this.delegateType = delegateType;
}
void BeginMethod(Type returnType, string methodName, Type[] argTypes, bool allowPrivateMemberAccess)
{
#if USE_REFEMIT
string typeName = "Type" + (typeCounter++);
InitAssemblyBuilder(typeName + "." + methodName);
this.typeBuilder = moduleBuilder.DefineType(typeName, TypeAttributes.Public);
this.methodBuilder = typeBuilder.DefineMethod(methodName, MethodAttributes.Public|MethodAttributes.Static, returnType, argTypes);
this.ilGen = this.methodBuilder.GetILGenerator();
#else
this.dynamicMethod = new DynamicMethod(methodName, returnType, argTypes, SerializationModule, allowPrivateMemberAccess);
this.ilGen = this.dynamicMethod.GetILGenerator();
#if DEBUG
this.allowPrivateMemberAccess = allowPrivateMemberAccess;
#endif
#endif
this.methodEndLabel = ilGen.DefineLabel();
this.blockStack = new Stack();
this.argList = new ArrayList();
for (int i = 0; i < argTypes.Length; i++)
argList.Add(new ArgBuilder(i, argTypes[i]));
if (codeGenTrace != CodeGenTrace.None)
EmitSourceLabel("Begin method " + methodName + " {");
}
internal Delegate EndMethod()
{
MarkLabel(methodEndLabel);
if (codeGenTrace != CodeGenTrace.None)
EmitSourceLabel("} End method");
Ret();
Delegate retVal = null;
#if USE_REFEMIT
Type type = typeBuilder.CreateType();
if (codeGenTrace != CodeGenTrace.None)
assemblyBuilder.Save(assemblyBuilder.GetName().Name+".dll");
MethodInfo method = type.GetMethod(methodBuilder.Name);
retVal = Delegate.CreateDelegate(delegateType, method);
methodBuilder = null;
#else
retVal = dynamicMethod.CreateDelegate(delegateType);
dynamicMethod = null;
#endif
delegateType = null;
ilGen = null;
blockStack = null;
argList = null;
return retVal;
}
internal MethodInfo CurrentMethod
{
get
{
#if USE_REFEMIT
return methodBuilder;
#else
return dynamicMethod;
#endif
}
}
internal ArgBuilder GetArg(int index)
{
return (ArgBuilder)argList[index];
}
internal Type GetVariableType(object var)
{
if (var is ArgBuilder)
return ((ArgBuilder)var).ArgType;
else if (var is LocalBuilder)
return ((LocalBuilder)var).LocalType;
else
return var.GetType();
}
internal LocalBuilder DeclareLocal(Type type, string name)
{
return DeclareLocal(type, name, false);
}
internal LocalBuilder DeclareLocal(Type type, string name, bool isPinned)
{
LocalBuilder local = ilGen.DeclareLocal(type, isPinned);
if (codeGenTrace != CodeGenTrace.None)
{
LocalNames[local] = name;
EmitSourceComment("Declare local '" + name + "' of type " + type);
}
return local;
}
internal void If()
{
InternalIf(false);
}
internal void IfNot()
{
InternalIf(true);
}
internal void Else()
{
IfState ifState = PopIfState();
Br(ifState.EndIf);
MarkLabel(ifState.ElseBegin);
ifState.ElseBegin = ifState.EndIf;
blockStack.Push(ifState);
}
internal void EndIf()
{
IfState ifState = PopIfState();
if (!ifState.ElseBegin.Equals(ifState.EndIf))
MarkLabel(ifState.ElseBegin);
MarkLabel(ifState.EndIf);
}
internal void Call(MethodInfo methodInfo)
{
if (methodInfo.IsVirtual)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Callvirt " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString());
ilGen.Emit(OpCodes.Callvirt, methodInfo);
}
else if (methodInfo.IsStatic)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Static Call " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString());
ilGen.Emit(OpCodes.Call, methodInfo);
}
else
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Call " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString());
ilGen.Emit(OpCodes.Call, methodInfo);
}
}
internal void New(ConstructorInfo constructor)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Newobj " + constructor.ToString() + " on type " + constructor.DeclaringType.ToString());
ilGen.Emit(OpCodes.Newobj, constructor);
}
internal void InitObj(Type valueType)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Initobj " + valueType);
ilGen.Emit(OpCodes.Initobj, valueType);
}
internal void LoadArrayElement(object obj, object arrayIndex)
{
Type objType = GetVariableType(obj).GetElementType();
Load(obj);
Load(arrayIndex);
if (IsStruct(objType))
{
Ldelema(objType);
Ldobj(objType);
}
else
Ldelem(objType);
}
internal void StoreArrayElement(object obj, object arrayIndex, object value)
{
Type objType = GetVariableType(obj).GetElementType();
Load(obj);
Load(arrayIndex);
if (IsStruct(objType))
Ldelema(objType);
Load(value);
ConvertValue(GetVariableType(value), objType);
if (IsStruct(objType))
Stobj(objType);
else
Stelem(objType);
}
static bool IsStruct(Type objType)
{
return objType.IsValueType && !objType.IsPrimitive;
}
internal void Load(object obj)
{
if (obj == null)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldnull");
ilGen.Emit(OpCodes.Ldnull);
}
else if (obj is ArgBuilder)
Ldarg((ArgBuilder)obj);
else if (obj is LocalBuilder)
Ldloc((LocalBuilder)obj);
else
Ldc(obj);
}
internal void Store(object var)
{
if (var is ArgBuilder)
Starg((ArgBuilder)var);
else if (var is LocalBuilder)
Stloc((LocalBuilder)var);
else
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenCanOnlyStoreIntoArgOrLocGot0, var.GetType().FullName)));
}
internal void LoadAddress(object obj)
{
if (obj is ArgBuilder)
LdargAddress((ArgBuilder)obj);
else if (obj is LocalBuilder)
LdlocAddress((LocalBuilder)obj);
else
Load(obj);
}
internal void ConvertAddress(Type source, Type target)
{
InternalConvert(source, target, true);
}
internal void ConvertValue(Type source, Type target)
{
InternalConvert(source, target, false);
}
internal void Castclass(Type target)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Castclass " + target);
ilGen.Emit(OpCodes.Castclass, target);
}
internal void Box(Type type)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Box " + type);
ilGen.Emit(OpCodes.Box, type);
}
internal void Unbox(Type type)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Unbox " + type);
ilGen.Emit(OpCodes.Unbox, type);
}
internal void Ldobj(Type type)
{
OpCode opCode = GetLdindOpCode(Type.GetTypeCode(type));
if (!opCode.Equals(OpCodes.Nop))
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction(opCode.ToString());
ilGen.Emit(opCode);
}
else
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldobj " + type);
ilGen.Emit(OpCodes.Ldobj, type);
}
}
internal void Stobj(Type type)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Stobj " + type);
ilGen.Emit(OpCodes.Stobj, type);
}
internal void Ldtoken(Type t)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldtoken " + t);
ilGen.Emit(OpCodes.Ldtoken, t);
}
internal void Ldc(object o)
{
Type valueType = o.GetType();
if (o is Type)
{
Ldtoken((Type)o);
Call(GetTypeFromHandle);
}
else if (valueType.IsEnum)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceComment("Ldc " + o.GetType() + "." + o);
Ldc(((IConvertible)o).ToType(Enum.GetUnderlyingType(valueType), null));
}
else
{
switch (Type.GetTypeCode(valueType))
{
case TypeCode.Boolean:
Ldc((bool)o);
break;
case TypeCode.Char:
Ldc((int)(char)o);
break;
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
Ldc(((IConvertible)o).ToInt32(CultureInfo.InvariantCulture));
break;
case TypeCode.Int32:
Ldc((int)o);
break;
case TypeCode.UInt32:
Ldc((int)(uint)o);
break;
case TypeCode.String:
Ldstr((string)o);
break;
case TypeCode.UInt64:
case TypeCode.Int64:
case TypeCode.Single:
case TypeCode.Double:
case TypeCode.Object:
case TypeCode.Decimal:
case TypeCode.DateTime:
case TypeCode.Empty:
case TypeCode.DBNull:
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenUnknownConstantType, valueType.FullName)));
}
}
}
internal void Ldc(bool boolVar)
{
if (boolVar)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldc.i4 1");
ilGen.Emit(OpCodes.Ldc_I4_1);
}
else
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldc.i4 0");
ilGen.Emit(OpCodes.Ldc_I4_0);
}
}
internal void Ldc(int intVar)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldc.i4 " + intVar);
switch (intVar)
{
case -1:
ilGen.Emit(OpCodes.Ldc_I4_M1);
break;
case 0:
ilGen.Emit(OpCodes.Ldc_I4_0);
break;
case 1:
ilGen.Emit(OpCodes.Ldc_I4_1);
break;
case 2:
ilGen.Emit(OpCodes.Ldc_I4_2);
break;
case 3:
ilGen.Emit(OpCodes.Ldc_I4_3);
break;
case 4:
ilGen.Emit(OpCodes.Ldc_I4_4);
break;
case 5:
ilGen.Emit(OpCodes.Ldc_I4_5);
break;
case 6:
ilGen.Emit(OpCodes.Ldc_I4_6);
break;
case 7:
ilGen.Emit(OpCodes.Ldc_I4_7);
break;
case 8:
ilGen.Emit(OpCodes.Ldc_I4_8);
break;
default:
ilGen.Emit(OpCodes.Ldc_I4, intVar);
break;
}
}
internal void Ldstr(string strVar)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldstr " + strVar);
ilGen.Emit(OpCodes.Ldstr, strVar);
}
internal void LdlocAddress(LocalBuilder localBuilder)
{
if (localBuilder.LocalType.IsValueType)
Ldloca(localBuilder);
else
Ldloc(localBuilder);
}
internal void Ldloc(LocalBuilder localBuilder)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldloc " + LocalNames[localBuilder]);
ilGen.Emit(OpCodes.Ldloc, localBuilder);
EmitStackTop(localBuilder.LocalType);
}
internal void Stloc(LocalBuilder local)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Stloc " + LocalNames[local]);
EmitStackTop(local.LocalType);
ilGen.Emit(OpCodes.Stloc, local);
}
internal void Ldloc(int slot)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldloc " + slot);
switch (slot)
{
case 0:
ilGen.Emit(OpCodes.Ldloc_0);
break;
case 1:
ilGen.Emit(OpCodes.Ldloc_1);
break;
case 2:
ilGen.Emit(OpCodes.Ldloc_2);
break;
case 3:
ilGen.Emit(OpCodes.Ldloc_3);
break;
default:
if (slot <= 255)
ilGen.Emit(OpCodes.Ldloc_S, slot);
else
ilGen.Emit(OpCodes.Ldloc, slot);
break;
}
}
internal void Stloc(int slot)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Stloc " + slot);
switch (slot)
{
case 0:
ilGen.Emit(OpCodes.Stloc_0);
break;
case 1:
ilGen.Emit(OpCodes.Stloc_1);
break;
case 2:
ilGen.Emit(OpCodes.Stloc_2);
break;
case 3:
ilGen.Emit(OpCodes.Stloc_3);
break;
default:
if (slot <= 255)
ilGen.Emit(OpCodes.Stloc_S, slot);
else
ilGen.Emit(OpCodes.Stloc, slot);
break;
}
}
internal void Ldloca(LocalBuilder localBuilder)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldloca " + LocalNames[localBuilder]);
ilGen.Emit(OpCodes.Ldloca, localBuilder);
EmitStackTop(localBuilder.LocalType);
}
internal void Ldloca(int slot)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldloca " + slot);
if (slot <= 255)
ilGen.Emit(OpCodes.Ldloca_S, slot);
else
ilGen.Emit(OpCodes.Ldloca, slot);
}
internal void LdargAddress(ArgBuilder argBuilder)
{
if (argBuilder.ArgType.IsValueType)
Ldarga(argBuilder);
else
Ldarg(argBuilder);
}
internal void Ldarg(ArgBuilder arg)
{
Ldarg(arg.Index);
}
internal void Starg(ArgBuilder arg)
{
Starg(arg.Index);
}
internal void Ldarg(int slot)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldarg " + slot);
switch (slot)
{
case 0:
ilGen.Emit(OpCodes.Ldarg_0);
break;
case 1:
ilGen.Emit(OpCodes.Ldarg_1);
break;
case 2:
ilGen.Emit(OpCodes.Ldarg_2);
break;
case 3:
ilGen.Emit(OpCodes.Ldarg_3);
break;
default:
if (slot <= 255)
ilGen.Emit(OpCodes.Ldarg_S, slot);
else
ilGen.Emit(OpCodes.Ldarg, slot);
break;
}
}
internal void Starg(int slot)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Starg " + slot);
if (slot <= 255)
ilGen.Emit(OpCodes.Starg_S, slot);
else
ilGen.Emit(OpCodes.Starg, slot);
}
internal void Ldarga(ArgBuilder argBuilder)
{
Ldarga(argBuilder.Index);
}
internal void Ldarga(int slot)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ldarga " + slot);
if (slot <= 255)
ilGen.Emit(OpCodes.Ldarga_S, slot);
else
ilGen.Emit(OpCodes.Ldarga, slot);
}
internal void Ldelem(Type arrayElementType)
{
if (arrayElementType.IsEnum)
{
Ldelem(Enum.GetUnderlyingType(arrayElementType));
}
else
{
OpCode opCode = GetLdelemOpCode(Type.GetTypeCode(arrayElementType));
if (opCode.Equals(OpCodes.Nop))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenArrayTypeIsNotSupported, arrayElementType.FullName)));
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction(opCode.ToString());
ilGen.Emit(opCode);
EmitStackTop(arrayElementType);
}
}
internal void Ldelema(Type arrayElementType)
{
OpCode opCode = OpCodes.Ldelema;
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction(opCode.ToString());
ilGen.Emit(opCode, arrayElementType);
EmitStackTop(arrayElementType);
}
internal void Stelem(Type arrayElementType)
{
if (arrayElementType.IsEnum)
Stelem(Enum.GetUnderlyingType(arrayElementType));
else
{
OpCode opCode = GetStelemOpCode(Type.GetTypeCode(arrayElementType));
if (opCode.Equals(OpCodes.Nop))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenArrayTypeIsNotSupported, arrayElementType.FullName)));
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction(opCode.ToString());
EmitStackTop(arrayElementType);
ilGen.Emit(opCode);
}
}
internal Label DefineLabel()
{
return ilGen.DefineLabel();
}
internal void MarkLabel(Label label)
{
ilGen.MarkLabel(label);
if (codeGenTrace != CodeGenTrace.None)
EmitSourceLabel(label.GetHashCode() + ":");
}
internal void Ret()
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Ret");
ilGen.Emit(OpCodes.Ret);
}
internal void Br(Label label)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Br " + label.GetHashCode());
ilGen.Emit(OpCodes.Br, label);
}
internal void Brfalse(Label label)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Brfalse " + label.GetHashCode());
ilGen.Emit(OpCodes.Brfalse, label);
}
internal void Brtrue(Label label)
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Brtrue " + label.GetHashCode());
ilGen.Emit(OpCodes.Brtrue, label);
}
internal void Pop()
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Pop");
ilGen.Emit(OpCodes.Pop);
}
internal void Dup()
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction("Dup");
ilGen.Emit(OpCodes.Dup);
}
void InternalIf(bool negate)
{
IfState ifState = new IfState();
ifState.EndIf = DefineLabel();
ifState.ElseBegin = DefineLabel();
if (negate)
Brtrue(ifState.ElseBegin);
else
Brfalse(ifState.ElseBegin);
blockStack.Push(ifState);
}
void InternalConvert(Type source, Type target, bool isAddress)
{
if (target == source)
return;
if (target.IsValueType)
{
if (source.IsValueType)
{
OpCode opCode = GetConvOpCode(Type.GetTypeCode(target));
if (opCode.Equals(OpCodes.Nop))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenNoConversionPossibleTo, target.FullName)));
else
{
if (codeGenTrace != CodeGenTrace.None)
EmitSourceInstruction(opCode.ToString());
ilGen.Emit(opCode);
}
}
else if (source.IsAssignableFrom(target))
{
Unbox(target);
if (!isAddress)
Ldobj(target);
}
else
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenIsNotAssignableFrom, target.FullName, source.FullName)));
}
else if (target.IsPointer)
{
Call(UnboxPointer);
}
else if (source.IsPointer)
{
Load(source);
Call(BoxPointer);
}
else if (target.IsAssignableFrom(source))
{
if (source.IsValueType)
{
if (isAddress)
Ldobj(source);
Box(source);
}
}
else if (source.IsAssignableFrom(target))
{
//assert(source.IsValueType == false);
Castclass(target);
}
else if (target.IsInterface || source.IsInterface)
{
Castclass(target);
}
else
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenIsNotAssignableFrom, target.FullName, source.FullName)));
}
IfState PopIfState()
{
object stackTop = blockStack.Pop();
IfState ifState = stackTop as IfState;
if (ifState == null)
ThrowMismatchException(stackTop);
return ifState;
}
#if USE_REFEMIT
void InitAssemblyBuilder(string methodName)
{
//if (assemblyBuilder == null) {
AssemblyName name = new AssemblyName();
name.Name = "Microsoft.GeneratedCode."+methodName;
bool saveAssembly = false;
if (codeGenTrace != CodeGenTrace.None)
saveAssembly = true;
if (saveAssembly)
{
assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.RunAndSave);
moduleBuilder = assemblyBuilder.DefineDynamicModule(name.Name, name.Name + ".dll", false);
}
else
{
assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
moduleBuilder = assemblyBuilder.DefineDynamicModule(name.Name, false);
}
//}
}
#endif
void ThrowMismatchException(object expected)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenExpectingEnd, expected.ToString())));
}
Hashtable LocalNames
{
get
{
if (localNames == null)
localNames = new Hashtable();
return localNames;
}
}
OpCode GetConvOpCode(TypeCode typeCode)
{
switch (typeCode)
{
case TypeCode.Boolean:
return OpCodes.Conv_I1; // TypeCode.Boolean:
case TypeCode.Char:
return OpCodes.Conv_I2; // TypeCode.Char:
case TypeCode.SByte:
return OpCodes.Conv_I1; // TypeCode.SByte:
case TypeCode.Byte:
return OpCodes.Conv_U1; // TypeCode.Byte:
case TypeCode.Int16:
return OpCodes.Conv_I2; // TypeCode.Int16:
case TypeCode.UInt16:
return OpCodes.Conv_U2; // TypeCode.UInt16:
case TypeCode.Int32:
return OpCodes.Conv_I4; // TypeCode.Int32:
case TypeCode.UInt32:
return OpCodes.Conv_U4; // TypeCode.UInt32:
case TypeCode.Int64:
return OpCodes.Conv_I8; // TypeCode.Int64:
case TypeCode.UInt64:
return OpCodes.Conv_I8; // TypeCode.UInt64:
case TypeCode.Single:
return OpCodes.Conv_R4; // TypeCode.Single:
case TypeCode.Double:
return OpCodes.Conv_R8; // TypeCode.Double:
default:
return OpCodes.Nop;
}
}
OpCode GetLdindOpCode(TypeCode typeCode)
{
switch (typeCode)
{
case TypeCode.Boolean:
return OpCodes.Ldind_I1; // TypeCode.Boolean:
case TypeCode.Char:
return OpCodes.Ldind_I2; // TypeCode.Char:
case TypeCode.SByte:
return OpCodes.Ldind_I1; // TypeCode.SByte:
case TypeCode.Byte:
return OpCodes.Ldind_U1; // TypeCode.Byte:
case TypeCode.Int16:
return OpCodes.Ldind_I2; // TypeCode.Int16:
case TypeCode.UInt16:
return OpCodes.Ldind_U2; // TypeCode.UInt16:
case TypeCode.Int32:
return OpCodes.Ldind_I4; // TypeCode.Int32:
case TypeCode.UInt32:
return OpCodes.Ldind_U4; // TypeCode.UInt32:
case TypeCode.Int64:
return OpCodes.Ldind_I8; // TypeCode.Int64:
case TypeCode.UInt64:
return OpCodes.Ldind_I8; // TypeCode.UInt64:
case TypeCode.Single:
return OpCodes.Ldind_R4; // TypeCode.Single:
case TypeCode.Double:
return OpCodes.Ldind_R8; // TypeCode.Double:
case TypeCode.String:
return OpCodes.Ldind_Ref; // TypeCode.String:
default:
return OpCodes.Nop;
}
//
}
OpCode GetLdelemOpCode(TypeCode typeCode)
{
switch (typeCode)
{
case TypeCode.Object:
return OpCodes.Ldelem_Ref; // TypeCode.Object:
case TypeCode.Boolean:
return OpCodes.Ldelem_I1; // TypeCode.Boolean:
case TypeCode.Char:
return OpCodes.Ldelem_I2; // TypeCode.Char:
case TypeCode.SByte:
return OpCodes.Ldelem_I1; // TypeCode.SByte:
case TypeCode.Byte:
return OpCodes.Ldelem_U1; // TypeCode.Byte:
case TypeCode.Int16:
return OpCodes.Ldelem_I2; // TypeCode.Int16:
case TypeCode.UInt16:
return OpCodes.Ldelem_U2; // TypeCode.UInt16:
case TypeCode.Int32:
return OpCodes.Ldelem_I4; // TypeCode.Int32:
case TypeCode.UInt32:
return OpCodes.Ldelem_U4; // TypeCode.UInt32:
case TypeCode.Int64:
return OpCodes.Ldelem_I8; // TypeCode.Int64:
case TypeCode.UInt64:
return OpCodes.Ldelem_I8; // TypeCode.UInt64:
case TypeCode.Single:
return OpCodes.Ldelem_R4; // TypeCode.Single:
case TypeCode.Double:
return OpCodes.Ldelem_R8; // TypeCode.Double:
case TypeCode.String:
return OpCodes.Ldelem_Ref; // TypeCode.String:
default:
return OpCodes.Nop;
}
}
OpCode GetStelemOpCode(TypeCode typeCode)
{
switch (typeCode)
{
case TypeCode.Object:
return OpCodes.Stelem_Ref; // TypeCode.Object:
case TypeCode.Boolean:
return OpCodes.Stelem_I1; // TypeCode.Boolean:
case TypeCode.Char:
return OpCodes.Stelem_I2; // TypeCode.Char:
case TypeCode.SByte:
return OpCodes.Stelem_I1; // TypeCode.SByte:
case TypeCode.Byte:
return OpCodes.Stelem_I1; // TypeCode.Byte:
case TypeCode.Int16:
return OpCodes.Stelem_I2; // TypeCode.Int16:
case TypeCode.UInt16:
return OpCodes.Stelem_I2; // TypeCode.UInt16:
case TypeCode.Int32:
return OpCodes.Stelem_I4; // TypeCode.Int32:
case TypeCode.UInt32:
return OpCodes.Stelem_I4; // TypeCode.UInt32:
case TypeCode.Int64:
return OpCodes.Stelem_I8; // TypeCode.Int64:
case TypeCode.UInt64:
return OpCodes.Stelem_I8; // TypeCode.UInt64:
case TypeCode.Single:
return OpCodes.Stelem_R4; // TypeCode.Single:
case TypeCode.Double:
return OpCodes.Stelem_R8; // TypeCode.Double:
case TypeCode.String:
return OpCodes.Stelem_Ref; // TypeCode.String:
default:
return OpCodes.Nop;
}
}
internal void EmitSourceInstruction(string line)
{
EmitSourceLine(" " + line);
}
internal void EmitSourceLabel(string line)
{
EmitSourceLine(line);
}
internal void EmitSourceComment(string comment)
{
EmitSourceInstruction("// " + comment);
}
internal void EmitSourceLine(string line)
{
if (codeGenTrace != CodeGenTrace.None)
OperationInvokerTrace.WriteInstruction(lineNo++, line);
if (ilGen != null && codeGenTrace == CodeGenTrace.Tron)
{
ilGen.Emit(OpCodes.Ldstr, string.Format(CultureInfo.InvariantCulture, "{0:00000}: {1}", lineNo - 1, line));
ilGen.Emit(OpCodes.Call, OperationInvokerTrace.TraceInstructionMethod);
}
}
internal void EmitStackTop(Type stackTopType)
{
if (codeGenTrace != CodeGenTrace.Tron)
return;
codeGenTrace = CodeGenTrace.None;
Dup();
ToString(stackTopType);
LocalBuilder topValue = DeclareLocal(typeof(string), "topValue");
Store(topValue);
Load("//value = ");
Load(topValue);
Concat2();
Call(OperationInvokerTrace.TraceInstructionMethod);
codeGenTrace = CodeGenTrace.Tron;
}
internal void ToString(Type type)
{
if (type.IsValueType)
{
Box(type);
Call(ObjectToString);
}
else
{
Dup();
IfNot();
Pop();
Load("<null>");
Else();
Call(ObjectToString);
EndIf();
}
}
internal void Concat2()
{
Call(StringConcat2);
}
internal void LoadZeroValueIntoLocal(Type type, LocalBuilder local)
{
if (type.IsValueType)
{
switch (Type.GetTypeCode(type))
{
case TypeCode.Boolean:
case TypeCode.Char:
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
case TypeCode.UInt32:
ilGen.Emit(OpCodes.Ldc_I4_0);
Store(local);
break;
case TypeCode.Int64:
case TypeCode.UInt64:
ilGen.Emit(OpCodes.Ldc_I4_0);
ilGen.Emit(OpCodes.Conv_I8);
Store(local);
break;
case TypeCode.Single:
ilGen.Emit(OpCodes.Ldc_R4, 0.0F);
Store(local);
break;
case TypeCode.Double:
ilGen.Emit(OpCodes.Ldc_R8, 0.0);
Store(local);
break;
case TypeCode.Decimal:
case TypeCode.DateTime:
default:
LoadAddress(local);
InitObj(type);
break;
}
}
else
{
Load(null);
Store(local);
}
}
}
internal class ArgBuilder
{
internal int Index;
internal Type ArgType;
internal ArgBuilder(int index, Type argType)
{
this.Index = index;
this.ArgType = argType;
}
}
internal class IfState
{
Label elseBegin;
Label endIf;
internal Label EndIf
{
get
{
return this.endIf;
}
set
{
this.endIf = value;
}
}
internal Label ElseBegin
{
get
{
return this.elseBegin;
}
set
{
this.elseBegin = value;
}
}
}
}