/******************************************************************************

 *

 * 

 *

 * Copyright (C) 1997-2015 by Dimitri van Heesch.

 *

 * Permission to use, copy, modify, and distribute this software and its

 * documentation under the terms of the GNU General Public License is hereby 

 * granted. No representations are made about the suitability of this software 

 * for any purpose. It is provided "as is" without express or implied warranty.

 * See the GNU General Public License for more details.

 *

 * Documents produced by Doxygen are derivative works derived from the

 * input used in their production; they are not affected by this license.

 *

 */

#include <ctype.h>

#include <qregexp.h>

#include "md5.h"

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include "config.h"

#include "definition.h"

#include "doxygen.h"

#include "language.h"

#include "message.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 "marshal.h"

#include "debug.h"

#include "vhdldocgen.h"

#include "memberlist.h"

#include "namespacedef.h"

#include "filedef.h"

#include "dirdef.h"

#define START_MARKER 0x4445465B // DEF[

#define END_MARKER   0x4445465D // DEF]

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

/** Private data associated with a Symbol Definition object. */

class DefinitionImpl

{

  public:

    DefinitionImpl();

   ~DefinitionImpl();

    void init(const char *df, const char *n);

    SectionDict *sectionDict;  // dictionary of all sections, not accessible

    MemberSDict *sourceRefByDict;

    MemberSDict *sourceRefsDict;

    QList<ListItemInfo> *xrefListItems;

    GroupList *partOfGroups;

    DocInfo   *details;    // not exported

    DocInfo   *inbodyDocs; // not exported

    BriefInfo *brief;      // not exported

    BodyInfo  *body;       // not exported

    QCString   briefSignatures;

    QCString   docSignatures;

    QCString localName;      // local (unqualified) name of the definition

                             // in the future m_name should become m_localName

    QCString qualifiedName;

    QCString ref;   // reference to external documentation

    bool hidden;

    bool isArtificial;

    Definition *outerScope;  // not owner

    // where the item was found

    QCString defFileName;

    QCString defFileExt;

    SrcLangExt lang;

    QCString id; // clang unique id

};

DefinitionImpl::DefinitionImpl()

  : sectionDict(0), sourceRefByDict(0), sourceRefsDict(0),

    xrefListItems(0), partOfGroups(0),

    details(0), inbodyDocs(0), brief(0), body(0), hidden(FALSE), isArtificial(FALSE),

    outerScope(0), lang(SrcLangExt_Unknown)

{

}

DefinitionImpl::~DefinitionImpl()

{

  delete sectionDict;

  delete sourceRefByDict;

  delete sourceRefsDict;

  delete partOfGroups;

  delete xrefListItems;

  delete brief;

  delete details;

  delete body;

  delete inbodyDocs;

}

void DefinitionImpl::init(const char *df, const char *n)

{

  defFileName = df;

  int lastDot = defFileName.findRev('.');

  if (lastDot!=-1)

  {

    defFileExt = defFileName.mid(lastDot);

  }

  QCString name = n;

  if (name!="<globalScope>") 

  {

    //extractNamespaceName(m_name,m_localName,ns);

    localName=stripScope(n);

  }

  else

  {

    localName=n;

  }

  //printf("m_localName=%s\n",m_localName.data());

  brief           = 0;

  details         = 0;

  body            = 0;

  inbodyDocs      = 0;

  sourceRefByDict = 0;

  sourceRefsDict  = 0;

  sectionDict     = 0, 

  outerScope      = Doxygen::globalScope;

  partOfGroups    = 0;

  xrefListItems   = 0;

  hidden          = FALSE;

  isArtificial    = FALSE;

  lang            = SrcLangExt_Unknown;

}

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

static bool matchExcludedSymbols(const char *name)

{

  static QStrList &exclSyms = Config_getList(EXCLUDE_SYMBOLS);

  if (exclSyms.count()==0) return FALSE; // nothing specified

  const char *pat = exclSyms.first();

  QCString symName = name;

  while (pat)

  {

    QCString pattern = pat;

    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

    {

      QRegExp re(substitute(pattern,"*",".*"),TRUE);

      int i,pl;

      i = re.match(symName,0,&pl);

      //printf("  %d = re.match(%s) pattern=%s\n",i,symName.data(),pattern.data());

      if (i!=-1) // wildcard match

      {

        int sl=symName.length();

        // check if it is a whole word match

        if ((i==0     || pattern.at(0)=='*'    || (!isId(symName.at(i-1))  && !forceStart)) &&

            (i+pl==sl || pattern.at(i+pl)=='*' || (!isId(symName.at(i+pl)) && !forceEnd))

           )

        {

          //printf("--> name=%s pattern=%s match at %d\n",symName.data(),pattern.data(),i);

          return TRUE;

        }

      }

    }

    else if (!pattern.isEmpty()) // match words

    {

      int i = symName.find(pattern);

      if (i!=-1) // we have a match!

      {

        int pl=pattern.length();

        int sl=symName.length();

        // check if it is a whole word match

        if ((i==0     || (!isId(symName.at(i-1))  && !forceStart)) &&

            (i+pl==sl || (!isId(symName.at(i+pl)) && !forceEnd))

           )

        {

          //printf("--> name=%s pattern=%s match at %d\n",symName.data(),pattern.data(),i);

          return TRUE; 

        }

      }

    }

    pat = exclSyms.next();

  }

  //printf("--> name=%s: no match\n",name);

  return FALSE;

}

void Definition::addToMap(const char *name,Definition *d)

{

  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' (%p)\n",symbolName.data(),d);

    DefinitionIntf *di=Doxygen::symbolMap->find(symbolName);

    //printf("  addToMap(%p): looking for symbol %s: %p\n",d,symbolName.data(),di);

    if (di==0) // new Symbol

    {

      //printf("  new symbol!\n");

      Doxygen::symbolMap->insert(symbolName,d);

    }

    else // existing symbol

    {

      //printf("  existing symbol: ");

      if (di->definitionType()==DefinitionIntf::TypeSymbolList) // already multiple symbols

      {

        //printf("adding to exiting list\n");

        DefinitionList *dl = (DefinitionList*)di;

        dl->append(d);

      }

      else // going from one to two symbols

      {

        Doxygen::symbolMap->take(symbolName);

        DefinitionList *dl = new DefinitionList;

        //printf("replacing symbol by list %p with elements %p and %p\n",dl,di,d);

        dl->append((Definition*)di);

        dl->append(d);

        Doxygen::symbolMap->insert(symbolName,dl);

      }

    }

    // auto resize if needed

    static int sizeIndex=9;

    if (Doxygen::symbolMap->size()>SDict_primes[sizeIndex])

    {

      Doxygen::symbolMap->resize(SDict_primes[++sizeIndex]);

    }

    d->_setSymbolName(symbolName);

  }

}

void Definition::removeFromMap(Definition *d)

{

  QCString symbolName = d->m_symbolName;

  if (!symbolName.isEmpty()) 

  {

    //printf("******* removing symbol `%s' (%p)\n",symbolName.data(),d);

    DefinitionIntf *di=Doxygen::symbolMap->find(symbolName);

    if (di)

    {

      if (di!=d) // symbolName not unique

      {

        //printf("  removing from list: %p!\n",di);

        DefinitionList *dl = (DefinitionList*)di;

        bool b = dl->removeRef(d);

        ASSERT(b==TRUE);

        if (dl->isEmpty())

        {

          Doxygen::symbolMap->take(symbolName);

        }

      }

      else // symbolName unique

      {

        //printf("  removing symbol %p\n",di);

        Doxygen::symbolMap->take(symbolName);

      }

    }

  }

}

Definition::Definition(const char *df,int dl,int dc,

                       const char *name,const char *b,

                       const char *d,bool isSymbol) : m_cookie(0)

{

  m_name = name;

  m_defLine = dl;

  m_defColumn = dc;

  m_impl = new DefinitionImpl;

  m_impl->init(df,name);

  m_isSymbol = isSymbol;

  if (isSymbol) addToMap(name,this);

  _setBriefDescription(b,df,dl);

  _setDocumentation(d,df,dl,TRUE,FALSE);

  if (matchExcludedSymbols(name)) 

  {

    m_impl->hidden = TRUE;

  }

}

Definition::Definition(const Definition &d) : DefinitionIntf(), m_cookie(0)

{

  m_name = d.m_name;

  m_defLine = d.m_defLine;

  m_impl = new DefinitionImpl;

  *m_impl = *d.m_impl;

  m_impl->sectionDict = 0;

  m_impl->sourceRefByDict = 0;

  m_impl->sourceRefsDict = 0;

  m_impl->partOfGroups = 0;

  m_impl->xrefListItems = 0;

  m_impl->brief = 0;

  m_impl->details = 0;

  m_impl->body = 0;

  m_impl->inbodyDocs = 0;

  if (d.m_impl->sectionDict)

  {

    m_impl->sectionDict = new SectionDict(17);

    SDict<SectionInfo>::Iterator it(*d.m_impl->sectionDict);

    SectionInfo *si;

    for (it.toFirst();(si=it.current());++it)

    {

      m_impl->sectionDict->append(si->label,si);

    }

  }

  if (d.m_impl->sourceRefByDict)

  {

    m_impl->sourceRefByDict = new MemberSDict;

    MemberSDict::IteratorDict it(*d.m_impl->sourceRefByDict);

    MemberDef *md;

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

    {

      m_impl->sourceRefByDict->append(it.currentKey(),md);

    }

  }

  if (d.m_impl->sourceRefsDict)

  {

    m_impl->sourceRefsDict = new MemberSDict;

    MemberSDict::IteratorDict it(*d.m_impl->sourceRefsDict);

    MemberDef *md;

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

    {

      m_impl->sourceRefsDict->append(it.currentKey(),md);

    }

  }

  if (d.m_impl->partOfGroups)

  {

    GroupListIterator it(*d.m_impl->partOfGroups);

    GroupDef *gd;

    for (it.toFirst();(gd=it.current());++it)

    {

      makePartOfGroup(gd);

    }

  }

  if (d.m_impl->xrefListItems)

  {

    setRefItems(d.m_impl->xrefListItems);

  }

  if (d.m_impl->brief)

  {

    m_impl->brief = new BriefInfo(*d.m_impl->brief);

  }

  if (d.m_impl->details)

  {

    m_impl->details = new DocInfo(*d.m_impl->details);

  }

  if (d.m_impl->body)

  {

    m_impl->body = new BodyInfo(*d.m_impl->body);

  }

  if (d.m_impl->inbodyDocs)

  {

    m_impl->inbodyDocs = new DocInfo(*d.m_impl->inbodyDocs);

  }

  m_isSymbol = d.m_isSymbol;

  if (m_isSymbol) addToMap(m_name,this);

}

Definition::~Definition()

{

  if (m_isSymbol)

  {

    removeFromMap(this);

  }

  if (m_impl)

  {

    delete m_impl;

    m_impl=0;

  }

  delete m_cookie;

  m_cookie=0;

}

void Definition::setName(const char *name)

{

  if (name==0) return;

  m_name = name;

}

void Definition::setId(const char *id)

{

  if (id==0) return;

  m_impl->id = id;

  if (Doxygen::clangUsrMap) 

  {

    //printf("Definition::setId '%s'->'%s'\n",id,m_name.data());

    Doxygen::clangUsrMap->insert(id,this);

  }

}

QCString Definition::id() const

{

  return m_impl->id;

}

void Definition::addSectionsToDefinition(QList<SectionInfo> *anchorList)

{

  if (!anchorList) return;

  //printf("%s: addSectionsToDefinition(%d)\n",name().data(),anchorList->count());

  QListIterator<SectionInfo> it(*anchorList);

  SectionInfo *si;

  for (;(si=it.current());++it)

  {

    //printf("Add section `%s' to definition `%s'\n",

    //    si->label.data(),name().data());

    SectionInfo *gsi=Doxygen::sectionDict->find(si->label);

    //printf("===== label=%s gsi=%p\n",si->label.data(),gsi);

    if (gsi==0)

    {

      gsi = new SectionInfo(*si);

      Doxygen::sectionDict->append(si->label,gsi);

    }

    if (m_impl->sectionDict==0)

    {

      m_impl->sectionDict = new SectionDict(17);

    }

    if (m_impl->sectionDict->find(gsi->label)==0)

    {

      m_impl->sectionDict->append(gsi->label,gsi);

      gsi->definition = this;

    }

  }

}

bool Definition::hasSections() const

{

  //printf("Definition::hasSections(%s) #sections=%d\n",name().data(),

  //    m_impl->sectionDict ? m_impl->sectionDict->count() : 0);

  if (m_impl->sectionDict==0) return FALSE;

  SDict<SectionInfo>::Iterator li(*m_impl->sectionDict);

  SectionInfo *si;

  for (li.toFirst();(si=li.current());++li)

  {

    if (si->type==SectionInfo::Section || 

        si->type==SectionInfo::Subsection || 

        si->type==SectionInfo::Subsubsection ||

        si->type==SectionInfo::Paragraph)

    {

      return TRUE;

    }

  }

  return FALSE;

}

void Definition::addSectionsToIndex()

{

  if (m_impl->sectionDict==0) return;

  //printf("Definition::addSectionsToIndex()\n");

  SDict<SectionInfo>::Iterator li(*m_impl->sectionDict);

  SectionInfo *si;

  int level=1;

  for (li.toFirst();(si=li.current());++li)

  {

    if (si->type==SectionInfo::Section       || 

        si->type==SectionInfo::Subsection    || 

        si->type==SectionInfo::Subsubsection ||

        si->type==SectionInfo::Paragraph)

    {

      //printf("  level=%d title=%s\n",level,si->title.data());

      int nextLevel = (int)si->type;

      int i;

      if (nextLevel>level)

      {

        for (i=level;i

        {

          Doxygen::indexList->incContentsDepth();

        }

      }

      else if (nextLevel

      {

        for (i=nextLevel;i

        {

          Doxygen::indexList->decContentsDepth();

        }

      }

      QCString title = si->title;

      if (title.isEmpty()) title = si->label;

      // determine if there is a next level inside this item

      ++li;

      bool isDir = ((li.current()) ? (int)(li.current()->type > nextLevel):FALSE);

      --li;

      Doxygen::indexList->addContentsItem(isDir,title,

                                         getReference(),

                                         getOutputFileBase(),

                                         si->label,

                                         FALSE,

                                         TRUE);

      level = nextLevel;

    }

  }

  while (level>1)

  {

    Doxygen::indexList->decContentsDepth();

    level--;

  }

}

void Definition::writeDocAnchorsToTagFile(FTextStream &tagFile)

{

  if (m_impl->sectionDict)

  {

    //printf("%s: writeDocAnchorsToTagFile(%d)\n",name().data(),m_impl->sectionDict->count());

    SDict<SectionInfo>::Iterator sdi(*m_impl->sectionDict);

    SectionInfo *si;

    for (;(si=sdi.current());++sdi)

    {

      if (!si->generated && si->ref.isEmpty())

      {

        //printf("write an entry!\n");

        if (definitionType()==TypeMember) tagFile << "  ";

        tagFile << "    <docanchor file=\"" << si->fileName << "\"";

        if (!si->title.isEmpty())

        {

          tagFile << " title=\"" << convertToXML(si->title) << "\"";

        }

        tagFile << ">" << si->label << "</docanchor>" << endl;

      }

    }

  }

}

bool Definition::_docsAlreadyAdded(const QCString &doc,QCString &sigList)

{

  uchar md5_sig[16];

  QCString sigStr(33);

  // to avoid mismatches due to differences in indenting, we first remove

  // double whitespaces...

  QCString docStr = doc.simplifyWhiteSpace();

  MD5Buffer((const unsigned char *)docStr.data(),docStr.length(),md5_sig);

  MD5SigToString(md5_sig,sigStr.rawData(),33);

  //printf("%s:_docsAlreadyAdded doc='%s' sig='%s' docSigs='%s'\n",

  //    name().data(),doc.data(),sigStr.data(),sigList.data());

  if (sigList.find(sigStr)==-1) // new docs, add signature to prevent re-adding it

  {

    sigList+=":"+sigStr;

    return FALSE;

  }

  else

  {

    return TRUE;

  }

}

void Definition::_setDocumentation(const char *d,const char *docFile,int docLine,

                                   bool stripWhiteSpace,bool atTop)

{

  //printf("%s::setDocumentation(%s,%s,%d,%d)\n",name().data(),d,docFile,docLine,stripWhiteSpace);

  if (d==0) return;

  QCString doc = d;

  if (stripWhiteSpace)

  {

    doc = stripLeadingAndTrailingEmptyLines(doc,docLine);

  }

  else // don't strip whitespace

  {

    doc=d;

  }

  if (!_docsAlreadyAdded(doc,m_impl->docSignatures))

  {

    //printf("setting docs for %s: `%s'\n",name().data(),m_doc.data());

    if (m_impl->details==0)

    {

      m_impl->details = new DocInfo;

    }

    if (m_impl->details->doc.isEmpty()) // fresh detailed description

    {

      m_impl->details->doc = doc;

    }

    else if (atTop) // another detailed description, append it to the start

    {

      m_impl->details->doc = doc+"\n\n"+m_impl->details->doc;

    }

    else // another detailed description, append it to the end

    {

      m_impl->details->doc += "\n\n"+doc;

    }

    if (docLine!=-1) // store location if valid

    {

      m_impl->details->file = docFile;

      m_impl->details->line = docLine;

    }

    else

    {

      m_impl->details->file = docFile;

      m_impl->details->line = 1;

    }

  }

}

void Definition::setDocumentation(const char *d,const char *docFile,int docLine,bool stripWhiteSpace)

{

  if (d==0) return;

  _setDocumentation(d,docFile,docLine,stripWhiteSpace,FALSE);

}

#define uni_isupper(c) (QChar(c).category()==QChar::Letter_Uppercase)

// do a UTF-8 aware search for the last real character and return TRUE 

// if that is a multibyte one.

static bool lastCharIsMultibyte(const QCString &s)

{

  int l = s.length();

  int p = 0;

  int pp = -1;

  while ((p=nextUtf8CharPosition(s,l,p))

  if (pp==-1 || ((uchar)s[pp])<0x80) return FALSE;

  return TRUE;

}

void Definition::_setBriefDescription(const char *b,const char *briefFile,int briefLine)

{

  static QCString outputLanguage = Config_getEnum(OUTPUT_LANGUAGE);

  static bool needsDot = outputLanguage!="Japanese" && 

                         outputLanguage!="Chinese" &&

                         outputLanguage!="Korean";

  QCString brief = b;

  brief = brief.stripWhiteSpace();

  if (brief.isEmpty()) return;

  int bl = brief.length();

  if (bl>0 && needsDot) // add punctuation if needed

  {

    int c = brief.at(bl-1);

    switch(c)

    {

      case '.': case '!': case '?': case '>': case ':': case ')': break;

      default: 

        if (uni_isupper(brief.at(0)) && !lastCharIsMultibyte(brief)) brief+='.'; 

        break;

    }

  }

  if (!_docsAlreadyAdded(brief,m_impl->briefSignatures))

  {

    if (m_impl->brief && !m_impl->brief->doc.isEmpty())

    {

       //printf("adding to details\n");

       _setDocumentation(brief,briefFile,briefLine,FALSE,TRUE);

    }

    else

    {

      //fprintf(stderr,"Definition::setBriefDescription(%s,%s,%d)\n",b,briefFile,briefLine);

      if (m_impl->brief==0)

      {

        m_impl->brief = new BriefInfo;

      }

      m_impl->brief->doc=brief;

      if (briefLine!=-1)

      {

        m_impl->brief->file = briefFile;

        m_impl->brief->line = briefLine;

      }

      else

      {

        m_impl->brief->file = briefFile;

        m_impl->brief->line = 1;

      }

    }

  }

  else

  {

    //printf("do nothing!\n");

  }

}

void Definition::setBriefDescription(const char *b,const char *briefFile,int briefLine) 

{ 

  if (b==0) return;

  _setBriefDescription(b,briefFile,briefLine);

}

void Definition::_setInbodyDocumentation(const char *doc,const char *inbodyFile,int inbodyLine)

{

  if (m_impl->inbodyDocs==0)

  {

    m_impl->inbodyDocs = new DocInfo;

  }

  if (m_impl->inbodyDocs->doc.isEmpty()) // fresh inbody docs

  {

    m_impl->inbodyDocs->doc  = doc;

    m_impl->inbodyDocs->file = inbodyFile;

    m_impl->inbodyDocs->line = inbodyLine;

  }

  else // another inbody documentation fragment, append this to the end

  {

    m_impl->inbodyDocs->doc += QCString("\n\n")+doc;

  }

}

void Definition::setInbodyDocumentation(const char *d,const char *inbodyFile,int inbodyLine)

{

  if (d==0) return;

  _setInbodyDocumentation(d,inbodyFile,inbodyLine);

}

/*! Reads a fragment of code from file \a fileName starting at 

 * line \a startLine and ending at line \a endLine (inclusive). The fragment is

 * stored in \a result. If FALSE is returned the code fragment could not be

 * found.

 *

 * The file is scanned for a opening bracket ('{') from \a startLine onward

 * The line actually containing the bracket is returned via startLine.

 * The file is scanned for a closing bracket ('}') from \a endLine backward.

 * The line actually containing the bracket is returned via endLine.

 * Note that for VHDL code the bracket search is not done.

 */

bool readCodeFragment(const char *fileName,

                      int &startLine,int &endLine,QCString &result)

{

  static bool filterSourceFiles = Config_getBool(FILTER_SOURCE_FILES);

  static int tabSize = Config_getInt(TAB_SIZE);

  //printf("readCodeFragment(%s,%d,%d)\n",fileName,startLine,endLine);

  if (fileName==0 || fileName[0]==0) return FALSE; // not a valid file name

  QCString filter = getFileFilter(fileName,TRUE);

  FILE *f=0;

  bool usePipe = !filter.isEmpty() && filterSourceFiles;

  SrcLangExt lang = getLanguageFromFileName(fileName);

  if (!usePipe) // no filter given or wanted

  {

    f = portable_fopen(fileName,"r");

  }

  else // use filter

  {

    QCString cmd=filter+" \""+fileName+"\"";

    Debug::print(Debug::ExtCmd,0,"Executing popen(`%s`)\n",qPrint(cmd));

    f = portable_popen(cmd,"r");

  }

  bool found = lang==SrcLangExt_VHDL   || 

               lang==SrcLangExt_Tcl    || 

               lang==SrcLangExt_Python || 

               lang==SrcLangExt_Fortran;  

               // for VHDL, TCL, Python, and Fortran no bracket search is possible

  if (f)

  {

    int c=0;

    int col=0;

    int lineNr=1;

    // skip until the startLine has reached

    while (lineNr

    {

      while ((c=fgetc(f))!='\n' && c!=EOF) /* skip */;

      lineNr++; 

      if (found && c == '\n') c = '\0';

    }

    if (!feof(f))

    {

      // skip until the opening bracket or lonely : is found

      char cn=0;

      while (lineNr<=endLine && !feof(f) && !found)

      {

        int pc=0;

        while ((c=fgetc(f))!='{' && c!=':' && c!=EOF)  // } so vi matching brackets has no problem

        {

          //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=fgetc(f))!='\n' && c!=EOF) pc=c;

            if (c=='\n') lineNr++,col=0;

          }

          else if (pc=='/' && c=='*') // skip C style comment

          {

            while (((c=fgetc(f))!='/' || pc!='*') && c!=EOF) 

            {

              if (c=='\n') lineNr++,col=0;

              pc=c;

            }

          }

          else

          {

            col++;

          }

          pc = c;

        }

        if (c==':')

        {

          cn=fgetc(f);

          if (cn!=':') found=TRUE;

        }

        else if (c=='{')   // } so vi matching brackets has no problem

        {

          found=TRUE;

        }

      }

      //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++;

        }

        const int maxLineLength=4096;

        char lineStr[maxLineLength];

        do 

        {

          //printf("reading line %d in range %d-%d\n",lineNr,startLine,endLine);

          int size_read;

          do 

          {

            // read up to maxLineLength-1 bytes, the last byte being zero

            char *p = fgets(lineStr, maxLineLength,f);

            //printf("  read %s",p);

            if (p) 

            {

              size_read=qstrlen(p); 

            }

            else  // nothing read

            {

              size_read=-1;

              lineStr[0]='\0';

            }

            result+=lineStr;

          } while (size_read == (maxLineLength-1));

          lineNr++; 

        } while (lineNr<=endLine && !feof(f));

        // strip stuff after closing bracket

        int newLineIndex = result.findRev('\n');

        int braceIndex   = result.findRev('}');

        if (braceIndex > newLineIndex) 

        {

          result.truncate(braceIndex+1);

        }

        endLine=lineNr-1;

      }

    }

    if (usePipe) 

    {

      portable_pclose(f); 

      Debug::print(Debug::FilterOutput, 0, "Filter output\n");

      Debug::print(Debug::FilterOutput,0,"-------------\n%s\n-------------\n",qPrint(result));

    }

    else 

    {

      fclose(f);

    }

  }

  result = transcodeCharacterStringToUTF8(result);