public static LuaValue date(LuaValue[] values)
{
LuaString format = values[0] as LuaString;
if (format != null)
{
if (format.Text == "*t")
{
LuaTable table = new LuaTable();
DateTime now = DateTime.Now;
table.SetNameValue("year", new LuaNumber(now.Year));
table.SetNameValue("month", new LuaNumber(now.Month));
table.SetNameValue("day", new LuaNumber(now.Day));
table.SetNameValue("hour", new LuaNumber(now.Hour));
table.SetNameValue("min", new LuaNumber(now.Minute));
table.SetNameValue("sec", new LuaNumber(now.Second));
table.SetNameValue("wday", new LuaNumber((int)now.DayOfWeek));
table.SetNameValue("yday", new LuaNumber(now.DayOfYear));
table.SetNameValue("isdst", LuaBoolean.From(now.IsDaylightSavingTime()));
}
else
{
return(new LuaString(DateTime.Now.ToString(format.Text)));
}
}
return(new LuaString(DateTime.Now.ToShortDateString()));
}
public static LuaValue IsMemberOf(LuaValue[] args)
{
LuaClass _class = args[1] as LuaClass;
LuaValue obj = args[0];
return(LuaBoolean.From(_class.Self.GetValue(obj) != LuaNil.Nil));
}
public static LuaValue IsObjectOf(LuaValue[] args)
{
LuaClass c = args[0] as LuaClass;
LuaClass _class = args[1] as LuaClass;
return(LuaBoolean.From(c == _class));
}
public static LuaValue removeitem(LuaValue[] values)
{
LuaTable table = values[0] as LuaTable;
LuaValue item = values[1];
bool removed = table.Remove(item);
return(LuaBoolean.From(removed));
}
private LuaValue PrefixUnaryOperation(string Operator, Term RightOperand, LuaTable enviroment)
{
LuaValue rightValue = RightOperand.Evaluate(enviroment);
switch (Operator)
{
case "-":
var number = rightValue as LuaNumber;
if (number != null)
{
return(new LuaNumber(-number.Number));
}
else
{
LuaFunction func = GetMetaFunction("__unm", rightValue, null);
if (func != null)
{
return(func.Invoke(new LuaValue[] { rightValue }));
}
}
break;
case "#":
var table = rightValue as LuaTable;
if (table != null)
{
return(new LuaNumber(table.Length));
}
var str = rightValue as LuaString;
if (str != null)
{
return(new LuaNumber(str.Text.Length));
}
if ((rightValue.MetaTable.GetValue("__len") != null) && ((rightValue.MetaTable.GetValue("__len") as LuaFunction) != null))
{
return((rightValue.MetaTable.GetValue("__len") as LuaFunction).Invoke(new LuaValue[] { }));
}
break;
case "not":
var rightBool = rightValue as LuaBoolean;
if (rightBool != null)
{
return(LuaBoolean.From(!rightBool.BoolValue));
}
break;
}
return(LuaNil.Nil);
}
public static LuaValue ToLuaValue(object value)
{
if ((value as LuaValue) != null)
{
return(value as LuaValue);
}
if (value is int || value is double || value is float)
{
return(new LuaNumber(Convert.ToDouble(value)));
}
else if (value is MuMech.MovingAverage)
{
return(new LuaNumber(((MuMech.MovingAverage)value).value));
}
else if (value is string)
{
return(new LuaString((string)value));
}
else if (value is bool)
{
return(LuaBoolean.From((bool)value));
}
else if (value == null)
{
return(LuaNil.Nil);
}
else if (value.GetType().IsEnum)
{
return(new LuaString(value.ToString()));
}
else if (value.GetType().IsArray)
{
LuaTable table = new LuaTable();
foreach (var item in (value as Array))
{
table.AddValue(ToLuaValue(item));
}
return(table);
}
else if (value is LuaValue)
{
return((LuaValue)value);
}
else
{
LuaUserdata data = new LuaUserdata(value);
data.MetaTable = GetControlMetaTable();
return(data);
}
}
public static LuaValue Require(LuaValue[] args)
{
// get loaders table
LuaTable t = (LuaRuntime.GlobalEnvironment.GetValue("package") as LuaTable).GetValue("loaders") as LuaTable;
if (t == null)
{
throw new Exception("Cannot get loaders table from package module!");
}
if (t.Count == 0)
{
throw new Exception("Loaders table is empty!");
}
// whether package was found/loaded
LuaBoolean b = LuaBoolean.False;
LuaValue module = null;
foreach (LuaValue key in t.Keys)
{
LuaFunction f = t.GetValue(key) as LuaFunction;
if (f != null)
{
LuaMultiValue lmv = f.Invoke(new LuaValue[] { new LuaString(args[0].Value.ToString()) }) as LuaMultiValue;
b = lmv.Values[0] as LuaBoolean;
if (b.BoolValue == true)
{
module = lmv.Values[1];
break;
}
}
else
{
throw new Exception("Cannot cast type '" + t.GetValue(key).GetType().ToString() + "' to type 'LuaFunction'");
}
}
if (b.BoolValue == false)
{
Console.WriteLine("Could not load package '" + args[0].Value.ToString() + "'!");
}
return(module);
}
public override LuaValue Evaluate(LuaTable enviroment)
{
return(LuaBoolean.From(bool.Parse(this.Text)));
}
public void Add(LuaBoolean Val)
{
}
List <LuaConstant> LoadConstants(ref FuncNode curNode)
{
int constNum = undumper.LoadInt();
List <LuaConstant> luaConstants = new List <LuaConstant>();
for (int i = 0; i < constNum; ++i)
{
byte type = undumper.LoadByte();
LuaConstant curConst;
switch ((ConstantType)type)
{
case ConstantType.LUA_TNIL:
curConst = new LuaConstant();
break;
case ConstantType.LUA_TBOOLEAN:
curConst = new LuaBoolean();
break;
case ConstantType.LUA_TNUMBER:
curConst = new LuaNumber();
break;
case ConstantType.LUA_TSTRING:
curConst = new LuaString();
break;
default:
curConst = new LuaConstant();
break;
}
curConst.Type = (ConstantType)type;
switch (curConst.Type)
{
case ConstantType.LUA_TNIL:
// DO NOTHING
break;
case ConstantType.LUA_TBOOLEAN:
curConst.Data = new byte[1];
curConst.Data[0] = undumper.LoadByte();
break;
case ConstantType.LUA_TNUMBER:
curConst.Data = undumper.LoadBlock(sizeof(double));
break;
case ConstantType.LUA_TSTRING:
curConst.Data = Encoding.ASCII.GetBytes(undumper.LoadString());
break;
default:
break;
}
luaConstants.Add(curConst);
}
int funcNum = undumper.LoadInt();
for (int i = 0; i < funcNum; ++i)
{
LoadFunction(ref curNode);
}
return(luaConstants);
}
public static LuaValue Wrap(LuaValue[] args)
{
LuaFunction f = args[0] as LuaFunction;
LuaCoroutine c = new LuaCoroutine(f);
LuaFunction f2 = new LuaFunction(new LuaFunc(delegate(LuaValue[] args2) { return(LuaBoolean.From(c.Resume(args2))); }));
return(f2);
}
private LuaValue InfixBinaryOperation(Term LeftOperand, string Operator, Term RightOperand, LuaTable enviroment)
{
LuaValue leftValue = LeftOperand.Evaluate(enviroment);
LuaValue rightValue = RightOperand.Evaluate(enviroment);
switch (Operator)
{
case "+":
var left = leftValue as LuaNumber;
var right = rightValue as LuaNumber;
if (left != null && right != null)
{
return(new LuaNumber(left.Number + right.Number));
}
else
{
LuaFunction func = GetMetaFunction("__add", leftValue, rightValue);
if (func != null)
{
return(func.Invoke(new LuaValue[] { leftValue, rightValue }));
}
}
break;
case "-":
left = leftValue as LuaNumber;
right = rightValue as LuaNumber;
if (left != null && right != null)
{
return(new LuaNumber(left.Number - right.Number));
}
else
{
LuaFunction func = GetMetaFunction("__sub", leftValue, rightValue);
if (func != null)
{
return(func.Invoke(new LuaValue[] { leftValue, rightValue }));
}
}
break;
case "*":
left = leftValue as LuaNumber;
right = rightValue as LuaNumber;
if (left != null && right != null)
{
return(new LuaNumber(left.Number * right.Number));
}
else
{
LuaFunction func = GetMetaFunction("__mul", leftValue, rightValue);
if (func != null)
{
return(func.Invoke(new LuaValue[] { leftValue, rightValue }));
}
}
break;
case "/":
left = leftValue as LuaNumber;
right = rightValue as LuaNumber;
if (left != null && right != null)
{
return(new LuaNumber(left.Number / right.Number));
}
else
{
LuaFunction func = GetMetaFunction("__div", leftValue, rightValue);
if (func != null)
{
return(func.Invoke(new LuaValue[] { leftValue, rightValue }));
}
}
break;
case "%":
left = leftValue as LuaNumber;
right = rightValue as LuaNumber;
if (left != null && right != null)
{
return(new LuaNumber(left.Number % right.Number));
}
else
{
LuaFunction func = GetMetaFunction("__mod", leftValue, rightValue);
if (func != null)
{
return(func.Invoke(new LuaValue[] { leftValue, rightValue }));
}
}
break;
case "^":
left = leftValue as LuaNumber;
right = rightValue as LuaNumber;
if (left != null && right != null)
{
return(new LuaNumber(Math.Pow(left.Number, right.Number)));
}
else
{
LuaFunction func = GetMetaFunction("__pow", leftValue, rightValue);
if (func != null)
{
return(func.Invoke(new LuaValue[] { leftValue, rightValue }));
}
}
break;
case "==":
return(LuaBoolean.From(leftValue.Equals(rightValue)));
case "~=":
return(LuaBoolean.From(leftValue.Equals(rightValue) == false));
case "<":
int?compare = Compare(leftValue, rightValue);
if (compare != null)
{
return(LuaBoolean.From(compare < 0));
}
else
{
LuaFunction func = GetMetaFunction("__lt", leftValue, rightValue);
if (func != null)
{
return(func.Invoke(new LuaValue[] { leftValue, rightValue }));
}
}
break;
case ">":
compare = Compare(leftValue, rightValue);
if (compare != null)
{
return(LuaBoolean.From(compare > 0));
}
else
{
LuaFunction func = GetMetaFunction("__gt", leftValue, rightValue);
if (func != null)
{
return(func.Invoke(new LuaValue[] { leftValue, rightValue }));
}
}
break;
case "<=":
compare = Compare(leftValue, rightValue);
if (compare != null)
{
return(LuaBoolean.From(compare <= 0));
}
else
{
LuaFunction func = GetMetaFunction("__le", leftValue, rightValue);
if (func != null)
{
return(func.Invoke(new LuaValue[] { leftValue, rightValue }));
}
}
break;
case ">=":
compare = Compare(leftValue, rightValue);
if (compare != null)
{
return(LuaBoolean.From(compare >= 0));
}
else
{
LuaFunction func = GetMetaFunction("__ge", leftValue, rightValue);
if (func != null)
{
return(func.Invoke(new LuaValue[] { leftValue, rightValue }));
}
}
break;
case "..":
if ((leftValue is LuaString || leftValue is LuaNumber) &&
(rightValue is LuaString || rightValue is LuaNumber))
{
return(new LuaString(string.Concat(leftValue, rightValue)));
}
else
{
LuaFunction func = GetMetaFunction("__concat", leftValue, rightValue);
if (func != null)
{
return(func.Invoke(new LuaValue[] { leftValue, rightValue }));
}
}
break;
case "and":
bool leftBool = leftValue.GetBooleanValue();
bool rightBool = rightValue.GetBooleanValue();
if (leftBool == false)
{
return(leftValue);
}
else
{
return(rightValue);
}
case "or":
leftBool = leftValue.GetBooleanValue();
rightBool = rightValue.GetBooleanValue();
if (leftBool == true)
{
return(leftValue);
}
else
{
return(rightValue);
}
}
return(null);
}
protected bool Equals(LuaBoolean other)
{
return(value.Equals(other.value));
}
