ROOT logo
// @(#)root/html:$Id: THtml.cxx 27910 2009-03-21 17:26:55Z axel $
// Author: Nenad Buncic (18/10/95), Axel Naumann (09/28/01)

/*************************************************************************
 * 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 "THtml.h"
#include "RConfigure.h"
#include "Riostream.h"
#include "TBaseClass.h"
#include "TClass.h"
#include "TClassDocOutput.h"
#include "TClassEdit.h"
#include "TClassTable.h"
#include "TDataType.h"
#include "TDocInfo.h"
#include "TDocOutput.h"
#include "TEnv.h"
#include "TInterpreter.h"
#include "TObjString.h"
#include "TPRegexp.h"
#include "TRegexp.h"
#include "TROOT.h"
#include "TSystem.h"
#include "TThread.h"

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <set>
#include <fstream>

THtml *gHtml = 0;

//______________________________________________________________________________
//______________________________________________________________________________
namespace {
   class THtmlThreadInfo {
   public:
      THtmlThreadInfo(THtml* html, bool force): fHtml(html), fForce(force) {}
      Bool_t GetForce() const {return fForce;}
      THtml* GetHtml() const {return fHtml;}

   private:
      THtml* fHtml;
      Bool_t fForce;
   };
};


//______________________________________________________________________________
THtml::THelperBase::~THelperBase()
{
   // Helper's destructor.
   // Check that no THtml object is attached to the helper - it might still need it!
   if (fHtml) {
      fHtml->HelperDeleted(this);
   }
}


//______________________________________________________________________________
void THtml::THelperBase::SetOwner(THtml* html) {
   // Set the THtml object owning this object; if it's already set to
   // a different THtml object than issue an error message and signal to
   // the currently set object that we are not belonging to it anymore.
   if (fHtml && html && html != fHtml) {
      Error("SetOwner()", "Object already owned by an THtml instance!");
      fHtml->HelperDeleted(this);
   }
   fHtml = html;
}


//______________________________________________________________________________
bool THtml::TModuleDefinition::GetModule(TClass* cl, TFileSysEntry* fse,
                                         TString& out_modulename) const
{
   // Set out_modulename to cl's module name; return true if it's valid.
   // If applicable, the module contains super modules separated by "/".
   //
   // ROOT takes the directory part of cl's implementation file name 
   // (or declaration file name, if the implementation file name is empty),
   // removes the last subdirectory if it is "src/" or "inc/", and interprets
   // the remaining path as the module hierarchy, converting it to upper case.
   // hist/histpainter/src/THistPainter.cxx thus becomes the module
   // HIST/HISTPAINTER. (Node: some ROOT packages get special treatment.)
   // If the file cannot be mapped into this scheme, the class's library
   // name (without directories, leading "lib" prefix or file extensions)
   // ius taken as the module name. If the module cannot be determined it is
   // set to "USER" and false is returned.
   //
   // If your software cannot be mapped into this scheme then derive your
   // own class from TModuleDefinition and pass it to THtml::SetModuleDefinition().
   //
   // The fse parameter is used to determine the relevant part of the path, i.e.
   // to not include parent directories of a TFileSysRoot.

   out_modulename = "USER";
   if (!cl) return false;

   // Filename: impl or decl?
   TString filename;
   if (fse) fse->GetFullName(filename, kFALSE);
   else {
      if (!GetOwner()->GetImplFileName(cl, kFALSE, filename))
         if (!GetOwner()->GetDeclFileName(cl, kFALSE, filename))
            return false;
   }
   TString inputdir = GetOwner()->GetInputPath();
   TString tok;
   Ssiz_t start = 0;
   // For -Idir/sub and A.h in dir/sub/A.h, use sub as module name if 
   // it would eb empty otehrwise.
   TString trailingInclude;
   while (inputdir.Tokenize(tok, start, THtml::GetDirDelimiter())) {      
      if (filename.BeginsWith(tok)) {
         if (tok.EndsWith("/") || tok.EndsWith("\\"))
            tok.Remove(tok.Length() - 1);
         trailingInclude = gSystem->BaseName(tok);
         filename.Remove(0, tok.Length());
         break;
      }
   }

   // take the directory name without "/" or leading "."
   out_modulename = gSystem->DirName(filename);

   while (out_modulename[0] == '.')
      out_modulename.Remove(0, 1);
   out_modulename.ReplaceAll("\\", "/");
   while (out_modulename[0] == '/')
      out_modulename.Remove(0, 1);
   while (out_modulename.EndsWith("/"))
      out_modulename.Remove(out_modulename.Length() - 1);

   if (!out_modulename[0])
      out_modulename = trailingInclude;

   if (!out_modulename[0])
      out_modulename = trailingInclude;

   // remove "/src", "/inc"
   if (out_modulename.EndsWith("/src")
      || out_modulename.EndsWith("/inc"))
      out_modulename.Remove(out_modulename.Length() - 4, 4);
   else {
   // remove "/src/whatever", "/inc/whatever"
      Ssiz_t pos = out_modulename.Index("/src/");
      if (pos == kNPOS)
         pos = out_modulename.Index("/inc/");
      if (pos != kNPOS)
         out_modulename.Remove(pos);
   }

   while (out_modulename.EndsWith("/"))
      out_modulename.Remove(out_modulename.Length() - 1);

   // special treatment:
   if (out_modulename == "MATH/GENVECTOR")
      out_modulename = "MATHCORE";
   else if (out_modulename == "MATH/MATRIX")
      out_modulename = "SMATRIX";
   else if (!out_modulename.Length()) {
      const char* cname= cl->GetName();
      if (strstr(cname, "::SMatrix<") || strstr(cname, "::SVector<"))
         out_modulename = "SMATRIX";
      else if (strstr(cname, "::TArrayProxy<") || strstr(cname, "::TClaArrayProxy<")
               || strstr(cname, "::TImpProxy<") || strstr(cname, "::TClaImpProxy<"))
         out_modulename = "TREEPLAYER";
      else {
         // determine the module name from the library name:
         out_modulename = cl->GetSharedLibs();
         Ssiz_t pos = out_modulename.Index(' ');
         if (pos != kNPOS)
            out_modulename.Remove(pos, out_modulename.Length());
         if (out_modulename.BeginsWith("lib"))
            out_modulename.Remove(0,3);
         pos = out_modulename.Index('.');
         if (pos != kNPOS)
            out_modulename.Remove(pos, out_modulename.Length());

         if (!out_modulename.Length()) {
            out_modulename = "USER";
            return false;
         }
      }
   }

   return true;
}

//______________________________________________________________________________
void THtml::TFileDefinition::ExpandSearchPath(TString& path) const
{
   // Create all permutations of path and THtml's input path:
   // path being PP/ and THtml's input being .:include/:src/ gives
   // .:./PP/:include:include/PP/:src/:src/PP
   THtml* owner = GetOwner();
   if (!owner) return;

   TString pathext;
   TString inputdir = owner->GetInputPath();
   TString tok;
   Ssiz_t start = 0;
   while (inputdir.Tokenize(tok, start, THtml::GetDirDelimiter())) {
      if (pathext.Length())
         pathext += GetDirDelimiter();
      if (tok.EndsWith("\\"))
         tok.Remove(tok.Length() - 1);
      pathext += tok;
      if (path.BeginsWith(tok))
         pathext += GetDirDelimiter() + path;
      else
         pathext += GetDirDelimiter() + tok + "/" + path;
   }
   path = pathext;

}

//______________________________________________________________________________
void THtml::TFileDefinition::SplitClassIntoDirFile(const TString& clname, TString& dir,
                                                   TString& filename) const
{
   // Given a class name with a scope, split the class name into directory part
   // and file name: A::B::C becomes module B, filename C.
   TString token;
   Ssiz_t from = 0;
   filename = "";
   dir = "";
   while (clname.Tokenize(token, from, "::") ) {
      dir = filename;
      filename = token;
   }

   // convert from Scope, class to module, filename.h
   dir.ToLower();
}


//______________________________________________________________________________
bool THtml::TFileDefinition::GetDeclFileName(const TClass* cl, TString& out_filename,
                                             TString& out_fsys, TFileSysEntry** fse) const
{
   // Determine cl's declaration file name. Usually it's just
   // cl->GetDeclFileName(), but sometimes conversions need to be done
   // like include/ to abc/cde/inc/. If no declaration file name is
   // available, look for b/inc/C.h for class A::B::C. out_fsys will contain
   // the file system's (i.e. local machine's) full path name to the file.
   // The function returns false if the class's header file cannot be found.
   //
   // If your software cannot be mapped into this scheme then derive your
   // own class from TFileDefinition and pass it to THtml::SetFileDefinition().

   return GetFileName(cl, true, out_filename, out_fsys, fse);
}

//______________________________________________________________________________
bool THtml::TFileDefinition::GetImplFileName(const TClass* cl, TString& out_filename,
                                             TString& out_fsys, TFileSysEntry** fse) const
{
   // Determine cl's implementation file name. Usually it's just
   // cl->GetImplFileName(), but sometimes conversions need to be done.
   // If no implementation file name is available look for b/src/C.cxx for
   // class A::B::C. out_fsys will contain the file system's (i.e. local 
   // machine's) full path name to the file.
   // The function returns false if the class's source file cannot be found.
   //
   // If your software cannot be mapped into this scheme then derive your
   // own class from TFileDefinition and pass it to THtml::SetFileDefinition().

   return GetFileName(cl, false, out_filename, out_fsys, fse);
}


//______________________________________________________________________________
void THtml::TFileDefinition::NormalizePath(TString& filename) const
{
   // Remove "/./" and collapse "/subdir/../" to "/"
   static const char* delim[] = {"/", "\\\\"};
   for (int i = 0; i < 2; ++i) {
      const char* d = delim[i];
      filename = filename.ReplaceAll(TString::Format("%c.%c", d[0], d[0]), TString(d[0]));
      TPRegexp reg(TString::Format("%s[^%s]+%s\\.\\.%s", d, d, d, d));
      while (reg.Substitute(filename, TString(d[0]), "", 0, 1)) {}
   }
}


//______________________________________________________________________________
TString THtml::TFileDefinition::MatchFileSysName(TString& filename, TFileSysEntry** fse) const
{
   // Find filename in the list of system files; return the system file name
   // and change filename to the file name as included.
   // filename must be normalized (no "/./" etc) before calling.

   TList* bucket = GetOwner()->GetLocalFiles()->GetEntries().GetListForObject(gSystem->BaseName(filename));
   TString filesysname;
   if (bucket) {
      TIter iFS(bucket);
      TFileSysEntry* fsentry = 0;
      while ((fsentry = (TFileSysEntry*) iFS())) {
         if (!filename.EndsWith(fsentry->GetName()))
            continue;
         fsentry->GetFullName(filesysname, kTRUE); // get the short version
         if (!filename.EndsWith(filesysname)) {
            filesysname = "";
            continue;
         }
         filename = filesysname;
         fsentry->GetFullName(filesysname, kFALSE); // get the long version
         if (fse) *fse = fsentry;
         break;
      }
   }
   return filesysname;
}


//______________________________________________________________________________
bool THtml::TFileDefinition::GetFileName(const TClass* cl, bool decl,
                                         TString& out_filename, TString& out_fsys,
                                         TFileSysEntry** fse) const
{
   // Common implementation for GetDeclFileName(), GetImplFileName()

   out_fsys = "";

   if (!cl) {
      out_filename = "";
      return false;
   }

   TString possibleFileName;
   TString possiblePath;
   TString filesysname;

   TString clfile = decl ? cl->GetDeclFileName() : cl->GetImplFileName();
   NormalizePath(clfile);
             
   out_filename = clfile;
   if (clfile.Length()) {
      // check that clfile doesn't start with one of the include paths;
      // that's not what we want (include/TObject.h), we want the actual file
      // if it exists (core/base/inc/TObject.h)

      // special case for TMath namespace:
      if (clfile == "include/TMathBase.h") {
         clfile = "math/mathcore/inc/TMath.h";
         out_filename = clfile;
      }

      TString inclDir;
      TString inclPath(GetOwner()->GetPathInfo().fIncludePath);
      Ssiz_t pos = 0;
      Ssiz_t longestMatch = kNPOS;
      while (inclPath.Tokenize(inclDir, pos, GetOwner()->GetDirDelimiter())) {
         if (clfile.BeginsWith(inclDir) && (longestMatch == kNPOS || inclDir.Length() > longestMatch))
            longestMatch = inclDir.Length();
      }
      if (longestMatch != kNPOS) {
         clfile.Remove(0, longestMatch);
         if (clfile.BeginsWith("/") || clfile.BeginsWith("\\"))
            clfile.Remove(0, 1);
         TString asincl(clfile);
         GetOwner()->GetPathDefinition().GetFileNameFromInclude(asincl, clfile);
         out_filename = clfile;
      } else {
         // header file without a -Iinclude-dir prefix
         filesysname = MatchFileSysName(out_filename, fse);
         if (filesysname[0]) {
            clfile = out_filename;
         }
      }
   } else {
      // check for a file named like the class:
      filesysname = cl->GetName();
      int templateLevel = 0;
      Ssiz_t end = filesysname.Length();
      Ssiz_t start = end - 1;
      for (; start >= 0 && (templateLevel || filesysname[start] != ':'); --start) {
         if (filesysname[start] == '>')
            ++templateLevel;
         else if (filesysname[start] == '<') {
            --templateLevel;
            if (!templateLevel)
               end = start;
         }
      }
      filesysname = filesysname(start + 1, end - start - 1);
      if (decl)
         filesysname += ".h";
      else
         filesysname += ".cxx";
      out_filename = filesysname;
      filesysname = MatchFileSysName(out_filename, fse);
      if (filesysname[0]) {
         clfile = out_filename;
      }
   }

   if (!decl && !clfile.Length()) {
      // determine possible impl file name from the decl file name,
      // replacing ".whatever" by ".cxx", and looking for it in the known
      // file names
      TString declSysFileName;
      if (GetFileName(cl, true, filesysname, declSysFileName)) {
         filesysname = gSystem->BaseName(filesysname);
         Ssiz_t posExt = filesysname.Last('.');
         if (posExt != kNPOS)
            filesysname.Remove(posExt);
         filesysname += ".cxx";
         out_filename = filesysname;
         filesysname = MatchFileSysName(out_filename, fse);
         if (filesysname[0]) {
            clfile = out_filename;
         }
      }
   }

   if (clfile.Length() && !decl) {
      // Do not return the source file for these packages, even though we can find them.
      // THtml needs to have the class description in the source file if it finds the
      // source file, and these classes have their class descriptions in the header files.
      // THtml needs to be improved to collect all of a class' documentation before writing
      // it out, so it can take the class doc from the header even though a source exists.
      static const char* vetoClasses[] = {"math/mathcore/", "math/mathmore/", "math/genvector/", 
                                          "math/minuit2/", "math/smatrix/"};
      for (unsigned int i = 0; i < sizeof(vetoClasses) / sizeof(char*); ++i) {
         if (clfile.Contains(vetoClasses[i])) {
            // of course there are exceptions from the exceptions:
            // TComplex and TRandom, TRandom1,...
            if (strcmp(cl->GetName(), "TComplex")
                && strcmp(cl->GetName(), "TMath")
                && strncmp(cl->GetName(), "TRandom", 7)) {
               out_filename = "";
               return false;
            } else break;
         }
      }
   }


   if (!clfile.Length()) {
      // determine possible decl file name from class + scope name:
      // A::B::C::myclass will result in possible file name myclass.h
      // in directory C/inc/
      out_filename = cl->GetName();
      if (!out_filename.Contains("::")) {
         out_filename = "";
         return false;
      }
      SplitClassIntoDirFile(out_filename, possiblePath, possibleFileName);

      // convert from Scope, class to module, filename.h
      if (possibleFileName.Length()) {
         if (decl)
            possibleFileName += ".h";
         else
            possibleFileName += ".cxx";
      }
      if (possiblePath.Length())
         possiblePath += "/";
      if (decl)
         possiblePath += "inc/";
      else
         possiblePath += "src/";
      out_filename = possiblePath + "/" + possibleFileName;
   } else {
      possiblePath = gSystem->DirName(clfile);
      possibleFileName = gSystem->BaseName(clfile);
   }

   if (possiblePath.Length())
      ExpandSearchPath(possiblePath);
   else possiblePath=".";

   out_fsys = gSystem->FindFile(possiblePath, possibleFileName, kReadPermission);
   if (out_fsys.Length()) {
      NormalizePath(out_fsys);
      return true;
   }
   out_filename = "";
   return false;
}

//______________________________________________________________________________
bool THtml::TPathDefinition::GetMacroPath(const TString& module, TString& out_dir) const
{
   // Determine the path to look for macros (see TDocMacroDirective) for
   // classes from a given module. If the path was sucessfully determined return true.
   // For ROOT, this directory is the "doc/macros" subdirectory of the module
   // directory; the path returned is GetDocDir(module) + "/macros".
   //
   // If your software cannot be mapped into this scheme then derive your
   // own class from TPathDefinition and pass it to THtml::SetPathDefinition().

   TString moduledoc;
   if (!GetDocDir(module, moduledoc))
      return false;
   if (moduledoc.EndsWith("\\"))
      moduledoc.Remove(moduledoc.Length() - 1);

   TString macropath(GetOwner()->GetMacroPath());
   TString macrodirpart;
   out_dir = "";
   Ssiz_t pos = 0;
   while (macropath.Tokenize(macrodirpart, pos, ":")) {
      out_dir += moduledoc + "/" + macrodirpart + ":";
   }
   return true;
}


//______________________________________________________________________________
bool THtml::TPathDefinition::GetDocDir(const TString& module, TString& doc_dir) const
{
   // Determine the module's documentation directory. If module is empty,
   // set doc_dir to the product's documentation directory.
   // If the path was sucessfuly determined return true.
   // For ROOT, this directory is the subdir "doc/" in the
   // module's path; the directory returned is module + "/doc".
   //
   // If your software cannot be mapped into this scheme then derive your
   // own class from TPathDefinition and pass it to THtml::SetPathDefinition().

   if (module.Length())
      doc_dir = module + "/";
   doc_dir += GetOwner()->GetPathInfo().fDocPath;
   return true;
}


//______________________________________________________________________________
bool THtml::TPathDefinition::GetIncludeAs(TClass* cl, TString& out_dir) const
{
   // Determine the path and filename used in an include statement for the
   // header file of the given class. E.g. the class ROOT::Math::Boost is
   // meant to be included as "Math/Genvector/Boost.h" - which is what
   // out_dir is set to. GetIncludeAs() returns whether the include 
   // statement's path was successfully determined.
   //
   // Any leading directory part that is part of fIncludePath (see SetIncludePath)
   // will be removed. For ROOT, leading "include/" is removed; everything after
   // is the include path. Only classes from TMVA are different; they are included
   // as TMVA/ClassName.h.
   //
   // If your software cannot be mapped into this scheme then derive your
   // own class from TPathDefinition and pass it to THtml::SetPathDefinition().

   out_dir = "";
   if (!cl || !GetOwner()) return false;

   const char* clname = cl->GetName();
   TString hdr;
   if (!GetOwner()->GetDeclFileName(cl, kFALSE, hdr))
      return false;

   out_dir = hdr;
   bool includePathMatches = false;
   TString tok;
   Ssiz_t pos = 0;
   while (!includePathMatches && GetOwner()->GetPathInfo().fIncludePath.Tokenize(tok, pos, THtml::GetDirDelimiter()))
      if (out_dir.BeginsWith(tok)) {
         out_dir = hdr(tok.Length(), hdr.Length());
         if (out_dir[0] == '/' || out_dir[0] == '\\')
            out_dir.Remove(0, 1);
         includePathMatches = true;
      }

   if (!includePathMatches) {
      // We probably have a file super/module/inc/optional/filename.h.
      // That gets translated into optional/filename.h.
      // Assume that only one occurrence of "/inc/" exists in hdr.
      // If /inc/ is not part of the include file name then
      // just return the full path.
      // If we have matched any include path then this ROOT-only
      // algorithm is skipped!
      Ssiz_t posInc = hdr.Index("/inc/");
      if (posInc == kNPOS) return true;
      hdr.Remove(0, posInc + 5);
      out_dir = hdr;

      // TMVA and RooStats special treatment:
      // TMVA::Whatever claims to be in in math/tmva/inc/Whatever.h
      // but it needs to get included as TMVA/Whatever.h
      if (strstr(clname, "TMVA::"))
         out_dir.Prepend("TMVA/");
      if (strstr(clname, "RooStats::"))
         out_dir.Prepend("RooStats/");
   }

   return (out_dir.Length());
}


//______________________________________________________________________________
bool THtml::TPathDefinition::GetFileNameFromInclude(const char* included, TString& out_fsname) const
{
   // Set out_fsname to the full pathname corresponding to a file
   // included as "included". Return false if this file cannot be determined
   // or found. For ROOT, out_fsname corresponds to included prepended with
   // "include"; only THtml prefers to work on the original files, e.g.
   // core/base/inc/TObject.h instead of include/TObject.h, so the
   // default implementation searches the TFileSysDB for an entry with
   // basename(included) and with matching directory part, setting out_fsname
   // to the TFileSysEntry's path.

   if (!included) return false;

   out_fsname = included;

   if (!strncmp(included, "TMVA/", 5)) {
      out_fsname.Remove(0, 4);
      out_fsname.Prepend("tmva/inc");
      return true;
   }
   // special treatment for roostats (same as in TMVA) 
   if (!strncmp(included, "RooStats/", 9)) {
      out_fsname.Remove(0, 8);
      out_fsname.Prepend("roofit/roostats/inc");
      return true;
   }

   TString incBase(gSystem->BaseName(included));
   TList* bucket = GetOwner()->GetLocalFiles()->GetEntries().GetListForObject(incBase);
   if (!bucket) return false;

   TString alldir(gSystem->DirName(included));
   TObjArray* arrSubDirs = alldir.Tokenize("/");
   TIter iEntry(bucket);
   TFileSysEntry* entry = 0;
   while ((entry = (TFileSysEntry*) iEntry())) {
      if (incBase != entry->GetName()) continue;
      // find entry with matching enclosing directory
      THtml::TFileSysDir* parent = entry->GetParent();
      for (int i = arrSubDirs->GetEntries() - 1; parent && i >= 0; --i) {
         const TString& subdir(((TObjString*)(*arrSubDirs)[i])->String());
         if (!subdir.Length() || subdir == ".")
            continue;
         if (subdir == parent->GetName())
            parent = parent->GetParent();
         else parent = 0;
      }
      if (parent) {
         // entry found!
         entry->GetFullName(out_fsname, kFALSE);
         delete arrSubDirs;
         return true;
      }
   }
   delete arrSubDirs;
   return false;
}

//______________________________________________________________________________
void THtml::TFileSysDir::Recurse(TFileSysDB* db, const char* path)
{
   // Recursively fill entries by parsing the contents of path.

   TString dir(path);
   if (gDebug > 0 || GetLevel() < 2)
      Info("Recurse", "scanning %s...", path);
   TPMERegexp regexp(db->GetIgnore());
   dir += "/";
   void* hDir = gSystem->OpenDirectory(dir);
   const char* direntry = 0;
   while ((direntry = gSystem->GetDirEntry(hDir))) {
      if (!direntry[0] || direntry[0] == '.' || regexp.Match(direntry)) continue;
      TString entryPath(dir + direntry);
      if (gSystem->AccessPathName(entryPath, kReadPermission))
         continue;
      FileStat_t buf;
      gSystem->GetPathInfo(entryPath, buf);
      if (R_ISDIR(buf.fMode)) {
         // skip if we would nest too deeply,  and skip soft links:
         if (GetLevel() > db->GetMaxLevel()
#ifndef R__WIN32
             || db->GetMapIno().GetValue(buf.fIno)
#endif
             ) continue;
         TFileSysDir* subdir = new TFileSysDir(direntry, this);
         fDirs.Add(subdir);
#ifndef R__WIN32
         db->GetMapIno().Add(buf.fIno, (Long_t)subdir);
#endif
         subdir->Recurse(db, entryPath);
      } else {
         int delen = strlen(direntry);
         // only .cxx and .h are taken
         if (strcmp(direntry + delen - 4, ".cxx")
             && strcmp(direntry + delen - 2, ".h"))
            continue;
         TFileSysEntry* entry = new TFileSysEntry(direntry, this);
         db->GetEntries().Add(entry);
         fFiles.Add(entry);
      }
   } // while dir entry
   gSystem->FreeDirectory(hDir);
}


//______________________________________________________________________________
void THtml::TFileSysDB::Fill()
{
   // Recursively fill entries by parsing the path specified in GetName();
   // can be a THtml::GetDirDelimiter() delimited list of paths.

   TString dir;
   Ssiz_t posPath = 0;
   while (fName.Tokenize(dir, posPath, THtml::GetDirDelimiter())) {
      if (gSystem->AccessPathName(dir, kReadPermission)) {
         Warning("Fill", "Cannot read InputPath \"%s\"!", dir.Data());
         continue;
      }
      FileStat_t buf;
      gSystem->GetPathInfo(dir, buf);
      if (R_ISDIR(buf.fMode)) {
#ifndef R__WIN32
         TFileSysRoot* prevroot = (TFileSysRoot*) GetMapIno().GetValue(buf.fIno);
         if (prevroot != 0) {
            Warning("Fill", "InputPath \"%s\" already present as \"%s\"!", dir.Data(), prevroot->GetName());
            continue;
         }
#endif
         TFileSysRoot* root = new TFileSysRoot(dir, this);
         fDirs.Add(root);
#ifndef R__WIN32
         GetMapIno().Add(buf.fIno, (Long_t)root);
#endif
         root->Recurse(this, dir);
      } else {
         Warning("Fill", "Cannot read InputPath \"%s\"!", dir.Data());
      }
   }
}


////////////////////////////////////////////////////////////////////////////////
/* BEGIN_HTML
<p>The THtml class is designed to easily document
classes, code, and code related text files (like change logs). It generates HTML 
pages conforming to the XHTML 1.0 transitional specifications; an example of 
these pages is ROOT's own <a href="http://root.cern.ch/root/html/ClassIndex.html">
reference guide</a>. This page was verified to be valid XHTML 1.0 transitional, 
which proves that all pages generated by THtml can be valid, as long as the user 
provided XHTML (documentation, header, etc) is valid. You can check the current 
THtml by clicking this icon: 
<a href="http://validator.w3.org/check?uri=referer"><img
        src="http://www.w3.org/Icons/valid-xhtml10"
        alt="Valid XHTML 1.0 Transitional" height="31" width="88" style="border: none;"/></a></p>
Overview:
<ol style="list-style-type: upper-roman;">
  <li><a href="#usage">Usage</a></li>
  <li><a href="#conf">Configuration</a>
  <ol><li><a href="#conf:input">Input files</a></li>
  <li><a href="#conf:output">Output directory</a></li>
  <li><a href="#conf:liblink">Linking other documentation</a></li>
  <li><a href="#conf:classdoc">Recognizing class documentation</a></li>
  <li><a href="#conf:tags">Author, copyright, etc.</a></li>
  <li><a href="#conf:header">Header and footer</a></li>
  <li><a href="#conf:search">Links to searches, home page, ViewVC</a></li>
  <li><a href="#conf:charset">HTML Charset</a></li>
  </ol></li>
  <li><a href="#syntax">Documentation syntax</a>
  <ol><li><a href="#syntax:classdesc">Class description</a></li>
  <li><a href="#syntax:classidx">Class index</a></li>
  <li><a href="#syntax:meth">Method documentation</a></li>
  <li><a href="#syntax:datamem">Data member documentation</a></li>
  </ol></li>
  <li><a href="#directive">Documentation directives</a>
  <ol><li><a href="#directive:html"><tt>BEGIN<!-- -->_HTML</tt> <tt>END<!-- -->_HTML</tt>: include 'raw' HTML</a></li>
  <li><a href="#directive:macro"><tt>BEGIN<!-- -->_MACRO</tt> <tt>END<!-- -->_MACRO</tt>: include a picture generated by a macro</a></li>
  <li><a href="#directive:latex"><tt>BEGIN<!-- -->_LATEX</tt> <tt>END<!-- -->_LATEX</tt>: include a latex picture</a></li>
  </ol></li>
  <li><a href="#index">Product and module index</a></li>
  <li><a href="#aux">Auxiliary files: style sheet, JavaScript, help page</a></li>
  <li><a href="#charts">Class Charts</a></li>
  <li><a href="#confvar">Configuration variables</a></li>
  <li><a href="#how">Behind the scenes</a></li>
</ol>


<h3><a name="usage">I. Usage</a></h3>
These are typical things people do with THtml:
<pre>
    root[] <a href="http://root.cern.ch/root/html/THtml.html">THtml</a> html;                // create a <a href="http://root.cern.ch/root/html/THtml.html">THtml</a> object
    root[] html.MakeAll();             // generate documentation for all changed classes
</pre>
or to run on just a few classes:
<pre>
    root[] <a href="http://root.cern.ch/root/html/THtml.html">THtml</a> html;                // create a <a href="http://root.cern.ch/root/html/THtml.html">THtml</a> object
    root[] html.MakeIndex();           // create auxilliary files (style sheet etc) and indices
    root[] html.MakeClass("TMyClass"); // create documentation for TMyClass only
</pre>
To "beautify" (i.e. create links to documentation for class names etc) some text 
file or macro, use:
<pre>
    root[] html.Convert( "hsimple.C", "Histogram example" )
</pre>


<h3><a name="conf">II. Configuration</a></h3>
Most configuration options can be set as a call to THtml, or as a TEnv variable,
which you can set in your .rootrc.

<h4><a name="conf:input">II.1 Input files</a></h4>

<p>In your .rootrc, define Root.Html.SourceDir to point to directories containing 
.cxx and .h files (see: <a href="http://root.cern.ch/root/html/TEnv.html">TEnv</a>) 
of the classes you want to document, or call THtml::SetInputDir()</p>

<p>Example:</p><pre>
  Root.Html.SourceDir:  .:src:include
  Root.Html.Root:       http://root.cern.ch/root/html</pre>


<h4><a name="conf:output">II.2 Output directory</a></h4>

<p>The output directory can be specified using the Root.Html.OutputDir
configuration variable (default value: "htmldoc"). If that directory 
doesn't exist <a href="http://root.cern.ch/root/html/THtml.html">THtml</a>
will create it.</p>

<p>Example:</p><pre>
  Root.Html.OutputDir:         htmldoc</pre>

<h4><a name="conf:liblink">II.3 Linking other documentation</a></h4>

<p>When trying to document a class, THtml searches for a source file in 
the directories set via SetInputDir(). If it cannot find it, it assumes
that this class must have been documented before. Based on the library
this class is defined in, it checks the configuration variable
<tt>Root.Html.LibName</tt>, and creates a link using its value.
Alternatively, you can set these URLs via THtml::SetLibURL().</p>

<p>Example:<br/>
If a class MyClass is defined in class mylibs/libMyLib.so, and .rootrc
contains</p><pre>
  Root.Html.MyLib: ../mylib/</pre>
<p>THtml will create a link to "../mylib/MyClass.html".</p>

<p>The library name association can be set up using the rootmap facility.
For the library in the example above, which contains a dictionary 
generated from the linkdef MyLinkdef.h, the command to generate the
rootmap file is</p>
<pre>  $ rlibmap -f -r rootmap -l mylib/libMyLib.so -d libCore.so -c MyLinkdef.h</pre>
<p>Here, <tt>-r</tt> specifies that the entries for libMyLib should be updated,
<tt>-l</tt> specifies the library we're dealing with, <tt>-d</tt> its 
dependencies, and <tt>-c</tt> its linkdef. The rootmap file must be within
one of the <tt>LD_LIBRARY_PATH</tt> (or <tt>PATH</tt> for Windows) directories
when ROOT is started, otherwise ROOT will not use it.</p>

<h4><a name="conf:classdoc">II.4 Recognizing class documentation</a></h4>

<p>The class documentation has to appear in the header file containing the
class, right in front of its declaration. It is introduced by a string
defined by Root.Html.Description or SetClassDocTag(). See the section on 
<a href="#syntax">documentation syntax</a> for further details.</p>

<p>Example:</p><pre>
  Root.Html.Description:       //____________________</pre>

<p>The class documentation will show which include statement is to be used 
and which library needs to be linked to access it.
The include file name is determined via 
<a href="http://root.cern.ch/root/html/TClass.html#TClass:GetDeclFileName">
TClass::GetDeclFileName()</a>;
leading parts are removed if they match any of the ':' separated entries in 
THtml::GetIncludePath().</p>

<h4><a name="conf:tags">II.5 Author, copyright, etc.</a></h4>

<p>During the conversion, 
<a href="http://root.cern.ch/root/html/THtml.html">THtml</a> will look for 
some strings ("tags") in the source file, which have to appear right in
front of e.g. the author's name, copyright notice, etc. These tags can be
defined with the following environment variables: Root.Html.Author,
Root.Html.LastUpdate and Root.Html.Copyright, or with
SetAuthorTag(), SetLastUpdateTag(), SetCopyrightTag().</p>

<p>If the LastUpdate tag is not found, the current date and time are used.
This is useful when using
<a href="http://root.cern.ch/root/html/THtml.html#THtml:MakeAll">THtml::MakeAll()</a>'s 
default option force=kFALSE, in which case 
<a href="http://root.cern.ch/root/html/THtml.html">THtml</a> generates 
documentation only for changed classes.</p>

Authors can be a comma separated list of author entries. Each entry has
one of the following two formats
<ul><li><tt>Name (non-alpha)</tt>.
<p><a href="http://root.cern.ch/root/html/THtml.html">THtml</a> will generate an 
HTML link for <tt>Name</tt>, taking the Root.Html.XWho configuration
variable (defaults to "http://consult.cern.ch/xwho/people?") and adding 
all parts of the name with spaces replaces by '+'. Non-alphanumerical 
characters are printed out behind <tt>Name</tt>.</p>

<p>Example:</p>
<tt>// Author: Enrico Fermi</tt> appears in the source file.
<a href="http://root.cern.ch/root/html/THtml.html">THtml</a> will generate the link
<tt>http://consult.cern.ch/xwho/people?Enrico+Fermi</tt>. This works well for
people at CERN.</li>

<li><tt>Name &lt;link&gt; Info</tt>.
<p><a href="http://root.cern.ch/root/html/THtml.html">THtml</a> will generate 
an HTML link for <tt>Name</tt> as specified by <tt>link</tt> and print 
<tt>Info</tt> behind <tt>Name</tt>.</p>

<p>Example:</p>
<tt>// Author: Enrico Fermi &lt;http://www.enricos-home.it&gt;</tt> or<br/>
<tt>// Author: Enrico Fermi &lt;mailto:enrico@fnal.gov&gt;</tt> in the
source file. That's world compatible.</li>
</ul>

<p>Example (with defaults given):</p><pre>
      Root.Html.Author:     // Author:
      Root.Html.LastUpdate: // @(#)
      Root.Html.Copyright:  * Copyright
      Root.Html.XWho:       http://consult.cern.ch/xwho/people?</pre>


<h4><a name="conf:header">II.6 Header and footer</a></h4>

<p><a href="http://root.cern.ch/root/html/THtml.html">THtml</a> generates 
a default header and footer for all pages. You can
specify your own versions with the configuration variables Root.Html.Header
and Root.Html.Footer, or by calling SetHeader(), SetFooter().
Both variables default to "", using the standard Root
versions. If it has a "+" appended, <a href="http://root.cern.ch/root/html/THtml.html">THtml</a> will
write both versions (user and root) to a file, for the header in the order
1st root, 2nd user, and for the footer 1st user, 2nd root (the root
versions containing "&lt;html&gt;" and &lt;/html&gt; tags, resp).</p>

<p>If you want to replace root's header you have to write a file containing
all HTML elements necessary starting with the &lt;doctype&gt; tag and ending with
(and including) the &lt;body&gt; tag. If you add your header it will be added
directly after Root's &lt;body&gt; tag. Any occurrence of the string <tt>%TITLE%</tt>
in the user's header file will be replaced by
a sensible, automatically generated title. If the header is generated for a
class, occurrences of <tt>%CLASS%</tt> will be replaced by the current class's name,
<tt>%SRCFILE%</tt> and <tt>%INCFILE%</tt> by the name of the source and header file, resp.
(as given by <a href="http://root.cern.ch/root/html/TClass.html#TClass:GetImplFileLine">TClass::GetImplFileName()</a>,
<a href="http://root.cern.ch/root/html/TClass.html#TClass:GetImplFileLine">TClass::GetDeclFileName()</a>).
If the header is not generated for a class, they will be replaced by "".</p>

<p>Root's footer starts with the tag &lt;!--SIGNATURE--&gt;. It includes the
author(s), last update, copyright, the links to the Root home page, to the
user home page, to the index file (ClassIndex.html), to the top of the page
and <tt>this page is automatically generated</tt> infomation. It ends with the
tags <tt>&lt;/body&gt;&lt;/html&gt;</tt>. If you want to replace it, 
<a href="http://root.cern.ch/root/html/THtml.html">THtml</a> will search for some
tags in your footer: Occurrences of the strings <tt>%AUTHOR%</tt>, <tt>%UPDATE%</tt>, and
<tt>%COPYRIGHT%</tt> are replaced by their
corresponding values before writing the html file. The <tt>%AUTHOR%</tt> tag will be
replaced by the exact string that follows Root.Html.Author, no link
generation will occur.</p>


<h4><a name="conf:search">II.7 Links to searches, home page, ViewVC</a></h4>

<p>Additional parameters can be set by Root.Html.Homepage (address of the
user's home page), Root.Html.SearchEngine (search engine for the class
documentation), Root.Html.Search (search URL, where %u is replaced by the 
referer and %s by the escaped search expression), and a ViewVC base URL 
Root.Html.ViewCVS. For the latter, the file name is appended or, if 
the URL contains %f, %f is replaced by the file name.
All values default to "".</p>

<p>Examples:</p><pre>
      Root.Html.Homepage:     http://www.enricos-home.it
      Root.Html.SearchEngine: http://root.cern.ch/root/Search.phtml
      Root.Html.Search:       http://www.google.com/search?q=%s+site%3A%u</pre>


<h4><a name="conf:charset">II.8 HTML Charset</a></h4>

<p>XHTML 1.0 transitional recommends the specification of the charset in the
content type meta tag, see e.g. <a href="http://www.w3.org/TR/2002/REC-xhtml1-20020801/">http://www.w3.org/TR/2002/REC-xhtml1-20020801/</a>
<a href="http://root.cern.ch/root/html/THtml.html">THtml</a> generates it for the HTML output files. It defaults to ISO-8859-1, and
can be changed using Root.Html.Charset.</p>

<p>Example:</p><pre>
      Root.Html.Charset:      EUC-JP</pre>

<h3><a name="syntax">III. Documentation syntax</a></h3>
<h4><a name="syntax:classdesc">III.1 Class description</a></h4>

<p>A class description block, which must be placed before the first
member function, has a following form:</p>
<pre>
////////////////////////////////////////////////////////////////
//                                                            //
// TMyClass                                                   //
//                                                            //
// This is the description block.                             //
//                                                            //
////////////////////////////////////////////////////////////////
</pre>
<p>The environment variable Root.Html.Description 
(see: <a href="http://root.cern.ch/root/html/TEnv.html">TEnv</a>) contains
the delimiter string (default value: <tt>//_________________</tt>). It means
that you can also write your class description block like this:</p>
<pre>
   //_____________________________________________________________
   // A description of the class starts with the line above, and
   // will take place here !
   //
</pre>
<p>Note that <b><i>everything</i></b> until the first non-commented line is considered
as a valid class description block.</p>

<h4><a name="syntax:classidx">III.2 Class index</a></h4>

<p>All classes to be documented will have an entry in the ClassIndex.html,
showing their name with a link to their documentation page and a miniature
description. This discription for e.g. the class MyClass has to be given
in MyClass's header as a comment right after ClassDef(MyClass, n).</p>

<h4><a name="syntax:meth">III.3 Method documentation</a></h4>
<p>A member function description block starts immediately after '{'
and looks like this:</p>
<pre>
   void TWorld::HelloWorldFunc(string *text)
   {
      // This is an example of description for the
      // TWorld member function

      helloWorld.Print( text );
   }
</pre>
Like in a class description block, <b><i>everything</i></b> until the first
non-commented line is considered as a valid member function
description block.

If the rootrc variable <tt>Root.Html.DescriptionStyle</tt> is set to 
<tt>Doc++</tt> THtml will also look for method documentation in front of
the function implementation. This feature is not recommended; source code
making use of this does not comply to the ROOT documentation standards, which
means future versions of THtml might not support it anymore.

<h4><a name="syntax:datamem">III.4 Data member documentation</a></h4>

<p>Data members are documented by putting a C++ comment behind their 
declaration in the header file, e.g.</p>
<pre>
   int fIAmADataMember; // this is a data member
</pre>


<h3><a name="directive">IV. Documentation directives</a></h3>
<em>NOTE that THtml does not yet support nested directives 
(i.e. latex inside html etc)!</em>

<h4><a name="directive:html">IV.1 <tt>BEGIN<!-- -->_HTML</tt> <tt>END<!-- -->_HTML</tt>: include 'raw' HTML</a></h4>

<p>You can insert pure html code into your documentation comments. During the
generation of the documentation, this code will be inserted as is
into the html file.</p>
<p>Pure html code must be surrounded by the keywords 
<tt>BEGIN<!-- -->_HTML</tt> and <tt>END<!-- -->_HTML</tt>, where the
case is ignored.
An example of pure html code is this class description you are reading right now.
THtml uses a 
<a href="http://root.cern.ch/root/html/TDocHtmlDirective.html">TDocHtmlDirective</a>
object to process this directive.</p>

<h4><a name="directive:macro">IV.2 <tt>BEGIN<!-- -->_MACRO</tt> <tt>END<!-- -->_MACRO</tt>: include a picture generated by a macro</a></h4>

<p>THtml can create images from scripts. You can either call an external 
script by surrounding it by "begin_macro"/"end_macro", or include an unnamed
macro within these keywords. The macro should return a pointer to an object;
this object will then be saved as a GIF file.</p>
<p>Objects deriving from 
<a href="http://root.cern.ch/root/html/TGObject.html">TGObject</a> (GUI elements)
will need to run in graphics mode (non-batch). You must specify this as a parameter:
"Begin_macro(GUI)...".
To create a second tab that displays the source of the macro you can specify
the argument "Begin_macro(source)...".
Of course you can combine them,
e.g. as "Begin_macro(source,gui)...". 
THtml uses a 
<a href="http://root.cern.ch/root/html/TDocMacroDirective.html">TDocMacroDirective</a>
object to process this directive.</p>
<p>This is an example:</p> END_HTML
BEGIN_MACRO(source)
{
  TCanvas* macro_example_canvas = new TCanvas("macro_example_canvas", "", 150, 150);
  macro_example_canvas->SetBorderSize(0);
  macro_example_canvas->SetFillStyle(1001);
  macro_example_canvas->SetFillColor(kWhite);
  macro_example_canvas->cd();
  TArc* macro_example_arc = new TArc(0.5,0.32,0.11,180,360);
  macro_example_arc->Draw();
  TEllipse* macro_example_ellipsis = new TEllipse(0.42,0.58,0.014,0.014,0,360,0);
  macro_example_ellipsis->SetFillStyle(0);
  macro_example_ellipsis->Draw();
  macro_example_ellipsis = new TEllipse(0.58,0.58,0.014,0.014,0,360,0);
  macro_example_ellipsis->SetFillStyle(0);
  macro_example_ellipsis->Draw();
  macro_example_ellipsis = new TEllipse(0.50,0.48,0.22,0.32,0,360,0);
  macro_example_ellipsis->SetFillStyle(0);
  macro_example_ellipsis->Draw();
  TLine* macro_example_line = new TLine(0.48,0.53,0.52,0.41);
  macro_example_line->Draw();
  return macro_example_canvas;
}
END_MACRO

BEGIN_HTML
<h4><a name="directive:latex">IV.3 <tt>BEGIN<!-- -->_LATEX</tt> <tt>END<!-- -->_LATEX</tt>: include a latex picture</a></h4>

<p>You can specify <a href="http://root.cern.ch/root/html/TLatex.html">TLatex</a>
style text and let THtml convert it into an image by surrounding it by "Begin_Latex", "End_Latex".
You can have multiple lines, and e.g. align each line at the '=' sign by passing
the argument <tt>separator='='</tt>. You can also specify how to align these parts;
if you want the part left of the separator to be right aligned, and the right part
to be left aligned, you could specify <tt>align='rl'</tt>. 
THtml uses a <a href="http://root.cern.ch/root/html/TDocLatexDirective.html">TDocLatexDirective</a>
object to process the directive.
This is an example output with arguments <tt>separator='=', align='rl'</tt>:</p>
END_HTML BEGIN_LATEX(separator='=', align='rl')#kappa(x)^{2}=sin(x)^{x}
x=#chi^{2} END_LATEX

BEGIN_HTML

<h3><a name="index">V. Product and module index</a></h3>

<p><a href="#THtml:MakeIndex">THtml::MakeIndex()</a> will generate index files for classes
and types, all modules, and the product which you can set by 
<a href="#THtml:SetProductName">THtml::SetProductName()</a>.
THtml will make use of external documentation in the module and product index,
either by linking it or by including it.
For the product THtml will include files found in the directory defined by
<a href="#THtml:SetProductDocDir">THtml::SetProductDocDir()</a>.
The files for modules are searched based on the source file directory of the 
module's classes; the (possibly relative) path set by 
<a href="#THtml:SetModuleDocPath">THtml::SetModuleDocPath()</a> will guide THtml
to the files.</p>

<p>A filename starting with "index." will be included in the index page;
all other files will be linked.
Only files ending on <tt>.html</tt> or <tt>.txt</tt> will be taken into account;
the text files will first be run through 
<a href="#THtml:Convert">THtml::Convert()</a>.
You can see an example <a href="http://root.cern.ch/root/html/HIST_Index.html">here</a>;
the part between "Index of HIST classes" and "Jump to" is created by parsing
the module's doc directory.</p>

<h3><a name="aux">VI. Auxiliary files: style sheet, JavaScript, help page</a></h3>

<p>The documentation pages share a common set of javascript and CSS files. They
are generated automatically when running <a href="#THtml:MakeAll">MakeAll()</a>; 
they can be generated on 
demand by calling <a href="#THtml:CreateAuxiliaryFiles">CreateAuxiliaryFiles()</a>.</p>


<h3><a name="charts">VII. Class Charts</a></h3>
THtml can generate a number of graphical representations for a class, which
are displayed as a tabbed set of imaged ontop of the class description.
It can show the inheritance, inherited and hidden members, directly and 
indirectly included files, and library dependencies.

These graphs are generated using the <a href="http://www.graphviz.org/">Graphviz</a>
package. You can install it from <a href="http://www.graphviz.org">http://www.graphviz.org</a>.
You can either put it into your $PATH, or tell THtml where to find it by calling
<a href="#THtml:SetDotDir">SetDotDir()</a>.


<h3><a name="confvar">VIII. Configuration variables</a></h3>

<p>Here is a list of all configuration variables that are known to THtml.
You can set them in your .rootrc file, see 
<a href="http://root.cern.ch/root/html/TEnv.html">TEnv</a>.</p>

<pre>
  Root.Html.OutputDir    (default: htmldoc)
  Root.Html.SourceDir    (default: .:src/:include/)
  Root.Html.Author       (default: // Author:) - start tag for authors
  Root.Html.LastUpdate   (default: // @(#)) - start tag for last update
  Root.Html.Copyright    (default:  * Copyright) - start tag for copyright notice
  Root.Html.Description  (default: //____________________ ) - start tag for class descr
  Root.Html.HomePage     (default: ) - URL to the user defined home page
  Root.Html.Header       (default: ) - location of user defined header
  Root.Html.Footer       (default: ) - location of user defined footer
  Root.Html.Root         (default: ) - URL of Root's class documentation
  Root.Html.SearchEngine (default: ) - link to the search engine
  Root.Html.Search       (defualt: ) - link to search by replacing "%s" with user input
  Root.Html.ViewCVS      (default: ) - URL of ViewCVS base
  Root.Html.XWho         (default: http://consult.cern.ch/xwho/people?) - URL of CERN's xWho
  Root.Html.Charset      (default: ISO-8859-1) - HTML character set
</pre>

<h3><a name="how">IX. Behind the scene</a></h3>

<p>Internally, THtml is just an API class that sets up the list of known
classes, and forwards API invocations to the "work horses".
<a href="http://root.cern.ch/root/html/TDocOutput.html">TDocOutput</a>
generates the output by letting a
<a href="http://root.cern.ch/root/html/TDocParser.html">TDocParser</a>
object parse the sources, which in turn invokes objects deriving from
<a href="http://root.cern.ch/root/html/TDocDirective.html">TDocDirective</a>
to process directives.</p>

END_HTML */
////////////////////////////////////////////////////////////////////////////////

ClassImp(THtml)
//______________________________________________________________________________
THtml::THtml():
   fCounterFormat("%12s %5s %s"),
   fProductName("(UNKNOWN PRODUCT)"),
   fThreadedClassIter(0), fMakeClassMutex(0),
   fGClient(0), fPathDef(0), fModuleDef(0), fFileDef(0),
   fLocalFiles(0), fBatch(kFALSE)
{
   // Create a THtml object.
   // In case output directory does not exist an error
   // will be printed and gHtml stays 0 also zombie bit will be set.

   // check for source directory
   fPathInfo.fInputPath = gEnv->GetValue("Root.Html.SourceDir", "./:src/:include/");

   // check for output directory
   SetOutputDir(gEnv->GetValue("Root.Html.OutputDir", "htmldoc"));

   fLinkInfo.fXwho = gEnv->GetValue("Root.Html.XWho", "http://consult.cern.ch/xwho/people?");
   fLinkInfo.fROOTURL = gEnv->GetValue("Root.Html.Root", "http://root.cern.ch/root/html");
   fDocSyntax.fClassDocTag = gEnv->GetValue("Root.Html.Description", "//____________________");
   fDocSyntax.fAuthorTag = gEnv->GetValue("Root.Html.Author", "// Author:");
   fDocSyntax.fLastUpdateTag = gEnv->GetValue("Root.Html.LastUpdate", "// @(#)");
   fDocSyntax.fCopyrightTag = gEnv->GetValue("Root.Html.Copyright", "* Copyright");
   fOutputStyle.fHeader = gEnv->GetValue("Root.Html.Header", "");
   fOutputStyle.fFooter = gEnv->GetValue("Root.Html.Footer", "");
   fLinkInfo.fHomepage = gEnv->GetValue("Root.Html.Homepage", "");
   fLinkInfo.fSearchStemURL = gEnv->GetValue("Root.Html.Search", "");
   fLinkInfo.fSearchEngine = gEnv->GetValue("Root.Html.SearchEngine", "");
   fLinkInfo.fViewCVS = gEnv->GetValue("Root.Html.ViewCVS", "");
   fOutputStyle.fCharset = gEnv->GetValue("Root.Html.Charset", "ISO-8859-1");
   fDocSyntax.fDocStyle = gEnv->GetValue("Root.Html.DescriptionStyle", "");

   fDocEntityInfo.fClasses.SetOwner();
   fDocEntityInfo.fModules.SetOwner();
   // insert html object in the list of special ROOT objects
   if (!gHtml) {
      gHtml = this;
      gROOT->GetListOfSpecials()->Add(gHtml);
   }

}


//______________________________________________________________________________
THtml::~THtml()
{
// Default destructor

   fDocEntityInfo.fClasses.Clear();
   fDocEntityInfo.fModules.Clear();
   if (gHtml == this) {
      gROOT->GetListOfSpecials()->Remove(gHtml);
      gHtml = 0;
   }
   delete fPathDef;
   delete fModuleDef;
   delete fFileDef;
   delete fLocalFiles;
}

//______________________________________________________________________________
void THtml::AddMacroPath(const char* path)
{
   // Add path to the directories to be searched for macro files
   // that are to be executed via the TDocMacroDirective
   // ("Begin_Macro"/"End_Macro"); relative to the source file
   // that the directive is run on.

   const char pathDelimiter = 
#ifdef R__WIN32
      ';';
#else
      ':';
#endif
   fPathInfo.fMacroPath += pathDelimiter;
   fPathInfo.fMacroPath += path;
}


//______________________________________________________________________________
void THtml::CreateAuxiliaryFiles() const
{
   // copy CSS, javascript file, etc to the output dir
   CreateJavascript();
   CreateStyleSheet();
   CopyFileFromEtcDir("HELP.html");
}

//______________________________________________________________________________
const THtml::TModuleDefinition& THtml::GetModuleDefinition() const
{
   // Return the TModuleDefinition (or derived) object as set by
   // SetModuleDefinition(); create and return a TModuleDefinition object
   // if none was set.
   if (!fModuleDef) {
      fModuleDef = new TModuleDefinition();
      fModuleDef->SetOwner(const_cast<THtml*>(this));
   }
   return *fModuleDef;
}

//______________________________________________________________________________
const THtml::TFileDefinition& THtml::GetFileDefinition() const
{
   // Return the TFileDefinition (or derived) object as set by
   // SetFileDefinition(); create and return a TFileDefinition object
   // if none was set.
   if (!fFileDef) {
      fFileDef = new TFileDefinition();
      fFileDef->SetOwner(const_cast<THtml*>(this));
   }
   return *fFileDef;
}

//______________________________________________________________________________
const THtml::TPathDefinition& THtml::GetPathDefinition() const
{
   // Return the TModuleDefinition (or derived) object as set by
   // SetModuleDefinition(); create and return a TModuleDefinition object
   // if none was set.
   if (!fPathDef) {
      fPathDef = new TPathDefinition();
      fPathDef->SetOwner(const_cast<THtml*>(this));
   }
   return *fPathDef;
}


//______________________________________________________________________________
const char* THtml::GetEtcDir() const
{
// Get the directory containing THtml's auxiliary files ($ROOTSYS/etc/html)

   if (fPathInfo.fEtcDir.Length())
      return fPathInfo.fEtcDir;

   R__LOCKGUARD(GetMakeClassMutex());

   fPathInfo.fEtcDir = "html";

#ifdef ROOTETCDIR
   gSystem->PrependPathName(ROOTETCDIR, fPathInfo.fEtcDir);
#else
   gSystem->PrependPathName("etc", fPathInfo.fEtcDir);
# ifdef ROOTPREFIX
   gSystem->PrependPathName(ROOTPREFIX, fPathInfo.fEtcDir);
# else
   if (getenv("ROOTSYS"))
      gSystem->PrependPathName(getenv("ROOTSYS"), fPathInfo.fEtcDir);
# endif
#endif

   return fPathInfo.fEtcDir;
}


//______________________________________________________________________________
TClassDocInfo *THtml::GetNextClass()
{
   // Return the next class to be generated for MakeClassThreaded.

   if (!fThreadedClassIter) return 0;

   R__LOCKGUARD(GetMakeClassMutex());

   TClassDocInfo* classinfo = 0;
   while ((classinfo = (TClassDocInfo*)(*fThreadedClassIter)())
          && !classinfo->IsSelected()) { }

   if (!classinfo) {
      delete fThreadedClassIter;
      fThreadedClassIter = 0;
   }

   fCounter.Form("%5d", fDocEntityInfo.fClasses.GetSize() - fThreadedClassCount++);

   return classinfo;
}


//______________________________________________________________________________
const char* THtml::GetURL(const char* lib /*=0*/) const
{
   // Get the documentation URL for library lib.
   // If lib == 0 or no documentation URL has been set for lib, return the ROOT 
   // documentation URL. The return value is always != 0.

   R__LOCKGUARD(GetMakeClassMutex());

   if (lib && strlen(lib)) {
      std::map<std::string, TString>::const_iterator iUrl = fLinkInfo.fLibURLs.find(lib);
      if (iUrl != fLinkInfo.fLibURLs.end()) return iUrl->second;
      return gEnv->GetValue(TString("Root.Html.") + lib, fLinkInfo.fROOTURL);
   }
   return fLinkInfo.fROOTURL;
}

//______________________________________________________________________________
Bool_t THtml::HaveDot()
{
   // Check whether dot is available in $PATH or in the directory set 
   // by SetDotPath()

   if (fPathInfo.fFoundDot != PathInfo_t::kDotUnknown) 
      return (fPathInfo.fFoundDot == PathInfo_t::kDotFound);

   R__LOCKGUARD(GetMakeClassMutex());

   Info("HaveDot", "Checking for Graphviz (dot)...");
   TString runDot("dot");
   if (fPathInfo.fDotDir.Length())
      gSystem->PrependPathName(fPathInfo.fDotDir, runDot);
   runDot += " -V";
   if (gDebug > 3)
      Info("HaveDot", "Running: %s", runDot.Data());
   if (gSystem->Exec(runDot)) {
      fPathInfo.fFoundDot = PathInfo_t::kDotNotFound;
      return kFALSE;
   }
   fPathInfo.fFoundDot = PathInfo_t::kDotFound;
   return kTRUE;

}

//______________________________________________________________________________
void THtml::HelperDeleted(THtml::THelperBase* who)
{
   // Inform the THtml object that one of its helper objects was deleted.
   // Called by THtml::HelperBase::~HelperBase().

   THelperBase* helpers[3] = {fPathDef, fModuleDef, fFileDef};
   for (int i = 0; who && i < 3; ++i)
      if (who == helpers[i])
         helpers[i] = who = 0;
}


//______________________________________________________________________________
void THtml::Convert(const char *filename, const char *title,
                    const char *dirname /*= ""*/, const char *relpath /*= "../"*/,
                    Int_t includeOutput /* = kNoOutput */,
                    const char* context /* = "" */)
{
// It converts a single text file to HTML
//
//
// Input: filename - name of the file to convert
//        title    - title which will be placed at the top of the HTML file
//        dirname  - optional parameter, if it's not specified, output will
//                   be placed in htmldoc/examples directory.
//        relpath  - optional parameter pointing to the THtml generated doc 
//                   on the server, relative to the current page.
//        includeOutput - if != kNoOutput, run the script passed as filename and
//                   store all created canvases in PNG files that are
//                   shown next to the converted source. Bitwise-ORing with 
//                   re-runs the script even if output PNGs exist that are newer
//                   than the script. If kCompiledOutput is passed, the script is
//                   run through ACLiC (.x filename+)
//        context  - line shown verbatim at the top of the page; e.g. for links.
//                   If context is non-empty it is expected to also print the
//                   title.
//
//  NOTE: Output file name is the same as filename, but with extension .html
//

   gROOT->GetListOfGlobals(kTRUE);        // force update of this list
   CreateListOfClasses("*");

   const char *dir;

   // if it's not defined, make the "examples" as a default directory
   if (!*dirname) {
      gSystem->ExpandPathName(fPathInfo.fOutputDir);
      dir = gSystem->ConcatFileName(fPathInfo.fOutputDir, "examples");
   } else
      dir = dirname;

   // create directory if necessary
   if (gSystem->AccessPathName(dir))
      gSystem->MakeDirectory(dir);

   // find a file
   char *cRealFilename =
       gSystem->Which(fPathInfo.fInputPath, filename, kReadPermission);

   if (!cRealFilename) {
      Error("Convert", "Can't find file '%s' !", filename);
      return;
   }

   TString realFilename(cRealFilename);
   delete[] cRealFilename;
   cRealFilename = 0;

   // open source file
   ifstream sourceFile;
   sourceFile.open(realFilename, ios::in);

   if (!sourceFile.good()) {
      Error("Convert", "Can't open file '%s' !", realFilename.Data());
      return;
   }

   if (gSystem->AccessPathName(dir)) {
      Error("Convert",
            "Directory '%s' doesn't exist, or it's write protected !", dir);
      return;
   }
   char *tmp1 =
       gSystem->ConcatFileName(dir, gSystem->BaseName(filename));

   TDocOutput output(*this);
   if (!fGClient)
      gROOT->ProcessLine(TString::Format("*((TGClient**)0x%lx) = gClient;",
                                         &fGClient));
   if (includeOutput && !fGClient)
      Warning("Convert", "Output requested but cannot initialize graphics: GUI  and GL windows not be available");
   output.Convert(sourceFile, realFilename, tmp1, title, relpath, includeOutput, context, fGClient);

   if (tmp1)
      delete[]tmp1;
   tmp1 = 0;
}

//______________________________________________________________________________
void  THtml::GetModuleNameForClass(TString& module, TClass* cl) const
{
   // Return the module name for a given class.
   // Use the cached information from fDocEntityInfo.fClasses.

   module = "(UNKNOWN)";
   TClassDocInfo* cdi = (TClassDocInfo*)fDocEntityInfo.fClasses.FindObject(cl->GetName());
   if (!cdi || !cdi->GetModule())
      return;
   module = cdi->GetModule()->GetName();
}


//______________________________________________________________________________
void THtml::CreateListOfClasses(const char* filter)
{
// Create the list of all known classes

   if (fDocEntityInfo.fClasses.GetSize() && fDocEntityInfo.fClassFilter == filter)
      return;

   Info("CreateListOfClasses", "Initializing - this might take a while...");
   // get total number of classes
   Int_t totalNumberOfClasses = gClassTable->Classes();

   // allocate memory
   fDocEntityInfo.fClasses.Clear();
   fDocEntityInfo.fModules.Clear();

   fDocEntityInfo.fClassFilter = filter;

   // start from begining
   gClassTable->Init();
   if (filter && (!filter[0] || !strcmp(filter, "*")))
      filter = ".*";
   TString reg = filter;
   TPMERegexp re(reg);

   bool skipROOTClasses = false;
   std::set<std::string> rootLibs;
   TList classesDeclFileNotFound;
   TList classesImplFileNotFound;

   // pre-run TObject at i == -1
   for (Int_t i = -1; i < totalNumberOfClasses; i++) {

      // get class name
      const char *cname = 0;
      if (i < 0) cname = "TObject";
      else cname = gClassTable->Next();

      // This is a hack for until after Cint and Reflex are one.
      if (strstr(cname, "__gnu_cxx::")) continue;

      // get class & filename - use TROOT::GetClass, as we also
      // want those classes without decl file name!
      TClass *classPtr = TClass::GetClass((const char *) cname, kTRUE);
      if (!classPtr) continue;

      std::string shortName(ShortType(cname));
      cname = shortName.c_str();

      TString s = cname;
      Bool_t matchesSelection = re.Match(s);


      TString hdr;
      TString hdrFS;
      TString src;
      TString srcFS;
      TString htmlfilename;
      TFileSysEntry* fse = 0;

      TClassDocInfo* cdi = (TClassDocInfo*) fDocEntityInfo.fClasses.FindObject(cname);
      if (cdi) {
         hdr = cdi->GetDeclFileName();
         hdrFS = cdi->GetDeclFileSysName();
         src = cdi->GetImplFileName();
         srcFS = cdi->GetImplFileSysName();
         htmlfilename = cdi->GetHtmlFileName();
      }

      if (!hdrFS.Length()) {
         if (!GetFileDefinition().GetDeclFileName(classPtr, hdr, hdrFS, &fse)) {
            // we don't even know where the class is defined;
            // just skip. Silence if it doesn't match the selection anyway
            if (i == -1 ) {
               skipROOTClasses = true;
               Info("CreateListOfClasses", "Cannot find header file for TObject at %s given the input path %s.",
                  classPtr->GetDeclFileName(), GetInputPath().Data());
               Info("CreateListOfClasses", "Assuming documentation is not for ROOT classes, or you need to pass "
                  "the proper directory to THtml::SetInputPath() so I can find %s.", classPtr->GetDeclFileName());
               continue;
            }
            // ignore STL
            if (classPtr->GetDeclFileName() && !strncmp(classPtr->GetDeclFileName(), "prec_stl/", 9))
               continue;
            if (skipROOTClasses) {
               if (classPtr->GetSharedLibs() && classPtr->GetSharedLibs()[0]) {
                  std::string lib(classPtr->GetSharedLibs());
                  size_t posSpace = lib.find(' ');
                  if (posSpace != std::string::npos)
                     lib.erase(posSpace);
                  if (rootLibs.find(lib) == rootLibs.end()) {
#ifdef ROOTLIBDIR
                     TString rootlibdir = ROOTLIBDIR;
#else
                     TString rootlibdir = "lib";
                     gSystem->PrependPathName(gRootDir, rootlibdir);
#endif
                     TString sLib(lib);
                     if (sLib.Index('.') == -1) {
                        sLib += ".";
                        sLib += gSystem->GetSoExt();
                     }
                     gSystem->PrependPathName(rootlibdir, sLib);
                     if (gSystem->AccessPathName(sLib))
                        // the library doesn't exist in $ROOTSYS/lib, so it's not
                        // a root lib and we need to tell the user.
                        classesDeclFileNotFound.AddLast(classPtr);
                     else rootLibs.insert(lib);
                  } // end "if rootLibs does not contain lib"
               } else {
                  // lib name unknown
                  static const char* rootClassesToIgnore[] =
                  { "ColorStruct_t", "CpuInfo_t", "Event_t", "FileStat_t", "GCValues_t", "MemInfo_t",
                     "PictureAttributes_t", "Point_t", "ProcInfo_t", "ROOT", "ROOT::Fit",
                     "Rectangle_t", "RedirectHandle_t", "Segment_t", "SetWindowAttributes_t",
                     "SysInfo_t", "TCint", "UserGroup_t", "WindowAttributes_t", "timespec", 0};
                  static const char* rootClassStemsToIgnore[] =
                  { "ROOT::Math", "TKDTree", "TMatrixT", "TParameter", "vector", 0 };
                  static size_t rootClassStemsToIgnoreLen[] = {0, 0, 0, 0, 0};
                  static std::set<std::string> setRootClassesToIgnore;
                  if (setRootClassesToIgnore.empty()) {
                     for (int ii = 0; rootClassesToIgnore[ii]; ++ii)
                        setRootClassesToIgnore.insert(rootClassesToIgnore[ii]);
                     for (int ii = 0; rootClassStemsToIgnore[ii]; ++ii)
                        rootClassStemsToIgnoreLen[ii] = strlen(rootClassStemsToIgnore[ii]);
                  }
                  // only complain about this class if it should not be ignored:
                  if (setRootClassesToIgnore.find(cname) == setRootClassesToIgnore.end()) {
                     bool matched = false;
                     for (int ii = 0; !matched && rootClassStemsToIgnore[ii]; ++ii)
                        matched = !strncmp(cname, rootClassStemsToIgnore[ii], rootClassStemsToIgnoreLen[ii]);
                     if (!matched)
                        classesDeclFileNotFound.AddLast(classPtr);
                  }
               } // lib name known
               continue;
            } else {
               if (matchesSelection && (!classPtr->GetDeclFileName() || !strstr(classPtr->GetDeclFileName(),"prec_stl/")))
                  classesDeclFileNotFound.AddLast(classPtr);
               continue;
            }
         }
      }

      Bool_t haveSource = (srcFS.Length());
      if (!haveSource)
         haveSource = GetFileDefinition().GetImplFileName(classPtr, src, srcFS, fse ? 0 : &fse);

      if (!haveSource) {
         classesImplFileNotFound.AddLast(classPtr);
      }

      if (!htmlfilename.Length())
         GetHtmlFileName(classPtr, htmlfilename);

      if (!cdi) {
         cdi = new TClassDocInfo(classPtr, htmlfilename, hdrFS, srcFS, hdr, src);
         fDocEntityInfo.fClasses.Add(cdi);
      } else {
         cdi->SetDeclFileName(hdr);
         cdi->SetImplFileName(src);
         cdi->SetDeclFileSysName(hdrFS);
         cdi->SetImplFileSysName(srcFS);
         cdi->SetHtmlFileName(htmlfilename);
      }

      cdi->SetSelected(matchesSelection);

      TString modulename;
      GetModuleDefinition().GetModule(classPtr, fse, modulename);
      if (!modulename.Length() || modulename == "USER") 
         GetModuleNameForClass(modulename, classPtr);
      
      TModuleDocInfo* module = (TModuleDocInfo*) fDocEntityInfo.fModules.FindObject(modulename);
      if (!module) {
         bool moduleSelected = cdi->IsSelected();

         TString parentModuleName(gSystem->DirName(modulename));
         TModuleDocInfo* super = 0;
         if (parentModuleName.Length() && parentModuleName != ".") {
            super = (TModuleDocInfo*) fDocEntityInfo.fModules.FindObject(parentModuleName);
            if (!super) {
               // create parents:
               TString token;
               Ssiz_t pos = 0;
               while (parentModuleName.Tokenize(token, pos, "/")) {
                  if (!token.Length() || token == ".") continue;
                  super = new TModuleDocInfo(token, super);
                  super->SetSelected(moduleSelected);
                  fDocEntityInfo.fModules.Add(super);
               }
            }
         }
         module = new TModuleDocInfo(modulename, super);
         module->SetSelected(moduleSelected);
         fDocEntityInfo.fModules.Add(module);
      }

      if (module) {
         module->AddClass(cdi);
         cdi->SetModule(module);
         if (cdi->HaveSource() && cdi->IsSelected())
            module->SetSelected();
      }

      // clear the typedefs; we fill them later
      cdi->GetListOfTypedefs().Clear();

      if (gDebug > 0)
         Info("CreateListOfClasses", "Adding class %s, module %s (%sselected)",
              cdi->GetName(), module ? module->GetName() : "[UNKNOWN]",
              cdi->IsSelected() ? "" : "not ");
   }



   bool cannotFind = false;
   if (!classesDeclFileNotFound.IsEmpty()) {
      Warning("CreateListOfClasses",
         "Cannot find the header for the following classes [reason]:");
      TIter iClassesDeclFileNotFound(&classesDeclFileNotFound);
      TClass* iClass = 0;
      while ((iClass = (TClass*)iClassesDeclFileNotFound())) {
         if (iClass->GetDeclFileName() && iClass->GetDeclFileName()[0]) {
            Warning("CreateListOfClasses", "   %s [header %s not found]", iClass->GetName(), iClass->GetDeclFileName());
            cannotFind = true;
         } else
            Warning("CreateListOfClasses", "   %s [header file is unknown]", iClass->GetName());
      }
   }

   if (!classesImplFileNotFound.IsEmpty() && gDebug > 3) {
      Warning("CreateListOfClasses",
         "Cannot find the source file for the following classes [reason]:");
      TIter iClassesDeclFileNotFound(&classesImplFileNotFound);
      TClass* iClass = 0;
      while ((iClass = (TClass*)iClassesDeclFileNotFound())) {
         if (iClass->GetDeclFileName() && iClass->GetDeclFileName()[0]) {
            Info("CreateListOfClasses", "   %s [source %s not found]", iClass->GetName(), iClass->GetImplFileName());
            cannotFind = true;
         } else
            Info("CreateListOfClasses", "   %s [source file is unknown, add \"ClassImpl(%s)\" to source file if it exists]",
               iClass->GetName(), iClass->GetName());
      }
   }
   if (cannotFind) {
      Warning("CreateListOfClasses", "THtml cannot find all headers and sources. ");
      Warning("CreateListOfClasses",
         "You might need to adjust the input path (currently %s) by calling THtml::SetInputDir()",
         GetInputPath().Data());
   }

   // fill typedefs
   TIter iTypedef(gROOT->GetListOfTypes());
   TDataType* dt = 0;
   TDocOutput output(*this);
   while ((dt = (TDataType*) iTypedef())) {
      if (dt->GetType() != -1) continue;
      TClassDocInfo* cdi = (TClassDocInfo*) fDocEntityInfo.fClasses.FindObject(dt->GetFullTypeName());
      if (cdi) {
         cdi->GetListOfTypedefs().Add(dt);
         if (gDebug > 1)
            Info("CreateListOfClasses", "Adding typedef %s to class %s",
                 dt->GetName(), cdi->GetName());

         bool inNamespace = true;
         TString surroundingNamespace(dt->GetName());
         Ssiz_t posTemplate = surroundingNamespace.Last('>');
         inNamespace = inNamespace && (posTemplate == kNPOS);
         if (inNamespace) {
            Ssiz_t posColumn = surroundingNamespace.Last(':');
            if (posColumn != kNPOS) {
               surroundingNamespace.Remove(posColumn - 1);
               TClass* clSurrounding = GetClass(surroundingNamespace);
               inNamespace = inNamespace && (!clSurrounding || IsNamespace(clSurrounding));
            }
         }
         if (inNamespace && cdi->GetModule()) {
            TString htmlfilename(dt->GetName());
            output.NameSpace2FileName(htmlfilename);
            htmlfilename += ".html";
            TClassDocInfo* cdiTD = new TClassDocInfo(dt, htmlfilename);
            cdiTD->SetModule(cdi->GetModule());
            cdiTD->SetSelected(cdi->IsSelected());
            cdi->GetModule()->AddClass(cdiTD);
         }
      }
   }

   fDocEntityInfo.fClasses.Sort();
   fDocEntityInfo.fModules.Sort();
   TIter iterModule(&fDocEntityInfo.fModules);
   TModuleDocInfo* mdi = 0;
   while ((mdi = (TModuleDocInfo*) iterModule()))
      mdi->GetClasses()->Sort();

   if (fProductName == "(UNKNOWN PRODUCT)" 
      && fDocEntityInfo.fModules.FindObject("core/base") 
      && fDocEntityInfo.fModules.FindObject("core/cont") 
      && fDocEntityInfo.fModules.FindObject("core/rint")
      && gProgName && strstr(gProgName, "root"))
      // if we have these modules we're probably building the root doc
      fProductName = "ROOT";

   if (fProductName == "(UNKNOWN PRODUCT)") {
      Warning("CreateListOfClasses", "Product not set. You should call gHtml->SetProduct(\"MyProductName\");");
   } else if (fProductName != "ROOT") {
      if (GetViewCVS().Contains("http://root.cern.ch/"))
         SetViewCVS("");
   }

   if (fDocEntityInfo.fModules.GetEntries() == 1
      && fDocEntityInfo.fModules.At(0)->GetName()
      && !strcmp(fDocEntityInfo.fModules.At(0)->GetName(), "(UNKNOWN)"))
      // Only one module, and its name is not known.
      // Let's call it "MAIN":
      ((TModuleDocInfo*) fDocEntityInfo.fModules.At(0))->SetName("MAIN");

   Info("CreateListOfClasses", "Initializing - DONE.");
}


//______________________________________________________________________________
void THtml::CreateListOfTypes()
{
// Create index of all data types and a page for each typedef-to-class

   TDocOutput output(*this);
   output.CreateTypeIndex();
   output.CreateClassTypeDefs();
}

//______________________________________________________________________________
Bool_t THtml::CopyFileFromEtcDir(const char* filename) const {
   // Copy a file from $ROOTSYS/etc/html into GetOutputDir()

   R__LOCKGUARD(GetMakeClassMutex());

   TString outFile(filename);

   TString inFile(outFile);
   gSystem->PrependPathName(GetEtcDir(), inFile);

   gSystem->PrependPathName(GetOutputDir(), outFile);

   if (gSystem->CopyFile(inFile, outFile, kTRUE) != 0) {
      Warning("CopyFileFromEtcDir", "Could not copy %s to %s", inFile.Data(), outFile.Data());
      return kFALSE;
   }

   return kTRUE;
}

//______________________________________________________________________________
void THtml::CreateHierarchy()
{
   // Create the inheritance hierarchy diagram for all classes
   TDocOutput output(*this);
   output.CreateHierarchy();
}

//______________________________________________________________________________
void THtml::CreateJavascript() const {
   // Write the default ROOT style sheet.
   CopyFileFromEtcDir("ROOT.js");
}

//______________________________________________________________________________
void THtml::CreateStyleSheet() const {
   // Write the default ROOT style sheet.
   CopyFileFromEtcDir("ROOT.css");
   CopyFileFromEtcDir("shadowAlpha.png");
   CopyFileFromEtcDir("shadow.gif");
}



//______________________________________________________________________________
void THtml::GetDerivedClasses(TClass* cl, std::map<TClass*, Int_t>& derived) const
{
   // fill derived with all classes inheriting from cl and their inheritance 
   // distance to cl

   TIter iClass(&fDocEntityInfo.fClasses);
   TClassDocInfo* cdi = 0;
   while ((cdi = (TClassDocInfo*) iClass())) {
      TClass* candidate = dynamic_cast<TClass*>(cdi->GetClass());
      if (!candidate) continue;
      if (candidate != cl && candidate->InheritsFrom(cl)) {
         Int_t level = 0;
         TClass* currentBaseOfCandidate = candidate;
         while (currentBaseOfCandidate != cl) {
            TList* bases = currentBaseOfCandidate->GetListOfBases();
            if (!bases) continue;
            TIter iBase(bases);
            TBaseClass* base = 0;
            while ((base = (TBaseClass*) iBase())) {
               TClass* clBase = base->GetClassPointer();
               if (clBase && clBase->InheritsFrom(cl)) {
                  ++level;
                  currentBaseOfCandidate = clBase;
               }
            }
         }
         derived[candidate] = level;
      }
   }
}

//______________________________________________________________________________
void THtml::GetHtmlFileName(TClass * classPtr, TString& filename) const
{
// Return real HTML filename
//
//
//  Input: classPtr - pointer to a class
//         filename - string containing a full name
//         of the corresponding HTML file after the function returns. 
//

   filename.Remove(0);
   if (!classPtr) return;

   TString cFilename;
   if (!GetImplFileName(classPtr, kFALSE, cFilename))
      GetDeclFileName(classPtr, kFALSE, cFilename);

   // classes without Impl/DeclFileName don't have docs,
   // and classes without docs don't have output file names
   if (!cFilename.Length())
      return;

   TString libName;
   const char *colon = strchr(cFilename, ':');
   if (colon)
      // old version, where source file name is prepended by "TAG:"
      libName = TString(cFilename, colon - cFilename);
   else
      // New version, check class's libname.
      // If libname is dir/libMyLib.so, check Root.Html.MyLib
      // If libname is myOtherLib.so.2.3, check Root.Html.myOtherLib
      // (i.e. remove directories, "lib" prefix, and any "extension")
      if (classPtr->GetSharedLibs()) {
         // first one is the class's lib
         TString libname(classPtr->GetSharedLibs());
         Ssiz_t posSpace = libname.First(' ');
         if (posSpace != kNPOS)
            libname.Remove(posSpace, libname.Length());
         TString libnameBase = gSystem->BaseName(libname);
         if (libnameBase.BeginsWith("lib"))
            libnameBase.Remove(0, 3);
         Ssiz_t posExt = libnameBase.First('.');
         if (posExt != '.')
            libnameBase.Remove(posExt, libnameBase.Length());
         if (libnameBase.Length())
            libName = libnameBase;
      }

   filename = cFilename;
   TString htmlFileName;
   if (!filename.Length() ||
      !gSystem->FindFile(fPathInfo.fInputPath, filename, kReadPermission)) {
      htmlFileName = GetURL(libName);
   } else
      htmlFileName = "./";

   if (htmlFileName.Length()) {
      filename = htmlFileName;
      TString className(classPtr->GetName());
      TDocOutput output(*const_cast<THtml*>(this));
      output.NameSpace2FileName(className);
      gSystem->PrependPathName(filename, className);
      filename = className;
      filename.ReplaceAll("\\", "/");
      filename += ".html";
   } else filename.Remove(0);
}

//______________________________________________________________________________
const char* THtml::GetHtmlFileName(const char* classname) const
{
   // Get the html file name for a class named classname.
   // Returns 0 if the class is not documented.
   TClassDocInfo* cdi = (TClassDocInfo*) fDocEntityInfo.fClasses.FindObject(classname);
   if (cdi)
      return cdi->GetHtmlFileName();
   return 0;
}

//______________________________________________________________________________
TClass *THtml::GetClass(const char *name1) const
{
//*-*-*-*-*Return pointer to class with name*-*-*-*-*-*-*-*-*-*-*-*-*
//*-*      =================================
   if(!name1 || !name1[0]) return 0;
   // no doc for internal classes
   if (strstr(name1,"ROOT::")==name1) {
      Bool_t ret = kTRUE;
      if (!strncmp(name1 + 6,"Math", 4))   ret = kFALSE;
      if (!strncmp(name1 + 6,"Reflex", 6)) ret = kFALSE;
      if (!strncmp(name1 + 6,"Cintex", 6)) ret = kFALSE;
      if (ret) return 0;
   }

   TClassDocInfo* cdi = (TClassDocInfo*)fDocEntityInfo.fClasses.FindObject(name1);
   if (!cdi) return 0;
   TClass *cl = dynamic_cast<TClass*>(cdi->GetClass());
   // hack to get rid of prec_stl types
   // TClassEdit checks are far too slow...
   /*
   if (cl && GetDeclFileName(cl) &&
       strstr(GetDeclFileName(cl),"prec_stl/"))
      cl = 0;
   */
   TString declFileName;
   if (cl && GetDeclFileName(cl, kFALSE, declFileName))
      return cl;
   return 0;
}

//______________________________________________________________________________
bool THtml::GetDeclFileName(TClass * cl, Bool_t filesys, TString& out_name) const
{
   // Return declaration file name; return the full path if filesys is true.
   return GetDeclImplFileName(cl, filesys, true, out_name);
}

//______________________________________________________________________________
bool THtml::GetImplFileName(TClass * cl, Bool_t filesys, TString& out_name) const
{
   // Return implementation file name
   return GetDeclImplFileName(cl, filesys, false, out_name);
}

//______________________________________________________________________________
bool THtml::GetDeclImplFileName(TClass * cl, bool filesys, bool decl, TString& out_name) const
{
   // Combined implementation for GetDeclFileName(), GetImplFileName():
   // Return declaration / implementation file name (depending on decl);
   // return the full path if filesys is true.

   out_name = "";

   R__LOCKGUARD(GetMakeClassMutex());
   TClassDocInfo* cdi = (TClassDocInfo*) fDocEntityInfo.fClasses.FindObject(cl->GetName());
   // whether we need to determine the fil name
   bool determine = (!cdi); // no cdi
   if (!determine) determine |=  decl &&  filesys && !cdi->GetDeclFileSysName()[0];
   if (!determine) determine |=  decl && !filesys && !cdi->GetDeclFileName()[0];
   if (!determine) determine |= !decl &&  filesys && !cdi->GetImplFileSysName()[0];
   if (!determine) determine |= !decl && !filesys && !cdi->GetImplFileName()[0];
   if (determine) {
      TString name;
      TString sysname;
      if (decl) {
         if (!GetFileDefinition().GetDeclFileName(cl, name, sysname))
            return false;
      } else {
         if (!GetFileDefinition().GetImplFileName(cl, name, sysname))
            return false;
      }
      if (cdi) {
         if (decl) {
            if (!cdi->GetDeclFileName() || !cdi->GetDeclFileName()[0])
               cdi->SetDeclFileName(name);
            if (!cdi->GetDeclFileSysName() || !cdi->GetDeclFileSysName()[0])
               cdi->SetDeclFileSysName(sysname);
         } else {
            if (!cdi->GetImplFileName() || !cdi->GetImplFileName()[0])
               cdi->SetImplFileName(name);
            if (!cdi->GetImplFileSysName() || !cdi->GetImplFileSysName()[0])
               cdi->SetImplFileSysName(sysname);
         }
      }

      if (filesys) out_name = sysname;
      else         out_name = name;
      return true;
   }
   if (filesys) {
      if (decl) out_name = cdi->GetDeclFileSysName();
      else      out_name = cdi->GetImplFileSysName();
   } else {
      if (decl) out_name = cdi->GetDeclFileName();
      else      out_name = cdi->GetImplFileName();
   }
   return true;
}

//______________________________________________________________________________
const TString& THtml::GetOutputDir(Bool_t createDir /*= kTRUE*/) const
{
   // Return the output directory as set by SetOutputDir().
   // Create it if it doesn't exist and if createDir is kTRUE.

   if (createDir) {
      R__LOCKGUARD(GetMakeClassMutex());

      gSystem->ExpandPathName(const_cast<THtml*>(this)->fPathInfo.fOutputDir);
      Long64_t sSize;
      Long_t sId, sFlags, sModtime;
      if (fPathInfo.fOutputDir.EndsWith("/") || fPathInfo.fOutputDir.EndsWith("\\"))
         fPathInfo.fOutputDir.Remove(fPathInfo.fOutputDir.Length() - 1);
      Int_t st = gSystem->GetPathInfo(fPathInfo.fOutputDir, &sId, &sSize, &sFlags, &sModtime);
      if (st || !(sFlags & 2)) {
         if (st == 0)
            Error("GetOutputDir", "output directory %s is an existing file",
                  fPathInfo.fOutputDir.Data());
         else if (gSystem->MakeDirectory(fPathInfo.fOutputDir) == -1)
            Error("GetOutputDir", "output directory %s does not exist and can't create it", fPathInfo.fOutputDir.Data());
      }
   }
   return fPathInfo.fOutputDir;
}

//______________________________________________________________________________
Bool_t THtml::IsNamespace(const TClass*cl)
{
   // Check whether cl is a namespace
   return (cl->Property() & kIsNamespace);
}

//______________________________________________________________________________
void THtml::LoadAllLibs()
{
   // Load all libraries known to ROOT via the rootmap system.

   TEnv* mapfile = gInterpreter->GetMapfile();
   if (!mapfile || !mapfile->GetTable()) return;

   std::set<std::string> loadedlibs;
   std::set<std::string> failedlibs;
   
   TEnvRec* rec = 0;
   TIter iEnvRec(mapfile->GetTable());
   while ((rec = (TEnvRec*) iEnvRec())) {
      TString libs = rec->GetValue();
      TString lib;
      Ssiz_t pos = 0;
      while (libs.Tokenize(lib, pos)) {
         // check that none of the libs failed to load
         if (failedlibs.find(lib.Data()) != failedlibs.end()) {
            // don't load it or any of its dependencies
            libs = "";
            break;
         }
      }
      pos = 0;
      while (libs.Tokenize(lib, pos)) {
         // ignore libCore - it's already loaded
         if (lib.BeginsWith("libCore"))
            continue;

         if (loadedlibs.find(lib.Data()) == loadedlibs.end()) {
            // just load the first library - TSystem will do the rest.
            gSystem->Load(lib);
            loadedlibs.insert(lib.Data());
         }
      }
   }
}


//______________________________________________________________________________
void THtml::MakeAll(Bool_t force, const char *filter, int numthreads /*= -1*/)
{
// Produce documentation for all the classes specified in the filter (by default "*")
// To process all classes having a name starting with XX, do:
//        html.MakeAll(kFALSE,"XX*");
// If force=kFALSE (default), only the classes that have been modified since
// the previous call to this function will be generated.
// If force=kTRUE, all classes passing the filter will be processed.
// If numthreads is != -1, use numthreads threads, else decide automatically
// based on the number of CPUs.

   MakeIndex(filter);

   if (numthreads == 1) {
      // CreateListOfClasses(filter); already done by MakeIndex
      TClassDocInfo* classinfo = 0;
      TIter iClassInfo(&fDocEntityInfo.fClasses);
      UInt_t count = 0;

      while ((classinfo = (TClassDocInfo*)iClassInfo())) {
         if (!classinfo->IsSelected()) 
            continue;
         fCounter.Form("%5d", fDocEntityInfo.fClasses.GetSize() - count++);
         MakeClass(classinfo, force);
      }
   } else {
      if (numthreads == -1) {
         SysInfo_t sysinfo;
         gSystem->GetSysInfo(&sysinfo);
         numthreads = sysinfo.fCpus;
         if (numthreads < 1)
            numthreads = 2;
      }
      fThreadedClassCount = 0;
      fThreadedClassIter = new TIter(&fDocEntityInfo.fClasses);
      THtmlThreadInfo hti(this, force);
      if (!fMakeClassMutex && gGlobalMutex) {
         gGlobalMutex->Lock();
         fMakeClassMutex = gGlobalMutex->Factory(kTRUE);
         gGlobalMutex->UnLock();
      }

      TList threads;
      gSystem->Load("libThread");
      while (--numthreads >= 0) {
         TThread* thread = new TThread(MakeClassThreaded, &hti);
         thread->Run();
         threads.Add(thread);
      }

      TIter iThread(&threads);
      TThread* thread = 0;
      Bool_t wait = kTRUE;
      while (wait) {
         while (wait && (thread = (TThread*) iThread()))
            wait &= (thread->GetState() == TThread::kRunningState);
         gSystem->ProcessEvents();
         gSystem->Sleep(500);
      }

      iThread.Reset();
      while ((thread = (TThread*) iThread()))
         thread->Join();
   }
   fCounter.Remove(0);
}


//______________________________________________________________________________
void THtml::MakeClass(const char *className, Bool_t force)
{
// Make HTML files for a single class
//
//
// Input: className - name of the class to process
//
   CreateListOfClasses("*");

   TClassDocInfo* cdi = (TClassDocInfo*)fDocEntityInfo.fClasses.FindObject(className);
   if (!cdi) {
      if (!TClassEdit::IsStdClass(className)) // stl classes won't be available, so no warning
         Error("MakeClass", "Unknown class '%s'!", className);
      return;
   }

   MakeClass(cdi, force);
}

//______________________________________________________________________________
void THtml::MakeClass(void *cdi_void, Bool_t force)
{
// Make HTML files for a single class
//
//
// Input: cdi - doc info for class to process
//
   if (!fDocEntityInfo.fClasses.GetSize())
      CreateListOfClasses("*");

   TClassDocInfo* cdi = (TClassDocInfo*) cdi_void;
   TClass* currentClass = dynamic_cast<TClass*>(cdi->GetClass());

   if (!currentClass) {
      if (!cdi->GetClass() &&
          !TClassEdit::IsStdClass(cdi->GetName())) // stl classes won't be available, so no warning
         Error("MakeClass", "Class '%s' is known, but I cannot find its TClass object!", cdi->GetName());
      return;
   }
   TString htmlFile(cdi->GetHtmlFileName());
   if (htmlFile.Length()
       && (htmlFile.BeginsWith("http://")
           || htmlFile.BeginsWith("https://")
           || gSystem->IsAbsoluteFileName(htmlFile))
       ) {
      htmlFile.Remove(0);
   }
   if (htmlFile.Length()) {
      TClassDocOutput cdo(*this, currentClass, &cdi->GetListOfTypedefs());
      cdo.Class2Html(force);
      cdo.MakeTree(force);
   } else {
      TString what(cdi->GetName());
      what += " (sources not found)";
      Printf(fCounterFormat.Data(), "-skipped-", fCounter.Data(), what.Data());
   }
}


//______________________________________________________________________________
void* THtml::MakeClassThreaded(void* info) {
   // Entry point of worker threads for multi-threaded MakeAll().
   // info points to an (internal) THtmlThreadInfo object containing the current
   // THtml object, and whether "force" was passed to MakeAll().
   // The thread will poll GetNextClass() until no further class is available.

   const THtmlThreadInfo* hti = (const THtmlThreadInfo*)info;
   if (!hti) return 0;
   TClassDocInfo* classinfo = 0;
   while ((classinfo = hti->GetHtml()->GetNextClass()))
      hti->GetHtml()->MakeClass(classinfo, hti->GetForce());

   return 0;
}

//______________________________________________________________________________
void THtml::MakeIndex(const char *filter)
{
   // Create the index files for the product, modules, all types, etc.
   // By default all classes are indexed (if filter="*");
   // to generate an index for all classes starting with "XX", do
   //    html.MakeIndex("XX*");

   CreateListOfClasses(filter);

   TDocOutput output(*this);
   // create indices
   output.CreateTypeIndex();
   output.CreateClassTypeDefs();
   output.CreateModuleIndex();
   output.CreateClassIndex();
   output.CreateProductIndex();

   // create a class hierarchy
   output.CreateHierarchy();
}


//______________________________________________________________________________
void THtml::MakeTree(const char *className, Bool_t force)
{
// Make an inheritance tree
//
//
// Input: className - name of the class to process
//

   // create canvas & set fill color
   TClass *classPtr = GetClass(className);

   if (!classPtr) {
      Error("MakeTree", "Unknown class '%s' !", className);
      return;
   }

   TClassDocOutput cdo(*this, classPtr, 0);
   cdo.MakeTree(force);
}

//______________________________________________________________________________
void THtml::SetFoundDot(Bool_t found) {
   // Set whether "dot" (a GraphViz utility) is avaliable
   if (found) fPathInfo.fFoundDot = PathInfo_t::kDotFound;
   else fPathInfo.fFoundDot = PathInfo_t::kDotNotFound;
}

//______________________________________________________________________________
void THtml::SetLocalFiles() const
{
   // Fill the files available in the file system below fPathInfo.fInputPath
   if (fLocalFiles) delete fLocalFiles;
   fLocalFiles = new TFileSysDB(fPathInfo.fInputPath, fPathInfo.fIgnorePath + "|(\\b" + GetOutputDir(kFALSE) + "\\b)" , 6);
}

//______________________________________________________________________________
void THtml::SetModuleDefinition(const TModuleDefinition& md)
{
   // Set the module defining object to be used; can also be a user derived
   // object (a la traits).
   delete fModuleDef;
   fModuleDef = (TModuleDefinition*) md.Clone();
   fModuleDef->SetOwner(const_cast<THtml*>(this));
}


//______________________________________________________________________________
void THtml::SetFileDefinition(const TFileDefinition& md)
{
   // Set the file defining object to be used; can also be a user derived
   // object (a la traits).
   delete fFileDef;
   fFileDef = (TFileDefinition*) md.Clone();
   fFileDef->SetOwner(const_cast<THtml*>(this));
}


//______________________________________________________________________________
void THtml::SetPathDefinition(const TPathDefinition& md)
{
   // Set the path defining object to be used; can also be a user derived
   // object (a la traits).
   delete fPathDef;
   fPathDef = (TPathDefinition*) md.Clone();
   fPathDef->SetOwner(const_cast<THtml*>(this));
}


//______________________________________________________________________________
void THtml::SetInputDir(const char *dir)
{
   // Set the directory containing the source files.
   // The source file for a class MyClass will be searched
   // by prepending dir to the value of
   // MyClass::Class()->GetImplFileName() - which can contain
   // directory information!
   // Also resets the class structure, in case new files can
   // be found after this call.

   fPathInfo.fInputPath = dir;
   gSystem->ExpandPathName(fPathInfo.fInputPath);

   // reset class table
   fDocEntityInfo.fClasses.Clear();
   fDocEntityInfo.fModules.Clear();
}

//______________________________________________________________________________
void THtml::SetOutputDir(const char *dir)
{
   // Set the directory where the HTML pages shuold be written to.
   // If the directory does not exist it will be created when needed.
   fPathInfo.fOutputDir = dir;
#ifdef R__WIN32
   fPathInfo.fOutputDir.ReplaceAll("/","\\");
#endif
}

//______________________________________________________________________________
void THtml::SetDeclFileName(TClass* cl, const char* filename)
{
   // Explicitly set a decl file name for TClass cl.
   TClassDocInfo* cdi = (TClassDocInfo*) fDocEntityInfo.fClasses.FindObject(cl->GetName());
   if (!cdi) {
      cdi = new TClassDocInfo(cl, "" /*html*/, "" /*fsdecl*/, "" /*fsimpl*/, filename);
      fDocEntityInfo.fClasses.Add(cdi);
   } else
      cdi->SetDeclFileName(filename);
}

//______________________________________________________________________________
void THtml::SetImplFileName(TClass* cl, const char* filename)
{
   // Explicitly set a impl file name for TClass cl.
   TClassDocInfo* cdi = (TClassDocInfo*) fDocEntityInfo.fClasses.FindObject(cl->GetName());
   if (!cdi) {
      cdi = new TClassDocInfo(cl, "" /*html*/, "" /*fsdecl*/, "" /*fsimpl*/, 0 /*decl*/, filename);
      fDocEntityInfo.fClasses.Add(cdi);
   } else
      cdi->SetImplFileName(filename);
}

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