// @(#)root/html:$Id$
// Author: Axel Naumann 2007-01-09

/*************************************************************************
 * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#include "TDocParser.h"

#include "Riostream.h"
#include "TBaseClass.h"
#include "TClass.h"
#include "TClassDocOutput.h"
#include "TDataMember.h"
#include "TDataType.h"
#include "TDatime.h"
#include "TDocDirective.h"
#include "TEnv.h"
#include "TGlobal.h"
#include "THtml.h"
#include "TInterpreter.h"
#include "TMethod.h"
#include "TMethodArg.h"
#include "TPRegexp.h"
#include "TROOT.h"
#include "TSystem.h"
#include "TVirtualMutex.h"
#include <string>

namespace {

   class TMethodWrapperImpl: public TDocMethodWrapper {
   public:
      TMethodWrapperImpl(TMethod* m, int overloadIdx):
         fMeth(m), fOverloadIdx(overloadIdx) {}

      static void SetClass(const TClass* cl) { fgClass = cl; }

      const char* GetName() const { return fMeth->GetName(); }
      ULong_t Hash() const { return fMeth->Hash();}
      Int_t GetNargs() const { return fMeth->GetNargs(); }
      virtual TMethod* GetMethod() const { return fMeth; }
      Bool_t IsSortable() const { return kTRUE; }

      Int_t GetOverloadIdx() const { return fOverloadIdx; }

      Int_t Compare(const TObject *obj) const {
         const TMethodWrapperImpl* m = dynamic_cast<const TMethodWrapperImpl*>(obj);
         if (!m) return 1;

         Int_t ret = strcasecmp(GetName(), m->GetName());
         if (ret == 0) {
            if (GetNargs() < m->GetNargs()) return -1;
            else if (GetNargs() > m->GetNargs()) return 1;
            if (GetMethod()->GetClass()->InheritsFrom(m->GetMethod()->GetClass()))
               return -1;
            else
               return 1;
         }

         const char* l(GetName());
         const char* r(m->GetName());
         if (l[0] == '~' && r[0] == '~') {
            ++l;
            ++r;
         }
         TClass *lcl = 0;
         TClass *rcl = 0;
         if (fMeth->Property() & (kIsConstructor|kIsDestructor)) {
            lcl = TClass::GetClass(l);
         }
         if (m->fMeth->Property() & (kIsConstructor|kIsDestructor)) {
            rcl = TClass::GetClass(r);
         }
         if (lcl && fgClass->InheritsFrom(lcl)) {
               if (rcl && fgClass->InheritsFrom(rcl)) {
                  if (lcl->InheritsFrom(rcl))
                     return -1;
                  else return 1;
               } else return -1;
         } else if (rcl && fgClass->InheritsFrom(rcl))
            return 1;

         if (l[0] == '~') return -1;
         if (r[0] == '~') return 1;
         return (ret < 0) ? -1 : 1;
      }

   private:
      static const TClass* fgClass; // current class, defining inheritance sort order
      TMethod* fMeth; // my method
      Int_t fOverloadIdx; // this is the n-th overload
   };

   const TClass* TMethodWrapperImpl::fgClass = 0;
}


//______________________________________________________________________________
////////////////////////////////////////////////////////////////////////////////
//
// Parse C++ source or header, and extract documentation.
//
// Also handles special macros like
/* Begin_Macro(GUI, source)
{
   TGMainFrame* f = new TGMainFrame(0, 100, 100);
   f->SetName("testMainFrame"); // that's part of the name of the image
   TGButton* b = new TGTextButton(f, "Test Button");
   f->AddFrame(b);
   f->MapSubwindows();
   f->Resize(f->GetDefaultSize());

   f->MapWindow();
   return f; // *HIDE*
}
End_Macro */
// or multiline Latex aligned at =:
/* Begin_Latex(separator='=',align=rcl) C = d #sqrt{#frac{2}{#lambdaD}} #int^{x}_{0}cos(#frac{#pi}{2}t^{2})dt
 D(x) = d End_Latex */
// even without alignment: Begin_Latex
// x=sin^2(y)
// y = #sqrt{sin(x)}
// End_Latex and what about running an external macro?
/* BEGIN_MACRO(source)


testmacro.C END_MACRO


and some nested stuff which doesn't work yet: */
// BEGIN_HTML
/* BEGIN_LATEX Wow,^{an}_{image}^{inside}_{a}^{html}_{block}
   END_LATEX
*/
// END_HTML
////////////////////////////////////////////////////////////////////////////////

ClassImp(TDocParser);

std::set<std::string>  TDocParser::fgKeywords;

//______________________________________________________________________________
TDocParser::TDocParser(TClassDocOutput& docOutput, TClass* cl):
   fHtml(docOutput.GetHtml()), fDocOutput(&docOutput), fLineNo(0),
   fCurrentClass(cl), fRecentClass(0), fCurrentModule(0),
   fDirectiveCount(0), fLineNumber(0), fDocContext(kIgnore),
   fCheckForMethod(kFALSE), fClassDocState(kClassDoc_Uninitialized),
   fCommentAtBOL(kFALSE), fAllowDirectives(kTRUE)
{
   // Constructor called for parsing class sources

   InitKeywords();

   fSourceInfoTags[kInfoLastUpdate] = fHtml->GetLastUpdateTag();
   fSourceInfoTags[kInfoAuthor]     = fHtml->GetAuthorTag();
   fSourceInfoTags[kInfoCopyright]  = fHtml->GetCopyrightTag();

   fClassDescrTag = fHtml->GetClassDocTag();

   TMethodWrapperImpl::SetClass(cl);

   for (int ia = 0; ia < 3; ++ia) {
      fMethods[ia].Rehash(101);
   }

   AddClassMethodsRecursively(0);
   AddClassDataMembersRecursively(0);

   // needed for list of methods,...
   fParseContext.push_back(kCode);

   // create an array of method names
   TMethod *method;
   TIter nextMethod(fCurrentClass->GetListOfMethods());
   fMethodCounts.clear();
   while ((method = (TMethod *) nextMethod())) {
      ++fMethodCounts[method->GetName()];
   }

}

//______________________________________________________________________________
TDocParser::TDocParser(TDocOutput& docOutput):
   fHtml(docOutput.GetHtml()), fDocOutput(&docOutput), fLineNo(0),
   fCurrentClass(0), fRecentClass(0), fDirectiveCount(0),
   fLineNumber(0), fDocContext(kIgnore),
   fCheckForMethod(kFALSE), fClassDocState(kClassDoc_Uninitialized),
   fCommentAtBOL(kFALSE), fAllowDirectives(kFALSE)
{
   // constructor called for parsing text files with Convert()
   InitKeywords();

   fSourceInfoTags[kInfoLastUpdate] = fHtml->GetLastUpdateTag();
   fSourceInfoTags[kInfoAuthor]     = fHtml->GetAuthorTag();
   fSourceInfoTags[kInfoCopyright]  = fHtml->GetCopyrightTag();

   fClassDescrTag = fHtml->GetClassDocTag();

   TMethodWrapperImpl::SetClass(0);
}

//______________________________________________________________________________
TDocParser::~TDocParser()
{
   // destructor, checking whether all methods have been found for gDebug > 3
   if (gDebug > 3) {
      for (std::map<std::string, Int_t>::const_iterator iMethod = fMethodCounts.begin();
         iMethod != fMethodCounts.end(); ++iMethod)
         if (iMethod->second)
            Info("~TDocParser", "Implementation of method %s::%s could not be found.",
            fCurrentClass ? fCurrentClass->GetName() : "",
            iMethod->first.c_str());
      TIter iDirective(&fDirectiveHandlers);
      TDocDirective* directive = 0;
      while ((directive = (TDocDirective*) iDirective())) {
         TString directiveName;
         directive->GetName(directiveName);
         Warning("~TDocParser", "Missing \"%s\" for macro %s", directive->GetEndTag(), directiveName.Data());
      }
   }
}

//______________________________________________________________________________
void TDocParser::AddClassMethodsRecursively(TBaseClass* bc)
{
   // Add accessible (i.e. non-private) methods of base class bc
   // and its base classes' methods to methodNames.
   // If bc==0, we add fCurrentClass's methods (and also private functions).

   // make a loop on member functions
   TClass *cl = fCurrentClass;
   if (bc)
      cl = bc->GetClassPointer(kFALSE);
   if (!cl) return;

   TMethod *method;
   TIter nextMethod(cl->GetListOfMethods());
   std::map<std::string, int> methOverloads;

   while ((method = (TMethod *) nextMethod())) {

      if (!strcmp(method->GetName(), "Dictionary") ||
          !strcmp(method->GetName(), "Class_Version") ||
          !strcmp(method->GetName(), "Class_Name") ||
          !strcmp(method->GetName(), "DeclFileName") ||
          !strcmp(method->GetName(), "DeclFileLine") ||
          !strcmp(method->GetName(), "ImplFileName") ||
          !strcmp(method->GetName(), "ImplFileLine") ||
          (bc && (method->GetName()[0] == '~' // d'tor
             || !strcmp(method->GetName(), method->GetReturnTypeName()))) // c'tor
          )
         continue;


      Int_t mtype = 0;
      if (kIsPrivate & method->Property())
         mtype = 0;
      else if (kIsProtected & method->Property())
         mtype = 1;
      else if (kIsPublic & method->Property())
         mtype = 2;

      if (bc) {
         if (mtype == 0) continue;
         if (bc->Property() & kIsPrivate)
            mtype = 0;
         else if ((bc->Property() & kIsProtected) && mtype == 2)
            mtype = 1;
      }

      Bool_t hidden = kFALSE;
      for (Int_t access = 0; !hidden && access < 3; ++access) {
         TMethodWrapperImpl* other = (TMethodWrapperImpl*) fMethods[access].FindObject(method->GetName());
         hidden |= (other) && (other->GetMethod()->GetClass() != method->GetClass());
      }
      if (!hidden) {
         fMethods[mtype].Add(new TMethodWrapperImpl(method, methOverloads[method->GetName()]));
         ++methOverloads[method->GetName()];
      }
   }

   TIter iBase(cl->GetListOfBases());
   TBaseClass* base = 0;
   while ((base = (TBaseClass*)iBase()))
      AddClassMethodsRecursively(base);

   if (!bc)
      for (Int_t access = 0; access < 3; ++access) {
         fMethods[access].SetOwner();
         fMethods[access].Sort();
      }
}

//______________________________________________________________________________
void TDocParser::AddClassDataMembersRecursively(TBaseClass* bc) {
   // Add data members of fCurrentClass and of bc to datamembers, recursively.
   // Real data members are in idx 0..2 (public, protected, private access),
   // enum constants in idx 3..5.

   // make a loop on member functions
   TClass *cl = fCurrentClass;
   if (bc)
      cl = bc->GetClassPointer(kFALSE);
   if (!cl) return;

   TDataMember *dm;
   TIter nextDM(cl->GetListOfDataMembers());

   while ((dm = (TDataMember *) nextDM())) {
      if (!strcmp(dm->GetName(), "fgIsA"))
         continue;
      Int_t mtype = 0;
      if (kIsPrivate & dm->Property())
         mtype = 0;
      else if (kIsProtected & dm->Property())
         mtype = 1;
      else if (kIsPublic & dm->Property())
         mtype = 2;

      if (bc) {
         if (mtype == 0) continue;
         if (bc->Property() & kIsPrivate)
            mtype = 0;
         else if ((bc->Property() & kIsProtected) && mtype == 2)
            mtype = 1;
      }

      const Int_t flagEnumConst = kIsEnum | kIsConstant | kIsStatic;
      if ((dm->Property() & flagEnumConst) == flagEnumConst
          && dm->GetDataType() && dm->GetDataType()->GetType() == kInt_t) {
         mtype = 5;
         // The access of the enum constant is defined by the access of the enum:
         // for CINT, all enum constants are public.
         // There is no TClass or TDataType for enum types; instead, use CINT:
         /*
           No - CINT does not know their access restriction.
           With CINT5 we have no way of determining it...

         ClassInfo_t* enumCI = gInterpreter->ClassInfo_Factory(dm->GetTypeName());
         if (enumCI) {
            Long_t prop = gInterpreter->ClassInfo_Property(enumCI);
            if (kIsPrivate & prop)
               mtype = 3;
            else if (kIsProtected & prop)
               mtype = 4;
            else if (kIsPublic & prop)
               mtype = 5;
            gInterpreter->ClassInfo_Delete(enumCI);
         }
         */
      }

      fDataMembers[mtype].Add(dm);
   }

   TIter iBase(cl->GetListOfBases());
   TBaseClass* base = 0;
   while ((base = (TBaseClass*)iBase()))
      AddClassDataMembersRecursively(base);

   if (!bc)
      for (Int_t access = 0; access < 6; ++access) {
         fDataMembers[access].SetOwner(kFALSE);
         if (access < 3) // don't sort enums; we keep them in enum tag order
            fDataMembers[access].Sort();
      }
}


//______________________________________________________________________________
void TDocParser::AnchorFromLine(const TString& line, TString& anchor) {
   // Create an anchor from the given line, by hashing it and
   // convertig the hash into a custom base64 string.

   const char base64String[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.";

   // use hash of line instead of e.g. line number.
   // advantages: more stable (lines can move around, we still find them back),
   // no need for keeping a line number context
   UInt_t hash = ::Hash(line);
   anchor.Remove(0);
   // force first letter to be [A-Za-z], to be id compatible
   anchor += base64String[hash % 52];
   hash /= 52;
   while (hash) {
      anchor += base64String[hash % 64];
      hash /= 64;
   }
}

//______________________________________________________________________________
void TDocParser::Convert(std::ostream& out, std::istream& in, const char* relpath,
                         Bool_t isCode, Bool_t interpretDirectives)
{
   // Parse text file "in", add links etc, and write output to "out".
   // If "isCode", "in" is assumed to be C++ code.
   fLineNumber = 0;
   fParseContext.clear();
   if (isCode) fParseContext.push_back(kCode);
   else        fParseContext.push_back(kComment); // so we can find "BEGIN_HTML"/"END_HTML" in plain text

   while (!in.eof()) {
      fLineRaw.ReadLine(in, kFALSE);
      ++fLineNumber;
      if (in.eof())
         break;

      // remove leading spaces
      fLineComment = "";
      fLineSource = fLineRaw;
      fLineStripped = fLineRaw;
      Strip(fLineStripped);

      DecorateKeywords(fLineSource);

      // Changes in this bit of code have consequences for:
      // * module index,
      // * source files,
      // * THtml::Convert() e.g. in tutorials/html/MakeTutorials.C
      if (!interpretDirectives) {
         // Only write the raw, uninterpreted directive code:
         if (!InContext(kDirective)) {
            GetDocOutput()->AdjustSourcePath(fLineSource, relpath);
            out << fLineSource << std::endl;
         }
      } else {
         // Write source for source and interpreted directives if they exist.
         if (fLineComment.Length() ) {
            GetDocOutput()->AdjustSourcePath(fLineComment, relpath);
            out << fLineComment << std::endl;
         } else if (!InContext(kDirective)) {
            GetDocOutput()->AdjustSourcePath(fLineSource, relpath);
            out << fLineSource << std::endl;
         }
      }
   }
}

//______________________________________________________________________________
void TDocParser::DecorateKeywords(std::ostream& out, const char *text)
{
   // Expand keywords in text, writing to out.
   TString str(text);
   DecorateKeywords(str);
   out << str;
}

//______________________________________________________________________________
void TDocParser::DecorateKeywords(TString& line)
{
   // Find keywords in line and create URLs around them. Escape characters with a
   // special meaning for HTML. Protect "Begin_Html"/"End_Html" pairs, and set the
   // parsing context. Evaluate sequences like a::b->c.
   // Skip regions where directives are active.

   std::list<TClass*> currentType;

   enum {
      kNada,
      kMember,
      kScope,
      kNumAccesses
   } scoping = kNada;

   currentType.push_back(0);

   Ssiz_t i = 0;
   while (isspace((UChar_t)line[i]))
      ++i;

   Ssiz_t startOfLine = i;

   // changed when the end of a directive is encountered, i.e.
   // from where fLineSource needs to be appended to fLineComment
   Ssiz_t copiedToCommentUpTo = 0;

   if (InContext(kDirective) && fDirectiveHandlers.Last()) {
      // we're only waiting for an "End_Whatever" and ignoring everything else
      TDocDirective* directive = (TDocDirective*)fDirectiveHandlers.Last();
      const char* endTag = directive->GetEndTag();
      Ssiz_t posEndTag = i;
      while (kNPOS != (posEndTag = line.Index(endTag, posEndTag, TString::kIgnoreCase)))
         if (posEndTag == 0 || line[posEndTag - 1] != '"') // escaping '"'
            break;
      if (posEndTag != kNPOS)
         i = posEndTag;
      else {
         Ssiz_t start = 0;
         if (!InContext(kComment) || (InContext(kComment) & kCXXComment)) {
            // means we are in a C++ comment
            while (isspace((UChar_t)fLineRaw[start])) ++start;
            if (fLineRaw[start] == '/' && fLineRaw[start + 1] == '/')
               start += 2;
            else start = 0;
         }
         directive->AddLine(fLineRaw(start, fLineRaw.Length()));
         while(i < line.Length())
            fDocOutput->ReplaceSpecialChars(line, i);
         copiedToCommentUpTo = i;
      }
   }

   for (; i < line.Length(); ++i) {

      if (!currentType.back())
         scoping = kNada;

      // evaluate scope relation
      if (Context() == kCode
         || Context() == kComment) {
         if (currentType.back())
            switch (line[i]) {
               case ':':
                  if (line[i + 1] == ':') {
                     scoping = kScope;
                     i += 1;
                     continue;
                  }
                  break;
               case '-':
                  if (line[i + 1] == '>') {
                     scoping = kMember;
                     i += 1;
                     continue;
                  }
                  break;
               case '.':
                  if (line[i + 1] != '.') {
                     // prevent "..."
                     scoping = kMember;
                     continue;
                  }
                  break;
            }
         switch (line[i]) {
            case '(':
               currentType.push_back(0);
               scoping = kNada;
               continue;
               break;
            case ')':
               if (currentType.size() > 1)
                  currentType.pop_back();
               scoping = kMember;
               continue;
               break;
         }
         if (i >= line.Length())
            break;
      } else // code or comment
         currentType.back() = 0;


      if (!IsWord(line[i])){

         Bool_t haveHtmlEscapedChar = Context() == kString
            && i > 2 && line[i] == '\'' && line[i-1] == ';';
         if (haveHtmlEscapedChar) {
            Ssiz_t posBegin = i - 2;
            while (posBegin > 0 && IsWord(line[posBegin]))
               --posBegin;
            haveHtmlEscapedChar = posBegin > 0 &&
               line[posBegin] == '&' && line[posBegin - 1] == '\'';
         }
         EParseContext context = Context();
         Bool_t closeString = context == kString
            && (  line[i] == '"'
               || (line[i] == '\''
                   && (  (i > 1 && line[i - 2] == '\'')
                      || (i > 3 && line[i - 2] == '\\' && line[i - 3] == '\'')))
               || haveHtmlEscapedChar)
            && (i == 0 || line[i - 1] != '\\'); // but not "foo \"str...
         if (context == kCode || context == kComment) {
            if (line[i] == '"' || (line[i] == '\'' && (
                  // 'a'
                  (line.Length() > i + 2 && line[i + 2] == '\'') ||
                  // '\a'
                  (line.Length() > i + 3 && line[i + 1] == '\'' && line[i + 3] == '\'')))) {

               fDocOutput->DecorateEntityBegin(line, i, kString);
               fParseContext.push_back(kString);
               currentType.back() = 0;
               closeString = kFALSE;
            } else if (context == kCode
               && line[i] == '/' && (line[i+1] == '/' || line[i+1] == '*')) {
               fParseContext.push_back(kComment);
               if (line[i+1] == '/')
                  fParseContext.back() |= kCXXComment;
               currentType.back() = 0;
               fDocOutput->DecorateEntityBegin(line, i, kComment);
               ++i;
            } else if (context == kComment
               && !(fParseContext.back() & kCXXComment)
               && line.Length() > i + 1
               && line[i] == '*' && line[i+1] == '/') {
               if (fParseContext.size()>1)
                  fParseContext.pop_back();

               currentType.back() = 0;
               i += 2;
               fDocOutput->DecorateEntityEnd(line, i, kComment);
               if (!fCommentAtBOL) {
                  if (InContext(kDirective))
                     ((TDocDirective*)fDirectiveHandlers.Last())->AddLine(line(copiedToCommentUpTo, i));
                  else
                     fLineComment += line(copiedToCommentUpTo, i);
                  copiedToCommentUpTo = i;
               }
            } else if (startOfLine == i
               && line[i] == '#'
               && context == kCode) {
               ExpandCPPLine(line, i);
            }
         } // if context is comment or code

         if (i < line.Length())
            fDocOutput->ReplaceSpecialChars(line, i);

         if (closeString) {
            fDocOutput->DecorateEntityEnd(line, i, kString);
            if (fParseContext.size()>1)
               fParseContext.pop_back();

            currentType.back() = 0;
         }
         --i; // i already moved by ReplaceSpecialChar

         continue;
      } // end of "not a word"

      // get the word
      Ssiz_t endWord = i;
      while (endWord < line.Length() && IsName(line[endWord]))
         endWord++;

      if (Context() == kString || Context() == kCPP) {
         // don't replace in strings, cpp, etc
         i = endWord - 1;
         continue;
      }

      TString word(line(i, endWord - i));

      // '"' escapes handling of "Begin_..."/"End_..."
      if ((i == 0 || (i > 0 && line[i - 1] != '"'))
         && HandleDirective(line, i, word, copiedToCommentUpTo)) {
         // something special happened; the currentType is gone.
         currentType.back() = 0;
         continue;
      }

      // don't replace keywords in comments
      if (Context() == kCode
         && fgKeywords.find(word.Data()) != fgKeywords.end()) {
         fDocOutput->DecorateEntityBegin(line, i, kKeyword);
         i += word.Length();
         fDocOutput->DecorateEntityEnd(line, i, kKeyword);
         --i; // -1 for ++i
         currentType.back() = 0;
         continue;
      }

      // Now decorate scopes and member, referencing their documentation:

      // generic layout:
      // A::B::C::member[arr]->othermember
      // we iterate through this, first scope is A, and currentType will be set toA,
      // next we see ::B, "::" signals to use currentType,...

      TDataType* subType = 0;
      TClass* subClass = 0;
      TDataMember *datamem = 0;
      TMethod *meth = 0;
      const char* globalTypeName = 0;
      if (!currentType.size()) {
         Warning("DecorateKeywords", "type context is empty!");
         currentType.push_back(0);
      }
      TClass* lookupScope = currentType.back();

      if (scoping == kNada) {
         if (fCurrentClass)
            lookupScope = fCurrentClass;
         else
            lookupScope = fRecentClass;
      }

      if (scoping == kNada) {
         subType = gROOT->GetType(word);
         if (!subType)
            subClass = fHtml->GetClass(word);
         if (!subType && !subClass) {
            TGlobal *global = gROOT->GetGlobal(word);
            if (global) {
               // cannot doc globals; take at least their type...
               globalTypeName = global->GetTypeName();
               subClass = fHtml->GetClass(globalTypeName);
               if (!subClass)
                  subType = gROOT->GetType(globalTypeName);
               else // hack to prevent current THtml obj from showing up - we only want gHtml
                  if (subClass == THtml::Class() && word != "gHtml")
                     subClass = 0;
            }
         }
         if (!subType && !subClass) {
            // too bad - cannot doc yet...
            //TFunction *globFunc = gROOT->GetGlobalFunctionWithPrototype(word);
            //globFunc = 0;
         }
         if (!subType && !subClass) {
            // also try template
            while (isspace(line[endWord])) ++endWord;
            if (line[endWord] == '<' || line[endWord] == '>') {
               // check for possible template
               Ssiz_t endWordT = endWord + 1;
               int templateLevel = 1;
               while (endWordT < line.Length()
                      && (templateLevel
                          || IsName(line[endWordT])
                          || line[endWordT] == '<'
                          || line[endWordT] == '>')) {
                  if (line[endWordT] == '<')
                     ++templateLevel;
                  else if (line[endWordT] == '>')
                     --templateLevel;
                  endWordT++;
               }
               subClass = fHtml->GetClass(line(i, endWordT - i).Data());
               if (subClass)
                  word = line(i, endWordT - i);
            }
         }
      }

      if (lookupScope && !subType && !subClass) {
         if (scoping == kScope) {
            TString subClassName(lookupScope->GetName());
            subClassName += "::";
            subClassName += word;
            subClass = fHtml->GetClass(subClassName);
            if (!subClass)
               subType = gROOT->GetType(subClassName);
         }
         if (!subClass && !subType) {
            // also try A::B::c()
            datamem = lookupScope->GetDataMember(word);
            if (!datamem)
               meth = lookupScope->GetMethodAllAny(word);
         }
         if (!subClass && !subType && !datamem && !meth) {
            // also try template
            while (isspace(line[endWord])) ++endWord;
            if (line[endWord] == '<' || line[endWord] == '>') {
               // check for possible template
               Ssiz_t endWordT = endWord + 1;
               int templateLevel = 1;
               while (endWordT < line.Length()
                      && (templateLevel
                          || IsName(line[endWordT])
                          || line[endWordT] == '<'
                          || line[endWordT] == '>')) {
                  if (line[endWordT] == '<')
                     ++templateLevel;
                  else if (line[endWordT] == '>')
                     --templateLevel;
                  endWordT++;
               }
               TString subClassName(lookupScope->GetName());
               subClassName += "::";
               subClassName += line(i, endWordT - i);
               subClass = fHtml->GetClass(subClassName);
               if (subClass)
                  word = line(i, endWordT - i);
            }
         }
      }
      // create the link
      TString mangledWord(word);
      fDocOutput->ReplaceSpecialChars(mangledWord);
      line.Replace(i, word.Length(), mangledWord);

      TSubString substr(line(i, mangledWord.Length()));
      if (subType) {
         fDocOutput->ReferenceEntity(substr, subType,
            globalTypeName ? globalTypeName : subType->GetName());
         currentType.back() = 0;
      } else if (subClass) {
         fDocOutput->ReferenceEntity(substr, subClass,
            globalTypeName ? globalTypeName : subClass->GetName());

         currentType.back() = subClass;
         fRecentClass = subClass;
      } else if (datamem || meth) {
            if (datamem) {
               fDocOutput->ReferenceEntity(substr, datamem);

               if (datamem->GetTypeName())
                  currentType.back() = fHtml->GetClass(datamem->GetTypeName());
            } else {
               fDocOutput->ReferenceEntity(substr, meth);

               TString retTypeName = meth->GetReturnTypeName();
               if (retTypeName.BeginsWith("const "))
                  retTypeName.Remove(0,6);
               Ssiz_t pos=0;
               while (IsWord(retTypeName[pos]) || retTypeName[pos]=='<' || retTypeName[pos]=='>' || retTypeName[pos]==':')
                  ++pos;
               retTypeName.Remove(pos, retTypeName.Length());
               if (retTypeName.Length())
                  currentType.back() = fHtml->GetClass(retTypeName);
            }
      } else
         currentType.back() = 0;

      //i += mangledWord.Length();
      i += substr.Length();

      --i; // due to ++i
   } // while i < line.Length()
   if (i > line.Length())
      i = line.Length();

   // clean up, no strings across lines
   if (Context() == kString) {
      fDocOutput->DecorateEntityEnd(line, i, kString);
      if (fParseContext.size()>1)
         fParseContext.pop_back();
      currentType.back() = 0;
   }

   // HandleDirective already copied the chunk before the directive
   // from fLineSource to fLineComment. So we're done up to "i" in
   // fLineSource; next time we encounter a directive we just need
   // to copy from startOfComment on.
   if ((InContext(kComment) || fCommentAtBOL) && copiedToCommentUpTo < line.Length()) {
      if (InContext(kDirective))
         ((TDocDirective*)fDirectiveHandlers.Last())->AddLine(line(copiedToCommentUpTo, line.Length()));
      else
         fLineComment += line(copiedToCommentUpTo, line.Length());
   }

   // Do this after we append to fLineComment, otherwise the closing
   // </span> gets sent to the directive.
   // clean up, no CPP comment across lines
   if (InContext(kComment) & kCXXComment) {
      fDocOutput->DecorateEntityEnd(line, i, kComment);
      if (fLineComment.Length()) {
         Ssiz_t pos = fLineComment.Length();
         fDocOutput->DecorateEntityEnd(fLineComment, pos, kComment);
      }
      RemoveCommentContext(kTRUE);
      currentType.back() = 0;
   }
}

//______________________________________________________________________________
void TDocParser::DecrementMethodCount(const char* name)
{
   // reduce method count for method called name,
   // removing it from fMethodCounts once the count reaches 0.

   typedef std::map<std::string /*method name*/, Int_t > MethodCount_t;
   MethodCount_t::iterator iMethodName = fMethodCounts.find(name);
   if (iMethodName != fMethodCounts.end()) {
      --(iMethodName->second);
      if (iMethodName->second <= 0)
         fMethodCounts.erase(iMethodName);
   }
}

//______________________________________________________________________________
void  TDocParser::DeleteDirectiveOutput() const
{
   // Delete output generated by prior runs of all known directives;
   // the output file names might have changes.

   TIter iClass(gROOT->GetListOfClasses());
   TClass* cl = 0;
   while ((cl = (TClass*) iClass()))
      if (cl != TDocDirective::Class()
         && cl->InheritsFrom(TDocDirective::Class())) {
         TDocDirective* directive = (TDocDirective*) cl->New();
         if (!directive) continue;
         directive->SetParser(const_cast<TDocParser*>(this));
         directive->DeleteOutput();
         delete directive;
      }
}

//______________________________________________________________________________
void TDocParser::ExpandCPPLine(TString& line, Ssiz_t& pos)
{
// Expand preprocessor statements
//
//
// Input: line - line containing the CPP statement,
//        pos  - position of '#'
//
//  NOTE: Looks for the #include statements and
//        creates link to the corresponding file
//        if such file exists
//

   Bool_t linkExist    = kFALSE;
   Ssiz_t posEndOfLine = line.Length();
   Ssiz_t posHash      = pos;

   Ssiz_t posInclude = line.Index("include", pos);
   if (posInclude != kNPOS) {
      TString filename;
      Ssiz_t posStartFilename = posInclude + 7;
      if (line.Tokenize(filename, posStartFilename, "[<\"]")) {
         Ssiz_t posEndFilename = posStartFilename;
         if (line.Tokenize(filename, posEndFilename, "[>\"]")) {
            R__LOCKGUARD(fHtml->GetMakeClassMutex());

            TString filesysFileName;
            if (fHtml->GetPathDefinition().GetFileNameFromInclude(filename, filesysFileName)) {
               fDocOutput->CopyHtmlFile(filesysFileName);

               TString endOfLine(line(posEndFilename - 1, line.Length()));
               line.Remove(posStartFilename, line.Length());
               for (Ssiz_t i = pos; i < line.Length();)
                  fDocOutput->ReplaceSpecialChars(line, i);

               line += "<a href=\"./";
               line += gSystem->BaseName(filename);
               line += "\">";
               line += filename + "</a>" + endOfLine[0]; // add include file's closing '>' or '"'
               posEndOfLine = line.Length() - 1; // set the "processed up to" to it
               fDocOutput->ReplaceSpecialChars(line, posEndOfLine); // and run replace-special-char on it

               line += endOfLine(1, endOfLine.Length()); // add the unprocessed part of the line back

               linkExist = kTRUE;
            }
         }
      }
   }

   if (!linkExist) {
      fDocOutput->ReplaceSpecialChars(line);
      posEndOfLine = line.Length();
   }

   Ssiz_t posHashAfterDecoration = posHash;
   fDocOutput->DecorateEntityBegin(line, posHashAfterDecoration, kCPP);
   posEndOfLine += posHashAfterDecoration - posHash;

   fDocOutput->DecorateEntityEnd(line, posEndOfLine, kCPP);
   pos = posEndOfLine;
}


//______________________________________________________________________________
void TDocParser::GetCurrentModule(TString& out_module) const {
   // Return the name of module for which sources are currently parsed.
   if (fCurrentModule) out_module = fCurrentModule;
   else if (fCurrentClass) fHtml->GetModuleNameForClass(out_module, fCurrentClass);
   else out_module = "(UNKNOWN MODULE WHILE PARSING)";
}

//______________________________________________________________________________
Bool_t TDocParser::HandleDirective(TString& line, Ssiz_t& pos, TString& word,
                                   Ssiz_t& copiedToCommentUpTo)
{
   // Process directives to the documentation engine, like "Begin_Html" / "End_Html",
   // "Begin_Macro" / "End_Macro", and "Begin_Latex" / "End_Latex".

   Bool_t begin = kTRUE;
   TClass* clDirective = IsDirective(line, pos, word, begin);
   if (!clDirective)
      return kFALSE;

   // we'll need end later on: afer the begin block, both end _and_ begin can be true.
   Bool_t end = !begin;

   TDocDirective* directive = 0; // allow re-use of object from begin block in end

   if (begin) {
      // copy from fLineSource to fLineComment, starting at copiedToCommentUpTo
      if (InContext(kDirective))
         ((TDocDirective*)fDirectiveHandlers.Last())->AddLine(fLineSource(copiedToCommentUpTo, pos - copiedToCommentUpTo));
      else
         fLineComment += fLineSource(copiedToCommentUpTo, pos - copiedToCommentUpTo);
      copiedToCommentUpTo = pos;

      pos += word.Length(); // skip the keyword

      directive = (TDocDirective*) clDirective->New();
      if (!directive)
         return kFALSE;

      directive->SetParser(this);
      if (fCurrentMethodTag.Length())
         directive->SetTag(fCurrentMethodTag);
      directive->SetCounter(fDirectiveCount++);

      // parse parameters
      TString params;
      if (begin && line[pos] == '(') {
         std::list<char> waitForClosing;
         Ssiz_t endParam = pos + 1;
         for (; endParam < line.Length()
            && (line[endParam] != ')' || !waitForClosing.empty()); ++endParam) {
            const char c = line[endParam];
            if (!waitForClosing.empty() && waitForClosing.back() == c) {
               waitForClosing.pop_back();
               continue;
            }
            switch (c) {
               case '"':
                  if (waitForClosing.empty() || waitForClosing.back() != '\'')
                     waitForClosing.push_back('"');
                  break;
               case '\'':
                  if (waitForClosing.empty() || waitForClosing.back() != '"')
                     waitForClosing.push_back('\'');
                  break;
               case '(':
                  if (waitForClosing.empty() || (waitForClosing.back() != '"' && waitForClosing.back() != '\''))
                     waitForClosing.push_back(')');
                  break;
               case '\\':
                  ++endParam; // skip next char
               default:
                  break;
            };
         }
         if (waitForClosing.empty()) {
            params = line(pos + 1, endParam - (pos + 1));
            pos += params.Length() + 2; // params + parentheses
         }
         directive->SetParameters(params);
      }

      // check for end tag in current line
      Ssiz_t posEndTag = pos;
      const char* endTag = directive->GetEndTag();
      Ssiz_t lenEndTag = strlen(endTag);
      while (kNPOS != (posEndTag = line.Index(endTag, posEndTag, TString::kIgnoreCase))) {
         if (line[posEndTag - 1] == '"') {
            posEndTag += lenEndTag;
            continue; // escaping '"'
         }
         break;
      }
      if (posEndTag != kNPOS) {
         end = kTRUE; // we just continue below!
      } else {
         fDirectiveHandlers.AddLast(directive);

         fParseContext.push_back(kDirective);
         if (InContext(kComment) & kCXXComment)
            fParseContext.back() |= kCXXComment;

         posEndTag = line.Length();
      }

      directive->AddLine(line(pos, posEndTag - pos));
      TString remainder(line(posEndTag, line.Length()));
      line.Remove(posEndTag, line.Length());

      while (pos < line.Length())
         fDocOutput->ReplaceSpecialChars(line, pos);

      pos = line.Length();
      // skip the remainder of the line
      copiedToCommentUpTo = line.Length();
      line += remainder;
   }

   // no else - "end" can also be set by begin having an end tag!
   if (end) {

      if (!begin)
         pos += word.Length(); // skip the keyword
      else pos += word.Length() - 2; // "Begin" is 2 chars longer than "End"

      if (!directive) directive = (TDocDirective*) fDirectiveHandlers.Last();

      if (!directive) {
         Warning("HandleDirective", "Cannot find directive handler object %s !",
            fLineRaw.Data());
         return kFALSE;
      }

      if (!begin) {
         Ssiz_t start = 0;
         if (!InContext(kComment) || (InContext(kComment) & kCXXComment)) {
            // means we are in a C++ comment
            while (isspace((UChar_t)fLineRaw[start])) ++start;
            if (fLineRaw[start] == '/' && fLineRaw[start + 1] == '/')
               start += 2;
            else start = 0;
         }
         directive->AddLine(line(start, pos - word.Length() - start));

         TString remainder(line(pos, line.Length()));
         line.Remove(pos, line.Length());
         fDocOutput->ReplaceSpecialChars(line);
         pos = line.Length();
         line += remainder;
      }
      copiedToCommentUpTo = pos;

      TString result;
      directive->GetResult(result);

      if (!begin)
         fDirectiveHandlers.Remove(fDirectiveHandlers.LastLink());
      delete directive;

      if (!begin) {
         // common to all directives: pop context
         Bool_t isInCxxComment = InContext(kDirective) & kCXXComment;
         if (fParseContext.size()>1)
            fParseContext.pop_back();
         if (isInCxxComment && !InContext(kComment)) {
            fParseContext.push_back(kComment | kCXXComment);
            fDocOutput->DecorateEntityBegin(line, pos, kComment);
         }
      }

      if (InContext(kDirective) && fDirectiveHandlers.Last())
         ((TDocDirective*)fDirectiveHandlers.Last())->AddLine(result(0, result.Length()));
      else
         fLineComment += result;

      /* NO - this can happen e.g. for "BEGIN_HTML / *..." (see doc in this class)
      if (Context() != kComment) {
         Warning("HandleDirective", "Popping back a directive context, but enclosing context is not a comment! At:\n%s",
            fLineRaw.Data());
         fParseContext.push_back(kComment);
      }
      */
   }

   return kTRUE;
}

//______________________________________________________________________________
UInt_t TDocParser::InContext(Int_t context) const
{
   // checks whether we are in a parse context, return the entry closest
   // to the current context.
   // If context is a EParseContextFlag just look for the first match in
   // the flags

   UInt_t lowerContext = context & kParseContextMask;
   UInt_t contextFlag  = context & kParseContextFlagMask;

   for (std::list<UInt_t>::const_reverse_iterator iPC = fParseContext.rbegin();
      iPC != fParseContext.rend(); ++iPC)
      if (!lowerContext || ((lowerContext && ((*iPC & kParseContextMask) == lowerContext))
         && (!contextFlag || (contextFlag && (*iPC & contextFlag)))))
         return *iPC;

   return 0;
}

//______________________________________________________________________________
void TDocParser::InitKeywords() const
{
   // fill C++ keywords into fgKeywords

   if (!fgKeywords.empty())
      return;

   fgKeywords.insert("asm");
   fgKeywords.insert("auto");
   fgKeywords.insert("bool");
   fgKeywords.insert("break");
   fgKeywords.insert("case");
   fgKeywords.insert("catch");
   fgKeywords.insert("char");
   fgKeywords.insert("class");
   fgKeywords.insert("const");
   fgKeywords.insert("const_cast");
   fgKeywords.insert("continue");
   fgKeywords.insert("default");
   fgKeywords.insert("delete");
   fgKeywords.insert("do");
   fgKeywords.insert("double");
   fgKeywords.insert("dynamic_cast");
   fgKeywords.insert("else");
   fgKeywords.insert("enum");
   fgKeywords.insert("explicit");
   fgKeywords.insert("export");
   fgKeywords.insert("extern");
   fgKeywords.insert("false");
   fgKeywords.insert("float");
   fgKeywords.insert("for");
   fgKeywords.insert("friend");
   fgKeywords.insert("goto");
   fgKeywords.insert("if");
   fgKeywords.insert("inline");
   fgKeywords.insert("int");
   fgKeywords.insert("long");
   fgKeywords.insert("mutable");
   fgKeywords.insert("namespace");
   fgKeywords.insert("new");
   fgKeywords.insert("operator");
   fgKeywords.insert("private");
   fgKeywords.insert("protected");
   fgKeywords.insert("public");
   fgKeywords.insert("register");
   fgKeywords.insert("reinterpret_cast");
   fgKeywords.insert("return");
   fgKeywords.insert("short");
   fgKeywords.insert("signed");
   fgKeywords.insert("sizeof");
   fgKeywords.insert("static");
   fgKeywords.insert("static_cast");
   fgKeywords.insert("struct");
   fgKeywords.insert("switch");
   fgKeywords.insert("template");
   fgKeywords.insert("this");
   fgKeywords.insert("throw");
   fgKeywords.insert("true");
   fgKeywords.insert("try");
   fgKeywords.insert("typedef");
   fgKeywords.insert("typeid");
   fgKeywords.insert("typename");
   fgKeywords.insert("union");
   fgKeywords.insert("unsigned");
   fgKeywords.insert("using");
   fgKeywords.insert("virtual");
   fgKeywords.insert("void");
   fgKeywords.insert("volatile");
   fgKeywords.insert("wchar_t");
   fgKeywords.insert("while");
}

//______________________________________________________________________________
TClass* TDocParser::IsDirective(const TString& line, Ssiz_t pos,
                                        const TString& word, Bool_t& begin) const
{
   // return whether word at line's pos is a valid directive, and returns its
   // TDocDirective's TClass object, or 0 if it's not a directive. Set begin
   // to kTRUE for "Begin_..."
   // You can implement your own handlers by implementing a class deriving
   // from TDocHandler, and calling it TDocTagDirective for "BEGIN_TAG",
   // "END_TAG" blocks.

   // '"' serves as escape char
   if (pos > 0 &&  line[pos - 1] == '"')
      return 0;

   begin      = word.BeginsWith("begin_", TString::kIgnoreCase);
   Bool_t end = word.BeginsWith("end_", TString::kIgnoreCase);

   if (!begin && !end)
      return 0;

   /* NO - we can have "BEGIN_HTML / * ..."
   if (!InContext(kComment))
      return 0;
   */

   TString tag = word( begin ? 6 : 4, word.Length());

   if (!tag.Length())
      return 0;

   tag.ToLower();
   tag[0] -= 'a' - 'A'; // first char is caps
   tag.Prepend("TDoc");
   tag += "Directive";

   TClass* clDirective = TClass::GetClass(tag, kFALSE);

   if (gDebug > 0 && !clDirective)
      Warning("IsDirective", "Unknown THtml directive %s in line %d!", word.Data(), fLineNo);

   return clDirective;
}

//______________________________________________________________________________
Bool_t TDocParser::IsName(UChar_t c)
{
// Check if c is a valid C++ name character
//
//
//  Input: c - a single character
//
// Output: TRUE if c is a valid C++ name character
//         and FALSE if it's not.
//
//   NOTE: Valid name characters are [a..zA..Z0..9_~],
//

   Bool_t ret = kFALSE;

   if (isalnum(c) || c == '_' || c == '~')
      ret = kTRUE;

   return ret;
}


//______________________________________________________________________________
Bool_t TDocParser::IsWord(UChar_t c)
{
// Check if c is a valid first character for C++ name
//
//
//  Input: c - a single character
//
// Output: TRUE if c is a valid first character for C++ name,
//         and FALSE if it's not.
//
//   NOTE: Valid first characters are [a..zA..Z_~]
//

   Bool_t ret = kFALSE;

   if (isalpha(c) || c == '_' || c == '~')
      ret = kTRUE;

   return ret;
}


//______________________________________________________________________________
TMethod* TDocParser::LocateMethodInCurrentLine(Ssiz_t &posMethodName, TString& ret,
                                               TString& name, TString& params,
                                               Bool_t& isconst, std::ostream &srcOut,
                                               TString &anchor, std::ifstream& sourceFile,
                                               Bool_t allowPureVirtual)
{
   // Search for a method starting at posMethodName, and return its return type,
   // its name, and its arguments. If the end of arguments is not found in the
   // current line, get a new line from sourceFile, beautify it to srcOut, creating
   // an anchor as necessary. When this function returns, posMethodName points to the
   // end of the function declaration, i.e. right after the arguments' closing bracket.
   // If posMethodName == kNPOS, we look for the first matching method in fMethodCounts.

   typedef std::map<std::string /*method name*/, Int_t > MethodCount_t;
   isconst = false;

   if (posMethodName == kNPOS) {
      name.Remove(0);
      TMethod * meth = 0;
      Ssiz_t posBlock = fLineRaw.Index('{');
      Ssiz_t posQuote = fLineRaw.Index('"');
      if (posQuote != kNPOS && (posBlock == kNPOS || posQuote < posBlock))
         posBlock = posQuote;
      if (posBlock == kNPOS)
         posBlock = fLineRaw.Length();
      for (MethodCount_t::iterator iMethodName = fMethodCounts.begin();
         !name.Length() && iMethodName != fMethodCounts.end(); ++iMethodName) {
         TString lookFor(iMethodName->first);
         posMethodName = fLineRaw.Index(lookFor);
         if (posMethodName != kNPOS && posMethodName < posBlock
            && (posMethodName == 0 || !IsWord(fLineRaw[posMethodName - 1]))) {
            // check whether the method name is followed by optional spaces and
            // an opening parathesis
            Ssiz_t posMethodEnd = posMethodName + lookFor.Length();
            while (isspace((UChar_t)fLineRaw[posMethodEnd])) ++posMethodEnd;
            if (fLineRaw[posMethodEnd] == '(') {
               meth = LocateMethodInCurrentLine(posMethodName, ret, name, params, isconst,
                                                srcOut, anchor, sourceFile, allowPureVirtual);
               if (name.Length())
                  return meth;
            }
         }
      }
      return 0;
   }

   name = fLineRaw(posMethodName, fLineRaw.Length() - posMethodName);

   // extract return type
   ret = fLineRaw(0, posMethodName);
   if (ret.Length()) {
      while (ret.Length() && (IsName(ret[ret.Length() - 1]) || ret[ret.Length()-1] == ':'))
         ret.Remove(ret.Length() - 1, 1);
      Strip(ret);
      Bool_t didSomething = kTRUE;
      while (didSomething) {
         didSomething = kFALSE;
         if (ret.BeginsWith("inline ")) {
            didSomething = kTRUE;
            ret.Remove(0, 7);
         }
         if (ret.BeginsWith("static ")) {
            didSomething = kTRUE;
            ret.Remove(0, 7);
         }
         if (ret.BeginsWith("virtual ")) {
            didSomething = kTRUE;
            ret.Remove(0, 8);
         }
      } // while replacing static, virtual, inline
      Strip(ret);
   }

   // extract parameters
   Ssiz_t posParam = name.First('(');
   if (posParam == kNPOS ||
      // no strange return types, please
      ret.Contains("{") || ret.Contains("}") || ret.Contains("(") || ret.Contains(")")
      || ret.Contains("=")) {
      ret.Remove(0);
      name.Remove(0);
      params.Remove(0);
      return 0;
   }

   if (name.BeginsWith("operator")) {
      // op () (...)
      Ssiz_t checkOpBracketParam = posParam + 1;
      while (isspace((UChar_t)name[checkOpBracketParam]))
         ++checkOpBracketParam;
      if (name[checkOpBracketParam] == ')') {
         ++checkOpBracketParam;
         while (isspace((UChar_t)name[checkOpBracketParam]))
            ++checkOpBracketParam;
         if (name[checkOpBracketParam] == '(')
            posParam = checkOpBracketParam;
      }
   } // check for op () (...)

   if (posParam == kNPOS) {
      ret.Remove(0);
      name.Remove(0);
      params.Remove(0);
      return 0;
   }

   params = name(posParam, name.Length() - posParam);
   name.Remove(posParam);
   while (name.Length() && isspace((UChar_t)name[name.Length() - 1]))
      name.Remove(name.Length() - 1);
   if (!name.Length()) {
      ret.Remove(0);
      name.Remove(0);
      params.Remove(0);
      return 0;
   }

   MethodCount_t::const_iterator iMethodName = fMethodCounts.find(name.Data());
   if (iMethodName == fMethodCounts.end() || iMethodName->second <= 0) {
      ret.Remove(0);
      name.Remove(0);
      params.Remove(0);
      return 0;
   }

   // find end of param
   Ssiz_t posParamEnd = 1;
   Int_t bracketLevel = 1;
   while (bracketLevel) {
      const char* paramEnd = strpbrk(params.Data() + posParamEnd, ")(\"'");
      if (!paramEnd) {
         // func with params over multiple lines
         // gotta write out this line before it gets lost
         if (!anchor.Length()) {
            // request an anchor, just in case...
            AnchorFromLine(fLineStripped, anchor);
            if (srcOut)
               srcOut << "<a name=\"" << anchor << "\"></a>";
         }
         ++fLineNumber;
         if (srcOut)
            WriteSourceLine(srcOut);

         fLineRaw.ReadLine(sourceFile, kFALSE);
         if (sourceFile.eof()) {
            Error("LocateMethodInCurrentLine",
               "Cannot find end of signature for function %s!",
               name.Data());
            break;
         }

         fCommentAtBOL = kFALSE;

         // replace class names etc
         fLineStripped = fLineRaw;
         Strip(fLineStripped);

         fLineSource = fLineRaw;
         DecorateKeywords(fLineSource);

         posParamEnd = params.Length();
         params += fLineRaw;
      } else
         posParamEnd = paramEnd - params.Data();
      switch (params[posParamEnd]) {
         case '(': ++bracketLevel; ++posParamEnd; break;
         case ')': --bracketLevel; ++posParamEnd; break;
         case '"': // skip ")"
            ++posParamEnd;
            while (params.Length() > posParamEnd && params[posParamEnd] != '"') {
               // skip '\"'
               if (params[posParamEnd] == '\\') ++posParamEnd;
               ++posParamEnd;
            }
            if (params.Length() <= posParamEnd) {
               // something is seriously wrong - skip :-/
               ret.Remove(0);
               name.Remove(0);
               params.Remove(0);
               return 0;
            }
            ++posParamEnd; // skip trailing '"'
            break;
         case '\'': // skip ')'
            ++posParamEnd;
            if (params[posParamEnd] == '\\') ++posParamEnd;
            posParamEnd += 2;
            break;
         default:
            ++posParamEnd;
      }
   } // while bracketlevel, i.e. (...(..)...)

   {
      TString pastParams(params(posParamEnd, params.Length()));
      pastParams = pastParams.Strip(TString::kLeading);
      isconst = pastParams.BeginsWith("const") && !(isalnum(pastParams[5]) || pastParams[5] == '_');
   }

   Ssiz_t posBlock     = params.Index('{', posParamEnd);
   Ssiz_t posSemicolon = params.Index(';', posParamEnd);
   Ssiz_t posPureVirt  = params.Index('=', posParamEnd);
   if (posSemicolon != kNPOS)
      if ((posBlock == kNPOS || (posSemicolon < posBlock)) &&
         (posPureVirt == kNPOS || !allowPureVirtual)
         && !allowPureVirtual) // allow any "func();" if pv is allowed
         params.Remove(0);

   if (params.Length())
      params.Remove(posParamEnd);

   if (!params.Length()) {
      ret.Remove(0);
      name.Remove(0);
      return 0;
   }
   // update posMethodName to point behind the method
   posMethodName = posParam + posParamEnd;
   if (fCurrentClass) {
      TMethod* meth = fCurrentClass->GetMethodAny(name);
      if (meth) {
         fDirectiveCount = 0;
         fCurrentMethodTag = name + "_";
         fCurrentMethodTag += fMethodCounts[name.Data()];
         return meth;
      }
   }

   return 0;
}


//______________________________________________________________________________
void TDocParser::Parse(std::ostream& out)
{
   // Locate methods, starting in the source file, then inline, then
   // immediately inside the class declaration. While doing that also
   // find the class description and special tags like the macro tag etc.

   fClassDocState = kClassDoc_LookingNothingFound;

   DeleteDirectiveOutput();

   LocateMethodsInSource(out);
   LocateMethodsInHeaderInline(out);
   LocateMethodsInHeaderClassDecl(out);

   if (!fSourceInfo[kInfoLastUpdate].Length()) {
      TDatime date;
      fSourceInfo[kInfoLastUpdate] = date.AsString();
   }
}

//______________________________________________________________________________
void TDocParser::LocateMethods(std::ostream& out, const char* filename,
                          Bool_t lookForSourceInfo /*= kTRUE*/,
                          Bool_t useDocxxStyle /*= kFALSE*/,
                          Bool_t allowPureVirtual /*= kFALSE*/,
                          const char* methodPattern /*= 0*/,
                          const char* sourceExt /*= 0 */)
{
   // Collect methods from the source or header file called filename.
   // It generates a beautified version of the source file on the fly;
   // the output file is given by the fCurrentClass's name, and sourceExt.
   // Documentation is extracted to out.
   //   lookForSourceInfo: if set, author, lastUpdate, and copyright are
   //     extracted (i.e. the values contained in fSourceInfo)
   //   useDocxxStyle: if set, documentation can be in front of the method
   //     name, not only inside the method. Useful doc Doc++/Doxygen style,
   //     and inline methods.
   //   lookForClassDescr: if set, the first line matching the class description
   //     rules is assumed to be the class description for fCurrentClass; the
   //     description is written to out.
   //   methodPattern: if set, methods have to be prepended by this tag. Usually
   //     the class name + "::". In header files, looking for in-place function
   //     definitions, this should be 0. In that case, only functions in
   //     fMethodCounts are searched for.

   TString sourceFileName(filename);
   fCurrentFile = filename;
   if (!sourceFileName.Length()) {
      fHtml->GetImplFileName(fCurrentClass, kFALSE, sourceFileName);
      Error("LocateMethods", "Can't find source file '%s' for class %s!",
         sourceFileName.Data(), fCurrentClass->GetName());
      return;
   }
   std::ifstream sourceFile(sourceFileName.Data());
   if (!sourceFile || !sourceFile.good()) {
      Error("LocateMethods", "Can't open file '%s' for reading!", sourceFileName.Data());
      return;
   }

   TPMERegexp patternRE(methodPattern ? methodPattern : "");

   TString codeOneLiner;
   TString methodRet;
   TString methodName;
   TString methodParam;
   Bool_t methodIsConst = kFALSE;
   TString anchor;
   TString docxxComment;

   Bool_t wroteMethodNowWaitingForOpenBlock = kFALSE;

   std::ofstream srcHtmlOut;
   TString srcHtmlOutName;
   if (sourceExt && sourceExt[0]) {
      static_cast<TClassDocOutput*>(fDocOutput)->CreateSourceOutputStream(srcHtmlOut, sourceExt, srcHtmlOutName);
      fLineNumber = 0;
   } else {
      sourceExt = 0;
      srcHtmlOutName = fCurrentClass->GetName();
      fDocOutput->NameSpace2FileName(srcHtmlOutName);
      gSystem->PrependPathName("src", srcHtmlOutName);
      srcHtmlOutName += ".h.html";
   }

   fParseContext.clear();
   fParseContext.push_back(kCode);
   fDocContext = kIgnore;
   fLineNo = 0;

   while (!sourceFile.eof()) {
      Bool_t needAnchor = kFALSE;

      ++fLineNo; // we count fortrany

      fLineRaw.ReadLine(sourceFile, kFALSE);
      if (sourceFile.eof()) break;

      fCommentAtBOL = InContext(kComment);

      // replace class names etc
      fLineStripped = fLineRaw;
      Strip(fLineStripped);

      fLineSource = fLineRaw;
      fLineComment = "";
      DecorateKeywords(fLineSource);

      if (!ProcessComment()) {
         // not a commented line

         if (fDocContext == kDocClass && fClassDocState < kClassDoc_Written) {
            TString strippedComment(fComment);
            Strip(strippedComment);
            if (strippedComment.Length() > 0) {
               fLastClassDoc = fComment;
               if (fClassDocState == kClassDoc_LookingNothingFound) {
                  fFirstClassDoc = fComment;
                  fClassDocState = kClassDoc_LookingHaveSomething;
               }
            }
            fDocContext = kIgnore;
         }

         Ssiz_t impIdx = fLineStripped.Index("ClassImp(");
         if (impIdx == 0 && fClassDocState == kClassDoc_LookingHaveSomething) {
            TString name(fCurrentClass->GetName());
            // take unscoped version
            Ssiz_t posLastScope = kNPOS;
            while ((posLastScope = name.Index("::")) != kNPOS)
               name.Remove(0, posLastScope + 2);

            Ssiz_t posName = fLineStripped.Index(name, impIdx);
            if (posName != kNPOS) {
               Ssiz_t posClosingParen = posName + name.Length();
               while (isspace(fLineStripped[posClosingParen])) ++posClosingParen;
               if (fLineStripped[posClosingParen] == ')') {
                  WriteClassDoc(out, kFALSE);
                  fDocContext = kIgnore;
               }
            }
         }

         if (fLineStripped.Length())
            // remove last class doc if it not followed by ClassImp
            // (with optional empty lines in between)
            fLastClassDoc = "";

         // write previous method
         if (methodName.Length() && !wroteMethodNowWaitingForOpenBlock) {
            TString savedComment;
            if (useDocxxStyle && docxxComment.Length()) {
               savedComment = fComment;
               fComment = docxxComment;
            }
            WriteMethod(out, methodRet, methodName, methodParam, methodIsConst,
               gSystem->BaseName(srcHtmlOutName), anchor, codeOneLiner);
            docxxComment.Remove(0);
            if (savedComment[0]) {
               fComment = savedComment;
            }
         }

         if (!wroteMethodNowWaitingForOpenBlock) {
            // check for method
            Ssiz_t posPattern = kNPOS;
            if (methodPattern) {
               posPattern = fLineRaw.Index((TPRegexp&)patternRE);
            }
            if (posPattern != kNPOS && methodPattern) {
               // no strings, no blocks in front of function declarations / implementations
               static const char vetoChars[] = "{\"";
               for (int ich = 0; posPattern != kNPOS && vetoChars[ich]; ++ich) {
                  Ssiz_t posVeto = fLineRaw.Index(vetoChars[ich]);
                  if (posVeto != kNPOS && posVeto < posPattern)
                     posPattern = kNPOS;
               }
            }
            if (posPattern != kNPOS || !methodPattern) {
               if (methodPattern) {
                  patternRE.Match(fLineRaw);
                  posPattern += patternRE[0].Length();
               }
               LocateMethodInCurrentLine(posPattern, methodRet, methodName,
                                         methodParam, methodIsConst, srcHtmlOut,
                                         anchor, sourceFile, allowPureVirtual);
               if (methodName.Length()) {
                  fDocContext = kDocFunc;
                  needAnchor = !anchor.Length();
                  if (useDocxxStyle)
                     docxxComment = fComment;
                  fComment.Remove(0);
                  codeOneLiner.Remove(0);

                  wroteMethodNowWaitingForOpenBlock = fLineRaw.Index("{", posPattern) == kNPOS;
                  wroteMethodNowWaitingForOpenBlock &= fLineRaw.Index(";", posPattern) == kNPOS;
               } else if (fLineRaw.First("{};") != kNPOS)
                  // these chars reset the preceding comment
                  fComment.Remove(0);
            } // pattern matches - could be a method
            else
               fComment.Remove(0);
         } else {
            wroteMethodNowWaitingForOpenBlock &= fLineRaw.Index("{") == kNPOS;
            wroteMethodNowWaitingForOpenBlock &= fLineRaw.Index(";") == kNPOS;
         } // if !wroteMethodNowWaitingForOpenBlock

         if (methodName.Length() && !wroteMethodNowWaitingForOpenBlock) {
            // make sure we don't have more '{' in commentLine than in fLineRaw
            if (!codeOneLiner.Length() &&
                fLineSource.CountChar('{') == 1 &&
                fLineSource.CountChar('}') == 1) {
               // a one-liner
               codeOneLiner = fLineSource;
               codeOneLiner.Remove(0, codeOneLiner.Index('{'));
               codeOneLiner.Remove(codeOneLiner.Index('}') + 1);
            }
         } // if method name and '{'
         // else not a comment, and we don't need the previous one:
         else if (!methodName.Length() && !useDocxxStyle)
            fComment.Remove(0);

         if (needAnchor || fExtraLinesWithAnchor.find(fLineNo) != fExtraLinesWithAnchor.end()) {
            AnchorFromLine(fLineStripped, anchor);
            if (sourceExt)
               srcHtmlOut << "<a name=\"" << anchor << "\"></a>";
         }
         // else anchor.Remove(0); - NO! WriteMethod will need it later!
      } // if !comment

      // check for last update,...
      Ssiz_t posTag = kNPOS;
      if (lookForSourceInfo)
         for (Int_t si = 0; si < (Int_t) kNumSourceInfos; ++si)
            if (!fSourceInfo[si].Length() && (posTag = fLineRaw.Index(fSourceInfoTags[si])) != kNPOS) {
               fSourceInfo[si] = fLineRaw(posTag + strlen(fSourceInfoTags[si]), fLineRaw.Length() - posTag);
               if (si == kInfoAuthor)
                  fDocOutput->FixupAuthorSourceInfo(fSourceInfo[kInfoAuthor]);
            }


      // write to .cxx.html
      ++fLineNumber;
      if (srcHtmlOut)
         WriteSourceLine(srcHtmlOut);
      else if (needAnchor)
         fExtraLinesWithAnchor.insert(fLineNo);
   } // while !sourceFile.eof()

   // deal with last func
   if (methodName.Length()) {
      if (useDocxxStyle && docxxComment.Length())
         fComment = docxxComment;
      WriteMethod(out, methodRet, methodName, methodParam, methodIsConst,
         gSystem->BaseName(srcHtmlOutName), anchor, codeOneLiner);
      docxxComment.Remove(0);
   } else
      WriteClassDoc(out);

   srcHtmlOut << "</pre>" << std::endl;

   fDocOutput->WriteLineNumbers(srcHtmlOut, fLineNumber, gSystem->BaseName(fCurrentFile));

   srcHtmlOut << "</div>" << std::endl;

   fDocOutput->WriteHtmlFooter(srcHtmlOut, "../");

   fParseContext.clear();
   fParseContext.push_back(kCode);
   fDocContext = kIgnore;
   fCurrentFile = "";
}

//______________________________________________________________________________
void TDocParser::LocateMethodsInSource(std::ostream& out)
{
   // Given fCurrentClass, look for methods in its source file,
   // and extract documentation to out, while beautifying the source
   // file in parallel.

   // for Doc++ style
   Bool_t useDocxxStyle = (fHtml->GetDocStyle() == "Doc++");

   TString pattern(fCurrentClass->GetName());
   // take unscoped version
   Ssiz_t posLastScope = kNPOS;
   while ((posLastScope = pattern.Index("::")) != kNPOS)
      pattern.Remove(0, posLastScope + 2);
   pattern += "::";

   TString implFileName;
   if (fHtml->GetImplFileName(fCurrentClass, kTRUE, implFileName)) {
      LocateMethods(out, implFileName, kFALSE /*source info*/, useDocxxStyle,
                    kFALSE /*allowPureVirtual*/, pattern, ".cxx.html");
      Ssiz_t posGt = pattern.Index('>');
      if (posGt != kNPOS) {
         // template! Re-run with pattern '...<.*>::'
         Ssiz_t posLt = pattern.Index('<');
         if (posLt != kNPOS && posLt < posGt) {
            pattern.Replace(posLt + 1, posGt - posLt - 1, ".*");
            LocateMethods(out, implFileName, kFALSE /*source info*/, useDocxxStyle,
                    kFALSE /*allowPureVirtual*/, pattern, ".cxx.html");
         }
      }
   }
}

//______________________________________________________________________________
void TDocParser::LocateMethodsInHeaderInline(std::ostream& out)
{
   // Given fCurrentClass, look for methods in its header file,
   // and extract documentation to out.

   // for inline methods, always allow doc before func
   Bool_t useDocxxStyle = kTRUE;

   TString pattern(fCurrentClass->GetName());
   // take unscoped version
   Ssiz_t posLastScope = kNPOS;
   while ((posLastScope = pattern.Index("::")) != kNPOS)
      pattern.Remove(0, posLastScope + 1);
   pattern += "::";

   TString declFileName;
   if (fHtml->GetDeclFileName(fCurrentClass, kTRUE, declFileName)) {
      LocateMethods(out, declFileName, kTRUE /*source info*/, useDocxxStyle,
                    kFALSE /*allowPureVirtual*/, pattern, 0);
      Ssiz_t posGt = pattern.Index('>');
      if (posGt != kNPOS) {
         // template! Re-run with pattern '...<.*>::'
         Ssiz_t posLt = pattern.Index('<');
         if (posLt != kNPOS && posLt < posGt) {
            pattern.Replace(posLt + 1, posGt - posLt - 1, ".*");
            LocateMethods(out, declFileName, kTRUE /*source info*/, useDocxxStyle,
                    kFALSE /*allowPureVirtual*/, pattern, 0);
         }
      }
   }
}

//______________________________________________________________________________
void TDocParser::LocateMethodsInHeaderClassDecl(std::ostream& out)
{
   // Given fCurrentClass, look for methods in its header file's
   // class declaration block, and extract documentation to out,
   // while beautifying the header file in parallel.

   TString declFileName;
   if (fHtml->GetDeclFileName(fCurrentClass, kTRUE, declFileName))
      LocateMethods(out, declFileName, kTRUE/*source info*/, kTRUE /*useDocxxStyle*/,
                    kTRUE /*allowPureVirtual*/, 0, ".h.html");
}

//______________________________________________________________________________
Bool_t TDocParser::ProcessComment()
{
   // Parse the current line as a comment, handling directives and re-formatting
   // the comment: remove "/*", "*/", "//", similar characters surrounding lines,
   // etc.
   //
   // Return kFALSE if the line is not a comment.

   if (!fCommentAtBOL
      && !(fLineStripped[0] == '/'
         && (fLineStripped[1] == '/' || fLineStripped[1] == '*'))
      && !InContext(kComment) && !InContext(kDirective)) {
      fLineComment = "";
      return kFALSE;
   }

   //if (InContext(kDirective))
   //   return kTRUE; - NO! we might have a comment from a previous directive!

   // don't write out empty lines if the current directive is eating the line
   if (InContext(kDirective) && !fLineComment.Length())
      return kTRUE;

   TString commentLine(fLineComment.Strip());

   // remove all <span class="comment"> tags
   Bool_t mustDealWithCommentAtBOL = fCommentAtBOL; // whether we had a closing "*/"
   Ssiz_t posComment = kNPOS;
   if (!fCommentAtBOL)
      posComment = commentLine.Index("<span class=\"comment\">", 0, TString::kIgnoreCase);
   Ssiz_t posSpanEnd = commentLine.Index("</span>", posComment == kNPOS?0:posComment, TString::kIgnoreCase);
   while ((mustDealWithCommentAtBOL && posSpanEnd != kNPOS) || posComment != kNPOS) {
      Int_t spanLevel = 1;
      Ssiz_t posSpan = commentLine.Index("<span", posComment + 1, TString::kIgnoreCase);
      while (spanLevel > 1 || (posSpan != kNPOS && posSpan < posSpanEnd)) {
         // another span was opened, take the next </span>
         if (posSpan != kNPOS && posSpan < posSpanEnd) {
            ++spanLevel;
            posSpan = commentLine.Index("<span", posSpan + 1, TString::kIgnoreCase);
            // posSpanEnd doesn't change
            continue;
         } // else
         --spanLevel;
         // posSpan doesn't change
         posSpanEnd = commentLine.Index("</span>", posSpanEnd + 1, TString::kIgnoreCase);
      }
      if (posSpanEnd != kNPOS) {
          // only remove span if </span> if it exists (or we end up with unbalanced spans)
         commentLine.Remove(posSpanEnd, 7);
         if (posComment != kNPOS)
            commentLine.Remove(posComment, 22);
         else {
            mustDealWithCommentAtBOL = kFALSE;
            // now remove C comments
            posComment = 0;
         }
         posComment = commentLine.Index("<span class=\"comment\">", posComment, TString::kIgnoreCase);
      } else break;
   }
   if (posComment != kNPOS)
      commentLine.Remove(posComment, 22);

   // don't strip in C comments, do strip if opening:
   if (!InContext(kComment) || (InContext(kComment) & kCXXComment)
       || (fLineStripped[0] == '/' && fLineStripped[1] == '*'))
      Strip(commentLine);

   // look for start tag of class description
   if ((fClassDocState == kClassDoc_LookingNothingFound
      || fClassDocState == kClassDoc_LookingHaveSomething)
      && !fComment.Length()
      && fDocContext == kIgnore && commentLine.Contains(fClassDescrTag)) {
      fDocContext = kDocClass;
   }

   char start_or_end = 0;
   // remove leading /*, //
   if (commentLine.Length()>1 && commentLine[0] == '/'
       && (commentLine[1] == '/' || commentLine[1] == '*')) {
      start_or_end = commentLine[1];
      commentLine.Remove(0, 2);
   }
   // remove trailing */
   if (start_or_end != '/' && commentLine.Length()>1
       && commentLine[commentLine.Length() - 2] == '*'
       && commentLine[commentLine.Length() - 1] == '/') {
      start_or_end = commentLine[commentLine.Length() - 2];
      commentLine.Remove(commentLine.Length()-2);
   }

   // remove repeating characters from the end of the line
   if (start_or_end && commentLine.Length() > 3) {
      TString lineAllOneChar(commentLine.Strip());

      Ssiz_t len = lineAllOneChar.Length();
      if (len > 2) {
         Char_t c = lineAllOneChar[len - 1];
         if (c == lineAllOneChar[len - 2] && c == lineAllOneChar[len - 3]) {
            TString lineAllOneCharStripped = lineAllOneChar.Strip(TString::kTrailing, c);
            Strip(lineAllOneCharStripped);
            if (!lineAllOneCharStripped.Length()) {
               commentLine.Remove(0);

               // also a class doc signature: line consists of ////
               if ((fClassDocState == kClassDoc_LookingNothingFound
                  || fClassDocState == kClassDoc_LookingHaveSomething)
                  && !fComment.Length()
                   && fDocContext == kIgnore && start_or_end=='/') {
                  fDocContext = kDocClass;
               }
            }
         }
      }
   }

   // remove leading and trailing chars from e.g. // some doc //
   if (commentLine.Length() > 0 && start_or_end == commentLine[commentLine.Length() - 1])
      // we already removed it as part of // or / *; also remove the trailing
      commentLine = commentLine.Strip(TString::kTrailing, start_or_end);

   if (commentLine.Length() > 2 && Context() != kDirective)
      while (commentLine.Length() > 2
             && !IsWord(commentLine[0])
             && commentLine[0] == commentLine[commentLine.Length() - 1])
         commentLine = commentLine.Strip(TString::kBoth, commentLine[0]);

   // remove leading '/' if we had // or '*' if we had / *
   while (start_or_end && commentLine[0] == start_or_end)
      commentLine.Remove(0, 1);

   fComment += commentLine + "\n";

   return kTRUE;
}

//______________________________________________________________________________
void TDocParser::RemoveCommentContext(Bool_t cxxcomment)
{
   // remove the top-most comment context that matches cxxcomment,

   UInt_t lookFor = kComment;
   if (cxxcomment) lookFor |= kCXXComment;
   std::list<UInt_t>::iterator iComment = fParseContext.end();
   for (std::list<UInt_t>::iterator iContext = fParseContext.begin();
      iContext != fParseContext.end(); ++ iContext)
      if (*iContext == lookFor) iComment =iContext;
   if (iComment != fParseContext.end())
      fParseContext.erase(iComment);
}

//______________________________________________________________________________
Bool_t TDocParser::Strip(TString& str)
{
   // strips ' ', tabs, and newlines from both sides of str
   Bool_t changed = str[0] == ' ' || str[0] == '\t' || str[0] == '\n';
   changed |= str.Length()
      && (str[str.Length() - 1] == ' ' || str[str.Length() - 1] == '\t'
         || str[str.Length() - 1] == '\n');
   if (!changed) return kFALSE;
   Ssiz_t i = 0;
   while (str[i] == ' ' || str[i] == '\t' || str[i] == '\n')
      ++i;
   str.Remove(0,i);
   i = str.Length() - 1;
   while (i >= 0 && (str[i] == ' ' || str[i] == '\t' || str[i] == '\n'))
      --i;
   str.Remove(i + 1, str.Length());
   return kTRUE;
}

//______________________________________________________________________________
void TDocParser::WriteClassDoc(std::ostream& out, Bool_t first /*= kTRUE*/)
{
   // Write the class description depending (among others) on fClassDocState.

   if (fClassDocState == kClassDoc_LookingHaveSomething || fClassDocState == kClassDoc_LookingNothingFound) {
      TString& classDoc = first || !fLastClassDoc.Length() ? fFirstClassDoc : fLastClassDoc;
      static_cast<TClassDocOutput*>(fDocOutput)->WriteClassDescription(out, classDoc);
      fClassDocState = kClassDoc_Written;
   }

}

namespace {
   static void RemoveUnneededSpaces(TString& s) {
      // Remove spaces except between identifier characters.
      // Assumes s is stripped (does not start nor end with space).
      for (Ssiz_t i = 1; i < s.Length() - 1; ++i) {
         if (s[i] == ' ') {
            char p = s[i - 1];
            char n = s[i + 1];
            if (((isalnum(p) || p == '_') && (isalnum(n) || n == '_'))
                || (p == '>' && n == '>')) {
               // "id id" or "> >": keep space
            } else {
               while (isspace(s[i])) {
                  s.Remove(i, 1);
               }
            }
         }
      }
   }

   static void ParseParameters(TString& strippedParams, TList& paramArr) {
      // Extract a list of strings (the parameters without initializers) from
      // the signature.
      int nest = 0;
      bool init = false;
      bool quoted = false;
      Ssiz_t len = strippedParams.Length();
      TString arg;
      for (Ssiz_t i = 0; i < len; ++i) {
         switch (strippedParams[i]) {
         case '<': // fallthrough
         case '(': // fallthrough
         case '[': ++nest; break;
         case '>': // fallthrough
         case ')': // fallthrough
         case ']': --nest; break;
         case '=': init = true; break;
         case '\'': ++i; if (strippedParams[i] == '\\') ++i; ++i; continue;
         case '\\': ++i; continue; break;
         case '"': quoted = !quoted; break;
         case ',': {
            if (!quoted && !nest) {
               TString strippedArg(arg.Strip(TString::kBoth));
               paramArr.AddLast(new TObjString(strippedArg));
               init = false;
               arg.Remove(0);
               continue;
            }
         }
         }
         if (!init) {
            arg += strippedParams[i];
         }
      }
      TString strippedLastArg(arg.Strip(TString::kBoth));
      if (strippedLastArg.Length()) {
         paramArr.AddLast(new TObjString(strippedLastArg));
      }
   }

   void MatchOverloadSignatures(TCollection* candidates, TList* paramArr)
   {
      // Check type identity of candidate signatures. For each argument, check whether it
      // reduces the list of candidates to > 0 elements.
      TList suppressed;
      TIter iCandidate(candidates);
      int nparams = paramArr->GetSize();
      for (int iparam = 0; iparam < nparams && candidates->GetSize() > 1; ++iparam) {
         TString& srcArg = ((TObjString*)paramArr->At(iparam))->String();
         TString noParName(srcArg);
         while (noParName.Length()
                && (isalnum(noParName[noParName.Length() - 1]) || noParName[noParName.Length() - 1] == '_'))
            noParName.Remove(noParName.Length() - 1);
         noParName = noParName.Strip(TString::kTrailing);

         if (noParName.Length()) {
            RemoveUnneededSpaces(noParName);
         }
         RemoveUnneededSpaces(srcArg);
         // comparison:
         // 0: strcmp
         // 1: source's parameter has last identifier (parameter name?) removed
         // 2: candidate type name contained in source parameter
         for (int comparison = 0; comparison < 5; ++comparison) {
            if (comparison == 1 && noParName == srcArg)
               // there is no parameter name to ignore
               continue;
            suppressed.Clear();
            iCandidate.Reset();
            TDocMethodWrapper* method = 0;
            while ((method = (TDocMethodWrapper*) iCandidate())) {
               TMethodArg* methArg = (TMethodArg*) method->GetMethod()->GetListOfMethodArgs()->At(iparam);
               TString sMethArg = methArg->GetFullTypeName();
               RemoveUnneededSpaces(sMethArg);
               bool matches = false;
               switch (comparison) {
               case 0: matches = (srcArg == sMethArg); break;
               case 1: matches = (noParName == sMethArg); break;
               case 2: matches = srcArg.Contains(sMethArg) || sMethArg.Contains(srcArg); break;
               }
               if (!matches) {
                  suppressed.Add(method);
               }
            }
            if (suppressed.GetSize()
                && suppressed.GetSize() < candidates->GetSize()) {
               candidates->RemoveAll(&suppressed);
               break;
            }
            if (!suppressed.GetSize()) {
               // we have a match, no point in trying a looser matching
               break;
            }
         }
      }
      if (candidates->GetSize() > 1) {
         // use TDocMethodWrapper::kDocumented bit
         suppressed.Clear();
         iCandidate.Reset();
         TDocMethodWrapper* method = 0;
         while ((method = (TDocMethodWrapper*) iCandidate())) {
            if (method->TestBit(TDocMethodWrapper::kDocumented)) {
               suppressed.AddLast(method);
            }
         }
         if (suppressed.GetSize()
             && suppressed.GetSize() < candidates->GetSize()) {
            candidates->RemoveAll(&suppressed);
         }
      }
   }
}

//______________________________________________________________________________
void TDocParser::WriteMethod(std::ostream& out, TString& ret,
                             TString& name, TString& params, Bool_t isconst,
                             const char* filename, TString& anchor,
                             TString& codeOneLiner)
{
   // Write a method, forwarding to TClassDocOutput

   // if we haven't found the class description until now it's too late.
   if (fClassDocState < kClassDoc_Written)
      WriteClassDoc(out);

   TString strippedParams(params);
   if (strippedParams[0] == '(') {
      strippedParams.Remove(0, 1);
      strippedParams.Remove(strippedParams.Length() - 1);
      strippedParams = strippedParams.Strip(TString::kBoth);
   }

   TList paramArr;
   paramArr.SetOwner();
   ParseParameters(strippedParams, paramArr);
   int nparams = paramArr.GetSize();

   // Collect overload candidates
   TList candidates;
   for (int access = 0; access < 3; ++access) {
      TList* methList = fMethods[access].GetListForObject(name);
      if (!methList) continue;

      TIter nextMethod(methList);
      TDocMethodWrapper* method = 0;
      while ((method = (TDocMethodWrapper *) nextMethod())) {
         if (name == method->GetName()
             && isconst == ((method->GetMethod()->Property() & kIsConstMethod) > 0)
             && method->GetMethod()->GetListOfMethodArgs()->GetSize() == nparams) {
            candidates.Add(method);
         }
      }
   }

   if (nparams && candidates.GetSize() > 1) {
      MatchOverloadSignatures(&candidates, &paramArr);
   }

   TDocMethodWrapper* guessedMethod = 0;
   if (candidates.GetSize() == 1) {
      guessedMethod = (TDocMethodWrapper*) candidates.First();
      guessedMethod->SetBit(TDocMethodWrapper::kDocumented);
   }

   static_cast<TClassDocOutput*>(fDocOutput)->WriteMethod(out, ret, name, params, filename, anchor,
                                                           fComment, codeOneLiner, guessedMethod);

   DecrementMethodCount(name);
   ret.Remove(0);
   name.Remove(0);
   params.Remove(0);
   anchor.Remove(0);
   fComment.Remove(0);

   fDocContext = kIgnore;
}

//______________________________________________________________________________
void TDocParser::WriteSourceLine(std::ostream& out)
{
   // Write fLineSource to out.
   // Adjust relative paths first.

   fDocOutput->AdjustSourcePath(fLineSource);
   out << fLineSource << std::endl;

}
 TDocParser.cxx:1
 TDocParser.cxx:2
 TDocParser.cxx:3
 TDocParser.cxx:4
 TDocParser.cxx:5
 TDocParser.cxx:6
 TDocParser.cxx:7
 TDocParser.cxx:8
 TDocParser.cxx:9
 TDocParser.cxx:10
 TDocParser.cxx:11
 TDocParser.cxx:12
 TDocParser.cxx:13
 TDocParser.cxx:14
 TDocParser.cxx:15
 TDocParser.cxx:16
 TDocParser.cxx:17
 TDocParser.cxx:18
 TDocParser.cxx:19
 TDocParser.cxx:20
 TDocParser.cxx:21
 TDocParser.cxx:22
 TDocParser.cxx:23
 TDocParser.cxx:24
 TDocParser.cxx:25
 TDocParser.cxx:26
 TDocParser.cxx:27
 TDocParser.cxx:28
 TDocParser.cxx:29
 TDocParser.cxx:30
 TDocParser.cxx:31
 TDocParser.cxx:32
 TDocParser.cxx:33
 TDocParser.cxx:34
 TDocParser.cxx:35
 TDocParser.cxx:36
 TDocParser.cxx:37
 TDocParser.cxx:38
 TDocParser.cxx:39
 TDocParser.cxx:40
 TDocParser.cxx:41
 TDocParser.cxx:42
 TDocParser.cxx:43
 TDocParser.cxx:44
 TDocParser.cxx:45
 TDocParser.cxx:46
 TDocParser.cxx:47
 TDocParser.cxx:48
 TDocParser.cxx:49
 TDocParser.cxx:50
 TDocParser.cxx:51
 TDocParser.cxx:52
 TDocParser.cxx:53
 TDocParser.cxx:54
 TDocParser.cxx:55
 TDocParser.cxx:56
 TDocParser.cxx:57
 TDocParser.cxx:58
 TDocParser.cxx:59
 TDocParser.cxx:60
 TDocParser.cxx:61
 TDocParser.cxx:62
 TDocParser.cxx:63
 TDocParser.cxx:64
 TDocParser.cxx:65
 TDocParser.cxx:66
 TDocParser.cxx:67
 TDocParser.cxx:68
 TDocParser.cxx:69
 TDocParser.cxx:70
 TDocParser.cxx:71
 TDocParser.cxx:72
 TDocParser.cxx:73
 TDocParser.cxx:74
 TDocParser.cxx:75
 TDocParser.cxx:76
 TDocParser.cxx:77
 TDocParser.cxx:78
 TDocParser.cxx:79
 TDocParser.cxx:80
 TDocParser.cxx:81
 TDocParser.cxx:82
 TDocParser.cxx:83
 TDocParser.cxx:84
 TDocParser.cxx:85
 TDocParser.cxx:86
 TDocParser.cxx:87
 TDocParser.cxx:88
 TDocParser.cxx:89
 TDocParser.cxx:90
 TDocParser.cxx:91
 TDocParser.cxx:92
 TDocParser.cxx:93
 TDocParser.cxx:94
 TDocParser.cxx:95
 TDocParser.cxx:96
 TDocParser.cxx:97
 TDocParser.cxx:98
 TDocParser.cxx:99
 TDocParser.cxx:100
 TDocParser.cxx:101
 TDocParser.cxx:102
 TDocParser.cxx:103
 TDocParser.cxx:104
 TDocParser.cxx:105
 TDocParser.cxx:106
 TDocParser.cxx:107
 TDocParser.cxx:108
 TDocParser.cxx:109
 TDocParser.cxx:110
 TDocParser.cxx:111
 TDocParser.cxx:112
 TDocParser.cxx:113
 TDocParser.cxx:114
 TDocParser.cxx:115
 TDocParser.cxx:116
 TDocParser.cxx:117
 TDocParser.cxx:118
 TDocParser.cxx:119
 TDocParser.cxx:120
 TDocParser.cxx:121
 TDocParser.cxx:122
 TDocParser.cxx:123
 TDocParser.cxx:124
 TDocParser.cxx:125
 TDocParser.cxx:126
 TDocParser.cxx:127
 TDocParser.cxx:128
 TDocParser.cxx:129
 TDocParser.cxx:130
 TDocParser.cxx:131
 TDocParser.cxx:132
 TDocParser.cxx:133
 TDocParser.cxx:134
 TDocParser.cxx:135
 TDocParser.cxx:136
 TDocParser.cxx:137
 TDocParser.cxx:138
 TDocParser.cxx:139
 TDocParser.cxx:140
 TDocParser.cxx:141
 TDocParser.cxx:142
 TDocParser.cxx:143
 TDocParser.cxx:144
 TDocParser.cxx:145
 TDocParser.cxx:146
 TDocParser.cxx:147
 TDocParser.cxx:148
 TDocParser.cxx:149
 TDocParser.cxx:150
 TDocParser.cxx:151
 TDocParser.cxx:152
 TDocParser.cxx:153
 TDocParser.cxx:154
 TDocParser.cxx:155
 TDocParser.cxx:156
 TDocParser.cxx:157
 TDocParser.cxx:158
 TDocParser.cxx:159
 TDocParser.cxx:160
 TDocParser.cxx:161
 TDocParser.cxx:162
 TDocParser.cxx:163
 TDocParser.cxx:164
 TDocParser.cxx:165
 TDocParser.cxx:166
 TDocParser.cxx:167
 TDocParser.cxx:168
 TDocParser.cxx:169
 TDocParser.cxx:170
 TDocParser.cxx:171
 TDocParser.cxx:172
 TDocParser.cxx:173
 TDocParser.cxx:174
 TDocParser.cxx:175
 TDocParser.cxx:176
 TDocParser.cxx:177
 TDocParser.cxx:178
 TDocParser.cxx:179
 TDocParser.cxx:180
 TDocParser.cxx:181
 TDocParser.cxx:182
 TDocParser.cxx:183
 TDocParser.cxx:184
 TDocParser.cxx:185
 TDocParser.cxx:186
 TDocParser.cxx:187
 TDocParser.cxx:188
 TDocParser.cxx:189
 TDocParser.cxx:190
 TDocParser.cxx:191
 TDocParser.cxx:192
 TDocParser.cxx:193
 TDocParser.cxx:194
 TDocParser.cxx:195
 TDocParser.cxx:196
 TDocParser.cxx:197
 TDocParser.cxx:198
 TDocParser.cxx:199
 TDocParser.cxx:200
 TDocParser.cxx:201
 TDocParser.cxx:202
 TDocParser.cxx:203
 TDocParser.cxx:204
 TDocParser.cxx:205
 TDocParser.cxx:206
 TDocParser.cxx:207
 TDocParser.cxx:208
 TDocParser.cxx:209
 TDocParser.cxx:210
 TDocParser.cxx:211
 TDocParser.cxx:212
 TDocParser.cxx:213
 TDocParser.cxx:214
 TDocParser.cxx:215
 TDocParser.cxx:216
 TDocParser.cxx:217
 TDocParser.cxx:218
 TDocParser.cxx:219
 TDocParser.cxx:220
 TDocParser.cxx:221
 TDocParser.cxx:222
 TDocParser.cxx:223
 TDocParser.cxx:224
 TDocParser.cxx:225
 TDocParser.cxx:226
 TDocParser.cxx:227
 TDocParser.cxx:228
 TDocParser.cxx:229
 TDocParser.cxx:230
 TDocParser.cxx:231
 TDocParser.cxx:232
 TDocParser.cxx:233
 TDocParser.cxx:234
 TDocParser.cxx:235
 TDocParser.cxx:236
 TDocParser.cxx:237
 TDocParser.cxx:238
 TDocParser.cxx:239
 TDocParser.cxx:240
 TDocParser.cxx:241
 TDocParser.cxx:242
 TDocParser.cxx:243
 TDocParser.cxx:244
 TDocParser.cxx:245
 TDocParser.cxx:246
 TDocParser.cxx:247
 TDocParser.cxx:248
 TDocParser.cxx:249
 TDocParser.cxx:250
 TDocParser.cxx:251
 TDocParser.cxx:252
 TDocParser.cxx:253
 TDocParser.cxx:254
 TDocParser.cxx:255
 TDocParser.cxx:256
 TDocParser.cxx:257
 TDocParser.cxx:258
 TDocParser.cxx:259
 TDocParser.cxx:260
 TDocParser.cxx:261
 TDocParser.cxx:262
 TDocParser.cxx:263
 TDocParser.cxx:264
 TDocParser.cxx:265
 TDocParser.cxx:266
 TDocParser.cxx:267
 TDocParser.cxx:268
 TDocParser.cxx:269
 TDocParser.cxx:270
 TDocParser.cxx:271
 TDocParser.cxx:272
 TDocParser.cxx:273
 TDocParser.cxx:274
 TDocParser.cxx:275
 TDocParser.cxx:276
 TDocParser.cxx:277
 TDocParser.cxx:278
 TDocParser.cxx:279
 TDocParser.cxx:280
 TDocParser.cxx:281
 TDocParser.cxx:282
 TDocParser.cxx:283
 TDocParser.cxx:284
 TDocParser.cxx:285
 TDocParser.cxx:286
 TDocParser.cxx:287
 TDocParser.cxx:288
 TDocParser.cxx:289
 TDocParser.cxx:290
 TDocParser.cxx:291
 TDocParser.cxx:292
 TDocParser.cxx:293
 TDocParser.cxx:294
 TDocParser.cxx:295
 TDocParser.cxx:296
 TDocParser.cxx:297
 TDocParser.cxx:298
 TDocParser.cxx:299
 TDocParser.cxx:300
 TDocParser.cxx:301
 TDocParser.cxx:302
 TDocParser.cxx:303
 TDocParser.cxx:304
 TDocParser.cxx:305
 TDocParser.cxx:306
 TDocParser.cxx:307
 TDocParser.cxx:308
 TDocParser.cxx:309
 TDocParser.cxx:310
 TDocParser.cxx:311
 TDocParser.cxx:312
 TDocParser.cxx:313
 TDocParser.cxx:314
 TDocParser.cxx:315
 TDocParser.cxx:316
 TDocParser.cxx:317
 TDocParser.cxx:318
 TDocParser.cxx:319
 TDocParser.cxx:320
 TDocParser.cxx:321
 TDocParser.cxx:322
 TDocParser.cxx:323
 TDocParser.cxx:324
 TDocParser.cxx:325
 TDocParser.cxx:326
 TDocParser.cxx:327
 TDocParser.cxx:328
 TDocParser.cxx:329
 TDocParser.cxx:330
 TDocParser.cxx:331
 TDocParser.cxx:332
 TDocParser.cxx:333
 TDocParser.cxx:334
 TDocParser.cxx:335
 TDocParser.cxx:336
 TDocParser.cxx:337
 TDocParser.cxx:338
 TDocParser.cxx:339
 TDocParser.cxx:340
 TDocParser.cxx:341
 TDocParser.cxx:342
 TDocParser.cxx:343
 TDocParser.cxx:344
 TDocParser.cxx:345
 TDocParser.cxx:346
 TDocParser.cxx:347
 TDocParser.cxx:348
 TDocParser.cxx:349
 TDocParser.cxx:350
 TDocParser.cxx:351
 TDocParser.cxx:352
 TDocParser.cxx:353
 TDocParser.cxx:354
 TDocParser.cxx:355
 TDocParser.cxx:356
 TDocParser.cxx:357
 TDocParser.cxx:358
 TDocParser.cxx:359
 TDocParser.cxx:360
 TDocParser.cxx:361
 TDocParser.cxx:362
 TDocParser.cxx:363
 TDocParser.cxx:364
 TDocParser.cxx:365
 TDocParser.cxx:366
 TDocParser.cxx:367
 TDocParser.cxx:368
 TDocParser.cxx:369
 TDocParser.cxx:370
 TDocParser.cxx:371
 TDocParser.cxx:372
 TDocParser.cxx:373
 TDocParser.cxx:374
 TDocParser.cxx:375
 TDocParser.cxx:376
 TDocParser.cxx:377
 TDocParser.cxx:378
 TDocParser.cxx:379
 TDocParser.cxx:380
 TDocParser.cxx:381
 TDocParser.cxx:382
 TDocParser.cxx:383
 TDocParser.cxx:384
 TDocParser.cxx:385
 TDocParser.cxx:386
 TDocParser.cxx:387
 TDocParser.cxx:388
 TDocParser.cxx:389
 TDocParser.cxx:390
 TDocParser.cxx:391
 TDocParser.cxx:392
 TDocParser.cxx:393
 TDocParser.cxx:394
 TDocParser.cxx:395
 TDocParser.cxx:396
 TDocParser.cxx:397
 TDocParser.cxx:398
 TDocParser.cxx:399
 TDocParser.cxx:400
 TDocParser.cxx:401
 TDocParser.cxx:402
 TDocParser.cxx:403
 TDocParser.cxx:404
 TDocParser.cxx:405
 TDocParser.cxx:406
 TDocParser.cxx:407
 TDocParser.cxx:408
 TDocParser.cxx:409
 TDocParser.cxx:410
 TDocParser.cxx:411
 TDocParser.cxx:412
 TDocParser.cxx:413
 TDocParser.cxx:414
 TDocParser.cxx:415
 TDocParser.cxx:416
 TDocParser.cxx:417
 TDocParser.cxx:418
 TDocParser.cxx:419
 TDocParser.cxx:420
 TDocParser.cxx:421
 TDocParser.cxx:422
 TDocParser.cxx:423
 TDocParser.cxx:424
 TDocParser.cxx:425
 TDocParser.cxx:426
 TDocParser.cxx:427
 TDocParser.cxx:428
 TDocParser.cxx:429
 TDocParser.cxx:430
 TDocParser.cxx:431
 TDocParser.cxx:432
 TDocParser.cxx:433
 TDocParser.cxx:434
 TDocParser.cxx:435
 TDocParser.cxx:436
 TDocParser.cxx:437
 TDocParser.cxx:438
 TDocParser.cxx:439
 TDocParser.cxx:440
 TDocParser.cxx:441
 TDocParser.cxx:442
 TDocParser.cxx:443
 TDocParser.cxx:444
 TDocParser.cxx:445
 TDocParser.cxx:446
 TDocParser.cxx:447
 TDocParser.cxx:448
 TDocParser.cxx:449
 TDocParser.cxx:450
 TDocParser.cxx:451
 TDocParser.cxx:452
 TDocParser.cxx:453
 TDocParser.cxx:454
 TDocParser.cxx:455
 TDocParser.cxx:456
 TDocParser.cxx:457
 TDocParser.cxx:458
 TDocParser.cxx:459
 TDocParser.cxx:460
 TDocParser.cxx:461
 TDocParser.cxx:462
 TDocParser.cxx:463
 TDocParser.cxx:464
 TDocParser.cxx:465
 TDocParser.cxx:466
 TDocParser.cxx:467
 TDocParser.cxx:468
 TDocParser.cxx:469
 TDocParser.cxx:470
 TDocParser.cxx:471
 TDocParser.cxx:472
 TDocParser.cxx:473
 TDocParser.cxx:474
 TDocParser.cxx:475
 TDocParser.cxx:476
 TDocParser.cxx:477
 TDocParser.cxx:478
 TDocParser.cxx:479
 TDocParser.cxx:480
 TDocParser.cxx:481
 TDocParser.cxx:482
 TDocParser.cxx:483
 TDocParser.cxx:484
 TDocParser.cxx:485
 TDocParser.cxx:486
 TDocParser.cxx:487
 TDocParser.cxx:488
 TDocParser.cxx:489
 TDocParser.cxx:490
 TDocParser.cxx:491
 TDocParser.cxx:492
 TDocParser.cxx:493
 TDocParser.cxx:494
 TDocParser.cxx:495
 TDocParser.cxx:496
 TDocParser.cxx:497
 TDocParser.cxx:498
 TDocParser.cxx:499
 TDocParser.cxx:500
 TDocParser.cxx:501
 TDocParser.cxx:502
 TDocParser.cxx:503
 TDocParser.cxx:504
 TDocParser.cxx:505
 TDocParser.cxx:506
 TDocParser.cxx:507
 TDocParser.cxx:508
 TDocParser.cxx:509
 TDocParser.cxx:510
 TDocParser.cxx:511
 TDocParser.cxx:512
 TDocParser.cxx:513
 TDocParser.cxx:514
 TDocParser.cxx:515
 TDocParser.cxx:516
 TDocParser.cxx:517
 TDocParser.cxx:518
 TDocParser.cxx:519
 TDocParser.cxx:520
 TDocParser.cxx:521
 TDocParser.cxx:522
 TDocParser.cxx:523
 TDocParser.cxx:524
 TDocParser.cxx:525
 TDocParser.cxx:526
 TDocParser.cxx:527
 TDocParser.cxx:528
 TDocParser.cxx:529
 TDocParser.cxx:530
 TDocParser.cxx:531
 TDocParser.cxx:532
 TDocParser.cxx:533
 TDocParser.cxx:534
 TDocParser.cxx:535
 TDocParser.cxx:536
 TDocParser.cxx:537
 TDocParser.cxx:538
 TDocParser.cxx:539
 TDocParser.cxx:540
 TDocParser.cxx:541
 TDocParser.cxx:542
 TDocParser.cxx:543
 TDocParser.cxx:544
 TDocParser.cxx:545
 TDocParser.cxx:546
 TDocParser.cxx:547
 TDocParser.cxx:548
 TDocParser.cxx:549
 TDocParser.cxx:550
 TDocParser.cxx:551
 TDocParser.cxx:552
 TDocParser.cxx:553
 TDocParser.cxx:554
 TDocParser.cxx:555
 TDocParser.cxx:556
 TDocParser.cxx:557
 TDocParser.cxx:558
 TDocParser.cxx:559
 TDocParser.cxx:560
 TDocParser.cxx:561
 TDocParser.cxx:562
 TDocParser.cxx:563
 TDocParser.cxx:564
 TDocParser.cxx:565
 TDocParser.cxx:566
 TDocParser.cxx:567
 TDocParser.cxx:568
 TDocParser.cxx:569
 TDocParser.cxx:570
 TDocParser.cxx:571
 TDocParser.cxx:572
 TDocParser.cxx:573
 TDocParser.cxx:574
 TDocParser.cxx:575
 TDocParser.cxx:576
 TDocParser.cxx:577
 TDocParser.cxx:578
 TDocParser.cxx:579
 TDocParser.cxx:580
 TDocParser.cxx:581
 TDocParser.cxx:582
 TDocParser.cxx:583
 TDocParser.cxx:584
 TDocParser.cxx:585
 TDocParser.cxx:586
 TDocParser.cxx:587
 TDocParser.cxx:588
 TDocParser.cxx:589
 TDocParser.cxx:590
 TDocParser.cxx:591
 TDocParser.cxx:592
 TDocParser.cxx:593
 TDocParser.cxx:594
 TDocParser.cxx:595
 TDocParser.cxx:596
 TDocParser.cxx:597
 TDocParser.cxx:598
 TDocParser.cxx:599
 TDocParser.cxx:600
 TDocParser.cxx:601
 TDocParser.cxx:602
 TDocParser.cxx:603
 TDocParser.cxx:604
 TDocParser.cxx:605
 TDocParser.cxx:606
 TDocParser.cxx:607
 TDocParser.cxx:608
 TDocParser.cxx:609
 TDocParser.cxx:610
 TDocParser.cxx:611
 TDocParser.cxx:612
 TDocParser.cxx:613
 TDocParser.cxx:614
 TDocParser.cxx:615
 TDocParser.cxx:616
 TDocParser.cxx:617
 TDocParser.cxx:618
 TDocParser.cxx:619
 TDocParser.cxx:620
 TDocParser.cxx:621
 TDocParser.cxx:622
 TDocParser.cxx:623
 TDocParser.cxx:624
 TDocParser.cxx:625
 TDocParser.cxx:626
 TDocParser.cxx:627
 TDocParser.cxx:628
 TDocParser.cxx:629
 TDocParser.cxx:630
 TDocParser.cxx:631
 TDocParser.cxx:632
 TDocParser.cxx:633
 TDocParser.cxx:634
 TDocParser.cxx:635
 TDocParser.cxx:636
 TDocParser.cxx:637
 TDocParser.cxx:638
 TDocParser.cxx:639
 TDocParser.cxx:640
 TDocParser.cxx:641
 TDocParser.cxx:642
 TDocParser.cxx:643
 TDocParser.cxx:644
 TDocParser.cxx:645
 TDocParser.cxx:646
 TDocParser.cxx:647
 TDocParser.cxx:648
 TDocParser.cxx:649
 TDocParser.cxx:650
 TDocParser.cxx:651
 TDocParser.cxx:652
 TDocParser.cxx:653
 TDocParser.cxx:654
 TDocParser.cxx:655
 TDocParser.cxx:656
 TDocParser.cxx:657
 TDocParser.cxx:658
 TDocParser.cxx:659
 TDocParser.cxx:660
 TDocParser.cxx:661
 TDocParser.cxx:662
 TDocParser.cxx:663
 TDocParser.cxx:664
 TDocParser.cxx:665
 TDocParser.cxx:666
 TDocParser.cxx:667
 TDocParser.cxx:668
 TDocParser.cxx:669
 TDocParser.cxx:670
 TDocParser.cxx:671
 TDocParser.cxx:672
 TDocParser.cxx:673
 TDocParser.cxx:674
 TDocParser.cxx:675
 TDocParser.cxx:676
 TDocParser.cxx:677
 TDocParser.cxx:678
 TDocParser.cxx:679
 TDocParser.cxx:680
 TDocParser.cxx:681
 TDocParser.cxx:682
 TDocParser.cxx:683
 TDocParser.cxx:684
 TDocParser.cxx:685
 TDocParser.cxx:686
 TDocParser.cxx:687
 TDocParser.cxx:688
 TDocParser.cxx:689
 TDocParser.cxx:690
 TDocParser.cxx:691
 TDocParser.cxx:692
 TDocParser.cxx:693
 TDocParser.cxx:694
 TDocParser.cxx:695
 TDocParser.cxx:696
 TDocParser.cxx:697
 TDocParser.cxx:698
 TDocParser.cxx:699
 TDocParser.cxx:700
 TDocParser.cxx:701
 TDocParser.cxx:702
 TDocParser.cxx:703
 TDocParser.cxx:704
 TDocParser.cxx:705
 TDocParser.cxx:706
 TDocParser.cxx:707
 TDocParser.cxx:708
 TDocParser.cxx:709
 TDocParser.cxx:710
 TDocParser.cxx:711
 TDocParser.cxx:712
 TDocParser.cxx:713
 TDocParser.cxx:714
 TDocParser.cxx:715
 TDocParser.cxx:716
 TDocParser.cxx:717
 TDocParser.cxx:718
 TDocParser.cxx:719
 TDocParser.cxx:720
 TDocParser.cxx:721
 TDocParser.cxx:722
 TDocParser.cxx:723
 TDocParser.cxx:724
 TDocParser.cxx:725
 TDocParser.cxx:726
 TDocParser.cxx:727
 TDocParser.cxx:728
 TDocParser.cxx:729
 TDocParser.cxx:730
 TDocParser.cxx:731
 TDocParser.cxx:732
 TDocParser.cxx:733
 TDocParser.cxx:734
 TDocParser.cxx:735
 TDocParser.cxx:736
 TDocParser.cxx:737
 TDocParser.cxx:738
 TDocParser.cxx:739
 TDocParser.cxx:740
 TDocParser.cxx:741
 TDocParser.cxx:742
 TDocParser.cxx:743
 TDocParser.cxx:744
 TDocParser.cxx:745
 TDocParser.cxx:746
 TDocParser.cxx:747
 TDocParser.cxx:748
 TDocParser.cxx:749
 TDocParser.cxx:750
 TDocParser.cxx:751
 TDocParser.cxx:752
 TDocParser.cxx:753
 TDocParser.cxx:754
 TDocParser.cxx:755
 TDocParser.cxx:756
 TDocParser.cxx:757
 TDocParser.cxx:758
 TDocParser.cxx:759
 TDocParser.cxx:760
 TDocParser.cxx:761
 TDocParser.cxx:762
 TDocParser.cxx:763
 TDocParser.cxx:764
 TDocParser.cxx:765
 TDocParser.cxx:766
 TDocParser.cxx:767
 TDocParser.cxx:768
 TDocParser.cxx:769
 TDocParser.cxx:770
 TDocParser.cxx:771
 TDocParser.cxx:772
 TDocParser.cxx:773
 TDocParser.cxx:774
 TDocParser.cxx:775
 TDocParser.cxx:776
 TDocParser.cxx:777
 TDocParser.cxx:778
 TDocParser.cxx:779
 TDocParser.cxx:780
 TDocParser.cxx:781
 TDocParser.cxx:782
 TDocParser.cxx:783
 TDocParser.cxx:784
 TDocParser.cxx:785
 TDocParser.cxx:786
 TDocParser.cxx:787
 TDocParser.cxx:788
 TDocParser.cxx:789
 TDocParser.cxx:790
 TDocParser.cxx:791
 TDocParser.cxx:792
 TDocParser.cxx:793
 TDocParser.cxx:794
 TDocParser.cxx:795
 TDocParser.cxx:796
 TDocParser.cxx:797
 TDocParser.cxx:798
 TDocParser.cxx:799
 TDocParser.cxx:800
 TDocParser.cxx:801
 TDocParser.cxx:802
 TDocParser.cxx:803
 TDocParser.cxx:804
 TDocParser.cxx:805
 TDocParser.cxx:806
 TDocParser.cxx:807
 TDocParser.cxx:808
 TDocParser.cxx:809
 TDocParser.cxx:810
 TDocParser.cxx:811
 TDocParser.cxx:812
 TDocParser.cxx:813
 TDocParser.cxx:814
 TDocParser.cxx:815
 TDocParser.cxx:816
 TDocParser.cxx:817
 TDocParser.cxx:818
 TDocParser.cxx:819
 TDocParser.cxx:820
 TDocParser.cxx:821
 TDocParser.cxx:822
 TDocParser.cxx:823
 TDocParser.cxx:824
 TDocParser.cxx:825
 TDocParser.cxx:826
 TDocParser.cxx:827
 TDocParser.cxx:828
 TDocParser.cxx:829
 TDocParser.cxx:830
 TDocParser.cxx:831
 TDocParser.cxx:832
 TDocParser.cxx:833
 TDocParser.cxx:834
 TDocParser.cxx:835
 TDocParser.cxx:836
 TDocParser.cxx:837
 TDocParser.cxx:838
 TDocParser.cxx:839
 TDocParser.cxx:840
 TDocParser.cxx:841
 TDocParser.cxx:842
 TDocParser.cxx:843
 TDocParser.cxx:844
 TDocParser.cxx:845
 TDocParser.cxx:846
 TDocParser.cxx:847
 TDocParser.cxx:848
 TDocParser.cxx:849
 TDocParser.cxx:850
 TDocParser.cxx:851
 TDocParser.cxx:852
 TDocParser.cxx:853
 TDocParser.cxx:854
 TDocParser.cxx:855
 TDocParser.cxx:856
 TDocParser.cxx:857
 TDocParser.cxx:858
 TDocParser.cxx:859
 TDocParser.cxx:860
 TDocParser.cxx:861
 TDocParser.cxx:862
 TDocParser.cxx:863
 TDocParser.cxx:864
 TDocParser.cxx:865
 TDocParser.cxx:866
 TDocParser.cxx:867
 TDocParser.cxx:868
 TDocParser.cxx:869
 TDocParser.cxx:870
 TDocParser.cxx:871
 TDocParser.cxx:872
 TDocParser.cxx:873
 TDocParser.cxx:874
 TDocParser.cxx:875
 TDocParser.cxx:876
 TDocParser.cxx:877
 TDocParser.cxx:878
 TDocParser.cxx:879
 TDocParser.cxx:880
 TDocParser.cxx:881
 TDocParser.cxx:882
 TDocParser.cxx:883
 TDocParser.cxx:884
 TDocParser.cxx:885
 TDocParser.cxx:886
 TDocParser.cxx:887
 TDocParser.cxx:888
 TDocParser.cxx:889
 TDocParser.cxx:890
 TDocParser.cxx:891
 TDocParser.cxx:892
 TDocParser.cxx:893
 TDocParser.cxx:894
 TDocParser.cxx:895
 TDocParser.cxx:896
 TDocParser.cxx:897
 TDocParser.cxx:898
 TDocParser.cxx:899
 TDocParser.cxx:900
 TDocParser.cxx:901
 TDocParser.cxx:902
 TDocParser.cxx:903
 TDocParser.cxx:904
 TDocParser.cxx:905
 TDocParser.cxx:906
 TDocParser.cxx:907
 TDocParser.cxx:908
 TDocParser.cxx:909
 TDocParser.cxx:910
 TDocParser.cxx:911
 TDocParser.cxx:912
 TDocParser.cxx:913
 TDocParser.cxx:914
 TDocParser.cxx:915
 TDocParser.cxx:916
 TDocParser.cxx:917
 TDocParser.cxx:918
 TDocParser.cxx:919
 TDocParser.cxx:920
 TDocParser.cxx:921
 TDocParser.cxx:922
 TDocParser.cxx:923
 TDocParser.cxx:924
 TDocParser.cxx:925
 TDocParser.cxx:926
 TDocParser.cxx:927
 TDocParser.cxx:928
 TDocParser.cxx:929
 TDocParser.cxx:930
 TDocParser.cxx:931
 TDocParser.cxx:932
 TDocParser.cxx:933
 TDocParser.cxx:934
 TDocParser.cxx:935
 TDocParser.cxx:936
 TDocParser.cxx:937
 TDocParser.cxx:938
 TDocParser.cxx:939
 TDocParser.cxx:940
 TDocParser.cxx:941
 TDocParser.cxx:942
 TDocParser.cxx:943
 TDocParser.cxx:944
 TDocParser.cxx:945
 TDocParser.cxx:946
 TDocParser.cxx:947
 TDocParser.cxx:948
 TDocParser.cxx:949
 TDocParser.cxx:950
 TDocParser.cxx:951
 TDocParser.cxx:952
 TDocParser.cxx:953
 TDocParser.cxx:954
 TDocParser.cxx:955
 TDocParser.cxx:956
 TDocParser.cxx:957
 TDocParser.cxx:958
 TDocParser.cxx:959
 TDocParser.cxx:960
 TDocParser.cxx:961
 TDocParser.cxx:962
 TDocParser.cxx:963
 TDocParser.cxx:964
 TDocParser.cxx:965
 TDocParser.cxx:966
 TDocParser.cxx:967
 TDocParser.cxx:968
 TDocParser.cxx:969
 TDocParser.cxx:970
 TDocParser.cxx:971
 TDocParser.cxx:972
 TDocParser.cxx:973
 TDocParser.cxx:974
 TDocParser.cxx:975
 TDocParser.cxx:976
 TDocParser.cxx:977
 TDocParser.cxx:978
 TDocParser.cxx:979
 TDocParser.cxx:980
 TDocParser.cxx:981
 TDocParser.cxx:982
 TDocParser.cxx:983
 TDocParser.cxx:984
 TDocParser.cxx:985
 TDocParser.cxx:986
 TDocParser.cxx:987
 TDocParser.cxx:988
 TDocParser.cxx:989
 TDocParser.cxx:990
 TDocParser.cxx:991
 TDocParser.cxx:992
 TDocParser.cxx:993
 TDocParser.cxx:994
 TDocParser.cxx:995
 TDocParser.cxx:996
 TDocParser.cxx:997
 TDocParser.cxx:998
 TDocParser.cxx:999
 TDocParser.cxx:1000
 TDocParser.cxx:1001
 TDocParser.cxx:1002
 TDocParser.cxx:1003
 TDocParser.cxx:1004
 TDocParser.cxx:1005
 TDocParser.cxx:1006
 TDocParser.cxx:1007
 TDocParser.cxx:1008
 TDocParser.cxx:1009
 TDocParser.cxx:1010
 TDocParser.cxx:1011
 TDocParser.cxx:1012
 TDocParser.cxx:1013
 TDocParser.cxx:1014
 TDocParser.cxx:1015
 TDocParser.cxx:1016
 TDocParser.cxx:1017
 TDocParser.cxx:1018
 TDocParser.cxx:1019
 TDocParser.cxx:1020
 TDocParser.cxx:1021
 TDocParser.cxx:1022
 TDocParser.cxx:1023
 TDocParser.cxx:1024
 TDocParser.cxx:1025
 TDocParser.cxx:1026
 TDocParser.cxx:1027
 TDocParser.cxx:1028
 TDocParser.cxx:1029
 TDocParser.cxx:1030
 TDocParser.cxx:1031
 TDocParser.cxx:1032
 TDocParser.cxx:1033
 TDocParser.cxx:1034
 TDocParser.cxx:1035
 TDocParser.cxx:1036
 TDocParser.cxx:1037
 TDocParser.cxx:1038
 TDocParser.cxx:1039
 TDocParser.cxx:1040
 TDocParser.cxx:1041
 TDocParser.cxx:1042
 TDocParser.cxx:1043
 TDocParser.cxx:1044
 TDocParser.cxx:1045
 TDocParser.cxx:1046
 TDocParser.cxx:1047
 TDocParser.cxx:1048
 TDocParser.cxx:1049
 TDocParser.cxx:1050
 TDocParser.cxx:1051
 TDocParser.cxx:1052
 TDocParser.cxx:1053
 TDocParser.cxx:1054
 TDocParser.cxx:1055
 TDocParser.cxx:1056
 TDocParser.cxx:1057
 TDocParser.cxx:1058
 TDocParser.cxx:1059
 TDocParser.cxx:1060
 TDocParser.cxx:1061
 TDocParser.cxx:1062
 TDocParser.cxx:1063
 TDocParser.cxx:1064
 TDocParser.cxx:1065
 TDocParser.cxx:1066
 TDocParser.cxx:1067
 TDocParser.cxx:1068
 TDocParser.cxx:1069
 TDocParser.cxx:1070
 TDocParser.cxx:1071
 TDocParser.cxx:1072
 TDocParser.cxx:1073
 TDocParser.cxx:1074
 TDocParser.cxx:1075
 TDocParser.cxx:1076
 TDocParser.cxx:1077
 TDocParser.cxx:1078
 TDocParser.cxx:1079
 TDocParser.cxx:1080
 TDocParser.cxx:1081
 TDocParser.cxx:1082
 TDocParser.cxx:1083
 TDocParser.cxx:1084
 TDocParser.cxx:1085
 TDocParser.cxx:1086
 TDocParser.cxx:1087
 TDocParser.cxx:1088
 TDocParser.cxx:1089
 TDocParser.cxx:1090
 TDocParser.cxx:1091
 TDocParser.cxx:1092
 TDocParser.cxx:1093
 TDocParser.cxx:1094
 TDocParser.cxx:1095
 TDocParser.cxx:1096
 TDocParser.cxx:1097
 TDocParser.cxx:1098
 TDocParser.cxx:1099
 TDocParser.cxx:1100
 TDocParser.cxx:1101
 TDocParser.cxx:1102
 TDocParser.cxx:1103
 TDocParser.cxx:1104
 TDocParser.cxx:1105
 TDocParser.cxx:1106
 TDocParser.cxx:1107
 TDocParser.cxx:1108
 TDocParser.cxx:1109
 TDocParser.cxx:1110
 TDocParser.cxx:1111
 TDocParser.cxx:1112
 TDocParser.cxx:1113
 TDocParser.cxx:1114
 TDocParser.cxx:1115
 TDocParser.cxx:1116
 TDocParser.cxx:1117
 TDocParser.cxx:1118
 TDocParser.cxx:1119
 TDocParser.cxx:1120
 TDocParser.cxx:1121
 TDocParser.cxx:1122
 TDocParser.cxx:1123
 TDocParser.cxx:1124
 TDocParser.cxx:1125
 TDocParser.cxx:1126
 TDocParser.cxx:1127
 TDocParser.cxx:1128
 TDocParser.cxx:1129
 TDocParser.cxx:1130
 TDocParser.cxx:1131
 TDocParser.cxx:1132
 TDocParser.cxx:1133
 TDocParser.cxx:1134
 TDocParser.cxx:1135
 TDocParser.cxx:1136
 TDocParser.cxx:1137
 TDocParser.cxx:1138
 TDocParser.cxx:1139
 TDocParser.cxx:1140
 TDocParser.cxx:1141
 TDocParser.cxx:1142
 TDocParser.cxx:1143
 TDocParser.cxx:1144
 TDocParser.cxx:1145
 TDocParser.cxx:1146
 TDocParser.cxx:1147
 TDocParser.cxx:1148
 TDocParser.cxx:1149
 TDocParser.cxx:1150
 TDocParser.cxx:1151
 TDocParser.cxx:1152
 TDocParser.cxx:1153
 TDocParser.cxx:1154
 TDocParser.cxx:1155
 TDocParser.cxx:1156
 TDocParser.cxx:1157
 TDocParser.cxx:1158
 TDocParser.cxx:1159
 TDocParser.cxx:1160
 TDocParser.cxx:1161
 TDocParser.cxx:1162
 TDocParser.cxx:1163
 TDocParser.cxx:1164
 TDocParser.cxx:1165
 TDocParser.cxx:1166
 TDocParser.cxx:1167
 TDocParser.cxx:1168
 TDocParser.cxx:1169
 TDocParser.cxx:1170
 TDocParser.cxx:1171
 TDocParser.cxx:1172
 TDocParser.cxx:1173
 TDocParser.cxx:1174
 TDocParser.cxx:1175
 TDocParser.cxx:1176
 TDocParser.cxx:1177
 TDocParser.cxx:1178
 TDocParser.cxx:1179
 TDocParser.cxx:1180
 TDocParser.cxx:1181
 TDocParser.cxx:1182
 TDocParser.cxx:1183
 TDocParser.cxx:1184
 TDocParser.cxx:1185
 TDocParser.cxx:1186
 TDocParser.cxx:1187
 TDocParser.cxx:1188
 TDocParser.cxx:1189
 TDocParser.cxx:1190
 TDocParser.cxx:1191
 TDocParser.cxx:1192
 TDocParser.cxx:1193
 TDocParser.cxx:1194
 TDocParser.cxx:1195
 TDocParser.cxx:1196
 TDocParser.cxx:1197
 TDocParser.cxx:1198
 TDocParser.cxx:1199
 TDocParser.cxx:1200
 TDocParser.cxx:1201
 TDocParser.cxx:1202
 TDocParser.cxx:1203
 TDocParser.cxx:1204
 TDocParser.cxx:1205
 TDocParser.cxx:1206
 TDocParser.cxx:1207
 TDocParser.cxx:1208
 TDocParser.cxx:1209
 TDocParser.cxx:1210
 TDocParser.cxx:1211
 TDocParser.cxx:1212
 TDocParser.cxx:1213
 TDocParser.cxx:1214
 TDocParser.cxx:1215
 TDocParser.cxx:1216
 TDocParser.cxx:1217
 TDocParser.cxx:1218
 TDocParser.cxx:1219
 TDocParser.cxx:1220
 TDocParser.cxx:1221
 TDocParser.cxx:1222
 TDocParser.cxx:1223
 TDocParser.cxx:1224
 TDocParser.cxx:1225
 TDocParser.cxx:1226
 TDocParser.cxx:1227
 TDocParser.cxx:1228
 TDocParser.cxx:1229
 TDocParser.cxx:1230
 TDocParser.cxx:1231
 TDocParser.cxx:1232
 TDocParser.cxx:1233
 TDocParser.cxx:1234
 TDocParser.cxx:1235
 TDocParser.cxx:1236
 TDocParser.cxx:1237
 TDocParser.cxx:1238
 TDocParser.cxx:1239
 TDocParser.cxx:1240
 TDocParser.cxx:1241
 TDocParser.cxx:1242
 TDocParser.cxx:1243
 TDocParser.cxx:1244
 TDocParser.cxx:1245
 TDocParser.cxx:1246
 TDocParser.cxx:1247
 TDocParser.cxx:1248
 TDocParser.cxx:1249
 TDocParser.cxx:1250
 TDocParser.cxx:1251
 TDocParser.cxx:1252
 TDocParser.cxx:1253
 TDocParser.cxx:1254
 TDocParser.cxx:1255
 TDocParser.cxx:1256
 TDocParser.cxx:1257
 TDocParser.cxx:1258
 TDocParser.cxx:1259
 TDocParser.cxx:1260
 TDocParser.cxx:1261
 TDocParser.cxx:1262
 TDocParser.cxx:1263
 TDocParser.cxx:1264
 TDocParser.cxx:1265
 TDocParser.cxx:1266
 TDocParser.cxx:1267
 TDocParser.cxx:1268
 TDocParser.cxx:1269
 TDocParser.cxx:1270
 TDocParser.cxx:1271
 TDocParser.cxx:1272
 TDocParser.cxx:1273
 TDocParser.cxx:1274
 TDocParser.cxx:1275
 TDocParser.cxx:1276
 TDocParser.cxx:1277
 TDocParser.cxx:1278
 TDocParser.cxx:1279
 TDocParser.cxx:1280
 TDocParser.cxx:1281
 TDocParser.cxx:1282
 TDocParser.cxx:1283
 TDocParser.cxx:1284
 TDocParser.cxx:1285
 TDocParser.cxx:1286
 TDocParser.cxx:1287
 TDocParser.cxx:1288
 TDocParser.cxx:1289
 TDocParser.cxx:1290
 TDocParser.cxx:1291
 TDocParser.cxx:1292
 TDocParser.cxx:1293
 TDocParser.cxx:1294
 TDocParser.cxx:1295
 TDocParser.cxx:1296
 TDocParser.cxx:1297
 TDocParser.cxx:1298
 TDocParser.cxx:1299
 TDocParser.cxx:1300
 TDocParser.cxx:1301
 TDocParser.cxx:1302
 TDocParser.cxx:1303
 TDocParser.cxx:1304
 TDocParser.cxx:1305
 TDocParser.cxx:1306
 TDocParser.cxx:1307
 TDocParser.cxx:1308
 TDocParser.cxx:1309
 TDocParser.cxx:1310
 TDocParser.cxx:1311
 TDocParser.cxx:1312
 TDocParser.cxx:1313
 TDocParser.cxx:1314
 TDocParser.cxx:1315
 TDocParser.cxx:1316
 TDocParser.cxx:1317
 TDocParser.cxx:1318
 TDocParser.cxx:1319
 TDocParser.cxx:1320
 TDocParser.cxx:1321
 TDocParser.cxx:1322
 TDocParser.cxx:1323
 TDocParser.cxx:1324
 TDocParser.cxx:1325
 TDocParser.cxx:1326
 TDocParser.cxx:1327
 TDocParser.cxx:1328
 TDocParser.cxx:1329
 TDocParser.cxx:1330
 TDocParser.cxx:1331
 TDocParser.cxx:1332
 TDocParser.cxx:1333
 TDocParser.cxx:1334
 TDocParser.cxx:1335
 TDocParser.cxx:1336
 TDocParser.cxx:1337
 TDocParser.cxx:1338
 TDocParser.cxx:1339
 TDocParser.cxx:1340
 TDocParser.cxx:1341
 TDocParser.cxx:1342
 TDocParser.cxx:1343
 TDocParser.cxx:1344
 TDocParser.cxx:1345
 TDocParser.cxx:1346
 TDocParser.cxx:1347
 TDocParser.cxx:1348
 TDocParser.cxx:1349
 TDocParser.cxx:1350
 TDocParser.cxx:1351
 TDocParser.cxx:1352
 TDocParser.cxx:1353
 TDocParser.cxx:1354
 TDocParser.cxx:1355
 TDocParser.cxx:1356
 TDocParser.cxx:1357
 TDocParser.cxx:1358
 TDocParser.cxx:1359
 TDocParser.cxx:1360
 TDocParser.cxx:1361
 TDocParser.cxx:1362
 TDocParser.cxx:1363
 TDocParser.cxx:1364
 TDocParser.cxx:1365
 TDocParser.cxx:1366
 TDocParser.cxx:1367
 TDocParser.cxx:1368
 TDocParser.cxx:1369
 TDocParser.cxx:1370
 TDocParser.cxx:1371
 TDocParser.cxx:1372
 TDocParser.cxx:1373
 TDocParser.cxx:1374
 TDocParser.cxx:1375
 TDocParser.cxx:1376
 TDocParser.cxx:1377
 TDocParser.cxx:1378
 TDocParser.cxx:1379
 TDocParser.cxx:1380
 TDocParser.cxx:1381
 TDocParser.cxx:1382
 TDocParser.cxx:1383
 TDocParser.cxx:1384
 TDocParser.cxx:1385
 TDocParser.cxx:1386
 TDocParser.cxx:1387
 TDocParser.cxx:1388
 TDocParser.cxx:1389
 TDocParser.cxx:1390
 TDocParser.cxx:1391
 TDocParser.cxx:1392
 TDocParser.cxx:1393
 TDocParser.cxx:1394
 TDocParser.cxx:1395
 TDocParser.cxx:1396
 TDocParser.cxx:1397
 TDocParser.cxx:1398
 TDocParser.cxx:1399
 TDocParser.cxx:1400
 TDocParser.cxx:1401
 TDocParser.cxx:1402
 TDocParser.cxx:1403
 TDocParser.cxx:1404
 TDocParser.cxx:1405
 TDocParser.cxx:1406
 TDocParser.cxx:1407
 TDocParser.cxx:1408
 TDocParser.cxx:1409
 TDocParser.cxx:1410
 TDocParser.cxx:1411
 TDocParser.cxx:1412
 TDocParser.cxx:1413
 TDocParser.cxx:1414
 TDocParser.cxx:1415
 TDocParser.cxx:1416
 TDocParser.cxx:1417
 TDocParser.cxx:1418
 TDocParser.cxx:1419
 TDocParser.cxx:1420
 TDocParser.cxx:1421
 TDocParser.cxx:1422
 TDocParser.cxx:1423
 TDocParser.cxx:1424
 TDocParser.cxx:1425
 TDocParser.cxx:1426
 TDocParser.cxx:1427
 TDocParser.cxx:1428
 TDocParser.cxx:1429
 TDocParser.cxx:1430
 TDocParser.cxx:1431
 TDocParser.cxx:1432
 TDocParser.cxx:1433
 TDocParser.cxx:1434
 TDocParser.cxx:1435
 TDocParser.cxx:1436
 TDocParser.cxx:1437
 TDocParser.cxx:1438
 TDocParser.cxx:1439
 TDocParser.cxx:1440
 TDocParser.cxx:1441
 TDocParser.cxx:1442
 TDocParser.cxx:1443
 TDocParser.cxx:1444
 TDocParser.cxx:1445
 TDocParser.cxx:1446
 TDocParser.cxx:1447
 TDocParser.cxx:1448
 TDocParser.cxx:1449
 TDocParser.cxx:1450
 TDocParser.cxx:1451
 TDocParser.cxx:1452
 TDocParser.cxx:1453
 TDocParser.cxx:1454
 TDocParser.cxx:1455
 TDocParser.cxx:1456
 TDocParser.cxx:1457
 TDocParser.cxx:1458
 TDocParser.cxx:1459
 TDocParser.cxx:1460
 TDocParser.cxx:1461
 TDocParser.cxx:1462
 TDocParser.cxx:1463
 TDocParser.cxx:1464
 TDocParser.cxx:1465
 TDocParser.cxx:1466
 TDocParser.cxx:1467
 TDocParser.cxx:1468
 TDocParser.cxx:1469
 TDocParser.cxx:1470
 TDocParser.cxx:1471
 TDocParser.cxx:1472
 TDocParser.cxx:1473
 TDocParser.cxx:1474
 TDocParser.cxx:1475
 TDocParser.cxx:1476
 TDocParser.cxx:1477
 TDocParser.cxx:1478
 TDocParser.cxx:1479
 TDocParser.cxx:1480
 TDocParser.cxx:1481
 TDocParser.cxx:1482
 TDocParser.cxx:1483
 TDocParser.cxx:1484
 TDocParser.cxx:1485
 TDocParser.cxx:1486
 TDocParser.cxx:1487
 TDocParser.cxx:1488
 TDocParser.cxx:1489
 TDocParser.cxx:1490
 TDocParser.cxx:1491
 TDocParser.cxx:1492
 TDocParser.cxx:1493
 TDocParser.cxx:1494
 TDocParser.cxx:1495
 TDocParser.cxx:1496
 TDocParser.cxx:1497
 TDocParser.cxx:1498
 TDocParser.cxx:1499
 TDocParser.cxx:1500
 TDocParser.cxx:1501
 TDocParser.cxx:1502
 TDocParser.cxx:1503
 TDocParser.cxx:1504
 TDocParser.cxx:1505
 TDocParser.cxx:1506
 TDocParser.cxx:1507
 TDocParser.cxx:1508
 TDocParser.cxx:1509
 TDocParser.cxx:1510
 TDocParser.cxx:1511
 TDocParser.cxx:1512
 TDocParser.cxx:1513
 TDocParser.cxx:1514
 TDocParser.cxx:1515
 TDocParser.cxx:1516
 TDocParser.cxx:1517
 TDocParser.cxx:1518
 TDocParser.cxx:1519
 TDocParser.cxx:1520
 TDocParser.cxx:1521
 TDocParser.cxx:1522
 TDocParser.cxx:1523
 TDocParser.cxx:1524
 TDocParser.cxx:1525
 TDocParser.cxx:1526
 TDocParser.cxx:1527
 TDocParser.cxx:1528
 TDocParser.cxx:1529
 TDocParser.cxx:1530
 TDocParser.cxx:1531
 TDocParser.cxx:1532
 TDocParser.cxx:1533
 TDocParser.cxx:1534
 TDocParser.cxx:1535
 TDocParser.cxx:1536
 TDocParser.cxx:1537
 TDocParser.cxx:1538
 TDocParser.cxx:1539
 TDocParser.cxx:1540
 TDocParser.cxx:1541
 TDocParser.cxx:1542
 TDocParser.cxx:1543
 TDocParser.cxx:1544
 TDocParser.cxx:1545
 TDocParser.cxx:1546
 TDocParser.cxx:1547
 TDocParser.cxx:1548
 TDocParser.cxx:1549
 TDocParser.cxx:1550
 TDocParser.cxx:1551
 TDocParser.cxx:1552
 TDocParser.cxx:1553
 TDocParser.cxx:1554
 TDocParser.cxx:1555
 TDocParser.cxx:1556
 TDocParser.cxx:1557
 TDocParser.cxx:1558
 TDocParser.cxx:1559
 TDocParser.cxx:1560
 TDocParser.cxx:1561
 TDocParser.cxx:1562
 TDocParser.cxx:1563
 TDocParser.cxx:1564
 TDocParser.cxx:1565
 TDocParser.cxx:1566
 TDocParser.cxx:1567
 TDocParser.cxx:1568
 TDocParser.cxx:1569
 TDocParser.cxx:1570
 TDocParser.cxx:1571
 TDocParser.cxx:1572
 TDocParser.cxx:1573
 TDocParser.cxx:1574
 TDocParser.cxx:1575
 TDocParser.cxx:1576
 TDocParser.cxx:1577
 TDocParser.cxx:1578
 TDocParser.cxx:1579
 TDocParser.cxx:1580
 TDocParser.cxx:1581
 TDocParser.cxx:1582
 TDocParser.cxx:1583
 TDocParser.cxx:1584
 TDocParser.cxx:1585
 TDocParser.cxx:1586
 TDocParser.cxx:1587
 TDocParser.cxx:1588
 TDocParser.cxx:1589
 TDocParser.cxx:1590
 TDocParser.cxx:1591
 TDocParser.cxx:1592
 TDocParser.cxx:1593
 TDocParser.cxx:1594
 TDocParser.cxx:1595
 TDocParser.cxx:1596
 TDocParser.cxx:1597
 TDocParser.cxx:1598
 TDocParser.cxx:1599
 TDocParser.cxx:1600
 TDocParser.cxx:1601
 TDocParser.cxx:1602
 TDocParser.cxx:1603
 TDocParser.cxx:1604
 TDocParser.cxx:1605
 TDocParser.cxx:1606
 TDocParser.cxx:1607
 TDocParser.cxx:1608
 TDocParser.cxx:1609
 TDocParser.cxx:1610
 TDocParser.cxx:1611
 TDocParser.cxx:1612
 TDocParser.cxx:1613
 TDocParser.cxx:1614
 TDocParser.cxx:1615
 TDocParser.cxx:1616
 TDocParser.cxx:1617
 TDocParser.cxx:1618
 TDocParser.cxx:1619
 TDocParser.cxx:1620
 TDocParser.cxx:1621
 TDocParser.cxx:1622
 TDocParser.cxx:1623
 TDocParser.cxx:1624
 TDocParser.cxx:1625
 TDocParser.cxx:1626
 TDocParser.cxx:1627
 TDocParser.cxx:1628
 TDocParser.cxx:1629
 TDocParser.cxx:1630
 TDocParser.cxx:1631
 TDocParser.cxx:1632
 TDocParser.cxx:1633
 TDocParser.cxx:1634
 TDocParser.cxx:1635
 TDocParser.cxx:1636
 TDocParser.cxx:1637
 TDocParser.cxx:1638
 TDocParser.cxx:1639
 TDocParser.cxx:1640
 TDocParser.cxx:1641
 TDocParser.cxx:1642
 TDocParser.cxx:1643
 TDocParser.cxx:1644
 TDocParser.cxx:1645
 TDocParser.cxx:1646
 TDocParser.cxx:1647
 TDocParser.cxx:1648
 TDocParser.cxx:1649
 TDocParser.cxx:1650
 TDocParser.cxx:1651
 TDocParser.cxx:1652
 TDocParser.cxx:1653
 TDocParser.cxx:1654
 TDocParser.cxx:1655
 TDocParser.cxx:1656
 TDocParser.cxx:1657
 TDocParser.cxx:1658
 TDocParser.cxx:1659
 TDocParser.cxx:1660
 TDocParser.cxx:1661
 TDocParser.cxx:1662
 TDocParser.cxx:1663
 TDocParser.cxx:1664
 TDocParser.cxx:1665
 TDocParser.cxx:1666
 TDocParser.cxx:1667
 TDocParser.cxx:1668
 TDocParser.cxx:1669
 TDocParser.cxx:1670
 TDocParser.cxx:1671
 TDocParser.cxx:1672
 TDocParser.cxx:1673
 TDocParser.cxx:1674
 TDocParser.cxx:1675
 TDocParser.cxx:1676
 TDocParser.cxx:1677
 TDocParser.cxx:1678
 TDocParser.cxx:1679
 TDocParser.cxx:1680
 TDocParser.cxx:1681
 TDocParser.cxx:1682
 TDocParser.cxx:1683
 TDocParser.cxx:1684
 TDocParser.cxx:1685
 TDocParser.cxx:1686
 TDocParser.cxx:1687
 TDocParser.cxx:1688
 TDocParser.cxx:1689
 TDocParser.cxx:1690
 TDocParser.cxx:1691
 TDocParser.cxx:1692
 TDocParser.cxx:1693
 TDocParser.cxx:1694
 TDocParser.cxx:1695
 TDocParser.cxx:1696
 TDocParser.cxx:1697
 TDocParser.cxx:1698
 TDocParser.cxx:1699
 TDocParser.cxx:1700
 TDocParser.cxx:1701
 TDocParser.cxx:1702
 TDocParser.cxx:1703
 TDocParser.cxx:1704
 TDocParser.cxx:1705
 TDocParser.cxx:1706
 TDocParser.cxx:1707
 TDocParser.cxx:1708
 TDocParser.cxx:1709
 TDocParser.cxx:1710
 TDocParser.cxx:1711
 TDocParser.cxx:1712
 TDocParser.cxx:1713
 TDocParser.cxx:1714
 TDocParser.cxx:1715
 TDocParser.cxx:1716
 TDocParser.cxx:1717
 TDocParser.cxx:1718
 TDocParser.cxx:1719
 TDocParser.cxx:1720
 TDocParser.cxx:1721
 TDocParser.cxx:1722
 TDocParser.cxx:1723
 TDocParser.cxx:1724
 TDocParser.cxx:1725
 TDocParser.cxx:1726
 TDocParser.cxx:1727
 TDocParser.cxx:1728
 TDocParser.cxx:1729
 TDocParser.cxx:1730
 TDocParser.cxx:1731
 TDocParser.cxx:1732
 TDocParser.cxx:1733
 TDocParser.cxx:1734
 TDocParser.cxx:1735
 TDocParser.cxx:1736
 TDocParser.cxx:1737
 TDocParser.cxx:1738
 TDocParser.cxx:1739
 TDocParser.cxx:1740
 TDocParser.cxx:1741
 TDocParser.cxx:1742
 TDocParser.cxx:1743
 TDocParser.cxx:1744
 TDocParser.cxx:1745
 TDocParser.cxx:1746
 TDocParser.cxx:1747
 TDocParser.cxx:1748
 TDocParser.cxx:1749
 TDocParser.cxx:1750
 TDocParser.cxx:1751
 TDocParser.cxx:1752
 TDocParser.cxx:1753
 TDocParser.cxx:1754
 TDocParser.cxx:1755
 TDocParser.cxx:1756
 TDocParser.cxx:1757
 TDocParser.cxx:1758
 TDocParser.cxx:1759
 TDocParser.cxx:1760
 TDocParser.cxx:1761
 TDocParser.cxx:1762
 TDocParser.cxx:1763
 TDocParser.cxx:1764
 TDocParser.cxx:1765
 TDocParser.cxx:1766
 TDocParser.cxx:1767
 TDocParser.cxx:1768
 TDocParser.cxx:1769
 TDocParser.cxx:1770
 TDocParser.cxx:1771
 TDocParser.cxx:1772
 TDocParser.cxx:1773
 TDocParser.cxx:1774
 TDocParser.cxx:1775
 TDocParser.cxx:1776
 TDocParser.cxx:1777
 TDocParser.cxx:1778
 TDocParser.cxx:1779
 TDocParser.cxx:1780
 TDocParser.cxx:1781
 TDocParser.cxx:1782
 TDocParser.cxx:1783
 TDocParser.cxx:1784
 TDocParser.cxx:1785
 TDocParser.cxx:1786
 TDocParser.cxx:1787
 TDocParser.cxx:1788
 TDocParser.cxx:1789
 TDocParser.cxx:1790
 TDocParser.cxx:1791
 TDocParser.cxx:1792
 TDocParser.cxx:1793
 TDocParser.cxx:1794
 TDocParser.cxx:1795
 TDocParser.cxx:1796
 TDocParser.cxx:1797
 TDocParser.cxx:1798
 TDocParser.cxx:1799
 TDocParser.cxx:1800
 TDocParser.cxx:1801
 TDocParser.cxx:1802
 TDocParser.cxx:1803
 TDocParser.cxx:1804
 TDocParser.cxx:1805
 TDocParser.cxx:1806
 TDocParser.cxx:1807
 TDocParser.cxx:1808
 TDocParser.cxx:1809
 TDocParser.cxx:1810
 TDocParser.cxx:1811
 TDocParser.cxx:1812
 TDocParser.cxx:1813
 TDocParser.cxx:1814
 TDocParser.cxx:1815
 TDocParser.cxx:1816
 TDocParser.cxx:1817
 TDocParser.cxx:1818
 TDocParser.cxx:1819
 TDocParser.cxx:1820
 TDocParser.cxx:1821
 TDocParser.cxx:1822
 TDocParser.cxx:1823
 TDocParser.cxx:1824
 TDocParser.cxx:1825
 TDocParser.cxx:1826
 TDocParser.cxx:1827
 TDocParser.cxx:1828
 TDocParser.cxx:1829
 TDocParser.cxx:1830
 TDocParser.cxx:1831
 TDocParser.cxx:1832
 TDocParser.cxx:1833
 TDocParser.cxx:1834
 TDocParser.cxx:1835
 TDocParser.cxx:1836
 TDocParser.cxx:1837
 TDocParser.cxx:1838
 TDocParser.cxx:1839
 TDocParser.cxx:1840
 TDocParser.cxx:1841
 TDocParser.cxx:1842
 TDocParser.cxx:1843
 TDocParser.cxx:1844
 TDocParser.cxx:1845
 TDocParser.cxx:1846
 TDocParser.cxx:1847
 TDocParser.cxx:1848
 TDocParser.cxx:1849
 TDocParser.cxx:1850
 TDocParser.cxx:1851
 TDocParser.cxx:1852
 TDocParser.cxx:1853
 TDocParser.cxx:1854
 TDocParser.cxx:1855
 TDocParser.cxx:1856
 TDocParser.cxx:1857
 TDocParser.cxx:1858
 TDocParser.cxx:1859
 TDocParser.cxx:1860
 TDocParser.cxx:1861
 TDocParser.cxx:1862
 TDocParser.cxx:1863
 TDocParser.cxx:1864
 TDocParser.cxx:1865
 TDocParser.cxx:1866
 TDocParser.cxx:1867
 TDocParser.cxx:1868
 TDocParser.cxx:1869
 TDocParser.cxx:1870
 TDocParser.cxx:1871
 TDocParser.cxx:1872
 TDocParser.cxx:1873
 TDocParser.cxx:1874
 TDocParser.cxx:1875
 TDocParser.cxx:1876
 TDocParser.cxx:1877
 TDocParser.cxx:1878
 TDocParser.cxx:1879
 TDocParser.cxx:1880
 TDocParser.cxx:1881
 TDocParser.cxx:1882
 TDocParser.cxx:1883
 TDocParser.cxx:1884
 TDocParser.cxx:1885
 TDocParser.cxx:1886
 TDocParser.cxx:1887
 TDocParser.cxx:1888
 TDocParser.cxx:1889
 TDocParser.cxx:1890
 TDocParser.cxx:1891
 TDocParser.cxx:1892
 TDocParser.cxx:1893
 TDocParser.cxx:1894
 TDocParser.cxx:1895
 TDocParser.cxx:1896
 TDocParser.cxx:1897
 TDocParser.cxx:1898
 TDocParser.cxx:1899
 TDocParser.cxx:1900
 TDocParser.cxx:1901
 TDocParser.cxx:1902
 TDocParser.cxx:1903
 TDocParser.cxx:1904
 TDocParser.cxx:1905
 TDocParser.cxx:1906
 TDocParser.cxx:1907
 TDocParser.cxx:1908
 TDocParser.cxx:1909
 TDocParser.cxx:1910
 TDocParser.cxx:1911
 TDocParser.cxx:1912
 TDocParser.cxx:1913
 TDocParser.cxx:1914
 TDocParser.cxx:1915
 TDocParser.cxx:1916
 TDocParser.cxx:1917
 TDocParser.cxx:1918
 TDocParser.cxx:1919
 TDocParser.cxx:1920
 TDocParser.cxx:1921
 TDocParser.cxx:1922
 TDocParser.cxx:1923
 TDocParser.cxx:1924
 TDocParser.cxx:1925
 TDocParser.cxx:1926
 TDocParser.cxx:1927
 TDocParser.cxx:1928
 TDocParser.cxx:1929
 TDocParser.cxx:1930
 TDocParser.cxx:1931
 TDocParser.cxx:1932
 TDocParser.cxx:1933
 TDocParser.cxx:1934
 TDocParser.cxx:1935
 TDocParser.cxx:1936
 TDocParser.cxx:1937
 TDocParser.cxx:1938
 TDocParser.cxx:1939
 TDocParser.cxx:1940
 TDocParser.cxx:1941
 TDocParser.cxx:1942
 TDocParser.cxx:1943
 TDocParser.cxx:1944
 TDocParser.cxx:1945
 TDocParser.cxx:1946
 TDocParser.cxx:1947
 TDocParser.cxx:1948
 TDocParser.cxx:1949
 TDocParser.cxx:1950
 TDocParser.cxx:1951
 TDocParser.cxx:1952
 TDocParser.cxx:1953
 TDocParser.cxx:1954
 TDocParser.cxx:1955
 TDocParser.cxx:1956
 TDocParser.cxx:1957
 TDocParser.cxx:1958
 TDocParser.cxx:1959
 TDocParser.cxx:1960
 TDocParser.cxx:1961
 TDocParser.cxx:1962
 TDocParser.cxx:1963
 TDocParser.cxx:1964
 TDocParser.cxx:1965
 TDocParser.cxx:1966
 TDocParser.cxx:1967
 TDocParser.cxx:1968
 TDocParser.cxx:1969
 TDocParser.cxx:1970
 TDocParser.cxx:1971
 TDocParser.cxx:1972
 TDocParser.cxx:1973
 TDocParser.cxx:1974
 TDocParser.cxx:1975
 TDocParser.cxx:1976
 TDocParser.cxx:1977
 TDocParser.cxx:1978
 TDocParser.cxx:1979
 TDocParser.cxx:1980
 TDocParser.cxx:1981
 TDocParser.cxx:1982
 TDocParser.cxx:1983
 TDocParser.cxx:1984
 TDocParser.cxx:1985
 TDocParser.cxx:1986
 TDocParser.cxx:1987
 TDocParser.cxx:1988
 TDocParser.cxx:1989
 TDocParser.cxx:1990
 TDocParser.cxx:1991
 TDocParser.cxx:1992
 TDocParser.cxx:1993
 TDocParser.cxx:1994
 TDocParser.cxx:1995
 TDocParser.cxx:1996
 TDocParser.cxx:1997
 TDocParser.cxx:1998
 TDocParser.cxx:1999
 TDocParser.cxx:2000
 TDocParser.cxx:2001
 TDocParser.cxx:2002
 TDocParser.cxx:2003
 TDocParser.cxx:2004
 TDocParser.cxx:2005
 TDocParser.cxx:2006
 TDocParser.cxx:2007
 TDocParser.cxx:2008
 TDocParser.cxx:2009
 TDocParser.cxx:2010
 TDocParser.cxx:2011
 TDocParser.cxx:2012
 TDocParser.cxx:2013
 TDocParser.cxx:2014
 TDocParser.cxx:2015
 TDocParser.cxx:2016
 TDocParser.cxx:2017
 TDocParser.cxx:2018
 TDocParser.cxx:2019
 TDocParser.cxx:2020
 TDocParser.cxx:2021
 TDocParser.cxx:2022
 TDocParser.cxx:2023
 TDocParser.cxx:2024
 TDocParser.cxx:2025
 TDocParser.cxx:2026
 TDocParser.cxx:2027
 TDocParser.cxx:2028
 TDocParser.cxx:2029
 TDocParser.cxx:2030
 TDocParser.cxx:2031
 TDocParser.cxx:2032
 TDocParser.cxx:2033
 TDocParser.cxx:2034
 TDocParser.cxx:2035
 TDocParser.cxx:2036
 TDocParser.cxx:2037
 TDocParser.cxx:2038
 TDocParser.cxx:2039
 TDocParser.cxx:2040
 TDocParser.cxx:2041
 TDocParser.cxx:2042
 TDocParser.cxx:2043
 TDocParser.cxx:2044
 TDocParser.cxx:2045
 TDocParser.cxx:2046
 TDocParser.cxx:2047
 TDocParser.cxx:2048
 TDocParser.cxx:2049
 TDocParser.cxx:2050
 TDocParser.cxx:2051
 TDocParser.cxx:2052
 TDocParser.cxx:2053
 TDocParser.cxx:2054
 TDocParser.cxx:2055
 TDocParser.cxx:2056
 TDocParser.cxx:2057
 TDocParser.cxx:2058
 TDocParser.cxx:2059
 TDocParser.cxx:2060
 TDocParser.cxx:2061
 TDocParser.cxx:2062
 TDocParser.cxx:2063
 TDocParser.cxx:2064
 TDocParser.cxx:2065
 TDocParser.cxx:2066
 TDocParser.cxx:2067
 TDocParser.cxx:2068
 TDocParser.cxx:2069
 TDocParser.cxx:2070
 TDocParser.cxx:2071
 TDocParser.cxx:2072
 TDocParser.cxx:2073
 TDocParser.cxx:2074
 TDocParser.cxx:2075
 TDocParser.cxx:2076
 TDocParser.cxx:2077
 TDocParser.cxx:2078
 TDocParser.cxx:2079
 TDocParser.cxx:2080
 TDocParser.cxx:2081
 TDocParser.cxx:2082
 TDocParser.cxx:2083
 TDocParser.cxx:2084
 TDocParser.cxx:2085
 TDocParser.cxx:2086
 TDocParser.cxx:2087
 TDocParser.cxx:2088
 TDocParser.cxx:2089
 TDocParser.cxx:2090
 TDocParser.cxx:2091
 TDocParser.cxx:2092
 TDocParser.cxx:2093
 TDocParser.cxx:2094
 TDocParser.cxx:2095
 TDocParser.cxx:2096
 TDocParser.cxx:2097
 TDocParser.cxx:2098
 TDocParser.cxx:2099
 TDocParser.cxx:2100
 TDocParser.cxx:2101
 TDocParser.cxx:2102
 TDocParser.cxx:2103
 TDocParser.cxx:2104
 TDocParser.cxx:2105
 TDocParser.cxx:2106
 TDocParser.cxx:2107
 TDocParser.cxx:2108
 TDocParser.cxx:2109
 TDocParser.cxx:2110
 TDocParser.cxx:2111
 TDocParser.cxx:2112
 TDocParser.cxx:2113
 TDocParser.cxx:2114
 TDocParser.cxx:2115
 TDocParser.cxx:2116
 TDocParser.cxx:2117
 TDocParser.cxx:2118
 TDocParser.cxx:2119
 TDocParser.cxx:2120
 TDocParser.cxx:2121
 TDocParser.cxx:2122
 TDocParser.cxx:2123
 TDocParser.cxx:2124
 TDocParser.cxx:2125
 TDocParser.cxx:2126
 TDocParser.cxx:2127
 TDocParser.cxx:2128
 TDocParser.cxx:2129
 TDocParser.cxx:2130
 TDocParser.cxx:2131
 TDocParser.cxx:2132
 TDocParser.cxx:2133
 TDocParser.cxx:2134
 TDocParser.cxx:2135
 TDocParser.cxx:2136
 TDocParser.cxx:2137
 TDocParser.cxx:2138
 TDocParser.cxx:2139
 TDocParser.cxx:2140
 TDocParser.cxx:2141
 TDocParser.cxx:2142
 TDocParser.cxx:2143
 TDocParser.cxx:2144
 TDocParser.cxx:2145
 TDocParser.cxx:2146
 TDocParser.cxx:2147
 TDocParser.cxx:2148
 TDocParser.cxx:2149
 TDocParser.cxx:2150
 TDocParser.cxx:2151
 TDocParser.cxx:2152
 TDocParser.cxx:2153
 TDocParser.cxx:2154
 TDocParser.cxx:2155
 TDocParser.cxx:2156
 TDocParser.cxx:2157
 TDocParser.cxx:2158
 TDocParser.cxx:2159
 TDocParser.cxx:2160
 TDocParser.cxx:2161
 TDocParser.cxx:2162
 TDocParser.cxx:2163
 TDocParser.cxx:2164
 TDocParser.cxx:2165
 TDocParser.cxx:2166
 TDocParser.cxx:2167
 TDocParser.cxx:2168
 TDocParser.cxx:2169
 TDocParser.cxx:2170
 TDocParser.cxx:2171
 TDocParser.cxx:2172
 TDocParser.cxx:2173
 TDocParser.cxx:2174
 TDocParser.cxx:2175
 TDocParser.cxx:2176
 TDocParser.cxx:2177
 TDocParser.cxx:2178
 TDocParser.cxx:2179
 TDocParser.cxx:2180
 TDocParser.cxx:2181
 TDocParser.cxx:2182
 TDocParser.cxx:2183
 TDocParser.cxx:2184
 TDocParser.cxx:2185
 TDocParser.cxx:2186
 TDocParser.cxx:2187
 TDocParser.cxx:2188
 TDocParser.cxx:2189
 TDocParser.cxx:2190
 TDocParser.cxx:2191
 TDocParser.cxx:2192
 TDocParser.cxx:2193
 TDocParser.cxx:2194
 TDocParser.cxx:2195
 TDocParser.cxx:2196
 TDocParser.cxx:2197
 TDocParser.cxx:2198
 TDocParser.cxx:2199
 TDocParser.cxx:2200
 TDocParser.cxx:2201
 TDocParser.cxx:2202
 TDocParser.cxx:2203
 TDocParser.cxx:2204
 TDocParser.cxx:2205
 TDocParser.cxx:2206
 TDocParser.cxx:2207
 TDocParser.cxx:2208
 TDocParser.cxx:2209
 TDocParser.cxx:2210
 TDocParser.cxx:2211
 TDocParser.cxx:2212
 TDocParser.cxx:2213
 TDocParser.cxx:2214
 TDocParser.cxx:2215
 TDocParser.cxx:2216
 TDocParser.cxx:2217
 TDocParser.cxx:2218
 TDocParser.cxx:2219
 TDocParser.cxx:2220
 TDocParser.cxx:2221
 TDocParser.cxx:2222
 TDocParser.cxx:2223
 TDocParser.cxx:2224
 TDocParser.cxx:2225
 TDocParser.cxx:2226
 TDocParser.cxx:2227
 TDocParser.cxx:2228
 TDocParser.cxx:2229
 TDocParser.cxx:2230
 TDocParser.cxx:2231
 TDocParser.cxx:2232
 TDocParser.cxx:2233
 TDocParser.cxx:2234
 TDocParser.cxx:2235
 TDocParser.cxx:2236
 TDocParser.cxx:2237
 TDocParser.cxx:2238
 TDocParser.cxx:2239
 TDocParser.cxx:2240
 TDocParser.cxx:2241
 TDocParser.cxx:2242
 TDocParser.cxx:2243
 TDocParser.cxx:2244
 TDocParser.cxx:2245
 TDocParser.cxx:2246
 TDocParser.cxx:2247
 TDocParser.cxx:2248
 TDocParser.cxx:2249
 TDocParser.cxx:2250
 TDocParser.cxx:2251
 TDocParser.cxx:2252
 TDocParser.cxx:2253
 TDocParser.cxx:2254
 TDocParser.cxx:2255
 TDocParser.cxx:2256
 TDocParser.cxx:2257
 TDocParser.cxx:2258
 TDocParser.cxx:2259
 TDocParser.cxx:2260
 TDocParser.cxx:2261
 TDocParser.cxx:2262
 TDocParser.cxx:2263
 TDocParser.cxx:2264
 TDocParser.cxx:2265
 TDocParser.cxx:2266
 TDocParser.cxx:2267
 TDocParser.cxx:2268
 TDocParser.cxx:2269
 TDocParser.cxx:2270
 TDocParser.cxx:2271
 TDocParser.cxx:2272
 TDocParser.cxx:2273
 TDocParser.cxx:2274
 TDocParser.cxx:2275
 TDocParser.cxx:2276
 TDocParser.cxx:2277
 TDocParser.cxx:2278
 TDocParser.cxx:2279
 TDocParser.cxx:2280
 TDocParser.cxx:2281
 TDocParser.cxx:2282
 TDocParser.cxx:2283
 TDocParser.cxx:2284
 TDocParser.cxx:2285
 TDocParser.cxx:2286
 TDocParser.cxx:2287
 TDocParser.cxx:2288
 TDocParser.cxx:2289
 TDocParser.cxx:2290
 TDocParser.cxx:2291
 TDocParser.cxx:2292
 TDocParser.cxx:2293
 TDocParser.cxx:2294
 TDocParser.cxx:2295
 TDocParser.cxx:2296
 TDocParser.cxx:2297
 TDocParser.cxx:2298
 TDocParser.cxx:2299
 TDocParser.cxx:2300
 TDocParser.cxx:2301
 TDocParser.cxx:2302
 TDocParser.cxx:2303
 TDocParser.cxx:2304
 TDocParser.cxx:2305
 TDocParser.cxx:2306