diff options
author | dimitri <dimitri@afe2bf4a-e733-0410-8a33-86f594647bc7> | 2001-08-05 12:03:04 (GMT) |
---|---|---|
committer | dimitri <dimitri@afe2bf4a-e733-0410-8a33-86f594647bc7> | 2001-08-05 12:03:04 (GMT) |
commit | 0c6e5ac9eab4ff31bb5650ac2faf9f6c5fc46e68 (patch) | |
tree | ae6f91b471c21991428c9b75a29ff8df55d1889d /src/util.cpp | |
parent | 071e39254b00ad7ffed5de8cdeb44072278d4d57 (diff) | |
download | Doxygen-0c6e5ac9eab4ff31bb5650ac2faf9f6c5fc46e68.zip Doxygen-0c6e5ac9eab4ff31bb5650ac2faf9f6c5fc46e68.tar.gz Doxygen-0c6e5ac9eab4ff31bb5650ac2faf9f6c5fc46e68.tar.bz2 |
Release-1.2.9.1
Diffstat (limited to 'src/util.cpp')
-rw-r--r-- | src/util.cpp | 300 |
1 files changed, 248 insertions, 52 deletions
diff --git a/src/util.cpp b/src/util.cpp index 576e1c1..e766b3f 100644 --- a/src/util.cpp +++ b/src/util.cpp @@ -557,7 +557,7 @@ QCString removeRedundantWhiteSpace(const QCString &s) { result+=" >"; // insert extra space for layouting (nested) templates } - else if (i>0 && i<l-1 && c==',' && isId(s.at(i-1)) && isId(s.at(i+1))) + else if (i>0 && i<l-1 && c==',' && !isspace(s.at(i-1)) && isId(s.at(i+1))) { result+=", "; } @@ -1014,28 +1014,71 @@ int minClassDistance(ClassDef *cd,ClassDef *bcd,int level) //} // strip any template specifiers that follow className in string s -static QCString trimTemplateSpecifiers(const QCString &className,const QCString &s) +static QCString trimTemplateSpecifiers( + const QCString &namespaceName, + const QCString &className, + const QCString &s +) { - //printf("trimTemplateSpecifiers(%s,%s)\n",className.data(),s.data()); - ClassDef *cd=getClass(className); - if (cd==0) return s; + //printf("trimTemplateSpecifiers(%s,%s,%s)\n",namespaceName.data(),className.data(),s.data()); + QCString scopeName=mergeScopes(namespaceName,className); + ClassDef *cd=getClass(scopeName); + if (cd==0) return s; // should not happen, but guard anyway. + QCString result=s; + + int i=className.length()-1; + if (className.at(i)=='>') // template specialization + { + // replace unspecialized occurrences in s, with their specialized versions. + int count=1; + int cl=i+1; + while (i>=0) + { + char c=className.at(i); + if (c=='>') count++,i--; + else if (c=='<') { count--; if (count==0) break; } + else i--; + } + QCString unspecClassName=className.left(i); + int l=i; + int p=0; + while ((i=result.find(unspecClassName,p))!=-1) + { + if (result.at(i+l)!='<') // unspecialized version + { + result=result.left(i)+className+result.right(result.length()-i-l); + l=cl; + } + p=i+l; + } + } + + //printf("result after specialization: %s\n",result.data()); + QCString qualName=cd->qualifiedNameWithTemplateParameters(); //printf("QualifiedName = %s\n",qualName.data()); // We strip the template arguments following className (if any) - QCString result=s; if (!qualName.isEmpty()) // there is a class name { - int i,p=0; - // TODO: also try smaller parts of the qualName, since we - // could be inside a namespace or class. - while ((i=result.find(qualName,p))!=-1) // class name is in the argument type + int is,ps=0; + int p=0,l,i; + + while ((is=getScopeFragment(qualName,ps,&l))!=-1) { - int ql=qualName.length(); - result=result.left(i)+cd->name()+result.right(result.length()-i-ql); - p=i+cd->name().length(); + QCString qualNamePart = qualName.right(qualName.length()-is); + //printf("qualNamePart=%s\n",qualNamePart.data()); + while ((i=result.find(qualNamePart,p))!=-1) + { + int ql=qualNamePart.length(); + result=result.left(i)+cd->name()+result.right(result.length()-i-ql); + p=i+cd->name().length(); + } + ps=is+l; } } + //printf("result=%s\n",result.data()); + return result; } @@ -1203,9 +1246,9 @@ static bool matchArgument(const Argument *srcA,const Argument *dstA, // before matching. This should use className and namespaceName // and usingNamespaces and usingClass to determine which typedefs // are in-scope, so it will not be very efficient :-( - - QCString srcAType=trimTemplateSpecifiers(className,srcA->type); - QCString dstAType=trimTemplateSpecifiers(className,dstA->type); + + QCString srcAType=trimTemplateSpecifiers(namespaceName,className,srcA->type); + QCString dstAType=trimTemplateSpecifiers(namespaceName,className,dstA->type); if (srcAType.left(6)=="class ") srcAType=srcAType.right(srcAType.length()-6); if (dstAType.left(6)=="class ") dstAType=dstAType.right(dstAType.length()-6); @@ -1235,6 +1278,9 @@ static bool matchArgument(const Argument *srcA,const Argument *dstA, stripIrrelevantConstVolatile(srcAType); stripIrrelevantConstVolatile(dstAType); + srcAType = removeRedundantWhiteSpace(srcAType); + dstAType = removeRedundantWhiteSpace(dstAType); + //srcAType=stripTemplateSpecifiersFromScope(srcAType,FALSE); //dstAType=stripTemplateSpecifiersFromScope(dstAType,FALSE); @@ -1446,9 +1492,23 @@ static void mergeArgument(Argument *srcA,Argument *dstA, dstA->type+=dstA->name; dstA->name.resize(0); } + if (srcA->name=="const" || srcA->name=="volatile") + { + srcA->type+=" "; + srcA->type+=srcA->name; + srcA->type=removeRedundantWhiteSpace(srcA->type); + srcA->name.resize(0); + } + if (dstA->name=="const" || dstA->name=="volatile") + { + dstA->type+=" "; + dstA->type+=dstA->name; + dstA->type=removeRedundantWhiteSpace(dstA->type); + dstA->name.resize(0); + } - QCString srcAType=trimTemplateSpecifiers(className,srcA->type); - QCString dstAType=trimTemplateSpecifiers(className,dstA->type); + QCString srcAType=trimTemplateSpecifiers(namespaceName,className,srcA->type); + QCString dstAType=trimTemplateSpecifiers(namespaceName,className,dstA->type); if (srcAType.left(6)=="class ") srcAType=srcAType.right(srcAType.length()-6); if (dstAType.left(6)=="class ") dstAType=dstAType.right(dstAType.length()-6); @@ -1617,10 +1677,16 @@ static void mergeArgument(Argument *srcA,Argument *dstA, if (i>0 && i<(int)srcAType.length()-1 && srcAType.at(i)!=':') // there is (probably) a name { - srcA->name=srcAType.right(srcAType.length()-i-1); - srcA->type=srcAType.left(i+1).stripWhiteSpace(); - dstA->name=dstAType.right(dstAType.length()-i-1); - dstA->type=dstAType.left(i+1).stripWhiteSpace(); + QCString srcAName=srcAType.right(srcAType.length()-i-1); + QCString dstAName=dstAType.right(dstAType.length()-i-1); + if (srcAName!="const" && srcAName!="volatile" && + dstAName!="const" && dstAName!="volatile") + { + srcA->name=srcAName; + srcA->type=srcAType.left(i+1).stripWhiteSpace(); + dstA->name=dstAName; + dstA->type=dstAType.left(i+1).stripWhiteSpace(); + } } } else if (!dstA->name.isEmpty()) @@ -1655,11 +1721,11 @@ bool matchArguments(ArgumentList *srcAl,ArgumentList *dstAl, QCString namespaceName=ns; // strip template specialization from class name if present - int til=className.find('<'),tir=className.find('>'); - if (til!=-1 && tir!=-1 && tir>til) - { - className=className.left(til)+className.right(className.length()-tir-1); - } + //int til=className.find('<'),tir=className.find('>'); + //if (til!=-1 && tir!=-1 && tir>til) + //{ + // className=className.left(til)+className.right(className.length()-tir-1); + //} //printf("matchArguments(%s,%s) className=%s namespaceName=%s checkCV=%d usingNamespaces=%d usingClasses=%d\n", // srcAl ? argListToString(srcAl).data() : "", @@ -2670,24 +2736,22 @@ QCString substituteKeywords(const QCString &s,const char *title) */ int getPrefixIndex(const QCString &name) { - int ni = name.findRev("::"); - if (ni==-1) ni=0; else ni+=2; //printf("getPrefixIndex(%s) ni=%d\n",name.data(),ni); QStrList &sl = Config_getList("IGNORE_PREFIX"); char *s = sl.first(); while (s) { const char *ps=s; - const char *pd=name.data()+ni; + const char *pd=name.data(); int i=0; while (*ps!=0 && *pd!=0 && *ps==*pd) ps++,pd++,i++; if (*ps==0 && *pd!=0) { - return ni+i; + return i; } s = sl.next(); } - return ni; + return 0; } //---------------------------------------------------------------------------- @@ -2868,17 +2932,52 @@ QCString insertTemplateSpecifierInScope(const QCString &scope,const QCString &te return result; } +/*! Strips the scope from a name. Examples: A::B will return A + * and A<T>::B<N::C<D> > will return A<T>. + * \todo deal with cases like A< s<<2 >::B + */ QCString stripScope(const char *name) { QCString result = name; - int ti=result.find('<'); // find start of template - if (ti==-1) ti=result.length(); - int i = ti>2 ? result.findRev("::",ti-2) : -1; // find scope just before template - if (i!=-1) // found scope + int l=result.length(); + int p=l-1; + bool done; + int count; + + while (p>=0) { - result=result.right(result.length()-i-2); + char c=result.at(p); + switch (c) + { + case ':': + //printf("stripScope(%s)=%s\n",name,result.right(l-p-1).data()); + return result.right(l-p-1); + case '>': + count=1; + done=FALSE; + //printf("pos < = %d\n",p); + p--; + while (p>=0 && !done) + { + c=result.at(p--); + switch (c) + { + case '>': count++; break; + case '<': count--; if (count<=0) done=TRUE; break; + default: + //printf("c=%c count=%d\n",c,count); + break; + } + } + //printf("pos > = %d\n",p+1); + break; + default: + p--; + } } - return result; + //printf("stripScope(%s)=%s\n",name,name); + return name; + } /*! Converts a string to an XML-encoded string */ @@ -3015,6 +3114,8 @@ bool extractClassNameFromType(const QCString &type,int &pos,QCString &name,QCStr QCString substituteTemplateArgumentsInString( const QCString &name,ArgumentList *formalArgs,ArgumentList *actualArgs) { + //printf("substituteTemplateArgumentsInString(name=%s formal=%s actualArg=%s)\n", + // name.data(),argListToString(formalArgs).data(),argListToString(actualArgs).data()); if (formalArgs==0) return name; QCString result; static QRegExp re("[a-z_A-Z][a-z_A-Z0-9]*"); @@ -3036,16 +3137,19 @@ QCString substituteTemplateArgumentsInString( ++formAli,actArg=actualArgs->next() ) { - if (formArg->name==n && actArg && !actArg->type.isEmpty()) // base class is a template argument - { - // replace formal argument with the actual argument of the instance - result += actArg->type; - found=TRUE; - } - else if (formArg->name==n && actArg==0 && !formArg->defval.isEmpty()) + if (formArg->type=="class" || formArg->type=="typename") { - result += formArg->defval; - found=TRUE; + if (formArg->name==n && actArg && !actArg->type.isEmpty()) // base class is a template argument + { + // replace formal argument with the actual argument of the instance + result += actArg->type; + found=TRUE; + } + else if (formArg->name==n && actArg==0 && !formArg->defval.isEmpty()) + { + result += formArg->defval; + found=TRUE; + } } } if (!found) result += n; @@ -3109,10 +3213,8 @@ QCString stripTemplateSpecifiersFromScope(const QCString &fullName, int p=0; int l=fullName.length(); int i=fullName.find('<'); - int si= i==-1 ? -1 : fullName.find("::",i); - while (i!=-1 && (!parentOnly || i<si)) + while (i!=-1) { - result+=fullName.mid(p,i-p); //printf("1:result+=%s\n",fullName.mid(p,i-p).data()); int e=i+1; bool done=FALSE; @@ -3130,18 +3232,112 @@ QCString stripTemplateSpecifiersFromScope(const QCString &fullName, done = count==0; } } + int si= fullName.find("::",e); + + if (parentOnly && si==-1) break; + // we only do the parent scope, so we stop here if needed + + result+=fullName.mid(p,i-p); //printf(" trying %s\n",(result+fullName.mid(i,e-i)).data()); - if (getClass(result+fullName.mid(i,e-i))!=0) + if (getClass(result+fullName.mid(i,e-i))!=0) { result+=fullName.mid(i,e-i); //printf("2:result+=%s\n",fullName.mid(i,e-i-1).data()); } p=e; i=fullName.find('<',p); - si= i==-1 ? -1 : fullName.find("::",i); } result+=fullName.right(l-p); //printf("3:result+=%s\n",fullName.right(l-p).data()); return result; } +/*! Merges two scope parts together. The parts may (partially) overlap. + * Example1: \c A::B and \c B::C will result in \c A::B::C <br> + * Example2: \c A and \c B will be \c A::B <br> + * Example3: \c A::B and B will be \c A::B + * + * @param leftScope the left hand part of the scope. + * @param rightScope the right hand part of the scope. + * @returns the merged scope. + */ +QCString mergeScopes(const QCString &leftScope,const QCString &rightScope) +{ + // case leftScope=="A" rightScope=="A::B" => result = "A::B" + if (leftScopeMatch(rightScope,leftScope)) return rightScope; + QCString result; + int i=0,p=leftScope.length(); + + // case leftScope=="A::B" rightScope=="B::C" => result = "A::B::C" + // case leftScope=="A::B" rightScope=="B" => result = "A::B" + bool found=FALSE; + while ((i=leftScope.findRev("::",p))!=-1) + { + if (leftScopeMatch(rightScope,leftScope.right(leftScope.length()-i-2))) + { + result = leftScope.left(i+2)+rightScope; + found=TRUE; + } + p=i-1; + } + if (found) return result; + + // case leftScope=="A" rightScope=="B" => result = "A::B" + result=leftScope.copy(); + if (!result.isEmpty() && !rightScope.isEmpty()) result+="::"; + result+=rightScope; + return result; +} + +/*! Returns a fragment from scope \a s, starting at position \a p. + * + * @param s the scope name as a string. + * @param p the start position (0 is the first). + * @param l the resulting length of the fragment. + * @returns the location of the fragment, or -1 if non is found. + */ +int getScopeFragment(const QCString &s,int p,int *l) +{ + int sl=s.length(); + int sp=p; + int count=0; + bool done; + if (sp>=sl) return -1; + while (sp<sl) + { + char c=s.at(sp); + if (c==':') sp++,p++; else break; + } + while (sp<sl) + { + char c=s.at(sp); + switch (c) + { + case ':': // found next part + goto found; + case '<': // skip template specifier + count=1;sp++; + done=FALSE; + while (sp<sl && !done) + { + // TODO: deal with << and >> operators! + char c=s.at(sp++); + switch(c) + { + case '<': count++; break; + case '>': count--; if (count==0) done=TRUE; break; + default: break; + } + } + break; + default: + sp++; + break; + } + } +found: + *l=sp-p; + //printf("getScopeFragment(%s,%d)=%s\n",s.data(),p,s.mid(p,*l).data()); + return p; +} + |