public override string GetCLRParamTypeName(DefParam param)
{
if (IsVoid)
{
string name = "void";
if (param.IsConst) name = "const " + name;
switch (param.PassedByType)
{
case PassedByType.Value:
break;
case PassedByType.Pointer:
name += "*";
break;
case PassedByType.PointerPointer:
name += "*%";
break;
case PassedByType.Reference:
throw new Exception("Unexpected");
}
return name;
}
switch (param.PassedByType)
{
case PassedByType.Value:
return Name;
case PassedByType.Reference:
case PassedByType.Pointer:
if (!param.IsConst && !param.HasAttribute<RawPointerParamAttribute>())
{
return "[Out] " + Name + "%";
}
else
{
//Treat it as array
//return "array<" + FullCLRName + ">^";
string name = Name + "*";
if (param.IsConst) name = "const " + name;
return name;
}
case PassedByType.PointerPointer:
default:
throw new Exception("Unexpected");
}
}
public override void GetNativeParamConversion(DefParam param, out string preConversion, out string conversion, out string postConversion)
{
preConversion = postConversion = null;
conversion = param.Name;
switch (param.PassedByType)
{
case PassedByType.Value:
case PassedByType.Reference:
break;
case PassedByType.Pointer:
if (!IsVoid)
{
if (!param.IsConst)
{
conversion = "*" + param.Name;
}
else
{
//Treat it as array
throw new Exception("Unexpected");
}
}
break;
case PassedByType.PointerPointer:
throw new Exception("Unexpected");
}
}
protected override void AddPropertyField(DefField field)
{
//TODO comments for fields
//AddComments(field);
string ptype;
if (field.IsNativeArray)
{
if (field.Type.HasAttribute<NativeValueContainerAttribute>()
|| (field.Type.IsValueType && !field.Type.HasWrapType(WrapTypes.NativePtrValueType)))
{
DefParam tmpParam = new DefParam(field, field.Name);
switch (field.PassedByType)
{
case PassedByType.Value:
tmpParam.PassedByType = PassedByType.Pointer;
break;
case PassedByType.Pointer:
tmpParam.PassedByType = PassedByType.PointerPointer;
break;
default:
throw new Exception("Unexpected");
}
ptype = tmpParam.CLRTypeName;
_sb.AppendIndent("");
if (field.IsStatic) _sb.Append("static ");
_sb.AppendFormat("property {0} {1}\n", ptype, field.Name);
_sb.AppendLine("{");
_sb.AppendLine(GetProtectionString(field.ProtectionType) + ":");
_sb.AppendLine("\t" + ptype + " get();");
_sb.AppendLine("}");
}
else
{
ptype = field.CLRTypeName;
_sb.AppendIndent("");
if (field.IsStatic) _sb.Append("static ");
_sb.AppendFormat("property {0} {1}[int]\n", ptype, field.Name);
_sb.AppendLine("{");
_sb.AppendLine(GetProtectionString(field.ProtectionType) + ":");
_sb.AppendLine("\t" + ptype + " get(int index);");
_sb.AppendLine("\tvoid set(int index, " + ptype + " value);");
_sb.AppendLine("}");
}
}
else if (_cachedMembers.Contains(field))
{
ptype = field.CLRTypeName;
_sb.AppendIndent("");
if (field.IsStatic) _sb.Append("static ");
_sb.AppendFormat("property {0} {1}\n", ptype, field.Name);
_sb.AppendLine("{");
_sb.AppendLine(GetProtectionString(field.ProtectionType) + ":");
_sb.AppendLine("\t" + ptype + " get();");
_sb.AppendLine("}");
}
else
{
ptype = GetCLRTypeName(field);
_sb.AppendIndent("");
if (field.IsStatic) _sb.Append("static ");
_sb.AppendFormat("property {0} {1}\n", ptype, field.Name);
_sb.AppendLine("{");
_sb.AppendLine(GetProtectionString(field.ProtectionType) + ":");
_sb.AppendLine("\t" + ptype + " get();");
if ( // SharedPtrs can be copied by value. Let all be copied by value just to be sure (field.PassedByType == PassedByType.Pointer || field.Type.IsValueType)
!IsReadOnly && !field.Type.HasAttribute<ReadOnlyForFieldsAttribute>()
&& !field.IsConst)
{
_sb.AppendLine(GetProtectionString(field.ProtectionType) + ":");
_sb.AppendLine("\tvoid set(" + ptype + " value);");
}
_sb.AppendLine("}");
}
}
public static void AddNativeProxyMethodBody(DefFunction f, string managedTarget, IndentStringBuilder sb)
{
string managedCall;
string fullPostConv = null;
if (f.IsGetProperty)
{
sb.AppendLine(f.CLRTypeName + " mp_return = " + managedTarget + "->" + f.CLRName + ";");
managedCall = "mp_return";
}
else if (f.IsSetProperty)
{
DefParam param = f.Parameters[0];
managedCall = managedTarget + "->" + f.CLRName + " = " + param.Type.GetNativeCallConversion(param.Name, param);
}
else
{
string pre, post, conv;
foreach (DefParam param in f.Parameters)
{
param.Type.GetNativeParamConversion(param, out pre, out conv, out post);
if (!String.IsNullOrEmpty(pre))
sb.AppendLine(pre);
if (!String.IsNullOrEmpty(post))
fullPostConv += post + "\n";
}
bool explicitCast = f.HasAttribute<ExplicitCastingForParamsAttribute>();
if (!f.IsVoid)
{
sb.AppendIndent(f.CLRTypeName + " mp_return = " + managedTarget + "->" + f.CLRName + "(");
for (int i = 0; i < f.Parameters.Count; i++)
{
DefParam param = f.Parameters[i];
param.Type.GetNativeParamConversion(param, out pre, out conv, out post);
sb.Append(" ");
if (explicitCast) sb.Append("(" + param.CLRTypeName + ")");
sb.Append(conv);
if (i < f.Parameters.Count - 1) sb.Append(",");
}
sb.Append(" );\n");
managedCall = "mp_return";
if (!String.IsNullOrEmpty(fullPostConv))
sb.AppendLine(fullPostConv);
}
else
{
managedCall = managedTarget + "->" + f.CLRName + "(";
for (int i = 0; i < f.Parameters.Count; i++)
{
DefParam param = f.Parameters[i];
param.Type.GetNativeParamConversion(param, out pre, out conv, out post);
managedCall += " ";
if (explicitCast) managedCall += "(" + param.CLRTypeName + ")";
managedCall += conv;
if (i < f.Parameters.Count - 1) managedCall += ",";
}
managedCall += " )";
}
}
if (!f.IsVoid)
{
if (f.Type is IDefString)
{
sb.AppendLine("SET_NATIVE_STRING( Mogre::Implementation::cachedReturnString, " + managedCall + " )");
sb.AppendLine("return Mogre::Implementation::cachedReturnString;");
}
else
{
string returnExpr;
string newname, expr, postcall;
DefParam param = new DefParam(f, managedCall);
expr = f.Type.GetPreCallParamConversion(param, out newname);
postcall = f.Type.GetPostCallParamConversionCleanup(param);
if (!String.IsNullOrEmpty(expr))
{
sb.AppendLine(expr);
if (String.IsNullOrEmpty(postcall))
returnExpr = newname;
else
{
throw new Exception("Unexpected");
}
}
else
{
returnExpr = newname;
}
if (IsCachedFunction(f))
{
sb.AppendLine("STATIC_ASSERT( sizeof(" + f.Type.FullNativeName + ") <= CACHED_RETURN_SIZE )");
sb.AppendLine("memcpy( Mogre::Implementation::cachedReturn, &" + returnExpr + ", sizeof(" + f.Type.FullNativeName + ") );");
sb.AppendLine("return *reinterpret_cast<" + f.Type.FullNativeName + "*>(Mogre::Implementation::cachedReturn);");
}
else
{
sb.AppendLine("return " + returnExpr + ";");
}
}
}
else
{
sb.AppendLine(managedCall + ";");
if (!String.IsNullOrEmpty(fullPostConv))
sb.AppendLine(fullPostConv);
}
}
public override string GetCLRParamTypeName(DefParam param)
{
if (!IsUnnamedSTLContainer)
return base.GetCLRParamTypeName(param);
switch (param.PassedByType)
{
case PassedByType.Reference:
return ConversionTypeName;
case PassedByType.Pointer:
if (param.IsConst)
return ConversionTypeName;
else
throw new Exception("Unexpected");
case PassedByType.PointerPointer:
case PassedByType.Value:
default:
throw new Exception("Unexpected");
}
}
public override string GetPreCallParamConversion(DefParam param, out string newname)
{
newname = "(" + param.NativeTypeName + ")" + param.Name;
return String.Empty;
}
public override string GetPreCallParamConversion(DefParam param, out string newname)
{
newname = param.Name;
return String.Empty;
}
public override string GetCLRParamTypeName(DefParam param)
{
switch (param.PassedByType)
{
case PassedByType.Value:
return FullCLRName + "^";
case PassedByType.Reference:
case PassedByType.PointerPointer:
case PassedByType.Pointer:
default:
throw new Exception("Unexpected");
}
}
public override void GetDefaultParamValueConversion(DefParam param, out string preConversion, out string conversion, out string postConversion, out DefType dependancyType)
{
preConversion = postConversion = "";
dependancyType = null;
switch (param.PassedByType)
{
case PassedByType.Reference:
case PassedByType.Value:
conversion = param.DefaultValue.Trim();
if (!conversion.StartsWith("\"")
&& conversion.Contains("::"))
{
//It's a static string of a class
if (conversion == "StringUtil::BLANK")
{
//Manually translate "StringUtil::BLANK" so that there's no need to wrap the StringUtil class
conversion = "String::Empty";
return;
}
string name = conversion.Substring(0, conversion.LastIndexOf("::"));
dependancyType = FindType<DefType>(name);
}
break;
default:
throw new Exception("Unexpected");
}
}
public override string GetPreCallParamConversion(DefParam param, out string newname)
{
switch (param.PassedByType)
{
case PassedByType.Reference:
case PassedByType.Value:
newname = "ToNative<" + ConversionTypeName + ", " + FullNativeName + ">( " + param.Name + ")";
return "";
case PassedByType.Pointer:
case PassedByType.PointerPointer:
default:
throw new Exception("Unexpected");
}
}
protected virtual string GetCLRParamTypeName(DefParam param)
{
AddTypeDependancy(param.Type);
return param.Type.GetCLRParamTypeName(param);
}
protected override void AddPropertyField(DefField field)
{
string ptype = GetCLRTypeName(field);
string pname = GetClassName() + "::" + field.Name;
if (field.IsNativeArray)
{
if (field.Type.HasAttribute<NativeValueContainerAttribute>()
|| (field.Type.IsValueType && !field.Type.HasWrapType(WrapTypes.NativePtrValueType)))
{
DefParam tmpParam = new DefParam(field, field.Name + "_array");
switch (field.PassedByType)
{
case PassedByType.Value:
tmpParam.PassedByType = PassedByType.Pointer;
break;
case PassedByType.Pointer:
tmpParam.PassedByType = PassedByType.PointerPointer;
break;
default:
throw new Exception("Unexpected");
}
ptype = GetCLRTypeName(tmpParam);
string managedType = field.Type.GetNativeCallConversion(GetNativeInvokationTarget(field), tmpParam);
_sb.AppendLine(ptype + " " + pname + "::get()");
_sb.AppendLine("{");
_sb.AppendLine("\treturn " + managedType + ";");
_sb.AppendLine("}");
}
else
{
string managedType = field.Type.GetNativeCallConversion(GetNativeInvokationTarget(field) + "[index]", field);
_sb.AppendLine(ptype + " " + pname + "::get(int index)");
_sb.AppendLine("{");
_sb.AppendLine("\tif (index < 0 || index >= " + field.ArraySize + ") throw gcnew IndexOutOfRangeException();");
_sb.AppendLine("\treturn " + managedType + ";");
_sb.AppendLine("}");
_sb.AppendLine("void " + pname + "::set(int index, " + ptype + " value )");
_sb.AppendLine("{");
_sb.IncreaseIndent();
_sb.AppendLine("if (index < 0 || index >= " + field.ArraySize + ") throw gcnew IndexOutOfRangeException();");
string param = AddParameterConversion(new DefParam(field, "value"));
_sb.AppendLine(GetNativeInvokationTarget(field) + "[index] = " + param + ";");
_sb.DecreaseIndent();
_sb.AppendLine("}");
}
}
else if (_cachedMembers.Contains(field))
{
string managedType;
if (field.Type.IsSTLContainer)
{
managedType = GetNativeInvokationTarget(field);
}
else
{
managedType = field.Type.GetNativeCallConversion(GetNativeInvokationTarget(field), field);
}
string priv = NameToPrivate(field);
_sb.AppendLine(ptype + " " + pname + "::get()");
_sb.AppendLine("{");
if (!field.IsStatic)
_sb.AppendLine("\treturn ( CLR_NULL == " + priv + " ) ? (" + priv + " = " + managedType + ") : " + priv + ";");
else
_sb.AppendLine("\treturn " + priv + ";");
_sb.AppendLine("}");
}
else
{
string managedType = field.Type.GetNativeCallConversion(GetNativeInvokationTarget(field), field);
_sb.AppendLine(ptype + " " + pname + "::get()");
_sb.AppendLine("{");
_sb.AppendLine("\treturn " + managedType + ";");
_sb.AppendLine("}");
if ( // SharedPtrs can be copied by value. Let all be copied by value just to be sure (field.PassedByType == PassedByType.Pointer || field.Type.IsValueType)
!IsReadOnly && !field.Type.HasAttribute<ReadOnlyForFieldsAttribute>()
&& !field.IsConst)
{
_sb.AppendLine("void " + pname + "::set( " + ptype + " value )");
_sb.AppendLine("{");
_sb.IncreaseIndent();
string param = AddParameterConversion(new DefParam(field, "value"));
_sb.AppendLine(GetNativeInvokationTarget(field) + " = " + param + ";");
_sb.DecreaseIndent();
_sb.AppendLine("}");
}
}
}
protected string AddParameterConversion(DefParam param)
{
string newname, expr, postcall;
expr = param.Type.GetPreCallParamConversion(param, out newname);
postcall = param.Type.GetPostCallParamConversionCleanup(param);
if (!String.IsNullOrEmpty(postcall))
throw new Exception("Unexpected");
if (!String.IsNullOrEmpty(expr))
_sb.AppendLine(expr);
return newname;
}
protected override void AddMethodsForField(DefField field)
{
string managedType = field.Type.GetNativeCallConversion(GetNativeInvokationTarget(field), field);
_sb.AppendLine(GetCLRTypeName(field) + " " + GetClassName() + "::get_" + field.Name + "()");
_sb.AppendLine("{");
_sb.AppendLine("\treturn " + managedType + ";");
_sb.AppendLine("}");
DefParam param = new DefParam(field, "value");
_sb.AppendLine("void " + GetClassName() + "::set_" + field.Name + "(" + param.Type.GetCLRParamTypeName(param) + " value)");
_sb.AppendLine("{");
_sb.IncreaseIndent();
_sb.AppendLine(GetNativeInvokationTarget(field) + " = " + AddParameterConversion(param) + ";");
_sb.DecreaseIndent();
_sb.AppendLine("}");
}
public override string GetPostCallParamConversionCleanup(DefParam param)
{
if (IsVoid)
return "";
switch (param.PassedByType)
{
case PassedByType.Pointer:
if (param.IsConst)
{
//Treat it as array
//return "delete[] arr_" + param.Name + ";";
return "";
}
else
return base.GetPostCallParamConversionCleanup(param);
default:
return base.GetPostCallParamConversionCleanup(param);
}
}
public override string GetPreCallParamConversion(DefParam param, out string newname)
{
if (IsVoid)
{
newname = param.Name;
return "";
}
switch (param.PassedByType)
{
case PassedByType.Reference:
newname = "*p_" + param.Name;
return "pin_ptr<" + FullCLRName + "> p_" + param.Name + " = &" + param.Name + ";\n";
case PassedByType.Pointer:
if (!param.IsConst && !param.HasAttribute<RawPointerParamAttribute>())
{
newname = "p_" + param.Name;
return "pin_ptr<" + FullCLRName + "> p_" + param.Name + " = &" + param.Name + ";\n";
}
else
{
//Treat it as array
//newname = "arr_" + param.Name;
//string expr = FullNativeName + "* arr_" + param.Name + " = new " + FullNativeName + "[" + param.Name + "->Length];\n";
//expr += "pin_ptr<" + FullCLRName + "> src_" + param.Name + " = &" + param.Name + "[0];\n";
//expr += "memcpy(arr_" + param.Name + ", src_" + param.Name + ", " + param.Name + "->Length * sizeof(" + FullNativeName + "));\n";
//return expr;
newname = param.Name;
return "";
}
default:
return base.GetPreCallParamConversion(param, out newname);
}
}
public override string GetPostCallParamConversionCleanup(DefParam param)
{
switch (param.PassedByType)
{
case PassedByType.Value:
case PassedByType.Reference:
return "";
case PassedByType.Pointer:
return "delete[] arr_" + param.Name + ";\n";
case PassedByType.PointerPointer:
default:
throw new Exception("Unexpected");
}
}
public override string GetPostCallParamConversionCleanup(DefParam param)
{
return String.Empty;
}
public override void GetDefaultParamValueConversion(DefParam param, out string preConversion, out string conversion, out string postConversion, out DefType dependancyType)
{
preConversion = postConversion = "";
dependancyType = null;
if (IsVoid)
{
conversion = param.DefaultValue;
return;
}
switch (param.PassedByType)
{
case PassedByType.Pointer:
if (!param.IsConst)
{
preConversion = FullCLRName + " out_" + param.Name + ";";
conversion = "out_" + param.Name;
return;
}
else
{
throw new Exception("Unexpected");
}
default:
conversion = param.DefaultValue;
break;
}
}
public override string GetCLRParamTypeName(DefParam param)
{
return GetCLRTypeName(param);
}
public override string GetPreCallParamConversion(DefParam param, out string newname)
{
string name = param.Name;
switch (param.PassedByType)
{
case PassedByType.Value:
case PassedByType.Reference:
newname = "o_" + name;
return "DECLARE_NATIVE_STRING( o_" + name + ", " + name + " )\n";
case PassedByType.Pointer:
string expr = FullNativeName + "* arr_" + name + " = new " + FullNativeName + "[" + name + "->Length];\n";
expr += "for (int i=0; i < " + name + "->Length; i++)\n";
expr += "{\n";
expr += "\tSET_NATIVE_STRING( arr_" + name + "[i], " + name + "[i] )\n";
expr += "}\n";
newname = "arr_" + name;
return expr;
case PassedByType.PointerPointer:
default:
throw new Exception("Unexpected");
}
}
public override string GetCLRParamTypeName(DefParam param)
{
switch (param.PassedByType)
{
case PassedByType.Reference:
case PassedByType.Pointer:
if (param.IsConst)
return FullCLRName.Replace(CLRName, "Const_" + CLRName) + "^";
else
return FullCLRName + "^";
case PassedByType.Value:
case PassedByType.PointerPointer:
default:
throw new Exception("Unexpected");
}
}
public override void GetDefaultParamValueConversion(DefParam param, out string preConversion, out string conversion, out string postConversion, out DefType dependancyType)
{
preConversion = postConversion = "";
dependancyType = null;
switch (param.PassedByType)
{
case PassedByType.Pointer:
if (param.DefaultValue == "NULL" || param.DefaultValue == "0")
{
conversion = "nullptr";
return;
}
else
throw new Exception("Unexpected");
default:
throw new Exception("Unexpected");
}
}
public override string GetPreCallParamConversion(DefParam param, out string newname)
{
if (!IsUnnamedSTLContainer)
return base.GetPreCallParamConversion(param, out newname);
string expr;
switch (param.PassedByType)
{
case PassedByType.Reference:
expr = FullNativeName + " o_" + param.Name + ";\n";
expr += PreCallConversionFunction + "(o_" + param.Name + ", " + param.Name + ");\n";
newname = "o_" + param.Name;
return expr;
case PassedByType.Pointer:
if (param.IsConst)
{
expr = FullNativeName + "* p_" + param.Name + " = 0;\n";
expr += FullNativeName + " o_" + param.Name + ";\n";
expr += "if (" + param.Name + " != CLR_NULL)\n{\n";
expr += "\t" + PreCallConversionFunction + "(o_" + param.Name + ", " + param.Name + ");\n";
expr += "\tp_" + param.Name + " = &o_" + param.Name + ";\n";
expr += "}\n";
newname = "p_" + param.Name;
return expr;
}
else
throw new Exception("Unexpected");
case PassedByType.PointerPointer:
case PassedByType.Value:
default:
throw new Exception("Unexpected");
}
}
public override string GetPreCallParamConversion(DefParam param, out string newname)
{
if (param.PassedByType == PassedByType.Pointer)
newname = "(" + param.Type.FullNativeName + "*) " + param.Name;
else
newname = param.Name;
return string.Empty;
}
protected virtual void AddNativeMethodParam(DefParam param)
{
_sb.Append(param.NativeTypeName + " " + param.Name);
}
protected override void AddMethodsForField(DefField field)
{
_sb.AppendLine(GetCLRTypeName(field) + " get_" + field.Name + "();");
DefParam param = new DefParam(field, "value");
_sb.AppendLine("void set_" + field.Name + "(" + param.Type.GetCLRParamTypeName(param) + " value);");
}
