library: libCore #include "TCint.h"

# TCint

class description - source file - inheritance tree (.pdf)

## class TCint : public TInterpreter

| Inheritance Chart:
`TObject`
| <- | `TNamed`
| <- | `TInterpreter`
| <- | `TCint` |

        private:

                       TCint()
          virtual void Execute(TMethod*, TObjArray*, int* = 0)

        protected:

           virtual void ExecThreadCB(char* command)
          virtual Int_t LoadLibraryMap()

        public:

                              TCint(const char* name, const char* title)
                              TCint(const TCint&)
                      virtual ~TCint()
                 virtual void AddIncludePath(const char* path)
                virtual Int_t AutoLoad(const char* classname)
                   static int AutoLoadCallback(const char* cls, const char* lib)
               virtual Long_t Calc(const char* line, TInterpreter::EErrorCode* error = 0)
               virtual Bool_t CheckClassInfo(const char* name)
               static TClass* Class()
                 virtual void ClearFileBusy()
                 virtual void ClearStack()
                 virtual void CreateListOfBaseClasses(TClass* cl)
                 virtual void CreateListOfDataMembers(TClass* cl)
                 virtual void CreateListOfMethodArgs(TFunction* m)
                 virtual void CreateListOfMethods(TClass* cl)
                virtual Int_t DeleteGlobal(void* obj)
                 virtual void EnableAutoLoading()
                 virtual void EndOfLineAction()
                 virtual void Execute(const char* function, const char* params, int* error = 0)
                 virtual void Execute(TObject* obj, TClass* cl, const char* method, const char* params, int* error = 0)
                 virtual void Execute(TObject* obj, TClass* cl, TMethod* method, TObjArray* params, int* error = 0)
               virtual Long_t ExecuteMacro(const char* filename, TInterpreter::EErrorCode* error = 0)
                 static void* FindSpecialObject(const char* name, G__ClassInfo* type, void** prevObj, void** assocPtr)
          virtual const char* GetClassSharedLibs(const char* cls) const
                virtual Int_t GetExitCode() const
          virtual const char* GetIncludePath() const
                virtual void* GetInterfaceMethod(TClass* cl, const char* method, const char* params)
                virtual void* GetInterfaceMethodWithPrototype(TClass* cl, const char* method, const char* proto)
          virtual const char* GetInterpreterTypeName(const char* name, Bool_t full = kFALSE) const
              virtual TString GetMangledName(TClass* cl, const char* method, const char* params)
              virtual TString GetMangledNameWithPrototype(TClass* cl, const char* method, const char* proto)
                virtual Int_t GetMore() const
                virtual char* GetPrompt()
          virtual const char* GetSharedLibDeps(const char* lib) const
          virtual const char* GetSharedLibs() const
                virtual Int_t InitializeDictionaries()
              virtual TClass* IsA() const
               virtual Bool_t IsErrorMessagesEnabled()
               virtual Bool_t IsLoaded(const char* filename) const
                virtual Int_t Load(const char* filenam, Bool_t system = kFALSE)
                 virtual void LoadMacro(const char* filename, TInterpreter::EErrorCode* error = 0)
                       TCint& operator=(const TCint&)
                 virtual void PrintIntro()
               virtual Long_t ProcessLine(const char* line, TInterpreter::EErrorCode* error = 0)
                       Long_t ProcessLineAsynch(const char* line, TInterpreter::EErrorCode* error = 0)
               virtual Long_t ProcessLineSynch(const char* line, TInterpreter::EErrorCode* error = 0)
                 virtual void RecursiveRemove(TObject* obj)
                 virtual void Reset()
                 virtual void ResetAll()
                 virtual void ResetGlobals()
                 virtual void RewindDictionary()
                 virtual void SaveContext()
                 virtual void SaveGlobalsContext()
                 virtual void SetClassInfo(TClass* cl, Bool_t reload = kFALSE)
               virtual Bool_t SetErrorMessages(Bool_t enable = kTRUE)
                 virtual void ShowMembers(TMemberInspector& insp, char* parent)
                 virtual void Streamer(TBuffer& b)
                         void StreamerNVirtual(TBuffer& b)
          virtual const char* TypeName(const char* typeDesc) const
                  static void UpdateAllCanvases()
                  static void UpdateClassInfo(char* name, Long_t tagnum)
                 virtual void UpdateListOfGlobalFunctions()
                 virtual void UpdateListOfGlobals()
                 virtual void UpdateListOfTypes()

### Data Members

        private:

                    Int_t fMore            1 if more input is required
                    Int_t fExitCode        value passed to exit() in interpreter
                     char fPrompt[64]      proposed prompt string
          G__dictposition fDictPos         CINT dictionary context after init
          G__dictposition fDictPosGlobals  CINT dictionary context after ResetGlobals()
                  TString fSharedLibs      hold a list of lib loaded by G__loadfile
                  TString fIncludePath     hold a list of lib include path
                    TEnv* fMapfile         map of classes and libraries

## Class Description

     This class defines an interface to the CINT C/C++ interpreter made
     by Masaharu Goto from HP Japan.

     CINT is an almost full ANSI compliant C/C++ interpreter.

TCint(const char *name, const char *title) : TInterpreter(name, title)

     Initialize the CINT interpreter interface.

~TCint()

     Destroy the CINT interpreter interface.

void ClearFileBusy()

     Reset CINT internal state in case a previous action was not correctly
     terminated by G__init_cint() and G__dlmod().

void ClearStack()

     Delete existing temporary values

Int_t InitializeDictionaries()

     Initialize all registered dictionaries. Normally this is already done
     by G__init_cint() and G__dlmod().

void EnableAutoLoading()

     Enable the automatic loading of shared libraries when a class
     is used that is stored in a not yet loaded library. Uses the
     information stored in the class/library map (typically
     $ROOTSYS/etc/system.rootmap).

void EndOfLineAction()

     It calls a "fantom" method to synchronize user keyboard input
     and ROOT prompt line.

void ExecThreadCB(TWin32SendClass *command)

     This function must be called from the "Command thread only".

Bool_t IsLoaded(const char* filename) const

     Return true if the file has already been loaded by cint.

Int_t Load(const char *filename, Bool_t system)

     Load a library file in CINT's memory.
     if 'system' is true, the library is never unloaded.

void LoadMacro(const char *filename, EErrorCode *error)

     Load a macro file in CINT's memory.

Long_t ProcessLine(const char *line, EErrorCode *error)

     Let CINT process a command line.
     If the command is executed and the result of G__process_cmd is 0,
     the return value is the int value corresponding to the result of the command
     (float and double return values will be truncated).

Long_t ProcessLineAsynch(const char *line, EErrorCode *error)

     Let CINT process a command line asynch.

Long_t ProcessLineSynch(const char *line, EErrorCode *error)

     Let CINT process a command line synchronously, i.e we are waiting
     it will be finished.

Long_t Calc(const char *line, EErrorCode *error)

     Directly execute an executable statement (e.g. "func()", "3+5", etc.
     however not declarations, like "Int_t x;").

void PrintIntro()

     Print CINT introduction and help message.

void RecursiveRemove(TObject *obj)

     Delete object from CINT symbol table so it can not be used anymore.
     CINT object are always on the heap.

void Reset()

     Reset the CINT state to the state saved by the last call to
     TCint::SaveContext().

void ResetAll()

     Reset the CINT state to its initial state.

void ResetGlobals()

     Reset the CINT global object state to the state saved by the last
     call to TCint::SaveGlobalsContext().

void RewindDictionary()

     Rewind CINT dictionary to the point where it was before executing
     the current macro. This function is typically called after SEGV or
     ctlr-C after doing a longjmp back to the prompt.

Int_t DeleteGlobal(void *obj)

     Delete obj from CINT symbol table so it cannot be accessed anymore.
     Returns 1 in case of success and 0 in case object was not in table.

void SaveContext()

     Save the current CINT state.

void SaveGlobalsContext()

     Save the current CINT state of global objects.

void UpdateListOfGlobals()

     Update the list of pointers to global variables. This function
     is called by TROOT::GetListOfGlobals().

void UpdateListOfGlobalFunctions()

     Update the list of pointers to global functions. This function
     is called by TROOT::GetListOfGlobalFunctions().

void UpdateListOfTypes()

     Update the list of pointers to Datatype (typedef) definitions. This
     function is called by TROOT::GetListOfTypes().

void SetClassInfo(TClass *cl, Bool_t reload)

     Set pointer to CINT's G__ClassInfo in TClass.

Bool_t CheckClassInfo(const char *name)

     Checks if a class with the specified name is defined in CINT.
     Returns kFALSE is class is not defined.

void CreateListOfBaseClasses(TClass *cl)

     Create list of pointers to base class(es) for TClass cl.

void CreateListOfDataMembers(TClass *cl)

     Create list of pointers to data members for TClass cl.

void CreateListOfMethods(TClass *cl)

     Create list of pointers to methods for TClass cl.

void CreateListOfMethodArgs(TFunction *m)

     Create list of pointers to method arguments for TMethod m.

TString GetMangledName(TClass *cl, const char *method, const char *params)

     Return the CINT mangled name for a method of a class with parameters
     params (params is a string of actual arguments, not formal ones). If the
     class is 0 the global function list will be searched.

TString GetMangledNameWithPrototype(TClass *cl, const char *method, const char *proto)

     Return the CINT mangled name for a method of a class with a certain
     prototype, i.e. "char*,int,float". If the class is 0 the global function
     list will be searched.

void* GetInterfaceMethod(TClass *cl, const char *method, const char *params)

     Return pointer to CINT interface function for a method of a class with
     parameters params (params is a string of actual arguments, not formal
     ones). If the class is 0 the global function list will be searched.

void* GetInterfaceMethodWithPrototype(TClass *cl, const char *method, const char *proto)

     Return pointer to CINT interface function for a method of a class with
     a certain prototype, i.e. "char*,int,float". If the class is 0 the global
     function list will be searched.

const char* GetInterpreterTypeName(const char *name, Bool_t full)

     The 'name' is known to the interpreter, this function returns
     the internal version of this name (usually just resolving typedefs)
     This is used in particular to synchronize between the name used
     by rootcint and by the run-time enviroment (TClass)
     Return 0 if the name is not known.

void Execute(const char *function, const char *params, int *error)

     Execute a global function with arguments params.

void Execute(TObject *obj, TClass *cl, const char *method, const char *params, int *error)

     Execute a method from class cl with arguments params.

void Execute(TObject *obj, TClass *cl, TMethod *method, TObjArray *params, int *error)

     Execute a method from class cl with the arguments in array params
     (params[0] ... params[n] = array of TObjString parameters).

Long_t ExecuteMacro(const char *filename, EErrorCode *error)

     Execute a CINT macro.

const char* TypeName(const char *typeDesc)

     Return the absolute type of typeDesc.
     E.g.: typeDesc = "class TNamed**", returns "TNamed".
     You need to use the result immediately before it is being overwritten.

Int_t LoadLibraryMap()

     Load map between class and library. Cint uses this information to
     automatically load the shared library for a class (autoload mechanism).
     See also the AutoLoadCallback() method below.

Int_t AutoLoad(const char *cls)

     Load library containing specified class. Returns 0 in case of error
     and 1 in case if success.

Int_t AutoLoadCallback(const char *cls, const char *lib)

     Load library containing specified class. Returns 0 in case of error
     and 1 in case if success.

void* FindSpecialObject(const char *item, G__ClassInfo *type, void **prevObj, void **assocPtr)

     Static function called by CINT when it finds an un-indentified object.
     This function tries to find the UO in the ROOT files, directories, etc.
     This functions has been registered by the TCint ctor.

void UpdateClassInfo(char *item, Long_t tagnum)

     Static function called by CINT when it changes the tagnum for
     a class (e.g. after re-executing the setup function). In such
     cases we have to update the tagnum in the G__ClassInfo used by
     the TClass for class "item".

void UpdateAllCanvases()

     Update all canvases at end the terminal input command.

const char* GetSharedLibs()

     Refresh the list of shared libraries and return it.

const char* GetClassSharedLibs(const char *cls)

     Get the list of shared libraries containing the code for class cls.
     The first library in the list is the one containing the class, the
     others are the libraries the first one depends on. Returns 0
     in case the library is not found.

const char* GetSharedLibDeps(const char *lib)

     Get the list a libraries on which the specified lib depends. The
     returned string contains as first element the lib itself.
     Returns 0 in case the lib does not exist or does not have
     any dependencies.

Bool_t IsErrorMessagesEnabled()

     If error messages are disabled, the interpreter should suppress its
     failures and warning messages from stdout.

Bool_t SetErrorMessages(Bool_t enable)

     If error messages are disabled, the interpreter should  suppress its
     failures and warning messages from stdout.

void AddIncludePath(const char *path)

     Add the given path to the list of directories in which the interpreter
     looks for include files. Only one path item can be specified at a
     time, i.e. "path1:path2" is not supported.

const char* GetIncludePath()

     Refresh the list of include paths known to the interpreter and return it
     with -I prepended.

### Inline Functions

                  TCint TCint(const char* name, const char* title)
                  Int_t GetExitCode() const
                  Int_t GetMore() const
                  char* GetPrompt()
                   void Execute(TObject* obj, TClass* cl, TMethod* method, TObjArray* params, int* error = 0)
                TClass* Class()
                TClass* IsA() const
                   void ShowMembers(TMemberInspector& insp, char* parent)
                   void Streamer(TBuffer& b)
                   void StreamerNVirtual(TBuffer& b)
                  TCint TCint(const TCint&)
                 TCint& operator=(const TCint&)

Author: Fons Rademakers 01/03/96
Last update: root/meta:$Name: $:$Id: TCint.cxx,v 1.104 2005/06/22 20:18:11 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *