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); } }
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) { 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)})); }
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 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) { 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) { context.MarkSequencePoint(LexicalInfo); EmitDebug("Turned into 0", context); }