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 concat(LuaValue[] values)
{
LuaTable table = values[0] as LuaTable;
LuaString separator = values.Length > 1 ? values[1] as LuaString : LuaString.Empty;
LuaNumber startNumber = values.Length > 2 ? values[2] as LuaNumber : null;
LuaNumber endNumber = values.Length > 3 ? values[3] as LuaNumber : null;
int start = startNumber == null ? 1 : (int)startNumber.Number;
int end = endNumber == null ? table.Length : (int)endNumber.Number;
if (start > end)
{
return(LuaString.Empty);
}
else
{
StringBuilder text = new StringBuilder();
for (int index = start; index < end; index++)
{
text.Append(table.GetValue(index).ToString());
text.Append(separator.Text);
}
text.Append(table.GetValue(end).ToString());
return(new LuaString(text.ToString()));
}
}
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 Remove(LuaValue[] values)
{
LuaString file = values[0] as LuaString;
if (File.Exists <LuaRuntime>(file.Text))
{
File.Delete <LuaRuntime>(file.Text);
return(new LuaString("File is deleted."));
}
/*
* else if (Directory.Exists(file.Text))
* {
* if (Directory.GetFileSystemEntries(file.Text).Length == 0)
* {
* Directory.Delete(file.Text);
* return new LuaString("Directory is deleted.");
* }
* else
* {
* return new LuaMultiValue(new LuaValue[] { LuaNil.Nil, new LuaString("Directory is not empty.") });
* }
* }
*/
else
{
return(new LuaMultiValue(new LuaValue[] { LuaNil.Nil, new LuaString("File or directory does not exist.") }));
}
}
public static LuaValue open(LuaValue[] values)
{
LuaString file = values[0] as LuaString;
LuaString modeStr = values.Length > 1 ? values[1] as LuaString : null;
string mode = modeStr == null ? "r" : modeStr.Text;
switch (mode)
{
case "r":
case "r+":
StreamReader reader = File.OpenText(file.Text);
return(new LuaUserdata(reader, FileLib.CreateMetaTable()));
case "w":
case "w+":
StreamWriter writer = File.CreateText(file.Text);
return(new LuaUserdata(writer, FileLib.CreateMetaTable()));
case "a":
case "a+":
writer = File.AppendText(file.Text);
return(new LuaUserdata(writer, FileLib.CreateMetaTable()));
default:
throw new ArgumentException("Invalid file open mode " + mode);
}
}
public static LuaValue dofile(LuaValue[] values)
{
LuaString file = values[0] as LuaString;
LuaTable enviroment = values[1] as LuaTable;
return(LuaInterpreter.RunFile(file.Text, enviroment));
}
public static LuaValue Rename(LuaValue[] values)
{
LuaString oldName = values[0] as LuaString;
LuaString newName = values[1] as LuaString;
if (File.Exists <LuaRuntime>(oldName.Text))
{
File.WriteAllBytes <LuaRuntime>(File.ReadAllBytes <LuaRuntime>(oldName.Text), newName.Text);
File.Delete <LuaRuntime>(oldName.Text);
//File.Move(oldName.Text, newName.Text);
return(new LuaString("File is renamed."));
}
/*
* else if (Directory.Exists(oldName.Text))
* {
* Directory.Move(oldName.Text, newName.Text);
* return new LuaString("Directory is renamed.");
* }
*/
else
{
return(new LuaMultiValue(new LuaValue[] { LuaNil.Nil, new LuaString("File or directory does not exist.") }));
}
}
public static LuaValue DoFile(LuaValue[] values)
{
LuaString file = values[0] as LuaString;
LuaTable enviroment = LuaRuntime.GlobalEnvironment;
return(LuaRuntime.RunFile(file.Text, enviroment));
}
public virtual void RegisterType(Type t, string name)
{
if (t == null)
{
throw new ArgumentNullException(nameof(t));
}
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
lock (this) {
var n = new LuaString(name);
ILuaValue o = GlobalsTable.GetItemRaw(n);
if (o != LuaNil.Nil)
{
throw new ArgumentException(string.Format(Resources.AlreadyRegistered, name));
}
else
{
GlobalsTable.SetItemRaw(n, new LuaType(t));
}
}
}
public static LuaValue remove(LuaValue[] values)
{
LuaString file = values[0] as LuaString;
if (File.Exists(file.Text))
{
File.Delete(file.Text);
return(new LuaString("File is deleted."));
}
else if (Directory.Exists(file.Text))
{
if (Directory.GetFileSystemEntries(file.Text).Length == 0)
{
Directory.Delete(file.Text);
return(new LuaString("Directory is deleted."));
}
else
{
return(new LuaMultiValue(new LuaValue[] { LuaNil.Nil, new LuaString("Directory is not empty.") }));
}
}
else
{
return(new LuaMultiValue(new LuaValue[] { LuaNil.Nil, new LuaString("File or directory does not exist.") }));
}
}
public static LuaValue reverse(LuaValue[] values)
{
LuaString str = values[0] as LuaString;
char[] chars = str.Text.ToCharArray();
Array.Reverse(chars);
return(new LuaString(new string(chars)));
}
private void loadFunctionStrings(LuaFunction function)
{
// Get the number of strings + loop
int stringCount = this.inputReader.ReadInt32();
for (int i = 0; i < stringCount; i++)
{
// Make a new lua string object
LuaString str = new LuaString();
// Get the type
int strType = inputReader.ReadByte();
switch (strType)
{
case 1:
str.String = (inputReader.ReadByte() == 1) ? "true" : "false";
str.StringType = StringType.boolean;
break;
case 3:
str.String = inputReader.ReadSingle().ToString("0.000000");
str.StringType = StringType.number;
break;
case 4:
int StringLength = inputReader.ReadInt32() - 1;
if (!exportBlackOps2)
{
inputReader.ReadInt32();
}
str.String = inputReader.ReadNullTerminatedString();
str.StringType = StringType.String;
break;
case 0xD:
string HashString;
ulong assetHash = inputReader.ReadUInt64() & 0xFFFFFFFFFFFFFFF;
if (!Program.AssetNameCache.Entries.TryGetValue(assetHash, out HashString))
{
str.String = String.Format("0x{0:X}", assetHash);
str.StringType = StringType.hash;
}
else
{
str.String = HashString;
str.StringType = StringType.String;
}
break;
case 0:
str.String = "nil";
str.StringType = StringType.nullptr;
break;
}
// Add it to the list
function.Strings.Add(str);
}
}
public static LuaValue execute(LuaValue[] values)
{
if (values.Length > 0)
{
LuaString command = values[0] as LuaString;
System.Diagnostics.Process.Start(command.Text);
}
return(new LuaNumber(1));
}
public static LuaValue format(LuaValue[] values)
{
LuaString format = values[0] as LuaString;
object[] args = new object[values.Length - 1];
for (int i = 0; i < args.Length; i++)
{
args[i] = values[i + 1].Value;
}
return(new LuaString(string.Format(format.Text, args)));
}
public static LuaValue rep(LuaValue[] values)
{
LuaString str = values[0] as LuaString;
LuaNumber number = values[1] as LuaNumber;
StringBuilder text = new StringBuilder();
for (int i = 0; i < number.Number; i++)
{
text.Append(str.Text);
}
return(new LuaString(text.ToString()));
}
public static LuaValue Error(LuaValue[] values)
{
if (values.Length > 0)
{
LuaString message = values[0] as LuaString;
throw new LuaError(message.Text);
}
else
{
throw new LuaError("Error!");
}
}
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 error(LuaValue[] values)
{
LuaString message = values[0] as LuaString;
if (message != null)
{
throw new LuaError(message.Text);
}
else
{
throw new LuaError("error raised!");
}
}
public static LuaValue getenv(LuaValue[] values)
{
LuaString name = values[0] as LuaString;
string variable = Environment.GetEnvironmentVariable(name.Text);
if (variable == null)
{
return(LuaNil.Nil);
}
else
{
return(new LuaString(variable));
}
}
public static LuaValue getn(LuaValue[] values) //[PixelCrushers]
{
int count = 0;
if (values.Length >= 1)
{
LuaTable table = values[0] as LuaTable;
if (table != null)
{
if (table.Count > 0) // dictionary
{
foreach (KeyValuePair <LuaValue, LuaValue> kvp in table.KeyValuePairs)
{
LuaString key = kvp.Key as LuaString;
LuaValue value = kvp.Value;
if ((key != null) && string.Equals(key.Text, "n"))
{
if (value is LuaNumber)
{
return(value as LuaNumber);
}
}
else if (value == LuaNil.Nil)
{
return(new LuaNumber(count));
}
else
{
count++;
}
}
}
else
{
foreach (LuaValue listValue in table.ListValues)
{
if (listValue == LuaNil.Nil)
{
return(new LuaNumber(count));
}
else
{
count++;
}
}
}
}
}
return(new LuaNumber(count));
}
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 ShowMessage(LuaValue[] values)
{
LuaString messageString = values[0] as LuaString;
LuaString captionString = values.Length > 1 ? values[1] as LuaString : null;
if (captionString == null)
{
MessageBox.Show(messageString.Text);
}
else
{
MessageBox.Show(messageString.Text, captionString.Text);
}
return(null);
}
public static LuaValue assert(LuaValue[] values)
{
//[PixelCrushers]bool condition = values[0].GetBooleanValue();
LuaString message = values.Length > 1 ? values[1] as LuaString : null;
if (message != null)
{
throw new LuaError(message.Text);
}
else
{
throw new LuaError("assertion failed!");
}
// return new LuaMultiValue { Values = values };
}
public static LuaValue loadstring(LuaValue[] values)
{
LuaString code = values[0] as LuaString;
LuaTable enviroment = values[1] as LuaTable;
Chunk chunk = LuaInterpreter.Parse(code.Text);
LuaFunction func = new LuaFunction(
(LuaValue[] args) =>
{
chunk.Enviroment = enviroment;
return(chunk.Execute());
}
);
return(func);
}
public void StringOperators()
{
LuaString s = "Hello, World!";
Assert.IsTrue(s == "Hello, World!"); // (LS, s)
Assert.IsTrue(s == new LuaString("Hello, World!")); // (LS, LS)
Assert.IsTrue("Hello, World!" == s); // (s, LS)
Assert.IsTrue(new LuaString("Hello, World!") == s); // (LS, LS)
Assert.IsFalse(s != "Hello, World!"); // (LS, s)
Assert.IsFalse(s != new LuaString("Hello, World!")); // (LS, LS)
Assert.IsFalse("Hello, World!" != s); // (s, LS)
Assert.IsFalse(new LuaString("Hello, World!") != s); // (LS, LS)
}
public static LuaValue @byte(LuaValue[] values)
{
LuaString str = values[0] as LuaString;
LuaNumber startNumber = values.Length > 1 ? values[1] as LuaNumber : null;
LuaNumber endNumber = values.Length > 2 ? values[2] as LuaNumber : null;
int start = startNumber == null ? 1 : (int)startNumber.Number;
int end = endNumber == null ? start : (int)endNumber.Number;
LuaValue[] numbers = new LuaValue[end - start + 1];
for (int i = 0; i < numbers.Length; i++)
{
numbers[i] = new LuaNumber(char.ConvertToUtf32(str.Text, start - 1 + i));
}
return(new LuaMultiValue(numbers));
}
public static LuaValue Tonumber(LuaValue[] values)
{
LuaString text = values[0] as LuaString;
if (text != null)
{
return(new LuaNumber(double.Parse(text.Text)));
}
LuaString number = values[0] as LuaString;
if (number != null)
{
return(number);
}
return(LuaNil.Nil);
}
public static void RefString(IntPtr strPoint, int index, string s, IntPtr L)
{
//超过缓存上限就等着 释放吧
if (weakDictionary.Count >= MAX_WEAK_STRING)
{
return;
}
int oldTop = LuaLib.lua_gettop(L);
LuaLib.lua_pushvalue(L, index);
int refIndex = LuaLib.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
LuaLib.lua_settop(L, oldTop);
//TODO 这里要不要改下，暂时 XLUA没有 用L查询 LuaEnv的接口
LuaString ls = new LuaString(refIndex, LuaProfiler.mainEnv, s, strPoint);
weakDictionary[(long)strPoint] = ls;
}
public void Init(GameObject obj, MonoBehaviour mb)
{
string s = "test test test from cs2lua !";
Debug.Log(s);
mb.StartCoroutine(this.TestCoroutine());
root = new GameObject("root");
var slider = GameObject.Find("Canvas/Slider").GetComponent(typeof(UnityEngine.UI.Slider)) as UnityEngine.UI.Slider;
var counttxt = GameObject.Find("Canvas/Count").GetComponent(typeof(UnityEngine.UI.Text)) as UnityEngine.UI.Text;
slider.onValueChanged.AddListener((float v) => {
Reset();
counttxt.text = LuaString.Format("cube:{0}", v);
max = (int)v;
});
Reset();
}
public static LuaValue sub(LuaValue[] values)
{
LuaString str = values[0] as LuaString;
LuaNumber startNumber = values[1] as LuaNumber;
LuaNumber endNumber = values.Length > 2 ? values[2] as LuaNumber : null;
int start = (int)startNumber.Number;
int end = endNumber == null ? -1 : (int)endNumber.Number;
if (start < 0)
{
start = str.Text.Length + start + 1;
}
if (end < 0)
{
end = str.Text.Length + end + 1;
}
return(new LuaString(str.Text.Substring(start - 1, end - start + 1)));
}
/// <summary>
/// Registers a type with the globals table.
/// </summary>
/// <param name="t">The type to register.</param>
/// <param name="name">The name of the type.</param>
/// <exception cref="System.ArgumentException">If there is already an
/// object registered with that name.</exception>
/// <exception cref="System.ArgumentNullException">If t or name is null.</exception>
public virtual void RegisterType(Type t, string name)
{
if (t == null)
throw new ArgumentNullException("t");
if (name == null)
throw new ArgumentNullException("name");
lock (this)
{
var n = new LuaString(name);
ILuaValue o = GlobalsTable.GetItemRaw(n);
if (o != LuaNil.Nil)
{
throw new ArgumentException(string.Format(Resources.AlreadyRegistered, name));
}
else
GlobalsTable.SetItemRaw(n, new LuaType(t));
}
}
