memberdef.cpp File Reference

#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"

Include dependency graph for memberdef.cpp:

Go to the source code of this file.

Classes
class	MemberDefImpl
class	MemberDefAliasImpl

Functions
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.
std::unique_ptr< MemberDef >	createMemberDefAlias (const Definition *newScope, const MemberDef *aliasMd)
static QCString	addTemplateNames (const QCString &s, const QCString &n, const QCString &t)
static bool	writeDefArgumentList (OutputList &ol, const Definition *scope, const MemberDef *md)
static void	writeExceptionListImpl (OutputList &ol, const ClassDef *cd, const MemberDef *md, QCString const &exception)
static void	writeExceptionList (OutputList &ol, const ClassDef *cd, const MemberDef *md)
static QCString	combineArgsAndException (QCString args, QCString exception)
static QCString	simplifyTypeForTable (const QCString &s)
static QCString	stripTrailingReturn (const QCString &trailRet)
static void	invalidateCachedTypesInArgumentList (ArgumentList &al)
static void	transferArgumentDocumentation (ArgumentList &decAl, ArgumentList &defAl)
void	combineDeclarationAndDefinition (MemberDefMutable *mdec, MemberDefMutable *mdef)
void	addDocCrossReference (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
static std::mutex	g_cachedAnonymousTypeMutex
static std::mutex	g_hasDetailedDescriptionMutex
static const reg::Ex	reAnonymous (R"([\w:@]*@\d+)")
static std::mutex	g_detectUndocumentedParamsMutex
static std::mutex	g_docCrossReferenceMutex

Function Documentation

addDocCrossReference()

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

Definition at line 6495 of file memberdef.cpp.

{
  MemberDefMutable *src = toMemberDefMutable(const_cast<MemberDef*>(s));
  MemberDefMutable *dst = toMemberDefMutable(const_cast<MemberDef*>(d));
  if (src==nullptr || dst==nullptr) return;
  //printf("--> addDocCrossReference src=%s,dst=%s\n",qPrint(src->name()),qPrint(dst->name()));
  if (dst->isTypedef() || dst->isEnumerate()) return; // don't add types
  if ((dst->hasReferencedByRelation() || dst->hasCallerGraph()) &&
      src->isCallable()
     )
  {
    QCString sourceRefName = src->sourceRefName();
    MemberDefMutable *mdDef = toMemberDefMutable(dst->memberDefinition());
    MemberDefMutable *mdDecl = toMemberDefMutable(dst->memberDeclaration());
 
    // ---- critical section
    std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
    dst->addSourceReferencedBy(src,sourceRefName);
    if (mdDef)
    {
      mdDef->addSourceReferencedBy(src,sourceRefName);
    }
    if (mdDecl)
    {
      mdDecl->addSourceReferencedBy(src,sourceRefName);
    }
    // ---- end critical section
  }
  if ((src->hasReferencesRelation() || src->hasCallGraph()) &&
      src->isCallable()
     )
  {
    QCString sourceRefName = dst->sourceRefName();
    MemberDefMutable *mdDef = toMemberDefMutable(src->memberDefinition());
    MemberDefMutable *mdDecl = toMemberDefMutable(src->memberDeclaration());
 
    // ---- critical section
    std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
    src->addSourceReferences(dst,sourceRefName);
    if (mdDef)
    {
      mdDef->addSourceReferences(dst,sourceRefName);
    }
    if (mdDecl)
    {
      mdDecl->addSourceReferences(dst,sourceRefName);
    }
    // ---- end critical section
  }
}

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 989 of file memberdef.cpp.

{
  QCString result;
  QCString clRealName=n;
  int p=0,i=0;
  if ((i=clRealName.find('<'))!=-1)
  {
    clRealName=clRealName.left(i); // strip template specialization
  }
  if ((i=clRealName.findRev("::"))!=-1)
  {
    clRealName=clRealName.right(clRealName.length()-i-2);
  }
  while ((i=s.find(clRealName,p))!=-1)
  {
    result+=s.mid(p,i-p);
    size_t j=clRealName.length()+i;
    if (s.length()==j || (s.at(j)!='<' && !isId(s.at(j))))
    { // add template names
      //printf("Adding %s+%s\n",qPrint(clRealName),qPrint(t));
      result+=clRealName+t;
    }
    else
    { // template names already present
      //printf("Adding %s\n",qPrint(clRealName));
      result+=clRealName;
    }
    p=i+static_cast<int>(clRealName.length());
  }
  result+=s.right(s.length()-p);
  //printf("addTemplateNames(%s,%s,%s)=%s\n",qPrint(s),qPrint(n),qPrint(t),qPrint(result));
  return result;
}

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 2213 of file memberdef.cpp.

{
  if (exception.isEmpty()) return args;                      // no exception, nothing to combine args
  int pos   = args.findRev(')');
  int eqPos = pos!=-1 ? args.find('=',pos) : -1;             // look for '=' in '(args) = something'
  if (eqPos==-1) return args+" "+exception;                  // append exception at the end
  return args.left(eqPos)+" "+exception+" "+args.mid(eqPos); // insert exception before =
}

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 6220 of file memberdef.cpp.

{
  AUTO_TRACE("mdec='{}' mdef='{}' mdec.isPrototype={} mdef.isPrototype={}",
              mdec->name(), mdef->name(), mdec->isPrototype(), mdef->isPrototype());
  if (
      (!mdef->isDocTransferDone() || !mdec->isDocTransferDone()) &&
      (
       (mdef->isFunction() && !mdef->isStatic() && !mdef->isPrototype()) ||
       (mdef->isVariable() && !mdef->isExternal() && !mdef->isStatic())
      )
     )
  {
    bool sameNumTemplateArgs = mdef->templateArguments().size()==mdec->templateArguments().size();
 
    ArgumentList &mdefAl = const_cast<ArgumentList&>(mdef->argumentList());
    ArgumentList &mdecAl = const_cast<ArgumentList&>(mdec->argumentList());
    if (sameNumTemplateArgs &&
        matchArguments2(mdef->getOuterScope(),mdef->getFileDef(),mdef->typeString(),&mdefAl,
                        mdec->getOuterScope(),mdec->getFileDef(),mdec->typeString(),&mdecAl,
                        TRUE,mdef->getLanguage()
                       )
       ) /* match found */
    {
      AUTO_TRACE_ADD("combining definition and declaration");
 
      if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
      {
        mdec->resolveUnnamedParameters(mdef);
      }
 
      // first merge argument documentation
      transferArgumentDocumentation(mdecAl,mdefAl);
 
      // copy brief description between definition and declaration
      QCString mdefBrief     = mdef->briefDescription();
      QCString mdecBrief     = mdec->briefDescription();
      QCString mdefBriefFile = mdef->briefFile();
      QCString mdecBriefFile = mdec->briefFile();
      int mdefBriefLine      = mdef->briefLine();
      int mdecBriefLine      = mdec->briefLine();
      if (!mdef->isDocTransferDone() && !mdecBrief.isEmpty())
      {
        mdef->setBriefDescription(mdecBrief,mdecBriefFile,mdecBriefLine);
      }
      if (!mdec->isDocTransferDone() && !mdefBrief.isEmpty())
      {
        mdec->setBriefDescription(mdefBrief,mdefBriefFile,mdefBriefLine);
      }
 
      // copy detailed description between definition and declaration
      QCString mdefDocs   = mdef->documentation();
      QCString mdecDocs   = mdec->documentation();
      QCString mdefFile   = mdef->docFile();
      QCString mdecFile   = mdec->docFile();
      int mdefLine        = mdef->docLine();
      int mdecLine        = mdec->docLine();
      bool mdefDocsForDef = mdef->isDocsForDefinition();
      bool mdecDocsForDef = mdec->isDocsForDefinition();
      if (!mdec->isDocTransferDone() && !mdefDocs.isEmpty())
      {
        //printf("transferring docs mdef->mdec (%s->%s)\n",mdef->argsString(),mdec->argsString());
        mdec->setDocumentation(mdefDocs,mdefFile,mdefLine);
        mdec->setDocsForDefinition(mdefDocsForDef);
        if (mdefAl.hasParameters())
        {
          auto mdefAlComb = stringToArgumentList(mdef->getLanguage(),mdef->argsString());
          transferArgumentDocumentation(mdefAl,*mdefAlComb);
          mdec->moveArgumentList(std::move(mdefAlComb));
        }
      }
      if (!mdef->isDocTransferDone() && !mdecDocs.isEmpty())
      {
        //printf("transferring docs mdec->mdef (%s->%s)\n",mdec->argsString(),mdef->argsString());
        mdef->setDocumentation(mdecDocs,mdecFile,mdecLine);
        mdef->setDocsForDefinition(mdecDocsForDef);
        if (mdecAl.hasParameters())
        {
          auto mdecAlComb = stringToArgumentList(mdec->getLanguage(),mdec->argsString());
          transferArgumentDocumentation(mdecAl,*mdecAlComb);
          mdef->moveDeclArgumentList(std::move(mdecAlComb));
        }
      }
 
      // copy inbody documentation between definition and declaration
      QCString mdefInbodyDocs = mdef->inbodyDocumentation();
      QCString mdecInbodyDocs = mdec->inbodyDocumentation();
      QCString mdefInbodyFile = mdef->inbodyFile();
      QCString mdecInbodyFile = mdec->inbodyFile();
      int mdefInbodyLine      = mdef->inbodyLine();
      int mdecInbodyLine      = mdec->inbodyLine();
      if (!mdec->isDocTransferDone() && !mdefInbodyDocs.isEmpty())
      {
        mdec->setInbodyDocumentation(mdefInbodyDocs,mdefInbodyFile,mdefInbodyLine);
      }
      if (!mdef->isDocTransferDone() && !mdecInbodyDocs.isEmpty())
      {
        mdef->setInbodyDocumentation(mdecInbodyDocs,mdecInbodyFile,mdecInbodyLine);
      }
 
      if (mdec->getStartBodyLine()!=-1 && mdef->getStartBodyLine()==-1)
      {
        //printf("body mdec->mdef %d-%d\n",mdec->getStartBodyLine(),mdef->getEndBodyLine());
        mdef->setBodySegment(mdec->getDefLine(),mdec->getStartBodyLine(),mdec->getEndBodyLine());
        mdef->setBodyDef(mdec->getBodyDef());
        //mdef->setBodyMember(mdec);
      }
      else if (mdef->getStartBodyLine()!=-1 && mdec->getStartBodyLine()==-1)
      {
        //printf("body mdef->mdec %d-%d\n",mdef->getStartBodyLine(),mdec->getEndBodyLine());
        mdec->setBodySegment(mdef->getDefLine(),mdef->getStartBodyLine(),mdef->getEndBodyLine());
        mdec->setBodyDef(mdef->getBodyDef());
        //mdec->setBodyMember(mdef);
      }
      mdec->mergeMemberSpecifiers(mdef->getMemberSpecifiers());
      mdef->mergeMemberSpecifiers(mdec->getMemberSpecifiers());
 
      // copy group info.
      if (mdec->getGroupDef()==nullptr && mdef->getGroupDef()!=nullptr)
      {
        mdec->setGroupDef(mdef->getGroupDef(),
            mdef->getGroupPri(),
            mdef->docFile(),
            mdef->docLine(),
            mdef->hasDocumentation(),
            mdef
            );
      }
      else if (mdef->getGroupDef()==nullptr && mdec->getGroupDef()!=nullptr)
      {
        mdef->setGroupDef(mdec->getGroupDef(),
            mdec->getGroupPri(),
            mdec->docFile(),
            mdec->docLine(),
            mdec->hasDocumentation(),
            mdec
            );
      }
 
 
      mdec->mergeRefItems(mdef);
      mdef->mergeRefItems(mdec);
 
      mdef->setMemberDeclaration(mdec);
      mdec->setMemberDefinition(mdef);
 
      mergeMemberOverrideOptions(mdec,mdef);
 
      mdef->addQualifiers(mdec->getQualifiers());
      mdec->addQualifiers(mdef->getQualifiers());
 
      mdef->setDocTransferDone();
      mdec->setDocTransferDone();
    }
  }
}

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(), MemberDef::isDocTransferDone(), 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(), MemberDefMutable::setDocTransferDone(), DefinitionMutable::setDocumentation(), MemberDefMutable::setGroupDef(), DefinitionMutable::setInbodyDocumentation(), MemberDefMutable::setMemberDeclaration(), MemberDefMutable::setMemberDefinition(), ArgumentList::size(), stringToArgumentList(), MemberDef::templateArguments(), transferArgumentDocumentation(), TRUE, and MemberDef::typeString().

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 524 of file memberdef.cpp.

{
  return std::make_unique<MemberDefImpl>(defFileName,defLine,defColumn,type,name,args,excp,prot,virt,
                           stat,related,t,tal,al,metaData);
}

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 980 of file memberdef.cpp.

{
  auto amd = std::make_unique<MemberDefAliasImpl>(newScope,aliasMd);
  //printf("amd: name=%s displayName=%s\n",qPrint(amd->name()),qPrint(amd->displayName()));
  return amd;
}

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

invalidateCachedTypesInArgumentList()

void invalidateCachedTypesInArgumentList ( ArgumentList & al )

static

Definition at line 6156 of file memberdef.cpp.

{
  for (Argument &a : al)
  {
    a.canType.clear();
  }
}

Referenced by MemberDefImpl::invalidateCachedArgumentTypes().

simplifyTypeForTable()

QCString simplifyTypeForTable ( const QCString & s )

static

Definition at line 3958 of file memberdef.cpp.

{
  QCString ts=removeAnonymousScopes(s);
  if (ts.endsWith("::")) ts = ts.left(ts.length()-2);
  static const reg::Ex re1(R"(\a\w*::)");       // non-template version
  static const reg::Ex re2(R"(\a\w*<[^>]*>::)"); // template version
  reg::Match match;
  std::string t = ts.str();
  while (reg::search(t,match,re2) || reg::search(t,match,re1))
  {
    t = match.prefix().str() + match.suffix().str(); // remove the matched part
  }
  //printf("simplifyTypeForTable(%s)->%s\n",qPrint(s),qPrint(t));
  return t;
}

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 4205 of file memberdef.cpp.

{
  QCString ret = trailRet;
 
  ret = ret.stripWhiteSpace();
  if (ret.startsWith("->"))
  {
    ret = ret.mid(2).stripWhiteSpace();
    return ret;
  }
  return trailRet;
}

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

Referenced by MemberDefImpl::warnIfUndocumentedParams().

toMemberDef() [1/3]

const MemberDef * toMemberDef

(

const Definition *

d

)

Definition at line 6573 of file memberdef.cpp.

{
  if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
  {
    return static_cast<const MemberDef*>(d);
  }
  else
  {
    return nullptr;
  }
}

toMemberDef() [2/3]

MemberDef * toMemberDef

(

Definition *

d

)

Definition at line 6548 of file memberdef.cpp.

{
  if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
  {
    return static_cast<MemberDef*>(d);
  }
  else
  {
    return nullptr;
  }
}

Referenced by codeFolding(), DefinitionImpl::computeTooltip(), definitionToName(), DocRef::DocRef(), dumpSymbol(), findMemberLink(), findUsingDeclImports(), generateClassOrGlobalLink(), RequirementManager::generatePage(), getDefs(), 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() [3/3]

MemberDef * toMemberDef

(

DefinitionMutable *

md

)

Definition at line 6560 of file memberdef.cpp.

{
  Definition *d = toDefinition(md);
  if (d && typeid(*d)==typeid(MemberDefImpl))
  {
    return static_cast<MemberDef*>(d);
  }
  else
  {
    return nullptr;
  }
}

References toDefinition().

toMemberDefMutable()

MemberDefMutable * toMemberDefMutable

(

Definition *

d

)

Definition at line 6585 of file memberdef.cpp.

{
  if (d && typeid(*d)==typeid(MemberDefImpl))
  {
    return static_cast<MemberDefMutable*>(d);
  }
  else
  {
    return nullptr;
  }
}

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(), MemberList::addRequirementReferences(), 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 6189 of file memberdef.cpp.

{
  for (auto decIt = decAl.begin(), defIt = defAl.begin();
            decIt!= decAl.end() && defIt!= defAl.end();
          ++decIt,               ++defIt)
  {
    Argument &decA = *decIt;
    Argument &defA = *defIt;
    if (decA.docs.isEmpty() && !defA.docs.isEmpty())
    {
      decA.docs = defA.docs;
    }
    else if (defA.docs.isEmpty() && !decA.docs.isEmpty())
    {
      defA.docs = decA.docs;
    }
    //printf("transferArgumentDocumentation(%s<->%s)\n",qPrint(decA.name),qPrint(defA.name));
    if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
    {
      if (decA.name.isEmpty() && !defA.name.isEmpty())
      {
        decA.name = defA.name;
      }
      else if (defA.name.isEmpty() && !decA.name.isEmpty())
      {
        defA.name = decA.name;
      }
    }
  }
}

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 1062 of file memberdef.cpp.

{
  const ArgumentList &defArgList=(md->isDocsForDefinition()) ?
                             md->argumentList() : md->declArgumentList();
  //printf("writeDefArgumentList '%s' isDocsForDefinition()=%d hasParameters()=%d (%s)\n",
  //    qPrint(md->name()),md->isDocsForDefinition(),defArgList.hasParameters(),qPrint(argListToString(defArgList)));
  if (!defArgList.hasParameters() || md->isProperty() || md->isTypedef())
  {
    return FALSE; // member has no function like argument list
  }
 
  bool isDefine = md->isDefine();
  if (!isDefine) ol.docify(" ");
 
  //printf("writeDefArgList(%d)\n",defArgList->count());
  ol.endMemberDocName();
  ol.startParameterList(!md->isObjCMethod());
  //printf("===> name=%s isDefine=%d\n",qPrint(md->name()),md->isDefine());
 
  QCString cName;
  if (scope)
  {
    cName=scope->name();
    int il=cName.find('<');
    int ir=cName.findRev('>');
    if (il!=-1 && ir!=-1 && ir>il)
    {
      cName=cName.mid(il,ir-il+1);
      //printf("1. cName=%s\n",qPrint(cName));
    }
    else if (scope->definitionType()==Definition::TypeClass)
    {
      cName=tempArgListToString((toClassDef(scope))->templateArguments(),
                             scope->getLanguage());
      //printf("2. cName=%s\n",qPrint(cName));
    }
    else // no template specifier
    {
      cName.clear();
    }
  }
  //printf("~~~ %s cName=%s\n",qPrint(md->name()),qPrint(cName));
 
  QCString sep = getLanguageSpecificSeparator(md->getLanguage(),true);
 
  LinkifyTextOptions options;
  options.setScope(scope).setFileScope(md->getBodyDef()).setSelf(md);
 
  bool first=TRUE;
  bool paramTypeStarted=FALSE;
  auto alIt = defArgList.begin();
  while (alIt!=defArgList.end())
  {
    Argument a = *alIt;
    if (isDefine || first)
    {
      ol.startParameterType(first,QCString());
      paramTypeStarted=true;
      if (isDefine)
      {
        ol.endParameterType();
        ol.startParameterName(TRUE);
      }
    }
 
    if (!a.attrib.isEmpty() && !md->isObjCMethod()) // argument has an IDL attribute
    {
      ol.docify(a.attrib+" ");
    }
 
    QCString atype = a.type;
    if (sep!="::") { atype=substitute(atype,"::",sep); }
 
    int funcPtrPos=-1;
    {
      if (md->isObjCMethod()) { atype.prepend("("); atype.append(")"); }
      if (atype!="...")
      {
        if (!cName.isEmpty() && scope && scope!=Doxygen::globalScope)
        {
          atype=addTemplateNames(atype,scope->name(),cName);
        }
        funcPtrPos = atype.find("*)(");
        if (funcPtrPos!=-1) funcPtrPos++;
        linkifyText(TextGeneratorOLImpl(ol),
                    funcPtrPos==-1 ? atype : atype.left(funcPtrPos),
                    options);
      }
    }
 
    if (!isDefine)
    {
      if (paramTypeStarted)
      {
        ol.endParameterType();
        paramTypeStarted=FALSE;
      }
      ol.startParameterName(defArgList.size()<2);
    }
    else
    {
      ol.endParameterName();
    }
 
    if (atype=="...")
    {
      ol.docify(atype);
    }
    else if (!a.name.isEmpty()) // argument has a name
    {
      ol.docify(a.name);
    }
    if (!isDefine)
    {
      if (funcPtrPos!=-1)
      {
        ol.writeNonBreakableSpace(1);
      }
      ol.endParameterName();
    }
    ol.startParameterExtra();
    if (funcPtrPos!=-1)
    {
      linkifyText(TextGeneratorOLImpl(ol),atype.mid(funcPtrPos),options);
    }
    if (!a.array.isEmpty())
    {
      ol.docify(a.array);
    }
    if (!a.defval.isEmpty()) // write the default value
    {
      QCString n=a.defval;
      if (scope && scope!=Doxygen::globalScope && !cName.isEmpty())
      {
        n=addTemplateNames(n,scope->name(),cName);
      }
      ol.startParameterDefVal(" = ");
      linkifyText(TextGeneratorOLImpl(ol),n,LinkifyTextOptions(options).setKeepSpaces(true));
      ol.endParameterDefVal();
    }
    ++alIt;
    if (alIt!=defArgList.end())
    {
      a = *alIt;
      if (!md->isObjCMethod()) ol.docify(", "); // there are more arguments
      if (!isDefine)
      {
        QCString key;
        if (md->isObjCMethod() && a.attrib.length()>=2)
        {
          //printf("Found parameter keyword %s\n",a.qPrint(attrib));
          // strip [ and ]
          key=a.attrib.mid(1,a.attrib.length()-2);
          if (key!=",") key+=":"; // for normal keywords add colon
        }
        ol.endParameterExtra(false,false,!md->isObjCMethod());
        ol.startParameterType(FALSE,key);
        paramTypeStarted=TRUE;
      }
      else // isDefine
      {
        ol.endParameterExtra(false,false,true);
      }
    }
    first=FALSE;
  }
  if (first)
  {
    ol.startParameterName(defArgList.size()<2);
    ol.endParameterName();
    ol.startParameterExtra();
  }
  ol.endParameterExtra(TRUE,defArgList.size()<2,!md->isObjCMethod());
  if (!md->extraTypeChars().isEmpty())
  {
    ol.docify(md->extraTypeChars());
  }
  if (defArgList.constSpecifier())
  {
    ol.docify(" const");
  }
  if (defArgList.volatileSpecifier())
  {
    ol.docify(" volatile");
  }
  if (defArgList.refQualifier()==RefQualifierType::LValue)
  {
    ol.docify(" &");
  }
  else if (defArgList.refQualifier()==RefQualifierType::RValue)
  {
    ol.docify(" &&");
  }
  if (!defArgList.trailingReturnType().isEmpty())
  {
    linkifyText(TextGeneratorOLImpl(ol), defArgList.trailingReturnType(), options);
  }
  return TRUE;
}

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, LinkifyTextOptions::setFileScope(), LinkifyTextOptions::setScope(), LinkifyTextOptions::setSelf(), 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 1302 of file memberdef.cpp.

{
  QCString exception = md->excpString().stripWhiteSpace();
  if ('{'==exception.at(0))
  {
    // this is an UNO IDL attribute - need special handling
    int index = exception.find(';');
    int oldIndex = 1;
    while (-1 != index) // there should be no more than 2 (set / get)
    {
      // omit '{' and ';' -> "set raises (...)"
      writeExceptionListImpl(ol,cd,md,exception.mid(oldIndex,index-oldIndex));
      oldIndex=index+1;
      index = exception.find(';',oldIndex);
    }
    // the rest is now just '}' - omit that
  }
  else
  {
    writeExceptionListImpl(ol,cd,md,exception);
  }
}

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 1262 of file memberdef.cpp.

{
  // this is ordinary exception spec - there must be a '('
  //printf("exception='%s'\n",qPrint(exception));
  int index = exception.find('(');
  LinkifyTextOptions options;
  options.setScope(cd).setFileScope(md->getBodyDef()).setSelf(md);
  if (index!=-1)
  {
    ol.exceptionEntry(exception.left(index),false);
    ++index; // paren in second column so skip it here
    for (int comma = exception.find(',', index); comma!=-1; )
    {
      ++comma; // include comma
      linkifyText(TextGeneratorOLImpl(ol),exception.mid(index,comma-index),options);
      ol.exceptionEntry(QCString(),false);
      index=comma;
      comma = exception.find(',', index);
    }
    int close = exception.find(')', index);
    if (close!=-1)
    {
      QCString type=removeRedundantWhiteSpace(exception.mid(index,close-index));
      linkifyText(TextGeneratorOLImpl(ol),type,options);
      ol.exceptionEntry(QCString(),true);
    }
    else
    {
      warn(md->getDefFileName(),md->getDefLine(),
          "missing ) in exception list on member {}",md->name());
    }
  }
  else // Java Exception
  {
    ol.docify(" ");
    linkifyText(TextGeneratorOLImpl(ol),exception,options);
  }
}

References OutputList::docify(), OutputList::exceptionEntry(), QCString::find(), Definition::getBodyDef(), Definition::getDefFileName(), Definition::getDefLine(), QCString::left(), linkifyText(), QCString::mid(), Definition::name(), removeRedundantWhiteSpace(), LinkifyTextOptions::setFileScope(), LinkifyTextOptions::setScope(), LinkifyTextOptions::setSelf(), and warn.

Referenced by writeExceptionList().

Variable Documentation

g_cachedAnonymousTypeMutex

std::mutex g_cachedAnonymousTypeMutex

static

Definition at line 1982 of file memberdef.cpp.

Referenced by MemberDefImpl::getClassDefOfAnonymousType().

g_detectUndocumentedParamsMutex

std::mutex g_detectUndocumentedParamsMutex

static

Definition at line 4218 of file memberdef.cpp.

Referenced by MemberDefImpl::detectUndocumentedParams().

g_docCrossReferenceMutex

std::mutex g_docCrossReferenceMutex

static

Definition at line 6493 of file memberdef.cpp.

Referenced by addDocCrossReference().

g_hasDetailedDescriptionMutex

std::mutex g_hasDetailedDescriptionMutex

static

Definition at line 2661 of file memberdef.cpp.

Referenced by MemberDefImpl::hasDetailedDescription().

reAnonymous

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

static

Referenced by MemberDefImpl::displayDefinition(), and MemberDefImpl::writeDocumentation().