public CodeGen(Stmt stmt, string moduleName)
{
if (IO.Path.GetFileName(moduleName) != moduleName)
{
throw new System.Exception("can only output into current directory!");
}
Reflect.AssemblyName name = new Reflect.AssemblyName(IO.Path.GetFileNameWithoutExtension(moduleName));
Emit.AssemblyBuilder asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(name, Emit.AssemblyBuilderAccess.Save);
Emit.ModuleBuilder modb = asmb.DefineDynamicModule(moduleName);
Emit.TypeBuilder typeBuilder = modb.DefineType("Foo");
Emit.MethodBuilder methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
// CodeGenerator
this.il = methb.GetILGenerator();
this.symbolTable = new Collections.Dictionary <string, Emit.LocalBuilder>();
// Go Compile!
this.GenStmt(stmt);
il.Emit(Emit.OpCodes.Ret);
typeBuilder.CreateType();
modb.CreateGlobalFunctions();
asmb.SetEntryPoint(methb);
asmb.Save(moduleName);
this.symbolTable = null;
this.il = null;
}
private void CompileMainClass(Node ActiveNode)
{
Emit.TypeBuilder _TypeBuilder =
TypeTable[ActiveNode.Nodes[1].Value];
Emit.MethodBuilder MethBuilder = _TypeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
this.AssemblerGenerator = MethBuilder.GetILGenerator();
CurrentType = _TypeBuilder;
OpenBlockVariables();
CreateCode(ActiveNode.Nodes[14]);
CreateCode(ActiveNode.Nodes[15]);
CloseBlockVariables();
// Отладочные команды
AssemblerGenerator.Emit(Emit.OpCodes.Ldstr, "Programm was finished. Press Enter key to quit...");
AssemblerGenerator.Emit(Emit.OpCodes.Call,
typeof(System.Console).GetMethod("WriteLine", new System.Type[] { typeof(string) }));
AssemblerGenerator.Emit(Emit.OpCodes.Call,
typeof(System.Console).GetMethod("ReadLine", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static, null, new System.Type[] { }, null));
AssemblerGenerator.Emit(Emit.OpCodes.Pop);
AssemblerGenerator.Emit(Emit.OpCodes.Ret);
CreatedTypeTable[ActiveNode.Nodes[1].Value] = _TypeBuilder.CreateType();
ModBuilder.CreateGlobalFunctions();
AsmBuilder.SetEntryPoint(MethBuilder);
}
public CodeGenerator(Expression pExpression, String pModuleName, ref LogHandler rLogHandler)
{
_symbolTable = new Dictionary <String, Emit.LocalBuilder>();
_assemblyName = new Reflect.AssemblyName(Path.GetFileNameWithoutExtension(pModuleName));
_statement = pExpression;
//Init Assembly
_assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(_assemblyName, Emit.AssemblyBuilderAccess.Save);
_moduleBuilder = _assemblyBuilder.DefineDynamicModule(pModuleName);
_typeBuilder = _moduleBuilder.DefineType("PascalCompilerType");
_methodBuilder = _typeBuilder.DefineMethod
(
"Main",
Reflect.MethodAttributes.Static,
typeof(void),
Type.EmptyTypes
);
_ilGenerator = _methodBuilder.GetILGenerator();
//Actual Work
GenerateStatement(_statement, null);
_ilGenerator.Emit(Emit.OpCodes.Ret);
//Finalizing Work
_typeBuilder.CreateType();
_moduleBuilder.CreateGlobalFunctions();
_assemblyBuilder.SetEntryPoint(_methodBuilder);
_assemblyBuilder.Save(pModuleName);
}
public CodeGen(ParseTreeNode stmt, string moduleName)
{
if (Path.GetFileName(moduleName) != moduleName)
{
throw new System.Exception("can only output into current directory!");
}
AssemblyName name = new AssemblyName(Path.GetFileNameWithoutExtension(moduleName));
asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Save);
ModuleBuilder modb = asmb.DefineDynamicModule(moduleName);
//mainProgram = modb.DefineType("Program");
//var mainArgs = new List<Tuple<string, Type>>();
//var mainProgramDef = new FunctionDefinition
//(
// mainProgram.DefineMethod("Main", MethodAttributes.Static, typeof(void), System.Type.EmptyTypes),
// new List<FunctionDefinition.Argument>()
//);
SymbolTable symbolTable = new SymbolTable(modb.DefineType("__Program"));
symbolTable.AddFunctionHeader("__Main", MethodAttributes.Static, null, new FunctionDefinition.Argument[]{});
//symbolTable.functionTable.AddHeader("Main", mainProgramDef);
stmt = PreGenerate(stmt, symbolTable);
stmt = ImportList(stmt, symbolTable);
// CodeGenerator
var il = symbolTable.functionTable["__Main"].GetILGenerator();
// Go Compile!
this.GenStmt(stmt, il, symbolTable);
//il.Emit(OpCodes.Ldstr, "Press any key to exit the program...");
//il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new Type[] { typeof(string) }));
//il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("ReadKey", new Type[] { }));
il.Emit(OpCodes.Ret);
//mainProgram.CreateType();
modb.CreateGlobalFunctions();
asmb.SetEntryPoint(symbolTable.functionTable["__Main"].methodDefinition);
symbolTable.typeTable.types[0].typeBuilder.CreateType();
asmb.Save(moduleName);
foreach (var symbol in symbolTable.Locals)
{
Console.WriteLine("{0}: {1}", symbol.Key, symbol.Value);
}
symbolTable = null;
il = null;
}
/**
* Saves the constructed assembly to a file
*/
public void SaveAssembly()
{
add_resources_to_assembly();
// if there are some nemerle specific metadata encoded in attributes
if (contains_nemerle_specifics)
{
var attr = Manager.AttributeCompiler.MakeEmittedAttribute(
SystemTypeCache.Reflection_AssemblyConfigurationAttribute, "ContainsNemerleTypes");
this._assembly_builder.SetCustomAttribute(attr);
}
// set the entry point
if (_need_entry_point)
{
if (Option.IsSome(_entry_point, out var entry_point_method_info))
{
_assembly_builder.SetEntryPoint(entry_point_method_info,
(Manager.Options.TargetIsWinexe)
? Emit.PEFileKinds.WindowApplication
: Emit.PEFileKinds.ConsoleApplication);
}
else
{
Message.Error("no suitable entry point (Main function) found");
}
}
// save the assembly
try
{
var (portableExecutableKind, imageFileMachine) = make_platform_flags(Manager.Options.Platform);
_assembly_builder.Save(Path.GetFileName(_OutputFileName), portableExecutableKind, imageFileMachine);
//when (_debug_emit != null) _debug_emit.Close ();
}
catch (System.UnauthorizedAccessException e)
{
Message.Error($"could not write to output file `$(this._OutputFileName)' -- `$(e.Message)'");
}
catch (IOException e)
{
Message.Error($"could not write to output file `$(this._OutputFileName)' -- `$(e.Message)'");
}
catch (System.Runtime.InteropServices.COMException e)
{
Message.Error($"Problems saving assembly: $(e.Message)");
}
catch (System.ApplicationException e)
{
Message.Error(e.Message);
}
}
private void finalizar(string nombreEjecutable)
{
//Asigno una pausa para indicar que finalizo la ejecucion del codigo objetivo generado
anadirPausa();
//Creo el assembler .net y defino las ultimas opciones de configuracion
il.Emit(Emit.OpCodes.Ret);
Type pp = typeBuilder.CreateType();
modb.CreateGlobalFunctions();
asmb.SetEntryPoint(methb, Reflect.Emit.PEFileKinds.ConsoleApplication);
asmb.Save(IO.Path.GetFileName(nombreEjecutable));
//Ahora procedo a limpiar la tabla de direcciones para su proximo uso.
TablaDireccionesSimbolos.Clear();
this.il = null;
}
public AssemblyGen(TypeDeclaration methodDec, string moduleName, string dllProbeDirectory)
{
if (IO.Path.GetFileName(moduleName) != moduleName)
{
throw new System.Exception("can only output into current directory!");
}
this.dllProbeDirectory = dllProbeDirectory;
typeList = new List <TypeGen>();
Reflect.AssemblyName name = new Reflect.AssemblyName(IO.Path.GetFileNameWithoutExtension(moduleName));
Emit.AssemblyBuilder asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(name, Emit.AssemblyBuilderAccess.Save);
Emit.ModuleBuilder modb = asmb.DefineDynamicModule(moduleName);
GenerateType(methodDec, modb, dllProbeDirectory);
modb.CreateGlobalFunctions();
asmb.SetEntryPoint(GetEntryPoint());
asmb.Save(moduleName);
}
public void BuildLi(List<CodeBlock> CodeBlocks, string asmname)
{
//setup
asm = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName(asmname), AssemblyBuilderAccess.Save);
ModuleBuilder mod = asm.DefineDynamicModule("TestOutput.exe",
asmname +".exe");
TypeBuilder type = mod.DefineType("Program", TypeAttributes.Class);
MethodBuilder main = type.DefineMethod("Main",
MethodAttributes.Public | MethodAttributes.Static);
ILGenerator il = main.GetILGenerator();
//actual il code
foreach (var block in CodeBlocks)
{
if (block.name == "ClassCode")
{
foreach (IAst node in block.Nodes)
{
if (node is ObjCallStmt)
{
ObjCallStmt nd = node as ObjCallStmt;
il.Emit(OpCodes.Ldstr, (nd.Paramaters[0] as EcString).Value as string);
}
}
break;
}
}
/* il.Emit(OpCodes.Ldstr, "Hello world!");
il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine",
BindingFlags.Public | BindingFlags.Static,
null, new Type[] { typeof(String) }, null));*/
il.Emit(OpCodes.Ret);
//done
type.CreateType();
asm.SetEntryPoint(main);
}
public static TypeBuilder GetTypeBuilder(string fileName, ModuleBuilder mb, AssemblyBuilder ab)
{
StreamReader file = new StreamReader(fileName);
TypeBuilder tb = mb.DefineType( fileName.Substring(0,fileName.Length-3).Replace(@"\", "."), TypeAttributes.Public);
var code = file.ReadToEnd();
var esprima = new Esprima.NET.Esprima();
var node = esprima.parse(code, new Options());
foreach (var fcuntionDef in node.body.Where(x => x.type == "FunctionDeclaration"))
{
var argumentNames = [email protected](x => typeof(Object)).ToArray();
MethodBuilder metb = tb.DefineMethod(fcuntionDef.id.name, MethodAttributes.Public | MethodAttributes.Static, null, argumentNames);
ab.SetEntryPoint(metb);
ILGenerator il = metb.GetILGenerator();
il.EmitWriteLine("Hello World");
il.Emit(OpCodes.Ret);
il.Emit(OpCodes.Ret);
}
tb.CreateType();
return tb;
}
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);
}
public CodeGen(stmt stmt, string moduleName, int count)
{
if (IO.Path.GetFileName(moduleName) != moduleName)
{
throw new System.Exception("can only output into current directory!");
}
stmts = stmt;
Reflect.AssemblyName name = new Reflect.AssemblyName("FAJF"); //name of the assembly
Emit.AssemblyBuilder asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(name, Emit.AssemblyBuilderAccess.Save);
Emit.ModuleBuilder modb = asmb.DefineDynamicModule(moduleName);
Emit.TypeBuilder typeBuilder = modb.DefineType("resister"); //name of the class
Emit.MethodBuilder methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
// CodeGenerator
this.il = methb.GetILGenerator();
this.symbolTable = new Collections.Dictionary <string, Emit.LocalBuilder>();
counting = 0;
counter = count;
counters = 0;
// Go Compile!
this.GenStmt(stmt);
il.Emit(Emit.OpCodes.Ret);
typeBuilder.CreateType();
modb.CreateGlobalFunctions();
asmb.SetEntryPoint(methb);
asmb.Save(moduleName);
// this.il.EmitWriteLine("press any key to continue");
this.symbolTable = null;
this.il = null;
System.Diagnostics.Process.Start(moduleName);
}
private AssemblyBuilder CreateExecutable(string name)
{
ILGenerator il;
name = name.Replace('\\', '/');
string exename = name.Contains('/') ? name.Substring(name.LastIndexOf('/') + 1) : name;
string pathname = name.Contains('/') ? name.Remove(name.LastIndexOf('/')) : null;
string asmname = exename.Contains('.') ? exename.Remove(exename.LastIndexOf('.')) : exename;
//
// We are generating a dynamic assembly here.
//
// Get type information from the runtime assembly
var asm_runtime = Assembly.Load("GameCreator.Runtime");
var asm_gamei = Assembly.Load("GameCreator.Runtime.Game.Interpreted");
var asm_game = Assembly.Load("GameCreator.Runtime.Game");
Type t_gamei = asm_gamei.GetType("GameCreator.Runtime.Game.Interpreted.InterpretedGame");
Type t_game = asm_game.GetType("GameCreator.Runtime.Game.Game");
Type t_ext = typeof(ResourceExtensions);
Type t_obj = typeof(Framework.Object);
Type t_room = typeof(Room);
Type t_event = typeof(Event);
Type t_lib = typeof(Framework.ActionLibrary);
Type t_context = typeof(LibraryContext);
Type t_rcontext = typeof(ResourceContext);
// Define our dynamic assembly
System.Reflection.Emit.AssemblyBuilder asm = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(asmname), AssemblyBuilderAccess.RunAndSave, pathname);
ModuleBuilder mod = asm.DefineDynamicModule(exename, exename);
// Define our Program type
TypeBuilder program = mod.DefineType(string.Format("{0}.Program", asmname));
System.Resources.IResourceWriter resw = mod.DefineResource(string.Format("{0}.Program.resources", asmname), string.Empty);
FieldBuilder resourceManager = program.DefineField("resourceManager", typeof(System.Resources.ResourceManager), FieldAttributes.Static);
MethodBuilder GetResourceManager = program.DefineMethod("GetResourceManager", MethodAttributes.Static, typeof(System.Resources.ResourceManager), Type.EmptyTypes);
il = GetResourceManager.GetILGenerator();
System.Reflection.Emit.Label grm_l_1 = il.DefineLabel();
il.Emit(OpCodes.Ldsfld, resourceManager);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Brtrue_S, grm_l_1);
il.Emit(OpCodes.Pop);
il.Emit(OpCodes.Ldstr, string.Format("{0}.Program", asmname));
il.Emit(OpCodes.Ldtoken, program);
il.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle", BindingFlags.Static | BindingFlags.Public));
il.Emit(OpCodes.Callvirt, typeof(Type).GetProperty("Assembly").GetGetMethod());
il.Emit(OpCodes.Newobj, typeof(System.Resources.ResourceManager).GetConstructor(new Type[] { typeof(string), typeof(Assembly) }));
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stsfld, resourceManager);
il.MarkLabel(grm_l_1);
il.Emit(OpCodes.Ret);
//program.SetCustomAttribute(new CustomAttributeBuilder(typeof(STAThreadAttribute).GetConstructor(new Type[] { }), new object[] { }));
// our static Main() function
// {
// GameCreator.Runtime.Object obj;
// GameCreator.Runtime.Event ev;
// GameCreator.Runtime.ActionLibrary lib;
// GameCreator.Runtime.Game.Init();
// ...
// lib = GameCreator.ActionLibrary.Define(id);
// lib.DefineAction(actionid, kind, execution, question, func, code, args);
// ...
// GameCreator.Runtime.Script.Define("name", index, "code");
// ...
// obj = GameCreator.Runtime.Object.Define("name", index);
// ev = obj.DefineEvent(event, num);
// ev.DefineAction(libid, actionid, args, appliesto, relative, not);
// ...
// GameCreator.Runtime.Room.Define("name", index).CreationCode = "code";
// ...
// GameCreator.Runtime.Game.Name = "name";
// GameCreator.Runtime.Game.Run();
// (return)
// }
// GameCreator.Runtime.Object obj;
// GameCreator.Runtime.Event ev;
// GameCreator.Runtime.ActionLibrary lib;
MethodBuilder initLibraries = program.DefineMethod("InitLibraries", MethodAttributes.Static);
il = initLibraries.GetILGenerator();
foreach (ActionLibrary lib in Program.Library)
{
// lib = GameCreator.ActionLibrary.Define(id);
il.EmitCall(OpCodes.Call, t_context.GetProperty("Current", BindingFlags.Public | BindingFlags.Static).GetGetMethod(), null);
il.Emit(OpCodes.Ldc_I4, lib.LibraryID);
il.EmitCall(OpCodes.Call, t_context.GetMethod("GetActionLibrary", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(int) }, null), null);
foreach (ActionDefinition ad in lib.Actions)
{
// lib.DefineAction(actionid, kind, execution, question, func, code, args);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Ldc_I4, ad.ActionID);
il.Emit(OpCodes.Ldc_I4, (int)ad.Kind);
il.Emit(OpCodes.Ldc_I4, (int)ad.ExecutionType);
il.Emit(ad.IsQuestion ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Ldstr, ad.FunctionName);
il.Emit(OpCodes.Ldstr, ad.Code);
// ... , new ActionArgumentType[] { x, y, z },
il.Emit(OpCodes.Ldc_I4, ad.ArgumentCount);
il.Emit(OpCodes.Newarr, typeof(ActionArgumentType));
for (int i = 0; i < ad.ArgumentCount; i++)
{
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Ldc_I4, i);
il.Emit(OpCodes.Ldc_I4, (int)ad.Arguments[i].Type);
il.Emit(OpCodes.Stelem_I4);
}
//
il.EmitCall(OpCodes.Call, t_lib.GetMethod("DefineAction", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(int), typeof(ActionKind), typeof(ActionExecutionType), typeof(bool), typeof(string), typeof(string), typeof(ActionArgumentType[]) }, null), null);
}
il.Emit(OpCodes.Pop);
}
il.Emit(OpCodes.Ret);
MethodBuilder defineSprites = program.DefineMethod("DefineSprites", MethodAttributes.Static);
il = defineSprites.GetILGenerator();
foreach (SpriteResourceView res in Program.Sprites.Values)
{
// Define the resource
int i = 0;
foreach (Bitmap b in res.Animation.Frames)
{
resw.AddResource(string.Format("spr_{0}_{1}", res.ResourceID, i++), b);
}
// GameCreator.Runtime.Sprite.Define("name", index, subimages);
il.EmitCall(OpCodes.Call, t_context.GetProperty("Current", BindingFlags.Public | BindingFlags.Static).GetGetMethod(), null);
il.EmitCall(OpCodes.Call, t_context.GetProperty("Resources", BindingFlags.Public | BindingFlags.Instance).GetGetMethod(), null);
il.EmitCall(OpCodes.Call, t_rcontext.GetProperty("Sprites", BindingFlags.Public | BindingFlags.Instance).GetGetMethod(), null);
il.Emit(OpCodes.Ldstr, res.Name);
il.Emit(OpCodes.Ldc_I4, res.ResourceID);
il.Emit(OpCodes.Ldc_I4, res.Animation.FrameCount);
il.EmitCall(OpCodes.Call, t_ext.GetMethod("Define", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(IndexedResourceManager <Sprite>), typeof(string), typeof(int), typeof(int) }, null), null);
il.Emit(OpCodes.Pop);
}
il.Emit(OpCodes.Ret);
MethodBuilder defineScripts = program.DefineMethod("DefineScripts", MethodAttributes.Static);
il = defineScripts.GetILGenerator();
foreach (ScriptResourceView res in Program.Scripts.Values)
{
// GameCreator.Runtime.Script.Define("name", index, "code");
il.EmitCall(OpCodes.Call, t_context.GetProperty("Current", BindingFlags.Public | BindingFlags.Static).GetGetMethod(), null);
il.EmitCall(OpCodes.Call, t_context.GetProperty("Resources", BindingFlags.Public | BindingFlags.Instance).GetGetMethod(), null);
il.EmitCall(OpCodes.Call, t_rcontext.GetProperty("Sprites", BindingFlags.Public | BindingFlags.Instance).GetGetMethod(), null);
il.Emit(OpCodes.Ldstr, res.Name);
il.Emit(OpCodes.Ldc_I4, res.ResourceID);
il.Emit(OpCodes.Ldstr, res.Code);
il.EmitCall(OpCodes.Call, t_ext.GetMethod("Define", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(IndexedResourceManager <Script>), typeof(string), typeof(int), typeof(string) }, null), null);
il.Emit(OpCodes.Pop);
}
il.Emit(OpCodes.Ret);
MethodBuilder defineObjects = program.DefineMethod("DefineObjects", MethodAttributes.Static);
il = defineObjects.GetILGenerator();
foreach (ObjectResourceView res in Program.Objects.Values)
{
// obj = GameCreator.Runtime.Object.Define("name", index);
il.EmitCall(OpCodes.Call, t_context.GetProperty("Current", BindingFlags.Public | BindingFlags.Static).GetGetMethod(), null);
il.EmitCall(OpCodes.Call, t_context.GetProperty("Resources", BindingFlags.Public | BindingFlags.Instance).GetGetMethod(), null);
il.EmitCall(OpCodes.Call, t_rcontext.GetProperty("Objects", BindingFlags.Public | BindingFlags.Instance).GetGetMethod(), null);
il.Emit(OpCodes.Ldstr, res.Name);
il.Emit(OpCodes.Ldc_I4, res.ResourceID);
il.EmitCall(OpCodes.Call, t_ext.GetMethod("Define", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(IndexedResourceManager <Framework.Object>), typeof(string), typeof(int) }, null), null);
foreach (ObjectEvent ev in res.Events)
{
// ev = obj.DefineEvent(event, num);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Ldc_I4, (int)ev.EventType);
il.Emit(OpCodes.Ldc_I4, (int)ev.EventNumber);
il.EmitCall(OpCodes.Call, t_obj.GetMethod("DefineEvent", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(int), typeof(int) }, null), null);
foreach (ActionDeclaration ad in ev.Actions)
{
// ev.DefineAction(libid, actionid, args, appliesto, relative, not);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Ldc_I4, ad.Kind.Library.LibraryID);
il.Emit(OpCodes.Ldc_I4, ad.Kind.ActionID);
// ... , new string[] { "arg", "arg", "arg" },
il.Emit(OpCodes.Ldc_I4, ad.Kind.ArgumentCount);
il.Emit(OpCodes.Newarr, typeof(string));
for (int i = 0; i < ad.Kind.ArgumentCount; i++)
{
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Ldc_I4, i);
il.Emit(OpCodes.Ldstr, ad.Arguments[i]);
il.Emit(OpCodes.Stelem_Ref);
}
//
il.Emit(OpCodes.Ldc_I4, ad.AppliesTo);
il.Emit(ad.Relative ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
il.Emit(ad.Not ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
il.EmitCall(OpCodes.Call, t_event.GetMethod("DefineAction", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(int), typeof(int), typeof(string[]), typeof(int), typeof(bool), typeof(bool) }, null), null);
}
il.Emit(OpCodes.Pop);
}
il.Emit(OpCodes.Dup);
// obj.SpriteIndex = ind;
il.Emit(OpCodes.Ldc_I4, res.Sprite);
il.EmitCall(OpCodes.Call, t_obj.GetProperty("SpriteIndex").GetSetMethod(), null);
//obj.Depth = d;
il.Emit(OpCodes.Ldc_R8, res.Depth);
il.EmitCall(OpCodes.Call, t_obj.GetProperty("Depth").GetSetMethod(), null);
}
il.Emit(OpCodes.Ret);
MethodBuilder defineRooms = program.DefineMethod("DefineRooms", MethodAttributes.Static);
il = defineRooms.GetILGenerator();
// Start defining rooms.
// We perform a 'preorder iterative traversal' of the 'Rooms' TreeNode to ensure the rooms are defined in the correct order.
// We can probably eliminate the stack by using the 'Parent' property of the nodes instead.
Stack <TreeNode> nodes = new Stack <TreeNode>();
nodes.Push(Rooms.Node);
while (nodes.Count != 0)
{
TreeNode tn = nodes.Pop();
if (tn.Tag.GetType() == typeof(RoomResourceView))
{
RoomResourceView res = (RoomResourceView)(tn.Tag);
// GameCreator.Runtime.Room.Define("name", index).CreationCode = "code";
il.EmitCall(OpCodes.Call, t_context.GetProperty("Current", BindingFlags.Public | BindingFlags.Static).GetGetMethod(), null);
il.EmitCall(OpCodes.Call, t_context.GetProperty("Resources", BindingFlags.Public | BindingFlags.Instance).GetGetMethod(), null);
il.EmitCall(OpCodes.Call, t_rcontext.GetProperty("Rooms", BindingFlags.Public | BindingFlags.Instance).GetGetMethod(), null);
il.Emit(OpCodes.Ldstr, res.Name);
il.Emit(OpCodes.Ldc_I4, res.ResourceID);
il.EmitCall(OpCodes.Call, t_ext.GetMethod("Define", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(IndexedResourceManager <Room>), typeof(string), typeof(int) }, null), null);
il.Emit(OpCodes.Ldstr, res.CreationCode);
il.EmitCall(OpCodes.Call, t_room.GetProperty("CreationCode").GetSetMethod(), null);
}
tn = tn.LastNode;
while (tn != null)
{
nodes.Push(tn);
tn = tn.PrevNode;
}
}
il.Emit(OpCodes.Ret);
MethodBuilder main = program.DefineMethod("Main", MethodAttributes.Static);
main.SetCustomAttribute(new CustomAttributeBuilder(typeof(STAThreadAttribute).GetConstructor(System.Type.EmptyTypes), new object[] { }));
il = main.GetILGenerator();
// GameCreator.Runtime.Game.Interpreted.InterpretedGame.Initialize();
il.EmitCall(OpCodes.Call, t_gamei.GetMethod("Initialize"), null);
// InitLibraries();
il.EmitCall(OpCodes.Call, initLibraries, null);
// DefineScripts();
il.EmitCall(OpCodes.Call, defineScripts, null);
// DefineSprites();
il.EmitCall(OpCodes.Call, defineSprites, null);
// DefineObjects();
il.EmitCall(OpCodes.Call, defineObjects, null);
// DefineRooms();
il.EmitCall(OpCodes.Call, defineRooms, null);
// GameCreator.Runtime.Game.Name = "name";
//il.Emit(OpCodes.Ldstr, asmname);
//il.EmitCall(OpCodes.Call, t_game.GetProperty("Name").GetSetMethod(), null);
// GameCreator.Runtime.Game.ResourceManager = GetResourceManager();
il.EmitCall(OpCodes.Call, GetResourceManager, null);
il.EmitCall(OpCodes.Call, t_game.GetProperty("ResourceManager").GetSetMethod(), null);
// GameCreator.Runtime.Game.Interpreted.InterpretedGame.Run();
il.EmitCall(OpCodes.Call, t_gamei.GetMethod("Run"), null);
// return statement, required
il.Emit(OpCodes.Ret);
program.CreateType();
asm.SetEntryPoint(main, PEFileKinds.WindowApplication);
// Use 32 bit (i386) since GTK# requires it and we plan on using it later
asm.Save(exename, PortableExecutableKinds.ILOnly, ImageFileMachine.I386);
return(asm);
}
public static void SetEntryPointForConsoleApplicationPortable(AssemblyBuilder assemblyBuilder, MethodInfo entryMethod)
{
assemblyBuilder.SetEntryPoint(entryMethod, PEFileKinds.ConsoleApplication);
}
private static void AddEntryPoint(AssemblyBuilder assemblyBuilder, ModuleBuilder moduleBuilder)
{
var typeBuilder = moduleBuilder.DefineType(
Guid.NewGuid().ToString("N"), TypeAttributes.Class | TypeAttributes.Public,
typeof(object));
var methodBuilder = typeBuilder.DefineMethod("Main",
MethodAttributes.HideBySig | MethodAttributes.Static | MethodAttributes.Public,
typeof(void), new Type[] { typeof(string[]) });
var methodGenerator = methodBuilder.GetILGenerator();
methodGenerator.EmitWriteLine("go!");
methodGenerator.Emit(OpCodes.Ret);
typeBuilder.CreateType();
assemblyBuilder.SetEntryPoint(methodBuilder);
}
public void GenerateExe()
{
string AssemblyName = "TestAssembly";
string ClassName = "TestClass";
string ExeName = ClassName + ".exe";
// 获得应用程序域，用于创建程序集。
domain = Thread.GetDomain();
// 创建程序集名称。
name = new AssemblyName();
name.Name = AssemblyName;
// 创建程序集。
asmbuilder = domain.DefineDynamicAssembly(name, AssemblyBuilderAccess.RunAndSave);
// 创建模块。
modbuilder = asmbuilder.DefineDynamicModule(ExeName);
// 创建类型。
typbuilder = modbuilder.DefineType(ClassName);
// 创建全局变量（类的静态变量）
fld = typbuilder.DefineField("haha", typeof(int), FieldAttributes.Static);
// 创建静态方法Add：public static int Add(int,int)
addBuilder = typbuilder.DefineMethod("Add", MethodAttributes.Public | MethodAttributes.Static, typeof(int), new Type[] { typeof(int), typeof(int) });
// 创建静态方法Add：public static int Fact(int)
factBuilder = typbuilder.DefineMethod("Fact", MethodAttributes.Public | MethodAttributes.Static, typeof(int), new Type[] { typeof(int) });
// 创建静态方法Main：public static void Main(string[])
mainBuilder = typbuilder.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static, typeof(void), new Type[] { typeof(string[]) });
// Add方法的代码生成器
iladd = addBuilder.GetILGenerator();
// 产生Add方法的代码
GenerateCodeForAdd();
// Fact方法的代码生成器
ilfact = factBuilder.GetILGenerator();
// 产生Fact方法的代码
GenerateCodeForFact();
// Main方法的代码生成器
ilmain = mainBuilder.GetILGenerator();
// 产生Main方法的代码。
GenerateCodeForMain();
// 类里所有东西都已经定义好了，现在要创建这个类。
typbuilder.CreateType();
// 设置入口点。
asmbuilder.SetEntryPoint((modbuilder.GetType(ClassName)).GetMethod("Main"));
// 保存到EXE文件。
asmbuilder.Save(ExeName);
}
private void SaveAssembly(
string fullyQualifiedModuleName,
AssemblyBuilder assemblyBuilder,
TypeBuilder typeBuilder)
{
Type NireType = typeBuilder.CreateType();
NireType.GetMethod("Main").Invoke(null, new string[] {null});
// set the entry point for the application and save it
assemblyBuilder.SetEntryPoint(this.methodbuilder, PEFileKinds.ConsoleApplication);
assemblyBuilder.Save(fullyQualifiedModuleName);
}