/// <summary> /// Correctly extract the leaf name. If it is an array, then it might not be what we are expecting here... /// </summary> /// <param name="leaf"></param> /// <returns></returns> private string ExtractVarName(SimpleLeafInfo leaf) { var m = _arrParser.Match(leaf.Title); if (!m.Success) { return(leaf.Name); } return(m.Groups["vname"].Value); }
/// <summary> /// We are going to deal with a template of some sort for a simple item. At the moment we can deal only /// with simple STL's... /// </summary> /// <param name="leaf"></param> /// <param name="templateInfo"></param> /// <returns></returns> private IClassItem ExtractTemplateItem(SimpleLeafInfo leaf, TemplateParser.TemplateInfo templateInfo) { if (templateInfo.TemplateName == "vector") { return(new ItemVector(TemplateParser.TranslateToCSharp(templateInfo), ExtractVarName(leaf).SanitizedName())); } else { throw new NotImplementedException("We rae not able to handle template classes other than vector: '" + templateInfo.TemplateName + "'"); } }
/// <summary> /// This looks like a C style array - that is "[" and "]" are being used, and in the title. Extract the index in it /// and pass it along. /// </summary> /// <param name="leaf"></param> /// <returns></returns> private IClassItem ExtractCArrayInfo(SimpleLeafInfo leaf) { // // Grab the name first. // var m = _arrParser.Match(leaf.Title); if (!m.Success) { return(null); } var vname = m.Groups["vname"].Value; // // Next job is to parse the remaining type into a simple item that we can use... // this allows for "arbitrary" items that are C-style arrays. // var baseItem = ExtractSimpleItem(new SimpleLeafInfo() { Title = vname, Name = vname, TypeName = leaf.TypeName }); // // Great! And then the new type will be whatever the type is of this base item, but indexed... // var tname = baseItem.ItemType; for (int i = 0; i < m.Groups["iname"].Captures.Count; i++) { tname += "[]"; } var arr = new ItemCStyleArray(tname, baseItem); // // Now, loop through and grab all the indicies we can find. // int index = 0; foreach (var indexBound in m.Groups["iname"].Captures.Cast <Capture>()) { index++; var iname = indexBound.Value; bool isConst = iname.All(char.IsDigit); arr.Add(0, iname, isConst); } return(arr); }
private IClassItem ExtractSimpleItem(SimpleLeafInfo leaf) { string className = TypeDefTranslator.ResolveTypedef(leaf.TypeName); // // Check if it is a c-style array. If it is, then the title will contain // the specification we need to look at for the c-style array bit. This will get // called recursively to parse the actual type after the c-style array bit is stripped off. // if (leaf.Title.Contains("[")) { return(ExtractCArrayInfo(leaf)); } // // Next, if the type is a template, special parse that. // var result = TemplateParser.ParseForTemplates(className); if (result is TemplateParser.TemplateInfo) { return(ExtractTemplateItem(leaf, result as TemplateParser.TemplateInfo)); } /// /// Ok - so it is a single "object" or similar. So we need to look at it and figure /// out how to deal with it. It could be a root object or just an "int" /// var ln = NormalizeLeafName(leaf.Name); IClassItem toAdd = null; if (IsROOTClass(className) && className != "string") { toAdd = new ItemROOTClass(ln, className); } else { toAdd = new ItemSimpleType(ln, className.SimpleCPPTypeToCSharpType()); } if (toAdd == null || toAdd.ItemType == null) { throw new InvalidOperationException("Unknown type - can't translate '" + className + "'."); } return(toAdd); }
public SimpleLeafInfo(SimpleLeafInfo old) { Name = old.Name; Title = old.Title; TypeName = old.TypeName; }
/// <summary> /// Correctly extract the leaf name. If it is an array, then it might not be what we are expecting here... /// </summary> /// <param name="leaf"></param> /// <returns></returns> private string ExtractVarName(SimpleLeafInfo leaf) { var m = _arrParser.Match(leaf.Title); if (!m.Success) return leaf.Name; return m.Groups["vname"].Value; }
/// <summary> /// We are going to deal with a template of some sort for a simple item. At the moment we can deal only /// with simple STL's... /// </summary> /// <param name="leaf"></param> /// <param name="templateInfo"></param> /// <returns></returns> private IClassItem ExtractTemplateItem(SimpleLeafInfo leaf, TemplateParser.TemplateInfo templateInfo) { if (templateInfo.TemplateName == "vector") { return new ItemVector(TemplateParser.TranslateToCSharp(templateInfo), ExtractVarName(leaf).SanitizedName()); } else { throw new NotImplementedException("We rae not able to handle template classes other than vector: '" + templateInfo.TemplateName + "'"); } }
/// <summary> /// This looks like a C style array - that is "[" and "]" are being used, and in the title. Extract the index in it /// and pass it along. /// </summary> /// <param name="leaf"></param> /// <returns></returns> private IClassItem ExtractCArrayInfo(SimpleLeafInfo leaf) { // // Grab the name first. // var m = _arrParser.Match(leaf.Title); if (!m.Success) return null; var vname = m.Groups["vname"].Value; // // Next job is to parse the remaining type into a simple item that we can use... // this allows for "arbitrary" items that are C-style arrays. // var baseItem = ExtractSimpleItem(new SimpleLeafInfo() { Title = vname, Name = vname, TypeName = leaf.TypeName }); // // Great! And then the new type will be whatever the type is of this base item, but indexed... // var tname = baseItem.ItemType; for (int i = 0; i < m.Groups["iname"].Captures.Count; i++) { tname += "[]"; } var arr = new ItemCStyleArray(tname, baseItem); // // Now, loop through and grab all the indicies we can find. // int index = 0; foreach (var indexBound in m.Groups["iname"].Captures.Cast<Capture>()) { index++; var iname = indexBound.Value; bool isConst = iname.All(char.IsDigit); arr.Add(0, iname, isConst); } return arr; }
private IClassItem ExtractSimpleItem(SimpleLeafInfo leaf) { string className = TypeDefTranslator.ResolveTypedef(leaf.TypeName); // // Check if it is a c-style array. If it is, then the title will contain // the specification we need to look at for the c-style array bit. This will get // called recursively to parse the actual type after the c-style array bit is stripped off. // if (leaf.Title.Contains("[")) return ExtractCArrayInfo(leaf); // // Next, if the type is a template, special parse that. // var result = TemplateParser.ParseForTemplates(className); if (result is TemplateParser.TemplateInfo) { return ExtractTemplateItem(leaf, result as TemplateParser.TemplateInfo); } /// /// Ok - so it is a single "object" or similar. So we need to look at it and figure /// out how to deal with it. It could be a root object or just an "int" /// var ln = NormalizeLeafName(leaf.Name); IClassItem toAdd = null; if (IsROOTClass(className) && className != "string") { toAdd = new ItemROOTClass(ln, className); } else { toAdd = new ItemSimpleType(ln, className.SimpleCPPTypeToCSharpType()); } if (toAdd == null || toAdd.ItemType == null) { throw new InvalidOperationException("Unknown type - can't translate '" + className + "'."); } return toAdd; }