static ILuaMultiValue _getStream(ILuaValue file, ILuaEnvironment E, out Stream s)
{
s = null;
if (file == LuaNil.Nil)
{
if (_output == null)
{
return(E.Runtime.CreateMultiValueFromObj(null, "No default output file set."));
}
s = _output;
}
else
{
if (file.ValueType == LuaValueType.Table)
{
s = ((ILuaTable)file).GetItemRaw(_stream).GetValue() as Stream;
if (s == null)
{
return(E.Runtime.CreateMultiValueFromObj(null, "Specified argument is not a valid file stream."));
}
}
else if (file.ValueType == LuaValueType.UserData)
{
s = file.GetValue() as Stream;
}
else
{
return(E.Runtime.CreateMultiValueFromObj(null, "Specified argument is not a valid file stream."));
}
}
return(null);
}
/// <summary>
/// Defines basic arithmetic for derived classes. This returns a
/// non-null value when default, or null if it is a visitor. This
/// throws if not a visitor.
/// </summary>
/// <param name="type">The type of operation to perform.</param>
/// <param name="other">The other value to use.</param>
/// <returns>The result of the operation.</returns>
/// <exception cref="System.InvalidOperationException">
/// If the operation cannot be performed with the given values.
/// </exception>
/// <exception cref="System.InvalidArgumentException">
/// If the argument is an invalid value.
/// </exception>
protected ILuaValue ArithmeticBase(BinaryOperationType type, ILuaValue other)
{
// Attempt to use a meta-method.
var ret = AttempMetamethod(type, this, other);
if (ret != null)
{
return(ret);
}
// Do some default operations.
ret = DefaultArithmetic(type, other);
if (ret != null)
{
return(ret);
}
// If the other is not a visitor, throw.
if (!(other is ILuaValueVisitor))
{
throw new InvalidOperationException(Errors.CannotArithmetic(this.ValueType));
}
else
{
return(null);
}
}
protected override ILuaMultiValue _invokeInternal(ILuaMultiValue args)
{
if (args.Count < 2)
{
throw new ArgumentException("Expecting at least two arguments to function 'overload'.");
}
ILuaValue meth = args[0];
ILuaValue obj = args[1];
if (meth.ValueType != LuaValueType.Function)
{
throw new ArgumentException("First argument to function 'overload' must be a method.");
}
if (obj.ValueType != LuaValueType.Number || ((double)obj.GetValue() % 1 != 0))
{
throw new ArgumentException(
"Second argument to function 'overload' must be an integer.");
}
int i = Convert.ToInt32((double)obj.GetValue());
return(meth.Invoke(null, false, i,
_environment.Runtime.CreateMultiValue(args.Skip(2).ToArray())));
}
void insert(ILuaTable table, ILuaValue pos, ILuaValue value = null)
{
CheckNotNull("table.insert", table);
CheckNotNull("table.insert", pos);
double i;
double len = table.Length().AsDouble() ?? 0;
if (value == null)
{
value = pos;
i = len + 1;
}
else
{
i = pos.AsDouble() ?? 0;
}
if (i > len + 1 || i < 1 || i % 1 != 0)
{
throw new ArgumentException(
"Position given to function 'table.insert' is outside valid range.");
}
for (double d = len; d >= i; d--)
{
var temp = table.GetItemRaw(E.Runtime.CreateValue(d));
table.SetItemRaw(E.Runtime.CreateValue(d + 1), temp);
}
table.SetItemRaw(pos, value);
}
protected override ILuaMultiValue _invokeInternal(ILuaValue target, bool memberCall,
int overload, ILuaMultiValue args)
{
ILuaValue method = (ILuaValue)Activator.CreateInstance(_type, new[] { _env });
return(method.Invoke(LuaNil.Nil, false, -1, args));
}
string concat(ILuaTable table, string sep = null, int i = 1, int j = -1)
{
CheckNotNull("table.concat", table);
int len = (int)(table.Length().AsDouble() ?? 0);
if (i >= len)
{
return("");
}
i = normalizeIndex_(len, i);
j = normalizeIndex_(len, j);
StringBuilder str = new StringBuilder();
for (; i <= j; i++)
{
ILuaValue temp = table.GetItemRaw(E.Runtime.CreateValue(i));
if (temp.ValueType != LuaValueType.String && temp.ValueType != LuaValueType.Number)
{
throw new ArgumentException(
"Invalid '" + temp.ValueType + "' value for function 'table.concat'.");
}
if (str.Length > 0)
{
str.Append(sep);
}
str.Append(temp);
}
return(str.ToString());
}
ILuaValue create(ILuaValue method)
{
if (method.ValueType != LuaValueType.Function)
throw new ArgumentException("First argument to function 'coroutine.create' must be a function.");
return E_.Runtime.CreateThread(method);
}
protected override ILuaMultiValue InvokeInternal(ILuaMultiValue args)
{
ILuaValue obj = args[0];
if (obj != LuaNil.Nil)
{
if (obj.ValueType == LuaValueType.String)
{
Stream s = File.OpenRead(obj.GetValue() as string);
_output = s;
}
else if (obj.ValueType == LuaValueType.Table)
{
Stream s = ((ILuaTable)obj).GetItemRaw(_stream) as Stream;
if (s == null)
{
throw new InvalidOperationException("First argument to function 'io.output' must be a file-stream or a string path.");
}
_output = s;
}
else if (obj is Stream)
{
_output = obj as Stream;
}
else
{
throw new InvalidOperationException("First argument to function 'io.output' must be a file-stream or a string path.");
}
}
return(Environment.Runtime.CreateMultiValue(_CreateFile(_output, Environment)));
}
static void Register(ILuaEnvironment env, ILuaValue table, Delegate func, string name = null)
{
var funcValue = env.Runtime.CreateValue(func);
var nameValue = env.Runtime.CreateValue(name ?? func.Method.Name);
table.SetIndex(nameValue, funcValue);
}
public override ILuaMultiValue Invoke(ILuaValue self, bool memberCall, int overload, ILuaMultiValue args)
{
if (overload >= 0)
{
throw new NotSupportedException(string.Format(Resources.CannotUseOverload, "LuaType"));
}
if (args == null)
{
args = new LuaMultiValue();
}
Type t = Type;
if (Helpers.GetCompatibleMethod(
t.GetConstructors()
.Where(c => c.GetCustomAttributes(typeof(LuaIgnoreAttribute), true).Length == 0)
.Select(c => Tuple.Create(c, (object)null)),
args, out ConstructorInfo method, out _))
{
object value = method.Invoke(Helpers.ConvertForArgs(args, method));
return(LuaMultiValue.CreateMultiValueFromObj(value));
}
throw new InvalidOperationException(string.Format(Resources.CannotCall, "LuaType"));
}
protected override ILuaMultiValue InvokeInternal(ILuaMultiValue args)
{
ILuaValue obj = args[0];
Stream s;
int start = 0;
if (obj.ValueType == LuaValueType.Table)
{
s = ((ILuaTable)obj).GetItemRaw(_stream) as Stream;
if (s == null)
{
throw new ArgumentException("First argument to io.read must be a file-stream or a file path, make sure to use file:read.");
}
start = 1;
}
else if (obj.GetValue() is Stream)
{
s = obj.GetValue() as Stream;
start = 1;
}
else
{
s = _input;
start = 0;
}
int[] a = _parse(args.Skip(start), "io.read");
return(_read(a, new StreamReader(s), Environment));
}
/// <summary>
/// Performs a binary arithmetic operation and returns the result.
/// </summary>
/// <param name="type">The type of operation to perform.</param>
/// <param name="other">The other value to use.</param>
/// <returns>The result of the operation.</returns>
/// <exception cref="System.InvalidOperationException">
/// If the operation cannot be performed with the given values.
/// </exception>
/// <exception cref="System.InvalidArgumentException">
/// If the argument is an invalid value.
/// </exception>
ILuaValue ILuaValue.Arithmetic(BinaryOperationType type, ILuaValue other)
{
// Attempt to use a meta-method.
var ret = LuaValueBase.AttempMetamethod(type, this, other);
if (ret != null)
{
return(ret);
}
// Do some default operations.
ret = DefaultArithmetic(type, other);
if (ret != null)
{
return(ret);
}
// If the other is not a visitor, throw.
if (!(other is ILuaValueVisitor))
{
throw new InvalidOperationException(Errors.CannotArithmetic(LuaValueType.Function));
}
else
{
return(((ILuaValueVisitor)other).Arithmetic(type, this));
}
}
static ILuaValue _processType(Type t, ILuaEnvironment env)
{
if (!typeof(ILuaValue).IsAssignableFrom(t))
{
return(null);
}
ConstructorInfo ci = t.GetConstructor(new Type[0]);
if (ci == null)
{
ci = t.GetConstructor(new Type[] { typeof(ILuaEnvironment) });
if (ci != null)
{
ILuaValue mod = (ILuaValue)ci.Invoke(new[] { env });
return(mod.Invoke(LuaNil.Nil, false, -1, env.Runtime.CreateMultiValue()).Single());
}
return(null);
}
else
{
ILuaValue mod = (ILuaValue)ci.Invoke(null);
return(mod.Invoke(LuaNil.Nil, false, -1, env.Runtime.CreateMultiValue()).Single());
}
}
/// <summary>
/// Helper function, sets the value at the given index. Uses
/// meta-methods if needed.
/// </summary>
/// <param name="index">The index to use.</param>
/// <param name="value">The value to set to.</param>
void Set(ILuaValue index, ILuaValue value)
{
index = index ?? LuaNil.Nil;
value = value ?? LuaNil.Nil;
ILuaValue ret;
if (!_values.TryGetValue(index, out ret) && MetaTable != null)
{
var method = MetaTable.GetItemRaw(_newindex);
if (method != null && method != LuaNil.Nil)
{
if (method.ValueType == LuaValueType.Function)
{
method.Invoke(this, true, -1, new LuaMultiValue(index, value));
}
else
{
method.SetIndex(index, value);
}
return;
}
}
SetItemRaw(index, value);
}
public override void Assign(ILuaValue value)
{
LuaType type = value as LuaType;
if (type != null)
{
if (Type == null)
{
Type = type.Type;
}
else
{
throw new InvalidOperationException(string.Format(Resources.MemberHasType, Name));
}
}
else
{
if (Default != null)
{
throw new InvalidOperationException(string.Format(Resources.MemberHasDefault, Name));
}
if (Type == null)
{
object temp = value == null ? value : value.GetValue();
Type = temp == null ? typeof(object) : temp.GetType();
}
Default = value;
}
}
/// <summary>
/// Performs some default arithmetic like comparisons and returns the result.
/// Returns null if there is no default.
/// </summary>
/// <param name="type">The type of operation to perform.</param>
/// <param name="other">The other value to use.</param>
/// <returns>The result of the operation.</returns>
private ILuaValue DefaultArithmetic(BinaryOperationType type, ILuaValue other)
{
switch (type)
{
case BinaryOperationType.Concat:
return(new LuaString(this.ToString() + other.ToString()));
case BinaryOperationType.Gt:
return(LuaBoolean.Create(CompareTo(other) > 0));
case BinaryOperationType.Lt:
return(LuaBoolean.Create(CompareTo(other) < 0));
case BinaryOperationType.Gte:
return(LuaBoolean.Create(CompareTo(other) >= 0));
case BinaryOperationType.Lte:
return(LuaBoolean.Create(CompareTo(other) <= 0));
case BinaryOperationType.Equals:
return(LuaBoolean.Create(Equals(other)));
case BinaryOperationType.NotEquals:
return(LuaBoolean.Create(!Equals(other)));
case BinaryOperationType.And:
return(other);
case BinaryOperationType.Or:
return(this);
default:
return(null);
}
}
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));
}
}
}
protected override ILuaMultiValue InvokeInternal(ILuaMultiValue args)
{
if (args.Count < 1)
{
throw new ArgumentException("Expecting at least one argument to function 'pcall'.");
}
ILuaValue func = args[0];
if (func.ValueType == LuaValueType.Function)
{
try
{
var ret = func.Invoke(LuaNil.Nil, false, -1, Environment.Runtime.CreateMultiValue(args.Skip(1).ToArray()));
return(Environment.Runtime.CreateMultiValue(new ILuaValue[] { LuaBoolean.True }.Union(ret).ToArray()));
}
catch (ThreadAbortException)
{
throw;
}
catch (ThreadInterruptedException)
{
throw;
}
catch (Exception e)
{
return(Environment.Runtime.CreateMultiValueFromObj(false, e.Message, e));
}
}
else
{
throw new ArgumentException("First argument to 'pcall' must be a function.");
}
}
static ILuaValue assert(ILuaValue value, ILuaValue obj = null)
{
string message = "Assertion failed: '" + (obj != null ? obj.ToString() : "") + "'.";
if (value.IsTrue)
return obj;
else
throw new AssertException(message);
}
protected override ILuaMultiValue _invokeInternal(ILuaValue target, bool methodCall,
int overload, ILuaMultiValue args) {
if (methodCall) {
args = new LuaMultiValue(new[] { target }.Concat(args).ToArray());
}
return _invokeInternal(args);
}
/// <summary>
/// Gets the value at the given index without using meta-methods.
/// </summary>
/// <param name="index">The index to get at.</param>
/// <returns>The value at the given index.</returns>
public ILuaValue GetItemRaw(ILuaValue index)
{
index = index ?? LuaNil.Nil;
ILuaValue ret;
return(_values.TryGetValue(index, out ret) && ret != null ? ret : LuaNil.Nil);
}
private LuaClass GetLuaClass(string name)
{
ILuaValue luaName = Lua.Environment.Runtime.CreateValue(name);
ILuaValue cls = Lua.Environment.GlobalsTable.GetItemRaw(luaName);
Assert.IsInstanceOf <LuaClass>(cls);
return((LuaClass)cls);
}
/// <summary>
/// Creates a new LuaThread object that calls the given method.
/// </summary>
/// <param name="env">The current environment.</param>
/// <param name="method">The method to invoke.</param>
internal LuaThreadNet(ILuaEnvironment env, ILuaValue method)
{
IsLua = true;
_env = env;
_method = method;
_backing = new Thread(_do);
_releaseBacking = true;
}
/// <summary>
/// Creates a new LuaThread object that calls the given method and executes on the given thread.
/// </summary>
/// <param name="env">The current environment.</param>
/// <param name="method">The method to invoke.</param>
/// <param name="thread">The thread that will execute this thread.</param>
internal LuaThreadNet(ILuaEnvironment env, Thread thread, ILuaValue method)
{
IsLua = true;
_env = env;
_method = method;
_backing = thread;
_releaseBacking = false;
}
/// <summary>
/// Creates a new LuaThread object that calls the given method and
/// executes on the given thread.
/// </summary>
/// <param name="E">The current environment.</param>
/// <param name="method">The method to invoke.</param>
/// <param name="thread">The thread that will execute this thread.</param>
internal LuaThreadNet(ILuaEnvironment E, Thread thread, ILuaValue method)
{
this.IsLua = true;
this.E_ = E;
this.method_ = method;
this.backing_ = thread;
this.releaseBacking_ = false;
}
/// <summary>
/// Creates a new LuaThread object that calls the given method.
/// </summary>
/// <param name="E">The current environment.</param>
/// <param name="method">The method to invoke.</param>
internal LuaThreadNet(ILuaEnvironment E, ILuaValue method)
{
this.IsLua = true;
this.E_ = E;
this.method_ = method;
this.backing_ = new Thread(Do);
this.releaseBacking_ = true;
}
/// <summary>
/// Creates a new LuaThread object that calls the given method.
/// </summary>
/// <param name="E">The current environment.</param>
/// <param name="method">The method to invoke.</param>
internal LuaThreadNet(ILuaEnvironment E, ILuaValue method)
{
this.IsLua = true;
this.E_ = E;
this.method_ = method;
this.backing_ = new Thread(Do);
this.releaseBacking_ = true;
}
/// <summary>
/// Creates a new LuaThread object that calls the given method and
/// executes on the given thread.
/// </summary>
/// <param name="E">The current environment.</param>
/// <param name="method">The method to invoke.</param>
/// <param name="thread">The thread that will execute this thread.</param>
internal LuaThreadNet(ILuaEnvironment E, Thread thread, ILuaValue method)
{
this.IsLua = true;
this.E_ = E;
this.method_ = method;
this.backing_ = thread;
this.releaseBacking_ = false;
}
protected override ILuaMultiValue InvokeInternal(ILuaMultiValue args)
{
ILuaValue obj = args[0];
Stream s;
int start = 0;
if (obj.ValueType == LuaValueType.Table)
{
s = ((ILuaTable)obj).GetItemRaw(_stream) as Stream;
if (s == null)
{
return(Environment.Runtime.CreateMultiValueFromObj(null, "First argument must be a file-stream or a file path."));
}
start = 1;
}
else if (obj is Stream)
{
s = obj as Stream;
start = 1;
}
else
{
s = _output;
start = 0;
}
try
{
for (int i = start; i < args.Count; i++)
{
var temp = args[i].GetValue();
if (temp is double)
{
var bt = (Environment.Settings.Encoding ?? Encoding.UTF8).GetBytes(((double)temp).ToString(CultureInfo.InvariantCulture));
s.Write(bt, 0, bt.Length);
}
else if (temp is string)
{
var bt = (Environment.Settings.Encoding ?? Encoding.UTF8).GetBytes(temp as string);
s.Write(bt, 0, bt.Length);
}
else
{
throw new ArgumentException("Arguments to io.write must be a string or number.");
}
}
return(Environment.Runtime.CreateMultiValue(_CreateFile(s, Environment)));
}
catch (ArgumentException)
{
throw;
}
catch (Exception e)
{
return(Environment.Runtime.CreateMultiValueFromObj(null, e.Message, e));
}
}
public override void SetIndex(ILuaValue index, ILuaValue value)
{
string name = index.GetValue() as string;
int overload = -1;
if (name == null)
{
throw new InvalidOperationException(string.Format(Resources.BadIndexType, "class definition", "string"));
}
// find if name is defining an overload.
if (name.Contains('`'))
{
if (!int.TryParse(name.Substring(name.IndexOf('`') + 1), out overload))
{
throw new InvalidOperationException(Resources.OnlyNumbersInOverload);
}
name = name.Substring(0, name.IndexOf('`'));
}
// find the members with the given name.
var members = type.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance).Where(m => m.Name == name).ToArray();
if (members == null || members.Length == 0)
{
throw new InvalidOperationException(string.Format(Resources.NoMemberFound, type, name));
}
if (members.Length > 1 && overload == -1)
{
throw new AmbiguousMatchException(string.Format(Resources.NoMemberFound, type, name));
}
if (overload != -1 && overload >= members.Length)
{
throw new InvalidOperationException(Resources.OverloadOutOfRange);
}
// set the backing parrent object.
name = type.FullName + "." + name;
if (members[0].MemberType == MemberTypes.Method)
{
if (value.ValueType != LuaValueType.Function)
{
throw new InvalidOperationException(string.Format(Resources.MustBeFunction, name));
}
Item item = parent.CreateItem(name, new[] { members[overload == -1 ? 0 : overload] });
item.Assign(value);
parent._items.Add(item);
}
else if (members[0].MemberType == MemberTypes.Property)
{
Item item = parent.CreateItem(name, members);
item.Assign(value);
parent._items.Add(item);
}
}
public override void Assign(ILuaValue value)
{
if (value.ValueType == LuaValueType.Table)
{
// set the 'get' method for the item
var item = value.GetIndex(new LuaString("get"));
if (item != null && item != LuaNil.Nil)
{
MethodInfo m = _prop.GetGetMethod(true);
if (m == null || (!m.Attributes.HasFlag(MethodAttributes.Abstract) && !m.Attributes.HasFlag(MethodAttributes.Virtual)))
{
throw new InvalidOperationException(string.Format(Resources.CannotOverrideProperty, Name));
}
BoundTo = m;
if (item.ValueType != LuaValueType.Function)
{
throw new InvalidOperationException(Resources.PropTableFuncs);
}
Method = item;
}
// set the 'set' method for the item
item = value.GetIndex(new LuaString("set"));
if (item != null && item != LuaNil.Nil)
{
MethodInfo m = _prop.GetSetMethod(true);
if (m == null || (!m.Attributes.HasFlag(MethodAttributes.Abstract) && !m.Attributes.HasFlag(MethodAttributes.Virtual)))
{
throw new InvalidOperationException(string.Format(Resources.CannotOverrideProperty, Name));
}
BoundSet = m;
if (item.ValueType != LuaValueType.Function)
{
throw new InvalidOperationException(Resources.PropTableFuncs);
}
MethodSet = item;
}
}
else
{
MethodInfo m = _prop.GetGetMethod(true);
if (m == null || (!m.Attributes.HasFlag(MethodAttributes.Abstract) && !m.Attributes.HasFlag(MethodAttributes.Virtual)))
{
throw new InvalidOperationException(string.Format(Resources.CannotOverrideProperty, Name));
}
BoundTo = m;
// check if the set method is abstract, if it is, we need to implement that also.
m = _prop.GetSetMethod(true);
if (m != null && (m.Attributes & MethodAttributes.Abstract) == MethodAttributes.Abstract)
{
BoundSet = m;
}
Default = value;
}
}
public override void SetIndex(ILuaValue index, ILuaValue value)
{
if (Value == null)
{
throw new InvalidOperationException(Errors.CannotIndex(LuaValueType.Nil));
}
Helpers.GetSetMember(Value.GetType(), Value, index, value);
}
public override ILuaValue GetIndex(ILuaValue index)
{
if (Value == null)
{
throw new InvalidOperationException(Errors.CannotIndex(LuaValueType.Nil));
}
return(Helpers.GetSetMember(Value.GetType(), Value, index));
}
ILuaValue create(ILuaValue method)
{
if (method.ValueType != LuaValueType.Function)
{
throw new ArgumentException("First argument to function 'coroutine.create' must be a function.");
}
return(E_.Runtime.CreateThread(method));
}
object wrap(ILuaValue func)
{
if (func.ValueType != LuaValueType.Function)
{
throw new ArgumentException(
"First argument to function 'coroutine.wrap' must be a function.");
}
var thread = E_.Runtime.CreateThread(func);
return (Func<ILuaMultiValue, ILuaMultiValue>)thread.Resume;
}
/// <summary>
/// Creates a new LuaThread for the given action.
/// </summary>
/// <param name="action">The method to invoke.</param>
/// <returns>A new LuaThread object that will invoke the given method.</returns>
/// <exception cref="System.ArgumentNullException">If action is null.</exception>
public ILuaThread Create(ILuaValue action)
{
lock (lock_)
{
CheckDisposed();
ResizePool();
WorkerThread thread = waitingThreads_.Dequeue();
thread.DoWork(action);
return thread.Target;
}
}
/// <summary>
/// Makes the current thread execute the given method.
/// </summary>
/// <param name="target">The method to execute.</param>
public void DoWork(ILuaValue target)
{
if (status_ != Status.Waiting)
{
throw new InvalidOperationException(
"The worker thread must be waiting to get a new task.");
}
Target = new LuaThreadNet(E_, backing_, target);
status_ = Status.Working;
lock (lock_)
Monitor.Pulse(lock_);
}
/// <summary>
/// Performs that actual invokation of the method.
/// </summary>
/// <param name="E">The current environment.</param>
/// <param name="target">The object that this was called on.</param>
/// <param name="memberCall">Whether the call used member call syntax (:).</param>
/// <param name="args">The current arguments, not null but maybe empty.</param>
/// <param name="overload">The overload to chose or negative to do
/// overload resoltion.</param>
/// <param name="byRef">An array of the indicies that are passed by-reference.</param>
/// <returns>The values to return to Lua.</returns>
/// <exception cref="System.ArgumentException">If the object cannot be
/// invoked with the given arguments.</exception>
/// <exception cref="System.Reflection.AmbiguousMatchException">If there are two
/// valid overloads for the given arguments.</exception>
/// <exception cref="System.IndexOutOfRangeException">If overload is
/// larger than the number of overloads.</exception>
/// <exception cref="System.NotSupportedException">If this object does
/// not support overloads.</exception>
protected override ILuaMultiValue InvokeInternal(ILuaValue target, bool methodCall, int overload, ILuaMultiValue args)
{
return _Method(_E, args, target, methodCall);
}
static ILuaValue getmetatable(ILuaValue value)
{
if (value.ValueType != LuaValueType.Table)
return LuaNil.Nil;
ILuaTable meta = ((ILuaTable)value).MetaTable;
if (meta != null)
{
ILuaValue method = meta.GetItemRaw(_metamethod);
if (method != null && method != LuaNil.Nil)
return method;
}
return meta;
}
static string tostring(ILuaValue value)
{
if (value.ValueType == LuaValueType.Table)
{
var meta = ((ILuaTable)value).MetaTable;
if (meta != null)
{
var m = meta.GetItemRaw(_tostring);
if (m != null && m.ValueType == LuaValueType.Function)
{
var result = m.Invoke(value, true, -1, LuaMultiValue.Empty);
return result[0].ToString();
}
}
}
return value.ToString();
}
static bool rawequal(ILuaValue v1, ILuaValue v2)
{
return object.Equals(v1, v2);
}
static object[] next(ILuaTable table, ILuaValue index)
{
bool return_next = index == LuaNil.Nil;
foreach (var item in table)
{
if (return_next)
return new object[] { item.Key, item.Value };
else if (item.Key == index)
return_next = true;
}
// return nil, nil;
return new object[0];
}
static string gsub(string source, string pattern, ILuaValue repl, int n = int.MaxValue)
{
CheckNotNull("string.gsub", source);
CheckNotNull("string.gsub", pattern);
return Regex.Replace(source, pattern, new gsubHelper(repl, n).Match);
}
static string type(ILuaValue value)
{
return value.ValueType.ToString().ToLower();
}
static ILuaValue rawset(ILuaTable table, ILuaValue index, ILuaValue value)
{
table.SetItemRaw(index, value);
return table;
}
/// <summary>
/// Creates a new Lua thread that calls the given method.
/// </summary>
/// <param name="method">The method to call.</param>
/// <returns>The new Lua thread object.</returns>
public ILuaThread CreateThread(ILuaValue method)
{
return threadPool_.Create(method);
}
static ILuaValue setmetatable(ILuaTable table, ILuaValue metatable)
{
if (metatable == LuaNil.Nil)
table.MetaTable = null;
else if (metatable.ValueType == LuaValueType.Table)
table.MetaTable = (ILuaTable)metatable;
else
{
throw new ArgumentException(
"Second argument to 'setmetatable' must be a table.");
}
return table;
}
static IEnumerable<object> select(ILuaValue index, params object[] args)
{
if (index.Equals("#"))
{
return new object[] { args.Length };
}
else if (index.ValueType == LuaValueType.Number)
{
double ind = index.AsDouble() ?? 0;
if (ind < 0)
ind = args.Length + ind + 1;
return args.Skip((int)(ind - 1));
}
else
{
throw new ArgumentException(
"First argument to function 'select' must be a number or the string '#'.");
}
}
static double? tonumber(ILuaValue value)
{
return value.AsDouble();
}
static ILuaMultiValue _getStream(ILuaValue file, ILuaEnvironment E, out Stream s)
{
s = null;
if (file == LuaNil.Nil)
{
if (_output == null)
return E.Runtime.CreateMultiValueFromObj(null, "No default output file set.");
s = _output;
}
else
{
if (file.ValueType == LuaValueType.Table)
{
s = ((ILuaTable)file).GetItemRaw(_stream).GetValue() as Stream;
if (s == null)
return E.Runtime.CreateMultiValueFromObj(null, "Specified argument is not a valid file stream.");
}
else if (file.ValueType == LuaValueType.UserData)
{
s = file.GetValue() as Stream;
}
else
return E.Runtime.CreateMultiValueFromObj(null, "Specified argument is not a valid file stream.");
}
return null;
}
/// <summary>
/// Performs that actual invokation of the method.
/// </summary>
/// <param name="target">The object that this was called on.</param>
/// <param name="memberCall">Whether the call used member call syntax (:).</param>
/// <param name="args">The current arguments, not null but maybe empty.</param>
/// <param name="overload">The overload to chose or negative to do
/// overload resoltion.</param>
/// <param name="byRef">An array of the indicies that are passed by-reference.</param>
/// <returns>The values to return to Lua.</returns>
/// <exception cref="System.ArgumentException">If the object cannot be
/// invoked with the given arguments.</exception>
/// <exception cref="System.Reflection.AmbiguousMatchException">If there are two
/// valid overloads for the given arguments.</exception>
/// <exception cref="System.IndexOutOfRangeException">If overload is
/// larger than the number of overloads.</exception>
/// <exception cref="System.NotSupportedException">If this object does
/// not support overloads.</exception>
protected override ILuaMultiValue InvokeInternal(ILuaValue target, bool memberCall, int overload, ILuaMultiValue args)
{
ILuaValue method = (ILuaValue)Activator.CreateInstance(_Type, new[] { _E });
Contract.Assume(method != null);
return method.Invoke(LuaNil.Nil, false, -1, args);
}
static void Register(ILuaEnvironment E, ILuaValue table, Delegate func, string name = null)
{
var funcValue = E.Runtime.CreateValue(func);
var nameValue = E.Runtime.CreateValue(name ?? func.Method.Name);
table.SetIndex(nameValue, funcValue);
}
/// <summary>
/// Performs that actual invokation of the method.
/// </summary>
/// <param name="target">The object that this was called on.</param>
/// <param name="memberCall">Whether the call used member call syntax (:).</param>
/// <param name="args">The current arguments, not null but maybe empty.</param>
/// <param name="overload">The overload to chose or negative to do
/// overload resoltion.</param>
/// <param name="byRef">An array of the indicies that are passed by-reference.</param>
/// <returns>The values to return to Lua.</returns>
/// <exception cref="System.ArgumentException">If the object cannot be
/// invoked with the given arguments.</exception>
/// <exception cref="System.Reflection.AmbiguousMatchException">If there are two
/// valid overloads for the given arguments.</exception>
/// <exception cref="System.IndexOutOfRangeException">If overload is
/// larger than the number of overloads.</exception>
/// <exception cref="System.NotSupportedException">If this object does
/// not support overloads.</exception>
protected override ILuaMultiValue InvokeInternal(ILuaValue target, bool methodCall, int overload, ILuaMultiValue args)
{
if (methodCall) args = new LuaMultiValue(new[] { target }.Concat(args).ToArray());
return InvokeInternal(args);
}
public ILuaThread CreateThread(ILuaValue method)
{
Contract.Requires(method != null);
Contract.Ensures(Contract.Result<ILuaThread>() != null);
return null;
}
static ILuaValue rawget(ILuaTable table, ILuaValue index)
{
return table.GetItemRaw(index);
}
public gsubHelper(ILuaValue value, int max)
{
count_ = 0;
max_ = max;
if (value.ValueType == LuaValueType.String)
string_ = (string)value.GetValue();
else if (value.ValueType == LuaValueType.Table)
table_ = (ILuaTable)value;
else if (value.ValueType == LuaValueType.Function)
method_ = value;
else
throw new ArgumentException("Third argument to function 'string.gsub' must be a string, table, or function.");
}
/// <summary>
/// Creates a delegate that can be called to call the given IMethod.
/// </summary>
/// <param name="E">The current environment.</param>
/// <param name="type">The type of the delegate.</param>
/// <param name="method">The method to call.</param>
/// <returns>A delegate that is used to call the method.</returns>
/// <exception cref="System.ArgumentException">If type is not a delegate
/// type.</exception>
/// <exception cref="System.ArgumentNullException">If any argument is null.</exception>
/// <exception cref="System.NotSupportedException">If this implementation
/// does not support created delegates.</exception>
public Delegate CreateDelegate(ILuaEnvironment E, Type type, ILuaValue method)
{
if (E == null)
throw new ArgumentNullException("E");
if (type == null)
throw new ArgumentNullException("type");
if (method == null)
throw new ArgumentNullException("method");
if (!typeof(Delegate).IsAssignableFrom(type.BaseType))
throw new ArgumentException(Resources.DeriveFromDelegate);
// search through the cache for a compatible delegate helper
object target; // TODO: Make CreateDelegate more efficient.
for (int i = 0; i < _delegateTypes.Count; i++)
{
target = Activator.CreateInstance(_delegateTypes[i], E, method);
Delegate d = Delegate.CreateDelegate(type, target, _delegateTypes[i].GetMethod("Do"), false);
if (d != null)
return d;
}
Type temp = CreateDelegateType(type.GetMethod("Invoke"));
_delegateTypes.Add(temp);
target = Activator.CreateInstance(temp, E, method);
return Delegate.CreateDelegate(type, target, temp.GetMethod("Do"));
}