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;
}
