public static LuaValue Lines(LuaValue[] values)
{
LuaUserdata data = values[0] as LuaUserdata;
TextReader reader = data.Value as TextReader;
LuaFunction func = new LuaFunction((LuaValue[] args) =>
{
LuaUserdata _data = values[0] as LuaUserdata;
TextReader _reader = data.Value as TextReader;
string line = _reader.ReadLine();
if (line != null)
{
return(new LuaString(line));
}
else
{
return(LuaNil.Nil);
}
}
);
return(new LuaMultiValue(new LuaValue[] { func, data, LuaNil.Nil }));
}
public static LuaValue seek(LuaValue[] values)
{
LuaUserdata data = values[0] as LuaUserdata;
Stream stream = null;
StreamWriter writer = data.Value as StreamWriter;
if (writer != null)
{
stream = writer.BaseStream;
}
else
{
StreamReader reader = data.Value as StreamReader;
if (reader != null)
{
stream = reader.BaseStream;
}
}
if (stream != null)
{
LuaString whenceStr = values.Length > 1 ? values[1] as LuaString : null;
string whence = whenceStr == null ? "cur" : whenceStr.Text;
LuaNumber offsetNum = values.Length > 1 && whenceStr == null ? values[1] as LuaNumber : null;
offsetNum = values.Length > 2 && offsetNum == null ? values[2] as LuaNumber : null;
long offset = offsetNum == null ? 0 : (long)offsetNum.Number;
stream.Seek(offset, GetSeekOrigin(whence));
}
return(null);
}
public static LuaValue StaticClassToLuaTable(Type type)
{
LuaUserdata data = new LuaUserdata(null);
data.MetaTable = GetControlMetaTable(true, type);
data.MetaTable.SetNameValue("staticClassType", ToLuaValue(type));
return(data);
}
public static LuaValue Flush(LuaValue[] values)
{
LuaUserdata data = values[0] as LuaUserdata;
TextWriter writer = data.Value as TextWriter;
writer.Flush();
return(null);
}
public static LuaValue RunApp(LuaValue[] values)
{
LuaUserdata data = values[0] as LuaUserdata;
Form form = (Form)data.Value;
form.PerformLayout();
Application.Run(form);
return(null);
}
/*
* public static LuaValue Seek(LuaValue[] values)
* {
* LuaUserdata data = values[0] as LuaUserdata;
* Stream stream = null;
*
* TextWriter writer = data.Value as TextWriter;
* if (writer != null)
* {
* stream = writer.BaseStream;
* }
* else
* {
* TextReader reader = data.Value as TextReader;
* if (reader != null)
* {
* stream = reader.BaseStream;
* }
* }
*
* if (stream != null)
* {
* LuaString whenceStr = values.Length > 1 ? values[1] as LuaString : null;
* string whence = whenceStr == null ? "cur" : whenceStr.Text;
*
* LuaNumber offsetNum = values.Length > 1 && whenceStr == null ? values[1] as LuaNumber : null;
* offsetNum = values.Length > 2 && offsetNum == null ? values[2] as LuaNumber : null;
* long offset = offsetNum == null ? 0 : (long)offsetNum.Number;
*
* stream.Seek(offset, GetSeekOrigin(whence));
* }
*
* return null;
* }
*
* static SeekOrigin GetSeekOrigin(string whence)
* {
* switch (whence)
* {
* case "set":
* return SeekOrigin.Begin;
* case "end":
* return SeekOrigin.End;
* case "cur":
* default:
* return SeekOrigin.Current;
* }
* }
*/
public static LuaValue Write(LuaValue[] values)
{
LuaUserdata data = values[0] as LuaUserdata;
TextWriter writer = data.Value as TextWriter;
for (int i = 1; i < values.Length; i++)
{
writer.Write(values[i].Value);
}
return(null);
}
public static LuaValue Read(LuaValue[] values)
{
LuaUserdata data = values[0] as LuaUserdata;
TextReader reader = data.Value as TextReader;
LuaNumber number = values.Length > 1 ? values[1] as LuaNumber : null;
if (number != null)
{
if (number.Number == 0)
{
return(LuaString.Empty);
}
if (reader.Peek() == -1)
{
return(LuaNil.Nil);
}
char[] block = new char[(int)number.Number];
int chars = reader.Read(block, 0, block.Length);
return(new LuaString(new string(block, 0, chars)));
}
LuaString param = values.Length > 1 ? values[1] as LuaString : null;
string mode = param == null ? "*l" : param.Text;
switch (mode)
{
case "*l":
if (reader.Peek() == -1)
{
return(LuaNil.Nil);
}
return(new LuaString(reader.ReadLine()));
case "*a":
return(new LuaString(reader.ReadToEnd()));
case "*n":
List <char> buffer = new List <char>();
int ch = reader.Peek();
while (ch >= '0' && ch <= '9')
{
buffer.Add((char)reader.Read());
ch = reader.Peek();
}
return(new LuaNumber(int.Parse(new string(buffer.ToArray()))));
}
return(null);
}
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 GetControlCreator(LuaValue[] values)
{
LuaString typeString = values[0] as LuaString;
string typeName = "System.Windows.Forms." + typeString.Text;
Type type = Assembly.GetAssembly(typeof(Application)).GetType(typeName, true, true);
LuaFunction func = new LuaFunction((LuaValue[] args) =>
{
object control = Activator.CreateInstance(type);
LuaTable table = args[0] as LuaTable;
string name = null;
if (table.Count > 0)
{
AddChildControls(control, table);
}
if (table.Count > 0)
{
foreach (var pair in table.KeyValuePairs)
{
string member = (pair.Key as LuaString).Text;
if (member == "Name")
{
name = (string)pair.Value.Value;
continue;
}
SetMemberValue(control, type, member, pair.Value.Value);
}
}
LuaUserdata data = new LuaUserdata(control);
data.MetaTable = GetControlMetaTable();
if (name != null)
{
LuaTable enviroment = currentModule.GetValue("_G") as LuaTable;
enviroment.SetNameValue(name, data);
}
return(data);
}
);
currentModule.SetNameValue(typeString.Text, func);
return(func);
}
public static LuaValue Close(LuaValue[] values)
{
LuaUserdata data = values[0] as LuaUserdata;
TextReader reader = data.Value as TextReader;
if (reader != null)
{
reader.Close();
return(null);
}
TextWriter writer = data.Value as TextWriter;
if (writer != null)
{
writer.Close();
}
return(null);
}
public static LuaTable GetControlMetaTable()
{
if (controlMetaTable == null)
{
controlMetaTable = new LuaTable();
controlMetaTable.SetNameValue("__index", new LuaFunction((values) =>
{
LuaUserdata control = values[0] as LuaUserdata;
Type type = control.Value.GetType();
LuaString member = values[1] as LuaString;
if (member != null)
{
return(GetMemberValue(control.Value, type, member.Text));
}
LuaNumber index = values[1] as LuaNumber;
if (index != null)
{
return(GetIndexerValue(control.Value, type, index.Number));
}
return(LuaNil.Nil);
}));
controlMetaTable.SetNameValue("__newindex", new LuaFunction((values) =>
{
LuaUserdata control = values[0] as LuaUserdata;
LuaString member = values[1] as LuaString;
LuaValue value = values[2];
Type type = control.Value.GetType();
SetMemberValue(control.Value, type, member.Text, value.Value);
return(null);
}));
}
return(controlMetaTable);
}
public static LuaValue output(LuaValue[] values)
{
if (values == null || values.Length == 0)
{
return(new LuaUserdata(DefaultOutput));
}
else
{
LuaString file = values[0] as LuaString;
if (file != null)
{
DefaultOutput = File.CreateText(file.Text);
return(null);
}
LuaUserdata data = values[0] as LuaUserdata;
if (data != null && data.Value is TextWriter)
{
DefaultOutput = data.Value as TextWriter;
}
return(null);
}
}
public static LuaValue Input(LuaValue[] values)
{
if (values == null || values.Length == 0)
{
return(new LuaUserdata(DefaultInput));
}
else
{
LuaString file = values[0] as LuaString;
if (file != null)
{
DefaultInput = File.OpenText <LuaRuntime>(file.Text);
return(null);
}
LuaUserdata data = values[0] as LuaUserdata;
if (data != null && data.Value is TextReader)
{
DefaultInput = data.Value as TextReader;
}
return(null);
}
}
/// <summary>
/// Sets the assignment
/// </summary>
/// <param name="baseValue"></param>
/// <param name="key"></param>
/// <param name="value"></param>
private static void SetKeyValue(LuaValue baseValue, LuaValue key, LuaValue value)
{
LuaValue newIndex = LuaNil.Nil;
LuaTable table = baseValue as LuaTable;
if (table != null)
{
if (table.MetaTable != null)
{
newIndex = table.MetaTable.GetValue("__newindex");
// to be finished at the end of this method
}
if (newIndex == LuaNil.Nil)
{
table.SetKeyValue(key, value);
return;
}
}
else if ((baseValue as LuaClass) != null)
{
LuaClass c = baseValue as LuaClass;
// null checks (mainly for debugging)
if (c.Self.MetaTable == null)
{
c.GenerateMetaTable();
}
//throw new Exception("Class metatable is nil!");
newIndex = c.Self.MetaTable.GetValue("__newindex");
if (newIndex == LuaNil.Nil)
{
c.Self.SetKeyValue(key, value);
}
else
{
(newIndex as LuaFunction).Invoke(new LuaValue[] { baseValue, key, value });
}
return;
}
else
{
LuaUserdata userdata = baseValue as LuaUserdata;
if (userdata != null)
{
if (userdata.MetaTable != null)
{
newIndex = userdata.MetaTable.GetValue("__newindex");
}
if (newIndex == LuaNil.Nil)
{
throw new Exception("Assign field of userdata without __newindex defined.");
}
}
}
LuaFunction func = newIndex as LuaFunction;
if (func != null)
{
func.Invoke(new LuaValue[] { baseValue, key, value });
}
else
{
SetKeyValue(newIndex, key, value);
}
}
public static LuaTable GetControlMetaTable(bool isStatic = false, Type classType = null)
{
LuaTable controlMetaTable = null;
if (isStatic == false && instanceControlMetaTable == null || isStatic == true && controlMetaTables.ContainsKey(classType) == false)
{
controlMetaTable = new LuaTable();
controlMetaTable.SetNameValue("__index", new LuaFunction((values) =>
{
bool isStaticClass = false;
LuaUserdata control = values[0] as LuaUserdata;
Type type;
if (control.MetaTable.ContainsKey(new LuaString("staticClassType")))
{
isStaticClass = true;
type = values[0].MetaTable.GetValue("staticClassType").Value as Type;
}
else
{
type = control.Value.GetType();
}
LuaString member = values[1] as LuaString;
if (member != null)
{
return(GetMemberValue((isStaticClass == false ? control.Value : null), type, member.Text));
}
LuaNumber index = values[1] as LuaNumber;
if (index != null)
{
return(GetIndexerValue((isStaticClass == false ? control.Value : null), type, index.Number));
}
return(LuaNil.Nil);
}));
controlMetaTable.SetNameValue("__newindex", new LuaFunction((values) =>
{
bool isStaticClass = false;
LuaUserdata control = values[0] as LuaUserdata;
Type type;
if (control.MetaTable.ContainsKey(new LuaString("staticClassType")))
{
isStaticClass = true;
type = values[0].MetaTable.GetValue("staticClassType").Value as Type;
}
else
{
type = control.Value.GetType();
}
LuaString member = values[1] as LuaString;
LuaValue value = values[2];
SetMemberValue((isStaticClass == false ? control.Value : null), type, member.Text, value.Value);
return(null);
}));
if (isStatic == false)
{
instanceControlMetaTable = controlMetaTable;
}
else
{
controlMetaTables[classType] = controlMetaTable;
}
}
if (isStatic == false)
{
return(instanceControlMetaTable);
}
else
{
return(controlMetaTables[classType]);
}
}
public override LuaValue Evaluate(LuaValue baseValue, LuaTable enviroment)
{
LuaValue value = null;
try { LuaValue.GetKeyValue(baseValue, new LuaString(this.Method)); } catch (Exception) { }
LuaFunction function = value as LuaFunction;
if (function != null)
{
if (this.Args.Table != null)
{
return(function.Function.Invoke(new LuaValue[] { baseValue, this.Args.Table.Evaluate(enviroment) }));
}
else if (this.Args.String != null)
{
return(function.Function.Invoke(new LuaValue[] { baseValue, this.Args.String.Evaluate(enviroment) }));
}
else
{
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
args.Insert(0, baseValue);
return(function.Function.Invoke(args.ToArray()));
}
} // method call on table would be like _G:script()
else if ((baseValue as LuaTable) != null)
{
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
return(((baseValue as LuaTable).MetaTable.GetValue("__call") as LuaFunction).Invoke(args.ToArray()));
}
else if ((baseValue as LuaClass) != null)
{
LuaClass c = baseValue as LuaClass;
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
args.Insert(0, new LuaString(this.Method));
if (c.Self.MetaTable == null)
{
c.GenerateMetaTable();
}
return((c.Self.MetaTable.GetValue("__call") as LuaFunction).Invoke(args.ToArray()));
}
else if ((baseValue as LuaUserdata) != null)
{
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
LuaUserdata obj = baseValue as LuaUserdata;
object o = obj.Value;
if (obj.MetaTable != null)
{
if (obj.MetaTable.GetValue(this.Method) != null)
{
LuaValue o2 = obj.MetaTable.GetValue(this.Method);
if ((o2 as LuaFunction) != null)
{
return((o2 as LuaFunction).Invoke(args.ToArray()));
}
else if ((o2 as LuaTable) != null)
{
throw new NotImplementedException(); // TODO
}
}
}
return(ObjectToLua.ToLuaValue(o.GetType().GetMethod(this.Method, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Invoke(o, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args.ToArray(), CultureInfo.CurrentCulture)));
}
else
{
throw new Exception("Invoke method call on non function value.");
}
}
public override LuaValue Evaluate(LuaValue baseValue, LuaTable enviroment)
{
LuaFunction function = baseValue as LuaFunction;
if (function != null)
{
if (function.Function.Method.DeclaringType.FullName == "SharpLua.Library.BaseLib" &&
(function.Function.Method.Name == "loadstring" || function.Function.Method.Name == "dofile"))
{
if (this.Args.String != null)
{
return(function.Function.Invoke(new LuaValue[] { this.Args.String.Evaluate(enviroment), enviroment }));
}
else
{
return(function.Function.Invoke(new LuaValue[] { this.Args.ArgList[0].Evaluate(enviroment), enviroment }));
}
}
if (this.Args.Table != null)
{
return(function.Function.Invoke(new LuaValue[] { this.Args.Table.Evaluate(enviroment) }));
}
else if (this.Args.String != null)
{
return(function.Function.Invoke(new LuaValue[] { this.Args.String.Evaluate(enviroment) }));
}
else
{
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
return(function.Function.Invoke(LuaMultiValue.UnWrapLuaValues(args.ToArray())));
}
}
else if ((baseValue as LuaTable) != null)
{
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
args.Insert(0, baseValue);
return(((baseValue as LuaTable).MetaTable.GetValue("__call") as LuaFunction).Invoke(args.ToArray()));
}
else if ((baseValue as LuaClass) != null)
{
LuaClass c = baseValue as LuaClass;
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
//args.Insert(0, new LuaString(this.Method);
if (c.Self.MetaTable == null)
{
c.GenerateMetaTable();
}
return((c.Self.MetaTable.GetValue("__call") as LuaFunction).Invoke(args.ToArray()));
}
else if ((baseValue as LuaUserdata) != null)
{
List <LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
LuaUserdata u = baseValue as LuaUserdata;
if (u.MetaTable != null)
{
if (u.MetaTable.GetValue("__call") != null)
{
return(ObjectToLua.ToLuaValue((u.MetaTable.GetValue("__call") as LuaFunction).Invoke(args.ToArray())));
}
else
{
throw new NotImplementedException();
}
}
else
{
throw new NotImplementedException();
}
}
else
{
throw new Exception("Invoke function call on non function value.");
}
}
