class TCint: public TInterpreter

 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().

 Delete existing temporary values

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

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

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

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

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

 Load a macro file in CINT's memory.

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

 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.

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

 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.

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

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

 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.

 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.

 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.

 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 file name of the current un-included interpreted file.
 See the documentation for GetCurrentMacroName().

 Return the file name of the currently interpreted file,
 included or not. Example to illustrate the difference between
 GetCurrentMacroName() and GetTopLevelMacroName():

#include <iostream>
void inclfunc() {
   std::cout << "In inclfile.h" << std::endl;
   std::cout << "  TCint::GetCurrentMacroName() returns  " <<
      TCint::GetCurrentMacroName() << std::endl;
   std::cout << "  TCint::GetTopLevelMacroName() returns " <<
      TCint::GetTopLevelMacroName() << std::endl;
}

#include <iostream>
#include "inclfile.h"
void mymacro() {
   std::cout << "In mymacro.C" << std::endl;
   std::cout << "  TCint::GetCurrentMacroName() returns  " <<
      TCint::GetCurrentMacroName() << std::endl;
   std::cout << "  TCint::GetTopLevelMacroName() returns " <<
      TCint::GetTopLevelMacroName() << std::endl;
   std::cout << "  Now calling inclfunc..." << std::endl;
   inclfunc();
}

 Running mymacro.C will print:

 root [0] .x mymacro.C
 In mymacro.C
   TCint::GetCurrentMacroName() returns  ./mymacro.C
   TCint::GetTopLevelMacroName() returns ./mymacro.C
   Now calling inclfunc...
 In inclfile.h
   TCint::GetCurrentMacroName() returns  inclfile.h
   TCint::GetTopLevelMacroName() returns ./mymacro.C

 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.

 Load map between class and library. If rootmapfile is specified a
 specific rootmap file can be added (typically used by ACLiC).
 In case of error -1 is returned, 0 otherwise.
 Cint uses this information to automatically load the shared library
 for a class (autoload mechanism).
 See also the AutoLoadCallback() method below.

 Unload library map entries coming from the specified library.
 Returns -1 in case no entries for the specified library were found,
 0 otherwise.

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

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

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

 This does the actual work of UpdateClassInfo.

 Update all canvases at end the terminal input command.

 Refresh the list of shared libraries and return it.

 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.

 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.

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

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

 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.

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