public TypeLookup.Item GetCTSTypdef(string name, Element element)
{
try
{
TypeLookup.Item i = TypeDefs.FindType(name, element.GenFile, element.Id, element.ParentID, element.PackageId);
return(i);
}
catch (Exception)
{
Debugger.Break();
}
return(null);
}
public CTSType GetCTSType(string inp, Element element)
{
CTSType.CallingType callingType;
string collectionType = "";
bool isOptional = false;
foreach (var a in inp.Split(new char[] { ':', '<', '>' }))
{
switch (a)
{
case "":
case "std":
case "ext":
case "boost":
continue;
case "vector":
switch (collectionType)
{
case "":
collectionType = "Vector";
continue;
case "Vector":
collectionType = "Matrix";
continue;
case "Matrix":
collectionType = "Cube";
continue;
default:
continue;
}
case "Handle":
callingType = CTSType.CallingType.HandleReference;
continue;
case "&":
callingType = CTSType.CallingType.Reference;
continue;
case "*":
callingType = CTSType.CallingType.Pointer;
continue;
case "optional":
callingType = CTSType.CallingType.Value;
isOptional = true;
continue;
case "shared_ptr":
callingType = CTSType.CallingType.BoostReference;
continue;
}
}
const string CUBE = "std::vector<std::vector<std::vector<";
const string MATRIX = "std::vector<std::vector<";
const string VECTOR = "std::vector<";
// convert traditional C++ to C++/CLI
if (inp == null)
{
inp = "";
}
string buff = inp.Replace("\n", "").Replace("> > >", ">>>").Replace("> >", ">>").Replace(" const", "").Replace("const ", "").Replace(" ", "");
// strip reference and pointer typs
if (buff.Contains("boost::shared_ptr"))
{
if (buff.EndsWith("&"))
{
buff = buff.Substring(0, buff.Length - 1);
}
buff = StripType(buff, "boost::shared_ptr");
callingType = CTSType.CallingType.BoostReference;
}
else if (buff.EndsWith("&") && buff.Contains("Handle"))
{
buff = StripType(buff.Substring(0, buff.Length - 1), "Handle");
callingType = CTSType.CallingType.HandleReference;
}
else if (buff.EndsWith("&"))
{
buff = buff.Substring(0, buff.Length - 1);
callingType = CTSType.CallingType.Reference;
}
else if (buff.EndsWith("*"))
{
buff = buff.Substring(0, buff.Length - 1);
callingType = CTSType.CallingType.Pointer;
}
else if (buff.Contains("boost::optional"))
{
buff = StripType(buff, "boost::optional");
callingType = CTSType.CallingType.Value;
isOptional = true;
}
else
{
callingType = CTSType.CallingType.Value;
}
buff = StripType(StripType(buff, "Handle"), "boost::shared_ptr").Replace("enum ", "").Replace("\n", "").Replace("\t", "");
if (buff.StartsWith(CUBE))
{
buff = inp.Substring(CUBE.Length, buff.Length - CUBE.Length - 3);
collectionType = "Cube";
}
else if (buff.StartsWith(MATRIX))
{
buff = inp.Substring(MATRIX.Length, buff.Length - MATRIX.Length - 2);
collectionType = "Matrix";
}
else if (buff.StartsWith(VECTOR))
{
buff = buff.Substring(VECTOR.Length, buff.Length - VECTOR.Length - 1);
collectionType = "Vector";
}
// strip any contained boost pointer
buff = StripType(StripType(StripType(buff, "std::boost::shared_ptr"), "Handle"), "boost::shared_ptr");
// if the inner object is a simple value type
string ctsBuff = CTSTypeDict[buff];
if (ctsBuff != buff)
{
return(new CTSType(ctsBuff, inp.Replace(buff, CTSTypeDict.GetNative(buff)), CTSType.FeatureType.Value, callingType, collectionType, isOptional));
}
else
{
TypeLookup.Item i = EnumDefs.FindType(buff, element.GenFile, element.Id, element.ParentID, element.PackageId);
if (i != null)
{
return(new CTSType(i.Definition, i.NativeDefinition, CTSType.FeatureType.Enum, callingType, collectionType, isOptional));
}
else
{
TypeLookup.Item lookup = GetCTSTypdef(buff, element);
if (lookup != null)
{
string new_inp = inp.Replace(lookup.Name, lookup.NativeDefinition);
return(GetCTSType(new_inp, element));
}
return(new CTSType(buff, inp, CTSType.FeatureType.Object, callingType, collectionType, isOptional));
}
}
}
