#include <src/pre.h>

Classes
struct	Private

Public Member Functions
	Preprocessor ()
	~Preprocessor ()
void	processFile (const QCString &fileName, const std::string &input, std::string &output)
void	addSearchDir (const QCString &dir)

Private Attributes
std::unique_ptr< Private >	p

Detailed Description

Definition at line 27 of file pre.h.

Constructor & Destructor Documentation

◆ Preprocessor()

Preprocessor::Preprocessor ( )

Definition at line 4142 of file pre.l.

                           : p(std::make_unique<Private>())
{
  preYYlex_init_extra(&p->state,&p->yyscanner);
  addSearchDir(".");
}

References addSearchDir(), and p.

◆ ~Preprocessor()

Preprocessor::~Preprocessor ( )

Definition at line 4148 of file pre.l.

{
  preYYlex_destroy(p->yyscanner);
}

References p.

Member Function Documentation

◆ addSearchDir()

void Preprocessor::addSearchDir ( const QCString & dir )

Definition at line 4135 of file pre.l.

{
  YY_EXTRA_TYPE state = preYYget_extra(p->yyscanner);
  FileInfo fi(dir.str());
  if (fi.isDir()) state->pathList.push_back(fi.absFilePath());
}

References FileInfo::absFilePath(), FileInfo::isDir(), p, and QCString::str().

Referenced by parseFile(), and Preprocessor().

◆ processFile()

void Preprocessor::processFile	(	const QCString &	fileName,
		const std::string &	input,
		std::string &	output )

Definition at line 4153 of file pre.l.

{
  AUTO_TRACE("fileName={}",fileName);
  yyscan_t yyscanner = p->yyscanner;
  YY_EXTRA_TYPE state = preYYget_extra(p->yyscanner);
  struct yyguts_t *yyg = (struct yyguts_t*)p->yyscanner;
 
#ifdef FLEX_DEBUG
  preYYset_debug(Debug::isFlagSet(Debug::Lex_pre)?1:0,yyscanner);
#endif
 
  DebugLex debugLex(Debug::Lex_pre, __FILE__, qPrint(fileName));
  //printf("##########################\n%s\n####################\n",
  //    qPrint(input));
 
  state->macroExpansion = Config_getBool(MACRO_EXPANSION);
  state->expandOnlyPredef = Config_getBool(EXPAND_ONLY_PREDEF);
  state->skip=FALSE;
  state->curlyCount=0;
  state->lexRulesPart=false;
  state->nospaces=FALSE;
  state->inputBuf=&input;
  state->inputBufPos=0;
  state->outputBuf=&output;
  state->includeStack.clear();
  state->expandedDict.clear();
  state->contextDefines.clear();
  state->pragmaSet.clear();
  while (!state->condStack.empty()) state->condStack.pop();
 
  setFileName(yyscanner,fileName);
 
  state->inputFileDef = state->yyFileDef;
  //yyextra->defineManager.startContext(state->fileName);
 
  initPredefined(yyscanner,fileName);
 
  state->yyLineNr = 1;
  state->yyColNr  = 1;
  state->ifcount  = 0;
 
  BEGIN( Start );
 
  state->expectGuard = guessSection(fileName).isHeader();
  state->guardName.clear();
  state->lastGuardName.clear();
  state->guardExpr.clear();
 
  preYYlex(yyscanner);
 
  while (!state->condStack.empty())
  {
    const std::unique_ptr<preYY_CondCtx> &ctx = state->condStack.top();
    QCString sectionInfo = " ";
    if (ctx->sectionId!=" ") sectionInfo.sprintf(" with label '%s' ",qPrint(ctx->sectionId.stripWhiteSpace()));
    warn(ctx->fileName,ctx->lineNr,"Conditional section{}does not have "
        "a corresponding \\endcond command within this file.",sectionInfo);
    state->condStack.pop();
  }
  // make sure we don't extend a \cond with missing \endcond over multiple files (see bug 624829)
  forceEndCondSection(yyscanner);
 
  if (!state->levelGuard.empty())
  {
    warn(state->fileName,state->yyLineNr,"More #if's than #endif's found (might be in an included file).");
  }
 
  if (Debug::isFlagSet(Debug::Preprocessor))
  {
    std::lock_guard<std::mutex> lock(g_debugMutex);
    Debug::print(Debug::Preprocessor,0,"Preprocessor output of {} (size: {} bytes):\n",fileName,output.size());
    std::string contents;
    if (Debug::isFlagSet(Debug::NoLineNo))
    {
      contents=output;
    }
    else // need to add line numbers
    {
      int line=1;
      bool startOfLine = true;
      size_t content_size = output.size() +
                            output.size()*6/40; // assuming 40 chars per line on average
                                                // and 6 chars extra for the line number
      contents.reserve(content_size);
      size_t pos=0;
      while (pos<output.size())
      {
        if (startOfLine)
        {
          char lineNrStr[15];
          snprintf(lineNrStr,15,"%05d ",line++);
          contents+=lineNrStr;
        }
        contents   += output[pos];
        startOfLine = output[pos]=='\n';
        pos++;
      }
    }
    char end[2]={0,0};
    if (!contents.empty() && contents[contents.length()-1]!='\n')
    {
      end[0]='\n';
    }
    Debug::print(Debug::Preprocessor,0,"---------\n{}{}---------\n",contents,end);
    if (yyextra->contextDefines.size()>0)
    {
      Debug::print(Debug::Preprocessor,0,"Macros accessible in this file ({}):\n", fileName);
      Debug::print(Debug::Preprocessor,0,"---------\n");
      for (auto &kv : yyextra->contextDefines)
      {
        Debug::print(Debug::Preprocessor,0,"{} ",kv.second.name);
      }
      for (auto &kv : yyextra->localDefines)
      {
        Debug::print(Debug::Preprocessor,0,"{} ",kv.second.name);
      }
      Debug::print(Debug::Preprocessor,0,"\n---------\n");
    }
    else
    {
      Debug::print(Debug::Preprocessor,0,"No macros accessible in this file ({}).\n", fileName);
    }
  }
 
  {
    std::lock_guard<std::mutex> lock(g_updateGlobals);
    for (const auto &inc : state->includeRelations)
    {
      auto toKind = [](bool local,bool imported) -> IncludeKind
      {
        if (local)
        {
          if (imported)
          {
            return IncludeKind::ImportLocalObjC;
          }
          return IncludeKind::IncludeLocal;
        }
        else if (imported)
        {
          return IncludeKind::ImportSystemObjC;
        }
        return IncludeKind::IncludeSystem;
      };
      if (inc->fromFileDef)
      {
        inc->fromFileDef->addIncludeDependency(inc->toFileDef,inc->includeName,toKind(inc->local,inc->imported));
      }
      if (inc->toFileDef && inc->fromFileDef)
      {
        inc->toFileDef->addIncludedByDependency(inc->fromFileDef,inc->fromFileDef->docName(),toKind(inc->local,inc->imported));
      }
    }
    // add the macro definition for this file to the global map
    Doxygen::macroDefinitions.emplace(state->fileName.str(),std::move(state->macroDefinitions));
  }
 
  //yyextra->defineManager.endContext();
}