doc/ref.txt

Reference manual for cint/makecint.

       Masaharu Goto (cint@pcroot.cern.ch)
       Copyright (c) 1995~2004 Masaharu Goto

 This document explains cint/makecint features and functionalities 
in an alphabetical order. 

==========================================================================
==========================================================================
==========================================================================
$CINTSYSDIR

 $CINTSYSDIR is an environment variable that contains name of directory
where CINT is installed.
A user must set CINTSYSDIR environment variable before using CINT.
Cint and makecint refers to files under $CINTSYSDIR at run time.
If $CINTSYSDIR is not properly set, cint and makecint will fail obtaining
platform dependent information or standard header files.
Platform dependent information is stored in $CINTSYSDIR/MAKEINFO and
standard header files exist under $CINTSYSDIR/include directory.

 Following examples show how to setup CINTSYSDIR and PATH environment variables
in UNIX and Windows-NT/95.

Example: UNIX, using either sh,ksh,bash, add following description to .profile

CINTSYSDIR=[CINT_install_directory]
PATH=$PATH:$CINTSYSDIR
MANPATH=$MANPATH:$CINTSYSDIR/doc
export PATH CINTSYSDIR MANPATH


Example: UNIX, using csh, add following description to .login

setenv CINTSYSDIR [CINT_install_directory]
setenv PATH ($PATH $CINTSYSDIR)
setenv MANPATH ($MANPATH $CINTSYSDIR/doc)


Example: Windows-NT/95, add following description to AUTOEXEC.BAT

SET CINTSYSDIR=C:\CINT
SET PATH=%CINTSYSDIR%;%PATH%


==========================================================================
$CINTSYSDIR/G__ci.h

  G__ci.h is a header file for CINT API.
G__ci.h must be included when using CINT API in a precompiled library.
-I$CINTSYSDIR option must be given to makecint when including G__ci.h.


Example:

  $ makecint -mk Makefile -o src -H src.h -C++ src.cxx -I$CINTSYSDIR
  $ make -f Makefile


  // src.h /////////////////////////////////////////////////////////////
  #include "G__ci.h"  // G__ci.h must be included
  void f();


  // src.cxx /////////////////////////////////////////////////////////////
  #include "src.h"
  void f() {
    G__loadfile("mysrc.C"); // API function is used
  }


==========================================================================
$CINTSYSDIR/MAKEINFO

 $CINTSYSDIR/MAKEINFO is an ASCII file containing platform dependent 
information.
$CINTSYSDIR/MAKEINFO is created at installation by setup script.
It is important to have appropreate MAKEINFO file because cint and makecint
refers to this file at run time for following information.

 * Name of C/C++ preprocessor command is obtained from MAKEINFO if -p or +P,-P
   command line option is given to cint and makecint. Preprocessor command 
   is set to CPREP (in case of C) and CPPPREP (in case of C++).

 * MAKEINFO is copied as header part of Makefile when running makecint.
   Makecint will add application specific description after that.

 * CHDRPOST, CPPHDRPOST, CSRCPOST, CPPSRCPOST, DLLPOST variables in MAKEINFO
   are refered by makecint and cint with -c[-1|-2] option. These variables
   determines file extension of header, source and DLL files.


 You can also set default behavior of Cint command line input by setting
INPUTMODE and INPUTMODELOCK in $CINTSYSDIR/MAKEINFO. Refer to INPUTMODE for
the detail.


SEE ALSO: platform dependency file, INPUTMODE

==========================================================================
$CINTSYSDIR/src/Api.h

 $CINTSYSDIR/src/Api.h contains definision of CINT ERTTI(Extensive Run Time 
Type Identification).
Api.h must be included when ERTTI API is used in a precompiled library.
-I$CINTSYSDIR and -I$CINTSYSDIR/src must be given to makecint when doing this.


SEE ALSO: ERTTI 

==========================================================================
#!

 You can run C++ source file as a command in Linux/UNIX environment if you
have #! command at the beginning of your script. This technique is popular 
in Linux/UNIX script programming.  In case of Cint, you have to have space
character between the #! and interpreter name. 

Example:
	  $ cat HelloWorld.cxx
	  #! /usr/local/bin/cint
	  int main() {
	    printf("Hello World\n");
	    return 0;
	  }

	  $ chmod +x HelloWorld.cxx
	  $ HelloWorld.cxx


Limitation:
  As described alread, you have to have space character between the #! and
  interpreter name. 

  If you give -p(preprocessor) option, the preprocessor will complain about #!
  because C/C++ preprocessor doesn't know about #!.


==========================================================================
#pragma

 ANSI C/C++ standard defines #pragma as a mean to implement platform dependent
functionality.
CINT defines several #progma statement to implement special functionality.

 A user can define new #pragma statement by using G__addpragma() API.


SEE ALSO: G__addpragma()

==========================================================================
#pragma ANSI

  #pragma ANSI statement can be used in a parameter information file (= header 
file given to makecint by -h and -H option).
#pragma ANSI will force subsequent function prototypes to be registered as
ANSI C/C++ style function in a precompiled library.
Usually #pragma ANSI is not necessary because this is a default state.
#pragma ANSI is only necessary after #pragma K&R.


SEE ALSO: #pragma K&R

==========================================================================
#pragma autocompile [on|off]

 #pragma autocompile statement will turn on/off effect of #pragma compile 
statement. Default is on.
If '#pragma autocompile off' appears in a source file, #pragma compile and
#pragma endcompile statements are ignored.


SEE ALSO: #pragma compile


==========================================================================
#pragma bytecode

  Functions enclosed by '#pragma bytecode' and '#pragma endbytecode' will
be compiled to a bytecode at loading time.
These functions are accelerated especially when they are called multiple 
times in a loop.
  This feature is experimental and premature.
Bytecode function has to comply following limitations.
 + must be 80 lines or less
 + must not have class/struct object as local variable or parameter 
 + must not have reference type variable as local variable or paramter
 + may be a little slower if a bytecode function contains big loop.
These limitations will be cleared in future revision.


Example:

  #pragma bytecode
  // Compile a function to bytecode that is called multiple times in a loop
  int BytecodeFunc(char *s,double d) {
    int result;
    result = sprintf(s,"BytecodeFunc %g\n",d);
    return(result);
  }
  #pragma endbytecode
  
  // function containing big loop may be faster without #pragma bytecode
  int InterpretedFunc() {
    int result;
    for(int i=0;i<1000;i++) {
      result += i;
    }
    return(result);
  }
  
  main() {
    char buf[100];
    for(int i=0;i<100;i++) {
      BytecodeFunc(buf,i*1.2);
      printf("%s\n",buf);
    }
    printf("%d\n",InterpretedFunc());
  }


==========================================================================
#pragma Ccomment [on|off]

 #pragma Ccomment statement turns on/off C comment handling in ROOT
comment string handling. Difference of Ccomment on and off are subtle.
Ccomment on will remove ending '*/' from comment string.

  /* myheader.h */
  struct A {
   int a;  /* integer a */
  };                /*  ^^ this part is removed  */

Example:

  #pragma Ccomment on
  #include "myheader.h"  /* C header */
  #pragma Ccomment off

==========================================================================
#pragma compile

 Source code that is enclosed by '#pragma compile' and '#pragma endcompile'
will be compiled as native code and dynamically loaded.
A user can enjoy native code performance in an interpreted source file.
This feature is only available with DLL or shared library capability of
the operating system. makecint will be implicitly used behind.
Source code surrounded by '#pragma compile' and '#pragma endcompile' must
be a complete C or C++ source.
Multiple pairs of '#pragma compile' and '#pragma endcompile' can be used.
If '#pragma endcompile' is omitted, everything after '#pragma compile'
will be compiled.
CINT must be installed with C/C++ compiler to utilize #pragma compile
statement.

 In above process, following files are implicitly created by Cint. 

  G__AC[xxx].C        : Source code enclosed by #pragma compile/endcompile
  G__AC[xxx].dll      : Dynamic Link Lib for G__AC[xxx].C
  G__AC[xxx].mak      : Makefile for making G__AC[xxx].dll
  G__cpp_G__AC[xxx].C : Dictionary code for G__AC[xxx].C
  G__cpp_G__AC[xxx].h : Dictionary code for G__AC[xxx].C
  G__cpp_G__AC[xxx].o : Object file for G__AC[xxx].dll

Cint checks if contents of G__AC[xxx].C is changed or not. It re-compiles
G__AC[xxx].dll only when there is a change.
Those files are left undeleted even after Cint session is terminated. Please
delete those files manually.


Example: In example below, loop() function will be compiled to a native code.

  /*  auto.c */
  main(int argc,char **argv) {
    loop(atoi(argv[1]));
    endfunc();
  }
  
  # pragma compile  /* following part is compiled */
  int sum=0;
  loop(int num) {
    int i=0;
    for(i=num;num>0;num--) sum += num;
  }
  #pragma endcompile
  
  endfunc() {
    printf("end of execution sum=%d\n",sum);
  }


==========================================================================
#pragma do_not_include "filename" ;

  This statement avoids inclusion of specified file. This statement is useful
at making cint dictionary from a simple header file but it includes 
complicated system header file.  Specifying the system header file name with
this statement, you can avoid problems loading it.

Example:
    // myfile1.h
    #include <windows.h>
    #include <stdafx.h>
    void my_simple_func(BYTE x);

    // myLinkDef.h
    #ifdef __MAKECINT__
    #pragma do_not_include "windows.h" // avoid loadingg windows.h
    #pragma do_not_include "stdafx.h"  // avoid loadingg windows.h
    typedef BYTE short; // define dummy typedef for dictionary generation
    #endif

    $ makecint -mk Makefile -dl mylib.dll -H myfile1.h myLinkDef.h


==========================================================================
#pragma endbytecode

Refer to #pragma bytecode 


==========================================================================
#pragma endcompile

Refer to #pragma compile 


==========================================================================
#pragma eval [expression] ;

  [expression] is evaluated whenever this line is parsed.
Do not use this statement. This statement exists for debugging CINT only.


==========================================================================
#pragma extra_include "filename" ;

  This statement is added for ROOT framework.  Specified filename will be
included in rootcint generated dictionary code. 
Ask Philippe Canal<pcanal@fnal.fnal.gov> for the detail.


==========================================================================
#pragma if defined([macro])
#pragma ifdef [macro]
#pragma ifndef [macro]
#pragma elif defined([macro])
#pragma endif

  #pragma if, ifdef, ifndef, elif and endif statements behaves the same as
ordinary #if,#ifdef, #ifndef,#elif and #endif preprocessor statements.
If -p or +P,-P command line option is given to cint or makecint, source and
header files are processed by C/C++ preprocessor prior to the interpretation.
In such case, #pragma if,ifdef, ifndef, elif and endif statements are ignored
in the preprocessor and left for cint to handle.
 An ordinary user does not need to use these statements often.


==========================================================================
#pragma include "[DLL_or_Header]"

 #pragma include statement behaves the same as ordinary #include statement.
It is recommended to use #pragma include when loading DLL(Dynamic Link Library)
in source file.
If -p or +P,-P command line option is given to cint or makecint, source and
header files are processed by C/C++ preprocessor prior to the interpretation.
In such case, #pragma include statement is ignored in the preprocessor and
left for cint to handle.
So, use #pragma include whenever you do not want include file to be processed
by C/C++ preprocessor.


Example: Following example loads DLL fft.dl in source file.

  #include <stdio.h>
  #pragma include <fft.dl>
  
  main() {
    ...
  }

==========================================================================
#pragma include_noerr "[DLL_or_Header1]"  <#on_error "[DLL_or_Header2]">

 #pragma include_noerr statement behaves similary to '#pragma include' 
statement. Difference is that #pragma include_noerr does not trap an 
error when specified file is not found.
 If [DLL_or_Header1] is not found  and  optional argument 
'#on_error "[DLL_or_Header2]"' is given, [DLL_or_Header2] will be loaded. 
Error is trapped if this file is not found.

Example: Following example loads DLL fft.dl and array.dl in source file.

  #include <stdio.h>
  #pragma include_noerr <fft.dl>
  #pragma include_noerr <array.dl>  #on_error <array.c>
  
  main() {
    ...
  }

==========================================================================
#pragma includepath "[path]"

 #pragma includepath statement add header file include path.
It has the same effect as giving -I[includepath] command line option.
#pragma includepath statement accepts one path name at a time.
If you have multiple include pathes to add, you need multiple #pragma
include statements.


Example: Following example adds /home/proj/include and /usr/myinclude as 
include pathes.

  #pragma includepath "/home/proj/include"
  #pragma includepath "/usr/myinclude"
  #include <mylib.h>
  
  
==========================================================================
#pragma K&R

 #pragma K&R statement turns off parameter checking of precompiled functions.
Function parameter types are usually checked when calling precompiled 
functions.
Parameter type checking is turned off for functions declared after 
#pragma K&R statement in parameter information file (header file given to
makecint by -h or -H option).
There are such library that depends on the old K&R compiler does not check
parameters and calls function only by name matching.
#pragm K&R is introduced to support such library emulating K&R style 
programming.
The K&R mode is active until #pragma ANSI statement appears.
#pragma K&R and #pragma ANSI statement can only appear in parameter 
information files.

Example: Giving following prog.h to makecint with -c-2 option, f1() and f3() 
are handled as ANSI function. Parameter types will be checked at run time. 
For f2() which is surrounded by #pragma K&R and #pragma ANSI, parameter
type checking is omitted when it is used in an interpreted source code.


    $ makecint -mk Makefile -o obj -h prog.h -C prog.c
  
  /* prog.h */
  #ifdef __CINT__

  long f1(int a,double b);
  #pragma K&R
  unsigned short f2();
  #pragma ANSI
  int f3(short c,float d);
  
  #else
  
  long f1();
  unsigned short f2();
  int f3();
  
  #endif
  

==========================================================================
#pragma link [C|C++|off] all [class|function|global|typedef];
#pragma link [C|C++|off] [class|struct|union|enum|namespace|protected] [name];
#pragma link [C|C++|off] [global|typedef] [name];
#pragma link [C|C++|off] [nestedclass|nestedtypedef];
#pragma link [C++|C|off|MACRO] function [name]<(argtypes)>;
#pragma link [C++|C|off|MACRO] function [classname]::[name]<(argtypes)>;
#pragma link off all methods;
#pragma link [C|C++|off] defined_in [filename];
#pragma link [C|C++|off] defined_in [class|struct|namespace] [name];
#pragma link [C|C++|off] all_function   [classname];
#pragma link [C|C++|off] all_datamember [classname];

 #pragma link statement selectively turns on/off symbol table registeration
of classes, global functions, global variables and typedefs.
All of the classes, global functions, global variables and typedefs in the
global scope are registered to the symbol table by default.
A user can turn the registeration on/off by using '#pragma link' statement. 
 #pragma link statement can only appear in parameter information file which
is given to makecint with -h or -H option. (or given to cint with -c-1 or
-c-2 option) 
If used with -h option of makecint (or -c-2 option of cint), 
'#pragma link C' , '#pragma link off' and '#pragma link MACRO' can be used. 
If used with -H option of makecint (or -c-1 option of cint), 
'#pragma link C++' , '#pragma link off' and '#pragma link MACRO' can be used.

If you want to add nested classes or nested typedefs in the precompiled
symbol table, use '#pragma link [C|C++|off] [nestedclass|nestedtypedef];'.

You can optionally specify argument type for '#pragma link [C++|C|off] 
function' statement in order to select one from several overloaded functions.
If you omit argument type, all function with specified [name] will be 
affected.

'#pragma link [C++|C] function' and '#pragma link MACRO function' behaves
similarly. '#pragma link [C++|C] function' assumes target to be real
function which has pointer to it. Pointer to registered function is refered. 
On the other hand, '#pragma link MACRO function' assumes target to be macro 
function.  Pointer to function is not refered.

'#pragma link [C|C++|off] defined_in [class|struct|namespace] [name];'
controls all of the object defined in speciic scope. When using this pragma, 
it is recommended to use '#pragma link C++ nestedclass; tool. Otherwise, 
definitions in enclosed scope does not appear in the dictionary.


Example: In following example, symbol table registeration of classes, 
functions, global variables and typedefs are once turned off by 
'#pragma link off ...' statements. Then registeration of selected class, 
function, global variabl and typedef are turned on by '#pragma link C++ ...' 
statement.


    $ makecint -mk Makefile -o obj -H myprog.h -C++ myprog.C

  /* myprog.h */
  class A { };
  class B { class D; };
  class C { typedef int I; };
  double f1();
  A f2();
  B f3(int x,char* c);
  B f3(A& x);
  A i;
  double d;
  short s;
  typedef int Int_t;
  #ifndef __MAKECINT__
  #define pwr(x) (x*x)
  #else
  double pwr(double x);	
  #endif
  
  #pragma link off all class;
  #pragma link off all function;
  #pragma link off all global;
  #pragma link off all typedef;
  #pragma link C++ class B;
  #pragma link C++ function f2;
  #pragma link C++ function f3(int,char*);
  #pragma link C++ global s;
  #pragma link C++ Int_t;
  #pragma link C++ nestedtypedef;
  #pragma link C++ nestedclass;
  #pragma link MACRO function pwr;


==========================================================================
#pragma link [C|C++|off] all [class|function|global|typedef];

This pragma statement turns on/off dictinoary generation for all classes,
structs, namespaces, global variables, global functions and typedefs.

Example:

  // some C++ header definition

  #ifdef __MAKECINT__
  // turns off dictionary generation for all
  #pragma link off all class;
  #pragma link off all function;
  #pragma link off all global;
  #pragma link off all typedef;
  #endif


==========================================================================
#pragma link [C|C++|off] [class|class+protected|struct|union|enum|namespace] [name];

This pragma statement selectively turns on/off dictionary generation for
specified classs,struct,union,enum or namespace. Dictinoary of all 
public members of class and struct will be generated. 

If 'class+protected' flag is used, dictionary for protected members 
will also be generated. However, dictinoary for protected constructor 
and destructor will not be generated. This 'class+protected' flag will
help you only for plain protected member access, but not for virtual
function resolution.

If you use 'namespace' flag,  it is recommended to add 
'#pragma link nestedclass;' and '#pragma link nestedtypedef;' also.

Behavior of 'class', 'struct' and 'namespace' flag are identical. 

Example:
  // some C++ header definition

  #ifdef __MAKECINT__
  #pragma link off all class;
  #pragma link C++ class A;
  #pragma link C++ class B;
  #pragma link C++ class C<int>;
  #pragma link C++ class+protected D;
  #pragma link C++ namespace project1;
  #pragma link nestedclass;
  #pragma link nestedtypedef;
  #endif


==========================================================================
#pragma link [C|C++|off] [global|typedef] [name];

This pragma statement selectively turns on/off dictionary generation for
global variable and typedef.

Example: 
  // some C/C++ header definition

  #ifdef __MAKECINT__
  #pragma link off all global;
  #pragma link off all typedef;
  #pragma link C++ global a;
  #pragma link C++ typedef Int_t;
  #endif


==========================================================================
#pragma link [C|C++|off] [nestedclass|nestedtypedef];

This pragma statement turns on dictionary generation for nested class and
nested typedef. 

Example:
  // some C/C++ header definition

  #ifdef __MAKECINT__
  #pragma link C++ nestedclass;
  #pragma link C++ nestedtypedef;
  #endif


==========================================================================
#pragma link [C++|C|off|MACRO] function [fname]<(argtypes)>;
#pragma link [C++|C|off|MACRO] function [classname]::[fname]<(argtypes)>;

This pragma turns on/off dictionary generation for specified function or
member function. You can provide only function name or with complete 
argument types. If you omit argument type, all function with specified 
[name] will be affected. If complete argument types are specified, one
that has exactly same argument list will be affected.

'#pragma link [C++|C] function' and '#pragma link MACRO function' behaves 
similarly. '#pragma link [C++|C] function' assumes target to be real 
function which has pointer to it. Pointer to registered function is 
refered. On the other hand, '#pragma link MACRO function' assumes target 
to be macro function.  Pointer to function can not be referenced in this
case.


Example:

   void f(int a);
   void f(double a);
   int g(int a,double b);
   int g(double x);
   #define max(a,b) (a>b?a:b)

   class A {
    public:
     int h(double y);
     int h(int a,double b);
   };

   #ifdef __MAKECINT__
   #pragma link off all functions;
   #pragma link C++ function f;
   #pragma link C++ function g(int,double);
   #pragma link C++ MACRO max;
   #pragma link C++ class A;
   #pragma link off function A::h(double);
   #endif


NEW BEHAVIOR FOR MEMBER FUNCTION TEMPLATE (cint5.15.61):

 Until 5.15.60, in order to generate dictionary for a member function, not 
only for the member function but class itself has to be turned on for the 
linkage. There was a inconvenience when generating dictinoary for template
member function afterwards.
From cint5.15.61, a new behavior is introduced. If link for a member function 
is specified, dictionary is generated even if link to the belonging class is 
off.  For example, if you originally have A.h as follows, and generate 
dictionary for that.

   // A.h
   template<class T> class A {
    public:
     template<class E> void f(E& x) { ... }
   };
   #ifdef __MAKECINT__
   #pragma link C++ class A<int>;
   #endif

     $ makecint -mk makeA -dl A.dll -H A.h
     $ make -f makeA

Then prepare another header file and instantiate template member function
of A. You can generate dictionary for the newly instantiated template 
member function only.

   // B.h
   #include "A.h"
   class B { ... };
   #ifdef __MAKECINT__
   #pragma link off defined_in A.h;
   #pragma link C++ function A<int>::f(B&);
   #endif

     $ makecint -mk makeB -dl B.dll -H B.h
     $ make -f makeB


==========================================================================
#pragma link off all methods;

This pragma turns off dictionary generation of all the member functions in
all classes.

Example:

  #ifdef __MAKECINT__
  #pragma link off all methods;
  #endif


==========================================================================
#pragma link [C|C++|off] all_function   [classname];
#pragma link [C|C++|off] all_datamember [classname];

Those pragam statements control linking of all the member function or
data member for a specified class.

At this momement, there should be no needs to use those statements.

Example:

  #ifdef __MAKECINT__
  #pragma link off all_function   A;
  #pragma link off all_datamember A;
  #endif


SEE ALSO: #pragma link function

==========================================================================
#pragma link [C|C++|off] defined_in [filename];

This pragma statement turns on/off dictionary generation of the object
defined in specific file.

Example:
    // file1.h
    // any C++ header definition

    // file2.h
    #ifdef __MAKECINT__
    #pragma link off all classes;
    #pragma link off all functions;
    #pragma link off all globals;
    #pragma link off all typedef;
    #pragma link C++ defined_in file1.h;
    #endif


==========================================================================
#pragma link [C|C++|off] defined_in [scope_name];
#pragma link [C|C++|off] defined_in [class|struct|namespace] [scope_name];

This pragma statement turns on/off dictionary generation of the object 
defined in specfic scope. [scope_name] should be class name, struct name or
namespace name. When using this pragma, it is recommended to use 
'#pragma link C++ nestedclass' too. Otherwise, definitions in enclosed 
scope does not appear in the dictionary.

Example:  

    namespace ns {
      int a;
      double b;
    };

    #ifdef __MAKECINT__
    #pragma link C++ defined_in ns;
    #pragma link C++ nestedclass;
    #endif


==========================================================================
#pragma link default [on|off]

This statements controls default link mode for makecint(cint -c-1|-c-2) 
and rootcint.  By truning default 'on' , all language constructs in given
header files will be included in generated Cint dictionary(interface 
method source file).   If default is set to 'off', nothing will be included
in the generated dictionary. Linkage to each item must be explicitly
set by '#pragma link [C|C++|off] [class|function|global]' statement.
This pragma statement must be given before cint/rootcint reads any C/C++
definitions from header files.

For pure Cint, default is on. For ROOT, including $ROOTSYSDIR/bin/cint,
default is off.  

This feature was added from cint5.15.57. Before this version, you had to
explicitly use '#pragma link off [class|function|global];' statements in
ROOT's LinkDef.h file. From 5.15.57, you can omit them.  


Example:  

    #ifdef __MAKECINT__
    #pragma link default off;
    #endif

    class A {
      int a;
      double b;
    };

    class B {
      int d;
      double e;
    };

    #ifdef __MAKECINT__
    #pragma link C++ class A; // only class A is linked, not B
    #endif


==========================================================================
#pragma link postprocess [filename] [action];

'#pragma link [C++|C|off]' is good enough for most of the case to control
precompiled object linkage to the interpreter, however, there are cases 
that you need more specialized control of linkage. 
'#pragma link postprocess' statement allows you to control precompiled
object linkage in flexible way.  It allows you to describe linkage rules 
in C++ macro using CINT ERTTI API.

The most common usage would be to switch on/off operator functions for
mathematical container class. All kinds of operators can be defined in
template container class, however, only ones that defined in element
class can be instantiated. It is needed to conditionally turn on/off
linkage of operator functions regarding property of the element class.
This is already implemented in stl/G__postprocess.h. In most of the case
you can simply specify something like below at the end of LinkDef file.

  #pragma link postprocess G__postprocess.h postprocess("MyArray");


Example: In following example, you define template class A with operator+
and operator-. It is instantiated by elements like int, int*, B, B*, C, C*.
Validity of each operator function is evaluated in stl/G__postprocess.h
and linkage is controlled on and off. Refer to stl/G__postprocess.h for
more detail.

  // t335.h ////////////////////////////////////////////
  template<class T> 
  class A {
    T a;
  public:
    A(const T& ain) { a=ain; }
    //A& operator=(const T& ain) { a=ain; return(*this); }
    A operator+(const A& x) {
      A z(a+x.a);
      return(z);
    }
    friend A<T> operator-(const A<T>& x,const A<T>& y) ;
  };
  
  template<class T>
  A<T> operator-(const A<T>& x,const A<T>& y) {
    T dif = x.a-y.a;
    A<T> z(dif);
    return(z);
  }
  
  class B {
   public:
  };
  
  class C {
    int a;
   public:
      C(int ain=0) { a = ain; }
    C operator+(const C& x) {
      C z(a+x.a);
      return(z);
    }
    friend C operator-(const C& x,const C& y) ;
  };
  
  C operator-(const C& x,const C& y) {
    int dif=x.a-y.a;
    C z(dif);
    return(z);
  }
  
  #ifdef __MAKECINT__
  #pragma link C++ class A<int>;
  #pragma link C++ class A<int*>;
  #pragma link C++ class A<B>;
  #pragma link C++ class A<B*>;
  #pragma link C++ class A<C>;
  #pragma link C++ class A<C*>;
  
  #pragma link postprocess G__postprocess.h G__postprocess("A");
  #endif
  // end of t335.h /////////////////////////////////////


==========================================================================
#pragma mask_newdelete [value];

 '#pragma mask_newdelete' statement sets flags to mask operator new/delete
 genneration in a dictionary source code. 
  When making cint dictionary or interface method source code, it usually
 overloads global new and delete operators. If you have yourown new/delete
 operator, you may want to elimitate new and delete from the dictionary
 source code. Above message indicates, status of new/delete operator 
 masking.  Mask flag is shown as hex number. In rootcint, -M0x1c is set 
 by default.

    #define G__IS_OPERATOR_NEW      0x01
         Global operator new is found in user header file. Cint automatically
        stops generating operator new function in the dictionary.

    #define G__IS_OPERATOR_DELETE   0x02
         Global operator delete is found in user header file. Cint 
        automatically stops generating operator delete function in the 
        dictionary.

    #define G__MASK_OPERATOR_NEW    0x04
         Cint does not generate operator new function in the dictionary
        because it is explicitly masked by -M0x4 command line option.

    #define G__MASK_OPERATOR_DELETE 0x08
         Cint does not generate operator new function in the dictionary
        because it is explicitly masked by -M0x8 command line option.

    #define G__NOT_USING_2ARG_NEW   0x10
         Cint uses operator new function with 1 argument in dictionary
        source code.

 From cint5.14.60, a new scheme is introduced. In the new method, 
 following flags dominates others. This scheme is intended to fix 
 problems associated with global operator new/delete.

    #define G__DUMMYARG_NEWDELETE        0x100
	  If this flag is set, a new operator new/delete scheme
	 is turned on. With this scheme, cint dictionary generates
	 following functions.

            void* operator new(size_t size,[DLLID]_tag* p);
            void operator delete(void *p,[DLLID]_tag* x);
            static void G__operator_delete(void *p);

    #define G__DUMMYARG_NEWDELETE_STATIC 0x200
          This flag makes operator new a static function. So,
	 following functions will be generated.

            static void* operator new(size_t size,[DLLID]_tag* p);
            static void operator delete(void *p,[DLLID]_tag* x);
            static void G__operator_delete(void *p);


 The value given to '#pragma mask_newdelete' is ORed with the flag set
 by '-cint -M[value]' option of makecint. (Refer to makecint.txt)

 Default value is 0x100 for pure CINT and 0x1c for ROOTCINT.

Example:
    #pragma mask_newdelete 0x10; 

SEE ALSO: doc/makecint.txt -M option,  doc/message.txt


==========================================================================
#pragma message [Message]

 '#pragma message' statement displays message string to stderr.

==========================================================================
#pragma permanent_link [DllFilename]

 '#pragma permanent_link' links specified DLL or shared library as part of
cint system. Once the DLL is linked, it will not be unlinked until cint
process is terminated.  DLL file will be searched in normal include search
paths.  In case specified file is not found, this statement does not generate
error and continue processing the source file.

Example:
    #pragma permanent_link pthread.dll


SEE ALSO:  #pragma include_noerr

==========================================================================
#pragma preprocess [filename_prefix]


 Cint normally reads source file directly. This is called one-path 
processing. The one-path processing has some limitation in define macro.
To eliminate define macro limitations, a user sometimes needs to use 
official C/C++ preprocessor prior to interpretation. Invokation of the 
C/C++ preprocessor is done automatically by cint.
 #pragma preprocess specifies that include files start with
[filename_prefix] should be processed by C/C++ preprocessor before cint
reads them. 


Example: In following example, include files start with X11/X go through
preprocessor than read by cint. myheader.h is directly read by cint.

  #pragma preprocess X11/X
  #include "X11/Xlib.h"
  #include "X11/Xutil.h"
  #include "myheader.h"


SEE ALSO: -p option, +P,-P suboption, one-path processing,
          two-path processing, preprocessor statements

==========================================================================
#pragma preprocessor [on|off]

 Cint normally reads source file directly. This is called one-path 
processing. The one-path processing has some limitation in define macro.
To eliminate define macro limitations, a user sometimes needs to use 
official C/C++ preprocessor prior to interpretation. Invokation of the 
C/C++ preprocessor is done automatically by cint.
 Include files which are enclosed by '#pragma preprocessor on' and
'#pragma preprocessor off' are preprocessed by C/C++ preprocesso prior to
interpretation.

Example: In following example, only myheader2.h and myheader3.h are processed 
by C/C++ preprocessor.  myheader1.h and myheader4.h are directly read by cint.

  #include <stdio.h>
  #include "myheader1.h"
  #pragma preprocessor on
  #include "myheader2.h"
  #include "myheader3.h"
  #pragma preprocessor off
  #include "myheader4.h"


SEE ALSO: -p option, +P,-P suboption, one-path processing,
          two-path processing, preprocessor statements

==========================================================================
#pragma security [level0-5]

 #pragma security statement sets security and robustness mode of cint.
Security mode is normally set by -q[levelN] command line option.
-q option can set only one security level for all of the source files
given to cint.
 Using #pragma security statement in source file enables having different
security level in different source file. 
#pragma security statement can appear only once at the begenning of source
or header file.


Example: In following example, security level1 is set to prog1.c. Casting to a
pointer is prohibited. Security level0 is set to prog2.c to allow casting
to pointer from long integer. 


  $ cint -qlevel1 prog2.c prog1.c

  /* prog1.c */
  #pragma security level1
  void main() {
    void *p = f2(0x4152368);
  }
  
  /* prog2.c */
  #pragma security level0
  void* f2(long l) {
    return((void*)l);
  }


SEE ALSO: security mode

==========================================================================
#pragma setertti

 #pragma setertti will setup symbol table for Extensive Run Time Type
Identivication API. This is a special statement which only appears in 
$CINTSYSDIR/ertti.h header file. Ordinaly user should not use this statement.

==========================================================================
#pragma setstdio

 #pragma setstdio will setup starnderd I/O file pointers in the interpreter
environment. This is a special statement which only appears in 
$CINTSYSDIR/stdio.h header file. Ordinaly user should not use this statement.

==========================================================================
#pragma setstream

 #pragma setstream will setup symbol table for iostream library in the
interpreter environment. This is a special statement which only appears in
$CINTSYSDIR/iostream.h header file. Ordinaly user should not use this 
statement.

==========================================================================
#pragma stub [C|C++|off] all functions;
#pragma stub [C|C++|off] function [name];

 #pragma stub statement registers specified function as STUB function in 
a precompiled library. This statement can only be used in parameter
information file.
 It is usually unnecessary to use this statement because -i and -i++ 
command line option of makecint provide the same functionality.

==========================================================================
__CINT__

 __CINT__ is a macro which is internally defined within cint interpreter.
This macro can be used to distinguish cint from other C/C++ processing
system. __CINT__ can not be disabled by #undef statement.

Example:

  #ifdef __CINT__
  #pragma include "myprog.dll"
  #else
  #include "myprog.h"
  #endif


==========================================================================
__CINT_INTERNAL_CPP__

 __CINT_INTERNAL_CPP__ is a macro which is internally defined within cint 
interpreter. This macro can be used to distinguish between external C/C++
preprocessor and one embedded in Cint parser. Latter one has limitation in
macro handling. When -p or +P option is used, external C/C++ preprocessor
which is designated in $CINTSYSDIR/MAKEINFO is used. __CINT_INTERNAL_CPP__ 
is not defined. Without -p or +P option, __CINT_INTERNAL_CPP__ is defined.


Example:

  #ifdef __CINT_INTERNAL_CPP__
  /* dummy */
  #else
  #include "/usr/include/sys/cdefs.h"
  #endif


==========================================================================
__cplusplus

 __cplusplus is a macro which is internally defined within cint interpreter
when interpreting C++ source code. __cplusplus is defined if source file
has following extensions.

   .C  .cc  .CC .hh .HH .wc .WC .cxx .CXX .cpp .CPP .hxx .HXX .hpp .HPP

It is not defined if source file has following filename extension.

   .c

It is context dependent if source file has following filename extensions.

   .h  .H

If -A option is given, __cplusplus is always defined regardless of filename
extension.  If -K option is given, __cplusplus is never defined reglardless
of filename extension.

Note:

 It is quite popular to use __cplusplus macro like following example.
This kind of structure is problematic for Cint. A special workaround is
implemented from cint5.15.106.

	#ifdef __cplusplus
	extern "C" {
	#endif

	void c_function() ;

	#ifdef __cplusplus
	}
	#endif



==========================================================================
__MAKECINT__

 __MAKECINT__ macro is defined when processing parameter information files.
__MAKECINT__ macro is explicitly given to 'cint -c[-1|-2]' from command line.
This macro can be used to distinguish makecint from other C/C++ processing
system.

Example:

  #ifdef __MAKECINT__
  #pragma link C++ function myfunc;
  #endif

SEE ALSO: parameter information file

==========================================================================
==========================================================================
==========================================================================
ANSI style function header

 cint can read both ANSI and K&R style function header. 
Cint does run-time parameter type checking for ANSI style function.
K&R style function is called with simple function name match.
ANSI style function is called only if type of parameter matches to 
C++ function overloading rule.
If a function with no parameter is declared as f() it is regarded as
K&R style. ANSI style funciton must be explicitly declared as f(void).
Hence, f1() and f2() in following example behaves differently.


Example:

  int f1() {}     // interpreted as K&R style function
  int f2(void) {} // interpreted as ANSI style function

  main()
  {
    f1(1); // call f1() successfully
    f2(1); // No match to f2(int), ERROR
  }

==========================================================================
archived library

 Archived library is a kind of precompiled library which is archived with
cint core as monolithic executable file. 
Archived library contains following components.

   * user program
   * interface method to the user program
   * interface method start-up program $CINTSYSDIR/main/G__setup.c
   * interpreter core, $CINTSYSDIR/src/G__ci.a
   * main() function

 Interface method registers symbols in user program to cint symbol table.
It is automatically generated by makecint or 'cint -c[-1|-2]'.
 User program must not include main() function because cint main() function 
$CINTSYSDIR/main/G__cppmain.o is linked by default. 
You must give -m option to makecint if you want to use different main() 
function.
In this case, cint must be explicitly initialized by G__iniy_cint() API.


SEE ALSO: DLL, precompiled library, G__init_cint()

==========================================================================
==========================================================================
==========================================================================
cint

 When written in lower case letter "cint", points C/C++ interpreter object.
Executable object $CINTSYSDIR/cint is a default C/C++ interpreter which only
includes ANSI C standard library and C++ iostream library.
You can create derivertive of cint by using makecint.
These derivartives have different name, however, same user inferface as cint.


==========================================================================
CINT

 When written in all upper case letter "CINT", points entire cint/makecint
system.


==========================================================================
CINTSYSDIR

  REFER to $CINTSYSDIR 

==========================================================================
==========================================================================
==========================================================================
debugger interface

 cint is not only an interpreter but also a source code debugger.
cint's debugger interface provides full set of debugger capability,
like step execution, break point, stack trace, source code trace, class
and function browsing, etc...
Debugger interface is invoked at following occasion.

       * When main() function is not found in given source files
       * When cint is invoked with step mode command line option -S,-s
       * Break point event
       * Keyboard interrupt by CTL-C or Break key
       * When debugger interface function G__pause() is called explicitly
       * Bus error, segmentation violation 


SEE ALSO: G__pause() , G__atpause , debugger usage

==========================================================================
debugger prompt

 Debugger prompt is a command prompt displayed by debugger interface. 
It usually looks as follows,

  FILE:xyz.C LINE:16 cint>


SEE ALSO: debugger interface, G__pause(), G__atpause, debugger usage

==========================================================================
DLL(Dynamic Link Library)

 DLL(Dynamic Link Library) is a kind of precompiled library which can be
dynamically linked/unlinked with cint at run time.
DLL can be linked in the same way as you load source file.
DLL module has to have file extension  .dl .dll .DLL .sl or .so because cint
distinguishes between source file and DLL by file extension.
DLL module contains following components.

   * user program
   * interface method to the user program

 Interface method registers symbols in user program to cint symbol table.
It is automatically generated by makecint or 'cint -c[-1|-2]'.



 In UNIX environment, DLL is implemented by shared library management routine.
If operating system does not have shared library facility, DLL feature of
CINT can not be used. Precompiled library can be embedded only as archived
library in that case.
 In Windows-95/NT, CINT utilizes Windows API to link DLL.

 CCDLLOPT, LDDLLOPT, LDOPT, SYSMACRO and DLLPOST variables in 
$CINTSYSDIR/MAKEINFO must be setup properly to use DLL.
There are currently following combination of SYSMACRO setting.

    SYSMACRO = -DG__SHAREDLIB -DG__OSFDLL
             Use OSF compliant dlopen(), dlsym(), dlclose() or emulated
             version.

    SYSMACRO = -DG__SHAREDLIB -DG__HPUXCPPDLL
             Use HP-UX cxxshl_load(),shl_findsym(),cxxshl_unload() 

    SYSMACRO = -DG__SHAREDLIB
             Use HP-UX shl_load(),shl_findsym(),shl_unload() 

    SYSMACRO = -DG__SHAREDLIB -D_WINDOWS
             Use Win32 API LoadLibrary(),GetProcAddress(),FreeLibrary()


SEE ALSO: interface method, precompiled library 

==========================================================================
==========================================================================
==========================================================================
Environment dependent macros

 Following macros are defined depending on the OS/CPU/Compiler/Framework
that Cint runs.  A user can test those macros by #ifdef statement in an
interpreted source code.

# Operating System dependent macros

   OS               macro             value
   -------------------------------------------------------------------------
   Linux            G__LINUX          same as __linux__        
   FreeBSD          G__FBSD           same as __FreeBSD__      
   HP-UX            G__HPUX           same as __hpux           
   Sun/Solaris      G__SUN            same as __sun            
   Windows          G__WIN32          same as _WIN32           
   Apple            G__APPLE          same as __APPLE__
   DEC/Compac VMS   G__VMS            same as __VMS            
   IBM AIX          G__AIX            same as _AIX             
   SGI IRIX         G__SGI            same as __sgi            
   Cygwin           G__CYGWIN         51                       


# CPU architecture dependent macros

   CPU              macro             value
   -------------------------------------------------------------------------
   HP-PA            G__hppa           same as __hppa__         
   Intel x86        G__i386           same as __i386__         
   Intel 860        G__i860           same as __i860__         
   Intel 960        G__i960           same as __i960__         
   Intel IA64       G__ia64           same as __ia64__         
   Motorola 68k     G__m68k           same as __m68k__         
   Motorola 88k     G__m88k           same as __m88k__         
   Motorola PPC     G__ppc            same as __ppc__          
   IBM      PPC     G__PPC            same as __PPC__          
   IBM S390         G__s390           same as __s390__         
   MIPS             G__mips           same as __mips__         
   DEC/Compac Alpha G__alpha          same as __alpha__        
   Sun Sparc        G__sparc          same as __sparc__        
   ARC              G__arc            same as __arc__          
   M32R             G__m32r           same as __M32r__         
   Hitachi SH       G__sh             same as __SH__           
   ARM              G__arm            same as __arm__          
   

# Compiler dependent macros

   Compiler         macro             value
   -------------------------------------------------------------------------
   gcc/g++          G__GNUC           same as __GNUC__         
   gcc/g++          G__GNUC_MINOR     same as __GNUC_MINOR__   
   HP aCC           G__HP_aCC         same as __HP_aCC__       
   Sun CC           G__SUNPRO_CC      same as __SUNPRO_CC      
   Sun C            G__SUNPRO_C       same as __SUNPRO_C       
   MS VC++          G__VISUAL         1
   MS VC++          G__MSC_VER        same as _MSC_VER         
                         1100:VC++5.0,1200:VC++6.0,1300:VC++7.0,1310:VC++7.1
   Symantec C++     G__SYMANTEC       same as __SC__           
   Borland C++      G__BORLAND        same as __BORLANDC__     
   Borland C++      G__BCPLUSPLUS     same as __BCPLUSPLUS__   
   Borland C++ 5.5  G__BORLANDCC5     505
   KCC              G__KCC            same as __KCC            
   Intel C++        G__INTEL_COMPILER same as __INTEL_COMPILER 


# Library dependent macros

   Library          macro             value
   -------------------------------------------------------------------------
   GNU LIBC         G__GLIBC          same as __GLIBC__        
   GNU LIBC         G__GLIBC_MINOR    same as __GLIBC_MINOR__  


# Framework dependent macros

   Framework        macro             value
   -------------------------------------------------------------------
   ROOT             G__ROOT           1


==========================================================================
ERTTI(Extensive Run Time Type Identification)

  CINT's ERTTI (Extensive Run Time Type Identification) is a special 
enhancement requested by Rene Brun and Fons Rademakers in CERN(European 
Laboratory for Particle Physics).
ERTTI API consists of 8 classes, which is an interface to C/C++ interpreter
symbol table.
ERTTI API classes can be used both in interpreter environment and precompiled
library.
<ertti.h> must be included to use ERTTI in interpreter environment.
-I$CINTSYSDIR/src and -I$CINTSYSDIR option must be given from command line
and <Api.h> must be included to use ERTTI in precompiled library.

  See alos to explanation about following ERTTI API classes.

      G__ClassInfo
      G__BaseClassInfo
      G__DataMemberInfo
      G__MethodInfo
      G__MethodArgInfo
      G__TypeInfo
      G__TypedefInfo
      G__CallFunc
      G__SourceFileInfo
      G__IncludePathInfo

Every ERTTI class has member function 'long Property()'. This function returns
property of concerned symbol as combination of following bit patter.

  #define G__BIT_ISTAGNUM          0x0000000f
  #define G__BIT_ISCLASS           0x00000001
  #define G__BIT_ISSTRUCT          0x00000002
  #define G__BIT_ISUNION           0x00000004
  #define G__BIT_ISENUM            0x00000008
  #define G__BIT_ISTYPEDEF         0x00000010
  #define G__BIT_ISFUNDAMENTAL     0x00000020
  #define G__BIT_ISABSTRACT        0x00000040
  #define G__BIT_ISVIRTUAL         0x00000080
  #define G__BIT_ISPUREVIRTUAL     0x00000100
  #define G__BIT_ISPUBLIC          0x00000200
  #define G__BIT_ISPROTECTED       0x00000400
  #define G__BIT_ISPRIVATE         0x00000800
  #define G__BIT_ISPOINTER         0x00001000
  #define G__BIT_ISARRAY           0x00002000
  #define G__BIT_ISSTATIC          0x00004000
  #define G__BIT_ISDEFAULT         0x00008000
  #define G__BIT_ISREFERENCE       0x00010000
  #define G__BIT_ISDIRECTINHERIT   0x00020000
  #define G__BIT_ISCCOMPILED       0x00040000
  #define G__BIT_ISCPPCOMPILED     0x00080000
  #define G__BIT_ISCOMPILED        0x000c0000
  #define G__BIT_ISCONSTANT        0x00100000
  #define G__BIT_ISVIRTUALBASE     0x00200000
  #define G__BIT_ISPCONSTANT       0x00400000
  #define G__BIT_ISGLOBALVAR       0x00800000
  #define G__BIT_ISLOCALVAR        0x01000000
  #define G__BIT_ISBYTECODE        0x02000000
  #define G__BIT_ISEXPLICIT        0x04000000


==========================================================================
ertti.h

 ertti.h is a header file which must be included to use ERTTI API in 
interpreter environment.


SEE ALSO: ERTTI 

==========================================================================
Exception handling

 Cint supports exception handling. A user can include standard <exception> 
header and make use of std::exception and std::bad_exception classes. When
using exceptions, it is highly recommended that your exception class is
derived from std::exception. This way you can catch an exception thrown
by a compiled code in an interpreted code.

 Following limitations apply to Cint exception handling.

 - If try, catch blocks are used in interpreted code, that portion can not
  be bytecode optimized. 

 - Throw only classes, not fundamental types. Cint is unable to catch 
  fundamental type exceptions, such as integer and pointer. 

 - Derive your class from std::exception and precompile it using makecint.
  Cint can, somehow, interpret your exception class. But it is safer to
  compile it.

 - With Windows Visual C++ 6.0, Cint has limitation resolving thrown
  exception type. 

 There are 2 examples in demo directory.

SEE ALSO: demo/exception/README.txt, demo/makecint/exception/README.txt


==========================================================================
extern "[dllname]" { ... }

 You can load global function from DLL without makecint/rootcint if you use
Intel 32bit CPU with gcc3.2, VC++ or BC++.  You need to load DLL and specify
function interface by extern "[dllname]" clause. You can access C global
functions. For gcc3.2 and VC++, you can also access C++ global functions. 
However, C++ function may sometimes fail because of incomplete emulation of 
gcc/VC++ name mangling.

Limitation: 
 This feature is convenient, however, capability is very limited. 
Makecint/rootcint still have significant advantage.

 Only fundamental types can be used as return and argument type. class
and struct objects can not be used.  

 Cint compiled with gcc can load DLL compiled by gcc and VC++. BC++ DLL is 
not tested, but it probably works. 
 Cint compiled with VC++ can load DLL compiled by gcc, VC++ and BC++. When 
loading gcc DLL, you need to add a directory containing Cygwin.dll to %path% 
environment variable. 
 Cint compiled with BC++ can load DLL compiled by BC++. There may be a way
to load gcc and VC++ DLLs, but no investigation is done yet.


Example: 

  ### Compiled source and header file ###################################

  // userdll.h
  #ifdef _WIN32
  #define EXPORT __declspec(dllexport)
  #else
  #define EXPORT
  #endif
  extern "C" {
    EXPORT void f1();
    EXPORT int f2(int a,double b,void* p);
  }
  EXPORT void f3(int *a,const int* b);

  // userdll.cxx
  #include "userdll.h"
  extern "C" {
    void f() { /* whatever */ }
    int f2(int a,double b,void* p) { /* whatever */ return 0; }
  }
  void f3(int* a,const int* b) { *a = *b+1; } // C++ function

  ### Create DLL ########################################################
  $    g++ -shared -o userdll.dll  userdll.cxx       # in case of g++
  c:\> cl /LD /ouserdll.dll userdll.cxx              # in case of VC++
  c:\> bcc32 -WD -P -euserdll.dll userdll.cxx        # in case of BC++

  
  ### Interpreted source ################################################
  // script.cxx
  extern "userdll.dll" {
    void f1();
    int f2(int a,double b,void* p);
  #if defined(G__VISUAL) || defined(G__GNUC)
    void f3(int *a,const int* b); 
  #endif
  }

  int main() {
    f1();
    int x = f2(123,3.14,NULL);
    int y;
  #if defined(G__VISUAL) || defined(G__GNUC)
    f3(&y,&x); // C++ function may fail
  #endif
    return 0;
  }

  ### Running Cint ######################################################
  c:\>  cint script.cxx


==========================================================================
==========================================================================
==========================================================================
file extention 

 cint recognizes following file extensions. cint does not check file 
extension strictly except for DLL.

    * C/C++ header file
          .h .H

    * C++ header file
          .hxx .HXX .hpp .HPP

    * C source file
          .c

    * C++ soruce file
          .C .cc .CC .cxx .CXX .cpp .CPP

    * DLL (Dynamic Link Library)
          .dl .dll .DLL .sl .so


==========================================================================
==========================================================================
==========================================================================
G__[????]

 CINT reserves symbol name starts with 'G__'.  Symbol name start with G__
must not be used. It may cause name conflict.


==========================================================================
G__add_ipath()

void G__add_ipath(const char* ipath)

G__add_ipath() API adds include path. It as same effect as -I command line
option. 

Example:
   G__add_ipath("/usr/local/mylib");
   G__add_ipath("/home/x/y");


SEE ALSO: G__delete_ipath()

==========================================================================
G__addpragma()

void G__addpragma(char *comname,void (*p2f)(char*));

 G__addpragma() API adds user defined #praga statement to cint parser.
It takes command keyword followed by #pragma and pointer to callback
function. The callback function must take string argument (char*).
String given to matching #pragma statement is given to the callback function
as argument.
G__addpragma() API can be used only in compiled program. 
WildC++ interpreter , merger of CINT and Tcl/Tk, is implemented using
this API.
(Refer to $CINTSYSDIR/lib/WildCard or $CINTSYSDIR/lib/wintcldl directory)


Example: Embedding MyCmd.c as precompiled library will add '#pragma MyCommand'
statement in the cint parser.
-B command line option of makecint registers user specific initialization
routine. 
When interpreting Example.C using MyCmd C/C++ interpreter, MyCallBack() 
function should parse lines between '#pragma MyCommad' and 
'#pragma endMyCommand'.


   $ makecint -mk Makefile -o MyCmd -h MyCmd.h -C MyCmd.c -B MyCommandInit 
   $ make
   $ MyCmd Example.C


  /* MyCmd.c */
  #include <stdio.h>
  void MyCallBack(char *args) {
    printf("MyCommand callback with argument %s\n",args);
    /* source file must be parsed here */
  }
  void MyCommandInit() {
    G__addpragma("MyCommand",MyCallBack);
  }


  /* MyCmd.h */
  void MyCallBack(char *args);
  void MyCommandInit();


  // Example.C
  main() {
    // C/C++ statements here
    // This part is given as callback function argument
    //                    |
    //                -----------
    #pragma MyCommand abc def efg
      This part is parsed by MyCallBack function.
      #pragma endMyCommand must be detected by the callback function.
    #pragma endMyCommand
    // Back to C/C++ statement
  }

==========================================================================
G__AllocConsole

int G__AllocConsole(void);

 This API generates new console window for Windows based application.  Pure
Windows program does not have any console window. In order to use Cint's
debugger capability, you need to create a new console window.

 Behavior of G__AllocConsole may depend on an internal flag inside Cint.
In order for G__AllocConsole to surely generate a new console window, call
G__setautoconsole() or G__FreeConsole() API before the G__AllocConsole. 

Windows only

Example:
  void f() {
    G__setautoconsole(0);
    G__AllocConsole();
  }


SEE ALSO: G__FreeConsole, G__setautoconsole

==========================================================================
G__ateval()

int G__ateval([anytype] obj);

 If you define G__ateval() function with an appropreate argument type, 
that function is evaluated when you evaluate value of object from interactive
interface. For example, if you have following source file.

   // ateval.cxx
   #include <string>
   int G__ateval(string& x) {
     cout << x << endl;
     return(0);
   }
   int G__ateval(int x) {
     cout << x << endl;
     return(1);
   }

and you load it as

   $  cint ateval.cxx
   cint> .
   cint> string a="abcdefg"
   cint> int x=12345
   cint> a
   abcde                              ## output of G__ateval(string&)
   (string)137023776                  ## output of cint interactive interface
   cint> x
   12345                              ## output of G__ateval(int)
   cint>

If you return 0 from G__ateval(), default output from cint interactive
interface will be displayed. If 1, it will not.


==========================================================================
G__atpause

void (*G__atpause)();

 G__atpause is a global variable that stores pointer to function which is
called when debugger interface is invoked.
G__atpause can be used only in precompiled library. Default value is NULL.
If non-zero value is set to G__atpause, cint takes it as a pointer to function
which should be called before displaying debugger prompt.
$CINTSYSDIR/G__ci.h must be included to use G__atpause feature.

Example: In following example, file buffer is flushed at before displaying
debugger prompt.


  $ makecint -mk Makefile -I$CINTSYSDIR -o mycint -m -C thisfile.c
  $ make
  $ mycint

/* thisfile.c */
#include "G__ci.h"   /* G__atpause is defined in G__ci.h */

FILE *fp;

void flushfiles() {
      fflush(fp);
}

main() {
      G__init_cint("cint");    /* initialize cint */
      G__atpause = flushfiles; /* assign to G__atpause */
      fp=fopen("something","w");
      fprintf(fp,"print something\n");
      G__pause(); /* flushfile is called */
      fclose(fp);
}


SEE ALSO: G__set_atpause(), debugger interface, G__pause(), debugger usage

==========================================================================
G__BaseClassInfo

 G__BaseClassInfo is an ERTTI API class which provides inheritance information
of class and struct.
<ertti.h> must be included to use ERTTI in an interpreter environment.
-I$CINTSYSDIR and -I$CINTSYSDIR/src command line option must be given to
cint and <Api.h> must be included to use ERTTI in precompiled library.

Interface of G__BaseClassInfo class is shown below. 
Constructor takes G__ClassInfo object as an argument.
Base class tree is iterated by G__BaseClassInfo::Next() member function.

  class G__BaseClassInfo : public G__ClassInfo {
   public:
    // initialization and reset
    G__BaseClassInfo(G__ClassInfo &a);
    void Init(G__ClassInfo &a);
  
    // get base-class information
    long Offset() ;
    long Property();
    int IsValid();
  
    // iteration
    int Next();
  
    // other specification
       .
  };


Example: Following example displays all of the base classes inherited by
ifstream class.


   $ cint  DispInherit.C
   ifstream inheritance information
    public: offset=0    fstreambase
      virtual  public: offset=0    ios
    virtual  public: offset=0    ios
    public: offset=4    istream
      virtual  public: offset=4    ios
    virtual  public: offset=0    ios
   $


   // DispInherit.C
   #include <iostream.h>
   #ifdef __CINT__
   #include <ertti.h>
   #else
   #include <Api.h>
   #endif
   display_inheritance(char *classname,long offset,int level) {
     G__ClassInfo cls(classname);
     G__BaseClassInfo base(cls);
     long property;
     while(base.Next()) {
       property=base.Property();
       for(int i=0;i<level;i++) putchar(' ');
       if(property&G__BIT_ISDIRECTINHERIT) printf("Direct  ");
       else                                printf("        ");
       if(property&G__BIT_ISVIRTUAL)   printf(" virtual ");
       if(property&G__BIT_ISPUBLIC)    printf(" public: ");
       if(property&G__BIT_ISPROTECTED) printf(" protected: ");
       if(property&G__BIT_ISPRIVATE)   printf(" private: ");
       printf("offset=%-3d  %s\n",base.Offset()+offset,base.Name());
       display_inheritance(base.Name(),base.Offset(),level+2);
     }
   }

   main() {
     char *classname="ifstream";
     printf("%s inheritance information\n",classname);
     display_inheritance(classname,0,0);
   }


SEE ALSO: ERTTI, G__ClassInfo,G__BaseClassInfo,G__MethodInfo,
          G__MethodArgInfo ,G__DataMemberInfo,G__TypeInfo,G__TypedefInfo,
          G__CallFunc

==========================================================================
G__calc()

[anytype] G__calc(const char* expression)   // interpreter environment
G__value G__calc(const char* expression)    // precompiled library environment

 G__calc() API evaluates C/C++ expression and returns its' value. 
In interpreter enviroment, type of the return value is automatically 
converted to suitable type without explicit type casting.
In precompiled library environment, it returns G__value object which
can be converted to long or double type object by G__double() or G__int()
API.
If G__calc() API is used in precompiled library, you should include
$CINTSYSDIR/G__ci.h.

 G__calc() can not evaluate declaration and conditional statement. If you
want to evaluate declarations and conditional statements, use G__exec_text()
instead.


Example: G__calc() used in interpreter environment

// interpreted source code
#include <stdio.h>
double f(float f) {
  printf("f=%g\n",f);
  return((double)f);
}

int main() {
   double d;
   d=G__calc("f(3.141592*1.5)");
   char home[100];
   strcpy(home,G__calc("getenv(\"HOME\")"));
   printf("home=%s\n",home);
   return 0;
}


Example: G__calc() used in precompiled library

// must be compiled with -I$CINTSYSDIR 
#include <stdio.h>
#include "G__ci.h"
double f(float f) {
  printf("f=%g\n",f);
  return((double)f);
}

void f2(float& a1) { // how to pass reference type
  printf("a1=%g\n",a1);
}

g() {
   double d;
   d=G__double(G__calc("f(3.141592*1.5)"));

   float x;
   char tmp[100];
   sprintf(tmp,"f2(*(float*)(%ld))",&x); // passing reference
   G__calc(tmp);

   char home[100];
   strcpy(home,(char*)G__int(G__calc("getenv(\"HOME\")")));
   printf("home=%s\n",home);
}



SEE ALSO: G__value , G__exec_text(), G__load_text()

==========================================================================
G__CallFunc

 G__CallFunc is an ERTTI API class which provides mean of calling
function which is registered to interpreter symbol table.
Same thing can be done by G__calc() API, however, G__CallFunc works
more efficiently when used repeatedly in a loop.
<ertti.h> must be included to use ERTTI in an interpreter environment.
-I$CINTSYSDIR and -I$CINTSYSDIR/src command line option must be given to
cint and <Api.h> must be included to use ERTTI in precompiled library.

Interface of G__CallFunc class is shown below. 
Unlike the other ERTTI classes, G__CallFunc can only be used in precompiled
library environment.

class G__CallFunc {
 public:
  // initialization and reset
  G__CallFunc() ;
  void Init() ;

  // set function and argument by string 
  void SetFunc(G__ClassInfo* cls,char* fname,char* args,long* poffset);
  void SetArgs(char* args);

  // set function and argument by pointer and value
  void SetFunc(G__InterfaceMethod f);
  void SetArg(long l) ;
  void SetArg(double d) ;

  // get pointer to interface method
  G__InterfaceMethod InterfaceMethod();

  // execute function
  void Exec(void *pobject) ;
  long ExecInt(void *pobject) ;
  double ExecDouble(void *pobject) ;

  // other specification
     .
};


Example1:
  Following example calls 'operator<<(double a) by using G__CallFunc class.


   $ makecint -mk Mkf -o cf -H cf.h -C++ cf.C -I$CINTSYSDIR -I$CINTSYSDIR/src
   $ make -f Mkf
   $ cf main.C
   3.14
   $


   // main.C
   #include <iostream.h>
   main() {
     callfuncexample();
   }

   // cf.h
   #include <iostream.h>
   #ifdef __CINT__
   #include <ertti.h>
   #else
   #include <Api.h>
   #endif
   void callfuncexample() ;

   // cf.C
   #include "cf.h"
   void callfuncexample() {
     G__ClassInfo cls("ostream");
     long offset;
     G__CallFunc func;
     func.SetFunc(&cls,"operator<<","3.14",&offset);
     *(ostream*)func.ExecInt((void*)(&cout)+offset) << endl;
   }


Example2:
  Find member function by name and parameter list in string.


   TCanvas c[10];
   void *address;
   long offset;
   G__CallFunc func;
   G__ClassInfo canvas("TCanvas");
   // set pointer to interface method and argument
   func.SetFunc(&canvas,"Draw","\"ABC\",1234,3.14",&offset);
   // call function
   for(int i=0;i<10;i++) {
     address = (void*)(&c[i]) + offset;
     func.Exec(address);
   }
   // reset everything
   func.Init();


Example3:
  Find member function by name and argument type in string, put actual 
  parameter by G__CallFunc::SetArg.

   TCanvas c[10];
   void *address;
   long offset;
   G__CallFunc func;
   G__ClassInfo canvas("TCanvas");
   // set pointer to interface method
   func.SetFunc(canvas.GetMethod("Draw","char*,int,double",&offset).InterfaceMethod());
   // set arguments
   char *title="ABC";
   func.SetArg((long)title);
   func.SetArg((long)1234);
   func.SetArg((double)3.14);
   // call function
   for(int i=0;i<10;i++) {
     address = (void*)(&c[i]) + offset;
     func.Exec(address);
   }

   // change arguments on same member function
   func.ResetArg();
   title="DEF";
   func.SetArg((long)title);
   func.SetArg((long)5678);
   func.SetArg((double)6.28);
   // call function
   for(int i=0;i<10;i++) {
     address = (void*)(&c[i]) + offset;
     func.Exec(address);
   }

   // reset everything
   func.Init();
 

Example4:
   #include <stdio.h>
   #include <ertti.h>

   class B {
     int sz;
     double *d;
    public:
     //B(int s) : sz(s+1) { printf("B(%d)\n",s); d = new double[sz]; }
     B(int s) { sz=s; printf("B(%d)\n",s); d = new double[sz]; }
     ~B() { printf("~B()\n"); delete[] d; }
     void Set(double offset, double step) {
       printf("Set(%g,%g)\n",offset,step);
       for(int i=0;i<sz;i++) d[i] = offset + step*i;
     }
     void disp() const {
       printf("disp() ");
       for(int i=0;i<sz;i++) printf("%g ",d[i]);
       printf("\n");
     }
     double Get(int s) const { return(d[s]); }
     void Set(int s,double v) { d[s]=v; }
   };
   
   void test3(const char* name) {
     printf("test3(%s)\n",name);
     long offset;
     G__ClassInfo cl(name+1);
     G__CallFunc ctor;
     G__CallFunc set;
     G__CallFunc disp;
     G__CallFunc dtor;
     ctor.SetFuncProto(&cl,name+1,"int",&offset);
     set.SetFuncProto(&cl,"Set","double,double",&offset);
     disp.SetFuncProto(&cl,"disp","",&offset);
     dtor.SetFuncProto(&cl,name,"",&offset);
   
     printf("%s %d\n",cl.Name(),cl.IsValid());
     printf("ctor %d\n",ctor.IsValid());
     printf("set %d\n",set.IsValid());
     printf("disp %d\n",disp.IsValid());
     printf("dtor %d\n",dtor.IsValid());
   
     for(int i=0;i<3;i++) {
       ctor.SetArg((long)(i+5));
       set.SetArg((double)i);
       set.SetArg((double)i/10);
       offset = ctor.ExecInt((void*)0);
       set.Exec((void*)offset);
       disp.Exec((void*)offset);
       dtor.Exec((void*)offset);
       ctor.ResetArg();
       set.ResetArg();
     }
   }
   
   int main() {
     test3("~B");
     return 0;
   }




SEE ALSO: ERTTI, G__ClassInfo,G__BaseClassInfo,G__MethodInfo
         ,G__MethodArgInfo,G__DataMemberInfo,G__TypeInfo
         ,G__TypedefInfo,G__CallFunc


==========================================================================
G__charformatter

char* G__charformatter(int ifmt,char* buf);


G__charformatter is a special API for handling printf like string formatting.
It implicitly takes variable arguments from interpreted function. First
argument takes position of formatting string in the interpreted function.
ifmt=0 if formatting string is given as the 1st argument of the interpreted 
function, ifmt=1 if 2nd.  Memory buffer must be given as 2nd argument of
G__charformatter.  This API is for expert use only.


Example: 
   int my_printf(char *format ...) {
     char temp[1024];
     return(printf("%s",G__charformatter(0,temp)));
   }
   int my_fprintf(FILE *fp,char *format ...) {
     char temp[1024];
     return(fprintf(fp,"%s",G__charformatter(1,temp)));
   }


==========================================================================
G__ClassInfo

 G__ClassInfo is an ERTTI class which provides class/struct/union/enum
information.
Property of class, struct, union and enum types can be obtained.
<ertti.h> must be included to use ERTTI in an interpreter environment.
-I$CINTSYSDIR and -I$CINTSYSDIR/src command line option must be given to
cint and <Api.h> must be included to use ERTTI in precompiled library.

Interface of G__ClassInfo class is shown below. 
If default constructor is used, information about all existing class,struct,
union,enum can be iterated by G__ClassInfo::Next() member function.
If class name is given to constructor, G__ClassInfo object is immediately
initialized to specified class,struct,union or enum type.

class G__ClassInfo {
 public:
  // initialization and reset
  G__ClassInfo();
  G__ClassInfo(const char *classname);
  G__ClassInfo(G__ClassInfo& x);
  ~G__ClassInfo();
  void Init();
  void Init(const char *classname);

  // test equality
  int operator==(const G__ClassInfo& a);
  int operator!=(const G__ClassInfo& a);

  // get class information
  const char *Name() ;
  const char *Fullname();
  const char *Title() ;
  int Size() ; 
  long Property();
  int NDataMembers();
  int NMethods();
  long IsBase(const char *classname);
  long IsBase(G__ClassInfo& a);
  G__ClassInfo EnclosingClass() ;
  int Linkage();
  const char *FileName() ;
  int LineNumber() ;
  G__InterfaceMethod GetInterfaceMethod(const char *fname,const char *arg
					,long* poffset);
  G__MethodInfo GetMethod(const char *fname,const char *arg,long* poffset);
  G__DataMemberInfo GetDataMember(const char *name,long* poffset);
  void SetGlobalcomp(int globalcomp);
  void SetProtectedAccess(int protectedaccess);
  int IsValid();

  // iteration
  int Next();

  // other specification
     .
};


Example: Following example displays information about iostream class.

   $ cint classes.C
   class ostream  size=36  NMethods=24  NDataMembers=0
   class streambuf  size=80  NMethods=19  NDataMembers=0
   class ostream  size=36  NMethods=24  NDataMembers=0
   class ios  size=32  NMethods=27  NDataMembers=30
   enum io_state  size=4  NMethods=0  NDataMembers=0
   enum open_mode  size=4  NMethods=0  NDataMembers=0
   enum seek_dir  size=4  NMethods=0  NDataMembers=0
          .
          .
          .

   
   // classes.C
   #include <stdio.h>
   #include <iostream.h>
   #ifdef __CINT__
   #include <ertti.h>
   #else
   #include <Api.h>
   #endif
   
   void display(G__ClassInfo& cls) {
     long property = cls.Property();
     if(property&G__BIT_ISCLASS)  printf("class ");
     if(property&G__BIT_ISSTRUCT) printf("struct ");
     if(property&G__BIT_ISUNION)  printf("uinon ");
     if(property&G__BIT_ISENUM)   printf("enum ");
     printf("%s  size=%d  NMethods=%d  NDataMembers=%d\n"
	   ,cls.Name(),cls.Size(),cls.NMethods(),cls.NDataMembers());
   }
   
   void oneclass(char* classname) {
     G__ClassInfo cls(classname);
     display(cls);
   }
   
   void allclasses() {
     G__ClassInfo cls;
     // scan all defined classes
     while(cls.Next()) {
       display(cls);
     }
   }
   
   main() {
     // display only specific class
     oneclass("ostream");
     allclasses();
   }


SEE ALSO: ERTTI, G__ClassInfo,G__BaseClassInfo,G__MethodInfo
         ,G__MethodArgInfo,G__DataMemberInfo,G__TypeInfo
         ,G__TypedefInfo,G__CallFunc

==========================================================================
G__DataMemberInfo

 G__DataMemberInfo is an ERTTI API class which provides information about
global variable and data member.
<ertti.h> must be included to use ERTTI in an interpreter environment.
-I$CINTSYSDIR and -I$CINTSYSDIR/src command line option must be given to
cint and <Api.h> must be included to use ERTTI in precompiled library.

Interface to G__DateMemberInfo is shown below.
If default constructor is used, G__DataMemberInfo is initialized to
give global variable information.
All the global variables can be iterated by G__DataMemberInfo::Next()
member function.
If G__ClassInfo object is given to the constructor, it is initiazlied to
give data member information.
All the data member to that class can be iterated by G__DataMemberInfo::Next()
member function.

Cint handles constant value macro as global variable. 
Hence, G__DataMemberInfo can give information about macro. 
But if -p or +P,-P option is used, macro information is stripped by
preprocessor before it is read by cint, macro information can not be
get by G__DataMemberInfo.

class G__DataMemberInfo {
 public:
  // initialization and reset
  G__DataMemberInfo();
  G__DataMemberInfo(class G__ClassInfo &a);
  void Init();
  void Init(class G__ClassInfo &a);

  // get data member information
  const char *Name();
  const char *Title();
  G__TypeInfo* Type();
  long Property();
  long Offset() ;
  int ArrayDim() ;
  int MaxIndex(int dim) ;
  G__ClassInfo* MemberOf();
  int IsValid();

  // iteration
  int Next();

  // other specification
     .
};


Example: Following example displays all of the global variables, then,
displays ios class data member.

   $ cint DatMem.C
   public: FILE* stdout;
   public: FILE* stderr;
   public: FILE* stdin;
   public: #define EOF;
   public: #define NULL;
   public: FILE* G__dumpfile;
   public: #define G__STDIO_H;
   public: #define _IOFBF;
   public: #define _IOLBF;
      .
      .
   public: enum io_state goodbit;
   public: enum io_state eofbit;
   public: enum io_state failbit;
   public: enum io_state badbit;
   public: enum io_state hardfail;
   public: enum ios::open_mode in;
   public: enum ios::open_mode out;
   public: enum ios::open_mode ate;
   public: enum ios::open_mode app;
   public: enum ios::open_mode trunc;
      .
      .


   // DatMem.C
   #include <stdio.h>
   #ifdef __CINT__
   #include <ertti.h>
   #else
   #include <Api.h>
   #endif
   
   void display(G__DataMemberInfo& dat) {
     long property = dat.Property();
     if(property&G__BIT_ISPUBLIC)    printf("public: ");
     if(property&G__BIT_ISPROTECTED) printf("protected: ");
     if(property&G__BIT_ISPRIVATE)   printf("private: ");
     if(property&G__BIT_ISCONSTANT)  printf("const ");
     printf("%s %s;\n",dat.Type()->Name(),dat.Name());
   }
   
   void globalvariable() {
     G__DataMemberInfo dat;
     while(dat.Next()) {
       display(dat);
     }
   }
   
   void datamember(char *classname) {
     G__ClassInfo cls(classname);
     G__DataMemberInfo dat(cls);
     while(dat.Next()) {
       display(dat);
     }
   }
   
   main() {
     globalvariable();
     G__loadfile("iostream.h");
     datamember("ios");
   }


SEE ALSO: ERTTI, G__ClassInfo,G__BaseClassInfo,G__MethodInfo
          ,G__MethodArgInfo,G__DataMemberInfo,G__TypeInfo
          ,G__TypedefInfo,G__CallFunc

==========================================================================
G__delete_ipath()

int G__delete_ipath(const char* path);

G__delete_ipath() API deletes include path set by -I command line option or 
G__add_ipath() API.  Returns 1 if successful, otherwise 0.

Example:
   G__delete_ipath("/usr/local/mylib");
   G__delete_ipath("/home/x/y");


SEE ALSO: G__add_ipath()


==========================================================================
G__getipathentry()

struct G__includepath *G__getipathentry();

To be documented.


==========================================================================
G__deletevariable()

int G__deletevariable(const char *varname);

  G__deletevariable() API deletes global variable in interpreter's 
symbol table.
If deleted object is a class or struct, destructor is called properly.
Returns 1 if successful, 0 if failed.


Example:

double d=123;
main() {
  G__deletevariable("d"); 
}


==========================================================================
G__double()

double G__double(G__value buf)

 G__double() API converts G__value object to double.
G__double() can only be used in precompiled library enrironment.
$CINTSYSDIR/G__ci.h must be included to use G__double() API.


SEE ALSO: G__calc(), G__value 

==========================================================================
G__dumpfile

FILE* G__dumpfile;

 G__dumpfile is a predefined global variable in Cint interpreter. It is
set to NULL by default.  When writable file pointer is set, Cint dumps
fuunction call history and trace coverage to the file. This variable is
automatically set by -d command line option. Alternatively, a user can
set this manually for starting the dump at any time. 


SEE ALSO: -d option (cint)

==========================================================================
G__exec_tempfile()

[anytype] G__exec_tempfile(const char* file);   // from interpreted code
G__value G__exec_tempfile(const char* file);    // from precompiled code

G__exec_tempfile() opens temporary source file and execute
it  in  the  current  context.   The tempfile can contain,
variable   declaration,   struct,union,enum    definition.
expression,  loop and control statement and cannot contain
function definition.  G__exec_tempfile() executes a state-
ment or statement list surrounded by '{' , '}' and returns
the last evaluated value.


Example:
    G__exec_tempfile("tmp.C");


{    // example of tempfile, tmp.C
  int i;
  double ary[100];
  for(i=0;i<100;i++) ary[i] = i;
}

Then in the main program, you can execute above  statement
by G__exec_tempfile.


SEE ALSO: G__calc(), G__exec_text(), G__load_text()

==========================================================================
G__exec_text()

[anytype] G__exec_text(const char* unnamedmacro);   // from interpreted code
G__value G__exec_text(const char* unmamedmacro);    // from precompiled code

 G__exec_text() API evaluates C/C++ statements and returns its' value. 
In interpreter enviroment, type of the return value is automatically 
converted to suitable type without explicit type casting.
In compiled code , it returns G__value object which can be converted 
to long or double type object by G__double() or G__int() API.
If G__exec_text() API is used in precompiled library, you should include
$CINTSYSDIR/G__ci.h.

 Unlike G__calc() API, G__exec_text() can evaluate declaration and 
conditional statement. However, because G__exec_text() uses temporary
file, execution can be slower than G__calc().


Example:
    G__exec_text("int i");
    G__exec_text("for(i=0;i<10;i++) printf(\"i=%d\n\",i);");
    G__exec_text("i");


SEE ALSO: G__calc(), G__exec_tempfile(), G__load_text()

==========================================================================
G__exec_text_str()

char* G__exec_text_str(const char* unnamedmacro,char* result);

 G__exec_text_str() API is a version of G__exec_text which returns result
as string. G__exec_text(unnamedmacro) is called inside, then result is 
converted to string.

Example:
    char result[512];
    G__exec_text_str("int i",result);
    printf("%s\n",result);
    G__exec_text_str("i",result);
    printf("%s\n",result);


==========================================================================
G__findsym()

void* G__findsym(const char *symname);

 G__findsym() API searches symbols in explicitly loaded DLL (or shared 
library).  DLL can be loaded by G__loadfile() API. If you want to get a
handle to procedure included in the loaded DLL, you can use this API. 
G__findsym() can be used both in the interpreter and compiled code.
Supporse you have compiled program as shown below.

   // mylib.h
   extern "C" void my_func() {
      ...
   }

And you create Cint DLL

  $  makecint -mk Makefile -dl mylib.dll -H mylib.h
  $  make -f Makefile

Then you can get handle of my_func() as follows,

  $  cint mylib.dll
  cint> p G__findsym("my_func")
  (void*)0x401324dc
  cint>

This operation is almost platform independent  except for following 
conditions.

 1) For Win32 and IBM AIX, you need to explicitly export the symbols you
   wnat to access. Otherwise, you can not get desired handle.
 2) Some compiler requires '_' (underscore) before the symbol name.
 3) If you want to get handle to C++ function, you need to know name 
   mangling rule of specific compiler. If you want to avoid name mangling
   you have to declare the function 'extern "C"'.


Note:
 You can not get handle if DLL is implicitly linked with Cint.


==========================================================================
G__ForceBytecodecompilation()

int G__ForceBytecodecompilation(char *funcname,char *param);

This API forces specified function to be optimized as bytecode. Giving name
and parameter type(s) of the function, Cint searches appropriate function
and compiles it into bytecode. Compilation may not always succeed. In case
it fails, this function returns non-zero value.

Example:

   // test.cxx
   void f(int x,double a) {
     ...
   }

   int main() {
     G__ForceBytecodecompilation("f","int,double");
     f();
     return 0;
   }


==========================================================================
G__free_p2fsetup()

void G__free_p2fsetup(void);


 G__free_p2fsetup() API frees pointer to dictionary initialization
routine  registered by G__set_p2fsetup() API. See example in 
G__set_p2fsetup() section.


SEE ALSO: G__set_p2fsetup()


==========================================================================
G__FreeConsole

int G__FreeConsole(void);

 This API deletes console window for Windows based application.  Windows
based program may not have a console window.  If console window is not needed,
you can call this API.

Windows only

Example:
  void f() {
    G__setautoconsole(0);
    G__AllocConsole();
        ...
    G__FreeConsole();
  }


SEE ALSO: G__AllocConsole, G__setautoconsole

==========================================================================
G__get_sym_underscore

int G__get_sym_underscore(void);

 This API informs you if Cint requires '_' for linking C symbols in DLL
or shared library. If return value is 1, '_' is needed. If 0, '_' is not
needed. 


SEE ALSO: G__set_sym_underscore

==========================================================================
G__getexitcode()

int G__getexitcode(void);


 G__getexitcode() API returns argument to exit() function which is called
in Cint interpreter. This API can only be used in compiled code. You can
call this API only once because the exit eode is reset to zero after this
function is called.


==========================================================================
G__getmakeinfo()

char* G__getmakeinfo(char *item);


 G__getmakeinfo() API reads $CINTSYSDIR/MAKEINFO file to extract specified
platform dependent parameter. For example, if you want to extract name of
C++ compiler, you do

  printf("%s\n",G__getmakeinfo("CPP"));

Here are some interesting values you can get from MAKEINFO.

   "CC"      : C compiler name
   "CPP"     : C++ compiler name
   "LD"      : linker name
   "CPREP"   : C preprocessor name
   "CPPPREP" : C++ preprocessor name
   "DLLPOST" : DLL or shared library file extension


SEE ALSO: $CINTSYSDIR/MAKEINFO, Platform dependency file

==========================================================================
G__getoptimizemode()

int G__getoptimizemode();

G__getoptimizemode() returns bytecode optimization mode currently set.


SEE ALSO:  G__optimizemode , doc/bytecode.txt

==========================================================================
G__IncludePathInfo

 G__IncludePathInfo is an ERTTI API class which gives you include path
information. G__IncludePathInfo gives include path name given by -I option
and '#pragma includepath [path];' statement. Public interface of this class
is shown below.


   class G__IncludePathInfo {
    public:
     G__IncludePathInfo();
     void Init();
     const char *Name(); 
     long Property();
     int IsValid();
     int Next();
   };


Example:

   #ifdef __CINT__
   #include <ertti.h>
   #else
   #include <Api.h>
   #endif

   main() {
     G__IncludePathInfo ipath;
     while(ipath.Next()) {
       printf("%s\n",ipath.Name());
     }
   }


==========================================================================
G__init_cint()

int G__init_cint(const char *command)


 G__init_cint() API explicitly initializes cint interpreter core.
Normally, cint main() function implicitly initializes the interpreter.
But if main() function is included in user program, the interpreter must
be explicitly initialized by G__init_cint() API. 
 G__init_cint() takes command string as an argument which requires same
format as you invoke cint from command line.
Initialized interperter can be terminated by G__scratch_all() API.
G__init_cint()/G__scratch_all() pair can be used multiple time in a
single process.

 Alternative way to initialize and start Cint is to use G__main() and 
G__setothermain() API. Those APIs are used in G__init_cint.

 G__init_cint() API can only be used in precompiled library environment.
$CINTSYSDIR/G__ci.h must be included. 

  Return value of G__init_cint() is shown in table below.

 +---------------------------------------------------------------------------+
 | G__INIT_CINT_SUCCESS      | 0 | Initialization successful. main() function|
 |                           |   | was not found in loaded source code.      |
 +---------------------------+---+-------------------------------------------+
 | G__INIT_CINT_SUCCESS_MAIN | 1 | Initialization successful. main() function|
 |                           |   | was found in loaded source code and       |
 |                           |   | executed.                                 |
 +---------------------------+---+-------------------------------------------+
 | G__INIT_CINT_FAILURE      |-1 | Initialization failed.                    |
 +---------------------------------------------------------------------------+
                   Table  Return value of G__init_cint() 

Example: Following example initializes cint interpreter core twice by using
G__init_cint() API.

  $ makecint -m -I$CINTSYSDIR -mk Makefile -o mycint -C mycint.c 
  $ make
  $ mycint

/* mycint.c,  must be compiled with -I$CINTSYSDIR */
#include "G__ci.h"
main() {
   G__init_cint("cint -qlevel1 source1.C");
   G__calc("f1()");
   G__scratch_all();

   switch(G__init_cint("cint source2.C lib.C")) {
   case G__INIT_CINT_SUCCESS: /* initialization done */
     G__calc("f2()");
     G__calc("lib()");
     G__scratch_all();
     break;
   case G__INIT_CINT_SUCCESS_MAIN: /* initialization + main() exec done */
     G__scratch_all();
     break;
   case G__INIT_CINT_FAILURE: /* falied initialization */
     break;
   }
}


SEE ALSO: -m command link option of makecint
          G__main() , G__setothermain() , 
          G__set_p2fsetup() , G__free_p2fsetup()

==========================================================================
G__input()

char* G__input(const char *prompt);

 G__input() reads keyboard input. It returns pointer to static char buffer
declared in G__pause(). G__input uses GNU readline library for command line
completion and history management. 

Example: 

main() {  // example program
  char *command;
  while(1) {
    command = G__input("input command > ");
    if(strcmp(command,"exit")==0) exit();
    system(command);
  }
}


==========================================================================
G__int()

long G__int(G__value buf)

 G__int() API converts G__value object to long integer.
G__int() can only be used in precompiled library enrironment.
$CINTSYSDIR/G__ci.h must be included to use G__int() API.


SEE ALSO: G__calc(), G__value 

==========================================================================
G__IsInMacro()

int G__IsInMacro(void)

G__IsInMacro() API checks if cint execution is G__exec_tempfile() context
(Macro mode), or normal source code interpretation mode. For example,


// macro source which is executed in G__exec_tempfile context
{
  printf("%d\n",G__IsInMacro()); // prints '1'
}


// C++ source file which is executed in normal interpretation mode
f() {
  printf("%d\n",G__IsInMacro()); // prints '0'
}


G__IsInMacro() is used in CINT and ROOT system software  to  switch
internal operational mode.


==========================================================================
G__isinterpretedp2f()

int G__isinterpretedp2f(void *p2f)

 Because the interpreter environment and C/C++ compiler has different 
processing system, special care is needed to deal with a pointer to function
in a compiled code. When pointer to function is evaluated in interpreter
environment, it returns either 1) pointer to an interpreted function, 2)
pointer to an interface method of a compiled global function, 3) pointer to
a true compiled funcion, or 4) pointer to a bytecode function. 
G__isinterpretedp2f() judges which of above case is the given pointer.
Return value is shown in a table below.

 This funciton is only valid for global functions. If you use this API for 
ANSI C library function, it may return G__UNKNOWNFUNC.

 It is unneccessary to use G__isinterpretedp2f() API in interpreter environment
because cint will automatically distinguish between the pointer and handle it
properly.

 +--------------------------------------------------------------------------+
 | G__UNKNOWNFUNC             | 0 | Unknown pointer which does not exist in |
 |                            |   | the cint global function table          |
 +----------------------------+---+-----------------------------------------+
 | G__INTERPRETEDFUNC         | 1 | Pointer to an interpreted function      |
 |                            |   |                                         |
 +----------------------------+---+-----------------------------------------+
 | G__COMPILEDINTERFACEMETHOD | 2 | Pointer to an interface method of user  |
 |                            |   | embedded precompiled global function    |
 +----------------------------+---+-----------------------------------------+
 | G__COMPILEDTRUEFUNC        | 3 | Pointer to a true compiled function     |
 |                            |   |                                         |
 +----------------------------+---+-----------------------------------------+
 | G__BYTECODEFUNC            | 4 | Pointer to a bytecode function that is  |
 |                            |   | optimized by cint                       |
 +--------------------------------------------------------------------------+
                Table  Return value of G__isinterpretedp2f()


Example: 

   #include <iostream.h>

   #include "Api.h"   // -I$CINTSYSDIR/src -I$CINTSYSDIR

   DoFCN(void *p2f,char* a,double b) {
     char *fname;
     // reconstruct function name
     fname=G__p2f2funcname(p2f);
     if(fname) {
       G__ClassInfo globalscope;
       G__MethodInfo method;
       long dummy;
       // resolve function overloading
       method=globalscope.GetMethod(fname,"char*,double",&dummy);
       if(method.IsValid()) {
         int (*p)(char*,double);
         char temp[200];
         int result;
         // get pointer to function again after overloading resolution
         p2f=method.PointerToFunc();
         // check what kind of pointer is it
         switch(G__isinterpretedp2f(p2f)) {
         case G__INTERPRETEDFUNC: // reconstruct function call as string
           sprintf(temp,"%s(%ld,%g)",(char*)p2f,a,b);
           result=G__int(G__calc(temp));
           break;
         case G__BYTECODEFUNC: // calling bytecode function
           G__CallFunc func;
           func.SetBytecode((struct G__bytecodefunc*)p2f);
           func.SetArg((long)a);
           func.SetArg((double)b);
           result=func.ExecDouble((void*)NULL);
           break;
         case G__COMPILEDINTERFACEMETHOD: // using interface method
           G__CallFunc func;
           func.SetFunc((G__InterfaceMethod)p2f);
           func.SetArg((long)a);
           func.SetArg((double)b);
           result=func.ExecDouble((void*)NULL);
           break;
         case G__COMPILEDTRUEFUNC: // using true pointer to function
           result=(*p2f)(a,b);
           break;
         case G__UNKNOWNFUNC: // this case will never happen
           result=(*p2f)(a,b);
           break;
         }
         cout << "result=" << result << endl;
       }
       else {
         cerr << "no overloading parameter matches" << endl;
       }
     }
     else {
       cerr << "unknown pointer to function" << endl;
     }
   }


Example2:

   $ makecint -mk mkf -dl lib1.dll -I$CINTSYSDIR -I$CINTSYSDIR/src -H lib1.h
   $ make -f mkf
   $ cint main.cxx

   ////////////////////////////////////////////////////////////////
   // lib1.h
   #include <iostream.h>
   #include "Api.h"   // -I$CINTSYSDIR/src -I$CINTSYSDIR
   //////////////////////////////////////////////////////////////
   // FunctionObject for double f(int*,double)
   //////////////////////////////////////////////////////////////
   class FunctionObject {
     G__ClassInfo globalscope;
     G__MethodInfo method;
     G__CallFunc func;
     long dummy;
     void *regeneratedp2f;
     int mode;
    public:
     void Init(void *p2f) {
       char *fname;
       // reconstruct function name
       fname=G__p2f2funcname(p2f);
       if(fname) {
         // resolve function overloading
         method=globalscope.GetMethod(fname,"int*,double",&dummy);
         if(method.IsValid()) {
	   // get pointer to function again after overloading resolution
	   regeneratedp2f=method.PointerToFunc();
	   // check what kind of pointer is it
	   mode = G__isinterpretedp2f(regeneratedp2f);
	   switch(mode) {
	   case G__INTERPRETEDFUNC: // reconstruct function call as string
	     break;
	   case G__BYTECODEFUNC: // calling bytecode function
	     func.SetBytecode((struct G__bytecodefunc*)regeneratedp2f);
	     break;
	   case G__COMPILEDINTERFACEMETHOD: // using interface method
	     func.SetFunc((G__InterfaceMethod)regeneratedp2f);
	     break;
	   case G__COMPILEDTRUEFUNC: // using true pointer to function
              break;
	   case G__UNKNOWNFUNC: // this case will never happen
              break;
	   }
         }
         else {
	   cerr << "no overloading parameter matches" << endl;
         }
        }
       else {
         cerr << "unknown pointer to function" << endl;
       }
     }

     double Do(int* a,double b) {
       double result;
       char temp[200];
       switch(mode) {
       case G__INTERPRETEDFUNC: // reconstruct function call as string
         sprintf(temp,"%s((int*)%ld,%g)",(char*)regeneratedp2f,(long)a,b);
         result=G__int(G__calc(temp));
         break;
       case G__BYTECODEFUNC: // calling bytecode function
       case G__COMPILEDINTERFACEMETHOD: // using interface method
         func.ResetArg();
         func.SetArg((long)a);
         func.SetArg((double)b);
         result=func.ExecDouble((void*)NULL);
         break;
       case G__COMPILEDTRUEFUNC: // using true pointer to function
       case G__UNKNOWNFUNC: // this case will never happen
         double (*p)(int*,double) ;
         p = (double (*)(int*,double))regeneratedp2f;
         result=(*p)(a,b);
         break;
       default:
      result = 0;
         break;
       }
       return result;
     }
   };
   
   //////////////////////////////////////////////////////////////
   // Plug in functions
   //////////////////////////////////////////////////////////////
   double f1(int* a,double b) {
     double result = b*(*a);
     return result;
   }
   
   double f2(int* a,double b) {
     double result = b+(*a);
     return result;
   }
   
   //////////////////////////////////////////////////////////////
   // main test
   //////////////////////////////////////////////////////////////
   void test(void* p2f,int n) {
     FunctionObject fx;
     fx.Init(p2f);
     double sum=0;
     int a;
     double b=0.1;
   
     for(int i=0;i<n;i++) {
       a = i;
       sum += fx.Do(&a,b);
     }
     cout << "sum = " << sum << endl;
   
   }
   // end of lib1.h
   ////////////////////////////////////////////////////////////////
   

   //////////////////////////////////////////////////////////////////
   // main.cxx
   #include "lib1.dll"
   
   //////////////////////////////////////////////////////////////
   // Plug in functions
   //////////////////////////////////////////////////////////////
   double f3(int* a,double b) {
     double result = b-(*a);
     return result;
   }
   
   double f4(int* a,double b) {
     double result = b*(*a)*2;
     return result;
   }
   
   int main() {
     test(f1,1000000);
     test(f2,1000000);
     test(f3,100000);
     test(f4,100000);
   }
   // end of main.cxx
   ///////////////////////////////////////////////////////////////////



==========================================================================
G__LockCpp()

void G__LockCpp()

G__LockCpp() API enforces all source code to be handled as C++ regardless of
file name extension.  Same effect as -A command line option.


SEE ALSO: cint -A option


==========================================================================
G__lasterror_filename()

char* G__lasterror_filename()

G__lasterror_filename() API returns filename which last cint error occured.


==========================================================================
G__lasterror_linenum()

char* G__lasterror_linenum()

G__lasterror_filename() API returns line number which last cint error occured.


==========================================================================
G__load_text()

char* G__load_text(const char *namedmacro)

 G__load_text() API loads null terminated string as source code. It can 
contain any kind of C/C++ syntax that Cint supports. The text is saved
into a temporary file and read by Cint. The tempoprary file is automatically
removed when it is unloaded.

 G__load_text() returns name of the temporary file in a static buffer. You
can use that name for unloading.  In an event of failure, G__load_text() 
returns 0.


Example:

  // example unnamed macro doit.cxx
  {
    char *p;
    p=G__load_text("class A{public: 
                             A() {printf(\"A()\n\");} 
                             ~A() {printf(\"~A()\n\");} };
                    void f(){ printf(\"f()\n\"); }");
    if(p) {
      G__exec_text("A x");
      G__exec_text("f()");
      G__unloadfile(p);
    }
  }

  
  // Running it
  $ cint
  cint> x doit.cxx
  A()
  f()
  ~A()
  (const int)0
  cint>


SEE ALSO: G__loadfile(), G__unloadfile(), G__exec_text()

==========================================================================
G__loadfile()

int G__loadfile(const char *filename)

 G__loadfile() API loads source code or DLL(Dynamic Link Library) at run-time.
If file extention is .sl  , .dl , .dll or .DLL , the file is linked as DLL.
Otherwise, the file is loaded as source or header file.
G__loadfile("[filename]") behaves the same as '#pragma include "[filename]"'.
It first searches current working directory for given file name.
If not found it searches directories specified as include path by -I
command line option.
If not found either, it searches $CINTSYSDIR/include directory.
G__loadfile() can be used both in interpreted code and precompiled library.

G__loadfile() returns 0 (G__LOADFILE_SUCCESS) when successful, 
1 (G__LOADFILE_DUPLICATE) if specified file is already loaded,
-1 (G__LOADFILE_FAILURE) or -2 (G__LOADFILE_FATAL) if it fails.

  +-----------------------------------------------------------------------+
  | G__LOADFILE_SUCCESS   |  0 | load file success                        |
  +-----------------------+----+------------------------------------------+
  | G__LOADFILE_DUPLICATE |  1 | specified file is already loaded         |
  +-----------------------+----+------------------------------------------+
  | G__LOADFILE_FAILURE   | -1 | load file failed                         |
  +-----------------------+----+------------------------------------------+
  | G__LOADFILE_FATAL     | -2 | unrecoverble error occured during load   |
  +-----------------------------------------------------------------------+
                     Table.  Return value of G__loadfile()


SEE ALSO: G__unloadfile(), G__load_text(), xtdebugger command 'L' 

==========================================================================
G__loadsystemfile()

int G__loadsystemfile(char *sysdllname)

G__loadsystemfile() API loads permanently loaded DLL(Dynamic Link Library).
Once loaded with this API, that DLL remains loaded even if G__unloadfile()
is called. 

This API is added by Fons Rademaker's request for ROOT2.23 support.


==========================================================================
G__main()

int G__main(int argc,char **argv)


 G__main() API explicitly initializes cint interpreter core.
Normally, cint main() function implicitly initializes the interpreter.
But if main() function is included in user program the interpreter must
be initialized explicitly by G__main() API. 
 G__main() takes array of command string as arguments which requires same
format as you invoke cint from command line. 

 Alternative way to initialize and start Cint is to use G__init_cint() API.
G__init_cint() uses G__main() inside.

 G__setothermain() must be called before calling G__main(). Setting 
G__setothermain(0), G__main() initializes, starts and terminates interpreter
automatically. In this case, after G__main() you can not use the interpreter.
If you set G__setothermain(2), G__main() leave the interpreter alive. You
can use the interpreter until it is explicitly terminated bby G__scratch_all()
API. 

 G__init_cint() behaves the same as G__setothermain(2) + G__main(argc,argv).

 Also, be aware of G__set_p2fsetup() and G__free_p2fsetup(). Those let 
Cint recognize definition of user defined library.


Example1:

   #include <stdio.h>
   extern "C" {(0), 
   extern void G__setothermain(int othermain);
   extern int G__main(int argc,char **argv);
   }

   int main(int argc,char **argv)
   {
     int result;
     G__setothermain(0);
     result=G__main(argc,argv);
     // interpreter is terminated here
     return(result);
   }


Example2:

   #include <stdio.h>
   extern "C" {
   extern void G__setothermain(int othermain);
   extern int G__main(int argc,char **argv);
   extern void G__scratch_all(void);
   }

   int main(int argc,char **argv)
   {
     int result;
     G__setothermain(2);
     result=G__main(argc,argv);
     // interpreter is still alive, you can use other Cint APIs
     G__scratch_all();
     return(result);
   }


SEE ALSO: G__setothermain() 
          G__set_p2fsetup() , G__free_p2fsetup()
          G__init_cint()


==========================================================================
G__MethodArgInfo

 G__MethodArgInfo is an ERTTI API class which provides information about
function arguments.
<ertti.h> must be included to use ERTTI in an interpreter environment.
-I$CINTSYSDIR and -I$CINTSYSDIR/src command line option must be given to
cint and <Api.h> must be included to use ERTTI in precompiled library.

Interface to G__MethodArgInfo is shown below.
G__MethodArgInfo object must be initialized by G__MethodInfo object.
Call G__MethodArgInfo::Next() method to get argument information one by one.


class G__MethodArgInfo {
 public:
  // initialization and reset
  G__MethodArgInfo();
  G__MethodArgInfo(class G__MethodInfo &a);
  void Init(class G__MethodInfo &a);

  // get member function argument information
  const char *Name();
  G__TypeInfo* Type() { return(&type); }
  long Property();
  char *DefaultValue();
  G__MethodInfo* ArgOf() { return(belongingmethod); }
  int IsValid();

  // iteration
  int Next();

  // other specification
     .
};


Example: Following example displays type and name of function argument.

   void displayparam(G__MethodInfo& func) {
     long property;
     G__MethodArgInfo arg(func);
     int state=0;
     printf("(");
     while(arg.Next()) {
       if(state) printf(",");
       state=1;
       property=arg.Property();
       if(property&G__BIT_ISCONSTANT) printf("const ");
       printf("%s",arg.Type()->Name());
       if(arg.Name()) printf(" %s",arg.Name());
       if(arg.DefaultValue()) printf("=%s",arg.DefaultValue());
     }
     printf(");\n");
   }


SEE ALSO: ERTTI, G__ClassInfo,G__BaseClassInfo,G__MethodInfo,G__MethodArgInfo
          ,G__DataMemberInfo,G__TypeInfo,G__TypedefInfo,G__CallFunc 

==========================================================================
G__MethodInfo

 G__MethodInfo is an ERTTI API class which provides information about
global function and member function.
<ertti.h> must be included to use ERTTI in an interpreter environment.
-I$CINTSYSDIR and -I$CINTSYSDIR/src command line option must be given to
cint and <Api.h> must be included to use ERTTI in precompiled library.

Interface to G__MethodInfo is shown below.
If default constructor is used, G__MethodInfo is initializaed to give
global function information.
All the global function can be iterated by G__MethodInfo::Next()
member function.
If G__ClassInfo object is given to the constructor, it is initialized to
give member function information.
All the member function can be iterated by G__MethodInfo::Next()
member function.


class G__MethodInfo {
 public:
  // initialization and reset
  G__MethodInfo();
  G__MethodInfo(G__ClassInfo &a);
  void Init();
  void Init(G__ClassInfo &a);

  // get member function information
  const char *Name();
  const char *Title();
  G__TypeInfo* Type();
  long Property();
  int NArg();
  int NDefaultArg();
  G__InterfaceMethod InterfaceMethod();
  void* PointerToFunc();
  G__ClassInfo* MemberOf();
  const char *FileName();
  int LineNumber();
  int Size();
  int IsBusy();
  int IsValid();

  // iteration
  int Next();

  // other specification
     .
};


Example: Following example displays all of the global functions and 
member function of ios class.


   $ cint Func.C
   public: void G__list_class();
   public: void G__list_class(char* classname);
   public: void G__list_memvar(char* classname);
   public: void G__list_memfunc(char* classname);
   public: void G__InitGetSpecialObject(G__pMethodSpecialObject pmethod);
   public: void G__InitGetSpecialValue(G__pMethodSpecialValue pmethod);
   public: void displayparam(class G__MethodInfo& func);
   public: void display(class G__MethodInfo& func);
   public: void globalfunc();
      .
      .
      .



   #include <stdio.h>
   #ifdef __CINT__
   #include <ertti.h>
   #else
   #include <Api.h>
   #endif
   
   void displayparam(G__MethodInfo& func) {
     long property;
     G__MethodArgInfo arg(func);
     int state=0;
     printf("(");
     while(arg.Next()) {
       if(state) printf(",");
       state=1;
       property=arg.Property();
       if(property&G__BIT_ISCONSTANT) printf("const ");
       printf("%s",arg.Type()->Name());
       if(arg.Name()) printf(" %s",arg.Name());
       if(arg.DefaultValue()) printf("=%s",arg.DefaultValue());
     }
     printf(");\n");
   }
   
   void display(G__MethodInfo& func) {
     long property = func.Property();
     if(property&G__BIT_ISPUBLIC)    printf("public: ");
     if(property&G__BIT_ISPROTECTED) printf("protected: ");
     if(property&G__BIT_ISPRIVATE)   printf("private: ");
     if(property&G__BIT_ISCONSTANT)  printf("const ");
     printf("%s %s",func.Type()->Name(),func.Name());
     displayparam(func);
   }
   
   void globalfunc() {
     G__MethodInfo func;
     while(func.Next()) {
       display(func);
     }
   }
   
   void memberfunc(char *classname) {
     G__ClassInfo cls(classname);
     G__MethodInfo func(cls);
     while(func.Next()) {
       display(func);
     }
   }
   
   main() {
     globalfunc();
     G__loadfile("iostream.h");
     memberfunc("ios");
   }


SEE ALSO: ERTTI, G__ClassInfo,G__BaseClassInfo,G__MethodInfo,G__MethodArgInfo
          ,G__DataMemberInfo,G__TypeInfo,G__TypedefInfo,G__CallFunc 

==========================================================================
G__optimizemode()

int G__optimizemode(int optimizelevel);
 
G__optimizemode() sets bytecode optimization mode. Optimization mode ranges
from 0 to 5. Default is 4. 


SEE ALSO:  G__getoptimizemode , doc/bytecode.txt


==========================================================================
G__p2f2funcname()

char* G__p2f2funcname(void* p2f)

 G__p2f2funcname() returns name of a function from a given pointer to 
function.
This function is only valid for user embedded or user interpreted global
functions.
If this function is used on ANSI C library function or CINT API function,
return value is always (char*)NULL.


SEE ALSO G__interpretedp2f() 

==========================================================================
G__pause()

int G__pause(char *prompt)

 G__pause() explicitly starts cint's debugger interface.
It displays debugger prompt and waits for user input.
G__pause() returns non-zero value when 'i' (ignore) or 'q' (quit) command
is given. 
Otherwise, it returns 0.

 G__pause() API can be used in both interpreted code and precompiled
library.
$CINTSYSDIR/G__ci.h must be included when using CINT API in precompiled
library.


  +------------------------------------------------------------------------+
  | G__PAUSE_NORMAL    | 0 | Normal return value                           |
  +--------------------+---+-----------------------------------------------+
  | G__PAUSE_IGNORE    | 1 | When 'i' command (ignore) is given            |
  +--------------------+---+-----------------------------------------------+
  | G__PAUSE_STEPOVER  | 3 | When 'S' command (step over) is given         |
  +------------------------------------------------------------------------+
                 Table.  Return value of G__pause()


Example: Following example shows 2 uses of G__pause() API. THe first one
simply calls G__pause(). This behaves the same as setting break point to
the position of G__pause(). Second example uses G__pause() in a while
loop which tests G__pause() against 0. The condition is true until user
inputs 'i' or 'q' command from the debugger interface.


main() {
      .
  G__pause();            // Behaves the same as setting break point here.
      .
  while(0==G__pause()) ; // Loops here until 'i' or 'q' command is given
}


SEE ALSO: debugger command 

==========================================================================
G__process_cmd()


int G__process_cmd(char *line,char *prompt,int *more,int *err,G__value *rslt);

G__process_cmd() executes cint debugger interface command. 

CAUTION:
 This API is only for expert's use. Do not use this API unless you really
understand the detail.


==========================================================================
G__reloadfile()

int G__reloadfile(const char *file);

G__reloadfile() API loads source code or DLL(Dynamic Link Library) at run-time.
It operates similary to G__loadfile(). 

If specified file is already loaded, G__reloadfile() unloads all files
loaded after specified one, then reloads all unloaded files again. While 
G__loadfile() reloads specified one only.


SEE ALSO: G__loadfile(), G__unloadfile(), G__load_text()

==========================================================================
G__scratch_all()

void G__scratch_all(void)

 G__scratch_all() API terminates the interpreter and frees heap memory 
used by it.
The interpreter should not be used after G__scratch_all() is called.
To resume the interpreter, user needs to call G__init_cint().

 G__scratch_all() can only be used in precompiled library.
$CINTSYSDIR/G__ci.h must be included to use CINT API in precompiled library.


SEE ALSO: G__init_cint() 

==========================================================================
G__set_aterror()

void G__set_aterror(void (*p2f)())

G__set_aterror() API sets callback routine for error handling. If set,
callback function is called whenever cint error occurs.
NULL, pointer to interpreted function or pointer to compiled function
can be set.


==========================================================================
G__set_atpause()

void G__set_atpause(void (*p2f)())

G__set_atpause() API sets callback routine for G__pause() API.
If set, callback function is called whenever G__pause() API is called.
NULL, pointer to interpreted function or pointer to compiled function
can be set.


SEE ALSO: G__atpause

==========================================================================
G__set_autoloading()   ### DELETED ### DO NOT USE THIS

void G__set_autoloading(int (*p2f)(char*))

G__set_autoloading sets a function to recover from command line input.
If undefined class is used in command line input, Cint uses this
function to find appropriate shared library and ask user if he/she
wants to load it. If you do not use this API, default function G__autoloading 
(in cint/src/pause.c) is set.  For example,

   cint> .
   cint> TUnknown *x
   Error: Symbol TUnknown is not defined in current scope ...
   TUnknown.dll exists. Do you want to load it(y/n)?  y
   !!!Dictionary position rewound... !!!error recovered!!!
   TUnknown.dll loaded
   cint>

This API can only be used in compiled code.  Only for expert use.

==========================================================================
G__set_class_autoloading_callback

void G__set_class_autoloading_callback(int (*p2f)(char* classname,char* libname));

This API sets callback function for autoloading.


SEE ALSO: G__set_class_autoloading_table

==========================================================================
G__set_class_autoloading_table

void G__set_class_autoloading_table(char* classname,char* libname);

This API sets class-name vs library-name table for library autoloading.
If such table is setup, the library is automatically loaded when class name
is referenced in script or command line.

Example:

  void init() {
    G__set_class_autoloading_table("TMyClass1","MyLib1.dll");
    G__set_class_autoloading_table("TMyClass2","MyLib1.dll");
    G__set_class_autoloading_table("TMyClass3","MyLib1.dll");
    G__set_class_autoloading_table("TYourClass1","YourLib1.dll");
    G__set_class_autoloading_table("TYourClass2","YourLib1.dll");
  }

  void script() {
    TMyClass2 a;  // MyLib1.dll is loaded
    TMyClass1 b;  
    TYourClass3 c; // YouLib1.dll is loadedk
    ...
  }

  int main() {
    init();
    script();
  }

SEE ALSO: G__set_class_autoloading_callback

==========================================================================
G__set_history_size

void G__set_history_size(int s);

G__set_history_size() API changes size of command input history file.
Default is 30.



==========================================================================
G__setautoconsole()

void G__setautoconsole(int autoconsole);

 This API sets a special flag to automatically console window at any stdio
access from the Cint interpreter in Windows environment. If autoconsole 
flag is set to 1, console window will be automatically generated.

Windows only

Example:
  void f() {
    G__setautoconsole(1);
        ...
    printf("abc\n");   // console window appears automatically
        ...
    G__FreeConsole();
  }


SEE ALSO: G__AllocConsole, G__FreeConsole

==========================================================================
G__setbreakpoint()

int G__setbreakpoint(char *breakline,char *breakfile);

G__setbreakpoint() sets break point for interpreted source code. You can
set break point in a couple of different ways.  0 is returned if break point
is set successfully.  If 1 is returned, Cint fails to set break point.

1. by function name
  If you give function name to breakline argument, Cint looks for matching
  function and break point is set at the beginning of that function. The
  breakfile argument is ignored. For example,
     G__setbreakpoint("myfunc","");
     G__setbreakpoint("MyClass::memfunc","");

2. by line number
  If the first character in breakline string is a digit, Cint consider the
  information as line number.  Break point is set at specified line number.
  If breakfile argument is also specified, break point is set at a specific
  line of the source file. If breakfile does not contain any information, 
  break points are set at specified line of every source file. For example,
     G__setbreakpoint("11","mysrc.cxx");
     G__setbreakpoint("100","");


==========================================================================
G__set_emergencycallback()

void G__set_emergencycallback(void (*p2f)())

G__set_emergencycallback() API sets callback routine for emergency purpose.
The callback function is called when 'save' command is given from command
line.  This API can be used only in compiled code. Argument must be NULL
or a pointer to compiled function.


==========================================================================
G__set_eolcallback()

void G__set_eolcallback(void (*eolcallback)(const char* fname,int linenum))

This feature has been there, but not ready for public use yet.


==========================================================================
G__set_errmsgcallback()

void G__set_errmsgcallback(void (*p2f)(char *msg))

G__set_errmsgcallback() API sets callback routine for error message display.
If set, callback function is called whenever cint displays error message.
This API can be used only in compiled code.  Argument must be NULL or 
a pointer to compiled function.

You must define G__ERRORCALLBACK macro when you compile Cint. If you use
UNIX, add -DG__ERRORCALLBACK to OTHMACRO in platform dependency file.

If you use MS VC++, you need to do a couple of things in order to activate
this API. First, you need to open a project c:\cint\src\libcint\libcint.mdp.
Then, bring up a project setting dialog by 'Project->Settings...' pull down
menu.  Select 'C/C++' tag.  Select 'Preprocessor' category. There, you find
an entry for preprocessor definitions. Add G__ERRORCALLBACK there.  Another
thing you must do is to add 'G__set_errormsgcallback @125' at the end of 
c:\cint\src\libcint\libcint.def.


==========================================================================
G__set_beforeparse_hook()

typedef void G__parse_hook_t ();
G__parse_hook_t* G__set_beforeparse_hook(G__parse_hook_t* hook);

To be documented.


==========================================================================
G__set_ioctortype_handler()

G__set_ioctortype_handler(int (*p2f)(const char*));

To be documented.


==========================================================================
G__set_ignoreinclude()

typedef int (*G__IgnoreInclude)(const char* fname,const char* expandedfname);
void G__set_ignoreinclude(G__IgnoreInclude p2f);

G__set_ignoreinclude() API sets callback routine for G__loadfile() API.
If set, G__loadfile() lets the callback function to decide whether to
actually load the file or ignore it.


==========================================================================
G__set_p2fsetup()

void G__set_p2fsetup(void (*p2f)());


 G__set_p2fsetup() API registers pointer to dictionary initialization
routine.  This API must be called before G__main() or G__init_cint()
API , in order to let Cint recognize definition of user defined library.
Registered information must be freed using G__free_p2fsetup().

 Dictionary for user defined library is generated by 'cint -c-1' for C++
and 'cint -c-2' for C. Name of initialization routine is G__cpp_setup()
for C++ and G__c_setup() for C.  If -N[DLLID] option is given to Cint,
names will be G__cpp_setup[DLLID]() and G__c_setup[DLLID]().


Example:

  Suppose you have User.h and User.cxx, 

   $  makecint -mk Makefile -o user -H User.h -C++ User.cxx
   $  make -f Makefile

 Alternatively, you can use 'cint -c-1' as follows.

   $  cint -w0 -zUser -NUser -nG__cpp_User.cxx -D__MAKECINT__ -c-1 -A User.h

  Uou will have dictionary source file G__cpp_User.cxx. At the end of 
 G__cpp_User.cxx, you will find G__cpp_setup() or G__cpp_setupUser().
 Give pointer to this function to G__set_p2fsetup().


   #include <stdio.h>
   extern "C" {
   extern void G__setothermain(int othermain);
   extern int G__main(int argc,char **argv);
   extern void G__set_p2fsetup(void (*p2f)());
   extern void G__free_p2fsetup();
   extern void G__cpp_setupUser();
   }

   int main(int argc,char **argv)
   {
     int result;
     G__set_p2fsetup(G__cpp_setupUser);
     G__setothermain(2);
     result=G__main(argc,argv);
     // Do other things with G__calc() and G__exec_text() API.
     G__scratch_all();
     G__free_p2fsetup();
     return(result);
   }


SEE ALSO: 
          G__main() , G__setothermain() 
          G__free_p2fsetup()
          G__init_cint()

==========================================================================
G__set_smartunload()

void G__set_smartunload(int smartunload);

G__set_smartunload() API sets a flag to enable source file smart unloading.


==========================================================================
G__set_sym_underscore

void G__set_sym_underscore(int sym_underscore);

 This API sets if Cint requires '_' for linking C symbols in DLL
or shared library. If 1 is set, '_' is needed. If 0, '_' not needed. 


SEE ALSO: G__get_sym_underscore

==========================================================================
G__setothermain()

void G__setothermain(int othermain)


 G__setothermain() API selects initialization mode for G__main().
 G__setothermain() must be called before calling G__main(). Setting 
G__setothermain(0), G__main() initializes, starts and terminates interpreter
automatically. In this case, after G__main() you can not use the interpreter.
If you set G__setothermain(2), G__main() leave the interpreter alive. You
can use the interpreter until it is explicitly terminated bby G__scratch_all()
API.

 See code example in G__main() section.


SEE ALSO: G__main() 
          G__set_p2fsetup() , G__free_p2fsetup()
          G__init_cint()


==========================================================================
G__exit()

void G__exit(int rtn);

To be documented


==========================================================================
G__SourceFileInfo

 G__SourceFileInfo is an ERTTI API class which gives you source file 
information.   Public interface of this class is shown below.


   class G__SourceFileInfo {
    public:
     G__SourceFileInfo();
     G__SourceFileInfo(int filenin);
     void Init();
     const char *Name(); 
     const char *Prepname(); 
     FILE* fp();
     int MaxLine();
     G__SourceFileInfo& IncludedFrom();
     long Property();
     int IsValid();
     int Next();
   };


Example:

   #ifdef __CINT__
   #include <ertti.h>
   #else
   #include <Api.h>
   #endif

   main() {
     G__SourceFileInfo src;
     while(src.Next()) {
       printf("%s lines=%d  fp=0x%x\n",src.Name(),src.MaxLine(),src.fp());
     }
   }

==========================================================================
G__stepmode()

int G__stepmode(int on_off);

G__stepmode() turns on/off step execution mode. This API can be used both
from interpreted and precompiled code.


==========================================================================
G__tracemode()

int G__tracemode(int on_off);
 
G__tracemode() turns on/off source code trace mode. This API can be used
both from interpreted and precompiled code.


==========================================================================
G__TypeInfo

 G__TypeInfo is an ERTTI API class which provides information about
object type.
<ertti.h> must be included to use ERTTI in an interpreter environment.
-I$CINTSYSDIR and -I$CINTSYSDIR/src command line option must be given to
cint and <Api.h> must be included to use ERTTI in precompiled library.

Interface to G__TypeInfo is shown below.
G__TypeInfo distinguishes among fundamental types, class, struct, union, 
enum and typedef information associated with object, function and function 
argument.

class G__TypeInfo : public G__ClassInfo  {
 public:
  // initialization and reset
  G__TypeInfo();
  G__TypeInfo(const char *typenamein);
  void Init(const char *typenamein);

  // test equality
  int operator==(const G__TypeInfo& a);
  int operator!=(const G__TypeInfo& a);

  // get type information
  const char *Name();
  const char *TrueName();
  int Size(); 
  long Property();
  int IsValid();
  void *New();
  int Type() { return(type); }

 private:
  // iteration is prohibited
  int Next();

  // other specification
     .
};


Example: Following example displays information about ostream class.

   $ cint DispType.C
   name=class ostream  truename=class ostream  size=36

   // DispType.C
   #include <iostream.h>
   #include <stdio.h>
   #ifdef __CINT__
   #include <ertti.h>
   #else
   #include <Api.h>
   #endif

   main() {
     long property;
     G__TypeInfo t("ostream");
     property=t.Property();
     if(property&G__BIT_ISTYPEDEF) printf("typedef ");
     printf("name=%s  truename=%s  size=%d\n",t.Name(),t.TrueName(),t.Size());
   }



 SEE ALSO:  ERTTI, G__ClassInfo,G__BaseClassInfo,G__MethodInfo,G__MethodArgInfo
,G__DataMemberInfo,G__TypeInfo,G__TypedefInfo,G__CallFunc 

==========================================================================
G__TypedefInfo

 G__TypedefInfo is an ERTI API class which provides information about
typedef.
<ertti.h> must be included to use ERTTI in an interpreter environment.
-I$CINTSYSDIR and -I$CINTSYSDIR/src command line option must be given to
cint and <Api.h> must be included to use ERTTI in precompiled library.

Interface to G__TypedefInfo is shown below.


class G__TypedefInfo : public G__TypeInfo {
 public:
  // initialization and reset
  G__TypedefInfo();
  G__TypedefInfo(const char *typenamein);
  void Init();
  void Init(const char *typenamein);

  // get typedef information
  const char *Title() ;
  int IsValid();

  // iteration
  int Next();

  // other specification
     .
};


Example: Following example displays information about all typedefs.

   #include <iostream.h>
   #include <stdio.h>
   #ifdef __CINT__
   #include <ertti.h>
   #else
   #include <Api.h>
   #endif
   
   main() {
     long property;
     G__TypedefInfo t;
     char buf[80];
     while(t.Next()) {
       strcpy(buf,t.TrueName());
       printf("typedef %s %s;\n",buf,t.Name());
     }
   }


SEE ALSO: ERTTI, G__ClassInfo,G__BaseClassInfo,G__MethodInfo,G__MethodArgInfo
          ,G__DataMemberInfo,G__TypeInfo,G__TypedefInfo,G__CallFunc 

==========================================================================
G__unloadfile()

int G__unloadfile(const char *filename)

 G__unloadfile() API unloads source code or DLL(Dynamic Link Library) at 
run-time.  Cint loads/unloads source/DLL files in stack-wise way. All the
source/DLL files loaded after specified one will be unloaded at once.
G__unloadfile() can be used both in interpreted code and precompiled library.

G__unloadfile() returns 0 (G__UNLOADFILE_SUCCESS) when successful, 
-1 (G__UNLOADFILE_FAILURE) if it fails.

  +-----------------------------------------------------------------------+
  | G__UNLOADFILE_SUCCESS |  0 | unload file success                      |
  +-----------------------+----+------------------------------------------+
  | G__UNLOADFILE_FAILURE | -1 | unload file failed                       |
  +-----------------------------------------------------------------------+
                     Table.  Return value of G__unloadfile()


SEE ALSO: G__loadfile(), G__load_text(), debugger command 'L' 


==========================================================================
G__SetCatchException

void G__SetCatchException(int mode);

This API turns on/off if C++ exception handling (try..catch) is used when
calling compiled C++ code from the interpreter. 



==========================================================================
G__SetUseCINTSYSDIR

void G__SetUseCINTSySDIR(int UseCINTSYSDIR);

Only valid in ROOT/CINT environment under compiled code. This API sets a 
flag to use environment variable $CINTSYSDIR over the $ROOTSYSDIR for 
searching CINT system files. If set to 1, $CINTSYSDIR is used, if 0, 
$ROOTSYS is used.  Default is 0.

Example:
     #include "G__ci.h"
     void StartCint() {
       G__SetUserCINTSYSDIR(1);
       G__init_cint("cint");
        ...
       G__scratch_all();
     }


==========================================================================
G__value

 G__value is a type defined in $CINTSYSDIR/G__ci.h. G__value is an internal
representation of arbitrary C/C++ object value. It is also a return value
of G__calc(), G__exec_text() and argument of G__double(), G__int() API.
Do not refer directly into G__value object, but always use those API to
refer the internals.


SEE ALSO: G__calc(), G__exec_text(), G__double(), G__int()

==========================================================================
G__virtualinfo

When compiling Stub class using '-i++' option or '#pragma stub' command,
you can add G__virtualinfo as public data member. This enables you to 
inherit an interpreted class from a Stub class. For example,


// compiled code
  #include <stdio.h>
  class CompiledClass {
   public:
    void vfunc1() { printf("CompiledClass::vfunc1()\n"); }
  };
  
  void f(CompiledClass* p) {
    p->vfunc1(); // virtual function call from compiled code
  }


// stub code (compiled)
  class StubClass : public CompiledClass {
   public:
    void vfunc1();
   
    long G__virtualinfo; // add this in order to inherit an interpreted class
                         // from a Stub class
  };


// interpreted code
  void StubClass::vfunc1() { printf("StubClass::vfunc1()\n"); }
  
  class InterpretedClass : public StubClass {
   public:
    void vfunc1() { printf("InterpretedClass::vfunc1()\n"); }
  };
  
  void g() {
    CompiledClass px[3];
    px[0] = new CompiledClass;
    px[1] = new StubClass;
    px[2] = new InterpretedClass;
    for(int i=0;i<3;i++) {
      f(px[i]); // mixed interpreted/compiled virtual function resolution
    }
    for(int i=0;i<3;i++) {
      // LIMITATION, THIS DOES NOT WORK.
      px[i]->vfunc1(); // virtual function call from interpreted code
    }
  }



==========================================================================
==========================================================================
==========================================================================
INPUTMODE

 You can set default behavior of Cint command line input by setting INPUTMODE
and INPUTMODELOCK in $CINTSYSDIR/MAKEINFO. If those variables are omitted,
behavior is backward compatible.


  INPUTMODE     = [value]
      [value]
       C++      : Takes C++ statement without 'p' or '{' '}'. ';' is needed
		  at the end of every statement.
          Example:
	    cint> printf("abc\n");
            abc
	    (const int)4
	    cint> { printf("abc\n"); }
            abc
	    (const int)4
	    cint> .p printf("abc\n")
            abc
	    (const int)4
	    cint> 1+2
	    end with ';', '@':abort > +3;
	    (const int)6
	    cint> .class
	      ... display list of classes ...

       root     : Takes C++ statement without 'p' or '{' '}'. ';' can be
		  omitted for single line statement.
          Example:
	    cint> printf("abc\n")
            abc
	    (const int)4
	    cint> { printf("abc\n"); }
            abc
	    (const int)4
	    cint> .p printf("abc\n")
            abc
	    (const int)4
	    cint> 1+2
	    (const int)3
	    cint> .class
	      ... display list of classes ...

       cint     : Takes Cint command without '.'. C++ statement must be 
		  enclosed by '{' '}'.
          Example:
	    cint> { printf("abc\n"); }
            abc
	    (const int)4
	    cint> p printf("abc\n")
            abc
	    (const int)4
	    cint> p 1+2
	    (const int)3
	    cint> class
	      ... display list of classes ...

  INPUTMODELOCK = [value]
      [value]
       on       : Lock input mode. You can not change input mode by '.','..' 
       off      : You can change input mode by '.','..'


Example1:
   # Default setting, compatible to conventional cint
   INPUTMODE     = cint
   INPUTMODELOCK = off

Example2:
   # Default setting for ROOT, compatible to conventional ROOT/CINT
   INPUTMODE     = root
   INPUTMODELOCK = on

Example3:
   # Use C++ mode and the mode can not be changed
   INPUTMODE     = C++
   INPUTMODELOCK = on


SEE ALSO: $CINTSYSDIR/MAKEINFO

==========================================================================
INPUTMODELOCK

  See INPUTMODE

==========================================================================
==========================================================================
==========================================================================
makecint

 makecint is a tool that makes precompiled library for Cint. If you give
necessary information to makecint as command line option, it creates a
Makefile for compiling and linking Cint precompiled library.


SEE ALSO: doc/makecint.txt

==========================================================================
MAKEINFO

 Refer to $CINTSYSDIR/MAKEINFO

==========================================================================
==========================================================================
==========================================================================
Platform dependency file

 Platform dependency file is a file that specifies CPU and/or Operating
System dependent information. Platform dependency file is used when compiling
Cint core and copied and used as $CINTSYSDIR/MAKEINFO file. Many examples
of platform dependency files exist under $CINTSYSDIR/platform directory.


SEE ALSO: platform/README.txt

==========================================================================
Precompiled library

 Precompiled library is a native code program that is built into and 
made accessible from Cint. Normally, precompiled library is created by
makecint (or rootcint in case of ROOT framework).

 There are 2 kinds of precompiled libraries.

  - Archived Library
      Archived library is statically linked with Cint core. Only one 
     archived library can be linked to Cint at a time. Archived library
     is used less often because Dynamic Link Library is , in most cases,
     better and convenient.

  - Dynamic Link Library
      Dynamic Link Library is dynamically loaded and unloaded with Cint core.
     Multiple Dynamic Link Library can be loaded at once.


SEE ALSO: doc/makecint.txt
          demo/makecint/README.txt, demo/makecint/*/README.txt

==========================================================================
==========================================================================
==========================================================================
STUB 

 For cint/makecint, STUB means a class or function that can be used in 
compiled code and its' implementation is interpreted. Concept of STUB
is shown as below by comparison with precompiled library.


        Interpreted code                 Compiled code    
              |                                |
              |calls                           |calls
              |                                |
              V                                V
        Compiled code                    Interpretedd code
          (Precompiled library)            (STUB)


SEE ALSO: doc/makecint.txt (-i++/-i option)
          demo/makecint/Stub/README.txt, demo/makecint/Stub2/README.txt

==========================================================================
==========================================================================
==========================================================================

