public CompilerState (PFunction source, Engine targetEngine, ILGenerator il, CompilerPass pass, FunctionLinking linking) { if (source == null) throw new ArgumentNullException("source"); if (targetEngine == null) throw new ArgumentNullException("targetEngine"); if (il == null) throw new ArgumentNullException("il"); _source = source; _linking = linking; _pass = pass; _targetEngine = targetEngine; _il = il; _indexMap = new Dictionary<int, string>(); _instructionLabels = new Label[Source.Code.Count + 1]; for (var i = 0; i < InstructionLabels.Length; i++) InstructionLabels[i] = il.DefineLabel(); _returnLabel = il.DefineLabel(); _symbols = new SymbolTable<CilSymbol>(); _tryBlocks = new Stack<CompiledTryCatchFinallyBlock>(); MetaEntry cilHints; _foreachHints = new List<ForeachHint>(); _cilExtensionOffsets = new Queue<int>(); if (source.Meta.TryGetValue(Loader.CilHintsKey, out cilHints)) { SortedSet<int> cilExtensionOffsets = null; foreach (var entry in cilHints.List) { var hint = entry.List; if (hint.Length < 1) continue; switch (hint[0].Text) { case CilExtensionHint.Key: if (cilExtensionOffsets == null) cilExtensionOffsets = new SortedSet<int>(); var cilExt = CilExtensionHint.FromMetaEntry(hint); foreach (var offset in cilExt.Offsets) cilExtensionOffsets.Add(offset); break; case ForeachHint.Key: _ForeachHints.Add(ForeachHint.FromMetaEntry(hint)); break; } } if (cilExtensionOffsets != null) { foreach (var offset in cilExtensionOffsets) _cilExtensionOffsets.Enqueue(offset); } } _seh = new StructuredExceptionHandling(this); _stackSize = new int[source.Code.Count]; }
public CompilerPass(Application app, FunctionLinking linking) : this( app, (linking & FunctionLinking.AvailableForLinking) == FunctionLinking.AvailableForLinking) { }
public static void Compile(StackContext sctx, List<PValue> lst, FunctionLinking linking) { if (lst == null) throw new ArgumentNullException("lst"); if (sctx == null) throw new ArgumentNullException("sctx"); var functions = new List<PFunction>(); foreach (var value in lst) { if (value == null) continue; var T = value.Type.ToBuiltIn(); PFunction func; switch (T) { case PType.BuiltIn.String: if ( !sctx.ParentApplication.Functions.TryGetValue((string) value.Value, out func)) continue; break; case PType.BuiltIn.Object: if (!value.TryConvertTo(sctx, false, out func)) continue; break; default: continue; } functions.Add(func); } Compile(functions, sctx.ParentEngine, linking); }
public CompilerPass(FunctionLinking linking) : this(null, linking) { }
public static void Compile(StackContext sctx, Application app, FunctionLinking linking) { if (sctx == null) throw new ArgumentNullException("sctx"); Compile(app, sctx.ParentEngine, linking); }
public static void Compile(Application app, Engine targetEngine, FunctionLinking linking) { if (app == null) throw new ArgumentNullException("app"); Compile(app.Functions, targetEngine, linking); }
private static void _compile (PFunction source, ILGenerator il, Engine targetEngine, CompilerPass pass, FunctionLinking linking) { var state = new CompilerState(source, targetEngine, il, pass, linking); //Every cil implementation needs to instantiate a CilFunctionContext and assign PValue.Null to the result. _emitCilImplementationHeader(state); //Reads the functions metadata about parameters, local variables and shared variables. //initializes shared variables. _buildSymbolTable(state); //CODE ANALYSIS // - determine number of temporary variables // - find variable references (alters the symbol table) // - determine stack size at all offsets _analysisAndPreparation(state); //Create and initialize local variables for parameters _parseParameters(state); //Shared variables and parameters have already been initialized // this method initializes (PValue.Null) the rest. _createAndInitializeRemainingLocals(state); //Emits IL for the functions Prexonite byte code. _emitInstructions(state); }
public static bool TryCompile(PFunction func, Engine targetEngine, FunctionLinking linking) { if (_checkQualification(func, targetEngine)) { var pass = new CompilerPass(func.ParentApplication, linking); var m = pass.DefineImplementationMethod(func.Id); var il = CompilerPass.GetIlGenerator(m); _compile(func, il, targetEngine, pass, linking); func.Declaration.CilImplementation = pass.GetDelegate(m); pass.LinkMetadata(func); return true; } return false; }
public static void Compile(IEnumerable<PFunction> functions, Engine targetEngine, FunctionLinking linking) { _checkQualification(functions, targetEngine); var qfuncs = new List<PFunction>(); //Get a list of qualifying functions foreach (var func in functions) if (!func.Meta.GetDefault(PFunction.VolatileKey, false)) qfuncs.Add(func); if (qfuncs.Count == 0) return; //No compilation to be done var pass = new CompilerPass(linking); //Generate method stubs foreach (var func in qfuncs) pass.DefineImplementationMethod(func.Id); //Emit IL foreach (var func in qfuncs) { _compile(func, CompilerPass.GetIlGenerator(pass.Implementations[func.Id]), targetEngine, pass, linking); } //Enable by name linking and link meta data to CIL implementations foreach (var func in qfuncs) { func.Declaration.CilImplementation = pass.GetDelegate(func.Id); pass.LinkMetadata(func); } }