public static StringBuilder BuildPropertiesTypeT(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]; bool bT = type.IsGenericTypeDefinition; StringBuilder sbt = null; if (bT) { sbt = new StringBuilder(); sbt.AppendFormat(" PropertyInfo property = JSDataExchangeMgr.GetPropertyInfoOfGenericClass(vc.csObj.GetType(), {0}); \n", propertiesIndex[i]); // [0] methodArrIndex sbt.AppendFormat(" if (property == null)\n return true;\n"); sbt.Append("\n"); sb.Append(sbt); } // // check to see if this is a indexer // ParameterInfo[] ps = property.GetIndexParameters(); bool bIndexer = (ps.Length > 0); StringBuilder sbActualParam = null; JSDataExchangeEditor.ParamHandler[] paramHandlers = null; if (bIndexer) { sbActualParam = new StringBuilder(); paramHandlers = new JSDataExchangeEditor.ParamHandler[ps.Length]; sbActualParam.Append("["); for (int j = 0; j < ps.Length; j++) { paramHandlers[j] = JSDataExchangeEditor.Get_ParamHandler(ps[j].ParameterType, j, false, false); sbActualParam.AppendFormat("{0}", paramHandlers[j].argName); if (j != ps.Length - 1) sbActualParam.Append(", "); } sbActualParam.Append("]"); } 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); MethodInfo[] accessors = property.GetAccessors(); bool isStatic = accessors[0].IsStatic; bool bReadOnly = !property.CanWrite; if (bIndexer) { for (int j = 0; j < ps.Length; j++) { sb.Append(" " + paramHandlers[j].getter + "\n"); } if (bT) { if (isStatic) { sbCall.AppendFormat("{0}{1}", JSNameMgr.GetTypeFullName(type), sbActualParam); } else { sbCall.AppendFormat("(({0})vc.csObj){1}", JSNameMgr.GetTypeFullName(type), sbActualParam); } } else { if (isStatic) { sbCall.AppendFormat("{0}{1}", JSNameMgr.GetTypeFullName(type), sbActualParam); } else { sbCall.AppendFormat("(({0})vc.csObj){1}", JSNameMgr.GetTypeFullName(type), sbActualParam); } } } if (!bReadOnly) { sb.Append(" if (vc.bGet) [[ \n"); } if (!bIndexer) { // get if (isStatic) sbCall.AppendFormat("{0}.{1}", JSNameMgr.GetTypeFullName(type), property.Name); else sbCall.AppendFormat("(({0})vc.csObj).{1}", JSNameMgr.GetTypeFullName(type), property.Name); } //if (type.IsValueType && !field.IsStatic) // sb.AppendFormat("{0} argThis = ({0})vc.csObj;", type.Name); sb.AppendFormat(" {0}", JSDataExchangeEditor.Get_Return(property.PropertyType, sbCall.ToString())); if (!bReadOnly) { sb.Append("\n ]]\n"); } // set if (!bReadOnly) { sb.Append(" else [[\n"); int ParamIndex = ps.Length; var paramHandler = JSDataExchangeEditor.Get_ParamHandler(property.PropertyType, ParamIndex, false, false); sb.Append(" " + paramHandler.getter + "\n"); if (bIndexer) { if (isStatic) sb.AppendFormat("{0} = {1};\n", sbCall, paramHandler.argName); else { if (type.IsValueType) { sb.AppendFormat(" {0} argThis = ({0})vc.csObj;\n", JSNameMgr.GetTypeFullName(type)); sb.AppendFormat("argThis{0} = {1};", sbActualParam, paramHandler.argName); sb.Append(" JSMgr.changeJSObj(vc.jsObjID, argThis);\n"); } else { sb.AppendFormat(" {0} = {1};\n", sbCall, paramHandler.argName); } } } else { if (isStatic) sb.AppendFormat("{0}.{1} = {2};\n", JSNameMgr.GetTypeFullName(type), property.Name, paramHandler.argName); else { if (type.IsValueType) { sb.AppendFormat(" {0} argThis = ({0})vc.csObj;\n", JSNameMgr.GetTypeFullName(type)); sb.AppendFormat(" argThis.{0} = {1};\n", property.Name, paramHandler.argName); sb.Append(" JSMgr.changeJSObj(vc.jsObjID, argThis);\n"); } else { sb.AppendFormat(" (({0})vc.csObj).{1} = {2};\n", JSNameMgr.GetTypeFullName(type), property.Name, paramHandler.argName); } } } sb.Append(" ]]\n"); } sb.AppendFormat("]]\n"); ccbn.properties.Add(functionName); } return sb; }
public static StringBuilder BuildNormalFunctionCall( int methodTag, ParameterInfo[] ps, string methodName, bool bStatic, Type returnType, bool bConstructor, int TCount = 0) { StringBuilder sb = new StringBuilder(); if (bConstructor) { sb.Append(" int _this = JSApi.getObject((int)JSApi.GetType.Arg);\n"); sb.Append(" JSApi.attachFinalizerObject(_this);\n"); sb.Append(" --argc;\n\n"); } if (bConstructor) { if (type.IsGenericTypeDefinition) { // Not generic method, but is generic type StringBuilder sbt = new StringBuilder(); sbt.AppendFormat(" ConstructorInfo constructor = JSDataExchangeMgr.makeGenericConstructor(typeof({0}), constructorID{1}); \n", JSNameMgr.GetTypeFullName(type), methodTag); //sbMethodHitTest.AppendFormat("GenericTypeCache.getConstructor(typeof({0}), {2}.constructorID{1});\n", JSNameMgr.GetTypeFullName(type), methodTag, JSNameMgr.GetTypeFileName(type)); sbt.AppendFormat(" if (constructor == null) return true;\n"); sbt.Append("\n"); sb.Append(sbt); } } else if (TCount > 0) { StringBuilder sbt = new StringBuilder(); sbt.Append(" // Get generic method by name and param count.\n"); if (!bStatic) // instance method { sbt.AppendFormat(" MethodInfo method = JSDataExchangeMgr.makeGenericMethod(vc.csObj.GetType(), methodID{0}, {1}); \n", methodTag, TCount); } else // static method { sbt.AppendFormat(" MethodInfo method = JSDataExchangeMgr.makeGenericMethod(typeof({0}), methodID{1}, {2}); \n", JSNameMgr.GetTypeFullName(type), methodTag, TCount); } sbt.AppendFormat(" if (method == null) return true;\n"); sbt.Append("\n"); sb.Append(sbt); } else if (type.IsGenericTypeDefinition) { // not generic method, but is generic type StringBuilder sbt = new StringBuilder(); sbt.Append(" // Get generic method by name and param count.\n"); if (!bStatic) // instance method { sbt.AppendFormat(" MethodInfo method = GenericTypeCache.getMethod(vc.csObj.GetType(), methodID{0}); \n", methodTag); } else // static method { // Debug.LogError("=================================ERROR"); sbt.AppendFormat(" MethodInfo method = GenericTypeCache.getMethod(typeof({0}), methodID{1}); \n", JSNameMgr.GetTypeFullName(type), // [0] methodTag); } sbt.AppendFormat(" if (method == null) return true;\n"); sbt.Append("\n"); sb.Append(sbt); } else if (type.IsGenericType) { ///////////////////// /// ERROR /////////// ///////////////////// } var paramHandlers = new JSDataExchangeEditor.ParamHandler[ps.Length]; for (int i = 0; i < ps.Length; i++) { if (true /* !ps[i].ParameterType.IsGenericParameter */ ) { // use original method's parameterinfo if (!JSDataExchangeEditor.IsDelegateDerived(ps[i].ParameterType)) paramHandlers[i] = JSDataExchangeEditor.Get_ParamHandler(ps[i], i); // if (ps[i].ParameterType.IsGenericParameter) // { // paramHandlers[i].getter = " JSMgr.datax.setTemp(method.GetParameters()[" + i.ToString() + "].ParameterType);\n" + paramHandlers[i].getter; // } } } // minimal params needed int minNeedParams = 0; for (int i = 0; i < ps.Length; i++) { if (ps[i].IsOptional) { break; } minNeedParams++; } if (bConstructor && type.IsGenericTypeDefinition) sb.AppendFormat(" int len = argc - {0};\n", type.GetGenericArguments().Length); else if (TCount == 0) sb.AppendFormat(" int len = argc;\n"); else sb.AppendFormat(" int len = argc - {0};\n", TCount); for (int j = minNeedParams; j <= ps.Length; j++) { StringBuilder sbGetParam = new StringBuilder(); StringBuilder sbActualParam = new StringBuilder(); StringBuilder sbUpdateRefParam = new StringBuilder(); // receive arguments first for (int i = 0; i < j; i++) { ParameterInfo p = ps[i]; //if (typeof(System.Delegate).IsAssignableFrom(p.ParameterType)) if (JSDataExchangeEditor.IsDelegateDerived(p.ParameterType)) { //string delegateGetName = JSDataExchangeEditor.GetFunctionArg_DelegateFuncionName(className, methodName, methodIndex, i); string delegateGetName = JSDataExchangeEditor.GetMethodArg_DelegateFuncionName(type, methodName, methodTag, i); //if (p.ParameterType.IsGenericType) if (p.ParameterType.ContainsGenericParameters) { // cg.args ta = new cg.args(); // sbGetParam.AppendFormat("foreach (var a in method.GetParameters()[{0}].ParameterType.GetGenericArguments()) ta.Add();"); sbGetParam.AppendFormat("object arg{0} = JSDataExchangeMgr.GetJSArg<object>(()=>[[\n", i); sbGetParam.AppendFormat(" if (JSApi.isFunctionS((int)JSApi.GetType.Arg)) [[\n"); sbGetParam.AppendFormat(" var getDelegateFun{0} = typeof({1}).GetMethod(\"{2}\").MakeGenericMethod\n", i, thisClassName, delegateGetName); sbGetParam.AppendFormat(" (method.GetParameters()[{0}].ParameterType.GetGenericArguments());\n", i); sbGetParam.AppendFormat(" return getDelegateFun{0}.Invoke(null, new object[][[{1}]]);\n", i, "JSApi.getFunctionS((int)JSApi.GetType.Arg)"); sbGetParam.Append(" ]]\n"); sbGetParam.Append(" else\n"); sbGetParam.AppendFormat(" return JSMgr.datax.getObject((int)JSApi.GetType.Arg);\n"); sbGetParam.Append("]]);\n"); // sbGetParam.AppendFormat(" var getDelegateFun{0} = typeof({1}).GetMethod(\"{2}\").MakeGenericMethod\n", i, thisClassName, delegateGetName); // sbGetParam.AppendFormat(" (method.GetParameters()[{0}].ParameterType.GetGenericArguments());\n", i); // sbGetParam.AppendFormat(" object arg{0} = getDelegateFun{0}.Invoke(null, new object[][[{1}]]);\n", i, "vc.getJSFunctionValue()"); } else { sbGetParam.AppendFormat(" {0} arg{1} = {2};\n", JSNameMgr.GetTypeFullName(p.ParameterType), // [0] i, // [1] JSDataExchangeEditor.Build_GetDelegate(delegateGetName, p.ParameterType) // [2] ); } } else { sbGetParam.Append(" " + paramHandlers[i].getter + "\n"); } // value type array // no 'out' nor 'ref' if ((p.ParameterType.IsByRef || p.IsOut) && !p.ParameterType.IsArray) sbActualParam.AppendFormat("{0} arg{1}{2}", (p.IsOut) ? "out" : "ref", i, (i == j - 1 ? "" : ", ")); else sbActualParam.AppendFormat("arg{0}{1}", i, (i == j - 1 ? "" : ", ")); // updater sbUpdateRefParam.Append(paramHandlers[i].updater); } /* * 0 parameters count * 1 class name * 2 function name * 3 actual parameters */ if (bConstructor) { StringBuilder sbCall = new StringBuilder(); if (!type.IsGenericTypeDefinition) sbCall.AppendFormat("new {0}({1})", JSNameMgr.GetTypeFullName(type), sbActualParam.ToString()); else { sbCall.AppendFormat("constructor.Invoke(null, new object[][[{0}]])", sbActualParam); } // string callAndReturn = JSDataExchangeEditor.Get_Return(type/*don't use returnType*/, sbCall.ToString()); string callAndReturn = new StringBuilder().AppendFormat(" JSMgr.addJSCSRel(_this, {0});", sbCall).ToString(); sb.AppendFormat(" {0}if (len == {1})\n", (j == minNeedParams) ? "" : "else ", j); sb.Append(" [[\n"); sb.Append(sbGetParam); sb.Append(callAndReturn).Append("\n"); if (sbUpdateRefParam.Length > 0) sb.Append(sbUpdateRefParam); sb.Append(" ]]\n"); // sb.AppendFormat(@" {0}if (len == {1}) // [[ // {2} // {3} // {4} // ]] // ", // (j == minNeedParams) ? "" : "else ", // [0] else // j, // [1] param length // sbGetParam, // [2] get param // callAndReturn, // [3] // sbUpdateRefParam); // [4] update ref/out params } else { StringBuilder sbCall = new StringBuilder(); StringBuilder sbActualParamT_arr = new StringBuilder(); //StringBuilder sbUpdateRefT = new StringBuilder(); if (TCount == 0 && !type.IsGenericTypeDefinition) { if (bStatic) sbCall.AppendFormat("{0}.{1}({2})", JSNameMgr.GetTypeFullName(type), methodName, sbActualParam.ToString()); else if (!type.IsValueType) sbCall.AppendFormat("(({0})vc.csObj).{1}({2})", JSNameMgr.GetTypeFullName(type), methodName, sbActualParam.ToString()); else sbCall.AppendFormat("argThis.{0}({1})", methodName, sbActualParam.ToString()); } else { if (ps.Length > 0) { sbActualParamT_arr.AppendFormat("object[] arr_t = new object[][[ {0} ]];", sbActualParam); // reflection call doesn't need out or ref modifier sbActualParamT_arr.Replace(" out ", " ").Replace(" ref ", " "); } else { sbActualParamT_arr.Append("object[] arr_t = null;"); } if (bStatic) sbCall.AppendFormat("method.Invoke(null, arr_t)"); else if (!type.IsValueType) sbCall.AppendFormat("method.Invoke(vc.csObj, arr_t)"); else sbCall.AppendFormat("method.Invoke(vc.csObj, arr_t)"); } string callAndReturn = JSDataExchangeEditor.Get_Return(returnType, sbCall.ToString()); StringBuilder sbStruct = null; if (type.IsValueType && !bStatic && TCount == 0 && !type.IsGenericTypeDefinition) { sbStruct = new StringBuilder(); sbStruct.AppendFormat("{0} argThis = ({0})vc.csObj;", JSNameMgr.GetTypeFullName(type)); } sb.AppendFormat(" {0}if (len == {1}) \n", (j == minNeedParams) ? "" : "else ", j); sb.Append(" [[\n"); sb.Append(sbGetParam); if (sbActualParamT_arr.Length > 0) { sb.Append(" ").Append(sbActualParamT_arr).Append("\n"); } // if it is Struct, get argThis first if (type.IsValueType && !bStatic && TCount == 0 && !type.IsGenericTypeDefinition) { sb.Append(sbStruct); } sb.Append(" ").Append(callAndReturn).Append("\n"); // if it is Struct, update 'this' object if (type.IsValueType && !bStatic && TCount == 0 && !type.IsGenericTypeDefinition) { sb.Append(" JSMgr.changeJSObj(vc.jsObjID, argThis);\n"); } sb.Append(sbUpdateRefParam); sb.Append(" ]]\n"); // sb.AppendFormat(@" {0}if (len == {1}) // [[ // {2} // {3} // {4} // {5} // {6} // ]] // ", // (j == minNeedParams) ? "" : "else ", // [0] else // j, // [1] param count // sbGetParam, // [2] get param // (type.IsValueType && !bStatic && TCount == 0 && !type.IsGenericTypeDefinition) ? sbStruct.ToString() : "", // [3] if Struct, get argThis first // callAndReturn, // [4] function call and return to js // (type.IsValueType && !bStatic && TCount == 0 && !type.IsGenericTypeDefinition) ? "JSMgr.changeJSObj(vc.jsObjID, argThis);" : "", // [5] if Struct, update 'this' object // sbUpdateRefParam); // [6] update ref/out param } } 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 BuildSpecialFunctionCall(ParameterInfo[] ps, string className, string methodName, bool bStatic, bool returnVoid, Type returnType) { StringBuilder sb = new StringBuilder(); var paramHandlers = new JSDataExchangeEditor.ParamHandler[ps.Length]; for (int i = 0; i < ps.Length; i++) { paramHandlers[i] = JSDataExchangeEditor.Get_ParamHandler(ps[i], i); sb.Append(" " + paramHandlers[i].getter + "\n"); } string strCall = string.Empty; // must be static if (methodName == "op_Addition") strCall = paramHandlers[0].argName + " + " + paramHandlers[1].argName; else if (methodName == "op_Subtraction") strCall = paramHandlers[0].argName + " - " + paramHandlers[1].argName; else if (methodName == "op_Multiply") strCall = paramHandlers[0].argName + " * " + paramHandlers[1].argName; else if (methodName == "op_Division") strCall = paramHandlers[0].argName + " / " + paramHandlers[1].argName; else if (methodName == "op_Equality") strCall = paramHandlers[0].argName + " == " + paramHandlers[1].argName; else if (methodName == "op_Inequality") strCall = paramHandlers[0].argName + " != " + paramHandlers[1].argName; else if (methodName == "op_UnaryNegation") strCall = "-" + paramHandlers[0].argName; else if (methodName == "op_LessThan") strCall = paramHandlers[0].argName + " < " + paramHandlers[1].argName; else if (methodName == "op_LessThanOrEqual") strCall = paramHandlers[0].argName + " <= " + paramHandlers[1].argName; else if (methodName == "op_GreaterThan") strCall = paramHandlers[0].argName + " > " + paramHandlers[1].argName; else if (methodName == "op_GreaterThanOrEqual") strCall = paramHandlers[0].argName + " >= " + paramHandlers[1].argName; else if (methodName == "op_Implicit") strCall = "(" + JSNameMgr.GetTypeFullName(returnType) + ")" + paramHandlers[0].argName; else Debug.LogError("Unknown special name: " + methodName); string ret = JSDataExchangeEditor.Get_Return(returnType, strCall); sb.Append(" " + ret); return sb; }