gcc/java/lang.c

   1 /* Java(TM) language-specific utility routines.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.
  21
  22 Java and all Java-based marks are trademarks or registered trademarks
  23 of Sun Microsystems, Inc. in the United States and other countries.
  24 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  25
  26 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "tree.h"
  31 #include "input.h"
  32 #include "rtl.h"
  33 #include "expr.h"
  34 #include "java-tree.h"
  35 #include "jcf.h"
  36 #include "toplev.h"
  37 #include "langhooks.h"
  38 #include "langhooks-def.h"
  39 #include "flags.h"
  40 #include "xref.h"
  41 #include "ggc.h"
  42 #include "diagnostic.h"
  43
  44 struct string_option
  45 {
  46   const char *const string;
  47   int *const variable;
  48   const int on_value;
  49 };
  50
  51 static const char *java_init PARAMS ((const char *));
  52 static void java_finish PARAMS ((void));
  53 static void java_init_options PARAMS ((void));
  54 static int java_decode_option PARAMS ((int, char **));
  55 static void put_decl_string PARAMS ((const char *, int));
  56 static void put_decl_node PARAMS ((tree));
  57 static void java_dummy_print PARAMS ((diagnostic_context *, const char *));
  58 static void lang_print_error PARAMS ((diagnostic_context *, const char *));
  59 static int process_option_with_no PARAMS ((const char *,
  60                                            const struct string_option *,
  61                                            int));
  62
  63 #ifndef TARGET_OBJECT_SUFFIX
  64 # define TARGET_OBJECT_SUFFIX ".o"
  65 #endif
  66
  67 /* Table indexed by tree code giving a string containing a character
  68    classifying the tree code.  Possibilities are
  69    t, d, s, c, r, <, 1 and 2.  See java/java-tree.def for details.  */
  70
  71 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
  72
  73 static const char java_tree_code_type[] = {
  74   'x',
  75 #include "java-tree.def"
  76 };
  77 #undef DEFTREECODE
  78
  79 /* Table indexed by tree code giving number of expression
  80    operands beyond the fixed part of the node structure.
  81    Not used for types or decls.  */
  82
  83 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
  84
  85 static const int java_tree_code_length[] = {
  86   0,
  87 #include "java-tree.def"
  88 };
  89 #undef DEFTREECODE
  90
  91 /* Names of tree components.
  92    Used for printing out the tree and error messages.  */
  93 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
  94
  95 static const char *const java_tree_code_name[] = {
  96   "@@dummy",
  97 #include "java-tree.def"
  98 };
  99 #undef DEFTREECODE
 100
 101 int compiling_from_source;
 102
 103 char * resource_name;
 104
 105 int flag_emit_class_files = 0;
 106
 107 /* Nonzero if input file is a file with a list of filenames to compile. */
 108
 109 int flag_filelist_file = 0;
 110
 111 /* When non zero, we emit xref strings. Values of the flag for xref
 112    backends are defined in xref_flag_table, xref.c.  */
 113
 114 int flag_emit_xref = 0;
 115
 116 /* When non zero, -Wall was turned on.  */
 117 int flag_wall = 0;
 118
 119 /* When non zero, check for redundant modifier uses.  */
 120 int flag_redundant = 0;
 121
 122 /* When non zero, call a library routine to do integer divisions. */
 123 int flag_use_divide_subroutine = 1;
 124
 125 /* When non zero, generate code for the Boehm GC.  */
 126 int flag_use_boehm_gc = 0;
 127
 128 /* When non zero, assume the runtime uses a hash table to map an
 129    object to its synchronization structure.  */
 130 int flag_hash_synchronization;
 131
 132 /* When non zero, assume all native functions are implemented with
 133    JNI, not CNI.  */
 134 int flag_jni = 0;
 135
 136 /* When non zero, warn when source file is newer than matching class
 137    file.  */
 138 int flag_newer = 1;
 139
 140 /* When non zero, generate checks for references to NULL.  */
 141 int flag_check_references = 0;
 142
 143 /* The encoding of the source file.  */
 144 const char *current_encoding = NULL;
 145
 146 /* When non zero, report the now deprecated empty statements.  */
 147 int flag_extraneous_semicolon;
 148
 149 /* When non zero, always check for a non gcj generated classes archive.  */
 150 int flag_force_classes_archive_check;
 151
 152 /* When zero, don't optimize static class initialization. This flag shouldn't
 153    be tested alone, use STATIC_CLASS_INITIALIZATION_OPTIMIZATION_P instead.  */
 154 int flag_optimize_sci = 1;
 155
 156 /* When non zero, use offset tables for virtual method calls
 157    in order to improve binary compatibility. */
 158 int flag_indirect_dispatch = 0;
 159
 160 /* When non zero, print extra version information.  */
 161 static int version_flag = 0;
 162
 163 /* Table of language-dependent -f options.
 164    STRING is the option name.  VARIABLE is the address of the variable.
 165    ON_VALUE is the value to store in VARIABLE
 166     if `-fSTRING' is seen as an option.
 167    (If `-fno-STRING' is seen as an option, the opposite value is stored.)  */
 168
 169 static const struct string_option
 170 lang_f_options[] =
 171 {
 172   {"emit-class-file", &flag_emit_class_files, 1},
 173   {"emit-class-files", &flag_emit_class_files, 1},
 174   {"filelist-file", &flag_filelist_file, 1},
 175   {"use-divide-subroutine", &flag_use_divide_subroutine, 1},
 176   {"use-boehm-gc", &flag_use_boehm_gc, 1},
 177   {"hash-synchronization", &flag_hash_synchronization, 1},
 178   {"jni", &flag_jni, 1},
 179   {"check-references", &flag_check_references, 1},
 180   {"force-classes-archive-check", &flag_force_classes_archive_check, 1},
 181   {"optimize-static-class-initialization", &flag_optimize_sci, 1 },
 182   {"indirect-dispatch", &flag_indirect_dispatch, 1}
 183 };
 184
 185 static const struct string_option
 186 lang_W_options[] =
 187 {
 188   { "redundant-modifiers", &flag_redundant, 1 },
 189   { "extraneous-semicolon", &flag_extraneous_semicolon, 1 },
 190   { "out-of-date", &flag_newer, 1 }
 191 };
 192
 193 JCF *current_jcf;
 194
 195 /* Variable controlling how dependency tracking is enabled in
 196    java_init.  */
 197 static int dependency_tracking = 0;
 198
 199 /* Flag values for DEPENDENCY_TRACKING.  */
 200 #define DEPEND_SET_FILE 1
 201 #define DEPEND_ENABLE   2
 202 #define DEPEND_TARGET_SET 4
 203 #define DEPEND_FILE_ALREADY_SET 8
 204
 205 #undef LANG_HOOKS_NAME
 206 #define LANG_HOOKS_NAME "GNU Java"
 207 #undef LANG_HOOKS_INIT
 208 #define LANG_HOOKS_INIT java_init
 209 #undef LANG_HOOKS_FINISH
 210 #define LANG_HOOKS_FINISH java_finish
 211 #undef LANG_HOOKS_INIT_OPTIONS
 212 #define LANG_HOOKS_INIT_OPTIONS java_init_options
 213 #undef LANG_HOOKS_DECODE_OPTION
 214 #define LANG_HOOKS_DECODE_OPTION java_decode_option
 215 #undef LANG_HOOKS_SET_YYDEBUG
 216 #define LANG_HOOKS_SET_YYDEBUG java_set_yydebug
 217
 218 /* Each front end provides its own.  */
 219 const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
 220
 221 /* Process an option that can accept a `no-' form.
 222    Return 1 if option found, 0 otherwise.  */
 223 static int
 224 process_option_with_no (p, table, table_size)
 225      const char *p;
 226      const struct string_option *table;
 227      int table_size;
 228 {
 229   int j;
 230
 231   for (j = 0; j < table_size; j++)
 232     {
 233       if (!strcmp (p, table[j].string))
 234         {
 235           *table[j].variable = table[j].on_value;
 236           return 1;
 237         }
 238       if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
 239           && ! strcmp (p+3, table[j].string))
 240         {
 241           *table[j].variable = ! table[j].on_value;
 242           return 1;
 243         }
 244     }
 245
 246   return 0;
 247 }
 248
 249 /*
 250  * process java-specific compiler command-line options
 251  * return 0, but do not complain if the option is not recognised.
 252  */
 253 static int
 254 java_decode_option (argc, argv)
 255      int argc __attribute__ ((__unused__));
 256      char **argv;
 257 {
 258   char *p = argv[0];
 259
 260   if (strcmp (p, "-version") == 0)
 261     {
 262       version_flag = 1;
 263       /* We return 0 so that the caller can process this.  */
 264       return 0;
 265     }
 266
 267 #define CLARG "-fcompile-resource="
 268   if (strncmp (p, CLARG, sizeof (CLARG) - 1) == 0)
 269     {
 270       resource_name = p + sizeof (CLARG) - 1;
 271       return 1;
 272     }
 273 #undef CLARG
 274 #define CLARG "-fassume-compiled="
 275   if (strncmp (p, CLARG, sizeof (CLARG) - 1) == 0)
 276     {
 277       add_assume_compiled (p + sizeof (CLARG) - 1, 0);
 278       return 1;
 279     }
 280 #undef CLARG
 281 #define CLARG "-fno-assume-compiled="
 282   if (strncmp (p, CLARG, sizeof (CLARG) - 1) == 0)
 283     {
 284       add_assume_compiled (p + sizeof (CLARG) - 1, 1);
 285       return 1;
 286     }
 287 #undef CLARG
 288 #define CLARG "-fassume-compiled"
 289   if (strncmp (p, CLARG, sizeof (CLARG) - 1) == 0)
 290     {
 291       add_assume_compiled ("", 0);
 292       return 1;
 293     }
 294 #undef CLARG
 295 #define CLARG "-fno-assume-compiled"
 296   if (strncmp (p, CLARG, sizeof (CLARG) - 1) == 0)
 297     {
 298       add_assume_compiled ("", 1);
 299       return 1;
 300     }
 301 #undef CLARG
 302 #define CLARG "-fclasspath="
 303   if (strncmp (p, CLARG, sizeof (CLARG) - 1) == 0)
 304     {
 305       jcf_path_classpath_arg (p + sizeof (CLARG) - 1);
 306       return 1;
 307     }
 308 #undef CLARG
 309 #define CLARG "-fCLASSPATH="
 310   if (strncmp (p, CLARG, sizeof (CLARG) - 1) == 0)
 311     {
 312       jcf_path_CLASSPATH_arg (p + sizeof (CLARG) - 1);
 313       return 1;
 314     }
 315 #undef CLARG
 316   else if (strncmp (p, "-I", 2) == 0)
 317     {
 318       jcf_path_include_arg (p + 2);
 319       return 1;
 320     }
 321
 322 #define ARG "-foutput-class-dir="
 323   if (strncmp (p, ARG, sizeof (ARG) - 1) == 0)
 324     {
 325       jcf_write_base_directory = p + sizeof (ARG) - 1;
 326       return 1;
 327     }
 328 #undef ARG
 329 #define ARG "-fencoding="
 330   if (strncmp (p, ARG, sizeof (ARG) - 1) == 0)
 331     {
 332       current_encoding = p + sizeof (ARG) - 1;
 333       return 1;
 334     }
 335 #undef ARG
 336
 337   if (p[0] == '-' && p[1] == 'f')
 338     {
 339       /* Some kind of -f option.
 340          P's value is the option sans `-f'.
 341          Search for it in the table of options.  */
 342       p += 2;
 343       return process_option_with_no (p, lang_f_options,
 344                                      ARRAY_SIZE (lang_f_options));
 345     }
 346
 347   if (strcmp (p, "-Wall") == 0)
 348     {
 349       flag_wall = 1;
 350       flag_redundant = 1;
 351       flag_extraneous_semicolon = 1;
 352       /* When -Wall given, enable -Wunused.  We do this because the C
 353          compiler does it, and people expect it.  */
 354       set_Wunused (1);
 355       return 1;
 356     }
 357
 358   if (p[0] == '-' && p[1] == 'W')
 359     {
 360       /* Skip `-W' and see if we accept the option or its `no-' form.  */
 361       p += 2;
 362       return process_option_with_no (p, lang_W_options,
 363                                      ARRAY_SIZE (lang_W_options));
 364     }
 365
 366   if (strcmp (p, "-MD") == 0)
 367     {
 368       jcf_dependency_init (1);
 369       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 370       return 1;
 371     }
 372   else if (strcmp (p, "-MMD") == 0)
 373     {
 374       jcf_dependency_init (0);
 375       dependency_tracking |= DEPEND_SET_FILE | DEPEND_ENABLE;
 376       return 1;
 377     }
 378   else if (strcmp (p, "-M") == 0)
 379     {
 380       jcf_dependency_init (1);
 381       dependency_tracking |= DEPEND_ENABLE;
 382       return 1;
 383     }
 384   else if (strcmp (p, "-MM") == 0)
 385     {
 386       jcf_dependency_init (0);
 387       dependency_tracking |= DEPEND_ENABLE;
 388       return 1;
 389     }
 390   else if (strcmp (p, "-MP") == 0)
 391     {
 392       jcf_dependency_print_dummies ();
 393       return 1;
 394     }
 395   else if (strcmp (p, "-MT") == 0)
 396     {
 397       jcf_dependency_set_target (argv[1]);
 398       dependency_tracking |= DEPEND_TARGET_SET;
 399       return 2;
 400     }
 401   else if (strcmp (p, "-MF") == 0)
 402     {
 403       jcf_dependency_set_dep_file (argv[1]);
 404       dependency_tracking |= DEPEND_FILE_ALREADY_SET;
 405       return 2;
 406     }
 407
 408   return 0;
 409 }
 410
 411 /* Global open file.  */
 412 FILE *finput;
 413
 414 static const char *
 415 java_init (filename)
 416      const char *filename;
 417 {
 418 #if 0
 419   extern int flag_minimal_debug;
 420   flag_minimal_debug = 0;
 421 #endif
 422
 423   /* Open input file.  */
 424
 425   if (filename == 0 || !strcmp (filename, "-"))
 426     {
 427       finput = stdin;
 428       filename = "stdin";
 429
 430       if (dependency_tracking)
 431         error ("can't do dependency tracking with input from stdin");
 432     }
 433   else
 434     {
 435       if (dependency_tracking)
 436         {
 437           char *dot;
 438
 439           /* If the target is set and the output filename is set, then
 440              there's no processing to do here.  Otherwise we must
 441              compute one or the other.  */
 442           if (! ((dependency_tracking & DEPEND_TARGET_SET)
 443                  && (dependency_tracking & DEPEND_FILE_ALREADY_SET)))
 444             {
 445               dot = strrchr (filename, '.');
 446               if (dot == NULL)
 447                 error ("couldn't determine target name for dependency tracking");
 448               else
 449                 {
 450                   char *buf = (char *) xmalloc (dot - filename +
 451                                                 3 + sizeof (TARGET_OBJECT_SUFFIX));
 452                   strncpy (buf, filename, dot - filename);
 453
 454                   /* If emitting class files, we might have multiple
 455                      targets.  The class generation code takes care of
 456                      registering them.  Otherwise we compute the
 457                      target name here.  */
 458                   if ((dependency_tracking & DEPEND_TARGET_SET))
 459                     ; /* Nothing.  */
 460                   else if (flag_emit_class_files)
 461                     jcf_dependency_set_target (NULL);
 462                   else
 463                     {
 464                       strcpy (buf + (dot - filename), TARGET_OBJECT_SUFFIX);
 465                       jcf_dependency_set_target (buf);
 466                     }
 467
 468                   if ((dependency_tracking & DEPEND_FILE_ALREADY_SET))
 469                     ; /* Nothing.  */
 470                   else if ((dependency_tracking & DEPEND_SET_FILE))
 471                     {
 472                       strcpy (buf + (dot - filename), ".d");
 473                       jcf_dependency_set_dep_file (buf);
 474                     }
 475                   else
 476                     jcf_dependency_set_dep_file ("-");
 477
 478                   free (buf);
 479                 }
 480             }
 481         }
 482     }
 483
 484   jcf_path_init ();
 485   jcf_path_seal (version_flag);
 486
 487   decl_printable_name = lang_printable_name;
 488   print_error_function = lang_print_error;
 489   lang_expand_expr = java_lang_expand_expr;
 490
 491   /* Append to Gcc tree node definition arrays */
 492
 493   memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
 494           java_tree_code_type,
 495           (int)LAST_JAVA_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
 496   memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
 497           java_tree_code_length,
 498           (LAST_JAVA_TREE_CODE -
 499            (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
 500   memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
 501           java_tree_code_name,
 502           (LAST_JAVA_TREE_CODE -
 503            (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
 504   java_init_decl_processing ();
 505
 506   using_eh_for_cleanups ();
 507
 508   return filename;
 509 }
 510
 511 static void
 512 java_finish ()
 513 {
 514   jcf_dependency_write ();
 515 }
 516
 517 /* Buffer used by lang_printable_name. */
 518 static char *decl_buf = NULL;
 519
 520 /* Allocated size of decl_buf. */
 521 static int decl_buflen = 0;
 522
 523 /* Length of used part of decl_buf;  position for next character. */
 524 static int decl_bufpos = 0;
 525
 526 /* Append the string STR to decl_buf.
 527    It length is given by LEN;  -1 means the string is nul-terminated. */
 528
 529 static void
 530 put_decl_string (str, len)
 531      const char *str;
 532      int len;
 533 {
 534   if (len < 0)
 535     len = strlen (str);
 536   if (decl_bufpos + len >= decl_buflen)
 537     {
 538       if (decl_buf == NULL)
 539         {
 540           decl_buflen = len + 100;
 541           decl_buf = (char *) xmalloc (decl_buflen);
 542         }
 543       else
 544         {
 545           decl_buflen *= 2;
 546           decl_buf = (char *) xrealloc (decl_buf, decl_buflen);
 547         }
 548     }
 549   strcpy (decl_buf + decl_bufpos, str);
 550   decl_bufpos += len;
 551 }
 552
 553 /* Append to decl_buf a printable name for NODE. */
 554
 555 static void
 556 put_decl_node (node)
 557      tree node;
 558 {
 559   int was_pointer = 0;
 560   if (TREE_CODE (node) == POINTER_TYPE)
 561     {
 562       node = TREE_TYPE (node);
 563       was_pointer = 1;
 564     }
 565   if (TREE_CODE_CLASS (TREE_CODE (node)) == 'd'
 566       && DECL_NAME (node) != NULL_TREE)
 567     {
 568       if (TREE_CODE (node) == FUNCTION_DECL)
 569         {
 570           /* We want to print the type the DECL belongs to. We don't do
 571              that when we handle constructors. */
 572           if (! DECL_CONSTRUCTOR_P (node)
 573               && ! DECL_ARTIFICIAL (node) && DECL_CONTEXT (node))
 574             {
 575               put_decl_node (TYPE_NAME (DECL_CONTEXT (node)));
 576               put_decl_string (".", 1);
 577             }
 578           if (! DECL_CONSTRUCTOR_P (node))
 579             put_decl_node (DECL_NAME (node));
 580           if (TREE_TYPE (node) != NULL_TREE)
 581             {
 582               int i = 0;
 583               tree args = TYPE_ARG_TYPES (TREE_TYPE (node));
 584               if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE)
 585                 args = TREE_CHAIN (args);
 586               put_decl_string ("(", 1);
 587               for ( ; args != end_params_node;  args = TREE_CHAIN (args), i++)
 588                 {
 589                   if (i > 0)
 590                     put_decl_string (",", 1);
 591                   put_decl_node (TREE_VALUE (args));
 592                 }
 593               put_decl_string (")", 1);
 594             }
 595         }
 596       else
 597         put_decl_node (DECL_NAME (node));
 598     }
 599   else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't'
 600       && TYPE_NAME (node) != NULL_TREE)
 601     {
 602       if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node))
 603         {
 604           put_decl_node (TYPE_ARRAY_ELEMENT (node));
 605           put_decl_string("[]", 2);
 606         }
 607       else if (node == promoted_byte_type_node)
 608         put_decl_string ("byte", 4);
 609       else if (node == promoted_short_type_node)
 610         put_decl_string ("short", 5);
 611       else if (node == promoted_char_type_node)
 612         put_decl_string ("char", 4);
 613       else if (node == promoted_boolean_type_node)
 614         put_decl_string ("boolean", 7);
 615       else if (node == void_type_node && was_pointer)
 616         put_decl_string ("null", 4);
 617       else
 618         put_decl_node (TYPE_NAME (node));
 619     }
 620   else if (TREE_CODE (node) == IDENTIFIER_NODE)
 621     put_decl_string (IDENTIFIER_POINTER (node), IDENTIFIER_LENGTH (node));
 622   else
 623     put_decl_string ("<unknown>", -1);
 624 }
 625
 626 /* Return a user-friendly name for DECL.
 627    The resulting string is only valid until the next call.
 628    The value of the hook decl_printable_name is this function,
 629    which is also called directly by lang_print_error. */
 630
 631 const char *
 632 lang_printable_name (decl, v)
 633      tree decl;
 634      int v  __attribute__ ((__unused__));
 635 {
 636   decl_bufpos = 0;
 637   put_decl_node (decl);
 638   put_decl_string ("", 1);
 639   return decl_buf;
 640 }
 641
 642 /* Does the same thing that lang_printable_name, but add a leading
 643    space to the DECL name string -- With Leading Space.  */
 644
 645 const char *
 646 lang_printable_name_wls (decl, v)
 647      tree decl;
 648      int v  __attribute__ ((__unused__));
 649 {
 650   decl_bufpos = 1;
 651   put_decl_node (decl);
 652   put_decl_string ("", 1);
 653   decl_buf [0] = ' ';
 654   return decl_buf;
 655 }
 656
 657 /* Print on stderr the current class and method context.  This function
 658    is the value of the hook print_error_function, called from toplev.c. */
 659
 660 static void
 661 lang_print_error (context, file)
 662      diagnostic_context *context __attribute__((__unused__));
 663      const char *file;
 664 {
 665   static tree last_error_function_context = NULL_TREE;
 666   static tree last_error_function = NULL;
 667   static int initialized_p;
 668
 669   /* Register LAST_ERROR_FUNCTION_CONTEXT and LAST_ERROR_FUNCTION with
 670      the garbage collector.  */
 671   if (!initialized_p)
 672     {
 673       ggc_add_tree_root (&last_error_function_context, 1);
 674       ggc_add_tree_root (&last_error_function, 1);
 675       initialized_p = 1;
 676     }
 677
 678   if (current_function_decl != NULL
 679       && DECL_CONTEXT (current_function_decl) != last_error_function_context)
 680     {
 681       if (file)
 682         fprintf (stderr, "%s: ", file);
 683
 684       last_error_function_context = DECL_CONTEXT (current_function_decl);
 685       fprintf (stderr, "In class `%s':\n",
 686                lang_printable_name (last_error_function_context, 0));
 687     }
 688   if (last_error_function != current_function_decl)
 689     {
 690       if (file)
 691         fprintf (stderr, "%s: ", file);
 692
 693       if (current_function_decl == NULL)
 694         fprintf (stderr, "At top level:\n");
 695       else
 696         {
 697           const char *name = lang_printable_name (current_function_decl, 2);
 698           fprintf (stderr, "In %s `%s':\n",
 699                    (DECL_CONSTRUCTOR_P (current_function_decl) ? "constructor"
 700                     : "method"),
 701                    name);
 702         }
 703
 704       last_error_function = current_function_decl;
 705     }
 706
 707 }
 708
 709 /* This doesn't do anything on purpose. It's used to satisfy the
 710    print_error_function hook we don't print error messages with bogus
 711    function prototypes.  */
 712
 713 static void
 714 java_dummy_print (c, s)
 715      diagnostic_context *c __attribute__ ((__unused__));
 716      const char *s __attribute__ ((__unused__));
 717 {
 718 }
 719
 720 /* Called to install the PRINT_ERROR_FUNCTION hook differently
 721    according to LEVEL. LEVEL is 1 during early parsing, when function
 722    prototypes aren't fully resolved. print_error_function is set so it
 723    doesn't print incomplete function prototypes. When LEVEL is 2,
 724    function prototypes are fully resolved and can be printed when
 725    reporting errors.  */
 726
 727 void lang_init_source (level)
 728      int level;
 729 {
 730   if (level == 1)
 731     print_error_function = java_dummy_print;
 732   else
 733     print_error_function = lang_print_error;
 734 }
 735
 736 static void
 737 java_init_options ()
 738 {
 739   flag_bounds_check = 1;
 740   flag_exceptions = 1;
 741   flag_non_call_exceptions = 1;
 742 }