} // func CompileChunk /// <summary>Create a code delegate without executing it.</summary> /// <param name="code">Code of the delegate..</param> /// <param name="options">Options for the compile process.</param> /// <param name="args">Arguments for the code block.</param> /// <returns>Compiled chunk.</returns> public LuaChunk CompileChunk(ILuaLexer code, LuaCompileOptions options, params KeyValuePair <string, Type>[] args) { if (code == null) { throw new ArgumentNullException(nameof(code)); } return(CompileChunkCore(code, options, args)); } // func CompileChunk
} // func CompileChunk /// <summary>Create a code delegate without executing it.</summary> /// <param name="code">Code of the delegate..</param> /// <param name="name">Name of the delegate</param> /// <param name="options">Options for the compile process.</param> /// <param name="args">Arguments for the code block.</param> /// <returns>Compiled chunk.</returns> public LuaChunk CompileChunk(string code, string name, LuaCompileOptions options, params KeyValuePair <string, Type>[] args) { if (String.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } using (var lex = LuaLexer.Create(name, new StringReader(code))) return(CompileChunkCore(lex, options, args)); } // func CompileChunk
} // func CompileChunk /// <summary>Creates a code delegate or returns a single return constant.</summary> /// <param name="code"></param> /// <param name="options"></param> /// <param name="args"></param> /// <returns></returns> public object CompileOrReturnPrint(ILuaLexer code, LuaCompileOptions options, params KeyValuePair <string, Type>[] args) { if (IsConstantScript(code)) // eof { return(code.LookAhead.Typ == LuaToken.String ? code.LookAhead.Value : ParseNumber(code.LookAhead.Value)); } else { return(CompileChunkCore(code, options, args)); } } // func CompileOrReturnPrint
} // func CompileChunk internal LuaChunk CompileChunk(string sChunkName, LuaCompileOptions options, TextReader tr, IEnumerable <KeyValuePair <string, Type> > args) { if (String.IsNullOrEmpty(sChunkName)) { throw new ArgumentNullException("chunkname"); } if (options == null) { options = new LuaCompileOptions(); } using (LuaLexer l = new LuaLexer(sChunkName, tr)) { bool lRegisterMethods = options.DebugEngine != null && (options.DebugEngine.Level & LuaDebugLevel.RegisterMethods) == LuaDebugLevel.RegisterMethods; if (lRegisterMethods) { BeginCompile(); } try { LambdaExpression expr = Parser.ParseChunk(this, options, true, l, null, typeof(LuaResult), args); if (printExpressionTree != null) { printExpressionTree.WriteLine(Parser.ExpressionToString(expr)); printExpressionTree.WriteLine(new string('=', 79)); } // compile the chunk if (options.DebugEngine == null) { return(new LuaChunk(this, expr.Name, expr.Compile())); } else { return(options.DebugEngine.CreateChunk(this, expr)); } } finally { if (lRegisterMethods) { EndCompile(); } } } } // func CompileChunk
} // func IsConstantScript internal LuaChunk CompileChunkCore(ILuaLexer lex, LuaCompileOptions options, IEnumerable <KeyValuePair <string, Type> > args) { if (options == null) { options = new LuaCompileOptions(); } var registerMethods = options.DebugEngine != null && (options.DebugEngine.Level & LuaDebugLevel.RegisterMethods) == LuaDebugLevel.RegisterMethods; if (registerMethods) { BeginCompile(); } try { var expr = Parser.ParseChunk(this, options, true, lex, null, typeof(LuaResult), args); if (printExpressionTree != null) { printExpressionTree.WriteLine(Parser.ExpressionToString(expr)); printExpressionTree.WriteLine(new string('=', 79)); } // compile the chunk return(options.DebugEngine == null ? new LuaChunk(this, expr.Name, expr.Compile()) : options.DebugEngine.CreateChunk(this, expr)); } finally { if (registerMethods) { EndCompile(); } } } // func CompileChunkCore
/// <summary>Create a code delegate without executing it.</summary> /// <param name="fileName">File to parse.</param> /// <param name="options">Options for the compile process.</param> /// <param name="args">Arguments for the code block.</param> /// <returns>Compiled chunk.</returns> public LuaChunk CompileChunk(string fileName, LuaCompileOptions options, params KeyValuePair <string, Type>[] args) { using (var sr = new StreamReader(fileName)) using (var lex = LuaLexer.Create(Path.GetFileName(fileName), sr, true)) return(CompileChunkCore(lex, options, args)); } // func CompileChunk
} // func CompileChunk /// <summary>Erzeugt ein Delegate aus dem Code, ohne ihn auszuführen.</summary> /// <param name="sCode">Code, der das Delegate darstellt.</param> /// <param name="sName">Name des Delegates</param> /// <param name="options">Options for the compile process.</param> /// <param name="args">Argumente</param> /// <returns>Compiled chunk.</returns> public LuaChunk CompileChunk(string sCode, string sName, LuaCompileOptions options, params KeyValuePair <string, Type>[] args) { return(CompileChunk(sName, options, new StringReader(sCode), args)); } // func CompileChunk
} // func CreateEnvironment #endregion #region -- Compile ---------------------------------------------------------------- /// <summary>Erzeugt ein Delegate aus dem Code, ohne ihn auszuführen.</summary> /// <param name="tr">Inhalt</param> /// <param name="sName">Name der Datei</param> /// <param name="options">Options for the compile process.</param> /// <param name="args">Parameter für den Codeblock</param> /// <returns>Compiled chunk.</returns> public LuaChunk CompileChunk(TextReader tr, string sName, LuaCompileOptions options, params KeyValuePair <string, Type>[] args) { return(CompileChunk(sName, options, tr, args)); } // func CompileChunk
/// <summary>Create a code delegate without executing it.</summary> /// <param name="code">Code of the delegate..</param> /// <param name="name">Name of the delegate</param> /// <param name="options">Options for the compile process.</param> /// <param name="args">Arguments for the code block.</param> /// <returns>Compiled chunk.</returns> public LuaChunk CompileChunk(string code, string name, LuaCompileOptions options, params KeyValuePair <string, Type>[] args) => CompileChunk(name, options, new StringReader(code), args);
} // func CompileChunk /// <summary>Create a code delegate without executing it.</summary> /// <param name="tr">Inhalt</param> /// <param name="name">Name der Datei</param> /// <param name="options">Options for the compile process.</param> /// <param name="args">Arguments for the code block.</param> /// <returns>Compiled chunk.</returns> public LuaChunk CompileChunk(TextReader tr, string name, LuaCompileOptions options, params KeyValuePair <string, Type>[] args) => CompileChunk(name, options, tr, args);
/// <summary>Create a code delegate without executing it.</summary> /// <param name="fileName">File to parse.</param> /// <param name="options">Options for the compile process.</param> /// <param name="args">Arguments for the code block.</param> /// <returns>Compiled chunk.</returns> public LuaChunk CompileChunk(string fileName, LuaCompileOptions options, params KeyValuePair <string, Type>[] args) { using (var sr = new StreamReader(fileName)) return(CompileChunk(Path.GetFileName(fileName), options, sr, args)); } // func CompileChunk
/// <summary>Erzeugt ein Delegate aus dem Code, ohne ihn auszuführen.</summary> /// <param name="lua"></param> /// <param name="sFileName">Dateiname die gelesen werden soll.</param> /// <param name="options">Options for the compile process.</param> /// <param name="args">Parameter für den Codeblock</param> /// <returns>Compiled chunk.</returns> public static LuaChunk CompileChunk(this Lua lua, string sFileName, LuaCompileOptions options, params KeyValuePair <string, Type>[] args) { using (StreamReader sr = new StreamReader(sFileName)) return(lua.CompileChunk(sr, Path.GetFileName(sFileName), options, args)); } // func CompileChunk