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 
76 /* Local function prototypes */
77 static char *java_accstring_lookup (int);
78 static void  classitf_redefinition_error (const char *,tree, tree, tree);
79 static void  variable_redefinition_error (tree, tree, tree, int);
80 static tree  create_class (int, tree, tree, tree);
81 static tree  create_interface (int, tree, tree);
82 static void  end_class_declaration (int);
83 static tree  find_field (tree, tree);
84 static tree lookup_field_wrapper (tree, tree);
85 static int   duplicate_declaration_error_p (tree, tree, tree);
86 static void  register_fields (int, tree, tree);
87 static tree parser_qualified_classname (tree);
88 static int  parser_check_super (tree, tree, tree);
89 static int  parser_check_super_interface (tree, tree, tree);
90 static void check_modifiers_consistency (int);
91 static tree lookup_cl (tree);
92 static tree lookup_java_method2 (tree, tree, int);
93 static tree method_header (int, tree, tree, tree);
94 static void fix_method_argument_names (tree ,tree);
95 static tree method_declarator (tree, tree);
96 static void parse_warning_context (tree cl, const char *msg, ...)
97   ATTRIBUTE_PRINTF_2;
98 static void issue_warning_error_from_context (tree, const char *msg, va_list)
99   ATTRIBUTE_PRINTF (2, 0);
100 static void parse_ctor_invocation_error (void);
101 static tree parse_jdk1_1_error (const char *);
102 static void complete_class_report_errors (jdep *);
103 static int process_imports (void);
104 static void read_import_dir (tree);
105 static int find_in_imports_on_demand (tree, tree);
106 static void find_in_imports (tree, tree);
107 static void check_inner_class_access (tree, tree, tree);
108 static int check_pkg_class_access (tree, tree, bool);
109 static void register_package (tree);
110 static tree resolve_package (tree, tree *, tree *);
111 static tree resolve_class (tree, tree, tree, tree);
112 static void declare_local_variables (int, tree, tree);
113 static void dump_java_tree (enum tree_dump_index, tree);
114 static void source_start_java_method (tree);
115 static void source_end_java_method (void);
116 static tree find_name_in_single_imports (tree);
117 static void check_abstract_method_header (tree);
118 static tree lookup_java_interface_method2 (tree, tree);
119 static tree resolve_expression_name (tree, tree *);
120 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
121 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
122 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
123 static int breakdown_qualified (tree *, tree *, tree);
124 static int in_same_package (tree, 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 java_complete_expand_method (tree);
146 static void java_expand_method_bodies (tree);
147 static int  unresolved_type_p (tree, tree *);
148 static void create_jdep_list (struct parser_ctxt *);
149 static tree build_expr_block (tree, tree);
150 static tree enter_block (void);
151 static tree exit_block (void);
152 static tree lookup_name_in_blocks (tree);
153 static void maybe_absorb_scoping_blocks (void);
154 static tree build_method_invocation (tree, tree);
155 static tree build_new_invocation (tree, tree);
156 static tree build_assignment (int, int, tree, tree);
157 static tree build_binop (enum tree_code, int, tree, tree);
158 static tree patch_assignment (tree, tree);
159 static tree patch_binop (tree, tree, tree);
160 static tree build_unaryop (int, int, tree);
161 static tree build_incdec (int, int, tree, int);
162 static tree patch_unaryop (tree, tree);
163 static tree build_cast (int, tree, tree);
164 static tree build_null_of_type (tree);
165 static tree patch_cast (tree, tree);
166 static int valid_ref_assignconv_cast_p (tree, tree, int);
167 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
168 static int valid_cast_to_p (tree, tree);
169 static int valid_method_invocation_conversion_p (tree, tree);
170 static tree try_builtin_assignconv (tree, tree, tree);
171 static tree try_reference_assignconv (tree, tree);
172 static tree build_unresolved_array_type (tree);
173 static int build_type_name_from_array_name (tree, tree *);
174 static tree build_array_from_name (tree, tree, tree, tree *);
175 static tree build_array_ref (int, tree, tree);
176 static tree patch_array_ref (tree);
177 static tree make_qualified_name (tree, tree, int);
178 static tree merge_qualified_name (tree, tree);
179 static tree make_qualified_primary (tree, tree, int);
180 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
181 static void qualify_ambiguous_name (tree);
182 static tree resolve_field_access (tree, tree *, tree *);
183 static tree build_newarray_node (tree, tree, int);
184 static tree patch_newarray (tree);
185 static tree resolve_type_during_patch (tree);
186 static tree build_this (int);
187 static tree build_wfl_wrap (tree, int);
188 static tree build_return (int, tree);
189 static tree patch_return (tree);
190 static tree maybe_access_field (tree, tree, tree);
191 static int complete_function_arguments (tree);
192 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
193 static int not_accessible_p (tree, tree, tree, int);
194 static void check_deprecation (tree, tree);
195 static int class_in_current_package (tree);
196 static tree build_if_else_statement (int, tree, tree, tree);
197 static tree patch_if_else_statement (tree);
198 static tree add_stmt_to_compound (tree, tree, 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 set_nested_class_simple_name_value (tree, int);
298 static void link_nested_class_to_enclosing (void);
299 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
300 static tree find_as_inner_class (tree, tree, tree);
301 static tree find_as_inner_class_do (tree, tree);
302 static int check_inner_class_redefinition (tree, tree);
303 
304 static tree build_thisn_assign (void);
305 static tree build_current_thisn (tree);
306 static tree build_access_to_thisn (tree, tree, int);
307 static tree maybe_build_thisn_access_method (tree);
308 
309 static tree build_outer_field_access (tree, tree);
310 static tree build_outer_field_access_methods (tree);
311 static tree build_outer_field_access_expr (int, tree, tree,
312 						  tree, tree);
313 static tree build_outer_method_access_method (tree);
314 static tree build_new_access_id (void);
315 static tree build_outer_field_access_method (tree, tree, tree,
316 						    tree, tree);
317 
318 static int outer_field_access_p (tree, tree);
319 static int outer_field_expanded_access_p (tree, tree *,
320 						 tree *, tree *);
321 static tree outer_field_access_fix (tree, tree, tree);
322 static tree build_incomplete_class_ref (int, tree);
323 static tree patch_incomplete_class_ref (tree);
324 static tree create_anonymous_class (int, tree);
325 static void patch_anonymous_class (tree, tree, tree);
326 static void add_inner_class_fields (tree, tree);
327 
328 static tree build_dot_class_method (tree);
329 static tree build_dot_class_method_invocation (tree, tree);
330 static void create_new_parser_context (int);
331 static tree maybe_build_class_init_for_field (tree, tree);
332 
333 static int attach_init_test_initialization_flags (void **, void *);
334 static int emit_test_initialization (void **, void *);
335 
336 static char *string_convert_int_cst (tree);
337 
338 /* Number of error found so far. */
339 int java_error_count;
340 /* Number of warning found so far. */
341 int java_warning_count;
342 /* Tell when not to fold, when doing xrefs */
343 int do_not_fold;
344 /* Cyclic inheritance report, as it can be set by layout_class */
345 const char *cyclic_inheritance_report;
346 
347 /* The current parser context */
348 struct parser_ctxt *ctxp;
349 
350 /* List of things that were analyzed for which code will be generated */
351 struct parser_ctxt *ctxp_for_generation = NULL;
352 
353 /* binop_lookup maps token to tree_code. It is used where binary
354    operations are involved and required by the parser. RDIV_EXPR
355    covers both integral/floating point division. The code is changed
356    once the type of both operator is worked out.  */
357 
358 static const enum tree_code binop_lookup[19] =
359   {
360     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
361     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
362     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
363     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
364     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
365    };
366 #define BINOP_LOOKUP(VALUE) 						\
367   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
368 
369 /* This is the end index for binary operators that can also be used
370    in compound assignments. */
371 #define BINOP_COMPOUND_CANDIDATES 11
372 
373 /* The "$L" identifier we use to create labels.  */
374 static GTY(()) tree label_id;
375 
376 /* The "StringBuffer" identifier used for the String `+' operator. */
377 static GTY(()) tree wfl_string_buffer;
378 
379 /* The "append" identifier used for String `+' operator.  */
380 static GTY(()) tree wfl_append;
381 
382 /* The "toString" identifier used for String `+' operator. */
383 static GTY(()) tree wfl_to_string;
384 
385 /* The "java.lang" import qualified name.  */
386 static GTY(()) tree java_lang_id;
387 
388 /* The generated `inst$' identifier used for generated enclosing
389    instance/field access functions.  */
390 static GTY(()) tree inst_id;
391 
392 /* Context and flag for static blocks */
393 static GTY(()) tree current_static_block;
394 
395 /* The generated `write_parm_value$' identifier.  */
396 static GTY(()) tree wpv_id;
397 
398 /* The list of all packages we've seen so far */
399 static GTY(()) tree package_list;
400 
401 /* Hold THIS for the scope of the current method decl.  */
402 static GTY(()) tree current_this;
403 
404 /* Hold a list of catch clauses list. The first element of this list is
405    the list of the catch clauses of the currently analyzed try block. */
406 static GTY(()) tree currently_caught_type_list;
407 
408 /* This holds a linked list of all the case labels for the current
409    switch statement.  It is only used when checking to see if there
410    are duplicate labels.  FIXME: probably this should just be attached
411    to the switch itself; then it could be referenced via
412    `ctxp->current_loop'.  */
413 static GTY(()) tree case_label_list;
414 
415 /* Anonymous class counter. Will be reset to 1 every time a non
416    anonymous class gets created. */
417 static int anonymous_class_counter = 1;
418 
419 static GTY(()) tree src_parse_roots[1];
420 
421 /* All classes seen from source code */
422 #define gclass_list src_parse_roots[0]
423 
424 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
425    line and point it out.  */
426 /* Should point out the one that don't fit. ASCII/unicode, going
427    backward. FIXME */
428 
429 #define check_modifiers(__message, __value, __mask) do {	\
430   if ((__value) & ~(__mask))					\
431     {								\
432       size_t i, remainder = (__value) & ~(__mask);	       	\
433       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)	\
434         if ((1 << i) & remainder)				\
435 	  parse_error_context (ctxp->modifier_ctx [i], (__message), \
436 			       java_accstring_lookup (1 << i)); \
437     }								\
438 } while (0)
439 
440 %}
441 
442 %union {
443   tree node;
444   int sub_token;
445   struct {
446     int token;
447     int location;
448   } operator;
449   int value;
450 }
451 
452 %{
453 #include "lex.c"
454 %}
455 
456 %pure_parser
457 
458 /* Things defined here have to match the order of what's in the
459    binop_lookup table.  */
460 
461 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
462 %token   LS_TK           SRS_TK          ZRS_TK
463 %token   AND_TK          XOR_TK          OR_TK
464 %token   BOOL_AND_TK BOOL_OR_TK
465 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
466 
467 /* This maps to the same binop_lookup entry than the token above */
468 
469 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
470 %token   REM_ASSIGN_TK
471 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
472 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
473 
474 
475 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
476 
477 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
478 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
479 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
480 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
481 %token   MODIFIER_TK
482 
483 /* Keep those two in order, too */
484 %token   DECR_TK INCR_TK
485 
486 /* From now one, things can be in any order */
487 
488 %token   DEFAULT_TK      IF_TK              THROW_TK
489 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
490 %token   THROWS_TK       BREAK_TK           IMPORT_TK
491 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
492 %token   VOID_TK         CATCH_TK           INTERFACE_TK
493 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
494 %token   SUPER_TK        WHILE_TK           CLASS_TK
495 %token   SWITCH_TK       CONST_TK           TRY_TK
496 %token   FOR_TK          NEW_TK             CONTINUE_TK
497 %token   GOTO_TK         PACKAGE_TK         THIS_TK
498 %token   ASSERT_TK
499 
500 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
501 %token   CHAR_TK         INTEGRAL_TK
502 
503 %token   FLOAT_TK        DOUBLE_TK          FP_TK
504 
505 %token   ID_TK
506 
507 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
508 
509 %token   ASSIGN_ANY_TK   ASSIGN_TK
510 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
511 
512 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
513 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
514 
515 %type    <value>	modifiers MODIFIER_TK final synchronized
516 
517 %type    <node>		super ID_TK identifier
518 %type    <node>		name simple_name qualified_name
519 %type	 <node>		type_declaration compilation_unit
520 			field_declaration method_declaration extends_interfaces
521                         interfaces interface_type_list
522                         import_declarations package_declaration
523                         type_declarations interface_body
524 			interface_member_declaration constant_declaration
525 			interface_member_declarations interface_type
526 			abstract_method_declaration
527 %type	 <node>		class_body_declaration class_member_declaration
528 			static_initializer constructor_declaration block
529 %type	 <node>		class_body_declarations constructor_header
530 %type    <node>		class_or_interface_type class_type class_type_list
531 			constructor_declarator explicit_constructor_invocation
532 %type    <node>         dim_expr dim_exprs this_or_super throws
533 
534 %type	 <node>		variable_declarator_id variable_declarator
535 			variable_declarators variable_initializer
536 			variable_initializers constructor_body
537 			array_initializer
538 
539 %type	 <node>		class_body block_end constructor_block_end
540 %type	 <node>		statement statement_without_trailing_substatement
541 			labeled_statement if_then_statement label_decl
542 			if_then_else_statement while_statement for_statement
543 			statement_nsi labeled_statement_nsi do_statement
544 			if_then_else_statement_nsi while_statement_nsi
545 			for_statement_nsi statement_expression_list for_init
546 			for_update statement_expression expression_statement
547 			primary_no_new_array expression primary
548 			array_creation_expression array_type
549 			class_instance_creation_expression field_access
550 			method_invocation array_access something_dot_new
551 			argument_list postfix_expression while_expression
552 			post_increment_expression post_decrement_expression
553 			unary_expression_not_plus_minus unary_expression
554 			pre_increment_expression pre_decrement_expression
555 			cast_expression
556 			multiplicative_expression additive_expression
557 			shift_expression relational_expression
558 			equality_expression and_expression
559 			exclusive_or_expression inclusive_or_expression
560 			conditional_and_expression conditional_or_expression
561 			conditional_expression assignment_expression
562 			left_hand_side assignment for_header for_begin
563 			constant_expression do_statement_begin empty_statement
564 			switch_statement synchronized_statement throw_statement
565 			try_statement assert_statement
566 			switch_expression switch_block
567 			catches catch_clause catch_clause_parameter finally
568 			anonymous_class_creation trap_overflow_corner_case
569 %type    <node>         return_statement break_statement continue_statement
570 
571 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
572 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
573 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
574 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
575 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
576 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
577 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
578 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
579 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
580 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
581 %type    <operator>	THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
582 %type	 <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
583 %type	 <operator>     NEW_TK ASSERT_TK
584 
585 %type	 <node>		method_body
586 
587 %type    <node>		literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
588 			STRING_LIT_TK NULL_TK VOID_TK
589 
590 %type	 <node>		IF_TK WHILE_TK FOR_TK
591 
592 %type    <node>         formal_parameter_list formal_parameter
593                         method_declarator method_header
594 
595 %type	 <node>		primitive_type reference_type type
596 			BOOLEAN_TK INTEGRAL_TK FP_TK
597 
598 /* Added or modified JDK 1.1 rule types  */
599 %type	 <node>		type_literals
600 
601 %%
602 /* 19.2 Production from 2.3: The Syntactic Grammar  */
603 goal:  compilation_unit
604 		{}
605 ;
606 
607 /* 19.3 Productions from 3: Lexical structure  */
608 literal:
609 	INT_LIT_TK
610 |	FP_LIT_TK
611 |	BOOL_LIT_TK
612 |	CHAR_LIT_TK
613 |       STRING_LIT_TK
614 |       NULL_TK
615 ;
616 
617 /* 19.4 Productions from 4: Types, Values and Variables  */
618 type:
619 	primitive_type
620 |	reference_type
621 ;
622 
623 primitive_type:
624 	INTEGRAL_TK
625 |	FP_TK
626 |	BOOLEAN_TK
627 ;
628 
629 reference_type:
630 	class_or_interface_type
631 |	array_type
632 ;
633 
634 class_or_interface_type:
635 	name
636 ;
637 
638 class_type:
639 	class_or_interface_type	/* Default rule */
640 ;
641 
642 interface_type:
643 	 class_or_interface_type
644 ;
645 
646 array_type:
647 	primitive_type dims
648 		{
649 		  int osb = pop_current_osb (ctxp);
650 		  tree t = build_java_array_type (($1), -1);
651 		  while (--osb)
652 		    t = build_unresolved_array_type (t);
653 		  $$ = t;
654 		}
655 |	name dims
656 		{
657 		  int osb = pop_current_osb (ctxp);
658 		  tree t = $1;
659 		  while (osb--)
660 		    t = build_unresolved_array_type (t);
661 		  $$ = t;
662 		}
663 ;
664 
665 /* 19.5 Productions from 6: Names  */
666 name:
667 	simple_name		/* Default rule */
668 |	qualified_name		/* Default rule */
669 ;
670 
671 simple_name:
672 	identifier		/* Default rule */
673 ;
674 
675 qualified_name:
676 	name DOT_TK identifier
677 		{ $$ = make_qualified_name ($1, $3, $2.location); }
678 ;
679 
680 identifier:
681 	ID_TK
682 ;
683 
684 /* 19.6: Production from 7: Packages  */
685 compilation_unit:
686 		{$$ = NULL;}
687 |	package_declaration
688 |	import_declarations
689 |	type_declarations
690 |       package_declaration import_declarations
691 |       package_declaration type_declarations
692 |       import_declarations type_declarations
693 |       package_declaration import_declarations type_declarations
694 ;
695 
696 import_declarations:
697 	import_declaration
698 		{
699 		  $$ = NULL;
700 		}
701 |	import_declarations import_declaration
702 		{
703 		  $$ = NULL;
704 		}
705 ;
706 
707 type_declarations:
708 	type_declaration
709 | 	type_declarations type_declaration
710 ;
711 
712 package_declaration:
713 	PACKAGE_TK name SC_TK
714 		{
715 		  ctxp->package = EXPR_WFL_NODE ($2);
716 		  register_package (ctxp->package);
717 		}
718 |	PACKAGE_TK error
719 		{yyerror ("Missing name"); RECOVER;}
720 |	PACKAGE_TK name error
721 		{yyerror ("';' expected"); RECOVER;}
722 ;
723 
724 import_declaration:
725 	single_type_import_declaration
726 |	type_import_on_demand_declaration
727 ;
728 
729 single_type_import_declaration:
730 	IMPORT_TK name SC_TK
731 		{
732 		  tree name = EXPR_WFL_NODE ($2), last_name;
733 		  int   i = IDENTIFIER_LENGTH (name)-1;
734 		  const char *last = &IDENTIFIER_POINTER (name)[i];
735 		  while (last != IDENTIFIER_POINTER (name))
736 		    {
737 		      if (last [0] == '.')
738 			break;
739 		      last--;
740 		    }
741 		  last_name = get_identifier (++last);
742 		  if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
743 		    {
744 		      tree err = find_name_in_single_imports (last_name);
745 		      if (err && err != name)
746 			parse_error_context
747 			  ($2, "Ambiguous class: `%s' and `%s'",
748 			   IDENTIFIER_POINTER (name),
749 			   IDENTIFIER_POINTER (err));
750 		      else
751 			REGISTER_IMPORT ($2, last_name);
752 		    }
753 		  else
754 		    REGISTER_IMPORT ($2, last_name);
755 		}
756 |	IMPORT_TK error
757 		{yyerror ("Missing name"); RECOVER;}
758 |	IMPORT_TK name error
759 		{yyerror ("';' expected"); RECOVER;}
760 ;
761 
762 type_import_on_demand_declaration:
763 	IMPORT_TK name DOT_TK MULT_TK SC_TK
764 		{
765 		  tree name = EXPR_WFL_NODE ($2);
766 		  tree it;
767 		  /* Search for duplicates. */
768 		  for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
769 		    if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
770 		      break;
771 		  /* Don't import the same thing more than once, just ignore
772 		     duplicates (7.5.2) */
773 		  if (! it)
774 		    {
775 		      read_import_dir ($2);
776 		      ctxp->import_demand_list =
777 			chainon (ctxp->import_demand_list,
778 				 build_tree_list ($2, NULL_TREE));
779 		    }
780 		}
781 |	IMPORT_TK name DOT_TK error
782 		{yyerror ("'*' expected"); RECOVER;}
783 |	IMPORT_TK name DOT_TK MULT_TK error
784 		{yyerror ("';' expected"); RECOVER;}
785 ;
786 
787 type_declaration:
788 	class_declaration
789 		{ end_class_declaration (0); }
790 |	interface_declaration
791 		{ end_class_declaration (0); }
792 |	empty_statement
793 |	error
794 		{
795 		  YYERROR_NOW;
796 		  yyerror ("Class or interface declaration expected");
797 		}
798 ;
799 
800 /* 19.7 Shortened from the original:
801    modifiers: modifier | modifiers modifier
802    modifier: any of public...  */
803 modifiers:
804 	MODIFIER_TK
805 		{
806 		  $$ = (1 << $1);
807 		}
808 |	modifiers MODIFIER_TK
809 		{
810 		  int acc = (1 << $2);
811 		  if ($$ & acc)
812 		    parse_error_context
813 		      (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
814 		       java_accstring_lookup (acc));
815 		  else
816 		    {
817 		      $$ |= acc;
818 		    }
819 		}
820 ;
821 
822 /* 19.8.1 Production from $8.1: Class Declaration */
823 class_declaration:
824 	modifiers CLASS_TK identifier super interfaces
825 		{ create_class ($1, $3, $4, $5); }
826 	class_body
827 		{;}
828 |	CLASS_TK identifier super interfaces
829 		{ create_class (0, $2, $3, $4); }
830 	class_body
831 		{;}
832 |	modifiers CLASS_TK error
833 		{ yyerror ("Missing class name"); RECOVER; }
834 |	CLASS_TK error
835 		{ yyerror ("Missing class name"); RECOVER; }
836 |       CLASS_TK identifier error
837 		{
838 		  if (!ctxp->class_err) yyerror ("'{' expected");
839 		  DRECOVER(class1);
840 		}
841 |       modifiers CLASS_TK identifier error
842 		{ if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
843 ;
844 
845 super:
846 		{ $$ = NULL; }
847 |	EXTENDS_TK class_type
848 		{ $$ = $2; }
849 |	EXTENDS_TK class_type error
850 		{yyerror ("'{' expected"); ctxp->class_err=1;}
851 |	EXTENDS_TK error
852 		{yyerror ("Missing super class name"); ctxp->class_err=1;}
853 ;
854 
855 interfaces:
856 		{ $$ = NULL_TREE; }
857 |	IMPLEMENTS_TK interface_type_list
858 		{ $$ = $2; }
859 |	IMPLEMENTS_TK error
860 		{
861 		  ctxp->class_err=1;
862 		  yyerror ("Missing interface name");
863 		}
864 ;
865 
866 interface_type_list:
867 	interface_type
868 		{
869 		  ctxp->interface_number = 1;
870 		  $$ = build_tree_list ($1, NULL_TREE);
871 		}
872 |	interface_type_list C_TK interface_type
873 		{
874 		  ctxp->interface_number++;
875 		  $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
876 		}
877 |	interface_type_list C_TK error
878 		{yyerror ("Missing interface name"); RECOVER;}
879 ;
880 
881 class_body:
882 	OCB_TK CCB_TK
883 		{
884 		  /* Store the location of the `}' when doing xrefs */
885 		  if (flag_emit_xref)
886 		    DECL_END_SOURCE_LINE (GET_CPC ()) =
887 		      EXPR_WFL_ADD_COL ($2.location, 1);
888 		  $$ = GET_CPC ();
889 		}
890 |	OCB_TK class_body_declarations CCB_TK
891 		{
892 		  /* Store the location of the `}' when doing xrefs */
893 		  if (flag_emit_xref)
894 		    DECL_END_SOURCE_LINE (GET_CPC ()) =
895 		      EXPR_WFL_ADD_COL ($3.location, 1);
896 		  $$ = GET_CPC ();
897 		}
898 ;
899 
900 class_body_declarations:
901 	class_body_declaration
902 |	class_body_declarations class_body_declaration
903 ;
904 
905 class_body_declaration:
906 	class_member_declaration
907 |	static_initializer
908 |	constructor_declaration
909 |	block			/* Added, JDK1.1, instance initializer */
910 		{
911 		  if ($1 != empty_stmt_node)
912 		    {
913 		      TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
914 		      SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
915 		    }
916 		}
917 ;
918 
919 class_member_declaration:
920 	field_declaration
921 |	method_declaration
922 |	class_declaration	/* Added, JDK1.1 inner classes */
923 		{ end_class_declaration (1); }
924 |	interface_declaration	/* Added, JDK1.1 inner interfaces */
925 		{ end_class_declaration (1); }
926 |	empty_statement
927 ;
928 
929 /* 19.8.2 Productions from 8.3: Field Declarations  */
930 field_declaration:
931 	type variable_declarators SC_TK
932 		{ register_fields (0, $1, $2); }
933 |	modifiers type variable_declarators SC_TK
934 		{
935 		  check_modifiers
936 		    ("Illegal modifier `%s' for field declaration",
937 		     $1, FIELD_MODIFIERS);
938 		  check_modifiers_consistency ($1);
939 		  register_fields ($1, $2, $3);
940 		}
941 ;
942 
943 variable_declarators:
944 	/* Should we use build_decl_list () instead ? FIXME */
945 	variable_declarator	/* Default rule */
946 |	variable_declarators C_TK variable_declarator
947 		{ $$ = chainon ($1, $3); }
948 |	variable_declarators C_TK error
949 		{yyerror ("Missing term"); RECOVER;}
950 ;
951 
952 variable_declarator:
953 	variable_declarator_id
954 		{ $$ = build_tree_list ($1, NULL_TREE); }
955 |	variable_declarator_id ASSIGN_TK variable_initializer
956 		{
957 		  if (java_error_count)
958 		    $3 = NULL_TREE;
959 		  $$ = build_tree_list
960 		    ($1, build_assignment ($2.token, $2.location, $1, $3));
961 		}
962 |	variable_declarator_id ASSIGN_TK error
963 		{
964 		  yyerror ("Missing variable initializer");
965 		  $$ = build_tree_list ($1, NULL_TREE);
966 		  RECOVER;
967 		}
968 |	variable_declarator_id ASSIGN_TK variable_initializer error
969 		{
970 		  yyerror ("';' expected");
971 		  $$ = build_tree_list ($1, NULL_TREE);
972 		  RECOVER;
973 		}
974 ;
975 
976 variable_declarator_id:
977 	identifier
978 |	variable_declarator_id OSB_TK CSB_TK
979 		{ $$ = build_unresolved_array_type ($1); }
980 |	identifier error
981 		{yyerror ("Invalid declaration"); DRECOVER(vdi);}
982 |	variable_declarator_id OSB_TK error
983 		{
984 		  yyerror ("']' expected");
985 		  DRECOVER(vdi);
986 		}
987 |	variable_declarator_id CSB_TK error
988 		{yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
989 ;
990 
991 variable_initializer:
992 	expression
993 |	array_initializer
994 ;
995 
996 /* 19.8.3 Productions from 8.4: Method Declarations  */
997 method_declaration:
998 	method_header
999 		{
1000 		  current_function_decl = $1;
1001 		  if (current_function_decl
1002 		      && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1003 		    source_start_java_method (current_function_decl);
1004 		  else
1005 		    current_function_decl = NULL_TREE;
1006 		}
1007 	method_body
1008 		{ finish_method_declaration ($3); }
1009 |	method_header error
1010 		{YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1011 ;
1012 
1013 method_header:
1014 	type method_declarator throws
1015 		{ $$ = method_header (0, $1, $2, $3); }
1016 |	VOID_TK method_declarator throws
1017 		{ $$ = method_header (0, void_type_node, $2, $3); }
1018 |	modifiers type method_declarator throws
1019 		{ $$ = method_header ($1, $2, $3, $4); }
1020 |	modifiers VOID_TK method_declarator throws
1021 		{ $$ = method_header ($1, void_type_node, $3, $4); }
1022 |	type error
1023 		{
1024 		  yyerror ("Invalid method declaration, method name required");
1025 		  RECOVER;
1026 		}
1027 |	modifiers type error
1028 		{
1029 		  yyerror ("Identifier expected");
1030 		  RECOVER;
1031 		}
1032 |	VOID_TK error
1033 		{
1034 		  yyerror ("Identifier expected");
1035 		  RECOVER;
1036 		}
1037 |	modifiers VOID_TK error
1038 		{
1039 		  yyerror ("Identifier expected");
1040 		  RECOVER;
1041 		}
1042 |	modifiers error
1043 		{
1044 		  yyerror ("Invalid method declaration, return type required");
1045 		  RECOVER;
1046 		}
1047 ;
1048 
1049 method_declarator:
1050 	identifier OP_TK CP_TK
1051 		{
1052 		  ctxp->formal_parameter_number = 0;
1053 		  $$ = method_declarator ($1, NULL_TREE);
1054 		}
1055 |	identifier OP_TK formal_parameter_list CP_TK
1056 		{ $$ = method_declarator ($1, $3); }
1057 |	method_declarator OSB_TK CSB_TK
1058 		{
1059 		  EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1060 		  TREE_PURPOSE ($1) =
1061 		    build_unresolved_array_type (TREE_PURPOSE ($1));
1062 		  parse_warning_context
1063 		    (wfl_operator,
1064 		     "Discouraged form of returned type specification");
1065 		}
1066 |	identifier OP_TK error
1067 		{yyerror ("')' expected"); DRECOVER(method_declarator);}
1068 |	method_declarator OSB_TK error
1069 		{yyerror ("']' expected"); RECOVER;}
1070 ;
1071 
1072 formal_parameter_list:
1073 	formal_parameter
1074 		{
1075 		  ctxp->formal_parameter_number = 1;
1076 		}
1077 |	formal_parameter_list C_TK formal_parameter
1078 		{
1079 		  ctxp->formal_parameter_number += 1;
1080 		  $$ = chainon ($1, $3);
1081 		}
1082 |	formal_parameter_list C_TK error
1083 		{ yyerror ("Missing formal parameter term"); RECOVER; }
1084 ;
1085 
1086 formal_parameter:
1087 	type variable_declarator_id
1088 		{
1089 		  $$ = build_tree_list ($2, $1);
1090 		}
1091 |	final type variable_declarator_id /* Added, JDK1.1 final parms */
1092 		{
1093 		  $$ = build_tree_list ($3, $2);
1094 		  ARG_FINAL_P ($$) = 1;
1095 		}
1096 |	type error
1097 		{
1098 		  yyerror ("Missing identifier"); RECOVER;
1099 		  $$ = NULL_TREE;
1100 		}
1101 |	final type error
1102 		{
1103 		  yyerror ("Missing identifier"); RECOVER;
1104 		  $$ = NULL_TREE;
1105 		}
1106 ;
1107 
1108 final:
1109 	modifiers
1110 		{
1111 		  check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1112 				   $1, ACC_FINAL);
1113 		  if ($1 != ACC_FINAL)
1114 		    MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1115 		}
1116 ;
1117 
1118 throws:
1119 		{ $$ = NULL_TREE; }
1120 |	THROWS_TK class_type_list
1121 		{ $$ = $2; }
1122 |	THROWS_TK error
1123 		{yyerror ("Missing class type term"); RECOVER;}
1124 ;
1125 
1126 class_type_list:
1127 	class_type
1128 		{ $$ = build_tree_list ($1, $1); }
1129 |	class_type_list C_TK class_type
1130 		{ $$ = tree_cons ($3, $3, $1); }
1131 |	class_type_list C_TK error
1132 		{yyerror ("Missing class type term"); RECOVER;}
1133 ;
1134 
1135 method_body:
1136 	block
1137 |	SC_TK { $$ = NULL_TREE; }
1138 ;
1139 
1140 /* 19.8.4 Productions from 8.5: Static Initializers  */
1141 static_initializer:
1142 	static block
1143 		{
1144 		  TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1145 		  SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1146 		  current_static_block = NULL_TREE;
1147 		}
1148 ;
1149 
1150 static:				/* Test lval.sub_token here */
1151 	modifiers
1152 		{
1153 		  check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1154 		  /* Can't have a static initializer in an innerclass */
1155 		  if ($1 | ACC_STATIC &&
1156 		      GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1157 		    parse_error_context
1158 		      (MODIFIER_WFL (STATIC_TK),
1159 		       "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1160 		       IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1161 		  SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1162 		}
1163 ;
1164 
1165 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1166 constructor_declaration:
1167 	constructor_header
1168 		{
1169 		  current_function_decl = $1;
1170 		  source_start_java_method (current_function_decl);
1171 		}
1172 	constructor_body
1173 		{ finish_method_declaration ($3); }
1174 ;
1175 
1176 constructor_header:
1177 	constructor_declarator throws
1178 		{ $$ = method_header (0, NULL_TREE, $1, $2); }
1179 |	modifiers constructor_declarator throws
1180 		{ $$ = method_header ($1, NULL_TREE, $2, $3); }
1181 ;
1182 
1183 constructor_declarator:
1184 	simple_name OP_TK CP_TK
1185 		{
1186 		  ctxp->formal_parameter_number = 0;
1187 		  $$ = method_declarator ($1, NULL_TREE);
1188 		}
1189 |	simple_name OP_TK formal_parameter_list CP_TK
1190 		{ $$ = method_declarator ($1, $3); }
1191 ;
1192 
1193 constructor_body:
1194 	/* Unlike regular method, we always need a complete (empty)
1195 	   body so we can safely perform all the required code
1196 	   addition (super invocation and field initialization) */
1197 	block_begin constructor_block_end
1198 		{
1199 		  BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1200 		  $$ = $2;
1201 		}
1202 |	block_begin explicit_constructor_invocation constructor_block_end
1203 		{ $$ = $3; }
1204 |	block_begin block_statements constructor_block_end
1205 		{ $$ = $3; }
1206 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1207 		{ $$ = $4; }
1208 ;
1209 
1210 constructor_block_end:
1211 	block_end
1212 ;
1213 
1214 /* Error recovery for that rule moved down expression_statement: rule.  */
1215 explicit_constructor_invocation:
1216 	this_or_super OP_TK CP_TK SC_TK
1217 		{
1218 		  $$ = build_method_invocation ($1, NULL_TREE);
1219 		  $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1220 		  $$ = java_method_add_stmt (current_function_decl, $$);
1221 		}
1222 |	this_or_super OP_TK argument_list CP_TK SC_TK
1223 		{
1224 		  $$ = build_method_invocation ($1, $3);
1225 		  $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1226 		  $$ = java_method_add_stmt (current_function_decl, $$);
1227 		}
1228         /* Added, JDK1.1 inner classes. Modified because the rule
1229 	   'primary' couldn't work.  */
1230 |	name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1231 		{$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1232 |	name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1233 		{$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1234 ;
1235 
1236 this_or_super:			/* Added, simplifies error diagnostics */
1237 	THIS_TK
1238 		{
1239 		  tree wfl = build_wfl_node (this_identifier_node);
1240 		  EXPR_WFL_LINECOL (wfl) = $1.location;
1241 		  $$ = wfl;
1242 		}
1243 |	SUPER_TK
1244 		{
1245 		  tree wfl = build_wfl_node (super_identifier_node);
1246 		  EXPR_WFL_LINECOL (wfl) = $1.location;
1247 		  $$ = wfl;
1248 		}
1249 ;
1250 
1251 /* 19.9 Productions from 9: Interfaces  */
1252 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1253 interface_declaration:
1254 	INTERFACE_TK identifier
1255 		{ create_interface (0, $2, NULL_TREE); }
1256 	interface_body
1257 		{ ; }
1258 |	modifiers INTERFACE_TK identifier
1259 		{ create_interface ($1, $3, NULL_TREE); }
1260 	interface_body
1261 		{ ; }
1262 |	INTERFACE_TK identifier extends_interfaces
1263 		{ create_interface (0, $2, $3);	}
1264 	interface_body
1265 		{ ; }
1266 |	modifiers INTERFACE_TK identifier extends_interfaces
1267 		{ create_interface ($1, $3, $4); }
1268 	interface_body
1269 		{ ; }
1270 |	INTERFACE_TK identifier error
1271 		{ yyerror ("'{' expected"); RECOVER; }
1272 |	modifiers INTERFACE_TK identifier error
1273 		{ yyerror ("'{' expected"); RECOVER; }
1274 ;
1275 
1276 extends_interfaces:
1277 	EXTENDS_TK interface_type
1278 		{
1279 		  ctxp->interface_number = 1;
1280 		  $$ = build_tree_list ($2, NULL_TREE);
1281 		}
1282 |	extends_interfaces C_TK interface_type
1283 		{
1284 		  ctxp->interface_number++;
1285 		  $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1286 		}
1287 |	EXTENDS_TK error
1288 		{yyerror ("Invalid interface type"); RECOVER;}
1289 |	extends_interfaces C_TK error
1290 		{yyerror ("Missing term"); RECOVER;}
1291 ;
1292 
1293 interface_body:
1294 	OCB_TK CCB_TK
1295 		{ $$ = NULL_TREE; }
1296 |	OCB_TK interface_member_declarations CCB_TK
1297 		{ $$ = NULL_TREE; }
1298 ;
1299 
1300 interface_member_declarations:
1301 	interface_member_declaration
1302 |	interface_member_declarations interface_member_declaration
1303 ;
1304 
1305 interface_member_declaration:
1306 	constant_declaration
1307 |	abstract_method_declaration
1308 |	class_declaration	/* Added, JDK1.1 inner classes */
1309 		{ end_class_declaration (1); }
1310 |	interface_declaration	/* Added, JDK1.1 inner interfaces */
1311 		{ end_class_declaration (1); }
1312 ;
1313 
1314 constant_declaration:
1315 	field_declaration
1316 ;
1317 
1318 abstract_method_declaration:
1319 	method_header SC_TK
1320 		{
1321 		  check_abstract_method_header ($1);
1322 		  current_function_decl = NULL_TREE; /* FIXME ? */
1323 		}
1324 |	method_header error
1325 		{yyerror ("';' expected"); RECOVER;}
1326 ;
1327 
1328 /* 19.10 Productions from 10: Arrays  */
1329 array_initializer:
1330 	OCB_TK CCB_TK
1331 		{ $$ = build_new_array_init ($1.location, NULL_TREE); }
1332 |	OCB_TK C_TK CCB_TK
1333 		{ $$ = build_new_array_init ($1.location, NULL_TREE); }
1334 |	OCB_TK variable_initializers CCB_TK
1335 		{ $$ = build_new_array_init ($1.location, $2); }
1336 |	OCB_TK variable_initializers C_TK CCB_TK
1337 		{ $$ = build_new_array_init ($1.location, $2); }
1338 ;
1339 
1340 variable_initializers:
1341 	variable_initializer
1342 		{
1343 		  $$ = tree_cons (maybe_build_array_element_wfl ($1),
1344 				  $1, NULL_TREE);
1345 		}
1346 |	variable_initializers C_TK variable_initializer
1347 		{
1348 		  $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1349 		}
1350 |	variable_initializers C_TK error
1351 		{yyerror ("Missing term"); RECOVER;}
1352 ;
1353 
1354 /* 19.11 Production from 14: Blocks and Statements  */
1355 block:
1356 	block_begin block_end
1357 		{ $$ = $2; }
1358 |	block_begin block_statements block_end
1359 		{ $$ = $3; }
1360 ;
1361 
1362 block_begin:
1363 	OCB_TK
1364 		{ enter_block (); }
1365 ;
1366 
1367 block_end:
1368 	CCB_TK
1369 		{
1370 		  maybe_absorb_scoping_blocks ();
1371 		  /* Store the location of the `}' when doing xrefs */
1372 		  if (current_function_decl && flag_emit_xref)
1373 		    DECL_END_SOURCE_LINE (current_function_decl) =
1374 		      EXPR_WFL_ADD_COL ($1.location, 1);
1375 		  $$ = exit_block ();
1376 		  if (!BLOCK_SUBBLOCKS ($$))
1377 		    BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1378 		}
1379 ;
1380 
1381 block_statements:
1382 	block_statement
1383 |	block_statements block_statement
1384 ;
1385 
1386 block_statement:
1387 	local_variable_declaration_statement
1388 |	statement
1389 		{ java_method_add_stmt (current_function_decl, $1); }
1390 |	class_declaration	/* Added, JDK1.1 local classes */
1391 		{
1392 		  LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1393 		  end_class_declaration (1);
1394 		}
1395 ;
1396 
1397 local_variable_declaration_statement:
1398 	local_variable_declaration SC_TK /* Can't catch missing ';' here */
1399 ;
1400 
1401 local_variable_declaration:
1402 	type variable_declarators
1403 		{ declare_local_variables (0, $1, $2); }
1404 |	final type variable_declarators /* Added, JDK1.1 final locals */
1405 		{ declare_local_variables ($1, $2, $3); }
1406 ;
1407 
1408 statement:
1409 	statement_without_trailing_substatement
1410 |	labeled_statement
1411 |	if_then_statement
1412 |	if_then_else_statement
1413 |	while_statement
1414 |	for_statement
1415 		{ $$ = exit_block (); }
1416 ;
1417 
1418 statement_nsi:
1419 	statement_without_trailing_substatement
1420 |	labeled_statement_nsi
1421 |	if_then_else_statement_nsi
1422 |	while_statement_nsi
1423 |	for_statement_nsi
1424 		{ $$ = exit_block (); }
1425 ;
1426 
1427 statement_without_trailing_substatement:
1428 	block
1429 |	empty_statement
1430 |	expression_statement
1431 |	switch_statement
1432 |	do_statement
1433 |	break_statement
1434 |	continue_statement
1435 |	return_statement
1436 |	synchronized_statement
1437 |	throw_statement
1438 |	try_statement
1439 |	assert_statement
1440 ;
1441 
1442 empty_statement:
1443 	SC_TK
1444 		{
1445 		  if (flag_extraneous_semicolon
1446 		      && ! current_static_block
1447 		      && (! current_function_decl ||
1448 			  /* Verify we're not in a inner class declaration */
1449 			  (GET_CPC () != TYPE_NAME
1450 			   (DECL_CONTEXT (current_function_decl)))))
1451 
1452 		    {
1453 		      EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1454 		      parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1455 		    }
1456 		  $$ = empty_stmt_node;
1457 		}
1458 ;
1459 
1460 label_decl:
1461 	identifier REL_CL_TK
1462 		{
1463 		  $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1464 					    EXPR_WFL_NODE ($1));
1465 		  pushlevel (2);
1466 		  push_labeled_block ($$);
1467 		  PUSH_LABELED_BLOCK ($$);
1468 		}
1469 ;
1470 
1471 labeled_statement:
1472 	label_decl statement
1473 		{ $$ = finish_labeled_statement ($1, $2); }
1474 |	identifier error
1475 		{yyerror ("':' expected"); RECOVER;}
1476 ;
1477 
1478 labeled_statement_nsi:
1479 	label_decl statement_nsi
1480 		{ $$ = finish_labeled_statement ($1, $2); }
1481 ;
1482 
1483 /* We concentrate here a bunch of error handling rules that we couldn't write
1484    earlier, because expression_statement catches a missing ';'.  */
1485 expression_statement:
1486 	statement_expression SC_TK
1487 		{
1488 		  /* We have a statement. Generate a WFL around it so
1489 		     we can debug it */
1490 		  $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1491 		  /* We know we have a statement, so set the debug
1492                      info to be eventually generate here. */
1493 		  $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1494 		}
1495 |	error SC_TK
1496 		{
1497 		  YYNOT_TWICE yyerror ("Invalid expression statement");
1498 		  DRECOVER (expr_stmt);
1499 		}
1500 |	error OCB_TK
1501 		{
1502 		  YYNOT_TWICE yyerror ("Invalid expression statement");
1503 		  DRECOVER (expr_stmt);
1504 		}
1505 |	error CCB_TK
1506 		{
1507 		  YYNOT_TWICE yyerror ("Invalid expression statement");
1508 		  DRECOVER (expr_stmt);
1509 		}
1510 |       this_or_super OP_TK error
1511 		{yyerror ("')' expected"); RECOVER;}
1512 |       this_or_super OP_TK CP_TK error
1513 		{
1514 		  parse_ctor_invocation_error ();
1515 		  RECOVER;
1516 		}
1517 |       this_or_super OP_TK argument_list error
1518 		{yyerror ("')' expected"); RECOVER;}
1519 |       this_or_super OP_TK argument_list CP_TK error
1520 		{
1521 		  parse_ctor_invocation_error ();
1522 		  RECOVER;
1523 		}
1524 |	name DOT_TK SUPER_TK error
1525 		{yyerror ("'(' expected"); RECOVER;}
1526 |	name DOT_TK SUPER_TK OP_TK error
1527 		{yyerror ("')' expected"); RECOVER;}
1528 |	name DOT_TK SUPER_TK OP_TK argument_list error
1529 		{yyerror ("')' expected"); RECOVER;}
1530 |	name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1531 		{yyerror ("';' expected"); RECOVER;}
1532 |	name DOT_TK SUPER_TK OP_TK CP_TK error
1533 		{yyerror ("';' expected"); RECOVER;}
1534 ;
1535 
1536 statement_expression:
1537 	assignment
1538 |	pre_increment_expression
1539 |	pre_decrement_expression
1540 |	post_increment_expression
1541 |	post_decrement_expression
1542 |	method_invocation
1543 |	class_instance_creation_expression
1544 ;
1545 
1546 if_then_statement:
1547 	IF_TK OP_TK expression CP_TK statement
1548 		{
1549 		  $$ = build_if_else_statement ($2.location, $3,
1550 						$5, NULL_TREE);
1551 		}
1552 |	IF_TK error
1553 		{yyerror ("'(' expected"); RECOVER;}
1554 |	IF_TK OP_TK error
1555 		{yyerror ("Missing term"); RECOVER;}
1556 |	IF_TK OP_TK expression error
1557 		{yyerror ("')' expected"); RECOVER;}
1558 ;
1559 
1560 if_then_else_statement:
1561 	IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1562 		{ $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1563 ;
1564 
1565 if_then_else_statement_nsi:
1566 	IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1567 		{ $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1568 ;
1569 
1570 switch_statement:
1571 	switch_expression
1572 		{
1573 		  enter_block ();
1574 		}
1575 	switch_block
1576 		{
1577 		  /* Make into "proper list" of COMPOUND_EXPRs.
1578 		     I.e. make the last statement also have its own
1579 		     COMPOUND_EXPR. */
1580 		  maybe_absorb_scoping_blocks ();
1581 		  TREE_OPERAND ($1, 1) = exit_block ();
1582 		  $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1583 		}
1584 ;
1585 
1586 switch_expression:
1587 	SWITCH_TK OP_TK expression CP_TK
1588 		{
1589 		  $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1590 		  EXPR_WFL_LINECOL ($$) = $2.location;
1591 		}
1592 |	SWITCH_TK error
1593 		{yyerror ("'(' expected"); RECOVER;}
1594 |	SWITCH_TK OP_TK error
1595 		{yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1596 |	SWITCH_TK OP_TK expression CP_TK error
1597 		{yyerror ("'{' expected"); RECOVER;}
1598 ;
1599 
1600 /* Default assignment is there to avoid type node on switch_block
1601    node. */
1602 
1603 switch_block:
1604 	OCB_TK CCB_TK
1605 		{ $$ = NULL_TREE; }
1606 |	OCB_TK switch_labels CCB_TK
1607 		{ $$ = NULL_TREE; }
1608 |	OCB_TK switch_block_statement_groups CCB_TK
1609 		{ $$ = NULL_TREE; }
1610 |	OCB_TK switch_block_statement_groups switch_labels CCB_TK
1611 		{ $$ = NULL_TREE; }
1612 ;
1613 
1614 switch_block_statement_groups:
1615 	switch_block_statement_group
1616 |	switch_block_statement_groups switch_block_statement_group
1617 ;
1618 
1619 switch_block_statement_group:
1620 	switch_labels block_statements
1621 ;
1622 
1623 switch_labels:
1624 	switch_label
1625 |	switch_labels switch_label
1626 ;
1627 
1628 switch_label:
1629 	CASE_TK constant_expression REL_CL_TK
1630 		{
1631 		  tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1632 		  EXPR_WFL_LINECOL (lab) = $1.location;
1633 		  java_method_add_stmt (current_function_decl, lab);
1634 		}
1635 |	DEFAULT_TK REL_CL_TK
1636 		{
1637 		  tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1638 		  EXPR_WFL_LINECOL (lab) = $1.location;
1639 		  java_method_add_stmt (current_function_decl, lab);
1640 		}
1641 |	CASE_TK error
1642 		{yyerror ("Missing or invalid constant expression"); RECOVER;}
1643 |	CASE_TK constant_expression error
1644 		{yyerror ("':' expected"); RECOVER;}
1645 |	DEFAULT_TK error
1646 		{yyerror ("':' expected"); RECOVER;}
1647 ;
1648 
1649 while_expression:
1650 	WHILE_TK OP_TK expression CP_TK
1651 		{
1652 		  tree body = build_loop_body ($2.location, $3, 0);
1653 		  $$ = build_new_loop (body);
1654 		}
1655 ;
1656 
1657 while_statement:
1658 	while_expression statement
1659 		{ $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1660 |	WHILE_TK error
1661 		{YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1662 |	WHILE_TK OP_TK error
1663 		{yyerror ("Missing term and ')' expected"); RECOVER;}
1664 |	WHILE_TK OP_TK expression error
1665 		{yyerror ("')' expected"); RECOVER;}
1666 ;
1667 
1668 while_statement_nsi:
1669 	while_expression statement_nsi
1670 		{ $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1671 ;
1672 
1673 do_statement_begin:
1674 	DO_TK
1675 		{
1676 		  tree body = build_loop_body (0, NULL_TREE, 1);
1677 		  $$ = build_new_loop (body);
1678 		}
1679 	/* Need error handing here. FIXME */
1680 ;
1681 
1682 do_statement:
1683 	do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1684 		{ $$ = finish_loop_body ($4.location, $5, $2, 1); }
1685 ;
1686 
1687 for_statement:
1688 	for_begin SC_TK expression SC_TK for_update CP_TK statement
1689 		{
1690 		  if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1691 		    $3 = build_wfl_node ($3);
1692 		  $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1693 		}
1694 |	for_begin SC_TK SC_TK for_update CP_TK statement
1695 		{
1696 		  $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1697 		  /* We have not condition, so we get rid of the EXIT_EXPR */
1698 		  LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1699 		    empty_stmt_node;
1700 		}
1701 |	for_begin SC_TK error
1702 		{yyerror ("Invalid control expression"); RECOVER;}
1703 |	for_begin SC_TK expression SC_TK error
1704 		{yyerror ("Invalid update expression"); RECOVER;}
1705 |	for_begin SC_TK SC_TK error
1706 		{yyerror ("Invalid update expression"); RECOVER;}
1707 ;
1708 
1709 for_statement_nsi:
1710 	for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1711 		{ $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1712 |	for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1713 		{
1714 		  $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1715 		  /* We have not condition, so we get rid of the EXIT_EXPR */
1716 		  LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1717 		    empty_stmt_node;
1718 		}
1719 ;
1720 
1721 for_header:
1722 	FOR_TK OP_TK
1723 		{
1724 		  /* This scope defined for local variable that may be
1725                      defined within the scope of the for loop */
1726 		  enter_block ();
1727 		}
1728 |	FOR_TK error
1729 		{yyerror ("'(' expected"); DRECOVER(for_1);}
1730 |	FOR_TK OP_TK error
1731 		{yyerror ("Invalid init statement"); RECOVER;}
1732 ;
1733 
1734 for_begin:
1735 	for_header for_init
1736 		{
1737 		  /* We now declare the loop body. The loop is
1738                      declared as a for loop. */
1739 		  tree body = build_loop_body (0, NULL_TREE, 0);
1740 		  $$ =  build_new_loop (body);
1741 		  FOR_LOOP_P ($$) = 1;
1742 		  /* The loop is added to the current block the for
1743                      statement is defined within */
1744 		  java_method_add_stmt (current_function_decl, $$);
1745 		}
1746 ;
1747 for_init:			/* Can be empty */
1748 		{ $$ = empty_stmt_node; }
1749 |	statement_expression_list
1750 		{
1751 		  /* Init statement recorded within the previously
1752                      defined block scope */
1753 		  $$ = java_method_add_stmt (current_function_decl, $1);
1754 		}
1755 |	local_variable_declaration
1756 		{
1757 		  /* Local variable are recorded within the previously
1758 		     defined block scope */
1759 		  $$ = NULL_TREE;
1760 		}
1761 |	statement_expression_list error
1762 		{yyerror ("';' expected"); DRECOVER(for_init_1);}
1763 ;
1764 
1765 for_update:			/* Can be empty */
1766 		{$$ = empty_stmt_node;}
1767 |	statement_expression_list
1768 		{ $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1769 ;
1770 
1771 statement_expression_list:
1772 	statement_expression
1773 		{ $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1774 |	statement_expression_list C_TK statement_expression
1775 		{ $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1776 |	statement_expression_list C_TK error
1777 		{yyerror ("Missing term"); RECOVER;}
1778 ;
1779 
1780 break_statement:
1781 	BREAK_TK SC_TK
1782 		{ $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1783 |	BREAK_TK identifier SC_TK
1784 		{ $$ = build_bc_statement ($1.location, 1, $2); }
1785 |	BREAK_TK error
1786 		{yyerror ("Missing term"); RECOVER;}
1787 |	BREAK_TK identifier error
1788 		{yyerror ("';' expected"); RECOVER;}
1789 ;
1790 
1791 continue_statement:
1792 	CONTINUE_TK SC_TK
1793 		{ $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1794 |       CONTINUE_TK identifier SC_TK
1795 		{ $$ = build_bc_statement ($1.location, 0, $2); }
1796 |	CONTINUE_TK error
1797 		{yyerror ("Missing term"); RECOVER;}
1798 |	CONTINUE_TK identifier error
1799 		{yyerror ("';' expected"); RECOVER;}
1800 ;
1801 
1802 return_statement:
1803 	RETURN_TK SC_TK
1804 		{ $$ = build_return ($1.location, NULL_TREE); }
1805 |	RETURN_TK expression SC_TK
1806 		{ $$ = build_return ($1.location, $2); }
1807 |	RETURN_TK error
1808 		{yyerror ("Missing term"); RECOVER;}
1809 |	RETURN_TK expression error
1810 		{yyerror ("';' expected"); RECOVER;}
1811 ;
1812 
1813 throw_statement:
1814 	THROW_TK expression SC_TK
1815 		{
1816 		  $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1817 		  EXPR_WFL_LINECOL ($$) = $1.location;
1818 		}
1819 |	THROW_TK error
1820 		{yyerror ("Missing term"); RECOVER;}
1821 |	THROW_TK expression error
1822 		{yyerror ("';' expected"); RECOVER;}
1823 ;
1824 
1825 assert_statement:
1826 	ASSERT_TK expression REL_CL_TK expression SC_TK
1827 		{
1828 		  $$ = build_assertion ($1.location, $2, $4);
1829 		}
1830 |	ASSERT_TK expression SC_TK
1831 		{
1832 		  $$ = build_assertion ($1.location, $2, NULL_TREE);
1833 		}
1834 |	ASSERT_TK error
1835 		{yyerror ("Missing term"); RECOVER;}
1836 |	ASSERT_TK expression error
1837 		{yyerror ("';' expected"); RECOVER;}
1838 ;
1839 
1840 synchronized_statement:
1841 	synchronized OP_TK expression CP_TK block
1842 		{
1843 		  $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1844 		  EXPR_WFL_LINECOL ($$) =
1845 		    EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1846 		}
1847 |	synchronized OP_TK expression CP_TK error
1848 		{yyerror ("'{' expected"); RECOVER;}
1849 |	synchronized error
1850 		{yyerror ("'(' expected"); RECOVER;}
1851 |	synchronized OP_TK error CP_TK
1852 		{yyerror ("Missing term"); RECOVER;}
1853 |	synchronized OP_TK error
1854 		{yyerror ("Missing term"); RECOVER;}
1855 ;
1856 
1857 synchronized:
1858 	modifiers
1859 		{
1860 		  check_modifiers (
1861              "Illegal modifier `%s'. Only `synchronized' was expected here",
1862 				   $1, ACC_SYNCHRONIZED);
1863 		  if ($1 != ACC_SYNCHRONIZED)
1864 		    MODIFIER_WFL (SYNCHRONIZED_TK) =
1865 		      build_wfl_node (NULL_TREE);
1866 		}
1867 ;
1868 
1869 try_statement:
1870 	TRY_TK block catches
1871 		{ $$ = build_try_statement ($1.location, $2, $3); }
1872 |	TRY_TK block finally
1873 		{ $$ = build_try_finally_statement ($1.location, $2, $3); }
1874 |	TRY_TK block catches finally
1875 		{ $$ = build_try_finally_statement
1876 		    ($1.location, build_try_statement ($1.location,
1877 						       $2, $3), $4);
1878 		}
1879 |	TRY_TK error
1880 		{yyerror ("'{' expected"); DRECOVER (try_statement);}
1881 ;
1882 
1883 catches:
1884 	catch_clause
1885 |	catches catch_clause
1886 		{
1887 		  TREE_CHAIN ($2) = $1;
1888 		  $$ = $2;
1889 		}
1890 ;
1891 
1892 catch_clause:
1893 	catch_clause_parameter block
1894 		{
1895 		  java_method_add_stmt (current_function_decl, $2);
1896 		  exit_block ();
1897 		  $$ = $1;
1898 		}
1899 ;
1900 
1901 catch_clause_parameter:
1902 	CATCH_TK OP_TK formal_parameter CP_TK
1903 		{
1904 		  /* We add a block to define a scope for
1905 		     formal_parameter (CCBP). The formal parameter is
1906 		     declared initialized by the appropriate function
1907 		     call */
1908                   tree ccpb;
1909                   tree init;
1910                   if ($3)
1911                     {
1912                       ccpb = enter_block ();
1913                       init = build_assignment
1914                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1915                          build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1916                       declare_local_variables (0, TREE_VALUE ($3),
1917                                                build_tree_list
1918 					       (TREE_PURPOSE ($3), init));
1919                       $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1920                       EXPR_WFL_LINECOL ($$) = $1.location;
1921                     }
1922                   else
1923                     {
1924                       $$ = error_mark_node;
1925                     }
1926 		}
1927 |	CATCH_TK error
1928 		{yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1929 |	CATCH_TK OP_TK error
1930 		{
1931 		  yyerror ("Missing term or ')' expected");
1932 		  RECOVER; $$ = NULL_TREE;
1933 		}
1934 |	CATCH_TK OP_TK error CP_TK /* That's for () */
1935 		{yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1936 ;
1937 
1938 finally:
1939 	FINALLY_TK block
1940 		{ $$ = $2; }
1941 |	FINALLY_TK error
1942 		{yyerror ("'{' expected"); RECOVER; }
1943 ;
1944 
1945 /* 19.12 Production from 15: Expressions  */
1946 primary:
1947 	primary_no_new_array
1948 |	array_creation_expression
1949 ;
1950 
1951 primary_no_new_array:
1952 	literal
1953 |	THIS_TK
1954 		{ $$ = build_this ($1.location); }
1955 |	OP_TK expression CP_TK
1956 		{$$ = $2;}
1957 |	class_instance_creation_expression
1958 |	field_access
1959 |	method_invocation
1960 |	array_access
1961 |	type_literals
1962         /* Added, JDK1.1 inner classes. Documentation is wrong
1963            refering to a 'ClassName' (class_name) rule that doesn't
1964            exist. Used name: instead.  */
1965 |	name DOT_TK THIS_TK
1966 		{
1967 		  tree wfl = build_wfl_node (this_identifier_node);
1968 		  $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1969 		}
1970 |	OP_TK expression error
1971 		{yyerror ("')' expected"); RECOVER;}
1972 |	name DOT_TK error
1973 		{yyerror ("'class' or 'this' expected" ); RECOVER;}
1974 |	primitive_type DOT_TK error
1975 		{yyerror ("'class' expected" ); RECOVER;}
1976 |	VOID_TK DOT_TK error
1977 		{yyerror ("'class' expected" ); RECOVER;}
1978 ;
1979 
1980 type_literals:
1981 	name DOT_TK CLASS_TK
1982 		{ $$ = build_incomplete_class_ref ($2.location, $1); }
1983 |	array_type DOT_TK CLASS_TK
1984 		{ $$ = build_incomplete_class_ref ($2.location, $1); }
1985 |	primitive_type DOT_TK CLASS_TK
1986                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1987 |	VOID_TK DOT_TK CLASS_TK
1988                 {
1989                    $$ = build_incomplete_class_ref ($2.location,
1990                                                    void_type_node);
1991                 }
1992 ;
1993 
1994 class_instance_creation_expression:
1995 	NEW_TK class_type OP_TK argument_list CP_TK
1996 		{ $$ = build_new_invocation ($2, $4); }
1997 |	NEW_TK class_type OP_TK CP_TK
1998 		{ $$ = build_new_invocation ($2, NULL_TREE); }
1999 |	anonymous_class_creation
2000         /* Added, JDK1.1 inner classes, modified to use name or
2001 	   primary instead of primary solely which couldn't work in
2002 	   all situations.  */
2003 |	something_dot_new identifier OP_TK CP_TK
2004 		{
2005 		  tree ctor = build_new_invocation ($2, NULL_TREE);
2006 		  $$ = make_qualified_primary ($1, ctor,
2007 					       EXPR_WFL_LINECOL ($1));
2008 		}
2009 |	something_dot_new identifier OP_TK CP_TK class_body
2010 |	something_dot_new identifier OP_TK argument_list CP_TK
2011 		{
2012 		  tree ctor = build_new_invocation ($2, $4);
2013 		  $$ = make_qualified_primary ($1, ctor,
2014 					       EXPR_WFL_LINECOL ($1));
2015 		}
2016 |	something_dot_new identifier OP_TK argument_list CP_TK class_body
2017 |	NEW_TK error SC_TK
2018 		{yyerror ("'(' expected"); DRECOVER(new_1);}
2019 |	NEW_TK class_type error
2020 		{yyerror ("'(' expected"); RECOVER;}
2021 |	NEW_TK class_type OP_TK error
2022 		{yyerror ("')' or term expected"); RECOVER;}
2023 |	NEW_TK class_type OP_TK argument_list error
2024 		{yyerror ("')' expected"); RECOVER;}
2025 |	something_dot_new error
2026 		{YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2027 |	something_dot_new identifier error
2028 		{yyerror ("'(' expected"); RECOVER;}
2029 ;
2030 
2031 /* Created after JDK1.1 rules originally added to
2032    class_instance_creation_expression, but modified to use
2033    'class_type' instead of 'TypeName' (type_name) which is mentioned
2034    in the documentation but doesn't exist. */
2035 
2036 anonymous_class_creation:
2037 	NEW_TK class_type OP_TK argument_list CP_TK
2038 		{ create_anonymous_class ($1.location, $2); }
2039         class_body
2040 		{
2041 		  tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2042 		  EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2043 
2044 		  end_class_declaration (1);
2045 
2046 		  /* Now we can craft the new expression */
2047 		  $$ = build_new_invocation (id, $4);
2048 
2049 		  /* Note that we can't possibly be here if
2050 		     `class_type' is an interface (in which case the
2051 		     anonymous class extends Object and implements
2052 		     `class_type', hence its constructor can't have
2053 		     arguments.) */
2054 
2055 		  /* Otherwise, the innerclass must feature a
2056 		     constructor matching `argument_list'. Anonymous
2057 		     classes are a bit special: it's impossible to
2058 		     define constructor for them, hence constructors
2059 		     must be generated following the hints provided by
2060 		     the `new' expression. Whether a super constructor
2061 		     of that nature exists or not is to be verified
2062 		     later on in verify_constructor_super.
2063 
2064 		     It's during the expansion of a `new' statement
2065 		     refering to an anonymous class that a ctor will
2066 		     be generated for the anonymous class, with the
2067 		     right arguments. */
2068 
2069 		}
2070 |	NEW_TK class_type OP_TK CP_TK
2071 		{ create_anonymous_class ($1.location, $2); }
2072         class_body
2073 		{
2074 		  tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2075 		  EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2076 
2077 		  end_class_declaration (1);
2078 
2079 		  /* Now we can craft the new expression. The
2080                      statement doesn't need to be remember so that a
2081                      constructor can be generated, since its signature
2082                      is already known. */
2083 		  $$ = build_new_invocation (id, NULL_TREE);
2084 		}
2085 ;
2086 
2087 something_dot_new:		/* Added, not part of the specs. */
2088 	name DOT_TK NEW_TK
2089 		{ $$ = $1; }
2090 |	primary DOT_TK NEW_TK
2091 		{ $$ = $1; }
2092 ;
2093 
2094 argument_list:
2095 	expression
2096 		{
2097 		  $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2098 		  ctxp->formal_parameter_number = 1;
2099 		}
2100 |	argument_list C_TK expression
2101 		{
2102 		  ctxp->formal_parameter_number += 1;
2103 		  $$ = tree_cons (NULL_TREE, $3, $1);
2104 		}
2105 |	argument_list C_TK error
2106 		{yyerror ("Missing term"); RECOVER;}
2107 ;
2108 
2109 array_creation_expression:
2110 	NEW_TK primitive_type dim_exprs
2111 		{ $$ = build_newarray_node ($2, $3, 0); }
2112 |	NEW_TK class_or_interface_type dim_exprs
2113 		{ $$ = build_newarray_node ($2, $3, 0); }
2114 |	NEW_TK primitive_type dim_exprs dims
2115 		{ $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2116 |	NEW_TK class_or_interface_type dim_exprs dims
2117 		{ $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2118         /* Added, JDK1.1 anonymous array. Initial documentation rule
2119            modified */
2120 |	NEW_TK class_or_interface_type dims array_initializer
2121 		{
2122 		  char *sig;
2123 		  int osb = pop_current_osb (ctxp);
2124 		  while (osb--)
2125 		    obstack_grow (&temporary_obstack, "[]", 2);
2126 		  obstack_1grow (&temporary_obstack, '\0');
2127 		  sig = obstack_finish (&temporary_obstack);
2128 		  $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2129 			      $2, get_identifier (sig), $4);
2130 		}
2131 |	NEW_TK primitive_type dims array_initializer
2132 		{
2133 		  int osb = pop_current_osb (ctxp);
2134 		  tree type = $2;
2135 		  while (osb--)
2136 		    type = build_java_array_type (type, -1);
2137 		  $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2138 			      build_pointer_type (type), NULL_TREE, $4);
2139 		}
2140 |	NEW_TK error CSB_TK
2141 		{yyerror ("'[' expected"); DRECOVER ("]");}
2142 |	NEW_TK error OSB_TK
2143 		{yyerror ("']' expected"); RECOVER;}
2144 ;
2145 
2146 dim_exprs:
2147 	dim_expr
2148 		{ $$ = build_tree_list (NULL_TREE, $1); }
2149 |	dim_exprs dim_expr
2150 		{ $$ = tree_cons (NULL_TREE, $2, $$); }
2151 ;
2152 
2153 dim_expr:
2154 	OSB_TK expression CSB_TK
2155 		{
2156 		  if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2157 		    {
2158 		      $2 = build_wfl_node ($2);
2159 		      TREE_TYPE ($2) = NULL_TREE;
2160 		    }
2161 		  EXPR_WFL_LINECOL ($2) = $1.location;
2162 		  $$ = $2;
2163 		}
2164 |	OSB_TK expression error
2165 		{yyerror ("']' expected"); RECOVER;}
2166 |	OSB_TK error
2167 		{
2168 		  yyerror ("Missing term");
2169 		  yyerror ("']' expected");
2170 		  RECOVER;
2171 		}
2172 ;
2173 
2174 dims:
2175 	OSB_TK CSB_TK
2176 		{
2177 		  int allocate = 0;
2178 		  /* If not initialized, allocate memory for the osb
2179                      numbers stack */
2180 		  if (!ctxp->osb_limit)
2181 		    {
2182 		      allocate = ctxp->osb_limit = 32;
2183 		      ctxp->osb_depth = -1;
2184 		    }
2185 		  /* If capacity overflown, reallocate a bigger chunk */
2186 		  else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2187 		    allocate = ctxp->osb_limit << 1;
2188 
2189 		  if (allocate)
2190 		    {
2191 		      allocate *= sizeof (int);
2192 		      if (ctxp->osb_number)
2193 			ctxp->osb_number = xrealloc (ctxp->osb_number,
2194 						     allocate);
2195 		      else
2196 			ctxp->osb_number = xmalloc (allocate);
2197 		    }
2198 		  ctxp->osb_depth++;
2199 		  CURRENT_OSB (ctxp) = 1;
2200 		}
2201 |	dims OSB_TK CSB_TK
2202 		{ CURRENT_OSB (ctxp)++; }
2203 |	dims OSB_TK error
2204 		{ yyerror ("']' expected"); RECOVER;}
2205 ;
2206 
2207 field_access:
2208 	primary DOT_TK identifier
2209 		{ $$ = make_qualified_primary ($1, $3, $2.location); }
2210 		/*  FIXME - REWRITE TO:
2211 		{ $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2212 |	SUPER_TK DOT_TK identifier
2213 		{
2214 		  tree super_wfl = build_wfl_node (super_identifier_node);
2215 		  EXPR_WFL_LINECOL (super_wfl) = $1.location;
2216 		  $$ = make_qualified_name (super_wfl, $3, $2.location);
2217 		}
2218 |	SUPER_TK error
2219 		{yyerror ("Field expected"); DRECOVER (super_field_acces);}
2220 ;
2221 
2222 method_invocation:
2223 	name OP_TK CP_TK
2224 		{ $$ = build_method_invocation ($1, NULL_TREE); }
2225 |	name OP_TK argument_list CP_TK
2226 		{ $$ = build_method_invocation ($1, $3); }
2227 |	primary DOT_TK identifier OP_TK CP_TK
2228 		{
2229 		  if (TREE_CODE ($1) == THIS_EXPR)
2230 		    $$ = build_this_super_qualified_invocation
2231 		      (1, $3, NULL_TREE, 0, $2.location);
2232 		  else
2233 		    {
2234 		      tree invok = build_method_invocation ($3, NULL_TREE);
2235 		      $$ = make_qualified_primary ($1, invok, $2.location);
2236 		    }
2237 		}
2238 |	primary DOT_TK identifier OP_TK argument_list CP_TK
2239 		{
2240 		  if (TREE_CODE ($1) == THIS_EXPR)
2241 		    $$ = build_this_super_qualified_invocation
2242 		      (1, $3, $5, 0, $2.location);
2243 		  else
2244 		    {
2245 		      tree invok = build_method_invocation ($3, $5);
2246 		      $$ = make_qualified_primary ($1, invok, $2.location);
2247 		    }
2248 		}
2249 |	SUPER_TK DOT_TK identifier OP_TK CP_TK
2250 		{
2251 		  $$ = build_this_super_qualified_invocation
2252 		    (0, $3, NULL_TREE, $1.location, $2.location);
2253 		}
2254 |	SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2255 		{
2256 		  $$ = build_this_super_qualified_invocation
2257 		    (0, $3, $5, $1.location, $2.location);
2258 		}
2259         /* Screws up thing. I let it here until I'm convinced it can
2260            be removed. FIXME
2261 |	primary DOT_TK error
2262 		{yyerror ("'(' expected"); DRECOVER(bad);} */
2263 |	SUPER_TK DOT_TK error CP_TK
2264 		{ yyerror ("'(' expected"); DRECOVER (method_invocation); }
2265 |	SUPER_TK DOT_TK error DOT_TK
2266 		{ yyerror ("'(' expected"); DRECOVER (method_invocation); }
2267 ;
2268 
2269 array_access:
2270 	name OSB_TK expression CSB_TK
2271 		{ $$ = build_array_ref ($2.location, $1, $3); }
2272 |	primary_no_new_array OSB_TK expression CSB_TK
2273 		{ $$ = build_array_ref ($2.location, $1, $3); }
2274 |	name OSB_TK error
2275 		{
2276 		  yyerror ("Missing term and ']' expected");
2277 		  DRECOVER(array_access);
2278 		}
2279 |	name OSB_TK expression error
2280 		{
2281 		  yyerror ("']' expected");
2282 		  DRECOVER(array_access);
2283 		}
2284 |	primary_no_new_array OSB_TK error
2285 		{
2286 		  yyerror ("Missing term and ']' expected");
2287 		  DRECOVER(array_access);
2288 		}
2289 |	primary_no_new_array OSB_TK expression error
2290 		{
2291 		  yyerror ("']' expected");
2292 		  DRECOVER(array_access);
2293 		}
2294 ;
2295 
2296 postfix_expression:
2297 	primary
2298 |	name
2299 |	post_increment_expression
2300 |	post_decrement_expression
2301 ;
2302 
2303 post_increment_expression:
2304 	postfix_expression INCR_TK
2305 		{ $$ = build_incdec ($2.token, $2.location, $1, 1); }
2306 ;
2307 
2308 post_decrement_expression:
2309 	postfix_expression DECR_TK
2310 		{ $$ = build_incdec ($2.token, $2.location, $1, 1); }
2311 ;
2312 
2313 trap_overflow_corner_case:
2314 	pre_increment_expression
2315 |	pre_decrement_expression
2316 |	PLUS_TK unary_expression
2317 		{$$ = build_unaryop ($1.token, $1.location, $2); }
2318 |	unary_expression_not_plus_minus
2319 |	PLUS_TK error
2320 		{yyerror ("Missing term"); RECOVER}
2321 ;
2322 
2323 unary_expression:
2324 	trap_overflow_corner_case
2325 		{
2326 		  error_if_numeric_overflow ($1);
2327 		  $$ = $1;
2328 		}
2329 |	MINUS_TK trap_overflow_corner_case
2330 		{$$ = build_unaryop ($1.token, $1.location, $2); }
2331 |	MINUS_TK error
2332 		{yyerror ("Missing term"); RECOVER}
2333 ;
2334 
2335 pre_increment_expression:
2336 	INCR_TK unary_expression
2337 		{$$ = build_incdec ($1.token, $1.location, $2, 0); }
2338 |	INCR_TK error
2339 		{yyerror ("Missing term"); RECOVER}
2340 ;
2341 
2342 pre_decrement_expression:
2343 	DECR_TK unary_expression
2344 		{$$ = build_incdec ($1.token, $1.location, $2, 0); }
2345 |	DECR_TK error
2346 		{yyerror ("Missing term"); RECOVER}
2347 ;
2348 
2349 unary_expression_not_plus_minus:
2350 	postfix_expression
2351 |	NOT_TK unary_expression
2352 		{$$ = build_unaryop ($1.token, $1.location, $2); }
2353 |	NEG_TK unary_expression
2354  		{$$ = build_unaryop ($1.token, $1.location, $2); }
2355 |	cast_expression
2356 |       NOT_TK error
2357 		{yyerror ("Missing term"); RECOVER}
2358 |       NEG_TK error
2359 		{yyerror ("Missing term"); RECOVER}
2360 ;
2361 
2362 cast_expression:		/* Error handling here is potentially weak */
2363 	OP_TK primitive_type dims CP_TK unary_expression
2364 		{
2365 		  tree type = $2;
2366 		  int osb = pop_current_osb (ctxp);
2367 		  while (osb--)
2368 		    type = build_java_array_type (type, -1);
2369 		  $$ = build_cast ($1.location, type, $5);
2370 		}
2371 |	OP_TK primitive_type CP_TK unary_expression
2372 		{ $$ = build_cast ($1.location, $2, $4); }
2373 |	OP_TK expression CP_TK unary_expression_not_plus_minus
2374 		{ $$ = build_cast ($1.location, $2, $4); }
2375 |	OP_TK name dims CP_TK unary_expression_not_plus_minus
2376 		{
2377 		  const char *ptr;
2378 		  int osb = pop_current_osb (ctxp);
2379 		  obstack_grow (&temporary_obstack,
2380 				IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2381 				IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2382 		  while (osb--)
2383 		    obstack_grow (&temporary_obstack, "[]", 2);
2384 		  obstack_1grow (&temporary_obstack, '\0');
2385 		  ptr = obstack_finish (&temporary_obstack);
2386 		  EXPR_WFL_NODE ($2) = get_identifier (ptr);
2387 		  $$ = build_cast ($1.location, $2, $5);
2388 		}
2389 |	OP_TK primitive_type OSB_TK error
2390 		{yyerror ("']' expected, invalid type expression");}
2391 |       OP_TK error
2392 		{
2393 	          YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2394 		  RECOVER;
2395 		}
2396 |	OP_TK primitive_type dims CP_TK error
2397 		{yyerror ("Missing term"); RECOVER;}
2398 |	OP_TK primitive_type CP_TK error
2399 		{yyerror ("Missing term"); RECOVER;}
2400 |	OP_TK name dims CP_TK error
2401 		{yyerror ("Missing term"); RECOVER;}
2402 ;
2403 
2404 multiplicative_expression:
2405 	unary_expression
2406 |	multiplicative_expression MULT_TK unary_expression
2407 		{
2408 		  $$ = build_binop (BINOP_LOOKUP ($2.token),
2409 				    $2.location, $1, $3);
2410 		}
2411 |	multiplicative_expression DIV_TK unary_expression
2412 		{
2413 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2414 				    $1, $3);
2415 		}
2416 |	multiplicative_expression REM_TK unary_expression
2417 		{
2418 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2419 				    $1, $3);
2420 		}
2421 |	multiplicative_expression MULT_TK error
2422 		{yyerror ("Missing term"); RECOVER;}
2423 |	multiplicative_expression DIV_TK error
2424 		{yyerror ("Missing term"); RECOVER;}
2425 |	multiplicative_expression REM_TK error
2426 		{yyerror ("Missing term"); RECOVER;}
2427 ;
2428 
2429 additive_expression:
2430 	multiplicative_expression
2431 |	additive_expression PLUS_TK multiplicative_expression
2432 		{
2433 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2434 				    $1, $3);
2435 		}
2436 |	additive_expression MINUS_TK multiplicative_expression
2437 		{
2438 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2439 				    $1, $3);
2440 		}
2441 |	additive_expression PLUS_TK error
2442 		{yyerror ("Missing term"); RECOVER;}
2443 |	additive_expression MINUS_TK error
2444 		{yyerror ("Missing term"); RECOVER;}
2445 ;
2446 
2447 shift_expression:
2448 	additive_expression
2449 |	shift_expression LS_TK additive_expression
2450 		{
2451 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2452 				    $1, $3);
2453 		}
2454 |	shift_expression SRS_TK additive_expression
2455 		{
2456 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2457 				    $1, $3);
2458 		}
2459 |	shift_expression ZRS_TK additive_expression
2460 		{
2461 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2462 				    $1, $3);
2463 		}
2464 |	shift_expression LS_TK error
2465 		{yyerror ("Missing term"); RECOVER;}
2466 |	shift_expression SRS_TK error
2467 		{yyerror ("Missing term"); RECOVER;}
2468 |	shift_expression ZRS_TK error
2469 		{yyerror ("Missing term"); RECOVER;}
2470 ;
2471 
2472 relational_expression:
2473 	shift_expression
2474 |	relational_expression LT_TK shift_expression
2475 		{
2476 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2477 				    $1, $3);
2478 		}
2479 |	relational_expression GT_TK shift_expression
2480 		{
2481 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2482 				    $1, $3);
2483 		}
2484 |	relational_expression LTE_TK shift_expression
2485 		{
2486 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2487 				    $1, $3);
2488 		}
2489 |	relational_expression GTE_TK shift_expression
2490 		{
2491 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2492 				    $1, $3);
2493 		}
2494 |	relational_expression INSTANCEOF_TK reference_type
2495 		{ $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2496 |	relational_expression LT_TK error
2497 		{yyerror ("Missing term"); RECOVER;}
2498 |	relational_expression GT_TK error
2499 		{yyerror ("Missing term"); RECOVER;}
2500 |	relational_expression LTE_TK error
2501 		{yyerror ("Missing term"); RECOVER;}
2502 |	relational_expression GTE_TK error
2503 		{yyerror ("Missing term"); RECOVER;}
2504 |	relational_expression INSTANCEOF_TK error
2505 		{yyerror ("Invalid reference type"); RECOVER;}
2506 ;
2507 
2508 equality_expression:
2509 	relational_expression
2510 |	equality_expression EQ_TK relational_expression
2511 		{
2512 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2513 				    $1, $3);
2514 		}
2515 |	equality_expression NEQ_TK relational_expression
2516 		{
2517 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2518 				    $1, $3);
2519 		}
2520 |	equality_expression EQ_TK error
2521 		{yyerror ("Missing term"); RECOVER;}
2522 |	equality_expression NEQ_TK error
2523 		{yyerror ("Missing term"); RECOVER;}
2524 ;
2525 
2526 and_expression:
2527 	equality_expression
2528 |	and_expression AND_TK equality_expression
2529 		{
2530 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2531 				    $1, $3);
2532 		}
2533 |	and_expression AND_TK error
2534 		{yyerror ("Missing term"); RECOVER;}
2535 ;
2536 
2537 exclusive_or_expression:
2538 	and_expression
2539 |	exclusive_or_expression XOR_TK and_expression
2540 		{
2541 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2542 				    $1, $3);
2543 		}
2544 |	exclusive_or_expression XOR_TK error
2545 		{yyerror ("Missing term"); RECOVER;}
2546 ;
2547 
2548 inclusive_or_expression:
2549 	exclusive_or_expression
2550 |	inclusive_or_expression OR_TK exclusive_or_expression
2551 		{
2552 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2553 				    $1, $3);
2554 		}
2555 |	inclusive_or_expression OR_TK error
2556 		{yyerror ("Missing term"); RECOVER;}
2557 ;
2558 
2559 conditional_and_expression:
2560 	inclusive_or_expression
2561 |	conditional_and_expression BOOL_AND_TK inclusive_or_expression
2562 		{
2563 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2564 				    $1, $3);
2565 		}
2566 |	conditional_and_expression BOOL_AND_TK error
2567 		{yyerror ("Missing term"); RECOVER;}
2568 ;
2569 
2570 conditional_or_expression:
2571 	conditional_and_expression
2572 |	conditional_or_expression BOOL_OR_TK conditional_and_expression
2573 		{
2574 		  $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2575 				    $1, $3);
2576 		}
2577 |	conditional_or_expression BOOL_OR_TK error
2578 		{yyerror ("Missing term"); RECOVER;}
2579 ;
2580 
2581 conditional_expression:		/* Error handling here is weak */
2582 	conditional_or_expression
2583 |	conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2584 		{
2585 		  $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2586 		  EXPR_WFL_LINECOL ($$) = $2.location;
2587 		}
2588 |	conditional_or_expression REL_QM_TK REL_CL_TK error
2589 		{
2590 		  YYERROR_NOW;
2591 		  yyerror ("Missing term");
2592 		  DRECOVER (1);
2593 		}
2594 |	conditional_or_expression REL_QM_TK error
2595 		{yyerror ("Missing term"); DRECOVER (2);}
2596 |	conditional_or_expression REL_QM_TK expression REL_CL_TK error
2597 		{yyerror ("Missing term"); DRECOVER (3);}
2598 ;
2599 
2600 assignment_expression:
2601 	conditional_expression
2602 |	assignment
2603 ;
2604 
2605 assignment:
2606 	left_hand_side assignment_operator assignment_expression
2607 		{ $$ = build_assignment ($2.token, $2.location, $1, $3); }
2608 |	left_hand_side assignment_operator error
2609 		{
2610 		  YYNOT_TWICE yyerror ("Missing term");
2611 		  DRECOVER (assign);
2612 		}
2613 ;
2614 
2615 left_hand_side:
2616 	name
2617 |	field_access
2618 |	array_access
2619 ;
2620 
2621 assignment_operator:
2622 	ASSIGN_ANY_TK
2623 |	ASSIGN_TK
2624 ;
2625 
2626 expression:
2627 	assignment_expression
2628 ;
2629 
2630 constant_expression:
2631 	expression
2632 ;
2633 
2634 %%
2635 
2636 /* Helper function to retrieve an OSB count. Should be used when the
2637    `dims:' rule is being used.  */
2638 
2639 static int
2640 pop_current_osb (struct parser_ctxt *ctxp)
2641 {
2642   int to_return;
2643 
2644   if (ctxp->osb_depth < 0)
2645     abort ();
2646 
2647   to_return = CURRENT_OSB (ctxp);
2648   ctxp->osb_depth--;
2649 
2650   return to_return;
2651 }
2652 
2653 
2654 
2655 /* This section of the code deal with save/restoring parser contexts.
2656    Add mode documentation here. FIXME */
2657 
2658 /* Helper function. Create a new parser context. With
2659    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2660    context is copied, otherwise, the new context is zeroed. The newly
2661    created context becomes the current one.  */
2662 
2663 static void
create_new_parser_context(int copy_from_previous)2664 create_new_parser_context (int copy_from_previous)
2665 {
2666   struct parser_ctxt *new;
2667 
2668   new = ggc_alloc (sizeof (struct parser_ctxt));
2669   if (copy_from_previous)
2670     {
2671       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2672       /* This flag, indicating the context saves global values,
2673 	 should only be set by java_parser_context_save_global.  */
2674       new->saved_data_ctx = 0;
2675     }
2676   else
2677     memset (new, 0, sizeof (struct parser_ctxt));
2678 
2679   new->next = ctxp;
2680   ctxp = new;
2681 }
2682 
2683 /* Create a new parser context and make it the current one. */
2684 
2685 void
java_push_parser_context(void)2686 java_push_parser_context (void)
2687 {
2688   create_new_parser_context (0);
2689 }
2690 
2691 void
java_pop_parser_context(int generate)2692 java_pop_parser_context (int generate)
2693 {
2694   tree current;
2695   struct parser_ctxt *toFree, *next;
2696 
2697   if (!ctxp)
2698     return;
2699 
2700   toFree = ctxp;
2701   next = ctxp->next;
2702   if (next)
2703     {
2704       input_line = ctxp->lineno;
2705       current_class = ctxp->class_type;
2706     }
2707 
2708   /* If the old and new lexers differ, then free the old one.  */
2709   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2710     java_destroy_lexer (ctxp->lexer);
2711 
2712   /* Set the single import class file flag to 0 for the current list
2713      of imported things */
2714   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2715     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2716 
2717   /* And restore those of the previous context */
2718   if ((ctxp = next))		/* Assignment is really meant here */
2719     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2720       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2721 
2722   /* If we pushed a context to parse a class intended to be generated,
2723      we keep it so we can remember the class. What we could actually
2724      do is to just update a list of class names.  */
2725   if (generate)
2726     {
2727       toFree->next = ctxp_for_generation;
2728       ctxp_for_generation = toFree;
2729     }
2730 }
2731 
2732 /* Create a parser context for the use of saving some global
2733    variables.  */
2734 
2735 void
java_parser_context_save_global(void)2736 java_parser_context_save_global (void)
2737 {
2738   if (!ctxp)
2739     {
2740       java_push_parser_context ();
2741       ctxp->saved_data_ctx = 1;
2742     }
2743 
2744   /* If this context already stores data, create a new one suitable
2745      for data storage. */
2746   else if (ctxp->saved_data)
2747     {
2748       create_new_parser_context (1);
2749       ctxp->saved_data_ctx = 1;
2750     }
2751 
2752   ctxp->lineno = input_line;
2753   ctxp->class_type = current_class;
2754   ctxp->filename = input_filename;
2755   ctxp->function_decl = current_function_decl;
2756   ctxp->saved_data = 1;
2757 }
2758 
2759 /* Restore some global variables from the previous context. Make the
2760    previous context the current one.  */
2761 
2762 void
java_parser_context_restore_global(void)2763 java_parser_context_restore_global (void)
2764 {
2765   input_line = ctxp->lineno;
2766   current_class = ctxp->class_type;
2767   input_filename = ctxp->filename;
2768   if (wfl_operator)
2769     {
2770       tree s;
2771       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2772       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2773     }
2774   current_function_decl = ctxp->function_decl;
2775   ctxp->saved_data = 0;
2776   if (ctxp->saved_data_ctx)
2777     java_pop_parser_context (0);
2778 }
2779 
2780 /* Suspend vital data for the current class/function being parsed so
2781    that an other class can be parsed. Used to let local/anonymous
2782    classes be parsed.  */
2783 
2784 static void
java_parser_context_suspend(void)2785 java_parser_context_suspend (void)
2786 {
2787   /* This makes debugging through java_debug_context easier */
2788   static const char *const name = "<inner buffer context>";
2789 
2790   /* Duplicate the previous context, use it to save the globals we're
2791      interested in */
2792   create_new_parser_context (1);
2793   ctxp->function_decl = current_function_decl;
2794   ctxp->class_type = current_class;
2795 
2796   /* Then create a new context which inherits all data from the
2797      previous one. This will be the new current context  */
2798   create_new_parser_context (1);
2799 
2800   /* Help debugging */
2801   ctxp->next->filename = name;
2802 }
2803 
2804 /* Resume vital data for the current class/function being parsed so
2805    that an other class can be parsed. Used to let local/anonymous
2806    classes be parsed.  The trick is the data storing file position
2807    informations must be restored to their current value, so parsing
2808    can resume as if no context was ever saved. */
2809 
2810 static void
java_parser_context_resume(void)2811 java_parser_context_resume (void)
2812 {
2813   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2814   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2815   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2816 
2817   /* We need to inherit the list of classes to complete/generate */
2818   restored->classd_list = old->classd_list;
2819   restored->class_list = old->class_list;
2820 
2821   /* Restore the current class and function from the saver */
2822   current_class = saver->class_type;
2823   current_function_decl = saver->function_decl;
2824 
2825   /* Retrieve the restored context */
2826   ctxp = restored;
2827 
2828   /* Re-installed the data for the parsing to carry on */
2829   memcpy (&ctxp->marker_begining, &old->marker_begining,
2830 	  (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2831 }
2832 
2833 /* Add a new anchor node to which all statement(s) initializing static
2834    and non static initialized upon declaration field(s) will be
2835    linked.  */
2836 
2837 static void
java_parser_context_push_initialized_field(void)2838 java_parser_context_push_initialized_field (void)
2839 {
2840   tree node;
2841 
2842   node = build_tree_list (NULL_TREE, NULL_TREE);
2843   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2844   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2845 
2846   node = build_tree_list (NULL_TREE, NULL_TREE);
2847   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2848   CPC_INITIALIZER_LIST (ctxp) = node;
2849 
2850   node = build_tree_list (NULL_TREE, NULL_TREE);
2851   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2852   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2853 }
2854 
2855 /* Pop the lists of initialized field. If this lists aren't empty,
2856    remember them so we can use it to create and populate the finit$
2857    or <clinit> functions. */
2858 
2859 static void
java_parser_context_pop_initialized_field(void)2860 java_parser_context_pop_initialized_field (void)
2861 {
2862   tree stmts;
2863   tree class_type = TREE_TYPE (GET_CPC ());
2864 
2865   if (CPC_INITIALIZER_LIST (ctxp))
2866     {
2867       stmts = CPC_INITIALIZER_STMT (ctxp);
2868       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2869       if (stmts && !java_error_count)
2870 	TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2871     }
2872 
2873   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2874     {
2875       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2876       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2877 	TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2878       /* Keep initialization in order to enforce 8.5 */
2879       if (stmts && !java_error_count)
2880 	TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2881     }
2882 
2883   /* JDK 1.1 instance initializers */
2884   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2885     {
2886       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2887       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2888 	TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2889       if (stmts && !java_error_count)
2890 	TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2891     }
2892 }
2893 
2894 static tree
reorder_static_initialized(tree list)2895 reorder_static_initialized (tree list)
2896 {
2897   /* We have to keep things in order. The alias initializer have to
2898      come first, then the initialized regular field, in reverse to
2899      keep them in lexical order. */
2900   tree marker, previous = NULL_TREE;
2901   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2902     if (TREE_CODE (marker) == TREE_LIST
2903 	&& !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2904       break;
2905 
2906   /* No static initialized, the list is fine as is */
2907   if (!previous)
2908     list = TREE_CHAIN (marker);
2909 
2910   /* No marker? reverse the whole list */
2911   else if (!marker)
2912     list = nreverse (list);
2913 
2914   /* Otherwise, reverse what's after the marker and the new reordered
2915      sublist will replace the marker. */
2916   else
2917     {
2918       TREE_CHAIN (previous) = NULL_TREE;
2919       list = nreverse (list);
2920       list = chainon (TREE_CHAIN (marker), list);
2921     }
2922   return list;
2923 }
2924 
2925 /* Helper functions to dump the parser context stack.  */
2926 
2927 #define TAB_CONTEXT(C) \
2928   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2929 
2930 static void
java_debug_context_do(int tab)2931 java_debug_context_do (int tab)
2932 {
2933   struct parser_ctxt *copy = ctxp;
2934   while (copy)
2935     {
2936       TAB_CONTEXT (tab);
2937       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2938       TAB_CONTEXT (tab);
2939       fprintf (stderr, "filename: %s\n", copy->filename);
2940       TAB_CONTEXT (tab);
2941       fprintf (stderr, "lineno: %d\n", copy->lineno);
2942       TAB_CONTEXT (tab);
2943       fprintf (stderr, "package: %s\n",
2944 	       (copy->package ?
2945 		IDENTIFIER_POINTER (copy->package) : "<none>"));
2946       TAB_CONTEXT (tab);
2947       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2948       TAB_CONTEXT (tab);
2949       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2950       copy = copy->next;
2951       tab += 2;
2952     }
2953 }
2954 
2955 /* Dump the stacked up parser contexts. Intended to be called from a
2956    debugger.  */
2957 
2958 void
java_debug_context(void)2959 java_debug_context (void)
2960 {
2961   java_debug_context_do (0);
2962 }
2963 
2964 
2965 
2966 /* Flag for the error report routine to issue the error the first time
2967    it's called (overriding the default behavior which is to drop the
2968    first invocation and honor the second one, taking advantage of a
2969    richer context.  */
2970 static int force_error = 0;
2971 
2972 /* Reporting an constructor invocation error.  */
2973 static void
parse_ctor_invocation_error(void)2974 parse_ctor_invocation_error (void)
2975 {
2976   if (DECL_CONSTRUCTOR_P (current_function_decl))
2977     yyerror ("Constructor invocation must be first thing in a constructor");
2978   else
2979     yyerror ("Only constructors can invoke constructors");
2980 }
2981 
2982 /* Reporting JDK1.1 features not implemented.  */
2983 
2984 static tree
parse_jdk1_1_error(const char * msg)2985 parse_jdk1_1_error (const char *msg)
2986 {
2987   sorry (": `%s' JDK1.1(TM) feature", msg);
2988   java_error_count++;
2989   return empty_stmt_node;
2990 }
2991 
2992 static int do_warning = 0;
2993 
2994 void
yyerror(const char * msg)2995 yyerror (const char *msg)
2996 {
2997   static java_lc elc;
2998   static int  prev_lineno;
2999   static const char *prev_msg;
3000 
3001   int save_lineno;
3002   char *remainder, *code_from_source;
3003 
3004   if (!force_error && prev_lineno == input_line)
3005     return;
3006 
3007   /* Save current error location but report latter, when the context is
3008      richer.  */
3009   if (ctxp->java_error_flag == 0)
3010     {
3011       ctxp->java_error_flag = 1;
3012       elc = ctxp->elc;
3013       /* Do something to use the previous line if we're reaching the
3014 	 end of the file... */
3015 #ifdef VERBOSE_SKELETON
3016       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3017 #endif
3018       return;
3019     }
3020 
3021   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3022   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3023     return;
3024 
3025   ctxp->java_error_flag = 0;
3026   if (do_warning)
3027     java_warning_count++;
3028   else
3029     java_error_count++;
3030 
3031   if (elc.col == 0 && msg && msg[1] == ';')
3032     {
3033       elc.col  = ctxp->p_line->char_col-1;
3034       elc.line = ctxp->p_line->lineno;
3035     }
3036 
3037   save_lineno = input_line;
3038   prev_lineno = input_line = elc.line;
3039   prev_msg = msg;
3040 
3041   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3042   obstack_grow0 (&temporary_obstack,
3043 		 code_from_source, strlen (code_from_source));
3044   remainder = obstack_finish (&temporary_obstack);
3045   if (do_warning)
3046     warning ("%s.\n%s", msg, remainder);
3047   else
3048     error ("%s.\n%s", msg, remainder);
3049 
3050   /* This allow us to cheaply avoid an extra 'Invalid expression
3051      statement' error report when errors have been already reported on
3052      the same line. This occurs when we report an error but don't have
3053      a synchronization point other than ';', which
3054      expression_statement is the only one to take care of.  */
3055   ctxp->prevent_ese = input_line = save_lineno;
3056 }
3057 
3058 static void
issue_warning_error_from_context(tree cl,const char * msg,va_list ap)3059 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3060 {
3061   const char *saved, *saved_input_filename;
3062   char buffer [4096];
3063   vsprintf (buffer, msg, ap);
3064   force_error = 1;
3065 
3066   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3067   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3068 		    (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3069 
3070   /* We have a CL, that's a good reason for using it if it contains data */
3071   saved = ctxp->filename;
3072   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3073     ctxp->filename = EXPR_WFL_FILENAME (cl);
3074   saved_input_filename = input_filename;
3075   input_filename = ctxp->filename;
3076   java_error (NULL);
3077   java_error (buffer);
3078   ctxp->filename = saved;
3079   input_filename = saved_input_filename;
3080   force_error = 0;
3081 }
3082 
3083 /* Issue an error message at a current source line CL */
3084 
3085 void
parse_error_context(tree cl,const char * msg,...)3086 parse_error_context (tree cl, const char *msg, ...)
3087 {
3088   va_list ap;
3089   va_start (ap, msg);
3090   issue_warning_error_from_context (cl, msg, ap);
3091   va_end (ap);
3092 }
3093 
3094 /* Issue a warning at a current source line CL */
3095 
3096 static void
parse_warning_context(tree cl,const char * msg,...)3097 parse_warning_context (tree cl, const char *msg, ...)
3098 {
3099   va_list ap;
3100   va_start (ap, msg);
3101 
3102   force_error = do_warning = 1;
3103   issue_warning_error_from_context (cl, msg, ap);
3104   do_warning = force_error = 0;
3105   va_end (ap);
3106 }
3107 
3108 static tree
find_expr_with_wfl(tree node)3109 find_expr_with_wfl (tree node)
3110 {
3111   while (node)
3112     {
3113       char code;
3114       tree to_return;
3115 
3116       switch (TREE_CODE (node))
3117 	{
3118 	case BLOCK:
3119 	  node = BLOCK_EXPR_BODY (node);
3120 	  continue;
3121 
3122 	case COMPOUND_EXPR:
3123 	  to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3124 	  if (to_return)
3125 	    return to_return;
3126 	  node = TREE_OPERAND (node, 1);
3127 	  continue;
3128 
3129 	case LOOP_EXPR:
3130 	  node = TREE_OPERAND (node, 0);
3131 	  continue;
3132 
3133 	case LABELED_BLOCK_EXPR:
3134 	  node = TREE_OPERAND (node, 1);
3135 	  continue;
3136 
3137 	default:
3138 	  code = TREE_CODE_CLASS (TREE_CODE (node));
3139 	  if (((code == '1') || (code == '2') || (code == 'e'))
3140 	      && EXPR_WFL_LINECOL (node))
3141 	    return node;
3142 	  return NULL_TREE;
3143 	}
3144     }
3145   return NULL_TREE;
3146 }
3147 
3148 /* Issue a missing return statement error. Uses METHOD to figure the
3149    last line of the method the error occurs in.  */
3150 
3151 static void
missing_return_error(tree method)3152 missing_return_error (tree method)
3153 {
3154   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3155   parse_error_context (wfl_operator, "Missing return statement");
3156 }
3157 
3158 /* Issue an unreachable statement error. From NODE, find the next
3159    statement to report appropriately.  */
3160 static void
unreachable_stmt_error(tree node)3161 unreachable_stmt_error (tree node)
3162 {
3163   /* Browse node to find the next expression node that has a WFL. Use
3164      the location to report the error */
3165   if (TREE_CODE (node) == COMPOUND_EXPR)
3166     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3167   else
3168     node = find_expr_with_wfl (node);
3169 
3170   if (node)
3171     {
3172       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3173       parse_error_context (wfl_operator, "Unreachable statement");
3174     }
3175   else
3176     abort ();
3177 }
3178 
3179 static int
not_accessible_field_error(tree wfl,tree decl)3180 not_accessible_field_error (tree wfl, tree decl)
3181 {
3182   parse_error_context
3183     (wfl, "Can't access %s field `%s.%s' from `%s'",
3184      java_accstring_lookup (get_access_flags_from_decl (decl)),
3185      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3186      IDENTIFIER_POINTER (DECL_NAME (decl)),
3187      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3188   return 1;
3189 }
3190 
3191 int
java_report_errors(void)3192 java_report_errors (void)
3193 {
3194   if (java_error_count)
3195     fprintf (stderr, "%d error%s",
3196 	     java_error_count, (java_error_count == 1 ? "" : "s"));
3197   if (java_warning_count)
3198     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3199 	     java_warning_count, (java_warning_count == 1 ? "" : "s"));
3200   if (java_error_count || java_warning_count)
3201     putc ('\n', stderr);
3202   return java_error_count;
3203 }
3204 
3205 static char *
java_accstring_lookup(int flags)3206 java_accstring_lookup (int flags)
3207 {
3208   static char buffer [80];
3209 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3210 
3211   /* Access modifier looked-up first for easier report on forbidden
3212      access. */
3213   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3214   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3215   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3216   if (flags & ACC_STATIC) COPY_RETURN ("static");
3217   if (flags & ACC_FINAL) COPY_RETURN ("final");
3218   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3219   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3220   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3221   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3222   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3223   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3224 
3225   buffer [0] = '\0';
3226   return buffer;
3227 #undef COPY_RETURN
3228 }
3229 
3230 /* Issuing error messages upon redefinition of classes, interfaces or
3231    variables. */
3232 
3233 static void
classitf_redefinition_error(const char * context,tree id,tree decl,tree cl)3234 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3235 {
3236   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3237 		       context, IDENTIFIER_POINTER (id),
3238 		       DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3239   /* Here we should point out where its redefined. It's a unicode. FIXME */
3240 }
3241 
3242 static void
variable_redefinition_error(tree context,tree name,tree type,int line)3243 variable_redefinition_error (tree context, tree name, tree type, int line)
3244 {
3245   const char *type_name;
3246 
3247   /* Figure a proper name for type. We might haven't resolved it */
3248   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3249     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3250   else
3251     type_name = lang_printable_name (type, 0);
3252 
3253   parse_error_context (context,
3254 		       "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3255 		       IDENTIFIER_POINTER (name),
3256 		       type_name, IDENTIFIER_POINTER (name), line);
3257 }
3258 
3259 /* If ANAME is terminated with `[]', it indicates an array. This
3260    function returns the number of `[]' found and if this number is
3261    greater than zero, it extracts the array type name and places it in
3262    the node pointed to by TRIMMED unless TRIMMED is null.  */
3263 
3264 static int
build_type_name_from_array_name(tree aname,tree * trimmed)3265 build_type_name_from_array_name (tree aname, tree *trimmed)
3266 {
3267   const char *name = IDENTIFIER_POINTER (aname);
3268   int len = IDENTIFIER_LENGTH (aname);
3269   int array_dims;
3270 
3271   STRING_STRIP_BRACKETS (name, len, array_dims);
3272 
3273   if (array_dims && trimmed)
3274     *trimmed = get_identifier_with_length (name, len);
3275 
3276   return array_dims;
3277 }
3278 
3279 static tree
build_array_from_name(tree type,tree type_wfl,tree name,tree * ret_name)3280 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3281 {
3282   int more_dims = 0;
3283 
3284   /* Eventually get more dims */
3285   more_dims = build_type_name_from_array_name (name, &name);
3286 
3287   /* If we have, then craft a new type for this variable */
3288   if (more_dims)
3289     {
3290       tree save = type;
3291 
3292       /* If we have a pointer, use its type */
3293       if (TREE_CODE (type) == POINTER_TYPE)
3294         type = TREE_TYPE (type);
3295 
3296       /* Building the first dimension of a primitive type uses this
3297          function */
3298       if (JPRIMITIVE_TYPE_P (type))
3299 	{
3300 	  type = build_java_array_type (type, -1);
3301 	  more_dims--;
3302 	}
3303       /* Otherwise, if we have a WFL for this type, use it (the type
3304          is already an array on an unresolved type, and we just keep
3305          on adding dimensions) */
3306       else if (type_wfl)
3307 	{
3308 	  type = type_wfl;
3309 	  more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3310 							NULL);
3311 	}
3312 
3313       /* Add all the dimensions */
3314       while (more_dims--)
3315 	type = build_unresolved_array_type (type);
3316 
3317       /* The type may have been incomplete in the first place */
3318       if (type_wfl)
3319 	type = obtain_incomplete_type (type);
3320     }
3321 
3322   if (ret_name)
3323     *ret_name = name;
3324   return type;
3325 }
3326 
3327 /* Build something that the type identifier resolver will identify as
3328    being an array to an unresolved type. TYPE_WFL is a WFL on a
3329    identifier. */
3330 
3331 static tree
build_unresolved_array_type(tree type_or_wfl)3332 build_unresolved_array_type (tree type_or_wfl)
3333 {
3334   const char *ptr;
3335   tree wfl;
3336 
3337   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3338      just create a array type */
3339   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3340     return build_java_array_type (type_or_wfl, -1);
3341 
3342   obstack_grow (&temporary_obstack,
3343 		 IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3344 		 IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3345   obstack_grow0 (&temporary_obstack, "[]", 2);
3346   ptr = obstack_finish (&temporary_obstack);
3347   wfl = build_expr_wfl (get_identifier (ptr),
3348 			EXPR_WFL_FILENAME (type_or_wfl),
3349 			EXPR_WFL_LINENO (type_or_wfl),
3350 			EXPR_WFL_COLNO (type_or_wfl));
3351   /* Re-install the existing qualifications so that the type can be
3352      resolved properly. */
3353   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3354   return wfl;
3355 }
3356 
3357 static void
parser_add_interface(tree class_decl,tree interface_decl,tree wfl)3358 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3359 {
3360   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3361     parse_error_context (wfl, "Interface `%s' repeated",
3362 			 IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3363 }
3364 
3365 /* Bulk of common class/interface checks. Return 1 if an error was
3366    encountered. TAG is 0 for a class, 1 for an interface.  */
3367 
3368 static int
check_class_interface_creation(int is_interface,int flags,tree raw_name,tree qualified_name,tree decl,tree cl)3369 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3370 				tree qualified_name, tree decl, tree cl)
3371 {
3372   tree node;
3373   int sca = 0;			/* Static class allowed */
3374   int icaf = 0;			/* Inner class allowed flags */
3375   int uaaf = CLASS_MODIFIERS;	/* Usually allowed access flags */
3376 
3377   if (!quiet_flag)
3378     fprintf (stderr, " %s%s %s",
3379 	     (CPC_INNER_P () ? "inner" : ""),
3380 	     (is_interface ? "interface" : "class"),
3381 	     IDENTIFIER_POINTER (qualified_name));
3382 
3383   /* Scope of an interface/class type name:
3384        - Can't be imported by a single type import
3385        - Can't already exists in the package */
3386   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3387       && (node = find_name_in_single_imports (raw_name))
3388       && !CPC_INNER_P ())
3389     {
3390       parse_error_context
3391 	(cl, "%s name `%s' clashes with imported type `%s'",
3392 	 (is_interface ? "Interface" : "Class"),
3393 	 IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3394       return 1;
3395     }
3396   if (decl && CLASS_COMPLETE_P (decl))
3397     {
3398       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3399 				   qualified_name, decl, cl);
3400       return 1;
3401     }
3402 
3403   if (check_inner_class_redefinition (raw_name, cl))
3404     return 1;
3405 
3406   /* If public, file name should match class/interface name, except
3407      when dealing with an inner class */
3408   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3409     {
3410       const char *f;
3411 
3412       for (f = &input_filename [strlen (input_filename)];
3413 	   f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3414 	   f--)
3415 	;
3416       if (IS_DIR_SEPARATOR (f[0]))
3417 	f++;
3418       if (strncmp (IDENTIFIER_POINTER (raw_name),
3419 		   f , IDENTIFIER_LENGTH (raw_name)) ||
3420 	  f [IDENTIFIER_LENGTH (raw_name)] != '.')
3421 	parse_error_context
3422 	  (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3423 			     (is_interface ? "interface" : "class"),
3424 			     IDENTIFIER_POINTER (qualified_name),
3425 			     IDENTIFIER_POINTER (raw_name));
3426     }
3427 
3428   /* Static classes can be declared only in top level classes. Note:
3429      once static, a inner class is a top level class. */
3430   if (flags & ACC_STATIC)
3431     {
3432       /* Catch the specific error of declaring an class inner class
3433 	 with no toplevel enclosing class. Prevent check_modifiers from
3434 	 complaining a second time */
3435       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3436 	{
3437 	  parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3438 			       IDENTIFIER_POINTER (qualified_name));
3439 	  sca = ACC_STATIC;
3440 	}
3441       /* Else, in the context of a top-level class declaration, let
3442          `check_modifiers' do its job, otherwise, give it a go */
3443       else
3444 	sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3445     }
3446 
3447   /* Inner classes can be declared private or protected
3448      within their enclosing classes. */
3449   if (CPC_INNER_P ())
3450     {
3451       /* A class which is local to a block can't be public, private,
3452 	 protected or static. But it is created final, so allow this
3453 	 one. */
3454       if (current_function_decl)
3455 	icaf = sca = uaaf = ACC_FINAL;
3456       else
3457 	{
3458 	  check_modifiers_consistency (flags);
3459 	  icaf = ACC_PROTECTED;
3460 	  if (! CLASS_INTERFACE (GET_CPC ()))
3461 	    icaf |= ACC_PRIVATE;
3462 	}
3463     }
3464 
3465   if (is_interface)
3466     {
3467       if (CPC_INNER_P ())
3468 	uaaf = INTERFACE_INNER_MODIFIERS;
3469       else
3470 	uaaf = INTERFACE_MODIFIERS;
3471 
3472       check_modifiers ("Illegal modifier `%s' for interface declaration",
3473 		       flags, uaaf);
3474     }
3475   else
3476     check_modifiers ((current_function_decl ?
3477 		      "Illegal modifier `%s' for local class declaration" :
3478 		      "Illegal modifier `%s' for class declaration"),
3479 		     flags, uaaf|sca|icaf);
3480   return 0;
3481 }
3482 
3483 /* Construct a nested class name.  If the final component starts with
3484    a digit, return true.  Otherwise return false.  */
3485 static int
make_nested_class_name(tree cpc_list)3486 make_nested_class_name (tree cpc_list)
3487 {
3488   tree name;
3489 
3490   if (!cpc_list)
3491     return 0;
3492 
3493   make_nested_class_name (TREE_CHAIN (cpc_list));
3494 
3495   /* Pick the qualified name when dealing with the first upmost
3496      enclosing class */
3497   name = (TREE_CHAIN (cpc_list)
3498 	  ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3499   obstack_grow (&temporary_obstack,
3500 		IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3501   obstack_1grow (&temporary_obstack, '$');
3502 
3503   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3504 }
3505 
3506 /* Can't redefine a class already defined in an earlier scope. */
3507 
3508 static int
check_inner_class_redefinition(tree raw_name,tree cl)3509 check_inner_class_redefinition (tree raw_name, tree cl)
3510 {
3511   tree scope_list;
3512 
3513   for (scope_list = GET_CPC_LIST (); scope_list;
3514        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3515     if (raw_name == GET_CPC_UN_NODE (scope_list))
3516       {
3517 	parse_error_context
3518 	  (cl, "The class name `%s' is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
3519 	   IDENTIFIER_POINTER (raw_name));
3520 	return 1;
3521       }
3522   return 0;
3523 }
3524 
3525 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3526    we remember ENCLOSING and SUPER.  */
3527 
3528 static tree
resolve_inner_class(htab_t circularity_hash,tree cl,tree * enclosing,tree * super,tree class_type)3529 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3530 		     tree *super, tree class_type)
3531 {
3532   tree local_enclosing = *enclosing;
3533   tree local_super = NULL_TREE;
3534 
3535   while (local_enclosing)
3536     {
3537       tree intermediate, decl;
3538 
3539       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3540 	local_enclosing;
3541 
3542       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3543 	return decl;
3544 
3545       intermediate = local_enclosing;
3546       /* Explore enclosing contexts. */
3547       while (INNER_CLASS_DECL_P (intermediate))
3548 	{
3549 	  intermediate = DECL_CONTEXT (intermediate);
3550 	  if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3551 	    return decl;
3552 	}
3553 
3554       /* Now go to the upper classes, bail out if necessary.  We will
3555 	 analyze the returned SUPER and act accordingly (see
3556 	 do_resolve_class).  */
3557       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3558 	  || TREE_TYPE (local_enclosing) == void_type_node)
3559 	{
3560 	  parse_error_context (cl, "Qualifier must be a reference");
3561 	  local_enclosing = NULL_TREE;
3562 	  break;
3563 	}
3564       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3565       if (!local_super || local_super == object_type_node)
3566         break;
3567 
3568       if (TREE_CODE (local_super) == POINTER_TYPE)
3569         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3570       else
3571 	local_super = TYPE_NAME (local_super);
3572 
3573       /* We may not have checked for circular inheritance yet, so do so
3574          here to prevent an infinite loop. */
3575       if (htab_find (circularity_hash, local_super) != NULL)
3576         {
3577           if (!cl)
3578             cl = lookup_cl (local_enclosing);
3579 
3580           parse_error_context
3581             (cl, "Cyclic inheritance involving %s",
3582 	     IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3583 	  local_enclosing = NULL_TREE;
3584         }
3585       else
3586 	local_enclosing = local_super;
3587     }
3588 
3589   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3590   *super = local_super;
3591   *enclosing = local_enclosing;
3592 
3593   return NULL_TREE;
3594 }
3595 
3596 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3597    qualified. */
3598 
3599 static tree
find_as_inner_class(tree enclosing,tree name,tree cl)3600 find_as_inner_class (tree enclosing, tree name, tree cl)
3601 {
3602   tree qual, to_return;
3603   if (!enclosing)
3604     return NULL_TREE;
3605 
3606   name = TYPE_NAME (name);
3607 
3608   /* First search: within the scope of `enclosing', search for name */
3609   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3610     qual = EXPR_WFL_QUALIFICATION (cl);
3611   else if (cl)
3612     qual = build_tree_list (cl, NULL_TREE);
3613   else
3614     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3615 
3616   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3617     return to_return;
3618 
3619   /* We're dealing with a qualified name. Try to resolve thing until
3620      we get something that is an enclosing class. */
3621   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3622     {
3623       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3624 
3625       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3626 	   qual = TREE_CHAIN (qual))
3627 	{
3628 	  acc = merge_qualified_name (acc,
3629 				      EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3630 	  BUILD_PTR_FROM_NAME (ptr, acc);
3631 	  decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3632 	}
3633 
3634       /* A NULL qual and a decl means that the search ended
3635          successfully?!? We have to do something then. FIXME */
3636 
3637       if (decl)
3638 	enclosing = decl;
3639       else
3640 	qual = EXPR_WFL_QUALIFICATION (cl);
3641     }
3642   /* Otherwise, create a qual for the other part of the resolution. */
3643   else
3644     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3645 
3646   return find_as_inner_class_do (qual, enclosing);
3647 }
3648 
3649 /* We go inside the list of sub classes and try to find a way
3650    through. */
3651 
3652 static tree
find_as_inner_class_do(tree qual,tree enclosing)3653 find_as_inner_class_do (tree qual, tree enclosing)
3654 {
3655   if (!qual)
3656     return NULL_TREE;
3657 
3658   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3659     {
3660       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3661       tree next_enclosing = NULL_TREE;
3662       tree inner_list;
3663 
3664       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3665            inner_list; inner_list = TREE_CHAIN (inner_list))
3666 	{
3667 	  if (TREE_VALUE (inner_list) == name_to_match)
3668 	    {
3669 	      next_enclosing = TREE_PURPOSE (inner_list);
3670 	      break;
3671 	    }
3672 	}
3673       enclosing = next_enclosing;
3674     }
3675 
3676   return (!qual && enclosing ? enclosing : NULL_TREE);
3677 }
3678 
3679 /* Reach all inner classes and tie their unqualified name to a
3680    DECL. */
3681 
3682 static void
set_nested_class_simple_name_value(tree outer,int set)3683 set_nested_class_simple_name_value (tree outer, int set)
3684 {
3685   tree l;
3686 
3687   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3688     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3689 						TREE_PURPOSE (l) : NULL_TREE);
3690 }
3691 
3692 static void
link_nested_class_to_enclosing(void)3693 link_nested_class_to_enclosing (void)
3694 {
3695   if (GET_ENCLOSING_CPC ())
3696     {
3697       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3698       DECL_INNER_CLASS_LIST (enclosing) =
3699 	tree_cons (GET_CPC (), GET_CPC_UN (),
3700 		   DECL_INNER_CLASS_LIST (enclosing));
3701     }
3702 }
3703 
3704 static tree
maybe_make_nested_class_name(tree name)3705 maybe_make_nested_class_name (tree name)
3706 {
3707   tree id = NULL_TREE;
3708 
3709   if (CPC_INNER_P ())
3710     {
3711       /* If we're in a function, we must append a number to create the
3712 	 nested class name.  However, we don't do this if the class we
3713 	 are constructing is anonymous, because in that case we'll
3714 	 already have a number as the class name.  */
3715       if (! make_nested_class_name (GET_CPC_LIST ())
3716 	  && current_function_decl != NULL_TREE
3717 	  && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3718 	{
3719 	  char buf[10];
3720 	  sprintf (buf, "%d", anonymous_class_counter);
3721 	  ++anonymous_class_counter;
3722 	  obstack_grow (&temporary_obstack, buf, strlen (buf));
3723 	  obstack_1grow (&temporary_obstack, '$');
3724 	}
3725       obstack_grow0 (&temporary_obstack,
3726 		     IDENTIFIER_POINTER (name),
3727 		     IDENTIFIER_LENGTH (name));
3728       id = get_identifier (obstack_finish (&temporary_obstack));
3729       if (ctxp->package)
3730 	QUALIFIED_P (id) = 1;
3731     }
3732   return id;
3733 }
3734 
3735 /* If DECL is NULL, create and push a new DECL, record the current
3736    line CL and do other maintenance things.  */
3737 
3738 static tree
maybe_create_class_interface_decl(tree decl,tree raw_name,tree qualified_name,tree cl)3739 maybe_create_class_interface_decl (tree decl, tree raw_name,
3740 				   tree qualified_name, tree cl)
3741 {
3742   if (!decl)
3743     decl = push_class (make_class (), qualified_name);
3744 
3745   /* Take care of the file and line business */
3746   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3747   /* If we're emitting xrefs, store the line/col number information */
3748   if (flag_emit_xref)
3749     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3750   else
3751     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3752   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3753   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3754   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3755     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3756 
3757   PUSH_CPC (decl, raw_name);
3758   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3759 
3760   /* Link the declaration to the already seen ones */
3761   TREE_CHAIN (decl) = ctxp->class_list;
3762   ctxp->class_list = decl;
3763 
3764   /* Create a new nodes in the global lists */
3765   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3766   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3767 
3768   /* Install a new dependency list element */
3769   create_jdep_list (ctxp);
3770 
3771   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3772 			  IDENTIFIER_POINTER (qualified_name)));
3773   return decl;
3774 }
3775 
3776 static void
add_superinterfaces(tree decl,tree interface_list)3777 add_superinterfaces (tree decl, tree interface_list)
3778 {
3779   tree node;
3780   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3781      takes care of ensuring that:
3782        - This is an accessible interface type,
3783        - Circularity detection.
3784    parser_add_interface is then called. If present but not defined,
3785    the check operation is delayed until the super interface gets
3786    defined.  */
3787   for (node = interface_list; node; node = TREE_CHAIN (node))
3788     {
3789       tree current = TREE_PURPOSE (node);
3790       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3791       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3792 	{
3793 	  if (!parser_check_super_interface (idecl, decl, current))
3794 	    parser_add_interface (decl, idecl, current);
3795 	}
3796       else
3797 	register_incomplete_type (JDEP_INTERFACE,
3798 				  current, decl, NULL_TREE);
3799     }
3800 }
3801 
3802 /* Create an interface in pass1 and return its decl. Return the
3803    interface's decl in pass 2.  */
3804 
3805 static tree
create_interface(int flags,tree id,tree super)3806 create_interface (int flags, tree id, tree super)
3807 {
3808   tree raw_name = EXPR_WFL_NODE (id);
3809   tree q_name = parser_qualified_classname (raw_name);
3810   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3811 
3812   /* Certain syntax errors are making SUPER be like ID. Avoid this
3813      case. */
3814   if (ctxp->class_err && id == super)
3815     super = NULL;
3816 
3817   EXPR_WFL_NODE (id) = q_name;	/* Keep source location, even if refined. */
3818 
3819   /* Basic checks: scope, redefinition, modifiers */
3820   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3821     {
3822       PUSH_ERROR ();
3823       return NULL_TREE;
3824     }
3825 
3826   /* Suspend the current parsing context if we're parsing an inner
3827      interface */
3828   if (CPC_INNER_P ())
3829     {
3830       java_parser_context_suspend ();
3831       /* Interface members are public. */
3832       if (CLASS_INTERFACE (GET_CPC ()))
3833 	flags |= ACC_PUBLIC;
3834     }
3835 
3836   /* Push a new context for (static) initialized upon declaration fields */
3837   java_parser_context_push_initialized_field ();
3838 
3839   /* Interface modifiers check
3840        - public/abstract allowed (already done at that point)
3841        - abstract is obsolete (comes first, it's a warning, or should be)
3842        - Can't use twice the same (checked in the modifier rule) */
3843   if ((flags & ACC_ABSTRACT) && flag_redundant)
3844     parse_warning_context
3845       (MODIFIER_WFL (ABSTRACT_TK),
3846        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3847 
3848   /* Create a new decl if DECL is NULL, otherwise fix it */
3849   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3850 
3851   /* Set super info and mark the class a complete */
3852   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3853 		  object_type_node, ctxp->interface_number);
3854   ctxp->interface_number = 0;
3855   CLASS_COMPLETE_P (decl) = 1;
3856   add_superinterfaces (decl, super);
3857 
3858   /* Eventually sets the @deprecated tag flag */
3859   CHECK_DEPRECATED (decl);
3860 
3861   return decl;
3862 }
3863 
3864 /* Patch anonymous class CLASS, by either extending or implementing
3865    DEP.  */
3866 
3867 static void
patch_anonymous_class(tree type_decl,tree class_decl,tree wfl)3868 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3869 {
3870   tree class = TREE_TYPE (class_decl);
3871   tree type =  TREE_TYPE (type_decl);
3872   tree binfo = TYPE_BINFO (class);
3873 
3874   /* If it's an interface, implement it */
3875   if (CLASS_INTERFACE (type_decl))
3876     {
3877       tree s_binfo;
3878       int length;
3879 
3880       if (parser_check_super_interface (type_decl, class_decl, wfl))
3881 	return;
3882 
3883       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3884       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3885       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3886       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3887       /* And add the interface */
3888       parser_add_interface (class_decl, type_decl, wfl);
3889     }
3890   /* Otherwise, it's a type we want to extend */
3891   else
3892     {
3893       if (parser_check_super (type_decl, class_decl, wfl))
3894 	return;
3895       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3896     }
3897 }
3898 
3899 static tree
create_anonymous_class(int location,tree type_name)3900 create_anonymous_class (int location, tree type_name)
3901 {
3902   char buffer [80];
3903   tree super = NULL_TREE, itf = NULL_TREE;
3904   tree id, type_decl, class;
3905 
3906   /* The unqualified name of the anonymous class. It's just a number. */
3907   sprintf (buffer, "%d", anonymous_class_counter++);
3908   id = build_wfl_node (get_identifier (buffer));
3909   EXPR_WFL_LINECOL (id) = location;
3910 
3911   /* We know about the type to extend/implement. We go ahead */
3912   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3913     {
3914       /* Create a class which either implements on extends the designated
3915 	 class. The class bears an inaccessible name. */
3916       if (CLASS_INTERFACE (type_decl))
3917 	{
3918 	  /* It's OK to modify it here. It's been already used and
3919              shouldn't be reused */
3920 	  ctxp->interface_number = 1;
3921 	  /* Interfaces should presented as a list of WFLs */
3922 	  itf = build_tree_list (type_name, NULL_TREE);
3923 	}
3924       else
3925 	super = type_name;
3926     }
3927 
3928   class = create_class (ACC_FINAL, id, super, itf);
3929 
3930   /* We didn't know anything about the stuff. We register a dependence. */
3931   if (!type_decl)
3932     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3933 
3934   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3935   return class;
3936 }
3937 
3938 /* Create a class in pass1 and return its decl. Return class
3939    interface's decl in pass 2.  */
3940 
3941 static tree
create_class(int flags,tree id,tree super,tree interfaces)3942 create_class (int flags, tree id, tree super, tree interfaces)
3943 {
3944   tree raw_name = EXPR_WFL_NODE (id);
3945   tree class_id, decl;
3946   tree super_decl_type;
3947 
3948   /* Certain syntax errors are making SUPER be like ID. Avoid this
3949      case. */
3950   if (ctxp->class_err && id == super)
3951     super = NULL;
3952 
3953   class_id = parser_qualified_classname (raw_name);
3954   decl = IDENTIFIER_CLASS_VALUE (class_id);
3955   EXPR_WFL_NODE (id) = class_id;
3956 
3957   /* Basic check: scope, redefinition, modifiers */
3958   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3959     {
3960       PUSH_ERROR ();
3961       return NULL_TREE;
3962     }
3963 
3964   /* Suspend the current parsing context if we're parsing an inner
3965      class or an anonymous class. */
3966   if (CPC_INNER_P ())
3967     {
3968       java_parser_context_suspend ();
3969       /* Interface members are public. */
3970       if (CLASS_INTERFACE (GET_CPC ()))
3971 	flags |= ACC_PUBLIC;
3972     }
3973 
3974   /* Push a new context for (static) initialized upon declaration fields */
3975   java_parser_context_push_initialized_field ();
3976 
3977   /* Class modifier check:
3978        - Allowed modifier (already done at that point)
3979        - abstract AND final forbidden
3980        - Public classes defined in the correct file */
3981   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3982     parse_error_context
3983       (id, "Class `%s' can't be declared both abstract and final",
3984        IDENTIFIER_POINTER (raw_name));
3985 
3986   /* Create a new decl if DECL is NULL, otherwise fix it */
3987   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3988 
3989   /* If SUPER exists, use it, otherwise use Object */
3990   if (super)
3991     {
3992       /* Can't extend java.lang.Object */
3993       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3994 	{
3995 	  parse_error_context (id, "Can't extend `java.lang.Object'");
3996 	  return NULL_TREE;
3997 	}
3998 
3999       super_decl_type =
4000 	register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4001     }
4002   else if (TREE_TYPE (decl) != object_type_node)
4003     super_decl_type = object_type_node;
4004   /* We're defining java.lang.Object */
4005   else
4006     super_decl_type = NULL_TREE;
4007 
4008   /* A class nested in an interface is implicitly static. */
4009   if (INNER_CLASS_DECL_P (decl)
4010       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4011     {
4012       flags |= ACC_STATIC;
4013     }
4014 
4015   /* Set super info and mark the class as complete. */
4016   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4017 		  ctxp->interface_number);
4018   ctxp->interface_number = 0;
4019   CLASS_COMPLETE_P (decl) = 1;
4020   add_superinterfaces (decl, interfaces);
4021 
4022   /* Add the private this$<n> field, Replicate final locals still in
4023      scope as private final fields mangled like val$<local_name>.
4024      This doesn't not occur for top level (static) inner classes. */
4025   if (PURE_INNER_CLASS_DECL_P (decl))
4026     add_inner_class_fields (decl, current_function_decl);
4027 
4028   /* If doing xref, store the location at which the inherited class
4029      (if any) was seen. */
4030   if (flag_emit_xref && super)
4031     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4032 
4033   /* Eventually sets the @deprecated tag flag */
4034   CHECK_DEPRECATED (decl);
4035 
4036   /* Reset the anonymous class counter when declaring non inner classes */
4037   if (!INNER_CLASS_DECL_P (decl))
4038     anonymous_class_counter = 1;
4039 
4040   return decl;
4041 }
4042 
4043 /* End a class declaration: register the statements used to create
4044    finit$ and <clinit>, pop the current class and resume the prior
4045    parser context if necessary.  */
4046 
4047 static void
end_class_declaration(int resume)4048 end_class_declaration (int resume)
4049 {
4050   /* If an error occurred, context weren't pushed and won't need to be
4051      popped by a resume. */
4052   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4053 
4054   if (GET_CPC () != error_mark_node)
4055     dump_java_tree (TDI_class, GET_CPC ());
4056 
4057   java_parser_context_pop_initialized_field ();
4058   POP_CPC ();
4059   if (resume && no_error_occurred)
4060     java_parser_context_resume ();
4061 
4062   /* We're ending a class declaration, this is a good time to reset
4063      the interface cout. Note that might have been already done in
4064      create_interface, but if at that time an inner class was being
4065      dealt with, the interface count was reset in a context created
4066      for the sake of handling inner classes declaration. */
4067   ctxp->interface_number = 0;
4068 }
4069 
4070 static void
add_inner_class_fields(tree class_decl,tree fct_decl)4071 add_inner_class_fields (tree class_decl, tree fct_decl)
4072 {
4073   tree block, marker, f;
4074 
4075   f = add_field (TREE_TYPE (class_decl),
4076 		 build_current_thisn (TREE_TYPE (class_decl)),
4077 		 build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4078 		 ACC_PRIVATE);
4079   FIELD_THISN (f) = 1;
4080 
4081   if (!fct_decl)
4082     return;
4083 
4084   for (block = GET_CURRENT_BLOCK (fct_decl);
4085        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4086     {
4087       tree decl;
4088       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4089 	{
4090 	  tree name, pname;
4091 	  tree wfl, init, list;
4092 
4093 	  /* Avoid non final arguments. */
4094 	  if (!LOCAL_FINAL_P (decl))
4095 	    continue;
4096 
4097 	  MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4098 	  MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4099 	  wfl = build_wfl_node (name);
4100 	  init = build_wfl_node (pname);
4101 	  /* Build an initialization for the field: it will be
4102 	     initialized by a parameter added to finit$, bearing a
4103 	     mangled name of the field itself (param$<n>.) The
4104 	     parameter is provided to finit$ by the constructor
4105 	     invoking it (hence the constructor will also feature a
4106 	     hidden parameter, set to the value of the outer context
4107 	     local at the time the inner class is created.)
4108 
4109 	     Note: we take into account all possible locals that can
4110 	     be accessed by the inner class. It's actually not trivial
4111 	     to minimize these aliases down to the ones really
4112 	     used. One way to do that would be to expand all regular
4113 	     methods first, then finit$ to get a picture of what's
4114 	     used.  It works with the exception that we would have to
4115 	     go back on all constructor invoked in regular methods to
4116 	     have their invocation reworked (to include the right amount
4117 	     of alias initializer parameters.)
4118 
4119 	     The only real way around, I think, is a first pass to
4120 	     identify locals really used in the inner class. We leave
4121 	     the flag FIELD_LOCAL_ALIAS_USED around for that future
4122 	     use.
4123 
4124 	     On the other hand, it only affect local inner classes,
4125 	     whose constructors (and finit$ call) will be featuring
4126 	     unnecessary arguments. It's easy for a developer to keep
4127 	     this number of parameter down by using the `final'
4128 	     keyword only when necessary. For the time being, we can
4129 	     issue a warning on unnecessary finals. FIXME */
4130 	  init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4131 				   wfl, init);
4132 
4133 	  /* Register the field. The TREE_LIST holding the part
4134 	     initialized/initializer will be marked ARG_FINAL_P so
4135 	     that the created field can be marked
4136 	     FIELD_LOCAL_ALIAS. */
4137 	  list = build_tree_list (wfl, init);
4138 	  ARG_FINAL_P (list) = 1;
4139 	  register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4140 	}
4141     }
4142 
4143   if (!CPC_INITIALIZER_STMT (ctxp))
4144     return;
4145 
4146   /* If we ever registered an alias field, insert and marker to
4147      remember where the list ends. The second part of the list (the one
4148      featuring initialized fields) so it can be later reversed to
4149      enforce 8.5. The marker will be removed during that operation. */
4150   marker = build_tree_list (NULL_TREE, NULL_TREE);
4151   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4152   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4153 }
4154 
4155 /* Can't use lookup_field () since we don't want to load the class and
4156    can't set the CLASS_LOADED_P flag */
4157 
4158 static tree
find_field(tree class,tree name)4159 find_field (tree class, tree name)
4160 {
4161   tree decl;
4162   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4163     {
4164       if (DECL_NAME (decl) == name)
4165 	return decl;
4166     }
4167   return NULL_TREE;
4168 }
4169 
4170 /* Wrap around lookup_field that doesn't potentially upset the value
4171    of CLASS */
4172 
4173 static tree
lookup_field_wrapper(tree class,tree name)4174 lookup_field_wrapper (tree class, tree name)
4175 {
4176   tree type = class;
4177   tree decl = NULL_TREE;
4178   java_parser_context_save_global ();
4179 
4180   /* Last chance: if we're within the context of an inner class, we
4181      might be trying to access a local variable defined in an outer
4182      context. We try to look for it now. */
4183   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4184     {
4185       tree new_name;
4186       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4187       decl = lookup_field (&type, new_name);
4188       if (decl && decl != error_mark_node)
4189 	FIELD_LOCAL_ALIAS_USED (decl) = 1;
4190     }
4191   if (!decl || decl == error_mark_node)
4192     {
4193       type = class;
4194       decl = lookup_field (&type, name);
4195     }
4196 
4197   /* If the field still hasn't been found, try the next enclosing context. */
4198   if (!decl && INNER_CLASS_TYPE_P (class))
4199     {
4200       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4201       decl = lookup_field_wrapper (outer_type, name);
4202     }
4203 
4204   java_parser_context_restore_global ();
4205   return decl == error_mark_node ? NULL : decl;
4206 }
4207 
4208 /* Find duplicate field within the same class declarations and report
4209    the error. Returns 1 if a duplicated field was found, 0
4210    otherwise.  */
4211 
4212 static int
duplicate_declaration_error_p(tree new_field_name,tree new_type,tree cl)4213 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4214 {
4215   /* This might be modified to work with method decl as well */
4216   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4217   if (decl)
4218     {
4219       char *t1 = xstrdup (purify_type_name
4220 			 ((TREE_CODE (new_type) == POINTER_TYPE
4221 			   && TREE_TYPE (new_type) == NULL_TREE) ?
4222 			  IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4223 			  lang_printable_name (new_type, 1)));
4224       /* The type may not have been completed by the time we report
4225 	 the error */
4226       char *t2 = xstrdup (purify_type_name
4227 			 ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4228 			   && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4229 			  IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4230 			  lang_printable_name (TREE_TYPE (decl), 1)));
4231       parse_error_context
4232 	(cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4233 	 t1, IDENTIFIER_POINTER (new_field_name),
4234 	 t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4235 	 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4236       free (t1);
4237       free (t2);
4238       return 1;
4239     }
4240   return 0;
4241 }
4242 
4243 /* Field registration routine. If TYPE doesn't exist, field
4244    declarations are linked to the undefined TYPE dependency list, to
4245    be later resolved in java_complete_class () */
4246 
4247 static void
register_fields(int flags,tree type,tree variable_list)4248 register_fields (int flags, tree type, tree variable_list)
4249 {
4250   tree current, saved_type;
4251   tree class_type = NULL_TREE;
4252   int saved_lineno = input_line;
4253   int must_chain = 0;
4254   tree wfl = NULL_TREE;
4255 
4256   if (GET_CPC ())
4257     class_type = TREE_TYPE (GET_CPC ());
4258 
4259   if (!class_type || class_type == error_mark_node)
4260     return;
4261 
4262   /* If we're adding fields to interfaces, those fields are public,
4263      static, final */
4264   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4265     {
4266       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4267 				 flags, ACC_PUBLIC, "interface field(s)");
4268       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4269 				 flags, ACC_STATIC, "interface field(s)");
4270       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4271 				 flags, ACC_FINAL, "interface field(s)");
4272       check_modifiers ("Illegal interface member modifier `%s'", flags,
4273 		       INTERFACE_FIELD_MODIFIERS);
4274       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4275     }
4276 
4277   /* Obtain a suitable type for resolution, if necessary */
4278   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4279 
4280   /* If TYPE is fully resolved and we don't have a reference, make one */
4281   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4282 
4283   for (current = variable_list, saved_type = type; current;
4284        current = TREE_CHAIN (current), type = saved_type)
4285     {
4286       tree real_type;
4287       tree field_decl;
4288       tree cl = TREE_PURPOSE (current);
4289       tree init = TREE_VALUE (current);
4290       tree current_name = EXPR_WFL_NODE (cl);
4291 
4292       /* Can't declare non-final static fields in inner classes */
4293       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4294           && !(flags & ACC_FINAL))
4295 	parse_error_context
4296           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4297 	   IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4298 	   lang_printable_name (class_type, 0));
4299 
4300       /* Process NAME, as it may specify extra dimension(s) for it */
4301       type = build_array_from_name (type, wfl, current_name, &current_name);
4302 
4303       /* Type adjustment. We may have just readjusted TYPE because
4304 	 the variable specified more dimensions. Make sure we have
4305 	 a reference if we can and don't have one already. Also
4306 	 change the name if we have an init. */
4307       if (type != saved_type)
4308 	{
4309 	  PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4310 	  if (init)
4311 	    EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4312 	}
4313 
4314       real_type = GET_REAL_TYPE (type);
4315       /* Check for redeclarations */
4316       if (duplicate_declaration_error_p (current_name, real_type, cl))
4317 	continue;
4318 
4319       /* Set lineno to the line the field was found and create a
4320          declaration for it. Eventually sets the @deprecated tag flag. */
4321       if (flag_emit_xref)
4322 	input_line = EXPR_WFL_LINECOL (cl);
4323       else
4324 	input_line = EXPR_WFL_LINENO (cl);
4325       field_decl = add_field (class_type, current_name, real_type, flags);
4326       CHECK_DEPRECATED_NO_RESET (field_decl);
4327 
4328       /* If the field denotes a final instance variable, then we
4329 	 allocate a LANG_DECL_SPECIFIC part to keep track of its
4330 	 initialization. We also mark whether the field was
4331 	 initialized upon its declaration. We don't do that if the
4332 	 created field is an alias to a final local. */
4333       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4334 	{
4335 	  MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4336 	  DECL_FIELD_FINAL_WFL (field_decl) = cl;
4337 	}
4338 
4339       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4340 	 we mark the created field FIELD_LOCAL_ALIAS, so that we can
4341 	 hide parameters to this inner class finit$ and
4342 	 constructors. It also means that the field isn't final per
4343 	 say. */
4344       if (ARG_FINAL_P (current))
4345 	{
4346 	  FIELD_LOCAL_ALIAS (field_decl) = 1;
4347 	  FIELD_FINAL (field_decl) = 0;
4348 	}
4349 
4350       /* Check if we must chain. */
4351       if (must_chain)
4352 	register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4353 
4354       /* If we have an initialization value tied to the field */
4355       if (init)
4356 	{
4357 	  /* The field is declared static */
4358 	  if (flags & ACC_STATIC)
4359 	    {
4360 	      /* We include the field and its initialization part into
4361 		 a list used to generate <clinit>. After <clinit> is
4362 		 walked, field initializations will be processed and
4363 		 fields initialized with known constants will be taken
4364 		 out of <clinit> and have their DECL_INITIAL set
4365 		 appropriately. */
4366 	      TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4367 	      SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4368 	      if (TREE_OPERAND (init, 1)
4369 		  && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4370 		TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4371 	    }
4372 	  /* A non-static field declared with an immediate initialization is
4373 	     to be initialized in <init>, if any.  This field is remembered
4374 	     to be processed at the time of the generation of <init>. */
4375 	  else
4376 	    {
4377 	      TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4378 	      SET_CPC_INITIALIZER_STMT (ctxp, init);
4379 	    }
4380 	  MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4381 	  DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4382 	}
4383     }
4384 
4385   CLEAR_DEPRECATED;
4386   input_line = saved_lineno;
4387 }
4388 
4389 /* Generate finit$, using the list of initialized fields to populate
4390    its body. finit$'s parameter(s) list is adjusted to include the
4391    one(s) used to initialized the field(s) caching outer context
4392    local(s).  */
4393 
4394 static tree
generate_finit(tree class_type)4395 generate_finit (tree class_type)
4396 {
4397   int count = 0;
4398   tree list = TYPE_FINIT_STMT_LIST (class_type);
4399   tree mdecl, current, parms;
4400 
4401   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4402 						  class_type, NULL_TREE,
4403 						  &count);
4404   CRAFTED_PARAM_LIST_FIXUP (parms);
4405   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4406 				    finit_identifier_node, parms);
4407   fix_method_argument_names (parms, mdecl);
4408   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4409 		       mdecl, NULL_TREE);
4410   DECL_FUNCTION_NAP (mdecl) = count;
4411   start_artificial_method_body (mdecl);
4412 
4413   for (current = list; current; current = TREE_CHAIN (current))
4414     java_method_add_stmt (mdecl,
4415 			  build_debugable_stmt (EXPR_WFL_LINECOL (current),
4416 						current));
4417   end_artificial_method_body (mdecl);
4418   return mdecl;
4419 }
4420 
4421 /* Generate a function to run the instance initialization code. The
4422    private method is called `instinit$'. Unless we're dealing with an
4423    anonymous class, we determine whether all ctors of CLASS_TYPE
4424    declare a checked exception in their `throws' clause in order to
4425    see whether it's necessary to encapsulate the instance initializer
4426    statements in a try/catch/rethrow sequence.  */
4427 
4428 static tree
generate_instinit(tree class_type)4429 generate_instinit (tree class_type)
4430 {
4431   tree current;
4432   tree compound = NULL_TREE;
4433   tree parms = tree_cons (this_identifier_node,
4434 			  build_pointer_type (class_type), end_params_node);
4435   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4436 					 void_type_node,
4437 					 instinit_identifier_node, parms);
4438 
4439   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4440 		       mdecl, NULL_TREE);
4441 
4442   /* Gather all the statements in a compound */
4443   for (current = TYPE_II_STMT_LIST (class_type);
4444        current; current = TREE_CHAIN (current))
4445     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4446 
4447   /* We need to encapsulate COMPOUND by a try/catch statement to
4448      rethrow exceptions that might occur in the instance initializer.
4449      We do that only if all ctors of CLASS_TYPE are set to catch a
4450      checked exception. This doesn't apply to anonymous classes (since
4451      they don't have declared ctors.) */
4452   if (!ANONYMOUS_CLASS_P (class_type) &&
4453       ctors_unchecked_throws_clause_p (class_type))
4454     {
4455       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4456 					     build1 (THROW_EXPR, NULL_TREE,
4457 						     build_wfl_node (wpv_id)));
4458       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4459 						      exception_type_node);
4460     }
4461 
4462   start_artificial_method_body (mdecl);
4463   java_method_add_stmt (mdecl, compound);
4464   end_artificial_method_body (mdecl);
4465 
4466   return mdecl;
4467 }
4468 
4469 /* FIXME */
4470 static tree
build_instinit_invocation(tree class_type)4471 build_instinit_invocation (tree class_type)
4472 {
4473   tree to_return = NULL_TREE;
4474 
4475   if (TYPE_II_STMT_LIST (class_type))
4476     {
4477       tree parm = build_tree_list (NULL_TREE,
4478 				   build_wfl_node (this_identifier_node));
4479       to_return =
4480 	build_method_invocation (build_wfl_node (instinit_identifier_node),
4481 				 parm);
4482     }
4483   return to_return;
4484 }
4485 
4486 /* Shared across method_declarator and method_header to remember the
4487    patch stage that was reached during the declaration of the method.
4488    A method DECL is built differently is there is no patch
4489    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4490    pending on the currently defined method.  */
4491 
4492 static int patch_stage;
4493 
4494 /* Check the method declaration and add the method to its current
4495    class.  If the argument list is known to contain incomplete types,
4496    the method is partially added and the registration will be resume
4497    once the method arguments resolved. If TYPE is NULL, we're dealing
4498    with a constructor.  */
4499 
4500 static tree
method_header(int flags,tree type,tree mdecl,tree throws)4501 method_header (int flags, tree type, tree mdecl, tree throws)
4502 {
4503   tree type_wfl = NULL_TREE;
4504   tree meth_name = NULL_TREE;
4505   tree current, orig_arg, this_class = NULL;
4506   tree id, meth;
4507   int saved_lineno;
4508   int constructor_ok = 0, must_chain;
4509   int count;
4510 
4511   if (mdecl == error_mark_node)
4512     return error_mark_node;
4513   meth = TREE_VALUE (mdecl);
4514   id = TREE_PURPOSE (mdecl);
4515 
4516   check_modifiers_consistency (flags);
4517 
4518   if (GET_CPC ())
4519     this_class = TREE_TYPE (GET_CPC ());
4520 
4521   if (!this_class || this_class == error_mark_node)
4522     return NULL_TREE;
4523 
4524   /* There are some forbidden modifiers for an abstract method and its
4525      class must be abstract as well.  */
4526   if (type && (flags & ACC_ABSTRACT))
4527     {
4528       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4529       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4530       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4531       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4532       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4533       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4534       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4535 	  && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4536 	parse_error_context
4537 	  (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4538 	   IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4539 	   IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4540     }
4541 
4542   /* A native method can't be strictfp.  */
4543   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4544     parse_error_context (id, "native method `%s' can't be strictfp",
4545 			 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4546   /* No such thing as a transient or volatile method.  */
4547   if ((flags & ACC_TRANSIENT))
4548     parse_error_context (id, "method `%s' can't be transient",
4549 			 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4550   if ((flags & ACC_VOLATILE))
4551     parse_error_context (id, "method `%s' can't be volatile",
4552 			 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4553 
4554   /* Things to be checked when declaring a constructor */
4555   if (!type)
4556     {
4557       int ec = java_error_count;
4558       /* 8.6: Constructor declarations: we might be trying to define a
4559          method without specifying a return type. */
4560       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4561 	parse_error_context
4562 	  (id, "Invalid method declaration, return type required");
4563       /* 8.6.3: Constructor modifiers */
4564       else
4565 	{
4566 	  JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4567 	  JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4568 	  JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4569 	  JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4570 	  JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4571 	  JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4572 	}
4573       /* If we found error here, we don't consider it's OK to tread
4574 	 the method definition as a constructor, for the rest of this
4575 	 function */
4576       if (ec == java_error_count)
4577 	constructor_ok = 1;
4578     }
4579 
4580   /* Method declared within the scope of an interface are implicitly
4581      abstract and public. Conflicts with other erroneously provided
4582      modifiers are checked right after. */
4583 
4584   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4585     {
4586       /* If FLAGS isn't set because of a modifier, turn the
4587 	 corresponding modifier WFL to NULL so we issue a warning on
4588 	 the obsolete use of the modifier */
4589       if (!(flags & ACC_PUBLIC))
4590         MODIFIER_WFL (PUBLIC_TK) = NULL;
4591       if (!(flags & ACC_ABSTRACT))
4592         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4593       flags |= ACC_PUBLIC;
4594       flags |= ACC_ABSTRACT;
4595     }
4596 
4597   /* Inner class can't declare static methods */
4598   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4599     {
4600       parse_error_context
4601 	(id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4602 	 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4603 	 lang_printable_name (this_class, 0));
4604     }
4605 
4606   /* Modifiers context reset moved up, so abstract method declaration
4607      modifiers can be later checked.  */
4608 
4609   /* Set constructor returned type to void and method name to <init>,
4610      unless we found an error identifier the constructor (in which
4611      case we retain the original name) */
4612   if (!type)
4613     {
4614       type = void_type_node;
4615       if (constructor_ok)
4616 	meth_name = init_identifier_node;
4617     }
4618   else
4619     meth_name = EXPR_WFL_NODE (id);
4620 
4621   /* Do the returned type resolution and registration if necessary */
4622   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4623 
4624   if (meth_name)
4625     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4626   EXPR_WFL_NODE (id) = meth_name;
4627   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4628 
4629   if (must_chain)
4630     {
4631       patch_stage = JDEP_METHOD_RETURN;
4632       register_incomplete_type (patch_stage, type_wfl, id, type);
4633       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4634     }
4635   else
4636     TREE_TYPE (meth) = type;
4637 
4638   saved_lineno = input_line;
4639   /* When defining an abstract or interface method, the curly
4640      bracket at level 1 doesn't exist because there is no function
4641      body */
4642   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4643 	    EXPR_WFL_LINENO (id));
4644 
4645   /* Remember the original argument list */
4646   orig_arg = TYPE_ARG_TYPES (meth);
4647 
4648   if (patch_stage)		/* includes ret type and/or all args */
4649     {
4650       jdep *jdep;
4651       meth = add_method_1 (this_class, flags, meth_name, meth);
4652       /* Patch for the return type */
4653       if (patch_stage == JDEP_METHOD_RETURN)
4654 	{
4655 	  jdep = CLASSD_LAST (ctxp->classd_list);
4656 	  JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4657 	}
4658       /* This is the stop JDEP. METH allows the function's signature
4659 	 to be computed. */
4660       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4661     }
4662   else
4663     meth = add_method (this_class, flags, meth_name,
4664 		       build_java_signature (meth));
4665 
4666   /* Remember final parameters */
4667   MARK_FINAL_PARMS (meth, orig_arg);
4668 
4669   /* Fix the method argument list so we have the argument name
4670      information */
4671   fix_method_argument_names (orig_arg, meth);
4672 
4673   /* Register the parameter number and re-install the current line
4674      number */
4675   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4676   input_line = saved_lineno;
4677 
4678   /* Register exception specified by the `throws' keyword for
4679      resolution and set the method decl appropriate field to the list.
4680      Note: the grammar ensures that what we get here are class
4681      types. */
4682   if (throws)
4683     {
4684       throws = nreverse (throws);
4685       for (current = throws; current; current = TREE_CHAIN (current))
4686 	{
4687 	  register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4688 				    NULL_TREE, NULL_TREE);
4689 	  JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4690 	    &TREE_VALUE (current);
4691 	}
4692       DECL_FUNCTION_THROWS (meth) = throws;
4693     }
4694 
4695   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4696     DECL_FUNCTION_WFL (meth) = id;
4697 
4698   /* Set the flag if we correctly processed a constructor */
4699   if (constructor_ok)
4700     {
4701       DECL_CONSTRUCTOR_P (meth) = 1;
4702       /* Compute and store the number of artificial parameters declared
4703 	 for this constructor */
4704       for (count = 0, current = TYPE_FIELDS (this_class); current;
4705 	   current = TREE_CHAIN (current))
4706 	if (FIELD_LOCAL_ALIAS (current))
4707 	  count++;
4708       DECL_FUNCTION_NAP (meth) = count;
4709     }
4710 
4711   /* Eventually set the @deprecated tag flag */
4712   CHECK_DEPRECATED (meth);
4713 
4714   /* If doing xref, store column and line number information instead
4715      of the line number only. */
4716   if (flag_emit_xref)
4717     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4718 
4719   return meth;
4720 }
4721 
4722 static void
fix_method_argument_names(tree orig_arg,tree meth)4723 fix_method_argument_names (tree orig_arg, tree meth)
4724 {
4725   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4726   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4727     {
4728       TREE_PURPOSE (arg) = this_identifier_node;
4729       arg = TREE_CHAIN (arg);
4730     }
4731   while (orig_arg != end_params_node)
4732     {
4733       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4734       orig_arg = TREE_CHAIN (orig_arg);
4735       arg = TREE_CHAIN (arg);
4736     }
4737 }
4738 
4739 /* Complete the method declaration with METHOD_BODY.  */
4740 
4741 static void
finish_method_declaration(tree method_body)4742 finish_method_declaration (tree method_body)
4743 {
4744   int flags;
4745 
4746   if (!current_function_decl)
4747     return;
4748 
4749   flags = get_access_flags_from_decl (current_function_decl);
4750 
4751   /* 8.4.5 Method Body */
4752   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4753     {
4754       tree name = DECL_NAME (current_function_decl);
4755       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4756 			   "%s method `%s' can't have a body defined",
4757 			   (METHOD_NATIVE (current_function_decl) ?
4758 			    "Native" : "Abstract"),
4759 			   IDENTIFIER_POINTER (name));
4760       method_body = NULL_TREE;
4761     }
4762   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4763     {
4764       tree name = DECL_NAME (current_function_decl);
4765       parse_error_context
4766 	(DECL_FUNCTION_WFL (current_function_decl),
4767 	 "Non native and non abstract method `%s' must have a body defined",
4768 	 IDENTIFIER_POINTER (name));
4769       method_body = NULL_TREE;
4770     }
4771 
4772   if (flag_emit_class_files && method_body
4773       && TREE_CODE (method_body) == NOP_EXPR
4774       && TREE_TYPE (current_function_decl)
4775       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4776     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4777 
4778   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4779   maybe_absorb_scoping_blocks ();
4780   /* Exit function's body */
4781   exit_block ();
4782   /* Merge last line of the function with first line, directly in the
4783      function decl. It will be used to emit correct debug info. */
4784   if (!flag_emit_xref)
4785     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4786 
4787   /* Since function's argument's list are shared, reset the
4788      ARG_FINAL_P parameter that might have been set on some of this
4789      function parameters. */
4790   UNMARK_FINAL_PARMS (current_function_decl);
4791 
4792   /* So we don't have an irrelevant function declaration context for
4793      the next static block we'll see. */
4794   current_function_decl = NULL_TREE;
4795 }
4796 
4797 /* Build a an error message for constructor circularity errors.  */
4798 
4799 static char *
constructor_circularity_msg(tree from,tree to)4800 constructor_circularity_msg (tree from, tree to)
4801 {
4802   static char string [4096];
4803   char *t = xstrdup (lang_printable_name (from, 0));
4804   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4805   free (t);
4806   return string;
4807 }
4808 
4809 /* Verify a circular call to METH. Return 1 if an error is found, 0
4810    otherwise.  */
4811 
4812 static GTY(()) tree vcc_list;
4813 static int
verify_constructor_circularity(tree meth,tree current)4814 verify_constructor_circularity (tree meth, tree current)
4815 {
4816   tree c;
4817 
4818   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4819     {
4820       if (TREE_VALUE (c) == meth)
4821 	{
4822 	  char *t;
4823 	  if (vcc_list)
4824 	    {
4825 	      tree liste;
4826 	      vcc_list = nreverse (vcc_list);
4827 	      for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4828 		{
4829 		  parse_error_context
4830 		    (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4831 		     constructor_circularity_msg
4832 		      (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4833 		  java_error_count--;
4834 		}
4835 	    }
4836 	  t = xstrdup (lang_printable_name (meth, 0));
4837 	  parse_error_context (TREE_PURPOSE (c),
4838 			       "%s: recursive invocation of constructor `%s'",
4839 			       constructor_circularity_msg (current, meth), t);
4840 	  free (t);
4841 	  vcc_list = NULL_TREE;
4842 	  return 1;
4843 	}
4844     }
4845   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4846     {
4847       vcc_list = tree_cons (c, current, vcc_list);
4848       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4849 	return 1;
4850       vcc_list = TREE_CHAIN (vcc_list);
4851     }
4852   return 0;
4853 }
4854 
4855 /* Check modifiers that can be declared but exclusively */
4856 
4857 static void
check_modifiers_consistency(int flags)4858 check_modifiers_consistency (int flags)
4859 {
4860   int acc_count = 0;
4861   tree cl = NULL_TREE;
4862 
4863   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4864   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4865   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4866   if (acc_count > 1)
4867     parse_error_context
4868       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4869 
4870   acc_count = 0;
4871   cl = NULL_TREE;
4872   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4873   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4874   if (acc_count > 1)
4875     parse_error_context (cl,
4876 			 "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4877 }
4878 
4879 /* Check the methode header METH for abstract specifics features */
4880 
4881 static void
check_abstract_method_header(tree meth)4882 check_abstract_method_header (tree meth)
4883 {
4884   int flags = get_access_flags_from_decl (meth);
4885 
4886   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4887 			      ACC_ABSTRACT, "abstract method",
4888 			      IDENTIFIER_POINTER (DECL_NAME (meth)));
4889   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4890 			      ACC_PUBLIC, "abstract method",
4891 			      IDENTIFIER_POINTER (DECL_NAME (meth)));
4892 
4893   check_modifiers ("Illegal modifier `%s' for interface method",
4894 		  flags, INTERFACE_METHOD_MODIFIERS);
4895 }
4896 
4897 /* Create a FUNCTION_TYPE node and start augmenting it with the
4898    declared function arguments. Arguments type that can't be resolved
4899    are left as they are, but the returned node is marked as containing
4900    incomplete types.  */
4901 
4902 static tree
method_declarator(tree id,tree list)4903 method_declarator (tree id, tree list)
4904 {
4905   tree arg_types = NULL_TREE, current, node;
4906   tree meth = make_node (FUNCTION_TYPE);
4907   jdep *jdep;
4908 
4909   patch_stage = JDEP_NO_PATCH;
4910 
4911   if (GET_CPC () == error_mark_node)
4912     return error_mark_node;
4913 
4914   /* If we're dealing with an inner class constructor, we hide the
4915      this$<n> decl in the name field of its parameter declaration.  We
4916      also might have to hide the outer context local alias
4917      initializers. Not done when the class is a toplevel class. */
4918   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4919       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4920     {
4921       tree aliases_list, type, thisn;
4922       /* First the aliases, linked to the regular parameters */
4923       aliases_list =
4924 	build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4925 						TREE_TYPE (GET_CPC ()),
4926 						NULL_TREE, NULL);
4927       list = chainon (nreverse (aliases_list), list);
4928 
4929       /* Then this$<n> */
4930       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4931       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4932       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4933 			list);
4934     }
4935 
4936   for (current = list; current; current = TREE_CHAIN (current))
4937     {
4938       int must_chain = 0;
4939       tree wfl_name = TREE_PURPOSE (current);
4940       tree type = TREE_VALUE (current);
4941       tree name = EXPR_WFL_NODE (wfl_name);
4942       tree already, arg_node;
4943       tree type_wfl = NULL_TREE;
4944       tree real_type;
4945 
4946       /* Obtain a suitable type for resolution, if necessary */
4947       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4948 
4949       /* Process NAME, as it may specify extra dimension(s) for it */
4950       type = build_array_from_name (type, type_wfl, name, &name);
4951       EXPR_WFL_NODE (wfl_name) = name;
4952 
4953       real_type = GET_REAL_TYPE (type);
4954       if (TREE_CODE (real_type) == RECORD_TYPE)
4955 	{
4956 	  real_type = promote_type (real_type);
4957 	  if (TREE_CODE (type) == TREE_LIST)
4958 	    TREE_PURPOSE (type) = real_type;
4959 	}
4960 
4961       /* Check redefinition */
4962       for (already = arg_types; already; already = TREE_CHAIN (already))
4963 	if (TREE_PURPOSE (already) == name)
4964 	  {
4965 	    parse_error_context
4966 	      (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4967 	       IDENTIFIER_POINTER (name),
4968 	       IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4969 	    break;
4970 	  }
4971 
4972       /* If we've an incomplete argument type, we know there is a location
4973 	 to patch when the type get resolved, later.  */
4974       jdep = NULL;
4975       if (must_chain)
4976 	{
4977 	  patch_stage = JDEP_METHOD;
4978 	  type = register_incomplete_type (patch_stage,
4979 					   type_wfl, wfl_name, type);
4980 	  jdep = CLASSD_LAST (ctxp->classd_list);
4981 	  JDEP_MISC (jdep) = id;
4982 	}
4983 
4984       /* The argument node: a name and a (possibly) incomplete type.  */
4985       arg_node = build_tree_list (name, real_type);
4986       /* Remember arguments declared final. */
4987       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4988 
4989       if (jdep)
4990 	JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4991       TREE_CHAIN (arg_node) = arg_types;
4992       arg_types = arg_node;
4993     }
4994   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
4995   node = build_tree_list (id, meth);
4996   return node;
4997 }
4998 
4999 static int
unresolved_type_p(tree wfl,tree * returned)5000 unresolved_type_p (tree wfl, tree *returned)
5001 
5002 {
5003   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5004     {
5005       if (returned)
5006 	{
5007 	  tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5008 	  if (decl && current_class && (decl == TYPE_NAME (current_class)))
5009 	    *returned = TREE_TYPE (decl);
5010 	  else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5011 	    *returned = TREE_TYPE (GET_CPC ());
5012 	  else
5013 	    *returned = NULL_TREE;
5014 	}
5015       return 1;
5016     }
5017   if (returned)
5018     *returned = wfl;
5019   return 0;
5020 }
5021 
5022 /* From NAME, build a qualified identifier node using the
5023    qualification from the current package definition. */
5024 
5025 static tree
parser_qualified_classname(tree name)5026 parser_qualified_classname (tree name)
5027 {
5028   tree nested_class_name;
5029 
5030   if ((nested_class_name = maybe_make_nested_class_name (name)))
5031     return nested_class_name;
5032 
5033   if (ctxp->package)
5034     return merge_qualified_name (ctxp->package, name);
5035   else
5036     return name;
5037 }
5038 
5039 /* Called once the type a interface extends is resolved. Returns 0 if
5040    everything is OK.  */
5041 
5042 static int
parser_check_super_interface(tree super_decl,tree this_decl,tree this_wfl)5043 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5044 {
5045   tree super_type = TREE_TYPE (super_decl);
5046 
5047   /* Has to be an interface */
5048   if (!CLASS_INTERFACE (super_decl))
5049     {
5050       parse_error_context
5051 	(this_wfl, "%s `%s' can't implement/extend %s `%s'",
5052 	 (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5053 	  "Interface" : "Class"),
5054 	 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5055 	 (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5056 	 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5057       return 1;
5058     }
5059 
5060   /* Check top-level interface access. Inner classes are subject to member
5061      access rules (6.6.1). */
5062   if (! INNER_CLASS_P (super_type)
5063       && check_pkg_class_access (DECL_NAME (super_decl),
5064 				 lookup_cl (this_decl), true))
5065     return 1;
5066 
5067   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5068 			  IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5069 			  IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5070   return 0;
5071 }
5072 
5073 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5074    0 if everything is OK.  */
5075 
5076 static int
parser_check_super(tree super_decl,tree this_decl,tree wfl)5077 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5078 {
5079   tree super_type = TREE_TYPE (super_decl);
5080 
5081   /* SUPER should be a CLASS (neither an array nor an interface) */
5082   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5083     {
5084       parse_error_context
5085 	(wfl, "Class `%s' can't subclass %s `%s'",
5086 	 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5087 	 (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5088 	 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5089       return 1;
5090     }
5091 
5092   if (CLASS_FINAL (TYPE_NAME (super_type)))
5093     {
5094       parse_error_context (wfl, "Can't subclass final classes: %s",
5095 			   IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5096       return 1;
5097     }
5098 
5099   /* Check top-level class scope. Inner classes are subject to member access
5100      rules (6.6.1). */
5101   if (! INNER_CLASS_P (super_type)
5102       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
5103     return 1;
5104 
5105   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5106 			  IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5107 			  IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5108   return 0;
5109 }
5110 
5111 /* Create a new dependency list and link it (in a LIFO manner) to the
5112    CTXP list of type dependency list.  */
5113 
5114 static void
create_jdep_list(struct parser_ctxt * ctxp)5115 create_jdep_list (struct parser_ctxt *ctxp)
5116 {
5117   jdeplist *new = xmalloc (sizeof (jdeplist));
5118   new->first = new->last = NULL;
5119   new->next = ctxp->classd_list;
5120   ctxp->classd_list = new;
5121 }
5122 
5123 static jdeplist *
reverse_jdep_list(struct parser_ctxt * ctxp)5124 reverse_jdep_list (struct parser_ctxt *ctxp)
5125 {
5126   jdeplist *prev = NULL, *current, *next;
5127   for (current = ctxp->classd_list; current; current = next)
5128     {
5129       next = current->next;
5130       current->next = prev;
5131       prev = current;
5132     }
5133   return prev;
5134 }
5135 
5136 /* Create a fake pointer based on the ID stored in
5137    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5138    registered again. */
5139 
5140 static tree
obtain_incomplete_type(tree type_name)5141 obtain_incomplete_type (tree type_name)
5142 {
5143   tree ptr = NULL_TREE, name;
5144 
5145   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5146     name = EXPR_WFL_NODE (type_name);
5147   else if (INCOMPLETE_TYPE_P (type_name))
5148     name = TYPE_NAME (type_name);
5149   else
5150     abort ();
5151 
5152   /* Workaround from build_pointer_type for incomplete types.  */
5153   BUILD_PTR_FROM_NAME (ptr, name);
5154   TYPE_MODE (ptr) = ptr_mode;
5155   layout_type (ptr);
5156 
5157   return ptr;
5158 }
5159 
5160 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5161    non NULL instead of computing a new fake type based on WFL. The new
5162    dependency is inserted in the current type dependency list, in FIFO
5163    manner.  */
5164 
5165 static tree
register_incomplete_type(int kind,tree wfl,tree decl,tree ptr)5166 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5167 {
5168   jdep *new = xmalloc (sizeof (jdep));
5169 
5170   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5171     ptr = obtain_incomplete_type (wfl);
5172 
5173   JDEP_KIND (new) = kind;
5174   JDEP_DECL (new) = decl;
5175   JDEP_TO_RESOLVE (new) = ptr;
5176   JDEP_WFL (new) = wfl;
5177   JDEP_CHAIN (new) = NULL;
5178   JDEP_MISC (new) = NULL_TREE;
5179   /* For some dependencies, set the enclosing class of the current
5180      class to be the enclosing context */
5181   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5182       && GET_ENCLOSING_CPC ())
5183     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5184   else if (kind == JDEP_SUPER)
5185     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5186 			    TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5187   else
5188     JDEP_ENCLOSING (new) = GET_CPC ();
5189   JDEP_GET_PATCH (new) = (tree *)NULL;
5190 
5191   JDEP_INSERT (ctxp->classd_list, new);
5192 
5193   return ptr;
5194 }
5195 
5196 /* This checks for circular references with innerclasses. We start
5197    from SOURCE and should never reach TARGET. Extended/implemented
5198    types in SOURCE have their enclosing context checked not to reach
5199    TARGET. When the last enclosing context of SOURCE is reached, its
5200    extended/implemented types are also checked not to reach TARGET.
5201    In case of error, WFL of the offending type is returned; NULL_TREE
5202    otherwise.  */
5203 
5204 static tree
check_inner_circular_reference(tree source,tree target)5205 check_inner_circular_reference (tree source, tree target)
5206 {
5207   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5208   tree ctx, cl;
5209   int i;
5210 
5211   if (!basetype_vec)
5212     return NULL_TREE;
5213 
5214   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5215     {
5216       tree su;
5217 
5218       /* We can end up with a NULL_TREE or an incomplete type here if
5219 	 we encountered previous type resolution errors. It's safe to
5220 	 simply ignore these cases.  */
5221       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5222 	continue;
5223       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5224       if (INCOMPLETE_TYPE_P (su))
5225 	continue;
5226 
5227       if (inherits_from_p (su, target))
5228 	return lookup_cl (TYPE_NAME (su));
5229 
5230       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5231 	{
5232 	  /* An enclosing context shouldn't be TARGET */
5233 	  if (ctx == TYPE_NAME (target))
5234 	    return lookup_cl (TYPE_NAME (su));
5235 
5236 	  /* When we reach the enclosing last context, start a check
5237 	     on it, with the same target */
5238 	  if (! DECL_CONTEXT (ctx) &&
5239 	      (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5240 	    return cl;
5241 	}
5242     }
5243   return NULL_TREE;
5244 }
5245 
5246 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5247    offending type if a circularity is detected. NULL_TREE is returned
5248    otherwise. TYPE can be an interface or a class.   */
5249 
5250 static tree
check_circular_reference(tree type)5251 check_circular_reference (tree type)
5252 {
5253   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5254   int i;
5255 
5256   if (!basetype_vec)
5257     return NULL_TREE;
5258 
5259   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5260     {
5261       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5262 	return lookup_cl (TYPE_NAME (type));
5263       return NULL_TREE;
5264     }
5265 
5266   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5267     {
5268       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5269       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5270 	  && interface_of_p (type, BINFO_TYPE (vec_elt)))
5271 	return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5272     }
5273   return NULL_TREE;
5274 }
5275 
5276 void
java_check_circular_reference(void)5277 java_check_circular_reference (void)
5278 {
5279   tree current;
5280   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5281     {
5282       tree type = TREE_TYPE (current);
5283       tree cl;
5284 
5285       cl = check_circular_reference (type);
5286       if (! cl)
5287 	cl = check_inner_circular_reference (type, type);
5288       if (cl)
5289 	parse_error_context (cl, "Cyclic class inheritance%s",
5290 			     (cyclic_inheritance_report ?
5291 			      cyclic_inheritance_report : ""));
5292     }
5293 }
5294 
5295 /* Augment the parameter list PARM with parameters crafted to
5296    initialize outer context locals aliases. Through ARTIFICIAL, a
5297    count is kept of the number of crafted parameters. MODE governs
5298    what eventually gets created: something suitable for a function
5299    creation or a function invocation, either the constructor or
5300    finit$.  */
5301 
5302 static tree
build_alias_initializer_parameter_list(int mode,tree class_type,tree parm,int * artificial)5303 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5304 					int *artificial)
5305 {
5306   tree field;
5307   tree additional_parms = NULL_TREE;
5308 
5309   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5310     if (FIELD_LOCAL_ALIAS (field))
5311       {
5312 	const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5313 	tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5314 	tree mangled_id;
5315 
5316 	switch (mode)
5317 	  {
5318 	  case AIPL_FUNCTION_DECLARATION:
5319 	    MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5320 							 &buffer [4]);
5321 	    purpose = build_wfl_node (mangled_id);
5322 	    if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5323 	      value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5324 	    else
5325 	      value = TREE_TYPE (field);
5326 	    break;
5327 
5328 	  case AIPL_FUNCTION_CREATION:
5329 	    MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5330 							 &buffer [4]);
5331 	    value = TREE_TYPE (field);
5332 	    break;
5333 
5334 	  case AIPL_FUNCTION_FINIT_INVOCATION:
5335 	    MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5336 							 &buffer [4]);
5337 	    /* Now, this is wrong. purpose should always be the NAME
5338 	       of something and value its matching value (decl, type,
5339 	       etc...) FIXME -- but there is a lot to fix. */
5340 
5341 	    /* When invoked for this kind of operation, we already
5342 	       know whether a field is used or not. */
5343 	    purpose = TREE_TYPE (field);
5344 	    value = build_wfl_node (mangled_id);
5345 	    break;
5346 
5347 	  case AIPL_FUNCTION_CTOR_INVOCATION:
5348 	    /* There are two case: the constructor invocation happens
5349 	       outside the local inner, in which case, locales from the outer
5350 	       context are directly used.
5351 
5352 	       Otherwise, we fold to using the alias directly. */
5353 	    if (class_type == current_class)
5354 	      value = field;
5355 	    else
5356 	      {
5357 		name = get_identifier (&buffer[4]);
5358 		value = IDENTIFIER_LOCAL_VALUE (name);
5359 	      }
5360 	    break;
5361 	  }
5362 	additional_parms = tree_cons (purpose, value, additional_parms);
5363 	if (artificial)
5364 	  *artificial +=1;
5365       }
5366   if (additional_parms)
5367     {
5368       if (ANONYMOUS_CLASS_P (class_type)
5369           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5370         additional_parms = nreverse (additional_parms);
5371       parm = chainon (additional_parms, parm);
5372     }
5373 
5374    return parm;
5375 }
5376 
5377 /* Craft a constructor for CLASS_DECL -- what we should do when none
5378    where found. ARGS is non NULL when a special signature must be
5379    enforced. This is the case for anonymous classes.  */
5380 
5381 static tree
craft_constructor(tree class_decl,tree args)5382 craft_constructor (tree class_decl, tree args)
5383 {
5384   tree class_type = TREE_TYPE (class_decl);
5385   tree parm = NULL_TREE;
5386   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5387 	       ACC_PUBLIC : 0);
5388   int i = 0, artificial = 0;
5389   tree decl, ctor_name;
5390   char buffer [80];
5391 
5392   /* The constructor name is <init> unless we're dealing with an
5393      anonymous class, in which case the name will be fixed after having
5394      be expanded. */
5395   if (ANONYMOUS_CLASS_P (class_type))
5396     ctor_name = DECL_NAME (class_decl);
5397   else
5398     ctor_name = init_identifier_node;
5399 
5400   /* If we're dealing with an inner class constructor, we hide the
5401      this$<n> decl in the name field of its parameter declaration. */
5402   if (PURE_INNER_CLASS_TYPE_P (class_type))
5403     {
5404       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5405       parm = tree_cons (build_current_thisn (class_type),
5406 			build_pointer_type (type), parm);
5407 
5408       /* Some more arguments to be hidden here. The values of the local
5409 	 variables of the outer context that the inner class needs to see. */
5410       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5411 						     class_type, parm,
5412 						     &artificial);
5413     }
5414 
5415   /* Then if there are any args to be enforced, enforce them now */
5416   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5417     {
5418       sprintf (buffer, "parm%d", i++);
5419       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5420     }
5421 
5422   CRAFTED_PARAM_LIST_FIXUP (parm);
5423   decl = create_artificial_method (class_type, flags, void_type_node,
5424 				   ctor_name, parm);
5425   fix_method_argument_names (parm, decl);
5426   /* Now, mark the artificial parameters. */
5427   DECL_FUNCTION_NAP (decl) = artificial;
5428   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5429   DECL_INLINE (decl) = 1;
5430   return decl;
5431 }
5432 
5433 
5434 /* Fix the constructors. This will be called right after circular
5435    references have been checked. It is necessary to fix constructors
5436    early even if no code generation will take place for that class:
5437    some generated constructor might be required by the class whose
5438    compilation triggered this one to be simply loaded.  */
5439 
5440 void
java_fix_constructors(void)5441 java_fix_constructors (void)
5442 {
5443   tree current;
5444 
5445   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5446     {
5447       tree class_type = TREE_TYPE (current);
5448       int saw_ctor = 0;
5449       tree decl;
5450 
5451       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5452 	continue;
5453 
5454       output_class = current_class = class_type;
5455       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5456 	{
5457 	  if (DECL_CONSTRUCTOR_P (decl))
5458 	    {
5459 	      fix_constructors (decl);
5460 	      saw_ctor = 1;
5461 	    }
5462 	}
5463 
5464       /* Anonymous class constructor can't be generated that early. */
5465       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5466 	craft_constructor (current, NULL_TREE);
5467     }
5468 }
5469 
5470 /* safe_layout_class just makes sure that we can load a class without
5471    disrupting the current_class, input_file, lineno, etc, information
5472    about the class processed currently.  */
5473 
5474 void
safe_layout_class(tree class)5475 safe_layout_class (tree class)
5476 {
5477   tree save_current_class = current_class;
5478   location_t save_location = input_location;
5479 
5480   layout_class (class);
5481 
5482   current_class = save_current_class;
5483   input_location = save_location;
5484 }
5485 
5486 static tree
jdep_resolve_class(jdep * dep)5487 jdep_resolve_class (jdep *dep)
5488 {
5489   tree decl;
5490 
5491   if (JDEP_RESOLVED_P (dep))
5492     decl = JDEP_RESOLVED_DECL (dep);
5493   else
5494     {
5495       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5496 			    JDEP_DECL (dep), JDEP_WFL (dep));
5497       JDEP_RESOLVED (dep, decl);
5498       /* If there is no WFL, that's ok.  We generate this warning
5499 	 elsewhere.  */
5500       if (decl && JDEP_WFL (dep) != NULL_TREE)
5501 	check_deprecation (JDEP_WFL (dep), decl);
5502     }
5503 
5504   if (!decl)
5505     complete_class_report_errors (dep);
5506   else if (PURE_INNER_CLASS_DECL_P (decl))
5507     {
5508       tree inner = TREE_TYPE (decl);
5509       if (! CLASS_LOADED_P (inner))
5510 	{
5511 	  safe_layout_class (inner);
5512 	  if (TYPE_SIZE (inner) == error_mark_node)
5513 	    TYPE_SIZE (inner) = NULL_TREE;
5514 	}
5515       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5516     }
5517   return decl;
5518 }
5519 
5520 /* Complete unsatisfied class declaration and their dependencies */
5521 
5522 void
java_complete_class(void)5523 java_complete_class (void)
5524 {
5525   tree cclass;
5526   jdeplist *cclassd;
5527   int error_found;
5528   tree type;
5529 
5530   /* Process imports */
5531   process_imports ();
5532 
5533   /* Reverse things so we have the right order */
5534   ctxp->class_list = nreverse (ctxp->class_list);
5535   ctxp->classd_list = reverse_jdep_list (ctxp);
5536 
5537   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5538        cclass && cclassd;
5539        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5540     {
5541       jdep *dep;
5542 
5543       /* We keep the compilation unit imports in the class so that
5544 	 they can be used later to resolve type dependencies that
5545 	 aren't necessary to solve now. */
5546       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5547       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5548 
5549       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5550 	{
5551 	  tree decl;
5552 	  if (!(decl = jdep_resolve_class (dep)))
5553 	    continue;
5554 
5555 	  /* Now it's time to patch */
5556 	  switch (JDEP_KIND (dep))
5557 	    {
5558 	    case JDEP_SUPER:
5559 	      /* Simply patch super */
5560 	      if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5561 		continue;
5562 	      BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5563 	        (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5564 	      break;
5565 
5566 	    case JDEP_FIELD:
5567 	      {
5568 		/* We do part of the job done in add_field */
5569 		tree field_decl = JDEP_DECL (dep);
5570 		tree field_type = TREE_TYPE (decl);
5571 		if (TREE_CODE (field_type) == RECORD_TYPE)
5572 		  field_type = promote_type (field_type);
5573 		TREE_TYPE (field_decl) = field_type;
5574 		DECL_ALIGN (field_decl) = 0;
5575 		DECL_USER_ALIGN (field_decl) = 0;
5576 		layout_decl (field_decl, 0);
5577 		SOURCE_FRONTEND_DEBUG
5578 		  (("Completed field/var decl `%s' with `%s'",
5579 		    IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5580 		    IDENTIFIER_POINTER (DECL_NAME (decl))));
5581 		break;
5582 	      }
5583 	    case JDEP_METHOD:	/* We start patching a method */
5584 	    case JDEP_METHOD_RETURN:
5585 	      error_found = 0;
5586 	      while (1)
5587 		{
5588 		  if (decl)
5589 		    {
5590 		      type = TREE_TYPE(decl);
5591 		      if (TREE_CODE (type) == RECORD_TYPE)
5592 			type = promote_type (type);
5593 		      JDEP_APPLY_PATCH (dep, type);
5594 		      SOURCE_FRONTEND_DEBUG
5595 			(((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5596 			   "Completing fct `%s' with ret type `%s'":
5597 			   "Completing arg `%s' with type `%s'"),
5598 			  IDENTIFIER_POINTER (EXPR_WFL_NODE
5599 					      (JDEP_DECL_WFL (dep))),
5600 			  IDENTIFIER_POINTER (DECL_NAME (decl))));
5601 		    }
5602 		  else
5603 		    error_found = 1;
5604 		  dep = JDEP_CHAIN (dep);
5605 		  if (JDEP_KIND (dep) == JDEP_METHOD_END)
5606 		    break;
5607 		  else
5608 		    decl = jdep_resolve_class (dep);
5609 		}
5610 	      if (!error_found)
5611 		{
5612 		  tree mdecl = JDEP_DECL (dep), signature;
5613 		  /* Recompute and reset the signature, check first that
5614 		     all types are now defined. If they're not,
5615 		     don't build the signature. */
5616 		  if (check_method_types_complete (mdecl))
5617 		    {
5618 		      signature = build_java_signature (TREE_TYPE (mdecl));
5619 		      set_java_signature (TREE_TYPE (mdecl), signature);
5620 		    }
5621 		}
5622 	      else
5623 		continue;
5624 	      break;
5625 
5626 	    case JDEP_INTERFACE:
5627 	      if (parser_check_super_interface (decl, JDEP_DECL (dep),
5628 						JDEP_WFL (dep)))
5629 		continue;
5630 	      parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5631 	      break;
5632 
5633 	    case JDEP_PARM:
5634 	    case JDEP_VARIABLE:
5635 	      type = TREE_TYPE(decl);
5636 	      if (TREE_CODE (type) == RECORD_TYPE)
5637 		type = promote_type (type);
5638 	      JDEP_APPLY_PATCH (dep, type);
5639 	      break;
5640 
5641 	    case JDEP_TYPE:
5642 	      JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5643 	      SOURCE_FRONTEND_DEBUG
5644 		(("Completing a random type dependency on a '%s' node",
5645 		  tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5646 	      break;
5647 
5648 	    case JDEP_EXCEPTION:
5649 	      JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5650 	      SOURCE_FRONTEND_DEBUG
5651 		(("Completing `%s' `throws' argument node",
5652 		  IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5653 	      break;
5654 
5655 	    case JDEP_ANONYMOUS:
5656 	      patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5657 	      break;
5658 
5659 	    default:
5660 	      abort ();
5661 	    }
5662 	}
5663     }
5664   return;
5665 }
5666 
5667 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5668    array.  */
5669 
5670 static tree
resolve_class(tree enclosing,tree class_type,tree decl,tree cl)5671 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5672 {
5673   tree tname = TYPE_NAME (class_type);
5674   tree resolved_type = TREE_TYPE (class_type);
5675   int array_dims = 0;
5676   tree resolved_type_decl;
5677 
5678   if (resolved_type != NULL_TREE)
5679     {
5680       tree resolved_type_decl = TYPE_NAME (resolved_type);
5681       if (resolved_type_decl == NULL_TREE
5682 	  || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5683 	{
5684 	  resolved_type_decl = build_decl (TYPE_DECL,
5685 					   TYPE_NAME (class_type),
5686 					   resolved_type);
5687 	}
5688       return resolved_type_decl;
5689     }
5690 
5691   /* 1- Check to see if we have an array. If true, find what we really
5692      want to resolve  */
5693   if ((array_dims = build_type_name_from_array_name (tname,
5694 						     &TYPE_NAME (class_type))))
5695     WFL_STRIP_BRACKET (cl, cl);
5696 
5697   /* 2- Resolve the bare type */
5698   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5699 					       decl, cl)))
5700     return NULL_TREE;
5701   resolved_type = TREE_TYPE (resolved_type_decl);
5702 
5703   /* 3- If we have an array, reconstruct the array down to its nesting */
5704   if (array_dims)
5705     {
5706       for (; array_dims; array_dims--)
5707 	resolved_type = build_java_array_type (resolved_type, -1);
5708       resolved_type_decl = TYPE_NAME (resolved_type);
5709     }
5710   TREE_TYPE (class_type) = resolved_type;
5711   return resolved_type_decl;
5712 }
5713 
5714 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5715    are used to report error messages; CL must either be NULL_TREE or a
5716    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5717    by a variable, since it is changed by find_in_imports{_on_demand}
5718    and (but it doesn't really matter) qualify_and_find.  */
5719 
5720 tree
do_resolve_class(tree enclosing,tree class_type,tree decl,tree cl)5721 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5722 {
5723   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5724   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5725   tree decl_result;
5726   htab_t circularity_hash;
5727 
5728   if (QUALIFIED_P (TYPE_NAME (class_type)))
5729     {
5730       /* If the type name is of the form `Q . Id', then Q is either a
5731 	 package name or a class name.  First we try to find Q as a
5732 	 class and then treat Id as a member type.  If we can't find Q
5733 	 as a class then we fall through.  */
5734       tree q, left, left_type, right;
5735       if (breakdown_qualified (&left, &right, TYPE_NAME (class_type)) == 0)
5736 	{
5737 	  BUILD_PTR_FROM_NAME (left_type, left);
5738 	  q = do_resolve_class (enclosing, left_type, decl, cl);
5739 	  if (q)
5740 	    {
5741 	      enclosing = q;
5742 	      saved_enclosing_type = TREE_TYPE (q);
5743 	      BUILD_PTR_FROM_NAME (class_type, right);
5744 	    }
5745 	}
5746     }
5747 
5748   if (enclosing)
5749     {
5750       /* This hash table is used to register the classes we're going
5751 	 through when searching the current class as an inner class, in
5752 	 order to detect circular references. Remember to free it before
5753 	 returning the section 0- of this function. */
5754       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5755 				      NULL);
5756 
5757       /* 0- Search in the current class as an inner class.
5758 	 Maybe some code here should be added to load the class or
5759 	 something, at least if the class isn't an inner class and ended
5760 	 being loaded from class file. FIXME. */
5761       while (enclosing)
5762 	{
5763 	  new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5764 						&super, class_type);
5765 	  if (new_class_decl)
5766 	    break;
5767 
5768 	  /* If we haven't found anything because SUPER reached Object and
5769 	     ENCLOSING happens to be an innerclass, try the enclosing context. */
5770 	  if ((!super || super == object_type_node) &&
5771 	      enclosing && INNER_CLASS_DECL_P (enclosing))
5772 	    enclosing = DECL_CONTEXT (enclosing);
5773 	  else
5774 	    enclosing = NULL_TREE;
5775 	}
5776 
5777       htab_delete (circularity_hash);
5778 
5779       if (new_class_decl)
5780 	return new_class_decl;
5781     }
5782 
5783   /* 1- Check for the type in single imports. This will change
5784      TYPE_NAME() if something relevant is found */
5785   find_in_imports (saved_enclosing_type, class_type);
5786 
5787   /* 2- And check for the type in the current compilation unit */
5788   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5789     {
5790       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5791 	  !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5792 	load_class (TYPE_NAME (class_type), 0);
5793       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5794     }
5795 
5796   /* 3- Search according to the current package definition */
5797   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5798     {
5799       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5800 					     TYPE_NAME (class_type))))
5801 	return new_class_decl;
5802     }
5803 
5804   /* 4- Check the import on demands. Don't allow bar.baz to be
5805      imported from foo.* */
5806   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5807     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5808       return NULL_TREE;
5809 
5810   /* If found in find_in_imports_on_demand, the type has already been
5811      loaded. */
5812   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5813     return new_class_decl;
5814 
5815   /* 5- Try with a name qualified with the package name we've seen so far */
5816   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5817     {
5818       tree package;
5819 
5820       /* If there is a current package (ctxp->package), it's the first
5821 	 element of package_list and we can skip it. */
5822       for (package = (ctxp->package ?
5823 		      TREE_CHAIN (package_list) : package_list);
5824 	   package; package = TREE_CHAIN (package))
5825 	if ((new_class_decl = qualify_and_find (class_type,
5826 					       TREE_PURPOSE (package),
5827 					       TYPE_NAME (class_type))))
5828 	  return new_class_decl;
5829     }
5830 
5831   /* 5- Check another compilation unit that bears the name of type */
5832   load_class (TYPE_NAME (class_type), 0);
5833 
5834   if (!cl)
5835     cl = lookup_cl (decl);
5836 
5837   /* If we don't have a value for CL, then we're being called recursively.
5838      We can't check package access just yet, but it will be taken care of
5839      by the caller. */
5840   if (cl)
5841     {
5842       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
5843         return NULL_TREE;
5844     }
5845 
5846   /* 6- Last call for a resolution */
5847   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5848 
5849   /* The final lookup might have registered a.b.c into a.b$c If we
5850      failed at the first lookup, progressively change the name if
5851      applicable and use the matching DECL instead. */
5852   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5853     {
5854       char *separator;
5855       tree name = TYPE_NAME (class_type);
5856       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5857 
5858       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5859 
5860       do {
5861 
5862        /* Reach the last '.', and if applicable, replace it by a `$' and
5863           see if this exists as a type. */
5864        if ((separator = strrchr (namebuffer, '.')))
5865          {
5866            *separator = '$';
5867            name = get_identifier (namebuffer);
5868            decl_result = IDENTIFIER_CLASS_VALUE (name);
5869          }
5870       } while (!decl_result && separator);
5871     }
5872   return decl_result;
5873 }
5874 
5875 static tree
qualify_and_find(tree class_type,tree package,tree name)5876 qualify_and_find (tree class_type, tree package, tree name)
5877 {
5878   tree new_qualified = merge_qualified_name (package, name);
5879   tree new_class_decl;
5880 
5881   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5882     load_class (new_qualified, 0);
5883   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5884     {
5885       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5886 	  !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5887 	load_class (new_qualified, 0);
5888       TYPE_NAME (class_type) = new_qualified;
5889       return IDENTIFIER_CLASS_VALUE (new_qualified);
5890     }
5891   return NULL_TREE;
5892 }
5893 
5894 /* Resolve NAME and lay it out (if not done and if not the current
5895    parsed class). Return a decl node. This function is meant to be
5896    called when type resolution is necessary during the walk pass.  */
5897 
5898 static tree
resolve_and_layout(tree something,tree cl)5899 resolve_and_layout (tree something, tree cl)
5900 {
5901   tree decl, decl_type;
5902 
5903   /* Don't do that on the current class */
5904   if (something == current_class)
5905     return TYPE_NAME (current_class);
5906 
5907   /* Don't do anything for void and other primitive types */
5908   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5909     return NULL_TREE;
5910 
5911   /* Pointer types can be reall pointer types or fake pointers. When
5912      finding a real pointer, recheck for primitive types */
5913   if (TREE_CODE (something) == POINTER_TYPE)
5914     {
5915       if (TREE_TYPE (something))
5916 	{
5917 	  something = TREE_TYPE (something);
5918 	  if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5919 	    return NULL_TREE;
5920 	}
5921       else
5922 	something = TYPE_NAME (something);
5923     }
5924 
5925   /* Don't do anything for arrays of primitive types */
5926   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5927       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5928     return NULL_TREE;
5929 
5930   /* Something might be a WFL */
5931   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5932     something = EXPR_WFL_NODE (something);
5933 
5934   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5935      TYPE_DECL or a real TYPE */
5936   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5937     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5938 	    DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5939 
5940   if (!(decl = resolve_no_layout (something, cl)))
5941     return NULL_TREE;
5942 
5943   /* Resolve and layout if necessary */
5944   decl_type = TREE_TYPE (decl);
5945   layout_class_methods (decl_type);
5946   /* Check methods */
5947   if (CLASS_FROM_SOURCE_P (decl_type))
5948     java_check_methods (decl);
5949   /* Layout the type if necessary */
5950   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5951     safe_layout_class (decl_type);
5952 
5953   return decl;
5954 }
5955 
5956 /* Resolve a class, returns its decl but doesn't perform any
5957    layout. The current parsing context is saved and restored */
5958 
5959 static tree
resolve_no_layout(tree name,tree cl)5960 resolve_no_layout (tree name, tree cl)
5961 {
5962   tree ptr, decl;
5963   BUILD_PTR_FROM_NAME (ptr, name);
5964   java_parser_context_save_global ();
5965   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5966   java_parser_context_restore_global ();
5967 
5968   return decl;
5969 }
5970 
5971 /* Called when reporting errors. Skip the '[]'s in a complex array
5972    type description that failed to be resolved. purify_type_name can't
5973    use an identifier tree.  */
5974 
5975 static const char *
purify_type_name(const char * name)5976 purify_type_name (const char *name)
5977 {
5978   int len = strlen (name);
5979   int bracket_found;
5980 
5981   STRING_STRIP_BRACKETS (name, len, bracket_found);
5982   if (bracket_found)
5983     {
5984       char *stripped_name = xmemdup (name, len, len+1);
5985       stripped_name [len] = '\0';
5986       return stripped_name;
5987     }
5988   return name;
5989 }
5990 
5991 /* The type CURRENT refers to can't be found. We print error messages.  */
5992 
5993 static void
complete_class_report_errors(jdep * dep)5994 complete_class_report_errors (jdep *dep)
5995 {
5996   const char *name;
5997 
5998   if (!JDEP_WFL (dep))
5999     return;
6000 
6001   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6002   switch (JDEP_KIND (dep))
6003     {
6004     case JDEP_SUPER:
6005       parse_error_context
6006 	(JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6007 	 purify_type_name (name),
6008 	 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6009       break;
6010     case JDEP_FIELD:
6011       parse_error_context
6012 	(JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6013 	 purify_type_name (name),
6014 	 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6015       break;
6016     case JDEP_METHOD:		/* Covers arguments */
6017       parse_error_context
6018 	(JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6019 	 purify_type_name (name),
6020 	 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6021 	 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6022       break;
6023     case JDEP_METHOD_RETURN:	/* Covers return type */
6024       parse_error_context
6025 	(JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6026 	 purify_type_name (name),
6027 	 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6028       break;
6029     case JDEP_INTERFACE:
6030       parse_error_context
6031 	(JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6032 	 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6033 	 (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6034 	 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6035       break;
6036     case JDEP_VARIABLE:
6037       parse_error_context
6038 	(JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6039 	 purify_type_name (IDENTIFIER_POINTER
6040 			   (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6041 	 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6042       break;
6043     case JDEP_EXCEPTION:	/* As specified by `throws' */
6044       parse_error_context
6045 	  (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6046 	 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6047       break;
6048     default:
6049       /* Fix for -Wall. Just break doing nothing. The error will be
6050          caught later */
6051       break;
6052     }
6053 }
6054 
6055 /* Return a static string containing the DECL prototype string. If
6056    DECL is a constructor, use the class name instead of the form
6057    <init> */
6058 
6059 static const char *
get_printable_method_name(tree decl)6060 get_printable_method_name (tree decl)
6061 {
6062   const char *to_return;
6063   tree name = NULL_TREE;
6064 
6065   if (DECL_CONSTRUCTOR_P (decl))
6066     {
6067       name = DECL_NAME (decl);
6068       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6069     }
6070 
6071   to_return = lang_printable_name (decl, 0);
6072   if (DECL_CONSTRUCTOR_P (decl))
6073     DECL_NAME (decl) = name;
6074 
6075   return to_return;
6076 }
6077 
6078 /* Track method being redefined inside the same class. As a side
6079    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6080    function it's a FWL, so we can track errors more accurately.)  */
6081 
6082 static int
check_method_redefinition(tree class,tree method)6083 check_method_redefinition (tree class, tree method)
6084 {
6085   tree redef, sig;
6086 
6087   /* There's no need to verify <clinit> and finit$ and instinit$ */
6088   if (DECL_CLINIT_P (method)
6089       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6090     return 0;
6091 
6092   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6093   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6094     {
6095       if (redef == method)
6096 	break;
6097       if (DECL_NAME (redef) == DECL_NAME (method)
6098 	  && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6099 	  && !DECL_ARTIFICIAL (method))
6100 	{
6101 	  parse_error_context
6102 	    (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6103 	     (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6104 	     get_printable_method_name (redef));
6105 	  return 1;
6106 	}
6107     }
6108   return 0;
6109 }
6110 
6111 /* Return 1 if check went ok, 0 otherwise.  */
6112 static int
check_abstract_method_definitions(int do_interface,tree class_decl,tree type)6113 check_abstract_method_definitions (int do_interface, tree class_decl,
6114 				   tree type)
6115 {
6116   tree class = TREE_TYPE (class_decl);
6117   tree method, end_type;
6118   int ok = 1;
6119 
6120   end_type = (do_interface ? object_type_node : type);
6121   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6122     {
6123       tree other_super, other_method, method_sig, method_name;
6124       int found = 0;
6125       int end_type_reached = 0;
6126 
6127       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6128 	continue;
6129 
6130       /* Now verify that somewhere in between TYPE and CLASS,
6131 	 abstract method METHOD gets a non abstract definition
6132 	 that is inherited by CLASS.  */
6133 
6134       method_sig = build_java_signature (TREE_TYPE (method));
6135       method_name = DECL_NAME (method);
6136       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6137 	method_name = EXPR_WFL_NODE (method_name);
6138 
6139       other_super = class;
6140       do {
6141 	if (other_super == end_type)
6142 	  end_type_reached = 1;
6143 
6144 	/* Method search */
6145 	for (other_method = TYPE_METHODS (other_super); other_method;
6146             other_method = TREE_CHAIN (other_method))
6147 	  {
6148 	    tree s = build_java_signature (TREE_TYPE (other_method));
6149 	    tree other_name = DECL_NAME (other_method);
6150 
6151 	    if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6152 	      other_name = EXPR_WFL_NODE (other_name);
6153 	    if (!DECL_CLINIT_P (other_method)
6154 		&& !DECL_CONSTRUCTOR_P (other_method)
6155 		&& method_name == other_name
6156 		&& method_sig == s
6157 		&& !METHOD_ABSTRACT (other_method))
6158              {
6159                found = 1;
6160                break;
6161              }
6162 	  }
6163 	other_super = CLASSTYPE_SUPER (other_super);
6164       } while (!end_type_reached);
6165 
6166       /* Report that abstract METHOD didn't find an implementation
6167 	 that CLASS can use. */
6168       if (!found)
6169 	{
6170 	  char *t = xstrdup (lang_printable_name
6171 			    (TREE_TYPE (TREE_TYPE (method)), 0));
6172 	  tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6173 
6174 	  parse_error_context
6175 	    (lookup_cl (class_decl),
6176 	     "Class `%s' doesn't define the abstract method `%s %s' from %s `%s'. This method must be defined or %s `%s' must be declared abstract",
6177 	     IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6178 	     t, lang_printable_name (method, 0),
6179 	     (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6180 	      "interface" : "class"),
6181 	     IDENTIFIER_POINTER (ccn),
6182 	     (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6183 	     IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6184 	  ok = 0;
6185 	  free (t);
6186 	}
6187     }
6188 
6189   if (ok && do_interface)
6190     {
6191       /* Check for implemented interfaces. */
6192       int i;
6193       tree vector = TYPE_BINFO_BASETYPES (type);
6194       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6195 	{
6196 	  tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6197 	  ok = check_abstract_method_definitions (1, class_decl, super);
6198 	}
6199     }
6200 
6201   return ok;
6202 }
6203 
6204 /* Check that CLASS_DECL somehow implements all inherited abstract
6205    methods.  */
6206 
6207 static void
java_check_abstract_method_definitions(tree class_decl)6208 java_check_abstract_method_definitions (tree class_decl)
6209 {
6210   tree class = TREE_TYPE (class_decl);
6211   tree super, vector;
6212   int i;
6213 
6214   if (CLASS_ABSTRACT (class_decl))
6215     return;
6216 
6217   /* Check for inherited types */
6218   super = class;
6219   do {
6220     super = CLASSTYPE_SUPER (super);
6221     check_abstract_method_definitions (0, class_decl, super);
6222   } while (super != object_type_node);
6223 
6224   /* Check for implemented interfaces. */
6225   vector = TYPE_BINFO_BASETYPES (class);
6226   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6227     {
6228       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6229       check_abstract_method_definitions (1, class_decl, super);
6230     }
6231 }
6232 
6233 /* Check all the types method DECL uses and return 1 if all of them
6234    are now complete, 0 otherwise. This is used to check whether its
6235    safe to build a method signature or not.  */
6236 
6237 static int
check_method_types_complete(tree decl)6238 check_method_types_complete (tree decl)
6239 {
6240   tree type = TREE_TYPE (decl);
6241   tree args;
6242 
6243   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6244     return 0;
6245 
6246   args = TYPE_ARG_TYPES (type);
6247   if (TREE_CODE (type) == METHOD_TYPE)
6248     args = TREE_CHAIN (args);
6249   for (; args != end_params_node; args = TREE_CHAIN (args))
6250     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6251       return 0;
6252 
6253   return 1;
6254 }
6255 
6256 /* Visible interface to check methods contained in CLASS_DECL */
6257 
6258 void
java_check_methods(tree class_decl)6259 java_check_methods (tree class_decl)
6260 {
6261   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6262     return;
6263 
6264   if (CLASS_INTERFACE (class_decl))
6265     java_check_abstract_methods (class_decl);
6266   else
6267     java_check_regular_methods (class_decl);
6268 
6269   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6270 }
6271 
6272 /* Like not_accessible_p, but doesn't refer to the current class at
6273    all.  */
6274 static bool
hack_is_accessible_p(tree member,tree from_where)6275 hack_is_accessible_p (tree member, tree from_where)
6276 {
6277   int flags = get_access_flags_from_decl (member);
6278 
6279   if (from_where == DECL_CONTEXT (member)
6280       || (flags & ACC_PUBLIC))
6281     return true;
6282 
6283   if ((flags & ACC_PROTECTED))
6284     {
6285       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6286 	return true;
6287     }
6288 
6289   if ((flags & ACC_PRIVATE))
6290     return false;
6291 
6292   /* Package private, or protected.  */
6293   return in_same_package (TYPE_NAME (from_where),
6294 			  TYPE_NAME (DECL_CONTEXT (member)));
6295 }
6296 
6297 /* Check all the methods of CLASS_DECL. Methods are first completed
6298    then checked according to regular method existence rules.  If no
6299    constructor for CLASS_DECL were encountered, then build its
6300    declaration.  */
6301 static void
java_check_regular_methods(tree class_decl)6302 java_check_regular_methods (tree class_decl)
6303 {
6304   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6305   tree method;
6306   tree class = TREE_TYPE (class_decl);
6307   tree found = NULL_TREE;
6308   tree mthrows;
6309 
6310   /* It is not necessary to check methods defined in java.lang.Object */
6311   if (class == object_type_node)
6312     return;
6313 
6314   if (!TYPE_NVIRTUALS (class))
6315     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6316 
6317   /* Should take interfaces into account. FIXME */
6318   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6319     {
6320       tree sig;
6321       tree method_wfl = DECL_FUNCTION_WFL (method);
6322       int aflags;
6323 
6324       /* Check for redefinitions */
6325       if (check_method_redefinition (class, method))
6326 	continue;
6327 
6328       /* We verify things thrown by the method.  They must inherit from
6329 	 java.lang.Throwable.  */
6330       for (mthrows = DECL_FUNCTION_THROWS (method);
6331 	   mthrows; mthrows = TREE_CHAIN (mthrows))
6332 	{
6333 	  if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6334 	    parse_error_context
6335 	      (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6336 	       IDENTIFIER_POINTER
6337 	         (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6338 	}
6339 
6340       /* If we see one constructor a mark so we don't generate the
6341 	 default one.  Also skip other verifications: constructors
6342 	 can't be inherited hence hidden or overridden.  */
6343       if (DECL_CONSTRUCTOR_P (method))
6344 	{
6345 	  saw_constructor = 1;
6346 	  continue;
6347 	}
6348 
6349       sig = build_java_argument_signature (TREE_TYPE (method));
6350       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6351 					      SEARCH_SUPER | SEARCH_INTERFACE);
6352 
6353       /* Inner class can't declare static methods */
6354       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6355 	{
6356 	  char *t = xstrdup (lang_printable_name (class, 0));
6357 	  parse_error_context
6358 	    (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6359 	     lang_printable_name (method, 0), t);
6360 	  free (t);
6361 	}
6362 
6363       /* Nothing overrides or it's a private method. */
6364       if (!found)
6365 	continue;
6366       if (METHOD_PRIVATE (found))
6367 	{
6368 	  found = NULL_TREE;
6369 	  continue;
6370 	}
6371 
6372       /* If `found' is declared in an interface, make sure the
6373 	 modifier matches. */
6374       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6375 	  && clinit_identifier_node != DECL_NAME (found)
6376 	  && !METHOD_PUBLIC (method))
6377 	{
6378 	  tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6379 	  parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6380 			       IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6381 			       lang_printable_name (method, 0),
6382 			       IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6383 	}
6384 
6385       /* Can't override a method with the same name and different return
6386 	 types. */
6387       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6388 	{
6389 	  char *t = xstrdup
6390 	    (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6391 	  parse_error_context
6392 	    (method_wfl,
6393 	     "Method `%s' was defined with return type `%s' in class `%s'",
6394 	     lang_printable_name (found, 0), t,
6395 	     IDENTIFIER_POINTER
6396 	       (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6397 	  free (t);
6398 	}
6399 
6400       aflags = get_access_flags_from_decl (found);
6401 
6402       /* Can't override final. Can't override static. */
6403       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6404 	{
6405 	  /* Static *can* override static */
6406 	  if (METHOD_STATIC (found) && METHOD_STATIC (method))
6407 	    continue;
6408 	  parse_error_context
6409 	    (method_wfl,
6410 	     "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6411 	     (METHOD_FINAL (found) ? "Final" : "Static"),
6412 	     lang_printable_name (found, 0),
6413 	     (METHOD_FINAL (found) ? "final" : "static"),
6414 	     IDENTIFIER_POINTER
6415 	       (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6416 	  continue;
6417 	}
6418 
6419       /* Static method can't override instance method. */
6420       if (METHOD_STATIC (method))
6421 	{
6422 	  parse_error_context
6423 	    (method_wfl,
6424 	     "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6425 	     lang_printable_name (found, 0),
6426 	     IDENTIFIER_POINTER
6427 	       (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6428 	  continue;
6429 	}
6430 
6431       /* - Overriding/hiding public must be public
6432 	 - Overriding/hiding protected must be protected or public
6433          - If the overridden or hidden method has default (package)
6434            access, then the overriding or hiding method must not be
6435            private; otherwise, a compile-time error occurs.  If
6436            `found' belongs to an interface, things have been already
6437            taken care of.  */
6438       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6439 	  && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6440 	      || (METHOD_PROTECTED (found)
6441 		  && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6442 	      || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6443 		  && METHOD_PRIVATE (method))))
6444 	{
6445 	  parse_error_context
6446 	    (method_wfl,
6447 	     "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6448 	     (METHOD_PUBLIC (method) ? "public" :
6449 	      (METHOD_PRIVATE (method) ? "private" : "protected")),
6450 	     IDENTIFIER_POINTER (DECL_NAME
6451 				 (TYPE_NAME (DECL_CONTEXT (found)))));
6452 	  continue;
6453 	}
6454 
6455       /* Check this method against all the other implementations it
6456 	 overrides.  Here we only check the class hierarchy; the rest
6457 	 of the checking is done later.  If this method is just a
6458 	 Miranda method, we can skip the check.  */
6459       if (! METHOD_INVISIBLE (method))
6460 	check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6461     }
6462 
6463   /* The above throws clause check only looked at superclasses.  Now
6464      we must also make sure that all methods declared in interfaces
6465      have compatible throws clauses.  FIXME: there are more efficient
6466      ways to organize this checking; we should implement one.  */
6467   check_interface_throws_clauses (class, class);
6468 
6469   if (!TYPE_NVIRTUALS (class))
6470     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6471 
6472   /* Search for inherited abstract method not yet implemented in this
6473      class.  */
6474   java_check_abstract_method_definitions (class_decl);
6475 
6476   if (!saw_constructor)
6477     abort ();
6478 }
6479 
6480 /* Check to make sure that all the methods in all the interfaces
6481    implemented by CLASS_DECL are compatible with the concrete
6482    implementations available in CHECK_CLASS_DECL.  */
6483 static void
check_interface_throws_clauses(tree check_class_decl,tree class_decl)6484 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6485 {
6486   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6487     {
6488       tree bases;
6489       int iface_len;
6490       int i;
6491 
6492       if (! CLASS_LOADED_P (class_decl))
6493 	{
6494 	  if (CLASS_FROM_SOURCE_P (class_decl))
6495 	    safe_layout_class (class_decl);
6496 	  else
6497 	    load_class (class_decl, 1);
6498 	}
6499 
6500       bases = TYPE_BINFO_BASETYPES (class_decl);
6501       iface_len = TREE_VEC_LENGTH (bases) - 1;
6502       for (i = iface_len; i > 0; --i)
6503 	{
6504 	  tree interface = BINFO_TYPE (TREE_VEC_ELT (bases, i));
6505 	  tree iface_method;
6506 
6507 	  for (iface_method = TYPE_METHODS (interface);
6508 	       iface_method != NULL_TREE;
6509 	       iface_method = TREE_CHAIN (iface_method))
6510 	    {
6511 	      tree sig, method;
6512 
6513 	      /* First look for a concrete method implemented or
6514 		 inherited by this class.  No need to search
6515 		 interfaces here, since we're already looking through
6516 		 all of them.  */
6517 	      sig = build_java_argument_signature (TREE_TYPE (iface_method));
6518 	      method
6519 		= lookup_argument_method_generic (check_class_decl,
6520 						  DECL_NAME (iface_method),
6521 						  sig, SEARCH_VISIBLE);
6522 	      /* If we don't find an implementation, that is ok.  Any
6523 		 potential errors from that are diagnosed elsewhere.
6524 		 Also, multiple inheritance with conflicting throws
6525 		 clauses is fine in the absence of a concrete
6526 		 implementation.  */
6527 	      if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6528 		  && !METHOD_INVISIBLE (iface_method))
6529 		{
6530 		  tree method_wfl = DECL_FUNCTION_WFL (method);
6531 		  check_throws_clauses (method, method_wfl, iface_method);
6532 		}
6533 	    }
6534 
6535 	  /* Now check superinterfaces.  */
6536 	  check_interface_throws_clauses (check_class_decl, interface);
6537 	}
6538     }
6539 }
6540 
6541 /* Check throws clauses of a method against the clauses of all the
6542    methods it overrides.  We do this by searching up the class
6543    hierarchy, examining all matching accessible methods.  */
6544 static void
check_concrete_throws_clauses(tree class,tree self_method,tree name,tree signature)6545 check_concrete_throws_clauses (tree class, tree self_method,
6546 			       tree name, tree signature)
6547 {
6548   tree method = lookup_argument_method_generic (class, name, signature,
6549 						SEARCH_SUPER | SEARCH_VISIBLE);
6550   while (method != NULL_TREE)
6551     {
6552       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6553 	check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6554 			      method);
6555 
6556       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6557 					       name, signature,
6558 					       SEARCH_SUPER | SEARCH_VISIBLE);
6559     }
6560 }
6561 
6562 /* Generate an error if the `throws' clause of METHOD (if any) is
6563    incompatible with the `throws' clause of FOUND (if any).  */
6564 static void
check_throws_clauses(tree method,tree method_wfl,tree found)6565 check_throws_clauses (tree method, tree method_wfl, tree found)
6566 {
6567   tree mthrows;
6568 
6569   /* Can't check these things with class loaded from bytecode. FIXME */
6570   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6571     return;
6572 
6573   for (mthrows = DECL_FUNCTION_THROWS (method);
6574        mthrows; mthrows = TREE_CHAIN (mthrows))
6575     {
6576       tree fthrows;
6577 
6578       /* We don't verify unchecked expressions */
6579       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6580 	continue;
6581       /* Checked expression must be compatible */
6582       for (fthrows = DECL_FUNCTION_THROWS (found);
6583 	   fthrows; fthrows = TREE_CHAIN (fthrows))
6584 	{
6585 	  if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6586 	    break;
6587 	}
6588       if (!fthrows)
6589 	{
6590 	  parse_error_context
6591 	    (method_wfl, "Invalid checked exception class `%s' in `throws' clause.  The exception must be a subclass of an exception thrown by `%s' from class `%s'",
6592 	     IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6593 	     lang_printable_name (found, 0),
6594 	     IDENTIFIER_POINTER
6595 	     (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6596 	}
6597     }
6598 }
6599 
6600 /* Check abstract method of interface INTERFACE */
6601 static void
java_check_abstract_methods(tree interface_decl)6602 java_check_abstract_methods (tree interface_decl)
6603 {
6604   int i, n;
6605   tree method, basetype_vec, found;
6606   tree interface = TREE_TYPE (interface_decl);
6607 
6608   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6609     {
6610       /* 2- Check for double definition inside the defining interface */
6611       if (check_method_redefinition (interface, method))
6612 	continue;
6613 
6614       /* 3- Overriding is OK as far as we preserve the return type.  */
6615       found = lookup_java_interface_method2 (interface, method);
6616       if (found)
6617 	{
6618 	  char *t;
6619 	  t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6620 	  parse_error_context
6621 	    (DECL_FUNCTION_WFL (found),
6622 	     "Method `%s' was defined with return type `%s' in class `%s'",
6623 	     lang_printable_name (found, 0), t,
6624 	     IDENTIFIER_POINTER
6625 	       (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6626 	  free (t);
6627 	  continue;
6628 	}
6629     }
6630 
6631   /* 4- Inherited methods can't differ by their returned types */
6632   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6633     return;
6634   n = TREE_VEC_LENGTH (basetype_vec);
6635   for (i = 0; i < n; i++)
6636     {
6637       tree sub_interface_method, sub_interface;
6638       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6639       if (!vec_elt)
6640 	continue;
6641       sub_interface = BINFO_TYPE (vec_elt);
6642       for (sub_interface_method = TYPE_METHODS (sub_interface);
6643 	   sub_interface_method;
6644 	   sub_interface_method = TREE_CHAIN (sub_interface_method))
6645 	{
6646 	  found = lookup_java_interface_method2 (interface,
6647 						 sub_interface_method);
6648 	  if (found && (found != sub_interface_method))
6649 	    {
6650 	      parse_error_context
6651 		(lookup_cl (sub_interface_method),
6652 		 "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6653 		 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6654 		 lang_printable_name (found, 0),
6655 		 IDENTIFIER_POINTER
6656 		   (DECL_NAME (TYPE_NAME
6657 			       (DECL_CONTEXT (sub_interface_method)))),
6658 		 IDENTIFIER_POINTER
6659 	           (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6660 	    }
6661 	}
6662     }
6663 }
6664 
6665 /* Lookup methods in interfaces using their name and partial
6666    signature. Return a matching method only if their types differ.  */
6667 
6668 static tree
lookup_java_interface_method2(tree class,tree method_decl)6669 lookup_java_interface_method2 (tree class, tree method_decl)
6670 {
6671   int i, n;
6672   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6673 
6674   if (!basetype_vec)
6675     return NULL_TREE;
6676 
6677   n = TREE_VEC_LENGTH (basetype_vec);
6678   for (i = 0; i < n; i++)
6679     {
6680       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6681       if ((BINFO_TYPE (vec_elt) != object_type_node)
6682 	  && (to_return =
6683 	      lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6684 	return to_return;
6685     }
6686   for (i = 0; i < n; i++)
6687     {
6688       to_return = lookup_java_interface_method2
6689 	(BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6690       if (to_return)
6691 	return to_return;
6692     }
6693 
6694   return NULL_TREE;
6695 }
6696 
6697 /* Lookup method using their name and partial signature. Return a
6698    matching method only if their types differ.  */
6699 
6700 static tree
lookup_java_method2(tree clas,tree method_decl,int do_interface)6701 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6702 {
6703   tree method, method_signature, method_name, method_type, name;
6704 
6705   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6706   name = DECL_NAME (method_decl);
6707   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6708 		 EXPR_WFL_NODE (name) : name);
6709   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6710 
6711   while (clas != NULL_TREE)
6712     {
6713       for (method = TYPE_METHODS (clas);
6714 	   method != NULL_TREE;  method = TREE_CHAIN (method))
6715 	{
6716 	  tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6717 	  tree name = DECL_NAME (method);
6718 	  if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6719 	       EXPR_WFL_NODE (name) : name) == method_name
6720 	      && method_sig == method_signature
6721 	      && TREE_TYPE (TREE_TYPE (method)) != method_type)
6722 	    return method;
6723 	}
6724       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6725     }
6726   return NULL_TREE;
6727 }
6728 
6729 /* Return the line that matches DECL line number, and try its best to
6730    position the column number. Used during error reports.  */
6731 
6732 static GTY(()) tree cl_v;
6733 static tree
lookup_cl(tree decl)6734 lookup_cl (tree decl)
6735 {
6736   char *line, *found;
6737 
6738   if (!decl)
6739     return NULL_TREE;
6740 
6741   if (cl_v == NULL_TREE)
6742     {
6743       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6744     }
6745 
6746   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6747   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6748 
6749   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6750 			    EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6751 
6752   found = strstr ((const char *)line,
6753 		  (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6754   if (found)
6755     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6756 
6757   return cl_v;
6758 }
6759 
6760 /* Look for a simple name in the single-type import list */
6761 
6762 static tree
find_name_in_single_imports(tree name)6763 find_name_in_single_imports (tree name)
6764 {
6765   tree node;
6766 
6767   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6768     if (TREE_VALUE (node) == name)
6769       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6770 
6771   return NULL_TREE;
6772 }
6773 
6774 /* Process all single-type import. */
6775 
6776 static int
process_imports(void)6777 process_imports (void)
6778 {
6779   tree import;
6780   int error_found;
6781 
6782   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6783     {
6784       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6785       char *original_name;
6786 
6787       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6788 			       IDENTIFIER_LENGTH (to_be_found),
6789 			       IDENTIFIER_LENGTH (to_be_found) + 1);
6790 
6791       /* Don't load twice something already defined. */
6792       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6793 	continue;
6794 
6795       while (1)
6796 	{
6797 	  tree left;
6798 
6799 	  QUALIFIED_P (to_be_found) = 1;
6800 	  load_class (to_be_found, 0);
6801 	  error_found =
6802 	    check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
6803 
6804 	  /* We found it, we can bail out */
6805 	  if (IDENTIFIER_CLASS_VALUE (to_be_found))
6806 	    {
6807 	      check_deprecation (TREE_PURPOSE (import),
6808 				 IDENTIFIER_CLASS_VALUE (to_be_found));
6809 	      break;
6810 	    }
6811 
6812 	  /* We haven't found it. Maybe we're trying to access an
6813 	     inner class.  The only way for us to know is to try again
6814 	     after having dropped a qualifier. If we can't break it further,
6815 	     we have an error. */
6816 	  if (breakdown_qualified (&left, NULL, to_be_found))
6817 	    break;
6818 
6819 	  to_be_found = left;
6820 	}
6821       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6822 	{
6823 	  parse_error_context (TREE_PURPOSE (import),
6824 			       "Class or interface `%s' not found in import",
6825 			       original_name);
6826 	  error_found = 1;
6827 	}
6828 
6829       free (original_name);
6830       if (error_found)
6831 	return 1;
6832     }
6833   return 0;
6834 }
6835 
6836 /* Possibly find and mark a class imported by a single-type import
6837    statement.  */
6838 
6839 static void
find_in_imports(tree enclosing_type,tree class_type)6840 find_in_imports (tree enclosing_type, tree class_type)
6841 {
6842   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6843 		 ctxp->import_list);
6844   while (import)
6845     {
6846       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6847 	{
6848 	  TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6849 	  QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6850 	  return;
6851 	}
6852       import = TREE_CHAIN (import);
6853     }
6854 }
6855 
6856 static int
note_possible_classname(const char * name,int len)6857 note_possible_classname (const char *name, int len)
6858 {
6859   tree node;
6860   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6861     len = len - 5;
6862   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6863     len = len - 6;
6864   else
6865     return 0;
6866   node = ident_subst (name, len, "", '/', '.', "");
6867   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6868   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6869   return 1;
6870 }
6871 
6872 /* Read a import directory, gathering potential match for further type
6873    references. Indifferently reads a filesystem or a ZIP archive
6874    directory.  */
6875 
6876 static void
read_import_dir(tree wfl)6877 read_import_dir (tree wfl)
6878 {
6879   tree package_id = EXPR_WFL_NODE (wfl);
6880   const char *package_name = IDENTIFIER_POINTER (package_id);
6881   int package_length = IDENTIFIER_LENGTH (package_id);
6882   DIR *dirp = NULL;
6883   JCF *saved_jcf = current_jcf;
6884 
6885   int found = 0;
6886   int k;
6887   void *entry;
6888   struct buffer filename[1];
6889 
6890   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6891     return;
6892   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6893 
6894   BUFFER_INIT (filename);
6895   buffer_grow (filename, package_length + 100);
6896 
6897   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6898     {
6899       const char *entry_name = jcf_path_name (entry);
6900       int entry_length = strlen (entry_name);
6901       if (jcf_path_is_zipfile (entry))
6902 	{
6903 	  ZipFile *zipf;
6904 	  buffer_grow (filename, entry_length);
6905 	  memcpy (filename->data, entry_name, entry_length - 1);
6906 	  filename->data[entry_length-1] = '\0';
6907 	  zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6908 	  if (zipf == NULL)
6909 	    error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6910 	  else
6911 	    {
6912 	      ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6913 	      BUFFER_RESET (filename);
6914 	      for (k = 0; k < package_length; k++)
6915 		{
6916 		  char ch = package_name[k];
6917 		  *filename->ptr++ = ch == '.' ? '/' : ch;
6918 		}
6919 	      *filename->ptr++ = '/';
6920 
6921 	      for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6922 		{
6923 		  const char *current_entry = ZIPDIR_FILENAME (zipd);
6924 		  int current_entry_len = zipd->filename_length;
6925 
6926 		  if (current_entry_len >= BUFFER_LENGTH (filename)
6927 		      && strncmp (filename->data, current_entry,
6928 				  BUFFER_LENGTH (filename)) != 0)
6929 		    continue;
6930 		  found |= note_possible_classname (current_entry,
6931 						    current_entry_len);
6932 		}
6933 	    }
6934 	}
6935       else
6936 	{
6937 	  BUFFER_RESET (filename);
6938 	  buffer_grow (filename, entry_length + package_length + 4);
6939 	  strcpy (filename->data, entry_name);
6940 	  filename->ptr = filename->data + entry_length;
6941 	  for (k = 0; k < package_length; k++)
6942 	    {
6943 	      char ch = package_name[k];
6944 	      *filename->ptr++ = ch == '.' ? '/' : ch;
6945 	    }
6946 	  *filename->ptr = '\0';
6947 
6948 	  dirp = opendir (filename->data);
6949 	  if (dirp == NULL)
6950 	    continue;
6951 	  *filename->ptr++ = '/';
6952 	  for (;;)
6953 	    {
6954 	      int len;
6955 	      const char *d_name;
6956 	      struct dirent *direntp = readdir (dirp);
6957 	      if (!direntp)
6958 		break;
6959 	      d_name = direntp->d_name;
6960 	      len = strlen (direntp->d_name);
6961 	      buffer_grow (filename, len+1);
6962 	      strcpy (filename->ptr, d_name);
6963 	      found |= note_possible_classname (filename->data + entry_length,
6964 						package_length+len+1);
6965 	    }
6966 	  if (dirp)
6967 	    closedir (dirp);
6968 	}
6969     }
6970 
6971   free (filename->data);
6972 
6973   /* Here we should have a unified way of retrieving an entry, to be
6974      indexed. */
6975   if (!found)
6976     {
6977       static int first = 1;
6978       if (first)
6979 	{
6980 	  error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6981 	  java_error_count++;
6982 	  first = 0;
6983 	}
6984       else
6985 	parse_error_context (wfl, "Package `%s' not found in import",
6986 			     package_name);
6987       current_jcf = saved_jcf;
6988       return;
6989     }
6990   current_jcf = saved_jcf;
6991 }
6992 
6993 /* Possibly find a type in the import on demands specified
6994    types. Returns 1 if an error occurred, 0 otherwise. Run through the
6995    entire list, to detected potential double definitions.  */
6996 
6997 static int
find_in_imports_on_demand(tree enclosing_type,tree class_type)6998 find_in_imports_on_demand (tree enclosing_type, tree class_type)
6999 {
7000   tree class_type_name = TYPE_NAME (class_type);
7001   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7002 		  ctxp->import_demand_list);
7003   tree cl = NULL_TREE;
7004   int seen_once = -1;	/* -1 when not set, 1 if seen once, >1 otherwise. */
7005   int to_return = -1;	/* -1 when not set, 0 or 1 otherwise */
7006   tree node;
7007 
7008   for (; import; import = TREE_CHAIN (import))
7009     {
7010       int saved_lineno = input_line;
7011       int access_check;
7012       const char *id_name;
7013       tree decl, type_name_copy;
7014 
7015       obstack_grow (&temporary_obstack,
7016 		    IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7017 		    IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7018       obstack_1grow (&temporary_obstack, '.');
7019       obstack_grow0 (&temporary_obstack,
7020 		     IDENTIFIER_POINTER (class_type_name),
7021 		     IDENTIFIER_LENGTH (class_type_name));
7022       id_name = obstack_finish (&temporary_obstack);
7023 
7024       if (! (node = maybe_get_identifier (id_name)))
7025 	continue;
7026 
7027       /* Setup lineno so that it refers to the line of the import (in
7028 	 case we parse a class file and encounter errors */
7029       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7030 
7031       type_name_copy = TYPE_NAME (class_type);
7032       TYPE_NAME (class_type) = node;
7033       QUALIFIED_P (node) = 1;
7034       decl = IDENTIFIER_CLASS_VALUE (node);
7035       access_check = -1;
7036       /* If there is no DECL set for the class or if the class isn't
7037 	 loaded and not seen in source yet, then load */
7038       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
7039 		    && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
7040 	{
7041 	  load_class (node, 0);
7042 	  decl = IDENTIFIER_CLASS_VALUE (node);
7043 	}
7044       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7045 	access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7046 					       false);
7047       else
7048 	/* 6.6.1: Inner classes are subject to member access rules. */
7049 	access_check = 0;
7050 
7051       input_line = saved_lineno;
7052 
7053       /* If the loaded class is not accessible or couldn't be loaded,
7054 	 we restore the original TYPE_NAME and process the next
7055 	 import. */
7056       if (access_check || !decl)
7057 	{
7058 	  TYPE_NAME (class_type) = type_name_copy;
7059 	  continue;
7060 	}
7061 
7062       /* If the loaded class is accessible, we keep a tab on it to
7063 	 detect and report multiple inclusions. */
7064       if (IS_A_CLASSFILE_NAME (node))
7065 	{
7066 	  if (seen_once < 0)
7067 	    {
7068 	      cl = TREE_PURPOSE (import);
7069 	      seen_once = 1;
7070 	    }
7071 	  else if (seen_once >= 0)
7072 	    {
7073 	      tree location = (cl ? cl : TREE_PURPOSE (import));
7074 	      tree package = (cl ? EXPR_WFL_NODE (cl) :
7075 			      EXPR_WFL_NODE (TREE_PURPOSE (import)));
7076 	      seen_once++;
7077 	      parse_error_context
7078 		(location,
7079 		 "Type `%s' also potentially defined in package `%s'",
7080 		 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7081 		 IDENTIFIER_POINTER (package));
7082 	    }
7083 	}
7084       to_return = access_check;
7085     }
7086 
7087   if (seen_once == 1)
7088     return to_return;
7089   else
7090     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7091 }
7092 
7093 /* Add package NAME to the list of packages encountered so far. To
7094    speed up class lookup in do_resolve_class, we make sure a
7095    particular package is added only once.  */
7096 
7097 static void
register_package(tree name)7098 register_package (tree name)
7099 {
7100   static htab_t pht;
7101   void **e;
7102 
7103   if (pht == NULL)
7104     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7105 
7106   e = htab_find_slot (pht, name, INSERT);
7107   if (*e == NULL)
7108     {
7109       package_list = chainon (package_list, build_tree_list (name, NULL));
7110       *e = name;
7111     }
7112 }
7113 
7114 static tree
resolve_package(tree pkg,tree * next,tree * type_name)7115 resolve_package (tree pkg, tree *next, tree *type_name)
7116 {
7117   tree current;
7118   tree decl = NULL_TREE;
7119   *type_name = NULL_TREE;
7120 
7121   /* The trick is to determine when the package name stops and were
7122      the name of something contained in the package starts. Then we
7123      return a fully qualified name of what we want to get. */
7124 
7125   *next = EXPR_WFL_QUALIFICATION (pkg);
7126 
7127   /* Try to progressively construct a type name */
7128   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7129     for (current = EXPR_WFL_QUALIFICATION (pkg);
7130 	 current; current = TREE_CHAIN (current))
7131       {
7132 	/* If we don't have what we're expecting, exit now. TYPE_NAME
7133 	   will be null and the error caught later. */
7134 	if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7135 	  break;
7136 	*type_name =
7137 	  merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7138 	if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7139 	  {
7140 	    /* resolve_package should be used in a loop, hence we
7141 	       point at this one to naturally process the next one at
7142 	       the next iteration. */
7143 	    *next = current;
7144 	    break;
7145 	  }
7146       }
7147   return decl;
7148 }
7149 
7150 
7151 /* Check accessibility of inner classes according to member access rules.
7152    DECL is the inner class, ENCLOSING_DECL is the class from which the
7153    access is being attempted. */
7154 
7155 static void
check_inner_class_access(tree decl,tree enclosing_decl,tree cl)7156 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7157 {
7158   const char *access;
7159   tree enclosing_decl_type;
7160 
7161   /* We don't issue an error message when CL is null. CL can be null
7162      as a result of processing a JDEP crafted by source_start_java_method
7163      for the purpose of patching its parm decl. But the error would
7164      have been already trapped when fixing the method's signature.
7165      DECL can also be NULL in case of earlier errors. */
7166   if (!decl || !cl)
7167     return;
7168 
7169   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7170 
7171   if (CLASS_PRIVATE (decl))
7172     {
7173       /* Access is permitted only within the body of the top-level
7174          class in which DECL is declared. */
7175       tree top_level = decl;
7176       while (DECL_CONTEXT (top_level))
7177         top_level = DECL_CONTEXT (top_level);
7178       while (DECL_CONTEXT (enclosing_decl))
7179         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7180       if (top_level == enclosing_decl)
7181         return;
7182       access = "private";
7183     }
7184   else if (CLASS_PROTECTED (decl))
7185     {
7186       tree decl_context;
7187       /* Access is permitted from within the same package... */
7188       if (in_same_package (decl, enclosing_decl))
7189         return;
7190 
7191       /* ... or from within the body of a subtype of the context in which
7192          DECL is declared. */
7193       decl_context = DECL_CONTEXT (decl);
7194       while (enclosing_decl)
7195         {
7196 	  if (CLASS_INTERFACE (decl))
7197 	    {
7198 	      if (interface_of_p (TREE_TYPE (decl_context),
7199 				  enclosing_decl_type))
7200 		return;
7201 	    }
7202 	  else
7203 	    {
7204 	      /* Eww. The order of the arguments is different!! */
7205 	      if (inherits_from_p (enclosing_decl_type,
7206 				   TREE_TYPE (decl_context)))
7207 		return;
7208 	    }
7209 	  enclosing_decl = DECL_CONTEXT (enclosing_decl);
7210 	}
7211       access = "protected";
7212     }
7213   else if (! CLASS_PUBLIC (decl))
7214     {
7215       /* Access is permitted only from within the same package as DECL. */
7216       if (in_same_package (decl, enclosing_decl))
7217         return;
7218       access = "non-public";
7219     }
7220   else
7221     /* Class is public. */
7222     return;
7223 
7224   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7225 		       (CLASS_INTERFACE (decl) ? "interface" : "class"),
7226 		       lang_printable_name (decl, 0), access);
7227 }
7228 
7229 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7230    foreign package, it must be PUBLIC. Return 0 if no access
7231    violations were found, 1 otherwise. If VERBOSE is true and an error
7232    was found, it is reported and accounted for.  */
7233 
7234 static int
check_pkg_class_access(tree class_name,tree cl,bool verbose)7235 check_pkg_class_access (tree class_name, tree cl, bool verbose)
7236 {
7237   tree type;
7238 
7239   if (!IDENTIFIER_CLASS_VALUE (class_name))
7240     return 0;
7241 
7242   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7243     return 0;
7244 
7245   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7246     {
7247       /* Access to a private class within the same package is
7248          allowed. */
7249       tree l, r;
7250       breakdown_qualified (&l, &r, class_name);
7251       if (!QUALIFIED_P (class_name) && !ctxp->package)
7252 	/* Both in the empty package. */
7253         return 0;
7254       if (l == ctxp->package)
7255 	/* Both in the same package. */
7256 	return 0;
7257 
7258       if (verbose)
7259 	parse_error_context
7260 	  (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7261 	   (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7262 	   IDENTIFIER_POINTER (class_name));
7263       return 1;
7264     }
7265   return 0;
7266 }
7267 
7268 /* Local variable declaration. */
7269 
7270 static void
declare_local_variables(int modifier,tree type,tree vlist)7271 declare_local_variables (int modifier, tree type, tree vlist)
7272 {
7273   tree decl, current, saved_type;
7274   tree type_wfl = NULL_TREE;
7275   int must_chain = 0;
7276   int final_p = 0;
7277 
7278   /* Push a new block if statements were seen between the last time we
7279      pushed a block and now. Keep a count of blocks to close */
7280   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7281     {
7282       tree b = enter_block ();
7283       BLOCK_IS_IMPLICIT (b) = 1;
7284     }
7285 
7286   if (modifier)
7287     {
7288       size_t i;
7289       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7290 	if (1 << i & modifier)
7291 	  break;
7292       if (modifier == ACC_FINAL)
7293 	final_p = 1;
7294       else
7295 	{
7296 	  parse_error_context
7297 	    (ctxp->modifier_ctx [i],
7298 	     "Only `final' is allowed as a local variables modifier");
7299 	  return;
7300 	}
7301     }
7302 
7303   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7304      hold the TYPE value if a new incomplete has to be created (as
7305      opposed to being found already existing and reused). */
7306   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7307 
7308   /* If TYPE is fully resolved and we don't have a reference, make one */
7309   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7310 
7311   /* Go through all the declared variables */
7312   for (current = vlist, saved_type = type; current;
7313        current = TREE_CHAIN (current), type = saved_type)
7314     {
7315       tree other, real_type;
7316       tree wfl  = TREE_PURPOSE (current);
7317       tree name = EXPR_WFL_NODE (wfl);
7318       tree init = TREE_VALUE (current);
7319 
7320       /* Process NAME, as it may specify extra dimension(s) for it */
7321       type = build_array_from_name (type, type_wfl, name, &name);
7322 
7323       /* Variable redefinition check */
7324       if ((other = lookup_name_in_blocks (name)))
7325 	{
7326 	  variable_redefinition_error (wfl, name, TREE_TYPE (other),
7327 				       DECL_SOURCE_LINE (other));
7328 	  continue;
7329 	}
7330 
7331       /* Type adjustment. We may have just readjusted TYPE because
7332 	 the variable specified more dimensions. Make sure we have
7333 	 a reference if we can and don't have one already. */
7334       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7335 
7336       real_type = GET_REAL_TYPE (type);
7337       /* Never layout this decl. This will be done when its scope
7338 	 will be entered */
7339       decl = build_decl (VAR_DECL, name, real_type);
7340       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7341       DECL_FINAL (decl) = final_p;
7342       BLOCK_CHAIN_DECL (decl);
7343 
7344       /* If doing xreferencing, replace the line number with the WFL
7345          compound value */
7346       if (flag_emit_xref)
7347 	DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7348 
7349       /* Don't try to use an INIT statement when an error was found */
7350       if (init && java_error_count)
7351 	init = NULL_TREE;
7352 
7353       /* Add the initialization function to the current function's code */
7354       if (init)
7355 	{
7356 	  /* Name might have been readjusted */
7357 	  EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7358 	  MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7359 	  java_method_add_stmt (current_function_decl,
7360 				build_debugable_stmt (EXPR_WFL_LINECOL (init),
7361 						      init));
7362 	}
7363 
7364       /* Setup dependency the type of the decl */
7365       if (must_chain)
7366 	{
7367 	  jdep *dep;
7368 	  register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7369 	  dep = CLASSD_LAST (ctxp->classd_list);
7370 	  JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7371 	}
7372     }
7373   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7374 }
7375 
7376 /* Called during parsing. Build decls from argument list.  */
7377 
7378 static void
source_start_java_method(tree fndecl)7379 source_start_java_method (tree fndecl)
7380 {
7381   tree tem;
7382   tree parm_decl;
7383   int i;
7384 
7385   if (!fndecl)
7386     return;
7387 
7388   current_function_decl = fndecl;
7389 
7390   /* New scope for the function */
7391   enter_block ();
7392   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7393        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7394     {
7395       tree type = TREE_VALUE (tem);
7396       tree name = TREE_PURPOSE (tem);
7397 
7398       /* If type is incomplete. Create an incomplete decl and ask for
7399 	 the decl to be patched later */
7400       if (INCOMPLETE_TYPE_P (type))
7401 	{
7402 	  jdep *jdep;
7403 	  tree real_type = GET_REAL_TYPE (type);
7404 	  parm_decl = build_decl (PARM_DECL, name, real_type);
7405 	  type = obtain_incomplete_type (type);
7406 	  register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7407 	  jdep = CLASSD_LAST (ctxp->classd_list);
7408 	  JDEP_MISC (jdep) = name;
7409 	  JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7410 	}
7411       else
7412 	parm_decl = build_decl (PARM_DECL, name, type);
7413 
7414       /* Remember if a local variable was declared final (via its
7415          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7416       if (ARG_FINAL_P (tem))
7417 	{
7418 	  MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7419 	  DECL_FINAL (parm_decl) = 1;
7420 	}
7421 
7422       BLOCK_CHAIN_DECL (parm_decl);
7423     }
7424   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7425   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7426     nreverse (tem);
7427   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7428   DECL_MAX_LOCALS (current_function_decl) = i;
7429 }
7430 
7431 /* Called during parsing. Creates an artificial method declaration.  */
7432 
7433 static tree
create_artificial_method(tree class,int flags,tree type,tree name,tree args)7434 create_artificial_method (tree class, int flags, tree type,
7435 			  tree name, tree args)
7436 {
7437   tree mdecl;
7438 
7439   java_parser_context_save_global ();
7440   input_line = 0;
7441   mdecl = make_node (FUNCTION_TYPE);
7442   TREE_TYPE (mdecl) = type;
7443   TYPE_ARG_TYPES (mdecl) = args;
7444   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7445   java_parser_context_restore_global ();
7446   DECL_ARTIFICIAL (mdecl) = 1;
7447   return mdecl;
7448 }
7449 
7450 /* Starts the body if an artificial method.  */
7451 
7452 static void
start_artificial_method_body(tree mdecl)7453 start_artificial_method_body (tree mdecl)
7454 {
7455   DECL_SOURCE_LINE (mdecl) = 1;
7456   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7457   source_start_java_method (mdecl);
7458   enter_block ();
7459 }
7460 
7461 static void
end_artificial_method_body(tree mdecl)7462 end_artificial_method_body (tree mdecl)
7463 {
7464   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7465      It has to be evaluated first. (if mdecl is current_function_decl,
7466      we have an undefined behavior if no temporary variable is used.) */
7467   tree b = exit_block ();
7468   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7469   exit_block ();
7470 }
7471 
7472 /* Dump a tree of some kind.  This is a convenience wrapper for the
7473    dump_* functions in tree-dump.c.  */
7474 static void
dump_java_tree(enum tree_dump_index phase,tree t)7475 dump_java_tree (enum tree_dump_index phase, tree t)
7476 {
7477   FILE *stream;
7478   int flags;
7479 
7480   stream = dump_begin (phase, &flags);
7481   flags |= TDF_SLIM;
7482   if (stream)
7483     {
7484       dump_node (t, flags, stream);
7485       dump_end (phase, stream);
7486     }
7487 }
7488 
7489 /* Terminate a function and expand its body.  */
7490 
7491 static void
source_end_java_method(void)7492 source_end_java_method (void)
7493 {
7494   tree fndecl = current_function_decl;
7495 
7496   if (!fndecl)
7497     return;
7498 
7499   java_parser_context_save_global ();
7500   input_line = ctxp->last_ccb_indent1;
7501 
7502   /* Turn function bodies with only a NOP expr null, so they don't get
7503      generated at all and we won't get warnings when using the -W
7504      -Wall flags. */
7505   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7506     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7507 
7508   /* We've generated all the trees for this function, and it has been
7509      patched.  Dump it to a file if the user requested it.  */
7510   dump_java_tree (TDI_original, fndecl);
7511 
7512   /* Defer expanding the method until cgraph analysis is complete.  */
7513   if (DECL_SAVED_TREE (fndecl))
7514     cgraph_finalize_function (fndecl, false);
7515 
7516   current_function_decl = NULL_TREE;
7517   java_parser_context_restore_global ();
7518 }
7519 
7520 /* Record EXPR in the current function block. Complements compound
7521    expression second operand if necessary.  */
7522 
7523 tree
java_method_add_stmt(tree fndecl,tree expr)7524 java_method_add_stmt (tree fndecl, tree expr)
7525 {
7526   if (!GET_CURRENT_BLOCK (fndecl))
7527     return NULL_TREE;
7528   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7529 }
7530 
7531 static tree
add_stmt_to_block(tree b,tree type,tree stmt)7532 add_stmt_to_block (tree b, tree type, tree stmt)
7533 {
7534   tree body = BLOCK_EXPR_BODY (b), c;
7535 
7536   if (java_error_count)
7537     return body;
7538 
7539   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7540     return body;
7541 
7542   BLOCK_EXPR_BODY (b) = c;
7543   TREE_SIDE_EFFECTS (c) = 1;
7544   return c;
7545 }
7546 
7547 /* Add STMT to EXISTING if possible, otherwise create a new
7548    COMPOUND_EXPR and add STMT to it. */
7549 
7550 static tree
add_stmt_to_compound(tree existing,tree type,tree stmt)7551 add_stmt_to_compound (tree existing, tree type, tree stmt)
7552 {
7553   if (existing)
7554     return build (COMPOUND_EXPR, type, existing, stmt);
7555   else
7556     return stmt;
7557 }
7558 
java_layout_seen_class_methods(void)7559 void java_layout_seen_class_methods (void)
7560 {
7561   tree previous_list = all_class_list;
7562   tree end = NULL_TREE;
7563   tree current;
7564 
7565   while (1)
7566     {
7567       for (current = previous_list;
7568 	   current != end; current = TREE_CHAIN (current))
7569 	layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7570 
7571       if (previous_list != all_class_list)
7572 	{
7573 	  end = previous_list;
7574 	  previous_list = all_class_list;
7575 	}
7576       else
7577 	break;
7578     }
7579 }
7580 
7581 static GTY(()) tree stop_reordering;
7582 void
java_reorder_fields(void)7583 java_reorder_fields (void)
7584 {
7585   tree current;
7586 
7587   for (current = gclass_list; current; current = TREE_CHAIN (current))
7588     {
7589       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7590 
7591       if (current_class == stop_reordering)
7592 	break;
7593 
7594       /* Reverse the fields, but leave the dummy field in front.
7595 	 Fields are already ordered for Object and Class */
7596       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7597 	  && current_class != class_type_node)
7598       {
7599 	/* If the dummy field is there, reverse the right fields and
7600 	   just layout the type for proper fields offset */
7601 	if (!DECL_NAME (TYPE_FIELDS (current_class)))
7602 	  {
7603 	    tree fields = TYPE_FIELDS (current_class);
7604 	    TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7605 	    TYPE_SIZE (current_class) = NULL_TREE;
7606 	  }
7607 	/* We don't have a dummy field, we need to layout the class,
7608            after having reversed the fields */
7609 	else
7610 	  {
7611 	    TYPE_FIELDS (current_class) =
7612 	      nreverse (TYPE_FIELDS (current_class));
7613 	    TYPE_SIZE (current_class) = NULL_TREE;
7614 	  }
7615       }
7616     }
7617   /* There are cases were gclass_list will be empty. */
7618   if (gclass_list)
7619     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7620 }
7621 
7622 /* Layout the methods of all classes loaded in one way or another.
7623    Check methods of source parsed classes. Then reorder the
7624    fields and layout the classes or the type of all source parsed
7625    classes */
7626 
7627 void
java_layout_classes(void)7628 java_layout_classes (void)
7629 {
7630   tree current;
7631   int save_error_count = java_error_count;
7632 
7633   /* Layout the methods of all classes seen so far */
7634   java_layout_seen_class_methods ();
7635   java_parse_abort_on_error ();
7636   all_class_list = NULL_TREE;
7637 
7638   /* Then check the methods of all parsed classes */
7639   for (current = gclass_list; current; current = TREE_CHAIN (current))
7640     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7641       java_check_methods (TREE_VALUE (current));
7642   java_parse_abort_on_error ();
7643 
7644   for (current = gclass_list; current; current = TREE_CHAIN (current))
7645     {
7646       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7647       layout_class (current_class);
7648 
7649       /* Error reported by the caller */
7650       if (java_error_count)
7651 	return;
7652     }
7653 
7654   /* We might have reloaded classes durign the process of laying out
7655      classes for code generation. We must layout the methods of those
7656      late additions, as constructor checks might use them */
7657   java_layout_seen_class_methods ();
7658   java_parse_abort_on_error ();
7659 }
7660 
7661 /* Expand methods in the current set of classes remembered for
7662    generation.  */
7663 
7664 static void
java_complete_expand_classes(void)7665 java_complete_expand_classes (void)
7666 {
7667   tree current;
7668 
7669   do_not_fold = flag_emit_xref;
7670 
7671   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7672     if (!INNER_CLASS_DECL_P (current))
7673       java_complete_expand_class (current);
7674 }
7675 
7676 /* Expand the methods found in OUTER, starting first by OUTER's inner
7677    classes, if any.  */
7678 
7679 static void
java_complete_expand_class(tree outer)7680 java_complete_expand_class (tree outer)
7681 {
7682   tree inner_list;
7683 
7684   set_nested_class_simple_name_value (outer, 1); /* Set */
7685 
7686   /* We need to go after all inner classes and start expanding them,
7687      starting with most nested ones. We have to do that because nested
7688      classes might add functions to outer classes */
7689 
7690   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7691        inner_list; inner_list = TREE_CHAIN (inner_list))
7692     java_complete_expand_class (TREE_PURPOSE (inner_list));
7693 
7694   java_complete_expand_methods (outer);
7695   set_nested_class_simple_name_value (outer, 0); /* Reset */
7696 }
7697 
7698 /* Expand methods registered in CLASS_DECL. The general idea is that
7699    we expand regular methods first. This allows us get an estimate on
7700    how outer context local alias fields are really used so we can add
7701    to the constructor just enough code to initialize them properly (it
7702    also lets us generate finit$ correctly.) Then we expand the
7703    constructors and then <clinit>.  */
7704 
7705 static void
java_complete_expand_methods(tree class_decl)7706 java_complete_expand_methods (tree class_decl)
7707 {
7708   tree clinit, decl, first_decl;
7709 
7710   output_class = current_class = TREE_TYPE (class_decl);
7711 
7712   /* Pre-expand <clinit> to figure whether we really need it or
7713      not. If we do need it, we pre-expand the static fields so they're
7714      ready to be used somewhere else. <clinit> will be fully expanded
7715      after we processed the constructors. */
7716   first_decl = TYPE_METHODS (current_class);
7717   clinit = maybe_generate_pre_expand_clinit (current_class);
7718 
7719   /* Then generate finit$ (if we need to) because constructors will
7720    try to use it.*/
7721   if (TYPE_FINIT_STMT_LIST (current_class))
7722     java_complete_expand_method (generate_finit (current_class));
7723 
7724   /* Then generate instinit$ (if we need to) because constructors will
7725      try to use it. */
7726   if (TYPE_II_STMT_LIST (current_class))
7727     java_complete_expand_method (generate_instinit (current_class));
7728 
7729   /* Now do the constructors */
7730   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7731     {
7732       int no_body;
7733 
7734       if (!DECL_CONSTRUCTOR_P (decl))
7735 	continue;
7736 
7737       no_body = !DECL_FUNCTION_BODY (decl);
7738       /* Don't generate debug info on line zero when expanding a
7739 	 generated constructor. */
7740       if (no_body)
7741 	restore_line_number_status (1);
7742 
7743       java_complete_expand_method (decl);
7744 
7745       if (no_body)
7746 	restore_line_number_status (0);
7747     }
7748 
7749   /* First, do the ordinary methods. */
7750   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7751     {
7752       /* Ctors aren't part of this batch. */
7753       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7754 	continue;
7755 
7756       /* Skip abstract or native methods -- but do handle native
7757  	 methods when generating JNI stubs.  */
7758       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7759 	{
7760 	  DECL_FUNCTION_BODY (decl) = NULL_TREE;
7761 	  continue;
7762 	}
7763 
7764       if (METHOD_NATIVE (decl))
7765  	{
7766  	  tree body;
7767 	  current_function_decl = decl;
7768 	  body = build_jni_stub (decl);
7769  	  BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7770  	}
7771 
7772       java_complete_expand_method (decl);
7773     }
7774 
7775   /* If there is indeed a <clinit>, fully expand it now */
7776   if (clinit)
7777     {
7778       /* Prevent the use of `this' inside <clinit> */
7779       ctxp->explicit_constructor_p = 1;
7780       java_complete_expand_method (clinit);
7781       ctxp->explicit_constructor_p = 0;
7782     }
7783 
7784   /* We might have generated a class$ that we now want to expand */
7785   if (TYPE_DOT_CLASS (current_class))
7786     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7787 
7788   /* Now verify constructor circularity (stop after the first one we
7789      prove wrong.) */
7790   if (!CLASS_INTERFACE (class_decl))
7791     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7792       if (DECL_CONSTRUCTOR_P (decl)
7793 	  && verify_constructor_circularity (decl, decl))
7794 	break;
7795 }
7796 
7797 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7798    safely used in some other methods/constructors.  */
7799 
7800 static tree
maybe_generate_pre_expand_clinit(tree class_type)7801 maybe_generate_pre_expand_clinit (tree class_type)
7802 {
7803   tree current, mdecl;
7804 
7805   if (!TYPE_CLINIT_STMT_LIST (class_type))
7806     return NULL_TREE;
7807 
7808   /* Go through all static fields and pre expand them */
7809   for (current = TYPE_FIELDS (class_type); current;
7810        current = TREE_CHAIN (current))
7811     if (FIELD_STATIC (current))
7812       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7813 
7814   /* Then build the <clinit> method */
7815   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7816 				    clinit_identifier_node, end_params_node);
7817   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7818 		       mdecl, NULL_TREE);
7819   start_artificial_method_body (mdecl);
7820 
7821   /* We process the list of assignment we produced as the result of
7822      the declaration of initialized static field and add them as
7823      statement to the <clinit> method. */
7824   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7825        current = TREE_CHAIN (current))
7826     {
7827       tree stmt = current;
7828       /* We build the assignment expression that will initialize the
7829 	 field to its value. There are strict rules on static
7830 	 initializers (8.5). FIXME */
7831       if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
7832 	stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7833       java_method_add_stmt (mdecl, stmt);
7834     }
7835 
7836   end_artificial_method_body (mdecl);
7837 
7838   /* Now we want to place <clinit> as the last method (because we need
7839      it at least for interface so that it doesn't interfere with the
7840      dispatch table based lookup. */
7841   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7842     {
7843       current = TREE_CHAIN (TYPE_METHODS (class_type));
7844       TYPE_METHODS (class_type) = current;
7845 
7846       while (TREE_CHAIN (current))
7847 	current = TREE_CHAIN (current);
7848 
7849       TREE_CHAIN (current) = mdecl;
7850       TREE_CHAIN (mdecl) = NULL_TREE;
7851     }
7852 
7853   return mdecl;
7854 }
7855 
7856 /* Analyzes a method body and look for something that isn't a
7857    MODIFY_EXPR with a constant value.  */
7858 
7859 static int
analyze_clinit_body(tree this_class,tree bbody)7860 analyze_clinit_body (tree this_class, tree bbody)
7861 {
7862   while (bbody)
7863     switch (TREE_CODE (bbody))
7864       {
7865       case BLOCK:
7866 	bbody = BLOCK_EXPR_BODY (bbody);
7867 	break;
7868 
7869       case EXPR_WITH_FILE_LOCATION:
7870 	bbody = EXPR_WFL_NODE (bbody);
7871 	break;
7872 
7873       case COMPOUND_EXPR:
7874 	if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7875 	  return 1;
7876 	bbody = TREE_OPERAND (bbody, 1);
7877 	break;
7878 
7879       case MODIFY_EXPR:
7880 	/* If we're generating to class file and we're dealing with an
7881 	   array initialization, we return 1 to keep <clinit> */
7882 	if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7883 	    && flag_emit_class_files)
7884 	  return 1;
7885 
7886 	/* There are a few cases where we're required to keep
7887 	   <clinit>:
7888 	   - If this is an assignment whose operand is not constant,
7889 	   - If this is an assignment to a non-initialized field,
7890 	   - If this field is not a member of the current class.
7891 	*/
7892 	return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7893 		|| ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7894 		|| DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7895 
7896       default:
7897 	return 1;
7898       }
7899   return 0;
7900 }
7901 
7902 
7903 /* See whether we could get rid of <clinit>. Criteria are: all static
7904    final fields have constant initial values and the body of <clinit>
7905    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7906 
7907 static int
maybe_yank_clinit(tree mdecl)7908 maybe_yank_clinit (tree mdecl)
7909 {
7910   tree type, current;
7911   tree fbody, bbody;
7912 
7913   if (!DECL_CLINIT_P (mdecl))
7914     return 0;
7915 
7916   /* If the body isn't empty, then we keep <clinit>. Note that if
7917      we're emitting classfiles, this isn't enough not to rule it
7918      out. */
7919   fbody = DECL_FUNCTION_BODY (mdecl);
7920   bbody = BLOCK_EXPR_BODY (fbody);
7921   if (bbody && bbody != error_mark_node)
7922     bbody = BLOCK_EXPR_BODY (bbody);
7923   else
7924     return 0;
7925   if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
7926     return 0;
7927 
7928   type = DECL_CONTEXT (mdecl);
7929   current = TYPE_FIELDS (type);
7930 
7931   for (current = (current ? TREE_CHAIN (current) : current);
7932        current; current = TREE_CHAIN (current))
7933     {
7934       tree f_init;
7935 
7936       /* We're not interested in non-static fields.  */
7937       if (!FIELD_STATIC (current))
7938 	continue;
7939 
7940       /* Nor in fields without initializers. */
7941       f_init = DECL_INITIAL (current);
7942       if (f_init == NULL_TREE)
7943 	continue;
7944 
7945       /* Anything that isn't String or a basic type is ruled out -- or
7946 	 if we know how to deal with it (when doing things natively) we
7947 	 should generated an empty <clinit> so that SUID are computed
7948 	 correctly. */
7949       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7950 	  && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7951 	return 0;
7952 
7953       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7954 	return 0;
7955     }
7956 
7957   /* Now we analyze the method body and look for something that
7958      isn't a MODIFY_EXPR */
7959   if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
7960     return 0;
7961 
7962   /* Get rid of <clinit> in the class' list of methods */
7963   if (TYPE_METHODS (type) == mdecl)
7964     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7965   else
7966     for (current = TYPE_METHODS (type); current;
7967 	 current = TREE_CHAIN (current))
7968       if (TREE_CHAIN (current) == mdecl)
7969 	{
7970 	  TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7971 	  break;
7972 	}
7973 
7974   return 1;
7975 }
7976 
7977 /* Install the argument from MDECL. Suitable to completion and
7978    expansion of mdecl's body.  */
7979 
7980 void
start_complete_expand_method(tree mdecl)7981 start_complete_expand_method (tree mdecl)
7982 {
7983   tree tem;
7984 
7985   pushlevel (1);		/* Prepare for a parameter push */
7986   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7987   DECL_ARGUMENTS (mdecl) = tem;
7988 
7989   for (; tem; tem = TREE_CHAIN (tem))
7990     {
7991       /* TREE_CHAIN (tem) will change after pushdecl. */
7992       tree next = TREE_CHAIN (tem);
7993       tree type = TREE_TYPE (tem);
7994       if (PROMOTE_PROTOTYPES
7995 	  && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
7996 	  && INTEGRAL_TYPE_P (type))
7997 	type = integer_type_node;
7998       DECL_ARG_TYPE (tem) = type;
7999       layout_decl (tem, 0);
8000       pushdecl (tem);
8001       /* Re-install the next so that the list is kept and the loop
8002 	 advances. */
8003       TREE_CHAIN (tem) = next;
8004     }
8005   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8006   input_line = DECL_SOURCE_LINE (mdecl);
8007   build_result_decl (mdecl);
8008 }
8009 
8010 
8011 /* Complete and expand a method.  */
8012 
8013 static void
java_complete_expand_method(tree mdecl)8014 java_complete_expand_method (tree mdecl)
8015 {
8016   tree fbody, block_body, exception_copy;
8017 
8018   current_function_decl = mdecl;
8019   /* Fix constructors before expanding them */
8020   if (DECL_CONSTRUCTOR_P (mdecl))
8021     fix_constructors (mdecl);
8022 
8023   /* Expand functions that have a body */
8024   if (!DECL_FUNCTION_BODY (mdecl))
8025     return;
8026 
8027   fbody = DECL_FUNCTION_BODY (mdecl);
8028   block_body = BLOCK_EXPR_BODY (fbody);
8029   exception_copy = NULL_TREE;
8030 
8031   current_function_decl = mdecl;
8032 
8033   if (! quiet_flag)
8034     fprintf (stderr, " [%s.",
8035 	     lang_printable_name (DECL_CONTEXT (mdecl), 0));
8036   announce_function (mdecl);
8037   if (! quiet_flag)
8038     fprintf (stderr, "]");
8039 
8040   /* Prepare the function for tree completion */
8041   start_complete_expand_method (mdecl);
8042 
8043   /* Install the current this */
8044   current_this = (!METHOD_STATIC (mdecl) ?
8045 		  BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8046 
8047   /* Purge the `throws' list of unchecked exceptions (we save a copy
8048      of the list and re-install it later.) */
8049   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8050   purge_unchecked_exceptions (mdecl);
8051 
8052   /* Install exceptions thrown with `throws' */
8053   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8054 
8055   if (block_body != NULL_TREE)
8056     {
8057       block_body = java_complete_tree (block_body);
8058 
8059       /* Before we check initialization, attached all class initialization
8060 	 variable to the block_body */
8061       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8062 		     attach_init_test_initialization_flags, block_body);
8063 
8064       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8065 	{
8066 	  check_for_initialization (block_body, mdecl);
8067 
8068 	  /* Go through all the flags marking the initialization of
8069 	     static variables and see whether they're definitively
8070 	     assigned, in which case the type is remembered as
8071 	     definitively initialized in MDECL. */
8072 	  if (STATIC_CLASS_INIT_OPT_P ())
8073 	    {
8074 	      /* Always register the context as properly initialized in
8075 		 MDECL. This used with caution helps removing extra
8076 		 initialization of self. */
8077 	      if (METHOD_STATIC (mdecl))
8078 		{
8079 		  *(htab_find_slot
8080 		    (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8081 		     DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8082 		}
8083 	    }
8084 	}
8085       ctxp->explicit_constructor_p = 0;
8086     }
8087 
8088   BLOCK_EXPR_BODY (fbody) = block_body;
8089 
8090   /* If we saw a return but couldn't evaluate it properly, we'll have
8091      an error_mark_node here. */
8092   if (block_body != error_mark_node
8093       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8094       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8095       && !flag_emit_xref)
8096     missing_return_error (current_function_decl);
8097 
8098   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8099   maybe_yank_clinit (mdecl);
8100 
8101   /* Pop the current level, with special measures if we found errors. */
8102   if (java_error_count)
8103     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8104   poplevel (1, 0, 1);
8105 
8106   /* Pop the exceptions and sanity check */
8107   POP_EXCEPTIONS();
8108   if (currently_caught_type_list)
8109     abort ();
8110 
8111   /* Restore the copy of the list of exceptions if emitting xrefs. */
8112   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8113 }
8114 
8115 /* For with each class for which there's code to generate. */
8116 
8117 static void
java_expand_method_bodies(tree class)8118 java_expand_method_bodies (tree class)
8119 {
8120   tree decl;
8121   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8122     {
8123       tree block;
8124       tree body;
8125 
8126       if (! DECL_FUNCTION_BODY (decl))
8127 	continue;
8128 
8129       current_function_decl = decl;
8130 
8131       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8132 
8133       if (TREE_CODE (block) != BLOCK)
8134 	abort ();
8135 
8136       /* Save the function body for inlining.  */
8137       DECL_SAVED_TREE (decl) = block;
8138 
8139       body = BLOCK_EXPR_BODY (block);
8140 
8141       if (TREE_TYPE (body) == NULL_TREE)
8142 	abort ();
8143 
8144       /* It's time to assign the variable flagging static class
8145 	 initialization based on which classes invoked static methods
8146 	 are definitely initializing. This should be flagged. */
8147       if (STATIC_CLASS_INIT_OPT_P ())
8148 	{
8149 	  tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8150 	  for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8151 	    {
8152 	      /* Executed for each statement calling a static function.
8153 		 LIST is a TREE_LIST whose PURPOSE is the called function
8154 		 and VALUE is a compound whose second operand can be patched
8155 		 with static class initialization flag assignments.  */
8156 
8157 	      tree called_method = TREE_PURPOSE (list);
8158 	      tree compound = TREE_VALUE (list);
8159 	      tree assignment_compound_list
8160 		= build_tree_list (called_method, NULL);
8161 
8162 	      /* For each class definitely initialized in
8163 		 CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8164 		 assignment to the class initialization flag. */
8165 	      htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8166 			     emit_test_initialization,
8167 			     assignment_compound_list);
8168 
8169 	      if (TREE_VALUE (assignment_compound_list))
8170 		TREE_OPERAND (compound, 1)
8171 		  = TREE_VALUE (assignment_compound_list);
8172 	    }
8173 	}
8174 
8175       /* Prepend class initialization to static methods.  */
8176       if (METHOD_STATIC (decl) && ! METHOD_PRIVATE (decl)
8177 	  && ! flag_emit_class_files
8178 	  && ! DECL_CLINIT_P (decl)
8179 	  && ! CLASS_INTERFACE (TYPE_NAME (class)))
8180 	{
8181 	  tree init = build (CALL_EXPR, void_type_node,
8182 			     build_address_of (soft_initclass_node),
8183 			     build_tree_list (NULL_TREE,
8184 					      build_class_ref (class)),
8185 			     NULL_TREE);
8186 	  TREE_SIDE_EFFECTS (init) = 1;
8187 	  body = build (COMPOUND_EXPR, TREE_TYPE (body), init, body);
8188 	  BLOCK_EXPR_BODY (block) = body;
8189 	}
8190 
8191       /* Wrap synchronized method bodies in a monitorenter
8192 	 plus monitorexit cleanup.  */
8193       if (METHOD_SYNCHRONIZED (decl) && ! flag_emit_class_files)
8194 	{
8195 	  tree enter, exit, lock;
8196 	  if (METHOD_STATIC (decl))
8197 	    lock = build_class_ref (class);
8198 	  else
8199 	    lock = DECL_ARGUMENTS (decl);
8200 	  BUILD_MONITOR_ENTER (enter, lock);
8201 	  BUILD_MONITOR_EXIT (exit, lock);
8202 
8203 	  body = build (COMPOUND_EXPR, void_type_node,
8204 			enter,
8205 			build (TRY_FINALLY_EXPR, void_type_node, body, exit));
8206 	  BLOCK_EXPR_BODY (block) = body;
8207 	}
8208 
8209       /* Expand the the function body.  */
8210       source_end_java_method ();
8211     }
8212 }
8213 
8214 
8215 
8216 /* This section of the code deals with accessing enclosing context
8217    fields either directly by using the relevant access to this$<n> or
8218    by invoking an access method crafted for that purpose.  */
8219 
8220 /* Build the necessary access from an inner class to an outer
8221    class. This routine could be optimized to cache previous result
8222    (decl, current_class and returned access).  When an access method
8223    needs to be generated, it always takes the form of a read. It might
8224    be later turned into a write by calling outer_field_access_fix.  */
8225 
8226 static tree
build_outer_field_access(tree id,tree decl)8227 build_outer_field_access (tree id, tree decl)
8228 {
8229   tree access = NULL_TREE;
8230   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8231   tree decl_ctx = DECL_CONTEXT (decl);
8232 
8233   /* If the immediate enclosing context of the current class is the
8234      field decl's class or inherits from it; build the access as
8235      `this$<n>.<field>'. Note that we will break the `private' barrier
8236      if we're not emitting bytecodes. */
8237   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8238       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8239     {
8240       tree thisn = build_current_thisn (current_class);
8241       access = make_qualified_primary (build_wfl_node (thisn),
8242 				       id, EXPR_WFL_LINECOL (id));
8243     }
8244   /* Otherwise, generate access methods to outer this and access the
8245      field (either using an access method or by direct access.) */
8246   else
8247     {
8248       int lc = EXPR_WFL_LINECOL (id);
8249 
8250       /* Now we chain the required number of calls to the access$0 to
8251 	 get a hold to the enclosing instance we need, and then we
8252 	 build the field access. */
8253       access = build_access_to_thisn (current_class, decl_ctx, lc);
8254 
8255       /* If the field is private and we're generating bytecode, then
8256          we generate an access method */
8257       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8258 	{
8259 	  tree name = build_outer_field_access_methods (decl);
8260 	  access = build_outer_field_access_expr (lc, decl_ctx,
8261 						  name, access, NULL_TREE);
8262 	}
8263       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8264 	 Once again we break the `private' access rule from a foreign
8265 	 class. */
8266       else
8267 	access = make_qualified_primary (access, id, lc);
8268     }
8269   return resolve_expression_name (access, NULL);
8270 }
8271 
8272 /* Return a nonzero value if NODE describes an outer field inner
8273    access.  */
8274 
8275 static int
outer_field_access_p(tree type,tree decl)8276 outer_field_access_p (tree type, tree decl)
8277 {
8278   if (!INNER_CLASS_TYPE_P (type)
8279       || TREE_CODE (decl) != FIELD_DECL
8280       || DECL_CONTEXT (decl) == type)
8281     return 0;
8282 
8283   /* If the inner class extends the declaration context of the field
8284      we're trying to access, then this isn't an outer field access */
8285   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8286     return 0;
8287 
8288   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8289        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8290     {
8291       if (type == DECL_CONTEXT (decl))
8292 	return 1;
8293 
8294       if (!DECL_CONTEXT (TYPE_NAME (type)))
8295 	{
8296 	  /* Before we give up, see whether the field is inherited from
8297 	     the enclosing context we're considering. */
8298 	  if (inherits_from_p (type, DECL_CONTEXT (decl)))
8299 	    return 1;
8300 	  break;
8301 	}
8302     }
8303 
8304   return 0;
8305 }
8306 
8307 /* Return a nonzero value if NODE represents an outer field inner
8308    access that was been already expanded. As a side effect, it returns
8309    the name of the field being accessed and the argument passed to the
8310    access function, suitable for a regeneration of the access method
8311    call if necessary. */
8312 
8313 static int
outer_field_expanded_access_p(tree node,tree * name,tree * arg_type,tree * arg)8314 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8315 			       tree *arg)
8316 {
8317   int identified = 0;
8318 
8319   if (TREE_CODE (node) != CALL_EXPR)
8320     return 0;
8321 
8322   /* Well, gcj generates slightly different tree nodes when compiling
8323      to native or bytecodes. It's the case for function calls. */
8324 
8325   if (flag_emit_class_files
8326       && TREE_CODE (node) == CALL_EXPR
8327       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8328     identified = 1;
8329   else if (!flag_emit_class_files)
8330     {
8331       node = TREE_OPERAND (node, 0);
8332 
8333       if (node && TREE_OPERAND (node, 0)
8334 	  && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8335 	{
8336 	  node = TREE_OPERAND (node, 0);
8337 	  if (TREE_OPERAND (node, 0)
8338 	      && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8339 	      && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8340 		  (DECL_NAME (TREE_OPERAND (node, 0)))))
8341 	    identified = 1;
8342 	}
8343     }
8344 
8345   if (identified && name && arg_type && arg)
8346     {
8347       tree argument = TREE_OPERAND (node, 1);
8348       *name = DECL_NAME (TREE_OPERAND (node, 0));
8349       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8350       *arg = TREE_VALUE (argument);
8351     }
8352   return identified;
8353 }
8354 
8355 /* Detect in NODE an outer field read access from an inner class and
8356    transform it into a write with RHS as an argument. This function is
8357    called from the java_complete_lhs when an assignment to a LHS can
8358    be identified. */
8359 
8360 static tree
outer_field_access_fix(tree wfl,tree node,tree rhs)8361 outer_field_access_fix (tree wfl, tree node, tree rhs)
8362 {
8363   tree name, arg_type, arg;
8364 
8365   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8366     {
8367       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8368 					    arg_type, name, arg, rhs);
8369       return java_complete_tree (node);
8370     }
8371   return NULL_TREE;
8372 }
8373 
8374 /* Construct the expression that calls an access method:
8375      <type>.access$<n>(<arg1> [, <arg2>]);
8376 
8377    ARG2 can be NULL and will be omitted in that case. It will denote a
8378    read access.  */
8379 
8380 static tree
build_outer_field_access_expr(int lc,tree type,tree access_method_name,tree arg1,tree arg2)8381 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8382 			       tree arg1, tree arg2)
8383 {
8384   tree args, cn, access;
8385 
8386   args = arg1 ? arg1 :
8387     build_wfl_node (build_current_thisn (current_class));
8388   args = build_tree_list (NULL_TREE, args);
8389 
8390   if (arg2)
8391     args = tree_cons (NULL_TREE, arg2, args);
8392 
8393   access = build_method_invocation (build_wfl_node (access_method_name), args);
8394   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8395   return make_qualified_primary (cn, access, lc);
8396 }
8397 
8398 static tree
build_new_access_id(void)8399 build_new_access_id (void)
8400 {
8401   static int access_n_counter = 1;
8402   char buffer [128];
8403 
8404   sprintf (buffer, "access$%d", access_n_counter++);
8405   return get_identifier (buffer);
8406 }
8407 
8408 /* Create the static access functions for the outer field DECL. We define a
8409    read:
8410      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8411        return inst$.field;
8412      }
8413    and a write access:
8414      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8415                                      TREE_TYPE (<field>) value$) {
8416        return inst$.field = value$;
8417      }
8418    We should have a usage flags on the DECL so we can lazily turn the ones
8419    we're using for code generation. FIXME.
8420 */
8421 
8422 static tree
build_outer_field_access_methods(tree decl)8423 build_outer_field_access_methods (tree decl)
8424 {
8425   tree id, args, stmt, mdecl;
8426 
8427   if (FIELD_INNER_ACCESS_P (decl))
8428     return FIELD_INNER_ACCESS (decl);
8429 
8430   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8431 
8432   /* Create the identifier and a function named after it. */
8433   id = build_new_access_id ();
8434 
8435   /* The identifier is marked as bearing the name of a generated write
8436      access function for outer field accessed from inner classes. */
8437   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8438 
8439   /* Create the read access */
8440   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8441   TREE_CHAIN (args) = end_params_node;
8442   stmt = make_qualified_primary (build_wfl_node (inst_id),
8443 				 build_wfl_node (DECL_NAME (decl)), 0);
8444   stmt = build_return (0, stmt);
8445   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8446 					   TREE_TYPE (decl), id, args, stmt);
8447   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8448 
8449   /* Create the write access method. No write access for final variable */
8450   if (!FIELD_FINAL (decl))
8451     {
8452       args = build_tree_list (inst_id,
8453 			      build_pointer_type (DECL_CONTEXT (decl)));
8454       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8455       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8456       stmt = make_qualified_primary (build_wfl_node (inst_id),
8457 				     build_wfl_node (DECL_NAME (decl)), 0);
8458       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8459 						build_wfl_node (wpv_id)));
8460       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8461 					       TREE_TYPE (decl), id,
8462 					       args, stmt);
8463     }
8464   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8465 
8466   /* Return the access name */
8467   return FIELD_INNER_ACCESS (decl) = id;
8468 }
8469 
8470 /* Build an field access method NAME.  */
8471 
8472 static tree
build_outer_field_access_method(tree class,tree type,tree name,tree args,tree body)8473 build_outer_field_access_method (tree class, tree type, tree name,
8474 				 tree args, tree body)
8475 {
8476   tree saved_current_function_decl, mdecl;
8477 
8478   /* Create the method */
8479   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8480   fix_method_argument_names (args, mdecl);
8481   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8482 
8483   /* Attach the method body. */
8484   saved_current_function_decl = current_function_decl;
8485   start_artificial_method_body (mdecl);
8486   java_method_add_stmt (mdecl, body);
8487   end_artificial_method_body (mdecl);
8488   current_function_decl = saved_current_function_decl;
8489 
8490   return mdecl;
8491 }
8492 
8493 
8494 /* This section deals with building access function necessary for
8495    certain kinds of method invocation from inner classes.  */
8496 
8497 static tree
build_outer_method_access_method(tree decl)8498 build_outer_method_access_method (tree decl)
8499 {
8500   tree saved_current_function_decl, mdecl;
8501   tree args = NULL_TREE, call_args = NULL_TREE;
8502   tree carg, id, body, class;
8503   char buffer [80];
8504   int parm_id_count = 0;
8505 
8506   /* Test this abort with an access to a private field */
8507   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8508     abort ();
8509 
8510   /* Check the cache first */
8511   if (DECL_FUNCTION_INNER_ACCESS (decl))
8512     return DECL_FUNCTION_INNER_ACCESS (decl);
8513 
8514   class = DECL_CONTEXT (decl);
8515 
8516   /* Obtain an access identifier and mark it */
8517   id = build_new_access_id ();
8518   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8519 
8520   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8521   /* Create the arguments, as much as the original */
8522   for (; carg && carg != end_params_node;
8523        carg = TREE_CHAIN (carg))
8524     {
8525       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8526       args = chainon (args, build_tree_list (get_identifier (buffer),
8527 					     TREE_VALUE (carg)));
8528     }
8529   args = chainon (args, end_params_node);
8530 
8531   /* Create the method */
8532   mdecl = create_artificial_method (class, ACC_STATIC,
8533 				    TREE_TYPE (TREE_TYPE (decl)), id, args);
8534   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8535   /* There is a potential bug here. We should be able to use
8536      fix_method_argument_names, but then arg names get mixed up and
8537      eventually a constructor will have its this$0 altered and the
8538      outer context won't be assignment properly. The testcase is
8539      stub.java FIXME */
8540   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8541 
8542   /* Attach the method body. */
8543   saved_current_function_decl = current_function_decl;
8544   start_artificial_method_body (mdecl);
8545 
8546   /* The actual method invocation uses the same args. When invoking a
8547      static methods that way, we don't want to skip the first
8548      argument. */
8549   carg = args;
8550   if (!METHOD_STATIC (decl))
8551     carg = TREE_CHAIN (carg);
8552   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8553     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8554 			   call_args);
8555 
8556   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8557 				  call_args);
8558   if (!METHOD_STATIC (decl))
8559     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8560 				   body, 0);
8561   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8562     body = build_return (0, body);
8563   java_method_add_stmt (mdecl,body);
8564   end_artificial_method_body (mdecl);
8565   current_function_decl = saved_current_function_decl;
8566 
8567   /* Back tag the access function so it know what it accesses */
8568   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8569 
8570   /* Tag the current method so it knows it has an access generated */
8571   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8572 }
8573 
8574 
8575 /* This section of the code deals with building expressions to access
8576    the enclosing instance of an inner class. The enclosing instance is
8577    kept in a generated field called this$<n>, with <n> being the
8578    inner class nesting level (starting from 0.)  */
8579 
8580 /* Build an access to a given this$<n>, always chaining access call to
8581    others. Access methods to this$<n> are build on the fly if
8582    necessary. This CAN'T be used to solely access this$<n-1> from
8583    this$<n> (which alway yield to special cases and optimization, see
8584    for example build_outer_field_access).  */
8585 
8586 static tree
build_access_to_thisn(tree from,tree to,int lc)8587 build_access_to_thisn (tree from, tree to, int lc)
8588 {
8589   tree access = NULL_TREE;
8590 
8591   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8592     {
8593       if (!access)
8594         {
8595           access = build_current_thisn (from);
8596           access = build_wfl_node (access);
8597         }
8598       else
8599 	{
8600 	  tree access0_wfl, cn;
8601 
8602 	  maybe_build_thisn_access_method (from);
8603 	  access0_wfl = build_wfl_node (access0_identifier_node);
8604 	  cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8605 	  EXPR_WFL_LINECOL (access0_wfl) = lc;
8606 	  access = build_tree_list (NULL_TREE, access);
8607 	  access = build_method_invocation (access0_wfl, access);
8608 	  access = make_qualified_primary (cn, access, lc);
8609 	}
8610 
8611       /* If FROM isn't an inner class, that's fine, we've done enough.
8612          What we're looking for can be accessed from there.  */
8613       from = DECL_CONTEXT (TYPE_NAME (from));
8614       if (!from)
8615 	break;
8616       from = TREE_TYPE (from);
8617     }
8618   return access;
8619 }
8620 
8621 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8622    is returned if nothing needs to be generated. Otherwise, the method
8623    generated and a method decl is returned.
8624 
8625    NOTE: These generated methods should be declared in a class file
8626    attribute so that they can't be referred to directly.  */
8627 
8628 static tree
maybe_build_thisn_access_method(tree type)8629 maybe_build_thisn_access_method (tree type)
8630 {
8631   tree mdecl, args, stmt, rtype;
8632   tree saved_current_function_decl;
8633 
8634   /* If TYPE is a top-level class, no access method is required.
8635      If there already is such an access method, bail out. */
8636   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8637     return NULL_TREE;
8638 
8639   /* We generate the method. The method looks like:
8640      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8641   */
8642   args = build_tree_list (inst_id, build_pointer_type (type));
8643   TREE_CHAIN (args) = end_params_node;
8644   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8645   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8646 				    access0_identifier_node, args);
8647   fix_method_argument_names (args, mdecl);
8648   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8649   stmt = build_current_thisn (type);
8650   stmt = make_qualified_primary (build_wfl_node (inst_id),
8651 				 build_wfl_node (stmt), 0);
8652   stmt = build_return (0, stmt);
8653 
8654   saved_current_function_decl = current_function_decl;
8655   start_artificial_method_body (mdecl);
8656   java_method_add_stmt (mdecl, stmt);
8657   end_artificial_method_body (mdecl);
8658   current_function_decl = saved_current_function_decl;
8659 
8660   CLASS_ACCESS0_GENERATED_P (type) = 1;
8661 
8662   return mdecl;
8663 }
8664 
8665 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8666    the first level of innerclassing. this$1 for the next one, etc...
8667    This function can be invoked with TYPE to NULL, available and then
8668    has to count the parser context.  */
8669 
8670 static GTY(()) tree saved_thisn;
8671 static GTY(()) tree saved_type;
8672 
8673 static tree
build_current_thisn(tree type)8674 build_current_thisn (tree type)
8675 {
8676   static int saved_i = -1;
8677   static int saved_type_i = 0;
8678   tree decl;
8679   char buffer [24];
8680   int i = 0;
8681 
8682   if (type)
8683     {
8684       if (type == saved_type)
8685 	i = saved_type_i;
8686       else
8687 	{
8688 	  for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8689 	       decl; decl = DECL_CONTEXT (decl), i++)
8690 	    ;
8691 
8692 	  saved_type = type;
8693 	  saved_type_i = i;
8694 	}
8695     }
8696   else
8697     i = list_length (GET_CPC_LIST ())-2;
8698 
8699   if (i == saved_i)
8700     return saved_thisn;
8701 
8702   sprintf (buffer, "this$%d", i);
8703   saved_i = i;
8704   saved_thisn = get_identifier (buffer);
8705   return saved_thisn;
8706 }
8707 
8708 /* Return the assignment to the hidden enclosing context `this$<n>'
8709    by the second incoming parameter to the innerclass constructor. The
8710    form used is `this.this$<n> = this$<n>;'.  */
8711 
8712 static tree
build_thisn_assign(void)8713 build_thisn_assign (void)
8714 {
8715   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8716     {
8717       tree thisn = build_current_thisn (current_class);
8718       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8719 					 build_wfl_node (thisn), 0);
8720       tree rhs = build_wfl_node (thisn);
8721       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8722       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8723     }
8724   return NULL_TREE;
8725 }
8726 
8727 
8728 /* Building the synthetic `class$' used to implement the `.class' 1.1
8729    extension for non primitive types. This method looks like:
8730 
8731     static Class class$(String type) throws NoClassDefFoundError
8732     {
8733       try {return (java.lang.Class.forName (String));}
8734       catch (ClassNotFoundException e) {
8735         throw new NoClassDefFoundError(e.getMessage());}
8736     } */
8737 
8738 static GTY(()) tree get_message_wfl;
8739 static GTY(()) tree type_parm_wfl;
8740 
8741 static tree
build_dot_class_method(tree class)8742 build_dot_class_method (tree class)
8743 {
8744 #define BWF(S) build_wfl_node (get_identifier ((S)))
8745 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8746   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8747   tree stmt, throw_stmt;
8748 
8749   if (!get_message_wfl)
8750     {
8751       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8752       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8753     }
8754 
8755   /* Build the arguments */
8756   args = build_tree_list (get_identifier ("type$"),
8757 			  build_pointer_type (string_type_node));
8758   TREE_CHAIN (args) = end_params_node;
8759 
8760   /* Build the qualified name java.lang.Class.forName */
8761   tmp = MQN (MQN (MQN (BWF ("java"),
8762 		       BWF ("lang")), BWF ("Class")), BWF ("forName"));
8763 
8764   /* Create the "class$" function */
8765   mdecl = create_artificial_method (class, ACC_STATIC,
8766 				    build_pointer_type (class_type_node),
8767 				    classdollar_identifier_node, args);
8768   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8769 		   BWF ("NoClassDefFoundError"));
8770   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8771   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8772   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8773     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8774 
8775   /* We start by building the try block. We need to build:
8776        return (java.lang.Class.forName (type)); */
8777   stmt = build_method_invocation (tmp,
8778 				  build_tree_list (NULL_TREE, type_parm_wfl));
8779   stmt = build_return (0, stmt);
8780 
8781   /* Now onto the catch block. We start by building the expression
8782      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8783   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8784 				    get_message_wfl, 0);
8785   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8786 
8787   /* Build new NoClassDefFoundError (_.getMessage) */
8788   throw_stmt = build_new_invocation
8789     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8790      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8791 
8792   /* Build the throw, (it's too early to use BUILD_THROW) */
8793   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8794 
8795   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8796   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8797 		   BWF ("ClassNotFoundException"));
8798   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8799 
8800   fix_method_argument_names (args, mdecl);
8801   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8802   saved_current_function_decl = current_function_decl;
8803   start_artificial_method_body (mdecl);
8804   java_method_add_stmt (mdecl, stmt);
8805   end_artificial_method_body (mdecl);
8806   current_function_decl = saved_current_function_decl;
8807   TYPE_DOT_CLASS (class) = mdecl;
8808 
8809   return mdecl;
8810 }
8811 
8812 static tree
build_dot_class_method_invocation(tree this_class,tree type)8813 build_dot_class_method_invocation (tree this_class, tree type)
8814 {
8815   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8816   tree sig_id, s, t;
8817 
8818   if (TYPE_ARRAY_P (type))
8819     sig_id = build_java_signature (type);
8820   else
8821     sig_id = DECL_NAME (TYPE_NAME (type));
8822 
8823   /* Ensure that the proper name separator is used */
8824   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8825 			       IDENTIFIER_LENGTH (sig_id));
8826 
8827   s = build_string (IDENTIFIER_LENGTH (sig_id),
8828 		    IDENTIFIER_POINTER (sig_id));
8829   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8830 			       build_tree_list (NULL_TREE, s));
8831   if (DECL_CONTEXT (dot_class_method) != this_class)
8832     {
8833       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8834       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8835     }
8836   return t;
8837 }
8838 
8839 /* This section of the code deals with constructor.  */
8840 
8841 /* Craft a body for default constructor. Patch existing constructor
8842    bodies with call to super() and field initialization statements if
8843    necessary.  */
8844 
8845 static void
fix_constructors(tree mdecl)8846 fix_constructors (tree mdecl)
8847 {
8848   tree iii;			/* Instance Initializer Invocation */
8849   tree body = DECL_FUNCTION_BODY (mdecl);
8850   tree thisn_assign, compound = NULL_TREE;
8851   tree class_type = DECL_CONTEXT (mdecl);
8852 
8853   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8854     return;
8855   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8856 
8857   if (!body)
8858     {
8859       /* It is an error for the compiler to generate a default
8860 	 constructor if the superclass doesn't have a constructor that
8861 	 takes no argument, or the same args for an anonymous class */
8862       if (verify_constructor_super (mdecl))
8863 	{
8864 	  tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8865 	  tree save = DECL_NAME (mdecl);
8866 	  const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8867 	  DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8868 	  parse_error_context
8869 	    (lookup_cl (TYPE_NAME (class_type)),
8870 	     "No constructor matching `%s' found in class `%s'",
8871 	     lang_printable_name (mdecl, 0), n);
8872 	  DECL_NAME (mdecl) = save;
8873 	}
8874 
8875       /* The constructor body must be crafted by hand. It's the
8876 	 constructor we defined when we realize we didn't have the
8877 	 CLASSNAME() constructor */
8878       start_artificial_method_body (mdecl);
8879 
8880       /* Insert an assignment to the this$<n> hidden field, if
8881          necessary */
8882       if ((thisn_assign = build_thisn_assign ()))
8883 	java_method_add_stmt (mdecl, thisn_assign);
8884 
8885       /* We don't generate a super constructor invocation if we're
8886 	 compiling java.lang.Object. build_super_invocation takes care
8887 	 of that. */
8888       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8889 
8890       /* FIXME */
8891       if ((iii = build_instinit_invocation (class_type)))
8892 	java_method_add_stmt (mdecl, iii);
8893 
8894       end_artificial_method_body (mdecl);
8895     }
8896   /* Search for an explicit constructor invocation */
8897   else
8898     {
8899       int found = 0;
8900       int invokes_this = 0;
8901       tree found_call = NULL_TREE;
8902       tree main_block = BLOCK_EXPR_BODY (body);
8903 
8904       while (body)
8905 	switch (TREE_CODE (body))
8906 	  {
8907 	  case CALL_EXPR:
8908 	    found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8909 	    if (CALL_THIS_CONSTRUCTOR_P (body))
8910 	      invokes_this = 1;
8911 	    body = NULL_TREE;
8912 	    break;
8913 	  case COMPOUND_EXPR:
8914 	  case EXPR_WITH_FILE_LOCATION:
8915 	    found_call = body;
8916 	    body = TREE_OPERAND (body, 0);
8917 	    break;
8918 	  case BLOCK:
8919 	    found_call = body;
8920 	    body = BLOCK_EXPR_BODY (body);
8921 	    break;
8922 	  default:
8923 	    found = 0;
8924 	    body = NULL_TREE;
8925 	  }
8926 
8927       /* Generate the assignment to this$<n>, if necessary */
8928       if ((thisn_assign = build_thisn_assign ()))
8929         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8930 
8931       /* The constructor is missing an invocation of super() */
8932       if (!found)
8933 	compound = add_stmt_to_compound (compound, NULL_TREE,
8934                                          build_super_invocation (mdecl));
8935       /* Explicit super() invocation should take place before the
8936          instance initializer blocks. */
8937       else
8938 	{
8939 	  compound = add_stmt_to_compound (compound, NULL_TREE,
8940 					   TREE_OPERAND (found_call, 0));
8941 	  TREE_OPERAND (found_call, 0) = empty_stmt_node;
8942 	}
8943 
8944       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8945 
8946       /* Insert the instance initializer block right after. */
8947       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8948 	compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8949 
8950       /* Fix the constructor main block if we're adding extra stmts */
8951       if (compound)
8952 	{
8953 	  compound = add_stmt_to_compound (compound, NULL_TREE,
8954 					   BLOCK_EXPR_BODY (main_block));
8955 	  BLOCK_EXPR_BODY (main_block) = compound;
8956 	}
8957     }
8958 }
8959 
8960 /* Browse constructors in the super class, searching for a constructor
8961    that doesn't take any argument. Return 0 if one is found, 1
8962    otherwise.  If the current class is an anonymous inner class, look
8963    for something that has the same signature. */
8964 
8965 static int
verify_constructor_super(tree mdecl)8966 verify_constructor_super (tree mdecl)
8967 {
8968   tree class = CLASSTYPE_SUPER (current_class);
8969   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8970   tree sdecl;
8971 
8972   if (!class)
8973     return 0;
8974 
8975   if (ANONYMOUS_CLASS_P (current_class))
8976     {
8977       tree mdecl_arg_type;
8978       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8979       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8980 	if (DECL_CONSTRUCTOR_P (sdecl))
8981 	  {
8982 	    tree m_arg_type;
8983 	    tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8984 	    if (super_inner)
8985 	      arg_type = TREE_CHAIN (arg_type);
8986 	    for (m_arg_type = mdecl_arg_type;
8987 		 (arg_type != end_params_node
8988 		  && m_arg_type != end_params_node);
8989 		 arg_type = TREE_CHAIN (arg_type),
8990 		   m_arg_type = TREE_CHAIN (m_arg_type))
8991 	      if (!valid_method_invocation_conversion_p
8992 		     (TREE_VALUE (arg_type),
8993 		      TREE_VALUE (m_arg_type)))
8994 		break;
8995 
8996 	    if (arg_type == end_params_node && m_arg_type == end_params_node)
8997 	      return 0;
8998 	  }
8999     }
9000   else
9001     {
9002       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9003 	{
9004 	  tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9005 	  if (super_inner)
9006 	    arg = TREE_CHAIN (arg);
9007 	  if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
9008 	    return 0;
9009 	}
9010     }
9011   return 1;
9012 }
9013 
9014 /* Generate code for all context remembered for code generation.  */
9015 
9016 static GTY(()) tree reversed_class_list;
9017 void
java_expand_classes(void)9018 java_expand_classes (void)
9019 {
9020   int save_error_count = 0;
9021   static struct parser_ctxt *cur_ctxp = NULL;
9022 
9023   java_parse_abort_on_error ();
9024   if (!(ctxp = ctxp_for_generation))
9025     return;
9026   java_layout_classes ();
9027   java_parse_abort_on_error ();
9028 
9029   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9030     {
9031       tree current;
9032       for (current = cur_ctxp->class_list;
9033 	   current;
9034 	   current = TREE_CHAIN (current))
9035 	gen_indirect_dispatch_tables (TREE_TYPE (current));
9036     }
9037 
9038   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9039     {
9040       ctxp = cur_ctxp;
9041       input_filename = ctxp->filename;
9042       lang_init_source (2);	       /* Error msgs have method prototypes */
9043       java_complete_expand_classes (); /* Complete and expand classes */
9044       java_parse_abort_on_error ();
9045     }
9046   input_filename = main_input_filename;
9047 
9048   /* Find anonymous classes and expand their constructor. This extra pass is
9049      necessary because the constructor itself is only generated when the
9050      method in which it is defined is expanded. */
9051   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9052     {
9053       tree current;
9054       ctxp = cur_ctxp;
9055       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9056 	{
9057 	  output_class = current_class = TREE_TYPE (current);
9058 	  if (ANONYMOUS_CLASS_P (current_class))
9059 	    {
9060 	      tree d;
9061 	      for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9062 		{
9063 		  if (DECL_CONSTRUCTOR_P (d))
9064 		    {
9065 		      restore_line_number_status (1);
9066 		      java_complete_expand_method (d);
9067 		      restore_line_number_status (0);
9068 		      break;	/* There is only one constructor. */
9069 		    }
9070 		}
9071 	    }
9072 	}
9073     }
9074 
9075   /* Expanding the constructors of anonymous classes generates access
9076      methods.  Scan all the methods looking for null DECL_RESULTs --
9077      this will be the case if a method hasn't been expanded.  */
9078   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9079     {
9080       tree current;
9081       ctxp = cur_ctxp;
9082       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9083 	{
9084 	  tree d;
9085 	  output_class = current_class = TREE_TYPE (current);
9086 	  for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9087 	    {
9088 	      if (DECL_RESULT (d) == NULL_TREE)
9089 		{
9090 		  restore_line_number_status (1);
9091 		  java_complete_expand_method (d);
9092 		  restore_line_number_status (0);
9093 		}
9094 	    }
9095 	}
9096     }
9097 
9098   /* ???  Instead of all this we could iterate around the list of
9099      classes until there were no more un-expanded methods.  It would
9100      take a little longer -- one pass over the whole list of methods
9101      -- but it would be simpler.  Like this:  */
9102 #if 0
9103     {
9104       int something_changed;
9105 
9106       do
9107 	{
9108 	  something_changed = 0;
9109 	  for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9110 	    {
9111 	      tree current;
9112 	      ctxp = cur_ctxp;
9113 	      for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9114 		{
9115 		  tree d;
9116 		  output_class = current_class = TREE_TYPE (current);
9117 		  for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9118 		    {
9119 		      if (DECL_RESULT (d) == NULL_TREE)
9120 			{
9121 			  something_changed = 1;
9122 			  restore_line_number_status (1);
9123 			  java_complete_expand_method (d);
9124 			  restore_line_number_status (0);
9125 			}
9126 		    }
9127 		}
9128 	    }
9129 	}
9130       while (something_changed);
9131     }
9132 #endif
9133 
9134   /* If we've found error at that stage, don't try to generate
9135      anything, unless we're emitting xrefs or checking the syntax only
9136      (but not using -fsyntax-only for the purpose of generating
9137      bytecode. */
9138   if (java_error_count && !flag_emit_xref
9139       && (!flag_syntax_only && !flag_emit_class_files))
9140     return;
9141 
9142   /* Now things are stable, go for generation of the class data. */
9143 
9144   /* We pessimistically marked all methods and fields external until
9145      we knew what set of classes we were planning to compile.  Now mark
9146      those that will be generated locally as not external.  */
9147   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9148     {
9149       tree current;
9150       ctxp = cur_ctxp;
9151       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9152 	java_mark_class_local (TREE_TYPE (current));
9153     }
9154 
9155   /* Compile the classes.  */
9156   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9157     {
9158       tree current;
9159       reversed_class_list = NULL;
9160 
9161       ctxp = cur_ctxp;
9162 
9163       /* We write out the classes in reverse order.  This ensures that
9164 	 inner classes are written before their containing classes,
9165 	 which is important for parallel builds.  Otherwise, the
9166 	 class file for the outer class may be found, but the class
9167 	 file for the inner class may not be present.  In that
9168 	 situation, the compiler cannot fall back to the original
9169 	 source, having already read the outer class, so we must
9170 	 prevent that situation.  */
9171       for (current = ctxp->class_list;
9172 	   current;
9173 	   current = TREE_CHAIN (current))
9174 	reversed_class_list
9175 	  = tree_cons (NULL_TREE, current, reversed_class_list);
9176 
9177       for (current = reversed_class_list;
9178 	   current;
9179 	   current = TREE_CHAIN (current))
9180 	{
9181 	  output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9182 	  if (flag_emit_class_files)
9183 	    write_classfile (current_class);
9184 	  if (flag_emit_xref)
9185 	    expand_xref (current_class);
9186 	  else if (! flag_syntax_only)
9187 	    java_expand_method_bodies (current_class);
9188 	}
9189     }
9190 }
9191 
9192 void
java_finish_classes(void)9193 java_finish_classes (void)
9194 {
9195   static struct parser_ctxt *cur_ctxp = NULL;
9196   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9197     {
9198       tree current;
9199       ctxp = cur_ctxp;
9200       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9201 	{
9202 	  output_class = current_class = TREE_TYPE (current);
9203 	  finish_class ();
9204 	}
9205     }
9206 }
9207 
9208 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9209    a tree list node containing RIGHT. Fore coming RIGHTs will be
9210    chained to this hook. LOCATION contains the location of the
9211    separating `.' operator.  */
9212 
9213 static tree
make_qualified_primary(tree primary,tree right,int location)9214 make_qualified_primary (tree primary, tree right, int location)
9215 {
9216   tree wfl;
9217 
9218   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9219     wfl = build_wfl_wrap (primary, location);
9220   else
9221     {
9222       wfl = primary;
9223       /* If wfl wasn't qualified, we build a first anchor */
9224       if (!EXPR_WFL_QUALIFICATION (wfl))
9225 	EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9226     }
9227 
9228   /* And chain them */
9229   EXPR_WFL_LINECOL (right) = location;
9230   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9231   PRIMARY_P (wfl) =  1;
9232   return wfl;
9233 }
9234 
9235 /* Simple merge of two name separated by a `.' */
9236 
9237 static tree
merge_qualified_name(tree left,tree right)9238 merge_qualified_name (tree left, tree right)
9239 {
9240   tree node;
9241   if (!left && !right)
9242     return NULL_TREE;
9243 
9244   if (!left)
9245     return right;
9246 
9247   if (!right)
9248     return left;
9249 
9250   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9251 		IDENTIFIER_LENGTH (left));
9252   obstack_1grow (&temporary_obstack, '.');
9253   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9254 		 IDENTIFIER_LENGTH (right));
9255   node =  get_identifier (obstack_base (&temporary_obstack));
9256   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9257   QUALIFIED_P (node) = 1;
9258   return node;
9259 }
9260 
9261 /* Merge the two parts of a qualified name into LEFT.  Set the
9262    location information of the resulting node to LOCATION, usually
9263    inherited from the location information of the `.' operator. */
9264 
9265 static tree
make_qualified_name(tree left,tree right,int location)9266 make_qualified_name (tree left, tree right, int location)
9267 {
9268 #ifdef USE_COMPONENT_REF
9269   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
9270   EXPR_WFL_LINECOL (node) = location;
9271   return node;
9272 #else
9273   tree left_id = EXPR_WFL_NODE (left);
9274   tree right_id = EXPR_WFL_NODE (right);
9275   tree wfl, merge;
9276 
9277   merge = merge_qualified_name (left_id, right_id);
9278 
9279   /* Left wasn't qualified and is now qualified */
9280   if (!QUALIFIED_P (left_id))
9281     {
9282       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9283       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9284       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9285     }
9286 
9287   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9288   EXPR_WFL_LINECOL (wfl) = location;
9289   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9290 
9291   EXPR_WFL_NODE (left) = merge;
9292   return left;
9293 #endif
9294 }
9295 
9296 /* Extract the last identifier component of the qualified in WFL. The
9297    last identifier is removed from the linked list */
9298 
9299 static tree
cut_identifier_in_qualified(tree wfl)9300 cut_identifier_in_qualified (tree wfl)
9301 {
9302   tree q;
9303   tree previous = NULL_TREE;
9304   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9305     if (!TREE_CHAIN (q))
9306       {
9307 	if (!previous)
9308 	  /* Operating on a non qualified qualified WFL.  */
9309 	  abort ();
9310 
9311 	TREE_CHAIN (previous) = NULL_TREE;
9312 	return TREE_PURPOSE (q);
9313       }
9314 }
9315 
9316 /* Resolve the expression name NAME. Return its decl.  */
9317 
9318 static tree
resolve_expression_name(tree id,tree * orig)9319 resolve_expression_name (tree id, tree *orig)
9320 {
9321   tree name = EXPR_WFL_NODE (id);
9322   tree decl;
9323 
9324   /* 6.5.5.1: Simple expression names */
9325   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9326     {
9327       /* 15.13.1: NAME can appear within the scope of a local variable
9328          declaration */
9329       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9330         return decl;
9331 
9332       /* 15.13.1: NAME can appear within a class declaration */
9333       else
9334         {
9335 	  decl = lookup_field_wrapper (current_class, name);
9336 	  if (decl)
9337 	    {
9338 	      tree access = NULL_TREE;
9339 	      int fs = FIELD_STATIC (decl);
9340 
9341 	      /* If we're accessing an outer scope local alias, make
9342 		 sure we change the name of the field we're going to
9343 		 build access to. */
9344 	      if (FIELD_LOCAL_ALIAS_USED (decl))
9345 		name = DECL_NAME (decl);
9346 
9347 	      check_deprecation (id, decl);
9348 
9349 	      /* Instance variable (8.3.1.1) can't appear within
9350 		 static method, static initializer or initializer for
9351 		 a static variable. */
9352 	      if (!fs && METHOD_STATIC (current_function_decl))
9353 	        {
9354 		  static_ref_err (id, name, current_class);
9355 		  return error_mark_node;
9356 		}
9357 	      /* Instance variables can't appear as an argument of
9358 		 an explicit constructor invocation */
9359 	      if (!fs && ctxp->explicit_constructor_p
9360 		  && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9361 		{
9362 		  parse_error_context
9363 		    (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9364 		  return error_mark_node;
9365 		}
9366 
9367 	      /* If we're processing an inner class and we're trying
9368 		 to access a field belonging to an outer class, build
9369 		 the access to the field */
9370 	      if (!fs && outer_field_access_p (current_class, decl))
9371 		{
9372 		  if (CLASS_STATIC (TYPE_NAME (current_class)))
9373 		    {
9374 		      static_ref_err (id, DECL_NAME (decl), current_class);
9375 		      return error_mark_node;
9376 		    }
9377 		  access = build_outer_field_access (id, decl);
9378 		  if (orig)
9379 		    *orig = access;
9380 		  return access;
9381 		}
9382 
9383 	      /* Otherwise build what it takes to access the field */
9384 	      access = build_field_ref ((fs ? NULL_TREE : current_this),
9385 					DECL_CONTEXT (decl), name);
9386 	      if (fs)
9387 		access = maybe_build_class_init_for_field (decl, access);
9388 	      /* We may be asked to save the real field access node */
9389 	      if (orig)
9390 		*orig = access;
9391 	      /* Last check: can we access the field? */
9392 	      if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9393 		{
9394 		  not_accessible_field_error (id, decl);
9395 		  return error_mark_node;
9396 		}
9397 	      /* And we return what we got */
9398 	      return access;
9399 	    }
9400 	  /* Fall down to error report on undefined variable */
9401 	}
9402     }
9403   /* 6.5.5.2 Qualified Expression Names */
9404   else
9405     {
9406       if (orig)
9407 	*orig = NULL_TREE;
9408       qualify_ambiguous_name (id);
9409       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9410       /* 15.10.2: Accessing Superclass Members using super */
9411       return resolve_field_access (id, orig, NULL);
9412     }
9413 
9414   /* We've got an error here */
9415   if (INNER_CLASS_TYPE_P (current_class))
9416     parse_error_context (id,
9417 			 "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9418 			 IDENTIFIER_POINTER (name),
9419 			 IDENTIFIER_POINTER (DECL_NAME
9420 					     (TYPE_NAME (current_class))));
9421   else
9422     parse_error_context (id, "Undefined variable `%s'",
9423 			 IDENTIFIER_POINTER (name));
9424 
9425   return error_mark_node;
9426 }
9427 
9428 static void
static_ref_err(tree wfl,tree field_id,tree class_type)9429 static_ref_err (tree wfl, tree field_id, tree class_type)
9430 {
9431   parse_error_context
9432     (wfl,
9433      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9434      IDENTIFIER_POINTER (field_id),
9435      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9436 }
9437 
9438 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9439    We return something suitable to generate the field access. We also
9440    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9441    recipient's address can be null. */
9442 
9443 static tree
resolve_field_access(tree qual_wfl,tree * field_decl,tree * field_type)9444 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9445 {
9446   int is_static = 0;
9447   tree field_ref;
9448   tree decl, where_found, type_found;
9449 
9450   if (resolve_qualified_expression_name (qual_wfl, &decl,
9451 					 &where_found, &type_found))
9452     return error_mark_node;
9453 
9454   /* Resolve the LENGTH field of an array here */
9455   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9456       && type_found && TYPE_ARRAY_P (type_found)
9457       && ! flag_emit_class_files && ! flag_emit_xref)
9458     {
9459       tree length = build_java_array_length_access (where_found);
9460       field_ref = length;
9461 
9462       /* In case we're dealing with a static array, we need to
9463 	 initialize its class before the array length can be fetched.
9464 	 It's also a good time to create a DECL_RTL for the field if
9465 	 none already exists, otherwise if the field was declared in a
9466 	 class found in an external file and hasn't been (and won't
9467 	 be) accessed for its value, none will be created. */
9468       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9469 	{
9470 	  build_static_field_ref (where_found);
9471 	  field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9472 	}
9473     }
9474   /* We might have been trying to resolve field.method(). In which
9475      case, the resolution is over and decl is the answer */
9476   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9477     field_ref = decl;
9478   else if (JDECL_P (decl))
9479     {
9480       if (!type_found)
9481 	type_found = DECL_CONTEXT (decl);
9482       is_static = FIELD_STATIC (decl);
9483       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9484 				    NULL_TREE : where_found),
9485 				   type_found, DECL_NAME (decl));
9486       if (field_ref == error_mark_node)
9487 	return error_mark_node;
9488       if (is_static)
9489 	field_ref = maybe_build_class_init_for_field (decl, field_ref);
9490 
9491       /* If we're looking at a static field, we may need to generate a
9492 	 class initialization for it.  This can happen when the access
9493 	 looks like `field.ref', where `field' is a static field in an
9494 	 interface we implement.  */
9495       if (!flag_emit_class_files
9496 	  && !flag_emit_xref
9497 	  && TREE_CODE (where_found) == VAR_DECL
9498 	  && FIELD_STATIC (where_found))
9499 	{
9500 	  build_static_field_ref (where_found);
9501 	  field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9502 	}
9503     }
9504   else
9505     field_ref = decl;
9506 
9507   if (field_decl)
9508     *field_decl = decl;
9509   if (field_type)
9510     *field_type = (QUAL_DECL_TYPE (decl) ?
9511 		   QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9512   return field_ref;
9513 }
9514 
9515 /* If NODE is an access to f static field, strip out the class
9516    initialization part and return the field decl, otherwise, return
9517    NODE. */
9518 
9519 static tree
strip_out_static_field_access_decl(tree node)9520 strip_out_static_field_access_decl (tree node)
9521 {
9522   if (TREE_CODE (node) == COMPOUND_EXPR)
9523     {
9524       tree op1 = TREE_OPERAND (node, 1);
9525       if (TREE_CODE (op1) == COMPOUND_EXPR)
9526 	 {
9527 	   tree call = TREE_OPERAND (op1, 0);
9528 	   if (TREE_CODE (call) == CALL_EXPR
9529 	       && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9530 	       && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9531 	       == soft_initclass_node)
9532 	     return TREE_OPERAND (op1, 1);
9533 	 }
9534       else if (JDECL_P (op1))
9535 	return op1;
9536     }
9537   return node;
9538 }
9539 
9540 /* 6.5.5.2: Qualified Expression Names */
9541 
9542 static int
resolve_qualified_expression_name(tree wfl,tree * found_decl,tree * where_found,tree * type_found)9543 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9544 				   tree *where_found, tree *type_found)
9545 {
9546   int from_type = 0;		/* Field search initiated from a type */
9547   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9548   int previous_call_static = 0;
9549   int is_static;
9550   tree decl = NULL_TREE, type = NULL_TREE, q;
9551   /* For certain for of inner class instantiation */
9552   tree saved_current, saved_this;
9553 #define RESTORE_THIS_AND_CURRENT_CLASS 				\
9554   { current_class = saved_current; current_this = saved_this;}
9555 
9556   *type_found = *where_found = NULL_TREE;
9557 
9558   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9559     {
9560       tree qual_wfl = QUAL_WFL (q);
9561       tree ret_decl;		/* for EH checking */
9562       int location;		/* for EH checking */
9563 
9564       /* 15.10.1 Field Access Using a Primary */
9565       switch (TREE_CODE (qual_wfl))
9566 	{
9567 	case CALL_EXPR:
9568 	case NEW_CLASS_EXPR:
9569 	  /* If the access to the function call is a non static field,
9570 	     build the code to access it. */
9571 	  if (JDECL_P (decl) && !FIELD_STATIC (decl))
9572 	    {
9573 	      decl = maybe_access_field (decl, *where_found,
9574 					 DECL_CONTEXT (decl));
9575 	      if (decl == error_mark_node)
9576 		return 1;
9577 	    }
9578 
9579 	  /* And code for the function call */
9580 	  if (complete_function_arguments (qual_wfl))
9581 	    return 1;
9582 
9583 	  /* We might have to setup a new current class and a new this
9584 	     for the search of an inner class, relative to the type of
9585 	     a expression resolved as `decl'. The current values are
9586 	     saved and restored shortly after */
9587 	  saved_current = current_class;
9588 	  saved_this = current_this;
9589 	  if (decl
9590 	      && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9591 		  || from_qualified_this))
9592 	    {
9593 	      /* If we still have `from_qualified_this', we have the form
9594 		 <T>.this.f() and we need to build <T>.this */
9595 	      if (from_qualified_this)
9596 		{
9597 		  decl = build_access_to_thisn (current_class, type, 0);
9598 		  decl = java_complete_tree (decl);
9599 		  type = TREE_TYPE (TREE_TYPE (decl));
9600 		}
9601 	      current_class = type;
9602 	      current_this = decl;
9603 	      from_qualified_this = 0;
9604 	    }
9605 
9606 	  if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9607 	    CALL_USING_SUPER (qual_wfl) = 1;
9608 	  location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9609 		      EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9610 	  *where_found = patch_method_invocation (qual_wfl, decl, type,
9611 						  from_super,
9612 						  &is_static, &ret_decl);
9613 	  from_super = 0;
9614 	  if (*where_found == error_mark_node)
9615 	    {
9616 	      RESTORE_THIS_AND_CURRENT_CLASS;
9617 	      return 1;
9618 	    }
9619 	  *type_found = type = QUAL_DECL_TYPE (*where_found);
9620 
9621 	  *where_found = force_evaluation_order (*where_found);
9622 
9623 	  /* If we're creating an inner class instance, check for that
9624 	     an enclosing instance is in scope */
9625 	  if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9626 	      && INNER_ENCLOSING_SCOPE_CHECK (type))
9627 	    {
9628 	      parse_error_context
9629 		(qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9630 		 lang_printable_name (type, 0),
9631 		 (!current_this ? "" :
9632 		  "; an explicit one must be provided when creating this inner class"));
9633 	      RESTORE_THIS_AND_CURRENT_CLASS;
9634 	      return 1;
9635 	    }
9636 
9637 	  /* In case we had to change then to resolve a inner class
9638 	     instantiation using a primary qualified by a `new' */
9639 	  RESTORE_THIS_AND_CURRENT_CLASS;
9640 
9641 	  if (location)
9642 	    {
9643 	      tree arguments = NULL_TREE;
9644 	      if (TREE_CODE (qual_wfl) == CALL_EXPR
9645 		  && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9646 		arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9647 	      check_thrown_exceptions (location, ret_decl, arguments);
9648 	    }
9649 
9650 	  /* If the previous call was static and this one is too,
9651 	     build a compound expression to hold the two (because in
9652 	     that case, previous function calls aren't transported as
9653 	     forcoming function's argument. */
9654 	  if (previous_call_static && is_static)
9655 	    {
9656 	      decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9657 			    decl, *where_found);
9658 	      TREE_SIDE_EFFECTS (decl) = 1;
9659 	    }
9660 	  else
9661 	    {
9662 	      previous_call_static = is_static;
9663 	      decl = *where_found;
9664 	    }
9665 	  from_type = 0;
9666 	  continue;
9667 
9668 	case NEW_ARRAY_EXPR:
9669 	case NEW_ANONYMOUS_ARRAY_EXPR:
9670 	  *where_found = decl = java_complete_tree (qual_wfl);
9671 	  if (decl == error_mark_node)
9672 	    return 1;
9673 	  *type_found = type = QUAL_DECL_TYPE (decl);
9674 	  continue;
9675 
9676 	case CONVERT_EXPR:
9677 	  *where_found = decl = java_complete_tree (qual_wfl);
9678 	  if (decl == error_mark_node)
9679 	    return 1;
9680 	  *type_found = type = QUAL_DECL_TYPE (decl);
9681 	  from_cast = 1;
9682 	  continue;
9683 
9684 	case CONDITIONAL_EXPR:
9685 	case STRING_CST:
9686 	case MODIFY_EXPR:
9687 	  *where_found = decl = java_complete_tree (qual_wfl);
9688 	  if (decl == error_mark_node)
9689 	    return 1;
9690 	  *type_found = type = QUAL_DECL_TYPE (decl);
9691 	  continue;
9692 
9693 	case ARRAY_REF:
9694 	  /* If the access to the function call is a non static field,
9695 	     build the code to access it. */
9696 	  if (JDECL_P (decl) && !FIELD_STATIC (decl))
9697 	    {
9698 	      decl = maybe_access_field (decl, *where_found, type);
9699 	      if (decl == error_mark_node)
9700 		return 1;
9701 	    }
9702 	  /* And code for the array reference expression */
9703 	  decl = java_complete_tree (qual_wfl);
9704 	  if (decl == error_mark_node)
9705 	    return 1;
9706 	  type = QUAL_DECL_TYPE (decl);
9707 	  continue;
9708 
9709 	case PLUS_EXPR:
9710 	  if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9711 	    return 1;
9712 	  if ((type = patch_string (decl)))
9713 	    decl = type;
9714 	  *where_found = QUAL_RESOLUTION (q) = decl;
9715 	  *type_found = type = TREE_TYPE (decl);
9716 	  break;
9717 
9718 	case CLASS_LITERAL:
9719 	  if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9720 	    return 1;
9721 	  *where_found = QUAL_RESOLUTION (q) = decl;
9722 	  *type_found = type = TREE_TYPE (decl);
9723 	  break;
9724 
9725 	default:
9726 	  /* Fix for -Wall Just go to the next statement. Don't
9727              continue */
9728 	  break;
9729 	}
9730 
9731       /* If we fall here, we weren't processing a (static) function call. */
9732       previous_call_static = 0;
9733 
9734       /* It can be the keyword THIS */
9735       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9736 	  && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9737 	{
9738 	  if (!current_this)
9739 	    {
9740 	      parse_error_context
9741 		(wfl, "Keyword `this' used outside allowed context");
9742 	      return 1;
9743 	    }
9744 	  if (ctxp->explicit_constructor_p
9745 	      && type == current_class)
9746 	    {
9747 	      parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9748 	      return 1;
9749 	    }
9750 	  /* We have to generate code for intermediate access */
9751 	  if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9752 	    {
9753 	      *where_found = decl = current_this;
9754 	      *type_found = type = QUAL_DECL_TYPE (decl);
9755 	    }
9756 	  /* We're trying to access the this from somewhere else. Make sure
9757 	     it's allowed before doing so. */
9758 	  else
9759 	    {
9760 	      if (!enclosing_context_p (type, current_class))
9761 		{
9762 		  char *p  = xstrdup (lang_printable_name (type, 0));
9763 		  parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9764 				       p, p,
9765 				       lang_printable_name (current_class, 0));
9766 		  free (p);
9767 		  return 1;
9768 		}
9769 	      from_qualified_this = 1;
9770 	      /* If there's nothing else after that, we need to
9771                  produce something now, otherwise, the section of the
9772                  code that needs to produce <T>.this will generate
9773                  what is necessary. */
9774 	      if (!TREE_CHAIN (q))
9775 		{
9776 		  decl = build_access_to_thisn (current_class, type, 0);
9777 		  *where_found = decl = java_complete_tree (decl);
9778 		  *type_found = type = TREE_TYPE (decl);
9779 		}
9780 	    }
9781 
9782 	  from_type = 0;
9783 	  continue;
9784 	}
9785 
9786       /* 15.10.2 Accessing Superclass Members using SUPER */
9787       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9788 	  && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9789 	{
9790 	  tree node;
9791 	  /* Check on the restricted use of SUPER */
9792 	  if (METHOD_STATIC (current_function_decl)
9793 	      || current_class == object_type_node)
9794 	    {
9795 	      parse_error_context
9796 		(wfl, "Keyword `super' used outside allowed context");
9797 	      return 1;
9798 	    }
9799 	  /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9800 	  node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9801 			     CLASSTYPE_SUPER (current_class),
9802 			     build_this (EXPR_WFL_LINECOL (qual_wfl)));
9803 	  *where_found = decl = java_complete_tree (node);
9804 	  if (decl == error_mark_node)
9805 	    return 1;
9806 	  *type_found = type = QUAL_DECL_TYPE (decl);
9807 	  from_super = from_type = 1;
9808 	  continue;
9809 	}
9810 
9811       /* 15.13.1: Can't search for field name in packages, so we
9812 	 assume a variable/class name was meant. */
9813       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9814 	{
9815 	  tree name;
9816 	  if ((decl = resolve_package (wfl, &q, &name)))
9817 	    {
9818 	      tree list;
9819 	      *where_found = decl;
9820 
9821 	      /* We want to be absolutely sure that the class is laid
9822                  out. We're going to search something inside it. */
9823 	      *type_found = type = TREE_TYPE (decl);
9824 	      layout_class (type);
9825 	      from_type = 1;
9826 
9827 	      /* Fix them all the way down, if any are left. */
9828 	      if (q)
9829 		{
9830 		  list = TREE_CHAIN (q);
9831 		  while (list)
9832 		    {
9833 		      RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9834 		      list = TREE_CHAIN (list);
9835 		    }
9836 		}
9837 	    }
9838 	  else
9839 	    {
9840 	      if (from_super || from_cast)
9841 		parse_error_context
9842 		  ((from_cast ? qual_wfl : wfl),
9843 		   "No variable `%s' defined in class `%s'",
9844 		   IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9845 		   lang_printable_name (type, 0));
9846 	      else
9847 		parse_error_context
9848 		  (qual_wfl, "Undefined variable or class name: `%s'",
9849 		   IDENTIFIER_POINTER (name));
9850 	      return 1;
9851 	    }
9852 	}
9853 
9854       /* We have a type name. It's been already resolved when the
9855 	 expression was qualified. */
9856       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9857 	{
9858 	  decl = QUAL_RESOLUTION (q);
9859 
9860 	  /* Sneak preview. If next we see a `new', we're facing a
9861 	     qualification with resulted in a type being selected
9862 	     instead of a field.  Report the error */
9863 	  if(TREE_CHAIN (q)
9864 	     && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9865 	    {
9866 	      parse_error_context (qual_wfl, "Undefined variable `%s'",
9867 				   IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9868 	      return 1;
9869 	    }
9870 
9871 	  if (not_accessible_p (TREE_TYPE (decl), decl, type, 0))
9872  	    return not_accessible_field_error (qual_wfl, decl);
9873 	  check_deprecation (qual_wfl, decl);
9874 
9875 	  type = TREE_TYPE (decl);
9876 	  from_type = 1;
9877 	}
9878       /* We resolve an expression name */
9879       else
9880 	{
9881 	  tree field_decl = NULL_TREE;
9882 
9883 	  /* If there exists an early resolution, use it. That occurs
9884 	     only once and we know that there are more things to
9885 	     come. Don't do that when processing something after SUPER
9886 	     (we need more thing to be put in place below */
9887 	  if (!from_super && QUAL_RESOLUTION (q))
9888 	    {
9889 	      decl = QUAL_RESOLUTION (q);
9890 	      if (!type)
9891 		{
9892 		  if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9893 		    {
9894 		      if (current_this)
9895 			*where_found = current_this;
9896 		      else
9897 			{
9898 			  static_ref_err (qual_wfl, DECL_NAME (decl),
9899 					  current_class);
9900 			  return 1;
9901 			}
9902                       if (outer_field_access_p (current_class, decl))
9903                         decl = build_outer_field_access (qual_wfl, decl);
9904 		    }
9905 		  else
9906 		    {
9907 		      *where_found = TREE_TYPE (decl);
9908 		      if (TREE_CODE (*where_found) == POINTER_TYPE)
9909 			*where_found = TREE_TYPE (*where_found);
9910 		    }
9911 		}
9912 	    }
9913 
9914 	  /* Report and error if we're using a numerical literal as a
9915              qualifier. It can only be an INTEGER_CST. */
9916 	  else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9917 	    {
9918 	      parse_error_context
9919 		(wfl, "Can't use type `%s' as a qualifier",
9920 		 lang_printable_name (TREE_TYPE (qual_wfl), 0));
9921 	      return 1;
9922 	    }
9923 
9924 	  /* We have to search for a field, knowing the type of its
9925              container. The flag FROM_TYPE indicates that we resolved
9926              the last member of the expression as a type name, which
9927              means that for the resolution of this field, we'll look
9928              for other errors than if it was resolved as a member of
9929              an other field. */
9930 	  else
9931 	    {
9932 	      int is_static;
9933 	      tree field_decl_type; /* For layout */
9934 
9935 	      if (!from_type && !JREFERENCE_TYPE_P (type))
9936 		{
9937 		  parse_error_context
9938 		    (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9939 		     IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9940 		     lang_printable_name (type, 0),
9941 		     IDENTIFIER_POINTER (DECL_NAME (decl)));
9942 		  return 1;
9943 		}
9944 
9945 	      field_decl = lookup_field_wrapper (type,
9946 						 EXPR_WFL_NODE (qual_wfl));
9947 
9948 	      /* Maybe what we're trying to access to is an inner
9949 		 class, only if decl is a TYPE_DECL. */
9950 	      if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9951 		{
9952 		  tree ptr, inner_decl;
9953 
9954 		  BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9955 		  inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9956 		  if (inner_decl)
9957 		    {
9958 		      check_inner_class_access (inner_decl, decl, qual_wfl);
9959 		      type = TREE_TYPE (inner_decl);
9960 		      decl = inner_decl;
9961 		      from_type = 1;
9962 		      continue;
9963 		    }
9964 		}
9965 
9966 	      if (field_decl == NULL_TREE)
9967 		{
9968 		  parse_error_context
9969 		    (qual_wfl, "No variable `%s' defined in type `%s'",
9970 		     IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9971 		     GET_TYPE_NAME (type));
9972 		  return 1;
9973 		}
9974 	      if (field_decl == error_mark_node)
9975 		return 1;
9976 
9977 	      /* Layout the type of field_decl, since we may need
9978                  it. Don't do primitive types or loaded classes. The
9979                  situation of non primitive arrays may not handled
9980                  properly here. FIXME */
9981 	      if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9982 		field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9983 	      else
9984 		field_decl_type = TREE_TYPE (field_decl);
9985 	      if (!JPRIMITIVE_TYPE_P (field_decl_type)
9986 		  && !CLASS_LOADED_P (field_decl_type)
9987 		  && !TYPE_ARRAY_P (field_decl_type))
9988 		resolve_and_layout (field_decl_type, NULL_TREE);
9989 
9990 	      /* Check on accessibility here */
9991 	      if (not_accessible_p (current_class, field_decl,
9992 				    DECL_CONTEXT (field_decl), from_super))
9993  		return not_accessible_field_error (qual_wfl,field_decl);
9994 	      check_deprecation (qual_wfl, field_decl);
9995 
9996 	      /* There are things to check when fields are accessed
9997 	         from type. There are no restrictions on a static
9998 	         declaration of the field when it is accessed from an
9999 	         interface */
10000 	      is_static = FIELD_STATIC (field_decl);
10001 	      if (!from_super && from_type
10002 		  && !TYPE_INTERFACE_P (type)
10003 		  && !is_static
10004 		  && (current_function_decl
10005 		      && METHOD_STATIC (current_function_decl)))
10006 		{
10007 		  static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
10008 		  return 1;
10009 		}
10010 	      from_cast = from_super = 0;
10011 
10012 	      /* It's an access from a type but it isn't static, we
10013 		 make it relative to `this'. */
10014 	      if (!is_static && from_type)
10015 		decl = current_this;
10016 
10017 	      /* If we need to generate something to get a proper
10018 		 handle on what this field is accessed from, do it
10019 		 now. */
10020 	      if (!is_static)
10021 		{
10022 		  decl = maybe_access_field (decl, *where_found, *type_found);
10023 		  if (decl == error_mark_node)
10024 		    return 1;
10025 		}
10026 
10027 	      /* We want to keep the location were found it, and the type
10028 		 we found. */
10029 	      *where_found = decl;
10030 	      *type_found = type;
10031 
10032 	      /* Generate the correct expression for field access from
10033 		 qualified this */
10034 	      if (from_qualified_this)
10035 		{
10036 		  field_decl = build_outer_field_access (qual_wfl, field_decl);
10037 		  from_qualified_this = 0;
10038 		}
10039 
10040 	      /* This is the decl found and eventually the next one to
10041 		 search from */
10042 	      decl = field_decl;
10043 	    }
10044 	  from_type = 0;
10045 	  type = QUAL_DECL_TYPE (decl);
10046 
10047 	  /* Sneak preview. If decl is qualified by a `new', report
10048              the error here to be accurate on the peculiar construct */
10049 	  if (TREE_CHAIN (q)
10050 	      && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10051 	      && !JREFERENCE_TYPE_P (type))
10052 	    {
10053 	      parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10054 				   lang_printable_name (type, 0));
10055 	      return 1;
10056 	    }
10057 	}
10058       /* `q' might have changed due to a after package resolution
10059          re-qualification */
10060       if (!q)
10061 	break;
10062     }
10063   *found_decl = decl;
10064   return 0;
10065 }
10066 
10067 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10068    can't be accessed from REFERENCE (a record type). If MEMBER
10069    features a protected access, we then use WHERE which, if non null,
10070    holds the type of MEMBER's access that is checked against
10071    6.6.2.1. This function should be used when decl is a field or a
10072    method.  */
10073 
10074 static int
not_accessible_p(tree reference,tree member,tree where,int from_super)10075 not_accessible_p (tree reference, tree member, tree where, int from_super)
10076 {
10077   int access_flag = get_access_flags_from_decl (member);
10078 
10079   /* Inner classes are processed by check_inner_class_access */
10080   if (INNER_CLASS_TYPE_P (reference))
10081     return 0;
10082 
10083   /* Access always granted for members declared public */
10084   if (access_flag & ACC_PUBLIC)
10085     return 0;
10086 
10087   /* Check access on protected members */
10088   if (access_flag & ACC_PROTECTED)
10089     {
10090       /* Access granted if it occurs from within the package
10091          containing the class in which the protected member is
10092          declared */
10093       if (class_in_current_package (DECL_CONTEXT (member)))
10094 	return 0;
10095 
10096       /* If accessed with the form `super.member', then access is granted */
10097       if (from_super)
10098 	return 0;
10099 
10100       /* If where is active, access was made through a
10101 	 qualifier. Access is granted if the type of the qualifier is
10102 	 or is a sublass of the type the access made from (6.6.2.1.)  */
10103       if (where && !inherits_from_p (reference, where))
10104 	return 1;
10105 
10106       /* Otherwise, access is granted if occurring from the class where
10107 	 member is declared or a subclass of it. Find the right
10108 	 context to perform the check */
10109       if (PURE_INNER_CLASS_TYPE_P (reference))
10110         {
10111           while (INNER_CLASS_TYPE_P (reference))
10112             {
10113               if (inherits_from_p (reference, DECL_CONTEXT (member)))
10114                 return 0;
10115               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10116             }
10117         }
10118       if (inherits_from_p (reference, DECL_CONTEXT (member)))
10119 	return 0;
10120       return 1;
10121     }
10122 
10123   /* Check access on private members. Access is granted only if it
10124      occurs from within the class in which it is declared -- that does
10125      it for innerclasses too. */
10126   if (access_flag & ACC_PRIVATE)
10127     {
10128       if (reference == DECL_CONTEXT (member))
10129 	return 0;
10130       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10131 	return 0;
10132       return 1;
10133     }
10134 
10135   /* Default access are permitted only when occurring within the
10136      package in which the type (REFERENCE) is declared. In other words,
10137      REFERENCE is defined in the current package */
10138   if (ctxp->package)
10139     return !class_in_current_package (reference);
10140 
10141   /* Otherwise, access is granted */
10142   return 0;
10143 }
10144 
10145 /* Test deprecated decl access.  */
10146 static void
check_deprecation(tree wfl,tree decl)10147 check_deprecation (tree wfl, tree decl)
10148 {
10149   const char *file;
10150   tree elt;
10151 
10152   if (! flag_deprecated)
10153     return;
10154 
10155   /* We want to look at the element type of arrays here, so we strip
10156      all surrounding array types.  */
10157   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10158     {
10159       elt = TREE_TYPE (decl);
10160       while (TYPE_ARRAY_P (elt))
10161 	elt = TYPE_ARRAY_ELEMENT (elt);
10162       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10163 	 to the record.  */
10164       decl = TYPE_NAME (TREE_TYPE (elt));
10165     }
10166   file = DECL_SOURCE_FILE (decl);
10167 
10168   /* Complain if the field is deprecated and the file it was defined
10169      in isn't compiled at the same time the file which contains its
10170      use is */
10171   if (DECL_DEPRECATED (decl)
10172       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10173     {
10174       const char *the;
10175       switch (TREE_CODE (decl))
10176 	{
10177 	case FUNCTION_DECL:
10178 	  the = "method";
10179 	  break;
10180 	case FIELD_DECL:
10181 	case VAR_DECL:
10182 	  the = "field";
10183 	  break;
10184 	case TYPE_DECL:
10185 	  parse_warning_context (wfl, "The class `%s' has been deprecated",
10186 				 IDENTIFIER_POINTER (DECL_NAME (decl)));
10187 	  return;
10188 	default:
10189 	  abort ();
10190 	}
10191       /* Don't issue a message if the context as been deprecated as a
10192          whole. */
10193       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10194 	parse_warning_context
10195 	  (wfl, "The %s `%s' in class `%s' has been deprecated",
10196 	   the, lang_printable_name (decl, 0),
10197 	   IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10198     }
10199 }
10200 
10201 /* Returns 1 if class was declared in the current package, 0 otherwise */
10202 
10203 static GTY(()) tree cicp_cache;
10204 static int
class_in_current_package(tree class)10205 class_in_current_package (tree class)
10206 {
10207   int qualified_flag;
10208   tree left;
10209 
10210   if (cicp_cache == class)
10211     return 1;
10212 
10213   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10214 
10215   /* If the current package is empty and the name of CLASS is
10216      qualified, class isn't in the current package.  If there is a
10217      current package and the name of the CLASS is not qualified, class
10218      isn't in the current package */
10219   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10220     return 0;
10221 
10222   /* If there is not package and the name of CLASS isn't qualified,
10223      they belong to the same unnamed package */
10224   if (!ctxp->package && !qualified_flag)
10225     return 1;
10226 
10227   /* Compare the left part of the name of CLASS with the package name */
10228   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10229   if (ctxp->package == left)
10230     {
10231       cicp_cache = class;
10232       return 1;
10233     }
10234   return 0;
10235 }
10236 
10237 /* This function may generate code to access DECL from WHERE. This is
10238    done only if certain conditions meet.  */
10239 
10240 static tree
maybe_access_field(tree decl,tree where,tree type)10241 maybe_access_field (tree decl, tree where, tree type)
10242 {
10243   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10244       && !FIELD_STATIC (decl))
10245     decl = build_field_ref (where ? where : current_this,
10246 			    (type ? type : DECL_CONTEXT (decl)),
10247 			    DECL_NAME (decl));
10248   return decl;
10249 }
10250 
10251 /* Build a method invocation, by patching PATCH. If non NULL
10252    and according to the situation, PRIMARY and WHERE may be
10253    used. IS_STATIC is set to 1 if the invoked function is static. */
10254 
10255 static tree
patch_method_invocation(tree patch,tree primary,tree where,int from_super,int * is_static,tree * ret_decl)10256 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10257 			 int *is_static, tree *ret_decl)
10258 {
10259   tree wfl = TREE_OPERAND (patch, 0);
10260   tree args = TREE_OPERAND (patch, 1);
10261   tree name = EXPR_WFL_NODE (wfl);
10262   tree list;
10263   int is_static_flag = 0;
10264   int is_super_init = 0;
10265   tree this_arg = NULL_TREE;
10266   int is_array_clone_call = 0;
10267 
10268   /* Should be overridden if everything goes well. Otherwise, if
10269      something fails, it should keep this value. It stop the
10270      evaluation of a bogus assignment. See java_complete_tree,
10271      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10272      evaluating an assignment */
10273   TREE_TYPE (patch) = error_mark_node;
10274 
10275   /* Since lookup functions are messing with line numbers, save the
10276      context now.  */
10277   java_parser_context_save_global ();
10278 
10279   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10280 
10281   /* Resolution of qualified name, excluding constructors */
10282   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10283     {
10284       tree identifier, identifier_wfl, type, resolved;
10285       /* Extract the last IDENTIFIER of the qualified
10286 	 expression. This is a wfl and we will use it's location
10287 	 data during error report. */
10288       identifier_wfl = cut_identifier_in_qualified (wfl);
10289       identifier = EXPR_WFL_NODE (identifier_wfl);
10290 
10291       /* Given the context, IDENTIFIER is syntactically qualified
10292 	 as a MethodName. We need to qualify what's before */
10293       qualify_ambiguous_name (wfl);
10294       resolved = resolve_field_access (wfl, NULL, NULL);
10295 
10296       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10297          && FIELD_FINAL (resolved)
10298          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10299          && !flag_emit_class_files && !flag_emit_xref)
10300        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10301 
10302       if (resolved == error_mark_node)
10303 	PATCH_METHOD_RETURN_ERROR ();
10304 
10305       type = GET_SKIP_TYPE (resolved);
10306       resolve_and_layout (type, NULL_TREE);
10307 
10308       if (JPRIMITIVE_TYPE_P (type))
10309         {
10310 	  parse_error_context
10311 	    (identifier_wfl,
10312 	     "Can't invoke a method on primitive type `%s'",
10313 	     IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10314 	  PATCH_METHOD_RETURN_ERROR ();
10315 	}
10316 
10317       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10318       args = nreverse (args);
10319 
10320       /* We're resolving a call from a type */
10321       if (TREE_CODE (resolved) == TYPE_DECL)
10322 	{
10323 	  if (CLASS_INTERFACE (resolved))
10324 	    {
10325 	      parse_error_context
10326 		(identifier_wfl,
10327 		"Can't make static reference to method `%s' in interface `%s'",
10328 		 IDENTIFIER_POINTER (identifier),
10329 		 IDENTIFIER_POINTER (name));
10330 	      PATCH_METHOD_RETURN_ERROR ();
10331 	    }
10332 	  if (list && !METHOD_STATIC (list))
10333 	    {
10334 	      char *fct_name = xstrdup (lang_printable_name (list, 0));
10335 	      parse_error_context
10336 		(identifier_wfl,
10337 		 "Can't make static reference to method `%s %s' in class `%s'",
10338 		 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10339 		 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10340 	      free (fct_name);
10341 	      PATCH_METHOD_RETURN_ERROR ();
10342 	    }
10343 	}
10344       else
10345 	this_arg = primary = resolved;
10346 
10347       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10348         is_array_clone_call = 1;
10349 
10350       /* IDENTIFIER_WFL will be used to report any problem further */
10351       wfl = identifier_wfl;
10352     }
10353   /* Resolution of simple names, names generated after a primary: or
10354      constructors */
10355   else
10356     {
10357       tree class_to_search = NULL_TREE;
10358       int lc;			/* Looking for Constructor */
10359 
10360       /* We search constructor in their target class */
10361       if (CALL_CONSTRUCTOR_P (patch))
10362 	{
10363 	  if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10364 	    class_to_search = EXPR_WFL_NODE (wfl);
10365 	  else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10366 		   this_identifier_node)
10367 	    class_to_search = NULL_TREE;
10368 	  else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10369 		   super_identifier_node)
10370 	    {
10371 	      is_super_init = 1;
10372 	      if (CLASSTYPE_SUPER (current_class))
10373 		class_to_search =
10374 		  DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10375 	      else
10376 		{
10377 		  parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10378 		  PATCH_METHOD_RETURN_ERROR ();
10379 		}
10380 	    }
10381 
10382 	  /* Class to search is NULL if we're searching the current one */
10383 	  if (class_to_search)
10384 	    {
10385 	      class_to_search = resolve_and_layout (class_to_search, wfl);
10386 
10387 	      if (!class_to_search)
10388 		{
10389 		  parse_error_context
10390 		    (wfl, "Class `%s' not found in type declaration",
10391 		     IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10392 		  PATCH_METHOD_RETURN_ERROR ();
10393 		}
10394 
10395 	      /* Can't instantiate an abstract class, but we can
10396 	         invoke it's constructor. It's use within the `new'
10397 	         context is denied here. */
10398 	      if (CLASS_ABSTRACT (class_to_search)
10399 		  && TREE_CODE (patch) == NEW_CLASS_EXPR)
10400 		{
10401 		  parse_error_context
10402 		    (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10403 		     IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10404 		  PATCH_METHOD_RETURN_ERROR ();
10405 		}
10406 
10407 	      class_to_search = TREE_TYPE (class_to_search);
10408 	    }
10409 	  else
10410 	    class_to_search = current_class;
10411 	  lc = 1;
10412 	}
10413       /* This is a regular search in the local class, unless an
10414          alternate class is specified. */
10415       else
10416 	{
10417 	  if (where != NULL_TREE)
10418 	    class_to_search = where;
10419 	  else if (QUALIFIED_P (name))
10420 	    class_to_search = current_class;
10421 	  else
10422 	    {
10423 	      class_to_search = current_class;
10424 
10425 	      for (;;)
10426 		{
10427 		  if (has_method (class_to_search, name))
10428 		    break;
10429 		  if (! INNER_CLASS_TYPE_P (class_to_search))
10430 		    {
10431 		      parse_error_context (wfl,
10432 					   "No method named `%s' in scope",
10433 					   IDENTIFIER_POINTER (name));
10434 		      PATCH_METHOD_RETURN_ERROR ();
10435 		    }
10436 		  class_to_search
10437 		    = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10438 		}
10439 	    }
10440 	  lc = 0;
10441 	}
10442 
10443       /* NAME is a simple identifier or comes from a primary. Search
10444 	 in the class whose declaration contain the method being
10445 	 invoked. */
10446       resolve_and_layout (class_to_search, NULL_TREE);
10447 
10448       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10449       /* Don't continue if no method were found, as the next statement
10450          can't be executed then. */
10451       if (!list)
10452 	PATCH_METHOD_RETURN_ERROR ();
10453 
10454       if (TYPE_ARRAY_P (class_to_search)
10455           && DECL_NAME (list) == get_identifier ("clone"))
10456         is_array_clone_call = 1;
10457 
10458       /* Check for static reference if non static methods */
10459       if (check_for_static_method_reference (wfl, patch, list,
10460 					     class_to_search, primary))
10461 	PATCH_METHOD_RETURN_ERROR ();
10462 
10463       /* Check for inner classes creation from illegal contexts */
10464       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10465 		 && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10466 	  && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10467 	  && !DECL_INIT_P (current_function_decl))
10468 	{
10469 	  parse_error_context
10470 	    (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10471 	     lang_printable_name (class_to_search, 0),
10472 	     (!current_this ? "" :
10473 	      "; an explicit one must be provided when creating this inner class"));
10474 	  PATCH_METHOD_RETURN_ERROR ();
10475 	}
10476 
10477       /* Non static methods are called with the current object extra
10478 	 argument. If patch a `new TYPE()', the argument is the value
10479 	 returned by the object allocator. If method is resolved as a
10480 	 primary, use the primary otherwise use the current THIS. */
10481       args = nreverse (args);
10482       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10483 	{
10484 	  this_arg = primary ? primary : current_this;
10485 
10486 	  /* If we're using an access method, things are different.
10487 	     There are two family of cases:
10488 
10489 	     1) We're not generating bytecodes:
10490 
10491 	     - LIST is non static. It's invocation is transformed from
10492 	       x(a1,...,an) into this$<n>.x(a1,....an).
10493 	     - LIST is static. It's invocation is transformed from
10494 	       x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10495 
10496 	     2) We're generating bytecodes:
10497 
10498 	     - LIST is non static. It's invocation is transformed from
10499 	       x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10500 	     - LIST is static. It's invocation is transformed from
10501 	       x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10502 
10503 	     Of course, this$<n> can be arbitrarily complex, ranging from
10504 	     this$0 (the immediate outer context) to
10505 	     access$0(access$0(...(this$0))).
10506 
10507 	     maybe_use_access_method returns a nonzero value if the
10508 	     this_arg has to be moved into the (then generated) stub
10509 	     argument list. In the meantime, the selected function
10510 	     might have be replaced by a generated stub. */
10511 	  if (!primary &&
10512 	      maybe_use_access_method (is_super_init, &list, &this_arg))
10513 	    {
10514 	      args = tree_cons (NULL_TREE, this_arg, args);
10515 	      this_arg = NULL_TREE; /* So it doesn't get chained twice */
10516 	    }
10517 	}
10518     }
10519 
10520   /* Merge point of all resolution schemes. If we have nothing, this
10521      is an error, already signaled */
10522   if (!list)
10523     PATCH_METHOD_RETURN_ERROR ();
10524 
10525   /* Check accessibility, position the is_static flag, build and
10526      return the call */
10527   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10528 			(primary ? TREE_TYPE (TREE_TYPE (primary)) :
10529 			 NULL_TREE), from_super)
10530       /* Calls to clone() on array types are permitted as a special-case. */
10531       && !is_array_clone_call)
10532     {
10533       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10534       const char *const access =
10535 	java_accstring_lookup (get_access_flags_from_decl (list));
10536       const char *const klass =
10537 	IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10538       const char *const refklass =
10539 	IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10540       const char *const what = (DECL_CONSTRUCTOR_P (list)
10541 				? "constructor" : "method");
10542       /* FIXME: WFL yields the wrong message here but I don't know
10543 	 what else to use.  */
10544       parse_error_context (wfl,
10545 			   "Can't access %s %s `%s.%s' from `%s'",
10546 			   access, what, klass, fct_name, refklass);
10547       PATCH_METHOD_RETURN_ERROR ();
10548     }
10549 
10550   /* Deprecation check: check whether the method being invoked or the
10551      instance-being-created's type are deprecated.  */
10552   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10553     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10554   check_deprecation (wfl, list);
10555 
10556   /* If invoking a innerclass constructor, there are hidden parameters
10557      to pass */
10558   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10559       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10560     {
10561       /* And make sure we add the accessed local variables to be saved
10562 	 in field aliases. */
10563       args = build_alias_initializer_parameter_list
10564 	(AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10565 
10566       /* Secretly pass the current_this/primary as a second argument */
10567       if (primary || current_this)
10568 	{
10569 	  tree extra_arg;
10570 	  tree this_type = (current_this ?
10571 			    TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10572 	  /* Method's (list) enclosing context */
10573 	  tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10574 	  /* If we have a primary, use it. */
10575 	  if (primary)
10576 	    extra_arg = primary;
10577 	  /* The current `this' is an inner class but isn't a direct
10578 	     enclosing context for the inner class we're trying to
10579 	     create. Build an access to the proper enclosing context
10580 	     and use it. */
10581 	  else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10582 		   && this_type != TREE_TYPE (mec))
10583 	    {
10584 
10585 	      extra_arg = build_access_to_thisn (current_class,
10586 						 TREE_TYPE (mec), 0);
10587 	      extra_arg = java_complete_tree (extra_arg);
10588 	    }
10589 	  /* Otherwise, just use the current `this' as an enclosing
10590              context. */
10591 	  else
10592 	    extra_arg = current_this;
10593 	  args = tree_cons (NULL_TREE, extra_arg, args);
10594 	}
10595       else
10596 	args = tree_cons (NULL_TREE, integer_zero_node, args);
10597     }
10598 
10599   /* This handles the situation where a constructor invocation needs
10600      to have an enclosing context passed as a second parameter (the
10601      constructor is one of an inner class). */
10602   if ((is_super_init ||
10603        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10604       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10605     {
10606       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10607       tree extra_arg =
10608 	build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10609       extra_arg = java_complete_tree (extra_arg);
10610       args = tree_cons (NULL_TREE, extra_arg, args);
10611     }
10612 
10613   is_static_flag = METHOD_STATIC (list);
10614   if (! is_static_flag && this_arg != NULL_TREE)
10615     args = tree_cons (NULL_TREE, this_arg, args);
10616 
10617   /* In the context of an explicit constructor invocation, we can't
10618      invoke any method relying on `this'. Exceptions are: we're
10619      invoking a static function, primary exists and is not the current
10620      this, we're creating a new object. */
10621   if (ctxp->explicit_constructor_p
10622       && !is_static_flag
10623       && (!primary || primary == current_this)
10624       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10625     {
10626       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10627       PATCH_METHOD_RETURN_ERROR ();
10628     }
10629   java_parser_context_restore_global ();
10630   if (is_static)
10631     *is_static = is_static_flag;
10632   /* Sometimes, we want the decl of the selected method. Such as for
10633      EH checking */
10634   if (ret_decl)
10635     *ret_decl = list;
10636   patch = patch_invoke (patch, list, args);
10637 
10638   /* Now is a good time to insert the call to finit$ */
10639   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10640     {
10641       tree finit_parms, finit_call;
10642 
10643       /* Prepare to pass hidden parameters to finit$, if any. */
10644       finit_parms = build_alias_initializer_parameter_list
10645 	(AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10646 
10647       finit_call =
10648 	build_method_invocation (build_wfl_node (finit_identifier_node),
10649 				 finit_parms);
10650 
10651       /* Generate the code used to initialize fields declared with an
10652 	 initialization statement and build a compound statement along
10653 	 with the super constructor invocation. */
10654       CAN_COMPLETE_NORMALLY (patch) = 1;
10655       patch = build (COMPOUND_EXPR, void_type_node, patch,
10656 		     java_complete_tree (finit_call));
10657     }
10658   return patch;
10659 }
10660 
10661 /* Check that we're not trying to do a static reference to a method in
10662    non static method. Return 1 if it's the case, 0 otherwise. */
10663 
10664 static int
check_for_static_method_reference(tree wfl,tree node,tree method,tree where,tree primary)10665 check_for_static_method_reference (tree wfl, tree node, tree method,
10666 				   tree where, tree primary)
10667 {
10668   if (METHOD_STATIC (current_function_decl)
10669       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10670     {
10671       char *fct_name = xstrdup (lang_printable_name (method, 0));
10672       parse_error_context
10673 	(wfl, "Can't make static reference to method `%s %s' in class `%s'",
10674 	 lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10675 	 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10676       free (fct_name);
10677       return 1;
10678     }
10679   return 0;
10680 }
10681 
10682 /* Fix the invocation of *MDECL if necessary in the case of a
10683    invocation from an inner class. *THIS_ARG might be modified
10684    appropriately and an alternative access to *MDECL might be
10685    returned.  */
10686 
10687 static int
maybe_use_access_method(int is_super_init,tree * mdecl,tree * this_arg)10688 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10689 {
10690   tree ctx;
10691   tree md = *mdecl, ta = *this_arg;
10692   int to_return = 0;
10693   int non_static_context = !METHOD_STATIC (md);
10694 
10695   if (is_super_init
10696       || DECL_CONTEXT (md) == current_class
10697       || !PURE_INNER_CLASS_TYPE_P (current_class)
10698       || DECL_FINIT_P (md)
10699       || DECL_INSTINIT_P (md))
10700     return 0;
10701 
10702   /* If we're calling a method found in an enclosing class, generate
10703      what it takes to retrieve the right this. Don't do that if we're
10704      invoking a static method. Note that if MD's type is unrelated to
10705      CURRENT_CLASS, then the current this can be used. */
10706 
10707   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10708     {
10709       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10710       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10711 	{
10712 	  ta = build_current_thisn (current_class);
10713 	  ta = build_wfl_node (ta);
10714 	}
10715       else
10716 	{
10717 	  tree type = ctx;
10718 	  while (type)
10719 	    {
10720 	      maybe_build_thisn_access_method (type);
10721 	      if (inherits_from_p (type, DECL_CONTEXT (md)))
10722 		{
10723 		  ta = build_access_to_thisn (ctx, type, 0);
10724 		  break;
10725 		}
10726 	      type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10727 		      TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10728 	    }
10729 	}
10730       ta = java_complete_tree (ta);
10731     }
10732 
10733   /* We might have to use an access method to get to MD. We can
10734      break the method access rule as far as we're not generating
10735      bytecode */
10736   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10737     {
10738       md = build_outer_method_access_method (md);
10739       to_return = 1;
10740     }
10741 
10742   *mdecl = md;
10743   *this_arg = ta;
10744 
10745   /* Returning a nonzero value indicates we were doing a non static
10746      method invocation that is now a static invocation. It will have
10747      callee displace `this' to insert it in the regular argument
10748      list. */
10749   return (non_static_context && to_return);
10750 }
10751 
10752 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10753    mode.  */
10754 
10755 static tree
patch_invoke(tree patch,tree method,tree args)10756 patch_invoke (tree patch, tree method, tree args)
10757 {
10758   tree dtable, func;
10759   tree original_call, t, ta;
10760   tree check = NULL_TREE;
10761 
10762   /* Last step for args: convert build-in types. If we're dealing with
10763      a new TYPE() type call, the first argument to the constructor
10764      isn't found in the incoming argument list, but delivered by
10765      `new' */
10766   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10767   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10768     t = TREE_CHAIN (t);
10769   for (ta = args; t != end_params_node && ta;
10770        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10771     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10772 	TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10773       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10774 
10775   /* Resolve unresolved returned type issues */
10776   t = TREE_TYPE (TREE_TYPE (method));
10777   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10778     resolve_and_layout (TREE_TYPE (t), NULL);
10779 
10780   if (flag_emit_class_files || flag_emit_xref)
10781     func = method;
10782   else
10783     {
10784       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10785 	{
10786 	case INVOKE_VIRTUAL:
10787 	  dtable = invoke_build_dtable (0, args);
10788 	  func = build_invokevirtual (dtable, method);
10789 	  break;
10790 
10791 	case INVOKE_NONVIRTUAL:
10792 	  /* If the object for the method call is null, we throw an
10793 	     exception.  We don't do this if the object is the current
10794 	     method's `this'.  In other cases we just rely on an
10795 	     optimization pass to eliminate redundant checks.  */
10796 	  if (TREE_VALUE (args) != current_this)
10797 	    {
10798 	      /* We use a save_expr here to make sure we only evaluate
10799 		 the new `self' expression once.  */
10800 	      tree save_arg = save_expr (TREE_VALUE (args));
10801 	      TREE_VALUE (args) = save_arg;
10802 	      check = java_check_reference (save_arg, 1);
10803 	    }
10804 	  /* Fall through.  */
10805 
10806 	case INVOKE_SUPER:
10807 	case INVOKE_STATIC:
10808 	  {
10809 	    tree signature = build_java_signature (TREE_TYPE (method));
10810 	    func = build_known_method_ref (method, TREE_TYPE (method),
10811 					   DECL_CONTEXT (method),
10812 					   signature, args);
10813 	  }
10814 	  break;
10815 
10816 	case INVOKE_INTERFACE:
10817 	  dtable = invoke_build_dtable (1, args);
10818 	  func = build_invokeinterface (dtable, method);
10819 	  break;
10820 
10821 	default:
10822 	  abort ();
10823 	}
10824 
10825       /* Ensure self_type is initialized, (invokestatic). FIXME */
10826       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10827     }
10828 
10829   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10830   TREE_OPERAND (patch, 0) = func;
10831   TREE_OPERAND (patch, 1) = args;
10832   patch = check_for_builtin (method, patch);
10833   original_call = patch;
10834 
10835   /* We're processing a `new TYPE ()' form. New is called and its
10836      returned value is the first argument to the constructor. We build
10837      a COMPOUND_EXPR and use saved expression so that the overall NEW
10838      expression value is a pointer to a newly created and initialized
10839      class. */
10840   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10841     {
10842       tree class = DECL_CONTEXT (method);
10843       tree c1, saved_new, size, new;
10844       tree alloc_node;
10845 
10846       if (flag_emit_class_files || flag_emit_xref)
10847 	{
10848 	  TREE_TYPE (patch) = build_pointer_type (class);
10849 	  return patch;
10850 	}
10851       if (!TYPE_SIZE (class))
10852 	safe_layout_class (class);
10853       size = size_in_bytes (class);
10854       alloc_node =
10855 	(class_has_finalize_method (class) ? alloc_object_node
10856 		  			   : alloc_no_finalizer_node);
10857       new = build (CALL_EXPR, promote_type (class),
10858 		   build_address_of (alloc_node),
10859 		   tree_cons (NULL_TREE, build_class_ref (class),
10860 			      build_tree_list (NULL_TREE,
10861 					       size_in_bytes (class))),
10862 		   NULL_TREE);
10863       saved_new = save_expr (new);
10864       c1 = build_tree_list (NULL_TREE, saved_new);
10865       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10866       TREE_OPERAND (original_call, 1) = c1;
10867       TREE_SET_CODE (original_call, CALL_EXPR);
10868       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10869     }
10870 
10871   /* If CHECK is set, then we are building a check to see if the object
10872      is NULL.  */
10873   if (check != NULL_TREE)
10874     {
10875       /* We have to call force_evaluation_order now because creating a
10876  	 COMPOUND_EXPR wraps the arg list in a way that makes it
10877  	 unrecognizable by force_evaluation_order later.  Yuk.  */
10878       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10879  		     force_evaluation_order (patch));
10880       TREE_SIDE_EFFECTS (patch) = 1;
10881     }
10882 
10883   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10884      put it as the first expression of a COMPOUND_EXPR. The second
10885      expression being an empty statement to be later patched if
10886      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10887      the VALUE is the compound) in a hashtable and return a
10888      COMPOUND_EXPR built so that the result of the evaluation of the
10889      original PATCH node is returned. */
10890   if (STATIC_CLASS_INIT_OPT_P ()
10891       && current_function_decl && METHOD_STATIC (method))
10892     {
10893       tree list;
10894       tree fndecl = current_function_decl;
10895       /* We have to call force_evaluation_order now because creating a
10896 	 COMPOUND_EXPR wraps the arg list in a way that makes it
10897 	 unrecognizable by force_evaluation_order later.  Yuk.  */
10898       tree save = save_expr (force_evaluation_order (patch));
10899       tree type = TREE_TYPE (patch);
10900 
10901       patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10902       list = tree_cons (method, patch,
10903 			DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10904 
10905       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10906 
10907       patch = build (COMPOUND_EXPR, type, patch, save);
10908     }
10909 
10910   return patch;
10911 }
10912 
10913 static int
invocation_mode(tree method,int super)10914 invocation_mode (tree method, int super)
10915 {
10916   int access = get_access_flags_from_decl (method);
10917 
10918   if (super)
10919     return INVOKE_SUPER;
10920 
10921   if (access & ACC_STATIC)
10922     return INVOKE_STATIC;
10923 
10924   /* We have to look for a constructor before we handle nonvirtual
10925      calls; otherwise the constructor will look nonvirtual.  */
10926   if (DECL_CONSTRUCTOR_P (method))
10927     return INVOKE_STATIC;
10928 
10929   if (access & ACC_FINAL || access & ACC_PRIVATE)
10930     return INVOKE_NONVIRTUAL;
10931 
10932   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10933     return INVOKE_NONVIRTUAL;
10934 
10935   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10936     return INVOKE_INTERFACE;
10937 
10938   return INVOKE_VIRTUAL;
10939 }
10940 
10941 /* Retrieve a refined list of matching methods. It covers the step
10942    15.11.2 (Compile-Time Step 2) */
10943 
10944 static tree
lookup_method_invoke(int lc,tree cl,tree class,tree name,tree arg_list)10945 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10946 {
10947   tree atl = end_params_node;		/* Arg Type List */
10948   tree method, signature, list, node;
10949   const char *candidates;		/* Used for error report */
10950   char *dup;
10951 
10952   /* Fix the arguments */
10953   for (node = arg_list; node; node = TREE_CHAIN (node))
10954     {
10955       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10956       /* Non primitive type may have to be resolved */
10957       if (!JPRIMITIVE_TYPE_P (current_arg))
10958 	resolve_and_layout (current_arg, NULL_TREE);
10959       /* And promoted */
10960       if (TREE_CODE (current_arg) == RECORD_TYPE)
10961         current_arg = promote_type (current_arg);
10962       atl = tree_cons (NULL_TREE, current_arg, atl);
10963     }
10964 
10965   /* Presto. If we're dealing with an anonymous class and a
10966      constructor call, generate the right constructor now, since we
10967      know the arguments' types. */
10968 
10969   if (lc && ANONYMOUS_CLASS_P (class))
10970     {
10971       tree saved_current_class;
10972       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10973       saved_current_class = current_class;
10974       current_class = class;
10975       fix_constructors (mdecl);
10976       current_class = saved_current_class;
10977     }
10978 
10979   /* Find all candidates and then refine the list, searching for the
10980      most specific method. */
10981   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10982   list = find_most_specific_methods_list (list);
10983   if (list && !TREE_CHAIN (list))
10984     return TREE_VALUE (list);
10985 
10986   /* Issue an error. List candidates if any. Candidates are listed
10987      only if accessible (non accessible methods may end-up here for
10988      the sake of a better error report). */
10989   candidates = NULL;
10990   if (list)
10991     {
10992       tree current;
10993       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10994       for (current = list; current; current = TREE_CHAIN (current))
10995 	{
10996 	  tree cm = TREE_VALUE (current);
10997 	  char string [4096];
10998 	  if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10999 	    continue;
11000 	  sprintf
11001 	    (string, "  `%s' in `%s'%s",
11002 	     get_printable_method_name (cm),
11003 	     IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
11004 	     (TREE_CHAIN (current) ? "\n" : ""));
11005 	  obstack_grow (&temporary_obstack, string, strlen (string));
11006 	}
11007       obstack_1grow (&temporary_obstack, '\0');
11008       candidates = obstack_finish (&temporary_obstack);
11009     }
11010   /* Issue the error message */
11011   method = make_node (FUNCTION_TYPE);
11012   TYPE_ARG_TYPES (method) = atl;
11013   signature = build_java_argument_signature (method);
11014   dup = xstrdup (lang_printable_name (class, 0));
11015   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
11016 		       (lc ? "constructor" : "method"),
11017 		       (lc ? dup : IDENTIFIER_POINTER (name)),
11018 		       IDENTIFIER_POINTER (signature), dup,
11019 		       (candidates ? candidates : ""));
11020   free (dup);
11021   return NULL_TREE;
11022 }
11023 
11024 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11025    when we're looking for a constructor. */
11026 
11027 static tree
find_applicable_accessible_methods_list(int lc,tree class,tree name,tree arglist)11028 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11029 					 tree arglist)
11030 {
11031   static htab_t searched_classes;
11032   static int search_not_done = 0;
11033   tree list = NULL_TREE, all_list = NULL_TREE;
11034 
11035   /* Check the hash table to determine if this class has been searched
11036      already. */
11037   if (searched_classes)
11038     {
11039       if (htab_find (searched_classes, class) != NULL)
11040 	return NULL;
11041     }
11042   else
11043     {
11044       searched_classes = htab_create (10, htab_hash_pointer,
11045 				      htab_eq_pointer, NULL);
11046     }
11047 
11048   search_not_done++;
11049   *htab_find_slot (searched_classes, class, INSERT) = class;
11050 
11051   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
11052     {
11053       load_class (class, 1);
11054       safe_layout_class (class);
11055     }
11056 
11057   /* Search interfaces */
11058   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11059       && CLASS_INTERFACE (TYPE_NAME (class)))
11060     {
11061       int i, n;
11062       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11063       search_applicable_methods_list (lc, TYPE_METHODS (class),
11064 				      name, arglist, &list, &all_list);
11065       n = TREE_VEC_LENGTH (basetype_vec);
11066       for (i = 1; i < n; i++)
11067 	{
11068 	  tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11069 	  tree rlist;
11070 
11071 	  rlist = find_applicable_accessible_methods_list (lc,  t, name,
11072 							   arglist);
11073 	  list = chainon (rlist, list);
11074 	}
11075     }
11076   /* Search classes */
11077   else
11078     {
11079       search_applicable_methods_list (lc, TYPE_METHODS (class),
11080 				      name, arglist, &list, &all_list);
11081 
11082       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11083 	 that we only search in class. Note that we should have found
11084 	 something at this point. */
11085       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11086 	{
11087 	  lc = 1;
11088 	  if (!list)
11089 	    abort ();
11090 	}
11091 
11092       /* We must search all interfaces of this class */
11093       if (!lc)
11094       {
11095 	tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11096 	int n = TREE_VEC_LENGTH (basetype_vec), i;
11097 	for (i = 1; i < n; i++)
11098 	  {
11099 	    tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11100 	    if (t != object_type_node)
11101 	      {
11102 		tree rlist
11103 		  = find_applicable_accessible_methods_list (lc, t,
11104 							     name, arglist);
11105 		list = chainon (rlist, list);
11106 	      }
11107 	  }
11108       }
11109 
11110       /* Search superclass */
11111       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11112 	{
11113           tree rlist;
11114           class = CLASSTYPE_SUPER (class);
11115           rlist = find_applicable_accessible_methods_list (lc, class,
11116                                                            name, arglist);
11117           list = chainon (rlist, list);
11118         }
11119     }
11120 
11121   search_not_done--;
11122 
11123   /* We're done. Reset the searched classes list and finally search
11124      java.lang.Object if it wasn't searched already. */
11125   if (!search_not_done)
11126     {
11127       if (!lc
11128 	  && TYPE_METHODS (object_type_node)
11129 	  && htab_find (searched_classes, object_type_node) == NULL)
11130 	{
11131           search_applicable_methods_list (lc,
11132                                           TYPE_METHODS (object_type_node),
11133                                           name, arglist, &list, &all_list);
11134         }
11135       htab_delete (searched_classes);
11136       searched_classes = NULL;
11137     }
11138 
11139   /* Either return the list obtained or all selected (but
11140      inaccessible) methods for better error report. */
11141   return (!list ? all_list : list);
11142 }
11143 
11144 /* Effectively search for the appropriate method in method */
11145 
11146 static void
search_applicable_methods_list(int lc,tree method,tree name,tree arglist,tree * list,tree * all_list)11147 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11148 				tree *list, tree *all_list)
11149 {
11150   for (; method; method = TREE_CHAIN (method))
11151     {
11152       /* When dealing with constructor, stop here, otherwise search
11153          other classes */
11154       if (lc && !DECL_CONSTRUCTOR_P (method))
11155 	continue;
11156       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11157 		       || (DECL_NAME (method) != name)))
11158 	continue;
11159 
11160       if (argument_types_convertible (method, arglist))
11161 	{
11162 	  /* Retain accessible methods only */
11163 	  if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11164 				 method, NULL_TREE, 0))
11165 	    *list = tree_cons (NULL_TREE, method, *list);
11166 	  else
11167 	    /* Also retain all selected method here */
11168 	    *all_list = tree_cons (NULL_TREE, method, *list);
11169 	}
11170     }
11171 }
11172 
11173 /* 15.11.2.2 Choose the Most Specific Method */
11174 
11175 static tree
find_most_specific_methods_list(tree list)11176 find_most_specific_methods_list (tree list)
11177 {
11178   int max = 0;
11179   int abstract, candidates;
11180   tree current, new_list = NULL_TREE;
11181   for (current = list; current; current = TREE_CHAIN (current))
11182     {
11183       tree method;
11184       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11185 
11186       for (method = list; method; method = TREE_CHAIN (method))
11187 	{
11188 	  tree method_v, current_v;
11189 	  /* Don't test a method against itself */
11190 	  if (method == current)
11191 	    continue;
11192 
11193 	  method_v = TREE_VALUE (method);
11194 	  current_v = TREE_VALUE (current);
11195 
11196 	  /* Compare arguments and location where methods where declared */
11197 	  if (argument_types_convertible (method_v, current_v))
11198 	    {
11199 	      if (valid_method_invocation_conversion_p
11200 		  (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11201 		  || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11202 		      && enclosing_context_p (DECL_CONTEXT (method_v),
11203 					      DECL_CONTEXT (current_v))))
11204 		{
11205 		  int v = (DECL_SPECIFIC_COUNT (current_v) +=
11206 		    (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11207 		  max = (v > max ? v : max);
11208 		}
11209 	    }
11210 	}
11211     }
11212 
11213   /* Review the list and select the maximally specific methods */
11214   for (current = list, abstract = -1, candidates = -1;
11215        current; current = TREE_CHAIN (current))
11216     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11217       {
11218 	new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11219 	abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11220 	candidates++;
11221       }
11222 
11223   /* If we have several and they're all abstract, just pick the
11224      closest one. */
11225   if (candidates > 0 && candidates == abstract)
11226     {
11227       /* FIXME: merge the throws clauses.  There is no convenient way
11228 	 to do this in gcj right now, since ideally we'd like to
11229 	 introduce a new METHOD_DECL here, but that is really not
11230 	 possible.  */
11231       new_list = nreverse (new_list);
11232       TREE_CHAIN (new_list) = NULL_TREE;
11233       return new_list;
11234     }
11235 
11236   /* We have several (we couldn't find a most specific), all but one
11237      are abstract, we pick the only non abstract one. */
11238   if (candidates > 0 && (candidates == abstract+1))
11239     {
11240       for (current = new_list; current; current = TREE_CHAIN (current))
11241 	if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11242 	  {
11243 	    TREE_CHAIN (current) = NULL_TREE;
11244 	    new_list = current;
11245 	  }
11246     }
11247 
11248   /* If we can't find one, lower expectations and try to gather multiple
11249      maximally specific methods */
11250   while (!new_list && max)
11251     {
11252       while (--max > 0)
11253 	{
11254 	  if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11255 	    new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11256 	}
11257     }
11258 
11259   return new_list;
11260 }
11261 
11262 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11263    converted by method invocation conversion (5.3) to the type of the
11264    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11265    to change less often than M1. */
11266 
11267 static GTY(()) tree m2_arg_value;
11268 static GTY(()) tree m2_arg_cache;
11269 
11270 static int
argument_types_convertible(tree m1,tree m2_or_arglist)11271 argument_types_convertible (tree m1, tree m2_or_arglist)
11272 {
11273   tree m1_arg, m2_arg;
11274 
11275   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11276 
11277   if (m2_arg_value == m2_or_arglist)
11278     m2_arg = m2_arg_cache;
11279   else
11280     {
11281       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11282          argument types */
11283       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11284 	{
11285 	  m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11286 	  if (!METHOD_STATIC (m2_or_arglist))
11287 	    m2_arg = TREE_CHAIN (m2_arg);
11288 	}
11289       else
11290 	m2_arg = m2_or_arglist;
11291 
11292       m2_arg_value = m2_or_arglist;
11293       m2_arg_cache = m2_arg;
11294     }
11295 
11296   while (m1_arg != end_params_node && m2_arg != end_params_node)
11297     {
11298       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11299       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11300 						 TREE_VALUE (m2_arg)))
11301 	break;
11302       m1_arg = TREE_CHAIN (m1_arg);
11303       m2_arg = TREE_CHAIN (m2_arg);
11304     }
11305   return m1_arg == end_params_node && m2_arg == end_params_node;
11306 }
11307 
11308 /* Qualification routines */
11309 
11310 /* Given a name x.y.z, look up x locally.  If it's found, save the
11311    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11312    so that we later try and load the appropriate classes.  */
11313 static void
qualify_ambiguous_name(tree id)11314 qualify_ambiguous_name (tree id)
11315 {
11316   tree name, decl;
11317 
11318   /* We inspect the first item of the qualification list.  As a sanity
11319      check, make sure that it is an identfier node.  */
11320   tree qual = EXPR_WFL_QUALIFICATION (id);
11321   tree qual_wfl = QUAL_WFL (qual);
11322 
11323   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11324     return;
11325 
11326   name = EXPR_WFL_NODE (qual_wfl);
11327 
11328   /* If we don't have an identifier, or we have a 'this' or 'super',
11329      then field access processing is all we need : there is nothing
11330      for us to do.  */
11331   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11332       name == this_identifier_node ||
11333       name == super_identifier_node)
11334     return;
11335 
11336   /* If name appears within the scope of a local variable declaration
11337      or parameter declaration, or is a field within an enclosing
11338      class, then it is an expression name.  Save the decl and let
11339      resolve_field_access do it's work.  */
11340   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11341       (decl = lookup_field_wrapper (current_class, name)))
11342     {
11343       QUAL_RESOLUTION (qual) = decl;
11344       return;
11345     }
11346 
11347   /* If name is a known class name (either declared or imported), mark
11348      us as a type name.  */
11349   if ((decl = resolve_and_layout (name, NULL_TREE)))
11350     {
11351       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11352       QUAL_RESOLUTION (qual) = decl;
11353     }
11354 
11355   /* Check here that NAME isn't declared by more than one
11356      type-import-on-demand declaration of the compilation unit
11357      containing NAME. FIXME */
11358 
11359   /* We couldn't find a declaration for the name.  Assume for now that
11360      we have a qualified class name that needs to be loaded from an
11361      external class file.  */
11362   else
11363     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11364 
11365   /* Propagate the qualification across other components of the
11366      qualified name */
11367   for (qual = TREE_CHAIN (qual); qual;
11368        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11369     {
11370       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11371 	RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11372     }
11373 
11374   /* Store the global qualification for the ambiguous part of ID back
11375      into ID fields */
11376   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11377     RESOLVE_TYPE_NAME_P (id) = 1;
11378   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11379     RESOLVE_PACKAGE_NAME_P (id) = 1;
11380 }
11381 
11382 static int
breakdown_qualified(tree * left,tree * right,tree source)11383 breakdown_qualified (tree *left, tree *right, tree source)
11384 {
11385   char *p, *base;
11386   int l = IDENTIFIER_LENGTH (source);
11387 
11388   base = alloca (l + 1);
11389   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11390 
11391   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11392   p = base + l - 1;
11393   while (*p != '.' && p != base)
11394     p--;
11395 
11396   /* We didn't find a '.'. Return an error.  */
11397   if (p == base)
11398     return 1;
11399 
11400   *p = '\0';
11401   if (right)
11402     *right = get_identifier (p+1);
11403   *left = get_identifier (base);
11404 
11405   return 0;
11406 }
11407 
11408 /* Return TRUE if two classes are from the same package. */
11409 
11410 static int
in_same_package(tree name1,tree name2)11411 in_same_package (tree name1, tree name2)
11412 {
11413   tree tmp;
11414   tree pkg1;
11415   tree pkg2;
11416 
11417   if (TREE_CODE (name1) == TYPE_DECL)
11418     name1 = DECL_NAME (name1);
11419   if (TREE_CODE (name2) == TYPE_DECL)
11420     name2 = DECL_NAME (name2);
11421 
11422   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11423     /* One in empty package. */
11424     return 0;
11425 
11426   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11427     /* Both in empty package. */
11428     return 1;
11429 
11430   breakdown_qualified (&pkg1, &tmp, name1);
11431   breakdown_qualified (&pkg2, &tmp, name2);
11432 
11433   return (pkg1 == pkg2);
11434 }
11435 
11436 /* Patch tree nodes in a function body. When a BLOCK is found, push
11437    local variable decls if present.
11438    Same as java_complete_lhs, but does resolve static finals to values. */
11439 
11440 static tree
java_complete_tree(tree node)11441 java_complete_tree (tree node)
11442 {
11443   node = java_complete_lhs (node);
11444   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11445       && DECL_INITIAL (node) != NULL_TREE
11446       && !flag_emit_xref)
11447     {
11448       tree value = fold_constant_for_init (node, node);
11449       if (value != NULL_TREE)
11450 	return value;
11451     }
11452   return node;
11453 }
11454 
11455 static tree
java_stabilize_reference(tree node)11456 java_stabilize_reference (tree node)
11457 {
11458   if (TREE_CODE (node) == COMPOUND_EXPR)
11459     {
11460       tree op0 = TREE_OPERAND (node, 0);
11461       tree op1 = TREE_OPERAND (node, 1);
11462       TREE_OPERAND (node, 0) = save_expr (op0);
11463       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11464       return node;
11465     }
11466   return stabilize_reference (node);
11467 }
11468 
11469 /* Patch tree nodes in a function body. When a BLOCK is found, push
11470    local variable decls if present.
11471    Same as java_complete_tree, but does not resolve static finals to values. */
11472 
11473 static tree
java_complete_lhs(tree node)11474 java_complete_lhs (tree node)
11475 {
11476   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11477   int flag;
11478 
11479   /* CONVERT_EXPR always has its type set, even though it needs to be
11480      worked out. */
11481   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11482     return node;
11483 
11484   /* The switch block implements cases processing container nodes
11485      first.  Contained nodes are always written back. Leaves come
11486      next and return a value. */
11487   switch (TREE_CODE (node))
11488     {
11489     case BLOCK:
11490 
11491       /* 1- Block section.
11492 	 Set the local values on decl names so we can identify them
11493 	 faster when they're referenced. At that stage, identifiers
11494 	 are legal so we don't check for declaration errors. */
11495       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11496 	{
11497 	  DECL_CONTEXT (cn) = current_function_decl;
11498 	  IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11499 	}
11500       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11501 	  CAN_COMPLETE_NORMALLY (node) = 1;
11502       else
11503 	{
11504 	  tree stmt = BLOCK_EXPR_BODY (node);
11505 	  tree *ptr;
11506 	  int error_seen = 0;
11507 	  if (TREE_CODE (stmt) == COMPOUND_EXPR)
11508 	    {
11509 	      /* Re-order from (((A; B); C); ...; Z) to
11510 		 (A; (B; (C ; (...; Z)))).
11511 		 This makes it easier to scan the statements left-to-right
11512 		 without using recursion (which might overflow the stack
11513 		 if the block has many statements. */
11514 	      for (;;)
11515 		{
11516 		  tree left = TREE_OPERAND (stmt, 0);
11517 		  if (TREE_CODE (left) != COMPOUND_EXPR)
11518 		    break;
11519 		  TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11520 		  TREE_OPERAND (left, 1) = stmt;
11521 		  stmt = left;
11522 		}
11523 	      BLOCK_EXPR_BODY (node) = stmt;
11524 	    }
11525 
11526 	  /* Now do the actual complete, without deep recursion for
11527              long blocks. */
11528 	  ptr = &BLOCK_EXPR_BODY (node);
11529 	  while (TREE_CODE (*ptr) == COMPOUND_EXPR
11530 		 && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11531 	    {
11532 	      tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11533 	      tree *next = &TREE_OPERAND (*ptr, 1);
11534 	      TREE_OPERAND (*ptr, 0) = cur;
11535 	      if (cur == empty_stmt_node)
11536 		{
11537 		  /* Optimization;  makes it easier to detect empty bodies.
11538 		     Most useful for <clinit> with all-constant initializer. */
11539 		  *ptr = *next;
11540 		  continue;
11541 		}
11542 	      if (TREE_CODE (cur) == ERROR_MARK)
11543 		error_seen++;
11544 	      else if (! CAN_COMPLETE_NORMALLY (cur))
11545 		{
11546 		  wfl_op2 = *next;
11547 		  for (;;)
11548 		    {
11549 		      if (TREE_CODE (wfl_op2) == BLOCK)
11550 			wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11551 		      else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11552 			wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11553 		      else
11554 			break;
11555 		    }
11556 		  if (TREE_CODE (wfl_op2) != CASE_EXPR
11557 		      && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11558 		    unreachable_stmt_error (*ptr);
11559 		}
11560 	      if (TREE_TYPE (*ptr) == NULL_TREE)
11561 		TREE_TYPE (*ptr) = void_type_node;
11562 	      ptr = next;
11563 	    }
11564 	  *ptr = java_complete_tree (*ptr);
11565 
11566 	  if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11567 	    return error_mark_node;
11568 	  CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11569 	}
11570       /* Turn local bindings to null */
11571       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11572 	IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11573 
11574       TREE_TYPE (node) = void_type_node;
11575       break;
11576 
11577       /* 2- They are expressions but ultimately deal with statements */
11578 
11579     case THROW_EXPR:
11580       wfl_op1 = TREE_OPERAND (node, 0);
11581       COMPLETE_CHECK_OP_0 (node);
11582       /* 14.19 A throw statement cannot complete normally. */
11583       CAN_COMPLETE_NORMALLY (node) = 0;
11584       return patch_throw_statement (node, wfl_op1);
11585 
11586     case SYNCHRONIZED_EXPR:
11587       wfl_op1 = TREE_OPERAND (node, 0);
11588       return patch_synchronized_statement (node, wfl_op1);
11589 
11590     case TRY_EXPR:
11591       return patch_try_statement (node);
11592 
11593     case TRY_FINALLY_EXPR:
11594       COMPLETE_CHECK_OP_0 (node);
11595       COMPLETE_CHECK_OP_1 (node);
11596       /* Reduce try/finally nodes with an empty try block.  */
11597       if (TREE_OPERAND (node, 0) == empty_stmt_node
11598 	  || BLOCK_EMPTY_P (TREE_OPERAND (node, 0)))
11599 	return TREE_OPERAND (node, 1);
11600       /* Likewise for an empty finally block.  */
11601       if (TREE_OPERAND (node, 1) == empty_stmt_node
11602 	  || BLOCK_EMPTY_P (TREE_OPERAND (node, 1)))
11603 	return TREE_OPERAND (node, 0);
11604       CAN_COMPLETE_NORMALLY (node)
11605 	= (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11606 	   && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11607       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11608       return node;
11609 
11610     case LABELED_BLOCK_EXPR:
11611       PUSH_LABELED_BLOCK (node);
11612       if (LABELED_BLOCK_BODY (node))
11613 	COMPLETE_CHECK_OP_1 (node);
11614       TREE_TYPE (node) = void_type_node;
11615       POP_LABELED_BLOCK ();
11616 
11617       if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11618 	{
11619 	  LABELED_BLOCK_BODY (node) = NULL_TREE;
11620 	  CAN_COMPLETE_NORMALLY (node) = 1;
11621 	}
11622       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11623 	CAN_COMPLETE_NORMALLY (node) = 1;
11624       return node;
11625 
11626     case EXIT_BLOCK_EXPR:
11627       /* We don't complete operand 1, because it's the return value of
11628          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11629       return patch_bc_statement (node);
11630 
11631     case CASE_EXPR:
11632       cn = java_complete_tree (TREE_OPERAND (node, 0));
11633       if (cn == error_mark_node)
11634 	return cn;
11635 
11636       /* First, the case expression must be constant. Values of final
11637          fields are accepted. */
11638       cn = fold (cn);
11639       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11640 	  && JDECL_P (TREE_OPERAND (cn, 1))
11641 	  && FIELD_FINAL (TREE_OPERAND (cn, 1))
11642 	  && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11643 	{
11644 	  cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11645 				       TREE_OPERAND (cn, 1));
11646 	}
11647       /* Accept final locals too. */
11648       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
11649 	cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11650 
11651       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11652 	{
11653 	  EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11654 	  parse_error_context (node, "Constant expression required");
11655 	  return error_mark_node;
11656 	}
11657 
11658       nn = ctxp->current_loop;
11659 
11660       /* It must be assignable to the type of the switch expression. */
11661       if (!try_builtin_assignconv (NULL_TREE,
11662 				   TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11663 	{
11664 	  EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11665 	  parse_error_context
11666 	    (wfl_operator,
11667 	     "Incompatible type for case. Can't convert `%s' to `int'",
11668 	     lang_printable_name (TREE_TYPE (cn), 0));
11669 	  return error_mark_node;
11670 	}
11671 
11672       cn = fold (convert (int_type_node, cn));
11673       TREE_CONSTANT_OVERFLOW (cn) = 0;
11674       CAN_COMPLETE_NORMALLY (cn) = 1;
11675 
11676       /* Save the label on a list so that we can later check for
11677 	 duplicates.  */
11678       case_label_list = tree_cons (node, cn, case_label_list);
11679 
11680       /* Multiple instance of a case label bearing the same value is
11681 	 checked later. The case expression is all right so far. */
11682       if (TREE_CODE (cn) == VAR_DECL)
11683 	cn = DECL_INITIAL (cn);
11684       TREE_OPERAND (node, 0) = cn;
11685       TREE_TYPE (node) = void_type_node;
11686       CAN_COMPLETE_NORMALLY (node) = 1;
11687       TREE_SIDE_EFFECTS (node) = 1;
11688       break;
11689 
11690     case DEFAULT_EXPR:
11691       nn = ctxp->current_loop;
11692       /* Only one default label is allowed per switch statement */
11693       if (SWITCH_HAS_DEFAULT (nn))
11694 	{
11695 	  EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11696 	  parse_error_context (wfl_operator,
11697 			       "Duplicate case label: `default'");
11698 	  return error_mark_node;
11699 	}
11700       else
11701 	SWITCH_HAS_DEFAULT (nn) = 1;
11702       TREE_TYPE (node) = void_type_node;
11703       TREE_SIDE_EFFECTS (node) = 1;
11704       CAN_COMPLETE_NORMALLY (node) = 1;
11705       break;
11706 
11707     case SWITCH_EXPR:
11708     case LOOP_EXPR:
11709       PUSH_LOOP (node);
11710       /* Check whether the loop was enclosed in a labeled
11711          statement. If not, create one, insert the loop in it and
11712          return the node */
11713       nn = patch_loop_statement (node);
11714 
11715       /* Anyways, walk the body of the loop */
11716       if (TREE_CODE (node) == LOOP_EXPR)
11717 	TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11718       /* Switch statement: walk the switch expression and the cases */
11719       else
11720 	node = patch_switch_statement (node);
11721 
11722       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11723 	nn = error_mark_node;
11724       else
11725 	{
11726 	  TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11727 	  /* If we returned something different, that's because we
11728 	     inserted a label. Pop the label too. */
11729 	  if (nn != node)
11730 	    {
11731 	      if (CAN_COMPLETE_NORMALLY (node))
11732 		CAN_COMPLETE_NORMALLY (nn) = 1;
11733 	      POP_LABELED_BLOCK ();
11734 	    }
11735 	}
11736       POP_LOOP ();
11737       return nn;
11738 
11739     case EXIT_EXPR:
11740       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11741       return patch_exit_expr (node);
11742 
11743     case COND_EXPR:
11744       /* Condition */
11745       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11746       if (TREE_OPERAND (node, 0) == error_mark_node)
11747 	return error_mark_node;
11748       /* then-else branches */
11749       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11750       if (TREE_OPERAND (node, 1) == error_mark_node)
11751 	return error_mark_node;
11752       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11753       if (TREE_OPERAND (node, 2) == error_mark_node)
11754 	return error_mark_node;
11755       return patch_if_else_statement (node);
11756       break;
11757 
11758     case CONDITIONAL_EXPR:
11759       /* Condition */
11760       wfl_op1 = TREE_OPERAND (node, 0);
11761       COMPLETE_CHECK_OP_0 (node);
11762       wfl_op2 = TREE_OPERAND (node, 1);
11763       COMPLETE_CHECK_OP_1 (node);
11764       wfl_op3 = TREE_OPERAND (node, 2);
11765       COMPLETE_CHECK_OP_2 (node);
11766       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11767 
11768       /* 3- Expression section */
11769     case COMPOUND_EXPR:
11770       wfl_op2 = TREE_OPERAND (node, 1);
11771       TREE_OPERAND (node, 0) = nn =
11772 	java_complete_tree (TREE_OPERAND (node, 0));
11773       if (wfl_op2 == empty_stmt_node)
11774 	CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11775       else
11776 	{
11777 	  if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11778 	    {
11779 	      /* An unreachable condition in a do-while statement
11780 		 is *not* (technically) an unreachable statement. */
11781 	      nn = wfl_op2;
11782 	      if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11783 		nn = EXPR_WFL_NODE (nn);
11784 	      /* NN can be NULL_TREE exactly when UPDATE is, in
11785 		 finish_for_loop.  */
11786 	      if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11787 		{
11788 		  SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11789 		  if (SUPPRESS_UNREACHABLE_ERROR (nn))
11790 		    {
11791 		      /* Perhaps this warning should have an
11792 			 associated flag.  The code being compiled is
11793 			 pedantically correct, but useless.  */
11794 		      parse_warning_context (wfl_operator,
11795 					     "Unreachable statement");
11796 		    }
11797 		  else
11798 		    parse_error_context (wfl_operator,
11799 					 "Unreachable statement");
11800 		}
11801 	    }
11802 	  TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11803 	  if (TREE_OPERAND (node, 1) == error_mark_node)
11804 	    return error_mark_node;
11805 	  /* Even though we might allow the case where the first
11806 	     operand doesn't return normally, we still should compute
11807 	     CAN_COMPLETE_NORMALLY correctly.  */
11808 	  CAN_COMPLETE_NORMALLY (node)
11809 	    = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11810 	       && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11811 	}
11812       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11813       break;
11814 
11815     case RETURN_EXPR:
11816       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11817       return patch_return (node);
11818 
11819     case EXPR_WITH_FILE_LOCATION:
11820       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11821 	  || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11822 	{
11823 	  tree wfl = node;
11824 	  node = resolve_expression_name (node, NULL);
11825 	  if (node == error_mark_node)
11826 	    return node;
11827 	  /* Keep line number information somewhere were it doesn't
11828 	     disrupt the completion process. */
11829 	  if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11830 	    {
11831 	      EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11832 	      TREE_OPERAND (node, 1) = wfl;
11833 	    }
11834 	  CAN_COMPLETE_NORMALLY (node) = 1;
11835 	}
11836       else
11837 	{
11838 	  tree body;
11839 	  int save_lineno = input_line;
11840 	  input_line = EXPR_WFL_LINENO (node);
11841 	  body = java_complete_tree (EXPR_WFL_NODE (node));
11842 	  input_line = save_lineno;
11843 	  EXPR_WFL_NODE (node) = body;
11844 	  TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11845 	  CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11846 	  if (body == empty_stmt_node || TREE_CONSTANT (body))
11847 	    {
11848 	      /* Makes it easier to constant fold, detect empty bodies. */
11849 	      return body;
11850 	    }
11851 	  if (body == error_mark_node)
11852 	    {
11853 	      /* Its important for the evaluation of assignment that
11854 		 this mark on the TREE_TYPE is propagated. */
11855 	      TREE_TYPE (node) = error_mark_node;
11856 	      return error_mark_node;
11857 	    }
11858 	  else
11859 	    TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11860 
11861 	}
11862       break;
11863 
11864     case NEW_ARRAY_EXPR:
11865       /* Patch all the dimensions */
11866       flag = 0;
11867       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11868 	{
11869 	  int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11870 	  tree dim = convert (int_type_node,
11871 			      java_complete_tree (TREE_VALUE (cn)));
11872 	  if (dim == error_mark_node)
11873 	    {
11874 	      flag = 1;
11875 	      continue;
11876 	    }
11877 	  else
11878 	    {
11879 	      TREE_VALUE (cn) = dim;
11880 	      /* Setup the location of the current dimension, for
11881 		 later error report. */
11882 	      TREE_PURPOSE (cn) =
11883 		build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11884 	      EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11885 	    }
11886 	}
11887       /* They complete the array creation expression, if no errors
11888          were found. */
11889       CAN_COMPLETE_NORMALLY (node) = 1;
11890       return (flag ? error_mark_node
11891 	      : force_evaluation_order (patch_newarray (node)));
11892 
11893     case NEW_ANONYMOUS_ARRAY_EXPR:
11894       /* Create the array type if necessary. */
11895       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11896 	{
11897 	  tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11898 	  if (!(type = resolve_type_during_patch (type)))
11899 	    return error_mark_node;
11900 	  type = build_array_from_name (type, NULL_TREE,
11901 					ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11902 	  ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11903 	}
11904       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11905 				   ANONYMOUS_ARRAY_INITIALIZER (node));
11906       if (node == error_mark_node)
11907 	return error_mark_node;
11908       CAN_COMPLETE_NORMALLY (node) = 1;
11909       return node;
11910 
11911     case NEW_CLASS_EXPR:
11912     case CALL_EXPR:
11913       /* Complete function's argument(s) first */
11914       if (complete_function_arguments (node))
11915 	return error_mark_node;
11916       else
11917 	{
11918 	  tree decl, wfl = TREE_OPERAND (node, 0);
11919 	  int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11920 	  int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11921                            super_identifier_node);
11922 	  tree arguments;
11923 	  int location = EXPR_WFL_LINECOL (node);
11924 
11925 	  node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11926 					  from_super, 0, &decl);
11927 	  if (node == error_mark_node)
11928 	    return error_mark_node;
11929 
11930 	  if (TREE_CODE (node) == CALL_EXPR
11931 	      && TREE_OPERAND (node, 1) != NULL_TREE)
11932 	    arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11933 	  else
11934 	    arguments = NULL_TREE;
11935 	  check_thrown_exceptions (location, decl, arguments);
11936 	  /* If we call this(...), register signature and positions */
11937 	  if (in_this)
11938 	    DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11939 	      tree_cons (wfl, decl,
11940 			 DECL_CONSTRUCTOR_CALLS (current_function_decl));
11941 	  CAN_COMPLETE_NORMALLY (node) = 1;
11942 	  return force_evaluation_order (node);
11943 	}
11944 
11945     case MODIFY_EXPR:
11946       /* Save potential wfls */
11947       wfl_op1 = TREE_OPERAND (node, 0);
11948       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11949 
11950       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11951 	  && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11952 	  && DECL_INITIAL (nn) != NULL_TREE)
11953 	{
11954 	  tree value;
11955 
11956 	  value = fold_constant_for_init (nn, nn);
11957 
11958 	  /* When we have a primitype type, or a string and we're not
11959              emitting a class file, we actually don't want to generate
11960              anything for the assignment. */
11961 	  if (value != NULL_TREE &&
11962 	      (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11963 	       (TREE_TYPE (value) == string_ptr_type_node &&
11964 		! flag_emit_class_files)))
11965 	    {
11966 	      /* Prepare node for patch_assignment */
11967 	      TREE_OPERAND (node, 1) = value;
11968 	      /* Call patch assignment to verify the assignment */
11969 	      if (patch_assignment (node, wfl_op1) == error_mark_node)
11970 		return error_mark_node;
11971 	      /* Set DECL_INITIAL properly (a conversion might have
11972                  been decided by patch_assignment) and return the
11973                  empty statement. */
11974 	      else
11975 		{
11976 		  tree patched = patch_string (TREE_OPERAND (node, 1));
11977 		  if (patched)
11978 		    DECL_INITIAL (nn) = patched;
11979 		  else
11980 		    DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11981 		  DECL_FIELD_FINAL_IUD (nn) = 1;
11982 		  return empty_stmt_node;
11983 		}
11984 	    }
11985 	  if (! flag_emit_class_files)
11986 	    DECL_INITIAL (nn) = NULL_TREE;
11987 	}
11988       wfl_op2 = TREE_OPERAND (node, 1);
11989 
11990       if (TREE_OPERAND (node, 0) == error_mark_node)
11991 	return error_mark_node;
11992 
11993       flag = COMPOUND_ASSIGN_P (wfl_op2);
11994       if (flag)
11995 	{
11996 	  /* This might break when accessing outer field from inner
11997              class. TESTME, FIXME */
11998 	  tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11999 
12000 	  /* Hand stabilize the lhs on both places */
12001 	  TREE_OPERAND (node, 0) = lvalue;
12002 	  TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12003 	    (flag_emit_class_files ? lvalue : save_expr (lvalue));
12004 
12005 	  /* 15.25.2.a: Left hand is not an array access. FIXME */
12006 	  /* Now complete the RHS. We write it back later on. */
12007 	  nn = java_complete_tree (TREE_OPERAND (node, 1));
12008 
12009 	  if ((cn = patch_string (nn)))
12010 	    nn = cn;
12011 
12012 	  /* The last part of the rewrite for E1 op= E2 is to have
12013 	     E1 = (T)(E1 op E2), with T being the type of E1. */
12014 	  nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12015 					       TREE_TYPE (lvalue), nn));
12016 
12017 	  /* If the assignment is compound and has reference type,
12018 	     then ensure the LHS has type String and nothing else.  */
12019 	  if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12020 	      && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12021 	    parse_error_context (wfl_op2,
12022 				 "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12023 				 lang_printable_name (TREE_TYPE (lvalue), 0));
12024 
12025 	  /* 15.25.2.b: Left hand is an array access. FIXME */
12026 	}
12027 
12028       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12029 	 function to complete this RHS. Note that a NEW_ARRAY_INIT
12030 	 might have been already fully expanded if created as a result
12031 	 of processing an anonymous array initializer. We avoid doing
12032 	 the operation twice by testing whether the node already bears
12033 	 a type. */
12034       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12035 	nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12036 				   TREE_OPERAND (node, 1));
12037       /* Otherwise we simply complete the RHS */
12038       else
12039 	nn = java_complete_tree (TREE_OPERAND (node, 1));
12040 
12041       if (nn == error_mark_node)
12042 	return error_mark_node;
12043 
12044       /* Write back the RHS as we evaluated it. */
12045       TREE_OPERAND (node, 1) = nn;
12046 
12047       /* In case we're handling = with a String as a RHS, we need to
12048 	 produce a String out of the RHS (it might still be a
12049 	 STRING_CST or a StringBuffer at this stage */
12050       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12051 	TREE_OPERAND (node, 1) = nn;
12052 
12053       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12054 					TREE_OPERAND (node, 1))))
12055 	{
12056 	  /* We return error_mark_node if outer_field_access_fix
12057 	     detects we write into a final. */
12058 	  if (nn == error_mark_node)
12059 	    return error_mark_node;
12060 	  node = nn;
12061 	}
12062       else
12063 	{
12064 	  node = patch_assignment (node, wfl_op1);
12065 	  if (node == error_mark_node)
12066 	    return error_mark_node;
12067 	  /* Reorganize the tree if necessary. */
12068 	  if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12069 		       || JSTRING_P (TREE_TYPE (node))))
12070 	    node = java_refold (node);
12071 	}
12072 
12073       /* Seek to set DECL_INITIAL to a proper value, since it might have
12074 	 undergone a conversion in patch_assignment. We do that only when
12075 	 it's necessary to have DECL_INITIAL properly set. */
12076       nn = TREE_OPERAND (node, 0);
12077       if (TREE_CODE (nn) == VAR_DECL
12078 	  && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12079 	  && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12080 	  && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12081 	      || TREE_TYPE (nn) == string_ptr_type_node))
12082 	DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12083 
12084       CAN_COMPLETE_NORMALLY (node) = 1;
12085       return node;
12086 
12087     case MULT_EXPR:
12088     case PLUS_EXPR:
12089     case MINUS_EXPR:
12090     case LSHIFT_EXPR:
12091     case RSHIFT_EXPR:
12092     case URSHIFT_EXPR:
12093     case BIT_AND_EXPR:
12094     case BIT_XOR_EXPR:
12095     case BIT_IOR_EXPR:
12096     case TRUNC_MOD_EXPR:
12097     case TRUNC_DIV_EXPR:
12098     case RDIV_EXPR:
12099     case TRUTH_ANDIF_EXPR:
12100     case TRUTH_ORIF_EXPR:
12101     case EQ_EXPR:
12102     case NE_EXPR:
12103     case GT_EXPR:
12104     case GE_EXPR:
12105     case LT_EXPR:
12106     case LE_EXPR:
12107       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12108 	 knows how to handle those cases. */
12109       wfl_op1 = TREE_OPERAND (node, 0);
12110       wfl_op2 = TREE_OPERAND (node, 1);
12111 
12112       CAN_COMPLETE_NORMALLY (node) = 1;
12113       /* Don't complete string nodes if dealing with the PLUS operand. */
12114       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12115         {
12116           nn = java_complete_tree (wfl_op1);
12117           if (nn == error_mark_node)
12118             return error_mark_node;
12119 
12120           TREE_OPERAND (node, 0) = nn;
12121         }
12122       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12123         {
12124           nn = java_complete_tree (wfl_op2);
12125           if (nn == error_mark_node)
12126             return error_mark_node;
12127 
12128           TREE_OPERAND (node, 1) = nn;
12129         }
12130       return patch_binop (node, wfl_op1, wfl_op2);
12131 
12132     case INSTANCEOF_EXPR:
12133       wfl_op1 = TREE_OPERAND (node, 0);
12134       COMPLETE_CHECK_OP_0 (node);
12135       if (flag_emit_xref)
12136 	{
12137 	  TREE_TYPE (node) = boolean_type_node;
12138 	  return node;
12139 	}
12140       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12141 
12142     case UNARY_PLUS_EXPR:
12143     case NEGATE_EXPR:
12144     case TRUTH_NOT_EXPR:
12145     case BIT_NOT_EXPR:
12146     case PREDECREMENT_EXPR:
12147     case PREINCREMENT_EXPR:
12148     case POSTDECREMENT_EXPR:
12149     case POSTINCREMENT_EXPR:
12150     case CONVERT_EXPR:
12151       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12152 	 how to handle those cases. */
12153       wfl_op1 = TREE_OPERAND (node, 0);
12154       CAN_COMPLETE_NORMALLY (node) = 1;
12155       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12156       if (TREE_OPERAND (node, 0) == error_mark_node)
12157 	return error_mark_node;
12158       node = patch_unaryop (node, wfl_op1);
12159       CAN_COMPLETE_NORMALLY (node) = 1;
12160       break;
12161 
12162     case ARRAY_REF:
12163       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12164 	 how to handle those cases. */
12165       wfl_op1 = TREE_OPERAND (node, 0);
12166       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12167       if (TREE_OPERAND (node, 0) == error_mark_node)
12168 	return error_mark_node;
12169       if (!flag_emit_class_files && !flag_emit_xref)
12170 	TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12171       /* The same applies to wfl_op2 */
12172       wfl_op2 = TREE_OPERAND (node, 1);
12173       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12174       if (TREE_OPERAND (node, 1) == error_mark_node)
12175 	return error_mark_node;
12176       if (!flag_emit_class_files && !flag_emit_xref)
12177 	TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12178       return patch_array_ref (node);
12179 
12180     case RECORD_TYPE:
12181       return node;;
12182 
12183     case COMPONENT_REF:
12184       /* The first step in the re-write of qualified name handling.  FIXME.
12185 	 So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12186       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12187       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12188 	{
12189 	  tree name = TREE_OPERAND (node, 1);
12190 	  tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12191 	  if (field == NULL_TREE)
12192 	    {
12193 	      error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12194 	      return error_mark_node;
12195 	    }
12196 	  if (! FIELD_STATIC (field))
12197 	    {
12198 	      error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12199 	      return error_mark_node;
12200 	    }
12201 	  return field;
12202 	}
12203       else
12204 	abort ();
12205       break;
12206 
12207     case THIS_EXPR:
12208       /* Can't use THIS in a static environment */
12209       if (!current_this)
12210 	{
12211 	  EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12212 	  parse_error_context (wfl_operator,
12213 			       "Keyword `this' used outside allowed context");
12214 	  TREE_TYPE (node) = error_mark_node;
12215 	  return error_mark_node;
12216 	}
12217       if (ctxp->explicit_constructor_p)
12218 	{
12219 	  EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12220 	  parse_error_context
12221 	    (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12222 	  TREE_TYPE (node) = error_mark_node;
12223 	  return error_mark_node;
12224 	}
12225       return current_this;
12226 
12227     case CLASS_LITERAL:
12228       CAN_COMPLETE_NORMALLY (node) = 1;
12229       node = patch_incomplete_class_ref (node);
12230       if (node == error_mark_node)
12231 	return error_mark_node;
12232       break;
12233 
12234     default:
12235       CAN_COMPLETE_NORMALLY (node) = 1;
12236       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12237 	 and it's time to turn it into the appropriate String object */
12238       if ((nn = patch_string (node)))
12239 	node = nn;
12240       else
12241 	internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12242     }
12243   return node;
12244 }
12245 
12246 /* Complete function call's argument. Return a nonzero value is an
12247    error was found.  */
12248 
12249 static int
complete_function_arguments(tree node)12250 complete_function_arguments (tree node)
12251 {
12252   int flag = 0;
12253   tree cn;
12254 
12255   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12256   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12257     {
12258       tree wfl = TREE_VALUE (cn), parm, temp;
12259       parm = java_complete_tree (wfl);
12260 
12261       if (parm == error_mark_node)
12262 	{
12263 	  flag = 1;
12264 	  continue;
12265 	}
12266       /* If have a string literal that we haven't transformed yet or a
12267 	 crafted string buffer, as a result of use of the the String
12268 	 `+' operator. Build `parm.toString()' and expand it. */
12269       if ((temp = patch_string (parm)))
12270 	parm = temp;
12271 
12272       TREE_VALUE (cn) = parm;
12273     }
12274   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12275   return flag;
12276 }
12277 
12278 /* Sometimes (for loops and variable initialized during their
12279    declaration), we want to wrap a statement around a WFL and turn it
12280    debugable.  */
12281 
12282 static tree
build_debugable_stmt(int location,tree stmt)12283 build_debugable_stmt (int location, tree stmt)
12284 {
12285   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12286     {
12287       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12288       EXPR_WFL_LINECOL (stmt) = location;
12289     }
12290   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12291   return stmt;
12292 }
12293 
12294 static tree
build_expr_block(tree body,tree decls)12295 build_expr_block (tree body, tree decls)
12296 
12297 {
12298   tree node = make_node (BLOCK);
12299   BLOCK_EXPR_DECLS (node) = decls;
12300   BLOCK_EXPR_BODY (node) = body;
12301   if (body)
12302     TREE_TYPE (node) = TREE_TYPE (body);
12303   TREE_SIDE_EFFECTS (node) = 1;
12304   return node;
12305 }
12306 
12307 /* Create a new function block and link it appropriately to current
12308    function block chain */
12309 
12310 static tree
enter_block(void)12311 enter_block (void)
12312 {
12313   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12314 
12315   /* Link block B supercontext to the previous block. The current
12316      function DECL is used as supercontext when enter_a_block is called
12317      for the first time for a given function. The current function body
12318      (DECL_FUNCTION_BODY) is set to be block B.  */
12319 
12320   tree fndecl = current_function_decl;
12321 
12322   if (!fndecl) {
12323     BLOCK_SUPERCONTEXT (b) = current_static_block;
12324     current_static_block = b;
12325   }
12326 
12327   else if (!DECL_FUNCTION_BODY (fndecl))
12328     {
12329       BLOCK_SUPERCONTEXT (b) = fndecl;
12330       DECL_FUNCTION_BODY (fndecl) = b;
12331     }
12332   else
12333     {
12334       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12335       DECL_FUNCTION_BODY (fndecl) = b;
12336     }
12337   return b;
12338 }
12339 
12340 /* Exit a block by changing the current function body
12341    (DECL_FUNCTION_BODY) to the current block super context, only if
12342    the block being exited isn't the method's top level one.  */
12343 
12344 static tree
exit_block(void)12345 exit_block (void)
12346 {
12347   tree b;
12348   if (current_function_decl)
12349     {
12350       b = DECL_FUNCTION_BODY (current_function_decl);
12351       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12352 	DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12353     }
12354   else
12355     {
12356       b = current_static_block;
12357 
12358       if (BLOCK_SUPERCONTEXT (b))
12359 	current_static_block = BLOCK_SUPERCONTEXT (b);
12360     }
12361   return b;
12362 }
12363 
12364 /* Lookup for NAME in the nested function's blocks, all the way up to
12365    the current toplevel one. It complies with Java's local variable
12366    scoping rules.  */
12367 
12368 static tree
lookup_name_in_blocks(tree name)12369 lookup_name_in_blocks (tree name)
12370 {
12371   tree b = GET_CURRENT_BLOCK (current_function_decl);
12372 
12373   while (b != current_function_decl)
12374     {
12375       tree current;
12376 
12377       /* Paranoid sanity check. To be removed */
12378       if (TREE_CODE (b) != BLOCK)
12379 	abort ();
12380 
12381       for (current = BLOCK_EXPR_DECLS (b); current;
12382 	   current = TREE_CHAIN (current))
12383 	if (DECL_NAME (current) == name)
12384 	  return current;
12385       b = BLOCK_SUPERCONTEXT (b);
12386     }
12387   return NULL_TREE;
12388 }
12389 
12390 static void
maybe_absorb_scoping_blocks(void)12391 maybe_absorb_scoping_blocks (void)
12392 {
12393   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12394     {
12395       tree b = exit_block ();
12396       java_method_add_stmt (current_function_decl, b);
12397       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12398     }
12399 }
12400 
12401 
12402 /* This section of the source is reserved to build_* functions that
12403    are building incomplete tree nodes and the patch_* functions that
12404    are completing them.  */
12405 
12406 /* Wrap a non WFL node around a WFL.  */
12407 
12408 static tree
build_wfl_wrap(tree node,int location)12409 build_wfl_wrap (tree node, int location)
12410 {
12411   tree wfl, node_to_insert = node;
12412 
12413   /* We want to process THIS . xxx symbolically, to keep it consistent
12414      with the way we're processing SUPER. A THIS from a primary as a
12415      different form than a SUPER. Turn THIS into something symbolic */
12416   if (TREE_CODE (node) == THIS_EXPR)
12417     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12418   else
12419     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12420 
12421   EXPR_WFL_LINECOL (wfl) = location;
12422   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12423   return wfl;
12424 }
12425 
12426 /* Build a super() constructor invocation. Returns empty_stmt_node if
12427    we're currently dealing with the class java.lang.Object. */
12428 
12429 static tree
build_super_invocation(tree mdecl)12430 build_super_invocation (tree mdecl)
12431 {
12432   if (DECL_CONTEXT (mdecl) == object_type_node)
12433     return empty_stmt_node;
12434   else
12435     {
12436       tree super_wfl = build_wfl_node (super_identifier_node);
12437       tree a = NULL_TREE, t;
12438       /* If we're dealing with an anonymous class, pass the arguments
12439          of the crafted constructor along. */
12440       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12441 	{
12442 	  SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12443 	  for (; t != end_params_node; t = TREE_CHAIN (t))
12444 	    a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12445 	}
12446       return build_method_invocation (super_wfl, a);
12447     }
12448 }
12449 
12450 /* Build a SUPER/THIS qualified method invocation.  */
12451 
12452 static tree
build_this_super_qualified_invocation(int use_this,tree name,tree args,int lloc,int rloc)12453 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12454 				       int lloc, int rloc)
12455 {
12456   tree invok;
12457   tree wfl =
12458     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12459   EXPR_WFL_LINECOL (wfl) = lloc;
12460   invok = build_method_invocation (name, args);
12461   return make_qualified_primary (wfl, invok, rloc);
12462 }
12463 
12464 /* Build an incomplete CALL_EXPR node. */
12465 
12466 static tree
build_method_invocation(tree name,tree args)12467 build_method_invocation (tree name, tree args)
12468 {
12469   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12470   TREE_SIDE_EFFECTS (call) = 1;
12471   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12472   return call;
12473 }
12474 
12475 /* Build an incomplete new xxx(...) node. */
12476 
12477 static tree
build_new_invocation(tree name,tree args)12478 build_new_invocation (tree name, tree args)
12479 {
12480   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12481   TREE_SIDE_EFFECTS (call) = 1;
12482   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12483   return call;
12484 }
12485 
12486 /* Build an incomplete assignment expression. */
12487 
12488 static tree
build_assignment(int op,int op_location,tree lhs,tree rhs)12489 build_assignment (int op, int op_location, tree lhs, tree rhs)
12490 {
12491   tree assignment;
12492   /* Build the corresponding binop if we deal with a Compound
12493      Assignment operator. Mark the binop sub-tree as part of a
12494      Compound Assignment expression */
12495   if (op != ASSIGN_TK)
12496     {
12497       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12498       COMPOUND_ASSIGN_P (rhs) = 1;
12499     }
12500   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12501   TREE_SIDE_EFFECTS (assignment) = 1;
12502   EXPR_WFL_LINECOL (assignment) = op_location;
12503   return assignment;
12504 }
12505 
12506 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12507    the buffer.  This is used only for string conversion.  */
12508 static char *
string_convert_int_cst(tree node)12509 string_convert_int_cst (tree node)
12510 {
12511   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12512   static char buffer[21];
12513 
12514   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12515   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12516   char *p = buffer + sizeof (buffer);
12517   int neg = 0;
12518 
12519   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12520 				  << (HOST_BITS_PER_WIDE_INT - 1));
12521 
12522   *--p = '\0';
12523 
12524   /* If negative, note the fact and negate the value.  */
12525   if ((hi & hibit))
12526     {
12527       lo = ~lo;
12528       hi = ~hi;
12529       if (++lo == 0)
12530 	++hi;
12531       neg = 1;
12532     }
12533 
12534   /* Divide by 10 until there are no bits left.  */
12535   do
12536     {
12537       unsigned HOST_WIDE_INT acc = 0;
12538       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12539       unsigned int i;
12540 
12541       /* Use long division to compute the result and the remainder.  */
12542       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12543 	{
12544 	  /* Shift a bit into accumulator.  */
12545 	  acc <<= 1;
12546 	  if ((hi & hibit))
12547 	    acc |= 1;
12548 
12549 	  /* Shift the value.  */
12550 	  hi <<= 1;
12551 	  if ((lo & hibit))
12552 	    hi |= 1;
12553 	  lo <<= 1;
12554 
12555 	  /* Shift the correct bit into the result.  */
12556 	  outhi <<= 1;
12557 	  if ((outlo & hibit))
12558 	    outhi |= 1;
12559 	  outlo <<= 1;
12560 	  if (acc >= 10)
12561 	    {
12562 	      acc -= 10;
12563 	      outlo |= 1;
12564 	    }
12565 	}
12566 
12567       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12568       *--p = '\060' + acc;
12569 
12570       hi = outhi;
12571       lo = outlo;
12572     }
12573   while (hi || lo);
12574 
12575   if (neg)
12576     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12577 
12578   return p;
12579 }
12580 
12581 /* Print an INTEGER_CST node in a static buffer, and return the
12582    buffer.  This is used only for error handling.  */
12583 char *
print_int_node(tree node)12584 print_int_node (tree node)
12585 {
12586   static char buffer [80];
12587   if (TREE_CONSTANT_OVERFLOW (node))
12588     sprintf (buffer, "<overflow>");
12589 
12590   if (TREE_INT_CST_HIGH (node) == 0)
12591     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12592 	     TREE_INT_CST_LOW (node));
12593   else if (TREE_INT_CST_HIGH (node) == -1
12594 	   && TREE_INT_CST_LOW (node) != 0)
12595     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12596 	     -TREE_INT_CST_LOW (node));
12597   else
12598     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12599 	     TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12600 
12601   return buffer;
12602 }
12603 
12604 
12605 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12606    context.  */
12607 
12608 /* 15.25 Assignment operators. */
12609 
12610 static tree
patch_assignment(tree node,tree wfl_op1)12611 patch_assignment (tree node, tree wfl_op1)
12612 {
12613   tree rhs = TREE_OPERAND (node, 1);
12614   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12615   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12616   int error_found = 0;
12617   int lvalue_from_array = 0;
12618   int is_return = 0;
12619 
12620   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12621 
12622   /* Lhs can be a named variable */
12623   if (JDECL_P (lvalue))
12624     {
12625       lhs_type = TREE_TYPE (lvalue);
12626     }
12627   /* Or Lhs can be an array access. */
12628   else if (TREE_CODE (lvalue) == ARRAY_REF)
12629     {
12630       lhs_type = TREE_TYPE (lvalue);
12631       lvalue_from_array = 1;
12632     }
12633   /* Or a field access */
12634   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12635     lhs_type = TREE_TYPE (lvalue);
12636   /* Or a function return slot */
12637   else if (TREE_CODE (lvalue) == RESULT_DECL)
12638     {
12639       /* If the return type is an integral type, then we create the
12640 	 RESULT_DECL with a promoted type, but we need to do these
12641 	 checks against the unpromoted type to ensure type safety.  So
12642 	 here we look at the real type, not the type of the decl we
12643 	 are modifying.  */
12644       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12645       is_return = 1;
12646     }
12647   /* Otherwise, we might want to try to write into an optimized static
12648      final, this is an of a different nature, reported further on. */
12649   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12650 	   && resolve_expression_name (wfl_op1, &llvalue))
12651     {
12652       lhs_type = TREE_TYPE (lvalue);
12653     }
12654   else
12655     {
12656       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12657       error_found = 1;
12658     }
12659 
12660   rhs_type = TREE_TYPE (rhs);
12661 
12662   /* 5.1 Try the assignment conversion for builtin type. */
12663   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12664 
12665   /* 5.2 If it failed, try a reference conversion */
12666   if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
12667     lhs_type = promote_type (rhs_type);
12668 
12669   /* 15.25.2 If we have a compound assignment, convert RHS into the
12670      type of the LHS */
12671   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12672     new_rhs = convert (lhs_type, rhs);
12673 
12674   /* Explicit cast required. This is an error */
12675   if (!new_rhs)
12676     {
12677       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12678       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12679       tree wfl;
12680       char operation [32];	/* Max size known */
12681 
12682       /* If the assignment is part of a declaration, we use the WFL of
12683 	 the declared variable to point out the error and call it a
12684 	 declaration problem. If the assignment is a genuine =
12685 	 operator, we call is a operator `=' problem, otherwise we
12686 	 call it an assignment problem. In both of these last cases,
12687 	 we use the WFL of the operator to indicate the error. */
12688 
12689       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12690 	{
12691 	  wfl = wfl_op1;
12692 	  strcpy (operation, "declaration");
12693 	}
12694       else
12695 	{
12696 	  wfl = wfl_operator;
12697 	  if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12698 	    strcpy (operation, "assignment");
12699 	  else if (is_return)
12700 	    strcpy (operation, "`return'");
12701 	  else
12702 	    strcpy (operation, "`='");
12703 	}
12704 
12705       if (!valid_cast_to_p (rhs_type, lhs_type))
12706 	parse_error_context
12707 	  (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12708 	   operation, t1, t2);
12709       else
12710 	parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12711 			     operation, t1, t2);
12712       free (t1); free (t2);
12713       error_found = 1;
12714     }
12715 
12716   if (error_found)
12717     return error_mark_node;
12718 
12719   /* If we're processing a `return' statement, promote the actual type
12720      to the promoted type.  */
12721   if (is_return)
12722     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12723 
12724   /* 10.10: Array Store Exception runtime check */
12725   if (!flag_emit_class_files
12726       && !flag_emit_xref
12727       && lvalue_from_array
12728       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12729     {
12730       tree array, store_check, base, index_expr;
12731 
12732       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12733       new_rhs = save_expr (new_rhs);
12734 
12735       /* Get the INDIRECT_REF. */
12736       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12737       /* Get the array pointer expr. */
12738       array = TREE_OPERAND (array, 0);
12739       store_check = build_java_arraystore_check (array, new_rhs);
12740 
12741       index_expr = TREE_OPERAND (lvalue, 1);
12742 
12743       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12744 	{
12745 	  /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12746 	     happen before the store check, so prepare to insert the store
12747 	     check within the second operand of the existing COMPOUND_EXPR. */
12748 	  base = index_expr;
12749 	}
12750       else
12751         base = lvalue;
12752 
12753       index_expr = TREE_OPERAND (base, 1);
12754       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12755 	  			      store_check, index_expr);
12756     }
12757 
12758   /* Final locals can be used as case values in switch
12759      statement. Prepare them for this eventuality. */
12760   if (TREE_CODE (lvalue) == VAR_DECL
12761       && DECL_FINAL (lvalue)
12762       && TREE_CONSTANT (new_rhs)
12763       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12764       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12765       )
12766     {
12767       TREE_CONSTANT (lvalue) = 1;
12768       DECL_INITIAL (lvalue) = new_rhs;
12769     }
12770 
12771   /* Copy the rhs if it's a reference.  */
12772   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12773     {
12774       switch (TREE_CODE (new_rhs))
12775 	{
12776 	case ARRAY_REF:
12777 	case INDIRECT_REF:
12778 	case COMPONENT_REF:
12779 	  /* Transform a = foo.bar
12780 	     into a = { int tmp; tmp = foo.bar; tmp; ).
12781 	     We need to ensure that if a read from memory fails
12782 	     because of a NullPointerException, a destination variable
12783 	     will remain unchanged.  An explicit temporary does what
12784 	     we need.
12785 
12786 	     If flag_check_references is set, this is unnecessary
12787 	     because we'll check each reference before doing any
12788 	     reads.  If optimize is not set the result will never be
12789 	     written to a stack slot that contains the LHS.  */
12790 	  {
12791 	    tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12792 				   TREE_TYPE (new_rhs));
12793 	    tree block = make_node (BLOCK);
12794 	    tree assignment
12795 	      = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12796 	    DECL_CONTEXT (tmp) = current_function_decl;
12797 	    TREE_TYPE (block) = TREE_TYPE (new_rhs);
12798 	    BLOCK_VARS (block) = tmp;
12799 	    BLOCK_EXPR_BODY (block)
12800 	      = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
12801 	    TREE_SIDE_EFFECTS (block) = 1;
12802 	    new_rhs = block;
12803 	  }
12804 	  break;
12805 	default:
12806 	  break;
12807 	}
12808     }
12809 
12810   TREE_OPERAND (node, 0) = lvalue;
12811   TREE_OPERAND (node, 1) = new_rhs;
12812   TREE_TYPE (node) = lhs_type;
12813   return node;
12814 }
12815 
12816 /* Check that type SOURCE can be cast into type DEST. If the cast
12817    can't occur at all, return NULL; otherwise, return a possibly
12818    modified rhs.  */
12819 
12820 static tree
try_reference_assignconv(tree lhs_type,tree rhs)12821 try_reference_assignconv (tree lhs_type, tree rhs)
12822 {
12823   tree new_rhs = NULL_TREE;
12824   tree rhs_type = TREE_TYPE (rhs);
12825 
12826   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12827     {
12828       /* `null' may be assigned to any reference type */
12829       if (rhs == null_pointer_node)
12830         new_rhs = null_pointer_node;
12831       /* Try the reference assignment conversion */
12832       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12833 	new_rhs = rhs;
12834       /* This is a magic assignment that we process differently */
12835       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12836 	new_rhs = rhs;
12837     }
12838   return new_rhs;
12839 }
12840 
12841 /* Check that RHS can be converted into LHS_TYPE by the assignment
12842    conversion (5.2), for the cases of RHS being a builtin type. Return
12843    NULL_TREE if the conversion fails or if because RHS isn't of a
12844    builtin type. Return a converted RHS if the conversion is possible.  */
12845 
12846 static tree
try_builtin_assignconv(tree wfl_op1,tree lhs_type,tree rhs)12847 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12848 {
12849   tree new_rhs = NULL_TREE;
12850   tree rhs_type = TREE_TYPE (rhs);
12851 
12852   /* Handle boolean specially.  */
12853   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12854       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12855     {
12856       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12857 	  && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12858 	new_rhs = rhs;
12859     }
12860 
12861   /* 5.1.1 Try Identity Conversion,
12862      5.1.2 Try Widening Primitive Conversion */
12863   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12864     new_rhs = convert (lhs_type, rhs);
12865 
12866   /* Try a narrowing primitive conversion (5.1.3):
12867        - expression is a constant expression of type byte, short, char,
12868          or int, AND
12869        - variable is byte, short or char AND
12870        - The value of the expression is representable in the type of the
12871          variable */
12872   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12873 	    || rhs_type == char_type_node || rhs_type == int_type_node)
12874 	    && TREE_CONSTANT (rhs)
12875 	   && (lhs_type == byte_type_node || lhs_type == char_type_node
12876 	       || lhs_type == short_type_node))
12877     {
12878       if (int_fits_type_p (rhs, lhs_type))
12879         new_rhs = convert (lhs_type, rhs);
12880       else if (wfl_op1)		/* Might be called with a NULL */
12881 	parse_warning_context
12882 	  (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12883 	   print_int_node (rhs), lang_printable_name (lhs_type, 0));
12884       /* Reported a warning that will turn into an error further
12885 	 down, so we don't return */
12886     }
12887 
12888   return new_rhs;
12889 }
12890 
12891 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12892    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12893    0 is the conversion test fails.  This implements parts the method
12894    invocation conversion (5.3).  */
12895 
12896 static int
valid_builtin_assignconv_identity_widening_p(tree lhs_type,tree rhs_type)12897 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12898 {
12899   /* 5.1.1: This is the identity conversion part. */
12900   if (lhs_type == rhs_type)
12901     return 1;
12902 
12903   /* Reject non primitive types and boolean conversions.  */
12904   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12905     return 0;
12906 
12907   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12908      than a char can't be converted into a char. Short can't too, but
12909      the < test below takes care of that */
12910   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12911     return 0;
12912 
12913   /* Accept all promoted type here. Note, we can't use <= in the test
12914      below, because we still need to bounce out assignments of short
12915      to char and the likes */
12916   if (lhs_type == int_type_node
12917       && (rhs_type == promoted_byte_type_node
12918 	  || rhs_type == promoted_short_type_node
12919 	  || rhs_type == promoted_char_type_node
12920 	  || rhs_type == promoted_boolean_type_node))
12921     return 1;
12922 
12923   /* From here, an integral is widened if its precision is smaller
12924      than the precision of the LHS or if the LHS is a floating point
12925      type, or the RHS is a float and the RHS a double. */
12926   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12927        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12928       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12929       || (rhs_type == float_type_node && lhs_type == double_type_node))
12930     return 1;
12931 
12932   return 0;
12933 }
12934 
12935 /* Check that something of SOURCE type can be assigned or cast to
12936    something of DEST type at runtime. Return 1 if the operation is
12937    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12938    were SOURCE is cast into DEST, which borrows a lot of the
12939    assignment check. */
12940 
12941 static int
valid_ref_assignconv_cast_p(tree source,tree dest,int cast)12942 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12943 {
12944   /* SOURCE or DEST might be null if not from a declared entity. */
12945   if (!source || !dest)
12946     return 0;
12947   if (JNULLP_TYPE_P (source))
12948     return 1;
12949   if (TREE_CODE (source) == POINTER_TYPE)
12950     source = TREE_TYPE (source);
12951   if (TREE_CODE (dest) == POINTER_TYPE)
12952     dest = TREE_TYPE (dest);
12953 
12954   /* If source and dest are being compiled from bytecode, they may need to
12955      be loaded. */
12956   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12957     {
12958       load_class (source, 1);
12959       safe_layout_class (source);
12960     }
12961   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12962     {
12963       load_class (dest, 1);
12964       safe_layout_class (dest);
12965     }
12966 
12967   /* Case where SOURCE is a class type */
12968   if (TYPE_CLASS_P (source))
12969     {
12970       if (TYPE_CLASS_P (dest))
12971 	return  (source == dest
12972 		 || inherits_from_p (source, dest)
12973 		 || (cast && inherits_from_p (dest, source)));
12974       if (TYPE_INTERFACE_P (dest))
12975 	{
12976 	  /* If doing a cast and SOURCE is final, the operation is
12977              always correct a compile time (because even if SOURCE
12978              does not implement DEST, a subclass of SOURCE might). */
12979 	  if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12980 	    return 1;
12981 	  /* Otherwise, SOURCE must implement DEST */
12982 	  return interface_of_p (dest, source);
12983 	}
12984       /* DEST is an array, cast permitted if SOURCE is of Object type */
12985       return (cast && source == object_type_node ? 1 : 0);
12986     }
12987   if (TYPE_INTERFACE_P (source))
12988     {
12989       if (TYPE_CLASS_P (dest))
12990 	{
12991 	  /* If not casting, DEST must be the Object type */
12992 	  if (!cast)
12993 	    return dest == object_type_node;
12994 	  /* We're doing a cast. The cast is always valid is class
12995 	     DEST is not final, otherwise, DEST must implement SOURCE */
12996 	  else if (!CLASS_FINAL (TYPE_NAME (dest)))
12997 	    return 1;
12998 	  else
12999 	    return interface_of_p (source, dest);
13000 	}
13001       if (TYPE_INTERFACE_P (dest))
13002 	{
13003 	  /* If doing a cast, then if SOURCE and DEST contain method
13004              with the same signature but different return type, then
13005              this is a (compile time) error */
13006 	  if (cast)
13007 	    {
13008 	      tree method_source, method_dest;
13009 	      tree source_type;
13010 	      tree source_sig;
13011 	      tree source_name;
13012 	      for (method_source = TYPE_METHODS (source); method_source;
13013 		   method_source = TREE_CHAIN (method_source))
13014 		{
13015 		  source_sig =
13016 		    build_java_argument_signature (TREE_TYPE (method_source));
13017 		  source_type = TREE_TYPE (TREE_TYPE (method_source));
13018 		  source_name = DECL_NAME (method_source);
13019 		  for (method_dest = TYPE_METHODS (dest);
13020 		       method_dest; method_dest = TREE_CHAIN (method_dest))
13021 		    if (source_sig ==
13022 			build_java_argument_signature (TREE_TYPE (method_dest))
13023 			&& source_name == DECL_NAME (method_dest)
13024 			&& source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13025 		      return 0;
13026 		}
13027 	      return 1;
13028 	    }
13029 	  else
13030 	    return source == dest || interface_of_p (dest, source);
13031 	}
13032       else
13033 	{
13034 	  /* Array */
13035 	  return (cast
13036 		  && (DECL_NAME (TYPE_NAME (source))
13037 		      == java_lang_cloneable_identifier_node
13038 		      || (DECL_NAME (TYPE_NAME (source))
13039 			  == java_io_serializable_identifier_node)));
13040 	}
13041     }
13042   if (TYPE_ARRAY_P (source))
13043     {
13044       if (TYPE_CLASS_P (dest))
13045 	return dest == object_type_node;
13046       /* Can't cast an array to an interface unless the interface is
13047 	 java.lang.Cloneable or java.io.Serializable.  */
13048       if (TYPE_INTERFACE_P (dest))
13049 	return (DECL_NAME (TYPE_NAME (dest))
13050 		== java_lang_cloneable_identifier_node
13051 		|| (DECL_NAME (TYPE_NAME (dest))
13052 		    == java_io_serializable_identifier_node));
13053       else			/* Arrays */
13054 	{
13055 	  tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13056 	  tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13057 
13058 	  /* In case of severe errors, they turn out null */
13059 	  if (!dest_element_type || !source_element_type)
13060 	    return 0;
13061 	  if (source_element_type == dest_element_type)
13062 	    return 1;
13063 	  return valid_ref_assignconv_cast_p (source_element_type,
13064 					      dest_element_type, cast);
13065 	}
13066       return 0;
13067     }
13068   return 0;
13069 }
13070 
13071 static int
valid_cast_to_p(tree source,tree dest)13072 valid_cast_to_p (tree source, tree dest)
13073 {
13074   if (TREE_CODE (source) == POINTER_TYPE)
13075     source = TREE_TYPE (source);
13076   if (TREE_CODE (dest) == POINTER_TYPE)
13077     dest = TREE_TYPE (dest);
13078 
13079   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13080     return valid_ref_assignconv_cast_p (source, dest, 1);
13081 
13082   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13083     return 1;
13084 
13085   else if (TREE_CODE (source) == BOOLEAN_TYPE
13086 	   && TREE_CODE (dest) == BOOLEAN_TYPE)
13087     return 1;
13088 
13089   return 0;
13090 }
13091 
13092 static tree
do_unary_numeric_promotion(tree arg)13093 do_unary_numeric_promotion (tree arg)
13094 {
13095   tree type = TREE_TYPE (arg);
13096   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13097       || TREE_CODE (type) == CHAR_TYPE)
13098     arg = convert (int_type_node, arg);
13099   return arg;
13100 }
13101 
13102 /* Return a nonzero value if SOURCE can be converted into DEST using
13103    the method invocation conversion rule (5.3).  */
13104 static int
valid_method_invocation_conversion_p(tree dest,tree source)13105 valid_method_invocation_conversion_p (tree dest, tree source)
13106 {
13107   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13108 	   && valid_builtin_assignconv_identity_widening_p (dest, source))
13109 	  || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13110 	      && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13111 	      && valid_ref_assignconv_cast_p (source, dest, 0)));
13112 }
13113 
13114 /* Build an incomplete binop expression. */
13115 
13116 static tree
build_binop(enum tree_code op,int op_location,tree op1,tree op2)13117 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13118 {
13119   tree binop = build (op, NULL_TREE, op1, op2);
13120   TREE_SIDE_EFFECTS (binop) = 1;
13121   /* Store the location of the operator, for better error report. The
13122      string of the operator will be rebuild based on the OP value. */
13123   EXPR_WFL_LINECOL (binop) = op_location;
13124   return binop;
13125 }
13126 
13127 /* Build the string of the operator retained by NODE. If NODE is part
13128    of a compound expression, add an '=' at the end of the string. This
13129    function is called when an error needs to be reported on an
13130    operator. The string is returned as a pointer to a static character
13131    buffer. */
13132 
13133 static char *
operator_string(tree node)13134 operator_string (tree node)
13135 {
13136 #define BUILD_OPERATOR_STRING(S)					\
13137   {									\
13138     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : ""));	\
13139     return buffer;							\
13140   }
13141 
13142   static char buffer [10];
13143   switch (TREE_CODE (node))
13144     {
13145     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13146     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13147     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13148     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13149     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13150     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13151     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13152     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13153     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13154     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13155     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13156     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13157     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13158     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13159     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13160     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13161     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13162     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13163     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13164     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13165     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13166     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13167     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13168     case PREINCREMENT_EXPR:	/* Fall through */
13169     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13170     case PREDECREMENT_EXPR:	/* Fall through */
13171     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13172     default:
13173       internal_error ("unregistered operator %s",
13174 		      tree_code_name [TREE_CODE (node)]);
13175     }
13176   return NULL;
13177 #undef BUILD_OPERATOR_STRING
13178 }
13179 
13180 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13181 
13182 static int
java_decl_equiv(tree var_acc1,tree var_acc2)13183 java_decl_equiv (tree var_acc1, tree var_acc2)
13184 {
13185   if (JDECL_P (var_acc1))
13186     return (var_acc1 == var_acc2);
13187 
13188   return (TREE_CODE (var_acc1) == COMPONENT_REF
13189 	  && TREE_CODE (var_acc2) == COMPONENT_REF
13190 	  && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13191 	     == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13192 	  && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13193 }
13194 
13195 /* Return a nonzero value if CODE is one of the operators that can be
13196    used in conjunction with the `=' operator in a compound assignment.  */
13197 
13198 static int
binop_compound_p(enum tree_code code)13199 binop_compound_p (enum tree_code code)
13200 {
13201   int i;
13202   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13203     if (binop_lookup [i] == code)
13204       break;
13205 
13206   return i < BINOP_COMPOUND_CANDIDATES;
13207 }
13208 
13209 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13210 
13211 static tree
java_refold(tree t)13212 java_refold (tree t)
13213 {
13214   tree c, b, ns, decl;
13215 
13216   if (TREE_CODE (t) != MODIFY_EXPR)
13217     return t;
13218 
13219   c = TREE_OPERAND (t, 1);
13220   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13221 	 && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13222 	 && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13223     return t;
13224 
13225   /* Now the left branch of the binary operator. */
13226   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13227   if (! (b && TREE_CODE (b) == NOP_EXPR
13228 	 && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13229     return t;
13230 
13231   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13232   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13233 	 && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13234     return t;
13235 
13236   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13237   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13238       /* It's got to be the an equivalent decl */
13239       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13240     {
13241       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13242       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13243       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13244       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13245       /* Change the right part of the BINOP_EXPR */
13246       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13247     }
13248 
13249   return t;
13250 }
13251 
13252 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13253    errors but we modify NODE so that it contains the type computed
13254    according to the expression, when it's fixed. Otherwise, we write
13255    error_mark_node as the type. It allows us to further the analysis
13256    of remaining nodes and detects more errors in certain cases.  */
13257 
13258 static tree
patch_binop(tree node,tree wfl_op1,tree wfl_op2)13259 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13260 {
13261   tree op1 = TREE_OPERAND (node, 0);
13262   tree op2 = TREE_OPERAND (node, 1);
13263   tree op1_type = TREE_TYPE (op1);
13264   tree op2_type = TREE_TYPE (op2);
13265   tree prom_type = NULL_TREE, cn;
13266   enum tree_code code = TREE_CODE (node);
13267 
13268   /* If 1, tell the routine that we have to return error_mark_node
13269      after checking for the initialization of the RHS */
13270   int error_found = 0;
13271 
13272   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13273 
13274   /* If either op<n>_type are NULL, this might be early signs of an
13275      error situation, unless it's too early to tell (in case we're
13276      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13277      correctly so the error can be later on reported accurately. */
13278   if (! (code == PLUS_EXPR || code == NE_EXPR
13279 	 || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13280     {
13281       tree n;
13282       if (! op1_type)
13283 	{
13284 	  n = java_complete_tree (op1);
13285 	  op1_type = TREE_TYPE (n);
13286 	}
13287       if (! op2_type)
13288 	{
13289 	  n = java_complete_tree (op2);
13290 	  op2_type = TREE_TYPE (n);
13291 	}
13292     }
13293 
13294   switch (code)
13295     {
13296     /* 15.16 Multiplicative operators */
13297     case MULT_EXPR:		/* 15.16.1 Multiplication Operator * */
13298     case RDIV_EXPR:		/* 15.16.2 Division Operator / */
13299     case TRUNC_DIV_EXPR:	/* 15.16.2 Integral type Division Operator / */
13300     case TRUNC_MOD_EXPR:	/* 15.16.3 Remainder operator % */
13301       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13302 	{
13303 	  if (!JNUMERIC_TYPE_P (op1_type))
13304 	    ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13305 	  if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13306 	    ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13307 	  TREE_TYPE (node) = error_mark_node;
13308 	  error_found = 1;
13309 	  break;
13310 	}
13311       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13312 
13313       /* Detect integral division by zero */
13314       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13315 	  && TREE_CODE (prom_type) == INTEGER_TYPE
13316 	  && (op2 == integer_zero_node || op2 == long_zero_node ||
13317 	      (TREE_CODE (op2) == INTEGER_CST &&
13318 	       ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13319 	{
13320 	  parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13321 	  TREE_CONSTANT (node) = 0;
13322 	}
13323 
13324       /* Change the division operator if necessary */
13325       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13326 	TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13327 
13328       /* Before divisions as is disappear, try to simplify and bail if
13329          applicable, otherwise we won't perform even simple
13330          simplifications like (1-1)/3. We can't do that with floating
13331          point number, folds can't handle them at this stage. */
13332       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13333 	  && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13334 	{
13335 	  TREE_TYPE (node) = prom_type;
13336 	  node = fold (node);
13337 	  if (TREE_CODE (node) != code)
13338 	    return node;
13339 	}
13340 
13341       if (TREE_CODE (prom_type) == INTEGER_TYPE
13342 	  && flag_use_divide_subroutine
13343 	  && ! flag_emit_class_files
13344 	  && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13345 	return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13346 
13347       /* This one is more complicated. FLOATs are processed by a
13348 	 function call to soft_fmod. Duplicate the value of the
13349 	 COMPOUND_ASSIGN_P flag. */
13350       if (code == TRUNC_MOD_EXPR)
13351 	{
13352 	  tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13353 	  COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13354 	  TREE_SIDE_EFFECTS (mod)
13355 	    = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13356 	  return mod;
13357 	}
13358       break;
13359 
13360     /* 15.17 Additive Operators */
13361     case PLUS_EXPR:		/* 15.17.1 String Concatenation Operator + */
13362 
13363       /* Operation is valid if either one argument is a string
13364 	 constant, a String object or a StringBuffer crafted for the
13365 	 purpose of the a previous usage of the String concatenation
13366 	 operator */
13367 
13368       if (TREE_CODE (op1) == STRING_CST
13369 	  || TREE_CODE (op2) == STRING_CST
13370 	  || JSTRING_TYPE_P (op1_type)
13371 	  || JSTRING_TYPE_P (op2_type)
13372 	  || IS_CRAFTED_STRING_BUFFER_P (op1)
13373 	  || IS_CRAFTED_STRING_BUFFER_P (op2))
13374 	return build_string_concatenation (op1, op2);
13375 
13376     case MINUS_EXPR:		/* 15.17.2 Additive Operators (+ and -) for
13377 				   Numeric Types */
13378       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13379 	{
13380 	  if (!JNUMERIC_TYPE_P (op1_type))
13381 	    ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13382 	  if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13383 	    ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13384 	  TREE_TYPE (node) = error_mark_node;
13385 	  error_found = 1;
13386 	  break;
13387 	}
13388       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13389       break;
13390 
13391     /* 15.18 Shift Operators */
13392     case LSHIFT_EXPR:
13393     case RSHIFT_EXPR:
13394     case URSHIFT_EXPR:
13395       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13396 	{
13397 	  if (!JINTEGRAL_TYPE_P (op1_type))
13398 	    ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13399 	  else
13400 	    {
13401 	      if (JNUMERIC_TYPE_P (op2_type))
13402 		parse_error_context (wfl_operator,
13403 				     "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13404 				     operator_string (node),
13405 				     lang_printable_name (op2_type, 0));
13406 	      else
13407 		parse_error_context (wfl_operator,
13408 				     "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13409 				     operator_string (node),
13410 				     lang_printable_name (op2_type, 0));
13411 	    }
13412 	  TREE_TYPE (node) = error_mark_node;
13413 	  error_found = 1;
13414 	  break;
13415 	}
13416 
13417       /* Unary numeric promotion (5.6.1) is performed on each operand
13418          separately */
13419       op1 = do_unary_numeric_promotion (op1);
13420       op2 = do_unary_numeric_promotion (op2);
13421 
13422       /* If the right hand side is of type `long', first cast it to
13423 	 `int'.  */
13424       if (TREE_TYPE (op2) == long_type_node)
13425 	op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13426 
13427       /* The type of the shift expression is the type of the promoted
13428          type of the left-hand operand */
13429       prom_type = TREE_TYPE (op1);
13430 
13431       /* Shift int only up to 0x1f and long up to 0x3f */
13432       if (prom_type == int_type_node)
13433 	op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13434 			   build_int_2 (0x1f, 0)));
13435       else
13436 	op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13437 			   build_int_2 (0x3f, 0)));
13438 
13439       /* The >>> operator is a >> operating on unsigned quantities */
13440       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13441 	{
13442 	  tree to_return;
13443           tree utype = java_unsigned_type (prom_type);
13444           op1 = convert (utype, op1);
13445 	  TREE_SET_CODE (node, RSHIFT_EXPR);
13446           TREE_OPERAND (node, 0) = op1;
13447           TREE_OPERAND (node, 1) = op2;
13448           TREE_TYPE (node) = utype;
13449 	  to_return = convert (prom_type, node);
13450 	  /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13451 	  COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13452 	  TREE_SIDE_EFFECTS (to_return)
13453 	    = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13454 	  return to_return;
13455 	}
13456       break;
13457 
13458       /* 15.19.1 Type Comparison Operator instanceof */
13459     case INSTANCEOF_EXPR:
13460 
13461       TREE_TYPE (node) = boolean_type_node;
13462 
13463       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13464       if ((cn = patch_string (op1)))
13465 	{
13466 	  op1 = cn;
13467 	  op1_type = TREE_TYPE (op1);
13468 	}
13469       if (op1_type == NULL_TREE)
13470 	abort ();
13471 
13472       if (!(op2_type = resolve_type_during_patch (op2)))
13473 	return error_mark_node;
13474 
13475       /* The first operand must be a reference type or the null type */
13476       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13477 	error_found = 1;	/* Error reported further below */
13478 
13479       /* The second operand must be a reference type */
13480       if (!JREFERENCE_TYPE_P (op2_type))
13481 	{
13482 	  SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13483 	  parse_error_context
13484 	    (wfl_operator, "Invalid argument `%s' for `instanceof'",
13485 	     lang_printable_name (op2_type, 0));
13486 	  error_found = 1;
13487 	}
13488 
13489       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13490 	{
13491 	  /* If the first operand is null, the result is always false */
13492 	  if (op1 == null_pointer_node)
13493 	    return boolean_false_node;
13494 	  else if (flag_emit_class_files)
13495 	    {
13496 	      TREE_OPERAND (node, 1) = op2_type;
13497 	      TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13498 	      return node;
13499 	    }
13500 	  /* Otherwise we have to invoke instance of to figure it out */
13501 	  else
13502 	    return build_instanceof (op1, op2_type);
13503 	}
13504       /* There is no way the expression operand can be an instance of
13505 	 the type operand. This is a compile time error. */
13506       else
13507 	{
13508 	  char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13509 	  SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13510 	  parse_error_context
13511 	    (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13512 	     t1, lang_printable_name (op2_type, 0));
13513 	  free (t1);
13514 	  error_found = 1;
13515 	}
13516 
13517       break;
13518 
13519       /* 15.21 Bitwise and Logical Operators */
13520     case BIT_AND_EXPR:
13521     case BIT_XOR_EXPR:
13522     case BIT_IOR_EXPR:
13523       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13524 	/* Binary numeric promotion is performed on both operand and the
13525 	   expression retain that type */
13526 	prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13527 
13528       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13529 	       && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13530 	/* The type of the bitwise operator expression is BOOLEAN */
13531 	prom_type = boolean_type_node;
13532       else
13533 	{
13534 	  if (!JINTEGRAL_TYPE_P (op1_type))
13535 	    ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13536 	  if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13537 	    ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13538 	  TREE_TYPE (node) = error_mark_node;
13539 	  error_found = 1;
13540 	  /* Insert a break here if adding thing before the switch's
13541              break for this case */
13542 	}
13543       break;
13544 
13545       /* 15.22 Conditional-And Operator */
13546     case TRUTH_ANDIF_EXPR:
13547       /* 15.23 Conditional-Or Operator */
13548     case TRUTH_ORIF_EXPR:
13549       /* Operands must be of BOOLEAN type */
13550       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13551 	  TREE_CODE (op2_type) != BOOLEAN_TYPE)
13552 	{
13553 	  if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13554 	    ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13555 	  if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13556 	    ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13557 	  TREE_TYPE (node) = boolean_type_node;
13558 	  error_found = 1;
13559 	  break;
13560 	}
13561       else if (integer_zerop (op1))
13562 	{
13563 	  return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13564 	}
13565       else if (integer_onep (op1))
13566 	{
13567 	  return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13568 	}
13569       /* The type of the conditional operators is BOOLEAN */
13570       prom_type = boolean_type_node;
13571       break;
13572 
13573       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13574     case LT_EXPR:
13575     case GT_EXPR:
13576     case LE_EXPR:
13577     case GE_EXPR:
13578       /* The type of each of the operands must be a primitive numeric
13579          type */
13580       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13581 	{
13582 	  if (!JNUMERIC_TYPE_P (op1_type))
13583 	    ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13584 	  if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13585 	    ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13586 	  TREE_TYPE (node) = boolean_type_node;
13587 	  error_found = 1;
13588 	  break;
13589 	}
13590       /* Binary numeric promotion is performed on the operands */
13591       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13592       /* The type of the relation expression is always BOOLEAN */
13593       prom_type = boolean_type_node;
13594       break;
13595 
13596       /* 15.20 Equality Operator */
13597     case EQ_EXPR:
13598     case NE_EXPR:
13599       /* It's time for us to patch the strings. */
13600       if ((cn = patch_string (op1)))
13601        {
13602          op1 = cn;
13603          op1_type = TREE_TYPE (op1);
13604        }
13605       if ((cn = patch_string (op2)))
13606        {
13607          op2 = cn;
13608          op2_type = TREE_TYPE (op2);
13609        }
13610 
13611       /* 15.20.1 Numerical Equality Operators == and != */
13612       /* Binary numeric promotion is performed on the operands */
13613       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13614 	binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13615 
13616       /* 15.20.2 Boolean Equality Operators == and != */
13617       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13618 	  TREE_CODE (op2_type) == BOOLEAN_TYPE)
13619 	;			/* Nothing to do here */
13620 
13621       /* 15.20.3 Reference Equality Operators == and != */
13622       /* Types have to be either references or the null type. If
13623          they're references, it must be possible to convert either
13624          type to the other by casting conversion. */
13625       else if (op1 == null_pointer_node || op2 == null_pointer_node
13626 	       || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13627 		   && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13628 		       || valid_ref_assignconv_cast_p (op2_type,
13629 						       op1_type, 1))))
13630 	;			/* Nothing to do here */
13631 
13632       /* Else we have an error figure what can't be converted into
13633 	 what and report the error */
13634       else
13635 	{
13636 	  char *t1;
13637 	  t1 = xstrdup (lang_printable_name (op1_type, 0));
13638 	  parse_error_context
13639 	    (wfl_operator,
13640 	     "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13641 	     operator_string (node), t1,
13642 	     lang_printable_name (op2_type, 0));
13643 	  free (t1);
13644 	  TREE_TYPE (node) = boolean_type_node;
13645 	  error_found = 1;
13646 	  break;
13647 	}
13648       prom_type = boolean_type_node;
13649       break;
13650     default:
13651       abort ();
13652     }
13653 
13654   if (error_found)
13655     return error_mark_node;
13656 
13657   TREE_OPERAND (node, 0) = op1;
13658   TREE_OPERAND (node, 1) = op2;
13659   TREE_TYPE (node) = prom_type;
13660   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13661 
13662   if (flag_emit_xref)
13663     return node;
13664 
13665   /* fold does not respect side-effect order as required for Java but not C.
13666    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13667    * bytecode.
13668    */
13669   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13670       : ! TREE_SIDE_EFFECTS (node))
13671     node = fold (node);
13672   return node;
13673 }
13674 
13675 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13676    zero value, the value of CSTE comes after the valude of STRING */
13677 
13678 static tree
do_merge_string_cste(tree cste,const char * string,int string_len,int after)13679 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13680 {
13681   const char *old = TREE_STRING_POINTER (cste);
13682   int old_len = TREE_STRING_LENGTH (cste);
13683   int len = old_len + string_len;
13684   char *new = alloca (len+1);
13685 
13686   if (after)
13687     {
13688       memcpy (new, string, string_len);
13689       memcpy (&new [string_len], old, old_len);
13690     }
13691   else
13692     {
13693       memcpy (new, old, old_len);
13694       memcpy (&new [old_len], string, string_len);
13695     }
13696   new [len] = '\0';
13697   return build_string (len, new);
13698 }
13699 
13700 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13701    new STRING_CST on success, NULL_TREE on failure.  */
13702 
13703 static tree
merge_string_cste(tree op1,tree op2,int after)13704 merge_string_cste (tree op1, tree op2, int after)
13705 {
13706   /* Handle two string constants right away.  */
13707   if (TREE_CODE (op2) == STRING_CST)
13708     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13709 				 TREE_STRING_LENGTH (op2), after);
13710 
13711   /* Reasonable integer constant can be treated right away.  */
13712   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13713     {
13714       static const char *const boolean_true = "true";
13715       static const char *const boolean_false = "false";
13716       static const char *const null_pointer = "null";
13717       char ch[4];
13718       const char *string;
13719 
13720       if (op2 == boolean_true_node)
13721 	string = boolean_true;
13722       else if (op2 == boolean_false_node)
13723 	string = boolean_false;
13724       else if (op2 == null_pointer_node
13725 	       || (integer_zerop (op2)
13726 		   && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13727 	/* FIXME: null is not a compile-time constant, so it is only safe to
13728 	   merge if the overall expression is non-constant. However, this
13729 	   code always merges without checking the overall expression.  */
13730 	string = null_pointer;
13731       else if (TREE_TYPE (op2) == char_type_node)
13732 	{
13733 	  /* Convert the character into UTF-8.	*/
13734 	  unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13735 	  unsigned char *p = (unsigned char *) ch;
13736 	  if (0x01 <= c && c <= 0x7f)
13737 	    *p++ = (unsigned char) c;
13738 	  else if (c < 0x7ff)
13739 	    {
13740 	      *p++ = (unsigned char) (c >> 6 | 0xc0);
13741 	      *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13742 	    }
13743 	  else
13744 	    {
13745 	      *p++ = (unsigned char) (c >> 12 | 0xe0);
13746 	      *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13747 	      *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13748 	    }
13749 	  *p = '\0';
13750 
13751 	  string = ch;
13752 	}
13753       else
13754 	string = string_convert_int_cst (op2);
13755 
13756       return do_merge_string_cste (op1, string, strlen (string), after);
13757     }
13758   return NULL_TREE;
13759 }
13760 
13761 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13762    has to be a STRING_CST and the other part must be a STRING_CST or a
13763    INTEGRAL constant. Return a new STRING_CST if the operation
13764    succeed, NULL_TREE otherwise.
13765 
13766    If the case we want to optimize for space, we might want to return
13767    NULL_TREE for each invocation of this routine. FIXME */
13768 
13769 static tree
string_constant_concatenation(tree op1,tree op2)13770 string_constant_concatenation (tree op1, tree op2)
13771 {
13772   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13773     {
13774       tree string, rest;
13775       int invert;
13776 
13777       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13778       rest   = (string == op1 ? op2 : op1);
13779       invert = (string == op1 ? 0 : 1 );
13780 
13781       /* Walk REST, only if it looks reasonable */
13782       if (TREE_CODE (rest) != STRING_CST
13783 	  && !IS_CRAFTED_STRING_BUFFER_P (rest)
13784 	  && !JSTRING_TYPE_P (TREE_TYPE (rest))
13785 	  && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13786 	{
13787 	  rest = java_complete_tree (rest);
13788 	  if (rest == error_mark_node)
13789 	    return error_mark_node;
13790 	  rest = fold (rest);
13791 	}
13792       return merge_string_cste (string, rest, invert);
13793     }
13794   return NULL_TREE;
13795 }
13796 
13797 /* Implement the `+' operator. Does static optimization if possible,
13798    otherwise create (if necessary) and append elements to a
13799    StringBuffer. The StringBuffer will be carried around until it is
13800    used for a function call or an assignment. Then toString() will be
13801    called on it to turn it into a String object. */
13802 
13803 static tree
build_string_concatenation(tree op1,tree op2)13804 build_string_concatenation (tree op1, tree op2)
13805 {
13806   tree result;
13807   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13808 
13809   if (flag_emit_xref)
13810     return build (PLUS_EXPR, string_type_node, op1, op2);
13811 
13812   /* Try to do some static optimization */
13813   if ((result = string_constant_concatenation (op1, op2)))
13814     return result;
13815 
13816   /* Discard empty strings on either side of the expression */
13817   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13818     {
13819       op1 = op2;
13820       op2 = NULL_TREE;
13821     }
13822   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13823     op2 = NULL_TREE;
13824 
13825   /* If operands are string constant, turn then into object references */
13826   if (TREE_CODE (op1) == STRING_CST)
13827     op1 = patch_string_cst (op1);
13828   if (op2 && TREE_CODE (op2) == STRING_CST)
13829     op2 = patch_string_cst (op2);
13830 
13831   /* If either one of the constant is null and the other non null
13832      operand is a String constant, return it. */
13833   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13834     return op1;
13835 
13836   /* If OP1 isn't already a StringBuffer, create and
13837      initialize a new one */
13838   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13839     {
13840       /* Two solutions here:
13841 	 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13842 	 2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13843       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13844 	op1 = BUILD_STRING_BUFFER (op1);
13845       else
13846 	{
13847 	  tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13848 	  op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13849 	}
13850     }
13851 
13852   if (op2)
13853     {
13854       /* OP1 is no longer the last node holding a crafted StringBuffer */
13855       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13856       /* Create a node for `{new...,xxx}.append (op2)' */
13857       if (op2)
13858 	op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13859     }
13860 
13861   /* Mark the last node holding a crafted StringBuffer */
13862   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13863 
13864   TREE_SIDE_EFFECTS (op1) = side_effects;
13865   return op1;
13866 }
13867 
13868 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13869    StringBuffer. If no string were found to be patched, return
13870    NULL. */
13871 
13872 static tree
patch_string(tree node)13873 patch_string (tree node)
13874 {
13875   if (node == error_mark_node)
13876     return error_mark_node;
13877   if (TREE_CODE (node) == STRING_CST)
13878     return patch_string_cst (node);
13879   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13880     {
13881       int saved = ctxp->explicit_constructor_p;
13882       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13883       tree ret;
13884       /* Temporary disable forbid the use of `this'. */
13885       ctxp->explicit_constructor_p = 0;
13886       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13887       /* String concatenation arguments must be evaluated in order too. */
13888       ret = force_evaluation_order (ret);
13889       /* Restore it at its previous value */
13890       ctxp->explicit_constructor_p = saved;
13891       return ret;
13892     }
13893   return NULL_TREE;
13894 }
13895 
13896 /* Build the internal representation of a string constant.  */
13897 
13898 static tree
patch_string_cst(tree node)13899 patch_string_cst (tree node)
13900 {
13901   int location;
13902   if (! flag_emit_class_files)
13903     {
13904       node = get_identifier (TREE_STRING_POINTER (node));
13905       location = alloc_name_constant (CONSTANT_String, node);
13906       node = build_ref_from_constant_pool (location);
13907     }
13908   TREE_TYPE (node) = string_ptr_type_node;
13909   TREE_CONSTANT (node) = 1;
13910   return node;
13911 }
13912 
13913 /* Build an incomplete unary operator expression. */
13914 
13915 static tree
build_unaryop(int op_token,int op_location,tree op1)13916 build_unaryop (int op_token, int op_location, tree op1)
13917 {
13918   enum tree_code op;
13919   tree unaryop;
13920   switch (op_token)
13921     {
13922     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13923     case MINUS_TK: op = NEGATE_EXPR; break;
13924     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13925     case NOT_TK: op = BIT_NOT_EXPR; break;
13926     default: abort ();
13927     }
13928 
13929   unaryop = build1 (op, NULL_TREE, op1);
13930   TREE_SIDE_EFFECTS (unaryop) = 1;
13931   /* Store the location of the operator, for better error report. The
13932      string of the operator will be rebuild based on the OP value. */
13933   EXPR_WFL_LINECOL (unaryop) = op_location;
13934   return unaryop;
13935 }
13936 
13937 /* Special case for the ++/-- operators, since they require an extra
13938    argument to build, which is set to NULL and patched
13939    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13940 
13941 static tree
build_incdec(int op_token,int op_location,tree op1,int is_post_p)13942 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13943 {
13944   static const enum tree_code lookup [2][2] =
13945     {
13946       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13947       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13948     };
13949   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
13950 		     NULL_TREE, op1, NULL_TREE);
13951   TREE_SIDE_EFFECTS (node) = 1;
13952   /* Store the location of the operator, for better error report. The
13953      string of the operator will be rebuild based on the OP value. */
13954   EXPR_WFL_LINECOL (node) = op_location;
13955   return node;
13956 }
13957 
13958 /* Build an incomplete cast operator, based on the use of the
13959    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13960    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13961    though its type is already set.  */
13962 
13963 static tree
build_cast(int location,tree type,tree exp)13964 build_cast (int location, tree type, tree exp)
13965 {
13966   tree node = build1 (CONVERT_EXPR, type, exp);
13967   EXPR_WFL_LINECOL (node) = location;
13968   return node;
13969 }
13970 
13971 /* Build an incomplete class reference operator.  */
13972 static tree
build_incomplete_class_ref(int location,tree class_name)13973 build_incomplete_class_ref (int location, tree class_name)
13974 {
13975   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13976   tree class_decl = GET_CPC ();
13977   tree this_class = TREE_TYPE (class_decl);
13978 
13979   /* Generate the synthetic static method `class$'.  (Previously we
13980      deferred this, causing different method tables to be emitted
13981      for native code and bytecode.)  */
13982   if (!TYPE_DOT_CLASS (this_class)
13983       && !JPRIMITIVE_TYPE_P (class_name)
13984       && !(TREE_CODE (class_name) == VOID_TYPE))
13985     {
13986       tree target_class;
13987 
13988       if (CLASS_INTERFACE (TYPE_NAME (this_class)))
13989 	{
13990 	  /* For interfaces, adding a static 'class$' method directly
13991 	     is illegal.  So create an inner class to contain the new
13992 	     method.  Empirically this matches the behavior of javac.  */
13993 	  tree t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
13994 	  tree inner = create_anonymous_class (0, t);
13995 	  target_class = TREE_TYPE (inner);
13996 	  end_class_declaration (1);
13997 	}
13998       else
13999 	{
14000 	  /* For inner classes, add a 'class$' method to their outermost
14001 	     context, creating it if necessary.  */
14002 	  while (INNER_CLASS_DECL_P (class_decl))
14003 	    class_decl = DECL_CONTEXT (class_decl);
14004 	  target_class = TREE_TYPE (class_decl);
14005 	}
14006 
14007       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
14008 	build_dot_class_method (target_class);
14009 
14010       if (this_class != target_class)
14011       	TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14012     }
14013 
14014   EXPR_WFL_LINECOL (node) = location;
14015   return node;
14016 }
14017 
14018 /* Complete an incomplete class reference operator.  */
14019 static tree
patch_incomplete_class_ref(tree node)14020 patch_incomplete_class_ref (tree node)
14021 {
14022   tree type = TREE_OPERAND (node, 0);
14023   tree ref_type;
14024 
14025   if (!(ref_type = resolve_type_during_patch (type)))
14026     return error_mark_node;
14027 
14028   /* If we're not emitting class files and we know ref_type is a
14029      compiled class, build a direct reference.  */
14030   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14031       || JPRIMITIVE_TYPE_P (ref_type)
14032       || TREE_CODE (ref_type) == VOID_TYPE)
14033     {
14034       tree dot = build_class_ref (ref_type);
14035       /* A class referenced by `foo.class' is initialized.  */
14036       if (!flag_emit_class_files)
14037        dot = build_class_init (ref_type, dot);
14038       return java_complete_tree (dot);
14039     }
14040 
14041   /* If we're emitting class files and we have to deal with non
14042      primitive types, we invoke the synthetic static method `class$'.  */
14043   ref_type = build_dot_class_method_invocation (current_class, ref_type);
14044   return java_complete_tree (ref_type);
14045 }
14046 
14047 /* 15.14 Unary operators. We return error_mark_node in case of error,
14048    but preserve the type of NODE if the type is fixed.  */
14049 
14050 static tree
patch_unaryop(tree node,tree wfl_op)14051 patch_unaryop (tree node, tree wfl_op)
14052 {
14053   tree op = TREE_OPERAND (node, 0);
14054   tree op_type = TREE_TYPE (op);
14055   tree prom_type = NULL_TREE, value, decl;
14056   int outer_field_flag = 0;
14057   int code = TREE_CODE (node);
14058   int error_found = 0;
14059 
14060   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14061 
14062   switch (code)
14063     {
14064       /* 15.13.2 Postfix Increment Operator ++ */
14065     case POSTINCREMENT_EXPR:
14066       /* 15.13.3 Postfix Increment Operator -- */
14067     case POSTDECREMENT_EXPR:
14068       /* 15.14.1 Prefix Increment Operator ++ */
14069     case PREINCREMENT_EXPR:
14070       /* 15.14.2 Prefix Decrement Operator -- */
14071     case PREDECREMENT_EXPR:
14072       op = decl = strip_out_static_field_access_decl (op);
14073       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14074       /* We might be trying to change an outer field accessed using
14075          access method. */
14076       if (outer_field_flag)
14077 	{
14078 	  /* Retrieve the decl of the field we're trying to access. We
14079              do that by first retrieving the function we would call to
14080              access the field. It has been already verified that this
14081              field isn't final */
14082 	  if (flag_emit_class_files)
14083 	    decl = TREE_OPERAND (op, 0);
14084 	  else
14085 	    decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14086 	  decl = DECL_FUNCTION_ACCESS_DECL (decl);
14087 	}
14088       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14089       else if (!JDECL_P (decl)
14090 	  && TREE_CODE (decl) != COMPONENT_REF
14091 	  && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14092 	  && TREE_CODE (decl) != INDIRECT_REF
14093 	  && !(TREE_CODE (decl) == COMPOUND_EXPR
14094 	       && TREE_OPERAND (decl, 1)
14095 	       && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14096 	{
14097 	  TREE_TYPE (node) = error_mark_node;
14098 	  error_found = 1;
14099 	}
14100 
14101       /* From now on, we know that op if a variable and that it has a
14102          valid wfl. We use wfl_op to locate errors related to the
14103          ++/-- operand. */
14104       if (!JNUMERIC_TYPE_P (op_type))
14105 	{
14106 	  parse_error_context
14107 	    (wfl_op, "Invalid argument type `%s' to `%s'",
14108 	     lang_printable_name (op_type, 0), operator_string (node));
14109 	  TREE_TYPE (node) = error_mark_node;
14110 	  error_found = 1;
14111 	}
14112       else
14113 	{
14114 	  /* Before the addition, binary numeric promotion is performed on
14115 	     both operands, if really necessary */
14116 	  if (JINTEGRAL_TYPE_P (op_type))
14117 	    {
14118 	      value = build_int_2 (1, 0);
14119 	      TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14120 	    }
14121 	  else
14122 	    {
14123 	      value = build_int_2 (1, 0);
14124 	      TREE_TYPE (node) =
14125 		binary_numeric_promotion (op_type,
14126 					  TREE_TYPE (value), &op, &value);
14127 	    }
14128 
14129 	  /* We remember we might be accessing an outer field */
14130 	  if (outer_field_flag)
14131 	    {
14132 	      /* We re-generate an access to the field */
14133 	      value = build (PLUS_EXPR, TREE_TYPE (op),
14134 			     build_outer_field_access (wfl_op, decl), value);
14135 
14136 	      /* And we patch the original access$() into a write
14137                  with plus_op as a rhs */
14138 	      return outer_field_access_fix (node, op, value);
14139 	    }
14140 
14141 	  /* And write back into the node. */
14142 	  TREE_OPERAND (node, 0) = op;
14143 	  TREE_OPERAND (node, 1) = value;
14144 	  /* Convert the overall back into its original type, if
14145              necessary, and return */
14146 	  if (JINTEGRAL_TYPE_P (op_type))
14147 	    return fold (node);
14148 	  else
14149 	    return fold (convert (op_type, node));
14150 	}
14151       break;
14152 
14153       /* 15.14.3 Unary Plus Operator + */
14154     case UNARY_PLUS_EXPR:
14155       /* 15.14.4 Unary Minus Operator - */
14156     case NEGATE_EXPR:
14157       if (!JNUMERIC_TYPE_P (op_type))
14158 	{
14159 	  ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14160 	  TREE_TYPE (node) = error_mark_node;
14161 	  error_found = 1;
14162 	}
14163       /* Unary numeric promotion is performed on operand */
14164       else
14165 	{
14166 	  op = do_unary_numeric_promotion (op);
14167 	  prom_type = TREE_TYPE (op);
14168 	  if (code == UNARY_PLUS_EXPR)
14169 	    return fold (op);
14170 	}
14171       break;
14172 
14173       /* 15.14.5 Bitwise Complement Operator ~ */
14174     case BIT_NOT_EXPR:
14175       if (!JINTEGRAL_TYPE_P (op_type))
14176 	{
14177 	  ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14178 	  TREE_TYPE (node) = error_mark_node;
14179 	  error_found = 1;
14180 	}
14181       else
14182 	{
14183 	  op = do_unary_numeric_promotion (op);
14184 	  prom_type = TREE_TYPE (op);
14185 	}
14186       break;
14187 
14188       /* 15.14.6 Logical Complement Operator ! */
14189     case TRUTH_NOT_EXPR:
14190       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14191 	{
14192 	  ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14193 	  /* But the type is known. We will report an error if further
14194 	     attempt of a assignment is made with this rhs */
14195 	  TREE_TYPE (node) = boolean_type_node;
14196 	  error_found = 1;
14197 	}
14198       else
14199 	prom_type = boolean_type_node;
14200       break;
14201 
14202       /* 15.15 Cast Expression */
14203     case CONVERT_EXPR:
14204       value = patch_cast (node, wfl_operator);
14205       if (value == error_mark_node)
14206 	{
14207 	  /* If this cast is part of an assignment, we tell the code
14208 	     that deals with it not to complain about a mismatch,
14209 	     because things have been cast, anyways */
14210 	  TREE_TYPE (node) = error_mark_node;
14211 	  error_found = 1;
14212 	}
14213       else
14214 	{
14215 	  value = fold (value);
14216 	  TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14217 	  return value;
14218 	}
14219       break;
14220     }
14221 
14222   if (error_found)
14223     return error_mark_node;
14224 
14225   /* There are cases where node has been replaced by something else
14226      and we don't end up returning here: UNARY_PLUS_EXPR,
14227      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14228   TREE_OPERAND (node, 0) = fold (op);
14229   TREE_TYPE (node) = prom_type;
14230   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14231   return fold (node);
14232 }
14233 
14234 /* Generic type resolution that sometimes takes place during node
14235    patching. Returned the resolved type or generate an error
14236    message. Return the resolved type or NULL_TREE.  */
14237 
14238 static tree
resolve_type_during_patch(tree type)14239 resolve_type_during_patch (tree type)
14240 {
14241   if (unresolved_type_p (type, NULL))
14242     {
14243       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14244       if (!type_decl)
14245 	{
14246 	  parse_error_context (type,
14247 			       "Class `%s' not found in type declaration",
14248 			       IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14249 	  return NULL_TREE;
14250 	}
14251 
14252       check_deprecation (type, type_decl);
14253 
14254       return TREE_TYPE (type_decl);
14255     }
14256   return type;
14257 }
14258 
14259 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14260    found. Otherwise NODE or something meant to replace it is returned.  */
14261 
14262 static tree
patch_cast(tree node,tree wfl_op)14263 patch_cast (tree node, tree wfl_op)
14264 {
14265   tree op = TREE_OPERAND (node, 0);
14266   tree cast_type = TREE_TYPE (node);
14267   tree patched, op_type;
14268   char *t1;
14269 
14270   /* Some string patching might be necessary at this stage */
14271   if ((patched = patch_string (op)))
14272     TREE_OPERAND (node, 0) = op = patched;
14273   op_type = TREE_TYPE (op);
14274 
14275   /* First resolve OP_TYPE if unresolved */
14276   if (!(cast_type = resolve_type_during_patch (cast_type)))
14277     return error_mark_node;
14278 
14279   /* Check on cast that are proven correct at compile time */
14280   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14281     {
14282       /* Same type */
14283       if (cast_type == op_type)
14284 	return node;
14285 
14286       /* A narrowing conversion from a floating-point number to an
14287 	 integral type requires special handling (5.1.3).  */
14288       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14289 	if (cast_type != long_type_node)
14290 	  op = convert (integer_type_node, op);
14291 
14292       /* Try widening/narrowing conversion.  Potentially, things need
14293 	 to be worked out in gcc so we implement the extreme cases
14294 	 correctly.  fold_convert() needs to be fixed.  */
14295       return convert (cast_type, op);
14296     }
14297 
14298   /* It's also valid to cast a boolean into a boolean */
14299   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14300     return node;
14301 
14302   /* null can be casted to references */
14303   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14304     return build_null_of_type (cast_type);
14305 
14306   /* The remaining legal casts involve conversion between reference
14307      types. Check for their compile time correctness. */
14308   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14309       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14310     {
14311       TREE_TYPE (node) = promote_type (cast_type);
14312       /* Now, the case can be determined correct at compile time if
14313          OP_TYPE can be converted into CAST_TYPE by assignment
14314          conversion (5.2) */
14315 
14316       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14317 	{
14318 	  TREE_SET_CODE (node, NOP_EXPR);
14319 	  return node;
14320 	}
14321 
14322       if (flag_emit_class_files)
14323 	{
14324 	  TREE_SET_CODE (node, CONVERT_EXPR);
14325 	  return node;
14326 	}
14327 
14328       /* The cast requires a run-time check */
14329       return build (CALL_EXPR, promote_type (cast_type),
14330 		    build_address_of (soft_checkcast_node),
14331 		    tree_cons (NULL_TREE, build_class_ref (cast_type),
14332 			       build_tree_list (NULL_TREE, op)),
14333 		    NULL_TREE);
14334     }
14335 
14336   /* Any other casts are proven incorrect at compile time */
14337   t1 = xstrdup (lang_printable_name (op_type, 0));
14338   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14339 		       t1, lang_printable_name (cast_type, 0));
14340   free (t1);
14341   return error_mark_node;
14342 }
14343 
14344 /* Build a null constant and give it the type TYPE.  */
14345 
14346 static tree
build_null_of_type(tree type)14347 build_null_of_type (tree type)
14348 {
14349   tree node = build_int_2 (0, 0);
14350   TREE_TYPE (node) = promote_type (type);
14351   return node;
14352 }
14353 
14354 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14355    a list of indices. */
14356 static tree
build_array_ref(int location,tree array,tree index)14357 build_array_ref (int location, tree array, tree index)
14358 {
14359   tree node = build (ARRAY_REF, NULL_TREE, array, index);
14360   EXPR_WFL_LINECOL (node) = location;
14361   return node;
14362 }
14363 
14364 /* 15.12 Array Access Expression */
14365 
14366 static tree
patch_array_ref(tree node)14367 patch_array_ref (tree node)
14368 {
14369   tree array = TREE_OPERAND (node, 0);
14370   tree array_type  = TREE_TYPE (array);
14371   tree index = TREE_OPERAND (node, 1);
14372   tree index_type = TREE_TYPE (index);
14373   int error_found = 0;
14374 
14375   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14376 
14377   if (TREE_CODE (array_type) == POINTER_TYPE)
14378     array_type = TREE_TYPE (array_type);
14379 
14380   /* The array reference must be an array */
14381   if (!TYPE_ARRAY_P (array_type))
14382     {
14383       parse_error_context
14384 	(wfl_operator,
14385 	 "`[]' can only be applied to arrays. It can't be applied to `%s'",
14386 	 lang_printable_name (array_type, 0));
14387       TREE_TYPE (node) = error_mark_node;
14388       error_found = 1;
14389     }
14390 
14391   /* The array index undergoes unary numeric promotion. The promoted
14392      type must be int */
14393   index = do_unary_numeric_promotion (index);
14394   if (TREE_TYPE (index) != int_type_node)
14395     {
14396       if (valid_cast_to_p (index_type, int_type_node))
14397 	parse_error_context (wfl_operator,
14398    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14399 			     lang_printable_name (index_type, 0));
14400       else
14401 	parse_error_context (wfl_operator,
14402           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14403 			     lang_printable_name (index_type, 0));
14404       TREE_TYPE (node) = error_mark_node;
14405       error_found = 1;
14406     }
14407 
14408   if (error_found)
14409     return error_mark_node;
14410 
14411   array_type = TYPE_ARRAY_ELEMENT (array_type);
14412 
14413   if (flag_emit_class_files || flag_emit_xref)
14414     {
14415       TREE_OPERAND (node, 0) = array;
14416       TREE_OPERAND (node, 1) = index;
14417     }
14418   else
14419     node = build_java_arrayaccess (array, array_type, index);
14420   TREE_TYPE (node) = array_type;
14421   return node;
14422 }
14423 
14424 /* 15.9 Array Creation Expressions */
14425 
14426 static tree
build_newarray_node(tree type,tree dims,int extra_dims)14427 build_newarray_node (tree type, tree dims, int extra_dims)
14428 {
14429   tree node =
14430     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14431 	   build_int_2 (extra_dims, 0));
14432   return node;
14433 }
14434 
14435 static tree
patch_newarray(tree node)14436 patch_newarray (tree node)
14437 {
14438   tree type = TREE_OPERAND (node, 0);
14439   tree dims = TREE_OPERAND (node, 1);
14440   tree cdim, array_type;
14441   int error_found = 0;
14442   int ndims = 0;
14443   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14444 
14445   /* Dimension types are verified. It's better for the types to be
14446      verified in order. */
14447   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14448     {
14449       int dim_error = 0;
14450       tree dim = TREE_VALUE (cdim);
14451 
14452       /* Dim might have been saved during its evaluation */
14453       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14454 
14455       /* The type of each specified dimension must be an integral type. */
14456       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14457 	dim_error = 1;
14458 
14459       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14460 	 promoted type must be int. */
14461       else
14462 	{
14463 	  dim = do_unary_numeric_promotion (dim);
14464 	  if (TREE_TYPE (dim) != int_type_node)
14465 	    dim_error = 1;
14466 	}
14467 
14468       /* Report errors on types here */
14469       if (dim_error)
14470 	{
14471 	  parse_error_context
14472 	    (TREE_PURPOSE (cdim),
14473 	     "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14474 	     (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14475 	      "Explicit cast needed to" : "Can't"),
14476 	     lang_printable_name (TREE_TYPE (dim), 0));
14477 	  error_found = 1;
14478 	}
14479 
14480       TREE_PURPOSE (cdim) = NULL_TREE;
14481     }
14482 
14483   /* Resolve array base type if unresolved */
14484   if (!(type = resolve_type_during_patch (type)))
14485     error_found = 1;
14486 
14487   if (error_found)
14488     {
14489       /* We don't want further evaluation of this bogus array creation
14490          operation */
14491       TREE_TYPE (node) = error_mark_node;
14492       return error_mark_node;
14493     }
14494 
14495   /* Set array_type to the actual (promoted) array type of the result. */
14496   if (TREE_CODE (type) == RECORD_TYPE)
14497     type = build_pointer_type (type);
14498   while (--xdims >= 0)
14499     {
14500       type = promote_type (build_java_array_type (type, -1));
14501     }
14502   dims = nreverse (dims);
14503   array_type = type;
14504   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14505     {
14506       type = array_type;
14507       array_type
14508 	= build_java_array_type (type,
14509 				 TREE_CODE (cdim) == INTEGER_CST
14510 				 ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14511 				 : -1);
14512       array_type = promote_type (array_type);
14513     }
14514   dims = nreverse (dims);
14515 
14516   /* The node is transformed into a function call. Things are done
14517      differently according to the number of dimensions. If the number
14518      of dimension is equal to 1, then the nature of the base type
14519      (primitive or not) matters. */
14520   if (ndims == 1)
14521     return build_new_array (type, TREE_VALUE (dims));
14522 
14523   /* Can't reuse what's already written in expr.c because it uses the
14524      JVM stack representation. Provide a build_multianewarray. FIXME */
14525   return build (CALL_EXPR, array_type,
14526 		build_address_of (soft_multianewarray_node),
14527 		tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14528 			   tree_cons (NULL_TREE,
14529 				      build_int_2 (ndims, 0), dims )),
14530 		NULL_TREE);
14531 }
14532 
14533 /* 10.6 Array initializer.  */
14534 
14535 /* Build a wfl for array element that don't have one, so we can
14536    pin-point errors.  */
14537 
14538 static tree
maybe_build_array_element_wfl(tree node)14539 maybe_build_array_element_wfl (tree node)
14540 {
14541   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14542     return build_expr_wfl (NULL_TREE, ctxp->filename,
14543 			   ctxp->elc.line, ctxp->elc.prev_col);
14544   else
14545     return NULL_TREE;
14546 }
14547 
14548 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14549    identification of initialized arrays easier to detect during walk
14550    and expansion.  */
14551 
14552 static tree
build_new_array_init(int location,tree values)14553 build_new_array_init (int location, tree values)
14554 {
14555   tree constructor = build_constructor (NULL_TREE, values);
14556   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14557   EXPR_WFL_LINECOL (to_return) = location;
14558   return to_return;
14559 }
14560 
14561 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14562    occurred.  Otherwise return NODE after having set its type
14563    appropriately.  */
14564 
14565 static tree
patch_new_array_init(tree type,tree node)14566 patch_new_array_init (tree type, tree node)
14567 {
14568   int error_seen = 0;
14569   tree current, element_type;
14570   HOST_WIDE_INT length;
14571   int all_constant = 1;
14572   tree init = TREE_OPERAND (node, 0);
14573 
14574   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14575     {
14576       parse_error_context (node,
14577 			   "Invalid array initializer for non-array type `%s'",
14578 			   lang_printable_name (type, 1));
14579       return error_mark_node;
14580     }
14581   type = TREE_TYPE (type);
14582   element_type = TYPE_ARRAY_ELEMENT (type);
14583 
14584   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14585 
14586   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14587        current;  length++, current = TREE_CHAIN (current))
14588     {
14589       tree elt = TREE_VALUE (current);
14590       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14591 	{
14592 	  error_seen |= array_constructor_check_entry (element_type, current);
14593 	  elt = TREE_VALUE (current);
14594 	  /* When compiling to native code, STRING_CST is converted to
14595 	     INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14596 	  if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14597 	    all_constant = 0;
14598 	}
14599       else
14600 	{
14601 	  TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14602 	  TREE_PURPOSE (current) = NULL_TREE;
14603 	  all_constant = 0;
14604 	}
14605       if (elt && TREE_CODE (elt) == TREE_LIST
14606 	  && TREE_VALUE (elt) == error_mark_node)
14607 	error_seen = 1;
14608     }
14609 
14610   if (error_seen)
14611     return error_mark_node;
14612 
14613   /* Create a new type. We can't reuse the one we have here by
14614      patching its dimension because it originally is of dimension -1
14615      hence reused by gcc. This would prevent triangular arrays. */
14616   type = build_java_array_type (element_type, length);
14617   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14618   TREE_TYPE (node) = promote_type (type);
14619   TREE_CONSTANT (init) = all_constant;
14620   TREE_CONSTANT (node) = all_constant;
14621   return node;
14622 }
14623 
14624 /* Verify that one entry of the initializer element list can be
14625    assigned to the array base type. Report 1 if an error occurred, 0
14626    otherwise.  */
14627 
14628 static int
array_constructor_check_entry(tree type,tree entry)14629 array_constructor_check_entry (tree type, tree entry)
14630 {
14631   char *array_type_string = NULL;	/* For error reports */
14632   tree value, type_value, new_value, wfl_value, patched;
14633   int error_seen = 0;
14634 
14635   new_value = NULL_TREE;
14636   wfl_value = TREE_VALUE (entry);
14637 
14638   value = java_complete_tree (TREE_VALUE (entry));
14639   /* patch_string return error_mark_node if arg is error_mark_node */
14640   if ((patched = patch_string (value)))
14641     value = patched;
14642   if (value == error_mark_node)
14643     return 1;
14644 
14645   type_value = TREE_TYPE (value);
14646 
14647   /* At anytime, try_builtin_assignconv can report a warning on
14648      constant overflow during narrowing. */
14649   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14650   new_value = try_builtin_assignconv (wfl_operator, type, value);
14651   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14652     type_value = promote_type (type);
14653 
14654   /* Check and report errors */
14655   if (!new_value)
14656     {
14657       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14658 		   "Can't" : "Explicit cast needed to");
14659       if (!array_type_string)
14660 	array_type_string = xstrdup (lang_printable_name (type, 1));
14661       parse_error_context
14662 	(wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14663 	 msg, lang_printable_name (type_value, 1), array_type_string);
14664       error_seen = 1;
14665     }
14666 
14667   if (new_value)
14668     TREE_VALUE (entry) = new_value;
14669 
14670   if (array_type_string)
14671     free (array_type_string);
14672 
14673   TREE_PURPOSE (entry) = NULL_TREE;
14674   return error_seen;
14675 }
14676 
14677 static tree
build_this(int location)14678 build_this (int location)
14679 {
14680   tree node = build_wfl_node (this_identifier_node);
14681   TREE_SET_CODE (node, THIS_EXPR);
14682   EXPR_WFL_LINECOL (node) = location;
14683   return node;
14684 }
14685 
14686 /* 14.15 The return statement. It builds a modify expression that
14687    assigns the returned value to the RESULT_DECL that hold the value
14688    to be returned. */
14689 
14690 static tree
build_return(int location,tree op)14691 build_return (int location, tree op)
14692 {
14693   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14694   EXPR_WFL_LINECOL (node) = location;
14695   node = build_debugable_stmt (location, node);
14696   return node;
14697 }
14698 
14699 static tree
patch_return(tree node)14700 patch_return (tree node)
14701 {
14702   tree return_exp = TREE_OPERAND (node, 0);
14703   tree meth = current_function_decl;
14704   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14705   int error_found = 0;
14706 
14707   TREE_TYPE (node) = error_mark_node;
14708   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14709 
14710   /* It's invalid to have a return value within a function that is
14711      declared with the keyword void or that is a constructor */
14712   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14713     error_found = 1;
14714 
14715   /* It's invalid to use a return statement in a static block */
14716   if (DECL_CLINIT_P (current_function_decl))
14717     error_found = 1;
14718 
14719   /* It's invalid to have a no return value within a function that
14720      isn't declared with the keyword `void' */
14721   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14722     error_found = 2;
14723 
14724   if (DECL_INSTINIT_P (current_function_decl))
14725     error_found = 1;
14726 
14727   if (error_found)
14728     {
14729       if (DECL_INSTINIT_P (current_function_decl))
14730 	parse_error_context (wfl_operator,
14731 			     "`return' inside instance initializer");
14732 
14733       else if (DECL_CLINIT_P (current_function_decl))
14734 	parse_error_context (wfl_operator,
14735 			     "`return' inside static initializer");
14736 
14737       else if (!DECL_CONSTRUCTOR_P (meth))
14738 	{
14739 	  char *t = xstrdup (lang_printable_name (mtype, 0));
14740 	  parse_error_context (wfl_operator,
14741 			       "`return' with%s value from `%s %s'",
14742 			       (error_found == 1 ? "" : "out"),
14743 			       t, lang_printable_name (meth, 0));
14744 	  free (t);
14745 	}
14746       else
14747 	parse_error_context (wfl_operator,
14748 			     "`return' with value from constructor `%s'",
14749 			     lang_printable_name (meth, 0));
14750       return error_mark_node;
14751     }
14752 
14753   /* If we have a return_exp, build a modify expression and expand
14754      it. Note: at that point, the assignment is declared valid, but we
14755      may want to carry some more hacks */
14756   if (return_exp)
14757     {
14758       tree exp = java_complete_tree (return_exp);
14759       tree modify, patched;
14760 
14761       if ((patched = patch_string (exp)))
14762 	exp = patched;
14763 
14764       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14765       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14766       modify = java_complete_tree (modify);
14767 
14768       if (modify != error_mark_node)
14769 	{
14770 	  TREE_SIDE_EFFECTS (modify) = 1;
14771 	  TREE_OPERAND (node, 0) = modify;
14772 	}
14773       else
14774 	return error_mark_node;
14775     }
14776   TREE_TYPE (node) = void_type_node;
14777   TREE_SIDE_EFFECTS (node) = 1;
14778   return node;
14779 }
14780 
14781 /* 14.8 The if Statement */
14782 
14783 static tree
build_if_else_statement(int location,tree expression,tree if_body,tree else_body)14784 build_if_else_statement (int location, tree expression, tree if_body,
14785 			 tree else_body)
14786 {
14787   tree node;
14788   if (!else_body)
14789     else_body = empty_stmt_node;
14790   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14791   EXPR_WFL_LINECOL (node) = location;
14792   node = build_debugable_stmt (location, node);
14793   return node;
14794 }
14795 
14796 static tree
patch_if_else_statement(tree node)14797 patch_if_else_statement (tree node)
14798 {
14799   tree expression = TREE_OPERAND (node, 0);
14800   int can_complete_normally
14801     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14802        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14803 
14804   TREE_TYPE (node) = error_mark_node;
14805   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14806 
14807   /* The type of expression must be boolean */
14808   if (TREE_TYPE (expression) != boolean_type_node
14809       && TREE_TYPE (expression) != promoted_boolean_type_node)
14810     {
14811       parse_error_context
14812 	(wfl_operator,
14813 	 "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14814 	 lang_printable_name (TREE_TYPE (expression), 0));
14815       return error_mark_node;
14816     }
14817 
14818   if (TREE_CODE (expression) == INTEGER_CST)
14819     {
14820       if (integer_zerop (expression))
14821 	node = TREE_OPERAND (node, 2);
14822       else
14823 	node = TREE_OPERAND (node, 1);
14824       if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14825 	{
14826 	  node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14827 	  CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14828 	}
14829       return node;
14830     }
14831   TREE_TYPE (node) = void_type_node;
14832   TREE_SIDE_EFFECTS (node) = 1;
14833   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14834   return node;
14835 }
14836 
14837 /* 14.6 Labeled Statements */
14838 
14839 /* Action taken when a labeled statement is parsed. a new
14840    LABELED_BLOCK_EXPR is created. No statement is attached to the
14841    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14842 
14843 static tree
build_labeled_block(int location,tree label)14844 build_labeled_block (int location, tree label)
14845 {
14846   tree label_name ;
14847   tree label_decl, node;
14848   if (label == NULL_TREE || label == continue_identifier_node)
14849     label_name = label;
14850   else
14851     {
14852       label_name = merge_qualified_name (label_id, label);
14853       /* Issue an error if we try to reuse a label that was previously
14854 	 declared */
14855       if (IDENTIFIER_LOCAL_VALUE (label_name))
14856 	{
14857 	  EXPR_WFL_LINECOL (wfl_operator) = location;
14858 	  parse_error_context (wfl_operator,
14859             "Declaration of `%s' shadows a previous label declaration",
14860 			       IDENTIFIER_POINTER (label));
14861 	  EXPR_WFL_LINECOL (wfl_operator) =
14862 	    EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14863 	  parse_error_context (wfl_operator,
14864             "This is the location of the previous declaration of label `%s'",
14865 			       IDENTIFIER_POINTER (label));
14866 	  java_error_count--;
14867 	}
14868     }
14869 
14870   label_decl = create_label_decl (label_name);
14871   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14872   EXPR_WFL_LINECOL (node) = location;
14873   TREE_SIDE_EFFECTS (node) = 1;
14874   return node;
14875 }
14876 
14877 /* A labeled statement LBE is attached a statement.  */
14878 
14879 static tree
finish_labeled_statement(tree lbe,tree statement)14880 finish_labeled_statement (tree lbe, /* Labeled block expr */
14881 			  tree statement)
14882 {
14883   /* In anyways, tie the loop to its statement */
14884   LABELED_BLOCK_BODY (lbe) = statement;
14885   pop_labeled_block ();
14886   POP_LABELED_BLOCK ();
14887   return lbe;
14888 }
14889 
14890 /* 14.10, 14.11, 14.12 Loop Statements */
14891 
14892 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14893    list. */
14894 
14895 static tree
build_new_loop(tree loop_body)14896 build_new_loop (tree loop_body)
14897 {
14898   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
14899   TREE_SIDE_EFFECTS (loop) = 1;
14900   PUSH_LOOP (loop);
14901   return loop;
14902 }
14903 
14904 /* Create a loop body according to the following structure:
14905      COMPOUND_EXPR
14906        COMPOUND_EXPR		(loop main body)
14907          EXIT_EXPR		(this order is for while/for loops.
14908          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14909            LABEL_DECL           (a continue occurring here branches at the
14910            BODY			 end of this labeled block)
14911        INCREMENT		(if any)
14912 
14913   REVERSED, if nonzero, tells that the loop condition expr comes
14914   after the body, like in the do-while loop.
14915 
14916   To obtain a loop, the loop body structure described above is
14917   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14918 
14919    LABELED_BLOCK_EXPR
14920      LABEL_DECL                   (use this label to exit the loop)
14921      LOOP_EXPR
14922        <structure described above> */
14923 
14924 static tree
build_loop_body(int location,tree condition,int reversed)14925 build_loop_body (int location, tree condition, int reversed)
14926 {
14927   tree first, second, body;
14928 
14929   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14930   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14931   condition = build_debugable_stmt (location, condition);
14932   TREE_SIDE_EFFECTS (condition) = 1;
14933 
14934   body = build_labeled_block (0, continue_identifier_node);
14935   first = (reversed ? body : condition);
14936   second = (reversed ? condition : body);
14937   return
14938     build (COMPOUND_EXPR, NULL_TREE,
14939 	   build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
14940 }
14941 
14942 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14943    their order) on the current loop. Unlink the current loop from the
14944    loop list.  */
14945 
14946 static tree
finish_loop_body(int location,tree condition,tree body,int reversed)14947 finish_loop_body (int location, tree condition, tree body, int reversed)
14948 {
14949   tree to_return = ctxp->current_loop;
14950   tree loop_body = LOOP_EXPR_BODY (to_return);
14951   if (condition)
14952     {
14953       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14954       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14955          The real EXIT_EXPR is one operand further. */
14956       EXPR_WFL_LINECOL (cnode) = location;
14957       /* This one is for accurate error reports */
14958       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14959       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14960     }
14961   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14962   POP_LOOP ();
14963   return to_return;
14964 }
14965 
14966 /* Tailored version of finish_loop_body for FOR loops, when FOR
14967    loops feature the condition part */
14968 
14969 static tree
finish_for_loop(int location,tree condition,tree update,tree body)14970 finish_for_loop (int location, tree condition, tree update, tree body)
14971 {
14972   /* Put the condition and the loop body in place */
14973   tree loop = finish_loop_body (location, condition, body, 0);
14974   /* LOOP is the current loop which has been now popped of the loop
14975      stack.  Mark the update block as reachable and install it.  We do
14976      this because the (current interpretation of the) JLS requires
14977      that the update expression be considered reachable even if the
14978      for loop's body doesn't complete normally.  */
14979   if (update != NULL_TREE && update != empty_stmt_node)
14980     {
14981       tree up2 = update;
14982       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14983 	up2 = EXPR_WFL_NODE (up2);
14984       /* It is possible for the update expression to be an
14985 	 EXPR_WFL_NODE wrapping nothing.  */
14986       if (up2 != NULL_TREE && up2 != empty_stmt_node)
14987 	{
14988 	  /* Try to detect constraint violations.  These would be
14989 	     programming errors somewhere.  */
14990 	  if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
14991 	      || TREE_CODE (up2) == LOOP_EXPR)
14992 	    abort ();
14993 	  SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
14994 	}
14995     }
14996   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14997   return loop;
14998 }
14999 
15000 /* Try to find the loop a block might be related to. This comprises
15001    the case where the LOOP_EXPR is found as the second operand of a
15002    COMPOUND_EXPR, because the loop happens to have an initialization
15003    part, then expressed as the first operand of the COMPOUND_EXPR. If
15004    the search finds something, 1 is returned. Otherwise, 0 is
15005    returned. The search is assumed to start from a
15006    LABELED_BLOCK_EXPR's block.  */
15007 
15008 static tree
search_loop(tree statement)15009 search_loop (tree statement)
15010 {
15011   if (TREE_CODE (statement) == LOOP_EXPR)
15012     return statement;
15013 
15014   if (TREE_CODE (statement) == BLOCK)
15015     statement = BLOCK_SUBBLOCKS (statement);
15016   else
15017     return NULL_TREE;
15018 
15019   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15020     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15021       statement = TREE_OPERAND (statement, 1);
15022 
15023   return (TREE_CODE (statement) == LOOP_EXPR
15024 	  && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15025 }
15026 
15027 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15028    returned otherwise.  */
15029 
15030 static int
labeled_block_contains_loop_p(tree block,tree loop)15031 labeled_block_contains_loop_p (tree block, tree loop)
15032 {
15033   if (!block)
15034     return 0;
15035 
15036   if (LABELED_BLOCK_BODY (block) == loop)
15037     return 1;
15038 
15039   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15040     return 1;
15041 
15042   return 0;
15043 }
15044 
15045 /* If the loop isn't surrounded by a labeled statement, create one and
15046    insert LOOP as its body.  */
15047 
15048 static tree
patch_loop_statement(tree loop)15049 patch_loop_statement (tree loop)
15050 {
15051   tree loop_label;
15052 
15053   TREE_TYPE (loop) = void_type_node;
15054   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15055     return loop;
15056 
15057   loop_label = build_labeled_block (0, NULL_TREE);
15058   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15059      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15060   LABELED_BLOCK_BODY (loop_label) = loop;
15061   PUSH_LABELED_BLOCK (loop_label);
15062   return loop_label;
15063 }
15064 
15065 /* 14.13, 14.14: break and continue Statements */
15066 
15067 /* Build a break or a continue statement. a null NAME indicates an
15068    unlabeled break/continue statement.  */
15069 
15070 static tree
build_bc_statement(int location,int is_break,tree name)15071 build_bc_statement (int location, int is_break, tree name)
15072 {
15073   tree break_continue, label_block_expr = NULL_TREE;
15074 
15075   if (name)
15076     {
15077       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15078 	    (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15079 	/* Null means that we don't have a target for this named
15080 	   break/continue. In this case, we make the target to be the
15081 	   label name, so that the error can be reported accurately in
15082 	   patch_bc_statement. */
15083 	label_block_expr = EXPR_WFL_NODE (name);
15084     }
15085   /* Unlabeled break/continue will be handled during the
15086      break/continue patch operation */
15087   break_continue
15088     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15089 
15090   IS_BREAK_STMT_P (break_continue) = is_break;
15091   TREE_SIDE_EFFECTS (break_continue) = 1;
15092   EXPR_WFL_LINECOL (break_continue) = location;
15093   break_continue = build_debugable_stmt (location, break_continue);
15094   return break_continue;
15095 }
15096 
15097 /* Verification of a break/continue statement. */
15098 
15099 static tree
patch_bc_statement(tree node)15100 patch_bc_statement (tree node)
15101 {
15102   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15103   tree labeled_block = ctxp->current_labeled_block;
15104   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15105 
15106   /* Having an identifier here means that the target is unknown. */
15107   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15108     {
15109       parse_error_context (wfl_operator, "No label definition found for `%s'",
15110 			   IDENTIFIER_POINTER (bc_label));
15111       return error_mark_node;
15112     }
15113   if (! IS_BREAK_STMT_P (node))
15114     {
15115       /* It's a continue statement. */
15116       for (;; labeled_block = TREE_CHAIN (labeled_block))
15117 	{
15118 	  if (labeled_block == NULL_TREE)
15119 	    {
15120 	      if (bc_label == NULL_TREE)
15121 		parse_error_context (wfl_operator,
15122 				     "`continue' must be in loop");
15123 	      else
15124 		parse_error_context
15125 		  (wfl_operator, "continue label `%s' does not name a loop",
15126 		   IDENTIFIER_POINTER (bc_label));
15127 	      return error_mark_node;
15128 	    }
15129 	  if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15130 	       == continue_identifier_node)
15131 	      && (bc_label == NULL_TREE
15132 		  || TREE_CHAIN (labeled_block) == bc_label))
15133 	    {
15134 	      bc_label = labeled_block;
15135 	      break;
15136 	    }
15137 	}
15138     }
15139   else if (!bc_label)
15140     {
15141       for (;; labeled_block = TREE_CHAIN (labeled_block))
15142 	{
15143 	  if (labeled_block == NULL_TREE)
15144 	    {
15145 	      parse_error_context (wfl_operator,
15146 				     "`break' must be in loop or switch");
15147 	      return error_mark_node;
15148 	    }
15149 	  target_stmt = LABELED_BLOCK_BODY (labeled_block);
15150 	  if (TREE_CODE (target_stmt) == SWITCH_EXPR
15151 	      || search_loop (target_stmt))
15152 	    {
15153 	      bc_label = labeled_block;
15154 	      break;
15155 	    }
15156 	}
15157     }
15158 
15159   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15160   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15161 
15162   /* Our break/continue don't return values. */
15163   TREE_TYPE (node) = void_type_node;
15164   /* Encapsulate the break within a compound statement so that it's
15165      expanded all the times by expand_expr (and not clobbered
15166      sometimes, like after a if statement) */
15167   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15168   TREE_SIDE_EFFECTS (node) = 1;
15169   return node;
15170 }
15171 
15172 /* Process the exit expression belonging to a loop. Its type must be
15173    boolean.  */
15174 
15175 static tree
patch_exit_expr(tree node)15176 patch_exit_expr (tree node)
15177 {
15178   tree expression = TREE_OPERAND (node, 0);
15179   TREE_TYPE (node) = error_mark_node;
15180   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15181 
15182   /* The type of expression must be boolean */
15183   if (TREE_TYPE (expression) != boolean_type_node)
15184     {
15185       parse_error_context
15186 	(wfl_operator,
15187     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15188 	 lang_printable_name (TREE_TYPE (expression), 0));
15189       return error_mark_node;
15190     }
15191   /* Now we know things are allright, invert the condition, fold and
15192      return */
15193   TREE_OPERAND (node, 0) =
15194     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15195 
15196   if (! integer_zerop (TREE_OPERAND (node, 0))
15197       && ctxp->current_loop != NULL_TREE
15198       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15199     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15200   if (! integer_onep (TREE_OPERAND (node, 0)))
15201     CAN_COMPLETE_NORMALLY (node) = 1;
15202 
15203 
15204   TREE_TYPE (node) = void_type_node;
15205   return node;
15206 }
15207 
15208 /* 14.9 Switch statement */
15209 
15210 static tree
patch_switch_statement(tree node)15211 patch_switch_statement (tree node)
15212 {
15213   tree se = TREE_OPERAND (node, 0), se_type;
15214   tree save, iter;
15215 
15216   /* Complete the switch expression */
15217   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15218   se_type = TREE_TYPE (se);
15219   /* The type of the switch expression must be char, byte, short or
15220      int */
15221   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15222     {
15223       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15224       parse_error_context (wfl_operator,
15225 	  "Incompatible type for `switch'. Can't convert `%s' to `int'",
15226 			   lang_printable_name (se_type, 0));
15227       /* This is what java_complete_tree will check */
15228       TREE_OPERAND (node, 0) = error_mark_node;
15229       return error_mark_node;
15230     }
15231 
15232   /* Save and restore the outer case label list.  */
15233   save = case_label_list;
15234   case_label_list = NULL_TREE;
15235 
15236   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15237 
15238   /* See if we've found a duplicate label.  We can't leave this until
15239      code generation, because in `--syntax-only' and `-C' modes we
15240      don't do ordinary code generation.  */
15241   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15242     {
15243       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15244       tree subiter;
15245       for (subiter = TREE_CHAIN (iter);
15246 	   subiter != NULL_TREE;
15247 	   subiter = TREE_CHAIN (subiter))
15248 	{
15249 	  HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15250 	  if (val == subval)
15251 	    {
15252 	      EXPR_WFL_LINECOL (wfl_operator)
15253 		= EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15254 	      /* The case_label_list is in reverse order, so print the
15255 		 outer label first.  */
15256 	      parse_error_context (wfl_operator, "duplicate case label: `"
15257 				   HOST_WIDE_INT_PRINT_DEC "'", subval);
15258 	      EXPR_WFL_LINECOL (wfl_operator)
15259 		= EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15260 	      parse_error_context (wfl_operator, "original label is here");
15261 
15262 	      break;
15263 	    }
15264 	}
15265     }
15266 
15267   case_label_list = save;
15268 
15269   /* Ready to return */
15270   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15271     {
15272       TREE_TYPE (node) = error_mark_node;
15273       return error_mark_node;
15274     }
15275   TREE_TYPE (node) = void_type_node;
15276   TREE_SIDE_EFFECTS (node) = 1;
15277   CAN_COMPLETE_NORMALLY (node)
15278     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15279       || ! SWITCH_HAS_DEFAULT (node);
15280   return node;
15281 }
15282 
15283 /* Assertions.  */
15284 
15285 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15286    might be NULL_TREE.  */
15287 static tree
build_assertion(int location,tree condition,tree value)15288 build_assertion (int location, tree condition, tree value)
15289 {
15290   tree node;
15291   tree klass = GET_CPC ();
15292 
15293   if (! CLASS_USES_ASSERTIONS (klass))
15294     {
15295       tree field, classdollar, id, call;
15296       tree class_type = TREE_TYPE (klass);
15297 
15298       field = add_field (class_type,
15299 			 get_identifier ("$assertionsDisabled"),
15300 			 boolean_type_node,
15301 			 ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15302       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15303       FIELD_SYNTHETIC (field) = 1;
15304 
15305       if (!TYPE_DOT_CLASS (class_type))
15306 	build_dot_class_method (class_type);
15307       classdollar = build_dot_class_method_invocation (class_type, class_type);
15308 
15309       /* Call CLASS.desiredAssertionStatus().  */
15310       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15311       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15312       call = make_qualified_primary (classdollar, call, location);
15313       TREE_SIDE_EFFECTS (call) = 1;
15314 
15315       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15316 	 seem odd, but we do it to generate code identical to that of
15317 	 the JDK.  */
15318       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15319       TREE_SIDE_EFFECTS (call) = 1;
15320       DECL_INITIAL (field) = call;
15321 
15322       /* Record the initializer in the initializer statement list.  */
15323       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15324       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15325       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15326       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15327 
15328       CLASS_USES_ASSERTIONS (klass) = 1;
15329     }
15330 
15331   if (value != NULL_TREE)
15332     value = tree_cons (NULL_TREE, value, NULL_TREE);
15333 
15334   node = build_wfl_node (get_identifier ("java"));
15335   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15336 			      location);
15337   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15338 			      location);
15339 
15340   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15341   TREE_SIDE_EFFECTS (node) = 1;
15342   /* It is too early to use BUILD_THROW.  */
15343   node = build1 (THROW_EXPR, NULL_TREE, node);
15344   TREE_SIDE_EFFECTS (node) = 1;
15345 
15346   /* We invert the condition; if we just put NODE as the `else' part
15347      then we generate weird-looking bytecode.  */
15348   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15349   /* Check $assertionsDisabled.  */
15350   condition
15351     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15352 	     build1 (TRUTH_NOT_EXPR, NULL_TREE,
15353 		     build_wfl_node (get_identifier ("$assertionsDisabled"))),
15354 	     condition);
15355   node = build_if_else_statement (location, condition, node, NULL_TREE);
15356   return node;
15357 }
15358 
15359 /* 14.18 The try/catch statements */
15360 
15361 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15362    catches TYPE and executes CATCH_STMTS.  */
15363 
15364 static tree
encapsulate_with_try_catch(int location,tree type_or_name,tree try_stmts,tree catch_stmts)15365 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15366 			    tree catch_stmts)
15367 {
15368   tree try_block, catch_clause_param, catch_block, catch;
15369 
15370   /* First build a try block */
15371   try_block = build_expr_block (try_stmts, NULL_TREE);
15372 
15373   /* Build a catch block: we need a catch clause parameter */
15374   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15375     {
15376       tree catch_type = obtain_incomplete_type (type_or_name);
15377       jdep *dep;
15378       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15379       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15380 				catch_clause_param, catch_type);
15381       dep = CLASSD_LAST (ctxp->classd_list);
15382       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15383     }
15384   else
15385     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15386 				     build_pointer_type (type_or_name));
15387 
15388   /* And a block */
15389   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15390 
15391   /* Initialize the variable and store in the block */
15392   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15393 		 build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15394   add_stmt_to_block (catch_block, NULL_TREE, catch);
15395 
15396   /* Add the catch statements */
15397   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15398 
15399   /* Now we can build a CATCH_EXPR */
15400   catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15401 
15402   return build_try_statement (location, try_block, catch_block);
15403 }
15404 
15405 static tree
build_try_statement(int location,tree try_block,tree catches)15406 build_try_statement (int location, tree try_block, tree catches)
15407 {
15408   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15409   EXPR_WFL_LINECOL (node) = location;
15410   return node;
15411 }
15412 
15413 static tree
build_try_finally_statement(int location,tree try_block,tree finally)15414 build_try_finally_statement (int location, tree try_block, tree finally)
15415 {
15416   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15417   EXPR_WFL_LINECOL (node) = location;
15418   return node;
15419 }
15420 
15421 static tree
patch_try_statement(tree node)15422 patch_try_statement (tree node)
15423 {
15424   int error_found = 0;
15425   tree try = TREE_OPERAND (node, 0);
15426   /* Exception handlers are considered in left to right order */
15427   tree catch = nreverse (TREE_OPERAND (node, 1));
15428   tree current, caught_type_list = NULL_TREE;
15429 
15430   /* Check catch clauses, if any. Every time we find an error, we try
15431      to process the next catch clause. We process the catch clause before
15432      the try block so that when processing the try block we can check thrown
15433      exceptions againts the caught type list. */
15434   for (current = catch; current; current = TREE_CHAIN (current))
15435     {
15436       tree carg_decl, carg_type;
15437       tree sub_current, catch_block, catch_clause;
15438       int unreachable;
15439 
15440       /* At this point, the structure of the catch clause is
15441 	   CATCH_EXPR		(catch node)
15442 	     BLOCK	        (with the decl of the parameter)
15443                COMPOUND_EXPR
15444                  MODIFY_EXPR   (assignment of the catch parameter)
15445 		 BLOCK	        (catch clause block)
15446        */
15447       catch_clause = TREE_OPERAND (current, 0);
15448       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15449       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15450 
15451       /* Catch clauses can't have more than one parameter declared,
15452 	 but it's already enforced by the grammar. Make sure that the
15453 	 only parameter of the clause statement in of class Throwable
15454 	 or a subclass of Throwable, but that was done earlier. The
15455 	 catch clause parameter type has also been resolved. */
15456 
15457       /* Just make sure that the catch clause parameter type inherits
15458 	 from java.lang.Throwable */
15459       if (!inherits_from_p (carg_type, throwable_type_node))
15460 	{
15461 	  EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15462 	  parse_error_context (wfl_operator,
15463 			       "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15464 			       lang_printable_name (carg_type, 0));
15465 	  error_found = 1;
15466 	  continue;
15467 	}
15468 
15469       /* Partial check for unreachable catch statement: The catch
15470 	 clause is reachable iff is no earlier catch block A in
15471 	 the try statement such that the type of the catch
15472 	 clause's parameter is the same as or a subclass of the
15473 	 type of A's parameter */
15474       unreachable = 0;
15475       for (sub_current = catch;
15476 	   sub_current != current; sub_current = TREE_CHAIN (sub_current))
15477 	{
15478 	  tree sub_catch_clause, decl;
15479 	  sub_catch_clause = TREE_OPERAND (sub_current, 0);
15480 	  decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15481 
15482 	  if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15483 	    {
15484 	      EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15485 	      parse_error_context
15486 		(wfl_operator,
15487 		 "`catch' not reached because of the catch clause at line %d",
15488 		 EXPR_WFL_LINENO (sub_current));
15489 	      unreachable = error_found = 1;
15490 	      break;
15491 	    }
15492 	}
15493       /* Complete the catch clause block */
15494       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15495       if (catch_block == error_mark_node)
15496 	{
15497 	  error_found = 1;
15498 	  continue;
15499 	}
15500       if (CAN_COMPLETE_NORMALLY (catch_block))
15501 	CAN_COMPLETE_NORMALLY (node) = 1;
15502       TREE_OPERAND (current, 0) = catch_block;
15503 
15504       if (unreachable)
15505 	continue;
15506 
15507       /* Things to do here: the exception must be thrown */
15508 
15509       /* Link this type to the caught type list */
15510       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15511     }
15512 
15513   PUSH_EXCEPTIONS (caught_type_list);
15514   if ((try = java_complete_tree (try)) == error_mark_node)
15515     error_found = 1;
15516   if (CAN_COMPLETE_NORMALLY (try))
15517     CAN_COMPLETE_NORMALLY (node) = 1;
15518   POP_EXCEPTIONS ();
15519 
15520   /* Verification ends here */
15521   if (error_found)
15522     return error_mark_node;
15523 
15524   TREE_OPERAND (node, 0) = try;
15525   TREE_OPERAND (node, 1) = catch;
15526   TREE_TYPE (node) = void_type_node;
15527   return node;
15528 }
15529 
15530 /* 14.17 The synchronized Statement */
15531 
15532 static tree
patch_synchronized_statement(tree node,tree wfl_op1)15533 patch_synchronized_statement (tree node, tree wfl_op1)
15534 {
15535   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15536   tree block = TREE_OPERAND (node, 1);
15537 
15538   tree tmp, enter, exit, expr_decl, assignment;
15539 
15540   if (expr == error_mark_node)
15541     {
15542       block = java_complete_tree (block);
15543       return expr;
15544     }
15545 
15546   /* We might be trying to synchronize on a STRING_CST */
15547   if ((tmp = patch_string (expr)))
15548     expr = tmp;
15549 
15550   /* The TYPE of expr must be a reference type */
15551   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15552     {
15553       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15554       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15555 			   lang_printable_name (TREE_TYPE (expr), 0));
15556       return error_mark_node;
15557     }
15558 
15559   if (flag_emit_xref)
15560     {
15561       TREE_OPERAND (node, 0) = expr;
15562       TREE_OPERAND (node, 1) = java_complete_tree (block);
15563       CAN_COMPLETE_NORMALLY (node) = 1;
15564       return node;
15565     }
15566 
15567   /* Generate a try-finally for the synchronized statement, except
15568      that the handler that catches all throw exception calls
15569      _Jv_MonitorExit and then rethrow the exception.
15570      The synchronized statement is then implemented as:
15571      TRY
15572        {
15573          _Jv_MonitorEnter (expression)
15574 	 synchronized_block
15575          _Jv_MonitorExit (expression)
15576        }
15577      CATCH_ALL
15578        {
15579          e = _Jv_exception_info ();
15580 	 _Jv_MonitorExit (expression)
15581 	 Throw (e);
15582        } */
15583 
15584   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15585   BUILD_MONITOR_ENTER (enter, expr_decl);
15586   BUILD_MONITOR_EXIT (exit, expr_decl);
15587   CAN_COMPLETE_NORMALLY (enter) = 1;
15588   CAN_COMPLETE_NORMALLY (exit) = 1;
15589   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15590   TREE_SIDE_EFFECTS (assignment) = 1;
15591   node = build (COMPOUND_EXPR, NULL_TREE,
15592 		build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15593 		build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15594   node = build_expr_block (node, expr_decl);
15595 
15596   return java_complete_tree (node);
15597 }
15598 
15599 /* 14.16 The throw Statement */
15600 
15601 static tree
patch_throw_statement(tree node,tree wfl_op1)15602 patch_throw_statement (tree node, tree wfl_op1)
15603 {
15604   tree expr = TREE_OPERAND (node, 0);
15605   tree type = TREE_TYPE (expr);
15606   int unchecked_ok = 0, tryblock_throws_ok = 0;
15607 
15608   /* Thrown expression must be assignable to java.lang.Throwable */
15609   if (!try_reference_assignconv (throwable_type_node, expr))
15610     {
15611       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15612       parse_error_context (wfl_operator,
15613     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15614 			   lang_printable_name (type, 0));
15615       /* If the thrown expression was a reference, we further the
15616          compile-time check. */
15617       if (!JREFERENCE_TYPE_P (type))
15618 	return error_mark_node;
15619     }
15620 
15621   /* At least one of the following must be true */
15622 
15623   /* The type of the throw expression is a not checked exception,
15624      i.e. is a unchecked expression. */
15625   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15626 
15627   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15628   /* An instance can't throw a checked exception unless that exception
15629      is explicitly declared in the `throws' clause of each
15630      constructor. This doesn't apply to anonymous classes, since they
15631      don't have declared constructors. */
15632   if (!unchecked_ok
15633       && DECL_INSTINIT_P (current_function_decl)
15634       && !ANONYMOUS_CLASS_P (current_class))
15635     {
15636       tree current;
15637       for (current = TYPE_METHODS (current_class); current;
15638 	   current = TREE_CHAIN (current))
15639 	if (DECL_CONSTRUCTOR_P (current)
15640 	    && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15641 	  {
15642 	    parse_error_context (wfl_operator, "Checked exception `%s' can't be thrown in instance initializer (not all declared constructor are declaring it in their `throws' clause)",
15643 				 lang_printable_name (TREE_TYPE (expr), 0));
15644 	    return error_mark_node;
15645 	  }
15646     }
15647 
15648   /* Throw is contained in a try statement and at least one catch
15649      clause can receive the thrown expression or the current method is
15650      declared to throw such an exception. Or, the throw statement is
15651      contained in a method or constructor declaration and the type of
15652      the Expression is assignable to at least one type listed in the
15653      throws clause the declaration. */
15654   if (!unchecked_ok)
15655     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15656   if (!(unchecked_ok || tryblock_throws_ok))
15657     {
15658       /* If there is a surrounding try block that has no matching
15659 	 clatch clause, report it first. A surrounding try block exits
15660 	 only if there is something after the list of checked
15661 	 exception thrown by the current function (if any). */
15662       if (IN_TRY_BLOCK_P ())
15663 	parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15664 			     lang_printable_name (type, 0));
15665       /* If we have no surrounding try statement and the method doesn't have
15666 	 any throws, report it now. FIXME */
15667 
15668       /* We report that the exception can't be throw from a try block
15669          in all circumstances but when the `throw' is inside a static
15670          block. */
15671       else if (!EXCEPTIONS_P (currently_caught_type_list)
15672 	       && !tryblock_throws_ok)
15673 	{
15674 	  if (DECL_CLINIT_P (current_function_decl))
15675 	    parse_error_context (wfl_operator,
15676                    "Checked exception `%s' can't be thrown in initializer",
15677 				 lang_printable_name (type, 0));
15678 	  else
15679 	    parse_error_context (wfl_operator,
15680                    "Checked exception `%s' isn't thrown from a `try' block",
15681 				 lang_printable_name (type, 0));
15682 	}
15683       /* Otherwise, the current method doesn't have the appropriate
15684          throws declaration */
15685       else
15686 	parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15687 			     lang_printable_name (type, 0));
15688       return error_mark_node;
15689     }
15690 
15691   if (! flag_emit_class_files && ! flag_emit_xref)
15692     BUILD_THROW (node, expr);
15693 
15694   /* If doing xrefs, keep the location where the `throw' was seen. */
15695   if (flag_emit_xref)
15696     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15697   return node;
15698 }
15699 
15700 /* Check that exception said to be thrown by method DECL can be
15701    effectively caught from where DECL is invoked.  THIS_EXPR is the
15702    expression that computes `this' for the method call.  */
15703 static void
check_thrown_exceptions(int location,tree decl,tree this_expr)15704 check_thrown_exceptions (int location, tree decl, tree this_expr)
15705 {
15706   tree throws;
15707   int is_array_call = 0;
15708 
15709   /* Skip check within generated methods, such as access$<n>.  */
15710   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15711     return;
15712 
15713   if (this_expr != NULL_TREE
15714       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15715       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15716     is_array_call = 1;
15717 
15718   /* For all the unchecked exceptions thrown by DECL.  */
15719   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15720        throws = TREE_CHAIN (throws))
15721     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15722       {
15723 	/* Suppress errors about cloning arrays.  */
15724 	if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15725 	  continue;
15726 
15727 	EXPR_WFL_LINECOL (wfl_operator) = location;
15728 	if (DECL_FINIT_P (current_function_decl))
15729 	  parse_error_context
15730             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15731 	     lang_printable_name (TREE_VALUE (throws), 0));
15732 	else
15733 	  {
15734 	    parse_error_context
15735 	      (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15736 	       lang_printable_name (TREE_VALUE (throws), 0),
15737 	       (DECL_INIT_P (current_function_decl) ?
15738 		IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15739 		IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15740 	  }
15741       }
15742 }
15743 
15744 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15745    try-catch blocks, OR is listed in the `throws' clause of the
15746    current method.  */
15747 
15748 static int
check_thrown_exceptions_do(tree exception)15749 check_thrown_exceptions_do (tree exception)
15750 {
15751   tree list = currently_caught_type_list;
15752   resolve_and_layout (exception, NULL_TREE);
15753   /* First, all the nested try-catch-finally at that stage. The
15754      last element contains `throws' clause exceptions, if any. */
15755   if (IS_UNCHECKED_EXCEPTION_P (exception))
15756     return 1;
15757   while (list)
15758     {
15759       tree caught;
15760       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15761 	if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15762 	  return 1;
15763       list = TREE_CHAIN (list);
15764     }
15765   return 0;
15766 }
15767 
15768 static void
purge_unchecked_exceptions(tree mdecl)15769 purge_unchecked_exceptions (tree mdecl)
15770 {
15771   tree throws = DECL_FUNCTION_THROWS (mdecl);
15772   tree new = NULL_TREE;
15773 
15774   while (throws)
15775     {
15776       tree next = TREE_CHAIN (throws);
15777       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15778 	{
15779 	  TREE_CHAIN (throws) = new;
15780 	  new = throws;
15781 	}
15782       throws = next;
15783     }
15784   /* List is inverted here, but it doesn't matter */
15785   DECL_FUNCTION_THROWS (mdecl) = new;
15786 }
15787 
15788 /* This function goes over all of CLASS_TYPE ctors and checks whether
15789    each of them features at least one unchecked exception in its
15790    `throws' clause. If it's the case, it returns `true', `false'
15791    otherwise.  */
15792 
15793 static bool
ctors_unchecked_throws_clause_p(tree class_type)15794 ctors_unchecked_throws_clause_p (tree class_type)
15795 {
15796   tree current;
15797 
15798   for (current = TYPE_METHODS (class_type); current;
15799        current = TREE_CHAIN (current))
15800     {
15801       bool ctu = false;	/* Ctor Throws Unchecked */
15802       if (DECL_CONSTRUCTOR_P (current))
15803 	{
15804 	  tree throws;
15805 	  for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15806 	       throws = TREE_CHAIN (throws))
15807 	    if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15808 	      ctu = true;
15809 	}
15810       /* We return false as we found one ctor that is unfit. */
15811       if (!ctu && DECL_CONSTRUCTOR_P (current))
15812 	return false;
15813     }
15814   /* All ctors feature at least one unchecked exception in their
15815      `throws' clause. */
15816   return true;
15817 }
15818 
15819 /* 15.24 Conditional Operator ?: */
15820 
15821 static tree
patch_conditional_expr(tree node,tree wfl_cond,tree wfl_op1)15822 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15823 {
15824   tree cond = TREE_OPERAND (node, 0);
15825   tree op1 = TREE_OPERAND (node, 1);
15826   tree op2 = TREE_OPERAND (node, 2);
15827   tree resulting_type = NULL_TREE;
15828   tree t1, t2, patched;
15829   int error_found = 0;
15830 
15831   /* Operands of ?: might be StringBuffers crafted as a result of a
15832      string concatenation. Obtain a descent operand here.  */
15833   if ((patched = patch_string (op1)))
15834     TREE_OPERAND (node, 1) = op1 = patched;
15835   if ((patched = patch_string (op2)))
15836     TREE_OPERAND (node, 2) = op2 = patched;
15837 
15838   t1 = TREE_TYPE (op1);
15839   t2 = TREE_TYPE (op2);
15840 
15841   /* The first expression must be a boolean */
15842   if (TREE_TYPE (cond) != boolean_type_node)
15843     {
15844       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15845       parse_error_context (wfl_operator,
15846                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15847 			   lang_printable_name (TREE_TYPE (cond), 0));
15848       error_found = 1;
15849     }
15850 
15851   /* Second and third can be numeric, boolean (i.e. primitive),
15852      references or null. Anything else results in an error */
15853   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15854 	|| ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15855 	    && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15856 	|| (t1 == boolean_type_node && t2 == boolean_type_node)))
15857     error_found = 1;
15858 
15859   /* Determine the type of the conditional expression. Same types are
15860      easy to deal with */
15861   else if (t1 == t2)
15862     resulting_type = t1;
15863 
15864   /* There are different rules for numeric types */
15865   else if (JNUMERIC_TYPE_P (t1))
15866     {
15867       /* if byte/short found, the resulting type is short */
15868       if ((t1 == byte_type_node && t2 == short_type_node)
15869 	  || (t1 == short_type_node && t2 == byte_type_node))
15870 	resulting_type = short_type_node;
15871 
15872       /* If t1 is a constant int and t2 is of type byte, short or char
15873 	 and t1's value fits in t2, then the resulting type is t2 */
15874       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15875 	  && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15876 	resulting_type = t2;
15877 
15878       /* If t2 is a constant int and t1 is of type byte, short or char
15879 	 and t2's value fits in t1, then the resulting type is t1 */
15880       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15881 	  && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15882 	resulting_type = t1;
15883 
15884       /* Otherwise, binary numeric promotion is applied and the
15885 	 resulting type is the promoted type of operand 1 and 2 */
15886       else
15887 	resulting_type = binary_numeric_promotion (t1, t2,
15888 						   &TREE_OPERAND (node, 1),
15889 						   &TREE_OPERAND (node, 2));
15890     }
15891 
15892   /* Cases of a reference and a null type */
15893   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15894     resulting_type = t1;
15895 
15896   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15897     resulting_type = t2;
15898 
15899   /* Last case: different reference types. If a type can be converted
15900      into the other one by assignment conversion, the latter
15901      determines the type of the expression */
15902   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15903     resulting_type = promote_type (t1);
15904 
15905   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15906     resulting_type = promote_type (t2);
15907 
15908   /* If we don't have any resulting type, we're in trouble */
15909   if (!resulting_type)
15910     {
15911       char *t = xstrdup (lang_printable_name (t1, 0));
15912       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15913       parse_error_context (wfl_operator,
15914 		 "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15915 			   t, lang_printable_name (t2, 0));
15916       free (t);
15917       error_found = 1;
15918     }
15919 
15920   if (error_found)
15921     {
15922       TREE_TYPE (node) = error_mark_node;
15923       return error_mark_node;
15924     }
15925 
15926   TREE_TYPE (node) = resulting_type;
15927   TREE_SET_CODE (node, COND_EXPR);
15928   CAN_COMPLETE_NORMALLY (node) = 1;
15929   return node;
15930 }
15931 
15932 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15933 
15934 static tree
maybe_build_class_init_for_field(tree decl,tree expr)15935 maybe_build_class_init_for_field (tree decl, tree expr)
15936 {
15937   tree clas = DECL_CONTEXT (decl);
15938   if (flag_emit_class_files || flag_emit_xref)
15939     return expr;
15940 
15941   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15942       && FIELD_FINAL (decl))
15943     {
15944       tree init = DECL_INITIAL (decl);
15945       if (init != NULL_TREE)
15946 	init = fold_constant_for_init (init, decl);
15947       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15948 	return expr;
15949     }
15950 
15951   return build_class_init (clas, expr);
15952 }
15953 
15954 /* Try to constant fold NODE.
15955    If NODE is not a constant expression, return NULL_EXPR.
15956    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15957 
15958 static tree
fold_constant_for_init(tree node,tree context)15959 fold_constant_for_init (tree node, tree context)
15960 {
15961   tree op0, op1, val;
15962   enum tree_code code = TREE_CODE (node);
15963 
15964   switch (code)
15965     {
15966     case INTEGER_CST:
15967       if (node == null_pointer_node)
15968 	return NULL_TREE;
15969     case STRING_CST:
15970     case REAL_CST:
15971       return node;
15972 
15973     case PLUS_EXPR:
15974     case MINUS_EXPR:
15975     case MULT_EXPR:
15976     case TRUNC_MOD_EXPR:
15977     case RDIV_EXPR:
15978     case LSHIFT_EXPR:
15979     case RSHIFT_EXPR:
15980     case URSHIFT_EXPR:
15981     case BIT_AND_EXPR:
15982     case BIT_XOR_EXPR:
15983     case BIT_IOR_EXPR:
15984     case TRUTH_ANDIF_EXPR:
15985     case TRUTH_ORIF_EXPR:
15986     case EQ_EXPR:
15987     case NE_EXPR:
15988     case GT_EXPR:
15989     case GE_EXPR:
15990     case LT_EXPR:
15991     case LE_EXPR:
15992       op0 = TREE_OPERAND (node, 0);
15993       op1 = TREE_OPERAND (node, 1);
15994       val = fold_constant_for_init (op0, context);
15995       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15996 	return NULL_TREE;
15997       TREE_OPERAND (node, 0) = val;
15998       val = fold_constant_for_init (op1, context);
15999       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16000 	return NULL_TREE;
16001       TREE_OPERAND (node, 1) = val;
16002       return patch_binop (node, op0, op1);
16003 
16004     case UNARY_PLUS_EXPR:
16005     case NEGATE_EXPR:
16006     case TRUTH_NOT_EXPR:
16007     case BIT_NOT_EXPR:
16008     case CONVERT_EXPR:
16009       op0 = TREE_OPERAND (node, 0);
16010       val = fold_constant_for_init (op0, context);
16011       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16012 	return NULL_TREE;
16013       TREE_OPERAND (node, 0) = val;
16014       val = patch_unaryop (node, op0);
16015       if (! TREE_CONSTANT (val))
16016 	return NULL_TREE;
16017       return val;
16018 
16019       break;
16020 
16021     case COND_EXPR:
16022       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16023       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16024 	return NULL_TREE;
16025       TREE_OPERAND (node, 0) = val;
16026       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16027       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16028 	return NULL_TREE;
16029       TREE_OPERAND (node, 1) = val;
16030       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16031       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16032 	return NULL_TREE;
16033       TREE_OPERAND (node, 2) = val;
16034       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16035 	: TREE_OPERAND (node, 2);
16036 
16037     case VAR_DECL:
16038     case FIELD_DECL:
16039       if (! FIELD_FINAL (node)
16040 	  || DECL_INITIAL (node) == NULL_TREE)
16041 	return NULL_TREE;
16042       val = DECL_INITIAL (node);
16043       /* Guard against infinite recursion. */
16044       DECL_INITIAL (node) = NULL_TREE;
16045       val = fold_constant_for_init (val, node);
16046       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16047 	val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16048       DECL_INITIAL (node) = val;
16049       return val;
16050 
16051     case EXPR_WITH_FILE_LOCATION:
16052       /* Compare java_complete_tree and resolve_expression_name. */
16053       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16054 	  || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16055 	{
16056 	  tree name = EXPR_WFL_NODE (node);
16057 	  tree decl;
16058 	  if (PRIMARY_P (node))
16059 	    return NULL_TREE;
16060 	  else if (! QUALIFIED_P (name))
16061 	    {
16062 	      decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16063 	      if (decl == NULL_TREE
16064 		  || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16065 		return NULL_TREE;
16066 	      return fold_constant_for_init (decl, decl);
16067 	    }
16068 	  else
16069 	    {
16070 	      /* Install the proper context for the field resolution.
16071 		 The prior context is restored once the name is
16072 		 properly qualified. */
16073 	      tree saved_current_class = current_class;
16074 	      /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16075 	      current_class = DECL_CONTEXT (context);
16076 	      qualify_ambiguous_name (node);
16077 	      current_class = saved_current_class;
16078 	      if (resolve_field_access (node, &decl, NULL)
16079 		  && decl != NULL_TREE)
16080 		return fold_constant_for_init (decl, decl);
16081 	      return NULL_TREE;
16082 	    }
16083 	}
16084       else
16085 	{
16086 	  op0 = TREE_OPERAND (node, 0);
16087 	  val = fold_constant_for_init (op0, context);
16088 	  if (val == NULL_TREE || ! TREE_CONSTANT (val))
16089 	    return NULL_TREE;
16090 	  TREE_OPERAND (node, 0) = val;
16091 	  return val;
16092 	}
16093 
16094 #ifdef USE_COMPONENT_REF
16095     case IDENTIFIER:
16096     case COMPONENT_REF:
16097       ?;
16098 #endif
16099 
16100     default:
16101       return NULL_TREE;
16102     }
16103 }
16104 
16105 #ifdef USE_COMPONENT_REF
16106 /* Context is 'T' for TypeName, 'P' for PackageName,
16107    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16108 
16109 tree
resolve_simple_name(tree name,int context)16110 resolve_simple_name (tree name, int context)
16111 {
16112 }
16113 
16114 tree
resolve_qualified_name(tree name,int context)16115 resolve_qualified_name (tree name, int context)
16116 {
16117 }
16118 #endif
16119 
16120 void
init_src_parse(void)16121 init_src_parse (void)
16122 {
16123   /* Sanity check; we've been bit by this before.  */
16124   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16125     abort ();
16126 }
16127 
16128 
16129 
16130 /* This section deals with the functions that are called when tables
16131    recording class initialization information are traversed.  */
16132 
16133 /* Attach to PTR (a block) the declaration found in ENTRY. */
16134 
16135 static int
attach_init_test_initialization_flags(void ** entry,void * ptr)16136 attach_init_test_initialization_flags (void **entry, void *ptr)
16137 {
16138   tree block = (tree)ptr;
16139   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16140 
16141   if (block != error_mark_node)
16142     {
16143       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16144       BLOCK_EXPR_DECLS (block) = ite->value;
16145     }
16146   return true;
16147 }
16148 
16149 /* This function is called for each class that is known definitely
16150    initialized when a given static method was called. This function
16151    augments a compound expression (INFO) storing all assignment to
16152    initialized static class flags if a flag already existed, otherwise
16153    a new one is created.  */
16154 
16155 static int
emit_test_initialization(void ** entry_p,void * info)16156 emit_test_initialization (void **entry_p, void *info)
16157 {
16158   tree l = (tree) info;
16159   tree decl, init;
16160   tree key = (tree) *entry_p;
16161   tree *ite;
16162   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16163 
16164   /* If we haven't found a flag and we're dealing with self registered
16165      with current_function_decl, then don't do anything. Self is
16166      always added as definitely initialized but this information is
16167      valid only if used outside the current function. */
16168   if (current_function_decl == TREE_PURPOSE (l)
16169       && java_treetreehash_find (cf_ht, key) == NULL)
16170     return true;
16171 
16172   ite = java_treetreehash_new (cf_ht, key);
16173 
16174   /* If we don't have a variable, create one and install it. */
16175   if (*ite == NULL)
16176     {
16177       tree block;
16178 
16179       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16180       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16181       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16182       DECL_CONTEXT (decl) = current_function_decl;
16183       DECL_INITIAL (decl) = boolean_true_node;
16184       /* Don't emit any symbolic debugging info for this decl.  */
16185       DECL_IGNORED_P (decl) = 1;
16186 
16187       /* The trick is to find the right context for it. */
16188       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16189       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16190       BLOCK_EXPR_DECLS (block) = decl;
16191       *ite = decl;
16192     }
16193   else
16194     decl = *ite;
16195 
16196   /* Now simply augment the compound that holds all the assignments
16197      pertaining to this method invocation. */
16198   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16199   TREE_SIDE_EFFECTS (init) = 1;
16200   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16201   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16202 
16203   return true;
16204 }
16205 
16206 #include "gt-java-parse.h"
16207 #include "gtype-java.h"
16208