JobCRootModule.cxx

Go to the documentation of this file.

// $Id: JobCRootModule.cxx,v 1.8 2002/06/13 15:45:49 rhatcher Exp $
#include "JobControl/JobCRootModule.h"

#include <cassert>

// ROOT include files
#include "TROOT.h"
#include "TSystem.h"
#include "TObjectTable.h"
#include "TRint.h"
#include "TEnv.h"
#include "TInterpreter.h"
// for function: char* Form(const char *fmt, ...)
#include "TString.h"

#include "JobControl/JobCModuleRegistry.h"
#include "JobControl/JobCommand.h"

#include "MessageService/MsgService.h"

CVSID("$Id: JobCRootModule.cxx,v 1.8 2002/06/13 15:45:49 rhatcher Exp $");
JOBMODULE(JobCRootModule, 
          "Root", "Directly handle ROOT commands passed to JobC");

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

JobCRootModule::JobCRootModule() 
{
   MSG("Root",Msg::kVerbose) << "JobCRootModule::ctor" << endl;
}

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

JobCRootModule::~JobCRootModule() 
{
   MSG("Root",Msg::kVerbose) << "JobCRootModule::dtor" << endl;
}

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

void JobCRootModule::Report() 
{
   MSG("Root",Msg::kWarning) << "JobCRootModule::Report" << endl;
}

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

void JobCRootModule::Reset() 
{
   MSG("Root",Msg::kWarning) << "JobCRootModule::Reset" << endl;
}

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

void JobCRootModule::InitRoot() 
{
   // Perform any necessary initialization
   // including putting TApplication into TRint-like mode
   MSG("Root",Msg::kVerbose) << "JobCRootModule::InitRoot" << endl;

   static bool first = true;
   if (!first) return;

   first = false;
   // Make sure there is a TApp running
   // if we plan on using CINT facilities
   TApplication* app = gROOT->GetApplication();
   if (app) {
      TRint* trint = dynamic_cast<TRint*>(app);
      if (!trint) {
         MSG("Root",Msg::kDebug) 
            << "JobCRootModule::InitRoot not a TRint" << endl;
         // initialize Root's CINT to be more like it would be
         // if this were a TRint, while still not running
         // the user's 
         app->ProcessLine("#include <iostream.h>");
         
         // TRint would do the following:
#ifdef TRINTLIKE
         // The following libs are also useful to have,
         // make sure they are loaded...
         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");
#endif
      } else {
         MSG("Root",Msg::kDebug)
            << "JobCRootModule::InitRoot was a TRint" << endl;
      }
      app->ProcessLine("#include <iomanip.h>");
      app->ProcessLine("#include <string>");
      gInterpreter->SaveContext();
      gInterpreter->SaveGlobalsContext();
   } else {
      MSG("Root",Msg::kFatal)
         << "JobCRootModule::InitRoot no TApplication" << endl;
   }

}

//......................................................................
void JobCRootModule::PassPtrToRoot(string className, 
                                   string instanceName,
                                   const void* ptr, bool isConst)
{
   // Pass a pointer to some class object to ROOT so
   // ProcessLine has access to the object
   // any "const"ness of "ptr" is *NOT* preserved if you lie via "isConst"

   // make sure TApp is running so that CINT with <iostream.h> is defined
   InitRoot();
   TApplication* app = gROOT->GetApplication();

   const char*  strConst = "";
   if (isConst) strConst = "const";

   // thanks Brett Viren for this "dirty trick".
   string theline = Form("%s %s* %s = (%s %s *)0x%lx",
                         strConst,
                         className.c_str(),
                         instanceName.c_str(),
                         strConst,
                         className.c_str(),
                         reinterpret_cast<unsigned long>(ptr));

   MSG("Root",Msg::kDebug) 
      << "JobCRootCommandModule::PassPtrToRoot " 
      << endl << theline << endl;

   app->ProcessLine(theline.c_str());
}

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

void JobCRootModule::HandleCommand(JobCommand* cmd) 
{

   static int ncmd = 0;
   ncmd++;

   class BadJobCRootCmd { };

   // make sure TApp is running so that CINT with <iostream.h> is defined
   InitRoot();

   try {
      TApplication* app = gROOT->GetApplication();
      const char* c = cmd->PopCmd();
      if (c) {
         string sc(c);
         if ((sc == "RunMacro")            || 
             (sc == "LoadMacro")           || 
             (sc == "CompileMacro")        || 
             (sc == "ForceCompileMacro")   || 
             (sc == "ProcessLine")            ) {
            string wholeLine;
            // eat up rest of line
            while (const char* opt = cmd->PopOpt()) {
               wholeLine += " ";  // put back in the spaces
               wholeLine += opt;
            }
            if (sc == "RunMacro")  wholeLine.insert(0,".x ");
            if (sc == "LoadMacro" || sc == "CompileMacro") 
               wholeLine.insert(0,".L ");
            if (sc == "CompileMacro") wholeLine += "+";
            if (sc == "ForceCompileMacro") wholeLine += "++";
            app->ProcessLine(wholeLine.c_str());
         }
         else if (sc == "StartBrowser") {
            static int nbrowser = 0; 
            nbrowser++;
            string bstart("TBrowser RootModuleBrowser");
            bstart += Form("%d",nbrowser);
            app->ProcessLine(bstart.c_str());
         }
         else if (sc == "LoadLibrary") {
            const char* libraryName = cmd->PopOpt();
            Int_t status = gSystem->Load(libraryName);
            MSG("Root",Msg::kInfo) 
               << Form("(Int_t) %d = gSystem->Load(%s)",
                       status,libraryName)
               << endl;
         }
         else if (sc == "LoadClass") {
            const char* className   = cmd->PopOpt();
            const char* libraryName = cmd->PopOpt();
            Int_t status = gROOT->LoadClass(className,libraryName);
            MSG("Root",Msg::kInfo) 
               << Form("(Int_t) %d = gROOT->LoadClass(%s,%s)",
                       status,className,libraryName)
               << endl;
         }
         else if (sc == "MacroPath") {
            const char* c2 = cmd->PopCmd();
            // if no further part of the command: assume user meant "Reset"
            if (!c2) c2 = "Reset";
            string sc2(c2);
            const char* opt = cmd->PopOpt();
            if (!opt) opt = "";
            if (sc2 == "Add") {
               // add first opt to from of macropath
               TString tsopt(opt);
               tsopt += ":";
               tsopt += TROOT::GetMacroPath();
               TROOT::SetMacroPath(tsopt);
            }
            else if (sc2 == "Reset") {
               // reset the path
               // if user supplied an option then full path is that
               // if not then the path is cleared and will be refetched
               // from the gEnv "database".
               TROOT::SetMacroPath(opt);
            }
            else if (sc2 == "Show") {
               // do nothing we'll always show the value
            }
            else {
               MSG("Root",Msg::kWarning) 
                  << "\"" << sc2 << "\": "
                  << "Not a valid sub-comand of " << sc << endl;
               throw BadJobCRootCmd();
            }
            MSG("Root",Msg::kInfo)
               << "MacroPath is \""
               << TROOT::GetMacroPath()
               << "\"" << endl;
         }
         else if (sc == "ObjectStat") {
            const char* c2 = cmd->PopCmd();
            // if no further part of the command: assume user meant "Print"
            if (!c2) c2 = "Print";
            string sc2(c2);
            if (sc2 == "Print") {
               if (gObjectTable) {
                  gObjectTable->Print();
               } else {
                  MSG("Root",Msg::kInfo) 
                     << "Sorry no gObjectTable available" << endl;
               }
            }
            else if (sc2 == "Set") {
               bool toggle = true;
               const char* val = cmd->PopOpt();
               if (val) {
                  // there was an actual value, use that
                  cmd->PushOpt();
                  toggle = (bool) cmd->PopIntOpt();
               }
               TObject::SetObjectStat(toggle);
            }
            else {
               MSG("Root",Msg::kWarning) 
                  << "\"" << sc2 << "\": "
                  << "Not a valid sub-comand of " << sc<< endl;
               throw BadJobCRootCmd();
            }
         }
         else if (sc == "Reset") {
            gROOT->Reset(cmd->PopOpt());
         }
         else if (sc == "SaveContext") {
            gROOT->SaveContext();
         }
         else if (sc == "SetStyle") {
            gROOT->SetStyle(cmd->PopOpt());
         }
         else {
            MSG("Root",Msg::kWarning) 
               << "\"" << sc << "\":"
               << " Not a valid command" << endl;
            throw BadJobCRootCmd();
         }
      }
      else {
         throw BadJobCRootCmd();
      }
   }
   catch ( BadJobCRootCmd ) {
      static bool firsthelp = true;
      if (firsthelp) Help();
      firsthelp = false;
   }
}

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

void JobCRootModule::Help()
{
   //
   // Print help for this module
   //

   const char *name = this->GetName();

   MSG("JobC", Msg::kInfo)
      << "Help for '" << name << "': " 
      << name 
      << " is a JobCModule interfacing to ROOT from JobControl" << endl
      << "Commands implemented:" 
      << endl << endl
//--------------
      << "  /" << name << "/RunMacro   <macro.C>    // root [] .x <macro.C>"
      << endl
      << "  /" << name << "/LoadMacro  <macro.C>    // root [] .L <macro.C>"
      << endl
      << "  /" << name << "/CompileMacro  <macro.C> // root [] .L <macro.C>+"
      << endl
      << "  /" << name << "/ForceCompileMacro  <macro.C> // root [] .L <macro.C>++"
      << endl
      << "     Run or Load a macro file, like .x or .L at ROOT prompt"
      << endl << endl
//--------------
      << "  /" << name << "/ProcessLine <arbitrary text>"
      << endl
      << "     Process line just like at ROOT prompt"
      << endl << endl
//--------------
      << "  /" << name << "/StartBrowser"
      << endl
      << "     Start a TBrowser"
      << endl << endl
//--------------
      << "  /" << name << "/LoadLibrary <libraryName> "
      << endl
      << "     Make a dynamic library available (via gSystem)"
      << endl << endl
//--------------
      << "  /" << name << "/LoadClass <className> <libraryName> "
      << endl
      << "     Make a class available out of a dynamic library (via gROOT)"
      << endl << endl
//--------------
      << "  /" << name << "/MacroPath/Add <location(s)>"
      << endl
      << "  /" << name << "/MacroPath/Reset [<full list>]"
      << endl
      << "  /" << name << "/MacroPath/Show"
      << endl
      << "     Manipulate the locations where ROOT looks for macros;"
      << endl
      << "     path is a colon separated list:"
      << endl
      << "        Add to the front of the list"
      << endl
      << "        Reset to fixed value (default: initial ROOT defined value)"
      << endl
      << "        Show the current setting"
      << endl << endl
//--------------
      << "  /" << name << "/ObjectStat/Set [1|0]"
      << endl
      << "  /" << name << "/ObjectStat/Print"
      << endl
      << "     TObject statistics collection (via gObjectTable):"
      << endl
      << "        Turn [on|off] the statistics collection (default: on)"
      << endl
      << "        Print the gObjectTable"
      << endl << endl
//--------------
      << "  /" << name << "/Reset "
      << endl
      << "     Reset ROOT"
      << endl << endl
//--------------
      << "  /" << name << "/SaveContext"
      << endl
      << "     Have the interpreter save the current context"
      << endl << endl
//--------------
      << "  /" << name << "/SetStyle <styleName>"
      << endl
      << "     Set the ROOT Style"
      << endl << endl
//--------------
      << endl;
}

---