ROOT logo
// @(#)root/rint:$Id$
// Author: Rene Brun   17/02/95

/*************************************************************************
 * 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.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Rint                                                                 //
//                                                                      //
// Rint is the ROOT Interactive Interface. It allows interactive access //
// to the ROOT system via the CINT C/C++ interpreter.                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TROOT.h"
#include "TClass.h"
#include "TVirtualX.h"
#include "TStyle.h"
#include "TObjectTable.h"
#include "TClassTable.h"
#include "TStopwatch.h"
#include "TBenchmark.h"
#include "TRint.h"
#include "TSystem.h"
#include "TEnv.h"
#include "TSysEvtHandler.h"
#include "TSystemDirectory.h"
#include "TError.h"
#include "TException.h"
#include "TInterpreter.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TTabCom.h"
#include "TError.h"
#include <stdlib.h>

#include "Getline.h"

#ifdef R__UNIX
#include <signal.h>
#endif

R__EXTERN void *gMmallocDesc; //is used and set in TMapFile and TClass

//______________________________________________________________________________
static Int_t Key_Pressed(Int_t key)
{
   gApplication->KeyPressed(key);
   return 0;
}

//______________________________________________________________________________
static Int_t BeepHook()
{
   if (!gSystem) return 0;
   gSystem->Beep();
   return 1;
}

//______________________________________________________________________________
static void ResetTermAtExit()
{
   // Restore terminal to non-raw mode.

   Getlinem(kCleanUp, 0);
}


//----- Interrupt signal handler -----------------------------------------------
//______________________________________________________________________________
class TInterruptHandler : public TSignalHandler {
public:
   TInterruptHandler() : TSignalHandler(kSigInterrupt, kFALSE) { }
   Bool_t  Notify();
};

//______________________________________________________________________________
Bool_t TInterruptHandler::Notify()
{
   // TRint interrupt handler.

   if (fDelay) {
      fDelay++;
      return kTRUE;
   }

   // make sure we use the sbrk heap (in case of mapped files)
   gMmallocDesc = 0;

   if (!gCint->GetSecurityError())
      gCint->GenericError("\n *** Break *** keyboard interrupt");
   else {
      Break("TInterruptHandler::Notify", "keyboard interrupt");
      if (TROOT::Initialized()) {
         Getlinem(kInit, "Root > ");
         gCint->RewindDictionary();
#ifndef WIN32
         Throw(GetSignal());
#endif
      }
   }
   return kTRUE;
}

//----- Terminal Input file handler --------------------------------------------
//______________________________________________________________________________
class TTermInputHandler : public TFileHandler {
public:
   TTermInputHandler(Int_t fd) : TFileHandler(fd, 1) { }
   Bool_t Notify();
   Bool_t ReadNotify() { return Notify(); }
};

//______________________________________________________________________________
Bool_t TTermInputHandler::Notify()
{
   // Notify implementation.  Call the application interupt handler.

   return gApplication->HandleTermInput();
}


ClassImp(TRint)

//______________________________________________________________________________
TRint::TRint(const char *appClassName, Int_t *argc, char **argv, void *options,
             Int_t numOptions, Bool_t noLogo)
       : TApplication(appClassName, argc, argv, options, numOptions)
{
   // Create an application environment. The TRint environment provides an
   // interface to the WM manager functionality and eventloop via inheritance
   // of TApplication and in addition provides interactive access to
   // the CINT C++ interpreter via the command line.

   fNcmd          = 0;
   fDefaultPrompt = "root [%d] ";
   fInterrupt     = kFALSE;

   gBenchmark = new TBenchmark();

   if (!noLogo && !NoLogoOpt()) {
      Bool_t lite = (Bool_t) gEnv->GetValue("Rint.WelcomeLite", 0);
      PrintLogo(lite);
   }

   // Explicitly load libMathCore as CINT will not auto load it when using one
   // of its globals. Once moved to Cling, which should work correctly, we
   // can remove this statement.
   gSystem->Load("libMathCore");

   // Load some frequently used includes
   Int_t includes = gEnv->GetValue("Rint.Includes", 1);
   // When the interactive ROOT starts, it can automatically load some frequently
   // used includes. However, this introduces several overheads
   //   -A long list of cint and system files must be kept open during the session
   //   -The initialisation takes more time (noticeable when using gdb or valgrind)
   //   -Memory overhead of about 5 Mbytes (1/3 of the ROOT executable) when including <vector>
   // In $ROOTSYS/etc/system.rootrc, you can set the variable Rint.Includes to 0
   // to disable the loading of these includes at startup.
   // You can set the variable to 1 (default) to load only <string> and <RTypesCint.h>
   // You can set it to 2 to load in addition <vector> and <pair>
   // We strongly recommend setting the variable to 2 if your scripts include <vector>
   // and you execute your scripts multiple times.
   if (includes > 0) {
      ProcessLine("#include <string>", kTRUE); // for std::string iostream.
      ProcessLine("#include <DllImport.h>", kTRUE);// Defined R__EXTERN
      if (includes > 1) {
         ProcessLine("#include <vector>", kTRUE);  // Needed because std::vector and std::pair are
         ProcessLine("#include <pair>", kTRUE);    // used within the core ROOT dictionaries
                                                   // and CINT will not be able to properly unload these files
      }
   }

   // Load user functions
   const char *logon;
   logon = gEnv->GetValue("Rint.Load", (char*)0);
   if (logon) {
      char *mac = gSystem->Which(TROOT::GetMacroPath(), logon, kReadPermission);
      if (mac)
         ProcessLine(Form(".L %s",logon), kTRUE);
      delete [] mac;
   }

   // Execute logon macro
   ExecLogon();

   // Save current interpreter context
   gCint->SaveContext();
   gCint->SaveGlobalsContext();

   // Install interrupt and terminal input handlers
   TInterruptHandler *ih = new TInterruptHandler();
   ih->Add();
   SetSignalHandler(ih);

   // Handle stdin events
   fInputHandler = new TTermInputHandler(0);
   fInputHandler->Add();

   // Goto into raw terminal input mode
   char defhist[kMAXPATHLEN];
   snprintf(defhist, sizeof(defhist), "%s/.root_hist", gSystem->HomeDirectory());
   logon = gEnv->GetValue("Rint.History", defhist);
   // In the code we had HistorySize and HistorySave, in the rootrc and doc
   // we have HistSize and HistSave. Keep the doc as it is and check
   // now also for HistSize and HistSave in case the user did not use
   // the History versions
   int hist_size = gEnv->GetValue("Rint.HistorySize", 500);
   if (hist_size == 500)
      hist_size = gEnv->GetValue("Rint.HistSize", 500);
   int hist_save = gEnv->GetValue("Rint.HistorySave", 400);
   if (hist_save == 400)
      hist_save = gEnv->GetValue("Rint.HistSave", 400);
   const char *envHist = gSystem->Getenv("ROOT_HIST");
   if (envHist) {
      hist_size = atoi(envHist);
      envHist = strchr(envHist, ':');
      if (envHist)
         hist_save = atoi(envHist+1);
   }
   Gl_histsize(hist_size, hist_save);
   Gl_histinit((char *)logon);

   // black on white or white on black?
   static const char* defaultColorsBW[] = {
      "bold blue", "magenta", "bold green", "bold red underlined", "default"
   };
   static const char* defaultColorsWB[] = {
      "yellow", "magenta", "bold green", "bold red underlined", "default"
   };

   const char** defaultColors = defaultColorsBW;
   TString revColor = gEnv->GetValue("Rint.ReverseColor", "no");
   if (revColor.Contains("yes", TString::kIgnoreCase)) {
      defaultColors = defaultColorsWB;
   }
   TString colorType = gEnv->GetValue("Rint.TypeColor", defaultColors[0]);
   TString colorTabCom = gEnv->GetValue("Rint.TabComColor", defaultColors[1]);
   TString colorBracket = gEnv->GetValue("Rint.BracketColor", defaultColors[2]);
   TString colorBadBracket = gEnv->GetValue("Rint.BadBracketColor", defaultColors[3]);
   TString colorPrompt = gEnv->GetValue("Rint.PromptColor", defaultColors[4]);
   Gl_setColors(colorType, colorTabCom, colorBracket, colorBadBracket, colorPrompt);

   Gl_windowchanged();

   atexit(ResetTermAtExit);

   // Setup for tab completion
   gTabCom      = new TTabCom;
   Gl_in_key    = &Key_Pressed;
   Gl_beep_hook = &BeepHook;

   // tell CINT to use our getline
   gCint->SetGetline(Getline, Gl_histadd);
}

//______________________________________________________________________________
TRint::~TRint()
{
   // Destructor.

   delete gTabCom;
   gTabCom = 0;
   Gl_in_key = 0;
   Gl_beep_hook = 0;
   fInputHandler->Remove();
   delete fInputHandler;
   // We can't know where the signal handler was changed since we started ...
   // so for now let's not delete it.
//   TSignalHandler *ih  = GetSignalHandler();
//   ih->Remove();
//   SetSignalHandler(0);
//   delete ih;
}

//______________________________________________________________________________
void TRint::ExecLogon()
{
   // Execute logon macro's. There are three levels of logon macros that
   // will be executed: the system logon etc/system.rootlogon.C, the global
   // user logon ~/.rootlogon.C and the local ./.rootlogon.C. For backward
   // compatibility also the logon macro as specified by the Rint.Logon
   // environment setting, by default ./rootlogon.C, will be executed.
   // No logon macros will be executed when the system is started with
   // the -n option.

   if (NoLogOpt()) return;

   TString name = ".rootlogon.C";
   TString sname = "system";
   sname += name;
#ifdef ROOTETCDIR
   char *s = gSystem->ConcatFileName(ROOTETCDIR, sname);
#else
   TString etc = gRootDir;
#ifdef WIN32
   etc += "\\etc";
#else
   etc += "/etc";
#endif
   char *s = gSystem->ConcatFileName(etc, sname);
#endif
   if (!gSystem->AccessPathName(s, kReadPermission)) {
      ProcessFile(s);
   }
   delete [] s;
   s = gSystem->ConcatFileName(gSystem->HomeDirectory(), name);
   if (!gSystem->AccessPathName(s, kReadPermission)) {
      ProcessFile(s);
   }
   delete [] s;
   // avoid executing ~/.rootlogon.C twice
   if (strcmp(gSystem->HomeDirectory(), gSystem->WorkingDirectory())) {
      if (!gSystem->AccessPathName(name, kReadPermission))
         ProcessFile(name);
   }

   // execute also the logon macro specified by "Rint.Logon"
   const char *logon = gEnv->GetValue("Rint.Logon", (char*)0);
   if (logon) {
      char *mac = gSystem->Which(TROOT::GetMacroPath(), logon, kReadPermission);
      if (mac)
         ProcessFile(logon);
      delete [] mac;
   }
}

//______________________________________________________________________________
void TRint::Run(Bool_t retrn)
{
   // Main application eventloop. First process files given on the command
   // line and then go into the main application event loop, unless the -q
   // command line option was specfied in which case the program terminates.
   // When retrun is true this method returns even when -q was specified.
   //
   // When QuitOpt is true and retrn is false, terminate the application with
   // an error code equal to either the ProcessLine error (if any) or the
   // return value of the command casted to a long.

   Getlinem(kInit, GetPrompt());

   Long_t retval = 0;
   Int_t  error = 0;
   volatile Bool_t needGetlinemInit = kFALSE;

   if (strlen(WorkingDirectory())) {
      // if directory specified as argument make it the working directory
      gSystem->ChangeDirectory(WorkingDirectory());
      TSystemDirectory *workdir = new TSystemDirectory("workdir", gSystem->WorkingDirectory());
      TObject *w = gROOT->GetListOfBrowsables()->FindObject("workdir");
      TObjLink *lnk = gROOT->GetListOfBrowsables()->FirstLink();
      while (lnk) {
         if (lnk->GetObject() == w) {
            lnk->SetObject(workdir);
            lnk->SetOption(gSystem->WorkingDirectory());
            break;
         }
         lnk = lnk->Next();
      }
      delete w;
   }

   // Process shell command line input files
   if (InputFiles()) {
      // Make sure that calls into the event loop
      // ignore end-of-file on the terminal.
      fInputHandler->DeActivate();
      TIter next(InputFiles());
      RETRY {
         retval = 0; error = 0;
         Int_t nfile = 0;
         TObjString *file;
         while ((file = (TObjString *)next())) {
            char cmd[kMAXPATHLEN+50];
            if (!fNcmd)
               printf("\n");
            Bool_t rootfile = kFALSE;
            
            if (file->String().EndsWith(".root") || file->String().BeginsWith("file:")) {
               rootfile = kTRUE;
            } else {
               FILE *mayberootfile = fopen(file->String(),"rb");
               if (mayberootfile) {
                  char header[5];
                  if (fgets(header,5,mayberootfile)) {
                     rootfile = strncmp(header,"root",4)==0;
                  }
                  fclose(mayberootfile);
               }
            }
            if (rootfile) {
               // special trick to be able to open files using UNC path names
               if (file->String().BeginsWith("\\\\"))
                  file->String().Prepend("\\\\");
               file->String().ReplaceAll("\\","/");
               const char *rfile = (const char*)file->String();
               Printf("Attaching file %s as _file%d...", rfile, nfile);
               snprintf(cmd, kMAXPATHLEN+50, "TFile *_file%d = TFile::Open(\"%s\")", nfile++, rfile);
            } else {
               Printf("Processing %s...", (const char*)file->String());
               snprintf(cmd, kMAXPATHLEN+50, ".x %s", (const char*)file->String());
            }
            Getlinem(kCleanUp, 0);
            Gl_histadd(cmd);
            fNcmd++;

            // The ProcessLine might throw an 'exception'.  In this case,
            // GetLinem(kInit,"Root >") is called and we are jump back
            // to RETRY ... and we have to avoid the Getlinem(kInit, GetPrompt());
            needGetlinemInit = kFALSE;
            retval = ProcessLine(cmd, kFALSE, &error);
            gCint->EndOfLineAction();

            // The ProcessLine has successfully completed and we need
            // to call Getlinem(kInit, GetPrompt());
            needGetlinemInit = kTRUE;

            if (error != 0) break;
         }
      } ENDTRY;

      if (QuitOpt()) {
         if (retrn) return;
         if (error) {
            retval = error;
         }
         // Bring retval into sensible range, 0..125.
         if (retval < 0) retval = 1;
         else if (retval > 125) retval = 1;
         Terminate(retval);
      }

      // Allow end-of-file on the terminal to be noticed
      // after we finish processing the command line input files.
      fInputHandler->Activate();
      
      ClearInputFiles();

      if (needGetlinemInit) Getlinem(kInit, GetPrompt());
   }

   if (QuitOpt()) {
      printf("\n");
      if (retrn) return;
      Terminate(0);
   }

   TApplication::Run(retrn);

   Getlinem(kCleanUp, 0);
}

//______________________________________________________________________________
void TRint::PrintLogo(Bool_t lite)
{
   // Print the ROOT logo on standard output.

   const char *root_version = gROOT->GetVersion();

   if (!lite) {
      static const char *months[] = {"January","February","March","April","May",
                                     "June","July","August","September","October",
                                     "November","December"};
      Int_t idatqq = gROOT->GetVersionDate();
      Int_t iday   = idatqq%100;
      Int_t imonth = (idatqq/100)%100;
      Int_t iyear  = (idatqq/10000);
      char *version_date = Form("%d %s %4d",iday,months[imonth-1],iyear);

      Printf("  *******************************************");
      Printf("  *                                         *");
      Printf("  *        W E L C O M E  to  R O O T       *");
      Printf("  *                                         *");
      Printf("  *   Version%10s %17s   *", root_version, version_date);
      Printf("  *                                         *");
      Printf("  *  You are welcome to visit our Web site  *");
      Printf("  *          http://root.cern.ch            *");
      Printf("  *                                         *");
      Printf("  *******************************************\n");
   }

   Printf("ROOT %s (%s@%s, %s on %s)", root_version, gROOT->GetGitBranch(),
          gROOT->GetGitCommit(), gROOT->GetGitDate(),
          gSystem->GetBuildArch());

   if (!lite)
      gCint->PrintIntro();

#ifdef R__UNIX
   // Popdown X logo, only if started with -splash option
   for (int i = 0; i < Argc(); i++)
      if (!strcmp(Argv(i), "-splash"))
         kill(getppid(), SIGUSR1);
#endif
}

//______________________________________________________________________________
char *TRint::GetPrompt()
{
   // Get prompt from interpreter. Either "root [n]" or "end with '}'".

   char *s = gCint->GetPrompt();
   if (s[0])
      strlcpy(fPrompt, s, sizeof(fPrompt));
   else
      snprintf(fPrompt, sizeof(fPrompt), fDefaultPrompt.Data(), fNcmd);

   return fPrompt;
}

//______________________________________________________________________________
const char *TRint::SetPrompt(const char *newPrompt)
{
   // Set a new default prompt. It returns the previous prompt.
   // The prompt may contain a %d which will be replaced by the commend
   // number. The default prompt is "root [%d] ". The maximum length of
   // the prompt is 55 characters. To set the prompt in an interactive
   // session do:
   // root [0] ((TRint*)gROOT->GetApplication())->SetPrompt("aap> ")
   // aap>

   static TString op = fDefaultPrompt;

   if (newPrompt && strlen(newPrompt) <= 55)
      fDefaultPrompt = newPrompt;
   else
      Error("SetPrompt", "newPrompt too long (> 55 characters)");

   return op.Data();
}

//______________________________________________________________________________
Bool_t TRint::HandleTermInput()
{
   // Handle input coming from terminal.

   static TStopwatch timer;
   const char *line;

   if ((line = Getlinem(kOneChar, 0))) {
      if (line[0] == 0 && Gl_eof())
         Terminate(0);

      gVirtualX->SetKeyAutoRepeat(kTRUE);

      Gl_histadd(line);

      TString sline = line;

      // strip off '\n' and leading and trailing blanks
      sline = sline.Chop();
      sline = sline.Strip(TString::kBoth);
      ReturnPressed((char*)sline.Data());

      fInterrupt = kFALSE;

      if (!gCint->GetMore() && !sline.IsNull()) fNcmd++;

      // prevent recursive calling of this input handler
      fInputHandler->DeActivate();

      if (gROOT->Timer()) timer.Start();

#ifdef R__EH
      Bool_t added = kFALSE;
#endif

      // This is needed when working with remote sessions
      SetBit(kProcessRemotely);

#ifdef R__EH
      try {
#endif
         TRY {
            if (!sline.IsNull())
               LineProcessed(sline);
            ProcessLine(sline);
         } CATCH(excode) {
            // enable again input handler
            fInputHandler->Activate();
#ifdef R__EH
            added = kTRUE;
#endif
            Throw(excode);
         } ENDTRY;
#ifdef R__EH
      }
      // handle every exception
      catch (...) {
         // enable again intput handler
         if (!added) fInputHandler->Activate();
         throw;
      }
#endif

      if (gROOT->Timer()) timer.Print("u");

      // enable again intput handler
      fInputHandler->Activate();

      if (!sline.BeginsWith(".reset"))
         gCint->EndOfLineAction();

      gTabCom->ClearAll();
      Getlinem(kInit, GetPrompt());
   }
   return kTRUE;
}

//______________________________________________________________________________
void TRint::HandleException(Int_t sig)
{
   // Handle exceptions (kSigBus, kSigSegmentationViolation,
   // kSigIllegalInstruction and kSigFloatingException) trapped in TSystem.
   // Specific TApplication implementations may want something different here.

   if (TROOT::Initialized()) {
      if (gException) {
         Getlinem(kCleanUp, 0);
         Getlinem(kInit, "Root > ");
      }
   }
   TApplication::HandleException(sig);
}

//______________________________________________________________________________
void TRint::Terminate(Int_t status)
{
   // Terminate the application. Reset the terminal to sane mode and call
   // the logoff macro defined via Rint.Logoff environment variable.

   Getlinem(kCleanUp, 0);

   if (ReturnFromRun()) {
      gSystem->ExitLoop();
   } else {
      delete gTabCom;
      gTabCom = 0;

      //Execute logoff macro
      const char *logoff;
      logoff = gEnv->GetValue("Rint.Logoff", (char*)0);
      if (logoff && !NoLogOpt()) {
         char *mac = gSystem->Which(TROOT::GetMacroPath(), logoff, kReadPermission);
         if (mac)
            ProcessFile(logoff);
         delete [] mac;
      }

      TApplication::Terminate(status);
   }
}

//______________________________________________________________________________
void TRint::SetEchoMode(Bool_t mode)
{
   // Set console mode:
   //
   //  mode = kTRUE  - echo input symbols
   //  mode = kFALSE - noecho input symbols

   Gl_config("noecho", mode ? 0 : 1);
}

//______________________________________________________________________________
Long_t TRint::ProcessRemote(const char *line, Int_t *)
{
   // Process the content of a line starting with ".R" (already stripped-off)
   // The format is
   //      [user@]host[:dir] [-l user] [-d dbg] [script]
   // The variable 'dir' is the remote directory to be used as working dir.
   // The username can be specified in two ways, "-l" having the priority
   // (as in ssh).
   // A 'dbg' value > 0 gives increasing verbosity.
   // The last argument 'script' allows to specify an alternative script to
   // be executed remotely to startup the session.

   Long_t ret = TApplication::ProcessRemote(line);

   if (ret == 1) {
      if (fAppRemote) {
         TString prompt; prompt.Form("%s:root [%%d] ", fAppRemote->ApplicationName());
         SetPrompt(prompt);
      } else {
         SetPrompt("root [%d] ");
      }
   }

   return ret;
}


//______________________________________________________________________________
Int_t TRint::TabCompletionHook(char *buf, int *pLoc, ostream& out)
{
   // Forward tab completion request to our TTabCom::Hook().
   if (gTabCom)
      return gTabCom->Hook(buf, pLoc, out);

   return -1;
}
 TRint.cxx:1
 TRint.cxx:2
 TRint.cxx:3
 TRint.cxx:4
 TRint.cxx:5
 TRint.cxx:6
 TRint.cxx:7
 TRint.cxx:8
 TRint.cxx:9
 TRint.cxx:10
 TRint.cxx:11
 TRint.cxx:12
 TRint.cxx:13
 TRint.cxx:14
 TRint.cxx:15
 TRint.cxx:16
 TRint.cxx:17
 TRint.cxx:18
 TRint.cxx:19
 TRint.cxx:20
 TRint.cxx:21
 TRint.cxx:22
 TRint.cxx:23
 TRint.cxx:24
 TRint.cxx:25
 TRint.cxx:26
 TRint.cxx:27
 TRint.cxx:28
 TRint.cxx:29
 TRint.cxx:30
 TRint.cxx:31
 TRint.cxx:32
 TRint.cxx:33
 TRint.cxx:34
 TRint.cxx:35
 TRint.cxx:36
 TRint.cxx:37
 TRint.cxx:38
 TRint.cxx:39
 TRint.cxx:40
 TRint.cxx:41
 TRint.cxx:42
 TRint.cxx:43
 TRint.cxx:44
 TRint.cxx:45
 TRint.cxx:46
 TRint.cxx:47
 TRint.cxx:48
 TRint.cxx:49
 TRint.cxx:50
 TRint.cxx:51
 TRint.cxx:52
 TRint.cxx:53
 TRint.cxx:54
 TRint.cxx:55
 TRint.cxx:56
 TRint.cxx:57
 TRint.cxx:58
 TRint.cxx:59
 TRint.cxx:60
 TRint.cxx:61
 TRint.cxx:62
 TRint.cxx:63
 TRint.cxx:64
 TRint.cxx:65
 TRint.cxx:66
 TRint.cxx:67
 TRint.cxx:68
 TRint.cxx:69
 TRint.cxx:70
 TRint.cxx:71
 TRint.cxx:72
 TRint.cxx:73
 TRint.cxx:74
 TRint.cxx:75
 TRint.cxx:76
 TRint.cxx:77
 TRint.cxx:78
 TRint.cxx:79
 TRint.cxx:80
 TRint.cxx:81
 TRint.cxx:82
 TRint.cxx:83
 TRint.cxx:84
 TRint.cxx:85
 TRint.cxx:86
 TRint.cxx:87
 TRint.cxx:88
 TRint.cxx:89
 TRint.cxx:90
 TRint.cxx:91
 TRint.cxx:92
 TRint.cxx:93
 TRint.cxx:94
 TRint.cxx:95
 TRint.cxx:96
 TRint.cxx:97
 TRint.cxx:98
 TRint.cxx:99
 TRint.cxx:100
 TRint.cxx:101
 TRint.cxx:102
 TRint.cxx:103
 TRint.cxx:104
 TRint.cxx:105
 TRint.cxx:106
 TRint.cxx:107
 TRint.cxx:108
 TRint.cxx:109
 TRint.cxx:110
 TRint.cxx:111
 TRint.cxx:112
 TRint.cxx:113
 TRint.cxx:114
 TRint.cxx:115
 TRint.cxx:116
 TRint.cxx:117
 TRint.cxx:118
 TRint.cxx:119
 TRint.cxx:120
 TRint.cxx:121
 TRint.cxx:122
 TRint.cxx:123
 TRint.cxx:124
 TRint.cxx:125
 TRint.cxx:126
 TRint.cxx:127
 TRint.cxx:128
 TRint.cxx:129
 TRint.cxx:130
 TRint.cxx:131
 TRint.cxx:132
 TRint.cxx:133
 TRint.cxx:134
 TRint.cxx:135
 TRint.cxx:136
 TRint.cxx:137
 TRint.cxx:138
 TRint.cxx:139
 TRint.cxx:140
 TRint.cxx:141
 TRint.cxx:142
 TRint.cxx:143
 TRint.cxx:144
 TRint.cxx:145
 TRint.cxx:146
 TRint.cxx:147
 TRint.cxx:148
 TRint.cxx:149
 TRint.cxx:150
 TRint.cxx:151
 TRint.cxx:152
 TRint.cxx:153
 TRint.cxx:154
 TRint.cxx:155
 TRint.cxx:156
 TRint.cxx:157
 TRint.cxx:158
 TRint.cxx:159
 TRint.cxx:160
 TRint.cxx:161
 TRint.cxx:162
 TRint.cxx:163
 TRint.cxx:164
 TRint.cxx:165
 TRint.cxx:166
 TRint.cxx:167
 TRint.cxx:168
 TRint.cxx:169
 TRint.cxx:170
 TRint.cxx:171
 TRint.cxx:172
 TRint.cxx:173
 TRint.cxx:174
 TRint.cxx:175
 TRint.cxx:176
 TRint.cxx:177
 TRint.cxx:178
 TRint.cxx:179
 TRint.cxx:180
 TRint.cxx:181
 TRint.cxx:182
 TRint.cxx:183
 TRint.cxx:184
 TRint.cxx:185
 TRint.cxx:186
 TRint.cxx:187
 TRint.cxx:188
 TRint.cxx:189
 TRint.cxx:190
 TRint.cxx:191
 TRint.cxx:192
 TRint.cxx:193
 TRint.cxx:194
 TRint.cxx:195
 TRint.cxx:196
 TRint.cxx:197
 TRint.cxx:198
 TRint.cxx:199
 TRint.cxx:200
 TRint.cxx:201
 TRint.cxx:202
 TRint.cxx:203
 TRint.cxx:204
 TRint.cxx:205
 TRint.cxx:206
 TRint.cxx:207
 TRint.cxx:208
 TRint.cxx:209
 TRint.cxx:210
 TRint.cxx:211
 TRint.cxx:212
 TRint.cxx:213
 TRint.cxx:214
 TRint.cxx:215
 TRint.cxx:216
 TRint.cxx:217
 TRint.cxx:218
 TRint.cxx:219
 TRint.cxx:220
 TRint.cxx:221
 TRint.cxx:222
 TRint.cxx:223
 TRint.cxx:224
 TRint.cxx:225
 TRint.cxx:226
 TRint.cxx:227
 TRint.cxx:228
 TRint.cxx:229
 TRint.cxx:230
 TRint.cxx:231
 TRint.cxx:232
 TRint.cxx:233
 TRint.cxx:234
 TRint.cxx:235
 TRint.cxx:236
 TRint.cxx:237
 TRint.cxx:238
 TRint.cxx:239
 TRint.cxx:240
 TRint.cxx:241
 TRint.cxx:242
 TRint.cxx:243
 TRint.cxx:244
 TRint.cxx:245
 TRint.cxx:246
 TRint.cxx:247
 TRint.cxx:248
 TRint.cxx:249
 TRint.cxx:250
 TRint.cxx:251
 TRint.cxx:252
 TRint.cxx:253
 TRint.cxx:254
 TRint.cxx:255
 TRint.cxx:256
 TRint.cxx:257
 TRint.cxx:258
 TRint.cxx:259
 TRint.cxx:260
 TRint.cxx:261
 TRint.cxx:262
 TRint.cxx:263
 TRint.cxx:264
 TRint.cxx:265
 TRint.cxx:266
 TRint.cxx:267
 TRint.cxx:268
 TRint.cxx:269
 TRint.cxx:270
 TRint.cxx:271
 TRint.cxx:272
 TRint.cxx:273
 TRint.cxx:274
 TRint.cxx:275
 TRint.cxx:276
 TRint.cxx:277
 TRint.cxx:278
 TRint.cxx:279
 TRint.cxx:280
 TRint.cxx:281
 TRint.cxx:282
 TRint.cxx:283
 TRint.cxx:284
 TRint.cxx:285
 TRint.cxx:286
 TRint.cxx:287
 TRint.cxx:288
 TRint.cxx:289
 TRint.cxx:290
 TRint.cxx:291
 TRint.cxx:292
 TRint.cxx:293
 TRint.cxx:294
 TRint.cxx:295
 TRint.cxx:296
 TRint.cxx:297
 TRint.cxx:298
 TRint.cxx:299
 TRint.cxx:300
 TRint.cxx:301
 TRint.cxx:302
 TRint.cxx:303
 TRint.cxx:304
 TRint.cxx:305
 TRint.cxx:306
 TRint.cxx:307
 TRint.cxx:308
 TRint.cxx:309
 TRint.cxx:310
 TRint.cxx:311
 TRint.cxx:312
 TRint.cxx:313
 TRint.cxx:314
 TRint.cxx:315
 TRint.cxx:316
 TRint.cxx:317
 TRint.cxx:318
 TRint.cxx:319
 TRint.cxx:320
 TRint.cxx:321
 TRint.cxx:322
 TRint.cxx:323
 TRint.cxx:324
 TRint.cxx:325
 TRint.cxx:326
 TRint.cxx:327
 TRint.cxx:328
 TRint.cxx:329
 TRint.cxx:330
 TRint.cxx:331
 TRint.cxx:332
 TRint.cxx:333
 TRint.cxx:334
 TRint.cxx:335
 TRint.cxx:336
 TRint.cxx:337
 TRint.cxx:338
 TRint.cxx:339
 TRint.cxx:340
 TRint.cxx:341
 TRint.cxx:342
 TRint.cxx:343
 TRint.cxx:344
 TRint.cxx:345
 TRint.cxx:346
 TRint.cxx:347
 TRint.cxx:348
 TRint.cxx:349
 TRint.cxx:350
 TRint.cxx:351
 TRint.cxx:352
 TRint.cxx:353
 TRint.cxx:354
 TRint.cxx:355
 TRint.cxx:356
 TRint.cxx:357
 TRint.cxx:358
 TRint.cxx:359
 TRint.cxx:360
 TRint.cxx:361
 TRint.cxx:362
 TRint.cxx:363
 TRint.cxx:364
 TRint.cxx:365
 TRint.cxx:366
 TRint.cxx:367
 TRint.cxx:368
 TRint.cxx:369
 TRint.cxx:370
 TRint.cxx:371
 TRint.cxx:372
 TRint.cxx:373
 TRint.cxx:374
 TRint.cxx:375
 TRint.cxx:376
 TRint.cxx:377
 TRint.cxx:378
 TRint.cxx:379
 TRint.cxx:380
 TRint.cxx:381
 TRint.cxx:382
 TRint.cxx:383
 TRint.cxx:384
 TRint.cxx:385
 TRint.cxx:386
 TRint.cxx:387
 TRint.cxx:388
 TRint.cxx:389
 TRint.cxx:390
 TRint.cxx:391
 TRint.cxx:392
 TRint.cxx:393
 TRint.cxx:394
 TRint.cxx:395
 TRint.cxx:396
 TRint.cxx:397
 TRint.cxx:398
 TRint.cxx:399
 TRint.cxx:400
 TRint.cxx:401
 TRint.cxx:402
 TRint.cxx:403
 TRint.cxx:404
 TRint.cxx:405
 TRint.cxx:406
 TRint.cxx:407
 TRint.cxx:408
 TRint.cxx:409
 TRint.cxx:410
 TRint.cxx:411
 TRint.cxx:412
 TRint.cxx:413
 TRint.cxx:414
 TRint.cxx:415
 TRint.cxx:416
 TRint.cxx:417
 TRint.cxx:418
 TRint.cxx:419
 TRint.cxx:420
 TRint.cxx:421
 TRint.cxx:422
 TRint.cxx:423
 TRint.cxx:424
 TRint.cxx:425
 TRint.cxx:426
 TRint.cxx:427
 TRint.cxx:428
 TRint.cxx:429
 TRint.cxx:430
 TRint.cxx:431
 TRint.cxx:432
 TRint.cxx:433
 TRint.cxx:434
 TRint.cxx:435
 TRint.cxx:436
 TRint.cxx:437
 TRint.cxx:438
 TRint.cxx:439
 TRint.cxx:440
 TRint.cxx:441
 TRint.cxx:442
 TRint.cxx:443
 TRint.cxx:444
 TRint.cxx:445
 TRint.cxx:446
 TRint.cxx:447
 TRint.cxx:448
 TRint.cxx:449
 TRint.cxx:450
 TRint.cxx:451
 TRint.cxx:452
 TRint.cxx:453
 TRint.cxx:454
 TRint.cxx:455
 TRint.cxx:456
 TRint.cxx:457
 TRint.cxx:458
 TRint.cxx:459
 TRint.cxx:460
 TRint.cxx:461
 TRint.cxx:462
 TRint.cxx:463
 TRint.cxx:464
 TRint.cxx:465
 TRint.cxx:466
 TRint.cxx:467
 TRint.cxx:468
 TRint.cxx:469
 TRint.cxx:470
 TRint.cxx:471
 TRint.cxx:472
 TRint.cxx:473
 TRint.cxx:474
 TRint.cxx:475
 TRint.cxx:476
 TRint.cxx:477
 TRint.cxx:478
 TRint.cxx:479
 TRint.cxx:480
 TRint.cxx:481
 TRint.cxx:482
 TRint.cxx:483
 TRint.cxx:484
 TRint.cxx:485
 TRint.cxx:486
 TRint.cxx:487
 TRint.cxx:488
 TRint.cxx:489
 TRint.cxx:490
 TRint.cxx:491
 TRint.cxx:492
 TRint.cxx:493
 TRint.cxx:494
 TRint.cxx:495
 TRint.cxx:496
 TRint.cxx:497
 TRint.cxx:498
 TRint.cxx:499
 TRint.cxx:500
 TRint.cxx:501
 TRint.cxx:502
 TRint.cxx:503
 TRint.cxx:504
 TRint.cxx:505
 TRint.cxx:506
 TRint.cxx:507
 TRint.cxx:508
 TRint.cxx:509
 TRint.cxx:510
 TRint.cxx:511
 TRint.cxx:512
 TRint.cxx:513
 TRint.cxx:514
 TRint.cxx:515
 TRint.cxx:516
 TRint.cxx:517
 TRint.cxx:518
 TRint.cxx:519
 TRint.cxx:520
 TRint.cxx:521
 TRint.cxx:522
 TRint.cxx:523
 TRint.cxx:524
 TRint.cxx:525
 TRint.cxx:526
 TRint.cxx:527
 TRint.cxx:528
 TRint.cxx:529
 TRint.cxx:530
 TRint.cxx:531
 TRint.cxx:532
 TRint.cxx:533
 TRint.cxx:534
 TRint.cxx:535
 TRint.cxx:536
 TRint.cxx:537
 TRint.cxx:538
 TRint.cxx:539
 TRint.cxx:540
 TRint.cxx:541
 TRint.cxx:542
 TRint.cxx:543
 TRint.cxx:544
 TRint.cxx:545
 TRint.cxx:546
 TRint.cxx:547
 TRint.cxx:548
 TRint.cxx:549
 TRint.cxx:550
 TRint.cxx:551
 TRint.cxx:552
 TRint.cxx:553
 TRint.cxx:554
 TRint.cxx:555
 TRint.cxx:556
 TRint.cxx:557
 TRint.cxx:558
 TRint.cxx:559
 TRint.cxx:560
 TRint.cxx:561
 TRint.cxx:562
 TRint.cxx:563
 TRint.cxx:564
 TRint.cxx:565
 TRint.cxx:566
 TRint.cxx:567
 TRint.cxx:568
 TRint.cxx:569
 TRint.cxx:570
 TRint.cxx:571
 TRint.cxx:572
 TRint.cxx:573
 TRint.cxx:574
 TRint.cxx:575
 TRint.cxx:576
 TRint.cxx:577
 TRint.cxx:578
 TRint.cxx:579
 TRint.cxx:580
 TRint.cxx:581
 TRint.cxx:582
 TRint.cxx:583
 TRint.cxx:584
 TRint.cxx:585
 TRint.cxx:586
 TRint.cxx:587
 TRint.cxx:588
 TRint.cxx:589
 TRint.cxx:590
 TRint.cxx:591
 TRint.cxx:592
 TRint.cxx:593
 TRint.cxx:594
 TRint.cxx:595
 TRint.cxx:596
 TRint.cxx:597
 TRint.cxx:598
 TRint.cxx:599
 TRint.cxx:600
 TRint.cxx:601
 TRint.cxx:602
 TRint.cxx:603
 TRint.cxx:604
 TRint.cxx:605
 TRint.cxx:606
 TRint.cxx:607
 TRint.cxx:608
 TRint.cxx:609
 TRint.cxx:610
 TRint.cxx:611
 TRint.cxx:612
 TRint.cxx:613
 TRint.cxx:614
 TRint.cxx:615
 TRint.cxx:616
 TRint.cxx:617
 TRint.cxx:618
 TRint.cxx:619
 TRint.cxx:620
 TRint.cxx:621
 TRint.cxx:622
 TRint.cxx:623
 TRint.cxx:624
 TRint.cxx:625
 TRint.cxx:626
 TRint.cxx:627
 TRint.cxx:628
 TRint.cxx:629
 TRint.cxx:630
 TRint.cxx:631
 TRint.cxx:632
 TRint.cxx:633
 TRint.cxx:634
 TRint.cxx:635
 TRint.cxx:636
 TRint.cxx:637
 TRint.cxx:638
 TRint.cxx:639
 TRint.cxx:640
 TRint.cxx:641
 TRint.cxx:642
 TRint.cxx:643
 TRint.cxx:644
 TRint.cxx:645
 TRint.cxx:646
 TRint.cxx:647
 TRint.cxx:648
 TRint.cxx:649
 TRint.cxx:650
 TRint.cxx:651
 TRint.cxx:652
 TRint.cxx:653
 TRint.cxx:654
 TRint.cxx:655
 TRint.cxx:656
 TRint.cxx:657
 TRint.cxx:658
 TRint.cxx:659
 TRint.cxx:660
 TRint.cxx:661
 TRint.cxx:662
 TRint.cxx:663
 TRint.cxx:664
 TRint.cxx:665
 TRint.cxx:666
 TRint.cxx:667
 TRint.cxx:668
 TRint.cxx:669
 TRint.cxx:670
 TRint.cxx:671
 TRint.cxx:672
 TRint.cxx:673
 TRint.cxx:674
 TRint.cxx:675
 TRint.cxx:676
 TRint.cxx:677
 TRint.cxx:678
 TRint.cxx:679
 TRint.cxx:680
 TRint.cxx:681
 TRint.cxx:682
 TRint.cxx:683
 TRint.cxx:684
 TRint.cxx:685
 TRint.cxx:686
 TRint.cxx:687
 TRint.cxx:688
 TRint.cxx:689
 TRint.cxx:690
 TRint.cxx:691
 TRint.cxx:692
 TRint.cxx:693
 TRint.cxx:694
 TRint.cxx:695
 TRint.cxx:696
 TRint.cxx:697
 TRint.cxx:698
 TRint.cxx:699
 TRint.cxx:700
 TRint.cxx:701
 TRint.cxx:702
 TRint.cxx:703
 TRint.cxx:704
 TRint.cxx:705
 TRint.cxx:706
 TRint.cxx:707