CINT(API) 


CAUTION:  Please refer to doc/ref.txt. This file is getting old.


 This document describes CINT C/C++ interpreter API functions.



CINT API functions
        Following  functions  are  supplied by cint for debugging
       and source code analysis purposes.

            char *G__input(const char *prompt);
            int G__pause();
            int G__tracemode(int on_off);
            int G__setbreakpoint(char *breakline,char *breakfile);
            int G__stepmode(int on_off);
            [anytype] G__calc(const char *expression);
            [anytype] G__exec_tempfile(const char *file);
            int G__loadfile(const char *file);
            int G__unloadfile(const char *file);
            int G__reloadfile(const char *file);
            char *G__search_next_member(const char *name,int state);
            void *G__what_type(const char *name,char *type,char *tagname,char *typename);
            int G__lock_variable(char *varname);
            int G__unlock_variable(char *varname);
            G__graph(double xdata[],double ydata[],int ndata,char *title,int mode);

# char *G__input(const char *prompt);

        G__input() reads keyboard input. It  returns  pointer  to
       char  declared  as  static  opject  in G__pause(). So, the
       returned pointer must not be freed.

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

# int G__pause();

       When  G__pause()  is  called,  interactive  interface  is
       started.   Debug commands can be used.  G__pause() returns
       1 if 'I' command is given.   So  you  can  repeat  calling
       G__pause() until 'i' input by following example.

         while(G__pause()==0);

# int G__tracemode(int on_off);

      G__tracemode() sets trace mode.

# int G__breakline(int line);

      G__breakline()  sets break point.  If 0 is given as argument, 
      break point is cleared.

# int G__stepmode(int on_off);

       G__stepmode() switchs on/off step execution mode.


# [anytype] G__calc(char *expression);

        G__calc() evaluates C expression.  It returns the type of
       object  the  argument  expression  returns.  Variables and
       function calls can be used in  the  expression.   Declara-
       tion,  loop  and  conditional statement can not be used in
       the expression.

            int i;
            double a;
            i = G__calc("1+2+3");  // returns int
            a = G__calc("3.14*i");  // returns double

# [anytype] G__exec_tempfile(char *file);

        G__exec_tempfile() opens temporal 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 of tempfile
                 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.


# int G__loadfile(const char *file);

        G__loadfile() incrementally loads source file. If file

# int G__unloadfile(const char *file);

        G__unloadfile()  unloads source file. If any of the func-
       tions  included  in  the  file  is  busy,  G__unloadfile()
       returns error code (-1) and won't unload it.

# int G__reloadfile(const char *file);

        G__reloadfile() does G__unloadfile() and G__loadfile() at
       once.

# char *G__search_next_member(const char *name,int state);

        G__search_next_member() searches for function  and  vari-
       able  name in current scope which start with name. state=0
       must be given at the first call of G__search_next_member()
       for  initialization.  In consequitive calls, state must be 1.
        G__search_next_member() returns malloced pointer. If  you
       call  this  function, you must free() the returned pointer
       afterwards.

# void *G__what_type(const char *name,char *type,char  *tagname
                     ,char *typename);

        G__what_type()  returns  pointer  and type information of
       the object of name.  Sufficient length of  string  pointer
       must be given to typa,tagname and typename argument.

# int  G__lock_variable(char  *varname); 
# int G__unlock_variable(char *varname);

       (THIS CAPABILITY IS OBSOLETED IN CINT-5.14.5)
        G__lock_variable()   and   G__unlock_variable()   control
       assignment  locking.  Assignement to specific variable can
       be locked/unlocked.

# G__graph(double  xdata[],double   ydata[],int   ndata,char *title,int mode);

        G__graph()  uses  xgraph  to  plot 2 dimentinal graph. If
       mode is 0, G__graph() waits for xgraph process to be  ter-
       minated. If mode is 1, xgraph becomes a background job. If
       mode is 3, G__graph() appends x and y data  to  "G__graph"
       file and will not invoke xgraph process.



# ERTTI (Extensive Run Time Type Identification)
        Many people are interested in Cint as basement for build-
       ing class browser or program analyzer. For  those  people,
       ERTTI  API which gives an access to Cint's symbol table is
       a useful interface. Information about ERTTI is  documented
       in doc/ref.txt



# pragma compile
        Source  file  can  be partially compiled by '#pragma com-
       pile' statement.  In the following example, 'int globals;'
       and  'func()'  are  compiled  when they are updated.  When
       this program  is  first  executed  by  cint,  makecint  is
       invoked  and  source  code surrounded by '#pragma compile'
       and '#pragma endcompile' will be compiled into  a  dynamic
       link library 'G__autocc.sl'. The G__autocc.sl is automati-
       cally loaded and compiled version of 'func()' will be exe-
       cuted.
        This feature is only available on HP-UX 8.0 or later ver-
       sion.

            // #pragma disablecomppile
            #pragma compile
            int globals; /* this global variable is compiled */
            #pragma endcompile

            main(int argc,char **argv) {
                 func(argv[1]);
            }

            #pragma compile
            int func(char *string)
            {
                 /* this function is compiled and dynamically linked */
            }


    #pragma compile
        Specifies beginning of compiled  section  which  must  be
       ended by '#pragma endcompile'. Multiple compile,endcompile
       pair can appear in the source code.

    #pragma endcompile
        Specifies end of compiled section.

    #pragma disablecompile
        Turn off '#pragma compile'. Pragma compile is  turned  on
       by  default. '#pragma disablecompile' must be described if
       you turn off the mode.

    #pragma enablecompile
        Turn on '#pragma compile'.




Undeclared symbol
        Cint can execute C code which  includes  undeclared  sym-
       bols.   Undeclared  symbols  are  detected  and handled by
       interpreter at run time.  As cint detects undeclared  sym-
       bols, warning message is printed out and execution will be
       continued.

       Assigning to undeclared variable:
        If assignment to undeclared variable appears, cint  allo-
       cates  automatic  variable.  If assignment value is double
       or float, double type variable is  allocated.   Otherwise,
       int  type  variable  is allocated.  For example, following
       program works as intended.

            main() {
                 double dat[10];
                 for(i=0;i<10;i++) {    /* i allocated as int */
                      dat[i]=i;
                      sum += dat[i]; /* sum allocated as double */
                 }
                 printf("sum=%g\n",sum);
            }

       If undeclared symbol first appears as array form, array of
       appropriate  size  will  be  allocated.   For  example, if
       'data[1][10]=3.14' appears without declaration of 'data' ,
       'double  data[2][11]'  is allocated and 'data[1][10]=3.14'
       is assigned.  Array can not be expanded  after  the  auto-
       matic  allocation.  So, 'data[2][15]=15;' will be rejected
       because array index is out of range.

            main() {
                 data[1][10]=3.14;  // double data[2][11]; data[1][10]=3.14;
                 data[0][3]=153.3;  // OK
                 data[2][15]=-15.0; // rejected, array can not be expanded
            }

       Pointer to automatically allocated  variable  can  not  be
       used.   If  undeclared  variable  appears with referencing
       operator '*' or '&', these operators are ignored.

       Referencing undeclared variable:
        If undeclared variable is referenced, cint  returns  NULL
       or zero as its value.

       Undeclared function:
        If  undeclared  function is called, it is simply skipped.
       Parameter list will be evaluated.

            main() {
                 int i=0;
                 undeclaredfunc(i++); // function call skipped
                 // i is 1 here because i++ was evaluated above
            }





BUGS
        Report  bugs  and  requirements  to root-cint@cern.ch. Bugs
       tend to be fixed very quickly. Any  kind  of  comments  or
       messages will be appreciated.

SEE ALSO
            doc/makecint.txt 


AUTHOR
       Masaharu Goto  (root-cint@cern.ch)
       Copyright  (c)  1995~1999 Masaharu Goto
















































2                            function                           6

