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 Free Software Foundation, Inc.
4 Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
23 Java and all Java-based marks are trademarks or registered trademarks
24 of Sun Microsystems, Inc. in the United States and other countries.
25 The Free Software Foundation is independent of Sun Microsystems, Inc. */
27 /* This file parses java source code and issues a tree node image
28 suitable for code generation (byte code and targeted CPU assembly
31 The grammar conforms to the Java grammar described in "The Java(TM)
32 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
33 1996, ISBN 0-201-63451-1"
35 The following modifications were brought to the original grammar:
37 method_body: added the rule '| block SC_TK'
38 static_initializer: added the rule 'static block SC_TK'.
40 Note: All the extra rules described above should go away when the
41 empty_statement rule will work.
43 statement_nsi: 'nsi' should be read no_short_if.
45 Some rules have been modified to support JDK1.1 inner classes
46 definitions and other extensions. */
57 #include "java-tree.h"
70 #define DIR_SEPARATOR '/'
73 /* Local function prototypes */
74 static char *java_accstring_lookup PARAMS ((int));
75 static void classitf_redefinition_error PARAMS ((const char *,tree, tree, tree));
76 static void variable_redefinition_error PARAMS ((tree, tree, tree, int));
77 static tree create_class PARAMS ((int, tree, tree, tree));
78 static tree create_interface PARAMS ((int, tree, tree));
79 static void end_class_declaration PARAMS ((int));
80 static tree find_field PARAMS ((tree, tree));
81 static tree lookup_field_wrapper PARAMS ((tree, tree));
82 static int duplicate_declaration_error_p PARAMS ((tree, tree, tree));
83 static void register_fields PARAMS ((int, tree, tree));
84 static tree parser_qualified_classname PARAMS ((int, tree));
85 static int parser_check_super PARAMS ((tree, tree, tree));
86 static int parser_check_super_interface PARAMS ((tree, tree, tree));
87 static void check_modifiers_consistency PARAMS ((int));
88 static tree lookup_cl PARAMS ((tree));
89 static tree lookup_java_method2 PARAMS ((tree, tree, int));
90 static tree method_header PARAMS ((int, tree, tree, tree));
91 static void fix_method_argument_names PARAMS ((tree ,tree));
92 static tree method_declarator PARAMS ((tree, tree));
93 static void parse_warning_context PARAMS ((tree cl, const char *msg, ...))
95 static void issue_warning_error_from_context PARAMS ((tree, const char *msg, va_list));
96 static void parse_ctor_invocation_error PARAMS ((void));
97 static tree parse_jdk1_1_error PARAMS ((const char *));
98 static void complete_class_report_errors PARAMS ((jdep *));
99 static int process_imports PARAMS ((void));
100 static void read_import_dir PARAMS ((tree));
101 static int find_in_imports_on_demand PARAMS ((tree));
102 static void find_in_imports PARAMS ((tree));
103 static void check_inner_class_access PARAMS ((tree, tree, tree));
104 static int check_pkg_class_access PARAMS ((tree, tree));
105 static void register_package PARAMS ((tree));
106 static tree resolve_package PARAMS ((tree, tree *));
107 static tree lookup_package_type PARAMS ((const char *, int));
108 static tree lookup_package_type_and_set_next PARAMS ((const char *, int, tree *));
109 static tree resolve_class PARAMS ((tree, tree, tree, tree));
110 static void declare_local_variables PARAMS ((int, tree, tree));
111 static void source_start_java_method PARAMS ((tree));
112 static void source_end_java_method PARAMS ((void));
113 static void expand_start_java_method PARAMS ((tree));
114 static tree find_name_in_single_imports PARAMS ((tree));
115 static void check_abstract_method_header PARAMS ((tree));
116 static tree lookup_java_interface_method2 PARAMS ((tree, tree));
117 static tree resolve_expression_name PARAMS ((tree, tree *));
118 static tree maybe_create_class_interface_decl PARAMS ((tree, tree, tree, tree));
119 static int check_class_interface_creation PARAMS ((int, int, tree,
121 static tree patch_method_invocation PARAMS ((tree, tree, tree,
123 static int breakdown_qualified PARAMS ((tree *, tree *, tree));
124 static tree resolve_and_layout PARAMS ((tree, tree));
125 static tree qualify_and_find PARAMS ((tree, tree, tree));
126 static tree resolve_no_layout PARAMS ((tree, tree));
127 static int invocation_mode PARAMS ((tree, int));
128 static tree find_applicable_accessible_methods_list PARAMS ((int, tree,
130 static void search_applicable_methods_list PARAMS ((int, tree, tree, tree,
132 static tree find_most_specific_methods_list PARAMS ((tree));
133 static int argument_types_convertible PARAMS ((tree, tree));
134 static tree patch_invoke PARAMS ((tree, tree, tree));
135 static int maybe_use_access_method PARAMS ((int, tree *, tree *));
136 static tree lookup_method_invoke PARAMS ((int, tree, tree, tree, tree));
137 static tree register_incomplete_type PARAMS ((int, tree, tree, tree));
138 static tree obtain_incomplete_type PARAMS ((tree));
139 static tree java_complete_lhs PARAMS ((tree));
140 static tree java_complete_tree PARAMS ((tree));
141 static tree maybe_generate_pre_expand_clinit PARAMS ((tree));
142 static int maybe_yank_clinit PARAMS ((tree));
143 static void java_complete_expand_method PARAMS ((tree));
144 static int unresolved_type_p PARAMS ((tree, tree *));
145 static void create_jdep_list PARAMS ((struct parser_ctxt *));
146 static tree build_expr_block PARAMS ((tree, tree));
147 static tree enter_block PARAMS ((void));
148 static tree enter_a_block PARAMS ((tree));
149 static tree exit_block PARAMS ((void));
150 static tree lookup_name_in_blocks PARAMS ((tree));
151 static void maybe_absorb_scoping_blocks PARAMS ((void));
152 static tree build_method_invocation PARAMS ((tree, tree));
153 static tree build_new_invocation PARAMS ((tree, tree));
154 static tree build_assignment PARAMS ((int, int, tree, tree));
155 static tree build_binop PARAMS ((enum tree_code, int, tree, tree));
156 static int check_final_assignment PARAMS ((tree ,tree));
157 static tree patch_assignment PARAMS ((tree, tree, tree ));
158 static tree patch_binop PARAMS ((tree, tree, tree));
159 static tree build_unaryop PARAMS ((int, int, tree));
160 static tree build_incdec PARAMS ((int, int, tree, int));
161 static tree patch_unaryop PARAMS ((tree, tree));
162 static tree build_cast PARAMS ((int, tree, tree));
163 static tree build_null_of_type PARAMS ((tree));
164 static tree patch_cast PARAMS ((tree, tree));
165 static int valid_ref_assignconv_cast_p PARAMS ((tree, tree, int));
166 static int valid_builtin_assignconv_identity_widening_p PARAMS ((tree, tree));
167 static int valid_cast_to_p PARAMS ((tree, tree));
168 static int valid_method_invocation_conversion_p PARAMS ((tree, tree));
169 static tree try_builtin_assignconv PARAMS ((tree, tree, tree));
170 static tree try_reference_assignconv PARAMS ((tree, tree));
171 static tree build_unresolved_array_type PARAMS ((tree));
172 static tree build_array_from_name PARAMS ((tree, tree, tree, tree *));
173 static tree build_array_ref PARAMS ((int, tree, tree));
174 static tree patch_array_ref PARAMS ((tree));
175 static tree make_qualified_name PARAMS ((tree, tree, int));
176 static tree merge_qualified_name PARAMS ((tree, tree));
177 static tree make_qualified_primary PARAMS ((tree, tree, int));
178 static int resolve_qualified_expression_name PARAMS ((tree, tree *,
180 static void qualify_ambiguous_name PARAMS ((tree));
181 static tree resolve_field_access PARAMS ((tree, tree *, tree *));
182 static tree build_newarray_node PARAMS ((tree, tree, int));
183 static tree patch_newarray PARAMS ((tree));
184 static tree resolve_type_during_patch PARAMS ((tree));
185 static tree build_this PARAMS ((int));
186 static tree build_wfl_wrap PARAMS ((tree, int));
187 static tree build_return PARAMS ((int, tree));
188 static tree patch_return PARAMS ((tree));
189 static tree maybe_access_field PARAMS ((tree, tree, tree));
190 static int complete_function_arguments PARAMS ((tree));
191 static int check_for_static_method_reference PARAMS ((tree, tree, tree,
193 static int not_accessible_p PARAMS ((tree, tree, int));
194 static void check_deprecation PARAMS ((tree, tree));
195 static int class_in_current_package PARAMS ((tree));
196 static tree build_if_else_statement PARAMS ((int, tree, tree, tree));
197 static tree patch_if_else_statement PARAMS ((tree));
198 static tree add_stmt_to_compound PARAMS ((tree, tree, tree));
199 static tree add_stmt_to_block PARAMS ((tree, tree, tree));
200 static tree patch_exit_expr PARAMS ((tree));
201 static tree build_labeled_block PARAMS ((int, tree));
202 static tree finish_labeled_statement PARAMS ((tree, tree));
203 static tree build_bc_statement PARAMS ((int, int, tree));
204 static tree patch_bc_statement PARAMS ((tree));
205 static tree patch_loop_statement PARAMS ((tree));
206 static tree build_new_loop PARAMS ((tree));
207 static tree build_loop_body PARAMS ((int, tree, int));
208 static tree finish_loop_body PARAMS ((int, tree, tree, int));
209 static tree build_debugable_stmt PARAMS ((int, tree));
210 static tree finish_for_loop PARAMS ((int, tree, tree, tree));
211 static tree patch_switch_statement PARAMS ((tree));
212 static tree string_constant_concatenation PARAMS ((tree, tree));
213 static tree build_string_concatenation PARAMS ((tree, tree));
214 static tree patch_string_cst PARAMS ((tree));
215 static tree patch_string PARAMS ((tree));
216 static tree build_try_statement PARAMS ((int, tree, tree));
217 static tree build_try_finally_statement PARAMS ((int, tree, tree));
218 static tree patch_try_statement PARAMS ((tree));
219 static tree patch_synchronized_statement PARAMS ((tree, tree));
220 static tree patch_throw_statement PARAMS ((tree, tree));
221 static void check_thrown_exceptions PARAMS ((int, tree));
222 static int check_thrown_exceptions_do PARAMS ((tree));
223 static void purge_unchecked_exceptions PARAMS ((tree));
224 static void check_throws_clauses PARAMS ((tree, tree, tree));
225 static void finish_method_declaration PARAMS ((tree));
226 static tree build_super_invocation PARAMS ((tree));
227 static int verify_constructor_circularity PARAMS ((tree, tree));
228 static char *constructor_circularity_msg PARAMS ((tree, tree));
229 static tree build_this_super_qualified_invocation PARAMS ((int, tree, tree,
231 static const char *get_printable_method_name PARAMS ((tree));
232 static tree patch_conditional_expr PARAMS ((tree, tree, tree));
233 static tree generate_finit PARAMS ((tree));
234 static void add_instance_initializer PARAMS ((tree));
235 static void fix_constructors PARAMS ((tree));
236 static tree build_alias_initializer_parameter_list PARAMS ((int, tree,
238 static void craft_constructor PARAMS ((tree, tree));
239 static int verify_constructor_super PARAMS ((tree));
240 static tree create_artificial_method PARAMS ((tree, int, tree, tree, tree));
241 static void start_artificial_method_body PARAMS ((tree));
242 static void end_artificial_method_body PARAMS ((tree));
243 static int check_method_redefinition PARAMS ((tree, tree));
244 static int reset_method_name PARAMS ((tree));
245 static int check_method_types_complete PARAMS ((tree));
246 static void java_check_regular_methods PARAMS ((tree));
247 static void java_check_abstract_methods PARAMS ((tree));
248 static tree maybe_build_primttype_type_ref PARAMS ((tree, tree));
249 static void unreachable_stmt_error PARAMS ((tree));
250 static tree find_expr_with_wfl PARAMS ((tree));
251 static void missing_return_error PARAMS ((tree));
252 static tree build_new_array_init PARAMS ((int, tree));
253 static tree patch_new_array_init PARAMS ((tree, tree));
254 static tree maybe_build_array_element_wfl PARAMS ((tree));
255 static int array_constructor_check_entry PARAMS ((tree, tree));
256 static const char *purify_type_name PARAMS ((const char *));
257 static tree fold_constant_for_init PARAMS ((tree, tree));
258 static tree strip_out_static_field_access_decl PARAMS ((tree));
259 static jdeplist *reverse_jdep_list PARAMS ((struct parser_ctxt *));
260 static void static_ref_err PARAMS ((tree, tree, tree));
261 static void parser_add_interface PARAMS ((tree, tree, tree));
262 static void add_superinterfaces PARAMS ((tree, tree));
263 static tree jdep_resolve_class PARAMS ((jdep *));
264 static int note_possible_classname PARAMS ((const char *, int));
265 static void java_complete_expand_classes PARAMS ((void));
266 static void java_complete_expand_class PARAMS ((tree));
267 static void java_complete_expand_methods PARAMS ((tree));
268 static tree cut_identifier_in_qualified PARAMS ((tree));
269 static tree java_stabilize_reference PARAMS ((tree));
270 static tree do_unary_numeric_promotion PARAMS ((tree));
271 static char * operator_string PARAMS ((tree));
272 static tree do_merge_string_cste PARAMS ((tree, const char *, int, int));
273 static tree merge_string_cste PARAMS ((tree, tree, int));
274 static tree java_refold PARAMS ((tree));
275 static int java_decl_equiv PARAMS ((tree, tree));
276 static int binop_compound_p PARAMS ((enum tree_code));
277 static tree search_loop PARAMS ((tree));
278 static int labeled_block_contains_loop_p PARAMS ((tree, tree));
279 static void check_abstract_method_definitions PARAMS ((int, tree, tree));
280 static void java_check_abstract_method_definitions PARAMS ((tree));
281 static void java_debug_context_do PARAMS ((int));
282 static void java_parser_context_push_initialized_field PARAMS ((void));
283 static void java_parser_context_pop_initialized_field PARAMS ((void));
284 static tree reorder_static_initialized PARAMS ((tree));
285 static void java_parser_context_suspend PARAMS ((void));
286 static void java_parser_context_resume PARAMS ((void));
288 /* JDK 1.1 work. FIXME */
290 static tree maybe_make_nested_class_name PARAMS ((tree));
291 static void make_nested_class_name PARAMS ((tree));
292 static void set_nested_class_simple_name_value PARAMS ((tree, int));
293 static void link_nested_class_to_enclosing PARAMS ((void));
294 static tree find_as_inner_class PARAMS ((tree, tree, tree));
295 static tree find_as_inner_class_do PARAMS ((tree, tree));
296 static int check_inner_class_redefinition PARAMS ((tree, tree));
298 static tree build_thisn_assign PARAMS ((void));
299 static tree build_current_thisn PARAMS ((tree));
300 static tree build_access_to_thisn PARAMS ((tree, tree, int));
301 static tree maybe_build_thisn_access_method PARAMS ((tree));
303 static tree build_outer_field_access PARAMS ((tree, tree));
304 static tree build_outer_field_access_methods PARAMS ((tree));
305 static tree build_outer_field_access_expr PARAMS ((int, tree, tree,
307 static tree build_outer_method_access_method PARAMS ((tree));
308 static tree build_new_access_id PARAMS ((void));
309 static tree build_outer_field_access_method PARAMS ((tree, tree, tree,
312 static int outer_field_access_p PARAMS ((tree, tree));
313 static int outer_field_expanded_access_p PARAMS ((tree, tree *,
315 static tree outer_field_access_fix PARAMS ((tree, tree, tree));
316 static tree build_incomplete_class_ref PARAMS ((int, tree));
317 static tree patch_incomplete_class_ref PARAMS ((tree));
318 static tree create_anonymous_class PARAMS ((int, tree));
319 static void patch_anonymous_class PARAMS ((tree, tree, tree));
320 static void add_inner_class_fields PARAMS ((tree, tree));
322 static tree build_dot_class_method PARAMS ((tree));
323 static tree build_dot_class_method_invocation PARAMS ((tree));
324 static void create_new_parser_context PARAMS ((int));
326 /* Number of error found so far. */
327 int java_error_count;
328 /* Number of warning found so far. */
329 int java_warning_count;
330 /* Tell when not to fold, when doing xrefs */
332 /* Cyclic inheritance report, as it can be set by layout_class */
333 char *cyclic_inheritance_report;
335 /* Tell when we're within an instance initializer */
336 static int in_instance_initializer;
338 /* The current parser context */
339 struct parser_ctxt *ctxp;
341 /* List of things that were analyzed for which code will be generated */
342 static struct parser_ctxt *ctxp_for_generation = NULL;
344 /* binop_lookup maps token to tree_code. It is used where binary
345 operations are involved and required by the parser. RDIV_EXPR
346 covers both integral/floating point division. The code is changed
347 once the type of both operator is worked out. */
349 static enum tree_code binop_lookup[19] =
351 PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
352 LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
353 BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
354 TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
355 EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
357 #define BINOP_LOOKUP(VALUE) \
358 binop_lookup [((VALUE) - PLUS_TK)% \
359 (sizeof (binop_lookup) / sizeof (binop_lookup[0]))]
361 /* This is the end index for binary operators that can also be used
362 in compound assignements. */
363 #define BINOP_COMPOUND_CANDIDATES 11
365 /* Fake WFL used to report error message. It is initialized once if
366 needed and reused with it's location information is overriden. */
367 tree wfl_operator = NULL_TREE;
369 /* The "$L" identifier we use to create labels. */
370 static tree label_id = NULL_TREE;
372 /* The "StringBuffer" identifier used for the String `+' operator. */
373 static tree wfl_string_buffer = NULL_TREE;
375 /* The "append" identifier used for String `+' operator. */
376 static tree wfl_append = NULL_TREE;
378 /* The "toString" identifier used for String `+' operator. */
379 static tree wfl_to_string = NULL_TREE;
381 /* The "java.lang" import qualified name. */
382 static tree java_lang_id = NULL_TREE;
384 /* The generated `inst$' identifier used for generated enclosing
385 instance/field access functions. */
386 static tree inst_id = NULL_TREE;
388 /* The "java.lang.Cloneable" qualified name. */
389 static tree java_lang_cloneable = NULL_TREE;
391 /* Context and flag for static blocks */
392 static tree current_static_block = NULL_TREE;
394 /* The generated `write_parm_value$' identifier. */
397 /* The list of all packages we've seen so far */
398 static tree package_list = NULL_TREE;
400 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
401 line and point it out. */
402 /* Should point out the one that don't fit. ASCII/unicode, going
405 #define check_modifiers(__message, __value, __mask) do { \
406 if ((__value) & ~(__mask)) \
408 int i, remainder = (__value) & ~(__mask); \
409 for (i = 0; i <= 10; i++) \
410 if ((1 << i) & remainder) \
411 parse_error_context (ctxp->modifier_ctx [i], (__message), \
412 java_accstring_lookup (1 << i)); \
434 /* Things defined here have to match the order of what's in the
435 binop_lookup table. */
437 %token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
438 %token LS_TK SRS_TK ZRS_TK
439 %token AND_TK XOR_TK OR_TK
440 %token BOOL_AND_TK BOOL_OR_TK
441 %token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
443 /* This maps to the same binop_lookup entry than the token above */
445 %token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
447 %token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
448 %token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
451 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
453 %token PUBLIC_TK PRIVATE_TK PROTECTED_TK
454 %token STATIC_TK FINAL_TK SYNCHRONIZED_TK
455 %token VOLATILE_TK TRANSIENT_TK NATIVE_TK
456 %token PAD_TK ABSTRACT_TK MODIFIER_TK
458 /* Keep those two in order, too */
459 %token DECR_TK INCR_TK
461 /* From now one, things can be in any order */
463 %token DEFAULT_TK IF_TK THROW_TK
464 %token BOOLEAN_TK DO_TK IMPLEMENTS_TK
465 %token THROWS_TK BREAK_TK IMPORT_TK
466 %token ELSE_TK INSTANCEOF_TK RETURN_TK
467 %token VOID_TK CATCH_TK INTERFACE_TK
468 %token CASE_TK EXTENDS_TK FINALLY_TK
469 %token SUPER_TK WHILE_TK CLASS_TK
470 %token SWITCH_TK CONST_TK TRY_TK
471 %token FOR_TK NEW_TK CONTINUE_TK
472 %token GOTO_TK PACKAGE_TK THIS_TK
474 %token BYTE_TK SHORT_TK INT_TK LONG_TK
475 %token CHAR_TK INTEGRAL_TK
477 %token FLOAT_TK DOUBLE_TK FP_TK
481 %token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
483 %token ASSIGN_ANY_TK ASSIGN_TK
484 %token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
486 %token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
487 %token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
489 %type <value> modifiers MODIFIER_TK final synchronized
491 %type <node> super ID_TK identifier
492 %type <node> name simple_name qualified_name
493 %type <node> type_declaration compilation_unit
494 field_declaration method_declaration extends_interfaces
495 interfaces interface_type_list
496 class_member_declaration
497 import_declarations package_declaration
498 type_declarations interface_body
499 interface_member_declaration constant_declaration
500 interface_member_declarations interface_type
501 abstract_method_declaration interface_type_list
502 %type <node> class_body_declaration class_member_declaration
503 static_initializer constructor_declaration block
504 %type <node> class_body_declarations constructor_header
505 %type <node> class_or_interface_type class_type class_type_list
506 constructor_declarator explicit_constructor_invocation
507 %type <node> dim_expr dim_exprs this_or_super throws
509 %type <node> variable_declarator_id variable_declarator
510 variable_declarators variable_initializer
511 variable_initializers constructor_body
514 %type <node> class_body block_end constructor_block_end
515 %type <node> statement statement_without_trailing_substatement
516 labeled_statement if_then_statement label_decl
517 if_then_else_statement while_statement for_statement
518 statement_nsi labeled_statement_nsi do_statement
519 if_then_else_statement_nsi while_statement_nsi
520 for_statement_nsi statement_expression_list for_init
521 for_update statement_expression expression_statement
522 primary_no_new_array expression primary
523 array_creation_expression array_type
524 class_instance_creation_expression field_access
525 method_invocation array_access something_dot_new
526 argument_list postfix_expression while_expression
527 post_increment_expression post_decrement_expression
528 unary_expression_not_plus_minus unary_expression
529 pre_increment_expression pre_decrement_expression
530 unary_expression_not_plus_minus cast_expression
531 multiplicative_expression additive_expression
532 shift_expression relational_expression
533 equality_expression and_expression
534 exclusive_or_expression inclusive_or_expression
535 conditional_and_expression conditional_or_expression
536 conditional_expression assignment_expression
537 left_hand_side assignment for_header for_begin
538 constant_expression do_statement_begin empty_statement
539 switch_statement synchronized_statement throw_statement
540 try_statement switch_expression switch_block
541 catches catch_clause catch_clause_parameter finally
542 anonymous_class_creation
543 %type <node> return_statement break_statement continue_statement
545 %type <operator> ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
546 %type <operator> REM_ASSIGN_TK PLUS_ASSIGN_TK MINUS_ASSIGN_TK
547 %type <operator> LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
548 %type <operator> AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
549 %type <operator> ASSIGN_ANY_TK assignment_operator
550 %token <operator> EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
551 %token <operator> BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
552 %token <operator> DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
553 %token <operator> NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
554 %token <operator> OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
555 %type <operator> THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
556 %type <operator> CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
557 %type <operator> NEW_TK
559 %type <node> method_body
561 %type <node> literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
562 STRING_LIT_TK NULL_TK VOID_TK
564 %type <node> IF_TK WHILE_TK FOR_TK
566 %type <node> formal_parameter_list formal_parameter
567 method_declarator method_header
569 %type <node> primitive_type reference_type type
570 BOOLEAN_TK INTEGRAL_TK FP_TK
572 /* Added or modified JDK 1.1 rule types */
573 %type <node> type_literals array_type_literal
576 /* 19.2 Production from 2.3: The Syntactic Grammar */
582 /* 19.3 Productions from 3: Lexical structure */
592 /* 19.4 Productions from 4: Types, Values and Variables */
605 class_or_interface_type
609 class_or_interface_type:
614 class_or_interface_type /* Default rule */
618 class_or_interface_type
622 primitive_type OSB_TK CSB_TK
624 $$ = build_java_array_type ($1, -1);
625 CLASS_LOADED_P ($$) = 1;
628 { $$ = build_unresolved_array_type ($1); }
629 | array_type OSB_TK CSB_TK
630 { $$ = build_unresolved_array_type ($1); }
631 | primitive_type OSB_TK error
632 {RULE ("']' expected"); RECOVER;}
633 | array_type OSB_TK error
634 {RULE ("']' expected"); RECOVER;}
637 /* 19.5 Productions from 6: Names */
639 simple_name /* Default rule */
640 | qualified_name /* Default rule */
644 identifier /* Default rule */
648 name DOT_TK identifier
649 { $$ = make_qualified_name ($1, $3, $2.location); }
656 /* 19.6: Production from 7: Packages */
659 | package_declaration
660 | import_declarations
662 | package_declaration import_declarations
663 | package_declaration type_declarations
664 | import_declarations type_declarations
665 | package_declaration import_declarations type_declarations
673 | import_declarations import_declaration
681 | type_declarations type_declaration
685 PACKAGE_TK name SC_TK
687 ctxp->package = EXPR_WFL_NODE ($2);
688 register_package (ctxp->package);
691 {yyerror ("Missing name"); RECOVER;}
692 | PACKAGE_TK name error
693 {yyerror ("';' expected"); RECOVER;}
697 single_type_import_declaration
698 | type_import_on_demand_declaration
701 single_type_import_declaration:
704 tree name = EXPR_WFL_NODE ($2), last_name;
705 int i = IDENTIFIER_LENGTH (name)-1;
706 const char *last = &IDENTIFIER_POINTER (name)[i];
707 while (last != IDENTIFIER_POINTER (name))
713 last_name = get_identifier (++last);
714 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
716 tree err = find_name_in_single_imports (last_name);
717 if (err && err != name)
719 ($2, "Ambiguous class: `%s' and `%s'",
720 IDENTIFIER_POINTER (name),
721 IDENTIFIER_POINTER (err));
723 REGISTER_IMPORT ($2, last_name);
726 REGISTER_IMPORT ($2, last_name);
729 {yyerror ("Missing name"); RECOVER;}
730 | IMPORT_TK name error
731 {yyerror ("';' expected"); RECOVER;}
734 type_import_on_demand_declaration:
735 IMPORT_TK name DOT_TK MULT_TK SC_TK
737 tree name = EXPR_WFL_NODE ($2);
738 /* Don't import java.lang.* twice. */
739 if (name != java_lang_id)
741 read_import_dir ($2);
742 ctxp->import_demand_list =
743 chainon (ctxp->import_demand_list,
744 build_tree_list ($2, NULL_TREE));
747 | IMPORT_TK name DOT_TK error
748 {yyerror ("'*' expected"); RECOVER;}
749 | IMPORT_TK name DOT_TK MULT_TK error
750 {yyerror ("';' expected"); RECOVER;}
755 { end_class_declaration (0); }
756 | interface_declaration
757 { end_class_declaration (0); }
763 yyerror ("Class or interface declaration expected");
767 /* 19.7 Shortened from the original:
768 modifiers: modifier | modifiers modifier
769 modifier: any of public... */
775 | modifiers MODIFIER_TK
780 (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
781 java_accstring_lookup (acc));
789 /* 19.8.1 Production from $8.1: Class Declaration */
791 modifiers CLASS_TK identifier super interfaces
792 { create_class ($1, $3, $4, $5); }
794 | CLASS_TK identifier super interfaces
795 { create_class (0, $2, $3, $4); }
797 | modifiers CLASS_TK error
798 {yyerror ("Missing class name"); RECOVER;}
800 {yyerror ("Missing class name"); RECOVER;}
801 | CLASS_TK identifier error
803 if (!ctxp->class_err) yyerror ("'{' expected");
806 | modifiers CLASS_TK identifier error
807 {if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER;}
812 | EXTENDS_TK class_type
814 | EXTENDS_TK class_type error
815 {yyerror ("'{' expected"); ctxp->class_err=1;}
817 {yyerror ("Missing super class name"); ctxp->class_err=1;}
822 | IMPLEMENTS_TK interface_type_list
824 | IMPLEMENTS_TK error
827 yyerror ("Missing interface name");
834 ctxp->interface_number = 1;
835 $$ = build_tree_list ($1, NULL_TREE);
837 | interface_type_list C_TK interface_type
839 ctxp->interface_number++;
840 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
842 | interface_type_list C_TK error
843 {yyerror ("Missing interface name"); RECOVER;}
849 /* Store the location of the `}' when doing xrefs */
851 DECL_END_SOURCE_LINE (GET_CPC ()) =
852 EXPR_WFL_ADD_COL ($2.location, 1);
855 | OCB_TK class_body_declarations CCB_TK
857 /* Store the location of the `}' when doing xrefs */
859 DECL_END_SOURCE_LINE (GET_CPC ()) =
860 EXPR_WFL_ADD_COL ($3.location, 1);
865 class_body_declarations:
866 class_body_declaration
867 | class_body_declarations class_body_declaration
870 class_body_declaration:
871 class_member_declaration
873 | constructor_declaration
874 | block /* Added, JDK1.1, instance initializer */
876 TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
877 SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
881 class_member_declaration:
883 | field_declaration SC_TK
886 | class_declaration /* Added, JDK1.1 inner classes */
887 { end_class_declaration (1); }
888 | interface_declaration /* Added, JDK1.1 inner interfaces */
889 { end_class_declaration (1); }
892 /* 19.8.2 Productions from 8.3: Field Declarations */
894 type variable_declarators SC_TK
895 { register_fields (0, $1, $2); }
896 | modifiers type variable_declarators SC_TK
899 ("Illegal modifier `%s' for field declaration",
900 $1, FIELD_MODIFIERS);
901 check_modifiers_consistency ($1);
902 register_fields ($1, $2, $3);
906 variable_declarators:
907 /* Should we use build_decl_list () instead ? FIXME */
908 variable_declarator /* Default rule */
909 | variable_declarators C_TK variable_declarator
910 { $$ = chainon ($1, $3); }
911 | variable_declarators C_TK error
912 {yyerror ("Missing term"); RECOVER;}
916 variable_declarator_id
917 { $$ = build_tree_list ($1, NULL_TREE); }
918 | variable_declarator_id ASSIGN_TK variable_initializer
920 if (java_error_count)
923 ($1, build_assignment ($2.token, $2.location, $1, $3));
925 | variable_declarator_id ASSIGN_TK error
927 yyerror ("Missing variable initializer");
928 $$ = build_tree_list ($1, NULL_TREE);
931 | variable_declarator_id ASSIGN_TK variable_initializer error
933 yyerror ("';' expected");
934 $$ = build_tree_list ($1, NULL_TREE);
939 variable_declarator_id:
941 | variable_declarator_id OSB_TK CSB_TK
942 { $$ = build_unresolved_array_type ($1); }
944 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
945 | variable_declarator_id OSB_TK error
946 {yyerror ("']' expected"); DRECOVER(vdi);}
947 | variable_declarator_id CSB_TK error
948 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
951 variable_initializer:
956 /* 19.8.3 Productions from 8.4: Method Declarations */
960 current_function_decl = $1;
961 if (current_function_decl
962 && TREE_CODE (current_function_decl) == FUNCTION_DECL)
963 source_start_java_method (current_function_decl);
965 current_function_decl = NULL_TREE;
968 { finish_method_declaration ($3); }
969 | method_header error
970 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
974 type method_declarator throws
975 { $$ = method_header (0, $1, $2, $3); }
976 | VOID_TK method_declarator throws
977 { $$ = method_header (0, void_type_node, $2, $3); }
978 | modifiers type method_declarator throws
979 { $$ = method_header ($1, $2, $3, $4); }
980 | modifiers VOID_TK method_declarator throws
981 { $$ = method_header ($1, void_type_node, $3, $4); }
984 yyerror ("Invalid method declaration, method name required");
987 | modifiers type error
990 {yyerror ("Identifier expected"); RECOVER;}
991 | modifiers VOID_TK error
992 {yyerror ("Identifier expected"); RECOVER;}
995 yyerror ("Invalid method declaration, return type required");
1001 identifier OP_TK CP_TK
1003 ctxp->formal_parameter_number = 0;
1004 $$ = method_declarator ($1, NULL_TREE);
1006 | identifier OP_TK formal_parameter_list CP_TK
1007 { $$ = method_declarator ($1, $3); }
1008 | method_declarator OSB_TK CSB_TK
1010 EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1012 build_unresolved_array_type (TREE_PURPOSE ($1));
1013 parse_warning_context
1015 "Discouraged form of returned type specification");
1017 | identifier OP_TK error
1018 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1019 | method_declarator OSB_TK error
1020 {yyerror ("']' expected"); RECOVER;}
1023 formal_parameter_list:
1026 ctxp->formal_parameter_number = 1;
1028 | formal_parameter_list C_TK formal_parameter
1030 ctxp->formal_parameter_number += 1;
1031 $$ = chainon ($1, $3);
1033 | formal_parameter_list C_TK error
1034 { yyerror ("Missing formal parameter term"); RECOVER; }
1038 type variable_declarator_id
1040 $$ = build_tree_list ($2, $1);
1042 | final type variable_declarator_id /* Added, JDK1.1 final parms */
1044 $$ = build_tree_list ($3, $2);
1045 ARG_FINAL_P ($$) = 1;
1049 yyerror ("Missing identifier"); RECOVER;
1054 yyerror ("Missing identifier"); RECOVER;
1062 check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1064 if ($1 != ACC_FINAL)
1065 MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1071 | THROWS_TK class_type_list
1074 {yyerror ("Missing class type term"); RECOVER;}
1079 { $$ = build_tree_list ($1, $1); }
1080 | class_type_list C_TK class_type
1081 { $$ = tree_cons ($3, $3, $1); }
1082 | class_type_list C_TK error
1083 {yyerror ("Missing class type term"); RECOVER;}
1090 { $$ = NULL_TREE; } /* Probably not the right thing to do. */
1093 /* 19.8.4 Productions from 8.5: Static Initializers */
1097 TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1098 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1100 | static block SC_TK /* Shouldn't be here. FIXME */
1102 TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1103 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1107 static: /* Test lval.sub_token here */
1110 check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1111 /* Can't have a static initializer in an innerclass */
1112 if ($1 | ACC_STATIC &&
1113 GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1115 (MODIFIER_WFL (STATIC_TK),
1116 "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1117 IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1118 SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1122 /* 19.8.5 Productions from 8.6: Constructor Declarations */
1123 constructor_declaration:
1126 current_function_decl = $1;
1127 source_start_java_method (current_function_decl);
1130 { finish_method_declaration ($3); }
1134 constructor_declarator throws
1135 { $$ = method_header (0, NULL_TREE, $1, $2); }
1136 | modifiers constructor_declarator throws
1137 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1140 constructor_declarator:
1141 simple_name OP_TK CP_TK
1143 ctxp->formal_parameter_number = 0;
1144 $$ = method_declarator ($1, NULL_TREE);
1146 | simple_name OP_TK formal_parameter_list CP_TK
1147 { $$ = method_declarator ($1, $3); }
1151 /* Unlike regular method, we always need a complete (empty)
1152 body so we can safely perform all the required code
1153 addition (super invocation and field initialization) */
1154 block_begin constructor_block_end
1156 BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1159 | block_begin explicit_constructor_invocation constructor_block_end
1161 | block_begin block_statements constructor_block_end
1163 | block_begin explicit_constructor_invocation block_statements constructor_block_end
1167 constructor_block_end:
1171 /* Error recovery for that rule moved down expression_statement: rule. */
1172 explicit_constructor_invocation:
1173 this_or_super OP_TK CP_TK SC_TK
1175 $$ = build_method_invocation ($1, NULL_TREE);
1176 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1177 $$ = java_method_add_stmt (current_function_decl, $$);
1179 | this_or_super OP_TK argument_list CP_TK SC_TK
1181 $$ = build_method_invocation ($1, $3);
1182 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1183 $$ = java_method_add_stmt (current_function_decl, $$);
1185 /* Added, JDK1.1 inner classes. Modified because the rule
1186 'primary' couldn't work. */
1187 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1188 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1189 | name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1190 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1193 this_or_super: /* Added, simplifies error diagnostics */
1196 tree wfl = build_wfl_node (this_identifier_node);
1197 EXPR_WFL_LINECOL (wfl) = $1.location;
1202 tree wfl = build_wfl_node (super_identifier_node);
1203 EXPR_WFL_LINECOL (wfl) = $1.location;
1208 /* 19.9 Productions from 9: Interfaces */
1209 /* 19.9.1 Productions from 9.1: Interfaces Declarations */
1210 interface_declaration:
1211 INTERFACE_TK identifier
1212 { create_interface (0, $2, NULL_TREE); }
1214 | modifiers INTERFACE_TK identifier
1215 { create_interface ($1, $3, NULL_TREE); }
1217 | INTERFACE_TK identifier extends_interfaces
1218 { create_interface (0, $2, $3); }
1220 | modifiers INTERFACE_TK identifier extends_interfaces
1221 { create_interface ($1, $3, $4); }
1223 | INTERFACE_TK identifier error
1224 {yyerror ("'{' expected"); RECOVER;}
1225 | modifiers INTERFACE_TK identifier error
1226 {yyerror ("'{' expected"); RECOVER;}
1230 EXTENDS_TK interface_type
1232 ctxp->interface_number = 1;
1233 $$ = build_tree_list ($2, NULL_TREE);
1235 | extends_interfaces C_TK interface_type
1237 ctxp->interface_number++;
1238 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1241 {yyerror ("Invalid interface type"); RECOVER;}
1242 | extends_interfaces C_TK error
1243 {yyerror ("Missing term"); RECOVER;}
1249 | OCB_TK interface_member_declarations CCB_TK
1253 interface_member_declarations:
1254 interface_member_declaration
1255 | interface_member_declarations interface_member_declaration
1258 interface_member_declaration:
1259 constant_declaration
1260 | abstract_method_declaration
1261 | class_declaration /* Added, JDK1.1 inner classes */
1262 { end_class_declaration (1); }
1263 | interface_declaration /* Added, JDK1.1 inner interfaces */
1264 { end_class_declaration (1); }
1267 constant_declaration:
1271 abstract_method_declaration:
1274 check_abstract_method_header ($1);
1275 current_function_decl = NULL_TREE; /* FIXME ? */
1277 | method_header error
1278 {yyerror ("';' expected"); RECOVER;}
1281 /* 19.10 Productions from 10: Arrays */
1284 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1285 | OCB_TK variable_initializers CCB_TK
1286 { $$ = build_new_array_init ($1.location, $2); }
1287 | OCB_TK variable_initializers C_TK CCB_TK
1288 { $$ = build_new_array_init ($1.location, $2); }
1291 variable_initializers:
1292 variable_initializer
1294 $$ = tree_cons (maybe_build_array_element_wfl ($1),
1297 | variable_initializers C_TK variable_initializer
1299 $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1301 | variable_initializers C_TK error
1302 {yyerror ("Missing term"); RECOVER;}
1305 /* 19.11 Production from 14: Blocks and Statements */
1309 /* Store the location of the `}' when doing xrefs */
1310 if (current_function_decl && flag_emit_xref)
1311 DECL_END_SOURCE_LINE (current_function_decl) =
1312 EXPR_WFL_ADD_COL ($2.location, 1);
1313 $$ = empty_stmt_node;
1315 | block_begin block_statements block_end
1327 maybe_absorb_scoping_blocks ();
1328 /* Store the location of the `}' when doing xrefs */
1329 if (current_function_decl && flag_emit_xref)
1330 DECL_END_SOURCE_LINE (current_function_decl) =
1331 EXPR_WFL_ADD_COL ($1.location, 1);
1333 if (!BLOCK_SUBBLOCKS ($$))
1334 BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1340 | block_statements block_statement
1344 local_variable_declaration_statement
1346 { java_method_add_stmt (current_function_decl, $1); }
1347 | class_declaration /* Added, JDK1.1 local classes */
1349 LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1350 end_class_declaration (1);
1354 local_variable_declaration_statement:
1355 local_variable_declaration SC_TK /* Can't catch missing ';' here */
1358 local_variable_declaration:
1359 type variable_declarators
1360 { declare_local_variables (0, $1, $2); }
1361 | final type variable_declarators /* Added, JDK1.1 final locals */
1362 { declare_local_variables ($1, $2, $3); }
1366 statement_without_trailing_substatement
1369 | if_then_else_statement
1372 { $$ = exit_block (); }
1376 statement_without_trailing_substatement
1377 | labeled_statement_nsi
1378 | if_then_else_statement_nsi
1379 | while_statement_nsi
1381 { $$ = exit_block (); }
1384 statement_without_trailing_substatement:
1387 | expression_statement
1391 | continue_statement
1393 | synchronized_statement
1400 { $$ = empty_stmt_node; }
1404 identifier REL_CL_TK
1406 $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1407 EXPR_WFL_NODE ($1));
1409 push_labeled_block ($$);
1410 PUSH_LABELED_BLOCK ($$);
1415 label_decl statement
1416 { $$ = finish_labeled_statement ($1, $2); }
1418 {yyerror ("':' expected"); RECOVER;}
1421 labeled_statement_nsi:
1422 label_decl statement_nsi
1423 { $$ = finish_labeled_statement ($1, $2); }
1426 /* We concentrate here a bunch of error handling rules that we couldn't write
1427 earlier, because expression_statement catches a missing ';'. */
1428 expression_statement:
1429 statement_expression SC_TK
1431 /* We have a statement. Generate a WFL around it so
1433 $$ = build_expr_wfl ($1, input_filename, lineno, 0);
1434 /* We know we have a statement, so set the debug
1435 info to be eventually generate here. */
1436 $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1440 if (ctxp->prevent_ese != lineno)
1441 yyerror ("Invalid expression statement");
1442 DRECOVER (expr_stmt);
1446 if (ctxp->prevent_ese != lineno)
1447 yyerror ("Invalid expression statement");
1448 DRECOVER (expr_stmt);
1452 if (ctxp->prevent_ese != lineno)
1453 yyerror ("Invalid expression statement");
1454 DRECOVER (expr_stmt);
1456 | this_or_super OP_TK error
1457 {yyerror ("')' expected"); RECOVER;}
1458 | this_or_super OP_TK CP_TK error
1460 parse_ctor_invocation_error ();
1463 | this_or_super OP_TK argument_list error
1464 {yyerror ("')' expected"); RECOVER;}
1465 | this_or_super OP_TK argument_list CP_TK error
1467 parse_ctor_invocation_error ();
1470 | name DOT_TK SUPER_TK error
1471 {yyerror ("'(' expected"); RECOVER;}
1472 | name DOT_TK SUPER_TK OP_TK error
1473 {yyerror ("')' expected"); RECOVER;}
1474 | name DOT_TK SUPER_TK OP_TK argument_list error
1475 {yyerror ("')' expected"); RECOVER;}
1476 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1477 {yyerror ("';' expected"); RECOVER;}
1478 | name DOT_TK SUPER_TK OP_TK CP_TK error
1479 {yyerror ("';' expected"); RECOVER;}
1482 statement_expression:
1484 | pre_increment_expression
1485 | pre_decrement_expression
1486 | post_increment_expression
1487 | post_decrement_expression
1489 | class_instance_creation_expression
1493 IF_TK OP_TK expression CP_TK statement
1495 $$ = build_if_else_statement ($2.location, $3,
1499 {yyerror ("'(' expected"); RECOVER;}
1501 {yyerror ("Missing term"); RECOVER;}
1502 | IF_TK OP_TK expression error
1503 {yyerror ("')' expected"); RECOVER;}
1506 if_then_else_statement:
1507 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1508 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1511 if_then_else_statement_nsi:
1512 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1513 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1523 /* Make into "proper list" of COMPOUND_EXPRs.
1524 I.e. make the last statment also have its own
1526 maybe_absorb_scoping_blocks ();
1527 TREE_OPERAND ($1, 1) = exit_block ();
1528 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1533 SWITCH_TK OP_TK expression CP_TK
1535 $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1536 EXPR_WFL_LINECOL ($$) = $2.location;
1539 {yyerror ("'(' expected"); RECOVER;}
1540 | SWITCH_TK OP_TK error
1541 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1542 | SWITCH_TK OP_TK expression CP_TK error
1543 {yyerror ("'{' expected"); RECOVER;}
1546 /* Default assignment is there to avoid type node on switch_block
1552 | OCB_TK switch_labels CCB_TK
1554 | OCB_TK switch_block_statement_groups CCB_TK
1556 | OCB_TK switch_block_statement_groups switch_labels CCB_TK
1560 switch_block_statement_groups:
1561 switch_block_statement_group
1562 | switch_block_statement_groups switch_block_statement_group
1565 switch_block_statement_group:
1566 switch_labels block_statements
1571 | switch_labels switch_label
1575 CASE_TK constant_expression REL_CL_TK
1577 tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1578 EXPR_WFL_LINECOL (lab) = $1.location;
1579 java_method_add_stmt (current_function_decl, lab);
1581 | DEFAULT_TK REL_CL_TK
1583 tree lab = build1 (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1584 EXPR_WFL_LINECOL (lab) = $1.location;
1585 java_method_add_stmt (current_function_decl, lab);
1588 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1589 | CASE_TK constant_expression error
1590 {yyerror ("':' expected"); RECOVER;}
1592 {yyerror ("':' expected"); RECOVER;}
1596 WHILE_TK OP_TK expression CP_TK
1598 tree body = build_loop_body ($2.location, $3, 0);
1599 $$ = build_new_loop (body);
1604 while_expression statement
1605 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1607 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1608 | WHILE_TK OP_TK error
1609 {yyerror ("Missing term and ')' expected"); RECOVER;}
1610 | WHILE_TK OP_TK expression error
1611 {yyerror ("')' expected"); RECOVER;}
1614 while_statement_nsi:
1615 while_expression statement_nsi
1616 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1622 tree body = build_loop_body (0, NULL_TREE, 1);
1623 $$ = build_new_loop (body);
1625 /* Need error handing here. FIXME */
1629 do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1630 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1634 for_begin SC_TK expression SC_TK for_update CP_TK statement
1636 if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1637 $3 = build_wfl_node ($3);
1638 $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1640 | for_begin SC_TK SC_TK for_update CP_TK statement
1642 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1643 /* We have not condition, so we get rid of the EXIT_EXPR */
1644 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1647 | for_begin SC_TK error
1648 {yyerror ("Invalid control expression"); RECOVER;}
1649 | for_begin SC_TK expression SC_TK error
1650 {yyerror ("Invalid update expression"); RECOVER;}
1651 | for_begin SC_TK SC_TK error
1652 {yyerror ("Invalid update expression"); RECOVER;}
1656 for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1657 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1658 | for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1660 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1661 /* We have not condition, so we get rid of the EXIT_EXPR */
1662 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1670 /* This scope defined for local variable that may be
1671 defined within the scope of the for loop */
1675 {yyerror ("'(' expected"); DRECOVER(for_1);}
1676 | FOR_TK OP_TK error
1677 {yyerror ("Invalid init statement"); RECOVER;}
1683 /* We now declare the loop body. The loop is
1684 declared as a for loop. */
1685 tree body = build_loop_body (0, NULL_TREE, 0);
1686 $$ = build_new_loop (body);
1687 FOR_LOOP_P ($$) = 1;
1688 /* The loop is added to the current block the for
1689 statement is defined within */
1690 java_method_add_stmt (current_function_decl, $$);
1693 for_init: /* Can be empty */
1694 { $$ = empty_stmt_node; }
1695 | statement_expression_list
1697 /* Init statement recorded within the previously
1698 defined block scope */
1699 $$ = java_method_add_stmt (current_function_decl, $1);
1701 | local_variable_declaration
1703 /* Local variable are recorded within the previously
1704 defined block scope */
1707 | statement_expression_list error
1708 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1711 for_update: /* Can be empty */
1712 {$$ = empty_stmt_node;}
1713 | statement_expression_list
1714 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1717 statement_expression_list:
1718 statement_expression
1719 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1720 | statement_expression_list C_TK statement_expression
1721 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1722 | statement_expression_list C_TK error
1723 {yyerror ("Missing term"); RECOVER;}
1728 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1729 | BREAK_TK identifier SC_TK
1730 { $$ = build_bc_statement ($1.location, 1, $2); }
1732 {yyerror ("Missing term"); RECOVER;}
1733 | BREAK_TK identifier error
1734 {yyerror ("';' expected"); RECOVER;}
1739 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1740 | CONTINUE_TK identifier SC_TK
1741 { $$ = build_bc_statement ($1.location, 0, $2); }
1743 {yyerror ("Missing term"); RECOVER;}
1744 | CONTINUE_TK identifier error
1745 {yyerror ("';' expected"); RECOVER;}
1750 { $$ = build_return ($1.location, NULL_TREE); }
1751 | RETURN_TK expression SC_TK
1752 { $$ = build_return ($1.location, $2); }
1754 {yyerror ("Missing term"); RECOVER;}
1755 | RETURN_TK expression error
1756 {yyerror ("';' expected"); RECOVER;}
1760 THROW_TK expression SC_TK
1762 $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1763 EXPR_WFL_LINECOL ($$) = $1.location;
1766 {yyerror ("Missing term"); RECOVER;}
1767 | THROW_TK expression error
1768 {yyerror ("';' expected"); RECOVER;}
1771 synchronized_statement:
1772 synchronized OP_TK expression CP_TK block
1774 $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1775 EXPR_WFL_LINECOL ($$) =
1776 EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1778 | synchronized OP_TK expression CP_TK error
1779 {yyerror ("'{' expected"); RECOVER;}
1780 | synchronized error
1781 {yyerror ("'(' expected"); RECOVER;}
1782 | synchronized OP_TK error CP_TK
1783 {yyerror ("Missing term"); RECOVER;}
1784 | synchronized OP_TK error
1785 {yyerror ("Missing term"); RECOVER;}
1792 "Illegal modifier `%s'. Only `synchronized' was expected here",
1793 $1, ACC_SYNCHRONIZED);
1794 if ($1 != ACC_SYNCHRONIZED)
1795 MODIFIER_WFL (SYNCHRONIZED_TK) =
1796 build_wfl_node (NULL_TREE);
1801 TRY_TK block catches
1802 { $$ = build_try_statement ($1.location, $2, $3); }
1803 | TRY_TK block finally
1804 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1805 | TRY_TK block catches finally
1806 { $$ = build_try_finally_statement
1807 ($1.location, build_try_statement ($1.location,
1811 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1816 | catches catch_clause
1818 TREE_CHAIN ($2) = $1;
1824 catch_clause_parameter block
1826 java_method_add_stmt (current_function_decl, $2);
1831 catch_clause_parameter:
1832 CATCH_TK OP_TK formal_parameter CP_TK
1834 /* We add a block to define a scope for
1835 formal_parameter (CCBP). The formal parameter is
1836 declared initialized by the appropriate function
1838 tree ccpb = enter_block ();
1839 tree init = build_assignment (ASSIGN_TK, $2.location,
1841 soft_exceptioninfo_call_node);
1842 declare_local_variables (0, TREE_VALUE ($3),
1843 build_tree_list (TREE_PURPOSE ($3),
1845 $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1846 EXPR_WFL_LINECOL ($$) = $1.location;
1849 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1850 | CATCH_TK OP_TK error
1852 yyerror ("Missing term or ')' expected");
1853 RECOVER; $$ = NULL_TREE;
1855 | CATCH_TK OP_TK error CP_TK /* That's for () */
1856 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1863 {yyerror ("'{' expected"); RECOVER; }
1866 /* 19.12 Production from 15: Expressions */
1868 primary_no_new_array
1869 | array_creation_expression
1872 primary_no_new_array:
1875 { $$ = build_this ($1.location); }
1876 | OP_TK expression CP_TK
1878 | class_instance_creation_expression
1883 /* Added, JDK1.1 inner classes. Documentation is wrong
1884 refering to a 'ClassName' (class_name) rule that doesn't
1885 exist. Used name: instead. */
1886 | name DOT_TK THIS_TK
1888 tree wfl = build_wfl_node (this_identifier_node);
1889 $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1891 | OP_TK expression error
1892 {yyerror ("')' expected"); RECOVER;}
1894 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1895 | primitive_type DOT_TK error
1896 {yyerror ("'class' expected" ); RECOVER;}
1897 | VOID_TK DOT_TK error
1898 {yyerror ("'class' expected" ); RECOVER;}
1901 /* Added, JDK1.1 type literals. We can't use `type' directly, so we
1902 broke the rule down a bit. */
1905 primitive_type OSB_TK CSB_TK
1907 $$ = build_java_array_type ($1, -1);
1908 CLASS_LOADED_P ($$) = 1;
1910 | name OSB_TK CSB_TK
1911 { $$ = build_unresolved_array_type ($1); }
1912 /* This triggers two reduce/reduce conflict between array_type_literal and
1914 | array_type OSB_TK CSB_TK
1915 { $$ = build_unresolved_array_type ($1); }
1920 name DOT_TK CLASS_TK
1921 { $$ = build_incomplete_class_ref ($2.location, $1); }
1922 | array_type_literal DOT_TK CLASS_TK
1923 { $$ = build_incomplete_class_ref ($2.location, $1); }
1924 | primitive_type DOT_TK CLASS_TK
1925 { $$ = build_class_ref ($1); }
1926 | VOID_TK DOT_TK CLASS_TK
1927 { $$ = build_class_ref (void_type_node); }
1930 class_instance_creation_expression:
1931 NEW_TK class_type OP_TK argument_list CP_TK
1932 { $$ = build_new_invocation ($2, $4); }
1933 | NEW_TK class_type OP_TK CP_TK
1934 { $$ = build_new_invocation ($2, NULL_TREE); }
1935 | anonymous_class_creation
1936 /* Added, JDK1.1 inner classes, modified to use name or
1937 primary instead of primary solely which couldn't work in
1939 | something_dot_new identifier OP_TK CP_TK
1941 tree ctor = build_new_invocation ($2, NULL_TREE);
1942 $$ = make_qualified_primary ($1, ctor,
1943 EXPR_WFL_LINECOL ($1));
1945 | something_dot_new identifier OP_TK CP_TK class_body
1946 | something_dot_new identifier OP_TK argument_list CP_TK
1948 tree ctor = build_new_invocation ($2, $4);
1949 $$ = make_qualified_primary ($1, ctor,
1950 EXPR_WFL_LINECOL ($1));
1952 | something_dot_new identifier OP_TK argument_list CP_TK class_body
1953 | NEW_TK error SC_TK
1954 {yyerror ("'(' expected"); DRECOVER(new_1);}
1955 | NEW_TK class_type error
1956 {yyerror ("'(' expected"); RECOVER;}
1957 | NEW_TK class_type OP_TK error
1958 {yyerror ("')' or term expected"); RECOVER;}
1959 | NEW_TK class_type OP_TK argument_list error
1960 {yyerror ("')' expected"); RECOVER;}
1961 | something_dot_new error
1962 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
1963 | something_dot_new identifier error
1964 {yyerror ("'(' expected"); RECOVER;}
1967 /* Created after JDK1.1 rules originally added to
1968 class_instance_creation_expression, but modified to use
1969 'class_type' instead of 'TypeName' (type_name) which is mentionned
1970 in the documentation but doesn't exist. */
1972 anonymous_class_creation:
1973 NEW_TK class_type OP_TK argument_list CP_TK
1974 { create_anonymous_class ($1.location, $2); }
1977 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
1978 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
1980 end_class_declaration (1);
1982 /* Now we can craft the new expression */
1983 $$ = build_new_invocation (id, $4);
1985 /* Note that we can't possibly be here if
1986 `class_type' is an interface (in which case the
1987 anonymous class extends Object and implements
1988 `class_type', hence its constructor can't have
1991 /* Otherwise, the innerclass must feature a
1992 constructor matching `argument_list'. Anonymous
1993 classes are a bit special: it's impossible to
1994 define constructor for them, hence constructors
1995 must be generated following the hints provided by
1996 the `new' expression. Whether a super constructor
1997 of that nature exists or not is to be verified
1998 later on in verify_constructor_super.
2000 It's during the expansion of a `new' statement
2001 refering to an anonymous class that a ctor will
2002 be generated for the anonymous class, with the
2006 | NEW_TK class_type OP_TK CP_TK
2007 { create_anonymous_class ($1.location, $2); }
2010 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2011 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2013 end_class_declaration (1);
2015 /* Now we can craft the new expression. The
2016 statement doesn't need to be remember so that a
2017 constructor can be generated, since its signature
2018 is already known. */
2019 $$ = build_new_invocation (id, NULL_TREE);
2023 something_dot_new: /* Added, not part of the specs. */
2026 | primary DOT_TK NEW_TK
2033 $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2034 ctxp->formal_parameter_number = 1;
2036 | argument_list C_TK expression
2038 ctxp->formal_parameter_number += 1;
2039 $$ = tree_cons (NULL_TREE, $3, $1);
2041 | argument_list C_TK error
2042 {yyerror ("Missing term"); RECOVER;}
2045 array_creation_expression:
2046 NEW_TK primitive_type dim_exprs
2047 { $$ = build_newarray_node ($2, $3, 0); }
2048 | NEW_TK class_or_interface_type dim_exprs
2049 { $$ = build_newarray_node ($2, $3, 0); }
2050 | NEW_TK primitive_type dim_exprs dims
2051 { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
2052 | NEW_TK class_or_interface_type dim_exprs dims
2053 { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
2054 /* Added, JDK1.1 anonymous array. Initial documentation rule
2056 | NEW_TK class_or_interface_type dims array_initializer
2059 while (CURRENT_OSB (ctxp)--)
2060 obstack_1grow (&temporary_obstack, '[');
2061 sig = obstack_finish (&temporary_obstack);
2062 $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2063 $2, get_identifier (sig), $4);
2065 | NEW_TK primitive_type dims array_initializer
2068 while (CURRENT_OSB (ctxp)--)
2069 type = build_java_array_type (type, -1);
2070 $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2071 build_pointer_type (type), NULL_TREE, $4);
2073 | NEW_TK error CSB_TK
2074 {yyerror ("'[' expected"); DRECOVER ("]");}
2075 | NEW_TK error OSB_TK
2076 {yyerror ("']' expected"); RECOVER;}
2081 { $$ = build_tree_list (NULL_TREE, $1); }
2082 | dim_exprs dim_expr
2083 { $$ = tree_cons (NULL_TREE, $2, $$); }
2087 OSB_TK expression CSB_TK
2089 if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2091 $2 = build_wfl_node ($2);
2092 TREE_TYPE ($2) = NULL_TREE;
2094 EXPR_WFL_LINECOL ($2) = $1.location;
2097 | OSB_TK expression error
2098 {yyerror ("']' expected"); RECOVER;}
2101 yyerror ("Missing term");
2102 yyerror ("']' expected");
2111 /* If not initialized, allocate memory for the osb
2113 if (!ctxp->osb_limit)
2115 allocate = ctxp->osb_limit = 32;
2116 ctxp->osb_depth = -1;
2118 /* If capacity overflown, reallocate a bigger chunk */
2119 else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2120 allocate = ctxp->osb_limit << 1;
2124 allocate *= sizeof (int);
2125 if (ctxp->osb_number)
2126 ctxp->osb_number = (int *)xrealloc (ctxp->osb_number,
2129 ctxp->osb_number = (int *)xmalloc (allocate);
2132 CURRENT_OSB (ctxp) = 1;
2134 | dims OSB_TK CSB_TK
2135 { CURRENT_OSB (ctxp)++; }
2137 { yyerror ("']' expected"); RECOVER;}
2141 primary DOT_TK identifier
2142 { $$ = make_qualified_primary ($1, $3, $2.location); }
2143 /* FIXME - REWRITE TO:
2144 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2145 | SUPER_TK DOT_TK identifier
2148 build_wfl_node (super_identifier_node);
2149 EXPR_WFL_LINECOL (super_wfl) = $1.location;
2150 $$ = make_qualified_name (super_wfl, $3, $2.location);
2153 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2158 { $$ = build_method_invocation ($1, NULL_TREE); }
2159 | name OP_TK argument_list CP_TK
2160 { $$ = build_method_invocation ($1, $3); }
2161 | primary DOT_TK identifier OP_TK CP_TK
2163 if (TREE_CODE ($1) == THIS_EXPR)
2164 $$ = build_this_super_qualified_invocation
2165 (1, $3, NULL_TREE, 0, $2.location);
2168 tree invok = build_method_invocation ($3, NULL_TREE);
2169 $$ = make_qualified_primary ($1, invok, $2.location);
2172 | primary DOT_TK identifier OP_TK argument_list CP_TK
2174 if (TREE_CODE ($1) == THIS_EXPR)
2175 $$ = build_this_super_qualified_invocation
2176 (1, $3, $5, 0, $2.location);
2179 tree invok = build_method_invocation ($3, $5);
2180 $$ = make_qualified_primary ($1, invok, $2.location);
2183 | SUPER_TK DOT_TK identifier OP_TK CP_TK
2185 $$ = build_this_super_qualified_invocation
2186 (0, $3, NULL_TREE, $1.location, $2.location);
2188 | SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2190 $$ = build_this_super_qualified_invocation
2191 (0, $3, $5, $1.location, $2.location);
2193 /* Screws up thing. I let it here until I'm convinced it can
2195 | primary DOT_TK error
2196 {yyerror ("'(' expected"); DRECOVER(bad);} */
2197 | SUPER_TK DOT_TK error CP_TK
2198 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2199 | SUPER_TK DOT_TK error DOT_TK
2200 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2204 name OSB_TK expression CSB_TK
2205 { $$ = build_array_ref ($2.location, $1, $3); }
2206 | primary_no_new_array OSB_TK expression CSB_TK
2207 { $$ = build_array_ref ($2.location, $1, $3); }
2210 yyerror ("Missing term and ']' expected");
2211 DRECOVER(array_access);
2213 | name OSB_TK expression error
2215 yyerror ("']' expected");
2216 DRECOVER(array_access);
2218 | primary_no_new_array OSB_TK error
2220 yyerror ("Missing term and ']' expected");
2221 DRECOVER(array_access);
2223 | primary_no_new_array OSB_TK expression error
2225 yyerror ("']' expected");
2226 DRECOVER(array_access);
2233 | post_increment_expression
2234 | post_decrement_expression
2237 post_increment_expression:
2238 postfix_expression INCR_TK
2239 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2242 post_decrement_expression:
2243 postfix_expression DECR_TK
2244 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2248 pre_increment_expression
2249 | pre_decrement_expression
2250 | PLUS_TK unary_expression
2251 {$$ = build_unaryop ($1.token, $1.location, $2); }
2252 | MINUS_TK unary_expression
2253 {$$ = build_unaryop ($1.token, $1.location, $2); }
2254 | unary_expression_not_plus_minus
2256 {yyerror ("Missing term"); RECOVER}
2258 {yyerror ("Missing term"); RECOVER}
2261 pre_increment_expression:
2262 INCR_TK unary_expression
2263 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2265 {yyerror ("Missing term"); RECOVER}
2268 pre_decrement_expression:
2269 DECR_TK unary_expression
2270 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2272 {yyerror ("Missing term"); RECOVER}
2275 unary_expression_not_plus_minus:
2277 | NOT_TK unary_expression
2278 {$$ = build_unaryop ($1.token, $1.location, $2); }
2279 | NEG_TK unary_expression
2280 {$$ = build_unaryop ($1.token, $1.location, $2); }
2283 {yyerror ("Missing term"); RECOVER}
2285 {yyerror ("Missing term"); RECOVER}
2288 cast_expression: /* Error handling here is potentially weak */
2289 OP_TK primitive_type dims CP_TK unary_expression
2292 while (CURRENT_OSB (ctxp)--)
2293 type = build_java_array_type (type, -1);
2295 $$ = build_cast ($1.location, type, $5);
2297 | OP_TK primitive_type CP_TK unary_expression
2298 { $$ = build_cast ($1.location, $2, $4); }
2299 | OP_TK expression CP_TK unary_expression_not_plus_minus
2300 { $$ = build_cast ($1.location, $2, $4); }
2301 | OP_TK name dims CP_TK unary_expression_not_plus_minus
2304 while (CURRENT_OSB (ctxp)--)
2305 obstack_1grow (&temporary_obstack, '[');
2307 obstack_grow0 (&temporary_obstack,
2308 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2309 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2310 ptr = obstack_finish (&temporary_obstack);
2311 EXPR_WFL_NODE ($2) = get_identifier (ptr);
2312 $$ = build_cast ($1.location, $2, $5);
2314 | OP_TK primitive_type OSB_TK error
2315 {yyerror ("']' expected, invalid type expression");}
2318 if (ctxp->prevent_ese != lineno)
2319 yyerror ("Invalid type expression"); RECOVER;
2322 | OP_TK primitive_type dims CP_TK error
2323 {yyerror ("Missing term"); RECOVER;}
2324 | OP_TK primitive_type CP_TK error
2325 {yyerror ("Missing term"); RECOVER;}
2326 | OP_TK name dims CP_TK error
2327 {yyerror ("Missing term"); RECOVER;}
2330 multiplicative_expression:
2332 | multiplicative_expression MULT_TK unary_expression
2334 $$ = build_binop (BINOP_LOOKUP ($2.token),
2335 $2.location, $1, $3);
2337 | multiplicative_expression DIV_TK unary_expression
2339 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2342 | multiplicative_expression REM_TK unary_expression
2344 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2347 | multiplicative_expression MULT_TK error
2348 {yyerror ("Missing term"); RECOVER;}
2349 | multiplicative_expression DIV_TK error
2350 {yyerror ("Missing term"); RECOVER;}
2351 | multiplicative_expression REM_TK error
2352 {yyerror ("Missing term"); RECOVER;}
2355 additive_expression:
2356 multiplicative_expression
2357 | additive_expression PLUS_TK multiplicative_expression
2359 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2362 | additive_expression MINUS_TK multiplicative_expression
2364 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2367 | additive_expression PLUS_TK error
2368 {yyerror ("Missing term"); RECOVER;}
2369 | additive_expression MINUS_TK error
2370 {yyerror ("Missing term"); RECOVER;}
2375 | shift_expression LS_TK additive_expression
2377 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2380 | shift_expression SRS_TK additive_expression
2382 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2385 | shift_expression ZRS_TK additive_expression
2387 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2390 | shift_expression LS_TK error
2391 {yyerror ("Missing term"); RECOVER;}
2392 | shift_expression SRS_TK error
2393 {yyerror ("Missing term"); RECOVER;}
2394 | shift_expression ZRS_TK error
2395 {yyerror ("Missing term"); RECOVER;}
2398 relational_expression:
2400 | relational_expression LT_TK shift_expression
2402 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2405 | relational_expression GT_TK shift_expression
2407 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2410 | relational_expression LTE_TK shift_expression
2412 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2415 | relational_expression GTE_TK shift_expression
2417 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2420 | relational_expression INSTANCEOF_TK reference_type
2421 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2422 | relational_expression LT_TK error
2423 {yyerror ("Missing term"); RECOVER;}
2424 | relational_expression GT_TK error
2425 {yyerror ("Missing term"); RECOVER;}
2426 | relational_expression LTE_TK error
2427 {yyerror ("Missing term"); RECOVER;}
2428 | relational_expression GTE_TK error
2429 {yyerror ("Missing term"); RECOVER;}
2430 | relational_expression INSTANCEOF_TK error
2431 {yyerror ("Invalid reference type"); RECOVER;}
2434 equality_expression:
2435 relational_expression
2436 | equality_expression EQ_TK relational_expression
2438 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2441 | equality_expression NEQ_TK relational_expression
2443 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2446 | equality_expression EQ_TK error
2447 {yyerror ("Missing term"); RECOVER;}
2448 | equality_expression NEQ_TK error
2449 {yyerror ("Missing term"); RECOVER;}
2454 | and_expression AND_TK equality_expression
2456 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2459 | and_expression AND_TK error
2460 {yyerror ("Missing term"); RECOVER;}
2463 exclusive_or_expression:
2465 | exclusive_or_expression XOR_TK and_expression
2467 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2470 | exclusive_or_expression XOR_TK error
2471 {yyerror ("Missing term"); RECOVER;}
2474 inclusive_or_expression:
2475 exclusive_or_expression
2476 | inclusive_or_expression OR_TK exclusive_or_expression
2478 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2481 | inclusive_or_expression OR_TK error
2482 {yyerror ("Missing term"); RECOVER;}
2485 conditional_and_expression:
2486 inclusive_or_expression
2487 | conditional_and_expression BOOL_AND_TK inclusive_or_expression
2489 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2492 | conditional_and_expression BOOL_AND_TK error
2493 {yyerror ("Missing term"); RECOVER;}
2496 conditional_or_expression:
2497 conditional_and_expression
2498 | conditional_or_expression BOOL_OR_TK conditional_and_expression
2500 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2503 | conditional_or_expression BOOL_OR_TK error
2504 {yyerror ("Missing term"); RECOVER;}
2507 conditional_expression: /* Error handling here is weak */
2508 conditional_or_expression
2509 | conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2511 $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2512 EXPR_WFL_LINECOL ($$) = $2.location;
2514 | conditional_or_expression REL_QM_TK REL_CL_TK error
2517 yyerror ("Missing term");
2520 | conditional_or_expression REL_QM_TK error
2521 {yyerror ("Missing term"); DRECOVER (2);}
2522 | conditional_or_expression REL_QM_TK expression REL_CL_TK error
2523 {yyerror ("Missing term"); DRECOVER (3);}
2526 assignment_expression:
2527 conditional_expression
2532 left_hand_side assignment_operator assignment_expression
2533 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2534 | left_hand_side assignment_operator error
2536 if (ctxp->prevent_ese != lineno)
2537 yyerror ("Missing term");
2548 assignment_operator:
2554 assignment_expression
2557 constant_expression:
2564 /* This section of the code deal with save/restoring parser contexts.
2565 Add mode documentation here. FIXME */
2567 /* Helper function. Create a new parser context. With
2568 COPY_FROM_PREVIOUS set to a non zero value, content of the previous
2569 context is copied, otherwise, the new context is zeroed. The newly
2570 created context becomes the current one. */
2573 create_new_parser_context (copy_from_previous)
2574 int copy_from_previous;
2576 struct parser_ctxt *new;
2578 new = (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt));
2579 if (copy_from_previous)
2581 memcpy ((PTR)new, (PTR)ctxp, sizeof (struct parser_ctxt));
2582 new->saved_data_ctx = 1;
2585 bzero ((PTR) new, sizeof (struct parser_ctxt));
2591 /* Create a new parser context and make it the current one. */
2594 java_push_parser_context ()
2596 create_new_parser_context (0);
2599 ctxp->incomplete_class = ctxp->next->incomplete_class;
2600 ctxp->gclass_list = ctxp->next->gclass_list;
2605 java_pop_parser_context (generate)
2609 struct parser_ctxt *toFree, *next;
2618 next->incomplete_class = ctxp->incomplete_class;
2619 next->gclass_list = ctxp->gclass_list;
2620 lineno = ctxp->lineno;
2621 finput = ctxp->finput;
2622 current_class = ctxp->current_class;
2625 /* Set the single import class file flag to 0 for the current list
2626 of imported things */
2627 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2628 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 0;
2630 /* And restore those of the previous context */
2631 if ((ctxp = next)) /* Assignment is really meant here */
2632 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2633 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 1;
2635 /* If we pushed a context to parse a class intended to be generated,
2636 we keep it so we can remember the class. What we could actually
2637 do is to just update a list of class names. */
2640 toFree->next = ctxp_for_generation;
2641 ctxp_for_generation = toFree;
2647 /* Create a parser context for the use of saving some global
2651 java_parser_context_save_global ()
2655 java_push_parser_context ();
2656 ctxp->saved_data_ctx = 1;
2659 /* If this context already stores data, create a new one suitable
2660 for data storage. */
2661 else if (ctxp->saved_data)
2662 create_new_parser_context (1);
2664 ctxp->finput = finput;
2665 ctxp->lineno = lineno;
2666 ctxp->current_class = current_class;
2667 ctxp->filename = input_filename;
2668 ctxp->current_function_decl = current_function_decl;
2669 ctxp->saved_data = 1;
2672 /* Restore some global variables from the previous context. Make the
2673 previous context the current one. */
2676 java_parser_context_restore_global ()
2678 finput = ctxp->finput;
2679 lineno = ctxp->lineno;
2680 current_class = ctxp->current_class;
2681 input_filename = ctxp->filename;
2682 current_function_decl = ctxp->current_function_decl;
2683 ctxp->saved_data = 0;
2684 if (ctxp->saved_data_ctx)
2685 java_pop_parser_context (0);
2688 /* Suspend vital data for the current class/function being parsed so
2689 that an other class can be parsed. Used to let local/anonymous
2690 classes be parsed. */
2693 java_parser_context_suspend ()
2695 /* This makes debugging through java_debug_context easier */
2696 static const char *name = "<inner buffer context>";
2698 /* Duplicate the previous context, use it to save the globals we're
2700 create_new_parser_context (1);
2701 ctxp->current_function_decl = current_function_decl;
2702 ctxp->current_class = current_class;
2704 /* Then create a new context which inherits all data from the
2705 previous one. This will be the new current context */
2706 create_new_parser_context (1);
2708 /* Help debugging */
2709 ctxp->next->filename = name;
2712 /* Resume vital data for the current class/function being parsed so
2713 that an other class can be parsed. Used to let local/anonymous
2714 classes be parsed. The trick is the data storing file position
2715 informations must be restored to their current value, so parsing
2716 can resume as if no context was ever saved. */
2719 java_parser_context_resume ()
2721 struct parser_ctxt *old = ctxp; /* This one is to be discarded */
2722 struct parser_ctxt *saver = old->next; /* This one contain saved info */
2723 struct parser_ctxt *restored = saver->next; /* This one is the old current */
2725 /* We need to inherit the list of classes to complete/generate */
2726 restored->incomplete_class = old->incomplete_class;
2727 restored->gclass_list = old->gclass_list;
2728 restored->classd_list = old->classd_list;
2729 restored->class_list = old->class_list;
2731 /* Restore the current class and function from the saver */
2732 current_class = saver->current_class;
2733 current_function_decl = saver->current_function_decl;
2735 /* Retrive the restored context */
2738 /* Re-installed the data for the parsing to carry on */
2739 bcopy (&old->marker_begining, &ctxp->marker_begining,
2740 (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2742 /* Buffer context can now be discarded */
2747 /* Add a new anchor node to which all statement(s) initializing static
2748 and non static initialized upon declaration field(s) will be
2752 java_parser_context_push_initialized_field ()
2756 node = build_tree_list (NULL_TREE, NULL_TREE);
2757 TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2758 CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2760 node = build_tree_list (NULL_TREE, NULL_TREE);
2761 TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2762 CPC_INITIALIZER_LIST (ctxp) = node;
2764 node = build_tree_list (NULL_TREE, NULL_TREE);
2765 TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2766 CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2769 /* Pop the lists of initialized field. If this lists aren't empty,
2770 remember them so we can use it to create and populate the $finit$
2771 or <clinit> functions. */
2774 java_parser_context_pop_initialized_field ()
2777 tree class_type = TREE_TYPE (GET_CPC ());
2779 if (CPC_INITIALIZER_LIST (ctxp))
2781 stmts = CPC_INITIALIZER_STMT (ctxp);
2782 CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2783 if (stmts && !java_error_count)
2784 TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2787 if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2789 stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2790 CPC_STATIC_INITIALIZER_LIST (ctxp) =
2791 TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2792 /* Keep initialization in order to enforce 8.5 */
2793 if (stmts && !java_error_count)
2794 TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2797 /* JDK 1.1 instance initializers */
2798 if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2800 stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2801 CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2802 TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2803 if (stmts && !java_error_count)
2804 TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2809 reorder_static_initialized (list)
2812 /* We have to keep things in order. The alias initializer have to
2813 come first, then the initialized regular field, in reverse to
2814 keep them in lexical order. */
2815 tree marker, previous = NULL_TREE;
2816 for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2817 if (TREE_CODE (marker) == TREE_LIST
2818 && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2821 /* No static initialized, the list is fine as is */
2823 list = TREE_CHAIN (marker);
2825 /* No marker? reverse the whole list */
2827 list = nreverse (list);
2829 /* Otherwise, reverse what's after the marker and the new reordered
2830 sublist will replace the marker. */
2833 TREE_CHAIN (previous) = NULL_TREE;
2834 list = nreverse (list);
2835 list = chainon (TREE_CHAIN (marker), list);
2840 /* Helper functions to dump the parser context stack. */
2842 #define TAB_CONTEXT(C) \
2843 {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2846 java_debug_context_do (tab)
2849 struct parser_ctxt *copy = ctxp;
2853 fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2855 fprintf (stderr, "filename: %s\n", copy->filename);
2857 fprintf (stderr, "lineno: %d\n", copy->lineno);
2859 fprintf (stderr, "package: %s\n",
2861 IDENTIFIER_POINTER (copy->package) : "<none>"));
2863 fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2865 fprintf (stderr, "saved data: %d\n", copy->saved_data);
2871 /* Dump the stacked up parser contexts. Intended to be called from a
2875 java_debug_context ()
2877 java_debug_context_do (0);
2882 /* Flag for the error report routine to issue the error the first time
2883 it's called (overriding the default behavior which is to drop the
2884 first invocation and honor the second one, taking advantage of a
2886 static int force_error = 0;
2888 /* Reporting an constructor invocation error. */
2890 parse_ctor_invocation_error ()
2892 if (DECL_CONSTRUCTOR_P (current_function_decl))
2893 yyerror ("Constructor invocation must be first thing in a constructor");
2895 yyerror ("Only constructors can invoke constructors");
2898 /* Reporting JDK1.1 features not implemented. */
2901 parse_jdk1_1_error (msg)
2904 sorry (": `%s' JDK1.1(TM) feature", msg);
2906 return empty_stmt_node;
2909 static int do_warning = 0;
2916 static int prev_lineno;
2917 static const char *prev_msg;
2920 char *remainder, *code_from_source;
2921 extern struct obstack temporary_obstack;
2923 if (!force_error && prev_lineno == lineno)
2926 /* Save current error location but report latter, when the context is
2928 if (ctxp->java_error_flag == 0)
2930 ctxp->java_error_flag = 1;
2932 /* Do something to use the previous line if we're reaching the
2933 end of the file... */
2934 #ifdef VERBOSE_SKELETON
2935 printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
2940 /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
2941 if (!force_error && msg == prev_msg && prev_lineno == elc.line)
2944 ctxp->java_error_flag = 0;
2946 java_warning_count++;
2950 if (elc.col == 0 && msg && msg[1] == ';')
2952 elc.col = ctxp->p_line->char_col-1;
2953 elc.line = ctxp->p_line->lineno;
2956 save_lineno = lineno;
2957 prev_lineno = lineno = elc.line;
2960 code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
2961 obstack_grow0 (&temporary_obstack,
2962 code_from_source, strlen (code_from_source));
2963 remainder = obstack_finish (&temporary_obstack);
2965 warning ("%s.\n%s", msg, remainder);
2967 error ("%s.\n%s", msg, remainder);
2969 /* This allow us to cheaply avoid an extra 'Invalid expression
2970 statement' error report when errors have been already reported on
2971 the same line. This occurs when we report an error but don't have
2972 a synchronization point other than ';', which
2973 expression_statement is the only one to take care of. */
2974 ctxp->prevent_ese = lineno = save_lineno;
2978 issue_warning_error_from_context (cl, msg, ap)
2983 const char *saved, *saved_input_filename;
2985 vsprintf (buffer, msg, ap);
2988 ctxp->elc.line = EXPR_WFL_LINENO (cl);
2989 ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
2990 (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
2992 /* We have a CL, that's a good reason for using it if it contains data */
2993 saved = ctxp->filename;
2994 if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
2995 ctxp->filename = EXPR_WFL_FILENAME (cl);
2996 saved_input_filename = input_filename;
2997 input_filename = ctxp->filename;
2999 java_error (buffer);
3000 ctxp->filename = saved;
3001 input_filename = saved_input_filename;
3005 /* Issue an error message at a current source line CL */
3008 parse_error_context VPARAMS ((tree cl, const char *msg, ...))
3010 #ifndef ANSI_PROTOTYPES
3017 #ifndef ANSI_PROTOTYPES
3018 cl = va_arg (ap, tree);
3019 msg = va_arg (ap, const char *);
3021 issue_warning_error_from_context (cl, msg, ap);
3025 /* Issue a warning at a current source line CL */
3028 parse_warning_context VPARAMS ((tree cl, const char *msg, ...))
3030 #ifndef ANSI_PROTOTYPES
3037 #ifndef ANSI_PROTOTYPES
3038 cl = va_arg (ap, tree);
3039 msg = va_arg (ap, const char *);
3042 force_error = do_warning = 1;
3043 issue_warning_error_from_context (cl, msg, ap);
3044 do_warning = force_error = 0;
3049 find_expr_with_wfl (node)
3057 switch (TREE_CODE (node))
3060 node = BLOCK_EXPR_BODY (node);
3064 to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3067 node = TREE_OPERAND (node, 1);
3071 node = TREE_OPERAND (node, 0);
3074 case LABELED_BLOCK_EXPR:
3075 node = TREE_OPERAND (node, 1);
3079 code = TREE_CODE_CLASS (TREE_CODE (node));
3080 if (((code == '1') || (code == '2') || (code == 'e'))
3081 && EXPR_WFL_LINECOL (node))
3089 /* Issue a missing return statement error. Uses METHOD to figure the
3090 last line of the method the error occurs in. */
3093 missing_return_error (method)
3096 EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
3097 parse_error_context (wfl_operator, "Missing return statement");
3100 /* Issue an unreachable statement error. From NODE, find the next
3101 statement to report appropriately. */
3103 unreachable_stmt_error (node)
3106 /* Browse node to find the next expression node that has a WFL. Use
3107 the location to report the error */
3108 if (TREE_CODE (node) == COMPOUND_EXPR)
3109 node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3111 node = find_expr_with_wfl (node);
3115 EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3116 parse_error_context (wfl_operator, "Unreachable statement");
3119 fatal ("Can't get valid statement - unreachable_stmt_error");
3123 java_report_errors ()
3125 if (java_error_count)
3126 fprintf (stderr, "%d error%s",
3127 java_error_count, (java_error_count == 1 ? "" : "s"));
3128 if (java_warning_count)
3129 fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3130 java_warning_count, (java_warning_count == 1 ? "" : "s"));
3131 if (java_error_count || java_warning_count)
3132 putc ('\n', stderr);
3133 return java_error_count;
3137 java_accstring_lookup (flags)
3140 static char buffer [80];
3141 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3143 /* Access modifier looked-up first for easier report on forbidden
3145 if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3146 if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3147 if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3148 if (flags & ACC_STATIC) COPY_RETURN ("static");
3149 if (flags & ACC_FINAL) COPY_RETURN ("final");
3150 if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3151 if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3152 if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3153 if (flags & ACC_NATIVE) COPY_RETURN ("native");
3154 if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3155 if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3162 /* Issuing error messages upon redefinition of classes, interfaces or
3166 classitf_redefinition_error (context, id, decl, cl)
3167 const char *context;
3170 parse_error_context (cl, "%s `%s' already defined in %s:%d",
3171 context, IDENTIFIER_POINTER (id),
3172 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3173 /* Here we should point out where its redefined. It's a unicode. FIXME */
3177 variable_redefinition_error (context, name, type, line)
3178 tree context, name, type;
3181 const char *type_name;
3183 /* Figure a proper name for type. We might haven't resolved it */
3184 if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3185 type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3187 type_name = lang_printable_name (type, 0);
3189 parse_error_context (context,
3190 "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3191 IDENTIFIER_POINTER (name),
3192 type_name, IDENTIFIER_POINTER (name), line);
3196 build_array_from_name (type, type_wfl, name, ret_name)
3197 tree type, type_wfl, name, *ret_name;
3202 /* Eventually get more dims */
3203 string = IDENTIFIER_POINTER (name);
3204 while (string [more_dims] == '[')
3207 /* If we have, then craft a new type for this variable */
3210 name = get_identifier (&string [more_dims]);
3212 /* If we have a pointer, use its type */
3213 if (TREE_CODE (type) == POINTER_TYPE)
3214 type = TREE_TYPE (type);
3216 /* Building the first dimension of a primitive type uses this
3218 if (JPRIMITIVE_TYPE_P (type))
3220 type = build_java_array_type (type, -1);
3221 CLASS_LOADED_P (type) = 1;
3224 /* Otherwise, if we have a WFL for this type, use it (the type
3225 is already an array on an unresolved type, and we just keep
3226 on adding dimensions) */
3230 /* Add all the dimensions */
3232 type = build_unresolved_array_type (type);
3234 /* The type may have been incomplete in the first place */
3236 type = obtain_incomplete_type (type);
3244 /* Build something that the type identifier resolver will identify as
3245 being an array to an unresolved type. TYPE_WFL is a WFL on a
3249 build_unresolved_array_type (type_or_wfl)
3254 /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3255 just create a array type */
3256 if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3258 tree type = build_java_array_type (type_or_wfl, -1);
3259 CLASS_LOADED_P (type) = CLASS_LOADED_P (type_or_wfl);
3263 obstack_1grow (&temporary_obstack, '[');
3264 obstack_grow0 (&temporary_obstack,
3265 IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3266 IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3267 ptr = obstack_finish (&temporary_obstack);
3268 return build_expr_wfl (get_identifier (ptr),
3269 EXPR_WFL_FILENAME (type_or_wfl),
3270 EXPR_WFL_LINENO (type_or_wfl),
3271 EXPR_WFL_COLNO (type_or_wfl));
3275 parser_add_interface (class_decl, interface_decl, wfl)
3276 tree class_decl, interface_decl, wfl;
3278 if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3279 parse_error_context (wfl, "Interface `%s' repeated",
3280 IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3283 /* Bulk of common class/interface checks. Return 1 if an error was
3284 encountered. TAG is 0 for a class, 1 for an interface. */
3287 check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
3288 int is_interface, flags;
3289 tree raw_name, qualified_name, decl, cl;
3292 int sca = 0; /* Static class allowed */
3293 int icaf = 0; /* Inner class allowed flags */
3294 int uaaf = CLASS_MODIFIERS; /* Usually allowed access flags */
3297 fprintf (stderr, " %s%s %s",
3298 (CPC_INNER_P () ? "inner" : ""),
3299 (is_interface ? "interface" : "class"),
3300 IDENTIFIER_POINTER (qualified_name));
3302 /* Scope of an interface/class type name:
3303 - Can't be imported by a single type import
3304 - Can't already exists in the package */
3305 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3306 && (node = find_name_in_single_imports (raw_name)))
3309 (cl, "%s name `%s' clashes with imported type `%s'",
3310 (is_interface ? "Interface" : "Class"),
3311 IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3314 if (decl && CLASS_COMPLETE_P (decl))
3316 classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3317 qualified_name, decl, cl);
3321 if (check_inner_class_redefinition (raw_name, cl))
3324 /* If public, file name should match class/interface name, except
3325 when dealing with an inner class */
3326 if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3330 /* Contains OS dependent assumption on path separator. FIXME */
3331 for (f = &input_filename [strlen (input_filename)];
3332 f != input_filename && f[0] != '/' && f[0] != DIR_SEPARATOR;
3335 if (f[0] == '/' || f[0] == DIR_SEPARATOR)
3337 if (strncmp (IDENTIFIER_POINTER (raw_name),
3338 f , IDENTIFIER_LENGTH (raw_name)) ||
3339 f [IDENTIFIER_LENGTH (raw_name)] != '.')
3341 (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3342 (is_interface ? "interface" : "class"),
3343 IDENTIFIER_POINTER (qualified_name),
3344 IDENTIFIER_POINTER (raw_name));
3347 /* Static classes can be declared only in top level classes. Note:
3348 once static, a inner class is a top level class. */
3349 if (flags & ACC_STATIC)
3351 /* Catch the specific error of declaring an class inner class
3352 with no toplevel enclosing class. Prevent check_modifiers from
3353 complaining a second time */
3354 if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3356 parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3357 IDENTIFIER_POINTER (qualified_name));
3360 /* Else, in the context of a top-level class declaration, let
3361 `check_modifiers' do its job, otherwise, give it a go */
3363 sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3366 /* Inner classes can be declared private or protected
3367 within their enclosing classes. */
3370 /* A class which is local to a block can't be public, private,
3371 protected or static. But it is created final, so allow this
3373 if (current_function_decl)
3374 icaf = sca = uaaf = ACC_FINAL;
3377 check_modifiers_consistency (flags);
3378 icaf = ACC_PRIVATE|ACC_PROTECTED;
3385 uaaf = INTERFACE_INNER_MODIFIERS;
3387 uaaf = INTERFACE_MODIFIERS;
3389 check_modifiers ("Illegal modifier `%s' for interface declaration",
3393 check_modifiers ((current_function_decl ?
3394 "Illegal modifier `%s' for local class declaration" :
3395 "Illegal modifier `%s' for class declaration"),
3396 flags, uaaf|sca|icaf);
3401 make_nested_class_name (cpc_list)
3409 make_nested_class_name (TREE_CHAIN (cpc_list));
3411 /* Pick the qualified name when dealing with the first upmost
3413 name = (TREE_CHAIN (cpc_list) ?
3414 TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3415 obstack_grow (&temporary_obstack,
3416 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3417 /* Why is NO_DOLLAR_IN_LABEL defined? */
3419 #ifdef NO_DOLLAR_IN_LABEL
3420 fatal ("make_nested_class_name: Can't use '$' as a separator "
3421 "for inner classes");
3424 obstack_1grow (&temporary_obstack, '$');
3427 /* Can't redefine a class already defined in an earlier scope. */
3430 check_inner_class_redefinition (raw_name, cl)
3435 for (scope_list = GET_CPC_LIST (); scope_list;
3436 scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3437 if (raw_name == GET_CPC_UN_NODE (scope_list))
3440 (cl, "The class name `%s' is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
3441 IDENTIFIER_POINTER (raw_name));
3448 find_as_inner_class (enclosing, name, cl)
3449 tree enclosing, name, cl;
3451 tree qual, to_return;
3455 name = TYPE_NAME (name);
3457 /* First search: within the scope of `enclosing', search for name */
3458 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3459 qual = EXPR_WFL_QUALIFICATION (cl);
3461 qual = build_tree_list (cl, NULL_TREE);
3463 qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3465 if ((to_return = find_as_inner_class_do (qual, enclosing)))
3468 /* We're dealing with a qualified name. Try to resolve thing until
3469 we get something that is an enclosing class. */
3470 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3472 tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3474 for(qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3475 qual = TREE_CHAIN (qual))
3477 acc = merge_qualified_name (acc,
3478 EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3479 BUILD_PTR_FROM_NAME (ptr, acc);
3480 decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3483 /* A NULL qual and a decl means that the search ended
3484 successfully?!? We have to do something then. FIXME */
3489 qual = EXPR_WFL_QUALIFICATION (cl);
3491 /* Otherwise, create a qual for the other part of the resolution. */
3493 qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3495 return find_as_inner_class_do (qual, enclosing);
3498 /* We go inside the list of sub classes and try to find a way
3502 find_as_inner_class_do (qual, enclosing)
3503 tree qual, enclosing;
3508 for (; qual && enclosing; qual = TREE_CHAIN (qual))
3510 tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3511 tree next_enclosing = NULL_TREE;
3514 for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3515 inner_list; inner_list = TREE_CHAIN (inner_list))
3517 if (TREE_VALUE (inner_list) == name_to_match)
3519 next_enclosing = TREE_PURPOSE (inner_list);
3523 enclosing = next_enclosing;
3526 return (!qual && enclosing ? enclosing : NULL_TREE);
3529 /* Reach all inner classes and tie their unqualified name to a
3533 set_nested_class_simple_name_value (outer, set)
3539 for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3540 IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3541 TREE_PURPOSE (l) : NULL_TREE);
3545 link_nested_class_to_enclosing ()
3547 if (GET_ENCLOSING_CPC ())
3549 tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3550 DECL_INNER_CLASS_LIST (enclosing) =
3551 tree_cons (GET_CPC (), GET_CPC_UN (),
3552 DECL_INNER_CLASS_LIST (enclosing));
3553 enclosing = enclosing;
3558 maybe_make_nested_class_name (name)
3561 tree id = NULL_TREE;
3565 make_nested_class_name (GET_CPC_LIST ());
3566 obstack_grow0 (&temporary_obstack,
3567 IDENTIFIER_POINTER (name),
3568 IDENTIFIER_LENGTH (name));
3569 id = get_identifier (obstack_finish (&temporary_obstack));
3571 QUALIFIED_P (id) = 1;
3576 /* If DECL is NULL, create and push a new DECL, record the current
3577 line CL and do other maintenance things. */
3580 maybe_create_class_interface_decl (decl, raw_name, qualified_name, cl)
3581 tree decl, raw_name, qualified_name, cl;
3584 decl = push_class (make_class (), qualified_name);
3586 /* Take care of the file and line business */
3587 DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3588 /* If we're emiting xrefs, store the line/col number information */
3590 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3592 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3593 CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3594 CLASS_FROM_CURRENTLY_COMPILED_SOURCE_P (TREE_TYPE (decl)) =
3595 IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3597 PUSH_CPC (decl, raw_name);
3598 DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3600 /* Link the declaration to the already seen ones */
3601 TREE_CHAIN (decl) = ctxp->class_list;
3602 ctxp->class_list = decl;
3604 /* Create a new nodes in the global lists */
3605 ctxp->gclass_list = tree_cons (NULL_TREE, decl, ctxp->gclass_list);
3606 all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3608 /* Install a new dependency list element */
3609 create_jdep_list (ctxp);
3611 SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3612 IDENTIFIER_POINTER (qualified_name)));
3617 add_superinterfaces (decl, interface_list)
3618 tree decl, interface_list;
3621 /* Superinterface(s): if present and defined, parser_check_super_interface ()
3622 takes care of ensuring that:
3623 - This is an accessible interface type,
3624 - Circularity detection.
3625 parser_add_interface is then called. If present but not defined,
3626 the check operation is delayed until the super interface gets
3628 for (node = interface_list; node; node = TREE_CHAIN (node))
3630 tree current = TREE_PURPOSE (node);
3631 tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3632 if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3634 if (!parser_check_super_interface (idecl, decl, current))
3635 parser_add_interface (decl, idecl, current);
3638 register_incomplete_type (JDEP_INTERFACE,
3639 current, decl, NULL_TREE);
3643 /* Create an interface in pass1 and return its decl. Return the
3644 interface's decl in pass 2. */
3647 create_interface (flags, id, super)
3651 tree raw_name = EXPR_WFL_NODE (id);
3652 tree q_name = parser_qualified_classname (flags & ACC_STATIC, raw_name);
3653 tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3655 EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */
3657 /* Basic checks: scope, redefinition, modifiers */
3658 if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3664 /* Suspend the current parsing context if we're parsing an inner
3667 java_parser_context_suspend ();
3669 /* Push a new context for (static) initialized upon declaration fields */
3670 java_parser_context_push_initialized_field ();
3672 /* Interface modifiers check
3673 - public/abstract allowed (already done at that point)
3674 - abstract is obsolete (comes first, it's a warning, or should be)
3675 - Can't use twice the same (checked in the modifier rule) */
3676 if ((flags & ACC_ABSTRACT) && flag_redundant)
3677 parse_warning_context
3678 (MODIFIER_WFL (ABSTRACT_TK),
3679 "Redundant use of `abstract' modifier. Interface `%s' is implicitely abstract", IDENTIFIER_POINTER (raw_name));
3681 /* Create a new decl if DECL is NULL, otherwise fix it */
3682 decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3684 /* Set super info and mark the class a complete */
3685 set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3686 object_type_node, ctxp->interface_number);
3687 ctxp->interface_number = 0;
3688 CLASS_COMPLETE_P (decl) = 1;
3689 add_superinterfaces (decl, super);
3694 /* Anonymous class counter. Will be reset to 1 every time a non
3695 anonymous class gets created. */
3696 static int anonymous_class_counter = 1;
3698 /* Patch anonymous class CLASS, by either extending or implementing
3702 patch_anonymous_class (type_decl, class_decl, wfl)
3703 tree type_decl, class_decl, wfl;
3705 tree class = TREE_TYPE (class_decl);
3706 tree type = TREE_TYPE (type_decl);
3707 tree binfo = TYPE_BINFO (class);
3709 /* If it's an interface, implement it */
3710 if (CLASS_INTERFACE (type_decl))
3715 if (parser_check_super_interface (type_decl, class_decl, wfl))
3718 s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3719 length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3720 TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3721 TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3722 /* And add the interface */
3723 parser_add_interface (class_decl, type_decl, wfl);
3725 /* Otherwise, it's a type we want to extend */
3728 if (parser_check_super (type_decl, class_decl, wfl))
3730 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3735 create_anonymous_class (location, type_name)
3740 tree super = NULL_TREE, itf = NULL_TREE;
3741 tree id, type_decl, class;
3743 /* The unqualified name of the anonymous class. It's just a number. */
3744 sprintf (buffer, "%d", anonymous_class_counter++);
3745 id = build_wfl_node (get_identifier (buffer));
3746 EXPR_WFL_LINECOL (id) = location;
3748 /* We know about the type to extend/implement. We go ahead */
3749 if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3751 /* Create a class which either implements on extends the designated
3752 class. The class bears an innacessible name. */
3753 if (CLASS_INTERFACE (type_decl))
3755 /* It's OK to modify it here. It's been already used and
3756 shouldn't be reused */
3757 ctxp->interface_number = 1;
3758 /* Interfaces should presented as a list of WFLs */
3759 itf = build_tree_list (type_name, NULL_TREE);
3765 class = create_class (ACC_FINAL, id, super, itf);
3767 /* We didn't know anything about the stuff. We register a dependence. */
3769 register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3771 ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3775 /* Create a class in pass1 and return its decl. Return class
3776 interface's decl in pass 2. */
3779 create_class (flags, id, super, interfaces)
3781 tree id, super, interfaces;
3783 tree raw_name = EXPR_WFL_NODE (id);
3784 tree class_id, decl;
3785 tree super_decl_type;
3787 class_id = parser_qualified_classname (0, raw_name);
3788 decl = IDENTIFIER_CLASS_VALUE (class_id);
3789 EXPR_WFL_NODE (id) = class_id;
3791 /* Basic check: scope, redefinition, modifiers */
3792 if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3798 /* Suspend the current parsing context if we're parsing an inner
3799 class or an anonymous class. */
3801 java_parser_context_suspend ();
3802 /* Push a new context for (static) initialized upon declaration fields */
3803 java_parser_context_push_initialized_field ();
3805 /* Class modifier check:
3806 - Allowed modifier (already done at that point)
3807 - abstract AND final forbidden
3808 - Public classes defined in the correct file */
3809 if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3811 (id, "Class `%s' can't be declared both abstract and final",
3812 IDENTIFIER_POINTER (raw_name));
3814 /* Create a new decl if DECL is NULL, otherwise fix it */
3815 decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3817 /* If SUPER exists, use it, otherwise use Object */
3820 /* Can't extend java.lang.Object */
3821 if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3823 parse_error_context (id, "Can't extend `java.lang.Object'");
3828 register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
3830 else if (TREE_TYPE (decl) != object_type_node)
3831 super_decl_type = object_type_node;
3832 /* We're defining java.lang.Object */
3834 super_decl_type = NULL_TREE;
3836 /* Set super info and mark the class a complete */
3837 set_super_info (flags, TREE_TYPE (decl), super_decl_type,
3838 ctxp->interface_number);
3839 ctxp->interface_number = 0;
3840 CLASS_COMPLETE_P (decl) = 1;
3841 add_superinterfaces (decl, interfaces);
3843 /* If the class is a top level inner class, install an alias. */
3844 if (INNER_CLASS_DECL_P (decl) && CLASS_STATIC (decl))
3846 tree alias = parser_qualified_classname (1, raw_name);
3847 IDENTIFIER_GLOBAL_VALUE (alias) = decl;
3850 /* Add the private this$<n> field, Replicate final locals still in
3851 scope as private final fields mangled like val$<local_name>.
3852 This doesn't not occur for top level (static) inner classes. */
3853 if (PURE_INNER_CLASS_DECL_P (decl))
3854 add_inner_class_fields (decl, current_function_decl);
3856 /* If doing xref, store the location at which the inherited class
3857 (if any) was seen. */
3858 if (flag_emit_xref && super)
3859 DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
3861 /* Eventually sets the @deprecated tag flag */
3862 CHECK_DEPRECATED (decl);
3864 /* Reset the anonymous class counter when declaring non inner classes */
3865 if (!INNER_CLASS_DECL_P (decl))
3866 anonymous_class_counter = 1;
3871 /* End a class declaration: register the statements used to create
3872 $finit$ and <clinit>, pop the current class and resume the prior
3873 parser context if necessary. */
3876 end_class_declaration (resume)
3879 /* If an error occured, context weren't pushed and won't need to be
3880 popped by a resume. */
3881 int no_error_occured = ctxp->next && GET_CPC () != error_mark_node;
3883 java_parser_context_pop_initialized_field ();
3885 if (resume && no_error_occured)
3886 java_parser_context_resume ();
3888 /* We're ending a class declaration, this is a good time to reset
3889 the interface cout. Note that might have been already done in
3890 create_interface, but if at that time an inner class was being
3891 dealt with, the interface count was reset in a context created
3892 for the sake of handling inner classes declaration. */
3893 ctxp->interface_number = 0;
3897 add_inner_class_fields (class_decl, fct_decl)
3901 tree block, marker, f;
3903 f = add_field (TREE_TYPE (class_decl),
3904 build_current_thisn (TREE_TYPE (class_decl)),
3905 build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
3907 FIELD_THISN (f) = 1;
3912 for (block = GET_CURRENT_BLOCK (fct_decl);
3913 block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
3916 for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
3919 tree wfl, init, list;
3921 /* Avoid non final arguments. */
3922 if (!LOCAL_FINAL (decl))
3925 MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
3926 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
3927 wfl = build_wfl_node (get_identifier (name));
3928 init = build_wfl_node (get_identifier (pname));
3929 /* Build an initialization for the field: it will be
3930 initialized by a parameter added to $finit$, bearing a
3931 mangled name of the field itself (param$<n>.) The
3932 parameter is provided to $finit$ by the constructor
3933 invoking it (hence the constructor will also feature a
3934 hidden parameter, set to the value of the outer context
3935 local at the time the inner class is created.)
3937 Note: we take into account all possible locals that can
3938 be accessed by the inner class. It's actually not trivial
3939 to minimize these aliases down to the ones really
3940 used. One way to do that would be to expand all regular
3941 methods first, then $finit$ to get a picture of what's
3942 used. It works with the exception that we would have to
3943 go back on all constructor invoked in regular methods to
3944 have their invokation reworked (to include the right amount
3945 of alias initializer parameters.)
3947 The only real way around, I think, is a first pass to
3948 identify locals really used in the inner class. We leave
3949 the flag FIELD_LOCAL_ALIAS_USED around for that future
3952 On the other hand, it only affect local inner classes,
3953 whose constructors (and $finit$ call) will be featuring
3954 unecessary arguments. It's easy for a developper to keep
3955 this number of parameter down by using the `final'
3956 keyword only when necessary. For the time being, we can
3957 issue a warning on unecessary finals. FIXME */
3958 init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
3961 /* Register the field. The TREE_LIST holding the part
3962 initialized/initializer will be marked ARG_FINAL_P so
3963 that the created field can be marked
3964 FIELD_LOCAL_ALIAS. */
3965 list = build_tree_list (wfl, init);
3966 ARG_FINAL_P (list) = 1;
3967 register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
3971 if (!CPC_INITIALIZER_STMT (ctxp))
3974 /* If we ever registered an alias field, insert and marker to
3975 remeber where the list ends. The second part of the list (the one
3976 featuring initialized fields) so it can be later reversed to
3977 enforce 8.5. The marker will be removed during that operation. */
3978 marker = build_tree_list (NULL_TREE, NULL_TREE);
3979 TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
3980 SET_CPC_INITIALIZER_STMT (ctxp, marker);
3983 /* Can't use lookup_field () since we don't want to load the class and
3984 can't set the CLASS_LOADED_P flag */
3987 find_field (class, name)
3992 for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
3994 if (DECL_NAME (decl) == name)
4000 /* Wrap around lookup_field that doesn't potentially upset the value
4004 lookup_field_wrapper (class, name)
4008 tree decl = NULL_TREE;
4009 java_parser_context_save_global ();
4011 /* Last chance: if we're within the context of an inner class, we
4012 might be trying to access a local variable defined in an outer
4013 context. We try to look for it now. */
4014 if (INNER_CLASS_TYPE_P (class))
4018 MANGLE_OUTER_LOCAL_VARIABLE_NAME (alias_buffer, name);
4019 new_name = get_identifier (alias_buffer);
4020 decl = lookup_field (&type, new_name);
4021 if (decl && decl != error_mark_node)
4022 FIELD_LOCAL_ALIAS_USED (decl) = 1;
4024 if (!decl || decl == error_mark_node)
4027 decl = lookup_field (&type, name);
4030 java_parser_context_restore_global ();
4031 return decl == error_mark_node ? NULL : decl;
4034 /* Find duplicate field within the same class declarations and report
4035 the error. Returns 1 if a duplicated field was found, 0
4039 duplicate_declaration_error_p (new_field_name, new_type, cl)
4040 tree new_field_name, new_type, cl;
4042 /* This might be modified to work with method decl as well */
4043 tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4046 char *t1 = xstrdup (purify_type_name
4047 ((TREE_CODE (new_type) == POINTER_TYPE
4048 && TREE_TYPE (new_type) == NULL_TREE) ?
4049 IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4050 lang_printable_name (new_type, 1)));
4051 /* The type may not have been completed by the time we report
4053 char *t2 = xstrdup (purify_type_name
4054 ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4055 && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4056 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4057 lang_printable_name (TREE_TYPE (decl), 1)));
4059 (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4060 t1, IDENTIFIER_POINTER (new_field_name),
4061 t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4062 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4070 /* Field registration routine. If TYPE doesn't exist, field
4071 declarations are linked to the undefined TYPE dependency list, to
4072 be later resolved in java_complete_class () */
4075 register_fields (flags, type, variable_list)
4077 tree type, variable_list;
4079 tree current, saved_type;
4080 tree class_type = NULL_TREE;
4081 int saved_lineno = lineno;
4083 tree wfl = NULL_TREE;
4086 class_type = TREE_TYPE (GET_CPC ());
4088 if (!class_type || class_type == error_mark_node)
4091 /* If we're adding fields to interfaces, those fields are public,
4093 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4095 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4096 flags, ACC_PUBLIC, "interface field(s)");
4097 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4098 flags, ACC_STATIC, "interface field(s)");
4099 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4100 flags, ACC_FINAL, "interface field(s)");
4101 check_modifiers ("Illegal interface member modifier `%s'", flags,
4102 INTERFACE_FIELD_MODIFIERS);
4103 flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4106 /* Obtain a suitable type for resolution, if necessary */
4107 SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4109 /* If TYPE is fully resolved and we don't have a reference, make one */
4110 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4112 for (current = variable_list, saved_type = type; current;
4113 current = TREE_CHAIN (current), type = saved_type)
4117 tree cl = TREE_PURPOSE (current);
4118 tree init = TREE_VALUE (current);
4119 tree current_name = EXPR_WFL_NODE (cl);
4121 /* Can't declare non-final static fields in inner classes */
4122 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4123 && !(flags & ACC_FINAL))
4125 (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4126 IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4127 lang_printable_name (class_type, 0));
4129 /* Process NAME, as it may specify extra dimension(s) for it */
4130 type = build_array_from_name (type, wfl, current_name, ¤t_name);
4132 /* Type adjustment. We may have just readjusted TYPE because
4133 the variable specified more dimensions. Make sure we have
4134 a reference if we can and don't have one already. Also
4135 change the name if we have an init. */
4136 if (type != saved_type)
4138 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4140 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4143 real_type = GET_REAL_TYPE (type);
4144 /* Check for redeclarations */
4145 if (duplicate_declaration_error_p (current_name, real_type, cl))
4148 /* Set lineno to the line the field was found and create a
4149 declaration for it. Eventually sets the @deprecated tag flag. */
4151 lineno = EXPR_WFL_LINECOL (cl);
4153 lineno = EXPR_WFL_LINENO (cl);
4154 field_decl = add_field (class_type, current_name, real_type, flags);
4155 CHECK_DEPRECATED (field_decl);
4157 /* If the couple initializer/initialized is marked ARG_FINAL_P, we
4158 mark the created field FIELD_LOCAL_ALIAS, so that we can
4159 hide parameters to this inner class $finit$ and constructors. */
4160 if (ARG_FINAL_P (current))
4161 FIELD_LOCAL_ALIAS (field_decl) = 1;
4163 /* Check if we must chain. */
4165 register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4167 /* If we have an initialization value tied to the field */
4170 /* The field is declared static */
4171 if (flags & ACC_STATIC)
4173 /* We include the field and its initialization part into
4174 a list used to generate <clinit>. After <clinit> is
4175 walked, field initializations will be processed and
4176 fields initialized with known constants will be taken
4177 out of <clinit> and have their DECL_INITIAL set
4179 TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4180 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4181 if (TREE_OPERAND (init, 1)
4182 && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4183 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4185 /* A non-static field declared with an immediate initialization is
4186 to be initialized in <init>, if any. This field is remembered
4187 to be processed at the time of the generation of <init>. */
4190 TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4191 SET_CPC_INITIALIZER_STMT (ctxp, init);
4193 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4194 DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4197 lineno = saved_lineno;
4200 /* Generate $finit$, using the list of initialized fields to populate
4201 its body. $finit$'s parameter(s) list is adjusted to include the
4202 one(s) used to initialized the field(s) caching outer context
4206 generate_finit (class_type)
4210 tree list = TYPE_FINIT_STMT_LIST (class_type);
4211 tree mdecl, current, parms;
4213 parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4214 class_type, NULL_TREE,
4216 CRAFTED_PARAM_LIST_FIXUP (parms);
4217 mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4218 finit_identifier_node, parms);
4219 fix_method_argument_names (parms, mdecl);
4220 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4222 DECL_FUNCTION_NAP (mdecl) = count;
4223 start_artificial_method_body (mdecl);
4225 for (current = list; current; current = TREE_CHAIN (current))
4226 java_method_add_stmt (mdecl,
4227 build_debugable_stmt (EXPR_WFL_LINECOL (current),
4229 end_artificial_method_body (mdecl);
4234 add_instance_initializer (mdecl)
4238 tree stmt_list = TYPE_II_STMT_LIST (DECL_CONTEXT (mdecl));
4239 tree compound = NULL_TREE;
4243 for (current = stmt_list; current; current = TREE_CHAIN (current))
4244 compound = add_stmt_to_compound (compound, NULL_TREE, current);
4246 java_method_add_stmt (mdecl, build1 (INSTANCE_INITIALIZERS_EXPR,
4247 NULL_TREE, compound));
4251 /* Shared accros method_declarator and method_header to remember the
4252 patch stage that was reached during the declaration of the method.
4253 A method DECL is built differently is there is no patch
4254 (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4255 pending on the currently defined method. */
4257 static int patch_stage;
4259 /* Check the method declaration and add the method to its current
4260 class. If the argument list is known to contain incomplete types,
4261 the method is partially added and the registration will be resume
4262 once the method arguments resolved. If TYPE is NULL, we're dealing
4263 with a constructor. */
4266 method_header (flags, type, mdecl, throws)
4268 tree type, mdecl, throws;
4270 tree meth = TREE_VALUE (mdecl);
4271 tree id = TREE_PURPOSE (mdecl);
4272 tree type_wfl = NULL_TREE;
4273 tree meth_name = NULL_TREE;
4274 tree current, orig_arg, this_class = NULL;
4276 int constructor_ok = 0, must_chain;
4279 check_modifiers_consistency (flags);
4282 this_class = TREE_TYPE (GET_CPC ());
4284 if (!this_class || this_class == error_mark_node)
4287 /* There are some forbidden modifiers for an abstract method and its
4288 class must be abstract as well. */
4289 if (type && (flags & ACC_ABSTRACT))
4291 ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4292 ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4293 ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4294 ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4295 ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED,id, "Synchronized");
4296 if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4297 && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4299 (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4300 IDENTIFIER_POINTER (DECL_NAME (ctxp->current_parsed_class)),
4301 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4304 /* Things to be checked when declaring a constructor */
4307 int ec = java_error_count;
4308 /* 8.6: Constructor declarations: we might be trying to define a
4309 method without specifying a return type. */
4310 if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4312 (id, "Invalid method declaration, return type required");
4313 /* 8.6.3: Constructor modifiers */
4316 JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4317 JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4318 JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4319 JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4320 JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4322 /* If we found error here, we don't consider it's OK to tread
4323 the method definition as a constructor, for the rest of this
4325 if (ec == java_error_count)
4329 /* Method declared within the scope of an interface are implicitly
4330 abstract and public. Conflicts with other erroneously provided
4331 modifiers are checked right after. */
4333 if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4335 /* If FLAGS isn't set because of a modifier, turn the
4336 corresponding modifier WFL to NULL so we issue a warning on
4337 the obsolete use of the modifier */
4338 if (!(flags & ACC_PUBLIC))
4339 MODIFIER_WFL (PUBLIC_TK) = NULL;
4340 if (!(flags & ACC_ABSTRACT))
4341 MODIFIER_WFL (ABSTRACT_TK) = NULL;
4342 flags |= ACC_PUBLIC;
4343 flags |= ACC_ABSTRACT;
4346 /* Inner class can't declare static methods */
4347 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4350 (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4351 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4352 lang_printable_name (this_class, 0));
4355 /* Modifiers context reset moved up, so abstract method declaration
4356 modifiers can be later checked. */
4358 /* Set constructor returned type to void and method name to <init>,
4359 unless we found an error identifier the constructor (in which
4360 case we retain the original name) */
4363 type = void_type_node;
4365 meth_name = init_identifier_node;
4368 meth_name = EXPR_WFL_NODE (id);
4370 /* Do the returned type resolution and registration if necessary */
4371 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4374 type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4375 EXPR_WFL_NODE (id) = meth_name;
4376 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4380 patch_stage = JDEP_METHOD_RETURN;
4381 register_incomplete_type (patch_stage, type_wfl, id, type);
4382 TREE_TYPE (meth) = GET_REAL_TYPE (type);
4385 TREE_TYPE (meth) = type;
4387 saved_lineno = lineno;
4388 /* When defining an abstract or interface method, the curly
4389 bracket at level 1 doesn't exist because there is no function
4391 lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4392 EXPR_WFL_LINENO (id));
4394 /* Remember the original argument list */
4395 orig_arg = TYPE_ARG_TYPES (meth);
4397 if (patch_stage) /* includes ret type and/or all args */
4400 meth = add_method_1 (this_class, flags, meth_name, meth);
4401 /* Patch for the return type */
4402 if (patch_stage == JDEP_METHOD_RETURN)
4404 jdep = CLASSD_LAST (ctxp->classd_list);
4405 JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4407 /* This is the stop JDEP. METH allows the function's signature
4409 register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4412 meth = add_method (this_class, flags, meth_name,
4413 build_java_signature (meth));
4415 /* Remember final parameters */
4416 MARK_FINAL_PARMS (meth, orig_arg);
4418 /* Fix the method argument list so we have the argument name
4420 fix_method_argument_names (orig_arg, meth);
4422 /* Register the parameter number and re-install the current line
4424 DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4425 lineno = saved_lineno;
4427 /* Register exception specified by the `throws' keyword for
4428 resolution and set the method decl appropriate field to the list.
4429 Note: the grammar ensures that what we get here are class
4433 throws = nreverse (throws);
4434 for (current = throws; current; current = TREE_CHAIN (current))
4436 register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4437 NULL_TREE, NULL_TREE);
4438 JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4439 &TREE_VALUE (current);
4441 DECL_FUNCTION_THROWS (meth) = throws;
4444 /* We set the DECL_NAME to ID so we can track the location where
4445 the function was declared. This allow us to report
4446 redefinition error accurately. When method are verified,
4447 DECL_NAME is reinstalled properly (using the content of the
4448 WFL node ID) (see check_method_redefinition). We don't do that
4449 when Object is being defined. Constructor <init> names will be
4450 reinstalled the same way. */
4451 if (TREE_TYPE (GET_CPC ()) != object_type_node)
4452 DECL_NAME (meth) = id;
4454 /* Set the flag if we correctly processed a constructor */
4457 DECL_CONSTRUCTOR_P (meth) = 1;
4458 /* Compute and store the number of artificial parameters declared
4459 for this constructor */
4460 for (count = 0, current = TYPE_FIELDS (this_class); current;
4461 current = TREE_CHAIN (current))
4462 if (FIELD_LOCAL_ALIAS (current))
4464 DECL_FUNCTION_NAP (meth) = count;
4467 /* Eventually set the @deprecated tag flag */
4468 CHECK_DEPRECATED (meth);
4470 /* If doing xref, store column and line number information instead
4471 of the line number only. */
4473 DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4479 fix_method_argument_names (orig_arg, meth)
4480 tree orig_arg, meth;
4482 tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4483 if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4485 TREE_PURPOSE (arg) = this_identifier_node;
4486 arg = TREE_CHAIN (arg);
4488 while (orig_arg != end_params_node)
4490 TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4491 orig_arg = TREE_CHAIN (orig_arg);
4492 arg = TREE_CHAIN (arg);
4496 /* Complete the method declaration with METHOD_BODY. */
4499 finish_method_declaration (method_body)
4504 if (!current_function_decl)
4507 flags = get_access_flags_from_decl (current_function_decl);
4509 /* 8.4.5 Method Body */
4510 if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4512 tree wfl = DECL_NAME (current_function_decl);
4513 parse_error_context (wfl,
4514 "%s method `%s' can't have a body defined",
4515 (METHOD_NATIVE (current_function_decl) ?
4516 "Native" : "Abstract"),
4517 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
4518 method_body = NULL_TREE;
4520 else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4522 tree wfl = DECL_NAME (current_function_decl);
4525 "Non native and non abstract method `%s' must have a body defined",
4526 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
4527 method_body = NULL_TREE;
4530 if (flag_emit_class_files && method_body
4531 && TREE_CODE (method_body) == NOP_EXPR
4532 && TREE_TYPE (current_function_decl)
4533 && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4534 method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4536 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4537 maybe_absorb_scoping_blocks ();
4538 /* Exit function's body */
4540 /* Merge last line of the function with first line, directly in the
4541 function decl. It will be used to emit correct debug info. */
4542 if (!flag_emit_xref)
4543 DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1);
4545 /* Since function's argument's list are shared, reset the
4546 ARG_FINAL_P parameter that might have been set on some of this
4547 function parameters. */
4548 UNMARK_FINAL_PARMS (current_function_decl);
4550 /* So we don't have an irrelevant function declaration context for
4551 the next static block we'll see. */
4552 current_function_decl = NULL_TREE;
4555 /* Build a an error message for constructor circularity errors. */
4558 constructor_circularity_msg (from, to)
4561 static char string [4096];
4562 char *t = xstrdup (lang_printable_name (from, 0));
4563 sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4568 /* Verify a circular call to METH. Return 1 if an error is found, 0
4572 verify_constructor_circularity (meth, current)
4575 static tree list = NULL_TREE;
4577 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4579 if (TREE_VALUE (c) == meth)
4585 list = nreverse (list);
4586 for (liste = list; liste; liste = TREE_CHAIN (liste))
4589 (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4590 constructor_circularity_msg
4591 (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4595 t = xstrdup (lang_printable_name (meth, 0));
4596 parse_error_context (TREE_PURPOSE (c),
4597 "%s: recursive invocation of constructor `%s'",
4598 constructor_circularity_msg (current, meth), t);
4604 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4606 list = tree_cons (c, current, list);
4607 if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4609 list = TREE_CHAIN (list);
4614 /* Check modifiers that can be declared but exclusively */
4617 check_modifiers_consistency (flags)
4621 tree cl = NULL_TREE;
4623 THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4624 THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4625 THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4628 (cl, "Inconsistent member declaration. At most one of `public', `private', or `protected' may be specified");
4632 THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4633 THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4635 parse_error_context (cl,
4636 "Inconsistent member declaration. At most one of `final' or `volatile' may be specified");
4639 /* Check the methode header METH for abstract specifics features */
4642 check_abstract_method_header (meth)
4645 int flags = get_access_flags_from_decl (meth);
4646 /* DECL_NAME might still be a WFL node */
4647 tree name = GET_METHOD_NAME (meth);
4649 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4650 ACC_ABSTRACT, "abstract method",
4651 IDENTIFIER_POINTER (name));
4652 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4653 ACC_PUBLIC, "abstract method",
4654 IDENTIFIER_POINTER (name));
4656 check_modifiers ("Illegal modifier `%s' for interface method",
4657 flags, INTERFACE_METHOD_MODIFIERS);
4660 /* Create a FUNCTION_TYPE node and start augmenting it with the
4661 declared function arguments. Arguments type that can't be resolved
4662 are left as they are, but the returned node is marked as containing
4663 incomplete types. */
4666 method_declarator (id, list)
4669 tree arg_types = NULL_TREE, current, node;
4670 tree meth = make_node (FUNCTION_TYPE);
4673 patch_stage = JDEP_NO_PATCH;
4675 /* If we're dealing with an inner class constructor, we hide the
4676 this$<n> decl in the name field of its parameter declaration. We
4677 also might have to hide the outer context local alias
4678 initializers. Not done when the class is a toplevel class. */
4679 if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4680 && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4682 tree aliases_list, type, thisn;
4683 /* First the aliases, linked to the regular parameters */
4685 build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4686 TREE_TYPE (GET_CPC ()),
4688 list = chainon (nreverse (aliases_list), list);
4691 type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4692 thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4693 list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4697 for (current = list; current; current = TREE_CHAIN (current))
4700 tree wfl_name = TREE_PURPOSE (current);
4701 tree type = TREE_VALUE (current);
4702 tree name = EXPR_WFL_NODE (wfl_name);
4703 tree already, arg_node;
4704 tree type_wfl = NULL_TREE;
4707 /* Obtain a suitable type for resolution, if necessary */
4708 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4710 /* Process NAME, as it may specify extra dimension(s) for it */
4711 type = build_array_from_name (type, type_wfl, name, &name);
4712 EXPR_WFL_NODE (wfl_name) = name;
4714 real_type = GET_REAL_TYPE (type);
4715 if (TREE_CODE (real_type) == RECORD_TYPE)
4717 real_type = promote_type (real_type);
4718 if (TREE_CODE (type) == TREE_LIST)
4719 TREE_PURPOSE (type) = real_type;
4722 /* Check redefinition */
4723 for (already = arg_types; already; already = TREE_CHAIN (already))
4724 if (TREE_PURPOSE (already) == name)
4727 (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4728 IDENTIFIER_POINTER (name),
4729 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4733 /* If we've an incomplete argument type, we know there is a location
4734 to patch when the type get resolved, later. */
4738 patch_stage = JDEP_METHOD;
4739 type = register_incomplete_type (patch_stage,
4740 type_wfl, wfl_name, type);
4741 jdep = CLASSD_LAST (ctxp->classd_list);
4742 JDEP_MISC (jdep) = id;
4745 /* The argument node: a name and a (possibly) incomplete type. */
4746 arg_node = build_tree_list (name, real_type);
4747 /* Remeber arguments declared final. */
4748 ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4751 JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4752 TREE_CHAIN (arg_node) = arg_types;
4753 arg_types = arg_node;
4755 TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
4756 node = build_tree_list (id, meth);
4761 unresolved_type_p (wfl, returned)
4766 if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
4770 tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
4771 if (decl && current_class && (decl == TYPE_NAME (current_class)))
4772 *returned = TREE_TYPE (decl);
4773 else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
4774 *returned = TREE_TYPE (GET_CPC ());
4776 *returned = NULL_TREE;
4785 /* From NAME, build a qualified identifier node using the
4786 qualification from the current package definition. */
4789 parser_qualified_classname (is_static, name)
4793 tree nested_class_name;
4796 && (nested_class_name = maybe_make_nested_class_name (name)))
4797 return nested_class_name;
4800 return merge_qualified_name (ctxp->package, name);
4805 /* Called once the type a interface extends is resolved. Returns 0 if
4806 everything is OK. */
4809 parser_check_super_interface (super_decl, this_decl, this_wfl)
4810 tree super_decl, this_decl, this_wfl;
4812 tree super_type = TREE_TYPE (super_decl);
4814 /* Has to be an interface */
4815 if (!CLASS_INTERFACE (super_decl))
4818 (this_wfl, "Can't use %s `%s' to implement/extend %s `%s'",
4819 (TYPE_ARRAY_P (super_type) ? "array" : "class"),
4820 IDENTIFIER_POINTER (DECL_NAME (super_decl)),
4821 (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
4822 "interface" : "class"),
4823 IDENTIFIER_POINTER (DECL_NAME (this_decl)));
4827 /* Check scope: same package OK, other package: OK if public */
4828 if (check_pkg_class_access (DECL_NAME (super_decl), lookup_cl (this_decl)))
4831 SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
4832 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4833 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
4837 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
4838 0 if everthing is OK. */
4841 parser_check_super (super_decl, this_decl, wfl)
4842 tree super_decl, this_decl, wfl;
4844 tree super_type = TREE_TYPE (super_decl);
4846 /* SUPER should be a CLASS (neither an array nor an interface) */
4847 if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
4850 (wfl, "Class `%s' can't subclass %s `%s'",
4851 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4852 (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
4853 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
4857 if (CLASS_FINAL (TYPE_NAME (super_type)))
4859 parse_error_context (wfl, "Can't subclass final classes: %s",
4860 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
4864 /* Check scope: same package OK, other package: OK if public */
4865 if (check_pkg_class_access (DECL_NAME (super_decl), wfl))
4868 SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
4869 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4870 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
4874 /* Create a new dependency list and link it (in a LIFO manner) to the
4875 CTXP list of type dependency list. */
4878 create_jdep_list (ctxp)
4879 struct parser_ctxt *ctxp;
4881 jdeplist *new = (jdeplist *)xmalloc (sizeof (jdeplist));
4882 new->first = new->last = NULL;
4883 new->next = ctxp->classd_list;
4884 ctxp->classd_list = new;
4888 reverse_jdep_list (ctxp)
4889 struct parser_ctxt *ctxp;
4891 register jdeplist *prev = NULL, *current, *next;
4892 for (current = ctxp->classd_list; current; current = next)
4894 next = current->next;
4895 current->next = prev;
4901 /* Create a fake pointer based on the ID stored in
4902 TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
4903 registered again. */
4906 obtain_incomplete_type (type_name)
4911 if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
4912 name = EXPR_WFL_NODE (type_name);
4913 else if (INCOMPLETE_TYPE_P (type_name))
4914 name = TYPE_NAME (type_name);
4916 fatal ("invalid type name - obtain_incomplete_type");
4918 for (ptr = ctxp->incomplete_class; ptr; ptr = TREE_CHAIN (ptr))
4919 if (TYPE_NAME (ptr) == name)
4924 push_obstacks (&permanent_obstack, &permanent_obstack);
4925 BUILD_PTR_FROM_NAME (ptr, name);
4928 TREE_CHAIN (ptr) = ctxp->incomplete_class;
4929 ctxp->incomplete_class = ptr;
4935 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
4936 non NULL instead of computing a new fake type based on WFL. The new
4937 dependency is inserted in the current type dependency list, in FIFO
4941 register_incomplete_type (kind, wfl, decl, ptr)
4943 tree wfl, decl, ptr;
4945 jdep *new = (jdep *)xmalloc (sizeof (jdep));
4947 if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
4948 ptr = obtain_incomplete_type (wfl);
4950 JDEP_KIND (new) = kind;
4951 JDEP_DECL (new) = decl;
4952 JDEP_SOLV (new) = ptr;
4953 JDEP_WFL (new) = wfl;
4954 JDEP_CHAIN (new) = NULL;
4955 JDEP_MISC (new) = NULL_TREE;
4956 /* For some dependencies, set the enclosing class of the current
4957 class to be the enclosing context */
4958 if ((kind == JDEP_SUPER || kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS)
4959 && GET_ENCLOSING_CPC ())
4960 JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
4962 JDEP_ENCLOSING (new) = GET_CPC ();
4963 JDEP_GET_PATCH (new) = (tree *)NULL;
4965 JDEP_INSERT (ctxp->classd_list, new);
4971 java_check_circular_reference ()
4974 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
4976 tree type = TREE_TYPE (current);
4977 if (CLASS_INTERFACE (current))
4979 /* Check all interfaces this class extends */
4980 tree basetype_vec = TYPE_BINFO_BASETYPES (type);
4985 n = TREE_VEC_LENGTH (basetype_vec);
4986 for (i = 0; i < n; i++)
4988 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
4989 if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
4990 && interface_of_p (type, BINFO_TYPE (vec_elt)))
4991 parse_error_context (lookup_cl (current),
4992 "Cyclic interface inheritance");
4996 if (inherits_from_p (CLASSTYPE_SUPER (type), type))
4997 parse_error_context (lookup_cl (current),
4998 "Cyclic class inheritance%s",
4999 (cyclic_inheritance_report ?
5000 cyclic_inheritance_report : ""));
5004 /* Augment the parameter list PARM with parameters crafted to
5005 initialize outer context locals aliases. Through ARTIFICIAL, a
5006 count is kept of the number of crafted parameters. MODE governs
5007 what eventually gets created: something suitable for a function
5008 creation or a function invocation, either the constructor or
5012 build_alias_initializer_parameter_list (mode, class_type, parm, artificial)
5014 tree class_type, parm;
5018 for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5019 if (FIELD_LOCAL_ALIAS (field))
5021 char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5022 tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5026 case AIPL_FUNCTION_DECLARATION:
5027 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
5028 purpose = build_wfl_node (get_identifier (buffer));
5029 if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5030 value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5032 value = TREE_TYPE (field);
5035 case AIPL_FUNCTION_CREATION:
5036 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
5037 purpose = get_identifier (buffer);
5038 value = TREE_TYPE (field);
5041 case AIPL_FUNCTION_FINIT_INVOCATION:
5042 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
5043 /* Now, this is wrong. purpose should always be the NAME
5044 of something and value its matching value (decl, type,
5045 etc...) FIXME -- but there is a lot to fix. */
5047 /* When invoked for this kind of operation, we already
5048 know whether a field is used or not. */
5049 purpose = TREE_TYPE (field);
5050 value = build_wfl_node (get_identifier (buffer));
5053 case AIPL_FUNCTION_CTOR_INVOCATION:
5054 /* There are two case: the constructor invokation happends
5055 outside the local inner, in which case, locales from the outer
5056 context are directly used.
5058 Otherwise, we fold to using the alias directly. */
5059 if (class_type == current_class)
5063 name = get_identifier (&buffer[4]);
5064 value = IDENTIFIER_LOCAL_VALUE (name);
5068 parm = tree_cons (purpose, value, parm);
5075 /* Craft a constructor for CLASS_DECL -- what we should do when none
5076 where found. ARGS is non NULL when a special signature must be
5077 enforced. This is the case for anonymous classes. */
5080 craft_constructor (class_decl, args)
5081 tree class_decl, args;
5083 tree class_type = TREE_TYPE (class_decl);
5084 tree parm = NULL_TREE;
5085 int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5087 int i = 0, artificial = 0;
5088 tree decl, ctor_name;
5091 push_obstacks (&permanent_obstack, &permanent_obstack);
5093 /* The constructor name is <init> unless we're dealing with an
5094 anonymous class, in which case the name will be fixed after having
5096 if (ANONYMOUS_CLASS_P (class_type))
5097 ctor_name = DECL_NAME (class_decl);
5099 ctor_name = init_identifier_node;
5101 /* If we're dealing with an inner class constructor, we hide the
5102 this$<n> decl in the name field of its parameter declaration. */
5103 if (PURE_INNER_CLASS_TYPE_P (class_type))
5105 tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5106 parm = tree_cons (build_current_thisn (class_type),
5107 build_pointer_type (type), parm);
5109 /* Some more arguments to be hidden here. The values of the local
5110 variables of the outer context that the inner class needs to see. */
5111 parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5116 /* Then if there are any args to be enforced, enforce them now */
5117 for (; args && args != end_params_node; args = TREE_CHAIN (args))
5119 sprintf (buffer, "parm%d", i++);
5120 parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5123 CRAFTED_PARAM_LIST_FIXUP (parm);
5124 decl = create_artificial_method (class_type, flags, void_type_node,
5126 fix_method_argument_names (parm, decl);
5127 /* Now, mark the artificial parameters. */
5128 DECL_FUNCTION_NAP (decl) = artificial;
5131 DECL_CONSTRUCTOR_P (decl) = 1;
5135 /* Fix the constructors. This will be called right after circular
5136 references have been checked. It is necessary to fix constructors
5137 early even if no code generation will take place for that class:
5138 some generated constructor might be required by the class whose
5139 compilation triggered this one to be simply loaded. */
5142 java_fix_constructors ()
5146 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5148 tree class_type = TREE_TYPE (current);
5152 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5155 for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5157 if (DECL_CONSTRUCTOR_P (decl))
5159 fix_constructors (decl);
5164 /* Anonymous class constructor can't be generated that early. */
5165 if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5166 craft_constructor (current, NULL_TREE);
5170 /* safe_layout_class just makes sure that we can load a class without
5171 disrupting the current_class, input_file, lineno, etc, information
5172 about the class processed currently. */
5175 safe_layout_class (class)
5178 tree save_current_class = current_class;
5179 const char *save_input_filename = input_filename;
5180 int save_lineno = lineno;
5182 push_obstacks (&permanent_obstack, &permanent_obstack);
5184 layout_class (class);
5187 current_class = save_current_class;
5188 input_filename = save_input_filename;
5189 lineno = save_lineno;
5190 CLASS_LOADED_P (class) = 1;
5194 jdep_resolve_class (dep)
5199 if (JDEP_RESOLVED_P (dep))
5200 decl = JDEP_RESOLVED_DECL (dep);
5203 decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5204 JDEP_DECL (dep), JDEP_WFL (dep));
5205 JDEP_RESOLVED (dep, decl);
5209 complete_class_report_errors (dep);
5211 check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5215 /* Complete unsatisfied class declaration and their dependencies */
5218 java_complete_class ()
5225 push_obstacks (&permanent_obstack, &permanent_obstack);
5227 /* Process imports */
5230 /* Rever things so we have the right order */
5231 ctxp->class_list = nreverse (ctxp->class_list);
5232 ctxp->classd_list = reverse_jdep_list (ctxp);
5234 for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5236 cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5239 for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5242 if (!(decl = jdep_resolve_class (dep)))
5245 /* Now it's time to patch */
5246 switch (JDEP_KIND (dep))
5249 /* Simply patch super */
5250 if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5252 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5253 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5258 /* We do part of the job done in add_field */
5259 tree field_decl = JDEP_DECL (dep);
5260 tree field_type = TREE_TYPE (decl);
5261 push_obstacks (&permanent_obstack, &permanent_obstack);
5262 if (TREE_CODE (field_type) == RECORD_TYPE)
5263 field_type = promote_type (field_type);
5265 TREE_TYPE (field_decl) = field_type;
5266 DECL_ALIGN (field_decl) = 0;
5267 DECL_USER_ALIGN (field_decl) = 0;
5268 layout_decl (field_decl, 0);
5269 SOURCE_FRONTEND_DEBUG
5270 (("Completed field/var decl `%s' with `%s'",
5271 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5272 IDENTIFIER_POINTER (DECL_NAME (decl))));
5275 case JDEP_METHOD: /* We start patching a method */
5276 case JDEP_METHOD_RETURN:
5282 type = TREE_TYPE(decl);
5283 if (TREE_CODE (type) == RECORD_TYPE)
5284 type = promote_type (type);
5285 JDEP_APPLY_PATCH (dep, type);
5286 SOURCE_FRONTEND_DEBUG
5287 (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5288 "Completing fct `%s' with ret type `%s'":
5289 "Completing arg `%s' with type `%s'"),
5290 IDENTIFIER_POINTER (EXPR_WFL_NODE
5291 (JDEP_DECL_WFL (dep))),
5292 IDENTIFIER_POINTER (DECL_NAME (decl))));
5296 dep = JDEP_CHAIN (dep);
5297 if (JDEP_KIND (dep) == JDEP_METHOD_END)
5300 decl = jdep_resolve_class (dep);
5304 tree mdecl = JDEP_DECL (dep), signature;
5305 push_obstacks (&permanent_obstack, &permanent_obstack);
5306 /* Recompute and reset the signature, check first that
5307 all types are now defined. If they're not,
5308 dont build the signature. */
5309 if (check_method_types_complete (mdecl))
5311 signature = build_java_signature (TREE_TYPE (mdecl));
5312 set_java_signature (TREE_TYPE (mdecl), signature);
5320 case JDEP_INTERFACE:
5321 if (parser_check_super_interface (decl, JDEP_DECL (dep),
5324 parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5329 type = TREE_TYPE(decl);
5330 if (TREE_CODE (type) == RECORD_TYPE)
5331 type = promote_type (type);
5332 JDEP_APPLY_PATCH (dep, type);
5336 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5337 SOURCE_FRONTEND_DEBUG
5338 (("Completing a random type dependency on a '%s' node",
5339 tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5342 case JDEP_EXCEPTION:
5343 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5344 SOURCE_FRONTEND_DEBUG
5345 (("Completing `%s' `throws' argument node",
5346 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5349 case JDEP_ANONYMOUS:
5350 patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5354 fatal ("Can't handle patch code %d - java_complete_class",
5363 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5367 resolve_class (enclosing, class_type, decl, cl)
5368 tree enclosing, class_type, decl, cl;
5370 const char *name = IDENTIFIER_POINTER (TYPE_NAME (class_type));
5371 const char *base = name;
5372 tree resolved_type = TREE_TYPE (class_type);
5373 tree resolved_type_decl;
5375 if (resolved_type != NULL_TREE)
5377 tree resolved_type_decl = TYPE_NAME (resolved_type);
5378 if (resolved_type_decl == NULL_TREE
5379 || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5381 resolved_type_decl = build_decl (TYPE_DECL,
5382 TYPE_NAME (class_type),
5385 return resolved_type_decl;
5388 /* 1- Check to see if we have an array. If true, find what we really
5390 while (name[0] == '[')
5393 TYPE_NAME (class_type) = get_identifier (name);
5395 /* 2- Resolve the bare type */
5396 if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5399 resolved_type = TREE_TYPE (resolved_type_decl);
5401 /* 3- If we have and array, reconstruct the array down to its nesting */
5404 while (base != name)
5406 if (TREE_CODE (resolved_type) == RECORD_TYPE)
5407 resolved_type = promote_type (resolved_type);
5408 resolved_type = build_java_array_type (resolved_type, -1);
5409 CLASS_LOADED_P (resolved_type) = 1;
5412 /* Build a fake decl for this, since this is what is expected to
5414 resolved_type_decl =
5415 build_decl (TYPE_DECL, TYPE_NAME (resolved_type), resolved_type);
5416 /* Figure how those two things are important for error report. FIXME */
5417 DECL_SOURCE_LINE (resolved_type_decl) = 0;
5418 DECL_SOURCE_FILE (resolved_type_decl) = input_filename;
5419 TYPE_NAME (class_type) = TYPE_NAME (resolved_type);
5421 TREE_TYPE (class_type) = resolved_type;
5422 return resolved_type_decl;
5425 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5426 are used to report error messages. */
5429 do_resolve_class (enclosing, class_type, decl, cl)
5430 tree enclosing, class_type, decl, cl;
5432 tree new_class_decl;
5434 /* Do not try to replace TYPE_NAME (class_type) by a variable, since
5435 it is changed by find_in_imports{_on_demand} and (but it doesn't
5436 really matter) qualify_and_find */
5438 /* 0- Search in the current class as an inner class */
5440 /* Maybe some code here should be added to load the class or
5441 something, at least if the class isn't an inner class and ended
5442 being loaded from class file. FIXME. */
5447 if ((new_class_decl = find_as_inner_class (enclosing, class_type, cl)))
5448 return new_class_decl;
5450 /* Now go to the upper classes, bail out if necessary. */
5451 enclosing = CLASSTYPE_SUPER (TREE_TYPE (enclosing));
5452 if (!enclosing || enclosing == object_type_node)
5455 if (TREE_CODE (enclosing) == RECORD_TYPE)
5457 enclosing = TYPE_NAME (enclosing);
5461 if (TREE_CODE (enclosing) == IDENTIFIER_NODE)
5463 BUILD_PTR_FROM_NAME (name, enclosing);
5467 enclosing = do_resolve_class (NULL, name, NULL, NULL);
5470 /* 1- Check for the type in single imports. This will change
5471 TYPE_NAME() if something relevant is found */
5472 find_in_imports (class_type);
5474 /* 2- And check for the type in the current compilation unit */
5475 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5477 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5478 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5479 load_class (TYPE_NAME (class_type), 0);
5480 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5483 /* 3- Search according to the current package definition */
5484 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5486 if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5487 TYPE_NAME (class_type))))
5488 return new_class_decl;
5491 /* 4- Check the import on demands. Don't allow bar.baz to be
5492 imported from foo.* */
5493 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5494 if (find_in_imports_on_demand (class_type))
5497 /* If found in find_in_imports_on_demant, the type has already been
5499 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5500 return new_class_decl;
5502 /* 5- Try with a name qualified with the package name we've seen so far */
5503 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5507 /* If there is a current package (ctxp->package), it's the first
5508 element of package_list and we can skip it. */
5509 for (package = (ctxp->package ?
5510 TREE_CHAIN (package_list) : package_list);
5511 package; package = TREE_CHAIN (package))
5512 if ((new_class_decl = qualify_and_find (class_type,
5513 TREE_PURPOSE (package),
5514 TYPE_NAME (class_type))))
5515 return new_class_decl;
5518 /* 5- Check an other compilation unit that bears the name of type */
5519 load_class (TYPE_NAME (class_type), 0);
5520 if (check_pkg_class_access (TYPE_NAME (class_type),
5521 (cl ? cl : lookup_cl (decl))))
5524 /* 6- Last call for a resolution */
5525 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5529 qualify_and_find (class_type, package, name)
5530 tree class_type, package, name;
5532 tree new_qualified = merge_qualified_name (package, name);
5533 tree new_class_decl;
5535 if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5536 load_class (new_qualified, 0);
5537 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5539 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5540 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5541 load_class (new_qualified, 0);
5542 TYPE_NAME (class_type) = new_qualified;
5543 return IDENTIFIER_CLASS_VALUE (new_qualified);
5548 /* Resolve NAME and lay it out (if not done and if not the current
5549 parsed class). Return a decl node. This function is meant to be
5550 called when type resolution is necessary during the walk pass. */
5553 resolve_and_layout (something, cl)
5559 /* Don't do that on the current class */
5560 if (something == current_class)
5561 return TYPE_NAME (current_class);
5563 /* Don't do anything for void and other primitive types */
5564 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5567 /* Pointer types can be reall pointer types or fake pointers. When
5568 finding a real pointer, recheck for primitive types */
5569 if (TREE_CODE (something) == POINTER_TYPE)
5571 if (TREE_TYPE (something))
5573 something = TREE_TYPE (something);
5574 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5578 something = TYPE_NAME (something);
5581 /* Don't do anything for arrays of primitive types */
5582 if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5583 && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5586 /* Something might be a WFL */
5587 if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5588 something = EXPR_WFL_NODE (something);
5590 /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5591 TYPE_DECL or a real TYPE */
5592 else if (TREE_CODE (something) != IDENTIFIER_NODE)
5593 something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5594 DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5596 if (!(decl = resolve_no_layout (something, cl)))
5599 /* Resolve and layout if necessary */
5600 layout_class_methods (TREE_TYPE (decl));
5601 /* Check methods, but only once */
5602 if (CLASS_FROM_SOURCE_P (TREE_TYPE (decl))
5603 && !CLASS_LOADED_P (TREE_TYPE (decl)))
5604 CHECK_METHODS (decl);
5605 if (TREE_TYPE (decl) != current_class && !CLASS_LOADED_P (TREE_TYPE (decl)))
5606 safe_layout_class (TREE_TYPE (decl));
5611 /* Resolve a class, returns its decl but doesn't perform any
5612 layout. The current parsing context is saved and restored */
5615 resolve_no_layout (name, cl)
5619 BUILD_PTR_FROM_NAME (ptr, name);
5620 java_parser_context_save_global ();
5621 decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5622 java_parser_context_restore_global ();
5627 /* Called when reporting errors. Skip leader '[' in a complex array
5628 type description that failed to be resolved. */
5631 purify_type_name (name)
5634 while (*name && *name == '[')
5639 /* The type CURRENT refers to can't be found. We print error messages. */
5642 complete_class_report_errors (dep)
5647 if (!JDEP_WFL (dep))
5650 name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
5651 switch (JDEP_KIND (dep))
5655 (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
5656 purify_type_name (name),
5657 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5661 (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
5662 purify_type_name (name),
5663 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5665 case JDEP_METHOD: /* Covers arguments */
5667 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
5668 purify_type_name (name),
5669 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
5670 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
5672 case JDEP_METHOD_RETURN: /* Covers return type */
5674 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
5675 purify_type_name (name),
5676 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
5678 case JDEP_INTERFACE:
5680 (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
5681 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
5682 (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
5683 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5687 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
5688 purify_type_name (IDENTIFIER_POINTER
5689 (EXPR_WFL_NODE (JDEP_WFL (dep)))),
5690 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5692 case JDEP_EXCEPTION: /* As specified by `throws' */
5694 (JDEP_WFL (dep), "Class `%s' not found in `throws'",
5695 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
5698 /* Fix for -Wall. Just break doing nothing. The error will be
5704 /* Return a static string containing the DECL prototype string. If
5705 DECL is a constructor, use the class name instead of the form
5709 get_printable_method_name (decl)
5712 const char *to_return;
5713 tree name = NULL_TREE;
5715 if (DECL_CONSTRUCTOR_P (decl))
5717 name = DECL_NAME (decl);
5718 DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
5721 to_return = lang_printable_name (decl, 0);
5722 if (DECL_CONSTRUCTOR_P (decl))
5723 DECL_NAME (decl) = name;
5728 /* Reinstall the proper DECL_NAME on METHOD. Return 0 if the method
5729 nevertheless needs to be verfied, 1 otherwise. */
5732 reset_method_name (method)
5735 if (!DECL_CLINIT_P (method) && !DECL_FINIT_P (method))
5737 /* NAME is just the plain name when Object is being defined */
5738 if (DECL_CONTEXT (method) != object_type_node)
5739 DECL_NAME (method) = (DECL_CONSTRUCTOR_P (method) ?
5740 init_identifier_node : GET_METHOD_NAME (method));
5747 /* Return the name of METHOD_DECL, when DECL_NAME is a WFL */
5750 java_get_real_method_name (method_decl)
5753 tree method_name = DECL_NAME (method_decl);
5754 if (DECL_CONSTRUCTOR_P (method_decl))
5755 return init_identifier_node;
5757 /* Explain here why METHOD_DECL doesn't have the DECL_CONSTRUCTUR_P
5758 and still can be a constructor. FIXME */
5760 /* Don't confuse method only bearing the name of their class as
5762 else if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (method_decl))
5764 && GET_CPC_UN () == EXPR_WFL_NODE (method_name)
5765 && get_access_flags_from_decl (method_decl) <= ACC_PROTECTED
5766 && TREE_TYPE (TREE_TYPE (method_decl)) == void_type_node)
5767 return init_identifier_node;
5769 return EXPR_WFL_NODE (method_name);
5772 /* Track method being redefined inside the same class. As a side
5773 effect, set DECL_NAME to an IDENTIFIER (prior entering this
5774 function it's a FWL, so we can track errors more accurately.) */
5777 check_method_redefinition (class, method)
5781 tree cl = DECL_NAME (method);
5782 tree sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
5783 /* decl name of artificial <clinit> and $finit$ doesn't need to be
5784 fixed and checked */
5786 /* Reset the method name before running the check. If it returns 1,
5787 the method doesn't need to be verified with respect to method
5788 redeclaration and we return 0 */
5789 if (reset_method_name (method))
5792 name = DECL_NAME (method);
5793 for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
5795 if (redef == method)
5797 if (DECL_NAME (redef) == name
5798 && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef)))
5801 (cl, "Duplicate %s declaration `%s'",
5802 (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
5803 get_printable_method_name (redef));
5811 check_abstract_method_definitions (do_interface, class_decl, type)
5813 tree class_decl, type;
5815 tree class = TREE_TYPE (class_decl);
5816 tree method, end_type;
5818 end_type = (do_interface ? object_type_node : type);
5819 for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
5821 tree other_super, other_method, method_sig, method_name;
5823 int end_type_reached = 0;
5825 if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
5828 /* Now verify that somewhere in between TYPE and CLASS,
5829 abstract method METHOD gets a non abstract definition
5830 that is inherited by CLASS. */
5832 method_sig = build_java_signature (TREE_TYPE (method));
5833 method_name = DECL_NAME (method);
5834 if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
5835 method_name = EXPR_WFL_NODE (method_name);
5837 other_super = class;
5839 if (other_super == end_type)
5840 end_type_reached = 1;
5843 for (other_method = TYPE_METHODS (other_super); other_method;
5844 other_method = TREE_CHAIN (other_method))
5846 tree s = build_java_signature (TREE_TYPE (other_method));
5847 tree other_name = DECL_NAME (other_method);
5849 if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
5850 other_name = EXPR_WFL_NODE (other_name);
5851 if (!DECL_CLINIT_P (other_method)
5852 && !DECL_CONSTRUCTOR_P (other_method)
5853 && method_name == other_name
5855 && !METHOD_ABSTRACT (other_method))
5861 other_super = CLASSTYPE_SUPER (other_super);
5862 } while (!end_type_reached);
5864 /* Report that abstract METHOD didn't find an implementation
5865 that CLASS can use. */
5868 char *t = xstrdup (lang_printable_name
5869 (TREE_TYPE (TREE_TYPE (method)), 0));
5870 tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
5871 tree saved_wfl = NULL_TREE;
5873 if (TREE_CODE (DECL_NAME (method)) == EXPR_WITH_FILE_LOCATION)
5875 saved_wfl = DECL_NAME (method);
5876 DECL_NAME (method) = EXPR_WFL_NODE (DECL_NAME (method));
5880 (lookup_cl (class_decl),
5881 "Class `%s' doesn't define the abstract method `%s %s' from %s `%s'. This method must be defined or %s `%s' must be declared abstract",
5882 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
5883 t, lang_printable_name (method, 0),
5884 (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
5885 "interface" : "class"),
5886 IDENTIFIER_POINTER (ccn),
5887 (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
5888 IDENTIFIER_POINTER (DECL_NAME (class_decl)));
5893 DECL_NAME (method) = saved_wfl;
5898 /* Check that CLASS_DECL somehow implements all inherited abstract
5902 java_check_abstract_method_definitions (class_decl)
5905 tree class = TREE_TYPE (class_decl);
5909 if (CLASS_ABSTRACT (class_decl))
5912 /* Check for inherited types */
5915 super = CLASSTYPE_SUPER (super);
5916 check_abstract_method_definitions (0, class_decl, super);
5917 } while (super != object_type_node);
5919 /* Check for implemented interfaces. */
5920 vector = TYPE_BINFO_BASETYPES (class);
5921 for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
5923 super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
5924 check_abstract_method_definitions (1, class_decl, super);
5928 /* Check all the types method DECL uses and return 1 if all of them
5929 are now complete, 0 otherwise. This is used to check whether its
5930 safe to build a method signature or not. */
5933 check_method_types_complete (decl)
5936 tree type = TREE_TYPE (decl);
5939 if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
5942 args = TYPE_ARG_TYPES (type);
5943 if (TREE_CODE (type) == METHOD_TYPE)
5944 args = TREE_CHAIN (args);
5945 for (; args != end_params_node; args = TREE_CHAIN (args))
5946 if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
5952 /* Check all the methods of CLASS_DECL. Methods are first completed
5953 then checked according to regular method existance rules. If no
5954 constructor for CLASS_DECL were encountered, then build its
5958 java_check_regular_methods (class_decl)
5961 int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
5963 tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl));
5964 tree saved_found_wfl = NULL_TREE, found = NULL_TREE;
5967 /* It is not necessary to check methods defined in java.lang.Object */
5968 if (class == object_type_node)
5971 if (!TYPE_NVIRTUALS (class))
5972 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
5974 /* Should take interfaces into account. FIXME */
5975 for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
5978 tree method_wfl = DECL_NAME (method);
5981 /* If we previously found something and its name was saved,
5983 if (found && saved_found_wfl)
5985 DECL_NAME (found) = saved_found_wfl;
5986 saved_found_wfl = NULL_TREE;
5989 /* Check for redefinitions */
5990 if (check_method_redefinition (class, method))
5993 /* If we see one constructor a mark so we don't generate the
5994 default one. Also skip other verifications: constructors
5995 can't be inherited hence hiden or overriden */
5996 if (DECL_CONSTRUCTOR_P (method))
5998 saw_constructor = 1;
6002 /* We verify things thrown by the method. They must inherits from
6003 java.lang.Throwable */
6004 for (mthrows = DECL_FUNCTION_THROWS (method);
6005 mthrows; mthrows = TREE_CHAIN (mthrows))
6007 if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6009 (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6011 (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6014 sig = build_java_argument_signature (TREE_TYPE (method));
6015 found = lookup_argument_method2 (class, DECL_NAME (method), sig);
6017 /* Inner class can't declare static methods */
6018 if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6020 char *t = xstrdup (lang_printable_name (class, 0));
6022 (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6023 lang_printable_name (method, 0), t);
6027 /* Nothing overrides or it's a private method. */
6030 if (METHOD_PRIVATE (found))
6036 /* If found wasn't verified, it's DECL_NAME won't be set properly.
6037 We set it temporarily for the sake of the error report. */
6038 saved_found_wfl = DECL_NAME (found);
6039 reset_method_name (found);
6041 /* If `found' is declared in an interface, make sure the
6042 modifier matches. */
6043 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6044 && clinit_identifier_node != DECL_NAME (found)
6045 && !METHOD_PUBLIC (method))
6047 tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6048 parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6049 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6050 lang_printable_name (method, 0),
6051 IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6054 /* Can't override a method with the same name and different return
6056 if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6059 (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6062 "Method `%s' was defined with return type `%s' in class `%s'",
6063 lang_printable_name (found, 0), t,
6065 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6069 aflags = get_access_flags_from_decl (found);
6070 /* If the method has default, access in an other package, then
6071 issue a warning that the current method doesn't override the
6072 one that was found elsewhere. Do not issue this warning when
6073 the match was found in java.lang.Object. */
6074 if (DECL_CONTEXT (found) != object_type_node
6075 && ((aflags & ACC_VISIBILITY) == 0)
6076 && !class_in_current_package (DECL_CONTEXT (found))
6077 && !DECL_CLINIT_P (found)
6078 && flag_not_overriding)
6080 parse_warning_context
6081 (method_wfl, "Method `%s' in class `%s' does not override the corresponding method in class `%s', which is private to a different package",
6082 lang_printable_name (found, 0),
6083 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6084 IDENTIFIER_POINTER (DECL_NAME
6085 (TYPE_NAME (DECL_CONTEXT (found)))));
6089 /* Can't override final. Can't override static. */
6090 if (METHOD_FINAL (found) || METHOD_STATIC (found))
6092 /* Static *can* override static */
6093 if (METHOD_STATIC (found) && METHOD_STATIC (method))
6097 "%s methods can't be overriden. Method `%s' is %s in class `%s'",
6098 (METHOD_FINAL (found) ? "Final" : "Static"),
6099 lang_printable_name (found, 0),
6100 (METHOD_FINAL (found) ? "final" : "static"),
6102 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6106 /* Static method can't override instance method. */
6107 if (METHOD_STATIC (method))
6111 "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
6112 lang_printable_name (found, 0),
6114 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6118 /* - Overriding/hiding public must be public
6119 - Overriding/hiding protected must be protected or public
6120 - If the overriden or hidden method has default (package)
6121 access, then the overriding or hiding method must not be
6122 private; otherwise, a compile-time error occurs. If
6123 `found' belongs to an interface, things have been already
6125 if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6126 && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6127 || (METHOD_PROTECTED (found)
6128 && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6129 || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6130 && METHOD_PRIVATE (method))))
6134 "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6135 (METHOD_PUBLIC (method) ? "public" :
6136 (METHOD_PRIVATE (method) ? "private" : "protected")),
6137 IDENTIFIER_POINTER (DECL_NAME
6138 (TYPE_NAME (DECL_CONTEXT (found)))));
6142 /* Overriding methods must have compatible `throws' clauses on checked
6143 exceptions, if any */
6144 check_throws_clauses (method, method_wfl, found);
6146 /* Inheriting multiple methods with the same signature. FIXME */
6149 /* Don't forget eventual pending found and saved_found_wfl. Take
6150 into account that we might have exited because we saw an
6151 artificial method as the last entry. */
6153 if (found && !DECL_ARTIFICIAL (found) && saved_found_wfl)
6154 DECL_NAME (found) = saved_found_wfl;
6156 if (!TYPE_NVIRTUALS (class))
6157 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6159 /* Search for inherited abstract method not yet implemented in this
6161 java_check_abstract_method_definitions (class_decl);
6163 if (!saw_constructor)
6164 fatal ("No constructor found");
6167 /* Return a non zero value if the `throws' clause of METHOD (if any)
6168 is incompatible with the `throws' clause of FOUND (if any). */
6171 check_throws_clauses (method, method_wfl, found)
6172 tree method, method_wfl, found;
6174 tree mthrows, fthrows;
6176 /* Can't check these things with class loaded from bytecode. FIXME */
6177 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6180 for (mthrows = DECL_FUNCTION_THROWS (method);
6181 mthrows; mthrows = TREE_CHAIN (mthrows))
6183 /* We don't verify unchecked expressions */
6184 if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6186 /* Checked expression must be compatible */
6187 for (fthrows = DECL_FUNCTION_THROWS (found);
6188 fthrows; fthrows = TREE_CHAIN (fthrows))
6189 if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6194 (method_wfl, "Invalid checked exception class `%s' in `throws' clause. The exception must be a subclass of an exception thrown by `%s' from class `%s'",
6195 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6196 lang_printable_name (found, 0),
6198 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6203 /* Check abstract method of interface INTERFACE */
6206 java_check_abstract_methods (interface_decl)
6207 tree interface_decl;
6210 tree method, basetype_vec, found;
6211 tree interface = TREE_TYPE (interface_decl);
6213 for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6215 tree method_wfl = DECL_NAME (method);
6217 /* 2- Check for double definition inside the defining interface */
6218 if (check_method_redefinition (interface, method))
6221 /* 3- Overriding is OK as far as we preserve the return type and
6222 the thrown exceptions (FIXME) */
6223 found = lookup_java_interface_method2 (interface, method);
6227 tree saved_found_wfl = DECL_NAME (found);
6228 reset_method_name (found);
6229 t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6232 "Method `%s' was defined with return type `%s' in class `%s'",
6233 lang_printable_name (found, 0), t,
6235 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6237 DECL_NAME (found) = saved_found_wfl;
6242 /* 4- Inherited methods can't differ by their returned types */
6243 if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6245 n = TREE_VEC_LENGTH (basetype_vec);
6246 for (i = 0; i < n; i++)
6248 tree sub_interface_method, sub_interface;
6249 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6252 sub_interface = BINFO_TYPE (vec_elt);
6253 for (sub_interface_method = TYPE_METHODS (sub_interface);
6254 sub_interface_method;
6255 sub_interface_method = TREE_CHAIN (sub_interface_method))
6257 found = lookup_java_interface_method2 (interface,
6258 sub_interface_method);
6259 if (found && (found != sub_interface_method))
6261 tree saved_found_wfl = DECL_NAME (found);
6262 reset_method_name (found);
6264 (lookup_cl (sub_interface_method),
6265 "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6266 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6267 lang_printable_name (found, 0),
6269 (DECL_NAME (TYPE_NAME
6270 (DECL_CONTEXT (sub_interface_method)))),
6272 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6273 DECL_NAME (found) = saved_found_wfl;
6279 /* Lookup methods in interfaces using their name and partial
6280 signature. Return a matching method only if their types differ. */
6283 lookup_java_interface_method2 (class, method_decl)
6284 tree class, method_decl;
6287 tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6292 n = TREE_VEC_LENGTH (basetype_vec);
6293 for (i = 0; i < n; i++)
6295 tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6296 if ((BINFO_TYPE (vec_elt) != object_type_node)
6298 lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6301 for (i = 0; i < n; i++)
6303 to_return = lookup_java_interface_method2
6304 (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6312 /* Lookup method using their name and partial signature. Return a
6313 matching method only if their types differ. */
6316 lookup_java_method2 (clas, method_decl, do_interface)
6317 tree clas, method_decl;
6320 tree method, method_signature, method_name, method_type, name;
6322 method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6323 name = DECL_NAME (method_decl);
6324 method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6325 EXPR_WFL_NODE (name) : name);
6326 method_type = TREE_TYPE (TREE_TYPE (method_decl));
6328 while (clas != NULL_TREE)
6330 for (method = TYPE_METHODS (clas);
6331 method != NULL_TREE; method = TREE_CHAIN (method))
6333 tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6334 tree name = DECL_NAME (method);
6335 if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6336 EXPR_WFL_NODE (name) : name) == method_name
6337 && method_sig == method_signature
6338 && TREE_TYPE (TREE_TYPE (method)) != method_type)
6341 clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6346 /* Return the line that matches DECL line number, and try its best to
6347 position the column number. Used during error reports. */
6353 static tree cl = NULL_TREE;
6359 if (cl == NULL_TREE)
6360 cl = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6362 EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl));
6363 EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1);
6365 line = java_get_line_col (IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE (cl)),
6366 EXPR_WFL_LINENO (cl), EXPR_WFL_COLNO (cl));
6368 found = strstr ((const char *)line,
6369 (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6371 EXPR_WFL_SET_LINECOL (cl, EXPR_WFL_LINENO (cl), found - line);
6376 /* Look for a simple name in the single-type import list */
6379 find_name_in_single_imports (name)
6384 for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6385 if (TREE_VALUE (node) == name)
6386 return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6391 /* Process all single-type import. */
6399 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6401 tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6403 /* Don't load twice something already defined. */
6404 if (IDENTIFIER_CLASS_VALUE (to_be_found))
6406 QUALIFIED_P (to_be_found) = 1;
6407 load_class (to_be_found, 0);
6409 check_pkg_class_access (to_be_found, TREE_PURPOSE (import));
6410 if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6412 parse_error_context (TREE_PURPOSE (import),
6413 "Class or interface `%s' not found in import",
6414 IDENTIFIER_POINTER (to_be_found));
6423 /* Possibly find and mark a class imported by a single-type import
6427 find_in_imports (class_type)
6432 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6433 if (TREE_VALUE (import) == TYPE_NAME (class_type))
6435 TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6436 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6441 note_possible_classname (name, len)
6446 if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6448 else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6452 node = ident_subst (name, len, "", '/', '.', "");
6453 IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6454 QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6458 /* Read a import directory, gathering potential match for further type
6459 references. Indifferently reads a filesystem or a ZIP archive
6463 read_import_dir (wfl)
6466 tree package_id = EXPR_WFL_NODE (wfl);
6467 const char *package_name = IDENTIFIER_POINTER (package_id);
6468 int package_length = IDENTIFIER_LENGTH (package_id);
6470 JCF *saved_jcf = current_jcf;
6475 struct buffer filename[1];
6478 if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6480 IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6482 BUFFER_INIT (filename);
6483 buffer_grow (filename, package_length + 100);
6485 for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6487 const char *entry_name = jcf_path_name (entry);
6488 int entry_length = strlen (entry_name);
6489 if (jcf_path_is_zipfile (entry))
6492 buffer_grow (filename, entry_length);
6493 memcpy (filename->data, entry_name, entry_length - 1);
6494 filename->data[entry_length-1] = '\0';
6495 zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6497 error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6500 ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6501 BUFFER_RESET (filename);
6502 for (k = 0; k < package_length; k++)
6504 char ch = package_name[k];
6505 *filename->ptr++ = ch == '.' ? '/' : ch;
6507 *filename->ptr++ = '/';
6509 for (k = 0; k < zipf->count; k++, zipd = ZIPDIR_NEXT (zipd))
6511 const char *current_entry = ZIPDIR_FILENAME (zipd);
6512 int current_entry_len = zipd->filename_length;
6514 if (current_entry_len >= BUFFER_LENGTH (filename)
6515 && strncmp (filename->data, current_entry,
6516 BUFFER_LENGTH (filename)) != 0)
6518 found |= note_possible_classname (current_entry,
6525 BUFFER_RESET (filename);
6526 buffer_grow (filename, entry_length + package_length + 4);
6527 strcpy (filename->data, entry_name);
6528 filename->ptr = filename->data + entry_length;
6529 for (k = 0; k < package_length; k++)
6531 char ch = package_name[k];
6532 *filename->ptr++ = ch == '.' ? '/' : ch;
6534 *filename->ptr = '\0';
6536 dirp = opendir (filename->data);
6539 *filename->ptr++ = '/';
6544 struct dirent *direntp = readdir (dirp);
6547 d_name = direntp->d_name;
6548 len = strlen (direntp->d_name);
6549 buffer_grow (filename, len+1);
6550 strcpy (filename->ptr, d_name);
6551 found |= note_possible_classname (filename->data + entry_length,
6552 package_length+len+1);
6559 free (filename->data);
6561 /* Here we should have a unified way of retrieving an entry, to be
6565 static int first = 1;
6568 error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives.", package_name);
6573 parse_error_context (wfl, "Package `%s' not found in import",
6575 current_jcf = saved_jcf;
6578 current_jcf = saved_jcf;
6581 /* Possibly find a type in the import on demands specified
6582 types. Returns 1 if an error occured, 0 otherwise. Run throught the
6583 entire list, to detected potential double definitions. */
6586 find_in_imports_on_demand (class_type)
6589 tree node, import, node_to_use = NULL_TREE;
6591 tree cl = NULL_TREE;
6593 for (import = ctxp->import_demand_list; import; import = TREE_CHAIN (import))
6595 const char *id_name;
6596 obstack_grow (&temporary_obstack,
6597 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
6598 IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
6599 obstack_1grow (&temporary_obstack, '.');
6600 obstack_grow0 (&temporary_obstack,
6601 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
6602 IDENTIFIER_LENGTH (TYPE_NAME (class_type)));
6603 id_name = obstack_finish (&temporary_obstack);
6605 node = maybe_get_identifier (id_name);
6606 if (node && IS_A_CLASSFILE_NAME (node))
6610 cl = TREE_PURPOSE (import);
6618 (import, "Type `%s' also potentially defined in package `%s'",
6619 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
6620 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))));
6627 /* Setup lineno so that it refers to the line of the import (in
6628 case we parse a class file and encounter errors */
6630 int saved_lineno = lineno;
6631 lineno = EXPR_WFL_LINENO (cl);
6632 TYPE_NAME (class_type) = node_to_use;
6633 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6634 decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
6635 /* If there is no DECL set for the class or if the class isn't
6636 loaded and not seen in source yet, the load */
6637 if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
6638 && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
6639 load_class (node_to_use, 0);
6640 lineno = saved_lineno;
6641 return check_pkg_class_access (TYPE_NAME (class_type), cl);
6644 return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
6647 /* Add package NAME to the list of package encountered so far. To
6648 speed up class lookup in do_resolve_class, we make sure a
6649 particular package is added only once. */
6652 register_package (name)
6655 static struct hash_table _pht, *pht = NULL;
6659 hash_table_init (&_pht, hash_newfunc,
6660 java_hash_hash_tree_node, java_hash_compare_tree_node);
6664 if (!hash_lookup (pht, (const hash_table_key) name, FALSE, NULL))
6666 package_list = chainon (package_list, build_tree_list (name, NULL));
6667 hash_lookup (pht, (const hash_table_key) name, TRUE, NULL);
6672 resolve_package (pkg, next)
6676 tree type_name = NULL_TREE;
6677 const char *name = IDENTIFIER_POINTER (EXPR_WFL_NODE (pkg));
6679 /* The trick is to determine when the package name stops and were
6680 the name of something contained in the package starts. Then we
6681 return a fully qualified name of what we want to get. */
6683 /* Do a quick search on well known package names */
6684 if (!strncmp (name, "java.lang.reflect", 17))
6687 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg))));
6688 type_name = lookup_package_type (name, 17);
6690 else if (!strncmp (name, "java.lang", 9))
6692 *next = TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg)));
6693 type_name = lookup_package_type (name, 9);
6696 /* If we found something here, return */
6700 *next = EXPR_WFL_QUALIFICATION (pkg);
6702 /* Try the current package. */
6703 if (ctxp->package && !strncmp (name, IDENTIFIER_POINTER (ctxp->package),
6704 IDENTIFIER_LENGTH (ctxp->package)))
6707 lookup_package_type_and_set_next (name,
6708 IDENTIFIER_LENGTH (ctxp->package),
6714 /* Search in imported package */
6715 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
6717 tree current_pkg_name = EXPR_WFL_NODE (TREE_PURPOSE (current));
6718 int len = IDENTIFIER_LENGTH (current_pkg_name);
6719 if (!strncmp (name, IDENTIFIER_POINTER (current_pkg_name), len))
6723 breakdown_qualified (&left, &dummy, current_pkg_name);
6724 len = IDENTIFIER_LENGTH (left);
6725 type_name = lookup_package_type_and_set_next (name, len, next);
6731 /* Try to progressively construct a type name */
6732 if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
6733 for (acc = NULL_TREE, current = EXPR_WFL_QUALIFICATION (pkg);
6734 current; current = TREE_CHAIN (current))
6736 acc = merge_qualified_name (acc, EXPR_WFL_NODE (QUAL_WFL (current)));
6737 if ((type_name = resolve_no_layout (acc, NULL_TREE)))
6740 /* resolve_package should be used in a loop, hence we
6741 point at this one to naturally process the next one at
6742 the next iteration. */
6751 lookup_package_type_and_set_next (name, len, next)
6757 tree type_name = lookup_package_type (name, len);
6762 ptr = IDENTIFIER_POINTER (type_name);
6763 while (ptr && (ptr = strchr (ptr, '.')))
6765 *next = TREE_CHAIN (*next);
6772 lookup_package_type (name, from)
6777 const char *sub = &name[from+1];
6778 while (*sub != '.' && *sub)
6780 strncpy (subname, name, sub-name);
6781 subname [sub-name] = '\0';
6782 return get_identifier (subname);
6786 check_inner_class_access (decl, enclosing_type, cl)
6787 tree decl, enclosing_type, cl;
6789 /* We don't issue an error message when CL is null. CL can be null
6790 as a result of processing a JDEP crafted by
6791 source_start_java_method for the purpose of patching its parm
6792 decl. But the error would have been already trapped when fixing
6793 the method's signature. */
6794 if (!(cl && PURE_INNER_CLASS_DECL_P (decl) && CLASS_PRIVATE (decl))
6795 || (PURE_INNER_CLASS_DECL_P (enclosing_type)
6796 && common_enclosing_context_p (TREE_TYPE (enclosing_type),
6798 || enclosing_context_p (TREE_TYPE (enclosing_type), TREE_TYPE (decl)))
6801 parse_error_context (cl, "Can't access nested %s %s. Only public classes and interfaces in other packages can be accessed",
6802 (CLASS_INTERFACE (decl) ? "interface" : "class"),
6803 lang_printable_name (decl, 0));
6806 /* Check that CLASS_NAME refers to a PUBLIC class. Return 0 if no
6807 access violations were found, 1 otherwise. */
6810 check_pkg_class_access (class_name, cl)
6816 if (!QUALIFIED_P (class_name) || !IDENTIFIER_CLASS_VALUE (class_name))
6819 if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
6822 if (!CLASS_PUBLIC (TYPE_NAME (type)))
6824 /* Access to a private class within the same package is
6827 breakdown_qualified (&l, &r, class_name);
6828 if (l == ctxp->package)
6832 (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
6833 (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
6834 IDENTIFIER_POINTER (class_name));
6840 /* Local variable declaration. */
6843 declare_local_variables (modifier, type, vlist)
6848 tree decl, current, saved_type;
6849 tree type_wfl = NULL_TREE;
6853 /* Push a new block if statements were seen between the last time we
6854 pushed a block and now. Keep a cound of block to close */
6855 if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
6857 tree body = GET_CURRENT_BLOCK (current_function_decl);
6858 tree b = enter_block ();
6859 BLOCK_EXPR_ORIGIN (b) = body;
6865 for (i = 0; i <= 10; i++) if (1 << i & modifier) break;
6866 if (modifier == ACC_FINAL)
6871 (ctxp->modifier_ctx [i],
6872 "Only `final' is allowed as a local variables modifier");
6877 /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
6878 hold the TYPE value if a new incomplete has to be created (as
6879 opposed to being found already existing and reused). */
6880 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
6882 /* If TYPE is fully resolved and we don't have a reference, make one */
6883 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
6885 /* Go through all the declared variables */
6886 for (current = vlist, saved_type = type; current;
6887 current = TREE_CHAIN (current), type = saved_type)
6889 tree other, real_type;
6890 tree wfl = TREE_PURPOSE (current);
6891 tree name = EXPR_WFL_NODE (wfl);
6892 tree init = TREE_VALUE (current);
6894 /* Process NAME, as it may specify extra dimension(s) for it */
6895 type = build_array_from_name (type, type_wfl, name, &name);
6897 /* Variable redefinition check */
6898 if ((other = lookup_name_in_blocks (name)))
6900 variable_redefinition_error (wfl, name, TREE_TYPE (other),
6901 DECL_SOURCE_LINE (other));
6905 /* Type adjustment. We may have just readjusted TYPE because
6906 the variable specified more dimensions. Make sure we have
6907 a reference if we can and don't have one already. */
6908 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
6910 real_type = GET_REAL_TYPE (type);
6911 /* Never layout this decl. This will be done when its scope
6913 decl = build_decl (VAR_DECL, name, real_type);
6914 LOCAL_FINAL (decl) = final_p;
6915 BLOCK_CHAIN_DECL (decl);
6917 /* If doing xreferencing, replace the line number with the WFL
6920 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
6922 /* Don't try to use an INIT statement when an error was found */
6923 if (init && java_error_count)
6926 /* Add the initialization function to the current function's code */
6929 /* Name might have been readjusted */
6930 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
6931 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
6932 java_method_add_stmt (current_function_decl,
6933 build_debugable_stmt (EXPR_WFL_LINECOL (init),
6937 /* Setup dependency the type of the decl */
6941 register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
6942 dep = CLASSD_LAST (ctxp->classd_list);
6943 JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
6946 SOURCE_FRONTEND_DEBUG (("Defined locals"));
6949 /* Called during parsing. Build decls from argument list. */
6952 source_start_java_method (fndecl)
6962 current_function_decl = fndecl;
6964 /* New scope for the function */
6966 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
6967 tem != end_params_node; tem = TREE_CHAIN (tem), i++)
6969 tree type = TREE_VALUE (tem);
6970 tree name = TREE_PURPOSE (tem);
6972 /* If type is incomplete. Create an incomplete decl and ask for
6973 the decl to be patched later */
6974 if (INCOMPLETE_TYPE_P (type))
6977 tree real_type = GET_REAL_TYPE (type);
6978 parm_decl = build_decl (PARM_DECL, name, real_type);
6979 type = obtain_incomplete_type (type);
6980 register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
6981 jdep = CLASSD_LAST (ctxp->classd_list);
6982 JDEP_MISC (jdep) = name;
6983 JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
6986 parm_decl = build_decl (PARM_DECL, name, type);
6988 /* Remember if a local variable was declared final (via its
6989 TREE_LIST of type/name.) Set LOCAL_FINAL accordingly. */
6990 if (ARG_FINAL_P (tem))
6991 LOCAL_FINAL (parm_decl) = 1;
6993 BLOCK_CHAIN_DECL (parm_decl);
6995 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
6996 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
6998 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
6999 DECL_MAX_LOCALS (current_function_decl) = i;
7002 /* Called during parsing. Creates an artificial method declaration. */
7005 create_artificial_method (class, flags, type, name, args)
7008 tree type, name, args;
7012 java_parser_context_save_global ();
7014 mdecl = make_node (FUNCTION_TYPE);
7015 TREE_TYPE (mdecl) = type;
7016 TYPE_ARG_TYPES (mdecl) = args;
7017 mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7018 java_parser_context_restore_global ();
7019 DECL_ARTIFICIAL (mdecl) = 1;
7023 /* Starts the body if an artifical method. */
7026 start_artificial_method_body (mdecl)
7029 DECL_SOURCE_LINE (mdecl) = 1;
7030 DECL_SOURCE_LINE_MERGE (mdecl, 1);
7031 source_start_java_method (mdecl);
7036 end_artificial_method_body (mdecl)
7039 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block ();
7043 /* Called during expansion. Push decls formerly built from argument
7044 list so they're usable during expansion. */
7047 expand_start_java_method (fndecl)
7052 current_function_decl = fndecl;
7055 fprintf (stderr, " [%s.", lang_printable_name (DECL_CONTEXT (fndecl), 0));
7056 announce_function (fndecl);
7058 fprintf (stderr, "]");
7060 pushlevel (1); /* Prepare for a parameter push */
7061 ptr = &DECL_ARGUMENTS (fndecl);
7062 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7065 tree next = TREE_CHAIN (tem);
7066 tree type = TREE_TYPE (tem);
7067 if (PROMOTE_PROTOTYPES
7068 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
7069 && INTEGRAL_TYPE_P (type))
7070 type = integer_type_node;
7071 DECL_ARG_TYPE (tem) = type;
7072 layout_decl (tem, 0);
7075 ptr = &TREE_CHAIN (tem);
7079 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
7080 lineno = DECL_SOURCE_LINE_FIRST (fndecl);
7083 /* Terminate a function and expand its body. */
7086 source_end_java_method ()
7088 tree fndecl = current_function_decl;
7089 int flag_asynchronous_exceptions = asynchronous_exceptions;
7094 java_parser_context_save_global ();
7095 lineno = ctxp->last_ccb_indent1;
7097 /* Set EH language codes */
7098 java_set_exception_lang_code ();
7100 /* Turn function bodies with only a NOP expr null, so they don't get
7101 generated at all and we won't get warnings when using the -W
7103 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7104 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7106 /* Generate function's code */
7107 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7108 && ! flag_emit_class_files
7109 && ! flag_emit_xref)
7110 expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
7112 /* pop out of its parameters */
7113 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
7115 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
7117 /* Generate rtl for function exit. */
7118 if (! flag_emit_class_files && ! flag_emit_xref)
7120 lineno = DECL_SOURCE_LINE_LAST (fndecl);
7121 /* Emit catch-finally clauses */
7123 expand_function_end (input_filename, lineno, 0);
7125 /* FIXME: If the current method contains any exception handlers,
7126 force asynchronous_exceptions: this is necessary because signal
7127 handlers in libjava may throw exceptions. This is far from being
7128 a perfect solution, but it's better than doing nothing at all.*/
7130 asynchronous_exceptions = 1;
7132 /* Run the optimizers and output assembler code for this function. */
7133 rest_of_compilation (fndecl);
7136 current_function_decl = NULL_TREE;
7137 permanent_allocation (1);
7138 java_parser_context_restore_global ();
7139 asynchronous_exceptions = flag_asynchronous_exceptions;
7142 /* Record EXPR in the current function block. Complements compound
7143 expression second operand if necessary. */
7146 java_method_add_stmt (fndecl, expr)
7149 if (!GET_CURRENT_BLOCK (fndecl))
7151 return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7155 add_stmt_to_block (b, type, stmt)
7158 tree body = BLOCK_EXPR_BODY (b), c;
7160 if (java_error_count)
7163 if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7166 BLOCK_EXPR_BODY (b) = c;
7167 TREE_SIDE_EFFECTS (c) = 1;
7171 /* Add STMT to EXISTING if possible, otherwise create a new
7172 COMPOUND_EXPR and add STMT to it. */
7175 add_stmt_to_compound (existing, type, stmt)
7176 tree existing, type, stmt;
7179 return build (COMPOUND_EXPR, type, existing, stmt);
7184 /* Hold THIS for the scope of the current public method decl. */
7185 static tree current_this;
7187 void java_layout_seen_class_methods ()
7189 tree previous_list = all_class_list;
7190 tree end = NULL_TREE;
7195 for (current = previous_list;
7196 current != end; current = TREE_CHAIN (current))
7197 layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7199 if (previous_list != all_class_list)
7201 end = previous_list;
7202 previous_list = all_class_list;
7210 java_reorder_fields ()
7212 static tree stop_reordering = NULL_TREE;
7215 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
7217 current_class = TREE_TYPE (TREE_VALUE (current));
7219 if (current_class == stop_reordering)
7222 /* Reverse the fields, but leave the dummy field in front.
7223 Fields are already ordered for Object and Class */
7224 if (TYPE_FIELDS (current_class) && current_class != object_type_node
7225 && current_class != class_type_node)
7227 /* If the dummy field is there, reverse the right fields and
7228 just layout the type for proper fields offset */
7229 if (!DECL_NAME (TYPE_FIELDS (current_class)))
7231 tree fields = TYPE_FIELDS (current_class);
7232 TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7233 TYPE_SIZE (current_class) = NULL_TREE;
7235 /* We don't have a dummy field, we need to layout the class,
7236 after having reversed the fields */
7239 TYPE_FIELDS (current_class) =
7240 nreverse (TYPE_FIELDS (current_class));
7241 TYPE_SIZE (current_class) = NULL_TREE;
7245 stop_reordering = TREE_TYPE (TREE_VALUE (ctxp->gclass_list));
7248 /* Layout the methods of all classes loaded in one way on an
7249 other. Check methods of source parsed classes. Then reorder the
7250 fields and layout the classes or the type of all source parsed
7254 java_layout_classes ()
7257 int save_error_count = java_error_count;
7259 /* Layout the methods of all classes seen so far */
7260 java_layout_seen_class_methods ();
7261 java_parse_abort_on_error ();
7262 all_class_list = NULL_TREE;
7264 /* Then check the methods of all parsed classes */
7265 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
7266 if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7267 CHECK_METHODS (TREE_VALUE (current));
7268 java_parse_abort_on_error ();
7270 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
7272 current_class = TREE_TYPE (TREE_VALUE (current));
7273 layout_class (current_class);
7275 /* From now on, the class is considered completely loaded */
7276 CLASS_LOADED_P (current_class) = 1;
7278 /* Error reported by the caller */
7279 if (java_error_count)
7283 /* We might have reloaded classes durign the process of laying out
7284 classes for code generation. We must layout the methods of those
7285 late additions, as constructor checks might use them */
7286 java_layout_seen_class_methods ();
7287 java_parse_abort_on_error ();
7290 /* Expand methods in the current set of classes rememebered for
7294 java_complete_expand_classes ()
7298 do_not_fold = flag_emit_xref;
7300 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7301 if (!INNER_CLASS_DECL_P (current))
7302 java_complete_expand_class (current);
7305 /* Expand the methods found in OUTER, starting first by OUTER's inner
7309 java_complete_expand_class (outer)
7314 set_nested_class_simple_name_value (outer, 1); /* Set */
7316 /* We need to go after all inner classes and start expanding them,
7317 starting with most nested ones. We have to do that because nested
7318 classes might add functions to outer classes */
7320 for (inner_list = DECL_INNER_CLASS_LIST (outer);
7321 inner_list; inner_list = TREE_CHAIN (inner_list))
7322 java_complete_expand_class (TREE_PURPOSE (inner_list));
7324 java_complete_expand_methods (outer);
7325 set_nested_class_simple_name_value (outer, 0); /* Reset */
7328 /* Expand methods registered in CLASS_DECL. The general idea is that
7329 we expand regular methods first. This allows us get an estimate on
7330 how outer context local alias fields are really used so we can add
7331 to the constructor just enough code to initialize them properly (it
7332 also lets us generate $finit$ correctly.) Then we expand the
7333 constructors and then <clinit>. */
7336 java_complete_expand_methods (class_decl)
7339 tree clinit, finit, decl, first_decl;
7341 current_class = TREE_TYPE (class_decl);
7343 /* Initialize a new constant pool */
7344 init_outgoing_cpool ();
7346 /* Pre-expand <clinit> to figure whether we really need it or
7347 not. If we do need it, we pre-expand the static fields so they're
7348 ready to be used somewhere else. <clinit> will be fully expanded
7349 after we processed the constructors. */
7350 first_decl = TYPE_METHODS (current_class);
7351 clinit = maybe_generate_pre_expand_clinit (current_class);
7353 /* Then generate $finit$ (if we need to) because constructor will
7355 if (TYPE_FINIT_STMT_LIST (current_class))
7357 finit = generate_finit (current_class);
7358 java_complete_expand_method (finit);
7361 /* Now do the constructors */
7362 for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7366 if (!DECL_CONSTRUCTOR_P (decl))
7369 no_body = !DECL_FUNCTION_BODY (decl);
7370 /* Don't generate debug info on line zero when expanding a
7371 generated constructor. */
7373 restore_line_number_status (1);
7375 java_complete_expand_method (decl);
7378 restore_line_number_status (0);
7381 /* First, do the ordinary methods. */
7382 for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7384 /* Skip abstract or native methods -- but do handle native
7385 methods when generating JNI stubs. */
7386 if (METHOD_ABSTRACT (decl)
7387 || (! flag_jni && METHOD_NATIVE (decl))
7388 || DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7391 if (METHOD_NATIVE (decl))
7393 tree body = build_jni_stub (decl);
7394 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7397 java_complete_expand_method (decl);
7400 /* If there is indeed a <clinit>, fully expand it now */
7403 /* Prevent the use of `this' inside <clinit> */
7404 ctxp->explicit_constructor_p = 1;
7405 java_complete_expand_method (clinit);
7406 ctxp->explicit_constructor_p = 0;
7409 /* We might have generated a class$ that we now want to expand */
7410 if (TYPE_DOT_CLASS (current_class))
7411 java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7413 /* Now verify constructor circularity (stop after the first one we
7415 if (!CLASS_INTERFACE (class_decl))
7416 for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7417 if (DECL_CONSTRUCTOR_P (decl)
7418 && verify_constructor_circularity (decl, decl))
7421 /* Save the constant pool. We'll need to restore it later. */
7422 TYPE_CPOOL (current_class) = outgoing_cpool;
7425 /* Hold a list of catch clauses list. The first element of this list is
7426 the list of the catch clauses of the currently analysed try block. */
7427 static tree currently_caught_type_list;
7429 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7430 safely used in some other methods/constructors. */
7433 maybe_generate_pre_expand_clinit (class_type)
7436 tree current, mdecl;
7438 if (!TYPE_CLINIT_STMT_LIST (class_type))
7441 /* Go through all static fields and pre expand them */
7442 for (current = TYPE_FIELDS (class_type); current;
7443 current = TREE_CHAIN (current))
7444 if (FIELD_STATIC (current))
7445 build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7447 /* Then build the <clinit> method */
7448 mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7449 clinit_identifier_node, end_params_node);
7450 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7452 start_artificial_method_body (mdecl);
7454 /* We process the list of assignment we produced as the result of
7455 the declaration of initialized static field and add them as
7456 statement to the <clinit> method. */
7457 for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7458 current = TREE_CHAIN (current))
7460 tree stmt = current;
7461 /* We build the assignment expression that will initialize the
7462 field to its value. There are strict rules on static
7463 initializers (8.5). FIXME */
7464 if (TREE_CODE (stmt) != BLOCK)
7465 stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7466 java_method_add_stmt (mdecl, stmt);
7469 end_artificial_method_body (mdecl);
7471 /* Now we want to place <clinit> as the last method (because we need
7472 it at least for interface so that it doesn't interfere with the
7473 dispatch table based lookup. */
7474 if (TREE_CHAIN (TYPE_METHODS (class_type)))
7476 current = TREE_CHAIN (TYPE_METHODS (class_type));
7477 TYPE_METHODS (class_type) = current;
7479 while (TREE_CHAIN (current))
7480 current = TREE_CHAIN (current);
7482 TREE_CHAIN (current) = mdecl;
7483 TREE_CHAIN (mdecl) = NULL_TREE;
7489 /* See whether we could get rid of <clinit>. Criteria are: all static
7490 final fields have constant initial values and the body of <clinit>
7491 is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7494 maybe_yank_clinit (mdecl)
7500 if (!DECL_CLINIT_P (mdecl))
7503 /* If the body isn't empty, then we keep <clinit> */
7504 fbody = DECL_FUNCTION_BODY (mdecl);
7505 if ((bbody = BLOCK_EXPR_BODY (fbody)))
7506 bbody = BLOCK_EXPR_BODY (bbody);
7507 if (bbody && bbody != empty_stmt_node)
7510 type = DECL_CONTEXT (mdecl);
7511 current = TYPE_FIELDS (type);
7513 for (current = (current ? TREE_CHAIN (current) : current);
7514 current; current = TREE_CHAIN (current))
7515 if (!(FIELD_STATIC (current) && FIELD_FINAL (current)
7516 && DECL_INITIAL (current) && TREE_CONSTANT (DECL_INITIAL (current))))
7522 /* Get rid of <clinit> in the class' list of methods */
7523 if (TYPE_METHODS (type) == mdecl)
7524 TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7526 for (current = TYPE_METHODS (type); current;
7527 current = TREE_CHAIN (current))
7528 if (TREE_CHAIN (current) == mdecl)
7530 TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7538 /* Complete and expand a method. */
7541 java_complete_expand_method (mdecl)
7544 int yank_clinit = 0;
7546 current_function_decl = mdecl;
7547 /* Fix constructors before expanding them */
7548 if (DECL_CONSTRUCTOR_P (mdecl))
7549 fix_constructors (mdecl);
7551 /* Expand functions that have a body */
7552 if (DECL_FUNCTION_BODY (mdecl))
7554 tree fbody = DECL_FUNCTION_BODY (mdecl);
7555 tree block_body = BLOCK_EXPR_BODY (fbody);
7556 tree exception_copy = NULL_TREE;
7557 expand_start_java_method (mdecl);
7558 build_result_decl (mdecl);
7561 = (!METHOD_STATIC (mdecl) ?
7562 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
7564 /* Purge the `throws' list of unchecked exceptions. If we're
7565 doing xref, save a copy of the list and re-install it
7568 exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
7570 purge_unchecked_exceptions (mdecl);
7572 /* Install exceptions thrown with `throws' */
7573 PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
7575 if (block_body != NULL_TREE)
7577 block_body = java_complete_tree (block_body);
7579 if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
7580 check_for_initialization (block_body);
7581 ctxp->explicit_constructor_p = 0;
7584 BLOCK_EXPR_BODY (fbody) = block_body;
7586 /* If we saw a return but couldn't evaluate it properly, we'll
7587 have an error_mark_node here. */
7588 if (block_body != error_mark_node
7589 && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
7590 && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
7592 missing_return_error (current_function_decl);
7594 /* Check wether we could just get rid of clinit, now the picture
7596 if (!(yank_clinit = maybe_yank_clinit (mdecl)))
7597 complete_start_java_method (mdecl);
7599 /* Don't go any further if we've found error(s) during the
7601 if (!java_error_count && !yank_clinit)
7602 source_end_java_method ();
7605 if (java_error_count)
7606 pushdecl_force_head (DECL_ARGUMENTS (mdecl));
7610 /* Pop the exceptions and sanity check */
7612 if (currently_caught_type_list)
7613 fatal ("Exception list non empty - java_complete_expand_method");
7616 DECL_FUNCTION_THROWS (mdecl) = exception_copy;
7622 /* This section of the code deals with accessing enclosing context
7623 fields either directly by using the relevant access to this$<n> or
7624 by invoking an access method crafted for that purpose. */
7626 /* Build the necessary access from an inner class to an outer
7627 class. This routine could be optimized to cache previous result
7628 (decl, current_class and returned access). When an access method
7629 needs to be generated, it always takes the form of a read. It might
7630 be later turned into a write by calling outer_field_access_fix. */
7633 build_outer_field_access (id, decl)
7636 tree access = NULL_TREE;
7637 tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
7639 /* If decl's class is the direct outer class of the current_class,
7640 build the access as `this$<n>.<field>'. Not that we will break
7641 the `private' barrier if we're not emitting bytecodes. */
7642 if (ctx == DECL_CONTEXT (decl)
7643 && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
7645 tree thisn = build_current_thisn (current_class);
7646 access = make_qualified_primary (build_wfl_node (thisn),
7647 id, EXPR_WFL_LINECOL (id));
7649 /* Otherwise, generate access methods to outer this and access the
7650 field (either using an access method or by direct access.) */
7653 int lc = EXPR_WFL_LINECOL (id);
7655 /* Now we chain the required number of calls to the access$0 to
7656 get a hold to the enclosing instance we need, and the we
7657 build the field access. */
7658 access = build_access_to_thisn (ctx, DECL_CONTEXT (decl), lc);
7660 /* If the field is private and we're generating bytecode, then
7661 we generate an access method */
7662 if (FIELD_PRIVATE (decl) && flag_emit_class_files )
7664 tree name = build_outer_field_access_methods (decl);
7665 access = build_outer_field_access_expr (lc, DECL_CONTEXT (decl),
7666 name, access, NULL_TREE);
7668 /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
7669 Once again we break the `private' access rule from a foreign
7672 access = make_qualified_primary (access, id, lc);
7674 return resolve_expression_name (access, NULL);
7677 /* Return a non zero value if NODE describes an outer field inner
7681 outer_field_access_p (type, decl)
7684 if (!INNER_CLASS_TYPE_P (type)
7685 || TREE_CODE (decl) != FIELD_DECL
7686 || DECL_CONTEXT (decl) == type)
7689 for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
7690 type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
7692 if (type == DECL_CONTEXT (decl))
7694 if (!DECL_CONTEXT (TYPE_NAME (type)))
7701 /* Return a non zero value if NODE represents an outer field inner
7702 access that was been already expanded. As a side effect, it returns
7703 the name of the field being accessed and the argument passed to the
7704 access function, suitable for a regeneration of the access method
7705 call if necessary. */
7708 outer_field_expanded_access_p (node, name, arg_type, arg)
7709 tree node, *name, *arg_type, *arg;
7713 if (TREE_CODE (node) != CALL_EXPR)
7716 /* Well, gcj generates slightly different tree nodes when compiling
7717 to native or bytecodes. It's the case for function calls. */
7719 if (flag_emit_class_files
7720 && TREE_CODE (node) == CALL_EXPR
7721 && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
7723 else if (!flag_emit_class_files)
7725 node = TREE_OPERAND (node, 0);
7727 if (node && TREE_OPERAND (node, 0)
7728 && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
7730 node = TREE_OPERAND (node, 0);
7731 if (TREE_OPERAND (node, 0)
7732 && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
7733 && (OUTER_FIELD_ACCESS_IDENTIFIER_P
7734 (DECL_NAME (TREE_OPERAND (node, 0)))))
7739 if (identified && name && arg_type && arg)
7741 tree argument = TREE_OPERAND (node, 1);
7742 *name = DECL_NAME (TREE_OPERAND (node, 0));
7743 *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
7744 *arg = TREE_VALUE (argument);
7749 /* Detect in NODE an outer field read access from an inner class and
7750 transform it into a write with RHS as an argument. This function is
7751 called from the java_complete_lhs when an assignment to a LHS can
7755 outer_field_access_fix (wfl, node, rhs)
7756 tree wfl, node, rhs;
7758 tree name, arg_type, arg;
7760 if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
7762 /* At any rate, check whether we're trying to assign a value to
7764 tree accessed = (JDECL_P (node) ? node :
7765 (TREE_CODE (node) == COMPONENT_REF ?
7766 TREE_OPERAND (node, 1) : node));
7767 if (check_final_assignment (accessed, wfl))
7768 return error_mark_node;
7770 node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
7771 arg_type, name, arg, rhs);
7772 return java_complete_tree (node);
7777 /* Construct the expression that calls an access method:
7778 <type>.access$<n>(<arg1> [, <arg2>]);
7780 ARG2 can be NULL and will be omitted in that case. It will denote a
7784 build_outer_field_access_expr (lc, type, access_method_name, arg1, arg2)
7786 tree type, access_method_name, arg1, arg2;
7788 tree args, cn, access;
7790 args = arg1 ? arg1 :
7791 build_wfl_node (build_current_thisn (current_class));
7792 args = build_tree_list (NULL_TREE, args);
7795 args = tree_cons (NULL_TREE, arg2, args);
7797 access = build_method_invocation (build_wfl_node (access_method_name), args);
7798 cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
7799 return make_qualified_primary (cn, access, lc);
7803 build_new_access_id ()
7805 static int access_n_counter = 1;
7808 sprintf (buffer, "access$%d", access_n_counter++);
7809 return get_identifier (buffer);
7812 /* Create the static access functions for the outer field DECL. We define a
7814 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
7818 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
7819 TREE_TYPE (<field>) value$) {
7820 return inst$.field = value$;
7822 We should have a usage flags on the DECL so we can lazily turn the ones
7823 we're using for code generation. FIXME.
7827 build_outer_field_access_methods (decl)
7830 tree id, args, stmt, mdecl;
7832 /* Check point, to be removed. FIXME */
7833 if (FIELD_INNER_ACCESS (decl)
7834 && TREE_CODE (FIELD_INNER_ACCESS (decl)) != IDENTIFIER_NODE)
7837 if (FIELD_INNER_ACCESS (decl))
7838 return FIELD_INNER_ACCESS (decl);
7840 push_obstacks (&permanent_obstack, &permanent_obstack);
7842 /* Create the identifier and a function named after it. */
7843 id = build_new_access_id ();
7845 /* The identifier is marked as bearing the name of a generated write
7846 access function for outer field accessed from inner classes. */
7847 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
7849 /* Create the read access */
7850 args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
7851 TREE_CHAIN (args) = end_params_node;
7852 stmt = make_qualified_primary (build_wfl_node (inst_id),
7853 build_wfl_node (DECL_NAME (decl)), 0);
7854 stmt = build_return (0, stmt);
7855 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
7856 TREE_TYPE (decl), id, args, stmt);
7857 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
7859 /* Create the write access method */
7860 args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
7861 TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
7862 TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
7863 stmt = make_qualified_primary (build_wfl_node (inst_id),
7864 build_wfl_node (DECL_NAME (decl)), 0);
7865 stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
7866 build_wfl_node (wpv_id)));
7868 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
7869 TREE_TYPE (decl), id, args, stmt);
7870 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
7873 /* Return the access name */
7874 return FIELD_INNER_ACCESS (decl) = id;
7877 /* Build an field access method NAME. */
7880 build_outer_field_access_method (class, type, name, args, body)
7881 tree class, type, name, args, body;
7883 tree saved_current_function_decl, mdecl;
7885 /* Create the method */
7886 mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
7887 fix_method_argument_names (args, mdecl);
7888 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
7890 /* Attach the method body. */
7891 saved_current_function_decl = current_function_decl;
7892 start_artificial_method_body (mdecl);
7893 java_method_add_stmt (mdecl, body);
7894 end_artificial_method_body (mdecl);
7895 current_function_decl = saved_current_function_decl;
7901 /* This section deals with building access function necessary for
7902 certain kinds of method invocation from inner classes. */
7905 build_outer_method_access_method (decl)
7908 tree saved_current_function_decl, mdecl;
7909 tree args = NULL_TREE, call_args = NULL_TREE;
7910 tree carg, id, body, class;
7912 int parm_id_count = 0;
7914 /* Test this abort with an access to a private field */
7915 if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
7918 /* Check the cache first */
7919 if (DECL_FUNCTION_INNER_ACCESS (decl))
7920 return DECL_FUNCTION_INNER_ACCESS (decl);
7922 class = DECL_CONTEXT (decl);
7924 /* Obtain an access identifier and mark it */
7925 id = build_new_access_id ();
7926 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
7928 push_obstacks (&permanent_obstack, &permanent_obstack);
7930 carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
7931 /* Create the arguments, as much as the original */
7932 for (; carg && carg != end_params_node;
7933 carg = TREE_CHAIN (carg))
7935 sprintf (buffer, "write_parm_value$%d", parm_id_count++);
7936 args = chainon (args, build_tree_list (get_identifier (buffer),
7937 TREE_VALUE (carg)));
7939 args = chainon (args, end_params_node);
7941 /* Create the method */
7942 mdecl = create_artificial_method (class, ACC_STATIC,
7943 TREE_TYPE (TREE_TYPE (decl)), id, args);
7944 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
7945 /* There is a potential bug here. We should be able to use
7946 fix_method_argument_names, but then arg names get mixed up and
7947 eventually a constructor will have its this$0 altered and the
7948 outer context won't be assignment properly. The test case is
7950 TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
7952 /* Attach the method body. */
7953 saved_current_function_decl = current_function_decl;
7954 start_artificial_method_body (mdecl);
7956 /* The actual method invocation uses the same args. When invoking a
7957 static methods that way, we don't want to skip the first
7960 if (!METHOD_STATIC (decl))
7961 carg = TREE_CHAIN (carg);
7962 for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
7963 call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
7966 body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
7968 if (!METHOD_STATIC (decl))
7969 body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
7971 if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
7972 body = build_return (0, body);
7973 java_method_add_stmt (mdecl,body);
7974 end_artificial_method_body (mdecl);
7975 current_function_decl = saved_current_function_decl;
7978 /* Back tag the access function so it know what it accesses */
7979 DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
7981 /* Tag the current method so it knows it has an access generated */
7982 return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
7986 /* This section of the code deals with building expressions to access
7987 the enclosing instance of an inner class. The enclosing instance is
7988 kept in a generated field called this$<n>, with <n> being the
7989 inner class nesting level (starting from 0.) */
7991 /* Build an access to a given this$<n>, possibly by chaining access
7992 call to others. Access methods to this$<n> are build on the fly if
7996 build_access_to_thisn (from, to, lc)
8000 tree access = NULL_TREE;
8004 tree access0_wfl, cn;
8006 maybe_build_thisn_access_method (from);
8007 access0_wfl = build_wfl_node (access0_identifier_node);
8008 cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8009 EXPR_WFL_LINECOL (access0_wfl) = lc;
8013 access = build_current_thisn (current_class);
8014 access = build_wfl_node (access);
8016 access = build_tree_list (NULL_TREE, access);
8017 access = build_method_invocation (access0_wfl, access);
8018 access = make_qualified_primary (cn, access, lc);
8020 from = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (from)));
8025 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8026 is returned if nothing needs to be generated. Otherwise, the method
8027 generated and a method decl is returned.
8029 NOTE: These generated methods should be declared in a class file
8030 attribute so that they can't be referred to directly. */
8033 maybe_build_thisn_access_method (type)
8036 tree mdecl, args, stmt, rtype;
8037 tree saved_current_function_decl;
8039 /* If TYPE is a top-level class, no access method is required.
8040 If there already is such an access method, bail out. */
8041 if (CLASS_ACCESS0_GENERATED_P (type) || !INNER_CLASS_TYPE_P (type))
8044 /* We generate the method. The method looks like:
8045 static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8047 push_obstacks (&permanent_obstack, &permanent_obstack);
8048 args = build_tree_list (inst_id, build_pointer_type (type));
8049 TREE_CHAIN (args) = end_params_node;
8050 rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8051 mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8052 access0_identifier_node, args);
8053 fix_method_argument_names (args, mdecl);
8054 layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8055 stmt = build_current_thisn (type);
8056 stmt = make_qualified_primary (build_wfl_node (inst_id),
8057 build_wfl_node (stmt), 0);
8058 stmt = build_return (0, stmt);
8060 saved_current_function_decl = current_function_decl;
8061 start_artificial_method_body (mdecl);
8062 java_method_add_stmt (mdecl, stmt);
8063 end_artificial_method_body (mdecl);
8064 current_function_decl = saved_current_function_decl;
8067 CLASS_ACCESS0_GENERATED_P (type) = 1;
8072 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8073 the first level of innerclassing. this$1 for the next one, etc...
8074 This function can be invoked with TYPE to NULL, available and then
8075 has to count the parser context. */
8078 build_current_thisn (type)
8081 static int saved_i = -1;
8082 static tree saved_thisn = NULL_TREE;
8090 static tree saved_type = NULL_TREE;
8091 static int saved_type_i = 0;
8093 if (type == saved_type)
8097 for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8098 decl; decl = DECL_CONTEXT (decl), i++)
8106 i = list_length (GET_CPC_LIST ())-2;
8111 sprintf (buffer, "this$%d", i);
8113 saved_thisn = get_identifier (buffer);
8117 /* Return the assignement to the hidden enclosing context `this$<n>'
8118 by the second incoming parameter to the innerclass constructor. The
8119 form used is `this.this$<n> = this$<n>;'. */
8122 build_thisn_assign ()
8124 if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8126 tree thisn = build_current_thisn (current_class);
8127 tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8128 build_wfl_node (thisn), 0);
8129 tree rhs = build_wfl_node (thisn);
8130 EXPR_WFL_SET_LINECOL (lhs, lineno, 0);
8131 return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8137 /* Building the synthetic `class$' used to implement the `.class' 1.1
8138 extension for non primitive types. This method looks like:
8140 static Class class$(String type) throws NoClassDefFoundError
8142 try {return (java.lang.Class.forName (String));}
8143 catch (ClassNotFoundException e) {
8144 throw new NoClassDefFoundError(e.getMessage());}
8148 build_dot_class_method (class)
8151 #define BWF(S) build_wfl_node (get_identifier ((S)))
8152 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8153 tree args, tmp, saved_current_function_decl, mdecl;
8154 tree stmt, throw_stmt, catch, catch_block, try_block;
8155 tree catch_clause_param;
8156 tree class_not_found_exception, no_class_def_found_error;
8158 static tree get_message_wfl, type_parm_wfl;
8160 if (!get_message_wfl)
8162 get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8163 type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8166 /* Build the arguments */
8167 args = build_tree_list (get_identifier ("type$"),
8168 build_pointer_type (string_type_node));
8169 TREE_CHAIN (args) = end_params_node;
8171 /* Build the qualified name java.lang.Class.forName */
8172 tmp = MQN (MQN (MQN (BWF ("java"),
8173 BWF ("lang")), BWF ("Class")), BWF ("forName"));
8175 /* For things we have to catch and throw */
8176 class_not_found_exception =
8177 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
8178 no_class_def_found_error =
8179 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
8180 load_class (class_not_found_exception, 1);
8181 load_class (no_class_def_found_error, 1);
8183 /* Create the "class$" function */
8184 mdecl = create_artificial_method (class, ACC_STATIC,
8185 build_pointer_type (class_type_node),
8186 get_identifier ("class$"), args);
8187 DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
8188 no_class_def_found_error);
8190 /* We start by building the try block. We need to build:
8191 return (java.lang.Class.forName (type)); */
8192 stmt = build_method_invocation (tmp,
8193 build_tree_list (NULL_TREE, type_parm_wfl));
8194 stmt = build_return (0, stmt);
8195 /* Put it in a block. That's the try block */
8196 try_block = build_expr_block (stmt, NULL_TREE);
8198 /* Now onto the catch block. We start by building the expression
8199 throwing a new exception:
8200 throw new NoClassDefFoundError (_.getMessage); */
8201 throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8202 get_message_wfl, 0);
8203 throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8205 /* Build new NoClassDefFoundError (_.getMessage) */
8206 throw_stmt = build_new_invocation
8207 (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8208 build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8210 /* Build the throw, (it's too early to use BUILD_THROW) */
8211 throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8213 /* Build the catch block to encapsulate all this. We begin by
8214 building an decl for the catch clause parameter and link it to
8215 newly created block, the catch block. */
8216 catch_clause_param =
8217 build_decl (VAR_DECL, wpv_id,
8218 build_pointer_type (class_not_found_exception));
8219 catch_block = build_expr_block (NULL_TREE, catch_clause_param);
8221 /* We initialize the variable with the exception handler. */
8222 catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
8223 soft_exceptioninfo_call_node);
8224 add_stmt_to_block (catch_block, NULL_TREE, catch);
8226 /* We add the statement throwing the new exception */
8227 add_stmt_to_block (catch_block, NULL_TREE, throw_stmt);
8229 /* Build a catch expression for all this */
8230 catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
8232 /* Build the try/catch sequence */
8233 stmt = build_try_statement (0, try_block, catch_block);
8235 fix_method_argument_names (args, mdecl);
8236 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8237 saved_current_function_decl = current_function_decl;
8238 start_artificial_method_body (mdecl);
8239 java_method_add_stmt (mdecl, stmt);
8240 end_artificial_method_body (mdecl);
8241 current_function_decl = saved_current_function_decl;
8242 TYPE_DOT_CLASS (class) = mdecl;
8248 build_dot_class_method_invocation (name)
8251 tree s = make_node (STRING_CST);
8252 TREE_STRING_LENGTH (s) = IDENTIFIER_LENGTH (name);
8253 TREE_STRING_POINTER (s) = obstack_alloc (expression_obstack,
8254 TREE_STRING_LENGTH (s)+1);
8255 strcpy (TREE_STRING_POINTER (s), IDENTIFIER_POINTER (name));
8256 return build_method_invocation (build_wfl_node (get_identifier ("class$")),
8257 build_tree_list (NULL_TREE, s));
8260 /* This section of the code deals with constructor. */
8262 /* Craft a body for default constructor. Patch existing constructor
8263 bodies with call to super() and field initialization statements if
8267 fix_constructors (mdecl)
8270 tree body = DECL_FUNCTION_BODY (mdecl);
8271 tree thisn_assign, compound = NULL_TREE;
8272 tree class_type = DECL_CONTEXT (mdecl);
8276 /* It is an error for the compiler to generate a default
8277 constructor if the superclass doesn't have a constructor that
8278 takes no argument, or the same args for an anonymous class */
8279 if (verify_constructor_super (mdecl))
8281 tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8282 tree save = DECL_NAME (mdecl);
8283 const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8284 DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8286 (lookup_cl (TYPE_NAME (class_type)),
8287 "No constructor matching `%s' found in class `%s'",
8288 lang_printable_name (mdecl, 0), n);
8289 DECL_NAME (mdecl) = save;
8292 /* The constructor body must be crafted by hand. It's the
8293 constructor we defined when we realize we didn't have the
8294 CLASSNAME() constructor */
8295 start_artificial_method_body (mdecl);
8297 /* We don't generate a super constructor invocation if we're
8298 compiling java.lang.Object. build_super_invocation takes care
8300 compound = java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8302 /* Insert the instance initializer block right here, after the
8303 super invocation. */
8304 add_instance_initializer (mdecl);
8306 /* Insert an assignment to the this$<n> hidden field, if
8308 if ((thisn_assign = build_thisn_assign ()))
8309 java_method_add_stmt (mdecl, thisn_assign);
8311 end_artificial_method_body (mdecl);
8313 /* Search for an explicit constructor invocation */
8317 tree main_block = BLOCK_EXPR_BODY (body);
8320 switch (TREE_CODE (body))
8323 found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8327 case EXPR_WITH_FILE_LOCATION:
8328 body = TREE_OPERAND (body, 0);
8331 body = BLOCK_EXPR_BODY (body);
8337 /* The constructor is missing an invocation of super() */
8339 compound = add_stmt_to_compound (compound, NULL_TREE,
8340 build_super_invocation (mdecl));
8342 /* Insert the instance initializer block right here, after the
8343 super invocation. */
8344 add_instance_initializer (mdecl);
8346 /* Generate the assignment to this$<n>, if necessary */
8347 if ((thisn_assign = build_thisn_assign ()))
8348 compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8350 /* Fix the constructor main block if we're adding extra stmts */
8353 compound = add_stmt_to_compound (compound, NULL_TREE,
8354 BLOCK_EXPR_BODY (main_block));
8355 BLOCK_EXPR_BODY (main_block) = compound;
8360 /* Browse constructors in the super class, searching for a constructor
8361 that doesn't take any argument. Return 0 if one is found, 1
8362 otherwise. If the current class is an anonymous inner class, look
8363 for something that has the same signature. */
8366 verify_constructor_super (mdecl)
8369 tree class = CLASSTYPE_SUPER (current_class);
8370 int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8376 if (ANONYMOUS_CLASS_P (current_class))
8378 tree mdecl_arg_type;
8379 SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8380 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8381 if (DECL_CONSTRUCTOR_P (sdecl))
8383 tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8385 arg_type = TREE_CHAIN (arg_type);
8386 for (; (arg_type != end_params_node
8387 && mdecl_arg_type != end_params_node);
8388 arg_type = TREE_CHAIN (arg_type),
8389 mdecl_arg_type = TREE_CHAIN (mdecl_arg_type))
8390 if (TREE_VALUE (arg_type) != TREE_VALUE (mdecl_arg_type))
8393 if (arg_type == end_params_node &&
8394 mdecl_arg_type == end_params_node)
8400 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8402 tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8404 arg = TREE_CHAIN (arg);
8405 if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8412 /* Generate code for all context remembered for code generation. */
8415 java_expand_classes ()
8417 int save_error_count = 0;
8418 static struct parser_ctxt *saved_ctxp = NULL;
8420 java_parse_abort_on_error ();
8421 if (!(ctxp = ctxp_for_generation))
8423 java_layout_classes ();
8424 java_parse_abort_on_error ();
8426 saved_ctxp = ctxp_for_generation;
8427 for (; ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8429 ctxp = ctxp_for_generation;
8430 lang_init_source (2); /* Error msgs have method prototypes */
8431 java_complete_expand_classes (); /* Complete and expand classes */
8432 java_parse_abort_on_error ();
8435 /* Find anonymous classes and expand their constructor, now they
8437 for (ctxp_for_generation = saved_ctxp;
8438 ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8441 ctxp = ctxp_for_generation;
8442 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8444 current_class = TREE_TYPE (current);
8445 if (ANONYMOUS_CLASS_P (current_class))
8448 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
8450 if (DECL_CONSTRUCTOR_P (d))
8452 restore_line_number_status (1);
8453 reset_method_name (d);
8454 java_complete_expand_method (d);
8455 restore_line_number_status (0);
8456 break; /* We now there are no other ones */
8463 /* If we've found error at that stage, don't try to generate
8464 anything, unless we're emitting xrefs or checking the syntax only
8465 (but not using -fsyntax-only for the purpose of generating
8467 if (java_error_count && !flag_emit_xref
8468 && (!flag_syntax_only && !flag_emit_class_files))
8471 /* Now things are stable, go for generation of the class data. */
8472 for (ctxp_for_generation = saved_ctxp;
8473 ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8476 ctxp = ctxp_for_generation;
8477 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8479 current_class = TREE_TYPE (current);
8480 outgoing_cpool = TYPE_CPOOL (current_class);
8481 if (flag_emit_class_files)
8482 write_classfile (current_class);
8484 expand_xref (current_class);
8485 else if (! flag_syntax_only)
8491 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
8492 a tree list node containing RIGHT. Fore coming RIGHTs will be
8493 chained to this hook. LOCATION contains the location of the
8494 separating `.' operator. */
8497 make_qualified_primary (primary, right, location)
8498 tree primary, right;
8503 if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
8504 wfl = build_wfl_wrap (primary, location);
8508 /* If wfl wasn't qualified, we build a first anchor */
8509 if (!EXPR_WFL_QUALIFICATION (wfl))
8510 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
8513 /* And chain them */
8514 EXPR_WFL_LINECOL (right) = location;
8515 chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
8516 PRIMARY_P (wfl) = 1;
8520 /* Simple merge of two name separated by a `.' */
8523 merge_qualified_name (left, right)
8527 if (!left && !right)
8536 obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
8537 IDENTIFIER_LENGTH (left));
8538 obstack_1grow (&temporary_obstack, '.');
8539 obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
8540 IDENTIFIER_LENGTH (right));
8541 node = get_identifier (obstack_base (&temporary_obstack));
8542 obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
8543 QUALIFIED_P (node) = 1;
8547 /* Merge the two parts of a qualified name into LEFT. Set the
8548 location information of the resulting node to LOCATION, usually
8549 inherited from the location information of the `.' operator. */
8552 make_qualified_name (left, right, location)
8556 #ifdef USE_COMPONENT_REF
8557 tree node = build (COMPONENT_REF, NULL_TREE, left, right);
8558 EXPR_WFL_LINECOL (node) = location;
8561 tree left_id = EXPR_WFL_NODE (left);
8562 tree right_id = EXPR_WFL_NODE (right);
8565 merge = merge_qualified_name (left_id, right_id);
8567 /* Left wasn't qualified and is now qualified */
8568 if (!QUALIFIED_P (left_id))
8570 tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
8571 EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
8572 EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
8575 wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
8576 EXPR_WFL_LINECOL (wfl) = location;
8577 chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
8579 EXPR_WFL_NODE (left) = merge;
8584 /* Extract the last identifier component of the qualified in WFL. The
8585 last identifier is removed from the linked list */
8588 cut_identifier_in_qualified (wfl)
8592 tree previous = NULL_TREE;
8593 for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
8594 if (!TREE_CHAIN (q))
8597 fatal ("Operating on a non qualified qualified WFL - cut_identifier_in_qualified");
8598 TREE_CHAIN (previous) = NULL_TREE;
8599 return TREE_PURPOSE (q);
8603 /* Resolve the expression name NAME. Return its decl. */
8606 resolve_expression_name (id, orig)
8610 tree name = EXPR_WFL_NODE (id);
8613 /* 6.5.5.1: Simple expression names */
8614 if (!PRIMARY_P (id) && !QUALIFIED_P (name))
8616 /* 15.13.1: NAME can appear within the scope of a local variable
8618 if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
8621 /* 15.13.1: NAME can appear within a class declaration */
8624 decl = lookup_field_wrapper (current_class, name);
8627 tree access = NULL_TREE;
8628 int fs = FIELD_STATIC (decl);
8630 /* If we're accessing an outer scope local alias, make
8631 sure we change the name of the field we're going to
8633 if (FIELD_LOCAL_ALIAS_USED (decl))
8634 name = DECL_NAME (decl);
8636 /* Instance variable (8.3.1.1) can't appear within
8637 static method, static initializer or initializer for
8638 a static variable. */
8639 if (!fs && METHOD_STATIC (current_function_decl))
8641 static_ref_err (id, name, current_class);
8642 return error_mark_node;
8644 /* Instance variables can't appear as an argument of
8645 an explicit constructor invocation */
8646 if (!fs && ctxp->explicit_constructor_p)
8649 (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
8650 return error_mark_node;
8653 /* If we're processing an inner class and we're trying
8654 to access a field belonging to an outer class, build
8655 the access to the field */
8656 if (!fs && outer_field_access_p (current_class, decl))
8657 return build_outer_field_access (id, decl);
8659 /* Otherwise build what it takes to access the field */
8660 access = build_field_ref ((fs ? NULL_TREE : current_this),
8661 DECL_CONTEXT (decl), name);
8662 if (fs && !flag_emit_class_files && !flag_emit_xref)
8663 access = build_class_init (DECL_CONTEXT (access), access);
8664 /* We may be asked to save the real field access node */
8667 /* And we return what we got */
8670 /* Fall down to error report on undefined variable */
8673 /* 6.5.5.2 Qualified Expression Names */
8678 qualify_ambiguous_name (id);
8679 /* 15.10.1 Field Access Using a Primary and/or Expression Name */
8680 /* 15.10.2: Accessing Superclass Members using super */
8681 return resolve_field_access (id, orig, NULL);
8684 /* We've got an error here */
8685 parse_error_context (id, "Undefined variable `%s'",
8686 IDENTIFIER_POINTER (name));
8688 return error_mark_node;
8692 static_ref_err (wfl, field_id, class_type)
8693 tree wfl, field_id, class_type;
8697 "Can't make a static reference to nonstatic variable `%s' in class `%s'",
8698 IDENTIFIER_POINTER (field_id),
8699 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
8702 /* 15.10.1 Field Acess Using a Primary and/or Expression Name.
8703 We return something suitable to generate the field access. We also
8704 return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
8705 recipient's address can be null. */
8708 resolve_field_access (qual_wfl, field_decl, field_type)
8710 tree *field_decl, *field_type;
8714 tree decl, where_found, type_found;
8716 if (resolve_qualified_expression_name (qual_wfl, &decl,
8717 &where_found, &type_found))
8718 return error_mark_node;
8720 /* Resolve the LENGTH field of an array here */
8721 if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
8722 && TYPE_ARRAY_P (type_found)
8723 && ! flag_emit_class_files && ! flag_emit_xref)
8725 tree length = build_java_array_length_access (where_found);
8727 build_java_arraynull_check (type_found, length, int_type_node);
8729 /* In case we're dealing with a static array, we need to
8730 initialize its class before the array length can be fetched.
8731 It's also a good time to create a DECL_RTL for the field if
8732 none already exists, otherwise if the field was declared in a
8733 class found in an external file and hasn't been (and won't
8734 be) accessed for its value, none will be created. */
8735 if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
8737 build_static_field_ref (where_found);
8738 field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
8741 /* We might have been trying to resolve field.method(). In which
8742 case, the resolution is over and decl is the answer */
8743 else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
8745 else if (JDECL_P (decl))
8747 int static_final_found = 0;
8749 type_found = DECL_CONTEXT (decl);
8750 is_static = JDECL_P (decl) && FIELD_STATIC (decl);
8751 if (FIELD_FINAL (decl)
8752 && JPRIMITIVE_TYPE_P (TREE_TYPE (decl))
8753 && DECL_INITIAL (decl))
8755 field_ref = java_complete_tree (decl);
8756 static_final_found = 1;
8759 field_ref = build_field_ref ((is_static && !flag_emit_xref?
8760 NULL_TREE : where_found),
8761 type_found, DECL_NAME (decl));
8762 if (field_ref == error_mark_node)
8763 return error_mark_node;
8764 if (is_static && !static_final_found
8765 && !flag_emit_class_files && !flag_emit_xref)
8766 field_ref = build_class_init (DECL_CONTEXT (decl), field_ref);
8774 *field_type = (QUAL_DECL_TYPE (decl) ?
8775 QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
8779 /* If NODE is an access to f static field, strip out the class
8780 initialization part and return the field decl, otherwise, return
8784 strip_out_static_field_access_decl (node)
8787 if (TREE_CODE (node) == COMPOUND_EXPR)
8789 tree op1 = TREE_OPERAND (node, 1);
8790 if (TREE_CODE (op1) == COMPOUND_EXPR)
8792 tree call = TREE_OPERAND (op1, 0);
8793 if (TREE_CODE (call) == CALL_EXPR
8794 && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
8795 && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
8796 == soft_initclass_node)
8797 return TREE_OPERAND (op1, 1);
8799 else if (JDECL_P (op1))
8805 /* 6.5.5.2: Qualified Expression Names */
8808 resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
8810 tree *found_decl, *type_found, *where_found;
8812 int from_type = 0; /* Field search initiated from a type */
8813 int from_super = 0, from_cast = 0, from_qualified_this = 0;
8814 int previous_call_static = 0;
8816 tree decl = NULL_TREE, type = NULL_TREE, q;
8817 /* For certain for of inner class instantiation */
8818 tree saved_current, saved_this;
8819 #define RESTORE_THIS_AND_CURRENT_CLASS \
8820 { current_class = saved_current; current_this = saved_this;}
8822 *type_found = *where_found = NULL_TREE;
8824 for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
8826 tree qual_wfl = QUAL_WFL (q);
8827 tree ret_decl; /* for EH checking */
8828 int location; /* for EH checking */
8830 /* 15.10.1 Field Access Using a Primary */
8831 switch (TREE_CODE (qual_wfl))
8834 case NEW_CLASS_EXPR:
8835 /* If the access to the function call is a non static field,
8836 build the code to access it. */
8837 if (JDECL_P (decl) && !FIELD_STATIC (decl))
8839 decl = maybe_access_field (decl, *where_found,
8840 DECL_CONTEXT (decl));
8841 if (decl == error_mark_node)
8845 /* And code for the function call */
8846 if (complete_function_arguments (qual_wfl))
8849 /* We might have to setup a new current class and a new this
8850 for the search of an inner class, relative to the type of
8851 a expression resolved as `decl'. The current values are
8852 saved and restored shortly after */
8853 saved_current = current_class;
8854 saved_this = current_this;
8855 if (decl && TREE_CODE (qual_wfl) == NEW_CLASS_EXPR)
8857 current_class = type;
8858 current_this = decl;
8861 if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
8862 CALL_USING_SUPER (qual_wfl) = 1;
8863 location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
8864 EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
8865 *where_found = patch_method_invocation (qual_wfl, decl, type,
8866 &is_static, &ret_decl);
8867 if (*where_found == error_mark_node)
8869 RESTORE_THIS_AND_CURRENT_CLASS;
8872 *type_found = type = QUAL_DECL_TYPE (*where_found);
8874 /* If we're creating an inner class instance, check for that
8875 an enclosing instance is in scope */
8876 if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
8877 && INNER_ENCLOSING_SCOPE_CHECK (type))
8880 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
8881 lang_printable_name (type, 0),
8882 (!current_this ? "" :
8883 "; an explicit one must be provided when creating this inner class"));
8884 RESTORE_THIS_AND_CURRENT_CLASS;
8888 /* In case we had to change then to resolve a inner class
8889 instantiation using a primary qualified by a `new' */
8890 RESTORE_THIS_AND_CURRENT_CLASS;
8894 check_thrown_exceptions (location, ret_decl);
8896 /* If the previous call was static and this one is too,
8897 build a compound expression to hold the two (because in
8898 that case, previous function calls aren't transported as
8899 forcoming function's argument. */
8900 if (previous_call_static && is_static)
8902 decl = build (COMPOUND_EXPR, type, decl, *where_found);
8903 TREE_SIDE_EFFECTS (decl) = 1;
8907 previous_call_static = is_static;
8908 decl = *where_found;
8913 case NEW_ARRAY_EXPR:
8914 case NEW_ANONYMOUS_ARRAY_EXPR:
8915 *where_found = decl = java_complete_tree (qual_wfl);
8916 if (decl == error_mark_node)
8918 *type_found = type = QUAL_DECL_TYPE (decl);
8919 CLASS_LOADED_P (type) = 1;
8923 *where_found = decl = java_complete_tree (qual_wfl);
8924 if (decl == error_mark_node)
8926 *type_found = type = QUAL_DECL_TYPE (decl);
8930 case CONDITIONAL_EXPR:
8933 *where_found = decl = java_complete_tree (qual_wfl);
8934 if (decl == error_mark_node)
8936 *type_found = type = QUAL_DECL_TYPE (decl);
8940 /* If the access to the function call is a non static field,
8941 build the code to access it. */
8942 if (JDECL_P (decl) && !FIELD_STATIC (decl))
8944 decl = maybe_access_field (decl, *where_found, type);
8945 if (decl == error_mark_node)
8948 /* And code for the array reference expression */
8949 decl = java_complete_tree (qual_wfl);
8950 if (decl == error_mark_node)
8952 type = QUAL_DECL_TYPE (decl);
8956 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
8958 if ((type = patch_string (decl)))
8960 *where_found = QUAL_RESOLUTION (q) = decl;
8961 *type_found = type = TREE_TYPE (decl);
8965 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
8967 *where_found = QUAL_RESOLUTION (q) = decl;
8968 *type_found = type = TREE_TYPE (decl);
8972 /* Fix for -Wall Just go to the next statement. Don't
8977 /* If we fall here, we weren't processing a (static) function call. */
8978 previous_call_static = 0;
8980 /* It can be the keyword THIS */
8981 if (EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
8986 (wfl, "Keyword `this' used outside allowed context");
8989 if (ctxp->explicit_constructor_p)
8991 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
8994 /* We have to generate code for intermediate acess */
8995 if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
8997 *where_found = decl = current_this;
8998 *type_found = type = QUAL_DECL_TYPE (decl);
9000 /* We're trying to access the this from somewhere else... */
9003 *where_found = decl = build_current_thisn (type);
9004 from_qualified_this = 1;
9011 /* 15.10.2 Accessing Superclass Members using SUPER */
9012 if (EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9015 /* Check on the restricted use of SUPER */
9016 if (METHOD_STATIC (current_function_decl)
9017 || current_class == object_type_node)
9020 (wfl, "Keyword `super' used outside allowed context");
9023 /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9024 node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9025 CLASSTYPE_SUPER (current_class),
9026 build_this (EXPR_WFL_LINECOL (qual_wfl)));
9027 *where_found = decl = java_complete_tree (node);
9028 if (decl == error_mark_node)
9030 *type_found = type = QUAL_DECL_TYPE (decl);
9031 from_super = from_type = 1;
9035 /* 15.13.1: Can't search for field name in packages, so we
9036 assume a variable/class name was meant. */
9037 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9039 tree name = resolve_package (wfl, &q);
9043 *where_found = decl = resolve_no_layout (name, qual_wfl);
9044 /* We want to be absolutely sure that the class is laid
9045 out. We're going to search something inside it. */
9046 *type_found = type = TREE_TYPE (decl);
9047 layout_class (type);
9050 /* Fix them all the way down, if any are left. */
9053 list = TREE_CHAIN (q);
9056 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (list)) = 1;
9057 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9058 list = TREE_CHAIN (list);
9064 if (from_super || from_cast)
9066 ((from_cast ? qual_wfl : wfl),
9067 "No variable `%s' defined in class `%s'",
9068 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9069 lang_printable_name (type, 0));
9072 (qual_wfl, "Undefined variable or class name: `%s'",
9073 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)));
9078 /* We have a type name. It's been already resolved when the
9079 expression was qualified. */
9080 else if (RESOLVE_TYPE_NAME_P (qual_wfl))
9082 if (!(decl = QUAL_RESOLUTION (q)))
9083 return 1; /* Error reported already */
9085 /* Sneak preview. If next we see a `new', we're facing a
9086 qualification with resulted in a type being selected
9087 instead of a field. Report the error */
9089 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9091 parse_error_context (qual_wfl, "Undefined variable `%s'",
9092 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9096 if (not_accessible_p (TREE_TYPE (decl), decl, 0))
9099 (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
9100 java_accstring_lookup (get_access_flags_from_decl (decl)),
9101 GET_TYPE_NAME (type),
9102 IDENTIFIER_POINTER (DECL_NAME (decl)),
9103 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
9106 check_deprecation (qual_wfl, decl);
9108 type = TREE_TYPE (decl);
9111 /* We resolve and expression name */
9114 tree field_decl = NULL_TREE;
9116 /* If there exists an early resolution, use it. That occurs
9117 only once and we know that there are more things to
9118 come. Don't do that when processing something after SUPER
9119 (we need more thing to be put in place below */
9120 if (!from_super && QUAL_RESOLUTION (q))
9122 decl = QUAL_RESOLUTION (q);
9125 if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9128 *where_found = current_this;
9131 static_ref_err (qual_wfl, DECL_NAME (decl),
9138 *where_found = TREE_TYPE (decl);
9139 if (TREE_CODE (*where_found) == POINTER_TYPE)
9140 *where_found = TREE_TYPE (*where_found);
9145 /* We have to search for a field, knowing the type of its
9146 container. The flag FROM_TYPE indicates that we resolved
9147 the last member of the expression as a type name, which
9148 means that for the resolution of this field, we'll look
9149 for other errors than if it was resolved as a member of
9154 tree field_decl_type; /* For layout */
9156 if (!from_type && !JREFERENCE_TYPE_P (type))
9159 (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9160 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9161 lang_printable_name (type, 0),
9162 IDENTIFIER_POINTER (DECL_NAME (field_decl)));
9166 field_decl = lookup_field_wrapper (type,
9167 EXPR_WFL_NODE (qual_wfl));
9168 if (field_decl == NULL_TREE)
9171 (qual_wfl, "No variable `%s' defined in type `%s'",
9172 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9173 GET_TYPE_NAME (type));
9176 if (field_decl == error_mark_node)
9179 /* Layout the type of field_decl, since we may need
9180 it. Don't do primitive types or loaded classes. The
9181 situation of non primitive arrays may not handled
9182 properly here. FIXME */
9183 if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9184 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9186 field_decl_type = TREE_TYPE (field_decl);
9187 if (!JPRIMITIVE_TYPE_P (field_decl_type)
9188 && !CLASS_LOADED_P (field_decl_type)
9189 && !TYPE_ARRAY_P (field_decl_type))
9190 resolve_and_layout (field_decl_type, NULL_TREE);
9191 if (TYPE_ARRAY_P (field_decl_type))
9192 CLASS_LOADED_P (field_decl_type) = 1;
9194 /* Check on accessibility here */
9195 if (not_accessible_p (type, field_decl, from_super))
9199 "Can't access %s field `%s.%s' from `%s'",
9200 java_accstring_lookup
9201 (get_access_flags_from_decl (field_decl)),
9202 GET_TYPE_NAME (type),
9203 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
9205 (DECL_NAME (TYPE_NAME (current_class))));
9208 check_deprecation (qual_wfl, field_decl);
9210 /* There are things to check when fields are accessed
9211 from type. There are no restrictions on a static
9212 declaration of the field when it is accessed from an
9214 is_static = FIELD_STATIC (field_decl);
9215 if (!from_super && from_type
9216 && !TYPE_INTERFACE_P (type)
9218 && (current_function_decl
9219 && METHOD_STATIC (current_function_decl)))
9221 static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9224 from_cast = from_super = 0;
9226 /* It's an access from a type but it isn't static, we
9227 make it relative to `this'. */
9228 if (!is_static && from_type)
9229 decl = current_this;
9231 /* If we need to generate something to get a proper
9232 handle on what this field is accessed from, do it
9236 decl = maybe_access_field (decl, *where_found, *type_found);
9237 if (decl == error_mark_node)
9241 /* We want to keep the location were found it, and the type
9243 *where_found = decl;
9246 /* Generate the correct expression for field access from
9248 if (from_qualified_this)
9250 field_decl = build_outer_field_access (qual_wfl, field_decl);
9251 from_qualified_this = 0;
9254 /* This is the decl found and eventually the next one to
9259 type = QUAL_DECL_TYPE (decl);
9261 /* Sneak preview. If decl is qualified by a `new', report
9262 the error here to be accurate on the peculiar construct */
9264 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
9265 && !JREFERENCE_TYPE_P (type))
9267 parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
9268 lang_printable_name (type, 0));
9272 /* `q' might have changed due to a after package resolution
9281 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
9282 can't be accessed from REFERENCE (a record type). */
9285 not_accessible_p (reference, member, from_super)
9286 tree reference, member;
9289 int access_flag = get_access_flags_from_decl (member);
9291 /* Access always granted for members declared public */
9292 if (access_flag & ACC_PUBLIC)
9295 /* Check access on protected members */
9296 if (access_flag & ACC_PROTECTED)
9298 /* Access granted if it occurs from within the package
9299 containing the class in which the protected member is
9301 if (class_in_current_package (DECL_CONTEXT (member)))
9304 /* If accessed with the form `super.member', then access is granted */
9308 /* Otherwise, access is granted if occuring from the class where
9309 member is declared or a subclass of it */
9310 if (inherits_from_p (reference, DECL_CONTEXT (member)))
9315 /* Check access on private members. Access is granted only if it
9316 occurs from within the class in which it is declared. Exceptions
9317 are accesses from inner-classes. This section is probably not
9319 if (access_flag & ACC_PRIVATE)
9320 return (current_class == DECL_CONTEXT (member) ? 0 :
9321 (INNER_CLASS_TYPE_P (current_class) ? 0 : 1));
9323 /* Default access are permitted only when occuring within the
9324 package in which the type (REFERENCE) is declared. In other words,
9325 REFERENCE is defined in the current package */
9327 return !class_in_current_package (reference);
9329 /* Otherwise, access is granted */
9333 /* Test deprecated decl access. */
9335 check_deprecation (wfl, decl)
9338 const char *file = DECL_SOURCE_FILE (decl);
9339 /* Complain if the field is deprecated and the file it was defined
9340 in isn't compiled at the same time the file which contains its
9342 if (DECL_DEPRECATED (decl)
9343 && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
9346 switch (TREE_CODE (decl))
9349 strcpy (the, "method");
9352 strcpy (the, "field");
9355 strcpy (the, "class");
9358 fatal ("unexpected DECL code - check_deprecation");
9360 parse_warning_context
9361 (wfl, "The %s `%s' in class `%s' has been deprecated",
9362 the, lang_printable_name (decl, 0),
9363 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
9367 /* Returns 1 if class was declared in the current package, 0 otherwise */
9370 class_in_current_package (class)
9373 static tree cache = NULL_TREE;
9380 qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
9382 /* If the current package is empty and the name of CLASS is
9383 qualified, class isn't in the current package. If there is a
9384 current package and the name of the CLASS is not qualified, class
9385 isn't in the current package */
9386 if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
9389 /* If there is not package and the name of CLASS isn't qualified,
9390 they belong to the same unnamed package */
9391 if (!ctxp->package && !qualified_flag)
9394 /* Compare the left part of the name of CLASS with the package name */
9395 breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
9396 if (ctxp->package == left)
9404 /* This function may generate code to access DECL from WHERE. This is
9405 done only if certain conditions meet. */
9408 maybe_access_field (decl, where, type)
9409 tree decl, where, type;
9411 if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
9412 && !FIELD_STATIC (decl))
9413 decl = build_field_ref (where ? where : current_this,
9414 (type ? type : DECL_CONTEXT (decl)),
9419 /* Build a method invocation, by patching PATCH. If non NULL
9420 and according to the situation, PRIMARY and WHERE may be
9421 used. IS_STATIC is set to 1 if the invoked function is static. */
9424 patch_method_invocation (patch, primary, where, is_static, ret_decl)
9425 tree patch, primary, where;
9429 tree wfl = TREE_OPERAND (patch, 0);
9430 tree args = TREE_OPERAND (patch, 1);
9431 tree name = EXPR_WFL_NODE (wfl);
9433 int is_static_flag = 0;
9434 int is_super_init = 0;
9435 tree this_arg = NULL_TREE;
9437 /* Should be overriden if everything goes well. Otherwise, if
9438 something fails, it should keep this value. It stop the
9439 evaluation of a bogus assignment. See java_complete_tree,
9440 MODIFY_EXPR: for the reasons why we sometimes want to keep on
9441 evaluating an assignment */
9442 TREE_TYPE (patch) = error_mark_node;
9444 /* Since lookup functions are messing with line numbers, save the
9446 java_parser_context_save_global ();
9448 /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
9450 /* Resolution of qualified name, excluding constructors */
9451 if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
9453 tree identifier, identifier_wfl, type, resolved;
9454 /* Extract the last IDENTIFIER of the qualified
9455 expression. This is a wfl and we will use it's location
9456 data during error report. */
9457 identifier_wfl = cut_identifier_in_qualified (wfl);
9458 identifier = EXPR_WFL_NODE (identifier_wfl);
9460 /* Given the context, IDENTIFIER is syntactically qualified
9461 as a MethodName. We need to qualify what's before */
9462 qualify_ambiguous_name (wfl);
9463 resolved = resolve_field_access (wfl, NULL, NULL);
9465 if (resolved == error_mark_node)
9466 PATCH_METHOD_RETURN_ERROR ();
9468 type = GET_SKIP_TYPE (resolved);
9469 resolve_and_layout (type, NULL_TREE);
9471 if (JPRIMITIVE_TYPE_P (type))
9475 "Can't invoke a method on primitive type `%s'",
9476 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
9477 PATCH_METHOD_RETURN_ERROR ();
9480 list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
9481 args = nreverse (args);
9483 /* We're resolving a call from a type */
9484 if (TREE_CODE (resolved) == TYPE_DECL)
9486 if (CLASS_INTERFACE (resolved))
9490 "Can't make static reference to method `%s' in interface `%s'",
9491 IDENTIFIER_POINTER (identifier),
9492 IDENTIFIER_POINTER (name));
9493 PATCH_METHOD_RETURN_ERROR ();
9495 if (list && !METHOD_STATIC (list))
9497 char *fct_name = xstrdup (lang_printable_name (list, 0));
9500 "Can't make static reference to method `%s %s' in class `%s'",
9501 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
9502 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
9504 PATCH_METHOD_RETURN_ERROR ();
9508 this_arg = primary = resolved;
9510 /* IDENTIFIER_WFL will be used to report any problem further */
9511 wfl = identifier_wfl;
9513 /* Resolution of simple names, names generated after a primary: or
9517 tree class_to_search = NULL_TREE;
9518 int lc; /* Looking for Constructor */
9520 /* We search constructor in their target class */
9521 if (CALL_CONSTRUCTOR_P (patch))
9523 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
9524 class_to_search = EXPR_WFL_NODE (wfl);
9525 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
9526 this_identifier_node)
9527 class_to_search = NULL_TREE;
9528 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
9529 super_identifier_node)
9532 if (CLASSTYPE_SUPER (current_class))
9534 DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
9537 parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
9538 PATCH_METHOD_RETURN_ERROR ();
9542 /* Class to search is NULL if we're searching the current one */
9543 if (class_to_search)
9545 class_to_search = resolve_and_layout (class_to_search, wfl);
9547 if (!class_to_search)
9550 (wfl, "Class `%s' not found in type declaration",
9551 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9552 PATCH_METHOD_RETURN_ERROR ();
9555 /* Can't instantiate an abstract class, but we can
9556 invoke it's constructor. It's use within the `new'
9557 context is denied here. */
9558 if (CLASS_ABSTRACT (class_to_search)
9559 && TREE_CODE (patch) == NEW_CLASS_EXPR)
9562 (wfl, "Class `%s' is an abstract class. It can't be instantiated",
9563 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9564 PATCH_METHOD_RETURN_ERROR ();
9567 class_to_search = TREE_TYPE (class_to_search);
9570 class_to_search = current_class;
9573 /* This is a regular search in the local class, unless an
9574 alternate class is specified. */
9577 class_to_search = (where ? where : current_class);
9581 /* NAME is a simple identifier or comes from a primary. Search
9582 in the class whose declaration contain the method being
9584 resolve_and_layout (class_to_search, NULL_TREE);
9586 list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
9587 /* Don't continue if no method were found, as the next statement
9588 can't be executed then. */
9590 PATCH_METHOD_RETURN_ERROR ();
9592 /* Check for static reference if non static methods */
9593 if (check_for_static_method_reference (wfl, patch, list,
9594 class_to_search, primary))
9595 PATCH_METHOD_RETURN_ERROR ();
9597 /* Check for inner classes creation from illegal contexts */
9598 if (lc && (INNER_CLASS_TYPE_P (class_to_search)
9599 && !CLASS_STATIC (TYPE_NAME (class_to_search)))
9600 && INNER_ENCLOSING_SCOPE_CHECK (class_to_search))
9603 (wfl, "No enclosing instance for inner class `%s' is in scope%s",
9604 lang_printable_name (class_to_search, 0),
9605 (!current_this ? "" :
9606 "; an explicit one must be provided when creating this inner class"));
9607 PATCH_METHOD_RETURN_ERROR ();
9610 /* Non static methods are called with the current object extra
9611 argument. If patch a `new TYPE()', the argument is the value
9612 returned by the object allocator. If method is resolved as a
9613 primary, use the primary otherwise use the current THIS. */
9614 args = nreverse (args);
9615 if (TREE_CODE (patch) != NEW_CLASS_EXPR)
9617 this_arg = primary ? primary : current_this;
9619 /* If we're using an access method, things are different.
9620 There are two familly of cases:
9622 1) We're not generating bytecodes:
9624 - LIST is non static. It's invocation is transformed from
9625 x(a1,...,an) into this$<n>.x(a1,....an).
9626 - LIST is static. It's invocation is transformed from
9627 x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
9629 2) We're generating bytecodes:
9631 - LIST is non static. It's invocation is transformed from
9632 x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
9633 - LIST is static. It's invocation is transformed from
9634 x(a1,....,an) into TYPEOF(this$<n>).x(a1,....an).
9636 Of course, this$<n> can be abitrary complex, ranging from
9637 this$0 (the immediate outer context) to
9638 access$0(access$0(...(this$0))).
9640 maybe_use_access_method returns a non zero value if the
9641 this_arg has to be moved into the (then generated) stub
9642 argument list. In the mean time, the selected function
9643 might have be replaced by a generated stub. */
9644 if (maybe_use_access_method (is_super_init, &list, &this_arg))
9645 args = tree_cons (NULL_TREE, this_arg, args);
9649 /* Merge point of all resolution schemes. If we have nothing, this
9650 is an error, already signaled */
9652 PATCH_METHOD_RETURN_ERROR ();
9654 /* Check accessibility, position the is_static flag, build and
9656 if (not_accessible_p (DECL_CONTEXT (current_function_decl), list, 0))
9658 char *fct_name = xstrdup (lang_printable_name (list, 0));
9660 (wfl, "Can't access %s method `%s %s.%s' from `%s'",
9661 java_accstring_lookup (get_access_flags_from_decl (list)),
9662 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
9663 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list)))),
9664 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
9666 PATCH_METHOD_RETURN_ERROR ();
9668 check_deprecation (wfl, list);
9670 /* If invoking a innerclass constructor, there are hidden parameters
9672 if (TREE_CODE (patch) == NEW_CLASS_EXPR
9673 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
9675 /* And make sure we add the accessed local variables to be saved
9676 in field aliases. */
9677 args = build_alias_initializer_parameter_list
9678 (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
9680 /* We have to reverse things. Find out why. FIXME */
9681 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (list)))
9682 args = nreverse (args);
9684 /* Secretely pass the current_this/primary as a second argument */
9685 if (primary || current_this)
9686 args = tree_cons (NULL_TREE, (primary ? primary : current_this), args);
9688 args = tree_cons (NULL_TREE, integer_zero_node, args);
9691 /* This handles the situation where a constructor invocation needs
9692 to have an enclosing context passed as a second parameter (the
9693 constructor is one of an inner class. We extract it from the
9694 current function. */
9695 if (is_super_init && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
9697 tree enclosing_decl = DECL_CONTEXT (TYPE_NAME (current_class));
9700 if (ANONYMOUS_CLASS_P (current_class) || !DECL_CONTEXT (enclosing_decl))
9702 extra_arg = DECL_FUNCTION_BODY (current_function_decl);
9703 extra_arg = TREE_CHAIN (BLOCK_EXPR_DECLS (extra_arg));
9707 tree dest = TREE_TYPE (DECL_CONTEXT (enclosing_decl));
9709 build_access_to_thisn (TREE_TYPE (enclosing_decl), dest, 0);
9710 extra_arg = java_complete_tree (extra_arg);
9712 args = tree_cons (NULL_TREE, extra_arg, args);
9715 is_static_flag = METHOD_STATIC (list);
9716 if (! METHOD_STATIC (list) && this_arg != NULL_TREE)
9717 args = tree_cons (NULL_TREE, this_arg, args);
9719 /* In the context of an explicit constructor invocation, we can't
9720 invoke any method relying on `this'. Exceptions are: we're
9721 invoking a static function, primary exists and is not the current
9722 this, we're creating a new object. */
9723 if (ctxp->explicit_constructor_p
9725 && (!primary || primary == current_this)
9726 && (TREE_CODE (patch) != NEW_CLASS_EXPR))
9728 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9729 PATCH_METHOD_RETURN_ERROR ();
9731 java_parser_context_restore_global ();
9733 *is_static = is_static_flag;
9734 /* Sometimes, we want the decl of the selected method. Such as for
9738 patch = patch_invoke (patch, list, args);
9739 if (is_super_init && CLASS_HAS_FINIT_P (current_class))
9741 tree finit_parms, finit_call;
9743 /* Prepare to pass hidden parameters to $finit$, if any. */
9744 finit_parms = build_alias_initializer_parameter_list
9745 (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
9748 build_method_invocation (build_wfl_node (finit_identifier_node),
9751 /* Generate the code used to initialize fields declared with an
9752 initialization statement and build a compound statement along
9753 with the super constructor invocation. */
9754 patch = build (COMPOUND_EXPR, void_type_node, patch,
9755 java_complete_tree (finit_call));
9756 CAN_COMPLETE_NORMALLY (patch) = 1;
9761 /* Check that we're not trying to do a static reference to a method in
9762 non static method. Return 1 if it's the case, 0 otherwise. */
9765 check_for_static_method_reference (wfl, node, method, where, primary)
9766 tree wfl, node, method, where, primary;
9768 if (METHOD_STATIC (current_function_decl)
9769 && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
9771 char *fct_name = xstrdup (lang_printable_name (method, 0));
9773 (wfl, "Can't make static reference to method `%s %s' in class `%s'",
9774 lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
9775 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
9782 /* Fix the invocation of *MDECL if necessary in the case of a
9783 invocation from an inner class. *THIS_ARG might be modified
9784 appropriately and an alternative access to *MDECL might be
9788 maybe_use_access_method (is_super_init, mdecl, this_arg)
9790 tree *mdecl, *this_arg;
9793 tree md = *mdecl, ta = *this_arg;
9795 int non_static_context = !METHOD_STATIC (md);
9798 || DECL_CONTEXT (md) == current_class
9799 || !PURE_INNER_CLASS_TYPE_P (current_class)
9800 || DECL_FINIT_P (md))
9803 /* If we're calling a method found in an enclosing class, generate
9804 what it takes to retrieve the right this. Don't do that if we're
9805 invoking a static method. */
9807 if (non_static_context)
9809 ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
9810 if (ctx == DECL_CONTEXT (md))
9812 ta = build_current_thisn (current_class);
9813 ta = build_wfl_node (ta);
9820 maybe_build_thisn_access_method (type);
9821 if (type == DECL_CONTEXT (md))
9823 ta = build_access_to_thisn (ctx, type, 0);
9826 type = (DECL_CONTEXT (TYPE_NAME (type)) ?
9827 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
9830 ta = java_complete_tree (ta);
9833 /* We might have to use an access method to get to MD. We can
9834 break the method access rule as far as we're not generating
9836 if (METHOD_PRIVATE (md) && flag_emit_class_files)
9838 md = build_outer_method_access_method (md);
9845 /* Returnin a non zero value indicates we were doing a non static
9846 method invokation that is now a static invocation. It will have
9847 callee displace `this' to insert it in the regular argument
9849 return (non_static_context && to_return);
9852 /* Patch an invoke expression METHOD and ARGS, based on its invocation
9856 patch_invoke (patch, method, args)
9857 tree patch, method, args;
9860 tree original_call, t, ta;
9861 tree cond = NULL_TREE;
9863 /* Last step for args: convert build-in types. If we're dealing with
9864 a new TYPE() type call, the first argument to the constructor
9865 isn't found in the incoming argument list, but delivered by
9867 t = TYPE_ARG_TYPES (TREE_TYPE (method));
9868 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
9870 for (ta = args; t != end_params_node && ta;
9871 t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
9872 if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
9873 TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
9874 TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
9876 /* Resolve unresolved returned type isses */
9877 t = TREE_TYPE (TREE_TYPE (method));
9878 if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
9879 resolve_and_layout (TREE_TYPE (t), NULL);
9881 if (flag_emit_class_files || flag_emit_xref)
9885 tree signature = build_java_signature (TREE_TYPE (method));
9886 switch (invocation_mode (method, CALL_USING_SUPER (patch)))
9888 case INVOKE_VIRTUAL:
9889 dtable = invoke_build_dtable (0, args);
9890 func = build_invokevirtual (dtable, method);
9893 case INVOKE_NONVIRTUAL:
9894 /* If the object for the method call is null, we throw an
9895 exception. We don't do this if the object is the current
9896 method's `this'. In other cases we just rely on an
9897 optimization pass to eliminate redundant checks. */
9898 if (TREE_VALUE (args) != current_this)
9900 /* We use a SAVE_EXPR here to make sure we only evaluate
9901 the new `self' expression once. */
9902 tree save_arg = save_expr (TREE_VALUE (args));
9903 TREE_VALUE (args) = save_arg;
9904 cond = build (EQ_EXPR, boolean_type_node, save_arg,
9911 func = build_known_method_ref (method, TREE_TYPE (method),
9912 DECL_CONTEXT (method),
9916 case INVOKE_INTERFACE:
9917 dtable = invoke_build_dtable (1, args);
9918 func = build_invokeinterface (dtable, method);
9922 fatal ("internal error - unknown invocation_mode result");
9925 /* Ensure self_type is initialized, (invokestatic). FIXME */
9926 func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
9929 TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
9930 TREE_OPERAND (patch, 0) = func;
9931 TREE_OPERAND (patch, 1) = args;
9932 original_call = patch;
9934 /* We're processing a `new TYPE ()' form. New is called and its
9935 returned value is the first argument to the constructor. We build
9936 a COMPOUND_EXPR and use saved expression so that the overall NEW
9937 expression value is a pointer to a newly created and initialized
9939 if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
9941 tree class = DECL_CONTEXT (method);
9942 tree c1, saved_new, size, new;
9943 if (flag_emit_class_files || flag_emit_xref)
9945 TREE_TYPE (patch) = build_pointer_type (class);
9948 if (!TYPE_SIZE (class))
9949 safe_layout_class (class);
9950 size = size_in_bytes (class);
9951 new = build (CALL_EXPR, promote_type (class),
9952 build_address_of (alloc_object_node),
9953 tree_cons (NULL_TREE, build_class_ref (class),
9954 build_tree_list (NULL_TREE,
9955 size_in_bytes (class))),
9957 saved_new = save_expr (new);
9958 c1 = build_tree_list (NULL_TREE, saved_new);
9959 TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
9960 TREE_OPERAND (original_call, 1) = c1;
9961 TREE_SET_CODE (original_call, CALL_EXPR);
9962 patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
9965 /* If COND is set, then we are building a check to see if the object
9967 if (cond != NULL_TREE)
9969 /* We have to make the `then' branch a compound expression to
9970 make the types turn out right. This seems bizarre. */
9971 patch = build (COND_EXPR, TREE_TYPE (patch), cond,
9972 build (COMPOUND_EXPR, TREE_TYPE (patch),
9973 build (CALL_EXPR, void_type_node,
9974 build_address_of (soft_nullpointer_node),
9975 NULL_TREE, NULL_TREE),
9976 (FLOAT_TYPE_P (TREE_TYPE (patch))
9977 ? build_real (TREE_TYPE (patch), dconst0)
9978 : build1 (CONVERT_EXPR, TREE_TYPE (patch),
9979 integer_zero_node))),
9981 TREE_SIDE_EFFECTS (patch) = 1;
9988 invocation_mode (method, super)
9992 int access = get_access_flags_from_decl (method);
9995 return INVOKE_SUPER;
9997 if (access & ACC_STATIC)
9998 return INVOKE_STATIC;
10000 /* We have to look for a constructor before we handle nonvirtual
10001 calls; otherwise the constructor will look nonvirtual. */
10002 if (DECL_CONSTRUCTOR_P (method))
10003 return INVOKE_STATIC;
10005 if (access & ACC_FINAL || access & ACC_PRIVATE)
10006 return INVOKE_NONVIRTUAL;
10008 if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10009 return INVOKE_NONVIRTUAL;
10011 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10012 return INVOKE_INTERFACE;
10014 return INVOKE_VIRTUAL;
10017 /* Retrieve a refined list of matching methods. It covers the step
10018 15.11.2 (Compile-Time Step 2) */
10021 lookup_method_invoke (lc, cl, class, name, arg_list)
10024 tree class, name, arg_list;
10026 tree atl = end_params_node; /* Arg Type List */
10027 tree method, signature, list, node;
10028 const char *candidates; /* Used for error report */
10031 /* Fix the arguments */
10032 for (node = arg_list; node; node = TREE_CHAIN (node))
10034 tree current_arg = TREE_TYPE (TREE_VALUE (node));
10035 /* Non primitive type may have to be resolved */
10036 if (!JPRIMITIVE_TYPE_P (current_arg))
10037 resolve_and_layout (current_arg, NULL_TREE);
10039 if (TREE_CODE (current_arg) == RECORD_TYPE)
10040 current_arg = promote_type (current_arg);
10041 atl = tree_cons (NULL_TREE, current_arg, atl);
10044 /* Presto. If we're dealing with an anonymous class and a
10045 constructor call, generate the right constructor now, since we
10046 know the arguments' types. */
10048 if (lc && ANONYMOUS_CLASS_P (class))
10049 craft_constructor (TYPE_NAME (class), atl);
10051 /* Find all candidates and then refine the list, searching for the
10052 most specific method. */
10053 list = find_applicable_accessible_methods_list (lc, class, name, atl);
10054 list = find_most_specific_methods_list (list);
10055 if (list && !TREE_CHAIN (list))
10056 return TREE_VALUE (list);
10058 /* Issue an error. List candidates if any. Candidates are listed
10059 only if accessible (non accessible methods may end-up here for
10060 the sake of a better error report). */
10065 obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10066 for (current = list; current; current = TREE_CHAIN (current))
10068 tree cm = TREE_VALUE (current);
10069 char string [4096];
10070 if (!cm || not_accessible_p (class, cm, 0))
10073 (string, " `%s' in `%s'%s",
10074 get_printable_method_name (cm),
10075 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10076 (TREE_CHAIN (current) ? "\n" : ""));
10077 obstack_grow (&temporary_obstack, string, strlen (string));
10079 obstack_1grow (&temporary_obstack, '\0');
10080 candidates = obstack_finish (&temporary_obstack);
10082 /* Issue the error message */
10083 method = make_node (FUNCTION_TYPE);
10084 TYPE_ARG_TYPES (method) = atl;
10085 signature = build_java_argument_signature (method);
10086 dup = xstrdup (lang_printable_name (class, 0));
10087 parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10088 (lc ? "constructor" : "method"),
10089 (lc ? dup : IDENTIFIER_POINTER (name)),
10090 IDENTIFIER_POINTER (signature), dup,
10091 (candidates ? candidates : ""));
10096 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10097 when we're looking for a constructor. */
10100 find_applicable_accessible_methods_list (lc, class, name, arglist)
10102 tree class, name, arglist;
10104 static struct hash_table t, *searched_classes = NULL;
10105 static int search_not_done = 0;
10106 tree list = NULL_TREE, all_list = NULL_TREE;
10108 /* Check the hash table to determine if this class has been searched
10110 if (searched_classes)
10112 if (hash_lookup (searched_classes,
10113 (const hash_table_key) class, FALSE, NULL))
10118 hash_table_init (&t, hash_newfunc, java_hash_hash_tree_node,
10119 java_hash_compare_tree_node);
10120 searched_classes = &t;
10124 hash_lookup (searched_classes,
10125 (const hash_table_key) class, TRUE, NULL);
10127 if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
10129 load_class (class, 1);
10130 safe_layout_class (class);
10133 /* Search interfaces */
10134 if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
10135 && CLASS_INTERFACE (TYPE_NAME (class)))
10138 tree basetype_vec = TYPE_BINFO_BASETYPES (class);
10139 search_applicable_methods_list (lc, TYPE_METHODS (class),
10140 name, arglist, &list, &all_list);
10141 n = TREE_VEC_LENGTH (basetype_vec);
10142 for (i = 1; i < n; i++)
10144 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
10147 rlist = find_applicable_accessible_methods_list (lc, t, name,
10149 list = chainon (rlist, list);
10152 /* Search classes */
10156 int seen_inner_class = 0;
10157 search_applicable_methods_list (lc, TYPE_METHODS (class),
10158 name, arglist, &list, &all_list);
10160 /* We must search all interfaces of this class */
10163 tree basetype_vec = TYPE_BINFO_BASETYPES (sc);
10164 int n = TREE_VEC_LENGTH (basetype_vec), i;
10165 for (i = 1; i < n; i++)
10167 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
10168 if (t != object_type_node)
10171 = find_applicable_accessible_methods_list (lc, t,
10173 list = chainon (rlist, list);
10178 /* Search enclosing context of inner classes before looking
10180 while (!lc && INNER_CLASS_TYPE_P (class))
10183 seen_inner_class = 1;
10184 class = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
10185 rlist = find_applicable_accessible_methods_list (lc, class,
10187 list = chainon (rlist, list);
10190 if (!lc && seen_inner_class
10191 && TREE_TYPE (DECL_CONTEXT (TYPE_NAME (sc))) == CLASSTYPE_SUPER (sc))
10192 class = CLASSTYPE_SUPER (sc);
10196 /* Search superclass */
10197 if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
10200 class = CLASSTYPE_SUPER (class);
10201 rlist = find_applicable_accessible_methods_list (lc, class,
10203 list = chainon (rlist, list);
10209 /* We're done. Reset the searched classes list and finally search
10210 java.lang.Object if it wasn't searched already. */
10211 if (!search_not_done)
10214 && TYPE_METHODS (object_type_node)
10215 && !hash_lookup (searched_classes,
10216 (const hash_table_key) object_type_node,
10219 search_applicable_methods_list (lc,
10220 TYPE_METHODS (object_type_node),
10221 name, arglist, &list, &all_list);
10223 hash_table_free (searched_classes);
10224 searched_classes = NULL;
10227 /* Either return the list obtained or all selected (but
10228 inaccessible) methods for better error report. */
10229 return (!list ? all_list : list);
10232 /* Effectively search for the appropriate method in method */
10235 search_applicable_methods_list (lc, method, name, arglist, list, all_list)
10237 tree method, name, arglist;
10238 tree *list, *all_list;
10240 for (; method; method = TREE_CHAIN (method))
10242 /* When dealing with constructor, stop here, otherwise search
10244 if (lc && !DECL_CONSTRUCTOR_P (method))
10246 else if (!lc && (DECL_CONSTRUCTOR_P (method)
10247 || (GET_METHOD_NAME (method) != name)))
10250 if (argument_types_convertible (method, arglist))
10252 /* Retain accessible methods only */
10253 if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
10255 *list = tree_cons (NULL_TREE, method, *list);
10257 /* Also retain all selected method here */
10258 *all_list = tree_cons (NULL_TREE, method, *list);
10263 /* 15.11.2.2 Choose the Most Specific Method */
10266 find_most_specific_methods_list (list)
10270 int abstract, candidates;
10271 tree current, new_list = NULL_TREE;
10272 for (current = list; current; current = TREE_CHAIN (current))
10275 DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
10277 for (method = list; method; method = TREE_CHAIN (method))
10279 /* Don't test a method against itself */
10280 if (method == current)
10283 /* Compare arguments and location where method where declared */
10284 if (argument_types_convertible (TREE_VALUE (method),
10285 TREE_VALUE (current))
10286 && valid_method_invocation_conversion_p
10287 (DECL_CONTEXT (TREE_VALUE (method)),
10288 DECL_CONTEXT (TREE_VALUE (current))))
10290 int v = ++DECL_SPECIFIC_COUNT (TREE_VALUE (current));
10291 max = (v > max ? v : max);
10296 /* Review the list and select the maximally specific methods */
10297 for (current = list, abstract = -1, candidates = -1;
10298 current; current = TREE_CHAIN (current))
10299 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
10301 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
10302 abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
10306 /* If we have several and they're all abstract, just pick the
10308 if (candidates > 0 && (candidates == abstract))
10310 new_list = nreverse (new_list);
10311 TREE_CHAIN (new_list) = NULL_TREE;
10314 /* We have several, we couldn't find a most specific, all but one are
10315 abstract, we pick the only non abstract one. */
10316 if (candidates > 0 && !max && (candidates == abstract+1))
10318 for (current = new_list; current; current = TREE_CHAIN (current))
10319 if (!METHOD_ABSTRACT (TREE_VALUE (current)))
10321 TREE_CHAIN (current) = NULL_TREE;
10322 new_list = current;
10326 /* If we can't find one, lower expectations and try to gather multiple
10327 maximally specific methods */
10328 while (!new_list && max)
10332 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
10333 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
10340 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
10341 converted by method invocation conversion (5.3) to the type of the
10342 corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
10343 to change less often than M1. */
10346 argument_types_convertible (m1, m2_or_arglist)
10347 tree m1, m2_or_arglist;
10349 static tree m2_arg_value = NULL_TREE;
10350 static tree m2_arg_cache = NULL_TREE;
10352 register tree m1_arg, m2_arg;
10354 SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
10356 if (m2_arg_value == m2_or_arglist)
10357 m2_arg = m2_arg_cache;
10360 /* M2_OR_ARGLIST can be a function DECL or a raw list of
10362 if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
10364 m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
10365 if (!METHOD_STATIC (m2_or_arglist))
10366 m2_arg = TREE_CHAIN (m2_arg);
10369 m2_arg = m2_or_arglist;
10371 m2_arg_value = m2_or_arglist;
10372 m2_arg_cache = m2_arg;
10375 while (m1_arg != end_params_node && m2_arg != end_params_node)
10377 resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
10378 if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
10379 TREE_VALUE (m2_arg)))
10381 m1_arg = TREE_CHAIN (m1_arg);
10382 m2_arg = TREE_CHAIN (m2_arg);
10384 return m1_arg == end_params_node && m2_arg == end_params_node;
10387 /* Qualification routines */
10390 qualify_ambiguous_name (id)
10393 tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
10394 saved_current_class;
10395 int again, super_found = 0, this_found = 0, new_array_found = 0;
10398 /* We first qualify the first element, then derive qualification of
10399 others based on the first one. If the first element is qualified
10400 by a resolution (field or type), this resolution is stored in the
10401 QUAL_RESOLUTION of the qual element being examined. We need to
10402 save the current_class since the use of SUPER might change the
10404 saved_current_class = current_class;
10405 qual = EXPR_WFL_QUALIFICATION (id);
10408 /* Simple qualified expression feature a qual_wfl that is a
10409 WFL. Expression derived from a primary feature more complicated
10410 things like a CALL_EXPR. Expression from primary need to be
10411 worked out to extract the part on which the qualification will
10413 qual_wfl = QUAL_WFL (qual);
10414 switch (TREE_CODE (qual_wfl))
10417 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10418 if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
10420 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
10421 qual_wfl = QUAL_WFL (qual);
10424 case NEW_ARRAY_EXPR:
10425 case NEW_ANONYMOUS_ARRAY_EXPR:
10426 qual = TREE_CHAIN (qual);
10427 again = new_array_found = 1;
10431 case NEW_CLASS_EXPR:
10432 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10435 while (TREE_CODE (qual_wfl) == ARRAY_REF)
10436 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10439 qual = TREE_CHAIN (qual);
10440 qual_wfl = QUAL_WFL (qual);
10442 case CLASS_LITERAL:
10443 qual = TREE_CHAIN (qual);
10444 qual_wfl = QUAL_WFL (qual);
10447 /* Fix for -Wall. Just break doing nothing */
10451 ptr_type = current_class;
10453 code = TREE_CODE (qual_wfl);
10455 /* Pos evaluation: non WFL leading expression nodes */
10456 if (code == CONVERT_EXPR
10457 && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
10458 name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
10460 else if (code == INTEGER_CST)
10463 else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
10464 TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
10465 name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
10467 else if (code == TREE_LIST)
10468 name = EXPR_WFL_NODE (TREE_PURPOSE (qual_wfl));
10470 else if (code == STRING_CST || code == CONDITIONAL_EXPR
10471 || code == PLUS_EXPR)
10473 qual = TREE_CHAIN (qual);
10474 qual_wfl = QUAL_WFL (qual);
10479 name = EXPR_WFL_NODE (qual_wfl);
10482 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
10487 /* If we have a THIS (from a primary), we set the context accordingly */
10488 if (name == this_identifier_node)
10490 qual = TREE_CHAIN (qual);
10491 qual_wfl = QUAL_WFL (qual);
10492 if (TREE_CODE (qual_wfl) == CALL_EXPR)
10495 name = EXPR_WFL_NODE (qual_wfl);
10498 /* If we have a SUPER, we set the context accordingly */
10499 if (name == super_identifier_node)
10501 current_class = CLASSTYPE_SUPER (ptr_type);
10502 /* Check that there is such a thing as a super class. If not,
10503 return. The error will be caught later on, during the
10505 if (!current_class)
10507 current_class = saved_current_class;
10510 qual = TREE_CHAIN (qual);
10511 /* Do one more interation to set things up */
10512 super_found = again = 1;
10516 /* If name appears within the scope of a local variable declaration
10517 or parameter declaration, then it is an expression name. We don't
10518 carry this test out if we're in the context of the use of SUPER
10520 if (!this_found && !super_found
10521 && TREE_CODE (name) != STRING_CST && TREE_CODE (name) != INTEGER_CST
10522 && (decl = IDENTIFIER_LOCAL_VALUE (name)))
10524 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
10525 QUAL_RESOLUTION (qual) = decl;
10528 /* If within the class/interface NAME was found to be used there
10529 exists a (possibly inherited) field named NAME, then this is an
10530 expression name. If we saw a NEW_ARRAY_EXPR before and want to
10531 address length, it is OK. */
10532 else if ((decl = lookup_field_wrapper (ptr_type, name))
10533 || (new_array_found && name == length_identifier_node))
10535 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
10536 QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
10539 /* We reclassify NAME as yielding to a type name resolution if:
10540 - NAME is a class/interface declared within the compilation
10541 unit containing NAME,
10542 - NAME is imported via a single-type-import declaration,
10543 - NAME is declared in an another compilation unit of the package
10544 of the compilation unit containing NAME,
10545 - NAME is declared by exactly on type-import-on-demand declaration
10546 of the compilation unit containing NAME.
10547 - NAME is actually a STRING_CST. */
10548 else if (TREE_CODE (name) == STRING_CST || TREE_CODE (name) == INTEGER_CST
10549 || (decl = resolve_and_layout (name, NULL_TREE)))
10551 RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
10552 QUAL_RESOLUTION (qual) = decl;
10555 /* Method call, array references and cast are expression name */
10556 else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
10557 || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
10558 || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR)
10559 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
10561 /* Check here that NAME isn't declared by more than one
10562 type-import-on-demand declaration of the compilation unit
10563 containing NAME. FIXME */
10565 /* Otherwise, NAME is reclassified as a package name */
10567 RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
10569 /* Propagate the qualification accross other components of the
10571 for (qual = TREE_CHAIN (qual); qual;
10572 qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
10574 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
10575 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
10577 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
10580 /* Store the global qualification for the ambiguous part of ID back
10582 if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
10583 RESOLVE_EXPRESSION_NAME_P (id) = 1;
10584 else if (RESOLVE_TYPE_NAME_P (qual_wfl))
10585 RESOLVE_TYPE_NAME_P (id) = 1;
10586 else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
10587 RESOLVE_PACKAGE_NAME_P (id) = 1;
10589 /* Restore the current class */
10590 current_class = saved_current_class;
10594 breakdown_qualified (left, right, source)
10595 tree *left, *right, source;
10597 char *p = IDENTIFIER_POINTER (source), *base;
10598 int l = IDENTIFIER_LENGTH (source);
10600 /* Breakdown NAME into REMAINDER . IDENTIFIER */
10603 while (*p != '.' && p != base)
10606 /* We didn't find a '.'. Return an error */
10612 *right = get_identifier (p+1);
10613 *left = get_identifier (IDENTIFIER_POINTER (source));
10619 /* Patch tree nodes in a function body. When a BLOCK is found, push
10620 local variable decls if present.
10621 Same as java_complete_lhs, but does resolve static finals to values. */
10624 java_complete_tree (node)
10627 node = java_complete_lhs (node);
10628 if (TREE_CODE (node) == VAR_DECL && FIELD_STATIC (node)
10629 && FIELD_FINAL (node) && DECL_INITIAL (node) != NULL_TREE
10630 && !flag_emit_xref)
10632 tree value = DECL_INITIAL (node);
10633 DECL_INITIAL (node) = NULL_TREE;
10634 push_obstacks (&permanent_obstack, &permanent_obstack);
10635 value = fold_constant_for_init (value, node);
10637 DECL_INITIAL (node) = value;
10638 if (value != NULL_TREE)
10640 /* fold_constant_for_init sometimes widen the original type
10641 of the constant (i.e. byte to int.) It's not desirable,
10642 especially if NODE is a function argument. */
10643 if (TREE_CODE (value) == INTEGER_CST
10644 && TREE_TYPE (node) != TREE_TYPE (value))
10645 return convert (TREE_TYPE (node), value);
10654 java_stabilize_reference (node)
10657 if (TREE_CODE (node) == COMPOUND_EXPR)
10659 tree op0 = TREE_OPERAND (node, 0);
10660 tree op1 = TREE_OPERAND (node, 1);
10661 TREE_OPERAND (node, 0) = save_expr (op0);
10662 TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
10665 return stabilize_reference (node);
10668 /* Patch tree nodes in a function body. When a BLOCK is found, push
10669 local variable decls if present.
10670 Same as java_complete_tree, but does not resolve static finals to values. */
10673 java_complete_lhs (node)
10676 tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
10679 /* CONVERT_EXPR always has its type set, even though it needs to be
10681 if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
10684 /* The switch block implements cases processing container nodes
10685 first. Contained nodes are always written back. Leaves come
10686 next and return a value. */
10687 switch (TREE_CODE (node))
10691 /* 1- Block section.
10692 Set the local values on decl names so we can identify them
10693 faster when they're referenced. At that stage, identifiers
10694 are legal so we don't check for declaration errors. */
10695 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
10697 DECL_CONTEXT (cn) = current_function_decl;
10698 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
10700 if (BLOCK_EXPR_BODY (node) == NULL_TREE)
10701 CAN_COMPLETE_NORMALLY (node) = 1;
10704 tree stmt = BLOCK_EXPR_BODY (node);
10706 int error_seen = 0;
10707 if (TREE_CODE (stmt) == COMPOUND_EXPR)
10709 /* Re-order from (((A; B); C); ...; Z) to
10710 (A; (B; (C ; (...; Z)))).
10711 This makes it easier to scan the statements left-to-right
10712 without using recursion (which might overflow the stack
10713 if the block has many statements. */
10716 tree left = TREE_OPERAND (stmt, 0);
10717 if (TREE_CODE (left) != COMPOUND_EXPR)
10719 TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
10720 TREE_OPERAND (left, 1) = stmt;
10723 BLOCK_EXPR_BODY (node) = stmt;
10726 /* Now do the actual complete, without deep recursion for
10728 ptr = &BLOCK_EXPR_BODY (node);
10729 while (TREE_CODE (*ptr) == COMPOUND_EXPR
10730 && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
10732 tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
10733 tree *next = &TREE_OPERAND (*ptr, 1);
10734 TREE_OPERAND (*ptr, 0) = cur;
10735 if (cur == empty_stmt_node)
10737 /* Optimization; makes it easier to detect empty bodies.
10738 Most useful for <clinit> with all-constant initializer. */
10742 if (TREE_CODE (cur) == ERROR_MARK)
10744 else if (! CAN_COMPLETE_NORMALLY (cur))
10749 if (TREE_CODE (wfl_op2) == BLOCK)
10750 wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
10751 else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
10752 wfl_op2 = TREE_OPERAND (wfl_op2, 0);
10756 if (TREE_CODE (wfl_op2) != CASE_EXPR
10757 && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
10758 unreachable_stmt_error (*ptr);
10762 *ptr = java_complete_tree (*ptr);
10764 if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
10765 return error_mark_node;
10766 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
10768 /* Turn local bindings to null */
10769 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
10770 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
10772 TREE_TYPE (node) = void_type_node;
10775 /* 2- They are expressions but ultimately deal with statements */
10778 wfl_op1 = TREE_OPERAND (node, 0);
10779 COMPLETE_CHECK_OP_0 (node);
10780 /* 14.19 A throw statement cannot complete normally. */
10781 CAN_COMPLETE_NORMALLY (node) = 0;
10782 return patch_throw_statement (node, wfl_op1);
10784 case SYNCHRONIZED_EXPR:
10785 wfl_op1 = TREE_OPERAND (node, 0);
10786 return patch_synchronized_statement (node, wfl_op1);
10789 return patch_try_statement (node);
10791 case TRY_FINALLY_EXPR:
10792 COMPLETE_CHECK_OP_0 (node);
10793 COMPLETE_CHECK_OP_1 (node);
10794 CAN_COMPLETE_NORMALLY (node)
10795 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
10796 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
10797 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
10800 case CLEANUP_POINT_EXPR:
10801 COMPLETE_CHECK_OP_0 (node);
10802 TREE_TYPE (node) = void_type_node;
10803 CAN_COMPLETE_NORMALLY (node) =
10804 CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
10807 case WITH_CLEANUP_EXPR:
10808 COMPLETE_CHECK_OP_0 (node);
10809 COMPLETE_CHECK_OP_2 (node);
10810 CAN_COMPLETE_NORMALLY (node) =
10811 CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
10812 TREE_TYPE (node) = void_type_node;
10815 case LABELED_BLOCK_EXPR:
10816 PUSH_LABELED_BLOCK (node);
10817 if (LABELED_BLOCK_BODY (node))
10818 COMPLETE_CHECK_OP_1 (node);
10819 TREE_TYPE (node) = void_type_node;
10820 POP_LABELED_BLOCK ();
10822 if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
10824 LABELED_BLOCK_BODY (node) = NULL_TREE;
10825 CAN_COMPLETE_NORMALLY (node) = 1;
10827 else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
10828 CAN_COMPLETE_NORMALLY (node) = 1;
10831 case EXIT_BLOCK_EXPR:
10832 /* We don't complete operand 1, because it's the return value of
10833 the EXIT_BLOCK_EXPR which doesn't exist it Java */
10834 return patch_bc_statement (node);
10837 cn = java_complete_tree (TREE_OPERAND (node, 0));
10838 if (cn == error_mark_node)
10841 /* First, the case expression must be constant. Values of final
10842 fields are accepted. */
10844 if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
10845 && JDECL_P (TREE_OPERAND (cn, 1))
10846 && FIELD_FINAL (TREE_OPERAND (cn, 1))
10847 && DECL_INITIAL (TREE_OPERAND (cn, 1)))
10849 push_obstacks (&permanent_obstack, &permanent_obstack);
10850 cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
10851 TREE_OPERAND (cn, 1));
10855 if (!TREE_CONSTANT (cn) && !flag_emit_xref)
10857 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10858 parse_error_context (node, "Constant expression required");
10859 return error_mark_node;
10862 nn = ctxp->current_loop;
10864 /* It must be assignable to the type of the switch expression. */
10865 if (!try_builtin_assignconv (NULL_TREE,
10866 TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
10868 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10869 parse_error_context
10871 "Incompatible type for case. Can't convert `%s' to `int'",
10872 lang_printable_name (TREE_TYPE (cn), 0));
10873 return error_mark_node;
10876 cn = fold (convert (int_type_node, cn));
10878 /* Multiple instance of a case label bearing the same
10879 value is checked during code generation. The case
10880 expression is allright so far. */
10881 TREE_OPERAND (node, 0) = cn;
10882 TREE_TYPE (node) = void_type_node;
10883 CAN_COMPLETE_NORMALLY (node) = 1;
10884 TREE_SIDE_EFFECTS (node) = 1;
10888 nn = ctxp->current_loop;
10889 /* Only one default label is allowed per switch statement */
10890 if (SWITCH_HAS_DEFAULT (nn))
10892 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10893 parse_error_context (wfl_operator,
10894 "Duplicate case label: `default'");
10895 return error_mark_node;
10898 SWITCH_HAS_DEFAULT (nn) = 1;
10899 TREE_TYPE (node) = void_type_node;
10900 TREE_SIDE_EFFECTS (node) = 1;
10901 CAN_COMPLETE_NORMALLY (node) = 1;
10907 /* Check whether the loop was enclosed in a labeled
10908 statement. If not, create one, insert the loop in it and
10910 nn = patch_loop_statement (node);
10912 /* Anyways, walk the body of the loop */
10913 if (TREE_CODE (node) == LOOP_EXPR)
10914 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10915 /* Switch statement: walk the switch expression and the cases */
10917 node = patch_switch_statement (node);
10919 if (TREE_OPERAND (node, 0) == error_mark_node)
10920 nn = error_mark_node;
10923 TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
10924 /* If we returned something different, that's because we
10925 inserted a label. Pop the label too. */
10928 if (CAN_COMPLETE_NORMALLY (node))
10929 CAN_COMPLETE_NORMALLY (nn) = 1;
10930 POP_LABELED_BLOCK ();
10937 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10938 return patch_exit_expr (node);
10942 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10943 if (TREE_OPERAND (node, 0) == error_mark_node)
10944 return error_mark_node;
10945 /* then-else branches */
10946 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
10947 if (TREE_OPERAND (node, 1) == error_mark_node)
10948 return error_mark_node;
10949 TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
10950 if (TREE_OPERAND (node, 2) == error_mark_node)
10951 return error_mark_node;
10952 return patch_if_else_statement (node);
10955 case CONDITIONAL_EXPR:
10957 wfl_op1 = TREE_OPERAND (node, 0);
10958 COMPLETE_CHECK_OP_0 (node);
10959 wfl_op2 = TREE_OPERAND (node, 1);
10960 COMPLETE_CHECK_OP_1 (node);
10961 wfl_op3 = TREE_OPERAND (node, 2);
10962 COMPLETE_CHECK_OP_2 (node);
10963 return patch_conditional_expr (node, wfl_op1, wfl_op2);
10965 /* 3- Expression section */
10966 case COMPOUND_EXPR:
10967 wfl_op2 = TREE_OPERAND (node, 1);
10968 TREE_OPERAND (node, 0) = nn =
10969 java_complete_tree (TREE_OPERAND (node, 0));
10970 if (wfl_op2 == empty_stmt_node)
10971 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
10974 if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
10976 /* An unreachable condition in a do-while statement
10977 is *not* (technically) an unreachable statement. */
10979 if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
10980 nn = EXPR_WFL_NODE (nn);
10981 if (TREE_CODE (nn) != EXIT_EXPR)
10983 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
10984 parse_error_context (wfl_operator, "Unreachable statement");
10987 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
10988 if (TREE_OPERAND (node, 1) == error_mark_node)
10989 return error_mark_node;
10990 CAN_COMPLETE_NORMALLY (node)
10991 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1));
10993 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
10997 /* CAN_COMPLETE_NORMALLY (node) = 0; */
10998 return patch_return (node);
11000 case EXPR_WITH_FILE_LOCATION:
11001 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11002 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11005 node = resolve_expression_name (node, NULL);
11006 if (node == error_mark_node)
11008 /* Keep line number information somewhere were it doesn't
11009 disrupt the completion process. */
11010 if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11012 EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11013 TREE_OPERAND (node, 1) = wfl;
11015 CAN_COMPLETE_NORMALLY (node) = 1;
11020 int save_lineno = lineno;
11021 lineno = EXPR_WFL_LINENO (node);
11022 body = java_complete_tree (EXPR_WFL_NODE (node));
11023 lineno = save_lineno;
11024 EXPR_WFL_NODE (node) = body;
11025 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11026 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11027 if (body == empty_stmt_node)
11029 /* Optimization; makes it easier to detect empty bodies. */
11032 if (body == error_mark_node)
11034 /* Its important for the evaluation of assignment that
11035 this mark on the TREE_TYPE is propagated. */
11036 TREE_TYPE (node) = error_mark_node;
11037 return error_mark_node;
11040 TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11045 case NEW_ARRAY_EXPR:
11046 /* Patch all the dimensions */
11048 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11050 int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11051 tree dim = convert (int_type_node,
11052 java_complete_tree (TREE_VALUE (cn)));
11053 if (dim == error_mark_node)
11060 TREE_VALUE (cn) = dim;
11061 /* Setup the location of the current dimension, for
11062 later error report. */
11063 TREE_PURPOSE (cn) =
11064 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11065 EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11068 /* They complete the array creation expression, if no errors
11070 CAN_COMPLETE_NORMALLY (node) = 1;
11071 return (flag ? error_mark_node
11072 : force_evaluation_order (patch_newarray (node)));
11074 case NEW_ANONYMOUS_ARRAY_EXPR:
11075 /* Create the array type if necessary. */
11076 if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11078 tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11079 if (!(type = resolve_type_during_patch (type)))
11080 return error_mark_node;
11081 type = build_array_from_name (type, NULL_TREE,
11082 ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11083 ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11085 node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11086 ANONYMOUS_ARRAY_INITIALIZER (node));
11087 if (node == error_mark_node)
11088 return error_mark_node;
11089 CAN_COMPLETE_NORMALLY (node) = 1;
11092 case NEW_CLASS_EXPR:
11094 /* Complete function's argument(s) first */
11095 if (complete_function_arguments (node))
11096 return error_mark_node;
11099 tree decl, wfl = TREE_OPERAND (node, 0);
11100 int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11102 node = patch_method_invocation (node, NULL_TREE,
11103 NULL_TREE, 0, &decl);
11104 if (node == error_mark_node)
11105 return error_mark_node;
11107 check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
11108 /* If we call this(...), register signature and positions */
11110 DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11111 tree_cons (wfl, decl,
11112 DECL_CONSTRUCTOR_CALLS (current_function_decl));
11113 CAN_COMPLETE_NORMALLY (node) = 1;
11114 return force_evaluation_order (node);
11118 /* Save potential wfls */
11119 wfl_op1 = TREE_OPERAND (node, 0);
11120 TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11122 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11123 && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11124 && DECL_INITIAL (nn) != NULL_TREE)
11128 push_obstacks (&permanent_obstack, &permanent_obstack);
11129 value = fold_constant_for_init (nn, nn);
11132 if (value != NULL_TREE)
11134 tree type = TREE_TYPE (value);
11135 if (JPRIMITIVE_TYPE_P (type) ||
11136 (type == string_ptr_type_node && ! flag_emit_class_files))
11137 return empty_stmt_node;
11139 DECL_INITIAL (nn) = NULL_TREE;
11141 wfl_op2 = TREE_OPERAND (node, 1);
11143 if (TREE_OPERAND (node, 0) == error_mark_node)
11144 return error_mark_node;
11146 flag = COMPOUND_ASSIGN_P (wfl_op2);
11149 /* This might break when accessing outer field from inner
11150 class. TESTME, FIXME */
11151 tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11153 /* Hand stablize the lhs on both places */
11154 TREE_OPERAND (node, 0) = lvalue;
11155 TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11156 (flag_emit_class_files ? lvalue : save_expr (lvalue));
11158 /* 15.25.2.a: Left hand is not an array access. FIXME */
11159 /* Now complete the RHS. We write it back later on. */
11160 nn = java_complete_tree (TREE_OPERAND (node, 1));
11162 if ((cn = patch_string (nn)))
11165 /* The last part of the rewrite for E1 op= E2 is to have
11166 E1 = (T)(E1 op E2), with T being the type of E1. */
11167 nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
11168 TREE_TYPE (lvalue), nn));
11170 /* 15.25.2.b: Left hand is an array access. FIXME */
11173 /* If we're about to patch a NEW_ARRAY_INIT, we call a special
11174 function to complete this RHS. Note that a NEW_ARRAY_INIT
11175 might have been already fully expanded if created as a result
11176 of processing an anonymous array initializer. We avoid doing
11177 the operation twice by testing whether the node already bears
11179 else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
11180 nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
11181 TREE_OPERAND (node, 1));
11182 /* Otherwise we simply complete the RHS */
11184 nn = java_complete_tree (TREE_OPERAND (node, 1));
11186 if (nn == error_mark_node)
11187 return error_mark_node;
11189 /* Write back the RHS as we evaluated it. */
11190 TREE_OPERAND (node, 1) = nn;
11192 /* In case we're handling = with a String as a RHS, we need to
11193 produce a String out of the RHS (it might still be a
11194 STRING_CST or a StringBuffer at this stage */
11195 if ((nn = patch_string (TREE_OPERAND (node, 1))))
11196 TREE_OPERAND (node, 1) = nn;
11198 if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
11199 TREE_OPERAND (node, 1))))
11201 /* We return error_mark_node if outer_field_access_fix
11202 detects we write into a final. */
11203 if (nn == error_mark_node)
11204 return error_mark_node;
11209 node = patch_assignment (node, wfl_op1, wfl_op2);
11210 /* Reorganize the tree if necessary. */
11211 if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
11212 || JSTRING_P (TREE_TYPE (node))))
11213 node = java_refold (node);
11216 CAN_COMPLETE_NORMALLY (node) = 1;
11228 case TRUNC_MOD_EXPR:
11229 case TRUNC_DIV_EXPR:
11231 case TRUTH_ANDIF_EXPR:
11232 case TRUTH_ORIF_EXPR:
11239 /* Operands 0 and 1 are WFL in certain cases only. patch_binop
11240 knows how to handle those cases. */
11241 wfl_op1 = TREE_OPERAND (node, 0);
11242 wfl_op2 = TREE_OPERAND (node, 1);
11244 CAN_COMPLETE_NORMALLY (node) = 1;
11245 /* Don't complete string nodes if dealing with the PLUS operand. */
11246 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
11248 nn = java_complete_tree (wfl_op1);
11249 if (nn == error_mark_node)
11250 return error_mark_node;
11252 TREE_OPERAND (node, 0) = nn;
11254 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
11256 nn = java_complete_tree (wfl_op2);
11257 if (nn == error_mark_node)
11258 return error_mark_node;
11260 TREE_OPERAND (node, 1) = nn;
11262 return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
11264 case INSTANCEOF_EXPR:
11265 wfl_op1 = TREE_OPERAND (node, 0);
11266 COMPLETE_CHECK_OP_0 (node);
11267 if (flag_emit_xref)
11269 TREE_TYPE (node) = boolean_type_node;
11272 return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
11274 case UNARY_PLUS_EXPR:
11276 case TRUTH_NOT_EXPR:
11278 case PREDECREMENT_EXPR:
11279 case PREINCREMENT_EXPR:
11280 case POSTDECREMENT_EXPR:
11281 case POSTINCREMENT_EXPR:
11283 /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
11284 how to handle those cases. */
11285 wfl_op1 = TREE_OPERAND (node, 0);
11286 CAN_COMPLETE_NORMALLY (node) = 1;
11287 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
11288 if (TREE_OPERAND (node, 0) == error_mark_node)
11289 return error_mark_node;
11290 node = patch_unaryop (node, wfl_op1);
11291 CAN_COMPLETE_NORMALLY (node) = 1;
11295 /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
11296 how to handle those cases. */
11297 wfl_op1 = TREE_OPERAND (node, 0);
11298 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
11299 if (TREE_OPERAND (node, 0) == error_mark_node)
11300 return error_mark_node;
11301 if (!flag_emit_class_files && !flag_emit_xref)
11302 TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
11303 /* The same applies to wfl_op2 */
11304 wfl_op2 = TREE_OPERAND (node, 1);
11305 TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
11306 if (TREE_OPERAND (node, 1) == error_mark_node)
11307 return error_mark_node;
11308 if (!flag_emit_class_files && !flag_emit_xref)
11309 TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
11310 return patch_array_ref (node);
11315 case COMPONENT_REF:
11316 /* The first step in the re-write of qualified name handling. FIXME.
11317 So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
11318 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11319 if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
11321 tree name = TREE_OPERAND (node, 1);
11322 tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
11323 if (field == NULL_TREE)
11325 error ("missing static field `%s'", IDENTIFIER_POINTER (name));
11326 return error_mark_node;
11328 if (! FIELD_STATIC (field))
11330 error ("not a static field `%s'", IDENTIFIER_POINTER (name));
11331 return error_mark_node;
11336 fatal ("unimplemented java_complete_tree for COMPONENT_REF");
11340 /* Can't use THIS in a static environment */
11343 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11344 parse_error_context (wfl_operator,
11345 "Keyword `this' used outside allowed context");
11346 TREE_TYPE (node) = error_mark_node;
11347 return error_mark_node;
11349 if (ctxp->explicit_constructor_p)
11351 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11352 parse_error_context
11353 (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
11354 TREE_TYPE (node) = error_mark_node;
11355 return error_mark_node;
11357 return current_this;
11359 case CLASS_LITERAL:
11360 CAN_COMPLETE_NORMALLY (node) = 1;
11361 node = patch_incomplete_class_ref (node);
11362 if (node == error_mark_node)
11363 return error_mark_node;
11366 case INSTANCE_INITIALIZERS_EXPR:
11367 in_instance_initializer++;
11368 node = java_complete_tree (TREE_OPERAND (node, 0));
11369 in_instance_initializer--;
11370 if (node != error_mark_node)
11371 TREE_TYPE (node) = void_type_node;
11373 return error_mark_node;
11377 CAN_COMPLETE_NORMALLY (node) = 1;
11378 /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
11379 and it's time to turn it into the appropriate String object */
11380 if ((nn = patch_string (node)))
11383 fatal ("No case for tree code `%s' - java_complete_tree\n",
11384 tree_code_name [TREE_CODE (node)]);
11389 /* Complete function call's argument. Return a non zero value is an
11390 error was found. */
11393 complete_function_arguments (node)
11399 ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
11400 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11402 tree wfl = TREE_VALUE (cn), parm, temp;
11403 parm = java_complete_tree (wfl);
11405 if (parm == error_mark_node)
11410 /* If have a string literal that we haven't transformed yet or a
11411 crafted string buffer, as a result of use of the the String
11412 `+' operator. Build `parm.toString()' and expand it. */
11413 if ((temp = patch_string (parm)))
11415 /* Inline PRIMTYPE.TYPE read access */
11416 parm = maybe_build_primttype_type_ref (parm, wfl);
11418 TREE_VALUE (cn) = parm;
11420 ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
11424 /* Sometimes (for loops and variable initialized during their
11425 declaration), we want to wrap a statement around a WFL and turn it
11429 build_debugable_stmt (location, stmt)
11433 if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
11435 stmt = build_expr_wfl (stmt, input_filename, 0, 0);
11436 EXPR_WFL_LINECOL (stmt) = location;
11438 JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
11443 build_expr_block (body, decls)
11446 tree node = make_node (BLOCK);
11447 BLOCK_EXPR_DECLS (node) = decls;
11448 BLOCK_EXPR_BODY (node) = body;
11450 TREE_TYPE (node) = TREE_TYPE (body);
11451 TREE_SIDE_EFFECTS (node) = 1;
11455 /* Create a new function block and link it approriately to current
11456 function block chain */
11461 return (enter_a_block (build_expr_block (NULL_TREE, NULL_TREE)));
11464 /* Link block B supercontext to the previous block. The current
11465 function DECL is used as supercontext when enter_a_block is called
11466 for the first time for a given function. The current function body
11467 (DECL_FUNCTION_BODY) is set to be block B. */
11473 tree fndecl = current_function_decl;
11476 BLOCK_SUPERCONTEXT (b) = current_static_block;
11477 current_static_block = b;
11480 else if (!DECL_FUNCTION_BODY (fndecl))
11482 BLOCK_SUPERCONTEXT (b) = fndecl;
11483 DECL_FUNCTION_BODY (fndecl) = b;
11487 BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
11488 DECL_FUNCTION_BODY (fndecl) = b;
11493 /* Exit a block by changing the current function body
11494 (DECL_FUNCTION_BODY) to the current block super context, only if
11495 the block being exited isn't the method's top level one. */
11501 if (current_function_decl)
11503 b = DECL_FUNCTION_BODY (current_function_decl);
11504 if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
11505 DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
11509 b = current_static_block;
11511 if (BLOCK_SUPERCONTEXT (b))
11512 current_static_block = BLOCK_SUPERCONTEXT (b);
11517 /* Lookup for NAME in the nested function's blocks, all the way up to
11518 the current toplevel one. It complies with Java's local variable
11522 lookup_name_in_blocks (name)
11525 tree b = GET_CURRENT_BLOCK (current_function_decl);
11527 while (b != current_function_decl)
11531 /* Paranoid sanity check. To be removed */
11532 if (TREE_CODE (b) != BLOCK)
11533 fatal ("non block expr function body - lookup_name_in_blocks");
11535 for (current = BLOCK_EXPR_DECLS (b); current;
11536 current = TREE_CHAIN (current))
11537 if (DECL_NAME (current) == name)
11539 b = BLOCK_SUPERCONTEXT (b);
11545 maybe_absorb_scoping_blocks ()
11547 while (BLOCK_EXPR_ORIGIN (GET_CURRENT_BLOCK (current_function_decl)))
11549 tree b = exit_block ();
11550 java_method_add_stmt (current_function_decl, b);
11551 SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
11556 /* This section of the source is reserved to build_* functions that
11557 are building incomplete tree nodes and the patch_* functions that
11558 are completing them. */
11560 /* Wrap a non WFL node around a WFL. */
11562 build_wfl_wrap (node, location)
11566 tree wfl, node_to_insert = node;
11568 /* We want to process THIS . xxx symbolicaly, to keep it consistent
11569 with the way we're processing SUPER. A THIS from a primary as a
11570 different form than a SUPER. Turn THIS into something symbolic */
11571 if (TREE_CODE (node) == THIS_EXPR)
11572 node_to_insert = wfl = build_wfl_node (this_identifier_node);
11574 wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
11576 EXPR_WFL_LINECOL (wfl) = location;
11577 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
11582 /* Build a super() constructor invocation. Returns empty_stmt_node if
11583 we're currently dealing with the class java.lang.Object. */
11586 build_super_invocation (mdecl)
11589 if (DECL_CONTEXT (mdecl) == object_type_node)
11590 return empty_stmt_node;
11593 tree super_wfl = build_wfl_node (super_identifier_node);
11594 tree a = NULL_TREE, t;
11595 /* If we're dealing with an anonymous class, pass the arguments
11596 of the crafted constructor along. */
11597 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
11599 SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
11600 for (; t != end_params_node; t = TREE_CHAIN (t))
11601 a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
11603 return build_method_invocation (super_wfl, a);
11607 /* Build a SUPER/THIS qualified method invocation. */
11610 build_this_super_qualified_invocation (use_this, name, args, lloc, rloc)
11617 build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
11618 EXPR_WFL_LINECOL (wfl) = lloc;
11619 invok = build_method_invocation (name, args);
11620 return make_qualified_primary (wfl, invok, rloc);
11623 /* Build an incomplete CALL_EXPR node. */
11626 build_method_invocation (name, args)
11630 tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
11631 TREE_SIDE_EFFECTS (call) = 1;
11632 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
11636 /* Build an incomplete new xxx(...) node. */
11639 build_new_invocation (name, args)
11642 tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
11643 TREE_SIDE_EFFECTS (call) = 1;
11644 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
11648 /* Build an incomplete assignment expression. */
11651 build_assignment (op, op_location, lhs, rhs)
11652 int op, op_location;
11656 /* Build the corresponding binop if we deal with a Compound
11657 Assignment operator. Mark the binop sub-tree as part of a
11658 Compound Assignment expression */
11659 if (op != ASSIGN_TK)
11661 rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
11662 COMPOUND_ASSIGN_P (rhs) = 1;
11664 assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
11665 TREE_SIDE_EFFECTS (assignment) = 1;
11666 EXPR_WFL_LINECOL (assignment) = op_location;
11670 /* Print an INTEGER_CST node in a static buffer, and return the buffer. */
11673 print_int_node (node)
11676 static char buffer [80];
11677 if (TREE_CONSTANT_OVERFLOW (node))
11678 sprintf (buffer, "<overflow>");
11680 if (TREE_INT_CST_HIGH (node) == 0)
11681 sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
11682 TREE_INT_CST_LOW (node));
11683 else if (TREE_INT_CST_HIGH (node) == -1
11684 && TREE_INT_CST_LOW (node) != 0)
11687 sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
11688 -TREE_INT_CST_LOW (node));
11691 sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
11692 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
11697 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
11701 check_final_assignment (lvalue, wfl)
11704 if (TREE_CODE (lvalue) == COMPOUND_EXPR
11705 && JDECL_P (TREE_OPERAND (lvalue, 1)))
11706 lvalue = TREE_OPERAND (lvalue, 1);
11708 /* When generating class files, references to the `length' field
11709 look a bit different. */
11710 if ((flag_emit_class_files
11711 && TREE_CODE (lvalue) == COMPONENT_REF
11712 && TYPE_ARRAY_P (TREE_TYPE (TREE_OPERAND (lvalue, 0)))
11713 && FIELD_FINAL (TREE_OPERAND (lvalue, 1)))
11714 || (TREE_CODE (lvalue) == FIELD_DECL
11715 && FIELD_FINAL (lvalue)
11716 && !DECL_CLINIT_P (current_function_decl)
11717 && !DECL_FINIT_P (current_function_decl)))
11719 parse_error_context
11720 (wfl, "Can't assign a value to the final variable `%s'",
11721 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
11727 /* Inline references to java.lang.PRIMTYPE.TYPE when accessed in
11728 read. This is needed to avoid circularities in the implementation
11729 of these fields in libjava. */
11732 maybe_build_primttype_type_ref (rhs, wfl)
11735 tree to_return = NULL_TREE;
11736 tree rhs_type = TREE_TYPE (rhs);
11737 if (TREE_CODE (rhs) == COMPOUND_EXPR)
11739 tree n = TREE_OPERAND (rhs, 1);
11740 if (TREE_CODE (n) == VAR_DECL
11741 && DECL_NAME (n) == TYPE_identifier_node
11742 && rhs_type == class_ptr_type
11743 && TREE_CODE (EXPR_WFL_NODE (wfl)) == IDENTIFIER_NODE)
11745 const char *self_name = IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl));
11746 if (!strncmp (self_name, "java.lang.", 10))
11747 to_return = build_primtype_type_ref (self_name);
11750 return (to_return ? to_return : rhs );
11753 /* 15.25 Assignment operators. */
11756 patch_assignment (node, wfl_op1, wfl_op2)
11761 tree rhs = TREE_OPERAND (node, 1);
11762 tree lvalue = TREE_OPERAND (node, 0), llvalue;
11763 tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
11764 int error_found = 0;
11765 int lvalue_from_array = 0;
11767 /* Can't assign to a (blank) final. */
11768 if (check_final_assignment (lvalue, wfl_op1))
11771 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11773 /* Lhs can be a named variable */
11774 if (JDECL_P (lvalue))
11776 lhs_type = TREE_TYPE (lvalue);
11778 /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME +
11779 comment on reason why */
11780 else if (TREE_CODE (wfl_op1) == ARRAY_REF)
11782 lhs_type = TREE_TYPE (lvalue);
11783 lvalue_from_array = 1;
11785 /* Or a field access */
11786 else if (TREE_CODE (lvalue) == COMPONENT_REF)
11787 lhs_type = TREE_TYPE (lvalue);
11788 /* Or a function return slot */
11789 else if (TREE_CODE (lvalue) == RESULT_DECL)
11790 lhs_type = TREE_TYPE (lvalue);
11791 /* Otherwise, we might want to try to write into an optimized static
11792 final, this is an of a different nature, reported further on. */
11793 else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
11794 && resolve_expression_name (wfl_op1, &llvalue))
11796 if (!error_found && check_final_assignment (llvalue, wfl_op1))
11798 /* What we should do instead is resetting the all the flags
11799 previously set, exchange lvalue for llvalue and continue. */
11801 return error_mark_node;
11804 lhs_type = TREE_TYPE (lvalue);
11808 parse_error_context (wfl_op1, "Invalid left hand side of assignment");
11812 rhs_type = TREE_TYPE (rhs);
11813 /* 5.1 Try the assignment conversion for builtin type. */
11814 new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
11816 /* 5.2 If it failed, try a reference conversion */
11817 if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
11818 lhs_type = promote_type (rhs_type);
11820 /* 15.25.2 If we have a compound assignment, convert RHS into the
11822 else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
11823 new_rhs = convert (lhs_type, rhs);
11825 /* Explicit cast required. This is an error */
11828 char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
11829 char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
11831 char operation [32]; /* Max size known */
11833 /* If the assignment is part of a declaration, we use the WFL of
11834 the declared variable to point out the error and call it a
11835 declaration problem. If the assignment is a genuine =
11836 operator, we call is a operator `=' problem, otherwise we
11837 call it an assignment problem. In both of these last cases,
11838 we use the WFL of the operator to indicate the error. */
11840 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
11843 strcpy (operation, "declaration");
11847 wfl = wfl_operator;
11848 if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
11849 strcpy (operation, "assignment");
11850 else if (TREE_CODE (TREE_OPERAND (node, 0)) == RESULT_DECL)
11851 strcpy (operation, "`return'");
11853 strcpy (operation, "`='");
11856 if (!valid_cast_to_p (rhs_type, lhs_type))
11857 parse_error_context
11858 (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
11859 operation, t1, t2);
11861 parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
11862 operation, t1, t2);
11863 free (t1); free (t2);
11867 /* Inline read access to java.lang.PRIMTYPE.TYPE */
11869 new_rhs = maybe_build_primttype_type_ref (new_rhs, wfl_op2);
11872 return error_mark_node;
11874 /* 10.10: Array Store Exception runtime check */
11875 if (!flag_emit_class_files
11877 && lvalue_from_array
11878 && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
11881 tree base = lvalue;
11883 /* We need to retrieve the right argument for _Jv_CheckArrayStore */
11884 if (TREE_CODE (lvalue) == COMPOUND_EXPR)
11885 base = TREE_OPERAND (lvalue, 0);
11888 if (flag_bounds_check)
11889 base = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (base, 0), 1), 0);
11891 base = TREE_OPERAND (TREE_OPERAND (base, 0), 0);
11894 /* Build the invocation of _Jv_CheckArrayStore */
11895 new_rhs = save_expr (new_rhs);
11896 check = build (CALL_EXPR, void_type_node,
11897 build_address_of (soft_checkarraystore_node),
11898 tree_cons (NULL_TREE, base,
11899 build_tree_list (NULL_TREE, new_rhs)),
11901 TREE_SIDE_EFFECTS (check) = 1;
11903 /* We have to decide on an insertion point */
11904 if (TREE_CODE (lvalue) == COMPOUND_EXPR)
11907 if (flag_bounds_check)
11909 t = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0);
11910 TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0) =
11911 build (COMPOUND_EXPR, void_type_node, t, check);
11914 TREE_OPERAND (lvalue, 1) = build (COMPOUND_EXPR, lhs_type,
11915 check, TREE_OPERAND (lvalue, 1));
11919 /* Make sure the bound check will happen before the store check */
11920 if (flag_bounds_check)
11921 TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0) =
11922 build (COMPOUND_EXPR, void_type_node,
11923 TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0), check);
11925 lvalue = build (COMPOUND_EXPR, lhs_type, check, lvalue);
11929 TREE_OPERAND (node, 0) = lvalue;
11930 TREE_OPERAND (node, 1) = new_rhs;
11931 TREE_TYPE (node) = lhs_type;
11935 /* Check that type SOURCE can be cast into type DEST. If the cast
11936 can't occur at all, return 0 otherwise 1. This function is used to
11937 produce accurate error messages on the reasons why an assignment
11941 try_reference_assignconv (lhs_type, rhs)
11942 tree lhs_type, rhs;
11944 tree new_rhs = NULL_TREE;
11945 tree rhs_type = TREE_TYPE (rhs);
11947 if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
11949 /* `null' may be assigned to any reference type */
11950 if (rhs == null_pointer_node)
11951 new_rhs = null_pointer_node;
11952 /* Try the reference assignment conversion */
11953 else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
11955 /* This is a magic assignment that we process differently */
11956 else if (rhs == soft_exceptioninfo_call_node)
11962 /* Check that RHS can be converted into LHS_TYPE by the assignment
11963 conversion (5.2), for the cases of RHS being a builtin type. Return
11964 NULL_TREE if the conversion fails or if because RHS isn't of a
11965 builtin type. Return a converted RHS if the conversion is possible. */
11968 try_builtin_assignconv (wfl_op1, lhs_type, rhs)
11969 tree wfl_op1, lhs_type, rhs;
11971 tree new_rhs = NULL_TREE;
11972 tree rhs_type = TREE_TYPE (rhs);
11974 /* Zero accepted everywhere */
11975 if (TREE_CODE (rhs) == INTEGER_CST
11976 && TREE_INT_CST_HIGH (rhs) == 0 && TREE_INT_CST_LOW (rhs) == 0
11977 && JPRIMITIVE_TYPE_P (rhs_type))
11978 new_rhs = convert (lhs_type, rhs);
11980 /* 5.1.1 Try Identity Conversion,
11981 5.1.2 Try Widening Primitive Conversion */
11982 else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
11983 new_rhs = convert (lhs_type, rhs);
11985 /* Try a narrowing primitive conversion (5.1.3):
11986 - expression is a constant expression of type int AND
11987 - variable is byte, short or char AND
11988 - The value of the expression is representable in the type of the
11990 else if (rhs_type == int_type_node && TREE_CONSTANT (rhs)
11991 && (lhs_type == byte_type_node || lhs_type == char_type_node
11992 || lhs_type == short_type_node))
11994 if (int_fits_type_p (rhs, lhs_type))
11995 new_rhs = convert (lhs_type, rhs);
11996 else if (wfl_op1) /* Might be called with a NULL */
11997 parse_warning_context
11998 (wfl_op1, "Constant expression `%s' to wide for narrowing primitive conversion to `%s'",
11999 print_int_node (rhs), lang_printable_name (lhs_type, 0));
12000 /* Reported a warning that will turn into an error further
12001 down, so we don't return */
12007 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12008 conversion (5.1.1) or widening primitve conversion (5.1.2). Return
12009 0 is the conversion test fails. This implements parts the method
12010 invocation convertion (5.3). */
12013 valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)
12014 tree lhs_type, rhs_type;
12016 /* 5.1.1: This is the identity conversion part. */
12017 if (lhs_type == rhs_type)
12020 /* Reject non primitive types */
12021 if (!JPRIMITIVE_TYPE_P (lhs_type) || !JPRIMITIVE_TYPE_P (rhs_type))
12024 /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12025 than a char can't be converted into a char. Short can't too, but
12026 the < test below takes care of that */
12027 if (lhs_type == char_type_node && rhs_type == byte_type_node)
12030 /* Accept all promoted type here. Note, we can't use <= in the test
12031 below, because we still need to bounce out assignments of short
12032 to char and the likes */
12033 if (lhs_type == int_type_node
12034 && (rhs_type == promoted_byte_type_node
12035 || rhs_type == promoted_short_type_node
12036 || rhs_type == promoted_char_type_node
12037 || rhs_type == promoted_boolean_type_node))
12040 /* From here, an integral is widened if its precision is smaller
12041 than the precision of the LHS or if the LHS is a floating point
12042 type, or the RHS is a float and the RHS a double. */
12043 if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12044 && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12045 || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12046 || (rhs_type == float_type_node && lhs_type == double_type_node))
12052 /* Check that something of SOURCE type can be assigned or cast to
12053 something of DEST type at runtime. Return 1 if the operation is
12054 valid, 0 otherwise. If CAST is set to 1, we're treating the case
12055 were SOURCE is cast into DEST, which borrows a lot of the
12056 assignment check. */
12059 valid_ref_assignconv_cast_p (source, dest, cast)
12064 /* SOURCE or DEST might be null if not from a declared entity. */
12065 if (!source || !dest)
12067 if (JNULLP_TYPE_P (source))
12069 if (TREE_CODE (source) == POINTER_TYPE)
12070 source = TREE_TYPE (source);
12071 if (TREE_CODE (dest) == POINTER_TYPE)
12072 dest = TREE_TYPE (dest);
12073 /* Case where SOURCE is a class type */
12074 if (TYPE_CLASS_P (source))
12076 if (TYPE_CLASS_P (dest))
12077 return (source == dest
12078 || inherits_from_p (source, dest)
12079 || enclosing_context_p (source, dest)
12080 || (cast && inherits_from_p (dest, source)));
12081 if (TYPE_INTERFACE_P (dest))
12083 /* If doing a cast and SOURCE is final, the operation is
12084 always correct a compile time (because even if SOURCE
12085 does not implement DEST, a subclass of SOURCE might). */
12086 if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12088 /* Otherwise, SOURCE must implement DEST */
12089 return interface_of_p (dest, source);
12091 /* DEST is an array, cast permited if SOURCE is of Object type */
12092 return (cast && source == object_type_node ? 1 : 0);
12094 if (TYPE_INTERFACE_P (source))
12096 if (TYPE_CLASS_P (dest))
12098 /* If not casting, DEST must be the Object type */
12100 return dest == object_type_node;
12101 /* We're doing a cast. The cast is always valid is class
12102 DEST is not final, otherwise, DEST must implement SOURCE */
12103 else if (!CLASS_FINAL (TYPE_NAME (dest)))
12106 return interface_of_p (source, dest);
12108 if (TYPE_INTERFACE_P (dest))
12110 /* If doing a cast, then if SOURCE and DEST contain method
12111 with the same signature but different return type, then
12112 this is a (compile time) error */
12115 tree method_source, method_dest;
12119 for (method_source = TYPE_METHODS (source); method_source;
12120 method_source = TREE_CHAIN (method_source))
12123 build_java_argument_signature (TREE_TYPE (method_source));
12124 source_type = TREE_TYPE (TREE_TYPE (method_source));
12125 source_name = DECL_NAME (method_source);
12126 for (method_dest = TYPE_METHODS (dest);
12127 method_dest; method_dest = TREE_CHAIN (method_dest))
12129 build_java_argument_signature (TREE_TYPE (method_dest))
12130 && source_name == DECL_NAME (method_dest)
12131 && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
12137 return source == dest || interface_of_p (dest, source);
12141 (DECL_NAME (TYPE_NAME (source)) == java_lang_cloneable) : 0);
12143 if (TYPE_ARRAY_P (source))
12145 if (TYPE_CLASS_P (dest))
12146 return dest == object_type_node;
12147 /* Can't cast an array to an interface unless the interface is
12148 java.lang.Cloneable */
12149 if (TYPE_INTERFACE_P (dest))
12150 return (DECL_NAME (TYPE_NAME (dest)) == java_lang_cloneable ? 1 : 0);
12153 tree source_element_type = TYPE_ARRAY_ELEMENT (source);
12154 tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
12156 /* In case of severe errors, they turn out null */
12157 if (!dest_element_type || !source_element_type)
12159 if (source_element_type == dest_element_type)
12161 return valid_ref_assignconv_cast_p (source_element_type,
12162 dest_element_type, cast);
12170 valid_cast_to_p (source, dest)
12174 if (TREE_CODE (source) == POINTER_TYPE)
12175 source = TREE_TYPE (source);
12176 if (TREE_CODE (dest) == POINTER_TYPE)
12177 dest = TREE_TYPE (dest);
12179 if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
12180 return valid_ref_assignconv_cast_p (source, dest, 1);
12182 else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
12188 /* Method invocation conversion test. Return 1 if type SOURCE can be
12189 converted to type DEST through the methond invocation conversion
12193 do_unary_numeric_promotion (arg)
12196 tree type = TREE_TYPE (arg);
12197 if (TREE_CODE (type) == INTEGER_TYPE ? TYPE_PRECISION (type) < 32
12198 : TREE_CODE (type) == CHAR_TYPE)
12199 arg = convert (int_type_node, arg);
12203 /* Return a non zero value if SOURCE can be converted into DEST using
12204 the method invocation conversion rule (5.3). */
12206 valid_method_invocation_conversion_p (dest, source)
12209 return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
12210 && valid_builtin_assignconv_identity_widening_p (dest, source))
12211 || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
12212 && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
12213 && valid_ref_assignconv_cast_p (source, dest, 0)));
12216 /* Build an incomplete binop expression. */
12219 build_binop (op, op_location, op1, op2)
12224 tree binop = build (op, NULL_TREE, op1, op2);
12225 TREE_SIDE_EFFECTS (binop) = 1;
12226 /* Store the location of the operator, for better error report. The
12227 string of the operator will be rebuild based on the OP value. */
12228 EXPR_WFL_LINECOL (binop) = op_location;
12232 /* Build the string of the operator retained by NODE. If NODE is part
12233 of a compound expression, add an '=' at the end of the string. This
12234 function is called when an error needs to be reported on an
12235 operator. The string is returned as a pointer to a static character
12239 operator_string (node)
12242 #define BUILD_OPERATOR_STRING(S) \
12244 sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
12248 static char buffer [10];
12249 switch (TREE_CODE (node))
12251 case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
12252 case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
12253 case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
12254 case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
12255 case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
12256 case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
12257 case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
12258 case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
12259 case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
12260 case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
12261 case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
12262 case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
12263 case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
12264 case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
12265 case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
12266 case GT_EXPR: BUILD_OPERATOR_STRING (">");
12267 case GE_EXPR: BUILD_OPERATOR_STRING (">=");
12268 case LT_EXPR: BUILD_OPERATOR_STRING ("<");
12269 case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
12270 case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
12271 case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
12272 case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
12273 case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
12274 case PREINCREMENT_EXPR: /* Fall through */
12275 case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
12276 case PREDECREMENT_EXPR: /* Fall through */
12277 case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
12279 fatal ("unregistered operator %s - operator_string",
12280 tree_code_name [TREE_CODE (node)]);
12283 #undef BUILD_OPERATOR_STRING
12286 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
12289 java_decl_equiv (var_acc1, var_acc2)
12290 tree var_acc1, var_acc2;
12292 if (JDECL_P (var_acc1))
12293 return (var_acc1 == var_acc2);
12295 return (TREE_CODE (var_acc1) == COMPONENT_REF
12296 && TREE_CODE (var_acc2) == COMPONENT_REF
12297 && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
12298 == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
12299 && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
12302 /* Return a non zero value if CODE is one of the operators that can be
12303 used in conjunction with the `=' operator in a compound assignment. */
12306 binop_compound_p (code)
12307 enum tree_code code;
12310 for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
12311 if (binop_lookup [i] == code)
12314 return i < BINOP_COMPOUND_CANDIDATES;
12317 /* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
12323 tree c, b, ns, decl;
12325 if (TREE_CODE (t) != MODIFY_EXPR)
12328 c = TREE_OPERAND (t, 1);
12329 if (! (c && TREE_CODE (c) == COMPOUND_EXPR
12330 && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
12331 && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
12334 /* Now the left branch of the binary operator. */
12335 b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
12336 if (! (b && TREE_CODE (b) == NOP_EXPR
12337 && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
12340 ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
12341 if (! (ns && TREE_CODE (ns) == NOP_EXPR
12342 && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
12345 decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
12346 if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
12347 /* It's got to be the an equivalent decl */
12348 && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
12350 /* Shorten the NOP_EXPR/SAVE_EXPR path. */
12351 TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
12352 /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
12353 TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
12354 /* Change the right part of the BINOP_EXPR */
12355 TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
12361 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
12362 errors but we modify NODE so that it contains the type computed
12363 according to the expression, when it's fixed. Otherwise, we write
12364 error_mark_node as the type. It allows us to further the analysis
12365 of remaining nodes and detects more errors in certain cases. */
12368 patch_binop (node, wfl_op1, wfl_op2)
12373 tree op1 = TREE_OPERAND (node, 0);
12374 tree op2 = TREE_OPERAND (node, 1);
12375 tree op1_type = TREE_TYPE (op1);
12376 tree op2_type = TREE_TYPE (op2);
12377 tree prom_type = NULL_TREE, cn;
12378 int code = TREE_CODE (node);
12380 /* If 1, tell the routine that we have to return error_mark_node
12381 after checking for the initialization of the RHS */
12382 int error_found = 0;
12384 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12388 /* 15.16 Multiplicative operators */
12389 case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
12390 case RDIV_EXPR: /* 15.16.2 Division Operator / */
12391 case TRUNC_DIV_EXPR: /* 15.16.2 Integral type Division Operator / */
12392 case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
12393 if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
12395 if (!JPRIMITIVE_TYPE_P (op1_type))
12396 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12397 if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
12398 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12399 TREE_TYPE (node) = error_mark_node;
12403 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12404 /* Change the division operator if necessary */
12405 if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
12406 TREE_SET_CODE (node, TRUNC_DIV_EXPR);
12408 if (TREE_CODE (prom_type) == INTEGER_TYPE
12409 && flag_use_divide_subroutine
12410 && ! flag_emit_class_files
12411 && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
12412 return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
12414 /* This one is more complicated. FLOATs are processed by a
12415 function call to soft_fmod. Duplicate the value of the
12416 COMPOUND_ASSIGN_P flag. */
12417 if (code == TRUNC_MOD_EXPR)
12419 tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
12420 COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
12421 TREE_SIDE_EFFECTS (mod)
12422 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
12427 /* 15.17 Additive Operators */
12428 case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
12430 /* Operation is valid if either one argument is a string
12431 constant, a String object or a StringBuffer crafted for the
12432 purpose of the a previous usage of the String concatenation
12435 if (TREE_CODE (op1) == STRING_CST
12436 || TREE_CODE (op2) == STRING_CST
12437 || JSTRING_TYPE_P (op1_type)
12438 || JSTRING_TYPE_P (op2_type)
12439 || IS_CRAFTED_STRING_BUFFER_P (op1)
12440 || IS_CRAFTED_STRING_BUFFER_P (op2))
12441 return build_string_concatenation (op1, op2);
12443 case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
12445 if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
12447 if (!JPRIMITIVE_TYPE_P (op1_type))
12448 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12449 if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
12450 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12451 TREE_TYPE (node) = error_mark_node;
12455 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12458 /* 15.18 Shift Operators */
12462 if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
12464 if (!JINTEGRAL_TYPE_P (op1_type))
12465 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
12468 if (JPRIMITIVE_TYPE_P (op2_type))
12469 parse_error_context (wfl_operator,
12470 "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
12471 operator_string (node),
12472 lang_printable_name (op2_type, 0));
12474 parse_error_context (wfl_operator,
12475 "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
12476 operator_string (node),
12477 lang_printable_name (op2_type, 0));
12479 TREE_TYPE (node) = error_mark_node;
12484 /* Unary numeric promotion (5.6.1) is performed on each operand
12486 op1 = do_unary_numeric_promotion (op1);
12487 op2 = do_unary_numeric_promotion (op2);
12489 /* The type of the shift expression is the type of the promoted
12490 type of the left-hand operand */
12491 prom_type = TREE_TYPE (op1);
12493 /* Shift int only up to 0x1f and long up to 0x3f */
12494 if (prom_type == int_type_node)
12495 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
12496 build_int_2 (0x1f, 0)));
12498 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
12499 build_int_2 (0x3f, 0)));
12501 /* The >>> operator is a >> operating on unsigned quantities */
12502 if (code == URSHIFT_EXPR && ! flag_emit_class_files)
12505 tree utype = unsigned_type (prom_type);
12506 op1 = convert (utype, op1);
12507 TREE_SET_CODE (node, RSHIFT_EXPR);
12508 TREE_OPERAND (node, 0) = op1;
12509 TREE_OPERAND (node, 1) = op2;
12510 TREE_TYPE (node) = utype;
12511 to_return = convert (prom_type, node);
12512 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
12513 COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
12514 TREE_SIDE_EFFECTS (to_return)
12515 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
12520 /* 15.19.1 Type Comparison Operator instaceof */
12521 case INSTANCEOF_EXPR:
12523 TREE_TYPE (node) = boolean_type_node;
12525 if (!(op2_type = resolve_type_during_patch (op2)))
12526 return error_mark_node;
12528 /* The first operand must be a reference type or the null type */
12529 if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
12530 error_found = 1; /* Error reported further below */
12532 /* The second operand must be a reference type */
12533 if (!JREFERENCE_TYPE_P (op2_type))
12535 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
12536 parse_error_context
12537 (wfl_operator, "Invalid argument `%s' for `instanceof'",
12538 lang_printable_name (op2_type, 0));
12542 if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
12544 /* If the first operand is null, the result is always false */
12545 if (op1 == null_pointer_node)
12546 return boolean_false_node;
12547 else if (flag_emit_class_files)
12549 TREE_OPERAND (node, 1) = op2_type;
12550 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
12553 /* Otherwise we have to invoke instance of to figure it out */
12555 return build_instanceof (op1, op2_type);
12557 /* There is no way the expression operand can be an instance of
12558 the type operand. This is a compile time error. */
12561 char *t1 = xstrdup (lang_printable_name (op1_type, 0));
12562 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
12563 parse_error_context
12564 (wfl_operator, "Impossible for `%s' to be instance of `%s'",
12565 t1, lang_printable_name (op2_type, 0));
12572 /* 15.21 Bitwise and Logical Operators */
12576 if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
12577 /* Binary numeric promotion is performed on both operand and the
12578 expression retain that type */
12579 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12581 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
12582 && TREE_CODE (op1_type) == BOOLEAN_TYPE)
12583 /* The type of the bitwise operator expression is BOOLEAN */
12584 prom_type = boolean_type_node;
12587 if (!JINTEGRAL_TYPE_P (op1_type))
12588 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
12589 if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
12590 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
12591 TREE_TYPE (node) = error_mark_node;
12593 /* Insert a break here if adding thing before the switch's
12594 break for this case */
12598 /* 15.22 Conditional-And Operator */
12599 case TRUTH_ANDIF_EXPR:
12600 /* 15.23 Conditional-Or Operator */
12601 case TRUTH_ORIF_EXPR:
12602 /* Operands must be of BOOLEAN type */
12603 if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
12604 TREE_CODE (op2_type) != BOOLEAN_TYPE)
12606 if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
12607 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
12608 if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
12609 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
12610 TREE_TYPE (node) = boolean_type_node;
12614 /* The type of the conditional operators is BOOLEAN */
12615 prom_type = boolean_type_node;
12618 /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
12623 /* The type of each of the operands must be a primitive numeric
12625 if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
12627 if (!JNUMERIC_TYPE_P (op1_type))
12628 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12629 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
12630 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12631 TREE_TYPE (node) = boolean_type_node;
12635 /* Binary numeric promotion is performed on the operands */
12636 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12637 /* The type of the relation expression is always BOOLEAN */
12638 prom_type = boolean_type_node;
12641 /* 15.20 Equality Operator */
12644 /* It's time for us to patch the strings. */
12645 if ((cn = patch_string (op1)))
12648 op1_type = TREE_TYPE (op1);
12650 if ((cn = patch_string (op2)))
12653 op2_type = TREE_TYPE (op2);
12656 /* 15.20.1 Numerical Equality Operators == and != */
12657 /* Binary numeric promotion is performed on the operands */
12658 if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
12659 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12661 /* 15.20.2 Boolean Equality Operators == and != */
12662 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
12663 TREE_CODE (op2_type) == BOOLEAN_TYPE)
12664 ; /* Nothing to do here */
12666 /* 15.20.3 Reference Equality Operators == and != */
12667 /* Types have to be either references or the null type. If
12668 they're references, it must be possible to convert either
12669 type to the other by casting conversion. */
12670 else if (op1 == null_pointer_node || op2 == null_pointer_node
12671 || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
12672 && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
12673 || valid_ref_assignconv_cast_p (op2_type,
12675 ; /* Nothing to do here */
12677 /* Else we have an error figure what can't be converted into
12678 what and report the error */
12682 t1 = xstrdup (lang_printable_name (op1_type, 0));
12683 parse_error_context
12685 "Incompatible type for `%s'. Can't convert `%s' to `%s'",
12686 operator_string (node), t1,
12687 lang_printable_name (op2_type, 0));
12689 TREE_TYPE (node) = boolean_type_node;
12693 prom_type = boolean_type_node;
12698 return error_mark_node;
12700 TREE_OPERAND (node, 0) = op1;
12701 TREE_OPERAND (node, 1) = op2;
12702 TREE_TYPE (node) = prom_type;
12703 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
12705 if (flag_emit_xref)
12708 /* fold does not respect side-effect order as required for Java but not C.
12709 * Also, it sometimes create SAVE_EXPRs which are bad when emitting
12712 if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
12713 : ! TREE_SIDE_EFFECTS (node))
12714 node = fold (node);
12718 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
12719 zero value, the value of CSTE comes after the valude of STRING */
12722 do_merge_string_cste (cste, string, string_len, after)
12724 const char *string;
12725 int string_len, after;
12727 int len = TREE_STRING_LENGTH (cste) + string_len;
12728 const char *old = TREE_STRING_POINTER (cste);
12729 TREE_STRING_LENGTH (cste) = len;
12730 TREE_STRING_POINTER (cste) = obstack_alloc (expression_obstack, len+1);
12733 strcpy (TREE_STRING_POINTER (cste), string);
12734 strcat (TREE_STRING_POINTER (cste), old);
12738 strcpy (TREE_STRING_POINTER (cste), old);
12739 strcat (TREE_STRING_POINTER (cste), string);
12744 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
12745 new STRING_CST on success, NULL_TREE on failure */
12748 merge_string_cste (op1, op2, after)
12752 /* Handle two string constants right away */
12753 if (TREE_CODE (op2) == STRING_CST)
12754 return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
12755 TREE_STRING_LENGTH (op2), after);
12757 /* Reasonable integer constant can be treated right away */
12758 if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
12760 static const char *boolean_true = "true";
12761 static const char *boolean_false = "false";
12762 static const char *null_pointer = "null";
12764 const char *string;
12766 if (op2 == boolean_true_node)
12767 string = boolean_true;
12768 else if (op2 == boolean_false_node)
12769 string = boolean_false;
12770 else if (op2 == null_pointer_node)
12771 string = null_pointer;
12772 else if (TREE_TYPE (op2) == char_type_node)
12774 ch[0] = (char )TREE_INT_CST_LOW (op2);
12779 string = print_int_node (op2);
12781 return do_merge_string_cste (op1, string, strlen (string), after);
12786 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
12787 has to be a STRING_CST and the other part must be a STRING_CST or a
12788 INTEGRAL constant. Return a new STRING_CST if the operation
12789 succeed, NULL_TREE otherwise.
12791 If the case we want to optimize for space, we might want to return
12792 NULL_TREE for each invocation of this routine. FIXME */
12795 string_constant_concatenation (op1, op2)
12798 if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
12803 string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
12804 rest = (string == op1 ? op2 : op1);
12805 invert = (string == op1 ? 0 : 1 );
12807 /* Walk REST, only if it looks reasonable */
12808 if (TREE_CODE (rest) != STRING_CST
12809 && !IS_CRAFTED_STRING_BUFFER_P (rest)
12810 && !JSTRING_TYPE_P (TREE_TYPE (rest))
12811 && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
12813 rest = java_complete_tree (rest);
12814 if (rest == error_mark_node)
12815 return error_mark_node;
12816 rest = fold (rest);
12818 return merge_string_cste (string, rest, invert);
12823 /* Implement the `+' operator. Does static optimization if possible,
12824 otherwise create (if necessary) and append elements to a
12825 StringBuffer. The StringBuffer will be carried around until it is
12826 used for a function call or an assignment. Then toString() will be
12827 called on it to turn it into a String object. */
12830 build_string_concatenation (op1, op2)
12834 int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
12836 if (flag_emit_xref)
12837 return build (PLUS_EXPR, string_type_node, op1, op2);
12839 /* Try to do some static optimization */
12840 if ((result = string_constant_concatenation (op1, op2)))
12843 /* Discard empty strings on either side of the expression */
12844 if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
12849 else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
12852 /* If operands are string constant, turn then into object references */
12853 if (TREE_CODE (op1) == STRING_CST)
12854 op1 = patch_string_cst (op1);
12855 if (op2 && TREE_CODE (op2) == STRING_CST)
12856 op2 = patch_string_cst (op2);
12858 /* If either one of the constant is null and the other non null
12859 operand is a String object, return it. */
12860 if (JSTRING_TYPE_P (TREE_TYPE (op1)) && !op2)
12863 /* If OP1 isn't already a StringBuffer, create and
12864 initialize a new one */
12865 if (!IS_CRAFTED_STRING_BUFFER_P (op1))
12867 /* Two solutions here:
12868 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
12869 2) OP1 is something else, we call new StringBuffer().append(OP1). */
12870 if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
12871 op1 = BUILD_STRING_BUFFER (op1);
12874 tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
12875 op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
12881 /* OP1 is no longer the last node holding a crafted StringBuffer */
12882 IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
12883 /* Create a node for `{new...,xxx}.append (op2)' */
12885 op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
12888 /* Mark the last node holding a crafted StringBuffer */
12889 IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
12891 TREE_SIDE_EFFECTS (op1) = side_effects;
12895 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
12896 StringBuffer. If no string were found to be patched, return
12900 patch_string (node)
12903 if (node == error_mark_node)
12904 return error_mark_node;
12905 if (TREE_CODE (node) == STRING_CST)
12906 return patch_string_cst (node);
12907 else if (IS_CRAFTED_STRING_BUFFER_P (node))
12909 int saved = ctxp->explicit_constructor_p;
12910 tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
12912 /* Temporary disable forbid the use of `this'. */
12913 ctxp->explicit_constructor_p = 0;
12914 ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
12915 /* String concatenation arguments must be evaluated in order too. */
12916 ret = force_evaluation_order (ret);
12917 /* Restore it at its previous value */
12918 ctxp->explicit_constructor_p = saved;
12924 /* Build the internal representation of a string constant. */
12927 patch_string_cst (node)
12931 if (! flag_emit_class_files)
12933 push_obstacks (&permanent_obstack, &permanent_obstack);
12934 node = get_identifier (TREE_STRING_POINTER (node));
12935 location = alloc_name_constant (CONSTANT_String, node);
12936 node = build_ref_from_constant_pool (location);
12939 TREE_TYPE (node) = string_ptr_type_node;
12940 TREE_CONSTANT (node) = 1;
12944 /* Build an incomplete unary operator expression. */
12947 build_unaryop (op_token, op_location, op1)
12948 int op_token, op_location;
12955 case PLUS_TK: op = UNARY_PLUS_EXPR; break;
12956 case MINUS_TK: op = NEGATE_EXPR; break;
12957 case NEG_TK: op = TRUTH_NOT_EXPR; break;
12958 case NOT_TK: op = BIT_NOT_EXPR; break;
12959 default: fatal ("Unknown token `%d' for unary operator - build_unaryop",
12963 unaryop = build1 (op, NULL_TREE, op1);
12964 TREE_SIDE_EFFECTS (unaryop) = 1;
12965 /* Store the location of the operator, for better error report. The
12966 string of the operator will be rebuild based on the OP value. */
12967 EXPR_WFL_LINECOL (unaryop) = op_location;
12971 /* Special case for the ++/-- operators, since they require an extra
12972 argument to build, which is set to NULL and patched
12973 later. IS_POST_P is 1 if the operator, 0 otherwise. */
12976 build_incdec (op_token, op_location, op1, is_post_p)
12977 int op_token, op_location;
12981 static enum tree_code lookup [2][2] =
12983 { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
12984 { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
12986 tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
12987 NULL_TREE, op1, NULL_TREE);
12988 TREE_SIDE_EFFECTS (node) = 1;
12989 /* Store the location of the operator, for better error report. The
12990 string of the operator will be rebuild based on the OP value. */
12991 EXPR_WFL_LINECOL (node) = op_location;
12995 /* Build an incomplete cast operator, based on the use of the
12996 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
12997 set. java_complete_tree is trained to walk a CONVERT_EXPR even
12998 though its type is already set. */
13001 build_cast (location, type, exp)
13005 tree node = build1 (CONVERT_EXPR, type, exp);
13006 EXPR_WFL_LINECOL (node) = location;
13010 /* Build an incomplete class reference operator. */
13012 build_incomplete_class_ref (location, class_name)
13016 tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13017 EXPR_WFL_LINECOL (node) = location;
13021 /* Complete an incomplete class reference operator. */
13023 patch_incomplete_class_ref (node)
13026 tree type = TREE_OPERAND (node, 0);
13029 if (!(ref_type = resolve_type_during_patch (type)))
13030 return error_mark_node;
13032 if (!flag_emit_class_files || JPRIMITIVE_TYPE_P (ref_type))
13034 /* A class referenced by `foo.class' is initialized. */
13035 return build_class_init (ref_type, build_class_ref (ref_type));
13038 /* If we're emitting class files and we have to deal with non
13039 primitive types, we invoke (and consider generating) the
13040 synthetic static method `class$'. */
13041 if (!TYPE_DOT_CLASS (current_class))
13042 build_dot_class_method (current_class);
13044 build_dot_class_method_invocation (DECL_NAME (TYPE_NAME (ref_type)));
13045 return java_complete_tree (ref_type);
13048 /* 15.14 Unary operators. We return error_mark_node in case of error,
13049 but preserve the type of NODE if the type is fixed. */
13052 patch_unaryop (node, wfl_op)
13056 tree op = TREE_OPERAND (node, 0);
13057 tree op_type = TREE_TYPE (op);
13058 tree prom_type = NULL_TREE, value, decl;
13059 int outer_field_flag = 0;
13060 int code = TREE_CODE (node);
13061 int error_found = 0;
13063 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13067 /* 15.13.2 Postfix Increment Operator ++ */
13068 case POSTINCREMENT_EXPR:
13069 /* 15.13.3 Postfix Increment Operator -- */
13070 case POSTDECREMENT_EXPR:
13071 /* 15.14.1 Prefix Increment Operator ++ */
13072 case PREINCREMENT_EXPR:
13073 /* 15.14.2 Prefix Decrement Operator -- */
13074 case PREDECREMENT_EXPR:
13075 op = decl = strip_out_static_field_access_decl (op);
13076 outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
13077 /* We might be trying to change an outer field accessed using
13079 if (outer_field_flag)
13081 /* Retrieve the decl of the field we're trying to access. We
13082 do that by first retrieving the function we would call to
13083 access the field. It has been already verified that this
13084 field isn't final */
13085 if (flag_emit_class_files)
13086 decl = TREE_OPERAND (op, 0);
13088 decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
13089 decl = DECL_FUNCTION_ACCESS_DECL (decl);
13091 /* We really should have a JAVA_ARRAY_EXPR to avoid this */
13092 else if (!JDECL_P (decl)
13093 && TREE_CODE (decl) != COMPONENT_REF
13094 && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
13095 && TREE_CODE (decl) != INDIRECT_REF
13096 && !(TREE_CODE (decl) == COMPOUND_EXPR
13097 && TREE_OPERAND (decl, 1)
13098 && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
13101 /* Before screaming, check that we're not in fact trying to
13102 increment a optimized static final access, in which case
13103 we issue an different error message. */
13104 if (!(TREE_CODE (wfl_op) == EXPR_WITH_FILE_LOCATION
13105 && resolve_expression_name (wfl_op, &lvalue)
13106 && check_final_assignment (lvalue, wfl_op)))
13107 parse_error_context (wfl_operator, "Invalid argument to `%s'",
13108 operator_string (node));
13109 TREE_TYPE (node) = error_mark_node;
13113 if (check_final_assignment (op, wfl_op))
13116 /* From now on, we know that op if a variable and that it has a
13117 valid wfl. We use wfl_op to locate errors related to the
13119 else if (!JNUMERIC_TYPE_P (op_type))
13121 parse_error_context
13122 (wfl_op, "Invalid argument type `%s' to `%s'",
13123 lang_printable_name (op_type, 0), operator_string (node));
13124 TREE_TYPE (node) = error_mark_node;
13129 /* Before the addition, binary numeric promotion is performed on
13130 both operands, if really necessary */
13131 if (JINTEGRAL_TYPE_P (op_type))
13133 value = build_int_2 (1, 0);
13134 TREE_TYPE (value) = TREE_TYPE (node) = op_type;
13138 value = build_int_2 (1, 0);
13140 binary_numeric_promotion (op_type,
13141 TREE_TYPE (value), &op, &value);
13144 /* We remember we might be accessing an outer field */
13145 if (outer_field_flag)
13147 /* We re-generate an access to the field */
13148 value = build (PLUS_EXPR, TREE_TYPE (op),
13149 build_outer_field_access (wfl_op, decl), value);
13151 /* And we patch the original access$() into a write
13152 with plus_op as a rhs */
13153 return outer_field_access_fix (node, op, value);
13156 /* And write back into the node. */
13157 TREE_OPERAND (node, 0) = op;
13158 TREE_OPERAND (node, 1) = value;
13159 /* Convert the overall back into its original type, if
13160 necessary, and return */
13161 if (JINTEGRAL_TYPE_P (op_type))
13162 return fold (node);
13164 return fold (convert (op_type, node));
13168 /* 15.14.3 Unary Plus Operator + */
13169 case UNARY_PLUS_EXPR:
13170 /* 15.14.4 Unary Minus Operator - */
13172 if (!JNUMERIC_TYPE_P (op_type))
13174 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
13175 TREE_TYPE (node) = error_mark_node;
13178 /* Unary numeric promotion is performed on operand */
13181 op = do_unary_numeric_promotion (op);
13182 prom_type = TREE_TYPE (op);
13183 if (code == UNARY_PLUS_EXPR)
13188 /* 15.14.5 Bitwise Complement Operator ~ */
13190 if (!JINTEGRAL_TYPE_P (op_type))
13192 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
13193 TREE_TYPE (node) = error_mark_node;
13198 op = do_unary_numeric_promotion (op);
13199 prom_type = TREE_TYPE (op);
13203 /* 15.14.6 Logical Complement Operator ! */
13204 case TRUTH_NOT_EXPR:
13205 if (TREE_CODE (op_type) != BOOLEAN_TYPE)
13207 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
13208 /* But the type is known. We will report an error if further
13209 attempt of a assignment is made with this rhs */
13210 TREE_TYPE (node) = boolean_type_node;
13214 prom_type = boolean_type_node;
13217 /* 15.15 Cast Expression */
13219 value = patch_cast (node, wfl_operator);
13220 if (value == error_mark_node)
13222 /* If this cast is part of an assignment, we tell the code
13223 that deals with it not to complain about a mismatch,
13224 because things have been cast, anyways */
13225 TREE_TYPE (node) = error_mark_node;
13230 value = fold (value);
13231 TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
13238 return error_mark_node;
13240 /* There are cases where node has been replaced by something else
13241 and we don't end up returning here: UNARY_PLUS_EXPR,
13242 CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
13243 TREE_OPERAND (node, 0) = fold (op);
13244 TREE_TYPE (node) = prom_type;
13245 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
13246 return fold (node);
13249 /* Generic type resolution that sometimes takes place during node
13250 patching. Returned the resolved type or generate an error
13251 message. Return the resolved type or NULL_TREE. */
13254 resolve_type_during_patch (type)
13257 if (unresolved_type_p (type, NULL))
13259 tree type_decl = resolve_no_layout (EXPR_WFL_NODE (type), NULL_TREE);
13262 parse_error_context (type,
13263 "Class `%s' not found in type declaration",
13264 IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
13269 CLASS_LOADED_P (TREE_TYPE (type_decl)) = 1;
13270 return TREE_TYPE (type_decl);
13275 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
13276 found. Otherwise NODE or something meant to replace it is returned. */
13279 patch_cast (node, wfl_operator)
13283 tree op = TREE_OPERAND (node, 0);
13284 tree op_type = TREE_TYPE (op);
13285 tree cast_type = TREE_TYPE (node);
13288 /* First resolve OP_TYPE if unresolved */
13289 if (!(cast_type = resolve_type_during_patch (cast_type)))
13290 return error_mark_node;
13292 /* Check on cast that are proven correct at compile time */
13293 if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
13296 if (cast_type == op_type)
13299 /* float and double type are converted to the original type main
13300 variant and then to the target type. */
13301 if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE)
13302 op = convert (integer_type_node, op);
13304 /* Try widening/narowwing convertion. Potentially, things need
13305 to be worked out in gcc so we implement the extreme cases
13306 correctly. fold_convert() needs to be fixed. */
13307 return convert (cast_type, op);
13310 /* It's also valid to cast a boolean into a boolean */
13311 if (op_type == boolean_type_node && cast_type == boolean_type_node)
13314 /* null can be casted to references */
13315 if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
13316 return build_null_of_type (cast_type);
13318 /* The remaining legal casts involve conversion between reference
13319 types. Check for their compile time correctness. */
13320 if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
13321 && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
13323 TREE_TYPE (node) = promote_type (cast_type);
13324 /* Now, the case can be determined correct at compile time if
13325 OP_TYPE can be converted into CAST_TYPE by assignment
13326 conversion (5.2) */
13328 if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
13330 TREE_SET_CODE (node, NOP_EXPR);
13334 if (flag_emit_class_files)
13336 TREE_SET_CODE (node, CONVERT_EXPR);
13340 /* The cast requires a run-time check */
13341 return build (CALL_EXPR, promote_type (cast_type),
13342 build_address_of (soft_checkcast_node),
13343 tree_cons (NULL_TREE, build_class_ref (cast_type),
13344 build_tree_list (NULL_TREE, op)),
13348 /* Any other casts are proven incorrect at compile time */
13349 t1 = xstrdup (lang_printable_name (op_type, 0));
13350 parse_error_context (wfl_operator, "Invalid cast from `%s' to `%s'",
13351 t1, lang_printable_name (cast_type, 0));
13353 return error_mark_node;
13356 /* Build a null constant and give it the type TYPE. */
13359 build_null_of_type (type)
13362 tree node = build_int_2 (0, 0);
13363 TREE_TYPE (node) = promote_type (type);
13367 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
13368 a list of indices. */
13370 build_array_ref (location, array, index)
13374 tree node = build (ARRAY_REF, NULL_TREE, array, index);
13375 EXPR_WFL_LINECOL (node) = location;
13379 /* 15.12 Array Access Expression */
13382 patch_array_ref (node)
13385 tree array = TREE_OPERAND (node, 0);
13386 tree array_type = TREE_TYPE (array);
13387 tree index = TREE_OPERAND (node, 1);
13388 tree index_type = TREE_TYPE (index);
13389 int error_found = 0;
13391 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13393 if (TREE_CODE (array_type) == POINTER_TYPE)
13394 array_type = TREE_TYPE (array_type);
13396 /* The array reference must be an array */
13397 if (!TYPE_ARRAY_P (array_type))
13399 parse_error_context
13401 "`[]' can only be applied to arrays. It can't be applied to `%s'",
13402 lang_printable_name (array_type, 0));
13403 TREE_TYPE (node) = error_mark_node;
13407 /* The array index undergoes unary numeric promotion. The promoted
13408 type must be int */
13409 index = do_unary_numeric_promotion (index);
13410 if (TREE_TYPE (index) != int_type_node)
13412 if (valid_cast_to_p (index_type, int_type_node))
13413 parse_error_context (wfl_operator,
13414 "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
13415 lang_printable_name (index_type, 0));
13417 parse_error_context (wfl_operator,
13418 "Incompatible type for `[]'. Can't convert `%s' to `int'",
13419 lang_printable_name (index_type, 0));
13420 TREE_TYPE (node) = error_mark_node;
13425 return error_mark_node;
13427 array_type = TYPE_ARRAY_ELEMENT (array_type);
13429 if (flag_emit_class_files || flag_emit_xref)
13431 TREE_OPERAND (node, 0) = array;
13432 TREE_OPERAND (node, 1) = index;
13436 /* The save_expr is for correct evaluation order. It would be cleaner
13437 to use force_evaluation_order (see comment there), but that is
13438 difficult when we also have to deal with bounds checking. */
13439 if (TREE_SIDE_EFFECTS (index))
13440 array = save_expr (array);
13441 node = build_java_arrayaccess (array, array_type, index);
13442 if (TREE_SIDE_EFFECTS (index))
13443 node = build (COMPOUND_EXPR, array_type, array, node);
13445 TREE_TYPE (node) = array_type;
13449 /* 15.9 Array Creation Expressions */
13452 build_newarray_node (type, dims, extra_dims)
13458 build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
13459 build_int_2 (extra_dims, 0));
13464 patch_newarray (node)
13467 tree type = TREE_OPERAND (node, 0);
13468 tree dims = TREE_OPERAND (node, 1);
13469 tree cdim, array_type;
13470 int error_found = 0;
13472 int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
13474 /* Dimension types are verified. It's better for the types to be
13475 verified in order. */
13476 for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
13479 tree dim = TREE_VALUE (cdim);
13481 /* Dim might have been saved during its evaluation */
13482 dim = (TREE_CODE (dim) == SAVE_EXPR ? dim = TREE_OPERAND (dim, 0) : dim);
13484 /* The type of each specified dimension must be an integral type. */
13485 if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
13488 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
13489 promoted type must be int. */
13492 dim = do_unary_numeric_promotion (dim);
13493 if (TREE_TYPE (dim) != int_type_node)
13497 /* Report errors on types here */
13500 parse_error_context
13501 (TREE_PURPOSE (cdim),
13502 "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
13503 (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
13504 "Explicit cast needed to" : "Can't"),
13505 lang_printable_name (TREE_TYPE (dim), 0));
13509 TREE_PURPOSE (cdim) = NULL_TREE;
13512 /* Resolve array base type if unresolved */
13513 if (!(type = resolve_type_during_patch (type)))
13518 /* We don't want further evaluation of this bogus array creation
13520 TREE_TYPE (node) = error_mark_node;
13521 return error_mark_node;
13524 /* Set array_type to the actual (promoted) array type of the result. */
13525 if (TREE_CODE (type) == RECORD_TYPE)
13526 type = build_pointer_type (type);
13527 while (--xdims >= 0)
13529 type = promote_type (build_java_array_type (type, -1));
13531 dims = nreverse (dims);
13533 for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
13537 = build_java_array_type (type,
13538 TREE_CODE (cdim) == INTEGER_CST
13539 ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
13541 array_type = promote_type (array_type);
13543 dims = nreverse (dims);
13545 /* The node is transformed into a function call. Things are done
13546 differently according to the number of dimensions. If the number
13547 of dimension is equal to 1, then the nature of the base type
13548 (primitive or not) matters. */
13550 return build_new_array (type, TREE_VALUE (dims));
13552 /* Can't reuse what's already written in expr.c because it uses the
13553 JVM stack representation. Provide a build_multianewarray. FIXME */
13554 return build (CALL_EXPR, array_type,
13555 build_address_of (soft_multianewarray_node),
13556 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
13557 tree_cons (NULL_TREE,
13558 build_int_2 (ndims, 0), dims )),
13562 /* 10.6 Array initializer. */
13564 /* Build a wfl for array element that don't have one, so we can
13565 pin-point errors. */
13568 maybe_build_array_element_wfl (node)
13571 if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
13572 return build_expr_wfl (NULL_TREE, ctxp->filename,
13573 ctxp->elc.line, ctxp->elc.prev_col);
13578 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
13579 identification of initialized arrays easier to detect during walk
13583 build_new_array_init (location, values)
13587 tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
13588 tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
13589 EXPR_WFL_LINECOL (to_return) = location;
13593 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
13594 occurred. Otherwise return NODE after having set its type
13598 patch_new_array_init (type, node)
13601 int error_seen = 0;
13602 tree current, element_type;
13603 HOST_WIDE_INT length;
13604 int all_constant = 1;
13605 tree init = TREE_OPERAND (node, 0);
13607 if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
13609 parse_error_context (node,
13610 "Invalid array initializer for non-array type `%s'",
13611 lang_printable_name (type, 1));
13612 return error_mark_node;
13614 type = TREE_TYPE (type);
13615 element_type = TYPE_ARRAY_ELEMENT (type);
13617 CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
13619 for (length = 0, current = CONSTRUCTOR_ELTS (init);
13620 current; length++, current = TREE_CHAIN (current))
13622 tree elt = TREE_VALUE (current);
13623 if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
13625 error_seen |= array_constructor_check_entry (element_type, current);
13626 elt = TREE_VALUE (current);
13627 /* When compiling to native code, STRING_CST is converted to
13628 INDIRECT_REF, but still with a TREE_CONSTANT flag. */
13629 if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
13634 TREE_VALUE (current) = patch_new_array_init (element_type, elt);
13635 TREE_PURPOSE (current) = NULL_TREE;
13638 if (elt && TREE_CODE (elt) == TREE_LIST
13639 && TREE_VALUE (elt) == error_mark_node)
13644 return error_mark_node;
13646 /* Create a new type. We can't reuse the one we have here by
13647 patching its dimension because it originally is of dimension -1
13648 hence reused by gcc. This would prevent triangular arrays. */
13649 type = build_java_array_type (element_type, length);
13650 TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
13651 TREE_TYPE (node) = promote_type (type);
13652 TREE_CONSTANT (init) = all_constant;
13653 TREE_CONSTANT (node) = all_constant;
13657 /* Verify that one entry of the initializer element list can be
13658 assigned to the array base type. Report 1 if an error occurred, 0
13662 array_constructor_check_entry (type, entry)
13665 char *array_type_string = NULL; /* For error reports */
13666 tree value, type_value, new_value, wfl_value, patched;
13667 int error_seen = 0;
13669 new_value = NULL_TREE;
13670 wfl_value = TREE_VALUE (entry);
13672 push_obstacks (&permanent_obstack, &permanent_obstack);
13673 value = java_complete_tree (TREE_VALUE (entry));
13674 /* patch_string return error_mark_node if arg is error_mark_node */
13675 if ((patched = patch_string (value)))
13677 if (value == error_mark_node)
13680 type_value = TREE_TYPE (value);
13682 /* At anytime, try_builtin_assignconv can report a warning on
13683 constant overflow during narrowing. */
13684 SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
13685 new_value = try_builtin_assignconv (wfl_operator, type, value);
13686 if (!new_value && (new_value = try_reference_assignconv (type, value)))
13687 type_value = promote_type (type);
13690 /* Check and report errors */
13693 const char *msg = (!valid_cast_to_p (type_value, type) ?
13694 "Can't" : "Explicit cast needed to");
13695 if (!array_type_string)
13696 array_type_string = xstrdup (lang_printable_name (type, 1));
13697 parse_error_context
13698 (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
13699 msg, lang_printable_name (type_value, 1), array_type_string);
13705 new_value = maybe_build_primttype_type_ref (new_value, wfl_value);
13706 TREE_VALUE (entry) = new_value;
13709 if (array_type_string)
13710 free (array_type_string);
13712 TREE_PURPOSE (entry) = NULL_TREE;
13717 build_this (location)
13720 tree node = build_wfl_node (this_identifier_node);
13721 TREE_SET_CODE (node, THIS_EXPR);
13722 EXPR_WFL_LINECOL (node) = location;
13726 /* 14.15 The return statement. It builds a modify expression that
13727 assigns the returned value to the RESULT_DECL that hold the value
13731 build_return (location, op)
13735 tree node = build1 (RETURN_EXPR, NULL_TREE, op);
13736 EXPR_WFL_LINECOL (node) = location;
13737 node = build_debugable_stmt (location, node);
13742 patch_return (node)
13745 tree return_exp = TREE_OPERAND (node, 0);
13746 tree meth = current_function_decl;
13747 tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
13748 int error_found = 0;
13750 TREE_TYPE (node) = error_mark_node;
13751 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13753 /* It's invalid to have a return value within a function that is
13754 declared with the keyword void or that is a constructor */
13755 if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
13758 /* It's invalid to use a return statement in a static block */
13759 if (DECL_CLINIT_P (current_function_decl))
13762 /* It's invalid to have a no return value within a function that
13763 isn't declared with the keyword `void' */
13764 if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
13767 if (in_instance_initializer)
13772 if (in_instance_initializer)
13773 parse_error_context (wfl_operator,
13774 "`return' inside instance initializer");
13776 else if (DECL_CLINIT_P (current_function_decl))
13777 parse_error_context (wfl_operator,
13778 "`return' inside static initializer");
13780 else if (!DECL_CONSTRUCTOR_P (meth))
13782 char *t = xstrdup (lang_printable_name (mtype, 0));
13783 parse_error_context (wfl_operator,
13784 "`return' with%s value from `%s %s'",
13785 (error_found == 1 ? "" : "out"),
13786 t, lang_printable_name (meth, 0));
13790 parse_error_context (wfl_operator,
13791 "`return' with value from constructor `%s'",
13792 lang_printable_name (meth, 0));
13793 return error_mark_node;
13796 /* If we have a return_exp, build a modify expression and expand
13797 it. Note: at that point, the assignment is declared valid, but we
13798 may want to carry some more hacks */
13801 tree exp = java_complete_tree (return_exp);
13802 tree modify, patched;
13804 /* If the function returned value and EXP are booleans, EXP has
13805 to be converted into the type of DECL_RESULT, which is integer
13806 (see complete_start_java_method) */
13807 if (TREE_TYPE (exp) == boolean_type_node &&
13808 TREE_TYPE (TREE_TYPE (meth)) == boolean_type_node)
13809 exp = convert_to_integer (TREE_TYPE (DECL_RESULT (meth)), exp);
13811 /* `null' can be assigned to a function returning a reference */
13812 if (JREFERENCE_TYPE_P (TREE_TYPE (TREE_TYPE (meth))) &&
13813 exp == null_pointer_node)
13814 exp = build_null_of_type (TREE_TYPE (TREE_TYPE (meth)));
13816 if ((patched = patch_string (exp)))
13819 modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
13820 EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
13821 modify = java_complete_tree (modify);
13823 if (modify != error_mark_node)
13825 TREE_SIDE_EFFECTS (modify) = 1;
13826 TREE_OPERAND (node, 0) = modify;
13829 return error_mark_node;
13831 TREE_TYPE (node) = void_type_node;
13832 TREE_SIDE_EFFECTS (node) = 1;
13836 /* 14.8 The if Statement */
13839 build_if_else_statement (location, expression, if_body, else_body)
13841 tree expression, if_body, else_body;
13845 else_body = empty_stmt_node;
13846 node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
13847 EXPR_WFL_LINECOL (node) = location;
13848 node = build_debugable_stmt (location, node);
13853 patch_if_else_statement (node)
13856 tree expression = TREE_OPERAND (node, 0);
13858 TREE_TYPE (node) = error_mark_node;
13859 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13861 /* The type of expression must be boolean */
13862 if (TREE_TYPE (expression) != boolean_type_node
13863 && TREE_TYPE (expression) != promoted_boolean_type_node)
13865 parse_error_context
13867 "Incompatible type for `if'. Can't convert `%s' to `boolean'",
13868 lang_printable_name (TREE_TYPE (expression), 0));
13869 return error_mark_node;
13872 TREE_TYPE (node) = void_type_node;
13873 TREE_SIDE_EFFECTS (node) = 1;
13874 CAN_COMPLETE_NORMALLY (node)
13875 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
13876 | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2));
13880 /* 14.6 Labeled Statements */
13882 /* Action taken when a lableled statement is parsed. a new
13883 LABELED_BLOCK_EXPR is created. No statement is attached to the
13884 label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
13887 build_labeled_block (location, label)
13892 tree label_decl, node;
13893 if (label == NULL_TREE || label == continue_identifier_node)
13894 label_name = label;
13897 label_name = merge_qualified_name (label_id, label);
13898 /* Issue an error if we try to reuse a label that was previously
13900 if (IDENTIFIER_LOCAL_VALUE (label_name))
13902 EXPR_WFL_LINECOL (wfl_operator) = location;
13903 parse_error_context (wfl_operator,
13904 "Declaration of `%s' shadows a previous label declaration",
13905 IDENTIFIER_POINTER (label));
13906 EXPR_WFL_LINECOL (wfl_operator) =
13907 EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
13908 parse_error_context (wfl_operator,
13909 "This is the location of the previous declaration of label `%s'",
13910 IDENTIFIER_POINTER (label));
13911 java_error_count--;
13915 label_decl = create_label_decl (label_name);
13916 node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
13917 EXPR_WFL_LINECOL (node) = location;
13918 TREE_SIDE_EFFECTS (node) = 1;
13922 /* A labeled statement LBE is attached a statement. */
13925 finish_labeled_statement (lbe, statement)
13926 tree lbe; /* Labeled block expr */
13929 /* In anyways, tie the loop to its statement */
13930 LABELED_BLOCK_BODY (lbe) = statement;
13931 pop_labeled_block ();
13932 POP_LABELED_BLOCK ();
13936 /* 14.10, 14.11, 14.12 Loop Statements */
13938 /* Create an empty LOOP_EXPR and make it the last in the nested loop
13942 build_new_loop (loop_body)
13945 tree loop = build (LOOP_EXPR, NULL_TREE, loop_body);
13946 TREE_SIDE_EFFECTS (loop) = 1;
13951 /* Create a loop body according to the following structure:
13953 COMPOUND_EXPR (loop main body)
13954 EXIT_EXPR (this order is for while/for loops.
13955 LABELED_BLOCK_EXPR the order is reversed for do loops)
13956 LABEL_DECL (a continue occuring here branches at the
13957 BODY end of this labeled block)
13960 REVERSED, if non zero, tells that the loop condition expr comes
13961 after the body, like in the do-while loop.
13963 To obtain a loop, the loop body structure described above is
13964 encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
13967 LABEL_DECL (use this label to exit the loop)
13969 <structure described above> */
13972 build_loop_body (location, condition, reversed)
13977 tree first, second, body;
13979 condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
13980 EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
13981 condition = build_debugable_stmt (location, condition);
13982 TREE_SIDE_EFFECTS (condition) = 1;
13984 body = build_labeled_block (0, continue_identifier_node);
13985 first = (reversed ? body : condition);
13986 second = (reversed ? condition : body);
13988 build (COMPOUND_EXPR, NULL_TREE,
13989 build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
13992 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
13993 their order) on the current loop. Unlink the current loop from the
13997 finish_loop_body (location, condition, body, reversed)
13999 tree condition, body;
14002 tree to_return = ctxp->current_loop;
14003 tree loop_body = LOOP_EXPR_BODY (to_return);
14006 tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14007 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14008 The real EXIT_EXPR is one operand further. */
14009 EXPR_WFL_LINECOL (cnode) = location;
14010 /* This one is for accurate error reports */
14011 EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14012 TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14014 LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14019 /* Tailored version of finish_loop_body for FOR loops, when FOR
14020 loops feature the condition part */
14023 finish_for_loop (location, condition, update, body)
14025 tree condition, update, body;
14027 /* Put the condition and the loop body in place */
14028 tree loop = finish_loop_body (location, condition, body, 0);
14029 /* LOOP is the current loop which has been now popped of the loop
14030 stack. Install the update block */
14031 LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14035 /* Try to find the loop a block might be related to. This comprises
14036 the case where the LOOP_EXPR is found as the second operand of a
14037 COMPOUND_EXPR, because the loop happens to have an initialization
14038 part, then expressed as the first operand of the COMPOUND_EXPR. If
14039 the search finds something, 1 is returned. Otherwise, 0 is
14040 returned. The search is assumed to start from a
14041 LABELED_BLOCK_EXPR's block. */
14044 search_loop (statement)
14047 if (TREE_CODE (statement) == LOOP_EXPR)
14050 if (TREE_CODE (statement) == BLOCK)
14051 statement = BLOCK_SUBBLOCKS (statement);
14055 if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14056 while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14057 statement = TREE_OPERAND (statement, 1);
14059 return (TREE_CODE (statement) == LOOP_EXPR
14060 && FOR_LOOP_P (statement) ? statement : NULL_TREE);
14063 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
14064 returned otherwise. */
14067 labeled_block_contains_loop_p (block, loop)
14073 if (LABELED_BLOCK_BODY (block) == loop)
14076 if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
14082 /* If the loop isn't surrounded by a labeled statement, create one and
14083 insert LOOP as its body. */
14086 patch_loop_statement (loop)
14091 TREE_TYPE (loop) = void_type_node;
14092 if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
14095 loop_label = build_labeled_block (0, NULL_TREE);
14096 /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
14097 that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
14098 LABELED_BLOCK_BODY (loop_label) = loop;
14099 PUSH_LABELED_BLOCK (loop_label);
14103 /* 14.13, 14.14: break and continue Statements */
14105 /* Build a break or a continue statement. a null NAME indicates an
14106 unlabeled break/continue statement. */
14109 build_bc_statement (location, is_break, name)
14110 int location, is_break;
14113 tree break_continue, label_block_expr = NULL_TREE;
14117 if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
14118 (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
14119 /* Null means that we don't have a target for this named
14120 break/continue. In this case, we make the target to be the
14121 label name, so that the error can be reported accuratly in
14122 patch_bc_statement. */
14123 label_block_expr = EXPR_WFL_NODE (name);
14125 /* Unlabeled break/continue will be handled during the
14126 break/continue patch operation */
14128 = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
14130 IS_BREAK_STMT_P (break_continue) = is_break;
14131 TREE_SIDE_EFFECTS (break_continue) = 1;
14132 EXPR_WFL_LINECOL (break_continue) = location;
14133 break_continue = build_debugable_stmt (location, break_continue);
14134 return break_continue;
14137 /* Verification of a break/continue statement. */
14140 patch_bc_statement (node)
14143 tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
14144 tree labeled_block = ctxp->current_labeled_block;
14145 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14147 /* Having an identifier here means that the target is unknown. */
14148 if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
14150 parse_error_context (wfl_operator, "No label definition found for `%s'",
14151 IDENTIFIER_POINTER (bc_label));
14152 return error_mark_node;
14154 if (! IS_BREAK_STMT_P (node))
14156 /* It's a continue statement. */
14157 for (;; labeled_block = TREE_CHAIN (labeled_block))
14159 if (labeled_block == NULL_TREE)
14161 if (bc_label == NULL_TREE)
14162 parse_error_context (wfl_operator,
14163 "`continue' must be in loop");
14165 parse_error_context
14166 (wfl_operator, "continue label `%s' does not name a loop",
14167 IDENTIFIER_POINTER (bc_label));
14168 return error_mark_node;
14170 if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
14171 == continue_identifier_node)
14172 && (bc_label == NULL_TREE
14173 || TREE_CHAIN (labeled_block) == bc_label))
14175 bc_label = labeled_block;
14180 else if (!bc_label)
14182 for (;; labeled_block = TREE_CHAIN (labeled_block))
14184 if (labeled_block == NULL_TREE)
14186 parse_error_context (wfl_operator,
14187 "`break' must be in loop or switch");
14188 return error_mark_node;
14190 target_stmt = LABELED_BLOCK_BODY (labeled_block);
14191 if (TREE_CODE (target_stmt) == SWITCH_EXPR
14192 || search_loop (target_stmt))
14194 bc_label = labeled_block;
14200 EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
14201 CAN_COMPLETE_NORMALLY (bc_label) = 1;
14203 /* Our break/continue don't return values. */
14204 TREE_TYPE (node) = void_type_node;
14205 /* Encapsulate the break within a compound statement so that it's
14206 expanded all the times by expand_expr (and not clobbered
14207 sometimes, like after a if statement) */
14208 node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
14209 TREE_SIDE_EFFECTS (node) = 1;
14213 /* Process the exit expression belonging to a loop. Its type must be
14217 patch_exit_expr (node)
14220 tree expression = TREE_OPERAND (node, 0);
14221 TREE_TYPE (node) = error_mark_node;
14222 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14224 /* The type of expression must be boolean */
14225 if (TREE_TYPE (expression) != boolean_type_node)
14227 parse_error_context
14229 "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
14230 lang_printable_name (TREE_TYPE (expression), 0));
14231 return error_mark_node;
14233 /* Now we know things are allright, invert the condition, fold and
14235 TREE_OPERAND (node, 0) =
14236 fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
14238 if (! integer_zerop (TREE_OPERAND (node, 0))
14239 && ctxp->current_loop != NULL_TREE
14240 && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
14241 CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
14242 if (! integer_onep (TREE_OPERAND (node, 0)))
14243 CAN_COMPLETE_NORMALLY (node) = 1;
14246 TREE_TYPE (node) = void_type_node;
14250 /* 14.9 Switch statement */
14253 patch_switch_statement (node)
14256 tree se = TREE_OPERAND (node, 0), se_type;
14258 /* Complete the switch expression */
14259 se = TREE_OPERAND (node, 0) = java_complete_tree (se);
14260 se_type = TREE_TYPE (se);
14261 /* The type of the switch expression must be char, byte, short or
14263 if (!JINTEGRAL_TYPE_P (se_type))
14265 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14266 parse_error_context (wfl_operator,
14267 "Incompatible type for `switch'. Can't convert `%s' to `int'",
14268 lang_printable_name (se_type, 0));
14269 /* This is what java_complete_tree will check */
14270 TREE_OPERAND (node, 0) = error_mark_node;
14271 return error_mark_node;
14274 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
14276 /* Ready to return */
14277 if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
14279 TREE_TYPE (node) = error_mark_node;
14280 return error_mark_node;
14282 TREE_TYPE (node) = void_type_node;
14283 TREE_SIDE_EFFECTS (node) = 1;
14284 CAN_COMPLETE_NORMALLY (node)
14285 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14286 || ! SWITCH_HAS_DEFAULT (node);
14290 /* 14.18 The try/catch statements */
14293 build_try_statement (location, try_block, catches)
14295 tree try_block, catches;
14297 tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
14298 EXPR_WFL_LINECOL (node) = location;
14303 build_try_finally_statement (location, try_block, finally)
14305 tree try_block, finally;
14307 tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
14308 EXPR_WFL_LINECOL (node) = location;
14313 patch_try_statement (node)
14316 int error_found = 0;
14317 tree try = TREE_OPERAND (node, 0);
14318 /* Exception handlers are considered in left to right order */
14319 tree catch = nreverse (TREE_OPERAND (node, 1));
14320 tree current, caught_type_list = NULL_TREE;
14322 /* Check catch clauses, if any. Every time we find an error, we try
14323 to process the next catch clause. We process the catch clause before
14324 the try block so that when processing the try block we can check thrown
14325 exceptions againts the caught type list. */
14326 for (current = catch; current; current = TREE_CHAIN (current))
14328 tree carg_decl, carg_type;
14329 tree sub_current, catch_block, catch_clause;
14332 /* At this point, the structure of the catch clause is
14333 CATCH_EXPR (catch node)
14334 BLOCK (with the decl of the parameter)
14336 MODIFY_EXPR (assignment of the catch parameter)
14337 BLOCK (catch clause block)
14339 catch_clause = TREE_OPERAND (current, 0);
14340 carg_decl = BLOCK_EXPR_DECLS (catch_clause);
14341 carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
14343 /* Catch clauses can't have more than one parameter declared,
14344 but it's already enforced by the grammar. Make sure that the
14345 only parameter of the clause statement in of class Throwable
14346 or a subclass of Throwable, but that was done earlier. The
14347 catch clause parameter type has also been resolved. */
14349 /* Just make sure that the catch clause parameter type inherits
14350 from java.lang.Throwable */
14351 if (!inherits_from_p (carg_type, throwable_type_node))
14353 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
14354 parse_error_context (wfl_operator,
14355 "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
14356 lang_printable_name (carg_type, 0));
14361 /* Partial check for unreachable catch statement: The catch
14362 clause is reachable iff is no earlier catch block A in
14363 the try statement such that the type of the catch
14364 clause's parameter is the same as or a subclass of the
14365 type of A's parameter */
14367 for (sub_current = catch;
14368 sub_current != current; sub_current = TREE_CHAIN (sub_current))
14370 tree sub_catch_clause, decl;
14371 sub_catch_clause = TREE_OPERAND (sub_current, 0);
14372 decl = BLOCK_EXPR_DECLS (sub_catch_clause);
14374 if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
14376 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
14377 parse_error_context
14379 "`catch' not reached because of the catch clause at line %d",
14380 EXPR_WFL_LINENO (sub_current));
14381 unreachable = error_found = 1;
14385 /* Complete the catch clause block */
14386 catch_block = java_complete_tree (TREE_OPERAND (current, 0));
14387 if (catch_block == error_mark_node)
14392 if (CAN_COMPLETE_NORMALLY (catch_block))
14393 CAN_COMPLETE_NORMALLY (node) = 1;
14394 TREE_OPERAND (current, 0) = catch_block;
14399 /* Things to do here: the exception must be thrown */
14401 /* Link this type to the caught type list */
14402 caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
14405 PUSH_EXCEPTIONS (caught_type_list);
14406 if ((try = java_complete_tree (try)) == error_mark_node)
14408 if (CAN_COMPLETE_NORMALLY (try))
14409 CAN_COMPLETE_NORMALLY (node) = 1;
14412 /* Verification ends here */
14414 return error_mark_node;
14416 TREE_OPERAND (node, 0) = try;
14417 TREE_OPERAND (node, 1) = catch;
14418 TREE_TYPE (node) = void_type_node;
14422 /* 14.17 The synchronized Statement */
14425 patch_synchronized_statement (node, wfl_op1)
14426 tree node, wfl_op1;
14428 tree expr = java_complete_tree (TREE_OPERAND (node, 0));
14429 tree block = TREE_OPERAND (node, 1);
14431 tree enter, exit, expr_decl, assignment;
14433 if (expr == error_mark_node)
14435 block = java_complete_tree (block);
14439 /* The TYPE of expr must be a reference type */
14440 if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
14442 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
14443 parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
14444 lang_printable_name (TREE_TYPE (expr), 0));
14445 return error_mark_node;
14448 if (flag_emit_xref)
14450 TREE_OPERAND (node, 0) = expr;
14451 TREE_OPERAND (node, 1) = java_complete_tree (block);
14452 CAN_COMPLETE_NORMALLY (node) = 1;
14456 /* Generate a try-finally for the synchronized statement, except
14457 that the handler that catches all throw exception calls
14458 _Jv_MonitorExit and then rethrow the exception.
14459 The synchronized statement is then implemented as:
14462 _Jv_MonitorEnter (expression)
14464 _Jv_MonitorExit (expression)
14468 e = _Jv_exception_info ();
14469 _Jv_MonitorExit (expression)
14473 expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
14474 BUILD_MONITOR_ENTER (enter, expr_decl);
14475 BUILD_MONITOR_EXIT (exit, expr_decl);
14476 CAN_COMPLETE_NORMALLY (enter) = 1;
14477 CAN_COMPLETE_NORMALLY (exit) = 1;
14478 assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
14479 TREE_SIDE_EFFECTS (assignment) = 1;
14480 node = build1 (CLEANUP_POINT_EXPR, NULL_TREE,
14481 build (COMPOUND_EXPR, NULL_TREE,
14482 build (WITH_CLEANUP_EXPR, NULL_TREE,
14483 build (COMPOUND_EXPR, NULL_TREE,
14484 assignment, enter),
14487 node = build_expr_block (node, expr_decl);
14489 return java_complete_tree (node);
14492 /* 14.16 The throw Statement */
14495 patch_throw_statement (node, wfl_op1)
14496 tree node, wfl_op1;
14498 tree expr = TREE_OPERAND (node, 0);
14499 tree type = TREE_TYPE (expr);
14500 int unchecked_ok = 0, tryblock_throws_ok = 0;
14502 /* Thrown expression must be assignable to java.lang.Throwable */
14503 if (!try_reference_assignconv (throwable_type_node, expr))
14505 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
14506 parse_error_context (wfl_operator,
14507 "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
14508 lang_printable_name (type, 0));
14509 /* If the thrown expression was a reference, we further the
14510 compile-time check. */
14511 if (!JREFERENCE_TYPE_P (type))
14512 return error_mark_node;
14515 /* At least one of the following must be true */
14517 /* The type of the throw expression is a not checked exception,
14518 i.e. is a unchecked expression. */
14519 unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
14521 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
14522 /* An instance can't throw a checked excetion unless that exception
14523 is explicitely declared in the `throws' clause of each
14524 constructor. This doesn't apply to anonymous classes, since they
14525 don't have declared constructors. */
14527 && in_instance_initializer && !ANONYMOUS_CLASS_P (current_class))
14530 for (current = TYPE_METHODS (current_class); current;
14531 current = TREE_CHAIN (current))
14532 if (DECL_CONSTRUCTOR_P (current)
14533 && !check_thrown_exceptions_do (TREE_TYPE (expr)))
14535 parse_error_context (wfl_operator, "Checked exception `%s' can't be thrown in instance initializer (not all declared constructor are declaring it in their `throws' clause)",
14536 lang_printable_name (TREE_TYPE (expr), 0));
14537 return error_mark_node;
14541 /* Throw is contained in a try statement and at least one catch
14542 clause can receive the thrown expression or the current method is
14543 declared to throw such an exception. Or, the throw statement is
14544 contained in a method or constructor declaration and the type of
14545 the Expression is assignable to at least one type listed in the
14546 throws clause the declaration. */
14548 tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
14549 if (!(unchecked_ok || tryblock_throws_ok))
14551 /* If there is a surrounding try block that has no matching
14552 clatch clause, report it first. A surrounding try block exits
14553 only if there is something after the list of checked
14554 exception thrown by the current function (if any). */
14555 if (IN_TRY_BLOCK_P ())
14556 parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
14557 lang_printable_name (type, 0));
14558 /* If we have no surrounding try statement and the method doesn't have
14559 any throws, report it now. FIXME */
14561 /* We report that the exception can't be throw from a try block
14562 in all circumstances but when the `throw' is inside a static
14564 else if (!EXCEPTIONS_P (currently_caught_type_list)
14565 && !tryblock_throws_ok)
14567 if (DECL_CLINIT_P (current_function_decl))
14568 parse_error_context (wfl_operator,
14569 "Checked exception `%s' can't be thrown in initializer",
14570 lang_printable_name (type, 0));
14572 parse_error_context (wfl_operator,
14573 "Checked exception `%s' isn't thrown from a `try' block",
14574 lang_printable_name (type, 0));
14576 /* Otherwise, the current method doesn't have the appropriate
14577 throws declaration */
14579 parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
14580 lang_printable_name (type, 0));
14581 return error_mark_node;
14584 if (! flag_emit_class_files && ! flag_emit_xref)
14585 BUILD_THROW (node, expr);
14587 /* If doing xrefs, keep the location where the `throw' was seen. */
14588 if (flag_emit_xref)
14589 EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
14593 /* Check that exception said to be thrown by method DECL can be
14594 effectively caught from where DECL is invoked. */
14597 check_thrown_exceptions (location, decl)
14602 /* For all the unchecked exceptions thrown by DECL */
14603 for (throws = DECL_FUNCTION_THROWS (decl); throws;
14604 throws = TREE_CHAIN (throws))
14605 if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
14608 /* Temporary hack to suppresses errors about cloning arrays. FIXME */
14609 if (DECL_NAME (decl) == get_identifier ("clone"))
14612 EXPR_WFL_LINECOL (wfl_operator) = location;
14613 if (DECL_FINIT_P (current_function_decl))
14614 parse_error_context
14615 (wfl_operator, "Exception `%s' can't be thrown in initializer",
14616 lang_printable_name (TREE_VALUE (throws), 0));
14619 parse_error_context
14620 (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
14621 lang_printable_name (TREE_VALUE (throws), 0),
14622 (DECL_INIT_P (current_function_decl) ?
14623 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
14624 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
14629 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
14630 try-catch blocks, OR is listed in the `throws' clause of the
14634 check_thrown_exceptions_do (exception)
14637 tree list = currently_caught_type_list;
14638 resolve_and_layout (exception, NULL_TREE);
14639 /* First, all the nested try-catch-finally at that stage. The
14640 last element contains `throws' clause exceptions, if any. */
14641 if (IS_UNCHECKED_EXCEPTION_P (exception))
14646 for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
14647 if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
14649 list = TREE_CHAIN (list);
14655 purge_unchecked_exceptions (mdecl)
14658 tree throws = DECL_FUNCTION_THROWS (mdecl);
14659 tree new = NULL_TREE;
14663 tree next = TREE_CHAIN (throws);
14664 if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
14666 TREE_CHAIN (throws) = new;
14671 /* List is inverted here, but it doesn't matter */
14672 DECL_FUNCTION_THROWS (mdecl) = new;
14675 /* 15.24 Conditional Operator ?: */
14678 patch_conditional_expr (node, wfl_cond, wfl_op1)
14679 tree node, wfl_cond, wfl_op1;
14681 tree cond = TREE_OPERAND (node, 0);
14682 tree op1 = TREE_OPERAND (node, 1);
14683 tree op2 = TREE_OPERAND (node, 2);
14684 tree resulting_type = NULL_TREE;
14685 tree t1, t2, patched;
14686 int error_found = 0;
14688 /* Operands of ?: might be StringBuffers crafted as a result of a
14689 string concatenation. Obtain a descent operand here. */
14690 if ((patched = patch_string (op1)))
14691 TREE_OPERAND (node, 1) = op1 = patched;
14692 if ((patched = patch_string (op2)))
14693 TREE_OPERAND (node, 2) = op2 = patched;
14695 t1 = TREE_TYPE (op1);
14696 t2 = TREE_TYPE (op2);
14698 /* The first expression must be a boolean */
14699 if (TREE_TYPE (cond) != boolean_type_node)
14701 SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
14702 parse_error_context (wfl_operator,
14703 "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
14704 lang_printable_name (TREE_TYPE (cond), 0));
14708 /* Second and third can be numeric, boolean (i.e. primitive),
14709 references or null. Anything else results in an error */
14710 if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
14711 || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
14712 && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
14713 || (t1 == boolean_type_node && t2 == boolean_type_node)))
14716 /* Determine the type of the conditional expression. Same types are
14717 easy to deal with */
14719 resulting_type = t1;
14721 /* There are different rules for numeric types */
14722 else if (JNUMERIC_TYPE_P (t1))
14724 /* if byte/short found, the resulting type is short */
14725 if ((t1 == byte_type_node && t2 == short_type_node)
14726 || (t1 == short_type_node && t2 == byte_type_node))
14727 resulting_type = short_type_node;
14729 /* If t1 is a constant int and t2 is of type byte, short or char
14730 and t1's value fits in t2, then the resulting type is t2 */
14731 else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
14732 && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
14733 resulting_type = t2;
14735 /* If t2 is a constant int and t1 is of type byte, short or char
14736 and t2's value fits in t1, then the resulting type is t1 */
14737 else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
14738 && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
14739 resulting_type = t1;
14741 /* Otherwise, binary numeric promotion is applied and the
14742 resulting type is the promoted type of operand 1 and 2 */
14744 resulting_type = binary_numeric_promotion (t1, t2,
14745 &TREE_OPERAND (node, 1),
14746 &TREE_OPERAND (node, 2));
14749 /* Cases of a reference and a null type */
14750 else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
14751 resulting_type = t1;
14753 else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
14754 resulting_type = t2;
14756 /* Last case: different reference types. If a type can be converted
14757 into the other one by assignment conversion, the latter
14758 determines the type of the expression */
14759 else if ((resulting_type = try_reference_assignconv (t1, op2)))
14760 resulting_type = promote_type (t1);
14762 else if ((resulting_type = try_reference_assignconv (t2, op1)))
14763 resulting_type = promote_type (t2);
14765 /* If we don't have any resulting type, we're in trouble */
14766 if (!resulting_type)
14768 char *t = xstrdup (lang_printable_name (t1, 0));
14769 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
14770 parse_error_context (wfl_operator,
14771 "Incompatible type for `?:'. Can't convert `%s' to `%s'",
14772 t, lang_printable_name (t2, 0));
14779 TREE_TYPE (node) = error_mark_node;
14780 return error_mark_node;
14783 TREE_TYPE (node) = resulting_type;
14784 TREE_SET_CODE (node, COND_EXPR);
14785 CAN_COMPLETE_NORMALLY (node) = 1;
14789 /* Try to constant fold NODE.
14790 If NODE is not a constant expression, return NULL_EXPR.
14791 CONTEXT is a static final VAR_DECL whose initializer we are folding. */
14794 fold_constant_for_init (node, context)
14798 tree op0, op1, val;
14799 enum tree_code code = TREE_CODE (node);
14801 if (code == STRING_CST)
14804 if (code == INTEGER_CST || code == REAL_CST)
14805 return convert (TREE_TYPE (context), node);
14812 case TRUNC_MOD_EXPR:
14820 case TRUTH_ANDIF_EXPR:
14821 case TRUTH_ORIF_EXPR:
14828 op0 = TREE_OPERAND (node, 0);
14829 op1 = TREE_OPERAND (node, 1);
14830 val = fold_constant_for_init (op0, context);
14831 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14833 TREE_OPERAND (node, 0) = val;
14834 val = fold_constant_for_init (op1, context);
14835 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14837 TREE_OPERAND (node, 1) = val;
14838 return patch_binop (node, op0, op1);
14840 case UNARY_PLUS_EXPR:
14842 case TRUTH_NOT_EXPR:
14845 op0 = TREE_OPERAND (node, 0);
14846 val = fold_constant_for_init (op0, context);
14847 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14849 TREE_OPERAND (node, 0) = val;
14850 return patch_unaryop (node, op0);
14854 val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
14855 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14857 TREE_OPERAND (node, 0) = val;
14858 val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
14859 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14861 TREE_OPERAND (node, 1) = val;
14862 val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
14863 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14865 TREE_OPERAND (node, 2) = val;
14866 return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
14867 : TREE_OPERAND (node, 2);
14871 if (! FIELD_FINAL (node)
14872 || DECL_INITIAL (node) == NULL_TREE)
14874 val = DECL_INITIAL (node);
14875 /* Guard against infinite recursion. */
14876 DECL_INITIAL (node) = NULL_TREE;
14877 val = fold_constant_for_init (val, node);
14878 DECL_INITIAL (node) = val;
14881 case EXPR_WITH_FILE_LOCATION:
14882 /* Compare java_complete_tree and resolve_expression_name. */
14883 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
14884 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
14886 tree name = EXPR_WFL_NODE (node);
14888 if (PRIMARY_P (node))
14890 else if (! QUALIFIED_P (name))
14892 decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
14893 if (decl == NULL_TREE
14894 || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
14896 return fold_constant_for_init (decl, decl);
14900 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
14901 qualify_ambiguous_name (node);
14902 if (resolve_field_access (node, &decl, NULL)
14903 && decl != NULL_TREE)
14904 return fold_constant_for_init (decl, decl);
14910 op0 = TREE_OPERAND (node, 0);
14911 val = fold_constant_for_init (op0, context);
14912 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14914 TREE_OPERAND (node, 0) = val;
14918 #ifdef USE_COMPONENT_REF
14920 case COMPONENT_REF:
14929 #ifdef USE_COMPONENT_REF
14930 /* Context is 'T' for TypeName, 'P' for PackageName,
14931 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
14934 resolve_simple_name (name, context)
14941 resolve_qualified_name (name, context)