Doxygen
Loading...
Searching...
No Matches
definition.cpp File Reference
#include <algorithm>
#include <iterator>
#include <unordered_map>
#include <string>
#include <optional>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include "anchor.h"
#include "md5.h"
#include "regex.h"
#include "config.h"
#include "definitionimpl.h"
#include "doxygen.h"
#include "language.h"
#include "message.h"
#include "portable.h"
#include "outputlist.h"
#include "code.h"
#include "util.h"
#include "groupdef.h"
#include "pagedef.h"
#include "section.h"
#include "htags.h"
#include "parserintf.h"
#include "debug.h"
#include "vhdldocgen.h"
#include "memberlist.h"
#include "namespacedef.h"
#include "filedef.h"
#include "dirdef.h"
#include "reflist.h"
#include "utf8.h"
#include "indexlist.h"
#include "fileinfo.h"
Include dependency graph for definition.cpp:

Go to the source code of this file.

Classes

class  DefinitionImpl::Private
 Private data associated with a Symbol DefinitionImpl object. More...
class  FilterCache
struct  FilterCache::FilterCacheItem

Functions

static bool matchExcludedSymbols (const QCString &name)
static void addToMap (const QCString &name, Definition *d)
static void removeFromMap (const QCString &name, Definition *d)
bool readCodeFragment (const QCString &fileName, bool isMacro, int &startLine, int &endLine, QCString &result)
 Reads a fragment from file fileName starting with line startLine and ending with line endLine.
static MemberVector refMapToVector (const std::unordered_map< std::string, MemberDef * > &map)
static bool stripWord (QCString &s, QCString w)
static QCString abbreviate (const QCString &s, const QCString &name)
DefinitiontoDefinition (DefinitionMutable *dm)
DefinitionMutabletoDefinitionMutable (Definition *d)

Variables

static std::recursive_mutex g_qualifiedNameMutex
static std::mutex g_memberReferenceMutex

Function Documentation

◆ abbreviate()

QCString abbreviate ( const QCString & s,
const QCString & name )
static

Definition at line 1555 of file definition.cpp.

1556{
1557 QCString scopelessName=name;
1558 int i=scopelessName.findRev("::");
1559 if (i!=-1) scopelessName=scopelessName.mid(i+2);
1560 QCString result=s;
1561 result=result.stripWhiteSpace();
1562 // strip trailing .
1563 if (!result.isEmpty() && result.at(result.length()-1)=='.')
1564 result=result.left(result.length()-1);
1565
1566 // strip any predefined prefix
1567 const StringVector &briefDescAbbrev = Config_getList(ABBREVIATE_BRIEF);
1568 for (const auto &p : briefDescAbbrev)
1569 {
1570 QCString str = substitute(p,"$name",scopelessName); // replace $name with entity name
1571 str += " ";
1572 stripWord(result,str);
1573 }
1574
1575 // capitalize first character
1576 if (!result.isEmpty())
1577 {
1578 char c = result[0];
1579 if (c >= 'a' && c <= 'z') result[0] += 'A' - 'a';
1580 }
1581
1582 return result;
1583}
This is an alternative implementation of QCString.
Definition qcstring.h:101
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:166
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition qcstring.h:241
char & at(size_t i)
Returns a reference to the character at index i.
Definition qcstring.h:593
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:163
QCString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition qcstring.h:260
int findRev(char c, int index=-1, bool cs=TRUE) const
Definition qcstring.cpp:96
QCString left(size_t len) const
Definition qcstring.h:229
#define Config_getList(name)
Definition config.h:38
std::vector< std::string > StringVector
Definition containers.h:33
static bool stripWord(QCString &s, QCString w)
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:482

References QCString::at(), Config_getList, QCString::findRev(), QCString::isEmpty(), QCString::left(), QCString::length(), QCString::mid(), QCString::stripWhiteSpace(), stripWord(), and substitute().

Referenced by Definition::briefDescription(), DefinitionAliasMixin< Base >::briefDescription(), DefinitionImpl::briefDescription(), DefinitionMixin< Base >::briefDescription(), and DefinitionImpl::operator=().

◆ addToMap()

void addToMap ( const QCString & name,
Definition * d )
static

Definition at line 211 of file definition.cpp.

212{
213 bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
214 QCString symbolName = name;
215 int index=computeQualifiedIndex(symbolName);
216 if (!vhdlOpt && index!=-1) symbolName=symbolName.mid(index+2);
217 if (!symbolName.isEmpty())
218 {
219 //printf("adding symbol %s\n",qPrint(symbolName));
220 Doxygen::symbolMap->add(symbolName,d);
221
222 d->_setSymbolName(symbolName);
223 }
224}
virtual void _setSymbolName(const QCString &name)=0
static SymbolMap< Definition > * symbolMap
Definition doxygen.h:125
#define Config_getBool(name)
Definition config.h:33
int computeQualifiedIndex(const QCString &name)
Return the index of the last :: in the string name that is still before the first <.
Definition util.cpp:6761

References Definition::_setSymbolName(), computeQualifiedIndex(), Config_getBool, QCString::isEmpty(), QCString::mid(), DefinitionImpl::name(), Doxygen::symbolMap, and DefinitionImpl::symbolName().

Referenced by DefinitionImpl::DefinitionImpl(), DefinitionImpl::DefinitionImpl(), and DefinitionAliasImpl::init().

◆ matchExcludedSymbols()

bool matchExcludedSymbols ( const QCString & name)
static

Definition at line 156 of file definition.cpp.

157{
158 const StringVector &exclSyms = Config_getList(EXCLUDE_SYMBOLS);
159 if (exclSyms.empty()) return FALSE; // nothing specified
160 const std::string &symName = name.str();
161 for (const auto &pat : exclSyms)
162 {
163 QCString pattern = pat;
164 bool forceStart=FALSE;
165 bool forceEnd=FALSE;
166 if (pattern.at(0)=='^')
167 pattern=pattern.mid(1),forceStart=TRUE;
168 if (pattern.at(pattern.length()-1)=='$')
169 pattern=pattern.left(pattern.length()-1),forceEnd=TRUE;
170 if (pattern.find('*')!=-1) // wildcard mode
171 {
172 const reg::Ex re(substitute(pattern,"*",".*").str());
174 if (reg::search(symName,match,re)) // wildcard match
175 {
176 size_t ui = match.position();
177 size_t pl = match.length();
178 size_t sl = symName.length();
179 if ((ui==0 || pattern.at(0)=='*' || (!isId(symName.at(ui-1)) && !forceStart)) &&
180 (ui+pl==sl || pattern.at(pattern.length()-1)=='*' || (!isId(symName.at(ui+pl)) && !forceEnd))
181 )
182 {
183 //printf("--> name=%s pattern=%s match at %d\n",qPrint(symName),qPrint(pattern),i);
184 return TRUE;
185 }
186 }
187 }
188 else if (!pattern.isEmpty()) // match words
189 {
190 size_t i = symName.find(pattern.str());
191 if (i!=std::string::npos) // we have a match!
192 {
193 size_t ui=i;
194 size_t pl=pattern.length();
195 size_t sl=symName.length();
196 // check if it is a whole word match
197 if ((ui==0 || (!isId(symName.at(ui-1)) && !forceStart)) &&
198 (ui+pl==sl || (!isId(symName.at(ui+pl)) && !forceEnd))
199 )
200 {
201 //printf("--> name=%s pattern=%s match at %d\n",qPrint(symName),qPrint(pattern),i);
202 return TRUE;
203 }
204 }
205 }
206 }
207 //printf("--> name=%s: no match\n",name);
208 return FALSE;
209}
int find(char c, int index=0, bool cs=TRUE) const
Definition qcstring.cpp:43
const std::string & str() const
Definition qcstring.h:552
Class representing a regular expression.
Definition regex.h:39
Object representing the matching results.
Definition regex.h:151
bool search(std::string_view str, Match &match, const Ex &re, size_t pos)
Search in a given string str starting at position pos for a match against regular expression re.
Definition regex.cpp:842
bool match(std::string_view str, Match &match, const Ex &re)
Matches a given string str for a match against regular expression re.
Definition regex.cpp:853
#define TRUE
Definition qcstring.h:37
#define FALSE
Definition qcstring.h:34
bool isId(int c)
Definition util.h:208

References QCString::at(), Config_getList, FALSE, QCString::find(), QCString::isEmpty(), isId(), QCString::left(), QCString::length(), QCString::mid(), DefinitionImpl::name(), reg::search(), QCString::str(), substitute(), and TRUE.

Referenced by DefinitionImpl::DefinitionImpl().

◆ readCodeFragment()

bool readCodeFragment ( const QCString & fileName,
bool isMacro,
int & startLine,
int & endLine,
QCString & result )

Reads a fragment from file fileName starting with line startLine and ending with line endLine.

Reads a fragment of code from file fileName starting at line startLine and ending at line endLine (inclusive). The fragment is stored in result. If FALSE is returned the code fragment could not be found.

The file is scanned for a opening bracket ('{') from startLine onward The line actually containing the bracket is returned via startLine. The file is scanned for a closing bracket ('}') from endLine backward. The line actually containing the bracket is returned via endLine. Note that for VHDL code the bracket search is not done.

Definition at line 748 of file definition.cpp.

750{
751 bool filterSourceFiles = Config_getBool(FILTER_SOURCE_FILES);
752 QCString filter = getFileFilter(fileName,TRUE);
753 bool usePipe = !filter.isEmpty() && filterSourceFiles;
754 int tabSize = Config_getInt(TAB_SIZE);
755 SrcLangExt lang = getLanguageFromFileName(fileName);
756 const int blockSize = 4096;
757 std::string str;
759 static_cast<size_t>(std::max(1,startLine)),
760 static_cast<size_t>(std::max({1,startLine,endLine})),str);
761 //printf("readCodeFragment(%s,startLine=%d,endLine=%d)=\n[[[\n%s]]]\n",qPrint(fileName),startLine,endLine,qPrint(str));
762
763 bool found = lang==SrcLangExt::VHDL ||
764 lang==SrcLangExt::Python ||
765 lang==SrcLangExt::Fortran ||
766 isMacro;
767 // for VHDL, Python, and Fortran no bracket search is possible
768 char *p=str.data();
769 if (p && *p)
770 {
771 char c=0;
772 int col=0;
773 int lineNr=startLine;
774 // skip until the opening bracket or lonely : is found
775 char cn=0;
776 while (*p && !found)
777 {
778 int pc=0;
779 while ((c=*p++)!='{' && c!=':' && c!=0)
780 {
781 //printf("parsing char '%c'\n",c);
782 if (c=='\n')
783 {
784 lineNr++,col=0;
785 }
786 else if (c=='\t')
787 {
788 col+=tabSize - (col%tabSize);
789 }
790 else if (pc=='/' && c=='/') // skip single line comment
791 {
792 while ((c=*p++)!='\n' && c!=0);
793 if (c=='\n') lineNr++,col=0;
794 }
795 else if (pc=='/' && c=='*') // skip C style comment
796 {
797 while (((c=*p++)!='/' || pc!='*') && c!=0)
798 {
799 if (c=='\n') lineNr++,col=0;
800 pc=c;
801 }
802 }
803 else
804 {
805 col++;
806 }
807 pc = c;
808 }
809 if (c==':')
810 {
811 cn=*p++;
812 if (cn!=':') found=TRUE;
813 }
814 else if (c=='{')
815 {
816 found=TRUE;
817 }
818 else if (c==0)
819 {
820 break;
821 }
822 }
823 //printf(" -> readCodeFragment(%s,%d,%d) lineNr=%d\n",fileName,startLine,endLine,lineNr);
824 if (found)
825 {
826 // For code with more than one line,
827 // fill the line with spaces until we are at the right column
828 // so that the opening brace lines up with the closing brace
829 if (endLine!=startLine)
830 {
831 QCString spaces;
832 spaces.fill(' ',col);
833 result+=spaces;
834 }
835 // copy until end of line
836 if (c) result+=c;
837 startLine=lineNr;
838 if (c==':')
839 {
840 result+=cn;
841 if (cn=='\n') lineNr++;
842 }
843 char lineStr[blockSize];
844 do
845 {
846 //printf("reading line %d in range %d-%d\n",lineNr,startLine,endLine);
847 int size_read=0;
848 do
849 {
850 // read up to blockSize-1 non-zero characters
851 int i=0;
852 while ((c=*p) && i<blockSize-1)
853 {
854 lineStr[i++]=c;
855 p++;
856 if (c=='\n') break; // stop at end of the line
857 }
858 lineStr[i]=0;
859 size_read=i;
860 result+=lineStr; // append line to the output
861 } while (size_read == (blockSize-1)); // append more if line does not fit in buffer
862 lineNr++;
863 } while (*p);
864
865 // strip stuff after closing bracket
866 int newLineIndex = result.findRev('\n');
867 int braceIndex = result.findRev('}');
868 if (braceIndex > newLineIndex)
869 {
870 result.resize(static_cast<size_t>(braceIndex+1));
871 }
872 endLine=lineNr-1;
873 }
874 if (usePipe)
875 {
876 Debug::print(Debug::FilterOutput, 0, "Filter output\n");
877 Debug::print(Debug::FilterOutput,0,"-------------\n{}\n-------------\n",result);
878 }
879 }
880 QCString encoding = getEncoding(FileInfo(fileName.str()));
881 if (encoding!="UTF-8")
882 {
883 std::string encBuf = result.str();
884 bool ok = transcodeCharacterStringToUTF8(encBuf,encoding.data());
885 if (ok)
886 {
887 result = encBuf;
888 }
889 else
890 {
891 err("failed to transcode characters in code fragment in file {} lines {} to {}, from input encoding {} to UTF-8\n",
892 fileName,startLine,endLine,encoding);
893
894 }
895 }
896 if (!result.isEmpty() && result.at(result.length()-1)!='\n') result += "\n";
897 //printf("readCodeFragment(%d-%d)=%s\n",startLine,endLine,qPrint(result));
898 return found;
899}
@ FilterOutput
Definition debug.h:38
static void print(DebugMask mask, int prio, fmt::format_string< Args... > fmt, Args &&... args)
Definition debug.h:76
Minimal replacement for QFileInfo.
Definition fileinfo.h:23
static FilterCache & instance()
bool getFileContents(const QCString &fileName, size_t startLine, size_t endLine, std::string &str)
void resize(size_t newlen)
Definition qcstring.h:180
QCString fill(char c, int len=-1)
Fills a string with a predefined character.
Definition qcstring.h:193
const char * data() const
Returns a pointer to the contents of the string in the form of a 0-terminated C string.
Definition qcstring.h:172
#define Config_getInt(name)
Definition config.h:34
#define err(fmt,...)
Definition message.h:127
SrcLangExt
Definition types.h:207
SrcLangExt getLanguageFromFileName(const QCString &fileName, SrcLangExt defLang)
Definition util.cpp:5134
bool transcodeCharacterStringToUTF8(std::string &input, const char *inputEncoding)
Definition util.cpp:1401
QCString getEncoding(const FileInfo &fi)
Definition util.cpp:5634
QCString getFileFilter(const QCString &name, bool isSourceCode)
Definition util.cpp:1367

References QCString::at(), Config_getBool, Config_getInt, QCString::data(), err, QCString::fill(), Debug::FilterOutput, QCString::findRev(), getEncoding(), FilterCache::getFileContents(), getFileFilter(), getLanguageFromFileName(), FilterCache::instance(), QCString::isEmpty(), QCString::length(), Debug::print(), QCString::resize(), QCString::str(), transcodeCharacterStringToUTF8(), and TRUE.

Referenced by VhdlDocGen::createFlowChart(), DefinitionMutable::toDefinition_(), and DefinitionImpl::writeInlineCode().

◆ refMapToVector()

MemberVector refMapToVector ( const std::unordered_map< std::string, MemberDef * > & map)
inlinestatic

Definition at line 1061 of file definition.cpp.

1062{
1063 // convert map to a vector of values
1064 MemberVector result;
1065 std::transform(map.begin(),map.end(), // iterate over map
1066 std::back_inserter(result), // add results to vector
1067 [](const auto &item)
1068 { return item.second; } // extract value to add from map Key,Value pair
1069 );
1070 // and sort it
1071 std::stable_sort(result.begin(),result.end(),
1072 [](const auto &m1,const auto &m2) { return genericCompareMembers(m1,m2)<0; });
1073 return result;
1074}
A vector of MemberDef object.
Definition memberlist.h:35
iterator end() noexcept
Definition memberlist.h:56
iterator begin() noexcept
Definition memberlist.h:54

References MemberVector::begin(), and MemberVector::end().

Referenced by DefinitionImpl::_writeSourceRefList(), DefinitionImpl::getReferencedByMembers(), and DefinitionImpl::getReferencesMembers().

◆ removeFromMap()

void removeFromMap ( const QCString & name,
Definition * d )
static

Definition at line 226 of file definition.cpp.

227{
228 Doxygen::symbolMap->remove(name,d);
229}

References DefinitionImpl::name(), and Doxygen::symbolMap.

Referenced by DefinitionAliasImpl::deinit(), and DefinitionImpl::~DefinitionImpl().

◆ stripWord()

bool stripWord ( QCString & s,
QCString w )
static

Definition at line 1542 of file definition.cpp.

1543{
1544 bool success=FALSE;
1545 if (s.left(w.length())==w)
1546 {
1547 success=TRUE;
1548 s=s.right(s.length()-w.length());
1549 }
1550 return success;
1551}
QCString right(size_t len) const
Definition qcstring.h:234

References FALSE, QCString::left(), QCString::length(), QCString::right(), and TRUE.

Referenced by abbreviate().

◆ toDefinition()

◆ toDefinitionMutable()

DefinitionMutable * toDefinitionMutable ( Definition * d)

Variable Documentation

◆ g_memberReferenceMutex

std::mutex g_memberReferenceMutex
static

◆ g_qualifiedNameMutex

std::recursive_mutex g_qualifiedNameMutex
static