public static bool IsIteratorWrapper(DefTypeDef type)
{
if (IsTypeNameIteratorWrapper(type.BaseTypeName))
return true;
return false;
}
public static bool IsInternalTypeDef(DefType type)
{
if (!(type is DefTypeDef))
{
return(false);
}
if (type.IsSharedPtr)
{
return(false);
}
DefTypeDef explicitType = (type.IsNested) ? type.ParentClass.FindType <DefTypeDef>(type.Name) : type.NameSpace.FindType <DefTypeDef>(type.Name);
if (explicitType.IsSTLContainer)
{
return(false);
}
if (explicitType.BaseType is DefInternal)
{
return(true);
}
return(false);
}
public static bool IsIteratorWrapper(DefTypeDef type)
{
if (IsTypeNameIteratorWrapper(type.BaseTypeName))
{
return(true);
}
return(false);
}
protected virtual DefType CreateExplicitContainerType(string container, string key, string val)
{
string stdcont = "std::" + container;
XmlDocument doc = new XmlDocument();
XmlElement elem = doc.CreateElement("typedef");
elem.SetAttribute("basetype", stdcont);
elem.SetAttribute("name", stdcont);
XmlElement te = doc.CreateElement("type");
te.InnerText = val;
elem.AppendChild(te);
if (key != "")
{
te = doc.CreateElement("type");
te.InnerText = key;
elem.InsertAfter(te, null);
}
return(DefTypeDef.CreateExplicitType((DefTypeDef)DefType.CreateType(elem)));
}
public static string GetBaseType(DefTypeDef typedef)
{
string baseTypeName = typedef.BaseTypeName;
if (string.IsNullOrEmpty(baseTypeName))
{
return(baseTypeName);
}
int charPos = baseTypeName.IndexOf("<");
string ogreTypeDef = charPos == -1 ? baseTypeName : baseTypeName.Substring(0, charPos);
if (IsStdCollection(ogreTypeDef))
{
return("std::" + ogreTypeDef);
}
if (ogreTypeDef.Equals("HashedVector", StringComparison.Ordinal))
{
return(ogreTypeDef);
}
return(baseTypeName);
}
public void IncAddValueTypeTypeDef(DefTypeDef t, IndentStringBuilder sb)
{
sb.AppendIndent("");
if (t.IsNested)
sb.Append(Producer.GetProtectionString(t.ProtectionType) + ": ");
sb.Append("typedef " + t.BaseType.FullCLRName + " " + t.CLRName + ";\n\n");
}
public void CppAddSTLContainer(DefTypeDef t, IndentStringBuilder sb)
{
if (t is DefStdPair)
{
return;
}
if (t is DefTemplateOneType)
{
if (t.HasAttribute<STLListNoRemoveAndUniqueAttribute>())
{
sb.AppendLine("#undef CPP_STLLIST_DEFINE_REMOVE_AND_UNIQUE");
sb.AppendLine("#define CPP_STLLIST_DEFINE_REMOVE_AND_UNIQUE(PREFIX,CLASS_NAME,M,N)");
sb.AppendLine();
}
sb.AppendLine("#define STLDECL_MANAGEDTYPE " + t.TypeMembers[0].CLRTypeName);
sb.AppendLine("#define STLDECL_NATIVETYPE " + t.TypeMembers[0].NativeTypeName);
CppCheckTypeForDependancy(t.TypeMembers[0].Type);
}
else if (t is DefTemplateTwoTypes)
{
sb.AppendLine("#define STLDECL_MANAGEDKEY " + t.TypeMembers[0].CLRTypeName);
sb.AppendLine("#define STLDECL_MANAGEDVALUE " + t.TypeMembers[1].CLRTypeName);
sb.AppendLine("#define STLDECL_NATIVEKEY " + t.TypeMembers[0].NativeTypeName);
sb.AppendLine("#define STLDECL_NATIVEVALUE " + t.TypeMembers[1].NativeTypeName);
CppCheckTypeForDependancy(t.TypeMembers[0].Type);
CppCheckTypeForDependancy(t.TypeMembers[1].Type);
}
sb.AppendIndent("CPP_DECLARE_STL" + t.STLContainer.ToUpper());
if (t.IsReadOnly)
sb.Append("_READONLY");
string prefix;
if (!t.IsNested)
{
prefix = t.FullNativeName;
prefix = prefix.Substring(0, prefix.LastIndexOf("::"));
}
else
{
prefix = t.ParentClass.FullNativeName;
}
if (prefix.Contains("::"))
prefix = prefix.Substring(prefix.IndexOf("::") + 2) + "::";
else
prefix = "";
sb.Append("( " + prefix + ", " + t.CLRName);
if (t is DefTemplateOneType)
sb.Append(", STLDECL_MANAGEDTYPE, STLDECL_NATIVETYPE )\n");
else if (t is DefTemplateTwoTypes)
sb.Append(", STLDECL_MANAGEDKEY, STLDECL_MANAGEDVALUE, STLDECL_NATIVEKEY, STLDECL_NATIVEVALUE )\n");
else
throw new Exception("Unexpected");
if (t is DefTemplateOneType)
{
sb.AppendLine("#undef STLDECL_MANAGEDTYPE");
sb.AppendLine("#undef STLDECL_NATIVETYPE");
if (t.HasAttribute<STLListNoRemoveAndUniqueAttribute>())
{
sb.AppendLine();
sb.AppendLine("#undef CPP_STLLIST_DEFINE_REMOVE_AND_UNIQUE");
sb.AppendLine("#define CPP_STLLIST_DEFINE_REMOVE_AND_UNIQUE(PREFIX,CLASS_NAME,M,N) CPP_STLLIST_REMOVE_AND_UNIQUE_DEFINITIONS(PREFIX,CLASS_NAME,M,N)");
}
}
else if (t is DefTemplateTwoTypes)
{
sb.AppendLine("#undef STLDECL_MANAGEDKEY");
sb.AppendLine("#undef STLDECL_MANAGEDVALUE");
sb.AppendLine("#undef STLDECL_NATIVEKEY");
sb.AppendLine("#undef STLDECL_NATIVEVALUE");
}
sb.AppendLine();
}
public void IncAddSTLContainer(DefTypeDef t, IndentStringBuilder sb)
{
if (t is DefStdPair)
{
//sb.AppendIndent("");
//if (t.IsNested)
// sb.Append(Producer.GetProtectionString(t.ProtectionType) + ": ");
//sb.Append("typedef " + t.FullSTLContainerTypeName + " " + t.CLRName + ";\n\n");
return;
}
if (!t.IsNested)
{
this.AddPreDeclaration("ref class " + t.CLRName + ";");
this.AddPreDeclaration("ref class Const_" + t.CLRName + ";");
}
if (t is DefTemplateOneType)
{
if (t.HasAttribute<STLListNoRemoveAndUniqueAttribute>())
{
sb.AppendLine("#undef INC_STLLIST_DEFINE_REMOVE_AND_UNIQUE");
sb.AppendLine("#define INC_STLLIST_DEFINE_REMOVE_AND_UNIQUE(M)");
sb.AppendLine();
}
sb.AppendLine("#define STLDECL_MANAGEDTYPE " + t.TypeMembers[0].CLRTypeName);
sb.AppendLine("#define STLDECL_NATIVETYPE " + t.TypeMembers[0].NativeTypeName);
CheckTypeForDependancy(t.TypeMembers[0].Type);
}
else if (t is DefTemplateTwoTypes)
{
sb.AppendLine("#define STLDECL_MANAGEDKEY " + t.TypeMembers[0].CLRTypeName);
sb.AppendLine("#define STLDECL_MANAGEDVALUE " + t.TypeMembers[1].CLRTypeName);
sb.AppendLine("#define STLDECL_NATIVEKEY " + t.TypeMembers[0].NativeTypeName);
sb.AppendLine("#define STLDECL_NATIVEVALUE " + t.TypeMembers[1].NativeTypeName);
CheckTypeForDependancy(t.TypeMembers[0].Type);
CheckTypeForDependancy(t.TypeMembers[1].Type);
}
sb.AppendIndent("");
string publicprot, privateprot;
if (!t.IsNested)
{
publicprot = "public";
privateprot = "private";
}
else
{
publicprot = Producer.GetProtectionString(t.ProtectionType) + ": ";
privateprot = "private:";
sb.Append(publicprot);
}
sb.Append("INC_DECLARE_STL" + t.STLContainer.ToUpper());
if (t.IsReadOnly)
sb.Append("_READONLY");
sb.Append("( " + t.CLRName);
if (t is DefTemplateOneType)
sb.Append(", STLDECL_MANAGEDTYPE, STLDECL_NATIVETYPE, " + publicprot + ", " + privateprot + " )\n");
else if (t is DefTemplateTwoTypes)
sb.Append(", STLDECL_MANAGEDKEY, STLDECL_MANAGEDVALUE, STLDECL_NATIVEKEY, STLDECL_NATIVEVALUE, " + publicprot + ", " + privateprot + " )\n");
else
throw new Exception("Unexpected");
if (t is DefTemplateOneType)
{
sb.AppendLine("#undef STLDECL_MANAGEDTYPE");
sb.AppendLine("#undef STLDECL_NATIVETYPE");
if (t.HasAttribute<STLListNoRemoveAndUniqueAttribute>())
{
sb.AppendLine();
sb.AppendLine("#undef INC_STLLIST_DEFINE_REMOVE_AND_UNIQUE");
sb.AppendLine("#define INC_STLLIST_DEFINE_REMOVE_AND_UNIQUE(M) INC_STLLIST_REMOVE_AND_UNIQUE_DEFINITIONS(M)");
}
}
else if (t is DefTemplateTwoTypes)
{
sb.AppendLine("#undef STLDECL_MANAGEDKEY");
sb.AppendLine("#undef STLDECL_MANAGEDVALUE");
sb.AppendLine("#undef STLDECL_NATIVEKEY");
sb.AppendLine("#undef STLDECL_NATIVEVALUE");
}
sb.AppendLine();
}
//public override string GetCLRTypeName(ITypeMember m)
//{
// switch (m.PassedByType)
// {
// case PassedByType.Reference:
// return ConversionTypeName;
// case PassedByType.PointerPointer:
// case PassedByType.Value:
// case PassedByType.Pointer:
// default:
// throw new Exception("Unexpected");
// }
//}
//public override string GetNativeCallConversion(string expr, ITypeMember m)
//{
// switch (m.PassedByType)
// {
// case PassedByType.Reference:
// return NativeCallConversionFunction + "( " + expr + ")";
// case PassedByType.PointerPointer:
// case PassedByType.Value:
// case PassedByType.Pointer:
// default:
// throw new Exception("Unexpected");
// }
//}
public static new DefTypeDef CreateExplicitType(DefTypeDef typedef)
{
return new DefStdMap(typedef.Element);
}
//public override void GetDefaultParamValueConversion(DefParam param, out string preConversion, out string conversion, out string postConversion)
//{
// preConversion = postConversion = "";
// switch (param.PassedByType)
// {
// case PassedByType.Pointer:
// if (param.IsConst)
// conversion = "nullptr";
// else
// {
// preConversion = "array<" + TypeMembers[0].CLRTypeName + ">^ out_" + param.Name + ";";
// conversion = "out_" + param.Name;
// }
// break;
// default:
// base.GetDefaultParamValueConversion(param, out preConversion, out conversion, out postConversion);
// break;
// }
//}
//public override string GetCLRParamTypeName(DefParam param)
//{
// switch (param.PassedByType)
// {
// case PassedByType.Reference:
// case PassedByType.Pointer:
// if (param.IsConst)
// return "Collections::Generic::List<" + TypeMembers[0].CLRTypeName + ">^";
// else
// return "[Out] array<" + TypeMembers[0].CLRTypeName + ">^%";
// case PassedByType.Value:
// return "Collections::Generic::List<" + TypeMembers[0].CLRTypeName + ">^";
// case PassedByType.PointerPointer:
// default:
// throw new Exception("Unexpected");
// }
//}
//public override string GetPreCallParamConversion(DefParam param, out string newname)
//{
// string expr;
// switch (param.PassedByType)
// {
// case PassedByType.Reference:
// if (param.IsConst)
// {
// expr = FullNativeName + " o_" + param.Name + ";\n";
// expr += "FillListFromGenericList<" + FullNativeName + ", " + TypeMembers[0].CLRTypeName + ">(o_" + param.Name + ", " + param.Name + ");\n";
// newname = "o_" + param.Name;
// return expr;
// }
// else
// {
// newname = "o_" + param.Name;
// return FullNativeName + " o_" + param.Name + ";\n";
// }
// 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 += "\tFillListFromGenericList<" + FullNativeName + ", " + TypeMembers[0].CLRTypeName + ">(o_" + param.Name + ", " + param.Name + ");\n";
// expr += "\tp_" + param.Name + " = &o_" + param.Name + ";\n";
// expr += "}\n";
// newname = "p_" + param.Name;
// return expr;
// }
// else
// {
// newname = "&o_" + param.Name;
// return FullNativeName + " o_" + param.Name + ";\n";
// }
// case PassedByType.Value:
// expr = FullNativeName + " o_" + param.Name + ";\n";
// expr += "FillListFromGenericList<" + FullNativeName + ", " + TypeMembers[0].CLRTypeName + ">(o_" + param.Name + ", " + param.Name + ");\n";
// newname = "o_" + param.Name;
// return expr;
// case PassedByType.PointerPointer:
// default:
// throw new Exception("Unexpected");
// }
//}
//public override string GetPostCallParamConversionCleanup(DefParam param)
//{
// switch (param.PassedByType)
// {
// case PassedByType.Reference:
// case PassedByType.Pointer:
// if (param.IsConst)
// {
// return base.GetPostCallParamConversionCleanup(param);
// }
// else
// {
// return param.Name + " = " + NativeCallConversionFunction + "<" + TypeMembers[0].CLRTypeName + ", " + FullNativeName + ">(o_" + param.Name + ");\n";
// }
// default:
// return base.GetPostCallParamConversionCleanup(param);
// }
//}
//public override string GetCLRTypeName(ITypeMember m)
//{
// if (IsUnnamedSTLContainer)
// {
// switch (m.PassedByType)
// {
// case PassedByType.Value:
// case PassedByType.Pointer:
// case PassedByType.Reference:
// return "array<" + TypeMembers[0].CLRTypeName + ">^";
// case PassedByType.PointerPointer:
// default:
// throw new Exception("Unexpected");
// }
// }
// else
// return base.GetCLRTypeName(m);
//}
//public override string GetNativeCallConversion(string expr, ITypeMember m)
//{
// if (IsUnnamedSTLContainer)
// {
// switch (m.PassedByType)
// {
// case PassedByType.Value:
// case PassedByType.Reference:
// return NativeCallConversionFunction + "<" + TypeMembers[0].CLRTypeName + ", " + FullNativeName + ">( " + expr + " )";
// case PassedByType.Pointer:
// return NativeCallConversionFunction + "<" + TypeMembers[0].CLRTypeName + ", " + FullNativeName + ">( *(" + expr + ") )";
// case PassedByType.PointerPointer:
// default:
// throw new Exception("Unexpected");
// }
// }
// else
// return base.GetNativeCallConversion(expr, m);
//}
public static new DefTypeDef CreateExplicitType(DefTypeDef typedef)
{
switch (typedef.BaseTypeName)
{
case "std::vector":
return DefStdVector.CreateExplicitType(typedef);
case "std::set":
return DefStdSet.CreateExplicitType(typedef);
case "std::deque":
return DefStdDeque.CreateExplicitType(typedef);
case "std::list":
return new DefStdList(typedef.Element);
default:
throw new Exception("Unexpected");
}
}
public static new DefTypeDef CreateExplicitType(DefTypeDef typedef)
{
return new DefIterator(typedef.Element);
}
public static new DefTypeDef CreateExplicitType(DefTypeDef typedef)
{
switch (typedef.BaseTypeName)
{
case "::std::hash_map":
return DefStdHashMap.CreateExplicitType(typedef);
case "std::map":
return DefStdMap.CreateExplicitType(typedef);
case "std::multimap":
return DefStdMultiMap.CreateExplicitType(typedef);
case "std::pair":
return DefStdPair.CreateExplicitType(typedef);
default:
throw new Exception("Unexpected");
}
}
public static new DefTypeDef CreateExplicitType(DefTypeDef typedef)
{
if (typedef.IsSharedPtr)
return DefSharedPtr.CreateExplicitType(typedef);
else if (Producer.IsIteratorWrapper(typedef))
return DefIterator.CreateExplicitType(typedef);
else if (typedef.BaseTypeName.StartsWith("TRect"))
return DefTRect.CreateExplicitType(typedef);
else
return DefStdList.CreateExplicitType(typedef);
}
