335 lines
10 KiB
C++
335 lines
10 KiB
C++
/* Copyright (C) 1999-2006 Free Software Foundation
|
|
|
|
This file is part of libgcj.
|
|
|
|
This software is copyrighted work licensed under the terms of the
|
|
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
|
details. */
|
|
|
|
#include <config.h>
|
|
|
|
#include <jvm.h>
|
|
#include <gcj/cni.h>
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
static void
|
|
help ()
|
|
{
|
|
printf ("Usage: gij [OPTION] ... CLASS [ARGS] ...\n");
|
|
printf (" to interpret Java bytecodes, or\n");
|
|
printf (" gij -jar [OPTION] ... JARFILE [ARGS] ...\n");
|
|
printf (" to execute a jar file\n\n");
|
|
printf (" --cp LIST set class path\n");
|
|
printf (" --classpath LIST set class path\n");
|
|
printf (" -DVAR=VAL define property VAR with value VAL\n");
|
|
printf (" -?, --help print this help, then exit\n");
|
|
printf (" -X print help on supported -X options, then exit\n");
|
|
printf (" --ms=NUMBER set initial heap size\n");
|
|
printf (" --mx=NUMBER set maximum heap size\n");
|
|
printf (" --verbose[:class] print information about class loading\n");
|
|
printf (" --showversion print version number, then keep going\n");
|
|
printf (" --version print version number, then exit\n");
|
|
printf ("\nOptions can be specified with `-' or `--'.\n");
|
|
printf ("\nSee http://gcc.gnu.org/java/ for information on reporting bugs\n");
|
|
exit (0);
|
|
}
|
|
|
|
static void
|
|
version ()
|
|
{
|
|
printf ("java version \"" JV_VERSION "\"\n");
|
|
printf ("gij (GNU libgcj) version %s\n\n", __VERSION__);
|
|
printf ("Copyright (C) 2006 Free Software Foundation, Inc.\n");
|
|
printf ("This is free software; see the source for copying conditions. There is NO\n");
|
|
printf ("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n");
|
|
}
|
|
|
|
static void
|
|
nonstandard_opts_help ()
|
|
{
|
|
printf (" -Xms<size> set initial heap size\n");
|
|
printf (" -Xmx<size> set maximum heap size\n");
|
|
printf (" -Xss<size> set thread stack size\n");
|
|
exit (0);
|
|
}
|
|
|
|
static void
|
|
add_option (JvVMInitArgs& vm_args, char const* option, void const* extra)
|
|
{
|
|
vm_args.options =
|
|
(JvVMOption*) JvRealloc (vm_args.options,
|
|
(vm_args.nOptions + 1) * sizeof (JvVMOption));
|
|
|
|
vm_args.options[vm_args.nOptions].optionString = const_cast<char*> (option);
|
|
vm_args.options[vm_args.nOptions].extraInfo = const_cast<void*> (extra);
|
|
++vm_args.nOptions;
|
|
}
|
|
|
|
int
|
|
main (int argc, char const** argv)
|
|
{
|
|
JvVMInitArgs vm_args;
|
|
bool jar_mode = false;
|
|
|
|
vm_args.options = NULL;
|
|
vm_args.nOptions = 0;
|
|
vm_args.ignoreUnrecognized = true;
|
|
|
|
// Command-line options always override the CLASSPATH environment
|
|
// variable.
|
|
char *classpath = getenv("CLASSPATH");
|
|
|
|
if (classpath)
|
|
{
|
|
char* darg = (char*) JvMalloc (strlen (classpath)
|
|
+ sizeof ("-Djava.class.path="));
|
|
sprintf (darg, "-Djava.class.path=%s", classpath);
|
|
add_option (vm_args, darg, NULL);
|
|
}
|
|
|
|
// Handle arguments to the java command. Store in vm_args arguments
|
|
// handled by the invocation API.
|
|
int i;
|
|
for (i = 1; i < argc; ++i)
|
|
{
|
|
char* arg = const_cast<char*> (argv[i]);
|
|
|
|
// A non-option stops processing.
|
|
if (arg[0] != '-')
|
|
break;
|
|
|
|
// A "--" stops processing.
|
|
if (! strcmp (arg, "--"))
|
|
{
|
|
++i;
|
|
break;
|
|
}
|
|
|
|
// Allow both single or double hyphen for all options.
|
|
if (arg[1] == '-')
|
|
++arg;
|
|
|
|
// Ignore JIT options
|
|
if (! strcmp (arg, "-client"))
|
|
continue;
|
|
else if (! strcmp (arg, "-server"))
|
|
continue;
|
|
else if (! strcmp (arg, "-hotspot"))
|
|
continue;
|
|
else if (! strcmp (arg, "-jrockit"))
|
|
continue;
|
|
// JVM Tool Interface options.
|
|
else if (! strncmp (arg, "-agentlib:", sizeof ("-agentlib:") - 1))
|
|
add_option (vm_args, arg, NULL);
|
|
else if (! strncmp (arg, "-agentpath:", sizeof ("-agentpath:") - 1))
|
|
add_option (vm_args, arg, NULL);
|
|
else if (! strcmp (arg, "-classpath") || ! strcmp (arg, "-cp"))
|
|
{
|
|
if (i >= argc - 1)
|
|
{
|
|
no_arg:
|
|
fprintf (stderr, "gij: option requires an argument -- `%s'\n",
|
|
argv[i]);
|
|
fprintf (stderr, "Try `gij --help' for more information.\n");
|
|
exit (1);
|
|
}
|
|
|
|
// Sun seems to translate the -classpath option into
|
|
// -Djava.class.path because if both -classpath and
|
|
// -Djava.class.path are specified on the java command line,
|
|
// the last one always wins.
|
|
char* darg = (char*) JvMalloc (strlen (argv[++i])
|
|
+ sizeof ("-Djava.class.path="));
|
|
sprintf (darg, "-Djava.class.path=%s", argv[i]);
|
|
add_option (vm_args, darg, NULL);
|
|
}
|
|
else if (! strcmp (arg, "-debug"))
|
|
{
|
|
char* xarg = strdup ("-Xdebug");
|
|
add_option (vm_args, xarg, NULL);
|
|
}
|
|
else if (! strncmp (arg, "-D", sizeof ("-D") - 1))
|
|
add_option (vm_args, arg, NULL);
|
|
// Ignore 32/64-bit JIT options
|
|
else if (! strcmp (arg, "-d32") || ! strcmp (arg, "-d64"))
|
|
continue;
|
|
else if (! strncmp (arg, "-enableassertions", sizeof ("-enableassertions") - 1)
|
|
|| ! strncmp (arg, "-ea", sizeof ("-ea") - 1))
|
|
{
|
|
// FIXME: hook up assertion support
|
|
continue;
|
|
}
|
|
else if (! strncmp (arg, "-disableassertions", sizeof ("-disableassertions") - 1)
|
|
|| ! strncmp (arg, "-da", sizeof ("-da") - 1))
|
|
{
|
|
// FIXME: hook up assertion support
|
|
continue;
|
|
}
|
|
else if (! strcmp (arg, "-enablesystemassertions")
|
|
|| ! strcmp (arg, "-esa"))
|
|
{
|
|
// FIXME: hook up system assertion support
|
|
continue;
|
|
}
|
|
else if (! strcmp (arg, "-disablesystemassertions")
|
|
|| ! strcmp (arg, "-dsa"))
|
|
{
|
|
// FIXME
|
|
continue;
|
|
}
|
|
else if (! strcmp (arg, "-jar"))
|
|
{
|
|
jar_mode = true;
|
|
continue;
|
|
}
|
|
// Ignore java.lang.instrument option
|
|
else if (! strncmp (arg, "-javaagent:", sizeof ("-javaagent:") - 1))
|
|
continue;
|
|
else if (! strcmp (arg, "-noclassgc"))
|
|
{
|
|
char* xarg = strdup ("-Xnoclassgc");
|
|
add_option (vm_args, xarg, NULL);
|
|
}
|
|
// -ms=n
|
|
else if (! strncmp (arg, "-ms=", sizeof ("-ms=") - 1))
|
|
{
|
|
arg[1] = 'X';
|
|
arg[2] = 'm';
|
|
arg[3] = 's';
|
|
add_option (vm_args, arg, NULL);
|
|
}
|
|
// -ms n
|
|
else if (! strcmp (arg, "-ms"))
|
|
{
|
|
if (i >= argc - 1)
|
|
goto no_arg;
|
|
|
|
char* xarg = (char*) JvMalloc (strlen (argv[++i])
|
|
+ sizeof ("-Xms"));
|
|
sprintf (xarg, "-Xms%s", argv[i]);
|
|
add_option (vm_args, xarg, NULL);
|
|
}
|
|
// -msn
|
|
else if (! strncmp (arg, "-ms", sizeof ("-ms") - 1))
|
|
{
|
|
char* xarg = (char*) JvMalloc (strlen (arg) + sizeof ("X"));
|
|
sprintf (xarg, "-Xms%s", arg + sizeof ("-Xms") - 1);
|
|
add_option (vm_args, xarg, NULL);
|
|
}
|
|
// -mx=n
|
|
else if (! strncmp (arg, "-mx=", sizeof ("-mx=") - 1))
|
|
{
|
|
arg[1] = 'X';
|
|
arg[2] = 'm';
|
|
arg[3] = 'x';
|
|
add_option (vm_args, arg, NULL);
|
|
}
|
|
// -mx n
|
|
else if (! strcmp (arg, "-mx"))
|
|
{
|
|
if (i >= argc - 1)
|
|
goto no_arg;
|
|
|
|
char* xarg = (char*) JvMalloc (strlen (argv[++i])
|
|
+ sizeof ("-Xmx"));
|
|
sprintf (xarg, "-Xmx%s", argv[i]);
|
|
add_option (vm_args, xarg, NULL);
|
|
}
|
|
// -mxn
|
|
else if (! strncmp (arg, "-mx", sizeof ("-mx") - 1))
|
|
{
|
|
char* xarg = (char*) JvMalloc (strlen (arg) + sizeof ("X"));
|
|
sprintf (xarg, "-Xmx%s", arg + sizeof ("-Xmx") - 1);
|
|
add_option (vm_args, xarg, NULL);
|
|
}
|
|
// -ss=n
|
|
else if (! strncmp (arg, "-ss=", sizeof ("-ss=") - 1))
|
|
{
|
|
arg[1] = 'X';
|
|
arg[2] = 's';
|
|
arg[3] = 's';
|
|
add_option (vm_args, arg, NULL);
|
|
}
|
|
// -ss n
|
|
else if (! strcmp (arg, "-ss"))
|
|
{
|
|
if (i >= argc - 1)
|
|
goto no_arg;
|
|
|
|
char* xarg = (char*) JvMalloc (strlen (argv[++i])
|
|
+ sizeof ("-Xss"));
|
|
sprintf (xarg, "-Xss%s", argv[i]);
|
|
add_option (vm_args, xarg, NULL);
|
|
}
|
|
// -ssn
|
|
else if (! strncmp (arg, "-ss", sizeof ("-ss") - 1))
|
|
{
|
|
char* xarg = (char*) JvMalloc (strlen (arg) + sizeof ("X"));
|
|
sprintf (xarg, "-Xss%s", arg + sizeof ("-Xss") - 1);
|
|
add_option (vm_args, xarg, NULL);
|
|
}
|
|
// This handles all the option variants that begin with
|
|
// -verbose.
|
|
else if (! strncmp (arg, "-verbose", 8))
|
|
add_option (vm_args, arg, NULL);
|
|
else if (! strcmp (arg, "-version"))
|
|
{
|
|
version ();
|
|
exit (0);
|
|
}
|
|
else if (! strcmp (arg, "-fullversion"))
|
|
{
|
|
printf ("java full version \"gcj-" JV_VERSION "\"\n");
|
|
exit (0);
|
|
}
|
|
else if (! strcmp (arg, "-showversion"))
|
|
version ();
|
|
else if (! strcmp (arg, "-help") || ! strcmp (arg, "-?"))
|
|
help ();
|
|
else if (! strcmp (arg, "-X"))
|
|
nonstandard_opts_help ();
|
|
else if (! strncmp (arg, "-X", 2))
|
|
add_option (vm_args, arg, NULL);
|
|
// Obsolete options recognized for backwards-compatibility.
|
|
else if (! strcmp (arg, "-verify")
|
|
|| ! strcmp (arg, "-verifyremote"))
|
|
continue;
|
|
else if (! strcmp (arg, "-noverify"))
|
|
{
|
|
gcj::verifyClasses = false;
|
|
}
|
|
else
|
|
{
|
|
fprintf (stderr, "gij: unrecognized option -- `%s'\n", argv[i]);
|
|
fprintf (stderr, "Try `gij --help' for more information.\n");
|
|
exit (1);
|
|
}
|
|
}
|
|
|
|
if (argc - i < 1)
|
|
{
|
|
fprintf (stderr, "Usage: gij [OPTION] ... CLASS [ARGS] ...\n");
|
|
fprintf (stderr, " to invoke CLASS.main, or\n");
|
|
fprintf (stderr, " gij -jar [OPTION] ... JARFILE [ARGS] ...\n");
|
|
fprintf (stderr, " to execute a jar file\n");
|
|
fprintf (stderr, "Try `gij --help' for more information.\n");
|
|
exit (1);
|
|
}
|
|
|
|
// -jar mode overrides all other modes of specifying class path:
|
|
// CLASSPATH, -Djava.class.path, -classpath and -cp.
|
|
if (jar_mode)
|
|
{
|
|
char* darg = (char*) JvMalloc (strlen (argv[i])
|
|
+ sizeof ("-Djava.class.path="));
|
|
sprintf (darg, "-Djava.class.path=%s", argv[i]);
|
|
add_option (vm_args, darg, NULL);
|
|
}
|
|
|
|
_Jv_RunMain (&vm_args, NULL, argv[i], argc - i,
|
|
(char const**) (argv + i), jar_mode);
|
|
}
|