/// <summary>
/// Initializes a new instance of the <see cref="Script"/> class.
/// </summary>
/// <param name="coreModules">The core modules to be pre-registered in the default global table.</param>
public Script(CoreModules coreModules)
{
Options = new ScriptOptions(DefaultOptions);
PerformanceStats = new PerformanceStatistics();
Registry = new Table(this);
m_ByteCode = new ByteCode(this);
m_MainProcessor = new Processor(this, m_GlobalTable, m_ByteCode);
m_GlobalTable = new Table(this).RegisterCoreModules(coreModules);
foreach (var t in TypeDescriptorRegistry.RegisteredTypes)
{
Type valType = t.Value.Type;
if (valType.GetTypeInfo().Assembly.FullName != typeof(Script).GetTypeInfo().Assembly.FullName)
{
// m_GlobalTable.RegisterModuleType(t.Value.Type);
if (t.Value is StandardUserDataDescriptor)
{
StandardUserDataDescriptor desc = (StandardUserDataDescriptor)t.Value;
foreach (var member in desc.Members)
{
if (member.Value is MethodMemberDescriptor)
{
MethodMemberDescriptor methDesc = (MethodMemberDescriptor)member.Value;
if (methDesc.IsConstructor)
{
m_GlobalTable.Set(methDesc.Name, methDesc.GetCallbackAsDynValue(this));
}
}
else if (member.Value is OverloadedMethodMemberDescriptor)
{
OverloadedMethodMemberDescriptor methDesc = (OverloadedMethodMemberDescriptor)member.Value;
foreach (var overloadDesc in methDesc.m_Overloads)
{
if (overloadDesc is MethodMemberDescriptor)
{
MethodMemberDescriptor actualDesc = (MethodMemberDescriptor)overloadDesc;
if (actualDesc.IsConstructor)
{
//m_GlobalTable.Set(desc.FriendlyName, actualDesc.GetCallbackAsDynValue(this));
m_GlobalTable.Set(desc.FriendlyName, DynValue.NewCallback(methDesc.GetCallbackFunction(this)));
break;
}
}
}
}
}
}
}
}
}
public static Table RegisterConstants(this Table table)
{
DynValue moonsharp_table = DynValue.NewTable(table.OwnerScript);
Table m = moonsharp_table.Table;
table.Set("_G", DynValue.NewTable(table));
table.Set("_VERSION", DynValue.NewString(string.Format("MoonSharp {0}", Script.VERSION)));
table.Set("_MOONSHARP", moonsharp_table);
m.Set("version", DynValue.NewString(Script.VERSION));
m.Set("luacompat", DynValue.NewString(Script.LUA_VERSION));
m.Set("platform", DynValue.NewString(Platform.Current.Name));
return(table);
}
/// <summary>
/// Registers the standard constants (_G, _VERSION, _MOONSHARP) to a table
/// </summary>
/// <param name="table">The table.</param>
public static Table RegisterConstants(this Table table)
{
var moonsharpTable = DynValue.NewTable(table.OwnerScript);
var m = moonsharpTable.Table;
table.Set("_G", DynValue.NewTable(table));
table.Set("_VERSION", DynValue.NewString($"MoonSharp {Script.VERSION}"));
table.Set("_MOONSHARP", moonsharpTable);
m.Set("version", DynValue.NewString(Script.VERSION));
m.Set("luacompat", DynValue.NewString(Script.LUA_VERSION));
m.Set("is_aot", DynValue.NewBoolean(Script.GlobalOptions.Platform.IsRunningOnAOT()));
m.Set("is_mono", DynValue.NewBoolean(PlatformAutoDetector.IsRunningOnMono));
return(table);
}
private static void RegisterScriptFieldAsConst(FieldInfo fi, object o, Table table, Type t, string name)
{
if (fi.FieldType == typeof(string))
{
string val = fi.GetValue(o) as string;
table.Set(name, DynValue.NewString(val));
}
else if (fi.FieldType == typeof(double))
{
double val = (double)fi.GetValue(o);
table.Set(name, DynValue.NewNumber(val));
}
else
{
throw new ArgumentException(string.Format("Field {0} does not have the right type - it must be string or double.", name));
}
}
private static Table CreateModuleNamespace(Table gtable, Type t)
{
MoonSharpModuleAttribute attr = (MoonSharpModuleAttribute)t.GetCustomAttributes(typeof(MoonSharpModuleAttribute), false).First();
if (string.IsNullOrEmpty(attr.Namespace))
{
return(gtable);
}
else
{
Table table = null;
DynValue found = gtable.Get(attr.Namespace);
if (found.Type == DataType.Table)
{
table = found.Table;
}
else
{
table = new Table(gtable.OwnerScript);
gtable.Set(attr.Namespace, DynValue.NewTable(table));
}
DynValue package = gtable.RawGet("package");
if (package == null || package.Type != DataType.Table)
{
gtable.Set("package", package = DynValue.NewTable(gtable.OwnerScript));
}
DynValue loaded = package.Table.RawGet("loaded");
if (loaded == null || loaded.Type != DataType.Table)
{
package.Table.Set("loaded", loaded = DynValue.NewTable(gtable.OwnerScript));
}
loaded.Table.Set(attr.Namespace, DynValue.NewTable(table));
return(table);
}
}
/// <summary>
/// Registers a module type to the specified table
/// </summary>
/// <param name="gtable">The table.</param>
/// <param name="t">The type</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">If the module contains some incompatibility</exception>
public static Table RegisterModuleType(this Table gtable, Type t)
{
Table table = CreateModuleNamespace(gtable, t);
foreach (MethodInfo mi in Framework.Do.GetMethods(t).Where(__mi => __mi.IsStatic))
{
if (mi.GetCustomAttributes(typeof(MoonSharpModuleMethodAttribute), false).ToArray().Length > 0)
{
MoonSharpModuleMethodAttribute attr = (MoonSharpModuleMethodAttribute)mi.GetCustomAttributes(typeof(MoonSharpModuleMethodAttribute), false).First();
if (!CallbackFunction.CheckCallbackSignature(mi, true))
{
throw new ArgumentException(string.Format("Method {0} does not have the right signature.", mi.Name));
}
#if NETFX_CORE
Delegate deleg = mi.CreateDelegate(typeof(Func <ScriptExecutionContext, CallbackArguments, DynValue>));
#else
Delegate deleg = Delegate.CreateDelegate(typeof(Func <ScriptExecutionContext, CallbackArguments, DynValue>), mi);
#endif
Func <ScriptExecutionContext, CallbackArguments, DynValue> func =
(Func <ScriptExecutionContext, CallbackArguments, DynValue>)deleg;
string name = (!string.IsNullOrEmpty(attr.Name)) ? attr.Name : mi.Name;
table.Set(name, DynValue.NewCallback(func, name));
}
else if (mi.Name == "MoonSharpInit")
{
object[] args = new object[2] {
gtable, table
};
mi.Invoke(null, args);
}
}
foreach (FieldInfo fi in Framework.Do.GetFields(t).Where(_mi => _mi.IsStatic && _mi.GetCustomAttributes(typeof(MoonSharpModuleMethodAttribute), false).ToArray().Length > 0))
{
MoonSharpModuleMethodAttribute attr = (MoonSharpModuleMethodAttribute)fi.GetCustomAttributes(typeof(MoonSharpModuleMethodAttribute), false).First();
string name = (!string.IsNullOrEmpty(attr.Name)) ? attr.Name : fi.Name;
RegisterScriptField(fi, null, table, t, name);
}
foreach (FieldInfo fi in Framework.Do.GetFields(t).Where(_mi => _mi.IsStatic && _mi.GetCustomAttributes(typeof(MoonSharpModuleConstantAttribute), false).ToArray().Length > 0))
{
MoonSharpModuleConstantAttribute attr = (MoonSharpModuleConstantAttribute)fi.GetCustomAttributes(typeof(MoonSharpModuleConstantAttribute), false).First();
string name = (!string.IsNullOrEmpty(attr.Name)) ? attr.Name : fi.Name;
RegisterScriptFieldAsConst(fi, null, table, t, name);
}
return(gtable);
}
/// <summary>
/// Registers the standard constants (_G, _VERSION, _MOONSHARP) to a table
/// </summary>
/// <param name="table">The table.</param>
/// <returns></returns>
public static Table RegisterConstants(this Table table)
{
DynValue moonsharp_table = DynValue.NewTable(table.OwnerScript);
Table m = moonsharp_table.Table;
table.Set("_G", DynValue.NewTable(table));
table.Set("_VERSION", DynValue.NewString(string.Format("MoonSharp {0}", Script.VERSION)));
table.Set("_MOONSHARP", moonsharp_table);
m.Set("version", DynValue.NewString(Script.VERSION));
m.Set("luacompat", DynValue.NewString(Script.LUA_VERSION));
m.Set("platform", DynValue.NewString(Script.GlobalOptions.Platform.GetPlatformName()));
m.Set("is_aot", DynValue.NewBoolean(Script.GlobalOptions.Platform.IsRunningOnAOT()));
m.Set("is_unity", DynValue.NewBoolean(PlatformAutoDetector.IsRunningOnUnity));
m.Set("is_mono", DynValue.NewBoolean(PlatformAutoDetector.IsRunningOnMono));
m.Set("is_clr4", DynValue.NewBoolean(PlatformAutoDetector.IsRunningOnClr4));
m.Set("is_pcl", DynValue.NewBoolean(PlatformAutoDetector.IsPortableFramework));
return(table);
}
private static void RegisterScriptField(FieldInfo fi, object o, Table table, Type t, string name)
{
if (fi.FieldType != typeof(string))
{
throw new ArgumentException(string.Format("Field {0} does not have the right type - it must be string.", name));
}
string val = fi.GetValue(o) as string;
DynValue fn = table.OwnerScript.LoadFunction(val, table, name);
table.Set(name, fn);
}
public static Table RegisterModuleType(this Table gtable, Type t)
{
Table table = CreateModuleNamespace(gtable, t);
foreach (MethodInfo mi in t.GetMethods(BindingFlags.Static | BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.NonPublic))
{
if (mi.GetCustomAttributes(typeof(MoonSharpMethodAttribute), false).Length > 0)
{
MoonSharpMethodAttribute attr = (MoonSharpMethodAttribute)mi.GetCustomAttributes(typeof(MoonSharpMethodAttribute), false).First();
if (!ConversionHelper.CheckCallbackSignature(mi))
{
throw new ArgumentException(string.Format("Method {0} does not have the right signature.", mi.Name));
}
Func <ScriptExecutionContext, CallbackArguments, DynValue> func = (Func <ScriptExecutionContext, CallbackArguments, DynValue>)Delegate.CreateDelegate(typeof(Func <ScriptExecutionContext, CallbackArguments, DynValue>), mi);
string name = (!string.IsNullOrEmpty(attr.Name)) ? attr.Name : mi.Name;
table.Set(name, DynValue.NewCallback(func, name));
}
else if (mi.Name == "MoonSharpInit")
{
object[] args = new object[2] {
gtable, table
};
mi.Invoke(null, args);
}
}
foreach (FieldInfo fi in t.GetFields(BindingFlags.Static | BindingFlags.GetField | BindingFlags.Public | BindingFlags.NonPublic).Where(_mi => _mi.GetCustomAttributes(typeof(MoonSharpMethodAttribute), false).Length > 0))
{
MoonSharpMethodAttribute attr = (MoonSharpMethodAttribute)fi.GetCustomAttributes(typeof(MoonSharpMethodAttribute), false).First();
string name = (!string.IsNullOrEmpty(attr.Name)) ? attr.Name : fi.Name;
RegisterScriptField(fi, null, table, t, name);
}
foreach (FieldInfo fi in t.GetFields(BindingFlags.Static | BindingFlags.GetField | BindingFlags.Public | BindingFlags.NonPublic).Where(_mi => _mi.GetCustomAttributes(typeof(MoonSharpConstantAttribute), false).Length > 0))
{
MoonSharpConstantAttribute attr = (MoonSharpConstantAttribute)fi.GetCustomAttributes(typeof(MoonSharpConstantAttribute), false).First();
string name = (!string.IsNullOrEmpty(attr.Name)) ? attr.Name : fi.Name;
RegisterScriptFieldAsConst(fi, null, table, t, name);
}
return(gtable);
}
public static DynValue ClassToLuaTable(Script script, object obj)
{
MoonSharp.Interpreter.Table table = new MoonSharp.Interpreter.Table(script);
var properties = obj.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
for (int i = 0; i < properties.Length; i++)
{
var property = properties[i];
var value = property.GetValue(obj, null);
if (value == null)
{
continue;
}
if (value.GetType() == typeof(string))
{
table.Set(property.Name, DynValue.NewString((string)value));
}
else if (value.GetType() == typeof(int))
{
table.Set(property.Name, DynValue.NewNumber((int)value));
}
else if (value.GetType() == typeof(float))
{
table.Set(property.Name, DynValue.NewNumber((float)value));
}
else if (value.GetType() == typeof(bool))
{
table.Set(property.Name, DynValue.NewBoolean((bool)value));
}
else if (value is ProtoBuf.IExtensible)
{
table.Set(property.Name, ClassToLuaTable(script, value));
}
else if (value is IList)
{
IList list = value as IList;
MoonSharp.Interpreter.Table value_table = new MoonSharp.Interpreter.Table(script);
for (int j = 0; j < list.Count; ++j)
{
DynValue item = null;
if (list[j] is ProtoBuf.IExtensible)
{
item = ClassToLuaTable(script, list[j]);
}
else if (list[j] is int)
{
item = DynValue.NewNumber((int)list[j]);
}
else if (list[j] is float)
{
item = DynValue.NewNumber((float)list[j]);
}
else if (list[j] is string)
{
item = DynValue.NewString((string)list[j]);
}
else if (list[j] is bool)
{
item = DynValue.NewBoolean((bool)list[j]);
}
else
{
Debug.LogError("Convert List to lua table error: unsupported types " + list[j].GetType());
}
value_table.Append(item);
}
table.Set(property.Name, DynValue.NewTable(value_table));
}
else
{
Debug.LogError("Convert class to lua table error: unsupported types " + value);
}
}
return(DynValue.NewTable(table));
}
public MoonSharp.Interpreter.Table GetCLRObjectTable(object obj, int level = 1, bool err = false)
{
level--;
MoonSharp.Interpreter.Table ret = new MoonSharp.Interpreter.Table(MoonScript);
foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(obj))
{
string name = descriptor.Name;
if (TypeForm.OmittedProperties.Contains(name))
{
continue;
}
object _value = null;
try {
_value = descriptor.GetValue(obj);
} catch (Exception e) {
ret.Set(name, MoonSharp.Interpreter.DynValue.NewString("[Error]"));
continue;
}
if (_value is int)
{
ret.Set(name, MoonSharp.Interpreter.DynValue.NewNumber((int)_value));
}
else if (_value is double)
{
ret.Set(name, MoonSharp.Interpreter.DynValue.NewNumber((double)_value));
}
else if (_value is byte)
{
ret.Set(name, MoonSharp.Interpreter.DynValue.NewNumber((byte)_value));
}
else if (_value is string)
{
ret.Set(name, MoonSharp.Interpreter.DynValue.NewString((string)_value));
}
else if (_value is bool)
{
ret.Set(name, MoonSharp.Interpreter.DynValue.NewBoolean((bool)_value));
}
else if (_value != null && _value.GetType().IsEnum)
{
ret.Set(name, MoonSharp.Interpreter.DynValue.NewNumber(Convert.ToInt32(_value)));
}
else if (level > 0)
{
try {
ret.Set(name, MoonSharp.Interpreter.DynValue.NewTable(GetCLRObjectTable(_value, level, err)));
} catch (Exception e)
{
if (err)
{
ret.Set(name, MoonSharp.Interpreter.DynValue.NewString("[Cannot get inside]"));
}
}
}
else
{
ret.Set(name, MoonSharp.Interpreter.DynValue.NewString(_value?.ToString()));
}
}
return(ret);
}