ROOT logo
// @(#)root/rint:$Id: TTabCom.cxx 41908 2011-11-11 14:43:28Z pcanal $
// Author: Christian Lacunza <lacunza@cdfsg6.lbl.gov>   27/04/99

// Modified by Artur Szostak <artur@alice.phy.uct.ac.za> : 1 June 2003
//   Added support for namespaces.

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

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TTabCom                                                                //
//                                                                        //
// This class performs basic tab completion.                              //
// You should be able to hit [TAB] to complete a partially typed:         //
//                                                                        //
//   username                                                             //
//   environment variable                                                 //
//   preprocessor directive                                               //
//   pragma                                                               //
//   filename (with a context-sensitive path)                             //
//   public member function or data member (including base classes)       //
//   global variable, function, or class name                             //
//                                                                        //
// Also, something like                                                   //
//                                                                        //
//   someObject->Func([TAB]                                               //
//   someObject.Func([TAB]                                                //
//   someClass::Func([TAB]                                                //
//   someClass var([TAB]                                                  //
//   new someClass([TAB]                                                  //
//                                                                        //
// will print a list of prototypes for the indicated                      //
// method or constructor.                                                 //
//                                                                        //
// Current limitations and bugs:                                          //
//                                                                        //
//  1. you can only use one member access operator at a time.             //
//     eg, this will work: gROOT->GetListOfG[TAB]                         //
//     but this will not:  gROOT->GetListOfGlobals()->Conta[TAB]          //
//                                                                        //
//  2. nothing is guaranteed to work on windows or VMS                    //
//     (for one thing, /bin/env and /etc/passwd are hardcoded)            //
//                                                                        //
//  3. CINT shortcut #2 is deliberately not supported.                    //
//     (using "operator.()" instead of "operator->()")                    //
//                                                                        //
//  4. most identifiers (including C++ identifiers, usernames,            //
//     environment variables, etc)                                        //
//     are restriceted to this character set: [_a-zA-Z0-9]                //
//     therefore, you won't be able to complete things like               //
//                                                                        //
//          operator new                                                  //
//          operator+                                                     //
//          etc                                                           //
//                                                                        //
//  5. ~whatever[TAB] always tries to complete a username.                //
//     use whitespace (~ whatever[TAB]) if you want to complete a global  //
//     identifier.                                                        //
//                                                                        //
//  6. CINT shortcut #3 is not supported when trying to complete          //
//     the name of a global object.  (it is supported when trying to      //
//     complete a member of a global object)                              //
//                                                                        //
//  7. the list of #pragma's is hardcoded                                 //
//     (ie not obtained from the interpreter at runtime)                  //
//     ==> user-defined #pragma's will not be recognized                  //
//                                                                        //
//  8. the system include directories are also hardcoded                  //
//     because i don't know how to get them from the interpreter.         //
//     fons, maybe they should be #ifdef'd for the different sytems?      //
//                                                                        //
//  9. the TabCom.FileIgnore resource is always applied, even if you      //
//     are not trying to complete a filename.                             //
//                                                                        //
// 10. anything in quotes is assumed to be a filename                     //
//     so (among other things) you can't complete a quoted class name:    //
//     eg, TClass class1( "TDict[TAB]                                     //
//     this won't work... looks for a file in pwd starting with TDict     //
//                                                                        //
// 11. the prototypes tend to omit the word "const" a lot.                //
//     this is a problem with ROOT or CINT.                               //
//                                                                        //
// 12. when listing ambiguous matches, only one column is used,           //
//     even if there are many completions.                                //
//                                                                        //
// 13. anonymous objects are not currently identified                     //
//     so, for example,                                                   //
//                                                                        //
//          root> printf( TString([TAB                                    //
//                                                                        //
//     gives an error message instead of listing TString's constructors.  //
//     (this could be fixed)                                              //
//                                                                        //
// 14. the routine that adds the "appendage" isn't smart enough to know   //
//     if it's already there:                                             //
//                                                                        //
//          root> TCanvas::Update()                                       //
//              press [TAB] here ^                                        //
//          root> TCanvas::Update()()                                     //
//     (this could be fixed)                                              //
//                                                                        //
// 15. the appendage is only applied if there is exactly 1 match.         //
//     eg, this                                                           //
//                                                                        //
//          root> G__at[TAB]                                              //
//          root> G__ateval                                               //
//                                                                        //
//     happens instead of this                                            //
//                                                                        //
//          root> G__at[TAB]                                              //
//          root> G__ateval(                                              //
//                                                                        //
//     because there are several overloaded versions of G__ateval().      //
//     (this could be fixed)                                              //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <assert.h>

#include "RConfigure.h"
#include "TTabCom.h"
#include "TClass.h"
#include "TSystem.h"
#include "TROOT.h"
#include "TMethod.h"
#include "TEnv.h"
#include "TBenchmark.h"
#include "TError.h"
#include "TGlobal.h"
#include "TList.h"
#include "Getline.h"
#include "TFunction.h"
#include "TMethodArg.h"
#include "TInterpreter.h"
#include "Riostream.h"
#include "Rstrstream.h"

#define BUF_SIZE    1024        // must match value in C_Getline.c (for bounds checking)
#define IfDebug(x)  if(gDebug==TTabCom::kDebug) x

#ifdef R__WIN32
#undef tmpnam
#define tmpnam(a) _tempnam(a, 0)
const char kDelim = ';';
#else
const char kDelim = ':';
#endif


ClassImp(TTabCom)
// ----------------------------------------------------------------------------
//
//             global/file scope variables
//
TTabCom *gTabCom = 0;

// ----------------------------------------------------------------------------
//
//              constructors
//

//______________________________________________________________________________
TTabCom::TTabCom()
{
   // Default constructor.
   fpDirectives = 0;
   fpPragmas = 0;
   fpGlobals = 0;
   fpGlobalFuncs = 0;
   fpClasses = 0;
   fpNamespaces = 0;
   fpUsers = 0;
   fBuf = 0;
   fpLoc = 0;
   fpEnvVars = 0;
   fpFiles = 0;
   fpSysIncFiles = 0;
   fVarIsPointer = kFALSE;
   fLastIter = 0;

   InitPatterns();
}

//
//              constructors
//
// ----------------------------------------------------------------------------

TTabCom::~TTabCom()
{
   // Destructor.

   ClearAll();
   ClearSysIncFiles(); // this one stays cached
   ClearUsers();       // this one stays cached
}

// ----------------------------------------------------------------------------
//
//              public member functions
//


//______________________________________________________________________________
void TTabCom::ClearClasses()
{
   // Clear classes and namespace collections.

   if (fpClasses) {
      fpClasses->Delete(0);
      delete fpClasses;
      fpClasses = 0;
   }

   // Since the namespace array is filled at the same time as fpClasses we
   // delete it at the same time.
   if (fpNamespaces) {
      fpNamespaces->Delete(0);
      delete fpNamespaces;
      fpNamespaces = 0;
   }
}

//______________________________________________________________________________
void TTabCom::ClearCppDirectives()
{
   // Forget all Cpp directives seen so far.

   if (!fpDirectives)
      return;
   fpDirectives->Delete(0);
   delete fpDirectives;
   fpDirectives = 0;
}

//______________________________________________________________________________
void TTabCom::ClearEnvVars()
{
   // Forget all environment variables seen so far.
   if (!fpEnvVars)
      return;
   fpEnvVars->Delete(0);
   delete fpEnvVars;
   fpEnvVars = 0;
}

//______________________________________________________________________________
void TTabCom::ClearFiles()
{
   // Close all files.
   if (!fpFiles)
      return;
   fpFiles->Delete(0);
   delete fpFiles;
   fpFiles = 0;
}

//______________________________________________________________________________
void TTabCom::ClearGlobalFunctions()
{
   // Forget all global functions seen so far.
   if (!fpGlobalFuncs)
      return;
   fpGlobalFuncs->Delete(0);
   delete fpGlobalFuncs;
   fpGlobalFuncs = 0;
}

//______________________________________________________________________________
void TTabCom::ClearGlobals()
{
   // Forget all global variables seen so far.
   if (!fpGlobals)
      return;
   fpGlobals->Delete(0);
   delete fpGlobals;
   fpGlobals = 0;
}

//______________________________________________________________________________
void TTabCom::ClearPragmas()
{
   // Forget all pragmas seen so far.
   if (!fpPragmas)
      return;
   fpPragmas->Delete(0);
   delete fpPragmas;
   fpPragmas = 0;
}

//______________________________________________________________________________
void TTabCom::ClearSysIncFiles()
{
   // Close system files.
   if (!fpSysIncFiles)
      return;
   fpSysIncFiles->Delete(0);
   delete fpSysIncFiles;
   fpSysIncFiles = 0;
}

//______________________________________________________________________________
void TTabCom::ClearUsers()
{
   // Forget all user seen so far.
   if (!fpUsers)
      return;
   fpUsers->Delete(0);
   delete fpUsers;
   fpUsers = 0;
}

//______________________________________________________________________________
void TTabCom::ClearAll()
{
   // clears all lists
   // except for user names and system include files.

   ClearClasses();
   ClearCppDirectives();
   ClearEnvVars();
   ClearFiles();
   ClearGlobalFunctions();
   ClearGlobals();
   ClearPragmas();
//   ClearSysIncFiles(); <-- this one stays cached
//   ClearUsers();       <-- this one stays cached
}

//______________________________________________________________________________
void TTabCom::RehashClasses()
{
   // Do the class rehash.
   ClearClasses();
   GetListOfClasses();
}

//______________________________________________________________________________
void TTabCom::RehashCppDirectives()
{
   // Cpp rehashing.
   ClearCppDirectives();
   GetListOfCppDirectives();
}

//______________________________________________________________________________
void TTabCom::RehashEnvVars()
{
   // Environemnt variables rehashing.
   ClearEnvVars();
   GetListOfEnvVars();
}

//______________________________________________________________________________
void TTabCom::RehashFiles()
{
   // Close files.
   ClearFiles();                /* path unknown */
}                               // think about this

//______________________________________________________________________________
void TTabCom::RehashGlobalFunctions()
{
   // Reload global functions.
   ClearGlobalFunctions();
   GetListOfGlobalFunctions();
}

//______________________________________________________________________________
void TTabCom::RehashGlobals()
{
   // Reload globals.
   ClearGlobals();
   GetListOfGlobals();
}

//______________________________________________________________________________
void TTabCom::RehashPragmas()
{
   // Reload pragmas.
   ClearPragmas();
   GetListOfPragmas();
}

//______________________________________________________________________________
void TTabCom::RehashSysIncFiles()
{
   // Reload system include files.
   ClearSysIncFiles();
   GetListOfSysIncFiles();
}

//______________________________________________________________________________
void TTabCom::RehashUsers()
{
   // Reload users.
   ClearUsers();
   GetListOfUsers();
}

//______________________________________________________________________________
void TTabCom::RehashAll()
{
   // clears and then rebuilds all lists
   // except for user names and system include files.

   RehashClasses();
   RehashCppDirectives();
   RehashEnvVars();
   RehashFiles();
   RehashGlobalFunctions();
   RehashGlobals();
   RehashPragmas();
//   RehashSysIncFiles(); <-- this one stays cached
//   RehashUsers();       <-- this one stays cached
}

//______________________________________________________________________________
const TSeqCollection *TTabCom::GetListOfClasses()
{
   // Return the list of classes.
   if (!fpClasses) {
      // generate a text list of classes on disk
      const char *tmpfilename = tmpnam(0);
      FILE *fout = fopen(tmpfilename, "w");
      if (!fout) return 0;
      gCint->DisplayClass(fout, (char*)"", 0, 0);
      fclose(fout);

      // open the file
      ifstream file1(tmpfilename);
      if (!file1) {
         Error("TTabCom::GetListOfClasses", "could not open file \"%s\"",
               tmpfilename);
         gSystem->Unlink(tmpfilename);
         return 0;
      }
      // skip the first 2 lines (which are just header info)
      file1.ignore(32000, '\n');
      file1.ignore(32000, '\n');

      // parse file, add to list
      fpClasses = new TContainer;
      fpNamespaces = new TContainer;
      TString line;
      while (file1) {
         line = "";
         line.ReadLine(file1, kFALSE);  // kFALSE ==> don't skip whitespace
         line = line(23, 32000);
// old way...
//             if (line.Index("class") >= 0)
//                  line = line(6, 32000);
//             else if (line.Index("enum") >= 0)
//                  line = line(5, 32000);
//             else if (line.Index("(unknown)") >= 0)
//                  line = line(10, 32000);
//             line = line("[^ ]*");
// new way...
         int index;
         Bool_t isanamespace = kFALSE;  // Flag used to check if we found a namespace name.
         if (0);
         else if ((index = line.Index(" class ")) >= 0)
            line = line(1 + index + 6, 32000);
         else if ((index = line.Index(" namespace ")) >= 0) {
            line = line(1 + index + 10, 32000);
            isanamespace = kTRUE;
         } else if ((index = line.Index(" struct ")) >= 0)
            line = line(1 + index + 7, 32000);
         else if ((index = line.Index(" enum ")) >= 0)
            line = line(1 + index + 5, 32000);
         else if ((index = line.Index(" (unknown) ")) >= 0)
            line = line(1 + index + 10, 32000);
         // 2 changes: 1. use spaces ^         ^          2. use offset ^^^^^ in case of long
         //               to reduce probablility that        filename which overflows
         //               these keywords will occur in       its field.
         //               filename or classname.
         line = line("[^ ]*");

         // If we find namespace names then add them to the fpNamespaces array and
         // not the classes array.
         if (isanamespace)
            fpNamespaces->Add(new TObjString(line));
         else
            fpClasses->Add(new TObjString(line));
      }

      // done with this file
      file1.close();
      gSystem->Unlink(tmpfilename);
   }

   return fpClasses;
}

//______________________________________________________________________________
const TSeqCollection *TTabCom::GetListOfCppDirectives()
{
   // Return the list of CPP directives.
   if (!fpDirectives) {
      fpDirectives = new TContainer;

      fpDirectives->Add(new TObjString("if"));
      fpDirectives->Add(new TObjString("ifdef"));
      fpDirectives->Add(new TObjString("ifndef"));
      fpDirectives->Add(new TObjString("elif"));
      fpDirectives->Add(new TObjString("else"));
      fpDirectives->Add(new TObjString("endif"));
      fpDirectives->Add(new TObjString("include"));
      fpDirectives->Add(new TObjString("define"));
      fpDirectives->Add(new TObjString("undef"));
      fpDirectives->Add(new TObjString("line"));
      fpDirectives->Add(new TObjString("error"));
      fpDirectives->Add(new TObjString("pragma"));
   }

   return fpDirectives;
}

//______________________________________________________________________________
const TSeqCollection *TTabCom::GetListOfFilesInPath(const char path[])
{
   // "path" should be initialized with a colon separated list of
   // system directories

   static TString previousPath;

   if (path && fpFiles && strcmp(path, previousPath) == 0) {
      return fpFiles;
   } else {
      ClearFiles();

      fpFiles = NewListOfFilesInPath(path);
      previousPath = path;
   }

   return fpFiles;
}

//______________________________________________________________________________
const TSeqCollection *TTabCom::GetListOfEnvVars()
{
   // Uses "env" (Unix) or "set" (Windows) to get list of environment variables.

   if (!fpEnvVars) {
      const char *tmpfilename = tmpnam(0);
      TString cmd;

#ifndef WIN32
      char *env = gSystem->Which(gSystem->Getenv("PATH"), "env", kExecutePermission);
      if (!env)
         return 0;
      cmd = env;
      cmd += " > ";
      delete [] env;
#else
      cmd = "set > ";
#endif
      cmd += tmpfilename;
      cmd += "\n";
      gSystem->Exec(cmd.Data());

      // open the file
      ifstream file1(tmpfilename);
      if (!file1) {
         Error("TTabCom::GetListOfEnvVars", "could not open file \"%s\"",
               tmpfilename);
         gSystem->Unlink(tmpfilename);
         return 0;
      }
      // parse, add
      fpEnvVars = new TContainer;
      TString line;
      while (file1)             // i think this loop goes one time extra which
         // results in an empty string in the list, but i don't think it causes any
         // problems.
      {
         line.ReadToDelim(file1, '=');
         file1.ignore(32000, '\n');
         fpEnvVars->Add(new TObjString(line.Data()));
      }

      file1.close();
      gSystem->Unlink(tmpfilename);
   }

   return fpEnvVars;
}

//______________________________________________________________________________
const TSeqCollection *TTabCom::GetListOfGlobals()
{
   // Return the list of globals.
   if (!fpGlobals) {

      fpGlobals = new TContainer;

      DataMemberInfo_t *a;
      int last = 0;
      int nglob = 0;

      // find the number of global objects
      DataMemberInfo_t *t = gCint->DataMemberInfo_Factory();
      while (gCint->DataMemberInfo_Next(t))
         nglob++;

      for (int i = 0; i < nglob; i++) {
         a = gCint->DataMemberInfo_Factory();
         gCint->DataMemberInfo_Next(a);             // initial positioning

         for (int j = 0; j < last; j++)
            gCint->DataMemberInfo_Next(a);

         // if name cannot be obtained no use to put in list
         if (gCint->DataMemberInfo_IsValid(a) && gCint->DataMemberInfo_Name(a)) {
            fpGlobals->Add(new TGlobal(a));
         } else
            gCint->DataMemberInfo_Delete(a);

         last++;
      }
      gCint->DataMemberInfo_Delete(t);
   }

   return fpGlobals;
}

//______________________________________________________________________________
const TSeqCollection *TTabCom::GetListOfGlobalFunctions()
{
   // Return the list of global functions.
   if (!fpGlobalFuncs) {

      fpGlobalFuncs = new TContainer;

      MethodInfo_t *a;
      int last = 0;
      int nglob = 0;

      // find the number of global functions
      MethodInfo_t *t = gCint->MethodInfo_Factory();
      while (gCint->MethodInfo_Next(t))
         nglob++;

      for (int i = 0; i < nglob; i++) {
         a = gCint->MethodInfo_Factory();
         gCint->MethodInfo_Next(a);             // initial positioning

         for (int j = 0; j < last; j++)
            gCint->MethodInfo_Next(a);

         // if name cannot be obtained no use to put in list
         if (gCint->MethodInfo_IsValid(a) && gCint->MethodInfo_Name(a)) {
            fpGlobalFuncs->Add(new TFunction(a));
         } else
            gCint->MethodInfo_Delete(a);

         last++;
      }
      gCint->MethodInfo_Delete(t);
   }

   return fpGlobalFuncs;
}

//______________________________________________________________________________
const TSeqCollection *TTabCom::GetListOfPragmas()
{
   // Return the list of pragmas
   if (!fpPragmas) {
      fpPragmas = new TContainer;

      fpPragmas->Add(new TObjString("ANSI "));
      fpPragmas->Add(new TObjString("autocompile "));
      fpPragmas->Add(new TObjString("bytecode "));
      fpPragmas->Add(new TObjString("compile "));
      fpPragmas->Add(new TObjString("endbytecode "));
      fpPragmas->Add(new TObjString("endcompile "));
      fpPragmas->Add(new TObjString("include "));
      fpPragmas->Add(new TObjString("includepath "));
      fpPragmas->Add(new TObjString("K&R "));
      fpPragmas->Add(new TObjString("link "));
      fpPragmas->Add(new TObjString("preprocess "));
      fpPragmas->Add(new TObjString("preprocessor "));
      fpPragmas->Add(new TObjString("security level"));
      // "setertti "  omitted. Ordinary user should not use this statement
      // "setstdio "  omitted. Ordinary user should not use this statement
      // "setstream " omitted. Ordinary user should not use this statement
      // "stub"       omitted. Ordinary user should not use this statement

   }

   return fpPragmas;
}

//______________________________________________________________________________
const TSeqCollection *TTabCom::GetListOfSysIncFiles()
{
   // Return the list of system include files.
   if (!fpSysIncFiles) {
      fpSysIncFiles = NewListOfFilesInPath(GetSysIncludePath());
   }

   return fpSysIncFiles;
}

//______________________________________________________________________________
const TSeqCollection *TTabCom::GetListOfUsers()
{
   // reads from "/etc/passwd"

   if (!fpUsers) {
      fpUsers = new TContainer;

      ifstream passwd;
      TString user;

      passwd.open("/etc/passwd");
      while (passwd) {
         user.ReadToDelim(passwd, ':');
         fpUsers->Add(new TObjString(user));
         passwd.ignore(32000, '\n');
      }
      passwd.close();
   }

   return fpUsers;
}

//
//              public member functions
//
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
//
//                           static utility functions
//

//______________________________________________________________________________
Char_t TTabCom::AllAgreeOnChar(int i, const TSeqCollection * pList,
                               Int_t & nGoodStrings)
{
   //[static utility function]///////////////////////////////////////////
   //
   //  if all the strings in "*pList" have the same ith character,
   //  that character is returned.
   //  otherwise 0 is returned.
   //
   //  any string "s" for which "ExcludedByFignore(s)" is true
   //  will be ignored unless All the strings in "*pList"
   //  are "ExcludedByFignore()"
   //
   //  in addition, the number of strings which were not
   //  "ExcludedByFignore()" is returned in "nGoodStrings".
   //
   /////////////////////////////////////////////////////////////////////////

   assert(pList != 0);

   TIter next(pList);
   TObject *pObj;
   const char *s = "";
   char ch0;
   Bool_t isGood;
   Bool_t atLeast1GoodString;

   // init
   nGoodStrings = 0;
   atLeast1GoodString = kFALSE;

   // first look for a good string
   do {
      if ((pObj = next())) {
         s = pObj->GetName();
         isGood = !ExcludedByFignore(s);
         if (isGood) {
            atLeast1GoodString = kTRUE;
            nGoodStrings += 1;
         }
      } else {
         // reached end of list without finding a single good string.
         // just use the first one.
         next.Reset();
         pObj = next();
         if (pObj) s = pObj->GetName();
         break;
      }
   }
   while (!isGood);

   // found a good string...
   ch0 = s[i];

   // all subsequent good strings must have the same ith char
   do {
      if ((pObj = next())) {
         s = pObj->GetName();
         isGood = !ExcludedByFignore(s);
         if (isGood)
            nGoodStrings += 1;
      } else
         return ch0;
   }
   while (((int) strlen(s) >= i && s[i] == ch0) ||
          (atLeast1GoodString && !isGood));

   return 0;
}

//______________________________________________________________________________
void TTabCom::AppendListOfFilesInDirectory(const char dirName[],
                                           TSeqCollection * pList)
{
   //[static utility function]/////////////////////////////
   //
   //  adds a TObjString to "*pList"
   //  for each entry found in the system directory "dirName"
   //
   //  directories that do not exist are silently ignored.
   //
   //////////////////////////////////////////////////////////

   assert(dirName != 0);
   assert(pList != 0);

   // open the directory
   void *dir = gSystem->OpenDirectory(dirName);

   // it is normal for this function to receive names of directories that do not exist.
   // they should be ignored and should not generate any error messages.
   if (!dir)
      return;

   // put each filename in the list
   const char *tmp_ptr;         // gSystem->GetDirEntry() returns 0 when no more files.
   TString fileName;

   while ((tmp_ptr = gSystem->GetDirEntry(dir))) {
      fileName = tmp_ptr;

      // skip "." and ".."
      if (fileName == "." || fileName == "..")
         continue;

      // add to list
      pList->Add(new TObjString(dirName + fileName.Prepend("/")));
   }
   // NOTE:
   // with a path like "/usr/include:/usr/include/CC:$ROOTDIR/include:$ROOTDIR/cint/include:..."
   // the above loop could get traversed 700 times or more.
   // ==> keep it minimal or it could cost whole seconds on slower machines.
   // also: TClonesArray doesn't help.

   // close the directory
   gSystem->FreeDirectory(dir);
}

// -----\/-------- homemade RTTI ---------------\/------------------------
//______________________________________________________________________________
TString TTabCom::DetermineClass(const char varName[])
{
   //[static utility function]/////////////////////////////
   //
   //  returns empty string on failure.
   //  otherwise returns something like this: "TROOT*".
   //  fails for non-class types (ie, int, char, etc).
   //  fails for pointers to functions.
   //
   ///////////////////////////////////


   ///////////////////////////////////
   //
   //  note that because of the strange way this function works,
   //  CINT will print
   //
   //     Error: No symbol asdf in current scope  FILE:/var/tmp/gaaa001HR LINE:1
   //
   //  if "varName" is not defined. (in this case, varName=="asdf")
   //  i don't know how to suppress this.
   //
   ///////////////////////////////////

   assert(varName != 0);
   IfDebug(cerr << "DetermineClass(\"" << varName << "\");" << endl);

   const char *tmpfile = tmpnam(0);
   TString cmd("gROOT->ProcessLine(\"");
   cmd += varName;
   cmd += "\"); > ";
   cmd += tmpfile;
   cmd += "\n";

   gROOT->ProcessLineSync(cmd.Data());
   // the type of the variable whose name is "varName"
   // should now be stored on disk in the file "tmpfile"

   TString type = "";
   int c;

   // open the file
   ifstream file1(tmpfile);
   if (!file1) {
      Error("TTabCom::DetermineClass", "could not open file \"%s\"",
            tmpfile);
      goto cleanup;
   }
   // first char should be '(', which we can ignore.
   c = file1.get();
   if (!file1 || c <= 0 || c == '*' || c != '(') {
      Error("TTabCom::DetermineClass", "variable \"%s\" not defined?",
            varName);
      goto cleanup;
   }
   IfDebug(cerr << (char) c << flush);

   // in case of success, "class TClassName*)0x12345" remains,
   // since the opening '(' was removed.
   file1 >> type;               // ignore "class"

   // non-class type ==> failure
   if (type == "const")
      file1 >> type;

   if (type != "class" && type != "struct") {
      type = "";                // empty return string indicates failure.
      goto cleanup;             //* RETURN *//
   }
   // ignore ' '
   c = file1.get();
   IfDebug(cerr << (char) c << flush);

   // this is what we want
   type.ReadToDelim(file1, ')');
   IfDebug(cerr << type << endl);

   // new version of CINT returns: "class TClassName*const)0x12345"
   // so we have to strip off "const"
   if (type.EndsWith("const"))
      type.Remove(type.Length() - 5);

cleanup:
   // done reading from file
   file1.close();
   gSystem->Unlink(tmpfile);

   return type;
}

//______________________________________________________________________________
Bool_t TTabCom::ExcludedByFignore(TString s)
{
   //[static utility function]/////////////////////////////
   //
   //  returns true iff "s" ends with one of
   //  the strings listed in the "TabCom.FileIgnore" resource.
   //
   /////////////////////////////////////////////////////////////

   const char *fignore = gEnv->GetValue("TabCom.FileIgnore", (char *) 0);

   if (!fignore) {
      return kFALSE;
   } else {
#ifdef R__SSTREAM
      istringstream endings((char *) fignore);
#else
      istrstream endings((char *) fignore);  // do i need to make a copy first?
#endif
      TString ending;

      ending.ReadToDelim(endings, kDelim);

      while (!ending.IsNull()) {
         if (s.EndsWith(ending))
            return kTRUE;
         else
            ending.ReadToDelim(endings, kDelim);  // next
      }
      return kFALSE;
   }
}

//______________________________________________________________________________
TString TTabCom::GetSysIncludePath()
{
   //[static utility function]/////////////////////////////
   //
   //  returns a colon-separated string of directories
   //  that CINT will search when you call #include<...>
   //
   //  returns empty string on failure.
   //
   ///////////////////////////////////////////////////////////

   // >i noticed that .include doesn't list the standard directories like
   // >/usr/include or /usr/include/CC.
   // >
   // >how can i get a list of all the directories the interpreter will
   // >search through when the user does a #include<...> ?
   //
   // Right now, there is no easy command to tell you about it.  Instead, I can
   // describe it here.
   //
   // 1) CINT first searches current working directory for #include "xxx"
   //   (#include <xxx> does not)
   //
   // 2) CINT searches include path directories given by -I option
   //
   // 3) CINT searches following standard include directories.
   //    $CINTSYSDIR/include
   //    $CINTSYSDIR/stl
   //    $CINTSYSDIR/msdev/include   if VC++4.0
   //    $CINTSYSDIR/sc/include      if Symantec C++
   //    /usr/include
   //    /usr/include/g++            if gcc,g++
   //    /usr/include/CC             if HP-UX
   //    /usr/include/codelibs       if HP-UX
   //
   // .include command only displays 2).
   //
   // Thank you
   // Masaharu Goto

   // 1) current dir
   // ----------------------------------------------
   // N/A


   // 2) -I option (and #pragma includepath)
   // ----------------------------------------------

   // get this part of the include path from the interpreter
   // and stick it in a tmp file.
   const char *tmpfilename = tmpnam(0);

   FILE *fout = fopen(tmpfilename, "w");
   if (!fout) return "";
   gCint->DisplayIncludePath(fout);
   fclose(fout);

   // open the tmp file
   ifstream file1(tmpfilename);
   if (!file1) {                // error
      Error("TTabCom::GetSysIncludePath", "could not open file \"%s\"",
            tmpfilename);
      gSystem->Unlink(tmpfilename);
      return "";
   }
   // parse it.
   TString token;               // input buffer
   TString path;                // all directories so far (colon-separated)
   file1 >> token;              // skip "include"
   file1 >> token;              // skip "path:"
   while (file1) {
      file1 >> token;
      if (!token.IsNull()) {
         if (path.Length() > 0)
            path.Append(":");
         path.Append(token.Data() + 2);  // +2 skips "-I"
      }
   }

   // done with the tmp file
   file1.close();
   gSystem->Unlink(tmpfilename);

   // 3) standard directories
   // ----------------------------------------------

#ifndef CINTINCDIR
   TString sCINTSYSDIR("$ROOTSYS/cint");
#else
   TString sCINTSYSDIR(CINTINCDIR);
#endif
   path.Append(":" + sCINTSYSDIR + "/include");
//   path.Append(":"+CINTSYSDIR+"/stl");
//   path.Append(":"+CINTSYSDIR+"/msdev/include");
//   path.Append(":"+CINTSYSDIR+"/sc/include");
   path.Append(":/usr/include");
//   path.Append(":/usr/include/g++");
//   path.Append(":/usr/include/CC");
//   path.Append(":/usr/include/codelibs");

   return path;
}

//______________________________________________________________________________
Bool_t TTabCom::IsDirectory(const char fileName[])
{
   //[static utility function]/////////////////////////////
   //
   //  calls TSystem::GetPathInfo() to see if "fileName"
   //  is a system directory.
   //
   ///////////////////////////////////////////////////////

   FileStat_t stat;
   gSystem->GetPathInfo(fileName, stat);
   return R_ISDIR(stat.fMode);
}

//______________________________________________________________________________
TSeqCollection *TTabCom::NewListOfFilesInPath(const char path1[])
{
   //[static utility function]/////////////////////////////
   //
   //  creates a list containing the full path name for each file
   //  in the (colon separated) string "path1"
   //
   //  memory is allocated with "new", so
   //  whoever calls this function takes responsibility for deleting it.
   //
   //////////////////////////////////////////////////////////////////////

   assert(path1 != 0);
   if (!path1[0]) path1 = ".";

   TContainer *pList = new TContainer;  // maybe use RTTI here? (since its a static function)
#ifdef R__SSTREAM
   istringstream path((char *) path1);
#else
   istrstream path((char *) path1);
#endif

   while (path.good())
   {
      TString dirName;
      dirName.ReadToDelim(path, kDelim);
      if (dirName.IsNull())
         continue;

      IfDebug(cerr << "NewListOfFilesInPath(): dirName = " << dirName <<
              endl);

      AppendListOfFilesInDirectory(dirName, pList);
   }

   return pList;
}

//______________________________________________________________________________
Bool_t TTabCom::PathIsSpecifiedInFileName(const TString & fileName)
{
   //[static utility function]/////////////////////////////
   //
   //  true if "fileName"
   //  1. is an absolute path ("/tmp/a")
   //  2. is a relative path  ("../whatever", "./test")
   //  3. starts with user name ("~/mail")
   //  4. starts with an environment variable ("$ROOTSYS/bin")
   //
   //////////////////////////////////////////////////////////////////////////

   char c1 = (fileName.Length() > 0) ? fileName[0] : 0;
   return c1 == '/' || c1 == '~' || c1 == '$' || fileName.BeginsWith("./")
       || fileName.BeginsWith("../");
}

//______________________________________________________________________________
void TTabCom::NoMsg(Int_t errorLevel)
{
   //[static utility function]/////////////////////////////
   //
   //  calling "NoMsg( errorLevel )",
   //  sets "gErrorIgnoreLevel" to "errorLevel+1" so that
   //  all errors with "level < errorLevel" will be ignored.
   //
   //  calling the function with a negative argument
   //  (e.g., "NoMsg( -1 )")
   //  resets gErrorIgnoreLevel to its previous value.
   //
   //////////////////////////////////////////////////////////////////

   ////////////////////////////////////////////////////////////////
   //
   // if you call the function twice with a non-negative argument
   // (without an intervening call with a negative argument)
   // it will complain because it is almost certainly an error
   // that will cause the function to loose track of the previous
   // value of gErrorIgnoreLevel.
   //
   // most common causes: 1. suspiciously placed "return;" statement
   //                     2. calling a function that calls "NoMsg()"
   //
   //////////////////////////////////////////////////////////////////

   const Int_t kNotDefined = -2;
   static Int_t old_level = kNotDefined;

   if (errorLevel < 0)          // reset
   {
      if (old_level == kNotDefined) {
         cerr << "NoMsg(): ERROR 1. old_level==" << old_level << endl;
         return;
      }

      gErrorIgnoreLevel = old_level;  // restore
      old_level = kNotDefined;
   } else                       // set
   {
      if (old_level != kNotDefined) {
         cerr << "NoMsg(): ERROR 2. old_level==" << old_level << endl;
         return;
      }

      old_level = gErrorIgnoreLevel;
      if (gErrorIgnoreLevel <= errorLevel)
         gErrorIgnoreLevel = errorLevel + 1;
   }
}

//
//                           static utility functions
//
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
//
//                       private member functions
//
//

//______________________________________________________________________________
Int_t TTabCom::Complete(const TRegexp & re,
                        const TSeqCollection * pListOfCandidates,
                        const char appendage[],
                        ostream& out,
                        TString::ECaseCompare cmp)
{
   // [private]

   // returns position of first change in buffer
   // ------------------------------------------
   // -2 ==> new line altogether (whole thing needs to be redrawn, including prompt)
   // -1 ==> no changes
   //  0 ==> beginning of line
   //  1 ==> after 1st char
   //  n ==> after nth char

   IfDebug(cerr << "TTabCom::Complete() ..." << endl);
   assert(fpLoc != 0);
   assert(pListOfCandidates != 0);

   Int_t pos = 0;               // position of first change
   const int loc = *fpLoc;      // location where TAB was pressed

   // -----------------------------------------
   //
   // 1. get the substring we need to complete
   //
   // NOTES:
   // s1 = original buffer
   // s2 = sub-buffer from 0 to wherever the user hit TAB
   // s3 = the actual text that needs completing
   //
   // -----------------------------------------
   TString s1(fBuf);
   TString s2 = s1(0, loc);
   TString s3 = s2(re);

   int start = s2.Index(re);

   IfDebug(cerr << "   s1: " << s1 << endl);
   IfDebug(cerr << "   s2: " << s2 << endl);
   IfDebug(cerr << "   s3: " << s3 << endl);
   IfDebug(cerr << "start: " << start << endl);
   IfDebug(cerr << endl);

   // -----------------------------------------
   // 2. go through each possible completion,
   //    keeping track of the number of matches
   // -----------------------------------------
   TList listOfMatches;         // list of matches (local filenames only) (insertion order must agree across these 3 lists)
   TList listOfFullPaths;       // list of matches (full filenames)       (insertion order must agree across these 3 lists)
   listOfMatches.SetOwner();
   listOfFullPaths.SetOwner();

   int nMatches = 0;            // number of matches
   TObject *pObj;               // pointer returned by iterator
   TIter next_candidate(pListOfCandidates);
   TIter next_match(&listOfMatches);
   TIter next_fullpath(&listOfFullPaths);

   // stick all matches into "listOfMatches"
   while ((pObj = next_candidate())) {
      // get the full filename
      const char *s4 = pObj->GetName();

      assert(s4 != 0);

      // pick off tail
      const char *s5 = strrchr(s4, '/');
      if (!s5)
         s5 = s4;               // no '/' found
      else
         s5 += 1;               // advance past '/'

      // if case sensitive (normal behaviour), check for match
      // if case insensitive, convert to TString and compare case insensitively
      if ((cmp == TString::kExact) && (strstr(s5, s3) == s5)) {
         nMatches += 1;
         listOfMatches.Add(new TObjString(s5));
         listOfFullPaths.Add(new TObjString(s4));
         IfDebug(cerr << "adding " << s5 << '\t' << s4 << endl);
      } else if (cmp == TString::kIgnoreCase) {
         TString ts5(s5);
         if (ts5.BeginsWith(s3, cmp))
         {
            nMatches += 1;
            listOfMatches.Add(new TObjString(s5));
            listOfFullPaths.Add(new TObjString(s4));
            IfDebug(cerr << "adding " << s5 << '\t' << s4 << endl);
         }
      } else {
//rdm         IfDebug(cerr << "considered " << s5 << '\t' << s4 << endl);
      }

   }

   // -----------------------------------------
   // 3. beep, list, or complete
   //    depending on how many matches were found
   // -----------------------------------------

   // 3a. no matches ==> bell
   TString partialMatch = "";

   if (nMatches == 0) {
      // Ring a bell!
      gSystem->Beep();
      pos = -1;
      goto done;                //* RETURN *//
   }
   // 3b. one or more matches.
   char match[1024];

   if (nMatches == 1) {
      // get the (lone) match
      const char *short_name = next_match()->GetName();
      const char *full_name = next_fullpath()->GetName();

      pObj = pListOfCandidates->FindObject(short_name);
      if (pObj) {
         IfDebug(cerr << endl << "class: " << pObj->ClassName() << endl);
         TString className = pObj->ClassName();
         if (0);
         else if (className == "TMethod" || className == "TFunction") {
            TFunction *pFunc = (TFunction *) pObj;
            if (0 == pFunc->GetNargs())
               appendage = "()";  // no args
            else
               appendage = "("; // user needs to supply some args
         } else if (className == "TDataMember") {
            appendage = " ";
         }
      }

      CopyMatch(match, short_name, appendage, full_name);
   } else {
      // multiple matches ==> complete as far as possible
      Char_t ch;
      Int_t nGoodStrings;

      for (int i = 0;
           (ch = AllAgreeOnChar(i, &listOfMatches, nGoodStrings));
           i += 1) {
         IfDebug(cerr << " i=" << i << " ch=" << ch << endl);
         partialMatch.Append(ch);
      }

      const char *s;
      const char *s0;

      // multiple matches, but maybe only 1 of them is any good.
      if (nGoodStrings == 1) {

         // find the 1 good match
         do {
            s = next_match()->GetName();
            s0 = next_fullpath()->GetName();
         }
         while (ExcludedByFignore(s));

         // and use it.
         CopyMatch(match, s, appendage, s0);
      } else {
         IfDebug(cerr << "more than 1 GoodString" << endl);

         if (partialMatch.Length() > s3.Length())
            // this partial match is our (partial) completion.
         {
            CopyMatch(match, partialMatch.Data());
         } else
            // couldn't do any completing at all,
            // print a list of all the ambiguous matches
            // (except for those excluded by "FileIgnore")
         {
            IfDebug(cerr << "printing ambiguous matches" << endl);
            out << endl;
            while ((pObj = next_match())) {
               s = pObj->GetName();
               s0 = next_fullpath()->GetName();
               if (!ExcludedByFignore(s) || nGoodStrings == 0) {
                  if (IsDirectory(s0))
                     out << s << "/" << endl;
                  else
                     out << s << endl;
               }
            }
            pos = -2;
            if (cmp == TString::kExact || partialMatch.Length() < s3.Length()) {
               goto done;          //* RETURN *//
            } // else:
            // update the matching part, will have changed
            // capitalization because only cmp == TString::kIgnoreCase
            // matches.
            CopyMatch(match, partialMatch.Data());
         }
      }
   }


   // ---------------------------------------
   // 4. finally write text into the buffer.
   // ---------------------------------------
   {
      int i = strlen(fBuf);     // old EOL position is i
      int l = strlen(match) - (loc - start);  // new EOL position will be i+L

      // first check for overflow
      if (strlen(fBuf) + strlen(match) + 1 > BUF_SIZE) {
         Error("TTabCom::Complete", "buffer overflow");
         pos = -2;
         goto done;             /* RETURN */
      }
      // debugging output
      IfDebug(cerr << "  i=" << i << endl);
      IfDebug(cerr << "  L=" << l << endl);
      IfDebug(cerr << "loc=" << loc << endl);

      // slide everything (including the null terminator) over to make space
      for (; i >= loc; i -= 1) {
         fBuf[i + l] = fBuf[i];
      }

      // insert match
      strncpy(fBuf + start, match, strlen(match));

      // the "get"->"Get" case of TString::kIgnore sets pos to -2
      // and falls through to update the buffer; we need to return
      // -2 in that case, so check here:
      if (pos != -2) {
         pos = loc;                // position of first change in "fBuf"
         if (cmp == TString::kIgnoreCase && pos < 0) {
            // We might have changed somthing before loc, due to differences in
            // capitalization. So return start:
            pos = start;
         }
      }
      *fpLoc = loc + l;         // new cursor position
   }

done:                         // <----- goto label
   // un-init
   fpLoc = 0;
   fBuf = 0;

   return pos;
}

//______________________________________________________________________________
void TTabCom::CopyMatch(char dest[], const char localName[],
                        const char appendage[],
                        const char fullName[]) const
{
   // [private]

   // if "appendage" is 0, no appendage is applied.
   //
   // if "appendage" is of the form "filenameXXX" then,
   // "filename" is ignored and "XXX" is taken to be the appendage,
   // but it will only be applied if the file is not a directory...
   // if the file is a directory, a "/" will be used for the appendage instead.
   //
   // if "appendage" is of the form "XXX" then "XXX" will be appended to the match.

   assert(dest != 0);
   assert(localName != 0);

   // potential buffer overflow.
   strcpy(dest, localName);

   const char *key = "filename";
   const int key_len = strlen(key);

   IfDebug(cerr << "CopyMatch()." << endl);
   IfDebug(cerr << "localName: " << (localName ? localName : "0") <<
           endl);
   IfDebug(cerr << "appendage: " << (appendage ? appendage : "0") <<
           endl);
   IfDebug(cerr << " fullName: " << (fullName ? fullName : "0") <<
           endl);


   // check to see if "appendage" starts with "key"
   if (appendage && strncmp(appendage, key, key_len) == 0) {
      // filenames get special treatment
      appendage += key_len;
      IfDebug(cerr << "new appendage: " << appendage << endl);
      if (IsDirectory(fullName)) {
         if (fullName)
            strcpy(dest + strlen(localName), "/");
      } else {
         if (appendage)
            strcpy(dest + strlen(localName), appendage);
      }
   } else {
      if (appendage)
         strcpy(dest + strlen(localName), appendage);
   }
}

//______________________________________________________________________________
TTabCom::EContext_t TTabCom::DetermineContext() const
{
   // [private]

   assert(fBuf != 0);

   const char *pStart;          // start of match
   const char *pEnd;            // end of match

   for (int context = 0; context < kNUM_PAT; ++context) {
      pEnd = Matchs(fBuf, *fpLoc, fPat[context], &pStart);
      if (pEnd) {
         IfDebug(cerr << endl
                 << "context=" << context << " "
                 << "RegExp=" << fRegExp[context]
                 << endl);
         return EContext_t(context);  //* RETURN *//
      }
   }

   return kUNKNOWN_CONTEXT;     //* RETURN *//
}

//______________________________________________________________________________
TString TTabCom::DeterminePath(const TString & fileName,
                               const char defaultPath[]) const
{
   // [private]

   if (PathIsSpecifiedInFileName(fileName)) {
      TString path = fileName;
      gSystem->ExpandPathName(path);
      Int_t end = path.Length()-1;
      if (end>0 && path[end]!='/' && path[end]!='\\') {
         path = gSystem->DirName(path);
      }
      return path;
   } else {
      TString newBase;
      TString extendedPath;
      if (fileName.Contains("/")) {
         Int_t end = fileName.Length()-1;
         if (fileName[end] != '/' && fileName[end] != '\\') {
            newBase = gSystem->DirName(fileName);
         } else {
            newBase = fileName;
         }
         extendedPath = ExtendPath(defaultPath, newBase);
      } else {
         newBase = "";
         extendedPath = defaultPath;
      }
      IfDebug(cerr << endl);
      IfDebug(cerr << "    fileName: " << fileName << endl);
      IfDebug(cerr << "    pathBase: " << newBase << endl);
      if (defaultPath) {
         IfDebug(cerr << " defaultPath: " << defaultPath << endl);
      } else {
         IfDebug(cerr << " defaultPath: " << endl);
      }         
      IfDebug(cerr << "extendedPath: " << extendedPath << endl);
      IfDebug(cerr << endl);

      return extendedPath;
   }
}

//______________________________________________________________________________
TString TTabCom::ExtendPath(const char originalPath[], TString newBase) const
{
   // [private]

   if (newBase.BeginsWith("/"))
      newBase.Remove(TString::kLeading, '/');
#ifdef R__SSTREAM
   stringstream str;
#else
   strstream str;
#endif
   TString dir;
   TString newPath;
   if (originalPath) str << originalPath;

   while (str.good())
   {
      dir = "";
      dir.ReadToDelim(str, kDelim);
      if (dir.IsNull())
         continue;              // ignore blank entries
      newPath.Append(dir);
      if (!newPath.EndsWith("/"))
         newPath.Append("/");
      newPath.Append(newBase);
      newPath.Append(kDelim);
   }

   return newPath.Strip(TString::kTrailing, kDelim);
}

//______________________________________________________________________________
Int_t TTabCom::Hook(char *buf, int *pLoc, ostream& out)
{
   // [private]

   // initialize
   fBuf = buf;
   fpLoc = pLoc;

   // frodo: iteration counter for recursive MakeClassFromVarName
   fLastIter = 0;

   // default
   Int_t pos = -2;  // position of the first character that was changed in the buffer (needed for redrawing)

   // get the context this tab was triggered in.
   EContext_t context = DetermineContext();

   // get the substring that triggered this tab (as defined by "SetPattern()")
   const char dummy[] = ".";
   TRegexp re1(context == kUNKNOWN_CONTEXT ? dummy : fRegExp[context]);
   TString s1(fBuf);
   TString s2 = s1(0, *fpLoc);
   TString s3 = s2(re1);

   switch (context) {
   case kUNKNOWN_CONTEXT:
      cerr << endl << "tab completion not implemented for this context" <<
          endl;
      pos = -2;
      break;

   case kSYS_UserName:
      {
         const TSeqCollection *pListOfUsers = GetListOfUsers();

         pos = Complete("[^~]*$", pListOfUsers, "/", out);
      }
      break;
   case kSYS_EnvVar:
      {
         const TSeqCollection *pEnv = GetListOfEnvVars();

         pos = Complete("[^$]*$", pEnv, "", out);
      }
      break;

   case kCINT_stdout:
   case kCINT_stderr:
   case kCINT_stdin:
      {
         const TString fileName = s3("[^ ><]*$");
         const TString filePath = DeterminePath(fileName,0);
         const TSeqCollection *pListOfFiles =
             GetListOfFilesInPath(filePath.Data());

//             pos = Complete( "[^ /]*$", pListOfFiles, " ", out );
         pos = Complete("[^ /]*$", pListOfFiles, "filename ", out);
      }
      break;

   case kCINT_Edit:
   case kCINT_Load:
   case kCINT_Exec:
   case kCINT_EXec:
      {
         const TString fileName = s3("[^ ]*$");
         const TString macroPath =
             DeterminePath(fileName, TROOT::GetMacroPath());
         const TSeqCollection *pListOfFiles =
             GetListOfFilesInPath(macroPath.Data());

//             pos = Complete( "[^ /]*$", pListOfFiles, " ", out);
         pos = Complete("[^ /]*$", pListOfFiles, "filename ", out);
      }
      break;

   case kCINT_pragma:
      {
         pos = Complete("[^ ]*$", GetListOfPragmas(), "", out);
      }
      break;
   case kCINT_includeSYS:
      {
         TString fileName = s3("[^<]*$");
         if (PathIsSpecifiedInFileName(fileName) || fileName.Contains("/")) {
            TString includePath =
                DeterminePath(fileName, GetSysIncludePath());

//                  pos = Complete( "[^</]*$", GetListOfFilesInPath( includePath ), "> ", out);
            pos =
                Complete("[^</]*$", GetListOfFilesInPath(includePath),
                         "filename> ", out);
         } else {
//                  pos = Complete( "[^</]*$", GetListOfSysIncFiles(), "> ", out);
            pos =
                Complete("[^</]*$", GetListOfSysIncFiles(), "filename> ", out);
         }
      }
      break;
   case kCINT_includePWD:
      {
         const TString fileName = s3("[^\"]*$");
         const TString includePath = DeterminePath(fileName, ".");
         const TSeqCollection *pListOfFiles =
             GetListOfFilesInPath(includePath.Data());

//             pos = Complete( "[^\"/]*$", pListOfFiles, "\" ", out);
         pos = Complete("[^\"/]*$", pListOfFiles, "filename\" ", out);
      }
      break;

   case kCINT_cpp:
      {
         pos = Complete("[^# ]*$", GetListOfCppDirectives(), " ", out);
      }
      break;

   case kROOT_Load:
      {
         const TString fileName = s3("[^\"]*$");
//             const TString  dynamicPath  = DeterminePath( fileName, TROOT::GetDynamicPath() ); /* should use this one */
         const TString dynamicPath = DeterminePath(fileName,gEnv->GetValue("Root.DynamicPath",(char *) 0));
         const TSeqCollection *pListOfFiles = GetListOfFilesInPath(dynamicPath);

//             pos = Complete( "[^\"/]*$", pListOfFiles, "\");", out);
         pos = Complete("[^\"/]*$", pListOfFiles, "filename\");", out);
      }
      break;

   case kSYS_FileName:
      {
         const TString fileName = s3("[^ \"]*$");
         const TString filePath = DeterminePath(fileName,".");
         const TSeqCollection *pListOfFiles = GetListOfFilesInPath(filePath.Data());

         pos = Complete("[^\" /]*$", pListOfFiles, "filename\"", out);
      }
      break;

   case kCXX_ScopeMember:
      {
         const EContext_t original_context = context;  // save this for later

         TClass *pClass;
         // may be a namespace, class, object, or pointer
         TString name = s3("^[_a-zA-Z][_a-zA-Z0-9]*");

         IfDebug(cerr << endl);
         IfDebug(cerr << "name: " << '"' << name << '"' << endl);

         // We need to decompose s3 a little more:
         // The part name is the partial symbol at the end of ::
         // eg. given s3 = "foo::bar::part" ,  partname = "part"
         TString partname = s3("[_a-zA-Z][_a-zA-Z0-9]*$");

         // The prefix, considering the s3 = "foo::bar::part" example would be
         // prefix = "foo::bar::". prefix equals the empty string if there is only one
         // or no set of colons in s3.
         // Note: we reconstruct the fully qualified name with a while loop because
         // it does not seem that TRegexp can handle something like "([_a-zA-Z][_a-zA-Z0-9]*::)+$"
         TString prefix = "";
         TString str = s2;
         str.Remove(str.Length() - partname.Length(), partname.Length());
         while (1) {
            TString sym = str("[_a-zA-Z][_a-zA-Z0-9]*::$");
            if (sym.Length() == 0)
               break;
            str.Remove(str.Length() - sym.Length(), sym.Length());
            prefix = sym + prefix;
         }

         // Not the preprefix would be = "foo::" from our previous example or the empty
         // string, "" if there is only one or no set of colons in prefix, eg. prefix = "bar::"
         TString preprefix = prefix;
         TString sym = prefix("[_a-zA-Z][_a-zA-Z0-9]*::$");
         preprefix.Remove(preprefix.Length() - sym.Length(), sym.Length());

         IfDebug(cerr << "prefix: " << '"' << prefix << '"' << endl);
         IfDebug(cerr << "preprefix: " << '"' << preprefix << '"' << endl);

         TString namesp = prefix;
         if (namesp.Length() >= 2)
            namesp.Remove(namesp.Length() - 2, 2);  // Remove the '::' at the end of the string.
         IfDebug(cerr << "namesp: " << '"' << namesp << '"' << endl);

         // Make sure autoloading happens (if it can).
         delete TryMakeClassFromClassName(namesp);

         // Sometimes, eg on startup of ROOT fpNamespaces might be 0,
         // so create and fill the array.
         if (!fpNamespaces)
            RehashClasses();

         // Try find the namesp string in the list of namespaces. If its found then
         // we need to treat the different prefices a little differently:
         TObjString objstr(namesp);
         TObjString *foundstr = 0;
         if (fpNamespaces)
            foundstr = (TObjString *)fpNamespaces->FindObject(&objstr);
         if (foundstr) {
            TContainer *pList = new TContainer;

            // Add all classes to pList that contain the prefix, i.e. are in the
            // specified namespace.
            const TSeqCollection *tmp = GetListOfClasses();
            if (!tmp) break;

            Int_t i;
            for (i = 0; i < tmp->GetSize(); i++) {
               TString astr = ((TObjString *) tmp->At(i))->String();
               TString rxp = "^";
               rxp += prefix;
               if (astr.Contains(TRegexp(rxp))) {
                  astr.Remove(0, prefix.Length());
                  TString s = astr("^[^: ]*");
                  TObjString *ostr = new TObjString(s);
                  if (!pList->Contains(ostr))
                     pList->Add(ostr);
                  else
                     delete ostr;
               }
            }

            // Add all the sub-namespaces in the specified namespace.
            for (i = 0; i < fpNamespaces->GetSize(); i++) {
               TString astr =
                   ((TObjString *) fpNamespaces->At(i))->String();
               TString rxp = "^";
               rxp += prefix;
               if (astr.Contains(TRegexp(rxp))) {
                  astr.Remove(0, prefix.Length());
                  TString s = astr("^[^: ]*");
                  TObjString *ostr = new TObjString(s);
                  if (!pList->Contains(ostr))
                     pList->Add(ostr);
                  else
                     delete ostr;
               }
            }

            // If a class with the same name as the Namespace name exists then
            // add it to the pList. (I don't think the C++ spec allows for this
            // but do this anyway, cant harm).
            pClass = TryMakeClassFromClassName(preprefix + name);
            if (pClass) {
               pList->AddAll(pClass->GetListOfAllPublicMethods());
               pList->AddAll(pClass->GetListOfAllPublicDataMembers());
            }

            pos = Complete("[^: ]*$", pList, "", out);

            delete pList;
            if (pClass)
               delete pClass;
         } else {
            pClass = MakeClassFromClassName(preprefix + name);
            if (!pClass) {
               pos = -2;
               break;
            }

            TContainer *pList = new TContainer;

            pList->AddAll(pClass->GetListOfAllPublicMethods());
            pList->AddAll(pClass->GetListOfAllPublicDataMembers());

            pos = Complete("[^: ]*$", pList, "(", out);

            delete pList;
            delete pClass;
         }

         if (context != original_context)
            pos = -2;
      }
      break;

   case kCXX_DirectMember:
   case kCXX_IndirectMember:
      {
         const EContext_t original_context = context;  // save this for later

         TClass *pClass;

         // frodo: Instead of just passing the last portion of the string to
         //        MakeClassFromVarName(), we now pass the all string and let
         //        it decide how to handle it... I know it's not the best way
         //        because of the context handling, but I wanted to "minimize"
         //        the changes to the current code and this seemed the best way
         //        to do it
         TString name = s1("[_a-zA-Z][-_a-zA-Z0-9<>():.]*$");

         IfDebug(cerr << endl);
         IfDebug(cerr << "name: " << '"' << name << '"' << endl);

         switch (context) {
         case kCXX_DirectMember:
            pClass = MakeClassFromVarName(name, context);
            break;
         case kCXX_IndirectMember:
            pClass = MakeClassFromVarName(name, context);
            break;
         default:
            assert(0);
            break;
         }
         if (!pClass) {
            pos = -2;
            break;
         }

         TContainer *pList = new TContainer;

         pList->AddAll(pClass->GetListOfAllPublicMethods());
         pList->AddAll(pClass->GetListOfAllPublicDataMembers());

         switch (context) {
         case kCXX_DirectMember:
            {
               int* store_fpLoc = fpLoc;
               char* store_fBuf = fBuf;
               pos = Complete("[^. ]*$", pList, "(", out);
               if (pos == -1) {
                  fpLoc = store_fpLoc;
                  fBuf = store_fBuf;
                  pos = Complete("[^. ]*$", pList, "(", out, TString::kIgnoreCase);
               }
               break;
            }
         case kCXX_IndirectMember:
            pos = Complete("[^> ]*$", pList, "(", out);
            break;
         default:
            assert(0);
            break;
         }

         delete pList;
         delete pClass;

         if (context != original_context)
            pos = -2;
      }
      break;

   case kCXX_ScopeProto:
      {
         const EContext_t original_context = context;  // save this for later

         // get class
         TClass *pClass;
         TString name = s3("^[_a-zA-Z][_a-zA-Z0-9]*");
         // "name" may now be the name of a class, object, or pointer

         IfDebug(cerr << endl);
         IfDebug(cerr << "name: " << '"' << name << '"' << endl);

         // We need to decompose s3 a little more:
         // The partname is the method symbol and a bracket at the end of ::
         // eg. given s3 = "foo::bar::part(" ,  partname = "part("
         TString partname = s3("[_a-zA-Z][_a-zA-Z0-9]* *($");

         // The prefix, considering the s3 = "foo::bar::part" example would be
         // prefix = "foo::bar::". prefix equals the empty string if there is only one
         // or no set of colons in s3.
         // Note: we reconstruct the fully qualified name with a while loop because
         // it does not seem that TRegexp can handle something like "([_a-zA-Z][_a-zA-Z0-9]*::)+$"
         TString prefix = "";
         TString str = s2;
         str.Remove(str.Length() - partname.Length(), partname.Length());
         while (1) {
            TString sym = str("[_a-zA-Z][_a-zA-Z0-9]*::$");
            if (sym.Length() == 0)
               break;
            str.Remove(str.Length() - sym.Length(), sym.Length());
            prefix = sym + prefix;
         }

         // Not the preprefix would be = "foo::" from our previous example or the empty
         // string, "" if there is only one or no set of colons in prefix, eg. prefix = "bar::"
         TString preprefix = prefix;
         TString sym = prefix("[_a-zA-Z][_a-zA-Z0-9]*::$");
         preprefix.Remove(preprefix.Length() - sym.Length(), sym.Length());

         IfDebug(cerr << "prefix: " << '"' << prefix << '"' << endl);
         IfDebug(cerr << "preprefix: " << '"' << preprefix << '"' << endl);

         pClass = MakeClassFromClassName(preprefix + name);
         if (!pClass) {
            pos = -2;
            break;
         }
         // get method name
         TString methodName;

         // (normal member function)
         methodName = s3("[^:>\\.(]*($");
         methodName.Chop();
         methodName.Remove(TString::kTrailing, ' ');

         IfDebug(cerr << methodName << endl);

         // get methods
         TContainer *pList = new TContainer;
         pList->AddAll(pClass->GetListOfAllPublicMethods());

         // print prototypes
         Bool_t foundOne = kFALSE;
         TIter nextMethod(pList);
         TMethod *pMethod;
         while ((pMethod = (TMethod *) nextMethod())) {
            if (methodName == pMethod->GetName()) {
               foundOne = kTRUE;
               out << endl << pMethod->GetReturnTypeName()
                   << " " << pMethod->GetName()
                   << pMethod->GetSignature();
               const char *comment = pMethod->GetCommentString();
               if (comment && comment[0] != '\0') {
                  out << " \t// " << comment;
               }
            }
         }

         // done
         if (foundOne) {
            out << endl;
            pos = -2;
         } else {
            gSystem->Beep();
            pos = -1;
         }

         // cleanup
         delete pList;
         delete pClass;

         if (context != original_context)
            pos = -2;
      }
      break;

   case kCXX_DirectProto:
   case kCXX_IndirectProto:
   case kCXX_NewProto:
   case kCXX_ConstructorProto:
      {
         const EContext_t original_context = context;  // save this for later

         // get class
         TClass *pClass;
         TString name;
         if (context == kCXX_NewProto) {
            name = s3("[_a-zA-Z][_a-zA-Z0-9:]* *($", 3);
            name.Chop();
            name.Remove(TString::kTrailing, ' ');
            // "name" should now be the name of a class
         } else {
            name = s3("^[_a-zA-Z][_a-zA-Z0-9:]*");
            // "name" may now be the name of a class, object, or pointer
         }
         IfDebug(cerr << endl);
         IfDebug(cerr << "name: " << '"' << name << '"' << endl);

         // frodo: Again, passing the all string
         TString namerec = s1;

         switch (context) {
         case kCXX_ScopeProto:
            pClass = MakeClassFromClassName(name);
            break;
         case kCXX_DirectProto:
            pClass = MakeClassFromVarName(namerec, context); // frodo
            break;
         case kCXX_IndirectProto:
            pClass = MakeClassFromVarName(namerec, context); // frodo
            break;
         case kCXX_NewProto:
            pClass = MakeClassFromClassName(name);
            break;
         case kCXX_ConstructorProto:
            pClass = MakeClassFromClassName(name);
            break;
         default:
            assert(0);
            break;
         }
         if (!pClass) {
            pos = -2;
            break;
         }
         // get method name
         TString methodName;
         if (context == kCXX_ConstructorProto || context == kCXX_NewProto) {
            // (constructor)
            methodName = name("[_a-zA-Z][_a-zA-Z0-9]*$");
         } else {
            // (normal member function)
            methodName = s3("[^:>\\.(]*($");
            methodName.Chop();
            methodName.Remove(TString::kTrailing, ' ');
         }
         IfDebug(cerr << methodName << endl);

         // get methods
         TContainer *pList = new TContainer;
         pList->AddAll(pClass->GetListOfAllPublicMethods());

         // print prototypes
         Bool_t foundOne = kFALSE;
         TIter nextMethod(pList);
         TMethod *pMethod;
         while ((pMethod = (TMethod *) nextMethod())) {
            if (methodName == pMethod->GetName()) {
               foundOne = kTRUE;
               out << endl << pMethod->GetReturnTypeName()
                   << " " << pMethod->GetName()
                   << pMethod->GetSignature();
               const char *comment = pMethod->GetCommentString();
               if (comment && comment[0] != '\0') {
                  out << " \t// " << comment;
               }
            }
         }

         // done
         if (foundOne) {
            out << endl;
            pos = -2;
         } else {
            gSystem->Beep();
            pos = -1;
         }

         // cleanup
         delete pList;
         delete pClass;

         if (context != original_context)
            pos = -2;
      }
      break;

   case kCXX_Global:
      {
         // first need to veto a few possibilities.
         int l2 = s2.Length(), l3 = s3.Length();

         // "abc().whatever[TAB]"
         if (l2 > l3 && s2[l2 - l3 - 1] == '.') {
            cerr << endl <<
                "tab completion not implemented for this context" << endl;
            break;              // veto
         }
         // "abc()->whatever[TAB]"
         if (l2 > l3 + 1 && s2(l2 - l3 - 2, 2) == "->") {
            cerr << endl <<
                "tab completion not implemented for this context" << endl;
            break;              // veto
         }

         TContainer *pList = new TContainer;

         const TSeqCollection *pL2 = GetListOfClasses();
         if (pL2) pList->AddAll(pL2);

         if (fpNamespaces) pList->AddAll(fpNamespaces); //rdm
         //
         const TSeqCollection *pC1 = GetListOfGlobals();
         if (pC1) pList->AddAll(pC1);
         //
         const TSeqCollection *pC3 = GetListOfGlobalFunctions();
         if (pC3) pList->AddAll(pC3);

         pos = Complete("[_a-zA-Z][_a-zA-Z0-9]*$", pList, "", out);

         delete pList;
      }
      break;

   case kCXX_GlobalProto:
      {
         // get function name
         TString functionName = s3("[_a-zA-Z][_a-zA-Z0-9]*");
         IfDebug(cerr << functionName << endl);

         TContainer listOfMatchingGlobalFuncs;
         TIter nextGlobalFunc(GetListOfGlobalFunctions());
         TObject *pObj;
         while ((pObj = nextGlobalFunc())) {
            if (strcmp(pObj->GetName(), functionName) == 0) {
               listOfMatchingGlobalFuncs.Add(pObj);
            }
         }

         if (listOfMatchingGlobalFuncs.IsEmpty()) {
            cerr << endl << "no such function: " << dblquote(functionName)
                << endl;
         } else {
            out << endl;
            TIter next(&listOfMatchingGlobalFuncs);
            TFunction *pFunction;
            while ((pFunction = (TFunction *) next())) {
               out << pFunction->GetReturnTypeName()
                   << " " << pFunction->GetName()
                   << pFunction->GetSignature()
                   << endl;
            }
         }

         pos = -2;
      }
      break;

      /******************************************************************/
      /*                                                                */
      /* default: should never happen                                   */
      /*                                                                */
      /******************************************************************/
   default:
      assert(0);
      break;
   }

   return pos;
}

//______________________________________________________________________________
void TTabCom::InitPatterns()
{
   // [private]

   // add more patterns somewhere below.
   // add corresponding enum to "EContext_t"
   //
   // note:
   // 1. in some cases order is important ...
   //
   //    the order of the "case" statements in "switch( context )" in "TTabCom::Hook()" is Not important.
   //
   //    the order of the "SetPattern()" function calls below is Not important.
   //
   //    the order of the initializers in the "EContext_t" enumeration Is important
   //    because DetermineContext() goes through the array in order, and returns at the first match.
   //
   // 2. below, "$" will match cursor position

   SetPattern(kSYS_UserName, "~[_a-zA-Z0-9]*$");
   SetPattern(kSYS_EnvVar, "$[_a-zA-Z0-9]*$");

   SetPattern(kCINT_stdout, "; *>>?.*$");  // stdout
   SetPattern(kCINT_stderr, "; *2>>?.*$"); // stderr
   SetPattern(kCINT_stdin, "; *<.*$");     // stdin

   SetPattern(kCINT_Edit, "^ *\\.E .*$");
   SetPattern(kCINT_Load, "^ *\\.L .*$");
   SetPattern(kCINT_Exec, "^ *\\.x +[-0-9_a-zA-Z~$./]*$");
   SetPattern(kCINT_EXec, "^ *\\.X +[-0-9_a-zA-Z~$./]*$");

   SetPattern(kCINT_pragma, "^# *pragma +[_a-zA-Z0-9]*$");
   SetPattern(kCINT_includeSYS, "^# *include *<[^>]*$");   // system files
   SetPattern(kCINT_includePWD, "^# *include *\"[^\"]*$"); // local files

   SetPattern(kCINT_cpp, "^# *[_a-zA-Z0-9]*$");

   SetPattern(kROOT_Load, "gSystem *-> *Load *( *\"[^\"]*$");

   SetPattern(kCXX_NewProto, "new +[_a-zA-Z][_a-zA-Z0-9:]* *($");
   SetPattern(kCXX_ConstructorProto,
              "[_a-zA-Z][_a-zA-Z0-9:]* +[_a-zA-Z][_a-zA-Z0-9]* *($");
   SetPattern(kCXX_ScopeProto,
              "[_a-zA-Z][_a-zA-Z0-9]* *:: *[_a-zA-Z0-9]* *($");
   SetPattern(kCXX_DirectProto,
              "[_a-zA-Z][_a-zA-Z0-9()]* *\\. *[_a-zA-Z0-9]* *($");
   SetPattern(kCXX_IndirectProto,
              "[_a-zA-Z][_a-zA-Z0-9()]* *-> *[_a-zA-Z0-9]* *($");

   SetPattern(kCXX_ScopeMember,
              "[_a-zA-Z][_a-zA-Z0-9]* *:: *[_a-zA-Z0-9]*$");
   SetPattern(kCXX_DirectMember,
              "[_a-zA-Z][_a-zA-Z0-9()]* *\\. *[_a-zA-Z0-9()]*$");  // frodo
   SetPattern(kCXX_IndirectMember,
              "[_a-zA-Z][_a-zA-Z0-9()]* *-> *[_a-zA-Z0-9()]*$");    // frodo

   SetPattern(kSYS_FileName, "\"[-0-9_a-zA-Z~$./]*$");
   SetPattern(kCXX_Global, "[_a-zA-Z][_a-zA-Z0-9]*$");
   SetPattern(kCXX_GlobalProto, "[_a-zA-Z][_a-zA-Z0-9]* *($");
}

//______________________________________________________________________________
TClass *TTabCom::MakeClassFromClassName(const char className[]) const
{
   // [private]
   //   (does some specific error handling that makes the function unsuitable for general use.)
   //   returns a new'd TClass given the name of a class.
   //   user must delete.
   //   returns 0 in case of error.

   // the TClass constructor will print a Warning message for classes that don't exist
   // so, ignore warnings temporarily.
   NoMsg(kWarning);
   TClass *pClass = new TClass(className);
   NoMsg(-1);

   // make sure "className" exists
   // if (pClass->Size() == 0) {   //namespace has 0 size
   if (pClass->GetListOfAllPublicMethods()->GetSize() == 0 &&
       pClass->GetListOfAllPublicDataMembers()->GetSize() == 0) {
      // i'm assuming this happens iff there was some error.
      // (misspelled the class name, for example)
      cerr << endl << "class " << dblquote(className) << " not defined." <<
          endl;
      return 0;
   }

   return pClass;
}

//______________________________________________________________________________
TClass *TTabCom::TryMakeClassFromClassName(const char className[]) const
{
   // Same as above but does not print the error message.

   // the TClass constructor will print a Warning message for classes that don't exist
   // so, ignore warnings temporarily.
   NoMsg(kWarning);
   TClass *pClass = new TClass(className);
   NoMsg(-1);

   // make sure "className" exists
   // if (pClass->Size() == 0) {   //namespace has 0 size
   if (pClass->GetListOfAllPublicMethods()->GetSize() == 0 &&
       pClass->GetListOfAllPublicDataMembers()->GetSize() == 0) {
      return 0;
   }

   return pClass;
}

//______________________________________________________________________________
TClass *TTabCom::MakeClassFromVarName(const char varName[],
                                      EContext_t & context, int iter)
{
   // [private]
   //   (does some specific error handling that makes the function unsuitable for general use.)
   //   returns a new'd TClass given the name of a variable.
   //   user must delete.
   //   returns 0 in case of error.
   //   if user has operator.() or operator->() backwards, will modify: context, *fpLoc and fBuf.
   //   context sensitive behavior.

   // frodo:
   // Because of the Member and Proto recursion, this has become a bit
   // complicated, so here is how it works:
   //
   // root [1] var.a.b.c[TAB]
   //
   // will generate the sucessive calls:
   // MakeClassFromVarName("var.a.b.c", context, 0) returns the class of "c"
   // MakeClassFromVarName("var.a.b", context, 1)   returns the class of "b"
   // MakeClassFromVarName("var.a", context, 2)     returns the class of "a"
   // MakeClassFromVarName("var", context, 3)

   // need to make sure "varName" exists
   // because "DetermineClass()" prints clumsy error message otherwise.
   Bool_t varName_exists = GetListOfGlobals()->Contains(varName) || // check in list of globals first.
       (gROOT->FindObject(varName) != 0);  // then check CINT "shortcut #3"


   //
   // frodo: Member and Proto recursion code
   //
   if (0) printf("varName is [%s] with iteration [%i]\n", varName, iter);

   // ParseReverse will return 0 if there are no "." or "->" in the varName
   Int_t cut = ParseReverse(varName, strlen(varName));

   // If it's not a "simple" variable and if there is at least one "." or "->"
   if (!varName_exists && cut != 0)
   {
      TString parentName = varName;
      TString memberName = varName;

      // Check to see if this is the last call (last member/method)
      if (iter > fLastIter) fLastIter = iter;

      parentName[cut] = 0;
      if (0) printf("Parent string is [%s]\n", parentName.Data());

      // We are treating here cases like h->SetXTitle(gROOT->Get<TAB>
      // i.e. when the parentName has an unbalanced number of paranthesis.
      if (cut>2) {
         UInt_t level = 0;
         for(Int_t i = cut-1; i>=0; --i) {
            switch (parentName[i]) {
               case '(':
                  if (level) --level;
                  else {
                     parentName = parentName(i+1,cut-i-1);
                     i = 0;
                  }
                  break;
               case ')':
                  ++level; break;
            }
         }
      }

      TClass *pclass;
      // Can be "." or "->"
      if (varName[cut] == '.') {
         memberName = varName+cut+1;
         if (0) printf("Member/method is [%s]\n", memberName.Data());
         EContext_t subcontext = kCXX_DirectMember;
         pclass = MakeClassFromVarName(parentName.Data(), subcontext, iter+1);
      } else {
         memberName = varName+cut+2;
         if (0) printf("Member/method is [%s]\n", memberName.Data());
         EContext_t subcontext = kCXX_IndirectMember;
         pclass = MakeClassFromVarName(parentName.Data(), subcontext, iter+1);
      }

      if (0) printf("I got [%s] from MakeClassFromVarName()\n", pclass->GetName());

      if (pclass)
      {
         if (0) printf("Variable [%s] exists!\n", parentName.Data());

         // If it's back in the first call of the function, return immediatly
         if (iter == 0) return pclass;

         if (0) printf("Trying data member [%s] of class [%s] ...\n",
            memberName.Data(), pclass->GetName());

         // Check if it's a member
         TDataMember *dmptr = 0; //pclass->GetDataMember(memberName.Data());
         TList  *dlist = pclass->GetListOfDataMembers();
         TIter   next(pclass->GetListOfAllPublicDataMembers());
         while ((dmptr = (TDataMember *) next())) {
            if (memberName == dmptr->GetName()) break;
         }
         delete dlist;
         if (dmptr)
         {
            if (0) printf("It's a member!\n");

            TString returnName = dmptr->GetTypeName();
            //              if (returnName[returnName.Length()-1] == '*')
            //                  printf("It's a pointer!\n");

            TClass *mclass = new TClass(returnName.Data());
            return mclass;
         }


         // Check if it's a proto: must have ()
         // This might not be too safe to use   :(
         char *parentesis_ptr = (char*)strrchr(memberName.Data(), '(');
         if (parentesis_ptr) *parentesis_ptr = 0;


         if (0) printf("Trying method [%s] of class [%s] ...\n",
            memberName.Data(), pclass->GetName());

         // Check if it's a method
         TMethod *mptr = 0; // pclass->GetMethodAny(memberName.Data());
         TList  *mlist = pclass->GetListOfAllPublicMethods();
         next = mlist;
         while ((mptr = (TMethod *) next())) {
            if (strcmp(memberName.Data(),mptr->GetName())==0) break;
         }
         delete mlist;

         if (mptr)
         {
            TString returnName = mptr->GetReturnTypeName();

            if (0) printf("It's a method called [%s] with return type [%s]\n",
               memberName.Data(), returnName.Data());

            // This will handle the methods that returns a pointer to a class
            if (returnName[returnName.Length()-1] == '*')
            {
               returnName[returnName.Length()-1] = 0;
               fVarIsPointer = kTRUE;
            }
            else
            {
               fVarIsPointer = kFALSE;
            }

            TClass *mclass = new TClass(returnName.Data());
            return mclass;
         }
      }
   }

   //
   // frodo: End of Member and Proto recursion code
   //


   // not found...
   if (!varName_exists) {
      cerr << endl << "variable " << dblquote(varName) << " not defined."
         << endl;
      return 0;                 //* RETURN *//
   }

   /*****************************************************************************************/
   /*                                                                                       */
   /*  this section is really ugly.                                                         */
   /*  and slow.                                                                            */
   /*  it could be made a lot better if there was some way to tell whether or not a given   */
   /*  variable is a pointer or a pointer to a pointer.                                     */
   /*                                                                                       */
   /*****************************************************************************************/

   TString className = DetermineClass(varName);

   if (className.IsNull() || className == "*") {
      // this will happen if "varName" is a fundamental type (as opposed to class type).
      // or a pointer to a pointer.
      // or a function pointer.
      cerr << endl << "problem determining class of " << dblquote(varName)
         << endl;
      return 0;                 //* RETURN *//
   }

   fVarIsPointer = className[className.Length() - 1] == '*';

   // frodo: I shouldn't have to do this, but for some reason now I have to
   //        otherwise the varptr->[TAB] won't work    :(
   if (fVarIsPointer)
      className[className.Length()-1] = 0;

   //
   // frodo: I wasn't able to put the automatic "." to "->" replacing working
   //        so I just commented out.
   //


   //   Bool_t varIsPointer = className[className.Length() - 1] == '*';

   //printf("Context is %i, fContext is %i, pointer is %i\n", context, fContext, fVarIsPointer);

   if (fVarIsPointer &&
      (context == kCXX_DirectMember || context == kCXX_DirectProto)) {
         // user is using operator.() instead of operator->()
         // ==>
         //      1. we are in wrong context.
         //      2. user is lazy
         //      3. or maybe confused

         // 1. fix the context
         switch (context) {
      case kCXX_DirectMember:
         context = kCXX_IndirectMember;
         break;
      case kCXX_DirectProto:
         context = kCXX_IndirectProto;
         break;
      default:
         assert(0);
         break;
         }

         // 2. fix the operator.
         int i;
         for (i = *fpLoc; fBuf[i] != '.'; i -= 1) {
         }
         int loc = i;
         for (i = strlen(fBuf); i >= loc; i -= 1) {
            fBuf[i + 1] = fBuf[i];
         }
         fBuf[loc] = '-';
         fBuf[loc + 1] = '>';
         *fpLoc += 1;

         // 3. inform the user.
         cerr << endl << dblquote(varName) <<
            " is of pointer type. Use this operator: ->" << endl;
   }

   if (context == kCXX_IndirectMember || context == kCXX_IndirectProto) {
      if (fVarIsPointer) {
         // frodo: This part no longer makes sense...
         className.Chop();      // remove the '*'

         if (className[className.Length() - 1] == '*') {
            cerr << endl << "can't handle pointers to pointers." << endl;
            return 0;           // RETURN
         }
      } else {
         // user is using operator->() instead of operator.()
         // ==>
         //      1. we are in wrong context.
         //      2. user is lazy
         //      3. or maybe confused

         // 1. fix the context
         switch (context) {
         case kCXX_IndirectMember:
            context = kCXX_DirectMember;
            break;
         case kCXX_IndirectProto:
            context = kCXX_DirectProto;
            break;
         default:
            assert(0);
            break;
         }

         // 2. fix the operator.
         int i;
         for (i = *fpLoc; fBuf[i - 1] != '-' && fBuf[i] != '>'; i -= 1) {
         }
         fBuf[i - 1] = '.';
         int len = strlen(fBuf);
         for (; i < len; i += 1) {
            fBuf[i] = fBuf[i + 1];
         }
         *fpLoc -= 1;

         // 3. inform the user.
         cerr << endl << dblquote(varName) <<
             " is not of pointer type. Use this operator: ." << endl;
      }
   }

   return new TClass(className);
}

//______________________________________________________________________________
void TTabCom::SetPattern(EContext_t handle, const char regexp[])
{
   // [private]

   // prevent overflow
   if (handle >= kNUM_PAT) {
      cerr << endl
          << "ERROR: handle="
          << (int) handle << " >= kNUM_PAT=" << (int) kNUM_PAT << endl;
      return;
   }

   fRegExp[handle] = regexp;
   Makepat(regexp, fPat[handle], MAX_LEN_PAT);
}



//______________________________________________________________________________
int TTabCom::ParseReverse(const char *var_str, int start)
{
   //
   // Returns the place in the string where to put the \0, starting the search
   // from "start"
   //
   int end = 0;
   if (start > (int)strlen(var_str)) start = strlen(var_str);

   for (int i = start; i > 0; i--)
   {
      if (var_str[i] == '.') return i;
      if (var_str[i] == '>' && i > 0 && var_str[i-1] == '-') return i-1;
   }

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