Skip to main content

The memberdef.cpp File Reference

Included Headers​

#include <stdio.h> #include <assert.h> #include <mutex> #include "md5.h" #include "memberdef.h" #include "membername.h" #include "doxygen.h" #include "util.h" #include "code.h" #include "message.h" #include "htmlhelp.h" #include "language.h" #include "outputlist.h" #include "example.h" #include "membergroup.h" #include "groupdef.h" #include "defargs.h" #include "docparser.h" #include "dot.h" #include "dotcallgraph.h" #include "searchindex.h" #include "parserintf.h" #include "vhdldocgen.h" #include "arguments.h" #include "memberlist.h" #include "namespacedef.h" #include "moduledef.h" #include "filedef.h" #include "config.h" #include "definitionimpl.h" #include "regex.h" #include "trace.h"

Classes Index​

classMemberDefImpl
classMemberDefAliasImpl

Functions Index​

std::unique_ptr< MemberDef >createMemberDef (const QCString &defFileName, int defLine, int defColumn, const QCString &type, const QCString &name, const QCString &args, const QCString &excp, Protection prot, Specifier virt, bool stat, Relationship related, MemberType t, const ArgumentList &tal, const ArgumentList &al, const QCString &metaData)

Factory method to create a new instance of a MemberDef. More...

std::unique_ptr< MemberDef >createMemberDefAlias (const Definition *newScope, const MemberDef *aliasMd)
static QCStringaddTemplateNames (const QCString &s, const QCString &n, const QCString &t)
static boolwriteDefArgumentList (OutputList &ol, const Definition *scope, const MemberDef *md)
static voidwriteExceptionListImpl (OutputList &ol, const ClassDef *cd, const MemberDef *md, QCString const &exception)
static voidwriteExceptionList (OutputList &ol, const ClassDef *cd, const MemberDef *md)
static QCStringcombineArgsAndException (QCString args, QCString exception)
static QCStringsimplifyTypeForTable (const QCString &s)
static QCStringstripTrailingReturn (const QCString &trailRet)
static voidinvalidateCachedTypesInArgumentList (ArgumentList &al)
static voidtransferArgumentDocumentation (ArgumentList &decAl, ArgumentList &defAl)
voidcombineDeclarationAndDefinition (MemberDefMutable *mdec, MemberDefMutable *mdef)
voidaddDocCrossReference (const MemberDef *s, const MemberDef *d)
MemberDef *toMemberDef (Definition *d)
MemberDef *toMemberDef (DefinitionMutable *md)
const MemberDef *toMemberDef (const Definition *d)
MemberDefMutable *toMemberDefMutable (Definition *d)

Variables Index​

static std::mutexg_cachedAnonymousTypeMutex
static std::mutexg_hasDetailedDescriptionMutex
static const reg::ExreAnonymous(R"([\w:@]*@\d+)")
static std::mutexg_detectUndocumentedParamsMutex
static std::mutexg_docCrossReferenceMutex

Functions​

addDocCrossReference()​

void addDocCrossReference (const MemberDef * s, const MemberDef * d)

Definition at line 6399 of file memberdef.cpp.

6399void addDocCrossReference(const MemberDef *s,const MemberDef *d)
6400{
6401 MemberDefMutable *src = toMemberDefMutable(const_cast<MemberDef*>(s));
6402 MemberDefMutable *dst = toMemberDefMutable(const_cast<MemberDef*>(d));
6403 if (src==nullptr || dst==nullptr) return;
6404 //printf("--> addDocCrossReference src=%s,dst=%s\n",qPrint(src->name()),qPrint(dst->name()));
6405 if (dst->isTypedef() || dst->isEnumerate()) return; // don't add types
6406 if ((dst->hasReferencedByRelation() || dst->hasCallerGraph()) &&
6407 src->isCallable()
6408 )
6409 {
6410 QCString sourceRefName = src->sourceRefName();
6411 MemberDefMutable *mdDef = toMemberDefMutable(dst->memberDefinition());
6412 MemberDefMutable *mdDecl = toMemberDefMutable(dst->memberDeclaration());
6413
6414 // ---- critical section
6415 std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
6416 dst->addSourceReferencedBy(src,sourceRefName);
6417 if (mdDef)
6418 {
6419 mdDef->addSourceReferencedBy(src,sourceRefName);
6420 }
6421 if (mdDecl)
6422 {
6423 mdDecl->addSourceReferencedBy(src,sourceRefName);
6424 }
6425 // ---- end critical section
6426 }
6427 if ((src->hasReferencesRelation() || src->hasCallGraph()) &&
6428 src->isCallable()
6429 )
6430 {
6431 QCString sourceRefName = dst->sourceRefName();
6432 MemberDefMutable *mdDef = toMemberDefMutable(src->memberDefinition());
6433 MemberDefMutable *mdDecl = toMemberDefMutable(src->memberDeclaration());
6434
6435 // ---- critical section
6436 std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
6437 src->addSourceReferences(dst,sourceRefName);
6438 if (mdDef)
6439 {
6440 mdDef->addSourceReferences(dst,sourceRefName);
6441 }
6442 if (mdDecl)
6443 {
6444 mdDecl->addSourceReferences(dst,sourceRefName);
6445 }
6446 // ---- end critical section
6447 }
6448}

References DefinitionMutable::addSourceReferencedBy, DefinitionMutable::addSourceReferences, g_docCrossReferenceMutex, MemberDef::hasCallerGraph, MemberDef::hasCallGraph, MemberDef::hasReferencedByRelation, MemberDef::hasReferencesRelation, MemberDef::isCallable, MemberDef::isEnumerate, MemberDef::isTypedef, MemberDef::memberDeclaration, MemberDef::memberDefinition, MemberDef::sourceRefName and toMemberDefMutable.

Referenced by findMemberLink, generateClassMemberLink, generateClassOrGlobalLink, generateClassOrGlobalLink, getLink, getLinkInScope, getLinkInScope, MemberDefMutable::setFromAnonymousScope and writeObjCMethodCall.

addTemplateNames()​

QCString addTemplateNames (const QCString & s, const QCString & n, const QCString & t)
 static

Definition at line 975 of file memberdef.cpp.

975static QCString addTemplateNames(const QCString &s,const QCString &n,const QCString &t)
976{
977 QCString result;
978 QCString clRealName=n;
979 int p=0,i=0;
980 if ((i=clRealName.find('<'))!=-1)
981 {
982 clRealName=clRealName.left(i); // strip template specialization
983 }
984 if ((i=clRealName.findRev("::"))!=-1)
985 {
986 clRealName=clRealName.right(clRealName.length()-i-2);
987 }
988 while ((i=s.find(clRealName,p))!=-1)
989 {
990 result+=s.mid(p,i-p);
991 size_t j=clRealName.length()+i;
992 if (s.length()==j || (s.at(j)!='<' && !isId(s.at(j))))
993 { // add template names
994 //printf("Adding %s+%s\n",qPrint(clRealName),qPrint(t));
995 result+=clRealName+t;
996 }
997 else
998 { // template names already present
999 //printf("Adding %s\n",qPrint(clRealName));
1000 result+=clRealName;
1001 }
1002 p=i+static_cast<int>(clRealName.length());
1003 }
1004 result+=s.right(s.length()-p);
1005 //printf("addTemplateNames(%s,%s,%s)=%s\n",qPrint(s),qPrint(n),qPrint(t),qPrint(result));
1006 return result;
1007}

References QCString::at, QCString::find, QCString::findRev, isId, QCString::left, QCString::length, QCString::mid and QCString::right.

Referenced by writeDefArgumentList.

combineArgsAndException()​

QCString combineArgsAndException (QCString args, QCString exception)
 static

Definition at line 2199 of file memberdef.cpp.

2199static QCString combineArgsAndException(QCString args,QCString exception)
2200{
2201 if (exception.isEmpty()) return args; // no exception, nothing to combine args
2202 int pos = args.findRev(')');
2203 int eqPos = pos!=-1 ? args.find('=',pos) : -1; // look for '=' in '(args) = something'
2204 if (eqPos==-1) return args+" "+exception; // append exception at the end
2205 return args.left(eqPos)+" "+exception+" "+args.mid(eqPos); // insert exception before =
2206}

References QCString::find, QCString::findRev, QCString::isEmpty, QCString::left and QCString::mid.

Referenced by MemberDefImpl::writeDeclaration.

combineDeclarationAndDefinition()​

void combineDeclarationAndDefinition (MemberDefMutable * mdec, MemberDefMutable * mdef)

Definition at line 6165 of file memberdef.cpp.

6165void combineDeclarationAndDefinition(MemberDefMutable *mdec,MemberDefMutable *mdef)
6166{
6167 AUTO_TRACE("mdec='{}' mdef='{}' mdec.isPrototype={} mdef.isPrototype={}",
6168 mdec->name(), mdef->name(), mdec->isPrototype(), mdef->isPrototype());
6169 if (
6170 (mdef->isFunction() && !mdef->isStatic() && !mdef->isPrototype()) ||
6171 (mdef->isVariable() && !mdef->isExternal() && !mdef->isStatic())
6172 )
6173 {
6174 bool sameNumTemplateArgs = mdef->templateArguments().size()==mdec->templateArguments().size();
6175
6176 ArgumentList &mdefAl = const_cast<ArgumentList&>(mdef->argumentList());
6177 ArgumentList &mdecAl = const_cast<ArgumentList&>(mdec->argumentList());
6178 if (sameNumTemplateArgs &&
6179 matchArguments2(mdef->getOuterScope(),mdef->getFileDef(),&mdefAl,
6180 mdec->getOuterScope(),mdec->getFileDef(),&mdecAl,
6181 TRUE,mdef->getLanguage()
6182 )
6183 ) /* match found */
6184 {
6185 AUTO_TRACE_ADD("combining definition and declaration");
6186
6187 if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
6188 {
6189 mdec->resolveUnnamedParameters(mdef);
6190 }
6191
6192 // first merge argument documentation
6193 transferArgumentDocumentation(mdecAl,mdefAl);
6194
6195 /* copy documentation between function definition and declaration */
6196 if (!mdec->briefDescription().isEmpty())
6197 {
6198 mdef->setBriefDescription(mdec->briefDescription(),mdec->briefFile(),mdec->briefLine());
6199 }
6200 else if (!mdef->briefDescription().isEmpty())
6201 {
6202 mdec->setBriefDescription(mdef->briefDescription(),mdef->briefFile(),mdef->briefLine());
6203 }
6204 if (!mdef->documentation().isEmpty())
6205 {
6206 //printf("transferring docs mdef->mdec (%s->%s)\n",mdef->argsString(),mdec->argsString());
6207 mdec->setDocumentation(mdef->documentation(),mdef->docFile(),mdef->docLine());
6208 mdec->setDocsForDefinition(mdef->isDocsForDefinition());
6209 if (mdefAl.hasParameters())
6210 {
6211 auto mdefAlComb = stringToArgumentList(mdef->getLanguage(),mdef->argsString());
6212 transferArgumentDocumentation(mdefAl,*mdefAlComb);
6213 mdec->moveArgumentList(std::move(mdefAlComb));
6214 }
6215 }
6216 else if (!mdec->documentation().isEmpty())
6217 {
6218 //printf("transferring docs mdec->mdef (%s->%s)\n",mdec->argsString(),mdef->argsString());
6219 mdef->setDocumentation(mdec->documentation(),mdec->docFile(),mdec->docLine());
6220 mdef->setDocsForDefinition(mdec->isDocsForDefinition());
6221 if (mdecAl.hasParameters())
6222 {
6223 auto mdecAlComb = stringToArgumentList(mdec->getLanguage(),mdec->argsString());
6224 transferArgumentDocumentation(mdecAl,*mdecAlComb);
6225 mdef->moveDeclArgumentList(std::move(mdecAlComb));
6226 }
6227 }
6228 if (!mdef->inbodyDocumentation().isEmpty())
6229 {
6230 mdec->setInbodyDocumentation(mdef->inbodyDocumentation(),mdef->inbodyFile(),mdef->inbodyLine());
6231 }
6232 else if (!mdec->inbodyDocumentation().isEmpty())
6233 {
6234 mdef->setInbodyDocumentation(mdec->inbodyDocumentation(),mdec->inbodyFile(),mdec->inbodyLine());
6235 }
6236 if (mdec->getStartBodyLine()!=-1 && mdef->getStartBodyLine()==-1)
6237 {
6238 //printf("body mdec->mdef %d-%d\n",mdec->getStartBodyLine(),mdef->getEndBodyLine());
6239 mdef->setBodySegment(mdec->getDefLine(),mdec->getStartBodyLine(),mdec->getEndBodyLine());
6240 mdef->setBodyDef(mdec->getBodyDef());
6241 //mdef->setBodyMember(mdec);
6242 }
6243 else if (mdef->getStartBodyLine()!=-1 && mdec->getStartBodyLine()==-1)
6244 {
6245 //printf("body mdef->mdec %d-%d\n",mdef->getStartBodyLine(),mdec->getEndBodyLine());
6246 mdec->setBodySegment(mdef->getDefLine(),mdef->getStartBodyLine(),mdef->getEndBodyLine());
6247 mdec->setBodyDef(mdef->getBodyDef());
6248 //mdec->setBodyMember(mdef);
6249 }
6250 mdec->mergeMemberSpecifiers(mdef->getMemberSpecifiers());
6251 mdef->mergeMemberSpecifiers(mdec->getMemberSpecifiers());
6252
6253 // copy group info.
6254 if (mdec->getGroupDef()==nullptr && mdef->getGroupDef()!=nullptr)
6255 {
6256 mdec->setGroupDef(mdef->getGroupDef(),
6257 mdef->getGroupPri(),
6258 mdef->docFile(),
6259 mdef->docLine(),
6260 mdef->hasDocumentation(),
6261 mdef
6262 );
6263 }
6264 else if (mdef->getGroupDef()==nullptr && mdec->getGroupDef()!=nullptr)
6265 {
6266 mdef->setGroupDef(mdec->getGroupDef(),
6267 mdec->getGroupPri(),
6268 mdec->docFile(),
6269 mdec->docLine(),
6270 mdec->hasDocumentation(),
6271 mdec
6272 );
6273 }
6274
6275
6276 mdec->mergeRefItems(mdef);
6277 mdef->mergeRefItems(mdec);
6278
6279 mdef->setMemberDeclaration(mdec);
6280 mdec->setMemberDefinition(mdef);
6281
6282 mergeMemberOverrideOptions(mdec,mdef);
6283
6284 mdef->addQualifiers(mdec->getQualifiers());
6285 mdec->addQualifiers(mdef->getQualifiers());
6286 }
6287 }
6288}

References MemberDefMutable::addQualifiers, MemberDef::argsString, MemberDef::argumentList, AUTO_TRACE, AUTO_TRACE_ADD, Definition::briefDescription, Definition::briefFile, Definition::briefLine, Config_getBool, Definition::docFile, Definition::docLine, Definition::documentation, Definition::getBodyDef, Definition::getDefLine, Definition::getEndBodyLine, MemberDef::getFileDef, MemberDef::getGroupDef, MemberDef::getGroupPri, Definition::getLanguage, MemberDef::getMemberSpecifiers, Definition::getOuterScope, MemberDef::getQualifiers, Definition::getStartBodyLine, Definition::hasDocumentation, ArgumentList::hasParameters, Definition::inbodyDocumentation, Definition::inbodyFile, Definition::inbodyLine, MemberDef::isDocsForDefinition, QCString::isEmpty, MemberDef::isExternal, MemberDef::isFunction, MemberDef::isPrototype, MemberDef::isStatic, MemberDef::isVariable, matchArguments2, mergeMemberOverrideOptions, MemberDefMutable::mergeMemberSpecifiers, DefinitionMutable::mergeRefItems, MemberDefMutable::moveArgumentList, MemberDefMutable::moveDeclArgumentList, Definition::name, MemberDefMutable::resolveUnnamedParameters, DefinitionMutable::setBodyDef, DefinitionMutable::setBodySegment, DefinitionMutable::setBriefDescription, MemberDefMutable::setDocsForDefinition, DefinitionMutable::setDocumentation, MemberDefMutable::setGroupDef, DefinitionMutable::setInbodyDocumentation, MemberDefMutable::setMemberDeclaration, MemberDefMutable::setMemberDefinition, ArgumentList::size, stringToArgumentList, MemberDef::templateArguments, transferArgumentDocumentation and TRUE.

Referenced by ClassDefImpl::mergeCategory, MemberDefMutable::setFromAnonymousScope and transferFunctionDocumentation.

createMemberDef()​

std::unique_ptr< MemberDef > createMemberDef (const QCString & defFileName, int defLine, int defColumn, const QCString & type, const QCString & name, const QCString & args, const QCString & excp, Protection prot, Specifier virt, bool stat, Relationship related, MemberType t, const ArgumentList & tal, const ArgumentList & al, const QCString & metaData)

Factory method to create a new instance of a MemberDef.

Definition at line 516 of file memberdef.cpp.

516std::unique_ptr<MemberDef> createMemberDef(const QCString &defFileName,int defLine,int defColumn,
517 const QCString &type,const QCString &name,const QCString &args,
518 const QCString &excp,Protection prot,Specifier virt,bool stat,
519 Relationship related,MemberType t,const ArgumentList &tal,
520 const ArgumentList &al,const QCString &metaData)
521{
522 return std::make_unique<MemberDefImpl>(defFileName,defLine,defColumn,type,name,args,excp,prot,virt,
523 stat,related,t,tal,al,metaData);
524}

Referenced by addEnumValuesToEnums, addGlobalFunction, addInstance, addInterfaceOrServiceToServiceOrSingleton, addLocalObjCMethod, addMemberSpecialization, addMethodToClass, addOverloaded, addVariableToClass, addVariableToFile, buildDefineList, createTagLessInstance, MemberDefImpl::createTemplateInstanceMember, createUsingMemberImportForClass, findDefineDocumentation, findEnums, findMember, findUsingDeclImports and MemberDefMutable::setFromAnonymousScope.

createMemberDefAlias()​

std::unique_ptr< MemberDef > createMemberDefAlias (const Definition * newScope, const MemberDef * aliasMd)

Definition at line 966 of file memberdef.cpp.

966std::unique_ptr<MemberDef> createMemberDefAlias(const Definition *newScope,const MemberDef *aliasMd)
967{
968 auto amd = std::make_unique<MemberDefAliasImpl>(newScope,aliasMd);
969 //printf("amd: name=%s displayName=%s\n",qPrint(amd->name()),qPrint(amd->displayName()));
970 return amd;
971}

Referenced by MemberDefAliasImpl::deepCopy, findUsingDeclImports, NamespaceDefImpl::insertMember, insertMemberAlias and MemberDefMutable::setFromAnonymousScope.

invalidateCachedTypesInArgumentList()​

void invalidateCachedTypesInArgumentList (ArgumentList & al)
 static

Definition at line 6102 of file memberdef.cpp.

6102static void invalidateCachedTypesInArgumentList(ArgumentList &al)
6103{
6104 for (Argument &a : al)
6105 {
6106 a.canType.clear();
6107 }
6108}

Referenced by MemberDefImpl::invalidateCachedArgumentTypes.

simplifyTypeForTable()​

QCString simplifyTypeForTable (const QCString & s)
 static

Definition at line 3922 of file memberdef.cpp.

3922static QCString simplifyTypeForTable(const QCString &s)
3923{
3924 QCString ts=removeAnonymousScopes(s);
3925 if (ts.endsWith("::")) ts = ts.left(ts.length()-2);
3926 static const reg::Ex re1(R"(\a\w*::)"); // non-template version
3927 static const reg::Ex re2(R"(\a\w*<[^>]*>::)"); // template version
3928 reg::Match match;
3929 std::string t = ts.str();
3930 while (reg::search(t,match,re2) || reg::search(t,match,re1))
3931 {
3932 t = match.prefix().str() + match.suffix().str(); // remove the matched part
3933 }
3934 //printf("simplifyTypeForTable(%s)->%s\n",qPrint(s),t.c_str());
3935 return QCString(t);
3936}

References QCString::endsWith, QCString::left, QCString::length, removeAnonymousScopes, reg::search and QCString::str.

Referenced by MemberDefImpl::fieldType.

stripTrailingReturn()​

QCString stripTrailingReturn (const QCString & trailRet)
 static

Definition at line 4169 of file memberdef.cpp.

4169static QCString stripTrailingReturn(const QCString &trailRet)
4170{
4171 QCString ret = trailRet;
4172
4173 ret = ret.stripWhiteSpace();
4174 if (ret.startsWith("->"))
4175 {
4176 ret = ret.mid(2).stripWhiteSpace();
4177 return ret;
4178 }
4179 return trailRet;
4180}

References QCString::mid, QCString::startsWith and QCString::stripWhiteSpace.

Referenced by MemberDefImpl::warnIfUndocumentedParams.

toMemberDef()​

MemberDef * toMemberDef (Definition * d)

Definition at line 6452 of file memberdef.cpp.

6452MemberDef *toMemberDef(Definition *d)
6453{
6454 if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
6455 {
6456 return static_cast<MemberDef*>(d);
6457 }
6458 else
6459 {
6460 return nullptr;
6461 }
6462}

Referenced by codeFolding, DefinitionImpl::computeTooltip, definitionToName, DocRef::DocRef, dumpSymbol, findMemberLink, findUsingDeclImports, generateClassOrGlobalLink, getDefsNew, MemberDefAliasImpl::getMdAlias, MemberDefAliasImpl::getMdAlias, getMemberFromSymbol, SymbolResolver::Private::getResolvedSymbol, SymbolResolver::Private::getResolvedType, getSQLDocBlock, SymbolResolver::Private::isAccessibleFrom, SymbolResolver::Private::isAccessibleFromWithExpScope, DocParser::processCopyDoc, SymbolResolver::resolveSymbol, resolveUserReferences, SearchIndex::setCurrentDoc, SearchIndexExternal::setCurrentDoc, MemberDefMutable::setFromAnonymousScope, SymbolResolver::Private::substTypedef, DefinitionImpl::writeInlineCode, writeJavasScriptSearchDataPage, writeObjCMethodCall, DefinitionImpl::writeToc and TooltipManager::writeTooltips.

toMemberDef()​

MemberDef * toMemberDef (DefinitionMutable * md)

Definition at line 6464 of file memberdef.cpp.

6464MemberDef *toMemberDef(DefinitionMutable *md)
6465{
6466 Definition *d = toDefinition(md);
6467 if (d && typeid(*d)==typeid(MemberDefImpl))
6468 {
6469 return static_cast<MemberDef*>(d);
6470 }
6471 else
6472 {
6473 return nullptr;
6474 }
6475}

Reference toDefinition.

toMemberDef()​

const MemberDef * toMemberDef (const Definition * d)

Definition at line 6477 of file memberdef.cpp.

6477const MemberDef *toMemberDef(const Definition *d)
6478{
6479 if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
6480 {
6481 return static_cast<const MemberDef*>(d);
6482 }
6483 else
6484 {
6485 return nullptr;
6486 }
6487}

toMemberDefMutable()​

MemberDefMutable * toMemberDefMutable (Definition * d)

Definition at line 6489 of file memberdef.cpp.

6489MemberDefMutable *toMemberDefMutable(Definition *d)
6490{
6491 if (d && typeid(*d)==typeid(MemberDefImpl))
6492 {
6493 return static_cast<MemberDefMutable*>(d);
6494 }
6495 else
6496 {
6497 return nullptr;
6498 }
6499}

Referenced by addDocCrossReference, addEnumValuesToEnums, addGlobalFunction, addInstance, addInterfaceOrServiceToServiceOrSingleton, MemberList::addListReferences, addLocalObjCMethod, addMemberFunction, addMemberSpecialization, addMembersToMemberGroup, addMemberToGroups, ClassDefImpl::addMemberToList, FileDefImpl::addMemberToList, ModuleDefImpl::addMemberToList, NamespaceDefImpl::addMemberToList, ModuleDefImpl::addMemberToModule, ModuleManager::addMemberToModule, ClassDefImpl::addMemberToTemplateInstance, addMethodToClass, addOverloaded, addVariableToClass, addVariableToFile, buildDefineList, buildFunctionList, buildTypedefList, computeMemberRelationsForBaseClass, createTagLessInstance, MemberDefImpl::createTemplateInstanceMember, createUsingMemberImportForClass, ClassDefImpl::deepCopy, MemberGroup::distributeMemberGroupDocumentation, findDefineDocumentation, findDEV, findEnumDocumentation, findEnums, findFriends, findGlobalMember, findMember, MemberList::findSectionsInDocumentation, findUsingDeclImports, flushCachedTemplateRelations, flushUnresolvedRelations, generateClassMemberLink, generateClassOrGlobalLink, getLinkInScope, ClassDefImpl::hideDerivedVariablesInPython, incrementFlowKeyWordCount, incrementFlowKeyWordCount, inheritDocumentation, GroupDefImpl::insertMember, MemberGroup::insertMember, NamespaceDefImpl::insertMember, MemberDefImpl::insertReimplementedBy, ClassDefImpl::mergeCategory, SymbolResolver::Private::newResolveTypedef, processTagLessClasses, MemberList::setAnchors, MemberList::setAnonymousEnumType, MemberDefMutable::setFromAnonymousScope, ClassDefImpl::setGroupDefForAllMembers, transferFunctionDocumentation, transferFunctionReferences, transferRelatedFunctionDocumentation, transferStaticInstanceInitializers, tryAddEnumDocsToGroupMember, vhdlCorrectMemberProperties, MemberDefImpl::writeDeclaration, MemberList::writeDocumentation, MemberList::writeDocumentationPage, VhdlDocGen::writePlainVHDLDeclarations, MemberList::writeSimpleDocumentation, VhdlDocGen::writeSource and MemberList::writeTagFile.

transferArgumentDocumentation()​

void transferArgumentDocumentation (ArgumentList & decAl, ArgumentList & defAl)
 static

Definition at line 6135 of file memberdef.cpp.

6135static void transferArgumentDocumentation(ArgumentList &decAl,ArgumentList &defAl)
6136{
6137 for (auto decIt = decAl.begin(), defIt = defAl.begin();
6138 decIt!= decAl.end() && defIt!= defAl.end();
6139 ++decIt, ++defIt)
6140 {
6141 Argument &decA = *decIt;
6142 Argument &defA = *defIt;
6143 if (decA.docs.isEmpty() && !defA.docs.isEmpty())
6144 {
6145 decA.docs = defA.docs;
6146 }
6147 else if (defA.docs.isEmpty() && !decA.docs.isEmpty())
6148 {
6149 defA.docs = decA.docs;
6150 }
6151 if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
6152 {
6153 if (decA.name.isEmpty() && !defA.name.isEmpty())
6154 {
6155 decA.name = defA.name;
6156 }
6157 else if (defA.name.isEmpty() && !decA.name.isEmpty())
6158 {
6159 defA.name = decA.name;
6160 }
6161 }
6162 }
6163}

References ArgumentList::begin, Config_getBool, Argument::docs, ArgumentList::end, QCString::isEmpty and Argument::name.

Referenced by combineDeclarationAndDefinition.

writeDefArgumentList()​

bool writeDefArgumentList (OutputList & ol, const Definition * scope, const MemberDef * md)
 static

Definition at line 1048 of file memberdef.cpp.

1048static bool writeDefArgumentList(OutputList &ol,const Definition *scope,const MemberDef *md)
1049{
1050 const ArgumentList &defArgList=(md->isDocsForDefinition()) ?
1051 md->argumentList() : md->declArgumentList();
1052 //printf("writeDefArgumentList '%s' isDocsForDefinition()=%d hasParameters()=%d (%s)\n",
1053 // qPrint(md->name()),md->isDocsForDefinition(),defArgList.hasParameters(),qPrint(argListToString(defArgList)));
1054 if (!defArgList.hasParameters() || md->isProperty() || md->isTypedef())
1055 {
1056 return FALSE; // member has no function like argument list
1057 }
1058
1059 bool isDefine = md->isDefine();
1060 if (!isDefine) ol.docify(" ");
1061
1062 //printf("writeDefArgList(%d)\n",defArgList->count());
1063 ol.endMemberDocName();
1064 ol.startParameterList(!md->isObjCMethod());
1065 //printf("===> name=%s isDefine=%d\n",qPrint(md->name()),md->isDefine());
1066
1067 QCString cName;
1068 if (scope)
1069 {
1070 cName=scope->name();
1071 int il=cName.find('<');
1072 int ir=cName.findRev('>');
1073 if (il!=-1 && ir!=-1 && ir>il)
1074 {
1075 cName=cName.mid(il,ir-il+1);
1076 //printf("1. cName=%s\n",qPrint(cName));
1077 }
1078 else if (scope->definitionType()==Definition::TypeClass)
1079 {
1080 cName=tempArgListToString((toClassDef(scope))->templateArguments(),
1081 scope->getLanguage());
1082 //printf("2. cName=%s\n",qPrint(cName));
1083 }
1084 else // no template specifier
1085 {
1086 cName.clear();
1087 }
1088 }
1089 //printf("~~~ %s cName=%s\n",qPrint(md->name()),qPrint(cName));
1090
1091 QCString sep = getLanguageSpecificSeparator(md->getLanguage(),true);
1092
1093 bool first=TRUE;
1094 bool paramTypeStarted=FALSE;
1095 auto alIt = defArgList.begin();
1096 while (alIt!=defArgList.end())
1097 {
1098 Argument a = *alIt;
1099 if (isDefine || first)
1100 {
1101 ol.startParameterType(first,QCString());
1102 paramTypeStarted=true;
1103 if (isDefine)
1104 {
1105 ol.endParameterType();
1106 ol.startParameterName(TRUE);
1107 }
1108 }
1109
1110 if (!a.attrib.isEmpty() && !md->isObjCMethod()) // argument has an IDL attribute
1111 {
1112 ol.docify(a.attrib+" ");
1113 }
1114
1115 QCString atype = a.type;
1116 if (sep!="::") { atype=substitute(atype,"::",sep); }
1117
1118 int funcPtrPos=-1;
1119 {
1120 if (md->isObjCMethod()) { atype.prepend("("); atype.append(")"); }
1121 if (atype!="...")
1122 {
1123 if (!cName.isEmpty() && scope && scope!=Doxygen::globalScope)
1124 {
1125 atype=addTemplateNames(atype,scope->name(),cName);
1126 }
1127 funcPtrPos = atype.find("*)(");
1128 if (funcPtrPos!=-1) funcPtrPos++;
1129 linkifyText(TextGeneratorOLImpl(ol),scope,md->getBodyDef(),md,
1130 funcPtrPos==-1 ? atype : atype.left(funcPtrPos));
1131 }
1132 }
1133
1134 if (!isDefine)
1135 {
1136 if (paramTypeStarted)
1137 {
1138 ol.endParameterType();
1139 paramTypeStarted=FALSE;
1140 }
1141 ol.startParameterName(defArgList.size()<2);
1142 }
1143 else
1144 {
1145 ol.endParameterName();
1146 }
1147
1148 if (atype=="...")
1149 {
1150 ol.docify(atype);
1151 }
1152 else if (!a.name.isEmpty()) // argument has a name
1153 {
1154 ol.docify(a.name);
1155 }
1156 if (!isDefine)
1157 {
1158 if (funcPtrPos!=-1)
1159 {
1160 ol.writeNonBreakableSpace(1);
1161 }
1162 ol.endParameterName();
1163 }
1164 ol.startParameterExtra();
1165 if (funcPtrPos!=-1)
1166 {
1167 linkifyText(TextGeneratorOLImpl(ol),scope,md->getBodyDef(),md,
1168 atype.mid(funcPtrPos));
1169 }
1170 if (!a.array.isEmpty())
1171 {
1172 ol.docify(a.array);
1173 }
1174 if (!a.defval.isEmpty()) // write the default value
1175 {
1176 QCString n=a.defval;
1177 if (scope && scope!=Doxygen::globalScope && !cName.isEmpty())
1178 {
1179 n=addTemplateNames(n,scope->name(),cName);
1180 }
1181 ol.startParameterDefVal(" = ");
1182 linkifyText(TextGeneratorOLImpl(ol),scope,md->getBodyDef(),md,n,FALSE,TRUE,TRUE);
1183 ol.endParameterDefVal();
1184 }
1185 ++alIt;
1186 if (alIt!=defArgList.end())
1187 {
1188 a = *alIt;
1189 if (!md->isObjCMethod()) ol.docify(", "); // there are more arguments
1190 if (!isDefine)
1191 {
1192 QCString key;
1193 if (md->isObjCMethod() && a.attrib.length()>=2)
1194 {
1195 //printf("Found parameter keyword %s\n",a.qPrint(attrib));
1196 // strip [ and ]
1197 key=a.attrib.mid(1,a.attrib.length()-2);
1198 if (key!=",") key+=":"; // for normal keywords add colon
1199 }
1200 ol.endParameterExtra(false,false,!md->isObjCMethod());
1201 ol.startParameterType(FALSE,key);
1202 paramTypeStarted=TRUE;
1203 }
1204 else // isDefine
1205 {
1206 ol.endParameterExtra(false,false,true);
1207 }
1208 }
1209 first=FALSE;
1210 }
1211 if (first)
1212 {
1213 ol.startParameterName(defArgList.size()<2);
1214 ol.endParameterName();
1215 ol.startParameterExtra();
1216 }
1217 ol.endParameterExtra(TRUE,defArgList.size()<2,!md->isObjCMethod());
1218 if (!md->extraTypeChars().isEmpty())
1219 {
1220 ol.docify(md->extraTypeChars());
1221 }
1222 if (defArgList.constSpecifier())
1223 {
1224 ol.docify(" const");
1225 }
1226 if (defArgList.volatileSpecifier())
1227 {
1228 ol.docify(" volatile");
1229 }
1230 if (defArgList.refQualifier()==RefQualifierType::LValue)
1231 {
1232 ol.docify(" &");
1233 }
1234 else if (defArgList.refQualifier()==RefQualifierType::RValue)
1235 {
1236 ol.docify(" &&");
1237 }
1238 if (!defArgList.trailingReturnType().isEmpty())
1239 {
1240 linkifyText(TextGeneratorOLImpl(ol), // out
1241 scope, // scope
1242 md->getBodyDef(), // fileScope
1243 md, // self
1244 defArgList.trailingReturnType(), // text
1245 FALSE // autoBreak
1246 );
1247
1248 }
1249 return TRUE;
1250}

References addTemplateNames, QCString::append, MemberDef::argumentList, Argument::array, Argument::attrib, ArgumentList::begin, QCString::clear, ArgumentList::constSpecifier, MemberDef::declArgumentList, Definition::definitionType, Argument::defval, OutputList::docify, ArgumentList::end, OutputList::endMemberDocName, OutputList::endParameterDefVal, OutputList::endParameterExtra, OutputList::endParameterName, OutputList::endParameterType, MemberDef::extraTypeChars, FALSE, QCString::find, QCString::findRev, Definition::getBodyDef, Definition::getLanguage, getLanguageSpecificSeparator, Doxygen::globalScope, ArgumentList::hasParameters, MemberDef::isDefine, MemberDef::isDocsForDefinition, QCString::isEmpty, MemberDef::isObjCMethod, MemberDef::isProperty, MemberDef::isTypedef, QCString::left, QCString::length, linkifyText, LValue, QCString::mid, Argument::name, Definition::name, QCString::prepend, ArgumentList::refQualifier, RValue, ArgumentList::size, OutputList::startParameterDefVal, OutputList::startParameterExtra, OutputList::startParameterList, OutputList::startParameterName, OutputList::startParameterType, substitute, tempArgListToString, toClassDef, ArgumentList::trailingReturnType, TRUE, Argument::type, Definition::TypeClass, ArgumentList::volatileSpecifier and OutputList::writeNonBreakableSpace.

Referenced by MemberDefImpl::writeDocumentation.

writeExceptionList()​

void writeExceptionList (OutputList & ol, const ClassDef * cd, const MemberDef * md)
 static

Definition at line 1291 of file memberdef.cpp.

1291static void writeExceptionList(OutputList &ol, const ClassDef *cd, const MemberDef *md)
1292{
1293 QCString exception(QCString(md->excpString()).stripWhiteSpace());
1294 if ('{'==exception.at(0))
1295 {
1296 // this is an UNO IDL attribute - need special handling
1297 int index = exception.find(';');
1298 int oldIndex = 1;
1299 while (-1 != index) // there should be no more than 2 (set / get)
1300 {
1301 // omit '{' and ';' -> "set raises (...)"
1302 writeExceptionListImpl(ol,cd,md,exception.mid(oldIndex,index-oldIndex));
1303 oldIndex=index+1;
1304 index = exception.find(';',oldIndex);
1305 }
1306 // the rest is now just '}' - omit that
1307 }
1308 else
1309 {
1310 writeExceptionListImpl(ol,cd,md,exception);
1311 }
1312}

References QCString::at, MemberDef::excpString, QCString::find, QCString::mid, QCString::stripWhiteSpace and writeExceptionListImpl.

Referenced by MemberDefImpl::writeDocumentation.

writeExceptionListImpl()​

void writeExceptionListImpl (OutputList & ol, const ClassDef * cd, const MemberDef * md, QCString const & exception)
 static

Definition at line 1252 of file memberdef.cpp.

1252static void writeExceptionListImpl(
1253 OutputList &ol, const ClassDef *cd, const MemberDef *md, QCString const& exception)
1254{
1255 // this is ordinary exception spec - there must be a '('
1256 //printf("exception='%s'\n",qPrint(exception));
1257 int index = exception.find('(');
1258 if (index!=-1)
1259 {
1260 ol.exceptionEntry(exception.left(index),false);
1261 ++index; // paren in second column so skip it here
1262 for (int comma = exception.find(',', index); comma!=-1; )
1263 {
1264 ++comma; // include comma
1265 linkifyText(TextGeneratorOLImpl(ol),cd,md->getBodyDef(),md,
1266 exception.mid(index,comma-index));
1267 ol.exceptionEntry(QCString(),false);
1268 index=comma;
1269 comma = exception.find(',', index);
1270 }
1271 int close = exception.find(')', index);
1272 if (close!=-1)
1273 {
1274 QCString type=removeRedundantWhiteSpace(exception.mid(index,close-index));
1275 linkifyText(TextGeneratorOLImpl(ol),cd,md->getBodyDef(),md,type);
1276 ol.exceptionEntry(QCString(),true);
1277 }
1278 else
1279 {
1280 warn(md->getDefFileName(),md->getDefLine(),
1281 "missing ) in exception list on member {}",md->name());
1282 }
1283 }
1284 else // Java Exception
1285 {
1286 ol.docify(" ");
1287 linkifyText(TextGeneratorOLImpl(ol),cd,md->getBodyDef(),md,exception);
1288 }
1289}

References OutputList::docify, OutputList::exceptionEntry, QCString::find, Definition::getBodyDef, Definition::getDefFileName, Definition::getDefLine, QCString::left, linkifyText, QCString::mid, Definition::name, removeRedundantWhiteSpace and warn.

Referenced by writeExceptionList.

Variables​

g_cachedAnonymousTypeMutex​

std::mutex g_cachedAnonymousTypeMutex
 static

Definition at line 1967 of file memberdef.cpp.

1967static std::mutex g_cachedAnonymousTypeMutex;

Referenced by MemberDefImpl::getClassDefOfAnonymousType.

g_detectUndocumentedParamsMutex​

std::mutex g_detectUndocumentedParamsMutex
 static

Definition at line 4182 of file memberdef.cpp.

4182static std::mutex g_detectUndocumentedParamsMutex;

Referenced by MemberDefImpl::detectUndocumentedParams.

g_docCrossReferenceMutex​

std::mutex g_docCrossReferenceMutex
 static

Definition at line 6397 of file memberdef.cpp.

6397static std::mutex g_docCrossReferenceMutex;

Referenced by addDocCrossReference.

g_hasDetailedDescriptionMutex​

std::mutex g_hasDetailedDescriptionMutex
 static

Definition at line 2654 of file memberdef.cpp.

2654static std::mutex g_hasDetailedDescriptionMutex;

Referenced by MemberDefImpl::hasDetailedDescription.

reAnonymous​

const reg::Ex reAnonymous(R"([\w:@]*@\d+)")
 static

Definition at line 3286 of file memberdef.cpp.

Referenced by MemberDefImpl::displayDefinition and MemberDefImpl::writeDocumentation.

Generated via doxygen2docusaurus by Doxygen 1.14.0.