public CodeTemplateParameter GetTemplateParByReAssignToName(string searchName) { int j = templatePars.Count; for (int i = 0; i < j; ++i) { CodeTemplateParameter tp = templatePars[i]; if (tp.ReAssignToTypeName == searchName) { return(tp); //found } } //not found return(null); }
public TemplateParameterTypeSymbol(CodeTemplateParameter templatePar) { this.templatePar = templatePar; this.TemplateParameterName = templatePar.ParameterName; this.NewName = templatePar.ParameterKind; }
public bool TryGetTemplateParByReAssignToName(string searchName, out CodeTemplateParameter found) { return((found = GetTemplateParByReAssignToName(searchName)) != null); }
public void AddTemplateParameter(CodeTemplateParameter par) { templatePars.Add(par); }
public TypeSymbol ResolveType(CodeTypeReference typeRef) { if (typeRef.ResolvedType != null) { return(typeRef.ResolvedType); } //recursive switch (typeRef.Kind) { case CodeTypeReferenceKind.Simple: { var simpleBase = (CodeSimpleTypeReference)typeRef; return(typeRef.ResolvedType = ResolveType(simpleBase.Name)); } case CodeTypeReferenceKind.QualifiedName: { var qnameType = (CodeQualifiedNameType)typeRef; switch (qnameType.LeftPart.ToString()) { //resolve wellknown type template case "std": return(ResolveType(qnameType.RightPart)); default: { if (_currentResolvingType != null && _currentResolvingType.TemplateNotation != null) { //search ns from template notation CodeTemplateParameter foundTemplatePar = null; if (_currentResolvingType.TemplateNotation.TryGetTemplateParByParameterName(qnameType.LeftPart.ToString(), out foundTemplatePar)) { //TODO: resolve template type parameter return(typeRef.ResolvedType = new TemplateParameterTypeSymbol(foundTemplatePar)); } } //-- TypeSymbol found; if (_typeCollection.TryGetType(typeRef.ToString(), out found)) { return(found); } throw new NotSupportedException(); } } } case CodeTypeReferenceKind.TypeTemplate: { //resolve wellknown type template var typeTemplate = (CodeTypeTemplateTypeReference)typeRef; string templateName = typeTemplate.Name; //this version => just switch by name first //TODO: switch by num of template item switch (typeTemplate.Name) { default: throw new NotSupportedException(); case "CefOwnPtr": case "CefStructBase": { TypeSymbol resolve1 = ResolveType(typeTemplate.Items[0]); TemplateTypeSymbol1 t1 = new TemplateTypeSymbol1(typeTemplate.Name); t1.Item0 = resolve1; return(typeRef.ResolvedType = t1); } case "multimap": case "map": { TemplateTypeSymbol2 t2 = new TemplateTypeSymbol2(typeTemplate.Name); t2.Item0 = ResolveType(typeTemplate.Items[0]); t2.Item1 = ResolveType(typeTemplate.Items[1]); return(typeRef.ResolvedType = t2); } case "CefCppToCScoped": case "CefCppToCRefCounted": { //cpp to c if (typeTemplate.Items.Count == 3) { //auto add native c/c++ type TemplateTypeSymbol3 t3 = new TemplateTypeSymbol3(typeTemplate.Name); t3.Item1 = ResolveType(typeTemplate.Items[1]); t3.Item2 = this._typeCollection.RegisterBaseCToCppTypeSymbol(typeTemplate.Items[2]); return(typeRef.ResolvedType = t3); } else { throw new NotSupportedException(); } } case "CefCToCppScoped": case "CefCToCppRefCounted": case "CefCToCpp": { //c to cpp if (typeTemplate.Items.Count == 3) { //auto add native c/c++ type TemplateTypeSymbol3 t3 = new TemplateTypeSymbol3(typeTemplate.Name); t3.Item1 = ResolveType(typeTemplate.Items[1]); t3.Item2 = this._typeCollection.RegisterBaseCToCppTypeSymbol(typeTemplate.Items[2]); return(typeRef.ResolvedType = t3); } else { throw new NotSupportedException(); } } case "RefCountedThreadSafe": { switch (typeTemplate.Items.Count) { case 1: return(typeRef.ResolvedType = ResolveType(typeTemplate.Items[0])); case 2: // from cef c api , //template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T> > return(typeRef.ResolvedType = ResolveType(typeTemplate.Items[0])); default: throw new NotSupportedException(); } } case "CefRefPtr": { if (typeTemplate.Items.Count == 1) { return(typeRef.ResolvedType = new ReferenceOrPointerTypeSymbol(ResolveType(typeTemplate.Items[0]), ContainerTypeKind.CefRefPtr)); } throw new NotSupportedException(); } case "CefRawPtr": { if (typeTemplate.Items.Count == 1) { return(typeRef.ResolvedType = new ReferenceOrPointerTypeSymbol(ResolveType(typeTemplate.Items[0]), ContainerTypeKind.CefRawPtr)); } throw new NotSupportedException(); } case "scoped_ptr": { if (typeTemplate.Items.Count == 1) { return(typeRef.ResolvedType = new ReferenceOrPointerTypeSymbol(ResolveType(typeTemplate.Items[0]), ContainerTypeKind.scoped_ptr)); } else { throw new NotSupportedException(); } } case "vector": { if (typeTemplate.Items.Count == 1) { return(typeRef.ResolvedType = new VecTypeSymbol(ResolveType(typeTemplate.Items[0]))); } else { throw new NotSupportedException(); } } } } case CodeTypeReferenceKind.Pointer: { var pointerType = (CodePointerTypeReference)typeRef; TypeSymbol elementType = ResolveType(pointerType.ElementType); return(typeRef.ResolvedType = new ReferenceOrPointerTypeSymbol(elementType, ContainerTypeKind.Pointer)); } case CodeTypeReferenceKind.ByRef: { var byRefType = (CodeByRefTypeReference)typeRef; TypeSymbol elementType = ResolveType(byRefType.ElementType); return(typeRef.ResolvedType = new ReferenceOrPointerTypeSymbol(elementType, ContainerTypeKind.ByRef)); } default: { throw new NotSupportedException(); } } }
TypeSymbol ResolveType(string typename) { TypeSymbol foundSymbol = null; if (_currentResolvingType != null) { //1. if (_currentResolvingType.IsTemplateTypeDefinition) { // //check if this is the template type parameter //if (typename == _currentResolvingType.TemplateNotation.templatePar.ReAssignToTypeName) //{ //found // return new TemplateParameterTypeSymbol(_currentResolvingType.TemplateNotation.templatePar); //} CodeTemplateParameter foundTemplatePar = null; if (_currentResolvingType.TemplateNotation.TryGetTemplateParByReAssignToName(typename, out foundTemplatePar)) { //TODO: resolve template type parameter return(new TemplateParameterTypeSymbol(foundTemplatePar)); } if (_currentResolvingType.TemplateNotation.TryGetTemplateParByParameterName(typename, out foundTemplatePar)) { //TODO: resolve template type parameter return(new TemplateParameterTypeSymbol(foundTemplatePar)); } } //2. //search nest type //TODO: review here -> use field if (_currentResolvingType.HasSubType) { List <CodeMemberDeclaration> tempResults = new List <CodeMemberDeclaration>(); int foundCount; if ((foundCount = _currentResolvingType.FindSubType(typename, tempResults)) > 0) { for (int i = 0; i < foundCount; ++i) { CodeMemberDeclaration subtype = tempResults[i]; switch (subtype.MemberKind) { default: throw new NotSupportedException(); case CodeMemberKind.Type: break; case CodeMemberKind.TypeDef: { CodeCTypeDef ctypedef = (CodeCTypeDef)subtype; TypeSymbol resolveFromType = ResolveType(ctypedef.From); if (resolveFromType != null) { //found return(resolveFromType); } } break; } } } } //3 if (_currentResolvingType.BaseTypes != null) { //check if we need to search in other scopes int baseCount = _currentResolvingType.BaseTypes.Count; //we get only 1 base count if (baseCount > 0) { if ((foundSymbol = SearchFromFirstBase(_currentResolvingType.BaseTypes[0] as CodeTypeTemplateTypeReference, typename)) != null) { return(foundSymbol); } } } } //------- if (this._typeCollection.TryGetType(typename, out foundSymbol)) { return(foundSymbol); } //this is convention if (typename.StartsWith("cef_") && IsAllLowerLetter(typename)) { //assume this is base c/cpp type foundSymbol = new SimpleTypeSymbol(typename); this._typeCollection.RegisterType( typename, foundSymbol); return(foundSymbol); } //not found return(foundSymbol); }