| public GetILGenerator ( ) : System.Reflection.Emit.ILGenerator | ||
| return | System.Reflection.Emit.ILGenerator | |
public override void Gen(TypeBuilder program, MethodBuilder method)
{
AstNode left = this.child;
AstNode right = left.sibling;
left.Gen(program, method);
right.Gen(program, method);
if (this.symbol == "+") {
method.GetILGenerator().EmitCall(OpCodes.Callvirt, typeof(TypeBase).GetMethod("Add"), new Type[] { typeof(TypeBase) });
} else if (this.symbol == "-") {
method.GetILGenerator().EmitCall(OpCodes.Callvirt,typeof(TypeBase).GetMethod("Minus"), new Type[] { typeof(TypeBase) });
}
}
public override void Gen(TypeBuilder program, MethodBuilder method)
{
EnviromentNode envNode = EnviromentList.Instance.LoopupSymbol(this.symbol);
AstNode right = this.child;
right.Gen(program, method);
if (envNode.IsGlobal) {
envNode.field = program.DefineField(this.symbol, typeof(TypeBase), System.Reflection.FieldAttributes.Private | System.Reflection.FieldAttributes.Static);
method.GetILGenerator().Emit(OpCodes.Stsfld, envNode.field);
} else {
envNode.local = method.GetILGenerator().DeclareLocal(typeof(TypeBase));
method.GetILGenerator().Emit(OpCodes.Stloc, envNode.local);
}
}
public override void Gen(TypeBuilder program, MethodBuilder method)
{
DoGen(program, method);
// then push a FunctionType value
EnviromentNode envNode = this.localenv == null ?
EnviromentList.Instance.LookupLocal(this.symbol) :
this.localenv.LookupLocal(this.symbol);
var tmp = method.GetILGenerator().DeclareLocal(typeof(TypeBase));
method.GetILGenerator().Emit(OpCodes.Ldstr, this.symbol);
method.GetILGenerator().Emit(OpCodes.Newobj, typeof(FunctionType).GetConstructor(new Type[] { typeof(string) }));
method.GetILGenerator().Emit(OpCodes.Stloc, tmp);
SetupClosure(method, envNode.method, envNode.ParamCount, tmp);
method.GetILGenerator().Emit(OpCodes.Ldloc, tmp);
}
public void Emit(CompilerErrorCollection errors, MethodBuilder m)
{
//Set the parameters
//ParameterBuilder[] parms = new ParameterInfo[args.Length];
for(int i = 0; i < args.Length; i++)
m.DefineParameter(i + 1, ParameterAttributes.None, args[i].Name);
ILGenerator gen = m.GetILGenerator();
//Define the IT variable
LocalRef it = locals["IT"] as LocalRef;
DefineLocal(gen, it);
statements.Process(this, errors, gen);
statements.Emit(this, gen);
//Cast the IT variable to our return type and return it
if (m.ReturnType != typeof(void))
{
gen.Emit(OpCodes.Ldloc, it.Local);
Expression.EmitCast(gen, it.Type, m.ReturnType);
}
gen.Emit(OpCodes.Ret);
}
private void CreateMethodBuilder()
{
methodBuilder = typeBuilder.DefineMethod(
"DynamicMethod", MethodAttributes.Public | MethodAttributes.Static, typeof(object), new Type[] { typeof(object), typeof(object[]) });
methodBuilder.InitLocals = true;
ilGenerator = methodBuilder.GetILGenerator();
}
private void CreateContinueMethod(MethodInfo method, MethodBuilder continueMethod, int position, Type[] parameters, int count)
{
var generator = continueMethod.GetILGenerator();
// Store array in temp0
generator.DeclareLocal(typeof (object[]));
generator.LoadArgument(1);
generator.StashTemporaryVariable(0);
// Push backing object onto the stack
generator.LoadField(backingObject);
// Push each of the arguments passed in onto the stack
for (int i = 0; i < count; i++)
{
generator.LoadTemporaryVariable(0);
generator.LoadInteger(i);
generator.Emit(OpCodes.Ldelem_Ref);
generator.MaybeUnBox(parameters[i]);
}
// Delegate to backing object
generator.Execute(method);
// Convert the returned value to an object
if (method.ReturnType == typeof(void))
generator.LoadNull();
else
generator.MaybeBox(method.ReturnType);
// Return
generator.Emit(OpCodes.Ret);
}
private void CreateMethodBuilder(Type returnType, Type[] parameterTypes)
{
methodBuilder = typeBuilder.DefineMethod(
"DynamicMethod", MethodAttributes.Public | MethodAttributes.Static, returnType, parameterTypes);
methodBuilder.InitLocals = true;
emitter = new Emitter(methodBuilder.GetILGenerator(), parameterTypes);
}
private static void EmitMethodBody (MethodBuilder methodBuilder, MethodInfo methodInfo, String message)
{
Type returnType = methodInfo.ReturnType;
ILGenerator generator = methodBuilder.GetILGenerator ();
ParameterInfo[] parameterInfos = methodInfo.GetParameters ();
if (returnType == typeof(void)) {
MethodInfo sendMessageInvoker = EmitInfos.OBJECTIVECRUNTIME_SENDMESSAGE_VOID_ARGS;
// Makes the actual call
generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldstr, message);
EmitParametersAsArrayOnStack (generator, parameterInfos);
generator.Emit (OpCodes.Call, sendMessageInvoker);
generator.Emit (OpCodes.Ret);
} else {
MethodInfo sendMessageInvoker = EmitInfos.OBJECTIVECRUNTIME_SENDMESSAGE_ARGS_GENERIC.MakeGenericMethod (returnType);
// Makes the actual call
generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldstr, message);
EmitParametersAsArrayOnStack (generator, parameterInfos);
generator.Emit (OpCodes.Call, sendMessageInvoker);
generator.Emit (OpCodes.Ret);
}
}
public PropertyEmitter(TypeBuilder owner, string name, Type propertyType, FieldBuilder propertyChangedField) {
this.owner = owner;
this.propertyChangedField = propertyChangedField;
fieldBuilder = owner.DefineField(String.Format("<{0}>", name), propertyType, FieldAttributes.Private);
getterBuilder = owner.DefineMethod(String.Format("get_{0}", name), MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.HideBySig|MethodAttributes.SpecialName, propertyType, Type.EmptyTypes);
ILGenerator getterIl = getterBuilder.GetILGenerator();
getterIl.Emit(OpCodes.Ldarg_0);
getterIl.Emit(OpCodes.Ldfld, fieldBuilder);
getterIl.Emit(OpCodes.Ret);
setterBuilder = owner.DefineMethod(String.Format("set_{0}", name), MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.HideBySig|MethodAttributes.SpecialName, typeof(void), new[] {propertyType});
ILGenerator setterIl = setterBuilder.GetILGenerator();
setterIl.Emit(OpCodes.Ldarg_0);
setterIl.Emit(OpCodes.Ldarg_1);
setterIl.Emit(OpCodes.Stfld, fieldBuilder);
if (propertyChangedField != null) {
setterIl.Emit(OpCodes.Ldarg_0);
setterIl.Emit(OpCodes.Dup);
setterIl.Emit(OpCodes.Ldfld, propertyChangedField);
setterIl.Emit(OpCodes.Ldstr, name);
setterIl.Emit(OpCodes.Call, proxyBase_NotifyPropertyChanged);
}
setterIl.Emit(OpCodes.Ret);
propertyBuilder = owner.DefineProperty(name, PropertyAttributes.None, propertyType, null);
propertyBuilder.SetGetMethod(getterBuilder);
propertyBuilder.SetSetMethod(setterBuilder);
}
private static void EmitEmptyImplementation( MethodBuilder vM, Type returnType, ParameterInfo[] parameters )
{
ILGenerator gVM = vM.GetILGenerator();
for( int i = 0; i < parameters.Length; ++i )
{
// DefineParameter use 0 for the return parameter.
ParameterInfo param = parameters[i];
vM.DefineParameter( i + 1, param.Attributes, param.Name );
if( param.IsOut )
{
Debug.Assert( param.ParameterType.IsByRef, "'Out' is just an attribute on 'by ref' parameters (unfortunate for covariance support)." );
gVM.StoreDefaultValueForOutParameter( param );
}
}
if( returnType != typeof( void ) )
{
if( returnType.GetTypeInfo().IsValueType )
{
LocalBuilder retValue = gVM.DeclareLocal( returnType );
gVM.Emit( OpCodes.Ldloca_S, retValue.LocalIndex );
gVM.Emit( OpCodes.Initobj, returnType );
gVM.LdLoc( retValue );
}
else
{
gVM.Emit( OpCodes.Ldnull );
}
}
gVM.Emit( OpCodes.Ret );
}
protected void SetUp () {
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = GetType().FullName;
AssemblyBuilder assembly
= Thread.GetDomain().DefineDynamicAssembly(
assemblyName, AssemblyBuilderAccess.Run);
module = assembly.DefineDynamicModule("module1");
tb = module.DefineType("class1",
TypeAttributes.Public);
eb = tb.DefineEvent ("event1", EventAttributes.None, typeof (AnEvent));
mb =
tb.DefineMethod ("OnAnEvent",
MethodAttributes.Public, typeof (void),
new Type [] { typeof (AnEvent) });
ILGenerator ilgen = mb.GetILGenerator();
ilgen.Emit (OpCodes.Ret);
// These two are required
eb.SetAddOnMethod (mb);
eb.SetRemoveOnMethod (mb);
}
public void CreateDynamicMethod()
{
#if SAVE_ASSEMBLY
if (_assemblyBuilder == null)
{
AssemblyName assemblyName = new AssemblyName("ExpressionAssembly");
_assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave, "I:\\Trash");
_moduleBuilder = _assemblyBuilder.DefineDynamicModule("ExpressionModule", "ExpressionModule.module");
}
string typeName = String.Format("Expression{0}", _typeCount);
_typeCount++;
_typeBuilder = _moduleBuilder.DefineType(typeName, TypeAttributes.Class | TypeAttributes.Public);
FieldBuilder filedBuilder = _typeBuilder.DefineField("Source", typeof(string), FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal);
filedBuilder.SetConstant(_source);
_methodBuilder = _typeBuilder.DefineMethod("Evaluate", MethodAttributes.Public | MethodAttributes.Static, typeof(object), new Type[] { typeof(object[]) });
_ilGenerator = _methodBuilder.GetILGenerator();
#else
_dynamicMethod = new DynamicMethod("Expression", typeof(object), new Type[] { typeof(object[]) }, GetType().Module);
_ilGenerator = _dynamicMethod.GetILGenerator();
#endif
}
public override void Gen(TypeBuilder program, MethodBuilder method)
{
AstNode left = this.child;
AstNode right = left.sibling;
left.Gen(program, method);
right.Gen(program, method);
method.GetILGenerator().EmitCall(OpCodes.Callvirt, typeof(TypeBase).GetMethod("Equal"), new Type[] { typeof(TypeBase) });
}
internal void BeginMethod(Type returnType, MethodBuilderInfo methodBuilderInfo, Type[] argTypes, string[] argNames, MethodAttributes methodAttributes)
{
#if DEBUG
methodBuilderInfo.Validate(returnType, argTypes, methodAttributes);
#endif
_methodBuilder = methodBuilderInfo.MethodBuilder;
_ilGen = _methodBuilder.GetILGenerator();
InitILGeneration(argTypes, argNames, (_methodBuilder.Attributes & MethodAttributes.Static) == MethodAttributes.Static);
}
private void EmitEqualsObj(TypeBuilder typeBuilder, MethodBuilder method, MethodBuilder typedEqualsMethoed)
{
ILGenerator iLGenerator = method.GetILGenerator();
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Isinst, typeBuilder);
iLGenerator.EmitCall(OpCodes.Call, typedEqualsMethoed, null);
iLGenerator.Emit(OpCodes.Ret);
}
/// <summary>
/// Constructs an Emitter using the specified MethodBuilder.
/// </summary>
/// <param name="metb">MethodBuilder</param>
public Emitter(MethodBuilder metb)
{
if (metb == null) {
throw new ArgumentNullException("metb");
}
_il = metb.GetILGenerator();
_temp = new Collection<LocalDescriptor>();
_code = new Collection<Instruction>();
}
public static void genDelegateCall( Type interfaceType
,Type[] parameters
,MethodBuilder methodBuilder
,FieldInfo invoker
,FieldInfo target)
{
ILGenerator IL = methodBuilder.GetILGenerator();
// Declare and initialize the array for passing the parameters.
IL.DeclareLocal(typeof(object[])); //loc.0
IL.DeclareLocal(typeof(MethodInfo)); //loc.1
IL.DeclareLocal(typeof(object)); //loc.2
//If there is a return
if(methodBuilder.ReturnType!=typeof(void))
IL.DeclareLocal(methodBuilder.ReturnType); //loc.3
// Init the args array
if(parameters==null)
{
IL.Emit(OpCodes.Ldnull);
storeLocal(IL,0);
}
else
{
loadInt32(IL,parameters.Length);
IL.Emit(OpCodes.Newarr, typeof(object));
storeLocal(IL,0);
// Store the parameters in the new array.
for(int i = 0; i < parameters.Length; i++)
{
loadLocal(IL,0);//Load the array reference
putArgInArray(IL,i, parameters[i]);
}
}
// Store the methodinfo object using the Ldtoken command. Must use the interfaces MethodInfo.
MethodInfo mi = parameters==null?interfaceType.GetMethod(methodBuilder.Name):interfaceType.GetMethod(methodBuilder.Name,parameters);
IL.Emit(OpCodes.Ldtoken,mi);
IL.Emit(OpCodes.Call, typeof(MethodBase).GetMethod("GetMethodFromHandle"));
storeLocal(IL,1);
IL.Emit(OpCodes.Ldarg_0); // Proxy (this)
IL.Emit(OpCodes.Ldfld, target); // The delegate from the proxy
storeLocal(IL,2);
// Setup the stack for the delegate call.
IL.Emit(OpCodes.Ldarg_0); // this needed for the load field opcode
IL.Emit(OpCodes.Ldfld, invoker);// The delegate from the proxy
loadLocal(IL,2);
//IL.Emit(OpCodes.Ldarg_0); // 1st arg - Proxy (this)
loadLocal(IL,1); // 2nd arg - MethodInfo
loadLocal(IL,0); // 3rd arg - array of arguments
IL.Emit(OpCodes.Callvirt,(typeof(Proxy.InvocationDelegate).GetMethod("Invoke")));
emitReturnFromMethod(IL, methodBuilder.ReturnType);
if(methodBuilder.ReturnType!=typeof(void))
{ // Not sure I need to so this but the C# compiler seems to generate this code?
storeLocal(IL,3);
loadLocal(IL,3);
}
IL.Emit(OpCodes.Ret);
}
public Function(string name, Type returnType, FuncParam[] parameters, Block body, MethodBuilder info)
{
Name = name;
ReturnType = returnType;
Params = parameters;
Body = body;
Info = info;
ILGenerator = info.GetILGenerator();
}
public CodeContext(DefinitionContext next,MethodBuilder method) : base(next)
{
if (method == null)
throw new ArgumentNullException("method");
this.method = method;
this.il = method.GetILGenerator();
this.locals = new Dictionary<string,LocalBuilder>();
this.parameters = new Dictionary<string,int>();
this.parametertypes = new List<Type>();
}
public void EmitMethodBody(MethodBuilder generatedMethod, MethodInfo method, FieldInfo field)
{
var IL = generatedMethod.GetILGenerator();
ParameterInfo[] parameters = method.GetParameters();
IL.DeclareLocal(typeof (object[]));
IL.DeclareLocal(typeof (InvocationInfo));
IL.DeclareLocal(typeof(System.Type[]));
IL.Emit(OpCodes.Ldarg_0);
IL.Emit(OpCodes.Callvirt, getInterceptor);
// if (interceptor == null)
// return base.method(...);
Label skipBaseCall = IL.DefineLabel();
IL.Emit(OpCodes.Ldnull);
IL.Emit(OpCodes.Bne_Un, skipBaseCall);
IL.Emit(OpCodes.Ldarg_0);
for (int i = 0; i < method.GetParameters().Length; i++)
IL.Emit(OpCodes.Ldarg_S, (sbyte)(i + 1));
IL.Emit(OpCodes.Call, method);
IL.Emit(OpCodes.Ret);
IL.MarkLabel(skipBaseCall);
// Push arguments for InvocationInfo constructor.
IL.Emit(OpCodes.Ldarg_0); // 'this' pointer
PushTargetMethodInfo(IL, generatedMethod, method);
PushStackTrace(IL);
PushGenericArguments(method, IL);
_argumentHandler.PushArguments(parameters, IL, false);
// InvocationInfo info = new InvocationInfo(...);
IL.Emit(OpCodes.Newobj, infoConstructor);
IL.Emit(OpCodes.Stloc_1);
// this.Interceptor.Intercept(info);
IL.Emit(OpCodes.Ldarg_0);
IL.Emit(OpCodes.Callvirt, getInterceptor);
IL.Emit(OpCodes.Ldloc_1);
IL.Emit(OpCodes.Callvirt, handlerMethod);
PackageReturnType(method, IL);
SaveRefArguments(IL, parameters);
IL.Emit(OpCodes.Ret);
}
public override void Gen(TypeBuilder program, MethodBuilder method)
{
ILGenerator il = method.GetILGenerator();
AstNode lowerBound = child;
AstNode upperBound = child.sibling;
il.Emit(OpCodes.Newobj, typeof(ArrayBoundType).GetConstructor(new Type[] { }));
lowerBound.Gen(program, method);
upperBound.Gen(program, method);
il.EmitCall(OpCodes.Call, typeof(ArrayBoundType).GetMethod("Append"),
new Type[] { typeof(TypeBase), typeof(TypeBase) });
}
public override MethodInfo BeginMethod(string methodName, Type returnType, Type[] paramTypes, string[] paramNames)
{
typeBuilder = _asm.ModuleBuilder.DefineType(methodName, System.Reflection.TypeAttributes.Public);
methodBuilder = typeBuilder.DefineMethod(
"R",
System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.Static,
System.Reflection.CallingConventions.Standard,
returnType,
paramTypes
);
MsilGen = methodBuilder.GetILGenerator();
return methodBuilder;
}
public CodeGenContext(List<Instruction> insList)
{
AssemblyName assemblyName = new AssemblyName ();
assemblyName.Name = ASSEMBLY_NAME;
assembly = Thread.GetDomain ().DefineDynamicAssembly (assemblyName, AssemblyBuilderAccess.RunAndSave, ".");
module = assembly.DefineDynamicModule ("module1", "ps.dll");
typeBuilder = module.DefineType ("Shader", TypeAttributes.Public);
method = typeBuilder.DefineMethod ("Exec", MethodAttributes.Public | MethodAttributes.Static, typeof (void), new Type [] { typeof (ShaderData) });
ilgen = method.GetILGenerator ();
this.insList = insList;
}
public static void CompileToInstanceMethod(this LambdaExpression expression, MethodBuilder method)
{
string uniqueId = Guid.NewGuid().ToString("N");
TypeBuilder typeBuilder = moduleBuilder.DefineType("t" + uniqueId);
MethodBuilder methodBuilder = typeBuilder.DefineMethod(
"m" + uniqueId,
MethodAttributes.Public | MethodAttributes.Static,
expression.Type,
expression.Parameters.Select(parameter => parameter.Type).ToArray());
expression.CompileToMethod(methodBuilder);
Type type = typeBuilder.CreateType();
MethodInfo staticMethod = type.GetMethod("m" + uniqueId);
new ILReader(staticMethod).Accept(new ILTransform(method.GetILGenerator()));
}
private static void GenerateMainMethod(MethodBuilder mainMethod, BFMemory memory, string sourceCode)
{
ILGenerator ilGen = mainMethod.GetILGenerator();
var charray = sourceCode
.Replace(" ", string.Empty)
.Replace("\r", string.Empty)
.Replace("\n", string.Empty)
.Replace("\t", string.Empty)
.ToCharArray();
using (var generator = new BFGenerator(ilGen, memory))
{
foreach (var t in charray)
{
switch (t)
{
case '>':
generator.GenerateMoveRight();
break;
case '<':
generator.GenerateMoveLeft();
break;
case '+':
generator.GenerateIncrement();
break;
case '-':
generator.GenerateDecrement();
break;
case '.':
generator.GenerateWrite();
break;
case ',':
generator.GenerateRead();
break;
case '[':
generator.GenerateOpenLoop();
break;
case ']':
generator.GenerateCloseLoop();
break;
}
}
}
}
private void GeneratePlangCore(AstNode root)
{
// generate all global field
//foreach (var keyvalue in EnviromentList.Global.table) {
// EnviromentNode node = keyvalue.Value;
// if( node.Type != "__function__" && node.Type != "__lambda__" )
// node.field = program.DefineField(keyvalue.Key, typeof(TypeBase), System.Reflection.FieldAttributes.Private | System.Reflection.FieldAttributes.Static);
//}
// then generate global sentenses
main = program.DefineMethod("Main", System.Reflection.MethodAttributes.Static | System.Reflection.MethodAttributes.Public,
System.Reflection.CallingConventions.Standard, typeof(void), null);
_gen.SetEntryPoint(main);
AstNode sentense = root;
while (sentense != null) {
sentense.Gen(program, main);
sentense = sentense.sibling;
}
main.GetILGenerator().Emit(OpCodes.Ret);
}
public BrainfuckApp(string name)
{
Name = name;
_asBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName { Name = "Brainfuck app" }, AssemblyBuilderAccess.Save);
_modBuilder = _asBuilder.DefineDynamicModule("bf", name + ".exe");
_typeBuilder = _modBuilder.DefineType("Program", TypeAttributes.Public);
_methBuilder = _typeBuilder.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static);
_asBuilder.SetEntryPoint(_methBuilder);
_il = _methBuilder.GetILGenerator();
_il.DeclareLocal(typeof(int));
_il.DeclareLocal(typeof(int[]));
// Initialize idx to 0
_il.Emit(OpCodes.Ldc_I4_0);
_il.Emit(OpCodes.Stloc_0);
// Initialize cell with 30000 fields of int
_il.Emit(OpCodes.Ldc_I4, 30000);
_il.Emit(OpCodes.Newarr, typeof(int));
_il.Emit(OpCodes.Stloc_1);
}
void GenFactoryDelegateMethod()
{
// This generates the method that will be wrapped by the delegate in the GetFactory method
_factoryDelegateMethod = _tb.DefineMethod(
"FactoryDelegateMethod",
MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.Static,
typeof(object),
_ctorArgTypes.Select(a => typeof(object)).ToArray());
var gen = _factoryDelegateMethod.GetILGenerator();
ushort index = 0;
foreach (var arg in _ctorArgTypes)
{
gen.EmitBestLdArg(index);
gen.Emit(OpCodes.Castclass, arg);
++index;
}
gen.Emit(OpCodes.Newobj, _ctor);
gen.Emit(OpCodes.Ret);
}
public override void Gen(TypeBuilder program, MethodBuilder method)
{
AstNode content = child;
ILGenerator il = method.GetILGenerator();
var tmp = il.DeclareLocal(typeof(ArrayType));
il.Emit(OpCodes.Newobj, typeof(ArrayType).GetConstructor(new Type[]{}));
il.Emit(OpCodes.Stloc, tmp);
int count = 0;
while (content != null)
{
count++;
il.Emit(OpCodes.Ldloc, tmp);
content.Gen(program, method);
il.EmitCall(OpCodes.Call, typeof(ArrayType).GetMethod("Append"),
new Type[] { typeof(TypeBase) });
content = content.sibling;
}
il.Emit(OpCodes.Ldloc, tmp);
}
public void GenerateIL(stmt Stmt, ILGenerator generator, Context context, Dictionary<string,LocalBuilder> symbolTable, MethodBuilder Method = null, TypeBuilder Class = null)
{
ILGenerator ilGenerator;
if (generator == null)
{
if (Method == null)
{
ilGenerator = mainMethod.GetILGenerator();
}
else
{
ilGenerator = Method.GetILGenerator();
}
}
else
{
ilGenerator = generator;
}
if (Class != null)
{
if(Stmt is stmt_list)
{
stmt_list list = Stmt as stmt_list; //Cast stmt
foreach (stmt s in list.list)
{
GenerateIL(s, null, context, null, null, Class);
}
}
}
else
{
if (Stmt is stmt_list)
{
stmt_list list = Stmt as stmt_list; //Cast stmt
foreach (stmt s in list.list)
{
GenerateIL(s, generator, context, symbolTable, Method, null);
}
}
else if (Stmt is declarevar)
{
declarevar stmt = Stmt as declarevar;
mainSymbolTable[stmt.name] = ilGenerator.DeclareLocal(GetILType(stmt.type));
GenerateExpr(stmt.value, ilGenerator);
StoreLocal(stmt.name, ilGenerator);
}
else if (Stmt is setvar)
{
setvar stmt = Stmt as setvar;
GenerateExpr(stmt.value, ilGenerator);
StoreLocal(stmt.name, ilGenerator);
}
else if (Stmt is function_call)
{
function_call stmt = Stmt as function_call;
GenerateExpr(stmt.arg, ilGenerator);
//ilGenerator.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));
MethodInfo method = GetMethodInfo(stmt.name, Class, null, GetExprTypes(stmt.arg));
MethodInfo rmethod = Type.GetType("System.Console").GetMethod("WriteLine", new Type[] { typeof(string) });
if(method == rmethod)
{
Console.WriteLine("MATCH!");
}
ilGenerator.Emit(OpCodes.Call, method);
}
else if (Stmt is class_definition)
{
class_definition stmt = Stmt as class_definition;
GenerateClass(stmt, context);
}
}
}
