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)
Definition *	toDefinition (DefinitionMutable *dm)
DefinitionMutable *	toDefinitionMutable (Definition *d)

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

Function Documentation

abbreviate()

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

static

Definition at line 1500 of file definition.cpp.

{
  QCString scopelessName=name;
  int i=scopelessName.findRev("::");
  if (i!=-1) scopelessName=scopelessName.mid(i+2);
  QCString result=s;
  result=result.stripWhiteSpace();
  // strip trailing .
  if (!result.isEmpty() && result.at(result.length()-1)=='.')
    result=result.left(result.length()-1);
 
  // strip any predefined prefix
  const StringVector &briefDescAbbrev = Config_getList(ABBREVIATE_BRIEF);
  for (const auto &p : briefDescAbbrev)
  {
    QCString str = substitute(p.c_str(),"$name",scopelessName); // replace $name with entity name
    str += " ";
    stripWord(result,str);
  }
 
  // capitalize first word
  if (!result.isEmpty())
  {
    char c=result[0];
    if (c>='a' && c<='z') c+='A'-'a';
    result[0]=c;
  }
  return result;
}

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()

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

static

Definition at line 214 of file definition.cpp.

{
  bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
  QCString symbolName = name;
  int index=computeQualifiedIndex(symbolName);
  if (!vhdlOpt && index!=-1) symbolName=symbolName.mid(index+2);
  if (!symbolName.isEmpty())
  {
    //printf("adding symbol %s\n",qPrint(symbolName));
    Doxygen::symbolMap->add(symbolName,d);
 
    d->_setSymbolName(symbolName);
  }
}

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()

static bool matchExcludedSymbols ( const QCString & name )

static

Definition at line 159 of file definition.cpp.

{
  const StringVector &exclSyms = Config_getList(EXCLUDE_SYMBOLS);
  if (exclSyms.empty()) return FALSE; // nothing specified
  std::string symName = name.str();
  for (const auto &pat : exclSyms)
  {
    QCString pattern = pat.c_str();
    bool forceStart=FALSE;
    bool forceEnd=FALSE;
    if (pattern.at(0)=='^')
      pattern=pattern.mid(1),forceStart=TRUE;
    if (pattern.at(pattern.length()-1)=='$')
      pattern=pattern.left(pattern.length()-1),forceEnd=TRUE;
    if (pattern.find('*')!=-1) // wildcard mode
    {
      const reg::Ex re(substitute(pattern,"*",".*").str());
      reg::Match match;
      if (reg::search(symName,match,re)) // wildcard match
      {
        size_t ui = match.position();
        size_t pl = match.length();
        size_t sl = symName.length();
        if ((ui==0     || pattern.at(0)=='*'                  || (!isId(symName.at(ui-1))  && !forceStart)) &&
            (ui+pl==sl || pattern.at(pattern.length()-1)=='*' || (!isId(symName.at(ui+pl)) && !forceEnd))
           )
        {
          //printf("--> name=%s pattern=%s match at %d\n",qPrint(symName),qPrint(pattern),i);
          return TRUE;
        }
      }
    }
    else if (!pattern.isEmpty()) // match words
    {
      size_t i = symName.find(pattern.str());
      if (i!=std::string::npos) // we have a match!
      {
        size_t ui=i;
        size_t pl=pattern.length();
        size_t sl=symName.length();
        // check if it is a whole word match
        if ((ui==0     || (!isId(symName.at(ui-1))  && !forceStart)) &&
            (ui+pl==sl || (!isId(symName.at(ui+pl)) && !forceEnd))
           )
        {
          //printf("--> name=%s pattern=%s match at %d\n",qPrint(symName),qPrint(pattern),i);
          return TRUE;
        }
      }
    }
  }
  //printf("--> name=%s: no match\n",name);
  return FALSE;
}

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 752 of file definition.cpp.

{
  bool filterSourceFiles = Config_getBool(FILTER_SOURCE_FILES);
  QCString filter = getFileFilter(fileName,TRUE);
  bool usePipe = !filter.isEmpty() && filterSourceFiles;
  int tabSize = Config_getInt(TAB_SIZE);
  SrcLangExt lang = getLanguageFromFileName(fileName);
  const int blockSize = 4096;
  std::string str;
  FilterCache::instance().getFileContents(fileName,
                                          static_cast<size_t>(std::max(1,startLine)),
                                          static_cast<size_t>(std::max({1,startLine,endLine})),str);
  //printf("readCodeFragment(%s,startLine=%d,endLine=%d)=\n[[[\n%s]]]\n",qPrint(fileName),startLine,endLine,qPrint(str));
 
  bool found = lang==SrcLangExt::VHDL   ||
               lang==SrcLangExt::Python ||
               lang==SrcLangExt::Fortran ||
               isMacro;
               // for VHDL, Python, and Fortran no bracket search is possible
  char *p=str.data();
  if (p && *p)
  {
    char c=0;
    int col=0;
    int lineNr=startLine;
    // skip until the opening bracket or lonely : is found
    char cn=0;
    while (*p && !found)
    {
      int pc=0;
      while ((c=*p++)!='{' && c!=':' && c!=0)
      {
        //printf("parsing char '%c'\n",c);
        if (c=='\n')
        {
          lineNr++,col=0;
        }
        else if (c=='\t')
        {
          col+=tabSize - (col%tabSize);
        }
        else if (pc=='/' && c=='/') // skip single line comment
        {
          while ((c=*p++)!='\n' && c!=0);
          if (c=='\n') lineNr++,col=0;
        }
        else if (pc=='/' && c=='*') // skip C style comment
        {
          while (((c=*p++)!='/' || pc!='*') && c!=0)
          {
            if (c=='\n') lineNr++,col=0;
            pc=c;
          }
        }
        else
        {
          col++;
        }
        pc = c;
      }
      if (c==':')
      {
        cn=*p++;
        if (cn!=':') found=TRUE;
      }
      else if (c=='{')
      {
        found=TRUE;
      }
      else if (c==0)
      {
        break;
      }
    }
    //printf(" -> readCodeFragment(%s,%d,%d) lineNr=%d\n",fileName,startLine,endLine,lineNr);
    if (found)
    {
      // For code with more than one line,
      // fill the line with spaces until we are at the right column
      // so that the opening brace lines up with the closing brace
      if (endLine!=startLine)
      {
        QCString spaces;
        spaces.fill(' ',col);
        result+=spaces;
      }
      // copy until end of line
      if (c) result+=c;
      startLine=lineNr;
      if (c==':')
      {
        result+=cn;
        if (cn=='\n') lineNr++;
      }
      char lineStr[blockSize];
      do
      {
        //printf("reading line %d in range %d-%d\n",lineNr,startLine,endLine);
        int size_read=0;
        do
        {
          // read up to blockSize-1 non-zero characters
          int i=0;
          while ((c=*p) && i<blockSize-1)
          {
            lineStr[i++]=c;
            p++;
            if (c=='\n') break; // stop at end of the line
          }
          lineStr[i]=0;
          size_read=i;
          result+=lineStr; // append line to the output
        } while (size_read == (blockSize-1)); // append more if line does not fit in buffer
        lineNr++;
      } while (*p);
 
      // strip stuff after closing bracket
      int newLineIndex = result.findRev('\n');
      int braceIndex   = result.findRev('}');
      if (braceIndex > newLineIndex)
      {
        result.resize(static_cast<size_t>(braceIndex+1));
      }
      endLine=lineNr-1;
    }
    if (usePipe)
    {
      Debug::print(Debug::FilterOutput, 0, "Filter output\n");
      Debug::print(Debug::FilterOutput,0,"-------------\n{}\n-------------\n",result);
    }
  }
  QCString encoding = getEncoding(FileInfo(fileName.str()));
  if (encoding!="UTF-8")
  {
    std::string encBuf = result.str();
    bool ok = transcodeCharacterStringToUTF8(encBuf,encoding.data());
    if (ok)
    {
      result = QCString(encBuf);
    }
    else
    {
      err("failed to transcode characters in code fragment in file {} lines {} to {}, from input encoding {} to UTF-8\n",
          fileName,startLine,endLine,encoding);
 
    }
  }
  if (!result.isEmpty() && result.at(result.length()-1)!='\n') result += "\n";
  //printf("readCodeFragment(%d-%d)=%s\n",startLine,endLine,qPrint(result));
  return found;
}

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

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

refMapToVector()

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

inlinestatic

Definition at line 1064 of file definition.cpp.

{
  // convert map to a vector of values
  MemberVector result;
  std::transform(map.begin(),map.end(),      // iterate over map
                 std::back_inserter(result), // add results to vector
                 [](const auto &item)
                 { return item.second; }     // extract value to add from map Key,Value pair
                );
  // and sort it
  std::stable_sort(result.begin(),result.end(),
              [](const auto &m1,const auto &m2) { return genericCompareMembers(m1,m2)<0; });
  return result;
}

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

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

removeFromMap()

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

static

Definition at line 229 of file definition.cpp.

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

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

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

stripWord()

static bool stripWord ( QCString & s, QCString w )

static

Definition at line 1487 of file definition.cpp.

{
  bool success=FALSE;
  if (s.left(w.length())==w)
  {
    success=TRUE;
    s=s.right(s.length()-w.length());
  }
  return success;
}

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

Referenced by abbreviate().

toDefinition()

Definition * toDefinition

(

DefinitionMutable *

dm

)

Definition at line 1872 of file definition.cpp.

{
  if (dm==nullptr) return nullptr;
  return dm->toDefinition_();
}

References DefinitionImpl::_docsAlreadyAdded(), DefinitionImpl::docFile(), DefinitionImpl::docLine(), QCString::isEmpty(), DefinitionImpl::p, stripLeadingAndTrailingEmptyLines(), and stripWhiteSpace().

Referenced by buildScopeFromQualifiedName(), findScopeFromQualifiedName(), toClassDef(), toConceptDef(), toMemberDef(), toNamespaceDef(), and MemberList::writeDocumentationPage().

toDefinitionMutable()

DefinitionMutable * toDefinitionMutable

(

Definition *

d

)

Definition at line 1878 of file definition.cpp.

{
  if (d==nullptr) return nullptr;
  return d->toDefinitionMutable_();
}

Referenced by addConceptToContext(), buildNamespaceList(), buildScopeFromQualifiedName(), computeTooltipTexts(), createTagLessInstance(), resolveClassNestingRelations(), and DefinitionMutable::toDefinition_().

Variable Documentation

g_memberReferenceMutex

std::mutex g_memberReferenceMutex

static

Definition at line 1671 of file definition.cpp.

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

g_qualifiedNameMutex

std::recursive_mutex g_qualifiedNameMutex

static

Definition at line 1220 of file definition.cpp.

Referenced by DefinitionImpl::qualifiedName(), and DefinitionImpl::setOuterScope().