| @\input texinfo @c -*-texinfo-*- |
| @setfilename gcj.info |
| @settitle Guide to GNU gcj |
| |
| @c Note: When reading this manual you'll find lots of strange |
| @c circumlocutions like ``compiler for the Java language''. |
| @c This is necessary due to Sun's restrictions on the use of |
| @c the word ``Java'. |
| |
| @c When this manual is copyrighted. |
| @set copyrights-gcj 2001 |
| |
| @c Versions |
| @set version-gcc 3.1 |
| @set which-gcj GCC-@value{version-gcc} |
| |
| @macro gcctabopt{body} |
| @code{\body\} |
| @end macro |
| |
| @ifinfo |
| @format |
| @dircategory Programming |
| @direntry |
| * Gcj: (gcj). Ahead-of-time compiler for the Java language |
| @end direntry |
| |
| @dircategory Individual utilities |
| @direntry |
| * gcjh: (gcj)Invoking gcjh. |
| Generate header files from Java class files |
| * jv-scan: (gcj)Invoking jv-scan. |
| Print information about Java source files |
| * jcf-dump: (gcj)Invoking jcf-dump. |
| Print information about Java class files |
| * gij: (gcj)Invoking gij. GNU interpreter for Java bytecode |
| @end direntry |
| @end format |
| |
| @c man begin COPYRIGHT |
| Copyright (C) @value{copyrights-gcj} Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.1 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being ``GNU General Public License'', the Front-Cover |
| texts being (a) (see below), and with the Back-Cover Texts being (b) |
| (see below). A copy of the license is included in the |
| @c man end |
| section entitled |
| ``GNU Free Documentation License''. |
| @ignore |
| @c man begin COPYRIGHT |
| man page gfdl(7). |
| @c man end |
| @end ignore |
| |
| (a) The FSF's Front-Cover Text is: |
| |
| A GNU Manual |
| |
| (b) The FSF's Back-Cover Text is: |
| |
| You have freedom to copy and modify this GNU Manual, like GNU |
| software. Copies published by the Free Software Foundation raise |
| funds for GNU development. |
| @end ifinfo |
| |
| @titlepage |
| @title GNU gcj |
| @author Tom Tromey |
| |
| @page |
| @vskip 0pt plus 1filll |
| Copyright @copyright{} @value{copyrights-gcj} Free Software Foundation, Inc. |
| @sp 2 |
| For the @value{which-gcj} Version* |
| @sp 1 |
| Published by the Free Software Foundation @* |
| 59 Temple Place - Suite 330@* |
| Boston, MA 02111-1307, USA@* |
| @sp 1 |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.1 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being ``GNU General Public License'', the Front-Cover |
| texts being (a) (see below), and with the Back-Cover Texts being (b) |
| (see below). A copy of the license is included in the section entitled |
| ``GNU Free Documentation License''. |
| |
| (a) The FSF's Front-Cover Text is: |
| |
| A GNU Manual |
| |
| (b) The FSF's Back-Cover Text is: |
| |
| You have freedom to copy and modify this GNU Manual, like GNU |
| software. Copies published by the Free Software Foundation raise |
| funds for GNU development. |
| @end titlepage |
| @contents |
| @page |
| |
| |
| @node Top |
| @top Introduction |
| |
| This manual describes how to use @code{gcj}, the GNU compiler for the |
| Java programming language. @code{gcj} can generate both @file{.class} |
| files and object files, and it can read both Java source code and |
| @file{.class} files. |
| |
| @menu |
| * Copying:: The GNU General Public License |
| * GNU Free Documentation License:: |
| How you can share and copy this manual |
| * Invoking gcj:: Compiler options supported by @code{gcj} |
| * Compatibility:: Compatibility between gcj and other tools for Java |
| * Invoking gcjh:: Generate header files from class files |
| * Invoking jv-scan:: Print information about source files |
| * Invoking jcf-dump:: Print information about class files |
| * Invoking gij:: Interpreting Java bytecodes |
| * Resources:: Where to look for more information |
| @end menu |
| |
| |
| @include gpl.texi |
| |
| @include fdl.texi |
| |
| |
| @node Invoking gcj |
| @chapter Invoking gcj |
| |
| @c man title gcj Ahead-of-time compiler for the Java language |
| |
| @ignore |
| @c man begin SYNOPSIS gcj |
| gcj [@option{-I}@var{dir}@dots{}] [@option{-d}@var{dir}@dots{}] |
| [@option{--classpath}=@var{path}] [@option{--CLASSPATH}=@var{path}] |
| [@option{-f}@var{option}@dots{}] [@option{--encoding}=@var{name}] |
| [@option{--main}=@var{classname}] [@option{-D}@var{name}[=@var{value}]@dots{}] |
| [@option{-C}] [@option{-R} @var{resource-name}] [@option{-d} @var{directory}] |
| [@option{-W}@var{warn}@dots{}] |
| @var{sourcefile}@dots{} |
| @c man end |
| @c man begin SEEALSO gcj |
| gcc(1), gcjh(1), gij(1), jv-scan(1), jcf-dump(1), gfdl(7), |
| and the Info entries for @file{gcj} and @file{gcc}. |
| @c man end |
| @end ignore |
| |
| @c man begin DESCRIPTION gcj |
| |
| As @code{gcj} is just another front end to @code{gcc}, it supports many |
| of the same options as gcc. @xref{Option Summary, , Option Summary, |
| gcc, Using the GNU Compiler Collection (GCC)}. This manual only documents the |
| options specific to @code{gcj}. |
| |
| @c man end |
| |
| @menu |
| * Input and output files:: |
| * Input Options:: How gcj finds files |
| * Encodings:: Options controlling source file encoding |
| * Warnings:: Options controlling warnings specific to gcj |
| * Code Generation:: Options controlling the output of gcj |
| * Configure-time Options:: Options you won't use |
| @end menu |
| |
| @c man begin OPTIONS gcj |
| |
| @node Input and output files |
| @section Input and output files |
| |
| A @code{gcj} command is like a @code{gcc} command, in that it |
| consists of a number of options and file names. The following kinds |
| of input file names are supported: |
| |
| @table @gcctabopt |
| @item @var{file}.java |
| Java source files. |
| @item @var{file}.class |
| Java bytecode files. |
| @item @var{file}.zip |
| @itemx @var{file}.jar |
| An archive containing one or more @code{.class} files, all of |
| which are compiled. The archive may be compressed. |
| @item @@@var{file} |
| A file containing a whitespace-separated list of input file names. |
| (Currently, these must all be @code{.java} source files, but that |
| may change.) |
| Each named file is compiled, just as if it had been on the command line. |
| @item @var{library}.a |
| @itemx @var{library}.so |
| @itemx -l@var{libname} |
| Libraries to use when linking. See the @code{gcc} manual. |
| @end table |
| |
| You can specify more than one input file on the @code{gcj} command line, |
| in which case they will all be compiled. If you specify a |
| @code{-o @var{FILENAME}} |
| option, all the input files will be compiled together, producing a |
| single output file, named @var{FILENAME}. |
| This is allowed even when using @code{-S} or @code{-c}, |
| but not when using @code{-C} or @code{-R}. |
| (This is an extension beyond the what plain @code{gcc} allows.) |
| (If more than one input file is specified, all must currently |
| be @code{.java} files, though we hope to fix this.) |
| |
| @node Input Options |
| @section Input Options |
| |
| @cindex class path |
| |
| @code{gcj} has options to control where it looks to find files it needs. |
| For instance, @code{gcj} might need to load a class that is referenced |
| by the file it has been asked to compile. Like other compilers for the |
| Java language, @code{gcj} has a notion of a @dfn{class path}. There are |
| several options and environment variables which can be used to |
| manipulate the class path. When @code{gcj} looks for a given class, it |
| searches the class path looking for matching @file{.class} or |
| @file{.java} file. @code{gcj} comes with a built-in class path which |
| points at the installed @file{libgcj.jar}, a file which contains all the |
| standard classes. |
| |
| In the below, a directory or path component can refer either to an |
| actual directory on the filesystem, or to a @file{.zip} or @file{.jar} |
| file, which @code{gcj} will search as if it is a directory. |
| |
| @table @gcctabopt |
| @item -I@var{dir} |
| All directories specified by @code{-I} are kept in order and prepended |
| to the class path constructed from all the other options. Unless |
| compatibility with tools like @code{javac} is imported, we recommend |
| always using @code{-I} instead of the other options for manipulating the |
| class path. |
| |
| @item --classpath=@var{path} |
| This sets the class path to @var{path}, a colon-separated list of paths |
| (on Windows-based systems, a semicolon-separate list of paths). |
| |
| @item --CLASSPATH=@var{path} |
| This sets the class path to @var{path}, a colon-separated list of paths |
| (on Windows-based systems, a semicolon-separate list of paths). This |
| differs from the @code{--classpath} option in that it also suppresses |
| the built-in system path. |
| |
| @item CLASSPATH |
| This is an environment variable which holds a list of paths. |
| @end table |
| |
| The final class path is constructed like so: |
| |
| @itemize @bullet |
| @item |
| First come all directories specified via @code{-I}. |
| |
| @item |
| If @code{--classpath} is specified, its value is appended and processing |
| stops. That is, @code{--classpath} suppresses all the options mentioned |
| later in this list. |
| |
| @item |
| If @code{--CLASSPATH} is specified, its value is appended and the |
| @code{CLASSPATH} environment variable is suppressed. |
| |
| @item |
| If the @code{CLASSPATH} environment variable is specified (and was not |
| suppressed by @code{--CLASSPATH}), then its value is appended. |
| |
| @item |
| Finally, the built-in system directory, @file{libgcj.jar}, is appended. |
| @end itemize |
| |
| The classfile built by @code{gcj} for the class @code{java.lang.Object} |
| (and placed in @code{libgcj.jar}) contains a special zero length |
| attribute @code{gnu.gcj.gcj-compiled}. The compiler looks for this |
| attribute when loading @code{java.lang.Object} and will report an error |
| if it isn't found, unless it compiles to bytecode (the option |
| @code{-fforce-classes-archive-check} can be used to override this |
| behavior in this particular case.) |
| |
| @table @gcctabopt |
| @item -fforce-classes-archive-check |
| This forces the compiler to always check for the special zero length |
| attribute @code{gnu.gcj.gcj-compiled} in @code{java.lang.Object} and |
| issue an error if it isn't found. |
| @end table |
| |
| @node Encodings |
| @section Encodings |
| |
| The Java programming language uses Unicode throughout. In an effort to |
| integrate well with other locales, @code{gcj} allows @file{.java} files |
| to be written using almost any encoding. @code{gcj} knows how to |
| convert these encodings into its internal encoding at compile time. |
| |
| You can use the @code{--encoding=@var{NAME}} option to specify an |
| encoding (of a particular character set) to use for source files. If |
| this is not specified, the default encoding comes from your current |
| locale. If your host system has insufficient locale support, then |
| @code{gcj} assumes the default encoding to be the @samp{UTF-8} encoding |
| of Unicode. |
| |
| To implement @code{--encoding}, @code{gcj} simply uses the host |
| platform's @code{iconv} conversion routine. This means that in practice |
| @code{gcj} is limited by the capabilities of the host platform. |
| |
| The names allowed for the argument @code{--encoding} vary from platform |
| to platform (since they are not standardized anywhere). However, |
| @code{gcj} implements the encoding named @samp{UTF-8} internally, so if |
| you choose to use this for your source files you can be assured that it |
| will work on every host. |
| |
| |
| @node Warnings |
| @section Warnings |
| |
| @code{gcj} implements several warnings. As with other generic |
| @code{gcc} warnings, if an option of the form @code{-Wfoo} enables a |
| warning, then @code{-Wno-foo} will disable it. Here we've chosen to |
| document the form of the warning which will have an effect -- the |
| default being the opposite of what is listed. |
| |
| @table @gcctabopt |
| @item -Wredundant-modifiers |
| With this flag, @code{gcj} will warn about redundant modifiers. For |
| instance, it will warn if an interface method is declared @code{public}. |
| |
| @item -Wextraneous-semicolon |
| This causes @code{gcj} to warn about empty statements. Empty statements |
| have been deprecated. |
| |
| @item -Wno-out-of-date |
| This option will cause @code{gcj} not to warn when a source file is |
| newer than its matching class file. By default @code{gcj} will warn |
| about this. |
| |
| @item -Wunused |
| This is the same as @code{gcc}'s @code{-Wunused}. |
| |
| @item -Wall |
| This is the same as @code{-Wredundant-modifiers -Wextraneous-semicolon |
| -Wunused}. |
| @end table |
| |
| |
| @node Code Generation |
| @section Code Generation |
| |
| In addition to the many @code{gcc} options controlling code generation, |
| @code{gcj} has several options specific to itself. |
| |
| @table @gcctabopt |
| @item --main=@var{CLASSNAME} |
| This option is used when linking to specify the name of the class whose |
| @code{main} method should be invoked when the resulting executable is |
| run. @footnote{The linker by default looks for a global function named |
| @code{main}. Since Java does not have global functions, and a |
| collection of Java classes may have more than one class with a |
| @code{main} method, you need to let the linker know which of those |
| @code{main} methods it should invoke when starting the application.} |
| |
| @item -D@var{name}[=@var{value}] |
| This option can only be used with @code{--main}. It defines a system |
| property named @var{name} with value @var{value}. If @var{value} is not |
| specified then it defaults to the empty string. These system properties |
| are initialized at the program's startup and can be retrieved at runtime |
| using the @code{java.lang.System.getProperty} method. |
| |
| @item -C |
| This option is used to tell @code{gcj} to generate bytecode |
| (@file{.class} files) rather than object code. |
| |
| @item -R @var{resource-name} |
| This option is used to tell @code{gcj} to compile the contents of a |
| given file to object code so it may be accessed at runtime with the core |
| protocol handler as @var{core:/resource-name}. |
| |
| @item -d @var{directory} |
| When used with @code{-C}, this causes all generated @file{.class} files |
| to be put in the appropriate subdirectory of @var{directory}. By |
| default they will be put in subdirectories of the current working |
| directory. |
| |
| @item -fno-bounds-check |
| By default, @code{gcj} generates code which checks the bounds of all |
| array indexing operations. With this option, these checks are omitted. |
| Note that this can result in unpredictable behavior if the code in |
| question actually does violate array bounds constraints. |
| |
| @item -fjni |
| With @code{gcj} there are two options for writing native methods: CNI |
| and JNI. By default @code{gcj} assumes you are using CNI. If you are |
| compiling a class with native methods, and these methods are implemented |
| using JNI, then you must use @code{-fjni}. This option causes |
| @code{gcj} to generate stubs which will invoke the underlying JNI |
| methods. |
| |
| @item -fno-optimize-static-class-initialization |
| When the optimization level is greather or equal to @code{-O2}, |
| @code{gcj} will try to optimize the way calls into the runtime are made |
| to initialize static classes upon their first use (this optimization |
| isn't carried out if @code{-C} was specified.) When compiling to native |
| code, @code{-fno-optimize-static-class-initialization} will turn this |
| optimization off, regardless of the optimization level in use. |
| @end table |
| |
| |
| @node Configure-time Options |
| @section Configure-time Options |
| |
| Some @code{gcj} code generations options affect the resulting ABI, and |
| so can only be meaningfully given when @code{libgcj}, the runtime |
| package, is configured. @code{libgcj} puts the appropriate options from |
| this group into a @samp{spec} file which is read by @code{gcj}. These |
| options are listed here for completeness; if you are using @code{libgcj} |
| then you won't want to touch these options. |
| |
| @table @gcctabopt |
| @item -fuse-boehm-gc |
| This enables the use of the Boehm GC bitmap marking code. In particular |
| this causes @code{gcj} to put an object marking descriptor into each |
| vtable. |
| |
| @item -fhash-synchronization |
| By default, synchronization data (the data used for @code{synchronize}, |
| @code{wait}, and @code{notify}) is pointed to by a word in each object. |
| With this option @code{gcj} assumes that this information is stored in a |
| hash table and not in the object itself. |
| |
| @item -fuse-divide-subroutine |
| On some systems, a library routine is called to perform integer |
| division. This is required to get exception handling correct when |
| dividing by zero. |
| |
| @item -fcheck-references |
| On some systems it's necessary to insert inline checks whenever |
| accessing an object via a reference. On other systems you won't need |
| this because null pointer accesses are caught automatically by the |
| processor. |
| @end table |
| |
| @c man end |
| |
| @node Compatibility |
| @chapter Compatibility with the Java Platform |
| |
| As we believe it is important that the Java platform not be fragmented, |
| @code{gcj} and @code{libgcj} try to conform to the relevant Java |
| specifications. However, limited manpower and incomplete and unclear |
| documentation work against us. So, there are caveats to using |
| @code{gcj}. |
| |
| This list of compatibility issues is by no means complete. |
| |
| @itemize @bullet |
| @item |
| @code{gcj} implements the JDK 1.1 language. It supports inner classes, |
| though these are known to still be buggy. It does not yet support the |
| Java 2 @code{strictfp} keyword (it recognizes the keyword but ignores |
| it). |
| |
| @item |
| @code{libgcj} is largely compatible with the JDK 1.2 libraries. |
| However, @code{libgcj} is missing many packages, most notably |
| @code{java.awt}. There are also individual missing classes and methods. |
| We currently do not have a list showing differences between |
| @code{libgcj} and the Java 2 platform. |
| |
| @item |
| Sometimes the @code{libgcj} implementation of a method or class differs |
| from the JDK implementation. This is not always a bug. Still, if it |
| affects you, it probably makes sense to report it so that we can discuss |
| the appropriate response. |
| @end itemize |
| |
| |
| @node Invoking gcjh |
| @chapter Invoking gcjh |
| |
| @c man title gcjh generate header files from Java class files |
| |
| @c man begin DESCRIPTION gcjh |
| |
| The @code{gcjh} program is used to generate header files from class |
| files. It can generate both CNI and JNI header files, as well as stub |
| implementation files which can be used as a basis for implementing the |
| required native methods. |
| |
| @c man end |
| |
| @ignore |
| @c man begin SYNOPSIS gcjh |
| gcjh [@option{-stubs}] [@option{-jni}] |
| [@option{-add}@var{text}] [@option{-append}@var{text}] [@option{-friend}@var{text}] [@option{-preprend}@var{text}] |
| [@option{--classpath}=@var{path}] [@option{--CLASSPATH}=@var{path}] |
| [@option{-I}@var{dir}@dots{}] [@option{-d}@var{dir}@dots{}] |
| [@option{-o}@var{file}] [@option{-td}@var{dir}] |
| [@option{-M}] [@option{-MM}] [@option{-MD}] [@option{-MMD}] |
| [@option{--version}] [@option{--help}] [@option{-v}] [@option{--verbose}] |
| @var{classname}@dots{} |
| @c man end |
| @c man begin SEEALSO gcjh |
| gcc(1), gcj(1), gij(1), jv-scan(1), jcf-dump(1), gfdl(7), |
| and the Info entries for @file{gcj} and @file{gcc}. |
| @c man end |
| @end ignore |
| |
| @c man begin OPTIONS gcjh |
| |
| @table @gcctabopt |
| @item -stubs |
| This causes @code{gcjh} to generate stub files instead of header files. |
| By default the stub file will be named after the class, with a suffix of |
| @samp{.cc}. In JNI mode, the default output file will have the suffix |
| @samp{.c}. |
| |
| @item -jni |
| This tells @code{gcjh} to generate a JNI header or stub. By default, |
| CNI headers are generated. |
| |
| @item -add @var{text} |
| Inserts @var{text} into the class body. This is ignored in JNI mode. |
| |
| @item -append @var{text} |
| Inserts @var{text} into the header file after the class declaration. |
| This is ignored in JNI mode. |
| |
| @item -friend @var{text} |
| Inserts @var{text} into the class as a @code{friend} declaration. |
| This is ignored in JNI mode. |
| |
| @item -prepend @var{text} |
| Inserts @var{text} into the header file before the class declaration. |
| This is ignored in JNI mode. |
| |
| @item --classpath=@var{path} |
| @itemx --CLASSPATH=@var{path} |
| @itemx -I@var{directory} |
| @itemx -d @var{directory} |
| @itemx -o @var{file} |
| These options are all identical to the corresponding @code{gcj} options. |
| |
| @item -o @var{file} |
| Sets the output file name. This cannot be used if there is more than |
| one class on the command line. |
| |
| @item -td @var{directory} |
| Sets the name of the directory to use for temporary files. |
| |
| @item -M |
| Print all dependencies to stdout; suppress ordinary output. |
| |
| @item -MM |
| Print non-system dependencies to stdout; suppress ordinary output. |
| |
| @item -MD |
| Print all dependencies to stdout. |
| |
| @item -MMD |
| Print non-system dependencies to stdout. |
| |
| @item --help |
| Print help about @code{gcjh} and exit. No further processing is done. |
| |
| @item --version |
| Print version information for @code{gcjh} and exit. No further |
| processing is done. |
| |
| @item -v, --verbose |
| Print extra information while running. |
| @end table |
| |
| All remaining options are considered to be names of classes. |
| |
| @c man end |
| |
| @node Invoking jv-scan |
| @chapter Invoking jv-scan |
| |
| @c man title jv-scan print information about Java source file |
| |
| @c man begin DESCRIPTION jv-scan |
| |
| The @code{jv-scan} program can be used to print information about a Java |
| source file (@file{.java} file). |
| |
| @c man end |
| |
| @ignore |
| @c man begin SYNOPSIS jv-scan |
| jv-scan [@option{--complexity}] [@option{--encoding}@var{name}] |
| [@option{--print-main}] [@option{--list-class}] [@option{--list-filename}] |
| [@option{--version}] [@option{--help}] |
| [@option{-o}@var{file}] @var{inputfile}@dots{} |
| @c man end |
| @c man begin SEEALSO jv-scan |
| gcc(1), gcj(1), gcjh(1), gij(1), jcf-dump(1), gfdl(7), |
| and the Info entries for @file{gcj} and @file{gcc}. |
| @c man end |
| @end ignore |
| |
| @c man begin OPTIONS jv-scan |
| |
| @table @gcctabopt |
| @item --complexity |
| This prints a complexity measure, related to cyclomatic complexity, for |
| each input file. |
| |
| @item --encoding=@var{name} |
| This works like the corresponding @code{gcj} option. |
| |
| @item --print-main |
| This prints the name of the class in this file containing a @code{main} |
| method. |
| |
| @item --list-class |
| This lists the names of all classes defined in the input files. |
| |
| @item --list-filename |
| If @code{--list-class} is given, this option causes @code{jv-scan} to |
| also print the name of the file in which each class was found. |
| |
| @item -o @var{file} |
| Print output to the named file. |
| |
| @item --help |
| Print help, then exit. |
| |
| @item --version |
| Print version number, then exit. |
| @end table |
| |
| @c man end |
| |
| @node Invoking jcf-dump |
| @chapter Invoking jcf-dump |
| |
| @c man title jcf-dump print information about Java class files |
| |
| @ignore |
| @c man begin SYNOPSIS jcf-dump |
| jcf-dump [@option{-c}] [@option{--javap}] |
| [@option{--classpath}=@var{path}] [@option{--CLASSPATH}=@var{path}] |
| [@option{-I}@var{dir}@dots{}] [@option{-o}@var{file}] |
| [@option{--version}] [@option{--help}] [@option{-v}] [@option{--verbose}] |
| @var{classname}@dots{} |
| @c man end |
| @c man begin SEEALSO jcf-dump |
| gcc(1), gcj(1), gcjh(1), gij(1), jcf-dump(1), gfdl(7), |
| and the Info entries for @file{gcj} and @file{gcc}. |
| @c man end |
| @end ignore |
| |
| @c man begin DESCRIPTION jcf-dump |
| |
| This is a class file examiner, similar to @code{javap}. It will print |
| information about a number of classes, which are specifed by class name |
| or file name. |
| |
| @c man end |
| |
| @c man begin OPTIONS jcf-dump |
| |
| @table @gcctabopt |
| @item -c |
| Disassemble method bodies. By default method bodies are not printed. |
| |
| @item --javap |
| Generate output in @code{javap} format. The implementation of this |
| feature is very incomplete. |
| |
| @item --classpath=@var{path} |
| @itemx --CLASSPATH=@var{path} |
| @itemx -I@var{directory} |
| @itemx -o @var{file} |
| These options as the same as the corresponding @code{gcj} options. |
| |
| @item --help |
| Print help, then exit. |
| |
| @item --version |
| Print version number, then exit. |
| |
| @item -v, --verbose |
| Print extra information while running. |
| @end table |
| |
| @c man end |
| |
| @node Invoking gij |
| @chapter Invoking gij |
| |
| @c man title gij GNU interpreter for Java bytecode |
| |
| @ignore |
| @c man begin SYNOPSIS gij |
| gij [@option{OPTION}] @dots{} @var{JARFILE} [@var{ARGS}@dots{}] |
| |
| gij [@option{-jar}] [@option{OPTION}] @dots{} @var{CLASS} [@var{ARGS}@dots{}] |
| |
| [@option{-D}@var{name}[=@var{value}]@dots{}] |
| [@option{-ms=}@var{number}] [@option{-mx=}@var{number}] |
| [@option{--version}] [@option{--help}] |
| @c man end |
| @c man begin SEEALSO gij |
| gcc(1), gcj(1), gcjh(1), jv-scan(1), jcf-dump(1), gfdl(7), |
| and the Info entries for @file{gcj} and @file{gcc}. |
| @c man end |
| @end ignore |
| |
| @c man begin DESCRIPTION gij |
| |
| @code{gij} is a Java bytecode interpreter included with @code{libgcj}. |
| @code{gij} is not available on every platform; porting it requires a |
| small amount of assembly programming which has not been done for all the |
| targets supported by @code{gcj}. |
| |
| The primary argument to @code{gij} is the name of a class or, with |
| @code{-jar}, a jar file. Options before this argument are interpreted |
| by @code{gij}; remaining options are passed to the interpreted program. |
| |
| If a class name is specified and this class does not have a @code{main} |
| method with the appropriate signature (a @code{static void} method with |
| a @code{String[]} as its sole argument), then @code{gij} will print an |
| error and exit. |
| |
| If a jar file is specified then @code{gij} will use information in it to |
| determine which class' @code{main} method will be invoked. |
| |
| @code{gij} will invoke the @code{main} method with all the remaining |
| command-line options. |
| |
| Note that @code{gij} is not limited to interpreting code. Because |
| @code{libgcj} includes a class loader which can dynamically load shared |
| objects, it is possible to give @code{gij} the name of a class which has |
| been compiled and put into a shared library on the class path. |
| |
| @c man end |
| |
| @c man begin OPTIONS gij |
| |
| @table @gcctabopt |
| @item -D@var{name}[=@var{value}] |
| This defines a system property named @var{name} with value @var{value}. |
| If @var{value} is not specified then it defaults to the empty string. |
| These system properties are initialized at the program's startup and can |
| be retrieved at runtime using the @code{java.lang.System.getProperty} |
| method. |
| |
| @item -ms=@var{number} |
| This sets the initial heap size. |
| |
| @item -mx=@var{number} |
| This sets the maximum heap size. |
| |
| @item -jar |
| This indicates that the name passed to @code{gij} should be interpreted |
| as the name of a jar file, not a class. |
| |
| @item --help |
| Print help, then exit. |
| |
| @item --version |
| Print version number, then exit. |
| @end table |
| |
| @c man end |
| |
| @node Resources |
| @chapter Resources |
| |
| While writing @code{gcj} and @code{libgcj} we have, of course, relied |
| heavily on documentation from Sun Microsystems. In particular we have |
| used The Java Language Specification (both first and second editions), |
| the Java Class Libraries (volumes one and two), and the Java Virtual |
| Machine Specification. In addition we've used the online documentation |
| at @uref{http://java.sun.com/}. |
| |
| The current @code{gcj} home page is |
| @uref{http://gcc.gnu.org/java/}. |
| |
| For more information on gcc, see @uref{http://gcc.gnu.org/}. |
| |
| Some @code{libgcj} testing is done using the Mauve test suite. This is |
| a free software Java class library test suite which is being written |
| because the JCK is not free. See |
| @uref{http://sources.redhat.com/mauve/} for more information. |
| |
| @bye |