TCint

class TCint : public TInterpreter

    private:

             TCint TCint()
      virtual void Execute(TMethod*, TObjArray*)

    protected:

      virtual void ExecThreadCB(TWin32SendClass* command)

    public:

                    TCint TCint(const char* name, const char* title)
                    TCint TCint(TCint&)
             virtual void ~TCint()
             virtual void AddIncludePath(const char* path)
           virtual Long_t Calc(const char* line)
           static TClass* Class()
             virtual void ClearFileBusy()
             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 EndOfLineAction()
             virtual void Execute(const char* function, const char* params)
             virtual void Execute(TObject* obj, TClass* cl, const char* method, const char* params)
             virtual void Execute(TObject* obj, TClass* cl, TMethod* method, TObjArray* params)
            virtual Int_t ExecuteMacro(const char* filename)
             static void* FindSpecialObject(char* name, G__ClassInfo* type, void** prevObj, void** assocPtr)
      virtual const char* GetIncludePath() const
            virtual void* GetInterfaceMethod(TClass* cl, char* method, char* params)
            virtual void* GetInterfaceMethodWithPrototype(TClass* cl, char* method, char* proto)
            virtual Int_t GetMore() const
            virtual char* GetPrompt()
      virtual const char* GetSharedLibs() const
            virtual Int_t InitializeDictionaries()
          virtual TClass* IsA() const
           virtual Bool_t IsLoaded(const char* filename) const
             virtual void LoadMacro(const char* filename)
             virtual void PrintIntro()
            virtual Int_t ProcessLine(const char* line)
                    Int_t ProcessLineAsynch(const char* line)
            virtual Int_t ProcessLineSynch(const char* line)
             virtual void Reset()
             virtual void ResetAll()
             virtual void ResetGlobals()
             virtual void RewindDictionary()
             virtual void SaveContext()
             virtual void SaveGlobalsContext()
             virtual void SetClassInfo(TClass* cl)
             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
                 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

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.             
                                                                      

 Initialize the CINT interpreter interface.

 Destroy the CINT interpreter interface.

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

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

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

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

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

 Load a macro file in CINT's memory.

 Let CINT process a command line.

 Let CINT process a command line asynch.

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

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

 Print CINT introduction and help message.

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

 Reset the CINT state to its initial state.

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

 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.

 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.

 Save the current CINT state.

 Save the current CINT state of global objects.

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

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

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

 Set pointer to CINT's G__ClassInfo in TClass.

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

 Create list of pointers to data members for TClass cl.

 Create list of pointers to methods for TClass cl.

 Create list of pointers to method arguments for TMethod m.

 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.

 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.

 Execute a global function with arguments params.

 Execute a method from class cl with arguments params.

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

 Execute a CINT macro.

 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.

 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.

 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".

 Update all canvases at end the terminal input command.

 Refresh the list of shared libraries and return it.

 Add the given path to the list of directory in which the interpreter
 look for include files.

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

Inline Functions

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