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)