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