/* Initialization of the front end environment, before command line
options are parsed. Signal handlers, internationalization etc.
ARGV0 is main's argv[0]. */
static void
general_init (const char *argv0)
{
const char *p;
p = argv0 + strlen (argv0);
while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
--p;
progname = p;
xmalloc_set_program_name (progname);
hex_init ();
gcc_init_libintl ();
line_table = XNEW (struct line_maps);
linemap_init (line_table);
line_table->reallocator = xrealloc;
}
int
main (int argc, char **argv)
{
char *classname, *p;
FILE *stream;
const char *mangled_classname;
int i, last_arg;
int indirect = 0;
char *prog_name = argv[0];
/* Unlock the stdio streams. */
unlock_std_streams ();
gcc_init_libintl ();
if (argc > 1 && ! strcmp (argv[1], "-findirect-dispatch"))
{
indirect = 1;
++argv;
--argc;
}
if (argc < 2)
usage (prog_name);
for (i = 1; i < argc; ++i)
{
if (! strncmp (argv[i], "-D", 2))
{
/* Handled later. */
}
else
break;
}
if (i < argc - 2 || i == argc)
usage (prog_name);
last_arg = i;
classname = argv[i];
/* gcj always appends `main' to classname. We need to strip this here. */
p = strrchr (classname, 'm');
if (p == NULL || p == classname || strcmp (p, "main") != 0)
usage (prog_name);
else
*p = '\0';
gcc_obstack_init (mangle_obstack);
mangled_classname = do_mangle_classname (classname);
if (i < argc - 1 && strcmp (argv[i + 1], "-") != 0)
{
const char *outfile = argv[i + 1];
stream = fopen (outfile, "w");
if (stream == NULL)
{
fprintf (stderr, _("%s: Cannot open output file: %s\n"),
prog_name, outfile);
exit (1);
}
}
else
stream = stdout;
/* At this point every element of ARGV from 1 to LAST_ARG is a `-D'
option. Process them appropriately. */
fprintf (stream, "extern const char **_Jv_Compiler_Properties;\n");
fprintf (stream, "static const char *props[] =\n{\n");
for (i = 1; i < last_arg; ++i)
{
const char *p;
fprintf (stream, " \"");
for (p = &argv[i][2]; *p; ++p)
{
if (! ISPRINT (*p))
fprintf (stream, "\\%o", *p);
else if (*p == '\\' || *p == '"')
fprintf (stream, "\\%c", *p);
else
putc (*p, stream);
}
fprintf (stream, "\",\n");
}
fprintf (stream, " 0\n};\n\n");
fprintf (stream, "int main (int argc, const char **argv)\n");
fprintf (stream, "{\n");
fprintf (stream, " _Jv_Compiler_Properties = props;\n");
if (indirect)
fprintf (stream, " JvRunMainName (\"%s\", argc, argv);\n", classname);
else
{
fprintf (stream, " extern char %s;\n", mangled_classname);
fprintf (stream, " JvRunMain (&%s, argc, argv);\n", mangled_classname);
}
fprintf (stream, "}\n");
if (stream != stdout && fclose (stream) != 0)
{
fprintf (stderr, _("%s: Failed to close output file %s\n"),
prog_name, argv[2]);
exit (1);
}
return 0;
}
void
general_init(const char *argv0)
{
const char *p;
p = argv0 + strlen(argv0);
while(p != argv0 && !IS_DIR_SEPARATOR(p[-1]))
--p;
progname = p;
xmalloc_set_program_name(progname);
hex_init();
/* Unlock the stdio streams. */
unlock_std_streams();
gcc_init_libintl();
/* Initialize the diagnostics reporting machinery, so option parsing
can give warnings and errors. */
diagnostic_initialize(global_dc);
/* Set a default printer. Language specific initializations will
override it later. */
pp_format_decoder(global_dc->printer) = &default_tree_printer;
/* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
#ifdef SIGSEGV
signal(SIGSEGV, crash_signal);
#endif
#ifdef SIGILL
signal(SIGILL, crash_signal);
#endif
#ifdef SIGBUS
signal(SIGBUS, crash_signal);
#endif
#ifdef SIGABRT
signal(SIGABRT, crash_signal);
#endif
#if defined SIGIOT &&(!defined SIGABRT || SIGABRT != SIGIOT)
signal(SIGIOT, crash_signal);
#endif
#ifdef SIGFPE
signal(SIGFPE, crash_signal);
#endif
/* Other host-specific signal setup. */
(*host_hooks.extra_signals)();
/* Initialize the garbage-collector, string pools and tree type hash
table. */
init_ggc();
init_stringpool();
linemap_init(&line_table);
init_ttree();
/* Initialize register usage now so switches may override. */
init_reg_sets();
/* Register the language-independent parameters. */
add_params(lang_independent_params, LAST_PARAM);
/* This must be done after add_params but before argument processing. */
init_ggc_heuristics();
init_optimization_passes();
}
int
main (int argc, char** argv)
{
JCF jcf[1];
int argi, opt;
/* Unlock the stdio streams. */
unlock_std_streams ();
gcc_init_libintl ();
if (argc <= 1)
{
fprintf (stderr, _("jcf-dump: no classes specified\n"));
usage ();
}
jcf_path_init ();
/* We use getopt_long_only to allow single `-' long options. For
some of our options this is more natural. */
while ((opt = getopt_long_only (argc, argv, "o:I:vc", options, NULL)) != -1)
{
switch (opt)
{
case 0:
/* Already handled. */
break;
case 'o':
output_file = optarg;
break;
case 'I':
jcf_path_include_arg (optarg);
break;
case 'v':
verbose++;
break;
case 'c':
flag_disassemble_methods = 1;
break;
case OPT_classpath:
jcf_path_classpath_arg (optarg);
break;
case OPT_bootclasspath:
jcf_path_bootclasspath_arg (optarg);
break;
case OPT_extdirs:
jcf_path_extdirs_arg (optarg);
break;
case OPT_HELP:
help ();
break;
case OPT_VERSION:
version ();
break;
case OPT_JAVAP:
flag_javap_compatible++;
flag_print_constant_pool = 0;
flag_print_attributes = 0;
break;
default:
usage ();
}
}
if (verbose && ! flag_javap_compatible)
flag_print_constant_pool = 1;
if (optind == argc)
{
fprintf (stderr, _("jcf-dump: no classes specified\n"));
usage ();
}
jcf_path_seal (verbose);
if (flag_print_main)
{
flag_print_fields = 0;
flag_print_methods = 0;
flag_print_constant_pool = 0;
flag_print_attributes = 0;
flag_print_class_info = 0;
}
if (output_file)
{
out = fopen (output_file, "w");
if (! out)
{
fprintf (stderr, _("Cannot open '%s' for output.\n"), output_file);
return FATAL_EXIT_CODE;
}
}
else
out = stdout;
if (optind >= argc)
{
fprintf (out, "Reading .class from <standard input>.\n");
open_class ("<stdio>", jcf, 0, NULL);
process_class (jcf);
}
else
{
for (argi = optind; argi < argc; argi++)
{
char *arg = argv[argi];
const char *class_filename = find_class (arg, strlen (arg), jcf, 0);
if (class_filename == NULL)
class_filename = find_classfile (arg, jcf, NULL);
if (class_filename == NULL)
{
perror ("Could not find class");
return FATAL_EXIT_CODE;
}
JCF_FILL (jcf, 4);
if (GET_u4 (jcf->read_ptr) == ZIPMAGIC)
{
long compressed_size, member_size;
int compression_method, filename_length, extra_length;
int general_purpose_bits;
const char *filename;
int total_length;
if (flag_print_class_info)
fprintf (out, "Reading classes from archive %s.\n",
class_filename);
for (;;)
{
int skip = 0;
jcf_filbuf_t save_filbuf = jcf->filbuf;
long magic = JCF_readu4_le (jcf);
if (magic == 0x02014b50 || magic == 0x06054b50)
break; /* got to central directory */
if (magic != 0x04034b50) /* ZIPMAGIC (little-endian) */
{
fprintf (stderr, _("bad format of .zip/.jar archive\n"));
return FATAL_EXIT_CODE;
}
JCF_FILL (jcf, 26);
JCF_SKIP (jcf, 2);
general_purpose_bits = JCF_readu2_le (jcf);
compression_method = JCF_readu2_le (jcf);
JCF_SKIP (jcf, 8);
compressed_size = JCF_readu4_le (jcf);
member_size = JCF_readu4_le (jcf);
filename_length = JCF_readu2_le (jcf);
extra_length = JCF_readu2_le (jcf);
total_length = filename_length + extra_length
+ compressed_size;
if (jcf->read_end - jcf->read_ptr < total_length)
jcf_trim_old_input (jcf);
JCF_FILL (jcf, total_length);
filename = (const char *) jcf->read_ptr;
JCF_SKIP (jcf, filename_length);
JCF_SKIP (jcf, extra_length);
if (filename_length > 0
&& filename[filename_length-1] == '/')
{
if (flag_print_class_info)
fprintf (out, "[Skipping directory %.*s]\n",
filename_length, filename);
skip = 1;
}
else if (compression_method != 0)
{
if (flag_print_class_info)
fprintf (out, "[Skipping compressed file %.*s]\n",
filename_length, filename);
skip = 1;
}
else if (member_size < 4
|| GET_u4 (jcf->read_ptr) != 0xcafebabe)
{
if (flag_print_class_info)
fprintf (out, "[Skipping non-.class member %.*s]\n",
filename_length, filename);
skip = 1;
}
else
{
if (flag_print_class_info)
fprintf (out, "Reading class member: %.*s.\n",
filename_length, filename);
}
if (skip)
{
JCF_SKIP (jcf, compressed_size);
}
else
{
unsigned char *save_end;
jcf->filbuf = jcf_unexpected_eof;
save_end = jcf->read_end;
jcf->read_end = jcf->read_ptr + compressed_size;
process_class (jcf);
jcf->filbuf = save_filbuf;
jcf->read_end = save_end;
}
}
}
else
{
if (flag_print_class_info)
fprintf (out, "Reading .class from %s.\n", class_filename);
process_class (jcf);
}
JCF_FINISH(jcf);
}
}
return SUCCESS_EXIT_CODE;
}
/* jc1-lite main entry point */
int
main (int argc, char **argv)
{
int i = 1;
const char *output_file = NULL;
const char *encoding = NULL;
long ft;
int opt;
exec_name = argv[0];
/* Default for output */
out = stdout;
/* Unlock the stdio streams. */
unlock_std_streams ();
gcc_init_libintl ();
/* Process options first. We use getopt_long and not
getopt_long_only because we only support `--' long options here. */
while ((opt = getopt_long (argc, argv, "o:", options, NULL)) != -1)
{
switch (opt)
{
case 0:
/* Already handled. */
break;
case 'o':
output_file = optarg;
break;
case OPT_HELP:
help ();
break;
case OPT_VERSION:
version ();
break;
case OPT_ENCODING:
encoding = optarg;
break;
default:
usage ();
break;
}
}
/* No flags? Do nothing */
if (! flag_find_main && ! flag_dump_class && ! flag_complexity)
return 0;
/* Check on bad usage */
if (flag_find_main + flag_dump_class + flag_complexity > 1)
fatal_error
("only one of '--print-main', '--list-class', and '--complexity' allowed");
if (output_file && !(out = fopen (output_file, "w")))
fatal_error ("can't open output file '%s'", output_file);
ft = ftell (out);
gcc_obstack_init (&temporary_obstack);
java_push_parser_context ();
for ( i = optind; i < argc; i++ )
if (argv [i])
{
char *filename = argv[i];
if ( (finput = fopen (filename, "r")) )
{
/* There's no point in trying to find the current encoding
unless we are going to do something intelligent with it
-- hence the test for iconv. */
#if defined (HAVE_LOCALE_H) && defined (HAVE_ICONV) && defined (HAVE_LANGINFO_CODESET)
setlocale (LC_CTYPE, "");
if (encoding == NULL)
encoding = nl_langinfo (CODESET);
#endif
if (encoding == NULL || *encoding == '\0')
encoding = DEFAULT_ENCODING;
main_input_filename = filename;
java_init_lex (finput, encoding);
ctxp->filename = filename;
yyparse ();
report ();
if (ftell (out) != ft)
fputc ('\n', out);
ft = ftell (out);
fclose (finput);
reset_report ();
}
else
fatal_error ("file not found '%s'", argv [i]);
}
/* Flush and close */
if (ftell (out) != ft)
fputc ('\n', out);
if (!output_file)
fclose (out);
return 0;
}