public static StringBuilder BuildConstructors(Type type, ConstructorInfo[] constructors, int slot, int howmanyConstructors)
{
string fmt = @"
_jstype.definition.{0} = function({1}) [[ CS.Call({2}); ]]";
StringBuilder sb = new StringBuilder();
var argActual = new cg.args();
var argFormal = new cg.args();
for (int i = 0; i < constructors.Length; i++)
{
ConstructorInfo con = constructors[i];
ParameterInfo[] ps = con == null? new ParameterInfo[0] : con.GetParameters();
argActual.Clear().Add(
(int)JSVCall.Oper.CONSTRUCTOR, // OP
slot,
i, // NOTICE
"true", // IsStatics
"this"
);
argFormal.Clear();
// add T to formal param
if (type.IsGenericTypeDefinition)
{
// TODO check
int TCount = type.GetGenericArguments().Length;
for (int j = 0; j < TCount; j++)
{
argFormal.Add("t" + j + "");
argActual.Add("t" + j + ".getNativeType()");
}
}
//StringBuilder sbFormalParam = new StringBuilder();
//StringBuilder sbActualParam = new StringBuilder();
for (int j = 0; j < ps.Length; j++)
{
argFormal.Add("a" + j.ToString());
argActual.Add("a" + j.ToString());
}
sb.AppendFormat(fmt,
SharpKitMethodName("ctor", ps, howmanyConstructors > 1), // [0]
argFormal, // [1]
argActual); // [2]
}
return sb;
}
public static StringBuilder BuildProperties(Type type, PropertyInfo[] properties, int[] propertiesIndex, ClassCallbackNames ccbn)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < properties.Length; i++)
{
var sbCall = new StringBuilder();
PropertyInfo property = properties[i];
MethodInfo[] accessors = property.GetAccessors();
bool isStatic = accessors[0].IsStatic;
JSDataExchangeEditor.MemberFeature features = 0;
if (isStatic) features |= JSDataExchangeEditor.MemberFeature.Static;
bool bGenericT = type.IsGenericTypeDefinition;
StringBuilder sbt = null;
bool isDelegate = JSDataExchangeEditor.IsDelegateDerived(property.PropertyType); ;// (typeof(System.Delegate).IsAssignableFrom(property.PropertyType));
if (isDelegate)
{
sb.Append(JSDataExchangeEditor.Build_DelegateFunction(type, property, property.PropertyType, i, 0));
}
// PropertyID
if (bGenericT)
{
cg.args arg = new cg.args();
arg.AddFormat("\"{0}\"", property.Name);
arg.AddFormat("\"{0}\"", property.PropertyType.Name);
if (property.PropertyType.IsGenericParameter)
{
arg.Add("TypeFlag.IsT");
}
else
{
arg.Add("TypeFlag.None");
}
cg.args arg1 = new cg.args();
cg.args arg2 = new cg.args();
foreach (ParameterInfo p in property.GetIndexParameters())
{
cg.args argFlag = ParameterInfo2TypeFlag(p);
arg1.AddFormat("\"{0}\"", p.ParameterType.Name);
arg2.Add(argFlag.Format(cg.args.ArgsFormat.Flag));
}
if (arg1.Count > 0)
arg.AddFormat("new string[]{0}", arg1.Format(cg.args.ArgsFormat.Brace));
else
arg.Add("null");
if (arg2.Count > 0)
arg.AddFormat("new TypeFlag[]{0}", arg2.Format(cg.args.ArgsFormat.Brace));
else
arg.Add("null");
sb.AppendFormat("public static PropertyID propertyID{0} = new PropertyID({1});\n", i, arg.ToString());
}
if (bGenericT)
{
sbt = new StringBuilder();
sbt.AppendFormat(" PropertyInfo member = GenericTypeCache.getProperty(vc.csObj.GetType(), propertyID{0}); \n", i);
sbt.AppendFormat(" if (member == null) return;\n");
sbt.Append("\n");
}
//
// check to see if this is a indexer
//
ParameterInfo[] ps = property.GetIndexParameters();
bool bIndexer = (ps.Length > 0);
if (bIndexer) features |= JSDataExchangeEditor.MemberFeature.Indexer;
cg.args argActual = new cg.args();
JSDataExchangeEditor.ParamHandler[] paramHandlers = new JSDataExchangeEditor.ParamHandler[ps.Length];
for (int j = 0; j < ps.Length; j++)
{
paramHandlers[j] = JSDataExchangeEditor.Get_ParamHandler(ps[j].ParameterType, j, false, false);
argActual.Add(paramHandlers[j].argName);
}
string functionName = type.Name + "_" + property.Name;
if (bIndexer)
{
foreach (var p in ps)
{
functionName += "_" + p.ParameterType.Name;
}
}
functionName = JSNameMgr.HandleFunctionName(functionName);
sb.AppendFormat("static void {0}(JSVCall vc)\n[[\n", functionName);
if (bGenericT)
{
sb.Append(sbt);
}
for (int j = 0; j < ps.Length; j++)
{
sb.Append(" " + paramHandlers[j].getter + "\n");
}
bool bReadOnly = (!property.CanWrite || property.GetSetMethod() == null);
sbCall.Append(JSDataExchangeEditor.BuildCallString(type, property, argActual.Format(cg.args.ArgsFormat.OnlyList),
features | JSDataExchangeEditor.MemberFeature.Get));
if (!bReadOnly)
{
sb.Append(" if (vc.bGet)\n");
sb.Append(" [[ \n");
}
//if (type.IsValueType && !field.IsStatic)
// sb.AppendFormat("{0} argThis = ({0})vc.csObj;", type.Name);
if (property.CanRead)
{
if (property.GetGetMethod() != null)
{
sb.Append(sbCall);
sb.AppendFormat(" {0}\n", JSDataExchangeEditor.Get_Return(property.PropertyType, "result"));
}
else
{
Debug.Log(type.Name + "." + property.Name + " 'get' is ignored because it's not public.");
}
}
if (!bReadOnly)
{
sb.Append(" ]]\n");
}
// set
if (!bReadOnly)
{
sb.Append(" else\n");
sb.Append(" [[ \n");
if (!isDelegate)
{
int ParamIndex = ps.Length;
var paramHandler = JSDataExchangeEditor.Get_ParamHandler(property.PropertyType, ParamIndex, false, false);
sb.Append(" " + paramHandler.getter + "\n");
sb.Append(JSDataExchangeEditor.BuildCallString(type, property, argActual.Format(cg.args.ArgsFormat.OnlyList),
features | JSDataExchangeEditor.MemberFeature.Set, paramHandler.argName));
}
else
{
var getDelegateFuncitonName = JSDataExchangeEditor.GetMethodArg_DelegateFuncionName(type, property.Name, i, 0);
// sb.Append(JSDataExchangeEditor.BuildCallString(type, field, "" /* argList */,
// features | JSDataExchangeEditor.MemberFeature.Set, getDelegateFuncitonName + "(vc.getJSFunctionValue())"));
string getDelegate = JSDataExchangeEditor.Build_GetDelegate(getDelegateFuncitonName, property.PropertyType);
sb.Append(JSDataExchangeEditor.BuildCallString(type, property, "" /* argList */,
features | JSDataExchangeEditor.MemberFeature.Set, getDelegate));
}
sb.Append(" ]]\n");
}
sb.AppendFormat("]]\n");
ccbn.properties.Add(functionName);
}
return sb;
}
public static StringBuilder BuildConstructors(Type type, ConstructorInfo[] constructors, int[] constructorsIndex, ClassCallbackNames ccbn)
{
/*
* methods
* 0 function name
* 1 list<CSParam> generation
* 2 function call
*/
string fmt = @"
static bool {0}(JSVCall vc, int argc)
[[
{1}
return true;
]]
";
StringBuilder sb = new StringBuilder();
/*if (constructors.Length == 0 && JSBindingSettings.IsGeneratedDefaultConstructor(type) &&
(type.IsValueType || (type.IsClass && !type.IsAbstract && !type.IsInterface)))
{
int olIndex = 1;
bool returnVoid = false;
string functionName = type.Name + "_" + type.Name +
(olIndex > 0 ? olIndex.ToString() : "") + "";// (cons.IsStatic ? "_S" : "");
sb.AppendFormat(fmt, functionName,
BuildNormalFunctionCall(0, new ParameterInfo[0], type.Name, type.Name, false, returnVoid, null, true));
ccbn.constructors.Add(functionName);
ccbn.constructorsCSParam.Add(GenListCSParam2(new ParameterInfo[0]).ToString());
}*/
// increase index if adding default constructor
// int deltaIndex = 0;
if (JSBindingSettings.NeedGenDefaultConstructor(type))
{
// deltaIndex = 1;
}
for (int i = 0; i < constructors.Length; i++)
{
ConstructorInfo cons = constructors[i];
if (cons == null)
{
sb.AppendFormat("public static ConstructorID constructorID{0} = new ConstructorID({1});\n", i, "null, null");
// this is default constructor
//bool returnVoid = false;
//string functionName = type.Name + "_" + type.Name + "1";
int olIndex = i + 1; // for constuctors, they are always overloaded
string functionName = JSNameMgr.HandleFunctionName(type.Name + "_" + type.Name + (olIndex > 0 ? olIndex.ToString() : ""));
sb.AppendFormat(fmt, functionName,
BuildNormalFunctionCall(0, new ParameterInfo[0], type.Name, false, null, true));
ccbn.constructors.Add(functionName);
ccbn.constructorsCSParam.Add(GenListCSParam2(new ParameterInfo[0]).ToString());
}
else
{
ParameterInfo[] paramS = cons.GetParameters();
int olIndex = i + 1; // for constuctors, they are always overloaded
int methodTag = i/* + deltaIndex*/;
for (int j = 0; j < paramS.Length; j++)
{
if (JSDataExchangeEditor.IsDelegateDerived(paramS[j].ParameterType))
{
StringBuilder sbD = JSDataExchangeEditor.Build_DelegateFunction(type, cons, paramS[j].ParameterType, methodTag, j);
sb.Append(sbD);
}
}
// ConstructorID
if (type.IsGenericTypeDefinition)
{
cg.args arg = new cg.args();
cg.args arg1 = new cg.args();
cg.args arg2 = new cg.args();
foreach (ParameterInfo p in cons.GetParameters())
{
cg.args argFlag = ParameterInfo2TypeFlag(p);
arg1.AddFormat("\"{0}\"", p.ParameterType.Name);
arg2.Add(argFlag.Format(cg.args.ArgsFormat.Flag));
}
if (arg1.Count > 0)
arg.AddFormat("new string[]{0}", arg1.Format(cg.args.ArgsFormat.Brace));
else
arg.Add("null");
if (arg2.Count > 0)
arg.AddFormat("new TypeFlag[]{0}", arg2.Format(cg.args.ArgsFormat.Brace));
else
arg.Add("null");
sb.AppendFormat("public static ConstructorID constructorID{0} = new ConstructorID({1});\n", i, arg.ToString());
}
string functionName = JSNameMgr.HandleFunctionName(type.Name + "_" + type.Name + (olIndex > 0 ? olIndex.ToString() : "") + (cons.IsStatic ? "_S" : ""));
sb.AppendFormat(fmt, functionName,
BuildNormalFunctionCall(methodTag, paramS, cons.Name, cons.IsStatic, null, true, 0));
ccbn.constructors.Add(functionName);
ccbn.constructorsCSParam.Add(GenListCSParam2(paramS).ToString());
}
}
return sb;
}
public static StringBuilder BuildMethods(Type type, MethodInfo[] methods, int[] methodsIndex, int[] olInfo, ClassCallbackNames ccbn)
{
/*
* methods
* 0 function name
* 1 list<CSParam> generation
* 2 function call
*/
string fmt = @"
static bool {0}(JSVCall vc, int argc)
[[
{1}
return true;
]]
";
StringBuilder sb = new StringBuilder();
for (int i = 0; i < methods.Length; i++)
{
MethodInfo method = methods[i];
ParameterInfo[] paramS = method.GetParameters();
for (int j = 0; j < paramS.Length; j++)
{
// if (paramS[j].ParameterType == typeof(DaikonForge.Tween.TweenAssignmentCallback<Vector3>))
// {
// Debug.Log("yes");
//
//if (typeof(System.Delegate).IsAssignableFrom(paramS[j].ParameterType))
if (JSDataExchangeEditor.IsDelegateDerived(paramS[j].ParameterType))
{
// StringBuilder sbD = JSDataExchangeEditor.BuildFunctionArg_DelegateFunction(type.Name, method.Name, paramS[j].ParameterType, i, j);
StringBuilder sbD = JSDataExchangeEditor.Build_DelegateFunction(type, method, paramS[j].ParameterType, i, j);
sb.Append(sbD);
}
}
// MethodID
if (type.IsGenericTypeDefinition || method.IsGenericMethodDefinition)
{
cg.args arg = new cg.args();
arg.AddFormat("\"{0}\"", method.Name);
arg.AddFormat("\"{0}\"", method.ReturnType.Name);
if (method.ReturnType.IsGenericParameter)
{
arg.Add("TypeFlag.IsT");
}
else
{
arg.Add("TypeFlag.None");
}
cg.args arg1 = new cg.args();
cg.args arg2 = new cg.args();
foreach (ParameterInfo p in method.GetParameters())
{
// flag of a parameter
cg.args argFlag = ParameterInfo2TypeFlag(p);
arg1.AddFormat("\"{0}\"", p.ParameterType.Name);
arg2.Add(argFlag.Format(cg.args.ArgsFormat.Flag));
}
if (arg1.Count > 0)
arg.AddFormat("new string[]{0}", arg1.Format(cg.args.ArgsFormat.Brace));
else
arg.Add("null");
if (arg2.Count > 0)
arg.AddFormat("new TypeFlag[]{0}", arg2.Format(cg.args.ArgsFormat.Brace));
else
arg.Add("null");
sb.AppendFormat("public static MethodID methodID{0} = new MethodID({1});\n", i, arg.ToString());
}
int olIndex = olInfo[i];
bool returnVoid = (method.ReturnType == typeof(void));
string functionName = type.Name + "_" + method.Name + (olIndex > 0 ? olIndex.ToString() : "") + (method.IsStatic ? "_S" : "");
int TCount = 0;
if (method.IsGenericMethodDefinition) {
TCount = method.GetGenericArguments().Length;
}
// if you change functionName
// also have to change code in 'Manual/' folder
functionName = JSNameMgr.HandleFunctionName(type.Name + "_" + SharpKitMethodName(method.Name, paramS, true, TCount));
if (method.IsSpecialName && method.Name == "op_Implicit" && paramS.Length > 0)
{
functionName += "_to_" + method.ReturnType.Name;
}
if (UnityEngineManual.isManual(functionName))
{
sb.AppendFormat(fmt, functionName, " UnityEngineManual." + functionName + "(vc, argc);");
}
else
{
sb.AppendFormat(fmt, functionName,
method.IsSpecialName ? BuildSpecialFunctionCall(paramS, type.Name, method.Name, method.IsStatic, returnVoid, method.ReturnType)
: BuildNormalFunctionCall(i, paramS, method.Name, method.IsStatic, method.ReturnType,
false/* is constructor */,
TCount));
}
ccbn.methods.Add(functionName);
ccbn.methodsCSParam.Add(GenListCSParam2(paramS).ToString());
}
return sb;
}
public static cg.args ParameterInfo2TypeFlag(ParameterInfo p)
{
cg.args argFlag = new cg.args();
Type2TypeFlag(p.ParameterType, argFlag);
if (p.IsOut)
argFlag.Add("TypeFlag.IsOut");
if (argFlag.Count == 0)
argFlag.Add("TypeFlag.None");
return argFlag;
}
public static StringBuilder Build_DelegateFunction(Type classType, MemberInfo memberInfo, Type delType, int methodTag, int argIndex)
{
// building a closure
// a function having a up-value: jsFunction
string getDelFunctionName = GetMethodArg_DelegateFuncionName(classType, memberInfo.Name, methodTag, argIndex);
var sb = new StringBuilder();
MethodInfo delInvoke = delType.GetMethod("Invoke");
ParameterInfo[] ps = delInvoke.GetParameters();
Type returnType = delType.GetMethod("Invoke").ReturnType;
var argsParam = new cg.args();
for (int i = 0; i < ps.Length; i++)
{
argsParam.Add(ps[i].Name);
}
// <t,u,v> ����ʽ
string stringTOfMethod = string.Empty;
if (delType.ContainsGenericParameters)
{
var arg = new cg.args();
foreach (var t in delType.GetGenericArguments())
{
arg.Add(t.Name);
}
stringTOfMethod = arg.Format(cg.args.ArgsFormat.GenericT);
}
// this function name is used in BuildFields, don't change
sb.AppendFormat("public static {0} {1}{2}(CSRepresentedObject objFunction)\n[[\n",
JSNameMgr.GetTypeFullName(delType, true), // [0]
getDelFunctionName, // [2]
stringTOfMethod // [1]
);
sb.Append(" if (objFunction == null || objFunction.jsObjID == 0)\n");
sb.Append(" [[\n return null;\n ]]\n");
sb.AppendFormat(" {0} action = ({1}) => \n", JSNameMgr.GetTypeFullName(delType, true), argsParam.Format(cg.args.ArgsFormat.OnlyList));
sb.AppendFormat(" [[\n");
sb.AppendFormat(" JSMgr.vCall.CallJSFunctionValue(0, objFunction.jsObjID{0}{1});\n", (argsParam.Count > 0) ? ", " : "", argsParam);
if (returnType != typeof(void))
sb.Append(" return (" + JSNameMgr.GetTypeFullName(returnType) + ")" + JSDataExchangeEditor.Get_GetJSReturn(returnType) + ";\n");
sb.AppendFormat(" ]];\n");
sb.Append(" JSMgr.addJSFunCSDelegateRel(objFunction.jsObjID, action);\n");
sb.Append(" return action;\n");
sb.AppendFormat("]]\n");
return sb;
}
