| public DefineNestedType ( string name ) : System.Reflection.Emit.TypeBuilder | ||
| name | string | |
| return | System.Reflection.Emit.TypeBuilder | |
public System.Type DeclareEnum(TypeBuilder module, string name, IEnumerable<string> values)
{
var enumType = module.DefineNestedType(name, TypeAttributes.NestedPublic | TypeAttributes.Sealed, typeof(Enum));
enumType.DefineField("value__", typeof(int), FieldAttributes.Private | FieldAttributes.SpecialName);
var i = 0;
foreach (var value in values)
{
FieldBuilder field = enumType.DefineField(value.ToString(), enumType, FieldAttributes.Public | FieldAttributes.Literal | FieldAttributes.Static);
field.SetConstant(i++);
}
return enumType.CreateType();
}
private TypeBuilder DefineType(Cci.INamedTypeDefinition typeDef, TypeBuilder containingTypeBuilder)
{
Debug.Assert(!_typeBuilders.ContainsKey(typeDef));
TypeBuilder typeBuilder;
string mangledName = Cci.MetadataWriter.GetMangledName(typeDef);
TypeAttributes attrs = (TypeAttributes)Cci.MetadataWriter.GetTypeDefFlags(typeDef, _context);
if (containingTypeBuilder != null)
{
typeBuilder = containingTypeBuilder.DefineNestedType(mangledName, attrs, null, (PackingSize)typeDef.Alignment, (int)typeDef.SizeOf);
}
else
{
var namespaceType = (Cci.INamespaceTypeDefinition)typeDef;
typeBuilder = _builder.DefineType(
MetadataHelpers.BuildQualifiedName(namespaceType.NamespaceName, mangledName),
attrs,
null, // parent set later
(PackingSize)typeDef.Alignment,
(int)typeDef.SizeOf
);
}
// generic parameters:
// We need to define generic parameters so that type references that target them can be resolved later on:
var typeParameters = GetConsolidatedTypeParameters(typeDef);
if (typeParameters != null)
{
DefineGenericParameters(typeBuilder, null, typeParameters);
}
_typeBuilders.Add(typeDef, typeBuilder);
return typeBuilder;
}
/// <summary>
/// Crea una clase que representara a esta funcion
/// Este metodo debe ser llamado antes de llamar al GenerateCode
/// </summary>
/// <param name="typeBuilder"></param>
public void CreateCallableClass(TypeBuilder typeBuilder)
{
//Las funciones debemos declararlas en un scope anidado, es decir, que sea una clase anidada
//Guardamos la funcion que definimos en la informacion de este callable
Callable.ILCallable = typeBuilder.DefineNestedType(Callable.GetName(), TypeAttributes.NestedPublic | TypeAttributes.Class);
//Como estamos definiendo un nuevo scope, y a veces sera necesario subir hacia los scopes padres, es necesario recibir una instancia del scope anterior
ParentInstance = Callable.ILCallable.DefineField(NamesGenerator.GenerateNewName(), typeBuilder,
FieldAttributes.Public);
//El constructor recibira tantos parametros como reciba la funcion
//Para poder generar el constructor, definimos primeramente los campos que almacenara esta clase (los parametros)
Callable.FieldsInClass = new Dictionary<string, FieldBuilder>(); //Donde guardaremos los campos definidos en esta clase asociados a esta funcion
//Lista de tipos que recibira el constructor
IList<Type> realTypesOfParameters = new List<Type>();
//Lo primero que recibe es la instancia del padre
realTypesOfParameters.Add(typeBuilder);
foreach (var field in Callable.Fields) {
//Cogemos el tipo del parametro actual. No era necesario hacerlo desde el chequeo semantico pues aqui tenemos el Scope por ser un IScopeDefiner
var type = Scope.GetType(field.TypeId).GetILType();
realTypesOfParameters.Add(type); //Anadimos el tipo (en C#) de este parametro para pasarselo al constructor (el Type[] que recibe)
//Creamos el campo en la clase
string name = NamesGenerator.GenerateNewName(); //Nombre del campo
var fieldBuilder = Callable.ILCallable.DefineField(name, type, FieldAttributes.Public); //Tipo del campo
Callable.FieldsInClass.Add(name, fieldBuilder);
}
//Ahora creamos el constructor, de forma similar a como hicimos con el RecordDeclarationNode
ConstructorBuilder constructor = Callable.ILCallable.DefineConstructor(MethodAttributes.Public,
CallingConventions.Standard,
realTypesOfParameters.ToArray());
//Guardamos el constructor en la informacion de este callable para cuando se vaya a instanciar
//Y ademas para cuando se ejecute el metodo CheckSemantic de este mismo nodo
Callable.Constructor = constructor;
//Creamos el cuerpo de la funcion (un metodo en esta clase)
//El metodo sera publico y no estatico
//Le asignamos el tipo de retorno que retorna esta funcion en caso de que no sea un procedimiento
var returnType = Callable.Type == null ? typeof (void) : Scope.GetType(Callable.Type).GetILType();
var methodBuilder = Callable.ILCallable.DefineMethod("Run", MethodAttributes.Public, //TODO: HideBySig?
returnType, new Type[0]);
//Asignamos el metodo principal de esta funcion a la informacion de la funcion
Callable.Method = methodBuilder;
}
public override void GenerateCode(ILGenerator generator, TypeBuilder typeBuilder)
{
//Creamos la clase correspondiente a este Let, pues la expresion Let-In-End define un nuevo scope
var letTypeBuilder = typeBuilder.DefineNestedType(NamesGenerator.GenerateNewName(), TypeAttributes.NestedPublic | TypeAttributes.Class);
#region Constructor
//Creamos el constructor de la clase, que recibe un parametro del padre
var constructor = letTypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard,
new Type[] {typeBuilder});
//Definimos los dos campos iniciales que tendra la clase
//Break (Int32) -> Flag que indica si se tiene que romper romper el flujo de la ejecucion o no. Se le da valor desde un hijo (Break u otro Let-In-End)
BreakField = letTypeBuilder.DefineField("Break", typeof (int), FieldAttributes.Public);
//ParentInstance (Tipo del padre) -> Referencia a la clase padre
ParentInstance = letTypeBuilder.DefineField("Parent", typeBuilder, FieldAttributes.Public);
//Anadimos el codigo necesario en el constructor
var genConstructor = constructor.GetILGenerator();
//Le asignamos a ParentInstance la instancia de mi padre que me pasaron en el constructor
genConstructor.Emit(OpCodes.Ldarg_0); //Cargamos 'this'
genConstructor.Emit(OpCodes.Ldarg_1); //Cargamos el parametro del constructor (mi padre)
genConstructor.Emit(OpCodes.Stfld, ParentInstance); //Cargamos el parametro del constructor (mi padre)
//Le asignamos el valor '0' al campo 'Break'
genConstructor.Emit(OpCodes.Ldarg_0); //Cargamos 'this'
genConstructor.Emit(OpCodes.Ldc_I4, 0); //Metemos en la pila un '0'
genConstructor.Emit(OpCodes.Stfld, BreakField); //Le asignamos el '0' al campo 'Break' de esta clase
//Generamos todas las declaraciones ya aqui en el constructor (para que los campos sean asignados a la clase antes de ejecutar el cuerpo del Let)
foreach (var group in GroupedDeclarations) {
//Generamos las declaraciones usando el generador del constructor, y se guardaran en la clase ya creada para este Let
GenerateCodeOfDeclarations(group, genConstructor, letTypeBuilder);
}
//Terminamos el constructor
genConstructor.Emit(OpCodes.Ret);
#endregion
//El tipo de retorno del metodo que crearemos depende del tipo de retorno de esta expresion Let-In-End
//Si no retorna nada, el metodo es Void. Sino, el metodo retorna el tipo de retorno de la expresion
var methodReturnType = ReturnType == null ? typeof(void) : ReturnType.GetILType();
//Creamos el metodo principal donde se ejecutara el cuerpo de este Let. No recibe parametros
var runMethodBuilder = letTypeBuilder.DefineMethod("Run", MethodAttributes.Public, CallingConventions.HasThis,
methodReturnType, new Type[0]);
var runGenerator = runMethodBuilder.GetILGenerator();
//Etiqueta para donde se saltara en caso de que se interrumpa el flujo de ejecucion
LabelEnd = runGenerator.DefineLabel();
//Generamos el codigo de la secuencia de expresiones dentro del metodo, y dentro de la clase que creamos para el Let (logico)
Expressions.GenerateCode(runGenerator, letTypeBuilder);
//Aqui almacenaremos el valor de retorno del Let (si retorna)
// LocalBuilder resultLocal = null;
//Si la secuencia de expresiones retorna algun valor
// if (ReturnType != null) {
//Creamos la variable donde guardaremos el valor
// resultLocal = runGenerator.DeclareLocal(ReturnType.GetILType());
//Asignamos el valor
// runGenerator.Emit(OpCodes.Stloc, resultLocal);
// }
//Ponemos aqui la etiqueta 'END'
runGenerator.MarkLabel(LabelEnd);
//Aqui comprobamos si me mandaron a interrumpir el flujo de ejecucion o no...
//Etiqueta a donde se saltara en caso de que no haga falta interrumpir la ejecucion
Label lblNoBreak = runGenerator.DefineLabel();
//Lo siguiente lo tenemos que hacer si alguna expresion de las que se ejecuto anteriormente tenia un 'Break'
if (Common.Common.BreakFound) {
//Comprobamos si 'Break == 0'
// Ver si hace falta terminar la ejecucion del padre.
runGenerator.Emit(OpCodes.Ldarg_0); //Cargamos 'this'
runGenerator.Emit(OpCodes.Ldfld, BreakField); //Cargamos el campo 'Break' de la clase del Let
runGenerator.Emit(OpCodes.Ldc_I4_0); //Anadimos el 0
runGenerator.Emit(OpCodes.Beq, lblNoBreak);
//Si Break == 0, entonces no hace falta terminar. Saltar para NO_BREAK
//Si hace falta terminar la ejecicion
//Le asignamos el valor '0' al campo Break de esta clase
runGenerator.Emit(OpCodes.Ldarg_0);
runGenerator.Emit(OpCodes.Ldc_I4_0);
runGenerator.Emit(OpCodes.Stfld, BreakField);
//Ahora, vamos subiendo por los ParentInstance hasta llegar a uno que sea IBreakable (For, While o Let)
//Garantizamos que siempre lleguemos, pues tambien lo chequeamos en la semantica del nodo Break.
var expression = Parent;
//Mientras no lleguemos a un nodo IBreakable
while (!(expression is IBreakable)) {
expression = expression.Parent;
}
//Ya tenemos en 'expression' al IScopeDefiner padre. Lo que tenemos que hacer es poner su campo 'Break' en 1
runGenerator.Emit(OpCodes.Ldarg_0); //Cargamos 'this'
runGenerator.Emit(OpCodes.Ldfld, ParentInstance); //Metemos en la pila la referencia a ParentInstance
runGenerator.Emit(OpCodes.Ldc_I4, 0); //Metemos en la pila el valor '1' que le asignaremos
runGenerator.Emit(OpCodes.Stfld, ((IBreakable) expression).BreakField); //Hacemos la asignacion
}
//Terminamos el metodo principal
runGenerator.Emit(OpCodes.Ret);
//Creamos la clase que definimos para que pueda ser usada
letTypeBuilder.CreateType();
//Ahora, FUERA DE LA CLASE 'LET', instanciamos la clase Let que creamos, y llamamos al metodo principal!
generator.Emit(OpCodes.Ldarg_0); //El constructor recibe como 1er argumento la instancia 'this'
generator.Emit(OpCodes.Newobj, constructor); //Llamamos al constructor (y pone la referencia al nuevo tipo creado en la pila)
generator.Emit(OpCodes.Callvirt, runMethodBuilder); //Llamamos al metodo principal
//De la forma que lo diseñe, el valor de retorno (si hay) quedara en el tope de la pila
}
/// <summary>
/// Defines a nested type given its name..
/// </summary>
/// <param name="name">The short name of the type.</param>
/// <returns>Returns the created <see cref="TypeBuilderHelper"/>.</returns>
/// <seealso cref="System.Reflection.Emit.TypeBuilder.DefineNestedType(string)">
/// TypeBuilder.DefineNestedType Method</seealso>
public TypeBuilderHelper DefineNestedType(string name)
{
return(new TypeBuilderHelper(_assembly, _typeBuilder.DefineNestedType(name)));
}
protected Type GrabType(Type Copy, TypeBuilder On)
{
if (Copy == null) return null;
if (TypesDone.ContainsKey(Copy))
return TypesDone[Copy];
if (!Sources.Contains(Copy.Module))
return TypeReplaceGenerics(Copy);
if (Copy.IsByRef)
return GrabType(Copy.GetElementType()).MakeByRefType();
if (Copy.IsArray)
return GrabType(Copy.GetElementType()).MakeArrayType();
if (On == null)
On = GrabType(Copy.DeclaringType) as TypeBuilder;
var OurInterfaces = new List<Type>();
Type[] Interfaces;
if (!Copy.IsEnum)
{
// To not specify an interface implementation if one of the parent types
// already implements one of the interfaces returned by GetInterfaces.
foreach (Type T in Copy.GetInterfaces())
{
if (!T.IsAssignableFrom(Copy.BaseType))
OurInterfaces.Add(T);
}
Interfaces = OurInterfaces.ToArray();
}
else Interfaces = null;
TypeBuilder Ret;
if (On == null) Ret = Module.DefineType(Copy.Name, Copy.Attributes, GrabType(Copy.BaseType), Interfaces);
else Ret = On.DefineNestedType(Copy.Name, Copy.Attributes, GrabType(Copy.BaseType), Interfaces);
TypesDone.Add(Copy, Ret);
// We need to copy over the static constructor explicitly, because it is never called in the IL
ConstructorInfo StaticConstr = FindStaticConstructor(Copy);
if (StaticConstr != null)
GrabConstructor(StaticConstr, Ret);
// Enum fields need to be copied over on .NET to avoid a TypeLoadException
// Interestingly, enum types without fields are perfectly fine with mono.
if (Copy.IsEnum)
{
GrabField(Copy.GetField("value__"), Ret);
foreach (FieldInfo Field in Copy.GetFields(BindingFlags.Public | BindingFlags.Static))
{
if (Field.DeclaringType != Copy) continue;
GrabField(Field);
}
}
// - If we are copying over a delegate, we need to guarantee that all members are copied over,
// if not we'll cause a runtime error somewhere along the pipeline (for example: mono fails
// on an assertion).
// - If we are copying over a class with an abstract parent, we need to copy over all methods
// to prevent a TypeLoadException at runtime (non-abstract types containing methods without
// a body cause this)
// Delegates have a native-code constructor that is needed, too
if (Copy.BaseType == typeof(MulticastDelegate))
{
ConstructorInfo NativeCtor = Copy.GetConstructors()[0];
GrabConstructor(NativeCtor, Ret);
GrabMethod(Copy.GetMethod("Invoke"), Ret);
GrabMethod(Copy.GetMethod("BeginInvoke"), Ret);
GrabMethod(Copy.GetMethod("EndInvoke"), Ret);
}
else if (Copy.IsExplicitLayout || Copy.BaseType.IsAbstract || OurInterfaces.Count > 0)
{
foreach (MethodInfo Method in Copy.GetMethods())
{
if (Method.DeclaringType != Copy) continue;
GrabMethod(Method, Ret);
}
foreach (MethodInfo Method in Copy.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance))
{
if (Method.DeclaringType != Copy) continue;
GrabMethod(Method, Ret);
}
foreach (FieldInfo Field in Copy.GetFields(BindingFlags.Instance | BindingFlags.NonPublic))
{
if (Field.DeclaringType != Copy) continue;
GrabField(Field, Ret);
}
}
if (Copy.IsEnum || Copy.BaseType == typeof(MulticastDelegate))
Ret.CreateType();
return Ret;
}
private void DeserializeNested(TypeBuilder tb)
{
PushState();
DeserializeCore(
tb.DefineNestedType(
Name(m_br.ReadString()),
(TypeAttributes)m_br.ReadUInt32(),
ReadType()));
PopState();
}
public static TypeBuilder DefineNestedDelegate (TypeBuilder typeBuilder, String delegateName, Type returnType, Type[] parameterTypes, String[] parameterNames, out ConstructorBuilder constructorBuilder)
{
// Parameter types for BeginInvoker are: parameterTypes + AsyncCallback + Object
Type[] beginInvokeParameterTypes = ArrayHelper.Append (parameterTypes, typeof(AsyncCallback), typeof(Object));
// Put names on parameters to ease debugging
String[] beginInvokeParameterNames = new String[beginInvokeParameterTypes.Length];
Array.Copy (parameterNames, beginInvokeParameterNames, parameterNames.Length);
beginInvokeParameterNames [parameterTypes.Length] = "callback";
beginInvokeParameterNames [parameterTypes.Length + 1] = "object";
// Create the nested type
TypeBuilder delegateBuilder = typeBuilder.DefineNestedType (delegateName, EmitConstants.PUBLIC_NESTED_TYPE, typeof(MulticastDelegate));
constructorBuilder = DefineConstructor (delegateBuilder, MethodImplAttributes.Runtime, new[] {
typeof(Object),
typeof(IntPtr)
}, new[] {
"object",
"method"
});
DefineOverrideMethod (delegateBuilder, MethodImplAttributes.Runtime, "Invoke", returnType, parameterTypes, parameterNames);
DefineOverrideMethod (delegateBuilder, MethodImplAttributes.Runtime, "BeginInvoke", typeof(IAsyncResult), beginInvokeParameterTypes, beginInvokeParameterNames);
DefineOverrideMethod (delegateBuilder, MethodImplAttributes.Runtime, "EndInvoke", returnType, new[] {typeof(IAsyncResult)}, new[] {"result"});
return delegateBuilder;
}
/*private class RefsAndArraysBuilderEx : RefsAndArraysBuilder
{
private MetaDataMapper mapper;
public RefsAndArraysBuilderEx(MetaDataMapper mapper)
{
this.mapper = mapper;
}
public override Type BuildRefType(Type type)
{
return( mapper.Map(TypeEx.BuildRefType(type)) );
}
public override Type BuildArrayType(Type type)
{
return( mapper.Map(TypeEx.BuildArrayType(type)) );
}
}*/
private static Type GetOrBuild(TypeBuilder cilpe, ArrayList list, int i)
{
if(list.Count > i)
return(list[i] as Type);
if(list.Count == i)
{
string name = "$CILPE$PseudoParameter_" + i;
TypeBuilder type = cilpe.DefineNestedType(name, TypeAttributes.NestedAssembly | TypeAttributes.Class);
list.Add(type);
return(type);
}
throw new ExportException();
}
public ASTNodeVisitor_JITCompiler(TypeBuilder parentTypeBuilder, ASTNode_Lambda node)
{
mLambdaNode = node;
TypeBuilder = parentTypeBuilder.DefineNestedType(JITInterpreter_DS2.Instance().GenernateUniqueString("closure"), TypeAttributes.NestedPublic);
ConstructorBuilder = TypeBuilder.DefineDefaultConstructor(MethodAttributes.Public);
FieldBuilders = new Dictionary<FreeAddress, FieldBuilder>();
foreach (var address in mLambdaNode.GetFreeAddresses()) {
FieldBuilders[address] = TypeBuilder.DefineField(address.ToString(), typeof(SharedValue), FieldAttributes.Public);
}
if (HasThisArgument()) {
MethodBuilder = TypeBuilder.DefineMethod(
"Invoke",
MethodAttributes.Public,
CallingConventions.HasThis,
typeof(object),
Enumerable.Repeat(typeof(object), mLambdaNode.formalCount).ToArray());
} else {
MethodBuilder = TypeBuilder.DefineMethod(
"Invoke",
MethodAttributes.Static | MethodAttributes.Public,
CallingConventions.Standard,
typeof(object),
Enumerable.Repeat(typeof(object), mLambdaNode.formalCount).ToArray());
}
mILGenerator = MethodBuilder.GetILGenerator();
DeclareLocals();
mTaillCallFlags.Push(true);
mLambdaNode.bodyNode.AcceptVisitor(this);
mTaillCallFlags.Pop();
mILGenerator.Emit(OpCodes.Ret);
TypeBuilder.CreateType();
}
public Class(Assembly asm, string ns, string name, bool pub, TypeBuilder parent)
{
Name = name;
if (parent != null)
{
FullName = name;
Access = pub ? TypeAttributes.NestedPublic : TypeAttributes.NestedPrivate;
TypeBuilder = parent.DefineNestedType(FullName, Access);
}
else
{
FullName = ns + "." + name;
Access = pub ? TypeAttributes.Public : TypeAttributes.NotPublic;
TypeBuilder = asm.ModuleBuilder.DefineType(FullName, Access);
}
}
protected static void ParseClass(XElement el, TypeBuilder parentType = null)
{
string ClassName = el.Attribute("Name").Value;
string Namespace = "";
if (el.Attribute("Namespace") != null)
Namespace = el.Attribute("Namespace").Value;
if (Namespace.Length > 0 && !Namespace.EndsWith("."))
Namespace += ".";
TypeBuilder newType = null;
if (parentType != null)
{
try
{
newType = parentType.DefineNestedType(ClassName, TypeAttributes.NestedPublic | TypeAttributes.Class);
}
catch (Exception e)
{
System.Console.WriteLine(e.ToString());
}
}
else
{
newType = moduleBuilder.DefineType(Namespace + ClassName, TypeAttributes.Public | TypeAttributes.Class);
}
Type baseType = null;
if (el.Attribute("Base") != null)
{
baseType = GetType(el.Attribute("Base").Value);
}
if (baseType == null)
baseType = typeof(ModAPI.Data.Models.BaseXMLProvider);
newType.SetParent(baseType);
Debug.Log("DynamicTypes", "Parsing dynamic type \"" + newType.FullName + "\".");
BuildingTypes.Add(newType.FullName, newType);
foreach (XElement subClass in el.Elements("Class"))
{
ParseClass(subClass, newType);
}
foreach (XElement propertyEl in el.Elements("Property"))
{
string propertyName = propertyEl.Attribute("Name").Value;
string typeName = propertyEl.Attribute("Type").Value;
Type propertyType = GetType(typeName);
if (!ParseProperty(newType, propertyType, typeName, propertyName))
{
if (!typeWaiting.ContainsKey(newType.FullName))
typeWaiting.Add(newType.FullName, 0);
typeWaiting[newType.FullName]++;
}
}
foreach (XElement fieldEl in el.Elements("Field"))
{
string fieldName = fieldEl.Attribute("Name").Value;
string typeName = fieldEl.Attribute("Type").Value;
Type fieldType = GetType(typeName);
if (!ParseField(newType, fieldType, typeName, fieldName))
{
if (!typeWaiting.ContainsKey(newType.FullName))
typeWaiting.Add(newType.FullName, 0);
typeWaiting[newType.FullName]++;
}
}
if (!typeWaiting.ContainsKey(newType.FullName))
{
TypeComplete(newType);
}
else
{
Debug.Log("DynamicTypes", "Dynamic type \"" + newType.FullName + "\" is waiting for completion.");
}
}
public override void Gen( TypeBuilder program, MethodBuilder method )
{
AstNode typeclass = this.child;
var tc = program.DefineNestedType( typeclass.symbol, TypeAttributes.NestedPublic );
EnviromentList.Instance.LoopupSymbol( typeclass.symbol ).typeBuilder = tc;
AstNode sibling = typeclass.sibling;
while (sibling != null) {
var subType = program.DefineNestedType( sibling.symbol, TypeAttributes.NestedPublic, tc );
EnviromentList.Instance.LoopupSymbol( sibling.symbol ).typeBuilder = subType;
var cc = subType.DefineConstructor( MethodAttributes.Public,
CallingConventions.Standard, new Type[0] );
EnviromentList.Instance.LoopupSymbol( sibling.symbol ).Constructor = cc;
cc.GetILGenerator().Emit( OpCodes.Ret );
sibling = sibling.sibling;
}
}
public ASTNodeVisitor_JITCompiler(ASTNodeVisitor_JITCompiler parent, TypeBuilder envTypeBuilder, ASTNode_Lambda node)
{
mParent = parent;
mEnvTypeBuilder = envTypeBuilder;
mLambdaNode = node;
mHeapEnvTypeBuilder = envTypeBuilder.DefineNestedType(JITInterpreter_DS.Instance().GenernateUniqueString("nested_class"));
if (HasThisArgument()) {
MethodBuilder = envTypeBuilder.DefineMethod(
JITInterpreter_DS.Instance().GenernateUniqueString("method"),
MethodAttributes.Public,
CallingConventions.HasThis,
typeof(object),
Enumerable.Repeat(typeof(object), mLambdaNode.formalCount).ToArray());
} else {
MethodBuilder = envTypeBuilder.DefineMethod(
JITInterpreter_DS.Instance().GenernateUniqueString("static_method"),
MethodAttributes.Static | MethodAttributes.Public,
CallingConventions.Standard,
typeof(object),
Enumerable.Repeat(typeof(object), mLambdaNode.formalCount).ToArray());
}
mILGenerator = MethodBuilder.GetILGenerator();
DeclareArguments();
DeclareLocals();
EmitInitHeapEnv();
mTailCallFlags.Push(true);
mLambdaNode.bodyNode.AcceptVisitor(this);
mTailCallFlags.Pop();
mILGenerator.Emit(OpCodes.Ret);
mHeapEnvTypeBuilder.CreateType();
}
private Type BuildDelegate(TypeBuilder type, MethodInfo method, Hashtable ctors, Hashtable invocations)
{
TypeBuilder d = type.DefineNestedType(method.Name + "Handler",
TypeAttributes.Class | TypeAttributes.NestedPrivate | TypeAttributes.Sealed,
typeof(System.MulticastDelegate));
ParameterInfo[] parameters = method.GetParameters();
Type[] paramTypes1 = new Type[parameters.Length];
Type[] paramTypes2 = new Type[parameters.Length + 2];
for (int i = 0; i < parameters.Length; i++)
{
paramTypes1[i] = parameters[i].ParameterType;
paramTypes2[i] = parameters[i].ParameterType;
}
paramTypes2[parameters.Length] = typeof(AsyncCallback);
paramTypes2[parameters.Length + 1] = typeof(object);
MethodAttributes theAttr = MethodAttributes.Public | MethodAttributes.HideBySig
| MethodAttributes.NewSlot | MethodAttributes.Virtual;
MethodImplAttributes theImplAttr = MethodImplAttributes.Runtime | MethodImplAttributes.Managed;
ConstructorBuilder ctor = d.DefineConstructor(MethodAttributes.Public,
CallingConventions.Standard, new Type[] { typeof(object), typeof(IntPtr) });
ctor.SetImplementationFlags(theImplAttr);
ctors.Add(method.Name, ctor);
d.DefineMethod("Invoke", theAttr, method.ReturnType, paramTypes1).SetImplementationFlags(theImplAttr);
MethodBuilder invocation = d.DefineMethod("BeginInvoke", theAttr, typeof(IAsyncResult), paramTypes2);
invocation.SetImplementationFlags(theImplAttr);
invocations.Add(method.Name, invocation);
d.DefineMethod("EndInvoke", theAttr, method.ReturnType,
new Type[] { typeof(IAsyncResult) }).SetImplementationFlags(theImplAttr);
return d;
}