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)
7 This file is part of GCC.
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)
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.
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.
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. */
28 /* This file parses java source code and issues a tree node image
29 suitable for code generation (byte code and targeted CPU assembly
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"
36 The following modifications were brought to the original grammar:
38 method_body: added the rule '| block SC_TK'
39 static_initializer: added the rule 'static block SC_TK'.
41 Note: All the extra rules described above should go away when the
42 empty_statement rule will work.
44 statement_nsi: 'nsi' should be read no_short_if.
46 Some rules have been modified to support JDK1.1 inner classes
47 definitions and other extensions. */
52 #include "coretypes.h"
60 #include "pretty-print.h"
61 #include "diagnostic.h"
63 #include "java-tree.h"
75 #include "tree-inline.h"
79 /* Local function prototypes */
80 static char *java_accstring_lookup (int);
81 static const char *accessibility_string (int);
82 static void classitf_redefinition_error (const char *,tree, tree, tree);
83 static void variable_redefinition_error (tree, tree, tree, int);
84 static tree create_class (int, tree, tree, tree);
85 static tree create_interface (int, tree, tree);
86 static void end_class_declaration (int);
87 static tree find_field (tree, tree);
88 static tree lookup_field_wrapper (tree, tree);
89 static int duplicate_declaration_error_p (tree, tree, tree);
90 static void register_fields (int, tree, tree);
91 static tree parser_qualified_classname (tree);
92 static int parser_check_super (tree, tree, tree);
93 static int parser_check_super_interface (tree, tree, tree);
94 static void check_modifiers_consistency (int);
95 static tree lookup_cl (tree);
96 static tree lookup_java_method2 (tree, tree, int);
97 static tree method_header (int, tree, tree, tree);
98 static void fix_method_argument_names (tree ,tree);
99 static tree method_declarator (tree, tree);
100 static void parse_warning_context (tree cl, const char *msgid, ...);
101 #ifdef USE_MAPPED_LOCATION
102 static void issue_warning_error_from_context
103 (source_location, const char *msgid, va_list *);
105 static void issue_warning_error_from_context
106 (tree, const char *msgid, va_list *);
108 static void parse_ctor_invocation_error (void);
109 static tree parse_jdk1_1_error (const char *);
110 static void complete_class_report_errors (jdep *);
111 static int process_imports (void);
112 static void read_import_dir (tree);
113 static int find_in_imports_on_demand (tree, tree);
114 static void find_in_imports (tree, tree);
115 static void check_inner_class_access (tree, tree, tree);
116 static int check_pkg_class_access (tree, tree, bool, tree);
117 static void register_package (tree);
118 static tree resolve_package (tree, tree *, tree *);
119 static tree resolve_class (tree, tree, tree, tree);
120 static void declare_local_variables (int, tree, tree);
121 static void dump_java_tree (enum tree_dump_index, tree);
122 static void source_start_java_method (tree);
123 static void source_end_java_method (void);
124 static tree find_name_in_single_imports (tree);
125 static void check_abstract_method_header (tree);
126 static tree lookup_java_interface_method2 (tree, tree);
127 static tree resolve_expression_name (tree, tree *);
128 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
129 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
130 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
131 static tree resolve_and_layout (tree, tree);
132 static tree qualify_and_find (tree, tree, tree);
133 static tree resolve_no_layout (tree, tree);
134 static int invocation_mode (tree, int);
135 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
136 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
137 static tree find_most_specific_methods_list (tree);
138 static int argument_types_convertible (tree, tree);
139 static tree patch_invoke (tree, tree, tree);
140 static int maybe_use_access_method (int, tree *, tree *);
141 static tree lookup_method_invoke (int, tree, tree, tree, tree);
142 static tree register_incomplete_type (int, tree, tree, tree);
143 static tree check_inner_circular_reference (tree, tree);
144 static tree check_circular_reference (tree);
145 static tree obtain_incomplete_type (tree);
146 static tree java_complete_lhs (tree);
147 static tree java_complete_tree (tree);
148 static tree maybe_generate_pre_expand_clinit (tree);
149 static int analyze_clinit_body (tree, tree);
150 static int maybe_yank_clinit (tree);
151 static void start_complete_expand_method (tree);
152 static void java_complete_expand_method (tree);
153 static void java_expand_method_bodies (tree);
154 static int unresolved_type_p (tree, tree *);
155 static void create_jdep_list (struct parser_ctxt *);
156 static tree build_expr_block (tree, tree);
157 static tree enter_block (void);
158 static tree exit_block (void);
159 static tree lookup_name_in_blocks (tree);
160 static void maybe_absorb_scoping_blocks (void);
161 static tree build_method_invocation (tree, tree);
162 static tree build_new_invocation (tree, tree);
163 static tree build_assignment (int, int, tree, tree);
164 static tree build_binop (enum tree_code, int, tree, tree);
165 static tree patch_assignment (tree, tree);
166 static tree patch_binop (tree, tree, tree);
167 static tree build_unaryop (int, int, tree);
168 static tree build_incdec (int, int, tree, int);
169 static tree patch_unaryop (tree, tree);
170 static tree build_cast (int, tree, tree);
171 static tree build_null_of_type (tree);
172 static tree patch_cast (tree, tree);
173 static int valid_ref_assignconv_cast_p (tree, tree, int);
174 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
175 static int valid_cast_to_p (tree, tree);
176 static int valid_method_invocation_conversion_p (tree, tree);
177 static tree try_builtin_assignconv (tree, tree, tree);
178 static tree try_reference_assignconv (tree, tree);
179 static tree build_unresolved_array_type (tree);
180 static int build_type_name_from_array_name (tree, tree *);
181 static tree build_array_from_name (tree, tree, tree, tree *);
182 static tree build_array_ref (int, tree, tree);
183 static tree patch_array_ref (tree);
184 #ifdef USE_MAPPED_LOCATION
185 static tree make_qualified_name (tree, tree, source_location);
187 static tree make_qualified_name (tree, tree, int);
189 static tree merge_qualified_name (tree, tree);
190 static tree make_qualified_primary (tree, tree, int);
191 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
192 static void qualify_ambiguous_name (tree);
193 static tree resolve_field_access (tree, tree *, tree *);
194 static tree build_newarray_node (tree, tree, int);
195 static tree patch_newarray (tree);
196 static tree resolve_type_during_patch (tree);
197 static tree build_this (int);
198 static tree build_wfl_wrap (tree, int);
199 static tree build_return (int, tree);
200 static tree patch_return (tree);
201 static tree maybe_access_field (tree, tree, tree);
202 static int complete_function_arguments (tree);
203 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
204 static int not_accessible_p (tree, tree, tree, int);
205 static void check_deprecation (tree, tree);
206 static int class_in_current_package (tree);
207 static tree build_if_else_statement (int, tree, tree, tree);
208 static tree patch_if_else_statement (tree);
209 static tree add_stmt_to_block (tree, tree, tree);
210 static tree patch_exit_expr (tree);
211 static tree build_labeled_block (int, tree);
212 static tree finish_labeled_statement (tree, tree);
213 static tree build_bc_statement (int, int, tree);
214 static tree patch_bc_statement (tree);
215 static tree patch_loop_statement (tree);
216 static tree build_new_loop (tree);
217 static tree build_loop_body (int, tree, int);
218 static tree finish_loop_body (int, tree, tree, int);
219 static tree build_debugable_stmt (int, tree);
220 static tree finish_for_loop (int, tree, tree, tree);
221 static tree patch_switch_statement (tree);
222 static tree string_constant_concatenation (tree, tree);
223 static tree build_string_concatenation (tree, tree);
224 static tree patch_string_cst (tree);
225 static tree patch_string (tree);
226 static tree encapsulate_with_try_catch (int, tree, tree, tree);
227 #ifdef USE_MAPPED_LOCATION
228 static tree build_assertion (source_location, tree, tree);
230 static tree build_assertion (int, tree, tree);
232 static tree build_try_statement (int, tree, tree);
233 static tree build_try_finally_statement (int, tree, tree);
234 static tree patch_try_statement (tree);
235 static tree patch_synchronized_statement (tree, tree);
236 static tree patch_throw_statement (tree, tree);
237 #ifdef USE_MAPPED_LOCATION
238 static void check_thrown_exceptions (source_location, tree, tree);
240 static void check_thrown_exceptions (int, tree, tree);
242 static int check_thrown_exceptions_do (tree);
243 static void purge_unchecked_exceptions (tree);
244 static bool ctors_unchecked_throws_clause_p (tree);
245 static void check_concrete_throws_clauses (tree, tree, tree, tree);
246 static void check_throws_clauses (tree, tree, tree);
247 static void finish_method_declaration (tree);
248 static tree build_super_invocation (tree);
249 static int verify_constructor_circularity (tree, tree);
250 static char *constructor_circularity_msg (tree, tree);
251 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
252 static const char *get_printable_method_name (tree);
253 static tree patch_conditional_expr (tree, tree, tree);
254 static tree generate_finit (tree);
255 static tree generate_instinit (tree);
256 static tree build_instinit_invocation (tree);
257 static void fix_constructors (tree);
258 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
259 static tree craft_constructor (tree, tree);
260 static int verify_constructor_super (tree);
261 static tree create_artificial_method (tree, int, tree, tree, tree);
262 static void start_artificial_method_body (tree);
263 static void end_artificial_method_body (tree);
264 static int check_method_redefinition (tree, tree);
265 static int check_method_types_complete (tree);
266 static bool hack_is_accessible_p (tree, tree);
267 static void java_check_regular_methods (tree);
268 static void check_interface_throws_clauses (tree, tree);
269 static void java_check_abstract_methods (tree);
270 static void unreachable_stmt_error (tree);
271 static int not_accessible_field_error (tree, tree);
272 static tree find_expr_with_wfl (tree);
273 static void missing_return_error (tree);
274 static tree build_new_array_init (int, tree);
275 static tree patch_new_array_init (tree, tree);
276 static tree maybe_build_array_element_wfl (tree);
277 static int array_constructor_check_entry (tree, tree);
278 static const char *purify_type_name (const char *);
279 static tree fold_constant_for_init (tree, tree);
280 static tree strip_out_static_field_access_decl (tree);
281 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
282 static void static_ref_err (tree, tree, tree);
283 static void parser_add_interface (tree, tree, tree);
284 static void add_superinterfaces (tree, tree);
285 static tree jdep_resolve_class (jdep *);
286 static int note_possible_classname (const char *, int);
287 static void java_complete_expand_classes (void);
288 static void java_complete_expand_class (tree);
289 static void java_complete_expand_methods (tree);
290 static tree cut_identifier_in_qualified (tree);
291 static tree java_stabilize_reference (tree);
292 static tree do_unary_numeric_promotion (tree);
293 static char * operator_string (tree);
294 static tree do_merge_string_cste (tree, const char *, int, int);
295 static tree merge_string_cste (tree, tree, int);
296 static tree java_refold (tree);
297 static int java_decl_equiv (tree, tree);
298 static int binop_compound_p (enum tree_code);
299 static tree search_loop (tree);
300 static int labeled_block_contains_loop_p (tree, tree);
301 static int check_abstract_method_definitions (int, tree, tree);
302 static void java_check_abstract_method_definitions (tree);
303 static void java_debug_context_do (int);
304 static void java_parser_context_push_initialized_field (void);
305 static void java_parser_context_pop_initialized_field (void);
306 static tree reorder_static_initialized (tree);
307 static void java_parser_context_suspend (void);
308 static void java_parser_context_resume (void);
309 static int pop_current_osb (struct parser_ctxt *);
311 /* JDK 1.1 work. FIXME */
313 static tree maybe_make_nested_class_name (tree);
314 static int make_nested_class_name (tree);
315 static void link_nested_class_to_enclosing (void);
316 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
317 static tree find_as_inner_class (tree, tree, tree);
318 static tree find_as_inner_class_do (tree, tree);
319 static int check_inner_class_redefinition (tree, tree);
321 static tree build_thisn_assign (void);
322 static tree build_current_thisn (tree);
323 static tree build_access_to_thisn (tree, tree, int);
324 static tree maybe_build_thisn_access_method (tree);
326 static tree build_outer_field_access (tree, tree);
327 static tree build_outer_field_access_methods (tree);
328 static tree build_outer_field_access_expr (int, tree, tree,
330 static tree build_outer_method_access_method (tree);
331 static tree build_new_access_id (void);
332 static tree build_outer_field_access_method (tree, tree, tree,
335 static int outer_field_access_p (tree, tree);
336 static int outer_field_expanded_access_p (tree, tree *,
338 static tree outer_field_access_fix (tree, tree, tree);
339 static tree build_incomplete_class_ref (int, tree);
340 static tree patch_incomplete_class_ref (tree);
341 static tree create_anonymous_class (tree);
342 static void patch_anonymous_class (tree, tree, tree);
343 static void add_inner_class_fields (tree, tree);
345 static tree build_dot_class_method (tree);
346 static tree build_dot_class_method_invocation (tree, tree);
347 static void create_new_parser_context (int);
348 static tree maybe_build_class_init_for_field (tree, tree);
350 static int attach_init_test_initialization_flags (void **, void *);
351 static int emit_test_initialization (void **, void *);
353 static char *string_convert_int_cst (tree);
355 /* Number of error found so far. */
356 int java_error_count;
357 /* Number of warning found so far. */
358 int java_warning_count;
359 /* Tell when not to fold, when doing xrefs */
361 /* Cyclic inheritance report, as it can be set by layout_class */
362 const char *cyclic_inheritance_report;
364 /* The current parser context */
365 struct parser_ctxt *ctxp;
367 /* List of things that were analyzed for which code will be generated */
368 struct parser_ctxt *ctxp_for_generation = NULL;
370 /* binop_lookup maps token to tree_code. It is used where binary
371 operations are involved and required by the parser. RDIV_EXPR
372 covers both integral/floating point division. The code is changed
373 once the type of both operator is worked out. */
375 static const enum tree_code binop_lookup[19] =
377 PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
378 LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
379 BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
380 TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
381 EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
383 #define BINOP_LOOKUP(VALUE) \
384 binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
386 /* This is the end index for binary operators that can also be used
387 in compound assignments. */
388 #define BINOP_COMPOUND_CANDIDATES 11
390 /* The "$L" identifier we use to create labels. */
391 static GTY(()) tree label_id;
393 /* The "StringBuffer" identifier used for the String `+' operator. */
394 static GTY(()) tree wfl_string_buffer;
396 /* The "append" identifier used for String `+' operator. */
397 static GTY(()) tree wfl_append;
399 /* The "toString" identifier used for String `+' operator. */
400 static GTY(()) tree wfl_to_string;
402 /* The "java.lang" import qualified name. */
403 static GTY(()) tree java_lang_id;
405 /* The generated `inst$' identifier used for generated enclosing
406 instance/field access functions. */
407 static GTY(()) tree inst_id;
409 /* Context and flag for static blocks */
410 static GTY(()) tree current_static_block;
412 /* The generated `write_parm_value$' identifier. */
413 static GTY(()) tree wpv_id;
415 /* The list of all packages we've seen so far */
416 static GTY(()) tree package_list;
418 /* Hold THIS for the scope of the current method decl. */
419 static GTY(()) tree current_this;
421 /* Hold a list of catch clauses list. The first element of this list is
422 the list of the catch clauses of the currently analyzed try block. */
423 static GTY(()) tree currently_caught_type_list;
425 /* This holds a linked list of all the case labels for the current
426 switch statement. It is only used when checking to see if there
427 are duplicate labels. FIXME: probably this should just be attached
428 to the switch itself; then it could be referenced via
429 `ctxp->current_loop'. */
430 static GTY(()) tree case_label_list;
432 /* Anonymous class counter. Will be reset to 1 every time a non
433 anonymous class gets created. */
434 static int anonymous_class_counter = 1;
436 static GTY(()) tree src_parse_roots[1];
438 /* All classes seen from source code */
439 #define gclass_list src_parse_roots[0]
441 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
442 line and point it out. */
443 /* Should point out the one that don't fit. ASCII/unicode, going
446 #define check_modifiers(__message, __value, __mask) do { \
447 if ((__value) & ~(__mask)) \
449 size_t i, remainder = (__value) & ~(__mask); \
450 for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++) \
451 if ((1 << i) & remainder) \
452 parse_error_context (ctxp->modifier_ctx [i], (__message), \
453 java_accstring_lookup (1 << i)); \
464 #ifdef USE_MAPPED_LOCATION
465 source_location location;
474 #ifdef USE_MAPPED_LOCATION
475 #define SET_EXPR_LOCATION_FROM_TOKEN(EXPR, TOKEN) \
476 SET_EXPR_LOCATION(EXPR, (TOKEN).location)
478 #define SET_EXPR_LOCATION_FROM_TOKEN(EXPR, TOKEN) \
479 (EXPR_WFL_LINECOL (EXPR) = (TOKEN).location)
487 /* Things defined here have to match the order of what's in the
488 binop_lookup table. */
490 %token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
491 %token LS_TK SRS_TK ZRS_TK
492 %token AND_TK XOR_TK OR_TK
493 %token BOOL_AND_TK BOOL_OR_TK
494 %token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
496 /* This maps to the same binop_lookup entry than the token above */
498 %token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
500 %token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
501 %token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
504 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
506 %token PUBLIC_TK PRIVATE_TK PROTECTED_TK
507 %token STATIC_TK FINAL_TK SYNCHRONIZED_TK
508 %token VOLATILE_TK TRANSIENT_TK NATIVE_TK
509 %token PAD_TK ABSTRACT_TK STRICT_TK
512 /* Keep those two in order, too */
513 %token DECR_TK INCR_TK
515 /* From now one, things can be in any order */
517 %token DEFAULT_TK IF_TK THROW_TK
518 %token BOOLEAN_TK DO_TK IMPLEMENTS_TK
519 %token THROWS_TK BREAK_TK IMPORT_TK
520 %token ELSE_TK INSTANCEOF_TK RETURN_TK
521 %token VOID_TK CATCH_TK INTERFACE_TK
522 %token CASE_TK EXTENDS_TK FINALLY_TK
523 %token SUPER_TK WHILE_TK CLASS_TK
524 %token SWITCH_TK CONST_TK TRY_TK
525 %token FOR_TK NEW_TK CONTINUE_TK
526 %token GOTO_TK PACKAGE_TK THIS_TK
529 %token BYTE_TK SHORT_TK INT_TK LONG_TK
530 %token CHAR_TK INTEGRAL_TK
532 %token FLOAT_TK DOUBLE_TK FP_TK
536 %token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
538 %token ASSIGN_ANY_TK ASSIGN_TK
539 %token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
541 %token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
542 %token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
544 %type <value> modifiers MODIFIER_TK final synchronized
546 %type <node> super ID_TK identifier
547 %type <node> name simple_name qualified_name
548 %type <node> type_declaration compilation_unit
549 field_declaration method_declaration extends_interfaces
550 interfaces interface_type_list
551 import_declarations package_declaration
552 type_declarations interface_body
553 interface_member_declaration constant_declaration
554 interface_member_declarations interface_type
555 abstract_method_declaration
556 %type <node> class_body_declaration class_member_declaration
557 static_initializer constructor_declaration block
558 %type <node> class_body_declarations constructor_header
559 %type <node> class_or_interface_type class_type class_type_list
560 constructor_declarator explicit_constructor_invocation
561 %type <node> dim_expr dim_exprs this_or_super throws
563 %type <node> variable_declarator_id variable_declarator
564 variable_declarators variable_initializer
565 variable_initializers constructor_body
568 %type <node> class_body block_end constructor_block_end
569 %type <node> statement statement_without_trailing_substatement
570 labeled_statement if_then_statement label_decl
571 if_then_else_statement while_statement for_statement
572 statement_nsi labeled_statement_nsi do_statement
573 if_then_else_statement_nsi while_statement_nsi
574 for_statement_nsi statement_expression_list for_init
575 for_update statement_expression expression_statement
576 primary_no_new_array expression primary array_type
577 array_creation_initialized array_creation_uninitialized
578 class_instance_creation_expression field_access
579 method_invocation array_access something_dot_new
580 argument_list postfix_expression while_expression
581 post_increment_expression post_decrement_expression
582 unary_expression_not_plus_minus unary_expression
583 pre_increment_expression pre_decrement_expression
585 multiplicative_expression additive_expression
586 shift_expression relational_expression
587 equality_expression and_expression
588 exclusive_or_expression inclusive_or_expression
589 conditional_and_expression conditional_or_expression
590 conditional_expression assignment_expression
591 left_hand_side assignment for_header for_begin
592 constant_expression do_statement_begin empty_statement
593 switch_statement synchronized_statement throw_statement
594 try_statement assert_statement
595 switch_expression switch_block
596 catches catch_clause catch_clause_parameter finally
597 anonymous_class_creation trap_overflow_corner_case
598 %type <node> return_statement break_statement continue_statement
600 %type <operator> ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
601 %type <operator> REM_ASSIGN_TK PLUS_ASSIGN_TK MINUS_ASSIGN_TK
602 %type <operator> LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
603 %type <operator> AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
604 %type <operator> ASSIGN_ANY_TK assignment_operator
605 %token <operator> EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
606 %token <operator> BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
607 %token <operator> DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
608 %token <operator> NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
609 %token <operator> OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
610 %type <operator> THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
611 %type <operator> CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
612 %type <operator> NEW_TK ASSERT_TK
614 %type <node> method_body
616 %type <node> literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
617 STRING_LIT_TK NULL_TK VOID_TK
619 %type <node> IF_TK WHILE_TK FOR_TK
621 %type <node> formal_parameter_list formal_parameter
622 method_declarator method_header
624 %type <node> primitive_type reference_type type
625 BOOLEAN_TK INTEGRAL_TK FP_TK
627 /* Added or modified JDK 1.1 rule types */
628 %type <node> type_literals
631 /* 19.2 Production from 2.3: The Syntactic Grammar */
632 goal: compilation_unit
636 /* 19.3 Productions from 3: Lexical structure */
646 /* 19.4 Productions from 4: Types, Values and Variables */
659 class_or_interface_type
663 class_or_interface_type:
668 class_or_interface_type /* Default rule */
672 class_or_interface_type
678 int osb = pop_current_osb (ctxp);
679 tree t = build_java_array_type (($1), -1);
681 t = build_unresolved_array_type (t);
686 int osb = pop_current_osb (ctxp);
689 t = build_unresolved_array_type (t);
694 /* 19.5 Productions from 6: Names */
696 simple_name /* Default rule */
697 | qualified_name /* Default rule */
701 identifier /* Default rule */
705 name DOT_TK identifier
706 { $$ = make_qualified_name ($1, $3, $2.location); }
713 /* 19.6: Production from 7: Packages */
716 | package_declaration
717 | import_declarations
719 | package_declaration import_declarations
720 | package_declaration type_declarations
721 | import_declarations type_declarations
722 | package_declaration import_declarations type_declarations
730 | import_declarations import_declaration
738 | type_declarations type_declaration
742 PACKAGE_TK name SC_TK
744 ctxp->package = EXPR_WFL_NODE ($2);
745 register_package (ctxp->package);
748 {yyerror ("Missing name"); RECOVER;}
749 | PACKAGE_TK name error
750 {yyerror ("';' expected"); RECOVER;}
754 single_type_import_declaration
755 | type_import_on_demand_declaration
758 single_type_import_declaration:
761 tree name = EXPR_WFL_NODE ($2), last_name;
762 int i = IDENTIFIER_LENGTH (name)-1;
763 const char *last = &IDENTIFIER_POINTER (name)[i];
764 while (last != IDENTIFIER_POINTER (name))
770 last_name = get_identifier (++last);
771 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
773 tree err = find_name_in_single_imports (last_name);
774 if (err && err != name)
776 ($2, "Ambiguous class: %qs and %qs",
777 IDENTIFIER_POINTER (name),
778 IDENTIFIER_POINTER (err));
780 REGISTER_IMPORT ($2, last_name);
783 REGISTER_IMPORT ($2, last_name);
786 {yyerror ("Missing name"); RECOVER;}
787 | IMPORT_TK name error
788 {yyerror ("';' expected"); RECOVER;}
791 type_import_on_demand_declaration:
792 IMPORT_TK name DOT_TK MULT_TK SC_TK
794 tree name = EXPR_WFL_NODE ($2);
796 /* Search for duplicates. */
797 for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
798 if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
800 /* Don't import the same thing more than once, just ignore
801 duplicates (7.5.2) */
804 read_import_dir ($2);
805 ctxp->import_demand_list =
806 chainon (ctxp->import_demand_list,
807 build_tree_list ($2, NULL_TREE));
810 | IMPORT_TK name DOT_TK error
811 {yyerror ("'*' expected"); RECOVER;}
812 | IMPORT_TK name DOT_TK MULT_TK error
813 {yyerror ("';' expected"); RECOVER;}
818 { end_class_declaration (0); }
819 | interface_declaration
820 { end_class_declaration (0); }
825 yyerror ("Class or interface declaration expected");
829 /* 19.7 Shortened from the original:
830 modifiers: modifier | modifiers modifier
831 modifier: any of public... */
837 | modifiers MODIFIER_TK
842 (ctxp->modifier_ctx [$2], "Modifier %qs declared twice",
843 java_accstring_lookup (acc));
851 /* 19.8.1 Production from $8.1: Class Declaration */
853 modifiers CLASS_TK identifier super interfaces
854 { create_class ($1, $3, $4, $5); }
857 | CLASS_TK identifier super interfaces
858 { create_class (0, $2, $3, $4); }
861 | modifiers CLASS_TK error
862 { yyerror ("Missing class name"); RECOVER; }
864 { yyerror ("Missing class name"); RECOVER; }
865 | CLASS_TK identifier error
867 if (!ctxp->class_err) yyerror ("'{' expected");
870 | modifiers CLASS_TK identifier error
871 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
876 | EXTENDS_TK class_type
878 | EXTENDS_TK class_type error
879 {yyerror ("'{' expected"); ctxp->class_err=1;}
881 {yyerror ("Missing super class name"); ctxp->class_err=1;}
886 | IMPLEMENTS_TK interface_type_list
888 | IMPLEMENTS_TK error
891 yyerror ("Missing interface name");
898 ctxp->interface_number = 1;
899 $$ = build_tree_list ($1, NULL_TREE);
901 | interface_type_list C_TK interface_type
903 ctxp->interface_number++;
904 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
906 | interface_type_list C_TK error
907 {yyerror ("Missing interface name"); RECOVER;}
913 /* Store the location of the `}' when doing xrefs */
915 DECL_END_SOURCE_LINE (GET_CPC ()) = $2.location;
918 | OCB_TK class_body_declarations CCB_TK
920 /* Store the location of the `}' when doing xrefs */
922 DECL_END_SOURCE_LINE (GET_CPC ()) = $3.location;
927 class_body_declarations:
928 class_body_declaration
929 | class_body_declarations class_body_declaration
932 class_body_declaration:
933 class_member_declaration
935 | constructor_declaration
936 | block /* Added, JDK1.1, instance initializer */
938 if (!IS_EMPTY_STMT ($1))
940 TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
941 SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
946 class_member_declaration:
949 | class_declaration /* Added, JDK1.1 inner classes */
950 { end_class_declaration (1); }
951 | interface_declaration /* Added, JDK1.1 inner interfaces */
952 { end_class_declaration (1); }
956 /* 19.8.2 Productions from 8.3: Field Declarations */
958 type variable_declarators SC_TK
959 { register_fields (0, $1, $2); }
960 | modifiers type variable_declarators SC_TK
963 ("Illegal modifier %qs for field declaration",
964 $1, FIELD_MODIFIERS);
965 check_modifiers_consistency ($1);
966 register_fields ($1, $2, $3);
970 variable_declarators:
971 /* Should we use build_decl_list () instead ? FIXME */
972 variable_declarator /* Default rule */
973 | variable_declarators C_TK variable_declarator
974 { $$ = chainon ($1, $3); }
975 | variable_declarators C_TK error
976 {yyerror ("Missing term"); RECOVER;}
980 variable_declarator_id
981 { $$ = build_tree_list ($1, NULL_TREE); }
982 | variable_declarator_id ASSIGN_TK variable_initializer
984 if (java_error_count)
987 ($1, build_assignment ($2.token, $2.location, $1, $3));
989 | variable_declarator_id ASSIGN_TK error
991 yyerror ("Missing variable initializer");
992 $$ = build_tree_list ($1, NULL_TREE);
995 | variable_declarator_id ASSIGN_TK variable_initializer error
997 yyerror ("';' expected");
998 $$ = build_tree_list ($1, NULL_TREE);
1003 variable_declarator_id:
1005 | variable_declarator_id OSB_TK CSB_TK
1006 { $$ = build_unresolved_array_type ($1); }
1008 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
1009 | variable_declarator_id OSB_TK error
1011 yyerror ("']' expected");
1014 | variable_declarator_id CSB_TK error
1015 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
1018 variable_initializer:
1023 /* 19.8.3 Productions from 8.4: Method Declarations */
1027 current_function_decl = $1;
1028 if (current_function_decl
1029 && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1030 source_start_java_method (current_function_decl);
1032 current_function_decl = NULL_TREE;
1035 { finish_method_declaration ($3); }
1036 | method_header error
1037 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1041 type method_declarator throws
1042 { $$ = method_header (0, $1, $2, $3); }
1043 | VOID_TK method_declarator throws
1044 { $$ = method_header (0, void_type_node, $2, $3); }
1045 | modifiers type method_declarator throws
1046 { $$ = method_header ($1, $2, $3, $4); }
1047 | modifiers VOID_TK method_declarator throws
1048 { $$ = method_header ($1, void_type_node, $3, $4); }
1051 yyerror ("Invalid method declaration, method name required");
1054 | modifiers type error
1056 yyerror ("Identifier expected");
1061 yyerror ("Identifier expected");
1064 | modifiers VOID_TK error
1066 yyerror ("Identifier expected");
1071 yyerror ("Invalid method declaration, return type required");
1077 identifier OP_TK CP_TK
1079 ctxp->formal_parameter_number = 0;
1080 $$ = method_declarator ($1, NULL_TREE);
1082 | identifier OP_TK formal_parameter_list CP_TK
1083 { $$ = method_declarator ($1, $3); }
1084 | method_declarator OSB_TK CSB_TK
1086 SET_EXPR_LOCATION_FROM_TOKEN (wfl_operator, $2);
1088 build_unresolved_array_type (TREE_PURPOSE ($1));
1089 parse_warning_context
1091 "Discouraged form of returned type specification");
1093 | identifier OP_TK error
1094 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1095 | method_declarator OSB_TK error
1096 {yyerror ("']' expected"); RECOVER;}
1099 formal_parameter_list:
1102 ctxp->formal_parameter_number = 1;
1104 | formal_parameter_list C_TK formal_parameter
1106 ctxp->formal_parameter_number += 1;
1107 $$ = chainon ($1, $3);
1109 | formal_parameter_list C_TK error
1110 { yyerror ("Missing formal parameter term"); RECOVER; }
1114 type variable_declarator_id
1116 $$ = build_tree_list ($2, $1);
1118 | final type variable_declarator_id /* Added, JDK1.1 final parms */
1120 $$ = build_tree_list ($3, $2);
1121 ARG_FINAL_P ($$) = 1;
1125 yyerror ("Missing identifier"); RECOVER;
1130 yyerror ("Missing identifier"); RECOVER;
1138 check_modifiers ("Illegal modifier %qs. Only %<final%> was expected here",
1140 if ($1 != ACC_FINAL)
1141 MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1147 | THROWS_TK class_type_list
1150 {yyerror ("Missing class type term"); RECOVER;}
1155 { $$ = build_tree_list ($1, $1); }
1156 | class_type_list C_TK class_type
1157 { $$ = tree_cons ($3, $3, $1); }
1158 | class_type_list C_TK error
1159 {yyerror ("Missing class type term"); RECOVER;}
1164 | SC_TK { $$ = NULL_TREE; }
1167 /* 19.8.4 Productions from 8.5: Static Initializers */
1171 TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1172 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1173 current_static_block = NULL_TREE;
1177 static: /* Test lval.sub_token here */
1180 check_modifiers ("Illegal modifier %qs for static initializer", $1, ACC_STATIC);
1181 /* Can't have a static initializer in an innerclass */
1182 if ($1 | ACC_STATIC &&
1183 GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1185 (MODIFIER_WFL (STATIC_TK),
1186 "Can't define static initializer in class %qs. Static initializer can only be defined in top-level classes",
1187 IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1188 SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1192 /* 19.8.5 Productions from 8.6: Constructor Declarations */
1193 constructor_declaration:
1196 current_function_decl = $1;
1197 source_start_java_method (current_function_decl);
1200 { finish_method_declaration ($3); }
1204 constructor_declarator throws
1205 { $$ = method_header (0, NULL_TREE, $1, $2); }
1206 | modifiers constructor_declarator throws
1207 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1210 constructor_declarator:
1211 simple_name OP_TK CP_TK
1213 ctxp->formal_parameter_number = 0;
1214 $$ = method_declarator ($1, NULL_TREE);
1216 | simple_name OP_TK formal_parameter_list CP_TK
1217 { $$ = method_declarator ($1, $3); }
1221 /* Unlike regular method, we always need a complete (empty)
1222 body so we can safely perform all the required code
1223 addition (super invocation and field initialization) */
1224 block_begin constructor_block_end
1226 BLOCK_EXPR_BODY ($2) = build_java_empty_stmt ();
1229 | block_begin explicit_constructor_invocation constructor_block_end
1231 | block_begin block_statements constructor_block_end
1233 | block_begin explicit_constructor_invocation block_statements constructor_block_end
1237 constructor_block_end:
1241 /* Error recovery for that rule moved down expression_statement: rule. */
1242 explicit_constructor_invocation:
1243 this_or_super OP_TK CP_TK SC_TK
1245 $$ = build_method_invocation ($1, NULL_TREE);
1246 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1247 $$ = java_method_add_stmt (current_function_decl, $$);
1249 | this_or_super OP_TK argument_list CP_TK SC_TK
1251 $$ = build_method_invocation ($1, $3);
1252 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1253 $$ = java_method_add_stmt (current_function_decl, $$);
1255 /* Added, JDK1.1 inner classes. Modified because the rule
1256 'primary' couldn't work. */
1257 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1258 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1259 | name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1260 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1263 this_or_super: /* Added, simplifies error diagnostics */
1266 tree wfl = build_wfl_node (this_identifier_node);
1267 SET_EXPR_LOCATION_FROM_TOKEN (wfl, $1);
1272 tree wfl = build_wfl_node (super_identifier_node);
1273 SET_EXPR_LOCATION_FROM_TOKEN (wfl, $1);
1278 /* 19.9 Productions from 9: Interfaces */
1279 /* 19.9.1 Productions from 9.1: Interfaces Declarations */
1280 interface_declaration:
1281 INTERFACE_TK identifier
1282 { create_interface (0, $2, NULL_TREE); }
1285 | modifiers INTERFACE_TK identifier
1286 { create_interface ($1, $3, NULL_TREE); }
1289 | INTERFACE_TK identifier extends_interfaces
1290 { create_interface (0, $2, $3); }
1293 | modifiers INTERFACE_TK identifier extends_interfaces
1294 { create_interface ($1, $3, $4); }
1297 | INTERFACE_TK identifier error
1298 { yyerror ("'{' expected"); RECOVER; }
1299 | modifiers INTERFACE_TK identifier error
1300 { yyerror ("'{' expected"); RECOVER; }
1304 EXTENDS_TK interface_type
1306 ctxp->interface_number = 1;
1307 $$ = build_tree_list ($2, NULL_TREE);
1309 | extends_interfaces C_TK interface_type
1311 ctxp->interface_number++;
1312 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1315 {yyerror ("Invalid interface type"); RECOVER;}
1316 | extends_interfaces C_TK error
1317 {yyerror ("Missing term"); RECOVER;}
1323 | OCB_TK interface_member_declarations CCB_TK
1327 interface_member_declarations:
1328 interface_member_declaration
1329 | interface_member_declarations interface_member_declaration
1332 interface_member_declaration:
1333 constant_declaration
1334 | abstract_method_declaration
1335 | class_declaration /* Added, JDK1.1 inner classes */
1336 { end_class_declaration (1); }
1337 | interface_declaration /* Added, JDK1.1 inner interfaces */
1338 { end_class_declaration (1); }
1341 constant_declaration:
1345 abstract_method_declaration:
1348 check_abstract_method_header ($1);
1349 current_function_decl = NULL_TREE; /* FIXME ? */
1351 | method_header error
1352 {yyerror ("';' expected"); RECOVER;}
1355 /* 19.10 Productions from 10: Arrays */
1358 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1359 | OCB_TK C_TK CCB_TK
1360 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1361 | OCB_TK variable_initializers CCB_TK
1362 { $$ = build_new_array_init ($1.location, $2); }
1363 | OCB_TK variable_initializers C_TK CCB_TK
1364 { $$ = build_new_array_init ($1.location, $2); }
1367 variable_initializers:
1368 variable_initializer
1370 $$ = tree_cons (maybe_build_array_element_wfl ($1),
1373 | variable_initializers C_TK variable_initializer
1375 $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1377 | variable_initializers C_TK error
1378 {yyerror ("Missing term"); RECOVER;}
1381 /* 19.11 Production from 14: Blocks and Statements */
1383 block_begin block_end
1385 | block_begin block_statements block_end
1397 maybe_absorb_scoping_blocks ();
1398 /* Store the location of the `}' when doing xrefs */
1399 if (current_function_decl && flag_emit_xref)
1400 DECL_END_SOURCE_LINE (current_function_decl) = $1.location;
1402 if (!BLOCK_SUBBLOCKS ($$))
1403 BLOCK_SUBBLOCKS ($$) = build_java_empty_stmt ();
1409 | block_statements block_statement
1413 local_variable_declaration_statement
1415 { java_method_add_stmt (current_function_decl, $1); }
1416 | class_declaration /* Added, JDK1.1 local classes */
1418 LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1419 end_class_declaration (1);
1423 local_variable_declaration_statement:
1424 local_variable_declaration SC_TK /* Can't catch missing ';' here */
1427 local_variable_declaration:
1428 type variable_declarators
1429 { declare_local_variables (0, $1, $2); }
1430 | final type variable_declarators /* Added, JDK1.1 final locals */
1431 { declare_local_variables ($1, $2, $3); }
1435 statement_without_trailing_substatement
1438 | if_then_else_statement
1441 { $$ = exit_block (); }
1445 statement_without_trailing_substatement
1446 | labeled_statement_nsi
1447 | if_then_else_statement_nsi
1448 | while_statement_nsi
1450 { $$ = exit_block (); }
1453 statement_without_trailing_substatement:
1456 | expression_statement
1460 | continue_statement
1462 | synchronized_statement
1471 if (flag_extraneous_semicolon
1472 && ! current_static_block
1473 && (! current_function_decl ||
1474 /* Verify we're not in a inner class declaration */
1475 (GET_CPC () != TYPE_NAME
1476 (DECL_CONTEXT (current_function_decl)))))
1479 #ifdef USE_MAPPED_LOCATION
1480 SET_EXPR_LOCATION (wfl_operator, input_location);
1482 EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1484 parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1486 $$ = build_java_empty_stmt ();
1491 identifier REL_CL_TK
1493 $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1494 EXPR_WFL_NODE ($1));
1496 push_labeled_block ($$);
1497 PUSH_LABELED_BLOCK ($$);
1502 label_decl statement
1503 { $$ = finish_labeled_statement ($1, $2); }
1505 {yyerror ("':' expected"); RECOVER;}
1508 labeled_statement_nsi:
1509 label_decl statement_nsi
1510 { $$ = finish_labeled_statement ($1, $2); }
1513 /* We concentrate here a bunch of error handling rules that we couldn't write
1514 earlier, because expression_statement catches a missing ';'. */
1515 expression_statement:
1516 statement_expression SC_TK
1518 /* We have a statement. Generate a WFL around it so
1520 #ifdef USE_MAPPED_LOCATION
1521 $$ = expr_add_location ($1, input_location, 1);
1523 $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1524 JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1526 /* We know we have a statement, so set the debug
1527 info to be eventually generate here. */
1531 YYNOT_TWICE yyerror ("Invalid expression statement");
1532 DRECOVER (expr_stmt);
1536 YYNOT_TWICE yyerror ("Invalid expression statement");
1537 DRECOVER (expr_stmt);
1541 YYNOT_TWICE yyerror ("Invalid expression statement");
1542 DRECOVER (expr_stmt);
1544 | this_or_super OP_TK error
1545 {yyerror ("')' expected"); RECOVER;}
1546 | this_or_super OP_TK CP_TK error
1548 parse_ctor_invocation_error ();
1551 | this_or_super OP_TK argument_list error
1552 {yyerror ("')' expected"); RECOVER;}
1553 | this_or_super OP_TK argument_list CP_TK error
1555 parse_ctor_invocation_error ();
1558 | name DOT_TK SUPER_TK error
1559 {yyerror ("'(' expected"); RECOVER;}
1560 | name DOT_TK SUPER_TK OP_TK error
1561 {yyerror ("')' expected"); RECOVER;}
1562 | name DOT_TK SUPER_TK OP_TK argument_list error
1563 {yyerror ("')' expected"); RECOVER;}
1564 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1565 {yyerror ("';' expected"); RECOVER;}
1566 | name DOT_TK SUPER_TK OP_TK CP_TK error
1567 {yyerror ("';' expected"); RECOVER;}
1570 statement_expression:
1572 | pre_increment_expression
1573 | pre_decrement_expression
1574 | post_increment_expression
1575 | post_decrement_expression
1577 | class_instance_creation_expression
1581 IF_TK OP_TK expression CP_TK statement
1583 $$ = build_if_else_statement ($2.location, $3,
1587 {yyerror ("'(' expected"); RECOVER;}
1589 {yyerror ("Missing term"); RECOVER;}
1590 | IF_TK OP_TK expression error
1591 {yyerror ("')' expected"); RECOVER;}
1594 if_then_else_statement:
1595 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1596 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1599 if_then_else_statement_nsi:
1600 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1601 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1611 /* Make into "proper list" of COMPOUND_EXPRs.
1612 I.e. make the last statement also have its own
1614 maybe_absorb_scoping_blocks ();
1615 TREE_OPERAND ($1, 1) = exit_block ();
1616 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1621 SWITCH_TK OP_TK expression CP_TK
1623 $$ = build3 (SWITCH_EXPR, NULL_TREE, $3,
1624 NULL_TREE, NULL_TREE);
1625 SET_EXPR_LOCATION_FROM_TOKEN ($$, $2);
1628 {yyerror ("'(' expected"); RECOVER;}
1629 | SWITCH_TK OP_TK error
1630 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1631 | SWITCH_TK OP_TK expression CP_TK error
1632 {yyerror ("'{' expected"); RECOVER;}
1635 /* Default assignment is there to avoid type node on switch_block
1641 | OCB_TK switch_labels CCB_TK
1643 | OCB_TK switch_block_statement_groups CCB_TK
1645 | OCB_TK switch_block_statement_groups switch_labels CCB_TK
1649 switch_block_statement_groups:
1650 switch_block_statement_group
1651 | switch_block_statement_groups switch_block_statement_group
1654 switch_block_statement_group:
1655 switch_labels block_statements
1660 | switch_labels switch_label
1664 CASE_TK constant_expression REL_CL_TK
1666 tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1667 SET_EXPR_LOCATION_FROM_TOKEN (lab, $1);
1668 java_method_add_stmt (current_function_decl, lab);
1670 | DEFAULT_TK REL_CL_TK
1672 tree lab = make_node (DEFAULT_EXPR);
1673 SET_EXPR_LOCATION_FROM_TOKEN (lab, $1);
1674 java_method_add_stmt (current_function_decl, lab);
1677 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1678 | CASE_TK constant_expression error
1679 {yyerror ("':' expected"); RECOVER;}
1681 {yyerror ("':' expected"); RECOVER;}
1685 WHILE_TK OP_TK expression CP_TK
1687 tree body = build_loop_body ($2.location, $3, 0);
1688 $$ = build_new_loop (body);
1693 while_expression statement
1694 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1696 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1697 | WHILE_TK OP_TK error
1698 {yyerror ("Missing term and ')' expected"); RECOVER;}
1699 | WHILE_TK OP_TK expression error
1700 {yyerror ("')' expected"); RECOVER;}
1703 while_statement_nsi:
1704 while_expression statement_nsi
1705 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1711 tree body = build_loop_body (0, NULL_TREE, 1);
1712 $$ = build_new_loop (body);
1714 /* Need error handing here. FIXME */
1718 do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1719 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1723 for_begin SC_TK expression SC_TK for_update CP_TK statement
1725 if (CONSTANT_CLASS_P ($3))
1726 $3 = build_wfl_node ($3);
1727 $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1729 | for_begin SC_TK SC_TK for_update CP_TK statement
1731 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1732 /* We have not condition, so we get rid of the EXIT_EXPR */
1733 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1734 build_java_empty_stmt ();
1736 | for_begin SC_TK error
1737 {yyerror ("Invalid control expression"); RECOVER;}
1738 | for_begin SC_TK expression SC_TK error
1739 {yyerror ("Invalid update expression"); RECOVER;}
1740 | for_begin SC_TK SC_TK error
1741 {yyerror ("Invalid update expression"); RECOVER;}
1745 for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1746 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1747 | for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1749 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1750 /* We have not condition, so we get rid of the EXIT_EXPR */
1751 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1752 build_java_empty_stmt ();
1759 /* This scope defined for local variable that may be
1760 defined within the scope of the for loop */
1764 {yyerror ("'(' expected"); DRECOVER(for_1);}
1765 | FOR_TK OP_TK error
1766 {yyerror ("Invalid init statement"); RECOVER;}
1772 /* We now declare the loop body. The loop is
1773 declared as a for loop. */
1774 tree body = build_loop_body (0, NULL_TREE, 0);
1775 $$ = build_new_loop (body);
1776 FOR_LOOP_P ($$) = 1;
1777 /* The loop is added to the current block the for
1778 statement is defined within */
1779 java_method_add_stmt (current_function_decl, $$);
1782 for_init: /* Can be empty */
1783 { $$ = build_java_empty_stmt (); }
1784 | statement_expression_list
1786 /* Init statement recorded within the previously
1787 defined block scope */
1788 $$ = java_method_add_stmt (current_function_decl, $1);
1790 | local_variable_declaration
1792 /* Local variable are recorded within the previously
1793 defined block scope */
1796 | statement_expression_list error
1797 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1800 for_update: /* Can be empty */
1801 {$$ = build_java_empty_stmt ();}
1802 | statement_expression_list
1803 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1806 statement_expression_list:
1807 statement_expression
1808 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1809 | statement_expression_list C_TK statement_expression
1810 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1811 | statement_expression_list C_TK error
1812 {yyerror ("Missing term"); RECOVER;}
1817 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1818 | BREAK_TK identifier SC_TK
1819 { $$ = build_bc_statement ($1.location, 1, $2); }
1821 {yyerror ("Missing term"); RECOVER;}
1822 | BREAK_TK identifier error
1823 {yyerror ("';' expected"); RECOVER;}
1828 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1829 | CONTINUE_TK identifier SC_TK
1830 { $$ = build_bc_statement ($1.location, 0, $2); }
1832 {yyerror ("Missing term"); RECOVER;}
1833 | CONTINUE_TK identifier error
1834 {yyerror ("';' expected"); RECOVER;}
1839 { $$ = build_return ($1.location, NULL_TREE); }
1840 | RETURN_TK expression SC_TK
1841 { $$ = build_return ($1.location, $2); }
1843 {yyerror ("Missing term"); RECOVER;}
1844 | RETURN_TK expression error
1845 {yyerror ("';' expected"); RECOVER;}
1849 THROW_TK expression SC_TK
1851 $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1852 SET_EXPR_LOCATION_FROM_TOKEN ($$, $1);
1855 {yyerror ("Missing term"); RECOVER;}
1856 | THROW_TK expression error
1857 {yyerror ("';' expected"); RECOVER;}
1861 ASSERT_TK expression REL_CL_TK expression SC_TK
1863 $$ = build_assertion ($1.location, $2, $4);
1865 | ASSERT_TK expression SC_TK
1867 $$ = build_assertion ($1.location, $2, NULL_TREE);
1870 {yyerror ("Missing term"); RECOVER;}
1871 | ASSERT_TK expression error
1872 {yyerror ("';' expected"); RECOVER;}
1875 synchronized_statement:
1876 synchronized OP_TK expression CP_TK block
1878 $$ = build2 (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1879 EXPR_WFL_LINECOL ($$) =
1880 EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1882 | synchronized OP_TK expression CP_TK error
1883 {yyerror ("'{' expected"); RECOVER;}
1884 | synchronized error
1885 {yyerror ("'(' expected"); RECOVER;}
1886 | synchronized OP_TK error CP_TK
1887 {yyerror ("Missing term"); RECOVER;}
1888 | synchronized OP_TK error
1889 {yyerror ("Missing term"); RECOVER;}
1896 "Illegal modifier %qs. Only %<synchronized%> was expected here",
1897 $1, ACC_SYNCHRONIZED);
1898 if ($1 != ACC_SYNCHRONIZED)
1899 MODIFIER_WFL (SYNCHRONIZED_TK) =
1900 build_wfl_node (NULL_TREE);
1905 TRY_TK block catches
1906 { $$ = build_try_statement ($1.location, $2, $3); }
1907 | TRY_TK block finally
1908 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1909 | TRY_TK block catches finally
1910 { $$ = build_try_finally_statement
1911 ($1.location, build_try_statement ($1.location,
1915 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1920 | catches catch_clause
1922 TREE_CHAIN ($2) = $1;
1928 catch_clause_parameter block
1930 java_method_add_stmt (current_function_decl, $2);
1936 catch_clause_parameter:
1937 CATCH_TK OP_TK formal_parameter CP_TK
1939 /* We add a block to define a scope for
1940 formal_parameter (CCBP). The formal parameter is
1941 declared initialized by the appropriate function
1947 ccpb = enter_block ();
1948 init = build_assignment
1949 (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1950 build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1951 declare_local_variables (0, TREE_VALUE ($3),
1953 (TREE_PURPOSE ($3), init));
1954 $$ = build1 (JAVA_CATCH_EXPR, NULL_TREE, ccpb);
1955 SET_EXPR_LOCATION_FROM_TOKEN ($$, $1);
1959 $$ = error_mark_node;
1963 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1964 | CATCH_TK OP_TK error
1966 yyerror ("Missing term or ')' expected");
1967 RECOVER; $$ = NULL_TREE;
1969 | CATCH_TK OP_TK error CP_TK /* That's for () */
1970 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1977 {yyerror ("'{' expected"); RECOVER; }
1980 /* 19.12 Production from 15: Expressions */
1982 primary_no_new_array
1983 | array_creation_uninitialized
1984 | array_creation_initialized
1987 primary_no_new_array:
1990 { $$ = build_this ($1.location); }
1991 | OP_TK expression CP_TK
1993 | class_instance_creation_expression
1998 /* Added, JDK1.1 inner classes. Documentation is wrong
1999 referring to a 'ClassName' (class_name) rule that doesn't
2000 exist. Used name: instead. */
2001 | name DOT_TK THIS_TK
2003 tree wfl = build_wfl_node (this_identifier_node);
2004 $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
2006 | OP_TK expression error
2007 {yyerror ("')' expected"); RECOVER;}
2009 {yyerror ("'class' or 'this' expected" ); RECOVER;}
2010 | primitive_type DOT_TK error
2011 {yyerror ("'class' expected" ); RECOVER;}
2012 | VOID_TK DOT_TK error
2013 {yyerror ("'class' expected" ); RECOVER;}
2017 name DOT_TK CLASS_TK
2018 { $$ = build_incomplete_class_ref ($2.location, $1); }
2019 | array_type DOT_TK CLASS_TK
2020 { $$ = build_incomplete_class_ref ($2.location, $1); }
2021 | primitive_type DOT_TK CLASS_TK
2022 { $$ = build_incomplete_class_ref ($2.location, $1); }
2023 | VOID_TK DOT_TK CLASS_TK
2025 $$ = build_incomplete_class_ref ($2.location,
2030 class_instance_creation_expression:
2031 NEW_TK class_type OP_TK argument_list CP_TK
2032 { $$ = build_new_invocation ($2, $4); }
2033 | NEW_TK class_type OP_TK CP_TK
2034 { $$ = build_new_invocation ($2, NULL_TREE); }
2035 | anonymous_class_creation
2036 /* Added, JDK1.1 inner classes, modified to use name or
2037 primary instead of primary solely which couldn't work in
2039 | something_dot_new identifier OP_TK CP_TK
2041 tree ctor = build_new_invocation ($2, NULL_TREE);
2042 $$ = make_qualified_primary ($1, ctor,
2043 EXPR_WFL_LINECOL ($1));
2045 | something_dot_new identifier OP_TK CP_TK class_body
2046 | something_dot_new identifier OP_TK argument_list CP_TK
2048 tree ctor = build_new_invocation ($2, $4);
2049 $$ = make_qualified_primary ($1, ctor,
2050 EXPR_WFL_LINECOL ($1));
2052 | something_dot_new identifier OP_TK argument_list CP_TK class_body
2053 | NEW_TK error SC_TK
2054 {$$ = NULL_TREE; yyerror ("'(' expected"); DRECOVER(new_1);}
2055 | NEW_TK class_type error
2056 {$$ = NULL_TREE; yyerror ("'(' expected"); RECOVER;}
2057 | NEW_TK class_type OP_TK error
2058 {$$ = NULL_TREE; yyerror ("')' or term expected"); RECOVER;}
2059 | NEW_TK class_type OP_TK argument_list error
2060 {$$ = NULL_TREE; yyerror ("')' expected"); RECOVER;}
2061 | something_dot_new error
2065 yyerror ("Identifier expected");
2068 | something_dot_new identifier error
2069 {$$ = NULL_TREE; yyerror ("'(' expected"); RECOVER;}
2072 /* Created after JDK1.1 rules originally added to
2073 class_instance_creation_expression, but modified to use
2074 'class_type' instead of 'TypeName' (type_name) which is mentioned
2075 in the documentation but doesn't exist. */
2077 anonymous_class_creation:
2078 NEW_TK class_type OP_TK argument_list CP_TK
2079 { create_anonymous_class ($2); }
2082 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2083 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2085 end_class_declaration (1);
2087 /* Now we can craft the new expression */
2088 $$ = build_new_invocation (id, $4);
2090 /* Note that we can't possibly be here if
2091 `class_type' is an interface (in which case the
2092 anonymous class extends Object and implements
2093 `class_type', hence its constructor can't have
2096 /* Otherwise, the innerclass must feature a
2097 constructor matching `argument_list'. Anonymous
2098 classes are a bit special: it's impossible to
2099 define constructor for them, hence constructors
2100 must be generated following the hints provided by
2101 the `new' expression. Whether a super constructor
2102 of that nature exists or not is to be verified
2103 later on in verify_constructor_super.
2105 It's during the expansion of a `new' statement
2106 referring to an anonymous class that a ctor will
2107 be generated for the anonymous class, with the
2111 | NEW_TK class_type OP_TK CP_TK
2112 { create_anonymous_class ($2); }
2115 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2116 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2118 end_class_declaration (1);
2120 /* Now we can craft the new expression. The
2121 statement doesn't need to be remember so that a
2122 constructor can be generated, since its signature
2123 is already known. */
2124 $$ = build_new_invocation (id, NULL_TREE);
2128 something_dot_new: /* Added, not part of the specs. */
2131 | primary DOT_TK NEW_TK
2138 $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2139 ctxp->formal_parameter_number = 1;
2141 | argument_list C_TK expression
2143 ctxp->formal_parameter_number += 1;
2144 $$ = tree_cons (NULL_TREE, $3, $1);
2146 | argument_list C_TK error
2147 {yyerror ("Missing term"); RECOVER;}
2150 array_creation_uninitialized:
2151 NEW_TK primitive_type dim_exprs
2152 { $$ = build_newarray_node ($2, $3, 0); }
2153 | NEW_TK class_or_interface_type dim_exprs
2154 { $$ = build_newarray_node ($2, $3, 0); }
2155 | NEW_TK primitive_type dim_exprs dims
2156 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2157 | NEW_TK class_or_interface_type dim_exprs dims
2158 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2159 | NEW_TK error CSB_TK
2160 {yyerror ("'[' expected"); DRECOVER ("]");}
2161 | NEW_TK error OSB_TK
2162 {yyerror ("']' expected"); RECOVER;}
2165 array_creation_initialized:
2166 /* Added, JDK1.1 anonymous array. Initial documentation rule
2168 NEW_TK class_or_interface_type dims array_initializer
2171 int osb = pop_current_osb (ctxp);
2173 obstack_grow (&temporary_obstack, "[]", 2);
2174 obstack_1grow (&temporary_obstack, '\0');
2175 sig = obstack_finish (&temporary_obstack);
2176 $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2177 $2, get_identifier (sig), $4);
2179 | NEW_TK primitive_type dims array_initializer
2181 int osb = pop_current_osb (ctxp);
2184 type = build_java_array_type (type, -1);
2185 $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2186 build_pointer_type (type), NULL_TREE, $4);
2188 | NEW_TK error CSB_TK
2189 {yyerror ("'[' expected"); DRECOVER ("]");}
2190 | NEW_TK error OSB_TK
2191 {yyerror ("']' expected"); RECOVER;}
2196 { $$ = build_tree_list (NULL_TREE, $1); }
2197 | dim_exprs dim_expr
2198 { $$ = tree_cons (NULL_TREE, $2, $$); }
2202 OSB_TK expression CSB_TK
2204 if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2206 $2 = build_wfl_node ($2);
2207 TREE_TYPE ($2) = NULL_TREE;
2209 EXPR_WFL_LINECOL ($2) = $1.location;
2212 | OSB_TK expression error
2213 {yyerror ("']' expected"); RECOVER;}
2216 yyerror ("Missing term");
2217 yyerror ("']' expected");
2226 /* If not initialized, allocate memory for the osb
2228 if (!ctxp->osb_limit)
2230 allocate = ctxp->osb_limit = 32;
2231 ctxp->osb_depth = -1;
2233 /* If capacity overflown, reallocate a bigger chunk */
2234 else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2235 allocate = ctxp->osb_limit << 1;
2239 allocate *= sizeof (int);
2240 if (ctxp->osb_number)
2241 ctxp->osb_number = xrealloc (ctxp->osb_number,
2244 ctxp->osb_number = xmalloc (allocate);
2247 CURRENT_OSB (ctxp) = 1;
2249 | dims OSB_TK CSB_TK
2250 { CURRENT_OSB (ctxp)++; }
2252 { yyerror ("']' expected"); RECOVER;}
2256 primary DOT_TK identifier
2257 { $$ = make_qualified_primary ($1, $3, $2.location); }
2258 /* FIXME - REWRITE TO:
2259 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2260 | SUPER_TK DOT_TK identifier
2262 tree super_wfl = build_wfl_node (super_identifier_node);
2263 SET_EXPR_LOCATION_FROM_TOKEN (super_wfl, $1);
2264 $$ = make_qualified_name (super_wfl, $3, $2.location);
2267 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2272 { $$ = build_method_invocation ($1, NULL_TREE); }
2273 | name OP_TK argument_list CP_TK
2274 { $$ = build_method_invocation ($1, $3); }
2275 | primary DOT_TK identifier OP_TK CP_TK
2277 if (TREE_CODE ($1) == THIS_EXPR)
2278 $$ = build_this_super_qualified_invocation
2279 (1, $3, NULL_TREE, 0, $2.location);
2282 tree invok = build_method_invocation ($3, NULL_TREE);
2283 $$ = make_qualified_primary ($1, invok, $2.location);
2286 | primary DOT_TK identifier OP_TK argument_list CP_TK
2288 if (TREE_CODE ($1) == THIS_EXPR)
2289 $$ = build_this_super_qualified_invocation
2290 (1, $3, $5, 0, $2.location);
2293 tree invok = build_method_invocation ($3, $5);
2294 $$ = make_qualified_primary ($1, invok, $2.location);
2297 | SUPER_TK DOT_TK identifier OP_TK CP_TK
2299 $$ = build_this_super_qualified_invocation
2300 (0, $3, NULL_TREE, $1.location, $2.location);
2302 | SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2304 $$ = build_this_super_qualified_invocation
2305 (0, $3, $5, $1.location, $2.location);
2307 /* Screws up thing. I let it here until I'm convinced it can
2309 | primary DOT_TK error
2310 {yyerror ("'(' expected"); DRECOVER(bad);} */
2311 | SUPER_TK DOT_TK error CP_TK
2312 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2313 | SUPER_TK DOT_TK error DOT_TK
2314 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2318 name OSB_TK expression CSB_TK
2319 { $$ = build_array_ref ($2.location, $1, $3); }
2320 | primary_no_new_array OSB_TK expression CSB_TK
2321 { $$ = build_array_ref ($2.location, $1, $3); }
2322 | array_creation_initialized OSB_TK expression CSB_TK
2323 { $$ = build_array_ref ($2.location, $1, $3); }
2326 yyerror ("Missing term and ']' expected");
2327 DRECOVER(array_access);
2329 | name OSB_TK expression error
2331 yyerror ("']' expected");
2332 DRECOVER(array_access);
2334 | primary_no_new_array OSB_TK error
2336 yyerror ("Missing term and ']' expected");
2337 DRECOVER(array_access);
2339 | primary_no_new_array OSB_TK expression error
2341 yyerror ("']' expected");
2342 DRECOVER(array_access);
2344 | array_creation_initialized OSB_TK error
2346 yyerror ("Missing term and ']' expected");
2347 DRECOVER(array_access);
2349 | array_creation_initialized OSB_TK expression error
2351 yyerror ("']' expected");
2352 DRECOVER(array_access);
2359 | post_increment_expression
2360 | post_decrement_expression
2363 post_increment_expression:
2364 postfix_expression INCR_TK
2365 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2368 post_decrement_expression:
2369 postfix_expression DECR_TK
2370 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2373 trap_overflow_corner_case:
2374 pre_increment_expression
2375 | pre_decrement_expression
2376 | PLUS_TK unary_expression
2377 {$$ = build_unaryop ($1.token, $1.location, $2); }
2378 | unary_expression_not_plus_minus
2380 {yyerror ("Missing term"); RECOVER}
2384 trap_overflow_corner_case
2387 error_if_numeric_overflow ($1);
2390 | MINUS_TK trap_overflow_corner_case
2391 {$$ = build_unaryop ($1.token, $1.location, $2); }
2393 {yyerror ("Missing term"); RECOVER}
2396 pre_increment_expression:
2397 INCR_TK unary_expression
2398 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2400 {yyerror ("Missing term"); RECOVER}
2403 pre_decrement_expression:
2404 DECR_TK unary_expression
2405 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2407 {yyerror ("Missing term"); RECOVER}
2410 unary_expression_not_plus_minus:
2412 | NOT_TK unary_expression
2413 {$$ = build_unaryop ($1.token, $1.location, $2); }
2414 | NEG_TK unary_expression
2415 {$$ = build_unaryop ($1.token, $1.location, $2); }
2418 {yyerror ("Missing term"); RECOVER}
2420 {yyerror ("Missing term"); RECOVER}
2423 cast_expression: /* Error handling here is potentially weak */
2424 OP_TK primitive_type dims CP_TK unary_expression
2427 int osb = pop_current_osb (ctxp);
2429 type = build_java_array_type (type, -1);
2430 $$ = build_cast ($1.location, type, $5);
2432 | OP_TK primitive_type CP_TK unary_expression
2433 { $$ = build_cast ($1.location, $2, $4); }
2434 | OP_TK expression CP_TK unary_expression_not_plus_minus
2435 { $$ = build_cast ($1.location, $2, $4); }
2436 | OP_TK name dims CP_TK unary_expression_not_plus_minus
2439 int osb = pop_current_osb (ctxp);
2440 obstack_grow (&temporary_obstack,
2441 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2442 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2444 obstack_grow (&temporary_obstack, "[]", 2);
2445 obstack_1grow (&temporary_obstack, '\0');
2446 ptr = obstack_finish (&temporary_obstack);
2447 EXPR_WFL_NODE ($2) = get_identifier (ptr);
2448 $$ = build_cast ($1.location, $2, $5);
2450 | OP_TK primitive_type OSB_TK error
2451 {yyerror ("']' expected, invalid type expression");}
2454 YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2457 | OP_TK primitive_type dims CP_TK error
2458 {yyerror ("Missing term"); RECOVER;}
2459 | OP_TK primitive_type CP_TK error
2460 {yyerror ("Missing term"); RECOVER;}
2461 | OP_TK name dims CP_TK error
2462 {yyerror ("Missing term"); RECOVER;}
2465 multiplicative_expression:
2467 | multiplicative_expression MULT_TK unary_expression
2469 $$ = build_binop (BINOP_LOOKUP ($2.token),
2470 $2.location, $1, $3);
2472 | multiplicative_expression DIV_TK unary_expression
2474 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2477 | multiplicative_expression REM_TK unary_expression
2479 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2482 | multiplicative_expression MULT_TK error
2483 {yyerror ("Missing term"); RECOVER;}
2484 | multiplicative_expression DIV_TK error
2485 {yyerror ("Missing term"); RECOVER;}
2486 | multiplicative_expression REM_TK error
2487 {yyerror ("Missing term"); RECOVER;}
2490 additive_expression:
2491 multiplicative_expression
2492 | additive_expression PLUS_TK multiplicative_expression
2494 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2497 | additive_expression MINUS_TK multiplicative_expression
2499 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2502 | additive_expression PLUS_TK error
2503 {yyerror ("Missing term"); RECOVER;}
2504 | additive_expression MINUS_TK error
2505 {yyerror ("Missing term"); RECOVER;}
2510 | shift_expression LS_TK additive_expression
2512 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2515 | shift_expression SRS_TK additive_expression
2517 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2520 | shift_expression ZRS_TK additive_expression
2522 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2525 | shift_expression LS_TK error
2526 {yyerror ("Missing term"); RECOVER;}
2527 | shift_expression SRS_TK error
2528 {yyerror ("Missing term"); RECOVER;}
2529 | shift_expression ZRS_TK error
2530 {yyerror ("Missing term"); RECOVER;}
2533 relational_expression:
2535 | relational_expression LT_TK shift_expression
2537 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2540 | relational_expression GT_TK shift_expression
2542 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2545 | relational_expression LTE_TK shift_expression
2547 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2550 | relational_expression GTE_TK shift_expression
2552 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2555 | relational_expression INSTANCEOF_TK reference_type
2556 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2557 | relational_expression LT_TK error
2558 {yyerror ("Missing term"); RECOVER;}
2559 | relational_expression GT_TK error
2560 {yyerror ("Missing term"); RECOVER;}
2561 | relational_expression LTE_TK error
2562 {yyerror ("Missing term"); RECOVER;}
2563 | relational_expression GTE_TK error
2564 {yyerror ("Missing term"); RECOVER;}
2565 | relational_expression INSTANCEOF_TK error
2566 {yyerror ("Invalid reference type"); RECOVER;}
2569 equality_expression:
2570 relational_expression
2571 | equality_expression EQ_TK relational_expression
2573 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2576 | equality_expression NEQ_TK relational_expression
2578 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2581 | equality_expression EQ_TK error
2582 {yyerror ("Missing term"); RECOVER;}
2583 | equality_expression NEQ_TK error
2584 {yyerror ("Missing term"); RECOVER;}
2589 | and_expression AND_TK equality_expression
2591 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2594 | and_expression AND_TK error
2595 {yyerror ("Missing term"); RECOVER;}
2598 exclusive_or_expression:
2600 | exclusive_or_expression XOR_TK and_expression
2602 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2605 | exclusive_or_expression XOR_TK error
2606 {yyerror ("Missing term"); RECOVER;}
2609 inclusive_or_expression:
2610 exclusive_or_expression
2611 | inclusive_or_expression OR_TK exclusive_or_expression
2613 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2616 | inclusive_or_expression OR_TK error
2617 {yyerror ("Missing term"); RECOVER;}
2620 conditional_and_expression:
2621 inclusive_or_expression
2622 | conditional_and_expression BOOL_AND_TK inclusive_or_expression
2624 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2627 | conditional_and_expression BOOL_AND_TK error
2628 {yyerror ("Missing term"); RECOVER;}
2631 conditional_or_expression:
2632 conditional_and_expression
2633 | conditional_or_expression BOOL_OR_TK conditional_and_expression
2635 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2638 | conditional_or_expression BOOL_OR_TK error
2639 {yyerror ("Missing term"); RECOVER;}
2642 conditional_expression: /* Error handling here is weak */
2643 conditional_or_expression
2644 | conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2646 $$ = build3 (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2647 SET_EXPR_LOCATION_FROM_TOKEN ($$, $2);
2649 | conditional_or_expression REL_QM_TK REL_CL_TK error
2652 yyerror ("Missing term");
2655 | conditional_or_expression REL_QM_TK error
2656 {yyerror ("Missing term"); DRECOVER (2);}
2657 | conditional_or_expression REL_QM_TK expression REL_CL_TK error
2658 {yyerror ("Missing term"); DRECOVER (3);}
2661 assignment_expression:
2662 conditional_expression
2667 left_hand_side assignment_operator assignment_expression
2668 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2669 | left_hand_side assignment_operator error
2671 YYNOT_TWICE yyerror ("Missing term");
2682 assignment_operator:
2688 assignment_expression
2691 constant_expression:
2697 /* Helper function to retrieve an OSB count. Should be used when the
2698 `dims:' rule is being used. */
2701 pop_current_osb (struct parser_ctxt *ctxp)
2705 if (ctxp->osb_depth < 0)
2708 to_return = CURRENT_OSB (ctxp);
2716 /* This section of the code deal with save/restoring parser contexts.
2717 Add mode documentation here. FIXME */
2719 /* Helper function. Create a new parser context. With
2720 COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2721 context is copied, otherwise, the new context is zeroed. The newly
2722 created context becomes the current one. */
2725 create_new_parser_context (int copy_from_previous)
2727 struct parser_ctxt *new;
2729 new = ggc_alloc (sizeof (struct parser_ctxt));
2730 if (copy_from_previous)
2732 memcpy (new, ctxp, sizeof (struct parser_ctxt));
2733 /* This flag, indicating the context saves global values,
2734 should only be set by java_parser_context_save_global. */
2735 new->saved_data_ctx = 0;
2738 memset (new, 0, sizeof (struct parser_ctxt));
2744 /* Create a new parser context and make it the current one. */
2747 java_push_parser_context (void)
2749 create_new_parser_context (0);
2753 java_pop_parser_context (int generate)
2756 struct parser_ctxt *next;
2764 input_location = ctxp->save_location;
2765 current_class = ctxp->class_type;
2768 /* If the old and new lexers differ, then free the old one. */
2769 if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2770 java_destroy_lexer (ctxp->lexer);
2772 /* Set the single import class file flag to 0 for the current list
2773 of imported things */
2774 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2775 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2777 /* If we pushed a context to parse a class intended to be generated,
2778 we keep it so we can remember the class. What we could actually
2779 do is to just update a list of class names. */
2782 ctxp->next = ctxp_for_generation;
2783 ctxp_for_generation = ctxp;
2786 /* And restore those of the previous context */
2787 if ((ctxp = next)) /* Assignment is really meant here */
2788 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2789 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2792 /* Create a parser context for the use of saving some global
2796 java_parser_context_save_global (void)
2800 java_push_parser_context ();
2801 ctxp->saved_data_ctx = 1;
2804 /* If this context already stores data, create a new one suitable
2805 for data storage. */
2806 else if (ctxp->saved_data)
2808 create_new_parser_context (1);
2809 ctxp->saved_data_ctx = 1;
2812 ctxp->save_location = input_location;
2813 ctxp->class_type = current_class;
2814 ctxp->function_decl = current_function_decl;
2815 ctxp->saved_data = 1;
2818 /* Restore some global variables from the previous context. Make the
2819 previous context the current one. */
2822 java_parser_context_restore_global (void)
2824 input_location = ctxp->save_location;
2825 current_class = ctxp->class_type;
2827 #ifdef USE_MAPPED_LOCATION
2828 SET_EXPR_LOCATION (wfl_operator, ctxp->save_location);
2830 EXPR_WFL_FILENAME_NODE (wfl_operator) = get_identifier (input_filename);
2832 current_function_decl = ctxp->function_decl;
2833 ctxp->saved_data = 0;
2834 if (ctxp->saved_data_ctx)
2835 java_pop_parser_context (0);
2838 /* Suspend vital data for the current class/function being parsed so
2839 that an other class can be parsed. Used to let local/anonymous
2840 classes be parsed. */
2843 java_parser_context_suspend (void)
2845 /* This makes debugging through java_debug_context easier */
2846 static const char *const name = "<inner buffer context>";
2848 /* Duplicate the previous context, use it to save the globals we're
2850 create_new_parser_context (1);
2851 ctxp->function_decl = current_function_decl;
2852 ctxp->class_type = current_class;
2854 /* Then create a new context which inherits all data from the
2855 previous one. This will be the new current context */
2856 create_new_parser_context (1);
2858 /* Help debugging */
2859 ctxp->next->filename = name;
2862 /* Resume vital data for the current class/function being parsed so
2863 that an other class can be parsed. Used to let local/anonymous
2864 classes be parsed. The trick is the data storing file position
2865 informations must be restored to their current value, so parsing
2866 can resume as if no context was ever saved. */
2869 java_parser_context_resume (void)
2871 struct parser_ctxt *old = ctxp; /* This one is to be discarded */
2872 struct parser_ctxt *saver = old->next; /* This one contain saved info */
2873 struct parser_ctxt *restored = saver->next; /* This one is the old current */
2875 /* We need to inherit the list of classes to complete/generate */
2876 restored->classd_list = old->classd_list;
2877 restored->class_list = old->class_list;
2879 /* Restore the current class and function from the saver */
2880 current_class = saver->class_type;
2881 current_function_decl = saver->function_decl;
2883 /* Retrieve the restored context */
2886 /* Re-installed the data for the parsing to carry on */
2887 memcpy (&ctxp->marker_begining, &old->marker_begining,
2888 (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2891 /* Add a new anchor node to which all statement(s) initializing static
2892 and non static initialized upon declaration field(s) will be
2896 java_parser_context_push_initialized_field (void)
2900 node = build_tree_list (NULL_TREE, NULL_TREE);
2901 TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2902 CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2904 node = build_tree_list (NULL_TREE, NULL_TREE);
2905 TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2906 CPC_INITIALIZER_LIST (ctxp) = node;
2908 node = build_tree_list (NULL_TREE, NULL_TREE);
2909 TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2910 CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2913 /* Pop the lists of initialized field. If this lists aren't empty,
2914 remember them so we can use it to create and populate the finit$
2915 or <clinit> functions. */
2918 java_parser_context_pop_initialized_field (void)
2921 tree class_type = TREE_TYPE (GET_CPC ());
2923 if (CPC_INITIALIZER_LIST (ctxp))
2925 stmts = CPC_INITIALIZER_STMT (ctxp);
2926 CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2927 if (stmts && !java_error_count)
2928 TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2931 if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2933 stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2934 CPC_STATIC_INITIALIZER_LIST (ctxp) =
2935 TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2936 /* Keep initialization in order to enforce 8.5 */
2937 if (stmts && !java_error_count)
2938 TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2941 /* JDK 1.1 instance initializers */
2942 if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2944 stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2945 CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2946 TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2947 if (stmts && !java_error_count)
2948 TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2953 reorder_static_initialized (tree list)
2955 /* We have to keep things in order. The alias initializer have to
2956 come first, then the initialized regular field, in reverse to
2957 keep them in lexical order. */
2958 tree marker, previous = NULL_TREE;
2959 for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2960 if (TREE_CODE (marker) == TREE_LIST
2961 && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2964 /* No static initialized, the list is fine as is */
2966 list = TREE_CHAIN (marker);
2968 /* No marker? reverse the whole list */
2970 list = nreverse (list);
2972 /* Otherwise, reverse what's after the marker and the new reordered
2973 sublist will replace the marker. */
2976 TREE_CHAIN (previous) = NULL_TREE;
2977 list = nreverse (list);
2978 list = chainon (TREE_CHAIN (marker), list);
2983 /* Helper functions to dump the parser context stack. */
2985 #define TAB_CONTEXT(C) \
2986 {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2989 java_debug_context_do (int tab)
2991 struct parser_ctxt *copy = ctxp;
2995 fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2997 fprintf (stderr, "filename: %s\n", copy->filename);
2999 fprintf (stderr, "package: %s\n",
3001 IDENTIFIER_POINTER (copy->package) : "<none>"));
3003 fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
3005 fprintf (stderr, "saved data: %d\n", copy->saved_data);
3011 /* Dump the stacked up parser contexts. Intended to be called from a
3015 java_debug_context (void)
3017 java_debug_context_do (0);
3022 /* Flag for the error report routine to issue the error the first time
3023 it's called (overriding the default behavior which is to drop the
3024 first invocation and honor the second one, taking advantage of a
3026 static int force_error = 0;
3028 /* Reporting an constructor invocation error. */
3030 parse_ctor_invocation_error (void)
3032 if (DECL_CONSTRUCTOR_P (current_function_decl))
3033 yyerror ("Constructor invocation must be first thing in a constructor");
3035 yyerror ("Only constructors can invoke constructors");
3038 /* Reporting JDK1.1 features not implemented. */
3041 parse_jdk1_1_error (const char *msg)
3043 sorry (": %qs JDK1.1(TM) feature", msg);
3045 return build_java_empty_stmt ();
3048 static int do_warning = 0;
3051 yyerror (const char *msgid)
3053 #ifdef USE_MAPPED_LOCATION
3054 static source_location elc;
3055 expanded_location xloc = expand_location (input_location);
3056 int current_line = xloc.line;
3060 int current_line = input_line;
3062 static int prev_lineno;
3063 static const char *prev_msg;
3065 char *remainder, *code_from_source;
3067 if (!force_error && prev_lineno == current_line)
3069 #ifndef USE_MAPPED_LOCATION
3070 current_line = ctxp->lexer->token_start.line;
3073 /* Save current error location but report latter, when the context is
3075 if (ctxp->java_error_flag == 0)
3077 ctxp->java_error_flag = 1;
3078 #ifdef USE_MAPPED_LOCATION
3079 elc = input_location;
3081 elc = ctxp->lexer->token_start;
3083 /* Do something to use the previous line if we're reaching the
3084 end of the file... */
3085 #ifdef VERBOSE_SKELETON
3086 printf ("* Error detected (%s)\n", (msgid ? msgid : "(null)"));
3091 /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3092 if (!force_error && msgid == prev_msg && prev_lineno == current_line)
3095 ctxp->java_error_flag = 0;
3097 java_warning_count++;
3102 if (elc.col == 0 && msgid && msgid[1] == ';')
3103 elc = ctxp->prev_line_end;
3108 #ifdef USE_MAPPED_LOCATION
3109 prev_lineno = current_line;
3110 code_from_source = java_get_line_col (xloc.file, current_line, xloc.column);
3112 save_lineno = input_line;
3113 prev_lineno = input_line = current_line;
3114 code_from_source = java_get_line_col (input_filename, current_line,
3115 ctxp->lexer->token_start.col);
3119 obstack_grow0 (&temporary_obstack,
3120 code_from_source, strlen (code_from_source));
3121 remainder = obstack_finish (&temporary_obstack);
3123 warning ("%s.\n%s", msgid, remainder);
3125 error ("%s.\n%s", msgid, remainder);
3127 /* This allow us to cheaply avoid an extra 'Invalid expression
3128 statement' error report when errors have been already reported on
3129 the same line. This occurs when we report an error but don't have
3130 a synchronization point other than ';', which
3131 expression_statement is the only one to take care of. */
3132 #ifndef USE_MAPPED_LOCATION
3133 input_line = save_lineno;
3135 ctxp->prevent_ese = input_line;
3139 issue_warning_error_from_context (
3140 #ifdef USE_MAPPED_LOCATION
3145 const char *msgid, va_list *ap)
3147 #ifdef USE_MAPPED_LOCATION
3148 source_location saved_location = input_location;
3149 expanded_location xloc = expand_location (cl);
3151 java_lc save_lc = ctxp->lexer->token_start;
3152 const char *saved = ctxp->filename, *saved_input_filename;
3157 text.err_no = errno;
3159 text.format_spec = msgid;
3160 pp_format_text (global_dc->printer, &text);
3161 strncpy (buffer, pp_formatted_text (global_dc->printer), sizeof (buffer) - 1);
3162 buffer[sizeof (buffer) - 1] = '\0';
3163 pp_clear_output_area (global_dc->printer);
3167 #ifdef USE_MAPPED_LOCATION
3168 if (xloc.file != NULL)
3170 ctxp->filename = xloc.file;
3171 input_location = cl;
3174 ctxp->lexer->token_start.line = EXPR_WFL_LINENO (cl);
3175 ctxp->lexer->token_start.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1
3176 : EXPR_WFL_COLNO (cl) == 0xffe ? -2
3177 : EXPR_WFL_COLNO (cl));
3179 /* We have a CL, that's a good reason for using it if it contains data */
3180 if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3181 ctxp->filename = EXPR_WFL_FILENAME (cl);
3182 saved_input_filename = input_filename;
3183 input_filename = ctxp->filename;
3186 java_error (buffer);
3187 #ifdef USE_MAPPED_LOCATION
3188 input_location = saved_location;
3190 ctxp->filename = saved;
3191 input_filename = saved_input_filename;
3192 ctxp->lexer->token_start = save_lc;
3197 /* Issue an error message at a current source line CL.
3198 FUTURE/FIXME: change cl to be a source_location. */
3201 parse_error_context (tree cl, const char *msgid, ...)
3204 va_start (ap, msgid);
3205 #ifdef USE_MAPPED_LOCATION
3206 issue_warning_error_from_context (EXPR_LOCATION (cl), msgid, &ap);
3208 issue_warning_error_from_context (cl, msgid, &ap);
3213 /* Issue a warning at a current source line CL.
3214 FUTURE/FIXME: change cl to be a source_location. */
3217 parse_warning_context (tree cl, const char *msgid, ...)
3220 va_start (ap, msgid);
3223 #ifdef USE_MAPPED_LOCATION
3224 issue_warning_error_from_context (EXPR_LOCATION (cl), msgid, &ap);
3226 issue_warning_error_from_context (cl, msgid, &ap);
3233 find_expr_with_wfl (tree node)
3237 enum tree_code_class code;
3240 switch (TREE_CODE (node))
3243 node = BLOCK_EXPR_BODY (node);
3247 to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3250 node = TREE_OPERAND (node, 1);
3254 node = TREE_OPERAND (node, 0);
3257 case LABELED_BLOCK_EXPR:
3258 node = LABELED_BLOCK_BODY (node);
3262 code = TREE_CODE_CLASS (TREE_CODE (node));
3263 if (((code == tcc_unary) || (code == tcc_binary)
3264 || (code == tcc_expression))
3265 && EXPR_WFL_LINECOL (node))
3273 /* Issue a missing return statement error. Uses METHOD to figure the
3274 last line of the method the error occurs in. */
3277 missing_return_error (tree method)
3279 #ifdef USE_MAPPED_LOCATION
3280 SET_EXPR_LOCATION (wfl_operator, DECL_FUNCTION_LAST_LINE (method));
3282 EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3284 parse_error_context (wfl_operator, "Missing return statement");
3287 /* Issue an unreachable statement error. From NODE, find the next
3288 statement to report appropriately. */
3290 unreachable_stmt_error (tree node)
3292 /* Browse node to find the next expression node that has a WFL. Use
3293 the location to report the error */
3294 if (TREE_CODE (node) == COMPOUND_EXPR)
3295 node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3297 node = find_expr_with_wfl (node);
3301 #ifdef USE_MAPPED_LOCATION
3302 SET_EXPR_LOCATION (wfl_operator, EXPR_LOCATION (node));
3304 EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3306 parse_error_context (wfl_operator, "Unreachable statement");
3313 not_accessible_field_error (tree wfl, tree decl)
3316 (wfl, "Can't access %s field %<%s.%s%> from %qs",
3317 accessibility_string (get_access_flags_from_decl (decl)),
3318 GET_TYPE_NAME (DECL_CONTEXT (decl)),
3319 IDENTIFIER_POINTER (DECL_NAME (decl)),
3320 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3325 java_report_errors (void)
3327 if (java_error_count)
3328 fprintf (stderr, "%d error%s",
3329 java_error_count, (java_error_count == 1 ? "" : "s"));
3330 if (java_warning_count)
3331 fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3332 java_warning_count, (java_warning_count == 1 ? "" : "s"));
3333 if (java_error_count || java_warning_count)
3334 putc ('\n', stderr);
3335 return java_error_count;
3339 java_accstring_lookup (int flags)
3341 static char buffer [80];
3342 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3344 /* Access modifier looked-up first for easier report on forbidden
3346 if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3347 if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3348 if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3349 if (flags & ACC_STATIC) COPY_RETURN ("static");
3350 if (flags & ACC_FINAL) COPY_RETURN ("final");
3351 if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3352 if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3353 if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3354 if (flags & ACC_NATIVE) COPY_RETURN ("native");
3355 if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3356 if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3363 /* Returns a string denoting the accessibility of a class or a member as
3364 indicated by FLAGS. We need a separate function from
3365 java_accstring_lookup, as the latter can return spurious "static", etc.
3366 if package-private access is defined (in which case none of the
3367 relevant access control bits in FLAGS is set). */
3370 accessibility_string (int flags)
3372 if (flags & ACC_PRIVATE) return "private";
3373 if (flags & ACC_PROTECTED) return "protected";
3374 if (flags & ACC_PUBLIC) return "public";
3376 return "package-private";
3379 /* Issuing error messages upon redefinition of classes, interfaces or
3383 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3385 parse_error_context (cl, "%s %qs already defined in %s:%d",
3386 context, IDENTIFIER_POINTER (id),
3387 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3388 /* Here we should point out where its redefined. It's a unicode. FIXME */
3392 variable_redefinition_error (tree context, tree name, tree type, int line)
3394 const char *type_name;
3396 /* Figure a proper name for type. We might haven't resolved it */
3397 if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3398 type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3400 type_name = lang_printable_name (type, 0);
3402 parse_error_context (context,
3403 "Variable %qs is already defined in this method and was declared %<%s %s%> at line %d",
3404 IDENTIFIER_POINTER (name),
3405 type_name, IDENTIFIER_POINTER (name), line);
3408 /* If ANAME is terminated with `[]', it indicates an array. This
3409 function returns the number of `[]' found and if this number is
3410 greater than zero, it extracts the array type name and places it in
3411 the node pointed to by TRIMMED unless TRIMMED is null. */
3414 build_type_name_from_array_name (tree aname, tree *trimmed)
3416 const char *name = IDENTIFIER_POINTER (aname);
3417 int len = IDENTIFIER_LENGTH (aname);
3420 STRING_STRIP_BRACKETS (name, len, array_dims);
3422 if (array_dims && trimmed)
3423 *trimmed = get_identifier_with_length (name, len);
3429 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3433 /* Eventually get more dims */
3434 more_dims = build_type_name_from_array_name (name, &name);
3436 /* If we have, then craft a new type for this variable */
3441 /* If we have a pointer, use its type */
3442 if (TREE_CODE (type) == POINTER_TYPE)
3443 type = TREE_TYPE (type);
3445 /* Building the first dimension of a primitive type uses this
3447 if (JPRIMITIVE_TYPE_P (type))
3449 type = build_java_array_type (type, -1);
3452 /* Otherwise, if we have a WFL for this type, use it (the type
3453 is already an array on an unresolved type, and we just keep
3454 on adding dimensions) */
3458 more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3462 /* Add all the dimensions */
3464 type = build_unresolved_array_type (type);
3466 /* The type may have been incomplete in the first place */
3468 type = obtain_incomplete_type (type);
3476 /* Build something that the type identifier resolver will identify as
3477 being an array to an unresolved type. TYPE_WFL is a WFL on a
3481 build_unresolved_array_type (tree type_or_wfl)
3486 /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3487 just create a array type */
3488 if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3489 return build_java_array_type (type_or_wfl, -1);
3491 obstack_grow (&temporary_obstack,
3492 IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3493 IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3494 obstack_grow0 (&temporary_obstack, "[]", 2);
3495 ptr = obstack_finish (&temporary_obstack);
3496 #ifdef USE_MAPPED_LOCATION
3497 wfl = build_expr_wfl (get_identifier (ptr), EXPR_LOCATION (type_or_wfl));
3499 wfl = build_expr_wfl (get_identifier (ptr),
3500 EXPR_WFL_FILENAME (type_or_wfl),
3501 EXPR_WFL_LINENO (type_or_wfl),
3502 EXPR_WFL_COLNO (type_or_wfl));
3504 /* Re-install the existing qualifications so that the type can be
3505 resolved properly. */
3506 EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3511 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3513 if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3514 parse_error_context (wfl, "Interface %qs repeated",
3515 IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3518 /* Bulk of common class/interface checks. Return 1 if an error was
3519 encountered. TAG is 0 for a class, 1 for an interface. */
3522 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3523 tree qualified_name, tree decl, tree cl)
3526 int sca = 0; /* Static class allowed */
3527 int icaf = 0; /* Inner class allowed flags */
3528 int uaaf = CLASS_MODIFIERS; /* Usually allowed access flags */
3531 fprintf (stderr, " %s%s %s",
3532 (CPC_INNER_P () ? "inner" : ""),
3533 (is_interface ? "interface" : "class"),
3534 IDENTIFIER_POINTER (qualified_name));
3536 /* Scope of an interface/class type name:
3537 - Can't be imported by a single type import
3538 - Can't already exists in the package */
3539 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3540 && (node = find_name_in_single_imports (raw_name))
3544 (cl, "%s name %qs clashes with imported type %qs",
3545 (is_interface ? "Interface" : "Class"),
3546 IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3549 if (decl && CLASS_COMPLETE_P (decl))
3551 classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3552 qualified_name, decl, cl);
3556 if (check_inner_class_redefinition (raw_name, cl))
3559 /* If public, file name should match class/interface name, except
3560 when dealing with an inner class */
3561 if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3563 const char *fname = input_filename;
3566 for (f = fname + strlen (fname);
3567 f != fname && ! IS_DIR_SEPARATOR (*f);
3570 if (IS_DIR_SEPARATOR (*f))
3572 if (strncmp (IDENTIFIER_POINTER (raw_name),
3573 f , IDENTIFIER_LENGTH (raw_name)) ||
3574 f [IDENTIFIER_LENGTH (raw_name)] != '.')
3576 (cl, "Public %s %qs must be defined in a file called %<%s.java%>",
3577 (is_interface ? "interface" : "class"),
3578 IDENTIFIER_POINTER (qualified_name),
3579 IDENTIFIER_POINTER (raw_name));
3582 /* Static classes can be declared only in top level classes. Note:
3583 once static, a inner class is a top level class. */
3584 if (flags & ACC_STATIC)
3586 /* Catch the specific error of declaring an class inner class
3587 with no toplevel enclosing class. Prevent check_modifiers from
3588 complaining a second time */
3589 if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3591 parse_error_context (cl, "Inner class %qs can't be static. Static classes can only occur in interfaces and top-level classes",
3592 IDENTIFIER_POINTER (qualified_name));
3595 /* Else, in the context of a top-level class declaration, let
3596 `check_modifiers' do its job, otherwise, give it a go */
3598 sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3601 /* Inner classes can be declared private or protected
3602 within their enclosing classes. */
3605 /* A class which is local to a block can't be public, private,
3606 protected or static. But it is created final, so allow this
3608 if (current_function_decl)
3609 icaf = sca = uaaf = ACC_FINAL;
3612 check_modifiers_consistency (flags);
3613 icaf = ACC_PROTECTED;
3614 if (! CLASS_INTERFACE (GET_CPC ()))
3615 icaf |= ACC_PRIVATE;
3622 uaaf = INTERFACE_INNER_MODIFIERS;
3624 uaaf = INTERFACE_MODIFIERS;
3626 check_modifiers ("Illegal modifier %qs for interface declaration",
3630 check_modifiers ((current_function_decl ?
3631 "Illegal modifier %qs for local class declaration" :
3632 "Illegal modifier %qs for class declaration"),
3633 flags, uaaf|sca|icaf);
3637 /* Construct a nested class name. If the final component starts with
3638 a digit, return true. Otherwise return false. */
3640 make_nested_class_name (tree cpc_list)
3647 make_nested_class_name (TREE_CHAIN (cpc_list));
3649 /* Pick the qualified name when dealing with the first upmost
3651 name = (TREE_CHAIN (cpc_list)
3652 ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3653 obstack_grow (&temporary_obstack,
3654 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3655 obstack_1grow (&temporary_obstack, '$');
3657 return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3660 /* Can't redefine a class already defined in an earlier scope. */
3663 check_inner_class_redefinition (tree raw_name, tree cl)
3667 for (scope_list = GET_CPC_LIST (); scope_list;
3668 scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3669 if (raw_name == GET_CPC_UN_NODE (scope_list))
3672 (cl, "The class name %qs is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
3673 IDENTIFIER_POINTER (raw_name));
3679 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3680 we remember ENCLOSING and SUPER. */
3683 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3684 tree *super, tree class_type)
3686 tree local_enclosing = *enclosing;
3687 tree local_super = NULL_TREE;
3689 while (local_enclosing)
3691 tree intermediate, decl;
3693 *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3696 if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3699 intermediate = local_enclosing;
3700 /* Explore enclosing contexts. */
3701 while (INNER_CLASS_DECL_P (intermediate))
3703 intermediate = DECL_CONTEXT (intermediate);
3704 if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3708 /* Now go to the upper classes, bail out if necessary. We will
3709 analyze the returned SUPER and act accordingly (see
3710 do_resolve_class). */
3711 if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3712 || TREE_TYPE (local_enclosing) == void_type_node)
3714 parse_error_context (cl, "Qualifier must be a reference");
3715 local_enclosing = NULL_TREE;
3718 local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3719 if (!local_super || local_super == object_type_node)
3722 if (TREE_CODE (local_super) == POINTER_TYPE)
3723 local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3725 local_super = TYPE_NAME (local_super);
3727 /* We may not have checked for circular inheritance yet, so do so
3728 here to prevent an infinite loop. */
3729 if (htab_find (circularity_hash, local_super) != NULL)
3732 cl = lookup_cl (local_enclosing);
3735 (cl, "Cyclic inheritance involving %s",
3736 IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3737 local_enclosing = NULL_TREE;
3740 local_enclosing = local_super;
3743 /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3744 *super = local_super;
3745 *enclosing = local_enclosing;
3750 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3754 find_as_inner_class (tree enclosing, tree name, tree cl)
3756 tree qual, to_return;
3760 name = TYPE_NAME (name);
3762 /* First search: within the scope of `enclosing', search for name */
3763 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3764 qual = EXPR_WFL_QUALIFICATION (cl);
3766 qual = build_tree_list (cl, NULL_TREE);
3768 qual = build_tree_list (build_unknown_wfl (name), NULL_TREE);
3770 if ((to_return = find_as_inner_class_do (qual, enclosing)))
3773 /* We're dealing with a qualified name. Try to resolve thing until
3774 we get something that is an enclosing class. */
3775 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3777 tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3779 for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3780 qual = TREE_CHAIN (qual))
3782 acc = merge_qualified_name (acc,
3783 EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3784 BUILD_PTR_FROM_NAME (ptr, acc);
3785 decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3788 /* A NULL qual and a decl means that the search ended
3789 successfully?!? We have to do something then. FIXME */
3794 qual = EXPR_WFL_QUALIFICATION (cl);
3796 /* Otherwise, create a qual for the other part of the resolution. */
3798 qual = build_tree_list (build_unknown_wfl (name), NULL_TREE);
3800 return find_as_inner_class_do (qual, enclosing);
3803 /* We go inside the list of sub classes and try to find a way
3807 find_as_inner_class_do (tree qual, tree enclosing)
3812 for (; qual && enclosing; qual = TREE_CHAIN (qual))
3814 tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3815 tree next_enclosing = NULL_TREE;
3818 for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3819 inner_list; inner_list = TREE_CHAIN (inner_list))
3821 if (TREE_VALUE (inner_list) == name_to_match)
3823 next_enclosing = TREE_PURPOSE (inner_list);
3827 enclosing = next_enclosing;
3830 return (!qual && enclosing ? enclosing : NULL_TREE);
3834 link_nested_class_to_enclosing (void)
3836 if (GET_ENCLOSING_CPC ())
3838 tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3839 DECL_INNER_CLASS_LIST (enclosing) =
3840 tree_cons (GET_CPC (), GET_CPC_UN (),
3841 DECL_INNER_CLASS_LIST (enclosing));
3846 maybe_make_nested_class_name (tree name)
3848 tree id = NULL_TREE;
3852 /* If we're in a function, we must append a number to create the
3853 nested class name. However, we don't do this if the class we
3854 are constructing is anonymous, because in that case we'll
3855 already have a number as the class name. */
3856 if (! make_nested_class_name (GET_CPC_LIST ())
3857 && current_function_decl != NULL_TREE
3858 && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3861 sprintf (buf, "%d", anonymous_class_counter);
3862 ++anonymous_class_counter;
3863 obstack_grow (&temporary_obstack, buf, strlen (buf));
3864 obstack_1grow (&temporary_obstack, '$');
3866 obstack_grow0 (&temporary_obstack,
3867 IDENTIFIER_POINTER (name),
3868 IDENTIFIER_LENGTH (name));
3869 id = get_identifier (obstack_finish (&temporary_obstack));
3871 QUALIFIED_P (id) = 1;
3876 /* If DECL is NULL, create and push a new DECL, record the current
3877 line CL and do other maintenance things. */
3880 maybe_create_class_interface_decl (tree decl, tree raw_name,
3881 tree qualified_name, tree cl)
3884 decl = push_class (make_class (), qualified_name);
3886 /* Take care of the file and line business */
3887 #ifdef USE_MAPPED_LOCATION
3888 DECL_SOURCE_LOCATION (decl) = EXPR_LOCATION (cl);
3890 DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3891 /* If we're emitting xrefs, store the line/col number information */
3893 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3895 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3897 CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3898 CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3899 #ifdef USE_MAPPED_LOCATION
3901 tree tmp = maybe_get_identifier (EXPR_FILENAME (cl));
3902 CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3903 tmp && IS_A_COMMAND_LINE_FILENAME_P (tmp);
3906 CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3907 IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3910 PUSH_CPC (decl, raw_name);
3911 DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3913 /* Link the declaration to the already seen ones */
3914 TREE_CHAIN (decl) = ctxp->class_list;
3915 ctxp->class_list = decl;
3917 /* Create a new nodes in the global lists */
3918 gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3919 all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3921 /* Install a new dependency list element */
3922 create_jdep_list (ctxp);
3924 SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3925 IDENTIFIER_POINTER (qualified_name)));
3930 add_superinterfaces (tree decl, tree interface_list)
3933 /* Superinterface(s): if present and defined, parser_check_super_interface ()
3934 takes care of ensuring that:
3935 - This is an accessible interface type,
3936 - Circularity detection.
3937 parser_add_interface is then called. If present but not defined,
3938 the check operation is delayed until the super interface gets
3940 for (node = interface_list; node; node = TREE_CHAIN (node))
3942 tree current = TREE_PURPOSE (node);
3943 tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3944 if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3946 if (!parser_check_super_interface (idecl, decl, current))
3947 parser_add_interface (decl, idecl, current);
3950 register_incomplete_type (JDEP_INTERFACE,
3951 current, decl, NULL_TREE);
3955 /* Create an interface in pass1 and return its decl. Return the
3956 interface's decl in pass 2. */
3959 create_interface (int flags, tree id, tree super)
3961 tree raw_name = EXPR_WFL_NODE (id);
3962 tree q_name = parser_qualified_classname (raw_name);
3963 tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3965 /* Certain syntax errors are making SUPER be like ID. Avoid this
3967 if (ctxp->class_err && id == super)
3970 EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */
3972 /* Basic checks: scope, redefinition, modifiers */
3973 if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3979 /* Suspend the current parsing context if we're parsing an inner
3983 java_parser_context_suspend ();
3984 /* Interface members are public. */
3985 if (CLASS_INTERFACE (GET_CPC ()))
3986 flags |= ACC_PUBLIC;
3989 /* Push a new context for (static) initialized upon declaration fields */
3990 java_parser_context_push_initialized_field ();
3992 /* Interface modifiers check
3993 - public/abstract allowed (already done at that point)
3994 - abstract is obsolete (comes first, it's a warning, or should be)
3995 - Can't use twice the same (checked in the modifier rule) */
3996 if ((flags & ACC_ABSTRACT) && flag_redundant)
3997 parse_warning_context
3998 (MODIFIER_WFL (ABSTRACT_TK),
3999 "Redundant use of %<abstract%> modifier. Interface %qs is implicitly abstract", IDENTIFIER_POINTER (raw_name));
4001 /* Create a new decl if DECL is NULL, otherwise fix it */
4002 decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
4004 /* Interfaces are always abstract. */
4005 flags |= ACC_ABSTRACT;
4007 /* Inner interfaces are always static. */
4008 if (INNER_CLASS_DECL_P (decl))
4009 flags |= ACC_STATIC;
4011 /* Set super info and mark the class a complete */
4012 set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
4013 object_type_node, ctxp->interface_number);
4014 ctxp->interface_number = 0;
4015 CLASS_COMPLETE_P (decl) = 1;
4016 add_superinterfaces (decl, super);
4018 /* Eventually sets the @deprecated tag flag */
4019 CHECK_DEPRECATED (decl);
4024 /* Patch anonymous class CLASS, by either extending or implementing
4028 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
4030 tree class = TREE_TYPE (class_decl);
4031 tree type = TREE_TYPE (type_decl);
4032 tree binfo = TYPE_BINFO (class);
4034 /* If it's an interface, implement it */
4035 if (CLASS_INTERFACE (type_decl))
4037 if (parser_check_super_interface (type_decl, class_decl, wfl))
4040 if (!VEC_space (tree, BINFO_BASE_BINFOS (binfo), 1))
4042 /* Extend the binfo - by reallocating and copying it. */
4047 new_binfo = make_tree_binfo ((BINFO_N_BASE_BINFOS (binfo) + 1) * 2);
4048 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4049 BINFO_BASE_APPEND (new_binfo, base_binfo);
4050 CLASS_HAS_SUPER_FLAG (new_binfo) = CLASS_HAS_SUPER_FLAG (binfo);
4051 BINFO_VTABLE (new_binfo) = BINFO_VTABLE (binfo);
4052 TYPE_BINFO (class) = new_binfo;
4055 /* And add the interface */
4056 parser_add_interface (class_decl, type_decl, wfl);
4058 /* Otherwise, it's a type we want to extend */
4061 if (parser_check_super (type_decl, class_decl, wfl))
4063 BINFO_TYPE (BINFO_BASE_BINFO (binfo, 0)) = type;
4067 /* Create an anonymous class which extends/implements TYPE_NAME, and return
4071 create_anonymous_class (tree type_name)
4074 tree super = NULL_TREE, itf = NULL_TREE;
4075 tree id, type_decl, class;
4077 /* The unqualified name of the anonymous class. It's just a number. */
4078 sprintf (buffer, "%d", anonymous_class_counter++);
4079 id = build_wfl_node (get_identifier (buffer));
4080 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL (type_name);
4082 /* We know about the type to extend/implement. We go ahead */
4083 if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
4085 /* Create a class which either implements on extends the designated
4086 class. The class bears an inaccessible name. */
4087 if (CLASS_INTERFACE (type_decl))
4089 /* It's OK to modify it here. It's been already used and
4090 shouldn't be reused */
4091 ctxp->interface_number = 1;
4092 /* Interfaces should presented as a list of WFLs */
4093 itf = build_tree_list (type_name, NULL_TREE);
4099 class = create_class (ACC_FINAL, id, super, itf);
4101 /* We didn't know anything about the stuff. We register a dependence. */
4103 register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
4105 ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
4109 /* Create a class in pass1 and return its decl. Return class
4110 interface's decl in pass 2. */
4113 create_class (int flags, tree id, tree super, tree interfaces)
4115 tree raw_name = EXPR_WFL_NODE (id);
4116 tree class_id, decl;
4117 tree super_decl_type;
4119 /* Certain syntax errors are making SUPER be like ID. Avoid this
4121 if (ctxp->class_err && id == super)
4124 class_id = parser_qualified_classname (raw_name);
4125 decl = IDENTIFIER_CLASS_VALUE (class_id);
4126 EXPR_WFL_NODE (id) = class_id;
4128 /* Basic check: scope, redefinition, modifiers */
4129 if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
4135 /* Suspend the current parsing context if we're parsing an inner
4136 class or an anonymous class. */
4139 java_parser_context_suspend ();
4140 /* Interface members are public. */
4141 if (CLASS_INTERFACE (GET_CPC ()))
4142 flags |= ACC_PUBLIC;
4145 /* Push a new context for (static) initialized upon declaration fields */
4146 java_parser_context_push_initialized_field ();
4148 /* Class modifier check:
4149 - Allowed modifier (already done at that point)
4150 - abstract AND final forbidden
4151 - Public classes defined in the correct file */
4152 if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
4154 (id, "Class %qs can't be declared both abstract and final",
4155 IDENTIFIER_POINTER (raw_name));
4157 /* Create a new decl if DECL is NULL, otherwise fix it */
4158 decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
4160 /* If SUPER exists, use it, otherwise use Object */
4163 /* java.lang.Object can't extend anything. */
4164 if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4166 parse_error_context (id, "%<java.lang.Object%> can't extend anything");
4171 register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4173 else if (TREE_TYPE (decl) != object_type_node)
4174 super_decl_type = object_type_node;
4175 /* We're defining java.lang.Object */
4177 super_decl_type = NULL_TREE;
4179 /* A class nested in an interface is implicitly static. */
4180 if (INNER_CLASS_DECL_P (decl)
4181 && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4183 flags |= ACC_STATIC;
4186 /* Set super info and mark the class as complete. */
4187 set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4188 ctxp->interface_number);
4189 ctxp->interface_number = 0;
4190 CLASS_COMPLETE_P (decl) = 1;
4191 add_superinterfaces (decl, interfaces);
4193 /* TYPE_VFIELD' is a compiler-generated field used to point to
4194 virtual function tables. In gcj, every class has a common base
4195 virtual function table in java.lang.object. */
4196 TYPE_VFIELD (TREE_TYPE (decl)) = TYPE_VFIELD (object_type_node);
4198 /* Add the private this$<n> field, Replicate final locals still in
4199 scope as private final fields mangled like val$<local_name>.
4200 This does not occur for top level (static) inner classes. */
4201 if (PURE_INNER_CLASS_DECL_P (decl))
4202 add_inner_class_fields (decl, current_function_decl);
4204 /* If doing xref, store the location at which the inherited class
4205 (if any) was seen. */
4206 if (flag_emit_xref && super)
4207 DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4209 /* Eventually sets the @deprecated tag flag */
4210 CHECK_DEPRECATED (decl);
4212 /* Reset the anonymous class counter when declaring non inner classes */
4213 if (!INNER_CLASS_DECL_P (decl))
4214 anonymous_class_counter = 1;
4219 /* End a class declaration: register the statements used to create
4220 finit$ and <clinit>, pop the current class and resume the prior
4221 parser context if necessary. */
4224 end_class_declaration (int resume)
4226 /* If an error occurred, context weren't pushed and won't need to be
4227 popped by a resume. */
4228 int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4230 if (GET_CPC () != error_mark_node)
4231 dump_java_tree (TDI_class, GET_CPC ());
4233 java_parser_context_pop_initialized_field ();
4235 if (resume && no_error_occurred)
4236 java_parser_context_resume ();
4238 /* We're ending a class declaration, this is a good time to reset
4239 the interface cout. Note that might have been already done in
4240 create_interface, but if at that time an inner class was being
4241 dealt with, the interface count was reset in a context created
4242 for the sake of handling inner classes declaration. */
4243 ctxp->interface_number = 0;
4247 add_inner_class_fields (tree class_decl, tree fct_decl)
4249 tree block, marker, f;
4251 f = add_field (TREE_TYPE (class_decl),
4252 build_current_thisn (TREE_TYPE (class_decl)),
4253 build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4255 FIELD_THISN (f) = 1;
4260 for (block = GET_CURRENT_BLOCK (fct_decl);
4261 block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4264 for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4267 tree wfl, init, list;
4269 /* Avoid non final arguments. */
4270 if (!LOCAL_FINAL_P (decl))
4273 MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4274 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4275 wfl = build_wfl_node (name);
4276 init = build_wfl_node (pname);
4277 /* Build an initialization for the field: it will be
4278 initialized by a parameter added to finit$, bearing a
4279 mangled name of the field itself (param$<n>.) The
4280 parameter is provided to finit$ by the constructor
4281 invoking it (hence the constructor will also feature a
4282 hidden parameter, set to the value of the outer context
4283 local at the time the inner class is created.)
4285 Note: we take into account all possible locals that can
4286 be accessed by the inner class. It's actually not trivial
4287 to minimize these aliases down to the ones really
4288 used. One way to do that would be to expand all regular
4289 methods first, then finit$ to get a picture of what's
4290 used. It works with the exception that we would have to
4291 go back on all constructor invoked in regular methods to
4292 have their invocation reworked (to include the right amount
4293 of alias initializer parameters.)
4295 The only real way around, I think, is a first pass to
4296 identify locals really used in the inner class. We leave
4297 the flag FIELD_LOCAL_ALIAS_USED around for that future
4300 On the other hand, it only affect local inner classes,
4301 whose constructors (and finit$ call) will be featuring
4302 unnecessary arguments. It's easy for a developer to keep
4303 this number of parameter down by using the `final'
4304 keyword only when necessary. For the time being, we can
4305 issue a warning on unnecessary finals. FIXME */
4306 init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4309 /* Register the field. The TREE_LIST holding the part
4310 initialized/initializer will be marked ARG_FINAL_P so
4311 that the created field can be marked
4312 FIELD_LOCAL_ALIAS. */
4313 list = build_tree_list (wfl, init);
4314 ARG_FINAL_P (list) = 1;
4315 register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4319 if (!CPC_INITIALIZER_STMT (ctxp))
4322 /* If we ever registered an alias field, insert and marker to
4323 remember where the list ends. The second part of the list (the one
4324 featuring initialized fields) so it can be later reversed to
4325 enforce 8.5. The marker will be removed during that operation. */
4326 marker = build_tree_list (NULL_TREE, NULL_TREE);
4327 TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4328 SET_CPC_INITIALIZER_STMT (ctxp, marker);
4331 /* Can't use lookup_field () since we don't want to load the class and
4332 can't set the CLASS_LOADED_P flag */
4335 find_field (tree class, tree name)
4338 for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4340 if (DECL_NAME (decl) == name)
4346 /* Wrap around lookup_field that doesn't potentially upset the value
4350 lookup_field_wrapper (tree class, tree name)
4353 tree decl = NULL_TREE;
4354 java_parser_context_save_global ();
4356 /* Last chance: if we're within the context of an inner class, we
4357 might be trying to access a local variable defined in an outer
4358 context. We try to look for it now. */
4359 if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4362 MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4363 decl = lookup_field (&type, new_name);
4364 if (decl && decl != error_mark_node)
4365 FIELD_LOCAL_ALIAS_USED (decl) = 1;
4367 if (!decl || decl == error_mark_node)
4370 decl = lookup_field (&type, name);
4373 /* If the field still hasn't been found, try the next enclosing context. */
4374 if (!decl && INNER_CLASS_TYPE_P (class))
4376 tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4377 decl = lookup_field_wrapper (outer_type, name);
4380 java_parser_context_restore_global ();
4381 return decl == error_mark_node ? NULL : decl;
4384 /* Find duplicate field within the same class declarations and report
4385 the error. Returns 1 if a duplicated field was found, 0
4389 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4391 /* This might be modified to work with method decl as well */
4392 tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4395 char *t1 = xstrdup (purify_type_name
4396 ((TREE_CODE (new_type) == POINTER_TYPE
4397 && TREE_TYPE (new_type) == NULL_TREE) ?
4398 IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4399 lang_printable_name (new_type, 1)));
4400 /* The type may not have been completed by the time we report
4402 char *t2 = xstrdup (purify_type_name
4403 ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4404 && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4405 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4406 lang_printable_name (TREE_TYPE (decl), 1)));
4408 (cl, "Duplicate variable declaration: %<%s %s%> was %<%s %s%> (%s:%d)",
4409 t1, IDENTIFIER_POINTER (new_field_name),
4410 t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4411 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4419 /* Field registration routine. If TYPE doesn't exist, field
4420 declarations are linked to the undefined TYPE dependency list, to
4421 be later resolved in java_complete_class () */
4424 register_fields (int flags, tree type, tree variable_list)
4426 tree current, saved_type;
4427 tree class_type = NULL_TREE;
4428 location_t saved_location = input_location;
4430 tree wfl = NULL_TREE;
4433 class_type = TREE_TYPE (GET_CPC ());
4435 if (!class_type || class_type == error_mark_node)
4438 /* If we're adding fields to interfaces, those fields are public,
4440 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4442 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4443 flags, ACC_PUBLIC, "interface field(s)");
4444 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4445 flags, ACC_STATIC, "interface field(s)");
4446 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4447 flags, ACC_FINAL, "interface field(s)");
4448 check_modifiers ("Illegal interface member modifier %qs", flags,
4449 INTERFACE_FIELD_MODIFIERS);
4450 flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4453 /* Obtain a suitable type for resolution, if necessary */
4454 SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4456 /* If TYPE is fully resolved and we don't have a reference, make one */
4457 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4459 for (current = variable_list, saved_type = type; current;
4460 current = TREE_CHAIN (current), type = saved_type)
4464 tree cl = TREE_PURPOSE (current);
4465 tree init = TREE_VALUE (current);
4466 tree current_name = EXPR_WFL_NODE (cl);
4468 /* Can't declare non-final static fields in inner classes */
4469 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4470 && !(flags & ACC_FINAL))
4472 (cl, "Field %qs can't be static in inner class %qs unless it is final",
4473 IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4474 lang_printable_name (class_type, 0));
4476 /* Process NAME, as it may specify extra dimension(s) for it */
4477 type = build_array_from_name (type, wfl, current_name, ¤t_name);
4479 /* Type adjustment. We may have just readjusted TYPE because
4480 the variable specified more dimensions. Make sure we have
4481 a reference if we can and don't have one already. Also
4482 change the name if we have an init. */
4483 if (type != saved_type)
4485 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4487 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4490 real_type = GET_REAL_TYPE (type);
4491 /* Check for redeclarations */
4492 if (duplicate_declaration_error_p (current_name, real_type, cl))
4495 /* Set input_line to the line the field was found and create a
4496 declaration for it. Eventually sets the @deprecated tag flag. */
4497 #ifdef USE_MAPPED_LOCATION
4498 input_location = EXPR_LOCATION (cl);
4501 input_line = EXPR_WFL_LINECOL (cl);
4503 input_line = EXPR_WFL_LINENO (cl);
4505 field_decl = add_field (class_type, current_name, real_type, flags);
4506 CHECK_DEPRECATED_NO_RESET (field_decl);
4508 /* If the field denotes a final instance variable, then we
4509 allocate a LANG_DECL_SPECIFIC part to keep track of its
4510 initialization. We also mark whether the field was
4511 initialized upon its declaration. We don't do that if the
4512 created field is an alias to a final local. */
4513 if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4515 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4516 DECL_FIELD_FINAL_WFL (field_decl) = cl;
4519 /* If the couple initializer/initialized is marked ARG_FINAL_P,
4520 we mark the created field FIELD_LOCAL_ALIAS, so that we can
4521 hide parameters to this inner class finit$ and
4522 constructors. It also means that the field isn't final per
4524 if (ARG_FINAL_P (current))
4526 FIELD_LOCAL_ALIAS (field_decl) = 1;
4527 FIELD_FINAL (field_decl) = 0;
4530 /* Check if we must chain. */
4532 register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4534 /* If we have an initialization value tied to the field */
4537 /* The field is declared static */
4538 if (flags & ACC_STATIC)
4540 /* We include the field and its initialization part into
4541 a list used to generate <clinit>. After <clinit> is
4542 walked, field initializations will be processed and
4543 fields initialized with known constants will be taken
4544 out of <clinit> and have their DECL_INITIAL set
4546 TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4547 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4548 if (TREE_OPERAND (init, 1)
4549 && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4550 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4552 /* A non-static field declared with an immediate initialization is
4553 to be initialized in <init>, if any. This field is remembered
4554 to be processed at the time of the generation of <init>. */
4557 TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4558 SET_CPC_INITIALIZER_STMT (ctxp, init);
4560 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4561 DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4566 input_location = saved_location;
4569 /* Generate finit$, using the list of initialized fields to populate
4570 its body. finit$'s parameter(s) list is adjusted to include the
4571 one(s) used to initialized the field(s) caching outer context
4575 generate_finit (tree class_type)
4578 tree list = TYPE_FINIT_STMT_LIST (class_type);
4579 tree mdecl, current, parms;
4581 parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4582 class_type, NULL_TREE,
4584 CRAFTED_PARAM_LIST_FIXUP (parms);
4585 mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4586 finit_identifier_node, parms);
4587 fix_method_argument_names (parms, mdecl);
4588 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4590 DECL_FUNCTION_NAP (mdecl) = count;
4591 start_artificial_method_body (mdecl);
4593 for (current = list; current; current = TREE_CHAIN (current))
4594 java_method_add_stmt (mdecl,
4595 build_debugable_stmt (EXPR_WFL_LINECOL (current),
4597 end_artificial_method_body (mdecl);
4601 /* Generate a function to run the instance initialization code. The
4602 private method is called `instinit$'. Unless we're dealing with an
4603 anonymous class, we determine whether all ctors of CLASS_TYPE
4604 declare a checked exception in their `throws' clause in order to
4605 see whether it's necessary to encapsulate the instance initializer
4606 statements in a try/catch/rethrow sequence. */
4609 generate_instinit (tree class_type)
4612 tree compound = NULL_TREE;
4613 tree parms = tree_cons (this_identifier_node,
4614 build_pointer_type (class_type), end_params_node);
4615 tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4617 instinit_identifier_node, parms);
4619 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4622 /* Gather all the statements in a compound */
4623 for (current = TYPE_II_STMT_LIST (class_type);
4624 current; current = TREE_CHAIN (current))
4625 compound = add_stmt_to_compound (compound, NULL_TREE, current);
4627 /* We need to encapsulate COMPOUND by a try/catch statement to
4628 rethrow exceptions that might occur in the instance initializer.
4629 We do that only if all ctors of CLASS_TYPE are set to catch a
4630 checked exception. This doesn't apply to anonymous classes (since
4631 they don't have declared ctors.) */
4632 if (!ANONYMOUS_CLASS_P (class_type) &&
4633 ctors_unchecked_throws_clause_p (class_type))
4635 compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4636 build1 (THROW_EXPR, NULL_TREE,
4637 build_wfl_node (wpv_id)));
4638 DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4639 exception_type_node);
4642 start_artificial_method_body (mdecl);
4643 java_method_add_stmt (mdecl, compound);
4644 end_artificial_method_body (mdecl);
4651 build_instinit_invocation (tree class_type)
4653 tree to_return = NULL_TREE;
4655 if (TYPE_II_STMT_LIST (class_type))
4657 tree parm = build_tree_list (NULL_TREE,
4658 build_wfl_node (this_identifier_node));
4660 build_method_invocation (build_wfl_node (instinit_identifier_node),
4666 /* Shared across method_declarator and method_header to remember the
4667 patch stage that was reached during the declaration of the method.
4668 A method DECL is built differently is there is no patch
4669 (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4670 pending on the currently defined method. */
4672 static int patch_stage;
4674 /* Check the method declaration and add the method to its current
4675 class. If the argument list is known to contain incomplete types,
4676 the method is partially added and the registration will be resume
4677 once the method arguments resolved. If TYPE is NULL, we're dealing
4678 with a constructor. */
4681 method_header (int flags, tree type, tree mdecl, tree throws)
4683 tree type_wfl = NULL_TREE;
4684 tree meth_name = NULL_TREE;
4685 tree current, orig_arg, this_class = NULL;
4687 location_t saved_location;
4688 int constructor_ok = 0, must_chain;
4691 if (mdecl == error_mark_node)
4692 return error_mark_node;
4693 meth = TREE_VALUE (mdecl);
4694 id = TREE_PURPOSE (mdecl);
4696 check_modifiers_consistency (flags);
4699 this_class = TREE_TYPE (GET_CPC ());
4701 if (!this_class || this_class == error_mark_node)
4704 /* There are some forbidden modifiers for an abstract method and its
4705 class must be abstract as well. */
4706 if (type && (flags & ACC_ABSTRACT))
4708 ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4709 ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4710 ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4711 ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4712 ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4713 ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4714 if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4715 && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4718 "Class %qs must be declared abstract to define abstract method %qs",
4719 IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4720 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4723 /* A native method can't be strictfp. */
4724 if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4725 parse_error_context (id, "native method %qs can't be strictfp",
4726 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4727 /* No such thing as a transient or volatile method. */
4728 if ((flags & ACC_TRANSIENT))
4729 parse_error_context (id, "method %qs can't be transient",
4730 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4731 if ((flags & ACC_VOLATILE))
4732 parse_error_context (id, "method %qs can't be volatile",
4733 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4735 /* Things to be checked when declaring a constructor */
4738 int ec = java_error_count;
4739 /* 8.6: Constructor declarations: we might be trying to define a
4740 method without specifying a return type. */
4741 if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4743 (id, "Invalid method declaration, return type required");
4744 /* 8.6.3: Constructor modifiers */
4747 JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4748 JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4749 JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4750 JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4751 JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4752 JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4754 /* If we found error here, we don't consider it's OK to tread
4755 the method definition as a constructor, for the rest of this
4757 if (ec == java_error_count)
4761 /* Method declared within the scope of an interface are implicitly
4762 abstract and public. Conflicts with other erroneously provided
4763 modifiers are checked right after. */
4765 if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4767 /* If FLAGS isn't set because of a modifier, turn the
4768 corresponding modifier WFL to NULL so we issue a warning on
4769 the obsolete use of the modifier */
4770 if (!(flags & ACC_PUBLIC))
4771 MODIFIER_WFL (PUBLIC_TK) = NULL;
4772 if (!(flags & ACC_ABSTRACT))
4773 MODIFIER_WFL (ABSTRACT_TK) = NULL;
4774 flags |= ACC_PUBLIC;
4775 flags |= ACC_ABSTRACT;
4778 /* Inner class can't declare static methods */
4779 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4782 (id, "Method %qs can't be static in inner class %qs. Only members of interfaces and top-level classes can be static",
4783 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4784 lang_printable_name (this_class, 0));
4787 /* Modifiers context reset moved up, so abstract method declaration
4788 modifiers can be later checked. */
4790 /* Set constructor returned type to void and method name to <init>,
4791 unless we found an error identifier the constructor (in which
4792 case we retain the original name) */
4795 type = void_type_node;
4797 meth_name = init_identifier_node;
4800 meth_name = EXPR_WFL_NODE (id);
4802 /* Do the returned type resolution and registration if necessary */
4803 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4806 type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4807 EXPR_WFL_NODE (id) = meth_name;
4808 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4812 patch_stage = JDEP_METHOD_RETURN;
4813 register_incomplete_type (patch_stage, type_wfl, id, type);
4814 TREE_TYPE (meth) = GET_REAL_TYPE (type);
4817 TREE_TYPE (meth) = type;
4819 saved_location = input_location;
4820 /* When defining an abstract or interface method, the curly
4821 bracket at level 1 doesn't exist because there is no function
4823 #ifdef USE_MAPPED_LOCATION
4824 input_location = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4825 EXPR_LOCATION (id));
4827 input_line = (ctxp->first_ccb_indent1 ? (int) ctxp->first_ccb_indent1 :
4828 EXPR_WFL_LINENO (id));
4831 /* Remember the original argument list */
4832 orig_arg = TYPE_ARG_TYPES (meth);
4834 if (patch_stage) /* includes ret type and/or all args */
4837 meth = add_method_1 (this_class, flags, meth_name, meth);
4838 /* Patch for the return type */
4839 if (patch_stage == JDEP_METHOD_RETURN)
4841 jdep = CLASSD_LAST (ctxp->classd_list);
4842 JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4844 /* This is the stop JDEP. METH allows the function's signature
4846 register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4849 meth = add_method (this_class, flags, meth_name,
4850 build_java_signature (meth));
4852 /* Remember final parameters */
4853 MARK_FINAL_PARMS (meth, orig_arg);
4855 /* Fix the method argument list so we have the argument name
4857 fix_method_argument_names (orig_arg, meth);
4859 /* Register the parameter number and re-install the current line
4861 DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4862 input_location = saved_location;
4864 /* Register exception specified by the `throws' keyword for
4865 resolution and set the method decl appropriate field to the list.
4866 Note: the grammar ensures that what we get here are class
4870 throws = nreverse (throws);
4871 for (current = throws; current; current = TREE_CHAIN (current))
4873 register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4874 NULL_TREE, NULL_TREE);
4875 JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4876 &TREE_VALUE (current);
4878 DECL_FUNCTION_THROWS (meth) = throws;
4881 if (TREE_TYPE (GET_CPC ()) != object_type_node)
4882 DECL_FUNCTION_WFL (meth) = id;
4884 /* Set the flag if we correctly processed a constructor */
4887 DECL_CONSTRUCTOR_P (meth) = 1;
4888 /* Compute and store the number of artificial parameters declared
4889 for this constructor */
4890 for (count = 0, current = TYPE_FIELDS (this_class); current;
4891 current = TREE_CHAIN (current))
4892 if (FIELD_LOCAL_ALIAS (current))
4894 DECL_FUNCTION_NAP (meth) = count;
4897 /* Eventually set the @deprecated tag flag */
4898 CHECK_DEPRECATED (meth);
4900 /* If doing xref, store column and line number information instead
4901 of the line number only. */
4904 #ifdef USE_MAPPED_LOCATION
4905 DECL_SOURCE_LOCATION (meth) = EXPR_LOCATION (id);
4907 DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4915 fix_method_argument_names (tree orig_arg, tree meth)
4917 tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4918 if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4920 TREE_PURPOSE (arg) = this_identifier_node;
4921 arg = TREE_CHAIN (arg);
4923 while (orig_arg != end_params_node)
4925 TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4926 orig_arg = TREE_CHAIN (orig_arg);
4927 arg = TREE_CHAIN (arg);
4931 /* Complete the method declaration with METHOD_BODY. */
4934 finish_method_declaration (tree method_body)
4938 if (!current_function_decl)
4941 flags = get_access_flags_from_decl (current_function_decl);
4943 /* 8.4.5 Method Body */
4944 if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4946 tree name = DECL_NAME (current_function_decl);
4947 parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4948 "%s method %qs can't have a body defined",
4949 (METHOD_NATIVE (current_function_decl) ?
4950 "Native" : "Abstract"),
4951 IDENTIFIER_POINTER (name));
4952 method_body = NULL_TREE;
4954 else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4956 tree name = DECL_NAME (current_function_decl);
4958 (DECL_FUNCTION_WFL (current_function_decl),
4959 "Non native and non abstract method %qs must have a body defined",
4960 IDENTIFIER_POINTER (name));
4961 method_body = NULL_TREE;
4964 if (flag_emit_class_files && method_body
4965 && TREE_CODE (method_body) == NOP_EXPR
4966 && TREE_TYPE (current_function_decl)
4967 && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4968 method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4970 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4971 maybe_absorb_scoping_blocks ();
4972 /* Exit function's body */
4974 /* Merge last line of the function with first line, directly in the
4975 function decl. It will be used to emit correct debug info. */
4976 if (!flag_emit_xref)
4977 DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4979 /* Since function's argument's list are shared, reset the
4980 ARG_FINAL_P parameter that might have been set on some of this
4981 function parameters. */
4982 UNMARK_FINAL_PARMS (current_function_decl);
4984 /* So we don't have an irrelevant function declaration context for
4985 the next static block we'll see. */
4986 current_function_decl = NULL_TREE;
4989 /* Build a an error message for constructor circularity errors. */
4992 constructor_circularity_msg (tree from, tree to)
4994 static char string [4096];
4995 char *t = xstrdup (lang_printable_name (from, 2));
4996 sprintf (string, "'%s' invokes '%s'", t, lang_printable_name (to, 2));
5001 /* Verify a circular call to METH. Return 1 if an error is found, 0
5004 static GTY(()) tree vcc_list;
5006 verify_constructor_circularity (tree meth, tree current)
5010 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
5012 if (TREE_VALUE (c) == meth)
5018 vcc_list = nreverse (vcc_list);
5019 for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
5022 (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
5023 constructor_circularity_msg
5024 (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
5028 t = xstrdup (lang_printable_name (meth, 2));
5029 parse_error_context (TREE_PURPOSE (c),
5030 "%s: recursive invocation of constructor %qs",
5031 constructor_circularity_msg (current, meth), t);
5033 vcc_list = NULL_TREE;
5037 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
5039 vcc_list = tree_cons (c, current, vcc_list);
5040 if (verify_constructor_circularity (meth, TREE_VALUE (c)))
5042 vcc_list = TREE_CHAIN (vcc_list);
5047 /* Check modifiers that can be declared but exclusively */
5050 check_modifiers_consistency (int flags)
5053 tree cl = NULL_TREE;
5055 THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
5056 THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
5057 THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
5060 (cl, "Inconsistent member declaration. At most one of %<public%>, %<private%>, or %<protected%> may be specified");
5064 THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
5065 THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
5067 parse_error_context (cl,
5068 "Inconsistent member declaration. At most one of %<final%> or %<volatile%> may be specified");
5071 /* Check the methode header METH for abstract specifics features */
5074 check_abstract_method_header (tree meth)
5076 int flags = get_access_flags_from_decl (meth);
5078 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
5079 ACC_ABSTRACT, "abstract method",
5080 IDENTIFIER_POINTER (DECL_NAME (meth)));
5081 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
5082 ACC_PUBLIC, "abstract method",
5083 IDENTIFIER_POINTER (DECL_NAME (meth)));
5085 check_modifiers ("Illegal modifier %qs for interface method",
5086 flags, INTERFACE_METHOD_MODIFIERS);
5089 /* Create a FUNCTION_TYPE node and start augmenting it with the
5090 declared function arguments. Arguments type that can't be resolved
5091 are left as they are, but the returned node is marked as containing
5092 incomplete types. */
5095 method_declarator (tree id, tree list)
5097 tree arg_types = NULL_TREE, current, node;
5098 tree meth = make_node (FUNCTION_TYPE);
5101 patch_stage = JDEP_NO_PATCH;
5103 if (GET_CPC () == error_mark_node)
5104 return error_mark_node;
5106 /* If we're dealing with an inner class constructor, we hide the
5107 this$<n> decl in the name field of its parameter declaration. We
5108 also might have to hide the outer context local alias
5109 initializers. Not done when the class is a toplevel class. */
5110 if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
5111 && EXPR_WFL_NODE (id) == GET_CPC_UN ())
5113 tree aliases_list, type, thisn;
5114 /* First the aliases, linked to the regular parameters */
5116 build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
5117 TREE_TYPE (GET_CPC ()),
5119 list = chainon (nreverse (aliases_list), list);
5122 type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
5123 thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
5124 list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
5128 for (current = list; current; current = TREE_CHAIN (current))
5131 tree wfl_name = TREE_PURPOSE (current);
5132 tree type = TREE_VALUE (current);
5133 tree name = EXPR_WFL_NODE (wfl_name);
5134 tree already, arg_node;
5135 tree type_wfl = NULL_TREE;
5138 /* Obtain a suitable type for resolution, if necessary */
5139 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
5141 /* Process NAME, as it may specify extra dimension(s) for it */
5142 type = build_array_from_name (type, type_wfl, name, &name);
5143 EXPR_WFL_NODE (wfl_name) = name;
5145 real_type = GET_REAL_TYPE (type);
5146 if (TREE_CODE (real_type) == RECORD_TYPE)
5148 real_type = promote_type (real_type);
5149 if (TREE_CODE (type) == TREE_LIST)
5150 TREE_PURPOSE (type) = real_type;
5153 /* Check redefinition */
5154 for (already = arg_types; already; already = TREE_CHAIN (already))
5155 if (TREE_PURPOSE (already) == name)
5158 (wfl_name, "Variable %qs is used more than once in the argument list of method %qs",
5159 IDENTIFIER_POINTER (name),
5160 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
5164 /* If we've an incomplete argument type, we know there is a location
5165 to patch when the type get resolved, later. */
5169 patch_stage = JDEP_METHOD;
5170 type = register_incomplete_type (patch_stage,
5171 type_wfl, wfl_name, type);
5172 jdep = CLASSD_LAST (ctxp->classd_list);
5173 JDEP_MISC (jdep) = id;
5176 /* The argument node: a name and a (possibly) incomplete type. */
5177 arg_node = build_tree_list (name, real_type);
5178 /* Remember arguments declared final. */
5179 ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5182 JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5183 TREE_CHAIN (arg_node) = arg_types;
5184 arg_types = arg_node;
5186 TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5187 node = build_tree_list (id, meth);
5192 unresolved_type_p (tree wfl, tree *returned)
5194 if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5198 tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5199 if (decl && current_class && (decl == TYPE_NAME (current_class)))
5200 *returned = TREE_TYPE (decl);
5201 else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5202 *returned = TREE_TYPE (GET_CPC ());
5204 *returned = NULL_TREE;
5213 /* From NAME, build a qualified identifier node using the
5214 qualification from the current package definition. */
5217 parser_qualified_classname (tree name)
5219 tree nested_class_name;
5221 if ((nested_class_name = maybe_make_nested_class_name (name)))
5222 return nested_class_name;
5225 return merge_qualified_name (ctxp->package, name);
5230 /* Called once the type a interface extends is resolved. Returns 0 if
5231 everything is OK. */
5234 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5236 tree super_type = TREE_TYPE (super_decl);
5238 /* Has to be an interface */
5239 if (!CLASS_INTERFACE (super_decl))
5242 (this_wfl, "%s %qs can't implement/extend %s %qs",
5243 (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5244 "Interface" : "Class"),
5245 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5246 (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5247 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5251 /* Check top-level interface access. Inner classes are subject to member
5252 access rules (6.6.1). */
5253 if (! INNER_CLASS_P (super_type)
5254 && check_pkg_class_access (DECL_NAME (super_decl),
5255 NULL_TREE, true, this_decl))
5258 SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5259 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5260 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5264 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5265 0 if everything is OK. */
5268 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5270 tree super_type = TREE_TYPE (super_decl);
5272 /* SUPER should be a CLASS (neither an array nor an interface) */
5273 if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5276 (wfl, "Class %qs can't subclass %s %qs",
5277 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5278 (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5279 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5283 if (CLASS_FINAL (TYPE_NAME (super_type)))
5285 parse_error_context (wfl, "Can't subclass final classes: %s",
5286 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5290 /* Check top-level class scope. Inner classes are subject to member access
5292 if (! INNER_CLASS_P (super_type)
5293 && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true, NULL_TREE)))
5296 SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5297 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5298 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5302 /* Create a new dependency list and link it (in a LIFO manner) to the
5303 CTXP list of type dependency list. */
5306 create_jdep_list (struct parser_ctxt *ctxp)
5308 jdeplist *new = xmalloc (sizeof (jdeplist));
5309 new->first = new->last = NULL;
5310 new->next = ctxp->classd_list;
5311 ctxp->classd_list = new;
5315 reverse_jdep_list (struct parser_ctxt *ctxp)
5317 jdeplist *prev = NULL, *current, *next;
5318 for (current = ctxp->classd_list; current; current = next)
5320 next = current->next;
5321 current->next = prev;
5327 /* Create a fake pointer based on the ID stored in
5328 TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5329 registered again. */
5332 obtain_incomplete_type (tree type_name)
5334 tree ptr = NULL_TREE, name;
5336 if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5337 name = EXPR_WFL_NODE (type_name);
5338 else if (INCOMPLETE_TYPE_P (type_name))
5339 name = TYPE_NAME (type_name);
5343 /* Workaround from build_pointer_type for incomplete types. */
5344 BUILD_PTR_FROM_NAME (ptr, name);
5345 TYPE_MODE (ptr) = ptr_mode;
5351 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5352 non NULL instead of computing a new fake type based on WFL. The new
5353 dependency is inserted in the current type dependency list, in FIFO
5357 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5359 jdep *new = xmalloc (sizeof (jdep));
5361 if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5362 ptr = obtain_incomplete_type (wfl);
5364 JDEP_KIND (new) = kind;
5365 JDEP_DECL (new) = decl;
5366 JDEP_TO_RESOLVE (new) = ptr;
5367 JDEP_WFL (new) = wfl;
5368 JDEP_CHAIN (new) = NULL;
5369 JDEP_MISC (new) = NULL_TREE;
5370 /* For some dependencies, set the enclosing class of the current
5371 class to be the enclosing context */
5372 if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS || kind == JDEP_SUPER)
5373 && GET_ENCLOSING_CPC ())
5374 JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5376 JDEP_ENCLOSING (new) = GET_CPC ();
5377 JDEP_GET_PATCH (new) = (tree *)NULL;
5379 JDEP_INSERT (ctxp->classd_list, new);
5384 /* This checks for circular references with innerclasses. We start
5385 from SOURCE and should never reach TARGET. Extended/implemented
5386 types in SOURCE have their enclosing context checked not to reach
5387 TARGET. When the last enclosing context of SOURCE is reached, its
5388 extended/implemented types are also checked not to reach TARGET.
5389 In case of error, WFL of the offending type is returned; NULL_TREE
5393 check_inner_circular_reference (tree source, tree target)
5399 for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (source), i, base_binfo); i++)
5403 /* We can end up with a NULL_TREE or an incomplete type here if
5404 we encountered previous type resolution errors. It's safe to
5405 simply ignore these cases. */
5406 su = BINFO_TYPE (base_binfo);
5407 if (INCOMPLETE_TYPE_P (su))
5410 if (inherits_from_p (su, target))
5411 return lookup_cl (TYPE_NAME (su));
5413 for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5415 /* An enclosing context shouldn't be TARGET */
5416 if (ctx == TYPE_NAME (target))
5417 return lookup_cl (TYPE_NAME (su));
5419 /* When we reach the enclosing last context, start a check
5420 on it, with the same target */
5421 if (! DECL_CONTEXT (ctx) &&
5422 (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5429 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5430 offending type if a circularity is detected. NULL_TREE is returned
5431 otherwise. TYPE can be an interface or a class. */
5434 check_circular_reference (tree type)
5439 if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
5442 if (! CLASS_INTERFACE (TYPE_NAME (type)))
5444 if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5445 return lookup_cl (TYPE_NAME (type));
5449 for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo); i++)
5451 if (BINFO_TYPE (base_binfo) != object_type_node
5452 && interface_of_p (type, BINFO_TYPE (base_binfo)))
5453 return lookup_cl (TYPE_NAME (BINFO_TYPE (base_binfo)));
5459 java_check_circular_reference (void)
5462 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5464 tree type = TREE_TYPE (current);
5467 cl = check_circular_reference (type);
5469 cl = check_inner_circular_reference (type, type);
5471 parse_error_context (cl, "Cyclic class inheritance%s",
5472 (cyclic_inheritance_report ?
5473 cyclic_inheritance_report : ""));
5477 /* Augment the parameter list PARM with parameters crafted to
5478 initialize outer context locals aliases. Through ARTIFICIAL, a
5479 count is kept of the number of crafted parameters. MODE governs
5480 what eventually gets created: something suitable for a function
5481 creation or a function invocation, either the constructor or
5485 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5489 tree additional_parms = NULL_TREE;
5491 for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5492 if (FIELD_LOCAL_ALIAS (field))
5494 const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5495 tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5500 case AIPL_FUNCTION_DECLARATION:
5501 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5503 purpose = build_wfl_node (mangled_id);
5504 if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5505 value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5507 value = TREE_TYPE (field);
5510 case AIPL_FUNCTION_CREATION:
5511 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5513 value = TREE_TYPE (field);
5516 case AIPL_FUNCTION_FINIT_INVOCATION:
5517 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5519 /* Now, this is wrong. purpose should always be the NAME
5520 of something and value its matching value (decl, type,
5521 etc...) FIXME -- but there is a lot to fix. */
5523 /* When invoked for this kind of operation, we already
5524 know whether a field is used or not. */
5525 purpose = TREE_TYPE (field);
5526 value = build_wfl_node (mangled_id);
5529 case AIPL_FUNCTION_CTOR_INVOCATION:
5530 /* There are two case: the constructor invocation happens
5531 outside the local inner, in which case, locales from the outer
5532 context are directly used.
5534 Otherwise, we fold to using the alias directly. */
5535 if (class_type == current_class)
5539 name = get_identifier (&buffer[4]);
5540 value = IDENTIFIER_LOCAL_VALUE (name);
5544 additional_parms = tree_cons (purpose, value, additional_parms);
5548 if (additional_parms)
5550 if (ANONYMOUS_CLASS_P (class_type)
5551 && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5552 additional_parms = nreverse (additional_parms);
5553 parm = chainon (additional_parms, parm);
5559 /* Craft a constructor for CLASS_DECL -- what we should do when none
5560 where found. ARGS is non NULL when a special signature must be
5561 enforced. This is the case for anonymous classes. */
5564 craft_constructor (tree class_decl, tree args)
5566 tree class_type = TREE_TYPE (class_decl);
5567 tree parm = NULL_TREE;
5568 /* Inherit access flags for the constructor from its enclosing class. */
5569 int valid_ctor_flags = ACC_PUBLIC | ACC_PROTECTED | ACC_PRIVATE;
5570 int flags = (get_access_flags_from_decl (class_decl) & valid_ctor_flags);
5571 int i = 0, artificial = 0;
5572 tree decl, ctor_name;
5575 ctor_name = init_identifier_node;
5577 /* If we're dealing with an inner class constructor, we hide the
5578 this$<n> decl in the name field of its parameter declaration. */
5579 if (PURE_INNER_CLASS_TYPE_P (class_type))
5581 tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5582 parm = tree_cons (build_current_thisn (class_type),
5583 build_pointer_type (type), parm);
5585 /* Some more arguments to be hidden here. The values of the local
5586 variables of the outer context that the inner class needs to see. */
5587 parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5592 /* Then if there are any args to be enforced, enforce them now */
5593 for (; args && args != end_params_node; args = TREE_CHAIN (args))
5595 sprintf (buffer, "parm%d", i++);
5596 parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5599 CRAFTED_PARAM_LIST_FIXUP (parm);
5600 decl = create_artificial_method (class_type, flags, void_type_node,
5602 fix_method_argument_names (parm, decl);
5603 /* Now, mark the artificial parameters. */
5604 DECL_FUNCTION_NAP (decl) = artificial;
5605 DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5606 DECL_INLINE (decl) = 1;
5611 /* Fix the constructors. This will be called right after circular
5612 references have been checked. It is necessary to fix constructors
5613 early even if no code generation will take place for that class:
5614 some generated constructor might be required by the class whose
5615 compilation triggered this one to be simply loaded. */
5618 java_fix_constructors (void)
5622 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5624 tree class_type = TREE_TYPE (current);
5628 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5631 output_class = current_class = class_type;
5632 for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5634 if (DECL_CONSTRUCTOR_P (decl))
5636 fix_constructors (decl);
5641 /* Anonymous class constructor can't be generated that early. */
5642 if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5643 craft_constructor (current, NULL_TREE);
5647 /* safe_layout_class just makes sure that we can load a class without
5648 disrupting the current_class, input_file, input_line, etc, information
5649 about the class processed currently. */
5652 safe_layout_class (tree class)
5654 tree save_current_class = current_class;
5655 location_t save_location = input_location;
5657 layout_class (class);
5659 current_class = save_current_class;
5660 input_location = save_location;
5664 jdep_resolve_class (jdep *dep)
5668 if (JDEP_RESOLVED_P (dep))
5669 decl = JDEP_RESOLVED_DECL (dep);
5672 decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5673 JDEP_DECL (dep), JDEP_WFL (dep));
5674 JDEP_RESOLVED (dep, decl);
5675 /* If there is no WFL, that's ok. We generate this warning
5677 if (decl && JDEP_WFL (dep) != NULL_TREE)
5678 check_deprecation (JDEP_WFL (dep), decl);
5682 complete_class_report_errors (dep);
5683 else if (INNER_CLASS_DECL_P (decl))
5685 tree inner = TREE_TYPE (decl);
5686 if (! CLASS_LOADED_P (inner))
5688 safe_layout_class (inner);
5689 if (TYPE_SIZE (inner) == error_mark_node)
5690 TYPE_SIZE (inner) = NULL_TREE;
5692 check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5697 /* Complete unsatisfied class declaration and their dependencies */
5700 java_complete_class (void)
5707 /* Process imports */
5710 /* Reverse things so we have the right order */
5711 ctxp->class_list = nreverse (ctxp->class_list);
5712 ctxp->classd_list = reverse_jdep_list (ctxp);
5714 for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5716 cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5720 /* We keep the compilation unit imports in the class so that
5721 they can be used later to resolve type dependencies that
5722 aren't necessary to solve now. */
5723 TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5724 TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5726 for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5729 if (!(decl = jdep_resolve_class (dep)))
5732 /* Now it's time to patch */
5733 switch (JDEP_KIND (dep))
5736 /* Simply patch super */
5737 if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5739 BINFO_TYPE (BINFO_BASE_BINFO
5740 (TYPE_BINFO (TREE_TYPE (JDEP_DECL (dep))), 0))
5746 /* We do part of the job done in add_field */
5747 tree field_decl = JDEP_DECL (dep);
5748 tree field_type = TREE_TYPE (decl);
5749 if (TREE_CODE (field_type) == RECORD_TYPE)
5750 field_type = promote_type (field_type);
5751 TREE_TYPE (field_decl) = field_type;
5752 DECL_ALIGN (field_decl) = 0;
5753 DECL_USER_ALIGN (field_decl) = 0;
5754 layout_decl (field_decl, 0);
5755 SOURCE_FRONTEND_DEBUG
5756 (("Completed field/var decl '%s' with '%s'",
5757 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5758 IDENTIFIER_POINTER (DECL_NAME (decl))));
5761 case JDEP_METHOD: /* We start patching a method */
5762 case JDEP_METHOD_RETURN:
5768 type = TREE_TYPE(decl);
5769 if (TREE_CODE (type) == RECORD_TYPE)
5770 type = promote_type (type);
5771 JDEP_APPLY_PATCH (dep, type);
5772 SOURCE_FRONTEND_DEBUG
5773 (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5774 "Completing fct '%s' with ret type '%s'":
5775 "Completing arg '%s' with type '%s'"),
5776 IDENTIFIER_POINTER (EXPR_WFL_NODE
5777 (JDEP_DECL_WFL (dep))),
5778 IDENTIFIER_POINTER (DECL_NAME (decl))));
5782 dep = JDEP_CHAIN (dep);
5783 if (JDEP_KIND (dep) == JDEP_METHOD_END)
5786 decl = jdep_resolve_class (dep);
5790 tree mdecl = JDEP_DECL (dep), signature;
5791 /* Recompute and reset the signature, check first that
5792 all types are now defined. If they're not,
5793 don't build the signature. */
5794 if (check_method_types_complete (mdecl))
5796 signature = build_java_signature (TREE_TYPE (mdecl));
5797 set_java_signature (TREE_TYPE (mdecl), signature);
5804 case JDEP_INTERFACE:
5805 if (parser_check_super_interface (decl, JDEP_DECL (dep),
5808 parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5813 type = TREE_TYPE(decl);
5814 if (TREE_CODE (type) == RECORD_TYPE)
5815 type = promote_type (type);
5816 JDEP_APPLY_PATCH (dep, type);
5820 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5821 SOURCE_FRONTEND_DEBUG
5822 (("Completing a random type dependency on a '%s' node",
5823 tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5826 case JDEP_EXCEPTION:
5827 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5828 SOURCE_FRONTEND_DEBUG
5829 (("Completing '%s' 'throws' argument node",
5830 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5833 case JDEP_ANONYMOUS:
5834 patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5845 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5849 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5851 tree tname = TYPE_NAME (class_type);
5852 tree resolved_type = TREE_TYPE (class_type);
5854 tree resolved_type_decl;
5856 if (resolved_type != NULL_TREE)
5858 tree resolved_type_decl = TYPE_NAME (resolved_type);
5859 if (resolved_type_decl == NULL_TREE
5860 || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5862 resolved_type_decl = build_decl (TYPE_DECL,
5863 TYPE_NAME (class_type),
5866 return resolved_type_decl;
5869 /* 1- Check to see if we have an array. If true, find what we really
5871 if ((array_dims = build_type_name_from_array_name (tname,
5872 &TYPE_NAME (class_type))))
5873 WFL_STRIP_BRACKET (cl, cl);
5875 /* 2- Resolve the bare type */
5876 if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5879 resolved_type = TREE_TYPE (resolved_type_decl);
5881 /* 3- If we have an array, reconstruct the array down to its nesting */
5884 for (; array_dims; array_dims--)
5885 resolved_type = build_java_array_type (resolved_type, -1);
5886 resolved_type_decl = TYPE_NAME (resolved_type);
5888 TREE_TYPE (class_type) = resolved_type;
5889 return resolved_type_decl;
5892 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5893 are used to report error messages; CL must either be NULL_TREE or a
5894 WFL wrapping a class. Do not try to replace TYPE_NAME (class_type)
5895 by a variable, since it is changed by find_in_imports{_on_demand}
5896 and (but it doesn't really matter) qualify_and_find. */
5899 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5901 tree new_class_decl = NULL_TREE, super = NULL_TREE;
5902 tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5904 htab_t circularity_hash;
5906 if (QUALIFIED_P (TYPE_NAME (class_type)))
5908 /* If the type name is of the form `Q . Id', then Q is either a
5909 package name or a class name. First we try to find Q as a
5910 class and then treat Id as a member type. If we can't find Q
5911 as a class then we fall through. */
5912 tree q, left, left_type, right;
5913 if (split_qualified_name (&left, &right, TYPE_NAME (class_type)) == 0)
5915 BUILD_PTR_FROM_NAME (left_type, left);
5916 q = do_resolve_class (enclosing, left_type, decl, cl);
5920 saved_enclosing_type = TREE_TYPE (q);
5921 BUILD_PTR_FROM_NAME (class_type, right);
5928 /* This hash table is used to register the classes we're going
5929 through when searching the current class as an inner class, in
5930 order to detect circular references. Remember to free it before
5931 returning the section 0- of this function. */
5932 circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5935 /* 0- Search in the current class as an inner class.
5936 Maybe some code here should be added to load the class or
5937 something, at least if the class isn't an inner class and ended
5938 being loaded from class file. FIXME. */
5941 new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5942 &super, class_type);
5946 /* If we haven't found anything because SUPER reached Object and
5947 ENCLOSING happens to be an innerclass, try the enclosing context. */
5948 if ((!super || super == object_type_node) &&
5949 enclosing && INNER_CLASS_DECL_P (enclosing))
5950 enclosing = DECL_CONTEXT (enclosing);
5952 enclosing = NULL_TREE;
5955 htab_delete (circularity_hash);
5958 return new_class_decl;
5961 /* 1- Check for the type in single imports. This will change
5962 TYPE_NAME() if something relevant is found */
5963 find_in_imports (saved_enclosing_type, class_type);
5965 /* 2- And check for the type in the current compilation unit */
5966 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5968 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5969 load_class (TYPE_NAME (class_type), 0);
5970 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5973 /* 3- Search according to the current package definition */
5974 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5976 if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5977 TYPE_NAME (class_type))))
5978 return new_class_decl;
5981 /* 4- Check the import on demands. Don't allow bar.baz to be
5982 imported from foo.* */
5983 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5984 if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5987 /* If found in find_in_imports_on_demand, the type has already been
5989 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5990 return new_class_decl;
5992 /* 5- Try with a name qualified with the package name we've seen so far */
5993 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5997 /* If there is a current package (ctxp->package), it's the first
5998 element of package_list and we can skip it. */
5999 for (package = (ctxp->package ?
6000 TREE_CHAIN (package_list) : package_list);
6001 package; package = TREE_CHAIN (package))
6002 if ((new_class_decl = qualify_and_find (class_type,
6003 TREE_PURPOSE (package),
6004 TYPE_NAME (class_type))))
6005 return new_class_decl;
6008 /* 5- Check another compilation unit that bears the name of type */
6009 load_class (TYPE_NAME (class_type), 0);
6012 cl = lookup_cl (decl);
6014 /* If we don't have a value for CL, then we're being called recursively.
6015 We can't check package access just yet, but it will be taken care of
6019 if (check_pkg_class_access (TYPE_NAME (class_type), cl, true, NULL_TREE))
6023 /* 6- Last call for a resolution */
6024 decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
6026 /* The final lookup might have registered a.b.c into a.b$c If we
6027 failed at the first lookup, progressively change the name if
6028 applicable and use the matching DECL instead. */
6029 if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
6032 tree name = TYPE_NAME (class_type);
6033 char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
6035 strcpy (namebuffer, IDENTIFIER_POINTER (name));
6039 /* Reach the last '.', and if applicable, replace it by a `$' and
6040 see if this exists as a type. */
6041 if ((separator = strrchr (namebuffer, '.')))
6044 name = get_identifier (namebuffer);
6045 decl_result = IDENTIFIER_CLASS_VALUE (name);
6047 } while (!decl_result && separator);
6053 qualify_and_find (tree class_type, tree package, tree name)
6055 tree new_qualified = merge_qualified_name (package, name);
6056 tree new_class_decl;
6058 if (!IDENTIFIER_CLASS_VALUE (new_qualified))
6059 load_class (new_qualified, 0);
6060 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
6062 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
6063 load_class (TREE_TYPE (new_class_decl), 0);
6064 TYPE_NAME (class_type) = new_qualified;
6065 return IDENTIFIER_CLASS_VALUE (new_qualified);
6070 /* Resolve NAME and lay it out (if not done and if not the current
6071 parsed class). Return a decl node. This function is meant to be
6072 called when type resolution is necessary during the walk pass. */
6075 resolve_and_layout (tree something, tree cl)
6077 tree decl, decl_type;
6079 /* Don't do that on the current class */
6080 if (something == current_class)
6081 return TYPE_NAME (current_class);
6083 /* Don't do anything for void and other primitive types */
6084 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
6087 /* Pointer types can be reall pointer types or fake pointers. When
6088 finding a real pointer, recheck for primitive types */
6089 if (TREE_CODE (something) == POINTER_TYPE)
6091 if (TREE_TYPE (something))
6093 something = TREE_TYPE (something);
6094 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
6098 something = TYPE_NAME (something);
6101 /* Don't do anything for arrays of primitive types */
6102 if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
6103 && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
6106 /* Something might be a WFL */
6107 if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
6108 something = EXPR_WFL_NODE (something);
6110 /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
6111 TYPE_DECL or a real TYPE */
6112 else if (TREE_CODE (something) != IDENTIFIER_NODE)
6113 something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
6114 DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
6116 if (!(decl = resolve_no_layout (something, cl)))
6119 /* Resolve and layout if necessary */
6120 decl_type = TREE_TYPE (decl);
6121 layout_class_methods (decl_type);
6123 if (CLASS_FROM_SOURCE_P (decl_type))
6124 java_check_methods (decl);
6125 /* Layout the type if necessary */
6126 if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
6127 safe_layout_class (decl_type);
6132 /* Resolve a class, returns its decl but doesn't perform any
6133 layout. The current parsing context is saved and restored */
6136 resolve_no_layout (tree name, tree cl)
6139 BUILD_PTR_FROM_NAME (ptr, name);
6140 java_parser_context_save_global ();
6141 decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
6142 java_parser_context_restore_global ();
6147 /* Called when reporting errors. Skip the '[]'s in a complex array
6148 type description that failed to be resolved. purify_type_name can't
6149 use an identifier tree. */
6152 purify_type_name (const char *name)
6154 int len = strlen (name);
6157 STRING_STRIP_BRACKETS (name, len, bracket_found);
6160 char *stripped_name = xmemdup (name, len, len+1);
6161 stripped_name [len] = '\0';
6162 return stripped_name;
6167 /* The type CURRENT refers to can't be found. We print error messages. */
6170 complete_class_report_errors (jdep *dep)
6174 if (!JDEP_WFL (dep))
6177 name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6178 switch (JDEP_KIND (dep))
6182 (JDEP_WFL (dep), "Superclass %qs of class %qs not found",
6183 purify_type_name (name),
6184 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6188 (JDEP_WFL (dep), "Type %qs not found in declaration of field %qs",
6189 purify_type_name (name),
6190 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6192 case JDEP_METHOD: /* Covers arguments */
6194 (JDEP_WFL (dep), "Type %qs not found in the declaration of the argument %qs of method %qs",
6195 purify_type_name (name),
6196 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6197 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6199 case JDEP_METHOD_RETURN: /* Covers return type */
6201 (JDEP_WFL (dep), "Type %qs not found in the declaration of the return type of method %qs",
6202 purify_type_name (name),
6203 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6205 case JDEP_INTERFACE:
6207 (JDEP_WFL (dep), "Superinterface %qs of %s %qs not found",
6208 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6209 (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6210 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6214 (JDEP_WFL (dep), "Type %qs not found in the declaration of the local variable %qs",
6215 purify_type_name (IDENTIFIER_POINTER
6216 (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6217 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6219 case JDEP_EXCEPTION: /* As specified by `throws' */
6221 (JDEP_WFL (dep), "Class %qs not found in %<throws%>",
6222 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6225 /* Fix for -Wall. Just break doing nothing. The error will be
6231 /* Return a static string containing the DECL prototype string. If
6232 DECL is a constructor, use the class name instead of the form
6236 get_printable_method_name (tree decl)
6238 const char *to_return;
6239 tree name = NULL_TREE;
6241 if (DECL_CONSTRUCTOR_P (decl))
6243 name = DECL_NAME (decl);
6244 DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6247 to_return = lang_printable_name (decl, 2);
6248 if (DECL_CONSTRUCTOR_P (decl))
6249 DECL_NAME (decl) = name;
6254 /* Track method being redefined inside the same class. As a side
6255 effect, set DECL_NAME to an IDENTIFIER (prior entering this
6256 function it's a FWL, so we can track errors more accurately.) */
6259 check_method_redefinition (tree class, tree method)
6263 /* There's no need to verify <clinit> and finit$ and instinit$ */
6264 if (DECL_CLINIT_P (method)
6265 || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6268 sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6269 for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6271 if (redef == method)
6273 if (DECL_NAME (redef) == DECL_NAME (method)
6274 && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6275 && !DECL_ARTIFICIAL (method))
6278 (DECL_FUNCTION_WFL (method), "Duplicate %s declaration %qs",
6279 (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6280 get_printable_method_name (redef));
6287 /* Return 1 if check went ok, 0 otherwise. */
6289 check_abstract_method_definitions (int do_interface, tree class_decl,
6292 tree class = TREE_TYPE (class_decl);
6293 tree method, end_type;
6296 end_type = (do_interface ? object_type_node : type);
6297 for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6299 tree other_super, other_method, method_sig, method_name;
6301 int end_type_reached = 0;
6303 if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6306 /* Now verify that somewhere in between TYPE and CLASS,
6307 abstract method METHOD gets a non abstract definition
6308 that is inherited by CLASS. */
6310 method_sig = build_java_signature (TREE_TYPE (method));
6311 method_name = DECL_NAME (method);
6312 if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6313 method_name = EXPR_WFL_NODE (method_name);
6315 other_super = class;
6317 if (other_super == end_type)
6318 end_type_reached = 1;
6321 for (other_method = TYPE_METHODS (other_super); other_method;
6322 other_method = TREE_CHAIN (other_method))
6324 tree s = build_java_signature (TREE_TYPE (other_method));
6325 tree other_name = DECL_NAME (other_method);
6327 if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6328 other_name = EXPR_WFL_NODE (other_name);
6329 if (!DECL_CLINIT_P (other_method)
6330 && !DECL_CONSTRUCTOR_P (other_method)
6331 && method_name == other_name
6333 && !METHOD_ABSTRACT (other_method))
6339 other_super = CLASSTYPE_SUPER (other_super);
6340 } while (!end_type_reached);
6342 /* Report that abstract METHOD didn't find an implementation
6343 that CLASS can use. */
6346 char *t = xstrdup (lang_printable_name
6347 (TREE_TYPE (TREE_TYPE (method)), 0));
6348 tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6351 (lookup_cl (class_decl),
6352 "Class %qs doesn't define the abstract method %<%s %s%> from %s %<%s%>. This method must be defined or %s %qs must be declared abstract",
6353 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6354 t, lang_printable_name (method, 2),
6355 (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6356 "interface" : "class"),
6357 IDENTIFIER_POINTER (ccn),
6358 (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6359 IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6365 if (ok && do_interface)
6367 /* Check for implemented interfaces. */
6372 ok && BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo);
6374 ok = check_abstract_method_definitions (1, class_decl,
6375 BINFO_TYPE (base_binfo));
6381 /* Check that CLASS_DECL somehow implements all inherited abstract
6385 java_check_abstract_method_definitions (tree class_decl)
6387 tree class = TREE_TYPE (class_decl);
6388 tree super, base_binfo;
6391 if (CLASS_ABSTRACT (class_decl))
6394 /* Check for inherited types */
6397 super = CLASSTYPE_SUPER (super);
6398 check_abstract_method_definitions (0, class_decl, super);
6399 } while (super != object_type_node);
6401 /* Check for implemented interfaces. */
6402 for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6403 check_abstract_method_definitions (1, class_decl, BINFO_TYPE (base_binfo));
6406 /* Check all the types method DECL uses and return 1 if all of them
6407 are now complete, 0 otherwise. This is used to check whether its
6408 safe to build a method signature or not. */
6411 check_method_types_complete (tree decl)
6413 tree type = TREE_TYPE (decl);
6416 if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6419 args = TYPE_ARG_TYPES (type);
6420 if (TREE_CODE (type) == METHOD_TYPE)
6421 args = TREE_CHAIN (args);
6422 for (; args != end_params_node; args = TREE_CHAIN (args))
6423 if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6429 /* Visible interface to check methods contained in CLASS_DECL */
6432 java_check_methods (tree class_decl)
6434 if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6437 if (CLASS_INTERFACE (class_decl))
6438 java_check_abstract_methods (class_decl);
6440 java_check_regular_methods (class_decl);
6442 CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6445 /* Like not_accessible_p, but doesn't refer to the current class at
6448 hack_is_accessible_p (tree member, tree from_where)
6450 int flags = get_access_flags_from_decl (member);
6452 if (from_where == DECL_CONTEXT (member)
6453 || (flags & ACC_PUBLIC))
6456 if ((flags & ACC_PROTECTED))
6458 if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6462 if ((flags & ACC_PRIVATE))
6465 /* Package private, or protected. */
6466 return in_same_package (TYPE_NAME (from_where),
6467 TYPE_NAME (DECL_CONTEXT (member)));
6470 /* Check all the methods of CLASS_DECL. Methods are first completed
6471 then checked according to regular method existence rules. If no
6472 constructor for CLASS_DECL were encountered, then build its
6475 java_check_regular_methods (tree class_decl)
6477 int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6479 tree class = TREE_TYPE (class_decl);
6480 tree found = NULL_TREE;
6483 /* It is not necessary to check methods defined in java.lang.Object */
6484 if (class == object_type_node)
6487 if (!TYPE_NVIRTUALS (class))
6488 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6490 /* Should take interfaces into account. FIXME */
6491 for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6494 tree method_wfl = DECL_FUNCTION_WFL (method);
6497 /* Check for redefinitions */
6498 if (check_method_redefinition (class, method))
6501 /* We verify things thrown by the method. They must inherit from
6502 java.lang.Throwable. */
6503 for (mthrows = DECL_FUNCTION_THROWS (method);
6504 mthrows; mthrows = TREE_CHAIN (mthrows))
6506 if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6508 (TREE_PURPOSE (mthrows), "Class %qs in %<throws%> clause must be a subclass of class %<java.lang.Throwable%>",
6510 (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6513 /* If we see one constructor a mark so we don't generate the
6514 default one. Also skip other verifications: constructors
6515 can't be inherited hence hidden or overridden. */
6516 if (DECL_CONSTRUCTOR_P (method))
6518 saw_constructor = 1;
6522 sig = build_java_argument_signature (TREE_TYPE (method));
6523 found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6524 SEARCH_SUPER | SEARCH_INTERFACE);
6526 /* Inner class can't declare static methods */
6527 if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6529 char *t = xstrdup (lang_printable_name (class, 0));
6531 (method_wfl, "Method %qs can't be static in inner class %qs. Only members of interfaces and top-level classes can be static",
6532 lang_printable_name (method, 2), t);
6536 /* Nothing overrides or it's a private method. */
6539 if (METHOD_PRIVATE (found))
6545 /* If `found' is declared in an interface, make sure the
6546 modifier matches. */
6547 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6548 && clinit_identifier_node != DECL_NAME (found)
6549 && !METHOD_PUBLIC (method))
6551 tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6552 parse_error_context (method_wfl, "Class %qs must override %qs with a public method in order to implement interface %qs",
6553 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6554 lang_printable_name (method, 2),
6555 IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6558 /* Can't override a method with the same name and different return
6560 if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6563 (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6566 "Method %qs was defined with return type %qs in class %qs",
6567 lang_printable_name (found, 2), t,
6569 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6573 aflags = get_access_flags_from_decl (found);
6575 /* Can't override final. Can't override static. */
6576 if (METHOD_FINAL (found) || METHOD_STATIC (found))
6578 /* Static *can* override static */
6579 if (METHOD_STATIC (found) && METHOD_STATIC (method))
6583 "%s methods can't be overridden. Method %qs is %s in class %qs",
6584 (METHOD_FINAL (found) ? "Final" : "Static"),
6585 lang_printable_name (found, 2),
6586 (METHOD_FINAL (found) ? "final" : "static"),
6588 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6592 /* Static method can't override instance method. */
6593 if (METHOD_STATIC (method))
6597 "Instance methods can't be overridden by a static method. Method %qs is an instance method in class %qs",
6598 lang_printable_name (found, 2),
6600 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6604 /* - Overriding/hiding public must be public
6605 - Overriding/hiding protected must be protected or public
6606 - If the overridden or hidden method has default (package)
6607 access, then the overriding or hiding method must not be
6608 private; otherwise, a compile-time error occurs. If
6609 `found' belongs to an interface, things have been already
6611 if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6612 && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6613 || (METHOD_PROTECTED (found)
6614 && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6615 || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6616 && METHOD_PRIVATE (method))))
6620 "Methods can't be overridden to be more private. Method %qs is not %s in class %qs", lang_printable_name (method, 2),
6621 (METHOD_PUBLIC (method) ? "public" :
6622 (METHOD_PRIVATE (method) ? "private" : "protected")),
6623 IDENTIFIER_POINTER (DECL_NAME
6624 (TYPE_NAME (DECL_CONTEXT (found)))));
6628 /* Check this method against all the other implementations it
6629 overrides. Here we only check the class hierarchy; the rest
6630 of the checking is done later. If this method is just a
6631 Miranda method, we can skip the check. */
6632 if (! METHOD_INVISIBLE (method))
6633 check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6636 /* The above throws clause check only looked at superclasses. Now
6637 we must also make sure that all methods declared in interfaces
6638 have compatible throws clauses. FIXME: there are more efficient
6639 ways to organize this checking; we should implement one. */
6640 check_interface_throws_clauses (class, class);
6642 if (!TYPE_NVIRTUALS (class))
6643 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6645 /* Search for inherited abstract method not yet implemented in this
6647 java_check_abstract_method_definitions (class_decl);
6649 if (!saw_constructor)
6653 /* Check to make sure that all the methods in all the interfaces
6654 implemented by CLASS_DECL are compatible with the concrete
6655 implementations available in CHECK_CLASS_DECL. */
6657 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6659 for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6663 if (! CLASS_LOADED_P (class_decl))
6665 if (CLASS_FROM_SOURCE_P (class_decl))
6666 safe_layout_class (class_decl);
6668 load_class (class_decl, 1);
6671 for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (class_decl)) - 1; i > 0; --i)
6674 = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (class_decl), i));
6677 for (iface_method = TYPE_METHODS (interface);
6678 iface_method != NULL_TREE;
6679 iface_method = TREE_CHAIN (iface_method))
6683 /* First look for a concrete method implemented or
6684 inherited by this class. No need to search
6685 interfaces here, since we're already looking through
6687 sig = build_java_argument_signature (TREE_TYPE (iface_method));
6689 = lookup_argument_method_generic (check_class_decl,
6690 DECL_NAME (iface_method),
6691 sig, SEARCH_VISIBLE);
6692 /* If we don't find an implementation, that is ok. Any
6693 potential errors from that are diagnosed elsewhere.
6694 Also, multiple inheritance with conflicting throws
6695 clauses is fine in the absence of a concrete
6697 if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6698 && !METHOD_INVISIBLE (iface_method))
6700 tree method_wfl = DECL_FUNCTION_WFL (method);
6701 check_throws_clauses (method, method_wfl, iface_method);
6705 /* Now check superinterfaces. */
6706 check_interface_throws_clauses (check_class_decl, interface);
6711 /* Check throws clauses of a method against the clauses of all the
6712 methods it overrides. We do this by searching up the class
6713 hierarchy, examining all matching accessible methods. */
6715 check_concrete_throws_clauses (tree class, tree self_method,
6716 tree name, tree signature)
6718 tree method = lookup_argument_method_generic (class, name, signature,
6719 SEARCH_SUPER | SEARCH_VISIBLE);
6720 while (method != NULL_TREE)
6722 if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6723 check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6726 method = lookup_argument_method_generic (DECL_CONTEXT (method),
6728 SEARCH_SUPER | SEARCH_VISIBLE);
6732 /* Generate an error if the `throws' clause of METHOD (if any) is
6733 incompatible with the `throws' clause of FOUND (if any). */
6735 check_throws_clauses (tree method, tree method_wfl, tree found)
6739 /* Can't check these things with class loaded from bytecode. FIXME */
6740 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6743 for (mthrows = DECL_FUNCTION_THROWS (method);
6744 mthrows; mthrows = TREE_CHAIN (mthrows))
6748 /* We don't verify unchecked expressions */
6749 if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6751 /* Checked expression must be compatible */
6752 for (fthrows = DECL_FUNCTION_THROWS (found);
6753 fthrows; fthrows = TREE_CHAIN (fthrows))
6755 if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6761 (method_wfl, "Invalid checked exception class %qs in %<throws%> clause. The exception must be a subclass of an exception thrown by %qs from class %qs",
6762 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6763 lang_printable_name (found, 2),
6765 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6770 /* Check abstract method of interface INTERFACE */
6772 java_check_abstract_methods (tree interface_decl)
6776 tree interface = TREE_TYPE (interface_decl);
6779 for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6781 /* 2- Check for double definition inside the defining interface */
6782 if (check_method_redefinition (interface, method))
6785 /* 3- Overriding is OK as far as we preserve the return type. */
6786 found = lookup_java_interface_method2 (interface, method);
6790 t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6792 (DECL_FUNCTION_WFL (found),
6793 "Method %qs was defined with return type %qs in class %qs",
6794 lang_printable_name (found, 2), t,
6796 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6802 /* 4- Inherited methods can't differ by their returned types */
6803 for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (interface), i, base_binfo); i++)
6805 tree sub_interface_method, sub_interface;
6807 sub_interface = BINFO_TYPE (base_binfo);
6808 for (sub_interface_method = TYPE_METHODS (sub_interface);
6809 sub_interface_method;
6810 sub_interface_method = TREE_CHAIN (sub_interface_method))
6812 found = lookup_java_interface_method2 (interface,
6813 sub_interface_method);
6814 if (found && (found != sub_interface_method))
6817 (lookup_cl (sub_interface_method),
6818 "Interface %qs inherits method %qs from interface %qs. This method is redefined with a different return type in interface %qs",
6819 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6820 lang_printable_name (found, 2),
6822 (DECL_NAME (TYPE_NAME
6823 (DECL_CONTEXT (sub_interface_method)))),
6825 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6831 /* Lookup methods in interfaces using their name and partial
6832 signature. Return a matching method only if their types differ. */
6835 lookup_java_interface_method2 (tree class, tree method_decl)
6841 for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6843 if ((BINFO_TYPE (base_binfo) != object_type_node)
6845 lookup_java_method2 (BINFO_TYPE (base_binfo), method_decl, 1)))
6848 for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6850 to_return = lookup_java_interface_method2
6851 (BINFO_TYPE (base_binfo), method_decl);
6859 /* Lookup method using their name and partial signature. Return a
6860 matching method only if their types differ. */
6863 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6865 tree method, method_signature, method_name, method_type, name;
6867 method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6868 name = DECL_NAME (method_decl);
6869 method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6870 EXPR_WFL_NODE (name) : name);
6871 method_type = TREE_TYPE (TREE_TYPE (method_decl));
6873 while (clas != NULL_TREE)
6875 for (method = TYPE_METHODS (clas);
6876 method != NULL_TREE; method = TREE_CHAIN (method))
6878 tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6879 tree name = DECL_NAME (method);
6880 if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6881 EXPR_WFL_NODE (name) : name) == method_name
6882 && method_sig == method_signature
6883 && TREE_TYPE (TREE_TYPE (method)) != method_type)
6886 clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6891 /* Return the line that matches DECL line number, and try its best to
6892 position the column number. Used during error reports.
6893 FUTURE/FIXME: return source_location instead of node. */
6895 static GTY(()) tree cl_v;
6897 lookup_cl (tree decl)
6899 #ifndef USE_MAPPED_LOCATION
6906 if (cl_v == NULL_TREE)
6908 cl_v = build_unknown_wfl (NULL_TREE);
6911 #ifdef USE_MAPPED_LOCATION
6912 SET_EXPR_LOCATION (cl_v, DECL_SOURCE_LOCATION (decl));
6914 EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6915 EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6917 line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6918 EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6920 found = strstr ((const char *)line,
6921 (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6923 EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6929 /* Look for a simple name in the single-type import list */
6932 find_name_in_single_imports (tree name)
6936 for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6937 if (TREE_VALUE (node) == name)
6938 return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6943 /* Process all single-type import. */
6946 process_imports (void)
6951 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6953 tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6954 char *original_name;
6956 original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6957 IDENTIFIER_LENGTH (to_be_found),
6958 IDENTIFIER_LENGTH (to_be_found) + 1);
6960 /* Don't load twice something already defined. */
6961 if (IDENTIFIER_CLASS_VALUE (to_be_found))
6968 QUALIFIED_P (to_be_found) = 1;
6969 load_class (to_be_found, 0);
6971 check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true, NULL_TREE);
6973 /* We found it, we can bail out */
6974 if (IDENTIFIER_CLASS_VALUE (to_be_found))
6976 check_deprecation (TREE_PURPOSE (import),
6977 IDENTIFIER_CLASS_VALUE (to_be_found));
6981 /* We haven't found it. Maybe we're trying to access an
6982 inner class. The only way for us to know is to try again
6983 after having dropped a qualifier. If we can't break it further,
6984 we have an error. */
6985 if (split_qualified_name (&left, NULL, to_be_found))
6990 if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6992 parse_error_context (TREE_PURPOSE (import),
6993 "Class or interface %qs not found in import",
6998 free (original_name);
7005 /* Possibly find and mark a class imported by a single-type import
7009 find_in_imports (tree enclosing_type, tree class_type)
7011 tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
7015 if (TREE_VALUE (import) == TYPE_NAME (class_type))
7017 TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
7018 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
7021 import = TREE_CHAIN (import);
7026 note_possible_classname (const char *name, int len)
7029 if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
7031 else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
7035 node = ident_subst (name, len, "", '/', '.', "");
7036 IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
7037 QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
7041 /* Read a import directory, gathering potential match for further type
7042 references. Indifferently reads a filesystem or a ZIP archive
7046 read_import_dir (tree wfl)
7048 tree package_id = EXPR_WFL_NODE (wfl);
7049 const char *package_name = IDENTIFIER_POINTER (package_id);
7050 int package_length = IDENTIFIER_LENGTH (package_id);
7052 JCF *saved_jcf = current_jcf;
7057 struct buffer filename[1];
7059 if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
7061 IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
7063 BUFFER_INIT (filename);
7064 buffer_grow (filename, package_length + 100);
7066 for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
7068 const char *entry_name = jcf_path_name (entry);
7069 int entry_length = strlen (entry_name);
7070 if (jcf_path_is_zipfile (entry))
7073 buffer_grow (filename, entry_length);
7074 memcpy (filename->data, entry_name, entry_length - 1);
7075 filename->data[entry_length-1] = '\0';
7076 zipf = opendir_in_zip ((const char *) filename->data, jcf_path_is_system (entry));
7078 error ("malformed .zip archive in CLASSPATH: %s", entry_name);
7081 ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
7082 BUFFER_RESET (filename);
7083 for (k = 0; k < package_length; k++)
7085 char ch = package_name[k];
7086 *filename->ptr++ = ch == '.' ? '/' : ch;
7088 *filename->ptr++ = '/';
7090 for (k = 0; k < zipf->count; k++, zipd = ZIPDIR_NEXT (zipd))
7092 const char *current_entry = ZIPDIR_FILENAME (zipd);
7093 int current_entry_len = zipd->filename_length;
7095 if (current_entry_len >= BUFFER_LENGTH (filename)
7096 && strncmp ((const char *) filename->data, current_entry,
7097 BUFFER_LENGTH (filename)) != 0)
7099 found |= note_possible_classname (current_entry,
7106 BUFFER_RESET (filename);
7107 buffer_grow (filename, entry_length + package_length + 4);
7108 strcpy ((char *) filename->data, entry_name);
7109 filename->ptr = filename->data + entry_length;
7110 for (k = 0; k < package_length; k++)
7112 char ch = package_name[k];
7113 *filename->ptr++ = ch == '.' ? '/' : ch;
7115 *filename->ptr = '\0';
7117 dirp = opendir ((const char *) filename->data);
7120 *filename->ptr++ = '/';
7125 struct dirent *direntp = readdir (dirp);
7128 d_name = direntp->d_name;
7129 len = strlen (direntp->d_name);
7130 buffer_grow (filename, len+1);
7131 strcpy ((char *) filename->ptr, d_name);
7132 found |= note_possible_classname ((const char *) filename->data + entry_length,
7133 package_length+len+1);
7140 free (filename->data);
7142 /* Here we should have a unified way of retrieving an entry, to be
7146 static int first = 1;
7149 error ("Can't find default package %qs. Check the CLASSPATH environment variable and the access to the archives", package_name);
7154 parse_error_context (wfl, "Package %qs not found in import",
7156 current_jcf = saved_jcf;
7159 current_jcf = saved_jcf;
7162 /* Possibly find a type in the import on demands specified
7163 types. Returns 1 if an error occurred, 0 otherwise. Run through the
7164 entire list, to detected potential double definitions. */
7167 find_in_imports_on_demand (tree enclosing_type, tree class_type)
7169 tree class_type_name = TYPE_NAME (class_type);
7170 tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7171 ctxp->import_demand_list);
7172 tree cl = NULL_TREE;
7173 int seen_once = -1; /* -1 when not set, 1 if seen once, >1 otherwise. */
7174 int to_return = -1; /* -1 when not set, 0 or 1 otherwise */
7177 for (; import; import = TREE_CHAIN (import))
7179 location_t saved_location = input_location;
7181 const char *id_name;
7182 tree decl, type_name_copy;
7184 obstack_grow (&temporary_obstack,
7185 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7186 IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7187 obstack_1grow (&temporary_obstack, '.');
7188 obstack_grow0 (&temporary_obstack,
7189 IDENTIFIER_POINTER (class_type_name),
7190 IDENTIFIER_LENGTH (class_type_name));
7191 id_name = obstack_finish (&temporary_obstack);
7193 if (! (node = maybe_get_identifier (id_name)))
7196 /* Setup input_line so that it refers to the line of the import (in
7197 case we parse a class file and encounter errors */
7198 #ifdef USE_MAPPED_LOCATION
7199 input_location = EXPR_LOCATION (TREE_PURPOSE (import));
7201 input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7204 type_name_copy = TYPE_NAME (class_type);
7205 TYPE_NAME (class_type) = node;
7206 QUALIFIED_P (node) = 1;
7207 decl = IDENTIFIER_CLASS_VALUE (node);
7209 /* If there is no DECL set for the class or if the class isn't
7210 loaded and not seen in source yet, then load */
7211 if (!decl || ! CLASS_LOADED_P (TREE_TYPE (decl)))
7213 load_class (node, 0);
7214 decl = IDENTIFIER_CLASS_VALUE (node);
7216 if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7217 access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7220 /* 6.6.1: Inner classes are subject to member access rules. */
7223 input_location = saved_location;
7225 /* If the loaded class is not accessible or couldn't be loaded,
7226 we restore the original TYPE_NAME and process the next
7228 if (access_check || !decl)
7230 TYPE_NAME (class_type) = type_name_copy;
7234 /* If the loaded class is accessible, we keep a tab on it to
7235 detect and report multiple inclusions. */
7236 if (IS_A_CLASSFILE_NAME (node))
7240 cl = TREE_PURPOSE (import);
7243 else if (seen_once >= 0)
7245 tree location = (cl ? cl : TREE_PURPOSE (import));
7246 tree package = (cl ? EXPR_WFL_NODE (cl) :
7247 EXPR_WFL_NODE (TREE_PURPOSE (import)));
7251 "Type %qs also potentially defined in package %qs",
7252 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7253 IDENTIFIER_POINTER (package));
7256 to_return = access_check;
7262 return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7265 /* Add package NAME to the list of packages encountered so far. To
7266 speed up class lookup in do_resolve_class, we make sure a
7267 particular package is added only once. */
7270 register_package (tree name)
7276 pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7278 e = htab_find_slot (pht, name, INSERT);
7281 package_list = chainon (package_list, build_tree_list (name, NULL));
7287 resolve_package (tree pkg, tree *next, tree *type_name)
7290 tree decl = NULL_TREE;
7291 *type_name = NULL_TREE;
7293 /* The trick is to determine when the package name stops and were
7294 the name of something contained in the package starts. Then we
7295 return a fully qualified name of what we want to get. */
7297 *next = EXPR_WFL_QUALIFICATION (pkg);
7299 /* Try to progressively construct a type name */
7300 if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7301 for (current = EXPR_WFL_QUALIFICATION (pkg);
7302 current; current = TREE_CHAIN (current))
7304 /* If we don't have what we're expecting, exit now. TYPE_NAME
7305 will be null and the error caught later. */
7306 if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7309 merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7310 if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7312 /* resolve_package should be used in a loop, hence we
7313 point at this one to naturally process the next one at
7314 the next iteration. */
7323 /* Check accessibility of inner classes according to member access rules.
7324 DECL is the inner class, ENCLOSING_DECL is the class from which the
7325 access is being attempted. */
7328 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7331 tree enclosing_decl_type;
7333 /* We don't issue an error message when CL is null. CL can be null
7334 as a result of processing a JDEP crafted by source_start_java_method
7335 for the purpose of patching its parm decl. But the error would
7336 have been already trapped when fixing the method's signature.
7337 DECL can also be NULL in case of earlier errors. */
7341 enclosing_decl_type = TREE_TYPE (enclosing_decl);
7343 if (CLASS_PRIVATE (decl))
7345 /* Access is permitted only within the body of the top-level
7346 class in which DECL is declared. */
7347 tree top_level = decl;
7348 while (DECL_CONTEXT (top_level))
7349 top_level = DECL_CONTEXT (top_level);
7350 while (DECL_CONTEXT (enclosing_decl))
7351 enclosing_decl = DECL_CONTEXT (enclosing_decl);
7352 if (top_level == enclosing_decl)
7356 else if (CLASS_PROTECTED (decl))
7359 /* Access is permitted from within the same package... */
7360 if (in_same_package (decl, enclosing_decl))
7363 /* ... or from within the body of a subtype of the context in which
7364 DECL is declared. */
7365 decl_context = DECL_CONTEXT (decl);
7366 while (enclosing_decl)
7368 if (CLASS_INTERFACE (decl))
7370 if (interface_of_p (TREE_TYPE (decl_context),
7371 enclosing_decl_type))
7376 /* Eww. The order of the arguments is different!! */
7377 if (inherits_from_p (enclosing_decl_type,
7378 TREE_TYPE (decl_context)))
7381 enclosing_decl = DECL_CONTEXT (enclosing_decl);
7383 access = "protected";
7385 else if (! CLASS_PUBLIC (decl))
7387 /* Access is permitted only from within the same package as DECL. */
7388 if (in_same_package (decl, enclosing_decl))
7390 access = "non-public";
7393 /* Class is public. */
7396 parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7397 (CLASS_INTERFACE (decl) ? "interface" : "class"),
7398 lang_printable_name (decl, 2), access);
7401 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7402 foreign package, it must be PUBLIC. Return 0 if no access
7403 violations were found, 1 otherwise. If VERBOSE is true and an error
7404 was found, it is reported and accounted for. If CL is NULL then
7405 look it up with THIS_DECL. */
7408 check_pkg_class_access (tree class_name, tree cl, bool verbose, tree this_decl)
7412 if (!IDENTIFIER_CLASS_VALUE (class_name))
7415 if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7418 if (!CLASS_PUBLIC (TYPE_NAME (type)))
7420 /* Access to a private class within the same package is
7423 split_qualified_name (&l, &r, class_name);
7424 if (!QUALIFIED_P (class_name) && !ctxp->package)
7425 /* Both in the empty package. */
7427 if (l == ctxp->package)
7428 /* Both in the same package. */
7433 (cl == NULL ? lookup_cl (this_decl): cl,
7434 "Can't access %s %qs. Only public classes and interfaces in other packages can be accessed",
7435 (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7436 IDENTIFIER_POINTER (class_name));
7442 /* Local variable declaration. */
7445 declare_local_variables (int modifier, tree type, tree vlist)
7447 tree decl, current, saved_type;
7448 tree type_wfl = NULL_TREE;
7452 /* Push a new block if statements were seen between the last time we
7453 pushed a block and now. Keep a count of blocks to close */
7454 if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7456 tree b = enter_block ();
7457 BLOCK_IS_IMPLICIT (b) = 1;
7463 for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7464 if (1 << i & modifier)
7466 if (modifier == ACC_FINAL)
7471 (ctxp->modifier_ctx [i],
7472 "Only %<final%> is allowed as a local variables modifier");
7477 /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7478 hold the TYPE value if a new incomplete has to be created (as
7479 opposed to being found already existing and reused). */
7480 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7482 /* If TYPE is fully resolved and we don't have a reference, make one */
7483 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7485 /* Go through all the declared variables */
7486 for (current = vlist, saved_type = type; current;
7487 current = TREE_CHAIN (current), type = saved_type)
7489 tree other, real_type;
7490 tree wfl = TREE_PURPOSE (current);
7491 tree name = EXPR_WFL_NODE (wfl);
7492 tree init = TREE_VALUE (current);
7494 /* Process NAME, as it may specify extra dimension(s) for it */
7495 type = build_array_from_name (type, type_wfl, name, &name);
7497 /* Variable redefinition check */
7498 if ((other = lookup_name_in_blocks (name)))
7500 variable_redefinition_error (wfl, name, TREE_TYPE (other),
7501 DECL_SOURCE_LINE (other));
7505 /* Type adjustment. We may have just readjusted TYPE because
7506 the variable specified more dimensions. Make sure we have
7507 a reference if we can and don't have one already. */
7508 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7510 real_type = GET_REAL_TYPE (type);
7511 /* Never layout this decl. This will be done when its scope
7513 decl = build_decl (VAR_DECL, name, real_type);
7514 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7515 DECL_FINAL (decl) = final_p;
7516 BLOCK_CHAIN_DECL (decl);
7518 /* If doing xreferencing, replace the line number with the WFL
7520 #ifdef USE_MAPPED_LOCATION
7522 DECL_SOURCE_LOCATION (decl) = EXPR_LOCATION (wfl);
7525 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7528 /* Don't try to use an INIT statement when an error was found */
7529 if (init && java_error_count)
7532 /* Remember it if this is an initialized-upon-declaration final
7534 if (init && final_p)
7536 DECL_LOCAL_FINAL_IUD (decl) = 1;
7539 /* Add the initialization function to the current function's code */
7542 /* Name might have been readjusted */
7543 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7544 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7545 java_method_add_stmt (current_function_decl,
7546 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7550 /* Setup dependency the type of the decl */
7554 register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7555 dep = CLASSD_LAST (ctxp->classd_list);
7556 JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7559 SOURCE_FRONTEND_DEBUG (("Defined locals"));
7562 /* Called during parsing. Build decls from argument list. */
7565 source_start_java_method (tree fndecl)
7574 current_function_decl = fndecl;
7576 /* New scope for the function */
7578 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7579 tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7581 tree type = TREE_VALUE (tem);
7582 tree name = TREE_PURPOSE (tem);
7584 /* If type is incomplete. Create an incomplete decl and ask for
7585 the decl to be patched later */
7586 if (INCOMPLETE_TYPE_P (type))
7589 tree real_type = GET_REAL_TYPE (type);
7590 parm_decl = build_decl (PARM_DECL, name, real_type);
7591 type = obtain_incomplete_type (type);
7592 register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7593 jdep = CLASSD_LAST (ctxp->classd_list);
7594 JDEP_MISC (jdep) = name;
7595 JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7598 parm_decl = build_decl (PARM_DECL, name, type);
7600 /* Remember if a local variable was declared final (via its
7601 TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7602 if (ARG_FINAL_P (tem))
7604 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7605 DECL_FINAL (parm_decl) = 1;
7608 BLOCK_CHAIN_DECL (parm_decl);
7610 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7611 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7613 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7614 DECL_MAX_LOCALS (current_function_decl) = i;
7617 /* Called during parsing. Creates an artificial method declaration. */
7620 create_artificial_method (tree class, int flags, tree type,
7621 tree name, tree args)
7624 location_t save_location = input_location;
7626 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (class));
7627 mdecl = make_node (FUNCTION_TYPE);
7628 TREE_TYPE (mdecl) = type;
7629 TYPE_ARG_TYPES (mdecl) = args;
7630 /* We used to compute the signature of MDECL here and then use
7631 add_method(), but that failed because our caller might modify
7632 the type of the returned method, which trashes the cache in
7633 get_type_from_signature(). */
7634 mdecl = add_method_1 (class, flags, name, mdecl);
7635 input_location = save_location;
7636 DECL_ARTIFICIAL (mdecl) = 1;
7640 /* Starts the body if an artificial method. */
7643 start_artificial_method_body (tree mdecl)
7645 #ifdef USE_MAPPED_LOCATION
7646 DECL_SOURCE_LOCATION (mdecl) = ctxp->file_start_location;
7647 DECL_FUNCTION_LAST_LINE (mdecl) = ctxp->file_start_location;
7649 DECL_SOURCE_LINE (mdecl) = 1;
7650 DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7652 source_start_java_method (mdecl);
7657 end_artificial_method_body (tree mdecl)
7659 /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7660 It has to be evaluated first. (if mdecl is current_function_decl,
7661 we have an undefined behavior if no temporary variable is used.) */
7662 tree b = exit_block ();
7663 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7667 /* Dump a tree of some kind. This is a convenience wrapper for the
7668 dump_* functions in tree-dump.c. */
7670 dump_java_tree (enum tree_dump_index phase, tree t)
7675 stream = dump_begin (phase, &flags);
7679 dump_node (t, flags, stream);
7680 dump_end (phase, stream);
7684 /* Terminate a function and expand its body. */
7687 source_end_java_method (void)
7689 tree fndecl = current_function_decl;
7694 java_parser_context_save_global ();
7695 #ifdef USE_MAPPED_LOCATION
7696 input_location = ctxp->last_ccb_indent1;
7698 input_line = ctxp->last_ccb_indent1;
7701 /* Turn function bodies with only a NOP expr null, so they don't get
7702 generated at all and we won't get warnings when using the -W
7704 if (IS_EMPTY_STMT (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))))
7705 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7707 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7708 && ! flag_emit_class_files
7709 && ! flag_emit_xref)
7710 finish_method (fndecl);
7712 current_function_decl = NULL_TREE;
7713 java_parser_context_restore_global ();
7714 current_function_decl = NULL_TREE;
7717 /* Record EXPR in the current function block. Complements compound
7718 expression second operand if necessary. */
7721 java_method_add_stmt (tree fndecl, tree expr)
7723 if (!GET_CURRENT_BLOCK (fndecl))
7725 return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7729 add_stmt_to_block (tree b, tree type, tree stmt)
7731 tree body = BLOCK_EXPR_BODY (b), c;
7733 if (java_error_count)
7736 if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7739 BLOCK_EXPR_BODY (b) = c;
7740 TREE_SIDE_EFFECTS (c) = 1;
7744 /* Lays out the methods for the classes seen so far. */
7747 java_layout_seen_class_methods (void)
7749 tree previous_list = all_class_list;
7750 tree end = NULL_TREE;
7755 for (current = previous_list;
7756 current != end; current = TREE_CHAIN (current))
7758 tree decl = TREE_VALUE (current);
7759 tree cls = TREE_TYPE (decl);
7761 input_location = DECL_SOURCE_LOCATION (decl);
7763 if (! CLASS_LOADED_P (cls))
7764 load_class (cls, 0);
7766 layout_class_methods (cls);
7769 /* Note that new classes might have been added while laying out
7770 methods, changing the value of all_class_list. */
7772 if (previous_list != all_class_list)
7774 end = previous_list;
7775 previous_list = all_class_list;
7782 static GTY(()) tree stop_reordering;
7784 java_reorder_fields (void)
7788 for (current = gclass_list; current; current = TREE_CHAIN (current))
7790 output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7792 if (current_class == stop_reordering)
7795 /* Reverse the fields, but leave the dummy field in front.
7796 Fields are already ordered for Object and Class */
7797 if (TYPE_FIELDS (current_class) && current_class != object_type_node
7798 && current_class != class_type_node)
7800 /* If the dummy field is there, reverse the right fields and
7801 just layout the type for proper fields offset */
7802 if (!DECL_NAME (TYPE_FIELDS (current_class)))
7804 tree fields = TYPE_FIELDS (current_class);
7805 TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7806 TYPE_SIZE (current_class) = NULL_TREE;
7808 /* We don't have a dummy field, we need to layout the class,
7809 after having reversed the fields */
7812 TYPE_FIELDS (current_class) =
7813 nreverse (TYPE_FIELDS (current_class));
7814 TYPE_SIZE (current_class) = NULL_TREE;
7818 /* There are cases were gclass_list will be empty. */
7820 stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7823 /* Layout the methods of all classes loaded in one way or another.
7824 Check methods of source parsed classes. Then reorder the
7825 fields and layout the classes or the type of all source parsed
7829 java_layout_classes (void)
7832 int save_error_count = java_error_count;
7834 /* Layout the methods of all classes seen so far */
7835 java_layout_seen_class_methods ();
7836 java_parse_abort_on_error ();
7837 all_class_list = NULL_TREE;
7839 /* Then check the methods of all parsed classes */
7840 for (current = gclass_list; current; current = TREE_CHAIN (current))
7841 if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7842 java_check_methods (TREE_VALUE (current));
7843 java_parse_abort_on_error ();
7845 for (current = gclass_list; current; current = TREE_CHAIN (current))
7847 output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7848 layout_class (current_class);
7850 /* Error reported by the caller */
7851 if (java_error_count)
7855 /* We might have reloaded classes durign the process of laying out
7856 classes for code generation. We must layout the methods of those
7857 late additions, as constructor checks might use them */
7858 java_layout_seen_class_methods ();
7859 java_parse_abort_on_error ();
7862 /* Expand methods in the current set of classes remembered for
7866 java_complete_expand_classes (void)
7870 do_not_fold = flag_emit_xref;
7872 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7873 if (!INNER_CLASS_DECL_P (current))
7874 java_complete_expand_class (current);
7877 /* Expand the methods found in OUTER, starting first by OUTER's inner
7881 java_complete_expand_class (tree outer)
7885 /* We need to go after all inner classes and start expanding them,
7886 starting with most nested ones. We have to do that because nested
7887 classes might add functions to outer classes */
7889 for (inner_list = DECL_INNER_CLASS_LIST (outer);
7890 inner_list; inner_list = TREE_CHAIN (inner_list))
7891 java_complete_expand_class (TREE_PURPOSE (inner_list));
7893 java_complete_expand_methods (outer);
7896 /* Expand methods registered in CLASS_DECL. The general idea is that
7897 we expand regular methods first. This allows us get an estimate on
7898 how outer context local alias fields are really used so we can add
7899 to the constructor just enough code to initialize them properly (it
7900 also lets us generate finit$ correctly.) Then we expand the
7901 constructors and then <clinit>. */
7904 java_complete_expand_methods (tree class_decl)
7906 tree clinit, decl, first_decl;
7908 output_class = current_class = TREE_TYPE (class_decl);
7910 /* Pre-expand <clinit> to figure whether we really need it or
7911 not. If we do need it, we pre-expand the static fields so they're
7912 ready to be used somewhere else. <clinit> will be fully expanded
7913 after we processed the constructors. */
7914 first_decl = TYPE_METHODS (current_class);
7915 clinit = maybe_generate_pre_expand_clinit (current_class);
7917 /* Then generate finit$ (if we need to) because constructors will
7919 if (TYPE_FINIT_STMT_LIST (current_class))
7920 java_complete_expand_method (generate_finit (current_class));
7922 /* Then generate instinit$ (if we need to) because constructors will
7924 if (TYPE_II_STMT_LIST (current_class))
7925 java_complete_expand_method (generate_instinit (current_class));
7927 /* Now do the constructors */
7928 for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7930 if (!DECL_CONSTRUCTOR_P (decl))
7932 java_complete_expand_method (decl);
7935 /* First, do the ordinary methods. */
7936 for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7938 /* Ctors aren't part of this batch. */
7939 if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7942 /* Skip abstract or native methods -- but do handle native
7943 methods when generating JNI stubs. */
7944 if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7946 DECL_FUNCTION_BODY (decl) = NULL_TREE;
7950 if (METHOD_NATIVE (decl))
7953 current_function_decl = decl;
7954 body = build_jni_stub (decl);
7955 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7958 java_complete_expand_method (decl);
7961 /* If there is indeed a <clinit>, fully expand it now */
7964 /* Prevent the use of `this' inside <clinit> */
7965 ctxp->explicit_constructor_p = 1;
7966 java_complete_expand_method (clinit);
7967 ctxp->explicit_constructor_p = 0;
7970 /* We might have generated a class$ that we now want to expand */
7971 if (TYPE_DOT_CLASS (current_class))
7972 java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7974 /* Now verify constructor circularity (stop after the first one we
7976 if (!CLASS_INTERFACE (class_decl))
7977 for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7978 if (DECL_CONSTRUCTOR_P (decl)
7979 && verify_constructor_circularity (decl, decl))
7983 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7984 safely used in some other methods/constructors. */
7987 maybe_generate_pre_expand_clinit (tree class_type)
7989 tree current, mdecl;
7991 if (!TYPE_CLINIT_STMT_LIST (class_type))
7994 /* Go through all static fields and pre expand them */
7995 for (current = TYPE_FIELDS (class_type); current;
7996 current = TREE_CHAIN (current))
7997 if (FIELD_STATIC (current))
7998 build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
8000 /* Then build the <clinit> method */
8001 mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
8002 clinit_identifier_node, end_params_node);
8003 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
8005 start_artificial_method_body (mdecl);
8007 /* We process the list of assignment we produced as the result of
8008 the declaration of initialized static field and add them as
8009 statement to the <clinit> method. */
8010 for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
8011 current = TREE_CHAIN (current))
8013 tree stmt = current;
8014 /* We build the assignment expression that will initialize the
8015 field to its value. There are strict rules on static
8016 initializers (8.5). FIXME */
8017 if (TREE_CODE (stmt) != BLOCK && !IS_EMPTY_STMT (stmt))
8018 stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
8019 java_method_add_stmt (mdecl, stmt);
8022 end_artificial_method_body (mdecl);
8024 /* Now we want to place <clinit> as the last method (because we need
8025 it at least for interface so that it doesn't interfere with the
8026 dispatch table based lookup. */
8027 if (TREE_CHAIN (TYPE_METHODS (class_type)))
8029 current = TREE_CHAIN (TYPE_METHODS (class_type));
8030 TYPE_METHODS (class_type) = current;
8032 while (TREE_CHAIN (current))
8033 current = TREE_CHAIN (current);
8035 TREE_CHAIN (current) = mdecl;
8036 TREE_CHAIN (mdecl) = NULL_TREE;
8042 /* Analyzes a method body and look for something that isn't a
8043 MODIFY_EXPR with a constant value. */
8046 analyze_clinit_body (tree this_class, tree bbody)
8049 switch (TREE_CODE (bbody))
8052 bbody = BLOCK_EXPR_BODY (bbody);
8055 case EXPR_WITH_FILE_LOCATION:
8056 bbody = EXPR_WFL_NODE (bbody);
8060 if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
8062 bbody = TREE_OPERAND (bbody, 1);
8066 /* If we're generating to class file and we're dealing with an
8067 array initialization, we return 1 to keep <clinit> */
8068 if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
8069 && flag_emit_class_files)
8072 /* There are a few cases where we're required to keep
8074 - If this is an assignment whose operand is not constant,
8075 - If this is an assignment to a non-initialized field,
8076 - If this field is not a member of the current class.
8078 return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
8079 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
8080 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
8089 /* See whether we could get rid of <clinit>. Criteria are: all static
8090 final fields have constant initial values and the body of <clinit>
8091 is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
8094 maybe_yank_clinit (tree mdecl)
8099 if (!DECL_CLINIT_P (mdecl))
8102 /* If the body isn't empty, then we keep <clinit>. Note that if
8103 we're emitting classfiles, this isn't enough not to rule it
8105 fbody = DECL_FUNCTION_BODY (mdecl);
8106 bbody = BLOCK_EXPR_BODY (fbody);
8107 if (bbody && bbody != error_mark_node)
8108 bbody = BLOCK_EXPR_BODY (bbody);
8111 if (bbody && ! flag_emit_class_files && !IS_EMPTY_STMT (bbody))
8114 type = DECL_CONTEXT (mdecl);
8115 current = TYPE_FIELDS (type);
8117 for (current = (current ? TREE_CHAIN (current) : current);
8118 current; current = TREE_CHAIN (current))
8122 /* We're not interested in non-static fields. */
8123 if (!FIELD_STATIC (current))
8126 /* Nor in fields without initializers. */
8127 f_init = DECL_INITIAL (current);
8128 if (f_init == NULL_TREE)
8131 /* Anything that isn't String or a basic type is ruled out -- or
8132 if we know how to deal with it (when doing things natively) we
8133 should generated an empty <clinit> so that SUID are computed
8135 if (! JSTRING_TYPE_P (TREE_TYPE (current))
8136 && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
8139 if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
8143 /* Now we analyze the method body and look for something that
8144 isn't a MODIFY_EXPR */
8145 if (!IS_EMPTY_STMT (bbody) && analyze_clinit_body (type, bbody))
8148 /* Get rid of <clinit> in the class' list of methods */
8149 if (TYPE_METHODS (type) == mdecl)
8150 TYPE_METHODS (type) = TREE_CHAIN (mdecl);
8152 for (current = TYPE_METHODS (type); current;
8153 current = TREE_CHAIN (current))
8154 if (TREE_CHAIN (current) == mdecl)
8156 TREE_CHAIN (current) = TREE_CHAIN (mdecl);
8163 /* Install the argument from MDECL. Suitable to completion and
8164 expansion of mdecl's body. */
8167 start_complete_expand_method (tree mdecl)
8171 pushlevel (1); /* Prepare for a parameter push */
8172 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
8173 DECL_ARGUMENTS (mdecl) = tem;
8175 for (; tem; tem = TREE_CHAIN (tem))
8177 /* TREE_CHAIN (tem) will change after pushdecl. */
8178 tree next = TREE_CHAIN (tem);
8179 tree type = TREE_TYPE (tem);
8180 if (targetm.calls.promote_prototypes (type)
8181 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
8182 && INTEGRAL_TYPE_P (type))
8183 type = integer_type_node;
8184 DECL_ARG_TYPE (tem) = type;
8185 layout_decl (tem, 0);
8187 /* Re-install the next so that the list is kept and the loop
8189 TREE_CHAIN (tem) = next;
8191 pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8192 input_location = DECL_SOURCE_LOCATION (mdecl);
8193 build_result_decl (mdecl);
8197 /* Complete and expand a method. */
8200 java_complete_expand_method (tree mdecl)
8202 tree fbody, block_body, exception_copy;
8204 current_function_decl = mdecl;
8205 /* Fix constructors before expanding them */
8206 if (DECL_CONSTRUCTOR_P (mdecl))
8207 fix_constructors (mdecl);
8209 /* Expand functions that have a body */
8210 if (!DECL_FUNCTION_BODY (mdecl))
8213 fbody = DECL_FUNCTION_BODY (mdecl);
8214 block_body = BLOCK_EXPR_BODY (fbody);
8215 exception_copy = NULL_TREE;
8217 current_function_decl = mdecl;
8220 fprintf (stderr, " [%s.",
8221 lang_printable_name (DECL_CONTEXT (mdecl), 0));
8222 announce_function (mdecl);
8224 fprintf (stderr, "]");
8226 /* Prepare the function for tree completion */
8227 start_complete_expand_method (mdecl);
8229 /* Install the current this */
8230 current_this = (!METHOD_STATIC (mdecl) ?
8231 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8233 /* Purge the `throws' list of unchecked exceptions (we save a copy
8234 of the list and re-install it later.) */
8235 exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8236 purge_unchecked_exceptions (mdecl);
8238 /* Install exceptions thrown with `throws' */
8239 PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8241 if (block_body != NULL_TREE)
8243 block_body = java_complete_tree (block_body);
8245 /* Before we check initialization, attached all class initialization
8246 variable to the block_body */
8247 htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8248 attach_init_test_initialization_flags, block_body);
8250 if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8252 check_for_initialization (block_body, mdecl);
8254 /* Go through all the flags marking the initialization of
8255 static variables and see whether they're definitively
8256 assigned, in which case the type is remembered as
8257 definitively initialized in MDECL. */
8258 if (STATIC_CLASS_INIT_OPT_P ())
8260 /* Always register the context as properly initialized in
8261 MDECL. This used with caution helps removing extra
8262 initialization of self. */
8263 if (METHOD_STATIC (mdecl))
8266 (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8267 DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8271 ctxp->explicit_constructor_p = 0;
8274 BLOCK_EXPR_BODY (fbody) = block_body;
8276 /* If we saw a return but couldn't evaluate it properly, we'll have
8277 an error_mark_node here. */
8278 if (block_body != error_mark_node
8279 && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8280 && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8282 missing_return_error (current_function_decl);
8284 /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8285 maybe_yank_clinit (mdecl);
8287 /* Pop the current level, with special measures if we found errors. */
8288 if (java_error_count)
8289 pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8292 /* Pop the exceptions and sanity check */
8294 if (currently_caught_type_list)
8297 /* Restore the copy of the list of exceptions if emitting xrefs. */
8298 DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8301 /* For with each class for which there's code to generate. */
8304 java_expand_method_bodies (tree class)
8307 for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8311 if (! DECL_FUNCTION_BODY (decl))
8314 current_function_decl = decl;
8316 block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8318 /* Save the function body for gimplify and inlining. */
8319 DECL_SAVED_TREE (decl) = block;
8321 /* It's time to assign the variable flagging static class
8322 initialization based on which classes invoked static methods
8323 are definitely initializing. This should be flagged. */
8324 if (STATIC_CLASS_INIT_OPT_P ())
8326 tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8327 for (; list != NULL_TREE; list = TREE_CHAIN (list))
8329 /* Executed for each statement calling a static function.
8330 LIST is a TREE_LIST whose PURPOSE is the called function
8331 and VALUE is a compound whose second operand can be patched
8332 with static class initialization flag assignments. */
8334 tree called_method = TREE_PURPOSE (list);
8335 tree compound = TREE_VALUE (list);
8336 tree assignment_compound_list
8337 = build_tree_list (called_method, NULL);
8339 /* For each class definitely initialized in
8340 CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8341 assignment to the class initialization flag. */
8342 htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8343 emit_test_initialization,
8344 assignment_compound_list);
8346 if (TREE_VALUE (assignment_compound_list))
8347 TREE_OPERAND (compound, 1)
8348 = TREE_VALUE (assignment_compound_list);
8352 /* Expand the function body. */
8353 source_end_java_method ();
8359 /* This section of the code deals with accessing enclosing context
8360 fields either directly by using the relevant access to this$<n> or
8361 by invoking an access method crafted for that purpose. */
8363 /* Build the necessary access from an inner class to an outer
8364 class. This routine could be optimized to cache previous result
8365 (decl, current_class and returned access). When an access method
8366 needs to be generated, it always takes the form of a read. It might
8367 be later turned into a write by calling outer_field_access_fix. */
8370 build_outer_field_access (tree id, tree decl)
8372 tree access = NULL_TREE;
8373 tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8374 tree decl_ctx = DECL_CONTEXT (decl);
8376 /* If the immediate enclosing context of the current class is the
8377 field decl's class or inherits from it; build the access as
8378 `this$<n>.<field>'. Note that we will break the `private' barrier
8379 if we're not emitting bytecodes. */
8380 if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8381 && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8383 tree thisn = build_current_thisn (current_class);
8384 access = make_qualified_primary (build_wfl_node (thisn),
8385 id, EXPR_WFL_LINECOL (id));
8387 /* Otherwise, generate access methods to outer this and access the
8388 field (either using an access method or by direct access.) */
8391 int lc = EXPR_WFL_LINECOL (id);
8393 /* Now we chain the required number of calls to the access$0 to
8394 get a hold to the enclosing instance we need, and then we
8395 build the field access. */
8396 access = build_access_to_thisn (current_class, decl_ctx, lc);
8398 /* If the field is private and we're generating bytecode, then
8399 we generate an access method */
8400 if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8402 tree name = build_outer_field_access_methods (decl);
8403 access = build_outer_field_access_expr (lc, decl_ctx,
8404 name, access, NULL_TREE);
8406 /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8407 Once again we break the `private' access rule from a foreign
8410 access = make_qualified_primary (access, id, lc);
8412 return resolve_expression_name (access, NULL);
8415 /* Return a nonzero value if NODE describes an outer field inner
8419 outer_field_access_p (tree type, tree decl)
8421 if (!INNER_CLASS_TYPE_P (type)
8422 || TREE_CODE (decl) != FIELD_DECL
8423 || DECL_CONTEXT (decl) == type)
8426 /* If the inner class extends the declaration context of the field
8427 we're trying to access, then this isn't an outer field access */
8428 if (inherits_from_p (type, DECL_CONTEXT (decl)))
8431 for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8432 type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8434 if (type == DECL_CONTEXT (decl))
8437 if (!DECL_CONTEXT (TYPE_NAME (type)))
8439 /* Before we give up, see whether the field is inherited from
8440 the enclosing context we're considering. */
8441 if (inherits_from_p (type, DECL_CONTEXT (decl)))
8450 /* Return a nonzero value if NODE represents an outer field inner
8451 access that was been already expanded. As a side effect, it returns
8452 the name of the field being accessed and the argument passed to the
8453 access function, suitable for a regeneration of the access method
8454 call if necessary. */
8457 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8462 if (TREE_CODE (node) != CALL_EXPR)
8465 /* Well, gcj generates slightly different tree nodes when compiling
8466 to native or bytecodes. It's the case for function calls. */
8468 if (flag_emit_class_files
8469 && TREE_CODE (node) == CALL_EXPR
8470 && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8472 else if (!flag_emit_class_files)
8474 node = TREE_OPERAND (node, 0);
8476 if (node && TREE_OPERAND (node, 0)
8477 && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8479 node = TREE_OPERAND (node, 0);
8480 if (TREE_OPERAND (node, 0)
8481 && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8482 && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8483 (DECL_NAME (TREE_OPERAND (node, 0)))))
8488 if (identified && name && arg_type && arg)
8490 tree argument = TREE_OPERAND (node, 1);
8491 *name = DECL_NAME (TREE_OPERAND (node, 0));
8492 *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8493 *arg = TREE_VALUE (argument);
8498 /* Detect in NODE an outer field read access from an inner class and
8499 transform it into a write with RHS as an argument. This function is
8500 called from the java_complete_lhs when an assignment to a LHS can
8504 outer_field_access_fix (tree wfl, tree node, tree rhs)
8506 tree name, arg_type, arg;
8508 if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8510 node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8511 arg_type, name, arg, rhs);
8512 return java_complete_tree (node);
8517 /* Construct the expression that calls an access method:
8518 <type>.access$<n>(<arg1> [, <arg2>]);
8520 ARG2 can be NULL and will be omitted in that case. It will denote a
8524 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8525 tree arg1, tree arg2)
8527 tree args, cn, access;
8529 args = arg1 ? arg1 :
8530 build_wfl_node (build_current_thisn (current_class));
8531 args = build_tree_list (NULL_TREE, args);
8534 args = tree_cons (NULL_TREE, arg2, args);
8536 access = build_method_invocation (build_wfl_node (access_method_name), args);
8537 cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8538 return make_qualified_primary (cn, access, lc);
8542 build_new_access_id (void)
8544 static int access_n_counter = 1;
8547 sprintf (buffer, "access$%d", access_n_counter++);
8548 return get_identifier (buffer);
8551 /* Create the static access functions for the outer field DECL. We define a
8553 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8557 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8558 TREE_TYPE (<field>) value$) {
8559 return inst$.field = value$;
8561 We should have a usage flags on the DECL so we can lazily turn the ones
8562 we're using for code generation. FIXME.
8566 build_outer_field_access_methods (tree decl)
8568 tree id, args, stmt, mdecl;
8570 if (FIELD_INNER_ACCESS_P (decl))
8571 return FIELD_INNER_ACCESS (decl);
8573 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8575 /* Create the identifier and a function named after it. */
8576 id = build_new_access_id ();
8578 /* The identifier is marked as bearing the name of a generated write
8579 access function for outer field accessed from inner classes. */
8580 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8582 /* Create the read access */
8583 args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8584 TREE_CHAIN (args) = end_params_node;
8585 stmt = make_qualified_primary (build_wfl_node (inst_id),
8586 build_wfl_node (DECL_NAME (decl)), 0);
8587 stmt = build_return (0, stmt);
8588 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8589 TREE_TYPE (decl), id, args, stmt);
8590 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8592 /* Create the write access method. No write access for final variable */
8593 if (!FIELD_FINAL (decl))
8595 args = build_tree_list (inst_id,
8596 build_pointer_type (DECL_CONTEXT (decl)));
8597 TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8598 TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8599 stmt = make_qualified_primary (build_wfl_node (inst_id),
8600 build_wfl_node (DECL_NAME (decl)), 0);
8601 stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8602 build_wfl_node (wpv_id)));
8603 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8604 TREE_TYPE (decl), id,
8607 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8609 /* Return the access name */
8610 return FIELD_INNER_ACCESS (decl) = id;
8613 /* Build an field access method NAME. */
8616 build_outer_field_access_method (tree class, tree type, tree name,
8617 tree args, tree body)
8619 tree saved_current_function_decl, mdecl;
8621 /* Create the method */
8622 mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8623 fix_method_argument_names (args, mdecl);
8624 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8626 /* Attach the method body. */
8627 saved_current_function_decl = current_function_decl;
8628 start_artificial_method_body (mdecl);
8629 java_method_add_stmt (mdecl, body);
8630 end_artificial_method_body (mdecl);
8631 current_function_decl = saved_current_function_decl;
8637 /* This section deals with building access function necessary for
8638 certain kinds of method invocation from inner classes. */
8641 build_outer_method_access_method (tree decl)
8643 tree saved_current_function_decl, mdecl;
8644 tree args = NULL_TREE, call_args = NULL_TREE;
8645 tree carg, id, body, class;
8647 int parm_id_count = 0;
8649 /* Test this abort with an access to a private field */
8650 if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8653 /* Check the cache first */
8654 if (DECL_FUNCTION_INNER_ACCESS (decl))
8655 return DECL_FUNCTION_INNER_ACCESS (decl);
8657 class = DECL_CONTEXT (decl);
8659 /* Obtain an access identifier and mark it */
8660 id = build_new_access_id ();
8661 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8663 carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8664 /* Create the arguments, as much as the original */
8665 for (; carg && carg != end_params_node;
8666 carg = TREE_CHAIN (carg))
8668 sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8669 args = chainon (args, build_tree_list (get_identifier (buffer),
8670 TREE_VALUE (carg)));
8672 args = chainon (args, end_params_node);
8674 /* Create the method */
8675 mdecl = create_artificial_method (class, ACC_STATIC,
8676 TREE_TYPE (TREE_TYPE (decl)), id, args);
8677 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8678 /* There is a potential bug here. We should be able to use
8679 fix_method_argument_names, but then arg names get mixed up and
8680 eventually a constructor will have its this$0 altered and the
8681 outer context won't be assignment properly. The testcase is
8683 TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8685 /* Attach the method body. */
8686 saved_current_function_decl = current_function_decl;
8687 start_artificial_method_body (mdecl);
8689 /* The actual method invocation uses the same args. When invoking a
8690 static methods that way, we don't want to skip the first
8693 if (!METHOD_STATIC (decl))
8694 carg = TREE_CHAIN (carg);
8695 for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8696 call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8699 body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8701 if (!METHOD_STATIC (decl))
8702 body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8704 if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8705 body = build_return (0, body);
8706 java_method_add_stmt (mdecl,body);
8707 end_artificial_method_body (mdecl);
8708 current_function_decl = saved_current_function_decl;
8710 /* Back tag the access function so it know what it accesses */
8711 DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8713 /* Tag the current method so it knows it has an access generated */
8714 return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8718 /* This section of the code deals with building expressions to access
8719 the enclosing instance of an inner class. The enclosing instance is
8720 kept in a generated field called this$<n>, with <n> being the
8721 inner class nesting level (starting from 0.) */
8723 /* Build an access to a given this$<n>, always chaining access call to
8724 others. Access methods to this$<n> are build on the fly if
8725 necessary. This CAN'T be used to solely access this$<n-1> from
8726 this$<n> (which alway yield to special cases and optimization, see
8727 for example build_outer_field_access). */
8730 build_access_to_thisn (tree from, tree to, int lc)
8732 tree access = NULL_TREE;
8734 while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8738 access = build_current_thisn (from);
8739 access = build_wfl_node (access);
8743 tree access0_wfl, cn;
8745 maybe_build_thisn_access_method (from);
8746 access0_wfl = build_wfl_node (access0_identifier_node);
8747 cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8748 EXPR_WFL_LINECOL (access0_wfl) = lc;
8749 access = build_tree_list (NULL_TREE, access);
8750 access = build_method_invocation (access0_wfl, access);
8751 access = make_qualified_primary (cn, access, lc);
8754 /* If FROM isn't an inner class, that's fine, we've done enough.
8755 What we're looking for can be accessed from there. */
8756 from = DECL_CONTEXT (TYPE_NAME (from));
8759 from = TREE_TYPE (from);
8764 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8765 is returned if nothing needs to be generated. Otherwise, the method
8766 generated and a method decl is returned.
8768 NOTE: These generated methods should be declared in a class file
8769 attribute so that they can't be referred to directly. */
8772 maybe_build_thisn_access_method (tree type)
8774 tree mdecl, args, stmt, rtype;
8775 tree saved_current_function_decl;
8777 /* If TYPE is a top-level class, no access method is required.
8778 If there already is such an access method, bail out. */
8779 if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8782 /* We generate the method. The method looks like:
8783 static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8785 args = build_tree_list (inst_id, build_pointer_type (type));
8786 TREE_CHAIN (args) = end_params_node;
8787 rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8788 mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8789 access0_identifier_node, args);
8790 fix_method_argument_names (args, mdecl);
8791 layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8792 stmt = build_current_thisn (type);
8793 stmt = make_qualified_primary (build_wfl_node (inst_id),
8794 build_wfl_node (stmt), 0);
8795 stmt = build_return (0, stmt);
8797 saved_current_function_decl = current_function_decl;
8798 start_artificial_method_body (mdecl);
8799 java_method_add_stmt (mdecl, stmt);
8800 end_artificial_method_body (mdecl);
8801 current_function_decl = saved_current_function_decl;
8803 CLASS_ACCESS0_GENERATED_P (type) = 1;
8808 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8809 the first level of innerclassing. this$1 for the next one, etc...
8810 This function can be invoked with TYPE to NULL, available and then
8811 has to count the parser context. */
8813 static GTY(()) tree saved_thisn;
8814 static GTY(()) tree saved_type;
8817 build_current_thisn (tree type)
8819 static int saved_i = -1;
8820 static int saved_type_i = 0;
8827 if (type == saved_type)
8831 for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8832 decl; decl = DECL_CONTEXT (decl), i++)
8840 i = list_length (GET_CPC_LIST ())-2;
8845 sprintf (buffer, "this$%d", i);
8847 saved_thisn = get_identifier (buffer);
8851 /* Return the assignment to the hidden enclosing context `this$<n>'
8852 by the second incoming parameter to the innerclass constructor. The
8853 form used is `this.this$<n> = this$<n>;'. */
8856 build_thisn_assign (void)
8858 if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8860 tree thisn = build_current_thisn (current_class);
8861 tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8862 build_wfl_node (thisn), 0);
8863 tree rhs = build_wfl_node (thisn);
8864 #ifdef USE_MAPPED_LOCATION
8865 SET_EXPR_LOCATION (lhs, input_location);
8867 EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8869 return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8875 /* Building the synthetic `class$' used to implement the `.class' 1.1
8876 extension for non primitive types. This method looks like:
8878 static Class class$(String type) throws NoClassDefFoundError
8880 try {return (java.lang.Class.forName (String));}
8881 catch (ClassNotFoundException e) {
8882 throw new NoClassDefFoundError(e.getMessage());}
8885 static GTY(()) tree get_message_wfl;
8886 static GTY(()) tree type_parm_wfl;
8889 build_dot_class_method (tree class)
8891 #define BWF(S) build_wfl_node (get_identifier ((S)))
8892 #ifdef USE_MAPPED_LOCATION
8893 #define MQN(X,Y) make_qualified_name ((X), (Y), UNKNOWN_LOCATION)
8895 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8897 tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8898 tree stmt, throw_stmt;
8900 if (!get_message_wfl)
8902 get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8903 type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8906 /* Build the arguments */
8907 args = build_tree_list (get_identifier ("type$"),
8908 build_pointer_type (string_type_node));
8909 TREE_CHAIN (args) = end_params_node;
8911 /* Build the qualified name java.lang.Class.forName */
8912 tmp = MQN (MQN (MQN (BWF ("java"),
8913 BWF ("lang")), BWF ("Class")), BWF ("forName"));
8915 /* Create the "class$" function */
8916 mdecl = create_artificial_method (class, ACC_STATIC,
8917 build_pointer_type (class_type_node),
8918 classdollar_identifier_node, args);
8919 qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8920 BWF ("NoClassDefFoundError"));
8921 DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8922 register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8923 JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8924 &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8926 /* We start by building the try block. We need to build:
8927 return (java.lang.Class.forName (type)); */
8928 stmt = build_method_invocation (tmp,
8929 build_tree_list (NULL_TREE, type_parm_wfl));
8930 stmt = build_return (0, stmt);
8932 /* Now onto the catch block. We start by building the expression
8933 throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8934 #ifdef USE_MAPPED_LOCATION
8935 throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8936 get_message_wfl, UNKNOWN_LOCATION);
8938 throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8939 get_message_wfl, 0);
8941 throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8943 /* Build new NoClassDefFoundError (_.getMessage) */
8944 throw_stmt = build_new_invocation
8945 (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8946 build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8948 /* Build the throw, (it's too early to use BUILD_THROW) */
8949 throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8951 /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8952 qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8953 BWF ("ClassNotFoundException"));
8954 stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8956 fix_method_argument_names (args, mdecl);
8957 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8958 saved_current_function_decl = current_function_decl;
8959 start_artificial_method_body (mdecl);
8960 java_method_add_stmt (mdecl, stmt);
8961 end_artificial_method_body (mdecl);
8962 current_function_decl = saved_current_function_decl;
8963 TYPE_DOT_CLASS (class) = mdecl;
8969 build_dot_class_method_invocation (tree this_class, tree type)
8971 tree dot_class_method = TYPE_DOT_CLASS (this_class);
8974 if (TYPE_ARRAY_P (type))
8975 sig_id = build_java_signature (type);
8977 sig_id = DECL_NAME (TYPE_NAME (type));
8979 /* Ensure that the proper name separator is used */
8980 sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8981 IDENTIFIER_LENGTH (sig_id));
8983 s = build_string (IDENTIFIER_LENGTH (sig_id),
8984 IDENTIFIER_POINTER (sig_id));
8985 t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8986 build_tree_list (NULL_TREE, s));
8987 if (DECL_CONTEXT (dot_class_method) != this_class)
8989 tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8990 t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8995 /* This section of the code deals with constructor. */
8997 /* Craft a body for default constructor. Patch existing constructor
8998 bodies with call to super() and field initialization statements if
9002 fix_constructors (tree mdecl)
9004 tree iii; /* Instance Initializer Invocation */
9005 tree *bodyp = &DECL_FUNCTION_BODY (mdecl);
9006 tree thisn_assign, compound = NULL_TREE;
9007 tree class_type = DECL_CONTEXT (mdecl);
9009 if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
9011 DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
9015 /* It is an error for the compiler to generate a default
9016 constructor if the superclass doesn't have a constructor that
9017 takes no argument, or the same args for an anonymous class */
9018 if (verify_constructor_super (mdecl))
9020 tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
9021 tree save = DECL_NAME (mdecl);
9022 const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
9023 DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
9025 (lookup_cl (TYPE_NAME (class_type)),
9026 "No constructor matching %qs found in class %qs",
9027 lang_printable_name (mdecl, 2), n);
9028 DECL_NAME (mdecl) = save;
9031 /* The constructor body must be crafted by hand. It's the
9032 constructor we defined when we realize we didn't have the
9033 CLASSNAME() constructor */
9034 start_artificial_method_body (mdecl);
9036 /* Insert an assignment to the this$<n> hidden field, if
9038 if ((thisn_assign = build_thisn_assign ()))
9039 java_method_add_stmt (mdecl, thisn_assign);
9041 /* We don't generate a super constructor invocation if we're
9042 compiling java.lang.Object. build_super_invocation takes care
9044 java_method_add_stmt (mdecl, build_super_invocation (mdecl));
9047 if ((iii = build_instinit_invocation (class_type)))
9048 java_method_add_stmt (mdecl, iii);
9050 end_artificial_method_body (mdecl);
9052 /* Search for an explicit constructor invocation */
9056 int invokes_this = 0;
9057 tree main_block = BLOCK_EXPR_BODY (*bodyp);
9062 switch (TREE_CODE (body))
9065 found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
9066 if (CALL_THIS_CONSTRUCTOR_P (body))
9070 case EXPR_WITH_FILE_LOCATION:
9071 bodyp = &TREE_OPERAND (body, 0);
9074 bodyp = &BLOCK_EXPR_BODY (body);
9082 /* Generate the assignment to this$<n>, if necessary */
9083 if ((thisn_assign = build_thisn_assign ()))
9084 compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
9086 /* The constructor is missing an invocation of super() */
9088 compound = add_stmt_to_compound (compound, NULL_TREE,
9089 build_super_invocation (mdecl));
9090 /* Explicit super() invocation should take place before the
9091 instance initializer blocks. */
9094 compound = add_stmt_to_compound (compound, NULL_TREE, *bodyp);
9095 *bodyp = build_java_empty_stmt ();
9098 DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
9100 /* Insert the instance initializer block right after. */
9101 if (!invokes_this && (iii = build_instinit_invocation (class_type)))
9102 compound = add_stmt_to_compound (compound, NULL_TREE, iii);
9104 /* Fix the constructor main block if we're adding extra stmts */
9107 compound = add_stmt_to_compound (compound, NULL_TREE,
9108 BLOCK_EXPR_BODY (main_block));
9109 BLOCK_EXPR_BODY (main_block) = compound;
9114 /* Browse constructors in the super class, searching for a constructor
9115 that doesn't take any argument. Return 0 if one is found, 1
9116 otherwise. If the current class is an anonymous inner class, look
9117 for something that has the same signature. */
9120 verify_constructor_super (tree mdecl)
9122 tree class = CLASSTYPE_SUPER (current_class);
9123 int super_inner = PURE_INNER_CLASS_TYPE_P (class);
9129 if (ANONYMOUS_CLASS_P (current_class))
9131 tree mdecl_arg_type;
9132 SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
9133 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9134 if (DECL_CONSTRUCTOR_P (sdecl))
9137 tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9139 arg_type = TREE_CHAIN (arg_type);
9140 for (m_arg_type = mdecl_arg_type;
9141 (arg_type != end_params_node
9142 && m_arg_type != end_params_node);
9143 arg_type = TREE_CHAIN (arg_type),
9144 m_arg_type = TREE_CHAIN (m_arg_type))
9145 if (!valid_method_invocation_conversion_p
9146 (TREE_VALUE (arg_type),
9147 TREE_VALUE (m_arg_type)))
9150 if (arg_type == end_params_node && m_arg_type == end_params_node)
9156 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9158 tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9160 arg = TREE_CHAIN (arg);
9161 if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
9168 /* Generate code for all context remembered for code generation. */
9170 static GTY(()) tree reversed_class_list;
9172 java_expand_classes (void)
9174 int save_error_count = 0;
9175 static struct parser_ctxt *cur_ctxp = NULL;
9176 location_t save_location;
9178 java_parse_abort_on_error ();
9179 if (!(ctxp = ctxp_for_generation))
9181 java_layout_classes ();
9182 java_parse_abort_on_error ();
9183 save_location = input_location;
9185 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9188 for (current = cur_ctxp->class_list;
9190 current = TREE_CHAIN (current))
9191 gen_indirect_dispatch_tables (TREE_TYPE (current));
9194 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9197 input_location = ctxp->file_start_location;
9198 lang_init_source (2); /* Error msgs have method prototypes */
9199 java_complete_expand_classes (); /* Complete and expand classes */
9200 java_parse_abort_on_error ();
9202 input_location = save_location;
9204 /* Find anonymous classes and expand their constructor. This extra pass is
9205 necessary because the constructor itself is only generated when the
9206 method in which it is defined is expanded. */
9207 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9211 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9213 output_class = current_class = TREE_TYPE (current);
9214 if (ANONYMOUS_CLASS_P (current_class))
9217 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9219 if (DECL_CONSTRUCTOR_P (d))
9221 java_complete_expand_method (d);
9222 break; /* There is only one constructor. */
9229 /* Expanding the constructors of anonymous classes generates access
9230 methods. Scan all the methods looking for null DECL_RESULTs --
9231 this will be the case if a method hasn't been expanded. */
9232 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9236 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9239 output_class = current_class = TREE_TYPE (current);
9240 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9242 if (DECL_RESULT (d) == NULL_TREE)
9243 java_complete_expand_method (d);
9248 /* ??? Instead of all this we could iterate around the list of
9249 classes until there were no more un-expanded methods. It would
9250 take a little longer -- one pass over the whole list of methods
9251 -- but it would be simpler. Like this: */
9254 int something_changed;
9258 something_changed = 0;
9259 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9263 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9266 output_class = current_class = TREE_TYPE (current);
9267 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9269 if (DECL_RESULT (d) == NULL_TREE)
9271 something_changed = 1;
9272 java_complete_expand_method (d);
9278 while (something_changed);
9282 /* If we've found error at that stage, don't try to generate
9283 anything, unless we're emitting xrefs or checking the syntax only
9284 (but not using -fsyntax-only for the purpose of generating
9286 if (java_error_count && !flag_emit_xref
9287 && (!flag_syntax_only && !flag_emit_class_files))
9290 /* Now things are stable, go for generation of the class data. */
9292 /* We pessimistically marked all methods and fields external until
9293 we knew what set of classes we were planning to compile. Now mark
9294 those that will be generated locally as not external. */
9295 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9299 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9300 java_mark_class_local (TREE_TYPE (current));
9303 /* Compile the classes. */
9304 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9307 reversed_class_list = NULL;
9311 /* We write out the classes in reverse order. This ensures that
9312 inner classes are written before their containing classes,
9313 which is important for parallel builds. Otherwise, the
9314 class file for the outer class may be found, but the class
9315 file for the inner class may not be present. In that
9316 situation, the compiler cannot fall back to the original
9317 source, having already read the outer class, so we must
9318 prevent that situation. */
9319 for (current = ctxp->class_list;
9321 current = TREE_CHAIN (current))
9323 = tree_cons (NULL_TREE, current, reversed_class_list);
9325 for (current = reversed_class_list;
9327 current = TREE_CHAIN (current))
9329 output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9330 if (flag_emit_class_files)
9331 write_classfile (current_class);
9333 expand_xref (current_class);
9334 else if (! flag_syntax_only)
9335 java_expand_method_bodies (current_class);
9341 java_finish_classes (void)
9343 static struct parser_ctxt *cur_ctxp = NULL;
9344 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9348 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9350 output_class = current_class = TREE_TYPE (current);
9356 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9357 a tree list node containing RIGHT. Fore coming RIGHTs will be
9358 chained to this hook. LOCATION contains the location of the
9359 separating `.' operator. */
9362 make_qualified_primary (tree primary, tree right, int location)
9366 if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9367 wfl = build_wfl_wrap (primary, location);
9371 /* If wfl wasn't qualified, we build a first anchor */
9372 if (!EXPR_WFL_QUALIFICATION (wfl))
9373 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9376 /* And chain them */
9377 EXPR_WFL_LINECOL (right) = location;
9378 chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9379 PRIMARY_P (wfl) = 1;
9383 /* Simple merge of two name separated by a `.' */
9386 merge_qualified_name (tree left, tree right)
9389 if (!left && !right)
9398 obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9399 IDENTIFIER_LENGTH (left));
9400 obstack_1grow (&temporary_obstack, '.');
9401 obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9402 IDENTIFIER_LENGTH (right));
9403 node = get_identifier (obstack_base (&temporary_obstack));
9404 obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9405 QUALIFIED_P (node) = 1;
9409 /* Merge the two parts of a qualified name into LEFT. Set the
9410 location information of the resulting node to LOCATION, usually
9411 inherited from the location information of the `.' operator. */
9414 make_qualified_name (tree left, tree right,
9415 #ifdef USE_MAPPED_LOCATION
9416 source_location location
9422 #ifdef USE_COMPONENT_REF
9423 tree node = build3 (COMPONENT_REF, NULL_TREE, left, right, NULL_TREE);
9424 SET_EXPR_LOCATION (node, location);
9427 tree left_id = EXPR_WFL_NODE (left);
9428 tree right_id = EXPR_WFL_NODE (right);
9431 merge = merge_qualified_name (left_id, right_id);
9433 /* Left wasn't qualified and is now qualified */
9434 #ifdef USE_MAPPED_LOCATION
9435 if (!QUALIFIED_P (left_id))
9437 tree wfl = build_expr_wfl (left_id, EXPR_LOCATION (left));
9438 EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9441 wfl = build_expr_wfl (right_id, location);
9443 if (!QUALIFIED_P (left_id))
9445 tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9446 EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9447 EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9450 wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9451 EXPR_WFL_LINECOL (wfl) = location;
9453 chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9454 EXPR_WFL_NODE (left) = merge;
9459 /* Extract the last identifier component of the qualified in WFL. The
9460 last identifier is removed from the linked list */
9463 cut_identifier_in_qualified (tree wfl)
9466 tree previous = NULL_TREE;
9467 for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9468 if (!TREE_CHAIN (q))
9471 /* Operating on a non qualified qualified WFL. */
9474 TREE_CHAIN (previous) = NULL_TREE;
9475 return TREE_PURPOSE (q);
9479 /* Resolve the expression name NAME. Return its decl. */
9482 resolve_expression_name (tree id, tree *orig)
9484 tree name = EXPR_WFL_NODE (id);
9487 /* 6.5.5.1: Simple expression names */
9488 if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9490 /* 15.13.1: NAME can appear within the scope of a local variable
9492 if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9495 /* 15.13.1: NAME can appear within a class declaration */
9498 decl = lookup_field_wrapper (current_class, name);
9501 tree access = NULL_TREE;
9502 int fs = FIELD_STATIC (decl);
9504 /* If we're accessing an outer scope local alias, make
9505 sure we change the name of the field we're going to
9507 if (FIELD_LOCAL_ALIAS_USED (decl))
9508 name = DECL_NAME (decl);
9510 check_deprecation (id, decl);
9512 /* Instance variable (8.3.1.1) can't appear within
9513 static method, static initializer or initializer for
9514 a static variable. */
9515 if (!fs && METHOD_STATIC (current_function_decl))
9517 static_ref_err (id, name, current_class);
9518 return error_mark_node;
9520 /* Instance variables can't appear as an argument of
9521 an explicit constructor invocation */
9522 if (!fs && ctxp->explicit_constructor_p
9523 && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9526 (id, "Can't reference %qs before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9527 return error_mark_node;
9530 /* If we're processing an inner class and we're trying
9531 to access a field belonging to an outer class, build
9532 the access to the field */
9533 if (!fs && outer_field_access_p (current_class, decl))
9535 if (CLASS_STATIC (TYPE_NAME (current_class)))
9537 static_ref_err (id, DECL_NAME (decl), current_class);
9538 return error_mark_node;
9540 access = build_outer_field_access (id, decl);
9546 /* Otherwise build what it takes to access the field */
9547 access = build_field_ref ((fs ? NULL_TREE : current_this),
9548 DECL_CONTEXT (decl), name);
9550 access = maybe_build_class_init_for_field (decl, access);
9551 /* We may be asked to save the real field access node */
9554 /* Last check: can we access the field? */
9555 if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9557 not_accessible_field_error (id, decl);
9558 return error_mark_node;
9560 /* And we return what we got */
9563 /* Fall down to error report on undefined variable */
9566 /* 6.5.5.2 Qualified Expression Names */
9571 qualify_ambiguous_name (id);
9572 /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9573 /* 15.10.2: Accessing Superclass Members using super */
9574 return resolve_field_access (id, orig, NULL);
9577 /* We've got an error here */
9578 if (INNER_CLASS_TYPE_P (current_class))
9579 parse_error_context (id,
9580 "Local variable %qs can't be accessed from within the inner class %qs unless it is declared final",
9581 IDENTIFIER_POINTER (name),
9582 IDENTIFIER_POINTER (DECL_NAME
9583 (TYPE_NAME (current_class))));
9585 parse_error_context (id, "Undefined variable %qs",
9586 IDENTIFIER_POINTER (name));
9588 return error_mark_node;
9592 static_ref_err (tree wfl, tree field_id, tree class_type)
9596 "Can't make a static reference to nonstatic variable %qs in class %qs",
9597 IDENTIFIER_POINTER (field_id),
9598 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9601 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9602 We return something suitable to generate the field access. We also
9603 return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
9604 recipient's address can be null. */
9607 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9611 tree decl = NULL_TREE, where_found, type_found;
9613 if (resolve_qualified_expression_name (qual_wfl, &decl,
9614 &where_found, &type_found))
9615 return error_mark_node;
9617 /* Resolve the LENGTH field of an array here */
9618 if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9619 && type_found && TYPE_ARRAY_P (type_found)
9620 && ! flag_emit_class_files && ! flag_emit_xref)
9622 tree length = build_java_array_length_access (where_found);
9625 /* In case we're dealing with a static array, we need to
9626 initialize its class before the array length can be fetched.
9627 It's also a good time to create a DECL_RTL for the field if
9628 none already exists, otherwise if the field was declared in a
9629 class found in an external file and hasn't been (and won't
9630 be) accessed for its value, none will be created. */
9631 if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9633 build_static_field_ref (where_found);
9634 field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9637 /* We might have been trying to resolve field.method(). In which
9638 case, the resolution is over and decl is the answer */
9639 else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9641 else if (JDECL_P (decl))
9644 type_found = DECL_CONTEXT (decl);
9645 is_static = FIELD_STATIC (decl);
9646 field_ref = build_field_ref ((is_static && !flag_emit_xref?
9647 NULL_TREE : where_found),
9648 type_found, DECL_NAME (decl));
9649 if (field_ref == error_mark_node)
9650 return error_mark_node;
9652 field_ref = maybe_build_class_init_for_field (decl, field_ref);
9654 /* If we're looking at a static field, we may need to generate a
9655 class initialization for it. This can happen when the access
9656 looks like `field.ref', where `field' is a static field in an
9657 interface we implement. */
9658 if (!flag_emit_class_files
9660 && TREE_CODE (where_found) == VAR_DECL
9661 && FIELD_STATIC (where_found))
9663 build_static_field_ref (where_found);
9664 field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9673 *field_type = (QUAL_DECL_TYPE (decl) ?
9674 QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9678 /* If NODE is an access to f static field, strip out the class
9679 initialization part and return the field decl, otherwise, return
9683 strip_out_static_field_access_decl (tree node)
9685 if (TREE_CODE (node) == COMPOUND_EXPR)
9687 tree op1 = TREE_OPERAND (node, 1);
9688 if (TREE_CODE (op1) == COMPOUND_EXPR)
9690 tree call = TREE_OPERAND (op1, 0);
9691 if (TREE_CODE (call) == CALL_EXPR
9692 && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9693 && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9694 == soft_initclass_node)
9695 return TREE_OPERAND (op1, 1);
9697 else if (JDECL_P (op1))
9703 /* 6.5.5.2: Qualified Expression Names */
9706 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9707 tree *where_found, tree *type_found)
9709 int from_type = 0; /* Field search initiated from a type */
9710 int from_super = 0, from_cast = 0, from_qualified_this = 0;
9711 int previous_call_static = 0;
9713 tree decl = NULL_TREE, type = NULL_TREE, q;
9714 /* For certain for of inner class instantiation */
9715 tree saved_current, saved_this;
9716 #define RESTORE_THIS_AND_CURRENT_CLASS \
9717 { current_class = saved_current; current_this = saved_this;}
9719 *type_found = *where_found = NULL_TREE;
9721 for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9723 tree qual_wfl = QUAL_WFL (q);
9724 tree ret_decl; /* for EH checking */
9725 #ifdef USE_MAPPED_LOCATION
9726 source_location location; /* for EH checking */
9728 int location; /* for EH checking */
9731 /* 15.10.1 Field Access Using a Primary */
9732 switch (TREE_CODE (qual_wfl))
9735 case NEW_CLASS_EXPR:
9736 /* If the access to the function call is a non static field,
9737 build the code to access it. */
9738 if (JDECL_P (decl) && !FIELD_STATIC (decl))
9740 decl = maybe_access_field (decl, *where_found,
9741 DECL_CONTEXT (decl));
9742 if (decl == error_mark_node)
9746 /* And code for the function call */
9747 if (complete_function_arguments (qual_wfl))
9750 /* We might have to setup a new current class and a new this
9751 for the search of an inner class, relative to the type of
9752 a expression resolved as `decl'. The current values are
9753 saved and restored shortly after */
9754 saved_current = current_class;
9755 saved_this = current_this;
9757 && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9758 || from_qualified_this))
9760 /* If we still have `from_qualified_this', we have the form
9761 <T>.this.f() and we need to build <T>.this */
9762 if (from_qualified_this)
9764 decl = build_access_to_thisn (current_class, type, 0);
9765 decl = java_complete_tree (decl);
9766 type = TREE_TYPE (TREE_TYPE (decl));
9768 current_class = type;
9769 current_this = decl;
9770 from_qualified_this = 0;
9773 if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9774 CALL_USING_SUPER (qual_wfl) = 1;
9775 #ifdef USE_MAPPED_LOCATION
9776 location = (TREE_CODE (qual_wfl) == CALL_EXPR
9777 ? EXPR_LOCATION (TREE_OPERAND (qual_wfl, 0))
9778 : UNKNOWN_LOCATION);
9780 location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9781 EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9783 *where_found = patch_method_invocation (qual_wfl, decl, type,
9785 &is_static, &ret_decl);
9787 if (*where_found == error_mark_node)
9789 RESTORE_THIS_AND_CURRENT_CLASS;
9792 *type_found = type = QUAL_DECL_TYPE (*where_found);
9794 *where_found = force_evaluation_order (*where_found);
9796 /* If we're creating an inner class instance, check for that
9797 an enclosing instance is in scope */
9798 if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9799 && INNER_ENCLOSING_SCOPE_CHECK (type))
9802 (qual_wfl, "No enclosing instance for inner class %qs is in scope%s",
9803 lang_printable_name (type, 0),
9804 (!current_this ? "" :
9805 "; an explicit one must be provided when creating this inner class"));
9806 RESTORE_THIS_AND_CURRENT_CLASS;
9810 /* In case we had to change then to resolve a inner class
9811 instantiation using a primary qualified by a `new' */
9812 RESTORE_THIS_AND_CURRENT_CLASS;
9814 #ifdef USE_MAPPED_LOCATION
9815 if (location != UNKNOWN_LOCATION)
9820 tree arguments = NULL_TREE;
9821 if (TREE_CODE (qual_wfl) == CALL_EXPR
9822 && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9823 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9824 check_thrown_exceptions (location, ret_decl, arguments);
9827 /* If the previous call was static and this one is too,
9828 build a compound expression to hold the two (because in
9829 that case, previous function calls aren't transported as
9830 forcoming function's argument. */
9831 if (previous_call_static && is_static)
9833 /* We must set CAN_COMPLETE_NORMALLY for the first call
9834 since it is done nowhere else. */
9835 CAN_COMPLETE_NORMALLY (decl) = 1;
9836 decl = build2 (COMPOUND_EXPR, TREE_TYPE (*where_found),
9837 decl, *where_found);
9838 TREE_SIDE_EFFECTS (decl) = 1;
9842 previous_call_static = is_static;
9843 decl = *where_found;
9848 case NEW_ARRAY_EXPR:
9849 case NEW_ANONYMOUS_ARRAY_EXPR:
9850 *where_found = decl = java_complete_tree (qual_wfl);
9851 if (decl == error_mark_node)
9853 *type_found = type = QUAL_DECL_TYPE (decl);
9857 *where_found = decl = java_complete_tree (qual_wfl);
9858 if (decl == error_mark_node)
9860 *type_found = type = QUAL_DECL_TYPE (decl);
9864 case CONDITIONAL_EXPR:
9867 *where_found = decl = java_complete_tree (qual_wfl);
9868 if (decl == error_mark_node)
9870 *type_found = type = QUAL_DECL_TYPE (decl);
9874 /* If the access to the function call is a non static field,
9875 build the code to access it. */
9876 if (JDECL_P (decl) && !FIELD_STATIC (decl))
9878 decl = maybe_access_field (decl, *where_found, type);
9879 if (decl == error_mark_node)
9882 /* And code for the array reference expression */
9883 decl = java_complete_tree (qual_wfl);
9884 if (decl == error_mark_node)
9886 type = QUAL_DECL_TYPE (decl);
9890 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9892 if ((type = patch_string (decl)))
9894 *where_found = QUAL_RESOLUTION (q) = decl;
9895 *type_found = type = TREE_TYPE (decl);
9899 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9901 *where_found = QUAL_RESOLUTION (q) = decl;
9902 *type_found = type = TREE_TYPE (decl);
9906 /* Fix for -Wall Just go to the next statement. Don't
9911 /* If we fall here, we weren't processing a (static) function call. */
9912 previous_call_static = 0;
9914 /* It can be the keyword THIS */
9915 if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9916 && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9921 (wfl, "Keyword %<this%> used outside allowed context");
9924 if (ctxp->explicit_constructor_p
9925 && type == current_class)
9927 parse_error_context (wfl, "Can't reference %<this%> before the superclass constructor has been called");
9930 /* We have to generate code for intermediate access */
9931 if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9933 *where_found = decl = current_this;
9934 *type_found = type = QUAL_DECL_TYPE (decl);
9936 /* We're trying to access the this from somewhere else. Make sure
9937 it's allowed before doing so. */
9940 if (!enclosing_context_p (type, current_class))
9942 char *p = xstrdup (lang_printable_name (type, 0));
9943 parse_error_context (qual_wfl, "Can't use variable %<%s.this%>: type %qs isn't an outer type of type %qs",
9945 lang_printable_name (current_class, 0));
9949 from_qualified_this = 1;
9950 /* If there's nothing else after that, we need to
9951 produce something now, otherwise, the section of the
9952 code that needs to produce <T>.this will generate
9953 what is necessary. */
9954 if (!TREE_CHAIN (q))
9956 decl = build_access_to_thisn (current_class, type, 0);
9957 *where_found = decl = java_complete_tree (decl);
9958 *type_found = type = TREE_TYPE (decl);
9966 /* 15.10.2 Accessing Superclass Members using SUPER */
9967 if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9968 && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9971 /* Check on the restricted use of SUPER */
9972 if (METHOD_STATIC (current_function_decl)
9973 || current_class == object_type_node)
9976 (wfl, "Keyword %<super%> used outside allowed context");
9979 /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9980 node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9981 CLASSTYPE_SUPER (current_class),
9982 build_this (EXPR_WFL_LINECOL (qual_wfl)));
9983 *where_found = decl = java_complete_tree (node);
9984 if (decl == error_mark_node)
9986 *type_found = type = QUAL_DECL_TYPE (decl);
9987 from_super = from_type = 1;
9991 /* 15.13.1: Can't search for field name in packages, so we
9992 assume a variable/class name was meant. */
9993 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9996 if ((decl = resolve_package (wfl, &q, &name)))
9999 *where_found = decl;
10001 check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
10003 /* We want to be absolutely sure that the class is laid
10004 out. We're going to search something inside it. */
10005 *type_found = type = TREE_TYPE (decl);
10006 layout_class (type);
10009 /* Fix them all the way down, if any are left. */
10012 list = TREE_CHAIN (q);
10015 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
10016 list = TREE_CHAIN (list);
10022 if (from_super || from_cast)
10023 parse_error_context
10024 ((from_cast ? qual_wfl : wfl),
10025 "No variable %qs defined in class %qs",
10026 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
10027 lang_printable_name (type, 0));
10029 parse_error_context
10030 (qual_wfl, "Undefined variable or class name: %qs",
10031 IDENTIFIER_POINTER (name));
10036 /* We have a type name. It's been already resolved when the
10037 expression was qualified. */
10038 else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
10040 decl = QUAL_RESOLUTION (q);
10042 /* Sneak preview. If next we see a `new', we're facing a
10043 qualification which resulted in a type being selected
10044 instead of a field. Report the error. */
10046 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
10048 parse_error_context (qual_wfl, "Undefined variable %qs",
10049 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10053 check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
10055 check_deprecation (qual_wfl, decl);
10057 type = TREE_TYPE (decl);
10060 /* We resolve an expression name */
10063 tree field_decl = NULL_TREE;
10065 /* If there exists an early resolution, use it. That occurs
10066 only once and we know that there are more things to
10067 come. Don't do that when processing something after SUPER
10068 (we need more thing to be put in place below */
10069 if (!from_super && QUAL_RESOLUTION (q))
10071 decl = QUAL_RESOLUTION (q);
10074 if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
10077 *where_found = current_this;
10080 static_ref_err (qual_wfl, DECL_NAME (decl),
10084 if (outer_field_access_p (current_class, decl))
10085 decl = build_outer_field_access (qual_wfl, decl);
10089 *where_found = TREE_TYPE (decl);
10090 if (TREE_CODE (*where_found) == POINTER_TYPE)
10091 *where_found = TREE_TYPE (*where_found);
10096 /* Report and error if we're using a numerical literal as a
10097 qualifier. It can only be an INTEGER_CST. */
10098 else if (TREE_CODE (qual_wfl) == INTEGER_CST)
10100 parse_error_context
10101 (wfl, "Can't use type %qs as a qualifier",
10102 lang_printable_name (TREE_TYPE (qual_wfl), 0));
10106 /* We have to search for a field, knowing the type of its
10107 container. The flag FROM_TYPE indicates that we resolved
10108 the last member of the expression as a type name, which
10109 means that for the resolution of this field, we'll look
10110 for other errors than if it was resolved as a member of
10115 tree field_decl_type; /* For layout */
10117 if (!from_type && !JREFERENCE_TYPE_P (type))
10119 parse_error_context
10120 (qual_wfl, "Attempt to reference field %qs in %<%s %s%>",
10121 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
10122 lang_printable_name (type, 0),
10123 IDENTIFIER_POINTER (DECL_NAME (decl)));
10127 field_decl = lookup_field_wrapper (type,
10128 EXPR_WFL_NODE (qual_wfl));
10130 /* Maybe what we're trying to access to is an inner
10131 class, only if decl is a TYPE_DECL. */
10132 if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
10134 tree ptr, inner_decl;
10136 BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
10137 inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
10140 check_inner_class_access (inner_decl, decl, qual_wfl);
10141 type = TREE_TYPE (inner_decl);
10148 if (field_decl == NULL_TREE)
10150 parse_error_context
10151 (qual_wfl, "No variable %qs defined in type %qs",
10152 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
10153 GET_TYPE_NAME (type));
10156 if (field_decl == error_mark_node)
10159 /* Layout the type of field_decl, since we may need
10160 it. Don't do primitive types or loaded classes. The
10161 situation of non primitive arrays may not handled
10162 properly here. FIXME */
10163 if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
10164 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
10166 field_decl_type = TREE_TYPE (field_decl);
10167 if (!JPRIMITIVE_TYPE_P (field_decl_type)
10168 && !CLASS_LOADED_P (field_decl_type)
10169 && !TYPE_ARRAY_P (field_decl_type))
10170 resolve_and_layout (field_decl_type, NULL_TREE);
10172 /* Check on accessibility here */
10173 if (not_accessible_p (current_class, field_decl,
10174 *type_found, from_super))
10175 return not_accessible_field_error (qual_wfl,field_decl);
10176 check_deprecation (qual_wfl, field_decl);
10178 /* There are things to check when fields are accessed
10179 from type. There are no restrictions on a static
10180 declaration of the field when it is accessed from an
10182 is_static = FIELD_STATIC (field_decl);
10183 if (!from_super && from_type
10184 && !TYPE_INTERFACE_P (type)
10186 && (current_function_decl
10187 && METHOD_STATIC (current_function_decl)))
10189 static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
10192 from_cast = from_super = 0;
10194 /* It's an access from a type but it isn't static, we
10195 make it relative to `this'. */
10196 if (!is_static && from_type)
10197 decl = current_this;
10199 /* If we need to generate something to get a proper
10200 handle on what this field is accessed from, do it
10204 decl = maybe_access_field (decl, *where_found, *type_found);
10205 if (decl == error_mark_node)
10209 /* We want to keep the location were found it, and the type
10211 *where_found = decl;
10212 *type_found = type;
10214 /* Generate the correct expression for field access from
10216 if (from_qualified_this)
10218 field_decl = build_outer_field_access (qual_wfl, field_decl);
10219 from_qualified_this = 0;
10222 /* This is the decl found and eventually the next one to
10227 type = QUAL_DECL_TYPE (decl);
10229 /* Sneak preview. If decl is qualified by a `new', report
10230 the error here to be accurate on the peculiar construct */
10232 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10233 && !JREFERENCE_TYPE_P (type))
10235 parse_error_context (qual_wfl, "Attempt to reference field %<new%> in a %qs",
10236 lang_printable_name (type, 0));
10240 /* `q' might have changed due to a after package resolution
10241 re-qualification */
10245 *found_decl = decl;
10249 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10250 can't be accessed from REFERENCE (a record type). If MEMBER
10251 features a protected access, we then use WHERE which, if non null,
10252 holds the type of MEMBER's access that is checked against
10253 6.6.2.1. This function should be used when decl is a field or a
10257 not_accessible_p (tree reference, tree member, tree where, int from_super)
10259 int access_flag = get_access_flags_from_decl (member);
10260 bool is_static = false;
10262 if (TREE_CODE (member) == FIELD_DECL ||
10263 TREE_CODE (member) == VAR_DECL)
10264 is_static = FIELD_STATIC (member);
10266 is_static = METHOD_STATIC (member);
10268 /* Access always granted for members declared public */
10269 if (access_flag & ACC_PUBLIC)
10272 /* Check access on protected members */
10273 if (access_flag & ACC_PROTECTED)
10275 /* Access granted if it occurs from within the package
10276 containing the class in which the protected member is
10278 if (class_in_current_package (DECL_CONTEXT (member)))
10281 /* If accessed with the form `super.member', then access is granted */
10285 /* If WHERE is active, access was made through a qualifier. For
10286 non-static members, access is granted if the type of the qualifier
10287 is or is a sublass of the type the access is made from (6.6.2.1.) */
10288 if (where && !is_static)
10292 if (inherits_from_p (where, reference))
10294 if (INNER_CLASS_TYPE_P (reference))
10295 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10302 /* Otherwise, access is granted if occurring from within the class
10303 where member is declared, or a subclass of it. */
10306 if (inherits_from_p (reference, DECL_CONTEXT (member)))
10308 if (INNER_CLASS_TYPE_P (reference))
10309 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10316 /* Check access on private members. Access is granted only if it
10317 occurs from within the class in which it is declared -- that does
10318 it for innerclasses too. */
10319 if (access_flag & ACC_PRIVATE)
10321 if (reference == DECL_CONTEXT (member) ||
10322 common_enclosing_context_p (DECL_CONTEXT (member), reference))
10327 /* Default access is permitted only when occurring from within the
10328 package in which the context (MEMBER) is declared. */
10329 return !class_in_current_package (DECL_CONTEXT (member));
10332 /* Test deprecated decl access. */
10334 check_deprecation (tree wfl, tree decl)
10339 if (! warn_deprecated)
10342 /* We want to look at the element type of arrays here, so we strip
10343 all surrounding array types. */
10344 if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10346 elt = TREE_TYPE (decl);
10347 while (TYPE_ARRAY_P (elt))
10348 elt = TYPE_ARRAY_ELEMENT (elt);
10349 /* We'll end up with a pointer type, so we use TREE_TYPE to go
10351 decl = TYPE_NAME (TREE_TYPE (elt));
10353 file = DECL_SOURCE_FILE (decl);
10355 /* Complain if the field is deprecated and the file it was defined
10356 in isn't compiled at the same time the file which contains its
10358 if (DECL_DEPRECATED (decl)
10359 && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10362 switch (TREE_CODE (decl))
10364 case FUNCTION_DECL:
10372 parse_warning_context (wfl, "The class %qs has been deprecated",
10373 IDENTIFIER_POINTER (DECL_NAME (decl)));
10378 /* Don't issue a message if the context as been deprecated as a
10380 if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10381 parse_warning_context
10382 (wfl, "The %s %qs in class %qs has been deprecated",
10383 the, lang_printable_name (decl, 0),
10384 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10388 /* Returns 1 if class was declared in the current package, 0 otherwise */
10390 static GTY(()) tree cicp_cache;
10392 class_in_current_package (tree class)
10394 int qualified_flag;
10397 if (cicp_cache == class)
10400 qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10402 /* If the current package is empty and the name of CLASS is
10403 qualified, class isn't in the current package. If there is a
10404 current package and the name of the CLASS is not qualified, class
10405 isn't in the current package */
10406 if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10409 /* If there is not package and the name of CLASS isn't qualified,
10410 they belong to the same unnamed package */
10411 if (!ctxp->package && !qualified_flag)
10414 /* Compare the left part of the name of CLASS with the package name */
10415 split_qualified_name (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10416 if (ctxp->package == left)
10418 cicp_cache = class;
10424 /* This function may generate code to access DECL from WHERE. This is
10425 done only if certain conditions meet. */
10428 maybe_access_field (tree decl, tree where, tree type)
10430 if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10431 && !FIELD_STATIC (decl))
10432 decl = build_field_ref (where ? where : current_this,
10433 (type ? type : DECL_CONTEXT (decl)),
10438 /* Build a method invocation, by patching PATCH. If non NULL
10439 and according to the situation, PRIMARY and WHERE may be
10440 used. IS_STATIC is set to 1 if the invoked function is static. */
10443 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10444 int *is_static, tree *ret_decl)
10446 tree wfl = TREE_OPERAND (patch, 0);
10447 tree args = TREE_OPERAND (patch, 1);
10448 tree name = EXPR_WFL_NODE (wfl);
10450 int is_static_flag = 0;
10451 int is_super_init = 0;
10452 tree this_arg = NULL_TREE;
10453 int is_array_clone_call = 0;
10455 /* Should be overridden if everything goes well. Otherwise, if
10456 something fails, it should keep this value. It stop the
10457 evaluation of a bogus assignment. See java_complete_tree,
10458 MODIFY_EXPR: for the reasons why we sometimes want to keep on
10459 evaluating an assignment */
10460 TREE_TYPE (patch) = error_mark_node;
10462 /* Since lookup functions are messing with line numbers, save the
10464 java_parser_context_save_global ();
10466 /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10468 /* Resolution of qualified name, excluding constructors */
10469 if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10471 tree identifier, identifier_wfl, type, resolved;
10472 /* Extract the last IDENTIFIER of the qualified
10473 expression. This is a wfl and we will use it's location
10474 data during error report. */
10475 identifier_wfl = cut_identifier_in_qualified (wfl);
10476 identifier = EXPR_WFL_NODE (identifier_wfl);
10478 /* Given the context, IDENTIFIER is syntactically qualified
10479 as a MethodName. We need to qualify what's before */
10480 qualify_ambiguous_name (wfl);
10481 resolved = resolve_field_access (wfl, NULL, NULL);
10483 if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10484 && FIELD_FINAL (resolved)
10485 && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10486 && !flag_emit_class_files && !flag_emit_xref)
10487 resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10489 if (resolved == error_mark_node)
10490 PATCH_METHOD_RETURN_ERROR ();
10492 type = GET_SKIP_TYPE (resolved);
10493 resolve_and_layout (type, NULL_TREE);
10495 if (JPRIMITIVE_TYPE_P (type))
10497 parse_error_context
10499 "Can't invoke a method on primitive type %qs",
10500 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10501 PATCH_METHOD_RETURN_ERROR ();
10504 list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10505 args = nreverse (args);
10507 /* We're resolving a call from a type */
10508 if (TREE_CODE (resolved) == TYPE_DECL)
10510 if (CLASS_INTERFACE (resolved))
10512 parse_error_context
10514 "Can't make static reference to method %qs in interface %qs",
10515 IDENTIFIER_POINTER (identifier),
10516 IDENTIFIER_POINTER (name));
10517 PATCH_METHOD_RETURN_ERROR ();
10519 if (list && !METHOD_STATIC (list))
10521 char *fct_name = xstrdup (lang_printable_name (list, 2));
10522 parse_error_context
10524 "Can't make static reference to method %<%s %s%> in class %qs",
10525 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10526 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10528 PATCH_METHOD_RETURN_ERROR ();
10532 this_arg = primary = resolved;
10534 if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10535 is_array_clone_call = 1;
10537 /* IDENTIFIER_WFL will be used to report any problem further */
10538 wfl = identifier_wfl;
10540 /* Resolution of simple names, names generated after a primary: or
10544 tree class_to_search = NULL_TREE;
10545 int lc; /* Looking for Constructor */
10547 /* We search constructor in their target class */
10548 if (CALL_CONSTRUCTOR_P (patch))
10550 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10551 class_to_search = EXPR_WFL_NODE (wfl);
10552 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10553 this_identifier_node)
10554 class_to_search = NULL_TREE;
10555 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10556 super_identifier_node)
10559 if (CLASSTYPE_SUPER (current_class))
10561 DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10564 parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10565 PATCH_METHOD_RETURN_ERROR ();
10569 /* Class to search is NULL if we're searching the current one */
10570 if (class_to_search)
10572 class_to_search = resolve_and_layout (class_to_search, wfl);
10574 if (!class_to_search)
10576 parse_error_context
10577 (wfl, "Class %qs not found in type declaration",
10578 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10579 PATCH_METHOD_RETURN_ERROR ();
10582 /* Can't instantiate an abstract class, but we can
10583 invoke it's constructor. It's use within the `new'
10584 context is denied here. */
10585 if (CLASS_ABSTRACT (class_to_search)
10586 && TREE_CODE (patch) == NEW_CLASS_EXPR)
10588 parse_error_context
10589 (wfl, "Class %qs is an abstract class. It can't be instantiated",
10590 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10591 PATCH_METHOD_RETURN_ERROR ();
10594 class_to_search = TREE_TYPE (class_to_search);
10597 class_to_search = current_class;
10600 /* This is a regular search in the local class, unless an
10601 alternate class is specified. */
10604 if (where != NULL_TREE)
10605 class_to_search = where;
10606 else if (QUALIFIED_P (name))
10607 class_to_search = current_class;
10610 class_to_search = current_class;
10614 if (has_method (class_to_search, name))
10616 if (! INNER_CLASS_TYPE_P (class_to_search))
10618 parse_error_context (wfl,
10619 "No method named %qs in scope",
10620 IDENTIFIER_POINTER (name));
10621 PATCH_METHOD_RETURN_ERROR ();
10624 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10630 /* NAME is a simple identifier or comes from a primary. Search
10631 in the class whose declaration contain the method being
10633 resolve_and_layout (class_to_search, NULL_TREE);
10635 list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10636 /* Don't continue if no method were found, as the next statement
10637 can't be executed then. */
10639 PATCH_METHOD_RETURN_ERROR ();
10641 if (TYPE_ARRAY_P (class_to_search)
10642 && DECL_NAME (list) == get_identifier ("clone"))
10643 is_array_clone_call = 1;
10645 /* Check for static reference if non static methods */
10646 if (check_for_static_method_reference (wfl, patch, list,
10647 class_to_search, primary))
10648 PATCH_METHOD_RETURN_ERROR ();
10650 /* Check for inner classes creation from illegal contexts */
10651 if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10652 && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10653 && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10654 && !DECL_INIT_P (current_function_decl))
10656 parse_error_context
10657 (wfl, "No enclosing instance for inner class %qs is in scope%s",
10658 lang_printable_name (class_to_search, 0),
10659 (!current_this ? "" :
10660 "; an explicit one must be provided when creating this inner class"));
10661 PATCH_METHOD_RETURN_ERROR ();
10664 /* Non static methods are called with the current object extra
10665 argument. If patch a `new TYPE()', the argument is the value
10666 returned by the object allocator. If method is resolved as a
10667 primary, use the primary otherwise use the current THIS. */
10668 args = nreverse (args);
10669 if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10671 this_arg = primary ? primary : current_this;
10673 /* If we're using an access method, things are different.
10674 There are two family of cases:
10676 1) We're not generating bytecodes:
10678 - LIST is non static. It's invocation is transformed from
10679 x(a1,...,an) into this$<n>.x(a1,....an).
10680 - LIST is static. It's invocation is transformed from
10681 x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10683 2) We're generating bytecodes:
10685 - LIST is non static. It's invocation is transformed from
10686 x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10687 - LIST is static. It's invocation is transformed from
10688 x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10690 Of course, this$<n> can be arbitrarily complex, ranging from
10691 this$0 (the immediate outer context) to
10692 access$0(access$0(...(this$0))).
10694 maybe_use_access_method returns a nonzero value if the
10695 this_arg has to be moved into the (then generated) stub
10696 argument list. In the meantime, the selected function
10697 might have be replaced by a generated stub. */
10699 maybe_use_access_method (is_super_init, &list, &this_arg))
10701 args = tree_cons (NULL_TREE, this_arg, args);
10702 this_arg = NULL_TREE; /* So it doesn't get chained twice */
10707 /* Merge point of all resolution schemes. If we have nothing, this
10708 is an error, already signaled */
10710 PATCH_METHOD_RETURN_ERROR ();
10712 /* Check accessibility, position the is_static flag, build and
10714 if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10715 (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10716 NULL_TREE), from_super)
10717 /* Calls to clone() on array types are permitted as a special-case. */
10718 && !is_array_clone_call)
10720 const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10721 const char *const access =
10722 accessibility_string (get_access_flags_from_decl (list));
10723 const char *const klass =
10724 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10725 const char *const refklass =
10726 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10727 const char *const what = (DECL_CONSTRUCTOR_P (list)
10728 ? "constructor" : "method");
10729 parse_error_context (wfl,
10730 "Can't access %s %s %<%s.%s%> from %qs",
10731 access, what, klass, fct_name, refklass);
10732 PATCH_METHOD_RETURN_ERROR ();
10735 /* Deprecation check: check whether the method being invoked or the
10736 instance-being-created's type are deprecated. */
10737 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10738 check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10739 check_deprecation (wfl, list);
10741 /* If invoking a innerclass constructor, there are hidden parameters
10743 if (TREE_CODE (patch) == NEW_CLASS_EXPR
10744 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10746 /* And make sure we add the accessed local variables to be saved
10747 in field aliases. */
10748 args = build_alias_initializer_parameter_list
10749 (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10751 /* Secretly pass the current_this/primary as a second argument */
10752 if (primary || current_this)
10755 tree this_type = (current_this ?
10756 TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10757 /* Method's (list) enclosing context */
10758 tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10759 /* If we have a primary, use it. */
10761 extra_arg = primary;
10762 /* The current `this' is an inner class but isn't a direct
10763 enclosing context for the inner class we're trying to
10764 create. Build an access to the proper enclosing context
10766 else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10767 && this_type != TREE_TYPE (mec))
10770 extra_arg = build_access_to_thisn (current_class,
10771 TREE_TYPE (mec), 0);
10772 extra_arg = java_complete_tree (extra_arg);
10774 /* Otherwise, just use the current `this' as an enclosing
10777 extra_arg = current_this;
10778 args = tree_cons (NULL_TREE, extra_arg, args);
10781 args = tree_cons (NULL_TREE, integer_zero_node, args);
10784 /* This handles the situation where a constructor invocation needs
10785 to have an enclosing context passed as a second parameter (the
10786 constructor is one of an inner class). */
10787 if ((is_super_init ||
10788 (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10789 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10791 tree dest = TYPE_NAME (DECL_CONTEXT (list));
10793 build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10794 extra_arg = java_complete_tree (extra_arg);
10795 args = tree_cons (NULL_TREE, extra_arg, args);
10798 is_static_flag = METHOD_STATIC (list);
10799 if (! is_static_flag && this_arg != NULL_TREE)
10800 args = tree_cons (NULL_TREE, this_arg, args);
10802 /* In the context of an explicit constructor invocation, we can't
10803 invoke any method relying on `this'. Exceptions are: we're
10804 invoking a static function, primary exists and is not the current
10805 this, we're creating a new object. */
10806 if (ctxp->explicit_constructor_p
10808 && (!primary || primary == current_this)
10809 && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10811 parse_error_context (wfl, "Can't reference %<this%> before the superclass constructor has been called");
10812 PATCH_METHOD_RETURN_ERROR ();
10814 java_parser_context_restore_global ();
10816 *is_static = is_static_flag;
10817 /* Sometimes, we want the decl of the selected method. Such as for
10821 patch = patch_invoke (patch, list, args);
10823 /* Now is a good time to insert the call to finit$ */
10824 if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10826 tree finit_parms, finit_call;
10828 /* Prepare to pass hidden parameters to finit$, if any. */
10829 finit_parms = build_alias_initializer_parameter_list
10830 (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10833 build_method_invocation (build_wfl_node (finit_identifier_node),
10836 /* Generate the code used to initialize fields declared with an
10837 initialization statement and build a compound statement along
10838 with the super constructor invocation. */
10839 CAN_COMPLETE_NORMALLY (patch) = 1;
10840 patch = build2 (COMPOUND_EXPR, void_type_node, patch,
10841 java_complete_tree (finit_call));
10846 /* Check that we're not trying to do a static reference to a method in
10847 non static method. Return 1 if it's the case, 0 otherwise. */
10850 check_for_static_method_reference (tree wfl, tree node, tree method,
10851 tree where, tree primary)
10853 if (METHOD_STATIC (current_function_decl)
10854 && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10856 char *fct_name = xstrdup (lang_printable_name (method, 0));
10857 parse_error_context
10858 (wfl, "Can't make static reference to method %<%s %s%> in class %qs",
10859 lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10860 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10867 /* Fix the invocation of *MDECL if necessary in the case of a
10868 invocation from an inner class. *THIS_ARG might be modified
10869 appropriately and an alternative access to *MDECL might be
10873 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10876 tree md = *mdecl, ta = *this_arg;
10878 int non_static_context = !METHOD_STATIC (md);
10881 || DECL_CONTEXT (md) == current_class
10882 || !PURE_INNER_CLASS_TYPE_P (current_class)
10883 || DECL_FINIT_P (md)
10884 || DECL_INSTINIT_P (md))
10887 /* If we're calling a method found in an enclosing class, generate
10888 what it takes to retrieve the right this. Don't do that if we're
10889 invoking a static method. Note that if MD's type is unrelated to
10890 CURRENT_CLASS, then the current this can be used. */
10892 if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10894 ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10895 if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10897 ta = build_current_thisn (current_class);
10898 ta = build_wfl_node (ta);
10905 maybe_build_thisn_access_method (type);
10906 if (inherits_from_p (type, DECL_CONTEXT (md)))
10908 ta = build_access_to_thisn (ctx, type, 0);
10911 type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10912 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10915 ta = java_complete_tree (ta);
10918 /* We might have to use an access method to get to MD. We can
10919 break the method access rule as far as we're not generating
10921 if (METHOD_PRIVATE (md) && flag_emit_class_files)
10923 md = build_outer_method_access_method (md);
10930 /* Returning a nonzero value indicates we were doing a non static
10931 method invocation that is now a static invocation. It will have
10932 callee displace `this' to insert it in the regular argument
10934 return (non_static_context && to_return);
10937 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10941 patch_invoke (tree patch, tree method, tree args)
10944 tree original_call, t, ta;
10945 tree check = NULL_TREE;
10947 /* Last step for args: convert build-in types. If we're dealing with
10948 a new TYPE() type call, the first argument to the constructor
10949 isn't found in the incoming argument list, but delivered by
10951 t = TYPE_ARG_TYPES (TREE_TYPE (method));
10952 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10953 t = TREE_CHAIN (t);
10954 for (ta = args; t != end_params_node && ta;
10955 t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10956 if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10957 TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10958 TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10960 /* Resolve unresolved returned type issues */
10961 t = TREE_TYPE (TREE_TYPE (method));
10962 if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10963 resolve_and_layout (TREE_TYPE (t), NULL);
10965 if (flag_emit_class_files || flag_emit_xref)
10969 switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10971 case INVOKE_VIRTUAL:
10972 dtable = invoke_build_dtable (0, args);
10973 func = build_invokevirtual (dtable, method);
10976 case INVOKE_NONVIRTUAL:
10977 /* If the object for the method call is null, we throw an
10978 exception. We don't do this if the object is the current
10979 method's `this'. In other cases we just rely on an
10980 optimization pass to eliminate redundant checks. */
10981 if (TREE_VALUE (args) != current_this)
10983 /* We use a save_expr here to make sure we only evaluate
10984 the new `self' expression once. */
10985 tree save_arg = save_expr (TREE_VALUE (args));
10986 TREE_VALUE (args) = save_arg;
10987 check = java_check_reference (save_arg, 1);
10989 /* Fall through. */
10992 case INVOKE_STATIC:
10994 tree signature = build_java_signature (TREE_TYPE (method));
10995 func = build_known_method_ref (method, TREE_TYPE (method),
10996 DECL_CONTEXT (method),
11001 case INVOKE_INTERFACE:
11002 dtable = invoke_build_dtable (1, args);
11003 func = build_invokeinterface (dtable, method);
11010 /* Ensure self_type is initialized, (invokestatic). FIXME */
11011 func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
11014 TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
11015 TREE_OPERAND (patch, 0) = func;
11016 TREE_OPERAND (patch, 1) = args;
11017 patch = check_for_builtin (method, patch);
11018 original_call = patch;
11020 /* We're processing a `new TYPE ()' form. New is called and its
11021 returned value is the first argument to the constructor. We build
11022 a COMPOUND_EXPR and use saved expression so that the overall NEW
11023 expression value is a pointer to a newly created and initialized
11025 if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
11027 tree class = DECL_CONTEXT (method);
11028 tree c1, saved_new, size, new;
11031 if (flag_emit_class_files || flag_emit_xref)
11033 TREE_TYPE (patch) = build_pointer_type (class);
11036 if (!TYPE_SIZE (class))
11037 safe_layout_class (class);
11038 size = size_in_bytes (class);
11040 (class_has_finalize_method (class) ? alloc_object_node
11041 : alloc_no_finalizer_node);
11042 new = build3 (CALL_EXPR, promote_type (class),
11043 build_address_of (alloc_node),
11044 build_tree_list (NULL_TREE, build_class_ref (class)),
11046 saved_new = save_expr (new);
11047 c1 = build_tree_list (NULL_TREE, saved_new);
11048 TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
11049 TREE_OPERAND (original_call, 1) = c1;
11050 TREE_SET_CODE (original_call, CALL_EXPR);
11051 patch = build2 (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
11054 /* If CHECK is set, then we are building a check to see if the object
11056 if (check != NULL_TREE)
11058 /* We have to call force_evaluation_order now because creating a
11059 COMPOUND_EXPR wraps the arg list in a way that makes it
11060 unrecognizable by force_evaluation_order later. Yuk. */
11061 patch = build2 (COMPOUND_EXPR, TREE_TYPE (patch), check,
11062 force_evaluation_order (patch));
11063 TREE_SIDE_EFFECTS (patch) = 1;
11066 /* In order to be able to modify PATCH later, we SAVE_EXPR it and
11067 put it as the first expression of a COMPOUND_EXPR. The second
11068 expression being an empty statement to be later patched if
11069 necessary. We remember a TREE_LIST (the PURPOSE is the method,
11070 the VALUE is the compound) in a hashtable and return a
11071 COMPOUND_EXPR built so that the result of the evaluation of the
11072 original PATCH node is returned. */
11073 if (STATIC_CLASS_INIT_OPT_P ()
11074 && current_function_decl && METHOD_STATIC (method))
11077 tree fndecl = current_function_decl;
11078 /* We have to call force_evaluation_order now because creating a
11079 COMPOUND_EXPR wraps the arg list in a way that makes it
11080 unrecognizable by force_evaluation_order later. Yuk. */
11081 tree save = force_evaluation_order (patch);
11082 tree type = TREE_TYPE (patch);
11084 patch = build2 (COMPOUND_EXPR, type, save, build_java_empty_stmt ());
11085 list = tree_cons (method, patch,
11086 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
11088 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
11090 patch = build2 (COMPOUND_EXPR, type, patch, save);
11097 invocation_mode (tree method, int super)
11099 int access = get_access_flags_from_decl (method);
11102 return INVOKE_SUPER;
11104 if (access & ACC_STATIC)
11105 return INVOKE_STATIC;
11107 /* We have to look for a constructor before we handle nonvirtual
11108 calls; otherwise the constructor will look nonvirtual. */
11109 if (DECL_CONSTRUCTOR_P (method))
11110 return INVOKE_STATIC;
11112 if (access & ACC_FINAL || access & ACC_PRIVATE)
11113 return INVOKE_NONVIRTUAL;
11115 if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
11116 return INVOKE_NONVIRTUAL;
11118 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
11119 return INVOKE_INTERFACE;
11121 return INVOKE_VIRTUAL;
11124 /* Retrieve a refined list of matching methods. It covers the step
11125 15.11.2 (Compile-Time Step 2) */
11128 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
11130 tree atl = end_params_node; /* Arg Type List */
11131 tree method, signature, list, node;
11132 const char *candidates; /* Used for error report */
11135 /* Fix the arguments */
11136 for (node = arg_list; node; node = TREE_CHAIN (node))
11138 tree current_arg = TREE_TYPE (TREE_VALUE (node));
11139 /* Non primitive type may have to be resolved */
11140 if (!JPRIMITIVE_TYPE_P (current_arg))
11141 resolve_and_layout (current_arg, NULL_TREE);
11143 if (TREE_CODE (current_arg) == RECORD_TYPE)
11144 current_arg = promote_type (current_arg);
11145 atl = tree_cons (NULL_TREE, current_arg, atl);
11148 /* Presto. If we're dealing with an anonymous class and a
11149 constructor call, generate the right constructor now, since we
11150 know the arguments' types. */
11152 if (lc && ANONYMOUS_CLASS_P (class))
11154 tree mdecl = craft_constructor (TYPE_NAME (class), atl);
11155 /* The anonymous class may have already been laid out, so make sure
11156 the new constructor is laid out here. */
11157 layout_class_method (class, CLASSTYPE_SUPER (class), mdecl, NULL_TREE);
11160 /* Find all candidates and then refine the list, searching for the
11161 most specific method. */
11162 list = find_applicable_accessible_methods_list (lc, class, name, atl);
11163 list = find_most_specific_methods_list (list);
11164 if (list && !TREE_CHAIN (list))
11165 return TREE_VALUE (list);
11167 /* Issue an error. List candidates if any. Candidates are listed
11168 only if accessible (non accessible methods may end-up here for
11169 the sake of a better error report). */
11174 obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
11175 for (current = list; current; current = TREE_CHAIN (current))
11177 tree cm = TREE_VALUE (current);
11178 char string [4096];
11179 if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
11182 (string, " '%s' in '%s'%s",
11183 get_printable_method_name (cm),
11184 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
11185 (TREE_CHAIN (current) ? "\n" : ""));
11186 obstack_grow (&temporary_obstack, string, strlen (string));
11188 obstack_1grow (&temporary_obstack, '\0');
11189 candidates = obstack_finish (&temporary_obstack);
11191 /* Issue the error message */
11192 method = make_node (FUNCTION_TYPE);
11193 TYPE_ARG_TYPES (method) = atl;
11194 signature = build_java_argument_signature (method);
11195 dup = xstrdup (lang_printable_name (class, 0));
11196 parse_error_context (cl, "Can't find %s %<%s(%s)%> in type %qs%s",
11197 (lc ? "constructor" : "method"),
11198 (lc ? dup : IDENTIFIER_POINTER (name)),
11199 IDENTIFIER_POINTER (signature), dup,
11200 (candidates ? candidates : ""));
11205 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11206 when we're looking for a constructor. */
11209 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11212 static htab_t searched_classes;
11213 static int search_not_done = 0;
11214 tree list = NULL_TREE, all_list = NULL_TREE;
11218 /* Check the hash table to determine if this class has been searched
11220 if (searched_classes)
11222 if (htab_find (searched_classes, class) != NULL)
11227 searched_classes = htab_create (10, htab_hash_pointer,
11228 htab_eq_pointer, NULL);
11232 *htab_find_slot (searched_classes, class, INSERT) = class;
11234 if (!CLASS_LOADED_P (class))
11236 load_class (class, 1);
11237 safe_layout_class (class);
11240 /* Search interfaces */
11241 if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11242 && CLASS_INTERFACE (TYPE_NAME (class)))
11244 search_applicable_methods_list (lc, TYPE_METHODS (class),
11245 name, arglist, &list, &all_list);
11246 for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11248 tree t = BINFO_TYPE (base_binfo);
11251 rlist = find_applicable_accessible_methods_list (lc, t, name,
11253 list = chainon (rlist, list);
11256 /* Search classes */
11259 search_applicable_methods_list (lc, TYPE_METHODS (class),
11260 name, arglist, &list, &all_list);
11262 /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11263 that we only search in class. Note that we should have found
11264 something at this point. */
11265 if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11272 /* We must search all interfaces of this class */
11276 BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11278 tree t = BINFO_TYPE (base_binfo);
11279 if (t != object_type_node)
11282 = find_applicable_accessible_methods_list (lc, t,
11284 list = chainon (rlist, list);
11289 /* Search superclass */
11290 if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11293 class = CLASSTYPE_SUPER (class);
11294 rlist = find_applicable_accessible_methods_list (lc, class,
11296 list = chainon (rlist, list);
11302 /* We're done. Reset the searched classes list and finally search
11303 java.lang.Object if it wasn't searched already. */
11304 if (!search_not_done)
11307 && TYPE_METHODS (object_type_node)
11308 && htab_find (searched_classes, object_type_node) == NULL)
11310 search_applicable_methods_list (lc,
11311 TYPE_METHODS (object_type_node),
11312 name, arglist, &list, &all_list);
11314 htab_delete (searched_classes);
11315 searched_classes = NULL;
11318 /* Either return the list obtained or all selected (but
11319 inaccessible) methods for better error report. */
11320 return (!list ? all_list : list);
11323 /* Effectively search for the appropriate method in method */
11326 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11327 tree *list, tree *all_list)
11329 for (; method; method = TREE_CHAIN (method))
11331 /* When dealing with constructor, stop here, otherwise search
11333 if (lc && !DECL_CONSTRUCTOR_P (method))
11335 else if (!lc && (DECL_CONSTRUCTOR_P (method)
11336 || (DECL_NAME (method) != name)))
11339 if (argument_types_convertible (method, arglist))
11341 /* Retain accessible methods only */
11342 if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11343 method, NULL_TREE, 0))
11344 *list = tree_cons (NULL_TREE, method, *list);
11346 /* Also retain all selected method here */
11347 *all_list = tree_cons (NULL_TREE, method, *list);
11352 /* 15.11.2.2 Choose the Most Specific Method */
11355 find_most_specific_methods_list (tree list)
11358 int abstract, candidates;
11359 tree current, new_list = NULL_TREE;
11360 for (current = list; current; current = TREE_CHAIN (current))
11363 DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11365 for (method = list; method; method = TREE_CHAIN (method))
11367 tree method_v, current_v;
11368 /* Don't test a method against itself */
11369 if (method == current)
11372 method_v = TREE_VALUE (method);
11373 current_v = TREE_VALUE (current);
11375 /* Compare arguments and location where methods where declared */
11376 if (argument_types_convertible (method_v, current_v))
11378 if (valid_method_invocation_conversion_p
11379 (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11380 || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11381 && enclosing_context_p (DECL_CONTEXT (method_v),
11382 DECL_CONTEXT (current_v))))
11384 int v = (DECL_SPECIFIC_COUNT (current_v) +=
11385 (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11386 max = (v > max ? v : max);
11392 /* Review the list and select the maximally specific methods */
11393 for (current = list, abstract = -1, candidates = -1;
11394 current; current = TREE_CHAIN (current))
11395 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11397 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11398 abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11402 /* If we have several and they're all abstract, just pick the
11404 if (candidates > 0 && candidates == abstract)
11406 /* FIXME: merge the throws clauses. There is no convenient way
11407 to do this in gcj right now, since ideally we'd like to
11408 introduce a new METHOD_DECL here, but that is really not
11410 new_list = nreverse (new_list);
11411 TREE_CHAIN (new_list) = NULL_TREE;
11415 /* We have several (we couldn't find a most specific), all but one
11416 are abstract, we pick the only non abstract one. */
11417 if (candidates > 0 && (candidates == abstract+1))
11419 for (current = new_list; current; current = TREE_CHAIN (current))
11420 if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11422 TREE_CHAIN (current) = NULL_TREE;
11423 new_list = current;
11427 /* If we can't find one, lower expectations and try to gather multiple
11428 maximally specific methods */
11429 while (!new_list && max)
11433 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11434 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11441 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11442 converted by method invocation conversion (5.3) to the type of the
11443 corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11444 to change less often than M1. */
11446 static GTY(()) tree m2_arg_value;
11447 static GTY(()) tree m2_arg_cache;
11450 argument_types_convertible (tree m1, tree m2_or_arglist)
11452 tree m1_arg, m2_arg;
11454 SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11456 if (m2_arg_value == m2_or_arglist)
11457 m2_arg = m2_arg_cache;
11460 /* M2_OR_ARGLIST can be a function DECL or a raw list of
11462 if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11464 m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11465 if (!METHOD_STATIC (m2_or_arglist))
11466 m2_arg = TREE_CHAIN (m2_arg);
11469 m2_arg = m2_or_arglist;
11471 m2_arg_value = m2_or_arglist;
11472 m2_arg_cache = m2_arg;
11475 while (m1_arg != end_params_node && m2_arg != end_params_node)
11477 resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11478 if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11479 TREE_VALUE (m2_arg)))
11481 m1_arg = TREE_CHAIN (m1_arg);
11482 m2_arg = TREE_CHAIN (m2_arg);
11484 return m1_arg == end_params_node && m2_arg == end_params_node;
11487 /* Qualification routines */
11489 /* Given a name x.y.z, look up x locally. If it's found, save the
11490 decl. If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11491 so that we later try and load the appropriate classes. */
11493 qualify_ambiguous_name (tree id)
11497 /* We inspect the first item of the qualification list. As a sanity
11498 check, make sure that it is an identfier node. */
11499 tree qual = EXPR_WFL_QUALIFICATION (id);
11500 tree qual_wfl = QUAL_WFL (qual);
11502 if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11505 name = EXPR_WFL_NODE (qual_wfl);
11507 /* If we don't have an identifier, or we have a 'this' or 'super',
11508 then field access processing is all we need : there is nothing
11510 if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11511 name == this_identifier_node ||
11512 name == super_identifier_node)
11515 /* If name appears within the scope of a local variable declaration
11516 or parameter declaration, or is a field within an enclosing
11517 class, then it is an expression name. Save the decl and let
11518 resolve_field_access do it's work. */
11519 if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11520 (decl = lookup_field_wrapper (current_class, name)))
11522 QUAL_RESOLUTION (qual) = decl;
11526 /* If name is a known class name (either declared or imported), mark
11527 us as a type name. */
11528 if ((decl = resolve_and_layout (name, NULL_TREE)))
11530 RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11531 QUAL_RESOLUTION (qual) = decl;
11534 /* Check here that NAME isn't declared by more than one
11535 type-import-on-demand declaration of the compilation unit
11536 containing NAME. FIXME */
11538 /* We couldn't find a declaration for the name. Assume for now that
11539 we have a qualified class name that needs to be loaded from an
11540 external class file. */
11542 RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11544 /* Propagate the qualification across other components of the
11546 for (qual = TREE_CHAIN (qual); qual;
11547 qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11549 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11550 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11553 /* Store the global qualification for the ambiguous part of ID back
11555 if (RESOLVE_TYPE_NAME_P (qual_wfl))
11556 RESOLVE_TYPE_NAME_P (id) = 1;
11557 else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11558 RESOLVE_PACKAGE_NAME_P (id) = 1;
11561 /* Patch tree nodes in a function body. When a BLOCK is found, push
11562 local variable decls if present.
11563 Same as java_complete_lhs, but does resolve static finals to values. */
11566 java_complete_tree (tree node)
11568 node = java_complete_lhs (node);
11569 if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11570 && DECL_INITIAL (node) != NULL_TREE
11571 && !flag_emit_xref)
11573 tree value = fold_constant_for_init (node, node);
11574 if (value != NULL_TREE)
11581 java_stabilize_reference (tree node)
11583 if (TREE_CODE (node) == COMPOUND_EXPR)
11585 tree op0 = TREE_OPERAND (node, 0);
11586 tree op1 = TREE_OPERAND (node, 1);
11587 TREE_OPERAND (node, 0) = save_expr (op0);
11588 TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11591 return stabilize_reference (node);
11594 /* Patch tree nodes in a function body. When a BLOCK is found, push
11595 local variable decls if present.
11596 Same as java_complete_tree, but does not resolve static finals to values. */
11599 java_complete_lhs (tree node)
11601 tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11604 /* CONVERT_EXPR always has its type set, even though it needs to be
11606 if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11609 /* The switch block implements cases processing container nodes
11610 first. Contained nodes are always written back. Leaves come
11611 next and return a value. */
11612 switch (TREE_CODE (node))
11616 /* 1- Block section.
11617 Set the local values on decl names so we can identify them
11618 faster when they're referenced. At that stage, identifiers
11619 are legal so we don't check for declaration errors. */
11620 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11622 DECL_CONTEXT (cn) = current_function_decl;
11623 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11625 if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11626 CAN_COMPLETE_NORMALLY (node) = 1;
11629 tree stmt = BLOCK_EXPR_BODY (node);
11631 int error_seen = 0;
11632 if (TREE_CODE (stmt) == COMPOUND_EXPR)
11634 /* Re-order from (((A; B); C); ...; Z) to
11635 (A; (B; (C ; (...; Z)))).
11636 This makes it easier to scan the statements left-to-right
11637 without using recursion (which might overflow the stack
11638 if the block has many statements. */
11641 tree left = TREE_OPERAND (stmt, 0);
11642 if (TREE_CODE (left) != COMPOUND_EXPR)
11644 TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11645 TREE_OPERAND (left, 1) = stmt;
11648 BLOCK_EXPR_BODY (node) = stmt;
11651 /* Now do the actual complete, without deep recursion for
11653 ptr = &BLOCK_EXPR_BODY (node);
11654 while (TREE_CODE (*ptr) == COMPOUND_EXPR
11655 && !IS_EMPTY_STMT (TREE_OPERAND (*ptr, 1)))
11657 tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11658 tree *next = &TREE_OPERAND (*ptr, 1);
11659 TREE_OPERAND (*ptr, 0) = cur;
11660 if (IS_EMPTY_STMT (cur))
11662 /* Optimization; makes it easier to detect empty bodies.
11663 Most useful for <clinit> with all-constant initializer. */
11667 if (TREE_CODE (cur) == ERROR_MARK)
11669 else if (! CAN_COMPLETE_NORMALLY (cur))
11674 if (TREE_CODE (wfl_op2) == BLOCK)
11675 wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11676 else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11677 wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11681 if (TREE_CODE (wfl_op2) != CASE_EXPR
11682 && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11683 unreachable_stmt_error (*ptr);
11685 if (TREE_TYPE (*ptr) == NULL_TREE)
11686 TREE_TYPE (*ptr) = void_type_node;
11689 *ptr = java_complete_tree (*ptr);
11691 if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11692 return error_mark_node;
11693 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11695 /* Turn local bindings to null */
11696 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11697 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11699 TREE_TYPE (node) = void_type_node;
11702 /* 2- They are expressions but ultimately deal with statements */
11705 wfl_op1 = TREE_OPERAND (node, 0);
11706 COMPLETE_CHECK_OP_0 (node);
11707 /* 14.19 A throw statement cannot complete normally. */
11708 CAN_COMPLETE_NORMALLY (node) = 0;
11709 return patch_throw_statement (node, wfl_op1);
11711 case SYNCHRONIZED_EXPR:
11712 wfl_op1 = TREE_OPERAND (node, 0);
11713 return patch_synchronized_statement (node, wfl_op1);
11716 return patch_try_statement (node);
11718 case TRY_FINALLY_EXPR:
11719 COMPLETE_CHECK_OP_0 (node);
11720 COMPLETE_CHECK_OP_1 (node);
11721 if (IS_EMPTY_STMT (TREE_OPERAND (node, 0)))
11722 /* Reduce try/finally nodes with an empty try block. */
11723 return TREE_OPERAND (node, 1);
11724 if (IS_EMPTY_STMT (TREE_OPERAND (node, 1)))
11725 /* Likewise for an empty finally block. */
11726 return TREE_OPERAND (node, 0);
11727 CAN_COMPLETE_NORMALLY (node)
11728 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11729 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11730 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11733 case LABELED_BLOCK_EXPR:
11734 PUSH_LABELED_BLOCK (node);
11735 if (LABELED_BLOCK_BODY (node))
11736 COMPLETE_CHECK_OP_1 (node);
11737 TREE_TYPE (node) = void_type_node;
11738 POP_LABELED_BLOCK ();
11740 if (IS_EMPTY_STMT (LABELED_BLOCK_BODY (node)))
11742 LABELED_BLOCK_BODY (node) = NULL_TREE;
11743 CAN_COMPLETE_NORMALLY (node) = 1;
11745 else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11746 CAN_COMPLETE_NORMALLY (node) = 1;
11749 case EXIT_BLOCK_EXPR:
11750 return patch_bc_statement (node);
11753 cn = java_complete_tree (TREE_OPERAND (node, 0));
11754 if (cn == error_mark_node)
11757 /* First, the case expression must be constant. Values of final
11758 fields are accepted. */
11760 if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11761 && JDECL_P (TREE_OPERAND (cn, 1))
11762 && FIELD_FINAL (TREE_OPERAND (cn, 1))
11763 && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11765 cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11766 TREE_OPERAND (cn, 1));
11768 /* Accept final locals too. */
11769 else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
11770 && DECL_INITIAL (cn))
11771 cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11773 if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11775 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11776 parse_error_context (node, "Constant expression required");
11777 return error_mark_node;
11780 nn = ctxp->current_loop;
11782 /* It must be assignable to the type of the switch expression. */
11783 if (!try_builtin_assignconv (NULL_TREE,
11784 TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11786 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11787 parse_error_context
11789 "Incompatible type for case. Can't convert %qs to %<int%>",
11790 lang_printable_name (TREE_TYPE (cn), 0));
11791 return error_mark_node;
11794 cn = fold (convert (int_type_node, cn));
11795 TREE_CONSTANT_OVERFLOW (cn) = 0;
11796 CAN_COMPLETE_NORMALLY (cn) = 1;
11798 /* Save the label on a list so that we can later check for
11800 case_label_list = tree_cons (node, cn, case_label_list);
11802 /* Multiple instance of a case label bearing the same value is
11803 checked later. The case expression is all right so far. */
11804 if (TREE_CODE (cn) == VAR_DECL)
11805 cn = DECL_INITIAL (cn);
11806 TREE_OPERAND (node, 0) = cn;
11807 TREE_TYPE (node) = void_type_node;
11808 CAN_COMPLETE_NORMALLY (node) = 1;
11809 TREE_SIDE_EFFECTS (node) = 1;
11813 nn = ctxp->current_loop;
11814 /* Only one default label is allowed per switch statement */
11815 if (SWITCH_HAS_DEFAULT (nn))
11817 #ifdef USE_MAPPED_LOCATION
11818 SET_EXPR_LOCATION (wfl_operator, EXPR_LOCATION (node));
11820 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11822 parse_error_context (wfl_operator,
11823 "Duplicate case label: %<default%>");
11824 return error_mark_node;
11827 SWITCH_HAS_DEFAULT (nn) = 1;
11828 TREE_TYPE (node) = void_type_node;
11829 TREE_SIDE_EFFECTS (node) = 1;
11830 CAN_COMPLETE_NORMALLY (node) = 1;
11836 /* Check whether the loop was enclosed in a labeled
11837 statement. If not, create one, insert the loop in it and
11839 nn = patch_loop_statement (node);
11841 /* Anyways, walk the body of the loop */
11842 if (TREE_CODE (node) == LOOP_EXPR)
11843 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11844 /* Switch statement: walk the switch expression and the cases */
11846 node = patch_switch_statement (node);
11848 if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11849 nn = error_mark_node;
11852 TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11853 /* If we returned something different, that's because we
11854 inserted a label. Pop the label too. */
11857 if (CAN_COMPLETE_NORMALLY (node))
11858 CAN_COMPLETE_NORMALLY (nn) = 1;
11859 POP_LABELED_BLOCK ();
11866 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11867 return patch_exit_expr (node);
11871 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11872 if (TREE_OPERAND (node, 0) == error_mark_node)
11873 return error_mark_node;
11874 /* then-else branches */
11875 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11876 if (TREE_OPERAND (node, 1) == error_mark_node)
11877 return error_mark_node;
11879 /* This is a special case due to build_assertion(). When
11880 assertions are disabled we build a COND_EXPR in which
11881 Operand 1 is the body of the assertion. If that happens to
11882 be a string concatenation we'll need to patch it here. */
11883 tree patched = patch_string (TREE_OPERAND (node, 1));
11885 TREE_OPERAND (node, 1) = patched;
11887 TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11888 if (TREE_OPERAND (node, 2) == error_mark_node)
11889 return error_mark_node;
11890 return patch_if_else_statement (node);
11893 case CONDITIONAL_EXPR:
11895 wfl_op1 = TREE_OPERAND (node, 0);
11896 COMPLETE_CHECK_OP_0 (node);
11897 wfl_op2 = TREE_OPERAND (node, 1);
11898 COMPLETE_CHECK_OP_1 (node);
11899 wfl_op3 = TREE_OPERAND (node, 2);
11900 COMPLETE_CHECK_OP_2 (node);
11901 return patch_conditional_expr (node, wfl_op1, wfl_op2);
11903 /* 3- Expression section */
11904 case COMPOUND_EXPR:
11905 wfl_op2 = TREE_OPERAND (node, 1);
11906 TREE_OPERAND (node, 0) = nn =
11907 java_complete_tree (TREE_OPERAND (node, 0));
11908 if (IS_EMPTY_STMT (wfl_op2))
11909 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11912 if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11914 /* An unreachable condition in a do-while statement
11915 is *not* (technically) an unreachable statement. */
11917 if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11918 nn = EXPR_WFL_NODE (nn);
11919 /* NN can be NULL_TREE exactly when UPDATE is, in
11920 finish_for_loop. */
11921 if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11923 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11924 if (SUPPRESS_UNREACHABLE_ERROR (nn))
11926 /* Perhaps this warning should have an
11927 associated flag. The code being compiled is
11928 pedantically correct, but useless. */
11929 parse_warning_context (wfl_operator,
11930 "Unreachable statement");
11933 parse_error_context (wfl_operator,
11934 "Unreachable statement");
11937 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11938 if (TREE_OPERAND (node, 1) == error_mark_node)
11939 return error_mark_node;
11940 /* Even though we might allow the case where the first
11941 operand doesn't return normally, we still should compute
11942 CAN_COMPLETE_NORMALLY correctly. */
11943 CAN_COMPLETE_NORMALLY (node)
11944 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11945 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11947 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11951 /* CAN_COMPLETE_NORMALLY (node) = 0; */
11952 return patch_return (node);
11954 case EXPR_WITH_FILE_LOCATION:
11955 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11956 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11959 node = resolve_expression_name (node, NULL);
11960 if (node == error_mark_node)
11962 /* Keep line number information somewhere were it doesn't
11963 disrupt the completion process. */
11964 if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11966 EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11967 TREE_OPERAND (node, 1) = wfl;
11969 CAN_COMPLETE_NORMALLY (node) = 1;
11974 location_t save_location = input_location;
11975 #ifdef USE_MAPPED_LOCATION
11976 input_location = EXPR_LOCATION (node);
11977 if (input_location == UNKNOWN_LOCATION)
11978 input_location = save_location;
11980 input_line = EXPR_WFL_LINENO (node);
11982 body = java_complete_tree (EXPR_WFL_NODE (node));
11983 input_location = save_location;
11984 EXPR_WFL_NODE (node) = body;
11985 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11986 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11987 if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
11989 /* Makes it easier to constant fold, detect empty bodies. */
11992 if (body == error_mark_node)
11994 /* Its important for the evaluation of assignment that
11995 this mark on the TREE_TYPE is propagated. */
11996 TREE_TYPE (node) = error_mark_node;
11997 return error_mark_node;
12000 TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
12005 case NEW_ARRAY_EXPR:
12006 /* Patch all the dimensions */
12008 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12010 int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
12011 tree dim = convert (int_type_node,
12012 java_complete_tree (TREE_VALUE (cn)));
12013 if (dim == error_mark_node)
12020 TREE_VALUE (cn) = dim;
12021 /* Setup the location of the current dimension, for
12022 later error report. */
12023 #ifdef USE_MAPPED_LOCATION
12024 TREE_PURPOSE (cn) = expr_add_location (NULL_TREE, location, 0);
12026 TREE_PURPOSE (cn) =
12027 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
12028 EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
12032 /* They complete the array creation expression, if no errors
12034 CAN_COMPLETE_NORMALLY (node) = 1;
12035 return (flag ? error_mark_node
12036 : force_evaluation_order (patch_newarray (node)));
12038 case NEW_ANONYMOUS_ARRAY_EXPR:
12039 /* Create the array type if necessary. */
12040 if (ANONYMOUS_ARRAY_DIMS_SIG (node))
12042 tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
12043 if (!(type = resolve_type_during_patch (type)))
12044 return error_mark_node;
12045 type = build_array_from_name (type, NULL_TREE,
12046 ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
12047 ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
12049 node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
12050 ANONYMOUS_ARRAY_INITIALIZER (node));
12051 if (node == error_mark_node)
12052 return error_mark_node;
12053 CAN_COMPLETE_NORMALLY (node) = 1;
12056 case NEW_CLASS_EXPR:
12058 /* Complete function's argument(s) first */
12059 if (complete_function_arguments (node))
12060 return error_mark_node;
12063 tree decl, wfl = TREE_OPERAND (node, 0);
12064 int in_this = CALL_THIS_CONSTRUCTOR_P (node);
12065 int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
12066 super_identifier_node);
12068 #ifdef USE_MAPPED_LOCATION
12069 source_location location = EXPR_LOCATION (node);
12071 int location = EXPR_WFL_LINECOL (node);
12074 node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
12075 from_super, 0, &decl);
12076 if (node == error_mark_node)
12077 return error_mark_node;
12079 if (TREE_CODE (node) == CALL_EXPR
12080 && TREE_OPERAND (node, 1) != NULL_TREE)
12081 arguments = TREE_VALUE (TREE_OPERAND (node, 1));
12083 arguments = NULL_TREE;
12084 check_thrown_exceptions (location, decl, arguments);
12085 /* If we call this(...), register signature and positions */
12087 DECL_CONSTRUCTOR_CALLS (current_function_decl) =
12088 tree_cons (wfl, decl,
12089 DECL_CONSTRUCTOR_CALLS (current_function_decl));
12090 CAN_COMPLETE_NORMALLY (node) = 1;
12091 return force_evaluation_order (node);
12095 /* Save potential wfls */
12096 wfl_op1 = TREE_OPERAND (node, 0);
12097 TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
12099 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
12100 && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
12101 && DECL_INITIAL (nn) != NULL_TREE)
12105 value = fold_constant_for_init (nn, nn);
12107 /* When we have a primitype type, or a string and we're not
12108 emitting a class file, we actually don't want to generate
12109 anything for the assignment. */
12110 if (value != NULL_TREE &&
12111 (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
12112 (TREE_TYPE (value) == string_ptr_type_node &&
12113 ! flag_emit_class_files)))
12115 /* Prepare node for patch_assignment */
12116 TREE_OPERAND (node, 1) = value;
12117 /* Call patch assignment to verify the assignment */
12118 if (patch_assignment (node, wfl_op1) == error_mark_node)
12119 return error_mark_node;
12120 /* Set DECL_INITIAL properly (a conversion might have
12121 been decided by patch_assignment) and return the
12122 empty statement. */
12125 tree patched = patch_string (TREE_OPERAND (node, 1));
12127 DECL_INITIAL (nn) = patched;
12129 DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12130 DECL_FIELD_FINAL_IUD (nn) = 1;
12131 return build_java_empty_stmt ();
12134 if (! flag_emit_class_files)
12135 DECL_INITIAL (nn) = NULL_TREE;
12137 wfl_op2 = TREE_OPERAND (node, 1);
12139 if (TREE_OPERAND (node, 0) == error_mark_node)
12140 return error_mark_node;
12142 flag = COMPOUND_ASSIGN_P (wfl_op2);
12145 /* This might break when accessing outer field from inner
12146 class. TESTME, FIXME */
12147 tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12149 /* Hand stabilize the lhs on both places */
12150 TREE_OPERAND (node, 0) = lvalue;
12151 TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12152 (flag_emit_class_files ? lvalue : save_expr (lvalue));
12154 /* 15.25.2.a: Left hand is not an array access. FIXME */
12155 /* Now complete the RHS. We write it back later on. */
12156 nn = java_complete_tree (TREE_OPERAND (node, 1));
12158 if ((cn = patch_string (nn)))
12161 /* The last part of the rewrite for E1 op= E2 is to have
12162 E1 = (T)(E1 op E2), with T being the type of E1. */
12163 nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12164 TREE_TYPE (lvalue), nn));
12166 /* If the assignment is compound and has reference type,
12167 then ensure the LHS has type String and nothing else. */
12168 if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12169 && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12170 parse_error_context (wfl_op2,
12171 "Incompatible type for %<+=%>. Can't convert %qs to %<java.lang.String%>",
12172 lang_printable_name (TREE_TYPE (lvalue), 0));
12174 /* 15.25.2.b: Left hand is an array access. FIXME */
12177 /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12178 function to complete this RHS. Note that a NEW_ARRAY_INIT
12179 might have been already fully expanded if created as a result
12180 of processing an anonymous array initializer. We avoid doing
12181 the operation twice by testing whether the node already bears
12183 else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12184 nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12185 TREE_OPERAND (node, 1));
12186 /* Otherwise we simply complete the RHS */
12188 nn = java_complete_tree (TREE_OPERAND (node, 1));
12190 if (nn == error_mark_node)
12191 return error_mark_node;
12193 /* Write back the RHS as we evaluated it. */
12194 TREE_OPERAND (node, 1) = nn;
12196 /* In case we're handling = with a String as a RHS, we need to
12197 produce a String out of the RHS (it might still be a
12198 STRING_CST or a StringBuffer at this stage */
12199 if ((nn = patch_string (TREE_OPERAND (node, 1))))
12200 TREE_OPERAND (node, 1) = nn;
12202 if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12203 TREE_OPERAND (node, 1))))
12205 /* We return error_mark_node if outer_field_access_fix
12206 detects we write into a final. */
12207 if (nn == error_mark_node)
12208 return error_mark_node;
12213 node = patch_assignment (node, wfl_op1);
12214 if (node == error_mark_node)
12215 return error_mark_node;
12216 /* Reorganize the tree if necessary. */
12217 if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12218 || JSTRING_P (TREE_TYPE (node))))
12219 node = java_refold (node);
12222 /* Seek to set DECL_INITIAL to a proper value, since it might have
12223 undergone a conversion in patch_assignment. We do that only when
12224 it's necessary to have DECL_INITIAL properly set. */
12225 nn = TREE_OPERAND (node, 0);
12226 if (TREE_CODE (nn) == VAR_DECL
12227 && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12228 && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12229 && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12230 || TREE_TYPE (nn) == string_ptr_type_node))
12231 DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12233 CAN_COMPLETE_NORMALLY (node) = 1;
12245 case TRUNC_MOD_EXPR:
12246 case TRUNC_DIV_EXPR:
12248 case TRUTH_ANDIF_EXPR:
12249 case TRUTH_ORIF_EXPR:
12256 /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12257 knows how to handle those cases. */
12258 wfl_op1 = TREE_OPERAND (node, 0);
12259 wfl_op2 = TREE_OPERAND (node, 1);
12261 CAN_COMPLETE_NORMALLY (node) = 1;
12262 /* Don't complete string nodes if dealing with the PLUS operand. */
12263 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12265 nn = java_complete_tree (wfl_op1);
12266 if (nn == error_mark_node)
12267 return error_mark_node;
12269 TREE_OPERAND (node, 0) = nn;
12271 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12273 nn = java_complete_tree (wfl_op2);
12274 if (nn == error_mark_node)
12275 return error_mark_node;
12277 TREE_OPERAND (node, 1) = nn;
12279 return patch_binop (node, wfl_op1, wfl_op2);
12281 case INSTANCEOF_EXPR:
12282 wfl_op1 = TREE_OPERAND (node, 0);
12283 COMPLETE_CHECK_OP_0 (node);
12284 if (flag_emit_xref)
12286 TREE_TYPE (node) = boolean_type_node;
12289 return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12291 case UNARY_PLUS_EXPR:
12293 case TRUTH_NOT_EXPR:
12295 case PREDECREMENT_EXPR:
12296 case PREINCREMENT_EXPR:
12297 case POSTDECREMENT_EXPR:
12298 case POSTINCREMENT_EXPR:
12300 /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12301 how to handle those cases. */
12302 wfl_op1 = TREE_OPERAND (node, 0);
12303 CAN_COMPLETE_NORMALLY (node) = 1;
12304 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12305 if (TREE_OPERAND (node, 0) == error_mark_node)
12306 return error_mark_node;
12307 node = patch_unaryop (node, wfl_op1);
12308 CAN_COMPLETE_NORMALLY (node) = 1;
12312 /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12313 how to handle those cases. */
12314 wfl_op1 = TREE_OPERAND (node, 0);
12315 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12316 if (TREE_OPERAND (node, 0) == error_mark_node)
12317 return error_mark_node;
12318 if (!flag_emit_class_files && !flag_emit_xref)
12319 TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12320 /* The same applies to wfl_op2 */
12321 wfl_op2 = TREE_OPERAND (node, 1);
12322 TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12323 if (TREE_OPERAND (node, 1) == error_mark_node)
12324 return error_mark_node;
12325 if (!flag_emit_class_files && !flag_emit_xref)
12326 TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12327 return patch_array_ref (node);
12332 case COMPONENT_REF:
12333 /* The first step in the re-write of qualified name handling. FIXME.
12334 So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12335 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12336 if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12338 tree name = TREE_OPERAND (node, 1);
12339 tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12340 if (field == NULL_TREE)
12342 error ("missing static field %qs", IDENTIFIER_POINTER (name));
12343 return error_mark_node;
12345 if (! FIELD_STATIC (field))
12347 error ("not a static field %qs", IDENTIFIER_POINTER (name));
12348 return error_mark_node;
12357 /* Can't use THIS in a static environment */
12360 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12361 parse_error_context (wfl_operator,
12362 "Keyword %<this%> used outside allowed context");
12363 TREE_TYPE (node) = error_mark_node;
12364 return error_mark_node;
12366 if (ctxp->explicit_constructor_p)
12368 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12369 parse_error_context
12370 (wfl_operator, "Can't reference %<this%> or %<super%> before the superclass constructor has been called");
12371 TREE_TYPE (node) = error_mark_node;
12372 return error_mark_node;
12374 return current_this;
12376 case CLASS_LITERAL:
12377 CAN_COMPLETE_NORMALLY (node) = 1;
12378 node = patch_incomplete_class_ref (node);
12379 if (node == error_mark_node)
12380 return error_mark_node;
12384 CAN_COMPLETE_NORMALLY (node) = 1;
12385 /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12386 and it's time to turn it into the appropriate String object */
12387 if ((nn = patch_string (node)))
12390 internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12395 /* Complete function call's argument. Return a nonzero value is an
12396 error was found. */
12399 complete_function_arguments (tree node)
12404 ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12405 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12407 tree wfl = TREE_VALUE (cn), parm, temp;
12408 parm = java_complete_tree (wfl);
12410 if (parm == error_mark_node)
12415 /* If we have a string literal that we haven't transformed yet or a
12416 crafted string buffer, as a result of the use of the String
12417 `+' operator. Build `parm.toString()' and expand it. */
12418 if ((temp = patch_string (parm)))
12421 TREE_VALUE (cn) = parm;
12423 ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12427 /* Sometimes (for loops and variable initialized during their
12428 declaration), we want to wrap a statement around a WFL and turn it
12432 build_debugable_stmt (int location, tree stmt)
12434 if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12436 #ifdef USE_MAPPED_LOCATION
12437 stmt = expr_add_location (stmt, location, 1);
12439 stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12440 EXPR_WFL_LINECOL (stmt) = location;
12441 JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12448 build_expr_block (tree body, tree decls)
12450 tree node = make_node (BLOCK);
12451 BLOCK_EXPR_DECLS (node) = decls;
12452 BLOCK_EXPR_BODY (node) = body;
12454 TREE_TYPE (node) = TREE_TYPE (body);
12455 TREE_SIDE_EFFECTS (node) = 1;
12459 /* Create a new function block and link it appropriately to current
12460 function block chain */
12465 tree b = build_expr_block (NULL_TREE, NULL_TREE);
12467 /* Link block B supercontext to the previous block. The current
12468 function DECL is used as supercontext when enter_a_block is called
12469 for the first time for a given function. The current function body
12470 (DECL_FUNCTION_BODY) is set to be block B. */
12472 tree fndecl = current_function_decl;
12475 BLOCK_SUPERCONTEXT (b) = current_static_block;
12476 current_static_block = b;
12479 else if (!DECL_FUNCTION_BODY (fndecl))
12481 BLOCK_SUPERCONTEXT (b) = fndecl;
12482 DECL_FUNCTION_BODY (fndecl) = b;
12486 BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12487 DECL_FUNCTION_BODY (fndecl) = b;
12492 /* Exit a block by changing the current function body
12493 (DECL_FUNCTION_BODY) to the current block super context, only if
12494 the block being exited isn't the method's top level one. */
12500 if (current_function_decl)
12502 b = DECL_FUNCTION_BODY (current_function_decl);
12503 if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12504 DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12508 b = current_static_block;
12510 if (BLOCK_SUPERCONTEXT (b))
12511 current_static_block = BLOCK_SUPERCONTEXT (b);
12516 /* Lookup for NAME in the nested function's blocks, all the way up to
12517 the current toplevel one. It complies with Java's local variable
12521 lookup_name_in_blocks (tree name)
12523 tree b = GET_CURRENT_BLOCK (current_function_decl);
12525 while (b != current_function_decl)
12529 /* Paranoid sanity check. To be removed */
12530 if (TREE_CODE (b) != BLOCK)
12533 for (current = BLOCK_EXPR_DECLS (b); current;
12534 current = TREE_CHAIN (current))
12535 if (DECL_NAME (current) == name)
12537 b = BLOCK_SUPERCONTEXT (b);
12543 maybe_absorb_scoping_blocks (void)
12545 while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12547 tree b = exit_block ();
12548 java_method_add_stmt (current_function_decl, b);
12549 SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12554 /* This section of the source is reserved to build_* functions that
12555 are building incomplete tree nodes and the patch_* functions that
12556 are completing them. */
12558 /* Wrap a non WFL node around a WFL. */
12561 build_wfl_wrap (tree node, int location)
12563 tree wfl, node_to_insert = node;
12565 /* We want to process THIS . xxx symbolically, to keep it consistent
12566 with the way we're processing SUPER. A THIS from a primary as a
12567 different form than a SUPER. Turn THIS into something symbolic */
12568 if (TREE_CODE (node) == THIS_EXPR)
12569 node_to_insert = wfl = build_wfl_node (this_identifier_node);
12571 #ifdef USE_MAPPED_LOCATION
12572 wfl = build_unknown_wfl (NULL_TREE);
12574 SET_EXPR_LOCATION (wfl, location);
12576 wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12578 EXPR_WFL_LINECOL (wfl) = location;
12580 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12584 /* Build a super() constructor invocation. Returns an empty statement if
12585 we're currently dealing with the class java.lang.Object. */
12588 build_super_invocation (tree mdecl)
12590 if (DECL_CONTEXT (mdecl) == object_type_node)
12591 return build_java_empty_stmt ();
12594 tree super_wfl = build_wfl_node (super_identifier_node);
12595 tree a = NULL_TREE, t;
12597 /* This is called after parsing is done, so the parser context
12598 won't be accurate. Set location info from current_class decl. */
12599 tree class_wfl = lookup_cl (TYPE_NAME (current_class));
12600 EXPR_WFL_LINECOL (super_wfl) = EXPR_WFL_LINECOL (class_wfl);
12602 /* If we're dealing with an anonymous class, pass the arguments
12603 of the crafted constructor along. */
12604 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12606 SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12607 for (; t != end_params_node; t = TREE_CHAIN (t))
12608 a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12610 return build_method_invocation (super_wfl, a);
12614 /* Build a SUPER/THIS qualified method invocation. */
12617 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12618 int lloc, int rloc)
12622 build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12623 EXPR_WFL_LINECOL (wfl) = lloc;
12624 invok = build_method_invocation (name, args);
12625 return make_qualified_primary (wfl, invok, rloc);
12628 /* Build an incomplete CALL_EXPR node. */
12631 build_method_invocation (tree name, tree args)
12633 tree call = build3 (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12634 TREE_SIDE_EFFECTS (call) = 1;
12635 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12639 /* Build an incomplete new xxx(...) node. */
12642 build_new_invocation (tree name, tree args)
12644 tree call = build3 (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12645 TREE_SIDE_EFFECTS (call) = 1;
12646 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12650 /* Build an incomplete assignment expression. */
12653 build_assignment (int op, int op_location, tree lhs, tree rhs)
12656 /* Build the corresponding binop if we deal with a Compound
12657 Assignment operator. Mark the binop sub-tree as part of a
12658 Compound Assignment expression */
12659 if (op != ASSIGN_TK)
12661 rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12662 COMPOUND_ASSIGN_P (rhs) = 1;
12664 assignment = build2 (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12665 TREE_SIDE_EFFECTS (assignment) = 1;
12666 EXPR_WFL_LINECOL (assignment) = op_location;
12670 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12671 the buffer. This is used only for string conversion. */
12673 string_convert_int_cst (tree node)
12675 /* Long.MIN_VALUE is -9223372036854775808, 20 characters. */
12676 static char buffer[21];
12678 unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12679 unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12680 char *p = buffer + sizeof (buffer);
12683 unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12684 << (HOST_BITS_PER_WIDE_INT - 1));
12688 /* If negative, note the fact and negate the value. */
12698 /* Divide by 10 until there are no bits left. */
12701 unsigned HOST_WIDE_INT acc = 0;
12702 unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12705 /* Use long division to compute the result and the remainder. */
12706 for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12708 /* Shift a bit into accumulator. */
12713 /* Shift the value. */
12719 /* Shift the correct bit into the result. */
12721 if ((outlo & hibit))
12731 /* '0' == 060 in Java, but might not be here (think EBCDIC). */
12732 *--p = '\060' + acc;
12740 *--p = '\055'; /* '-' == 055 in Java, but might not be here. */
12745 /* Print an INTEGER_CST node in a static buffer, and return the
12746 buffer. This is used only for error handling. */
12748 print_int_node (tree node)
12750 static char buffer [80];
12751 if (TREE_CONSTANT_OVERFLOW (node))
12752 sprintf (buffer, "<overflow>");
12754 if (TREE_INT_CST_HIGH (node) == 0)
12755 sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12756 TREE_INT_CST_LOW (node));
12757 else if (TREE_INT_CST_HIGH (node) == -1
12758 && TREE_INT_CST_LOW (node) != 0)
12759 sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12760 -TREE_INT_CST_LOW (node));
12762 sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12763 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12769 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12772 /* 15.25 Assignment operators. */
12775 patch_assignment (tree node, tree wfl_op1)
12777 tree rhs = TREE_OPERAND (node, 1);
12778 tree lvalue = TREE_OPERAND (node, 0), llvalue;
12779 tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12780 int error_found = 0;
12781 int lvalue_from_array = 0;
12784 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12786 /* Lhs can be a named variable */
12787 if (JDECL_P (lvalue))
12789 lhs_type = TREE_TYPE (lvalue);
12791 /* Or Lhs can be an array access. */
12792 else if (TREE_CODE (lvalue) == ARRAY_REF)
12794 lhs_type = TREE_TYPE (lvalue);
12795 lvalue_from_array = 1;
12797 /* Or a field access */
12798 else if (TREE_CODE (lvalue) == COMPONENT_REF)
12799 lhs_type = TREE_TYPE (lvalue);
12800 /* Or a function return slot */
12801 else if (TREE_CODE (lvalue) == RESULT_DECL)
12803 /* If the return type is an integral type, then we create the
12804 RESULT_DECL with a promoted type, but we need to do these
12805 checks against the unpromoted type to ensure type safety. So
12806 here we look at the real type, not the type of the decl we
12808 lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12811 /* Otherwise, we might want to try to write into an optimized static
12812 final, this is an of a different nature, reported further on. */
12813 else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12814 && resolve_expression_name (wfl_op1, &llvalue))
12816 lhs_type = TREE_TYPE (lvalue);
12820 parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12824 rhs_type = TREE_TYPE (rhs);
12826 /* 5.1 Try the assignment conversion for builtin type. */
12827 new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12829 /* 5.2 If it failed, try a reference conversion */
12831 new_rhs = try_reference_assignconv (lhs_type, rhs);
12833 /* 15.25.2 If we have a compound assignment, convert RHS into the
12835 else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12836 new_rhs = convert (lhs_type, rhs);
12838 /* Explicit cast required. This is an error */
12841 char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12842 char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12844 char operation [32]; /* Max size known */
12846 /* If the assignment is part of a declaration, we use the WFL of
12847 the declared variable to point out the error and call it a
12848 declaration problem. If the assignment is a genuine =
12849 operator, we call is a operator `=' problem, otherwise we
12850 call it an assignment problem. In both of these last cases,
12851 we use the WFL of the operator to indicate the error. */
12853 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12856 strcpy (operation, "declaration");
12860 wfl = wfl_operator;
12861 if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12862 strcpy (operation, "assignment");
12863 else if (is_return)
12864 strcpy (operation, "'return'");
12866 strcpy (operation, "'='");
12869 if (!valid_cast_to_p (rhs_type, lhs_type))
12870 parse_error_context
12871 (wfl, "Incompatible type for %s. Can't convert %qs to %qs",
12872 operation, t1, t2);
12874 parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert %qs to %qs",
12875 operation, t1, t2);
12876 free (t1); free (t2);
12881 return error_mark_node;
12883 /* If we're processing a `return' statement, promote the actual type
12884 to the promoted type. */
12886 new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12888 /* 10.10: Array Store Exception runtime check */
12889 if (!flag_emit_class_files
12891 && lvalue_from_array
12892 && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12894 tree array, store_check, base, index_expr;
12896 /* Save RHS so that it doesn't get re-evaluated by the store check. */
12897 new_rhs = save_expr (new_rhs);
12899 /* Get the INDIRECT_REF. */
12900 array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12901 /* Get the array pointer expr. */
12902 array = TREE_OPERAND (array, 0);
12903 store_check = build_java_arraystore_check (array, new_rhs);
12905 index_expr = TREE_OPERAND (lvalue, 1);
12907 if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12909 /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12910 happen before the store check, so prepare to insert the store
12911 check within the second operand of the existing COMPOUND_EXPR. */
12917 index_expr = TREE_OPERAND (base, 1);
12918 TREE_OPERAND (base, 1) = build2 (COMPOUND_EXPR, TREE_TYPE (index_expr),
12919 store_check, index_expr);
12922 /* Final locals can be used as case values in switch
12923 statement. Prepare them for this eventuality. */
12924 if (TREE_CODE (lvalue) == VAR_DECL
12925 && DECL_FINAL (lvalue)
12926 && TREE_CONSTANT (new_rhs)
12927 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12928 && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12931 TREE_CONSTANT (lvalue) = 1;
12932 TREE_INVARIANT (lvalue) = 1;
12933 DECL_INITIAL (lvalue) = new_rhs;
12936 /* Copy the rhs if it's a reference. */
12937 if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12939 switch (TREE_CODE (new_rhs))
12943 case COMPONENT_REF:
12944 /* Transform a = foo.bar
12945 into a = ({int tmp; tmp = foo.bar;}).
12946 We need to ensure that if a read from memory fails
12947 because of a NullPointerException, a destination variable
12948 will remain unchanged. An explicit temporary does what
12951 If flag_check_references is set, this is unnecessary
12952 because we'll check each reference before doing any
12953 reads. If optimize is not set the result will never be
12954 written to a stack slot that contains the LHS. */
12956 tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12957 TREE_TYPE (new_rhs));
12958 tree block = make_node (BLOCK);
12960 = build2 (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12961 DECL_CONTEXT (tmp) = current_function_decl;
12962 TREE_TYPE (block) = TREE_TYPE (new_rhs);
12963 BLOCK_VARS (block) = tmp;
12964 BLOCK_EXPR_BODY (block) = assignment;
12965 TREE_SIDE_EFFECTS (block) = 1;
12974 TREE_OPERAND (node, 0) = lvalue;
12975 TREE_OPERAND (node, 1) = new_rhs;
12976 TREE_TYPE (node) = lhs_type;
12980 /* Check that type SOURCE can be cast into type DEST. If the cast
12981 can't occur at all, return NULL; otherwise, return a possibly
12985 try_reference_assignconv (tree lhs_type, tree rhs)
12987 tree new_rhs = NULL_TREE;
12988 tree rhs_type = TREE_TYPE (rhs);
12990 if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12992 /* `null' may be assigned to any reference type */
12993 if (rhs == null_pointer_node)
12994 new_rhs = null_pointer_node;
12995 /* Try the reference assignment conversion */
12996 else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12998 /* This is a magic assignment that we process differently */
12999 else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
13005 /* Check that RHS can be converted into LHS_TYPE by the assignment
13006 conversion (5.2), for the cases of RHS being a builtin type. Return
13007 NULL_TREE if the conversion fails or if because RHS isn't of a
13008 builtin type. Return a converted RHS if the conversion is possible. */
13011 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
13013 tree new_rhs = NULL_TREE;
13014 tree rhs_type = TREE_TYPE (rhs);
13016 /* Handle boolean specially. */
13017 if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
13018 || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
13020 if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
13021 && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
13025 /* 5.1.1 Try Identity Conversion,
13026 5.1.2 Try Widening Primitive Conversion */
13027 else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
13028 new_rhs = convert (lhs_type, rhs);
13030 /* Try a narrowing primitive conversion (5.1.3):
13031 - expression is a constant expression of type byte, short, char,
13033 - variable is byte, short or char AND
13034 - The value of the expression is representable in the type of the
13036 else if ((rhs_type == byte_type_node || rhs_type == short_type_node
13037 || rhs_type == char_type_node || rhs_type == int_type_node)
13038 && TREE_CONSTANT (rhs)
13039 && (lhs_type == byte_type_node || lhs_type == char_type_node
13040 || lhs_type == short_type_node))
13042 if (int_fits_type_p (rhs, lhs_type))
13043 new_rhs = convert (lhs_type, rhs);
13044 else if (wfl_op1) /* Might be called with a NULL */
13045 parse_warning_context
13047 "Constant expression %qs too wide for narrowing primitive conversion to %qs",
13048 print_int_node (rhs), lang_printable_name (lhs_type, 0));
13049 /* Reported a warning that will turn into an error further
13050 down, so we don't return */
13056 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
13057 conversion (5.1.1) or widening primitive conversion (5.1.2). Return
13058 0 is the conversion test fails. This implements parts the method
13059 invocation conversion (5.3). */
13062 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
13064 /* 5.1.1: This is the identity conversion part. */
13065 if (lhs_type == rhs_type)
13068 /* Reject non primitive types and boolean conversions. */
13069 if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
13072 /* 5.1.2: widening primitive conversion. byte, even if it's smaller
13073 than a char can't be converted into a char. Short can't too, but
13074 the < test below takes care of that */
13075 if (lhs_type == char_type_node && rhs_type == byte_type_node)
13078 /* Accept all promoted type here. Note, we can't use <= in the test
13079 below, because we still need to bounce out assignments of short
13080 to char and the likes */
13081 if (lhs_type == int_type_node
13082 && (rhs_type == promoted_byte_type_node
13083 || rhs_type == promoted_short_type_node
13084 || rhs_type == promoted_char_type_node
13085 || rhs_type == promoted_boolean_type_node))
13088 /* From here, an integral is widened if its precision is smaller
13089 than the precision of the LHS or if the LHS is a floating point
13090 type, or the RHS is a float and the RHS a double. */
13091 if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
13092 && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
13093 || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
13094 || (rhs_type == float_type_node && lhs_type == double_type_node))
13100 /* Check that something of SOURCE type can be assigned or cast to
13101 something of DEST type at runtime. Return 1 if the operation is
13102 valid, 0 otherwise. If CAST is set to 1, we're treating the case
13103 were SOURCE is cast into DEST, which borrows a lot of the
13104 assignment check. */
13107 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
13109 /* SOURCE or DEST might be null if not from a declared entity. */
13110 if (!source || !dest)
13112 if (JNULLP_TYPE_P (source))
13114 if (TREE_CODE (source) == POINTER_TYPE)
13115 source = TREE_TYPE (source);
13116 if (TREE_CODE (dest) == POINTER_TYPE)
13117 dest = TREE_TYPE (dest);
13119 /* If source and dest are being compiled from bytecode, they may need to
13121 if (CLASS_P (source) && !CLASS_LOADED_P (source))
13123 load_class (source, 1);
13124 safe_layout_class (source);
13126 if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
13128 load_class (dest, 1);
13129 safe_layout_class (dest);
13132 /* Case where SOURCE is a class type */
13133 if (TYPE_CLASS_P (source))
13135 if (TYPE_CLASS_P (dest))
13136 return (source == dest
13137 || inherits_from_p (source, dest)
13138 || (cast && inherits_from_p (dest, source)));
13139 if (TYPE_INTERFACE_P (dest))
13141 /* If doing a cast and SOURCE is final, the operation is
13142 always correct a compile time (because even if SOURCE
13143 does not implement DEST, a subclass of SOURCE might). */
13144 if (cast && !CLASS_FINAL (TYPE_NAME (source)))
13146 /* Otherwise, SOURCE must implement DEST */
13147 return interface_of_p (dest, source);
13149 /* DEST is an array, cast permitted if SOURCE is of Object type */
13150 return (cast && source == object_type_node ? 1 : 0);
13152 if (TYPE_INTERFACE_P (source))
13154 if (TYPE_CLASS_P (dest))
13156 /* If not casting, DEST must be the Object type */
13158 return dest == object_type_node;
13159 /* We're doing a cast. The cast is always valid is class
13160 DEST is not final, otherwise, DEST must implement SOURCE */
13161 else if (!CLASS_FINAL (TYPE_NAME (dest)))
13164 return interface_of_p (source, dest);
13166 if (TYPE_INTERFACE_P (dest))
13168 /* If doing a cast, then if SOURCE and DEST contain method
13169 with the same signature but different return type, then
13170 this is a (compile time) error */
13173 tree method_source, method_dest;
13177 for (method_source = TYPE_METHODS (source); method_source;
13178 method_source = TREE_CHAIN (method_source))
13181 build_java_argument_signature (TREE_TYPE (method_source));
13182 source_type = TREE_TYPE (TREE_TYPE (method_source));
13183 source_name = DECL_NAME (method_source);
13184 for (method_dest = TYPE_METHODS (dest);
13185 method_dest; method_dest = TREE_CHAIN (method_dest))
13187 build_java_argument_signature (TREE_TYPE (method_dest))
13188 && source_name == DECL_NAME (method_dest)
13189 && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13195 return source == dest || interface_of_p (dest, source);
13201 && (DECL_NAME (TYPE_NAME (source))
13202 == java_lang_cloneable_identifier_node
13203 || (DECL_NAME (TYPE_NAME (source))
13204 == java_io_serializable_identifier_node)));
13207 if (TYPE_ARRAY_P (source))
13209 if (TYPE_CLASS_P (dest))
13210 return dest == object_type_node;
13211 /* Can't cast an array to an interface unless the interface is
13212 java.lang.Cloneable or java.io.Serializable. */
13213 if (TYPE_INTERFACE_P (dest))
13214 return (DECL_NAME (TYPE_NAME (dest))
13215 == java_lang_cloneable_identifier_node
13216 || (DECL_NAME (TYPE_NAME (dest))
13217 == java_io_serializable_identifier_node));
13220 tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13221 tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13223 /* In case of severe errors, they turn out null */
13224 if (!dest_element_type || !source_element_type)
13226 if (source_element_type == dest_element_type)
13228 return valid_ref_assignconv_cast_p (source_element_type,
13229 dest_element_type, cast);
13237 valid_cast_to_p (tree source, tree dest)
13239 if (TREE_CODE (source) == POINTER_TYPE)
13240 source = TREE_TYPE (source);
13241 if (TREE_CODE (dest) == POINTER_TYPE)
13242 dest = TREE_TYPE (dest);
13244 if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13245 return valid_ref_assignconv_cast_p (source, dest, 1);
13247 else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13250 else if (TREE_CODE (source) == BOOLEAN_TYPE
13251 && TREE_CODE (dest) == BOOLEAN_TYPE)
13258 do_unary_numeric_promotion (tree arg)
13260 tree type = TREE_TYPE (arg);
13261 if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13262 || TREE_CODE (type) == CHAR_TYPE)
13263 arg = convert (int_type_node, arg);
13267 /* Return a nonzero value if SOURCE can be converted into DEST using
13268 the method invocation conversion rule (5.3). */
13270 valid_method_invocation_conversion_p (tree dest, tree source)
13272 return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13273 && valid_builtin_assignconv_identity_widening_p (dest, source))
13274 || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13275 && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13276 && valid_ref_assignconv_cast_p (source, dest, 0)));
13279 /* Build an incomplete binop expression. */
13282 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13284 tree binop = build2 (op, NULL_TREE, op1, op2);
13285 TREE_SIDE_EFFECTS (binop) = 1;
13286 /* Store the location of the operator, for better error report. The
13287 string of the operator will be rebuild based on the OP value. */
13288 EXPR_WFL_LINECOL (binop) = op_location;
13292 /* Build the string of the operator retained by NODE. If NODE is part
13293 of a compound expression, add an '=' at the end of the string. This
13294 function is called when an error needs to be reported on an
13295 operator. The string is returned as a pointer to a static character
13299 operator_string (tree node)
13301 #define BUILD_OPERATOR_STRING(S) \
13303 sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13307 static char buffer [10];
13308 switch (TREE_CODE (node))
13310 case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13311 case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13312 case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13313 case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13314 case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13315 case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13316 case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13317 case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13318 case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13319 case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13320 case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13321 case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13322 case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13323 case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13324 case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13325 case GT_EXPR: BUILD_OPERATOR_STRING (">");
13326 case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13327 case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13328 case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13329 case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13330 case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13331 case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13332 case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13333 case PREINCREMENT_EXPR: /* Fall through */
13334 case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13335 case PREDECREMENT_EXPR: /* Fall through */
13336 case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13338 internal_error ("unregistered operator %s",
13339 tree_code_name [TREE_CODE (node)]);
13342 #undef BUILD_OPERATOR_STRING
13345 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
13348 java_decl_equiv (tree var_acc1, tree var_acc2)
13350 if (JDECL_P (var_acc1))
13351 return (var_acc1 == var_acc2);
13353 return (TREE_CODE (var_acc1) == COMPONENT_REF
13354 && TREE_CODE (var_acc2) == COMPONENT_REF
13355 && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13356 == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13357 && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13360 /* Return a nonzero value if CODE is one of the operators that can be
13361 used in conjunction with the `=' operator in a compound assignment. */
13364 binop_compound_p (enum tree_code code)
13367 for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13368 if (binop_lookup [i] == code)
13371 return i < BINOP_COMPOUND_CANDIDATES;
13374 /* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
13377 java_refold (tree t)
13379 tree c, b, ns, decl;
13381 if (TREE_CODE (t) != MODIFY_EXPR)
13384 c = TREE_OPERAND (t, 1);
13385 if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13386 && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13387 && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13390 /* Now the left branch of the binary operator. */
13391 b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13392 if (! (b && TREE_CODE (b) == NOP_EXPR
13393 && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13396 ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13397 if (! (ns && TREE_CODE (ns) == NOP_EXPR
13398 && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13401 decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13402 if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13403 /* It's got to be the an equivalent decl */
13404 && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13406 /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13407 TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13408 /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13409 TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13410 /* Change the right part of the BINOP_EXPR */
13411 TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13417 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13418 errors but we modify NODE so that it contains the type computed
13419 according to the expression, when it's fixed. Otherwise, we write
13420 error_mark_node as the type. It allows us to further the analysis
13421 of remaining nodes and detects more errors in certain cases. */
13424 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13426 tree op1 = TREE_OPERAND (node, 0);
13427 tree op2 = TREE_OPERAND (node, 1);
13428 tree op1_type = TREE_TYPE (op1);
13429 tree op2_type = TREE_TYPE (op2);
13430 tree prom_type = NULL_TREE, cn;
13431 enum tree_code code = TREE_CODE (node);
13433 /* If 1, tell the routine that we have to return error_mark_node
13434 after checking for the initialization of the RHS */
13435 int error_found = 0;
13437 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13439 /* If either op<n>_type are NULL, this might be early signs of an
13440 error situation, unless it's too early to tell (in case we're
13441 handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13442 correctly so the error can be later on reported accurately. */
13443 if (! (code == PLUS_EXPR || code == NE_EXPR
13444 || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13449 n = java_complete_tree (op1);
13450 op1_type = TREE_TYPE (n);
13454 n = java_complete_tree (op2);
13455 op2_type = TREE_TYPE (n);
13461 /* 15.16 Multiplicative operators */
13462 case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
13463 case RDIV_EXPR: /* 15.16.2 Division Operator / */
13464 case TRUNC_DIV_EXPR: /* 15.16.2 Integral type Division Operator / */
13465 case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
13466 if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13468 if (!JNUMERIC_TYPE_P (op1_type))
13469 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13470 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13471 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13472 TREE_TYPE (node) = error_mark_node;
13476 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13478 /* Detect integral division by zero */
13479 if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13480 && TREE_CODE (prom_type) == INTEGER_TYPE
13481 && (op2 == integer_zero_node || op2 == long_zero_node ||
13482 (TREE_CODE (op2) == INTEGER_CST &&
13483 ! TREE_INT_CST_LOW (op2) && ! TREE_INT_CST_HIGH (op2))))
13485 parse_warning_context
13487 "Evaluating this expression will result in an arithmetic exception being thrown");
13488 TREE_CONSTANT (node) = 0;
13489 TREE_INVARIANT (node) = 0;
13492 /* Change the division operator if necessary */
13493 if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13494 TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13496 /* Before divisions as is disappear, try to simplify and bail if
13497 applicable, otherwise we won't perform even simple
13498 simplifications like (1-1)/3. We can't do that with floating
13499 point number, folds can't handle them at this stage. */
13500 if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13501 && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13503 TREE_TYPE (node) = prom_type;
13504 node = fold (node);
13505 if (TREE_CODE (node) != code)
13509 if (TREE_CODE (prom_type) == INTEGER_TYPE
13510 && flag_use_divide_subroutine
13511 && ! flag_emit_class_files
13512 && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13513 return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13515 /* This one is more complicated. FLOATs are processed by a
13516 function call to soft_fmod. Duplicate the value of the
13517 COMPOUND_ASSIGN_P flag. */
13518 if (code == TRUNC_MOD_EXPR)
13520 tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13521 COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13526 /* 15.17 Additive Operators */
13527 case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
13529 /* Operation is valid if either one argument is a string
13530 constant, a String object or a StringBuffer crafted for the
13531 purpose of the a previous usage of the String concatenation
13534 if (TREE_CODE (op1) == STRING_CST
13535 || TREE_CODE (op2) == STRING_CST
13536 || JSTRING_TYPE_P (op1_type)
13537 || JSTRING_TYPE_P (op2_type)
13538 || IS_CRAFTED_STRING_BUFFER_P (op1)
13539 || IS_CRAFTED_STRING_BUFFER_P (op2))
13540 return build_string_concatenation (op1, op2);
13542 case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
13544 if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13546 if (!JNUMERIC_TYPE_P (op1_type))
13547 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13548 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13549 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13550 TREE_TYPE (node) = error_mark_node;
13554 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13557 /* 15.18 Shift Operators */
13561 if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13563 if (!JINTEGRAL_TYPE_P (op1_type))
13564 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13567 if (JNUMERIC_TYPE_P (op2_type))
13568 parse_error_context (wfl_operator,
13569 "Incompatible type for %qs. Explicit cast needed to convert shift distance from %qs to integral",
13570 operator_string (node),
13571 lang_printable_name (op2_type, 0));
13573 parse_error_context (wfl_operator,
13574 "Incompatible type for %qs. Can't convert shift distance from %qs to integral",
13575 operator_string (node),
13576 lang_printable_name (op2_type, 0));
13578 TREE_TYPE (node) = error_mark_node;
13583 /* Unary numeric promotion (5.6.1) is performed on each operand
13585 op1 = do_unary_numeric_promotion (op1);
13586 op2 = do_unary_numeric_promotion (op2);
13588 /* If the right hand side is of type `long', first cast it to
13590 if (TREE_TYPE (op2) == long_type_node)
13591 op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13593 /* The type of the shift expression is the type of the promoted
13594 type of the left-hand operand */
13595 prom_type = TREE_TYPE (op1);
13597 /* Shift int only up to 0x1f and long up to 0x3f */
13598 if (prom_type == int_type_node)
13599 op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13600 build_int_cst (NULL_TREE, 0x1f)));
13602 op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13603 build_int_cst (NULL_TREE, 0x3f)));
13605 /* The >>> operator is a >> operating on unsigned quantities */
13606 if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13609 tree utype = java_unsigned_type (prom_type);
13610 op1 = convert (utype, op1);
13611 TREE_SET_CODE (node, RSHIFT_EXPR);
13612 TREE_OPERAND (node, 0) = op1;
13613 TREE_OPERAND (node, 1) = op2;
13614 TREE_TYPE (node) = utype;
13615 to_return = convert (prom_type, node);
13616 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13617 COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13618 TREE_SIDE_EFFECTS (to_return)
13619 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13624 /* 15.19.1 Type Comparison Operator instanceof */
13625 case INSTANCEOF_EXPR:
13627 TREE_TYPE (node) = boolean_type_node;
13629 /* OP1_TYPE might be NULL when OP1 is a string constant. */
13630 if ((cn = patch_string (op1)))
13633 op1_type = TREE_TYPE (op1);
13635 if (op1_type == NULL_TREE)
13638 if (!(op2_type = resolve_type_during_patch (op2)))
13639 return error_mark_node;
13641 /* The first operand must be a reference type or the null type */
13642 if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13643 error_found = 1; /* Error reported further below */
13645 /* The second operand must be a reference type */
13646 if (!JREFERENCE_TYPE_P (op2_type))
13648 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13649 parse_error_context
13650 (wfl_operator, "Invalid argument %qs for %<instanceof%>",
13651 lang_printable_name (op2_type, 0));
13655 if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13657 /* If the first operand is null, the result is always false */
13658 if (op1 == null_pointer_node)
13659 return boolean_false_node;
13660 else if (flag_emit_class_files)
13662 TREE_OPERAND (node, 1) = op2_type;
13663 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13666 /* Otherwise we have to invoke instance of to figure it out */
13668 return build_instanceof (op1, op2_type);
13670 /* There is no way the expression operand can be an instance of
13671 the type operand. This is a compile time error. */
13674 char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13675 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13676 parse_error_context
13677 (wfl_operator, "Impossible for %qs to be instance of %qs",
13678 t1, lang_printable_name (op2_type, 0));
13685 /* 15.21 Bitwise and Logical Operators */
13689 if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13690 /* Binary numeric promotion is performed on both operand and the
13691 expression retain that type */
13692 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13694 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13695 && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13696 /* The type of the bitwise operator expression is BOOLEAN */
13697 prom_type = boolean_type_node;
13700 if (!JINTEGRAL_TYPE_P (op1_type))
13701 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13702 if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13703 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13704 TREE_TYPE (node) = error_mark_node;
13706 /* Insert a break here if adding thing before the switch's
13707 break for this case */
13711 /* 15.22 Conditional-And Operator */
13712 case TRUTH_ANDIF_EXPR:
13713 /* 15.23 Conditional-Or Operator */
13714 case TRUTH_ORIF_EXPR:
13715 /* Operands must be of BOOLEAN type */
13716 if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13717 TREE_CODE (op2_type) != BOOLEAN_TYPE)
13719 if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13720 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13721 if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13722 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13723 TREE_TYPE (node) = boolean_type_node;
13727 else if (integer_zerop (op1))
13729 return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13731 else if (integer_onep (op1))
13733 return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13735 /* The type of the conditional operators is BOOLEAN */
13736 prom_type = boolean_type_node;
13739 /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13744 /* The type of each of the operands must be a primitive numeric
13746 if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13748 if (!JNUMERIC_TYPE_P (op1_type))
13749 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13750 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13751 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13752 TREE_TYPE (node) = boolean_type_node;
13756 /* Binary numeric promotion is performed on the operands */
13757 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13758 /* The type of the relation expression is always BOOLEAN */
13759 prom_type = boolean_type_node;
13762 /* 15.20 Equality Operator */
13765 /* It's time for us to patch the strings. */
13766 if ((cn = patch_string (op1)))
13769 op1_type = TREE_TYPE (op1);
13771 if ((cn = patch_string (op2)))
13774 op2_type = TREE_TYPE (op2);
13777 /* 15.20.1 Numerical Equality Operators == and != */
13778 /* Binary numeric promotion is performed on the operands */
13779 if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13780 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13782 /* 15.20.2 Boolean Equality Operators == and != */
13783 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13784 TREE_CODE (op2_type) == BOOLEAN_TYPE)
13785 ; /* Nothing to do here */
13787 /* 15.20.3 Reference Equality Operators == and != */
13788 /* Types have to be either references or the null type. If
13789 they're references, it must be possible to convert either
13790 type to the other by casting conversion. */
13791 else if (op1 == null_pointer_node || op2 == null_pointer_node
13792 || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13793 && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13794 || valid_ref_assignconv_cast_p (op2_type,
13796 ; /* Nothing to do here */
13798 /* Else we have an error figure what can't be converted into
13799 what and report the error */
13803 t1 = xstrdup (lang_printable_name (op1_type, 0));
13804 parse_error_context
13806 "Incompatible type for %qs. Can't convert %qs to %qs",
13807 operator_string (node), t1,
13808 lang_printable_name (op2_type, 0));
13810 TREE_TYPE (node) = boolean_type_node;
13814 prom_type = boolean_type_node;
13821 return error_mark_node;
13823 TREE_OPERAND (node, 0) = op1;
13824 TREE_OPERAND (node, 1) = op2;
13825 TREE_TYPE (node) = prom_type;
13826 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13828 if (flag_emit_xref)
13831 /* fold does not respect side-effect order as required for Java but not C.
13832 * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13835 if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13836 : ! TREE_SIDE_EFFECTS (node))
13837 node = fold (node);
13841 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13842 zero value, the value of CSTE comes after the valude of STRING */
13845 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13847 const char *old = TREE_STRING_POINTER (cste);
13848 int old_len = TREE_STRING_LENGTH (cste);
13849 int len = old_len + string_len;
13850 char *new = alloca (len+1);
13854 memcpy (new, string, string_len);
13855 memcpy (&new [string_len], old, old_len);
13859 memcpy (new, old, old_len);
13860 memcpy (&new [old_len], string, string_len);
13863 return build_string (len, new);
13866 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13867 new STRING_CST on success, NULL_TREE on failure. */
13870 merge_string_cste (tree op1, tree op2, int after)
13872 /* Handle two string constants right away. */
13873 if (TREE_CODE (op2) == STRING_CST)
13874 return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13875 TREE_STRING_LENGTH (op2), after);
13877 /* Reasonable integer constant can be treated right away. */
13878 if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13880 static const char *const boolean_true = "true";
13881 static const char *const boolean_false = "false";
13882 static const char *const null_pointer = "null";
13884 const char *string;
13886 if (op2 == boolean_true_node)
13887 string = boolean_true;
13888 else if (op2 == boolean_false_node)
13889 string = boolean_false;
13890 else if (op2 == null_pointer_node
13891 || (integer_zerop (op2)
13892 && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13893 /* FIXME: null is not a compile-time constant, so it is only safe to
13894 merge if the overall expression is non-constant. However, this
13895 code always merges without checking the overall expression. */
13896 string = null_pointer;
13897 else if (TREE_TYPE (op2) == char_type_node)
13899 /* Convert the character into UTF-8. */
13900 unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13901 unsigned char *p = (unsigned char *) ch;
13902 if (0x01 <= c && c <= 0x7f)
13903 *p++ = (unsigned char) c;
13904 else if (c < 0x7ff)
13906 *p++ = (unsigned char) (c >> 6 | 0xc0);
13907 *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13911 *p++ = (unsigned char) (c >> 12 | 0xe0);
13912 *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13913 *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13920 string = string_convert_int_cst (op2);
13922 return do_merge_string_cste (op1, string, strlen (string), after);
13927 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13928 has to be a STRING_CST and the other part must be a STRING_CST or a
13929 INTEGRAL constant. Return a new STRING_CST if the operation
13930 succeed, NULL_TREE otherwise.
13932 If the case we want to optimize for space, we might want to return
13933 NULL_TREE for each invocation of this routine. FIXME */
13936 string_constant_concatenation (tree op1, tree op2)
13938 if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13943 string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13944 rest = (string == op1 ? op2 : op1);
13945 invert = (string == op1 ? 0 : 1 );
13947 /* Walk REST, only if it looks reasonable */
13948 if (TREE_CODE (rest) != STRING_CST
13949 && !IS_CRAFTED_STRING_BUFFER_P (rest)
13950 && !JSTRING_TYPE_P (TREE_TYPE (rest))
13951 && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13953 rest = java_complete_tree (rest);
13954 if (rest == error_mark_node)
13955 return error_mark_node;
13956 rest = fold (rest);
13958 return merge_string_cste (string, rest, invert);
13963 /* Implement the `+' operator. Does static optimization if possible,
13964 otherwise create (if necessary) and append elements to a
13965 StringBuffer. The StringBuffer will be carried around until it is
13966 used for a function call or an assignment. Then toString() will be
13967 called on it to turn it into a String object. */
13970 build_string_concatenation (tree op1, tree op2)
13973 int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13975 if (flag_emit_xref)
13976 return build2 (PLUS_EXPR, string_type_node, op1, op2);
13978 /* Try to do some static optimization */
13979 if ((result = string_constant_concatenation (op1, op2)))
13982 /* Discard empty strings on either side of the expression */
13983 if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13988 else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13991 /* If operands are string constant, turn then into object references */
13992 if (TREE_CODE (op1) == STRING_CST)
13993 op1 = patch_string_cst (op1);
13994 if (op2 && TREE_CODE (op2) == STRING_CST)
13995 op2 = patch_string_cst (op2);
13997 /* If either one of the constant is null and the other non null
13998 operand is a String constant, return it. */
13999 if ((TREE_CODE (op1) == STRING_CST) && !op2)
14002 /* If OP1 isn't already a StringBuffer, create and
14003 initialize a new one */
14004 if (!IS_CRAFTED_STRING_BUFFER_P (op1))
14006 /* Two solutions here:
14007 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
14008 2) OP1 is something else, we call new StringBuffer().append(OP1). */
14009 if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
14010 op1 = BUILD_STRING_BUFFER (op1);
14013 tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
14014 op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
14020 /* OP1 is no longer the last node holding a crafted StringBuffer */
14021 IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
14022 /* Create a node for `{new...,xxx}.append (op2)' */
14024 op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
14027 /* Mark the last node holding a crafted StringBuffer */
14028 IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
14030 TREE_SIDE_EFFECTS (op1) = side_effects;
14034 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
14035 StringBuffer. If no string were found to be patched, return
14039 patch_string (tree node)
14041 if (node == error_mark_node)
14042 return error_mark_node;
14043 if (TREE_CODE (node) == STRING_CST)
14044 return patch_string_cst (node);
14045 else if (IS_CRAFTED_STRING_BUFFER_P (node))
14047 int saved = ctxp->explicit_constructor_p;
14048 tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
14050 /* Temporary disable forbid the use of `this'. */
14051 ctxp->explicit_constructor_p = 0;
14052 ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
14053 /* String concatenation arguments must be evaluated in order too. */
14054 ret = force_evaluation_order (ret);
14055 /* Restore it at its previous value */
14056 ctxp->explicit_constructor_p = saved;
14062 /* Build the internal representation of a string constant. */
14065 patch_string_cst (tree node)
14068 if (! flag_emit_class_files)
14070 node = get_identifier (TREE_STRING_POINTER (node));
14071 location = alloc_name_constant (CONSTANT_String, node);
14072 node = build_ref_from_constant_pool (location);
14074 TREE_CONSTANT (node) = 1;
14075 TREE_INVARIANT (node) = 1;
14077 /* ??? Guessing that the class file code can't handle casts. */
14078 if (! flag_emit_class_files)
14079 node = convert (string_ptr_type_node, node);
14081 TREE_TYPE (node) = string_ptr_type_node;
14086 /* Build an incomplete unary operator expression. */
14089 build_unaryop (int op_token, int op_location, tree op1)
14095 case PLUS_TK: op = UNARY_PLUS_EXPR; break;
14096 case MINUS_TK: op = NEGATE_EXPR; break;
14097 case NEG_TK: op = TRUTH_NOT_EXPR; break;
14098 case NOT_TK: op = BIT_NOT_EXPR; break;
14102 unaryop = build1 (op, NULL_TREE, op1);
14103 TREE_SIDE_EFFECTS (unaryop) = 1;
14104 /* Store the location of the operator, for better error report. The
14105 string of the operator will be rebuild based on the OP value. */
14106 EXPR_WFL_LINECOL (unaryop) = op_location;
14110 /* Special case for the ++/-- operators, since they require an extra
14111 argument to build, which is set to NULL and patched
14112 later. IS_POST_P is 1 if the operator, 0 otherwise. */
14115 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
14117 static const enum tree_code lookup [2][2] =
14119 { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
14120 { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
14122 tree node = build2 (lookup [is_post_p][(op_token - DECR_TK)],
14123 NULL_TREE, op1, NULL_TREE);
14124 TREE_SIDE_EFFECTS (node) = 1;
14125 /* Store the location of the operator, for better error report. The
14126 string of the operator will be rebuild based on the OP value. */
14127 EXPR_WFL_LINECOL (node) = op_location;
14131 /* Build an incomplete cast operator, based on the use of the
14132 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
14133 set. java_complete_tree is trained to walk a CONVERT_EXPR even
14134 though its type is already set. */
14137 build_cast (int location, tree type, tree exp)
14139 tree node = build1 (CONVERT_EXPR, type, exp);
14140 EXPR_WFL_LINECOL (node) = location;
14144 /* Build an incomplete class reference operator. */
14146 build_incomplete_class_ref (int location, tree class_name)
14148 tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
14149 tree class_decl = GET_CPC ();
14150 tree this_class = TREE_TYPE (class_decl);
14152 /* Generate the synthetic static method `class$'. (Previously we
14153 deferred this, causing different method tables to be emitted
14154 for native code and bytecode.) */
14155 if (!TYPE_DOT_CLASS (this_class)
14156 && !JPRIMITIVE_TYPE_P (class_name)
14157 && !(TREE_CODE (class_name) == VOID_TYPE))
14159 tree cpc_list = GET_CPC_LIST();
14160 tree cpc = cpc_list;
14163 /* For inner classes, add a 'class$' method to their outermost
14164 context, creating it if necessary. */
14166 while (GET_NEXT_ENCLOSING_CPC(cpc))
14167 cpc = GET_NEXT_ENCLOSING_CPC(cpc);
14168 class_decl = TREE_VALUE (cpc);
14170 target_class = TREE_TYPE (class_decl);
14172 if (CLASS_INTERFACE (TYPE_NAME (target_class)))
14174 /* For interfaces, adding a static 'class$' method directly
14175 is illegal. So create an inner class to contain the new
14176 method. Empirically this matches the behavior of javac. */
14178 /* We want the generated inner class inside the outermost class. */
14179 GET_CPC_LIST() = cpc;
14180 t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
14181 inner = create_anonymous_class (t);
14182 target_class = TREE_TYPE (inner);
14183 end_class_declaration (1);
14184 GET_CPC_LIST() = cpc_list;
14187 if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
14188 build_dot_class_method (target_class);
14190 if (this_class != target_class)
14191 TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14194 EXPR_WFL_LINECOL (node) = location;
14198 /* Complete an incomplete class reference operator. */
14200 patch_incomplete_class_ref (tree node)
14202 tree type = TREE_OPERAND (node, 0);
14205 if (!(ref_type = resolve_type_during_patch (type)))
14206 return error_mark_node;
14208 /* If we're not emitting class files and we know ref_type is a
14209 compiled class, build a direct reference. */
14210 if ((! flag_emit_class_files && is_compiled_class (ref_type))
14211 || JPRIMITIVE_TYPE_P (ref_type)
14212 || TREE_CODE (ref_type) == VOID_TYPE)
14214 tree dot = build_class_ref (ref_type);
14215 /* A class referenced by `foo.class' is initialized. */
14216 if (!flag_emit_class_files)
14217 dot = build_class_init (ref_type, dot);
14218 return java_complete_tree (dot);
14221 /* If we're emitting class files and we have to deal with non
14222 primitive types, we invoke the synthetic static method `class$'. */
14223 ref_type = build_dot_class_method_invocation (current_class, ref_type);
14224 return java_complete_tree (ref_type);
14227 /* 15.14 Unary operators. We return error_mark_node in case of error,
14228 but preserve the type of NODE if the type is fixed. */
14231 patch_unaryop (tree node, tree wfl_op)
14233 tree op = TREE_OPERAND (node, 0);
14234 tree op_type = TREE_TYPE (op);
14235 tree prom_type = NULL_TREE, value, decl;
14236 int outer_field_flag = 0;
14237 int code = TREE_CODE (node);
14238 int error_found = 0;
14240 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14244 /* 15.13.2 Postfix Increment Operator ++ */
14245 case POSTINCREMENT_EXPR:
14246 /* 15.13.3 Postfix Increment Operator -- */
14247 case POSTDECREMENT_EXPR:
14248 /* 15.14.1 Prefix Increment Operator ++ */
14249 case PREINCREMENT_EXPR:
14250 /* 15.14.2 Prefix Decrement Operator -- */
14251 case PREDECREMENT_EXPR:
14252 op = decl = strip_out_static_field_access_decl (op);
14253 outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14254 /* We might be trying to change an outer field accessed using
14256 if (outer_field_flag)
14258 /* Retrieve the decl of the field we're trying to access. We
14259 do that by first retrieving the function we would call to
14260 access the field. It has been already verified that this
14261 field isn't final */
14262 if (flag_emit_class_files)
14263 decl = TREE_OPERAND (op, 0);
14265 decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14266 decl = DECL_FUNCTION_ACCESS_DECL (decl);
14268 /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14269 else if (!JDECL_P (decl)
14270 && TREE_CODE (decl) != COMPONENT_REF
14271 && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14272 && TREE_CODE (decl) != INDIRECT_REF
14273 && !(TREE_CODE (decl) == COMPOUND_EXPR
14274 && TREE_OPERAND (decl, 1)
14275 && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14277 TREE_TYPE (node) = error_mark_node;
14281 /* From now on, we know that op if a variable and that it has a
14282 valid wfl. We use wfl_op to locate errors related to the
14284 if (!JNUMERIC_TYPE_P (op_type))
14286 parse_error_context
14287 (wfl_op, "Invalid argument type %qs to %qs",
14288 lang_printable_name (op_type, 0), operator_string (node));
14289 TREE_TYPE (node) = error_mark_node;
14294 /* Before the addition, binary numeric promotion is performed on
14295 both operands, if really necessary */
14296 if (JINTEGRAL_TYPE_P (op_type))
14298 value = build_int_cst (op_type, 1);
14299 TREE_TYPE (node) = op_type;
14303 value = build_int_cst (NULL_TREE, 1);
14305 binary_numeric_promotion (op_type,
14306 TREE_TYPE (value), &op, &value);
14309 /* We remember we might be accessing an outer field */
14310 if (outer_field_flag)
14312 /* We re-generate an access to the field */
14313 value = build2 (PLUS_EXPR, TREE_TYPE (op),
14314 build_outer_field_access (wfl_op, decl), value);
14316 /* And we patch the original access$() into a write
14317 with plus_op as a rhs */
14318 return outer_field_access_fix (node, op, value);
14321 /* And write back into the node. */
14322 TREE_OPERAND (node, 0) = op;
14323 TREE_OPERAND (node, 1) = value;
14324 /* Convert the overall back into its original type, if
14325 necessary, and return */
14326 if (JINTEGRAL_TYPE_P (op_type))
14327 return fold (node);
14329 return fold (convert (op_type, node));
14333 /* 15.14.3 Unary Plus Operator + */
14334 case UNARY_PLUS_EXPR:
14335 /* 15.14.4 Unary Minus Operator - */
14337 if (!JNUMERIC_TYPE_P (op_type))
14339 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14340 TREE_TYPE (node) = error_mark_node;
14343 /* Unary numeric promotion is performed on operand */
14346 op = do_unary_numeric_promotion (op);
14347 prom_type = TREE_TYPE (op);
14348 if (code == UNARY_PLUS_EXPR)
14353 /* 15.14.5 Bitwise Complement Operator ~ */
14355 if (!JINTEGRAL_TYPE_P (op_type))
14357 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14358 TREE_TYPE (node) = error_mark_node;
14363 op = do_unary_numeric_promotion (op);
14364 prom_type = TREE_TYPE (op);
14368 /* 15.14.6 Logical Complement Operator ! */
14369 case TRUTH_NOT_EXPR:
14370 if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14372 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14373 /* But the type is known. We will report an error if further
14374 attempt of a assignment is made with this rhs */
14375 TREE_TYPE (node) = boolean_type_node;
14379 prom_type = boolean_type_node;
14382 /* 15.15 Cast Expression */
14384 value = patch_cast (node, wfl_operator);
14385 if (value == error_mark_node)
14387 /* If this cast is part of an assignment, we tell the code
14388 that deals with it not to complain about a mismatch,
14389 because things have been cast, anyways */
14390 TREE_TYPE (node) = error_mark_node;
14395 value = fold (value);
14402 return error_mark_node;
14404 /* There are cases where node has been replaced by something else
14405 and we don't end up returning here: UNARY_PLUS_EXPR,
14406 CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14407 TREE_OPERAND (node, 0) = fold (op);
14408 TREE_TYPE (node) = prom_type;
14409 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14410 return fold (node);
14413 /* Generic type resolution that sometimes takes place during node
14414 patching. Returned the resolved type or generate an error
14415 message. Return the resolved type or NULL_TREE. */
14418 resolve_type_during_patch (tree type)
14420 if (unresolved_type_p (type, NULL))
14422 tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14425 parse_error_context (type,
14426 "Class %qs not found in type declaration",
14427 IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14431 check_deprecation (type, type_decl);
14433 return TREE_TYPE (type_decl);
14438 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14439 found. Otherwise NODE or something meant to replace it is returned. */
14442 patch_cast (tree node, tree wfl_op)
14444 tree op = TREE_OPERAND (node, 0);
14445 tree cast_type = TREE_TYPE (node);
14446 tree patched, op_type;
14449 /* Some string patching might be necessary at this stage */
14450 if ((patched = patch_string (op)))
14451 TREE_OPERAND (node, 0) = op = patched;
14452 op_type = TREE_TYPE (op);
14454 /* First resolve OP_TYPE if unresolved */
14455 if (!(cast_type = resolve_type_during_patch (cast_type)))
14456 return error_mark_node;
14458 /* Check on cast that are proven correct at compile time */
14459 if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14462 if (cast_type == op_type)
14465 /* A narrowing conversion from a floating-point number to an
14466 integral type requires special handling (5.1.3). */
14467 if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14468 if (cast_type != long_type_node)
14469 op = convert (integer_type_node, op);
14471 /* Try widening/narrowing conversion. Potentially, things need
14472 to be worked out in gcc so we implement the extreme cases
14473 correctly. fold_convert() needs to be fixed. */
14474 return convert (cast_type, op);
14477 /* It's also valid to cast a boolean into a boolean */
14478 if (op_type == boolean_type_node && cast_type == boolean_type_node)
14481 /* null can be casted to references */
14482 if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14483 return build_null_of_type (cast_type);
14485 /* The remaining legal casts involve conversion between reference
14486 types. Check for their compile time correctness. */
14487 if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14488 && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14490 TREE_TYPE (node) = promote_type (cast_type);
14491 /* Now, the case can be determined correct at compile time if
14492 OP_TYPE can be converted into CAST_TYPE by assignment
14493 conversion (5.2) */
14495 if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14497 TREE_SET_CODE (node, NOP_EXPR);
14501 if (flag_emit_class_files)
14503 TREE_SET_CODE (node, CONVERT_EXPR);
14507 /* The cast requires a run-time check */
14508 return build3 (CALL_EXPR, promote_type (cast_type),
14509 build_address_of (soft_checkcast_node),
14510 tree_cons (NULL_TREE, build_class_ref (cast_type),
14511 build_tree_list (NULL_TREE, op)),
14515 /* Any other casts are proven incorrect at compile time */
14516 t1 = xstrdup (lang_printable_name (op_type, 0));
14517 parse_error_context (wfl_op, "Invalid cast from %qs to %qs",
14518 t1, lang_printable_name (cast_type, 0));
14520 return error_mark_node;
14523 /* Build a null constant and give it the type TYPE. */
14526 build_null_of_type (tree type)
14528 tree node = build_int_cst (promote_type (type), 0);
14532 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14533 a list of indices. */
14535 build_array_ref (int location, tree array, tree index)
14537 tree node = build4 (ARRAY_REF, NULL_TREE, array, index,
14538 NULL_TREE, NULL_TREE);
14539 EXPR_WFL_LINECOL (node) = location;
14543 /* 15.12 Array Access Expression */
14546 patch_array_ref (tree node)
14548 tree array = TREE_OPERAND (node, 0);
14549 tree array_type = TREE_TYPE (array);
14550 tree index = TREE_OPERAND (node, 1);
14551 tree index_type = TREE_TYPE (index);
14552 int error_found = 0;
14554 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14556 if (TREE_CODE (array_type) == POINTER_TYPE)
14557 array_type = TREE_TYPE (array_type);
14559 /* The array reference must be an array */
14560 if (!TYPE_ARRAY_P (array_type))
14562 parse_error_context
14564 "%<[]%> can only be applied to arrays. It can't be applied to %qs",
14565 lang_printable_name (array_type, 0));
14566 TREE_TYPE (node) = error_mark_node;
14570 /* The array index undergoes unary numeric promotion. The promoted
14571 type must be int */
14572 index = do_unary_numeric_promotion (index);
14573 if (TREE_TYPE (index) != int_type_node)
14575 if (valid_cast_to_p (index_type, int_type_node))
14576 parse_error_context (wfl_operator,
14577 "Incompatible type for %<[]%>. Explicit cast needed to convert %qs to %<int%>",
14578 lang_printable_name (index_type, 0));
14580 parse_error_context (wfl_operator,
14581 "Incompatible type for %<[]%>. Can't convert %qs to %<int%>",
14582 lang_printable_name (index_type, 0));
14583 TREE_TYPE (node) = error_mark_node;
14588 return error_mark_node;
14590 array_type = TYPE_ARRAY_ELEMENT (array_type);
14592 if (flag_emit_class_files || flag_emit_xref)
14594 TREE_OPERAND (node, 0) = array;
14595 TREE_OPERAND (node, 1) = index;
14598 node = build_java_arrayaccess (array, array_type, index);
14599 TREE_TYPE (node) = array_type;
14603 /* 15.9 Array Creation Expressions */
14606 build_newarray_node (tree type, tree dims, int extra_dims)
14608 tree node = build3 (NEW_ARRAY_EXPR, NULL_TREE, type,
14610 build_int_cst (NULL_TREE, extra_dims));
14615 patch_newarray (tree node)
14617 tree type = TREE_OPERAND (node, 0);
14618 tree dims = TREE_OPERAND (node, 1);
14619 tree cdim, array_type;
14620 int error_found = 0;
14622 int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14624 /* Dimension types are verified. It's better for the types to be
14625 verified in order. */
14626 for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14629 tree dim = TREE_VALUE (cdim);
14631 /* Dim might have been saved during its evaluation */
14632 dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14634 /* The type of each specified dimension must be an integral type. */
14635 if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14638 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14639 promoted type must be int. */
14642 dim = do_unary_numeric_promotion (dim);
14643 if (TREE_TYPE (dim) != int_type_node)
14647 /* Report errors on types here */
14650 parse_error_context
14651 (TREE_PURPOSE (cdim),
14652 "Incompatible type for dimension in array creation expression. %s convert %qs to %<int%>",
14653 (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14654 "Explicit cast needed to" : "Can't"),
14655 lang_printable_name (TREE_TYPE (dim), 0));
14659 TREE_PURPOSE (cdim) = NULL_TREE;
14662 /* Resolve array base type if unresolved */
14663 if (!(type = resolve_type_during_patch (type)))
14668 /* We don't want further evaluation of this bogus array creation
14670 TREE_TYPE (node) = error_mark_node;
14671 return error_mark_node;
14674 /* Set array_type to the actual (promoted) array type of the result. */
14675 if (TREE_CODE (type) == RECORD_TYPE)
14676 type = build_pointer_type (type);
14677 while (--xdims >= 0)
14679 type = promote_type (build_java_array_type (type, -1));
14681 dims = nreverse (dims);
14683 for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14687 = build_java_array_type (type,
14688 TREE_CODE (cdim) == INTEGER_CST
14689 ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14691 array_type = promote_type (array_type);
14693 dims = nreverse (dims);
14695 /* The node is transformed into a function call. Things are done
14696 differently according to the number of dimensions. If the number
14697 of dimension is equal to 1, then the nature of the base type
14698 (primitive or not) matters. */
14700 return build_new_array (type, TREE_VALUE (dims));
14702 /* Can't reuse what's already written in expr.c because it uses the
14703 JVM stack representation. Provide a build_multianewarray. FIXME */
14704 return build3 (CALL_EXPR, array_type,
14705 build_address_of (soft_multianewarray_node),
14706 tree_cons (NULL_TREE,
14707 build_class_ref (TREE_TYPE (array_type)),
14708 tree_cons (NULL_TREE,
14709 build_int_cst (NULL_TREE, ndims),
14714 /* 10.6 Array initializer. */
14716 /* Build a wfl for array element that don't have one, so we can
14717 pin-point errors. */
14720 maybe_build_array_element_wfl (tree node)
14722 if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14724 /* FIXME - old code used "prev_lc.line" and "elc.prev_col */
14725 return build_expr_wfl (NULL_TREE,
14726 #ifdef USE_MAPPED_LOCATION
14730 ctxp->lexer->token_start.line,
14731 ctxp->lexer->token_start.col
14739 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14740 identification of initialized arrays easier to detect during walk
14744 build_new_array_init (int location, tree values)
14746 tree constructor = build_constructor (NULL_TREE, values);
14747 tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14748 EXPR_WFL_LINECOL (to_return) = location;
14752 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14753 occurred. Otherwise return NODE after having set its type
14757 patch_new_array_init (tree type, tree node)
14759 int error_seen = 0;
14760 tree current, element_type;
14761 HOST_WIDE_INT length;
14762 int all_constant = 1;
14763 tree init = TREE_OPERAND (node, 0);
14765 if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14767 parse_error_context (node,
14768 "Invalid array initializer for non-array type %qs",
14769 lang_printable_name (type, 1));
14770 return error_mark_node;
14772 type = TREE_TYPE (type);
14773 element_type = TYPE_ARRAY_ELEMENT (type);
14775 CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14777 for (length = 0, current = CONSTRUCTOR_ELTS (init);
14778 current; length++, current = TREE_CHAIN (current))
14780 tree elt = TREE_VALUE (current);
14781 if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14783 error_seen |= array_constructor_check_entry (element_type, current);
14784 elt = TREE_VALUE (current);
14785 /* When compiling to native code, STRING_CST is converted to
14786 INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14787 if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14792 TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14793 TREE_PURPOSE (current) = NULL_TREE;
14796 if (elt && TREE_CODE (elt) == TREE_LIST
14797 && TREE_VALUE (elt) == error_mark_node)
14802 return error_mark_node;
14804 /* Create a new type. We can't reuse the one we have here by
14805 patching its dimension because it originally is of dimension -1
14806 hence reused by gcc. This would prevent triangular arrays. */
14807 type = build_java_array_type (element_type, length);
14808 TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14809 TREE_TYPE (node) = promote_type (type);
14810 TREE_CONSTANT (init) = all_constant;
14811 TREE_INVARIANT (init) = all_constant;
14812 TREE_CONSTANT (node) = all_constant;
14813 TREE_INVARIANT (node) = all_constant;
14817 /* Verify that one entry of the initializer element list can be
14818 assigned to the array base type. Report 1 if an error occurred, 0
14822 array_constructor_check_entry (tree type, tree entry)
14824 char *array_type_string = NULL; /* For error reports */
14825 tree value, type_value, new_value, wfl_value, patched;
14826 int error_seen = 0;
14828 new_value = NULL_TREE;
14829 wfl_value = TREE_VALUE (entry);
14831 value = java_complete_tree (TREE_VALUE (entry));
14832 /* patch_string return error_mark_node if arg is error_mark_node */
14833 if ((patched = patch_string (value)))
14835 if (value == error_mark_node)
14838 type_value = TREE_TYPE (value);
14840 /* At anytime, try_builtin_assignconv can report a warning on
14841 constant overflow during narrowing. */
14842 SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14843 new_value = try_builtin_assignconv (wfl_operator, type, value);
14844 if (!new_value && (new_value = try_reference_assignconv (type, value)))
14845 type_value = promote_type (type);
14847 /* Check and report errors */
14850 const char *const msg = (!valid_cast_to_p (type_value, type) ?
14851 "Can't" : "Explicit cast needed to");
14852 if (!array_type_string)
14853 array_type_string = xstrdup (lang_printable_name (type, 1));
14854 parse_error_context
14855 (wfl_operator, "Incompatible type for array. %s convert %qs to %qs",
14856 msg, lang_printable_name (type_value, 1), array_type_string);
14861 TREE_VALUE (entry) = new_value;
14863 if (array_type_string)
14864 free (array_type_string);
14866 TREE_PURPOSE (entry) = NULL_TREE;
14871 build_this (int location)
14873 tree node = build_wfl_node (this_identifier_node);
14874 TREE_SET_CODE (node, THIS_EXPR);
14875 EXPR_WFL_LINECOL (node) = location;
14879 /* 14.15 The return statement. It builds a modify expression that
14880 assigns the returned value to the RESULT_DECL that hold the value
14884 build_return (int location, tree op)
14886 tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14887 EXPR_WFL_LINECOL (node) = location;
14888 node = build_debugable_stmt (location, node);
14893 patch_return (tree node)
14895 tree return_exp = TREE_OPERAND (node, 0);
14896 tree meth = current_function_decl;
14897 tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14898 int error_found = 0;
14900 TREE_TYPE (node) = error_mark_node;
14901 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14903 /* It's invalid to have a return value within a function that is
14904 declared with the keyword void or that is a constructor */
14905 if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14908 /* It's invalid to use a return statement in a static block */
14909 if (DECL_CLINIT_P (current_function_decl))
14912 /* It's invalid to have a no return value within a function that
14913 isn't declared with the keyword `void' */
14914 if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14917 if (DECL_INSTINIT_P (current_function_decl))
14922 if (DECL_INSTINIT_P (current_function_decl))
14923 parse_error_context (wfl_operator,
14924 "%<return%> inside instance initializer");
14926 else if (DECL_CLINIT_P (current_function_decl))
14927 parse_error_context (wfl_operator,
14928 "%<return%> inside static initializer");
14930 else if (!DECL_CONSTRUCTOR_P (meth))
14932 char *t = xstrdup (lang_printable_name (mtype, 0));
14933 parse_error_context (wfl_operator,
14934 "%<return%> with%s value from %<%s %s%>",
14935 (error_found == 1 ? "" : "out"),
14936 t, lang_printable_name (meth, 2));
14940 parse_error_context (wfl_operator,
14941 "%<return%> with value from constructor %qs",
14942 lang_printable_name (meth, 2));
14943 return error_mark_node;
14946 /* If we have a return_exp, build a modify expression and expand
14947 it. Note: at that point, the assignment is declared valid, but we
14948 may want to carry some more hacks */
14951 tree exp = java_complete_tree (return_exp);
14952 tree modify, patched;
14954 if ((patched = patch_string (exp)))
14957 modify = build2 (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14958 EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14959 modify = java_complete_tree (modify);
14961 if (modify != error_mark_node)
14963 TREE_SIDE_EFFECTS (modify) = 1;
14964 TREE_OPERAND (node, 0) = modify;
14967 return error_mark_node;
14969 TREE_TYPE (node) = void_type_node;
14970 TREE_SIDE_EFFECTS (node) = 1;
14974 /* 14.8 The if Statement */
14977 build_if_else_statement (int location, tree expression, tree if_body,
14982 else_body = build_java_empty_stmt ();
14983 node = build3 (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14984 EXPR_WFL_LINECOL (node) = location;
14985 node = build_debugable_stmt (location, node);
14990 patch_if_else_statement (tree node)
14992 tree expression = TREE_OPERAND (node, 0);
14993 int can_complete_normally
14994 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14995 | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14997 TREE_TYPE (node) = error_mark_node;
14998 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15000 /* The type of expression must be boolean */
15001 if (TREE_TYPE (expression) != boolean_type_node
15002 && TREE_TYPE (expression) != promoted_boolean_type_node)
15004 parse_error_context
15006 "Incompatible type for %<if%>. Can't convert %qs to %<boolean%>",
15007 lang_printable_name (TREE_TYPE (expression), 0));
15008 return error_mark_node;
15011 TREE_TYPE (node) = void_type_node;
15012 TREE_SIDE_EFFECTS (node) = 1;
15013 CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
15017 /* 14.6 Labeled Statements */
15019 /* Action taken when a labeled statement is parsed. a new
15020 LABELED_BLOCK_EXPR is created. No statement is attached to the
15021 label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
15024 build_labeled_block (int location, tree label)
15027 tree label_decl, node;
15028 if (label == NULL_TREE || label == continue_identifier_node)
15029 label_name = label;
15032 label_name = merge_qualified_name (label_id, label);
15033 /* Issue an error if we try to reuse a label that was previously
15035 if (IDENTIFIER_LOCAL_VALUE (label_name))
15037 EXPR_WFL_LINECOL (wfl_operator) = location;
15038 parse_error_context (wfl_operator,
15039 "Declaration of %qs shadows a previous label declaration",
15040 IDENTIFIER_POINTER (label));
15041 EXPR_WFL_LINECOL (wfl_operator) =
15042 EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
15043 parse_error_context (wfl_operator,
15044 "This is the location of the previous declaration of label %qs",
15045 IDENTIFIER_POINTER (label));
15046 java_error_count--;
15050 label_decl = create_label_decl (label_name);
15051 node = build2 (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
15052 EXPR_WFL_LINECOL (node) = location;
15053 TREE_SIDE_EFFECTS (node) = 1;
15057 /* A labeled statement LBE is attached a statement. */
15060 finish_labeled_statement (tree lbe, /* Labeled block expr */
15063 /* In anyways, tie the loop to its statement */
15064 LABELED_BLOCK_BODY (lbe) = statement;
15065 pop_labeled_block ();
15066 POP_LABELED_BLOCK ();
15070 /* 14.10, 14.11, 14.12 Loop Statements */
15072 /* Create an empty LOOP_EXPR and make it the last in the nested loop
15076 build_new_loop (tree loop_body)
15078 tree loop = build1 (LOOP_EXPR, NULL_TREE, loop_body);
15079 TREE_SIDE_EFFECTS (loop) = 1;
15084 /* Create a loop body according to the following structure:
15086 COMPOUND_EXPR (loop main body)
15087 EXIT_EXPR (this order is for while/for loops.
15088 LABELED_BLOCK_EXPR the order is reversed for do loops)
15089 LABEL_DECL (a continue occurring here branches at the
15090 BODY end of this labeled block)
15093 REVERSED, if nonzero, tells that the loop condition expr comes
15094 after the body, like in the do-while loop.
15096 To obtain a loop, the loop body structure described above is
15097 encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
15100 LABEL_DECL (use this label to exit the loop)
15102 <structure described above> */
15105 build_loop_body (int location, tree condition, int reversed)
15107 tree first, second, body;
15109 condition = build1 (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
15110 EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
15111 condition = build_debugable_stmt (location, condition);
15112 TREE_SIDE_EFFECTS (condition) = 1;
15114 body = build_labeled_block (0, continue_identifier_node);
15115 first = (reversed ? body : condition);
15116 second = (reversed ? condition : body);
15117 return build2 (COMPOUND_EXPR, NULL_TREE,
15118 build2 (COMPOUND_EXPR, NULL_TREE, first, second),
15119 build_java_empty_stmt ());
15122 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
15123 their order) on the current loop. Unlink the current loop from the
15127 finish_loop_body (int location, tree condition, tree body, int reversed)
15129 tree to_return = ctxp->current_loop;
15130 tree loop_body = LOOP_EXPR_BODY (to_return);
15133 tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
15134 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
15135 The real EXIT_EXPR is one operand further. */
15136 EXPR_WFL_LINECOL (cnode) = location;
15137 if (TREE_CODE (cnode) == EXPR_WITH_FILE_LOCATION)
15139 cnode = EXPR_WFL_NODE (cnode);
15140 /* This one is for accurate error reports */
15141 EXPR_WFL_LINECOL (cnode) = location;
15143 TREE_OPERAND (cnode, 0) = condition;
15145 LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
15150 /* Tailored version of finish_loop_body for FOR loops, when FOR
15151 loops feature the condition part */
15154 finish_for_loop (int location, tree condition, tree update, tree body)
15156 /* Put the condition and the loop body in place */
15157 tree loop = finish_loop_body (location, condition, body, 0);
15158 /* LOOP is the current loop which has been now popped of the loop
15159 stack. Mark the update block as reachable and install it. We do
15160 this because the (current interpretation of the) JLS requires
15161 that the update expression be considered reachable even if the
15162 for loop's body doesn't complete normally. */
15163 if (update != NULL_TREE && !IS_EMPTY_STMT (update))
15166 if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
15167 up2 = EXPR_WFL_NODE (up2);
15168 /* It is possible for the update expression to be an
15169 EXPR_WFL_NODE wrapping nothing. */
15170 if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
15172 /* Try to detect constraint violations. These would be
15173 programming errors somewhere. */
15174 if (! EXPR_P (up2) || TREE_CODE (up2) == LOOP_EXPR)
15176 SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
15179 LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
15183 /* Try to find the loop a block might be related to. This comprises
15184 the case where the LOOP_EXPR is found as the second operand of a
15185 COMPOUND_EXPR, because the loop happens to have an initialization
15186 part, then expressed as the first operand of the COMPOUND_EXPR. If
15187 the search finds something, 1 is returned. Otherwise, 0 is
15188 returned. The search is assumed to start from a
15189 LABELED_BLOCK_EXPR's block. */
15192 search_loop (tree statement)
15194 if (TREE_CODE (statement) == LOOP_EXPR)
15197 if (TREE_CODE (statement) == BLOCK)
15198 statement = BLOCK_SUBBLOCKS (statement);
15202 if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15203 while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15204 statement = TREE_OPERAND (statement, 1);
15206 return (TREE_CODE (statement) == LOOP_EXPR
15207 && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15210 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15211 returned otherwise. */
15214 labeled_block_contains_loop_p (tree block, tree loop)
15219 if (LABELED_BLOCK_BODY (block) == loop)
15222 if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15228 /* If the loop isn't surrounded by a labeled statement, create one and
15229 insert LOOP as its body. */
15232 patch_loop_statement (tree loop)
15236 TREE_TYPE (loop) = void_type_node;
15237 if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15240 loop_label = build_labeled_block (0, NULL_TREE);
15241 /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15242 that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15243 LABELED_BLOCK_BODY (loop_label) = loop;
15244 PUSH_LABELED_BLOCK (loop_label);
15248 /* 14.13, 14.14: break and continue Statements */
15250 /* Build a break or a continue statement. a null NAME indicates an
15251 unlabeled break/continue statement. */
15254 build_bc_statement (int location, int is_break, tree name)
15256 tree break_continue, label_block_expr = NULL_TREE;
15260 if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15261 (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15262 /* Null means that we don't have a target for this named
15263 break/continue. In this case, we make the target to be the
15264 label name, so that the error can be reported accurately in
15265 patch_bc_statement. */
15266 label_block_expr = EXPR_WFL_NODE (name);
15268 /* Unlabeled break/continue will be handled during the
15269 break/continue patch operation */
15270 break_continue = build1 (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr);
15272 IS_BREAK_STMT_P (break_continue) = is_break;
15273 TREE_SIDE_EFFECTS (break_continue) = 1;
15274 EXPR_WFL_LINECOL (break_continue) = location;
15275 break_continue = build_debugable_stmt (location, break_continue);
15276 return break_continue;
15279 /* Verification of a break/continue statement. */
15282 patch_bc_statement (tree node)
15284 tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15285 tree labeled_block = ctxp->current_labeled_block;
15286 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15288 /* Having an identifier here means that the target is unknown. */
15289 if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15291 parse_error_context (wfl_operator, "No label definition found for %qs",
15292 IDENTIFIER_POINTER (bc_label));
15293 return error_mark_node;
15295 if (! IS_BREAK_STMT_P (node))
15297 /* It's a continue statement. */
15298 for (;; labeled_block = TREE_CHAIN (labeled_block))
15300 if (labeled_block == NULL_TREE)
15302 if (bc_label == NULL_TREE)
15303 parse_error_context (wfl_operator,
15304 "%<continue%> must be in loop");
15306 parse_error_context
15307 (wfl_operator, "continue label %qs does not name a loop",
15308 IDENTIFIER_POINTER (bc_label));
15309 return error_mark_node;
15311 if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15312 == continue_identifier_node)
15313 && (bc_label == NULL_TREE
15314 || TREE_CHAIN (labeled_block) == bc_label))
15316 bc_label = labeled_block;
15321 else if (!bc_label)
15323 for (;; labeled_block = TREE_CHAIN (labeled_block))
15325 if (labeled_block == NULL_TREE)
15327 parse_error_context (wfl_operator,
15328 "%<break%> must be in loop or switch");
15329 return error_mark_node;
15331 target_stmt = LABELED_BLOCK_BODY (labeled_block);
15332 if (TREE_CODE (target_stmt) == SWITCH_EXPR
15333 || search_loop (target_stmt))
15335 bc_label = labeled_block;
15341 EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15342 CAN_COMPLETE_NORMALLY (bc_label) = 1;
15344 /* Our break/continue don't return values. */
15345 TREE_TYPE (node) = void_type_node;
15346 /* Encapsulate the break within a compound statement so that it's
15347 expanded all the times by expand_expr (and not clobbered
15348 sometimes, like after a if statement) */
15349 node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15350 TREE_SIDE_EFFECTS (node) = 1;
15354 /* Process the exit expression belonging to a loop. Its type must be
15358 patch_exit_expr (tree node)
15360 tree expression = TREE_OPERAND (node, 0);
15361 TREE_TYPE (node) = error_mark_node;
15362 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15364 /* The type of expression must be boolean */
15365 if (TREE_TYPE (expression) != boolean_type_node)
15367 parse_error_context
15369 "Incompatible type for loop conditional. Can't convert %qs to %<boolean%>",
15370 lang_printable_name (TREE_TYPE (expression), 0));
15371 return error_mark_node;
15373 /* Now we know things are allright, invert the condition, fold and
15375 TREE_OPERAND (node, 0) =
15376 fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15378 if (! integer_zerop (TREE_OPERAND (node, 0))
15379 && ctxp->current_loop != NULL_TREE
15380 && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15381 CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15382 if (! integer_onep (TREE_OPERAND (node, 0)))
15383 CAN_COMPLETE_NORMALLY (node) = 1;
15386 TREE_TYPE (node) = void_type_node;
15390 /* 14.9 Switch statement */
15393 patch_switch_statement (tree node)
15395 tree se = TREE_OPERAND (node, 0), se_type;
15398 /* Complete the switch expression */
15399 se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15400 se_type = TREE_TYPE (se);
15401 /* The type of the switch expression must be char, byte, short or
15403 if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15405 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15406 parse_error_context (wfl_operator,
15407 "Incompatible type for %<switch%>. Can't convert %qs to %<int%>",
15408 lang_printable_name (se_type, 0));
15409 /* This is what java_complete_tree will check */
15410 TREE_OPERAND (node, 0) = error_mark_node;
15411 return error_mark_node;
15414 /* Save and restore the outer case label list. */
15415 save = case_label_list;
15416 case_label_list = NULL_TREE;
15418 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15420 /* See if we've found a duplicate label. We can't leave this until
15421 code generation, because in `--syntax-only' and `-C' modes we
15422 don't do ordinary code generation. */
15423 for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15425 HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15427 for (subiter = TREE_CHAIN (iter);
15428 subiter != NULL_TREE;
15429 subiter = TREE_CHAIN (subiter))
15431 HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15434 EXPR_WFL_LINECOL (wfl_operator)
15435 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15436 /* The case_label_list is in reverse order, so print the
15437 outer label first. */
15438 parse_error_context (wfl_operator, "duplicate case label: %<"
15439 HOST_WIDE_INT_PRINT_DEC "%>", subval);
15440 EXPR_WFL_LINECOL (wfl_operator)
15441 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15442 parse_error_context (wfl_operator, "original label is here");
15449 case_label_list = save;
15451 /* Ready to return */
15452 if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15454 TREE_TYPE (node) = error_mark_node;
15455 return error_mark_node;
15457 TREE_TYPE (node) = void_type_node;
15458 TREE_SIDE_EFFECTS (node) = 1;
15459 CAN_COMPLETE_NORMALLY (node)
15460 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15461 || ! SWITCH_HAS_DEFAULT (node);
15467 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15468 might be NULL_TREE. */
15471 #ifdef USE_MAPPED_LOCATION
15472 source_location location,
15476 tree condition, tree value)
15479 tree klass = GET_CPC ();
15481 if (! enable_assertions (klass))
15483 condition = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15484 boolean_false_node, condition);
15485 if (value == NULL_TREE)
15486 value = build_java_empty_stmt ();
15487 return build_if_else_statement (location, condition,
15491 if (! CLASS_USES_ASSERTIONS (klass))
15493 tree field, classdollar, id, call;
15494 tree class_type = TREE_TYPE (klass);
15496 field = add_field (class_type,
15497 get_identifier ("$assertionsDisabled"),
15499 ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15500 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15501 FIELD_SYNTHETIC (field) = 1;
15503 classdollar = build_incomplete_class_ref (location, class_type);
15505 /* Call CLASS.desiredAssertionStatus(). */
15506 id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15507 call = build3 (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15508 call = make_qualified_primary (classdollar, call, location);
15509 TREE_SIDE_EFFECTS (call) = 1;
15511 /* Invert to obtain !CLASS.desiredAssertionStatus(). This may
15512 seem odd, but we do it to generate code identical to that of
15514 call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15515 TREE_SIDE_EFFECTS (call) = 1;
15516 DECL_INITIAL (field) = call;
15518 /* Record the initializer in the initializer statement list. */
15519 call = build2 (MODIFY_EXPR, NULL_TREE, field, call);
15520 TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15521 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15522 MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15524 CLASS_USES_ASSERTIONS (klass) = 1;
15527 if (value != NULL_TREE)
15528 value = tree_cons (NULL_TREE, value, NULL_TREE);
15530 node = build_wfl_node (get_identifier ("java"));
15531 node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15533 node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15536 node = build3 (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15537 TREE_SIDE_EFFECTS (node) = 1;
15538 /* It is too early to use BUILD_THROW. */
15539 node = build1 (THROW_EXPR, NULL_TREE, node);
15540 TREE_SIDE_EFFECTS (node) = 1;
15542 /* We invert the condition; if we just put NODE as the `else' part
15543 then we generate weird-looking bytecode. */
15544 condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15545 /* Check $assertionsDisabled. */
15547 = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15548 build1 (TRUTH_NOT_EXPR, NULL_TREE,
15549 build_wfl_node (get_identifier ("$assertionsDisabled"))),
15551 node = build_if_else_statement (location, condition, node, NULL_TREE);
15555 /* 14.18 The try/catch statements */
15557 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15558 catches TYPE and executes CATCH_STMTS. */
15561 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15564 tree try_block, catch_clause_param, catch_block, catch;
15566 /* First build a try block */
15567 try_block = build_expr_block (try_stmts, NULL_TREE);
15569 /* Build a catch block: we need a catch clause parameter */
15570 if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15572 tree catch_type = obtain_incomplete_type (type_or_name);
15574 catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15575 register_incomplete_type (JDEP_VARIABLE, type_or_name,
15576 catch_clause_param, catch_type);
15577 dep = CLASSD_LAST (ctxp->classd_list);
15578 JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15581 catch_clause_param = build_decl (VAR_DECL, wpv_id,
15582 build_pointer_type (type_or_name));
15585 catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15587 /* Initialize the variable and store in the block */
15588 catch = build2 (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15589 build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15590 add_stmt_to_block (catch_block, NULL_TREE, catch);
15592 /* Add the catch statements */
15593 add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15595 /* Now we can build a JAVA_CATCH_EXPR */
15596 catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
15598 return build_try_statement (location, try_block, catch_block);
15602 build_try_statement (int location, tree try_block, tree catches)
15604 tree node = build2 (TRY_EXPR, NULL_TREE, try_block, catches);
15605 EXPR_WFL_LINECOL (node) = location;
15610 build_try_finally_statement (int location, tree try_block, tree finally)
15612 tree node = build2 (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15613 EXPR_WFL_LINECOL (node) = location;
15618 patch_try_statement (tree node)
15620 int error_found = 0;
15621 tree try = TREE_OPERAND (node, 0);
15622 /* Exception handlers are considered in left to right order */
15623 tree catch = nreverse (TREE_OPERAND (node, 1));
15624 tree current, caught_type_list = NULL_TREE;
15626 /* Check catch clauses, if any. Every time we find an error, we try
15627 to process the next catch clause. We process the catch clause before
15628 the try block so that when processing the try block we can check thrown
15629 exceptions against the caught type list. */
15630 for (current = catch; current; current = TREE_CHAIN (current))
15632 tree carg_decl, carg_type;
15633 tree sub_current, catch_block, catch_clause;
15636 /* At this point, the structure of the catch clause is
15637 JAVA_CATCH_EXPR (catch node)
15638 BLOCK (with the decl of the parameter)
15640 MODIFY_EXPR (assignment of the catch parameter)
15641 BLOCK (catch clause block)
15643 catch_clause = TREE_OPERAND (current, 0);
15644 carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15645 carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15647 /* Catch clauses can't have more than one parameter declared,
15648 but it's already enforced by the grammar. Make sure that the
15649 only parameter of the clause statement in of class Throwable
15650 or a subclass of Throwable, but that was done earlier. The
15651 catch clause parameter type has also been resolved. */
15653 /* Just make sure that the catch clause parameter type inherits
15654 from java.lang.Throwable */
15655 if (!inherits_from_p (carg_type, throwable_type_node))
15657 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15658 parse_error_context (wfl_operator,
15659 "Can't catch class %qs. Catch clause parameter type must be a subclass of class %<java.lang.Throwable%>",
15660 lang_printable_name (carg_type, 0));
15665 /* Partial check for unreachable catch statement: The catch
15666 clause is reachable iff is no earlier catch block A in
15667 the try statement such that the type of the catch
15668 clause's parameter is the same as or a subclass of the
15669 type of A's parameter */
15671 for (sub_current = catch;
15672 sub_current != current; sub_current = TREE_CHAIN (sub_current))
15674 tree sub_catch_clause, decl;
15675 sub_catch_clause = TREE_OPERAND (sub_current, 0);
15676 decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15678 if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15680 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15681 parse_error_context
15683 "%<catch%> not reached because of the catch clause at line %d",
15684 EXPR_WFL_LINENO (sub_current));
15685 unreachable = error_found = 1;
15689 /* Complete the catch clause block */
15690 catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15691 if (catch_block == error_mark_node)
15696 if (CAN_COMPLETE_NORMALLY (catch_block))
15697 CAN_COMPLETE_NORMALLY (node) = 1;
15698 TREE_OPERAND (current, 0) = catch_block;
15703 /* Things to do here: the exception must be thrown */
15705 /* Link this type to the caught type list */
15706 caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15709 PUSH_EXCEPTIONS (caught_type_list);
15710 if ((try = java_complete_tree (try)) == error_mark_node)
15712 if (CAN_COMPLETE_NORMALLY (try))
15713 CAN_COMPLETE_NORMALLY (node) = 1;
15716 /* Verification ends here */
15718 return error_mark_node;
15720 TREE_OPERAND (node, 0) = try;
15721 TREE_OPERAND (node, 1) = catch;
15722 TREE_TYPE (node) = void_type_node;
15726 /* 14.17 The synchronized Statement */
15729 patch_synchronized_statement (tree node, tree wfl_op1)
15731 tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15732 tree block = TREE_OPERAND (node, 1);
15734 tree tmp, enter, exit, expr_decl, assignment;
15736 if (expr == error_mark_node)
15738 block = java_complete_tree (block);
15742 /* We might be trying to synchronize on a STRING_CST */
15743 if ((tmp = patch_string (expr)))
15746 /* The TYPE of expr must be a reference type */
15747 if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15749 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15750 parse_error_context (wfl_operator, "Incompatible type for %<synchronized%>. Can't convert %qs to %<java.lang.Object%>",
15751 lang_printable_name (TREE_TYPE (expr), 0));
15752 return error_mark_node;
15755 if (flag_emit_xref)
15757 TREE_OPERAND (node, 0) = expr;
15758 TREE_OPERAND (node, 1) = java_complete_tree (block);
15759 CAN_COMPLETE_NORMALLY (node) = 1;
15763 /* Generate a try-finally for the synchronized statement, except
15764 that the handler that catches all throw exception calls
15765 _Jv_MonitorExit and then rethrow the exception.
15766 The synchronized statement is then implemented as:
15769 _Jv_MonitorEnter (expression)
15771 _Jv_MonitorExit (expression)
15775 e = _Jv_exception_info ();
15776 _Jv_MonitorExit (expression)
15780 expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15781 BUILD_MONITOR_ENTER (enter, expr_decl);
15782 BUILD_MONITOR_EXIT (exit, expr_decl);
15783 CAN_COMPLETE_NORMALLY (enter) = 1;
15784 CAN_COMPLETE_NORMALLY (exit) = 1;
15785 assignment = build2 (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15786 TREE_SIDE_EFFECTS (assignment) = 1;
15787 node = build2 (COMPOUND_EXPR, NULL_TREE,
15788 build2 (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15789 build2 (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15790 node = build_expr_block (node, expr_decl);
15792 return java_complete_tree (node);
15795 /* 14.16 The throw Statement */
15798 patch_throw_statement (tree node, tree wfl_op1)
15800 tree expr = TREE_OPERAND (node, 0);
15801 tree type = TREE_TYPE (expr);
15802 int unchecked_ok = 0, tryblock_throws_ok = 0;
15804 /* Thrown expression must be assignable to java.lang.Throwable */
15805 if (!try_reference_assignconv (throwable_type_node, expr))
15807 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15808 parse_error_context (wfl_operator,
15809 "Can't throw %qs; it must be a subclass of class %<java.lang.Throwable%>",
15810 lang_printable_name (type, 0));
15811 /* If the thrown expression was a reference, we further the
15812 compile-time check. */
15813 if (!JREFERENCE_TYPE_P (type))
15814 return error_mark_node;
15817 /* At least one of the following must be true */
15819 /* The type of the throw expression is a not checked exception,
15820 i.e. is a unchecked expression. */
15821 unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15823 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15824 /* An instance can't throw a checked exception unless that exception
15825 is explicitly declared in the `throws' clause of each
15826 constructor. This doesn't apply to anonymous classes, since they
15827 don't have declared constructors. */
15829 && DECL_INSTINIT_P (current_function_decl)
15830 && !ANONYMOUS_CLASS_P (current_class))
15833 for (current = TYPE_METHODS (current_class); current;
15834 current = TREE_CHAIN (current))
15835 if (DECL_CONSTRUCTOR_P (current)
15836 && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15838 parse_error_context (wfl_operator, "Checked exception %qs can't be thrown in instance initializer (not all declared constructor are declaring it in their %<throws%> clause)",
15839 lang_printable_name (TREE_TYPE (expr), 0));
15840 return error_mark_node;
15844 /* Throw is contained in a try statement and at least one catch
15845 clause can receive the thrown expression or the current method is
15846 declared to throw such an exception. Or, the throw statement is
15847 contained in a method or constructor declaration and the type of
15848 the Expression is assignable to at least one type listed in the
15849 throws clause the declaration. */
15851 tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15852 if (!(unchecked_ok || tryblock_throws_ok))
15854 /* If there is a surrounding try block that has no matching
15855 clatch clause, report it first. A surrounding try block exits
15856 only if there is something after the list of checked
15857 exception thrown by the current function (if any). */
15858 if (IN_TRY_BLOCK_P ())
15859 parse_error_context (wfl_operator, "Checked exception %qs can't be caught by any of the catch clause(s) of the surrounding %<try%> block",
15860 lang_printable_name (type, 0));
15861 /* If we have no surrounding try statement and the method doesn't have
15862 any throws, report it now. FIXME */
15864 /* We report that the exception can't be throw from a try block
15865 in all circumstances but when the `throw' is inside a static
15867 else if (!EXCEPTIONS_P (currently_caught_type_list)
15868 && !tryblock_throws_ok)
15870 if (DECL_CLINIT_P (current_function_decl))
15871 parse_error_context (wfl_operator,
15872 "Checked exception %qs can't be thrown in initializer",
15873 lang_printable_name (type, 0));
15875 parse_error_context (wfl_operator,
15876 "Checked exception %qs isn't thrown from a %<try%> block",
15877 lang_printable_name (type, 0));
15879 /* Otherwise, the current method doesn't have the appropriate
15880 throws declaration */
15882 parse_error_context (wfl_operator, "Checked exception %qs doesn't match any of current method's %<throws%> declaration(s)",
15883 lang_printable_name (type, 0));
15884 return error_mark_node;
15887 if (! flag_emit_class_files && ! flag_emit_xref)
15888 BUILD_THROW (node, expr);
15890 /* If doing xrefs, keep the location where the `throw' was seen. */
15891 if (flag_emit_xref)
15892 EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15896 /* Check that exception said to be thrown by method DECL can be
15897 effectively caught from where DECL is invoked. THIS_EXPR is the
15898 expression that computes `this' for the method call. */
15900 check_thrown_exceptions (
15901 #ifdef USE_MAPPED_LOCATION
15902 source_location location,
15907 tree decl, tree this_expr)
15910 int is_array_call = 0;
15912 /* Skip check within generated methods, such as access$<n>. */
15913 if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15916 if (this_expr != NULL_TREE
15917 && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15918 && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15921 /* For all the unchecked exceptions thrown by DECL. */
15922 for (throws = DECL_FUNCTION_THROWS (decl); throws;
15923 throws = TREE_CHAIN (throws))
15924 if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15926 /* Suppress errors about cloning arrays. */
15927 if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15930 #ifdef USE_MAPPED_LOCATION
15931 SET_EXPR_LOCATION (wfl_operator, location);
15933 EXPR_WFL_LINECOL (wfl_operator) = location;
15935 if (DECL_FINIT_P (current_function_decl))
15936 parse_error_context
15937 (wfl_operator, "Exception %qs can't be thrown in initializer",
15938 lang_printable_name (TREE_VALUE (throws), 0));
15941 parse_error_context
15942 (wfl_operator, "Exception %qs must be caught, or it must be declared in the %<throws%> clause of %qs",
15943 lang_printable_name (TREE_VALUE (throws), 0),
15944 (DECL_INIT_P (current_function_decl) ?
15945 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15946 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15951 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15952 try-catch blocks, OR is listed in the `throws' clause of the
15956 check_thrown_exceptions_do (tree exception)
15958 tree list = currently_caught_type_list;
15959 resolve_and_layout (exception, NULL_TREE);
15960 /* First, all the nested try-catch-finally at that stage. The
15961 last element contains `throws' clause exceptions, if any. */
15962 if (IS_UNCHECKED_EXCEPTION_P (exception))
15967 for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15968 if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15970 list = TREE_CHAIN (list);
15976 purge_unchecked_exceptions (tree mdecl)
15978 tree throws = DECL_FUNCTION_THROWS (mdecl);
15979 tree new = NULL_TREE;
15983 tree next = TREE_CHAIN (throws);
15984 if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15986 TREE_CHAIN (throws) = new;
15991 /* List is inverted here, but it doesn't matter */
15992 DECL_FUNCTION_THROWS (mdecl) = new;
15995 /* This function goes over all of CLASS_TYPE ctors and checks whether
15996 each of them features at least one unchecked exception in its
15997 `throws' clause. If it's the case, it returns `true', `false'
16001 ctors_unchecked_throws_clause_p (tree class_type)
16005 for (current = TYPE_METHODS (class_type); current;
16006 current = TREE_CHAIN (current))
16008 bool ctu = false; /* Ctor Throws Unchecked */
16009 if (DECL_CONSTRUCTOR_P (current))
16012 for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
16013 throws = TREE_CHAIN (throws))
16014 if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
16017 /* We return false as we found one ctor that is unfit. */
16018 if (!ctu && DECL_CONSTRUCTOR_P (current))
16021 /* All ctors feature at least one unchecked exception in their
16022 `throws' clause. */
16026 /* 15.24 Conditional Operator ?: */
16029 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
16031 tree cond = TREE_OPERAND (node, 0);
16032 tree op1 = TREE_OPERAND (node, 1);
16033 tree op2 = TREE_OPERAND (node, 2);
16034 tree resulting_type = NULL_TREE;
16035 tree t1, t2, patched;
16036 int error_found = 0;
16038 /* Operands of ?: might be StringBuffers crafted as a result of a
16039 string concatenation. Obtain a descent operand here. */
16040 if ((patched = patch_string (op1)))
16041 TREE_OPERAND (node, 1) = op1 = patched;
16042 if ((patched = patch_string (op2)))
16043 TREE_OPERAND (node, 2) = op2 = patched;
16045 t1 = TREE_TYPE (op1);
16046 t2 = TREE_TYPE (op2);
16048 /* The first expression must be a boolean */
16049 if (TREE_TYPE (cond) != boolean_type_node)
16051 SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
16052 parse_error_context (wfl_operator,
16053 "Incompatible type for %<?:%>. Can't convert %qs to %<boolean%>",
16054 lang_printable_name (TREE_TYPE (cond), 0));
16058 /* Second and third can be numeric, boolean (i.e. primitive),
16059 references or null. Anything else results in an error */
16060 if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
16061 || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
16062 && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
16063 || (t1 == boolean_type_node && t2 == boolean_type_node)))
16066 /* Determine the type of the conditional expression. Same types are
16067 easy to deal with */
16069 resulting_type = t1;
16071 /* There are different rules for numeric types */
16072 else if (JNUMERIC_TYPE_P (t1))
16074 /* if byte/short found, the resulting type is short */
16075 if ((t1 == byte_type_node && t2 == short_type_node)
16076 || (t1 == short_type_node && t2 == byte_type_node))
16077 resulting_type = short_type_node;
16079 /* If t1 is a constant int and t2 is of type byte, short or char
16080 and t1's value fits in t2, then the resulting type is t2 */
16081 else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
16082 && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
16083 resulting_type = t2;
16085 /* If t2 is a constant int and t1 is of type byte, short or char
16086 and t2's value fits in t1, then the resulting type is t1 */
16087 else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
16088 && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
16089 resulting_type = t1;
16091 /* Otherwise, binary numeric promotion is applied and the
16092 resulting type is the promoted type of operand 1 and 2 */
16094 resulting_type = binary_numeric_promotion (t1, t2,
16095 &TREE_OPERAND (node, 1),
16096 &TREE_OPERAND (node, 2));
16099 /* Cases of a reference and a null type */
16100 else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
16101 resulting_type = t1;
16103 else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
16104 resulting_type = t2;
16106 /* Last case: different reference types. If a type can be converted
16107 into the other one by assignment conversion, the latter
16108 determines the type of the expression */
16109 else if ((resulting_type = try_reference_assignconv (t1, op2)))
16110 resulting_type = promote_type (t1);
16112 else if ((resulting_type = try_reference_assignconv (t2, op1)))
16113 resulting_type = promote_type (t2);
16115 /* If we don't have any resulting type, we're in trouble */
16116 if (!resulting_type)
16118 char *t = xstrdup (lang_printable_name (t1, 0));
16119 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
16120 parse_error_context (wfl_operator,
16121 "Incompatible type for %<?:%>. Can't convert %qs to %qs",
16122 t, lang_printable_name (t2, 0));
16129 TREE_TYPE (node) = error_mark_node;
16130 return error_mark_node;
16133 TREE_TYPE (node) = resulting_type;
16134 TREE_SET_CODE (node, COND_EXPR);
16135 CAN_COMPLETE_NORMALLY (node) = 1;
16139 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
16142 maybe_build_class_init_for_field (tree decl, tree expr)
16144 tree clas = DECL_CONTEXT (decl);
16145 if (flag_emit_class_files || flag_emit_xref)
16148 if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
16149 && FIELD_FINAL (decl))
16151 tree init = DECL_INITIAL (decl);
16152 if (init != NULL_TREE)
16153 init = fold_constant_for_init (init, decl);
16154 if (init != NULL_TREE && CONSTANT_VALUE_P (init))
16158 return build_class_init (clas, expr);
16161 /* Try to constant fold NODE.
16162 If NODE is not a constant expression, return NULL_EXPR.
16163 CONTEXT is a static final VAR_DECL whose initializer we are folding. */
16166 fold_constant_for_init (tree node, tree context)
16168 tree op0, op1, val;
16169 enum tree_code code = TREE_CODE (node);
16174 if (node == null_pointer_node)
16183 case TRUNC_MOD_EXPR:
16191 case TRUTH_ANDIF_EXPR:
16192 case TRUTH_ORIF_EXPR:
16199 op0 = TREE_OPERAND (node, 0);
16200 op1 = TREE_OPERAND (node, 1);
16201 val = fold_constant_for_init (op0, context);
16202 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16204 TREE_OPERAND (node, 0) = val;
16205 val = fold_constant_for_init (op1, context);
16206 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16208 TREE_OPERAND (node, 1) = val;
16209 return patch_binop (node, op0, op1);
16211 case UNARY_PLUS_EXPR:
16213 case TRUTH_NOT_EXPR:
16216 op0 = TREE_OPERAND (node, 0);
16217 val = fold_constant_for_init (op0, context);
16218 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16220 TREE_OPERAND (node, 0) = val;
16221 val = patch_unaryop (node, op0);
16222 if (! TREE_CONSTANT (val))
16229 val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16230 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16232 TREE_OPERAND (node, 0) = val;
16233 val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16234 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16236 TREE_OPERAND (node, 1) = val;
16237 val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16238 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16240 TREE_OPERAND (node, 2) = val;
16241 return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16242 : TREE_OPERAND (node, 2);
16246 if (! FIELD_FINAL (node)
16247 || DECL_INITIAL (node) == NULL_TREE)
16249 val = DECL_INITIAL (node);
16250 /* Guard against infinite recursion. */
16251 DECL_INITIAL (node) = NULL_TREE;
16252 val = fold_constant_for_init (val, node);
16253 if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16254 val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16255 DECL_INITIAL (node) = val;
16258 case EXPR_WITH_FILE_LOCATION:
16259 /* Compare java_complete_tree and resolve_expression_name. */
16260 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16261 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16263 tree name = EXPR_WFL_NODE (node);
16265 if (PRIMARY_P (node))
16267 else if (! QUALIFIED_P (name))
16269 decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16270 if (decl == NULL_TREE
16271 || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16273 return fold_constant_for_init (decl, decl);
16277 tree r = NULL_TREE;
16278 /* Install the proper context for the field resolution. */
16279 tree saved_current_class = current_class;
16280 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
16281 current_class = DECL_CONTEXT (context);
16282 qualify_ambiguous_name (node);
16283 r = resolve_field_access (node, &decl, NULL);
16284 /* Restore prior context. */
16285 current_class = saved_current_class;
16286 if (r != error_mark_node && decl != NULL_TREE)
16287 return fold_constant_for_init (decl, decl);
16293 op0 = TREE_OPERAND (node, 0);
16294 val = fold_constant_for_init (op0, context);
16295 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16297 TREE_OPERAND (node, 0) = val;
16301 #ifdef USE_COMPONENT_REF
16303 case COMPONENT_REF:
16312 #ifdef USE_COMPONENT_REF
16313 /* Context is 'T' for TypeName, 'P' for PackageName,
16314 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16317 resolve_simple_name (tree name, int context)
16322 resolve_qualified_name (tree name, int context)
16328 init_src_parse (void)
16330 /* Sanity check; we've been bit by this before. */
16331 if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16337 /* This section deals with the functions that are called when tables
16338 recording class initialization information are traversed. */
16340 /* Attach to PTR (a block) the declaration found in ENTRY. */
16343 attach_init_test_initialization_flags (void **entry, void *ptr)
16345 tree block = (tree)ptr;
16346 struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16348 if (block != error_mark_node)
16350 tree body = BLOCK_SUBBLOCKS (block);
16351 TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16352 BLOCK_EXPR_DECLS (block) = ite->value;
16353 body = build2 (COMPOUND_EXPR, void_type_node,
16354 build1 (DECL_EXPR, void_type_node, ite->value), body);
16355 BLOCK_SUBBLOCKS (block) = body;
16360 /* This function is called for each class that is known definitely
16361 initialized when a given static method was called. This function
16362 augments a compound expression (INFO) storing all assignment to
16363 initialized static class flags if a flag already existed, otherwise
16364 a new one is created. */
16367 emit_test_initialization (void **entry_p, void *info)
16369 tree l = (tree) info;
16371 tree key = (tree) *entry_p;
16373 htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16375 /* If we haven't found a flag and we're dealing with self registered
16376 with current_function_decl, then don't do anything. Self is
16377 always added as definitely initialized but this information is
16378 valid only if used outside the current function. */
16379 if (current_function_decl == TREE_PURPOSE (l)
16380 && java_treetreehash_find (cf_ht, key) == NULL)
16383 ite = java_treetreehash_new (cf_ht, key);
16385 /* If we don't have a variable, create one and install it. */
16390 decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16391 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16392 LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16393 DECL_CONTEXT (decl) = current_function_decl;
16394 DECL_INITIAL (decl) = boolean_true_node;
16395 /* Don't emit any symbolic debugging info for this decl. */
16396 DECL_IGNORED_P (decl) = 1;
16398 /* The trick is to find the right context for it. */
16399 block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16400 TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16401 BLOCK_EXPR_DECLS (block) = decl;
16407 /* Now simply augment the compound that holds all the assignments
16408 pertaining to this method invocation. */
16409 init = build2 (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16410 TREE_SIDE_EFFECTS (init) = 1;
16411 TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16412 TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16417 #ifdef __XGETTEXT__
16418 /* Depending on the version of Bison used to compile this grammar,
16419 it may issue generic diagnostics spelled "syntax error" or
16420 "parse error". To prevent this from changing the translation
16421 template randomly, we list all the variants of this particular
16422 diagnostic here. Translators: there is no fine distinction
16423 between diagnostics with "syntax error" in them, and diagnostics
16424 with "parse error" in them. It's okay to give them both the same
16426 const char d1[] = N_("syntax error");
16427 const char d2[] = N_("parse error");
16428 const char d3[] = N_("syntax error; also virtual memory exhausted");
16429 const char d4[] = N_("parse error; also virtual memory exhausted");
16430 const char d5[] = N_("syntax error: cannot back up");
16431 const char d6[] = N_("parse error: cannot back up");
16434 #include "gt-java-parse.h"
16435 #include "gtype-java.h"