?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2004-02-11 Eric Christopher <echristo@redhat.com>
[official-gcc.git] / gcc / java / parse.y
blob390b8cdaefd5bf87b0bb6f3afca3a0d68583c825
1 /* Source code parsing and tree node generation for the GNU compiler
2 for the Java(TM) language.
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
4 Free Software Foundation, Inc.
5 Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA.
23
24 Java and all Java-based marks are trademarks or registered trademarks
25 of Sun Microsystems, Inc. in the United States and other countries.
26 The Free Software Foundation is independent of Sun Microsystems, Inc. */
27
28 /* This file parses java source code and issues a tree node image
29 suitable for code generation (byte code and targeted CPU assembly
30 language).
31
32 The grammar conforms to the Java grammar described in "The Java(TM)
33 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
34 1996, ISBN 0-201-63451-1"
35
36 The following modifications were brought to the original grammar:
37
38 method_body: added the rule '| block SC_TK'
39 static_initializer: added the rule 'static block SC_TK'.
40
41 Note: All the extra rules described above should go away when the
42 empty_statement rule will work.
43
44 statement_nsi: 'nsi' should be read no_short_if.
45
46 Some rules have been modified to support JDK1.1 inner classes
47 definitions and other extensions. */
48
49 %{
50 #include "config.h"
51 #include "system.h"
52 #include "coretypes.h"
53 #include "tm.h"
54 #include <dirent.h>
55 #include "tree.h"
56 #include "rtl.h"
57 #include "real.h"
58 #include "obstack.h"
59 #include "toplev.h"
60 #include "flags.h"
61 #include "java-tree.h"
62 #include "jcf.h"
63 #include "lex.h"
64 #include "parse.h"
65 #include "zipfile.h"
66 #include "convert.h"
67 #include "buffer.h"
68 #include "xref.h"
69 #include "function.h"
70 #include "except.h"
71 #include "ggc.h"
72 #include "debug.h"
73 #include "tree-inline.h"
74 #include "cgraph.h"
75 #include "target.h"
76
77 /* Local function prototypes */
78 static char *java_accstring_lookup (int);
79 static void classitf_redefinition_error (const char *,tree, tree, tree);
80 static void variable_redefinition_error (tree, tree, tree, int);
81 static tree create_class (int, tree, tree, tree);
82 static tree create_interface (int, tree, tree);
83 static void end_class_declaration (int);
84 static tree find_field (tree, tree);
85 static tree lookup_field_wrapper (tree, tree);
86 static int duplicate_declaration_error_p (tree, tree, tree);
87 static void register_fields (int, tree, tree);
88 static tree parser_qualified_classname (tree);
89 static int parser_check_super (tree, tree, tree);
90 static int parser_check_super_interface (tree, tree, tree);
91 static void check_modifiers_consistency (int);
92 static tree lookup_cl (tree);
93 static tree lookup_java_method2 (tree, tree, int);
94 static tree method_header (int, tree, tree, tree);
95 static void fix_method_argument_names (tree ,tree);
96 static tree method_declarator (tree, tree);
97 static void parse_warning_context (tree cl, const char *msg, ...)
98 ATTRIBUTE_PRINTF_2;
99 static void issue_warning_error_from_context (tree, const char *msg, va_list)
100 ATTRIBUTE_PRINTF (2, 0);
101 static void parse_ctor_invocation_error (void);
102 static tree parse_jdk1_1_error (const char *);
103 static void complete_class_report_errors (jdep *);
104 static int process_imports (void);
105 static void read_import_dir (tree);
106 static int find_in_imports_on_demand (tree, tree);
107 static void find_in_imports (tree, tree);
108 static void check_inner_class_access (tree, tree, tree);
109 static int check_pkg_class_access (tree, tree, bool);
110 static void register_package (tree);
111 static tree resolve_package (tree, tree *, tree *);
112 static tree resolve_class (tree, tree, tree, tree);
113 static void declare_local_variables (int, tree, tree);
114 static void dump_java_tree (enum tree_dump_index, tree);
115 static void source_start_java_method (tree);
116 static void source_end_java_method (void);
117 static tree find_name_in_single_imports (tree);
118 static void check_abstract_method_header (tree);
119 static tree lookup_java_interface_method2 (tree, tree);
120 static tree resolve_expression_name (tree, tree *);
121 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
122 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
123 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
124 static int breakdown_qualified (tree *, tree *, tree);
125 static int in_same_package (tree, tree);
126 static tree resolve_and_layout (tree, tree);
127 static tree qualify_and_find (tree, tree, tree);
128 static tree resolve_no_layout (tree, tree);
129 static int invocation_mode (tree, int);
130 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
131 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
132 static tree find_most_specific_methods_list (tree);
133 static int argument_types_convertible (tree, tree);
134 static tree patch_invoke (tree, tree, tree);
135 static int maybe_use_access_method (int, tree *, tree *);
136 static tree lookup_method_invoke (int, tree, tree, tree, tree);
137 static tree register_incomplete_type (int, tree, tree, tree);
138 static tree check_inner_circular_reference (tree, tree);
139 static tree check_circular_reference (tree);
140 static tree obtain_incomplete_type (tree);
141 static tree java_complete_lhs (tree);
142 static tree java_complete_tree (tree);
143 static tree maybe_generate_pre_expand_clinit (tree);
144 static int analyze_clinit_body (tree, tree);
145 static int maybe_yank_clinit (tree);
146 static void java_complete_expand_method (tree);
147 static void java_expand_method_bodies (tree);
148 static int unresolved_type_p (tree, tree *);
149 static void create_jdep_list (struct parser_ctxt *);
150 static tree build_expr_block (tree, tree);
151 static tree enter_block (void);
152 static tree exit_block (void);
153 static tree lookup_name_in_blocks (tree);
154 static void maybe_absorb_scoping_blocks (void);
155 static tree build_method_invocation (tree, tree);
156 static tree build_new_invocation (tree, tree);
157 static tree build_assignment (int, int, tree, tree);
158 static tree build_binop (enum tree_code, int, tree, tree);
159 static tree patch_assignment (tree, tree);
160 static tree patch_binop (tree, tree, tree);
161 static tree build_unaryop (int, int, tree);
162 static tree build_incdec (int, int, tree, int);
163 static tree patch_unaryop (tree, tree);
164 static tree build_cast (int, tree, tree);
165 static tree build_null_of_type (tree);
166 static tree patch_cast (tree, tree);
167 static int valid_ref_assignconv_cast_p (tree, tree, int);
168 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
169 static int valid_cast_to_p (tree, tree);
170 static int valid_method_invocation_conversion_p (tree, tree);
171 static tree try_builtin_assignconv (tree, tree, tree);
172 static tree try_reference_assignconv (tree, tree);
173 static tree build_unresolved_array_type (tree);
174 static int build_type_name_from_array_name (tree, tree *);
175 static tree build_array_from_name (tree, tree, tree, tree *);
176 static tree build_array_ref (int, tree, tree);
177 static tree patch_array_ref (tree);
178 static tree make_qualified_name (tree, tree, int);
179 static tree merge_qualified_name (tree, tree);
180 static tree make_qualified_primary (tree, tree, int);
181 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
182 static void qualify_ambiguous_name (tree);
183 static tree resolve_field_access (tree, tree *, tree *);
184 static tree build_newarray_node (tree, tree, int);
185 static tree patch_newarray (tree);
186 static tree resolve_type_during_patch (tree);
187 static tree build_this (int);
188 static tree build_wfl_wrap (tree, int);
189 static tree build_return (int, tree);
190 static tree patch_return (tree);
191 static tree maybe_access_field (tree, tree, tree);
192 static int complete_function_arguments (tree);
193 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
194 static int not_accessible_p (tree, tree, tree, int);
195 static void check_deprecation (tree, tree);
196 static int class_in_current_package (tree);
197 static tree build_if_else_statement (int, tree, tree, tree);
198 static tree patch_if_else_statement (tree);
199 static tree add_stmt_to_compound (tree, tree, tree);
200 static tree add_stmt_to_block (tree, tree, tree);
201 static tree patch_exit_expr (tree);
202 static tree build_labeled_block (int, tree);
203 static tree finish_labeled_statement (tree, tree);
204 static tree build_bc_statement (int, int, tree);
205 static tree patch_bc_statement (tree);
206 static tree patch_loop_statement (tree);
207 static tree build_new_loop (tree);
208 static tree build_loop_body (int, tree, int);
209 static tree finish_loop_body (int, tree, tree, int);
210 static tree build_debugable_stmt (int, tree);
211 static tree finish_for_loop (int, tree, tree, tree);
212 static tree patch_switch_statement (tree);
213 static tree string_constant_concatenation (tree, tree);
214 static tree build_string_concatenation (tree, tree);
215 static tree patch_string_cst (tree);
216 static tree patch_string (tree);
217 static tree encapsulate_with_try_catch (int, tree, tree, tree);
218 static tree build_assertion (int, tree, tree);
219 static tree build_try_statement (int, tree, tree);
220 static tree build_try_finally_statement (int, tree, tree);
221 static tree patch_try_statement (tree);
222 static tree patch_synchronized_statement (tree, tree);
223 static tree patch_throw_statement (tree, tree);
224 static void check_thrown_exceptions (int, tree, tree);
225 static int check_thrown_exceptions_do (tree);
226 static void purge_unchecked_exceptions (tree);
227 static bool ctors_unchecked_throws_clause_p (tree);
228 static void check_concrete_throws_clauses (tree, tree, tree, tree);
229 static void check_throws_clauses (tree, tree, tree);
230 static void finish_method_declaration (tree);
231 static tree build_super_invocation (tree);
232 static int verify_constructor_circularity (tree, tree);
233 static char *constructor_circularity_msg (tree, tree);
234 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
235 static const char *get_printable_method_name (tree);
236 static tree patch_conditional_expr (tree, tree, tree);
237 static tree generate_finit (tree);
238 static tree generate_instinit (tree);
239 static tree build_instinit_invocation (tree);
240 static void fix_constructors (tree);
241 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
242 static tree craft_constructor (tree, tree);
243 static int verify_constructor_super (tree);
244 static tree create_artificial_method (tree, int, tree, tree, tree);
245 static void start_artificial_method_body (tree);
246 static void end_artificial_method_body (tree);
247 static int check_method_redefinition (tree, tree);
248 static int check_method_types_complete (tree);
249 static bool hack_is_accessible_p (tree, tree);
250 static void java_check_regular_methods (tree);
251 static void check_interface_throws_clauses (tree, tree);
252 static void java_check_abstract_methods (tree);
253 static void unreachable_stmt_error (tree);
254 static int not_accessible_field_error (tree, tree);
255 static tree find_expr_with_wfl (tree);
256 static void missing_return_error (tree);
257 static tree build_new_array_init (int, tree);
258 static tree patch_new_array_init (tree, tree);
259 static tree maybe_build_array_element_wfl (tree);
260 static int array_constructor_check_entry (tree, tree);
261 static const char *purify_type_name (const char *);
262 static tree fold_constant_for_init (tree, tree);
263 static tree strip_out_static_field_access_decl (tree);
264 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
265 static void static_ref_err (tree, tree, tree);
266 static void parser_add_interface (tree, tree, tree);
267 static void add_superinterfaces (tree, tree);
268 static tree jdep_resolve_class (jdep *);
269 static int note_possible_classname (const char *, int);
270 static void java_complete_expand_classes (void);
271 static void java_complete_expand_class (tree);
272 static void java_complete_expand_methods (tree);
273 static tree cut_identifier_in_qualified (tree);
274 static tree java_stabilize_reference (tree);
275 static tree do_unary_numeric_promotion (tree);
276 static char * operator_string (tree);
277 static tree do_merge_string_cste (tree, const char *, int, int);
278 static tree merge_string_cste (tree, tree, int);
279 static tree java_refold (tree);
280 static int java_decl_equiv (tree, tree);
281 static int binop_compound_p (enum tree_code);
282 static tree search_loop (tree);
283 static int labeled_block_contains_loop_p (tree, tree);
284 static int check_abstract_method_definitions (int, tree, tree);
285 static void java_check_abstract_method_definitions (tree);
286 static void java_debug_context_do (int);
287 static void java_parser_context_push_initialized_field (void);
288 static void java_parser_context_pop_initialized_field (void);
289 static tree reorder_static_initialized (tree);
290 static void java_parser_context_suspend (void);
291 static void java_parser_context_resume (void);
292 static int pop_current_osb (struct parser_ctxt *);
293
294 /* JDK 1.1 work. FIXME */
295
296 static tree maybe_make_nested_class_name (tree);
297 static int make_nested_class_name (tree);
298 static void set_nested_class_simple_name_value (tree, int);
299 static void link_nested_class_to_enclosing (void);
300 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
301 static tree find_as_inner_class (tree, tree, tree);
302 static tree find_as_inner_class_do (tree, tree);
303 static int check_inner_class_redefinition (tree, tree);
304
305 static tree build_thisn_assign (void);
306 static tree build_current_thisn (tree);
307 static tree build_access_to_thisn (tree, tree, int);
308 static tree maybe_build_thisn_access_method (tree);
309
310 static tree build_outer_field_access (tree, tree);
311 static tree build_outer_field_access_methods (tree);
312 static tree build_outer_field_access_expr (int, tree, tree,
313 tree, tree);
314 static tree build_outer_method_access_method (tree);
315 static tree build_new_access_id (void);
316 static tree build_outer_field_access_method (tree, tree, tree,
317 tree, tree);
318
319 static int outer_field_access_p (tree, tree);
320 static int outer_field_expanded_access_p (tree, tree *,
321 tree *, tree *);
322 static tree outer_field_access_fix (tree, tree, tree);
323 static tree build_incomplete_class_ref (int, tree);
324 static tree patch_incomplete_class_ref (tree);
325 static tree create_anonymous_class (int, tree);
326 static void patch_anonymous_class (tree, tree, tree);
327 static void add_inner_class_fields (tree, tree);
328
329 static tree build_dot_class_method (tree);
330 static tree build_dot_class_method_invocation (tree, tree);
331 static void create_new_parser_context (int);
332 static tree maybe_build_class_init_for_field (tree, tree);
333
334 static int attach_init_test_initialization_flags (void **, void *);
335 static int emit_test_initialization (void **, void *);
336
337 static char *string_convert_int_cst (tree);
338
339 /* Number of error found so far. */
340 int java_error_count;
341 /* Number of warning found so far. */
342 int java_warning_count;
343 /* Tell when not to fold, when doing xrefs */
344 int do_not_fold;
345 /* Cyclic inheritance report, as it can be set by layout_class */
346 const char *cyclic_inheritance_report;
347
348 /* The current parser context */
349 struct parser_ctxt *ctxp;
350
351 /* List of things that were analyzed for which code will be generated */
352 struct parser_ctxt *ctxp_for_generation = NULL;
353
354 /* binop_lookup maps token to tree_code. It is used where binary
355 operations are involved and required by the parser. RDIV_EXPR
356 covers both integral/floating point division. The code is changed
357 once the type of both operator is worked out. */
358
359 static const enum tree_code binop_lookup[19] =
360 {
361 PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
362 LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
363 BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
364 TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
365 EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
366 };
367 #define BINOP_LOOKUP(VALUE) \
368 binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
369
370 /* This is the end index for binary operators that can also be used
371 in compound assignments. */
372 #define BINOP_COMPOUND_CANDIDATES 11
373
374 /* The "$L" identifier we use to create labels. */
375 static GTY(()) tree label_id;
376
377 /* The "StringBuffer" identifier used for the String `+' operator. */
378 static GTY(()) tree wfl_string_buffer;
379
380 /* The "append" identifier used for String `+' operator. */
381 static GTY(()) tree wfl_append;
382
383 /* The "toString" identifier used for String `+' operator. */
384 static GTY(()) tree wfl_to_string;
385
386 /* The "java.lang" import qualified name. */
387 static GTY(()) tree java_lang_id;
388
389 /* The generated `inst$' identifier used for generated enclosing
390 instance/field access functions. */
391 static GTY(()) tree inst_id;
392
393 /* Context and flag for static blocks */
394 static GTY(()) tree current_static_block;
395
396 /* The generated `write_parm_value$' identifier. */
397 static GTY(()) tree wpv_id;
398
399 /* The list of all packages we've seen so far */
400 static GTY(()) tree package_list;
401
402 /* Hold THIS for the scope of the current method decl. */
403 static GTY(()) tree current_this;
404
405 /* Hold a list of catch clauses list. The first element of this list is
406 the list of the catch clauses of the currently analyzed try block. */
407 static GTY(()) tree currently_caught_type_list;
408
409 /* This holds a linked list of all the case labels for the current
410 switch statement. It is only used when checking to see if there
411 are duplicate labels. FIXME: probably this should just be attached
412 to the switch itself; then it could be referenced via
413 `ctxp->current_loop'. */
414 static GTY(()) tree case_label_list;
415
416 /* Anonymous class counter. Will be reset to 1 every time a non
417 anonymous class gets created. */
418 static int anonymous_class_counter = 1;
419
420 static GTY(()) tree src_parse_roots[1];
421
422 /* All classes seen from source code */
423 #define gclass_list src_parse_roots[0]
424
425 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
426 line and point it out. */
427 /* Should point out the one that don't fit. ASCII/unicode, going
428 backward. FIXME */
429
430 #define check_modifiers(__message, __value, __mask) do { \
431 if ((__value) & ~(__mask)) \
432 { \
433 size_t i, remainder = (__value) & ~(__mask); \
434 for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++) \
435 if ((1 << i) & remainder) \
436 parse_error_context (ctxp->modifier_ctx [i], (__message), \
437 java_accstring_lookup (1 << i)); \
438 } \
439 } while (0)
440
441 %}
442
443 %union {
444 tree node;
445 int sub_token;
446 struct {
447 int token;
448 int location;
449 } operator;
450 int value;
451 }
452
453 %{
454 #include "lex.c"
455 %}
456
457 %pure_parser
458
459 /* Things defined here have to match the order of what's in the
460 binop_lookup table. */
461
462 %token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
463 %token LS_TK SRS_TK ZRS_TK
464 %token AND_TK XOR_TK OR_TK
465 %token BOOL_AND_TK BOOL_OR_TK
466 %token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
467
468 /* This maps to the same binop_lookup entry than the token above */
469
470 %token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
471 %token REM_ASSIGN_TK
472 %token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
473 %token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
474
475
476 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
477
478 %token PUBLIC_TK PRIVATE_TK PROTECTED_TK
479 %token STATIC_TK FINAL_TK SYNCHRONIZED_TK
480 %token VOLATILE_TK TRANSIENT_TK NATIVE_TK
481 %token PAD_TK ABSTRACT_TK STRICT_TK
482 %token MODIFIER_TK
483
484 /* Keep those two in order, too */
485 %token DECR_TK INCR_TK
486
487 /* From now one, things can be in any order */
488
489 %token DEFAULT_TK IF_TK THROW_TK
490 %token BOOLEAN_TK DO_TK IMPLEMENTS_TK
491 %token THROWS_TK BREAK_TK IMPORT_TK
492 %token ELSE_TK INSTANCEOF_TK RETURN_TK
493 %token VOID_TK CATCH_TK INTERFACE_TK
494 %token CASE_TK EXTENDS_TK FINALLY_TK
495 %token SUPER_TK WHILE_TK CLASS_TK
496 %token SWITCH_TK CONST_TK TRY_TK
497 %token FOR_TK NEW_TK CONTINUE_TK
498 %token GOTO_TK PACKAGE_TK THIS_TK
499 %token ASSERT_TK
500
501 %token BYTE_TK SHORT_TK INT_TK LONG_TK
502 %token CHAR_TK INTEGRAL_TK
503
504 %token FLOAT_TK DOUBLE_TK FP_TK
505
506 %token ID_TK
507
508 %token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
509
510 %token ASSIGN_ANY_TK ASSIGN_TK
511 %token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
512
513 %token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
514 %token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
515
516 %type <value> modifiers MODIFIER_TK final synchronized
517
518 %type <node> super ID_TK identifier
519 %type <node> name simple_name qualified_name
520 %type <node> type_declaration compilation_unit
521 field_declaration method_declaration extends_interfaces
522 interfaces interface_type_list
523 import_declarations package_declaration
524 type_declarations interface_body
525 interface_member_declaration constant_declaration
526 interface_member_declarations interface_type
527 abstract_method_declaration
528 %type <node> class_body_declaration class_member_declaration
529 static_initializer constructor_declaration block
530 %type <node> class_body_declarations constructor_header
531 %type <node> class_or_interface_type class_type class_type_list
532 constructor_declarator explicit_constructor_invocation
533 %type <node> dim_expr dim_exprs this_or_super throws
534
535 %type <node> variable_declarator_id variable_declarator
536 variable_declarators variable_initializer
537 variable_initializers constructor_body
538 array_initializer
539
540 %type <node> class_body block_end constructor_block_end
541 %type <node> statement statement_without_trailing_substatement
542 labeled_statement if_then_statement label_decl
543 if_then_else_statement while_statement for_statement
544 statement_nsi labeled_statement_nsi do_statement
545 if_then_else_statement_nsi while_statement_nsi
546 for_statement_nsi statement_expression_list for_init
547 for_update statement_expression expression_statement
548 primary_no_new_array expression primary
549 array_creation_expression array_type
550 class_instance_creation_expression field_access
551 method_invocation array_access something_dot_new
552 argument_list postfix_expression while_expression
553 post_increment_expression post_decrement_expression
554 unary_expression_not_plus_minus unary_expression
555 pre_increment_expression pre_decrement_expression
556 cast_expression
557 multiplicative_expression additive_expression
558 shift_expression relational_expression
559 equality_expression and_expression
560 exclusive_or_expression inclusive_or_expression
561 conditional_and_expression conditional_or_expression
562 conditional_expression assignment_expression
563 left_hand_side assignment for_header for_begin
564 constant_expression do_statement_begin empty_statement
565 switch_statement synchronized_statement throw_statement
566 try_statement assert_statement
567 switch_expression switch_block
568 catches catch_clause catch_clause_parameter finally
569 anonymous_class_creation trap_overflow_corner_case
570 %type <node> return_statement break_statement continue_statement
571
572 %type <operator> ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
573 %type <operator> REM_ASSIGN_TK PLUS_ASSIGN_TK MINUS_ASSIGN_TK
574 %type <operator> LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
575 %type <operator> AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
576 %type <operator> ASSIGN_ANY_TK assignment_operator
577 %token <operator> EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
578 %token <operator> BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
579 %token <operator> DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
580 %token <operator> NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
581 %token <operator> OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
582 %type <operator> THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
583 %type <operator> CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
584 %type <operator> NEW_TK ASSERT_TK
585
586 %type <node> method_body
587
588 %type <node> literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
589 STRING_LIT_TK NULL_TK VOID_TK
590
591 %type <node> IF_TK WHILE_TK FOR_TK
592
593 %type <node> formal_parameter_list formal_parameter
594 method_declarator method_header
595
596 %type <node> primitive_type reference_type type
597 BOOLEAN_TK INTEGRAL_TK FP_TK
598
599 /* Added or modified JDK 1.1 rule types */
600 %type <node> type_literals
601
602 %%
603 /* 19.2 Production from 2.3: The Syntactic Grammar */
604 goal: compilation_unit
605 {}
606 ;
607
608 /* 19.3 Productions from 3: Lexical structure */
609 literal:
610 INT_LIT_TK
611 | FP_LIT_TK
612 | BOOL_LIT_TK
613 | CHAR_LIT_TK
614 | STRING_LIT_TK
615 | NULL_TK
616 ;
617
618 /* 19.4 Productions from 4: Types, Values and Variables */
619 type:
620 primitive_type
621 | reference_type
622 ;
623
624 primitive_type:
625 INTEGRAL_TK
626 | FP_TK
627 | BOOLEAN_TK
628 ;
629
630 reference_type:
631 class_or_interface_type
632 | array_type
633 ;
634
635 class_or_interface_type:
636 name
637 ;
638
639 class_type:
640 class_or_interface_type /* Default rule */
641 ;
642
643 interface_type:
644 class_or_interface_type
645 ;
646
647 array_type:
648 primitive_type dims
649 {
650 int osb = pop_current_osb (ctxp);
651 tree t = build_java_array_type (($1), -1);
652 while (--osb)
653 t = build_unresolved_array_type (t);
654 $$ = t;
655 }
656 | name dims
657 {
658 int osb = pop_current_osb (ctxp);
659 tree t = $1;
660 while (osb--)
661 t = build_unresolved_array_type (t);
662 $$ = t;
663 }
664 ;
665
666 /* 19.5 Productions from 6: Names */
667 name:
668 simple_name /* Default rule */
669 | qualified_name /* Default rule */
670 ;
671
672 simple_name:
673 identifier /* Default rule */
674 ;
675
676 qualified_name:
677 name DOT_TK identifier
678 { $$ = make_qualified_name ($1, $3, $2.location); }
679 ;
680
681 identifier:
682 ID_TK
683 ;
684
685 /* 19.6: Production from 7: Packages */
686 compilation_unit:
687 {$$ = NULL;}
688 | package_declaration
689 | import_declarations
690 | type_declarations
691 | package_declaration import_declarations
692 | package_declaration type_declarations
693 | import_declarations type_declarations
694 | package_declaration import_declarations type_declarations
695 ;
696
697 import_declarations:
698 import_declaration
699 {
700 $$ = NULL;
701 }
702 | import_declarations import_declaration
703 {
704 $$ = NULL;
705 }
706 ;
707
708 type_declarations:
709 type_declaration
710 | type_declarations type_declaration
711 ;
712
713 package_declaration:
714 PACKAGE_TK name SC_TK
715 {
716 ctxp->package = EXPR_WFL_NODE ($2);
717 register_package (ctxp->package);
718 }
719 | PACKAGE_TK error
720 {yyerror ("Missing name"); RECOVER;}
721 | PACKAGE_TK name error
722 {yyerror ("';' expected"); RECOVER;}
723 ;
724
725 import_declaration:
726 single_type_import_declaration
727 | type_import_on_demand_declaration
728 ;
729
730 single_type_import_declaration:
731 IMPORT_TK name SC_TK
732 {
733 tree name = EXPR_WFL_NODE ($2), last_name;
734 int i = IDENTIFIER_LENGTH (name)-1;
735 const char *last = &IDENTIFIER_POINTER (name)[i];
736 while (last != IDENTIFIER_POINTER (name))
737 {
738 if (last [0] == '.')
739 break;
740 last--;
741 }
742 last_name = get_identifier (++last);
743 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
744 {
745 tree err = find_name_in_single_imports (last_name);
746 if (err && err != name)
747 parse_error_context
748 ($2, "Ambiguous class: `%s' and `%s'",
749 IDENTIFIER_POINTER (name),
750 IDENTIFIER_POINTER (err));
751 else
752 REGISTER_IMPORT ($2, last_name);
753 }
754 else
755 REGISTER_IMPORT ($2, last_name);
756 }
757 | IMPORT_TK error
758 {yyerror ("Missing name"); RECOVER;}
759 | IMPORT_TK name error
760 {yyerror ("';' expected"); RECOVER;}
761 ;
762
763 type_import_on_demand_declaration:
764 IMPORT_TK name DOT_TK MULT_TK SC_TK
765 {
766 tree name = EXPR_WFL_NODE ($2);
767 tree it;
768 /* Search for duplicates. */
769 for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
770 if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
771 break;
772 /* Don't import the same thing more than once, just ignore
773 duplicates (7.5.2) */
774 if (! it)
775 {
776 read_import_dir ($2);
777 ctxp->import_demand_list =
778 chainon (ctxp->import_demand_list,
779 build_tree_list ($2, NULL_TREE));
780 }
781 }
782 | IMPORT_TK name DOT_TK error
783 {yyerror ("'*' expected"); RECOVER;}
784 | IMPORT_TK name DOT_TK MULT_TK error
785 {yyerror ("';' expected"); RECOVER;}
786 ;
787
788 type_declaration:
789 class_declaration
790 { end_class_declaration (0); }
791 | interface_declaration
792 { end_class_declaration (0); }
793 | empty_statement
794 | error
795 {
796 YYERROR_NOW;
797 yyerror ("Class or interface declaration expected");
798 }
799 ;
800
801 /* 19.7 Shortened from the original:
802 modifiers: modifier | modifiers modifier
803 modifier: any of public... */
804 modifiers:
805 MODIFIER_TK
806 {
807 $$ = (1 << $1);
808 }
809 | modifiers MODIFIER_TK
810 {
811 int acc = (1 << $2);
812 if ($$ & acc)
813 parse_error_context
814 (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
815 java_accstring_lookup (acc));
816 else
817 {
818 $$ |= acc;
819 }
820 }
821 ;
822
823 /* 19.8.1 Production from $8.1: Class Declaration */
824 class_declaration:
825 modifiers CLASS_TK identifier super interfaces
826 { create_class ($1, $3, $4, $5); }
827 class_body
828 {;}
829 | CLASS_TK identifier super interfaces
830 { create_class (0, $2, $3, $4); }
831 class_body
832 {;}
833 | modifiers CLASS_TK error
834 { yyerror ("Missing class name"); RECOVER; }
835 | CLASS_TK error
836 { yyerror ("Missing class name"); RECOVER; }
837 | CLASS_TK identifier error
838 {
839 if (!ctxp->class_err) yyerror ("'{' expected");
840 DRECOVER(class1);
841 }
842 | modifiers CLASS_TK identifier error
843 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
844 ;
845
846 super:
847 { $$ = NULL; }
848 | EXTENDS_TK class_type
849 { $$ = $2; }
850 | EXTENDS_TK class_type error
851 {yyerror ("'{' expected"); ctxp->class_err=1;}
852 | EXTENDS_TK error
853 {yyerror ("Missing super class name"); ctxp->class_err=1;}
854 ;
855
856 interfaces:
857 { $$ = NULL_TREE; }
858 | IMPLEMENTS_TK interface_type_list
859 { $$ = $2; }
860 | IMPLEMENTS_TK error
861 {
862 ctxp->class_err=1;
863 yyerror ("Missing interface name");
864 }
865 ;
866
867 interface_type_list:
868 interface_type
869 {
870 ctxp->interface_number = 1;
871 $$ = build_tree_list ($1, NULL_TREE);
872 }
873 | interface_type_list C_TK interface_type
874 {
875 ctxp->interface_number++;
876 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
877 }
878 | interface_type_list C_TK error
879 {yyerror ("Missing interface name"); RECOVER;}
880 ;
881
882 class_body:
883 OCB_TK CCB_TK
884 {
885 /* Store the location of the `}' when doing xrefs */
886 if (flag_emit_xref)
887 DECL_END_SOURCE_LINE (GET_CPC ()) =
888 EXPR_WFL_ADD_COL ($2.location, 1);
889 $$ = GET_CPC ();
890 }
891 | OCB_TK class_body_declarations CCB_TK
892 {
893 /* Store the location of the `}' when doing xrefs */
894 if (flag_emit_xref)
895 DECL_END_SOURCE_LINE (GET_CPC ()) =
896 EXPR_WFL_ADD_COL ($3.location, 1);
897 $$ = GET_CPC ();
898 }
899 ;
900
901 class_body_declarations:
902 class_body_declaration
903 | class_body_declarations class_body_declaration
904 ;
905
906 class_body_declaration:
907 class_member_declaration
908 | static_initializer
909 | constructor_declaration
910 | block /* Added, JDK1.1, instance initializer */
911 {
912 if ($1 != empty_stmt_node)
913 {
914 TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
915 SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
916 }
917 }
918 ;
919
920 class_member_declaration:
921 field_declaration
922 | method_declaration
923 | class_declaration /* Added, JDK1.1 inner classes */
924 { end_class_declaration (1); }
925 | interface_declaration /* Added, JDK1.1 inner interfaces */
926 { end_class_declaration (1); }
927 | empty_statement
928 ;
929
930 /* 19.8.2 Productions from 8.3: Field Declarations */
931 field_declaration:
932 type variable_declarators SC_TK
933 { register_fields (0, $1, $2); }
934 | modifiers type variable_declarators SC_TK
935 {
936 check_modifiers
937 ("Illegal modifier `%s' for field declaration",
938 $1, FIELD_MODIFIERS);
939 check_modifiers_consistency ($1);
940 register_fields ($1, $2, $3);
941 }
942 ;
943
944 variable_declarators:
945 /* Should we use build_decl_list () instead ? FIXME */
946 variable_declarator /* Default rule */
947 | variable_declarators C_TK variable_declarator
948 { $$ = chainon ($1, $3); }
949 | variable_declarators C_TK error
950 {yyerror ("Missing term"); RECOVER;}
951 ;
952
953 variable_declarator:
954 variable_declarator_id
955 { $$ = build_tree_list ($1, NULL_TREE); }
956 | variable_declarator_id ASSIGN_TK variable_initializer
957 {
958 if (java_error_count)
959 $3 = NULL_TREE;
960 $$ = build_tree_list
961 ($1, build_assignment ($2.token, $2.location, $1, $3));
962 }
963 | variable_declarator_id ASSIGN_TK error
964 {
965 yyerror ("Missing variable initializer");
966 $$ = build_tree_list ($1, NULL_TREE);
967 RECOVER;
968 }
969 | variable_declarator_id ASSIGN_TK variable_initializer error
970 {
971 yyerror ("';' expected");
972 $$ = build_tree_list ($1, NULL_TREE);
973 RECOVER;
974 }
975 ;
976
977 variable_declarator_id:
978 identifier
979 | variable_declarator_id OSB_TK CSB_TK
980 { $$ = build_unresolved_array_type ($1); }
981 | identifier error
982 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
983 | variable_declarator_id OSB_TK error
984 {
985 yyerror ("']' expected");
986 DRECOVER(vdi);
987 }
988 | variable_declarator_id CSB_TK error
989 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
990 ;
991
992 variable_initializer:
993 expression
994 | array_initializer
995 ;
996
997 /* 19.8.3 Productions from 8.4: Method Declarations */
998 method_declaration:
999 method_header
1000 {
1001 current_function_decl = $1;
1002 if (current_function_decl
1003 && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1004 source_start_java_method (current_function_decl);
1005 else
1006 current_function_decl = NULL_TREE;
1007 }
1008 method_body
1009 { finish_method_declaration ($3); }
1010 | method_header error
1011 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1012 ;
1013
1014 method_header:
1015 type method_declarator throws
1016 { $$ = method_header (0, $1, $2, $3); }
1017 | VOID_TK method_declarator throws
1018 { $$ = method_header (0, void_type_node, $2, $3); }
1019 | modifiers type method_declarator throws
1020 { $$ = method_header ($1, $2, $3, $4); }
1021 | modifiers VOID_TK method_declarator throws
1022 { $$ = method_header ($1, void_type_node, $3, $4); }
1023 | type error
1024 {
1025 yyerror ("Invalid method declaration, method name required");
1026 RECOVER;
1027 }
1028 | modifiers type error
1029 {
1030 yyerror ("Identifier expected");
1031 RECOVER;
1032 }
1033 | VOID_TK error
1034 {
1035 yyerror ("Identifier expected");
1036 RECOVER;
1037 }
1038 | modifiers VOID_TK error
1039 {
1040 yyerror ("Identifier expected");
1041 RECOVER;
1042 }
1043 | modifiers error
1044 {
1045 yyerror ("Invalid method declaration, return type required");
1046 RECOVER;
1047 }
1048 ;
1049
1050 method_declarator:
1051 identifier OP_TK CP_TK
1052 {
1053 ctxp->formal_parameter_number = 0;
1054 $$ = method_declarator ($1, NULL_TREE);
1055 }
1056 | identifier OP_TK formal_parameter_list CP_TK
1057 { $$ = method_declarator ($1, $3); }
1058 | method_declarator OSB_TK CSB_TK
1059 {
1060 EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1061 TREE_PURPOSE ($1) =
1062 build_unresolved_array_type (TREE_PURPOSE ($1));
1063 parse_warning_context
1064 (wfl_operator,
1065 "Discouraged form of returned type specification");
1066 }
1067 | identifier OP_TK error
1068 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1069 | method_declarator OSB_TK error
1070 {yyerror ("']' expected"); RECOVER;}
1071 ;
1072
1073 formal_parameter_list:
1074 formal_parameter
1075 {
1076 ctxp->formal_parameter_number = 1;
1077 }
1078 | formal_parameter_list C_TK formal_parameter
1079 {
1080 ctxp->formal_parameter_number += 1;
1081 $$ = chainon ($1, $3);
1082 }
1083 | formal_parameter_list C_TK error
1084 { yyerror ("Missing formal parameter term"); RECOVER; }
1085 ;
1086
1087 formal_parameter:
1088 type variable_declarator_id
1089 {
1090 $$ = build_tree_list ($2, $1);
1091 }
1092 | final type variable_declarator_id /* Added, JDK1.1 final parms */
1093 {
1094 $$ = build_tree_list ($3, $2);
1095 ARG_FINAL_P ($$) = 1;
1096 }
1097 | type error
1098 {
1099 yyerror ("Missing identifier"); RECOVER;
1100 $$ = NULL_TREE;
1101 }
1102 | final type error
1103 {
1104 yyerror ("Missing identifier"); RECOVER;
1105 $$ = NULL_TREE;
1106 }
1107 ;
1108
1109 final:
1110 modifiers
1111 {
1112 check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1113 $1, ACC_FINAL);
1114 if ($1 != ACC_FINAL)
1115 MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1116 }
1117 ;
1118
1119 throws:
1120 { $$ = NULL_TREE; }
1121 | THROWS_TK class_type_list
1122 { $$ = $2; }
1123 | THROWS_TK error
1124 {yyerror ("Missing class type term"); RECOVER;}
1125 ;
1126
1127 class_type_list:
1128 class_type
1129 { $$ = build_tree_list ($1, $1); }
1130 | class_type_list C_TK class_type
1131 { $$ = tree_cons ($3, $3, $1); }
1132 | class_type_list C_TK error
1133 {yyerror ("Missing class type term"); RECOVER;}
1134 ;
1135
1136 method_body:
1137 block
1138 | SC_TK { $$ = NULL_TREE; }
1139 ;
1140
1141 /* 19.8.4 Productions from 8.5: Static Initializers */
1142 static_initializer:
1143 static block
1144 {
1145 TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1146 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1147 current_static_block = NULL_TREE;
1148 }
1149 ;
1150
1151 static: /* Test lval.sub_token here */
1152 modifiers
1153 {
1154 check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1155 /* Can't have a static initializer in an innerclass */
1156 if ($1 | ACC_STATIC &&
1157 GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1158 parse_error_context
1159 (MODIFIER_WFL (STATIC_TK),
1160 "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1161 IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1162 SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1163 }
1164 ;
1165
1166 /* 19.8.5 Productions from 8.6: Constructor Declarations */
1167 constructor_declaration:
1168 constructor_header
1169 {
1170 current_function_decl = $1;
1171 source_start_java_method (current_function_decl);
1172 }
1173 constructor_body
1174 { finish_method_declaration ($3); }
1175 ;
1176
1177 constructor_header:
1178 constructor_declarator throws
1179 { $$ = method_header (0, NULL_TREE, $1, $2); }
1180 | modifiers constructor_declarator throws
1181 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1182 ;
1183
1184 constructor_declarator:
1185 simple_name OP_TK CP_TK
1186 {
1187 ctxp->formal_parameter_number = 0;
1188 $$ = method_declarator ($1, NULL_TREE);
1189 }
1190 | simple_name OP_TK formal_parameter_list CP_TK
1191 { $$ = method_declarator ($1, $3); }
1192 ;
1193
1194 constructor_body:
1195 /* Unlike regular method, we always need a complete (empty)
1196 body so we can safely perform all the required code
1197 addition (super invocation and field initialization) */
1198 block_begin constructor_block_end
1199 {
1200 BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1201 $$ = $2;
1202 }
1203 | block_begin explicit_constructor_invocation constructor_block_end
1204 { $$ = $3; }
1205 | block_begin block_statements constructor_block_end
1206 { $$ = $3; }
1207 | block_begin explicit_constructor_invocation block_statements constructor_block_end
1208 { $$ = $4; }
1209 ;
1210
1211 constructor_block_end:
1212 block_end
1213 ;
1214
1215 /* Error recovery for that rule moved down expression_statement: rule. */
1216 explicit_constructor_invocation:
1217 this_or_super OP_TK CP_TK SC_TK
1218 {
1219 $$ = build_method_invocation ($1, NULL_TREE);
1220 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1221 $$ = java_method_add_stmt (current_function_decl, $$);
1222 }
1223 | this_or_super OP_TK argument_list CP_TK SC_TK
1224 {
1225 $$ = build_method_invocation ($1, $3);
1226 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1227 $$ = java_method_add_stmt (current_function_decl, $$);
1228 }
1229 /* Added, JDK1.1 inner classes. Modified because the rule
1230 'primary' couldn't work. */
1231 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1232 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1233 | name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1234 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1235 ;
1236
1237 this_or_super: /* Added, simplifies error diagnostics */
1238 THIS_TK
1239 {
1240 tree wfl = build_wfl_node (this_identifier_node);
1241 EXPR_WFL_LINECOL (wfl) = $1.location;
1242 $$ = wfl;
1243 }
1244 | SUPER_TK
1245 {
1246 tree wfl = build_wfl_node (super_identifier_node);
1247 EXPR_WFL_LINECOL (wfl) = $1.location;
1248 $$ = wfl;
1249 }
1250 ;
1251
1252 /* 19.9 Productions from 9: Interfaces */
1253 /* 19.9.1 Productions from 9.1: Interfaces Declarations */
1254 interface_declaration:
1255 INTERFACE_TK identifier
1256 { create_interface (0, $2, NULL_TREE); }
1257 interface_body
1258 { ; }
1259 | modifiers INTERFACE_TK identifier
1260 { create_interface ($1, $3, NULL_TREE); }
1261 interface_body
1262 { ; }
1263 | INTERFACE_TK identifier extends_interfaces
1264 { create_interface (0, $2, $3); }
1265 interface_body
1266 { ; }
1267 | modifiers INTERFACE_TK identifier extends_interfaces
1268 { create_interface ($1, $3, $4); }
1269 interface_body
1270 { ; }
1271 | INTERFACE_TK identifier error
1272 { yyerror ("'{' expected"); RECOVER; }
1273 | modifiers INTERFACE_TK identifier error
1274 { yyerror ("'{' expected"); RECOVER; }
1275 ;
1276
1277 extends_interfaces:
1278 EXTENDS_TK interface_type
1279 {
1280 ctxp->interface_number = 1;
1281 $$ = build_tree_list ($2, NULL_TREE);
1282 }
1283 | extends_interfaces C_TK interface_type
1284 {
1285 ctxp->interface_number++;
1286 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1287 }
1288 | EXTENDS_TK error
1289 {yyerror ("Invalid interface type"); RECOVER;}
1290 | extends_interfaces C_TK error
1291 {yyerror ("Missing term"); RECOVER;}
1292 ;
1293
1294 interface_body:
1295 OCB_TK CCB_TK
1296 { $$ = NULL_TREE; }
1297 | OCB_TK interface_member_declarations CCB_TK
1298 { $$ = NULL_TREE; }
1299 ;
1300
1301 interface_member_declarations:
1302 interface_member_declaration
1303 | interface_member_declarations interface_member_declaration
1304 ;
1305
1306 interface_member_declaration:
1307 constant_declaration
1308 | abstract_method_declaration
1309 | class_declaration /* Added, JDK1.1 inner classes */
1310 { end_class_declaration (1); }
1311 | interface_declaration /* Added, JDK1.1 inner interfaces */
1312 { end_class_declaration (1); }
1313 ;
1314
1315 constant_declaration:
1316 field_declaration
1317 ;
1318
1319 abstract_method_declaration:
1320 method_header SC_TK
1321 {
1322 check_abstract_method_header ($1);
1323 current_function_decl = NULL_TREE; /* FIXME ? */
1324 }
1325 | method_header error
1326 {yyerror ("';' expected"); RECOVER;}
1327 ;
1328
1329 /* 19.10 Productions from 10: Arrays */
1330 array_initializer:
1331 OCB_TK CCB_TK
1332 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1333 | OCB_TK C_TK CCB_TK
1334 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1335 | OCB_TK variable_initializers CCB_TK
1336 { $$ = build_new_array_init ($1.location, $2); }
1337 | OCB_TK variable_initializers C_TK CCB_TK
1338 { $$ = build_new_array_init ($1.location, $2); }
1339 ;
1340
1341 variable_initializers:
1342 variable_initializer
1343 {
1344 $$ = tree_cons (maybe_build_array_element_wfl ($1),
1345 $1, NULL_TREE);
1346 }
1347 | variable_initializers C_TK variable_initializer
1348 {
1349 $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1350 }
1351 | variable_initializers C_TK error
1352 {yyerror ("Missing term"); RECOVER;}
1353 ;
1354
1355 /* 19.11 Production from 14: Blocks and Statements */
1356 block:
1357 block_begin block_end
1358 { $$ = $2; }
1359 | block_begin block_statements block_end
1360 { $$ = $3; }
1361 ;
1362
1363 block_begin:
1364 OCB_TK
1365 { enter_block (); }
1366 ;
1367
1368 block_end:
1369 CCB_TK
1370 {
1371 maybe_absorb_scoping_blocks ();
1372 /* Store the location of the `}' when doing xrefs */
1373 if (current_function_decl && flag_emit_xref)
1374 DECL_END_SOURCE_LINE (current_function_decl) =
1375 EXPR_WFL_ADD_COL ($1.location, 1);
1376 $$ = exit_block ();
1377 if (!BLOCK_SUBBLOCKS ($$))
1378 BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1379 }
1380 ;
1381
1382 block_statements:
1383 block_statement
1384 | block_statements block_statement
1385 ;
1386
1387 block_statement:
1388 local_variable_declaration_statement
1389 | statement
1390 { java_method_add_stmt (current_function_decl, $1); }
1391 | class_declaration /* Added, JDK1.1 local classes */
1392 {
1393 LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1394 end_class_declaration (1);
1395 }
1396 ;
1397
1398 local_variable_declaration_statement:
1399 local_variable_declaration SC_TK /* Can't catch missing ';' here */
1400 ;
1401
1402 local_variable_declaration:
1403 type variable_declarators
1404 { declare_local_variables (0, $1, $2); }
1405 | final type variable_declarators /* Added, JDK1.1 final locals */
1406 { declare_local_variables ($1, $2, $3); }
1407 ;
1408
1409 statement:
1410 statement_without_trailing_substatement
1411 | labeled_statement
1412 | if_then_statement
1413 | if_then_else_statement
1414 | while_statement
1415 | for_statement
1416 { $$ = exit_block (); }
1417 ;
1418
1419 statement_nsi:
1420 statement_without_trailing_substatement
1421 | labeled_statement_nsi
1422 | if_then_else_statement_nsi
1423 | while_statement_nsi
1424 | for_statement_nsi
1425 { $$ = exit_block (); }
1426 ;
1427
1428 statement_without_trailing_substatement:
1429 block
1430 | empty_statement
1431 | expression_statement
1432 | switch_statement
1433 | do_statement
1434 | break_statement
1435 | continue_statement
1436 | return_statement
1437 | synchronized_statement
1438 | throw_statement
1439 | try_statement
1440 | assert_statement
1441 ;
1442
1443 empty_statement:
1444 SC_TK
1445 {
1446 if (flag_extraneous_semicolon
1447 && ! current_static_block
1448 && (! current_function_decl ||
1449 /* Verify we're not in a inner class declaration */
1450 (GET_CPC () != TYPE_NAME
1451 (DECL_CONTEXT (current_function_decl)))))
1452
1453 {
1454 EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1455 parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1456 }
1457 $$ = empty_stmt_node;
1458 }
1459 ;
1460
1461 label_decl:
1462 identifier REL_CL_TK
1463 {
1464 $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1465 EXPR_WFL_NODE ($1));
1466 pushlevel (2);
1467 push_labeled_block ($$);
1468 PUSH_LABELED_BLOCK ($$);
1469 }
1470 ;
1471
1472 labeled_statement:
1473 label_decl statement
1474 { $$ = finish_labeled_statement ($1, $2); }
1475 | identifier error
1476 {yyerror ("':' expected"); RECOVER;}
1477 ;
1478
1479 labeled_statement_nsi:
1480 label_decl statement_nsi
1481 { $$ = finish_labeled_statement ($1, $2); }
1482 ;
1483
1484 /* We concentrate here a bunch of error handling rules that we couldn't write
1485 earlier, because expression_statement catches a missing ';'. */
1486 expression_statement:
1487 statement_expression SC_TK
1488 {
1489 /* We have a statement. Generate a WFL around it so
1490 we can debug it */
1491 $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1492 /* We know we have a statement, so set the debug
1493 info to be eventually generate here. */
1494 $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1495 }
1496 | error SC_TK
1497 {
1498 YYNOT_TWICE yyerror ("Invalid expression statement");
1499 DRECOVER (expr_stmt);
1500 }
1501 | error OCB_TK
1502 {
1503 YYNOT_TWICE yyerror ("Invalid expression statement");
1504 DRECOVER (expr_stmt);
1505 }
1506 | error CCB_TK
1507 {
1508 YYNOT_TWICE yyerror ("Invalid expression statement");
1509 DRECOVER (expr_stmt);
1510 }
1511 | this_or_super OP_TK error
1512 {yyerror ("')' expected"); RECOVER;}
1513 | this_or_super OP_TK CP_TK error
1514 {
1515 parse_ctor_invocation_error ();
1516 RECOVER;
1517 }
1518 | this_or_super OP_TK argument_list error
1519 {yyerror ("')' expected"); RECOVER;}
1520 | this_or_super OP_TK argument_list CP_TK error
1521 {
1522 parse_ctor_invocation_error ();
1523 RECOVER;
1524 }
1525 | name DOT_TK SUPER_TK error
1526 {yyerror ("'(' expected"); RECOVER;}
1527 | name DOT_TK SUPER_TK OP_TK error
1528 {yyerror ("')' expected"); RECOVER;}
1529 | name DOT_TK SUPER_TK OP_TK argument_list error
1530 {yyerror ("')' expected"); RECOVER;}
1531 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1532 {yyerror ("';' expected"); RECOVER;}
1533 | name DOT_TK SUPER_TK OP_TK CP_TK error
1534 {yyerror ("';' expected"); RECOVER;}
1535 ;
1536
1537 statement_expression:
1538 assignment
1539 | pre_increment_expression
1540 | pre_decrement_expression
1541 | post_increment_expression
1542 | post_decrement_expression
1543 | method_invocation
1544 | class_instance_creation_expression
1545 ;
1546
1547 if_then_statement:
1548 IF_TK OP_TK expression CP_TK statement
1549 {
1550 $$ = build_if_else_statement ($2.location, $3,
1551 $5, NULL_TREE);
1552 }
1553 | IF_TK error
1554 {yyerror ("'(' expected"); RECOVER;}
1555 | IF_TK OP_TK error
1556 {yyerror ("Missing term"); RECOVER;}
1557 | IF_TK OP_TK expression error
1558 {yyerror ("')' expected"); RECOVER;}
1559 ;
1560
1561 if_then_else_statement:
1562 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1563 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1564 ;
1565
1566 if_then_else_statement_nsi:
1567 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1568 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1569 ;
1570
1571 switch_statement:
1572 switch_expression
1573 {
1574 enter_block ();
1575 }
1576 switch_block
1577 {
1578 /* Make into "proper list" of COMPOUND_EXPRs.
1579 I.e. make the last statement also have its own
1580 COMPOUND_EXPR. */
1581 maybe_absorb_scoping_blocks ();
1582 TREE_OPERAND ($1, 1) = exit_block ();
1583 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1584 }
1585 ;
1586
1587 switch_expression:
1588 SWITCH_TK OP_TK expression CP_TK
1589 {
1590 $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1591 EXPR_WFL_LINECOL ($$) = $2.location;
1592 }
1593 | SWITCH_TK error
1594 {yyerror ("'(' expected"); RECOVER;}
1595 | SWITCH_TK OP_TK error
1596 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1597 | SWITCH_TK OP_TK expression CP_TK error
1598 {yyerror ("'{' expected"); RECOVER;}
1599 ;
1600
1601 /* Default assignment is there to avoid type node on switch_block
1602 node. */
1603
1604 switch_block:
1605 OCB_TK CCB_TK
1606 { $$ = NULL_TREE; }
1607 | OCB_TK switch_labels CCB_TK
1608 { $$ = NULL_TREE; }
1609 | OCB_TK switch_block_statement_groups CCB_TK
1610 { $$ = NULL_TREE; }
1611 | OCB_TK switch_block_statement_groups switch_labels CCB_TK
1612 { $$ = NULL_TREE; }
1613 ;
1614
1615 switch_block_statement_groups:
1616 switch_block_statement_group
1617 | switch_block_statement_groups switch_block_statement_group
1618 ;
1619
1620 switch_block_statement_group:
1621 switch_labels block_statements
1622 ;
1623
1624 switch_labels:
1625 switch_label
1626 | switch_labels switch_label
1627 ;
1628
1629 switch_label:
1630 CASE_TK constant_expression REL_CL_TK
1631 {
1632 tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1633 EXPR_WFL_LINECOL (lab) = $1.location;
1634 java_method_add_stmt (current_function_decl, lab);
1635 }
1636 | DEFAULT_TK REL_CL_TK
1637 {
1638 tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1639 EXPR_WFL_LINECOL (lab) = $1.location;
1640 java_method_add_stmt (current_function_decl, lab);
1641 }
1642 | CASE_TK error
1643 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1644 | CASE_TK constant_expression error
1645 {yyerror ("':' expected"); RECOVER;}
1646 | DEFAULT_TK error
1647 {yyerror ("':' expected"); RECOVER;}
1648 ;
1649
1650 while_expression:
1651 WHILE_TK OP_TK expression CP_TK
1652 {
1653 tree body = build_loop_body ($2.location, $3, 0);
1654 $$ = build_new_loop (body);
1655 }
1656 ;
1657
1658 while_statement:
1659 while_expression statement
1660 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1661 | WHILE_TK error
1662 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1663 | WHILE_TK OP_TK error
1664 {yyerror ("Missing term and ')' expected"); RECOVER;}
1665 | WHILE_TK OP_TK expression error
1666 {yyerror ("')' expected"); RECOVER;}
1667 ;
1668
1669 while_statement_nsi:
1670 while_expression statement_nsi
1671 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1672 ;
1673
1674 do_statement_begin:
1675 DO_TK
1676 {
1677 tree body = build_loop_body (0, NULL_TREE, 1);
1678 $$ = build_new_loop (body);
1679 }
1680 /* Need error handing here. FIXME */
1681 ;
1682
1683 do_statement:
1684 do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1685 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1686 ;
1687
1688 for_statement:
1689 for_begin SC_TK expression SC_TK for_update CP_TK statement
1690 {
1691 if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1692 $3 = build_wfl_node ($3);
1693 $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1694 }
1695 | for_begin SC_TK SC_TK for_update CP_TK statement
1696 {
1697 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1698 /* We have not condition, so we get rid of the EXIT_EXPR */
1699 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1700 empty_stmt_node;
1701 }
1702 | for_begin SC_TK error
1703 {yyerror ("Invalid control expression"); RECOVER;}
1704 | for_begin SC_TK expression SC_TK error
1705 {yyerror ("Invalid update expression"); RECOVER;}
1706 | for_begin SC_TK SC_TK error
1707 {yyerror ("Invalid update expression"); RECOVER;}
1708 ;
1709
1710 for_statement_nsi:
1711 for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1712 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1713 | for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1714 {
1715 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1716 /* We have not condition, so we get rid of the EXIT_EXPR */
1717 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1718 empty_stmt_node;
1719 }
1720 ;
1721
1722 for_header:
1723 FOR_TK OP_TK
1724 {
1725 /* This scope defined for local variable that may be
1726 defined within the scope of the for loop */
1727 enter_block ();
1728 }
1729 | FOR_TK error
1730 {yyerror ("'(' expected"); DRECOVER(for_1);}
1731 | FOR_TK OP_TK error
1732 {yyerror ("Invalid init statement"); RECOVER;}
1733 ;
1734
1735 for_begin:
1736 for_header for_init
1737 {
1738 /* We now declare the loop body. The loop is
1739 declared as a for loop. */
1740 tree body = build_loop_body (0, NULL_TREE, 0);
1741 $$ = build_new_loop (body);
1742 FOR_LOOP_P ($$) = 1;
1743 /* The loop is added to the current block the for
1744 statement is defined within */
1745 java_method_add_stmt (current_function_decl, $$);
1746 }
1747 ;
1748 for_init: /* Can be empty */
1749 { $$ = empty_stmt_node; }
1750 | statement_expression_list
1751 {
1752 /* Init statement recorded within the previously
1753 defined block scope */
1754 $$ = java_method_add_stmt (current_function_decl, $1);
1755 }
1756 | local_variable_declaration
1757 {
1758 /* Local variable are recorded within the previously
1759 defined block scope */
1760 $$ = NULL_TREE;
1761 }
1762 | statement_expression_list error
1763 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1764 ;
1765
1766 for_update: /* Can be empty */
1767 {$$ = empty_stmt_node;}
1768 | statement_expression_list
1769 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1770 ;
1771
1772 statement_expression_list:
1773 statement_expression
1774 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1775 | statement_expression_list C_TK statement_expression
1776 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1777 | statement_expression_list C_TK error
1778 {yyerror ("Missing term"); RECOVER;}
1779 ;
1780
1781 break_statement:
1782 BREAK_TK SC_TK
1783 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1784 | BREAK_TK identifier SC_TK
1785 { $$ = build_bc_statement ($1.location, 1, $2); }
1786 | BREAK_TK error
1787 {yyerror ("Missing term"); RECOVER;}
1788 | BREAK_TK identifier error
1789 {yyerror ("';' expected"); RECOVER;}
1790 ;
1791
1792 continue_statement:
1793 CONTINUE_TK SC_TK
1794 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1795 | CONTINUE_TK identifier SC_TK
1796 { $$ = build_bc_statement ($1.location, 0, $2); }
1797 | CONTINUE_TK error
1798 {yyerror ("Missing term"); RECOVER;}
1799 | CONTINUE_TK identifier error
1800 {yyerror ("';' expected"); RECOVER;}
1801 ;
1802
1803 return_statement:
1804 RETURN_TK SC_TK
1805 { $$ = build_return ($1.location, NULL_TREE); }
1806 | RETURN_TK expression SC_TK
1807 { $$ = build_return ($1.location, $2); }
1808 | RETURN_TK error
1809 {yyerror ("Missing term"); RECOVER;}
1810 | RETURN_TK expression error
1811 {yyerror ("';' expected"); RECOVER;}
1812 ;
1813
1814 throw_statement:
1815 THROW_TK expression SC_TK
1816 {
1817 $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1818 EXPR_WFL_LINECOL ($$) = $1.location;
1819 }
1820 | THROW_TK error
1821 {yyerror ("Missing term"); RECOVER;}
1822 | THROW_TK expression error
1823 {yyerror ("';' expected"); RECOVER;}
1824 ;
1825
1826 assert_statement:
1827 ASSERT_TK expression REL_CL_TK expression SC_TK
1828 {
1829 $$ = build_assertion ($1.location, $2, $4);
1830 }
1831 | ASSERT_TK expression SC_TK
1832 {
1833 $$ = build_assertion ($1.location, $2, NULL_TREE);
1834 }
1835 | ASSERT_TK error
1836 {yyerror ("Missing term"); RECOVER;}
1837 | ASSERT_TK expression error
1838 {yyerror ("';' expected"); RECOVER;}
1839 ;
1840
1841 synchronized_statement:
1842 synchronized OP_TK expression CP_TK block
1843 {
1844 $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1845 EXPR_WFL_LINECOL ($$) =
1846 EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1847 }
1848 | synchronized OP_TK expression CP_TK error
1849 {yyerror ("'{' expected"); RECOVER;}
1850 | synchronized error
1851 {yyerror ("'(' expected"); RECOVER;}
1852 | synchronized OP_TK error CP_TK
1853 {yyerror ("Missing term"); RECOVER;}
1854 | synchronized OP_TK error
1855 {yyerror ("Missing term"); RECOVER;}
1856 ;
1857
1858 synchronized:
1859 modifiers
1860 {
1861 check_modifiers (
1862 "Illegal modifier `%s'. Only `synchronized' was expected here",
1863 $1, ACC_SYNCHRONIZED);
1864 if ($1 != ACC_SYNCHRONIZED)
1865 MODIFIER_WFL (SYNCHRONIZED_TK) =
1866 build_wfl_node (NULL_TREE);
1867 }
1868 ;
1869
1870 try_statement:
1871 TRY_TK block catches
1872 { $$ = build_try_statement ($1.location, $2, $3); }
1873 | TRY_TK block finally
1874 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1875 | TRY_TK block catches finally
1876 { $$ = build_try_finally_statement
1877 ($1.location, build_try_statement ($1.location,
1878 $2, $3), $4);
1879 }
1880 | TRY_TK error
1881 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1882 ;
1883
1884 catches:
1885 catch_clause
1886 | catches catch_clause
1887 {
1888 TREE_CHAIN ($2) = $1;
1889 $$ = $2;
1890 }
1891 ;
1892
1893 catch_clause:
1894 catch_clause_parameter block
1895 {
1896 java_method_add_stmt (current_function_decl, $2);
1897 exit_block ();
1898 $$ = $1;
1899 }
1900 ;
1901
1902 catch_clause_parameter:
1903 CATCH_TK OP_TK formal_parameter CP_TK
1904 {
1905 /* We add a block to define a scope for
1906 formal_parameter (CCBP). The formal parameter is
1907 declared initialized by the appropriate function
1908 call */
1909 tree ccpb;
1910 tree init;
1911 if ($3)
1912 {
1913 ccpb = enter_block ();
1914 init = build_assignment
1915 (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1916 build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1917 declare_local_variables (0, TREE_VALUE ($3),
1918 build_tree_list
1919 (TREE_PURPOSE ($3), init));
1920 $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1921 EXPR_WFL_LINECOL ($$) = $1.location;
1922 }
1923 else
1924 {
1925 $$ = error_mark_node;
1926 }
1927 }
1928 | CATCH_TK error
1929 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1930 | CATCH_TK OP_TK error
1931 {
1932 yyerror ("Missing term or ')' expected");
1933 RECOVER; $$ = NULL_TREE;
1934 }
1935 | CATCH_TK OP_TK error CP_TK /* That's for () */
1936 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1937 ;
1938
1939 finally:
1940 FINALLY_TK block
1941 { $$ = $2; }
1942 | FINALLY_TK error
1943 {yyerror ("'{' expected"); RECOVER; }
1944 ;
1945
1946 /* 19.12 Production from 15: Expressions */
1947 primary:
1948 primary_no_new_array
1949 | array_creation_expression
1950 ;
1951
1952 primary_no_new_array:
1953 literal
1954 | THIS_TK
1955 { $$ = build_this ($1.location); }
1956 | OP_TK expression CP_TK
1957 {$$ = $2;}
1958 | class_instance_creation_expression
1959 | field_access
1960 | method_invocation
1961 | array_access
1962 | type_literals
1963 /* Added, JDK1.1 inner classes. Documentation is wrong
1964 refering to a 'ClassName' (class_name) rule that doesn't
1965 exist. Used name: instead. */
1966 | name DOT_TK THIS_TK
1967 {
1968 tree wfl = build_wfl_node (this_identifier_node);
1969 $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1970 }
1971 | OP_TK expression error
1972 {yyerror ("')' expected"); RECOVER;}
1973 | name DOT_TK error
1974 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1975 | primitive_type DOT_TK error
1976 {yyerror ("'class' expected" ); RECOVER;}
1977 | VOID_TK DOT_TK error
1978 {yyerror ("'class' expected" ); RECOVER;}
1979 ;
1980
1981 type_literals:
1982 name DOT_TK CLASS_TK
1983 { $$ = build_incomplete_class_ref ($2.location, $1); }
1984 | array_type DOT_TK CLASS_TK
1985 { $$ = build_incomplete_class_ref ($2.location, $1); }
1986 | primitive_type DOT_TK CLASS_TK
1987 { $$ = build_incomplete_class_ref ($2.location, $1); }
1988 | VOID_TK DOT_TK CLASS_TK
1989 {
1990 $$ = build_incomplete_class_ref ($2.location,
1991 void_type_node);
1992 }
1993 ;
1994
1995 class_instance_creation_expression:
1996 NEW_TK class_type OP_TK argument_list CP_TK
1997 { $$ = build_new_invocation ($2, $4); }
1998 | NEW_TK class_type OP_TK CP_TK
1999 { $$ = build_new_invocation ($2, NULL_TREE); }
2000 | anonymous_class_creation
2001 /* Added, JDK1.1 inner classes, modified to use name or
2002 primary instead of primary solely which couldn't work in
2003 all situations. */
2004 | something_dot_new identifier OP_TK CP_TK
2005 {
2006 tree ctor = build_new_invocation ($2, NULL_TREE);
2007 $$ = make_qualified_primary ($1, ctor,
2008 EXPR_WFL_LINECOL ($1));
2009 }
2010 | something_dot_new identifier OP_TK CP_TK class_body
2011 | something_dot_new identifier OP_TK argument_list CP_TK
2012 {
2013 tree ctor = build_new_invocation ($2, $4);
2014 $$ = make_qualified_primary ($1, ctor,
2015 EXPR_WFL_LINECOL ($1));
2016 }
2017 | something_dot_new identifier OP_TK argument_list CP_TK class_body
2018 | NEW_TK error SC_TK
2019 {yyerror ("'(' expected"); DRECOVER(new_1);}
2020 | NEW_TK class_type error
2021 {yyerror ("'(' expected"); RECOVER;}
2022 | NEW_TK class_type OP_TK error
2023 {yyerror ("')' or term expected"); RECOVER;}
2024 | NEW_TK class_type OP_TK argument_list error
2025 {yyerror ("')' expected"); RECOVER;}
2026 | something_dot_new error
2027 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2028 | something_dot_new identifier error
2029 {yyerror ("'(' expected"); RECOVER;}
2030 ;
2031
2032 /* Created after JDK1.1 rules originally added to
2033 class_instance_creation_expression, but modified to use
2034 'class_type' instead of 'TypeName' (type_name) which is mentioned
2035 in the documentation but doesn't exist. */
2036
2037 anonymous_class_creation:
2038 NEW_TK class_type OP_TK argument_list CP_TK
2039 { create_anonymous_class ($1.location, $2); }
2040 class_body
2041 {
2042 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2043 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2044
2045 end_class_declaration (1);
2046
2047 /* Now we can craft the new expression */
2048 $$ = build_new_invocation (id, $4);
2049
2050 /* Note that we can't possibly be here if
2051 `class_type' is an interface (in which case the
2052 anonymous class extends Object and implements
2053 `class_type', hence its constructor can't have
2054 arguments.) */
2055
2056 /* Otherwise, the innerclass must feature a
2057 constructor matching `argument_list'. Anonymous
2058 classes are a bit special: it's impossible to
2059 define constructor for them, hence constructors
2060 must be generated following the hints provided by
2061 the `new' expression. Whether a super constructor
2062 of that nature exists or not is to be verified
2063 later on in verify_constructor_super.
2064
2065 It's during the expansion of a `new' statement
2066 refering to an anonymous class that a ctor will
2067 be generated for the anonymous class, with the
2068 right arguments. */
2069
2070 }
2071 | NEW_TK class_type OP_TK CP_TK
2072 { create_anonymous_class ($1.location, $2); }
2073 class_body
2074 {
2075 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2076 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2077
2078 end_class_declaration (1);
2079
2080 /* Now we can craft the new expression. The
2081 statement doesn't need to be remember so that a
2082 constructor can be generated, since its signature
2083 is already known. */
2084 $$ = build_new_invocation (id, NULL_TREE);
2085 }
2086 ;
2087
2088 something_dot_new: /* Added, not part of the specs. */
2089 name DOT_TK NEW_TK
2090 { $$ = $1; }
2091 | primary DOT_TK NEW_TK
2092 { $$ = $1; }
2093 ;
2094
2095 argument_list:
2096 expression
2097 {
2098 $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2099 ctxp->formal_parameter_number = 1;
2100 }
2101 | argument_list C_TK expression
2102 {
2103 ctxp->formal_parameter_number += 1;
2104 $$ = tree_cons (NULL_TREE, $3, $1);
2105 }
2106 | argument_list C_TK error
2107 {yyerror ("Missing term"); RECOVER;}
2108 ;
2109
2110 array_creation_expression:
2111 NEW_TK primitive_type dim_exprs
2112 { $$ = build_newarray_node ($2, $3, 0); }
2113 | NEW_TK class_or_interface_type dim_exprs
2114 { $$ = build_newarray_node ($2, $3, 0); }
2115 | NEW_TK primitive_type dim_exprs dims
2116 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2117 | NEW_TK class_or_interface_type dim_exprs dims
2118 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2119 /* Added, JDK1.1 anonymous array. Initial documentation rule
2120 modified */
2121 | NEW_TK class_or_interface_type dims array_initializer
2122 {
2123 char *sig;
2124 int osb = pop_current_osb (ctxp);
2125 while (osb--)
2126 obstack_grow (&temporary_obstack, "[]", 2);
2127 obstack_1grow (&temporary_obstack, '\0');
2128 sig = obstack_finish (&temporary_obstack);
2129 $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2130 $2, get_identifier (sig), $4);
2131 }
2132 | NEW_TK primitive_type dims array_initializer
2133 {
2134 int osb = pop_current_osb (ctxp);
2135 tree type = $2;
2136 while (osb--)
2137 type = build_java_array_type (type, -1);
2138 $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2139 build_pointer_type (type), NULL_TREE, $4);
2140 }
2141 | NEW_TK error CSB_TK
2142 {yyerror ("'[' expected"); DRECOVER ("]");}
2143 | NEW_TK error OSB_TK
2144 {yyerror ("']' expected"); RECOVER;}
2145 ;
2146
2147 dim_exprs:
2148 dim_expr
2149 { $$ = build_tree_list (NULL_TREE, $1); }
2150 | dim_exprs dim_expr
2151 { $$ = tree_cons (NULL_TREE, $2, $$); }
2152 ;
2153
2154 dim_expr:
2155 OSB_TK expression CSB_TK
2156 {
2157 if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2158 {
2159 $2 = build_wfl_node ($2);
2160 TREE_TYPE ($2) = NULL_TREE;
2161 }
2162 EXPR_WFL_LINECOL ($2) = $1.location;
2163 $$ = $2;
2164 }
2165 | OSB_TK expression error
2166 {yyerror ("']' expected"); RECOVER;}
2167 | OSB_TK error
2168 {
2169 yyerror ("Missing term");
2170 yyerror ("']' expected");
2171 RECOVER;
2172 }
2173 ;
2174
2175 dims:
2176 OSB_TK CSB_TK
2177 {
2178 int allocate = 0;
2179 /* If not initialized, allocate memory for the osb
2180 numbers stack */
2181 if (!ctxp->osb_limit)
2182 {
2183 allocate = ctxp->osb_limit = 32;
2184 ctxp->osb_depth = -1;
2185 }
2186 /* If capacity overflown, reallocate a bigger chunk */
2187 else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2188 allocate = ctxp->osb_limit << 1;
2189
2190 if (allocate)
2191 {
2192 allocate *= sizeof (int);
2193 if (ctxp->osb_number)
2194 ctxp->osb_number = xrealloc (ctxp->osb_number,
2195 allocate);
2196 else
2197 ctxp->osb_number = xmalloc (allocate);
2198 }
2199 ctxp->osb_depth++;
2200 CURRENT_OSB (ctxp) = 1;
2201 }
2202 | dims OSB_TK CSB_TK
2203 { CURRENT_OSB (ctxp)++; }
2204 | dims OSB_TK error
2205 { yyerror ("']' expected"); RECOVER;}
2206 ;
2207
2208 field_access:
2209 primary DOT_TK identifier
2210 { $$ = make_qualified_primary ($1, $3, $2.location); }
2211 /* FIXME - REWRITE TO:
2212 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2213 | SUPER_TK DOT_TK identifier
2214 {
2215 tree super_wfl = build_wfl_node (super_identifier_node);
2216 EXPR_WFL_LINECOL (super_wfl) = $1.location;
2217 $$ = make_qualified_name (super_wfl, $3, $2.location);
2218 }
2219 | SUPER_TK error
2220 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2221 ;
2222
2223 method_invocation:
2224 name OP_TK CP_TK
2225 { $$ = build_method_invocation ($1, NULL_TREE); }
2226 | name OP_TK argument_list CP_TK
2227 { $$ = build_method_invocation ($1, $3); }
2228 | primary DOT_TK identifier OP_TK CP_TK
2229 {
2230 if (TREE_CODE ($1) == THIS_EXPR)
2231 $$ = build_this_super_qualified_invocation
2232 (1, $3, NULL_TREE, 0, $2.location);
2233 else
2234 {
2235 tree invok = build_method_invocation ($3, NULL_TREE);
2236 $$ = make_qualified_primary ($1, invok, $2.location);
2237 }
2238 }
2239 | primary DOT_TK identifier OP_TK argument_list CP_TK
2240 {
2241 if (TREE_CODE ($1) == THIS_EXPR)
2242 $$ = build_this_super_qualified_invocation
2243 (1, $3, $5, 0, $2.location);
2244 else
2245 {
2246 tree invok = build_method_invocation ($3, $5);
2247 $$ = make_qualified_primary ($1, invok, $2.location);
2248 }
2249 }
2250 | SUPER_TK DOT_TK identifier OP_TK CP_TK
2251 {
2252 $$ = build_this_super_qualified_invocation
2253 (0, $3, NULL_TREE, $1.location, $2.location);
2254 }
2255 | SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2256 {
2257 $$ = build_this_super_qualified_invocation
2258 (0, $3, $5, $1.location, $2.location);
2259 }
2260 /* Screws up thing. I let it here until I'm convinced it can
2261 be removed. FIXME
2262 | primary DOT_TK error
2263 {yyerror ("'(' expected"); DRECOVER(bad);} */
2264 | SUPER_TK DOT_TK error CP_TK
2265 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2266 | SUPER_TK DOT_TK error DOT_TK
2267 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2268 ;
2269
2270 array_access:
2271 name OSB_TK expression CSB_TK
2272 { $$ = build_array_ref ($2.location, $1, $3); }
2273 | primary_no_new_array OSB_TK expression CSB_TK
2274 { $$ = build_array_ref ($2.location, $1, $3); }
2275 | name OSB_TK error
2276 {
2277 yyerror ("Missing term and ']' expected");
2278 DRECOVER(array_access);
2279 }
2280 | name OSB_TK expression error
2281 {
2282 yyerror ("']' expected");
2283 DRECOVER(array_access);
2284 }
2285 | primary_no_new_array OSB_TK error
2286 {
2287 yyerror ("Missing term and ']' expected");
2288 DRECOVER(array_access);
2289 }
2290 | primary_no_new_array OSB_TK expression error
2291 {
2292 yyerror ("']' expected");
2293 DRECOVER(array_access);
2294 }
2295 ;
2296
2297 postfix_expression:
2298 primary
2299 | name
2300 | post_increment_expression
2301 | post_decrement_expression
2302 ;
2303
2304 post_increment_expression:
2305 postfix_expression INCR_TK
2306 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2307 ;
2308
2309 post_decrement_expression:
2310 postfix_expression DECR_TK
2311 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2312 ;
2313
2314 trap_overflow_corner_case:
2315 pre_increment_expression
2316 | pre_decrement_expression
2317 | PLUS_TK unary_expression
2318 {$$ = build_unaryop ($1.token, $1.location, $2); }
2319 | unary_expression_not_plus_minus
2320 | PLUS_TK error
2321 {yyerror ("Missing term"); RECOVER}
2322 ;
2323
2324 unary_expression:
2325 trap_overflow_corner_case
2326 {
2327 error_if_numeric_overflow ($1);
2328 $$ = $1;
2329 }
2330 | MINUS_TK trap_overflow_corner_case
2331 {$$ = build_unaryop ($1.token, $1.location, $2); }
2332 | MINUS_TK error
2333 {yyerror ("Missing term"); RECOVER}
2334 ;
2335
2336 pre_increment_expression:
2337 INCR_TK unary_expression
2338 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2339 | INCR_TK error
2340 {yyerror ("Missing term"); RECOVER}
2341 ;
2342
2343 pre_decrement_expression:
2344 DECR_TK unary_expression
2345 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2346 | DECR_TK error
2347 {yyerror ("Missing term"); RECOVER}
2348 ;
2349
2350 unary_expression_not_plus_minus:
2351 postfix_expression
2352 | NOT_TK unary_expression
2353 {$$ = build_unaryop ($1.token, $1.location, $2); }
2354 | NEG_TK unary_expression
2355 {$$ = build_unaryop ($1.token, $1.location, $2); }
2356 | cast_expression
2357 | NOT_TK error
2358 {yyerror ("Missing term"); RECOVER}
2359 | NEG_TK error
2360 {yyerror ("Missing term"); RECOVER}
2361 ;
2362
2363 cast_expression: /* Error handling here is potentially weak */
2364 OP_TK primitive_type dims CP_TK unary_expression
2365 {
2366 tree type = $2;
2367 int osb = pop_current_osb (ctxp);
2368 while (osb--)
2369 type = build_java_array_type (type, -1);
2370 $$ = build_cast ($1.location, type, $5);
2371 }
2372 | OP_TK primitive_type CP_TK unary_expression
2373 { $$ = build_cast ($1.location, $2, $4); }
2374 | OP_TK expression CP_TK unary_expression_not_plus_minus
2375 { $$ = build_cast ($1.location, $2, $4); }
2376 | OP_TK name dims CP_TK unary_expression_not_plus_minus
2377 {
2378 const char *ptr;
2379 int osb = pop_current_osb (ctxp);
2380 obstack_grow (&temporary_obstack,
2381 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2382 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2383 while (osb--)
2384 obstack_grow (&temporary_obstack, "[]", 2);
2385 obstack_1grow (&temporary_obstack, '\0');
2386 ptr = obstack_finish (&temporary_obstack);
2387 EXPR_WFL_NODE ($2) = get_identifier (ptr);
2388 $$ = build_cast ($1.location, $2, $5);
2389 }
2390 | OP_TK primitive_type OSB_TK error
2391 {yyerror ("']' expected, invalid type expression");}
2392 | OP_TK error
2393 {
2394 YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2395 RECOVER;
2396 }
2397 | OP_TK primitive_type dims CP_TK error
2398 {yyerror ("Missing term"); RECOVER;}
2399 | OP_TK primitive_type CP_TK error
2400 {yyerror ("Missing term"); RECOVER;}
2401 | OP_TK name dims CP_TK error
2402 {yyerror ("Missing term"); RECOVER;}
2403 ;
2404
2405 multiplicative_expression:
2406 unary_expression
2407 | multiplicative_expression MULT_TK unary_expression
2408 {
2409 $$ = build_binop (BINOP_LOOKUP ($2.token),
2410 $2.location, $1, $3);
2411 }
2412 | multiplicative_expression DIV_TK unary_expression
2413 {
2414 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2415 $1, $3);
2416 }
2417 | multiplicative_expression REM_TK unary_expression
2418 {
2419 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2420 $1, $3);
2421 }
2422 | multiplicative_expression MULT_TK error
2423 {yyerror ("Missing term"); RECOVER;}
2424 | multiplicative_expression DIV_TK error
2425 {yyerror ("Missing term"); RECOVER;}
2426 | multiplicative_expression REM_TK error
2427 {yyerror ("Missing term"); RECOVER;}
2428 ;
2429
2430 additive_expression:
2431 multiplicative_expression
2432 | additive_expression PLUS_TK multiplicative_expression
2433 {
2434 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2435 $1, $3);
2436 }
2437 | additive_expression MINUS_TK multiplicative_expression
2438 {
2439 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2440 $1, $3);
2441 }
2442 | additive_expression PLUS_TK error
2443 {yyerror ("Missing term"); RECOVER;}
2444 | additive_expression MINUS_TK error
2445 {yyerror ("Missing term"); RECOVER;}
2446 ;
2447
2448 shift_expression:
2449 additive_expression
2450 | shift_expression LS_TK additive_expression
2451 {
2452 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2453 $1, $3);
2454 }
2455 | shift_expression SRS_TK additive_expression
2456 {
2457 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2458 $1, $3);
2459 }
2460 | shift_expression ZRS_TK additive_expression
2461 {
2462 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2463 $1, $3);
2464 }
2465 | shift_expression LS_TK error
2466 {yyerror ("Missing term"); RECOVER;}
2467 | shift_expression SRS_TK error
2468 {yyerror ("Missing term"); RECOVER;}
2469 | shift_expression ZRS_TK error
2470 {yyerror ("Missing term"); RECOVER;}
2471 ;
2472
2473 relational_expression:
2474 shift_expression
2475 | relational_expression LT_TK shift_expression
2476 {
2477 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2478 $1, $3);
2479 }
2480 | relational_expression GT_TK shift_expression
2481 {
2482 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2483 $1, $3);
2484 }
2485 | relational_expression LTE_TK shift_expression
2486 {
2487 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2488 $1, $3);
2489 }
2490 | relational_expression GTE_TK shift_expression
2491 {
2492 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2493 $1, $3);
2494 }
2495 | relational_expression INSTANCEOF_TK reference_type
2496 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2497 | relational_expression LT_TK error
2498 {yyerror ("Missing term"); RECOVER;}
2499 | relational_expression GT_TK error
2500 {yyerror ("Missing term"); RECOVER;}
2501 | relational_expression LTE_TK error
2502 {yyerror ("Missing term"); RECOVER;}
2503 | relational_expression GTE_TK error
2504 {yyerror ("Missing term"); RECOVER;}
2505 | relational_expression INSTANCEOF_TK error
2506 {yyerror ("Invalid reference type"); RECOVER;}
2507 ;
2508
2509 equality_expression:
2510 relational_expression
2511 | equality_expression EQ_TK relational_expression
2512 {
2513 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2514 $1, $3);
2515 }
2516 | equality_expression NEQ_TK relational_expression
2517 {
2518 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2519 $1, $3);
2520 }
2521 | equality_expression EQ_TK error
2522 {yyerror ("Missing term"); RECOVER;}
2523 | equality_expression NEQ_TK error
2524 {yyerror ("Missing term"); RECOVER;}
2525 ;
2526
2527 and_expression:
2528 equality_expression
2529 | and_expression AND_TK equality_expression
2530 {
2531 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2532 $1, $3);
2533 }
2534 | and_expression AND_TK error
2535 {yyerror ("Missing term"); RECOVER;}
2536 ;
2537
2538 exclusive_or_expression:
2539 and_expression
2540 | exclusive_or_expression XOR_TK and_expression
2541 {
2542 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2543 $1, $3);
2544 }
2545 | exclusive_or_expression XOR_TK error
2546 {yyerror ("Missing term"); RECOVER;}
2547 ;
2548
2549 inclusive_or_expression:
2550 exclusive_or_expression
2551 | inclusive_or_expression OR_TK exclusive_or_expression
2552 {
2553 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2554 $1, $3);
2555 }
2556 | inclusive_or_expression OR_TK error
2557 {yyerror ("Missing term"); RECOVER;}
2558 ;
2559
2560 conditional_and_expression:
2561 inclusive_or_expression
2562 | conditional_and_expression BOOL_AND_TK inclusive_or_expression
2563 {
2564 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2565 $1, $3);
2566 }
2567 | conditional_and_expression BOOL_AND_TK error
2568 {yyerror ("Missing term"); RECOVER;}
2569 ;
2570
2571 conditional_or_expression:
2572 conditional_and_expression
2573 | conditional_or_expression BOOL_OR_TK conditional_and_expression
2574 {
2575 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2576 $1, $3);
2577 }
2578 | conditional_or_expression BOOL_OR_TK error
2579 {yyerror ("Missing term"); RECOVER;}
2580 ;
2581
2582 conditional_expression: /* Error handling here is weak */
2583 conditional_or_expression
2584 | conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2585 {
2586 $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2587 EXPR_WFL_LINECOL ($$) = $2.location;
2588 }
2589 | conditional_or_expression REL_QM_TK REL_CL_TK error
2590 {
2591 YYERROR_NOW;
2592 yyerror ("Missing term");
2593 DRECOVER (1);
2594 }
2595 | conditional_or_expression REL_QM_TK error
2596 {yyerror ("Missing term"); DRECOVER (2);}
2597 | conditional_or_expression REL_QM_TK expression REL_CL_TK error
2598 {yyerror ("Missing term"); DRECOVER (3);}
2599 ;
2600
2601 assignment_expression:
2602 conditional_expression
2603 | assignment
2604 ;
2605
2606 assignment:
2607 left_hand_side assignment_operator assignment_expression
2608 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2609 | left_hand_side assignment_operator error
2610 {
2611 YYNOT_TWICE yyerror ("Missing term");
2612 DRECOVER (assign);
2613 }
2614 ;
2615
2616 left_hand_side:
2617 name
2618 | field_access
2619 | array_access
2620 ;
2621
2622 assignment_operator:
2623 ASSIGN_ANY_TK
2624 | ASSIGN_TK
2625 ;
2626
2627 expression:
2628 assignment_expression
2629 ;
2630
2631 constant_expression:
2632 expression
2633 ;
2634
2635 %%
2636
2637 /* Helper function to retrieve an OSB count. Should be used when the
2638 `dims:' rule is being used. */
2639
2640 static int
2641 pop_current_osb (struct parser_ctxt *ctxp)
2642 {
2643 int to_return;
2644
2645 if (ctxp->osb_depth < 0)
2646 abort ();
2647
2648 to_return = CURRENT_OSB (ctxp);
2649 ctxp->osb_depth--;
2650
2651 return to_return;
2652 }
2653
2654 \f
2655
2656 /* This section of the code deal with save/restoring parser contexts.
2657 Add mode documentation here. FIXME */
2658
2659 /* Helper function. Create a new parser context. With
2660 COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2661 context is copied, otherwise, the new context is zeroed. The newly
2662 created context becomes the current one. */
2663
2664 static void
2665 create_new_parser_context (int copy_from_previous)
2666 {
2667 struct parser_ctxt *new;
2668
2669 new = ggc_alloc (sizeof (struct parser_ctxt));
2670 if (copy_from_previous)
2671 {
2672 memcpy (new, ctxp, sizeof (struct parser_ctxt));
2673 /* This flag, indicating the context saves global values,
2674 should only be set by java_parser_context_save_global. */
2675 new->saved_data_ctx = 0;
2676 }
2677 else
2678 memset (new, 0, sizeof (struct parser_ctxt));
2679
2680 new->next = ctxp;
2681 ctxp = new;
2682 }
2683
2684 /* Create a new parser context and make it the current one. */
2685
2686 void
2687 java_push_parser_context (void)
2688 {
2689 create_new_parser_context (0);
2690 }
2691
2692 void
2693 java_pop_parser_context (int generate)
2694 {
2695 tree current;
2696 struct parser_ctxt *toFree, *next;
2697
2698 if (!ctxp)
2699 return;
2700
2701 toFree = ctxp;
2702 next = ctxp->next;
2703 if (next)
2704 {
2705 input_line = ctxp->lineno;
2706 current_class = ctxp->class_type;
2707 }
2708
2709 /* If the old and new lexers differ, then free the old one. */
2710 if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2711 java_destroy_lexer (ctxp->lexer);
2712
2713 /* Set the single import class file flag to 0 for the current list
2714 of imported things */
2715 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2716 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2717
2718 /* And restore those of the previous context */
2719 if ((ctxp = next)) /* Assignment is really meant here */
2720 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2721 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2722
2723 /* If we pushed a context to parse a class intended to be generated,
2724 we keep it so we can remember the class. What we could actually
2725 do is to just update a list of class names. */
2726 if (generate)
2727 {
2728 toFree->next = ctxp_for_generation;
2729 ctxp_for_generation = toFree;
2730 }
2731 }
2732
2733 /* Create a parser context for the use of saving some global
2734 variables. */
2735
2736 void
2737 java_parser_context_save_global (void)
2738 {
2739 if (!ctxp)
2740 {
2741 java_push_parser_context ();
2742 ctxp->saved_data_ctx = 1;
2743 }
2744
2745 /* If this context already stores data, create a new one suitable
2746 for data storage. */
2747 else if (ctxp->saved_data)
2748 {
2749 create_new_parser_context (1);
2750 ctxp->saved_data_ctx = 1;
2751 }
2752
2753 ctxp->lineno = input_line;
2754 ctxp->class_type = current_class;
2755 ctxp->filename = input_filename;
2756 ctxp->function_decl = current_function_decl;
2757 ctxp->saved_data = 1;
2758 }
2759
2760 /* Restore some global variables from the previous context. Make the
2761 previous context the current one. */
2762
2763 void
2764 java_parser_context_restore_global (void)
2765 {
2766 input_line = ctxp->lineno;
2767 current_class = ctxp->class_type;
2768 input_filename = ctxp->filename;
2769 if (wfl_operator)
2770 {
2771 tree s;
2772 BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2773 EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2774 }
2775 current_function_decl = ctxp->function_decl;
2776 ctxp->saved_data = 0;
2777 if (ctxp->saved_data_ctx)
2778 java_pop_parser_context (0);
2779 }
2780
2781 /* Suspend vital data for the current class/function being parsed so
2782 that an other class can be parsed. Used to let local/anonymous
2783 classes be parsed. */
2784
2785 static void
2786 java_parser_context_suspend (void)
2787 {
2788 /* This makes debugging through java_debug_context easier */
2789 static const char *const name = "<inner buffer context>";
2790
2791 /* Duplicate the previous context, use it to save the globals we're
2792 interested in */
2793 create_new_parser_context (1);
2794 ctxp->function_decl = current_function_decl;
2795 ctxp->class_type = current_class;
2796
2797 /* Then create a new context which inherits all data from the
2798 previous one. This will be the new current context */
2799 create_new_parser_context (1);
2800
2801 /* Help debugging */
2802 ctxp->next->filename = name;
2803 }
2804
2805 /* Resume vital data for the current class/function being parsed so
2806 that an other class can be parsed. Used to let local/anonymous
2807 classes be parsed. The trick is the data storing file position
2808 informations must be restored to their current value, so parsing
2809 can resume as if no context was ever saved. */
2810
2811 static void
2812 java_parser_context_resume (void)
2813 {
2814 struct parser_ctxt *old = ctxp; /* This one is to be discarded */
2815 struct parser_ctxt *saver = old->next; /* This one contain saved info */
2816 struct parser_ctxt *restored = saver->next; /* This one is the old current */
2817
2818 /* We need to inherit the list of classes to complete/generate */
2819 restored->classd_list = old->classd_list;
2820 restored->class_list = old->class_list;
2821
2822 /* Restore the current class and function from the saver */
2823 current_class = saver->class_type;
2824 current_function_decl = saver->function_decl;
2825
2826 /* Retrieve the restored context */
2827 ctxp = restored;
2828
2829 /* Re-installed the data for the parsing to carry on */
2830 memcpy (&ctxp->marker_begining, &old->marker_begining,
2831 (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2832 }
2833
2834 /* Add a new anchor node to which all statement(s) initializing static
2835 and non static initialized upon declaration field(s) will be
2836 linked. */
2837
2838 static void
2839 java_parser_context_push_initialized_field (void)
2840 {
2841 tree node;
2842
2843 node = build_tree_list (NULL_TREE, NULL_TREE);
2844 TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2845 CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2846
2847 node = build_tree_list (NULL_TREE, NULL_TREE);
2848 TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2849 CPC_INITIALIZER_LIST (ctxp) = node;
2850
2851 node = build_tree_list (NULL_TREE, NULL_TREE);
2852 TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2853 CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2854 }
2855
2856 /* Pop the lists of initialized field. If this lists aren't empty,
2857 remember them so we can use it to create and populate the finit$
2858 or <clinit> functions. */
2859
2860 static void
2861 java_parser_context_pop_initialized_field (void)
2862 {
2863 tree stmts;
2864 tree class_type = TREE_TYPE (GET_CPC ());
2865
2866 if (CPC_INITIALIZER_LIST (ctxp))
2867 {
2868 stmts = CPC_INITIALIZER_STMT (ctxp);
2869 CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2870 if (stmts && !java_error_count)
2871 TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2872 }
2873
2874 if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2875 {
2876 stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2877 CPC_STATIC_INITIALIZER_LIST (ctxp) =
2878 TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2879 /* Keep initialization in order to enforce 8.5 */
2880 if (stmts && !java_error_count)
2881 TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2882 }
2883
2884 /* JDK 1.1 instance initializers */
2885 if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2886 {
2887 stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2888 CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2889 TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2890 if (stmts && !java_error_count)
2891 TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2892 }
2893 }
2894
2895 static tree
2896 reorder_static_initialized (tree list)
2897 {
2898 /* We have to keep things in order. The alias initializer have to
2899 come first, then the initialized regular field, in reverse to
2900 keep them in lexical order. */
2901 tree marker, previous = NULL_TREE;
2902 for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2903 if (TREE_CODE (marker) == TREE_LIST
2904 && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2905 break;
2906
2907 /* No static initialized, the list is fine as is */
2908 if (!previous)
2909 list = TREE_CHAIN (marker);
2910
2911 /* No marker? reverse the whole list */
2912 else if (!marker)
2913 list = nreverse (list);
2914
2915 /* Otherwise, reverse what's after the marker and the new reordered
2916 sublist will replace the marker. */
2917 else
2918 {
2919 TREE_CHAIN (previous) = NULL_TREE;
2920 list = nreverse (list);
2921 list = chainon (TREE_CHAIN (marker), list);
2922 }
2923 return list;
2924 }
2925
2926 /* Helper functions to dump the parser context stack. */
2927
2928 #define TAB_CONTEXT(C) \
2929 {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2930
2931 static void
2932 java_debug_context_do (int tab)
2933 {
2934 struct parser_ctxt *copy = ctxp;
2935 while (copy)
2936 {
2937 TAB_CONTEXT (tab);
2938 fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2939 TAB_CONTEXT (tab);
2940 fprintf (stderr, "filename: %s\n", copy->filename);
2941 TAB_CONTEXT (tab);
2942 fprintf (stderr, "lineno: %d\n", copy->lineno);
2943 TAB_CONTEXT (tab);
2944 fprintf (stderr, "package: %s\n",
2945 (copy->package ?
2946 IDENTIFIER_POINTER (copy->package) : "<none>"));
2947 TAB_CONTEXT (tab);
2948 fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2949 TAB_CONTEXT (tab);
2950 fprintf (stderr, "saved data: %d\n", copy->saved_data);
2951 copy = copy->next;
2952 tab += 2;
2953 }
2954 }
2955
2956 /* Dump the stacked up parser contexts. Intended to be called from a
2957 debugger. */
2958
2959 void
2960 java_debug_context (void)
2961 {
2962 java_debug_context_do (0);
2963 }
2964
2965 \f
2966
2967 /* Flag for the error report routine to issue the error the first time
2968 it's called (overriding the default behavior which is to drop the
2969 first invocation and honor the second one, taking advantage of a
2970 richer context. */
2971 static int force_error = 0;
2972
2973 /* Reporting an constructor invocation error. */
2974 static void
2975 parse_ctor_invocation_error (void)
2976 {
2977 if (DECL_CONSTRUCTOR_P (current_function_decl))
2978 yyerror ("Constructor invocation must be first thing in a constructor");
2979 else
2980 yyerror ("Only constructors can invoke constructors");
2981 }
2982
2983 /* Reporting JDK1.1 features not implemented. */
2984
2985 static tree
2986 parse_jdk1_1_error (const char *msg)
2987 {
2988 sorry (": `%s' JDK1.1(TM) feature", msg);
2989 java_error_count++;
2990 return empty_stmt_node;
2991 }
2992
2993 static int do_warning = 0;
2994
2995 void
2996 yyerror (const char *msg)
2997 {
2998 static java_lc elc;
2999 static int prev_lineno;
3000 static const char *prev_msg;
3001
3002 int save_lineno;
3003 char *remainder, *code_from_source;
3004
3005 if (!force_error && prev_lineno == input_line)
3006 return;
3007
3008 /* Save current error location but report latter, when the context is
3009 richer. */
3010 if (ctxp->java_error_flag == 0)
3011 {
3012 ctxp->java_error_flag = 1;
3013 elc = ctxp->elc;
3014 /* Do something to use the previous line if we're reaching the
3015 end of the file... */
3016 #ifdef VERBOSE_SKELETON
3017 printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3018 #endif
3019 return;
3020 }
3021
3022 /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3023 if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3024 return;
3025
3026 ctxp->java_error_flag = 0;
3027 if (do_warning)
3028 java_warning_count++;
3029 else
3030 java_error_count++;
3031
3032 if (elc.col == 0 && msg && msg[1] == ';')
3033 {
3034 elc.col = ctxp->p_line->char_col-1;
3035 elc.line = ctxp->p_line->lineno;
3036 }
3037
3038 save_lineno = input_line;
3039 prev_lineno = input_line = elc.line;
3040 prev_msg = msg;
3041
3042 code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3043 obstack_grow0 (&temporary_obstack,
3044 code_from_source, strlen (code_from_source));
3045 remainder = obstack_finish (&temporary_obstack);
3046 if (do_warning)
3047 warning ("%s.\n%s", msg, remainder);
3048 else
3049 error ("%s.\n%s", msg, remainder);
3050
3051 /* This allow us to cheaply avoid an extra 'Invalid expression
3052 statement' error report when errors have been already reported on
3053 the same line. This occurs when we report an error but don't have
3054 a synchronization point other than ';', which
3055 expression_statement is the only one to take care of. */
3056 ctxp->prevent_ese = input_line = save_lineno;
3057 }
3058
3059 static void
3060 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3061 {
3062 const char *saved, *saved_input_filename;
3063 char buffer [4096];
3064 vsprintf (buffer, msg, ap);
3065 force_error = 1;
3066
3067 ctxp->elc.line = EXPR_WFL_LINENO (cl);
3068 ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3069 (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3070
3071 /* We have a CL, that's a good reason for using it if it contains data */
3072 saved = ctxp->filename;
3073 if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3074 ctxp->filename = EXPR_WFL_FILENAME (cl);
3075 saved_input_filename = input_filename;
3076 input_filename = ctxp->filename;
3077 java_error (NULL);
3078 java_error (buffer);
3079 ctxp->filename = saved;
3080 input_filename = saved_input_filename;
3081 force_error = 0;
3082 }
3083
3084 /* Issue an error message at a current source line CL */
3085
3086 void
3087 parse_error_context (tree cl, const char *msg, ...)
3088 {
3089 va_list ap;
3090 va_start (ap, msg);
3091 issue_warning_error_from_context (cl, msg, ap);
3092 va_end (ap);
3093 }
3094
3095 /* Issue a warning at a current source line CL */
3096
3097 static void
3098 parse_warning_context (tree cl, const char *msg, ...)
3099 {
3100 va_list ap;
3101 va_start (ap, msg);
3102
3103 force_error = do_warning = 1;
3104 issue_warning_error_from_context (cl, msg, ap);
3105 do_warning = force_error = 0;
3106 va_end (ap);
3107 }
3108
3109 static tree
3110 find_expr_with_wfl (tree node)
3111 {
3112 while (node)
3113 {
3114 char code;
3115 tree to_return;
3116
3117 switch (TREE_CODE (node))
3118 {
3119 case BLOCK:
3120 node = BLOCK_EXPR_BODY (node);
3121 continue;
3122
3123 case COMPOUND_EXPR:
3124 to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3125 if (to_return)
3126 return to_return;
3127 node = TREE_OPERAND (node, 1);
3128 continue;
3129
3130 case LOOP_EXPR:
3131 node = TREE_OPERAND (node, 0);
3132 continue;
3133
3134 case LABELED_BLOCK_EXPR:
3135 node = TREE_OPERAND (node, 1);
3136 continue;
3137
3138 default:
3139 code = TREE_CODE_CLASS (TREE_CODE (node));
3140 if (((code == '1') || (code == '2') || (code == 'e'))
3141 && EXPR_WFL_LINECOL (node))
3142 return node;
3143 return NULL_TREE;
3144 }
3145 }
3146 return NULL_TREE;
3147 }
3148
3149 /* Issue a missing return statement error. Uses METHOD to figure the
3150 last line of the method the error occurs in. */
3151
3152 static void
3153 missing_return_error (tree method)
3154 {
3155 EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3156 parse_error_context (wfl_operator, "Missing return statement");
3157 }
3158
3159 /* Issue an unreachable statement error. From NODE, find the next
3160 statement to report appropriately. */
3161 static void
3162 unreachable_stmt_error (tree node)
3163 {
3164 /* Browse node to find the next expression node that has a WFL. Use
3165 the location to report the error */
3166 if (TREE_CODE (node) == COMPOUND_EXPR)
3167 node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3168 else
3169 node = find_expr_with_wfl (node);
3170
3171 if (node)
3172 {
3173 EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3174 parse_error_context (wfl_operator, "Unreachable statement");
3175 }
3176 else
3177 abort ();
3178 }
3179
3180 static int
3181 not_accessible_field_error (tree wfl, tree decl)
3182 {
3183 parse_error_context
3184 (wfl, "Can't access %s field `%s.%s' from `%s'",
3185 java_accstring_lookup (get_access_flags_from_decl (decl)),
3186 GET_TYPE_NAME (DECL_CONTEXT (decl)),
3187 IDENTIFIER_POINTER (DECL_NAME (decl)),
3188 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3189 return 1;
3190 }
3191
3192 int
3193 java_report_errors (void)
3194 {
3195 if (java_error_count)
3196 fprintf (stderr, "%d error%s",
3197 java_error_count, (java_error_count == 1 ? "" : "s"));
3198 if (java_warning_count)
3199 fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3200 java_warning_count, (java_warning_count == 1 ? "" : "s"));
3201 if (java_error_count || java_warning_count)
3202 putc ('\n', stderr);
3203 return java_error_count;
3204 }
3205
3206 static char *
3207 java_accstring_lookup (int flags)
3208 {
3209 static char buffer [80];
3210 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3211
3212 /* Access modifier looked-up first for easier report on forbidden
3213 access. */
3214 if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3215 if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3216 if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3217 if (flags & ACC_STATIC) COPY_RETURN ("static");
3218 if (flags & ACC_FINAL) COPY_RETURN ("final");
3219 if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3220 if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3221 if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3222 if (flags & ACC_NATIVE) COPY_RETURN ("native");
3223 if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3224 if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3225
3226 buffer [0] = '\0';
3227 return buffer;
3228 #undef COPY_RETURN
3229 }
3230
3231 /* Issuing error messages upon redefinition of classes, interfaces or
3232 variables. */
3233
3234 static void
3235 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3236 {
3237 parse_error_context (cl, "%s `%s' already defined in %s:%d",
3238 context, IDENTIFIER_POINTER (id),
3239 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3240 /* Here we should point out where its redefined. It's a unicode. FIXME */
3241 }
3242
3243 static void
3244 variable_redefinition_error (tree context, tree name, tree type, int line)
3245 {
3246 const char *type_name;
3247
3248 /* Figure a proper name for type. We might haven't resolved it */
3249 if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3250 type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3251 else
3252 type_name = lang_printable_name (type, 0);
3253
3254 parse_error_context (context,
3255 "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3256 IDENTIFIER_POINTER (name),
3257 type_name, IDENTIFIER_POINTER (name), line);
3258 }
3259
3260 /* If ANAME is terminated with `[]', it indicates an array. This
3261 function returns the number of `[]' found and if this number is
3262 greater than zero, it extracts the array type name and places it in
3263 the node pointed to by TRIMMED unless TRIMMED is null. */
3264
3265 static int
3266 build_type_name_from_array_name (tree aname, tree *trimmed)
3267 {
3268 const char *name = IDENTIFIER_POINTER (aname);
3269 int len = IDENTIFIER_LENGTH (aname);
3270 int array_dims;
3271
3272 STRING_STRIP_BRACKETS (name, len, array_dims);
3273
3274 if (array_dims && trimmed)
3275 *trimmed = get_identifier_with_length (name, len);
3276
3277 return array_dims;
3278 }
3279
3280 static tree
3281 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3282 {
3283 int more_dims = 0;
3284
3285 /* Eventually get more dims */
3286 more_dims = build_type_name_from_array_name (name, &name);
3287
3288 /* If we have, then craft a new type for this variable */
3289 if (more_dims)
3290 {
3291 tree save = type;
3292
3293 /* If we have a pointer, use its type */
3294 if (TREE_CODE (type) == POINTER_TYPE)
3295 type = TREE_TYPE (type);
3296
3297 /* Building the first dimension of a primitive type uses this
3298 function */
3299 if (JPRIMITIVE_TYPE_P (type))
3300 {
3301 type = build_java_array_type (type, -1);
3302 more_dims--;
3303 }
3304 /* Otherwise, if we have a WFL for this type, use it (the type
3305 is already an array on an unresolved type, and we just keep
3306 on adding dimensions) */
3307 else if (type_wfl)
3308 {
3309 type = type_wfl;
3310 more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3311 NULL);
3312 }
3313
3314 /* Add all the dimensions */
3315 while (more_dims--)
3316 type = build_unresolved_array_type (type);
3317
3318 /* The type may have been incomplete in the first place */
3319 if (type_wfl)
3320 type = obtain_incomplete_type (type);
3321 }
3322
3323 if (ret_name)
3324 *ret_name = name;
3325 return type;
3326 }
3327
3328 /* Build something that the type identifier resolver will identify as
3329 being an array to an unresolved type. TYPE_WFL is a WFL on a
3330 identifier. */
3331
3332 static tree
3333 build_unresolved_array_type (tree type_or_wfl)
3334 {
3335 const char *ptr;
3336 tree wfl;
3337
3338 /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3339 just create a array type */
3340 if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3341 return build_java_array_type (type_or_wfl, -1);
3342
3343 obstack_grow (&temporary_obstack,
3344 IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3345 IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3346 obstack_grow0 (&temporary_obstack, "[]", 2);
3347 ptr = obstack_finish (&temporary_obstack);
3348 wfl = build_expr_wfl (get_identifier (ptr),
3349 EXPR_WFL_FILENAME (type_or_wfl),
3350 EXPR_WFL_LINENO (type_or_wfl),
3351 EXPR_WFL_COLNO (type_or_wfl));
3352 /* Re-install the existing qualifications so that the type can be
3353 resolved properly. */
3354 EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3355 return wfl;
3356 }
3357
3358 static void
3359 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3360 {
3361 if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3362 parse_error_context (wfl, "Interface `%s' repeated",
3363 IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3364 }
3365
3366 /* Bulk of common class/interface checks. Return 1 if an error was
3367 encountered. TAG is 0 for a class, 1 for an interface. */
3368
3369 static int
3370 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3371 tree qualified_name, tree decl, tree cl)
3372 {
3373 tree node;
3374 int sca = 0; /* Static class allowed */
3375 int icaf = 0; /* Inner class allowed flags */
3376 int uaaf = CLASS_MODIFIERS; /* Usually allowed access flags */
3377
3378 if (!quiet_flag)
3379 fprintf (stderr, " %s%s %s",
3380 (CPC_INNER_P () ? "inner" : ""),
3381 (is_interface ? "interface" : "class"),
3382 IDENTIFIER_POINTER (qualified_name));
3383
3384 /* Scope of an interface/class type name:
3385 - Can't be imported by a single type import
3386 - Can't already exists in the package */
3387 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3388 && (node = find_name_in_single_imports (raw_name))
3389 && !CPC_INNER_P ())
3390 {
3391 parse_error_context
3392 (cl, "%s name `%s' clashes with imported type `%s'",
3393 (is_interface ? "Interface" : "Class"),
3394 IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3395 return 1;
3396 }
3397 if (decl && CLASS_COMPLETE_P (decl))
3398 {
3399 classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3400 qualified_name, decl, cl);
3401 return 1;
3402 }
3403
3404 if (check_inner_class_redefinition (raw_name, cl))
3405 return 1;
3406
3407 /* If public, file name should match class/interface name, except
3408 when dealing with an inner class */
3409 if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3410 {
3411 const char *f;
3412
3413 for (f = &input_filename [strlen (input_filename)];
3414 f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3415 f--)
3416 ;
3417 if (IS_DIR_SEPARATOR (f[0]))
3418 f++;
3419 if (strncmp (IDENTIFIER_POINTER (raw_name),
3420 f , IDENTIFIER_LENGTH (raw_name)) ||
3421 f [IDENTIFIER_LENGTH (raw_name)] != '.')
3422 parse_error_context
3423 (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3424 (is_interface ? "interface" : "class"),
3425 IDENTIFIER_POINTER (qualified_name),
3426 IDENTIFIER_POINTER (raw_name));
3427 }
3428
3429 /* Static classes can be declared only in top level classes. Note:
3430 once static, a inner class is a top level class. */
3431 if (flags & ACC_STATIC)
3432 {
3433 /* Catch the specific error of declaring an class inner class
3434 with no toplevel enclosing class. Prevent check_modifiers from
3435 complaining a second time */
3436 if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3437 {
3438 parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3439 IDENTIFIER_POINTER (qualified_name));
3440 sca = ACC_STATIC;
3441 }
3442 /* Else, in the context of a top-level class declaration, let
3443 `check_modifiers' do its job, otherwise, give it a go */
3444 else
3445 sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3446 }
3447
3448 /* Inner classes can be declared private or protected
3449 within their enclosing classes. */
3450 if (CPC_INNER_P ())
3451 {
3452 /* A class which is local to a block can't be public, private,
3453 protected or static. But it is created final, so allow this
3454 one. */
3455 if (current_function_decl)
3456 icaf = sca = uaaf = ACC_FINAL;
3457 else
3458 {
3459 check_modifiers_consistency (flags);
3460 icaf = ACC_PROTECTED;
3461 if (! CLASS_INTERFACE (GET_CPC ()))
3462 icaf |= ACC_PRIVATE;
3463 }
3464 }
3465
3466 if (is_interface)
3467 {
3468 if (CPC_INNER_P ())
3469 uaaf = INTERFACE_INNER_MODIFIERS;
3470 else
3471 uaaf = INTERFACE_MODIFIERS;
3472
3473 check_modifiers ("Illegal modifier `%s' for interface declaration",
3474 flags, uaaf);
3475 }
3476 else
3477 check_modifiers ((current_function_decl ?
3478 "Illegal modifier `%s' for local class declaration" :
3479 "Illegal modifier `%s' for class declaration"),
3480 flags, uaaf|sca|icaf);
3481 return 0;
3482 }
3483
3484 /* Construct a nested class name. If the final component starts with
3485 a digit, return true. Otherwise return false. */
3486 static int
3487 make_nested_class_name (tree cpc_list)
3488 {
3489 tree name;
3490
3491 if (!cpc_list)
3492 return 0;
3493
3494 make_nested_class_name (TREE_CHAIN (cpc_list));
3495
3496 /* Pick the qualified name when dealing with the first upmost
3497 enclosing class */
3498 name = (TREE_CHAIN (cpc_list)
3499 ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3500 obstack_grow (&temporary_obstack,
3501 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3502 obstack_1grow (&temporary_obstack, '$');
3503
3504 return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3505 }
3506
3507 /* Can't redefine a class already defined in an earlier scope. */
3508
3509 static int
3510 check_inner_class_redefinition (tree raw_name, tree cl)
3511 {
3512 tree scope_list;
3513
3514 for (scope_list = GET_CPC_LIST (); scope_list;
3515 scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3516 if (raw_name == GET_CPC_UN_NODE (scope_list))
3517 {
3518 parse_error_context
3519 (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",
3520 IDENTIFIER_POINTER (raw_name));
3521 return 1;
3522 }
3523 return 0;
3524 }
3525
3526 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3527 we remember ENCLOSING and SUPER. */
3528
3529 static tree
3530 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3531 tree *super, tree class_type)
3532 {
3533 tree local_enclosing = *enclosing;
3534 tree local_super = NULL_TREE;
3535
3536 while (local_enclosing)
3537 {
3538 tree intermediate, decl;
3539
3540 *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3541 local_enclosing;
3542
3543 if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3544 return decl;
3545
3546 intermediate = local_enclosing;
3547 /* Explore enclosing contexts. */
3548 while (INNER_CLASS_DECL_P (intermediate))
3549 {
3550 intermediate = DECL_CONTEXT (intermediate);
3551 if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3552 return decl;
3553 }
3554
3555 /* Now go to the upper classes, bail out if necessary. We will
3556 analyze the returned SUPER and act accordingly (see
3557 do_resolve_class). */
3558 if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3559 || TREE_TYPE (local_enclosing) == void_type_node)
3560 {
3561 parse_error_context (cl, "Qualifier must be a reference");
3562 local_enclosing = NULL_TREE;
3563 break;
3564 }
3565 local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3566 if (!local_super || local_super == object_type_node)
3567 break;
3568
3569 if (TREE_CODE (local_super) == POINTER_TYPE)
3570 local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3571 else
3572 local_super = TYPE_NAME (local_super);
3573
3574 /* We may not have checked for circular inheritance yet, so do so
3575 here to prevent an infinite loop. */
3576 if (htab_find (circularity_hash, local_super) != NULL)
3577 {
3578 if (!cl)
3579 cl = lookup_cl (local_enclosing);
3580
3581 parse_error_context
3582 (cl, "Cyclic inheritance involving %s",
3583 IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3584 local_enclosing = NULL_TREE;
3585 }
3586 else
3587 local_enclosing = local_super;
3588 }
3589
3590 /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3591 *super = local_super;
3592 *enclosing = local_enclosing;
3593
3594 return NULL_TREE;
3595 }
3596
3597 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3598 qualified. */
3599
3600 static tree
3601 find_as_inner_class (tree enclosing, tree name, tree cl)
3602 {
3603 tree qual, to_return;
3604 if (!enclosing)
3605 return NULL_TREE;
3606
3607 name = TYPE_NAME (name);
3608
3609 /* First search: within the scope of `enclosing', search for name */
3610 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3611 qual = EXPR_WFL_QUALIFICATION (cl);
3612 else if (cl)
3613 qual = build_tree_list (cl, NULL_TREE);
3614 else
3615 qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3616
3617 if ((to_return = find_as_inner_class_do (qual, enclosing)))
3618 return to_return;
3619
3620 /* We're dealing with a qualified name. Try to resolve thing until
3621 we get something that is an enclosing class. */
3622 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3623 {
3624 tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3625
3626 for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3627 qual = TREE_CHAIN (qual))
3628 {
3629 acc = merge_qualified_name (acc,
3630 EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3631 BUILD_PTR_FROM_NAME (ptr, acc);
3632 decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3633 }
3634
3635 /* A NULL qual and a decl means that the search ended
3636 successfully?!? We have to do something then. FIXME */
3637
3638 if (decl)
3639 enclosing = decl;
3640 else
3641 qual = EXPR_WFL_QUALIFICATION (cl);
3642 }
3643 /* Otherwise, create a qual for the other part of the resolution. */
3644 else
3645 qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3646
3647 return find_as_inner_class_do (qual, enclosing);
3648 }
3649
3650 /* We go inside the list of sub classes and try to find a way
3651 through. */
3652
3653 static tree
3654 find_as_inner_class_do (tree qual, tree enclosing)
3655 {
3656 if (!qual)
3657 return NULL_TREE;
3658
3659 for (; qual && enclosing; qual = TREE_CHAIN (qual))
3660 {
3661 tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3662 tree next_enclosing = NULL_TREE;
3663 tree inner_list;
3664
3665 for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3666 inner_list; inner_list = TREE_CHAIN (inner_list))
3667 {
3668 if (TREE_VALUE (inner_list) == name_to_match)
3669 {
3670 next_enclosing = TREE_PURPOSE (inner_list);
3671 break;
3672 }
3673 }
3674 enclosing = next_enclosing;
3675 }
3676
3677 return (!qual && enclosing ? enclosing : NULL_TREE);
3678 }
3679
3680 /* Reach all inner classes and tie their unqualified name to a
3681 DECL. */
3682
3683 static void
3684 set_nested_class_simple_name_value (tree outer, int set)
3685 {
3686 tree l;
3687
3688 for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3689 IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3690 TREE_PURPOSE (l) : NULL_TREE);
3691 }
3692
3693 static void
3694 link_nested_class_to_enclosing (void)
3695 {
3696 if (GET_ENCLOSING_CPC ())
3697 {
3698 tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3699 DECL_INNER_CLASS_LIST (enclosing) =
3700 tree_cons (GET_CPC (), GET_CPC_UN (),
3701 DECL_INNER_CLASS_LIST (enclosing));
3702 }
3703 }
3704
3705 static tree
3706 maybe_make_nested_class_name (tree name)
3707 {
3708 tree id = NULL_TREE;
3709
3710 if (CPC_INNER_P ())
3711 {
3712 /* If we're in a function, we must append a number to create the
3713 nested class name. However, we don't do this if the class we
3714 are constructing is anonymous, because in that case we'll
3715 already have a number as the class name. */
3716 if (! make_nested_class_name (GET_CPC_LIST ())
3717 && current_function_decl != NULL_TREE
3718 && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3719 {
3720 char buf[10];
3721 sprintf (buf, "%d", anonymous_class_counter);
3722 ++anonymous_class_counter;
3723 obstack_grow (&temporary_obstack, buf, strlen (buf));
3724 obstack_1grow (&temporary_obstack, '$');
3725 }
3726 obstack_grow0 (&temporary_obstack,
3727 IDENTIFIER_POINTER (name),
3728 IDENTIFIER_LENGTH (name));
3729 id = get_identifier (obstack_finish (&temporary_obstack));
3730 if (ctxp->package)
3731 QUALIFIED_P (id) = 1;
3732 }
3733 return id;
3734 }
3735
3736 /* If DECL is NULL, create and push a new DECL, record the current
3737 line CL and do other maintenance things. */
3738
3739 static tree
3740 maybe_create_class_interface_decl (tree decl, tree raw_name,
3741 tree qualified_name, tree cl)
3742 {
3743 if (!decl)
3744 decl = push_class (make_class (), qualified_name);
3745
3746 /* Take care of the file and line business */
3747 DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3748 /* If we're emitting xrefs, store the line/col number information */
3749 if (flag_emit_xref)
3750 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3751 else
3752 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3753 CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3754 CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3755 CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3756 IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3757
3758 PUSH_CPC (decl, raw_name);
3759 DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3760
3761 /* Link the declaration to the already seen ones */
3762 TREE_CHAIN (decl) = ctxp->class_list;
3763 ctxp->class_list = decl;
3764
3765 /* Create a new nodes in the global lists */
3766 gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3767 all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3768
3769 /* Install a new dependency list element */
3770 create_jdep_list (ctxp);
3771
3772 SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3773 IDENTIFIER_POINTER (qualified_name)));
3774 return decl;
3775 }
3776
3777 static void
3778 add_superinterfaces (tree decl, tree interface_list)
3779 {
3780 tree node;
3781 /* Superinterface(s): if present and defined, parser_check_super_interface ()
3782 takes care of ensuring that:
3783 - This is an accessible interface type,
3784 - Circularity detection.
3785 parser_add_interface is then called. If present but not defined,
3786 the check operation is delayed until the super interface gets
3787 defined. */
3788 for (node = interface_list; node; node = TREE_CHAIN (node))
3789 {
3790 tree current = TREE_PURPOSE (node);
3791 tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3792 if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3793 {
3794 if (!parser_check_super_interface (idecl, decl, current))
3795 parser_add_interface (decl, idecl, current);
3796 }
3797 else
3798 register_incomplete_type (JDEP_INTERFACE,
3799 current, decl, NULL_TREE);
3800 }
3801 }
3802
3803 /* Create an interface in pass1 and return its decl. Return the
3804 interface's decl in pass 2. */
3805
3806 static tree
3807 create_interface (int flags, tree id, tree super)
3808 {
3809 tree raw_name = EXPR_WFL_NODE (id);
3810 tree q_name = parser_qualified_classname (raw_name);
3811 tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3812
3813 /* Certain syntax errors are making SUPER be like ID. Avoid this
3814 case. */
3815 if (ctxp->class_err && id == super)
3816 super = NULL;
3817
3818 EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */
3819
3820 /* Basic checks: scope, redefinition, modifiers */
3821 if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3822 {
3823 PUSH_ERROR ();
3824 return NULL_TREE;
3825 }
3826
3827 /* Suspend the current parsing context if we're parsing an inner
3828 interface */
3829 if (CPC_INNER_P ())
3830 {
3831 java_parser_context_suspend ();
3832 /* Interface members are public. */
3833 if (CLASS_INTERFACE (GET_CPC ()))
3834 flags |= ACC_PUBLIC;
3835 }
3836
3837 /* Push a new context for (static) initialized upon declaration fields */
3838 java_parser_context_push_initialized_field ();
3839
3840 /* Interface modifiers check
3841 - public/abstract allowed (already done at that point)
3842 - abstract is obsolete (comes first, it's a warning, or should be)
3843 - Can't use twice the same (checked in the modifier rule) */
3844 if ((flags & ACC_ABSTRACT) && flag_redundant)
3845 parse_warning_context
3846 (MODIFIER_WFL (ABSTRACT_TK),
3847 "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3848
3849 /* Create a new decl if DECL is NULL, otherwise fix it */
3850 decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3851
3852 /* Set super info and mark the class a complete */
3853 set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3854 object_type_node, ctxp->interface_number);
3855 ctxp->interface_number = 0;
3856 CLASS_COMPLETE_P (decl) = 1;
3857 add_superinterfaces (decl, super);
3858
3859 /* Eventually sets the @deprecated tag flag */
3860 CHECK_DEPRECATED (decl);
3861
3862 return decl;
3863 }
3864
3865 /* Patch anonymous class CLASS, by either extending or implementing
3866 DEP. */
3867
3868 static void
3869 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3870 {
3871 tree class = TREE_TYPE (class_decl);
3872 tree type = TREE_TYPE (type_decl);
3873 tree binfo = TYPE_BINFO (class);
3874
3875 /* If it's an interface, implement it */
3876 if (CLASS_INTERFACE (type_decl))
3877 {
3878 tree s_binfo;
3879 int length;
3880
3881 if (parser_check_super_interface (type_decl, class_decl, wfl))
3882 return;
3883
3884 s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3885 length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3886 TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3887 TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3888 /* And add the interface */
3889 parser_add_interface (class_decl, type_decl, wfl);
3890 }
3891 /* Otherwise, it's a type we want to extend */
3892 else
3893 {
3894 if (parser_check_super (type_decl, class_decl, wfl))
3895 return;
3896 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3897 }
3898 }
3899
3900 static tree
3901 create_anonymous_class (int location, tree type_name)
3902 {
3903 char buffer [80];
3904 tree super = NULL_TREE, itf = NULL_TREE;
3905 tree id, type_decl, class;
3906
3907 /* The unqualified name of the anonymous class. It's just a number. */
3908 sprintf (buffer, "%d", anonymous_class_counter++);
3909 id = build_wfl_node (get_identifier (buffer));
3910 EXPR_WFL_LINECOL (id) = location;
3911
3912 /* We know about the type to extend/implement. We go ahead */
3913 if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3914 {
3915 /* Create a class which either implements on extends the designated
3916 class. The class bears an inaccessible name. */
3917 if (CLASS_INTERFACE (type_decl))
3918 {
3919 /* It's OK to modify it here. It's been already used and
3920 shouldn't be reused */
3921 ctxp->interface_number = 1;
3922 /* Interfaces should presented as a list of WFLs */
3923 itf = build_tree_list (type_name, NULL_TREE);
3924 }
3925 else
3926 super = type_name;
3927 }
3928
3929 class = create_class (ACC_FINAL, id, super, itf);
3930
3931 /* We didn't know anything about the stuff. We register a dependence. */
3932 if (!type_decl)
3933 register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3934
3935 ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3936 return class;
3937 }
3938
3939 /* Create a class in pass1 and return its decl. Return class
3940 interface's decl in pass 2. */
3941
3942 static tree
3943 create_class (int flags, tree id, tree super, tree interfaces)
3944 {
3945 tree raw_name = EXPR_WFL_NODE (id);
3946 tree class_id, decl;
3947 tree super_decl_type;
3948
3949 /* Certain syntax errors are making SUPER be like ID. Avoid this
3950 case. */
3951 if (ctxp->class_err && id == super)
3952 super = NULL;
3953
3954 class_id = parser_qualified_classname (raw_name);
3955 decl = IDENTIFIER_CLASS_VALUE (class_id);
3956 EXPR_WFL_NODE (id) = class_id;
3957
3958 /* Basic check: scope, redefinition, modifiers */
3959 if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3960 {
3961 PUSH_ERROR ();
3962 return NULL_TREE;
3963 }
3964
3965 /* Suspend the current parsing context if we're parsing an inner
3966 class or an anonymous class. */
3967 if (CPC_INNER_P ())
3968 {
3969 java_parser_context_suspend ();
3970 /* Interface members are public. */
3971 if (CLASS_INTERFACE (GET_CPC ()))
3972 flags |= ACC_PUBLIC;
3973 }
3974
3975 /* Push a new context for (static) initialized upon declaration fields */
3976 java_parser_context_push_initialized_field ();
3977
3978 /* Class modifier check:
3979 - Allowed modifier (already done at that point)
3980 - abstract AND final forbidden
3981 - Public classes defined in the correct file */
3982 if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3983 parse_error_context
3984 (id, "Class `%s' can't be declared both abstract and final",
3985 IDENTIFIER_POINTER (raw_name));
3986
3987 /* Create a new decl if DECL is NULL, otherwise fix it */
3988 decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3989
3990 /* If SUPER exists, use it, otherwise use Object */
3991 if (super)
3992 {
3993 /* Can't extend java.lang.Object */
3994 if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3995 {
3996 parse_error_context (id, "Can't extend `java.lang.Object'");
3997 return NULL_TREE;
3998 }
3999
4000 super_decl_type =
4001 register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4002 }
4003 else if (TREE_TYPE (decl) != object_type_node)
4004 super_decl_type = object_type_node;
4005 /* We're defining java.lang.Object */
4006 else
4007 super_decl_type = NULL_TREE;
4008
4009 /* A class nested in an interface is implicitly static. */
4010 if (INNER_CLASS_DECL_P (decl)
4011 && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4012 {
4013 flags |= ACC_STATIC;
4014 }
4015
4016 /* Set super info and mark the class as complete. */
4017 set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4018 ctxp->interface_number);
4019 ctxp->interface_number = 0;
4020 CLASS_COMPLETE_P (decl) = 1;
4021 add_superinterfaces (decl, interfaces);
4022
4023 /* Add the private this$<n> field, Replicate final locals still in
4024 scope as private final fields mangled like val$<local_name>.
4025 This doesn't not occur for top level (static) inner classes. */
4026 if (PURE_INNER_CLASS_DECL_P (decl))
4027 add_inner_class_fields (decl, current_function_decl);
4028
4029 /* If doing xref, store the location at which the inherited class
4030 (if any) was seen. */
4031 if (flag_emit_xref && super)
4032 DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4033
4034 /* Eventually sets the @deprecated tag flag */
4035 CHECK_DEPRECATED (decl);
4036
4037 /* Reset the anonymous class counter when declaring non inner classes */
4038 if (!INNER_CLASS_DECL_P (decl))
4039 anonymous_class_counter = 1;
4040
4041 return decl;
4042 }
4043
4044 /* End a class declaration: register the statements used to create
4045 finit$ and <clinit>, pop the current class and resume the prior
4046 parser context if necessary. */
4047
4048 static void
4049 end_class_declaration (int resume)
4050 {
4051 /* If an error occurred, context weren't pushed and won't need to be
4052 popped by a resume. */
4053 int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4054
4055 if (GET_CPC () != error_mark_node)
4056 dump_java_tree (TDI_class, GET_CPC ());
4057
4058 java_parser_context_pop_initialized_field ();
4059 POP_CPC ();
4060 if (resume && no_error_occurred)
4061 java_parser_context_resume ();
4062
4063 /* We're ending a class declaration, this is a good time to reset
4064 the interface cout. Note that might have been already done in
4065 create_interface, but if at that time an inner class was being
4066 dealt with, the interface count was reset in a context created
4067 for the sake of handling inner classes declaration. */
4068 ctxp->interface_number = 0;
4069 }
4070
4071 static void
4072 add_inner_class_fields (tree class_decl, tree fct_decl)
4073 {
4074 tree block, marker, f;
4075
4076 f = add_field (TREE_TYPE (class_decl),
4077 build_current_thisn (TREE_TYPE (class_decl)),
4078 build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4079 ACC_PRIVATE);
4080 FIELD_THISN (f) = 1;
4081
4082 if (!fct_decl)
4083 return;
4084
4085 for (block = GET_CURRENT_BLOCK (fct_decl);
4086 block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4087 {
4088 tree decl;
4089 for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4090 {
4091 tree name, pname;
4092 tree wfl, init, list;
4093
4094 /* Avoid non final arguments. */
4095 if (!LOCAL_FINAL_P (decl))
4096 continue;
4097
4098 MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4099 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4100 wfl = build_wfl_node (name);
4101 init = build_wfl_node (pname);
4102 /* Build an initialization for the field: it will be
4103 initialized by a parameter added to finit$, bearing a
4104 mangled name of the field itself (param$<n>.) The
4105 parameter is provided to finit$ by the constructor
4106 invoking it (hence the constructor will also feature a
4107 hidden parameter, set to the value of the outer context
4108 local at the time the inner class is created.)
4109
4110 Note: we take into account all possible locals that can
4111 be accessed by the inner class. It's actually not trivial
4112 to minimize these aliases down to the ones really
4113 used. One way to do that would be to expand all regular
4114 methods first, then finit$ to get a picture of what's
4115 used. It works with the exception that we would have to
4116 go back on all constructor invoked in regular methods to
4117 have their invocation reworked (to include the right amount
4118 of alias initializer parameters.)
4119
4120 The only real way around, I think, is a first pass to
4121 identify locals really used in the inner class. We leave
4122 the flag FIELD_LOCAL_ALIAS_USED around for that future
4123 use.
4124
4125 On the other hand, it only affect local inner classes,
4126 whose constructors (and finit$ call) will be featuring
4127 unnecessary arguments. It's easy for a developer to keep
4128 this number of parameter down by using the `final'
4129 keyword only when necessary. For the time being, we can
4130 issue a warning on unnecessary finals. FIXME */
4131 init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4132 wfl, init);
4133
4134 /* Register the field. The TREE_LIST holding the part
4135 initialized/initializer will be marked ARG_FINAL_P so
4136 that the created field can be marked
4137 FIELD_LOCAL_ALIAS. */
4138 list = build_tree_list (wfl, init);
4139 ARG_FINAL_P (list) = 1;
4140 register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4141 }
4142 }
4143
4144 if (!CPC_INITIALIZER_STMT (ctxp))
4145 return;
4146
4147 /* If we ever registered an alias field, insert and marker to
4148 remember where the list ends. The second part of the list (the one
4149 featuring initialized fields) so it can be later reversed to
4150 enforce 8.5. The marker will be removed during that operation. */
4151 marker = build_tree_list (NULL_TREE, NULL_TREE);
4152 TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4153 SET_CPC_INITIALIZER_STMT (ctxp, marker);
4154 }
4155
4156 /* Can't use lookup_field () since we don't want to load the class and
4157 can't set the CLASS_LOADED_P flag */
4158
4159 static tree
4160 find_field (tree class, tree name)
4161 {
4162 tree decl;
4163 for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4164 {
4165 if (DECL_NAME (decl) == name)
4166 return decl;
4167 }
4168 return NULL_TREE;
4169 }
4170
4171 /* Wrap around lookup_field that doesn't potentially upset the value
4172 of CLASS */
4173
4174 static tree
4175 lookup_field_wrapper (tree class, tree name)
4176 {
4177 tree type = class;
4178 tree decl = NULL_TREE;
4179 java_parser_context_save_global ();
4180
4181 /* Last chance: if we're within the context of an inner class, we
4182 might be trying to access a local variable defined in an outer
4183 context. We try to look for it now. */
4184 if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4185 {
4186 tree new_name;
4187 MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4188 decl = lookup_field (&type, new_name);
4189 if (decl && decl != error_mark_node)
4190 FIELD_LOCAL_ALIAS_USED (decl) = 1;
4191 }
4192 if (!decl || decl == error_mark_node)
4193 {
4194 type = class;
4195 decl = lookup_field (&type, name);
4196 }
4197
4198 /* If the field still hasn't been found, try the next enclosing context. */
4199 if (!decl && INNER_CLASS_TYPE_P (class))
4200 {
4201 tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4202 decl = lookup_field_wrapper (outer_type, name);
4203 }
4204
4205 java_parser_context_restore_global ();
4206 return decl == error_mark_node ? NULL : decl;
4207 }
4208
4209 /* Find duplicate field within the same class declarations and report
4210 the error. Returns 1 if a duplicated field was found, 0
4211 otherwise. */
4212
4213 static int
4214 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4215 {
4216 /* This might be modified to work with method decl as well */
4217 tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4218 if (decl)
4219 {
4220 char *t1 = xstrdup (purify_type_name
4221 ((TREE_CODE (new_type) == POINTER_TYPE
4222 && TREE_TYPE (new_type) == NULL_TREE) ?
4223 IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4224 lang_printable_name (new_type, 1)));
4225 /* The type may not have been completed by the time we report
4226 the error */
4227 char *t2 = xstrdup (purify_type_name
4228 ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4229 && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4230 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4231 lang_printable_name (TREE_TYPE (decl), 1)));
4232 parse_error_context
4233 (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4234 t1, IDENTIFIER_POINTER (new_field_name),
4235 t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4236 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4237 free (t1);
4238 free (t2);
4239 return 1;
4240 }
4241 return 0;
4242 }
4243
4244 /* Field registration routine. If TYPE doesn't exist, field
4245 declarations are linked to the undefined TYPE dependency list, to
4246 be later resolved in java_complete_class () */
4247
4248 static void
4249 register_fields (int flags, tree type, tree variable_list)
4250 {
4251 tree current, saved_type;
4252 tree class_type = NULL_TREE;
4253 int saved_lineno = input_line;
4254 int must_chain = 0;
4255 tree wfl = NULL_TREE;
4256
4257 if (GET_CPC ())
4258 class_type = TREE_TYPE (GET_CPC ());
4259
4260 if (!class_type || class_type == error_mark_node)
4261 return;
4262
4263 /* If we're adding fields to interfaces, those fields are public,
4264 static, final */
4265 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4266 {
4267 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4268 flags, ACC_PUBLIC, "interface field(s)");
4269 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4270 flags, ACC_STATIC, "interface field(s)");
4271 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4272 flags, ACC_FINAL, "interface field(s)");
4273 check_modifiers ("Illegal interface member modifier `%s'", flags,
4274 INTERFACE_FIELD_MODIFIERS);
4275 flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4276 }
4277
4278 /* Obtain a suitable type for resolution, if necessary */
4279 SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4280
4281 /* If TYPE is fully resolved and we don't have a reference, make one */
4282 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4283
4284 for (current = variable_list, saved_type = type; current;
4285 current = TREE_CHAIN (current), type = saved_type)
4286 {
4287 tree real_type;
4288 tree field_decl;
4289 tree cl = TREE_PURPOSE (current);
4290 tree init = TREE_VALUE (current);
4291 tree current_name = EXPR_WFL_NODE (cl);
4292
4293 /* Can't declare non-final static fields in inner classes */
4294 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4295 && !(flags & ACC_FINAL))
4296 parse_error_context
4297 (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4298 IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4299 lang_printable_name (class_type, 0));
4300
4301 /* Process NAME, as it may specify extra dimension(s) for it */
4302 type = build_array_from_name (type, wfl, current_name, &current_name);
4303
4304 /* Type adjustment. We may have just readjusted TYPE because
4305 the variable specified more dimensions. Make sure we have
4306 a reference if we can and don't have one already. Also
4307 change the name if we have an init. */
4308 if (type != saved_type)
4309 {
4310 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4311 if (init)
4312 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4313 }
4314
4315 real_type = GET_REAL_TYPE (type);
4316 /* Check for redeclarations */
4317 if (duplicate_declaration_error_p (current_name, real_type, cl))
4318 continue;
4319
4320 /* Set lineno to the line the field was found and create a
4321 declaration for it. Eventually sets the @deprecated tag flag. */
4322 if (flag_emit_xref)
4323 input_line = EXPR_WFL_LINECOL (cl);
4324 else
4325 input_line = EXPR_WFL_LINENO (cl);
4326 field_decl = add_field (class_type, current_name, real_type, flags);
4327 CHECK_DEPRECATED_NO_RESET (field_decl);
4328
4329 /* If the field denotes a final instance variable, then we
4330 allocate a LANG_DECL_SPECIFIC part to keep track of its
4331 initialization. We also mark whether the field was
4332 initialized upon its declaration. We don't do that if the
4333 created field is an alias to a final local. */
4334 if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4335 {
4336 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4337 DECL_FIELD_FINAL_WFL (field_decl) = cl;
4338 }
4339
4340 /* If the couple initializer/initialized is marked ARG_FINAL_P,
4341 we mark the created field FIELD_LOCAL_ALIAS, so that we can
4342 hide parameters to this inner class finit$ and
4343 constructors. It also means that the field isn't final per
4344 say. */
4345 if (ARG_FINAL_P (current))
4346 {
4347 FIELD_LOCAL_ALIAS (field_decl) = 1;
4348 FIELD_FINAL (field_decl) = 0;
4349 }
4350
4351 /* Check if we must chain. */
4352 if (must_chain)
4353 register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4354
4355 /* If we have an initialization value tied to the field */
4356 if (init)
4357 {
4358 /* The field is declared static */
4359 if (flags & ACC_STATIC)
4360 {
4361 /* We include the field and its initialization part into
4362 a list used to generate <clinit>. After <clinit> is
4363 walked, field initializations will be processed and
4364 fields initialized with known constants will be taken
4365 out of <clinit> and have their DECL_INITIAL set
4366 appropriately. */
4367 TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4368 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4369 if (TREE_OPERAND (init, 1)
4370 && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4371 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4372 }
4373 /* A non-static field declared with an immediate initialization is
4374 to be initialized in <init>, if any. This field is remembered
4375 to be processed at the time of the generation of <init>. */
4376 else
4377 {
4378 TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4379 SET_CPC_INITIALIZER_STMT (ctxp, init);
4380 }
4381 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4382 DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4383 }
4384 }
4385
4386 CLEAR_DEPRECATED;
4387 input_line = saved_lineno;
4388 }
4389
4390 /* Generate finit$, using the list of initialized fields to populate
4391 its body. finit$'s parameter(s) list is adjusted to include the
4392 one(s) used to initialized the field(s) caching outer context
4393 local(s). */
4394
4395 static tree
4396 generate_finit (tree class_type)
4397 {
4398 int count = 0;
4399 tree list = TYPE_FINIT_STMT_LIST (class_type);
4400 tree mdecl, current, parms;
4401
4402 parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4403 class_type, NULL_TREE,
4404 &count);
4405 CRAFTED_PARAM_LIST_FIXUP (parms);
4406 mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4407 finit_identifier_node, parms);
4408 fix_method_argument_names (parms, mdecl);
4409 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4410 mdecl, NULL_TREE);
4411 DECL_FUNCTION_NAP (mdecl) = count;
4412 start_artificial_method_body (mdecl);
4413
4414 for (current = list; current; current = TREE_CHAIN (current))
4415 java_method_add_stmt (mdecl,
4416 build_debugable_stmt (EXPR_WFL_LINECOL (current),
4417 current));
4418 end_artificial_method_body (mdecl);
4419 return mdecl;
4420 }
4421
4422 /* Generate a function to run the instance initialization code. The
4423 private method is called `instinit$'. Unless we're dealing with an
4424 anonymous class, we determine whether all ctors of CLASS_TYPE
4425 declare a checked exception in their `throws' clause in order to
4426 see whether it's necessary to encapsulate the instance initializer
4427 statements in a try/catch/rethrow sequence. */
4428
4429 static tree
4430 generate_instinit (tree class_type)
4431 {
4432 tree current;
4433 tree compound = NULL_TREE;
4434 tree parms = tree_cons (this_identifier_node,
4435 build_pointer_type (class_type), end_params_node);
4436 tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4437 void_type_node,
4438 instinit_identifier_node, parms);
4439
4440 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4441 mdecl, NULL_TREE);
4442
4443 /* Gather all the statements in a compound */
4444 for (current = TYPE_II_STMT_LIST (class_type);
4445 current; current = TREE_CHAIN (current))
4446 compound = add_stmt_to_compound (compound, NULL_TREE, current);
4447
4448 /* We need to encapsulate COMPOUND by a try/catch statement to
4449 rethrow exceptions that might occur in the instance initializer.
4450 We do that only if all ctors of CLASS_TYPE are set to catch a
4451 checked exception. This doesn't apply to anonymous classes (since
4452 they don't have declared ctors.) */
4453 if (!ANONYMOUS_CLASS_P (class_type) &&
4454 ctors_unchecked_throws_clause_p (class_type))
4455 {
4456 compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4457 build1 (THROW_EXPR, NULL_TREE,
4458 build_wfl_node (wpv_id)));
4459 DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4460 exception_type_node);
4461 }
4462
4463 start_artificial_method_body (mdecl);
4464 java_method_add_stmt (mdecl, compound);
4465 end_artificial_method_body (mdecl);
4466
4467 return mdecl;
4468 }
4469
4470 /* FIXME */
4471 static tree
4472 build_instinit_invocation (tree class_type)
4473 {
4474 tree to_return = NULL_TREE;
4475
4476 if (TYPE_II_STMT_LIST (class_type))
4477 {
4478 tree parm = build_tree_list (NULL_TREE,
4479 build_wfl_node (this_identifier_node));
4480 to_return =
4481 build_method_invocation (build_wfl_node (instinit_identifier_node),
4482 parm);
4483 }
4484 return to_return;
4485 }
4486
4487 /* Shared across method_declarator and method_header to remember the
4488 patch stage that was reached during the declaration of the method.
4489 A method DECL is built differently is there is no patch
4490 (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4491 pending on the currently defined method. */
4492
4493 static int patch_stage;
4494
4495 /* Check the method declaration and add the method to its current
4496 class. If the argument list is known to contain incomplete types,
4497 the method is partially added and the registration will be resume
4498 once the method arguments resolved. If TYPE is NULL, we're dealing
4499 with a constructor. */
4500
4501 static tree
4502 method_header (int flags, tree type, tree mdecl, tree throws)
4503 {
4504 tree type_wfl = NULL_TREE;
4505 tree meth_name = NULL_TREE;
4506 tree current, orig_arg, this_class = NULL;
4507 tree id, meth;
4508 int saved_lineno;
4509 int constructor_ok = 0, must_chain;
4510 int count;
4511
4512 if (mdecl == error_mark_node)
4513 return error_mark_node;
4514 meth = TREE_VALUE (mdecl);
4515 id = TREE_PURPOSE (mdecl);
4516
4517 check_modifiers_consistency (flags);
4518
4519 if (GET_CPC ())
4520 this_class = TREE_TYPE (GET_CPC ());
4521
4522 if (!this_class || this_class == error_mark_node)
4523 return NULL_TREE;
4524
4525 /* There are some forbidden modifiers for an abstract method and its
4526 class must be abstract as well. */
4527 if (type && (flags & ACC_ABSTRACT))
4528 {
4529 ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4530 ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4531 ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4532 ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4533 ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4534 ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4535 if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4536 && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4537 parse_error_context
4538 (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4539 IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4540 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4541 }
4542
4543 /* A native method can't be strictfp. */
4544 if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4545 parse_error_context (id, "native method `%s' can't be strictfp",
4546 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4547 /* No such thing as a transient or volatile method. */
4548 if ((flags & ACC_TRANSIENT))
4549 parse_error_context (id, "method `%s' can't be transient",
4550 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4551 if ((flags & ACC_VOLATILE))
4552 parse_error_context (id, "method `%s' can't be volatile",
4553 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4554
4555 /* Things to be checked when declaring a constructor */
4556 if (!type)
4557 {
4558 int ec = java_error_count;
4559 /* 8.6: Constructor declarations: we might be trying to define a
4560 method without specifying a return type. */
4561 if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4562 parse_error_context
4563 (id, "Invalid method declaration, return type required");
4564 /* 8.6.3: Constructor modifiers */
4565 else
4566 {
4567 JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4568 JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4569 JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4570 JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4571 JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4572 JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4573 }
4574 /* If we found error here, we don't consider it's OK to tread
4575 the method definition as a constructor, for the rest of this
4576 function */
4577 if (ec == java_error_count)
4578 constructor_ok = 1;
4579 }
4580
4581 /* Method declared within the scope of an interface are implicitly
4582 abstract and public. Conflicts with other erroneously provided
4583 modifiers are checked right after. */
4584
4585 if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4586 {
4587 /* If FLAGS isn't set because of a modifier, turn the
4588 corresponding modifier WFL to NULL so we issue a warning on
4589 the obsolete use of the modifier */
4590 if (!(flags & ACC_PUBLIC))
4591 MODIFIER_WFL (PUBLIC_TK) = NULL;
4592 if (!(flags & ACC_ABSTRACT))
4593 MODIFIER_WFL (ABSTRACT_TK) = NULL;
4594 flags |= ACC_PUBLIC;
4595 flags |= ACC_ABSTRACT;
4596 }
4597
4598 /* Inner class can't declare static methods */
4599 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4600 {
4601 parse_error_context
4602 (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4603 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4604 lang_printable_name (this_class, 0));
4605 }
4606
4607 /* Modifiers context reset moved up, so abstract method declaration
4608 modifiers can be later checked. */
4609
4610 /* Set constructor returned type to void and method name to <init>,
4611 unless we found an error identifier the constructor (in which
4612 case we retain the original name) */
4613 if (!type)
4614 {
4615 type = void_type_node;
4616 if (constructor_ok)
4617 meth_name = init_identifier_node;
4618 }
4619 else
4620 meth_name = EXPR_WFL_NODE (id);
4621
4622 /* Do the returned type resolution and registration if necessary */
4623 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4624
4625 if (meth_name)
4626 type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4627 EXPR_WFL_NODE (id) = meth_name;
4628 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4629
4630 if (must_chain)
4631 {
4632 patch_stage = JDEP_METHOD_RETURN;
4633 register_incomplete_type (patch_stage, type_wfl, id, type);
4634 TREE_TYPE (meth) = GET_REAL_TYPE (type);
4635 }
4636 else
4637 TREE_TYPE (meth) = type;
4638
4639 saved_lineno = input_line;
4640 /* When defining an abstract or interface method, the curly
4641 bracket at level 1 doesn't exist because there is no function
4642 body */
4643 input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4644 EXPR_WFL_LINENO (id));
4645
4646 /* Remember the original argument list */
4647 orig_arg = TYPE_ARG_TYPES (meth);
4648
4649 if (patch_stage) /* includes ret type and/or all args */
4650 {
4651 jdep *jdep;
4652 meth = add_method_1 (this_class, flags, meth_name, meth);
4653 /* Patch for the return type */
4654 if (patch_stage == JDEP_METHOD_RETURN)
4655 {
4656 jdep = CLASSD_LAST (ctxp->classd_list);
4657 JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4658 }
4659 /* This is the stop JDEP. METH allows the function's signature
4660 to be computed. */
4661 register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4662 }
4663 else
4664 meth = add_method (this_class, flags, meth_name,
4665 build_java_signature (meth));
4666
4667 /* Remember final parameters */
4668 MARK_FINAL_PARMS (meth, orig_arg);
4669
4670 /* Fix the method argument list so we have the argument name
4671 information */
4672 fix_method_argument_names (orig_arg, meth);
4673
4674 /* Register the parameter number and re-install the current line
4675 number */
4676 DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4677 input_line = saved_lineno;
4678
4679 /* Register exception specified by the `throws' keyword for
4680 resolution and set the method decl appropriate field to the list.
4681 Note: the grammar ensures that what we get here are class
4682 types. */
4683 if (throws)
4684 {
4685 throws = nreverse (throws);
4686 for (current = throws; current; current = TREE_CHAIN (current))
4687 {
4688 register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4689 NULL_TREE, NULL_TREE);
4690 JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4691 &TREE_VALUE (current);
4692 }
4693 DECL_FUNCTION_THROWS (meth) = throws;
4694 }
4695
4696 if (TREE_TYPE (GET_CPC ()) != object_type_node)
4697 DECL_FUNCTION_WFL (meth) = id;
4698
4699 /* Set the flag if we correctly processed a constructor */
4700 if (constructor_ok)
4701 {
4702 DECL_CONSTRUCTOR_P (meth) = 1;
4703 /* Compute and store the number of artificial parameters declared
4704 for this constructor */
4705 for (count = 0, current = TYPE_FIELDS (this_class); current;
4706 current = TREE_CHAIN (current))
4707 if (FIELD_LOCAL_ALIAS (current))
4708 count++;
4709 DECL_FUNCTION_NAP (meth) = count;
4710 }
4711
4712 /* Eventually set the @deprecated tag flag */
4713 CHECK_DEPRECATED (meth);
4714
4715 /* If doing xref, store column and line number information instead
4716 of the line number only. */
4717 if (flag_emit_xref)
4718 DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4719
4720 return meth;
4721 }
4722
4723 static void
4724 fix_method_argument_names (tree orig_arg, tree meth)
4725 {
4726 tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4727 if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4728 {
4729 TREE_PURPOSE (arg) = this_identifier_node;
4730 arg = TREE_CHAIN (arg);
4731 }
4732 while (orig_arg != end_params_node)
4733 {
4734 TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4735 orig_arg = TREE_CHAIN (orig_arg);
4736 arg = TREE_CHAIN (arg);
4737 }
4738 }
4739
4740 /* Complete the method declaration with METHOD_BODY. */
4741
4742 static void
4743 finish_method_declaration (tree method_body)
4744 {
4745 int flags;
4746
4747 if (!current_function_decl)
4748 return;
4749
4750 flags = get_access_flags_from_decl (current_function_decl);
4751
4752 /* 8.4.5 Method Body */
4753 if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4754 {
4755 tree name = DECL_NAME (current_function_decl);
4756 parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4757 "%s method `%s' can't have a body defined",
4758 (METHOD_NATIVE (current_function_decl) ?
4759 "Native" : "Abstract"),
4760 IDENTIFIER_POINTER (name));
4761 method_body = NULL_TREE;
4762 }
4763 else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4764 {
4765 tree name = DECL_NAME (current_function_decl);
4766 parse_error_context
4767 (DECL_FUNCTION_WFL (current_function_decl),
4768 "Non native and non abstract method `%s' must have a body defined",
4769 IDENTIFIER_POINTER (name));
4770 method_body = NULL_TREE;
4771 }
4772
4773 if (flag_emit_class_files && method_body
4774 && TREE_CODE (method_body) == NOP_EXPR
4775 && TREE_TYPE (current_function_decl)
4776 && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4777 method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4778
4779 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4780 maybe_absorb_scoping_blocks ();
4781 /* Exit function's body */
4782 exit_block ();
4783 /* Merge last line of the function with first line, directly in the
4784 function decl. It will be used to emit correct debug info. */
4785 if (!flag_emit_xref)
4786 DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4787
4788 /* Since function's argument's list are shared, reset the
4789 ARG_FINAL_P parameter that might have been set on some of this
4790 function parameters. */
4791 UNMARK_FINAL_PARMS (current_function_decl);
4792
4793 /* So we don't have an irrelevant function declaration context for
4794 the next static block we'll see. */
4795 current_function_decl = NULL_TREE;
4796 }
4797
4798 /* Build a an error message for constructor circularity errors. */
4799
4800 static char *
4801 constructor_circularity_msg (tree from, tree to)
4802 {
4803 static char string [4096];
4804 char *t = xstrdup (lang_printable_name (from, 0));
4805 sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4806 free (t);
4807 return string;
4808 }
4809
4810 /* Verify a circular call to METH. Return 1 if an error is found, 0
4811 otherwise. */
4812
4813 static GTY(()) tree vcc_list;
4814 static int
4815 verify_constructor_circularity (tree meth, tree current)
4816 {
4817 tree c;
4818
4819 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4820 {
4821 if (TREE_VALUE (c) == meth)
4822 {
4823 char *t;
4824 if (vcc_list)
4825 {
4826 tree liste;
4827 vcc_list = nreverse (vcc_list);
4828 for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4829 {
4830 parse_error_context
4831 (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4832 constructor_circularity_msg
4833 (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4834 java_error_count--;
4835 }
4836 }
4837 t = xstrdup (lang_printable_name (meth, 0));
4838 parse_error_context (TREE_PURPOSE (c),
4839 "%s: recursive invocation of constructor `%s'",
4840 constructor_circularity_msg (current, meth), t);
4841 free (t);
4842 vcc_list = NULL_TREE;
4843 return 1;
4844 }
4845 }
4846 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4847 {
4848 vcc_list = tree_cons (c, current, vcc_list);
4849 if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4850 return 1;
4851 vcc_list = TREE_CHAIN (vcc_list);
4852 }
4853 return 0;
4854 }
4855
4856 /* Check modifiers that can be declared but exclusively */
4857
4858 static void
4859 check_modifiers_consistency (int flags)
4860 {
4861 int acc_count = 0;
4862 tree cl = NULL_TREE;
4863
4864 THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4865 THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4866 THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4867 if (acc_count > 1)
4868 parse_error_context
4869 (cl, "Inconsistent member declaration. At most one of `public', `private', or `protected' may be specified");
4870
4871 acc_count = 0;
4872 cl = NULL_TREE;
4873 THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4874 THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4875 if (acc_count > 1)
4876 parse_error_context (cl,
4877 "Inconsistent member declaration. At most one of `final' or `volatile' may be specified");
4878 }
4879
4880 /* Check the methode header METH for abstract specifics features */
4881
4882 static void
4883 check_abstract_method_header (tree meth)
4884 {
4885 int flags = get_access_flags_from_decl (meth);
4886
4887 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4888 ACC_ABSTRACT, "abstract method",
4889 IDENTIFIER_POINTER (DECL_NAME (meth)));
4890 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4891 ACC_PUBLIC, "abstract method",
4892 IDENTIFIER_POINTER (DECL_NAME (meth)));
4893
4894 check_modifiers ("Illegal modifier `%s' for interface method",
4895 flags, INTERFACE_METHOD_MODIFIERS);
4896 }
4897
4898 /* Create a FUNCTION_TYPE node and start augmenting it with the
4899 declared function arguments. Arguments type that can't be resolved
4900 are left as they are, but the returned node is marked as containing
4901 incomplete types. */
4902
4903 static tree
4904 method_declarator (tree id, tree list)
4905 {
4906 tree arg_types = NULL_TREE, current, node;
4907 tree meth = make_node (FUNCTION_TYPE);
4908 jdep *jdep;
4909
4910 patch_stage = JDEP_NO_PATCH;
4911
4912 if (GET_CPC () == error_mark_node)
4913 return error_mark_node;
4914
4915 /* If we're dealing with an inner class constructor, we hide the
4916 this$<n> decl in the name field of its parameter declaration. We
4917 also might have to hide the outer context local alias
4918 initializers. Not done when the class is a toplevel class. */
4919 if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4920 && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4921 {
4922 tree aliases_list, type, thisn;
4923 /* First the aliases, linked to the regular parameters */
4924 aliases_list =
4925 build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4926 TREE_TYPE (GET_CPC ()),
4927 NULL_TREE, NULL);
4928 list = chainon (nreverse (aliases_list), list);
4929
4930 /* Then this$<n> */
4931 type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4932 thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4933 list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4934 list);
4935 }
4936
4937 for (current = list; current; current = TREE_CHAIN (current))
4938 {
4939 int must_chain = 0;
4940 tree wfl_name = TREE_PURPOSE (current);
4941 tree type = TREE_VALUE (current);
4942 tree name = EXPR_WFL_NODE (wfl_name);
4943 tree already, arg_node;
4944 tree type_wfl = NULL_TREE;
4945 tree real_type;
4946
4947 /* Obtain a suitable type for resolution, if necessary */
4948 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4949
4950 /* Process NAME, as it may specify extra dimension(s) for it */
4951 type = build_array_from_name (type, type_wfl, name, &name);
4952 EXPR_WFL_NODE (wfl_name) = name;
4953
4954 real_type = GET_REAL_TYPE (type);
4955 if (TREE_CODE (real_type) == RECORD_TYPE)
4956 {
4957 real_type = promote_type (real_type);
4958 if (TREE_CODE (type) == TREE_LIST)
4959 TREE_PURPOSE (type) = real_type;
4960 }
4961
4962 /* Check redefinition */
4963 for (already = arg_types; already; already = TREE_CHAIN (already))
4964 if (TREE_PURPOSE (already) == name)
4965 {
4966 parse_error_context
4967 (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4968 IDENTIFIER_POINTER (name),
4969 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4970 break;
4971 }
4972
4973 /* If we've an incomplete argument type, we know there is a location
4974 to patch when the type get resolved, later. */
4975 jdep = NULL;
4976 if (must_chain)
4977 {
4978 patch_stage = JDEP_METHOD;
4979 type = register_incomplete_type (patch_stage,
4980 type_wfl, wfl_name, type);
4981 jdep = CLASSD_LAST (ctxp->classd_list);
4982 JDEP_MISC (jdep) = id;
4983 }
4984
4985 /* The argument node: a name and a (possibly) incomplete type. */
4986 arg_node = build_tree_list (name, real_type);
4987 /* Remember arguments declared final. */
4988 ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4989
4990 if (jdep)
4991 JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4992 TREE_CHAIN (arg_node) = arg_types;
4993 arg_types = arg_node;
4994 }
4995 TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
4996 node = build_tree_list (id, meth);
4997 return node;
4998 }
4999
5000 static int
5001 unresolved_type_p (tree wfl, tree *returned)
5002
5003 {
5004 if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5005 {
5006 if (returned)
5007 {
5008 tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5009 if (decl && current_class && (decl == TYPE_NAME (current_class)))
5010 *returned = TREE_TYPE (decl);
5011 else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5012 *returned = TREE_TYPE (GET_CPC ());
5013 else
5014 *returned = NULL_TREE;
5015 }
5016 return 1;
5017 }
5018 if (returned)
5019 *returned = wfl;
5020 return 0;
5021 }
5022
5023 /* From NAME, build a qualified identifier node using the
5024 qualification from the current package definition. */
5025
5026 static tree
5027 parser_qualified_classname (tree name)
5028 {
5029 tree nested_class_name;
5030
5031 if ((nested_class_name = maybe_make_nested_class_name (name)))
5032 return nested_class_name;
5033
5034 if (ctxp->package)
5035 return merge_qualified_name (ctxp->package, name);
5036 else
5037 return name;
5038 }
5039
5040 /* Called once the type a interface extends is resolved. Returns 0 if
5041 everything is OK. */
5042
5043 static int
5044 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5045 {
5046 tree super_type = TREE_TYPE (super_decl);
5047
5048 /* Has to be an interface */
5049 if (!CLASS_INTERFACE (super_decl))
5050 {
5051 parse_error_context
5052 (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5053 (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5054 "Interface" : "Class"),
5055 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5056 (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5057 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5058 return 1;
5059 }
5060
5061 /* Check top-level interface access. Inner classes are subject to member
5062 access rules (6.6.1). */
5063 if (! INNER_CLASS_P (super_type)
5064 && check_pkg_class_access (DECL_NAME (super_decl),
5065 lookup_cl (this_decl), true))
5066 return 1;
5067
5068 SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5069 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5070 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5071 return 0;
5072 }
5073
5074 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5075 0 if everything is OK. */
5076
5077 static int
5078 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5079 {
5080 tree super_type = TREE_TYPE (super_decl);
5081
5082 /* SUPER should be a CLASS (neither an array nor an interface) */
5083 if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5084 {
5085 parse_error_context
5086 (wfl, "Class `%s' can't subclass %s `%s'",
5087 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5088 (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5089 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5090 return 1;
5091 }
5092
5093 if (CLASS_FINAL (TYPE_NAME (super_type)))
5094 {
5095 parse_error_context (wfl, "Can't subclass final classes: %s",
5096 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5097 return 1;
5098 }
5099
5100 /* Check top-level class scope. Inner classes are subject to member access
5101 rules (6.6.1). */
5102 if (! INNER_CLASS_P (super_type)
5103 && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
5104 return 1;
5105
5106 SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5107 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5108 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5109 return 0;
5110 }
5111
5112 /* Create a new dependency list and link it (in a LIFO manner) to the
5113 CTXP list of type dependency list. */
5114
5115 static void
5116 create_jdep_list (struct parser_ctxt *ctxp)
5117 {
5118 jdeplist *new = xmalloc (sizeof (jdeplist));
5119 new->first = new->last = NULL;
5120 new->next = ctxp->classd_list;
5121 ctxp->classd_list = new;
5122 }
5123
5124 static jdeplist *
5125 reverse_jdep_list (struct parser_ctxt *ctxp)
5126 {
5127 jdeplist *prev = NULL, *current, *next;
5128 for (current = ctxp->classd_list; current; current = next)
5129 {
5130 next = current->next;
5131 current->next = prev;
5132 prev = current;
5133 }
5134 return prev;
5135 }
5136
5137 /* Create a fake pointer based on the ID stored in
5138 TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5139 registered again. */
5140
5141 static tree
5142 obtain_incomplete_type (tree type_name)
5143 {
5144 tree ptr = NULL_TREE, name;
5145
5146 if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5147 name = EXPR_WFL_NODE (type_name);
5148 else if (INCOMPLETE_TYPE_P (type_name))
5149 name = TYPE_NAME (type_name);
5150 else
5151 abort ();
5152
5153 /* Workaround from build_pointer_type for incomplete types. */
5154 BUILD_PTR_FROM_NAME (ptr, name);
5155 TYPE_MODE (ptr) = ptr_mode;
5156 layout_type (ptr);
5157
5158 return ptr;
5159 }
5160
5161 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5162 non NULL instead of computing a new fake type based on WFL. The new
5163 dependency is inserted in the current type dependency list, in FIFO
5164 manner. */
5165
5166 static tree
5167 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5168 {
5169 jdep *new = xmalloc (sizeof (jdep));
5170
5171 if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5172 ptr = obtain_incomplete_type (wfl);
5173
5174 JDEP_KIND (new) = kind;
5175 JDEP_DECL (new) = decl;
5176 JDEP_TO_RESOLVE (new) = ptr;
5177 JDEP_WFL (new) = wfl;
5178 JDEP_CHAIN (new) = NULL;
5179 JDEP_MISC (new) = NULL_TREE;
5180 /* For some dependencies, set the enclosing class of the current
5181 class to be the enclosing context */
5182 if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS)
5183 && GET_ENCLOSING_CPC ())
5184 JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5185 else if (kind == JDEP_SUPER)
5186 JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5187 TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5188 else
5189 JDEP_ENCLOSING (new) = GET_CPC ();
5190 JDEP_GET_PATCH (new) = (tree *)NULL;
5191
5192 JDEP_INSERT (ctxp->classd_list, new);
5193
5194 return ptr;
5195 }
5196
5197 /* This checks for circular references with innerclasses. We start
5198 from SOURCE and should never reach TARGET. Extended/implemented
5199 types in SOURCE have their enclosing context checked not to reach
5200 TARGET. When the last enclosing context of SOURCE is reached, its
5201 extended/implemented types are also checked not to reach TARGET.
5202 In case of error, WFL of the offending type is returned; NULL_TREE
5203 otherwise. */
5204
5205 static tree
5206 check_inner_circular_reference (tree source, tree target)
5207 {
5208 tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5209 tree ctx, cl;
5210 int i;
5211
5212 if (!basetype_vec)
5213 return NULL_TREE;
5214
5215 for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5216 {
5217 tree su;
5218
5219 /* We can end up with a NULL_TREE or an incomplete type here if
5220 we encountered previous type resolution errors. It's safe to
5221 simply ignore these cases. */
5222 if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5223 continue;
5224 su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5225 if (INCOMPLETE_TYPE_P (su))
5226 continue;
5227
5228 if (inherits_from_p (su, target))
5229 return lookup_cl (TYPE_NAME (su));
5230
5231 for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5232 {
5233 /* An enclosing context shouldn't be TARGET */
5234 if (ctx == TYPE_NAME (target))
5235 return lookup_cl (TYPE_NAME (su));
5236
5237 /* When we reach the enclosing last context, start a check
5238 on it, with the same target */
5239 if (! DECL_CONTEXT (ctx) &&
5240 (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5241 return cl;
5242 }
5243 }
5244 return NULL_TREE;
5245 }
5246
5247 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5248 offending type if a circularity is detected. NULL_TREE is returned
5249 otherwise. TYPE can be an interface or a class. */
5250
5251 static tree
5252 check_circular_reference (tree type)
5253 {
5254 tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5255 int i;
5256
5257 if (!basetype_vec)
5258 return NULL_TREE;
5259
5260 if (! CLASS_INTERFACE (TYPE_NAME (type)))
5261 {
5262 if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5263 return lookup_cl (TYPE_NAME (type));
5264 return NULL_TREE;
5265 }
5266
5267 for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5268 {
5269 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5270 if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5271 && interface_of_p (type, BINFO_TYPE (vec_elt)))
5272 return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5273 }
5274 return NULL_TREE;
5275 }
5276
5277 void
5278 java_check_circular_reference (void)
5279 {
5280 tree current;
5281 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5282 {
5283 tree type = TREE_TYPE (current);
5284 tree cl;
5285
5286 cl = check_circular_reference (type);
5287 if (! cl)
5288 cl = check_inner_circular_reference (type, type);
5289 if (cl)
5290 parse_error_context (cl, "Cyclic class inheritance%s",
5291 (cyclic_inheritance_report ?
5292 cyclic_inheritance_report : ""));
5293 }
5294 }
5295
5296 /* Augment the parameter list PARM with parameters crafted to
5297 initialize outer context locals aliases. Through ARTIFICIAL, a
5298 count is kept of the number of crafted parameters. MODE governs
5299 what eventually gets created: something suitable for a function
5300 creation or a function invocation, either the constructor or
5301 finit$. */
5302
5303 static tree
5304 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5305 int *artificial)
5306 {
5307 tree field;
5308 tree additional_parms = NULL_TREE;
5309
5310 for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5311 if (FIELD_LOCAL_ALIAS (field))
5312 {
5313 const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5314 tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5315 tree mangled_id;
5316
5317 switch (mode)
5318 {
5319 case AIPL_FUNCTION_DECLARATION:
5320 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5321 &buffer [4]);
5322 purpose = build_wfl_node (mangled_id);
5323 if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5324 value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5325 else
5326 value = TREE_TYPE (field);
5327 break;
5328
5329 case AIPL_FUNCTION_CREATION:
5330 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5331 &buffer [4]);
5332 value = TREE_TYPE (field);
5333 break;
5334
5335 case AIPL_FUNCTION_FINIT_INVOCATION:
5336 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5337 &buffer [4]);
5338 /* Now, this is wrong. purpose should always be the NAME
5339 of something and value its matching value (decl, type,
5340 etc...) FIXME -- but there is a lot to fix. */
5341
5342 /* When invoked for this kind of operation, we already
5343 know whether a field is used or not. */
5344 purpose = TREE_TYPE (field);
5345 value = build_wfl_node (mangled_id);
5346 break;
5347
5348 case AIPL_FUNCTION_CTOR_INVOCATION:
5349 /* There are two case: the constructor invocation happens
5350 outside the local inner, in which case, locales from the outer
5351 context are directly used.
5352
5353 Otherwise, we fold to using the alias directly. */
5354 if (class_type == current_class)
5355 value = field;
5356 else
5357 {
5358 name = get_identifier (&buffer[4]);
5359 value = IDENTIFIER_LOCAL_VALUE (name);
5360 }
5361 break;
5362 }
5363 additional_parms = tree_cons (purpose, value, additional_parms);
5364 if (artificial)
5365 *artificial +=1;
5366 }
5367 if (additional_parms)
5368 {
5369 if (ANONYMOUS_CLASS_P (class_type)
5370 && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5371 additional_parms = nreverse (additional_parms);
5372 parm = chainon (additional_parms, parm);
5373 }
5374
5375 return parm;
5376 }
5377
5378 /* Craft a constructor for CLASS_DECL -- what we should do when none
5379 where found. ARGS is non NULL when a special signature must be
5380 enforced. This is the case for anonymous classes. */
5381
5382 static tree
5383 craft_constructor (tree class_decl, tree args)
5384 {
5385 tree class_type = TREE_TYPE (class_decl);
5386 tree parm = NULL_TREE;
5387 int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5388 ACC_PUBLIC : 0);
5389 int i = 0, artificial = 0;
5390 tree decl, ctor_name;
5391 char buffer [80];
5392
5393 /* The constructor name is <init> unless we're dealing with an
5394 anonymous class, in which case the name will be fixed after having
5395 be expanded. */
5396 if (ANONYMOUS_CLASS_P (class_type))
5397 ctor_name = DECL_NAME (class_decl);
5398 else
5399 ctor_name = init_identifier_node;
5400
5401 /* If we're dealing with an inner class constructor, we hide the
5402 this$<n> decl in the name field of its parameter declaration. */
5403 if (PURE_INNER_CLASS_TYPE_P (class_type))
5404 {
5405 tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5406 parm = tree_cons (build_current_thisn (class_type),
5407 build_pointer_type (type), parm);
5408
5409 /* Some more arguments to be hidden here. The values of the local
5410 variables of the outer context that the inner class needs to see. */
5411 parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5412 class_type, parm,
5413 &artificial);
5414 }
5415
5416 /* Then if there are any args to be enforced, enforce them now */
5417 for (; args && args != end_params_node; args = TREE_CHAIN (args))
5418 {
5419 sprintf (buffer, "parm%d", i++);
5420 parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5421 }
5422
5423 CRAFTED_PARAM_LIST_FIXUP (parm);
5424 decl = create_artificial_method (class_type, flags, void_type_node,
5425 ctor_name, parm);
5426 fix_method_argument_names (parm, decl);
5427 /* Now, mark the artificial parameters. */
5428 DECL_FUNCTION_NAP (decl) = artificial;
5429 DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5430 DECL_INLINE (decl) = 1;
5431 return decl;
5432 }
5433
5434
5435 /* Fix the constructors. This will be called right after circular
5436 references have been checked. It is necessary to fix constructors
5437 early even if no code generation will take place for that class:
5438 some generated constructor might be required by the class whose
5439 compilation triggered this one to be simply loaded. */
5440
5441 void
5442 java_fix_constructors (void)
5443 {
5444 tree current;
5445
5446 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5447 {
5448 tree class_type = TREE_TYPE (current);
5449 int saw_ctor = 0;
5450 tree decl;
5451
5452 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5453 continue;
5454
5455 output_class = current_class = class_type;
5456 for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5457 {
5458 if (DECL_CONSTRUCTOR_P (decl))
5459 {
5460 fix_constructors (decl);
5461 saw_ctor = 1;
5462 }
5463 }
5464
5465 /* Anonymous class constructor can't be generated that early. */
5466 if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5467 craft_constructor (current, NULL_TREE);
5468 }
5469 }
5470
5471 /* safe_layout_class just makes sure that we can load a class without
5472 disrupting the current_class, input_file, lineno, etc, information
5473 about the class processed currently. */
5474
5475 void
5476 safe_layout_class (tree class)
5477 {
5478 tree save_current_class = current_class;
5479 location_t save_location = input_location;
5480
5481 layout_class (class);
5482
5483 current_class = save_current_class;
5484 input_location = save_location;
5485 }
5486
5487 static tree
5488 jdep_resolve_class (jdep *dep)
5489 {
5490 tree decl;
5491
5492 if (JDEP_RESOLVED_P (dep))
5493 decl = JDEP_RESOLVED_DECL (dep);
5494 else
5495 {
5496 decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5497 JDEP_DECL (dep), JDEP_WFL (dep));
5498 JDEP_RESOLVED (dep, decl);
5499 /* If there is no WFL, that's ok. We generate this warning
5500 elsewhere. */
5501 if (decl && JDEP_WFL (dep) != NULL_TREE)
5502 check_deprecation (JDEP_WFL (dep), decl);
5503 }
5504
5505 if (!decl)
5506 complete_class_report_errors (dep);
5507 else if (PURE_INNER_CLASS_DECL_P (decl))
5508 {
5509 tree inner = TREE_TYPE (decl);
5510 if (! CLASS_LOADED_P (inner))
5511 {
5512 safe_layout_class (inner);
5513 if (TYPE_SIZE (inner) == error_mark_node)
5514 TYPE_SIZE (inner) = NULL_TREE;
5515 }
5516 check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5517 }
5518 return decl;
5519 }
5520
5521 /* Complete unsatisfied class declaration and their dependencies */
5522
5523 void
5524 java_complete_class (void)
5525 {
5526 tree cclass;
5527 jdeplist *cclassd;
5528 int error_found;
5529 tree type;
5530
5531 /* Process imports */
5532 process_imports ();
5533
5534 /* Reverse things so we have the right order */
5535 ctxp->class_list = nreverse (ctxp->class_list);
5536 ctxp->classd_list = reverse_jdep_list (ctxp);
5537
5538 for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5539 cclass && cclassd;
5540 cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5541 {
5542 jdep *dep;
5543
5544 /* We keep the compilation unit imports in the class so that
5545 they can be used later to resolve type dependencies that
5546 aren't necessary to solve now. */
5547 TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5548 TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5549
5550 for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5551 {
5552 tree decl;
5553 if (!(decl = jdep_resolve_class (dep)))
5554 continue;
5555
5556 /* Now it's time to patch */
5557 switch (JDEP_KIND (dep))
5558 {
5559 case JDEP_SUPER:
5560 /* Simply patch super */
5561 if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5562 continue;
5563 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5564 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5565 break;
5566
5567 case JDEP_FIELD:
5568 {
5569 /* We do part of the job done in add_field */
5570 tree field_decl = JDEP_DECL (dep);
5571 tree field_type = TREE_TYPE (decl);
5572 if (TREE_CODE (field_type) == RECORD_TYPE)
5573 field_type = promote_type (field_type);
5574 TREE_TYPE (field_decl) = field_type;
5575 DECL_ALIGN (field_decl) = 0;
5576 DECL_USER_ALIGN (field_decl) = 0;
5577 layout_decl (field_decl, 0);
5578 SOURCE_FRONTEND_DEBUG
5579 (("Completed field/var decl `%s' with `%s'",
5580 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5581 IDENTIFIER_POINTER (DECL_NAME (decl))));
5582 break;
5583 }
5584 case JDEP_METHOD: /* We start patching a method */
5585 case JDEP_METHOD_RETURN:
5586 error_found = 0;
5587 while (1)
5588 {
5589 if (decl)
5590 {
5591 type = TREE_TYPE(decl);
5592 if (TREE_CODE (type) == RECORD_TYPE)
5593 type = promote_type (type);
5594 JDEP_APPLY_PATCH (dep, type);
5595 SOURCE_FRONTEND_DEBUG
5596 (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5597 "Completing fct `%s' with ret type `%s'":
5598 "Completing arg `%s' with type `%s'"),
5599 IDENTIFIER_POINTER (EXPR_WFL_NODE
5600 (JDEP_DECL_WFL (dep))),
5601 IDENTIFIER_POINTER (DECL_NAME (decl))));
5602 }
5603 else
5604 error_found = 1;
5605 dep = JDEP_CHAIN (dep);
5606 if (JDEP_KIND (dep) == JDEP_METHOD_END)
5607 break;
5608 else
5609 decl = jdep_resolve_class (dep);
5610 }
5611 if (!error_found)
5612 {
5613 tree mdecl = JDEP_DECL (dep), signature;
5614 /* Recompute and reset the signature, check first that
5615 all types are now defined. If they're not,
5616 don't build the signature. */
5617 if (check_method_types_complete (mdecl))
5618 {
5619 signature = build_java_signature (TREE_TYPE (mdecl));
5620 set_java_signature (TREE_TYPE (mdecl), signature);
5621 }
5622 }
5623 else
5624 continue;
5625 break;
5626
5627 case JDEP_INTERFACE:
5628 if (parser_check_super_interface (decl, JDEP_DECL (dep),
5629 JDEP_WFL (dep)))
5630 continue;
5631 parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5632 break;
5633
5634 case JDEP_PARM:
5635 case JDEP_VARIABLE:
5636 type = TREE_TYPE(decl);
5637 if (TREE_CODE (type) == RECORD_TYPE)
5638 type = promote_type (type);
5639 JDEP_APPLY_PATCH (dep, type);
5640 break;
5641
5642 case JDEP_TYPE:
5643 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5644 SOURCE_FRONTEND_DEBUG
5645 (("Completing a random type dependency on a '%s' node",
5646 tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5647 break;
5648
5649 case JDEP_EXCEPTION:
5650 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5651 SOURCE_FRONTEND_DEBUG
5652 (("Completing `%s' `throws' argument node",
5653 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5654 break;
5655
5656 case JDEP_ANONYMOUS:
5657 patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5658 break;
5659
5660 default:
5661 abort ();
5662 }
5663 }
5664 }
5665 return;
5666 }
5667
5668 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5669 array. */
5670
5671 static tree
5672 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5673 {
5674 tree tname = TYPE_NAME (class_type);
5675 tree resolved_type = TREE_TYPE (class_type);
5676 int array_dims = 0;
5677 tree resolved_type_decl;
5678
5679 if (resolved_type != NULL_TREE)
5680 {
5681 tree resolved_type_decl = TYPE_NAME (resolved_type);
5682 if (resolved_type_decl == NULL_TREE
5683 || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5684 {
5685 resolved_type_decl = build_decl (TYPE_DECL,
5686 TYPE_NAME (class_type),
5687 resolved_type);
5688 }
5689 return resolved_type_decl;
5690 }
5691
5692 /* 1- Check to see if we have an array. If true, find what we really
5693 want to resolve */
5694 if ((array_dims = build_type_name_from_array_name (tname,
5695 &TYPE_NAME (class_type))))
5696 WFL_STRIP_BRACKET (cl, cl);
5697
5698 /* 2- Resolve the bare type */
5699 if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5700 decl, cl)))
5701 return NULL_TREE;
5702 resolved_type = TREE_TYPE (resolved_type_decl);
5703
5704 /* 3- If we have an array, reconstruct the array down to its nesting */
5705 if (array_dims)
5706 {
5707 for (; array_dims; array_dims--)
5708 resolved_type = build_java_array_type (resolved_type, -1);
5709 resolved_type_decl = TYPE_NAME (resolved_type);
5710 }
5711 TREE_TYPE (class_type) = resolved_type;
5712 return resolved_type_decl;
5713 }
5714
5715 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5716 are used to report error messages; CL must either be NULL_TREE or a
5717 WFL wrapping a class. Do not try to replace TYPE_NAME (class_type)
5718 by a variable, since it is changed by find_in_imports{_on_demand}
5719 and (but it doesn't really matter) qualify_and_find. */
5720
5721 tree
5722 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5723 {
5724 tree new_class_decl = NULL_TREE, super = NULL_TREE;
5725 tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5726 tree decl_result;
5727 htab_t circularity_hash;
5728
5729 if (QUALIFIED_P (TYPE_NAME (class_type)))
5730 {
5731 /* If the type name is of the form `Q . Id', then Q is either a
5732 package name or a class name. First we try to find Q as a
5733 class and then treat Id as a member type. If we can't find Q
5734 as a class then we fall through. */
5735 tree q, left, left_type, right;
5736 if (breakdown_qualified (&left, &right, TYPE_NAME (class_type)) == 0)
5737 {
5738 BUILD_PTR_FROM_NAME (left_type, left);
5739 q = do_resolve_class (enclosing, left_type, decl, cl);
5740 if (q)
5741 {
5742 enclosing = q;
5743 saved_enclosing_type = TREE_TYPE (q);
5744 BUILD_PTR_FROM_NAME (class_type, right);
5745 }
5746 }
5747 }
5748
5749 if (enclosing)
5750 {
5751 /* This hash table is used to register the classes we're going
5752 through when searching the current class as an inner class, in
5753 order to detect circular references. Remember to free it before
5754 returning the section 0- of this function. */
5755 circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5756 NULL);
5757
5758 /* 0- Search in the current class as an inner class.
5759 Maybe some code here should be added to load the class or
5760 something, at least if the class isn't an inner class and ended
5761 being loaded from class file. FIXME. */
5762 while (enclosing)
5763 {
5764 new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5765 &super, class_type);
5766 if (new_class_decl)
5767 break;
5768
5769 /* If we haven't found anything because SUPER reached Object and
5770 ENCLOSING happens to be an innerclass, try the enclosing context. */
5771 if ((!super || super == object_type_node) &&
5772 enclosing && INNER_CLASS_DECL_P (enclosing))
5773 enclosing = DECL_CONTEXT (enclosing);
5774 else
5775 enclosing = NULL_TREE;
5776 }
5777
5778 htab_delete (circularity_hash);
5779
5780 if (new_class_decl)
5781 return new_class_decl;
5782 }
5783
5784 /* 1- Check for the type in single imports. This will change
5785 TYPE_NAME() if something relevant is found */
5786 find_in_imports (saved_enclosing_type, class_type);
5787
5788 /* 2- And check for the type in the current compilation unit */
5789 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5790 {
5791 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5792 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5793 load_class (TYPE_NAME (class_type), 0);
5794 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5795 }
5796
5797 /* 3- Search according to the current package definition */
5798 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5799 {
5800 if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5801 TYPE_NAME (class_type))))
5802 return new_class_decl;
5803 }
5804
5805 /* 4- Check the import on demands. Don't allow bar.baz to be
5806 imported from foo.* */
5807 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5808 if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5809 return NULL_TREE;
5810
5811 /* If found in find_in_imports_on_demand, the type has already been
5812 loaded. */
5813 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5814 return new_class_decl;
5815
5816 /* 5- Try with a name qualified with the package name we've seen so far */
5817 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5818 {
5819 tree package;
5820
5821 /* If there is a current package (ctxp->package), it's the first
5822 element of package_list and we can skip it. */
5823 for (package = (ctxp->package ?
5824 TREE_CHAIN (package_list) : package_list);
5825 package; package = TREE_CHAIN (package))
5826 if ((new_class_decl = qualify_and_find (class_type,
5827 TREE_PURPOSE (package),
5828 TYPE_NAME (class_type))))
5829 return new_class_decl;
5830 }
5831
5832 /* 5- Check another compilation unit that bears the name of type */
5833 load_class (TYPE_NAME (class_type), 0);
5834
5835 if (!cl)
5836 cl = lookup_cl (decl);
5837
5838 /* If we don't have a value for CL, then we're being called recursively.
5839 We can't check package access just yet, but it will be taken care of
5840 by the caller. */
5841 if (cl)
5842 {
5843 if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
5844 return NULL_TREE;
5845 }
5846
5847 /* 6- Last call for a resolution */
5848 decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5849
5850 /* The final lookup might have registered a.b.c into a.b$c If we
5851 failed at the first lookup, progressively change the name if
5852 applicable and use the matching DECL instead. */
5853 if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5854 {
5855 char *separator;
5856 tree name = TYPE_NAME (class_type);
5857 char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5858
5859 strcpy (namebuffer, IDENTIFIER_POINTER (name));
5860
5861 do {
5862
5863 /* Reach the last '.', and if applicable, replace it by a `$' and
5864 see if this exists as a type. */
5865 if ((separator = strrchr (namebuffer, '.')))
5866 {
5867 *separator = '$';
5868 name = get_identifier (namebuffer);
5869 decl_result = IDENTIFIER_CLASS_VALUE (name);
5870 }
5871 } while (!decl_result && separator);
5872 }
5873 return decl_result;
5874 }
5875
5876 static tree
5877 qualify_and_find (tree class_type, tree package, tree name)
5878 {
5879 tree new_qualified = merge_qualified_name (package, name);
5880 tree new_class_decl;
5881
5882 if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5883 load_class (new_qualified, 0);
5884 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5885 {
5886 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5887 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5888 load_class (new_qualified, 0);
5889 TYPE_NAME (class_type) = new_qualified;
5890 return IDENTIFIER_CLASS_VALUE (new_qualified);
5891 }
5892 return NULL_TREE;
5893 }
5894
5895 /* Resolve NAME and lay it out (if not done and if not the current
5896 parsed class). Return a decl node. This function is meant to be
5897 called when type resolution is necessary during the walk pass. */
5898
5899 static tree
5900 resolve_and_layout (tree something, tree cl)
5901 {
5902 tree decl, decl_type;
5903
5904 /* Don't do that on the current class */
5905 if (something == current_class)
5906 return TYPE_NAME (current_class);
5907
5908 /* Don't do anything for void and other primitive types */
5909 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5910 return NULL_TREE;
5911
5912 /* Pointer types can be reall pointer types or fake pointers. When
5913 finding a real pointer, recheck for primitive types */
5914 if (TREE_CODE (something) == POINTER_TYPE)
5915 {
5916 if (TREE_TYPE (something))
5917 {
5918 something = TREE_TYPE (something);
5919 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5920 return NULL_TREE;
5921 }
5922 else
5923 something = TYPE_NAME (something);
5924 }
5925
5926 /* Don't do anything for arrays of primitive types */
5927 if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5928 && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5929 return NULL_TREE;
5930
5931 /* Something might be a WFL */
5932 if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5933 something = EXPR_WFL_NODE (something);
5934
5935 /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5936 TYPE_DECL or a real TYPE */
5937 else if (TREE_CODE (something) != IDENTIFIER_NODE)
5938 something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5939 DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5940
5941 if (!(decl = resolve_no_layout (something, cl)))
5942 return NULL_TREE;
5943
5944 /* Resolve and layout if necessary */
5945 decl_type = TREE_TYPE (decl);
5946 layout_class_methods (decl_type);
5947 /* Check methods */
5948 if (CLASS_FROM_SOURCE_P (decl_type))
5949 java_check_methods (decl);
5950 /* Layout the type if necessary */
5951 if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5952 safe_layout_class (decl_type);
5953
5954 return decl;
5955 }
5956
5957 /* Resolve a class, returns its decl but doesn't perform any
5958 layout. The current parsing context is saved and restored */
5959
5960 static tree
5961 resolve_no_layout (tree name, tree cl)
5962 {
5963 tree ptr, decl;
5964 BUILD_PTR_FROM_NAME (ptr, name);
5965 java_parser_context_save_global ();
5966 decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5967 java_parser_context_restore_global ();
5968
5969 return decl;
5970 }
5971
5972 /* Called when reporting errors. Skip the '[]'s in a complex array
5973 type description that failed to be resolved. purify_type_name can't
5974 use an identifier tree. */
5975
5976 static const char *
5977 purify_type_name (const char *name)
5978 {
5979 int len = strlen (name);
5980 int bracket_found;
5981
5982 STRING_STRIP_BRACKETS (name, len, bracket_found);
5983 if (bracket_found)
5984 {
5985 char *stripped_name = xmemdup (name, len, len+1);
5986 stripped_name [len] = '\0';
5987 return stripped_name;
5988 }
5989 return name;
5990 }
5991
5992 /* The type CURRENT refers to can't be found. We print error messages. */
5993
5994 static void
5995 complete_class_report_errors (jdep *dep)
5996 {
5997 const char *name;
5998
5999 if (!JDEP_WFL (dep))
6000 return;
6001
6002 name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6003 switch (JDEP_KIND (dep))
6004 {
6005 case JDEP_SUPER:
6006 parse_error_context
6007 (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6008 purify_type_name (name),
6009 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6010 break;
6011 case JDEP_FIELD:
6012 parse_error_context
6013 (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6014 purify_type_name (name),
6015 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6016 break;
6017 case JDEP_METHOD: /* Covers arguments */
6018 parse_error_context
6019 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6020 purify_type_name (name),
6021 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6022 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6023 break;
6024 case JDEP_METHOD_RETURN: /* Covers return type */
6025 parse_error_context
6026 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6027 purify_type_name (name),
6028 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6029 break;
6030 case JDEP_INTERFACE:
6031 parse_error_context
6032 (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6033 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6034 (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6035 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6036 break;
6037 case JDEP_VARIABLE:
6038 parse_error_context
6039 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6040 purify_type_name (IDENTIFIER_POINTER
6041 (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6042 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6043 break;
6044 case JDEP_EXCEPTION: /* As specified by `throws' */
6045 parse_error_context
6046 (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6047 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6048 break;
6049 default:
6050 /* Fix for -Wall. Just break doing nothing. The error will be
6051 caught later */
6052 break;
6053 }
6054 }
6055
6056 /* Return a static string containing the DECL prototype string. If
6057 DECL is a constructor, use the class name instead of the form
6058 <init> */
6059
6060 static const char *
6061 get_printable_method_name (tree decl)
6062 {
6063 const char *to_return;
6064 tree name = NULL_TREE;
6065
6066 if (DECL_CONSTRUCTOR_P (decl))
6067 {
6068 name = DECL_NAME (decl);
6069 DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6070 }
6071
6072 to_return = lang_printable_name (decl, 0);
6073 if (DECL_CONSTRUCTOR_P (decl))
6074 DECL_NAME (decl) = name;
6075
6076 return to_return;
6077 }
6078
6079 /* Track method being redefined inside the same class. As a side
6080 effect, set DECL_NAME to an IDENTIFIER (prior entering this
6081 function it's a FWL, so we can track errors more accurately.) */
6082
6083 static int
6084 check_method_redefinition (tree class, tree method)
6085 {
6086 tree redef, sig;
6087
6088 /* There's no need to verify <clinit> and finit$ and instinit$ */
6089 if (DECL_CLINIT_P (method)
6090 || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6091 return 0;
6092
6093 sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6094 for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6095 {
6096 if (redef == method)
6097 break;
6098 if (DECL_NAME (redef) == DECL_NAME (method)
6099 && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6100 && !DECL_ARTIFICIAL (method))
6101 {
6102 parse_error_context
6103 (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6104 (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6105 get_printable_method_name (redef));
6106 return 1;
6107 }
6108 }
6109 return 0;
6110 }
6111
6112 /* Return 1 if check went ok, 0 otherwise. */
6113 static int
6114 check_abstract_method_definitions (int do_interface, tree class_decl,
6115 tree type)
6116 {
6117 tree class = TREE_TYPE (class_decl);
6118 tree method, end_type;
6119 int ok = 1;
6120
6121 end_type = (do_interface ? object_type_node : type);
6122 for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6123 {
6124 tree other_super, other_method, method_sig, method_name;
6125 int found = 0;
6126 int end_type_reached = 0;
6127
6128 if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6129 continue;
6130
6131 /* Now verify that somewhere in between TYPE and CLASS,
6132 abstract method METHOD gets a non abstract definition
6133 that is inherited by CLASS. */
6134
6135 method_sig = build_java_signature (TREE_TYPE (method));
6136 method_name = DECL_NAME (method);
6137 if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6138 method_name = EXPR_WFL_NODE (method_name);
6139
6140 other_super = class;
6141 do {
6142 if (other_super == end_type)
6143 end_type_reached = 1;
6144
6145 /* Method search */
6146 for (other_method = TYPE_METHODS (other_super); other_method;
6147 other_method = TREE_CHAIN (other_method))
6148 {
6149 tree s = build_java_signature (TREE_TYPE (other_method));
6150 tree other_name = DECL_NAME (other_method);
6151
6152 if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6153 other_name = EXPR_WFL_NODE (other_name);
6154 if (!DECL_CLINIT_P (other_method)
6155 && !DECL_CONSTRUCTOR_P (other_method)
6156 && method_name == other_name
6157 && method_sig == s
6158 && !METHOD_ABSTRACT (other_method))
6159 {
6160 found = 1;
6161 break;
6162 }
6163 }
6164 other_super = CLASSTYPE_SUPER (other_super);
6165 } while (!end_type_reached);
6166
6167 /* Report that abstract METHOD didn't find an implementation
6168 that CLASS can use. */
6169 if (!found)
6170 {
6171 char *t = xstrdup (lang_printable_name
6172 (TREE_TYPE (TREE_TYPE (method)), 0));
6173 tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6174
6175 parse_error_context
6176 (lookup_cl (class_decl),
6177 "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",
6178 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6179 t, lang_printable_name (method, 0),
6180 (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6181 "interface" : "class"),
6182 IDENTIFIER_POINTER (ccn),
6183 (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6184 IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6185 ok = 0;
6186 free (t);
6187 }
6188 }
6189
6190 if (ok && do_interface)
6191 {
6192 /* Check for implemented interfaces. */
6193 int i;
6194 tree vector = TYPE_BINFO_BASETYPES (type);
6195 for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6196 {
6197 tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6198 ok = check_abstract_method_definitions (1, class_decl, super);
6199 }
6200 }
6201
6202 return ok;
6203 }
6204
6205 /* Check that CLASS_DECL somehow implements all inherited abstract
6206 methods. */
6207
6208 static void
6209 java_check_abstract_method_definitions (tree class_decl)
6210 {
6211 tree class = TREE_TYPE (class_decl);
6212 tree super, vector;
6213 int i;
6214
6215 if (CLASS_ABSTRACT (class_decl))
6216 return;
6217
6218 /* Check for inherited types */
6219 super = class;
6220 do {
6221 super = CLASSTYPE_SUPER (super);
6222 check_abstract_method_definitions (0, class_decl, super);
6223 } while (super != object_type_node);
6224
6225 /* Check for implemented interfaces. */
6226 vector = TYPE_BINFO_BASETYPES (class);
6227 for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6228 {
6229 super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6230 check_abstract_method_definitions (1, class_decl, super);
6231 }
6232 }
6233
6234 /* Check all the types method DECL uses and return 1 if all of them
6235 are now complete, 0 otherwise. This is used to check whether its
6236 safe to build a method signature or not. */
6237
6238 static int
6239 check_method_types_complete (tree decl)
6240 {
6241 tree type = TREE_TYPE (decl);
6242 tree args;
6243
6244 if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6245 return 0;
6246
6247 args = TYPE_ARG_TYPES (type);
6248 if (TREE_CODE (type) == METHOD_TYPE)
6249 args = TREE_CHAIN (args);
6250 for (; args != end_params_node; args = TREE_CHAIN (args))
6251 if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6252 return 0;
6253
6254 return 1;
6255 }
6256
6257 /* Visible interface to check methods contained in CLASS_DECL */
6258
6259 void
6260 java_check_methods (tree class_decl)
6261 {
6262 if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6263 return;
6264
6265 if (CLASS_INTERFACE (class_decl))
6266 java_check_abstract_methods (class_decl);
6267 else
6268 java_check_regular_methods (class_decl);
6269
6270 CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6271 }
6272
6273 /* Like not_accessible_p, but doesn't refer to the current class at
6274 all. */
6275 static bool
6276 hack_is_accessible_p (tree member, tree from_where)
6277 {
6278 int flags = get_access_flags_from_decl (member);
6279
6280 if (from_where == DECL_CONTEXT (member)
6281 || (flags & ACC_PUBLIC))
6282 return true;
6283
6284 if ((flags & ACC_PROTECTED))
6285 {
6286 if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6287 return true;
6288 }
6289
6290 if ((flags & ACC_PRIVATE))
6291 return false;
6292
6293 /* Package private, or protected. */
6294 return in_same_package (TYPE_NAME (from_where),
6295 TYPE_NAME (DECL_CONTEXT (member)));
6296 }
6297
6298 /* Check all the methods of CLASS_DECL. Methods are first completed
6299 then checked according to regular method existence rules. If no
6300 constructor for CLASS_DECL were encountered, then build its
6301 declaration. */
6302 static void
6303 java_check_regular_methods (tree class_decl)
6304 {
6305 int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6306 tree method;
6307 tree class = TREE_TYPE (class_decl);
6308 tree found = NULL_TREE;
6309 tree mthrows;
6310
6311 /* It is not necessary to check methods defined in java.lang.Object */
6312 if (class == object_type_node)
6313 return;
6314
6315 if (!TYPE_NVIRTUALS (class))
6316 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6317
6318 /* Should take interfaces into account. FIXME */
6319 for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6320 {
6321 tree sig;
6322 tree method_wfl = DECL_FUNCTION_WFL (method);
6323 int aflags;
6324
6325 /* Check for redefinitions */
6326 if (check_method_redefinition (class, method))
6327 continue;
6328
6329 /* We verify things thrown by the method. They must inherit from
6330 java.lang.Throwable. */
6331 for (mthrows = DECL_FUNCTION_THROWS (method);
6332 mthrows; mthrows = TREE_CHAIN (mthrows))
6333 {
6334 if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6335 parse_error_context
6336 (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6337 IDENTIFIER_POINTER
6338 (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6339 }
6340
6341 /* If we see one constructor a mark so we don't generate the
6342 default one. Also skip other verifications: constructors
6343 can't be inherited hence hidden or overridden. */
6344 if (DECL_CONSTRUCTOR_P (method))
6345 {
6346 saw_constructor = 1;
6347 continue;
6348 }
6349
6350 sig = build_java_argument_signature (TREE_TYPE (method));
6351 found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6352 SEARCH_SUPER | SEARCH_INTERFACE);
6353
6354 /* Inner class can't declare static methods */
6355 if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6356 {
6357 char *t = xstrdup (lang_printable_name (class, 0));
6358 parse_error_context
6359 (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6360 lang_printable_name (method, 0), t);
6361 free (t);
6362 }
6363
6364 /* Nothing overrides or it's a private method. */
6365 if (!found)
6366 continue;
6367 if (METHOD_PRIVATE (found))
6368 {
6369 found = NULL_TREE;
6370 continue;
6371 }
6372
6373 /* If `found' is declared in an interface, make sure the
6374 modifier matches. */
6375 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6376 && clinit_identifier_node != DECL_NAME (found)
6377 && !METHOD_PUBLIC (method))
6378 {
6379 tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6380 parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6381 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6382 lang_printable_name (method, 0),
6383 IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6384 }
6385
6386 /* Can't override a method with the same name and different return
6387 types. */
6388 if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6389 {
6390 char *t = xstrdup
6391 (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6392 parse_error_context
6393 (method_wfl,
6394 "Method `%s' was defined with return type `%s' in class `%s'",
6395 lang_printable_name (found, 0), t,
6396 IDENTIFIER_POINTER
6397 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6398 free (t);
6399 }
6400
6401 aflags = get_access_flags_from_decl (found);
6402
6403 /* Can't override final. Can't override static. */
6404 if (METHOD_FINAL (found) || METHOD_STATIC (found))
6405 {
6406 /* Static *can* override static */
6407 if (METHOD_STATIC (found) && METHOD_STATIC (method))
6408 continue;
6409 parse_error_context
6410 (method_wfl,
6411 "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6412 (METHOD_FINAL (found) ? "Final" : "Static"),
6413 lang_printable_name (found, 0),
6414 (METHOD_FINAL (found) ? "final" : "static"),
6415 IDENTIFIER_POINTER
6416 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6417 continue;
6418 }
6419
6420 /* Static method can't override instance method. */
6421 if (METHOD_STATIC (method))
6422 {
6423 parse_error_context
6424 (method_wfl,
6425 "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6426 lang_printable_name (found, 0),
6427 IDENTIFIER_POINTER
6428 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6429 continue;
6430 }
6431
6432 /* - Overriding/hiding public must be public
6433 - Overriding/hiding protected must be protected or public
6434 - If the overridden or hidden method has default (package)
6435 access, then the overriding or hiding method must not be
6436 private; otherwise, a compile-time error occurs. If
6437 `found' belongs to an interface, things have been already
6438 taken care of. */
6439 if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6440 && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6441 || (METHOD_PROTECTED (found)
6442 && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6443 || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6444 && METHOD_PRIVATE (method))))
6445 {
6446 parse_error_context
6447 (method_wfl,
6448 "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6449 (METHOD_PUBLIC (method) ? "public" :
6450 (METHOD_PRIVATE (method) ? "private" : "protected")),
6451 IDENTIFIER_POINTER (DECL_NAME
6452 (TYPE_NAME (DECL_CONTEXT (found)))));
6453 continue;
6454 }
6455
6456 /* Check this method against all the other implementations it
6457 overrides. Here we only check the class hierarchy; the rest
6458 of the checking is done later. If this method is just a
6459 Miranda method, we can skip the check. */
6460 if (! METHOD_INVISIBLE (method))
6461 check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6462 }
6463
6464 /* The above throws clause check only looked at superclasses. Now
6465 we must also make sure that all methods declared in interfaces
6466 have compatible throws clauses. FIXME: there are more efficient
6467 ways to organize this checking; we should implement one. */
6468 check_interface_throws_clauses (class, class);
6469
6470 if (!TYPE_NVIRTUALS (class))
6471 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6472
6473 /* Search for inherited abstract method not yet implemented in this
6474 class. */
6475 java_check_abstract_method_definitions (class_decl);
6476
6477 if (!saw_constructor)
6478 abort ();
6479 }
6480
6481 /* Check to make sure that all the methods in all the interfaces
6482 implemented by CLASS_DECL are compatible with the concrete
6483 implementations available in CHECK_CLASS_DECL. */
6484 static void
6485 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6486 {
6487 for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6488 {
6489 tree bases;
6490 int iface_len;
6491 int i;
6492
6493 if (! CLASS_LOADED_P (class_decl))
6494 {
6495 if (CLASS_FROM_SOURCE_P (class_decl))
6496 safe_layout_class (class_decl);
6497 else
6498 load_class (class_decl, 1);
6499 }
6500
6501 bases = TYPE_BINFO_BASETYPES (class_decl);
6502 iface_len = TREE_VEC_LENGTH (bases) - 1;
6503 for (i = iface_len; i > 0; --i)
6504 {
6505 tree interface = BINFO_TYPE (TREE_VEC_ELT (bases, i));
6506 tree iface_method;
6507
6508 for (iface_method = TYPE_METHODS (interface);
6509 iface_method != NULL_TREE;
6510 iface_method = TREE_CHAIN (iface_method))
6511 {
6512 tree sig, method;
6513
6514 /* First look for a concrete method implemented or
6515 inherited by this class. No need to search
6516 interfaces here, since we're already looking through
6517 all of them. */
6518 sig = build_java_argument_signature (TREE_TYPE (iface_method));
6519 method
6520 = lookup_argument_method_generic (check_class_decl,
6521 DECL_NAME (iface_method),
6522 sig, SEARCH_VISIBLE);
6523 /* If we don't find an implementation, that is ok. Any
6524 potential errors from that are diagnosed elsewhere.
6525 Also, multiple inheritance with conflicting throws
6526 clauses is fine in the absence of a concrete
6527 implementation. */
6528 if (method != NULL_TREE && !METHOD_ABSTRACT (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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 (targetm.calls.promote_prototypes (type)
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
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
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 \f
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
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
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
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
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
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
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
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
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 \f
8494 /* This section deals with building access function necessary for
8495 certain kinds of method invocation from inner classes. */
8496
8497 static tree
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 \f
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
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
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
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
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 \f
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 {
9873 parse_error_context
9874 (qual_wfl, "Can't access %s class '%s' from '%s'",
9875 java_accstring_lookup (get_access_flags_from_decl (decl)),
9876 IDENTIFIER_POINTER (DECL_NAME (decl)),
9877 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
9878 return 1;
9879 }
9880 check_deprecation (qual_wfl, decl);
9881
9882 type = TREE_TYPE (decl);
9883 from_type = 1;
9884 }
9885 /* We resolve an expression name */
9886 else
9887 {
9888 tree field_decl = NULL_TREE;
9889
9890 /* If there exists an early resolution, use it. That occurs
9891 only once and we know that there are more things to
9892 come. Don't do that when processing something after SUPER
9893 (we need more thing to be put in place below */
9894 if (!from_super && QUAL_RESOLUTION (q))
9895 {
9896 decl = QUAL_RESOLUTION (q);
9897 if (!type)
9898 {
9899 if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9900 {
9901 if (current_this)
9902 *where_found = current_this;
9903 else
9904 {
9905 static_ref_err (qual_wfl, DECL_NAME (decl),
9906 current_class);
9907 return 1;
9908 }
9909 if (outer_field_access_p (current_class, decl))
9910 decl = build_outer_field_access (qual_wfl, decl);
9911 }
9912 else
9913 {
9914 *where_found = TREE_TYPE (decl);
9915 if (TREE_CODE (*where_found) == POINTER_TYPE)
9916 *where_found = TREE_TYPE (*where_found);
9917 }
9918 }
9919 }
9920
9921 /* Report and error if we're using a numerical literal as a
9922 qualifier. It can only be an INTEGER_CST. */
9923 else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9924 {
9925 parse_error_context
9926 (wfl, "Can't use type `%s' as a qualifier",
9927 lang_printable_name (TREE_TYPE (qual_wfl), 0));
9928 return 1;
9929 }
9930
9931 /* We have to search for a field, knowing the type of its
9932 container. The flag FROM_TYPE indicates that we resolved
9933 the last member of the expression as a type name, which
9934 means that for the resolution of this field, we'll look
9935 for other errors than if it was resolved as a member of
9936 an other field. */
9937 else
9938 {
9939 int is_static;
9940 tree field_decl_type; /* For layout */
9941
9942 if (!from_type && !JREFERENCE_TYPE_P (type))
9943 {
9944 parse_error_context
9945 (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9946 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9947 lang_printable_name (type, 0),
9948 IDENTIFIER_POINTER (DECL_NAME (decl)));
9949 return 1;
9950 }
9951
9952 field_decl = lookup_field_wrapper (type,
9953 EXPR_WFL_NODE (qual_wfl));
9954
9955 /* Maybe what we're trying to access to is an inner
9956 class, only if decl is a TYPE_DECL. */
9957 if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9958 {
9959 tree ptr, inner_decl;
9960
9961 BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9962 inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9963 if (inner_decl)
9964 {
9965 check_inner_class_access (inner_decl, decl, qual_wfl);
9966 type = TREE_TYPE (inner_decl);
9967 decl = inner_decl;
9968 from_type = 1;
9969 continue;
9970 }
9971 }
9972
9973 if (field_decl == NULL_TREE)
9974 {
9975 parse_error_context
9976 (qual_wfl, "No variable `%s' defined in type `%s'",
9977 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9978 GET_TYPE_NAME (type));
9979 return 1;
9980 }
9981 if (field_decl == error_mark_node)
9982 return 1;
9983
9984 /* Layout the type of field_decl, since we may need
9985 it. Don't do primitive types or loaded classes. The
9986 situation of non primitive arrays may not handled
9987 properly here. FIXME */
9988 if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9989 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9990 else
9991 field_decl_type = TREE_TYPE (field_decl);
9992 if (!JPRIMITIVE_TYPE_P (field_decl_type)
9993 && !CLASS_LOADED_P (field_decl_type)
9994 && !TYPE_ARRAY_P (field_decl_type))
9995 resolve_and_layout (field_decl_type, NULL_TREE);
9996
9997 /* Check on accessibility here */
9998 if (not_accessible_p (current_class, field_decl,
9999 DECL_CONTEXT (field_decl), from_super))
10000 return not_accessible_field_error (qual_wfl,field_decl);
10001 check_deprecation (qual_wfl, field_decl);
10002
10003 /* There are things to check when fields are accessed
10004 from type. There are no restrictions on a static
10005 declaration of the field when it is accessed from an
10006 interface */
10007 is_static = FIELD_STATIC (field_decl);
10008 if (!from_super && from_type
10009 && !TYPE_INTERFACE_P (type)
10010 && !is_static
10011 && (current_function_decl
10012 && METHOD_STATIC (current_function_decl)))
10013 {
10014 static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
10015 return 1;
10016 }
10017 from_cast = from_super = 0;
10018
10019 /* It's an access from a type but it isn't static, we
10020 make it relative to `this'. */
10021 if (!is_static && from_type)
10022 decl = current_this;
10023
10024 /* If we need to generate something to get a proper
10025 handle on what this field is accessed from, do it
10026 now. */
10027 if (!is_static)
10028 {
10029 decl = maybe_access_field (decl, *where_found, *type_found);
10030 if (decl == error_mark_node)
10031 return 1;
10032 }
10033
10034 /* We want to keep the location were found it, and the type
10035 we found. */
10036 *where_found = decl;
10037 *type_found = type;
10038
10039 /* Generate the correct expression for field access from
10040 qualified this */
10041 if (from_qualified_this)
10042 {
10043 field_decl = build_outer_field_access (qual_wfl, field_decl);
10044 from_qualified_this = 0;
10045 }
10046
10047 /* This is the decl found and eventually the next one to
10048 search from */
10049 decl = field_decl;
10050 }
10051 from_type = 0;
10052 type = QUAL_DECL_TYPE (decl);
10053
10054 /* Sneak preview. If decl is qualified by a `new', report
10055 the error here to be accurate on the peculiar construct */
10056 if (TREE_CHAIN (q)
10057 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10058 && !JREFERENCE_TYPE_P (type))
10059 {
10060 parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10061 lang_printable_name (type, 0));
10062 return 1;
10063 }
10064 }
10065 /* `q' might have changed due to a after package resolution
10066 re-qualification */
10067 if (!q)
10068 break;
10069 }
10070 *found_decl = decl;
10071 return 0;
10072 }
10073
10074 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10075 can't be accessed from REFERENCE (a record type). If MEMBER
10076 features a protected access, we then use WHERE which, if non null,
10077 holds the type of MEMBER's access that is checked against
10078 6.6.2.1. This function should be used when decl is a field or a
10079 method. */
10080
10081 static int
10082 not_accessible_p (tree reference, tree member, tree where, int from_super)
10083 {
10084 int access_flag = get_access_flags_from_decl (member);
10085
10086 /* Inner classes are processed by check_inner_class_access */
10087 if (INNER_CLASS_TYPE_P (reference))
10088 return 0;
10089
10090 /* Access always granted for members declared public */
10091 if (access_flag & ACC_PUBLIC)
10092 return 0;
10093
10094 /* Check access on protected members */
10095 if (access_flag & ACC_PROTECTED)
10096 {
10097 /* Access granted if it occurs from within the package
10098 containing the class in which the protected member is
10099 declared */
10100 if (class_in_current_package (DECL_CONTEXT (member)))
10101 return 0;
10102
10103 /* If accessed with the form `super.member', then access is granted */
10104 if (from_super)
10105 return 0;
10106
10107 /* If where is active, access was made through a
10108 qualifier. Access is granted if the type of the qualifier is
10109 or is a sublass of the type the access made from (6.6.2.1.) */
10110 if (where && !inherits_from_p (reference, where))
10111 return 1;
10112
10113 /* Otherwise, access is granted if occurring from the class where
10114 member is declared or a subclass of it. Find the right
10115 context to perform the check */
10116 if (PURE_INNER_CLASS_TYPE_P (reference))
10117 {
10118 while (INNER_CLASS_TYPE_P (reference))
10119 {
10120 if (inherits_from_p (reference, DECL_CONTEXT (member)))
10121 return 0;
10122 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10123 }
10124 }
10125 if (inherits_from_p (reference, DECL_CONTEXT (member)))
10126 return 0;
10127 return 1;
10128 }
10129
10130 /* Check access on private members. Access is granted only if it
10131 occurs from within the class in which it is declared -- that does
10132 it for innerclasses too. */
10133 if (access_flag & ACC_PRIVATE)
10134 {
10135 if (reference == DECL_CONTEXT (member))
10136 return 0;
10137 if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10138 return 0;
10139 return 1;
10140 }
10141
10142 /* Default access are permitted only when occurring within the
10143 package in which the type (REFERENCE) is declared. In other words,
10144 REFERENCE is defined in the current package */
10145 if (ctxp->package)
10146 return !class_in_current_package (reference);
10147
10148 /* Otherwise, access is granted */
10149 return 0;
10150 }
10151
10152 /* Test deprecated decl access. */
10153 static void
10154 check_deprecation (tree wfl, tree decl)
10155 {
10156 const char *file;
10157 tree elt;
10158
10159 if (! flag_deprecated)
10160 return;
10161
10162 /* We want to look at the element type of arrays here, so we strip
10163 all surrounding array types. */
10164 if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10165 {
10166 elt = TREE_TYPE (decl);
10167 while (TYPE_ARRAY_P (elt))
10168 elt = TYPE_ARRAY_ELEMENT (elt);
10169 /* We'll end up with a pointer type, so we use TREE_TYPE to go
10170 to the record. */
10171 decl = TYPE_NAME (TREE_TYPE (elt));
10172 }
10173 file = DECL_SOURCE_FILE (decl);
10174
10175 /* Complain if the field is deprecated and the file it was defined
10176 in isn't compiled at the same time the file which contains its
10177 use is */
10178 if (DECL_DEPRECATED (decl)
10179 && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10180 {
10181 const char *the;
10182 switch (TREE_CODE (decl))
10183 {
10184 case FUNCTION_DECL:
10185 the = "method";
10186 break;
10187 case FIELD_DECL:
10188 case VAR_DECL:
10189 the = "field";
10190 break;
10191 case TYPE_DECL:
10192 parse_warning_context (wfl, "The class `%s' has been deprecated",
10193 IDENTIFIER_POINTER (DECL_NAME (decl)));
10194 return;
10195 default:
10196 abort ();
10197 }
10198 /* Don't issue a message if the context as been deprecated as a
10199 whole. */
10200 if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10201 parse_warning_context
10202 (wfl, "The %s `%s' in class `%s' has been deprecated",
10203 the, lang_printable_name (decl, 0),
10204 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10205 }
10206 }
10207
10208 /* Returns 1 if class was declared in the current package, 0 otherwise */
10209
10210 static GTY(()) tree cicp_cache;
10211 static int
10212 class_in_current_package (tree class)
10213 {
10214 int qualified_flag;
10215 tree left;
10216
10217 if (cicp_cache == class)
10218 return 1;
10219
10220 qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10221
10222 /* If the current package is empty and the name of CLASS is
10223 qualified, class isn't in the current package. If there is a
10224 current package and the name of the CLASS is not qualified, class
10225 isn't in the current package */
10226 if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10227 return 0;
10228
10229 /* If there is not package and the name of CLASS isn't qualified,
10230 they belong to the same unnamed package */
10231 if (!ctxp->package && !qualified_flag)
10232 return 1;
10233
10234 /* Compare the left part of the name of CLASS with the package name */
10235 breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10236 if (ctxp->package == left)
10237 {
10238 cicp_cache = class;
10239 return 1;
10240 }
10241 return 0;
10242 }
10243
10244 /* This function may generate code to access DECL from WHERE. This is
10245 done only if certain conditions meet. */
10246
10247 static tree
10248 maybe_access_field (tree decl, tree where, tree type)
10249 {
10250 if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10251 && !FIELD_STATIC (decl))
10252 decl = build_field_ref (where ? where : current_this,
10253 (type ? type : DECL_CONTEXT (decl)),
10254 DECL_NAME (decl));
10255 return decl;
10256 }
10257
10258 /* Build a method invocation, by patching PATCH. If non NULL
10259 and according to the situation, PRIMARY and WHERE may be
10260 used. IS_STATIC is set to 1 if the invoked function is static. */
10261
10262 static tree
10263 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10264 int *is_static, tree *ret_decl)
10265 {
10266 tree wfl = TREE_OPERAND (patch, 0);
10267 tree args = TREE_OPERAND (patch, 1);
10268 tree name = EXPR_WFL_NODE (wfl);
10269 tree list;
10270 int is_static_flag = 0;
10271 int is_super_init = 0;
10272 tree this_arg = NULL_TREE;
10273 int is_array_clone_call = 0;
10274
10275 /* Should be overridden if everything goes well. Otherwise, if
10276 something fails, it should keep this value. It stop the
10277 evaluation of a bogus assignment. See java_complete_tree,
10278 MODIFY_EXPR: for the reasons why we sometimes want to keep on
10279 evaluating an assignment */
10280 TREE_TYPE (patch) = error_mark_node;
10281
10282 /* Since lookup functions are messing with line numbers, save the
10283 context now. */
10284 java_parser_context_save_global ();
10285
10286 /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10287
10288 /* Resolution of qualified name, excluding constructors */
10289 if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10290 {
10291 tree identifier, identifier_wfl, type, resolved;
10292 /* Extract the last IDENTIFIER of the qualified
10293 expression. This is a wfl and we will use it's location
10294 data during error report. */
10295 identifier_wfl = cut_identifier_in_qualified (wfl);
10296 identifier = EXPR_WFL_NODE (identifier_wfl);
10297
10298 /* Given the context, IDENTIFIER is syntactically qualified
10299 as a MethodName. We need to qualify what's before */
10300 qualify_ambiguous_name (wfl);
10301 resolved = resolve_field_access (wfl, NULL, NULL);
10302
10303 if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10304 && FIELD_FINAL (resolved)
10305 && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10306 && !flag_emit_class_files && !flag_emit_xref)
10307 resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10308
10309 if (resolved == error_mark_node)
10310 PATCH_METHOD_RETURN_ERROR ();
10311
10312 type = GET_SKIP_TYPE (resolved);
10313 resolve_and_layout (type, NULL_TREE);
10314
10315 if (JPRIMITIVE_TYPE_P (type))
10316 {
10317 parse_error_context
10318 (identifier_wfl,
10319 "Can't invoke a method on primitive type `%s'",
10320 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10321 PATCH_METHOD_RETURN_ERROR ();
10322 }
10323
10324 list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10325 args = nreverse (args);
10326
10327 /* We're resolving a call from a type */
10328 if (TREE_CODE (resolved) == TYPE_DECL)
10329 {
10330 if (CLASS_INTERFACE (resolved))
10331 {
10332 parse_error_context
10333 (identifier_wfl,
10334 "Can't make static reference to method `%s' in interface `%s'",
10335 IDENTIFIER_POINTER (identifier),
10336 IDENTIFIER_POINTER (name));
10337 PATCH_METHOD_RETURN_ERROR ();
10338 }
10339 if (list && !METHOD_STATIC (list))
10340 {
10341 char *fct_name = xstrdup (lang_printable_name (list, 0));
10342 parse_error_context
10343 (identifier_wfl,
10344 "Can't make static reference to method `%s %s' in class `%s'",
10345 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10346 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10347 free (fct_name);
10348 PATCH_METHOD_RETURN_ERROR ();
10349 }
10350 }
10351 else
10352 this_arg = primary = resolved;
10353
10354 if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10355 is_array_clone_call = 1;
10356
10357 /* IDENTIFIER_WFL will be used to report any problem further */
10358 wfl = identifier_wfl;
10359 }
10360 /* Resolution of simple names, names generated after a primary: or
10361 constructors */
10362 else
10363 {
10364 tree class_to_search = NULL_TREE;
10365 int lc; /* Looking for Constructor */
10366
10367 /* We search constructor in their target class */
10368 if (CALL_CONSTRUCTOR_P (patch))
10369 {
10370 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10371 class_to_search = EXPR_WFL_NODE (wfl);
10372 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10373 this_identifier_node)
10374 class_to_search = NULL_TREE;
10375 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10376 super_identifier_node)
10377 {
10378 is_super_init = 1;
10379 if (CLASSTYPE_SUPER (current_class))
10380 class_to_search =
10381 DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10382 else
10383 {
10384 parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10385 PATCH_METHOD_RETURN_ERROR ();
10386 }
10387 }
10388
10389 /* Class to search is NULL if we're searching the current one */
10390 if (class_to_search)
10391 {
10392 class_to_search = resolve_and_layout (class_to_search, wfl);
10393
10394 if (!class_to_search)
10395 {
10396 parse_error_context
10397 (wfl, "Class `%s' not found in type declaration",
10398 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10399 PATCH_METHOD_RETURN_ERROR ();
10400 }
10401
10402 /* Can't instantiate an abstract class, but we can
10403 invoke it's constructor. It's use within the `new'
10404 context is denied here. */
10405 if (CLASS_ABSTRACT (class_to_search)
10406 && TREE_CODE (patch) == NEW_CLASS_EXPR)
10407 {
10408 parse_error_context
10409 (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10410 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10411 PATCH_METHOD_RETURN_ERROR ();
10412 }
10413
10414 class_to_search = TREE_TYPE (class_to_search);
10415 }
10416 else
10417 class_to_search = current_class;
10418 lc = 1;
10419 }
10420 /* This is a regular search in the local class, unless an
10421 alternate class is specified. */
10422 else
10423 {
10424 if (where != NULL_TREE)
10425 class_to_search = where;
10426 else if (QUALIFIED_P (name))
10427 class_to_search = current_class;
10428 else
10429 {
10430 class_to_search = current_class;
10431
10432 for (;;)
10433 {
10434 if (has_method (class_to_search, name))
10435 break;
10436 if (! INNER_CLASS_TYPE_P (class_to_search))
10437 {
10438 parse_error_context (wfl,
10439 "No method named `%s' in scope",
10440 IDENTIFIER_POINTER (name));
10441 PATCH_METHOD_RETURN_ERROR ();
10442 }
10443 class_to_search
10444 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10445 }
10446 }
10447 lc = 0;
10448 }
10449
10450 /* NAME is a simple identifier or comes from a primary. Search
10451 in the class whose declaration contain the method being
10452 invoked. */
10453 resolve_and_layout (class_to_search, NULL_TREE);
10454
10455 list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10456 /* Don't continue if no method were found, as the next statement
10457 can't be executed then. */
10458 if (!list)
10459 PATCH_METHOD_RETURN_ERROR ();
10460
10461 if (TYPE_ARRAY_P (class_to_search)
10462 && DECL_NAME (list) == get_identifier ("clone"))
10463 is_array_clone_call = 1;
10464
10465 /* Check for static reference if non static methods */
10466 if (check_for_static_method_reference (wfl, patch, list,
10467 class_to_search, primary))
10468 PATCH_METHOD_RETURN_ERROR ();
10469
10470 /* Check for inner classes creation from illegal contexts */
10471 if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10472 && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10473 && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10474 && !DECL_INIT_P (current_function_decl))
10475 {
10476 parse_error_context
10477 (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10478 lang_printable_name (class_to_search, 0),
10479 (!current_this ? "" :
10480 "; an explicit one must be provided when creating this inner class"));
10481 PATCH_METHOD_RETURN_ERROR ();
10482 }
10483
10484 /* Non static methods are called with the current object extra
10485 argument. If patch a `new TYPE()', the argument is the value
10486 returned by the object allocator. If method is resolved as a
10487 primary, use the primary otherwise use the current THIS. */
10488 args = nreverse (args);
10489 if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10490 {
10491 this_arg = primary ? primary : current_this;
10492
10493 /* If we're using an access method, things are different.
10494 There are two family of cases:
10495
10496 1) We're not generating bytecodes:
10497
10498 - LIST is non static. It's invocation is transformed from
10499 x(a1,...,an) into this$<n>.x(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 2) We're generating bytecodes:
10504
10505 - LIST is non static. It's invocation is transformed from
10506 x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10507 - LIST is static. It's invocation is transformed from
10508 x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10509
10510 Of course, this$<n> can be arbitrarily complex, ranging from
10511 this$0 (the immediate outer context) to
10512 access$0(access$0(...(this$0))).
10513
10514 maybe_use_access_method returns a nonzero value if the
10515 this_arg has to be moved into the (then generated) stub
10516 argument list. In the meantime, the selected function
10517 might have be replaced by a generated stub. */
10518 if (!primary &&
10519 maybe_use_access_method (is_super_init, &list, &this_arg))
10520 {
10521 args = tree_cons (NULL_TREE, this_arg, args);
10522 this_arg = NULL_TREE; /* So it doesn't get chained twice */
10523 }
10524 }
10525 }
10526
10527 /* Merge point of all resolution schemes. If we have nothing, this
10528 is an error, already signaled */
10529 if (!list)
10530 PATCH_METHOD_RETURN_ERROR ();
10531
10532 /* Check accessibility, position the is_static flag, build and
10533 return the call */
10534 if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10535 (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10536 NULL_TREE), from_super)
10537 /* Calls to clone() on array types are permitted as a special-case. */
10538 && !is_array_clone_call)
10539 {
10540 const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10541 const char *const access =
10542 java_accstring_lookup (get_access_flags_from_decl (list));
10543 const char *const klass =
10544 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10545 const char *const refklass =
10546 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10547 const char *const what = (DECL_CONSTRUCTOR_P (list)
10548 ? "constructor" : "method");
10549 /* FIXME: WFL yields the wrong message here but I don't know
10550 what else to use. */
10551 parse_error_context (wfl,
10552 "Can't access %s %s `%s.%s' from `%s'",
10553 access, what, klass, fct_name, refklass);
10554 PATCH_METHOD_RETURN_ERROR ();
10555 }
10556
10557 /* Deprecation check: check whether the method being invoked or the
10558 instance-being-created's type are deprecated. */
10559 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10560 check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10561 check_deprecation (wfl, list);
10562
10563 /* If invoking a innerclass constructor, there are hidden parameters
10564 to pass */
10565 if (TREE_CODE (patch) == NEW_CLASS_EXPR
10566 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10567 {
10568 /* And make sure we add the accessed local variables to be saved
10569 in field aliases. */
10570 args = build_alias_initializer_parameter_list
10571 (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10572
10573 /* Secretly pass the current_this/primary as a second argument */
10574 if (primary || current_this)
10575 {
10576 tree extra_arg;
10577 tree this_type = (current_this ?
10578 TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10579 /* Method's (list) enclosing context */
10580 tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10581 /* If we have a primary, use it. */
10582 if (primary)
10583 extra_arg = primary;
10584 /* The current `this' is an inner class but isn't a direct
10585 enclosing context for the inner class we're trying to
10586 create. Build an access to the proper enclosing context
10587 and use it. */
10588 else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10589 && this_type != TREE_TYPE (mec))
10590 {
10591
10592 extra_arg = build_access_to_thisn (current_class,
10593 TREE_TYPE (mec), 0);
10594 extra_arg = java_complete_tree (extra_arg);
10595 }
10596 /* Otherwise, just use the current `this' as an enclosing
10597 context. */
10598 else
10599 extra_arg = current_this;
10600 args = tree_cons (NULL_TREE, extra_arg, args);
10601 }
10602 else
10603 args = tree_cons (NULL_TREE, integer_zero_node, args);
10604 }
10605
10606 /* This handles the situation where a constructor invocation needs
10607 to have an enclosing context passed as a second parameter (the
10608 constructor is one of an inner class). */
10609 if ((is_super_init ||
10610 (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10611 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10612 {
10613 tree dest = TYPE_NAME (DECL_CONTEXT (list));
10614 tree extra_arg =
10615 build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10616 extra_arg = java_complete_tree (extra_arg);
10617 args = tree_cons (NULL_TREE, extra_arg, args);
10618 }
10619
10620 is_static_flag = METHOD_STATIC (list);
10621 if (! is_static_flag && this_arg != NULL_TREE)
10622 args = tree_cons (NULL_TREE, this_arg, args);
10623
10624 /* In the context of an explicit constructor invocation, we can't
10625 invoke any method relying on `this'. Exceptions are: we're
10626 invoking a static function, primary exists and is not the current
10627 this, we're creating a new object. */
10628 if (ctxp->explicit_constructor_p
10629 && !is_static_flag
10630 && (!primary || primary == current_this)
10631 && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10632 {
10633 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10634 PATCH_METHOD_RETURN_ERROR ();
10635 }
10636 java_parser_context_restore_global ();
10637 if (is_static)
10638 *is_static = is_static_flag;
10639 /* Sometimes, we want the decl of the selected method. Such as for
10640 EH checking */
10641 if (ret_decl)
10642 *ret_decl = list;
10643 patch = patch_invoke (patch, list, args);
10644
10645 /* Now is a good time to insert the call to finit$ */
10646 if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10647 {
10648 tree finit_parms, finit_call;
10649
10650 /* Prepare to pass hidden parameters to finit$, if any. */
10651 finit_parms = build_alias_initializer_parameter_list
10652 (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10653
10654 finit_call =
10655 build_method_invocation (build_wfl_node (finit_identifier_node),
10656 finit_parms);
10657
10658 /* Generate the code used to initialize fields declared with an
10659 initialization statement and build a compound statement along
10660 with the super constructor invocation. */
10661 CAN_COMPLETE_NORMALLY (patch) = 1;
10662 patch = build (COMPOUND_EXPR, void_type_node, patch,
10663 java_complete_tree (finit_call));
10664 }
10665 return patch;
10666 }
10667
10668 /* Check that we're not trying to do a static reference to a method in
10669 non static method. Return 1 if it's the case, 0 otherwise. */
10670
10671 static int
10672 check_for_static_method_reference (tree wfl, tree node, tree method,
10673 tree where, tree primary)
10674 {
10675 if (METHOD_STATIC (current_function_decl)
10676 && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10677 {
10678 char *fct_name = xstrdup (lang_printable_name (method, 0));
10679 parse_error_context
10680 (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10681 lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10682 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10683 free (fct_name);
10684 return 1;
10685 }
10686 return 0;
10687 }
10688
10689 /* Fix the invocation of *MDECL if necessary in the case of a
10690 invocation from an inner class. *THIS_ARG might be modified
10691 appropriately and an alternative access to *MDECL might be
10692 returned. */
10693
10694 static int
10695 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10696 {
10697 tree ctx;
10698 tree md = *mdecl, ta = *this_arg;
10699 int to_return = 0;
10700 int non_static_context = !METHOD_STATIC (md);
10701
10702 if (is_super_init
10703 || DECL_CONTEXT (md) == current_class
10704 || !PURE_INNER_CLASS_TYPE_P (current_class)
10705 || DECL_FINIT_P (md)
10706 || DECL_INSTINIT_P (md))
10707 return 0;
10708
10709 /* If we're calling a method found in an enclosing class, generate
10710 what it takes to retrieve the right this. Don't do that if we're
10711 invoking a static method. Note that if MD's type is unrelated to
10712 CURRENT_CLASS, then the current this can be used. */
10713
10714 if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10715 {
10716 ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10717 if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10718 {
10719 ta = build_current_thisn (current_class);
10720 ta = build_wfl_node (ta);
10721 }
10722 else
10723 {
10724 tree type = ctx;
10725 while (type)
10726 {
10727 maybe_build_thisn_access_method (type);
10728 if (inherits_from_p (type, DECL_CONTEXT (md)))
10729 {
10730 ta = build_access_to_thisn (ctx, type, 0);
10731 break;
10732 }
10733 type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10734 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10735 }
10736 }
10737 ta = java_complete_tree (ta);
10738 }
10739
10740 /* We might have to use an access method to get to MD. We can
10741 break the method access rule as far as we're not generating
10742 bytecode */
10743 if (METHOD_PRIVATE (md) && flag_emit_class_files)
10744 {
10745 md = build_outer_method_access_method (md);
10746 to_return = 1;
10747 }
10748
10749 *mdecl = md;
10750 *this_arg = ta;
10751
10752 /* Returning a nonzero value indicates we were doing a non static
10753 method invocation that is now a static invocation. It will have
10754 callee displace `this' to insert it in the regular argument
10755 list. */
10756 return (non_static_context && to_return);
10757 }
10758
10759 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10760 mode. */
10761
10762 static tree
10763 patch_invoke (tree patch, tree method, tree args)
10764 {
10765 tree dtable, func;
10766 tree original_call, t, ta;
10767 tree check = NULL_TREE;
10768
10769 /* Last step for args: convert build-in types. If we're dealing with
10770 a new TYPE() type call, the first argument to the constructor
10771 isn't found in the incoming argument list, but delivered by
10772 `new' */
10773 t = TYPE_ARG_TYPES (TREE_TYPE (method));
10774 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10775 t = TREE_CHAIN (t);
10776 for (ta = args; t != end_params_node && ta;
10777 t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10778 if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10779 TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10780 TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10781
10782 /* Resolve unresolved returned type issues */
10783 t = TREE_TYPE (TREE_TYPE (method));
10784 if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10785 resolve_and_layout (TREE_TYPE (t), NULL);
10786
10787 if (flag_emit_class_files || flag_emit_xref)
10788 func = method;
10789 else
10790 {
10791 switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10792 {
10793 case INVOKE_VIRTUAL:
10794 dtable = invoke_build_dtable (0, args);
10795 func = build_invokevirtual (dtable, method);
10796 break;
10797
10798 case INVOKE_NONVIRTUAL:
10799 /* If the object for the method call is null, we throw an
10800 exception. We don't do this if the object is the current
10801 method's `this'. In other cases we just rely on an
10802 optimization pass to eliminate redundant checks. */
10803 if (TREE_VALUE (args) != current_this)
10804 {
10805 /* We use a save_expr here to make sure we only evaluate
10806 the new `self' expression once. */
10807 tree save_arg = save_expr (TREE_VALUE (args));
10808 TREE_VALUE (args) = save_arg;
10809 check = java_check_reference (save_arg, 1);
10810 }
10811 /* Fall through. */
10812
10813 case INVOKE_SUPER:
10814 case INVOKE_STATIC:
10815 {
10816 tree signature = build_java_signature (TREE_TYPE (method));
10817 func = build_known_method_ref (method, TREE_TYPE (method),
10818 DECL_CONTEXT (method),
10819 signature, args);
10820 }
10821 break;
10822
10823 case INVOKE_INTERFACE:
10824 dtable = invoke_build_dtable (1, args);
10825 func = build_invokeinterface (dtable, method);
10826 break;
10827
10828 default:
10829 abort ();
10830 }
10831
10832 /* Ensure self_type is initialized, (invokestatic). FIXME */
10833 func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10834 }
10835
10836 TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10837 TREE_OPERAND (patch, 0) = func;
10838 TREE_OPERAND (patch, 1) = args;
10839 patch = check_for_builtin (method, patch);
10840 original_call = patch;
10841
10842 /* We're processing a `new TYPE ()' form. New is called and its
10843 returned value is the first argument to the constructor. We build
10844 a COMPOUND_EXPR and use saved expression so that the overall NEW
10845 expression value is a pointer to a newly created and initialized
10846 class. */
10847 if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10848 {
10849 tree class = DECL_CONTEXT (method);
10850 tree c1, saved_new, size, new;
10851 tree alloc_node;
10852
10853 if (flag_emit_class_files || flag_emit_xref)
10854 {
10855 TREE_TYPE (patch) = build_pointer_type (class);
10856 return patch;
10857 }
10858 if (!TYPE_SIZE (class))
10859 safe_layout_class (class);
10860 size = size_in_bytes (class);
10861 alloc_node =
10862 (class_has_finalize_method (class) ? alloc_object_node
10863 : alloc_no_finalizer_node);
10864 new = build (CALL_EXPR, promote_type (class),
10865 build_address_of (alloc_node),
10866 tree_cons (NULL_TREE, build_class_ref (class),
10867 build_tree_list (NULL_TREE,
10868 size_in_bytes (class))),
10869 NULL_TREE);
10870 saved_new = save_expr (new);
10871 c1 = build_tree_list (NULL_TREE, saved_new);
10872 TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10873 TREE_OPERAND (original_call, 1) = c1;
10874 TREE_SET_CODE (original_call, CALL_EXPR);
10875 patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10876 }
10877
10878 /* If CHECK is set, then we are building a check to see if the object
10879 is NULL. */
10880 if (check != NULL_TREE)
10881 {
10882 /* We have to call force_evaluation_order now because creating a
10883 COMPOUND_EXPR wraps the arg list in a way that makes it
10884 unrecognizable by force_evaluation_order later. Yuk. */
10885 patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10886 force_evaluation_order (patch));
10887 TREE_SIDE_EFFECTS (patch) = 1;
10888 }
10889
10890 /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10891 put it as the first expression of a COMPOUND_EXPR. The second
10892 expression being an empty statement to be later patched if
10893 necessary. We remember a TREE_LIST (the PURPOSE is the method,
10894 the VALUE is the compound) in a hashtable and return a
10895 COMPOUND_EXPR built so that the result of the evaluation of the
10896 original PATCH node is returned. */
10897 if (STATIC_CLASS_INIT_OPT_P ()
10898 && current_function_decl && METHOD_STATIC (method))
10899 {
10900 tree list;
10901 tree fndecl = current_function_decl;
10902 /* We have to call force_evaluation_order now because creating a
10903 COMPOUND_EXPR wraps the arg list in a way that makes it
10904 unrecognizable by force_evaluation_order later. Yuk. */
10905 tree save = save_expr (force_evaluation_order (patch));
10906 tree type = TREE_TYPE (patch);
10907
10908 patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10909 list = tree_cons (method, patch,
10910 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10911
10912 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10913
10914 patch = build (COMPOUND_EXPR, type, patch, save);
10915 }
10916
10917 return patch;
10918 }
10919
10920 static int
10921 invocation_mode (tree method, int super)
10922 {
10923 int access = get_access_flags_from_decl (method);
10924
10925 if (super)
10926 return INVOKE_SUPER;
10927
10928 if (access & ACC_STATIC)
10929 return INVOKE_STATIC;
10930
10931 /* We have to look for a constructor before we handle nonvirtual
10932 calls; otherwise the constructor will look nonvirtual. */
10933 if (DECL_CONSTRUCTOR_P (method))
10934 return INVOKE_STATIC;
10935
10936 if (access & ACC_FINAL || access & ACC_PRIVATE)
10937 return INVOKE_NONVIRTUAL;
10938
10939 if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10940 return INVOKE_NONVIRTUAL;
10941
10942 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10943 return INVOKE_INTERFACE;
10944
10945 return INVOKE_VIRTUAL;
10946 }
10947
10948 /* Retrieve a refined list of matching methods. It covers the step
10949 15.11.2 (Compile-Time Step 2) */
10950
10951 static tree
10952 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10953 {
10954 tree atl = end_params_node; /* Arg Type List */
10955 tree method, signature, list, node;
10956 const char *candidates; /* Used for error report */
10957 char *dup;
10958
10959 /* Fix the arguments */
10960 for (node = arg_list; node; node = TREE_CHAIN (node))
10961 {
10962 tree current_arg = TREE_TYPE (TREE_VALUE (node));
10963 /* Non primitive type may have to be resolved */
10964 if (!JPRIMITIVE_TYPE_P (current_arg))
10965 resolve_and_layout (current_arg, NULL_TREE);
10966 /* And promoted */
10967 if (TREE_CODE (current_arg) == RECORD_TYPE)
10968 current_arg = promote_type (current_arg);
10969 atl = tree_cons (NULL_TREE, current_arg, atl);
10970 }
10971
10972 /* Presto. If we're dealing with an anonymous class and a
10973 constructor call, generate the right constructor now, since we
10974 know the arguments' types. */
10975
10976 if (lc && ANONYMOUS_CLASS_P (class))
10977 {
10978 tree saved_current_class;
10979 tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10980 saved_current_class = current_class;
10981 current_class = class;
10982 fix_constructors (mdecl);
10983 current_class = saved_current_class;
10984 }
10985
10986 /* Find all candidates and then refine the list, searching for the
10987 most specific method. */
10988 list = find_applicable_accessible_methods_list (lc, class, name, atl);
10989 list = find_most_specific_methods_list (list);
10990 if (list && !TREE_CHAIN (list))
10991 return TREE_VALUE (list);
10992
10993 /* Issue an error. List candidates if any. Candidates are listed
10994 only if accessible (non accessible methods may end-up here for
10995 the sake of a better error report). */
10996 candidates = NULL;
10997 if (list)
10998 {
10999 tree current;
11000 obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
11001 for (current = list; current; current = TREE_CHAIN (current))
11002 {
11003 tree cm = TREE_VALUE (current);
11004 char string [4096];
11005 if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
11006 continue;
11007 sprintf
11008 (string, " `%s' in `%s'%s",
11009 get_printable_method_name (cm),
11010 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
11011 (TREE_CHAIN (current) ? "\n" : ""));
11012 obstack_grow (&temporary_obstack, string, strlen (string));
11013 }
11014 obstack_1grow (&temporary_obstack, '\0');
11015 candidates = obstack_finish (&temporary_obstack);
11016 }
11017 /* Issue the error message */
11018 method = make_node (FUNCTION_TYPE);
11019 TYPE_ARG_TYPES (method) = atl;
11020 signature = build_java_argument_signature (method);
11021 dup = xstrdup (lang_printable_name (class, 0));
11022 parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
11023 (lc ? "constructor" : "method"),
11024 (lc ? dup : IDENTIFIER_POINTER (name)),
11025 IDENTIFIER_POINTER (signature), dup,
11026 (candidates ? candidates : ""));
11027 free (dup);
11028 return NULL_TREE;
11029 }
11030
11031 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11032 when we're looking for a constructor. */
11033
11034 static tree
11035 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11036 tree arglist)
11037 {
11038 static htab_t searched_classes;
11039 static int search_not_done = 0;
11040 tree list = NULL_TREE, all_list = NULL_TREE;
11041
11042 /* Check the hash table to determine if this class has been searched
11043 already. */
11044 if (searched_classes)
11045 {
11046 if (htab_find (searched_classes, class) != NULL)
11047 return NULL;
11048 }
11049 else
11050 {
11051 searched_classes = htab_create (10, htab_hash_pointer,
11052 htab_eq_pointer, NULL);
11053 }
11054
11055 search_not_done++;
11056 *htab_find_slot (searched_classes, class, INSERT) = class;
11057
11058 if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
11059 {
11060 load_class (class, 1);
11061 safe_layout_class (class);
11062 }
11063
11064 /* Search interfaces */
11065 if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11066 && CLASS_INTERFACE (TYPE_NAME (class)))
11067 {
11068 int i, n;
11069 tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11070 search_applicable_methods_list (lc, TYPE_METHODS (class),
11071 name, arglist, &list, &all_list);
11072 n = TREE_VEC_LENGTH (basetype_vec);
11073 for (i = 1; i < n; i++)
11074 {
11075 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11076 tree rlist;
11077
11078 rlist = find_applicable_accessible_methods_list (lc, t, name,
11079 arglist);
11080 list = chainon (rlist, list);
11081 }
11082 }
11083 /* Search classes */
11084 else
11085 {
11086 search_applicable_methods_list (lc, TYPE_METHODS (class),
11087 name, arglist, &list, &all_list);
11088
11089 /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11090 that we only search in class. Note that we should have found
11091 something at this point. */
11092 if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11093 {
11094 lc = 1;
11095 if (!list)
11096 abort ();
11097 }
11098
11099 /* We must search all interfaces of this class */
11100 if (!lc)
11101 {
11102 tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11103 int n = TREE_VEC_LENGTH (basetype_vec), i;
11104 for (i = 1; i < n; i++)
11105 {
11106 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11107 if (t != object_type_node)
11108 {
11109 tree rlist
11110 = find_applicable_accessible_methods_list (lc, t,
11111 name, arglist);
11112 list = chainon (rlist, list);
11113 }
11114 }
11115 }
11116
11117 /* Search superclass */
11118 if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11119 {
11120 tree rlist;
11121 class = CLASSTYPE_SUPER (class);
11122 rlist = find_applicable_accessible_methods_list (lc, class,
11123 name, arglist);
11124 list = chainon (rlist, list);
11125 }
11126 }
11127
11128 search_not_done--;
11129
11130 /* We're done. Reset the searched classes list and finally search
11131 java.lang.Object if it wasn't searched already. */
11132 if (!search_not_done)
11133 {
11134 if (!lc
11135 && TYPE_METHODS (object_type_node)
11136 && htab_find (searched_classes, object_type_node) == NULL)
11137 {
11138 search_applicable_methods_list (lc,
11139 TYPE_METHODS (object_type_node),
11140 name, arglist, &list, &all_list);
11141 }
11142 htab_delete (searched_classes);
11143 searched_classes = NULL;
11144 }
11145
11146 /* Either return the list obtained or all selected (but
11147 inaccessible) methods for better error report. */
11148 return (!list ? all_list : list);
11149 }
11150
11151 /* Effectively search for the appropriate method in method */
11152
11153 static void
11154 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11155 tree *list, tree *all_list)
11156 {
11157 for (; method; method = TREE_CHAIN (method))
11158 {
11159 /* When dealing with constructor, stop here, otherwise search
11160 other classes */
11161 if (lc && !DECL_CONSTRUCTOR_P (method))
11162 continue;
11163 else if (!lc && (DECL_CONSTRUCTOR_P (method)
11164 || (DECL_NAME (method) != name)))
11165 continue;
11166
11167 if (argument_types_convertible (method, arglist))
11168 {
11169 /* Retain accessible methods only */
11170 if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11171 method, NULL_TREE, 0))
11172 *list = tree_cons (NULL_TREE, method, *list);
11173 else
11174 /* Also retain all selected method here */
11175 *all_list = tree_cons (NULL_TREE, method, *list);
11176 }
11177 }
11178 }
11179
11180 /* 15.11.2.2 Choose the Most Specific Method */
11181
11182 static tree
11183 find_most_specific_methods_list (tree list)
11184 {
11185 int max = 0;
11186 int abstract, candidates;
11187 tree current, new_list = NULL_TREE;
11188 for (current = list; current; current = TREE_CHAIN (current))
11189 {
11190 tree method;
11191 DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11192
11193 for (method = list; method; method = TREE_CHAIN (method))
11194 {
11195 tree method_v, current_v;
11196 /* Don't test a method against itself */
11197 if (method == current)
11198 continue;
11199
11200 method_v = TREE_VALUE (method);
11201 current_v = TREE_VALUE (current);
11202
11203 /* Compare arguments and location where methods where declared */
11204 if (argument_types_convertible (method_v, current_v))
11205 {
11206 if (valid_method_invocation_conversion_p
11207 (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11208 || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11209 && enclosing_context_p (DECL_CONTEXT (method_v),
11210 DECL_CONTEXT (current_v))))
11211 {
11212 int v = (DECL_SPECIFIC_COUNT (current_v) +=
11213 (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11214 max = (v > max ? v : max);
11215 }
11216 }
11217 }
11218 }
11219
11220 /* Review the list and select the maximally specific methods */
11221 for (current = list, abstract = -1, candidates = -1;
11222 current; current = TREE_CHAIN (current))
11223 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11224 {
11225 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11226 abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11227 candidates++;
11228 }
11229
11230 /* If we have several and they're all abstract, just pick the
11231 closest one. */
11232 if (candidates > 0 && candidates == abstract)
11233 {
11234 /* FIXME: merge the throws clauses. There is no convenient way
11235 to do this in gcj right now, since ideally we'd like to
11236 introduce a new METHOD_DECL here, but that is really not
11237 possible. */
11238 new_list = nreverse (new_list);
11239 TREE_CHAIN (new_list) = NULL_TREE;
11240 return new_list;
11241 }
11242
11243 /* We have several (we couldn't find a most specific), all but one
11244 are abstract, we pick the only non abstract one. */
11245 if (candidates > 0 && (candidates == abstract+1))
11246 {
11247 for (current = new_list; current; current = TREE_CHAIN (current))
11248 if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11249 {
11250 TREE_CHAIN (current) = NULL_TREE;
11251 new_list = current;
11252 }
11253 }
11254
11255 /* If we can't find one, lower expectations and try to gather multiple
11256 maximally specific methods */
11257 while (!new_list && max)
11258 {
11259 while (--max > 0)
11260 {
11261 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11262 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11263 }
11264 }
11265
11266 return new_list;
11267 }
11268
11269 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11270 converted by method invocation conversion (5.3) to the type of the
11271 corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11272 to change less often than M1. */
11273
11274 static GTY(()) tree m2_arg_value;
11275 static GTY(()) tree m2_arg_cache;
11276
11277 static int
11278 argument_types_convertible (tree m1, tree m2_or_arglist)
11279 {
11280 tree m1_arg, m2_arg;
11281
11282 SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11283
11284 if (m2_arg_value == m2_or_arglist)
11285 m2_arg = m2_arg_cache;
11286 else
11287 {
11288 /* M2_OR_ARGLIST can be a function DECL or a raw list of
11289 argument types */
11290 if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11291 {
11292 m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11293 if (!METHOD_STATIC (m2_or_arglist))
11294 m2_arg = TREE_CHAIN (m2_arg);
11295 }
11296 else
11297 m2_arg = m2_or_arglist;
11298
11299 m2_arg_value = m2_or_arglist;
11300 m2_arg_cache = m2_arg;
11301 }
11302
11303 while (m1_arg != end_params_node && m2_arg != end_params_node)
11304 {
11305 resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11306 if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11307 TREE_VALUE (m2_arg)))
11308 break;
11309 m1_arg = TREE_CHAIN (m1_arg);
11310 m2_arg = TREE_CHAIN (m2_arg);
11311 }
11312 return m1_arg == end_params_node && m2_arg == end_params_node;
11313 }
11314
11315 /* Qualification routines */
11316
11317 /* Given a name x.y.z, look up x locally. If it's found, save the
11318 decl. If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11319 so that we later try and load the appropriate classes. */
11320 static void
11321 qualify_ambiguous_name (tree id)
11322 {
11323 tree name, decl;
11324
11325 /* We inspect the first item of the qualification list. As a sanity
11326 check, make sure that it is an identfier node. */
11327 tree qual = EXPR_WFL_QUALIFICATION (id);
11328 tree qual_wfl = QUAL_WFL (qual);
11329
11330 if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11331 return;
11332
11333 name = EXPR_WFL_NODE (qual_wfl);
11334
11335 /* If we don't have an identifier, or we have a 'this' or 'super',
11336 then field access processing is all we need : there is nothing
11337 for us to do. */
11338 if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11339 name == this_identifier_node ||
11340 name == super_identifier_node)
11341 return;
11342
11343 /* If name appears within the scope of a local variable declaration
11344 or parameter declaration, or is a field within an enclosing
11345 class, then it is an expression name. Save the decl and let
11346 resolve_field_access do it's work. */
11347 if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11348 (decl = lookup_field_wrapper (current_class, name)))
11349 {
11350 QUAL_RESOLUTION (qual) = decl;
11351 return;
11352 }
11353
11354 /* If name is a known class name (either declared or imported), mark
11355 us as a type name. */
11356 if ((decl = resolve_and_layout (name, NULL_TREE)))
11357 {
11358 RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11359 QUAL_RESOLUTION (qual) = decl;
11360 }
11361
11362 /* Check here that NAME isn't declared by more than one
11363 type-import-on-demand declaration of the compilation unit
11364 containing NAME. FIXME */
11365
11366 /* We couldn't find a declaration for the name. Assume for now that
11367 we have a qualified class name that needs to be loaded from an
11368 external class file. */
11369 else
11370 RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11371
11372 /* Propagate the qualification across other components of the
11373 qualified name */
11374 for (qual = TREE_CHAIN (qual); qual;
11375 qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11376 {
11377 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11378 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11379 }
11380
11381 /* Store the global qualification for the ambiguous part of ID back
11382 into ID fields */
11383 if (RESOLVE_TYPE_NAME_P (qual_wfl))
11384 RESOLVE_TYPE_NAME_P (id) = 1;
11385 else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11386 RESOLVE_PACKAGE_NAME_P (id) = 1;
11387 }
11388
11389 static int
11390 breakdown_qualified (tree *left, tree *right, tree source)
11391 {
11392 char *p, *base;
11393 int l = IDENTIFIER_LENGTH (source);
11394
11395 base = alloca (l + 1);
11396 memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11397
11398 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
11399 p = base + l - 1;
11400 while (*p != '.' && p != base)
11401 p--;
11402
11403 /* We didn't find a '.'. Return an error. */
11404 if (p == base)
11405 return 1;
11406
11407 *p = '\0';
11408 if (right)
11409 *right = get_identifier (p+1);
11410 *left = get_identifier (base);
11411
11412 return 0;
11413 }
11414
11415 /* Return TRUE if two classes are from the same package. */
11416
11417 static int
11418 in_same_package (tree name1, tree name2)
11419 {
11420 tree tmp;
11421 tree pkg1;
11422 tree pkg2;
11423
11424 if (TREE_CODE (name1) == TYPE_DECL)
11425 name1 = DECL_NAME (name1);
11426 if (TREE_CODE (name2) == TYPE_DECL)
11427 name2 = DECL_NAME (name2);
11428
11429 if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11430 /* One in empty package. */
11431 return 0;
11432
11433 if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11434 /* Both in empty package. */
11435 return 1;
11436
11437 breakdown_qualified (&pkg1, &tmp, name1);
11438 breakdown_qualified (&pkg2, &tmp, name2);
11439
11440 return (pkg1 == pkg2);
11441 }
11442
11443 /* Patch tree nodes in a function body. When a BLOCK is found, push
11444 local variable decls if present.
11445 Same as java_complete_lhs, but does resolve static finals to values. */
11446
11447 static tree
11448 java_complete_tree (tree node)
11449 {
11450 node = java_complete_lhs (node);
11451 if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11452 && DECL_INITIAL (node) != NULL_TREE
11453 && !flag_emit_xref)
11454 {
11455 tree value = fold_constant_for_init (node, node);
11456 if (value != NULL_TREE)
11457 return value;
11458 }
11459 return node;
11460 }
11461
11462 static tree
11463 java_stabilize_reference (tree node)
11464 {
11465 if (TREE_CODE (node) == COMPOUND_EXPR)
11466 {
11467 tree op0 = TREE_OPERAND (node, 0);
11468 tree op1 = TREE_OPERAND (node, 1);
11469 TREE_OPERAND (node, 0) = save_expr (op0);
11470 TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11471 return node;
11472 }
11473 return stabilize_reference (node);
11474 }
11475
11476 /* Patch tree nodes in a function body. When a BLOCK is found, push
11477 local variable decls if present.
11478 Same as java_complete_tree, but does not resolve static finals to values. */
11479
11480 static tree
11481 java_complete_lhs (tree node)
11482 {
11483 tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11484 int flag;
11485
11486 /* CONVERT_EXPR always has its type set, even though it needs to be
11487 worked out. */
11488 if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11489 return node;
11490
11491 /* The switch block implements cases processing container nodes
11492 first. Contained nodes are always written back. Leaves come
11493 next and return a value. */
11494 switch (TREE_CODE (node))
11495 {
11496 case BLOCK:
11497
11498 /* 1- Block section.
11499 Set the local values on decl names so we can identify them
11500 faster when they're referenced. At that stage, identifiers
11501 are legal so we don't check for declaration errors. */
11502 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11503 {
11504 DECL_CONTEXT (cn) = current_function_decl;
11505 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11506 }
11507 if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11508 CAN_COMPLETE_NORMALLY (node) = 1;
11509 else
11510 {
11511 tree stmt = BLOCK_EXPR_BODY (node);
11512 tree *ptr;
11513 int error_seen = 0;
11514 if (TREE_CODE (stmt) == COMPOUND_EXPR)
11515 {
11516 /* Re-order from (((A; B); C); ...; Z) to
11517 (A; (B; (C ; (...; Z)))).
11518 This makes it easier to scan the statements left-to-right
11519 without using recursion (which might overflow the stack
11520 if the block has many statements. */
11521 for (;;)
11522 {
11523 tree left = TREE_OPERAND (stmt, 0);
11524 if (TREE_CODE (left) != COMPOUND_EXPR)
11525 break;
11526 TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11527 TREE_OPERAND (left, 1) = stmt;
11528 stmt = left;
11529 }
11530 BLOCK_EXPR_BODY (node) = stmt;
11531 }
11532
11533 /* Now do the actual complete, without deep recursion for
11534 long blocks. */
11535 ptr = &BLOCK_EXPR_BODY (node);
11536 while (TREE_CODE (*ptr) == COMPOUND_EXPR
11537 && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11538 {
11539 tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11540 tree *next = &TREE_OPERAND (*ptr, 1);
11541 TREE_OPERAND (*ptr, 0) = cur;
11542 if (cur == empty_stmt_node)
11543 {
11544 /* Optimization; makes it easier to detect empty bodies.
11545 Most useful for <clinit> with all-constant initializer. */
11546 *ptr = *next;
11547 continue;
11548 }
11549 if (TREE_CODE (cur) == ERROR_MARK)
11550 error_seen++;
11551 else if (! CAN_COMPLETE_NORMALLY (cur))
11552 {
11553 wfl_op2 = *next;
11554 for (;;)
11555 {
11556 if (TREE_CODE (wfl_op2) == BLOCK)
11557 wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11558 else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11559 wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11560 else
11561 break;
11562 }
11563 if (TREE_CODE (wfl_op2) != CASE_EXPR
11564 && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11565 unreachable_stmt_error (*ptr);
11566 }
11567 if (TREE_TYPE (*ptr) == NULL_TREE)
11568 TREE_TYPE (*ptr) = void_type_node;
11569 ptr = next;
11570 }
11571 *ptr = java_complete_tree (*ptr);
11572
11573 if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11574 return error_mark_node;
11575 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11576 }
11577 /* Turn local bindings to null */
11578 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11579 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11580
11581 TREE_TYPE (node) = void_type_node;
11582 break;
11583
11584 /* 2- They are expressions but ultimately deal with statements */
11585
11586 case THROW_EXPR:
11587 wfl_op1 = TREE_OPERAND (node, 0);
11588 COMPLETE_CHECK_OP_0 (node);
11589 /* 14.19 A throw statement cannot complete normally. */
11590 CAN_COMPLETE_NORMALLY (node) = 0;
11591 return patch_throw_statement (node, wfl_op1);
11592
11593 case SYNCHRONIZED_EXPR:
11594 wfl_op1 = TREE_OPERAND (node, 0);
11595 return patch_synchronized_statement (node, wfl_op1);
11596
11597 case TRY_EXPR:
11598 return patch_try_statement (node);
11599
11600 case TRY_FINALLY_EXPR:
11601 COMPLETE_CHECK_OP_0 (node);
11602 COMPLETE_CHECK_OP_1 (node);
11603 /* Reduce try/finally nodes with an empty try block. */
11604 if (TREE_OPERAND (node, 0) == empty_stmt_node
11605 || BLOCK_EMPTY_P (TREE_OPERAND (node, 0)))
11606 return TREE_OPERAND (node, 1);
11607 /* Likewise for an empty finally block. */
11608 if (TREE_OPERAND (node, 1) == empty_stmt_node
11609 || BLOCK_EMPTY_P (TREE_OPERAND (node, 1)))
11610 return TREE_OPERAND (node, 0);
11611 CAN_COMPLETE_NORMALLY (node)
11612 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11613 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11614 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11615 return node;
11616
11617 case LABELED_BLOCK_EXPR:
11618 PUSH_LABELED_BLOCK (node);
11619 if (LABELED_BLOCK_BODY (node))
11620 COMPLETE_CHECK_OP_1 (node);
11621 TREE_TYPE (node) = void_type_node;
11622 POP_LABELED_BLOCK ();
11623
11624 if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11625 {
11626 LABELED_BLOCK_BODY (node) = NULL_TREE;
11627 CAN_COMPLETE_NORMALLY (node) = 1;
11628 }
11629 else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11630 CAN_COMPLETE_NORMALLY (node) = 1;
11631 return node;
11632
11633 case EXIT_BLOCK_EXPR:
11634 /* We don't complete operand 1, because it's the return value of
11635 the EXIT_BLOCK_EXPR which doesn't exist it Java */
11636 return patch_bc_statement (node);
11637
11638 case CASE_EXPR:
11639 cn = java_complete_tree (TREE_OPERAND (node, 0));
11640 if (cn == error_mark_node)
11641 return cn;
11642
11643 /* First, the case expression must be constant. Values of final
11644 fields are accepted. */
11645 cn = fold (cn);
11646 if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11647 && JDECL_P (TREE_OPERAND (cn, 1))
11648 && FIELD_FINAL (TREE_OPERAND (cn, 1))
11649 && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11650 {
11651 cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11652 TREE_OPERAND (cn, 1));
11653 }
11654 /* Accept final locals too. */
11655 else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
11656 cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11657
11658 if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11659 {
11660 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11661 parse_error_context (node, "Constant expression required");
11662 return error_mark_node;
11663 }
11664
11665 nn = ctxp->current_loop;
11666
11667 /* It must be assignable to the type of the switch expression. */
11668 if (!try_builtin_assignconv (NULL_TREE,
11669 TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11670 {
11671 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11672 parse_error_context
11673 (wfl_operator,
11674 "Incompatible type for case. Can't convert `%s' to `int'",
11675 lang_printable_name (TREE_TYPE (cn), 0));
11676 return error_mark_node;
11677 }
11678
11679 cn = fold (convert (int_type_node, cn));
11680 TREE_CONSTANT_OVERFLOW (cn) = 0;
11681 CAN_COMPLETE_NORMALLY (cn) = 1;
11682
11683 /* Save the label on a list so that we can later check for
11684 duplicates. */
11685 case_label_list = tree_cons (node, cn, case_label_list);
11686
11687 /* Multiple instance of a case label bearing the same value is
11688 checked later. The case expression is all right so far. */
11689 if (TREE_CODE (cn) == VAR_DECL)
11690 cn = DECL_INITIAL (cn);
11691 TREE_OPERAND (node, 0) = cn;
11692 TREE_TYPE (node) = void_type_node;
11693 CAN_COMPLETE_NORMALLY (node) = 1;
11694 TREE_SIDE_EFFECTS (node) = 1;
11695 break;
11696
11697 case DEFAULT_EXPR:
11698 nn = ctxp->current_loop;
11699 /* Only one default label is allowed per switch statement */
11700 if (SWITCH_HAS_DEFAULT (nn))
11701 {
11702 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11703 parse_error_context (wfl_operator,
11704 "Duplicate case label: `default'");
11705 return error_mark_node;
11706 }
11707 else
11708 SWITCH_HAS_DEFAULT (nn) = 1;
11709 TREE_TYPE (node) = void_type_node;
11710 TREE_SIDE_EFFECTS (node) = 1;
11711 CAN_COMPLETE_NORMALLY (node) = 1;
11712 break;
11713
11714 case SWITCH_EXPR:
11715 case LOOP_EXPR:
11716 PUSH_LOOP (node);
11717 /* Check whether the loop was enclosed in a labeled
11718 statement. If not, create one, insert the loop in it and
11719 return the node */
11720 nn = patch_loop_statement (node);
11721
11722 /* Anyways, walk the body of the loop */
11723 if (TREE_CODE (node) == LOOP_EXPR)
11724 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11725 /* Switch statement: walk the switch expression and the cases */
11726 else
11727 node = patch_switch_statement (node);
11728
11729 if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11730 nn = error_mark_node;
11731 else
11732 {
11733 TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11734 /* If we returned something different, that's because we
11735 inserted a label. Pop the label too. */
11736 if (nn != node)
11737 {
11738 if (CAN_COMPLETE_NORMALLY (node))
11739 CAN_COMPLETE_NORMALLY (nn) = 1;
11740 POP_LABELED_BLOCK ();
11741 }
11742 }
11743 POP_LOOP ();
11744 return nn;
11745
11746 case EXIT_EXPR:
11747 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11748 return patch_exit_expr (node);
11749
11750 case COND_EXPR:
11751 /* Condition */
11752 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11753 if (TREE_OPERAND (node, 0) == error_mark_node)
11754 return error_mark_node;
11755 /* then-else branches */
11756 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11757 if (TREE_OPERAND (node, 1) == error_mark_node)
11758 return error_mark_node;
11759 TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11760 if (TREE_OPERAND (node, 2) == error_mark_node)
11761 return error_mark_node;
11762 return patch_if_else_statement (node);
11763 break;
11764
11765 case CONDITIONAL_EXPR:
11766 /* Condition */
11767 wfl_op1 = TREE_OPERAND (node, 0);
11768 COMPLETE_CHECK_OP_0 (node);
11769 wfl_op2 = TREE_OPERAND (node, 1);
11770 COMPLETE_CHECK_OP_1 (node);
11771 wfl_op3 = TREE_OPERAND (node, 2);
11772 COMPLETE_CHECK_OP_2 (node);
11773 return patch_conditional_expr (node, wfl_op1, wfl_op2);
11774
11775 /* 3- Expression section */
11776 case COMPOUND_EXPR:
11777 wfl_op2 = TREE_OPERAND (node, 1);
11778 TREE_OPERAND (node, 0) = nn =
11779 java_complete_tree (TREE_OPERAND (node, 0));
11780 if (wfl_op2 == empty_stmt_node)
11781 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11782 else
11783 {
11784 if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11785 {
11786 /* An unreachable condition in a do-while statement
11787 is *not* (technically) an unreachable statement. */
11788 nn = wfl_op2;
11789 if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11790 nn = EXPR_WFL_NODE (nn);
11791 /* NN can be NULL_TREE exactly when UPDATE is, in
11792 finish_for_loop. */
11793 if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11794 {
11795 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11796 if (SUPPRESS_UNREACHABLE_ERROR (nn))
11797 {
11798 /* Perhaps this warning should have an
11799 associated flag. The code being compiled is
11800 pedantically correct, but useless. */
11801 parse_warning_context (wfl_operator,
11802 "Unreachable statement");
11803 }
11804 else
11805 parse_error_context (wfl_operator,
11806 "Unreachable statement");
11807 }
11808 }
11809 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11810 if (TREE_OPERAND (node, 1) == error_mark_node)
11811 return error_mark_node;
11812 /* Even though we might allow the case where the first
11813 operand doesn't return normally, we still should compute
11814 CAN_COMPLETE_NORMALLY correctly. */
11815 CAN_COMPLETE_NORMALLY (node)
11816 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11817 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11818 }
11819 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11820 break;
11821
11822 case RETURN_EXPR:
11823 /* CAN_COMPLETE_NORMALLY (node) = 0; */
11824 return patch_return (node);
11825
11826 case EXPR_WITH_FILE_LOCATION:
11827 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11828 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11829 {
11830 tree wfl = node;
11831 node = resolve_expression_name (node, NULL);
11832 if (node == error_mark_node)
11833 return node;
11834 /* Keep line number information somewhere were it doesn't
11835 disrupt the completion process. */
11836 if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11837 {
11838 EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11839 TREE_OPERAND (node, 1) = wfl;
11840 }
11841 CAN_COMPLETE_NORMALLY (node) = 1;
11842 }
11843 else
11844 {
11845 tree body;
11846 int save_lineno = input_line;
11847 input_line = EXPR_WFL_LINENO (node);
11848 body = java_complete_tree (EXPR_WFL_NODE (node));
11849 input_line = save_lineno;
11850 EXPR_WFL_NODE (node) = body;
11851 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11852 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11853 if (body == empty_stmt_node || TREE_CONSTANT (body))
11854 {
11855 /* Makes it easier to constant fold, detect empty bodies. */
11856 return body;
11857 }
11858 if (body == error_mark_node)
11859 {
11860 /* Its important for the evaluation of assignment that
11861 this mark on the TREE_TYPE is propagated. */
11862 TREE_TYPE (node) = error_mark_node;
11863 return error_mark_node;
11864 }
11865 else
11866 TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11867
11868 }
11869 break;
11870
11871 case NEW_ARRAY_EXPR:
11872 /* Patch all the dimensions */
11873 flag = 0;
11874 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11875 {
11876 int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11877 tree dim = convert (int_type_node,
11878 java_complete_tree (TREE_VALUE (cn)));
11879 if (dim == error_mark_node)
11880 {
11881 flag = 1;
11882 continue;
11883 }
11884 else
11885 {
11886 TREE_VALUE (cn) = dim;
11887 /* Setup the location of the current dimension, for
11888 later error report. */
11889 TREE_PURPOSE (cn) =
11890 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11891 EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11892 }
11893 }
11894 /* They complete the array creation expression, if no errors
11895 were found. */
11896 CAN_COMPLETE_NORMALLY (node) = 1;
11897 return (flag ? error_mark_node
11898 : force_evaluation_order (patch_newarray (node)));
11899
11900 case NEW_ANONYMOUS_ARRAY_EXPR:
11901 /* Create the array type if necessary. */
11902 if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11903 {
11904 tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11905 if (!(type = resolve_type_during_patch (type)))
11906 return error_mark_node;
11907 type = build_array_from_name (type, NULL_TREE,
11908 ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11909 ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11910 }
11911 node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11912 ANONYMOUS_ARRAY_INITIALIZER (node));
11913 if (node == error_mark_node)
11914 return error_mark_node;
11915 CAN_COMPLETE_NORMALLY (node) = 1;
11916 return node;
11917
11918 case NEW_CLASS_EXPR:
11919 case CALL_EXPR:
11920 /* Complete function's argument(s) first */
11921 if (complete_function_arguments (node))
11922 return error_mark_node;
11923 else
11924 {
11925 tree decl, wfl = TREE_OPERAND (node, 0);
11926 int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11927 int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11928 super_identifier_node);
11929 tree arguments;
11930 int location = EXPR_WFL_LINECOL (node);
11931
11932 node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11933 from_super, 0, &decl);
11934 if (node == error_mark_node)
11935 return error_mark_node;
11936
11937 if (TREE_CODE (node) == CALL_EXPR
11938 && TREE_OPERAND (node, 1) != NULL_TREE)
11939 arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11940 else
11941 arguments = NULL_TREE;
11942 check_thrown_exceptions (location, decl, arguments);
11943 /* If we call this(...), register signature and positions */
11944 if (in_this)
11945 DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11946 tree_cons (wfl, decl,
11947 DECL_CONSTRUCTOR_CALLS (current_function_decl));
11948 CAN_COMPLETE_NORMALLY (node) = 1;
11949 return force_evaluation_order (node);
11950 }
11951
11952 case MODIFY_EXPR:
11953 /* Save potential wfls */
11954 wfl_op1 = TREE_OPERAND (node, 0);
11955 TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11956
11957 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11958 && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11959 && DECL_INITIAL (nn) != NULL_TREE)
11960 {
11961 tree value;
11962
11963 value = fold_constant_for_init (nn, nn);
11964
11965 /* When we have a primitype type, or a string and we're not
11966 emitting a class file, we actually don't want to generate
11967 anything for the assignment. */
11968 if (value != NULL_TREE &&
11969 (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11970 (TREE_TYPE (value) == string_ptr_type_node &&
11971 ! flag_emit_class_files)))
11972 {
11973 /* Prepare node for patch_assignment */
11974 TREE_OPERAND (node, 1) = value;
11975 /* Call patch assignment to verify the assignment */
11976 if (patch_assignment (node, wfl_op1) == error_mark_node)
11977 return error_mark_node;
11978 /* Set DECL_INITIAL properly (a conversion might have
11979 been decided by patch_assignment) and return the
11980 empty statement. */
11981 else
11982 {
11983 tree patched = patch_string (TREE_OPERAND (node, 1));
11984 if (patched)
11985 DECL_INITIAL (nn) = patched;
11986 else
11987 DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11988 DECL_FIELD_FINAL_IUD (nn) = 1;
11989 return empty_stmt_node;
11990 }
11991 }
11992 if (! flag_emit_class_files)
11993 DECL_INITIAL (nn) = NULL_TREE;
11994 }
11995 wfl_op2 = TREE_OPERAND (node, 1);
11996
11997 if (TREE_OPERAND (node, 0) == error_mark_node)
11998 return error_mark_node;
11999
12000 flag = COMPOUND_ASSIGN_P (wfl_op2);
12001 if (flag)
12002 {
12003 /* This might break when accessing outer field from inner
12004 class. TESTME, FIXME */
12005 tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12006
12007 /* Hand stabilize the lhs on both places */
12008 TREE_OPERAND (node, 0) = lvalue;
12009 TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12010 (flag_emit_class_files ? lvalue : save_expr (lvalue));
12011
12012 /* 15.25.2.a: Left hand is not an array access. FIXME */
12013 /* Now complete the RHS. We write it back later on. */
12014 nn = java_complete_tree (TREE_OPERAND (node, 1));
12015
12016 if ((cn = patch_string (nn)))
12017 nn = cn;
12018
12019 /* The last part of the rewrite for E1 op= E2 is to have
12020 E1 = (T)(E1 op E2), with T being the type of E1. */
12021 nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12022 TREE_TYPE (lvalue), nn));
12023
12024 /* If the assignment is compound and has reference type,
12025 then ensure the LHS has type String and nothing else. */
12026 if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12027 && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12028 parse_error_context (wfl_op2,
12029 "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12030 lang_printable_name (TREE_TYPE (lvalue), 0));
12031
12032 /* 15.25.2.b: Left hand is an array access. FIXME */
12033 }
12034
12035 /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12036 function to complete this RHS. Note that a NEW_ARRAY_INIT
12037 might have been already fully expanded if created as a result
12038 of processing an anonymous array initializer. We avoid doing
12039 the operation twice by testing whether the node already bears
12040 a type. */
12041 else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12042 nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12043 TREE_OPERAND (node, 1));
12044 /* Otherwise we simply complete the RHS */
12045 else
12046 nn = java_complete_tree (TREE_OPERAND (node, 1));
12047
12048 if (nn == error_mark_node)
12049 return error_mark_node;
12050
12051 /* Write back the RHS as we evaluated it. */
12052 TREE_OPERAND (node, 1) = nn;
12053
12054 /* In case we're handling = with a String as a RHS, we need to
12055 produce a String out of the RHS (it might still be a
12056 STRING_CST or a StringBuffer at this stage */
12057 if ((nn = patch_string (TREE_OPERAND (node, 1))))
12058 TREE_OPERAND (node, 1) = nn;
12059
12060 if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12061 TREE_OPERAND (node, 1))))
12062 {
12063 /* We return error_mark_node if outer_field_access_fix
12064 detects we write into a final. */
12065 if (nn == error_mark_node)
12066 return error_mark_node;
12067 node = nn;
12068 }
12069 else
12070 {
12071 node = patch_assignment (node, wfl_op1);
12072 if (node == error_mark_node)
12073 return error_mark_node;
12074 /* Reorganize the tree if necessary. */
12075 if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12076 || JSTRING_P (TREE_TYPE (node))))
12077 node = java_refold (node);
12078 }
12079
12080 /* Seek to set DECL_INITIAL to a proper value, since it might have
12081 undergone a conversion in patch_assignment. We do that only when
12082 it's necessary to have DECL_INITIAL properly set. */
12083 nn = TREE_OPERAND (node, 0);
12084 if (TREE_CODE (nn) == VAR_DECL
12085 && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12086 && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12087 && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12088 || TREE_TYPE (nn) == string_ptr_type_node))
12089 DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12090
12091 CAN_COMPLETE_NORMALLY (node) = 1;
12092 return node;
12093
12094 case MULT_EXPR:
12095 case PLUS_EXPR:
12096 case MINUS_EXPR:
12097 case LSHIFT_EXPR:
12098 case RSHIFT_EXPR:
12099 case URSHIFT_EXPR:
12100 case BIT_AND_EXPR:
12101 case BIT_XOR_EXPR:
12102 case BIT_IOR_EXPR:
12103 case TRUNC_MOD_EXPR:
12104 case TRUNC_DIV_EXPR:
12105 case RDIV_EXPR:
12106 case TRUTH_ANDIF_EXPR:
12107 case TRUTH_ORIF_EXPR:
12108 case EQ_EXPR:
12109 case NE_EXPR:
12110 case GT_EXPR:
12111 case GE_EXPR:
12112 case LT_EXPR:
12113 case LE_EXPR:
12114 /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12115 knows how to handle those cases. */
12116 wfl_op1 = TREE_OPERAND (node, 0);
12117 wfl_op2 = TREE_OPERAND (node, 1);
12118
12119 CAN_COMPLETE_NORMALLY (node) = 1;
12120 /* Don't complete string nodes if dealing with the PLUS operand. */
12121 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12122 {
12123 nn = java_complete_tree (wfl_op1);
12124 if (nn == error_mark_node)
12125 return error_mark_node;
12126
12127 TREE_OPERAND (node, 0) = nn;
12128 }
12129 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12130 {
12131 nn = java_complete_tree (wfl_op2);
12132 if (nn == error_mark_node)
12133 return error_mark_node;
12134
12135 TREE_OPERAND (node, 1) = nn;
12136 }
12137 return patch_binop (node, wfl_op1, wfl_op2);
12138
12139 case INSTANCEOF_EXPR:
12140 wfl_op1 = TREE_OPERAND (node, 0);
12141 COMPLETE_CHECK_OP_0 (node);
12142 if (flag_emit_xref)
12143 {
12144 TREE_TYPE (node) = boolean_type_node;
12145 return node;
12146 }
12147 return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12148
12149 case UNARY_PLUS_EXPR:
12150 case NEGATE_EXPR:
12151 case TRUTH_NOT_EXPR:
12152 case BIT_NOT_EXPR:
12153 case PREDECREMENT_EXPR:
12154 case PREINCREMENT_EXPR:
12155 case POSTDECREMENT_EXPR:
12156 case POSTINCREMENT_EXPR:
12157 case CONVERT_EXPR:
12158 /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12159 how to handle those cases. */
12160 wfl_op1 = TREE_OPERAND (node, 0);
12161 CAN_COMPLETE_NORMALLY (node) = 1;
12162 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12163 if (TREE_OPERAND (node, 0) == error_mark_node)
12164 return error_mark_node;
12165 node = patch_unaryop (node, wfl_op1);
12166 CAN_COMPLETE_NORMALLY (node) = 1;
12167 break;
12168
12169 case ARRAY_REF:
12170 /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12171 how to handle those cases. */
12172 wfl_op1 = TREE_OPERAND (node, 0);
12173 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12174 if (TREE_OPERAND (node, 0) == error_mark_node)
12175 return error_mark_node;
12176 if (!flag_emit_class_files && !flag_emit_xref)
12177 TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12178 /* The same applies to wfl_op2 */
12179 wfl_op2 = TREE_OPERAND (node, 1);
12180 TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12181 if (TREE_OPERAND (node, 1) == error_mark_node)
12182 return error_mark_node;
12183 if (!flag_emit_class_files && !flag_emit_xref)
12184 TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12185 return patch_array_ref (node);
12186
12187 case RECORD_TYPE:
12188 return node;;
12189
12190 case COMPONENT_REF:
12191 /* The first step in the re-write of qualified name handling. FIXME.
12192 So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12193 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12194 if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12195 {
12196 tree name = TREE_OPERAND (node, 1);
12197 tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12198 if (field == NULL_TREE)
12199 {
12200 error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12201 return error_mark_node;
12202 }
12203 if (! FIELD_STATIC (field))
12204 {
12205 error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12206 return error_mark_node;
12207 }
12208 return field;
12209 }
12210 else
12211 abort ();
12212 break;
12213
12214 case THIS_EXPR:
12215 /* Can't use THIS in a static environment */
12216 if (!current_this)
12217 {
12218 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12219 parse_error_context (wfl_operator,
12220 "Keyword `this' used outside allowed context");
12221 TREE_TYPE (node) = error_mark_node;
12222 return error_mark_node;
12223 }
12224 if (ctxp->explicit_constructor_p)
12225 {
12226 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12227 parse_error_context
12228 (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12229 TREE_TYPE (node) = error_mark_node;
12230 return error_mark_node;
12231 }
12232 return current_this;
12233
12234 case CLASS_LITERAL:
12235 CAN_COMPLETE_NORMALLY (node) = 1;
12236 node = patch_incomplete_class_ref (node);
12237 if (node == error_mark_node)
12238 return error_mark_node;
12239 break;
12240
12241 default:
12242 CAN_COMPLETE_NORMALLY (node) = 1;
12243 /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12244 and it's time to turn it into the appropriate String object */
12245 if ((nn = patch_string (node)))
12246 node = nn;
12247 else
12248 internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12249 }
12250 return node;
12251 }
12252
12253 /* Complete function call's argument. Return a nonzero value is an
12254 error was found. */
12255
12256 static int
12257 complete_function_arguments (tree node)
12258 {
12259 int flag = 0;
12260 tree cn;
12261
12262 ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12263 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12264 {
12265 tree wfl = TREE_VALUE (cn), parm, temp;
12266 parm = java_complete_tree (wfl);
12267
12268 if (parm == error_mark_node)
12269 {
12270 flag = 1;
12271 continue;
12272 }
12273 /* If have a string literal that we haven't transformed yet or a
12274 crafted string buffer, as a result of use of the the String
12275 `+' operator. Build `parm.toString()' and expand it. */
12276 if ((temp = patch_string (parm)))
12277 parm = temp;
12278
12279 TREE_VALUE (cn) = parm;
12280 }
12281 ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12282 return flag;
12283 }
12284
12285 /* Sometimes (for loops and variable initialized during their
12286 declaration), we want to wrap a statement around a WFL and turn it
12287 debugable. */
12288
12289 static tree
12290 build_debugable_stmt (int location, tree stmt)
12291 {
12292 if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12293 {
12294 stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12295 EXPR_WFL_LINECOL (stmt) = location;
12296 }
12297 JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12298 return stmt;
12299 }
12300
12301 static tree
12302 build_expr_block (tree body, tree decls)
12303
12304 {
12305 tree node = make_node (BLOCK);
12306 BLOCK_EXPR_DECLS (node) = decls;
12307 BLOCK_EXPR_BODY (node) = body;
12308 if (body)
12309 TREE_TYPE (node) = TREE_TYPE (body);
12310 TREE_SIDE_EFFECTS (node) = 1;
12311 return node;
12312 }
12313
12314 /* Create a new function block and link it appropriately to current
12315 function block chain */
12316
12317 static tree
12318 enter_block (void)
12319 {
12320 tree b = build_expr_block (NULL_TREE, NULL_TREE);
12321
12322 /* Link block B supercontext to the previous block. The current
12323 function DECL is used as supercontext when enter_a_block is called
12324 for the first time for a given function. The current function body
12325 (DECL_FUNCTION_BODY) is set to be block B. */
12326
12327 tree fndecl = current_function_decl;
12328
12329 if (!fndecl) {
12330 BLOCK_SUPERCONTEXT (b) = current_static_block;
12331 current_static_block = b;
12332 }
12333
12334 else if (!DECL_FUNCTION_BODY (fndecl))
12335 {
12336 BLOCK_SUPERCONTEXT (b) = fndecl;
12337 DECL_FUNCTION_BODY (fndecl) = b;
12338 }
12339 else
12340 {
12341 BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12342 DECL_FUNCTION_BODY (fndecl) = b;
12343 }
12344 return b;
12345 }
12346
12347 /* Exit a block by changing the current function body
12348 (DECL_FUNCTION_BODY) to the current block super context, only if
12349 the block being exited isn't the method's top level one. */
12350
12351 static tree
12352 exit_block (void)
12353 {
12354 tree b;
12355 if (current_function_decl)
12356 {
12357 b = DECL_FUNCTION_BODY (current_function_decl);
12358 if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12359 DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12360 }
12361 else
12362 {
12363 b = current_static_block;
12364
12365 if (BLOCK_SUPERCONTEXT (b))
12366 current_static_block = BLOCK_SUPERCONTEXT (b);
12367 }
12368 return b;
12369 }
12370
12371 /* Lookup for NAME in the nested function's blocks, all the way up to
12372 the current toplevel one. It complies with Java's local variable
12373 scoping rules. */
12374
12375 static tree
12376 lookup_name_in_blocks (tree name)
12377 {
12378 tree b = GET_CURRENT_BLOCK (current_function_decl);
12379
12380 while (b != current_function_decl)
12381 {
12382 tree current;
12383
12384 /* Paranoid sanity check. To be removed */
12385 if (TREE_CODE (b) != BLOCK)
12386 abort ();
12387
12388 for (current = BLOCK_EXPR_DECLS (b); current;
12389 current = TREE_CHAIN (current))
12390 if (DECL_NAME (current) == name)
12391 return current;
12392 b = BLOCK_SUPERCONTEXT (b);
12393 }
12394 return NULL_TREE;
12395 }
12396
12397 static void
12398 maybe_absorb_scoping_blocks (void)
12399 {
12400 while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12401 {
12402 tree b = exit_block ();
12403 java_method_add_stmt (current_function_decl, b);
12404 SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12405 }
12406 }
12407
12408 \f
12409 /* This section of the source is reserved to build_* functions that
12410 are building incomplete tree nodes and the patch_* functions that
12411 are completing them. */
12412
12413 /* Wrap a non WFL node around a WFL. */
12414
12415 static tree
12416 build_wfl_wrap (tree node, int location)
12417 {
12418 tree wfl, node_to_insert = node;
12419
12420 /* We want to process THIS . xxx symbolically, to keep it consistent
12421 with the way we're processing SUPER. A THIS from a primary as a
12422 different form than a SUPER. Turn THIS into something symbolic */
12423 if (TREE_CODE (node) == THIS_EXPR)
12424 node_to_insert = wfl = build_wfl_node (this_identifier_node);
12425 else
12426 wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12427
12428 EXPR_WFL_LINECOL (wfl) = location;
12429 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12430 return wfl;
12431 }
12432
12433 /* Build a super() constructor invocation. Returns empty_stmt_node if
12434 we're currently dealing with the class java.lang.Object. */
12435
12436 static tree
12437 build_super_invocation (tree mdecl)
12438 {
12439 if (DECL_CONTEXT (mdecl) == object_type_node)
12440 return empty_stmt_node;
12441 else
12442 {
12443 tree super_wfl = build_wfl_node (super_identifier_node);
12444 tree a = NULL_TREE, t;
12445 /* If we're dealing with an anonymous class, pass the arguments
12446 of the crafted constructor along. */
12447 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12448 {
12449 SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12450 for (; t != end_params_node; t = TREE_CHAIN (t))
12451 a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12452 }
12453 return build_method_invocation (super_wfl, a);
12454 }
12455 }
12456
12457 /* Build a SUPER/THIS qualified method invocation. */
12458
12459 static tree
12460 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12461 int lloc, int rloc)
12462 {
12463 tree invok;
12464 tree wfl =
12465 build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12466 EXPR_WFL_LINECOL (wfl) = lloc;
12467 invok = build_method_invocation (name, args);
12468 return make_qualified_primary (wfl, invok, rloc);
12469 }
12470
12471 /* Build an incomplete CALL_EXPR node. */
12472
12473 static tree
12474 build_method_invocation (tree name, tree args)
12475 {
12476 tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12477 TREE_SIDE_EFFECTS (call) = 1;
12478 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12479 return call;
12480 }
12481
12482 /* Build an incomplete new xxx(...) node. */
12483
12484 static tree
12485 build_new_invocation (tree name, tree args)
12486 {
12487 tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12488 TREE_SIDE_EFFECTS (call) = 1;
12489 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12490 return call;
12491 }
12492
12493 /* Build an incomplete assignment expression. */
12494
12495 static tree
12496 build_assignment (int op, int op_location, tree lhs, tree rhs)
12497 {
12498 tree assignment;
12499 /* Build the corresponding binop if we deal with a Compound
12500 Assignment operator. Mark the binop sub-tree as part of a
12501 Compound Assignment expression */
12502 if (op != ASSIGN_TK)
12503 {
12504 rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12505 COMPOUND_ASSIGN_P (rhs) = 1;
12506 }
12507 assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12508 TREE_SIDE_EFFECTS (assignment) = 1;
12509 EXPR_WFL_LINECOL (assignment) = op_location;
12510 return assignment;
12511 }
12512
12513 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12514 the buffer. This is used only for string conversion. */
12515 static char *
12516 string_convert_int_cst (tree node)
12517 {
12518 /* Long.MIN_VALUE is -9223372036854775808, 20 characters. */
12519 static char buffer[21];
12520
12521 unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12522 unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12523 char *p = buffer + sizeof (buffer);
12524 int neg = 0;
12525
12526 unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12527 << (HOST_BITS_PER_WIDE_INT - 1));
12528
12529 *--p = '\0';
12530
12531 /* If negative, note the fact and negate the value. */
12532 if ((hi & hibit))
12533 {
12534 lo = ~lo;
12535 hi = ~hi;
12536 if (++lo == 0)
12537 ++hi;
12538 neg = 1;
12539 }
12540
12541 /* Divide by 10 until there are no bits left. */
12542 do
12543 {
12544 unsigned HOST_WIDE_INT acc = 0;
12545 unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12546 unsigned int i;
12547
12548 /* Use long division to compute the result and the remainder. */
12549 for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12550 {
12551 /* Shift a bit into accumulator. */
12552 acc <<= 1;
12553 if ((hi & hibit))
12554 acc |= 1;
12555
12556 /* Shift the value. */
12557 hi <<= 1;
12558 if ((lo & hibit))
12559 hi |= 1;
12560 lo <<= 1;
12561
12562 /* Shift the correct bit into the result. */
12563 outhi <<= 1;
12564 if ((outlo & hibit))
12565 outhi |= 1;
12566 outlo <<= 1;
12567 if (acc >= 10)
12568 {
12569 acc -= 10;
12570 outlo |= 1;
12571 }
12572 }
12573
12574 /* '0' == 060 in Java, but might not be here (think EBCDIC). */
12575 *--p = '\060' + acc;
12576
12577 hi = outhi;
12578 lo = outlo;
12579 }
12580 while (hi || lo);
12581
12582 if (neg)
12583 *--p = '\055'; /* '-' == 055 in Java, but might not be here. */
12584
12585 return p;
12586 }
12587
12588 /* Print an INTEGER_CST node in a static buffer, and return the
12589 buffer. This is used only for error handling. */
12590 char *
12591 print_int_node (tree node)
12592 {
12593 static char buffer [80];
12594 if (TREE_CONSTANT_OVERFLOW (node))
12595 sprintf (buffer, "<overflow>");
12596
12597 if (TREE_INT_CST_HIGH (node) == 0)
12598 sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12599 TREE_INT_CST_LOW (node));
12600 else if (TREE_INT_CST_HIGH (node) == -1
12601 && TREE_INT_CST_LOW (node) != 0)
12602 sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12603 -TREE_INT_CST_LOW (node));
12604 else
12605 sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12606 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12607
12608 return buffer;
12609 }
12610
12611 \f
12612 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12613 context. */
12614
12615 /* 15.25 Assignment operators. */
12616
12617 static tree
12618 patch_assignment (tree node, tree wfl_op1)
12619 {
12620 tree rhs = TREE_OPERAND (node, 1);
12621 tree lvalue = TREE_OPERAND (node, 0), llvalue;
12622 tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12623 int error_found = 0;
12624 int lvalue_from_array = 0;
12625 int is_return = 0;
12626
12627 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12628
12629 /* Lhs can be a named variable */
12630 if (JDECL_P (lvalue))
12631 {
12632 lhs_type = TREE_TYPE (lvalue);
12633 }
12634 /* Or Lhs can be an array access. */
12635 else if (TREE_CODE (lvalue) == ARRAY_REF)
12636 {
12637 lhs_type = TREE_TYPE (lvalue);
12638 lvalue_from_array = 1;
12639 }
12640 /* Or a field access */
12641 else if (TREE_CODE (lvalue) == COMPONENT_REF)
12642 lhs_type = TREE_TYPE (lvalue);
12643 /* Or a function return slot */
12644 else if (TREE_CODE (lvalue) == RESULT_DECL)
12645 {
12646 /* If the return type is an integral type, then we create the
12647 RESULT_DECL with a promoted type, but we need to do these
12648 checks against the unpromoted type to ensure type safety. So
12649 here we look at the real type, not the type of the decl we
12650 are modifying. */
12651 lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12652 is_return = 1;
12653 }
12654 /* Otherwise, we might want to try to write into an optimized static
12655 final, this is an of a different nature, reported further on. */
12656 else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12657 && resolve_expression_name (wfl_op1, &llvalue))
12658 {
12659 lhs_type = TREE_TYPE (lvalue);
12660 }
12661 else
12662 {
12663 parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12664 error_found = 1;
12665 }
12666
12667 rhs_type = TREE_TYPE (rhs);
12668
12669 /* 5.1 Try the assignment conversion for builtin type. */
12670 new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12671
12672 /* 5.2 If it failed, try a reference conversion */
12673 if (!new_rhs)
12674 new_rhs = try_reference_assignconv (lhs_type, rhs);
12675
12676 /* 15.25.2 If we have a compound assignment, convert RHS into the
12677 type of the LHS */
12678 else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12679 new_rhs = convert (lhs_type, rhs);
12680
12681 /* Explicit cast required. This is an error */
12682 if (!new_rhs)
12683 {
12684 char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12685 char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12686 tree wfl;
12687 char operation [32]; /* Max size known */
12688
12689 /* If the assignment is part of a declaration, we use the WFL of
12690 the declared variable to point out the error and call it a
12691 declaration problem. If the assignment is a genuine =
12692 operator, we call is a operator `=' problem, otherwise we
12693 call it an assignment problem. In both of these last cases,
12694 we use the WFL of the operator to indicate the error. */
12695
12696 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12697 {
12698 wfl = wfl_op1;
12699 strcpy (operation, "declaration");
12700 }
12701 else
12702 {
12703 wfl = wfl_operator;
12704 if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12705 strcpy (operation, "assignment");
12706 else if (is_return)
12707 strcpy (operation, "`return'");
12708 else
12709 strcpy (operation, "`='");
12710 }
12711
12712 if (!valid_cast_to_p (rhs_type, lhs_type))
12713 parse_error_context
12714 (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12715 operation, t1, t2);
12716 else
12717 parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12718 operation, t1, t2);
12719 free (t1); free (t2);
12720 error_found = 1;
12721 }
12722
12723 if (error_found)
12724 return error_mark_node;
12725
12726 /* If we're processing a `return' statement, promote the actual type
12727 to the promoted type. */
12728 if (is_return)
12729 new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12730
12731 /* 10.10: Array Store Exception runtime check */
12732 if (!flag_emit_class_files
12733 && !flag_emit_xref
12734 && lvalue_from_array
12735 && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12736 {
12737 tree array, store_check, base, index_expr;
12738
12739 /* Save RHS so that it doesn't get re-evaluated by the store check. */
12740 new_rhs = save_expr (new_rhs);
12741
12742 /* Get the INDIRECT_REF. */
12743 array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12744 /* Get the array pointer expr. */
12745 array = TREE_OPERAND (array, 0);
12746 store_check = build_java_arraystore_check (array, new_rhs);
12747
12748 index_expr = TREE_OPERAND (lvalue, 1);
12749
12750 if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12751 {
12752 /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12753 happen before the store check, so prepare to insert the store
12754 check within the second operand of the existing COMPOUND_EXPR. */
12755 base = index_expr;
12756 }
12757 else
12758 base = lvalue;
12759
12760 index_expr = TREE_OPERAND (base, 1);
12761 TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12762 store_check, index_expr);
12763 }
12764
12765 /* Final locals can be used as case values in switch
12766 statement. Prepare them for this eventuality. */
12767 if (TREE_CODE (lvalue) == VAR_DECL
12768 && DECL_FINAL (lvalue)
12769 && TREE_CONSTANT (new_rhs)
12770 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12771 && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12772 )
12773 {
12774 TREE_CONSTANT (lvalue) = 1;
12775 DECL_INITIAL (lvalue) = new_rhs;
12776 }
12777
12778 /* Copy the rhs if it's a reference. */
12779 if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12780 {
12781 switch (TREE_CODE (new_rhs))
12782 {
12783 case ARRAY_REF:
12784 case INDIRECT_REF:
12785 case COMPONENT_REF:
12786 /* Transform a = foo.bar
12787 into a = { int tmp; tmp = foo.bar; tmp; ).
12788 We need to ensure that if a read from memory fails
12789 because of a NullPointerException, a destination variable
12790 will remain unchanged. An explicit temporary does what
12791 we need.
12792
12793 If flag_check_references is set, this is unnecessary
12794 because we'll check each reference before doing any
12795 reads. If optimize is not set the result will never be
12796 written to a stack slot that contains the LHS. */
12797 {
12798 tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12799 TREE_TYPE (new_rhs));
12800 tree block = make_node (BLOCK);
12801 tree assignment
12802 = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12803 DECL_CONTEXT (tmp) = current_function_decl;
12804 TREE_TYPE (block) = TREE_TYPE (new_rhs);
12805 BLOCK_VARS (block) = tmp;
12806 BLOCK_EXPR_BODY (block)
12807 = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
12808 TREE_SIDE_EFFECTS (block) = 1;
12809 new_rhs = block;
12810 }
12811 break;
12812 default:
12813 break;
12814 }
12815 }
12816
12817 TREE_OPERAND (node, 0) = lvalue;
12818 TREE_OPERAND (node, 1) = new_rhs;
12819 TREE_TYPE (node) = lhs_type;
12820 return node;
12821 }
12822
12823 /* Check that type SOURCE can be cast into type DEST. If the cast
12824 can't occur at all, return NULL; otherwise, return a possibly
12825 modified rhs. */
12826
12827 static tree
12828 try_reference_assignconv (tree lhs_type, tree rhs)
12829 {
12830 tree new_rhs = NULL_TREE;
12831 tree rhs_type = TREE_TYPE (rhs);
12832
12833 if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12834 {
12835 /* `null' may be assigned to any reference type */
12836 if (rhs == null_pointer_node)
12837 new_rhs = null_pointer_node;
12838 /* Try the reference assignment conversion */
12839 else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12840 new_rhs = rhs;
12841 /* This is a magic assignment that we process differently */
12842 else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12843 new_rhs = rhs;
12844 }
12845 return new_rhs;
12846 }
12847
12848 /* Check that RHS can be converted into LHS_TYPE by the assignment
12849 conversion (5.2), for the cases of RHS being a builtin type. Return
12850 NULL_TREE if the conversion fails or if because RHS isn't of a
12851 builtin type. Return a converted RHS if the conversion is possible. */
12852
12853 static tree
12854 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12855 {
12856 tree new_rhs = NULL_TREE;
12857 tree rhs_type = TREE_TYPE (rhs);
12858
12859 /* Handle boolean specially. */
12860 if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12861 || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12862 {
12863 if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12864 && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12865 new_rhs = rhs;
12866 }
12867
12868 /* 5.1.1 Try Identity Conversion,
12869 5.1.2 Try Widening Primitive Conversion */
12870 else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12871 new_rhs = convert (lhs_type, rhs);
12872
12873 /* Try a narrowing primitive conversion (5.1.3):
12874 - expression is a constant expression of type byte, short, char,
12875 or int, AND
12876 - variable is byte, short or char AND
12877 - The value of the expression is representable in the type of the
12878 variable */
12879 else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12880 || rhs_type == char_type_node || rhs_type == int_type_node)
12881 && TREE_CONSTANT (rhs)
12882 && (lhs_type == byte_type_node || lhs_type == char_type_node
12883 || lhs_type == short_type_node))
12884 {
12885 if (int_fits_type_p (rhs, lhs_type))
12886 new_rhs = convert (lhs_type, rhs);
12887 else if (wfl_op1) /* Might be called with a NULL */
12888 parse_warning_context
12889 (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12890 print_int_node (rhs), lang_printable_name (lhs_type, 0));
12891 /* Reported a warning that will turn into an error further
12892 down, so we don't return */
12893 }
12894
12895 return new_rhs;
12896 }
12897
12898 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12899 conversion (5.1.1) or widening primitive conversion (5.1.2). Return
12900 0 is the conversion test fails. This implements parts the method
12901 invocation conversion (5.3). */
12902
12903 static int
12904 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12905 {
12906 /* 5.1.1: This is the identity conversion part. */
12907 if (lhs_type == rhs_type)
12908 return 1;
12909
12910 /* Reject non primitive types and boolean conversions. */
12911 if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12912 return 0;
12913
12914 /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12915 than a char can't be converted into a char. Short can't too, but
12916 the < test below takes care of that */
12917 if (lhs_type == char_type_node && rhs_type == byte_type_node)
12918 return 0;
12919
12920 /* Accept all promoted type here. Note, we can't use <= in the test
12921 below, because we still need to bounce out assignments of short
12922 to char and the likes */
12923 if (lhs_type == int_type_node
12924 && (rhs_type == promoted_byte_type_node
12925 || rhs_type == promoted_short_type_node
12926 || rhs_type == promoted_char_type_node
12927 || rhs_type == promoted_boolean_type_node))
12928 return 1;
12929
12930 /* From here, an integral is widened if its precision is smaller
12931 than the precision of the LHS or if the LHS is a floating point
12932 type, or the RHS is a float and the RHS a double. */
12933 if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12934 && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12935 || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12936 || (rhs_type == float_type_node && lhs_type == double_type_node))
12937 return 1;
12938
12939 return 0;
12940 }
12941
12942 /* Check that something of SOURCE type can be assigned or cast to
12943 something of DEST type at runtime. Return 1 if the operation is
12944 valid, 0 otherwise. If CAST is set to 1, we're treating the case
12945 were SOURCE is cast into DEST, which borrows a lot of the
12946 assignment check. */
12947
12948 static int
12949 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12950 {
12951 /* SOURCE or DEST might be null if not from a declared entity. */
12952 if (!source || !dest)
12953 return 0;
12954 if (JNULLP_TYPE_P (source))
12955 return 1;
12956 if (TREE_CODE (source) == POINTER_TYPE)
12957 source = TREE_TYPE (source);
12958 if (TREE_CODE (dest) == POINTER_TYPE)
12959 dest = TREE_TYPE (dest);
12960
12961 /* If source and dest are being compiled from bytecode, they may need to
12962 be loaded. */
12963 if (CLASS_P (source) && !CLASS_LOADED_P (source))
12964 {
12965 load_class (source, 1);
12966 safe_layout_class (source);
12967 }
12968 if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12969 {
12970 load_class (dest, 1);
12971 safe_layout_class (dest);
12972 }
12973
12974 /* Case where SOURCE is a class type */
12975 if (TYPE_CLASS_P (source))
12976 {
12977 if (TYPE_CLASS_P (dest))
12978 return (source == dest
12979 || inherits_from_p (source, dest)
12980 || (cast && inherits_from_p (dest, source)));
12981 if (TYPE_INTERFACE_P (dest))
12982 {
12983 /* If doing a cast and SOURCE is final, the operation is
12984 always correct a compile time (because even if SOURCE
12985 does not implement DEST, a subclass of SOURCE might). */
12986 if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12987 return 1;
12988 /* Otherwise, SOURCE must implement DEST */
12989 return interface_of_p (dest, source);
12990 }
12991 /* DEST is an array, cast permitted if SOURCE is of Object type */
12992 return (cast && source == object_type_node ? 1 : 0);
12993 }
12994 if (TYPE_INTERFACE_P (source))
12995 {
12996 if (TYPE_CLASS_P (dest))
12997 {
12998 /* If not casting, DEST must be the Object type */
12999 if (!cast)
13000 return dest == object_type_node;
13001 /* We're doing a cast. The cast is always valid is class
13002 DEST is not final, otherwise, DEST must implement SOURCE */
13003 else if (!CLASS_FINAL (TYPE_NAME (dest)))
13004 return 1;
13005 else
13006 return interface_of_p (source, dest);
13007 }
13008 if (TYPE_INTERFACE_P (dest))
13009 {
13010 /* If doing a cast, then if SOURCE and DEST contain method
13011 with the same signature but different return type, then
13012 this is a (compile time) error */
13013 if (cast)
13014 {
13015 tree method_source, method_dest;
13016 tree source_type;
13017 tree source_sig;
13018 tree source_name;
13019 for (method_source = TYPE_METHODS (source); method_source;
13020 method_source = TREE_CHAIN (method_source))
13021 {
13022 source_sig =
13023 build_java_argument_signature (TREE_TYPE (method_source));
13024 source_type = TREE_TYPE (TREE_TYPE (method_source));
13025 source_name = DECL_NAME (method_source);
13026 for (method_dest = TYPE_METHODS (dest);
13027 method_dest; method_dest = TREE_CHAIN (method_dest))
13028 if (source_sig ==
13029 build_java_argument_signature (TREE_TYPE (method_dest))
13030 && source_name == DECL_NAME (method_dest)
13031 && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13032 return 0;
13033 }
13034 return 1;
13035 }
13036 else
13037 return source == dest || interface_of_p (dest, source);
13038 }
13039 else
13040 {
13041 /* Array */
13042 return (cast
13043 && (DECL_NAME (TYPE_NAME (source))
13044 == java_lang_cloneable_identifier_node
13045 || (DECL_NAME (TYPE_NAME (source))
13046 == java_io_serializable_identifier_node)));
13047 }
13048 }
13049 if (TYPE_ARRAY_P (source))
13050 {
13051 if (TYPE_CLASS_P (dest))
13052 return dest == object_type_node;
13053 /* Can't cast an array to an interface unless the interface is
13054 java.lang.Cloneable or java.io.Serializable. */
13055 if (TYPE_INTERFACE_P (dest))
13056 return (DECL_NAME (TYPE_NAME (dest))
13057 == java_lang_cloneable_identifier_node
13058 || (DECL_NAME (TYPE_NAME (dest))
13059 == java_io_serializable_identifier_node));
13060 else /* Arrays */
13061 {
13062 tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13063 tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13064
13065 /* In case of severe errors, they turn out null */
13066 if (!dest_element_type || !source_element_type)
13067 return 0;
13068 if (source_element_type == dest_element_type)
13069 return 1;
13070 return valid_ref_assignconv_cast_p (source_element_type,
13071 dest_element_type, cast);
13072 }
13073 return 0;
13074 }
13075 return 0;
13076 }
13077
13078 static int
13079 valid_cast_to_p (tree source, tree dest)
13080 {
13081 if (TREE_CODE (source) == POINTER_TYPE)
13082 source = TREE_TYPE (source);
13083 if (TREE_CODE (dest) == POINTER_TYPE)
13084 dest = TREE_TYPE (dest);
13085
13086 if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13087 return valid_ref_assignconv_cast_p (source, dest, 1);
13088
13089 else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13090 return 1;
13091
13092 else if (TREE_CODE (source) == BOOLEAN_TYPE
13093 && TREE_CODE (dest) == BOOLEAN_TYPE)
13094 return 1;
13095
13096 return 0;
13097 }
13098
13099 static tree
13100 do_unary_numeric_promotion (tree arg)
13101 {
13102 tree type = TREE_TYPE (arg);
13103 if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13104 || TREE_CODE (type) == CHAR_TYPE)
13105 arg = convert (int_type_node, arg);
13106 return arg;
13107 }
13108
13109 /* Return a nonzero value if SOURCE can be converted into DEST using
13110 the method invocation conversion rule (5.3). */
13111 static int
13112 valid_method_invocation_conversion_p (tree dest, tree source)
13113 {
13114 return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13115 && valid_builtin_assignconv_identity_widening_p (dest, source))
13116 || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13117 && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13118 && valid_ref_assignconv_cast_p (source, dest, 0)));
13119 }
13120
13121 /* Build an incomplete binop expression. */
13122
13123 static tree
13124 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13125 {
13126 tree binop = build (op, NULL_TREE, op1, op2);
13127 TREE_SIDE_EFFECTS (binop) = 1;
13128 /* Store the location of the operator, for better error report. The
13129 string of the operator will be rebuild based on the OP value. */
13130 EXPR_WFL_LINECOL (binop) = op_location;
13131 return binop;
13132 }
13133
13134 /* Build the string of the operator retained by NODE. If NODE is part
13135 of a compound expression, add an '=' at the end of the string. This
13136 function is called when an error needs to be reported on an
13137 operator. The string is returned as a pointer to a static character
13138 buffer. */
13139
13140 static char *
13141 operator_string (tree node)
13142 {
13143 #define BUILD_OPERATOR_STRING(S) \
13144 { \
13145 sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13146 return buffer; \
13147 }
13148
13149 static char buffer [10];
13150 switch (TREE_CODE (node))
13151 {
13152 case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13153 case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13154 case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13155 case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13156 case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13157 case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13158 case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13159 case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13160 case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13161 case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13162 case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13163 case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13164 case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13165 case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13166 case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13167 case GT_EXPR: BUILD_OPERATOR_STRING (">");
13168 case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13169 case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13170 case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13171 case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13172 case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13173 case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13174 case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13175 case PREINCREMENT_EXPR: /* Fall through */
13176 case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13177 case PREDECREMENT_EXPR: /* Fall through */
13178 case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13179 default:
13180 internal_error ("unregistered operator %s",
13181 tree_code_name [TREE_CODE (node)]);
13182 }
13183 return NULL;
13184 #undef BUILD_OPERATOR_STRING
13185 }
13186
13187 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
13188
13189 static int
13190 java_decl_equiv (tree var_acc1, tree var_acc2)
13191 {
13192 if (JDECL_P (var_acc1))
13193 return (var_acc1 == var_acc2);
13194
13195 return (TREE_CODE (var_acc1) == COMPONENT_REF
13196 && TREE_CODE (var_acc2) == COMPONENT_REF
13197 && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13198 == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13199 && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13200 }
13201
13202 /* Return a nonzero value if CODE is one of the operators that can be
13203 used in conjunction with the `=' operator in a compound assignment. */
13204
13205 static int
13206 binop_compound_p (enum tree_code code)
13207 {
13208 int i;
13209 for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13210 if (binop_lookup [i] == code)
13211 break;
13212
13213 return i < BINOP_COMPOUND_CANDIDATES;
13214 }
13215
13216 /* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
13217
13218 static tree
13219 java_refold (tree t)
13220 {
13221 tree c, b, ns, decl;
13222
13223 if (TREE_CODE (t) != MODIFY_EXPR)
13224 return t;
13225
13226 c = TREE_OPERAND (t, 1);
13227 if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13228 && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13229 && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13230 return t;
13231
13232 /* Now the left branch of the binary operator. */
13233 b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13234 if (! (b && TREE_CODE (b) == NOP_EXPR
13235 && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13236 return t;
13237
13238 ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13239 if (! (ns && TREE_CODE (ns) == NOP_EXPR
13240 && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13241 return t;
13242
13243 decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13244 if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13245 /* It's got to be the an equivalent decl */
13246 && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13247 {
13248 /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13249 TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13250 /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13251 TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13252 /* Change the right part of the BINOP_EXPR */
13253 TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13254 }
13255
13256 return t;
13257 }
13258
13259 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13260 errors but we modify NODE so that it contains the type computed
13261 according to the expression, when it's fixed. Otherwise, we write
13262 error_mark_node as the type. It allows us to further the analysis
13263 of remaining nodes and detects more errors in certain cases. */
13264
13265 static tree
13266 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13267 {
13268 tree op1 = TREE_OPERAND (node, 0);
13269 tree op2 = TREE_OPERAND (node, 1);
13270 tree op1_type = TREE_TYPE (op1);
13271 tree op2_type = TREE_TYPE (op2);
13272 tree prom_type = NULL_TREE, cn;
13273 enum tree_code code = TREE_CODE (node);
13274
13275 /* If 1, tell the routine that we have to return error_mark_node
13276 after checking for the initialization of the RHS */
13277 int error_found = 0;
13278
13279 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13280
13281 /* If either op<n>_type are NULL, this might be early signs of an
13282 error situation, unless it's too early to tell (in case we're
13283 handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13284 correctly so the error can be later on reported accurately. */
13285 if (! (code == PLUS_EXPR || code == NE_EXPR
13286 || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13287 {
13288 tree n;
13289 if (! op1_type)
13290 {
13291 n = java_complete_tree (op1);
13292 op1_type = TREE_TYPE (n);
13293 }
13294 if (! op2_type)
13295 {
13296 n = java_complete_tree (op2);
13297 op2_type = TREE_TYPE (n);
13298 }
13299 }
13300
13301 switch (code)
13302 {
13303 /* 15.16 Multiplicative operators */
13304 case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
13305 case RDIV_EXPR: /* 15.16.2 Division Operator / */
13306 case TRUNC_DIV_EXPR: /* 15.16.2 Integral type Division Operator / */
13307 case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
13308 if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13309 {
13310 if (!JNUMERIC_TYPE_P (op1_type))
13311 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13312 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13313 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13314 TREE_TYPE (node) = error_mark_node;
13315 error_found = 1;
13316 break;
13317 }
13318 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13319
13320 /* Detect integral division by zero */
13321 if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13322 && TREE_CODE (prom_type) == INTEGER_TYPE
13323 && (op2 == integer_zero_node || op2 == long_zero_node ||
13324 (TREE_CODE (op2) == INTEGER_CST &&
13325 ! TREE_INT_CST_LOW (op2) && ! TREE_INT_CST_HIGH (op2))))
13326 {
13327 parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13328 TREE_CONSTANT (node) = 0;
13329 }
13330
13331 /* Change the division operator if necessary */
13332 if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13333 TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13334
13335 /* Before divisions as is disappear, try to simplify and bail if
13336 applicable, otherwise we won't perform even simple
13337 simplifications like (1-1)/3. We can't do that with floating
13338 point number, folds can't handle them at this stage. */
13339 if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13340 && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13341 {
13342 TREE_TYPE (node) = prom_type;
13343 node = fold (node);
13344 if (TREE_CODE (node) != code)
13345 return node;
13346 }
13347
13348 if (TREE_CODE (prom_type) == INTEGER_TYPE
13349 && flag_use_divide_subroutine
13350 && ! flag_emit_class_files
13351 && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13352 return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13353
13354 /* This one is more complicated. FLOATs are processed by a
13355 function call to soft_fmod. Duplicate the value of the
13356 COMPOUND_ASSIGN_P flag. */
13357 if (code == TRUNC_MOD_EXPR)
13358 {
13359 tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13360 COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13361 TREE_SIDE_EFFECTS (mod)
13362 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13363 return mod;
13364 }
13365 break;
13366
13367 /* 15.17 Additive Operators */
13368 case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
13369
13370 /* Operation is valid if either one argument is a string
13371 constant, a String object or a StringBuffer crafted for the
13372 purpose of the a previous usage of the String concatenation
13373 operator */
13374
13375 if (TREE_CODE (op1) == STRING_CST
13376 || TREE_CODE (op2) == STRING_CST
13377 || JSTRING_TYPE_P (op1_type)
13378 || JSTRING_TYPE_P (op2_type)
13379 || IS_CRAFTED_STRING_BUFFER_P (op1)
13380 || IS_CRAFTED_STRING_BUFFER_P (op2))
13381 return build_string_concatenation (op1, op2);
13382
13383 case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
13384 Numeric Types */
13385 if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13386 {
13387 if (!JNUMERIC_TYPE_P (op1_type))
13388 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13389 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13390 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13391 TREE_TYPE (node) = error_mark_node;
13392 error_found = 1;
13393 break;
13394 }
13395 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13396 break;
13397
13398 /* 15.18 Shift Operators */
13399 case LSHIFT_EXPR:
13400 case RSHIFT_EXPR:
13401 case URSHIFT_EXPR:
13402 if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13403 {
13404 if (!JINTEGRAL_TYPE_P (op1_type))
13405 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13406 else
13407 {
13408 if (JNUMERIC_TYPE_P (op2_type))
13409 parse_error_context (wfl_operator,
13410 "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13411 operator_string (node),
13412 lang_printable_name (op2_type, 0));
13413 else
13414 parse_error_context (wfl_operator,
13415 "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13416 operator_string (node),
13417 lang_printable_name (op2_type, 0));
13418 }
13419 TREE_TYPE (node) = error_mark_node;
13420 error_found = 1;
13421 break;
13422 }
13423
13424 /* Unary numeric promotion (5.6.1) is performed on each operand
13425 separately */
13426 op1 = do_unary_numeric_promotion (op1);
13427 op2 = do_unary_numeric_promotion (op2);
13428
13429 /* If the right hand side is of type `long', first cast it to
13430 `int'. */
13431 if (TREE_TYPE (op2) == long_type_node)
13432 op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13433
13434 /* The type of the shift expression is the type of the promoted
13435 type of the left-hand operand */
13436 prom_type = TREE_TYPE (op1);
13437
13438 /* Shift int only up to 0x1f and long up to 0x3f */
13439 if (prom_type == int_type_node)
13440 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13441 build_int_2 (0x1f, 0)));
13442 else
13443 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13444 build_int_2 (0x3f, 0)));
13445
13446 /* The >>> operator is a >> operating on unsigned quantities */
13447 if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13448 {
13449 tree to_return;
13450 tree utype = java_unsigned_type (prom_type);
13451 op1 = convert (utype, op1);
13452 TREE_SET_CODE (node, RSHIFT_EXPR);
13453 TREE_OPERAND (node, 0) = op1;
13454 TREE_OPERAND (node, 1) = op2;
13455 TREE_TYPE (node) = utype;
13456 to_return = convert (prom_type, node);
13457 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13458 COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13459 TREE_SIDE_EFFECTS (to_return)
13460 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13461 return to_return;
13462 }
13463 break;
13464
13465 /* 15.19.1 Type Comparison Operator instanceof */
13466 case INSTANCEOF_EXPR:
13467
13468 TREE_TYPE (node) = boolean_type_node;
13469
13470 /* OP1_TYPE might be NULL when OP1 is a string constant. */
13471 if ((cn = patch_string (op1)))
13472 {
13473 op1 = cn;
13474 op1_type = TREE_TYPE (op1);
13475 }
13476 if (op1_type == NULL_TREE)
13477 abort ();
13478
13479 if (!(op2_type = resolve_type_during_patch (op2)))
13480 return error_mark_node;
13481
13482 /* The first operand must be a reference type or the null type */
13483 if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13484 error_found = 1; /* Error reported further below */
13485
13486 /* The second operand must be a reference type */
13487 if (!JREFERENCE_TYPE_P (op2_type))
13488 {
13489 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13490 parse_error_context
13491 (wfl_operator, "Invalid argument `%s' for `instanceof'",
13492 lang_printable_name (op2_type, 0));
13493 error_found = 1;
13494 }
13495
13496 if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13497 {
13498 /* If the first operand is null, the result is always false */
13499 if (op1 == null_pointer_node)
13500 return boolean_false_node;
13501 else if (flag_emit_class_files)
13502 {
13503 TREE_OPERAND (node, 1) = op2_type;
13504 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13505 return node;
13506 }
13507 /* Otherwise we have to invoke instance of to figure it out */
13508 else
13509 return build_instanceof (op1, op2_type);
13510 }
13511 /* There is no way the expression operand can be an instance of
13512 the type operand. This is a compile time error. */
13513 else
13514 {
13515 char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13516 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13517 parse_error_context
13518 (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13519 t1, lang_printable_name (op2_type, 0));
13520 free (t1);
13521 error_found = 1;
13522 }
13523
13524 break;
13525
13526 /* 15.21 Bitwise and Logical Operators */
13527 case BIT_AND_EXPR:
13528 case BIT_XOR_EXPR:
13529 case BIT_IOR_EXPR:
13530 if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13531 /* Binary numeric promotion is performed on both operand and the
13532 expression retain that type */
13533 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13534
13535 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13536 && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13537 /* The type of the bitwise operator expression is BOOLEAN */
13538 prom_type = boolean_type_node;
13539 else
13540 {
13541 if (!JINTEGRAL_TYPE_P (op1_type))
13542 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13543 if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13544 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13545 TREE_TYPE (node) = error_mark_node;
13546 error_found = 1;
13547 /* Insert a break here if adding thing before the switch's
13548 break for this case */
13549 }
13550 break;
13551
13552 /* 15.22 Conditional-And Operator */
13553 case TRUTH_ANDIF_EXPR:
13554 /* 15.23 Conditional-Or Operator */
13555 case TRUTH_ORIF_EXPR:
13556 /* Operands must be of BOOLEAN type */
13557 if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13558 TREE_CODE (op2_type) != BOOLEAN_TYPE)
13559 {
13560 if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13561 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13562 if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13563 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13564 TREE_TYPE (node) = boolean_type_node;
13565 error_found = 1;
13566 break;
13567 }
13568 else if (integer_zerop (op1))
13569 {
13570 return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13571 }
13572 else if (integer_onep (op1))
13573 {
13574 return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13575 }
13576 /* The type of the conditional operators is BOOLEAN */
13577 prom_type = boolean_type_node;
13578 break;
13579
13580 /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13581 case LT_EXPR:
13582 case GT_EXPR:
13583 case LE_EXPR:
13584 case GE_EXPR:
13585 /* The type of each of the operands must be a primitive numeric
13586 type */
13587 if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13588 {
13589 if (!JNUMERIC_TYPE_P (op1_type))
13590 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13591 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13592 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13593 TREE_TYPE (node) = boolean_type_node;
13594 error_found = 1;
13595 break;
13596 }
13597 /* Binary numeric promotion is performed on the operands */
13598 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13599 /* The type of the relation expression is always BOOLEAN */
13600 prom_type = boolean_type_node;
13601 break;
13602
13603 /* 15.20 Equality Operator */
13604 case EQ_EXPR:
13605 case NE_EXPR:
13606 /* It's time for us to patch the strings. */
13607 if ((cn = patch_string (op1)))
13608 {
13609 op1 = cn;
13610 op1_type = TREE_TYPE (op1);
13611 }
13612 if ((cn = patch_string (op2)))
13613 {
13614 op2 = cn;
13615 op2_type = TREE_TYPE (op2);
13616 }
13617
13618 /* 15.20.1 Numerical Equality Operators == and != */
13619 /* Binary numeric promotion is performed on the operands */
13620 if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13621 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13622
13623 /* 15.20.2 Boolean Equality Operators == and != */
13624 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13625 TREE_CODE (op2_type) == BOOLEAN_TYPE)
13626 ; /* Nothing to do here */
13627
13628 /* 15.20.3 Reference Equality Operators == and != */
13629 /* Types have to be either references or the null type. If
13630 they're references, it must be possible to convert either
13631 type to the other by casting conversion. */
13632 else if (op1 == null_pointer_node || op2 == null_pointer_node
13633 || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13634 && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13635 || valid_ref_assignconv_cast_p (op2_type,
13636 op1_type, 1))))
13637 ; /* Nothing to do here */
13638
13639 /* Else we have an error figure what can't be converted into
13640 what and report the error */
13641 else
13642 {
13643 char *t1;
13644 t1 = xstrdup (lang_printable_name (op1_type, 0));
13645 parse_error_context
13646 (wfl_operator,
13647 "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13648 operator_string (node), t1,
13649 lang_printable_name (op2_type, 0));
13650 free (t1);
13651 TREE_TYPE (node) = boolean_type_node;
13652 error_found = 1;
13653 break;
13654 }
13655 prom_type = boolean_type_node;
13656 break;
13657 default:
13658 abort ();
13659 }
13660
13661 if (error_found)
13662 return error_mark_node;
13663
13664 TREE_OPERAND (node, 0) = op1;
13665 TREE_OPERAND (node, 1) = op2;
13666 TREE_TYPE (node) = prom_type;
13667 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13668
13669 if (flag_emit_xref)
13670 return node;
13671
13672 /* fold does not respect side-effect order as required for Java but not C.
13673 * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13674 * bytecode.
13675 */
13676 if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13677 : ! TREE_SIDE_EFFECTS (node))
13678 node = fold (node);
13679 return node;
13680 }
13681
13682 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13683 zero value, the value of CSTE comes after the valude of STRING */
13684
13685 static tree
13686 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13687 {
13688 const char *old = TREE_STRING_POINTER (cste);
13689 int old_len = TREE_STRING_LENGTH (cste);
13690 int len = old_len + string_len;
13691 char *new = alloca (len+1);
13692
13693 if (after)
13694 {
13695 memcpy (new, string, string_len);
13696 memcpy (&new [string_len], old, old_len);
13697 }
13698 else
13699 {
13700 memcpy (new, old, old_len);
13701 memcpy (&new [old_len], string, string_len);
13702 }
13703 new [len] = '\0';
13704 return build_string (len, new);
13705 }
13706
13707 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13708 new STRING_CST on success, NULL_TREE on failure. */
13709
13710 static tree
13711 merge_string_cste (tree op1, tree op2, int after)
13712 {
13713 /* Handle two string constants right away. */
13714 if (TREE_CODE (op2) == STRING_CST)
13715 return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13716 TREE_STRING_LENGTH (op2), after);
13717
13718 /* Reasonable integer constant can be treated right away. */
13719 if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13720 {
13721 static const char *const boolean_true = "true";
13722 static const char *const boolean_false = "false";
13723 static const char *const null_pointer = "null";
13724 char ch[4];
13725 const char *string;
13726
13727 if (op2 == boolean_true_node)
13728 string = boolean_true;
13729 else if (op2 == boolean_false_node)
13730 string = boolean_false;
13731 else if (op2 == null_pointer_node
13732 || (integer_zerop (op2)
13733 && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13734 /* FIXME: null is not a compile-time constant, so it is only safe to
13735 merge if the overall expression is non-constant. However, this
13736 code always merges without checking the overall expression. */
13737 string = null_pointer;
13738 else if (TREE_TYPE (op2) == char_type_node)
13739 {
13740 /* Convert the character into UTF-8. */
13741 unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13742 unsigned char *p = (unsigned char *) ch;
13743 if (0x01 <= c && c <= 0x7f)
13744 *p++ = (unsigned char) c;
13745 else if (c < 0x7ff)
13746 {
13747 *p++ = (unsigned char) (c >> 6 | 0xc0);
13748 *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13749 }
13750 else
13751 {
13752 *p++ = (unsigned char) (c >> 12 | 0xe0);
13753 *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13754 *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13755 }
13756 *p = '\0';
13757
13758 string = ch;
13759 }
13760 else
13761 string = string_convert_int_cst (op2);
13762
13763 return do_merge_string_cste (op1, string, strlen (string), after);
13764 }
13765 return NULL_TREE;
13766 }
13767
13768 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13769 has to be a STRING_CST and the other part must be a STRING_CST or a
13770 INTEGRAL constant. Return a new STRING_CST if the operation
13771 succeed, NULL_TREE otherwise.
13772
13773 If the case we want to optimize for space, we might want to return
13774 NULL_TREE for each invocation of this routine. FIXME */
13775
13776 static tree
13777 string_constant_concatenation (tree op1, tree op2)
13778 {
13779 if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13780 {
13781 tree string, rest;
13782 int invert;
13783
13784 string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13785 rest = (string == op1 ? op2 : op1);
13786 invert = (string == op1 ? 0 : 1 );
13787
13788 /* Walk REST, only if it looks reasonable */
13789 if (TREE_CODE (rest) != STRING_CST
13790 && !IS_CRAFTED_STRING_BUFFER_P (rest)
13791 && !JSTRING_TYPE_P (TREE_TYPE (rest))
13792 && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13793 {
13794 rest = java_complete_tree (rest);
13795 if (rest == error_mark_node)
13796 return error_mark_node;
13797 rest = fold (rest);
13798 }
13799 return merge_string_cste (string, rest, invert);
13800 }
13801 return NULL_TREE;
13802 }
13803
13804 /* Implement the `+' operator. Does static optimization if possible,
13805 otherwise create (if necessary) and append elements to a
13806 StringBuffer. The StringBuffer will be carried around until it is
13807 used for a function call or an assignment. Then toString() will be
13808 called on it to turn it into a String object. */
13809
13810 static tree
13811 build_string_concatenation (tree op1, tree op2)
13812 {
13813 tree result;
13814 int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13815
13816 if (flag_emit_xref)
13817 return build (PLUS_EXPR, string_type_node, op1, op2);
13818
13819 /* Try to do some static optimization */
13820 if ((result = string_constant_concatenation (op1, op2)))
13821 return result;
13822
13823 /* Discard empty strings on either side of the expression */
13824 if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13825 {
13826 op1 = op2;
13827 op2 = NULL_TREE;
13828 }
13829 else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13830 op2 = NULL_TREE;
13831
13832 /* If operands are string constant, turn then into object references */
13833 if (TREE_CODE (op1) == STRING_CST)
13834 op1 = patch_string_cst (op1);
13835 if (op2 && TREE_CODE (op2) == STRING_CST)
13836 op2 = patch_string_cst (op2);
13837
13838 /* If either one of the constant is null and the other non null
13839 operand is a String constant, return it. */
13840 if ((TREE_CODE (op1) == STRING_CST) && !op2)
13841 return op1;
13842
13843 /* If OP1 isn't already a StringBuffer, create and
13844 initialize a new one */
13845 if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13846 {
13847 /* Two solutions here:
13848 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13849 2) OP1 is something else, we call new StringBuffer().append(OP1). */
13850 if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13851 op1 = BUILD_STRING_BUFFER (op1);
13852 else
13853 {
13854 tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13855 op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13856 }
13857 }
13858
13859 if (op2)
13860 {
13861 /* OP1 is no longer the last node holding a crafted StringBuffer */
13862 IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13863 /* Create a node for `{new...,xxx}.append (op2)' */
13864 if (op2)
13865 op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13866 }
13867
13868 /* Mark the last node holding a crafted StringBuffer */
13869 IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13870
13871 TREE_SIDE_EFFECTS (op1) = side_effects;
13872 return op1;
13873 }
13874
13875 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13876 StringBuffer. If no string were found to be patched, return
13877 NULL. */
13878
13879 static tree
13880 patch_string (tree node)
13881 {
13882 if (node == error_mark_node)
13883 return error_mark_node;
13884 if (TREE_CODE (node) == STRING_CST)
13885 return patch_string_cst (node);
13886 else if (IS_CRAFTED_STRING_BUFFER_P (node))
13887 {
13888 int saved = ctxp->explicit_constructor_p;
13889 tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13890 tree ret;
13891 /* Temporary disable forbid the use of `this'. */
13892 ctxp->explicit_constructor_p = 0;
13893 ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13894 /* String concatenation arguments must be evaluated in order too. */
13895 ret = force_evaluation_order (ret);
13896 /* Restore it at its previous value */
13897 ctxp->explicit_constructor_p = saved;
13898 return ret;
13899 }
13900 return NULL_TREE;
13901 }
13902
13903 /* Build the internal representation of a string constant. */
13904
13905 static tree
13906 patch_string_cst (tree node)
13907 {
13908 int location;
13909 if (! flag_emit_class_files)
13910 {
13911 node = get_identifier (TREE_STRING_POINTER (node));
13912 location = alloc_name_constant (CONSTANT_String, node);
13913 node = build_ref_from_constant_pool (location);
13914 }
13915 TREE_TYPE (node) = string_ptr_type_node;
13916 TREE_CONSTANT (node) = 1;
13917 return node;
13918 }
13919
13920 /* Build an incomplete unary operator expression. */
13921
13922 static tree
13923 build_unaryop (int op_token, int op_location, tree op1)
13924 {
13925 enum tree_code op;
13926 tree unaryop;
13927 switch (op_token)
13928 {
13929 case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13930 case MINUS_TK: op = NEGATE_EXPR; break;
13931 case NEG_TK: op = TRUTH_NOT_EXPR; break;
13932 case NOT_TK: op = BIT_NOT_EXPR; break;
13933 default: abort ();
13934 }
13935
13936 unaryop = build1 (op, NULL_TREE, op1);
13937 TREE_SIDE_EFFECTS (unaryop) = 1;
13938 /* Store the location of the operator, for better error report. The
13939 string of the operator will be rebuild based on the OP value. */
13940 EXPR_WFL_LINECOL (unaryop) = op_location;
13941 return unaryop;
13942 }
13943
13944 /* Special case for the ++/-- operators, since they require an extra
13945 argument to build, which is set to NULL and patched
13946 later. IS_POST_P is 1 if the operator, 0 otherwise. */
13947
13948 static tree
13949 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13950 {
13951 static const enum tree_code lookup [2][2] =
13952 {
13953 { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13954 { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13955 };
13956 tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
13957 NULL_TREE, op1, NULL_TREE);
13958 TREE_SIDE_EFFECTS (node) = 1;
13959 /* Store the location of the operator, for better error report. The
13960 string of the operator will be rebuild based on the OP value. */
13961 EXPR_WFL_LINECOL (node) = op_location;
13962 return node;
13963 }
13964
13965 /* Build an incomplete cast operator, based on the use of the
13966 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13967 set. java_complete_tree is trained to walk a CONVERT_EXPR even
13968 though its type is already set. */
13969
13970 static tree
13971 build_cast (int location, tree type, tree exp)
13972 {
13973 tree node = build1 (CONVERT_EXPR, type, exp);
13974 EXPR_WFL_LINECOL (node) = location;
13975 return node;
13976 }
13977
13978 /* Build an incomplete class reference operator. */
13979 static tree
13980 build_incomplete_class_ref (int location, tree class_name)
13981 {
13982 tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13983 tree class_decl = GET_CPC ();
13984 tree this_class = TREE_TYPE (class_decl);
13985
13986 /* Generate the synthetic static method `class$'. (Previously we
13987 deferred this, causing different method tables to be emitted
13988 for native code and bytecode.) */
13989 if (!TYPE_DOT_CLASS (this_class)
13990 && !JPRIMITIVE_TYPE_P (class_name)
13991 && !(TREE_CODE (class_name) == VOID_TYPE))
13992 {
13993 tree target_class;
13994
13995 if (CLASS_INTERFACE (TYPE_NAME (this_class)))
13996 {
13997 /* For interfaces, adding a static 'class$' method directly
13998 is illegal. So create an inner class to contain the new
13999 method. Empirically this matches the behavior of javac. */
14000 tree t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
14001 tree inner = create_anonymous_class (0, t);
14002 target_class = TREE_TYPE (inner);
14003 end_class_declaration (1);
14004 }
14005 else
14006 {
14007 /* For inner classes, add a 'class$' method to their outermost
14008 context, creating it if necessary. */
14009 while (INNER_CLASS_DECL_P (class_decl))
14010 class_decl = DECL_CONTEXT (class_decl);
14011 target_class = TREE_TYPE (class_decl);
14012 }
14013
14014 if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
14015 build_dot_class_method (target_class);
14016
14017 if (this_class != target_class)
14018 TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14019 }
14020
14021 EXPR_WFL_LINECOL (node) = location;
14022 return node;
14023 }
14024
14025 /* Complete an incomplete class reference operator. */
14026 static tree
14027 patch_incomplete_class_ref (tree node)
14028 {
14029 tree type = TREE_OPERAND (node, 0);
14030 tree ref_type;
14031
14032 if (!(ref_type = resolve_type_during_patch (type)))
14033 return error_mark_node;
14034
14035 /* If we're not emitting class files and we know ref_type is a
14036 compiled class, build a direct reference. */
14037 if ((! flag_emit_class_files && is_compiled_class (ref_type))
14038 || JPRIMITIVE_TYPE_P (ref_type)
14039 || TREE_CODE (ref_type) == VOID_TYPE)
14040 {
14041 tree dot = build_class_ref (ref_type);
14042 /* A class referenced by `foo.class' is initialized. */
14043 if (!flag_emit_class_files)
14044 dot = build_class_init (ref_type, dot);
14045 return java_complete_tree (dot);
14046 }
14047
14048 /* If we're emitting class files and we have to deal with non
14049 primitive types, we invoke the synthetic static method `class$'. */
14050 ref_type = build_dot_class_method_invocation (current_class, ref_type);
14051 return java_complete_tree (ref_type);
14052 }
14053
14054 /* 15.14 Unary operators. We return error_mark_node in case of error,
14055 but preserve the type of NODE if the type is fixed. */
14056
14057 static tree
14058 patch_unaryop (tree node, tree wfl_op)
14059 {
14060 tree op = TREE_OPERAND (node, 0);
14061 tree op_type = TREE_TYPE (op);
14062 tree prom_type = NULL_TREE, value, decl;
14063 int outer_field_flag = 0;
14064 int code = TREE_CODE (node);
14065 int error_found = 0;
14066
14067 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14068
14069 switch (code)
14070 {
14071 /* 15.13.2 Postfix Increment Operator ++ */
14072 case POSTINCREMENT_EXPR:
14073 /* 15.13.3 Postfix Increment Operator -- */
14074 case POSTDECREMENT_EXPR:
14075 /* 15.14.1 Prefix Increment Operator ++ */
14076 case PREINCREMENT_EXPR:
14077 /* 15.14.2 Prefix Decrement Operator -- */
14078 case PREDECREMENT_EXPR:
14079 op = decl = strip_out_static_field_access_decl (op);
14080 outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14081 /* We might be trying to change an outer field accessed using
14082 access method. */
14083 if (outer_field_flag)
14084 {
14085 /* Retrieve the decl of the field we're trying to access. We
14086 do that by first retrieving the function we would call to
14087 access the field. It has been already verified that this
14088 field isn't final */
14089 if (flag_emit_class_files)
14090 decl = TREE_OPERAND (op, 0);
14091 else
14092 decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14093 decl = DECL_FUNCTION_ACCESS_DECL (decl);
14094 }
14095 /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14096 else if (!JDECL_P (decl)
14097 && TREE_CODE (decl) != COMPONENT_REF
14098 && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14099 && TREE_CODE (decl) != INDIRECT_REF
14100 && !(TREE_CODE (decl) == COMPOUND_EXPR
14101 && TREE_OPERAND (decl, 1)
14102 && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14103 {
14104 TREE_TYPE (node) = error_mark_node;
14105 error_found = 1;
14106 }
14107
14108 /* From now on, we know that op if a variable and that it has a
14109 valid wfl. We use wfl_op to locate errors related to the
14110 ++/-- operand. */
14111 if (!JNUMERIC_TYPE_P (op_type))
14112 {
14113 parse_error_context
14114 (wfl_op, "Invalid argument type `%s' to `%s'",
14115 lang_printable_name (op_type, 0), operator_string (node));
14116 TREE_TYPE (node) = error_mark_node;
14117 error_found = 1;
14118 }
14119 else
14120 {
14121 /* Before the addition, binary numeric promotion is performed on
14122 both operands, if really necessary */
14123 if (JINTEGRAL_TYPE_P (op_type))
14124 {
14125 value = build_int_2 (1, 0);
14126 TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14127 }
14128 else
14129 {
14130 value = build_int_2 (1, 0);
14131 TREE_TYPE (node) =
14132 binary_numeric_promotion (op_type,
14133 TREE_TYPE (value), &op, &value);
14134 }
14135
14136 /* We remember we might be accessing an outer field */
14137 if (outer_field_flag)
14138 {
14139 /* We re-generate an access to the field */
14140 value = build (PLUS_EXPR, TREE_TYPE (op),
14141 build_outer_field_access (wfl_op, decl), value);
14142
14143 /* And we patch the original access$() into a write
14144 with plus_op as a rhs */
14145 return outer_field_access_fix (node, op, value);
14146 }
14147
14148 /* And write back into the node. */
14149 TREE_OPERAND (node, 0) = op;
14150 TREE_OPERAND (node, 1) = value;
14151 /* Convert the overall back into its original type, if
14152 necessary, and return */
14153 if (JINTEGRAL_TYPE_P (op_type))
14154 return fold (node);
14155 else
14156 return fold (convert (op_type, node));
14157 }
14158 break;
14159
14160 /* 15.14.3 Unary Plus Operator + */
14161 case UNARY_PLUS_EXPR:
14162 /* 15.14.4 Unary Minus Operator - */
14163 case NEGATE_EXPR:
14164 if (!JNUMERIC_TYPE_P (op_type))
14165 {
14166 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14167 TREE_TYPE (node) = error_mark_node;
14168 error_found = 1;
14169 }
14170 /* Unary numeric promotion is performed on operand */
14171 else
14172 {
14173 op = do_unary_numeric_promotion (op);
14174 prom_type = TREE_TYPE (op);
14175 if (code == UNARY_PLUS_EXPR)
14176 return fold (op);
14177 }
14178 break;
14179
14180 /* 15.14.5 Bitwise Complement Operator ~ */
14181 case BIT_NOT_EXPR:
14182 if (!JINTEGRAL_TYPE_P (op_type))
14183 {
14184 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14185 TREE_TYPE (node) = error_mark_node;
14186 error_found = 1;
14187 }
14188 else
14189 {
14190 op = do_unary_numeric_promotion (op);
14191 prom_type = TREE_TYPE (op);
14192 }
14193 break;
14194
14195 /* 15.14.6 Logical Complement Operator ! */
14196 case TRUTH_NOT_EXPR:
14197 if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14198 {
14199 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14200 /* But the type is known. We will report an error if further
14201 attempt of a assignment is made with this rhs */
14202 TREE_TYPE (node) = boolean_type_node;
14203 error_found = 1;
14204 }
14205 else
14206 prom_type = boolean_type_node;
14207 break;
14208
14209 /* 15.15 Cast Expression */
14210 case CONVERT_EXPR:
14211 value = patch_cast (node, wfl_operator);
14212 if (value == error_mark_node)
14213 {
14214 /* If this cast is part of an assignment, we tell the code
14215 that deals with it not to complain about a mismatch,
14216 because things have been cast, anyways */
14217 TREE_TYPE (node) = error_mark_node;
14218 error_found = 1;
14219 }
14220 else
14221 {
14222 value = fold (value);
14223 TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14224 return value;
14225 }
14226 break;
14227 }
14228
14229 if (error_found)
14230 return error_mark_node;
14231
14232 /* There are cases where node has been replaced by something else
14233 and we don't end up returning here: UNARY_PLUS_EXPR,
14234 CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14235 TREE_OPERAND (node, 0) = fold (op);
14236 TREE_TYPE (node) = prom_type;
14237 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14238 return fold (node);
14239 }
14240
14241 /* Generic type resolution that sometimes takes place during node
14242 patching. Returned the resolved type or generate an error
14243 message. Return the resolved type or NULL_TREE. */
14244
14245 static tree
14246 resolve_type_during_patch (tree type)
14247 {
14248 if (unresolved_type_p (type, NULL))
14249 {
14250 tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14251 if (!type_decl)
14252 {
14253 parse_error_context (type,
14254 "Class `%s' not found in type declaration",
14255 IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14256 return NULL_TREE;
14257 }
14258
14259 check_deprecation (type, type_decl);
14260
14261 return TREE_TYPE (type_decl);
14262 }
14263 return type;
14264 }
14265
14266 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14267 found. Otherwise NODE or something meant to replace it is returned. */
14268
14269 static tree
14270 patch_cast (tree node, tree wfl_op)
14271 {
14272 tree op = TREE_OPERAND (node, 0);
14273 tree cast_type = TREE_TYPE (node);
14274 tree patched, op_type;
14275 char *t1;
14276
14277 /* Some string patching might be necessary at this stage */
14278 if ((patched = patch_string (op)))
14279 TREE_OPERAND (node, 0) = op = patched;
14280 op_type = TREE_TYPE (op);
14281
14282 /* First resolve OP_TYPE if unresolved */
14283 if (!(cast_type = resolve_type_during_patch (cast_type)))
14284 return error_mark_node;
14285
14286 /* Check on cast that are proven correct at compile time */
14287 if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14288 {
14289 /* Same type */
14290 if (cast_type == op_type)
14291 return node;
14292
14293 /* A narrowing conversion from a floating-point number to an
14294 integral type requires special handling (5.1.3). */
14295 if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14296 if (cast_type != long_type_node)
14297 op = convert (integer_type_node, op);
14298
14299 /* Try widening/narrowing conversion. Potentially, things need
14300 to be worked out in gcc so we implement the extreme cases
14301 correctly. fold_convert() needs to be fixed. */
14302 return convert (cast_type, op);
14303 }
14304
14305 /* It's also valid to cast a boolean into a boolean */
14306 if (op_type == boolean_type_node && cast_type == boolean_type_node)
14307 return node;
14308
14309 /* null can be casted to references */
14310 if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14311 return build_null_of_type (cast_type);
14312
14313 /* The remaining legal casts involve conversion between reference
14314 types. Check for their compile time correctness. */
14315 if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14316 && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14317 {
14318 TREE_TYPE (node) = promote_type (cast_type);
14319 /* Now, the case can be determined correct at compile time if
14320 OP_TYPE can be converted into CAST_TYPE by assignment
14321 conversion (5.2) */
14322
14323 if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14324 {
14325 TREE_SET_CODE (node, NOP_EXPR);
14326 return node;
14327 }
14328
14329 if (flag_emit_class_files)
14330 {
14331 TREE_SET_CODE (node, CONVERT_EXPR);
14332 return node;
14333 }
14334
14335 /* The cast requires a run-time check */
14336 return build (CALL_EXPR, promote_type (cast_type),
14337 build_address_of (soft_checkcast_node),
14338 tree_cons (NULL_TREE, build_class_ref (cast_type),
14339 build_tree_list (NULL_TREE, op)),
14340 NULL_TREE);
14341 }
14342
14343 /* Any other casts are proven incorrect at compile time */
14344 t1 = xstrdup (lang_printable_name (op_type, 0));
14345 parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14346 t1, lang_printable_name (cast_type, 0));
14347 free (t1);
14348 return error_mark_node;
14349 }
14350
14351 /* Build a null constant and give it the type TYPE. */
14352
14353 static tree
14354 build_null_of_type (tree type)
14355 {
14356 tree node = build_int_2 (0, 0);
14357 TREE_TYPE (node) = promote_type (type);
14358 return node;
14359 }
14360
14361 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14362 a list of indices. */
14363 static tree
14364 build_array_ref (int location, tree array, tree index)
14365 {
14366 tree node = build (ARRAY_REF, NULL_TREE, array, index);
14367 EXPR_WFL_LINECOL (node) = location;
14368 return node;
14369 }
14370
14371 /* 15.12 Array Access Expression */
14372
14373 static tree
14374 patch_array_ref (tree node)
14375 {
14376 tree array = TREE_OPERAND (node, 0);
14377 tree array_type = TREE_TYPE (array);
14378 tree index = TREE_OPERAND (node, 1);
14379 tree index_type = TREE_TYPE (index);
14380 int error_found = 0;
14381
14382 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14383
14384 if (TREE_CODE (array_type) == POINTER_TYPE)
14385 array_type = TREE_TYPE (array_type);
14386
14387 /* The array reference must be an array */
14388 if (!TYPE_ARRAY_P (array_type))
14389 {
14390 parse_error_context
14391 (wfl_operator,
14392 "`[]' can only be applied to arrays. It can't be applied to `%s'",
14393 lang_printable_name (array_type, 0));
14394 TREE_TYPE (node) = error_mark_node;
14395 error_found = 1;
14396 }
14397
14398 /* The array index undergoes unary numeric promotion. The promoted
14399 type must be int */
14400 index = do_unary_numeric_promotion (index);
14401 if (TREE_TYPE (index) != int_type_node)
14402 {
14403 if (valid_cast_to_p (index_type, int_type_node))
14404 parse_error_context (wfl_operator,
14405 "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14406 lang_printable_name (index_type, 0));
14407 else
14408 parse_error_context (wfl_operator,
14409 "Incompatible type for `[]'. Can't convert `%s' to `int'",
14410 lang_printable_name (index_type, 0));
14411 TREE_TYPE (node) = error_mark_node;
14412 error_found = 1;
14413 }
14414
14415 if (error_found)
14416 return error_mark_node;
14417
14418 array_type = TYPE_ARRAY_ELEMENT (array_type);
14419
14420 if (flag_emit_class_files || flag_emit_xref)
14421 {
14422 TREE_OPERAND (node, 0) = array;
14423 TREE_OPERAND (node, 1) = index;
14424 }
14425 else
14426 node = build_java_arrayaccess (array, array_type, index);
14427 TREE_TYPE (node) = array_type;
14428 return node;
14429 }
14430
14431 /* 15.9 Array Creation Expressions */
14432
14433 static tree
14434 build_newarray_node (tree type, tree dims, int extra_dims)
14435 {
14436 tree node =
14437 build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14438 build_int_2 (extra_dims, 0));
14439 return node;
14440 }
14441
14442 static tree
14443 patch_newarray (tree node)
14444 {
14445 tree type = TREE_OPERAND (node, 0);
14446 tree dims = TREE_OPERAND (node, 1);
14447 tree cdim, array_type;
14448 int error_found = 0;
14449 int ndims = 0;
14450 int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14451
14452 /* Dimension types are verified. It's better for the types to be
14453 verified in order. */
14454 for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14455 {
14456 int dim_error = 0;
14457 tree dim = TREE_VALUE (cdim);
14458
14459 /* Dim might have been saved during its evaluation */
14460 dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14461
14462 /* The type of each specified dimension must be an integral type. */
14463 if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14464 dim_error = 1;
14465
14466 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14467 promoted type must be int. */
14468 else
14469 {
14470 dim = do_unary_numeric_promotion (dim);
14471 if (TREE_TYPE (dim) != int_type_node)
14472 dim_error = 1;
14473 }
14474
14475 /* Report errors on types here */
14476 if (dim_error)
14477 {
14478 parse_error_context
14479 (TREE_PURPOSE (cdim),
14480 "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14481 (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14482 "Explicit cast needed to" : "Can't"),
14483 lang_printable_name (TREE_TYPE (dim), 0));
14484 error_found = 1;
14485 }
14486
14487 TREE_PURPOSE (cdim) = NULL_TREE;
14488 }
14489
14490 /* Resolve array base type if unresolved */
14491 if (!(type = resolve_type_during_patch (type)))
14492 error_found = 1;
14493
14494 if (error_found)
14495 {
14496 /* We don't want further evaluation of this bogus array creation
14497 operation */
14498 TREE_TYPE (node) = error_mark_node;
14499 return error_mark_node;
14500 }
14501
14502 /* Set array_type to the actual (promoted) array type of the result. */
14503 if (TREE_CODE (type) == RECORD_TYPE)
14504 type = build_pointer_type (type);
14505 while (--xdims >= 0)
14506 {
14507 type = promote_type (build_java_array_type (type, -1));
14508 }
14509 dims = nreverse (dims);
14510 array_type = type;
14511 for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14512 {
14513 type = array_type;
14514 array_type
14515 = build_java_array_type (type,
14516 TREE_CODE (cdim) == INTEGER_CST
14517 ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14518 : -1);
14519 array_type = promote_type (array_type);
14520 }
14521 dims = nreverse (dims);
14522
14523 /* The node is transformed into a function call. Things are done
14524 differently according to the number of dimensions. If the number
14525 of dimension is equal to 1, then the nature of the base type
14526 (primitive or not) matters. */
14527 if (ndims == 1)
14528 return build_new_array (type, TREE_VALUE (dims));
14529
14530 /* Can't reuse what's already written in expr.c because it uses the
14531 JVM stack representation. Provide a build_multianewarray. FIXME */
14532 return build (CALL_EXPR, array_type,
14533 build_address_of (soft_multianewarray_node),
14534 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14535 tree_cons (NULL_TREE,
14536 build_int_2 (ndims, 0), dims )),
14537 NULL_TREE);
14538 }
14539
14540 /* 10.6 Array initializer. */
14541
14542 /* Build a wfl for array element that don't have one, so we can
14543 pin-point errors. */
14544
14545 static tree
14546 maybe_build_array_element_wfl (tree node)
14547 {
14548 if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14549 return build_expr_wfl (NULL_TREE, ctxp->filename,
14550 ctxp->elc.line, ctxp->elc.prev_col);
14551 else
14552 return NULL_TREE;
14553 }
14554
14555 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14556 identification of initialized arrays easier to detect during walk
14557 and expansion. */
14558
14559 static tree
14560 build_new_array_init (int location, tree values)
14561 {
14562 tree constructor = build_constructor (NULL_TREE, values);
14563 tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14564 EXPR_WFL_LINECOL (to_return) = location;
14565 return to_return;
14566 }
14567
14568 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14569 occurred. Otherwise return NODE after having set its type
14570 appropriately. */
14571
14572 static tree
14573 patch_new_array_init (tree type, tree node)
14574 {
14575 int error_seen = 0;
14576 tree current, element_type;
14577 HOST_WIDE_INT length;
14578 int all_constant = 1;
14579 tree init = TREE_OPERAND (node, 0);
14580
14581 if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14582 {
14583 parse_error_context (node,
14584 "Invalid array initializer for non-array type `%s'",
14585 lang_printable_name (type, 1));
14586 return error_mark_node;
14587 }
14588 type = TREE_TYPE (type);
14589 element_type = TYPE_ARRAY_ELEMENT (type);
14590
14591 CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14592
14593 for (length = 0, current = CONSTRUCTOR_ELTS (init);
14594 current; length++, current = TREE_CHAIN (current))
14595 {
14596 tree elt = TREE_VALUE (current);
14597 if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14598 {
14599 error_seen |= array_constructor_check_entry (element_type, current);
14600 elt = TREE_VALUE (current);
14601 /* When compiling to native code, STRING_CST is converted to
14602 INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14603 if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14604 all_constant = 0;
14605 }
14606 else
14607 {
14608 TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14609 TREE_PURPOSE (current) = NULL_TREE;
14610 all_constant = 0;
14611 }
14612 if (elt && TREE_CODE (elt) == TREE_LIST
14613 && TREE_VALUE (elt) == error_mark_node)
14614 error_seen = 1;
14615 }
14616
14617 if (error_seen)
14618 return error_mark_node;
14619
14620 /* Create a new type. We can't reuse the one we have here by
14621 patching its dimension because it originally is of dimension -1
14622 hence reused by gcc. This would prevent triangular arrays. */
14623 type = build_java_array_type (element_type, length);
14624 TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14625 TREE_TYPE (node) = promote_type (type);
14626 TREE_CONSTANT (init) = all_constant;
14627 TREE_CONSTANT (node) = all_constant;
14628 return node;
14629 }
14630
14631 /* Verify that one entry of the initializer element list can be
14632 assigned to the array base type. Report 1 if an error occurred, 0
14633 otherwise. */
14634
14635 static int
14636 array_constructor_check_entry (tree type, tree entry)
14637 {
14638 char *array_type_string = NULL; /* For error reports */
14639 tree value, type_value, new_value, wfl_value, patched;
14640 int error_seen = 0;
14641
14642 new_value = NULL_TREE;
14643 wfl_value = TREE_VALUE (entry);
14644
14645 value = java_complete_tree (TREE_VALUE (entry));
14646 /* patch_string return error_mark_node if arg is error_mark_node */
14647 if ((patched = patch_string (value)))
14648 value = patched;
14649 if (value == error_mark_node)
14650 return 1;
14651
14652 type_value = TREE_TYPE (value);
14653
14654 /* At anytime, try_builtin_assignconv can report a warning on
14655 constant overflow during narrowing. */
14656 SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14657 new_value = try_builtin_assignconv (wfl_operator, type, value);
14658 if (!new_value && (new_value = try_reference_assignconv (type, value)))
14659 type_value = promote_type (type);
14660
14661 /* Check and report errors */
14662 if (!new_value)
14663 {
14664 const char *const msg = (!valid_cast_to_p (type_value, type) ?
14665 "Can't" : "Explicit cast needed to");
14666 if (!array_type_string)
14667 array_type_string = xstrdup (lang_printable_name (type, 1));
14668 parse_error_context
14669 (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14670 msg, lang_printable_name (type_value, 1), array_type_string);
14671 error_seen = 1;
14672 }
14673
14674 if (new_value)
14675 TREE_VALUE (entry) = new_value;
14676
14677 if (array_type_string)
14678 free (array_type_string);
14679
14680 TREE_PURPOSE (entry) = NULL_TREE;
14681 return error_seen;
14682 }
14683
14684 static tree
14685 build_this (int location)
14686 {
14687 tree node = build_wfl_node (this_identifier_node);
14688 TREE_SET_CODE (node, THIS_EXPR);
14689 EXPR_WFL_LINECOL (node) = location;
14690 return node;
14691 }
14692
14693 /* 14.15 The return statement. It builds a modify expression that
14694 assigns the returned value to the RESULT_DECL that hold the value
14695 to be returned. */
14696
14697 static tree
14698 build_return (int location, tree op)
14699 {
14700 tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14701 EXPR_WFL_LINECOL (node) = location;
14702 node = build_debugable_stmt (location, node);
14703 return node;
14704 }
14705
14706 static tree
14707 patch_return (tree node)
14708 {
14709 tree return_exp = TREE_OPERAND (node, 0);
14710 tree meth = current_function_decl;
14711 tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14712 int error_found = 0;
14713
14714 TREE_TYPE (node) = error_mark_node;
14715 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14716
14717 /* It's invalid to have a return value within a function that is
14718 declared with the keyword void or that is a constructor */
14719 if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14720 error_found = 1;
14721
14722 /* It's invalid to use a return statement in a static block */
14723 if (DECL_CLINIT_P (current_function_decl))
14724 error_found = 1;
14725
14726 /* It's invalid to have a no return value within a function that
14727 isn't declared with the keyword `void' */
14728 if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14729 error_found = 2;
14730
14731 if (DECL_INSTINIT_P (current_function_decl))
14732 error_found = 1;
14733
14734 if (error_found)
14735 {
14736 if (DECL_INSTINIT_P (current_function_decl))
14737 parse_error_context (wfl_operator,
14738 "`return' inside instance initializer");
14739
14740 else if (DECL_CLINIT_P (current_function_decl))
14741 parse_error_context (wfl_operator,
14742 "`return' inside static initializer");
14743
14744 else if (!DECL_CONSTRUCTOR_P (meth))
14745 {
14746 char *t = xstrdup (lang_printable_name (mtype, 0));
14747 parse_error_context (wfl_operator,
14748 "`return' with%s value from `%s %s'",
14749 (error_found == 1 ? "" : "out"),
14750 t, lang_printable_name (meth, 0));
14751 free (t);
14752 }
14753 else
14754 parse_error_context (wfl_operator,
14755 "`return' with value from constructor `%s'",
14756 lang_printable_name (meth, 0));
14757 return error_mark_node;
14758 }
14759
14760 /* If we have a return_exp, build a modify expression and expand
14761 it. Note: at that point, the assignment is declared valid, but we
14762 may want to carry some more hacks */
14763 if (return_exp)
14764 {
14765 tree exp = java_complete_tree (return_exp);
14766 tree modify, patched;
14767
14768 if ((patched = patch_string (exp)))
14769 exp = patched;
14770
14771 modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14772 EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14773 modify = java_complete_tree (modify);
14774
14775 if (modify != error_mark_node)
14776 {
14777 TREE_SIDE_EFFECTS (modify) = 1;
14778 TREE_OPERAND (node, 0) = modify;
14779 }
14780 else
14781 return error_mark_node;
14782 }
14783 TREE_TYPE (node) = void_type_node;
14784 TREE_SIDE_EFFECTS (node) = 1;
14785 return node;
14786 }
14787
14788 /* 14.8 The if Statement */
14789
14790 static tree
14791 build_if_else_statement (int location, tree expression, tree if_body,
14792 tree else_body)
14793 {
14794 tree node;
14795 if (!else_body)
14796 else_body = empty_stmt_node;
14797 node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14798 EXPR_WFL_LINECOL (node) = location;
14799 node = build_debugable_stmt (location, node);
14800 return node;
14801 }
14802
14803 static tree
14804 patch_if_else_statement (tree node)
14805 {
14806 tree expression = TREE_OPERAND (node, 0);
14807 int can_complete_normally
14808 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14809 | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14810
14811 TREE_TYPE (node) = error_mark_node;
14812 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14813
14814 /* The type of expression must be boolean */
14815 if (TREE_TYPE (expression) != boolean_type_node
14816 && TREE_TYPE (expression) != promoted_boolean_type_node)
14817 {
14818 parse_error_context
14819 (wfl_operator,
14820 "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14821 lang_printable_name (TREE_TYPE (expression), 0));
14822 return error_mark_node;
14823 }
14824
14825 if (TREE_CODE (expression) == INTEGER_CST)
14826 {
14827 if (integer_zerop (expression))
14828 node = TREE_OPERAND (node, 2);
14829 else
14830 node = TREE_OPERAND (node, 1);
14831 if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14832 {
14833 node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14834 CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14835 }
14836 return node;
14837 }
14838 TREE_TYPE (node) = void_type_node;
14839 TREE_SIDE_EFFECTS (node) = 1;
14840 CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14841 return node;
14842 }
14843
14844 /* 14.6 Labeled Statements */
14845
14846 /* Action taken when a labeled statement is parsed. a new
14847 LABELED_BLOCK_EXPR is created. No statement is attached to the
14848 label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
14849
14850 static tree
14851 build_labeled_block (int location, tree label)
14852 {
14853 tree label_name ;
14854 tree label_decl, node;
14855 if (label == NULL_TREE || label == continue_identifier_node)
14856 label_name = label;
14857 else
14858 {
14859 label_name = merge_qualified_name (label_id, label);
14860 /* Issue an error if we try to reuse a label that was previously
14861 declared */
14862 if (IDENTIFIER_LOCAL_VALUE (label_name))
14863 {
14864 EXPR_WFL_LINECOL (wfl_operator) = location;
14865 parse_error_context (wfl_operator,
14866 "Declaration of `%s' shadows a previous label declaration",
14867 IDENTIFIER_POINTER (label));
14868 EXPR_WFL_LINECOL (wfl_operator) =
14869 EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14870 parse_error_context (wfl_operator,
14871 "This is the location of the previous declaration of label `%s'",
14872 IDENTIFIER_POINTER (label));
14873 java_error_count--;
14874 }
14875 }
14876
14877 label_decl = create_label_decl (label_name);
14878 node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14879 EXPR_WFL_LINECOL (node) = location;
14880 TREE_SIDE_EFFECTS (node) = 1;
14881 return node;
14882 }
14883
14884 /* A labeled statement LBE is attached a statement. */
14885
14886 static tree
14887 finish_labeled_statement (tree lbe, /* Labeled block expr */
14888 tree statement)
14889 {
14890 /* In anyways, tie the loop to its statement */
14891 LABELED_BLOCK_BODY (lbe) = statement;
14892 pop_labeled_block ();
14893 POP_LABELED_BLOCK ();
14894 return lbe;
14895 }
14896
14897 /* 14.10, 14.11, 14.12 Loop Statements */
14898
14899 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14900 list. */
14901
14902 static tree
14903 build_new_loop (tree loop_body)
14904 {
14905 tree loop = build (LOOP_EXPR, NULL_TREE, loop_body);
14906 TREE_SIDE_EFFECTS (loop) = 1;
14907 PUSH_LOOP (loop);
14908 return loop;
14909 }
14910
14911 /* Create a loop body according to the following structure:
14912 COMPOUND_EXPR
14913 COMPOUND_EXPR (loop main body)
14914 EXIT_EXPR (this order is for while/for loops.
14915 LABELED_BLOCK_EXPR the order is reversed for do loops)
14916 LABEL_DECL (a continue occurring here branches at the
14917 BODY end of this labeled block)
14918 INCREMENT (if any)
14919
14920 REVERSED, if nonzero, tells that the loop condition expr comes
14921 after the body, like in the do-while loop.
14922
14923 To obtain a loop, the loop body structure described above is
14924 encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14925
14926 LABELED_BLOCK_EXPR
14927 LABEL_DECL (use this label to exit the loop)
14928 LOOP_EXPR
14929 <structure described above> */
14930
14931 static tree
14932 build_loop_body (int location, tree condition, int reversed)
14933 {
14934 tree first, second, body;
14935
14936 condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14937 EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14938 condition = build_debugable_stmt (location, condition);
14939 TREE_SIDE_EFFECTS (condition) = 1;
14940
14941 body = build_labeled_block (0, continue_identifier_node);
14942 first = (reversed ? body : condition);
14943 second = (reversed ? condition : body);
14944 return
14945 build (COMPOUND_EXPR, NULL_TREE,
14946 build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
14947 }
14948
14949 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14950 their order) on the current loop. Unlink the current loop from the
14951 loop list. */
14952
14953 static tree
14954 finish_loop_body (int location, tree condition, tree body, int reversed)
14955 {
14956 tree to_return = ctxp->current_loop;
14957 tree loop_body = LOOP_EXPR_BODY (to_return);
14958 if (condition)
14959 {
14960 tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14961 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14962 The real EXIT_EXPR is one operand further. */
14963 EXPR_WFL_LINECOL (cnode) = location;
14964 /* This one is for accurate error reports */
14965 EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14966 TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14967 }
14968 LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14969 POP_LOOP ();
14970 return to_return;
14971 }
14972
14973 /* Tailored version of finish_loop_body for FOR loops, when FOR
14974 loops feature the condition part */
14975
14976 static tree
14977 finish_for_loop (int location, tree condition, tree update, tree body)
14978 {
14979 /* Put the condition and the loop body in place */
14980 tree loop = finish_loop_body (location, condition, body, 0);
14981 /* LOOP is the current loop which has been now popped of the loop
14982 stack. Mark the update block as reachable and install it. We do
14983 this because the (current interpretation of the) JLS requires
14984 that the update expression be considered reachable even if the
14985 for loop's body doesn't complete normally. */
14986 if (update != NULL_TREE && update != empty_stmt_node)
14987 {
14988 tree up2 = update;
14989 if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14990 up2 = EXPR_WFL_NODE (up2);
14991 /* It is possible for the update expression to be an
14992 EXPR_WFL_NODE wrapping nothing. */
14993 if (up2 != NULL_TREE && up2 != empty_stmt_node)
14994 {
14995 /* Try to detect constraint violations. These would be
14996 programming errors somewhere. */
14997 if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
14998 || TREE_CODE (up2) == LOOP_EXPR)
14999 abort ();
15000 SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
15001 }
15002 }
15003 LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
15004 return loop;
15005 }
15006
15007 /* Try to find the loop a block might be related to. This comprises
15008 the case where the LOOP_EXPR is found as the second operand of a
15009 COMPOUND_EXPR, because the loop happens to have an initialization
15010 part, then expressed as the first operand of the COMPOUND_EXPR. If
15011 the search finds something, 1 is returned. Otherwise, 0 is
15012 returned. The search is assumed to start from a
15013 LABELED_BLOCK_EXPR's block. */
15014
15015 static tree
15016 search_loop (tree statement)
15017 {
15018 if (TREE_CODE (statement) == LOOP_EXPR)
15019 return statement;
15020
15021 if (TREE_CODE (statement) == BLOCK)
15022 statement = BLOCK_SUBBLOCKS (statement);
15023 else
15024 return NULL_TREE;
15025
15026 if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15027 while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15028 statement = TREE_OPERAND (statement, 1);
15029
15030 return (TREE_CODE (statement) == LOOP_EXPR
15031 && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15032 }
15033
15034 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15035 returned otherwise. */
15036
15037 static int
15038 labeled_block_contains_loop_p (tree block, tree loop)
15039 {
15040 if (!block)
15041 return 0;
15042
15043 if (LABELED_BLOCK_BODY (block) == loop)
15044 return 1;
15045
15046 if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15047 return 1;
15048
15049 return 0;
15050 }
15051
15052 /* If the loop isn't surrounded by a labeled statement, create one and
15053 insert LOOP as its body. */
15054
15055 static tree
15056 patch_loop_statement (tree loop)
15057 {
15058 tree loop_label;
15059
15060 TREE_TYPE (loop) = void_type_node;
15061 if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15062 return loop;
15063
15064 loop_label = build_labeled_block (0, NULL_TREE);
15065 /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15066 that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15067 LABELED_BLOCK_BODY (loop_label) = loop;
15068 PUSH_LABELED_BLOCK (loop_label);
15069 return loop_label;
15070 }
15071
15072 /* 14.13, 14.14: break and continue Statements */
15073
15074 /* Build a break or a continue statement. a null NAME indicates an
15075 unlabeled break/continue statement. */
15076
15077 static tree
15078 build_bc_statement (int location, int is_break, tree name)
15079 {
15080 tree break_continue, label_block_expr = NULL_TREE;
15081
15082 if (name)
15083 {
15084 if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15085 (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15086 /* Null means that we don't have a target for this named
15087 break/continue. In this case, we make the target to be the
15088 label name, so that the error can be reported accurately in
15089 patch_bc_statement. */
15090 label_block_expr = EXPR_WFL_NODE (name);
15091 }
15092 /* Unlabeled break/continue will be handled during the
15093 break/continue patch operation */
15094 break_continue
15095 = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15096
15097 IS_BREAK_STMT_P (break_continue) = is_break;
15098 TREE_SIDE_EFFECTS (break_continue) = 1;
15099 EXPR_WFL_LINECOL (break_continue) = location;
15100 break_continue = build_debugable_stmt (location, break_continue);
15101 return break_continue;
15102 }
15103
15104 /* Verification of a break/continue statement. */
15105
15106 static tree
15107 patch_bc_statement (tree node)
15108 {
15109 tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15110 tree labeled_block = ctxp->current_labeled_block;
15111 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15112
15113 /* Having an identifier here means that the target is unknown. */
15114 if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15115 {
15116 parse_error_context (wfl_operator, "No label definition found for `%s'",
15117 IDENTIFIER_POINTER (bc_label));
15118 return error_mark_node;
15119 }
15120 if (! IS_BREAK_STMT_P (node))
15121 {
15122 /* It's a continue statement. */
15123 for (;; labeled_block = TREE_CHAIN (labeled_block))
15124 {
15125 if (labeled_block == NULL_TREE)
15126 {
15127 if (bc_label == NULL_TREE)
15128 parse_error_context (wfl_operator,
15129 "`continue' must be in loop");
15130 else
15131 parse_error_context
15132 (wfl_operator, "continue label `%s' does not name a loop",
15133 IDENTIFIER_POINTER (bc_label));
15134 return error_mark_node;
15135 }
15136 if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15137 == continue_identifier_node)
15138 && (bc_label == NULL_TREE
15139 || TREE_CHAIN (labeled_block) == bc_label))
15140 {
15141 bc_label = labeled_block;
15142 break;
15143 }
15144 }
15145 }
15146 else if (!bc_label)
15147 {
15148 for (;; labeled_block = TREE_CHAIN (labeled_block))
15149 {
15150 if (labeled_block == NULL_TREE)
15151 {
15152 parse_error_context (wfl_operator,
15153 "`break' must be in loop or switch");
15154 return error_mark_node;
15155 }
15156 target_stmt = LABELED_BLOCK_BODY (labeled_block);
15157 if (TREE_CODE (target_stmt) == SWITCH_EXPR
15158 || search_loop (target_stmt))
15159 {
15160 bc_label = labeled_block;
15161 break;
15162 }
15163 }
15164 }
15165
15166 EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15167 CAN_COMPLETE_NORMALLY (bc_label) = 1;
15168
15169 /* Our break/continue don't return values. */
15170 TREE_TYPE (node) = void_type_node;
15171 /* Encapsulate the break within a compound statement so that it's
15172 expanded all the times by expand_expr (and not clobbered
15173 sometimes, like after a if statement) */
15174 node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15175 TREE_SIDE_EFFECTS (node) = 1;
15176 return node;
15177 }
15178
15179 /* Process the exit expression belonging to a loop. Its type must be
15180 boolean. */
15181
15182 static tree
15183 patch_exit_expr (tree node)
15184 {
15185 tree expression = TREE_OPERAND (node, 0);
15186 TREE_TYPE (node) = error_mark_node;
15187 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15188
15189 /* The type of expression must be boolean */
15190 if (TREE_TYPE (expression) != boolean_type_node)
15191 {
15192 parse_error_context
15193 (wfl_operator,
15194 "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15195 lang_printable_name (TREE_TYPE (expression), 0));
15196 return error_mark_node;
15197 }
15198 /* Now we know things are allright, invert the condition, fold and
15199 return */
15200 TREE_OPERAND (node, 0) =
15201 fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15202
15203 if (! integer_zerop (TREE_OPERAND (node, 0))
15204 && ctxp->current_loop != NULL_TREE
15205 && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15206 CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15207 if (! integer_onep (TREE_OPERAND (node, 0)))
15208 CAN_COMPLETE_NORMALLY (node) = 1;
15209
15210
15211 TREE_TYPE (node) = void_type_node;
15212 return node;
15213 }
15214
15215 /* 14.9 Switch statement */
15216
15217 static tree
15218 patch_switch_statement (tree node)
15219 {
15220 tree se = TREE_OPERAND (node, 0), se_type;
15221 tree save, iter;
15222
15223 /* Complete the switch expression */
15224 se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15225 se_type = TREE_TYPE (se);
15226 /* The type of the switch expression must be char, byte, short or
15227 int */
15228 if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15229 {
15230 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15231 parse_error_context (wfl_operator,
15232 "Incompatible type for `switch'. Can't convert `%s' to `int'",
15233 lang_printable_name (se_type, 0));
15234 /* This is what java_complete_tree will check */
15235 TREE_OPERAND (node, 0) = error_mark_node;
15236 return error_mark_node;
15237 }
15238
15239 /* Save and restore the outer case label list. */
15240 save = case_label_list;
15241 case_label_list = NULL_TREE;
15242
15243 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15244
15245 /* See if we've found a duplicate label. We can't leave this until
15246 code generation, because in `--syntax-only' and `-C' modes we
15247 don't do ordinary code generation. */
15248 for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15249 {
15250 HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15251 tree subiter;
15252 for (subiter = TREE_CHAIN (iter);
15253 subiter != NULL_TREE;
15254 subiter = TREE_CHAIN (subiter))
15255 {
15256 HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15257 if (val == subval)
15258 {
15259 EXPR_WFL_LINECOL (wfl_operator)
15260 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15261 /* The case_label_list is in reverse order, so print the
15262 outer label first. */
15263 parse_error_context (wfl_operator, "duplicate case label: `"
15264 HOST_WIDE_INT_PRINT_DEC "'", subval);
15265 EXPR_WFL_LINECOL (wfl_operator)
15266 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15267 parse_error_context (wfl_operator, "original label is here");
15268
15269 break;
15270 }
15271 }
15272 }
15273
15274 case_label_list = save;
15275
15276 /* Ready to return */
15277 if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15278 {
15279 TREE_TYPE (node) = error_mark_node;
15280 return error_mark_node;
15281 }
15282 TREE_TYPE (node) = void_type_node;
15283 TREE_SIDE_EFFECTS (node) = 1;
15284 CAN_COMPLETE_NORMALLY (node)
15285 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15286 || ! SWITCH_HAS_DEFAULT (node);
15287 return node;
15288 }
15289
15290 /* Assertions. */
15291
15292 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15293 might be NULL_TREE. */
15294 static tree
15295 build_assertion (int location, tree condition, tree value)
15296 {
15297 tree node;
15298 tree klass = GET_CPC ();
15299
15300 if (! CLASS_USES_ASSERTIONS (klass))
15301 {
15302 tree field, classdollar, id, call;
15303 tree class_type = TREE_TYPE (klass);
15304
15305 field = add_field (class_type,
15306 get_identifier ("$assertionsDisabled"),
15307 boolean_type_node,
15308 ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15309 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15310 FIELD_SYNTHETIC (field) = 1;
15311
15312 if (!TYPE_DOT_CLASS (class_type))
15313 build_dot_class_method (class_type);
15314 classdollar = build_dot_class_method_invocation (class_type, class_type);
15315
15316 /* Call CLASS.desiredAssertionStatus(). */
15317 id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15318 call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15319 call = make_qualified_primary (classdollar, call, location);
15320 TREE_SIDE_EFFECTS (call) = 1;
15321
15322 /* Invert to obtain !CLASS.desiredAssertionStatus(). This may
15323 seem odd, but we do it to generate code identical to that of
15324 the JDK. */
15325 call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15326 TREE_SIDE_EFFECTS (call) = 1;
15327 DECL_INITIAL (field) = call;
15328
15329 /* Record the initializer in the initializer statement list. */
15330 call = build (MODIFY_EXPR, NULL_TREE, field, call);
15331 TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15332 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15333 MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15334
15335 CLASS_USES_ASSERTIONS (klass) = 1;
15336 }
15337
15338 if (value != NULL_TREE)
15339 value = tree_cons (NULL_TREE, value, NULL_TREE);
15340
15341 node = build_wfl_node (get_identifier ("java"));
15342 node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15343 location);
15344 node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15345 location);
15346
15347 node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15348 TREE_SIDE_EFFECTS (node) = 1;
15349 /* It is too early to use BUILD_THROW. */
15350 node = build1 (THROW_EXPR, NULL_TREE, node);
15351 TREE_SIDE_EFFECTS (node) = 1;
15352
15353 /* We invert the condition; if we just put NODE as the `else' part
15354 then we generate weird-looking bytecode. */
15355 condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15356 /* Check $assertionsDisabled. */
15357 condition
15358 = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15359 build1 (TRUTH_NOT_EXPR, NULL_TREE,
15360 build_wfl_node (get_identifier ("$assertionsDisabled"))),
15361 condition);
15362 node = build_if_else_statement (location, condition, node, NULL_TREE);
15363 return node;
15364 }
15365
15366 /* 14.18 The try/catch statements */
15367
15368 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15369 catches TYPE and executes CATCH_STMTS. */
15370
15371 static tree
15372 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15373 tree catch_stmts)
15374 {
15375 tree try_block, catch_clause_param, catch_block, catch;
15376
15377 /* First build a try block */
15378 try_block = build_expr_block (try_stmts, NULL_TREE);
15379
15380 /* Build a catch block: we need a catch clause parameter */
15381 if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15382 {
15383 tree catch_type = obtain_incomplete_type (type_or_name);
15384 jdep *dep;
15385 catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15386 register_incomplete_type (JDEP_VARIABLE, type_or_name,
15387 catch_clause_param, catch_type);
15388 dep = CLASSD_LAST (ctxp->classd_list);
15389 JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15390 }
15391 else
15392 catch_clause_param = build_decl (VAR_DECL, wpv_id,
15393 build_pointer_type (type_or_name));
15394
15395 /* And a block */
15396 catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15397
15398 /* Initialize the variable and store in the block */
15399 catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15400 build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15401 add_stmt_to_block (catch_block, NULL_TREE, catch);
15402
15403 /* Add the catch statements */
15404 add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15405
15406 /* Now we can build a CATCH_EXPR */
15407 catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15408
15409 return build_try_statement (location, try_block, catch_block);
15410 }
15411
15412 static tree
15413 build_try_statement (int location, tree try_block, tree catches)
15414 {
15415 tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15416 EXPR_WFL_LINECOL (node) = location;
15417 return node;
15418 }
15419
15420 static tree
15421 build_try_finally_statement (int location, tree try_block, tree finally)
15422 {
15423 tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15424 EXPR_WFL_LINECOL (node) = location;
15425 return node;
15426 }
15427
15428 static tree
15429 patch_try_statement (tree node)
15430 {
15431 int error_found = 0;
15432 tree try = TREE_OPERAND (node, 0);
15433 /* Exception handlers are considered in left to right order */
15434 tree catch = nreverse (TREE_OPERAND (node, 1));
15435 tree current, caught_type_list = NULL_TREE;
15436
15437 /* Check catch clauses, if any. Every time we find an error, we try
15438 to process the next catch clause. We process the catch clause before
15439 the try block so that when processing the try block we can check thrown
15440 exceptions againts the caught type list. */
15441 for (current = catch; current; current = TREE_CHAIN (current))
15442 {
15443 tree carg_decl, carg_type;
15444 tree sub_current, catch_block, catch_clause;
15445 int unreachable;
15446
15447 /* At this point, the structure of the catch clause is
15448 CATCH_EXPR (catch node)
15449 BLOCK (with the decl of the parameter)
15450 COMPOUND_EXPR
15451 MODIFY_EXPR (assignment of the catch parameter)
15452 BLOCK (catch clause block)
15453 */
15454 catch_clause = TREE_OPERAND (current, 0);
15455 carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15456 carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15457
15458 /* Catch clauses can't have more than one parameter declared,
15459 but it's already enforced by the grammar. Make sure that the
15460 only parameter of the clause statement in of class Throwable
15461 or a subclass of Throwable, but that was done earlier. The
15462 catch clause parameter type has also been resolved. */
15463
15464 /* Just make sure that the catch clause parameter type inherits
15465 from java.lang.Throwable */
15466 if (!inherits_from_p (carg_type, throwable_type_node))
15467 {
15468 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15469 parse_error_context (wfl_operator,
15470 "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15471 lang_printable_name (carg_type, 0));
15472 error_found = 1;
15473 continue;
15474 }
15475
15476 /* Partial check for unreachable catch statement: The catch
15477 clause is reachable iff is no earlier catch block A in
15478 the try statement such that the type of the catch
15479 clause's parameter is the same as or a subclass of the
15480 type of A's parameter */
15481 unreachable = 0;
15482 for (sub_current = catch;
15483 sub_current != current; sub_current = TREE_CHAIN (sub_current))
15484 {
15485 tree sub_catch_clause, decl;
15486 sub_catch_clause = TREE_OPERAND (sub_current, 0);
15487 decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15488
15489 if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15490 {
15491 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15492 parse_error_context
15493 (wfl_operator,
15494 "`catch' not reached because of the catch clause at line %d",
15495 EXPR_WFL_LINENO (sub_current));
15496 unreachable = error_found = 1;
15497 break;
15498 }
15499 }
15500 /* Complete the catch clause block */
15501 catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15502 if (catch_block == error_mark_node)
15503 {
15504 error_found = 1;
15505 continue;
15506 }
15507 if (CAN_COMPLETE_NORMALLY (catch_block))
15508 CAN_COMPLETE_NORMALLY (node) = 1;
15509 TREE_OPERAND (current, 0) = catch_block;
15510
15511 if (unreachable)
15512 continue;
15513
15514 /* Things to do here: the exception must be thrown */
15515
15516 /* Link this type to the caught type list */
15517 caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15518 }
15519
15520 PUSH_EXCEPTIONS (caught_type_list);
15521 if ((try = java_complete_tree (try)) == error_mark_node)
15522 error_found = 1;
15523 if (CAN_COMPLETE_NORMALLY (try))
15524 CAN_COMPLETE_NORMALLY (node) = 1;
15525 POP_EXCEPTIONS ();
15526
15527 /* Verification ends here */
15528 if (error_found)
15529 return error_mark_node;
15530
15531 TREE_OPERAND (node, 0) = try;
15532 TREE_OPERAND (node, 1) = catch;
15533 TREE_TYPE (node) = void_type_node;
15534 return node;
15535 }
15536
15537 /* 14.17 The synchronized Statement */
15538
15539 static tree
15540 patch_synchronized_statement (tree node, tree wfl_op1)
15541 {
15542 tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15543 tree block = TREE_OPERAND (node, 1);
15544
15545 tree tmp, enter, exit, expr_decl, assignment;
15546
15547 if (expr == error_mark_node)
15548 {
15549 block = java_complete_tree (block);
15550 return expr;
15551 }
15552
15553 /* We might be trying to synchronize on a STRING_CST */
15554 if ((tmp = patch_string (expr)))
15555 expr = tmp;
15556
15557 /* The TYPE of expr must be a reference type */
15558 if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15559 {
15560 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15561 parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15562 lang_printable_name (TREE_TYPE (expr), 0));
15563 return error_mark_node;
15564 }
15565
15566 if (flag_emit_xref)
15567 {
15568 TREE_OPERAND (node, 0) = expr;
15569 TREE_OPERAND (node, 1) = java_complete_tree (block);
15570 CAN_COMPLETE_NORMALLY (node) = 1;
15571 return node;
15572 }
15573
15574 /* Generate a try-finally for the synchronized statement, except
15575 that the handler that catches all throw exception calls
15576 _Jv_MonitorExit and then rethrow the exception.
15577 The synchronized statement is then implemented as:
15578 TRY
15579 {
15580 _Jv_MonitorEnter (expression)
15581 synchronized_block
15582 _Jv_MonitorExit (expression)
15583 }
15584 CATCH_ALL
15585 {
15586 e = _Jv_exception_info ();
15587 _Jv_MonitorExit (expression)
15588 Throw (e);
15589 } */
15590
15591 expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15592 BUILD_MONITOR_ENTER (enter, expr_decl);
15593 BUILD_MONITOR_EXIT (exit, expr_decl);
15594 CAN_COMPLETE_NORMALLY (enter) = 1;
15595 CAN_COMPLETE_NORMALLY (exit) = 1;
15596 assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15597 TREE_SIDE_EFFECTS (assignment) = 1;
15598 node = build (COMPOUND_EXPR, NULL_TREE,
15599 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15600 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15601 node = build_expr_block (node, expr_decl);
15602
15603 return java_complete_tree (node);
15604 }
15605
15606 /* 14.16 The throw Statement */
15607
15608 static tree
15609 patch_throw_statement (tree node, tree wfl_op1)
15610 {
15611 tree expr = TREE_OPERAND (node, 0);
15612 tree type = TREE_TYPE (expr);
15613 int unchecked_ok = 0, tryblock_throws_ok = 0;
15614
15615 /* Thrown expression must be assignable to java.lang.Throwable */
15616 if (!try_reference_assignconv (throwable_type_node, expr))
15617 {
15618 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15619 parse_error_context (wfl_operator,
15620 "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15621 lang_printable_name (type, 0));
15622 /* If the thrown expression was a reference, we further the
15623 compile-time check. */
15624 if (!JREFERENCE_TYPE_P (type))
15625 return error_mark_node;
15626 }
15627
15628 /* At least one of the following must be true */
15629
15630 /* The type of the throw expression is a not checked exception,
15631 i.e. is a unchecked expression. */
15632 unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15633
15634 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15635 /* An instance can't throw a checked exception unless that exception
15636 is explicitly declared in the `throws' clause of each
15637 constructor. This doesn't apply to anonymous classes, since they
15638 don't have declared constructors. */
15639 if (!unchecked_ok
15640 && DECL_INSTINIT_P (current_function_decl)
15641 && !ANONYMOUS_CLASS_P (current_class))
15642 {
15643 tree current;
15644 for (current = TYPE_METHODS (current_class); current;
15645 current = TREE_CHAIN (current))
15646 if (DECL_CONSTRUCTOR_P (current)
15647 && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15648 {
15649 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)",
15650 lang_printable_name (TREE_TYPE (expr), 0));
15651 return error_mark_node;
15652 }
15653 }
15654
15655 /* Throw is contained in a try statement and at least one catch
15656 clause can receive the thrown expression or the current method is
15657 declared to throw such an exception. Or, the throw statement is
15658 contained in a method or constructor declaration and the type of
15659 the Expression is assignable to at least one type listed in the
15660 throws clause the declaration. */
15661 if (!unchecked_ok)
15662 tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15663 if (!(unchecked_ok || tryblock_throws_ok))
15664 {
15665 /* If there is a surrounding try block that has no matching
15666 clatch clause, report it first. A surrounding try block exits
15667 only if there is something after the list of checked
15668 exception thrown by the current function (if any). */
15669 if (IN_TRY_BLOCK_P ())
15670 parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15671 lang_printable_name (type, 0));
15672 /* If we have no surrounding try statement and the method doesn't have
15673 any throws, report it now. FIXME */
15674
15675 /* We report that the exception can't be throw from a try block
15676 in all circumstances but when the `throw' is inside a static
15677 block. */
15678 else if (!EXCEPTIONS_P (currently_caught_type_list)
15679 && !tryblock_throws_ok)
15680 {
15681 if (DECL_CLINIT_P (current_function_decl))
15682 parse_error_context (wfl_operator,
15683 "Checked exception `%s' can't be thrown in initializer",
15684 lang_printable_name (type, 0));
15685 else
15686 parse_error_context (wfl_operator,
15687 "Checked exception `%s' isn't thrown from a `try' block",
15688 lang_printable_name (type, 0));
15689 }
15690 /* Otherwise, the current method doesn't have the appropriate
15691 throws declaration */
15692 else
15693 parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15694 lang_printable_name (type, 0));
15695 return error_mark_node;
15696 }
15697
15698 if (! flag_emit_class_files && ! flag_emit_xref)
15699 BUILD_THROW (node, expr);
15700
15701 /* If doing xrefs, keep the location where the `throw' was seen. */
15702 if (flag_emit_xref)
15703 EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15704 return node;
15705 }
15706
15707 /* Check that exception said to be thrown by method DECL can be
15708 effectively caught from where DECL is invoked. THIS_EXPR is the
15709 expression that computes `this' for the method call. */
15710 static void
15711 check_thrown_exceptions (int location, tree decl, tree this_expr)
15712 {
15713 tree throws;
15714 int is_array_call = 0;
15715
15716 /* Skip check within generated methods, such as access$<n>. */
15717 if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15718 return;
15719
15720 if (this_expr != NULL_TREE
15721 && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15722 && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15723 is_array_call = 1;
15724
15725 /* For all the unchecked exceptions thrown by DECL. */
15726 for (throws = DECL_FUNCTION_THROWS (decl); throws;
15727 throws = TREE_CHAIN (throws))
15728 if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15729 {
15730 /* Suppress errors about cloning arrays. */
15731 if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15732 continue;
15733
15734 EXPR_WFL_LINECOL (wfl_operator) = location;
15735 if (DECL_FINIT_P (current_function_decl))
15736 parse_error_context
15737 (wfl_operator, "Exception `%s' can't be thrown in initializer",
15738 lang_printable_name (TREE_VALUE (throws), 0));
15739 else
15740 {
15741 parse_error_context
15742 (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15743 lang_printable_name (TREE_VALUE (throws), 0),
15744 (DECL_INIT_P (current_function_decl) ?
15745 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15746 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15747 }
15748 }
15749 }
15750
15751 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15752 try-catch blocks, OR is listed in the `throws' clause of the
15753 current method. */
15754
15755 static int
15756 check_thrown_exceptions_do (tree exception)
15757 {
15758 tree list = currently_caught_type_list;
15759 resolve_and_layout (exception, NULL_TREE);
15760 /* First, all the nested try-catch-finally at that stage. The
15761 last element contains `throws' clause exceptions, if any. */
15762 if (IS_UNCHECKED_EXCEPTION_P (exception))
15763 return 1;
15764 while (list)
15765 {
15766 tree caught;
15767 for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15768 if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15769 return 1;
15770 list = TREE_CHAIN (list);
15771 }
15772 return 0;
15773 }
15774
15775 static void
15776 purge_unchecked_exceptions (tree mdecl)
15777 {
15778 tree throws = DECL_FUNCTION_THROWS (mdecl);
15779 tree new = NULL_TREE;
15780
15781 while (throws)
15782 {
15783 tree next = TREE_CHAIN (throws);
15784 if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15785 {
15786 TREE_CHAIN (throws) = new;
15787 new = throws;
15788 }
15789 throws = next;
15790 }
15791 /* List is inverted here, but it doesn't matter */
15792 DECL_FUNCTION_THROWS (mdecl) = new;
15793 }
15794
15795 /* This function goes over all of CLASS_TYPE ctors and checks whether
15796 each of them features at least one unchecked exception in its
15797 `throws' clause. If it's the case, it returns `true', `false'
15798 otherwise. */
15799
15800 static bool
15801 ctors_unchecked_throws_clause_p (tree class_type)
15802 {
15803 tree current;
15804
15805 for (current = TYPE_METHODS (class_type); current;
15806 current = TREE_CHAIN (current))
15807 {
15808 bool ctu = false; /* Ctor Throws Unchecked */
15809 if (DECL_CONSTRUCTOR_P (current))
15810 {
15811 tree throws;
15812 for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15813 throws = TREE_CHAIN (throws))
15814 if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15815 ctu = true;
15816 }
15817 /* We return false as we found one ctor that is unfit. */
15818 if (!ctu && DECL_CONSTRUCTOR_P (current))
15819 return false;
15820 }
15821 /* All ctors feature at least one unchecked exception in their
15822 `throws' clause. */
15823 return true;
15824 }
15825
15826 /* 15.24 Conditional Operator ?: */
15827
15828 static tree
15829 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15830 {
15831 tree cond = TREE_OPERAND (node, 0);
15832 tree op1 = TREE_OPERAND (node, 1);
15833 tree op2 = TREE_OPERAND (node, 2);
15834 tree resulting_type = NULL_TREE;
15835 tree t1, t2, patched;
15836 int error_found = 0;
15837
15838 /* Operands of ?: might be StringBuffers crafted as a result of a
15839 string concatenation. Obtain a descent operand here. */
15840 if ((patched = patch_string (op1)))
15841 TREE_OPERAND (node, 1) = op1 = patched;
15842 if ((patched = patch_string (op2)))
15843 TREE_OPERAND (node, 2) = op2 = patched;
15844
15845 t1 = TREE_TYPE (op1);
15846 t2 = TREE_TYPE (op2);
15847
15848 /* The first expression must be a boolean */
15849 if (TREE_TYPE (cond) != boolean_type_node)
15850 {
15851 SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15852 parse_error_context (wfl_operator,
15853 "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15854 lang_printable_name (TREE_TYPE (cond), 0));
15855 error_found = 1;
15856 }
15857
15858 /* Second and third can be numeric, boolean (i.e. primitive),
15859 references or null. Anything else results in an error */
15860 if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15861 || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15862 && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15863 || (t1 == boolean_type_node && t2 == boolean_type_node)))
15864 error_found = 1;
15865
15866 /* Determine the type of the conditional expression. Same types are
15867 easy to deal with */
15868 else if (t1 == t2)
15869 resulting_type = t1;
15870
15871 /* There are different rules for numeric types */
15872 else if (JNUMERIC_TYPE_P (t1))
15873 {
15874 /* if byte/short found, the resulting type is short */
15875 if ((t1 == byte_type_node && t2 == short_type_node)
15876 || (t1 == short_type_node && t2 == byte_type_node))
15877 resulting_type = short_type_node;
15878
15879 /* If t1 is a constant int and t2 is of type byte, short or char
15880 and t1's value fits in t2, then the resulting type is t2 */
15881 else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15882 && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15883 resulting_type = t2;
15884
15885 /* If t2 is a constant int and t1 is of type byte, short or char
15886 and t2's value fits in t1, then the resulting type is t1 */
15887 else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15888 && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15889 resulting_type = t1;
15890
15891 /* Otherwise, binary numeric promotion is applied and the
15892 resulting type is the promoted type of operand 1 and 2 */
15893 else
15894 resulting_type = binary_numeric_promotion (t1, t2,
15895 &TREE_OPERAND (node, 1),
15896 &TREE_OPERAND (node, 2));
15897 }
15898
15899 /* Cases of a reference and a null type */
15900 else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15901 resulting_type = t1;
15902
15903 else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15904 resulting_type = t2;
15905
15906 /* Last case: different reference types. If a type can be converted
15907 into the other one by assignment conversion, the latter
15908 determines the type of the expression */
15909 else if ((resulting_type = try_reference_assignconv (t1, op2)))
15910 resulting_type = promote_type (t1);
15911
15912 else if ((resulting_type = try_reference_assignconv (t2, op1)))
15913 resulting_type = promote_type (t2);
15914
15915 /* If we don't have any resulting type, we're in trouble */
15916 if (!resulting_type)
15917 {
15918 char *t = xstrdup (lang_printable_name (t1, 0));
15919 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15920 parse_error_context (wfl_operator,
15921 "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15922 t, lang_printable_name (t2, 0));
15923 free (t);
15924 error_found = 1;
15925 }
15926
15927 if (error_found)
15928 {
15929 TREE_TYPE (node) = error_mark_node;
15930 return error_mark_node;
15931 }
15932
15933 TREE_TYPE (node) = resulting_type;
15934 TREE_SET_CODE (node, COND_EXPR);
15935 CAN_COMPLETE_NORMALLY (node) = 1;
15936 return node;
15937 }
15938
15939 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15940
15941 static tree
15942 maybe_build_class_init_for_field (tree decl, tree expr)
15943 {
15944 tree clas = DECL_CONTEXT (decl);
15945 if (flag_emit_class_files || flag_emit_xref)
15946 return expr;
15947
15948 if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15949 && FIELD_FINAL (decl))
15950 {
15951 tree init = DECL_INITIAL (decl);
15952 if (init != NULL_TREE)
15953 init = fold_constant_for_init (init, decl);
15954 if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15955 return expr;
15956 }
15957
15958 return build_class_init (clas, expr);
15959 }
15960
15961 /* Try to constant fold NODE.
15962 If NODE is not a constant expression, return NULL_EXPR.
15963 CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15964
15965 static tree
15966 fold_constant_for_init (tree node, tree context)
15967 {
15968 tree op0, op1, val;
15969 enum tree_code code = TREE_CODE (node);
15970
15971 switch (code)
15972 {
15973 case INTEGER_CST:
15974 if (node == null_pointer_node)
15975 return NULL_TREE;
15976 case STRING_CST:
15977 case REAL_CST:
15978 return node;
15979
15980 case PLUS_EXPR:
15981 case MINUS_EXPR:
15982 case MULT_EXPR:
15983 case TRUNC_MOD_EXPR:
15984 case RDIV_EXPR:
15985 case LSHIFT_EXPR:
15986 case RSHIFT_EXPR:
15987 case URSHIFT_EXPR:
15988 case BIT_AND_EXPR:
15989 case BIT_XOR_EXPR:
15990 case BIT_IOR_EXPR:
15991 case TRUTH_ANDIF_EXPR:
15992 case TRUTH_ORIF_EXPR:
15993 case EQ_EXPR:
15994 case NE_EXPR:
15995 case GT_EXPR:
15996 case GE_EXPR:
15997 case LT_EXPR:
15998 case LE_EXPR:
15999 op0 = TREE_OPERAND (node, 0);
16000 op1 = TREE_OPERAND (node, 1);
16001 val = fold_constant_for_init (op0, context);
16002 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16003 return NULL_TREE;
16004 TREE_OPERAND (node, 0) = val;
16005 val = fold_constant_for_init (op1, context);
16006 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16007 return NULL_TREE;
16008 TREE_OPERAND (node, 1) = val;
16009 return patch_binop (node, op0, op1);
16010
16011 case UNARY_PLUS_EXPR:
16012 case NEGATE_EXPR:
16013 case TRUTH_NOT_EXPR:
16014 case BIT_NOT_EXPR:
16015 case CONVERT_EXPR:
16016 op0 = TREE_OPERAND (node, 0);
16017 val = fold_constant_for_init (op0, context);
16018 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16019 return NULL_TREE;
16020 TREE_OPERAND (node, 0) = val;
16021 val = patch_unaryop (node, op0);
16022 if (! TREE_CONSTANT (val))
16023 return NULL_TREE;
16024 return val;
16025
16026 break;
16027
16028 case COND_EXPR:
16029 val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16030 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16031 return NULL_TREE;
16032 TREE_OPERAND (node, 0) = val;
16033 val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16034 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16035 return NULL_TREE;
16036 TREE_OPERAND (node, 1) = val;
16037 val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16038 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16039 return NULL_TREE;
16040 TREE_OPERAND (node, 2) = val;
16041 return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16042 : TREE_OPERAND (node, 2);
16043
16044 case VAR_DECL:
16045 case FIELD_DECL:
16046 if (! FIELD_FINAL (node)
16047 || DECL_INITIAL (node) == NULL_TREE)
16048 return NULL_TREE;
16049 val = DECL_INITIAL (node);
16050 /* Guard against infinite recursion. */
16051 DECL_INITIAL (node) = NULL_TREE;
16052 val = fold_constant_for_init (val, node);
16053 if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16054 val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16055 DECL_INITIAL (node) = val;
16056 return val;
16057
16058 case EXPR_WITH_FILE_LOCATION:
16059 /* Compare java_complete_tree and resolve_expression_name. */
16060 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16061 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16062 {
16063 tree name = EXPR_WFL_NODE (node);
16064 tree decl;
16065 if (PRIMARY_P (node))
16066 return NULL_TREE;
16067 else if (! QUALIFIED_P (name))
16068 {
16069 decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16070 if (decl == NULL_TREE
16071 || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16072 return NULL_TREE;
16073 return fold_constant_for_init (decl, decl);
16074 }
16075 else
16076 {
16077 /* Install the proper context for the field resolution.
16078 The prior context is restored once the name is
16079 properly qualified. */
16080 tree saved_current_class = current_class;
16081 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
16082 current_class = DECL_CONTEXT (context);
16083 qualify_ambiguous_name (node);
16084 current_class = saved_current_class;
16085 if (resolve_field_access (node, &decl, NULL)
16086 && decl != NULL_TREE)
16087 return fold_constant_for_init (decl, decl);
16088 return NULL_TREE;
16089 }
16090 }
16091 else
16092 {
16093 op0 = TREE_OPERAND (node, 0);
16094 val = fold_constant_for_init (op0, context);
16095 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16096 return NULL_TREE;
16097 TREE_OPERAND (node, 0) = val;
16098 return val;
16099 }
16100
16101 #ifdef USE_COMPONENT_REF
16102 case IDENTIFIER:
16103 case COMPONENT_REF:
16104 ?;
16105 #endif
16106
16107 default:
16108 return NULL_TREE;
16109 }
16110 }
16111
16112 #ifdef USE_COMPONENT_REF
16113 /* Context is 'T' for TypeName, 'P' for PackageName,
16114 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16115
16116 tree
16117 resolve_simple_name (tree name, int context)
16118 {
16119 }
16120
16121 tree
16122 resolve_qualified_name (tree name, int context)
16123 {
16124 }
16125 #endif
16126
16127 void
16128 init_src_parse (void)
16129 {
16130 /* Sanity check; we've been bit by this before. */
16131 if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16132 abort ();
16133 }
16134
16135 \f
16136
16137 /* This section deals with the functions that are called when tables
16138 recording class initialization information are traversed. */
16139
16140 /* Attach to PTR (a block) the declaration found in ENTRY. */
16141
16142 static int
16143 attach_init_test_initialization_flags (void **entry, void *ptr)
16144 {
16145 tree block = (tree)ptr;
16146 struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16147
16148 if (block != error_mark_node)
16149 {
16150 TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16151 BLOCK_EXPR_DECLS (block) = ite->value;
16152 }
16153 return true;
16154 }
16155
16156 /* This function is called for each class that is known definitely
16157 initialized when a given static method was called. This function
16158 augments a compound expression (INFO) storing all assignment to
16159 initialized static class flags if a flag already existed, otherwise
16160 a new one is created. */
16161
16162 static int
16163 emit_test_initialization (void **entry_p, void *info)
16164 {
16165 tree l = (tree) info;
16166 tree decl, init;
16167 tree key = (tree) *entry_p;
16168 tree *ite;
16169 htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16170
16171 /* If we haven't found a flag and we're dealing with self registered
16172 with current_function_decl, then don't do anything. Self is
16173 always added as definitely initialized but this information is
16174 valid only if used outside the current function. */
16175 if (current_function_decl == TREE_PURPOSE (l)
16176 && java_treetreehash_find (cf_ht, key) == NULL)
16177 return true;
16178
16179 ite = java_treetreehash_new (cf_ht, key);
16180
16181 /* If we don't have a variable, create one and install it. */
16182 if (*ite == NULL)
16183 {
16184 tree block;
16185
16186 decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16187 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16188 LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16189 DECL_CONTEXT (decl) = current_function_decl;
16190 DECL_INITIAL (decl) = boolean_true_node;
16191 /* Don't emit any symbolic debugging info for this decl. */
16192 DECL_IGNORED_P (decl) = 1;
16193
16194 /* The trick is to find the right context for it. */
16195 block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16196 TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16197 BLOCK_EXPR_DECLS (block) = decl;
16198 *ite = decl;
16199 }
16200 else
16201 decl = *ite;
16202
16203 /* Now simply augment the compound that holds all the assignments
16204 pertaining to this method invocation. */
16205 init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16206 TREE_SIDE_EFFECTS (init) = 1;
16207 TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16208 TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16209
16210 return true;
16211 }
16212
16213 #include "gt-java-parse.h"
16214 #include "gtype-java.h"
Mirror of the offical gcc git repository hosted at gcc.gnu.org