public static string GetDelegateWrapTypeName(TypeReference type, TypeReference delegateTarget)
{
var paramTpes = Utils.GetDelegateParams(type, delegateTarget, out var returnType);
var paramDeclear = "(";
for (int i = 0; i < paramTpes.Count; i++)
{
var p = paramTpes[i];
paramDeclear += $"{TypeResolver.Resolve(p).TypeName()} arg{i} ";
if (i != paramTpes.Count - 1)
{
paramDeclear += ",";
}
}
paramDeclear += ")";
var returnName = returnType == null ? "void" : TypeResolver.Resolve(returnType).TypeName();
var sign = paramDeclear + returnName;
var delegateName = "";
if (!delegateSignDic.TryGetValue(sign, out delegateName))
{
delegateName = "Delegate" + sign.GetHashCode().ToString("x");
delegateSignDic[sign] = delegateName;
}
var define = $"public delegate {returnName} {delegateName} {paramDeclear}";
GenerateBindings.AddDelegateDefine(define);
return(delegateName);
}
public ListResolver(TypeReference type) : base(type)
{
var genericInstace = type as GenericInstanceType;
genericType = genericInstace.GenericArguments.First();
resolver = TypeResolver.Resolve(genericType);
}
void GenProperty()
{
var flag = isStatic ? "static " : "";
if (isAbstract)
{
flag += "abstract ";
}
else if (isOverride)
{
flag += "override ";
}
else if (isVirtual)
{
flag += "virtual ";
}
CS.Writer.Start($"public {flag}{TypeResolver.Resolve(genProperty.PropertyType).RealTypeName()} {genProperty.Name}");
foreach (var m in methods)
{
m.Gen();
}
CS.Writer.End();
}
public static string GetGenericTypeName(TypeReference type, bool boxedType = false)
{
var gType = type as GenericInstanceType;
if (!type.Name.Contains("`") || gType == null)
{
return(type.Name);
}
var typeName = TypeResolver.Resolve(type).RealTypeName();
var baseType = typeName.Substring(0, typeName.IndexOf('`'));
var param = "<";
for (int i = 0; i < gType.GenericArguments.Count; i++)
{
var p = gType.GenericArguments[i];
var pName = boxedType ? TypeResolver.Resolve(p).TypeName() : TypeResolver.Resolve(p).RealTypeName();
if (p.IsGenericInstance)
{
pName = Utils.GetGenericTypeName(p, boxedType);
}
param += pName + (i == gType.GenericArguments.Count - 1 ? "" : ", ");
}
param += ">";
return(baseType + param);
}
/// <summary>
/// var thizObj = (GameObject)ObjectStore.Get(thiz);
/// var value = thizObj.layer;
/// return value;
/// </summary>
/// <returns> value </returns>
public override string Implement(string name)
{
var thizObj = GetThizObj();
var propertyName = method.Name.Substring("get_".Length);
CS.Writer.WriteLine($"var {name} = {thizObj}.{propertyName}");
return(TypeResolver.Resolve(method.ReturnType).Box(name));
}
//declear : (int thiz_h, System.Boolean value)
//or:(this.Handle, value)
public static string BindMethodParamDefine(MethodDefinition method, bool declear = false)
{
var param = "(";
if (!method.IsStatic)
{
if (method.DeclaringType.IsValueType)
{
if (declear)
{
param += TypeResolver.Resolve(method.DeclaringType).Paramer("thiz");
}
else
{
param += "ref this";
}
if (method.HasParameters)
{
param += ", ";
}
}
else if (!method.IsConstructor)
{
if (declear)
{
param += TypeResolver.Resolve(method.DeclaringType).Paramer("thiz");
}
else
{
param += "this.Handle";
}
if (method.HasParameters)
{
param += ", ";
}
}
}
var lastP = method.Parameters.LastOrDefault();
foreach (var p in method.Parameters)
{
if (declear)
{
param += TypeResolver.Resolve(p.ParameterType).Paramer(p.Name) + (p == lastP ? "" : ", ");
}
else
{
param += TypeResolver.Resolve(p.ParameterType).Box(p.Name) + (p == lastP ? "" : ", ");
}
}
param += ")";
return(param);
}
/// <summary>
/// var thizObj = (GameObject)ObjectStore.Get(thiz);
/// thizObj.layer = value;
/// </summary>
/// <returns> valueHandle </returns>
public override string Implement(string name)
{
name = "value";
var thizObj = GetThizObj();
var propertyName = method.Name.Substring("set_".Length);
var valueName = TypeResolver.Resolve(method.Parameters.First().ParameterType).Unbox(name, true);
CS.Writer.WriteLine($"{thizObj}.{propertyName} = {valueName}");
return("");
}
protected string GetThizObj()
{
if (method.IsStatic)
{
return(method.DeclaringType.FullName.Replace("/", "."));
}
else
{
return(TypeResolver.Resolve(method.DeclaringType).Unbox("thiz", true));
}
}
/// <summary>
/// var res = MonoBind.UnityEngine_GameObject_GetComponent_1(this.Handle, type);
/// var resObj = ObjectStore.Get<Component>(res);
/// return resObj;
/// </summary>
/// <returns> resObj </returns>
public virtual string Call(string name)
{
if (method.ReturnType.IsVoid())
{
CS.Writer.WriteLine(Utils.BindMethodName(method));
return("");
}
var reName = TypeResolver.Resolve(method.ReturnType).LocalVariable(name);
CS.Writer.WriteLine($"{reName} = {Utils.BindMethodName(method)}");
return(TypeResolver.Resolve(method.ReturnType).Unbox(name));
}
public override string Unbox(string name, bool previous)
{
using (new LP(CS.Writer.CreateLinePoint("//list unbox", previous)))
{
var relTypeName = $"List<{TypeResolver.Resolve(genericType).RealTypeName()}>";
CS.Writer.WriteLine($"{relTypeName} {name}_r = new {relTypeName}()");
CS.Writer.Start($"foreach (var item in { name})");
var res = resolver.Unbox("item");
CS.Writer.WriteLine($"{name}_r.add({res})");
CS.Writer.End();
}
return($"{name}_r");
}
/*
* static event global::UnityEngine.Application.LogCallback _logMessageReceived;
* static Action<int, int, int> logMessageReceivedAction = OnlogMessageReceived;
* static void OnlogMessageReceived(int arg0,int arg1,int arg2)
* {
* _logMessageReceived(unbox(arg0), unbox(arg1), unbox(arg2));
* }
* public static event global::UnityEngine.Application.LogCallback logMessageReceived
* {
* add
* {
* bool add = _logMessageReceived == null;
* _logMessageReceived += value;
* if(add)
* {
* var value_p = Marshal.GetFunctionPointerForDelegate(logMessageReceivedAction);
* MonoBind.UnityEngine_Application_add_logMessageReceived(value_p);
* }
* }
* remove
* {
* _logMessageReceived -= value;
* if(_logMessageReceived == null)
* {
* var value_p = Marshal.GetFunctionPointerForDelegate(logMessageReceivedAction);
* MonoBind.UnityEngine_Application_remove_logMessageReceived(value_p);
* }
* }
* }
*/
public override void Gen()
{
var name = genName;
var flag = isStatic ? "static" : "";
flag += isEvent ? " event" : "";
var type = genType; // LogCallback(string condition, string stackTrace, LogType type);
var eventTypeName = TypeResolver.Resolve(type).RealTypeName();
if (type.IsGenericInstance)
{
eventTypeName = Utils.GetGenericTypeName(type);
}
var eventDeclear = Utils.GetDelegateWrapTypeName(type, isStatic ? null : declarType); //Action <int,int,int>
var paramTpes = Utils.GetDelegateParams(type, isStatic ? null : declarType, out var returnType); // string , string , LogType ,returnType
var returnTypeName = returnType != null?TypeResolver.Resolve(returnType).RealTypeName() : "void";
//static event global::UnityEngine.Application.LogCallback _logMessageReceived;
CS.Writer.WriteLine($"public {flag} {eventTypeName} _{name}");
//static Action<int, int, int> logMessageReceivedAction = OnlogMessageReceived;
CS.Writer.WriteLine($"static {eventDeclear} {name}Action = On{name}");
//static void OnlogMessageReceived(int arg0,int arg1,int arg2)
var eventFuncDeclear = $"static {returnTypeName} On{name}(";
for (int i = 0; i < paramTpes.Count; i++)
{
var p = paramTpes[i];
eventFuncDeclear += TypeResolver.Resolve(p).LocalVariable($"arg{i}");
if (i != paramTpes.Count - 1)
{
eventFuncDeclear += ",";
}
}
eventFuncDeclear += ")";
CS.Writer.Start(eventFuncDeclear);
CS.Writer.WriteLine("Exception __e = null");
CS.Writer.Start("try");
//_logMessageReceived(unbox(arg0), unbox(arg1), unbox(arg2));
var callCmd = $"_{name}(";
var targetObj = "";
for (int i = 0; i < paramTpes.Count; i++)
{
var p = paramTpes[i];
var param = TypeResolver.Resolve(p).Unbox($"arg{i}");
if (i == 0 && !isStatic)
{
targetObj = param + ".";
continue;
}
callCmd += param;
if (i != paramTpes.Count - 1)
{
callCmd += ",";
}
}
callCmd += ")";
if (!string.IsNullOrEmpty(targetObj))
{
callCmd = targetObj + callCmd;
}
if (returnType != null)
{
callCmd = $"var res = " + callCmd;
}
CS.Writer.WriteLine(callCmd);
if (returnType != null)
{
var res = TypeResolver.Resolve(returnType).Box("res");
CS.Writer.WriteLine($"return {res}");
}
CS.Writer.End();//try
CS.Writer.Start("catch(Exception e)");
CS.Writer.WriteLine("__e = e");
CS.Writer.End();//catch
CS.Writer.WriteLine("if(__e != null)", false);
CS.Writer.WriteLine("ScriptEngine.OnException(__e.ToString())");
if (returnType != null)
{
CS.Writer.WriteLine($"return default({returnTypeName})");
}
CS.Writer.End();//method
//public static event LogCallback logMessageReceived
CS.Writer.Start($"public {flag} {eventTypeName} {name}");
var targetHandle = isStatic ? "" : "this.Handle, ";
if (addMethod != null || setMethod != null)
{
var method = isEvent ? addMethod : setMethod;
var op = isEvent ? "+=" : "=";
CS.Writer.Start(isEvent? "add":"set");
CS.Writer.WriteLine($"bool attach = (_{name} == null)");
CS.Writer.WriteLine($"_{name} {op} value");
CS.Writer.Start("if(attach)");
var res = TypeResolver.Resolve(type).Box($"{name}Action");
CS.Writer.WriteLine(Utils.BindMethodName(method, false, false) + $"({targetHandle}{res})");
//var value_p = Marshal.GetFunctionPointerForDelegate(logMessageReceivedAction);
//MonoBind.UnityEngine_Application_add_logMessageReceived(value_p);
CS.Writer.WriteLine("ScriptEngine.CheckException()");
CS.Writer.End(); //if(attach)
CS.Writer.End(); // add
}
if (removeMethod != null)
{
CS.Writer.Start("remove");
CS.Writer.WriteLine($"_{name} -= value");
CS.Writer.Start($"if(_{name} == null)");
var res = TypeResolver.Resolve(type).Box($"{name}Action");
CS.Writer.WriteLine(Utils.BindMethodName(removeMethod, false, false) + $"({targetHandle}{res})");
CS.Writer.WriteLine("ScriptEngine.CheckException()");
CS.Writer.End(); //if(attach)
CS.Writer.End(); // remove
}
else if (getMethod != null)
{
CS.Writer.Start("get");
CS.Writer.WriteLine($"return _{name}");
CS.Writer.End(); //get
}
CS.Writer.End();
}
/// <summary>
/// var thizObj = (GameObject)ObjectStore.Get(thiz_h);
/// var value = thizObj.GetComponent(type);
/// var value_h = ObjectStore.Store(value);
/// return value_h;
/// </summary>
/// <returns> value_h </returns>
public virtual string Implement(string name)
{
var thizObj = GetThizObj();
if (method.ReturnType.IsVoid())
{
CS.Writer.WriteLine("", false);
}
else
{
CS.Writer.WriteLine($"var {name} = ", false);
}
string paramSeparation = ",";
if (method.Name == "op_Implicit")
{
CS.Writer.Write($"");
}
else if (method.Name == "op_Equality")
{
paramSeparation = "==";
}
else if (method.Name == "op_Inequality")
{
paramSeparation = "!=";
}
else if (method.Name == "op_Addition")
{
paramSeparation = "+";
}
else if (method.Name == "op_Subtraction")
{
paramSeparation = "-";
}
else if (method.Name == "op_Multiply")
{
paramSeparation = "*";
}
else if (method.Name == "op_Division")
{
paramSeparation = "/";
}
else if (method.Name == "op_LessThan")
{
paramSeparation = "<";
}
else if (method.Name == "op_GreaterThan")
{
paramSeparation = ">";
}
else if (method.Name == "op_Explicit")
{
CS.Writer.Write($"({TypeResolver.Resolve(method.ReturnType).RealTypeName()})");
}
else if (method.Name == "op_UnaryNegation")
{
CS.Writer.Write($"-");
}
else
{
CS.Writer.Write($"{thizObj}.{method.Name}");
}
CS.Writer.Write($"(");
var lastP = method.Parameters.LastOrDefault();
foreach (var p in method.Parameters)
{
var value = TypeResolver.Resolve(p.ParameterType).Unbox(p.Name, true);
//if (p.ParameterType.IsByReference)
// value = "ref " + value;
CS.Writer.Write(value);
if (lastP != p)
{
CS.Writer.Write(paramSeparation);
}
}
CS.Writer.Write(");");
return(TypeResolver.Resolve(method.ReturnType).Box(name));
}
public virtual string ReturnType()
{
return(TypeResolver.Resolve(method.ReturnType).TypeName());
}
/*
* static Action <int,int,int> logMessageReceived;
* static void OnlogMessageReceived(string arg0, string arg1, LogType arg2)
* {
* logMessageReceived(box(arg0), box(arg1), box(arg2));
* }
* [MonoPInvokeCallback(typeof(UnityEngine_Application_logMessageReceived_Type))]
* static void UnityEngine_Application_logMessageReceived (IntPtr value_p)
* {
* logMessageReceived = Marshal.GetDelegateForFunctionPointer<Action<int, int, int>>(value_p);
* UnityEngine.Application.logMessageReceived += OnlogMessageReceived;
* }
*/
public override string Implement(string name)
{
var isStatic = method.IsStatic;
var type = method.Parameters.FirstOrDefault().ParameterType; // LogCallback(string condition, string stackTrace, LogType type);
var paramTpes = Utils.GetDelegateParams(type, isStatic? null: method.DeclaringType, out var returnType); // string , string , LogType ,returnType
var eventDeclear = Utils.GetDelegateWrapTypeName(type, isStatic ? null : method.DeclaringType); //Action <int,int,int>
var returnTypeName = returnType != null?TypeResolver.Resolve(returnType).RealTypeName() : "void";
//static void OnlogMessageReceived(string arg0, string arg1, LogType arg2)
var eventFuncDeclear = $"static {returnTypeName} On{uniqueName}(";
for (int i = 0; i < paramTpes.Count; i++)
{
var p = paramTpes[i];
if (!isStatic && i == 0)
{
eventFuncDeclear += "this ";
}
eventFuncDeclear += $"{TypeResolver.Resolve(p).RealTypeName()} arg{i}";
if (i != paramTpes.Count - 1)
{
eventFuncDeclear += ",";
}
}
eventFuncDeclear += ")";
using (new LP(CS.Writer.GetLinePoint("//Method")))
{
CS.Writer.WriteLine($"static {eventDeclear} {uniqueName}");
CS.Writer.Start(eventFuncDeclear);
var callCmd = $"{uniqueName}(";
if (returnType != null)
{
callCmd = "var res = " + callCmd;
}
for (int i = 0; i < paramTpes.Count; i++)
{
var p = paramTpes[i];
callCmd += TypeResolver.Resolve(p).Box($"arg{i}");
if (i != paramTpes.Count - 1)
{
callCmd += ",";
}
}
callCmd += ")";
CS.Writer.WriteLine(callCmd);
CS.Writer.WriteLine("ScriptEngine.CheckException()");
if (returnType != null)
{
var res = TypeResolver.Resolve(returnType).Box("res");
CS.Writer.WriteLine($"return {res}");
}
CS.Writer.End();
}
name = "value";
var thizObj = GetThizObj();
CS.Writer.WriteLine($"{uniqueName} = Marshal.GetDelegateForFunctionPointer<{eventDeclear}>({name}_p)");
var actionTarget = isStatic ? $"On{uniqueName}" : $"{thizObj}.On{uniqueName}";
var op = isEvent ? "+=" : "=";
CS.Writer.WriteLine($"{thizObj}.{propertyName} {op} {actionTarget}");
return("");
}
/// <summary>
/// var value = new GameObject(name);
/// var valueHandle = ObjectStore.Store(value);
/// return valueHandle;
/// </summary>
/// <returns> valueHandle </returns>
public override string Implement(string name)
{
if (!IsValueTypeConstructor)
{
CS.Writer.WriteLine($"var {name} = new {TypeResolver.Resolve(method.DeclaringType).RealTypeName()}(", false);
var lastP = method.Parameters.LastOrDefault();
foreach (var p in method.Parameters)
{
CS.Writer.Write(TypeResolver.Resolve(p.ParameterType).Unbox(p.Name, true));
if (lastP != p)
{
CS.Writer.Write(",");
}
}
CS.Writer.Write(");");
CS.Writer.WriteLine($"var {name}Handle = ObjectStore.Store({name})");
return($"{name}Handle");
}
else
{
//if (UnityEngine_Vector3__ctor_94_info == null)
// UnityEngine_Vector3__ctor_94_info = typeof(UnityEngine.Vector3).GetConstructor(new Type[] { typeof(System.Single), typeof(System.Single), typeof(System.Single) });
//UnityEngine_Vector3__ctor_94_info.Invoke(thiz, System.Reflection.BindingFlags.Default, Type.DefaultBinder, new object[] { x, y, z }, null);
/*var infoName = Utils.BindMethodName(method, true, false) + "_info";
* CS.Writer.WriteLine($"if({infoName} == null)", false);
* CS.Writer.Write($"{infoName} = typeof({TypeResolver.Resolve(method.DeclaringType).RealTypeName()}).GetConstructor(new Type[] {{ ");
* var lastP = method.Parameters.LastOrDefault();
* foreach (var p in method.Parameters)
* {
* CS.Writer.Write($"typeof({TypeResolver.Resolve(p.ParameterType).RealTypeName()})");
* if (lastP != p)
* CS.Writer.Write(",");
* }
* CS.Writer.Write(" });");
*
* CS.Writer.WriteLine($"{infoName}.Invoke(thiz, System.Reflection.BindingFlags.Default, Type.DefaultBinder, new object[] {{", false);
* lastP = method.Parameters.LastOrDefault();
* foreach (var p in method.Parameters)
* {
* CS.Writer.Write(TypeResolver.Resolve(p.ParameterType).Unbox(p.Name, true));
* if (lastP != p)
* CS.Writer.Write(",");
* }
* CS.Writer.Write("}, null);");*/
CS.Writer.WriteLine($"var n = new {TypeResolver.Resolve(method.DeclaringType).RealTypeName()}(", false);
var lastP = method.Parameters.LastOrDefault();
foreach (var p in method.Parameters)
{
CS.Writer.Write(TypeResolver.Resolve(p.ParameterType).Unbox(p.Name, true));
if (lastP != p)
{
CS.Writer.Write(",");
}
}
CS.Writer.Write(");");
CS.Writer.WriteLine("thiz = n");
return("");
}
}
string GetMethodDelcear()
{
string declear = "public ";
if (genMethod.IsStatic)
{
declear += "static ";
}
if (Utils.IsUnsafeMethod(genMethod))
{
declear += "unsafe ";
}
if (genMethod.IsAbstract)
{
declear += "abstract ";
}
else if (genMethod.IsOverride())
{
declear += "override ";
}
else if (genMethod.IsVirtual && !genMethod.IsFinal)
{
declear += "virtual ";
}
var methodName = genMethod.Name;
switch (methodName)
{
case "op_Addition":
methodName = "operator+";
break;
case "op_Subtraction":
methodName = "operator-";
break;
case "op_UnaryNegation":
methodName = "operator-";
break;
case "op_Multiply":
methodName = "operator*";
break;
case "op_Division":
methodName = "operator/";
break;
case "op_Equality":
methodName = "operator==";
break;
case "op_Inequality":
methodName = "operator!=";
break;
case "op_Implicit":
methodName = "implicit operator " + genMethod.ReturnType.Name;
break;
case "op_Explicit":
methodName = "explicit operator " + genMethod.ReturnType.Name;
break;
}
if (!genMethod.IsConstructor)
{
if (!methodName.StartsWith("implicit") && !methodName.StartsWith("explicit"))
{
declear += TypeResolver.Resolve(genMethod.ReturnType).RealTypeName() + " ";
}
declear += methodName;
}
else
{
declear += genMethod.DeclaringType.Name;
}
var param = "(";
var lastP = genMethod.Parameters.LastOrDefault();
foreach (var p in genMethod.Parameters)
{
var type = p.ParameterType;
var typeName = TypeResolver.Resolve(type).RealTypeName();
if (type.IsGenericInstance)
{
typeName = Utils.GetGenericTypeName(type);
}
param += $"{typeName} {p.Name}" + (p == lastP ? "" : ", ");
}
param += ")";
declear += param;
if (genMethod.IsConstructor && genMethod.DeclaringType.IsValueType)
{
declear += ":this()";
}
return(declear);
}
