.\"                                      Hey, EMACS: -*- nroff -*-
.\" First parameter, NAME, should be all caps
.\" Second parameter, 1, should be 1-8, maybe w/ subsection
.\" other parameters are allowed: see man(7), man(1)
.TH MAKECINT 1 "February  3, 2001"
.\" Please adjust this date whenever revising the manpage.
.\"
.\" Some roff macros, for reference:
.\" .nh        disable hyphenation
.\" .hy        enable hyphenation
.\" .ad l      left justify
.\" .ad b      justify to both left and right margins
.\" .nf        disable filling
.\" .fi        enable filling
.\" .br        insert line break
.\" .sp <n>    insert n+1 empty lines
.\" for manpage-specific macros, see man(7)
.SH NAME
makecint \- C/C++ interpreter-compiler
.SH SYNOPSIS
.B 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++ ]
.SH DESCRIPTION
.B 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).
.br
(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.)
.br
.SH OUTLINE OF MAKING A PRECOMPILED LIBRARY
Generic  outline of making a precompiled library  will be
described in this section.

.br
.B Files
.br
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.

.br
.B Procedure
.br
1) Create a Makefile
.br
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.
.nf

     $ makecint \-mk Makefile\-o mycint \-H xxx.h yyy.h \-C++ xxx.C yyy.o

.fi
Command line options will be explained later in this document.

.br
2) Modify Makefile (if needed)
.br
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.

.br
3) Do make
.br
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.
.nf
     $ make
.fi
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.

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

.SH WHAT CAN BE DONE WITH THE PRECOMPILED LIBRARY
.B Non static global variable and function
.br
Non static global variables and functions can be accessed from the
interpreter.

.br
.B Class members
.br
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')

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

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

.br
.B Inheritance, Class object as member
.br
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.

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

.SH 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'.
.TP
.B \-o OBJ
specify object name (customized C/C++ interpreter).
.br
\-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,
.nf
    $ makecint \-mk Makefile \-o mycint \-H prog.h \-C++ prog.C
    $ make
.fi
Will make customized cint "mycint" including prog.C user specific
library.
.TP
.B \-dl DYNLIB
Generate dynamic link library object.
.br
This option generates dynamic link library(DLL) which can be
dynamically linked with cint at run time.  For example,
.nf
    $ makecint \-mk Makefile \-dl func.dl \-H func1.h func2.h \-C++ func1.C func2.C
    $ make
.fi
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.
.nf
    $ cint func.dl othersource.c
    $ cint func1.dl func2.dl othersource.c
.fi
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.
.br
For example,
.nf
    // Interpreted source file
    #include "func1.dl"
    #pragma include "func1.dl"
    main() {
         .
    }
.fi
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.
.TP
.B \-mk MKFILE
Create interface routine and makefile, no compilation.
.br
The '-mk MKFILE' option will specify name of created makefile.  For
example
.nf
    $ makecint \-mk make.prog1 \-o prog1 \-H prog1.h \-C++ prog1.C
    $ make \-f make.prog1
    $ prog1
.fi
.TP
.B \-p
Use preprocessor before parsing parameter information files (OLD)
.br
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.
.nf
     $ makecint \-mk Makeit \-p \-o mycint \-H prog.h \-C++ prog.C
     $ make \-f Makeit
.fi
This option is being obsoleted. Use +P,-P instead.
.TP
.B \-m
Needed if main() is included in the source file.
.br
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.
.nf
/* 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();
}
.fi
.BR
.nf
int G__init_cint(char* command)
.fi
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.
.nf
    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
.fi
After the initialization you can use following functions.
.nf

G__value G__calc(char* expression)
.fi
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,
.nf
    // 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();
.fi
.nf

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

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

int G__loadfile(char* filename)
.fi
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.
.nf
    G__init_cint("cint");
    G__loadfile("src1.C");
    G__loadfile("myLib.dl");
    G__loadfile("src2.c");
    G__calc("f()");
.fi
.nf

int G__unloadfile(char* filename)
.fi
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.
.nf
    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
.fi
.nf

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

char* G__input(char* prompt)
.fi
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.
.nf
    char *buf[100];
    G__init_cint("cint");
    strcpy(buf,G__input("Input your command >");
    G__calc(buf);
.fi
.nf

void G__scratch_all(void)
.fi
This function terminates interpreter. All the files are unloaded and
environment is reset.
.TP
.B \-D MACRO
Define macro
.br
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'.
.nf
    $ makecint \-mk Makeit \-DONLINE \-o mycint \-H source.h \-C++ source.C
    $ make \-f Makeit
.fi
.TP
.B \-I INCLDPATH
Include file search path
.br
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'.
.nf
    $ makecint \-mk Makeit \-I/users/include \-I/include \-H src.h \-C++ src.C
    $ make \-f Makeit
.fi
.TP
.B \-H SUTPI.h
C++ header as parameter information file.
.br
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.
.nf
    $ makecint \-mk Mkit \-o mycint \-H src1.h src2.h \-C++ src1.C src2.C
    $ make \-f Mkit
.fi
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.
.nf
    class A {
        // supported feature
    #ifndef __MAKECINT__
        // unsupported feature
    #endif
    };
.fi
.TP
.B \-h SUTPI.h
C header as parameter information file.
.br
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.
.nf
    $ makecint \-mk Makeit \-A \-o mycint \-h csrc1.h csrc2.h \-C csrc1.c csrc2.c
    $ make \-f Makeit
.fi
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.
.TP
.B \+P, \-P
Turn preprocessor mode for following header files on/off
.br
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.
.nf
    $ 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
.fi
.TP
.B \+V, \-V
Turn class title loading for following header files on/off
.br
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.
.nf
    $ 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
.fi
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.
.nf
    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
    } ;
.fi
.TP
.B \-C++ SUT.C
Link C++ source code or object. Not accessed unless \-H SUT.h is given.
.br
With the '-C++' option, [sut].C file is used as body of C++ compiled
object.
.br
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.
.TP
.B \-C SUT.c
Link C source code or object. Not accessed unless \-h SUT.h is given.
.br
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.
.TP
.B \-i++ STUB.h
C++ STUB function parameter information file.
.br
-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.
.nf
#### 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
.fi
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.
.TP
.B \-i STUB.h
C STUB function parameter information file.
.br
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.
.nf
$ makecint \-mk Makefile \-o mycint \-h Src.h \-i Stub.h \-C Src.c
$ make \-f Makefile
$ mycint Stub.c
.fi
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.
.TP
.B \-c SUT.c
Same as '-h [sut].c \-C [sut].c'
.TP
.B \-l \-lLIB
Compiled object, Library or linker options
.TP
.B \-u UNDEFFILE
Handle undefined typename as class name.
.br
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.
.nf
    $ makecint \-mk Makeit \-u undef.h \-H src.h \-C++ src.C
    $ make \-mk Makeit
.fi
This option is not perfect. If you find problem, you need to fix it
manually.
.TP
.B \-U DIR
Directory to disable interface method generation.
.br
If you give this option, cint/makecint will disable dictionary
generation for header files exist under given directory. For
example,
.nf
    $ makecint \-mk makefile \-dl src.dll \-I/x/inc \-U/x/inc \-H src.h
    $ make \-f makefile
    $ cint src.dll
.fi
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.
.TP
.B \-Y [0|1]
Ignore std namespace (default=1:ignore)
.TP
.B \-Z [0|1]
Automatic loading of standard header files
.br
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,
.nf
    // 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            //      "
.fi
.TP
.B \-cc OPT
Compiler option
.TP
.B \-cint OPT
Cint option
.br
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.
.TP
.B \-cint \-M NEWDELMASK
Mask operator new/delete generation
.br
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.
.nf

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

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

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

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

  #define G__NOT_USING_2ARG_NEW   0x10
.fi
Cint uses operator new function with 1 argument in dictionary source
code.
.br
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.
.nf

  #define G__DUMMYARG_NEWDELETE        0x100
.fi
If this flag is set, a new operator new/delete scheme is turned
on. With this scheme, cint dictionary generates following functions.
.nf
    void* operator new(size_t size,[DLLID]_tag* p);
    void operator delete(void *p,[DLLID]_tag* x);
    static void G__operator_delete(void *p);
.fi
.nf

  #define G__DUMMYARG_NEWDELETE_STATIC 0x200
.fi
This flag makes operator new a static function. So,
following functions will be generated.
.nf
    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);
.fi
Default value is \-M0x100 for pure CINT and \-M0x1c for ROOTCINT.
.nf
    $ makecint \-mk Makeit \-H src.h \-C++ src.C \-cint \-M0x1c
    $ make \-mk Makeit
.fi
If you have one argument operator new in your source code, your
operator new should look like below.
.nf
    #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...
    }
.fi
If you have two argument operator new in your source code, your
operator new should look like below.
.nf
    #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...
    }
.fi
If you have operator delete in your source code, your operator
delete should look like below.
.nf
    #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...
    }
.fi
.TP
.B \-cint  \-Z [0|1]
Automatic loading of standard header files
.br
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,
.nf
    // 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            //      "
.fi
.TP
.B \-B FUNCNAME
Initialization function name
.PP


.SH SEE ALSO
.BR cint (1),
.br
The programs are documented fully in various files under
/usr/share/doc/cint/.
.SH AUTHOR
Masaharu Goto <MXJ02154@niftyserve.or.jp>
.br
Copyright \(co 1995-2000 Masaharu Goto
.br
This manual page was compiled from information in the Cint source
package for the Debian GNU/Linux system (but may be used by others).