private object LuaLoad(object ld, string source, string mode, LuaTable env)
{
if (String.IsNullOrEmpty(source))
{
source = "=(load)";
}
if (mode == "b" || !(ld is string || ld is LuaMethod || ld is Delegate)) // binary chunks are not implementeted
{
throw new NotImplementedException();
}
try
{
// collect the chunks
if (Lua.RtInvokeable(ld))
{
StringBuilder sbCode = new StringBuilder();
string sPart;
while (!String.IsNullOrEmpty(sPart = (string)new LuaResult(RtInvokeSite(ld))[0]))
{
sbCode.Append(sPart);
}
ld = sbCode.ToString();
}
// create the chunk
return(LuaLoadReturn(Lua.CompileChunk((string)ld, source, null), env));
}
catch (Exception e)
{
return(new LuaResult(null, e.Message));
}
} // func LuaLoad
private object LuaLoadFile(string filename, string mode, LuaTable env)
{
if (mode == "b") // binary chunks are not implementeted
{
throw new NotImplementedException();
}
// create the chunk
return(LuaLoadReturn(Lua.CompileChunk(filename, null), env));
} // func LuaLoadFile
private object LuaLoadFile(string filename, string mode, LuaTable env)
{
if (mode == "b") // binary chunks are not implementeted
{
throw new NotImplementedException();
}
// create the chunk
return(LuaLoadReturn(Lua.CompileChunk(filename, null, new KeyValuePair <string, Type>("...", typeof(object[]))), env));
} // func LuaLoadFile
/// <summary>
/// Runs a block of Lua code from a string.
/// </summary>
/// <param name="block">The code to run.</param>
/// <param name="env">The Lua environment to run it in.</param>
/// <returns>The script's return value, or False if an error occurred.</returns>
public static LuaResult Run(string block, LuaGlobal env = null)
{
if (env == null)
{
env = Environment;
}
// Do we have this chunk cached? If so, use that version.
var hash = block.GetHashCode();
var useCache = false;
LuaChunk compiledChunk = null;
if (LuaCache.ContainsKey(hash))
{
compiledChunk = LuaCache[hash];
useCache = true;
}
else
{
// Attempt to compile and add it to the cache.
try
{
compiledChunk = IronLua.CompileChunk(block, "lol.lua", null);
useCache = true;
LuaCache.Add(hash, compiledChunk);
}
catch (LuaException pax)
{
//Wrap it up in a normal Exception that our custom handler can then unwrap, so we can show the context in a nice way.
throw new Exception("Lua parse error while trying to run this chunk:" + System.Environment.NewLine + PrepareParseError(block, pax.Line, pax.Column) + System.Environment.NewLine + pax.Message, pax);
}
}
// TODO: It failed to compile? Run interpreted and hope for useful information
LuaResult ret = null;
try
{
if (useCache)
{
ret = env.DoChunk(compiledChunk);
}
else
{
ret = env.DoChunk(block, "lol.lua");
}
}
catch (LuaException pax)
{
//Wrap it up in a normal Exception that our custom handler can then unwrap, so we can show the context in a nice way.
throw new Exception("Lua parse error while trying to run this chunk:" + System.Environment.NewLine + PrepareParseError(block, pax.Line, pax.Column) + System.Environment.NewLine + pax.Message, pax);
}
return(ret);
}
} // func DoChunk
private LuaResult DoChunk(string sChunkName, TextReader tr, KeyValuePair <string, object>[] args)
{
// Erzeuge die Parameter
object[] callArgs;
KeyValuePair <string, Type>[] callTypes;
if (args != null)
{
callArgs = new object[args.Length];
callTypes = new KeyValuePair <string, Type> [args.Length];
for (int i = 0; i < args.Length; i++)
{
callArgs[i] = args[i].Value;
callTypes[i] = new KeyValuePair <string, Type>(args[i].Key, args[i].Value == null ? typeof(object) : args[i].Value.GetType());
}
}
else
{
callArgs = new object[0];
callTypes = new KeyValuePair <string, Type> [0];
}
// Führe den Block aus
return(DoChunk(lua.CompileChunk(sChunkName, null, tr, callTypes), callArgs));
} // func DoChunk
public bool Initialize(string taskName, IDictionary <string, TaskPropertyInfo> parameterGroup, string taskBody, IBuildEngine taskFactoryLoggingHost)
{
TaskLoggingHelper log = new TaskLoggingHelper(taskFactoryLoggingHost, taskName);
// We use the property group for the declaration
taskProperties = (from c in parameterGroup select c.Value).ToArray();
// Compile chunk
try
{
log.LogMessage("Compile script.");
task = lua.CompileChunk(taskBody, taskName, Lua.DefaultDebugEngine,
new KeyValuePair <string, Type>("engine", typeof(IBuildEngine)),
new KeyValuePair <string, Type>("log", typeof(TaskLoggingHelper))
);
return(true);
}
catch (LuaParseException e)
{
log.LogError("{0} (at line {1},{2})", e.Message, taskName, e.Line);
return(false);
}
} // func Initialize
} // func DoChunk
/// <summary>Compiles and execute the stream.</summary>
/// <param name="tr">Stream</param>
/// <param name="name">Name of the stream</param>
/// <param name="args">Parameter definition for the stream.</param>
/// <returns>Return values of the stream.</returns>
public LuaResult DoChunk(TextReader tr, string name, params KeyValuePair <string, object>[] args)
{
// Erzeuge die Parameter
object[] callArgs;
KeyValuePair <string, Type>[] callTypes;
if (args != null)
{
callArgs = new object[args.Length];
callTypes = new KeyValuePair <string, Type> [args.Length];
for (var i = 0; i < args.Length; i++)
{
callArgs[i] = args[i].Value;
callTypes[i] = new KeyValuePair <string, Type>(args[i].Key, args[i].Value == null ? typeof(object) : args[i].Value.GetType());
}
}
else
{
callArgs = new object[0];
callTypes = new KeyValuePair <string, Type> [0];
}
// Führe den Block aus
return(DoChunk(lua.CompileChunk(tr, name, null, callTypes), callArgs));
} // proc DoChunk
} // func ParseArgument
private static void RunScript(Func <string> code, string sName)
{
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
// compile chunk
LuaChunk c = lua.CompileChunk(code(), sName, new LuaCompileOptions()
{
DebugEngine = debugEngine
});
string sCompileTime = String.Format("{0:N0} ms", sw.ElapsedMilliseconds);
sw.Reset();
sw.Start();
// run chunk
LuaResult r = global.DoChunk(c);
string sRunTime = String.Format("{0:N0} ms", sw.ElapsedMilliseconds);
string sSize;
if (c.Size < 0)
{
sSize = "unknown";
}
else if (c.Size == 0)
{
sSize = String.Empty;
}
else
{
sSize = c.Size.ToString("N0") + " byte";
}
// start with a new line
if (Console.CursorLeft > 0)
{
Console.WriteLine();
}
// print result
if (r.Count > 0)
{
for (int i = 0; i < r.Count; i++)
{
WriteVariable(i, r[i]);
}
}
// print summary
const string csCompile = "==> compile: ";
const string csRuntime = " run: ";
Console.CursorLeft = Console.WindowWidth - csCompile.Length - (sSize.Length > 0 ? sSize.Length + 3 : 0) - sCompileTime.Length - csRuntime.Length - sRunTime.Length - 1;
WriteText(ConsoleColor.DarkGreen, csCompile);
WriteText(ConsoleColor.Green, sCompileTime);
if (sSize.Length > 0)
{
WriteText(ConsoleColor.DarkGreen, " [");
WriteText(ConsoleColor.Green, sSize);
WriteText(ConsoleColor.DarkGreen, "]");
}
WriteText(ConsoleColor.DarkGreen, csRuntime);
WriteText(ConsoleColor.Green, sRunTime);
Console.WriteLine();
}
catch (LuaParseException e)
{
WriteText(ConsoleColor.DarkRed, String.Format("Parse error at line {0:N0} (column: {1:N0}):", e.Line, e.Column));
Console.WriteLine();
WriteText(ConsoleColor.DarkRed, " " + e.Message);
Console.WriteLine();
}
catch (Exception e)
{
Exception ex = e is TargetInvocationException ? e.InnerException : e;
WriteException(ex);
}
} // proc RunScript
/// <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