public override void Compile(CompileContext context) { foreach (Expression exp in ChildNodes) { exp.Compile(context); } context.ILGenerator.Emit(OpCodes.Newobj, _constructor); }
public override void Compile(CompileContext context) { ILGenerator il = context.ILGenerator; Left.Compile(context); if (Left is Variable) il.Emit(OpCodes.Unbox_Any, typeof(int)); Right.Compile(context); if (Right is Variable) il.Emit(OpCodes.Unbox_Any, typeof(int)); switch (this.Op) { case ArithmeticBinOp.Divide: il.Emit(OpCodes.Div); break; case ArithmeticBinOp.Minus: il.Emit(OpCodes.Sub_Ovf); break; case ArithmeticBinOp.Multiply: il.Emit(OpCodes.Mul_Ovf); break; case ArithmeticBinOp.Plus: il.Emit(OpCodes.Add_Ovf); break; case ArithmeticBinOp.Modulo: il.Emit(OpCodes.Rem); break; default: throw new Exception("Unknown arithmetic binary operation: " + this.Op); } }
public override void Compile(CompileContext context) { ILGenerator il = context.ILGenerator; Left.Compile(context); if (Left is Variable) il.Emit(OpCodes.Unbox_Any, typeof(int)); Right.Compile(context); if (Right is Variable) il.Emit(OpCodes.Unbox_Any, typeof(int)); switch (this.Op) { case RelationalBinOp.Equal: il.Emit(OpCodes.Ceq); break; case RelationalBinOp.NotEqual: il.Emit(OpCodes.Ceq); il.Emit(OpCodes.Ldc_I4_0); il.Emit(OpCodes.Ceq); break; case RelationalBinOp.GreaterThan: il.Emit(OpCodes.Cgt); break; case RelationalBinOp.LessThan: il.Emit(OpCodes.Clt); break; case RelationalBinOp.GreaterThanOrEqual: il.Emit(OpCodes.Clt); il.Emit(OpCodes.Ldc_I4_0); il.Emit(OpCodes.Ceq); break; case RelationalBinOp.LessThanOrEqual: il.Emit(OpCodes.Cgt); il.Emit(OpCodes.Ldc_I4_0); il.Emit(OpCodes.Ceq); break; default: throw new Exception("Unknown relational binary operation: " + this.Op); } }
public override void Compile(CompileContext context) { Type procType = typeof(ProcessBase); ILGenerator il = context.ILGenerator; EmitDebug("Preparing to sync now...", context); LocalBuilder syncObject = il.DeclareLocal(typeof(ChannelSyncAction)); il.Emit(OpCodes.Ldarg_0); //this il.Emit(OpCodes.Ldstr, Name); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldc_I4, _children.Count); il.Emit(OpCodes.Ldc_I4_0); il.Emit(OpCodes.Newobj, typeof(ChannelSyncAction).GetConstructor(new Type[] { typeof(string), typeof(ProcessBase), typeof(int), typeof(bool) })); il.Emit(OpCodes.Stloc, syncObject); //Now put the result of any expression we have into the sync objects foreach (Expression exp in _children) { il.Emit(OpCodes.Ldloc, syncObject); exp.Compile(context); if (exp is ArithmeticExpression || exp is MethodCallExpression) { il.Emit(OpCodes.Box, typeof(int)); } il.Emit(OpCodes.Call, typeof(ChannelSyncAction).GetMethod("AddValue")); } il.Emit(OpCodes.Ldloc, syncObject); il.Emit(OpCodes.Call, SyncMethod); //Do nothing here after. In an action class that actually does something we would //compile it here. context.MarkSequencePoint(this.LexicalInfo); }
public override void Compile(CompileContext context) { if (_value) { context.ILGenerator.Emit(OpCodes.Ldc_I4_1); } else { context.ILGenerator.Emit(OpCodes.Ldc_I4_0); } }
protected void OverridePreProcess(CompileContext context, MethodInfo newMethod) { MethodInfo baseGetPreProcess = typeof(ProcessBase).GetMethod("get_PreProcess"); MethodBuilder getPreProcess = context.Type.Builder.DefineMethod("get_PreProcess", MethodAttributes.Public | MethodAttributes.Virtual, typeof(PreProcessAction), new Type[] { }); ILGenerator il = getPreProcess.GetILGenerator(); il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Ldftn, newMethod); il.Emit(OpCodes.Newobj, typeof(PreProcessAction).GetConstructors()[0]); il.Emit(OpCodes.Ret); context.Type.Builder.DefineMethodOverride(getPreProcess, baseGetPreProcess); }
public override void Compile(CompileContext context) { string innerTypeName = "Repl_" + context.Type.Name; ILGenerator il = context.ILGenerator; TypeInfo newType = null; newType = Process.CompileNewProcessStart(context, innerTypeName); Process.Compile(context); Process.CompileNewProcessEnd(context); Label startLoop = il.DefineLabel(); il.MarkLabel(startLoop); LocalBuilder replCount = il.DeclareLocal(typeof(int)); //Give the replicated process the variables as they are at this point... foreach (string paramName in newType.ConstructorParameters) { il.Emit(OpCodes.Ldloc, context.Type.GetLocal(paramName)); } LocalBuilder loc = il.DeclareLocal(newType.Builder); il.Emit(OpCodes.Newobj, newType.Constructor); il.Emit(OpCodes.Stloc, loc); il.Emit(OpCodes.Ldloc, loc); //Set this process as the parent of the new proc, that allows it to activate this thread //again once it is past its first input action. il.Emit(OpCodes.Ldarg_0); //load the "this" pointer il.Emit(OpCodes.Call, MethodResolver.GetMethod(typeof(ProcessBase), "set_Parent")); //start the new instance of the replicated process il.Emit(OpCodes.Ldloc, loc); il.Emit(OpCodes.Call, MethodResolver.GetMethod(typeof(ProcessBase), "Run")); //Count how many we've emitted il.Emit(OpCodes.Ldloc, replCount); il.Emit(OpCodes.Ldc_I4_1); il.Emit(OpCodes.Add); il.Emit(OpCodes.Stloc, replCount); //Print that information. il.Emit(OpCodes.Ldstr, "Number of " + innerTypeName + " started: "); il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("Write", new Type[] {typeof(string)})); il.Emit(OpCodes.Ldloc, replCount); il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new Type[] {typeof(int)})); //Suspend ourselves, we will be woken up by the replicated process once it gets //past its first action... il.Emit(OpCodes.Call, typeof(Thread).GetMethod("get_CurrentThread")); il.Emit(OpCodes.Call, typeof(Thread).GetMethod("Suspend")); il.Emit(OpCodes.Br, startLoop); }
public override void Compile(CompileContext context) { if (_local != null) { context.ILGenerator.Emit(OpCodes.Ldloc, _local); } else { LocalBuilder local = context.Type.GetLocal(Name); if (local == null) { local = context.ILGenerator.DeclareLocal(typeof(object)); if (context.Options.Debug) { local.SetLocalSymInfo(Name); } context.Type.Locals.Add(Name, local); } context.ILGenerator.Emit(OpCodes.Ldloc, local); } }
public override void Compile(CompileContext context) { ILGenerator il = context.ILGenerator; Left.Compile(context); Right.Compile(context); switch (this.Op) { case LogicalBinOp.And: il.Emit(OpCodes.And); break; case LogicalBinOp.Or: il.Emit(OpCodes.Or); break; case LogicalBinOp.Xor: il.Emit(OpCodes.Xor); break; default: throw new Exception("Unknown logical binary operation: " + this.Op); } }
public override void Compile(CompileContext context) { if (_mapping.Count > 0) { MethodBuilder relabel = context.Type.Builder.DefineMethod("RelabelAction", MethodAttributes.Public | MethodAttributes.Static, typeof(IAction), new Type[] { typeof(IAction) }); ILGenerator il = relabel.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Isinst, typeof(ChannelSyncAction)); Label isChannelSync = il.DefineLabel(); il.Emit(OpCodes.Brtrue, isChannelSync); ////If not ChannelSync then return the passed in argument il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ret); il.MarkLabel(isChannelSync); LocalBuilder channel = il.DeclareLocal(typeof(ChannelSyncAction)); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Castclass, typeof(ChannelSyncAction)); il.Emit(OpCodes.Stloc, channel); Label end = il.DefineLabel(); //Now we've got a ChannelSync object foreach (string from in _mapping.Keys) { string to = _mapping[from]; //Check whether the key matches the current name il.Emit(OpCodes.Ldloc, channel); il.Emit(OpCodes.Call, typeof(ChannelSyncAction).GetMethod("get_Name")); il.Emit(OpCodes.Ldstr, from); il.Emit(OpCodes.Call, typeof(string).GetMethod("op_Equality")); Label nextCheck = il.DefineLabel(); il.Emit(OpCodes.Brfalse, nextCheck); il.Emit(OpCodes.Ldloc, channel); il.Emit(OpCodes.Ldstr, to); il.Emit(OpCodes.Call, typeof(ChannelSyncAction).GetMethod("set_Name")); il.Emit(OpCodes.Br, end); il.MarkLabel(nextCheck); } il.MarkLabel(end); il.Emit(OpCodes.Ldloc, channel); il.Emit(OpCodes.Ret); base.OverridePreProcess(context, relabel); } }
public override void Compile(CompileContext context) { Type procType = typeof(ProcessBase); ILGenerator il = context.ILGenerator; EmitDebug("Preparing to sync now...", context); il.Emit(OpCodes.Ldarg_0); //this, to call the Sync //Create methodcall sync object il.Emit(OpCodes.Ldstr, this.Name); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Newobj, typeof(MethodCallAction).GetConstructor(new Type[] { typeof(string), typeof(ProcessBase)})); //Call sync il.Emit(OpCodes.Call, SyncMethod); context.MarkSequencePoint(this.LexicalInfo); //Now compile the actual method call MethodCallExpr.Compile(context); }
public override void Compile(CompileContext context) { Type procType = typeof(ProcessBase); ILGenerator il = context.ILGenerator; EmitDebug("Preparing to sync now...", context); LocalBuilder syncObject = il.DeclareLocal(typeof(ChannelSyncAction)); il.Emit(OpCodes.Ldarg_0); //this il.Emit(OpCodes.Ldstr, Name); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldc_I4, _children.Count); il.Emit(OpCodes.Ldc_I4_1); il.Emit(OpCodes.Newobj, typeof(ChannelSyncAction).GetConstructor(new Type[] { typeof(string), typeof(ProcessBase), typeof(int), typeof(bool) })); il.Emit(OpCodes.Stloc, syncObject); il.Emit(OpCodes.Ldloc, syncObject); il.Emit(OpCodes.Call, SyncMethod); context.MarkSequencePoint(this.LexicalInfo); //Save values to variables for (int i = 0; i < _children.Count; i++) { Variable var = (Variable)_children[i]; if (context.Options.Optimize && !var.IsUsed) { continue; } //Get the value to assign to it... il.Emit(OpCodes.Ldloc, syncObject); il.Emit(OpCodes.Ldc_I4, i); il.Emit(OpCodes.Call, typeof(ChannelSyncAction).GetMethod("GetValue")); //...and assign it LocalBuilder local = context.Type.GetLocal(var.Name); if (local == null) { //Inactions can be defining occurrences, so just create it... local = context.ILGenerator.DeclareLocal(typeof(object)); if (context.Options.Debug) { local.SetLocalSymInfo(var.Name); } context.Type.Locals.Add(var.Name, local); } il.Emit(OpCodes.Stloc, local); } }
void CompileTupleSpaces(CompileContext context) { ILGenerator il = context.ILGenerator; LocalBuilder loc = il.DeclareLocal(typeof(Locality)); LocalBuilder arr = il.DeclareLocal(typeof(object[])); this.tuples.Sort(delegate(TupleInfo t1, TupleInfo t2) { return t1.Locality.CompareTo(t2.Locality); }); string lastLocality = ""; foreach (TupleInfo ti in this.tuples) { if (lastLocality != ti.Locality) { il.Emit(OpCodes.Ldstr, ti.Locality); il.Emit(OpCodes.Call, typeof(Net).GetMethod("AddLocality")); il.Emit(OpCodes.Stloc, loc); lastLocality = ti.Locality; } il.Emit(OpCodes.Ldc_I4, ti.Items.Count); il.Emit(OpCodes.Newarr, typeof(object)); il.Emit(OpCodes.Stloc, arr); for (int i = 0; i < ti.Items.Count; i++) { object elem = ti.Items[i]; il.Emit(OpCodes.Ldloc, arr); il.Emit(OpCodes.Ldc_I4, i); if (elem is int) { il.Emit(OpCodes.Ldc_I4, (int)elem); il.Emit(OpCodes.Box, typeof(int)); } else if (elem is string) { il.Emit(OpCodes.Ldstr, (string) elem); } il.Emit(OpCodes.Stelem_Ref); } il.Emit(OpCodes.Ldloc, loc); il.Emit(OpCodes.Ldloc, arr); il.Emit(OpCodes.Newobj, typeof(Tuple).GetConstructors()[0]); il.Emit(OpCodes.Call, typeof(Locality).GetMethod("Out")); } }
public override void Compile(CompileContext context) { List<Process> processes = this.Processes; for (int i = 0; i < processes.Count; i++) { Process p = processes[i]; string innerTypeName = "Parallel" + (i + 1); if (context.Options.Optimize && !p.IsUsed) { continue; } TypeInfo newProcType = null; if (p.HasRestrictionsOrPreProcess || !(p is ProcessConstant)) { newProcType = p.CompileNewProcessStart(context, innerTypeName); } p.Compile(context); if (newProcType != null) { p.CompileNewProcessEnd(context); EmitRunProcess(context, newProcType, false, p.LexicalInfo, true); } } }
public override void Compile(CompileContext context) { List<Process> processes = this.Processes; for (int i = 0; i < processes.Count; i++) { Process p = (Process)processes[i]; if (context.Options.Optimize && !p.IsUsed) { continue; } if (p is ProcessConstant && !p.HasRestrictionsOrPreProcess) { //Don't need to create a special proc just for wrapping this ProcessConstant pc = (ProcessConstant)p; EmitRunProcess(context, context.GetType(pc.Name), true, p.LexicalInfo, true); } else { string innerTypeName = "NonDeterministic" + (i + 1); TypeInfo newType = p.CompileNewProcessStart(context, innerTypeName); p.Compile(context); p.CompileNewProcessEnd(context); EmitRunProcess(context, newType, true, p.LexicalInfo, true); } } }
public override void Compile(CompileContext context) { if (_channelNames.Count > 0) { MethodBuilder restrict = context.Type.Builder.DefineMethod("RestrictByName", MethodAttributes.Public | MethodAttributes.Static, typeof(bool), new Type[] { typeof(IAction) }); ILGenerator il = restrict.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Isinst, typeof(ChannelSyncAction)); Label isChannelSync = il.DefineLabel(); il.Emit(OpCodes.Brtrue, isChannelSync); ////If not ChannelSync then return false il.Emit(OpCodes.Ldc_I4_0); il.Emit(OpCodes.Ret); il.MarkLabel(isChannelSync); LocalBuilder channel = il.DeclareLocal(typeof(ChannelSyncAction)); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Castclass, typeof(ChannelSyncAction)); il.Emit(OpCodes.Stloc, channel); //Now we've got a ChannelSync object foreach (string channelName in _channelNames) { il.Emit(OpCodes.Ldloc, channel); il.Emit(OpCodes.Call, typeof(ChannelSyncAction).GetMethod("get_Name")); il.Emit(OpCodes.Ldstr, channelName); il.Emit(OpCodes.Call, typeof(string).GetMethod("op_Equality")); } //Or them all together for (int i = 0; i < _channelNames.Count - 1; i++) { il.Emit(OpCodes.Or); } il.Emit(OpCodes.Ret); base.OverrideRestrict(context, restrict); } }
public override void Compile(CompileContext context) { if (context.Options.Optimize && !ElseBranch.IsUsed) { IfBranch.Compile(context); return; } else if (context.Options.Optimize && !IfBranch.IsUsed) { ElseBranch.Compile(context); return; } Label elseStart = context.ILGenerator.DefineLabel(); Label elseEnd = context.ILGenerator.DefineLabel(); context.MarkSequencePoint(Expression.LexicalInfo); this.Expression.Compile(context); context.ILGenerator.Emit(OpCodes.Brfalse, elseStart); IfBranch.Compile(context); context.ILGenerator.Emit(OpCodes.Br, elseEnd); context.ILGenerator.MarkLabel(elseStart); ElseBranch.Compile(context); context.ILGenerator.MarkLabel(elseEnd); if (context.Options.Debug && ElseBranch.LexicalInfo.EndLine != 0) { LexicalInfo l = ElseBranch.LexicalInfo; context.ILGenerator.MarkSequencePoint(context.DebugWriter, l.EndLine, l.EndColumn + 1, l.EndLine, l.EndColumn + 1); } }
public void Compile(CompileOptions options) { string absolutePath = Path.Combine(Environment.CurrentDirectory, options.OutputFile); string filename = Path.GetFileName(absolutePath); string folder = Path.GetDirectoryName(absolutePath); AssemblyName name = new AssemblyName(filename); AssemblyBuilder assembly = Thread.GetDomain().DefineDynamicAssembly(name, AssemblyBuilderAccess.Save, folder); ModuleBuilder module = assembly.DefineDynamicModule(options.OutputFile, filename, options.Debug); if (options.EmbedPLR) { EmbedAssembly(Assembly.GetExecutingAssembly()); } if (_embeddedAssemblies.Count > 0) { GenerateAssemblyLookup(module); } CompileContext context = new CompileContext(); context.Options = options; context.Module = module; MethodBuilder mainMethod = module.DefineGlobalMethod("Main", MethodAttributes.Public | MethodAttributes.Static, typeof(int), new Type[] { }); if (options.Debug) { context.DebugWriter = module.DefineDocument(options.Arguments[0], Guid.Empty, Guid.Empty, SymDocumentType.Text); module.SetUserEntryPoint(mainMethod); } context.Module = module; context.ImportedClasses = _importedClasses; if (BeforeCompile != null) { BeforeCompile(context); } foreach (ProcessDefinition procdef in this) { procdef.CompileSignature(module, context); } if (!context.ImportedClasses.Contains(typeof(PLR.Runtime.BuiltIns).FullName)) { context.ImportedClasses.Add(typeof(PLR.Runtime.BuiltIns).FullName); } context.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly()); if (options.References != "") { foreach (string assemblyName in options.References.Split(',')) { string absoluteAssemblyPath = Path.Combine(Directory.GetCurrentDirectory(), assemblyName); if (!File.Exists(absoluteAssemblyPath)) { Console.Error.WriteLine("Assembly '{0}' does not exist!", absoluteAssemblyPath); Environment.Exit(1); } context.ReferencedAssemblies.Add(Assembly.LoadFile(absoluteAssemblyPath)); } } foreach (ProcessDefinition procdef in this) { context.CurrentMasterType = null; procdef.Compile(context); context.CurrentMasterType = null; } List<LocalBuilder> initial = new List<LocalBuilder>(); context.PushIL(mainMethod.GetILGenerator()); if (MainMethodStart != null) { MainMethodStart(context); } foreach (ProcessDefinition procdef in this) { if (procdef.EntryProc) { TypeInfo startProc = context.GetType(procdef.FullName); LocalBuilder loc = context.ILGenerator.DeclareLocal(startProc.Builder); context.ILGenerator.Emit(OpCodes.Newobj, startProc.Constructor); context.ILGenerator.Emit(OpCodes.Stloc, loc); } } //Run Scheduler, who now knows all the new Processes CallScheduler("Run", true, context); if (MainMethodEnd!= null) { MainMethodEnd(context); } //return 0; context.ILGenerator.Emit(OpCodes.Ldc_I4_0); context.ILGenerator.Emit(OpCodes.Ret); if (AfterCompile != null) { AfterCompile(context); } module.CreateGlobalFunctions(); assembly.SetEntryPoint(mainMethod, PEFileKinds.ConsoleApplication); assembly.Save(filename); }
public override void Compile(CompileContext context) { }
private void GenerateAssemblyLookup(ModuleBuilder module) { if (_embeddedAssemblies.Count == 0) { return; } foreach (Assembly ass in _embeddedAssemblies) { string shortname = ass.FullName.Substring(0, ass.FullName.IndexOf(",")); string tempfile = Path.GetTempFileName(); File.Copy(new Uri(ass.EscapedCodeBase).LocalPath, tempfile, true); MemoryStream ms = new MemoryStream(File.ReadAllBytes(tempfile)); ms.Seek(0, SeekOrigin.Begin); module.DefineManifestResource(shortname, ms, ResourceAttributes.Public); File.Delete(tempfile); } MethodBuilder resolveAssemblyMethod = module.DefineGlobalMethod("ResolveAssembly", MethodAttributes.Public | MethodAttributes.Static, typeof(Assembly), new Type[] { typeof(object), typeof(System.ResolveEventArgs) }); ILGenerator ilResolve = resolveAssemblyMethod.GetILGenerator(); CompileContext resolvecontext = new CompileContext(); resolvecontext.PushIL(ilResolve); LocalBuilder localStream = ilResolve.DeclareLocal(typeof(Stream)); LocalBuilder localBuf = ilResolve.DeclareLocal(typeof(byte[])); LocalBuilder localName = ilResolve.DeclareLocal(typeof(string)); ilResolve.Emit(OpCodes.Ldarg_1); ilResolve.Emit(OpCodes.Call, typeof(ResolveEventArgs).GetMethod("get_Name")); ilResolve.Emit(OpCodes.Stloc, localName); ilResolve.Emit(OpCodes.Ldloc, localName); ilResolve.Emit(OpCodes.Ldc_I4_0); ilResolve.Emit(OpCodes.Ldloc, localName); ilResolve.Emit(OpCodes.Ldstr, ","); ilResolve.Emit(OpCodes.Call, typeof(string).GetMethod("IndexOf", new Type[] { typeof(string) })); ilResolve.Emit(OpCodes.Call, typeof(string).GetMethod("Substring", new Type[] { typeof(int), typeof(int) })); ilResolve.Emit(OpCodes.Stloc, localName); Assign(localStream, Call(Call(typeof(Assembly), "GetExecutingAssembly", false), "GetManifestResourceStream", false, localName), resolvecontext); Label notNull = ilResolve.DefineLabel(); ilResolve.Emit(OpCodes.Ldloc, localStream); ilResolve.Emit(OpCodes.Brtrue, notNull); { //Not found, just return null ilResolve.Emit(OpCodes.Ldnull); ilResolve.Emit(OpCodes.Ret); } ilResolve.MarkLabel(notNull); Call(localStream, "get_Length", false).Compile(resolvecontext); ilResolve.Emit(OpCodes.Conv_Ovf_I); ilResolve.Emit(OpCodes.Newarr, typeof(System.Byte)); ilResolve.Emit(OpCodes.Stloc, localBuf); ilResolve.Emit(OpCodes.Ldloc, localStream); ilResolve.Emit(OpCodes.Ldloc, localBuf); ilResolve.Emit(OpCodes.Ldc_I4_0); ilResolve.Emit(OpCodes.Ldloc, localBuf); ilResolve.Emit(OpCodes.Ldlen); ilResolve.Emit(OpCodes.Conv_I4); ilResolve.Emit(OpCodes.Callvirt, typeof(Stream).GetMethod("Read", new Type[] { typeof(byte[]), typeof(int), typeof(int) })); ilResolve.Emit(OpCodes.Pop); //Notify that we loaded this embedded... ilResolve.Emit(OpCodes.Ldarg_1); ilResolve.Emit(OpCodes.Call, typeof(ResolveEventArgs).GetMethod("get_Name")); ilResolve.Emit(OpCodes.Ldstr, " was not found externally, loading embedded version..."); ilResolve.Emit(OpCodes.Call, typeof(string).GetMethod("Concat", new Type[] { typeof(string), typeof(string) })); ilResolve.Emit(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new Type[] { typeof(string) })); Call(typeof(Assembly), "Load", false, localBuf).Compile(resolvecontext); ilResolve.Emit(OpCodes.Ret); resolvecontext.PopIL(); MethodBuilder moduleInitializer = module.DefineGlobalMethod(".cctor", MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.RTSpecialName, null, new Type[] { }); ILGenerator ilStartup = moduleInitializer.GetILGenerator(); ilStartup.Emit(OpCodes.Call, typeof(System.AppDomain).GetMethod("get_CurrentDomain")); ilStartup.Emit(OpCodes.Ldnull); ilStartup.Emit(OpCodes.Ldftn, resolveAssemblyMethod); ilStartup.Emit(OpCodes.Newobj, MethodResolver.GetConstructor(typeof(System.ResolveEventHandler))); ilStartup.Emit(OpCodes.Callvirt, MethodResolver.GetMethod(typeof(System.AppDomain), "add_AssemblyResolve")); ilStartup.Emit(OpCodes.Ret); }
public void CompileNewProcessEnd(CompileContext context) { if (this.WrapInTryCatch) { context.ILGenerator.BeginCatchBlock(typeof(ProcessKilledException)); context.ILGenerator.Emit(OpCodes.Pop); //Pop the exception off the stack EmitDebug("Caught ProcessKilledException", context); //Just catch here to abort, don't do anything context.ILGenerator.EndExceptionBlock(); } Call(new ThisPointer(typeof(ProcessBase)), "Die", true).Compile(context); context.ILGenerator.Emit(OpCodes.Ret); context.Type.Builder.CreateType(); context.PopType(); context.PopIL(); }
public override void Compile(CompileContext context) { Type[] argtypes = GetArgTypes(); if (_method == null) { _method = context.GetMethod(_methodName, argtypes); } if (_instance != null) { _instance.Compile(context); } ParameterInfo[] actualParams = _method.GetParameters(); for (int i = 0 ; i< ChildNodes.Count; i++) { Expression exp = (Expression)ChildNodes[i]; exp.Compile(context); if (exp.Type.Equals(typeof(int)) && actualParams[i].ParameterType.Equals(typeof(object))) { context.ILGenerator.Emit(OpCodes.Box, typeof(int)); } if (exp is Variable) { context.ILGenerator.Emit(OpCodes.Unbox_Any, typeof(int)); } } if (_method.IsVirtual) { context.ILGenerator.Emit(OpCodes.Callvirt, _method); } else { context.ILGenerator.Emit(OpCodes.Call, _method); } if (PopReturnValue && _method.ReturnType != typeof(void)) { context.ILGenerator.Emit(OpCodes.Pop); } }
public override void Compile(CompileContext context) { foreach (Expression exp in this.Expressions) { exp.Compile(context); if (exp is ArithmeticExpression) { context.ILGenerator.Emit(OpCodes.Box, typeof(Int32)); } } context.MarkSequencePoint(this.LexicalInfo); EmitRunProcess(context, context.GetType(this.FullName), false, LexicalInfo, false); }
public override void Compile(CompileContext context) { context.ILGenerator.Emit(OpCodes.Ldstr, _value); }
public override void Compile(CompileContext context) { _exp.Compile(context); if (_exp is Variable) context.ILGenerator.Emit(OpCodes.Unbox_Any, typeof(int)); context.ILGenerator.Emit(OpCodes.Neg); }
public override void Compile(CompileContext context) { Type procType = typeof(ProcessBase); ILGenerator il = context.ILGenerator; EmitDebug("Preparing to sync now...", context); LocalBuilder syncObject = il.DeclareLocal(typeof(KLAIMAction)); il.Emit(OpCodes.Ldarg_0); //this il.Emit(OpCodes.Ldarg_0); //this il.Emit(OpCodes.Ldstr, this.ToString()); il.Emit(OpCodes.Newobj, typeof(KLAIMAction).GetConstructors()[0]); il.Emit(OpCodes.Call, SyncMethod); //..and here we actually do something... context.MarkSequencePoint(this.LexicalInfo); if (this.At is PLRString && ((PLRString)this.At).Value == "Screen") { CompileOutAtScreen(context); return; } LocalBuilder loc = il.DeclareLocal(typeof(Locality)); LocalBuilder arr = il.DeclareLocal(typeof(object[])); if (this.At is Variable && ((Variable)this.At).Name == "self") { il.Emit(OpCodes.Ldstr, this.Locality); } else { this.At.Compile(context); } il.Emit(OpCodes.Call, typeof(Net).GetMethod("GetLocality")); il.Emit(OpCodes.Stloc, loc); il.Emit(OpCodes.Ldc_I4, this.ChildNodes.Count-1); il.Emit(OpCodes.Newarr, typeof(object)); il.Emit(OpCodes.Stloc, arr); for (int i = 1; i < this.ChildNodes.Count; i++) { Node node = this.ChildNodes[i]; il.Emit(OpCodes.Ldloc, arr); il.Emit(OpCodes.Ldc_I4, i-1); node.Compile(context); if (node is ArithmeticExpression) { il.Emit(OpCodes.Box, typeof(int)); } il.Emit(OpCodes.Stelem_Ref); } //Create the Tuple from the array LocalBuilder tuple = il.DeclareLocal(typeof(Tuple)); il.Emit(OpCodes.Ldloc, arr); il.Emit(OpCodes.Newobj, typeof(Tuple).GetConstructor(new Type[] { typeof(object[]) })); il.Emit(OpCodes.Stloc, tuple); il.Emit(OpCodes.Ldloc, loc); il.Emit(OpCodes.Ldloc, tuple); il.Emit(OpCodes.Call, typeof(Locality).GetMethod("Out")); //Now lets print out the net for fun... il.EmitWriteLine("************** CURRENT TUPLES **************"); il.Emit(OpCodes.Call, typeof(Net).GetMethod("Display")); il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new Type[] {typeof(string)})); }
private void CompileOutAtScreen(CompileContext context) { ILGenerator il = context.ILGenerator; LocalBuilder builder = il.DeclareLocal(typeof(StringBuilder)); il.Emit(OpCodes.Newobj, typeof(StringBuilder).GetConstructor(new Type[] { })); il.Emit(OpCodes.Stloc, builder); for (int i = 1; i < this.ChildNodes.Count;i++ ) { Node node = this.ChildNodes[i]; il.Emit(OpCodes.Ldloc, builder); node.Compile(context); if (node is ArithmeticExpression) { il.Emit(OpCodes.Box, typeof(int)); } il.Emit(OpCodes.Call, typeof(StringBuilder).GetMethod("Append", new Type[] { typeof(object) })); if (i != ChildNodes.Count - 1) { il.Emit(OpCodes.Ldloc, builder); il.Emit(OpCodes.Ldstr, ", "); il.Emit(OpCodes.Call, typeof(StringBuilder).GetMethod("Append", new Type[] { typeof(string) })); } } il.Emit(OpCodes.Ldloc, builder); il.Emit(OpCodes.Call, typeof(StringBuilder).GetMethod("ToString", new Type[]{})); il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new Type[] { typeof(string) })); }
public override void Compile(CompileContext context) { context.ILGenerator.Emit(OpCodes.Ldnull); }
public override void Compile(CompileContext context) { Type procType = typeof(ProcessBase); ILGenerator il = context.ILGenerator; EmitDebug("Preparing to sync now...", context); LocalBuilder syncObject = il.DeclareLocal(typeof(KLAIMAction)); il.Emit(OpCodes.Ldarg_0); //this il.Emit(OpCodes.Ldarg_0); //this il.Emit(OpCodes.Ldstr, this.ToString()); il.Emit(OpCodes.Newobj, typeof(KLAIMAction).GetConstructors()[0]); il.Emit(OpCodes.Call, SyncMethod); //..and here we actually do something... context.MarkSequencePoint(this.LexicalInfo); LocalBuilder loc = il.DeclareLocal(typeof(Locality)); LocalBuilder arr = il.DeclareLocal(typeof(object[])); LocalBuilder tuple = il.DeclareLocal(typeof(Tuple)); if (this.At is Variable && ((Variable)this.At).Name == "self") { il.Emit(OpCodes.Ldstr, this.Locality); } else { this.At.Compile(context); } il.Emit(OpCodes.Call, typeof(Net).GetMethod("GetLocality")); il.Emit(OpCodes.Stloc, loc); il.Emit(OpCodes.Ldc_I4, this.ChildNodes.Count - 1); il.Emit(OpCodes.Newarr, typeof(object)); il.Emit(OpCodes.Stloc, arr); for (int i = 1; i < this.ChildNodes.Count; i++) { Node node = this.ChildNodes[i]; il.Emit(OpCodes.Ldloc, arr); il.Emit(OpCodes.Ldc_I4, i - 1); node.Compile(context); if (node is ArithmeticExpression) { il.Emit(OpCodes.Box, typeof(int)); } il.Emit(OpCodes.Stelem_Ref); } il.Emit(OpCodes.Ldloc, loc); il.Emit(OpCodes.Ldloc, arr); il.Emit(OpCodes.Call, typeof(Locality).GetMethod(_methodName)); //We might be blocked at this location for a very long time... il.Emit(OpCodes.Stloc, tuple); //Now lets bind our variables... if they are used in the process for (int i = 1; i < this.ChildNodes.Count; i++) { if (_children[i] is VariableBinding) { VariableBinding var = (VariableBinding)_children[i]; if (context.Options.Optimize && !var.IsUsed) { continue; } //Get the value to assign to it... il.Emit(OpCodes.Ldloc, tuple); il.Emit(OpCodes.Ldc_I4, i - 1); il.Emit(OpCodes.Call, typeof(Tuple).GetMethod("GetValueAt")); //...and assign it LocalBuilder bindLoc = context.Type.GetLocal(var.Name); if (bindLoc == null) { bindLoc = il.DeclareLocal(typeof(object)); context.Type.Locals.Add(var.Name, bindLoc); if (context.Options.Debug) { bindLoc.SetLocalSymInfo(var.Name); } } il.Emit(OpCodes.Stloc, bindLoc); } } //Ok, we got past the input action. If our parent is not null then we are a replicated //process and should notify our parent that we have really started. Label noParent = il.DefineLabel(); il.Emit(OpCodes.Ldarg_0); //Load the "this" pointer il.Emit(OpCodes.Call, typeof(ProcessBase).GetMethod("get_Parent")); il.Emit(OpCodes.Brfalse, noParent); { il.Emit(OpCodes.Ldarg_0); //Load the "this" pointer il.Emit(OpCodes.Call, typeof(ProcessBase).GetMethod("get_Parent")); il.Emit(OpCodes.Call, typeof(ProcessBase).GetMethod("get_Thread")); //find our parent thread il.Emit(OpCodes.Call, typeof(Thread).GetMethod("Resume")); //Now we've woken up our parent. Set the Parent property to null, so it doesn't get passed //on to the rest of this process, KLAIM has no need for the Parent and passing it on might //lead to later in actions spawning extra instances of the replicated process. il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Call, typeof(ProcessBase).GetMethod("set_Parent")); } il.MarkLabel(noParent); //Now lets print out the net for fun... il.EmitWriteLine("************** CURRENT TUPLES **************"); il.Emit(OpCodes.Call, typeof(Net).GetMethod("Display")); il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new Type[] { typeof(string) })); //TODO: Notify possible replicated process }
public override void Compile(CompileContext context) { MethodInfo newMethod = context.GetMethod(_methodName); base.OverridePreProcess(context, newMethod); }