//============================================================
// 変換処理
//============================================================
public ScriptObject ToScriptObject(object value)
{
if (value == null)
{
return(new ScriptObject(this, null));
}
IWrapper wrapper = value as IWrapper;
if (wrapper != null)
{
value = wrapper.Value;
}
System.Type t = value.GetType();
if (t.IsArray && t.GetArrayRank() == 1)
{
value = ArrayFromClr((object[])value);
}
else if (value is System.Delegate)
{
System.Delegate dlg = (System.Delegate)value;
ScriptObject ret;
if (!funcs.TryGetValue(dlg, out ret))
{
ret = new ScriptObject(this, this.exec(@"var ret=function(){return " + ROOT + @".InvokeD(args[0],arguments);};
ret.toString=function(){return 'function " + dlg.Method.Name + @"(){\r\n\t[native code]\r\n}';};
return ret;", dlg));
funcs.Add(dlg, ret);
}
return(ret);
}
return(new ScriptObject(this, value));
}
public static TypeSyntax Create(System.Type type)
{
if (type is null)
{
return(null);
}
TypeSyntax value;
if (type.IsArray)
{
value = new ArrayTypeSyntax(Create(type.GetElementType()), type.GetArrayRank());
}
else if (type.IsGenericType)
{
var types = type.GetGenericArguments();
NodeList <TypeSyntax> typeNodes = new NodeList <TypeSyntax>(types.Length);
foreach (var arg in types)
{
typeNodes.Add(Create(arg));
}
value = new RefTypeSyntax(type.FullName, typeNodes);
}
else
{
value = new RefTypeSyntax(type.FullName);
}
value.Type = type;
return(value);
}
private void InternalAppend(System.Type itemType, System.Object item)
{
if (itemType.IsPrimitive ||
itemType.IsEnum ||
itemType == typeof(string))
{
Append(item.ToString());
return;
}
if (itemType.IsSubclassOf(typeof(UnityEngine.Object)))
{
var unityObject = item as UnityEngine.Object;
Append((unityObject != null) ? unityObject.name : "");
return;
}
if (itemType.IsArray)
{
var array = item as System.Array;
if (array == null || itemType.GetArrayRank() > 1)
{
Append("0");
}
else
{
var objectList = new List <System.Object>();
foreach (var subItem in array)
{
if (subItem != null)
{
objectList.Add(subItem);
}
}
Append(objectList.Count.ToString());
foreach (var subItem in objectList)
{
InternalAppend(itemType.GetElementType(), subItem);
}
}
return;
}
var bindingFlags = BindingFlags.Instance | BindingFlags.Public;
var members = itemType.GetFields(bindingFlags);
foreach (var member in members)
{
InternalAppend(member.FieldType, member.GetValue(item));
}
}
private static object CopyArray(List <object> items, System.Type arrayType, ArrayList counts)
{
if (arrayType.IsArray)
{
if (arrayType.GetArrayRank() == 2)
{
int rank0 = int.Parse(counts[0].ToString());
int rank1 = int.Parse(counts[1].ToString());
System.Array list = System.Array.CreateInstance(arrayType.GetElementType(), rank0, rank1);
int size = rank0 * rank1;
if (size != items.Count)
{
EB.Debug.Log("Bad!!! size= " + size + " count=" + items.Count);
}
int x = 0;
int y = 0;
for (int i = 0; i < items.Count; ++i)
{
list.SetValue(items[i], x, y);
++y;
if (y == rank1)
{
y = 0;
++x;
}
}
return(list);
}
else
{
System.Array list = System.Array.CreateInstance(arrayType.GetElementType(), items.Count);
System.Array.Copy(items.ToArray(), list, items.Count);
return(list);
}
}
else
{
IList list = (IList)System.Activator.CreateInstance(arrayType);
foreach (object item in items)
{
list.Add(item);
}
return(list);
}
}
/// <summary>
/// System.Type を表す文字列を C# 形式で取得します。
/// </summary>
/// <param name="t">文字列に直す前の System.Type を指定します。</param>
/// <returns>System.Type を文字列で表した物を取得します。</returns>
public static string CSharpName(System.Type t)
{
if (t.IsArray)
{
return(CSharpName(t.GetElementType()) + "[" + new string(',', t.GetArrayRank() - 1) + "]");
}
if (t.IsPointer)
{
return(CSharpName(t.GetElementType()) + "*");
}
if (t.IsByRef)
{
return(CSharpName(t.GetElementType()) + "&");
}
if (t.IsGenericType)
{
if (t.GetGenericTypeDefinition() == typeof(System.Nullable <>))
{
return(CSharpName(t.GetGenericArguments()[0]) + "?");
}
string temp = CSharpName_gen(t);
System.Type[] args = t.GetGenericArguments();
int i = 0;
return(CSharpName_rxGen.Replace(temp, delegate(Rgx::Match m){
int M = int.Parse(m.Groups[1].Value);
if (M == 0 || i + M > args.Length)
{
return m.Value;
}
string ret = CSharpName(args[i++]);
for (int j = 1; j < M; j++)
{
ret += "," + CSharpName(args[i++]);
}
return "<" + ret + ">";
}));
}
if (t.IsGenericParameter)
{
return(t.Name);
}
switch (GetTypeCode(t))
{
case TypeCodes.Void: return("void");
case TypeCodes.SByte: return("sbyte");
case TypeCodes.Byte: return("byte");
case TypeCodes.Short: return("short");
case TypeCodes.UShort: return("ushort");
case TypeCodes.Int: return("int");
case TypeCodes.UInt: return("uint");
case TypeCodes.Long: return("long");
case TypeCodes.ULong: return("ulong");
case TypeCodes.Float: return("float");
case TypeCodes.Double: return("double");
case TypeCodes.Decimal: return("decimal");
case TypeCodes.Char: return("char");
case TypeCodes.Bool: return("bool");
case TypeCodes.String: return("string");
case TypeCodes.Object: return("object");
default: return(t.FullName);
}
}
static void GetClassName(System.Type type, out string clsName, out string realClsName, out bool isByRef, bool simpleClassName = false)
{
isByRef = type.IsByRef;
if (isByRef)
{
type = type.GetElementType();
}
bool isArray = type.IsArray;
int arrayCount = 1;
if (isArray)
{
arrayCount = type.GetArrayRank();
type = type.GetElementType();
}
string realNamespace = null;
bool isNestedGeneric = false;
if (type.IsNested)
{
string bClsName, bRealClsName;
bool tmp;
var rt = type.ReflectedType;
if (rt.IsGenericType && rt.IsGenericTypeDefinition)
{
if (type.IsGenericType)
{
rt = rt.MakeGenericType(type.GetGenericArguments());
isNestedGeneric = true;
}
}
if (rt == type)
{
wxb.L.LogErrorFormat("type:{0} -> {1}", type.Name, rt.Name);
}
GetClassName(rt, out bClsName, out bRealClsName, out tmp);
clsName = simpleClassName ? "" : bClsName + "_";
realNamespace = bRealClsName + ".";
}
else
{
clsName = simpleClassName ? "" : (!string.IsNullOrEmpty(type.Namespace) ? type.Namespace.Replace(".", "_") + "_" : "");
realNamespace = !string.IsNullOrEmpty(type.Namespace) ? type.Namespace + "." : null;
}
clsName = clsName + type.Name.Replace(".", "_").Replace("`", "_").Replace("<", "_").Replace(">", "_");
bool isGeneric = false;
string ga = null;
if (type.IsGenericType && !isNestedGeneric)
{
isGeneric = true;
clsName += "_";
ga = "<";
var args = type.GetGenericArguments();
bool first = true;
foreach (var j in args)
{
if (first)
{
first = false;
}
else
{
clsName += "_";
ga += ", ";
}
string a, b;
bool tmp;
if (type == j)
{
wxb.L.LogErrorFormat("type:{0} -> {1}", type.Name, j.Name);
}
GetClassName(j, out a, out b, out tmp, true);
clsName += a;
ga += b;
}
ga += ">";
}
if (!simpleClassName)
{
clsName += "_Binding";
}
if (isArray)
{
clsName += "_Array";
}
realClsName = realNamespace;
if (isGeneric)
{
int idx = type.Name.IndexOf("`");
if (idx > 0)
{
realClsName += type.Name.Substring(0, idx);
realClsName += ga;
}
else
{
realClsName += type.Name;
}
}
else
{
realClsName += type.Name;
}
if (isArray)
{
if (arrayCount == 1)
{
realClsName += "[]";
}
else
{
realClsName += "[";
for (int i = 1; i < arrayCount; ++i)
{
realClsName += ",";
}
realClsName += "]";
}
}
}
public int GetArrayRank() => t.GetArrayRank();
public bool IsValid(System.Type type)
{
return(type.IsArray == true && type.GetArrayRank() == 1);
}
