#include "clangparser.h"

#include "settings.h"

#include <stdio.h>

#if USE_LIBCLANG

#include <clang-c/Index.h>

#include "clang/Tooling/Tooling.h"

#include <qfileinfo.h>

#include <stdlib.h>

#include "message.h"

#include "sortdict.h"

#include "outputgen.h"

#include "filedef.h"

#include "memberdef.h"

#include "doxygen.h"

#include "util.h"

#include "config.h"

#include "growbuf.h"

#include "membername.h"

#include "filename.h"

#include "tooltip.h"

static Definition *g_currentDefinition=0;

static MemberDef  *g_currentMemberDef=0;

static uint        g_currentLine=0;

static bool        g_searchForBody=FALSE;

static bool        g_insideBody=FALSE;

static uint        g_bracketCount=0;

#endif

ClangParser *ClangParser::instance()

{

  if (!s_instance) s_instance = new ClangParser;

  return s_instance;

}

ClangParser *ClangParser::s_instance = 0;

//--------------------------------------------------------------------------

#if USE_LIBCLANG

class ClangParser::Private

{

  public:

    enum DetectedLang { Detected_Cpp, Detected_ObjC, Detected_ObjCpp };

    Private() : tu(0), tokens(0), numTokens(0), cursors(0), 

                ufs(0), sources(0), numFiles(0), fileMapping(257),

                detectedLang(Detected_Cpp)

    { fileMapping.setAutoDelete(TRUE); }

    int getCurrentTokenLine();

    CXIndex index;

    CXTranslationUnit tu;

    QCString fileName;

    CXToken *tokens;

    uint numTokens;

    CXCursor *cursors;

    uint curLine;

    uint curToken;

    CXUnsavedFile *ufs;

    QCString *sources;

    uint numFiles;

    QDict<uint> fileMapping;

    DetectedLang detectedLang;

};

static QCString detab(const QCString &s)

{

  static int tabSize = Config_getInt(TAB_SIZE);

  GrowBuf out;

  int size = s.length();

  const char *data = s.data();

  int i=0;

  int col=0;

  const int maxIndent=1000000; // value representing infinity

  int minIndent=maxIndent;

  while (i

  {

    char c = data[i++];

    switch(c)

    {

      case '\t': // expand tab

        {

          int stop = tabSize - (col%tabSize);

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

          col+=stop;

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

        }

        break;

      case '\n': // reset colomn counter

        out.addChar(c);

        col=0;

        break;

      case ' ': // increment column counter

        out.addChar(c);

        col++;

        break;

      default: // non-whitespace => update minIndent

        out.addChar(c);

        if (c<0 && i

        {

          out.addChar(data[i++]); // >= 2 bytes

          if (((uchar)c&0xE0)==0xE0 && i

          {

            out.addChar(data[i++]); // 3 bytes

          }

          if (((uchar)c&0xF0)==0xF0 && i

          {

            out.addChar(data[i++]); // 4 byres

          }

        }

        if (col

        col++;

    }

  }

  out.addChar(0);

  //printf("detab refIndent=%d\n",refIndent);

  return out.get();

}

/** Callback function called for each include in a translation unit */

static void inclusionVisitor(CXFile includedFile,

                             CXSourceLocation* /*inclusionStack*/,

                             unsigned /*includeLen*/,

                             CXClientData clientData)

{

  QDict<void> *fileDict = (QDict<void> *)clientData;

  CXString incFileName = clang_getFileName(includedFile);

  //printf("--- file %s includes %s\n",fileName,clang_getCString(incFileName));

  fileDict->insert(clang_getCString(incFileName),(void*)0x8);

  clang_disposeString(incFileName);

}

/** filter the \a files and only keep those that are found as include files

 *  within the current translation unit.

 *  @param[in,out] files The list of files to filter.

 */ 

void ClangParser::determineInputFilesInSameTu(QStrList &files)

{

  // put the files in this translation unit in a dictionary

  QDict<void> incFound(257);

  clang_getInclusions(p->tu,

      inclusionVisitor,

      (CXClientData)&incFound

      );

  // create a new filtered file list

  QStrList resultIncludes;

  QStrListIterator it2(files);

  for (it2.toFirst();it2.current();++it2)

  {

    if (incFound.find(it2.current()))

    {

      resultIncludes.append(it2.current());

    }

  }

  // replace the original list

  files=resultIncludes;

}

void ClangParser::start(const char *fileName,QStrList &filesInTranslationUnit)

{

  static bool clangAssistedParsing = Config_getBool(CLANG_ASSISTED_PARSING);

  static QStrList &includePath = Config_getList(INCLUDE_PATH);

  static QStrList clangOptions = Config_getList(CLANG_OPTIONS);

  static QCString clangCompileDatabase = Config_getList(CLANG_COMPILATION_DATABASE_PATH);

  if (!clangAssistedParsing) return;

  //printf("ClangParser::start(%s)\n",fileName);

  p->fileName = fileName;

  p->index    = clang_createIndex(0, 0);

  p->curLine  = 1;

  p->curToken = 0;

  QDictIterator<void> di(Doxygen::inputPaths);

  int argc=0;

  std::string error;

  // load a clang compilation database (https://clang.llvm.org/docs/JSONCompilationDatabase.html)

  // this only needs to be loaded once, and could be refactored to a higher level function

  static std::unique_ptr<clang::tooling::CompilationDatabase> db =

      clang::tooling::CompilationDatabase::loadFromDirectory(clangCompileDatabase.data(), error);

  int clang_option_len = 0;

  std::vector<clang::tooling::CompileCommand> command;

  if (strcmp(clangCompileDatabase, "0") != 0) {

      if (db == nullptr) {

          // user specified a path, but DB file was not found

          err("%s using clang compilation database path of: \"%s\"\n", error.c_str(),

              clangCompileDatabase.data());

      } else {

          // check if the file we are parsing is in the DB

          command = db->getCompileCommands(fileName);

          if (!command.empty() ) {

              // it's possible to have multiple entries for the same file, so use the last entry

              clang_option_len = command[command.size()-1].CommandLine.size();

          }

      }

  }

  char **argv = (char**)malloc(sizeof(char*)*(4+Doxygen::inputPaths.count()+includePath.count()+clangOptions.count()+clang_option_len));

  if (!command.empty() ) {

      std::vector<std::string> options = command[command.size()-1].CommandLine;

      // copy each compiler option used from the database. Skip the first which is compiler exe.

      for (auto option = options.begin()+1; option != options.end(); option++) {

          argv[argc++] = strdup(option->c_str());

      }

      // this extra addition to argv is accounted for as we are skipping the first entry in

      argv[argc++]=strdup("-w"); // finally, turn off warnings.

  } else {

  // add include paths for input files

  for (di.toFirst();di.current();++di,++argc)

  {

    QCString inc = QCString("-I")+di.currentKey();

    argv[argc]=strdup(inc.data());

    //printf("argv[%d]=%s\n",argc,argv[argc]);

  }

  // add external include paths

  for (uint i=0;i

  {

    QCString inc = QCString("-I")+includePath.at(i);

    argv[argc++]=strdup(inc.data());

  }

  // user specified options

  for (uint i=0;i

  {

    argv[argc++]=strdup(clangOptions.at(i));

  }

  // extra options

  argv[argc++]=strdup("-ferror-limit=0");

  argv[argc++]=strdup("-x");

  // Since we can be presented with a .h file that can contain C/C++ or

  // Objective C code and we need to configure the parser before knowing this,

  // we use the source file to detected the language. Detection will fail if you

  // pass a bunch of .h files containing ObjC code, and no sources :-(

  SrcLangExt lang = getLanguageFromFileName(fileName);

  if (lang==SrcLangExt_ObjC || p->detectedLang!=ClangParser::Private::Detected_Cpp)

  {

    QCString fn = fileName;

    if (p->detectedLang==ClangParser::Private::Detected_Cpp && 

        (fn.right(4).lower()==".cpp" || fn.right(4).lower()==".cxx" ||

         fn.right(3).lower()==".cc" || fn.right(2).lower()==".c"))

    { // fall back to C/C++ once we see an extension that indicates this

      p->detectedLang = ClangParser::Private::Detected_Cpp;

    }

    else if (fn.right(3).lower()==".mm") // switch to Objective C++

    {

      p->detectedLang = ClangParser::Private::Detected_ObjCpp;

    }

    else if (fn.right(2).lower()==".m") // switch to Objective C

    {

      p->detectedLang = ClangParser::Private::Detected_ObjC;

    }

  }

  switch(p->detectedLang)

  {

    case ClangParser::Private::Detected_Cpp: 

      argv[argc++]=strdup("c++"); 

      break;

    case ClangParser::Private::Detected_ObjC: 

      argv[argc++]=strdup("objective-c"); 

      break;

    case ClangParser::Private::Detected_ObjCpp: 

      argv[argc++]=strdup("objective-c++"); 

      break;

  }

  // provide the input and and its dependencies as unsaved files so we can

  // pass the filtered versions

  argv[argc++]=strdup(fileName);

  }

  static bool filterSourceFiles = Config_getBool(FILTER_SOURCE_FILES);

  //printf("source %s ----------\n%s\n-------------\n\n",

  //    fileName,p->source.data());

  uint numUnsavedFiles = filesInTranslationUnit.count()+1;

  p->numFiles = numUnsavedFiles;

  p->sources = new QCString[numUnsavedFiles];

  p->ufs     = new CXUnsavedFile[numUnsavedFiles];

  p->sources[0]      = detab(fileToString(fileName,filterSourceFiles,TRUE));

  p->ufs[0].Filename = strdup(fileName);

  p->ufs[0].Contents = p->sources[0].data();

  p->ufs[0].Length   = p->sources[0].length();

  QStrListIterator it(filesInTranslationUnit);

  uint i=1;

  for (it.toFirst();it.current() && i

  {

    p->fileMapping.insert(it.current(),new uint(i));

    p->sources[i]      = detab(fileToString(it.current(),filterSourceFiles,TRUE));

    p->ufs[i].Filename = strdup(it.current());

    p->ufs[i].Contents = p->sources[i].data();

    p->ufs[i].Length   = p->sources[i].length();

  }

  // let libclang do the actual parsing

  p->tu = clang_parseTranslationUnit(p->index, 0,

                                     argv, argc, p->ufs, numUnsavedFiles, 

                                     CXTranslationUnit_DetailedPreprocessingRecord);

  // free arguments

  for (int i=0;i

  {

    free(argv[i]);

  }

  free(argv);

  if (p->tu)

  {

    // filter out any includes not found by the clang parser

    determineInputFilesInSameTu(filesInTranslationUnit);

    // show any warnings that the compiler produced

    for (uint i=0, n=clang_getNumDiagnostics(p->tu); i!=n; ++i) 

    {

      CXDiagnostic diag = clang_getDiagnostic(p->tu, i); 

      CXString string = clang_formatDiagnostic(diag,

          clang_defaultDiagnosticDisplayOptions()); 

      err("%s [clang]\n",clang_getCString(string));

      clang_disposeString(string);

      clang_disposeDiagnostic(diag);

    }

    // create a source range for the given file

    QFileInfo fi(fileName);

    CXFile f = clang_getFile(p->tu, fileName);

    CXSourceLocation fileBegin = clang_getLocationForOffset(p->tu, f, 0);

    CXSourceLocation fileEnd   = clang_getLocationForOffset(p->tu, f, p->ufs[0].Length);

    CXSourceRange    fileRange = clang_getRange(fileBegin, fileEnd);

    // produce a token stream for the file

    clang_tokenize(p->tu,fileRange,&p->tokens,&p->numTokens);

    // produce cursors for each token in the stream

    p->cursors=new CXCursor[p->numTokens];

    clang_annotateTokens(p->tu,p->tokens,p->numTokens,p->cursors);

  }

  else

  {

    p->tokens    = 0;

    p->numTokens = 0;

    p->cursors   = 0;

    err("clang: Failed to parse translation unit %s\n",fileName);

  }

}

void ClangParser::switchToFile(const char *fileName)

{

  if (p->tu)

  {

    delete[] p->cursors;

    clang_disposeTokens(p->tu,p->tokens,p->numTokens);

    p->tokens    = 0;

    p->numTokens = 0;

    p->cursors   = 0;

    QFileInfo fi(fileName);

    CXFile f = clang_getFile(p->tu, fileName);

    uint *pIndex=p->fileMapping.find(fileName);

    if (pIndex && *pIndex<p->numFiles)

    {

      uint i=*pIndex;

      //printf("switchToFile %s: len=%ld\n",fileName,p->ufs[i].Length);

      CXSourceLocation fileBegin = clang_getLocationForOffset(p->tu, f, 0);

      CXSourceLocation fileEnd   = clang_getLocationForOffset(p->tu, f, p->ufs[i].Length);

      CXSourceRange    fileRange = clang_getRange(fileBegin, fileEnd);

      clang_tokenize(p->tu,fileRange,&p->tokens,&p->numTokens);

      p->cursors=new CXCursor[p->numTokens];

      clang_annotateTokens(p->tu,p->tokens,p->numTokens,p->cursors);

      p->curLine  = 1;

      p->curToken = 0;

    }

    else

    {

      err("clang: Failed to find input file %s in mapping\n",fileName);

    }

  }

}

void ClangParser::finish()

{

  static bool clangAssistedParsing = Config_getBool(CLANG_ASSISTED_PARSING);

  if (!clangAssistedParsing) return;

  if (p->tu)

  {

    //printf("ClangParser::finish()\n");

    delete[] p->cursors;

    clang_disposeTokens(p->tu,p->tokens,p->numTokens);

    clang_disposeTranslationUnit(p->tu);

    clang_disposeIndex(p->index);

    p->fileMapping.clear();

    p->tokens    = 0;

    p->numTokens = 0;

    p->cursors   = 0;

  }

  for (uint i=0;i<p->numFiles;i++)

  {

    free((void *)p->ufs[i].Filename);

  }

  delete[] p->ufs;

  delete[] p->sources;

  p->ufs       = 0;

  p->sources   = 0;

  p->numFiles  = 0;

  p->tu        = 0;

}

int ClangParser::Private::getCurrentTokenLine()

{

  uint l, c;

  if (numTokens==0) return 1;

  // guard against filters that reduce the number of lines

  if (curToken>=numTokens) curToken=numTokens-1;

  CXSourceLocation start = clang_getTokenLocation(tu,tokens[curToken]);

  clang_getSpellingLocation(start, 0, &l, &c, 0);

  return l;

}

QCString ClangParser::lookup(uint line,const char *symbol)

{

  //printf("ClangParser::lookup(%d,%s)\n",line,symbol);

  QCString result;

  if (symbol==0) return result;

  static bool clangAssistedParsing = Config_getBool(CLANG_ASSISTED_PARSING);

  if (!clangAssistedParsing) return result;

  int sl = strlen(symbol);

  uint l = p->getCurrentTokenLine();

  while (l>=line && p->curToken>0)

  {

    if (l==line) // already at the right line

    {

      p->curToken--; // linear search to start of the line

      l = p->getCurrentTokenLine();

    }

    else 

    {

      p->curToken/=2; // binary search backward

      l = p->getCurrentTokenLine();

    }

  }

  bool found=FALSE;

  while (l<=line && p->curToken<p->numTokens && !found)

  {

    CXString tokenString = clang_getTokenSpelling(p->tu, p->tokens[p->curToken]);

    //if (l==line)

    //{

    //  printf("try to match symbol %s with token %s\n",symbol,clang_getCString(tokenString));

    //}

    const char *ts = clang_getCString(tokenString);

    int tl = strlen(ts);

    int startIndex = p->curToken;

    if (l==line && strncmp(ts,symbol,tl)==0) // found partial match at the correct line

    {

      int offset = tl;

      while (offset

      {

        //printf("found partial match\n");

        p->curToken++;

        if (p->curToken>=p->numTokens)

        {

          break; // end of token stream

        }

        l = p->getCurrentTokenLine();

        clang_disposeString(tokenString);

        tokenString = clang_getTokenSpelling(p->tu, p->tokens[p->curToken]);

        ts = clang_getCString(tokenString);

        tl = ts ? strlen(ts) : 0;

        // skip over any spaces in the symbol

        char c;

        while (offset

        {

          offset++;

        }

        if (strncmp(ts,symbol+offset,tl)!=0) // next token matches?

        {

          //printf("no match '%s'<->'%s'\n",ts,symbol+offset);

          break; // no match

        }

        //printf("partial match '%s'<->'%s'\n",ts,symbol+offset);

        offset+=tl;

      }

      if (offset==sl) // symbol matches the token(s)

      {

        CXCursor c = p->cursors[p->curToken];

        CXString usr = clang_getCursorUSR(c);

        //printf("found full match %s usr='%s'\n",symbol,clang_getCString(usr));

        result = clang_getCString(usr);

        clang_disposeString(usr);

        found=TRUE;

      }

      else // reset token cursor to start of the search

      {

        p->curToken = startIndex;

      }

    }

    clang_disposeString(tokenString);

    p->curToken++;

    if (p->curToken<p->numTokens)

    {

      l = p->getCurrentTokenLine();

    }

  }

  //if (!found)

  //{

  //  printf("Did not find symbol %s at line %d :-(\n",symbol,line);

  //}

  //else

  //{

  //  printf("Found symbol %s usr=%s\n",symbol,result.data());

  //}

  return result;

}

static QCString keywordToType(const char *keyword)

{

  static bool init=TRUE;

  static QDict<void> flowKeywords(47);

  static QDict<void> typeKeywords(47);

  if (init)

  {

    flowKeywords.insert("break",(void*)0x8);

    flowKeywords.insert("case",(void*)0x8);

    flowKeywords.insert("catch",(void*)0x8);

    flowKeywords.insert("continue",(void*)0x8);

    flowKeywords.insert("default",(void*)0x8);

    flowKeywords.insert("do",(void*)0x8);

    flowKeywords.insert("else",(void*)0x8);

    flowKeywords.insert("finally",(void*)0x8);

    flowKeywords.insert("for",(void*)0x8);

    flowKeywords.insert("foreach",(void*)0x8);

    flowKeywords.insert("for each",(void*)0x8);

    flowKeywords.insert("goto",(void*)0x8);

    flowKeywords.insert("if",(void*)0x8);

    flowKeywords.insert("return",(void*)0x8);

    flowKeywords.insert("switch",(void*)0x8);

    flowKeywords.insert("throw",(void*)0x8);

    flowKeywords.insert("throws",(void*)0x8);

    flowKeywords.insert("try",(void*)0x8);

    flowKeywords.insert("while",(void*)0x8);

    flowKeywords.insert("@try",(void*)0x8);

    flowKeywords.insert("@catch",(void*)0x8);

    flowKeywords.insert("@finally",(void*)0x8);

    typeKeywords.insert("bool",(void*)0x8);

    typeKeywords.insert("char",(void*)0x8);

    typeKeywords.insert("double",(void*)0x8);

    typeKeywords.insert("float",(void*)0x8);

    typeKeywords.insert("int",(void*)0x8);

    typeKeywords.insert("long",(void*)0x8);

    typeKeywords.insert("object",(void*)0x8);

    typeKeywords.insert("short",(void*)0x8);

    typeKeywords.insert("signed",(void*)0x8);

    typeKeywords.insert("unsigned",(void*)0x8);

    typeKeywords.insert("void",(void*)0x8);

    typeKeywords.insert("wchar_t",(void*)0x8);

    typeKeywords.insert("size_t",(void*)0x8);

    typeKeywords.insert("boolean",(void*)0x8);

    typeKeywords.insert("id",(void*)0x8);

    typeKeywords.insert("SEL",(void*)0x8);

    typeKeywords.insert("string",(void*)0x8);

    typeKeywords.insert("nullptr",(void*)0x8);

    init=FALSE;

  }

  if (flowKeywords[keyword]) return "keywordflow";

  if (typeKeywords[keyword]) return "keywordtype";

  return "keyword";

}

static void writeLineNumber(CodeOutputInterface &ol,FileDef *fd,uint line)

{

  Definition *d = fd ? fd->getSourceDefinition(line) : 0;

  if (d && d->isLinkable())

  {

    g_currentDefinition=d;

    g_currentLine=line;

    MemberDef *md = fd->getSourceMember(line);

    if (md && md->isLinkable())  // link to member

    {

      if (g_currentMemberDef!=md) // new member, start search for body

      {

        g_searchForBody=TRUE;

        g_insideBody=FALSE;

        g_bracketCount=0;

      }

      g_currentMemberDef=md;

      ol.writeLineNumber(md->getReference(),

                         md->getOutputFileBase(),

                         md->anchor(),

                         line);

    }

    else // link to compound

    {

      g_currentMemberDef=0;

      ol.writeLineNumber(d->getReference(),

                         d->getOutputFileBase(),

                         d->anchor(),

                         line);

    }

  }

  else // no link

  {

    ol.writeLineNumber(0,0,0,line);

  }

  // set search page target

  if (Doxygen::searchIndex)

  {

    QCString lineAnchor;

    lineAnchor.sprintf("l%05d",line);

    ol.setCurrentDoc(fd,lineAnchor,TRUE);

  }

  //printf("writeLineNumber(%d) g_searchForBody=%d\n",line,g_searchForBody);

}

static void codifyLines(CodeOutputInterface &ol,FileDef *fd,const char *text,

                        uint &line,uint &column,const char *fontClass=0)

{

  if (fontClass) ol.startFontClass(fontClass);

  const char *p=text,*sp=p;

  char c;

  bool done=FALSE;

  while (!done)

  {

    sp=p;

    while ((c=*p++) && c!='\n') { column++; }

    if (c=='\n')

    {

      line++;

      int l = (int)(p-sp-1);

      column=l+1;

      char *tmp = (char*)malloc(l+1);

      memcpy(tmp,sp,l);

      tmp[l]='\0';

      ol.codify(tmp);

      free(tmp);

      if (fontClass) ol.endFontClass();

      ol.endCodeLine();

      ol.startCodeLine(TRUE);

      writeLineNumber(ol,fd,line);

      if (fontClass) ol.startFontClass(fontClass);

    }

    else

    {

      ol.codify(sp);

      done=TRUE;

    }

  }

  if (fontClass) ol.endFontClass();

}

static void writeMultiLineCodeLink(CodeOutputInterface &ol,

                  FileDef *fd,uint &line,uint &column,

                  Definition *d,

                  const char *text)

{

  static bool sourceTooltips = Config_getBool(SOURCE_TOOLTIPS);

  TooltipManager::instance()->addTooltip(d);

  QCString ref  = d->getReference();

  QCString file = d->getOutputFileBase();

  QCString anchor = d->anchor();

  QCString tooltip;

  if (!sourceTooltips) // fall back to simple "title" tooltips

  {

   tooltip = d->briefDescriptionAsTooltip();

  }

  bool done=FALSE;

  char *p=(char *)text;

  while (!done)

  {

    char *sp=p;

    char c;

    while ((c=*p++) && c!='\n') { column++; }

    if (c=='\n')

    {

      line++;

      *(p-1)='\0';

      //printf("writeCodeLink(%s,%s,%s,%s)\n",ref,file,anchor,sp);

      ol.writeCodeLink(ref,file,anchor,sp,tooltip);

      ol.endCodeLine();

      ol.startCodeLine(TRUE);

      writeLineNumber(ol,fd,line);

    }

    else

    {

      //printf("writeCodeLink(%s,%s,%s,%s)\n",ref,file,anchor,sp);

      ol.writeCodeLink(ref,file,anchor,sp,tooltip);

      done=TRUE;

    }

  }

}

void ClangParser::linkInclude(CodeOutputInterface &ol,FileDef *fd,

    uint &line,uint &column,const char *text)

{

  QCString incName = text;

  incName = incName.mid(1,incName.length()-2); // strip ".." or  <..>

  FileDef *ifd=0;

  if (!incName.isEmpty())

  {

    FileName *fn = Doxygen::inputNameDict->find(incName);

    if (fn)

    {

      bool found=false;

      FileNameIterator fni(*fn);

      // for each include name

      for (fni.toFirst();!found && (ifd=fni.current());++fni)

      {

        // see if this source file actually includes the file

        found = fd->isIncluded(ifd->absFilePath());

        //printf("      include file %s found=%d\n",ifd->absFilePath().data(),found);

      }

    }

  }

  if (ifd)

  {

    ol.writeCodeLink(ifd->getReference(),ifd->getOutputFileBase(),0,text,ifd->briefDescriptionAsTooltip());

  }

  else

  {

    codifyLines(ol,ifd,text,line,column,"preprocessor");

  }

}

void ClangParser::linkMacro(CodeOutputInterface &ol,FileDef *fd,

    uint &line,uint &column,const char *text)

{

  MemberName *mn=Doxygen::functionNameSDict->find(text);

  if (mn)

  {

    MemberNameIterator mni(*mn);

    MemberDef *md;

    for (mni.toFirst();(md=mni.current());++mni)

    {

      if (md->isDefine())

      {

        writeMultiLineCodeLink(ol,fd,line,column,md,text);

        return;

      }

    }

  }

  codifyLines(ol,fd,text,line,column);

}

void ClangParser::linkIdentifier(CodeOutputInterface &ol,FileDef *fd,

    uint &line,uint &column,const char *text,int tokenIndex)

{

  CXCursor c = p->cursors[tokenIndex];

  CXCursor r = clang_getCursorReferenced(c);

  if (!clang_equalCursors(r, c))

  {

    c=r; // link to referenced location

  }

  CXCursor t = clang_getSpecializedCursorTemplate(c);

  if (!clang_Cursor_isNull(t) && !clang_equalCursors(t,c))

  {

    c=t; // link to template 

  }

  CXString usr = clang_getCursorUSR(c);

  const char *usrStr = clang_getCString(usr);

  Definition *d = usrStr ? Doxygen::clangUsrMap->find(usrStr) : 0;

  //CXCursorKind kind = clang_getCursorKind(c);

  //if (d==0)

  //{

  //  printf("didn't find definition for '%s' usr='%s' kind=%d\n",

  //      text,usrStr,kind);

  //}

  //else

  //{

  //  printf("found definition for '%s' usr='%s' name='%s'\n",

  //      text,usrStr,d->name().data());

  //}

  if (d && d->isLinkable())

  {

    if (g_insideBody &&

        g_currentMemberDef && d->definitionType()==Definition::TypeMember && 

        (g_currentMemberDef!=d || g_currentLine

    {

      addDocCrossReference(g_currentMemberDef,(MemberDef*)d);

    }

    writeMultiLineCodeLink(ol,fd,line,column,d,text);

  }

  else

  {

    codifyLines(ol,fd,text,line,column);

  }

  clang_disposeString(usr);

}

static void detectFunctionBody(const char *s)

{

  //printf("punct=%s g_searchForBody=%d g_insideBody=%d g_bracketCount=%d\n",

  //  s,g_searchForBody,g_insideBody,g_bracketCount);

  if (g_searchForBody && (qstrcmp(s,":")==0 || qstrcmp(s,"{")==0)) // start of 'body' (: is for constructor)

  {

    g_searchForBody=FALSE;

    g_insideBody=TRUE;

  }

  else if (g_searchForBody && qstrcmp(s,";")==0) // declaration only

  {

    g_searchForBody=FALSE;

    g_insideBody=FALSE;

  }

  if (g_insideBody && qstrcmp(s,"{")==0) // increase scoping level

  {

    g_bracketCount++;

  }

  if (g_insideBody && qstrcmp(s,"}")==0) // decrease scoping level

  {

    g_bracketCount--;

    if (g_bracketCount<=0) // got outside of function body

    {

      g_insideBody=FALSE;

      g_bracketCount=0;

    }

  }

}

void ClangParser::writeSources(CodeOutputInterface &ol,FileDef *fd)

{

  TooltipManager::instance()->clearTooltips();

  // (re)set global parser state

  g_currentDefinition=0;

  g_currentMemberDef=0;

  g_currentLine=0;

  g_searchForBody=FALSE;

  g_insideBody=FALSE;

  g_bracketCount=0;

  unsigned int line=1,column=1;

  QCString lineNumber,lineAnchor;

  ol.startCodeLine(TRUE);

  writeLineNumber(ol,fd,line);

  for (unsigned int i=0;i<p->numTokens;i++)

  {

    CXSourceLocation start = clang_getTokenLocation(p->tu, p->tokens[i]);

    unsigned int l, c;

    clang_getSpellingLocation(start, 0, &l, &c, 0);

    if (l > line) column = 1;

    while (line

    { 

      line++; 

      ol.endCodeLine();

      ol.startCodeLine(TRUE);

      writeLineNumber(ol,fd,line);

    } 

    while (column

    CXString tokenString = clang_getTokenSpelling(p->tu, p->tokens[i]);

    char const *s = clang_getCString(tokenString);

    CXCursorKind cursorKind  = clang_getCursorKind(p->cursors[i]);

    CXTokenKind tokenKind = clang_getTokenKind(p->tokens[i]);

    //printf("%d:%d %s cursorKind=%d tokenKind=%d\n",line,column,s,cursorKind,tokenKind);

    switch (tokenKind)

    {

      case CXToken_Keyword: 

        if (strcmp(s,"operator")==0)

        {

          linkIdentifier(ol,fd,line,column,s,i);

        }

        else

        {

          codifyLines(ol,fd,s,line,column,

              cursorKind==CXCursor_PreprocessingDirective ? "preprocessor" :

              keywordToType(s));

        }

        break;

      case CXToken_Literal: 

        if (cursorKind==CXCursor_InclusionDirective)

        {

          linkInclude(ol,fd,line,column,s);

        }

        else if (s[0]=='"' || s[0]=='\'') 

        {

          codifyLines(ol,fd,s,line,column,"stringliteral");

        }

        else 

        {

          codifyLines(ol,fd,s,line,column);

        }

        break;

      case CXToken_Comment: 

        codifyLines(ol,fd,s,line,column,"comment");

        break;