/// <summary>
/// Gets a Lua expression that is of the given type.
/// </summary>
/// <param name="type">The type of expression.</param>
/// <returns>A valid Lua expression of the given type.</returns>
static string GetValueForType(LuaValueType type)
{
switch (type)
{
case LuaValueType.Nil:
return("nil");
case LuaValueType.String:
return("'foobar'");
case LuaValueType.Bool:
return("true");
case LuaValueType.Table:
return("{}");
case LuaValueType.Function:
return("function() end");
case LuaValueType.Number:
return("123");
case LuaValueType.Thread:
return("coroutine.create(function() end)");
case LuaValueType.UserData:
return("UserData()");
default:
throw new NotImplementedException();
}
}
public Lua()
{
LuaState.loaderDelegate += luaLoader;
luaState = new LuaState();
// LuaDLL.lua_pushstdcallcfunction(luaState.L, import);
//LuaDLL.lua_setglobal(luaState.L, "using");
LuaObject.init(luaState.L);
bindAll(luaState.L);
GameObject go = new GameObject("LuaSvrProxy");
lgo = go.AddComponent <LuaSvrGameObject>();
GameObject.DontDestroyOnLoad(go);
lgo.state = luaState;
lgo.onUpdate = this.tick;
LuaTimer.reg(luaState.L);
LuaCoroutine.reg(luaState.L, lgo);
Helper.reg(luaState.L);
LuaValueType.reg(luaState.L);
LuaDLL.luaS_openextlibs(luaState.L);
/*
* if (LuaDLL.lua_gettop(luaState.L) != errorReported)
* {
* Debug.LogError("Some function not remove temp value from lua stack. You should fix it.");
* errorReported = LuaDLL.lua_gettop(luaState.L);
* }
* */
}
static int GetClassType(IntPtr L)
{
int reference = LuaDLL.tolua_getmetatableref(L, -1);
if (reference > 0)
{
Type t = LuaStatic.GetClassType(L, reference);
Push(L, t);
}
else
{
LuaValueType ret = LuaDLL.tolua_getvaluetype(L, -1);
switch (ret)
{
case LuaValueType.Vector3:
Push(L, typeof(Vector3));
break;
case LuaValueType.Quaternion:
Push(L, typeof(Quaternion));
break;
case LuaValueType.Vector4:
Push(L, typeof(Vector4));
break;
case LuaValueType.Color:
Push(L, typeof(Color));
break;
case LuaValueType.Ray:
Push(L, typeof(Ray));
break;
case LuaValueType.Bounds:
Push(L, typeof(Bounds));
break;
case LuaValueType.Vector2:
Push(L, typeof(Vector2));
break;
case LuaValueType.LayerMask:
Push(L, typeof(LayerMask));
break;
case LuaValueType.RaycastHit:
Push(L, typeof(RaycastHit));
break;
default:
lhDebug.LogError("type not register to lua");
LuaDLL.lua_pushnil(L);
break;
}
}
return(1);
}
private void ExpectType(LuaValueType type)
{
if (m_type != type)
{
throw GenerateTypeError(type.GetTypeName());
}
}
private void ExpectType(LuaValueType type, int index)
{
var foundType = this[index].Type;
if (foundType != type)
{
throw GenerateTypeError(type.GetTypeName(), index);
}
}
static bool lua_isusertable(IntPtr L, Type t, int pos)
{
if (t.IsArray)
{
return(true);
}
else if (t == typeof(LuaTable))
{
return(true);
}
else if (t.IsValueType)
{
LuaValueType vt = LuaDLL.tolua_getvaluetype(L, pos);
switch (vt)
{
case LuaValueType.Vector3:
return(typeof(Vector3) == t);
case LuaValueType.Quaternion:
return(typeof(Quaternion) == t);
case LuaValueType.Color:
return(typeof(Color) == t);
case LuaValueType.Ray:
return(typeof(Ray) == t);
case LuaValueType.Bounds:
return(typeof(Bounds) == t);
case LuaValueType.Vector2:
return(typeof(Vector2) == t);
case LuaValueType.Vector4:
return(typeof(Vector4) == t);
case LuaValueType.Touch:
return(typeof(Touch) == t);
case LuaValueType.LayerMask:
return(typeof(LayerMask) == t);
case LuaValueType.RaycastHit:
return(typeof(RaycastHit) == t);
default:
break;
}
}
else if (LuaDLL.tolua_isvptrtable(L, pos))
{
return(IsMatchUserData(L, t, pos));
}
return(false);
}
/// <summary>
/// 初始化LuaValue对象
/// </summary>
/// <param name="decoder">对象解码器</param>
public LuaValue(LuaObjectDecoder decoder)
: base(decoder)
{
int contextId = decoder.readInt32();
_context = LuaContext.getContext(contextId);
_tableId = decoder.readString();
_type = (LuaValueType)decoder.readInt16();
_value = null;
switch (_type)
{
case LuaValueType.Integer:
_value = decoder.readInt32();
break;
case LuaValueType.Boolean:
_value = decoder.readByte();
break;
case LuaValueType.Number:
_value = decoder.readDouble();
break;
case LuaValueType.Data:
_value = decoder.readBytes();
break;
case LuaValueType.String:
_value = decoder.readString();
break;
case LuaValueType.Array:
_value = readArrayList(decoder);
break;
case LuaValueType.Map:
_value = readHashtable(decoder);
break;
case LuaValueType.Function:
_value = decoder.readObject() as LuaFunction;
break;
case LuaValueType.Ptr:
_value = decoder.readObject() as LuaPointer;
break;
case LuaValueType.Tuple:
_value = decoder.readObject() as LuaTuple;
break;
case LuaValueType.Object:
_value = decoder.readObject();
break;
}
}
private void ExpectType(LuaValue key, LuaValueType type)
{
var value = this[key];
if (value.Type != type)
{
throw GenerateTypeError(type.GetTypeName(), key);
}
}
public static string GetTypeName(this LuaValueType type)
{
switch (type)
{
case LuaValueType.Nil:
default:
{
return("nil");
}
case LuaValueType.Boolean:
{
return("boolean");
}
case LuaValueType.Integer:
case LuaValueType.Number:
{
return("number");
}
case LuaValueType.String:
case LuaValueType.ByteString:
{
return("string");
}
case LuaValueType.Table:
{
return("table");
}
case LuaValueType.Object:
{
return("object");
}
case LuaValueType.Function:
case LuaValueType.CFunction:
{
return("function");
}
case LuaValueType.Coroutine:
{
return("coroutine");
}
case LuaValueType.Userdata:
{
return("userdata");
}
}
}
public LuaValue(LuaCoroutine value)
{
if (value != null)
{
m_type = LuaValueType.Coroutine;
m_value = new ValueUnion(value);
}
else
{
m_type = LuaValueType.Nil;
m_value = new ValueUnion();
}
}
public LuaValue(LuaCFunction value)
{
if (value != null)
{
m_type = LuaValueType.CFunction;
m_value = new ValueUnion(value);
}
else
{
m_type = LuaValueType.Nil;
m_value = new ValueUnion();
}
}
public LuaValue(LuaObject value)
{
if (value != null)
{
m_type = LuaValueType.Object;
m_value = new ValueUnion(value);
}
else
{
m_type = LuaValueType.Nil;
m_value = new ValueUnion();
}
}
public LuaValue(LuaTable value)
{
if (value != null)
{
m_type = LuaValueType.Table;
m_value = new ValueUnion(value);
}
else
{
m_type = LuaValueType.Nil;
m_value = new ValueUnion();
}
}
public LuaValue(byte[] value)
{
if (value != null)
{
m_type = LuaValueType.ByteString;
m_value = new ValueUnion(value);
}
else
{
m_type = LuaValueType.Nil;
m_value = new ValueUnion();
}
}
/// <summary>
/// Runs a test that tests invalid arguments passed to a method. It will run the test
/// with all types except the given one.
/// </summary>
/// <param name="validType">The valid argument type.</param>
/// <param name="format">A format string for the code to test.</param>
/// <param name="allowNil">True to allow nil to be passed.</param>
protected void RunInvalidTypeTests(LuaValueType validType, string format, bool allowNil = false)
{
foreach (var type in Enum.GetValues(typeof(LuaValueType)).Cast<LuaValueType>())
{
if (type == validType || (type == LuaValueType.Nil && allowNil))
continue;
try
{
Lua.DoText(string.Format(format, GetValueForType(type)));
Assert.Fail("Expected ArgumentException to be thrown for type " + type);
}
catch (ArgumentException) { /* noop */ }
}
}
/// <summary>
/// Runs a test that tests invalid arguments passed to a method. It will run the test
/// with all types except the given one.
/// </summary>
/// <param name="validType">The valid argument type.</param>
/// <param name="format">A format string for the code to test.</param>
/// <param name="allowNil">True to allow nil to be passed.</param>
protected void _runInvalidTypeTests(LuaValueType validType, string format,
bool allowNil = false)
{
foreach (var type in Enum.GetValues(typeof(LuaValueType)).Cast <LuaValueType>())
{
if (type == validType || (type == LuaValueType.Nil && allowNil))
{
continue;
}
try {
_lua.DoText(string.Format(format, _getValueForType(type)));
Assert.Fail("Expected ArgumentException to be thrown for type " + type);
} catch (ArgumentException) { }
}
}
public LuaValue ReadValue()
{
LuaValueType type = (LuaValueType)ReadInt32();
Int64 value;
if (type == LuaValueType.NUMBER)
{
value = ReadNumberRaw();
}
else
{
value = ReadObjectID();
}
return(new LuaValue(value, type));
}
void doinit(IntPtr L)
{
// LuaTimer.reg(L);
LuaCoroutine.reg(L, lgo);
Helper.reg(L);
LuaValueType.reg(L);
SLuaDebug.reg(L);
LuaUtils.reg(luaState.L);
lgo.state = luaState;
lgo.onUpdate = this.tick;
lgo.init();
LuaState.errorDelegate = delegate(string msg) {
errorDelegate(msg);
};
inited = true;
}
/// <summary>
/// 初始化LuaValue对象
/// </summary>
/// <param name="decoder">对象解码器</param>
public LuaValue(LuaObjectDecoder decoder)
{
_type = (LuaValueType)decoder.readInt16();
_value = null;
switch (_type)
{
case LuaValueType.Integer:
_value = decoder.readInt32();
break;
case LuaValueType.Boolean:
_value = decoder.readByte();
break;
case LuaValueType.Number:
_value = decoder.readDouble();
break;
case LuaValueType.Data:
_value = decoder.readBytes();
break;
case LuaValueType.String:
_value = decoder.readString();
break;
case LuaValueType.Array:
_value = readArrayList(decoder);
break;
case LuaValueType.Map:
_value = readHashtable(decoder);
break;
case LuaValueType.Object:
{
_value = decoder.readObject();
break;
}
}
}
void ProcessMessage_AutocompleteOptions()
{
AutocompleteResult[] options = null;
int seqid = m_readBuffer.ReadInt32();
int count = m_readBuffer.ReadInt32();
if (count >= 0)
{
options = new AutocompleteResult[count];
for (int index = 0; index < count; ++index)
{
LuaValue key = m_readBuffer.ReadValue();
LuaValueType valueType = (LuaValueType)m_readBuffer.ReadInt32();
options[index] = new AutocompleteResult(key, valueType);
}
}
string message = m_readBuffer.ReadString();
OnAutocompleteOptions(seqid, options, message);
}
public static object ToVarTable(IntPtr L, int stackPos)
{
stackPos = LuaDLL.abs_index(L, stackPos);
LuaValueType ret = LuaDLL.tolua_getvaluetype(L, stackPos);
switch (ret)
{
case LuaValueType.Vector3:
return(ToVector3(L, stackPos));
case LuaValueType.Quaternion:
return(ToQuaternion(L, stackPos));
case LuaValueType.Vector4:
return(ToVector4(L, stackPos));
case LuaValueType.Color:
return(ToColor(L, stackPos));
case LuaValueType.Ray:
return(ToRay(L, stackPos));
case LuaValueType.Bounds:
return(ToBounds(L, stackPos));
case LuaValueType.Vector2:
return(ToVector2(L, 2));
case LuaValueType.LayerMask:
return(ToLayerMask(L, stackPos));
default:
LuaDLL.lua_pushvalue(L, stackPos);
int reference = LuaDLL.toluaL_ref(L);
return(LuaStatic.GetTable(L, reference));
}
}
private void _doinit(IntPtr _luaState, LuaSvrFlag _flag)
{
//LuaTimer.reg( _luaState );
#if UNITY_EDITOR
if (UnityEditor.EditorApplication.isPlaying)
#endif
LuaCoroutine.reg(_luaState, this);
SLua.Helper.reg(_luaState);
if (SLuaSetting.Instance.useLuaValueType)
{
LuaValueType.reg(_luaState);
}
if ((_flag & LuaSvrFlag.LSF_EXTLIB) != 0)
{
LuaDLL.luaS_openextlibs(_luaState);
}
if ((_flag & LuaSvrFlag.LSF_3RDDLL) != 0)
{
Lua3rdDLL.open(_luaState);
}
Inited = true;
}
/// <summary>
/// Gets a Lua expression that is of the given type.
/// </summary>
/// <param name="type">The type of expression.</param>
/// <returns>A valid Lua expression of the given type.</returns>
static string GetValueForType(LuaValueType type)
{
switch (type)
{
case LuaValueType.Nil:
return "nil";
case LuaValueType.String:
return "'foobar'";
case LuaValueType.Bool:
return "true";
case LuaValueType.Table:
return "{}";
case LuaValueType.Function:
return "function() end";
case LuaValueType.Number:
return "123";
case LuaValueType.Thread:
return "coroutine.create(function() end)";
case LuaValueType.UserData:
return "UserData()";
default:
throw new NotImplementedException();
}
}
/// <summary>
/// 初始化一个布尔值
/// </summary>
/// <param name="value">布尔值</param>
public LuaValue(bool value)
{
_value = value;
_type = LuaValueType.Boolean;
}
/// <summary>
/// 初始化一个双精度浮点数
/// </summary>
/// <param name="value">浮点数</param>
public LuaValue(double value)
{
_value = value;
_type = LuaValueType.Number;
}
/// <summary>
/// 初始化一个整型值
/// </summary>
/// <param name="value">整型值</param>
public LuaValue(int value)
{
_value = value;
_type = LuaValueType.Integer;
}
/// <summary>
/// 初始化一个字典值
/// </summary>
/// <param name="value">字典.</param>
public LuaValue(Dictionary <string, LuaValue> value)
{
_value = value;
_type = LuaValueType.Map;
}
/// <summary>
/// 初始化一个Nil值
/// </summary>
public LuaValue()
{
_value = null;
_type = LuaValueType.Nil;
}
/// <summary>
/// 初始化一个对象值
/// </summary>
/// <param name="value">对象</param>
public LuaValue(object value)
{
if (value != null)
{
if (value is int ||
value is uint ||
value is Int16 ||
value is UInt16 ||
value is Int64 ||
value is UInt64)
{
_value = value;
_type = LuaValueType.Integer;
}
else if (value is double ||
value is float)
{
_value = value;
_type = LuaValueType.Number;
}
else if (value is bool)
{
_value = value;
_type = LuaValueType.Boolean;
}
else if (value is byte[])
{
_value = value;
_type = LuaValueType.Data;
}
else if (value is string)
{
_value = value;
_type = LuaValueType.String;
}
else if (value is Array)
{
List <LuaValue> arr = new List <LuaValue> ();
_value = arr;
_type = LuaValueType.Array;
//转换数据
foreach (object item in (value as Array))
{
LuaValue itemValue = new LuaValue(item);
arr.Add(itemValue);
}
}
else if (value is IDictionary)
{
Dictionary <string, LuaValue> dict = new Dictionary <string, LuaValue> ();
_value = dict;
_type = LuaValueType.Map;
foreach (DictionaryEntry de in (value as IDictionary))
{
LuaValue itemValue = new LuaValue(de.Value);
dict.Add(Convert.ToString(de.Key), itemValue);
}
}
else if (value is LuaFunction)
{
_value = value;
_type = LuaValueType.Function;
}
else if (value is LuaPointer)
{
_value = value;
_type = LuaValueType.Ptr;
}
else if (value is LuaTuple)
{
_value = value;
_type = LuaValueType.Tuple;
}
else
{
if (value is LuaObjectDescriptor)
{
_value = value;
}
else if (value is ILuaObject)
{
_value = (value as ILuaObject).getDescriptor();
}
else
{
_value = new LuaObjectDescriptor(value);
}
_type = LuaValueType.Object;
}
}
else
{
_value = null;
_type = LuaValueType.Nil;
}
}
public virtual LuaExpression CastTo(LuaValueType newType)
{
switch (newType)
{
case LuaValueType.Boolean:
switch (GetType())
{
case LuaValueType.Number:
return new LuaExpression.BinOp(
LuaBinaryOperatorType.IsNotEqualTo,
this,
new LuaExpression.NumberLiteral(0));
default: return this;
}
case LuaValueType.Number:
switch (GetType())
{
case LuaValueType.Boolean:
return new LuaExpression.BinOp(
LuaBinaryOperatorType.LogicalOr,
new LuaExpression.BinOp(
LuaBinaryOperatorType.LogicalAnd,
this,
new LuaExpression.NumberLiteral(1)),
new LuaExpression.NumberLiteral(0));
default: return this;
}
default: return this;
}
}
/// <summary>
/// 初始化一个字符串值
/// </summary>
/// <param name="value">字符串.</param>
public LuaValue(string value)
{
_value = value;
_type = LuaValueType.String;
}
/// <summary>
/// Creates a string when enumerating on an invalid value.
/// </summary>
/// <param name="type">The type of the value.</param>
/// <returns>An error string.</returns>
public static string CannotEnumerate(LuaValueType type)
{
return string.Format(Resources.CannotEnumerate, type.ToString().ToLower());
}
/// <summary>
/// Creates a string when performing arithmetic on an invalid value.
/// </summary>
/// <param name="type">The type of the value.</param>
/// <returns>An error string.</returns>
public static string CannotArithmetic(LuaValueType type)
{
return string.Format(Resources.CannotArithmetic, type.ToString().ToLower());
}
/// <summary>
/// Creates a string when indexing on an invalid value.
/// </summary>
/// <param name="type">The type of the value.</param>
/// <returns>An error string.</returns>
public static string CannotIndex(LuaValueType type)
{
return string.Format(Resources.CannotIndex, type.ToString().ToLower());
}
/// <summary>
/// 初始化一个数组值
/// </summary>
/// <param name="value">数组</param>
public LuaValue(List <LuaValue> value)
{
_value = value;
_type = LuaValueType.Array;
}
public object ToObject(int index)
{
LuaTypes luaType = LuaLib.lua_type(L, index);
switch (luaType)
{
case LuaTypes.LUA_TNONE:
case LuaTypes.LUA_TNIL:
{
return(null);
}
case LuaTypes.LUA_TBOOLEAN:
{
return(LuaLib.lua_toboolean(L, index));
}
case LuaTypes.LUA_TNUMBER:
{
return(LuaLib.lua_tonumber(L, index));
}
case LuaTypes.LUA_TSTRING:
{
return(LuaLib.lua_tostring(L, index));
}
case LuaTypes.LUA_TTABLE:
{
LuaValueType valueType = LuaValueType.None;
LuaLib.lua_pushvalue(L, index); // |t
LuaLib.lua_pushstring(L, "__valueType"); // |t|k
LuaLib.lua_rawget(L, -2); // |t|vt
if (!LuaLib.lua_isnil(L, -1))
{
valueType = (LuaValueType)LuaLib.lua_tonumber(L, -1); // |t|vt
}
LuaLib.lua_pop(L, 2); // |
switch (valueType)
{
case LuaValueType.None:
{
return(ToTable(index));
}
case LuaValueType.Color:
{
return(ToColor(index));
}
case LuaValueType.Quaternion:
{
return(ToQuaternion(index));
}
case LuaValueType.Vector2:
{
return(ToVector2(index));
}
case LuaValueType.Vector3:
{
return(ToVector3(index));
}
case LuaValueType.Vector4:
{
return(ToVector4(index));
}
default:
{
return(null);
}
}
}
case LuaTypes.LUA_TFUNCTION:
{
return(ToFunction(index));
}
case LuaTypes.LUA_TUSERDATA:
{
return(ToCSObject(index));
}
default:
{
return(null);
}
}
}
private LuaExpression(LuaValueType vtype)
{
_type = vtype;
}
private LuaExpression()
{
_type = LuaValueType.Any;
}
public AutocompleteResult(LuaValue key, LuaValueType valueType)
{
m_key = key;
m_valueType = valueType;
}
private LuaExpression(string keyword, LuaValueType vtype)
{
_keyword = keyword;
_type = vtype;
}
