Man Linux: Main Page and Category List

NAME

       makecint - C/C++ interpreter-compiler

SYNOPSIS

       makecint  [  -mk  MAKEFILE  ]  [  -o  OBJECT  ] [ -H C++HEADER ] [ -C++
       C++SOURCE] [ -m ] [ -p ] [ -dl DLL ] [ -h CHEADER ] [ -C CSOURCE] [  -l
       LIB ] [ -i STUBC] [ -i++ STUBC++ ]

DESCRIPTION

       makecint  is  an  utility  to link compiled C/C++ objects with the Cint
       C/C++ interpreter. Functions, global variables and classes defined in a
       C/C++   pre-compiled  library  can  be  seamlessly  accessed  from  the
       interpreter. As you call yacc/lex a compiler-compiler, we call makecint
       an  interpreter-compiler.   A  pre-compiled  library can be dynamically
       loaded as Dynamic Link Library (DLL). See also cint (1).
       (This sounds smooth, however, I recommend to  start  from  very  simple
       example.    Linking  non-trivial  libraries  will  be  tricky.  Contact
       MXJ02154@niftyserve.or.jp if you need help.)

OUTLINE OF MAKING A PRECOMPILED LIBRARY

       Generic  outline of making a precompiled library  will be described  in
       this section.

       Files
       You  need to prepare header files [xxx.h]  which  includes interface of
       the encapsulated C/C++ library.  You  also  need  either  source  files
       [xxx.C]  [xxx.c],  object  files  [xxx.o],  library  files  [xxx].a  or
       combination of those.

       Procedure
       1) Create a Makefile
       First of all, you need to create a Makefile by using makecint. Makecint
       will  automate  a process of generating Makefile. In following example,
       makecint will create a Makefile which compiles "mycint" executable. The
       "mycint" embeds xxx.C and yyy.o as precompiled library.
            $ makecint -mk Makefile -o mycint -H xxx.h yyy.h -C++ xxx.C yyy.o
       Command line options will be explained later in this document.

       2) Modify Makefile (if needed)
       Please  check  the  created  Makefile and modify it if needed.  If your
       library is simple, modification  may  not  be  needed.   However,  when
       linking  non-trivial  libraries,  you may need to carefully examine and
       modify Makefile by hand.

       3) Do make
       Do  make.  "mycint"  will  be  compiled  and  linked.  "mycint"  is   a
       customized  C/C++   interpreter  which  pre-includes interface to xxx.h
       and yyy.h.
            $ make
       Inside the make, Cint is invoked  for  making  dictionary  source  code
       G__cpp_[XXX].C   and/or   G__c_[XXX].c.   These  source  files  include
       interface methods for enabling seamless access between the  interpreter
       and a compiled code.

       Examples
       /usr/share/doc/cint/demo/makecint     directory    contains   examples.
       Refer to /usr/share/doc/cint/demo/makecint/README.txt for details.

WHAT CAN BE DONE WITH THE PRECOMPILED LIBRARY

       Non static global variable and function
       Non static global variables and functions  can  be  accessed  from  the
       interpreter.

       Class members
       Public  member  of  classes  and  structs  can  be  accessed  from  the
       interpreter. You can not access private and protected members from  the
       interpreter.  Size  of  class/struct objects and data-member/base-class
       offsets match to the compiled code.  (If you use a  special  technique,
       you can access protected member from the interpreter. SEE ’#pragma link
       C++ class+protected’)

       Template
       Instantiated template class and  template  function   can  be  accessed
       from  the  interpreter. Template itself can not be precompiled.

       typedef
       Typedef   information  is  precompiled  and  can  be   used   from  the
       interpreter.

       Inheritance, Class object as member
       Inheritance and class object members are handled properly when they are
       precompiled.   Precompiled class can be a super-class of an interpreted
       class.  Also, object of  precompiled  class  can  be  a  member  of  an
       interpreted  class.   Virtual  function defined in precompiled class is
       only  virtual  within  the  precompiled  object  because  compiler  and
       interpreter  has different virtual function resolution mechanism. There
       will be a possible enhancement in the future.

       Default constructor, copy constructor , destructor
       If one of  default  constructor,  copy  constructor  or  destructor  is
       declared private (or protected), the class can not be accessed from the
       interpreter.

OPTIONS

       Space between option specifier and option argument is significant.  You
       must  put  space  between  them.  For example, ’-o object’ is valid but
       ’-oobject’ is not. Exceptions are  -D  and  -I  options  which  accepts
       arguments like ’-DMACRO1’ and ’-I/home/mydir/include’.

       -o OBJ specify object name (customized C/C++ interpreter).
              -o option specifies object name which becomes a customized C/C++
              interpreter.  -o option can not be omitted, otherwise -dl option
              must  be  given.   -o and -dl options are exclusive. Only one of
              them must be given.  For example,
                  $ makecint -mk Makefile -o mycint -H prog.h -C++ prog.C
                  $ make
              Will  make  customized  cint  "mycint"  including  prog.C   user
              specific library.

       -dl DYNLIB
              Generate dynamic link library object.
              This  option  generates  dynamic  link library(DLL) which can be
              dynamically linked with cint at run time.  For example,
                  $ makecint -mk Makefile -dl func.dl -H func1.h func2.h -C++ func1.C func2.C
                  $ make
              This will generate  a  DLL  ’func.dl’  which  includes  Position
              Independent  Code of func1.C, func2.C.  -dl option compiles user
              specific Suffix of the dynamic link library can be either ’.dl’,
              ’.sl’,  or  ’.DLL’.  You can link func.dl by passing it to cint.
              Multiple DLL can be linked at a  time  if  there  is  no  cyclic
              symbol dependency.
                  $ cint func.dl othersource.c
                  $ cint func1.dl func2.dl othersource.c
              You  can  link  the  DLL  by  ’#include’  or  ’#pragma  include’
              statement in the source code. ’#include’ and  ’#pragma  include’
              behaves exactly the same except that when you try to compile the
              source code by a compiler ’#include’ will cause an error.
              For example,
                  // Interpreted source file
                  #include "func1.dl"
                  #pragma include "func1.dl"
                  main() {
                       .
                  }
              Operation of the dynamic link library  function/global/stub  are
              identical to that of archived version.  Option ’-o’ and ’-m’ can
              not be used with ’-dl’.  Installation and all makecint  activity
              must be done under same OS and compiler environment.

       -mk MKFILE
              Create interface routine and makefile, no compilation.
              The  ’-mk  MKFILE’ option will specify name of created makefile.
              For example
                  $ makecint -mk make.prog1 -o prog1 -H prog1.h -C++ prog1.C
                  $ make -f make.prog1
                  $ prog1

       -p     Use preprocessor  before  parsing  parameter  information  files
              (OLD)
              If  ’-p’  option  is  added,  parameter  information  files  are
              preprocessed by real preprocessor. Cint does  not  parse  define
              macro  perfectly.  It  is  recommended to use -p option when you
              link non-trivial library with heavy define macro usage.  Name of
              C/C++ preprocessor must be set in the $CINTSYSDIR/MAKEINFO file.
                   $ makecint -mk Makeit -p -o mycint -H prog.h -C++ prog.C
                   $ make -f Makeit
              This option is being obsoleted. Use +P,-P instead.

       -m     Needed if main() is included in the source file.
              If main() function is included in the precompiled  object,  ’-m’
              option  must  be  given.  This  option  avoids linking Cint main
              function.  You need to  call  G__init_cint()  and  G__calc()  to
              start  C/C++  interpreter  from your host program.  (See example
              below) Header file $CINTSYSDIR/G__ci.h has to be included.
              /* Example host program host.c
              * $ makecint -mk Makefile -o host -m -I$CINTSYSDIR -h host.h -C host.c
              * $ make
              */
              #include <G__ci.h>
              #include "host.h"   /* host.h can be an empty file */
              main() {
                int state;
                char command[100], macrofile[100], *p;
                state=G__init_cint("cint");
                while(0==state) {
                  strcpy(macrofile,G__input("Input macro file >"));
                  if(strcmp(macrofile,"exit")==0) break;
                  if(0==G__loadfile(macrofile)) {
                    strcpy(command,macrofile);
                    p = strchr(command,’.’);
                    if(p) {
                      strcpy(p,"()");
                      G__calc(command);
                    }
                    G__unloadfile(macrofile);
                  }
                }
                G__scratch_all();
              }

              int G__init_cint(char* command)
              This function will  initialize  Cint.  main()  is  automatically
              executed  if it exists and returns 1.  If main() is not found it
              returns 0.  It returns -1 if initialization fails.
                  int state;
                  state=G__init_cint("cint source.c");
                  // 0==state : initialized but no main()
                  // 1==state : initialized and main() called
                  // -1==state: initialization failed
              After the initialization you can use following functions.

              G__value G__calc(char* expression)
              This function evaluates C/C++ expression  as  string.   Returned
              value is in the form of generic object G__value. G__value can be
              translated to long or double value by ’int G__int(G__value val)’
              or ’double G__double(G__value val)’ functions. For example,
                  // double f(int a) and void g(void) in source.c
                  double d;
                  G__init_cint("cint source.c");
                  G__calc("g()");
                  d=G__double(G__calc("f(1234)"));
                  G__scratch_all();

              long G__int(G__value buf)
              This  function converts G__value object to a long int value.

              double G__double(G__value buf)
              This  function converts G__value object  to  a  double precision
              float value.

              int G__loadfile(char* filename)
              This  function  loads  C/C++  source  code   or   Dynamic   Link
              Library(DLL).  If  suffix of the filename is .dl, .sl, .so, .dll
              or .DLL, the file is linked  as  DLL.  Otherwise,  C/C++  source
              file.  It returns 0 if the file is successfully loaded, 1 if the
              file is already loaded and -1 if the file can not be loaded.  In
              case of fatal error, it returns -2.
                  G__init_cint("cint");
                  G__loadfile("src1.C");
                  G__loadfile("myLib.dl");
                  G__loadfile("src2.c");
                  G__calc("f()");

              int G__unloadfile(char* filename)
              This   function  unloads  C/C++  source  code  or  Dynamic  Link
              Library(DLL). In order to keep consistency, all the files loaded
              after the specified file will be unloaded. It returns 0 if files
              are successfully unloaded, -1 if not.  It first checks if any of
              the function defined in the unloading files are busy.
                  G__init_cint("cint src0.c");
                  G__loadfile("src1.C");
                  G__loadfile("myLib.dl");
                  G__loadfile("src2.c");
                  G__loadfile("src3.C");
                  ....
                  G__unloadfile("src2.c"); // unload src2.c and src3.C
                  ....
                  G__loadfile("src4.C");
                  ....
                  G__unloadfile("src4.C"); // unload src4.C
                  ....
                  G__unloadfile("src0.c"); // unload all files

              int G__pause(void)
              This  function  starts  debugger interface. It returns 0 except
              ’i’(ignore)  or  ’q’(quit)  command  is  used.  You  can   start
              interactive interface as follows.
                  G__init_cint("cint source.c");
                  while(G__pause()==0); // pause until ’i’ command
                  G__scratch_all();

              char* G__input(char* prompt)
              This  function  is  a  command  line  input  frontend  function.
              Although  this  is  not  an  essential  function  to  the  C/C++
              interpreter,  this  is often convenient because readline history
              and command  line  editing  capability  is  built-in  using  GNU
              readline  library.   This function returns a pointer to a static
              string buffer.
                  char *buf[100];
                  G__init_cint("cint");
                  strcpy(buf,G__input("Input your command >");
                  G__calc(buf);

              void G__scratch_all(void)
              This function terminates interpreter. All the files are unloaded
              and environment is reset.

       -D MACRO
              Define macro
              This   option   defines  macro  for  global  variable  parameter
              information file.  Global variable parameter informa- tion  file
              will be conditionally parsed with ’#ifdef MACRO’ statement.  You
              can not put multiple macro names after ’-D’. ’-D’ must be  given
              before  every individual macro name.  Space between -D and macro
              name is not significant.  You can either  go  ’-DMACRO’  or  ’-D
              MACRO’.
                  $ makecint -mk Makeit -DONLINE -o mycint -H source.h -C++ source.C
                  $ make -f Makeit

       -I INCLDPATH
              Include file search path
              You  can  not  put multiple path after ’-I’.  ’-I’ must be given
              before every individual  include  path.  Space  between  -I  and
              pathname  is not significant.  You can either go ’-Ipath’ or ’-I
              path’.
                  $ makecint -mk Makeit -I/users/include -I/include -H src.h -C++ src.C
                  $ make -f Makeit

       -H SUTPI.h
              C++ header as parameter information file.
              With  the  ’-H’  option,  SUTPI.h  file  is  used  as  parameter
              information  file  for  the  encapsulated  C++ object. Cint will
              analyze  the  header  file  and  create  interface   method   in
              G__cpp_[XXX].C.  Multiple header files can be given after single
              ’-H’  option.   Class,  struct,  union,  enum,   public   member
              functions  and  data  members,  non-static  global  function and
              variables, typedefs and macros in  precompiled  library  can  be
              used from interpreter.
                  $ makecint -mk Mkit -o mycint -H src1.h src2.h -C++ src1.C src2.C
                  $ make -f Mkit
              SUTPI.h  file  must  be  compliant  to  cint syntax limi tations
              described in /usr/share/doc/cint/limitati.txt.  If SUTPI.h  uses
              C++  language  constructs  which  is not supported by cint, that
              part must be excluded  by  "#ifndef  __MAKECINT__"  or  "#ifndef
              __CINT__".  The  macro  __CINT__  is  defined  both for cint and
              makecint and __MAKECINT__ is defined only for makecint.
                  class A {
                      // supported feature
                  #ifndef __MAKECINT__
                      // unsupported feature
                  #endif
                  };

       -h SUTPI.h
              C header as parameter information file.
              With ’-h’ option, SUTPU.h file is used as parameter  information
              file  for the encapsulated C object.  Cint will analyze the file
              and create interface method  in  G__c_[XXX].c.  Multiple  header
              files  can be given after one ’-h’.  Header file must be written
              in  ANSI-C  format.   K&R  style   header   is   not   accepted.
              struct,union,enum,  non-static  global  function  and variables,
              typedefs and macros in precompiled  library  can  be  used  from
              interpreter.
                  $ makecint -mk Makeit -A -o mycint -h csrc1.h csrc2.h -C csrc1.c csrc2.c
                  $ make -f Makeit
              SUTPI.h  file  must  be  compliant  to  cint  syntax limitations
              described /usr/share/doc/cint/limitati.txt.  If SUTPI.h uses C++
              language  constructs  which  is not supported by cint, that part
              must  be  excluded  by  "#ifndef   __MAKECINT__"   or   "#ifndef
              __CINT__".  The  macro  __CINT__  is  defined  both for cint and
              makecint and __MAKECINT__ is defined only for makecint.

       +P, -P Turn preprocessor mode for following header files on/off
              The +P and -P are suboptions of  -h  ,  -H  option  which  turns
              on/off  preprocessor  option on file by file basis.  Files after
              +P  will  be  preprocessed  and  files   after   -P   won’t   be
              preprocessed.  You can selectively use preprocessor in following
              manner. In this example, only C.h and D.h , which  are  enclosed
              by +P/-P , will be preprocessed by real C/C++ preprocessor.  You
              must not use -p option when you use  +P/-P  option.   +P  option
              must  always  come before -P , however, -P can be omitted if all
              files  after  +P  are  preprocessed.  The  name  of  the   C/C++
              preprocessor must be set in the $CINTSYSDIR/MAKEINFO file.
                  $ makecint -mk Makeit -o mycint -H A.h B.h +P C.h D.h -P E.h F.h -C++ all.C
                  $ make -f Makeit

       +V, -V Turn class title loading for following header files on/off
              The  +V  and  -V  are  suboptions for -h , -H option which turns
              on/off loading class title by file basis. Class  title  will  be
              loaded  for the files after +V.  Class title won’t be loaded for
              the files after -V.
                  $ makecint -mk Makeit -o mycint -H A.h B.h +V C.h D.h -V E.h F.h -C++ all.C
                  $ make -f Makeit
              Class title has to be described in class/struct defi- nition  in
              header  file  as  follows.   Basically, ’//’ style comment right
              after each member declaration will be  loaded  as  class  member
              comment.
                  class ABC {
                     int a;         // title of the member variable
                     double b;      // title of the member variable
                     int c();       // title of the member function
                     ClassDef(ABC)  // title of the class
                  } ;

       -C++ SUT.C
              Link  C++ source code or object. Not accessed unless -H SUT.h is
              given.
              With the ’-C++’ option, [sut].C file is  used  as  body  of  C++
              compiled object.
              If  appropriate  header  file  is  given  by  ’-H’ option, those
              compiled object can be accessed from the interpreter.  At  least
              one  header  file  must  be  given  by -H option when using -C++
              option.  Otherwise, makecint fails.  Multiple source  files  can
              be given after one  ’-C++’.  Suffix of the C++ source files must
              be  properly set in the $CINTSYSDIR/MAKEINFO file.

       -C SUT.c
              Link C source code or object. Not accessed unless  -h  SUT.h  is
              given.
              With  the  ’-C’ option, SUT.c file is used as body of C compiled
              object.  If the appropriate header file is given by ’-h’ option,
              those  compiled objects can be accessed from the interpreter. At
              least one header file must be given by -h option when  using  -C
              option.   Multiple  source  files  can  be given after one ’-C’.
              Suffix of the C  source  files  must  be  properly  set  in  the
              $CINTSYSDIR/MAKEINFO file.

       -i++ STUB.h
              C++ STUB function parameter information file.
              -i++ option does opposite of -H option.  While -H option enables
              access of  precompiled  object  from  interpreter,  -i++  option
              enables access of interpreted functions from compiled code.
              #### Example is in /usr/share/doc/cint/demo/makecint/Stub directory
              $ makecint -mk Makefile -o mycint -H Src.h -i++ Stub.h -C++ Src.C
              $ make -f Makefile
              $ mycint Stub.C
              STUB.h  file  must  be  compliant  to  cint  syntax  limitations
              described in /usr/share/doc/cint/limitatitxt.   Only  non-static
              global  functions  can be specified in STUB.h file.  Behavior of
              class,  struct,  union,  enum  and  non-static  global  variable
              defined in STUB.h is undefined.

       -i STUB.h
              C STUB function parameter information file.
              The  -i  option  does  the  opposite  of the -h option. While -h
              enables  access  of  precompiled  object  from  interpreter,  -i
              enables access of interpreted functions from compiled code.
              $ makecint -mk Makefile -o mycint -h Src.h -i Stub.h -C Src.c
              $ make -f Makefile
              $ mycint Stub.c
              STUB.h  file  must  be  compliant  to  cint  syntax  limitations
              described in  man  page  file  /usr/share/doc/cint/limitati.txt.
              Only  non-static  global  functions  can  be specified in STUB.h
              file. Behavior of struct,  union,  enum  and  non-static  global
              variable defined in STUB.h is undefined.

       -c SUT.c
              Same as ’-h [sut].c -C [sut].c’

       -l -lLIB
              Compiled object, Library or linker options

       -u UNDEFFILE
              Handle undefined typename as class name.
              Fighting againt undefined typename is a tidious work, especially
              when you do not need public access to those.  -u option  ignores
              such  symbols and generates dummy code to eliminate this kind of
              problem. It handles unknown typename as a class  name  which  is
              not  exposed.  -u  option takes output file name as an argument.
              All of the undefined typenames will be written out.
                  $ makecint -mk Makeit -u undef.h -H src.h -C++ src.C
                  $ make -mk Makeit
              This option is not perfect. If you find problem, you need to fix
              it manually.

       -U DIR Directory to disable interface method generation.
              If  you  give this option, cint/makecint will disable dictionary
              generation for header files exist  under  given  directory.  For
              example,
                  $ makecint -mk makefile -dl src.dll -I/x/inc -U/x/inc -H src.h
                  $ make -f makefile
                  $ cint src.dll
              Suppose  you  have /x/inc/mylib.h and it is included from src.h,
              things defined in /x/inc/mylib.h can not be  accessed  from  the
              interpreter.

       -Y [0|1]
              Ignore std namespace (default=1:ignore)

       -Z [0|1]
              Automatic loading of standard header files
              If  you  give this option, cint/makecint will automatically load
              standard header files used in header file given by -h/-H option.
              Default  is  off(0).  -Z1  must be given to makecint when making
              dictinoary. For example,
                  // src.h
                  #include <string>     // this will trigger implicit loading
                  class myclass { .. };

                  $ makecint -mk makefile -dl src.dll -Z1 -H src.h
                  $ make -f makefile
                  $ cint src.dll
                  cint> .file
                  0: myheader.dll      // explicitly loaded
                  1: string            // loaded implicitly by shared library
                  2: string.dll        //      "
                  3: bool.h            //      "

       -cc OPT
              Compiler option

       -cint OPT
              Cint option
              This option specifies command line  option  directly  gieven  to
              cint. Multiple cint options can be given after -cint.  There are
              a few important cint options which I will describe below.

       -cint -M NEWDELMASK
              Mask operator new/delete generation
              Caution: 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.  -M option turns
              off automatic creation of operator new/delete in the  dictionary
              source code. Mask flag is given as hex number described below.

                #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.  This  scmeme  is
              still   experimmental.   In  the  new  method,  following  flags
              dominates others.  This  scheme  is  intended  to  fix  problems
              associated  with  global  operator  new/delete.  Before 5.14.59,
              -M0x1c or -M0x10 was needed for HP-UX aCC, Solaris CC5  and  few
              other  compilers.  From  5.14.60,  this option is not needed for
              those platforms any more.

                #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);
              Default  value is -M0x100 for pure CINT and -M0x1c for ROOTCINT.
                  $ makecint -mk Makeit -H src.h -C++ src.C -cint -M0x1c
                  $ make -mk Makeit
              If you have one argument operator new in your source code,  your
              operator new should look like below.
                  #define G__PVOID (-1)
                  extern "C" long G__getgvp();
                  void* operator new(size_t size) {
                    if(G__PVOID!=G__getgvp()) return((void*)G__getgvp());
                    // Yourown things...
                  }
              If  you have two argument operator new in your source code, your
              operator new should look like below.
                  #define G__PVOID (-1)
                  extern "C" long G__getgvp();
                  void* operator new(size_t size,void* p) {
                    if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return(p);
                    // Yourown things...
                  }
              If you have operator delete in your source code,  your  operator
              delete should look like below.
                  #define G__PVOID (-1)
                  extern "C" long G__getgvp();
                  void operator delete(void *p) {
                      if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return;
                      // Yourown things...
                  }

       -cint -Z [0|1]
              Automatic loading of standard header files
              If  you  give this option, cint/makecint will automatically load
              standard header files used in header file given by -h/-H option.
              Default  is  off(0).  -Z1  must be given to makecint when making
              dictinoary. For example,
                  // src.h
                  #include <string>     // this will trigger implicit loading
                  class myclass { .. };

                  $ makecint -mk makefile -dl src.dll -H src.h -cint -Z1
                  $ make -f makefile
                  $ cint src.dll
                  cint> .file
                  0: myheader.dll      // explicitly loaded
                  1: string            // loaded implicitly by shared library
                  2: string.dll        //      "
                  3: bool.h            //      "

       -B FUNCNAME
              Initialization function name

SEE ALSO

       cint(1),
       The  programs   are   documented   fully   in   various   files   under
       /usr/share/doc/cint/.

AUTHOR

       Masaharu Goto <MXJ02154@niftyserve.or.jp>
       Copyright © 1995-2000 Masaharu Goto
       This  manual  page  was  compiled  from  information in the Cint source
       package for the Debian GNU/Linux system (but may be used by others).

                               February  3, 2001                   MAKECINT(1)