public override LuaValue Execute(LuaTable enviroment, out bool isBreak)
{
LuaNumber start = this.Start.Evaluate(enviroment) as LuaNumber;
LuaNumber end = this.End.Evaluate(enviroment) as LuaNumber;
double step = 1;
if (this.Step != null)
{
step = (this.Step.Evaluate(enviroment) as LuaNumber).Number;
}
var table = new LuaTable(enviroment);
table.SetNameValue(this.VarName, start);
this.Body.Enviroment = table;
while (step > 0 && start.Number <= end.Number ||
step <= 0 && start.Number >= end.Number)
{
var returnValue = this.Body.Execute(out isBreak);
if (returnValue != null || isBreak == true)
{
isBreak = false;
return(returnValue);
}
start.Number += step;
}
isBreak = false;
return(null);
}
public static LuaValue Wait(LuaValue[] args)
{
LuaNumber time = args[0] as LuaNumber;
if (time == null)
{
LuaFunction cond = args[0] as LuaFunction;
if (cond == null)
{
throw new Exception("wait: object '" + args[0] + "' is not a number or function!");
}
bool condOK = false;
while (!condOK)
{
try
{
condOK = cond.Invoke(null).GetBooleanValue();
}
catch (Exception e)
{
A8Console.WriteLine("Exception on wait: " + e.GetType().Name + " - " + e.Message);
}
if (!condOK)
{
System.Threading.Thread.Sleep(100);
}
}
}
else
{
System.Threading.Thread.Sleep(int.Parse((time.Number * 1000).ToString()));
}
return(null);
}
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 randomseed(LuaValue[] values)
{
LuaNumber number = CheckArgs(values);
randomGenerator = new Random((int)number.Number);
return(number);
}
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 Wait(LuaValue[] args)
{
LuaNumber time = args[0] as LuaNumber;
if (time == null)
{
throw new Exception("object '" + args[0] + "' is not a number!");
}
System.Threading.Thread.Sleep(int.Parse((time.Number * 1000).ToString()));
return(null);
}
public void NumberOperators()
{
LuaNumber ln = 5;
Assert.IsTrue(6 == ln + 1);
Assert.IsTrue(1 + ln == 6);
Assert.IsTrue(6 == (LuaNumber)1 + ln);
Assert.IsTrue(20 == ln * 4);
Assert.IsNull((LuaNumber)null + 5);
}
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()));
}
private Object floatToInt(Object key)
{
if (TypeExtension.TypeEqual <double>(key))
{
double f = (double)key;
if (LuaNumber.IsInteger(f))
{
return(Convert.ToInt64(f));
}
}
return(key);
}
public static LuaValue modf(LuaValue[] values)
{
LuaNumber number = CheckArgs(values);
double integer = Math.Floor(number.Number);
return(new LuaMultiValue(new LuaNumber[]
{
new LuaNumber(integer),
new LuaNumber(number.Number - integer)
}
));
}
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 setn(LuaValue[] values) //[PixelCrushers]
{
if (values.Length >= 2)
{
LuaTable table = values[0] as LuaTable;
LuaNumber number = values[1] as LuaNumber;
if (table != null && number != null)
{
table.SetNameValue("n", number);
}
}
return(LuaNil.Nil);
}
public static LuaValue UnPack(LuaValue[] values)
{
LuaTable table = values[0] as LuaTable;
LuaNumber startNumber = values.Length > 1 ? values[1] as LuaNumber : null;
LuaNumber lengthNumber = values.Length > 2 ? values[2] as LuaNumber : null;
int start = startNumber == null ? 1 : (int)startNumber.Number;
int length = lengthNumber == null ? values.Length : (int)lengthNumber.Number;
LuaValue[] section = new LuaValue[length];
for (int i = 0; i < length; i++)
{
section[i] = table.GetValue(start + i);
}
return(new LuaMultiValue(section));
}
public static LuaValue remove(LuaValue[] values)
{
LuaTable table = values[0] as LuaTable;
int index = table.Length;
if (values.Length == 2)
{
LuaNumber number = values[1] as LuaNumber;
index = (int)number.Number;
}
LuaValue item = table.GetValue(index);
table.RemoveAt(index);
return(item);
}
public static LuaValue random(LuaValue[] values)
{
if (values.Length == 0)
{
return(new LuaNumber(randomGenerator.NextDouble()));
}
else if (values.Length == 1)
{
LuaNumber number1 = values[0] as LuaNumber;
return(new LuaNumber(randomGenerator.Next((int)number1.Number + 1))); //[PixelCrushers] Added "+1" (upper is exclusive)
}
else
{
var numbers = CheckArgs2(values);
return(new LuaNumber(randomGenerator.Next((int)numbers.Item1, (int)numbers.Item2 + 1))); //[PixelCrushers] Added "+1" (upper is exclusive)
}
}
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 @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 random(LuaValue[] values)
{
if (values.Length == 0)
{
return(new LuaNumber(randomGenerator.NextDouble()));
}
else if (values.Length == 1)
{
LuaNumber number1 = values[0] as LuaNumber;
return(new LuaNumber(randomGenerator.Next((int)number1.Number)));
}
else
{
var numbers = CheckArgs2(values);
return(new LuaNumber(randomGenerator.Next((int)numbers.Item1, (int)numbers.Item2)));
}
}
public static LuaValue maxn(LuaValue[] values)
{
LuaTable table = values[0] as LuaTable;
double maxIndex = double.MinValue;
foreach (var key in table.Keys)
{
LuaNumber number = key as LuaNumber;
if (number != null && number.Number > 0)
{
if (number.Number > maxIndex)
{
maxIndex = number.Number;
}
}
}
return(new LuaNumber(maxIndex));
}
public static LuaValue insert(LuaValue[] values)
{
LuaTable table = values[0] as LuaTable;
if (values.Length == 2)
{
LuaValue item = values[1];
table.AddValue(item);
}
else if (values.Length == 3)
{
LuaNumber number = values[1] as LuaNumber;
LuaValue item = values[2];
int index = (int)number.Number;
table.InsertValue(index, item);
}
return(null);
}
public static long?ToInteger(string s)
{
long?i = LuaNumber.ParseLong(s);
if (i != null)
{
return(i);
}
double?f = LuaNumber.ParseDouble(s);
if (f != null && LuaNumber.IsInteger(f))
{
return(LuaNumber.ParseLong(f));
}
else
{
return(null);
}
}
private static LuaNumber CheckArgs(LuaValue[] values)
{
if (values.Length >= 1)
{
LuaNumber number = values[0] as LuaNumber;
if (number != null)
{
return(number);
}
else
{
throw new LuaError("bad argument #1 to 'abs' (number expected, got {0})", values[0].GetTypeCode());
}
}
else
{
throw new LuaError("bad argument #1 to 'abs' (number expected, got no value)");
}
}
public static double?ToFloat(Object val)
{
if (TypeExtension.TypeEqual <double>(val))
{
return((double)val);
}
else if (TypeExtension.TypeEqual <long>(val))
{
return(Convert.ToDouble(((long)val)));
}
else if (TypeExtension.TypeEqual <string>(val))
{
return(LuaNumber.ParseDouble((string)val));
}
else
{
return(null);
}
}
private static int?Compare(LuaValue leftValue, LuaValue rightValue)
{
LuaNumber left = leftValue as LuaNumber;
LuaNumber right = rightValue as LuaNumber;
if (left != null && right != null)
{
return(left.Number.CompareTo(right.Number));
}
LuaString leftString = leftValue as LuaString;
LuaString rightString = rightValue as LuaString;
if (leftString != null && rightString != null)
{
return(StringComparer.Ordinal.Compare(leftString.Text, rightString.Text));
}
return(null);
}
public static long?ToInteger(Object val)
{
if (TypeExtension.TypeEqual <long>(val))
{
return((long)val);
}
else if (TypeExtension.TypeEqual <double>(val))
{
double n = (double)val;
return(LuaNumber.IsInteger(n) ? (long?)n : null);
}
else if (TypeExtension.TypeEqual <string>(val))
{
return(ToInteger((string)val));
}
else
{
return(null);
}
}
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)));
}
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 find(LuaValue[] values) //[PixelCrushers] Added string.find()
{
LuaString strValue = values[0] as LuaString;
LuaString patternValue = values[1] as LuaString;
LuaNumber initNumber = values.Length > 2 ? values[2] as LuaNumber : null;
//---Not implemented: LuaBoolean plainBoolean = values.Length > 3 ? values[3] as LuaBoolean : null;
string s = strValue.ToString();
string pattern = patternValue.ToString();
int init = (initNumber != null) ? (int)initNumber.Number : 1;
//---Not implemented: bool plain = (plainBoolean != null) ? plainBoolean.BoolValue : false;
var startIndex = s.IndexOf(pattern, init - 1) + 1;
if (startIndex == 0)
{
return(LuaNil.Nil);
}
var endIndex = startIndex + pattern.Length - 1;
var result = new LuaTable();
result.AddValue(new LuaNumber(startIndex));
result.AddValue(new LuaNumber(endIndex));
return(result);
}
private static Tuple <double, double> CheckArgs2(LuaValue[] values)
{
if (values.Length >= 2)
{
LuaNumber number1 = values[0] as LuaNumber;
if (number1 == null)
{
throw new LuaError("bad argument #1 to 'abs' (number expected, got {0})", values[0].GetTypeCode());
}
LuaNumber number2 = values[1] as LuaNumber;
if (number2 == null)
{
throw new LuaError("bad argument #2 to 'abs' (number expected, got {0})", values[1].GetTypeCode());
}
return(Tuple.Create(number1.Number, number2.Number));
}
else
{
throw new LuaError("bad argument #1 to 'abs' (number expected, got no value)");
}
}
public static LuaValue Select(LuaValue[] values)
{
LuaNumber number = values[0] as LuaNumber;
if (number != null)
{
int index = (int)number.Number;
LuaValue[] args = new LuaValue[values.Length - index];
for (int i = 0; i < args.Length; i++)
{
args[i] = values[index + i];
}
return(new LuaMultiValue(args));
}
LuaString text = values[0] as LuaString;
if (text.Text == "#")
{
return(new LuaNumber(values.Length - 1));
}
return(LuaNil.Nil);
}
public static LuaValue cosh(LuaValue[] values)
{
LuaNumber number = CheckArgs(values);
return(new LuaNumber(Math.Cosh(number.Number)));
}
