OSDN Git Service

* java-tree.h (all_class_filename): Remove useless macro.
[pf3gnuchains/gcc-fork.git] / gcc / java / parse.y
1 /* Source code parsing and tree node generation for the GNU compiler
2    for the Java(TM) language.
3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
4    Free Software Foundation, Inc.
5    Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING.  If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA.
23
24 Java and all Java-based marks are trademarks or registered trademarks
25 of Sun Microsystems, Inc. in the United States and other countries.
26 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
27
28 /* This file parses java source code and issues a tree node image
29 suitable for code generation (byte code and targeted CPU assembly
30 language).
31
32 The grammar conforms to the Java grammar described in "The Java(TM)
33 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
34 1996, ISBN 0-201-63451-1"
35
36 The following modifications were brought to the original grammar:
37
38 method_body: added the rule '| block SC_TK'
39 static_initializer: added the rule 'static block SC_TK'.
40
41 Note: All the extra rules described above should go away when the
42       empty_statement rule will work.
43
44 statement_nsi: 'nsi' should be read no_short_if.
45
46 Some rules have been modified to support JDK1.1 inner classes
47 definitions and other extensions.  */
48
49 %{
50 #include "config.h"
51 #include "system.h"
52 #include "coretypes.h"
53 #include "tm.h"
54 #include <dirent.h>
55 #include "tree.h"
56 #include "rtl.h"
57 #include "real.h"
58 #include "obstack.h"
59 #include "toplev.h"
60 #include "flags.h"
61 #include "java-tree.h"
62 #include "jcf.h"
63 #include "lex.h"
64 #include "parse.h"
65 #include "zipfile.h"
66 #include "convert.h"
67 #include "buffer.h"
68 #include "xref.h"
69 #include "function.h"
70 #include "except.h"
71 #include "ggc.h"
72 #include "debug.h"
73 #include "tree-inline.h"
74 #include "cgraph.h"
75 #include "target.h"
76
77 /* Local function prototypes */
78 static char *java_accstring_lookup (int);
79 static const char *accessibility_string (int);
80 static void  classitf_redefinition_error (const char *,tree, tree, tree);
81 static void  variable_redefinition_error (tree, tree, tree, int);
82 static tree  create_class (int, tree, tree, tree);
83 static tree  create_interface (int, tree, tree);
84 static void  end_class_declaration (int);
85 static tree  find_field (tree, tree);
86 static tree lookup_field_wrapper (tree, tree);
87 static int   duplicate_declaration_error_p (tree, tree, tree);
88 static void  register_fields (int, tree, tree);
89 static tree parser_qualified_classname (tree);
90 static int  parser_check_super (tree, tree, tree);
91 static int  parser_check_super_interface (tree, tree, tree);
92 static void check_modifiers_consistency (int);
93 static tree lookup_cl (tree);
94 static tree lookup_java_method2 (tree, tree, int);
95 static tree method_header (int, tree, tree, tree);
96 static void fix_method_argument_names (tree ,tree);
97 static tree method_declarator (tree, tree);
98 static void parse_warning_context (tree cl, const char *msg, ...)
99   ATTRIBUTE_PRINTF_2;
100 static void issue_warning_error_from_context (tree, const char *msg, va_list)
101   ATTRIBUTE_PRINTF (2, 0);
102 static void parse_ctor_invocation_error (void);
103 static tree parse_jdk1_1_error (const char *);
104 static void complete_class_report_errors (jdep *);
105 static int process_imports (void);
106 static void read_import_dir (tree);
107 static int find_in_imports_on_demand (tree, tree);
108 static void find_in_imports (tree, tree);
109 static void check_inner_class_access (tree, tree, tree);
110 static int check_pkg_class_access (tree, tree, bool, tree);
111 static void register_package (tree);
112 static tree resolve_package (tree, tree *, tree *);
113 static tree resolve_class (tree, tree, tree, tree);
114 static void declare_local_variables (int, tree, tree);
115 static void dump_java_tree (enum tree_dump_index, tree);
116 static void source_start_java_method (tree);
117 static void source_end_java_method (void);
118 static tree find_name_in_single_imports (tree);
119 static void check_abstract_method_header (tree);
120 static tree lookup_java_interface_method2 (tree, tree);
121 static tree resolve_expression_name (tree, tree *);
122 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
123 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
124 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
125 static tree resolve_and_layout (tree, tree);
126 static tree qualify_and_find (tree, tree, tree);
127 static tree resolve_no_layout (tree, tree);
128 static int invocation_mode (tree, int);
129 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
130 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
131 static tree find_most_specific_methods_list (tree);
132 static int argument_types_convertible (tree, tree);
133 static tree patch_invoke (tree, tree, tree);
134 static int maybe_use_access_method (int, tree *, tree *);
135 static tree lookup_method_invoke (int, tree, tree, tree, tree);
136 static tree register_incomplete_type (int, tree, tree, tree);
137 static tree check_inner_circular_reference (tree, tree);
138 static tree check_circular_reference (tree);
139 static tree obtain_incomplete_type (tree);
140 static tree java_complete_lhs (tree);
141 static tree java_complete_tree (tree);
142 static tree maybe_generate_pre_expand_clinit (tree);
143 static int analyze_clinit_body (tree, tree);
144 static int maybe_yank_clinit (tree);
145 static void start_complete_expand_method (tree);
146 static void java_complete_expand_method (tree);
147 static void java_expand_method_bodies (tree);
148 static int  unresolved_type_p (tree, tree *);
149 static void create_jdep_list (struct parser_ctxt *);
150 static tree build_expr_block (tree, tree);
151 static tree enter_block (void);
152 static tree exit_block (void);
153 static tree lookup_name_in_blocks (tree);
154 static void maybe_absorb_scoping_blocks (void);
155 static tree build_method_invocation (tree, tree);
156 static tree build_new_invocation (tree, tree);
157 static tree build_assignment (int, int, tree, tree);
158 static tree build_binop (enum tree_code, int, tree, tree);
159 static tree patch_assignment (tree, tree);
160 static tree patch_binop (tree, tree, tree);
161 static tree build_unaryop (int, int, tree);
162 static tree build_incdec (int, int, tree, int);
163 static tree patch_unaryop (tree, tree);
164 static tree build_cast (int, tree, tree);
165 static tree build_null_of_type (tree);
166 static tree patch_cast (tree, tree);
167 static int valid_ref_assignconv_cast_p (tree, tree, int);
168 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
169 static int valid_cast_to_p (tree, tree);
170 static int valid_method_invocation_conversion_p (tree, tree);
171 static tree try_builtin_assignconv (tree, tree, tree);
172 static tree try_reference_assignconv (tree, tree);
173 static tree build_unresolved_array_type (tree);
174 static int build_type_name_from_array_name (tree, tree *);
175 static tree build_array_from_name (tree, tree, tree, tree *);
176 static tree build_array_ref (int, tree, tree);
177 static tree patch_array_ref (tree);
178 static tree make_qualified_name (tree, tree, int);
179 static tree merge_qualified_name (tree, tree);
180 static tree make_qualified_primary (tree, tree, int);
181 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
182 static void qualify_ambiguous_name (tree);
183 static tree resolve_field_access (tree, tree *, tree *);
184 static tree build_newarray_node (tree, tree, int);
185 static tree patch_newarray (tree);
186 static tree resolve_type_during_patch (tree);
187 static tree build_this (int);
188 static tree build_wfl_wrap (tree, int);
189 static tree build_return (int, tree);
190 static tree patch_return (tree);
191 static tree maybe_access_field (tree, tree, tree);
192 static int complete_function_arguments (tree);
193 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
194 static int not_accessible_p (tree, tree, tree, int);
195 static void check_deprecation (tree, tree);
196 static int class_in_current_package (tree);
197 static tree build_if_else_statement (int, tree, tree, tree);
198 static tree patch_if_else_statement (tree);
199 static tree add_stmt_to_block (tree, tree, tree);
200 static tree patch_exit_expr (tree);
201 static tree build_labeled_block (int, tree);
202 static tree finish_labeled_statement (tree, tree);
203 static tree build_bc_statement (int, int, tree);
204 static tree patch_bc_statement (tree);
205 static tree patch_loop_statement (tree);
206 static tree build_new_loop (tree);
207 static tree build_loop_body (int, tree, int);
208 static tree finish_loop_body (int, tree, tree, int);
209 static tree build_debugable_stmt (int, tree);
210 static tree finish_for_loop (int, tree, tree, tree);
211 static tree patch_switch_statement (tree);
212 static tree string_constant_concatenation (tree, tree);
213 static tree build_string_concatenation (tree, tree);
214 static tree patch_string_cst (tree);
215 static tree patch_string (tree);
216 static tree encapsulate_with_try_catch (int, tree, tree, tree);
217 static tree build_assertion (int, tree, tree);
218 static tree build_try_statement (int, tree, tree);
219 static tree build_try_finally_statement (int, tree, tree);
220 static tree patch_try_statement (tree);
221 static tree patch_synchronized_statement (tree, tree);
222 static tree patch_throw_statement (tree, tree);
223 static void check_thrown_exceptions (int, tree, tree);
224 static int check_thrown_exceptions_do (tree);
225 static void purge_unchecked_exceptions (tree);
226 static bool ctors_unchecked_throws_clause_p (tree);
227 static void check_concrete_throws_clauses (tree, tree, tree, tree);
228 static void check_throws_clauses (tree, tree, tree);
229 static void finish_method_declaration (tree);
230 static tree build_super_invocation (tree);
231 static int verify_constructor_circularity (tree, tree);
232 static char *constructor_circularity_msg (tree, tree);
233 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
234 static const char *get_printable_method_name (tree);
235 static tree patch_conditional_expr (tree, tree, tree);
236 static tree generate_finit (tree);
237 static tree generate_instinit (tree);
238 static tree build_instinit_invocation (tree);
239 static void fix_constructors (tree);
240 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
241 static tree craft_constructor (tree, tree);
242 static int verify_constructor_super (tree);
243 static tree create_artificial_method (tree, int, tree, tree, tree);
244 static void start_artificial_method_body (tree);
245 static void end_artificial_method_body (tree);
246 static int check_method_redefinition (tree, tree);
247 static int check_method_types_complete (tree);
248 static bool hack_is_accessible_p (tree, tree);
249 static void java_check_regular_methods (tree);
250 static void check_interface_throws_clauses (tree, tree);
251 static void java_check_abstract_methods (tree);
252 static void unreachable_stmt_error (tree);
253 static int not_accessible_field_error (tree, tree);
254 static tree find_expr_with_wfl (tree);
255 static void missing_return_error (tree);
256 static tree build_new_array_init (int, tree);
257 static tree patch_new_array_init (tree, tree);
258 static tree maybe_build_array_element_wfl (tree);
259 static int array_constructor_check_entry (tree, tree);
260 static const char *purify_type_name (const char *);
261 static tree fold_constant_for_init (tree, tree);
262 static tree strip_out_static_field_access_decl (tree);
263 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
264 static void static_ref_err (tree, tree, tree);
265 static void parser_add_interface (tree, tree, tree);
266 static void add_superinterfaces (tree, tree);
267 static tree jdep_resolve_class (jdep *);
268 static int note_possible_classname (const char *, int);
269 static void java_complete_expand_classes (void);
270 static void java_complete_expand_class (tree);
271 static void java_complete_expand_methods (tree);
272 static tree cut_identifier_in_qualified (tree);
273 static tree java_stabilize_reference (tree);
274 static tree do_unary_numeric_promotion (tree);
275 static char * operator_string (tree);
276 static tree do_merge_string_cste (tree, const char *, int, int);
277 static tree merge_string_cste (tree, tree, int);
278 static tree java_refold (tree);
279 static int java_decl_equiv (tree, tree);
280 static int binop_compound_p (enum tree_code);
281 static tree search_loop (tree);
282 static int labeled_block_contains_loop_p (tree, tree);
283 static int check_abstract_method_definitions (int, tree, tree);
284 static void java_check_abstract_method_definitions (tree);
285 static void java_debug_context_do (int);
286 static void java_parser_context_push_initialized_field (void);
287 static void java_parser_context_pop_initialized_field (void);
288 static tree reorder_static_initialized (tree);
289 static void java_parser_context_suspend (void);
290 static void java_parser_context_resume (void);
291 static int pop_current_osb (struct parser_ctxt *);
292
293 /* JDK 1.1 work. FIXME */
294
295 static tree maybe_make_nested_class_name (tree);
296 static int make_nested_class_name (tree);
297 static void link_nested_class_to_enclosing (void);
298 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
299 static tree find_as_inner_class (tree, tree, tree);
300 static tree find_as_inner_class_do (tree, tree);
301 static int check_inner_class_redefinition (tree, tree);
302
303 static tree build_thisn_assign (void);
304 static tree build_current_thisn (tree);
305 static tree build_access_to_thisn (tree, tree, int);
306 static tree maybe_build_thisn_access_method (tree);
307
308 static tree build_outer_field_access (tree, tree);
309 static tree build_outer_field_access_methods (tree);
310 static tree build_outer_field_access_expr (int, tree, tree,
311                                                   tree, tree);
312 static tree build_outer_method_access_method (tree);
313 static tree build_new_access_id (void);
314 static tree build_outer_field_access_method (tree, tree, tree,
315                                                     tree, tree);
316
317 static int outer_field_access_p (tree, tree);
318 static int outer_field_expanded_access_p (tree, tree *,
319                                                  tree *, tree *);
320 static tree outer_field_access_fix (tree, tree, tree);
321 static tree build_incomplete_class_ref (int, tree);
322 static tree patch_incomplete_class_ref (tree);
323 static tree create_anonymous_class (tree);
324 static void patch_anonymous_class (tree, tree, tree);
325 static void add_inner_class_fields (tree, tree);
326
327 static tree build_dot_class_method (tree);
328 static tree build_dot_class_method_invocation (tree, tree);
329 static void create_new_parser_context (int);
330 static tree maybe_build_class_init_for_field (tree, tree);
331
332 static int attach_init_test_initialization_flags (void **, void *);
333 static int emit_test_initialization (void **, void *);
334
335 static char *string_convert_int_cst (tree);
336
337 /* Number of error found so far. */
338 int java_error_count;
339 /* Number of warning found so far. */
340 int java_warning_count;
341 /* Tell when not to fold, when doing xrefs */
342 int do_not_fold;
343 /* Cyclic inheritance report, as it can be set by layout_class */
344 const char *cyclic_inheritance_report;
345
346 /* The current parser context */
347 struct parser_ctxt *ctxp;
348
349 /* List of things that were analyzed for which code will be generated */
350 struct parser_ctxt *ctxp_for_generation = NULL;
351
352 /* binop_lookup maps token to tree_code. It is used where binary
353    operations are involved and required by the parser. RDIV_EXPR
354    covers both integral/floating point division. The code is changed
355    once the type of both operator is worked out.  */
356
357 static const enum tree_code binop_lookup[19] =
358   {
359     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
360     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
361     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
362     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
363     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
364    };
365 #define BINOP_LOOKUP(VALUE)                                             \
366   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
367
368 /* This is the end index for binary operators that can also be used
369    in compound assignments. */
370 #define BINOP_COMPOUND_CANDIDATES 11
371
372 /* The "$L" identifier we use to create labels.  */
373 static GTY(()) tree label_id;
374
375 /* The "StringBuffer" identifier used for the String `+' operator. */
376 static GTY(()) tree wfl_string_buffer;
377
378 /* The "append" identifier used for String `+' operator.  */
379 static GTY(()) tree wfl_append;
380
381 /* The "toString" identifier used for String `+' operator. */
382 static GTY(()) tree wfl_to_string;
383
384 /* The "java.lang" import qualified name.  */
385 static GTY(()) tree java_lang_id;
386
387 /* The generated `inst$' identifier used for generated enclosing
388    instance/field access functions.  */
389 static GTY(()) tree inst_id;
390
391 /* Context and flag for static blocks */
392 static GTY(()) tree current_static_block;
393
394 /* The generated `write_parm_value$' identifier.  */
395 static GTY(()) tree wpv_id;
396
397 /* The list of all packages we've seen so far */
398 static GTY(()) tree package_list;
399
400 /* Hold THIS for the scope of the current method decl.  */
401 static GTY(()) tree current_this;
402
403 /* Hold a list of catch clauses list. The first element of this list is
404    the list of the catch clauses of the currently analyzed try block. */
405 static GTY(()) tree currently_caught_type_list;
406
407 /* This holds a linked list of all the case labels for the current
408    switch statement.  It is only used when checking to see if there
409    are duplicate labels.  FIXME: probably this should just be attached
410    to the switch itself; then it could be referenced via
411    `ctxp->current_loop'.  */
412 static GTY(()) tree case_label_list;
413
414 /* Anonymous class counter. Will be reset to 1 every time a non
415    anonymous class gets created. */
416 static int anonymous_class_counter = 1;
417
418 static GTY(()) tree src_parse_roots[1];
419
420 /* All classes seen from source code */
421 #define gclass_list src_parse_roots[0]
422
423 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
424    line and point it out.  */
425 /* Should point out the one that don't fit. ASCII/unicode, going
426    backward. FIXME */
427
428 #define check_modifiers(__message, __value, __mask) do {        \
429   if ((__value) & ~(__mask))                                    \
430     {                                                           \
431       size_t i, remainder = (__value) & ~(__mask);              \
432       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
433         if ((1 << i) & remainder)                               \
434           parse_error_context (ctxp->modifier_ctx [i], (__message), \
435                                java_accstring_lookup (1 << i)); \
436     }                                                           \
437 } while (0)
438
439 %}
440
441 %union {
442   tree node;
443   int sub_token;
444   struct {
445     int token;
446     int location;
447   } operator;
448   int value;
449 }
450
451 %{
452 #include "lex.c"
453 %}
454
455 %pure_parser
456
457 /* Things defined here have to match the order of what's in the
458    binop_lookup table.  */
459
460 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
461 %token   LS_TK           SRS_TK          ZRS_TK
462 %token   AND_TK          XOR_TK          OR_TK
463 %token   BOOL_AND_TK BOOL_OR_TK
464 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
465
466 /* This maps to the same binop_lookup entry than the token above */
467
468 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
469 %token   REM_ASSIGN_TK
470 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
471 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
472
473
474 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
475
476 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
477 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
478 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
479 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
480 %token   MODIFIER_TK
481
482 /* Keep those two in order, too */
483 %token   DECR_TK INCR_TK
484
485 /* From now one, things can be in any order */
486
487 %token   DEFAULT_TK      IF_TK              THROW_TK
488 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
489 %token   THROWS_TK       BREAK_TK           IMPORT_TK
490 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
491 %token   VOID_TK         CATCH_TK           INTERFACE_TK
492 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
493 %token   SUPER_TK        WHILE_TK           CLASS_TK
494 %token   SWITCH_TK       CONST_TK           TRY_TK
495 %token   FOR_TK          NEW_TK             CONTINUE_TK
496 %token   GOTO_TK         PACKAGE_TK         THIS_TK
497 %token   ASSERT_TK
498
499 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
500 %token   CHAR_TK         INTEGRAL_TK
501
502 %token   FLOAT_TK        DOUBLE_TK          FP_TK
503
504 %token   ID_TK
505
506 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
507
508 %token   ASSIGN_ANY_TK   ASSIGN_TK
509 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
510
511 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
512 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
513
514 %type    <value>        modifiers MODIFIER_TK final synchronized
515
516 %type    <node>         super ID_TK identifier
517 %type    <node>         name simple_name qualified_name
518 %type    <node>         type_declaration compilation_unit
519                         field_declaration method_declaration extends_interfaces
520                         interfaces interface_type_list
521                         import_declarations package_declaration
522                         type_declarations interface_body
523                         interface_member_declaration constant_declaration
524                         interface_member_declarations interface_type
525                         abstract_method_declaration
526 %type    <node>         class_body_declaration class_member_declaration
527                         static_initializer constructor_declaration block
528 %type    <node>         class_body_declarations constructor_header
529 %type    <node>         class_or_interface_type class_type class_type_list
530                         constructor_declarator explicit_constructor_invocation
531 %type    <node>         dim_expr dim_exprs this_or_super throws
532
533 %type    <node>         variable_declarator_id variable_declarator
534                         variable_declarators variable_initializer
535                         variable_initializers constructor_body
536                         array_initializer
537
538 %type    <node>         class_body block_end constructor_block_end
539 %type    <node>         statement statement_without_trailing_substatement
540                         labeled_statement if_then_statement label_decl
541                         if_then_else_statement while_statement for_statement
542                         statement_nsi labeled_statement_nsi do_statement
543                         if_then_else_statement_nsi while_statement_nsi
544                         for_statement_nsi statement_expression_list for_init
545                         for_update statement_expression expression_statement
546                         primary_no_new_array expression primary
547                         array_creation_expression array_type
548                         class_instance_creation_expression field_access
549                         method_invocation array_access something_dot_new
550                         argument_list postfix_expression while_expression
551                         post_increment_expression post_decrement_expression
552                         unary_expression_not_plus_minus unary_expression
553                         pre_increment_expression pre_decrement_expression
554                         cast_expression
555                         multiplicative_expression additive_expression
556                         shift_expression relational_expression
557                         equality_expression and_expression
558                         exclusive_or_expression inclusive_or_expression
559                         conditional_and_expression conditional_or_expression
560                         conditional_expression assignment_expression
561                         left_hand_side assignment for_header for_begin
562                         constant_expression do_statement_begin empty_statement
563                         switch_statement synchronized_statement throw_statement
564                         try_statement assert_statement
565                         switch_expression switch_block
566                         catches catch_clause catch_clause_parameter finally
567                         anonymous_class_creation trap_overflow_corner_case
568 %type    <node>         return_statement break_statement continue_statement
569
570 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
571 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
572 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
573 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
574 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
575 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
576 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
577 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
578 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
579 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
580 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
581 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
582 %type    <operator>     NEW_TK ASSERT_TK
583
584 %type    <node>         method_body
585
586 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
587                         STRING_LIT_TK NULL_TK VOID_TK
588
589 %type    <node>         IF_TK WHILE_TK FOR_TK
590
591 %type    <node>         formal_parameter_list formal_parameter
592                         method_declarator method_header
593
594 %type    <node>         primitive_type reference_type type
595                         BOOLEAN_TK INTEGRAL_TK FP_TK
596
597 /* Added or modified JDK 1.1 rule types  */
598 %type    <node>         type_literals
599
600 %%
601 /* 19.2 Production from 2.3: The Syntactic Grammar  */
602 goal:  compilation_unit
603                 {}
604 ;
605
606 /* 19.3 Productions from 3: Lexical structure  */
607 literal:
608         INT_LIT_TK
609 |       FP_LIT_TK
610 |       BOOL_LIT_TK
611 |       CHAR_LIT_TK
612 |       STRING_LIT_TK
613 |       NULL_TK
614 ;
615
616 /* 19.4 Productions from 4: Types, Values and Variables  */
617 type:
618         primitive_type
619 |       reference_type
620 ;
621
622 primitive_type:
623         INTEGRAL_TK
624 |       FP_TK
625 |       BOOLEAN_TK
626 ;
627
628 reference_type:
629         class_or_interface_type
630 |       array_type
631 ;
632
633 class_or_interface_type:
634         name
635 ;
636
637 class_type:
638         class_or_interface_type /* Default rule */
639 ;
640
641 interface_type:
642          class_or_interface_type
643 ;
644
645 array_type:
646         primitive_type dims
647                 {
648                   int osb = pop_current_osb (ctxp);
649                   tree t = build_java_array_type (($1), -1);
650                   while (--osb)
651                     t = build_unresolved_array_type (t);
652                   $$ = t;
653                 }
654 |       name dims
655                 {
656                   int osb = pop_current_osb (ctxp);
657                   tree t = $1;
658                   while (osb--)
659                     t = build_unresolved_array_type (t);
660                   $$ = t;
661                 }
662 ;
663
664 /* 19.5 Productions from 6: Names  */
665 name:
666         simple_name             /* Default rule */
667 |       qualified_name          /* Default rule */
668 ;
669
670 simple_name:
671         identifier              /* Default rule */
672 ;
673
674 qualified_name:
675         name DOT_TK identifier
676                 { $$ = make_qualified_name ($1, $3, $2.location); }
677 ;
678
679 identifier:
680         ID_TK
681 ;
682
683 /* 19.6: Production from 7: Packages  */
684 compilation_unit:
685                 {$$ = NULL;}
686 |       package_declaration
687 |       import_declarations
688 |       type_declarations
689 |       package_declaration import_declarations
690 |       package_declaration type_declarations
691 |       import_declarations type_declarations
692 |       package_declaration import_declarations type_declarations
693 ;
694
695 import_declarations:
696         import_declaration
697                 {
698                   $$ = NULL;
699                 }
700 |       import_declarations import_declaration
701                 {
702                   $$ = NULL;
703                 }
704 ;
705
706 type_declarations:
707         type_declaration
708 |       type_declarations type_declaration
709 ;
710
711 package_declaration:
712         PACKAGE_TK name SC_TK
713                 {
714                   ctxp->package = EXPR_WFL_NODE ($2);
715                   register_package (ctxp->package);
716                 }
717 |       PACKAGE_TK error
718                 {yyerror ("Missing name"); RECOVER;}
719 |       PACKAGE_TK name error
720                 {yyerror ("';' expected"); RECOVER;}
721 ;
722
723 import_declaration:
724         single_type_import_declaration
725 |       type_import_on_demand_declaration
726 ;
727
728 single_type_import_declaration:
729         IMPORT_TK name SC_TK
730                 {
731                   tree name = EXPR_WFL_NODE ($2), last_name;
732                   int   i = IDENTIFIER_LENGTH (name)-1;
733                   const char *last = &IDENTIFIER_POINTER (name)[i];
734                   while (last != IDENTIFIER_POINTER (name))
735                     {
736                       if (last [0] == '.')
737                         break;
738                       last--;
739                     }
740                   last_name = get_identifier (++last);
741                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
742                     {
743                       tree err = find_name_in_single_imports (last_name);
744                       if (err && err != name)
745                         parse_error_context
746                           ($2, "Ambiguous class: `%s' and `%s'",
747                            IDENTIFIER_POINTER (name),
748                            IDENTIFIER_POINTER (err));
749                       else
750                         REGISTER_IMPORT ($2, last_name);
751                     }
752                   else
753                     REGISTER_IMPORT ($2, last_name);
754                 }
755 |       IMPORT_TK error
756                 {yyerror ("Missing name"); RECOVER;}
757 |       IMPORT_TK name error
758                 {yyerror ("';' expected"); RECOVER;}
759 ;
760
761 type_import_on_demand_declaration:
762         IMPORT_TK name DOT_TK MULT_TK SC_TK
763                 {
764                   tree name = EXPR_WFL_NODE ($2);
765                   tree it;
766                   /* Search for duplicates. */
767                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
768                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
769                       break;
770                   /* Don't import the same thing more than once, just ignore
771                      duplicates (7.5.2) */
772                   if (! it)
773                     {
774                       read_import_dir ($2);
775                       ctxp->import_demand_list =
776                         chainon (ctxp->import_demand_list,
777                                  build_tree_list ($2, NULL_TREE));
778                     }
779                 }
780 |       IMPORT_TK name DOT_TK error
781                 {yyerror ("'*' expected"); RECOVER;}
782 |       IMPORT_TK name DOT_TK MULT_TK error
783                 {yyerror ("';' expected"); RECOVER;}
784 ;
785
786 type_declaration:
787         class_declaration
788                 { end_class_declaration (0); }
789 |       interface_declaration
790                 { end_class_declaration (0); }
791 |       empty_statement
792 |       error
793                 {
794                   YYERROR_NOW;
795                   yyerror ("Class or interface declaration expected");
796                 }
797 ;
798
799 /* 19.7 Shortened from the original:
800    modifiers: modifier | modifiers modifier
801    modifier: any of public...  */
802 modifiers:
803         MODIFIER_TK
804                 {
805                   $$ = (1 << $1);
806                 }
807 |       modifiers MODIFIER_TK
808                 {
809                   int acc = (1 << $2);
810                   if ($$ & acc)
811                     parse_error_context
812                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
813                        java_accstring_lookup (acc));
814                   else
815                     {
816                       $$ |= acc;
817                     }
818                 }
819 ;
820
821 /* 19.8.1 Production from $8.1: Class Declaration */
822 class_declaration:
823         modifiers CLASS_TK identifier super interfaces
824                 { create_class ($1, $3, $4, $5); }
825         class_body
826                 {;}
827 |       CLASS_TK identifier super interfaces
828                 { create_class (0, $2, $3, $4); }
829         class_body
830                 {;}
831 |       modifiers CLASS_TK error
832                 { yyerror ("Missing class name"); RECOVER; }
833 |       CLASS_TK error
834                 { yyerror ("Missing class name"); RECOVER; }
835 |       CLASS_TK identifier error
836                 {
837                   if (!ctxp->class_err) yyerror ("'{' expected");
838                   DRECOVER(class1);
839                 }
840 |       modifiers CLASS_TK identifier error
841                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
842 ;
843
844 super:
845                 { $$ = NULL; }
846 |       EXTENDS_TK class_type
847                 { $$ = $2; }
848 |       EXTENDS_TK class_type error
849                 {yyerror ("'{' expected"); ctxp->class_err=1;}
850 |       EXTENDS_TK error
851                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
852 ;
853
854 interfaces:
855                 { $$ = NULL_TREE; }
856 |       IMPLEMENTS_TK interface_type_list
857                 { $$ = $2; }
858 |       IMPLEMENTS_TK error
859                 {
860                   ctxp->class_err=1;
861                   yyerror ("Missing interface name");
862                 }
863 ;
864
865 interface_type_list:
866         interface_type
867                 {
868                   ctxp->interface_number = 1;
869                   $$ = build_tree_list ($1, NULL_TREE);
870                 }
871 |       interface_type_list C_TK interface_type
872                 {
873                   ctxp->interface_number++;
874                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
875                 }
876 |       interface_type_list C_TK error
877                 {yyerror ("Missing interface name"); RECOVER;}
878 ;
879
880 class_body:
881         OCB_TK CCB_TK
882                 {
883                   /* Store the location of the `}' when doing xrefs */
884                   if (flag_emit_xref)
885                     DECL_END_SOURCE_LINE (GET_CPC ()) =
886                       EXPR_WFL_ADD_COL ($2.location, 1);
887                   $$ = GET_CPC ();
888                 }
889 |       OCB_TK class_body_declarations CCB_TK
890                 {
891                   /* Store the location of the `}' when doing xrefs */
892                   if (flag_emit_xref)
893                     DECL_END_SOURCE_LINE (GET_CPC ()) =
894                       EXPR_WFL_ADD_COL ($3.location, 1);
895                   $$ = GET_CPC ();
896                 }
897 ;
898
899 class_body_declarations:
900         class_body_declaration
901 |       class_body_declarations class_body_declaration
902 ;
903
904 class_body_declaration:
905         class_member_declaration
906 |       static_initializer
907 |       constructor_declaration
908 |       block                   /* Added, JDK1.1, instance initializer */
909                 {
910                   if (!IS_EMPTY_STMT ($1))
911                     {
912                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
913                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
914                     }
915                 }
916 ;
917
918 class_member_declaration:
919         field_declaration
920 |       method_declaration
921 |       class_declaration       /* Added, JDK1.1 inner classes */
922                 { end_class_declaration (1); }
923 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
924                 { end_class_declaration (1); }
925 |       empty_statement
926 ;
927
928 /* 19.8.2 Productions from 8.3: Field Declarations  */
929 field_declaration:
930         type variable_declarators SC_TK
931                 { register_fields (0, $1, $2); }
932 |       modifiers type variable_declarators SC_TK
933                 {
934                   check_modifiers
935                     ("Illegal modifier `%s' for field declaration",
936                      $1, FIELD_MODIFIERS);
937                   check_modifiers_consistency ($1);
938                   register_fields ($1, $2, $3);
939                 }
940 ;
941
942 variable_declarators:
943         /* Should we use build_decl_list () instead ? FIXME */
944         variable_declarator     /* Default rule */
945 |       variable_declarators C_TK variable_declarator
946                 { $$ = chainon ($1, $3); }
947 |       variable_declarators C_TK error
948                 {yyerror ("Missing term"); RECOVER;}
949 ;
950
951 variable_declarator:
952         variable_declarator_id
953                 { $$ = build_tree_list ($1, NULL_TREE); }
954 |       variable_declarator_id ASSIGN_TK variable_initializer
955                 {
956                   if (java_error_count)
957                     $3 = NULL_TREE;
958                   $$ = build_tree_list
959                     ($1, build_assignment ($2.token, $2.location, $1, $3));
960                 }
961 |       variable_declarator_id ASSIGN_TK error
962                 {
963                   yyerror ("Missing variable initializer");
964                   $$ = build_tree_list ($1, NULL_TREE);
965                   RECOVER;
966                 }
967 |       variable_declarator_id ASSIGN_TK variable_initializer error
968                 {
969                   yyerror ("';' expected");
970                   $$ = build_tree_list ($1, NULL_TREE);
971                   RECOVER;
972                 }
973 ;
974
975 variable_declarator_id:
976         identifier
977 |       variable_declarator_id OSB_TK CSB_TK
978                 { $$ = build_unresolved_array_type ($1); }
979 |       identifier error
980                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
981 |       variable_declarator_id OSB_TK error
982                 {
983                   yyerror ("']' expected");
984                   DRECOVER(vdi);
985                 }
986 |       variable_declarator_id CSB_TK error
987                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
988 ;
989
990 variable_initializer:
991         expression
992 |       array_initializer
993 ;
994
995 /* 19.8.3 Productions from 8.4: Method Declarations  */
996 method_declaration:
997         method_header
998                 {
999                   current_function_decl = $1;
1000                   if (current_function_decl
1001                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1002                     source_start_java_method (current_function_decl);
1003                   else
1004                     current_function_decl = NULL_TREE;
1005                 }
1006         method_body
1007                 { finish_method_declaration ($3); }
1008 |       method_header error
1009                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1010 ;
1011
1012 method_header:
1013         type method_declarator throws
1014                 { $$ = method_header (0, $1, $2, $3); }
1015 |       VOID_TK method_declarator throws
1016                 { $$ = method_header (0, void_type_node, $2, $3); }
1017 |       modifiers type method_declarator throws
1018                 { $$ = method_header ($1, $2, $3, $4); }
1019 |       modifiers VOID_TK method_declarator throws
1020                 { $$ = method_header ($1, void_type_node, $3, $4); }
1021 |       type error
1022                 {
1023                   yyerror ("Invalid method declaration, method name required");
1024                   RECOVER;
1025                 }
1026 |       modifiers type error
1027                 {
1028                   yyerror ("Identifier expected");
1029                   RECOVER;
1030                 }
1031 |       VOID_TK error
1032                 {
1033                   yyerror ("Identifier expected");
1034                   RECOVER;
1035                 }
1036 |       modifiers VOID_TK error
1037                 {
1038                   yyerror ("Identifier expected");
1039                   RECOVER;
1040                 }
1041 |       modifiers error
1042                 {
1043                   yyerror ("Invalid method declaration, return type required");
1044                   RECOVER;
1045                 }
1046 ;
1047
1048 method_declarator:
1049         identifier OP_TK CP_TK
1050                 {
1051                   ctxp->formal_parameter_number = 0;
1052                   $$ = method_declarator ($1, NULL_TREE);
1053                 }
1054 |       identifier OP_TK formal_parameter_list CP_TK
1055                 { $$ = method_declarator ($1, $3); }
1056 |       method_declarator OSB_TK CSB_TK
1057                 {
1058                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1059                   TREE_PURPOSE ($1) =
1060                     build_unresolved_array_type (TREE_PURPOSE ($1));
1061                   parse_warning_context
1062                     (wfl_operator,
1063                      "Discouraged form of returned type specification");
1064                 }
1065 |       identifier OP_TK error
1066                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1067 |       method_declarator OSB_TK error
1068                 {yyerror ("']' expected"); RECOVER;}
1069 ;
1070
1071 formal_parameter_list:
1072         formal_parameter
1073                 {
1074                   ctxp->formal_parameter_number = 1;
1075                 }
1076 |       formal_parameter_list C_TK formal_parameter
1077                 {
1078                   ctxp->formal_parameter_number += 1;
1079                   $$ = chainon ($1, $3);
1080                 }
1081 |       formal_parameter_list C_TK error
1082                 { yyerror ("Missing formal parameter term"); RECOVER; }
1083 ;
1084
1085 formal_parameter:
1086         type variable_declarator_id
1087                 {
1088                   $$ = build_tree_list ($2, $1);
1089                 }
1090 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1091                 {
1092                   $$ = build_tree_list ($3, $2);
1093                   ARG_FINAL_P ($$) = 1;
1094                 }
1095 |       type error
1096                 {
1097                   yyerror ("Missing identifier"); RECOVER;
1098                   $$ = NULL_TREE;
1099                 }
1100 |       final type error
1101                 {
1102                   yyerror ("Missing identifier"); RECOVER;
1103                   $$ = NULL_TREE;
1104                 }
1105 ;
1106
1107 final:
1108         modifiers
1109                 {
1110                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1111                                    $1, ACC_FINAL);
1112                   if ($1 != ACC_FINAL)
1113                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1114                 }
1115 ;
1116
1117 throws:
1118                 { $$ = NULL_TREE; }
1119 |       THROWS_TK class_type_list
1120                 { $$ = $2; }
1121 |       THROWS_TK error
1122                 {yyerror ("Missing class type term"); RECOVER;}
1123 ;
1124
1125 class_type_list:
1126         class_type
1127                 { $$ = build_tree_list ($1, $1); }
1128 |       class_type_list C_TK class_type
1129                 { $$ = tree_cons ($3, $3, $1); }
1130 |       class_type_list C_TK error
1131                 {yyerror ("Missing class type term"); RECOVER;}
1132 ;
1133
1134 method_body:
1135         block
1136 |       SC_TK { $$ = NULL_TREE; }
1137 ;
1138
1139 /* 19.8.4 Productions from 8.5: Static Initializers  */
1140 static_initializer:
1141         static block
1142                 {
1143                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1144                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1145                   current_static_block = NULL_TREE;
1146                 }
1147 ;
1148
1149 static:                         /* Test lval.sub_token here */
1150         modifiers
1151                 {
1152                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1153                   /* Can't have a static initializer in an innerclass */
1154                   if ($1 | ACC_STATIC &&
1155                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1156                     parse_error_context
1157                       (MODIFIER_WFL (STATIC_TK),
1158                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1159                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1160                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1161                 }
1162 ;
1163
1164 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1165 constructor_declaration:
1166         constructor_header
1167                 {
1168                   current_function_decl = $1;
1169                   source_start_java_method (current_function_decl);
1170                 }
1171         constructor_body
1172                 { finish_method_declaration ($3); }
1173 ;
1174
1175 constructor_header:
1176         constructor_declarator throws
1177                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1178 |       modifiers constructor_declarator throws
1179                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1180 ;
1181
1182 constructor_declarator:
1183         simple_name OP_TK CP_TK
1184                 {
1185                   ctxp->formal_parameter_number = 0;
1186                   $$ = method_declarator ($1, NULL_TREE);
1187                 }
1188 |       simple_name OP_TK formal_parameter_list CP_TK
1189                 { $$ = method_declarator ($1, $3); }
1190 ;
1191
1192 constructor_body:
1193         /* Unlike regular method, we always need a complete (empty)
1194            body so we can safely perform all the required code
1195            addition (super invocation and field initialization) */
1196         block_begin constructor_block_end
1197                 {
1198                   BLOCK_EXPR_BODY ($2) = build_java_empty_stmt ();
1199                   $$ = $2;
1200                 }
1201 |       block_begin explicit_constructor_invocation constructor_block_end
1202                 { $$ = $3; }
1203 |       block_begin block_statements constructor_block_end
1204                 { $$ = $3; }
1205 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1206                 { $$ = $4; }
1207 ;
1208
1209 constructor_block_end:
1210         block_end
1211 ;
1212
1213 /* Error recovery for that rule moved down expression_statement: rule.  */
1214 explicit_constructor_invocation:
1215         this_or_super OP_TK CP_TK SC_TK
1216                 {
1217                   $$ = build_method_invocation ($1, NULL_TREE);
1218                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1219                   $$ = java_method_add_stmt (current_function_decl, $$);
1220                 }
1221 |       this_or_super OP_TK argument_list CP_TK SC_TK
1222                 {
1223                   $$ = build_method_invocation ($1, $3);
1224                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1225                   $$ = java_method_add_stmt (current_function_decl, $$);
1226                 }
1227         /* Added, JDK1.1 inner classes. Modified because the rule
1228            'primary' couldn't work.  */
1229 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1230                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1231 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1232                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1233 ;
1234
1235 this_or_super:                  /* Added, simplifies error diagnostics */
1236         THIS_TK
1237                 {
1238                   tree wfl = build_wfl_node (this_identifier_node);
1239                   EXPR_WFL_LINECOL (wfl) = $1.location;
1240                   $$ = wfl;
1241                 }
1242 |       SUPER_TK
1243                 {
1244                   tree wfl = build_wfl_node (super_identifier_node);
1245                   EXPR_WFL_LINECOL (wfl) = $1.location;
1246                   $$ = wfl;
1247                 }
1248 ;
1249
1250 /* 19.9 Productions from 9: Interfaces  */
1251 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1252 interface_declaration:
1253         INTERFACE_TK identifier
1254                 { create_interface (0, $2, NULL_TREE); }
1255         interface_body
1256                 { ; }
1257 |       modifiers INTERFACE_TK identifier
1258                 { create_interface ($1, $3, NULL_TREE); }
1259         interface_body
1260                 { ; }
1261 |       INTERFACE_TK identifier extends_interfaces
1262                 { create_interface (0, $2, $3); }
1263         interface_body
1264                 { ; }
1265 |       modifiers INTERFACE_TK identifier extends_interfaces
1266                 { create_interface ($1, $3, $4); }
1267         interface_body
1268                 { ; }
1269 |       INTERFACE_TK identifier error
1270                 { yyerror ("'{' expected"); RECOVER; }
1271 |       modifiers INTERFACE_TK identifier error
1272                 { yyerror ("'{' expected"); RECOVER; }
1273 ;
1274
1275 extends_interfaces:
1276         EXTENDS_TK interface_type
1277                 {
1278                   ctxp->interface_number = 1;
1279                   $$ = build_tree_list ($2, NULL_TREE);
1280                 }
1281 |       extends_interfaces C_TK interface_type
1282                 {
1283                   ctxp->interface_number++;
1284                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1285                 }
1286 |       EXTENDS_TK error
1287                 {yyerror ("Invalid interface type"); RECOVER;}
1288 |       extends_interfaces C_TK error
1289                 {yyerror ("Missing term"); RECOVER;}
1290 ;
1291
1292 interface_body:
1293         OCB_TK CCB_TK
1294                 { $$ = NULL_TREE; }
1295 |       OCB_TK interface_member_declarations CCB_TK
1296                 { $$ = NULL_TREE; }
1297 ;
1298
1299 interface_member_declarations:
1300         interface_member_declaration
1301 |       interface_member_declarations interface_member_declaration
1302 ;
1303
1304 interface_member_declaration:
1305         constant_declaration
1306 |       abstract_method_declaration
1307 |       class_declaration       /* Added, JDK1.1 inner classes */
1308                 { end_class_declaration (1); }
1309 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1310                 { end_class_declaration (1); }
1311 ;
1312
1313 constant_declaration:
1314         field_declaration
1315 ;
1316
1317 abstract_method_declaration:
1318         method_header SC_TK
1319                 {
1320                   check_abstract_method_header ($1);
1321                   current_function_decl = NULL_TREE; /* FIXME ? */
1322                 }
1323 |       method_header error
1324                 {yyerror ("';' expected"); RECOVER;}
1325 ;
1326
1327 /* 19.10 Productions from 10: Arrays  */
1328 array_initializer:
1329         OCB_TK CCB_TK
1330                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1331 |       OCB_TK C_TK CCB_TK
1332                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1333 |       OCB_TK variable_initializers CCB_TK
1334                 { $$ = build_new_array_init ($1.location, $2); }
1335 |       OCB_TK variable_initializers C_TK CCB_TK
1336                 { $$ = build_new_array_init ($1.location, $2); }
1337 ;
1338
1339 variable_initializers:
1340         variable_initializer
1341                 {
1342                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1343                                   $1, NULL_TREE);
1344                 }
1345 |       variable_initializers C_TK variable_initializer
1346                 {
1347                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1348                 }
1349 |       variable_initializers C_TK error
1350                 {yyerror ("Missing term"); RECOVER;}
1351 ;
1352
1353 /* 19.11 Production from 14: Blocks and Statements  */
1354 block:
1355         block_begin block_end
1356                 { $$ = $2; }
1357 |       block_begin block_statements block_end
1358                 { $$ = $3; }
1359 ;
1360
1361 block_begin:
1362         OCB_TK
1363                 { enter_block (); }
1364 ;
1365
1366 block_end:
1367         CCB_TK
1368                 {
1369                   maybe_absorb_scoping_blocks ();
1370                   /* Store the location of the `}' when doing xrefs */
1371                   if (current_function_decl && flag_emit_xref)
1372                     DECL_END_SOURCE_LINE (current_function_decl) =
1373                       EXPR_WFL_ADD_COL ($1.location, 1);
1374                   $$ = exit_block ();
1375                   if (!BLOCK_SUBBLOCKS ($$))
1376                     BLOCK_SUBBLOCKS ($$) = build_java_empty_stmt ();
1377                 }
1378 ;
1379
1380 block_statements:
1381         block_statement
1382 |       block_statements block_statement
1383 ;
1384
1385 block_statement:
1386         local_variable_declaration_statement
1387 |       statement
1388                 { java_method_add_stmt (current_function_decl, $1); }
1389 |       class_declaration       /* Added, JDK1.1 local classes */
1390                 {
1391                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1392                   end_class_declaration (1);
1393                 }
1394 ;
1395
1396 local_variable_declaration_statement:
1397         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1398 ;
1399
1400 local_variable_declaration:
1401         type variable_declarators
1402                 { declare_local_variables (0, $1, $2); }
1403 |       final type variable_declarators /* Added, JDK1.1 final locals */
1404                 { declare_local_variables ($1, $2, $3); }
1405 ;
1406
1407 statement:
1408         statement_without_trailing_substatement
1409 |       labeled_statement
1410 |       if_then_statement
1411 |       if_then_else_statement
1412 |       while_statement
1413 |       for_statement
1414                 { $$ = exit_block (); }
1415 ;
1416
1417 statement_nsi:
1418         statement_without_trailing_substatement
1419 |       labeled_statement_nsi
1420 |       if_then_else_statement_nsi
1421 |       while_statement_nsi
1422 |       for_statement_nsi
1423                 { $$ = exit_block (); }
1424 ;
1425
1426 statement_without_trailing_substatement:
1427         block
1428 |       empty_statement
1429 |       expression_statement
1430 |       switch_statement
1431 |       do_statement
1432 |       break_statement
1433 |       continue_statement
1434 |       return_statement
1435 |       synchronized_statement
1436 |       throw_statement
1437 |       try_statement
1438 |       assert_statement
1439 ;
1440
1441 empty_statement:
1442         SC_TK
1443                 {
1444                   if (flag_extraneous_semicolon
1445                       && ! current_static_block
1446                       && (! current_function_decl ||
1447                           /* Verify we're not in a inner class declaration */
1448                           (GET_CPC () != TYPE_NAME
1449                            (DECL_CONTEXT (current_function_decl)))))
1450
1451                     {
1452                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1453                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1454                     }
1455                   $$ = build_java_empty_stmt ();
1456                 }
1457 ;
1458
1459 label_decl:
1460         identifier REL_CL_TK
1461                 {
1462                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1463                                             EXPR_WFL_NODE ($1));
1464                   pushlevel (2);
1465                   push_labeled_block ($$);
1466                   PUSH_LABELED_BLOCK ($$);
1467                 }
1468 ;
1469
1470 labeled_statement:
1471         label_decl statement
1472                 { $$ = finish_labeled_statement ($1, $2); }
1473 |       identifier error
1474                 {yyerror ("':' expected"); RECOVER;}
1475 ;
1476
1477 labeled_statement_nsi:
1478         label_decl statement_nsi
1479                 { $$ = finish_labeled_statement ($1, $2); }
1480 ;
1481
1482 /* We concentrate here a bunch of error handling rules that we couldn't write
1483    earlier, because expression_statement catches a missing ';'.  */
1484 expression_statement:
1485         statement_expression SC_TK
1486                 {
1487                   /* We have a statement. Generate a WFL around it so
1488                      we can debug it */
1489                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1490                   /* We know we have a statement, so set the debug
1491                      info to be eventually generate here. */
1492                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1493                 }
1494 |       error SC_TK
1495                 {
1496                   YYNOT_TWICE yyerror ("Invalid expression statement");
1497                   DRECOVER (expr_stmt);
1498                 }
1499 |       error OCB_TK
1500                 {
1501                   YYNOT_TWICE yyerror ("Invalid expression statement");
1502                   DRECOVER (expr_stmt);
1503                 }
1504 |       error CCB_TK
1505                 {
1506                   YYNOT_TWICE yyerror ("Invalid expression statement");
1507                   DRECOVER (expr_stmt);
1508                 }
1509 |       this_or_super OP_TK error
1510                 {yyerror ("')' expected"); RECOVER;}
1511 |       this_or_super OP_TK CP_TK error
1512                 {
1513                   parse_ctor_invocation_error ();
1514                   RECOVER;
1515                 }
1516 |       this_or_super OP_TK argument_list error
1517                 {yyerror ("')' expected"); RECOVER;}
1518 |       this_or_super OP_TK argument_list CP_TK error
1519                 {
1520                   parse_ctor_invocation_error ();
1521                   RECOVER;
1522                 }
1523 |       name DOT_TK SUPER_TK error
1524                 {yyerror ("'(' expected"); RECOVER;}
1525 |       name DOT_TK SUPER_TK OP_TK error
1526                 {yyerror ("')' expected"); RECOVER;}
1527 |       name DOT_TK SUPER_TK OP_TK argument_list error
1528                 {yyerror ("')' expected"); RECOVER;}
1529 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1530                 {yyerror ("';' expected"); RECOVER;}
1531 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1532                 {yyerror ("';' expected"); RECOVER;}
1533 ;
1534
1535 statement_expression:
1536         assignment
1537 |       pre_increment_expression
1538 |       pre_decrement_expression
1539 |       post_increment_expression
1540 |       post_decrement_expression
1541 |       method_invocation
1542 |       class_instance_creation_expression
1543 ;
1544
1545 if_then_statement:
1546         IF_TK OP_TK expression CP_TK statement
1547                 {
1548                   $$ = build_if_else_statement ($2.location, $3,
1549                                                 $5, NULL_TREE);
1550                 }
1551 |       IF_TK error
1552                 {yyerror ("'(' expected"); RECOVER;}
1553 |       IF_TK OP_TK error
1554                 {yyerror ("Missing term"); RECOVER;}
1555 |       IF_TK OP_TK expression error
1556                 {yyerror ("')' expected"); RECOVER;}
1557 ;
1558
1559 if_then_else_statement:
1560         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1561                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1562 ;
1563
1564 if_then_else_statement_nsi:
1565         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1566                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1567 ;
1568
1569 switch_statement:
1570         switch_expression
1571                 {
1572                   enter_block ();
1573                 }
1574         switch_block
1575                 {
1576                   /* Make into "proper list" of COMPOUND_EXPRs.
1577                      I.e. make the last statement also have its own
1578                      COMPOUND_EXPR. */
1579                   maybe_absorb_scoping_blocks ();
1580                   TREE_OPERAND ($1, 1) = exit_block ();
1581                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1582                 }
1583 ;
1584
1585 switch_expression:
1586         SWITCH_TK OP_TK expression CP_TK
1587                 {
1588                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE, NULL_TREE);
1589                   EXPR_WFL_LINECOL ($$) = $2.location;
1590                 }
1591 |       SWITCH_TK error
1592                 {yyerror ("'(' expected"); RECOVER;}
1593 |       SWITCH_TK OP_TK error
1594                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1595 |       SWITCH_TK OP_TK expression CP_TK error
1596                 {yyerror ("'{' expected"); RECOVER;}
1597 ;
1598
1599 /* Default assignment is there to avoid type node on switch_block
1600    node. */
1601
1602 switch_block:
1603         OCB_TK CCB_TK
1604                 { $$ = NULL_TREE; }
1605 |       OCB_TK switch_labels CCB_TK
1606                 { $$ = NULL_TREE; }
1607 |       OCB_TK switch_block_statement_groups CCB_TK
1608                 { $$ = NULL_TREE; }
1609 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1610                 { $$ = NULL_TREE; }
1611 ;
1612
1613 switch_block_statement_groups:
1614         switch_block_statement_group
1615 |       switch_block_statement_groups switch_block_statement_group
1616 ;
1617
1618 switch_block_statement_group:
1619         switch_labels block_statements
1620 ;
1621
1622 switch_labels:
1623         switch_label
1624 |       switch_labels switch_label
1625 ;
1626
1627 switch_label:
1628         CASE_TK constant_expression REL_CL_TK
1629                 {
1630                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1631                   EXPR_WFL_LINECOL (lab) = $1.location;
1632                   java_method_add_stmt (current_function_decl, lab);
1633                 }
1634 |       DEFAULT_TK REL_CL_TK
1635                 {
1636                   tree lab = make_node (DEFAULT_EXPR);
1637                   EXPR_WFL_LINECOL (lab) = $1.location;
1638                   java_method_add_stmt (current_function_decl, lab);
1639                 }
1640 |       CASE_TK error
1641                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1642 |       CASE_TK constant_expression error
1643                 {yyerror ("':' expected"); RECOVER;}
1644 |       DEFAULT_TK error
1645                 {yyerror ("':' expected"); RECOVER;}
1646 ;
1647
1648 while_expression:
1649         WHILE_TK OP_TK expression CP_TK
1650                 {
1651                   tree body = build_loop_body ($2.location, $3, 0);
1652                   $$ = build_new_loop (body);
1653                 }
1654 ;
1655
1656 while_statement:
1657         while_expression statement
1658                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1659 |       WHILE_TK error
1660                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1661 |       WHILE_TK OP_TK error
1662                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1663 |       WHILE_TK OP_TK expression error
1664                 {yyerror ("')' expected"); RECOVER;}
1665 ;
1666
1667 while_statement_nsi:
1668         while_expression statement_nsi
1669                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1670 ;
1671
1672 do_statement_begin:
1673         DO_TK
1674                 {
1675                   tree body = build_loop_body (0, NULL_TREE, 1);
1676                   $$ = build_new_loop (body);
1677                 }
1678         /* Need error handing here. FIXME */
1679 ;
1680
1681 do_statement:
1682         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1683                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1684 ;
1685
1686 for_statement:
1687         for_begin SC_TK expression SC_TK for_update CP_TK statement
1688                 {
1689                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1690                     $3 = build_wfl_node ($3);
1691                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1692                 }
1693 |       for_begin SC_TK SC_TK for_update CP_TK statement
1694                 {
1695                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1696                   /* We have not condition, so we get rid of the EXIT_EXPR */
1697                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1698                     build_java_empty_stmt ();
1699                 }
1700 |       for_begin SC_TK error
1701                 {yyerror ("Invalid control expression"); RECOVER;}
1702 |       for_begin SC_TK expression SC_TK error
1703                 {yyerror ("Invalid update expression"); RECOVER;}
1704 |       for_begin SC_TK SC_TK error
1705                 {yyerror ("Invalid update expression"); RECOVER;}
1706 ;
1707
1708 for_statement_nsi:
1709         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1710                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1711 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1712                 {
1713                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1714                   /* We have not condition, so we get rid of the EXIT_EXPR */
1715                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1716                     build_java_empty_stmt ();
1717                 }
1718 ;
1719
1720 for_header:
1721         FOR_TK OP_TK
1722                 {
1723                   /* This scope defined for local variable that may be
1724                      defined within the scope of the for loop */
1725                   enter_block ();
1726                 }
1727 |       FOR_TK error
1728                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1729 |       FOR_TK OP_TK error
1730                 {yyerror ("Invalid init statement"); RECOVER;}
1731 ;
1732
1733 for_begin:
1734         for_header for_init
1735                 {
1736                   /* We now declare the loop body. The loop is
1737                      declared as a for loop. */
1738                   tree body = build_loop_body (0, NULL_TREE, 0);
1739                   $$ =  build_new_loop (body);
1740                   FOR_LOOP_P ($$) = 1;
1741                   /* The loop is added to the current block the for
1742                      statement is defined within */
1743                   java_method_add_stmt (current_function_decl, $$);
1744                 }
1745 ;
1746 for_init:                       /* Can be empty */
1747                 { $$ = build_java_empty_stmt (); }
1748 |       statement_expression_list
1749                 {
1750                   /* Init statement recorded within the previously
1751                      defined block scope */
1752                   $$ = java_method_add_stmt (current_function_decl, $1);
1753                 }
1754 |       local_variable_declaration
1755                 {
1756                   /* Local variable are recorded within the previously
1757                      defined block scope */
1758                   $$ = NULL_TREE;
1759                 }
1760 |       statement_expression_list error
1761                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1762 ;
1763
1764 for_update:                     /* Can be empty */
1765                 {$$ = build_java_empty_stmt ();}
1766 |       statement_expression_list
1767                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1768 ;
1769
1770 statement_expression_list:
1771         statement_expression
1772                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1773 |       statement_expression_list C_TK statement_expression
1774                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1775 |       statement_expression_list C_TK error
1776                 {yyerror ("Missing term"); RECOVER;}
1777 ;
1778
1779 break_statement:
1780         BREAK_TK SC_TK
1781                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1782 |       BREAK_TK identifier SC_TK
1783                 { $$ = build_bc_statement ($1.location, 1, $2); }
1784 |       BREAK_TK error
1785                 {yyerror ("Missing term"); RECOVER;}
1786 |       BREAK_TK identifier error
1787                 {yyerror ("';' expected"); RECOVER;}
1788 ;
1789
1790 continue_statement:
1791         CONTINUE_TK SC_TK
1792                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1793 |       CONTINUE_TK identifier SC_TK
1794                 { $$ = build_bc_statement ($1.location, 0, $2); }
1795 |       CONTINUE_TK error
1796                 {yyerror ("Missing term"); RECOVER;}
1797 |       CONTINUE_TK identifier error
1798                 {yyerror ("';' expected"); RECOVER;}
1799 ;
1800
1801 return_statement:
1802         RETURN_TK SC_TK
1803                 { $$ = build_return ($1.location, NULL_TREE); }
1804 |       RETURN_TK expression SC_TK
1805                 { $$ = build_return ($1.location, $2); }
1806 |       RETURN_TK error
1807                 {yyerror ("Missing term"); RECOVER;}
1808 |       RETURN_TK expression error
1809                 {yyerror ("';' expected"); RECOVER;}
1810 ;
1811
1812 throw_statement:
1813         THROW_TK expression SC_TK
1814                 {
1815                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1816                   EXPR_WFL_LINECOL ($$) = $1.location;
1817                 }
1818 |       THROW_TK error
1819                 {yyerror ("Missing term"); RECOVER;}
1820 |       THROW_TK expression error
1821                 {yyerror ("';' expected"); RECOVER;}
1822 ;
1823
1824 assert_statement:
1825         ASSERT_TK expression REL_CL_TK expression SC_TK
1826                 {
1827                   $$ = build_assertion ($1.location, $2, $4);
1828                 }
1829 |       ASSERT_TK expression SC_TK
1830                 {
1831                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1832                 }
1833 |       ASSERT_TK error
1834                 {yyerror ("Missing term"); RECOVER;}
1835 |       ASSERT_TK expression error
1836                 {yyerror ("';' expected"); RECOVER;}
1837 ;
1838
1839 synchronized_statement:
1840         synchronized OP_TK expression CP_TK block
1841                 {
1842                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1843                   EXPR_WFL_LINECOL ($$) =
1844                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1845                 }
1846 |       synchronized OP_TK expression CP_TK error
1847                 {yyerror ("'{' expected"); RECOVER;}
1848 |       synchronized error
1849                 {yyerror ("'(' expected"); RECOVER;}
1850 |       synchronized OP_TK error CP_TK
1851                 {yyerror ("Missing term"); RECOVER;}
1852 |       synchronized OP_TK error
1853                 {yyerror ("Missing term"); RECOVER;}
1854 ;
1855
1856 synchronized:
1857         modifiers
1858                 {
1859                   check_modifiers (
1860              "Illegal modifier `%s'. Only `synchronized' was expected here",
1861                                    $1, ACC_SYNCHRONIZED);
1862                   if ($1 != ACC_SYNCHRONIZED)
1863                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1864                       build_wfl_node (NULL_TREE);
1865                 }
1866 ;
1867
1868 try_statement:
1869         TRY_TK block catches
1870                 { $$ = build_try_statement ($1.location, $2, $3); }
1871 |       TRY_TK block finally
1872                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1873 |       TRY_TK block catches finally
1874                 { $$ = build_try_finally_statement
1875                     ($1.location, build_try_statement ($1.location,
1876                                                        $2, $3), $4);
1877                 }
1878 |       TRY_TK error
1879                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1880 ;
1881
1882 catches:
1883         catch_clause
1884 |       catches catch_clause
1885                 {
1886                   TREE_CHAIN ($2) = $1;
1887                   $$ = $2;
1888                 }
1889 ;
1890
1891 catch_clause:
1892         catch_clause_parameter block
1893                 {
1894                   java_method_add_stmt (current_function_decl, $2);
1895                   exit_block ();
1896                   $$ = $1;
1897                 }
1898 ;
1899
1900 catch_clause_parameter:
1901         CATCH_TK OP_TK formal_parameter CP_TK
1902                 {
1903                   /* We add a block to define a scope for
1904                      formal_parameter (CCBP). The formal parameter is
1905                      declared initialized by the appropriate function
1906                      call */
1907                   tree ccpb;
1908                   tree init;
1909                   if ($3)
1910                     {
1911                       ccpb = enter_block ();
1912                       init = build_assignment
1913                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1914                          build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1915                       declare_local_variables (0, TREE_VALUE ($3),
1916                                                build_tree_list 
1917                                                (TREE_PURPOSE ($3), init));
1918                       $$ = build1 (JAVA_CATCH_EXPR, NULL_TREE, ccpb);
1919                       EXPR_WFL_LINECOL ($$) = $1.location;
1920                     }
1921                   else
1922                     {
1923                       $$ = error_mark_node;
1924                     }
1925                 }
1926 |       CATCH_TK error
1927                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1928 |       CATCH_TK OP_TK error
1929                 {
1930                   yyerror ("Missing term or ')' expected");
1931                   RECOVER; $$ = NULL_TREE;
1932                 }
1933 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1934                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1935 ;
1936
1937 finally:
1938         FINALLY_TK block
1939                 { $$ = $2; }
1940 |       FINALLY_TK error
1941                 {yyerror ("'{' expected"); RECOVER; }
1942 ;
1943
1944 /* 19.12 Production from 15: Expressions  */
1945 primary:
1946         primary_no_new_array
1947 |       array_creation_expression
1948 ;
1949
1950 primary_no_new_array:
1951         literal
1952 |       THIS_TK
1953                 { $$ = build_this ($1.location); }
1954 |       OP_TK expression CP_TK
1955                 {$$ = $2;}
1956 |       class_instance_creation_expression
1957 |       field_access
1958 |       method_invocation
1959 |       array_access
1960 |       type_literals
1961         /* Added, JDK1.1 inner classes. Documentation is wrong
1962            refering to a 'ClassName' (class_name) rule that doesn't
1963            exist. Used name: instead.  */
1964 |       name DOT_TK THIS_TK
1965                 {
1966                   tree wfl = build_wfl_node (this_identifier_node);
1967                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1968                 }
1969 |       OP_TK expression error
1970                 {yyerror ("')' expected"); RECOVER;}
1971 |       name DOT_TK error
1972                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1973 |       primitive_type DOT_TK error
1974                 {yyerror ("'class' expected" ); RECOVER;}
1975 |       VOID_TK DOT_TK error
1976                 {yyerror ("'class' expected" ); RECOVER;}
1977 ;
1978
1979 type_literals:
1980         name DOT_TK CLASS_TK
1981                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1982 |       array_type DOT_TK CLASS_TK
1983                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1984 |       primitive_type DOT_TK CLASS_TK
1985                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1986 |       VOID_TK DOT_TK CLASS_TK
1987                 {
1988                    $$ = build_incomplete_class_ref ($2.location,
1989                                                    void_type_node);
1990                 }
1991 ;
1992
1993 class_instance_creation_expression:
1994         NEW_TK class_type OP_TK argument_list CP_TK
1995                 { $$ = build_new_invocation ($2, $4); }
1996 |       NEW_TK class_type OP_TK CP_TK
1997                 { $$ = build_new_invocation ($2, NULL_TREE); }
1998 |       anonymous_class_creation
1999         /* Added, JDK1.1 inner classes, modified to use name or
2000            primary instead of primary solely which couldn't work in
2001            all situations.  */
2002 |       something_dot_new identifier OP_TK CP_TK
2003                 {
2004                   tree ctor = build_new_invocation ($2, NULL_TREE);
2005                   $$ = make_qualified_primary ($1, ctor,
2006                                                EXPR_WFL_LINECOL ($1));
2007                 }
2008 |       something_dot_new identifier OP_TK CP_TK class_body
2009 |       something_dot_new identifier OP_TK argument_list CP_TK
2010                 {
2011                   tree ctor = build_new_invocation ($2, $4);
2012                   $$ = make_qualified_primary ($1, ctor,
2013                                                EXPR_WFL_LINECOL ($1));
2014                 }
2015 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2016 |       NEW_TK error SC_TK
2017                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2018 |       NEW_TK class_type error
2019                 {yyerror ("'(' expected"); RECOVER;}
2020 |       NEW_TK class_type OP_TK error
2021                 {yyerror ("')' or term expected"); RECOVER;}
2022 |       NEW_TK class_type OP_TK argument_list error
2023                 {yyerror ("')' expected"); RECOVER;}
2024 |       something_dot_new error
2025                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2026 |       something_dot_new identifier error
2027                 {yyerror ("'(' expected"); RECOVER;}
2028 ;
2029
2030 /* Created after JDK1.1 rules originally added to
2031    class_instance_creation_expression, but modified to use
2032    'class_type' instead of 'TypeName' (type_name) which is mentioned
2033    in the documentation but doesn't exist. */
2034
2035 anonymous_class_creation:
2036         NEW_TK class_type OP_TK argument_list CP_TK
2037                 { create_anonymous_class ($2); }
2038         class_body
2039                 {
2040                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2041                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2042
2043                   end_class_declaration (1);
2044
2045                   /* Now we can craft the new expression */
2046                   $$ = build_new_invocation (id, $4);
2047
2048                   /* Note that we can't possibly be here if
2049                      `class_type' is an interface (in which case the
2050                      anonymous class extends Object and implements
2051                      `class_type', hence its constructor can't have
2052                      arguments.) */
2053
2054                   /* Otherwise, the innerclass must feature a
2055                      constructor matching `argument_list'. Anonymous
2056                      classes are a bit special: it's impossible to
2057                      define constructor for them, hence constructors
2058                      must be generated following the hints provided by
2059                      the `new' expression. Whether a super constructor
2060                      of that nature exists or not is to be verified
2061                      later on in verify_constructor_super.
2062
2063                      It's during the expansion of a `new' statement
2064                      refering to an anonymous class that a ctor will
2065                      be generated for the anonymous class, with the
2066                      right arguments. */
2067
2068                 }
2069 |       NEW_TK class_type OP_TK CP_TK
2070                 { create_anonymous_class ($2); }
2071         class_body
2072                 {
2073                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2074                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2075
2076                   end_class_declaration (1);
2077
2078                   /* Now we can craft the new expression. The
2079                      statement doesn't need to be remember so that a
2080                      constructor can be generated, since its signature
2081                      is already known. */
2082                   $$ = build_new_invocation (id, NULL_TREE);
2083                 }
2084 ;
2085
2086 something_dot_new:              /* Added, not part of the specs. */
2087         name DOT_TK NEW_TK
2088                 { $$ = $1; }
2089 |       primary DOT_TK NEW_TK
2090                 { $$ = $1; }
2091 ;
2092
2093 argument_list:
2094         expression
2095                 {
2096                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2097                   ctxp->formal_parameter_number = 1;
2098                 }
2099 |       argument_list C_TK expression
2100                 {
2101                   ctxp->formal_parameter_number += 1;
2102                   $$ = tree_cons (NULL_TREE, $3, $1);
2103                 }
2104 |       argument_list C_TK error
2105                 {yyerror ("Missing term"); RECOVER;}
2106 ;
2107
2108 array_creation_expression:
2109         NEW_TK primitive_type dim_exprs
2110                 { $$ = build_newarray_node ($2, $3, 0); }
2111 |       NEW_TK class_or_interface_type dim_exprs
2112                 { $$ = build_newarray_node ($2, $3, 0); }
2113 |       NEW_TK primitive_type dim_exprs dims
2114                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2115 |       NEW_TK class_or_interface_type dim_exprs dims
2116                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2117         /* Added, JDK1.1 anonymous array. Initial documentation rule
2118            modified */
2119 |       NEW_TK class_or_interface_type dims array_initializer
2120                 {
2121                   char *sig;
2122                   int osb = pop_current_osb (ctxp);
2123                   while (osb--)
2124                     obstack_grow (&temporary_obstack, "[]", 2);
2125                   obstack_1grow (&temporary_obstack, '\0');
2126                   sig = obstack_finish (&temporary_obstack);
2127                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2128                               $2, get_identifier (sig), $4);
2129                 }
2130 |       NEW_TK primitive_type dims array_initializer
2131                 {
2132                   int osb = pop_current_osb (ctxp);
2133                   tree type = $2;
2134                   while (osb--)
2135                     type = build_java_array_type (type, -1);
2136                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2137                               build_pointer_type (type), NULL_TREE, $4);
2138                 }
2139 |       NEW_TK error CSB_TK
2140                 {yyerror ("'[' expected"); DRECOVER ("]");}
2141 |       NEW_TK error OSB_TK
2142                 {yyerror ("']' expected"); RECOVER;}
2143 ;
2144
2145 dim_exprs:
2146         dim_expr
2147                 { $$ = build_tree_list (NULL_TREE, $1); }
2148 |       dim_exprs dim_expr
2149                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2150 ;
2151
2152 dim_expr:
2153         OSB_TK expression CSB_TK
2154                 {
2155                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2156                     {
2157                       $2 = build_wfl_node ($2);
2158                       TREE_TYPE ($2) = NULL_TREE;
2159                     }
2160                   EXPR_WFL_LINECOL ($2) = $1.location;
2161                   $$ = $2;
2162                 }
2163 |       OSB_TK expression error
2164                 {yyerror ("']' expected"); RECOVER;}
2165 |       OSB_TK error
2166                 {
2167                   yyerror ("Missing term");
2168                   yyerror ("']' expected");
2169                   RECOVER;
2170                 }
2171 ;
2172
2173 dims:
2174         OSB_TK CSB_TK
2175                 {
2176                   int allocate = 0;
2177                   /* If not initialized, allocate memory for the osb
2178                      numbers stack */
2179                   if (!ctxp->osb_limit)
2180                     {
2181                       allocate = ctxp->osb_limit = 32;
2182                       ctxp->osb_depth = -1;
2183                     }
2184                   /* If capacity overflown, reallocate a bigger chunk */
2185                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2186                     allocate = ctxp->osb_limit << 1;
2187
2188                   if (allocate)
2189                     {
2190                       allocate *= sizeof (int);
2191                       if (ctxp->osb_number)
2192                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2193                                                      allocate);
2194                       else
2195                         ctxp->osb_number = xmalloc (allocate);
2196                     }
2197                   ctxp->osb_depth++;
2198                   CURRENT_OSB (ctxp) = 1;
2199                 }
2200 |       dims OSB_TK CSB_TK
2201                 { CURRENT_OSB (ctxp)++; }
2202 |       dims OSB_TK error
2203                 { yyerror ("']' expected"); RECOVER;}
2204 ;
2205
2206 field_access:
2207         primary DOT_TK identifier
2208                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2209                 /*  FIXME - REWRITE TO:
2210                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2211 |       SUPER_TK DOT_TK identifier
2212                 {
2213                   tree super_wfl = build_wfl_node (super_identifier_node);
2214                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2215                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2216                 }
2217 |       SUPER_TK error
2218                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2219 ;
2220
2221 method_invocation:
2222         name OP_TK CP_TK
2223                 { $$ = build_method_invocation ($1, NULL_TREE); }
2224 |       name OP_TK argument_list CP_TK
2225                 { $$ = build_method_invocation ($1, $3); }
2226 |       primary DOT_TK identifier OP_TK CP_TK
2227                 {
2228                   if (TREE_CODE ($1) == THIS_EXPR)
2229                     $$ = build_this_super_qualified_invocation
2230                       (1, $3, NULL_TREE, 0, $2.location);
2231                   else
2232                     {
2233                       tree invok = build_method_invocation ($3, NULL_TREE);
2234                       $$ = make_qualified_primary ($1, invok, $2.location);
2235                     }
2236                 }
2237 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2238                 {
2239                   if (TREE_CODE ($1) == THIS_EXPR)
2240                     $$ = build_this_super_qualified_invocation
2241                       (1, $3, $5, 0, $2.location);
2242                   else
2243                     {
2244                       tree invok = build_method_invocation ($3, $5);
2245                       $$ = make_qualified_primary ($1, invok, $2.location);
2246                     }
2247                 }
2248 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2249                 {
2250                   $$ = build_this_super_qualified_invocation
2251                     (0, $3, NULL_TREE, $1.location, $2.location);
2252                 }
2253 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2254                 {
2255                   $$ = build_this_super_qualified_invocation
2256                     (0, $3, $5, $1.location, $2.location);
2257                 }
2258         /* Screws up thing. I let it here until I'm convinced it can
2259            be removed. FIXME
2260 |       primary DOT_TK error
2261                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2262 |       SUPER_TK DOT_TK error CP_TK
2263                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2264 |       SUPER_TK DOT_TK error DOT_TK
2265                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2266 ;
2267
2268 array_access:
2269         name OSB_TK expression CSB_TK
2270                 { $$ = build_array_ref ($2.location, $1, $3); }
2271 |       primary_no_new_array OSB_TK expression CSB_TK
2272                 { $$ = build_array_ref ($2.location, $1, $3); }
2273 |       name OSB_TK error
2274                 {
2275                   yyerror ("Missing term and ']' expected");
2276                   DRECOVER(array_access);
2277                 }
2278 |       name OSB_TK expression error
2279                 {
2280                   yyerror ("']' expected");
2281                   DRECOVER(array_access);
2282                 }
2283 |       primary_no_new_array OSB_TK error
2284                 {
2285                   yyerror ("Missing term and ']' expected");
2286                   DRECOVER(array_access);
2287                 }
2288 |       primary_no_new_array OSB_TK expression error
2289                 {
2290                   yyerror ("']' expected");
2291                   DRECOVER(array_access);
2292                 }
2293 ;
2294
2295 postfix_expression:
2296         primary
2297 |       name
2298 |       post_increment_expression
2299 |       post_decrement_expression
2300 ;
2301
2302 post_increment_expression:
2303         postfix_expression INCR_TK
2304                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2305 ;
2306
2307 post_decrement_expression:
2308         postfix_expression DECR_TK
2309                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2310 ;
2311
2312 trap_overflow_corner_case:
2313         pre_increment_expression
2314 |       pre_decrement_expression
2315 |       PLUS_TK unary_expression
2316                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2317 |       unary_expression_not_plus_minus
2318 |       PLUS_TK error
2319                 {yyerror ("Missing term"); RECOVER}
2320 ;
2321
2322 unary_expression:
2323         trap_overflow_corner_case
2324                 {
2325                   error_if_numeric_overflow ($1);
2326                   $$ = $1;
2327                 }
2328 |       MINUS_TK trap_overflow_corner_case
2329                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2330 |       MINUS_TK error
2331                 {yyerror ("Missing term"); RECOVER}
2332 ;
2333
2334 pre_increment_expression:
2335         INCR_TK unary_expression
2336                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2337 |       INCR_TK error
2338                 {yyerror ("Missing term"); RECOVER}
2339 ;
2340
2341 pre_decrement_expression:
2342         DECR_TK unary_expression
2343                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2344 |       DECR_TK error
2345                 {yyerror ("Missing term"); RECOVER}
2346 ;
2347
2348 unary_expression_not_plus_minus:
2349         postfix_expression
2350 |       NOT_TK unary_expression
2351                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2352 |       NEG_TK unary_expression
2353                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2354 |       cast_expression
2355 |       NOT_TK error
2356                 {yyerror ("Missing term"); RECOVER}
2357 |       NEG_TK error
2358                 {yyerror ("Missing term"); RECOVER}
2359 ;
2360
2361 cast_expression:                /* Error handling here is potentially weak */
2362         OP_TK primitive_type dims CP_TK unary_expression
2363                 {
2364                   tree type = $2;
2365                   int osb = pop_current_osb (ctxp);
2366                   while (osb--)
2367                     type = build_java_array_type (type, -1);
2368                   $$ = build_cast ($1.location, type, $5);
2369                 }
2370 |       OP_TK primitive_type CP_TK unary_expression
2371                 { $$ = build_cast ($1.location, $2, $4); }
2372 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2373                 { $$ = build_cast ($1.location, $2, $4); }
2374 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2375                 {
2376                   const char *ptr;
2377                   int osb = pop_current_osb (ctxp);
2378                   obstack_grow (&temporary_obstack,
2379                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2380                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2381                   while (osb--)
2382                     obstack_grow (&temporary_obstack, "[]", 2);
2383                   obstack_1grow (&temporary_obstack, '\0');
2384                   ptr = obstack_finish (&temporary_obstack);
2385                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2386                   $$ = build_cast ($1.location, $2, $5);
2387                 }
2388 |       OP_TK primitive_type OSB_TK error
2389                 {yyerror ("']' expected, invalid type expression");}
2390 |       OP_TK error
2391                 {
2392                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2393                   RECOVER;
2394                 }
2395 |       OP_TK primitive_type dims CP_TK error
2396                 {yyerror ("Missing term"); RECOVER;}
2397 |       OP_TK primitive_type CP_TK error
2398                 {yyerror ("Missing term"); RECOVER;}
2399 |       OP_TK name dims CP_TK error
2400                 {yyerror ("Missing term"); RECOVER;}
2401 ;
2402
2403 multiplicative_expression:
2404         unary_expression
2405 |       multiplicative_expression MULT_TK unary_expression
2406                 {
2407                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2408                                     $2.location, $1, $3);
2409                 }
2410 |       multiplicative_expression DIV_TK unary_expression
2411                 {
2412                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2413                                     $1, $3);
2414                 }
2415 |       multiplicative_expression REM_TK unary_expression
2416                 {
2417                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2418                                     $1, $3);
2419                 }
2420 |       multiplicative_expression MULT_TK error
2421                 {yyerror ("Missing term"); RECOVER;}
2422 |       multiplicative_expression DIV_TK error
2423                 {yyerror ("Missing term"); RECOVER;}
2424 |       multiplicative_expression REM_TK error
2425                 {yyerror ("Missing term"); RECOVER;}
2426 ;
2427
2428 additive_expression:
2429         multiplicative_expression
2430 |       additive_expression PLUS_TK multiplicative_expression
2431                 {
2432                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2433                                     $1, $3);
2434                 }
2435 |       additive_expression MINUS_TK multiplicative_expression
2436                 {
2437                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2438                                     $1, $3);
2439                 }
2440 |       additive_expression PLUS_TK error
2441                 {yyerror ("Missing term"); RECOVER;}
2442 |       additive_expression MINUS_TK error
2443                 {yyerror ("Missing term"); RECOVER;}
2444 ;
2445
2446 shift_expression:
2447         additive_expression
2448 |       shift_expression LS_TK additive_expression
2449                 {
2450                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2451                                     $1, $3);
2452                 }
2453 |       shift_expression SRS_TK additive_expression
2454                 {
2455                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2456                                     $1, $3);
2457                 }
2458 |       shift_expression ZRS_TK additive_expression
2459                 {
2460                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2461                                     $1, $3);
2462                 }
2463 |       shift_expression LS_TK error
2464                 {yyerror ("Missing term"); RECOVER;}
2465 |       shift_expression SRS_TK error
2466                 {yyerror ("Missing term"); RECOVER;}
2467 |       shift_expression ZRS_TK error
2468                 {yyerror ("Missing term"); RECOVER;}
2469 ;
2470
2471 relational_expression:
2472         shift_expression
2473 |       relational_expression LT_TK shift_expression
2474                 {
2475                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2476                                     $1, $3);
2477                 }
2478 |       relational_expression GT_TK shift_expression
2479                 {
2480                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2481                                     $1, $3);
2482                 }
2483 |       relational_expression LTE_TK shift_expression
2484                 {
2485                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2486                                     $1, $3);
2487                 }
2488 |       relational_expression GTE_TK shift_expression
2489                 {
2490                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2491                                     $1, $3);
2492                 }
2493 |       relational_expression INSTANCEOF_TK reference_type
2494                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2495 |       relational_expression LT_TK error
2496                 {yyerror ("Missing term"); RECOVER;}
2497 |       relational_expression GT_TK error
2498                 {yyerror ("Missing term"); RECOVER;}
2499 |       relational_expression LTE_TK error
2500                 {yyerror ("Missing term"); RECOVER;}
2501 |       relational_expression GTE_TK error
2502                 {yyerror ("Missing term"); RECOVER;}
2503 |       relational_expression INSTANCEOF_TK error
2504                 {yyerror ("Invalid reference type"); RECOVER;}
2505 ;
2506
2507 equality_expression:
2508         relational_expression
2509 |       equality_expression EQ_TK relational_expression
2510                 {
2511                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2512                                     $1, $3);
2513                 }
2514 |       equality_expression NEQ_TK relational_expression
2515                 {
2516                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2517                                     $1, $3);
2518                 }
2519 |       equality_expression EQ_TK error
2520                 {yyerror ("Missing term"); RECOVER;}
2521 |       equality_expression NEQ_TK error
2522                 {yyerror ("Missing term"); RECOVER;}
2523 ;
2524
2525 and_expression:
2526         equality_expression
2527 |       and_expression AND_TK equality_expression
2528                 {
2529                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2530                                     $1, $3);
2531                 }
2532 |       and_expression AND_TK error
2533                 {yyerror ("Missing term"); RECOVER;}
2534 ;
2535
2536 exclusive_or_expression:
2537         and_expression
2538 |       exclusive_or_expression XOR_TK and_expression
2539                 {
2540                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2541                                     $1, $3);
2542                 }
2543 |       exclusive_or_expression XOR_TK error
2544                 {yyerror ("Missing term"); RECOVER;}
2545 ;
2546
2547 inclusive_or_expression:
2548         exclusive_or_expression
2549 |       inclusive_or_expression OR_TK exclusive_or_expression
2550                 {
2551                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2552                                     $1, $3);
2553                 }
2554 |       inclusive_or_expression OR_TK error
2555                 {yyerror ("Missing term"); RECOVER;}
2556 ;
2557
2558 conditional_and_expression:
2559         inclusive_or_expression
2560 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2561                 {
2562                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2563                                     $1, $3);
2564                 }
2565 |       conditional_and_expression BOOL_AND_TK error
2566                 {yyerror ("Missing term"); RECOVER;}
2567 ;
2568
2569 conditional_or_expression:
2570         conditional_and_expression
2571 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2572                 {
2573                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2574                                     $1, $3);
2575                 }
2576 |       conditional_or_expression BOOL_OR_TK error
2577                 {yyerror ("Missing term"); RECOVER;}
2578 ;
2579
2580 conditional_expression:         /* Error handling here is weak */
2581         conditional_or_expression
2582 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2583                 {
2584                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2585                   EXPR_WFL_LINECOL ($$) = $2.location;
2586                 }
2587 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2588                 {
2589                   YYERROR_NOW;
2590                   yyerror ("Missing term");
2591                   DRECOVER (1);
2592                 }
2593 |       conditional_or_expression REL_QM_TK error
2594                 {yyerror ("Missing term"); DRECOVER (2);}
2595 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2596                 {yyerror ("Missing term"); DRECOVER (3);}
2597 ;
2598
2599 assignment_expression:
2600         conditional_expression
2601 |       assignment
2602 ;
2603
2604 assignment:
2605         left_hand_side assignment_operator assignment_expression
2606                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2607 |       left_hand_side assignment_operator error
2608                 {
2609                   YYNOT_TWICE yyerror ("Missing term");
2610                   DRECOVER (assign);
2611                 }
2612 ;
2613
2614 left_hand_side:
2615         name
2616 |       field_access
2617 |       array_access
2618 ;
2619
2620 assignment_operator:
2621         ASSIGN_ANY_TK
2622 |       ASSIGN_TK
2623 ;
2624
2625 expression:
2626         assignment_expression
2627 ;
2628
2629 constant_expression:
2630         expression
2631 ;
2632
2633 %%
2634
2635 /* Helper function to retrieve an OSB count. Should be used when the
2636    `dims:' rule is being used.  */
2637
2638 static int
2639 pop_current_osb (struct parser_ctxt *ctxp)
2640 {
2641   int to_return;
2642
2643   if (ctxp->osb_depth < 0)
2644     abort ();
2645
2646   to_return = CURRENT_OSB (ctxp);
2647   ctxp->osb_depth--;
2648
2649   return to_return;
2650 }
2651
2652 \f
2653
2654 /* This section of the code deal with save/restoring parser contexts.
2655    Add mode documentation here. FIXME */
2656
2657 /* Helper function. Create a new parser context. With
2658    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2659    context is copied, otherwise, the new context is zeroed. The newly
2660    created context becomes the current one.  */
2661
2662 static void
2663 create_new_parser_context (int copy_from_previous)
2664 {
2665   struct parser_ctxt *new;
2666
2667   new = ggc_alloc (sizeof (struct parser_ctxt));
2668   if (copy_from_previous)
2669     {
2670       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2671       /* This flag, indicating the context saves global values,
2672          should only be set by java_parser_context_save_global.  */
2673       new->saved_data_ctx = 0;
2674     }
2675   else
2676     memset (new, 0, sizeof (struct parser_ctxt));
2677
2678   new->next = ctxp;
2679   ctxp = new;
2680 }
2681
2682 /* Create a new parser context and make it the current one. */
2683
2684 void
2685 java_push_parser_context (void)
2686 {
2687   create_new_parser_context (0);
2688 }
2689
2690 void
2691 java_pop_parser_context (int generate)
2692 {
2693   tree current;
2694   struct parser_ctxt *toFree, *next;
2695
2696   if (!ctxp)
2697     return;
2698
2699   toFree = ctxp;
2700   next = ctxp->next;
2701   if (next)
2702     {
2703       input_line = ctxp->lineno;
2704       current_class = ctxp->class_type;
2705     }
2706
2707   /* If the old and new lexers differ, then free the old one.  */
2708   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2709     java_destroy_lexer (ctxp->lexer);
2710
2711   /* Set the single import class file flag to 0 for the current list
2712      of imported things */
2713   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2714     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2715
2716   /* And restore those of the previous context */
2717   if ((ctxp = next))            /* Assignment is really meant here */
2718     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2719       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2720
2721   /* If we pushed a context to parse a class intended to be generated,
2722      we keep it so we can remember the class. What we could actually
2723      do is to just update a list of class names.  */
2724   if (generate)
2725     {
2726       toFree->next = ctxp_for_generation;
2727       ctxp_for_generation = toFree;
2728     }
2729 }
2730
2731 /* Create a parser context for the use of saving some global
2732    variables.  */
2733
2734 void
2735 java_parser_context_save_global (void)
2736 {
2737   if (!ctxp)
2738     {
2739       java_push_parser_context ();
2740       ctxp->saved_data_ctx = 1;
2741     }
2742
2743   /* If this context already stores data, create a new one suitable
2744      for data storage. */
2745   else if (ctxp->saved_data)
2746     {
2747       create_new_parser_context (1);
2748       ctxp->saved_data_ctx = 1;
2749     }
2750
2751   ctxp->lineno = input_line;
2752   ctxp->class_type = current_class;
2753   ctxp->filename = input_filename;
2754   ctxp->function_decl = current_function_decl;
2755   ctxp->saved_data = 1;
2756 }
2757
2758 /* Restore some global variables from the previous context. Make the
2759    previous context the current one.  */
2760
2761 void
2762 java_parser_context_restore_global (void)
2763 {
2764   input_line = ctxp->lineno;
2765   current_class = ctxp->class_type;
2766   input_filename = ctxp->filename;
2767   if (wfl_operator)
2768     EXPR_WFL_FILENAME_NODE (wfl_operator) = get_identifier (input_filename);
2769   current_function_decl = ctxp->function_decl;
2770   ctxp->saved_data = 0;
2771   if (ctxp->saved_data_ctx)
2772     java_pop_parser_context (0);
2773 }
2774
2775 /* Suspend vital data for the current class/function being parsed so
2776    that an other class can be parsed. Used to let local/anonymous
2777    classes be parsed.  */
2778
2779 static void
2780 java_parser_context_suspend (void)
2781 {
2782   /* This makes debugging through java_debug_context easier */
2783   static const char *const name = "<inner buffer context>";
2784
2785   /* Duplicate the previous context, use it to save the globals we're
2786      interested in */
2787   create_new_parser_context (1);
2788   ctxp->function_decl = current_function_decl;
2789   ctxp->class_type = current_class;
2790
2791   /* Then create a new context which inherits all data from the
2792      previous one. This will be the new current context  */
2793   create_new_parser_context (1);
2794
2795   /* Help debugging */
2796   ctxp->next->filename = name;
2797 }
2798
2799 /* Resume vital data for the current class/function being parsed so
2800    that an other class can be parsed. Used to let local/anonymous
2801    classes be parsed.  The trick is the data storing file position
2802    informations must be restored to their current value, so parsing
2803    can resume as if no context was ever saved. */
2804
2805 static void
2806 java_parser_context_resume (void)
2807 {
2808   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2809   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2810   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2811
2812   /* We need to inherit the list of classes to complete/generate */
2813   restored->classd_list = old->classd_list;
2814   restored->class_list = old->class_list;
2815
2816   /* Restore the current class and function from the saver */
2817   current_class = saver->class_type;
2818   current_function_decl = saver->function_decl;
2819
2820   /* Retrieve the restored context */
2821   ctxp = restored;
2822
2823   /* Re-installed the data for the parsing to carry on */
2824   memcpy (&ctxp->marker_begining, &old->marker_begining,
2825           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2826 }
2827
2828 /* Add a new anchor node to which all statement(s) initializing static
2829    and non static initialized upon declaration field(s) will be
2830    linked.  */
2831
2832 static void
2833 java_parser_context_push_initialized_field (void)
2834 {
2835   tree node;
2836
2837   node = build_tree_list (NULL_TREE, NULL_TREE);
2838   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2839   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2840
2841   node = build_tree_list (NULL_TREE, NULL_TREE);
2842   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2843   CPC_INITIALIZER_LIST (ctxp) = node;
2844
2845   node = build_tree_list (NULL_TREE, NULL_TREE);
2846   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2847   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2848 }
2849
2850 /* Pop the lists of initialized field. If this lists aren't empty,
2851    remember them so we can use it to create and populate the finit$
2852    or <clinit> functions. */
2853
2854 static void
2855 java_parser_context_pop_initialized_field (void)
2856 {
2857   tree stmts;
2858   tree class_type = TREE_TYPE (GET_CPC ());
2859
2860   if (CPC_INITIALIZER_LIST (ctxp))
2861     {
2862       stmts = CPC_INITIALIZER_STMT (ctxp);
2863       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2864       if (stmts && !java_error_count)
2865         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2866     }
2867
2868   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2869     {
2870       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2871       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2872         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2873       /* Keep initialization in order to enforce 8.5 */
2874       if (stmts && !java_error_count)
2875         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2876     }
2877
2878   /* JDK 1.1 instance initializers */
2879   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2880     {
2881       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2882       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2883         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2884       if (stmts && !java_error_count)
2885         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2886     }
2887 }
2888
2889 static tree
2890 reorder_static_initialized (tree list)
2891 {
2892   /* We have to keep things in order. The alias initializer have to
2893      come first, then the initialized regular field, in reverse to
2894      keep them in lexical order. */
2895   tree marker, previous = NULL_TREE;
2896   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2897     if (TREE_CODE (marker) == TREE_LIST
2898         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2899       break;
2900
2901   /* No static initialized, the list is fine as is */
2902   if (!previous)
2903     list = TREE_CHAIN (marker);
2904
2905   /* No marker? reverse the whole list */
2906   else if (!marker)
2907     list = nreverse (list);
2908
2909   /* Otherwise, reverse what's after the marker and the new reordered
2910      sublist will replace the marker. */
2911   else
2912     {
2913       TREE_CHAIN (previous) = NULL_TREE;
2914       list = nreverse (list);
2915       list = chainon (TREE_CHAIN (marker), list);
2916     }
2917   return list;
2918 }
2919
2920 /* Helper functions to dump the parser context stack.  */
2921
2922 #define TAB_CONTEXT(C) \
2923   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2924
2925 static void
2926 java_debug_context_do (int tab)
2927 {
2928   struct parser_ctxt *copy = ctxp;
2929   while (copy)
2930     {
2931       TAB_CONTEXT (tab);
2932       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2933       TAB_CONTEXT (tab);
2934       fprintf (stderr, "filename: %s\n", copy->filename);
2935       TAB_CONTEXT (tab);
2936       fprintf (stderr, "lineno: %d\n", copy->lineno);
2937       TAB_CONTEXT (tab);
2938       fprintf (stderr, "package: %s\n",
2939                (copy->package ?
2940                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2941       TAB_CONTEXT (tab);
2942       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2943       TAB_CONTEXT (tab);
2944       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2945       copy = copy->next;
2946       tab += 2;
2947     }
2948 }
2949
2950 /* Dump the stacked up parser contexts. Intended to be called from a
2951    debugger.  */
2952
2953 void
2954 java_debug_context (void)
2955 {
2956   java_debug_context_do (0);
2957 }
2958
2959 \f
2960
2961 /* Flag for the error report routine to issue the error the first time
2962    it's called (overriding the default behavior which is to drop the
2963    first invocation and honor the second one, taking advantage of a
2964    richer context.  */
2965 static int force_error = 0;
2966
2967 /* Reporting an constructor invocation error.  */
2968 static void
2969 parse_ctor_invocation_error (void)
2970 {
2971   if (DECL_CONSTRUCTOR_P (current_function_decl))
2972     yyerror ("Constructor invocation must be first thing in a constructor");
2973   else
2974     yyerror ("Only constructors can invoke constructors");
2975 }
2976
2977 /* Reporting JDK1.1 features not implemented.  */
2978
2979 static tree
2980 parse_jdk1_1_error (const char *msg)
2981 {
2982   sorry (": `%s' JDK1.1(TM) feature", msg);
2983   java_error_count++;
2984   return build_java_empty_stmt ();
2985 }
2986
2987 static int do_warning = 0;
2988
2989 void
2990 yyerror (const char *msg)
2991 {
2992   static java_lc elc;
2993   static int  prev_lineno;
2994   static const char *prev_msg;
2995
2996   int save_lineno;
2997   char *remainder, *code_from_source;
2998
2999   if (!force_error && prev_lineno == input_line)
3000     return;
3001
3002   /* Save current error location but report latter, when the context is
3003      richer.  */
3004   if (ctxp->java_error_flag == 0)
3005     {
3006       ctxp->java_error_flag = 1;
3007       elc = ctxp->elc;
3008       /* Do something to use the previous line if we're reaching the
3009          end of the file... */
3010 #ifdef VERBOSE_SKELETON
3011       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3012 #endif
3013       return;
3014     }
3015
3016   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3017   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3018     return;
3019
3020   ctxp->java_error_flag = 0;
3021   if (do_warning)
3022     java_warning_count++;
3023   else
3024     java_error_count++;
3025
3026   if (elc.col == 0 && msg && msg[1] == ';')
3027     {
3028       elc.col  = ctxp->p_line->char_col-1;
3029       elc.line = ctxp->p_line->lineno;
3030     }
3031
3032   save_lineno = input_line;
3033   prev_lineno = input_line = elc.line;
3034   prev_msg = msg;
3035
3036   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3037   obstack_grow0 (&temporary_obstack,
3038                  code_from_source, strlen (code_from_source));
3039   remainder = obstack_finish (&temporary_obstack);
3040   if (do_warning)
3041     warning ("%s.\n%s", msg, remainder);
3042   else
3043     error ("%s.\n%s", msg, remainder);
3044
3045   /* This allow us to cheaply avoid an extra 'Invalid expression
3046      statement' error report when errors have been already reported on
3047      the same line. This occurs when we report an error but don't have
3048      a synchronization point other than ';', which
3049      expression_statement is the only one to take care of.  */
3050   ctxp->prevent_ese = input_line = save_lineno;
3051 }
3052
3053 static void
3054 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3055 {
3056   const char *saved, *saved_input_filename;
3057   char buffer [4096];
3058   vsprintf (buffer, msg, ap);
3059   force_error = 1;
3060
3061   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3062   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3063                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3064
3065   /* We have a CL, that's a good reason for using it if it contains data */
3066   saved = ctxp->filename;
3067   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3068     ctxp->filename = EXPR_WFL_FILENAME (cl);
3069   saved_input_filename = input_filename;
3070   input_filename = ctxp->filename;
3071   java_error (NULL);
3072   java_error (buffer);
3073   ctxp->filename = saved;
3074   input_filename = saved_input_filename;
3075   force_error = 0;
3076 }
3077
3078 /* Issue an error message at a current source line CL */
3079
3080 void
3081 parse_error_context (tree cl, const char *msg, ...)
3082 {
3083   va_list ap;
3084   va_start (ap, msg);
3085   issue_warning_error_from_context (cl, msg, ap);
3086   va_end (ap);
3087 }
3088
3089 /* Issue a warning at a current source line CL */
3090
3091 static void
3092 parse_warning_context (tree cl, const char *msg, ...)
3093 {
3094   va_list ap;
3095   va_start (ap, msg);
3096
3097   force_error = do_warning = 1;
3098   issue_warning_error_from_context (cl, msg, ap);
3099   do_warning = force_error = 0;
3100   va_end (ap);
3101 }
3102
3103 static tree
3104 find_expr_with_wfl (tree node)
3105 {
3106   while (node)
3107     {
3108       char code;
3109       tree to_return;
3110
3111       switch (TREE_CODE (node))
3112         {
3113         case BLOCK:
3114           node = BLOCK_EXPR_BODY (node);
3115           continue;
3116
3117         case COMPOUND_EXPR:
3118           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3119           if (to_return)
3120             return to_return;
3121           node = TREE_OPERAND (node, 1);
3122           continue;
3123
3124         case LOOP_EXPR:
3125           node = TREE_OPERAND (node, 0);
3126           continue;
3127
3128         case LABELED_BLOCK_EXPR:
3129           node = TREE_OPERAND (node, 1);
3130           continue;
3131
3132         default:
3133           code = TREE_CODE_CLASS (TREE_CODE (node));
3134           if (((code == '1') || (code == '2') || (code == 'e'))
3135               && EXPR_WFL_LINECOL (node))
3136             return node;
3137           return NULL_TREE;
3138         }
3139     }
3140   return NULL_TREE;
3141 }
3142
3143 /* Issue a missing return statement error. Uses METHOD to figure the
3144    last line of the method the error occurs in.  */
3145
3146 static void
3147 missing_return_error (tree method)
3148 {
3149   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3150   parse_error_context (wfl_operator, "Missing return statement");
3151 }
3152
3153 /* Issue an unreachable statement error. From NODE, find the next
3154    statement to report appropriately.  */
3155 static void
3156 unreachable_stmt_error (tree node)
3157 {
3158   /* Browse node to find the next expression node that has a WFL. Use
3159      the location to report the error */
3160   if (TREE_CODE (node) == COMPOUND_EXPR)
3161     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3162   else
3163     node = find_expr_with_wfl (node);
3164
3165   if (node)
3166     {
3167       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3168       parse_error_context (wfl_operator, "Unreachable statement");
3169     }
3170   else
3171     abort ();
3172 }
3173
3174 static int
3175 not_accessible_field_error (tree wfl, tree decl)
3176 {
3177   parse_error_context 
3178     (wfl, "Can't access %s field `%s.%s' from `%s'",
3179      accessibility_string (get_access_flags_from_decl (decl)),
3180      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3181      IDENTIFIER_POINTER (DECL_NAME (decl)),
3182      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3183   return 1;
3184 }
3185
3186 int
3187 java_report_errors (void)
3188 {
3189   if (java_error_count)
3190     fprintf (stderr, "%d error%s",
3191              java_error_count, (java_error_count == 1 ? "" : "s"));
3192   if (java_warning_count)
3193     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3194              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3195   if (java_error_count || java_warning_count)
3196     putc ('\n', stderr);
3197   return java_error_count;
3198 }
3199
3200 static char *
3201 java_accstring_lookup (int flags)
3202 {
3203   static char buffer [80];
3204 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3205
3206   /* Access modifier looked-up first for easier report on forbidden
3207      access. */
3208   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3209   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3210   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3211   if (flags & ACC_STATIC) COPY_RETURN ("static");
3212   if (flags & ACC_FINAL) COPY_RETURN ("final");
3213   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3214   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3215   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3216   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3217   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3218   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3219
3220   buffer [0] = '\0';
3221   return buffer;
3222 #undef COPY_RETURN
3223 }
3224
3225 /* Returns a string denoting the accessibility of a class or a member as
3226    indicated by FLAGS.  We need a separate function from
3227    java_accstring_lookup, as the latter can return spurious "static", etc.
3228    if package-private access is defined (in which case none of the
3229    relevant access control bits in FLAGS is set).  */
3230
3231 static const char *
3232 accessibility_string (int flags)
3233 {
3234   if (flags & ACC_PRIVATE) return "private";
3235   if (flags & ACC_PROTECTED) return "protected";
3236   if (flags & ACC_PUBLIC) return "public";
3237
3238   return "package-private";
3239 }
3240
3241 /* Issuing error messages upon redefinition of classes, interfaces or
3242    variables. */
3243
3244 static void
3245 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3246 {
3247   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3248                        context, IDENTIFIER_POINTER (id),
3249                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3250   /* Here we should point out where its redefined. It's a unicode. FIXME */
3251 }
3252
3253 static void
3254 variable_redefinition_error (tree context, tree name, tree type, int line)
3255 {
3256   const char *type_name;
3257
3258   /* Figure a proper name for type. We might haven't resolved it */
3259   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3260     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3261   else
3262     type_name = lang_printable_name (type, 0);
3263
3264   parse_error_context (context,
3265                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3266                        IDENTIFIER_POINTER (name),
3267                        type_name, IDENTIFIER_POINTER (name), line);
3268 }
3269
3270 /* If ANAME is terminated with `[]', it indicates an array. This
3271    function returns the number of `[]' found and if this number is
3272    greater than zero, it extracts the array type name and places it in
3273    the node pointed to by TRIMMED unless TRIMMED is null.  */
3274
3275 static int
3276 build_type_name_from_array_name (tree aname, tree *trimmed)
3277 {
3278   const char *name = IDENTIFIER_POINTER (aname);
3279   int len = IDENTIFIER_LENGTH (aname);
3280   int array_dims;
3281
3282   STRING_STRIP_BRACKETS (name, len, array_dims);
3283
3284   if (array_dims && trimmed)
3285     *trimmed = get_identifier_with_length (name, len);
3286
3287   return array_dims;
3288 }
3289
3290 static tree
3291 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3292 {
3293   int more_dims = 0;
3294
3295   /* Eventually get more dims */
3296   more_dims = build_type_name_from_array_name (name, &name);
3297
3298   /* If we have, then craft a new type for this variable */
3299   if (more_dims)
3300     {
3301       tree save = type;
3302
3303       /* If we have a pointer, use its type */
3304       if (TREE_CODE (type) == POINTER_TYPE)
3305         type = TREE_TYPE (type);
3306
3307       /* Building the first dimension of a primitive type uses this
3308          function */
3309       if (JPRIMITIVE_TYPE_P (type))
3310         {
3311           type = build_java_array_type (type, -1);
3312           more_dims--;
3313         }
3314       /* Otherwise, if we have a WFL for this type, use it (the type
3315          is already an array on an unresolved type, and we just keep
3316          on adding dimensions) */
3317       else if (type_wfl)
3318         {
3319           type = type_wfl;
3320           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3321                                                         NULL);
3322         }
3323
3324       /* Add all the dimensions */
3325       while (more_dims--)
3326         type = build_unresolved_array_type (type);
3327
3328       /* The type may have been incomplete in the first place */
3329       if (type_wfl)
3330         type = obtain_incomplete_type (type);
3331     }
3332
3333   if (ret_name)
3334     *ret_name = name;
3335   return type;
3336 }
3337
3338 /* Build something that the type identifier resolver will identify as
3339    being an array to an unresolved type. TYPE_WFL is a WFL on a
3340    identifier. */
3341
3342 static tree
3343 build_unresolved_array_type (tree type_or_wfl)
3344 {
3345   const char *ptr;
3346   tree wfl;
3347
3348   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3349      just create a array type */
3350   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3351     return build_java_array_type (type_or_wfl, -1);
3352
3353   obstack_grow (&temporary_obstack,
3354                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3355                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3356   obstack_grow0 (&temporary_obstack, "[]", 2);
3357   ptr = obstack_finish (&temporary_obstack);
3358   wfl = build_expr_wfl (get_identifier (ptr),
3359                         EXPR_WFL_FILENAME (type_or_wfl),
3360                         EXPR_WFL_LINENO (type_or_wfl),
3361                         EXPR_WFL_COLNO (type_or_wfl));
3362   /* Re-install the existing qualifications so that the type can be
3363      resolved properly. */
3364   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3365   return wfl;
3366 }
3367
3368 static void
3369 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3370 {
3371   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3372     parse_error_context (wfl, "Interface `%s' repeated",
3373                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3374 }
3375
3376 /* Bulk of common class/interface checks. Return 1 if an error was
3377    encountered. TAG is 0 for a class, 1 for an interface.  */
3378
3379 static int
3380 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3381                                 tree qualified_name, tree decl, tree cl)