The `util.h` File Reference

A bunch of utility functions. More...

Included Headers

#include <memory> #include <unordered_map> #include <algorithm> #include <functional> #include <fstream> #include <variant> #include <string_view> #include <ctype.h> #include "types.h" #include "docparser.h" #include "containers.h" #include "outputgen.h" #include "regex.h" #include "conceptdef.h" #include "construct.h"

Classes Index

class	TextGeneratorIntf
	Abstract interface for a hyperlinked text fragment. More...

class	TextGeneratorOLImpl
	Implements TextGeneratorIntf for an OutputDocInterface stream. More...

struct	GetDefInput


struct	GetDefResult


struct	SelectionBlock


struct	SelectionMarkerInfo


struct	KeywordSubstitution


struct	ColoredImgDataItem
	Data associated with a HSV colored image. More...

Typedefs Index

using	SelectionBlockList = std::vector< SelectionBlock >


using	KeywordSubstitutionList = std::vector< KeywordSubstitution >

Functions Index

QCString	langToString (SrcLangExt lang)
	Returns a string representation of lang. More...

QCString	getLanguageSpecificSeparator (SrcLangExt lang, bool classScope=FALSE)
	Returns the scope separator to use given the programming language lang. More...

void	linkifyText (const TextGeneratorIntf &ol, const Definition scope, const FileDef fileScope, const Definition *self, const QCString &text, bool autoBreak=FALSE, bool external=TRUE, bool keepSpaces=FALSE, int indentLevel=0)


QCString	fileToString (const QCString &name, bool filter=FALSE, bool isSourceCode=FALSE)


GetDefResult	getDefs (const GetDefInput &input)


QCString	getFileFilter (const QCString &name, bool isSourceCode)


bool	resolveRef (const QCString &scName, const QCString &name, bool inSeeBlock, const Definition resContext, const MemberDef resMember, SrcLangExt lang, bool lookForSpecializations=TRUE, const FileDef *currentFile=nullptr, bool checkScope=FALSE)


bool	resolveLink (const QCString &scName, const QCString &lr, bool inSeeBlock, const Definition **resContext, QCString &resAnchor, SrcLangExt lang, const QCString &prefix=QCString())


void	generateFileRef (OutputList &ol, const QCString &, const QCString &linkTxt=QCString())


void	writePageRef (OutputList &ol, const QCString &cn, const QCString &mn)


bool	matchArguments2 (const Definition srcScope, const FileDef srcFileScope, const ArgumentList srcAl, const Definition dstScope, const FileDef dstFileScope, const ArgumentList dstAl, bool checkCV, SrcLangExt lang)


void	mergeArguments (ArgumentList &, ArgumentList &, bool forceNameOverwrite=FALSE)


bool	matchTemplateArguments (const ArgumentList &srcAl, const ArgumentList &dstAl)


QCString	substituteClassNames (const QCString &s)


QCString	selectBlocks (const QCString &s, const SelectionBlockList &blockList, const SelectionMarkerInfo &markerInfo)
	remove disabled blocks and all block markers from s and return the result as a string More...

void	checkBlocks (const QCString &s, const QCString fileName, const SelectionMarkerInfo &markerInfo)


QCString	removeEmptyLines (const QCString &s)


FileDef *	findFileDef (const FileNameLinkedMap *fnMap, const QCString &n, bool &ambig)


QCString	findFilePath (const QCString &file, bool &ambig)


QCString	showFileDefMatches (const FileNameLinkedMap *fnMap, const QCString &n)


EntryType	guessSection (const QCString &name)


bool	isId (int c)


bool	isIdJS (int c)


QCString	removeRedundantWhiteSpace (const QCString &s)


QCString	inlineArgListToDoc (const ArgumentList &al)


QCString	inlineTemplateArgListToDoc (const ArgumentList &al)


QCString	argListToString (const ArgumentList &al, bool useCanonicalType=FALSE, bool showDefVals=TRUE)


QCString	tempArgListToString (const ArgumentList &al, SrcLangExt lang, bool includeDefaults=true)


QCString	generateMarker (int id)


void	writeExamples (OutputList &ol, const ExampleList &el)


QCString	stripAnonymousNamespaceScope (const QCString &s)


QCString	stripFromPath (const QCString &path)


QCString	stripFromIncludePath (const QCString &path)


bool	rightScopeMatch (const QCString &scope, const QCString &name)


bool	leftScopeMatch (const QCString &scope, const QCString &name)


QCString	substituteKeywords (const QCString &file, const QCString &s, const KeywordSubstitutionList &keywords)


QCString	substituteKeywords (const QCString &file, const QCString &s, const QCString &title, const QCString &projName, const QCString &projNum, const QCString &projBrief)


int	getPrefixIndex (const QCString &name)


QCString	removeAnonymousScopes (const QCString &s)


QCString	replaceAnonymousScopes (const QCString &s, const QCString &replacement=QCString())


QCString	convertNameToFile (const QCString &name, bool allowDots=FALSE, bool allowUnderscore=FALSE)


QCString	generateAnonymousAnchor (const QCString &fileName, int count)


void	extractNamespaceName (const QCString &scopeName, QCString &className, QCString &namespaceName, bool allowEmptyClass=FALSE)


QCString	insertTemplateSpecifierInScope (const QCString &scope, const QCString &templ)


QCString	stripScope (const QCString &name)


QCString	convertToId (const QCString &s)


QCString	correctId (const QCString &s)


QCString	convertToHtml (const QCString &s, bool keepEntities=true)


QCString	convertToXML (const QCString &s, bool keepEntities=false)


QCString	convertToJSString (const QCString &s, bool keepEntities=false)


QCString	getOverloadDocs ()


void	addMembersToMemberGroup (MemberList ml, MemberGroupList pMemberGroups, const Definition *context)


int	extractClassNameFromType (const QCString &type, int &pos, QCString &name, QCString &templSpec, SrcLangExt=SrcLangExt::Unknown)


QCString	normalizeNonTemplateArgumentsInString (const QCString &name, const Definition *context, const ArgumentList &formalArgs)


QCString	substituteTemplateArgumentsInString (const QCString &name, const ArgumentList &formalArgs, const ArgumentList *actualArgs)


QCString	stripTemplateSpecifiersFromScope (const QCString &fullName, bool parentOnly=TRUE, QCString *lastScopeStripped=nullptr, QCString scopeName=QCString(), bool allowArtificial=true)


QCString	resolveTypeDef (const Definition d, const QCString &name, const Definition *typedefContext=nullptr)


QCString	mergeScopes (const QCString &leftScope, const QCString &rightScope)


int	getScopeFragment (const QCString &s, int p, int *l)


void	addRefItem (const RefItemVector &sli, const QCString &key, const QCString &prefix, const QCString &name, const QCString &title, const QCString &args, const Definition *scope)


PageDef *	addRelatedPage (const QCString &name, const QCString &ptitle, const QCString &doc, const QCString &fileName, int docLine, int startLine, const RefItemVector &sli=RefItemVector(), GroupDef gd=nullptr, const TagInfo tagInfo=nullptr, bool xref=FALSE, SrcLangExt lang=SrcLangExt::Unknown)


bool	getCaseSenseNames ()


QCString	escapeCharsInString (const QCString &name, bool allowDots, bool allowUnderscore=FALSE)


QCString	unescapeCharsInString (const QCString &s)


void	addGroupListToTitle (OutputList &ol, const Definition *d)


QCString	linkToText (SrcLangExt lang, const QCString &link, bool isFileName)


bool	checkExtension (const QCString &fName, const QCString &ext)


void	addHtmlExtensionIfMissing (QCString &fName)


QCString	stripExtensionGeneral (const QCString &fName, const QCString &ext)


QCString	stripExtension (const QCString &fName)


int	computeQualifiedIndex (const QCString &name)
	Return the index of the last :: in the string name that is still before the first <. More...

void	addDirPrefix (QCString &fileName)


QCString	relativePathToRoot (const QCString &name)


QCString	determineAbsoluteIncludeName (const QCString &curFile, const QCString &incFileName)


void	createSubDirs (const Dir &d)


void	clearSubDirs (const Dir &d)


QCString	removeLongPathMarker (QCString path)


QCString	stripPath (const QCString &s)


bool	containsWord (const QCString &s, const char *word)
	returns TRUE iff string s contains word w More...

bool	findAndRemoveWord (QCString &s, const char *word)
	removes occurrences of whole word from sentence, while keeps internal spaces and reducing multiple sequences of spaces. More...

QCString	stripLeadingAndTrailingEmptyLines (const QCString &s, int &docLine)
	Special version of QCString::stripWhiteSpace() that only strips completely blank lines. More...

bool	updateLanguageMapping (const QCString &extension, const QCString &parser)


SrcLangExt	getLanguageFromFileName (const QCString &fileName, SrcLangExt defLang=SrcLangExt::Cpp)


SrcLangExt	getLanguageFromCodeLang (QCString &fileName)
	Routine to handle the language attribute of the \code command. More...

QCString	getFileNameExtension (const QCString &fn)


void	initDefaultExtensionMapping ()


void	addCodeOnlyMappings ()


bool	checkIfTypedef (const Definition scope, const FileDef fileScope, const QCString &n)


QCString	parseCommentAsText (const Definition scope, const MemberDef member, const QCString &doc, const QCString &fileName, int lineNr)


QCString	parseCommentAsHtml (const Definition scope, const MemberDef member, const QCString &doc, const QCString &fileName, int lineNr)


bool	transcodeCharacterStringToUTF8 (std::string &input, const char *inputEncoding)


QCString	recodeString (const QCString &str, const char fromEncoding, const char toEncoding)


void	writeTypeConstraints (OutputList &ol, const Definition *d, const ArgumentList &al)


QCString	convertCharEntitiesToUTF8 (const QCString &s)


void	stackTrace ()


bool	readInputFile (const QCString &fileName, std::string &contents, bool filter=TRUE, bool isSourceCode=FALSE)
	read a file name fileName and optionally filter and transcode it More...

QCString	filterTitle (const QCString &title)


bool	patternMatch (const FileInfo &fi, const StringVector &patList)


QCString	externalLinkTarget (const bool parent=false)


QCString	createHtmlUrl (const QCString &relPath, const QCString &ref, bool href, bool islocalFile, const QCString &targetFileName, const QCString &anchor)


QCString	externalRef (const QCString &relPath, const QCString &ref, bool href)


int	nextUtf8CharPosition (const QCString &utf8Str, uint32_t len, uint32_t startPos)


void	writeMarkerList (OutputList &ol, const std::string &markerText, size_t numMarkers, std::function< void(size_t)> replaceFunc)


void	writeColoredImgData (const QCString &dir, ColoredImgDataItem data[])
	Writes the intensity only bitmap represented by data as an image to directory dir using the colors defined by HTML_COLORSTYLE_*. More...

QCString	replaceColorMarkers (const QCString &str)
	Replaces any markers of the form ##AA in input string str by new markers of the form #AABBCC, where #AABBCC represents a valid color, based on the intensity represented by hex number AA and the current HTML_COLORSTYLE_* settings. More...

bool	copyFile (const QCString &src, const QCString &dest)
	Copies the contents of file with name src to the newly created file with name dest. More...

int	lineBlock (const QCString &text, const QCString &marker)
	Returns the line number of the line following the line with the marker. More...

bool	isURL (const QCString &url)
	Checks whether the given url starts with a supported protocol. More...

QCString	correctURL (const QCString &url, const QCString &relPath)
	Corrects URL url according to the relative path relPath. More...

QCString	processMarkup (const QCString &s)


bool	protectionLevelVisible (Protection prot)


QCString	stripIndentation (const QCString &s, bool skipFirstLine=false)


void	stripIndentationVerbatim (QCString &doc, const int indentationLevel)


QCString	getDotImageExtension ()


bool	fileVisibleInIndex (const FileDef *fd, bool &genSourceFile)


QCString	extractDirection (QCString &docs)
	Strip the direction part from docs and return it as a string in canonical form The input docs string can start with e.g. More...

void	convertProtectionLevel (MemberListType inListType, Protection inProt, MemberListType outListType1, MemberListType outListType2)
	Computes for a given list type inListType, which are the the corresponding list type(s) in the base class that are to be added to this list. More...

bool	mainPageHasTitle ()


bool	openOutputFile (const QCString &outFile, std::ofstream &f)


StringVector	split (const std::string &s, const std::string &delimiter)
	split input string s by string delimiter delimiter. More...

StringVector	split (const std::string &s, const reg::Ex &delimiter)
	split input string s by regular expression delimiter delimiter. More...

int	findIndex (const StringVector &sv, const std::string &s)
	find the index of a string in a vector of strings, returns -1 if the string could not be found More...

int	findIndex (const std::string &s, const reg::Ex &re)
	find the index of the first occurrence of pattern re in a string s returns -1 if the pattern could not be found More...

std::string	join (const StringVector &s, const std::string &delimiter)
	create a string where the string in the vector are joined by the given delimiter More...

bool	recognizeFixedForm (const QCString &contents, FortranFormat format)


FortranFormat	convertFileNameFortranParserCode (QCString fn)


QCString	integerToAlpha (int n, bool upper=true)


QCString	integerToRoman (int n, bool upper=true)


QCString	getEncoding (const FileInfo &fi)


QCString	fixSpaces (const QCString &s)


QCString	detab (const QCString &s, size_t &refIndent)


QCString	getProjectId ()


QCString	projectLogoFile ()


void	mergeMemberOverrideOptions (MemberDefMutable md1, MemberDefMutable md2)


size_t	updateColumnCount (const char *s, size_t col)


QCString	mangleCSharpGenericName (const QCString &name)


QCString	demangleCSharpGenericName (const QCString &name, const QCString &templArgs)

Description

A bunch of utility functions.

Typedefs

KeywordSubstitutionList

using KeywordSubstitutionList = std::vector<KeywordSubstitution>

Definition at line 248 of file util.h.

248using KeywordSubstitutionList = std::vector<KeywordSubstitution>;

SelectionBlockList

using SelectionBlockList = std::vector<SelectionBlock>

Definition at line 182 of file util.h.

182using SelectionBlockList = std::vector<SelectionBlock>;

Functions

addCodeOnlyMappings()

void addCodeOnlyMappings ()

Declaration at line 378 of file util.h, definition at line 5716 of file util.cpp.

5716void addCodeOnlyMappings()

5717{

5718 updateLanguageMapping(".xml", "xml");

5719 updateLanguageMapping(".sql", "sql");

5720}

Reference updateLanguageMapping.

Referenced by generateOutput.

addDirPrefix()

void addDirPrefix (QCString & fileName)

Definition at line 356 of file util.h.

addGroupListToTitle()

void addGroupListToTitle (OutputList & ol, const Definition * d)

Declaration at line 340 of file util.h, definition at line 5406 of file util.cpp.

5406void addGroupListToTitle(OutputList &ol,const Definition *d)

5407{

5408 recursivelyAddGroupListToTitle(ol,d,TRUE);

5409}

References recursivelyAddGroupListToTitle and TRUE.

Referenced by ClassDefImpl::writeDocumentation, ConceptDefImpl::writeDocumentation, FileDefImpl::writeDocumentation, GroupDefImpl::writeDocumentation, ModuleDefImpl::writeDocumentation and NamespaceDefImpl::writeDocumentation.

addHtmlExtensionIfMissing()

void addHtmlExtensionIfMissing (QCString & fName)

Declaration at line 346 of file util.h, definition at line 5416 of file util.cpp.

5416void addHtmlExtensionIfMissing(QCString &fName)

5417{

5418 if (fName.isEmpty()) return;

5419 int i_fs = fName.findRev('/');

5420 int i_bs = fName.findRev('\\');

5421 int i = fName.find('.',std::max({ i_fs, i_bs ,0})); // search for . after path part

5422 if (i==-1)

5423 {

5424 fName+=Doxygen::htmlFileExtension;

5425 }

5426}

References QCString::find, QCString::findRev, Doxygen::htmlFileExtension and QCString::isEmpty.

Referenced by HtmlCodeGenerator::_writeCodeLink, Crawlmap::addContentsItem, DocSets::addContentsItem, EclipseHelp::addContentsItem, HtmlHelp::addContentsItem, Qhp::addContentsItem, Crawlmap::addIndexFile, Sitemap::addIndexFile, common_attributes, convertMapFile, dumpSymbol, field2URL, FTVHelp::Private::generateTree, Crawlmap::initialize, makeFileName, makeFileName, makeURL, DefinitionImpl::navigationPathAsString, node2URL, HtmlDocVisitor::operator(), replaceRef, SearchIndexExternal::setCurrentDoc, HtmlGenerator::startFile, HtmlGenerator::startIndexItem, HtmlDocVisitor::startLink, HtmlGenerator::startTextLink, LayoutNavEntry::url, DefinitionImpl::writeDocAnchorsToTagFile, writeIndex, HtmlGenerator::writeInheritedSectionTitle, writeJavasScriptSearchDataPage, writeMapArea, HtmlGenerator::writeObjectLink, ClassDefImpl::writeQuickMemberLinks, FileDefImpl::writeQuickMemberLinks, GroupDefImpl::writeQuickMemberLinks, NamespaceDefImpl::writeQuickMemberLinks, HtmlGenerator::writeSplitBarAsString, HtmlGenerator::writeStartAnnoItem, HtmlGenerator::writeSummaryLink, ClassDefImpl::writeTagFile, ConceptDefImpl::writeTagFile, DirDefImpl::writeTagFile, FileDefImpl::writeTagFile, GroupDefImpl::writeTagFile, MemberDefImpl::writeTagFile, ModuleDefImpl::writeTagFile, NamespaceDefImpl::writeTagFile, PageDefImpl::writeTagFile, VhdlDocGen::writeTagFile, DocSets::writeToken, HtmlCodeGenerator::writeTooltip and DotNode::writeUrl.

addMembersToMemberGroup()

void addMembersToMemberGroup (MemberList * ml, MemberGroupList * pMemberGroups, const Definition * context)

Declaration at line 284 of file util.h, definition at line 4611 of file util.cpp.

4611void addMembersToMemberGroup(MemberList *ml,

4612 MemberGroupList *pMemberGroups,

4613 const Definition *context)

4614{

4615 ASSERT(context!=nullptr);

4616 //printf("addMemberToMemberGroup() context=%s\n",qPrint(context->name()));

4617 if (ml==nullptr) return;

4618

4619 struct MoveMemberInfo

4620 {

4621 MoveMemberInfo(MemberDef *md,MemberGroup *mg,const RefItemVector &rv)

4622 : memberDef(md), memberGroup(mg), sli(rv) {}

4623 MemberDef *memberDef;

4624 MemberGroup *memberGroup;

4625 RefItemVector sli;

4626 };

4627 std::vector<MoveMemberInfo> movedMembers;

4628

4629 for (const auto &md : *ml)

4630 {

4631 if (md->isEnumerate()) // insert enum value of this enum into groups

4632 {

4633 for (const auto &fmd : md->enumFieldList())

4634 {

4635 int groupId=fmd->getMemberGroupId();

4636 if (groupId!=-1)

4637 {

4638 auto it = Doxygen::memberGroupInfoMap.find(groupId);

4639 if (it!=Doxygen::memberGroupInfoMap.end())

4640 {

4641 const auto &info = it->second;

4642 auto mg_it = std::find_if(pMemberGroups->begin(),

4643 pMemberGroups->end(),

4644 [&groupId](const auto &g)

4645 { return g->groupId()==groupId; }

4646 );

4647 MemberGroup *mg_ptr = nullptr;

4648 if (mg_it==pMemberGroups->end())

4649 {

4650 auto mg = std::make_unique<MemberGroup>(

4651 context,

4652 groupId,

4653 info->header,

4654 info->doc,

4655 info->docFile,

4656 info->docLine,

4657 ml->container());

4658 mg_ptr = mg.get();

4659 pMemberGroups->push_back(std::move(mg));

4660 }

4661 else

4662 {

4663 mg_ptr = (*mg_it).get();

4664 }

4665 mg_ptr->insertMember(fmd); // insert in member group

4666 MemberDefMutable *fmdm = toMemberDefMutable(fmd);

4667 if (fmdm)

4668 {

4669 fmdm->setMemberGroup(mg_ptr);

4670 }

4671 }

4672 }

4673 }

4674 }

4675 int groupId=md->getMemberGroupId();

4676 if (groupId!=-1)

4677 {

4678 auto it = Doxygen::memberGroupInfoMap.find(groupId);

4679 if (it!=Doxygen::memberGroupInfoMap.end())

4680 {

4681 const auto &info = it->second;

4682 auto mg_it = std::find_if(pMemberGroups->begin(),

4683 pMemberGroups->end(),

4684 [&groupId](const auto &g)

4685 { return g->groupId()==groupId; }

4686 );

4687 MemberGroup *mg_ptr = nullptr;

4688 if (mg_it==pMemberGroups->end())

4689 {

4690 auto mg = std::make_unique<MemberGroup>(

4691 context,

4692 groupId,

4693 info->header,

4694 info->doc,

4695 info->docFile,

4696 info->docLine,

4697 ml->container());

4698 mg_ptr = mg.get();

4699 pMemberGroups->push_back(std::move(mg));

4700 }

4701 else

4702 {

4703 mg_ptr = (*mg_it).get();

4704 }

4705 movedMembers.emplace_back(md,mg_ptr,info->m_sli);

4706 }

4707 }

4708 }

4709

4710 // move the members to their group

4711 for (const auto &mmi : movedMembers)

4712 {

4713 ml->remove(mmi.memberDef); // remove from member list

4714 mmi.memberGroup->insertMember(mmi.memberDef->resolveAlias()); // insert in member group

4715 mmi.memberGroup->setRefItems(mmi.sli);

4716 MemberDefMutable *rmdm = toMemberDefMutable(mmi.memberDef);

4717 if (rmdm)

4718 {

4719 rmdm->setMemberGroup(mmi.memberGroup);

4720 }

4721 }

4722}

References ASSERT, MemberList::container, Definition::docFile, end, MemberGroup::insertMember, Doxygen::memberGroupInfoMap, MemberVector::remove, MemberDef::setMemberGroup and toMemberDefMutable.

addRefItem()

void addRefItem (const RefItemVector & sli, const QCString & key, const QCString & prefix, const QCString & name, const QCString & title, const QCString & args, const Definition * scope)

Declaration at line 314 of file util.h, definition at line 5319 of file util.cpp.

5319void addRefItem(const RefItemVector &sli,

5320 const QCString &key, const QCString &prefix, const QCString &name,

5321 const QCString &title, const QCString &args, const Definition *scope)

5322{

5323 //printf("addRefItem(sli=%d,key=%s,prefix=%s,name=%s,title=%s,args=%s)\n",(int)sli.size(),key,prefix,name,title,args);

5324 if (!key.isEmpty() && key[0]!='@') // check for @ to skip anonymous stuff (see bug427012)

5325 {

5326 for (RefItem *item : sli)

5327 {

5328 item->setPrefix(prefix);

5329 item->setScope(scope);

5330 item->setName(name);

5331 item->setTitle(title);

5332 item->setArgs(args);

5333 item->setGroup(key);

5334 }

5335 }

5336}

References QCString::isEmpty and prefix.

Referenced by MemberDefImpl::addListReference, addListReferences, ClassDefImpl::addListReferences, FileDefImpl::addListReferences, GroupDefImpl::addListReferences, ModuleDefImpl::addListReferences, NamespaceDefImpl::addListReferences and buildPageList.

addRelatedPage()

PageDef * addRelatedPage (const QCString & name, const QCString & ptitle, const QCString & doc, const QCString & fileName, int docLine, int startLine, const RefItemVector & sli=RefItemVector(), GroupDef * gd=nullptr, const TagInfo * tagInfo=nullptr, bool xref=FALSE, SrcLangExt lang=SrcLangExt::Unknown)

Declaration at line 322 of file util.h, definition at line 5189 of file util.cpp.

5189PageDef *addRelatedPage(const QCString &name,const QCString &ptitle,

5190 const QCString &doc,

5191 const QCString &fileName,

5192 int docLine,

5193 int startLine,

5194 const RefItemVector &sli,

5195 GroupDef *gd,

5196 const TagInfo *tagInfo,

5197 bool xref,

5198 SrcLangExt lang

5199 )

5200{

5201 PageDef *pd=nullptr;

5202 //printf("addRelatedPage(name=%s gd=%p)\n",qPrint(name),gd);

5203 QCString title=ptitle.stripWhiteSpace();

5204 bool newPage = true;

5205 if ((pd=Doxygen::pageLinkedMap->find(name)) && !pd->isReference())

5206 {

5207 if (!xref && !title.isEmpty() && pd->title()!=pd->name() && pd->title()!=title)

5208 {

5209 warn(fileName,startLine,"multiple use of page label '{}' with different titles, (other occurrence: {}, line: {})",

5210 name,pd->docFile(),pd->getStartBodyLine());

5211 }

5212 if (!title.isEmpty() && pd->title()==pd->name()) // pd has no real title yet

5213 {

5214 pd->setTitle(title);

5215 SectionInfo *si = SectionManager::instance().find(pd->name());

5216 if (si)

5217 {

5218 si->setTitle(title);

5219 }

5220 }

5221 // append documentation block to the page.

5222 pd->setDocumentation(doc,fileName,docLine);

5223 //printf("Adding page docs '%s' pi=%p name=%s\n",qPrint(doc),pd,name);

5224 // append (x)refitems to the page.

5225 pd->setRefItems(sli);

5226 newPage = false;

5227 }

5228

5229 if (newPage) // new page

5230 {

5231 QCString baseName=name;

5232 if (baseName.endsWith(".tex"))

5233 baseName=baseName.left(baseName.length()-4);

5234 else if (baseName.right(Doxygen::htmlFileExtension.length())==Doxygen::htmlFileExtension)

5235 baseName=baseName.left(baseName.length()-Doxygen::htmlFileExtension.length());

5236

5237 //printf("Appending page '%s'\n",qPrint(baseName));

5238 if (pd) // replace existing page

5239 {

5240 pd->setDocumentation(doc,fileName,docLine);

5241 pd->setFileName(::convertNameToFile(baseName,FALSE,TRUE));

5242 pd->setShowLineNo(FALSE);

5243 pd->setNestingLevel(0);

5244 pd->setPageScope(nullptr);

5245 pd->setTitle(title);

5246 pd->setReference(QCString());

5247 }

5248 else // newPage

5249 {

5250 pd = Doxygen::pageLinkedMap->add(baseName,

5251 createPageDef(fileName,docLine,baseName,doc,title));

5252 }

5253 pd->setBodySegment(startLine,startLine,-1);

5254

5255 pd->setRefItems(sli);

5256 pd->setLanguage(lang);

5257

5258 if (tagInfo)

5259 {

5260 pd->setReference(tagInfo->tagName);

5261 pd->setFileName(tagInfo->fileName);

5262 }

5263

5264 if (gd) gd->addPage(pd);

5265

5266 if (pd->hasTitle())

5267 {

5268 //outputList->writeTitle(pi->name,pi->title);

5269

5270 // a page name is a label as well!

5271 QCString file;

5272 QCString orgFile;

5273 int line = -1;

5274 if (gd)

5275 {

5276 file=gd->getOutputFileBase();

5277 orgFile=gd->getOutputFileBase();

5278 }

5279 else

5280 {

5281 file=pd->getOutputFileBase();

5282 orgFile=pd->docFile();

5283 line = pd->getStartBodyLine();

5284 }

5285 const SectionInfo *si = SectionManager::instance().find(pd->name());

5286 if (si)

5287 {

5288 if (!si->ref().isEmpty()) // we are from a tag file

5289 {

5290 SectionManager::instance().replace(pd->name(),

5291 file,-1,pd->title(),SectionType::Page,0,pd->getReference());

5292 }

5293 else if (si->lineNr() != -1)

5294 {

5295 warn(orgFile,line,"multiple use of section label '{}', (first occurrence: {}, line {})",pd->name(),si->fileName(),si->lineNr());

5296 }

5297 else

5298 {

5299 warn(orgFile,line,"multiple use of section label '{}', (first occurrence: {})",pd->name(),si->fileName());

5300 }

5301 }

5302 else

5303 {

5304 SectionManager::instance().add(pd->name(),

5305 file,-1,pd->title(),SectionType::Page,0,pd->getReference());

5306 //printf("si->label='%s' si->definition=%s si->fileName='%s'\n",

5307 // qPrint(si->label),si->definition?si->definition->name().data():"<none>",

5308 // qPrint(si->fileName));

5309 //printf(" SectionInfo: sec=%p sec->fileName=%s\n",si,qPrint(si->fileName));

5310 //printf("Adding section key=%s si->fileName=%s\n",qPrint(pageName),qPrint(si->fileName));

5311 }

5312 }

5313 }

5314 return pd;

5315}

References SectionManager::add, GroupDef::addPage, convertNameToFile, createPageDef, Definition::docFile, QCString::endsWith, FALSE, SectionInfo::fileName, TagInfo::fileName, LinkedMap< T, Hash, KeyEqual, Map >::find, Definition::getOutputFileBase, Definition::getReference, Definition::getStartBodyLine, PageDef::hasTitle, Doxygen::htmlFileExtension, SectionManager::instance, QCString::isEmpty, Definition::isReference, QCString::left, QCString::length, SectionInfo::lineNr, Definition::name, SectionType::Page, Doxygen::pageLinkedMap, SectionInfo::ref, SectionManager::replace, QCString::right, DefinitionMutable::setBodySegment, DefinitionMutable::setDocumentation, PageDef::setFileName, DefinitionMutable::setLanguage, PageDef::setNestingLevel, PageDef::setPageScope, DefinitionMutable::setReference, DefinitionMutable::setRefItems, PageDef::setShowLineNo, PageDef::setTitle, SectionInfo::setTitle, QCString::stripWhiteSpace, TagInfo::tagName, PageDef::title, TRUE and warn.

argListToString()

QCString argListToString (const ArgumentList & al, bool useCanonicalType=FALSE, bool showDefVals=TRUE)

Declaration at line 222 of file util.h, definition at line 1202 of file util.cpp.

1202QCString argListToString(const ArgumentList &al,bool useCanonicalType,bool showDefVals)

1203{

1204 QCString result;

1205 if (!al.hasParameters()) return result;

1206 result+="(";

1207 for (auto it = al.begin() ; it!=al.end() ;)

1208 {

1209 Argument a = *it;

1210 QCString type1 = useCanonicalType && !a.canType.isEmpty() ? a.canType : a.type;

1211 QCString type2;

1212 int i=type1.find(")("); // hack to deal with function pointers

1213 if (i!=-1)

1214 {

1215 type2=type1.mid(i);

1216 type1=type1.left(i);

1217 }

1218 if (!a.attrib.isEmpty())

1219 {

1220 result+=a.attrib+" ";

1221 }

1222 if (!a.name.isEmpty() || !a.array.isEmpty())

1223 {

1224 result+= type1+" "+a.name+type2+a.array;

1225 }

1226 else

1227 {

1228 result+= type1+type2;

1229 }

1230 if (!a.defval.isEmpty() && showDefVals)

1231 {

1232 result+="="+a.defval;

1233 }

1234 ++it;

1235 if (it!=al.end()) result+=", ";

1236 }

1237 result+=")";

1238 if (al.constSpecifier()) result+=" const";

1239 if (al.volatileSpecifier()) result+=" volatile";

1240 if (al.refQualifier()==RefQualifierType::LValue) result+=" &";

1241 else if (al.refQualifier()==RefQualifierType::RValue) result+=" &&";

1242 if (!al.trailingReturnType().isEmpty()) result+=al.trailingReturnType();

1243 if (al.pureSpecifier()) result+=" =0";

1244 return removeRedundantWhiteSpace(result);

1245}

References Argument::array, Argument::attrib, ArgumentList::begin, Argument::canType, ArgumentList::constSpecifier, Argument::defval, ArgumentList::end, QCString::find, ArgumentList::hasParameters, QCString::isEmpty, QCString::left, LValue, QCString::mid, Argument::name, ArgumentList::pureSpecifier, ArgumentList::refQualifier, removeRedundantWhiteSpace, RValue, ArgumentList::trailingReturnType, Argument::type and ArgumentList::volatileSpecifier.

Referenced by addMemberFunction, DocParser::checkArgumentName, DocParser::checkUnOrMultipleDocumentedParams, findFriends, findGlobalMember, findMember, SymbolResolver::Private::getResolvedSymbol, matchArguments2, matchTemplateArguments, mergeArguments and substituteTemplateArgumentsInString.

checkBlocks()

void checkBlocks (const QCString & s, const QCString fileName, const SelectionMarkerInfo & markerInfo)

Declaration at line 196 of file util.h, definition at line 7037 of file util.cpp.

7037void checkBlocks(const QCString &s, const QCString fileName,const SelectionMarkerInfo &markerInfo)

7038{

7039 if (s.isEmpty()) return;

7040

7041 const char *p = s.data();

7042 char c = 0;

7043 while ((c=*p))

7044 {

7045 if (c==markerInfo.markerChar) // potential start of marker

7046 {

7047 if (qstrncmp(p,markerInfo.beginStr,markerInfo.beginLen)==0) // start of begin marker

7048 {

7049 size_t len = markerInfo.beginLen;

7050 bool negate = *(p+len)=='!';

7051 if (negate) len++;

7052 p += len;

7053 QCString marker;

7054 while (*p)

7055 {

7056 if (markerInfo.closeLen==0 && *p=='\n') // matching end of line

7057 {

7058 warn(fileName,-1,"Remaining begin replacement with marker '{}'",marker);

7059 break;

7060 }

7061 else if (markerInfo.closeLen!= 0 && qstrncmp(p,markerInfo.closeStr,markerInfo.closeLen)==0) // matching marker closing

7062 {

7063 p += markerInfo.closeLen;

7064 warn(fileName,-1,"Remaining begin replacement with marker '{}'",marker);

7065 break;

7066 }

7067 marker += *p;

7068 p++;

7069 }

7070 }

7071 else if (qstrncmp(p,markerInfo.endStr,markerInfo.endLen)==0) // start of end marker

7072 {

7073 size_t len = markerInfo.endLen;

7074 bool negate = *(p+len)=='!';

7075 if (negate) len++;

7076 p += len;

7077 QCString marker;

7078 while (*p)

7079 {

7080 if (markerInfo.closeLen==0 && *p=='\n') // matching end of line

7081 {

7082 warn(fileName,-1,"Remaining end replacement with marker '{}'",marker);

7083 break;

7084 }

7085 else if (markerInfo.closeLen!= 0 && qstrncmp(p,markerInfo.closeStr,markerInfo.closeLen)==0) // matching marker closing

7086 {

7087 p += markerInfo.closeLen;

7088 warn(fileName,-1,"Remaining end replacement with marker '{}'",marker);

7089 break;

7090 }

7091 marker += *p;

7092 p++;

7093 }

7094 }

7095 }

7096 p++;

7097 }

7098}

References SelectionMarkerInfo::beginLen, SelectionMarkerInfo::beginStr, SelectionMarkerInfo::closeLen, SelectionMarkerInfo::closeStr, QCString::data, SelectionMarkerInfo::endLen, SelectionMarkerInfo::endStr, QCString::isEmpty, SelectionMarkerInfo::markerChar, qstrncmp and warn.

Referenced by HtmlGenerator::init and LatexGenerator::init.

checkExtension()

bool checkExtension (const QCString & fName, const QCString & ext)

Declaration at line 344 of file util.h, definition at line 5411 of file util.cpp.

5411bool checkExtension(const QCString &fName, const QCString &ext)

5412{

5413 return fName.right(ext.length())==ext;

5414}

References QCString::length and QCString::right.

Referenced by copyLatexStyleSheet and extraLatexStyleSheet.

checkIfTypedef()

bool checkIfTypedef (const Definition * scope, const FileDef * fileScope, const QCString & n)

Returns true iff the given name string appears to be a typedef in scope.

Declaration at line 380 of file util.h, definition at line 5826 of file util.cpp.

5826bool checkIfTypedef(const Definition *scope,const FileDef *fileScope,const QCString &n)

5827{

5828 MemberDef *bestMatch = getMemberFromSymbol(scope,fileScope,n);

5829

5830 if (bestMatch && bestMatch->isTypedef())

5831 return TRUE; // closest matching symbol is a typedef

5832 else

5833 return FALSE;

5834}

References FALSE, getMemberFromSymbol, MemberDef::isTypedef and TRUE.

Referenced by isVarWithConstructor.

clearSubDirs()

void clearSubDirs (const Dir & d)

Declaration at line 362 of file util.h, definition at line 4184 of file util.cpp.

4184void clearSubDirs(const Dir &d)

4185{

4186 if (Config_getBool(CREATE_SUBDIRS))

4187 {

4188 // remove empty subdirectories

4189 int createSubdirsLevelPow2 = 1 << Config_getInt(CREATE_SUBDIRS_LEVEL);

4190 for (int l1=0;l1<16;l1++)

4191 {

4192 QCString subdir;

4193 subdir.sprintf("d%x",l1);

4194 for (int l2=0; l2 < createSubdirsLevelPow2; l2++)

4195 {

4196 QCString subsubdir;

4197 subsubdir.sprintf("d%x/d%02x",l1,l2);

4198 if (d.exists(subsubdir.str()) && d.isEmpty(subsubdir.str()))

4199 {

4200 d.rmdir(subsubdir.str());

4201 }

4202 }

4203 if (d.exists(subdir.str()) && d.isEmpty(subdir.str()))

4204 {

4205 d.rmdir(subdir.str());

4206 }

4207 }

4208 }

4209}

References Config_getBool, Config_getInt, Dir::exists, Dir::isEmpty, Dir::rmdir, QCString::sprintf and QCString::str.

Referenced by DocbookGenerator::cleanup, HtmlGenerator::cleanup, LatexGenerator::cleanup, ManGenerator::cleanup, RTFGenerator::cleanup and generateXML.

computeQualifiedIndex()

int computeQualifiedIndex (const QCString & name)

Return the index of the last :: in the string name that is still before the first <.

Declaration at line 354 of file util.h, definition at line 7339 of file util.cpp.

7339int computeQualifiedIndex(const QCString &name)

7340{

7341 int l = static_cast<int>(name.length());

7342 int lastSepPos = -1;

7343 const char *p = name.data();

7344 int i=l-2;

7345 int sharpCount=0;

7346 // --- begin optimized version of ts=name.findRev(">::");

7347 int ts = -1;

7348 while (i>=0)

7349 {

7350 if (p[i]=='>')

7351 {

7352 if (sharpCount==0 && p[i+1]==':' && p[i+2]==':')

7353 {

7354 ts=i;

7355 break;

7356 }

7357 sharpCount++;

7358 }

7359 else if (p[i]=='<')

7360 {

7361 sharpCount--;

7362 }

7363 i--;

7364 }

7365 // --- end optimized version

7366 if (ts==-1) ts=0; else p+=++ts;

7367 for (i=ts;i<l-1;i++)

7368 {

7369 char c=*p++;

7370 if (c==':' && *p==':') lastSepPos=i;

7371 if (c=='<') break;

7372 }

7373 return lastSepPos;

7374}

References QCString::data and QCString::length.

Referenced by addToMap, addVariable, buildFunctionList, buildTypedefList, getMemberFromSymbol, SymbolResolver::Private::getResolvedSymbolRec and SymbolResolver::Private::getResolvedTypeRec.

containsWord()

bool containsWord (const QCString & s, const char * word)

returns TRUE iff string s contains word w

Declaration at line 367 of file util.h, definition at line 5482 of file util.cpp.

5482bool containsWord(const QCString &str,const char *word)

5483{

5484 if (str.isEmpty() || word==nullptr) return false;

5485 static const reg::Ex re(R"(\a+)");

5486 std::string s = str.str();

5487 for (reg::Iterator it(s,re) ; it!=reg::Iterator() ; ++it)

5488 {

5489 if (it->str()==word) return true;

5490 }

5491 return false;

5492}

References QCString::isEmpty and QCString::str.

convertCharEntitiesToUTF8()

QCString convertCharEntitiesToUTF8 (const QCString & s)

Declaration at line 391 of file util.h, definition at line 4561 of file util.cpp.

4561QCString convertCharEntitiesToUTF8(const QCString &str)

4562{

4563 if (str.isEmpty()) return QCString();

4564

4565 std::string s = str.data();

4566 static const reg::Ex re(R"(&\a\w*;)");

4567 reg::Iterator it(s,re);

4568 reg::Iterator end;

4569

4570 GrowBuf growBuf;

4571 size_t p=0, i=0, l=0;

4572 for (; it!=end ; ++it)

4573 {

4574 const auto &match = *it;

4575 p = match.position();

4576 l = match.length();

4577 if (p>i)

4578 {

4579 growBuf.addStr(s.substr(i,p-i));

4580 }

4581 QCString entity(match.str());

4582 HtmlEntityMapper::SymType symType = HtmlEntityMapper::instance().name2sym(entity);

4583 const char *code=nullptr;

4584 if (symType!=HtmlEntityMapper::Sym_Unknown && (code=HtmlEntityMapper::instance().utf8(symType)))

4585 {

4586 growBuf.addStr(code);

4587 }

4588 else

4589 {

4590 growBuf.addStr(entity);

4591 }

4592 i=p+l;

4593 }

4594 growBuf.addStr(s.substr(i));

4595 growBuf.addChar(0);

4596 //printf("convertCharEntitiesToUTF8(%s)->%s\n",qPrint(s),growBuf.get());

4597 return growBuf.get();

4598}

References GrowBuf::addChar, GrowBuf::addStr, QCString::data, end, GrowBuf::get, HtmlEntityMapper::instance, QCString::isEmpty, HtmlEntityMapper::name2sym and HtmlEntityMapper::Sym_Unknown.

Referenced by convertToJSString, generateSqlite3ForPage, generateXMLForPage, getSQLDocBlock and parseCommentAsText.

convertFileNameFortranParserCode()

FortranFormat convertFileNameFortranParserCode (QCString fn)

Declaration at line 465 of file util.h, definition at line 6911 of file util.cpp.

6911FortranFormat convertFileNameFortranParserCode(QCString fn)

6912{

6913 QCString ext = getFileNameExtension(fn);

6914 QCString parserName = Doxygen::parserManager->getParserName(ext);

6915

6916 if (parserName == "fortranfixed") return FortranFormat::Fixed;

6917 else if (parserName == "fortranfree") return FortranFormat::Free;

6918

6919 return FortranFormat::Unknown;

6920}

References Fixed, Free, getFileNameExtension, Doxygen::parserManager and Unknown.

Referenced by convertCppComments.

convertNameToFile()

QCString convertNameToFile (const QCString & name, bool allowDots=FALSE, bool allowUnderscore=FALSE)

This function determines the file name on disk of an item given its name, which could be a class name with template arguments, so special characters need to be escaped.

Declaration at line 261 of file util.h, definition at line 4021 of file util.cpp.

4021QCString convertNameToFile(const QCString &name,bool allowDots,bool allowUnderscore)

4022{

4023 if (name.isEmpty()) return name;

4024 bool shortNames = Config_getBool(SHORT_NAMES);

4025 bool createSubdirs = Config_getBool(CREATE_SUBDIRS);

4026 QCString result;

4027 if (shortNames) // use short names only

4028 {

4029 std::lock_guard<std::mutex> lock(g_usedNamesMutex);

4030 auto kv = g_usedNames.find(name.str());

4031 uint32_t num=0;

4032 if (kv!=g_usedNames.end())

4033 {

4034 num = kv->second;

4035 }

4036 else

4037 {

4038 num = g_usedNamesCount;

4039 g_usedNames.emplace(name.str(),g_usedNamesCount++);

4040 }

4041 result.sprintf("a%05d",num);

4042 }

4043 else // long names

4044 {

4045 result=escapeCharsInString(name,allowDots,allowUnderscore);

4046 size_t resultLen = result.length();

4047 if (resultLen>=128) // prevent names that cannot be created!

4048 {

4049 // third algorithm based on MD5 hash

4050 uint8_t md5_sig[16];

4051 char sigStr[33];

4052 MD5Buffer(result.data(),static_cast<unsigned int>(resultLen),md5_sig);

4053 MD5SigToString(md5_sig,sigStr);

4054 result=result.left(128-32)+sigStr;

4055 }

4056 }

4057 if (createSubdirs)

4058 {

4059 int l1Dir=0,l2Dir=0;

4060 int createSubdirsLevel = Config_getInt(CREATE_SUBDIRS_LEVEL);

4061 int createSubdirsBitmaskL2 = (1<<createSubdirsLevel)-1;

4062

4063 // compute md5 hash to determine sub directory to use

4064 uint8_t md5_sig[16];

4065 MD5Buffer(result.data(),static_cast<unsigned int>(result.length()),md5_sig);

4066 l1Dir = md5_sig[14] & 0xf;

4067 l2Dir = md5_sig[15] & createSubdirsBitmaskL2;

4068

4069 result.prepend(QCString().sprintf("d%x/d%02x/",l1Dir,l2Dir));

4070 }

4071 //printf("*** convertNameToFile(%s)->%s\n",qPrint(name),qPrint(result));

4072 return result;

4073}

References Config_getBool, Config_getInt, QCString::data, escapeCharsInString, g_usedNames, g_usedNamesCount, g_usedNamesMutex, QCString::isEmpty, QCString::left, QCString::length, QCString::prepend, QCString::sprintf and QCString::str.

Referenced by addRelatedPage, buildExampleList, ClassDefImpl::ClassDefImpl, ClassDefImpl::deepCopy, DocAnchor::DocAnchor, DocCite::DocCite, ModuleDefImpl::getOutputFileBase, DocParser::handleAHref, PageDefImpl::PageDefImpl, CCodeParser::parseCode, FortranCodeParser::parseCode, VHDLCodeParser::parseCode, RefList::RefList, FileDefImpl::setDiskNameLocal and NamespaceDefImpl::setFileNameLocal.

convertProtectionLevel()

void convertProtectionLevel (MemberListType inListType, Protection inProt, MemberListType * outListType1, MemberListType * outListType2)

Computes for a given list type inListType, which are the the corresponding list type(s) in the base class that are to be added to this list.

So for public inheritance, the mapping is 1-1, so outListType1=inListType Private members are to be hidden completely.

For protected inheritance, both protected and public members of the base class should be joined in the protected member section.

For private inheritance, both protected and public members of the base class should be joined in the private member section.

Declaration at line 448 of file util.h, definition at line 6744 of file util.cpp.

6744void convertProtectionLevel(

6745 MemberListType inListType,

6746 Protection inProt,

6747 MemberListType *outListType1,

6748 MemberListType *outListType2

6749 )

6750{

6751 bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);

6752

6753 // default representing 1-1 mapping

6754 *outListType1=inListType;

6755 *outListType2=MemberListType::Invalid();

6756

6757 if (inProt==Protection::Public)

6758 {

6759 if (inListType.isPrivate())

6760 {

6761 *outListType1=MemberListType::Invalid();

6762 }

6763 }

6764 else if (inProt==Protection::Protected)

6765 {

6766 if (inListType.isPrivate() || inListType.isPublic())

6767 {

6768 *outListType1=MemberListType::Invalid();

6769 }

6770 else if (inListType.isProtected())

6771 {

6772 *outListType2=inListType.toPublic();

6773 }

6774 }

6775 else if (inProt==Protection::Private)

6776 {

6777 if (inListType.isPublic() || inListType.isProtected())

6778 {

6779 *outListType1=MemberListType::Invalid();

6780 }

6781 else if (inListType.isPrivate())

6782 {

6783 if (extractPrivate)

6784 {

6785 *outListType1=inListType.toPublic();

6786 *outListType2=inListType.toProtected();

6787 }

6788 else

6789 {

6790 *outListType1=MemberListType::Invalid();

6791 }

6792 }

6793 }

6794

6795 //printf("convertProtectionLevel(type=%s prot=%d): %s,%s\n",

6796 // qPrint(inListType.to_string()),inProt,qPrint(outListType1->to_string()),qPrint(outListType2->to_string()));

6797}

References Config_getBool, MemberListType::Invalid, MemberListType::isPrivate, MemberListType::isProtected, MemberListType::isPublic, MemberListType::toProtected and MemberListType::toPublic.

Referenced by ClassDefImpl::countInheritedDecMembers and ClassDefImpl::writeInheritedMemberDeclarations.

convertToHtml()

QCString convertToHtml (const QCString & s, bool keepEntities=true)

Converts a string to a HTML-encoded string

Declaration at line 276 of file util.h, definition at line 4480 of file util.cpp.

4480QCString convertToHtml(const QCString &s,bool keepEntities)

4481{

4482 if (s.isEmpty()) return s;

4483 GrowBuf growBuf;

4484 const char *p=s.data();

4485 char c = 0;

4486 while ((c=*p++))

4487 {

4488 switch (c)

4489 {

4490 case '<': growBuf.addStr("<"); break;

4491 case '>': growBuf.addStr(">"); break;

4492 case '&': if (keepEntities)

4493 {

4494 const char *e=p;

4495 char ce = 0;

4496 while ((ce=*e++))

4497 {

4498 if (ce==';' || (!(isId(ce) || ce=='#'))) break;

4499 }

4500 if (ce==';') // found end of an entity

4501 {

4502 // copy entry verbatim

4503 growBuf.addChar(c);

4504 while (p<e) growBuf.addChar(*p++);

4505 }

4506 else

4507 {

4508 growBuf.addStr("&");

4509 }

4510 }

4511 else

4512 {

4513 growBuf.addStr("&");

4514 }

4515 break;

4516 case '\'': growBuf.addStr("'"); break;

4517 case '"': growBuf.addStr("""); break;

4518 default:

4519 {

4520 uint8_t uc = static_cast<uint8_t>(c);

4521 if (uc<32 && !isspace(c))

4522 {

4523 growBuf.addStr("&#x24");

4524 growBuf.addChar(hex[uc>>4]);

4525 growBuf.addChar(hex[uc&0xF]);

4526 growBuf.addChar(';');

4527 }

4528 else

4529 {

4530 growBuf.addChar(c);

4531 }

4532 }

4533 break;

4534 }

4535 }

4536 growBuf.addChar(0);

4537 return growBuf.get();

4538}

References GrowBuf::addChar, GrowBuf::addStr, QCString::data, GrowBuf::get, hex, QCString::isEmpty and isId.

Referenced by HtmlCodeGenerator::_writeCodeLink, HtmlHelp::addContentsItem, convertToHtmlAndTruncate, FTVHelp::Private::generateLink, DefinitionImpl::navigationPathAsString, HtmlDocVisitor::operator(), HtmlDocVisitor::operator(), HtmlDocVisitor::operator(), HtmlGenerator::startFile, HtmlDocVisitor::startLink, substituteHtmlKeywords, HtmlHelpIndex::writeFields, HtmlGenerator::writeInheritedSectionTitle, HtmlGenerator::writeLogoAsString, writeMapArea, HtmlGenerator::writePageFooter, ClassDefImpl::writeQuickMemberLinks, FileDefImpl::writeQuickMemberLinks, GroupDefImpl::writeQuickMemberLinks, NamespaceDefImpl::writeQuickMemberLinks and HtmlGenerator::writeSearchPage.

convertToId()

QCString convertToId (const QCString & s)

Converts a string to a HTML id string

Declaration at line 273 of file util.h, definition at line 4389 of file util.cpp.

4389QCString convertToId(const QCString &s)

4390{

4391 if (s.isEmpty()) return s;

4392 GrowBuf growBuf;

4393 const char *p = s.data();

4394 char c = 0;

4395 bool first = true;

4396 while ((c=*p++))

4397 {

4398 char encChar[4];

4399 if ((c>='0' && c<='9') || (c>='a' && c<='z') || (c>='A' && c<='Z') || c=='-')

4400 { // any permissive character except _

4401 if (first && c>='0' && c<='9') growBuf.addChar('a'); // don't start with a digit

4402 growBuf.addChar(c);

4403 }

4404 else

4405 {

4406 encChar[0]='_';

4407 encChar[1]=hex[static_cast<unsigned char>(c)>>4];

4408 encChar[2]=hex[static_cast<unsigned char>(c)&0xF];

4409 encChar[3]=0;

4410 growBuf.addStr(encChar);

4411 }

4412 first=FALSE;

4413 }

4414 growBuf.addChar(0);

4415 return growBuf.get();

4416}

References GrowBuf::addChar, GrowBuf::addStr, QCString::data, FALSE, GrowBuf::get, hex and QCString::isEmpty.

Referenced by HtmlGenerator::endClassDiagram, HtmlGenerator::endMemberTemplateParams, renderMemberIndicesAsJs, HtmlGenerator::startGroupHeader, HtmlGenerator::startMemberItem, writeMemberList, writeQuickMemberIndex, ClassDefImpl::writeSummaryLinks and VhdlDocGen::writeVHDLDeclarations.

convertToJSString()

QCString convertToJSString (const QCString & s, bool keepEntities=false)

Declaration at line 280 of file util.h, definition at line 4540 of file util.cpp.

4540QCString convertToJSString(const QCString &s,bool keepEntities)

4541{

4542 if (s.isEmpty()) return s;

4543 GrowBuf growBuf;

4544 const char *p=s.data();

4545 char c = 0;

4546 while ((c=*p++))

4547 {

4548 switch (c)

4549 {

4550 case '"': growBuf.addStr("\\\""); break;

4551 case '\\': if (*p=='u' && *(p+1)=='{') growBuf.addStr("\\");

4552 else growBuf.addStr("\\\\");

4553 break;

4554 default: growBuf.addChar(c); break;

4555 }

4556 }

4557 growBuf.addChar(0);

4558 return keepEntities ? growBuf.get() : convertCharEntitiesToUTF8(growBuf.get());

4559}

References GrowBuf::addChar, GrowBuf::addStr, convertCharEntitiesToUTF8, QCString::data, GrowBuf::get and QCString::isEmpty.

Referenced by generateJSLink, generateJSNavTree, renderMemberIndicesAsJs and renderQuickLinksAsJs.

convertToXML()

QCString convertToXML (const QCString & s, bool keepEntities=false)

Converts a string to an XML-encoded string

Declaration at line 278 of file util.h, definition at line 4429 of file util.cpp.

4429QCString convertToXML(const QCString &s, bool keepEntities)

4430{

4431 if (s.isEmpty()) return s;

4432 GrowBuf growBuf;

4433 const char *p = s.data();

4434 char c = 0;

4435 while ((c=*p++))

4436 {

4437 switch (c)

4438 {

4439 case '<': growBuf.addStr("<"); break;

4440 case '>': growBuf.addStr(">"); break;

4441 case '&': if (keepEntities)

4442 {

4443 const char *e=p;

4444 char ce = 0;

4445 while ((ce=*e++))

4446 {

4447 if (ce==';' || (!(isId(ce) || ce=='#'))) break;

4448 }

4449 if (ce==';') // found end of an entity

4450 {

4451 // copy entry verbatim

4452 growBuf.addChar(c);

4453 while (p<e) growBuf.addChar(*p++);

4454 }

4455 else

4456 {

4457 growBuf.addStr("&");

4458 }

4459 }

4460 else

4461 {

4462 growBuf.addStr("&");

4463 }

4464 break;

4465 case '\'': growBuf.addStr("'"); break;

4466 case '"': growBuf.addStr("""); break;

4467 case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8:

4468 case 11: case 12: case 13: case 14: case 15: case 16: case 17: case 18:

4469 case 19: case 20: case 21: case 22: case 23: case 24: case 25: case 26:

4470 case 27: case 28: case 29: case 30: case 31:

4471 break; // skip invalid XML characters (see http://www.w3.org/TR/2000/REC-xml-20001006#NT-Char)

4472 default: growBuf.addChar(c); break;

4473 }

4474 }

4475 growBuf.addChar(0);

4476 return growBuf.get();

4477}

References GrowBuf::addChar, GrowBuf::addStr, QCString::data, GrowBuf::get, QCString::isEmpty and isId.

copyFile()

bool copyFile (const QCString & src, const QCString & dest)

Copies the contents of file with name src to the newly created file with name dest.

Returns TRUE if successful.

Declaration at line 427 of file util.h, definition at line 6374 of file util.cpp.

6374bool copyFile(const QCString &src,const QCString &dest)

6375{

6376 if (!Dir().copy(src.str(),dest.str()))

6377 {

6378 err("could not copy file {} to {}\n",src,dest);

6379 return false;

6380 }

6381 return true;

6382}

References err and QCString::str.

correctId()

QCString correctId (const QCString & s)

Some strings have been corrected but the requirement regarding the fact that an id cannot have a digit at the first position. To overcome problems with double labels we always place an "a" in front

Declaration at line 274 of file util.h, definition at line 4422 of file util.cpp.

4422QCString correctId(const QCString &s)

4423{

4424 if (s.isEmpty()) return s;

4425 return "a" + s;

4426}

Reference QCString::isEmpty.

Referenced by DotGraph::generateCode and DotFilePatcher::run.

correctURL()

QCString correctURL (const QCString & url, const QCString & relPath)

Corrects URL url according to the relative path relPath.

Returns the corrected URL. For absolute URLs no correction will be done.

Declaration at line 433 of file util.h, definition at line 6442 of file util.cpp.

6442QCString correctURL(const QCString &url,const QCString &relPath)

6443{

6444 QCString result = url;

6445 if (!relPath.isEmpty() && !isURL(url))

6446 {

6447 result.prepend(relPath);

6448 }

6449 return result;

6450}

References QCString::isEmpty, isURL and QCString::prepend.

Referenced by HtmlDocVisitor::operator(), HtmlDocVisitor::operator(), XmlDocVisitor::operator(), startQuickIndexItem and writeIndexHierarchyEntries.

createHtmlUrl()

QCString createHtmlUrl (const QCString & relPath, const QCString & ref, bool href, bool islocalFile, const QCString & targetFileName, const QCString & anchor)

Declaration at line 402 of file util.h, definition at line 6237 of file util.cpp.

6237QCString createHtmlUrl(const QCString &relPath,

6238 const QCString &ref,

6239 bool href,

6240 bool isLocalFile,

6241 const QCString &targetFileName,

6242 const QCString &anchor)

6243{

6244 QCString url;

6245 if (!ref.isEmpty())

6246 {

6247 url = externalRef(relPath,ref,href);

6248 }

6249 if (!targetFileName.isEmpty())

6250 {

6251 QCString fn = targetFileName;

6252 if (ref.isEmpty())

6253 {

6254 if (!anchor.isEmpty() && isLocalFile)

6255 {

6256 fn=""; // omit file name for local links

6257 }

6258 else

6259 {

6260 url = relPath;

6261 }

6262 }

6263 url+=fn;

6264 }

6265 if (!anchor.isEmpty()) url+="#"+anchor;

6266 //printf("createHtmlUrl(relPath=%s,local=%d,target=%s,anchor=%s)=%s\n",qPrint(relPath),isLocalFile,qPrint(targetFileName),qPrint(anchor),qPrint(url));

6267 return url;

6268}

References externalRef and QCString::isEmpty.

Referenced by HtmlCodeGenerator::_writeCodeLink, HtmlDocVisitor::startLink, HtmlGenerator::startTextLink, HtmlGenerator::writeObjectLink and HtmlCodeGenerator::writeTooltip.

createSubDirs()

void createSubDirs (const Dir & d)

Declaration at line 361 of file util.h, definition at line 4157 of file util.cpp.

4157void createSubDirs(const Dir &d)

4158{

4159 if (Config_getBool(CREATE_SUBDIRS))

4160 {

4161 // create up to 4096 subdirectories

4162 int createSubdirsLevelPow2 = 1 << Config_getInt(CREATE_SUBDIRS_LEVEL);

4163 for (int l1=0; l1<16; l1++)

4164 {

4165 QCString subdir;

4166 subdir.sprintf("d%x",l1);

4167 if (!d.exists(subdir.str()) && !d.mkdir(subdir.str()))

4168 {

4169 term("Failed to create output directory '{}'\n",subdir);

4170 }

4171 for (int l2=0; l2<createSubdirsLevelPow2; l2++)

4172 {

4173 QCString subsubdir;

4174 subsubdir.sprintf("d%x/d%02x",l1,l2);

4175 if (!d.exists(subsubdir.str()) && !d.mkdir(subsubdir.str()))

4176 {

4177 term("Failed to create output directory '{}'\n",subsubdir);

4178 }

4179 }

4180 }

4181 }

4182}

References Config_getBool, Config_getInt, Dir::exists, Dir::mkdir, QCString::sprintf, QCString::str and term.

Referenced by generateXML, DocbookGenerator::init, HtmlGenerator::init, LatexGenerator::init, ManGenerator::init, RTFGenerator::init, ClassDefImpl::writeQuickMemberLinks, FileDefImpl::writeQuickMemberLinks, GroupDefImpl::writeQuickMemberLinks and NamespaceDefImpl::writeQuickMemberLinks.

demangleCSharpGenericName()

QCString demangleCSharpGenericName (const QCString & name, const QCString & templArgs)

Declaration at line 484 of file util.h, definition at line 7438 of file util.cpp.

7438QCString demangleCSharpGenericName(const QCString &name,const QCString &templArgs)

7439{

7440 QCString result=name;

7441 if (result.endsWith("-g"))

7442 {

7443 int idx = result.find('-');

7444 result = result.left(idx)+templArgs;

7445 }

7446 return result;

7447}

References QCString::endsWith, QCString::find and QCString::left.

Referenced by ClassDefImpl::className.

detab()

QCString detab (const QCString & s, size_t & refIndent)

Declaration at line 474 of file util.h, definition at line 7235 of file util.cpp.

7235QCString detab(const QCString &s,size_t &refIndent)

7236{

7237 int tabSize = Config_getInt(TAB_SIZE);

7238 size_t size = s.length();

7239 GrowBuf out(size);

7240 const char *data = s.data();

7241 size_t i=0;

7242 int col=0;

7243 constexpr auto doxy_nbsp = "&_doxy_nbsp;"; // doxygen escape command for UTF-8 nbsp

7244 const int maxIndent=1000000; // value representing infinity

7245 int minIndent=maxIndent;

7246 bool skip = false;

7247 while (i<size)

7248 {

7249 char c = data[i++];

7250 switch(c)

7251 {

7252 case '\t': // expand tab

7253 {

7254 int stop = tabSize - (col%tabSize);

7255 //printf("expand at %d stop=%d\n",col,stop);

7256 col+=stop;

7257 while (stop--) out.addChar(' ');

7258 }

7259 break;

7260 case '\\':

7261 if (data[i] == '\\') // escaped command -> ignore

7262 {

7263 out.addChar(c);

7264 out.addChar(data[i++]);

7265 col+=2;

7266 }

7267 else if (i+5<size && literal_at(data+i,"iskip")) // \iskip command

7268 {

7269 i+=5;

7270 skip = true;

7271 }

7272 else if (i+8<size && literal_at(data+i,"endiskip")) // \endiskip command

7273 {

7274 i+=8;

7275 skip = false;

7276 }

7277 else // some other command

7278 {

7279 out.addChar(c);

7280 col++;

7281 }

7282 break;

7283 case '\n': // reset column counter

7284 out.addChar(c);

7285 col=0;

7286 break;

7287 case ' ': // increment column counter

7288 out.addChar(c);

7289 col++;

7290 break;

7291 default: // non-whitespace => update minIndent

7292 if (c<0 && i<size) // multibyte sequence

7293 {

7294 // special handling of the UTF-8 nbsp character 194 160

7295 int nb = isUTF8NonBreakableSpace(data);

7296 if (nb>0)

7297 {

7298 out.addStr(doxy_nbsp);

7299 i+=nb-1;

7300 }

7301 else

7302 {

7303 int bytes = getUTF8CharNumBytes(c);

7304 for (int j=0;j<bytes-1 && c;j++)

7305 {

7306 out.addChar(c);

7307 c = data[i++];

7308 }

7309 out.addChar(c);

7310 }

7311 }

7312 else

7313 {

7314 out.addChar(c);

7315 }

7316 if (!skip && col<minIndent) minIndent=col;

7317 col++;

7318 }

7319 }

7320 if (minIndent!=maxIndent) refIndent=minIndent; else refIndent=0;

7321 out.addChar(0);

7322 //printf("detab(\n%s\n)=[\n%s\n]\n",qPrint(s),qPrint(out.get()));

7323 return out.get();

7324}

References GrowBuf::addChar, GrowBuf::addStr, Config_getInt, QCString::data, GrowBuf::get, getUTF8CharNumBytes, isUTF8NonBreakableSpace, QCString::length and literal_at.

Referenced by Markdown::process.

determineAbsoluteIncludeName()

QCString determineAbsoluteIncludeName (const QCString & curFile, const QCString & incFileName)

Declaration at line 359 of file util.h, definition at line 4117 of file util.cpp.

4117QCString determineAbsoluteIncludeName(const QCString &curFile,const QCString &incFileName)

4118{

4119 bool searchIncludes = Config_getBool(SEARCH_INCLUDES);

4120 QCString absIncFileName = incFileName;

4121 FileInfo fi(curFile.str());

4122 if (fi.exists())

4123 {

4124 QCString absName = QCString(fi.dirPath(TRUE))+"/"+incFileName;

4125 FileInfo fi2(absName.str());

4126 if (fi2.exists())

4127 {

4128 absIncFileName=fi2.absFilePath();

4129 }

4130 else if (searchIncludes) // search in INCLUDE_PATH as well

4131 {

4132 const StringVector &includePath = Config_getList(INCLUDE_PATH);

4133 for (const auto &incPath : includePath)

4134 {

4135 FileInfo fi3(incPath);

4136 if (fi3.exists() && fi3.isDir())

4137 {

4138 absName = QCString(fi3.absFilePath())+"/"+incFileName;

4139 //printf("trying absName=%s\n",qPrint(absName));

4140 FileInfo fi4(absName.str());

4141 if (fi4.exists())

4142 {

4143 absIncFileName=fi4.absFilePath();

4144 break;

4145 }

4146 //printf( "absIncFileName = %s\n", qPrint(absIncFileName) );

4147 }

4148 }

4149 }

4150 //printf( "absIncFileName = %s\n", qPrint(absIncFileName) );

4151 }

4152 return absIncFileName;

4153}

References FileInfo::absFilePath, Config_getBool, Config_getList, FileInfo::dirPath, FileInfo::exists, FileInfo::isDir, QCString::str and TRUE.

Referenced by readIncludeFile and ModuleManager::resolveImports.

escapeCharsInString()

QCString escapeCharsInString (const QCString & name, bool allowDots, bool allowUnderscore=FALSE)

Declaration at line 337 of file util.h, definition at line 3847 of file util.cpp.

3847QCString escapeCharsInString(const QCString &name,bool allowDots,bool allowUnderscore)

3848{

3849 if (name.isEmpty()) return name;

3850 bool caseSenseNames = getCaseSenseNames();

3851 bool allowUnicodeNames = Config_getBool(ALLOW_UNICODE_NAMES);

3852 GrowBuf growBuf;

3853 signed char c = 0;

3854 const char *p=name.data();

3855 while ((c=*p++)!=0)

3856 {

3857 switch(c)

3858 {

3859 case '_': if (allowUnderscore) growBuf.addChar('_'); else growBuf.addStr("__"); break;

3860 case '-': growBuf.addChar('-'); break;

3861 case ':': growBuf.addStr("_1"); break;

3862 case '/': growBuf.addStr("_2"); break;

3863 case '<': growBuf.addStr("_3"); break;

3864 case '>': growBuf.addStr("_4"); break;

3865 case '*': growBuf.addStr("_5"); break;

3866 case '&': growBuf.addStr("_6"); break;

3867 case '|': growBuf.addStr("_7"); break;

3868 case '.': if (allowDots) growBuf.addChar('.'); else growBuf.addStr("_8"); break;

3869 case '!': growBuf.addStr("_9"); break;

3870 case ',': growBuf.addStr("_00"); break;

3871 case ' ': growBuf.addStr("_01"); break;

3872 case '{': growBuf.addStr("_02"); break;

3873 case '}': growBuf.addStr("_03"); break;

3874 case '?': growBuf.addStr("_04"); break;

3875 case '^': growBuf.addStr("_05"); break;

3876 case '%': growBuf.addStr("_06"); break;

3877 case '(': growBuf.addStr("_07"); break;

3878 case ')': growBuf.addStr("_08"); break;

3879 case '+': growBuf.addStr("_09"); break;

3880 case '=': growBuf.addStr("_0a"); break;

3881 case '$': growBuf.addStr("_0b"); break;

3882 case '\\': growBuf.addStr("_0c"); break;

3883 case '@': growBuf.addStr("_0d"); break;

3884 case ']': growBuf.addStr("_0e"); break;

3885 case '[': growBuf.addStr("_0f"); break;

3886 case '#': growBuf.addStr("_0g"); break;

3887 case '"': growBuf.addStr("_0h"); break;

3888 case '~': growBuf.addStr("_0i"); break;

3889 case '\'': growBuf.addStr("_0j"); break;

3890 case ';': growBuf.addStr("_0k"); break;

3891 case '`': growBuf.addStr("_0l"); break;

3892 default:

3893 if (c<0)

3894 {

3895 bool doEscape = true;

3896 if (allowUnicodeNames)

3897 {

3898 int charLen = getUTF8CharNumBytes(c);

3899 if (charLen>0)

3900 {

3901 growBuf.addStr(p-1,charLen);

3902 p+=charLen;

3903 doEscape = false;

3904 }

3905 }

3906 if (doEscape) // not a valid unicode char or escaping needed

3907 {

3908 char ids[5];

3909 unsigned char id = static_cast<unsigned char>(c);

3910 ids[0]='_';

3911 ids[1]='x';

3912 ids[2]=hex[id>>4];

3913 ids[3]=hex[id&0xF];

3914 ids[4]=0;

3915 growBuf.addStr(ids);

3916 }

3917 }

3918 else if (caseSenseNames || !isupper(c))

3919 {

3920 growBuf.addChar(c);

3921 }

3922 else

3923 {

3924 growBuf.addChar('_');

3925 growBuf.addChar(static_cast<char>(tolower(c)));

3926 }

3927 break;

3928 }

3929 }

3930 growBuf.addChar(0);

3931 return growBuf.get();

3932}

References GrowBuf::addChar, GrowBuf::addStr, Config_getBool, QCString::data, GrowBuf::get, getCaseSenseNames, getUTF8CharNumBytes, hex and QCString::isEmpty.

Referenced by convertNameToFile, DotClassGraph::getMapLabel, DotDirDeps::getMapLabel, DotGfxHierarchyTable::getMapLabel, DotGroupCollaboration::getMapLabel, DotInclDepGraph::getMapLabel, markdownFileNameToId and PageDefImpl::writeDocumentation.

externalLinkTarget()

QCString externalLinkTarget (const bool parent=false)

Declaration at line 401 of file util.h, definition at line 6226 of file util.cpp.

6226QCString externalLinkTarget(const bool parent)

6227{

6228 bool extLinksInWindow = Config_getBool(EXT_LINKS_IN_WINDOW);

6229 if (extLinksInWindow)

6230 return "target=\"_blank\" ";

6231 else if (parent)

6232 return "target=\"_parent\" ";

6233 else

6234 return "";

6235}

References Config_getBool and parent.

Referenced by HtmlCodeGenerator::_writeCodeLink, FTVHelp::Private::generateLink, Markdown::Private::processLink, replaceRef, HtmlGenerator::startIndexItem, HtmlDocVisitor::startLink, HtmlGenerator::writeInheritedSectionTitle, writeMapArea and HtmlGenerator::writeObjectLink.

externalRef()

QCString externalRef (const QCString & relPath, const QCString & ref, bool href)

Declaration at line 408 of file util.h, definition at line 6270 of file util.cpp.

6270QCString externalRef(const QCString &relPath,const QCString &ref,bool href)

6271{

6272 QCString result;

6273 if (!ref.isEmpty())

6274 {

6275 auto it = Doxygen::tagDestinationMap.find(ref.str());

6276 if (it!=Doxygen::tagDestinationMap.end())

6277 {

6278 result = it->second;

6279 size_t l = result.length();

6280 if (!relPath.isEmpty() && l>0 && result.at(0)=='.')

6281 { // relative path -> prepend relPath.

6282 result.prepend(relPath);

6283 l+=relPath.length();

6284 }

6285 if (l>0 && result.at(l-1)!='/') result+='/';

6286 if (!href) result.append("\" ");

6287 }

6288 }

6289 else

6290 {

6291 result = relPath;

6292 }

6293 return result;

6294}

References QCString::append, QCString::at, end, QCString::isEmpty, QCString::length, QCString::prepend, QCString::str and Doxygen::tagDestinationMap.

Referenced by HtmlHelp::addContentsItem, convertMapFile, createHtmlUrl, generateJSLink, FTVHelp::Private::generateLink, replaceRef, HtmlGenerator::startIndexItem, LayoutNavEntry::url, HtmlGenerator::writeInheritedSectionTitle, writeJavasScriptSearchDataPage and writeMapArea.

extractClassNameFromType()

int extractClassNameFromType (const QCString & type, int & pos, QCString & name, QCString & templSpec, SrcLangExt lang=SrcLangExt::Unknown)

Extracts a (sub-)string from type starting at pos that could form a class. The index of the match is returned and the found class name and a template argument list templSpec. If -1 is returned there are no more matches.

Declaration at line 288 of file util.h, definition at line 4729 of file util.cpp.

4729int extractClassNameFromType(const QCString &type,int &pos,QCString &name,QCString &templSpec,SrcLangExt lang)

4730{

4731 static const reg::Ex re_norm(R"(\a[\w:]*)");

4732 static const reg::Ex re_fortran(R"(\a[\w:()=]*)");

4733 const reg::Ex *re = &re_norm;

4734

4735 name.clear();

4736 templSpec.clear();

4737 if (type.isEmpty()) return -1;

4738 size_t typeLen=type.length();

4739 if (typeLen>0)

4740 {

4741 if (lang == SrcLangExt::Fortran)

4742 {

4743 if (type[pos]==',') return -1;

4744 if (!type.lower().startsWith("type"))

4745 {

4746 re = &re_fortran;

4747 }

4748 }

4749 std::string s = type.str();

4750 reg::Iterator it(s,*re,static_cast<int>(pos));

4751 reg::Iterator end;

4752

4753 if (it!=end)

4754 {

4755 const auto &match = *it;

4756 size_t i = match.position();

4757 size_t l = match.length();

4758 size_t ts = i+l;

4759 size_t te = ts;

4760 size_t tl = 0;

4761

4762 while (ts<typeLen && type[static_cast<uint32_t>(ts)]==' ') ts++,tl++; // skip any whitespace

4763 if (ts<typeLen && type[static_cast<uint32_t>(ts)]=='<') // assume template instance

4764 {

4765 // locate end of template

4766 te=ts+1;

4767 int brCount=1;

4768 while (te<typeLen && brCount!=0)

4769 {

4770 if (type[static_cast<uint32_t>(te)]=='<')

4771 {

4772 if (te<typeLen-1 && type[static_cast<uint32_t>(te)+1]=='<') te++; else brCount++;

4773 }

4774 if (type[static_cast<uint32_t>(te)]=='>')

4775 {

4776 if (te<typeLen-1 && type[static_cast<uint32_t>(te)+1]=='>') te++; else brCount--;

4777 }

4778 te++;

4779 }

4780 }

4781 name = match.str();

4782 if (te>ts)

4783 {

4784 templSpec = QCString(type).mid(ts,te-ts);

4785 tl+=te-ts;

4786 pos=static_cast<int>(i+l+tl);

4787 }

4788 else // no template part

4789 {

4790 pos=static_cast<int>(i+l);

4791 }

4792 //printf("extractClassNameFromType([in] type=%s,[out] pos=%d,[out] name=%s,[out] templ=%s)=TRUE i=%d\n",

4793 // qPrint(type),pos,qPrint(name),qPrint(templSpec),i);

4794 return static_cast<int>(i);

4795 }

4796 }

4797 pos = static_cast<int>(typeLen);

4798 //printf("extractClassNameFromType([in] type=%s,[out] pos=%d,[out] name=%s,[out] templ=%s)=FALSE\n",

4799 // qPrint(type),pos,qPrint(name),qPrint(templSpec));

4800 return -1;

4801}

References QCString::clear, end, QCString::isEmpty, QCString::length, QCString::lower, QCString::mid, QCString::startsWith and QCString::str.

Referenced by extractCanonicalType, findUsedClassesForClass, stripClassName and stripClassName.

extractDirection()

QCString extractDirection (QCString & docs)

Strip the direction part from docs and return it as a string in canonical form The input docs string can start with e.g.

"[in]", "[in, out]", "[inout]", "[out,in]"...

Returns: either "[in,out]", "[in]", or "[out]" or the empty string.

Declaration at line 446 of file util.h, definition at line 6693 of file util.cpp.

6693QCString extractDirection(QCString &docs)

6694{

6695 std::string s = docs.str();

6696 static const reg::Ex re(R"(\[([ inout,]+)\])");

6697 reg::Iterator it(s,re);

6698 reg::Iterator end;

6699 if (it!=end)

6700 {

6701 const auto &match = *it;

6702 size_t p = match.position();

6703 size_t l = match.length();

6704 if (p==0 && l>2)

6705 {

6706 // make dir the part inside [...] without separators

6707 std::string dir = match[1].str();

6708 // strip , and ' ' from dir

6709 dir.erase(std::remove_if(dir.begin(),dir.end(),

6710 [](const char c) { return c==' ' || c==','; }

6711 ),dir.end());

6712 unsigned char ioMask=0;

6713 size_t inIndex = dir.find( "in");

6714 if ( inIndex!=std::string::npos) dir.erase( inIndex,2),ioMask|=(1<<0);

6715 size_t outIndex = dir.find("out");

6716 if (outIndex!=std::string::npos) dir.erase(outIndex,3),ioMask|=(1<<1);

6717 if (dir.empty() && ioMask!=0) // only in and/or out attributes found

6718 {

6719 docs = s.substr(l); // strip attributes

6720 if (ioMask==((1<<0)|(1<<1))) return "[in,out]";

6721 else if (ioMask==(1<<0)) return "[in]";

6722 else if (ioMask==(1<<1)) return "[out]";

6723 }

6724 }

6725 }

6726 return "";

6727}

References end and QCString::str.

Referenced by inlineArgListToDoc.

extractNamespaceName()

void extractNamespaceName (const QCString & scopeName, QCString & className, QCString & namespaceName, bool allowEmptyClass=FALSE)

Input is a scopeName, output is the scopename split into a namespace part (as large as possible) and a classname part.

Declaration at line 265 of file util.h, definition at line 4214 of file util.cpp.

4214void extractNamespaceName(const QCString &scopeName,

4215 QCString &className,QCString &namespaceName,

4216 bool allowEmptyClass)

4217{

4218 int i=0, p=0;

4219 QCString clName=scopeName;

4220 NamespaceDef *nd = nullptr;

4221 if (!clName.isEmpty() && (nd=getResolvedNamespace(clName)) && getClass(clName)==nullptr)

4222 { // the whole name is a namespace (and not a class)

4223 namespaceName=nd->name();

4224 className.clear();

4225 goto done;

4226 }

4227 p=static_cast<int>(clName.length())-2;

4228 while (p>=0 && (i=clName.findRev("::",p))!=-1)

4229 // see if the first part is a namespace (and not a class)

4230 {

4231 //printf("Trying %s\n",qPrint(clName.left(i)));

4232 if (i>0 && (nd=getResolvedNamespace(clName.left(i))) && getClass(clName.left(i))==nullptr)

4233 {

4234 //printf("found!\n");

4235 namespaceName=nd->name();

4236 className=clName.right(clName.length()-i-2);

4237 goto done;

4238 }

4239 p=i-2; // try a smaller piece of the scope

4240 }

4241 //printf("not found!\n");

4242

4243 // not found, so we just have to guess.

4244 className=scopeName;

4245 namespaceName.clear();

4246

4247done:

4248 if (className.isEmpty() && !namespaceName.isEmpty() && !allowEmptyClass)

4249 {

4250 // class and namespace with the same name, correct to return the class.

4251 className=namespaceName;

4252 namespaceName.clear();

4253 }

4254 //printf("extractNamespace '%s' => '%s|%s'\n",qPrint(scopeName),

4255 // qPrint(className),qPrint(namespaceName));

4256 if (className.endsWith("-p"))

4257 {

4258 className = className.left(className.length()-2);

4259 }

4260 return;

4261}

References QCString::clear, QCString::endsWith, QCString::findRev, getClass, getResolvedNamespace, QCString::isEmpty, QCString::left, QCString::length, Definition::name and QCString::right.

Referenced by addClassToContext, addConceptToContext, findMember and writeAlphabeticalClassList.

fileToString()

QCString fileToString (const QCString & name, bool filter=FALSE, bool isSourceCode=FALSE)

reads a file with name name and returns it as a string. If filter is TRUE the file will be filtered by any user specified input filter. If name is "-" the string will be read from standard input.

Declaration at line 107 of file util.h, definition at line 1442 of file util.cpp.

1442QCString fileToString(const QCString &name,bool filter,bool isSourceCode)

1443{

1444 if (name.isEmpty()) return QCString();

1445 bool fileOpened=false;

1446 if (name[0]=='-' && name[1]==0) // read from stdin

1447 {

1448 std::string contents;

1449 std::string line;

1450 while (getline(std::cin,line))

1451 {

1452 contents+=line+'\n';

1453 }

1454 return QCString(contents);

1455 }

1456 else // read from file

1457 {

1458 FileInfo fi(name.str());

1459 if (!fi.exists() || !fi.isFile())

1460 {

1461 err("file '{}' not found\n",name);

1462 return "";

1463 }

1464 std::string buf;

1465 fileOpened=readInputFile(name,buf,filter,isSourceCode);

1466 if (fileOpened)

1467 {

1468 addTerminalCharIfMissing(buf,'\n');

1469 return buf;

1470 }

1471 }

1472 if (!fileOpened)

1473 {

1474 err("cannot open file '{}' for reading\n",name);

1475 }

1476 return "";

1477}

References addTerminalCharIfMissing, err, FileInfo::exists, QCString::isEmpty, FileInfo::isFile, readInputFile and QCString::str.

Referenced by createDVIFile, extractBoundingBox, getConvertLatexMacro, HtmlGenerator::init, LatexGenerator::init, LayoutDocManager::parse, parseInput, FileDefImpl::parseSource, parseTagFile, DocParser::readTextFileByName, readTextFileByName, runPlantumlContent, FileDefImpl::writeSourceBody, HtmlGenerator::writeStyleInfo and writeXMLCodeBlock.

fileVisibleInIndex()

bool fileVisibleInIndex (const FileDef * fd, bool & genSourceFile)

Declaration at line 444 of file util.h, definition at line 6604 of file util.cpp.

6604bool fileVisibleInIndex(const FileDef *fd,bool &genSourceFile)

6605{

6606 bool allExternals = Config_getBool(ALLEXTERNALS);

6607 bool isDocFile = fd->isDocumentationFile();

6608 genSourceFile = !isDocFile && fd->generateSourceFile();

6609 return ( ((allExternals && fd->isLinkable()) ||

6610 fd->isLinkableInProject()

6611 ) &&

6612 !isDocFile

6613 );

6614}

References Config_getBool, FileDef::generateSourceFile, FileDef::isDocumentationFile, Definition::isLinkable and Definition::isLinkableInProject.

Referenced by countFiles, dirHasVisibleChildren, generateJSTree, writeDirHierarchy, writeDirTreeNode and DirDefImpl::writeFileList.

filterTitle()

QCString filterTitle (const QCString & title)

Declaration at line 397 of file util.h, definition at line 6131 of file util.cpp.

6131QCString filterTitle(const QCString &title)

6132{

6133 std::string tf;

6134 std::string t = title.str();

6135 static const reg::Ex re(R"(%[a-z_A-Z]+)");

6136 reg::Iterator it(t,re);

6137 reg::Iterator end;

6138 size_t p = 0;

6139 for (; it!=end ; ++it)

6140 {

6141 const auto &match = *it;

6142 size_t i = match.position();

6143 size_t l = match.length();

6144 if (i>p) tf+=t.substr(p,i-p);

6145 tf+=match.str().substr(1); // skip %

6146 p=i+l;

6147 }

6148 tf+=t.substr(p);

6149 return QCString(tf);

6150}

References end and QCString::str.

Referenced by addToIndices, createJavaScriptSearchIndex, PerlModGenerator::generatePerlModForPage, generateSqlite3ForPage, generateXMLForPage, mainPageHasOwnTitle, parseCommentAsHtml, SearchIndexExternal::setCurrentDoc, HtmlGenerator::startFile, writeExampleIndex and writeJavasScriptSearchDataPage.

findAndRemoveWord()

bool findAndRemoveWord (QCString & sentence, const char * word)

removes occurrences of whole word from sentence, while keeps internal spaces and reducing multiple sequences of spaces.

Example: sentence= cat+ catfish cat cat concat cat, word=cat returns: + catfish concat

Declaration at line 369 of file util.h, definition at line 5498 of file util.cpp.

5498bool findAndRemoveWord(QCString &sentence,const char *word)

5499{

5500 static reg::Ex re(R"(\s*(\<\a+\>)\s*)");

5501 std::string s = sentence.str();

5502 reg::Iterator it(s,re);

5503 reg::Iterator end;

5504 std::string result;

5505 bool found=false;

5506 size_t p=0;

5507 for ( ; it!=end ; ++it)

5508 {

5509 const auto match = *it;

5510 std::string part = match[1].str();

5511 if (part!=word)

5512 {

5513 size_t i = match.position();

5514 size_t l = match.length();

5515 result+=s.substr(p,i-p);

5516 result+=match.str();

5517 p=i+l;

5518 }

5519 else

5520 {

5521 found=true;

5522 size_t i = match[1].position();

5523 size_t l = match[1].length();

5524 result+=s.substr(p,i-p);

5525 p=i+l;

5526 }

5527 }

5528 result+=s.substr(p);

5529 sentence = QCString(result).simplifyWhiteSpace();

5530 return found;

5531}

References end, QCString::simplifyWhiteSpace and QCString::str.

Referenced by isVarWithConstructor.

findFileDef()

FileDef * findFileDef (const FileNameLinkedMap * fnMap, const QCString & n, bool & ambig)

Declaration at line 201 of file util.h, definition at line 3416 of file util.cpp.

3416FileDef *findFileDef(const FileNameLinkedMap *fnMap,const QCString &n,bool &ambig)

3417{

3418 ambig=FALSE;

3419 if (n.isEmpty()) return nullptr;

3420

3421

3422 const int maxAddrSize = 20;

3423 char addr[maxAddrSize];

3424 qsnprintf(addr,maxAddrSize,"%p:",reinterpret_cast<const void*>(fnMap));

3425 QCString key = addr;

3426 key+=n;

3427

3428 std::lock_guard<std::mutex> lock(g_findFileDefMutex);

3429 FindFileCacheElem *cachedResult = g_findFileDefCache.find(key.str());

3430 //printf("key=%s cachedResult=%p\n",qPrint(key),cachedResult);

3431 if (cachedResult)

3432 {

3433 ambig = cachedResult->isAmbig;

3434 //printf("cached: fileDef=%p\n",cachedResult->fileDef);

3435 return cachedResult->fileDef;

3436 }

3437 else

3438 {

3439 cachedResult = g_findFileDefCache.insert(key.str(),FindFileCacheElem(nullptr,FALSE));

3440 }

3441

3442 QCString name=Dir::cleanDirPath(n.str());

3443 QCString path;

3444 if (name.isEmpty()) return nullptr;

3445 int slashPos=std::max(name.findRev('/'),name.findRev('\\'));

3446 if (slashPos!=-1)

3447 {

3448 path=removeLongPathMarker(name.left(slashPos+1));

3449 name=name.right(name.length()-slashPos-1);

3450 }

3451 if (name.isEmpty()) return nullptr;

3452 const FileName *fn = fnMap->find(name);

3453 if (fn)

3454 {

3455 //printf("fn->size()=%zu\n",fn->size());

3456 if (fn->size()==1)

3457 {

3458 const std::unique_ptr<FileDef> &fd = fn->front();

3459 bool isSamePath = Portable::fileSystemIsCaseSensitive() ?

3460 fd->getPath().right(path.length())==path :

3461 fd->getPath().right(path.length()).lower()==path.lower();

3462 if (path.isEmpty() || isSamePath)

3463 {

3464 cachedResult->fileDef = fd.get();

3465 return fd.get();

3466 }

3467 }

3468 else // file name alone is ambiguous

3469 {

3470 int count=0;

3471 FileDef *lastMatch=nullptr;

3472 QCString pathStripped = stripFromIncludePath(path);

3473 for (const auto &fd_p : *fn)

3474 {

3475 FileDef *fd = fd_p.get();

3476 QCString fdStripPath = stripFromIncludePath(fd->getPath());

3477 if (path.isEmpty() || fdStripPath.right(pathStripped.length())==pathStripped)

3478 {

3479 count++;

3480 lastMatch=fd;

3481 }

3482 }

3483

3484 ambig=(count>1);

3485 cachedResult->isAmbig = ambig;

3486 cachedResult->fileDef = lastMatch;

3487 return lastMatch;

3488 }

3489 }

3490 else

3491 {

3492 //printf("not found!\n");

3493 }

3494 return nullptr;

3495}

References Dir::cleanDirPath, FALSE, FindFileCacheElem::fileDef, Portable::fileSystemIsCaseSensitive, LinkedMap< T, Hash, KeyEqual, Map >::find, QCString::findRev, g_findFileDefCache, g_findFileDefMutex, FileDef::getPath, FindFileCacheElem::isAmbig, QCString::isEmpty, QCString::left, QCString::length, QCString::lower, qsnprintf, removeLongPathMarker, QCString::right, QCString::str and stripFromIncludePath.

Referenced by addIncludeFile, buildFileList, checkMarkdownMainfile, DocParser::findAndCopyImage, DocParser::findDocsForMemberOrCompound, findFile, findFilePath, generateFileRef, generateFileSources, DocParser::handleLinkedWord, DocbookDocVisitor::operator(), XmlDocVisitor::operator(), DocDiaFile::parse, DocDotFile::parse, DocMscFile::parse, DocPlantUmlFile::parse, parseFilesMultiThreading, parseFilesSingleThreading, Markdown::Private::processLink, readIncludeFile, readTextFileByName, ModuleManager::resolveImports, resolveLink, ModuleManager::resolvePartitions, resolveRef and setFileName.

findFilePath()

QCString findFilePath (const QCString & file, bool & ambig)

Declaration at line 202 of file util.h, definition at line 3499 of file util.cpp.

3499QCString findFilePath(const QCString &file,bool &ambig)

3500{

3501 ambig=false;

3502 QCString result;

3503 bool found=false;

3504 if (!found)

3505 {

3506 FileInfo fi(file.str());

3507 if (fi.exists())

3508 {

3509 result=fi.absFilePath();

3510 found=true;

3511 }

3512 }

3513 if (!found)

3514 {

3515 const StringVector &examplePathList = Config_getList(EXAMPLE_PATH);

3516 for (const auto &s : examplePathList)

3517 {

3518 std::string absFileName = s+(Portable::pathSeparator()+file).str();

3519 FileInfo fi(absFileName);

3520 if (fi.exists())

3521 {

3522 result=fi.absFilePath();

3523 found=true;

3524 }

3525 }

3526 }

3527

3528 if (!found)

3529 {

3530 // as a fallback we also look in the exampleNameDict

3531 FileDef *fd = findFileDef(Doxygen::exampleNameLinkedMap,file,ambig);

3532 if (fd && !ambig)

3533 {

3534 result=fd->absFilePath();

3535 }

3536 }

3537 return result;

3538}

References FileDef::absFilePath, FileInfo::absFilePath, Config_getList, Doxygen::exampleNameLinkedMap, FileInfo::exists, findFileDef, Portable::pathSeparator and QCString::str.

Referenced by readIncludeFile and DocParser::readTextFileByName.

findIndex()

int findIndex (const StringVector & sv, const std::string & s)

find the index of a string in a vector of strings, returns -1 if the string could not be found

Declaration at line 460 of file util.h, definition at line 7169 of file util.cpp.

7169int findIndex(const StringVector &sv,const std::string &s)

7170{

7171 auto it = std::find(sv.begin(),sv.end(),s);

7172 return it!=sv.end() ? static_cast<int>(it-sv.begin()) : -1;

7173}

Referenced by initUCF, VhdlDocGen::parseForBinding, VhdlDocGen::parseUCF, DotFilePatcher::run and VhdlDocGen::writeFormatString.

findIndex()

int findIndex (const std::string & s, const reg::Ex & re)

find the index of the first occurrence of pattern re in a string s returns -1 if the pattern could not be found

Declaration at line 461 of file util.h, definition at line 7177 of file util.cpp.

7177int findIndex(const std::string &s,const reg::Ex &re)

7178{

7179 reg::Match match;

7180 return reg::search(s,match,re) ? static_cast<int>(match.position()) : -1;

7181}

Reference reg::search.

fixSpaces()

QCString fixSpaces (const QCString & s)

inline

Definition at line 472 of file util.h.

472inline QCString fixSpaces(const QCString &s) { return substitute(s," "," "); }

Reference substitute.

Referenced by renderQuickLinksAsTabs, renderQuickLinksAsTree, writeClassMemberIndexFiltered, writeFileMemberIndexFiltered, writeModuleMemberIndexFiltered, writeNamespaceMemberIndexFiltered and writeUserGroupStubPage.

generateAnonymousAnchor()

QCString generateAnonymousAnchor (const QCString & fileName, int count)

Declaration at line 263 of file util.h, definition at line 4075 of file util.cpp.

4075QCString generateAnonymousAnchor(const QCString &fileName,int count)

4076{

4077 QCString fn = stripFromPath(fileName)+":"+QCString().setNum(count);

4078 const int sig_size=16;

4079 uint8_t md5_sig[sig_size];

4080 MD5Buffer(fn.data(),static_cast<unsigned int>(fn.length()),md5_sig);

4081 char result[sig_size*3+2];

4082 char *p = result;

4083 *p++='@';

4084 for (int i=0;i<sig_size;i++)

4085 {

4086 static const char oct[]="01234567";

4087 uint8_t byte = md5_sig[i];

4088 *p++=oct[(byte>>6)&7];

4089 *p++=oct[(byte>>3)&7];

4090 *p++=oct[(byte>>0)&7];

4091 }

4092 *p='\0';

4093 return result;

4094}

References QCString::data, QCString::length, QCString::setNum and stripFromPath.

generateFileRef()

void generateFileRef (OutputList & ol, const QCString & name, const QCString & linkTxt=QCString())

Declaration at line 158 of file util.h, definition at line 3388 of file util.cpp.

3388void generateFileRef(OutputList &ol,const QCString &name,const QCString &text)

3389{

3390 //printf("generateFileRef(%s,%s)\n",name,text);

3391 QCString linkText = text.isEmpty() ? text : name;

3392 //FileInfo *fi;

3393 bool ambig = false;

3394 FileDef *fd = findFileDef(Doxygen::inputNameLinkedMap,name,ambig);

3395 if (fd && fd->isLinkable())

3396 // link to documented input file

3397 ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),QCString(),linkText);

3398 else

3399 ol.docify(linkText);

3400}

References OutputList::docify, findFileDef, Definition::getOutputFileBase, Definition::getReference, Doxygen::inputNameLinkedMap, QCString::isEmpty, Definition::isLinkable and OutputList::writeObjectLink.

generateMarker()

QCString generateMarker (int id)

Generate a place holder for a position in a list. Used for translators to be able to specify different elements orders depending on whether text flows from left to right or visa versa.

Declaration at line 226 of file util.h, definition at line 291 of file util.cpp.

291QCString generateMarker(int id)

292{

293 const int maxMarkerStrLen = 20;

294 char result[maxMarkerStrLen];

295 qsnprintf(result,maxMarkerStrLen,"@%d",id);

296 return result;

297}

Reference qsnprintf.

getCaseSenseNames()

bool getCaseSenseNames ()

Declaration at line 335 of file util.h, definition at line 3837 of file util.cpp.

3837bool getCaseSenseNames()

3838{

3839 auto caseSenseNames = Config_getEnum(CASE_SENSE_NAMES);

3840

3841 if (caseSenseNames == CASE_SENSE_NAMES_t::YES) return true;

3842 else if (caseSenseNames == CASE_SENSE_NAMES_t::NO) return false;

3843 else return Portable::fileSystemIsCaseSensitive();

3844}

References Config_getEnum and Portable::fileSystemIsCaseSensitive.

Referenced by escapeCharsInString, genericPatternMatch, FileNameFn::searchKey and unescapeCharsInString.

getDefs()

GetDefResult getDefs (const GetDefInput & input)

Declaration at line 134 of file util.h, definition at line 2823 of file util.cpp.

2823GetDefResult getDefs(const GetDefInput &input)

2824{

2825 if (false) // set this to true to try the old and new routine side-by-side and compare the results

2826 {

2827 printf("@@ ------ getDefsOld start\n");

2828 GetDefResult result = getDefsOld(input);

2829 printf("@@ ------ getDefsOld end\n");

2830 printf("@@ ------ getDefsNew start\n");

2831 GetDefResult newResult = getDefsNew(input);

2832 printf("@@ ------ getDefsNew end\n");

2833 if (result.found!=newResult.found ||

2834 result.md!=newResult.md ||

2835 result.cd!=newResult.cd ||

2836 result.fd!=newResult.fd ||

2837 result.nd!=newResult.nd ||

2838 result.gd!=newResult.gd

2839 )

2840 {

2841 printf("@@ getDefsOld(scName=%s, mbName=%s, args=%s, forceEmptyScope=%d "

2842 "currentFile=%s checkCV=%d)=%d md=%s (%p) cd=%s fd=%s nd=%s gd=%s\n",

2843 qPrint(input.scopeName), qPrint(input.memberName), qPrint(input.args),

2844 input.forceEmptyScope, qPrint(input.currentFile?input.currentFile->name():QCString()),

2845 input.checkCV,

2846 result.found,

2847 qPrint(result.md ? result.md->name() : QCString()),

2848 (void*)result.md,

2849 qPrint(result.cd ? result.cd->name() : QCString()),

2850 qPrint(result.fd ? result.fd->name() : QCString()),

2851 qPrint(result.nd ? result.nd->name() : QCString()),

2852 qPrint(result.gd ? result.gd->name() : QCString())

2853 );

2854 printf("@@ ------ getDefsOld start\n");

2855 printf("@@ getDefsNew(scName=%s, mbName=%s, args=%s, forceEmptyScope=%d "

2856 "currentFile=%s checkCV=%d)=%d md=%s (%p) cd=%s fd=%s nd=%s gd=%s\n",

2857 qPrint(input.scopeName), qPrint(input.memberName), qPrint(input.args),

2858 input.forceEmptyScope, qPrint(input.currentFile?input.currentFile->name():QCString()),

2859 input.checkCV,

2860 newResult.found,

2861 qPrint(newResult.md ? newResult.md->name() : QCString()),

2862 (void*)newResult.md,

2863 qPrint(newResult.cd ? newResult.cd->name() : QCString()),

2864 qPrint(newResult.fd ? newResult.fd->name() : QCString()),

2865 qPrint(newResult.nd ? newResult.nd->name() : QCString()),

2866 qPrint(newResult.gd ? newResult.gd->name() : QCString())

2867 );

2868 }

2869 return result; // use return newResult to use the result of the new routine

2870 }

2871 else // do one of the two getDefs routines (comment out the other one)

2872 {

2873 return getDefsNew(input);

2874 }

2875}

References GetDefInput::args, GetDefResult::cd, GetDefInput::checkCV, GetDefInput::currentFile, GetDefResult::fd, GetDefInput::forceEmptyScope, GetDefResult::found, GetDefResult::gd, getDefsNew, getDefsOld, GetDefResult::md, GetDefInput::memberName, Definition::name, GetDefResult::nd, qPrint and GetDefInput::scopeName.

Referenced by DocParser::findDocsForMemberOrCompound, getLinkInScope, getLinkInScope, linkifyText and resolveRef.

getDotImageExtension()

QCString getDotImageExtension ()

Declaration at line 442 of file util.h, definition at line 6804 of file util.cpp.

6804QCString getDotImageExtension()

6805{

6806 QCString imgExt = Config_getEnumAsString(DOT_IMAGE_FORMAT);

6807 int i= imgExt.find(':'); // strip renderer part when using e.g. 'png:cairo:gd' as format

6808 return i==-1 ? imgExt : imgExt.left(i);

6809}

References Config_getEnumAsString, QCString::find and QCString::left.

getEncoding()

QCString getEncoding (const FileInfo & fi)

Declaration at line 470 of file util.h, definition at line 6212 of file util.cpp.

6212QCString getEncoding(const FileInfo &fi)

6213{

6214 InputFileEncoding elem;

6215 auto getter = [](const InputFileEncoding &e) { return e.pattern; };

6216 if (genericPatternMatch(fi,Doxygen::inputFileEncodingList,elem,getter)) // check for file specific encoding

6217 {

6218 return elem.encoding;

6219 }

6220 else // fall back to default encoding

6221 {

6222 return Config_getString(INPUT_ENCODING);

6223 }

6224}

References Config_getString, InputFileEncoding::encoding, genericPatternMatch and Doxygen::inputFileEncodingList.

Referenced by readCodeFragment and readInputFile.

getFileFilter()

QCString getFileFilter (const QCString & name, bool isSourceCode)

looks for a filter for the file name. Returns the name of the filter if there is a match for the file name, otherwise an empty string. In case inSourceCode is TRUE then first the source filter list is considered.

Declaration at line 136 of file util.h, definition at line 1370 of file util.cpp.

1370QCString getFileFilter(const QCString &name,bool isSourceCode)

1371{

1372 // sanity check

1373 if (name.isEmpty()) return "";

1374

1375 const StringVector& filterSrcList = Config_getList(FILTER_SOURCE_PATTERNS);

1376 const StringVector& filterList = Config_getList(FILTER_PATTERNS);

1377

1378 QCString filterName;

1379 bool found=FALSE;

1380 if (isSourceCode && !filterSrcList.empty())

1381 { // first look for source filter pattern list

1382 filterName = getFilterFromList(name,filterSrcList,found);

1383 }

1384 if (!found && filterName.isEmpty())

1385 { // then look for filter pattern list

1386 filterName = getFilterFromList(name,filterList,found);

1387 }

1388 if (!found)

1389 { // then use the generic input filter

1390 return Config_getString(INPUT_FILTER);

1391 }

1392 else

1393 {

1394 /* remove surrounding double quotes */

1395 if (filterName.length()>=2 && filterName[0]=='"' && filterName[static_cast<int>(filterName.length())-1]=='"')

1396 {

1397 filterName = filterName.mid(1,filterName.length()-2);

1398 }

1399 return filterName;

1400 }

1401}

References Config_getList, Config_getString, FALSE, getFilterFromList, QCString::isEmpty, QCString::length and QCString::mid.

Referenced by FilterCache::getFileContents, CodeFragmentManager::parseCodeFragment, readCodeFragment, readInputFile and FileDefImpl::writeSourceBody.

getFileNameExtension()

QCString getFileNameExtension (const QCString & fn)

Declaration at line 376 of file util.h, definition at line 5764 of file util.cpp.

5764QCString getFileNameExtension(const QCString &fn)

5765{

5766 if (fn.isEmpty()) return "";

5767 int lastDot = fn.findRev('.');

5768 if (lastDot!=-1) return fn.mid(lastDot);

5769 return "";

5770}

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

Referenced by TooltipManager::addTooltip, anonymous{tagreader.cpp}::TagFileParser::buildLists, convertFileNameFortranParserCode, generateExampleDocs, FileDefImpl::isDocumentationFile, DocbookDocVisitor::operator(), HtmlDocVisitor::operator(), LatexDocVisitor::operator(), ManDocVisitor::operator(), RTFDocVisitor::operator(), XmlDocVisitor::operator(), CodeFragmentManager::parseCodeFragment and MarkdownOutlineParser::parseInput.

getLanguageFromCodeLang()

SrcLangExt getLanguageFromCodeLang (QCString & fileName)

Routine to handle the language attribute of the \code command.

Declaration at line 375 of file util.h, definition at line 5740 of file util.cpp.

5740SrcLangExt getLanguageFromCodeLang(QCString &fileName)

5741{

5742 // try the extension

5743 auto lang = getLanguageFromFileName(fileName, SrcLangExt::Unknown);

5744 if (lang == SrcLangExt::Unknown)

5745 {

5746 // try the language names

5747 QCString langName = fileName.lower();

5748 if (langName.at(0)=='.') langName = langName.mid(1);

5749 auto it = std::find_if(g_lang2extMap.begin(),g_lang2extMap.end(),

5750 [&langName](const auto &info) { return info.langName==langName; });

5751 if (it != g_lang2extMap.end())

5752 {

5753 lang = it->parserId;

5754 fileName = it->defExt;

5755 }

5756 else // default to C++

5757 {

5758 return SrcLangExt::Cpp;

5759 }

5760 }

5761 return lang;

5762}

References QCString::at, g_lang2extMap, getLanguageFromFileName, QCString::lower and QCString::mid.

Referenced by DocbookDocVisitor::operator(), HtmlDocVisitor::operator(), LatexDocVisitor::operator(), ManDocVisitor::operator(), RTFDocVisitor::operator() and XmlDocVisitor::operator().

getLanguageFromFileName()

SrcLangExt getLanguageFromFileName (const QCString & fileName, SrcLangExt defLang=SrcLangExt::Cpp)

Declaration at line 374 of file util.h, definition at line 5722 of file util.cpp.

5722SrcLangExt getLanguageFromFileName(const QCString& fileName, SrcLangExt defLang)

5723{

5724 FileInfo fi(fileName.str());

5725 // we need only the part after the last ".", newer implementations of FileInfo have 'suffix()' for this.

5726 QCString extName = QCString(fi.extension(FALSE)).lower();

5727 if (extName.isEmpty()) extName=".no_extension";

5728 if (extName.at(0)!='.') extName.prepend(".");

5729 auto it = g_extLookup.find(extName.str());

5730 if (it!=g_extLookup.end()) // listed extension

5731 {

5732 //printf("getLanguageFromFileName(%s)=%x\n",qPrint(fi.extension()),*pVal);

5733 return it->second;

5734 }

5735 //printf("getLanguageFromFileName(%s) not found!\n",qPrint(fileName));

5736 return defLang; // not listed => assume C-ish language.

5737}

References QCString::at, FileInfo::extension, FALSE, g_extLookup, QCString::isEmpty, QCString::lower, QCString::prepend and QCString::str.

getLanguageSpecificSeparator()

QCString getLanguageSpecificSeparator (SrcLangExt lang, bool classScope=FALSE)

Returns the scope separator to use given the programming language lang.

Declaration at line 92 of file util.h, definition at line 6414 of file util.cpp.

6414QCString getLanguageSpecificSeparator(SrcLangExt lang,bool classScope)

6415{

6416 if (lang==SrcLangExt::Java || lang==SrcLangExt::CSharp || lang==SrcLangExt::VHDL || lang==SrcLangExt::Python)

6417 {

6418 return ".";

6419 }

6420 else if (lang==SrcLangExt::PHP && !classScope)

6421 {

6422 return "\\";

6423 }

6424 else

6425 {

6426 return "::";

6427 }

6428}

Referenced by DefinitionImpl::_writeSourceRefList, addGlobalFunction, MemberDefImpl::addListReference, addMethodToClass, addVariableToFile, MemberDefImpl::displayDefinition, DefinitionAliasImpl::init, linkToText, makeDisplayName, makeDisplayName, makeQualifiedNameWithTemplateParameters, ClassDefImpl::mergeMembersFromBaseClasses, DefinitionImpl::qualifiedName, MemberDefImpl::qualifiedName, SearchIndex::setCurrentDoc, validatingParseDoc, MemberDefImpl::warnIfUndocumented, writeAlphabeticalClassList, MemberDefImpl::writeDeclaration, writeDefArgumentList, MemberDefImpl::writeDocumentation, writeJavasScriptSearchDataPage, MemberDefImpl::writeLink and writeMemberReference.

getOverloadDocs()

QCString getOverloadDocs ()

Returns the standard string that is generated when the \overload command is used.

Declaration at line 282 of file util.h, definition at line 4603 of file util.cpp.

4603QCString getOverloadDocs()

4604{

4605 return theTranslator->trOverloadText();

4606 //"This is an overloaded member function, "

4607 // "provided for convenience. It differs from the above "

4608 // "function only in what argument(s) it accepts.";

4609}

Reference theTranslator.

Referenced by addMemberDocs, addOverloaded and CommentScanner::parseCommentBlock.

getPrefixIndex()

int getPrefixIndex (const QCString & name)

Returns the character index within name of the first prefix in Config_getList(IGNORE_PREFIX) that matches name at the left hand side, or zero if no match was found

Declaration at line 255 of file util.h, definition at line 3753 of file util.cpp.

3753int getPrefixIndex(const QCString &name)

3754{

3755 if (name.isEmpty()) return 0;

3756 const StringVector &sl = Config_getList(IGNORE_PREFIX);

3757 for (const auto &s : sl)

3758 {

3759 const char *ps=s.c_str();

3760 const char *pd=name.data();

3761 int i=0;

3762 while (*ps!=0 && *pd!=0 && *ps==*pd) ps++,pd++,i++;

3763 if (*ps==0 && *pd!=0)

3764 {

3765 return i;

3766 }

3767 }

3768 return 0;

3769}

References Config_getList, QCString::data and QCString::isEmpty.

Referenced by Index::addClassMemberNameToIndex, Index::addFileMemberNameToIndex, Index::addModuleMemberNameToIndex, Index::addNamespaceMemberNameToIndex, SearchIndex::addWordRec, parseInput, writeAlphabeticalClassList and writeMemberList.

getProjectId()

QCString getProjectId ()

Declaration at line 476 of file util.h, definition at line 7326 of file util.cpp.

7326QCString getProjectId()

7327{

7328 QCString projectCookie = Config_getString(HTML_PROJECT_COOKIE);

7329 if (projectCookie.isEmpty()) return QCString();

7330 uint8_t md5_sig[16];

7331 char sigStr[34];

7332 MD5Buffer(projectCookie.data(),static_cast<unsigned int>(projectCookie.length()),md5_sig);

7333 MD5SigToString(md5_sig,sigStr);

7334 sigStr[32]='_'; sigStr[33]=0;

7335 return sigStr;

7336}

References Config_getString, QCString::data, QCString::isEmpty and QCString::length.

Referenced by generateJSNavTree, HtmlGenerator::init and writeJavaScriptSearchIndex.

getScopeFragment()

int getScopeFragment (const QCString & s, int p, int * l)

Returns a fragment from scope s, starting at position p.

Parameters

s	the scope name as a string.
p	the start position (0 is the first).
l	the resulting length of the fragment.

Returns: the location of the fragment, or -1 if non is found.

Declaration at line 312 of file util.h, definition at line 5142 of file util.cpp.

5142int getScopeFragment(const QCString &s,int p,int *l)

5143{

5144 int sl=static_cast<int>(s.length());

5145 int sp=p;

5146 int count=0;

5147 bool done=false;

5148 if (sp>=sl) return -1;

5149 while (sp<sl)

5150 {

5151 char c=s.at(sp);

5152 if (c==':') sp++,p++; else break;

5153 }

5154 while (sp<sl)

5155 {

5156 char c=s.at(sp);

5157 switch (c)

5158 {

5159 case ':': // found next part

5160 goto found;

5161 case '<': // skip template specifier

5162 count=1;sp++;

5163 done=false;

5164 while (sp<sl && !done)

5165 {

5166 // TODO: deal with << and >> operators!

5167 c=s.at(sp++);

5168 switch(c)

5169 {

5170 case '<': count++; break;

5171 case '>': count--; if (count==0) done=true; break;

5172 default: break;

5173 }

5174 }

5175 break;

5176 default:

5177 sp++;

5178 break;

5179 }

5180 }

5181found:

5182 *l=sp-p;

5183 //printf("getScopeFragment(%s,%d)=%s\n",qPrint(s),p,qPrint(s.mid(p,*l)));

5184 return p;

5185}

References QCString::at and QCString::length.

Referenced by buildScopeFromQualifiedName, findScopeFromQualifiedName, SymbolResolver::Private::followPath, resolveTypeDef and stripAnonymousNamespaceScope.

guessSection()

EntryType guessSection (const QCString & name)

try to determine if name is a source or a header file name by looking at the extension. A number of variations is allowed in both upper and lower case) If anyone knows or uses another extension please let me know :-)

Declaration at line 206 of file util.h, definition at line 350 of file util.cpp.

350EntryType guessSection(const QCString &name)

351{

352 QCString n=name.lower();

353 static const std::unordered_set<std::string> sourceExt = {

354 "c","cc","cxx","cpp","c++","cppm","ccm","cxxm","c++m", // C/C++

355 "java", // Java

356 "cs", // C#

357 "m","mm", // Objective-C

358 "ii","ixx","ipp","i++","inl", // C/C++ inline

359 "xml","lex","sql" // others

360 };

361 static const std::unordered_set<std::string> headerExt = {

362 "h", "hh", "hxx", "hpp", "h++", "ixx", // C/C++ header

363 "idl", "ddl", "pidl", "ice" // IDL like

364 };

365 int lastDot = n.findRev('.');

366 if (lastDot!=-1)

367 {

368 QCString extension = n.mid(lastDot+1); // part after the last dot

369 if (sourceExt.find(extension.str())!=sourceExt.end())

370 {

371 return EntryType::makeSource();

372 }

373 if (headerExt.find(extension.str())!=headerExt.end())

374 {

375 return EntryType::makeHeader();

376 }

377 }

378 else

379 {

380 if (getLanguageFromFileName(name,SrcLangExt::Unknown) == SrcLangExt::Cpp) return EntryType::makeHeader();

381 }

382 return EntryType::makeEmpty();

383}

References QCString::findRev, getLanguageFromFileName, QCString::lower, QCString::mid and QCString::str.

Referenced by addIncludeFile, anonymous{tagreader.cpp}::TagFileParser::buildLists, ClassDefImpl::ClassDefImpl, computeClassRelations, FileDefImpl::FileDefImpl, FileDefImpl::generateSourceFile, parseMain, parseMain, Preprocessor::processFile, setFileName and warnUndocumentedNamespaces.

initDefaultExtensionMapping()

void initDefaultExtensionMapping ()

Declaration at line 377 of file util.h, definition at line 5649 of file util.cpp.

5649void initDefaultExtensionMapping()

5650{

5651 // NOTE: when adding an extension, also add the extension in config.xml

5652 // extension parser id

5653 updateLanguageMapping(".dox", "c");

5654 updateLanguageMapping(".txt", "c"); // see bug 760836

5655 updateLanguageMapping(".doc", "c");

5656 updateLanguageMapping(".c", "c");

5657 updateLanguageMapping(".C", "c");

5658 updateLanguageMapping(".cc", "c");

5659 updateLanguageMapping(".CC", "c");

5660 updateLanguageMapping(".cxx", "c");

5661 updateLanguageMapping(".cpp", "c");

5662 updateLanguageMapping(".c++", "c");

5663 updateLanguageMapping(".cxxm", "c"); // C++20 modules

5664 updateLanguageMapping(".cppm", "c"); // C++20 modules

5665 updateLanguageMapping(".ccm", "c"); // C++20 modules

5666 updateLanguageMapping(".c++m", "c"); // C++20 modules

5667 updateLanguageMapping(".ii", "c");

5668 updateLanguageMapping(".ixx", "c");

5669 updateLanguageMapping(".ipp", "c");

5670 updateLanguageMapping(".i++", "c");

5671 updateLanguageMapping(".inl", "c");

5672 updateLanguageMapping(".h", "c");

5673 updateLanguageMapping(".H", "c");

5674 updateLanguageMapping(".hh", "c");

5675 updateLanguageMapping(".HH", "c");

5676 updateLanguageMapping(".hxx", "c");

5677 updateLanguageMapping(".hpp", "c");

5678 updateLanguageMapping(".h++", "c");

5679 updateLanguageMapping(".idl", "idl");

5680 updateLanguageMapping(".ddl", "idl");

5681 updateLanguageMapping(".odl", "idl");

5682 updateLanguageMapping(".java", "java");

5683 //updateLanguageMapping(".as", "javascript"); // not officially supported

5684 //updateLanguageMapping(".js", "javascript"); // not officially supported

5685 updateLanguageMapping(".cs", "csharp");

5686 updateLanguageMapping(".d", "d");

5687 updateLanguageMapping(".php", "php");

5688 updateLanguageMapping(".php4", "php");

5689 updateLanguageMapping(".php5", "php");

5690 updateLanguageMapping(".inc", "php");

5691 updateLanguageMapping(".phtml", "php");

5692 updateLanguageMapping(".m", "objective-c");

5693 updateLanguageMapping(".M", "objective-c");

5694 updateLanguageMapping(".mm", "c"); // see bug746361

5695 updateLanguageMapping(".py", "python");

5696 updateLanguageMapping(".pyw", "python");

5697 updateLanguageMapping(".f", "fortran");

5698 updateLanguageMapping(".for", "fortran");

5699 updateLanguageMapping(".f90", "fortran");

5700 updateLanguageMapping(".f95", "fortran");

5701 updateLanguageMapping(".f03", "fortran");

5702 updateLanguageMapping(".f08", "fortran");

5703 updateLanguageMapping(".f18", "fortran");

5704 updateLanguageMapping(".vhd", "vhdl");

5705 updateLanguageMapping(".vhdl", "vhdl");

5706 updateLanguageMapping(".ucf", "vhdl");

5707 updateLanguageMapping(".qsf", "vhdl");

5708 updateLanguageMapping(".md", "md");

5709 updateLanguageMapping(".markdown", "md");

5710 updateLanguageMapping(".ice", "slice");

5711 updateLanguageMapping(".l", "lex");

5712 updateLanguageMapping(".doxygen_lex_c", "c"); // this is a placeholder so we can map initializations

5713 // in the lex scanning to cpp

5714}

Reference updateLanguageMapping.

Referenced by initDoxygen.

inlineArgListToDoc()

QCString inlineArgListToDoc (const ArgumentList & al)

Declaration at line 219 of file util.h, definition at line 1157 of file util.cpp.

1157QCString inlineArgListToDoc(const ArgumentList &al)

1158{

1159 QCString paramDocs;

1160 if (al.hasDocumentation())

1161 {

1162 for (const Argument &a : al)

1163 {

1164 if (a.hasDocumentation())

1165 {

1166 QCString docsWithoutDir = a.docs;

1167 QCString direction = extractDirection(docsWithoutDir);

1168 paramDocs+=" \\ilinebr @param"+direction+" "+a.name+" "+docsWithoutDir;

1169 }

1170 }

1171 }

1172 return paramDocs;

1173}

References extractDirection and ArgumentList::hasDocumentation.

Referenced by DocParser::processCopyDoc and MemberDefImpl::writeDocumentation.

inlineTemplateArgListToDoc()

QCString inlineTemplateArgListToDoc (const ArgumentList & al)

Declaration at line 220 of file util.h, definition at line 1175 of file util.cpp.

1175QCString inlineTemplateArgListToDoc(const ArgumentList &al)

1176{

1177 QCString paramDocs;

1178 if (al.hasTemplateDocumentation())

1179 {

1180 for (const Argument &a : al)

1181 {

1182 if (!a.docs.isEmpty())

1183 {

1184 if (!a.name.isEmpty())

1185 {

1186 paramDocs+=" \\ilinebr @tparam "+a.name+" "+a.docs;

1187 }

1188 else if (!a.type.isEmpty())

1189 {

1190 QCString type = a.type;

1191 type.stripPrefix("class ");

1192 type.stripPrefix("typename ");

1193 type = type.stripWhiteSpace();

1194 paramDocs+=" \\ilinebr @tparam "+type+" "+a.docs;

1195 }

1196 }

1197 }

1198 }

1199 return paramDocs;

1200}

References ArgumentList::hasTemplateDocumentation, QCString::stripPrefix and QCString::stripWhiteSpace.

Referenced by ClassDefImpl::writeDetailedDocumentationBody and MemberDefImpl::writeDocumentation.

insertTemplateSpecifierInScope()

QCString insertTemplateSpecifierInScope (const QCString & scope, const QCString & templ)

Declaration at line 269 of file util.h, definition at line 4263 of file util.cpp.

4263QCString insertTemplateSpecifierInScope(const QCString &scope,const QCString &templ)

4264{

4265 QCString result=scope;

4266 if (!templ.isEmpty() && scope.find('<')==-1)

4267 {

4268 int si=0, pi=0;

4269 ClassDef *cd=nullptr;

4270 while (

4271 (si=scope.find("::",pi))!=-1 && !getClass(scope.left(si)+templ) &&

4272 ((cd=getClass(scope.left(si)))==nullptr || cd->templateArguments().empty())

4273 )

4274 {

4275 //printf("Tried '%s'\n",qPrint((scope.left(si)+templ)));

4276 pi=si+2;

4277 }

4278 if (si==-1) // not nested => append template specifier

4279 {

4280 result+=templ;

4281 }

4282 else // nested => insert template specifier before after first class name

4283 {

4284 result=scope.left(si) + templ + scope.right(scope.length()-si);

4285 }

4286 }

4287 //printf("insertTemplateSpecifierInScope('%s','%s')=%s\n",

4288 // qPrint(scope),qPrint(templ),qPrint(result));

4289 return result;

4290}

References ArgumentList::empty, QCString::find, getClass, QCString::isEmpty, QCString::left, QCString::length, QCString::right and ClassDef::templateArguments.

Referenced by DotClassGraph::addClass, generateXMLForClass, DiagramItem::label, ClassDefImpl::writeInheritanceGraph and ClassDefImpl::writeTagFile.

integerToAlpha()

QCString integerToAlpha (int n, bool upper=true)

Declaration at line 467 of file util.h, definition at line 7197 of file util.cpp.

7197QCString integerToAlpha(int n, bool upper)

7198{

7199 QCString result;

7200 int residual = n;

7201

7202 char modVal[2];

7203 modVal[1] = 0;

7204 while (residual > 0)

7205 {

7206 modVal[0] = (upper ? 'A': 'a') + (residual-1)%26;

7207 result = modVal + result;

7208 residual = (residual-1) / 26;

7209 }

7210 return result;

7211}

Referenced by ManDocVisitor::operator() and RTFDocVisitor::operator().

integerToRoman()

QCString integerToRoman (int n, bool upper=true)

Declaration at line 468 of file util.h, definition at line 7213 of file util.cpp.

7213QCString integerToRoman(int n, bool upper)

7214{

7215 static const char *str_romans_upper[] = { "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I" };

7216 static const char *str_romans_lower[] = { "m", "cm", "d", "cd", "c", "xc", "l", "xl", "x", "ix", "v", "iv", "i" };

7217 static const int values[] = { 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 };

7218 static const char **str_romans = upper ? str_romans_upper : str_romans_lower;

7219

7220 QCString result;

7221 int residual = n;

7222

7223 for (int i = 0; i < 13; ++i)

7224 {

7225 while (residual - values[i] >= 0)

7226 {

7227 result += str_romans[i];

7228 residual -= values[i];

7229 }

7230 }

7231

7232 return result;

7233}

Referenced by LatexDocVisitor::operator(), ManDocVisitor::operator() and RTFDocVisitor::operator().

isId()

bool isId (int c)

inline

Definition at line 208 of file util.h.

208inline bool isId(int c)

209{

210 return c=='_' || c>=128 || c<0 || isalnum(c) || c=='$';

211}

Referenced by addTemplateNames, SearchIndexExternal::addWord, convertToHtml, convertToXML, MemberDefImpl::displayDefinition, escapeId, filterLatexString, findEndOfCommand, getNextId, matchExcludedSymbols, nameIsOperator, processConcatOperators, removeIdsAndMarkers, removeRedundantWhiteSpace, replaceAliases, splitKnRArg, splitSearchTokens, startsWithKeyword, stripIrrelevantString, substituteTemplateArgumentsInString, tempArgListToString, MemberDefImpl::writeDocumentation and PlantumlManager::writePlantUMLSource.

isIdJS()

bool isIdJS (int c)

inline

Definition at line 212 of file util.h.

212inline bool isIdJS(int c)

213{

214 return c>=128 || c<0 || isalnum(c);

215}

Referenced by SearchTerm::termEncoded.

isURL()

bool isURL (const QCString & url)

Checks whether the given url starts with a supported protocol.

Declaration at line 431 of file util.h, definition at line 6430 of file util.cpp.

6430bool isURL(const QCString &url)

6431{

6432 static const std::unordered_set<std::string> schemes = {

6433 "http", "https", "ftp", "ftps", "sftp", "file", "news", "irc", "ircs"

6434 };

6435 QCString loc_url = url.stripWhiteSpace();

6436 int colonPos = loc_url.find(':');

6437 return colonPos!=-1 && schemes.find(loc_url.left(colonPos).str())!=schemes.end();

6438}

References QCString::find, QCString::left, QCString::str and QCString::stripWhiteSpace.

Referenced by correctURL, Markdown::Private::processLink and renderQuickLinksAsJs.

join()

std::string join (const StringVector & s, const std::string & delimiter)

create a string where the string in the vector are joined by the given delimiter

Declaration at line 462 of file util.h, definition at line 7184 of file util.cpp.

7184std::string join(const StringVector &sv,const std::string &delimiter)

7185{

7186 std::string result;

7187 bool first=true;

7188 for (const auto &s : sv)

7189 {

7190 if (!first) result+=delimiter;

7191 first=false;

7192 result+=s;

7193 }

7194 return result;

7195}

Referenced by handleAnchor, handleCite, handleFormatBlock and handleImage.

langToString()

QCString langToString (SrcLangExt lang)

Returns a string representation of lang.

Declaration at line 91 of file util.h, definition at line 6408 of file util.cpp.

6408QCString langToString(SrcLangExt lang)

6409{

6410 return to_string(lang);

6411}

Reference to_string.

Referenced by buildNamespaceList, findUsingDirectives, generateXMLForClass, generateXMLForFile and generateXMLForNamespace.

leftScopeMatch()

bool leftScopeMatch (const QCString & scope, const QCString & name)

Declaration at line 238 of file util.h, definition at line 893 of file util.cpp.

893bool leftScopeMatch(const QCString &scope, const QCString &name)

894{

895 size_t sl=scope.length();

896 size_t nl=name.length();

897 return (name==scope || // equal

898 (name.left(sl)==scope && // substring

899 nl>sl+1 && name.at(sl)==':' && name.at(sl+1)==':' // scope

900 )

901 );

902}

References QCString::at, QCString::left and QCString::length.

Referenced by addClassToContext, addConceptToContext, buildFunctionList, mergeScopes, pushScope and resolveRef.

lineBlock()

int lineBlock (const QCString & text, const QCString & marker)

Returns the line number of the line following the line with the marker.

See Also: routine extractBlock

Declaration at line 429 of file util.h, definition at line 6387 of file util.cpp.

6387int lineBlock(const QCString &text,const QCString &marker)

6388{

6389 int result = 1;

6390

6391 // find the character positions of the first marker

6392 int m1 = text.find(marker);

6393 if (m1==-1) return result;

6394

6395 // find start line positions for the markers

6396 bool found=false;

6397 int p=0, i=0;

6398 while (!found && (i=text.find('\n',p))!=-1)

6399 {

6400 found = (p<=m1 && m1<i); // found the line with the start marker

6401 p=i+1;

6402 result++;

6403 }

6404 return result;

6405}

Reference QCString::find.

Referenced by readIncludeFile.

linkifyText()

void linkifyText (const TextGeneratorIntf & ol, const Definition * scope, const FileDef * fileScope, const Definition * self, const QCString & text, bool autoBreak=FALSE, bool external=TRUE, bool keepSpaces=FALSE, int indentLevel=0)

Declaration at line 96 of file util.h, definition at line 905 of file util.cpp.

905void linkifyText(const TextGeneratorIntf &out, const Definition *scope,

906 const FileDef *fileScope,const Definition *self,

907 const QCString &text, bool autoBreak,bool external,

908 bool keepSpaces,int indentLevel)

909{

910 if (text.isEmpty()) return;

911 //printf("linkify='%s'\n",qPrint(text));

912 std::string_view txtStr=text.view();

913 size_t strLen = txtStr.length();

914 if (strLen==0) return;

915

916 static const reg::Ex regExp(R"((::)?\a[\w~!\\.:$"]*)");

917 reg::Iterator it(txtStr,regExp);

918 reg::Iterator end;

919

920 //printf("linkifyText scope=%s fileScope=%s strtxt=%s strlen=%zu external=%d\n",

921 // scope ? qPrint(scope->name()):"<none>",

922 // fileScope ? qPrint(fileScope->name()) : "<none>",

923 // qPrint(txtStr),strLen,external);

924 size_t index=0;

925 size_t skipIndex=0;

926 size_t floatingIndex=0;

927 for (; it!=end ; ++it) // for each word from the text string

928 {

929 const auto &match = *it;

930 size_t newIndex = match.position();

931 size_t matchLen = match.length();

932 floatingIndex+=newIndex-skipIndex+matchLen;

933 if (newIndex>0 && txtStr.at(newIndex-1)=='0') // ignore hex numbers (match x00 in 0x00)

934 {

935 std::string_view part = txtStr.substr(skipIndex,newIndex+matchLen-skipIndex);

936 out.writeString(part,keepSpaces);

937 skipIndex=index=newIndex+matchLen;

938 continue;

939 }

940

941 // add non-word part to the result

942 bool insideString=FALSE;

943 for (size_t i=index;i<newIndex;i++)

944 {

945 if (txtStr.at(i)=='"') insideString=!insideString;

946 if (txtStr.at(i)=='\\') i++; // skip next character it is escaped

947 }

948

949 //printf("floatingIndex=%d strlen=%d autoBreak=%d\n",floatingIndex,strLen,autoBreak);

950 if (strLen>35 && floatingIndex>30 && autoBreak) // try to insert a split point

951 {

952 std::string_view splitText = txtStr.substr(skipIndex,newIndex-skipIndex);

953 size_t splitLength = splitText.length();

954 size_t offset=1;

955 size_t i = splitText.find(',');

956 if (i==std::string::npos) { i=splitText.find('<'); if (i!=std::string::npos) offset=0; }

957 if (i==std::string::npos) i=splitText.find('>');

958 if (i==std::string::npos) i=splitText.find(' ');

959 //printf("splitText=[%s] len=%d i=%d offset=%d\n",qPrint(splitText),splitLength,i,offset);

960 if (i!=std::string::npos) // add a link-break at i in case of Html output

961 {

962 std::string_view part1 = splitText.substr(0,i+offset);

963 out.writeString(part1,keepSpaces);

964 out.writeBreak(indentLevel==0 ? 0 : indentLevel+1);

965 std::string_view part2 = splitText.substr(i+offset);

966 out.writeString(part2,keepSpaces);

967 floatingIndex=splitLength-i-offset+matchLen;

968 }

969 else

970 {

971 out.writeString(splitText,keepSpaces);

972 }

973 }

974 else

975 {

976 //ol.docify(txtStr.mid(skipIndex,newIndex-skipIndex));

977 std::string_view part = txtStr.substr(skipIndex,newIndex-skipIndex);

978 out.writeString(part,keepSpaces);

979 }

980 // get word from string

981 std::string_view word=txtStr.substr(newIndex,matchLen);

982 QCString matchWord = substitute(substitute(QCString(word),"\\","::"),".","::");

983 //printf("linkifyText word=%s matchWord=%s scope=%s\n",

984 // qPrint(word),qPrint(matchWord),scope ? qPrint(scope->name()) : "<none>");

985 bool found=FALSE;

986 if (!insideString)

987 {

988 const ClassDef *cd=nullptr;

989 const ConceptDef *cnd=nullptr;

990 //printf("** Match word '%s'\n",qPrint(matchWord));

991

992 SymbolResolver resolver(fileScope);

993 cd=resolver.resolveClass(scope,matchWord);

994 const MemberDef *typeDef = resolver.getTypedef();

995 if (typeDef) // First look at typedef then class, see bug 584184

996 {

997 if (external ? typeDef->isLinkable() : typeDef->isLinkableInProject())

998 {

999 if (typeDef->getOuterScope()!=self)

1000 {

1001 //printf("Found typedef %s word='%s'\n",qPrint(typeDef->name()),qPrint(word));

1002 out.writeLink(typeDef->getReference(),

1003 typeDef->getOutputFileBase(),

1004 typeDef->anchor(),

1005 word);

1006 found=TRUE;

1007 }

1008 }

1009 }

1010 auto writeCompoundName = [&](const auto *cd_) {

1011 if (external ? cd_->isLinkable() : cd_->isLinkableInProject())

1012 {

1013 if (self==nullptr || cd_->qualifiedName()!=self->qualifiedName())

1014 {

1015 //printf("Found compound %s word='%s'\n",qPrint(cd->name()),qPrint(word));

1016 out.writeLink(cd_->getReference(),cd_->getOutputFileBase(),cd_->anchor(),word);

1017 found=TRUE;

1018 }

1019 }

1020 };

1021 if (!found && (cd || (cd=getClass(matchWord))))

1022 {

1023 writeCompoundName(cd);

1024 }

1025 else if ((cd=getClass(matchWord+"-p"))) // search for Obj-C protocols as well

1026 {

1027 writeCompoundName(cd);

1028 }

1029 else if ((cnd=getConcept(matchWord))) // search for concepts

1030 {

1031 writeCompoundName(cnd);

1032 }

1033 else

1034 {

1035 //printf(" -> nothing\n");

1036 }

1037

1038 int m = matchWord.findRev("::");

1039 QCString scopeName;

1040 if (scope &&

1041 (scope->definitionType()==Definition::TypeClass ||

1042 scope->definitionType()==Definition::TypeNamespace

1043 )

1044 )

1045 {

1046 scopeName=scope->name();

1047 }

1048 else if (m!=-1)

1049 {

1050 scopeName = matchWord.left(m);

1051 matchWord = matchWord.mid(m+2);

1052 }

1053

1054 //printf("ScopeName=%s\n",qPrint(scopeName));

1055 //if (!found) printf("Trying to link '%s' in '%s'\n",qPrint(word),qPrint(scopeName));

1056 if (!found)

1057 {

1058 GetDefInput input(scopeName,matchWord,QCString());

1059 GetDefResult result = getDefs(input);

1060 if (result.found && result.md &&

1061 (external ? result.md->isLinkable() : result.md->isLinkableInProject())

1062 )

1063 {

1064 //printf("Found ref scope=%s\n",d ? qPrint(d->name()) : "<global>");

1065 //ol.writeObjectLink(d->getReference(),d->getOutputFileBase(),

1066 // md->anchor(),word);

1067 if (result.md!=self && (self==nullptr || result.md->name()!=self->name()))

1068 // name check is needed for overloaded members, where getDefs just returns one

1069 {

1070 /* in case of Fortran scope and the variable is a non Fortran variable: don't link,

1071 * see also getLink in fortrancode.l

1072 */

1073 if (!(scope &&

1074 (scope->getLanguage() == SrcLangExt::Fortran) &&

1075 result.md->isVariable() &&

1076 (result.md->getLanguage() != SrcLangExt::Fortran)

1077 )

1078 )

1079 {

1080 //printf("found symbol %s word='%s'\n",qPrint(result.md->name()),qPrint(word));

1081 out.writeLink(result.md->getReference(),result.md->getOutputFileBase(),

1082 result.md->anchor(),word);

1083 found=TRUE;

1084 }

1085 }

1086 }

1087 }

1088 }

1089

1090 if (!found) // add word to the result

1091 {

1092 out.writeString(word,keepSpaces);

1093 }

1094 // set next start point in the string

1095 //printf("index=%d/%d\n",index,txtStr.length());

1096 skipIndex=index=newIndex+matchLen;

1097 }

1098 // add last part of the string to the result.

1099 //ol.docify(txtStr.right(txtStr.length()-skipIndex));

1100 std::string_view lastPart = txtStr.substr(skipIndex);

1101 out.writeString(lastPart,keepSpaces);

1102}

References Definition::anchor, Definition::definitionType, end, FALSE, QCString::findRev, GetDefResult::found, getClass, getConcept, getDefs, Definition::getLanguage, Definition::getOuterScope, Definition::getOutputFileBase, Definition::getReference, SymbolResolver::getTypedef, QCString::isEmpty, Definition::isLinkable, Definition::isLinkableInProject, MemberDef::isVariable, QCString::left, GetDefResult::md, QCString::mid, Definition::name, Definition::qualifiedName, SymbolResolver::resolveClass, substitute, TRUE, Definition::TypeClass, Definition::TypeNamespace, QCString::view, TextGeneratorIntf::writeBreak, TextGeneratorIntf::writeLink and TextGeneratorIntf::writeString.

Referenced by MemberDefImpl::_writeTemplatePrefix, generateSqlite3ForMember, generateXMLForClass, generateXMLForConcept, generateXMLForMember, insertMemberFunctionParams, MemberDefImpl::writeDeclaration, writeDefArgumentList, MemberDefImpl::writeDocumentation, writeExceptionListImpl, MemberDefImpl::writeMemberDocSimple, writeTemplateArgumentList, ClassDefImpl::writeTemplateSpec and writeTypeConstraints.

linkToText()

QCString linkToText (SrcLangExt lang, const QCString & link, bool isFileName)

Declaration at line 342 of file util.h, definition at line 3220 of file util.cpp.

3220QCString linkToText(SrcLangExt lang,const QCString &link,bool isFileName)

3221{

3222 //bool optimizeOutputJava = Config_getBool(OPTIMIZE_OUTPUT_JAVA);

3223 QCString result=link;

3224 if (!result.isEmpty())

3225 {

3226 // replace # by ::

3227 result=substitute(result,"#","::");

3228 // replace . by ::

3229 if (!isFileName && result.find('<')==-1) result=substitute(result,".","::",3);

3230 // strip leading :: prefix if present

3231 if (result.at(0)==':' && result.at(1)==':')

3232 {

3233 result=result.right(result.length()-2);

3234 }

3235 QCString sep = getLanguageSpecificSeparator(lang);

3236 if (sep!="::")

3237 {

3238 result=substitute(result,"::",sep);

3239 }

3240 }

3241 //printf("linkToText(%s,lang=%d)=%s\n",qPrint(link),lang,qPrint(result));

3242 return result;

3243}

References QCString::at, QCString::find, getLanguageSpecificSeparator, QCString::isEmpty, QCString::length, QCString::right and substitute.

Referenced by DotCallGraph::buildGraph, DocRef::DocRef, DotCallGraph::DotCallGraph and DocParser::handleLinkedWord.

mainPageHasTitle()

bool mainPageHasTitle ()

Declaration at line 455 of file util.h, definition at line 6799 of file util.cpp.

6799bool mainPageHasTitle()

6800{

6801 return Doxygen::mainPage!=nullptr && Doxygen::mainPage->hasTitle();

6802}

Reference Doxygen::mainPage.

Referenced by generateJSNavTree, generateSqlite3ForPage, generateXMLForPage, mainPageHasOwnTitle and writeIndex.

mangleCSharpGenericName()

QCString mangleCSharpGenericName (const QCString & name)

Declaration at line 483 of file util.h, definition at line 7428 of file util.cpp.

7428QCString mangleCSharpGenericName(const QCString &name)

7429{

7430 int idx = name.find('<');

7431 if (idx!=-1)

7432 {

7433 return name.left(idx)+"-"+QCString().setNum(name.contains(",")+1)+"-g";

7434 }

7435 return name;

7436}

References QCString::contains, QCString::find, QCString::left and QCString::setNum.

Referenced by addClassToContext, addEnumValuesToEnums, addVariable, buildFunctionList, extractClassName, findClassRelation, findEnums, SymbolResolver::resolveClass, resolveLink and resolveRef.

matchArguments2()

bool matchArguments2 (const Definition * srcScope, const FileDef * srcFileScope, const ArgumentList * srcAl, const Definition * dstScope, const FileDef * dstFileScope, const ArgumentList * dstAl, bool checkCV, SrcLangExt lang)

Declaration at line 165 of file util.h, definition at line 1959 of file util.cpp.

1959bool matchArguments2(const Definition *srcScope,const FileDef *srcFileScope,const ArgumentList *srcAl,

1960 const Definition *dstScope,const FileDef *dstFileScope,const ArgumentList *dstAl,

1961 bool checkCV,SrcLangExt lang)

1962{

1963 ASSERT(srcScope!=nullptr && dstScope!=nullptr);

1964

1965 AUTO_TRACE("srcScope='{}' dstScope='{}' srcArgs='{}' dstArgs='{}' checkCV={} lang={}",

1966 srcScope->name(),dstScope->name(),srcAl?argListToString(*srcAl):"",dstAl?argListToString(*dstAl):"",checkCV,lang);

1967

1968 if (srcAl==nullptr || dstAl==nullptr)

1969 {

1970 bool match = srcAl==dstAl;

1971 if (match)

1972 {

1973 MATCH

1974 return TRUE;

1975 }

1976 else

1977 {

1978 NOMATCH

1979 return FALSE;

1980 }

1981 }

1982

1983 // handle special case with void argument

1984 if ( srcAl->empty() && dstAl->size()==1 && dstAl->front().type=="void" )

1985 { // special case for finding match between func() and func(void)

1986 Argument a;

1987 a.type = "void";

1988 const_cast<ArgumentList*>(srcAl)->push_back(a);

1989 MATCH

1990 return TRUE;

1991 }

1992 if ( dstAl->empty() && srcAl->size()==1 && srcAl->front().type=="void" )

1993 { // special case for finding match between func(void) and func()

1994 Argument a;

1995 a.type = "void";

1996 const_cast<ArgumentList*>(dstAl)->push_back(a);

1997 MATCH

1998 return TRUE;

1999 }

2000

2001 if (srcAl->size() != dstAl->size())

2002 {

2003 NOMATCH

2004 return FALSE; // different number of arguments -> no match

2005 }

2006

2007 if (checkCV)

2008 {

2009 if (srcAl->constSpecifier() != dstAl->constSpecifier())

2010 {

2011 NOMATCH

2012 return FALSE; // one member is const, the other not -> no match

2013 }

2014 if (srcAl->volatileSpecifier() != dstAl->volatileSpecifier())

2015 {

2016 NOMATCH

2017 return FALSE; // one member is volatile, the other not -> no match

2018 }

2019 }

2020

2021 if (srcAl->refQualifier() != dstAl->refQualifier())

2022 {

2023 NOMATCH

2024 return FALSE; // one member is has a different ref-qualifier than the other

2025 }

2026

2027 // so far the argument list could match, so we need to compare the types of

2028 // all arguments.

2029 auto srcIt = srcAl->begin();

2030 auto dstIt = dstAl->begin();

2031 for (;srcIt!=srcAl->end() && dstIt!=dstAl->end();++srcIt,++dstIt)

2032 {

2033 Argument &srcA = const_cast<Argument&>(*srcIt);

2034 Argument &dstA = const_cast<Argument&>(*dstIt);

2035 if (!matchArgument2(srcScope,srcFileScope,srcA,

2036 dstScope,dstFileScope,dstA,

2037 lang)

2038 )

2039 {

2040 NOMATCH

2041 return FALSE;

2042 }

2043 }

2044 MATCH

2045 return TRUE; // all arguments match

2046}

References argListToString, ASSERT, AUTO_TRACE, ArgumentList::begin, ArgumentList::constSpecifier, ArgumentList::empty, ArgumentList::end, FALSE, ArgumentList::front, MATCH, matchArgument2, Definition::name, NOMATCH, ArgumentList::refQualifier, ArgumentList::size, TRUE, Argument::type and ArgumentList::volatileSpecifier.

Referenced by addMemberDocs, addMemberFunction, buildFunctionList, combineDeclarationAndDefinition, computeMemberRelationsForBaseClass, ClassDefImpl::containsOverload, findFriends, findGlobalMember, findMember, findMembersWithSpecificName, getDefsOld, SymbolResolver::Private::getResolvedSymbol, GroupDefImpl::insertMember, matchCanonicalTypes, ClassDefImpl::mergeMembersFromBaseClasses, transferFunctionReferences and transferRelatedFunctionDocumentation.

matchTemplateArguments()

bool matchTemplateArguments (const ArgumentList & srcAl, const ArgumentList & dstAl)

Declaration at line 172 of file util.h, definition at line 2197 of file util.cpp.

2197bool matchTemplateArguments(const ArgumentList &srcAl,const ArgumentList &dstAl)

2198{

2199 AUTO_TRACE("srcAl=%s dstAl=%s",argListToString(srcAl),argListToString(dstAl));

2200 if (srcAl.size()!=dstAl.size()) // different number of template parameters -> overload

2201 {

2202 AUTO_TRACE_EXIT("different number of parameters");

2203 return false;

2204 }

2205 auto isUnconstraintTemplate = [](const QCString &type)

2206 {

2207 return type=="typename" || type=="class" || type.startsWith("typename ") || type.startsWith("class ");

2208 };

2209 auto srcIt = srcAl.begin();

2210 auto dstIt = dstAl.begin();

2211 while (srcIt!=srcAl.end() && dstIt!=dstAl.end())

2212 {

2213 const Argument &srcA = *srcIt;

2214 const Argument &dstA = *dstIt;

2215 if ((!isUnconstraintTemplate(srcA.type) || !isUnconstraintTemplate(dstA.type)) && srcA.type!=dstA.type) // different constraints -> overload

2216 {

2217 AUTO_TRACE_EXIT("different constraints");

2218 return false;

2219 }

2220 ++srcIt;

2221 ++dstIt;

2222 }

2223 AUTO_TRACE_EXIT("same");

2224 // no overload with respect to the template parameters

2225 return true;

2226}

References argListToString, AUTO_TRACE, AUTO_TRACE_EXIT, ArgumentList::begin, ArgumentList::end, ArgumentList::size and Argument::type.

Referenced by buildFunctionList.

mergeArguments()

void mergeArguments (ArgumentList & srcAl, ArgumentList & dstAl, bool forceNameOverwrite=FALSE)

Declaration at line 170 of file util.h, definition at line 2053 of file util.cpp.

2053void mergeArguments(ArgumentList &srcAl,ArgumentList &dstAl,bool forceNameOverwrite)

2054{

2055 AUTO_TRACE("srcAl='{}',dstAl='{}',forceNameOverwrite={}",

2056 qPrint(argListToString(srcAl)),qPrint(argListToString(dstAl)),forceNameOverwrite);

2057

2058 if (srcAl.size()!=dstAl.size())

2059 {

2060 return; // invalid argument lists -> do not merge

2061 }

2062

2063 auto srcIt=srcAl.begin();

2064 auto dstIt=dstAl.begin();

2065 while (srcIt!=srcAl.end() && dstIt!=dstAl.end())

2066 {

2067 Argument &srcA = *srcIt;

2068 Argument &dstA = *dstIt;

2069

2070 AUTO_TRACE_ADD("before merge: src=[type='{}',name='{}',def='{}'] dst=[type='{}',name='{}',def='{}']",

2071 srcA.type,srcA.name,srcA.defval,

2072 dstA.type,dstA.name,dstA.defval);

2073 if (srcA.defval.isEmpty() && !dstA.defval.isEmpty())

2074 {

2075 //printf("Defval changing '%s'->'%s'\n",qPrint(srcA.defval),qPrint(dstA.defval));

2076 srcA.defval=dstA.defval;

2077 }

2078 else if (!srcA.defval.isEmpty() && dstA.defval.isEmpty())

2079 {

2080 //printf("Defval changing '%s'->'%s'\n",qPrint(dstA.defval),qPrint(srcA.defval));

2081 dstA.defval=srcA.defval;

2082 }

2083

2084 // fix wrongly detected const or volatile specifiers before merging.

2085 // example: "const A *const" is detected as type="const A *" name="const"

2086 if (srcA.name=="const" || srcA.name=="volatile")

2087 {

2088 srcA.type+=" "+srcA.name;

2089 srcA.name.clear();

2090 }

2091 if (dstA.name=="const" || dstA.name=="volatile")

2092 {

2093 dstA.type+=" "+dstA.name;

2094 dstA.name.clear();

2095 }

2096

2097 if (srcA.type==dstA.type)

2098 {

2099 //printf("1. merging %s:%s <-> %s:%s\n",qPrint(srcA.type),qPrint(srcA.name),qPrint(dstA.type),qPrint(dstA.name));

2100 if (srcA.name.isEmpty() && !dstA.name.isEmpty())

2101 {

2102 //printf("type: '%s':='%s'\n",qPrint(srcA.type),qPrint(dstA.type));

2103 //printf("name: '%s':='%s'\n",qPrint(srcA.name),qPrint(dstA.name));

2104 srcA.type = dstA.type;

2105 srcA.name = dstA.name;

2106 }

2107 else if (!srcA.name.isEmpty() && dstA.name.isEmpty())

2108 {

2109 //printf("type: '%s':='%s'\n",qPrint(dstA.type),qPrint(srcA.type));

2110 //printf("name: '%s':='%s'\n",qPrint(dstA.name),qPrint(srcA.name));

2111 dstA.type = srcA.type;

2112 dstA.name = srcA.name;

2113 }

2114 else if (!srcA.name.isEmpty() && !dstA.name.isEmpty())

2115 {

2116 //printf("srcA.name=%s dstA.name=%s\n",qPrint(srcA.name),qPrint(dstA.name));

2117 if (forceNameOverwrite)

2118 {

2119 srcA.name = dstA.name;

2120 }

2121 else

2122 {

2123 if (srcA.docs.isEmpty() && !dstA.docs.isEmpty())

2124 {

2125 srcA.name = dstA.name;

2126 }

2127 else if (!srcA.docs.isEmpty() && dstA.docs.isEmpty())

2128 {

2129 dstA.name = srcA.name;

2130 }

2131 }

2132 }

2133 }

2134 else

2135 {

2136 //printf("2. merging '%s':'%s' <-> '%s':'%s'\n",qPrint(srcA.type),qPrint(srcA.name),qPrint(dstA.type),qPrint(dstA.name));

2137 srcA.type=srcA.type.stripWhiteSpace();

2138 dstA.type=dstA.type.stripWhiteSpace();

2139 if (srcA.type+" "+srcA.name==dstA.type) // "unsigned long:int" <-> "unsigned long int:bla"

2140 {

2141 srcA.type+=" "+srcA.name;

2142 srcA.name=dstA.name;

2143 }

2144 else if (dstA.type+" "+dstA.name==srcA.type) // "unsigned long int bla" <-> "unsigned long int"

2145 {

2146 dstA.type+=" "+dstA.name;

2147 dstA.name=srcA.name;

2148 }

2149 else if (srcA.name.isEmpty() && !dstA.name.isEmpty())

2150 {

2151 srcA.name = dstA.name;

2152 }

2153 else if (dstA.name.isEmpty() && !srcA.name.isEmpty())

2154 {

2155 dstA.name = srcA.name;

2156 }

2157 }

2158 int i1=srcA.type.find("::"),

2159 i2=dstA.type.find("::"),

2160 j1=static_cast<int>(srcA.type.length())-i1-2,

2161 j2=static_cast<int>(dstA.type.length())-i2-2;

2162 if (i1!=-1 && i2==-1 && srcA.type.right(j1)==dstA.type)

2163 {

2164 //printf("type: '%s':='%s'\n",qPrint(dstA.type),qPrint(srcA.type));

2165 //printf("name: '%s':='%s'\n",qPrint(dstA.name),qPrint(srcA.name));

2166 dstA.type = srcA.type.left(i1+2)+dstA.type;

2167 dstA.name = srcA.name;

2168 }

2169 else if (i1==-1 && i2!=-1 && dstA.type.right(j2)==srcA.type)

2170 {

2171 //printf("type: '%s':='%s'\n",qPrint(srcA.type),qPrint(dstA.type));

2172 //printf("name: '%s':='%s'\n",qPrint(dstA.name),qPrint(srcA.name));

2173 srcA.type = dstA.type.left(i2+2)+srcA.type;

2174 srcA.name = dstA.name;

2175 }

2176 if (srcA.docs.isEmpty() && !dstA.docs.isEmpty())

2177 {

2178 srcA.docs = dstA.docs;

2179 }

2180 else if (dstA.docs.isEmpty() && !srcA.docs.isEmpty())

2181 {

2182 dstA.docs = srcA.docs;

2183 }

2184 //printf("Merge argument '%s|%s' '%s|%s'\n",

2185 // qPrint(srcA.type), qPrint(srcA.name),

2186 // qPrint(dstA.type), qPrint(dstA.name));

2187 ++srcIt;

2188 ++dstIt;

2189 AUTO_TRACE_ADD("after merge: src=[type='{}',name='{}',def='{}'] dst=[type='{}',name='{}',def='{}']",

2190 srcA.type,srcA.name,srcA.defval,

2191 dstA.type,dstA.name,dstA.defval);

2192 }

2193}

References argListToString, AUTO_TRACE, AUTO_TRACE_ADD, ArgumentList::begin, QCString::clear, Argument::defval, Argument::docs, ArgumentList::end, QCString::find, QCString::isEmpty, QCString::left, QCString::length, Argument::name, qPrint, QCString::right, ArgumentList::size, QCString::stripWhiteSpace and Argument::type.

Referenced by addMemberDocs, buildFunctionList and findFriends.

mergeMemberOverrideOptions()

void mergeMemberOverrideOptions (MemberDefMutable * md1, MemberDefMutable * md2)

Declaration at line 479 of file util.h, definition at line 7376 of file util.cpp.

7376void mergeMemberOverrideOptions(MemberDefMutable *md1,MemberDefMutable *md2)

7377{

7378 if (Config_getBool(CALL_GRAPH) !=md1->hasCallGraph()) md2->overrideCallGraph(md1->hasCallGraph());

7379 if (Config_getBool(CALLER_GRAPH)!=md1->hasCallerGraph()) md2->overrideCallerGraph(md1->hasCallerGraph());

7380 if (Config_getBool(CALL_GRAPH) !=md2->hasCallGraph()) md1->overrideCallGraph( md2->hasCallGraph());

7381 if (Config_getBool(CALLER_GRAPH)!=md2->hasCallerGraph()) md1->overrideCallerGraph(md2->hasCallerGraph());

7382

7383 if (Config_getBool(SHOW_ENUM_VALUES) !=md1->hasEnumValues()) md2->overrideEnumValues(md1->hasEnumValues());

7384 if (Config_getBool(SHOW_ENUM_VALUES) !=md2->hasEnumValues()) md1->overrideEnumValues( md2->hasEnumValues());

7385

7386 if (Config_getBool(REFERENCED_BY_RELATION)!=md1->hasReferencedByRelation()) md2->overrideReferencedByRelation(md1->hasReferencedByRelation());

7387 if (Config_getBool(REFERENCES_RELATION) !=md1->hasReferencesRelation()) md2->overrideReferencesRelation(md1->hasReferencesRelation());

7388 if (Config_getBool(REFERENCED_BY_RELATION)!=md2->hasReferencedByRelation()) md1->overrideReferencedByRelation(md2->hasReferencedByRelation());

7389 if (Config_getBool(REFERENCES_RELATION) !=md2->hasReferencesRelation()) md1->overrideReferencesRelation(md2->hasReferencesRelation());

7390

7391 if (Config_getBool(INLINE_SOURCES)!=md1->hasInlineSource()) md2->overrideInlineSource(md1->hasInlineSource());

7392 if (Config_getBool(INLINE_SOURCES)!=md2->hasInlineSource()) md1->overrideInlineSource(md2->hasInlineSource());

7393}

References Config_getBool, MemberDef::hasCallerGraph, MemberDef::hasCallGraph, MemberDef::hasEnumValues, MemberDef::hasInlineSource, MemberDef::hasReferencedByRelation, MemberDef::hasReferencesRelation, MemberDefMutable::overrideCallerGraph, MemberDefMutable::overrideCallGraph, MemberDefMutable::overrideEnumValues, MemberDefMutable::overrideInlineSource, MemberDefMutable::overrideReferencedByRelation and MemberDefMutable::overrideReferencesRelation.

Referenced by combineDeclarationAndDefinition and findFriends.

mergeScopes()

QCString mergeScopes (const QCString & leftScope, const QCString & rightScope)

Merges two scope parts together. The parts may (partially) overlap. Example1: A::B and B::C will result in A::B::C
Example2: A and B will be A::B
Example3: A::B and B will be A::B

Parameters

leftScope	the left hand part of the scope.
rightScope	the right hand part of the scope.

Returns: the merged scope.

Declaration at line 310 of file util.h, definition at line 5097 of file util.cpp.

5097QCString mergeScopes(const QCString &leftScope,const QCString &rightScope)

5098{

5099 AUTO_TRACE("leftScope='{}' rightScope='{}'",leftScope,rightScope);

5100 // case leftScope=="A" rightScope=="A::B" => result = "A::B"

5101 if (leftScopeMatch(leftScope,rightScope))

5102 {

5103 AUTO_TRACE_EXIT("case1={}",rightScope);

5104 return rightScope;

5105 }

5106 QCString result;

5107 int i=0,p=static_cast<int>(leftScope.length());

5108

5109 // case leftScope=="A::B" rightScope=="B::C" => result = "A::B::C"

5110 // case leftScope=="A::B" rightScope=="B" => result = "A::B"

5111 bool found=FALSE;

5112 while ((i=leftScope.findRev("::",p))>0)

5113 {

5114 if (leftScopeMatch(rightScope,leftScope.right(leftScope.length()-i-2)))

5115 {

5116 result = leftScope.left(i+2)+rightScope;

5117 found=TRUE;

5118 }

5119 p=i-1;

5120 }

5121 if (found)

5122 {

5123 AUTO_TRACE_EXIT("case2={}",result);

5124 return result;

5125 }

5126

5127 // case leftScope=="A" rightScope=="B" => result = "A::B"

5128 result=leftScope;

5129 if (!result.isEmpty() && !rightScope.isEmpty()) result+="::";

5130 result+=rightScope;

5131 AUTO_TRACE_EXIT("case3={}",result);

5132 return result;

5133}

References AUTO_TRACE, AUTO_TRACE_EXIT, FALSE, QCString::findRev, QCString::isEmpty, QCString::left, leftScopeMatch, QCString::length, QCString::right and TRUE.

Referenced by addEnumValuesToEnums, addVariable, findEnums, findMember and stripTemplateSpecifiersFromScope.

nextUtf8CharPosition()

int nextUtf8CharPosition (const QCString & utf8Str, uint32_t len, uint32_t startPos)

Definition at line 409 of file util.h.

normalizeNonTemplateArgumentsInString()

QCString normalizeNonTemplateArgumentsInString (const QCString & name, const Definition * context, const ArgumentList & formalArgs)

Declaration at line 291 of file util.h, definition at line 4803 of file util.cpp.

4803QCString normalizeNonTemplateArgumentsInString(

4804 const QCString &name,

4805 const Definition *context,

4806 const ArgumentList &formalArgs)

4807{

4808 // skip until <

4809 int p=name.find('<');

4810 if (p==-1) return name;

4811 p++;

4812 QCString result = name.left(p);

4813

4814 std::string s = name.mid(p).str();

4815 static const reg::Ex re(R"([\a:][\w:]*)");

4816 reg::Iterator it(s,re);

4817 reg::Iterator end;

4818 size_t pi=0;

4819 // for each identifier in the template part (e.g. B<T> -> T)

4820 for (; it!=end ; ++it)

4821 {

4822 const auto &match = *it;

4823 size_t i = match.position();

4824 size_t l = match.length();

4825 result += s.substr(pi,i-pi);

4826 QCString n(match.str());

4827 bool found=FALSE;

4828 for (const Argument &formArg : formalArgs)

4829 {

4830 if (formArg.name == n)

4831 {

4832 found=TRUE;

4833 break;

4834 }

4835 }

4836 if (!found)

4837 {

4838 // try to resolve the type

4839 SymbolResolver resolver;

4840 const ClassDef *cd = resolver.resolveClass(context,n);

4841 if (cd)

4842 {

4843 result+=cd->name();

4844 }

4845 else

4846 {

4847 result+=n;

4848 }

4849 }

4850 else

4851 {

4852 result+=n;

4853 }

4854 pi=i+l;

4855 }

4856 result+=s.substr(pi);

4857 //printf("normalizeNonTemplateArgumentInString(%s)=%s\n",qPrint(name),qPrint(result));

4858 return removeRedundantWhiteSpace(result);

4859}

References end, FALSE, QCString::find, QCString::left, QCString::mid, Definition::name, removeRedundantWhiteSpace, SymbolResolver::resolveClass, QCString::str and TRUE.

Referenced by findUsedClassesForClass.

openOutputFile()

bool openOutputFile (const QCString & outFile, std::ofstream & f)

Declaration at line 456 of file util.h, definition at line 6811 of file util.cpp.

6811bool openOutputFile(const QCString &outFile,std::ofstream &f)

6812{

6813 assert(!f.is_open());

6814 bool fileOpened=FALSE;

6815 bool writeToStdout=outFile=="-";

6816 if (writeToStdout) // write to stdout

6817 {

6818 f.basic_ios<char>::rdbuf(std::cout.rdbuf());

6819 fileOpened = true;

6820 }

6821 else // write to file

6822 {

6823 FileInfo fi(outFile.str());

6824 if (fi.exists()) // create a backup

6825 {

6826 Dir dir;

6827 FileInfo backup(fi.filePath()+".bak");

6828 if (backup.exists()) // remove existing backup

6829 dir.remove(backup.filePath());

6830 dir.rename(fi.filePath(),fi.filePath()+".bak");

6831 }

6832 f = Portable::openOutputStream(outFile);

6833 fileOpened = f.is_open();

6834 }

6835 return fileOpened;

6836}

References FileInfo::exists, FALSE, FileInfo::filePath, Portable::openOutputStream, Dir::remove, Dir::rename and QCString::str.

Referenced by compareDoxyfile, generateConfigFile, readConfiguration and writeDefaultLayoutFile.

parseCommentAsHtml()

QCString parseCommentAsHtml (const Definition * scope, const MemberDef * member, const QCString & doc, const QCString & fileName, int lineNr)

Declaration at line 383 of file util.h, definition at line 5931 of file util.cpp.

5931QCString parseCommentAsHtml(const Definition *scope,const MemberDef *member,const QCString &doc,const QCString &fileName,int lineNr)

5932{

5933 std::lock_guard lock(g_docCacheMutex);

5934 auto it = g_docCache.find(doc.str());

5935 if (it != g_docCache.end())

5936 {

5937 //printf("Cache: [%s]->[%s]\n",qPrint(doc),qPrint(it->second));

5938 return it->second;

5939 }

5940 auto parser { createDocParser() };

5941 auto ast { validatingParseTitle(*parser.get(),fileName,lineNr,doc) };

5942 auto astImpl = dynamic_cast<const DocNodeAST*>(ast.get());

5943 QCString result;

5944 if (astImpl)

5945 {

5946 TextStream t;

5947 OutputCodeList codeList;

5948 codeList.add<HtmlCodeGenerator>(&t);

5949 HtmlDocVisitor visitor(t,codeList,scope,fileName);

5950 std::visit(visitor,astImpl->root);

5951 result = t.str();

5952 }

5953 else // fallback, should not happen

5954 {

5955 result = filterTitle(doc);

5956 }

5957 //printf("Conversion: [%s]->[%s]\n",qPrint(doc),qPrint(result));

5958 g_docCache.insert(std::make_pair(doc.str(),result));

5959 return result;

5960}

References OutputCodeList::add, createDocParser, filterTitle, g_docCache, g_docCacheMutex, QCString::str, TextStream::str and validatingParseTitle.

Referenced by PageDefImpl::addSectionsToIndex, SearchTerm::makeTitle, DefinitionImpl::navigationPathAsString, writeGroupTreeNode, writeIndex, writeJavasScriptSearchDataPage and writePages.

parseCommentAsText()

QCString parseCommentAsText (const Definition * scope, const MemberDef * member, const QCString & doc, const QCString & fileName, int lineNr)

Declaration at line 382 of file util.h, definition at line 5880 of file util.cpp.

5880QCString parseCommentAsText(const Definition *scope,const MemberDef *md,

5881 const QCString &doc,const QCString &fileName,int lineNr)

5882{

5883 if (doc.isEmpty()) return "";

5884 //printf("parseCommentAsText(%s)\n",qPrint(doc));

5885 TextStream t;

5886 auto parser { createDocParser() };

5887 auto ast { validatingParseDoc(*parser.get(),

5888 fileName,lineNr,

5889 scope,md,doc,FALSE,FALSE,

5890 QCString(),FALSE,FALSE,Config_getBool(MARKDOWN_SUPPORT),false) };

5891 auto astImpl = dynamic_cast<const DocNodeAST*>(ast.get());

5892 if (astImpl)

5893 {

5894 TextDocVisitor visitor(t);

5895 std::visit(visitor,astImpl->root);

5896 }

5897 QCString result = convertCharEntitiesToUTF8(t.str().c_str()).stripWhiteSpace();

5898 int i=0;

5899 int charCnt=0;

5900 int l=static_cast<int>(result.length());

5901 while ((i=nextUTF8CharPosition(result,l,i))<l)

5902 {

5903 charCnt++;

5904 if (charCnt>=80) break;

5905 }

5906 if (charCnt>=80) // try to truncate the string

5907 {

5908 while ((i=nextUTF8CharPosition(result,l,i))<l && charCnt<100)

5909 {

5910 charCnt++;

5911 if (result.at(i)==',' ||

5912 result.at(i)=='.' ||

5913 result.at(i)=='!' ||

5914 result.at(i)=='?' ||

5915 result.at(i)=='}') // good for UTF-16 characters and } otherwise also a good point to stop the string

5916 {

5917 i++; // we want to be "behind" last inspected character

5918 break;

5919 }

5920 }

5921 }

5922 if ( i < l) result=result.left(i)+"...";

5923 return result.data();

5924}

References QCString::at, Config_getBool, convertCharEntitiesToUTF8, createDocParser, QCString::data, FALSE, QCString::isEmpty, QCString::left, QCString::length, nextUTF8CharPosition, TextStream::str, QCString::stripWhiteSpace and validatingParseDoc.

Referenced by PageDefImpl::addSectionsToIndex, DefinitionImpl::computeTooltip, writeGroupTreeNode, writeIndex and writePages.

patternMatch()

bool patternMatch (const FileInfo & fi, const StringVector & patList)

Declaration at line 399 of file util.h, definition at line 6205 of file util.cpp.

6205bool patternMatch(const FileInfo &fi,const StringVector &patList)

6206{

6207 std::string elem;

6208 auto getter = [](std::string s) { return QCString(s); };

6209 return genericPatternMatch(fi,patList,elem,getter);

6210}

Reference genericPatternMatch.

Referenced by checkAndOpenFile and readDir.

processMarkup()

QCString processMarkup (const QCString & s)

Definition at line 435 of file util.h.

projectLogoFile()

QCString projectLogoFile ()

Declaration at line 477 of file util.h, definition at line 3658 of file util.cpp.

3658QCString projectLogoFile()

3659{

3660 QCString projectLogo = Config_getString(PROJECT_LOGO);

3661 if (!projectLogo.isEmpty())

3662 {

3663 // check for optional width= and height= specifier

3664 int wi = projectLogo.find(" width=");

3665 if (wi!=-1) // and strip them

3666 {

3667 projectLogo = projectLogo.left(wi);

3668 }

3669 int hi = projectLogo.find(" height=");

3670 if (hi!=-1)

3671 {

3672 projectLogo = projectLogo.left(hi);

3673 }

3674 }

3675 //printf("projectlogo='%s'\n",qPrint(projectLogo));

3676 return projectLogo;

3677}

References Config_getString, QCString::find, QCString::isEmpty and QCString::left.

Referenced by copyLogo and substituteKeywords.

protectionLevelVisible()

bool protectionLevelVisible (Protection prot)

Declaration at line 437 of file util.h, definition at line 6454 of file util.cpp.

6454bool protectionLevelVisible(Protection prot)

6455{

6456 bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);

6457 bool extractPackage = Config_getBool(EXTRACT_PACKAGE);

6458

6459 return (prot!=Protection::Private && prot!=Protection::Package) ||

6460 (prot==Protection::Private && extractPrivate) ||

6461 (prot==Protection::Package && extractPackage);

6462}

Reference Config_getBool.

Referenced by MemberDefImpl::_computeLinkableInProject, addClassAndNestedClasses, computeClassRelations, MemberDefImpl::hasDetailedDescription, ClassDefImpl::internalInsertMember, MemberDefImpl::isBriefSectionVisible, ClassDefImpl::isLinkableInProject, ClassDefImpl::isVisibleInHierarchy, MemberDefImpl::warnIfUndocumented, MemberDefImpl::writeDeclaration, ClassDefImpl::writeDocumentationForInnerClasses, ClassDefImpl::writeMemberList and ClassDefImpl::writeTagFile.

readInputFile()

bool readInputFile (const QCString & fileName, std::string & contents, bool filter=TRUE, bool isSourceCode=FALSE)

read a file name fileName and optionally filter and transcode it

Declaration at line 395 of file util.h, definition at line 6051 of file util.cpp.

6051bool readInputFile(const QCString &fileName,std::string &contents,bool filter,bool isSourceCode)

6052{

6053 // try to open file

6054 FileInfo fi(fileName.str());

6055 if (!fi.exists()) return FALSE;

6056 QCString filterName = getFileFilter(fileName,isSourceCode);

6057 if (filterName.isEmpty() || !filter)

6058 {

6059 std::ifstream f = Portable::openInputStream(fileName,true);

6060 if (!f.is_open())

6061 {

6062 err("could not open file {}\n",fileName);

6063 return FALSE;

6064 }

6065 // read the file

6066 auto fileSize = fi.size();

6067 contents.resize(fileSize);

6068 f.read(contents.data(),fileSize);

6069 if (f.fail())

6070 {

6071 err("problems while reading file {}\n",fileName);

6072 return FALSE;

6073 }

6074 }

6075 else

6076 {

6077 QCString cmd=filterName+" \""+fileName+"\"";

6078 Debug::print(Debug::ExtCmd,0,"Executing popen(`{}`)\n",cmd);

6079 FILE *f=Portable::popen(cmd,"r");

6080 if (!f)

6081 {

6082 err("could not execute filter {}\n",filterName);

6083 return FALSE;

6084 }

6085 const int bufSize=4096;

6086 char buf[bufSize];

6087 int numRead = 0;

6088 while ((numRead=static_cast<int>(fread(buf,1,bufSize,f)))>0)

6089 {

6090 //printf(">>>>>>>>Reading %d bytes\n",numRead);

6091 contents.append(buf,numRead);

6092 }

6093 Portable::pclose(f);

6094 Debug::print(Debug::FilterOutput, 0, "Filter output\n");

6095 Debug::print(Debug::FilterOutput,0,"-------------\n{}\n-------------\n",contents);

6096 }

6097

6098 if (contents.size()>=2 &&

6099 static_cast<uint8_t>(contents[0])==0xFF &&

6100 static_cast<uint8_t>(contents[1])==0xFE // Little endian BOM

6101 ) // UCS-2LE encoded file

6102 {

6103 transcodeCharacterBuffer(fileName,contents,"UCS-2LE","UTF-8");

6104 }

6105 else if (contents.size()>=2 &&

6106 static_cast<uint8_t>(contents[0])==0xFE &&

6107 static_cast<uint8_t>(contents[1])==0xFF // big endian BOM

6108 ) // UCS-2BE encoded file

6109 {

6110 transcodeCharacterBuffer(fileName,contents,"UCS-2BE","UTF-8");

6111 }

6112 else if (contents.size()>=3 &&

6113 static_cast<uint8_t>(contents[0])==0xEF &&

6114 static_cast<uint8_t>(contents[1])==0xBB &&

6115 static_cast<uint8_t>(contents[2])==0xBF

6116 ) // UTF-8 encoded file

6117 {

6118 contents.erase(0,3); // remove UTF-8 BOM: no translation needed

6119 }

6120 else // transcode according to the INPUT_ENCODING setting

6121 {

6122 // do character transcoding if needed.

6123 transcodeCharacterBuffer(fileName,contents,getEncoding(fi),"UTF-8");

6124 }

6125

6126 filterCRLF(contents);

6127 return true;

6128}

References err, FileInfo::exists, Debug::ExtCmd, FALSE, filterCRLF, Debug::FilterOutput, getEncoding, getFileFilter, QCString::isEmpty, Portable::openInputStream, Portable::pclose, Portable::popen, Debug::print, FileInfo::size, QCString::str and transcodeCharacterBuffer.

Referenced by checkAndOpenFile, fileToString, HtmlDocVisitor::operator(), RTFDocVisitor::operator(), parseFile, parseInput, readIncludeFile, DocbookDocVisitor::startPlantUmlFile and LatexDocVisitor::startPlantUmlFile.

recodeString()

QCString recodeString (const QCString & str, const char * fromEncoding, const char * toEncoding)

Definition at line 387 of file util.h.

References FALSE, parent and TRUE.

recognizeFixedForm()

bool recognizeFixedForm (const QCString & contents, FortranFormat format)

Declaration at line 464 of file util.h, definition at line 6858 of file util.cpp.

6858bool recognizeFixedForm(const QCString &contents, FortranFormat format)

6859{

6860 int column=0;

6861 bool skipLine=FALSE;

6862

6863 if (format == FortranFormat::Fixed) return TRUE;

6864 if (format == FortranFormat::Free) return FALSE;

6865

6866 int tabSize=Config_getInt(TAB_SIZE);

6867 size_t sizCont = contents.length();

6868 for (size_t i=0;i<sizCont;i++)

6869 {

6870 column++;

6871

6872 switch(contents.at(i))

6873 {

6874 case '\n':

6875 column=0;

6876 skipLine=FALSE;

6877 break;

6878 case '\t':

6879 column += tabSize-1;

6880 break;

6881 case ' ':

6882 break;

6883 case '\000':

6884 return FALSE;

6885 case '#':

6886 skipLine=TRUE;

6887 break;

6888 case 'C':

6889 case 'c':

6890 if (column==1)

6891 {

6892 return !keyWordsFortranC(contents.data()+i);

6893 }

6894 // fallthrough

6895 case '*':

6896 if (column==1) return TRUE;

6897 if (skipLine) break;

6898 return FALSE;

6899 case '!':

6900 if (column!=6) skipLine=TRUE;

6901 break;

6902 default:

6903 if (skipLine) break;

6904 if (column>=7) return TRUE;

6905 return FALSE;

6906 }

6907 }

6908 return FALSE;

6909}

References QCString::at, Config_getInt, QCString::data, FALSE, Fixed, Free, keyWordsFortranC, QCString::length and TRUE.

Referenced by convertCppComments, FortranCodeParser::parseCode and parseMain.

relativePathToRoot()

QCString relativePathToRoot (const QCString & name)

Declaration at line 358 of file util.h, definition at line 4096 of file util.cpp.

4096QCString relativePathToRoot(const QCString &name)

4097{

4098 QCString result;

4099 if (Config_getBool(CREATE_SUBDIRS))

4100 {

4101 if (name.isEmpty())

4102 {

4103 return REL_PATH_TO_ROOT;

4104 }

4105 else

4106 {

4107 int i = name.findRev('/');

4108 if (i!=-1)

4109 {

4110 result=REL_PATH_TO_ROOT;

4111 }

4112 }

4113 }

4114 return result;

4115}

References Config_getBool, QCString::findRev, QCString::isEmpty and REL_PATH_TO_ROOT.

Referenced by generateBriefDoc, DocbookGenerator::startFile, HtmlGenerator::startFile, LatexGenerator::startFile, RTFGenerator::startFile and validatingParseDoc.

removeAnonymousScopes()

QCString removeAnonymousScopes (const QCString & str)

Removes all anonymous scopes from string s Possible examples:

   "bla::@10::blep"      => "bla::blep"
   "bla::@10::@11::blep" => "bla::blep"
   "@10::blep"           => "blep"
   " @10::blep"          => "blep"
   "@9::@10::blep"       => "blep"
   "bla::@1"             => "bla"
   "bla::@1::@2"         => "bla"
   "bla @1"              => "bla"

Declaration at line 257 of file util.h, definition at line 173 of file util.cpp.

173QCString removeAnonymousScopes(const QCString &str)

174{

175 std::string result;

176 if (str.isEmpty()) return QCString(result);

177

178 // helper to check if the found delimiter starts with a colon

179 auto startsWithColon = [](const std::string &del)

180 {

181 for (size_t i=0;i<del.size();i++)

182 {

183 if (del[i]=='@') return false;

184 else if (del[i]==':') return true;

185 }

186 return false;

187 };

188

189 // helper to check if the found delimiter ends with a colon

190 auto endsWithColon = [](const std::string &del)

191 {

192 for (int i=static_cast<int>(del.size())-1;i>=0;i--)

193 {

194 if (del[i]=='@') return false;

195 else if (del[i]==':') return true;

196 }

197 return false;

198 };

199

200 static const reg::Ex re(R"([\s:]*@\d+[\s:]*)");

201 std::string s = str.str();

202 reg::Iterator iter(s,re);

203 reg::Iterator end;

204 size_t p=0;

205 size_t sl=s.length();

206 bool needsSeparator=false;

207 for ( ; iter!=end ; ++iter)

208 {

209 const auto &match = *iter;

210 size_t i = match.position();

211 if (i>p) // add non-matching prefix

212 {

213 if (needsSeparator) result+="::";

214 needsSeparator=false;

215 result+=s.substr(p,i-p);

216 }

217 std::string delim = match.str();

218 needsSeparator = needsSeparator || (startsWithColon(delim) && endsWithColon(delim));

219 p = match.position()+match.length();

220 }

221 if (p<sl) // add trailing remainder

222 {

223 if (needsSeparator) result+="::";

224 result+=s.substr(p);

225 }

226 return result;

227}

References end, QCString::isEmpty and QCString::str.

Referenced by createTagLessInstance, MemberDefImpl::displayDefinition, generateClassMemberLink, makeDisplayName, makeDisplayName, simplifyTypeForTable, MemberDefImpl::writeDeclaration and MemberDefImpl::writeDocumentation.

removeEmptyLines()

QCString removeEmptyLines (const QCString & s)

Declaration at line 198 of file util.h, definition at line 7101 of file util.cpp.

7101QCString removeEmptyLines(const QCString &s)

7102{

7103 std::string out;

7104 out.reserve(s.length());

7105 const char *p=s.data();

7106 if (p)

7107 {

7108 char c = 0;

7109 while ((c=*p++))

7110 {

7111 if (c=='\n')

7112 {

7113 const char *e = p;

7114 while (*e==' ' || *e=='\t') e++;

7115 if (*e=='\n')

7116 {

7117 p=e;

7118 }

7119 else out+=c;

7120 }

7121 else

7122 {

7123 out+=c;

7124 }

7125 }

7126 }

7127 //printf("removeEmptyLines(%s)=%s\n",qPrint(s),qPrint(out));

7128 return out;

7129}

References QCString::data, QCString::length and QCString::reserve.

Referenced by substituteHtmlKeywords and substituteLatexKeywords.

removeLongPathMarker()

QCString removeLongPathMarker (QCString path)

Declaration at line 364 of file util.h, definition at line 299 of file util.cpp.

299QCString removeLongPathMarker(QCString path)

300{

301#if defined(_WIN32)

302 if (path.startsWith("//?/")) // strip leading "\\?\" part from path

303 {

304 path=path.mid(4);

305 }

306#endif

307 return path;

308}

References QCString::mid and QCString::startsWith.

Referenced by computeCommonDirPrefix, FileDefImpl::FileDefImpl, findFileDef, DirDefImpl::mergeDirectoryInTree and stripFromPath.

removeRedundantWhiteSpace()

QCString removeRedundantWhiteSpace (const QCString & s)

Declaration at line 217 of file util.h, definition at line 579 of file util.cpp.

579QCString removeRedundantWhiteSpace(const QCString &s)

580{

581 bool cliSupport = Config_getBool(CPP_CLI_SUPPORT);

582 bool vhdl = Config_getBool(OPTIMIZE_OUTPUT_VHDL);

583

584 if (s.isEmpty() || vhdl) return s;

585

586 // We use a static character array to

587 // improve the performance of this function

588 // and thread_local is needed to make it multi-thread safe

589 static THREAD_LOCAL char *growBuf = nullptr;

590 static THREAD_LOCAL size_t growBufLen = 0;

591 if (s.length()*3>growBufLen) // For input character we produce at most 3 output characters,

592 {

593 growBufLen = s.length()*3;

594 growBuf = static_cast<char *>(realloc(growBuf,growBufLen+1)); // add 1 for 0-terminator

595 }

596 if (growBuf==nullptr) return s; // should not happen, only we run out of memory

597

598 const char *src=s.data();

599 char *dst=growBuf;

600

601 size_t i=0;

602 size_t l=s.length();

603 size_t csp=0;

604 size_t vosp=0;

605 size_t vsp=0;

606 size_t osp=0;

607 char pc=0;

608 // skip leading whitespace

609 while (i<l && isspace(static_cast<uint8_t>(src[i])))

610 {

611 i++;

612 }

613 for (;i<l;i++)

614 {

615 char c=src[i];

616 char nc=i+1<l ? src[i+1] : ' ';

617

618 auto searchForKeyword = [&](const char *kw,size_t &matchLen,size_t totalLen)

619 {

620 if (matchLen<=totalLen && c==kw[matchLen] && // character matches substring kw

621 (matchLen>0 || // inside search string

622 i==0 || // if it is the first character

623 !isId(pc) // the previous may not be a digit

624 )

625 )

626 matchLen++;

627 else // reset counter

628 matchLen=0;

629 };

630 searchForKeyword(constScope, csp, 5); // keyword: const

631 searchForKeyword(volatileScope, vosp, 8); // keyword: volatile

632 searchForKeyword(virtualScope, vsp, 7); // keyword: virtual

633

634 // search for "operator"

635 if (osp<11 && (osp>=8 || c==operatorScope[osp]) && // character matches substring "operator" followed by 3 arbitrary characters

636 (osp>0 || // inside search string

637 i==0 || // if it is the first character

638 !isId(pc) // the previous may not be a digit

639 )

640 )

641 osp++;

642 else // reset counter

643 osp=0;

644

645 switch(c)

646 {

647 case '"': // quoted string

648 {

649 *dst++=c;

650 i++;

651 for (;i<l;i++) // find end of string

652 {

653 c = src[i];

654 *dst++=c;

655 if (c=='\\' && i+1<l)

656 {

657 i++;

658 c = src[i];

659 *dst++=c;

660 }

661 else if (c=='"')

662 {

663 break;

664 }

665 }

666 }

667 break;

668 case '<': // current char is a <

669 *dst++=c;

670 if (i+1<l &&

671 (isId(nc)) && // next char is an id char

672 (osp<8) // string in front is not "operator"

673 )

674 {

675 *dst++=' '; // add extra space

676 }

677 break;

678 case '>': // current char is a >

679 if (i>0 && !isspace(static_cast<uint8_t>(pc)) &&

680 (isId(pc) || pc=='*' || pc=='&' || pc=='.' || pc=='>') && // prev char is an id char or space or *&.

681 (osp<8 || (osp==8 && pc!='-')) // string in front is not "operator>" or "operator->"

682 )

683 {

684 *dst++=' '; // add extra space in front

685 }

686 *dst++=c;

687 if (i+1<l && (nc=='-' || nc=='&')) // '>-' -> '> -'

688 {

689 *dst++=' '; // add extra space after

690 }

691 break;

692 case ',': // current char is a ,

693 *dst++=c;

694 if (i>0 && !isspace(static_cast<uint8_t>(pc)) &&

695 ((i+1<l && (isId(nc) || nc=='[')) || // the [ is for attributes (see bug702170)

696 (i+2<l && nc=='$' && isId(src[i+2])) || // for PHP: ',$name' -> ', $name'

697 (i+3<l && nc=='&' && src[i+2]=='$' && isId(src[i+3])) // for PHP: ',&$name' -> ', &$name'

698 )

699 )

700 {

701 *dst++=' '; // add extra space after

702 }

703 break;

704 case '^': // CLI 'Type^name' -> 'Type^ name'

705 case '%': // CLI 'Type%name' -> 'Type% name'

706 *dst++=c;

707 if (cliSupport && i+1<l && (isId(nc) || nc=='-'))

708 {

709 *dst++=' '; // add extra space after

710 }

711 break;

712 case ')': // current char is a ) -> ')name' -> ') name'

713 *dst++=c;

714 if (i+1<l && (isId(nc) || nc=='-'))

715 {

716 *dst++=' '; // add extra space after

717 }

718 break;

719 case '*':

720 if (i>0 && pc!=' ' && pc!='\t' && pc!=':' &&

721 pc!='*' && pc!='&' && pc!='(' && pc!='/' &&

722 pc!='.' && osp<9

723 )

724 // avoid splitting &&, **, .*, operator*, operator->*

725 {

726 *dst++=' ';

727 }

728 *dst++=c;

729 break;

730 case '&':

731 if (i>0 && isId(pc) && osp<9)

732 {

733 if (nc != '=')

734 // avoid splitting operator&=

735 {

736 *dst++=' ';

737 }

738 }

739 *dst++=c;

740 break;

741 case '$': // '$name' -> ' $name'

742 // 'name$name' -> 'name$name'

743 if (isId(pc))

744 {

745 *dst++=c;

746 break;

747 }

748 // else fallthrough

749 case '@': // '@name' -> ' @name'

750 case '\'': // ''name' -> '' name'

751 if (i>0 && i+1<l && pc!='=' && pc!=':' && !isspace(static_cast<uint8_t>(pc)) &&

752 isId(nc) && osp<8) // ")id" -> ") id"

753 {

754 *dst++=' ';

755 }

756 *dst++=c;

757 break;

758 case ':': // current char is a :

759 if (csp==6) // replace const::A by const ::A

760 {

761 *dst++=' ';

762 csp=0;

763 }

764 else if (vosp==9) // replace volatile::A by volatile ::A

765 {

766 *dst++=' ';

767 vosp=0;

768 }

769 else if (vsp==8) // replace virtual::A by virtual ::A

770 {

771 *dst++=' ';

772 vsp=0;

773 }

774 *dst++=c;

775 break;

776 case ' ': // fallthrough

777 case '\n': // fallthrough

778 case '\t':

779 {

780 if (g_charAroundSpace.charMap[static_cast<uint8_t>(pc)].before &&

781 g_charAroundSpace.charMap[static_cast<uint8_t>(nc)].after &&

782 !(pc==',' && nc=='.') &&

783 (osp<8 || (osp>=8 && isId(pc) && isId(nc)))

784 // e.g. 'operator >>' -> 'operator>>',

785 // 'operator "" _x' -> 'operator""_x',

786 // but not 'operator int' -> 'operatorint'

787 )

788 { // keep space

789 *dst++=' ';

790 }

791 else if ((pc=='*' || pc=='&' || pc=='.') && nc=='>')

792 {

793 *dst++=' ';

794 }

795 }

796 break;

797 default:

798 *dst++=c;

799 auto correctKeywordAllowedInsideScope = [&](char cc,size_t &matchLen,size_t totalLen) {

800 if (c==cc && matchLen==totalLen)

801 {

802 if ((i+2<l && src[i+1] == ':' && src[i+2] == ':') || // keyword::

803 ((i>matchLen && src[i-matchLen] == ':' && src[i-matchLen-1] == ':')) // ::keyword

804 ) matchLen = 0;

805 };

806 };

807 correctKeywordAllowedInsideScope('t',csp, 5); // keyword: const

808 correctKeywordAllowedInsideScope('e',vosp,8); // keyword: volatile

809 correctKeywordAllowedInsideScope('l',vsp, 7); // keyword: virtual

810

811 auto correctKeywordNotPartOfScope = [&](char cc,size_t &matchLen,size_t totalLen)

812 {

813 if (c==cc && matchLen==totalLen && i+1<l && // found matching keyword

814 !(isId(nc) || nc==')' || nc==',' || qisspace(nc))

815 ) // prevent keyword ::A from being converted to keyword::A

816 {

817 *dst++=' ';

818 matchLen=0;

819 }

820 };

821 correctKeywordNotPartOfScope('t',csp, 5); // keyword: const

822 correctKeywordNotPartOfScope('e',vosp,8); // keyword: volatile

823 correctKeywordNotPartOfScope('l',vsp, 7); // keyword: virtual

824 break;

825 }

826 pc=c;

827 }

828 *dst++='\0';

829 //printf("removeRedundantWhitespace(%s)->%s\n",qPrint(s),growBuf);

830 return growBuf;

831}

References Config_getBool, constScope, QCString::data, g_charAroundSpace, QCString::isEmpty, isId, QCString::length, operatorScope, qisspace, THREAD_LOCAL, virtualScope and volatileScope.

Referenced by addFrom, addGlobalFunction, addMethodToClass, addVariable, addVariableToClass, argListToString, buildFunctionList, buildInterfaceAndServiceList, buildTypedefList, ClassDefImpl::ClassDefImpl, extractCanonicalType, findClassRelation, DocParser::findDocsForMemberOrCompound, findMember, findUsedClassesForClass, findUsingDeclImports, generateFunctionLink, generateFunctionLink, generateLink, getCanonicalTypeForIdentifier, getLink, getLink, getLink, MemberDefImpl::init, ClassDefImpl::insertTemplateInstance, MemberDefImpl::MemberDefImpl, normalizeNonTemplateArgumentsInString, parseFuncDecl, resolveRef, tempArgListToString and writeExceptionListImpl.

replaceAnonymousScopes()

QCString replaceAnonymousScopes (const QCString & s, const QCString & replacement=QCString())

Declaration at line 259 of file util.h, definition at line 230 of file util.cpp.

230QCString replaceAnonymousScopes(const QCString &s,const QCString &replacement)

231{

232 if (s.isEmpty()) return s;

233 static const reg::Ex marker(R"(@\d+)");

234 std::string result = reg::replace(s.str(),marker,

235 !replacement.isEmpty() ? replacement.data() : "__anonymous__");

236 //printf("replaceAnonymousScopes('%s')='%s'\n",qPrint(s),qPrint(result));

237 return QCString(result);

238}

References QCString::data, QCString::isEmpty, reg::replace and QCString::str.

Referenced by addMemberFunction, findGlobalMember and generateDEFForMember.

replaceColorMarkers()

QCString replaceColorMarkers (const QCString & str)

Replaces any markers of the form ##AA in input string str by new markers of the form #AABBCC, where #AABBCC represents a valid color, based on the intensity represented by hex number AA and the current HTML_COLORSTYLE_* settings.

Declaration at line 425 of file util.h, definition at line 6323 of file util.cpp.

6323QCString replaceColorMarkers(const QCString &str)

6324{

6325 if (str.isEmpty()) return QCString();

6326 std::string result;

6327 std::string s=str.str();

6328 static const reg::Ex re(R"(##[0-9A-Fa-f][0-9A-Fa-f])");

6329 reg::Iterator it(s,re);

6330 reg::Iterator end;

6331 int hue = Config_getInt(HTML_COLORSTYLE_HUE);

6332 int sat = Config_getInt(HTML_COLORSTYLE_SAT);

6333 int gamma = Config_getInt(HTML_COLORSTYLE_GAMMA);

6334 size_t sl=s.length();

6335 size_t p=0;

6336 for (; it!=end ; ++it)

6337 {

6338 const auto &match = *it;

6339 size_t i = match.position();

6340 size_t l = match.length();

6341 if (i>p) result+=s.substr(p,i-p);

6342 std::string lumStr = match.str().substr(2);

6343#define HEXTONUM(x) (((x)>='0' && (x)<='9') ? ((x)-'0') : \

6344 ((x)>='a' && (x)<='f') ? ((x)-'a'+10) : \

6345 ((x)>='A' && (x)<='F') ? ((x)-'A'+10) : 0)

6346

6347 double r = 0,g = 0,b = 0;

6348 int level = HEXTONUM(lumStr[0])*16+HEXTONUM(lumStr[1]);

6349 ColoredImage::hsl2rgb(hue/360.0,sat/255.0,

6350 pow(level/255.0,gamma/100.0),&r,&g,&b);

6351 int red = static_cast<int>(r*255.0);

6352 int green = static_cast<int>(g*255.0);

6353 int blue = static_cast<int>(b*255.0);

6354 char colStr[8];

6355 colStr[0]='#';

6356 colStr[1]=hex[red>>4];

6357 colStr[2]=hex[red&0xf];

6358 colStr[3]=hex[green>>4];

6359 colStr[4]=hex[green&0xf];

6360 colStr[5]=hex[blue>>4];

6361 colStr[6]=hex[blue&0xf];

6362 colStr[7]=0;

6363 //printf("replacing %s->%s (level=%d)\n",qPrint(lumStr),colStr,level);

6364 result+=colStr;

6365 p=i+l;

6366 }

6367 if (p<sl) result+=s.substr(p);

6368 return QCString(result);

6369}

References Config_getInt, end, hex, HEXTONUM, ColoredImage::hsl2rgb, QCString::isEmpty and QCString::str.

Referenced by ResourceMgr::copyResourceAs, fillColorStyleMaps, HtmlGenerator::init and writeDefaultStyleSheet.

resolveLink()

bool resolveLink (const QCString & scName, const QCString & lr, bool inSeeBlock, const Definition ** resContext, QCString & resAnchor, SrcLangExt lang, const QCString & prefix=QCString())

Declaration at line 149 of file util.h, definition at line 3246 of file util.cpp.

3246bool resolveLink(/* in */ const QCString &scName,

3247 /* in */ const QCString &lr,

3248 /* in */ bool /*inSeeBlock*/,

3249 /* out */ const Definition **resContext,

3250 /* out */ QCString &resAnchor,

3251 /* in */ SrcLangExt lang,

3252 /* in */ const QCString &prefix

3253 )

3254{

3255 *resContext=nullptr;

3256

3257 QCString linkRef=lr;

3258 if (lang==SrcLangExt::CSharp)

3259 {

3260 linkRef = mangleCSharpGenericName(linkRef);

3261 }

3262 QCString linkRefWithoutTemplates = stripTemplateSpecifiersFromScope(linkRef,FALSE);

3263 AUTO_TRACE("scName='{}',ref='{}'",scName,lr);

3264 const FileDef *fd = nullptr;

3265 const GroupDef *gd = nullptr;

3266 const PageDef *pd = nullptr;

3267 const ClassDef *cd = nullptr;

3268 const DirDef *dir = nullptr;

3269 const ConceptDef *cnd = nullptr;

3270 const ModuleDef *modd = nullptr;

3271 const NamespaceDef *nd = nullptr;

3272 const SectionInfo *si = nullptr;

3273 bool ambig = false;

3274 if (linkRef.isEmpty()) // no reference name!

3275 {

3276 AUTO_TRACE_EXIT("no_ref");

3277 return FALSE;

3278 }

3279 else if ((pd=Doxygen::pageLinkedMap->find(linkRef))) // link to a page

3280 {

3281 gd = pd->getGroupDef();

3282 if (gd)

3283 {

3284 if (!pd->name().isEmpty()) si=SectionManager::instance().find(pd->name());

3285 *resContext=gd;

3286 if (si) resAnchor = si->label();

3287 }

3288 else

3289 {

3290 *resContext=pd;

3291 }

3292 AUTO_TRACE_EXIT("page");

3293 return TRUE;

3294 }

3295 else if ((si=SectionManager::instance().find(prefix+linkRef)))

3296 {

3297 *resContext=si->definition();

3298 resAnchor = si->label();

3299 AUTO_TRACE_EXIT("section");

3300 return TRUE;

3301 }

3302 else if ((si=SectionManager::instance().find(linkRef)))

3303 {

3304 *resContext=si->definition();

3305 resAnchor = si->label();

3306 AUTO_TRACE_EXIT("section");

3307 return TRUE;

3308 }

3309 else if ((pd=Doxygen::exampleLinkedMap->find(linkRef))) // link to an example

3310 {

3311 *resContext=pd;

3312 AUTO_TRACE_EXIT("example");

3313 return TRUE;

3314 }

3315 else if ((gd=Doxygen::groupLinkedMap->find(linkRef))) // link to a group

3316 {

3317 *resContext=gd;

3318 AUTO_TRACE_EXIT("group");

3319 return TRUE;

3320 }

3321 else if ((fd=findFileDef(Doxygen::inputNameLinkedMap,linkRef,ambig)) // file link

3322 && fd->isLinkable())

3323 {

3324 *resContext=fd;

3325 AUTO_TRACE_EXIT("file");

3326 return TRUE;

3327 }

3328 else if ((cd=getClass(linkRef))) // class link

3329 {

3330 *resContext=cd;

3331 resAnchor=cd->anchor();

3332 AUTO_TRACE_EXIT("class");

3333 return TRUE;

3334 }

3335 else if (lang==SrcLangExt::Java &&

3336 (cd=getClass(linkRefWithoutTemplates))) // Java generic class link

3337 {

3338 *resContext=cd;

3339 resAnchor=cd->anchor();

3340 AUTO_TRACE_EXIT("generic");

3341 return TRUE;

3342 }

3343 else if ((cd=getClass(linkRef+"-p"))) // Obj-C protocol link

3344 {

3345 *resContext=cd;

3346 resAnchor=cd->anchor();

3347 AUTO_TRACE_EXIT("protocol");

3348 return TRUE;

3349 }

3350 else if ((cnd=getConcept(linkRef))) // C++20 concept definition

3351 {

3352 *resContext=cnd;

3353 resAnchor=cnd->anchor();

3354 AUTO_TRACE_EXIT("concept");

3355 return TRUE;

3356 }

3357 else if ((modd=ModuleManager::instance().modules().find(linkRef)))

3358 {

3359 *resContext=modd;

3360 resAnchor=modd->anchor();

3361 AUTO_TRACE_EXIT("module");

3362 return TRUE;

3363 }

3364 else if ((nd=Doxygen::namespaceLinkedMap->find(linkRef)))

3365 {

3366 *resContext=nd;

3367 AUTO_TRACE_EXIT("namespace");

3368 return TRUE;

3369 }

3370 else if ((dir=Doxygen::dirLinkedMap->find(FileInfo(linkRef.str()).absFilePath()+"/"))

3371 && dir->isLinkable()) // TODO: make this location independent like filedefs

3372 {

3373 *resContext=dir;

3374 AUTO_TRACE_EXIT("directory");

3375 return TRUE;

3376 }

3377 else // probably a member reference

3378 {

3379 const MemberDef *md = nullptr;

3380 bool res = resolveRef(scName,lr,TRUE,resContext,&md,lang);

3381 if (md) resAnchor=md->anchor();

3382 AUTO_TRACE_EXIT("member? res={}",res);

3383 return res;

3384 }

3385}

References FileInfo::absFilePath, Definition::anchor, AUTO_TRACE, AUTO_TRACE_EXIT, SectionInfo::definition, Doxygen::dirLinkedMap, Doxygen::exampleLinkedMap, FALSE, LinkedMap< T, Hash, KeyEqual, Map >::find, findFileDef, getClass, getConcept, PageDef::getGroupDef, Doxygen::groupLinkedMap, Doxygen::inputNameLinkedMap, ModuleManager::instance, SectionManager::instance, QCString::isEmpty, Definition::isLinkable, SectionInfo::label, mangleCSharpGenericName, Definition::name, Doxygen::namespaceLinkedMap, Doxygen::pageLinkedMap, prefix, resolveRef, QCString::str, stripTemplateSpecifiersFromScope and TRUE.

Referenced by DocLink::DocLink and DocRef::DocRef.

resolveRef()

bool resolveRef (const QCString & scName, const QCString & name, bool inSeeBlock, const Definition ** resContext, const MemberDef ** resMember, SrcLangExt lang, bool lookForSpecialization=TRUE, const FileDef * currentFile=nullptr, bool checkScope=FALSE)

Returns an object to reference to given its name and context

Postcondition: return value TRUE implies *resContext!=0 or *resMember!=0

Declaration at line 138 of file util.h, definition at line 2965 of file util.cpp.

2965bool resolveRef(/* in */ const QCString &scName,

2966 /* in */ const QCString &name,

2967 /* in */ bool inSeeBlock,

2968 /* out */ const Definition **resContext,

2969 /* out */ const MemberDef **resMember,

2970 /* in */ SrcLangExt lang,

2971 bool lookForSpecialization,

2972 const FileDef *currentFile,

2973 bool checkScope

2974 )

2975{

2976 AUTO_TRACE("scope={} name={} inSeeBlock={}",scName,name,inSeeBlock);

2977 //printf("resolveRef(scope=%s,name=%s,inSeeBlock=%d)\n",qPrint(scName),qPrint(name),inSeeBlock);

2978 QCString tsName = name;

2979 //bool memberScopeFirst = tsName.find('#')!=-1;

2980 QCString fullName = substitute(tsName,"#","::");

2981 if (fullName.find("anonymous_namespace{")==-1)

2982 {

2983 fullName = removeRedundantWhiteSpace(substitute(fullName,".","::",3));

2984 }

2985 else

2986 {

2987 fullName = removeRedundantWhiteSpace(fullName);

2988 }

2989

2990 int templStartPos;

2991 if (lang==SrcLangExt::CSharp && (templStartPos=fullName.find('<'))!=-1)

2992 {

2993 int templEndPos = fullName.findRev('>');

2994 if (templEndPos!=-1)

2995 {

2996 fullName = mangleCSharpGenericName(fullName.left(templEndPos+1))+fullName.mid(templEndPos+1);

2997 AUTO_TRACE_ADD("C# mangled name='{}'",fullName);

2998 }

2999 }

3000

3001 int bracePos=findParameterList(fullName);

3002 int endNamePos=bracePos!=-1 ? bracePos : static_cast<int>(fullName.length());

3003 int scopePos=fullName.findRev("::",endNamePos);

3004 bool explicitScope = fullName.startsWith("::") && // ::scope or #scope

3005 (scopePos>2 || // ::N::A

3006 tsName.startsWith("::") || // ::foo in local scope

3007 scName==nullptr // #foo in global scope

3008 );

3009 bool allowTypeOnly=false;

3010

3011 // default result values

3012 *resContext=nullptr;

3013 *resMember=nullptr;

3014

3015 if (bracePos==-1) // simple name

3016 {

3017 // the following if() was commented out for releases in the range

3018 // 1.5.2 to 1.6.1, but has been restored as a result of bug report 594787

3019 if (!inSeeBlock && scopePos==-1 && isLowerCase(tsName))

3020 { // link to lower case only name => do not try to autolink

3021 AUTO_TRACE_ADD("false");

3022 return FALSE;

3023 }

3024

3025 ClassDef *cd=nullptr;

3026 NamespaceDef *nd=nullptr;

3027 ConceptDef *cnd=nullptr;

3028 ModuleDef *modd=nullptr;

3029

3030 //printf("scName=%s fullName=%s\n",qPrint(scName),qPrint(fullName));

3031

3032 // check if this is a class or namespace reference

3033 if (scName!=fullName && getScopeDefs(scName,fullName,cd,cnd,nd,modd))

3034 {

3035 //printf("found scopeDef\n");

3036 if (cd) // scope matches that of a class

3037 {

3038 *resContext = cd;

3039 }

3040 else if (cnd)

3041 {

3042 *resContext = cnd;

3043 }

3044 else if (modd)

3045 {

3046 *resContext = modd;

3047 }

3048 else // scope matches that of a namespace

3049 {

3050 ASSERT(nd!=nullptr);

3051 *resContext = nd;

3052 }

3053 AUTO_TRACE_ADD("true");

3054 return TRUE;

3055 }

3056 else if (scName==fullName || (!inSeeBlock && scopePos==-1))

3057 // nothing to link => output plain text

3058 {

3059 //printf("found scName=%s fullName=%s scName==fullName=%d "

3060 // "inSeeBlock=%d scopePos=%d!\n",

3061 // qPrint(scName),qPrint(fullName),scName==fullName,inSeeBlock,scopePos);

3062

3063 // at this point we have a bare word that is not a class or namespace

3064 // we should also allow typedefs or enums to be linked, but not for instance member

3065 // functions, otherwise 'Foo' would always link to the 'Foo()' constructor instead of the

3066 // 'Foo' class. So we use this flag as a filter.

3067 allowTypeOnly=true;

3068 }

3069

3070 // continue search...

3071 }

3072

3073 // extract userscope+name

3074 QCString nameStr=fullName.left(endNamePos);

3075 if (explicitScope) nameStr=nameStr.mid(2);

3076

3077

3078 // extract arguments

3079 QCString argsStr;

3080 if (bracePos!=-1) argsStr=fullName.right(fullName.length()-bracePos);

3081

3082 // strip template specifier

3083 // TODO: match against the correct partial template instantiation

3084 int templPos=nameStr.find('<');

3085 bool tryUnspecializedVersion = FALSE;

3086 if (templPos!=-1 && nameStr.find("operator")==-1)

3087 {

3088 int endTemplPos=nameStr.findRev('>');

3089 if (endTemplPos!=-1)

3090 {

3091 if (!lookForSpecialization)

3092 {

3093 nameStr=nameStr.left(templPos)+nameStr.right(nameStr.length()-endTemplPos-1);

3094 }

3095 else

3096 {

3097 tryUnspecializedVersion = TRUE;

3098 }

3099 }

3100 }

3101

3102 QCString scopeStr=scName;

3103 if (nameStr.length()>scopeStr.length() && leftScopeMatch(scopeStr,nameStr))

3104 {

3105 nameStr=nameStr.mid(scopeStr.length()+2);

3106 }

3107

3108 const GroupDef *gd = nullptr;

3109 const ConceptDef *cnd = nullptr;

3110 const ModuleDef *modd = nullptr;

3111

3112 // check if nameStr is a member or global.

3113 //printf("getDefs(scope=%s,name=%s,args=%s checkScope=%d)\n",

3114 // qPrint(scopeStr), qPrint(nameStr), qPrint(argsStr),checkScope);

3115 GetDefInput input(scopeStr,nameStr,argsStr);

3116 input.forceEmptyScope = explicitScope;

3117 input.currentFile = currentFile;

3118 input.checkCV = true;

3119 GetDefResult result = getDefs(input);

3120 if (result.found)

3121 {

3122 //printf("after getDefs checkScope=%d nameStr=%s\n",checkScope,qPrint(nameStr));

3123 if (checkScope && result.md && result.md->getOuterScope()==Doxygen::globalScope &&

3124 !result.md->isStrongEnumValue() &&

3125 (!scopeStr.isEmpty() || nameStr.find("::")>0))

3126 {

3127 // we did find a member, but it is a global one while we were explicitly

3128 // looking for a scoped variable. See bug 616387 for an example why this check is needed.

3129 // note we do need to support autolinking to "::symbol" hence the >0

3130 //printf("not global member!\n");

3131 *resContext=nullptr;

3132 *resMember=nullptr;

3133 AUTO_TRACE_ADD("false");

3134 return FALSE;

3135 }

3136 //printf("after getDefs md=%p cd=%p fd=%p nd=%p gd=%p\n",md,cd,fd,nd,gd);

3137 if (result.md)

3138 {

3139 if (!allowTypeOnly || result.md->isTypedef() || result.md->isEnumerate())

3140 {

3141 *resMember=result.md;

3142 *resContext=result.md;

3143 }

3144 else // md is not a type, but we explicitly expect one

3145 {

3146 *resContext=nullptr;

3147 *resMember=nullptr;

3148 AUTO_TRACE_ADD("false");

3149 return FALSE;

3150 }

3151 }

3152 else if (result.cd) *resContext=result.cd;

3153 else if (result.nd) *resContext=result.nd;

3154 else if (result.fd) *resContext=result.fd;

3155 else if (result.gd) *resContext=result.gd;

3156 else if (result.cnd) *resContext=result.cnd;

3157 else if (result.modd) *resContext=result.modd;

3158 else

3159 {

3160 *resContext=nullptr; *resMember=nullptr;

3161 AUTO_TRACE_ADD("false");

3162 return FALSE;

3163 }

3164 //printf("member=%s (md=%p) anchor=%s linkable()=%d context=%s\n",

3165 // qPrint(md->name()), md, qPrint(md->anchor()), md->isLinkable(), qPrint((*resContext)->name()));

3166 AUTO_TRACE_ADD("true");

3167 return TRUE;

3168 }

3169 else if (inSeeBlock && !nameStr.isEmpty() && (gd=Doxygen::groupLinkedMap->find(nameStr)))

3170 { // group link

3171 *resContext=gd;

3172 AUTO_TRACE_ADD("true");

3173 return TRUE;

3174 }

3175 else if ((cnd=Doxygen::conceptLinkedMap->find(nameStr)))

3176 {

3177 *resContext=cnd;

3178 AUTO_TRACE_ADD("true");

3179 return TRUE;

3180 }

3181 else if ((modd=ModuleManager::instance().modules().find(nameStr)))

3182 {

3183 *resContext=modd;

3184 AUTO_TRACE_ADD("true");

3185 return TRUE;

3186 }

3187 else if (tsName.find('.')!=-1) // maybe a link to a file

3188 {

3189 bool ambig = false;

3190 const FileDef *fd=findFileDef(Doxygen::inputNameLinkedMap,tsName,ambig);

3191 if (fd && !ambig)

3192 {

3193 *resContext=fd;

3194 AUTO_TRACE_ADD("true");

3195 return TRUE;

3196 }

3197 }

3198

3199 if (tryUnspecializedVersion)

3200 {

3201 bool b = resolveRef(scName,name,inSeeBlock,resContext,resMember,lang,FALSE,nullptr,checkScope);

3202 AUTO_TRACE_ADD("{}",b);

3203 return b;

3204 }

3205 if (bracePos!=-1) // Try without parameters as well, could be a constructor invocation

3206 {

3207 *resContext=getClass(fullName.left(bracePos));

3208 if (*resContext)

3209 {

3210 AUTO_TRACE_ADD("true");

3211 return TRUE;

3212 }

3213 }

3214 //printf("resolveRef: %s not found!\n",qPrint(name));

3215

3216 AUTO_TRACE_ADD("false");

3217 return FALSE;

3218}

References ASSERT, AUTO_TRACE, AUTO_TRACE_ADD, GetDefResult::cd, GetDefInput::checkCV, GetDefResult::cnd, Doxygen::conceptLinkedMap, GetDefInput::currentFile, FALSE, GetDefResult::fd, QCString::find, findFileDef, findParameterList, QCString::findRev, GetDefInput::forceEmptyScope, GetDefResult::found, GetDefResult::gd, getClass, getDefs, Definition::getOuterScope, getScopeDefs, Doxygen::globalScope, Doxygen::groupLinkedMap, Doxygen::inputNameLinkedMap, ModuleManager::instance, QCString::isEmpty, MemberDef::isEnumerate, isLowerCase, MemberDef::isStrongEnumValue, MemberDef::isTypedef, QCString::left, leftScopeMatch, QCString::length, mangleCSharpGenericName, GetDefResult::md, QCString::mid, GetDefResult::modd, GetDefResult::nd, removeRedundantWhiteSpace, resolveRef, QCString::right, QCString::startsWith, substitute and TRUE.

Referenced by DocParser::handleLinkedWord, resolveLink and resolveRef.

resolveTypeDef()

QCString resolveTypeDef (const Definition * d, const QCString & name, const Definition ** typedefContext=nullptr)

Declaration at line 307 of file util.h, definition at line 385 of file util.cpp.

385QCString resolveTypeDef(const Definition *context,const QCString &qualifiedName,

386 const Definition **typedefContext)

387{

388 AUTO_TRACE("context='{}' qualifiedName='{}'",context?context->name():"",qualifiedName);

389 QCString result;

390 if (qualifiedName.isEmpty())

391 {

392 AUTO_TRACE_EXIT("empty name");

393 return result;

394 }

395

396 const Definition *mContext=context;

397 if (typedefContext) *typedefContext=context;

398

399 // see if the qualified name has a scope part

400 if (qualifiedName.find('<')!=-1)

401 {

402 AUTO_TRACE_EXIT("template");

403 return result;

404 }

405 int scopeIndex = qualifiedName.findRev("::");

406 QCString resName=qualifiedName;

407 if (scopeIndex!=-1) // strip scope part for the name

408 {

409 resName=qualifiedName.right(qualifiedName.length()-scopeIndex-2);

410 if (resName.isEmpty())

411 {

412 AUTO_TRACE_EXIT("invalid format");

413 return result;

414 }

415 }

416 const MemberDef *md=nullptr;

417 while (mContext && md==nullptr)

418 {

419 // step 1: get the right scope

420 const Definition *resScope=mContext;

421 if (scopeIndex!=-1)

422 {

423 // split-off scope part

424 QCString resScopeName = qualifiedName.left(scopeIndex);

425 //printf("resScopeName='%s'\n",qPrint(resScopeName));

426

427 // look-up scope in context

428 int is=0,ps=0,l=0;

429 while ((is=getScopeFragment(resScopeName,ps,&l))!=-1)

430 {

431 QCString qualScopePart = resScopeName.mid(is,l);

432 QCString tmp = resolveTypeDef(mContext,qualScopePart);

433 if (!tmp.isEmpty()) qualScopePart=tmp;

434 resScope = resScope->findInnerCompound(qualScopePart);

435 //printf("qualScopePart='%s' resScope=%p\n",qPrint(qualScopePart),resScope);

436 if (resScope==nullptr) break;

437 ps=is+l;

438 }

439 }

440 AUTO_TRACE_ADD("resScope='{}' resName='{}'",resScope?resScope->name():"",resName);

441

442 // step 2: get the member

443 if (resScope) // no scope or scope found in the current context

444 {

445 //printf("scope found: %s, look for typedef %s\n",

446 // qPrint(resScope->qualifiedName()),qPrint(resName));

447 MemberNameLinkedMap *mnd=nullptr;

448 bool searchRelated=false;

449 bool mustBeRelated=false;

450 if (resScope->definitionType()==Definition::TypeClass)

451 {

452 mnd=Doxygen::memberNameLinkedMap;

453 }

454 else

455 {

456 mnd=Doxygen::functionNameLinkedMap;

457 searchRelated=true;

458 }

459 MemberName *mn=mnd->find(resName);

460 if (mn==0 && searchRelated)

461 {

462 mn=Doxygen::memberNameLinkedMap->find(resName);

463 mustBeRelated=true;

464 }

465 if (mn)

466 {

467 int minDist=-1;

468 for (const auto &tmd_p : *mn)

469 {

470 const MemberDef *tmd = tmd_p.get();

471 AUTO_TRACE_ADD("found candidate member '{}' isTypeDef={}' isRelated={} mustBeRelated={}",

472 tmd->name(),tmd->isTypedef(),tmd->isRelated(),mustBeRelated);

473 //printf("Found member %s resScope=%s outerScope=%s mContext=%p\n",

474 // qPrint(tmd->name()),qPrint( resScope->name()),

475 // qPrint(tmd->getOuterScope()->name()), mContext);

476 if (tmd->isTypedef())

477 {

478 if (resScope==Doxygen::globalScope && tmd->isRelated() && mustBeRelated)

479 {

480 md = tmd;

481 }

482 else

483 {

484 SymbolResolver resolver;

485 int dist=resolver.isAccessibleFrom(resScope,tmd);

486 if (dist!=-1 && (md==nullptr || dist<minDist))

487 {

488 md = tmd;

489 minDist = dist;

490 }

491 }

492 }

493 }

494 }

495 }

496 mContext=mContext->getOuterScope();

497 }

498

499 AUTO_TRACE_ADD("md='{}'",md?md->name():"");

500 // step 3: get the member's type

501 if (md)

502 {

503 //printf(">>resolveTypeDef: Found typedef name '%s' in scope '%s' value='%s' args='%s'\n",

504 // qPrint(qualifiedName),qPrint(context->name()),qPrint(md->typeString()),qPrint(md->argsString())

505 // );

506 result=md->typeString();

507 QCString args = md->argsString();

508 if (args.find(")(")!=-1) // typedef of a function/member pointer

509 {

510 result+=args;

511 }

512 else if (args.find('[')!=-1) // typedef of an array

513 {

514 result+=args;

515 }

516 if (typedefContext) *typedefContext=md->getOuterScope();

517 }

518 else

519 {

520 //printf(">>resolveTypeDef: Typedef '%s' not found in scope '%s'!\n",

521 // qPrint(qualifiedName),context ? qPrint(context->name()) : "<global>");

522 }

523 AUTO_TRACE_EXIT("result='{}'",result);

524 return result;

525}

References MemberDef::argsString, AUTO_TRACE, AUTO_TRACE_ADD, AUTO_TRACE_EXIT, Definition::definitionType, LinkedMap< T, Hash, KeyEqual, Map >::find, QCString::find, Definition::findInnerCompound, QCString::findRev, Doxygen::functionNameLinkedMap, Definition::getOuterScope, getScopeFragment, Doxygen::globalScope, SymbolResolver::isAccessibleFrom, QCString::isEmpty, MemberDef::isRelated, MemberDef::isTypedef, QCString::left, QCString::length, Doxygen::memberNameLinkedMap, QCString::mid, Definition::name, resolveTypeDef, QCString::right, Definition::TypeClass and MemberDef::typeString.

Referenced by findUsedClassesForClass, getCanonicalTemplateSpec, getCanonicalTypeForIdentifier, isVarWithConstructor and resolveTypeDef.

rightScopeMatch()

bool rightScopeMatch (const QCString & scope, const QCString & name)

Declaration at line 236 of file util.h, definition at line 882 of file util.cpp.

882bool rightScopeMatch(const QCString &scope, const QCString &name)

883{

884 size_t sl=scope.length();

885 size_t nl=name.length();

886 return (name==scope || // equal

887 (scope.right(nl)==name && // substring

888 sl>1+nl && scope.at(sl-nl-1)==':' && scope.at(sl-nl-2)==':' // scope

889 )

890 );

891}

References QCString::at, QCString::length and QCString::right.

Referenced by addMemberFunction, findScopeFromQualifiedName, getDefsOld and isRecursiveBaseClass.

selectBlocks()

QCString selectBlocks (const QCString & s, const SelectionBlockList & blockList, const SelectionMarkerInfo & markerInfo)

remove disabled blocks and all block markers from s and return the result as a string

Declaration at line 195 of file util.h, definition at line 6924 of file util.cpp.

6924QCString selectBlocks(const QCString &s,const SelectionBlockList &blockList,const SelectionMarkerInfo &markerInfo)

6925{

6926 if (s.isEmpty()) return s;

6927

6928 // helper to find the end of a block

6929 auto skipBlock = [&markerInfo](const char *p,const SelectionBlock &blk)

6930 {

6931 char c = 0;

6932 while ((c=*p))

6933 {

6934 if (c==markerInfo.markerChar && qstrncmp(p,markerInfo.endStr,markerInfo.endLen)==0) // end marker

6935 {

6936 size_t len = markerInfo.endLen;

6937 bool negate = *(p+markerInfo.endLen)=='!';

6938 if (negate) len++;

6939 size_t blkNameLen = qstrlen(blk.name);

6940 if (qstrncmp(p+len,blk.name,blkNameLen)==0 && // matching marker name

6941 qstrncmp(p+len+blkNameLen,markerInfo.closeStr,markerInfo.closeLen)==0) // matching marker closing

6942 {

6943 //printf("Found end marker %s enabled=%d negate=%d\n",blk.name,blk.enabled,negate);

6944 return p+len+blkNameLen+markerInfo.closeLen;

6945 }

6946 else // not the right marker id

6947 {

6948 p++;

6949 }

6950 }

6951 else // not and end marker

6952 {

6953 p++;

6954 }

6955 }

6956 return p;

6957 };

6958

6959 QCString result;

6960 result.reserve(s.length());

6961 const char *p = s.data();

6962 char c = 0;

6963 while ((c=*p))

6964 {

6965 if (c==markerInfo.markerChar) // potential start of marker

6966 {

6967 if (qstrncmp(p,markerInfo.beginStr,markerInfo.beginLen)==0) // start of begin marker

6968 {

6969 bool found = false;

6970 size_t len = markerInfo.beginLen;

6971 bool negate = *(p+len)=='!';

6972 if (negate) len++;

6973 for (const auto &blk : blockList)

6974 {

6975 size_t blkNameLen = qstrlen(blk.name);

6976 if (qstrncmp(p+len,blk.name,blkNameLen)==0 && // matching marker name

6977 qstrncmp(p+len+blkNameLen,markerInfo.closeStr,markerInfo.closeLen)==0) // matching marker closing

6978 {

6979 bool blockEnabled = blk.enabled!=negate;

6980 //printf("Found start marker %s enabled=%d negate=%d\n",blk.name,blk.enabled,negate);

6981 p+=len+blkNameLen+markerInfo.closeLen;

6982 if (!blockEnabled) // skip until the end of the block

6983 {

6984 //printf("skipping block\n");

6985 p=skipBlock(p,blk);

6986 }

6987 found=true;

6988 break;

6989 }

6990 }

6991 if (!found) // unknown marker id

6992 {

6993 result+=c;

6994 p++;

6995 }

6996 }

6997 else if (qstrncmp(p,markerInfo.endStr,markerInfo.endLen)==0) // start of end marker

6998 {

6999 bool found = false;

7000 size_t len = markerInfo.endLen;

7001 bool negate = *(p+len)=='!';

7002 if (negate) len++;

7003 for (const auto &blk : blockList)

7004 {

7005 size_t blkNameLen = qstrlen(blk.name);

7006 if (qstrncmp(p+len,blk.name,blkNameLen)==0 && // matching marker name

7007 qstrncmp(p+len+blkNameLen,markerInfo.closeStr,markerInfo.closeLen)==0) // matching marker closing

7008 {

7009 //printf("Found end marker %s enabled=%d negate=%d\n",blk.name,blk.enabled,negate);

7010 p+=len+blkNameLen+markerInfo.closeLen;

7011 found=true;

7012 break;

7013 }

7014 }

7015 if (!found) // unknown marker id

7016 {

7017 result+=c;

7018 p++;

7019 }

7020 }

7021 else // not a start or end marker

7022 {

7023 result+=c;

7024 p++;

7025 }

7026 }

7027 else // not a marker character

7028 {

7029 result+=c;

7030 p++;

7031 }

7032 }

7033 //printf("====\n%s\n-----\n%s\n~~~~\n",qPrint(s),qPrint(result));

7034 return result;

7035}

References SelectionMarkerInfo::beginLen, SelectionMarkerInfo::beginStr, SelectionMarkerInfo::closeLen, SelectionMarkerInfo::closeStr, QCString::data, SelectionMarkerInfo::endLen, SelectionMarkerInfo::endStr, QCString::isEmpty, QCString::length, SelectionMarkerInfo::markerChar, qstrlen, qstrncmp and QCString::reserve.

Referenced by substituteHtmlKeywords and substituteLatexKeywords.

showFileDefMatches()

QCString showFileDefMatches (const FileNameLinkedMap * fnMap, const QCString & n)

Declaration at line 204 of file util.h, definition at line 3542 of file util.cpp.

3542QCString showFileDefMatches(const FileNameLinkedMap *fnMap,const QCString &n)

3543{

3544 QCString result;

3545 QCString name=n;

3546 QCString path;

3547 int slashPos=std::max(name.findRev('/'),name.findRev('\\'));

3548 if (slashPos!=-1)

3549 {

3550 path=name.left(slashPos+1);

3551 name=name.right(name.length()-slashPos-1);

3552 }

3553 const FileName *fn=fnMap->find(name);

3554 if (fn)

3555 {

3556 bool first = true;

3557 for (const auto &fd : *fn)

3558 {

3559 if (path.isEmpty() || fd->getPath().right(path.length())==path)

3560 {

3561 if (!first) result += "\n";

3562 else first = false;

3563 result+=" "+fd->absFilePath();

3564 }

3565 }

3566 }

3567 return result;

3568}

References LinkedMap< T, Hash, KeyEqual, Map >::find, QCString::findRev, QCString::isEmpty, QCString::left, QCString::length and QCString::right.

Referenced by addIncludeFile, buildFileList, DocParser::findAndCopyImage, DocDiaFile::parse, DocDotFile::parse, DocMscFile::parse, DocPlantUmlFile::parse, readIncludeFile, DocParser::readTextFileByName and readTextFileByName.

split()

StringVector split (const std::string & s, const std::string & delimiter)

split input string s by string delimiter delimiter.

returns a vector of non-empty strings that are between the delimiters

Declaration at line 458 of file util.h, definition at line 7133 of file util.cpp.

7133StringVector split(const std::string &s,const std::string &delimiter)

7134{

7135 StringVector result;

7136 size_t prev = 0, pos = 0, len = s.length();

7137 do

7138 {

7139 pos = s.find(delimiter, prev);

7140 if (pos == std::string::npos) pos = len;

7141 if (pos>prev) result.push_back(s.substr(prev,pos-prev));

7142 prev = pos + delimiter.length();

7143 }

7144 while (pos<len && prev<len);

7145 return result;

7146}

Referenced by VHDLOutlineParser::addProto, VHDLOutlineParser::addVhdlType, FlowChart::alignCommentNode, anonymous{tagreader.cpp}::TagFileParser::buildLists, VHDLOutlineParser::checkInlineCode, checkVhdlString, VHDLOutlineParser::createFunction, VhdlDocGen::findArchitecture, CitationManager::generatePage, getFilteredImageAttributes, VhdlDocGen::getIndexWord, DocPara::handleCite, DocPara::handleCommand, DocParser::handleImage, DocPara::handleInclude, Qhp::initialize, VhdlDocGen::parseForBinding, VhdlDocGen::parseForConfig, parseIncludeOptions, writeFuncProto, VhdlDocGen::writeInlineClassLink and VhdlDocGen::writeRecUnitDocu.

split()

StringVector split (const std::string & s, const reg::Ex & delimiter)

split input string s by regular expression delimiter delimiter.

returns a vector of non-empty strings that are between the delimiters

Declaration at line 459 of file util.h, definition at line 7150 of file util.cpp.

7150StringVector split(const std::string &s,const reg::Ex &delimiter)

7151{

7152 StringVector result;

7153 reg::Iterator iter(s, delimiter);

7154 reg::Iterator end;

7155 size_t p=0;

7156 for ( ; iter != end; ++iter)

7157 {

7158 const auto &match = *iter;

7159 size_t i=match.position();

7160 size_t l=match.length();

7161 if (i>p) result.push_back(s.substr(p,i-p));

7162 p=i+l;

7163 }

7164 if (p<s.length()) result.push_back(s.substr(p));

7165 return result;

7166}

Reference end.

stackTrace()

void stackTrace ()

Declaration at line 393 of file util.h, definition at line 5987 of file util.cpp.

5987void stackTrace()

5988{

5989#ifdef TRACINGSUPPORT

5990 void *backtraceFrames[128];

5991 int frameCount = backtrace(backtraceFrames, 128);

5992 const size_t cmdLen = 40960;

5993 static char cmd[cmdLen];

5994 char *p = cmd;

5995 p += qsnprintf(p,cmdLen,"/usr/bin/atos -p %d ", (int)getpid());

5996 for (int x = 0; x < frameCount; x++)

5997 {

5998 p += qsnprintf(p,cmdLen,"%p ", backtraceFrames[x]);

5999 }

6000 fprintf(stderr,"========== STACKTRACE START ==============\n");

6001 if (FILE *fp = Portable::popen(cmd, "r"))

6002 {

6003 char resBuf[512];

6004 while (size_t len = fread(resBuf, 1, sizeof(resBuf), fp))

6005 {

6006 fwrite(resBuf, 1, len, stderr);

6007 }

6008 Portable::pclose(fp);

6009 }

6010 fprintf(stderr,"============ STACKTRACE END ==============\n");

6011 //fprintf(stderr,"%s\n", frameStrings[x]);

6012#endif

6013}

References Portable::pclose, Portable::popen and qsnprintf.

stripAnonymousNamespaceScope()

QCString stripAnonymousNamespaceScope (const QCString & s)

Declaration at line 230 of file util.h, definition at line 242 of file util.cpp.

242QCString stripAnonymousNamespaceScope(const QCString &s)

243{

244 int i=0,p=0,l=0;

245 QCString newScope;

246 int sl = static_cast<int>(s.length());

247 while ((i=getScopeFragment(s,p,&l))!=-1)

248 {

249 //printf("Scope fragment %s\n",qPrint(s.mid(i,l)));

250 if (Doxygen::namespaceLinkedMap->find(s.left(i+l))!=nullptr)

251 {

252 if (s.at(i)!='@')

253 {

254 if (!newScope.isEmpty()) newScope+="::";

255 newScope+=s.mid(i,l);

256 }

257 }

258 else if (i<sl)

259 {

260 if (!newScope.isEmpty()) newScope+="::";

261 newScope+=s.right(sl-i);

262 goto done;

263 }

264 p=i+l;

265 }

266done:

267 //printf("stripAnonymousNamespaceScope('%s')='%s'\n",qPrint(s),qPrint(newScope));

268 return newScope;

269}

References QCString::at, getScopeFragment, QCString::isEmpty, QCString::left, QCString::length, QCString::mid, Doxygen::namespaceLinkedMap and QCString::right.

Referenced by addMemberFunction, addPageToContext, addVariable, buildNamespaceList, computeTemplateClassRelations, extractClassName, findGroupScope, findUsingDeclImports, findUsingDirectives, MemberDefImpl::getClassDefOfAnonymousType and resolveClassNestingRelations.

stripExtension()

QCString stripExtension (const QCString & fName)

Declaration at line 350 of file util.h, definition at line 5438 of file util.cpp.

5438QCString stripExtension(const QCString &fName)

5439{

5440 return stripExtensionGeneral(fName, Doxygen::htmlFileExtension);

5441}

References Doxygen::htmlFileExtension and stripExtensionGeneral.

Referenced by anonymous{tagreader.cpp}::TagFileParser::buildLists, ClassDefImpl::ClassDefImpl and MemberDefImpl::setTagInfo.

stripExtensionGeneral()

QCString stripExtensionGeneral (const QCString & fName, const QCString & ext)

Declaration at line 348 of file util.h, definition at line 5428 of file util.cpp.

5428QCString stripExtensionGeneral(const QCString &fName, const QCString &ext)

5429{

5430 QCString result=fName;

5431 if (result.right(ext.length())==ext)

5432 {

5433 result=result.left(result.length()-ext.length());

5434 }

5435 return result;

5436}

References QCString::left, QCString::length and QCString::right.

Referenced by TooltipManager::addTooltip, anonymous{tagreader.cpp}::TagFileParser::buildLists, extraLatexStyleSheet, MarkdownOutlineParser::parseInput, stripExtension, DocbookCodeGenerator::writeCodeLinkLine, LatexCodeGenerator::writeLineNumber and RTFCodeGenerator::writeLineNumber.

stripFromIncludePath()

QCString stripFromIncludePath (const QCString & path)

strip part of path if it matches one of the paths in the Config_getList(INCLUDE_PATH) list

Declaration at line 234 of file util.h, definition at line 341 of file util.cpp.

341QCString stripFromIncludePath(const QCString &path)

342{

343 return stripFromPath(path,Config_getList(STRIP_FROM_INC_PATH));

344}

References Config_getList and stripFromPath.

Referenced by MemberDefImpl::_writeGroupInclude, addIncludeFile and findFileDef.

stripFromPath()

QCString stripFromPath (const QCString & path)

strip part of path if it matches one of the paths in the Config_getList(STRIP_FROM_PATH) list

Declaration at line 232 of file util.h, definition at line 333 of file util.cpp.

333QCString stripFromPath(const QCString &path)

334{

335 return stripFromPath(path,Config_getList(STRIP_FROM_PATH));

336}

References Config_getList and stripFromPath.

stripIndentation()

QCString stripIndentation (const QCString & s, bool skipFirstLine=false)

Declaration at line 439 of file util.h, definition at line 6466 of file util.cpp.

6466QCString stripIndentation(const QCString &s,bool skipFirstLine)

6467{

6468 if (s.isEmpty()) return s; // empty string -> we're done

6469

6470 //printf("stripIndentation:\n%s\n------\n",qPrint(s));

6471 // compute minimum indentation over all lines

6472 const char *p=s.data();

6473 char c=0;

6474 int indent=0;

6475 int minIndent=1000000; // "infinite"

6476 bool searchIndent=true;

6477 int tabSize=Config_getInt(TAB_SIZE);

6478 bool skipFirst = skipFirstLine;

6479 while ((c=*p++))

6480 {

6481 if (c=='\t') indent+=tabSize - (indent%tabSize);

6482 else if (c=='\n') indent=0,searchIndent=true,skipFirst=false;

6483 else if (c==' ') indent++;

6484 else if (searchIndent && !skipFirst)

6485 {

6486 searchIndent=false;

6487 if (indent<minIndent) minIndent=indent;

6488 }

6489 }

6490

6491 // no indent to remove -> we're done

6492 if (minIndent==0) return substitute(s,"@ilinebr","\\ilinebr");

6493

6494 // remove minimum indentation for each line

6495 TextStream result;

6496 p=s.data();

6497 indent=0;

6498 skipFirst=skipFirstLine;

6499 while ((c=*p++))

6500 {

6501 if (c=='\n') // start of new line

6502 {

6503 indent=0;

6504 result << c;

6505 skipFirst=false;

6506 }

6507 else if (indent<minIndent && !skipFirst) // skip until we reach minIndent

6508 {

6509 if (c=='\t')

6510 {

6511 int newIndent = indent+tabSize-(indent%tabSize);

6512 int i=newIndent;

6513 while (i>minIndent) // if a tab crosses the minIndent boundary fill the rest with spaces

6514 {

6515 result << ' ';

6516 i--;

6517 }

6518 indent=newIndent;

6519 }

6520 else // space

6521 {

6522 indent++;

6523 }

6524 }

6525 else if (c=='\\' && literal_at(p,"ilinebr "))

6526 // we also need to remove the indentation after a \ilinebr command at the end of a line

6527 {

6528 result << "\\ilinebr ";

6529 p+=8;

6530 int skipAmount=0;

6531 for (int j=0;j<minIndent;j++) if (*(p+j)==' ') skipAmount++; // test to see if we have the indent

6532 if (skipAmount==minIndent)

6533 {

6534 p+=skipAmount; // remove the indent

6535 }

6536 }

6537 else if (c=='@' && literal_at(p,"ilinebr"))

6538 {

6539 result << "\\ilinebr";

6540 p+=7;

6541 }

6542 else // copy anything until the end of the line

6543 {

6544 result << c;

6545 }

6546 }

6547

6548 //printf("stripIndentation: result=\n%s\n------\n",qPrint(result.str()));

6549

6550 return result.str();

6551}

References Config_getInt, QCString::data, QCString::isEmpty, literal_at, TextStream::str and substitute.

Referenced by handleCommentBlock, handleCommentBlock, handleCommentBlock, handleParametersCommentBlocks, DocPara::handleStartCode and MarkdownOutlineParser::parseInput.

stripIndentationVerbatim()

void stripIndentationVerbatim (QCString & doc, const int indentationLevel)

Declaration at line 440 of file util.h, definition at line 6554 of file util.cpp.

6554void stripIndentationVerbatim(QCString &doc,const int indentationLevel)

6555{

6556 //printf("stripIndentationVerbatim(level=%d):\n%s\n------\n",indentationLevel,qPrint(doc));

6557 if (indentationLevel <= 0 || doc.isEmpty()) return; // nothing to strip

6558

6559 // by stripping content the string will only become shorter so we write the results

6560 // back into the input string and then resize it at the end.

6561 char c = 0;

6562 const char *src = doc.data();

6563 char *dst = doc.rawData();

6564 bool insideIndent = false; // skip the initial line from stripping

6565 int cnt = 0;

6566 while ((c=*src++))

6567 {

6568 // invariant: dst<=src

6569 switch(c)

6570 {

6571 case '\n':

6572 *dst++ = c;

6573 insideIndent = true;

6574 cnt = indentationLevel;

6575 break;

6576 case ' ':

6577 if (insideIndent)

6578 {

6579 if (cnt>0) // count down the spacing until the end of the indent

6580 {

6581 cnt--;

6582 }

6583 else // reached the end of the indent, start of the part of the line to keep

6584 {

6585 insideIndent = false;

6586 *dst++ = c;

6587 }

6588 }

6589 else // part after indent, copy to the output

6590 {

6591 *dst++ = c;

6592 }

6593 break;

6594 default:

6595 insideIndent = false;

6596 *dst++ = c;

6597 break;

6598 }

6599 }

6600 doc.resize(static_cast<uint32_t>(dst-doc.data()));

6601 //printf("stripIndentationVerbatim: result=\n%s\n------\n",qPrint(doc));

6602}

References QCString::data, QCString::isEmpty, QCString::rawData and QCString::resize.

stripLeadingAndTrailingEmptyLines()

QCString stripLeadingAndTrailingEmptyLines (const QCString & s, int & docLine)

Special version of QCString::stripWhiteSpace() that only strips completely blank lines.

Parameters

s	the string to be stripped
docLine	the line number corresponding to the start of the string. This will be adjusted based on the number of lines stripped from the start.

Returns: The stripped string.

Declaration at line 371 of file util.h, definition at line 5541 of file util.cpp.

5541QCString stripLeadingAndTrailingEmptyLines(const QCString &s,int &docLine)

5542{

5543 if (s.isEmpty()) return QCString();

5544 const char *p = s.data();

5545

5546 // search for leading empty lines

5547 int i=0,li=-1,l=static_cast<int>(s.length());

5548 char c = 0;

5549 while ((c=*p))

5550 {

5551 if (c==' ' || c=='\t' || c=='\r') i++,p++;

5552 else if (c=='\\' && literal_at(p,"\\ilinebr")) i+=8,li=i,p+=8;

5553 else if (c=='\n') i++,li=i,docLine++,p++;

5554 else break;

5555 }

5556

5557 // search for trailing empty lines

5558 int b=l-1,bi=-1;

5559 p=s.data()+b;

5560 while (b>=0)

5561 {

5562 c=*p;

5563 if (c==' ' || c=='\t' || c=='\r') b--,p--;

5564 else if (c=='r' && b>=7 && literal_at(p-7,"\\ilinebr")) bi=b-7,b-=8,p-=8;

5565 else if (c=='>' && b>=11 && literal_at(p-11,"\\ilinebr<br>")) bi=b-11,b-=12,p-=12;

5566 else if (c=='\n') bi=b,b--,p--;

5567 else break;

5568 }

5569

5570 // return whole string if no leading or trailing lines where found

5571 if (li==-1 && bi==-1) return s;

5572

5573 // return substring

5574 if (bi==-1) bi=l;

5575 if (li==-1) li=0;

5576 if (bi<=li) return QCString(); // only empty lines

5577 //printf("docLine='%s' len=%d li=%d bi=%d\n",qPrint(s),s.length(),li,bi);

5578 return s.mid(li,bi-li);

5579}

References QCString::data, QCString::isEmpty, QCString::length, literal_at and QCString::mid.

Referenced by DefinitionImpl::_setBriefDescription, DocGroup::addDocs, VHDLOutlineParser::checkInlineCode, DocPara::handleCommand, CommentScanner::parseCommentBlock and toDefinition.

stripPath()

QCString stripPath (const QCString & s)

Declaration at line 365 of file util.h, definition at line 5465 of file util.cpp.

5465QCString stripPath(const QCString &s)

5466{

5467 QCString result=s;

5468 int i=result.findRev('/');

5469 if (i!=-1)

5470 {

5471 result=result.mid(i+1);

5472 }

5473 i=result.findRev('\\');

5474 if (i!=-1)

5475 {

5476 result=result.mid(i+1);

5477 }

5478 return result;

5479}

References QCString::findRev and QCString::mid.

stripScope()

QCString stripScope (const QCString & name)

Strips the scope from a name. Examples: A::B will return A and A<T>::B<N::C<D> > will return A<T>.

Declaration at line 271 of file util.h, definition at line 4296 of file util.cpp.

4296QCString stripScope(const QCString &name)

4297{

4298 QCString result = name;

4299 int l = static_cast<int>(result.length());

4300 int p = 0;

4301 bool done = FALSE;

4302 bool skipBracket=FALSE; // if brackets do not match properly, ignore them altogether

4303 int count=0;

4304 int round=0;

4305

4306 do

4307 {

4308 p=l-1; // start at the end of the string

4309 while (p>=0 && count>=0)

4310 {

4311 char c=result.at(p);

4312 switch (c)

4313 {

4314 case ':':

4315 // only exit in the case of ::

4316 //printf("stripScope(%s)=%s\n",name,qPrint(result.right(l-p-1)));

4317 if (p>0 && result.at(p-1)==':' && (count==0 || skipBracket))

4318 {

4319 return result.right(l-p-1);

4320 }

4321 p--;

4322 break;

4323 case '>':

4324 if (skipBracket) // we don't care about brackets

4325 {

4326 p--;

4327 }

4328 else // count open/close brackets

4329 {

4330 if (p>0 && result.at(p-1)=='>') // skip >> operator

4331 {

4332 p-=2;

4333 break;

4334 }

4335 count=1;

4336 //printf("pos < = %d\n",p);

4337 p--;

4338 bool foundMatch=false;

4339 while (p>=0 && !foundMatch)

4340 {

4341 c=result.at(p--);

4342 switch (c)

4343 {

4344 case ')':

4345 round++;

4346 break;

4347 case '(':

4348 round--;

4349 break;

4350 case '>': // ignore > inside (...) to support e.g. (sizeof(T)>0) inside template parameters

4351 if (round==0) count++;

4352 break;

4353 case '<':

4354 if (round==0)

4355 {

4356 if (p>0)

4357 {

4358 if (result.at(p-1) == '<') // skip << operator

4359 {

4360 p--;

4361 break;

4362 }

4363 }

4364 count--;

4365 foundMatch = count==0;

4366 }

4367 break;

4368 default:

4369 //printf("c=%c count=%d\n",c,count);

4370 break;

4371 }

4372 }

4373 }

4374 //printf("pos > = %d\n",p+1);

4375 break;

4376 default:

4377 p--;

4378 }

4379 }

4380 done = count==0 || skipBracket; // reparse if brackets do not match

4381 skipBracket=TRUE;

4382 }

4383 while (!done); // if < > unbalanced repeat ignoring them

4384 //printf("stripScope(%s)=%s\n",name,name);

4385 return name;

4386}

References QCString::at, FALSE, QCString::length, QCString::right and TRUE.

Referenced by DotClassGraph::addClass, DocRef::DocRef, generateJSLink, getCanonicalTypeForIdentifier, DefinitionImpl::Private::init, DiagramItem::label, NamespaceDefImpl::writeBriefDescription and ClassDefImpl::writeIncludeFilesForSlice.

stripTemplateSpecifiersFromScope()

QCString stripTemplateSpecifiersFromScope (const QCString & fullName, bool parentOnly=TRUE, QCString * pLastScopeStripped=nullptr, QCString scopeName=QCString(), bool allowArtificial=true)

Strips template specifiers from scope fullName, except those that make up specialized classes. The switch parentOnly determines whether or not a template "at the end" of a scope should be considered, e.g. with parentOnly is TRUE, A<T>::B<S> will try to strip <T> and not <S>, while parentOnly is FALSE will strip both unless A<T> or B<S> are specialized template classes.

Declaration at line 301 of file util.h, definition at line 5030 of file util.cpp.

5030QCString stripTemplateSpecifiersFromScope(const QCString &fullName,

5031 bool parentOnly,

5032 QCString *pLastScopeStripped,

5033 QCString scopeName,

5034 bool allowArtificial)

5035{

5036 //printf("stripTemplateSpecifiersFromScope(name=%s,scopeName=%s)\n",qPrint(fullName),qPrint(scopeName));

5037 int i=fullName.find('<');

5038 if (i==-1) return fullName;

5039 QCString result;

5040 int p=0;

5041 int l=static_cast<int>(fullName.length());

5042 while (i!=-1)

5043 {

5044 //printf("1:result+=%s\n",qPrint(fullName.mid(p,i-p)));

5045 int e=i+1;

5046 int count=1;

5047 int round=0;

5048 while (e<l && count>0)

5049 {

5050 char c=fullName.at(e++);

5051 switch (c)

5052 {

5053 case '(': round++; break;

5054 case ')': if (round>0) round--; break;

5055 case '<': if (round==0) count++; break;

5056 case '>': if (round==0) count--; break;

5057 default:

5058 break;

5059 }

5060 }

5061 int si= fullName.find("::",e);

5062

5063 if (parentOnly && si==-1) break;

5064 // we only do the parent scope, so we stop here if needed

5065

5066 result+=fullName.mid(p,i-p);

5067 //printf(" trying %s\n",qPrint(mergeScopes(scopeName,result+fullName.mid(i,e-i))));

5068 ClassDef *cd = getClass(mergeScopes(scopeName,result+fullName.mid(i,e-i)));

5069 if (cd!=nullptr && (allowArtificial || !cd->isArtificial()))

5070 {

5071 result+=fullName.mid(i,e-i);

5072 //printf(" 2:result+=%s\n",qPrint(fullName.mid(i,e-i-1)));

5073 }

5074 else if (pLastScopeStripped)

5075 {

5076 //printf(" last stripped scope '%s'\n",qPrint(fullName.mid(i,e-i)));

5077 *pLastScopeStripped=fullName.mid(i,e-i);

5078 }

5079 p=e;

5080 i=fullName.find('<',p);

5081 }

5082 result+=fullName.right(l-p);

5083 //printf("3:result+=%s\n",qPrint(fullName.right(l-p)));

5084 //printf("end result=%s\n",qPrint(result));

5085 return result;

5086}

References QCString::at, QCString::find, getClass, Definition::isArtificial, QCString::length, mergeScopes, QCString::mid and QCString::right.

Referenced by addClassToContext, addMemberFunction, addVariable, buildFunctionList, computeTemplateClassRelations, extractClassName, findMember, findScopeFromQualifiedName, findUsingDeclImports, getCanonicalTypeForIdentifier, getDefsOld, SymbolResolver::Private::getResolvedSymbolRec, SymbolResolver::Private::getResolvedTypeRec, SymbolResolver::Private::newResolveTypedef and resolveLink.

substituteClassNames()

QCString substituteClassNames (const QCString & s)

Definition at line 174 of file util.h.

substituteKeywords()

QCString substituteKeywords (const QCString & file, const QCString & s, const KeywordSubstitutionList & keywords)

Declaration at line 250 of file util.h, definition at line 3572 of file util.cpp.

3572QCString substituteKeywords(const QCString &file, const QCString &s,const KeywordSubstitutionList &keywords)

3573{

3574 std::string substRes;

3575 int line = 1;

3576 const char *p = s.data();

3577 if (p)

3578 {

3579 // reserve some room for expansion

3580 substRes.reserve(s.length()+1024);

3581 char c = 0;

3582 while ((c=*p))

3583 {

3584 bool found = false;

3585 if (c=='$')

3586 {

3587 for (const auto &kw : keywords)

3588 {

3589 size_t keyLen = qstrlen(kw.keyword);

3590 if (qstrncmp(p,kw.keyword,keyLen)==0)

3591 {

3592 const char *startArg = p+keyLen;

3593 bool expectParam = std::holds_alternative<KeywordSubstitution::GetValueWithParam>(kw.getValueVariant);

3594 //printf("%s: expectParam=%d *startArg=%c\n",kw.keyword,expectParam,*startArg);

3595 if (expectParam && *startArg=='(') // $key(value)

3596 {

3597 size_t j=1;

3598 const char *endArg = nullptr;

3599 while ((c=*(startArg+j)) && c!=')' && c!='\n' && c!=0) j++;

3600 if (c==')') endArg=startArg+j;

3601 if (endArg)

3602 {

3603 QCString value = QCString(startArg+1).left(endArg-startArg-1);

3604 auto &&getValue = std::get<KeywordSubstitution::GetValueWithParam>(kw.getValueVariant);

3605 substRes+=getValue(value).str();

3606 p=endArg+1;

3607 //printf("found '%s'->'%s'\n",kw.keyword,qPrint(getValue(value)));

3608 }

3609 else

3610 {

3611 //printf("missing argument\n");

3612 warn(file,line,"Missing argument for '{}'",kw.keyword);

3613 p+=keyLen;

3614 }

3615 }

3616 else if (!expectParam) // $key

3617 {

3618 auto &&getValue = std::get<KeywordSubstitution::GetValue>(kw.getValueVariant);

3619 substRes+=getValue().str();

3620 //printf("found '%s'->'%s'\n",kw.keyword,qPrint(getValue()));

3621 p+=keyLen;

3622 }

3623 else

3624 {

3625 //printf("%s %d Expected arguments, none specified '%s'\n",qPrint(file), line, qPrint(kw.keyword));

3626 warn(file,line,"Expected arguments for '{}' but none were specified",kw.keyword);

3627 p+=keyLen;

3628 }

3629 found = true;

3630 break;

3631 }

3632 }

3633 }

3634 if (!found) // copy

3635 {

3636 if (c=='\n') line++;

3637 substRes+=c;

3638 p++;

3639 }

3640 }

3641 }

3642 return substRes;

3643}

References QCString::data, QCString::left, QCString::length, qstrlen, qstrncmp and warn.

Referenced by substituteHtmlKeywords, substituteKeywords and substituteLatexKeywords.

substituteKeywords()

QCString substituteKeywords (const QCString & file, const QCString & s, const QCString & title, const QCString & projName, const QCString & projNum, const QCString & projBrief)

Declaration at line 252 of file util.h, definition at line 3724 of file util.cpp.

3724QCString substituteKeywords(const QCString &file,const QCString &s,const QCString &title,

3725 const QCString &projName,const QCString &projNum,const QCString &projBrief)

3726{

3727 return substituteKeywords(file,s,

3728 {

3729 // keyword value getter

3730 { "$title", [&]() { return !title.isEmpty() ? title : projName; } },

3731 { "$datetime", [&]() { return dateToString(DateTimeType::DateTime); } },

3732 { "$date", [&]() { return dateToString(DateTimeType::Date); } },

3733 { "$time", [&]() { return dateToString(DateTimeType::Time); } },

3734 { "$year", [&]() { return yearToString(); } },

3735 { "$doxygenversion", [&]() { return getDoxygenVersion(); } },

3736 { "$projectname", [&]() { return projName; } },

3737 { "$projectnumber", [&]() { return projNum; } },

3738 { "$projectbrief", [&]() { return projBrief; } },

3739 { "$projectlogo", [&]() { return stripPath(projectLogoFile()); } },

3740 { "$logosize", [&]() { return projectLogoSize(); } },

3741 { "$projecticon", [&]() { return stripPath(Config_getString(PROJECT_ICON)); } },

3742 { "$langISO", [&]() { return theTranslator->trISOLang(); } },

3743 { "$showdate", [&](const QCString &fmt) { return showDate(fmt); } }

3744 });

3745}

References Config_getString, Date, DateTime, dateToString, QCString::isEmpty, projectLogoFile, projectLogoSize, showDate, stripPath, substituteKeywords, theTranslator, Time and yearToString.

substituteTemplateArgumentsInString()

QCString substituteTemplateArgumentsInString (const QCString & nm, const ArgumentList & formalArgs, const ArgumentList * actualArgs)

Substitutes any occurrence of a formal argument from argument list formalArgs in name by the corresponding actual argument in argument list actualArgs. The result after substitution is returned as a string. The argument name is used to prevent recursive substitution.

Declaration at line 296 of file util.h, definition at line 4868 of file util.cpp.

4868QCString substituteTemplateArgumentsInString(

4869 const QCString &nm,

4870 const ArgumentList &formalArgs,

4871 const ArgumentList *actualArgs)

4872{

4873 AUTO_TRACE("name={} formalArgs={} actualArgs={}",nm,argListToString(formalArgs),actualArgs ? argListToString(*actualArgs) : QCString());

4874 if (formalArgs.empty()) return nm;

4875 QCString result;

4876

4877 static const reg::Ex re(R"(\a\w*)");

4878 std::string name = nm.str();

4879 reg::Iterator it(name,re);

4880 reg::Iterator end;

4881 size_t p=0;

4882

4883 for (; it!=end ; ++it)

4884 {

4885 const auto &match = *it;

4886 size_t i = match.position();

4887 size_t l = match.length();

4888 if (i>p) result += name.substr(p,i-p);

4889 QCString n(match.str());

4890 ArgumentList::const_iterator actIt;

4891 if (actualArgs)

4892 {

4893 actIt = actualArgs->begin();

4894 }

4895 //printf(": name=%s\n",qPrint(name));

4896

4897 // if n is a template argument, then we substitute it

4898 // for its template instance argument.

4899 bool found=FALSE;

4900 for (auto formIt = formalArgs.begin();

4901 formIt!=formalArgs.end() && !found;

4902 ++formIt

4903 )

4904 {

4905 Argument formArg = *formIt;

4906 Argument actArg;

4907 if (actualArgs && actIt!=actualArgs->end())

4908 {

4909 actArg = *actIt;

4910 }

4911 if (formArg.type.startsWith("class ") && formArg.name.isEmpty())

4912 {

4913 formArg.name = formArg.type.mid(6);

4914 formArg.type = "class";

4915 }

4916 else if (formArg.type.startsWith("typename ") && formArg.name.isEmpty())

4917 {

4918 formArg.name = formArg.type.mid(9);

4919 formArg.type = "typename";

4920 }

4921 else if (formArg.type.startsWith("class...")) // match 'class... name' to 'name...'

4922 {

4923 formArg.name += "...";

4924 formArg.type = formArg.type.left(5)+formArg.type.mid(8);

4925 }

4926 else if (formArg.type.startsWith("typename...")) // match 'typename... name' to 'name...'

4927 {

4928 formArg.name += "...";

4929 formArg.type = formArg.type.left(8)+formArg.type.mid(11);

4930 }

4931 //printf(": n=%s formArg->type='%s' formArg->name='%s' formArg->defval='%s' actArg->type='%s' actArg->name='%s' \n",

4932 // qPrint(n),qPrint(formArg.type),qPrint(formArg.name),qPrint(formArg.defval),qPrint(actArg.type),qPrint(actArg.name));

4933 if (formArg.type=="class" || formArg.type=="typename" || formArg.type.startsWith("template"))

4934 {

4935 if (formArg.name==n && actualArgs && actIt!=actualArgs->end() && !actArg.type.isEmpty()) // base class is a template argument

4936 {

4937 static constexpr auto hasRecursion = [](const QCString &prefix,const QCString &nameArg,const QCString &subst) -> bool

4938 {

4939 int ii=0;

4940 int pp=0;

4941

4942 ii = subst.find('<');

4943 //printf("prefix='%s' subst='%s'\n",qPrint(prefix.mid(prefix.length()-ii-2,ii+1)),qPrint(subst.left(ii+1)));

4944 if (ii!=-1 && static_cast<int>(prefix.length())>=ii+2 && prefix.mid(prefix.length()-ii-2,ii+1)==subst.left(ii+1))

4945 {

4946 return true; // don't replace 'A< ' with 'A< A<...', see issue #10951

4947 }

4948

4949 while ((ii=subst.find(nameArg,pp))!=-1)

4950 {

4951 bool beforeNonWord = ii==0 || !isId(subst.at(ii-1));

4952 bool afterNonWord = subst.length()==ii+nameArg.length() || !isId(subst.at(ii+nameArg.length()));

4953 if (beforeNonWord && afterNonWord)

4954 {

4955 return true; // if nameArg=='A' then subst=='A::Z' or 'S<A>' or 'Z::A' should return true, but 'AA::ZZ' or 'BAH' should not match

4956 }

4957 pp=ii+static_cast<int>(nameArg.length());

4958 }

4959 return false;

4960 };

4961 // replace formal argument with the actual argument of the instance

4962 AUTO_TRACE_ADD("result={} n={} type={} hasRecursion={}",result,n,actArg.type,hasRecursion(result,n,actArg.type));

4963 if (!hasRecursion(result,n,actArg.type))

4964 // the scope guard is to prevent recursive lockup for

4965 // template<class A> class C : public<A::T>,

4966 // where A::T would become A::T::T here,

4967 // since n==A and actArg->type==A::T

4968 // see bug595833 for an example

4969 //

4970 // Also prevent recursive substitution if n is part of actArg.type, i.e.

4971 // n='A' in argType='S< A >' would produce 'S< S< A > >'

4972 {

4973 if (actArg.name.isEmpty())

4974 {

4975 result += actArg.type;

4976 }

4977 else

4978 // for case where the actual arg is something like "unsigned int"

4979 // the "int" part is in actArg->name.

4980 {

4981 result += actArg.type+" "+actArg.name;

4982 }

4983 found=TRUE;

4984 }

4985 }

4986 else if (formArg.name==n &&

4987 (actualArgs==nullptr || actIt==actualArgs->end()) &&

4988 !formArg.defval.isEmpty() &&

4989 formArg.defval!=nm /* to prevent recursion */

4990 )

4991 {

4992 result += substituteTemplateArgumentsInString(formArg.defval,formalArgs,actualArgs);

4993 found=TRUE;

4994 }

4995 }

4996 else if (formArg.name==n &&

4997 (actualArgs==nullptr || actIt==actualArgs->end()) &&

4998 !formArg.defval.isEmpty() &&

4999 formArg.defval!=nm /* to prevent recursion */

5000 )

5001 {

5002 result += substituteTemplateArgumentsInString(formArg.defval,formalArgs,actualArgs);

5003 found=TRUE;

5004 }

5005 if (actualArgs && actIt!=actualArgs->end())

5006 {

5007 actIt++;

5008 }

5009 }

5010 if (!found)

5011 {

5012 result += n;

5013 }

5014 p=i+l;

5015 }

5016 result+=name.substr(p);

5017 result=result.simplifyWhiteSpace();

5018 AUTO_TRACE_EXIT("result={}",result);

5019 return result.stripWhiteSpace();

5020}

References argListToString, AUTO_TRACE, AUTO_TRACE_ADD, AUTO_TRACE_EXIT, ArgumentList::begin, Argument::defval, ArgumentList::empty, ArgumentList::end, end, FALSE, QCString::isEmpty, isId, QCString::left, QCString::mid, Argument::name, prefix, QCString::simplifyWhiteSpace, QCString::startsWith, QCString::str, QCString::stripWhiteSpace, substituteTemplateArgumentsInString, TRUE and Argument::type.

Referenced by computeTemplateClassRelations, MemberDefImpl::createTemplateInstanceMember, findBaseClassesForClass, findUsedClassesForClass, SymbolResolver::Private::getResolvedSymbol, SymbolResolver::Private::newResolveTypedef and substituteTemplateArgumentsInString.

tempArgListToString()

QCString tempArgListToString (const ArgumentList & al, SrcLangExt lang, bool includeDefaults=true)

Declaration at line 224 of file util.h, definition at line 1247 of file util.cpp.

1247QCString tempArgListToString(const ArgumentList &al,SrcLangExt lang,bool includeDefault)

1248{

1249 QCString result;

1250 if (al.empty()) return result;

1251 result="<";

1252 bool first=true;

1253 for (const auto &a : al)

1254 {

1255 if (a.defval.isEmpty() || includeDefault)

1256 {

1257 if (!first) result+=", ";

1258 if (!a.name.isEmpty()) // add template argument name

1259 {

1260 if (lang==SrcLangExt::Java || lang==SrcLangExt::CSharp)

1261 {

1262 result+=a.type+" ";

1263 }

1264 result+=a.name;

1265 }

1266 else // extract name from type

1267 {

1268 int i = static_cast<int>(a.type.length())-1;

1269 while (i>=0 && isId(a.type.at(i))) i--;

1270 if (i>0)

1271 {

1272 result+=a.type.right(a.type.length()-i-1);

1273 if (a.type.find("...")!=-1)

1274 {

1275 result+="...";

1276 }

1277 }

1278 else // nothing found -> take whole name

1279 {

1280 result+=a.type;

1281 }

1282 }

1283 if (!a.typeConstraint.isEmpty() && lang==SrcLangExt::Java)

1284 {

1285 result+=" extends "; // TODO: now Java specific, C# has where...

1286 result+=a.typeConstraint;

1287 }

1288 first=false;

1289 }

1290 }

1291 result+=">";

1292 return removeRedundantWhiteSpace(result);

1293}

References ArgumentList::empty, isId, removeRedundantWhiteSpace and QCString::right.

Referenced by addMemberFunction, ClassDefImpl::className, findTemplateInstanceRelation, makeQualifiedNameWithTemplateParameters, searchTemplateSpecs and writeDefArgumentList.

transcodeCharacterStringToUTF8()

bool transcodeCharacterStringToUTF8 (std::string & input, const char * inputEncoding)

Declaration at line 385 of file util.h, definition at line 1404 of file util.cpp.

1404bool transcodeCharacterStringToUTF8(std::string &input, const char *inputEncoding)

1405{

1406 const char *outputEncoding = "UTF-8";

1407 if (inputEncoding==nullptr || qstricmp(inputEncoding,outputEncoding)==0) return true;

1408 size_t inputSize=input.length();

1409 size_t outputSize=inputSize*4;

1410 QCString output(outputSize, QCString::ExplicitSize);

1411 void *cd = portable_iconv_open(outputEncoding,inputEncoding);

1412 if (cd==reinterpret_cast<void *>(-1))

1413 {

1414 return false;

1415 }

1416 bool ok=true;

1417 size_t iLeft=inputSize;

1418 size_t oLeft=outputSize;

1419 const char *inputPtr = input.data();

1420 char *outputPtr = output.rawData();

1421 if (!portable_iconv(cd, &inputPtr, &iLeft, &outputPtr, &oLeft))

1422 {

1423 outputSize-=static_cast<int>(oLeft);

1424 output.resize(outputSize);

1425 output.at(outputSize)='\0';

1426 // replace input

1427 input=output.str();

1428 //printf("iconv: input size=%d output size=%d\n[%s]\n",size,newSize,qPrint(srcBuf));

1429 }

1430 else

1431 {

1432 ok=false;

1433 }

1434 portable_iconv_close(cd);

1435 return ok;

1436}

References QCString::at, QCString::ExplicitSize, portable_iconv, portable_iconv_close, portable_iconv_open, qstricmp, QCString::rawData, QCString::resize and QCString::str.

Referenced by LayoutDocManager::parse and readCodeFragment.

unescapeCharsInString()

QCString unescapeCharsInString (const QCString & s)

Declaration at line 338 of file util.h, definition at line 3934 of file util.cpp.

3934QCString unescapeCharsInString(const QCString &s)

3935{

3936 if (s.isEmpty()) return s;

3937 bool caseSenseNames = getCaseSenseNames();

3938 QCString result;

3939 const char *p = s.data();

3940 if (p)

3941 {

3942 char c = 0;

3943 while ((c=*p++))

3944 {

3945 if (c=='_') // 2 or 3 character escape

3946 {

3947 switch (*p)

3948 {

3949 case '_': result+=c; p++; break; // __ -> '_'

3950 case '1': result+=':'; p++; break; // _1 -> ':'

3951 case '2': result+='/'; p++; break; // _2 -> '/'

3952 case '3': result+='<'; p++; break; // _3 -> '<'

3953 case '4': result+='>'; p++; break; // _4 -> '>'

3954 case '5': result+='*'; p++; break; // _5 -> '*'

3955 case '6': result+='&'; p++; break; // _6 -> '&'

3956 case '7': result+='|'; p++; break; // _7 -> '|'

3957 case '8': result+='.'; p++; break; // _8 -> '.'

3958 case '9': result+='!'; p++; break; // _9 -> '!'

3959 case '0': // 3 character escape

3960 switch (*(p+1))

3961 {

3962 case '0': result+=','; p+=2; break; // _00 -> ','

3963 case '1': result+=' '; p+=2; break; // _01 -> ' '

3964 case '2': result+='{'; p+=2; break; // _02 -> '{'

3965 case '3': result+='}'; p+=2; break; // _03 -> '}'

3966 case '4': result+='?'; p+=2; break; // _04 -> '?'

3967 case '5': result+='^'; p+=2; break; // _05 -> '^'

3968 case '6': result+='%'; p+=2; break; // _06 -> '%'

3969 case '7': result+='('; p+=2; break; // _07 -> '('

3970 case '8': result+=')'; p+=2; break; // _08 -> ')'

3971 case '9': result+='+'; p+=2; break; // _09 -> '+'

3972 case 'a': result+='='; p+=2; break; // _0a -> '='

3973 case 'b': result+='$'; p+=2; break; // _0b -> '$'

3974 case 'c': result+='\\'; p+=2; break;// _0c -> '\'

3975 case 'd': result+='@'; p+=2; break; // _0d -> '@'

3976 case 'e': result+=']'; p+=2; break; // _0e -> ']'

3977 case 'f': result+='['; p+=2; break; // _0f -> '['

3978 case 'g': result+='#'; p+=2; break; // _0g -> '#'

3979 case 'h': result+='"'; p+=2; break; // _0h -> '"'

3980 case 'i': result+='~'; p+=2; break; // _0i -> '~'

3981 case 'j': result+='\''; p+=2; break;// _0j -> '\'

3982 case 'k': result+=';'; p+=2; break; // _0k -> ';'

3983 case 'l': result+='`'; p+=2; break; // _0l -> '`'

3984 default: // unknown escape, just pass underscore character as-is

3985 result+=c;

3986 break;

3987 }

3988 break;

3989 default:

3990 if (!caseSenseNames && c>='a' && c<='z') // lower to upper case escape, _a -> 'A'

3991 {

3992 result+=static_cast<char>(toupper(*p));

3993 p++;

3994 }

3995 else // unknown escape, pass underscore character as-is

3996 {

3997 result+=c;

3998 }

3999 break;

4000 }

4001 }

4002 else // normal character; pass as is

4003 {

4004 result+=c;

4005 }

4006 }

4007 }

4008 return result;

4009}

References QCString::data, getCaseSenseNames and QCString::isEmpty.

updateColumnCount()

size_t updateColumnCount (const char * s, size_t col)

Declaration at line 481 of file util.h, definition at line 7395 of file util.cpp.

7395size_t updateColumnCount(const char *s,size_t col)

7396{

7397 if (s)

7398 {

7399 const int tabSize = Config_getInt(TAB_SIZE);

7400 char c;

7401 while ((c=*s++))

7402 {

7403 switch(c)

7404 {

7405 case '\t': col+=tabSize - (col%tabSize);

7406 break;

7407 case '\n': col=0;

7408 break;

7409 default:

7410 col++;

7411 if (c<0) // multi-byte character

7412 {

7413 int numBytes = getUTF8CharNumBytes(c);

7414 for (int i=0;i<numBytes-1 && (c=*s++);i++) {} // skip over extra chars

7415 if (c==0) return col; // end of string half way a multibyte char

7416 }

7417 break;

7418 }

7419 }

7420 }

7421 return col;

7422}

References Config_getInt and getUTF8CharNumBytes.

Referenced by HtmlCodeGenerator::codify, LatexCodeGenerator::codify, ManCodeGenerator::codify, RTFCodeGenerator::codify, writeDocbookCodeString and writeXMLCodeString.

updateLanguageMapping()

bool updateLanguageMapping (const QCString & extension, const QCString & parser)

Declaration at line 373 of file util.h, definition at line 5617 of file util.cpp.

5617bool updateLanguageMapping(const QCString &extension,const QCString &language)

5618{

5619 QCString langName = language.lower();

5620 auto it1 = std::find_if(g_lang2extMap.begin(),g_lang2extMap.end(),

5621 [&langName](const auto &info) { return info.langName==langName; });

5622 if (it1 == g_lang2extMap.end()) return false;

5623

5624 // found the language

5625 SrcLangExt parserId = it1->parserId;

5626 QCString extName = extension.lower();

5627 if (extName.isEmpty()) return FALSE;

5628 if (extName.at(0)!='.') extName.prepend(".");

5629 auto it2 = g_extLookup.find(extName.str());

5630 if (it2!=g_extLookup.end())

5631 {

5632 g_extLookup.erase(it2); // language was already register for this ext

5633 }

5634 //printf("registering extension %s\n",qPrint(extName));

5635 g_extLookup.emplace(extName.str(),parserId);

5636 if (!Doxygen::parserManager->registerExtension(extName,it1->parserName))

5637 {

5638 err("Failed to assign extension {} to parser {} for language {}\n",

5639 extName.data(),it1->parserName,language);

5640 }

5641 else

5642 {

5643 //msg("Registered extension {} to language parser {}...\n",

5644 // extName,language);

5645 }

5646 return TRUE;

5647}

References QCString::at, QCString::data, err, FALSE, g_extLookup, g_lang2extMap, QCString::isEmpty, QCString::lower, Doxygen::parserManager, QCString::prepend, QCString::str and TRUE.

Referenced by addCodeOnlyMappings, adjustConfiguration and initDefaultExtensionMapping.

writeColoredImgData()

void writeColoredImgData (const QCString & dir, ColoredImgDataItem data=[])

Writes the intensity only bitmap represented by data as an image to directory dir using the colors defined by HTML_COLORSTYLE_*.

Declaration at line 424 of file util.h, definition at line 6299 of file util.cpp.

6299void writeColoredImgData(const QCString &dir,ColoredImgDataItem data[])

6300{

6301 int hue = Config_getInt(HTML_COLORSTYLE_HUE);

6302 int sat = Config_getInt(HTML_COLORSTYLE_SAT);

6303 int gamma = Config_getInt(HTML_COLORSTYLE_GAMMA);

6304 while (data->name)

6305 {

6306 QCString fileName = dir+"/"+data->name;

6307 ColoredImage img(data->width,data->height,data->content,data->alpha,

6308 sat,hue,gamma);

6309 if (!img.save(fileName))

6310 {

6311 fprintf(stderr,"Warning: Cannot open file %s for writing\n",data->name);

6312 }

6313 Doxygen::indexList->addImageFile(data->name);

6314 data++;

6315 }

6316}

References ColoredImgDataItem::alpha, Config_getInt, ColoredImgDataItem::content, ColoredImgDataItem::height, Doxygen::indexList, ColoredImgDataItem::name, ColoredImage::save and ColoredImgDataItem::width.

writeExamples()

void writeExamples (OutputList & ol, const ExampleList & el)

Declaration at line 228 of file util.h, definition at line 1128 of file util.cpp.

1128void writeExamples(OutputList &ol,const ExampleList &list)

1129{

1130 auto replaceFunc = [&list,&ol](size_t entryIndex)

1131 {

1132 const auto &e = list[entryIndex];

1133 ol.pushGeneratorState();

1134 ol.disable(OutputType::Latex);

1135 ol.disable(OutputType::RTF);

1136 ol.disable(OutputType::Docbook);

1137 // link for Html / man

1138 //printf("writeObjectLink(file=%s)\n",qPrint(e->file));

1139 ol.writeObjectLink(QCString(),e.file,e.anchor,e.name);

1140 ol.popGeneratorState();

1141

1142 ol.pushGeneratorState();

1143 ol.disable(OutputType::Man);

1144 ol.disable(OutputType::Html);

1145 // link for Latex / pdf with anchor because the sources

1146 // are not hyperlinked (not possible with a verbatim environment).

1147 ol.writeObjectLink(QCString(),e.file,QCString(),e.name);

1148 ol.popGeneratorState();

1149 };

1150

1151 writeMarkerList(ol, theTranslator->trWriteList(static_cast<int>(list.size())).str(), list.size(), replaceFunc);

1152

1153 ol.writeString(".");

1154}

References OutputList::disable, Docbook, Html, Latex, Man, OutputList::popGeneratorState, OutputList::pushGeneratorState, RTF, theTranslator, writeMarkerList, OutputList::writeObjectLink and OutputList::writeString.

Referenced by MemberDefImpl::_writeExamples and ClassDefImpl::writeDetailedDocumentationBody.

writeMarkerList()

void writeMarkerList (OutputList & ol, const std::string & markerText, size_t numMarkers, std::function< void(size_t)> replaceFunc)

Declaration at line 411 of file util.h, definition at line 1104 of file util.cpp.

1104void writeMarkerList(OutputList &ol,const std::string &markerText,size_t numMarkers,

1105 std::function<void(size_t)> replaceFunc)

1106{

1107 static const reg::Ex marker(R"(@(\d+))");

1108 reg::Iterator it(markerText,marker);

1109 reg::Iterator end;

1110 size_t index=0;

1111 // now replace all markers in inheritLine with links to the classes

1112 for ( ; it!=end ; ++it)

1113 {

1114 const auto &match = *it;

1115 size_t newIndex = match.position();

1116 size_t matchLen = match.length();

1117 ol.parseText(markerText.substr(index,newIndex-index));

1118 unsigned long entryIndex = std::stoul(match[1].str());

1119 if (entryIndex<static_cast<unsigned long>(numMarkers))

1120 {

1121 replaceFunc(entryIndex);

1122 }

1123 index=newIndex+matchLen;

1124 }

1125 ol.parseText(markerText.substr(index));

1126}

References end and OutputList::parseText.

Referenced by MemberDefImpl::_writeReimplementedBy, DefinitionImpl::_writeSourceRefList, writeExamples and ClassDefImpl::writeInheritanceGraph.

writePageRef()

void writePageRef (OutputList & ol, const QCString & cn, const QCString & mn)

Declaration at line 161 of file util.h, definition at line 271 of file util.cpp.

271void writePageRef(OutputList &ol,const QCString &cn,const QCString &mn)

272{

273 ol.pushGeneratorState();

274

275 ol.disable(OutputType::Html);

276 ol.disable(OutputType::Man);

277 ol.disable(OutputType::Docbook);

278 if (Config_getBool(PDF_HYPERLINKS)) ol.disable(OutputType::Latex);

279 if (Config_getBool(RTF_HYPERLINKS)) ol.disable(OutputType::RTF);

280 ol.startPageRef();

281 ol.docify(theTranslator->trPageAbbreviation());

282 ol.endPageRef(cn,mn);

283

284 ol.popGeneratorState();

285}

References Config_getBool, OutputList::disable, Docbook, OutputList::docify, OutputList::endPageRef, Html, Latex, Man, OutputList::popGeneratorState, OutputList::pushGeneratorState, RTF, OutputList::startPageRef and theTranslator.

Referenced by MemberDefImpl::_writeReimplementedBy and MemberDefImpl::_writeReimplements.

writeTypeConstraints()

void writeTypeConstraints (OutputList & ol, const Definition * d, const ArgumentList & al)

Declaration at line 389 of file util.h, definition at line 5965 of file util.cpp.

5965void writeTypeConstraints(OutputList &ol,const Definition *d,const ArgumentList &al)

5966{

5967 if (al.empty()) return;

5968 ol.startConstraintList(theTranslator->trTypeConstraints());

5969 for (const Argument &a : al)

5970 {

5971 ol.startConstraintParam();

5972 ol.parseText(a.name);

5973 ol.endConstraintParam();

5974 ol.startConstraintType();

5975 linkifyText(TextGeneratorOLImpl(ol),d,nullptr,nullptr,a.type);

5976 ol.endConstraintType();

5977 ol.startConstraintDocs();

5978 ol.generateDoc(d->docFile(),d->docLine(),d,nullptr,a.docs,TRUE,FALSE,

5979 QCString(),FALSE,FALSE);

5980 ol.endConstraintDocs();

5981 }

5982 ol.endConstraintList();

5983}

References Definition::docFile, Definition::docLine, ArgumentList::empty, OutputList::endConstraintDocs, OutputList::endConstraintList, OutputList::endConstraintParam, OutputList::endConstraintType, FALSE, OutputList::generateDoc, linkifyText, OutputList::parseText, OutputList::startConstraintDocs, OutputList::startConstraintList, OutputList::startConstraintParam, OutputList::startConstraintType, theTranslator and TRUE.

Referenced by MemberDefImpl::_writeTypeConstraints and ClassDefImpl::writeDetailedDocumentationBody.

Generated via doxygen2docusaurus by Doxygen 1.14.0.

Included Headers​

Classes Index​

Typedefs Index​

Functions Index​

Description​

Typedefs​

KeywordSubstitutionList​

SelectionBlockList​

Functions​

addCodeOnlyMappings()​

addDirPrefix()​

addGroupListToTitle()​

addHtmlExtensionIfMissing()​

addMembersToMemberGroup()​

addRefItem()​

addRelatedPage()​

argListToString()​

checkBlocks()​

checkExtension()​

checkIfTypedef()​

clearSubDirs()​

computeQualifiedIndex()​

containsWord()​

convertCharEntitiesToUTF8()​

convertFileNameFortranParserCode()​

convertNameToFile()​

convertProtectionLevel()​

convertToHtml()​

convertToId()​

convertToJSString()​

convertToXML()​

copyFile()​

correctId()​

correctURL()​

createHtmlUrl()​

createSubDirs()​

demangleCSharpGenericName()​

detab()​

determineAbsoluteIncludeName()​

escapeCharsInString()​

externalLinkTarget()​

externalRef()​

extractClassNameFromType()​

extractDirection()​

extractNamespaceName()​

fileToString()​

fileVisibleInIndex()​

filterTitle()​

findAndRemoveWord()​

findFileDef()​

findFilePath()​

findIndex()​

findIndex()​

fixSpaces()​

generateAnonymousAnchor()​

generateFileRef()​

generateMarker()​

getCaseSenseNames()​

getDefs()​

getDotImageExtension()​

getEncoding()​

getFileFilter()​

getFileNameExtension()​

getLanguageFromCodeLang()​

getLanguageFromFileName()​

getLanguageSpecificSeparator()​

getOverloadDocs()​

getPrefixIndex()​

getProjectId()​

getScopeFragment()​

guessSection()​

initDefaultExtensionMapping()​

inlineArgListToDoc()​

inlineTemplateArgListToDoc()​

insertTemplateSpecifierInScope()​

integerToAlpha()​

integerToRoman()​

isId()​

isIdJS()​

isURL()​

Included Headers

Classes Index

Typedefs Index

Functions Index

Description

Typedefs

KeywordSubstitutionList

SelectionBlockList

Functions

addCodeOnlyMappings()

addDirPrefix()

addGroupListToTitle()

addHtmlExtensionIfMissing()

addMembersToMemberGroup()

addRefItem()

addRelatedPage()

argListToString()

checkBlocks()

checkExtension()

checkIfTypedef()

clearSubDirs()

computeQualifiedIndex()

containsWord()

convertCharEntitiesToUTF8()

convertFileNameFortranParserCode()

convertNameToFile()

convertProtectionLevel()

convertToHtml()

convertToId()

convertToJSString()

convertToXML()

copyFile()

correctId()

correctURL()

createHtmlUrl()

createSubDirs()

demangleCSharpGenericName()

detab()

determineAbsoluteIncludeName()

escapeCharsInString()

externalLinkTarget()

externalRef()

extractClassNameFromType()

extractDirection()

extractNamespaceName()

fileToString()

fileVisibleInIndex()

filterTitle()

findAndRemoveWord()

findFileDef()

findFilePath()

findIndex()

findIndex()

fixSpaces()

generateAnonymousAnchor()

generateFileRef()

generateMarker()

getCaseSenseNames()

getDefs()

getDotImageExtension()

getEncoding()

getFileFilter()

getFileNameExtension()

getLanguageFromCodeLang()

getLanguageFromFileName()

getLanguageSpecificSeparator()

getOverloadDocs()

getPrefixIndex()

getProjectId()

getScopeFragment()

guessSection()

initDefaultExtensionMapping()

inlineArgListToDoc()

inlineTemplateArgListToDoc()

insertTemplateSpecifierInScope()

integerToAlpha()

integerToRoman()

isId()

isIdJS()

isURL()