CINT(1)                                                   CINT(1)


NAME
       cint - C/C++ interpreter


DESCRIPTION
        "cint"  is  a  C/C++ interpreter. About 95% of ANSI C and
       90% of C++ features are covered. (Data abstraction,  class
       inheritance, virtual function, function and operator over-
       loading, default parameter, template,  etc...)   Cint  has
       source  code  debugger  for interpreted source code and it
       has sufficient capability for debugging a C++ script.


CINT AND MAKECINT
        Cint can be used just as it is, but it is recommended  to
       use  makecint.   Makecint can encapsulate   native   C/C++
       objects into Cint as precompiled libraries.  User  defined 
       precompiled  objects  can be accessed  from the interpreter
       and  a  user  application  can  invoke C/C++ interpreter as 
       interactive interface. It provides seamless compiler/interpreter 
       scripting environment. Precompiled libraries can be dynamically 
       loaded/unloaded if they are configured as Dynamic Link Library 
       (DLL). SEE ALSO MAKECINT(1)


SYNOPSIS
       cint <[options]> <[sourcefiles]|[suboption]> <[arguments]>

       [options]     (* : used only with makecint or -c option)
          -A : ANSI C++ mode(default)
          -b [line] : set break line
        * -c -1: make C++ precompiled interface method files
        * -c -2: make C precompiled interface method files
        * -c -10: make C++ precompiled interface method files. Default link off
        * -c -20: make C precompiled interface method files. Default link off
        * -c -11: make C++ precompiled interface method files. Default link on
        * -c -21: make C precompiled interface method files. Default link on
          -C : copy src to $TMPDIR so that src can be change during cint run
          -d [dumpfile] : dump function call history
          -D [macro] : define macro symbol for #ifdef
          -e : Not ignore extern declarations
          -E : Dump core at error
          -E -E : Exit process at error and uncaught exception
          -f [file] : set break file
          -F [assignement] : set global variable
          -G [tracedmp] : dump exec trace into file
          -i : interactively return undefined symbol value
          -I [includepath] : set include file search path
	  -j [0|1]: Create multi-thread safe DLL(experimental)
	  -J[0-4] : Display nothing(0)/error(1)/warning(2)/note(3)/all(4) 
          -K : C mode
          -l [dynamiclinklib] : link dynamic link library
          -m : Support 8bit char comment (Disable multi-byte char)
        * -n [linkname] : Specify precompiled interface method filename
        * -N [DLL_name] : Specify DLL interface method name
          -O [0~4] : Loop compiler on(1~5) off(0). Default on(4)
          -Q : Quiet mode (no prompt)
          -p : use preprocessor prior to interpretation
          -q [security] : Set security level(default 0)
          -r : revision and linked function/global info
          -R : display input file at break point
          -s : step execution mode
          -S : step execution mode, First stop in main()
          -t : trace execution
          -T : trace from pre-run
        * -u [undefout] : listup possible undefined typenames
        * -U [dir] : directory to disable interface method generation
        * -V : Generate symbols for non-public member with -c option
          -v : Bytecode compiler debug mode
          -X [readlinedumpfile] : Execute readline dumpfile
          -x 'main() {...}' : Execute argument as source code
          -Y [0|1] : ignore(1) not ignore(0) std namespace 
          -Z [0|1]: auto loading of std hdr files with DLL
          --'command': Execute interactive command and terminate Cint

       [sourcefiles]
        Cint directly accepts C/C++ source file. If you give mul-
       tiple  source  files,  main() function must be included in
       the last one. If source file is omitted or main() function
       is  not  found  in  given  source file, cint automatically
       starts interactive interface.
        Cint reads source file  on-the-fly  from the file system. 
       Do not change the active source files during cint run.

       [suboptions]   (* : used only with makecint or -c option)
        Suboptions are options which appears  in  between  source files.
           +V : turn on class title comment mode for following source fies
           -V : turn off class title comment mode for following source fies
           +P : turn on preprocessor for following source files
           -P : turn off preprocessor for following source files
         * +STUB : stub function header begin
         * -STUB : stub function header end

       [arguments]
        Arguments to main(int argc,char *argv[]) function.


EXAMPLE
            $ cint
            $ cint lib1.c lib2.c source.c
            $ cint -S -I../include -DDEBUG source.c
            $ cint -x 'main(int argc,char *argv[]){printf("%s\n",argv[1]);}'
            $ cint -qlevel1 myprog.C


LANGUAGE LIMITATIONS
        Refer to doc/limitati.txt


DEBUG MODE
        Cint starts debug mode at following situation.
            * main() function is not included in the given source file.
            * Step execution mode (-S,-s option)
            * Program reaches to a break point
            * Keyboard interrupt (CTL-C or Break)
            * Explicit call of interactive interface function G__pause().
            * Bus error or segmentation violation occurred.

       # GNU readline
        GNU readline library , if exists, is used as command line
       front-end processor.  It can perform command line  editing
       and name completion.

       # Debug mode command
        You  can perform step and trace execution, locate as many
       break  points  as  you  want,  look  into   function/vari-
       able/class  information  tables,  etc...  Use of following
       debug mode commands enables you to do these things.
        Cint's debug mode can only debug interpreted source code.
       You  need to use a binary level debugger to debug pre-com-
       piled library. Cint can be used with any  kind  of  binary
       level debugger such as xdb,gdb.

       cint (C/C++ interpreter) debugger usage:
       Dump:        n [file]  : create new readline dumpfile and start dump
                    y [file]  : append readline dump to [file]
                    z         : stop readline dump
                    < [file]  : execute readline dumpfile
                    > [file]  : output redirect to [file]
                    2> [file] : error redirect to [file]
                    .         : switch command input mode
       Help:        ?         : help
                    help      : help
                    /[keyword] : help information for keyword
       Completion:  [nam][Tab] : complete symbol name start with [nam]
                    [nam][Tab][Tab] : list up all symbol name start with [nam]]
       Shell:       ![shell]  : execute shell command
       Source:      v <[line]>: view source code <around [line]>
                    V [stack] : view source code in function call stack
                    t         : show function call stack
                    f [file]  : select file to debug
                    T         : turn on/off trace mode for all source
		    J [stat]  : Set warning level [0-5]
                    A [1|0]   : allowing automatic variable on/off
                    trace <classname> : turn on trace mode for class
                    deltrace <classname> : turn off trace mode for class
                    break [classname] : set break point at every [classname] 
                                        memberfunc
                    delbreak [classname] : turn off memberfunc break point
       Evaluation:  p [expr]  : evaluate expression 
                                 (no declaration/loop/condition)
                    s [expr]  : step into expression 
                                 (no declaration/loop/condition)
                    S [expr]  : step over expression 
                                 (no declaration/loop/condition)
                    {[statements]} : evaluate statement (any kind)
                    x [file]  : load [file] and evaluate {statements} in the 
                                file
                    X [file]  : load [file] and execute function [file]
                                 (wo extension)
                    E <[file]>: open editor and evaluate {statements} in the 
                                file
       Load/Unload: L [file]  : load [file]
                    La [file] : reload all files loaded after [file]
                    U [file]  : unload [file]
                    C [1|0]   : copy source to $TMPDIR (on/off)
                    reset     : reset interpreter environment
                    undo      : undo previous declarations
                    lang      : local langguage (EUC,SJIS,EUROPEAN,UNKNOWN)
       Monitor:     g <[var]> : list global variable
                    l <[var]> : list local variable
                    proto <[scope]::>[func] : show function prototype
                    class <[name]> : show class definition (one level)
                    Class <[name]> : show class definition (all level)
                    typedef <name> : show typedefs
                    function  : show interpreted functions
                    macro     : show macro functions
                    template  : show templates
                    include   : show include paths
                    file      : show loaded files
                    where     : show current file position
                    security  : show security level
                    refcount  : reference count control on/off
                    garbage   : show garbage collection buffer
                    Garbage   : Do garbage collection
                    cover [file] : save trace coverage
                    return [val] : return undefined symbol value
       Run:         S         : step over function/loop
                    s         : step into function/loop
                    i         : ignore and step over
                    c <[line]>: continue <to [line]>
                    e         : step out from function
                    f [file]  : select file to debug
                    b [line]  : set break point
                    db [line] : delete break point
                    a [assert]: break only if assertion is true
                    O [0~4]   : Set bytecode compiler mode
                    debug     : bytecode status display on/off
                    asmstep   : bytecode step mode on/off
                    status    : show bytecode exec flags
                    dasm      : disassembler
       Quit:        q         : quit cint 
                    qqq       : quit cint - mandatory


ENVIRONMENT VARIABLE
        You  need  to set following environment variables. If you
       install cint into /usr/local/cint directory, for example,

       ksh/bsh
            CINTSYSDIR=/usr/local/cint
            export CINTSYSDIR
                 # or where you have installed cint

       csh
            setenv CINTSYSDIR /usr/local/cint
                 # or where you have installed cint



CINT INSTALLATION
        Refer   to   $CINTSYSDIR/README.txt   and   $CINTSYSDIR/plat-
       form/README.txt.



SEE ALSO
            doc/makecint.txt


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


