JobCRootEnv.cxx

Go to the documentation of this file.

// $Id: JobCRootEnv.cxx,v 1.35 2007/04/26 14:22:13 west Exp $
//
// A class to manage the ROOT global environment
//
// messier@huhepl.harvard.edu
#include "JobControl/JobCRootEnv.h"

#include <TSystem.h>

#include <iostream>
#include <cassert>     // assert
#include <cstring>     // strlen, strncmp
#include <cstdio>      // sprintf
using namespace std;
extern "C" {
#include <sys/types.h> // opendir, closedir
#include <dirent.h>    // opendir, closedir
#ifdef MACOSX
  #include <unistd.h>
#else
  #include <getopt.h>
#endif
#ifndef GETOPTDONE     // Some getopt.h's have this, some don't...
#define GETOPTDONE (-1)
#endif
}
#include "MessageService/MsgService.h"
// ROOT include files
#include "TROOT.h"
#include "TRint.h"
#include "TSystem.h"
#include "TString.h"
#include "TSysEvtHandler.h"
#include "TInterpreter.h"

#include "JobControl/IsArgMacroFile.h"

CVSID("$Id: JobCRootEnv.cxx,v 1.35 2007/04/26 14:22:13 west Exp $");

//......................................................................

JobCRootEnv::JobCRootEnv(int argc, char** argv) : 
  fHaveBatchOpt(false),
  fHaveQuitOpt(false),
  fHaveMacroFiles(false),
  fHaveInaccessibleFile(false)
{
//======================================================================
// Purpose: Set up the ROOT environment
//
// Inputs:
//  argc - number of command line arguments
//  argv - array of command line arguments
//======================================================================
  // Root only understands a subset of the command line arguments we
  // might want to allow. This makes a copy of command line arguments
  // ROOT understands.
  static int   localArgc = 0;   // Copy of command line args.
  static char* localArgv[1024]; // Copy of command line args.
  if (argc>0) {
    localArgv[localArgc++] = argv[0];
  }
  else {
    localArgv[localArgc++] = const_cast<char*>("moot"); // Dummy program name
  }
  
  // Setup the ROOT globals. gROOT from TROOT.h
  if (gROOT==0) {
    static TROOT root("TROOT",localArgv[0]);
  }
  assert(gROOT);

  // Setup the application
  TApplication* app = gROOT->GetApplication();
  if (app==0) {
    int c;

#ifndef MACOSX
  optind = 0; // getopt.h: Reset getopt to start of arguments
#else
  optind = 1; // skip 0th argument ("loon") for MACOSX
#endif

#ifdef IRIX6
    getoptreset(); // needed by IRIX to reset getopt
#endif
    const char* opts = "bs:nqlt:r:x:hH:d:u:p:o:v:";
    while ((c=getopt(argc, argv, opts)) != GETOPTDONE) {
      MSG("JobC",Msg::kDebug)
        << "Processing job command-line ROOT option argument: "
        << c << " '" << (char)c << "'" << endl;
      switch (c) {
        // const_cast because these are string constants but TRint
        // ctor needs a char**
      case 'l': localArgv[localArgc++] = const_cast<char*>("-l"); break;
      case 'b': localArgv[localArgc++] = const_cast<char*>("-b"); fHaveBatchOpt = true; break;
      case 'n': localArgv[localArgc++] = const_cast<char*>("-n"); break;
      case 'q': localArgv[localArgc++] = const_cast<char*>("-q"); fHaveQuitOpt  = true; break;
      case 'h': localArgv[localArgc++] = const_cast<char*>("-h"); break;
      default: break;
      }
    }

    // Add the directory/macro file stuff to the list
    int ndir = 0; // Number of directories specified on command line
    for (int i=optind; i<argc; ++i) {
      // Check if argv[i] is a directory -- if yes add it to the ROOT
      // command line
      DIR* d = opendir(argv[i]);
      if (d) {
        localArgv[localArgc++] = argv[i];
        closedir(d);
        ++ndir;
      }

      // Check if argv[i] is a ROOT macro file
      // if yes add it to the ROOT command line
      TString fname = IsArgMacroFile(argv[i]);
      if (fname != "") {
        if (gSystem->AccessPathName(fname.Data())) {
          cerr << "Skipping inaccessible file: " << argv[i] << endl;
          fHaveInaccessibleFile = true;
          continue;
        }
        fHaveMacroFiles = true;
        localArgv[localArgc++] = argv[i];
      }
    }
    // If the user has two directories on the command line they've
    // made a mistake. Kindly inform them of that mistake...
    if (ndir>1) {
      MSG("JobC",Msg::kError) << 
        "Ambiguous: More than one directory specified on command line.\n";
      exit(1);
    }

    // Create the ROOT application. This is a little confusing. The
    // "new" goes off and puts the TRint application off into ROOT
    // global space (gROOT). I can check that's true with the
    // assert(). I'm assuming gROOT has taken control of the delete
    // for this class. The assert checks that the first part is
    // true. I guess I'd have to look at the root code to see if the
    // second assumption is also true.
    TRint* rint = new TRint("TAPP",&localArgc,localArgv,0,0,kTRUE);
    assert(rint == gROOT->GetApplication());
    std::string p = gSystem->BaseName(localArgv[0]); p += " [%d] ";
    rint->SetPrompt(p.c_str());    

    // Configure the ROOT session
    this->SignalConfig();
    this->InterpreterConfig();
    this->LoadIncludes();
    this->LoadClasses();
  }
}

//......................................................................

void JobCRootEnv::InterpreterConfig()
{
//======================================================================
// Configure the root interpreter
//======================================================================
  if (gInterpreter) { // gInterpreter from TInterpreter.h
    gInterpreter->SaveContext();
    gInterpreter->SaveGlobalsContext();
  }
}

//......................................................................

void JobCRootEnv::SignalConfig() 
{
//======================================================================
// Configure root's signale handlers
//======================================================================
  if (gSystem) { // gSystem from TSystem.h
    // Reset ROOT's signal handling to the defaults...
    gSystem->ResetSignal(kSigBus,                  kTRUE);
    gSystem->ResetSignal(kSigSegmentationViolation,kTRUE);
    gSystem->ResetSignal(kSigSystem,               kTRUE);
    gSystem->ResetSignal(kSigPipe,                 kTRUE);
    gSystem->ResetSignal(kSigIllegalInstruction,   kTRUE);
    gSystem->ResetSignal(kSigQuit,                 kTRUE);
    if (fHaveBatchOpt)
      gSystem->ResetSignal(kSigInterrupt,          kTRUE);
    gSystem->ResetSignal(kSigWindowChanged,        kTRUE);
    //rwh: 2004-09-07 leave ROOT's version of SigAlarm handling in place
    //gSystem->ResetSignal(kSigAlarm,                kTRUE);
    gSystem->ResetSignal(kSigChild,                kTRUE);
    gSystem->ResetSignal(kSigUrgent,               kTRUE);
    gSystem->ResetSignal(kSigFloatingException,    kTRUE);
    gSystem->ResetSignal(kSigTermination,          kTRUE);
    gSystem->ResetSignal(kSigUser1,                kTRUE);
    gSystem->ResetSignal(kSigUser2,                kTRUE);
  }
}

//......................................................................

void JobCRootEnv::LoadIncludes()
{
//======================================================================
// Load include files to make the root session more covenient
//======================================================================
  TApplication* app = gROOT->GetApplication();
  if (app) {
    // Load a set of useful C++ includes.
    // app->ProcessLine("#include <iostream>"); // Root gets this one itself
    app->ProcessLine("#include <iomanip>");
    app->ProcessLine("#include <string>");

    // Load minos include files
    TString mp = gROOT->GetMacroPath();
    TString ip;
    const char* p;
    p = gSystem->Getenv("SRT_PRIVATE_CONTEXT");
    if (p) {
      mp += ":";
      mp += p;
      mp += ":";
      mp += p;
      mp += "/macros";
      ip += " -I";
      ip += p;
    }
    p = gSystem->Getenv("SRT_PUBLIC_CONTEXT");
    if (p) {
      mp += ":";
      mp += p;
      mp += "/macros";
      ip += " -I";
      ip += p;
    }
    
    gROOT->SetMacroPath(mp.Data());
    gSystem->SetIncludePath(ip);
    
    TString dip = ".include ";
    dip += gSystem->Getenv("SRT_PRIVATE_CONTEXT");
    gROOT->ProcessLine(dip.Data());

    dip = ".include ";
    dip += gSystem->Getenv("SRT_PUBLIC_CONTEXT");
    gROOT->ProcessLine(dip.Data());
    dip += "/RDBC/include";
    gROOT->ProcessLine(dip.Data());
  }
}

//......................................................................

void JobCRootEnv::LoadClasses()
{
//======================================================================
// Load classes to make the root session more covenient
//======================================================================
  if (gROOT) {
    gROOT->LoadClass("TGeometry",   "Graf3d");
    gROOT->LoadClass("TTree",       "Tree");
    gROOT->LoadClass("TMatrix",     "Matrix");
    gROOT->LoadClass("TMinuit",     "Minuit");
    gROOT->LoadClass("TPostScript", "Postscript");
    gROOT->LoadClass("TCanvas",     "Gpad");
    gROOT->LoadClass("THtml",       "Html");
  }
}

//......................................................................

JobCRootEnv::~JobCRootEnv() 
{
//======================================================================
// Purpose: Shut down the ROOT session
//======================================================================
}

//......................................................................

int JobCRootEnv::RunTheApp()
{
//======================================================================
// Purpose: Turn control over to the ROOT application
//======================================================================
  TApplication* app = gROOT->GetApplication();
  if (app) {
    app->Run(kTRUE); // kTRUE == "Return from run" request...
    return 1;
  }
  return 0;
}

---