public static void AddIoLibrary(LuaContext Context)
{
dynamic io = LuaObject.NewTable();
FileMetatable.__index = LuaObject.NewTable();
FileMetatable.__index.write = (LuaFunction)write;
FileMetatable.__index.close = (LuaFunction)close;
FileMetatable.__index.flush = (LuaFunction)flush;
FileMetatable.__index.seek = (LuaFunction)seek;
FileMetatable.__index.read = (LuaFunction)read;
io.open = (LuaFunction)io_open;
io.type = (LuaFunction)io_type;
io.input = (LuaFunction)io_input;
io.output = (LuaFunction)io_output;
io.temp = (LuaFunction)io_temp;
io.flush = (LuaFunction)io_flush;
io.write = (LuaFunction)io_write;
io.read = (LuaFunction)io_read;
currentInput = CreateFileObject(Console.OpenStandardInput());
currentOutput = CreateFileObject(Console.OpenStandardOutput(), true);
io.stdin = currentInput;
io.stdout = currentOutput;
io.stderr = CreateFileObject(Console.OpenStandardError(), true);
Context.Set("io", io);
}
static LuaArguments EvalGenericFor(GenericFor stat, LuaContext Context, out LuaReturnStatus returned)
{
returned.broke = false;
returned.returned = false;
LuaArguments args = null;
foreach (IExpression expr in stat.Expressions)
{
if (args == null)
{
args = EvalExpression(expr, Context);
}
else
{
args.Concat(EvalExpression(expr, Context));
}
}
LuaObject f = args[0], s = args[1], var = args[2];
LuaContext ctx = new LuaContext(Context);
while (true)
{
LuaArguments res = f.Call(s, var);
for (int i = 0; i < stat.Variables.Count; i++)
{
ctx.SetLocal(stat.Variables[i], res[i]);
}
if (res[0].IsNil)
{
break;
}
var = res[0];
LuaArguments obj = EvalBlock(stat.Block, ctx, out returned);
if (returned.broke)
{
break;
}
if (returned.returned)
{
return(obj);
}
}
return(Lua.Return());
}
static LuaArguments EvalFunctionCall(FunctionCall Expression, LuaContext Context)
{
LuaObject func = EvalExpression(Expression.Function, Context)[0];
LuaArguments args = null;
if (Expression.Arguments != null || Expression.Arguments.Count != 0)
{
List <LuaObject> values = new List <LuaObject>();
foreach (IExpression expr in Expression.Arguments)
{
values.AddRange(EvalExpression(expr, Context));
}
args = values.ToArray();
}
return(func.Call(args));
}
static LuaObject EvalTableConstructor(TableConstructor tctor, LuaContext Context)
{
Dictionary <LuaObject, LuaObject> table = new Dictionary <LuaObject, LuaObject>();
int i = 0;
foreach (KeyValuePair <IExpression, IExpression> pair in tctor.Values)
{
if (i == tctor.Values.Count - 1 && (pair.Value is FunctionCall || pair.Value is VarargsLiteral))
// This is the last element, and this is a function call or varargs, thus we will add
// every return value to the table
{
LuaObject key = EvalExpression(pair.Key, Context)[0];
if (key.IsNumber)
{
LuaArguments values = EvalExpression(pair.Value, Context);
double k = key;
foreach (LuaObject v in values)
{
table.Add(k, v);
k++;
}
}
else
{
LuaObject value = EvalExpression(pair.Value, Context)[0];
table.Add(key, value);
}
}
else
{
LuaObject key = EvalExpression(pair.Key, Context)[0];
LuaObject value = EvalExpression(pair.Value, Context)[0];
table.Add(key, value);
}
i++;
}
return(LuaObject.FromTable(table));
}
static LuaObject EvalFunctionDefinition(FunctionDefinition fdef, LuaContext Context)
{
LuaObject obj = LuaObject.FromFunction(delegate(LuaArguments args)
{
LuaContext ctx = new LuaContext(Context);
LuaReturnStatus ret;
for (int i = 0; i < args.Length; i++)
{
if (i < fdef.Arguments.Count)
{
ctx.SetLocal(fdef.Arguments[i].Name, args[i]);
}
else
{
ctx.Varargs.Add(args[i]);
}
}
return(EvalBlock(fdef.Body, ctx, out ret));
});
return(obj);
}
internal static LuaArguments EvalBlock(Block Block, LuaContext Context, out LuaReturnStatus returned)
{
returned.broke = false;
returned.returned = false;
LuaArguments obj = new LuaObject[] { LuaObject.Nil };
foreach (IStatement stat in Block.Statements)
{
if (stat is Assignment)
{
Assignment assign = stat as Assignment;
LuaArguments values = null;
foreach (IExpression expr in assign.Expressions)
{
if (values == null)
{
values = EvalExpression(expr, Context);
}
else
{
values.Concat(EvalExpression(expr, Context));
}
}
for (int i = 0; i < assign.Variables.Count; i++)
{
SetAssignable(assign.Variables[i], values[i], Context);
}
}
else if (stat is LocalAssignment)
{
LocalAssignment assign = stat as LocalAssignment;
LuaArguments values = null;
foreach (IExpression expr in assign.Values)
{
if (values == null)
{
values = EvalExpression(expr, Context);
}
else
{
values.Concat(EvalExpression(expr, Context));
}
}
for (int i = 0; i < assign.Names.Count; i++)
{
Context.SetLocal(assign.Names[i], values[i]);
}
}
else if (stat is ReturnStat)
{
ReturnStat ret = stat as ReturnStat;
returned.returned = true;
List <LuaObject> values = new List <LuaObject>();
int i = 0;
foreach (IExpression expr in ret.Expressions)
{
if (i == ret.Expressions.Count - 1)
{
values.AddRange(EvalExpression(expr, Context));
}
else
{
values.Add(EvalExpression(expr, Context)[0]);
}
i++;
}
return(values.ToArray());
}
else if (stat is FunctionCall)
{
FunctionCall call = stat as FunctionCall;
EvalFunctionCall(call, Context);
}
else if (stat is Block)
{
Block block = stat as Block;
LuaContext ctx = new LuaContext(Context);
obj = EvalBlock(block, ctx, out returned);
if (returned.returned)
{
return(obj);
}
}
else if (stat is IfStat)
{
obj = EvalIf(stat as IfStat, Context, out returned);
if (returned.returned)
{
return(obj);
}
}
else if (stat is WhileStat)
{
obj = EvalWhile(stat as WhileStat, Context, out returned);
if (returned.returned)
{
return(obj);
}
}
else if (stat is RepeatStat)
{
obj = EvalRepeat(stat as RepeatStat, Context, out returned);
if (returned.returned)
{
return(obj);
}
}
else if (stat is BreakStat)
{
returned.returned = false;
returned.broke = true;
return(Lua.Return(LuaObject.Nil));
}
else if (stat is NumericFor)
{
obj = EvalNumericFor(stat as NumericFor, Context, out returned);
if (returned.returned)
{
return(obj);
}
}
else
{
obj = EvalGenericFor(stat as GenericFor, Context, out returned);
if (returned.returned)
{
return(obj);
}
}
}
return(obj);
}
static void SetTable(TableAccess Expression, LuaObject Value, LuaContext Context)
{
EvalExpression(Expression.Expression, Context)[0][EvalExpression(Expression.Index, Context)[0]] = Value;
}
static LuaArguments EvalVarargs(LuaContext Context)
{
return(Context.Varargs);
}
/// <summary>
/// Used to create scopes
/// </summary>
public LuaContext(LuaContext Parent)
{
parent = Parent;
variables = new Dictionary <string, LuaObject>();
varargs = new LuaArguments(new LuaObject[] { });
}
public static void AddMathLibrary(LuaContext Context)
{
dynamic math = LuaObject.NewTable();
math.abs = (LuaFunction)math_abs;
math.acos = (LuaFunction)math_acos;
math.asin = (LuaFunction)math_asin;
math.atan = (LuaFunction)math_atan;
math.atan2 = (LuaFunction)math_atan2;
math.ceil = (LuaFunction)math_ceil;
math.cos = (LuaFunction)math_cos;
math.cosh = (LuaFunction)math_cosh;
math.exp = (LuaFunction)math_exp;
math.floor = (LuaFunction)math_floor;
math.log = (LuaFunction)math_log;
math.max = (LuaFunction)math_max;
math.min = (LuaFunction)math_min;
math.pow = (LuaFunction)math_pow;
math.sin = (LuaFunction)math_sin;
math.sinh = (LuaFunction)math_sinh;
math.sqrt = (LuaFunction)math_sqrt;
math.tan = (LuaFunction)math_tan;
math.tanh = (LuaFunction)math_tanh;
math.pi = Math.PI;
Context.Set("math", math);
}
/// <summary>
/// Used to create scopes
/// </summary>
public LuaContext(LuaContext Parent)
{
parent = Parent;
variables = new Dictionary<string, LuaObject>();
varargs = new LuaArguments(new LuaObject[] { });
}
