?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
oops - fixed typo in previous delta
[official-gcc.git] / gcc / java / parse.y
blob843d695e718f841f7de34c301d55c36feaf0ef47
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)
5
6 This file is part of GNU CC.
7
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)
11 any later version.
12
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.
17
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.
22
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. */
26
27 /* This file parses java source code and issues a tree node image
28 suitable for code generation (byte code and targeted CPU assembly
29 language).
30
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"
34
35 The following modifications were brought to the original grammar:
36
37 method_body: added the rule '| block SC_TK'
38 static_initializer: added the rule 'static block SC_TK'.
39
40 Note: All the extra rules described above should go away when the
41 empty_statement rule will work.
42
43 statement_nsi: 'nsi' should be read no_short_if.
44
45 Some rules have been modified to support JDK1.1 inner classes
46 definitions and other extensions. */
47
48 %{
49 #include "config.h"
50 #include "system.h"
51 #include <dirent.h>
52 #include "tree.h"
53 #include "rtl.h"
54 #include "obstack.h"
55 #include "toplev.h"
56 #include "flags.h"
57 #include "java-tree.h"
58 #include "jcf.h"
59 #include "lex.h"
60 #include "parse.h"
61 #include "zipfile.h"
62 #include "convert.h"
63 #include "buffer.h"
64 #include "xref.h"
65 #include "function.h"
66 #include "except.h"
67 #include "defaults.h"
68
69 /* Local function prototypes */
70 static char *java_accstring_lookup PARAMS ((int));
71 static void classitf_redefinition_error PARAMS ((const char *,tree, tree, tree));
72 static void variable_redefinition_error PARAMS ((tree, tree, tree, int));
73 static tree create_class PARAMS ((int, tree, tree, tree));
74 static tree create_interface PARAMS ((int, tree, tree));
75 static tree find_field PARAMS ((tree, tree));
76 static tree lookup_field_wrapper PARAMS ((tree, tree));
77 static int duplicate_declaration_error_p PARAMS ((tree, tree, tree));
78 static void register_fields PARAMS ((int, tree, tree));
79 static tree parser_qualified_classname PARAMS ((tree));
80 static int parser_check_super PARAMS ((tree, tree, tree));
81 static int parser_check_super_interface PARAMS ((tree, tree, tree));
82 static void check_modifiers_consistency PARAMS ((int));
83 static tree lookup_cl PARAMS ((tree));
84 static tree lookup_java_method2 PARAMS ((tree, tree, int));
85 static tree method_header PARAMS ((int, tree, tree, tree));
86 static void fix_method_argument_names PARAMS ((tree ,tree));
87 static tree method_declarator PARAMS ((tree, tree));
88 static void parse_warning_context PARAMS ((tree cl, const char *msg, ...))
89 ATTRIBUTE_PRINTF_2;
90 static void issue_warning_error_from_context PARAMS ((tree, const char *msg, va_list));
91 static void parse_ctor_invocation_error PARAMS ((void));
92 static tree parse_jdk1_1_error PARAMS ((const char *));
93 static void complete_class_report_errors PARAMS ((jdep *));
94 static int process_imports PARAMS ((void));
95 static void read_import_dir PARAMS ((tree));
96 static int find_in_imports_on_demand PARAMS ((tree));
97 static int find_in_imports PARAMS ((tree));
98 static int check_pkg_class_access PARAMS ((tree, tree));
99 static tree resolve_package PARAMS ((tree, tree *));
100 static tree lookup_package_type PARAMS ((const char *, int));
101 static tree lookup_package_type_and_set_next PARAMS ((const char *, int, tree *));
102 static tree resolve_class PARAMS ((tree, tree, tree));
103 static void declare_local_variables PARAMS ((int, tree, tree));
104 static void source_start_java_method PARAMS ((tree));
105 static void source_end_java_method PARAMS ((void));
106 static void expand_start_java_method PARAMS ((tree));
107 static tree find_name_in_single_imports PARAMS ((tree));
108 static void check_abstract_method_header PARAMS ((tree));
109 static tree lookup_java_interface_method2 PARAMS ((tree, tree));
110 static tree resolve_expression_name PARAMS ((tree, tree *));
111 static tree maybe_create_class_interface_decl PARAMS ((tree, tree, tree));
112 static int check_class_interface_creation PARAMS ((int, int, tree,
113 tree, tree, tree));
114 static tree patch_method_invocation PARAMS ((tree, tree, tree,
115 int *, tree *));
116 static int breakdown_qualified PARAMS ((tree *, tree *, tree));
117 static tree resolve_and_layout PARAMS ((tree, tree));
118 static tree resolve_no_layout PARAMS ((tree, tree));
119 static int invocation_mode PARAMS ((tree, int));
120 static tree find_applicable_accessible_methods_list PARAMS ((int, tree,
121 tree, tree));
122 static void search_applicable_methods_list PARAMS ((int, tree, tree, tree,
123 tree *, tree *));
124 static tree find_most_specific_methods_list PARAMS ((tree));
125 static int argument_types_convertible PARAMS ((tree, tree));
126 static tree patch_invoke PARAMS ((tree, tree, tree));
127 static tree lookup_method_invoke PARAMS ((int, tree, tree, tree, tree));
128 static tree register_incomplete_type PARAMS ((int, tree, tree, tree));
129 static tree obtain_incomplete_type PARAMS ((tree));
130 static tree java_complete_lhs PARAMS ((tree));
131 static tree java_complete_tree PARAMS ((tree));
132 static int java_pre_expand_clinit PARAMS ((tree));
133 static void java_complete_expand_method PARAMS ((tree));
134 static int unresolved_type_p PARAMS ((tree, tree *));
135 static void create_jdep_list PARAMS ((struct parser_ctxt *));
136 static tree build_expr_block PARAMS ((tree, tree));
137 static tree enter_block PARAMS ((void));
138 static tree enter_a_block PARAMS ((tree));
139 static tree exit_block PARAMS ((void));
140 static tree lookup_name_in_blocks PARAMS ((tree));
141 static void maybe_absorb_scoping_blocks PARAMS ((void));
142 static tree build_method_invocation PARAMS ((tree, tree));
143 static tree build_new_invocation PARAMS ((tree, tree));
144 static tree build_assignment PARAMS ((int, int, tree, tree));
145 static tree build_binop PARAMS ((enum tree_code, int, tree, tree));
146 static int check_final_assignment PARAMS ((tree ,tree));
147 static tree patch_assignment PARAMS ((tree, tree, tree ));
148 static tree patch_binop PARAMS ((tree, tree, tree));
149 static tree build_unaryop PARAMS ((int, int, tree));
150 static tree build_incdec PARAMS ((int, int, tree, int));
151 static tree patch_unaryop PARAMS ((tree, tree));
152 static tree build_cast PARAMS ((int, tree, tree));
153 static tree build_null_of_type PARAMS ((tree));
154 static tree patch_cast PARAMS ((tree, tree));
155 static int valid_ref_assignconv_cast_p PARAMS ((tree, tree, int));
156 static int valid_builtin_assignconv_identity_widening_p PARAMS ((tree, tree));
157 static int valid_cast_to_p PARAMS ((tree, tree));
158 static int valid_method_invocation_conversion_p PARAMS ((tree, tree));
159 static tree try_builtin_assignconv PARAMS ((tree, tree, tree));
160 static tree try_reference_assignconv PARAMS ((tree, tree));
161 static tree build_unresolved_array_type PARAMS ((tree));
162 static tree build_array_from_name PARAMS ((tree, tree, tree, tree *));
163 static tree build_array_ref PARAMS ((int, tree, tree));
164 static tree patch_array_ref PARAMS ((tree));
165 static tree make_qualified_name PARAMS ((tree, tree, int));
166 static tree merge_qualified_name PARAMS ((tree, tree));
167 static tree make_qualified_primary PARAMS ((tree, tree, int));
168 static int resolve_qualified_expression_name PARAMS ((tree, tree *,
169 tree *, tree *));
170 static void qualify_ambiguous_name PARAMS ((tree));
171 static void maybe_generate_clinit PARAMS ((void));
172 static tree resolve_field_access PARAMS ((tree, tree *, tree *));
173 static tree build_newarray_node PARAMS ((tree, tree, int));
174 static tree patch_newarray PARAMS ((tree));
175 static tree resolve_type_during_patch PARAMS ((tree));
176 static tree build_this PARAMS ((int));
177 static tree build_return PARAMS ((int, tree));
178 static tree patch_return PARAMS ((tree));
179 static tree maybe_access_field PARAMS ((tree, tree, tree));
180 static int complete_function_arguments PARAMS ((tree));
181 static int check_for_static_method_reference PARAMS ((tree, tree, tree, tree, tree));
182 static int not_accessible_p PARAMS ((tree, tree, int));
183 static void check_deprecation PARAMS ((tree, tree));
184 static int class_in_current_package PARAMS ((tree));
185 static tree build_if_else_statement PARAMS ((int, tree, tree, tree));
186 static tree patch_if_else_statement PARAMS ((tree));
187 static tree add_stmt_to_compound PARAMS ((tree, tree, tree));
188 static tree add_stmt_to_block PARAMS ((tree, tree, tree));
189 static tree patch_exit_expr PARAMS ((tree));
190 static tree build_labeled_block PARAMS ((int, tree));
191 static tree finish_labeled_statement PARAMS ((tree, tree));
192 static tree build_bc_statement PARAMS ((int, int, tree));
193 static tree patch_bc_statement PARAMS ((tree));
194 static tree patch_loop_statement PARAMS ((tree));
195 static tree build_new_loop PARAMS ((tree));
196 static tree build_loop_body PARAMS ((int, tree, int));
197 static tree finish_loop_body PARAMS ((int, tree, tree, int));
198 static tree build_debugable_stmt PARAMS ((int, tree));
199 static tree finish_for_loop PARAMS ((int, tree, tree, tree));
200 static tree patch_switch_statement PARAMS ((tree));
201 static tree string_constant_concatenation PARAMS ((tree, tree));
202 static tree build_string_concatenation PARAMS ((tree, tree));
203 static tree patch_string_cst PARAMS ((tree));
204 static tree patch_string PARAMS ((tree));
205 static tree build_try_statement PARAMS ((int, tree, tree));
206 static tree build_try_finally_statement PARAMS ((int, tree, tree));
207 static tree patch_try_statement PARAMS ((tree));
208 static tree patch_synchronized_statement PARAMS ((tree, tree));
209 static tree patch_throw_statement PARAMS ((tree, tree));
210 static void check_thrown_exceptions PARAMS ((int, tree));
211 static int check_thrown_exceptions_do PARAMS ((tree));
212 static void purge_unchecked_exceptions PARAMS ((tree));
213 static void check_throws_clauses PARAMS ((tree, tree, tree));
214 static void finish_method_declaration PARAMS ((tree));
215 static tree build_super_invocation PARAMS ((tree));
216 static int verify_constructor_circularity PARAMS ((tree, tree));
217 static char *constructor_circularity_msg PARAMS ((tree, tree));
218 static tree build_this_super_qualified_invocation PARAMS ((int, tree, tree,
219 int, int));
220 static const char *get_printable_method_name PARAMS ((tree));
221 static tree patch_conditional_expr PARAMS ((tree, tree, tree));
222 static void maybe_generate_finit PARAMS ((void));
223 static void fix_constructors PARAMS ((tree));
224 static int verify_constructor_super PARAMS ((void));
225 static tree create_artificial_method PARAMS ((tree, int, tree, tree, tree));
226 static void start_artificial_method_body PARAMS ((tree));
227 static void end_artificial_method_body PARAMS ((tree));
228 static int check_method_redefinition PARAMS ((tree, tree));
229 static int reset_method_name PARAMS ((tree));
230 static void java_check_regular_methods PARAMS ((tree));
231 static void java_check_abstract_methods PARAMS ((tree));
232 static tree maybe_build_primttype_type_ref PARAMS ((tree, tree));
233 static void unreachable_stmt_error PARAMS ((tree));
234 static tree find_expr_with_wfl PARAMS ((tree));
235 static void missing_return_error PARAMS ((tree));
236 static tree build_new_array_init PARAMS ((int, tree));
237 static tree patch_new_array_init PARAMS ((tree, tree));
238 static tree maybe_build_array_element_wfl PARAMS ((tree));
239 static int array_constructor_check_entry PARAMS ((tree, tree));
240 static const char *purify_type_name PARAMS ((const char *));
241 static tree fold_constant_for_init PARAMS ((tree, tree));
242 static tree strip_out_static_field_access_decl PARAMS ((tree));
243 static jdeplist *reverse_jdep_list PARAMS ((struct parser_ctxt *));
244 static void static_ref_err PARAMS ((tree, tree, tree));
245 static void parser_add_interface PARAMS ((tree, tree, tree));
246 static void add_superinterfaces PARAMS ((tree, tree));
247 static tree jdep_resolve_class PARAMS ((jdep *));
248 static int note_possible_classname PARAMS ((const char *, int));
249 static void java_complete_expand_methods PARAMS ((void));
250 static void java_expand_finals PARAMS ((void));
251 static tree cut_identifier_in_qualified PARAMS ((tree));
252 static tree java_stabilize_reference PARAMS ((tree));
253 static tree do_unary_numeric_promotion PARAMS ((tree));
254 static char * operator_string PARAMS ((tree));
255 static tree do_merge_string_cste PARAMS ((tree, const char *, int, int));
256 static tree merge_string_cste PARAMS ((tree, tree, int));
257 static tree java_refold PARAMS ((tree));
258 static int java_decl_equiv PARAMS ((tree, tree));
259 static int binop_compound_p PARAMS ((enum tree_code));
260 static tree search_loop PARAMS ((tree));
261 static int labeled_block_contains_loop_p PARAMS ((tree, tree));
262 static void check_abstract_method_definitions PARAMS ((int, tree, tree));
263 static void java_check_abstract_method_definitions PARAMS ((tree));
264 static void java_debug_context_do PARAMS ((int));
265
266 /* Number of error found so far. */
267 int java_error_count;
268 /* Number of warning found so far. */
269 int java_warning_count;
270 /* Tell when not to fold, when doing xrefs */
271 int do_not_fold;
272
273 /* The current parser context */
274 struct parser_ctxt *ctxp;
275
276 /* List of things that were analyzed for which code will be generated */
277 static struct parser_ctxt *ctxp_for_generation = NULL;
278
279 /* binop_lookup maps token to tree_code. It is used where binary
280 operations are involved and required by the parser. RDIV_EXPR
281 covers both integral/floating point division. The code is changed
282 once the type of both operator is worked out. */
283
284 static enum tree_code binop_lookup[19] =
285 {
286 PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
287 LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
288 BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
289 TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
290 EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
291 };
292 #define BINOP_LOOKUP(VALUE) \
293 binop_lookup [((VALUE) - PLUS_TK)% \
294 (sizeof (binop_lookup) / sizeof (binop_lookup[0]))]
295
296 /* This is the end index for binary operators that can also be used
297 in compound assignements. */
298 #define BINOP_COMPOUND_CANDIDATES 11
299
300 /* Fake WFL used to report error message. It is initialized once if
301 needed and reused with it's location information is overriden. */
302 tree wfl_operator = NULL_TREE;
303
304 /* The "$L" identifier we use to create labels. */
305 static tree label_id = NULL_TREE;
306
307 /* The "StringBuffer" identifier used for the String `+' operator. */
308 static tree wfl_string_buffer = NULL_TREE;
309
310 /* The "append" identifier used for String `+' operator. */
311 static tree wfl_append = NULL_TREE;
312
313 /* The "toString" identifier used for String `+' operator. */
314 static tree wfl_to_string = NULL_TREE;
315
316 /* The "java.lang" import qualified name. */
317 static tree java_lang_id = NULL_TREE;
318
319 /* The "java.lang.Cloneable" qualified name. */
320 static tree java_lang_cloneable = NULL_TREE;
321
322 /* Context and flag for static blocks */
323 static tree current_static_block = NULL_TREE;
324
325 /* The list of all packages we've seen so far */
326 static tree package_list = NULL_TREE;
327
328 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
329 line and point it out. */
330 /* Should point out the one that don't fit. ASCII/unicode, going
331 backward. FIXME */
332
333 #define check_modifiers(__message, __value, __mask) do { \
334 if ((__value) & ~(__mask)) \
335 { \
336 int i, remainder = (__value) & ~(__mask); \
337 for (i = 0; i <= 10; i++) \
338 if ((1 << i) & remainder) \
339 parse_error_context (ctxp->modifier_ctx [i], (__message), \
340 java_accstring_lookup (1 << i)); \
341 } \
342 } while (0)
343
344 %}
345
346 %union {
347 tree node;
348 int sub_token;
349 struct {
350 int token;
351 int location;
352 } operator;
353 int value;
354 }
355
356 %{
357 #include "lex.c"
358 %}
359
360 %pure_parser
361
362 /* Things defined here have to match the order of what's in the
363 binop_lookup table. */
364
365 %token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
366 %token LS_TK SRS_TK ZRS_TK
367 %token AND_TK XOR_TK OR_TK
368 %token BOOL_AND_TK BOOL_OR_TK
369 %token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
370
371 /* This maps to the same binop_lookup entry than the token above */
372
373 %token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
374 %token REM_ASSIGN_TK
375 %token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
376 %token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
377
378
379 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
380
381 %token PUBLIC_TK PRIVATE_TK PROTECTED_TK
382 %token STATIC_TK FINAL_TK SYNCHRONIZED_TK
383 %token VOLATILE_TK TRANSIENT_TK NATIVE_TK
384 %token PAD_TK ABSTRACT_TK MODIFIER_TK
385
386 /* Keep those two in order, too */
387 %token DECR_TK INCR_TK
388
389 /* From now one, things can be in any order */
390
391 %token DEFAULT_TK IF_TK THROW_TK
392 %token BOOLEAN_TK DO_TK IMPLEMENTS_TK
393 %token THROWS_TK BREAK_TK IMPORT_TK
394 %token ELSE_TK INSTANCEOF_TK RETURN_TK
395 %token VOID_TK CATCH_TK INTERFACE_TK
396 %token CASE_TK EXTENDS_TK FINALLY_TK
397 %token SUPER_TK WHILE_TK CLASS_TK
398 %token SWITCH_TK CONST_TK TRY_TK
399 %token FOR_TK NEW_TK CONTINUE_TK
400 %token GOTO_TK PACKAGE_TK THIS_TK
401
402 %token BYTE_TK SHORT_TK INT_TK LONG_TK
403 %token CHAR_TK INTEGRAL_TK
404
405 %token FLOAT_TK DOUBLE_TK FP_TK
406
407 %token ID_TK
408
409 %token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
410
411 %token ASSIGN_ANY_TK ASSIGN_TK
412 %token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
413
414 %token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
415 %token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
416
417 %type <value> modifiers MODIFIER_TK final
418
419 %type <node> super ID_TK identifier
420 %type <node> name simple_name qualified_name
421 %type <node> class_declaration type_declaration compilation_unit
422 field_declaration method_declaration extends_interfaces
423 interfaces interface_type_list
424 interface_declaration class_member_declaration
425 import_declarations package_declaration
426 type_declarations interface_body
427 interface_member_declaration constant_declaration
428 interface_member_declarations interface_type
429 abstract_method_declaration interface_type_list
430 %type <node> class_body_declaration class_member_declaration
431 static_initializer constructor_declaration block
432 %type <node> class_body_declarations constructor_header
433 %type <node> class_or_interface_type class_type class_type_list
434 constructor_declarator explicit_constructor_invocation
435 %type <node> dim_expr dim_exprs this_or_super throws
436
437 %type <node> variable_declarator_id variable_declarator
438 variable_declarators variable_initializer
439 variable_initializers constructor_body
440 array_initializer
441
442 %type <node> class_body block_end constructor_block_end
443 %type <node> statement statement_without_trailing_substatement
444 labeled_statement if_then_statement label_decl
445 if_then_else_statement while_statement for_statement
446 statement_nsi labeled_statement_nsi do_statement
447 if_then_else_statement_nsi while_statement_nsi
448 for_statement_nsi statement_expression_list for_init
449 for_update statement_expression expression_statement
450 primary_no_new_array expression primary
451 array_creation_expression array_type
452 class_instance_creation_expression field_access
453 method_invocation array_access something_dot_new
454 argument_list postfix_expression while_expression
455 post_increment_expression post_decrement_expression
456 unary_expression_not_plus_minus unary_expression
457 pre_increment_expression pre_decrement_expression
458 unary_expression_not_plus_minus cast_expression
459 multiplicative_expression additive_expression
460 shift_expression relational_expression
461 equality_expression and_expression
462 exclusive_or_expression inclusive_or_expression
463 conditional_and_expression conditional_or_expression
464 conditional_expression assignment_expression
465 left_hand_side assignment for_header for_begin
466 constant_expression do_statement_begin empty_statement
467 switch_statement synchronized_statement throw_statement
468 try_statement switch_expression switch_block
469 catches catch_clause catch_clause_parameter finally
470 %type <node> return_statement break_statement continue_statement
471
472 %type <operator> ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
473 %type <operator> REM_ASSIGN_TK PLUS_ASSIGN_TK MINUS_ASSIGN_TK
474 %type <operator> LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
475 %type <operator> AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
476 %type <operator> ASSIGN_ANY_TK assignment_operator
477 %token <operator> EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
478 %token <operator> BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
479 %token <operator> DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
480 %token <operator> NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
481 %token <operator> OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
482 %type <operator> THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
483 %type <operator> CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
484
485 %type <node> method_body
486
487 %type <node> literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
488 STRING_LIT_TK NULL_TK VOID_TK
489
490 %type <node> IF_TK WHILE_TK FOR_TK
491
492 %type <node> formal_parameter_list formal_parameter
493 method_declarator method_header
494
495 %type <node> primitive_type reference_type type
496 BOOLEAN_TK INTEGRAL_TK FP_TK
497
498 %%
499 /* 19.2 Production from 2.3: The Syntactic Grammar */
500 goal:
501 compilation_unit
502 {}
503 ;
504
505 /* 19.3 Productions from 3: Lexical structure */
506 literal:
507 INT_LIT_TK
508 | FP_LIT_TK
509 | BOOL_LIT_TK
510 | CHAR_LIT_TK
511 | STRING_LIT_TK
512 | NULL_TK
513 ;
514
515 /* 19.4 Productions from 4: Types, Values and Variables */
516 type:
517 primitive_type
518 | reference_type
519 ;
520
521 primitive_type:
522 INTEGRAL_TK
523 | FP_TK
524 | BOOLEAN_TK
525 ;
526
527 reference_type:
528 class_or_interface_type
529 | array_type
530 ;
531
532 class_or_interface_type:
533 name
534 ;
535
536 class_type:
537 class_or_interface_type /* Default rule */
538 ;
539
540 interface_type:
541 class_or_interface_type
542 ;
543
544 array_type:
545 primitive_type OSB_TK CSB_TK
546 {
547 $$ = build_java_array_type ($1, -1);
548 CLASS_LOADED_P ($$) = 1;
549 }
550 | name OSB_TK CSB_TK
551 { $$ = build_unresolved_array_type ($1); }
552 | array_type OSB_TK CSB_TK
553 { $$ = build_unresolved_array_type ($1); }
554 | primitive_type OSB_TK error
555 {RULE ("']' expected"); RECOVER;}
556 | array_type OSB_TK error
557 {RULE ("']' expected"); RECOVER;}
558 ;
559
560 /* 19.5 Productions from 6: Names */
561 name:
562 simple_name /* Default rule */
563 | qualified_name /* Default rule */
564 ;
565
566 simple_name:
567 identifier /* Default rule */
568 ;
569
570 qualified_name:
571 name DOT_TK identifier
572 { $$ = make_qualified_name ($1, $3, $2.location); }
573 ;
574
575 identifier:
576 ID_TK
577 ;
578
579 /* 19.6: Production from 7: Packages */
580 compilation_unit:
581 {$$ = NULL;}
582 | package_declaration
583 | import_declarations
584 | type_declarations
585 | package_declaration import_declarations
586 | package_declaration type_declarations
587 | import_declarations type_declarations
588 | package_declaration import_declarations type_declarations
589 ;
590
591 import_declarations:
592 import_declaration
593 {
594 $$ = NULL;
595 }
596 | import_declarations import_declaration
597 {
598 $$ = NULL;
599 }
600 ;
601
602 type_declarations:
603 type_declaration
604 | type_declarations type_declaration
605 ;
606
607 package_declaration:
608 PACKAGE_TK name SC_TK
609 {
610 ctxp->package = EXPR_WFL_NODE ($2);
611 package_list = tree_cons (ctxp->package, NULL, package_list);
612 }
613 | PACKAGE_TK error
614 {yyerror ("Missing name"); RECOVER;}
615 | PACKAGE_TK name error
616 {yyerror ("';' expected"); RECOVER;}
617 ;
618
619 import_declaration:
620 single_type_import_declaration
621 | type_import_on_demand_declaration
622 ;
623
624 single_type_import_declaration:
625 IMPORT_TK name SC_TK
626 {
627 tree name = EXPR_WFL_NODE ($2), node, last_name;
628 int i = IDENTIFIER_LENGTH (name)-1;
629 const char *last = &IDENTIFIER_POINTER (name)[i];
630 while (last != IDENTIFIER_POINTER (name))
631 {
632 if (last [0] == '.')
633 break;
634 last--;
635 }
636 last_name = get_identifier (++last);
637 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
638 {
639 tree err = find_name_in_single_imports (last_name);
640 if (err && err != name)
641 parse_error_context
642 ($2, "Ambiguous class: `%s' and `%s'",
643 IDENTIFIER_POINTER (name),
644 IDENTIFIER_POINTER (err));
645 else
646 REGISTER_IMPORT ($2, last_name)
647 }
648 else
649 REGISTER_IMPORT ($2, last_name);
650 }
651 | IMPORT_TK error
652 {yyerror ("Missing name"); RECOVER;}
653 | IMPORT_TK name error
654 {yyerror ("';' expected"); RECOVER;}
655 ;
656
657 type_import_on_demand_declaration:
658 IMPORT_TK name DOT_TK MULT_TK SC_TK
659 {
660 tree name = EXPR_WFL_NODE ($2);
661 /* Don't import java.lang.* twice. */
662 if (name != java_lang_id)
663 {
664 tree node = build_tree_list ($2, NULL_TREE);
665 read_import_dir ($2);
666 TREE_CHAIN (node) = ctxp->import_demand_list;
667 ctxp->import_demand_list = node;
668 }
669 }
670 | IMPORT_TK name DOT_TK error
671 {yyerror ("'*' expected"); RECOVER;}
672 | IMPORT_TK name DOT_TK MULT_TK error
673 {yyerror ("';' expected"); RECOVER;}
674 ;
675
676 type_declaration:
677 class_declaration
678 {
679 maybe_generate_finit ();
680 maybe_generate_clinit ();
681 $$ = $1;
682 }
683 | interface_declaration
684 {
685 maybe_generate_clinit ();
686 $$ = $1;
687 }
688 | SC_TK
689 { $$ = NULL; }
690 | error
691 {
692 YYERROR_NOW;
693 yyerror ("Class or interface declaration expected");
694 }
695 ;
696
697 /* 19.7 Shortened from the original:
698 modifiers: modifier | modifiers modifier
699 modifier: any of public... */
700 modifiers:
701 MODIFIER_TK
702 {
703 $$ = (1 << $1);
704 }
705 | modifiers MODIFIER_TK
706 {
707 int acc = (1 << $2);
708 if ($$ & acc)
709 parse_error_context
710 (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
711 java_accstring_lookup (acc));
712 else
713 {
714 $$ |= acc;
715 }
716 }
717 ;
718
719 /* 19.8.1 Production from $8.1: Class Declaration */
720 class_declaration:
721 modifiers CLASS_TK identifier super interfaces
722 { create_class ($1, $3, $4, $5); }
723 class_body
724 {
725 $$ = $7;
726 }
727 | CLASS_TK identifier super interfaces
728 { create_class (0, $2, $3, $4); }
729 class_body
730 {
731 $$ = $6;
732 }
733 | modifiers CLASS_TK error
734 {yyerror ("Missing class name"); RECOVER;}
735 | CLASS_TK error
736 {yyerror ("Missing class name"); RECOVER;}
737 | CLASS_TK identifier error
738 {
739 if (!ctxp->class_err) yyerror ("'{' expected");
740 DRECOVER(class1);
741 }
742 | modifiers CLASS_TK identifier error
743 {if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER;}
744 ;
745
746 super:
747 { $$ = NULL; }
748 | EXTENDS_TK class_type
749 { $$ = $2; }
750 | EXTENDS_TK class_type error
751 {yyerror ("'{' expected"); ctxp->class_err=1;}
752 | EXTENDS_TK error
753 {yyerror ("Missing super class name"); ctxp->class_err=1;}
754 ;
755
756 interfaces:
757 { $$ = NULL_TREE; }
758 | IMPLEMENTS_TK interface_type_list
759 { $$ = $2; }
760 | IMPLEMENTS_TK error
761 {
762 ctxp->class_err=1;
763 yyerror ("Missing interface name");
764 }
765 ;
766
767 interface_type_list:
768 interface_type
769 {
770 ctxp->interface_number = 1;
771 $$ = build_tree_list ($1, NULL_TREE);
772 }
773 | interface_type_list C_TK interface_type
774 {
775 ctxp->interface_number++;
776 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
777 }
778 | interface_type_list C_TK error
779 {yyerror ("Missing interface name"); RECOVER;}
780 ;
781
782 class_body:
783 OCB_TK CCB_TK
784 {
785 /* Store the location of the `}' when doing xrefs */
786 if (flag_emit_xref)
787 DECL_END_SOURCE_LINE (ctxp->current_parsed_class) =
788 EXPR_WFL_ADD_COL ($2.location, 1);
789 $$ = ctxp->current_parsed_class;
790 }
791 | OCB_TK class_body_declarations CCB_TK
792 {
793 /* Store the location of the `}' when doing xrefs */
794 if (flag_emit_xref)
795 DECL_END_SOURCE_LINE (ctxp->current_parsed_class) =
796 EXPR_WFL_ADD_COL ($3.location, 1);
797 $$ = ctxp->current_parsed_class;
798 }
799 ;
800
801 class_body_declarations:
802 class_body_declaration
803 | class_body_declarations class_body_declaration
804 ;
805
806 class_body_declaration:
807 class_member_declaration
808 | static_initializer
809 | constructor_declaration
810 | block /* Added, JDK1.1, instance initializer */
811 { $$ = parse_jdk1_1_error ("instance initializer"); }
812 ;
813
814 class_member_declaration:
815 field_declaration
816 | field_declaration SC_TK
817 { $$ = $1; }
818 | method_declaration
819 | class_declaration /* Added, JDK1.1 inner classes */
820 { $$ = parse_jdk1_1_error ("inner classe declaration"); }
821 | interface_declaration /* Added, JDK1.1 inner classes */
822 { $$ = parse_jdk1_1_error ("inner interface declaration"); }
823 ;
824
825 /* 19.8.2 Productions from 8.3: Field Declarations */
826 field_declaration:
827 type variable_declarators SC_TK
828 { register_fields (0, $1, $2); }
829 | modifiers type variable_declarators SC_TK
830 {
831 check_modifiers
832 ("Illegal modifier `%s' for field declaration",
833 $1, FIELD_MODIFIERS);
834 check_modifiers_consistency ($1);
835 register_fields ($1, $2, $3);
836 }
837 ;
838
839 variable_declarators:
840 /* Should we use build_decl_list () instead ? FIXME */
841 variable_declarator /* Default rule */
842 | variable_declarators C_TK variable_declarator
843 { $$ = chainon ($1, $3); }
844 | variable_declarators C_TK error
845 {yyerror ("Missing term"); RECOVER;}
846 ;
847
848 variable_declarator:
849 variable_declarator_id
850 { $$ = build_tree_list ($1, NULL_TREE); }
851 | variable_declarator_id ASSIGN_TK variable_initializer
852 {
853 if (java_error_count)
854 $3 = NULL_TREE;
855 $$ = build_tree_list
856 ($1, build_assignment ($2.token, $2.location, $1, $3));
857 }
858 | variable_declarator_id ASSIGN_TK error
859 {
860 yyerror ("Missing variable initializer");
861 $$ = build_tree_list ($1, NULL_TREE);
862 RECOVER;
863 }
864 | variable_declarator_id ASSIGN_TK variable_initializer error
865 {
866 yyerror ("';' expected");
867 $$ = build_tree_list ($1, NULL_TREE);
868 RECOVER;
869 }
870 ;
871
872 variable_declarator_id:
873 identifier
874 | variable_declarator_id OSB_TK CSB_TK
875 { $$ = build_unresolved_array_type ($1); }
876 | identifier error
877 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
878 | variable_declarator_id OSB_TK error
879 {yyerror ("']' expected"); DRECOVER(vdi);}
880 | variable_declarator_id CSB_TK error
881 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
882 ;
883
884 variable_initializer:
885 expression
886 | array_initializer
887 ;
888
889 /* 19.8.3 Productions from 8.4: Method Declarations */
890 method_declaration:
891 method_header
892 {
893 current_function_decl = $1;
894 source_start_java_method (current_function_decl);
895 }
896 method_body
897 { finish_method_declaration ($3); }
898 | method_header error
899 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
900 ;
901
902 method_header:
903 type method_declarator throws
904 { $$ = method_header (0, $1, $2, $3); }
905 | VOID_TK method_declarator throws
906 { $$ = method_header (0, void_type_node, $2, $3); }
907 | modifiers type method_declarator throws
908 { $$ = method_header ($1, $2, $3, $4); }
909 | modifiers VOID_TK method_declarator throws
910 { $$ = method_header ($1, void_type_node, $3, $4); }
911 | type error
912 {
913 yyerror ("Invalid method declaration, method name required");
914 RECOVER;
915 }
916 | modifiers type error
917 {RECOVER;}
918 | VOID_TK error
919 {yyerror ("Identifier expected"); RECOVER;}
920 | modifiers VOID_TK error
921 {yyerror ("Identifier expected"); RECOVER;}
922 | modifiers error
923 {
924 yyerror ("Invalid method declaration, return type required");
925 RECOVER;
926 }
927 ;
928
929 method_declarator:
930 identifier OP_TK CP_TK
931 { $$ = method_declarator ($1, NULL_TREE); }
932 | identifier OP_TK formal_parameter_list CP_TK
933 { $$ = method_declarator ($1, $3); }
934 | method_declarator OSB_TK CSB_TK
935 {
936 EXPR_WFL_LINECOL (wfl_operator) = $2.location;
937 TREE_PURPOSE ($1) =
938 build_unresolved_array_type (TREE_PURPOSE ($1));
939 parse_warning_context
940 (wfl_operator,
941 "Discouraged form of returned type specification");
942 }
943 | identifier OP_TK error
944 {yyerror ("')' expected"); DRECOVER(method_declarator);}
945 | method_declarator OSB_TK error
946 {yyerror ("']' expected"); RECOVER;}
947 ;
948
949 formal_parameter_list:
950 formal_parameter
951 {
952 ctxp->formal_parameter_number = 1;
953 }
954 | formal_parameter_list C_TK formal_parameter
955 {
956 ctxp->formal_parameter_number += 1;
957 $$ = chainon ($1, $3);
958 }
959 | formal_parameter_list C_TK error
960 {yyerror ("Missing formal parameter term"); RECOVER;}
961 ;
962
963 formal_parameter:
964 type variable_declarator_id
965 {
966 $$ = build_tree_list ($2, $1);
967 }
968 | final type variable_declarator_id /* Added, JDK1.1 final parms */
969 {
970 parse_jdk1_1_error ("final parameters");
971 $$ = build_tree_list ($3, $2);
972 }
973 | type error
974 {
975 yyerror ("Missing identifier"); RECOVER;
976 $$ = NULL_TREE;
977 }
978 | final type error
979 {
980 yyerror ("Missing identifier"); RECOVER;
981 $$ = NULL_TREE;
982 }
983 ;
984
985 final:
986 modifiers
987 {
988 check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
989 $1, ACC_FINAL);
990 if ($1 != ACC_FINAL)
991 MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
992 }
993 ;
994
995 throws:
996 { $$ = NULL_TREE; }
997 | THROWS_TK class_type_list
998 { $$ = $2; }
999 | THROWS_TK error
1000 {yyerror ("Missing class type term"); RECOVER;}
1001 ;
1002
1003 class_type_list:
1004 class_type
1005 { $$ = build_tree_list ($1, $1); }
1006 | class_type_list C_TK class_type
1007 { $$ = tree_cons ($3, $3, $1); }
1008 | class_type_list C_TK error
1009 {yyerror ("Missing class type term"); RECOVER;}
1010 ;
1011
1012 method_body:
1013 block
1014 | block SC_TK
1015 | SC_TK
1016 { $$ = NULL_TREE; } /* Probably not the right thing to do. */
1017 ;
1018
1019 /* 19.8.4 Productions from 8.5: Static Initializers */
1020 static_initializer:
1021 static block
1022 {
1023 TREE_CHAIN ($2) = ctxp->static_initialized;
1024 ctxp->static_initialized = $2;
1025 }
1026 | static block SC_TK /* Shouldn't be here. FIXME */
1027 {
1028 TREE_CHAIN ($2) = ctxp->static_initialized;
1029 ctxp->static_initialized = $2;
1030 }
1031 ;
1032
1033 static: /* Test lval.sub_token here */
1034 MODIFIER_TK
1035 {
1036 SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1037 }
1038 ;
1039
1040 /* 19.8.5 Productions from 8.6: Constructor Declarations */
1041 constructor_declaration:
1042 constructor_header
1043 {
1044 current_function_decl = $1;
1045 source_start_java_method (current_function_decl);
1046 }
1047 constructor_body
1048 { finish_method_declaration ($3); }
1049 ;
1050
1051 constructor_header:
1052 constructor_declarator throws
1053 { $$ = method_header (0, NULL_TREE, $1, $2); }
1054 | modifiers constructor_declarator throws
1055 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1056 ;
1057
1058 constructor_declarator:
1059 simple_name OP_TK CP_TK
1060 { $$ = method_declarator ($1, NULL_TREE); }
1061 | simple_name OP_TK formal_parameter_list CP_TK
1062 { $$ = method_declarator ($1, $3); }
1063 ;
1064
1065 constructor_body:
1066 /* Unlike regular method, we always need a complete (empty)
1067 body so we can safely perform all the required code
1068 addition (super invocation and field initialization) */
1069 block_begin constructor_block_end
1070 {
1071 BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1072 $$ = $2;
1073 }
1074 | block_begin explicit_constructor_invocation constructor_block_end
1075 { $$ = $3; }
1076 | block_begin block_statements constructor_block_end
1077 { $$ = $3; }
1078 | block_begin explicit_constructor_invocation block_statements constructor_block_end
1079 { $$ = $4; }
1080 ;
1081
1082 constructor_block_end:
1083 block_end
1084 | block_end SC_TK
1085
1086 /* Error recovery for that rule moved down expression_statement: rule. */
1087 explicit_constructor_invocation:
1088 this_or_super OP_TK CP_TK SC_TK
1089 {
1090 $$ = build_method_invocation ($1, NULL_TREE);
1091 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1092 $$ = java_method_add_stmt (current_function_decl, $$);
1093 }
1094 | this_or_super OP_TK argument_list CP_TK SC_TK
1095 {
1096 $$ = build_method_invocation ($1, $3);
1097 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1098 $$ = java_method_add_stmt (current_function_decl, $$);
1099 }
1100 /* Added, JDK1.1 inner classes. Modified because the rule
1101 'primary' couldn't work. */
1102 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1103 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1104 | name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1105 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1106 ;
1107
1108 this_or_super: /* Added, simplifies error diagnostics */
1109 THIS_TK
1110 {
1111 tree wfl = build_wfl_node (this_identifier_node);
1112 EXPR_WFL_LINECOL (wfl) = $1.location;
1113 $$ = wfl;
1114 }
1115 | SUPER_TK
1116 {
1117 tree wfl = build_wfl_node (super_identifier_node);
1118 EXPR_WFL_LINECOL (wfl) = $1.location;
1119 $$ = wfl;
1120 }
1121 ;
1122
1123 /* 19.9 Productions from 9: Interfaces */
1124 /* 19.9.1 Productions from 9.1: Interfaces Declarations */
1125 interface_declaration:
1126 INTERFACE_TK identifier
1127 { create_interface (0, $2, NULL_TREE); }
1128 interface_body
1129 {
1130 $$ = $4;
1131 }
1132 | modifiers INTERFACE_TK identifier
1133 { create_interface ($1, $3, NULL_TREE); }
1134 interface_body
1135 {
1136 $$ = $5;
1137 }
1138 | INTERFACE_TK identifier extends_interfaces
1139 { create_interface (0, $2, $3); }
1140 interface_body
1141 {
1142 $$ = $5;
1143 }
1144 | modifiers INTERFACE_TK identifier extends_interfaces
1145 { create_interface ($1, $3, $4); }
1146 interface_body
1147 {
1148 $$ = $6;
1149 }
1150 | INTERFACE_TK identifier error
1151 {yyerror ("'{' expected"); RECOVER;}
1152 | modifiers INTERFACE_TK identifier error
1153 {yyerror ("'{' expected"); RECOVER;}
1154 ;
1155
1156 extends_interfaces:
1157 EXTENDS_TK interface_type
1158 {
1159 ctxp->interface_number = 1;
1160 $$ = build_tree_list ($2, NULL_TREE);
1161 }
1162 | extends_interfaces C_TK interface_type
1163 {
1164 ctxp->interface_number++;
1165 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1166 }
1167 | EXTENDS_TK error
1168 {yyerror ("Invalid interface type"); RECOVER;}
1169 | extends_interfaces C_TK error
1170 {yyerror ("Missing term"); RECOVER;}
1171 ;
1172
1173 interface_body:
1174 OCB_TK CCB_TK
1175 { $$ = NULL_TREE; }
1176 | OCB_TK interface_member_declarations CCB_TK
1177 { $$ = NULL_TREE; }
1178 ;
1179
1180 interface_member_declarations:
1181 interface_member_declaration
1182 | interface_member_declarations interface_member_declaration
1183 ;
1184
1185 interface_member_declaration:
1186 constant_declaration
1187 | abstract_method_declaration
1188 | class_declaration /* Added, JDK1.1 inner classes */
1189 { $$ = parse_jdk1_1_error ("inner class declaration"); }
1190 | interface_declaration /* Added, JDK1.1 inner classes */
1191 { $$ = parse_jdk1_1_error ("inner interface declaration"); }
1192 ;
1193
1194 constant_declaration:
1195 field_declaration
1196 ;
1197
1198 abstract_method_declaration:
1199 method_header SC_TK
1200 {
1201 check_abstract_method_header ($1);
1202 current_function_decl = NULL_TREE; /* FIXME ? */
1203 }
1204 | method_header error
1205 {yyerror ("';' expected"); RECOVER;}
1206 ;
1207
1208 /* 19.10 Productions from 10: Arrays */
1209 array_initializer:
1210 OCB_TK CCB_TK
1211 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1212 | OCB_TK variable_initializers CCB_TK
1213 { $$ = build_new_array_init ($1.location, $2); }
1214 | OCB_TK variable_initializers C_TK CCB_TK
1215 { $$ = build_new_array_init ($1.location, $2); }
1216 ;
1217
1218 variable_initializers:
1219 variable_initializer
1220 {
1221 $$ = tree_cons (maybe_build_array_element_wfl ($1),
1222 $1, NULL_TREE);
1223 }
1224 | variable_initializers C_TK variable_initializer
1225 {
1226 $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1227 }
1228 | variable_initializers C_TK error
1229 {yyerror ("Missing term"); RECOVER;}
1230 ;
1231
1232 /* 19.11 Production from 14: Blocks and Statements */
1233 block:
1234 OCB_TK CCB_TK
1235 {
1236 /* Store the location of the `}' when doing xrefs */
1237 if (current_function_decl && flag_emit_xref)
1238 DECL_END_SOURCE_LINE (current_function_decl) =
1239 EXPR_WFL_ADD_COL ($2.location, 1);
1240 $$ = empty_stmt_node;
1241 }
1242 | block_begin block_statements block_end
1243 { $$ = $3; }
1244 ;
1245
1246 block_begin:
1247 OCB_TK
1248 { enter_block (); }
1249 ;
1250
1251 block_end:
1252 CCB_TK
1253 {
1254 maybe_absorb_scoping_blocks ();
1255 /* Store the location of the `}' when doing xrefs */
1256 if (current_function_decl && flag_emit_xref)
1257 DECL_END_SOURCE_LINE (current_function_decl) =
1258 EXPR_WFL_ADD_COL ($1.location, 1);
1259 $$ = exit_block ();
1260 }
1261 ;
1262
1263 block_statements:
1264 block_statement
1265 | block_statements block_statement
1266 ;
1267
1268 block_statement:
1269 local_variable_declaration_statement
1270 | statement
1271 { java_method_add_stmt (current_function_decl, $1); }
1272 | class_declaration /* Added, JDK1.1 inner classes */
1273 { parse_jdk1_1_error ("inner class declaration"); }
1274 ;
1275
1276 local_variable_declaration_statement:
1277 local_variable_declaration SC_TK /* Can't catch missing ';' here */
1278 ;
1279
1280 local_variable_declaration:
1281 type variable_declarators
1282 { declare_local_variables (0, $1, $2); }
1283 | final type variable_declarators /* Added, JDK1.1 final locals */
1284 { declare_local_variables ($1, $2, $3); }
1285 ;
1286
1287 statement:
1288 statement_without_trailing_substatement
1289 | labeled_statement
1290 | if_then_statement
1291 | if_then_else_statement
1292 | while_statement
1293 | for_statement
1294 { $$ = exit_block (); }
1295 ;
1296
1297 statement_nsi:
1298 statement_without_trailing_substatement
1299 | labeled_statement_nsi
1300 | if_then_else_statement_nsi
1301 | while_statement_nsi
1302 | for_statement_nsi
1303 { $$ = exit_block (); }
1304 ;
1305
1306 statement_without_trailing_substatement:
1307 block
1308 | empty_statement
1309 | expression_statement
1310 | switch_statement
1311 | do_statement
1312 | break_statement
1313 | continue_statement
1314 | return_statement
1315 | synchronized_statement
1316 | throw_statement
1317 | try_statement
1318 ;
1319
1320 empty_statement:
1321 SC_TK
1322 { $$ = empty_stmt_node; }
1323 ;
1324
1325 label_decl:
1326 identifier REL_CL_TK
1327 {
1328 $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1329 EXPR_WFL_NODE ($1));
1330 pushlevel (2);
1331 push_labeled_block ($$);
1332 PUSH_LABELED_BLOCK ($$);
1333 }
1334 ;
1335
1336 labeled_statement:
1337 label_decl statement
1338 { $$ = finish_labeled_statement ($1, $2); }
1339 | identifier error
1340 {yyerror ("':' expected"); RECOVER;}
1341 ;
1342
1343 labeled_statement_nsi:
1344 label_decl statement_nsi
1345 { $$ = finish_labeled_statement ($1, $2); }
1346 ;
1347
1348 /* We concentrate here a bunch of error handling rules that we couldn't write
1349 earlier, because expression_statement catches a missing ';'. */
1350 expression_statement:
1351 statement_expression SC_TK
1352 {
1353 /* We have a statement. Generate a WFL around it so
1354 we can debug it */
1355 $$ = build_expr_wfl ($1, input_filename, lineno, 0);
1356 /* We know we have a statement, so set the debug
1357 info to be eventually generate here. */
1358 $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1359 }
1360 | error SC_TK
1361 {
1362 if (ctxp->prevent_ese != lineno)
1363 yyerror ("Invalid expression statement");
1364 DRECOVER (expr_stmt);
1365 }
1366 | error OCB_TK
1367 {
1368 if (ctxp->prevent_ese != lineno)
1369 yyerror ("Invalid expression statement");
1370 DRECOVER (expr_stmt);
1371 }
1372 | error CCB_TK
1373 {
1374 if (ctxp->prevent_ese != lineno)
1375 yyerror ("Invalid expression statement");
1376 DRECOVER (expr_stmt);
1377 }
1378 | this_or_super OP_TK error
1379 {yyerror ("')' expected"); RECOVER;}
1380 | this_or_super OP_TK CP_TK error
1381 {
1382 parse_ctor_invocation_error ();
1383 RECOVER;
1384 }
1385 | this_or_super OP_TK argument_list error
1386 {yyerror ("')' expected"); RECOVER;}
1387 | this_or_super OP_TK argument_list CP_TK error
1388 {
1389 parse_ctor_invocation_error ();
1390 RECOVER;
1391 }
1392 | name DOT_TK SUPER_TK error
1393 {yyerror ("'(' expected"); RECOVER;}
1394 | name DOT_TK SUPER_TK OP_TK error
1395 {yyerror ("')' expected"); RECOVER;}
1396 | name DOT_TK SUPER_TK OP_TK argument_list error
1397 {yyerror ("')' expected"); RECOVER;}
1398 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1399 {yyerror ("';' expected"); RECOVER;}
1400 | name DOT_TK SUPER_TK OP_TK CP_TK error
1401 {yyerror ("';' expected"); RECOVER;}
1402 ;
1403
1404 statement_expression:
1405 assignment
1406 | pre_increment_expression
1407 | pre_decrement_expression
1408 | post_increment_expression
1409 | post_decrement_expression
1410 | method_invocation
1411 | class_instance_creation_expression
1412 ;
1413
1414 if_then_statement:
1415 IF_TK OP_TK expression CP_TK statement
1416 {
1417 $$ = build_if_else_statement ($2.location, $3,
1418 $5, NULL_TREE);
1419 }
1420 | IF_TK error
1421 {yyerror ("'(' expected"); RECOVER;}
1422 | IF_TK OP_TK error
1423 {yyerror ("Missing term"); RECOVER;}
1424 | IF_TK OP_TK expression error
1425 {yyerror ("')' expected"); RECOVER;}
1426 ;
1427
1428 if_then_else_statement:
1429 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1430 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1431 ;
1432
1433 if_then_else_statement_nsi:
1434 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1435 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1436 ;
1437
1438 switch_statement:
1439 switch_expression
1440 {
1441 enter_block ();
1442 }
1443 switch_block
1444 {
1445 /* Make into "proper list" of COMPOUND_EXPRs.
1446 I.e. make the last statment also have its own
1447 COMPOUND_EXPR. */
1448 maybe_absorb_scoping_blocks ();
1449 TREE_OPERAND ($1, 1) = exit_block ();
1450 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1451 }
1452 ;
1453
1454 switch_expression:
1455 SWITCH_TK OP_TK expression CP_TK
1456 {
1457 $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1458 EXPR_WFL_LINECOL ($$) = $2.location;
1459 }
1460 | SWITCH_TK error
1461 {yyerror ("'(' expected"); RECOVER;}
1462 | SWITCH_TK OP_TK error
1463 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1464 | SWITCH_TK OP_TK expression CP_TK error
1465 {yyerror ("'{' expected"); RECOVER;}
1466 ;
1467
1468 /* Default assignment is there to avoid type node on switch_block
1469 node. */
1470
1471 switch_block:
1472 OCB_TK CCB_TK
1473 { $$ = NULL_TREE; }
1474 | OCB_TK switch_labels CCB_TK
1475 { $$ = NULL_TREE; }
1476 | OCB_TK switch_block_statement_groups CCB_TK
1477 { $$ = NULL_TREE; }
1478 | OCB_TK switch_block_statement_groups switch_labels CCB_TK
1479 { $$ = NULL_TREE; }
1480 ;
1481
1482 switch_block_statement_groups:
1483 switch_block_statement_group
1484 | switch_block_statement_groups switch_block_statement_group
1485 ;
1486
1487 switch_block_statement_group:
1488 switch_labels block_statements
1489 ;
1490
1491 switch_labels:
1492 switch_label
1493 | switch_labels switch_label
1494 ;
1495
1496 switch_label:
1497 CASE_TK constant_expression REL_CL_TK
1498 {
1499 tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1500 EXPR_WFL_LINECOL (lab) = $1.location;
1501 java_method_add_stmt (current_function_decl, lab);
1502 }
1503 | DEFAULT_TK REL_CL_TK
1504 {
1505 tree lab = build1 (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1506 EXPR_WFL_LINECOL (lab) = $1.location;
1507 java_method_add_stmt (current_function_decl, lab);
1508 }
1509 | CASE_TK error
1510 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1511 | CASE_TK constant_expression error
1512 {yyerror ("':' expected"); RECOVER;}
1513 | DEFAULT_TK error
1514 {yyerror ("':' expected"); RECOVER;}
1515 ;
1516
1517 while_expression:
1518 WHILE_TK OP_TK expression CP_TK
1519 {
1520 tree body = build_loop_body ($2.location, $3, 0);
1521 $$ = build_new_loop (body);
1522 }
1523 ;
1524
1525 while_statement:
1526 while_expression statement
1527 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1528 | WHILE_TK error
1529 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1530 | WHILE_TK OP_TK error
1531 {yyerror ("Missing term and ')' expected"); RECOVER;}
1532 | WHILE_TK OP_TK expression error
1533 {yyerror ("')' expected"); RECOVER;}
1534 ;
1535
1536 while_statement_nsi:
1537 while_expression statement_nsi
1538 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1539 ;
1540
1541 do_statement_begin:
1542 DO_TK
1543 {
1544 tree body = build_loop_body (0, NULL_TREE, 1);
1545 $$ = build_new_loop (body);
1546 }
1547 /* Need error handing here. FIXME */
1548 ;
1549
1550 do_statement:
1551 do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1552 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1553 ;
1554
1555 for_statement:
1556 for_begin SC_TK expression SC_TK for_update CP_TK statement
1557 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7); }
1558 | for_begin SC_TK SC_TK for_update CP_TK statement
1559 {
1560 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1561 /* We have not condition, so we get rid of the EXIT_EXPR */
1562 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1563 empty_stmt_node;
1564 }
1565 | for_begin SC_TK error
1566 {yyerror ("Invalid control expression"); RECOVER;}
1567 | for_begin SC_TK expression SC_TK error
1568 {yyerror ("Invalid update expression"); RECOVER;}
1569 | for_begin SC_TK SC_TK error
1570 {yyerror ("Invalid update expression"); RECOVER;}
1571 ;
1572
1573 for_statement_nsi:
1574 for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1575 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1576 | for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1577 {
1578 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1579 /* We have not condition, so we get rid of the EXIT_EXPR */
1580 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1581 empty_stmt_node;
1582 }
1583 ;
1584
1585 for_header:
1586 FOR_TK OP_TK
1587 {
1588 /* This scope defined for local variable that may be
1589 defined within the scope of the for loop */
1590 enter_block ();
1591 }
1592 | FOR_TK error
1593 {yyerror ("'(' expected"); DRECOVER(for_1);}
1594 | FOR_TK OP_TK error
1595 {yyerror ("Invalid init statement"); RECOVER;}
1596 ;
1597
1598 for_begin:
1599 for_header for_init
1600 {
1601 /* We now declare the loop body. The loop is
1602 declared as a for loop. */
1603 tree body = build_loop_body (0, NULL_TREE, 0);
1604 $$ = build_new_loop (body);
1605 IS_FOR_LOOP_P ($$) = 1;
1606 /* The loop is added to the current block the for
1607 statement is defined within */
1608 java_method_add_stmt (current_function_decl, $$);
1609 }
1610 ;
1611 for_init: /* Can be empty */
1612 { $$ = empty_stmt_node; }
1613 | statement_expression_list
1614 {
1615 /* Init statement recorded within the previously
1616 defined block scope */
1617 $$ = java_method_add_stmt (current_function_decl, $1);
1618 }
1619 | local_variable_declaration
1620 {
1621 /* Local variable are recorded within the previously
1622 defined block scope */
1623 $$ = NULL_TREE;
1624 }
1625 | statement_expression_list error
1626 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1627 ;
1628
1629 for_update: /* Can be empty */
1630 {$$ = empty_stmt_node;}
1631 | statement_expression_list
1632 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1633 ;
1634
1635 statement_expression_list:
1636 statement_expression
1637 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1638 | statement_expression_list C_TK statement_expression
1639 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1640 | statement_expression_list C_TK error
1641 {yyerror ("Missing term"); RECOVER;}
1642 ;
1643
1644 break_statement:
1645 BREAK_TK SC_TK
1646 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1647 | BREAK_TK identifier SC_TK
1648 { $$ = build_bc_statement ($1.location, 1, $2); }
1649 | BREAK_TK error
1650 {yyerror ("Missing term"); RECOVER;}
1651 | BREAK_TK identifier error
1652 {yyerror ("';' expected"); RECOVER;}
1653 ;
1654
1655 continue_statement:
1656 CONTINUE_TK SC_TK
1657 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1658 | CONTINUE_TK identifier SC_TK
1659 { $$ = build_bc_statement ($1.location, 0, $2); }
1660 | CONTINUE_TK error
1661 {yyerror ("Missing term"); RECOVER;}
1662 | CONTINUE_TK identifier error
1663 {yyerror ("';' expected"); RECOVER;}
1664 ;
1665
1666 return_statement:
1667 RETURN_TK SC_TK
1668 { $$ = build_return ($1.location, NULL_TREE); }
1669 | RETURN_TK expression SC_TK
1670 { $$ = build_return ($1.location, $2); }
1671 | RETURN_TK error
1672 {yyerror ("Missing term"); RECOVER;}
1673 | RETURN_TK expression error
1674 {yyerror ("';' expected"); RECOVER;}
1675 ;
1676
1677 throw_statement:
1678 THROW_TK expression SC_TK
1679 {
1680 $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1681 EXPR_WFL_LINECOL ($$) = $1.location;
1682 }
1683 | THROW_TK error
1684 {yyerror ("Missing term"); RECOVER;}
1685 | THROW_TK expression error
1686 {yyerror ("';' expected"); RECOVER;}
1687 ;
1688
1689 synchronized_statement:
1690 synchronized OP_TK expression CP_TK block
1691 {
1692 $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1693 EXPR_WFL_LINECOL ($$) =
1694 EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1695 }
1696 | synchronized OP_TK expression CP_TK error
1697 {yyerror ("'{' expected"); RECOVER;}
1698 | synchronized error
1699 {yyerror ("'(' expected"); RECOVER;}
1700 | synchronized OP_TK error CP_TK
1701 {yyerror ("Missing term"); RECOVER;}
1702 | synchronized OP_TK error
1703 {yyerror ("Missing term"); RECOVER;}
1704 ;
1705
1706 synchronized:
1707 modifiers
1708 {
1709 check_modifiers (
1710 "Illegal modifier `%s'. Only `synchronized' was expected here",
1711 $1, ACC_SYNCHRONIZED);
1712 if ($1 != ACC_SYNCHRONIZED)
1713 MODIFIER_WFL (SYNCHRONIZED_TK) =
1714 build_wfl_node (NULL_TREE);
1715 }
1716 ;
1717
1718 try_statement:
1719 TRY_TK block catches
1720 { $$ = build_try_statement ($1.location, $2, $3); }
1721 | TRY_TK block finally
1722 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1723 | TRY_TK block catches finally
1724 { $$ = build_try_finally_statement
1725 ($1.location, build_try_statement ($1.location,
1726 $2, $3), $4);
1727 }
1728 | TRY_TK error
1729 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1730 ;
1731
1732 catches:
1733 catch_clause
1734 | catches catch_clause
1735 {
1736 TREE_CHAIN ($2) = $1;
1737 $$ = $2;
1738 }
1739 ;
1740
1741 catch_clause:
1742 catch_clause_parameter block
1743 {
1744 java_method_add_stmt (current_function_decl, $2);
1745 exit_block ();
1746 $$ = $1;
1747 }
1748
1749 catch_clause_parameter:
1750 CATCH_TK OP_TK formal_parameter CP_TK
1751 {
1752 /* We add a block to define a scope for
1753 formal_parameter (CCBP). The formal parameter is
1754 declared initialized by the appropriate function
1755 call */
1756 tree ccpb = enter_block ();
1757 tree init = build_assignment (ASSIGN_TK, $2.location,
1758 TREE_PURPOSE ($3),
1759 soft_exceptioninfo_call_node);
1760 declare_local_variables (0, TREE_VALUE ($3),
1761 build_tree_list (TREE_PURPOSE ($3),
1762 init));
1763 $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1764 EXPR_WFL_LINECOL ($$) = $1.location;
1765 }
1766 | CATCH_TK error
1767 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1768 | CATCH_TK OP_TK error
1769 {
1770 yyerror ("Missing term or ')' expected");
1771 RECOVER; $$ = NULL_TREE;
1772 }
1773 | CATCH_TK OP_TK error CP_TK /* That's for () */
1774 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1775 ;
1776
1777 finally:
1778 FINALLY_TK block
1779 { $$ = $2; }
1780 | FINALLY_TK error
1781 {yyerror ("'{' expected"); RECOVER; }
1782 ;
1783
1784 /* 19.12 Production from 15: Expressions */
1785 primary:
1786 primary_no_new_array
1787 | array_creation_expression
1788 ;
1789
1790 primary_no_new_array:
1791 literal
1792 | THIS_TK
1793 { $$ = build_this ($1.location); }
1794 | OP_TK expression CP_TK
1795 {$$ = $2;}
1796 | class_instance_creation_expression
1797 | field_access
1798 | method_invocation
1799 | array_access
1800 /* type DOT_TK CLASS_TK doens't work. So we split the rule
1801 'type' into its components. Missing is something for array,
1802 which will complete the reference_type part. FIXME */
1803 | name DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
1804 { $$ = parse_jdk1_1_error ("named class literals"); }
1805 | primitive_type DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
1806 { $$ = build_class_ref ($1); }
1807 | VOID_TK DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
1808 { $$ = build_class_ref (void_type_node); }
1809 /* Added, JDK1.1 inner classes. Documentation is wrong
1810 refering to a 'ClassName' (class_name) rule that doesn't
1811 exist. Used name instead. */
1812 | name DOT_TK THIS_TK
1813 { $$ = parse_jdk1_1_error ("class literals"); }
1814 | OP_TK expression error
1815 {yyerror ("')' expected"); RECOVER;}
1816 | name DOT_TK error
1817 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1818 | primitive_type DOT_TK error
1819 {yyerror ("'class' expected" ); RECOVER;}
1820 | VOID_TK DOT_TK error
1821 {yyerror ("'class' expected" ); RECOVER;}
1822 ;
1823
1824 class_instance_creation_expression:
1825 NEW_TK class_type OP_TK argument_list CP_TK
1826 { $$ = build_new_invocation ($2, $4); }
1827 | NEW_TK class_type OP_TK CP_TK
1828 { $$ = build_new_invocation ($2, NULL_TREE); }
1829 /* Added, JDK1.1 inner classes but modified to use
1830 'class_type' instead of 'TypeName' (type_name) mentionned
1831 in the documentation but doesn't exist. */
1832 | NEW_TK class_type OP_TK argument_list CP_TK class_body
1833 { $$ = parse_jdk1_1_error ("inner class instance creation"); }
1834 | NEW_TK class_type OP_TK CP_TK class_body
1835 { $$ = parse_jdk1_1_error ("inner class instance creation"); }
1836 /* Added, JDK1.1 inner classes, modified to use name or
1837 primary instead of primary solely which couldn't work in
1838 all situations. */
1839 | something_dot_new identifier OP_TK CP_TK
1840 | something_dot_new identifier OP_TK CP_TK class_body
1841 | something_dot_new identifier OP_TK argument_list CP_TK
1842 | something_dot_new identifier OP_TK argument_list CP_TK class_body
1843 | NEW_TK error SC_TK
1844 {yyerror ("'(' expected"); DRECOVER(new_1);}
1845 | NEW_TK class_type error
1846 {yyerror ("'(' expected"); RECOVER;}
1847 | NEW_TK class_type OP_TK error
1848 {yyerror ("')' or term expected"); RECOVER;}
1849 | NEW_TK class_type OP_TK argument_list error
1850 {yyerror ("')' expected"); RECOVER;}
1851 | something_dot_new error
1852 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
1853 | something_dot_new identifier error
1854 {yyerror ("'(' expected"); RECOVER;}
1855 ;
1856
1857 something_dot_new: /* Added, not part of the specs. */
1858 name DOT_TK NEW_TK
1859 | primary DOT_TK NEW_TK
1860 ;
1861
1862 argument_list:
1863 expression
1864 {
1865 $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
1866 ctxp->formal_parameter_number = 1;
1867 }
1868 | argument_list C_TK expression
1869 {
1870 ctxp->formal_parameter_number += 1;
1871 $$ = tree_cons (NULL_TREE, $3, $1);
1872 }
1873 | argument_list C_TK error
1874 {yyerror ("Missing term"); RECOVER;}
1875 ;
1876
1877 array_creation_expression:
1878 NEW_TK primitive_type dim_exprs
1879 { $$ = build_newarray_node ($2, $3, 0); }
1880 | NEW_TK class_or_interface_type dim_exprs
1881 { $$ = build_newarray_node ($2, $3, 0); }
1882 | NEW_TK primitive_type dim_exprs dims
1883 { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
1884 | NEW_TK class_or_interface_type dim_exprs dims
1885 { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
1886 /* Added, JDK1.1 anonymous array. Initial documentation rule
1887 modified */
1888 | NEW_TK class_or_interface_type dims array_initializer
1889 { $$ = parse_jdk1_1_error ("anonymous array"); }
1890 | NEW_TK primitive_type dims array_initializer
1891 { $$ = parse_jdk1_1_error ("anonymous array"); }
1892 | NEW_TK error CSB_TK
1893 {yyerror ("'[' expected"); DRECOVER ("]");}
1894 | NEW_TK error OSB_TK
1895 {yyerror ("']' expected"); RECOVER;}
1896 ;
1897
1898 dim_exprs:
1899 dim_expr
1900 { $$ = build_tree_list (NULL_TREE, $1); }
1901 | dim_exprs dim_expr
1902 { $$ = tree_cons (NULL_TREE, $2, $$); }
1903 ;
1904
1905 dim_expr:
1906 OSB_TK expression CSB_TK
1907 {
1908 EXPR_WFL_LINECOL ($2) = $1.location;
1909 $$ = $2;
1910 }
1911 | OSB_TK expression error
1912 {yyerror ("']' expected"); RECOVER;}
1913 | OSB_TK error
1914 {
1915 yyerror ("Missing term");
1916 yyerror ("']' expected");
1917 RECOVER;
1918 }
1919 ;
1920
1921 dims:
1922 OSB_TK CSB_TK
1923 {
1924 int allocate = 0;
1925 /* If not initialized, allocate memory for the osb
1926 numbers stack */
1927 if (!ctxp->osb_limit)
1928 {
1929 allocate = ctxp->osb_limit = 32;
1930 ctxp->osb_depth = -1;
1931 }
1932 /* If capacity overflown, reallocate a bigger chuck */
1933 else if (ctxp->osb_depth+1 == ctxp->osb_limit)
1934 allocate = ctxp->osb_limit << 1;
1935
1936 if (allocate)
1937 {
1938 allocate *= sizeof (int);
1939 if (ctxp->osb_number)
1940 ctxp->osb_number = (int *)xrealloc (ctxp->osb_number,
1941 allocate);
1942 else
1943 ctxp->osb_number = (int *)xmalloc (allocate);
1944 }
1945 ctxp->osb_depth++;
1946 CURRENT_OSB (ctxp) = 1;
1947 }
1948 | dims OSB_TK CSB_TK
1949 { CURRENT_OSB (ctxp)++; }
1950 | dims OSB_TK error
1951 { yyerror ("']' expected"); RECOVER;}
1952 ;
1953
1954 field_access:
1955 primary DOT_TK identifier
1956 { $$ = make_qualified_primary ($1, $3, $2.location); }
1957 /* FIXME - REWRITE TO:
1958 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
1959 | SUPER_TK DOT_TK identifier
1960 {
1961 tree super_wfl =
1962 build_wfl_node (super_identifier_node);
1963 EXPR_WFL_LINECOL (super_wfl) = $1.location;
1964 $$ = make_qualified_name (super_wfl, $3, $2.location);
1965 }
1966 | SUPER_TK error
1967 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
1968 ;
1969
1970 method_invocation:
1971 name OP_TK CP_TK
1972 { $$ = build_method_invocation ($1, NULL_TREE); }
1973 | name OP_TK argument_list CP_TK
1974 { $$ = build_method_invocation ($1, $3); }
1975 | primary DOT_TK identifier OP_TK CP_TK
1976 {
1977 if (TREE_CODE ($1) == THIS_EXPR)
1978 $$ = build_this_super_qualified_invocation
1979 (1, $3, NULL_TREE, 0, $2.location);
1980 else
1981 {
1982 tree invok = build_method_invocation ($3, NULL_TREE);
1983 $$ = make_qualified_primary ($1, invok, $2.location);
1984 }
1985 }
1986 | primary DOT_TK identifier OP_TK argument_list CP_TK
1987 {
1988 if (TREE_CODE ($1) == THIS_EXPR)
1989 $$ = build_this_super_qualified_invocation
1990 (1, $3, $5, 0, $2.location);
1991 else
1992 {
1993 tree invok = build_method_invocation ($3, $5);
1994 $$ = make_qualified_primary ($1, invok, $2.location);
1995 }
1996 }
1997 | SUPER_TK DOT_TK identifier OP_TK CP_TK
1998 {
1999 $$ = build_this_super_qualified_invocation
2000 (0, $3, NULL_TREE, $1.location, $2.location);
2001 }
2002 | SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2003 {
2004 $$ = build_this_super_qualified_invocation
2005 (0, $3, $5, $1.location, $2.location);
2006 }
2007 /* Screws up thing. I let it here until I'm convinced it can
2008 be removed. FIXME
2009 | primary DOT_TK error
2010 {yyerror ("'(' expected"); DRECOVER(bad);} */
2011 | SUPER_TK DOT_TK error CP_TK
2012 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2013 | SUPER_TK DOT_TK error DOT_TK
2014 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2015 ;
2016
2017 array_access:
2018 name OSB_TK expression CSB_TK
2019 { $$ = build_array_ref ($2.location, $1, $3); }
2020 | primary_no_new_array OSB_TK expression CSB_TK
2021 { $$ = build_array_ref ($2.location, $1, $3); }
2022 | name OSB_TK error
2023 {
2024 yyerror ("Missing term and ']' expected");
2025 DRECOVER(array_access);
2026 }
2027 | name OSB_TK expression error
2028 {
2029 yyerror ("']' expected");
2030 DRECOVER(array_access);
2031 }
2032 | primary_no_new_array OSB_TK error
2033 {
2034 yyerror ("Missing term and ']' expected");
2035 DRECOVER(array_access);
2036 }
2037 | primary_no_new_array OSB_TK expression error
2038 {
2039 yyerror ("']' expected");
2040 DRECOVER(array_access);
2041 }
2042 ;
2043
2044 postfix_expression:
2045 primary
2046 | name
2047 | post_increment_expression
2048 | post_decrement_expression
2049 ;
2050
2051 post_increment_expression:
2052 postfix_expression INCR_TK
2053 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2054 ;
2055
2056 post_decrement_expression:
2057 postfix_expression DECR_TK
2058 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2059 ;
2060
2061 unary_expression:
2062 pre_increment_expression
2063 | pre_decrement_expression
2064 | PLUS_TK unary_expression
2065 {$$ = build_unaryop ($1.token, $1.location, $2); }
2066 | MINUS_TK unary_expression
2067 {$$ = build_unaryop ($1.token, $1.location, $2); }
2068 | unary_expression_not_plus_minus
2069 | PLUS_TK error
2070 {yyerror ("Missing term"); RECOVER}
2071 | MINUS_TK error
2072 {yyerror ("Missing term"); RECOVER}
2073 ;
2074
2075 pre_increment_expression:
2076 INCR_TK unary_expression
2077 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2078 | INCR_TK error
2079 {yyerror ("Missing term"); RECOVER}
2080 ;
2081
2082 pre_decrement_expression:
2083 DECR_TK unary_expression
2084 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2085 | DECR_TK error
2086 {yyerror ("Missing term"); RECOVER}
2087 ;
2088
2089 unary_expression_not_plus_minus:
2090 postfix_expression
2091 | NOT_TK unary_expression
2092 {$$ = build_unaryop ($1.token, $1.location, $2); }
2093 | NEG_TK unary_expression
2094 {$$ = build_unaryop ($1.token, $1.location, $2); }
2095 | cast_expression
2096 | NOT_TK error
2097 {yyerror ("Missing term"); RECOVER}
2098 | NEG_TK error
2099 {yyerror ("Missing term"); RECOVER}
2100 ;
2101
2102 cast_expression: /* Error handling here is potentially weak */
2103 OP_TK primitive_type dims CP_TK unary_expression
2104 {
2105 tree type = $2;
2106 while (CURRENT_OSB (ctxp)--)
2107 type = build_java_array_type (type, -1);
2108 ctxp->osb_depth--;
2109 $$ = build_cast ($1.location, type, $5);
2110 }
2111 | OP_TK primitive_type CP_TK unary_expression
2112 { $$ = build_cast ($1.location, $2, $4); }
2113 | OP_TK expression CP_TK unary_expression_not_plus_minus
2114 { $$ = build_cast ($1.location, $2, $4); }
2115 | OP_TK name dims CP_TK unary_expression_not_plus_minus
2116 {
2117 const char *ptr;
2118 while (CURRENT_OSB (ctxp)--)
2119 obstack_1grow (&temporary_obstack, '[');
2120 ctxp->osb_depth--;
2121 obstack_grow0 (&temporary_obstack,
2122 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2123 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2124 ptr = obstack_finish (&temporary_obstack);
2125 EXPR_WFL_NODE ($2) = get_identifier (ptr);
2126 $$ = build_cast ($1.location, $2, $5);
2127 }
2128 | OP_TK primitive_type OSB_TK error
2129 {yyerror ("']' expected, invalid type expression");}
2130 | OP_TK error
2131 {
2132 if (ctxp->prevent_ese != lineno)
2133 yyerror ("Invalid type expression"); RECOVER;
2134 RECOVER;
2135 }
2136 | OP_TK primitive_type dims CP_TK error
2137 {yyerror ("Missing term"); RECOVER;}
2138 | OP_TK primitive_type CP_TK error
2139 {yyerror ("Missing term"); RECOVER;}
2140 | OP_TK name dims CP_TK error
2141 {yyerror ("Missing term"); RECOVER;}
2142 ;
2143
2144 multiplicative_expression:
2145 unary_expression
2146 | multiplicative_expression MULT_TK unary_expression
2147 {
2148 $$ = build_binop (BINOP_LOOKUP ($2.token),
2149 $2.location, $1, $3);
2150 }
2151 | multiplicative_expression DIV_TK unary_expression
2152 {
2153 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2154 $1, $3);
2155 }
2156 | multiplicative_expression REM_TK unary_expression
2157 {
2158 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2159 $1, $3);
2160 }
2161 | multiplicative_expression MULT_TK error
2162 {yyerror ("Missing term"); RECOVER;}
2163 | multiplicative_expression DIV_TK error
2164 {yyerror ("Missing term"); RECOVER;}
2165 | multiplicative_expression REM_TK error
2166 {yyerror ("Missing term"); RECOVER;}
2167 ;
2168
2169 additive_expression:
2170 multiplicative_expression
2171 | additive_expression PLUS_TK multiplicative_expression
2172 {
2173 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2174 $1, $3);
2175 }
2176 | additive_expression MINUS_TK multiplicative_expression
2177 {
2178 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2179 $1, $3);
2180 }
2181 | additive_expression PLUS_TK error
2182 {yyerror ("Missing term"); RECOVER;}
2183 | additive_expression MINUS_TK error
2184 {yyerror ("Missing term"); RECOVER;}
2185 ;
2186
2187 shift_expression:
2188 additive_expression
2189 | shift_expression LS_TK additive_expression
2190 {
2191 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2192 $1, $3);
2193 }
2194 | shift_expression SRS_TK additive_expression
2195 {
2196 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2197 $1, $3);
2198 }
2199 | shift_expression ZRS_TK additive_expression
2200 {
2201 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2202 $1, $3);
2203 }
2204 | shift_expression LS_TK error
2205 {yyerror ("Missing term"); RECOVER;}
2206 | shift_expression SRS_TK error
2207 {yyerror ("Missing term"); RECOVER;}
2208 | shift_expression ZRS_TK error
2209 {yyerror ("Missing term"); RECOVER;}
2210 ;
2211
2212 relational_expression:
2213 shift_expression
2214 | relational_expression LT_TK shift_expression
2215 {
2216 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2217 $1, $3);
2218 }
2219 | relational_expression GT_TK shift_expression
2220 {
2221 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2222 $1, $3);
2223 }
2224 | relational_expression LTE_TK shift_expression
2225 {
2226 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2227 $1, $3);
2228 }
2229 | relational_expression GTE_TK shift_expression
2230 {
2231 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2232 $1, $3);
2233 }
2234 | relational_expression INSTANCEOF_TK reference_type
2235 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2236 | relational_expression LT_TK error
2237 {yyerror ("Missing term"); RECOVER;}
2238 | relational_expression GT_TK error
2239 {yyerror ("Missing term"); RECOVER;}
2240 | relational_expression LTE_TK error
2241 {yyerror ("Missing term"); RECOVER;}
2242 | relational_expression GTE_TK error
2243 {yyerror ("Missing term"); RECOVER;}
2244 | relational_expression INSTANCEOF_TK error
2245 {yyerror ("Invalid reference type"); RECOVER;}
2246 ;
2247
2248 equality_expression:
2249 relational_expression
2250 | equality_expression EQ_TK relational_expression
2251 {
2252 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2253 $1, $3);
2254 }
2255 | equality_expression NEQ_TK relational_expression
2256 {
2257 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2258 $1, $3);
2259 }
2260 | equality_expression EQ_TK error
2261 {yyerror ("Missing term"); RECOVER;}
2262 | equality_expression NEQ_TK error
2263 {yyerror ("Missing term"); RECOVER;}
2264 ;
2265
2266 and_expression:
2267 equality_expression
2268 | and_expression AND_TK equality_expression
2269 {
2270 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2271 $1, $3);
2272 }
2273 | and_expression AND_TK error
2274 {yyerror ("Missing term"); RECOVER;}
2275 ;
2276
2277 exclusive_or_expression:
2278 and_expression
2279 | exclusive_or_expression XOR_TK and_expression
2280 {
2281 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2282 $1, $3);
2283 }
2284 | exclusive_or_expression XOR_TK error
2285 {yyerror ("Missing term"); RECOVER;}
2286 ;
2287
2288 inclusive_or_expression:
2289 exclusive_or_expression
2290 | inclusive_or_expression OR_TK exclusive_or_expression
2291 {
2292 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2293 $1, $3);
2294 }
2295 | inclusive_or_expression OR_TK error
2296 {yyerror ("Missing term"); RECOVER;}
2297 ;
2298
2299 conditional_and_expression:
2300 inclusive_or_expression
2301 | conditional_and_expression BOOL_AND_TK inclusive_or_expression
2302 {
2303 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2304 $1, $3);
2305 }
2306 | conditional_and_expression BOOL_AND_TK error
2307 {yyerror ("Missing term"); RECOVER;}
2308 ;
2309
2310 conditional_or_expression:
2311 conditional_and_expression
2312 | conditional_or_expression BOOL_OR_TK conditional_and_expression
2313 {
2314 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2315 $1, $3);
2316 }
2317 | conditional_or_expression BOOL_OR_TK error
2318 {yyerror ("Missing term"); RECOVER;}
2319 ;
2320
2321 conditional_expression: /* Error handling here is weak */
2322 conditional_or_expression
2323 | conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2324 {
2325 $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2326 EXPR_WFL_LINECOL ($$) = $2.location;
2327 }
2328 | conditional_or_expression REL_QM_TK REL_CL_TK error
2329 {
2330 YYERROR_NOW;
2331 yyerror ("Missing term");
2332 DRECOVER (1);
2333 }
2334 | conditional_or_expression REL_QM_TK error
2335 {yyerror ("Missing term"); DRECOVER (2);}
2336 | conditional_or_expression REL_QM_TK expression REL_CL_TK error
2337 {yyerror ("Missing term"); DRECOVER (3);}
2338 ;
2339
2340 assignment_expression:
2341 conditional_expression
2342 | assignment
2343 ;
2344
2345 assignment:
2346 left_hand_side assignment_operator assignment_expression
2347 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2348 | left_hand_side assignment_operator error
2349 {
2350 if (ctxp->prevent_ese != lineno)
2351 yyerror ("Missing term");
2352 DRECOVER (assign);
2353 }
2354 ;
2355
2356 left_hand_side:
2357 name
2358 | field_access
2359 | array_access
2360 ;
2361
2362 assignment_operator:
2363 ASSIGN_ANY_TK
2364 | ASSIGN_TK
2365 ;
2366
2367 expression:
2368 assignment_expression
2369 ;
2370
2371 constant_expression:
2372 expression
2373 ;
2374
2375 %%
2376 \f
2377
2378 /* Flag for the error report routine to issue the error the first time
2379 it's called (overriding the default behavior which is to drop the
2380 first invocation and honor the second one, taking advantage of a
2381 richer context. */
2382 static int force_error = 0;
2383
2384 /* Create a new parser context and make it the current one. */
2385
2386 void
2387 java_push_parser_context ()
2388 {
2389 struct parser_ctxt *new =
2390 (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt));
2391
2392 bzero ((PTR) new, sizeof (struct parser_ctxt));
2393 new->next = ctxp;
2394 ctxp = new;
2395 if (ctxp->next)
2396 {
2397 ctxp->incomplete_class = ctxp->next->incomplete_class;
2398 ctxp->gclass_list = ctxp->next->gclass_list;
2399 }
2400 }
2401
2402 void
2403 java_parser_context_save_global ()
2404 {
2405 if (!ctxp)
2406 {
2407 java_push_parser_context ();
2408 ctxp->saved_data_ctx = 1;
2409 }
2410 else if (ctxp->saved_data)
2411 {
2412 struct parser_ctxt *new =
2413 (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt));
2414 bzero ((PTR)new, sizeof (struct parser_ctxt));
2415 memcpy ((PTR)new, (PTR)ctxp, sizeof (struct parser_ctxt));
2416 new->next = ctxp;
2417 ctxp = new;
2418 ctxp->saved_data_ctx = 1;
2419 }
2420 ctxp->finput = finput;
2421 ctxp->lineno = lineno;
2422 ctxp->current_class = current_class;
2423 ctxp->filename = input_filename;
2424 ctxp->current_function_decl = current_function_decl;
2425 ctxp->saved_data = 1;
2426 }
2427
2428 void
2429 java_parser_context_restore_global ()
2430 {
2431 finput = ctxp->finput;
2432 lineno = ctxp->lineno;
2433 current_class = ctxp->current_class;
2434 input_filename = ctxp->filename;
2435 ctxp->saved_data = 0;
2436 current_function_decl = ctxp->current_function_decl;
2437 if (ctxp->saved_data_ctx)
2438 java_pop_parser_context (0);
2439 }
2440
2441 void
2442 java_pop_parser_context (generate)
2443 int generate;
2444 {
2445 tree current;
2446 struct parser_ctxt *toFree, *next;
2447
2448 if (!ctxp)
2449 return;
2450
2451 toFree = ctxp;
2452 next = ctxp->next;
2453 if (next)
2454 {
2455 next->incomplete_class = ctxp->incomplete_class;
2456 next->gclass_list = ctxp->gclass_list;
2457 lineno = ctxp->lineno;
2458 finput = ctxp->finput;
2459 current_class = ctxp->current_class;
2460 }
2461
2462 /* Set the single import class file flag to 0 for the current list
2463 of imported things */
2464 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2465 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 0;
2466
2467 /* And restore those of the previous context */
2468 if ((ctxp = next)) /* Assignment is really meant here */
2469 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2470 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 1;
2471
2472 if (generate)
2473 {
2474 toFree->next = ctxp_for_generation;
2475 ctxp_for_generation = toFree;
2476 }
2477 else
2478 free (toFree);
2479 }
2480
2481 /* Dump the stacked up parser contexts. Intended to be called from a
2482 debugger. */
2483
2484 static void
2485 java_debug_context_do (tab)
2486 int tab;
2487 {
2488 #define JAVA_TAB_CONTEXT(C) \
2489 {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2490
2491 struct parser_ctxt *copy = ctxp;
2492 while (copy)
2493 {
2494 JAVA_TAB_CONTEXT (tab);
2495 fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2496 JAVA_TAB_CONTEXT (tab);
2497 fprintf (stderr, "filename: %s\n", copy->filename);
2498 JAVA_TAB_CONTEXT (tab);
2499 fprintf (stderr, "package: %s\n",
2500 (copy->package ?
2501 IDENTIFIER_POINTER (copy->package) : "<none>"));
2502 JAVA_TAB_CONTEXT (tab);
2503 fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2504 JAVA_TAB_CONTEXT (tab);
2505 fprintf (stderr, "saved data: %d\n", copy->saved_data);
2506 copy = copy->next;
2507 tab += 2;
2508 }
2509 #undef JAVA_TAB_CONTEXT
2510 }
2511
2512 void
2513 java_debug_context ()
2514 {
2515 java_debug_context_do (0);
2516 }
2517
2518
2519 /* Reporting an constructor invocation error. */
2520 static void
2521 parse_ctor_invocation_error ()
2522 {
2523 if (DECL_CONSTRUCTOR_P (current_function_decl))
2524 yyerror ("Constructor invocation must be first thing in a constructor");
2525 else
2526 yyerror ("Only constructors can invoke constructors");
2527 }
2528
2529 /* Reporting JDK1.1 features not implemented. */
2530
2531 static tree
2532 parse_jdk1_1_error (msg)
2533 const char *msg;
2534 {
2535 sorry (": `%s' JDK1.1(TM) feature", msg);
2536 java_error_count++;
2537 return empty_stmt_node;
2538 }
2539
2540 static int do_warning = 0;
2541
2542 void
2543 yyerror (msg)
2544 const char *msg;
2545 {
2546 static java_lc elc;
2547 static int prev_lineno;
2548 static const char *prev_msg;
2549
2550 int save_lineno;
2551 char *remainder, *code_from_source;
2552 extern struct obstack temporary_obstack;
2553
2554 if (!force_error && prev_lineno == lineno)
2555 return;
2556
2557 /* Save current error location but report latter, when the context is
2558 richer. */
2559 if (ctxp->java_error_flag == 0)
2560 {
2561 ctxp->java_error_flag = 1;
2562 elc = ctxp->elc;
2563 /* Do something to use the previous line if we're reaching the
2564 end of the file... */
2565 #ifdef VERBOSE_SKELETON
2566 printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
2567 #endif
2568 return;
2569 }
2570
2571 /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
2572 if (!force_error && msg == prev_msg && prev_lineno == elc.line)
2573 return;
2574
2575 ctxp->java_error_flag = 0;
2576 if (do_warning)
2577 java_warning_count++;
2578 else
2579 java_error_count++;
2580
2581 if (elc.col == 0 && msg[1] == ';')
2582 {
2583 elc.col = ctxp->p_line->char_col-1;
2584 elc.line = ctxp->p_line->lineno;
2585 }
2586
2587 save_lineno = lineno;
2588 prev_lineno = lineno = elc.line;
2589 prev_msg = msg;
2590
2591 code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
2592 obstack_grow0 (&temporary_obstack,
2593 code_from_source, strlen (code_from_source));
2594 remainder = obstack_finish (&temporary_obstack);
2595 if (do_warning)
2596 warning ("%s.\n%s", msg, remainder);
2597 else
2598 error ("%s.\n%s", msg, remainder);
2599
2600 /* This allow us to cheaply avoid an extra 'Invalid expression
2601 statement' error report when errors have been already reported on
2602 the same line. This occurs when we report an error but don't have
2603 a synchronization point other than ';', which
2604 expression_statement is the only one to take care of. */
2605 ctxp->prevent_ese = lineno = save_lineno;
2606 }
2607
2608 static void
2609 issue_warning_error_from_context (cl, msg, ap)
2610 tree cl;
2611 const char *msg;
2612 va_list ap;
2613 {
2614 char *saved, *saved_input_filename;
2615 char buffer [4096];
2616 vsprintf (buffer, msg, ap);
2617 force_error = 1;
2618
2619 ctxp->elc.line = EXPR_WFL_LINENO (cl);
2620 ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
2621 (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
2622
2623 /* We have a CL, that's a good reason for using it if it contains data */
2624 saved = ctxp->filename;
2625 if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
2626 ctxp->filename = EXPR_WFL_FILENAME (cl);
2627 saved_input_filename = input_filename;
2628 input_filename = ctxp->filename;
2629 java_error (NULL);
2630 java_error (buffer);
2631 ctxp->filename = saved;
2632 input_filename = saved_input_filename;
2633 force_error = 0;
2634 }
2635
2636 /* Issue an error message at a current source line CL */
2637
2638 void
2639 parse_error_context VPARAMS ((tree cl, const char *msg, ...))
2640 {
2641 #ifndef ANSI_PROTOTYPES
2642 tree cl;
2643 const char *msg;
2644 #endif
2645 va_list ap;
2646
2647 VA_START (ap, msg);
2648 #ifndef ANSI_PROTOTYPES
2649 cl = va_arg (ap, tree);
2650 msg = va_arg (ap, const char *);
2651 #endif
2652 issue_warning_error_from_context (cl, msg, ap);
2653 va_end (ap);
2654 }
2655
2656 /* Issue a warning at a current source line CL */
2657
2658 static void
2659 parse_warning_context VPARAMS ((tree cl, const char *msg, ...))
2660 {
2661 #ifndef ANSI_PROTOTYPES
2662 tree cl;
2663 const char *msg;
2664 #endif
2665 va_list ap;
2666
2667 VA_START (ap, msg);
2668 #ifndef ANSI_PROTOTYPES
2669 cl = va_arg (ap, tree);
2670 msg = va_arg (ap, const char *);
2671 #endif
2672
2673 force_error = do_warning = 1;
2674 issue_warning_error_from_context (cl, msg, ap);
2675 do_warning = force_error = 0;
2676 va_end (ap);
2677 }
2678
2679 static tree
2680 find_expr_with_wfl (node)
2681 tree node;
2682 {
2683 while (node)
2684 {
2685 char code;
2686 tree to_return;
2687
2688 switch (TREE_CODE (node))
2689 {
2690 case BLOCK:
2691 node = BLOCK_EXPR_BODY (node);
2692 continue;
2693
2694 case COMPOUND_EXPR:
2695 to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
2696 if (to_return)
2697 return to_return;
2698 node = TREE_OPERAND (node, 1);
2699 continue;
2700
2701 case LOOP_EXPR:
2702 node = TREE_OPERAND (node, 0);
2703 continue;
2704
2705 case LABELED_BLOCK_EXPR:
2706 node = TREE_OPERAND (node, 1);
2707 continue;
2708
2709 default:
2710 code = TREE_CODE_CLASS (TREE_CODE (node));
2711 if (((code == '1') || (code == '2') || (code == 'e'))
2712 && EXPR_WFL_LINECOL (node))
2713 return node;
2714 return NULL_TREE;
2715 }
2716 }
2717 return NULL_TREE;
2718 }
2719
2720 /* Issue a missing return statement error. Uses METHOD to figure the
2721 last line of the method the error occurs in. */
2722
2723 static void
2724 missing_return_error (method)
2725 tree method;
2726 {
2727 EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
2728 parse_error_context (wfl_operator, "Missing return statement");
2729 }
2730
2731 /* Issue an unreachable statement error. From NODE, find the next
2732 statement to report appropriately. */
2733 static void
2734 unreachable_stmt_error (node)
2735 tree node;
2736 {
2737 /* Browse node to find the next expression node that has a WFL. Use
2738 the location to report the error */
2739 if (TREE_CODE (node) == COMPOUND_EXPR)
2740 node = find_expr_with_wfl (TREE_OPERAND (node, 1));
2741 else
2742 node = find_expr_with_wfl (node);
2743
2744 if (node)
2745 {
2746 EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
2747 parse_error_context (wfl_operator, "Unreachable statement");
2748 }
2749 else
2750 fatal ("Can't get valid statement - unreachable_stmt_error");
2751 }
2752
2753 int
2754 java_report_errors ()
2755 {
2756 if (java_error_count)
2757 fprintf (stderr, "%d error%s",
2758 java_error_count, (java_error_count == 1 ? "" : "s"));
2759 if (java_warning_count)
2760 fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
2761 java_warning_count, (java_warning_count == 1 ? "" : "s"));
2762 if (java_error_count || java_warning_count)
2763 putc ('\n', stderr);
2764 return java_error_count;
2765 }
2766
2767 static char *
2768 java_accstring_lookup (flags)
2769 int flags;
2770 {
2771 static char buffer [80];
2772 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
2773
2774 /* Access modifier looked-up first for easier report on forbidden
2775 access. */
2776 if (flags & ACC_PUBLIC) COPY_RETURN ("public");
2777 if (flags & ACC_PRIVATE) COPY_RETURN ("private");
2778 if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
2779 if (flags & ACC_STATIC) COPY_RETURN ("static");
2780 if (flags & ACC_FINAL) COPY_RETURN ("final");
2781 if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
2782 if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
2783 if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
2784 if (flags & ACC_NATIVE) COPY_RETURN ("native");
2785 if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
2786 if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
2787
2788 buffer [0] = '\0';
2789 return buffer;
2790 #undef COPY_RETURN
2791 }
2792
2793 /* Issuing error messages upon redefinition of classes, interfaces or
2794 variables. */
2795
2796 static void
2797 classitf_redefinition_error (context, id, decl, cl)
2798 const char *context;
2799 tree id, decl, cl;
2800 {
2801 parse_error_context (cl, "%s `%s' already defined in %s:%d",
2802 context, IDENTIFIER_POINTER (id),
2803 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
2804 /* Here we should point out where its redefined. It's a unicode. FIXME */
2805 }
2806
2807 static void
2808 variable_redefinition_error (context, name, type, line)
2809 tree context, name, type;
2810 int line;
2811 {
2812 const char *type_name;
2813
2814 /* Figure a proper name for type. We might haven't resolved it */
2815 if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
2816 type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
2817 else
2818 type_name = lang_printable_name (type, 0);
2819
2820 parse_error_context (context,
2821 "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
2822 IDENTIFIER_POINTER (name),
2823 type_name, IDENTIFIER_POINTER (name), line);
2824 }
2825
2826 static tree
2827 build_array_from_name (type, type_wfl, name, ret_name)
2828 tree type, type_wfl, name, *ret_name;
2829 {
2830 int more_dims = 0;
2831 const char *string;
2832
2833 /* Eventually get more dims */
2834 string = IDENTIFIER_POINTER (name);
2835 while (string [more_dims] == '[')
2836 more_dims++;
2837
2838 /* If we have, then craft a new type for this variable */
2839 if (more_dims)
2840 {
2841 name = get_identifier (&string [more_dims]);
2842
2843 /* If we have a pointer, use its type */
2844 if (TREE_CODE (type) == POINTER_TYPE)
2845 type = TREE_TYPE (type);
2846
2847 /* Building the first dimension of a primitive type uses this
2848 function */
2849 if (JPRIMITIVE_TYPE_P (type))
2850 {
2851 type = build_java_array_type (type, -1);
2852 CLASS_LOADED_P (type) = 1;
2853 more_dims--;
2854 }
2855 /* Otherwise, if we have a WFL for this type, use it (the type
2856 is already an array on an unresolved type, and we just keep
2857 on adding dimensions) */
2858 else if (type_wfl)
2859 type = type_wfl;
2860
2861 /* Add all the dimensions */
2862 while (more_dims--)
2863 type = build_unresolved_array_type (type);
2864
2865 /* The type may have been incomplete in the first place */
2866 if (type_wfl)
2867 type = obtain_incomplete_type (type);
2868 }
2869
2870 *ret_name = name;
2871 return type;
2872 }
2873
2874 /* Build something that the type identifier resolver will identify as
2875 being an array to an unresolved type. TYPE_WFL is a WFL on a
2876 identifier. */
2877
2878 static tree
2879 build_unresolved_array_type (type_or_wfl)
2880 tree type_or_wfl;
2881 {
2882 const char *ptr;
2883
2884 /* TYPE_OR_WFL might be an array on a resolved type. In this case,
2885 just create a array type */
2886 if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
2887 {
2888 tree type = build_java_array_type (type_or_wfl, -1);
2889 CLASS_LOADED_P (type) = CLASS_LOADED_P (type_or_wfl);
2890 return type;
2891 }
2892
2893 obstack_1grow (&temporary_obstack, '[');
2894 obstack_grow0 (&temporary_obstack,
2895 IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
2896 IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
2897 ptr = obstack_finish (&temporary_obstack);
2898 return build_expr_wfl (get_identifier (ptr),
2899 EXPR_WFL_FILENAME (type_or_wfl),
2900 EXPR_WFL_LINENO (type_or_wfl),
2901 EXPR_WFL_COLNO (type_or_wfl));
2902 }
2903
2904 static void
2905 parser_add_interface (class_decl, interface_decl, wfl)
2906 tree class_decl, interface_decl, wfl;
2907 {
2908 if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
2909 parse_error_context (wfl, "Interface `%s' repeated",
2910 IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
2911 }
2912
2913 /* Bulk of common class/interface checks. Return 1 if an error was
2914 encountered. TAG is 0 for a class, 1 for an interface. */
2915
2916 static int
2917 check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
2918 int is_interface, flags;
2919 tree raw_name, qualified_name, decl, cl;
2920 {
2921 tree node;
2922
2923 if (!quiet_flag)
2924 fprintf (stderr, " %s %s", (is_interface ? "interface" : "class"),
2925 IDENTIFIER_POINTER (qualified_name));
2926
2927 /* Scope of an interface/class type name:
2928 - Can't be imported by a single type import
2929 - Can't already exists in the package */
2930 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
2931 && (node = find_name_in_single_imports (raw_name)))
2932 {
2933 parse_error_context
2934 (cl, "%s name `%s' clashes with imported type `%s'",
2935 (is_interface ? "Interface" : "Class"),
2936 IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
2937 return 1;
2938 }
2939 if (decl && CLASS_COMPLETE_P (decl))
2940 {
2941 classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
2942 qualified_name, decl, cl);
2943 return 1;
2944 }
2945
2946 /* If public, file name should match class/interface name */
2947 if (flags & ACC_PUBLIC)
2948 {
2949 const char *f;
2950
2951 /* Contains OS dependent assumption on path separator. FIXME */
2952 for (f = &input_filename [strlen (input_filename)];
2953 f != input_filename && f[0] != '/' && f[0] != DIR_SEPARATOR;
2954 f--)
2955 ;
2956 if (f[0] == '/' || f[0] == DIR_SEPARATOR)
2957 f++;
2958 if (strncmp (IDENTIFIER_POINTER (raw_name),
2959 f , IDENTIFIER_LENGTH (raw_name)) ||
2960 f [IDENTIFIER_LENGTH (raw_name)] != '.')
2961 parse_error_context
2962 (cl, "Public %s `%s' must be defined in a file called `%s.java'",
2963 (is_interface ? "interface" : "class"),
2964 IDENTIFIER_POINTER (qualified_name),
2965 IDENTIFIER_POINTER (raw_name));
2966 }
2967
2968 if (is_interface)
2969 check_modifiers ("Illegal modifier `%s' for interface declaration",
2970 flags, INTERFACE_MODIFIERS);
2971 else
2972 check_modifiers ("Illegal modifier `%s' for class declaration",
2973 flags, CLASS_MODIFIERS);
2974 return 0;
2975 }
2976
2977 /* If DECL is NULL, create and push a new DECL, record the current
2978 line CL and do other maintenance things. */
2979
2980 static tree
2981 maybe_create_class_interface_decl (decl, qualified_name, cl)
2982 tree decl, qualified_name, cl;
2983 {
2984 if (!decl)
2985 decl = push_class (make_class (), qualified_name);
2986
2987 /* Take care of the file and line business */
2988 DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
2989 /* If we're emiting xrefs, store the line/col number information */
2990 if (flag_emit_xref)
2991 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
2992 else
2993 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
2994 CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
2995 CLASS_FROM_CURRENTLY_COMPILED_SOURCE_P (TREE_TYPE (decl)) =
2996 IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
2997
2998 ctxp->current_parsed_class = decl;
2999
3000 /* Link the declaration to the already seen ones */
3001 TREE_CHAIN (decl) = ctxp->class_list;
3002 ctxp->class_list = decl;
3003
3004 /* Create a new nodes in the global lists */
3005 ctxp->gclass_list = tree_cons (NULL_TREE, decl, ctxp->gclass_list);
3006 all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3007
3008 /* Install a new dependency list element */
3009 create_jdep_list (ctxp);
3010
3011 SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3012 IDENTIFIER_POINTER (qualified_name)));
3013 return decl;
3014 }
3015
3016 static void
3017 add_superinterfaces (decl, interface_list)
3018 tree decl, interface_list;
3019 {
3020 tree node;
3021 /* Superinterface(s): if present and defined, parser_check_super_interface ()
3022 takes care of ensuring that:
3023 - This is an accessible interface type,
3024 - Circularity detection.
3025 parser_add_interface is then called. If present but not defined,
3026 the check operation is delayed until the super interface gets
3027 defined. */
3028 for (node = interface_list; node; node = TREE_CHAIN (node))
3029 {
3030 tree current = TREE_PURPOSE (node);
3031 tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3032 if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3033 {
3034 if (!parser_check_super_interface (idecl, decl, current))
3035 parser_add_interface (decl, idecl, current);
3036 }
3037 else
3038 register_incomplete_type (JDEP_INTERFACE,
3039 current, decl, NULL_TREE);
3040 }
3041 }
3042
3043 /* Create an interface in pass1 and return its decl. Return the
3044 interface's decl in pass 2. */
3045
3046 static tree
3047 create_interface (flags, id, super)
3048 int flags;
3049 tree id, super;
3050 {
3051 tree raw_name = EXPR_WFL_NODE (id);
3052 tree q_name = parser_qualified_classname (id);
3053 tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3054
3055 EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */
3056
3057 /* Basic checks: scope, redefinition, modifiers */
3058 if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3059 return NULL_TREE;
3060
3061 /* Interface modifiers check
3062 - public/abstract allowed (already done at that point)
3063 - abstract is obsolete (comes first, it's a warning, or should be)
3064 - Can't use twice the same (checked in the modifier rule) */
3065 if ((flags & ACC_ABSTRACT) && flag_redundant)
3066 parse_warning_context
3067 (MODIFIER_WFL (ABSTRACT_TK),
3068 "Redundant use of `abstract' modifier. Interface `%s' is implicitely abstract", IDENTIFIER_POINTER (raw_name));
3069
3070 /* Create a new decl if DECL is NULL, otherwise fix it */
3071 decl = maybe_create_class_interface_decl (decl, q_name, id);
3072
3073 /* Set super info and mark the class a complete */
3074 set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3075 object_type_node, ctxp->interface_number);
3076 ctxp->interface_number = 0;
3077 CLASS_COMPLETE_P (decl) = 1;
3078 add_superinterfaces (decl, super);
3079
3080 return decl;
3081 }
3082
3083 /* Create an class in pass1 and return its decl. Return class
3084 interface's decl in pass 2. */
3085
3086 static tree
3087 create_class (flags, id, super, interfaces)
3088 int flags;
3089 tree id, super, interfaces;
3090 {
3091 tree raw_name = EXPR_WFL_NODE (id);
3092 tree class_id, decl;
3093 tree super_decl_type;
3094
3095 class_id = parser_qualified_classname (id);
3096 decl = IDENTIFIER_CLASS_VALUE (class_id);
3097 ctxp->current_parsed_class_un = EXPR_WFL_NODE (id);
3098 EXPR_WFL_NODE (id) = class_id;
3099
3100 /* Basic check: scope, redefinition, modifiers */
3101 if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3102 return NULL_TREE;
3103
3104 /* Class modifier check:
3105 - Allowed modifier (already done at that point)
3106 - abstract AND final forbidden
3107 - Public classes defined in the correct file */
3108 if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3109 parse_error_context
3110 (id, "Class `%s' can't be declared both abstract and final",
3111 IDENTIFIER_POINTER (raw_name));
3112
3113 /* Create a new decl if DECL is NULL, otherwise fix it */
3114 decl = maybe_create_class_interface_decl (decl, class_id, id);
3115
3116 /* If SUPER exists, use it, otherwise use Object */
3117 if (super)
3118 {
3119 /* Can't extend java.lang.Object */
3120 if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3121 {
3122 parse_error_context (id, "Can't extend `java.lang.Object'");
3123 return NULL_TREE;
3124 }
3125
3126 super_decl_type =
3127 register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
3128 }
3129 else if (TREE_TYPE (decl) != object_type_node)
3130 super_decl_type = object_type_node;
3131 /* We're defining java.lang.Object */
3132 else
3133 super_decl_type = NULL_TREE;
3134
3135 /* Set super info and mark the class a complete */
3136 set_super_info (flags, TREE_TYPE (decl), super_decl_type,
3137 ctxp->interface_number);
3138 ctxp->interface_number = 0;
3139 CLASS_COMPLETE_P (decl) = 1;
3140 add_superinterfaces (decl, interfaces);
3141
3142 /* If doing xref, store the location at which the inherited class
3143 (if any) was seen. */
3144 if (flag_emit_xref && super)
3145 DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
3146
3147 /* Eventually sets the @deprecated tag flag */
3148 CHECK_DEPRECATED (decl);
3149
3150 return decl;
3151 }
3152
3153 /* Can't use lookup_field () since we don't want to load the class and
3154 can't set the CLASS_LOADED_P flag */
3155
3156 static tree
3157 find_field (class, name)
3158 tree class;
3159 tree name;
3160 {
3161 tree decl;
3162 for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
3163 {
3164 if (DECL_NAME (decl) == name)
3165 return decl;
3166 }
3167 return NULL_TREE;
3168 }
3169
3170 /* Wrap around lookup_field that doesn't potentially upset the value
3171 of CLASS */
3172
3173 static tree
3174 lookup_field_wrapper (class, name)
3175 tree class, name;
3176 {
3177 tree type = class;
3178 tree decl;
3179 java_parser_context_save_global ();
3180 decl = lookup_field (&type, name);
3181 java_parser_context_restore_global ();
3182 return decl == error_mark_node ? NULL : decl;
3183 }
3184
3185 /* Find duplicate field within the same class declarations and report
3186 the error. Returns 1 if a duplicated field was found, 0
3187 otherwise. */
3188
3189 static int
3190 duplicate_declaration_error_p (new_field_name, new_type, cl)
3191 tree new_field_name, new_type, cl;
3192 {
3193 /* This might be modified to work with method decl as well */
3194 tree decl = find_field (TREE_TYPE (ctxp->current_parsed_class),
3195 new_field_name);
3196 if (decl)
3197 {
3198 char *t1 = xstrdup (purify_type_name
3199 ((TREE_CODE (new_type) == POINTER_TYPE
3200 && TREE_TYPE (new_type) == NULL_TREE) ?
3201 IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
3202 lang_printable_name (new_type, 1)));
3203 /* The type may not have been completed by the time we report
3204 the error */
3205 char *t2 = xstrdup (purify_type_name
3206 ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
3207 && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
3208 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
3209 lang_printable_name (TREE_TYPE (decl), 1)));
3210 parse_error_context
3211 (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
3212 t1, IDENTIFIER_POINTER (new_field_name),
3213 t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
3214 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3215 free (t1);
3216 free (t2);
3217 return 1;
3218 }
3219 return 0;
3220 }
3221
3222 /* Field registration routine. If TYPE doesn't exist, field
3223 declarations are linked to the undefined TYPE dependency list, to
3224 be later resolved in java_complete_class () */
3225
3226 static void
3227 register_fields (flags, type, variable_list)
3228 int flags;
3229 tree type, variable_list;
3230 {
3231 tree current, saved_type;
3232 tree class_type = TREE_TYPE (ctxp->current_parsed_class);
3233 int saved_lineno = lineno;
3234 int must_chain = 0;
3235 tree wfl = NULL_TREE;
3236
3237 /* If we're adding fields to interfaces, those fields are public,
3238 static, final */
3239 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
3240 {
3241 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
3242 flags, ACC_PUBLIC, "interface field(s)");
3243 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
3244 flags, ACC_STATIC, "interface field(s)");
3245 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
3246 flags, ACC_FINAL, "interface field(s)");
3247 check_modifiers ("Illegal interface member modifier `%s'", flags,
3248 INTERFACE_FIELD_MODIFIERS);
3249 flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
3250 }
3251
3252 /* Obtain a suitable type for resolution, if necessary */
3253 SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
3254
3255 /* If TYPE is fully resolved and we don't have a reference, make one */
3256 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
3257
3258 for (current = variable_list, saved_type = type; current;
3259 current = TREE_CHAIN (current), type = saved_type)
3260 {
3261 tree real_type;
3262 tree field_decl;
3263 tree cl = TREE_PURPOSE (current);
3264 tree init = TREE_VALUE (current);
3265 tree current_name = EXPR_WFL_NODE (cl);
3266
3267 /* Process NAME, as it may specify extra dimension(s) for it */
3268 type = build_array_from_name (type, wfl, current_name, &current_name);
3269
3270 /* Type adjustment. We may have just readjusted TYPE because
3271 the variable specified more dimensions. Make sure we have
3272 a reference if we can and don't have one already. Also
3273 change the name if we have an init. */
3274 if (type != saved_type)
3275 {
3276 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
3277 if (init)
3278 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
3279 }
3280
3281 real_type = GET_REAL_TYPE (type);
3282 /* Check for redeclarations */
3283 if (duplicate_declaration_error_p (current_name, real_type, cl))
3284 continue;
3285
3286 /* Set lineno to the line the field was found and create a
3287 declaration for it. Eventually sets the @deprecated tag flag. */
3288 if (flag_emit_xref)
3289 lineno = EXPR_WFL_LINECOL (cl);
3290 else
3291 lineno = EXPR_WFL_LINENO (cl);
3292 field_decl = add_field (class_type, current_name, real_type, flags);
3293 CHECK_DEPRECATED (field_decl);
3294
3295 /* Check if we must chain. */
3296 if (must_chain)
3297 register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
3298
3299 /* If we have an initialization value tied to the field */
3300 if (init)
3301 {
3302 /* The field is declared static */
3303 if (flags & ACC_STATIC)
3304 {
3305 /* We include the field and its initialization part into
3306 a list used to generate <clinit>. After <clinit> is
3307 walked, field initializations will be processed and
3308 fields initialized with known constants will be taken
3309 out of <clinit> and have their DECL_INITIAL set
3310 appropriately. */
3311 TREE_CHAIN (init) = ctxp->static_initialized;
3312 ctxp->static_initialized = init;
3313 if (TREE_OPERAND (init, 1)
3314 && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
3315 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
3316 }
3317 /* A non-static field declared with an immediate initialization is
3318 to be initialized in <init>, if any. This field is remembered
3319 to be processed at the time of the generation of <init>. */
3320 else
3321 {
3322 TREE_CHAIN (init) = ctxp->non_static_initialized;
3323 ctxp->non_static_initialized = init;
3324 }
3325 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
3326 DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
3327 }
3328 }
3329 lineno = saved_lineno;
3330 }
3331
3332 /* Generate the method $finit$ that initializes fields initialized
3333 upon declaration. */
3334
3335 static void
3336 maybe_generate_finit ()
3337 {
3338 tree mdecl, current;
3339
3340 if (!ctxp->non_static_initialized || java_error_count)
3341 return;
3342
3343 mdecl = create_artificial_method (TREE_TYPE (ctxp->current_parsed_class),
3344 ACC_PRIVATE, void_type_node,
3345 finit_identifier_node, end_params_node);
3346 start_artificial_method_body (mdecl);
3347
3348 ctxp->non_static_initialized = nreverse (ctxp->non_static_initialized);
3349 for (current = ctxp->non_static_initialized; current;
3350 current = TREE_CHAIN (current))
3351 java_method_add_stmt (mdecl,
3352 build_debugable_stmt (EXPR_WFL_LINECOL (current),
3353 current));
3354
3355 end_artificial_method_body (mdecl);
3356 CLASS_HAS_FINIT_P (TREE_TYPE (ctxp->current_parsed_class)) = 1;
3357 ctxp->non_static_initialized = NULL_TREE;
3358 }
3359
3360 /* Check whether it is necessary to generate a <clinit> for the class
3361 we just parsed. */
3362
3363 static void
3364 maybe_generate_clinit ()
3365 {
3366 tree mdecl, c;
3367
3368 if (!ctxp->static_initialized || java_error_count)
3369 return;
3370
3371 mdecl = create_artificial_method (TREE_TYPE (ctxp->current_parsed_class),
3372 ACC_STATIC, void_type_node,
3373 clinit_identifier_node, end_params_node);
3374 start_artificial_method_body (mdecl);
3375
3376 /* Keep initialization in order to enforce 8.5 */
3377 ctxp->static_initialized = nreverse (ctxp->static_initialized);
3378
3379 /* We process the list of assignment we produced as the result of
3380 the declaration of initialized static field and add them as
3381 statement to the <clinit> method. */
3382 for (c = ctxp->static_initialized; c; c = TREE_CHAIN (c))
3383 {
3384 /* We build the assignment expression that will initialize the
3385 field to its value. There are strict rules on static
3386 initializers (8.5). FIXME */
3387 java_method_add_stmt (mdecl,
3388 build_debugable_stmt (EXPR_WFL_LINECOL (c), c));
3389 }
3390
3391 end_artificial_method_body (mdecl);
3392 ctxp->static_initialized = NULL_TREE;
3393 }
3394
3395 /* Shared accros method_declarator and method_header to remember the
3396 patch stage that was reached during the declaration of the method.
3397 A method DECL is built differently is there is no patch
3398 (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
3399 pending on the currently defined method. */
3400
3401 static int patch_stage;
3402
3403 /* Check the method declaration and add the method to its current
3404 class. If the argument list is known to contain incomplete types,
3405 the method is partially added and the registration will be resume
3406 once the method arguments resolved. If TYPE is NULL, we're dealing
3407 with a constructor. */
3408
3409 static tree
3410 method_header (flags, type, mdecl, throws)
3411 int flags;
3412 tree type, mdecl, throws;
3413 {
3414 tree meth = TREE_VALUE (mdecl);
3415 tree id = TREE_PURPOSE (mdecl);
3416 tree type_wfl = NULL_TREE;
3417 tree meth_name = NULL_TREE;
3418 tree current, orig_arg, this_class;
3419 int saved_lineno;
3420 int constructor_ok = 0, must_chain;
3421
3422 check_modifiers_consistency (flags);
3423
3424 if (ctxp->current_parsed_class)
3425 this_class = TREE_TYPE (ctxp->current_parsed_class);
3426 else
3427 return NULL_TREE;
3428
3429 /* There are some forbidden modifiers for an abstract method and its
3430 class must be abstract as well. */
3431 if (type && (flags & ACC_ABSTRACT))
3432 {
3433 ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
3434 ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
3435 ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
3436 ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
3437 ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED,id, "Synchronized");
3438 if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
3439 && !CLASS_INTERFACE (TYPE_NAME (this_class)))
3440 parse_error_context
3441 (id, "Class `%s' must be declared abstract to define abstract method `%s'",
3442 IDENTIFIER_POINTER (DECL_NAME (ctxp->current_parsed_class)),
3443 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
3444 }
3445 /* Things to be checked when declaring a constructor */
3446 if (!type)
3447 {
3448 int ec = java_error_count;
3449 /* 8.6: Constructor declarations: we might be trying to define a
3450 method without specifying a return type. */
3451 if (EXPR_WFL_NODE (id) != ctxp->current_parsed_class_un)
3452 parse_error_context
3453 (id, "Invalid method declaration, return type required");
3454 /* 8.6.3: Constructor modifiers */
3455 else
3456 {
3457 JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
3458 JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
3459 JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
3460 JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
3461 JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
3462 }
3463 /* If we found error here, we don't consider it's OK to tread
3464 the method definition as a constructor, for the rest of this
3465 function */
3466 if (ec == java_error_count)
3467 constructor_ok = 1;
3468 }
3469
3470 /* Method declared within the scope of an interface are implicitly
3471 abstract and public. Conflicts with other erroneously provided
3472 modifiers are checked right after. */
3473
3474 if (CLASS_INTERFACE (TYPE_NAME (this_class)))
3475 {
3476 /* If FLAGS isn't set because of a modifier, turn the
3477 corresponding modifier WFL to NULL so we issue a warning on
3478 the obsolete use of the modifier */
3479 if (!(flags & ACC_PUBLIC))
3480 MODIFIER_WFL (PUBLIC_TK) = NULL;
3481 if (!(flags & ACC_ABSTRACT))
3482 MODIFIER_WFL (ABSTRACT_TK) = NULL;
3483 flags |= ACC_PUBLIC;
3484 flags |= ACC_ABSTRACT;
3485 }
3486
3487 /* Modifiers context reset moved up, so abstract method declaration
3488 modifiers can be later checked. */
3489
3490 /* Set constructor returned type to void and method name to <init>,
3491 unless we found an error identifier the constructor (in which
3492 case we retain the original name) */
3493 if (!type)
3494 {
3495 type = void_type_node;
3496 if (constructor_ok)
3497 meth_name = init_identifier_node;
3498 }
3499 else
3500 meth_name = EXPR_WFL_NODE (id);
3501
3502 /* Do the returned type resolution and registration if necessary */
3503 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
3504
3505 if (meth_name)
3506 type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
3507 EXPR_WFL_NODE (id) = meth_name;
3508 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
3509
3510 if (must_chain)
3511 {
3512 patch_stage = JDEP_METHOD_RETURN;
3513 register_incomplete_type (patch_stage, type_wfl, id, type);
3514 TREE_TYPE (meth) = GET_REAL_TYPE (type);
3515 }
3516 else
3517 TREE_TYPE (meth) = type;
3518
3519 saved_lineno = lineno;
3520 /* When defining an abstract or interface method, the curly
3521 bracket at level 1 doesn't exist because there is no function
3522 body */
3523 lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
3524 EXPR_WFL_LINENO (id));
3525
3526 /* Remember the original argument list */
3527 orig_arg = TYPE_ARG_TYPES (meth);
3528
3529 if (patch_stage) /* includes ret type and/or all args */
3530 {
3531 jdep *jdep;
3532 meth = add_method_1 (this_class, flags, meth_name, meth);
3533 /* Patch for the return type */
3534 if (patch_stage == JDEP_METHOD_RETURN)
3535 {
3536 jdep = CLASSD_LAST (ctxp->classd_list);
3537 JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
3538 }
3539 /* This is the stop JDEP. METH allows the function's signature
3540 to be computed. */
3541 register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
3542 }
3543 else
3544 meth = add_method (this_class, flags, meth_name,
3545 build_java_signature (meth));
3546
3547 /* Fix the method argument list so we have the argument name
3548 information */
3549 fix_method_argument_names (orig_arg, meth);
3550
3551 /* Register the parameter number and re-install the current line
3552 number */
3553 DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
3554 lineno = saved_lineno;
3555
3556 /* Register exception specified by the `throws' keyword for
3557 resolution and set the method decl appropriate field to the list.
3558 Note: the grammar ensures that what we get here are class
3559 types. */
3560 if (throws)
3561 {
3562 throws = nreverse (throws);
3563 for (current = throws; current; current = TREE_CHAIN (current))
3564 {
3565 register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
3566 NULL_TREE, NULL_TREE);
3567 JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
3568 &TREE_VALUE (current);
3569 }
3570 DECL_FUNCTION_THROWS (meth) = throws;
3571 }
3572
3573 /* We set the DECL_NAME to ID so we can track the location where
3574 the function was declared. This allow us to report
3575 redefinition error accurately. When method are verified,
3576 DECL_NAME is reinstalled properly (using the content of the
3577 WFL node ID) (see check_method_redefinition). We don't do that
3578 when Object is being defined. Constructor <init> names will be
3579 reinstalled the same way. */
3580 if (TREE_TYPE (ctxp->current_parsed_class) != object_type_node)
3581 DECL_NAME (meth) = id;
3582
3583 /* Set the flag if we correctly processed a constructor */
3584 if (constructor_ok)
3585 DECL_CONSTRUCTOR_P (meth) = 1;
3586
3587 /* Eventually set the @deprecated tag flag */
3588 CHECK_DEPRECATED (meth);
3589
3590 /* If doing xref, store column and line number information instead
3591 of the line number only. */
3592 if (flag_emit_xref)
3593 DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
3594
3595 return meth;
3596 }
3597
3598 static void
3599 fix_method_argument_names (orig_arg, meth)
3600 tree orig_arg, meth;
3601 {
3602 tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
3603 if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
3604 {
3605 TREE_PURPOSE (arg) = this_identifier_node;
3606 arg = TREE_CHAIN (arg);
3607 }
3608 while (orig_arg != end_params_node)
3609 {
3610 TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
3611 orig_arg = TREE_CHAIN (orig_arg);
3612 arg = TREE_CHAIN (arg);
3613 }
3614 }
3615
3616 /* Complete the method declaration with METHOD_BODY. */
3617
3618 static void
3619 finish_method_declaration (method_body)
3620 tree method_body;
3621 {
3622 int flags;
3623
3624 if (!current_function_decl)
3625 return;
3626
3627 flags = get_access_flags_from_decl (current_function_decl);
3628
3629 /* 8.4.5 Method Body */
3630 if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
3631 {
3632 tree wfl = DECL_NAME (current_function_decl);
3633 parse_error_context (wfl,
3634 "%s method `%s' can't have a body defined",
3635 (METHOD_NATIVE (current_function_decl) ?
3636 "Native" : "Abstract"),
3637 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
3638 method_body = NULL_TREE;
3639 }
3640 else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
3641 {
3642 tree wfl = DECL_NAME (current_function_decl);
3643 parse_error_context
3644 (wfl,
3645 "Non native and non abstract method `%s' must have a body defined",
3646 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
3647 method_body = NULL_TREE;
3648 }
3649
3650 if (flag_emit_class_files && method_body
3651 && TREE_CODE (method_body) == NOP_EXPR
3652 && TREE_TYPE (current_function_decl)
3653 && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
3654 method_body = build1 (RETURN_EXPR, void_type_node, NULL);
3655
3656 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
3657 maybe_absorb_scoping_blocks ();
3658 /* Exit function's body */
3659 exit_block ();
3660 /* Merge last line of the function with first line, directly in the
3661 function decl. It will be used to emit correct debug info. */
3662 if (!flag_emit_xref)
3663 DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1);
3664 /* So we don't have an irrelevant function declaration context for
3665 the next static block we'll see. */
3666 current_function_decl = NULL_TREE;
3667 }
3668
3669 /* Build a an error message for constructor circularity errors. */
3670
3671 static char *
3672 constructor_circularity_msg (from, to)
3673 tree from, to;
3674 {
3675 static char string [4096];
3676 char *t = xstrdup (lang_printable_name (from, 0));
3677 sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
3678 free (t);
3679 return string;
3680 }
3681
3682 /* Verify a circular call to METH. Return 1 if an error is found, 0
3683 otherwise. */
3684
3685 static int
3686 verify_constructor_circularity (meth, current)
3687 tree meth, current;
3688 {
3689 static tree list = NULL_TREE;
3690 tree c;
3691 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
3692 {
3693 if (TREE_VALUE (c) == meth)
3694 {
3695 char *t;
3696 if (list)
3697 {
3698 tree liste;
3699 list = nreverse (list);
3700 for (liste = list; liste; liste = TREE_CHAIN (liste))
3701 {
3702 parse_error_context
3703 (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
3704 constructor_circularity_msg
3705 (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
3706 java_error_count--;
3707 }
3708 }
3709 t = xstrdup (lang_printable_name (meth, 0));
3710 parse_error_context (TREE_PURPOSE (c),
3711 "%s: recursive invocation of constructor `%s'",
3712 constructor_circularity_msg (current, meth), t);
3713 free (t);
3714 list = NULL_TREE;
3715 return 1;
3716 }
3717 }
3718 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
3719 {
3720 list = tree_cons (c, current, list);
3721 if (verify_constructor_circularity (meth, TREE_VALUE (c)))
3722 return 1;
3723 list = TREE_CHAIN (list);
3724 }
3725 return 0;
3726 }
3727
3728 /* Check modifiers that can be declared but exclusively */
3729
3730 static void
3731 check_modifiers_consistency (flags)
3732 int flags;
3733 {
3734 int acc_count = 0;
3735 tree cl = NULL_TREE;
3736
3737 THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, 0, acc_count, cl);
3738 THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, 1, acc_count, cl);
3739 THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, 2, acc_count, cl);
3740 if (acc_count > 1)
3741 parse_error_context
3742 (cl, "Inconsistent member declaration. At most one of `public', `private', or `protected' may be specified");
3743 }
3744
3745 /* Check the methode header METH for abstract specifics features */
3746
3747 static void
3748 check_abstract_method_header (meth)
3749 tree meth;
3750 {
3751 int flags = get_access_flags_from_decl (meth);
3752 /* DECL_NAME might still be a WFL node */
3753 tree name = GET_METHOD_NAME (meth);
3754
3755 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
3756 ACC_ABSTRACT, "abstract method",
3757 IDENTIFIER_POINTER (name));
3758 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
3759 ACC_PUBLIC, "abstract method",
3760 IDENTIFIER_POINTER (name));
3761
3762 check_modifiers ("Illegal modifier `%s' for interface method",
3763 flags, INTERFACE_METHOD_MODIFIERS);
3764 }
3765
3766 /* Create a FUNCTION_TYPE node and start augmenting it with the
3767 declared function arguments. Arguments type that can't be resolved
3768 are left as they are, but the returned node is marked as containing
3769 incomplete types. */
3770
3771 static tree
3772 method_declarator (id, list)
3773 tree id, list;
3774 {
3775 tree arg_types = NULL_TREE, current, node;
3776 tree meth = make_node (FUNCTION_TYPE);
3777 jdep *jdep;
3778
3779 patch_stage = JDEP_NO_PATCH;
3780
3781 for (current = list; current; current = TREE_CHAIN (current))
3782 {
3783 int must_chain = 0;
3784 tree wfl_name = TREE_PURPOSE (current);
3785 tree type = TREE_VALUE (current);
3786 tree name = EXPR_WFL_NODE (wfl_name);
3787 tree already, arg_node;
3788 tree type_wfl = NULL_TREE;
3789 tree real_type;
3790
3791 /* Obtain a suitable type for resolution, if necessary */
3792 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
3793
3794 /* Process NAME, as it may specify extra dimension(s) for it */
3795 type = build_array_from_name (type, type_wfl, name, &name);
3796 EXPR_WFL_NODE (wfl_name) = name;
3797
3798 real_type = GET_REAL_TYPE (type);
3799 if (TREE_CODE (real_type) == RECORD_TYPE)
3800 {
3801 real_type = promote_type (real_type);
3802 if (TREE_CODE (type) == TREE_LIST)
3803 TREE_PURPOSE (type) = real_type;
3804 }
3805
3806 /* Check redefinition */
3807 for (already = arg_types; already; already = TREE_CHAIN (already))
3808 if (TREE_PURPOSE (already) == name)
3809 {
3810 parse_error_context
3811 (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
3812 IDENTIFIER_POINTER (name),
3813 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
3814 break;
3815 }
3816
3817 /* If we've an incomplete argument type, we know there is a location
3818 to patch when the type get resolved, later. */
3819 jdep = NULL;
3820 if (must_chain)
3821 {
3822 patch_stage = JDEP_METHOD;
3823 type = register_incomplete_type (patch_stage,
3824 type_wfl, wfl_name, type);
3825 jdep = CLASSD_LAST (ctxp->classd_list);
3826 JDEP_MISC (jdep) = id;
3827 }
3828
3829 /* The argument node: a name and a (possibly) incomplete type */
3830 arg_node = build_tree_list (name, real_type);
3831 if (jdep)
3832 JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
3833 TREE_CHAIN (arg_node) = arg_types;
3834 arg_types = arg_node;
3835 }
3836 TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
3837 node = build_tree_list (id, meth);
3838 return node;
3839 }
3840
3841 static int
3842 unresolved_type_p (wfl, returned)
3843 tree wfl;
3844 tree *returned;
3845
3846 {
3847 if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
3848 {
3849 tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
3850 if (returned)
3851 *returned = (decl ? TREE_TYPE (decl) : NULL_TREE);
3852 return 1;
3853 }
3854 if (returned)
3855 *returned = wfl;
3856 return 0;
3857 }
3858
3859 /* From NAME, build a qualified identifier node using the
3860 qualification from the current package definition. */
3861
3862 static tree
3863 parser_qualified_classname (name)
3864 tree name;
3865 {
3866 if (ctxp->package)
3867 return merge_qualified_name (ctxp->package, EXPR_WFL_NODE (name));
3868 else
3869 return EXPR_WFL_NODE (name);
3870 }
3871
3872 /* Called once the type a interface extends is resolved. Returns 0 if
3873 everything is OK. */
3874
3875 static int
3876 parser_check_super_interface (super_decl, this_decl, this_wfl)
3877 tree super_decl, this_decl, this_wfl;
3878 {
3879 tree super_type = TREE_TYPE (super_decl);
3880
3881 /* Has to be an interface */
3882 if (!CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (super_decl))))
3883 {
3884 parse_error_context
3885 (this_wfl, "Can't use %s `%s' to implement/extend %s `%s'",
3886 (TYPE_ARRAY_P (super_type) ? "array" : "class"),
3887 IDENTIFIER_POINTER (DECL_NAME (super_decl)),
3888 (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
3889 "interface" : "class"),
3890 IDENTIFIER_POINTER (DECL_NAME (this_decl)));
3891 return 1;
3892 }
3893
3894 /* Check scope: same package OK, other package: OK if public */
3895 if (check_pkg_class_access (DECL_NAME (super_decl), lookup_cl (this_decl)))
3896 return 1;
3897
3898 SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
3899 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
3900 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
3901 return 0;
3902 }
3903
3904 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
3905 0 if everthing is OK. */
3906
3907 static int
3908 parser_check_super (super_decl, this_decl, wfl)
3909 tree super_decl, this_decl, wfl;
3910 {
3911 tree super_type = TREE_TYPE (super_decl);
3912
3913 /* SUPER should be a CLASS (neither an array nor an interface) */
3914 if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
3915 {
3916 parse_error_context
3917 (wfl, "Class `%s' can't subclass %s `%s'",
3918 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
3919 (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
3920 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
3921 return 1;
3922 }
3923
3924 if (CLASS_FINAL (TYPE_NAME (super_type)))
3925 {
3926 parse_error_context (wfl, "Can't subclass final classes: %s",
3927 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
3928 return 1;
3929 }
3930
3931 /* Check scope: same package OK, other package: OK if public */
3932 if (check_pkg_class_access (DECL_NAME (super_decl), wfl))
3933 return 1;
3934
3935 SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
3936 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
3937 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
3938 return 0;
3939 }
3940
3941 /* Create a new dependency list and link it (in a LIFO manner) to the
3942 CTXP list of type dependency list. */
3943
3944 static void
3945 create_jdep_list (ctxp)
3946 struct parser_ctxt *ctxp;
3947 {
3948 jdeplist *new = (jdeplist *)xmalloc (sizeof (jdeplist));
3949 new->first = new->last = NULL;
3950 new->next = ctxp->classd_list;
3951 ctxp->classd_list = new;
3952 }
3953
3954 static jdeplist *
3955 reverse_jdep_list (ctxp)
3956 struct parser_ctxt *ctxp;
3957 {
3958 register jdeplist *prev = NULL, *current, *next;
3959 for (current = ctxp->classd_list; current; current = next)
3960 {
3961 next = current->next;
3962 current->next = prev;
3963 prev = current;
3964 }
3965 return prev;
3966 }
3967
3968 /* Create a fake pointer based on the ID stored in
3969 TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
3970 registered again. */
3971
3972 static tree
3973 obtain_incomplete_type (type_name)
3974 tree type_name;
3975 {
3976 tree ptr, name;
3977
3978 if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
3979 name = EXPR_WFL_NODE (type_name);
3980 else if (INCOMPLETE_TYPE_P (type_name))
3981 name = TYPE_NAME (type_name);
3982 else
3983 fatal ("invalid type name - obtain_incomplete_type");
3984
3985 for (ptr = ctxp->incomplete_class; ptr; ptr = TREE_CHAIN (ptr))
3986 if (TYPE_NAME (ptr) == name)
3987 break;
3988
3989 if (!ptr)
3990 {
3991 push_obstacks (&permanent_obstack, &permanent_obstack);
3992 BUILD_PTR_FROM_NAME (ptr, name);
3993 layout_type (ptr);
3994 pop_obstacks ();
3995 TREE_CHAIN (ptr) = ctxp->incomplete_class;
3996 ctxp->incomplete_class = ptr;
3997 }
3998
3999 return ptr;
4000 }
4001
4002 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
4003 non NULL instead of computing a new fake type based on WFL. The new
4004 dependency is inserted in the current type dependency list, in FIFO
4005 manner. */
4006
4007 static tree
4008 register_incomplete_type (kind, wfl, decl, ptr)
4009 int kind;
4010 tree wfl, decl, ptr;
4011 {
4012 jdep *new = (jdep *)xmalloc (sizeof (jdep));
4013
4014 if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
4015 ptr = obtain_incomplete_type (wfl);
4016
4017 JDEP_KIND (new) = kind;
4018 JDEP_DECL (new) = decl;
4019 JDEP_SOLV (new) = ptr;
4020 JDEP_WFL (new) = wfl;
4021 JDEP_CHAIN (new) = NULL;
4022 JDEP_MISC (new) = NULL_TREE;
4023 JDEP_GET_PATCH (new) = (tree *)NULL;
4024
4025 JDEP_INSERT (ctxp->classd_list, new);
4026
4027 return ptr;
4028 }
4029
4030 void
4031 java_check_circular_reference ()
4032 {
4033 tree current;
4034 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
4035 {
4036 tree type = TREE_TYPE (current);
4037 if (CLASS_INTERFACE (current))
4038 {
4039 /* Check all interfaces this class extends */
4040 tree basetype_vec = TYPE_BINFO_BASETYPES (type);
4041 int n, i;
4042
4043 if (!basetype_vec)
4044 return;
4045 n = TREE_VEC_LENGTH (basetype_vec);
4046 for (i = 0; i < n; i++)
4047 {
4048 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
4049 if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
4050 && interface_of_p (type, BINFO_TYPE (vec_elt)))
4051 parse_error_context (lookup_cl (current),
4052 "Cyclic interface inheritance");
4053 }
4054 }
4055 else
4056 if (inherits_from_p (CLASSTYPE_SUPER (type), type))
4057 parse_error_context (lookup_cl (current),
4058 "Cyclic class inheritance");
4059 }
4060 }
4061
4062 /* Fix the constructors. This will be called right after circular
4063 references have been checked. It is necessary to fix constructors
4064 early even if no code generation will take place for that class:
4065 some generated constructor might be required by the class whose
4066 compilation triggered this one to be simply loaded. */
4067
4068 void
4069 java_fix_constructors ()
4070 {
4071 tree current;
4072
4073 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
4074 {
4075 tree decl;
4076 tree class_type = TREE_TYPE (current);
4077 int saw_ctor = 0;
4078
4079 for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
4080 {
4081 if (DECL_CONSTRUCTOR_P (decl))
4082 {
4083 fix_constructors (decl);
4084 saw_ctor = 1;
4085 }
4086 }
4087
4088 if (!saw_ctor)
4089 {
4090 int flags = (get_access_flags_from_decl (current) & ACC_PUBLIC ?
4091 ACC_PUBLIC : 0);
4092 decl = create_artificial_method (class_type, flags, void_type_node,
4093 init_identifier_node,
4094 end_params_node);
4095 DECL_CONSTRUCTOR_P (decl) = 1;
4096 }
4097 }
4098 }
4099
4100 /* safe_layout_class just makes sure that we can load a class without
4101 disrupting the current_class, input_file, lineno, etc, information
4102 about the class processed currently. */
4103
4104 void
4105 safe_layout_class (class)
4106 tree class;
4107 {
4108 tree save_current_class = current_class;
4109 char *save_input_filename = input_filename;
4110 int save_lineno = lineno;
4111
4112 push_obstacks (&permanent_obstack, &permanent_obstack);
4113
4114 layout_class (class);
4115 pop_obstacks ();
4116
4117 current_class = save_current_class;
4118 input_filename = save_input_filename;
4119 lineno = save_lineno;
4120 CLASS_LOADED_P (class) = 1;
4121 }
4122
4123 static tree
4124 jdep_resolve_class (dep)
4125 jdep *dep;
4126 {
4127 tree decl;
4128
4129 if (JDEP_RESOLVED_P (dep))
4130 decl = JDEP_RESOLVED_DECL (dep);
4131 else
4132 {
4133 decl = resolve_class (JDEP_TO_RESOLVE (dep),
4134 JDEP_DECL (dep), JDEP_WFL (dep));
4135 JDEP_RESOLVED (dep, decl);
4136 }
4137
4138 if (!decl)
4139 complete_class_report_errors (dep);
4140
4141 return decl;
4142 }
4143
4144 /* Complete unsatisfied class declaration and their dependencies */
4145
4146 void
4147 java_complete_class ()
4148 {
4149 tree cclass;
4150 jdeplist *cclassd;
4151 int error_found;
4152 tree type;
4153
4154 push_obstacks (&permanent_obstack, &permanent_obstack);
4155
4156 /* Process imports and reverse the import on demand list */
4157 process_imports ();
4158 if (ctxp->import_demand_list)
4159 ctxp->import_demand_list = nreverse (ctxp->import_demand_list);
4160
4161 /* Rever things so we have the right order */
4162 ctxp->class_list = nreverse (ctxp->class_list);
4163 ctxp->classd_list = reverse_jdep_list (ctxp);
4164
4165 for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
4166 cclass && cclassd;
4167 cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
4168 {
4169 jdep *dep;
4170 for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
4171 {
4172 tree decl;
4173 if (!(decl = jdep_resolve_class (dep)))
4174 continue;
4175
4176 /* Now it's time to patch */
4177 switch (JDEP_KIND (dep))
4178 {
4179 case JDEP_SUPER:
4180 /* Simply patch super */
4181 if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
4182 continue;
4183 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
4184 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
4185 break;
4186
4187 case JDEP_FIELD:
4188 {
4189 /* We do part of the job done in add_field */
4190 tree field_decl = JDEP_DECL (dep);
4191 tree field_type = TREE_TYPE (decl);
4192 push_obstacks (&permanent_obstack, &permanent_obstack);
4193 if (TREE_CODE (field_type) == RECORD_TYPE)
4194 field_type = promote_type (field_type);
4195 pop_obstacks ();
4196 TREE_TYPE (field_decl) = field_type;
4197 DECL_ALIGN (field_decl) = 0;
4198 layout_decl (field_decl, 0);
4199 SOURCE_FRONTEND_DEBUG
4200 (("Completed field/var decl `%s' with `%s'",
4201 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
4202 IDENTIFIER_POINTER (DECL_NAME (decl))));
4203 break;
4204 }
4205 case JDEP_METHOD: /* We start patching a method */
4206 case JDEP_METHOD_RETURN:
4207 error_found = 0;
4208 while (1)
4209 {
4210 if (decl)
4211 {
4212 type = TREE_TYPE(decl);
4213 if (TREE_CODE (type) == RECORD_TYPE)
4214 type = promote_type (type);
4215 JDEP_APPLY_PATCH (dep, type);
4216 SOURCE_FRONTEND_DEBUG
4217 (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
4218 "Completing fct `%s' with ret type `%s'":
4219 "Completing arg `%s' with type `%s'"),
4220 IDENTIFIER_POINTER (EXPR_WFL_NODE
4221 (JDEP_DECL_WFL (dep))),
4222 IDENTIFIER_POINTER (DECL_NAME (decl))));
4223 }
4224 else
4225 error_found = 1;
4226 dep = JDEP_CHAIN (dep);
4227 if (JDEP_KIND (dep) == JDEP_METHOD_END)
4228 break;
4229 else
4230 decl = jdep_resolve_class (dep);
4231 }
4232 if (!error_found)
4233 {
4234 tree mdecl = JDEP_DECL (dep), signature;
4235 push_obstacks (&permanent_obstack, &permanent_obstack);
4236 /* Recompute and reset the signature */
4237 signature = build_java_signature (TREE_TYPE (mdecl));
4238 set_java_signature (TREE_TYPE (mdecl), signature);
4239 pop_obstacks ();
4240 }
4241 else
4242 continue;
4243 break;
4244
4245 case JDEP_INTERFACE:
4246 if (parser_check_super_interface (decl, JDEP_DECL (dep),
4247 JDEP_WFL (dep)))
4248 continue;
4249 parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
4250 break;
4251
4252 case JDEP_PARM:
4253 case JDEP_VARIABLE:
4254 type = TREE_TYPE(decl);
4255 if (TREE_CODE (type) == RECORD_TYPE)
4256 type = promote_type (type);
4257 JDEP_APPLY_PATCH (dep, type);
4258 break;
4259
4260 case JDEP_TYPE:
4261 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
4262 SOURCE_FRONTEND_DEBUG
4263 (("Completing a random type dependency on a '%s' node",
4264 tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
4265 break;
4266
4267 case JDEP_EXCEPTION:
4268 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
4269 SOURCE_FRONTEND_DEBUG
4270 (("Completing `%s' `throws' argument node",
4271 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
4272 break;
4273
4274 default:
4275 fatal ("Can't handle patch code %d - java_complete_class",
4276 JDEP_KIND (dep));
4277 }
4278 }
4279 }
4280 pop_obstacks ();
4281 return;
4282 }
4283
4284 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
4285 array. */
4286
4287 static tree
4288 resolve_class (class_type, decl, cl)
4289 tree class_type, decl, cl;
4290 {
4291 const char *name = IDENTIFIER_POINTER (TYPE_NAME (class_type));
4292 const char *base = name;
4293 tree resolved_type = TREE_TYPE (class_type);
4294 tree resolved_type_decl;
4295
4296 if (resolved_type != NULL_TREE)
4297 {
4298 tree resolved_type_decl = TYPE_NAME (resolved_type);
4299 if (resolved_type_decl == NULL_TREE
4300 || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
4301 {
4302 resolved_type_decl = build_decl (TYPE_DECL,
4303 TYPE_NAME (class_type),
4304 resolved_type);
4305 }
4306 return resolved_type_decl;
4307 }
4308
4309 /* 1- Check to see if we have an array. If true, find what we really
4310 want to resolve */
4311 while (name[0] == '[')
4312 name++;
4313 if (base != name)
4314 TYPE_NAME (class_type) = get_identifier (name);
4315
4316 /* 2- Resolve the bare type */
4317 if (!(resolved_type_decl = do_resolve_class (class_type, decl, cl)))
4318 return NULL_TREE;
4319 resolved_type = TREE_TYPE (resolved_type_decl);
4320
4321 /* 3- If we have and array, reconstruct the array down to its nesting */
4322 if (base != name)
4323 {
4324 while (base != name)
4325 {
4326 if (TREE_CODE (resolved_type) == RECORD_TYPE)
4327 resolved_type = promote_type (resolved_type);
4328 resolved_type = build_java_array_type (resolved_type, -1);
4329 CLASS_LOADED_P (resolved_type) = 1;
4330 name--;
4331 }
4332 /* Build a fake decl for this, since this is what is expected to
4333 be returned. */
4334 resolved_type_decl =
4335 build_decl (TYPE_DECL, TYPE_NAME (resolved_type), resolved_type);
4336 /* Figure how those two things are important for error report. FIXME */
4337 DECL_SOURCE_LINE (resolved_type_decl) = 0;
4338 DECL_SOURCE_FILE (resolved_type_decl) = input_filename;
4339 TYPE_NAME (class_type) = TYPE_NAME (resolved_type);
4340 }
4341 TREE_TYPE (class_type) = resolved_type;
4342 return resolved_type_decl;
4343 }
4344
4345 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
4346 are used to report error messages. */
4347
4348 tree
4349 do_resolve_class (class_type, decl, cl)
4350 tree class_type;
4351 tree decl;
4352 tree cl;
4353 {
4354 tree new_class_decl;
4355 tree original_name = NULL_TREE;
4356
4357 /* Do not try to replace TYPE_NAME (class_type) by a variable, since
4358 its is changed by find_in_imports{_on_demand} */
4359
4360 /* 1- Check for the type in single imports */
4361 if (find_in_imports (class_type))
4362 return NULL_TREE;
4363
4364 /* 2- And check for the type in the current compilation unit. If it fails,
4365 try with a name qualified with the package name we've seen so far */
4366 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
4367 {
4368 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
4369 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
4370 load_class (TYPE_NAME (class_type), 0);
4371 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
4372 }
4373
4374 original_name = TYPE_NAME (class_type);
4375 if (!QUALIFIED_P (TYPE_NAME (class_type)))
4376 {
4377 tree package;
4378 for (package = package_list; package; package = TREE_CHAIN (package))
4379 {
4380 tree new_qualified;
4381
4382 new_qualified = merge_qualified_name (TREE_PURPOSE (package),
4383 original_name);
4384 TYPE_NAME (class_type) = new_qualified;
4385 new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
4386 if (!new_class_decl)
4387 load_class (TYPE_NAME (class_type), 0);
4388 new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
4389 if (new_class_decl)
4390 {
4391 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
4392 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
4393 load_class (TYPE_NAME (class_type), 0);
4394 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
4395 }
4396 }
4397 }
4398 TYPE_NAME (class_type) = original_name;
4399
4400 /* 3- Check an other compilation unit that bears the name of type */
4401 load_class (TYPE_NAME (class_type), 0);
4402 if (check_pkg_class_access (TYPE_NAME (class_type),
4403 (cl ? cl : lookup_cl (decl))))
4404 return NULL_TREE;
4405
4406 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
4407 return new_class_decl;
4408
4409 /* 4- Check the import on demands. Don't allow bar.baz to be
4410 imported from foo.* */
4411 if (!QUALIFIED_P (TYPE_NAME (class_type)))
4412 if (find_in_imports_on_demand (class_type))
4413 return NULL_TREE;
4414
4415 /* 5- Last call for a resolution */
4416 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
4417 }
4418
4419 /* Resolve NAME and lay it out (if not done and if not the current
4420 parsed class). Return a decl node. This function is meant to be
4421 called when type resolution is necessary during the walk pass. */
4422
4423 static tree
4424 resolve_and_layout (something, cl)
4425 tree something;
4426 tree cl;
4427 {
4428 tree decl;
4429
4430 /* Don't do that on the current class */
4431 if (something == current_class)
4432 return TYPE_NAME (current_class);
4433
4434 /* Don't do anything for void and other primitive types */
4435 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
4436 return NULL_TREE;
4437
4438 /* Pointer types can be reall pointer types or fake pointers. When
4439 finding a real pointer, recheck for primitive types */
4440 if (TREE_CODE (something) == POINTER_TYPE)
4441 {
4442 if (TREE_TYPE (something))
4443 {
4444 something = TREE_TYPE (something);
4445 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
4446 return NULL_TREE;
4447 }
4448 else
4449 something = TYPE_NAME (something);
4450 }
4451
4452 /* Don't do anything for arrays of primitive types */
4453 if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
4454 && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
4455 return NULL_TREE;
4456
4457 /* If something is not and IDENTIFIER_NODE, it can be a a TYPE_DECL
4458 or a real TYPE */
4459 if (TREE_CODE (something) != IDENTIFIER_NODE)
4460 something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
4461 DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
4462
4463 if (!(decl = resolve_no_layout (something, cl)))
4464 return NULL_TREE;
4465
4466 /* Resolve and layout if necessary */
4467 layout_class_methods (TREE_TYPE (decl));
4468 /* Check methods, but only once */
4469 if (CLASS_FROM_SOURCE_P (TREE_TYPE (decl))
4470 && !CLASS_LOADED_P (TREE_TYPE (decl)))
4471 CHECK_METHODS (decl);
4472 if (TREE_TYPE (decl) != current_class && !CLASS_LOADED_P (TREE_TYPE (decl)))
4473 safe_layout_class (TREE_TYPE (decl));
4474
4475 return decl;
4476 }
4477
4478 /* Resolve a class, returns its decl but doesn't perform any
4479 layout. The current parsing context is saved and restored */
4480
4481 static tree
4482 resolve_no_layout (name, cl)
4483 tree name, cl;
4484 {
4485 tree ptr, decl;
4486 BUILD_PTR_FROM_NAME (ptr, name);
4487 java_parser_context_save_global ();
4488 decl = resolve_class (ptr, NULL_TREE, cl);
4489 java_parser_context_restore_global ();
4490
4491 return decl;
4492 }
4493
4494 /* Called when reporting errors. Skip leader '[' in a complex array
4495 type description that failed to be resolved. */
4496
4497 static const char *
4498 purify_type_name (name)
4499 const char *name;
4500 {
4501 while (*name && *name == '[')
4502 name++;
4503 return name;
4504 }
4505
4506 /* The type CURRENT refers to can't be found. We print error messages. */
4507
4508 static void
4509 complete_class_report_errors (dep)
4510 jdep *dep;
4511 {
4512 const char *name;
4513
4514 if (!JDEP_WFL (dep))
4515 return;
4516
4517 name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
4518 switch (JDEP_KIND (dep))
4519 {
4520 case JDEP_SUPER:
4521 parse_error_context
4522 (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
4523 purify_type_name (name),
4524 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
4525 break;
4526 case JDEP_FIELD:
4527 parse_error_context
4528 (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
4529 purify_type_name (name),
4530 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
4531 break;
4532 case JDEP_METHOD: /* Covers arguments */
4533 parse_error_context
4534 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
4535 purify_type_name (name),
4536 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
4537 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
4538 break;
4539 case JDEP_METHOD_RETURN: /* Covers return type */
4540 parse_error_context
4541 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
4542 purify_type_name (name),
4543 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
4544 break;
4545 case JDEP_INTERFACE:
4546 parse_error_context
4547 (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
4548 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
4549 (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
4550 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
4551 break;
4552 case JDEP_VARIABLE:
4553 parse_error_context
4554 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
4555 purify_type_name (IDENTIFIER_POINTER
4556 (EXPR_WFL_NODE (JDEP_WFL (dep)))),
4557 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
4558 break;
4559 case JDEP_EXCEPTION: /* As specified by `throws' */
4560 parse_error_context
4561 (JDEP_WFL (dep), "Class `%s' not found in `throws'",
4562 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
4563 break;
4564 default:
4565 /* Fix for -Wall. Just break doing nothing. The error will be
4566 caught later */
4567 break;
4568 }
4569 }
4570
4571 /* Check uninitialized final. */
4572
4573 void
4574 java_check_final ()
4575 {
4576 }
4577
4578 /* Return a static string containing the DECL prototype string. If
4579 DECL is a constructor, use the class name instead of the form
4580 <init> */
4581
4582 static const char *
4583 get_printable_method_name (decl)
4584 tree decl;
4585 {
4586 const char *to_return;
4587 tree name = NULL_TREE;
4588
4589 if (DECL_CONSTRUCTOR_P (decl))
4590 {
4591 name = DECL_NAME (decl);
4592 DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
4593 }
4594
4595 to_return = lang_printable_name (decl, 0);
4596 if (DECL_CONSTRUCTOR_P (decl))
4597 DECL_NAME (decl) = name;
4598
4599 return to_return;
4600 }
4601
4602 /* Reinstall the proper DECL_NAME on METHOD. Return 0 if the method
4603 nevertheless needs to be verfied, 1 otherwise. */
4604
4605 static int
4606 reset_method_name (method)
4607 tree method;
4608 {
4609 if (!IS_CLINIT (method) && DECL_NAME (method) != finit_identifier_node)
4610 {
4611 /* NAME is just the plain name when Object is being defined */
4612 if (DECL_CONTEXT (method) != object_type_node)
4613 DECL_NAME (method) = (DECL_CONSTRUCTOR_P (method) ?
4614 init_identifier_node : GET_METHOD_NAME (method));
4615 return 0;
4616 }
4617 else
4618 return 1;
4619 }
4620
4621 /* Return the name of METHOD_DECL, when DECL_NAME is a WFL */
4622
4623 tree
4624 java_get_real_method_name (method_decl)
4625 tree method_decl;
4626 {
4627 tree method_name = DECL_NAME (method_decl);
4628 if (DECL_CONSTRUCTOR_P (method_decl))
4629 return init_identifier_node;
4630
4631 /* Explain here why METHOD_DECL doesn't have the DECL_CONSTRUCTUR_P
4632 and still can be a constructor. FIXME */
4633
4634 /* Don't confuse method only bearing the name of their class as
4635 constructors */
4636 else if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (method_decl))
4637 && ctxp
4638 && ctxp->current_parsed_class_un == EXPR_WFL_NODE (method_name)
4639 && get_access_flags_from_decl (method_decl) <= ACC_PROTECTED
4640 && TREE_TYPE (TREE_TYPE (method_decl)) == void_type_node)
4641 return init_identifier_node;
4642 else
4643 return EXPR_WFL_NODE (method_name);
4644 }
4645
4646 /* Track method being redefined inside the same class. As a side
4647 effect, set DECL_NAME to an IDENTIFIER (prior entering this
4648 function it's a FWL, so we can track errors more accurately.) */
4649
4650 static int
4651 check_method_redefinition (class, method)
4652 tree class, method;
4653 {
4654 tree redef, name;
4655 tree cl = DECL_NAME (method);
4656 tree sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
4657 /* decl name of artificial <clinit> and $finit$ doesn't need to be
4658 fixed and checked */
4659
4660 /* Reset the method name before running the check. If it returns 1,
4661 the method doesn't need to be verified with respect to method
4662 redeclaration and we return 0 */
4663 if (reset_method_name (method))
4664 return 0;
4665
4666 name = DECL_NAME (method);
4667 for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
4668 {
4669 if (redef == method)
4670 break;
4671 if (DECL_NAME (redef) == name
4672 && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef)))
4673 {
4674 parse_error_context
4675 (cl, "Duplicate %s declaration `%s'",
4676 (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
4677 get_printable_method_name (redef));
4678 return 1;
4679 }
4680 }
4681 return 0;
4682 }
4683
4684 static void
4685 check_abstract_method_definitions (do_interface, class_decl, type)
4686 int do_interface;
4687 tree class_decl, type;
4688 {
4689 tree class = TREE_TYPE (class_decl);
4690 tree method, end_type;
4691
4692 end_type = (do_interface ? object_type_node : type);
4693 for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
4694 {
4695 tree other_super, other_method, method_sig, method_name;
4696 int found = 0;
4697
4698 if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
4699 continue;
4700
4701 /* Now verify that somewhere in between TYPE and CLASS,
4702 abstract method METHOD gets a non abstract definition
4703 that is inherited by CLASS. */
4704
4705 method_sig = build_java_signature (TREE_TYPE (method));
4706 method_name = DECL_NAME (method);
4707 if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
4708 method_name = EXPR_WFL_NODE (method_name);
4709
4710 for (other_super = class; other_super != end_type;
4711 other_super = CLASSTYPE_SUPER (other_super))
4712 {
4713 for (other_method = TYPE_METHODS (other_super); other_method;
4714 other_method = TREE_CHAIN (other_method))
4715 {
4716 tree s = build_java_signature (TREE_TYPE (other_method));
4717 tree other_name = DECL_NAME (other_method);
4718
4719 if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
4720 other_name = EXPR_WFL_NODE (other_name);
4721 if (!IS_CLINIT (other_method)
4722 && !DECL_CONSTRUCTOR_P (other_method)
4723 && method_name == other_name && method_sig == s)
4724 {
4725 found = 1;
4726 break;
4727 }
4728 }
4729 }
4730
4731 /* Report that abstract METHOD didn't find an implementation
4732 that CLASS can use. */
4733 if (!found)
4734 {
4735 char *t = xstrdup (lang_printable_name
4736 (TREE_TYPE (TREE_TYPE (method)), 0));
4737 tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
4738 tree saved_wfl = NULL_TREE;
4739
4740 if (TREE_CODE (DECL_NAME (method)) == EXPR_WITH_FILE_LOCATION)
4741 {
4742 saved_wfl = DECL_NAME (method);
4743 DECL_NAME (method) = EXPR_WFL_NODE (DECL_NAME (method));
4744 }
4745
4746 parse_error_context
4747 (lookup_cl (class_decl),
4748 "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",
4749 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
4750 t, lang_printable_name (method, 0),
4751 (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
4752 "interface" : "class"),
4753 IDENTIFIER_POINTER (ccn),
4754 (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
4755 IDENTIFIER_POINTER (DECL_NAME (class_decl)));
4756
4757 free (t);
4758
4759 if (saved_wfl)
4760 DECL_NAME (method) = saved_wfl;
4761 }
4762 }
4763 }
4764
4765 /* Check that CLASS_DECL somehoow implements all inherited abstract
4766 methods. */
4767
4768 static void
4769 java_check_abstract_method_definitions (class_decl)
4770 tree class_decl;
4771 {
4772 tree class = TREE_TYPE (class_decl);
4773 tree super, vector;
4774 int i;
4775
4776 if (CLASS_ABSTRACT (class_decl))
4777 return;
4778
4779 /* Check for inherited types */
4780 for (super = CLASSTYPE_SUPER (class); super != object_type_node;
4781 super = CLASSTYPE_SUPER (super))
4782 {
4783 if (!CLASS_ABSTRACT (TYPE_NAME (super)))
4784 continue;
4785
4786 check_abstract_method_definitions (0, class_decl, super);
4787 }
4788
4789 /* Check for implemented interfaces. */
4790 vector = TYPE_BINFO_BASETYPES (class);
4791 for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
4792 {
4793 super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
4794 check_abstract_method_definitions (1, class_decl, super);
4795 }
4796 }
4797
4798 /* Check all the methods of CLASS_DECL. Methods are first completed
4799 then checked according to regular method existance rules. If no
4800 constructor for CLASS_DECL were encountered, then build its
4801 declaration. */
4802
4803 static void
4804 java_check_regular_methods (class_decl)
4805 tree class_decl;
4806 {
4807 int saw_constructor = 0;
4808 tree method;
4809 tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl));
4810 tree super_class = CLASSTYPE_SUPER (class);
4811 tree saved_found_wfl = NULL_TREE, found = NULL_TREE;
4812 tree mthrows;
4813
4814 /* It is not necessary to check methods defined in java.lang.Object */
4815 if (class == object_type_node)
4816 return;
4817
4818 if (!TYPE_NVIRTUALS (class))
4819 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
4820
4821 /* Should take interfaces into account. FIXME */
4822 for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
4823 {
4824 tree sig;
4825 tree method_wfl = DECL_NAME (method);
4826 int aflags;
4827
4828 /* If we previously found something and its name was saved,
4829 reinstall it now */
4830 if (found && saved_found_wfl)
4831 {
4832 DECL_NAME (found) = saved_found_wfl;
4833 saved_found_wfl = NULL_TREE;
4834 }
4835
4836 /* Check for redefinitions */
4837 if (check_method_redefinition (class, method))
4838 continue;
4839
4840 /* If we see one constructor a mark so we don't generate the
4841 default one. Also skip other verifications: constructors
4842 can't be inherited hence hiden or overriden */
4843 if (DECL_CONSTRUCTOR_P (method))
4844 {
4845 saw_constructor = 1;
4846 continue;
4847 }
4848
4849 /* We verify things thrown by the method. They must inherits from
4850 java.lang.Throwable */
4851 for (mthrows = DECL_FUNCTION_THROWS (method);
4852 mthrows; mthrows = TREE_CHAIN (mthrows))
4853 {
4854 if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
4855 parse_error_context
4856 (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
4857 IDENTIFIER_POINTER
4858 (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
4859 }
4860
4861 sig = build_java_argument_signature (TREE_TYPE (method));
4862 found = lookup_argument_method (super_class, DECL_NAME (method), sig);
4863
4864 /* Nothing overrides or it's a private method. */
4865 if (!found)
4866 continue;
4867 if (METHOD_PRIVATE (found))
4868 {
4869 found = NULL_TREE;
4870 continue;
4871 }
4872
4873 /* If found wasn't verified, it's DECL_NAME won't be set properly.
4874 We set it temporarily for the sake of the error report. */
4875 saved_found_wfl = DECL_NAME (found);
4876 reset_method_name (found);
4877
4878 /* Can't override a method with the same name and different return
4879 types. */
4880 if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
4881 {
4882 char *t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)),
4883 0));
4884 parse_error_context
4885 (method_wfl,
4886 "Method `%s' was defined with return type `%s' in class `%s'",
4887 lang_printable_name (found, 0), t,
4888 IDENTIFIER_POINTER
4889 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
4890 free (t);
4891 }
4892
4893 aflags = get_access_flags_from_decl (found);
4894 /* If the method has default, access in an other package, then
4895 issue a warning that the current method doesn't override the
4896 one that was found elsewhere. Do not issue this warning when
4897 the match was found in java.lang.Object. */
4898 if (DECL_CONTEXT (found) != object_type_node
4899 && ((aflags & ACC_VISIBILITY) == 0)
4900 && !class_in_current_package (DECL_CONTEXT (found))
4901 && DECL_NAME (found) != clinit_identifier_node
4902 && flag_not_overriding)
4903 {
4904 parse_warning_context
4905 (method_wfl, "Method `%s' in class `%s' does not override the corresponding method in class `%s', which is private to a different package",
4906 lang_printable_name (found, 0),
4907 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
4908 IDENTIFIER_POINTER (DECL_NAME
4909 (TYPE_NAME (DECL_CONTEXT (found)))));
4910 continue;
4911 }
4912
4913 /* Can't override final. Can't override static. */
4914 if (METHOD_FINAL (found) || METHOD_STATIC (found))
4915 {
4916 /* Static *can* override static */
4917 if (METHOD_STATIC (found) && METHOD_STATIC (method))
4918 continue;
4919 parse_error_context
4920 (method_wfl,
4921 "%s methods can't be overriden. Method `%s' is %s in class `%s'",
4922 (METHOD_FINAL (found) ? "Final" : "Static"),
4923 lang_printable_name (found, 0),
4924 (METHOD_FINAL (found) ? "final" : "static"),
4925 IDENTIFIER_POINTER
4926 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
4927 continue;
4928 }
4929
4930 /* Static method can't override instance method. */
4931 if (METHOD_STATIC (method))
4932 {
4933 parse_error_context
4934 (method_wfl,
4935 "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
4936 lang_printable_name (found, 0),
4937 IDENTIFIER_POINTER
4938 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
4939 continue;
4940 }
4941
4942 /* - Overriding/hiding public must be public
4943 - Overriding/hiding protected must be protected or public
4944 - If the overriden or hidden method has default (package)
4945 access, then the overriding or hiding method must not be
4946 private; otherwise, a compile-time error occurs */
4947 if ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
4948 || (METHOD_PROTECTED (found)
4949 && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
4950 || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
4951 && METHOD_PRIVATE (method)))
4952 {
4953 parse_error_context
4954 (method_wfl,
4955 "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
4956 (METHOD_PUBLIC (method) ? "public" :
4957 (METHOD_PRIVATE (method) ? "private" : "protected")),
4958 IDENTIFIER_POINTER (DECL_NAME
4959 (TYPE_NAME (DECL_CONTEXT (found)))));
4960 continue;
4961 }
4962
4963 /* Overriding methods must have compatible `throws' clauses on checked
4964 exceptions, if any */
4965 check_throws_clauses (method, method_wfl, found);
4966
4967 /* Inheriting multiple methods with the same signature. FIXME */
4968 }
4969
4970 /* Don't forget eventual pending found and saved_found_wfl. Take
4971 into account that we might have exited because we saw an
4972 artificial method as the last entry. */
4973
4974 if (found && !DECL_ARTIFICIAL (found) && saved_found_wfl)
4975 DECL_NAME (found) = saved_found_wfl;
4976
4977 if (!TYPE_NVIRTUALS (class))
4978 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
4979
4980 /* Search for inherited abstract method not yet implemented in this
4981 class. */
4982 java_check_abstract_method_definitions (class_decl);
4983
4984 if (!saw_constructor)
4985 fatal ("No constructor found");
4986 }
4987
4988 /* Return a non zero value if the `throws' clause of METHOD (if any)
4989 is incompatible with the `throws' clause of FOUND (if any). */
4990
4991 static void
4992 check_throws_clauses (method, method_wfl, found)
4993 tree method, method_wfl, found;
4994 {
4995 tree mthrows, fthrows;
4996
4997 /* Can't check these things with class loaded from bytecode. FIXME */
4998 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
4999 return;
5000
5001 for (mthrows = DECL_FUNCTION_THROWS (method);
5002 mthrows; mthrows = TREE_CHAIN (mthrows))
5003 {
5004 /* We don't verify unchecked expressions */
5005 if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
5006 continue;
5007 /* Checked expression must be compatible */
5008 for (fthrows = DECL_FUNCTION_THROWS (found);
5009 fthrows; fthrows = TREE_CHAIN (fthrows))
5010 if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
5011 break;
5012 if (!fthrows)
5013 {
5014 parse_error_context
5015 (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'",
5016 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
5017 lang_printable_name (found, 0),
5018 IDENTIFIER_POINTER
5019 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
5020 }
5021 }
5022 }
5023
5024 /* Check abstract method of interface INTERFACE */
5025
5026 static void
5027 java_check_abstract_methods (interface_decl)
5028 tree interface_decl;
5029 {
5030 int i, n;
5031 tree method, basetype_vec, found;
5032 tree interface = TREE_TYPE (interface_decl);
5033
5034 for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
5035 {
5036 tree method_wfl = DECL_NAME (method);
5037
5038 /* 2- Check for double definition inside the defining interface */
5039 if (check_method_redefinition (interface, method))
5040 continue;
5041
5042 /* 3- Overriding is OK as far as we preserve the return type and
5043 the thrown exceptions (FIXME) */
5044 found = lookup_java_interface_method2 (interface, method);
5045 if (found)
5046 {
5047 char *t;
5048 tree saved_found_wfl = DECL_NAME (found);
5049 reset_method_name (found);
5050 t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
5051 parse_error_context
5052 (method_wfl,
5053 "Method `%s' was defined with return type `%s' in class `%s'",
5054 lang_printable_name (found, 0), t,
5055 IDENTIFIER_POINTER
5056 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
5057 free (t);
5058 DECL_NAME (found) = saved_found_wfl;
5059 continue;
5060 }
5061 }
5062
5063 /* 4- Inherited methods can't differ by their returned types */
5064 if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
5065 return;
5066 n = TREE_VEC_LENGTH (basetype_vec);
5067 for (i = 0; i < n; i++)
5068 {
5069 tree sub_interface_method, sub_interface;
5070 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5071 if (!vec_elt)
5072 continue;
5073 sub_interface = BINFO_TYPE (vec_elt);
5074 for (sub_interface_method = TYPE_METHODS (sub_interface);
5075 sub_interface_method;
5076 sub_interface_method = TREE_CHAIN (sub_interface_method))
5077 {
5078 found = lookup_java_interface_method2 (interface,
5079 sub_interface_method);
5080 if (found && (found != sub_interface_method))
5081 {
5082 tree saved_found_wfl = DECL_NAME (found);
5083 reset_method_name (found);
5084 parse_error_context
5085 (lookup_cl (sub_interface_method),
5086 "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
5087 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
5088 lang_printable_name (found, 0),
5089 IDENTIFIER_POINTER
5090 (DECL_NAME (TYPE_NAME
5091 (DECL_CONTEXT (sub_interface_method)))),
5092 IDENTIFIER_POINTER
5093 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
5094 DECL_NAME (found) = saved_found_wfl;
5095 }
5096 }
5097 }
5098 }
5099
5100 /* Lookup methods in interfaces using their name and partial
5101 signature. Return a matching method only if their types differ. */
5102
5103 static tree
5104 lookup_java_interface_method2 (class, method_decl)
5105 tree class, method_decl;
5106 {
5107 int i, n;
5108 tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
5109
5110 if (!basetype_vec)
5111 return NULL_TREE;
5112
5113 n = TREE_VEC_LENGTH (basetype_vec);
5114 for (i = 0; i < n; i++)
5115 {
5116 tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
5117 if ((BINFO_TYPE (vec_elt) != object_type_node)
5118 && (to_return =
5119 lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
5120 return to_return;
5121 }
5122 for (i = 0; i < n; i++)
5123 {
5124 to_return = lookup_java_interface_method2
5125 (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
5126 if (to_return)
5127 return to_return;
5128 }
5129
5130 return NULL_TREE;
5131 }
5132
5133 /* Lookup method using their name and partial signature. Return a
5134 matching method only if their types differ. */
5135
5136 static tree
5137 lookup_java_method2 (clas, method_decl, do_interface)
5138 tree clas, method_decl;
5139 int do_interface;
5140 {
5141 tree method, method_signature, method_name, method_type, name;
5142
5143 method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
5144 name = DECL_NAME (method_decl);
5145 method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
5146 EXPR_WFL_NODE (name) : name);
5147 method_type = TREE_TYPE (TREE_TYPE (method_decl));
5148
5149 while (clas != NULL_TREE)
5150 {
5151 for (method = TYPE_METHODS (clas);
5152 method != NULL_TREE; method = TREE_CHAIN (method))
5153 {
5154 tree method_sig = build_java_argument_signature (TREE_TYPE (method));
5155 tree name = DECL_NAME (method);
5156 if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
5157 EXPR_WFL_NODE (name) : name) == method_name
5158 && method_sig == method_signature
5159 && TREE_TYPE (TREE_TYPE (method)) != method_type)
5160 return method;
5161 }
5162 clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
5163 }
5164 return NULL_TREE;
5165 }
5166
5167 /* Return the line that matches DECL line number, and try its best to
5168 position the column number. Used during error reports. */
5169
5170 static tree
5171 lookup_cl (decl)
5172 tree decl;
5173 {
5174 static tree cl = NULL_TREE;
5175 char *line, *found;
5176
5177 if (!decl)
5178 return NULL_TREE;
5179
5180 if (cl == NULL_TREE)
5181 cl = build_expr_wfl (NULL_TREE, NULL, 0, 0);
5182
5183 EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl));
5184 EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1);
5185
5186 line = java_get_line_col (IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE (cl)),
5187 EXPR_WFL_LINENO (cl), EXPR_WFL_COLNO (cl));
5188
5189 found = strstr ((const char *)line,
5190 (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
5191 if (found)
5192 EXPR_WFL_SET_LINECOL (cl, EXPR_WFL_LINENO (cl), found - line);
5193
5194 return cl;
5195 }
5196
5197 /* Look for a simple name in the single-type import list */
5198
5199 static tree
5200 find_name_in_single_imports (name)
5201 tree name;
5202 {
5203 tree node;
5204
5205 for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
5206 if (TREE_VALUE (node) == name)
5207 return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
5208
5209 return NULL_TREE;
5210 }
5211
5212 /* Process all single-type import. */
5213
5214 static int
5215 process_imports ()
5216 {
5217 tree import;
5218 int error_found;
5219
5220 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
5221 {
5222 tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
5223
5224 /* Don't load twice something already defined. */
5225 if (IDENTIFIER_CLASS_VALUE (to_be_found))
5226 continue;
5227 QUALIFIED_P (to_be_found) = 1;
5228 load_class (to_be_found, 0);
5229 error_found =
5230 check_pkg_class_access (to_be_found, TREE_PURPOSE (import));
5231 if (!IDENTIFIER_CLASS_VALUE (to_be_found))
5232 {
5233 parse_error_context (TREE_PURPOSE (import),
5234 "Class or interface `%s' not found in import",
5235 IDENTIFIER_POINTER (to_be_found));
5236 return 1;
5237 }
5238 if (error_found)
5239 return 1;
5240 }
5241 return 0;
5242 }
5243
5244 /* Possibly find a class imported by a single-type import statement. Return
5245 1 if an error occured, 0 otherwise. */
5246
5247 static int
5248 find_in_imports (class_type)
5249 tree class_type;
5250 {
5251 tree import;
5252
5253 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
5254 if (TREE_VALUE (import) == TYPE_NAME (class_type))
5255 {
5256 TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
5257 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
5258 }
5259 return 0;
5260 }
5261
5262 static int
5263 note_possible_classname (name, len)
5264 const char *name;
5265 int len;
5266 {
5267 tree node;
5268 if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
5269 len = len - 5;
5270 else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
5271 len = len - 6;
5272 else
5273 return 0;
5274 node = ident_subst (name, len, "", '/', '.', "");
5275 IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
5276 QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
5277 return 1;
5278 }
5279
5280 /* Read a import directory, gathering potential match for further type
5281 references. Indifferently reads a filesystem or a ZIP archive
5282 directory. */
5283
5284 static void
5285 read_import_dir (wfl)
5286 tree wfl;
5287 {
5288 tree package_id = EXPR_WFL_NODE (wfl);
5289 const char *package_name = IDENTIFIER_POINTER (package_id);
5290 int package_length = IDENTIFIER_LENGTH (package_id);
5291 DIR *dirp = NULL;
5292 JCF *saved_jcf = current_jcf;
5293
5294 int found = 0;
5295 int k;
5296 void *entry;
5297 struct buffer filename[1];
5298
5299
5300 if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
5301 return;
5302 IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
5303
5304 BUFFER_INIT (filename);
5305 buffer_grow (filename, package_length + 100);
5306
5307 for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
5308 {
5309 const char *entry_name = jcf_path_name (entry);
5310 int entry_length = strlen (entry_name);
5311 if (jcf_path_is_zipfile (entry))
5312 {
5313 ZipFile *zipf;
5314 buffer_grow (filename, entry_length);
5315 memcpy (filename->data, entry_name, entry_length - 1);
5316 filename->data[entry_length-1] = '\0';
5317 zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
5318 if (zipf == NULL)
5319 error ("malformed .zip archive in CLASSPATH: %s", entry_name);
5320 else
5321 {
5322 ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
5323 BUFFER_RESET (filename);
5324 for (k = 0; k < package_length; k++)
5325 {
5326 char ch = package_name[k];
5327 *filename->ptr++ = ch == '.' ? '/' : ch;
5328 }
5329 *filename->ptr++ = '/';
5330
5331 for (k = 0; k < zipf->count; k++, zipd = ZIPDIR_NEXT (zipd))
5332 {
5333 const char *current_entry = ZIPDIR_FILENAME (zipd);
5334 int current_entry_len = zipd->filename_length;
5335
5336 if (current_entry_len >= BUFFER_LENGTH (filename)
5337 && strncmp (filename->data, current_entry,
5338 BUFFER_LENGTH (filename)) != 0)
5339 continue;
5340 found |= note_possible_classname (current_entry,
5341 current_entry_len);
5342 }
5343 }
5344 }
5345 else
5346 {
5347 BUFFER_RESET (filename);
5348 buffer_grow (filename, entry_length + package_length + 4);
5349 strcpy (filename->data, entry_name);
5350 filename->ptr = filename->data + entry_length;
5351 for (k = 0; k < package_length; k++)
5352 {
5353 char ch = package_name[k];
5354 *filename->ptr++ = ch == '.' ? '/' : ch;
5355 }
5356 *filename->ptr = '\0';
5357
5358 dirp = opendir (filename->data);
5359 if (dirp == NULL)
5360 continue;
5361 *filename->ptr++ = '/';
5362 for (;;)
5363 {
5364 int len;
5365 const char *d_name;
5366 struct dirent *direntp = readdir (dirp);
5367 if (!direntp)
5368 break;
5369 d_name = direntp->d_name;
5370 len = strlen (direntp->d_name);
5371 buffer_grow (filename, len+1);
5372 strcpy (filename->ptr, d_name);
5373 found |= note_possible_classname (filename->data + entry_length,
5374 package_length+len+1);
5375 }
5376 if (dirp)
5377 closedir (dirp);
5378 }
5379 }
5380
5381 free (filename->data);
5382
5383 /* Here we should have a unified way of retrieving an entry, to be
5384 indexed. */
5385 if (!found)
5386 {
5387 static int first = 1;
5388 if (first)
5389 {
5390 error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives.", package_name);
5391 java_error_count++;
5392 first = 0;
5393 }
5394 else
5395 parse_error_context (wfl, "Package `%s' not found in import",
5396 package_name);
5397 current_jcf = saved_jcf;
5398 return;
5399 }
5400 current_jcf = saved_jcf;
5401 }
5402
5403 /* Possibly find a type in the import on demands specified
5404 types. Returns 1 if an error occured, 0 otherwise. Run throught the
5405 entire list, to detected potential double definitions. */
5406
5407 static int
5408 find_in_imports_on_demand (class_type)
5409 tree class_type;
5410 {
5411 tree node, import, node_to_use = NULL_TREE;
5412 int seen_once = -1;
5413 tree cl = NULL_TREE;
5414
5415 for (import = ctxp->import_demand_list; import; import = TREE_CHAIN (import))
5416 {
5417 const char *id_name;
5418 obstack_grow (&temporary_obstack,
5419 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
5420 IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
5421 obstack_1grow (&temporary_obstack, '.');
5422 obstack_grow0 (&temporary_obstack,
5423 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
5424 IDENTIFIER_LENGTH (TYPE_NAME (class_type)));
5425 id_name = obstack_finish (&temporary_obstack);
5426
5427 node = maybe_get_identifier (id_name);
5428 if (node && IS_A_CLASSFILE_NAME (node))
5429 {
5430 if (seen_once < 0)
5431 {
5432 cl = TREE_PURPOSE (import);
5433 seen_once = 1;
5434 node_to_use = node;
5435 }
5436 else
5437 {
5438 seen_once++;
5439 parse_error_context
5440 (import, "Type `%s' also potentially defined in package `%s'",
5441 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
5442 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))));
5443 }
5444 }
5445 }
5446
5447 if (seen_once == 1)
5448 {
5449 /* Setup lineno so that it refers to the line of the import (in
5450 case we parse a class file and encounter errors */
5451 tree decl;
5452 int saved_lineno = lineno;
5453 lineno = EXPR_WFL_LINENO (cl);
5454 TYPE_NAME (class_type) = node_to_use;
5455 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
5456 decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5457 /* If there is no DECL set for the class or if the class isn't
5458 loaded and not seen in source yet, the load */
5459 if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
5460 && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
5461 load_class (node_to_use, 0);
5462 lineno = saved_lineno;
5463 return check_pkg_class_access (TYPE_NAME (class_type), cl);
5464 }
5465 else
5466 return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
5467 }
5468
5469 static tree
5470 resolve_package (pkg, next)
5471 tree pkg, *next;
5472 {
5473 tree current;
5474 tree type_name = NULL_TREE;
5475 const char *name = IDENTIFIER_POINTER (EXPR_WFL_NODE (pkg));
5476
5477 /* The trick is to determine when the package name stops and were
5478 the name of something contained in the package starts. Then we
5479 return a fully qualified name of what we want to get. */
5480
5481 /* Do a quick search on well known package names */
5482 if (!strncmp (name, "java.lang.reflect", 17))
5483 {
5484 *next =
5485 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg))));
5486 type_name = lookup_package_type (name, 17);
5487 }
5488 else if (!strncmp (name, "java.lang", 9))
5489 {
5490 *next = TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg)));
5491 type_name = lookup_package_type (name, 9);
5492 }
5493
5494 /* If we found something here, return */
5495 if (type_name)
5496 return type_name;
5497
5498 *next = EXPR_WFL_QUALIFICATION (pkg);
5499
5500 /* Try the current package. */
5501 if (ctxp->package && !strncmp (name, IDENTIFIER_POINTER (ctxp->package),
5502 IDENTIFIER_LENGTH (ctxp->package)))
5503 {
5504 type_name =
5505 lookup_package_type_and_set_next (name,
5506 IDENTIFIER_LENGTH (ctxp->package),
5507 next );
5508 if (type_name)
5509 return type_name;
5510 }
5511
5512 /* Search in imported package */
5513 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
5514 {
5515 tree current_pkg_name = EXPR_WFL_NODE (TREE_PURPOSE (current));
5516 int len = IDENTIFIER_LENGTH (current_pkg_name);
5517 if (!strncmp (name, IDENTIFIER_POINTER (current_pkg_name), len))
5518 {
5519 tree left, dummy;
5520
5521 breakdown_qualified (&left, &dummy, current_pkg_name);
5522 len = IDENTIFIER_LENGTH (left);
5523 type_name = lookup_package_type_and_set_next (name, len, next);
5524 if (type_name)
5525 break;
5526 }
5527 }
5528
5529 return type_name;
5530 }
5531
5532 static tree
5533 lookup_package_type_and_set_next (name, len, next)
5534 const char *name;
5535 int len;
5536 tree *next;
5537 {
5538 const char *ptr;
5539 tree type_name = lookup_package_type (name, len);
5540
5541 if (!type_name)
5542 return NULL;
5543
5544 ptr = IDENTIFIER_POINTER (type_name);
5545 while (ptr && (ptr = strchr (ptr, '.')))
5546 {
5547 *next = TREE_CHAIN (*next);
5548 ptr++;
5549 }
5550 return type_name;
5551 }
5552
5553 static tree
5554 lookup_package_type (name, from)
5555 const char *name;
5556 int from;
5557 {
5558 char subname [128];
5559 const char *sub = &name[from+1];
5560 while (*sub != '.' && *sub)
5561 sub++;
5562 strncpy (subname, name, sub-name);
5563 subname [sub-name] = '\0';
5564 return get_identifier (subname);
5565 }
5566
5567 /* Check that CLASS_NAME refers to a PUBLIC class. Return 0 if no
5568 access violations were found, 1 otherwise. */
5569
5570 static int
5571 check_pkg_class_access (class_name, cl)
5572 tree class_name;
5573 tree cl;
5574 {
5575 tree type;
5576
5577 if (!QUALIFIED_P (class_name) || !IDENTIFIER_CLASS_VALUE (class_name))
5578 return 0;
5579
5580 if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
5581 return 0;
5582
5583 if (!CLASS_PUBLIC (TYPE_NAME (type)))
5584 {
5585 /* Access to a private class within the same package is
5586 allowed. */
5587 tree l, r;
5588 breakdown_qualified (&l, &r, class_name);
5589 if (l == ctxp->package)
5590 return 0;
5591
5592 parse_error_context
5593 (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
5594 (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
5595 IDENTIFIER_POINTER (class_name));
5596 return 1;
5597 }
5598 return 0;
5599 }
5600
5601 /* Local variable declaration. */
5602
5603 static void
5604 declare_local_variables (modifier, type, vlist)
5605 int modifier;
5606 tree type;
5607 tree vlist;
5608 {
5609 tree decl, current, saved_type;
5610 tree type_wfl = NULL_TREE;
5611 int must_chain = 0;
5612
5613 /* Push a new block if statements were seen between the last time we
5614 pushed a block and now. Keep a cound of block to close */
5615 if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
5616 {
5617 tree body = GET_CURRENT_BLOCK (current_function_decl);
5618 tree b = enter_block ();
5619 BLOCK_EXPR_ORIGIN (b) = body;
5620 }
5621
5622 if (modifier)
5623 {
5624 int i;
5625 for (i = 0; i <= 10; i++) if (1 << i & modifier) break;
5626 if (modifier == ACC_FINAL)
5627 {
5628 if (flag_static_local_jdk1_1)
5629 parse_warning_context (ctxp->modifier_ctx [i],
5630 "Unsupported JDK1.1 `final' local variable (treated as non final)");
5631 }
5632 else
5633 {
5634 parse_error_context
5635 (ctxp->modifier_ctx [i],
5636 "Only `final' is allowed as a local variables modifier");
5637 return;
5638 }
5639 }
5640
5641 /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
5642 hold the TYPE value if a new incomplete has to be created (as
5643 opposed to being found already existing and reused). */
5644 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
5645
5646 /* If TYPE is fully resolved and we don't have a reference, make one */
5647 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
5648
5649 /* Go through all the declared variables */
5650 for (current = vlist, saved_type = type; current;
5651 current = TREE_CHAIN (current), type = saved_type)
5652 {
5653 tree other, real_type;
5654 tree wfl = TREE_PURPOSE (current);
5655 tree name = EXPR_WFL_NODE (wfl);
5656 tree init = TREE_VALUE (current);
5657
5658 /* Process NAME, as it may specify extra dimension(s) for it */
5659 type = build_array_from_name (type, type_wfl, name, &name);
5660
5661 /* Variable redefinition check */
5662 if ((other = lookup_name_in_blocks (name)))
5663 {
5664 variable_redefinition_error (wfl, name, TREE_TYPE (other),
5665 DECL_SOURCE_LINE (other));
5666 continue;
5667 }
5668
5669 /* Type adjustment. We may have just readjusted TYPE because
5670 the variable specified more dimensions. Make sure we have
5671 a reference if we can and don't have one already. */
5672 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
5673
5674 real_type = GET_REAL_TYPE (type);
5675 /* Never layout this decl. This will be done when its scope
5676 will be entered */
5677 decl = build_decl (VAR_DECL, name, real_type);
5678 BLOCK_CHAIN_DECL (decl);
5679
5680 /* If doing xreferencing, replace the line number with the WFL
5681 compound value */
5682 if (flag_emit_xref)
5683 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
5684
5685 /* Don't try to use an INIT statement when an error was found */
5686 if (init && java_error_count)
5687 init = NULL_TREE;
5688
5689 /* Add the initialization function to the current function's code */
5690 if (init)
5691 {
5692 /* Name might have been readjusted */
5693 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
5694 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
5695 java_method_add_stmt (current_function_decl,
5696 build_debugable_stmt (EXPR_WFL_LINECOL (init),
5697 init));
5698 }
5699
5700 /* Setup dependency the type of the decl */
5701 if (must_chain)
5702 {
5703 jdep *dep;
5704 register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
5705 dep = CLASSD_LAST (ctxp->classd_list);
5706 JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
5707 }
5708 }
5709 SOURCE_FRONTEND_DEBUG (("Defined locals"));
5710 }
5711
5712 /* Called during parsing. Build decls from argument list. */
5713
5714 static void
5715 source_start_java_method (fndecl)
5716 tree fndecl;
5717 {
5718 tree tem;
5719 tree parm_decl;
5720 int i;
5721
5722 if (!fndecl)
5723 return;
5724
5725 current_function_decl = fndecl;
5726
5727 /* New scope for the function */
5728 enter_block ();
5729 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
5730 tem != end_params_node; tem = TREE_CHAIN (tem), i++)
5731 {
5732 tree type = TREE_VALUE (tem);
5733 tree name = TREE_PURPOSE (tem);
5734
5735 /* If type is incomplete. Create an incomplete decl and ask for
5736 the decl to be patched later */
5737 if (INCOMPLETE_TYPE_P (type))
5738 {
5739 jdep *jdep;
5740 tree real_type = GET_REAL_TYPE (type);
5741 parm_decl = build_decl (PARM_DECL, name, real_type);
5742 type = obtain_incomplete_type (type);
5743 register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
5744 jdep = CLASSD_LAST (ctxp->classd_list);
5745 JDEP_MISC (jdep) = name;
5746 JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
5747 }
5748 else
5749 parm_decl = build_decl (PARM_DECL, name, type);
5750
5751 BLOCK_CHAIN_DECL (parm_decl);
5752 }
5753 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
5754 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
5755 nreverse (tem);
5756 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
5757 }
5758
5759 /* Called during parsing. Creates an artificial method declaration. */
5760
5761 static tree
5762 create_artificial_method (class, flags, type, name, args)
5763 tree class;
5764 int flags;
5765 tree type, name, args;
5766 {
5767 int saved_lineno = lineno;
5768 tree mdecl;
5769
5770 lineno = 0;
5771 mdecl = make_node (FUNCTION_TYPE);
5772 TREE_TYPE (mdecl) = type;
5773 TYPE_ARG_TYPES (mdecl) = args;
5774 mdecl = add_method (class, flags, name, build_java_signature (mdecl));
5775 lineno = saved_lineno;
5776 DECL_ARTIFICIAL (mdecl) = 1;
5777 return mdecl;
5778 }
5779
5780 /* Starts the body if an artifical method. */
5781
5782 static void
5783 start_artificial_method_body (mdecl)
5784 tree mdecl;
5785 {
5786 DECL_SOURCE_LINE (mdecl) = 1;
5787 DECL_SOURCE_LINE_MERGE (mdecl, 1);
5788 source_start_java_method (mdecl);
5789 enter_block ();
5790 }
5791
5792 static void
5793 end_artificial_method_body (mdecl)
5794 tree mdecl;
5795 {
5796 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block ();
5797 exit_block ();
5798 }
5799
5800 /* Called during expansion. Push decls formerly built from argument
5801 list so they're usable during expansion. */
5802
5803 static void
5804 expand_start_java_method (fndecl)
5805 tree fndecl;
5806 {
5807 tree tem, *ptr;
5808
5809 current_function_decl = fndecl;
5810
5811 announce_function (fndecl);
5812 pushlevel (1); /* Push parameters */
5813 ptr = &DECL_ARGUMENTS (fndecl);
5814 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
5815 while (tem)
5816 {
5817 tree next = TREE_CHAIN (tem);
5818 tree type = TREE_TYPE (tem);
5819 if (PROMOTE_PROTOTYPES
5820 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
5821 && INTEGRAL_TYPE_P (type))
5822 type = integer_type_node;
5823 DECL_ARG_TYPE (tem) = type;
5824 layout_decl (tem, 0);
5825 pushdecl (tem);
5826 *ptr = tem;
5827 ptr = &TREE_CHAIN (tem);
5828 tem = next;
5829 }
5830 *ptr = NULL_TREE;
5831 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
5832 lineno = DECL_SOURCE_LINE_FIRST (fndecl);
5833 }
5834
5835 /* Terminate a function and expand its body. */
5836
5837 static void
5838 source_end_java_method ()
5839 {
5840 tree fndecl = current_function_decl;
5841 int flag_asynchronous_exceptions = asynchronous_exceptions;
5842
5843 if (!fndecl)
5844 return;
5845
5846 java_parser_context_save_global ();
5847 lineno = ctxp->last_ccb_indent1;
5848
5849 /* Set EH language codes */
5850 java_set_exception_lang_code ();
5851
5852 /* Turn function bodies with only a NOP expr null, so they don't get
5853 generated at all and we won't get warnings when using the -W
5854 -Wall flags. */
5855 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
5856 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
5857
5858 /* Generate function's code */
5859 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
5860 && ! flag_emit_class_files
5861 && ! flag_emit_xref)
5862 expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
5863
5864 /* pop out of its parameters */
5865 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
5866 poplevel (1, 0, 1);
5867 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
5868
5869 /* Generate rtl for function exit. */
5870 if (! flag_emit_class_files && ! flag_emit_xref)
5871 {
5872 lineno = DECL_SOURCE_LINE_LAST (fndecl);
5873 /* Emit catch-finally clauses */
5874 emit_handlers ();
5875 expand_function_end (input_filename, lineno, 0);
5876
5877 /* FIXME: If the current method contains any exception handlers,
5878 force asynchronous_exceptions: this is necessary because signal
5879 handlers in libjava may throw exceptions. This is far from being
5880 a perfect solution, but it's better than doing nothing at all.*/
5881 if (catch_clauses)
5882 asynchronous_exceptions = 1;
5883
5884 /* Run the optimizers and output assembler code for this function. */
5885 rest_of_compilation (fndecl);
5886 }
5887
5888 current_function_decl = NULL_TREE;
5889 permanent_allocation (1);
5890 java_parser_context_restore_global ();
5891 asynchronous_exceptions = flag_asynchronous_exceptions;
5892 }
5893
5894 /* Record EXPR in the current function block. Complements compound
5895 expression second operand if necessary. */
5896
5897 tree
5898 java_method_add_stmt (fndecl, expr)
5899 tree fndecl, expr;
5900 {
5901 if (!GET_CURRENT_BLOCK (fndecl))
5902 return NULL_TREE;
5903 return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
5904 }
5905
5906 static tree
5907 add_stmt_to_block (b, type, stmt)
5908 tree b, type, stmt;
5909 {
5910 tree body = BLOCK_EXPR_BODY (b), c;
5911
5912 if (java_error_count)
5913 return body;
5914
5915 if ((c = add_stmt_to_compound (body, type, stmt)) == body)
5916 return body;
5917
5918 BLOCK_EXPR_BODY (b) = c;
5919 TREE_SIDE_EFFECTS (c) = 1;
5920 return c;
5921 }
5922
5923 /* Add STMT to EXISTING if possible, otherwise create a new
5924 COMPOUND_EXPR and add STMT to it. */
5925
5926 static tree
5927 add_stmt_to_compound (existing, type, stmt)
5928 tree existing, type, stmt;
5929 {
5930 if (existing)
5931 return build (COMPOUND_EXPR, type, existing, stmt);
5932 else
5933 return stmt;
5934 }
5935
5936 /* Hold THIS for the scope of the current public method decl. */
5937 static tree current_this;
5938
5939 void java_layout_seen_class_methods ()
5940 {
5941 tree previous_list = all_class_list;
5942 tree end = NULL_TREE;
5943 tree current;
5944
5945 while (1)
5946 {
5947 for (current = previous_list;
5948 current != end; current = TREE_CHAIN (current))
5949 layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
5950
5951 if (previous_list != all_class_list)
5952 {
5953 end = previous_list;
5954 previous_list = all_class_list;
5955 }
5956 else
5957 break;
5958 }
5959 }
5960
5961 /* Layout the methods of all classes loaded in one way on an
5962 other. Check methods of source parsed classes. Then reorder the
5963 fields and layout the classes or the type of all source parsed
5964 classes */
5965
5966 void
5967 java_layout_classes ()
5968 {
5969 tree current;
5970 int save_error_count = java_error_count;
5971
5972 /* Layout the methods of all classes seen so far */
5973 java_layout_seen_class_methods ();
5974 java_parse_abort_on_error ();
5975 all_class_list = NULL_TREE;
5976
5977 /* Then check the methods of all parsed classes */
5978 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
5979 if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
5980 CHECK_METHODS (TREE_VALUE (current));
5981 java_parse_abort_on_error ();
5982
5983 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
5984 {
5985 current_class = TREE_TYPE (TREE_VALUE (current));
5986
5987 /* Reverse the fields, but leave the dummy field in front.
5988 Fields are already ordered for Object and Class */
5989 if (TYPE_FIELDS (current_class) && current_class != object_type_node
5990 && current_class != class_type_node)
5991 {
5992 /* If the dummy field is there, reverse the right fields and
5993 just layout the type for proper fields offset */
5994 if (!DECL_NAME (TYPE_FIELDS (current_class)))
5995 {
5996 tree fields = TYPE_FIELDS (current_class);
5997 TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
5998 TYPE_SIZE (current_class) = NULL_TREE;
5999 layout_type (current_class);
6000 }
6001 /* We don't have a dummy field, we need to layout the class,
6002 after having reversed the fields */
6003 else
6004 {
6005 TYPE_FIELDS (current_class) =
6006 nreverse (TYPE_FIELDS (current_class));
6007 TYPE_SIZE (current_class) = NULL_TREE;
6008 layout_class (current_class);
6009 }
6010 }
6011 else
6012 layout_class (current_class);
6013
6014 /* From now on, the class is considered completely loaded */
6015 CLASS_LOADED_P (current_class) = 1;
6016
6017 /* Error reported by the caller */
6018 if (java_error_count)
6019 return;
6020 }
6021
6022 /* We might have reloaded classes durign the process of laying out
6023 classes for code generation. We must layout the methods of those
6024 late additions, as constructor checks might use them */
6025 java_layout_seen_class_methods ();
6026 java_parse_abort_on_error ();
6027 }
6028
6029 /* Expand all methods in all registered classes. */
6030
6031 static void
6032 java_complete_expand_methods ()
6033 {
6034 tree current;
6035
6036 do_not_fold = flag_emit_xref;
6037
6038 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
6039 {
6040 int is_interface;
6041 tree class_type = CLASS_TO_HANDLE_TYPE (TREE_TYPE (current));
6042 tree decl, prev_decl;
6043
6044 current_class = TREE_TYPE (current);
6045 is_interface = CLASS_INTERFACE (TYPE_NAME (current_class));
6046
6047 /* Initialize a new constant pool */
6048 init_outgoing_cpool ();
6049
6050 /* We want <clinit> (if any) to be processed first. */
6051 for (prev_decl = NULL_TREE, decl = TYPE_METHODS (class_type);
6052 decl; prev_decl= decl, decl = TREE_CHAIN (decl))
6053 if (IS_CLINIT (decl))
6054 {
6055 if (!java_pre_expand_clinit (decl))
6056 {
6057 if (prev_decl)
6058 TREE_CHAIN (prev_decl) = TREE_CHAIN (decl);
6059 else
6060 TYPE_METHODS (class_type) = TREE_CHAIN (decl);
6061 }
6062 break;
6063 }
6064
6065 /* Now go on for regular business. */
6066 for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
6067 {
6068 current_function_decl = decl;
6069 /* Don't generate debug info on line zero when expanding a
6070 generated constructor. */
6071 if (DECL_CONSTRUCTOR_P (decl) && !DECL_FUNCTION_BODY (decl))
6072 {
6073 /* If we found errors, it's too dangerous to try to
6074 generate and expand a constructor */
6075 if (!java_error_count)
6076 {
6077 restore_line_number_status (1);
6078 java_complete_expand_method (decl);
6079 restore_line_number_status (0);
6080 }
6081 }
6082 else if (METHOD_ABSTRACT (decl) || METHOD_NATIVE (decl))
6083 continue;
6084 else
6085 java_complete_expand_method (decl);
6086 }
6087
6088 /* Now verify constructor circularity (stop after the first one
6089 we find) */
6090 if (!is_interface)
6091 for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
6092 if (DECL_CONSTRUCTOR_P (decl) &&
6093 verify_constructor_circularity (decl, decl))
6094 break;
6095
6096 /* Make the class data, register it and run the rest of decl
6097 compilation on it */
6098 if (!java_error_count)
6099 {
6100 if (flag_emit_class_files)
6101 write_classfile (current_class);
6102 if (flag_emit_xref)
6103 expand_xref (current_class);
6104 else if (! flag_syntax_only)
6105 finish_class ();
6106 }
6107 }
6108 }
6109
6110 /* Hold a list of catch clauses list. The first element of this list is
6111 the list of the catch clauses of the currently analysed try block. */
6112 static tree currently_caught_type_list;
6113
6114 /* Complete and expand <clinit>. Return a non zero value if <clinit>
6115 is worth keeping. */
6116
6117 static int
6118 java_pre_expand_clinit (decl)
6119 tree decl;
6120 {
6121 tree fbody = DECL_FUNCTION_BODY (decl);
6122 int to_return = 1;
6123
6124 if (fbody != NULL_TREE)
6125 {
6126 /* First check if we can ignore empty <clinit> */
6127 tree block_body = BLOCK_EXPR_BODY (fbody);
6128
6129 current_this = NULL_TREE;
6130 current_function_decl = decl;
6131 if (block_body != NULL_TREE)
6132 {
6133 /* Prevent the use of `this' inside <clinit> */
6134 ctxp->explicit_constructor_p = 1;
6135 block_body = java_complete_tree (block_body);
6136 ctxp->explicit_constructor_p = 0;
6137
6138 BLOCK_EXPR_BODY (fbody) = block_body;
6139 if (block_body != NULL_TREE && TREE_CODE (block_body) == BLOCK
6140 && BLOCK_EXPR_BODY (block_body) == empty_stmt_node)
6141 to_return = 0;
6142 }
6143 }
6144 return to_return;
6145 }
6146
6147 /* Complete and expand a method. */
6148
6149 static void
6150 java_complete_expand_method (mdecl)
6151 tree mdecl;
6152 {
6153 /* Fix constructors before expanding them */
6154 if (DECL_CONSTRUCTOR_P (mdecl))
6155 fix_constructors (mdecl);
6156
6157 /* Expand functions that have a body */
6158 if (DECL_FUNCTION_BODY (mdecl))
6159 {
6160 tree fbody = DECL_FUNCTION_BODY (mdecl);
6161 tree block_body = BLOCK_EXPR_BODY (fbody);
6162 tree exception_copy = NULL_TREE;
6163 expand_start_java_method (mdecl);
6164 build_result_decl (mdecl);
6165
6166 current_this
6167 = (!METHOD_STATIC (mdecl) ?
6168 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
6169
6170 /* Purge the `throws' list of unchecked exceptions. If we're
6171 doing xref, save a copy of the list and re-install it
6172 later. */
6173 if (flag_emit_xref)
6174 exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
6175
6176 purge_unchecked_exceptions (mdecl);
6177
6178 /* Install exceptions thrown with `throws' */
6179 PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
6180
6181 if (block_body != NULL_TREE)
6182 {
6183 block_body = java_complete_tree (block_body);
6184 if (!flag_emit_xref)
6185 check_for_initialization (block_body);
6186 ctxp->explicit_constructor_p = 0;
6187 }
6188 BLOCK_EXPR_BODY (fbody) = block_body;
6189
6190 if ((block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
6191 && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
6192 && !flag_emit_xref)
6193 missing_return_error (current_function_decl);
6194
6195 complete_start_java_method (mdecl);
6196
6197 /* Don't go any further if we've found error(s) during the
6198 expansion */
6199 if (!java_error_count)
6200 source_end_java_method ();
6201 else
6202 {
6203 pushdecl_force_head (DECL_ARGUMENTS (mdecl));
6204 poplevel (1, 0, 1);
6205 }
6206
6207 /* Pop the exceptions and sanity check */
6208 POP_EXCEPTIONS();
6209 if (currently_caught_type_list)
6210 fatal ("Exception list non empty - java_complete_expand_method");
6211
6212 if (flag_emit_xref)
6213 DECL_FUNCTION_THROWS (mdecl) = exception_copy;
6214 }
6215 }
6216
6217 /* Craft a body for default constructor. Patch existing constructor
6218 bodies with call to super() and field initialization statements if
6219 necessary. */
6220
6221 static void
6222 fix_constructors (mdecl)
6223 tree mdecl;
6224 {
6225 tree body = DECL_FUNCTION_BODY (mdecl);
6226
6227 if (!body)
6228 {
6229 /* The constructor body must be crafted by hand. It's the
6230 constructor we defined when we realize we didn't have the
6231 CLASSNAME() constructor */
6232
6233 tree compound;
6234
6235 /* It is an error for the compiler to generate a default
6236 constructor if the superclass doesn't have a constructor that
6237 takes no argument */
6238 if (verify_constructor_super ())
6239 {
6240 tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (current_class));
6241 const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
6242 parse_error_context
6243 (lookup_cl (TYPE_NAME (current_class)),
6244 "No constructor matching `%s()' found in class `%s'", n, n);
6245 }
6246
6247 start_artificial_method_body (mdecl);
6248
6249 /* We don't generate a super constructor invocation if we're
6250 compiling java.lang.Object. build_super_invocation takes care
6251 of that. */
6252 compound = java_method_add_stmt (mdecl, build_super_invocation (mdecl));
6253
6254 end_artificial_method_body (mdecl);
6255 }
6256 /* Search for an explicit constructor invocation */
6257 else
6258 {
6259 int found = 0;
6260 tree main_block = BLOCK_EXPR_BODY (body);
6261 tree compound = NULL_TREE;
6262
6263 while (body)
6264 switch (TREE_CODE (body))
6265 {
6266 case CALL_EXPR:
6267 found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
6268 body = NULL_TREE;
6269 break;
6270 case COMPOUND_EXPR:
6271 case EXPR_WITH_FILE_LOCATION:
6272 body = TREE_OPERAND (body, 0);
6273 break;
6274 case BLOCK:
6275 body = BLOCK_EXPR_BODY (body);
6276 break;
6277 default:
6278 found = 0;
6279 body = NULL_TREE;
6280 }
6281 /* The constructor is missing an invocation of super() */
6282 if (!found)
6283 compound = add_stmt_to_compound (compound, NULL_TREE,
6284 build_super_invocation (mdecl));
6285
6286 /* Fix the constructor main block if we're adding extra stmts */
6287 if (compound)
6288 {
6289 compound = add_stmt_to_compound (compound, NULL_TREE,
6290 BLOCK_EXPR_BODY (main_block));
6291 BLOCK_EXPR_BODY (main_block) = compound;
6292 }
6293 }
6294 }
6295
6296 /* Browse constructors in the super class, searching for a constructor
6297 that doesn't take any argument. Return 0 if one is found, 1
6298 otherwise. */
6299
6300 static int
6301 verify_constructor_super ()
6302 {
6303 tree class = CLASSTYPE_SUPER (current_class);
6304 if (!class)
6305 return 0;
6306
6307 if (class)
6308 {
6309 tree mdecl;
6310 for (mdecl = TYPE_METHODS (class); mdecl; mdecl = TREE_CHAIN (mdecl))
6311 {
6312 if (DECL_CONSTRUCTOR_P (mdecl)
6313 && TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (mdecl)))
6314 == end_params_node)
6315 return 0;
6316 }
6317 }
6318 return 1;
6319 }
6320
6321 /* Expand finals. */
6322
6323 static void
6324 java_expand_finals ()
6325 {
6326 }
6327
6328 /* Generate code for all context remembered for code generation. */
6329
6330 void
6331 java_expand_classes ()
6332 {
6333 int save_error_count = 0;
6334 java_parse_abort_on_error ();
6335 if (!(ctxp = ctxp_for_generation))
6336 return;
6337 java_layout_classes ();
6338 java_parse_abort_on_error ();
6339
6340 for (; ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
6341 {
6342 ctxp = ctxp_for_generation;
6343 lang_init_source (2); /* Error msgs have method prototypes */
6344 java_complete_expand_methods (); /* Complete and expand method bodies */
6345 java_parse_abort_on_error ();
6346 java_expand_finals (); /* Expand and check the finals */
6347 java_parse_abort_on_error ();
6348 java_check_final (); /* Check unitialized final */
6349 java_parse_abort_on_error ();
6350 }
6351 }
6352
6353 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
6354 a tree list node containing RIGHT. Fore coming RIGHTs will be
6355 chained to this hook. LOCATION contains the location of the
6356 separating `.' operator. */
6357
6358 static tree
6359 make_qualified_primary (primary, right, location)
6360 tree primary, right;
6361 int location;
6362 {
6363 tree wfl;
6364
6365 /* We want to process THIS . xxx symbolicaly, to keep it consistent
6366 with the way we're processing SUPER. A THIS from a primary as a
6367 different form than a SUPER. Turn THIS into something symbolic */
6368 if (TREE_CODE (primary) == THIS_EXPR)
6369 {
6370 wfl = build_wfl_node (this_identifier_node);
6371 EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary);
6372 wfl = make_qualified_name (wfl, right, location);
6373 PRIMARY_P (wfl) = 1;
6374 return wfl;
6375 }
6376 /* Other non WFL node are wrapped around a WFL */
6377 else if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
6378 {
6379 wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
6380 EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary);
6381 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (primary, NULL_TREE);
6382 }
6383 else
6384 {
6385 wfl = primary;
6386 if (!EXPR_WFL_QUALIFICATION (primary))
6387 EXPR_WFL_QUALIFICATION (primary) =
6388 build_tree_list (primary, NULL_TREE);
6389 }
6390
6391 EXPR_WFL_LINECOL (right) = location;
6392 chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
6393 PRIMARY_P (wfl) = 1;
6394 return wfl;
6395 }
6396
6397 /* Simple merge of two name separated by a `.' */
6398
6399 static tree
6400 merge_qualified_name (left, right)
6401 tree left, right;
6402 {
6403 tree node;
6404 obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
6405 IDENTIFIER_LENGTH (left));
6406 obstack_1grow (&temporary_obstack, '.');
6407 obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
6408 IDENTIFIER_LENGTH (right));
6409 node = get_identifier (obstack_base (&temporary_obstack));
6410 obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
6411 QUALIFIED_P (node) = 1;
6412 return node;
6413 }
6414
6415 /* Merge the two parts of a qualified name into LEFT. Set the
6416 location information of the resulting node to LOCATION, usually
6417 inherited from the location information of the `.' operator. */
6418
6419 static tree
6420 make_qualified_name (left, right, location)
6421 tree left, right;
6422 int location;
6423 {
6424 #ifdef USE_COMPONENT_REF
6425 tree node = build (COMPONENT_REF, NULL_TREE, left, right);
6426 EXPR_WFL_LINECOL (node) = location;
6427 return node;
6428 #else
6429 tree left_id = EXPR_WFL_NODE (left);
6430 tree right_id = EXPR_WFL_NODE (right);
6431 tree wfl, merge;
6432
6433 merge = merge_qualified_name (left_id, right_id);
6434
6435 /* Left wasn't qualified and is now qualified */
6436 if (!QUALIFIED_P (left_id))
6437 {
6438 tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
6439 EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
6440 EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
6441 }
6442
6443 wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
6444 EXPR_WFL_LINECOL (wfl) = location;
6445 chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
6446
6447 EXPR_WFL_NODE (left) = merge;
6448 return left;
6449 #endif
6450 }
6451
6452 /* Extract the last identifier component of the qualified in WFL. The
6453 last identifier is removed from the linked list */
6454
6455 static tree
6456 cut_identifier_in_qualified (wfl)
6457 tree wfl;
6458 {
6459 tree q;
6460 tree previous = NULL_TREE;
6461 for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
6462 if (!TREE_CHAIN (q))
6463 {
6464 if (!previous)
6465 fatal ("Operating on a non qualified qualified WFL - cut_identifier_in_qualified");
6466 TREE_CHAIN (previous) = NULL_TREE;
6467 return TREE_PURPOSE (q);
6468 }
6469 }
6470
6471 /* Resolve the expression name NAME. Return its decl. */
6472
6473 static tree
6474 resolve_expression_name (id, orig)
6475 tree id;
6476 tree *orig;
6477 {
6478 tree name = EXPR_WFL_NODE (id);
6479 tree decl;
6480
6481 /* 6.5.5.1: Simple expression names */
6482 if (!PRIMARY_P (id) && !QUALIFIED_P (name))
6483 {
6484 /* 15.13.1: NAME can appear within the scope of a local variable
6485 declaration */
6486 if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
6487 return decl;
6488
6489 /* 15.13.1: NAME can appear within a class declaration */
6490 else
6491 {
6492 decl = lookup_field_wrapper (current_class, name);
6493 if (decl)
6494 {
6495 int fs = FIELD_STATIC (decl);
6496 /* Instance variable (8.3.1.1) can't appear within
6497 static method, static initializer or initializer for
6498 a static variable. */
6499 if (!fs && METHOD_STATIC (current_function_decl))
6500 {
6501 static_ref_err (id, name, current_class);
6502 return error_mark_node;
6503 }
6504 /* Instance variables can't appear as an argument of
6505 an explicit constructor invocation */
6506 if (!fs && ctxp->explicit_constructor_p)
6507 {
6508 parse_error_context
6509 (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
6510 return error_mark_node;
6511 }
6512
6513 /* Otherwise build what it takes to access the field */
6514 decl = build_field_ref ((fs ? NULL_TREE : current_this),
6515 DECL_CONTEXT (decl), name);
6516 if (fs && !flag_emit_class_files && !flag_emit_xref)
6517 decl = build_class_init (DECL_CONTEXT (decl), decl);
6518 /* We may be asked to save the real field access node */
6519 if (orig)
6520 *orig = decl;
6521 /* And we return what we got */
6522 return decl;
6523 }
6524 /* Fall down to error report on undefined variable */
6525 }
6526 }
6527 /* 6.5.5.2 Qualified Expression Names */
6528 else
6529 {
6530 if (orig)
6531 *orig = NULL_TREE;
6532 qualify_ambiguous_name (id);
6533 /* 15.10.1 Field Access Using a Primary and/or Expression Name */
6534 /* 15.10.2: Accessing Superclass Members using super */
6535 return resolve_field_access (id, NULL, NULL);
6536 }
6537
6538 /* We've got an error here */
6539 parse_error_context (id, "Undefined variable `%s'",
6540 IDENTIFIER_POINTER (name));
6541
6542 return error_mark_node;
6543 }
6544
6545 static void
6546 static_ref_err (wfl, field_id, class_type)
6547 tree wfl, field_id, class_type;
6548 {
6549 parse_error_context
6550 (wfl,
6551 "Can't make a static reference to nonstatic variable `%s' in class `%s'",
6552 IDENTIFIER_POINTER (field_id),
6553 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
6554 }
6555
6556 /* 15.10.1 Field Acess Using a Primary and/or Expression Name.
6557 We return something suitable to generate the field access. We also
6558 return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
6559 recipient's address can be null. */
6560
6561 static tree
6562 resolve_field_access (qual_wfl, field_decl, field_type)
6563 tree qual_wfl;
6564 tree *field_decl, *field_type;
6565 {
6566 int is_static = 0;
6567 tree field_ref;
6568 tree decl, where_found, type_found;
6569
6570 if (resolve_qualified_expression_name (qual_wfl, &decl,
6571 &where_found, &type_found))
6572 return error_mark_node;
6573
6574 /* Resolve the LENGTH field of an array here */
6575 if (DECL_NAME (decl) == length_identifier_node && TYPE_ARRAY_P (type_found)
6576 && ! flag_emit_class_files && ! flag_emit_xref)
6577 {
6578 tree length = build_java_array_length_access (where_found);
6579 field_ref =
6580 build_java_arraynull_check (type_found, length, int_type_node);
6581 }
6582 /* We might have been trying to resolve field.method(). In which
6583 case, the resolution is over and decl is the answer */
6584 else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
6585 field_ref = decl;
6586 else if (JDECL_P (decl))
6587 {
6588 int static_final_found = 0;
6589 if (!type_found)
6590 type_found = DECL_CONTEXT (decl);
6591 is_static = JDECL_P (decl) && FIELD_STATIC (decl);
6592 if (FIELD_FINAL (decl)
6593 && JPRIMITIVE_TYPE_P (TREE_TYPE (decl))
6594 && DECL_LANG_SPECIFIC (decl)
6595 && DECL_INITIAL (decl))
6596 {
6597 field_ref = DECL_INITIAL (decl);
6598 static_final_found = 1;
6599 }
6600 else
6601 field_ref = build_field_ref ((is_static && !flag_emit_xref?
6602 NULL_TREE : where_found),
6603 type_found, DECL_NAME (decl));
6604 if (field_ref == error_mark_node)
6605 return error_mark_node;
6606 if (is_static && !static_final_found
6607 && !flag_emit_class_files && !flag_emit_xref)
6608 {
6609 field_ref = build_class_init (type_found, field_ref);
6610 /* If the static field was identified by an expression that
6611 needs to be generated, make the field access a compound
6612 expression whose first part is the evaluation of the
6613 field selector part. */
6614 if (where_found && TREE_CODE (where_found) != TYPE_DECL
6615 && TREE_CODE (where_found) != RECORD_TYPE)
6616 {
6617 tree type = QUAL_DECL_TYPE (field_ref);
6618 if (TREE_CODE (type) == RECORD_TYPE)
6619 type = build_pointer_type (type);
6620 field_ref = build (COMPOUND_EXPR, type, where_found, field_ref);
6621 }
6622 }
6623 }
6624 else
6625 field_ref = decl;
6626
6627 if (field_decl)
6628 *field_decl = decl;
6629 if (field_type)
6630 *field_type = (QUAL_DECL_TYPE (decl) ?
6631 QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
6632 return field_ref;
6633 }
6634
6635 /* If NODE is an access to f static field, strip out the class
6636 initialization part and return the field decl, otherwise, return
6637 NODE. */
6638
6639 static tree
6640 strip_out_static_field_access_decl (node)
6641 tree node;
6642 {
6643 if (TREE_CODE (node) == COMPOUND_EXPR)
6644 {
6645 tree op1 = TREE_OPERAND (node, 1);
6646 if (TREE_CODE (op1) == COMPOUND_EXPR)
6647 {
6648 tree call = TREE_OPERAND (op1, 0);
6649 if (TREE_CODE (call) == CALL_EXPR
6650 && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
6651 && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
6652 == soft_initclass_node)
6653 return TREE_OPERAND (op1, 1);
6654 }
6655 else if (JDECL_P (op1))
6656 return op1;
6657 }
6658 return node;
6659 }
6660
6661 /* 6.5.5.2: Qualified Expression Names */
6662
6663 static int
6664 resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
6665 tree wfl;
6666 tree *found_decl, *type_found, *where_found;
6667 {
6668 int from_type = 0; /* Field search initiated from a type */
6669 int from_super = 0, from_cast = 0;
6670 int previous_call_static = 0;
6671 int is_static;
6672 tree decl = NULL_TREE, type = NULL_TREE, q;
6673 *type_found = *where_found = NULL_TREE;
6674
6675 for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
6676 {
6677 tree qual_wfl = QUAL_WFL (q);
6678 tree ret_decl; /* for EH checking */
6679 int location; /* for EH checking */
6680
6681 /* 15.10.1 Field Access Using a Primary */
6682 switch (TREE_CODE (qual_wfl))
6683 {
6684 case CALL_EXPR:
6685 case NEW_CLASS_EXPR:
6686 /* If the access to the function call is a non static field,
6687 build the code to access it. */
6688 if (JDECL_P (decl) && !FIELD_STATIC (decl))
6689 {
6690 decl = maybe_access_field (decl, *where_found,
6691 DECL_CONTEXT (decl));
6692 if (decl == error_mark_node)
6693 return 1;
6694 }
6695 /* And code for the function call */
6696 if (complete_function_arguments (qual_wfl))
6697 return 1;
6698
6699 if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
6700 CALL_USING_SUPER (qual_wfl) = 1;
6701 location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
6702 EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
6703 *where_found = patch_method_invocation (qual_wfl, decl, type,
6704 &is_static, &ret_decl);
6705 if (*where_found == error_mark_node)
6706 return 1;
6707 *type_found = type = QUAL_DECL_TYPE (*where_found);
6708
6709 /* EH check */
6710 if (location)
6711 check_thrown_exceptions (location, ret_decl);
6712
6713 /* If the previous call was static and this one is too,
6714 build a compound expression to hold the two (because in
6715 that case, previous function calls aren't transported as
6716 forcoming function's argument. */
6717 if (previous_call_static && is_static)
6718 {
6719 decl = build (COMPOUND_EXPR, type, decl, *where_found);
6720 TREE_SIDE_EFFECTS (decl) = 1;
6721 }
6722 else
6723 {
6724 previous_call_static = is_static;
6725 decl = *where_found;
6726 }
6727 continue;
6728
6729 case NEW_ARRAY_EXPR:
6730 *where_found = decl = java_complete_tree (qual_wfl);
6731 if (decl == error_mark_node)
6732 return 1;
6733 *type_found = type = QUAL_DECL_TYPE (decl);
6734 CLASS_LOADED_P (type) = 1;
6735 continue;
6736
6737 case CONVERT_EXPR:
6738 *where_found = decl = java_complete_tree (qual_wfl);
6739 if (decl == error_mark_node)
6740 return 1;
6741 *type_found = type = QUAL_DECL_TYPE (decl);
6742 from_cast = 1;
6743 continue;
6744
6745 case CONDITIONAL_EXPR:
6746 case STRING_CST:
6747 case MODIFY_EXPR:
6748 *where_found = decl = java_complete_tree (qual_wfl);
6749 if (decl == error_mark_node)
6750 return 1;
6751 *type_found = type = QUAL_DECL_TYPE (decl);
6752 continue;
6753
6754 case ARRAY_REF:
6755 /* If the access to the function call is a non static field,
6756 build the code to access it. */
6757 if (JDECL_P (decl) && !FIELD_STATIC (decl))
6758 {
6759 decl = maybe_access_field (decl, *where_found, type);
6760 if (decl == error_mark_node)
6761 return 1;
6762 }
6763 /* And code for the array reference expression */
6764 decl = java_complete_tree (qual_wfl);
6765 if (decl == error_mark_node)
6766 return 1;
6767 type = QUAL_DECL_TYPE (decl);
6768 continue;
6769
6770 case PLUS_EXPR:
6771 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
6772 return 1;
6773 if ((type = patch_string (decl)))
6774 decl = type;
6775 *where_found = QUAL_RESOLUTION (q) = decl;
6776 *type_found = type = TREE_TYPE (decl);
6777 break;
6778
6779 default:
6780 /* Fix for -Wall Just go to the next statement. Don't
6781 continue */
6782 break;
6783 }
6784
6785 /* If we fall here, we weren't processing a (static) function call. */
6786 previous_call_static = 0;
6787
6788 /* It can be the keyword THIS */
6789 if (EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
6790 {
6791 if (!current_this)
6792 {
6793 parse_error_context
6794 (wfl, "Keyword `this' used outside allowed context");
6795 return 1;
6796 }
6797 if (ctxp->explicit_constructor_p)
6798 {
6799 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
6800 return 1;
6801 }
6802 /* We have to generate code for intermediate acess */
6803 *where_found = decl = current_this;
6804 *type_found = type = QUAL_DECL_TYPE (decl);
6805 continue;
6806 }
6807
6808 /* 15.10.2 Accessing Superclass Members using SUPER */
6809 if (EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
6810 {
6811 tree node;
6812 /* Check on the restricted use of SUPER */
6813 if (METHOD_STATIC (current_function_decl)
6814 || current_class == object_type_node)
6815 {
6816 parse_error_context
6817 (wfl, "Keyword `super' used outside allowed context");
6818 return 1;
6819 }
6820 /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
6821 node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
6822 CLASSTYPE_SUPER (current_class),
6823 build_this (EXPR_WFL_LINECOL (qual_wfl)));
6824 *where_found = decl = java_complete_tree (node);
6825 if (decl == error_mark_node)
6826 return 1;
6827 *type_found = type = QUAL_DECL_TYPE (decl);
6828 from_super = from_type = 1;
6829 continue;
6830 }
6831
6832 /* 15.13.1: Can't search for field name in packages, so we
6833 assume a variable/class name was meant. */
6834 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
6835 {
6836 tree name = resolve_package (wfl, &q);
6837 if (name)
6838 {
6839 *where_found = decl = resolve_no_layout (name, qual_wfl);
6840 /* We wan't to be absolutely that the class is laid
6841 out. We're going to search something inside it. */
6842 *type_found = type = TREE_TYPE (decl);
6843 layout_class (type);
6844 from_type = 1;
6845 /* Should be a list, really. FIXME */
6846 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (TREE_CHAIN (q))) = 1;
6847 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (TREE_CHAIN (q))) = 0;
6848 }
6849 else
6850 {
6851 if (from_super || from_cast)
6852 parse_error_context
6853 ((from_cast ? qual_wfl : wfl),
6854 "No variable `%s' defined in class `%s'",
6855 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
6856 lang_printable_name (type, 0));
6857 else
6858 parse_error_context
6859 (qual_wfl, "Undefined variable or class name: `%s'",
6860 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)));
6861 return 1;
6862 }
6863 }
6864
6865 /* We have a type name. It's been already resolved when the
6866 expression was qualified. */
6867 else if (RESOLVE_TYPE_NAME_P (qual_wfl))
6868 {
6869 if (!(decl = QUAL_RESOLUTION (q)))
6870 return 1; /* Error reported already */
6871
6872 if (not_accessible_p (TREE_TYPE (decl), decl, 0))
6873 {
6874 parse_error_context
6875 (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
6876 java_accstring_lookup (get_access_flags_from_decl (decl)),
6877 GET_TYPE_NAME (type),
6878 IDENTIFIER_POINTER (DECL_NAME (decl)),
6879 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
6880 return 1;
6881 }
6882 check_deprecation (qual_wfl, decl);
6883
6884 type = TREE_TYPE (decl);
6885 from_type = 1;
6886 }
6887 /* We resolve and expression name */
6888 else
6889 {
6890 tree field_decl = NULL_TREE;
6891
6892 /* If there exists an early resolution, use it. That occurs
6893 only once and we know that there are more things to
6894 come. Don't do that when processing something after SUPER
6895 (we need more thing to be put in place below */
6896 if (!from_super && QUAL_RESOLUTION (q))
6897 {
6898 decl = QUAL_RESOLUTION (q);
6899 if (!type)
6900 {
6901 if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
6902 {
6903 if (current_this)
6904 *where_found = current_this;
6905 else
6906 {
6907 static_ref_err (qual_wfl, DECL_NAME (decl),
6908 current_class);
6909 return 1;
6910 }
6911 }
6912 else
6913 {
6914 *where_found = TREE_TYPE (decl);
6915 if (TREE_CODE (*where_found) == POINTER_TYPE)
6916 *where_found = TREE_TYPE (*where_found);
6917 }
6918 }
6919 }
6920
6921 /* We have to search for a field, knowing the type of its
6922 container. The flag FROM_TYPE indicates that we resolved
6923 the last member of the expression as a type name, which
6924 means that for the resolution of this field, we'll look
6925 for other errors than if it was resolved as a member of
6926 an other field. */
6927 else
6928 {
6929 int is_static;
6930 tree field_decl_type; /* For layout */
6931
6932 if (!from_type && !JREFERENCE_TYPE_P (type))
6933 {
6934 parse_error_context
6935 (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
6936 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
6937 lang_printable_name (type, 0),
6938 IDENTIFIER_POINTER (DECL_NAME (field_decl)));
6939 return 1;
6940 }
6941
6942 field_decl = lookup_field_wrapper (type,
6943 EXPR_WFL_NODE (qual_wfl));
6944 if (field_decl == NULL_TREE)
6945 {
6946 parse_error_context
6947 (qual_wfl, "No variable `%s' defined in type `%s'",
6948 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
6949 GET_TYPE_NAME (type));
6950 return 1;
6951 }
6952 if (field_decl == error_mark_node)
6953 return 1;
6954
6955 /* Layout the type of field_decl, since we may need
6956 it. Don't do primitive types or loaded classes. The
6957 situation of non primitive arrays may not handled
6958 properly here. FIXME */
6959 if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
6960 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
6961 else
6962 field_decl_type = TREE_TYPE (field_decl);
6963 if (!JPRIMITIVE_TYPE_P (field_decl_type)
6964 && !CLASS_LOADED_P (field_decl_type)
6965 && !TYPE_ARRAY_P (field_decl_type))
6966 resolve_and_layout (field_decl_type, NULL_TREE);
6967 if (TYPE_ARRAY_P (field_decl_type))
6968 CLASS_LOADED_P (field_decl_type) = 1;
6969
6970 /* Check on accessibility here */
6971 if (not_accessible_p (type, field_decl, from_super))
6972 {
6973 parse_error_context
6974 (qual_wfl,
6975 "Can't access %s field `%s.%s' from `%s'",
6976 java_accstring_lookup
6977 (get_access_flags_from_decl (field_decl)),
6978 GET_TYPE_NAME (type),
6979 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
6980 IDENTIFIER_POINTER
6981 (DECL_NAME (TYPE_NAME (current_class))));
6982 return 1;
6983 }
6984 check_deprecation (qual_wfl, field_decl);
6985
6986 /* There are things to check when fields are accessed
6987 from type. There are no restrictions on a static
6988 declaration of the field when it is accessed from an
6989 interface */
6990 is_static = FIELD_STATIC (field_decl);
6991 if (!from_super && from_type
6992 && !TYPE_INTERFACE_P (type) && !is_static)
6993 {
6994 static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
6995 return 1;
6996 }
6997 from_cast = from_super = 0;
6998
6999 /* If we need to generate something to get a proper
7000 handle on what this field is accessed from, do it
7001 now. */
7002 if (!is_static)
7003 {
7004 decl = maybe_access_field (decl, *where_found, *type_found);
7005 if (decl == error_mark_node)
7006 return 1;
7007 }
7008
7009 /* We want to keep the location were found it, and the type
7010 we found. */
7011 *where_found = decl;
7012 *type_found = type;
7013
7014 /* This is the decl found and eventually the next one to
7015 search from */
7016 decl = field_decl;
7017 }
7018 from_type = 0;
7019 type = QUAL_DECL_TYPE (decl);
7020 }
7021 }
7022 *found_decl = decl;
7023 return 0;
7024 }
7025
7026 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
7027 can't be accessed from REFERENCE (a record type). */
7028
7029 static int
7030 not_accessible_p (reference, member, from_super)
7031 tree reference, member;
7032 int from_super;
7033 {
7034 int access_flag = get_access_flags_from_decl (member);
7035
7036 /* Access always granted for members declared public */
7037 if (access_flag & ACC_PUBLIC)
7038 return 0;
7039
7040 /* Check access on protected members */
7041 if (access_flag & ACC_PROTECTED)
7042 {
7043 /* Access granted if it occurs from within the package
7044 containing the class in which the protected member is
7045 declared */
7046 if (class_in_current_package (DECL_CONTEXT (member)))
7047 return 0;
7048
7049 /* If accessed with the form `super.member', then access is granted */
7050 if (from_super)
7051 return 0;
7052
7053 /* Otherwise, access is granted if occuring from the class where
7054 member is declared or a subclass of it */
7055 if (inherits_from_p (reference, current_class))
7056 return 0;
7057 return 1;
7058 }
7059
7060 /* Check access on private members. Access is granted only if it
7061 occurs from within the class in witch it is declared */
7062 if (access_flag & ACC_PRIVATE)
7063 return (current_class == DECL_CONTEXT (member) ? 0 : 1);
7064
7065 /* Default access are permitted only when occuring within the
7066 package in which the type (REFERENCE) is declared. In other words,
7067 REFERENCE is defined in the current package */
7068 if (ctxp->package)
7069 return !class_in_current_package (reference);
7070
7071 /* Otherwise, access is granted */
7072 return 0;
7073 }
7074
7075 /* Test deprecated decl access. */
7076 static void
7077 check_deprecation (wfl, decl)
7078 tree wfl, decl;
7079 {
7080 const char *file = DECL_SOURCE_FILE (decl);
7081 /* Complain if the field is deprecated and the file it was defined
7082 in isn't compiled at the same time the file which contains its
7083 use is */
7084 if (DECL_DEPRECATED (decl)
7085 && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
7086 {
7087 char the [20];
7088 switch (TREE_CODE (decl))
7089 {
7090 case FUNCTION_DECL:
7091 strcpy (the, "method");
7092 break;
7093 case FIELD_DECL:
7094 strcpy (the, "field");
7095 break;
7096 case TYPE_DECL:
7097 strcpy (the, "class");
7098 break;
7099 default:
7100 fatal ("unexpected DECL code - check_deprecation");
7101 }
7102 parse_warning_context
7103 (wfl, "The %s `%s' in class `%s' has been deprecated",
7104 the, lang_printable_name (decl, 0),
7105 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
7106 }
7107 }
7108
7109 /* Returns 1 if class was declared in the current package, 0 otherwise */
7110
7111 static int
7112 class_in_current_package (class)
7113 tree class;
7114 {
7115 static tree cache = NULL_TREE;
7116 int qualified_flag;
7117 tree left;
7118
7119 if (cache == class)
7120 return 1;
7121
7122 qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
7123
7124 /* If the current package is empty and the name of CLASS is
7125 qualified, class isn't in the current package. If there is a
7126 current package and the name of the CLASS is not qualified, class
7127 isn't in the current package */
7128 if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
7129 return 0;
7130
7131 /* If there is not package and the name of CLASS isn't qualified,
7132 they belong to the same unnamed package */
7133 if (!ctxp->package && !qualified_flag)
7134 return 1;
7135
7136 /* Compare the left part of the name of CLASS with the package name */
7137 breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
7138 if (ctxp->package == left)
7139 {
7140 cache = class;
7141 return 1;
7142 }
7143 return 0;
7144 }
7145
7146 /* This function may generate code to access DECL from WHERE. This is
7147 done only if certain conditions meet. */
7148
7149 static tree
7150 maybe_access_field (decl, where, type)
7151 tree decl, where, type;
7152 {
7153 if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
7154 && !FIELD_STATIC (decl))
7155 decl = build_field_ref (where ? where : current_this,
7156 (type ? type : DECL_CONTEXT (decl)),
7157 DECL_NAME (decl));
7158 return decl;
7159 }
7160
7161 /* Build a method invocation, by patching PATCH. If non NULL
7162 and according to the situation, PRIMARY and WHERE may be
7163 used. IS_STATIC is set to 1 if the invoked function is static. */
7164
7165 static tree
7166 patch_method_invocation (patch, primary, where, is_static, ret_decl)
7167 tree patch, primary, where;
7168 int *is_static;
7169 tree *ret_decl;
7170 {
7171 tree wfl = TREE_OPERAND (patch, 0);
7172 tree args = TREE_OPERAND (patch, 1);
7173 tree name = EXPR_WFL_NODE (wfl);
7174 tree list;
7175 int is_static_flag = 0;
7176 int is_super_init = 0;
7177 tree this_arg = NULL_TREE;
7178
7179 /* Should be overriden if everything goes well. Otherwise, if
7180 something fails, it should keep this value. It stop the
7181 evaluation of a bogus assignment. See java_complete_tree,
7182 MODIFY_EXPR: for the reasons why we sometimes want to keep on
7183 evaluating an assignment */
7184 TREE_TYPE (patch) = error_mark_node;
7185
7186 /* Since lookup functions are messing with line numbers, save the
7187 context now. */
7188 java_parser_context_save_global ();
7189
7190 /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
7191
7192 /* Resolution of qualified name, excluding constructors */
7193 if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
7194 {
7195 tree class_decl, identifier, identifier_wfl;
7196 /* Extract the last IDENTIFIER of the qualified
7197 expression. This is a wfl and we will use it's location
7198 data during error report. */
7199 identifier_wfl = cut_identifier_in_qualified (wfl);
7200 identifier = EXPR_WFL_NODE (identifier_wfl);
7201
7202 /* Given the context, IDENTIFIER is syntactically qualified
7203 as a MethodName. We need to qualify what's before */
7204 qualify_ambiguous_name (wfl);
7205
7206 /* Package resolution */
7207 if (RESOLVE_PACKAGE_NAME_P (wfl))
7208 {
7209 tree next, decl, name = resolve_package (wfl, &next);
7210
7211 if (!name)
7212 {
7213 tree remainder;
7214 breakdown_qualified (&remainder, NULL, EXPR_WFL_NODE (wfl));
7215 parse_error_context
7216 (wfl, "Can't search method `%s' in package `%s'",
7217 IDENTIFIER_POINTER (identifier),
7218 IDENTIFIER_POINTER (remainder));
7219 PATCH_METHOD_RETURN_ERROR ();
7220 }
7221 RESOLVE_PACKAGE_NAME_P (wfl) = 0;
7222 if ((decl = resolve_no_layout (name, QUAL_WFL (next))))
7223 {
7224 QUAL_RESOLUTION (EXPR_WFL_QUALIFICATION (wfl)) = decl;
7225 RESOLVE_EXPRESSION_NAME_P (wfl) = 0;
7226 RESOLVE_TYPE_NAME_P (wfl) = 1;
7227 }
7228 else
7229 {
7230 RESOLVE_EXPRESSION_NAME_P (wfl) = 1;
7231 RESOLVE_TYPE_NAME_P (wfl) = 0;
7232 }
7233 }
7234
7235 /* We're resolving a call from a type */
7236 if (RESOLVE_TYPE_NAME_P (wfl))
7237 {
7238 tree decl = QUAL_RESOLUTION (EXPR_WFL_QUALIFICATION (wfl));
7239 tree name = DECL_NAME (decl);
7240 tree type;
7241
7242 class_decl = resolve_and_layout (name, wfl);
7243 if (CLASS_INTERFACE (decl))
7244 {
7245 parse_error_context
7246 (identifier_wfl,
7247 "Can't make static reference to method `%s' in interface `%s'",
7248 IDENTIFIER_POINTER (identifier),
7249 IDENTIFIER_POINTER (name));
7250 PATCH_METHOD_RETURN_ERROR ();
7251 }
7252 /* Look the method up in the type selector. The method ought
7253 to be static. */
7254 type = TREE_TYPE (class_decl);
7255 list = lookup_method_invoke (0, wfl, type, identifier, args);
7256 if (list && !METHOD_STATIC (list))
7257 {
7258 char *fct_name = xstrdup (lang_printable_name (list, 0));
7259 parse_error_context
7260 (identifier_wfl,
7261 "Can't make static reference to method `%s %s' in class `%s'",
7262 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
7263 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
7264 free (fct_name);
7265 PATCH_METHOD_RETURN_ERROR ();
7266 }
7267 args = nreverse (args);
7268 }
7269 /* We're resolving an expression name */
7270 else
7271 {
7272 tree field, type;
7273
7274 /* 1- Find the field to which the call applies */
7275 field = resolve_field_access (wfl, NULL, &type);
7276 if (field == error_mark_node)
7277 PATCH_METHOD_RETURN_ERROR ();
7278 /* field is used in lieu of a primary. It alows us not to
7279 report errors on erroneous use of `this' in
7280 constructors. */
7281 primary = field;
7282
7283 /* 2- Do the layout of the class where the last field
7284 was found, so we can search it. */
7285 class_decl = resolve_and_layout (type, NULL_TREE);
7286 if (class_decl != NULL_TREE)
7287 type = TREE_TYPE (class_decl);
7288
7289 /* 3- Retrieve a filtered list of method matches, Refine
7290 if necessary. In any cases, point out errors. */
7291 list = lookup_method_invoke (0, identifier_wfl, type,
7292 identifier, args);
7293
7294 /* 4- Add the field as an argument */
7295 args = nreverse (args);
7296 this_arg = field;
7297 }
7298
7299 /* IDENTIFIER_WFL will be used to report any problem further */
7300 wfl = identifier_wfl;
7301 }
7302 /* Resolution of simple names, names generated after a primary: or
7303 constructors */
7304 else
7305 {
7306 tree class_to_search = NULL_TREE;
7307 int lc; /* Looking for Constructor */
7308
7309 /* We search constructor in their target class */
7310 if (CALL_CONSTRUCTOR_P (patch))
7311 {
7312 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
7313 class_to_search = EXPR_WFL_NODE (wfl);
7314 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
7315 this_identifier_node)
7316 class_to_search = NULL_TREE;
7317 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
7318 super_identifier_node)
7319 {
7320 is_super_init = 1;
7321 if (CLASSTYPE_SUPER (current_class))
7322 class_to_search =
7323 DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
7324 else
7325 {
7326 parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
7327 PATCH_METHOD_RETURN_ERROR ();
7328 }
7329 }
7330
7331 /* Class to search is NULL if we're searching the current one */
7332 if (class_to_search)
7333 {
7334 class_to_search = resolve_and_layout (class_to_search,
7335 NULL_TREE);
7336 if (!class_to_search)
7337 {
7338 parse_error_context
7339 (wfl, "Class `%s' not found in type declaration",
7340 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
7341 PATCH_METHOD_RETURN_ERROR ();
7342 }
7343
7344 /* Can't instantiate an abstract class, but we can
7345 invoke it's constructor. It's use within the `new'
7346 context is denied here. */
7347 if (CLASS_ABSTRACT (class_to_search)
7348 && TREE_CODE (patch) == NEW_CLASS_EXPR)
7349 {
7350 parse_error_context
7351 (wfl, "Class `%s' is an abstract class. It can't be instantiated",
7352 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
7353 PATCH_METHOD_RETURN_ERROR ();
7354 }
7355 class_to_search = TREE_TYPE (class_to_search);
7356 }
7357 else
7358 class_to_search = current_class;
7359 lc = 1;
7360 }
7361 /* This is a regular search in the local class, unless an
7362 alternate class is specified. */
7363 else
7364 {
7365 class_to_search = (where ? where : current_class);
7366 lc = 0;
7367 }
7368
7369 /* NAME is a simple identifier or comes from a primary. Search
7370 in the class whose declaration contain the method being
7371 invoked. */
7372 resolve_and_layout (class_to_search, NULL_TREE);
7373 list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
7374
7375 /* Don't continue if no method were found, as the next statement
7376 can't be executed then. */
7377 if (!list)
7378 PATCH_METHOD_RETURN_ERROR ();
7379
7380 /* Check for static reference if non static methods */
7381 if (check_for_static_method_reference (wfl, patch, list,
7382 class_to_search, primary))
7383 PATCH_METHOD_RETURN_ERROR ();
7384
7385 /* Non static methods are called with the current object extra
7386 argument. If patch a `new TYPE()', the argument is the value
7387 returned by the object allocator. If method is resolved as a
7388 primary, use the primary otherwise use the current THIS. */
7389 args = nreverse (args);
7390 if (TREE_CODE (patch) != NEW_CLASS_EXPR)
7391 this_arg = primary ? primary : current_this;
7392 }
7393
7394 /* Merge point of all resolution schemes. If we have nothing, this
7395 is an error, already signaled */
7396 if (!list)
7397 PATCH_METHOD_RETURN_ERROR ();
7398
7399 /* Check accessibility, position the is_static flag, build and
7400 return the call */
7401 if (not_accessible_p (DECL_CONTEXT (current_function_decl), list, 0))
7402 {
7403 char *fct_name = xstrdup (lang_printable_name (list, 0));
7404 parse_error_context
7405 (wfl, "Can't access %s method `%s %s.%s' from `%s'",
7406 java_accstring_lookup (get_access_flags_from_decl (list)),
7407 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
7408 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list)))),
7409 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
7410 free (fct_name);
7411 PATCH_METHOD_RETURN_ERROR ();
7412 }
7413 check_deprecation (wfl, list);
7414
7415 is_static_flag = METHOD_STATIC (list);
7416 if (! METHOD_STATIC (list) && this_arg != NULL_TREE)
7417 args = tree_cons (NULL_TREE, this_arg, args);
7418
7419 /* In the context of an explicit constructor invocation, we can't
7420 invoke any method relying on `this'. Exceptions are: we're
7421 invoking a static function, primary exists and is not the current
7422 this, we're creating a new object. */
7423 if (ctxp->explicit_constructor_p
7424 && !is_static_flag
7425 && (!primary || primary == current_this)
7426 && (TREE_CODE (patch) != NEW_CLASS_EXPR))
7427 {
7428 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
7429 PATCH_METHOD_RETURN_ERROR ();
7430 }
7431 java_parser_context_restore_global ();
7432 if (is_static)
7433 *is_static = is_static_flag;
7434 /* Sometimes, we want the decl of the selected method. Such as for
7435 EH checking */
7436 if (ret_decl)
7437 *ret_decl = list;
7438 patch = patch_invoke (patch, list, args);
7439 if (is_super_init && CLASS_HAS_FINIT_P (current_class))
7440 {
7441 /* Generate the code used to initialize fields declared with an
7442 initialization statement. For now, it returns a call the the
7443 artificial function $finit$, if required. */
7444
7445 tree finit_call =
7446 build_method_invocation (build_expr_wfl (finit_identifier_node,
7447 input_filename, 0, 0),
7448 NULL_TREE);
7449 patch = build (COMPOUND_EXPR, void_type_node, patch,
7450 java_complete_tree (finit_call));
7451 CAN_COMPLETE_NORMALLY (patch) = 1;
7452 }
7453 return patch;
7454 }
7455
7456 /* Check that we're not trying to do a static reference to a method in
7457 non static method. Return 1 if it's the case, 0 otherwise. */
7458
7459 static int
7460 check_for_static_method_reference (wfl, node, method, where, primary)
7461 tree wfl, node, method, where, primary;
7462 {
7463 if (METHOD_STATIC (current_function_decl)
7464 && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
7465 {
7466 char *fct_name = xstrdup (lang_printable_name (method, 0));
7467 parse_error_context
7468 (wfl, "Can't make static reference to method `%s %s' in class `%s'",
7469 lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
7470 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
7471 free (fct_name);
7472 return 1;
7473 }
7474 return 0;
7475 }
7476
7477 /* Patch an invoke expression METHOD and ARGS, based on its invocation
7478 mode. */
7479
7480 static tree
7481 patch_invoke (patch, method, args)
7482 tree patch, method, args;
7483 {
7484 tree dtable, func;
7485 tree original_call, t, ta;
7486
7487 /* Last step for args: convert build-in types. If we're dealing with
7488 a new TYPE() type call, the first argument to the constructor
7489 isn't found in the incomming argument list, but delivered by
7490 `new' */
7491 t = TYPE_ARG_TYPES (TREE_TYPE (method));
7492 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
7493 t = TREE_CHAIN (t);
7494 for (ta = args; t != end_params_node && ta;
7495 t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
7496 if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
7497 TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
7498 TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
7499
7500 /* Resolve unresolved returned type isses */
7501 t = TREE_TYPE (TREE_TYPE (method));
7502 if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
7503 resolve_and_layout (TREE_TYPE (t), NULL);
7504
7505 if (flag_emit_class_files || flag_emit_xref)
7506 func = method;
7507 else
7508 {
7509 tree signature = build_java_signature (TREE_TYPE (method));
7510 switch (invocation_mode (method, CALL_USING_SUPER (patch)))
7511 {
7512 case INVOKE_VIRTUAL:
7513 dtable = invoke_build_dtable (0, args);
7514 func = build_invokevirtual (dtable, method);
7515 break;
7516
7517 case INVOKE_SUPER:
7518 case INVOKE_STATIC:
7519 func = build_known_method_ref (method, TREE_TYPE (method),
7520 DECL_CONTEXT (method),
7521 signature, args);
7522 break;
7523
7524 case INVOKE_INTERFACE:
7525 dtable = invoke_build_dtable (1, args);
7526 func = build_invokeinterface (dtable, DECL_NAME (method), signature);
7527 break;
7528
7529 default:
7530 fatal ("internal error - unknown invocation_mode result");
7531 }
7532
7533 /* Ensure self_type is initialized, (invokestatic). FIXME */
7534 func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
7535 }
7536
7537 TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
7538 TREE_OPERAND (patch, 0) = func;
7539 TREE_OPERAND (patch, 1) = args;
7540 original_call = patch;
7541
7542 /* We're processing a `new TYPE ()' form. New is called an its
7543 returned value is the first argument to the constructor. We build
7544 a COMPOUND_EXPR and use saved expression so that the overall NEW
7545 expression value is a pointer to a newly created and initialized
7546 class. */
7547 if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
7548 {
7549 tree class = DECL_CONTEXT (method);
7550 tree c1, saved_new, size, new;
7551 if (flag_emit_class_files || flag_emit_xref)
7552 {
7553 TREE_TYPE (patch) = build_pointer_type (class);
7554 return patch;
7555 }
7556 if (!TYPE_SIZE (class))
7557 safe_layout_class (class);
7558 size = size_in_bytes (class);
7559 new = build (CALL_EXPR, promote_type (class),
7560 build_address_of (alloc_object_node),
7561 tree_cons (NULL_TREE, build_class_ref (class),
7562 build_tree_list (NULL_TREE,
7563 size_in_bytes (class))),
7564 NULL_TREE);
7565 saved_new = save_expr (new);
7566 c1 = build_tree_list (NULL_TREE, saved_new);
7567 TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
7568 TREE_OPERAND (original_call, 1) = c1;
7569 TREE_SET_CODE (original_call, CALL_EXPR);
7570 patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
7571 }
7572 return patch;
7573 }
7574
7575 static int
7576 invocation_mode (method, super)
7577 tree method;
7578 int super;
7579 {
7580 int access = get_access_flags_from_decl (method);
7581
7582 if (super)
7583 return INVOKE_SUPER;
7584
7585 if (access & ACC_STATIC || access & ACC_FINAL || access & ACC_PRIVATE)
7586 return INVOKE_STATIC;
7587
7588 if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
7589 return INVOKE_STATIC;
7590
7591 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
7592 return INVOKE_INTERFACE;
7593
7594 if (DECL_CONSTRUCTOR_P (method))
7595 return INVOKE_STATIC;
7596
7597 return INVOKE_VIRTUAL;
7598 }
7599
7600 /* Retrieve a refined list of matching methods. It covers the step
7601 15.11.2 (Compile-Time Step 2) */
7602
7603 static tree
7604 lookup_method_invoke (lc, cl, class, name, arg_list)
7605 int lc;
7606 tree cl;
7607 tree class, name, arg_list;
7608 {
7609 tree atl = end_params_node; /* Arg Type List */
7610 tree method, signature, list, node;
7611 const char *candidates; /* Used for error report */
7612 char *dup;
7613
7614 /* Fix the arguments */
7615 for (node = arg_list; node; node = TREE_CHAIN (node))
7616 {
7617 tree current_arg = TREE_TYPE (TREE_VALUE (node));
7618 /* Non primitive type may have to be resolved */
7619 if (!JPRIMITIVE_TYPE_P (current_arg))
7620 resolve_and_layout (current_arg, NULL_TREE);
7621 /* And promoted */
7622 if (TREE_CODE (current_arg) == RECORD_TYPE)
7623 current_arg = promote_type (current_arg);
7624 atl = tree_cons (NULL_TREE, current_arg, atl);
7625 }
7626
7627 /* Find all candidates and then refine the list, searching for the
7628 most specific method. */
7629 list = find_applicable_accessible_methods_list (lc, class, name, atl);
7630 list = find_most_specific_methods_list (list);
7631 if (list && !TREE_CHAIN (list))
7632 return TREE_VALUE (list);
7633
7634 /* Issue an error. List candidates if any. Candidates are listed
7635 only if accessible (non accessible methods may end-up here for
7636 the sake of a better error report). */
7637 candidates = NULL;
7638 if (list)
7639 {
7640 tree current;
7641 obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
7642 for (current = list; current; current = TREE_CHAIN (current))
7643 {
7644 tree cm = TREE_VALUE (current);
7645 char string [4096];
7646 if (!cm || not_accessible_p (class, cm, 0))
7647 continue;
7648 sprintf
7649 (string, " `%s' in `%s'%s",
7650 get_printable_method_name (cm),
7651 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
7652 (TREE_CHAIN (current) ? "\n" : ""));
7653 obstack_grow (&temporary_obstack, string, strlen (string));
7654 }
7655 obstack_1grow (&temporary_obstack, '\0');
7656 candidates = obstack_finish (&temporary_obstack);
7657 }
7658 /* Issue the error message */
7659 method = make_node (FUNCTION_TYPE);
7660 TYPE_ARG_TYPES (method) = atl;
7661 signature = build_java_argument_signature (method);
7662 dup = xstrdup (lang_printable_name (class, 0));
7663 parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
7664 (lc ? "constructor" : "method"),
7665 (lc ? dup : IDENTIFIER_POINTER (name)),
7666 IDENTIFIER_POINTER (signature), dup,
7667 (candidates ? candidates : ""));
7668 free (dup);
7669 return NULL_TREE;
7670 }
7671
7672 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
7673 when we're looking for a constructor. */
7674
7675 static tree
7676 find_applicable_accessible_methods_list (lc, class, name, arglist)
7677 int lc;
7678 tree class, name, arglist;
7679 {
7680 tree list = NULL_TREE, all_list = NULL_TREE;
7681
7682 /* Search interfaces */
7683 if (CLASS_INTERFACE (TYPE_NAME (class))
7684 || CLASS_ABSTRACT (TYPE_NAME (class)))
7685 {
7686 static tree searched_interfaces = NULL_TREE;
7687 static int search_not_done = 0;
7688 int i, n;
7689 tree basetype_vec = TYPE_BINFO_BASETYPES (class);
7690
7691 /* Have we searched this interface already? */
7692 if (searched_interfaces)
7693 {
7694 tree current;
7695 for (current = searched_interfaces;
7696 current; current = TREE_CHAIN (current))
7697 if (TREE_VALUE (current) == class)
7698 return NULL;
7699 }
7700 searched_interfaces = tree_cons (NULL_TREE, class, searched_interfaces);
7701
7702 search_applicable_methods_list
7703 (lc, TYPE_METHODS (class), name, arglist, &list, &all_list);
7704
7705 n = TREE_VEC_LENGTH (basetype_vec);
7706 for (i = 0; i < n; i++)
7707 {
7708 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
7709 tree rlist;
7710
7711 /* Skip java.lang.Object (we'll search it once later.) */
7712 if (t == object_type_node)
7713 continue;
7714
7715 search_not_done++;
7716 rlist = find_applicable_accessible_methods_list (lc, t, name,
7717 arglist);
7718 all_list = chainon (rlist, (list ? list : all_list));
7719 search_not_done--;
7720 }
7721
7722 /* We're done. Reset the searched interfaces list and finally search
7723 java.lang.Object */
7724 if (!search_not_done)
7725 {
7726 searched_interfaces = NULL_TREE;
7727 search_applicable_methods_list (lc, TYPE_METHODS (object_type_node),
7728 name, arglist, &list, &all_list);
7729 }
7730 }
7731 /* Search classes */
7732 else
7733 while (class != NULL_TREE)
7734 {
7735 search_applicable_methods_list
7736 (lc, TYPE_METHODS (class), name, arglist, &list, &all_list);
7737 class = (lc ? NULL_TREE : CLASSTYPE_SUPER (class));
7738 }
7739
7740 /* Either return the list obtained or all selected (but
7741 inaccessible) methods for better error report. */
7742 return (!list ? all_list : list);
7743 }
7744
7745 /* Effectively search for the approriate method in method */
7746
7747 static void
7748 search_applicable_methods_list(lc, method, name, arglist, list, all_list)
7749 int lc;
7750 tree method, name, arglist;
7751 tree *list, *all_list;
7752 {
7753 for (; method; method = TREE_CHAIN (method))
7754 {
7755 /* When dealing with constructor, stop here, otherwise search
7756 other classes */
7757 if (lc && !DECL_CONSTRUCTOR_P (method))
7758 continue;
7759 else if (!lc && (DECL_CONSTRUCTOR_P (method)
7760 || (GET_METHOD_NAME (method) != name)))
7761 continue;
7762
7763 if (argument_types_convertible (method, arglist))
7764 {
7765 /* Retain accessible methods only */
7766 if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
7767 method, 0))
7768 *list = tree_cons (NULL_TREE, method, *list);
7769 else
7770 /* Also retain all selected method here */
7771 *all_list = tree_cons (NULL_TREE, method, *list);
7772 }
7773 }
7774 }
7775
7776 /* 15.11.2.2 Choose the Most Specific Method */
7777
7778 static tree
7779 find_most_specific_methods_list (list)
7780 tree list;
7781 {
7782 int max = 0;
7783 tree current, new_list = NULL_TREE;
7784 for (current = list; current; current = TREE_CHAIN (current))
7785 {
7786 tree method;
7787 DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
7788
7789 for (method = list; method; method = TREE_CHAIN (method))
7790 {
7791 /* Don't test a method against itself */
7792 if (method == current)
7793 continue;
7794
7795 /* Compare arguments and location where method where declared */
7796 if (argument_types_convertible (TREE_VALUE (method),
7797 TREE_VALUE (current))
7798 && valid_method_invocation_conversion_p
7799 (DECL_CONTEXT (TREE_VALUE (method)),
7800 DECL_CONTEXT (TREE_VALUE (current))))
7801 {
7802 int v = ++DECL_SPECIFIC_COUNT (TREE_VALUE (current));
7803 max = (v > max ? v : max);
7804 }
7805 }
7806 }
7807
7808 /* Review the list and select the maximally specific methods */
7809 for (current = list; current; current = TREE_CHAIN (current))
7810 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
7811 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
7812
7813 /* If we can't find one, lower expectations and try to gather multiple
7814 maximally specific methods */
7815 while (!new_list)
7816 {
7817 while (--max > 0)
7818 {
7819 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
7820 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
7821 }
7822 return new_list;
7823 }
7824
7825 return new_list;
7826 }
7827
7828 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
7829 converted by method invocation conversion (5.3) to the type of the
7830 corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
7831 to change less often than M1. */
7832
7833 static int
7834 argument_types_convertible (m1, m2_or_arglist)
7835 tree m1, m2_or_arglist;
7836 {
7837 static tree m2_arg_value = NULL_TREE;
7838 static tree m2_arg_cache = NULL_TREE;
7839
7840 register tree m1_arg, m2_arg;
7841
7842 m1_arg = TYPE_ARG_TYPES (TREE_TYPE (m1));
7843 if (!METHOD_STATIC (m1))
7844 m1_arg = TREE_CHAIN (m1_arg);
7845
7846 if (m2_arg_value == m2_or_arglist)
7847 m2_arg = m2_arg_cache;
7848 else
7849 {
7850 /* M2_OR_ARGLIST can be a function DECL or a raw list of
7851 argument types */
7852 if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
7853 {
7854 m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
7855 if (!METHOD_STATIC (m2_or_arglist))
7856 m2_arg = TREE_CHAIN (m2_arg);
7857 }
7858 else
7859 m2_arg = m2_or_arglist;
7860
7861 m2_arg_value = m2_or_arglist;
7862 m2_arg_cache = m2_arg;
7863 }
7864
7865 while (m1_arg != end_params_node && m2_arg != end_params_node)
7866 {
7867 resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
7868 if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
7869 TREE_VALUE (m2_arg)))
7870 break;
7871 m1_arg = TREE_CHAIN (m1_arg);
7872 m2_arg = TREE_CHAIN (m2_arg);
7873 }
7874 return m1_arg == end_params_node && m2_arg == end_params_node;
7875 }
7876
7877 /* Qualification routines */
7878
7879 static void
7880 qualify_ambiguous_name (id)
7881 tree id;
7882 {
7883 tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
7884 saved_current_class;
7885 int again, super_found = 0, this_found = 0, new_array_found = 0;
7886 int code;
7887
7888 /* We first qualify the first element, then derive qualification of
7889 others based on the first one. If the first element is qualified
7890 by a resolution (field or type), this resolution is stored in the
7891 QUAL_RESOLUTION of the qual element being examined. We need to
7892 save the current_class since the use of SUPER might change the
7893 its value. */
7894 saved_current_class = current_class;
7895 qual = EXPR_WFL_QUALIFICATION (id);
7896 do {
7897
7898 /* Simple qualified expression feature a qual_wfl that is a
7899 WFL. Expression derived from a primary feature more complicated
7900 things like a CALL_EXPR. Expression from primary need to be
7901 worked out to extract the part on which the qualification will
7902 take place. */
7903 qual_wfl = QUAL_WFL (qual);
7904 switch (TREE_CODE (qual_wfl))
7905 {
7906 case CALL_EXPR:
7907 qual_wfl = TREE_OPERAND (qual_wfl, 0);
7908 if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
7909 {
7910 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
7911 qual_wfl = QUAL_WFL (qual);
7912 }
7913 break;
7914 case NEW_ARRAY_EXPR:
7915 qual = TREE_CHAIN (qual);
7916 again = new_array_found = 1;
7917 continue;
7918 case NEW_CLASS_EXPR:
7919 case CONVERT_EXPR:
7920 qual_wfl = TREE_OPERAND (qual_wfl, 0);
7921 break;
7922 case ARRAY_REF:
7923 while (TREE_CODE (qual_wfl) == ARRAY_REF)
7924 qual_wfl = TREE_OPERAND (qual_wfl, 0);
7925 break;
7926 case STRING_CST:
7927 qual = TREE_CHAIN (qual);
7928 qual_wfl = QUAL_WFL (qual);
7929 break;
7930 default:
7931 /* Fix for -Wall. Just break doing nothing */
7932 break;
7933 }
7934
7935 ptr_type = current_class;
7936 again = 0;
7937 code = TREE_CODE (qual_wfl);
7938
7939 /* Pos evaluation: non WFL leading expression nodes */
7940 if (code == CONVERT_EXPR
7941 && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
7942 name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
7943
7944 else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
7945 TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
7946 name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
7947
7948 else if (code == STRING_CST || code == CONDITIONAL_EXPR
7949 || code == PLUS_EXPR)
7950 {
7951 qual = TREE_CHAIN (qual);
7952 qual_wfl = QUAL_WFL (qual);
7953 again = 1;
7954 }
7955 else
7956 {
7957 name = EXPR_WFL_NODE (qual_wfl);
7958 if (!name)
7959 {
7960 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
7961 again = 1;
7962 }
7963 }
7964
7965 /* If we have a THIS (from a primary), we set the context accordingly */
7966 if (name == this_identifier_node)
7967 {
7968 qual = TREE_CHAIN (qual);
7969 qual_wfl = QUAL_WFL (qual);
7970 if (TREE_CODE (qual_wfl) == CALL_EXPR)
7971 again = 1;
7972 else
7973 name = EXPR_WFL_NODE (qual_wfl);
7974 this_found = 1;
7975 }
7976 /* If we have a SUPER, we set the context accordingly */
7977 if (name == super_identifier_node)
7978 {
7979 current_class = CLASSTYPE_SUPER (ptr_type);
7980 /* Check that there is such a thing as a super class. If not,
7981 return. The error will be caught later on, during the
7982 resolution */
7983 if (!current_class)
7984 {
7985 current_class = saved_current_class;
7986 return;
7987 }
7988 qual = TREE_CHAIN (qual);
7989 /* Do one more interation to set things up */
7990 super_found = again = 1;
7991 }
7992 } while (again);
7993
7994 /* If name appears within the scope of a location variable
7995 declaration or parameter declaration, then it is an expression
7996 name. We don't carry this test out if we're in the context of the
7997 use of SUPER or THIS */
7998 if (!this_found && !super_found &&
7999 TREE_CODE (name) != STRING_CST && (decl = IDENTIFIER_LOCAL_VALUE (name)))
8000 {
8001 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
8002 QUAL_RESOLUTION (qual) = decl;
8003 }
8004
8005 /* If within the class/interface NAME was found to be used there
8006 exists a (possibly inherited) field named NAME, then this is an
8007 expression name. If we saw a NEW_ARRAY_EXPR before and want to
8008 address length, it is OK. */
8009 else if ((decl = lookup_field_wrapper (ptr_type, name))
8010 || (new_array_found && name == length_identifier_node))
8011 {
8012 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
8013 QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
8014 }
8015
8016 /* We reclassify NAME as yielding to a type name resolution if:
8017 - NAME is a class/interface declared within the compilation
8018 unit containing NAME,
8019 - NAME is imported via a single-type-import declaration,
8020 - NAME is declared in an another compilation unit of the package
8021 of the compilation unit containing NAME,
8022 - NAME is declared by exactly on type-import-on-demand declaration
8023 of the compilation unit containing NAME.
8024 - NAME is actually a STRING_CST. */
8025 else if (TREE_CODE (name) == STRING_CST ||
8026 (decl = resolve_and_layout (name, NULL_TREE)))
8027 {
8028 RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
8029 QUAL_RESOLUTION (qual) = decl;
8030 }
8031
8032 /* Method call are expression name */
8033 else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
8034 || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
8035 || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR)
8036 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
8037
8038 /* Check here that NAME isn't declared by more than one
8039 type-import-on-demand declaration of the compilation unit
8040 containing NAME. FIXME */
8041
8042 /* Otherwise, NAME is reclassified as a package name */
8043 else
8044 RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
8045
8046 /* Propagate the qualification accross other components of the
8047 qualified name */
8048 for (qual = TREE_CHAIN (qual); qual;
8049 qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
8050 {
8051 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
8052 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
8053 else
8054 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
8055 }
8056
8057 /* Store the global qualification for the ambiguous part of ID back
8058 into ID fields */
8059 if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
8060 RESOLVE_EXPRESSION_NAME_P (id) = 1;
8061 else if (RESOLVE_TYPE_NAME_P (qual_wfl))
8062 RESOLVE_TYPE_NAME_P (id) = 1;
8063 else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
8064 RESOLVE_PACKAGE_NAME_P (id) = 1;
8065
8066 /* Restore the current class */
8067 current_class = saved_current_class;
8068 }
8069
8070 static int
8071 breakdown_qualified (left, right, source)
8072 tree *left, *right, source;
8073 {
8074 char *p = IDENTIFIER_POINTER (source), *base;
8075 int l = IDENTIFIER_LENGTH (source);
8076
8077 /* Breakdown NAME into REMAINDER . IDENTIFIER */
8078 base = p;
8079 p += (l-1);
8080 while (*p != '.' && p != base)
8081 p--;
8082
8083 /* We didn't find a '.'. Return an error */
8084 if (p == base)
8085 return 1;
8086
8087 *p = '\0';
8088 if (right)
8089 *right = get_identifier (p+1);
8090 *left = get_identifier (IDENTIFIER_POINTER (source));
8091 *p = '.';
8092
8093 return 0;
8094 }
8095
8096 /* Patch tree nodes in a function body. When a BLOCK is found, push
8097 local variable decls if present.
8098 Same as java_complete_lhs, but does resolve static finals to values. */
8099
8100 static tree
8101 java_complete_tree (node)
8102 tree node;
8103 {
8104 node = java_complete_lhs (node);
8105 if (TREE_CODE (node) == VAR_DECL && FIELD_STATIC (node)
8106 && FIELD_FINAL (node) && DECL_INITIAL (node) != NULL_TREE
8107 && !flag_emit_xref)
8108 {
8109 tree value = DECL_INITIAL (node);
8110 DECL_INITIAL (node) = NULL_TREE;
8111 push_obstacks (&permanent_obstack, &permanent_obstack);
8112 value = fold_constant_for_init (value, node);
8113 pop_obstacks ();
8114 DECL_INITIAL (node) = value;
8115 if (value != NULL_TREE)
8116 return value;
8117 }
8118 return node;
8119 }
8120
8121 static tree
8122 java_stabilize_reference (node)
8123 tree node;
8124 {
8125 if (TREE_CODE (node) == COMPOUND_EXPR)
8126 {
8127 tree op0 = TREE_OPERAND (node, 0);
8128 tree op1 = TREE_OPERAND (node, 1);
8129 TREE_OPERAND (node, 0) = save_expr (op0);
8130 TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
8131 return node;
8132 }
8133 return stabilize_reference (node);
8134 }
8135
8136 /* Patch tree nodes in a function body. When a BLOCK is found, push
8137 local variable decls if present.
8138 Same as java_complete_tree, but does not resolve static finals to values. */
8139
8140 static tree
8141 java_complete_lhs (node)
8142 tree node;
8143 {
8144 tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
8145 int flag;
8146
8147 /* CONVERT_EXPR always has its type set, even though it needs to be
8148 worked out. */
8149 if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
8150 return node;
8151
8152 /* The switch block implements cases processing container nodes
8153 first. Contained nodes are always written back. Leaves come
8154 next and return a value. */
8155 switch (TREE_CODE (node))
8156 {
8157 case BLOCK:
8158
8159 /* 1- Block section.
8160 Set the local values on decl names so we can identify them
8161 faster when they're referenced. At that stage, identifiers
8162 are legal so we don't check for declaration errors. */
8163 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
8164 {
8165 DECL_CONTEXT (cn) = current_function_decl;
8166 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
8167 }
8168 if (BLOCK_EXPR_BODY (node) == NULL_TREE)
8169 CAN_COMPLETE_NORMALLY (node) = 1;
8170 else
8171 {
8172 tree stmt = BLOCK_EXPR_BODY (node);
8173 tree *ptr;
8174 int error_seen = 0;
8175 if (TREE_CODE (stmt) == COMPOUND_EXPR)
8176 {
8177 /* Re-order from (((A; B); C); ...; Z) to
8178 (A; (B; (C ; (...; Z)))).
8179 This makes it easier to scan the statements left-to-right
8180 without using recursion (which might overflow the stack
8181 if the block has many statements. */
8182 for (;;)
8183 {
8184 tree left = TREE_OPERAND (stmt, 0);
8185 if (TREE_CODE (left) != COMPOUND_EXPR)
8186 break;
8187 TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
8188 TREE_OPERAND (left, 1) = stmt;
8189 stmt = left;
8190 }
8191 BLOCK_EXPR_BODY (node) = stmt;
8192 }
8193
8194 /* Now do the actual complete, without deep recursion for
8195 long blocks. */
8196 ptr = &BLOCK_EXPR_BODY (node);
8197 while (TREE_CODE (*ptr) == COMPOUND_EXPR
8198 && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
8199 {
8200 tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
8201 tree *next = &TREE_OPERAND (*ptr, 1);
8202 TREE_OPERAND (*ptr, 0) = cur;
8203 if (cur == empty_stmt_node)
8204 {
8205 /* Optimization; makes it easier to detect empty bodies.
8206 Most useful for <clinit> with all-constant initializer. */
8207 *ptr = *next;
8208 continue;
8209 }
8210 if (TREE_CODE (cur) == ERROR_MARK)
8211 error_seen++;
8212 else if (! CAN_COMPLETE_NORMALLY (cur))
8213 {
8214 wfl_op2 = *next;
8215 for (;;)
8216 {
8217 if (TREE_CODE (wfl_op2) == BLOCK)
8218 wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
8219 else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
8220 wfl_op2 = TREE_OPERAND (wfl_op2, 0);
8221 else
8222 break;
8223 }
8224 if (TREE_CODE (wfl_op2) != CASE_EXPR
8225 && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
8226 unreachable_stmt_error (*ptr);
8227 }
8228 ptr = next;
8229 }
8230 *ptr = java_complete_tree (*ptr);
8231
8232 if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
8233 return error_mark_node;
8234 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
8235 }
8236 /* Turn local bindings to null */
8237 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
8238 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
8239
8240 TREE_TYPE (node) = void_type_node;
8241 break;
8242
8243 /* 2- They are expressions but ultimately deal with statements */
8244
8245 case THROW_EXPR:
8246 wfl_op1 = TREE_OPERAND (node, 0);
8247 COMPLETE_CHECK_OP_0 (node);
8248 /* CAN_COMPLETE_NORMALLY (node) = 0; */
8249 return patch_throw_statement (node, wfl_op1);
8250
8251 case SYNCHRONIZED_EXPR:
8252 wfl_op1 = TREE_OPERAND (node, 0);
8253 return patch_synchronized_statement (node, wfl_op1);
8254
8255 case TRY_EXPR:
8256 return patch_try_statement (node);
8257
8258 case TRY_FINALLY_EXPR:
8259 COMPLETE_CHECK_OP_0 (node);
8260 COMPLETE_CHECK_OP_1 (node);
8261 CAN_COMPLETE_NORMALLY (node)
8262 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
8263 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
8264 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
8265 return node;
8266
8267 case CLEANUP_POINT_EXPR:
8268 COMPLETE_CHECK_OP_0 (node);
8269 TREE_TYPE (node) = void_type_node;
8270 CAN_COMPLETE_NORMALLY (node) =
8271 CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
8272 return node;
8273
8274 case WITH_CLEANUP_EXPR:
8275 COMPLETE_CHECK_OP_0 (node);
8276 COMPLETE_CHECK_OP_2 (node);
8277 CAN_COMPLETE_NORMALLY (node) =
8278 CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
8279 TREE_TYPE (node) = void_type_node;
8280 return node;
8281
8282 case LABELED_BLOCK_EXPR:
8283 PUSH_LABELED_BLOCK (node);
8284 if (LABELED_BLOCK_BODY (node))
8285 COMPLETE_CHECK_OP_1 (node);
8286 TREE_TYPE (node) = void_type_node;
8287 POP_LABELED_BLOCK ();
8288
8289 if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
8290 {
8291 LABELED_BLOCK_BODY (node) = NULL_TREE;
8292 CAN_COMPLETE_NORMALLY (node) = 1;
8293 }
8294 else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
8295 CAN_COMPLETE_NORMALLY (node) = 1;
8296 return node;
8297
8298 case EXIT_BLOCK_EXPR:
8299 /* We don't complete operand 1, because it's the return value of
8300 the EXIT_BLOCK_EXPR which doesn't exist it Java */
8301 return patch_bc_statement (node);
8302
8303 case CASE_EXPR:
8304 cn = java_complete_tree (TREE_OPERAND (node, 0));
8305 if (cn == error_mark_node)
8306 return cn;
8307
8308 /* First, the case expression must be constant. Values of final
8309 fields are accepted. */
8310 cn = fold (cn);
8311 if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
8312 && JDECL_P (TREE_OPERAND (cn, 1))
8313 && FIELD_FINAL (TREE_OPERAND (cn, 1))
8314 && DECL_INITIAL (TREE_OPERAND (cn, 1)))
8315 {
8316 push_obstacks (&permanent_obstack, &permanent_obstack);
8317 cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
8318 TREE_OPERAND (cn, 1));
8319 pop_obstacks ();
8320 }
8321
8322 if (!TREE_CONSTANT (cn) && !flag_emit_xref)
8323 {
8324 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
8325 parse_error_context (node, "Constant expression required");
8326 return error_mark_node;
8327 }
8328
8329 nn = ctxp->current_loop;
8330
8331 /* It must be assignable to the type of the switch expression. */
8332 if (!try_builtin_assignconv (NULL_TREE,
8333 TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
8334 {
8335 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
8336 parse_error_context
8337 (wfl_operator,
8338 "Incompatible type for case. Can't convert `%s' to `int'",
8339 lang_printable_name (TREE_TYPE (cn), 0));
8340 return error_mark_node;
8341 }
8342
8343 cn = fold (convert (int_type_node, cn));
8344
8345 /* Multiple instance of a case label bearing the same
8346 value is checked during code generation. The case
8347 expression is allright so far. */
8348 TREE_OPERAND (node, 0) = cn;
8349 TREE_TYPE (node) = void_type_node;
8350 CAN_COMPLETE_NORMALLY (node) = 1;
8351 TREE_SIDE_EFFECTS (node) = 1;
8352 break;
8353
8354 case DEFAULT_EXPR:
8355 nn = ctxp->current_loop;
8356 /* Only one default label is allowed per switch statement */
8357 if (SWITCH_HAS_DEFAULT (nn))
8358 {
8359 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
8360 parse_error_context (wfl_operator,
8361 "Duplicate case label: `default'");
8362 return error_mark_node;
8363 }
8364 else
8365 SWITCH_HAS_DEFAULT (nn) = 1;
8366 TREE_TYPE (node) = void_type_node;
8367 TREE_SIDE_EFFECTS (node) = 1;
8368 CAN_COMPLETE_NORMALLY (node) = 1;
8369 break;
8370
8371 case SWITCH_EXPR:
8372 case LOOP_EXPR:
8373 PUSH_LOOP (node);
8374 /* Check whether the loop was enclosed in a labeled
8375 statement. If not, create one, insert the loop in it and
8376 return the node */
8377 nn = patch_loop_statement (node);
8378
8379 /* Anyways, walk the body of the loop */
8380 if (TREE_CODE (node) == LOOP_EXPR)
8381 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
8382 /* Switch statement: walk the switch expression and the cases */
8383 else
8384 node = patch_switch_statement (node);
8385
8386 if (TREE_OPERAND (node, 0) == error_mark_node)
8387 nn = error_mark_node;
8388 else
8389 {
8390 TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
8391 /* If we returned something different, that's because we
8392 inserted a label. Pop the label too. */
8393 if (nn != node)
8394 {
8395 if (CAN_COMPLETE_NORMALLY (node))
8396 CAN_COMPLETE_NORMALLY (nn) = 1;
8397 POP_LABELED_BLOCK ();
8398 }
8399 }
8400 POP_LOOP ();
8401 return nn;
8402
8403 case EXIT_EXPR:
8404 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
8405 return patch_exit_expr (node);
8406
8407 case COND_EXPR:
8408 /* Condition */
8409 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
8410 if (TREE_OPERAND (node, 0) == error_mark_node)
8411 return error_mark_node;
8412 /* then-else branches */
8413 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
8414 if (TREE_OPERAND (node, 1) == error_mark_node)
8415 return error_mark_node;
8416 TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
8417 if (TREE_OPERAND (node, 2) == error_mark_node)
8418 return error_mark_node;
8419 return patch_if_else_statement (node);
8420 break;
8421
8422 case CONDITIONAL_EXPR:
8423 /* Condition */
8424 wfl_op1 = TREE_OPERAND (node, 0);
8425 COMPLETE_CHECK_OP_0 (node);
8426 wfl_op2 = TREE_OPERAND (node, 1);
8427 COMPLETE_CHECK_OP_1 (node);
8428 wfl_op3 = TREE_OPERAND (node, 2);
8429 COMPLETE_CHECK_OP_2 (node);
8430 return patch_conditional_expr (node, wfl_op1, wfl_op2);
8431
8432 /* 3- Expression section */
8433 case COMPOUND_EXPR:
8434 wfl_op2 = TREE_OPERAND (node, 1);
8435 TREE_OPERAND (node, 0) = nn =
8436 java_complete_tree (TREE_OPERAND (node, 0));
8437 if (wfl_op2 == empty_stmt_node)
8438 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
8439 else
8440 {
8441 if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
8442 {
8443 /* An unreachable condition in a do-while statement
8444 is *not* (technically) an unreachable statement. */
8445 nn = wfl_op2;
8446 if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
8447 nn = EXPR_WFL_NODE (nn);
8448 if (TREE_CODE (nn) != EXIT_EXPR)
8449 {
8450 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
8451 parse_error_context (wfl_operator, "Unreachable statement");
8452 }
8453 }
8454 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
8455 if (TREE_OPERAND (node, 1) == error_mark_node)
8456 return error_mark_node;
8457 CAN_COMPLETE_NORMALLY (node)
8458 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1));
8459 }
8460 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
8461 break;
8462
8463 case RETURN_EXPR:
8464 /* CAN_COMPLETE_NORMALLY (node) = 0; */
8465 return patch_return (node);
8466
8467 case EXPR_WITH_FILE_LOCATION:
8468 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
8469 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
8470 {
8471 tree wfl = node;
8472 node = resolve_expression_name (node, NULL);
8473 if (node == error_mark_node)
8474 return node;
8475 /* Keep line number information somewhere were it doesn't
8476 disrupt the completion process. */
8477 if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
8478 {
8479 EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
8480 TREE_OPERAND (node, 1) = wfl;
8481 }
8482 CAN_COMPLETE_NORMALLY (node) = 1;
8483 }
8484 else
8485 {
8486 tree body;
8487 int save_lineno = lineno;
8488 lineno = EXPR_WFL_LINENO (node);
8489 body = java_complete_tree (EXPR_WFL_NODE (node));
8490 lineno = save_lineno;
8491 EXPR_WFL_NODE (node) = body;
8492 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
8493 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
8494 if (body == empty_stmt_node)
8495 {
8496 /* Optimization; makes it easier to detect empty bodies. */
8497 return body;
8498 }
8499 if (body == error_mark_node)
8500 {
8501 /* Its important for the evaluation of assignment that
8502 this mark on the TREE_TYPE is propagated. */
8503 TREE_TYPE (node) = error_mark_node;
8504 return error_mark_node;
8505 }
8506 else
8507 TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
8508
8509 }
8510 break;
8511
8512 case NEW_ARRAY_EXPR:
8513 /* Patch all the dimensions */
8514 flag = 0;
8515 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
8516 {
8517 int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
8518 tree dim = convert (int_type_node,
8519 java_complete_tree (TREE_VALUE (cn)));
8520 if (dim == error_mark_node)
8521 {
8522 flag = 1;
8523 continue;
8524 }
8525 else
8526 {
8527 TREE_VALUE (cn) = dim;
8528 /* Setup the location of the current dimension, for
8529 later error report. */
8530 TREE_PURPOSE (cn) =
8531 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
8532 EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
8533 }
8534 }
8535 /* They complete the array creation expression, if no errors
8536 were found. */
8537 CAN_COMPLETE_NORMALLY (node) = 1;
8538 return (flag ? error_mark_node
8539 : force_evaluation_order (patch_newarray (node)));
8540
8541 case NEW_CLASS_EXPR:
8542 case CALL_EXPR:
8543 /* Complete function's argument(s) first */
8544 if (complete_function_arguments (node))
8545 return error_mark_node;
8546 else
8547 {
8548 tree decl, wfl = TREE_OPERAND (node, 0);
8549 int in_this = CALL_THIS_CONSTRUCTOR_P (node);
8550
8551 node = patch_method_invocation (node, NULL_TREE,
8552 NULL_TREE, 0, &decl);
8553 if (node == error_mark_node)
8554 return error_mark_node;
8555
8556 check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
8557 /* If we call this(...), register signature and positions */
8558 if (in_this)
8559 DECL_CONSTRUCTOR_CALLS (current_function_decl) =
8560 tree_cons (wfl, decl,
8561 DECL_CONSTRUCTOR_CALLS (current_function_decl));
8562 CAN_COMPLETE_NORMALLY (node) = 1;
8563 return force_evaluation_order (node);
8564 }
8565
8566 case MODIFY_EXPR:
8567 /* Save potential wfls */
8568 wfl_op1 = TREE_OPERAND (node, 0);
8569 TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
8570 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
8571 && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
8572 && DECL_INITIAL (nn) != NULL_TREE)
8573 {
8574 tree value;
8575
8576 push_obstacks (&permanent_obstack, &permanent_obstack);
8577 value = fold_constant_for_init (nn, nn);
8578 pop_obstacks ();
8579 if (value != NULL_TREE)
8580 {
8581 tree type = TREE_TYPE (value);
8582 if (JPRIMITIVE_TYPE_P (type) || type == string_ptr_type_node)
8583 return empty_stmt_node;
8584 }
8585 DECL_INITIAL (nn) = NULL_TREE;
8586 }
8587 wfl_op2 = TREE_OPERAND (node, 1);
8588
8589 if (TREE_OPERAND (node, 0) == error_mark_node)
8590 return error_mark_node;
8591
8592 flag = COMPOUND_ASSIGN_P (wfl_op2);
8593 if (flag)
8594 {
8595 tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
8596
8597 /* Hand stablize the lhs on both places */
8598 TREE_OPERAND (node, 0) = lvalue;
8599 TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
8600 (flag_emit_class_files ? lvalue : save_expr (lvalue));
8601
8602 /* 15.25.2.a: Left hand is not an array access. FIXME */
8603 /* Now complete the RHS. We write it back later on. */
8604 nn = java_complete_tree (TREE_OPERAND (node, 1));
8605
8606 if ((cn = patch_string (nn)))
8607 nn = cn;
8608
8609 /* The last part of the rewrite for E1 op= E2 is to have
8610 E1 = (T)(E1 op E2), with T being the type of E1. */
8611 nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
8612 TREE_TYPE (lvalue), nn));
8613
8614 /* 15.25.2.b: Left hand is an array access. FIXME */
8615 }
8616
8617 /* If we're about to patch a NEW_ARRAY_INIT, we call a special
8618 function to complete this RHS */
8619 else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT)
8620 nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
8621 TREE_OPERAND (node, 1));
8622 /* Otherwise we simply complete the RHS */
8623 else
8624 nn = java_complete_tree (TREE_OPERAND (node, 1));
8625
8626 if (nn == error_mark_node)
8627 return error_mark_node;
8628
8629 /* Write back the RHS as we evaluated it. */
8630 TREE_OPERAND (node, 1) = nn;
8631
8632 /* In case we're handling = with a String as a RHS, we need to
8633 produce a String out of the RHS (it might still be a
8634 STRING_CST or a StringBuffer at this stage */
8635 if ((nn = patch_string (TREE_OPERAND (node, 1))))
8636 TREE_OPERAND (node, 1) = nn;
8637 node = patch_assignment (node, wfl_op1, wfl_op2);
8638 /* Reorganize the tree if necessary. */
8639 if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
8640 || JSTRING_P (TREE_TYPE (node))))
8641 node = java_refold (node);
8642 CAN_COMPLETE_NORMALLY (node) = 1;
8643 return node;
8644
8645 case MULT_EXPR:
8646 case PLUS_EXPR:
8647 case MINUS_EXPR:
8648 case LSHIFT_EXPR:
8649 case RSHIFT_EXPR:
8650 case URSHIFT_EXPR:
8651 case BIT_AND_EXPR:
8652 case BIT_XOR_EXPR:
8653 case BIT_IOR_EXPR:
8654 case TRUNC_MOD_EXPR:
8655 case RDIV_EXPR:
8656 case TRUTH_ANDIF_EXPR:
8657 case TRUTH_ORIF_EXPR:
8658 case EQ_EXPR:
8659 case NE_EXPR:
8660 case GT_EXPR:
8661 case GE_EXPR:
8662 case LT_EXPR:
8663 case LE_EXPR:
8664 /* Operands 0 and 1 are WFL in certain cases only. patch_binop
8665 knows how to handle those cases. */
8666 wfl_op1 = TREE_OPERAND (node, 0);
8667 wfl_op2 = TREE_OPERAND (node, 1);
8668
8669 CAN_COMPLETE_NORMALLY (node) = 1;
8670 /* Don't complete string nodes if dealing with the PLUS operand. */
8671 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
8672 {
8673 nn = java_complete_tree (wfl_op1);
8674 if (nn == error_mark_node)
8675 return error_mark_node;
8676 if ((cn = patch_string (nn)))
8677 nn = cn;
8678 TREE_OPERAND (node, 0) = nn;
8679 }
8680 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
8681 {
8682 nn = java_complete_tree (wfl_op2);
8683 if (nn == error_mark_node)
8684 return error_mark_node;
8685 if ((cn = patch_string (nn)))
8686 nn = cn;
8687 TREE_OPERAND (node, 1) = nn;
8688 }
8689 return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
8690
8691 case INSTANCEOF_EXPR:
8692 wfl_op1 = TREE_OPERAND (node, 0);
8693 COMPLETE_CHECK_OP_0 (node);
8694 if (flag_emit_xref)
8695 {
8696 TREE_TYPE (node) = boolean_type_node;
8697 return node;
8698 }
8699 return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
8700
8701 case UNARY_PLUS_EXPR:
8702 case NEGATE_EXPR:
8703 case TRUTH_NOT_EXPR:
8704 case BIT_NOT_EXPR:
8705 case PREDECREMENT_EXPR:
8706 case PREINCREMENT_EXPR:
8707 case POSTDECREMENT_EXPR:
8708 case POSTINCREMENT_EXPR:
8709 case CONVERT_EXPR:
8710 /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
8711 how to handle those cases. */
8712 wfl_op1 = TREE_OPERAND (node, 0);
8713 CAN_COMPLETE_NORMALLY (node) = 1;
8714 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
8715 if (TREE_OPERAND (node, 0) == error_mark_node)
8716 return error_mark_node;
8717 node = patch_unaryop (node, wfl_op1);
8718 CAN_COMPLETE_NORMALLY (node) = 1;
8719 break;
8720
8721 case ARRAY_REF:
8722 /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
8723 how to handle those cases. */
8724 wfl_op1 = TREE_OPERAND (node, 0);
8725 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
8726 if (TREE_OPERAND (node, 0) == error_mark_node)
8727 return error_mark_node;
8728 if (!flag_emit_class_files && !flag_emit_xref)
8729 TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
8730 /* The same applies to wfl_op2 */
8731 wfl_op2 = TREE_OPERAND (node, 1);
8732 TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
8733 if (TREE_OPERAND (node, 1) == error_mark_node)
8734 return error_mark_node;
8735 if (!flag_emit_class_files && !flag_emit_xref)
8736 TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
8737 return patch_array_ref (node);
8738
8739 case RECORD_TYPE:
8740 return node;;
8741
8742 case COMPONENT_REF:
8743 /* The first step in the re-write of qualified name handling. FIXME.
8744 So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
8745 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
8746 if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
8747 {
8748 tree name = TREE_OPERAND (node, 1);
8749 tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
8750 if (field == NULL_TREE)
8751 {
8752 error ("missing static field `%s'", IDENTIFIER_POINTER (name));
8753 return error_mark_node;
8754 }
8755 if (! FIELD_STATIC (field))
8756 {
8757 error ("not a static field `%s'", IDENTIFIER_POINTER (name));
8758 return error_mark_node;
8759 }
8760 return field;
8761 }
8762 else
8763 fatal ("unimplemented java_complete_tree for COMPONENT_REF");
8764 break;
8765
8766 case THIS_EXPR:
8767 /* Can't use THIS in a static environment */
8768 if (!current_this)
8769 {
8770 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
8771 parse_error_context (wfl_operator,
8772 "Keyword `this' used outside allowed context");
8773 TREE_TYPE (node) = error_mark_node;
8774 return error_mark_node;
8775 }
8776 if (ctxp->explicit_constructor_p)
8777 {
8778 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
8779 parse_error_context
8780 (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
8781 TREE_TYPE (node) = error_mark_node;
8782 return error_mark_node;
8783 }
8784 return current_this;
8785
8786 default:
8787 CAN_COMPLETE_NORMALLY (node) = 1;
8788 /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
8789 and it's time to turn it into the appropriate String object
8790 */
8791 if ((node = patch_string (node)))
8792 return node;
8793 fatal ("No case for tree code `%s' - java_complete_tree\n",
8794 tree_code_name [TREE_CODE (node)]);
8795 }
8796 return node;
8797 }
8798
8799 /* Complete function call's argument. Return a non zero value is an
8800 error was found. */
8801
8802 static int
8803 complete_function_arguments (node)
8804 tree node;
8805 {
8806 int flag = 0;
8807 tree cn;
8808
8809 ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
8810 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
8811 {
8812 tree wfl = TREE_VALUE (cn), parm, temp;
8813 parm = java_complete_tree (wfl);
8814 if (parm == error_mark_node)
8815 {
8816 flag = 1;
8817 continue;
8818 }
8819 /* If have a string literal that we haven't transformed yet or a
8820 crafted string buffer, as a result of use of the the String
8821 `+' operator. Build `parm.toString()' and expand it. */
8822 if ((temp = patch_string (parm)))
8823 parm = temp;
8824 /* Inline PRIMTYPE.TYPE read access */
8825 parm = maybe_build_primttype_type_ref (parm, wfl);
8826
8827 TREE_VALUE (cn) = parm;
8828 }
8829 ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
8830 return flag;
8831 }
8832
8833 /* Sometimes (for loops and variable initialized during their
8834 declaration), we want to wrap a statement around a WFL and turn it
8835 debugable. */
8836
8837 static tree
8838 build_debugable_stmt (location, stmt)
8839 int location;
8840 tree stmt;
8841 {
8842 if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
8843 {
8844 stmt = build_expr_wfl (stmt, input_filename, 0, 0);
8845 EXPR_WFL_LINECOL (stmt) = location;
8846 }
8847 JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
8848 return stmt;
8849 }
8850
8851 static tree
8852 build_expr_block (body, decls)
8853 tree body, decls;
8854 {
8855 tree node = make_node (BLOCK);
8856 BLOCK_EXPR_DECLS (node) = decls;
8857 BLOCK_EXPR_BODY (node) = body;
8858 if (body)
8859 TREE_TYPE (node) = TREE_TYPE (body);
8860 TREE_SIDE_EFFECTS (node) = 1;
8861 return node;
8862 }
8863
8864 /* Create a new function block and link it approriately to current
8865 function block chain */
8866
8867 static tree
8868 enter_block ()
8869 {
8870 return (enter_a_block (build_expr_block (NULL_TREE, NULL_TREE)));
8871 }
8872
8873 /* Link block B supercontext to the previous block. The current
8874 function DECL is used as supercontext when enter_a_block is called
8875 for the first time for a given function. The current function body
8876 (DECL_FUNCTION_BODY) is set to be block B. */
8877
8878 static tree
8879 enter_a_block (b)
8880 tree b;
8881 {
8882 tree fndecl = current_function_decl;
8883
8884 if (!fndecl) {
8885 BLOCK_SUPERCONTEXT (b) = current_static_block;
8886 current_static_block = b;
8887 }
8888
8889 else if (!DECL_FUNCTION_BODY (fndecl))
8890 {
8891 BLOCK_SUPERCONTEXT (b) = fndecl;
8892 DECL_FUNCTION_BODY (fndecl) = b;
8893 }
8894 else
8895 {
8896 BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
8897 DECL_FUNCTION_BODY (fndecl) = b;
8898 }
8899 return b;
8900 }
8901
8902 /* Exit a block by changing the current function body
8903 (DECL_FUNCTION_BODY) to the current block super context, only if
8904 the block being exited isn't the method's top level one. */
8905
8906 static tree
8907 exit_block ()
8908 {
8909 tree b;
8910 if (current_function_decl)
8911 {
8912 b = DECL_FUNCTION_BODY (current_function_decl);
8913 if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
8914 DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
8915 }
8916 else
8917 {
8918 b = current_static_block;
8919
8920 if (BLOCK_SUPERCONTEXT (b))
8921 current_static_block = BLOCK_SUPERCONTEXT (b);
8922 }
8923 return b;
8924 }
8925
8926 /* Lookup for NAME in the nested function's blocks, all the way up to
8927 the current toplevel one. It complies with Java's local variable
8928 scoping rules. */
8929
8930 static tree
8931 lookup_name_in_blocks (name)
8932 tree name;
8933 {
8934 tree b = GET_CURRENT_BLOCK (current_function_decl);
8935
8936 while (b != current_function_decl)
8937 {
8938 tree current;
8939
8940 /* Paranoid sanity check. To be removed */
8941 if (TREE_CODE (b) != BLOCK)
8942 fatal ("non block expr function body - lookup_name_in_blocks");
8943
8944 for (current = BLOCK_EXPR_DECLS (b); current;
8945 current = TREE_CHAIN (current))
8946 if (DECL_NAME (current) == name)
8947 return current;
8948 b = BLOCK_SUPERCONTEXT (b);
8949 }
8950 return NULL_TREE;
8951 }
8952
8953 static void
8954 maybe_absorb_scoping_blocks ()
8955 {
8956 while (BLOCK_EXPR_ORIGIN (GET_CURRENT_BLOCK (current_function_decl)))
8957 {
8958 tree b = exit_block ();
8959 java_method_add_stmt (current_function_decl, b);
8960 SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
8961 }
8962 }
8963
8964 \f
8965 /* This section of the source is reserved to build_* functions that
8966 are building incomplete tree nodes and the patch_* functions that
8967 are completing them. */
8968
8969 /* Build a super() constructor invocation. Returns empty_stmt_node if
8970 we're currently dealing with the class java.lang.Object. */
8971
8972 static tree
8973 build_super_invocation (mdecl)
8974 tree mdecl;
8975 {
8976 if (DECL_CONTEXT (mdecl) == object_type_node)
8977 return empty_stmt_node;
8978 else
8979 {
8980 tree super_wfl = build_wfl_node (super_identifier_node);
8981 return build_method_invocation (super_wfl, NULL_TREE);
8982 }
8983 }
8984
8985 /* Build a SUPER/THIS qualified method invocation. */
8986
8987 static tree
8988 build_this_super_qualified_invocation (use_this, name, args, lloc, rloc)
8989 int use_this;
8990 tree name, args;
8991 int lloc, rloc;
8992
8993 {
8994 tree invok;
8995 tree wfl =
8996 build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
8997 EXPR_WFL_LINECOL (wfl) = lloc;
8998 invok = build_method_invocation (name, args);
8999 return make_qualified_primary (wfl, invok, rloc);
9000 }
9001
9002 /* Build an incomplete CALL_EXPR node. */
9003
9004 static tree
9005 build_method_invocation (name, args)
9006 tree name;
9007 tree args;
9008 {
9009 tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
9010 TREE_SIDE_EFFECTS (call) = 1;
9011 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
9012 return call;
9013 }
9014
9015 /* Build an incomplete new xxx(...) node. */
9016
9017 static tree
9018 build_new_invocation (name, args)
9019 tree name, args;
9020 {
9021 tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
9022 TREE_SIDE_EFFECTS (call) = 1;
9023 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
9024 return call;
9025 }
9026
9027 /* Build an incomplete assignment expression. */
9028
9029 static tree
9030 build_assignment (op, op_location, lhs, rhs)
9031 int op, op_location;
9032 tree lhs, rhs;
9033 {
9034 tree assignment;
9035 /* Build the corresponding binop if we deal with a Compound
9036 Assignment operator. Mark the binop sub-tree as part of a
9037 Compound Assignment expression */
9038 if (op != ASSIGN_TK)
9039 {
9040 rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
9041 COMPOUND_ASSIGN_P (rhs) = 1;
9042 }
9043 assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
9044 TREE_SIDE_EFFECTS (assignment) = 1;
9045 EXPR_WFL_LINECOL (assignment) = op_location;
9046 return assignment;
9047 }
9048
9049 /* Print an INTEGER_CST node in a static buffer, and return the buffer. */
9050
9051 char *
9052 print_int_node (node)
9053 tree node;
9054 {
9055 static char buffer [80];
9056 if (TREE_CONSTANT_OVERFLOW (node))
9057 sprintf (buffer, "<overflow>");
9058
9059 if (TREE_INT_CST_HIGH (node) == 0)
9060 sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
9061 TREE_INT_CST_LOW (node));
9062 else if (TREE_INT_CST_HIGH (node) == -1
9063 && TREE_INT_CST_LOW (node) != 0)
9064 {
9065 buffer [0] = '-';
9066 sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
9067 -TREE_INT_CST_LOW (node));
9068 }
9069 else
9070 sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
9071 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
9072
9073 return buffer;
9074 }
9075
9076 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
9077 context. */
9078
9079 static int
9080 check_final_assignment (lvalue, wfl)
9081 tree lvalue, wfl;
9082 {
9083 if (JDECL_P (lvalue)
9084 && FIELD_FINAL (lvalue) && !IS_CLINIT (current_function_decl))
9085 {
9086 parse_error_context
9087 (wfl, "Can't assign a value to the final variable `%s'",
9088 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9089 return 1;
9090 }
9091 return 0;
9092 }
9093
9094 /* Inline references to java.lang.PRIMTYPE.TYPE when accessed in
9095 read. This is needed to avoid circularities in the implementation
9096 of these fields in libjava. */
9097
9098 static tree
9099 maybe_build_primttype_type_ref (rhs, wfl)
9100 tree rhs, wfl;
9101 {
9102 tree to_return = NULL_TREE;
9103 tree rhs_type = TREE_TYPE (rhs);
9104 if (TREE_CODE (rhs) == COMPOUND_EXPR)
9105 {
9106 tree n = TREE_OPERAND (rhs, 1);
9107 if (TREE_CODE (n) == VAR_DECL
9108 && DECL_NAME (n) == TYPE_identifier_node
9109 && rhs_type == class_ptr_type)
9110 {
9111 const char *self_name = IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl));
9112 if (!strncmp (self_name, "java.lang.", 10))
9113 to_return = build_primtype_type_ref (self_name);
9114 }
9115 }
9116 return (to_return ? to_return : rhs );
9117 }
9118
9119 /* 15.25 Assignment operators. */
9120
9121 static tree
9122 patch_assignment (node, wfl_op1, wfl_op2)
9123 tree node;
9124 tree wfl_op1;
9125 tree wfl_op2;
9126 {
9127 tree rhs = TREE_OPERAND (node, 1);
9128 tree lvalue = TREE_OPERAND (node, 0), llvalue;
9129 tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
9130 int error_found = 0;
9131 int lvalue_from_array = 0;
9132
9133 /* Can't assign to a final. */
9134 if (check_final_assignment (lvalue, wfl_op1))
9135 error_found = 1;
9136
9137 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
9138
9139 /* Lhs can be a named variable */
9140 if (JDECL_P (lvalue))
9141 {
9142 lhs_type = TREE_TYPE (lvalue);
9143 }
9144 /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME +
9145 comment on reason why */
9146 else if (TREE_CODE (wfl_op1) == ARRAY_REF)
9147 {
9148 lhs_type = TREE_TYPE (lvalue);
9149 lvalue_from_array = 1;
9150 }
9151 /* Or a field access */
9152 else if (TREE_CODE (lvalue) == COMPONENT_REF)
9153 lhs_type = TREE_TYPE (lvalue);
9154 /* Or a function return slot */
9155 else if (TREE_CODE (lvalue) == RESULT_DECL)
9156 lhs_type = TREE_TYPE (lvalue);
9157 /* Otherwise, we might want to try to write into an optimized static
9158 final, this is an of a different nature, reported further on. */
9159 else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
9160 && resolve_expression_name (wfl_op1, &llvalue))
9161 {
9162 if (check_final_assignment (llvalue, wfl_op1))
9163 {
9164 /* What we should do instead is resetting the all the flags
9165 previously set, exchange lvalue for llvalue and continue. */
9166 error_found = 1;
9167 return error_mark_node;
9168 }
9169 else
9170 lhs_type = TREE_TYPE (lvalue);
9171 }
9172 else
9173 {
9174 parse_error_context (wfl_op1, "Invalid left hand side of assignment");
9175 error_found = 1;
9176 }
9177
9178 rhs_type = TREE_TYPE (rhs);
9179 /* 5.1 Try the assignment conversion for builtin type. */
9180 new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
9181
9182 /* 5.2 If it failed, try a reference conversion */
9183 if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
9184 lhs_type = promote_type (rhs_type);
9185
9186 /* 15.25.2 If we have a compound assignment, convert RHS into the
9187 type of the LHS */
9188 else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
9189 new_rhs = convert (lhs_type, rhs);
9190
9191 /* Explicit cast required. This is an error */
9192 if (!new_rhs)
9193 {
9194 char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
9195 char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
9196 tree wfl;
9197 char operation [32]; /* Max size known */
9198
9199 /* If the assignment is part of a declaration, we use the WFL of
9200 the declared variable to point out the error and call it a
9201 declaration problem. If the assignment is a genuine =
9202 operator, we call is a operator `=' problem, otherwise we
9203 call it an assignment problem. In both of these last cases,
9204 we use the WFL of the operator to indicate the error. */
9205
9206 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
9207 {
9208 wfl = wfl_op1;
9209 strcpy (operation, "declaration");
9210 }
9211 else
9212 {
9213 wfl = wfl_operator;
9214 if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
9215 strcpy (operation, "assignment");
9216 else if (TREE_CODE (TREE_OPERAND (node, 0)) == RESULT_DECL)
9217 strcpy (operation, "`return'");
9218 else
9219 strcpy (operation, "`='");
9220 }
9221
9222 if (!valid_cast_to_p (rhs_type, lhs_type))
9223 parse_error_context
9224 (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
9225 operation, t1, t2);
9226 else
9227 parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
9228 operation, t1, t2);
9229 free (t1); free (t2);
9230 error_found = 1;
9231 }
9232
9233 /* Inline read access to java.lang.PRIMTYPE.TYPE */
9234 if (new_rhs)
9235 new_rhs = maybe_build_primttype_type_ref (new_rhs, wfl_op2);
9236
9237 if (error_found)
9238 return error_mark_node;
9239
9240 /* 10.10: Array Store Exception runtime check */
9241 if (!flag_emit_class_files
9242 && !flag_emit_xref
9243 && lvalue_from_array
9244 && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
9245 {
9246 tree check;
9247 tree base = lvalue;
9248
9249 /* We need to retrieve the right argument for _Jv_CheckArrayStore */
9250 if (TREE_CODE (lvalue) == COMPOUND_EXPR)
9251 base = TREE_OPERAND (lvalue, 0);
9252 else
9253 {
9254 if (flag_bounds_check)
9255 base = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (base, 0), 1), 0);
9256 else
9257 base = TREE_OPERAND (TREE_OPERAND (base, 0), 0);
9258 }
9259
9260 /* Build the invocation of _Jv_CheckArrayStore */
9261 new_rhs = save_expr (new_rhs);
9262 check = build (CALL_EXPR, void_type_node,
9263 build_address_of (soft_checkarraystore_node),
9264 tree_cons (NULL_TREE, base,
9265 build_tree_list (NULL_TREE, new_rhs)),
9266 NULL_TREE);
9267 TREE_SIDE_EFFECTS (check) = 1;
9268
9269 /* We have to decide on an insertion point */
9270 if (TREE_CODE (lvalue) == COMPOUND_EXPR)
9271 {
9272 tree t;
9273 if (flag_bounds_check)
9274 {
9275 t = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0);
9276 TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0) =
9277 build (COMPOUND_EXPR, void_type_node, t, check);
9278 }
9279 else
9280 TREE_OPERAND (lvalue, 1) = build (COMPOUND_EXPR, lhs_type,
9281 check, TREE_OPERAND (lvalue, 1));
9282 }
9283 else
9284 {
9285 /* Make sure the bound check will happen before the store check */
9286 if (flag_bounds_check)
9287 TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0) =
9288 build (COMPOUND_EXPR, void_type_node,
9289 TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0), check);
9290 else
9291 lvalue = build (COMPOUND_EXPR, lhs_type, check, lvalue);
9292 }
9293 }
9294
9295 TREE_OPERAND (node, 0) = lvalue;
9296 TREE_OPERAND (node, 1) = new_rhs;
9297 TREE_TYPE (node) = lhs_type;
9298 return node;
9299 }
9300
9301 /* Check that type SOURCE can be cast into type DEST. If the cast
9302 can't occur at all, return 0 otherwise 1. This function is used to
9303 produce accurate error messages on the reasons why an assignment
9304 failed. */
9305
9306 static tree
9307 try_reference_assignconv (lhs_type, rhs)
9308 tree lhs_type, rhs;
9309 {
9310 tree new_rhs = NULL_TREE;
9311 tree rhs_type = TREE_TYPE (rhs);
9312
9313 if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
9314 {
9315 /* `null' may be assigned to any reference type */
9316 if (rhs == null_pointer_node)
9317 new_rhs = null_pointer_node;
9318 /* Try the reference assignment conversion */
9319 else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
9320 new_rhs = rhs;
9321 /* This is a magic assignment that we process differently */
9322 else if (rhs == soft_exceptioninfo_call_node)
9323 new_rhs = rhs;
9324 }
9325 return new_rhs;
9326 }
9327
9328 /* Check that RHS can be converted into LHS_TYPE by the assignment
9329 conversion (5.2), for the cases of RHS being a builtin type. Return
9330 NULL_TREE if the conversion fails or if because RHS isn't of a
9331 builtin type. Return a converted RHS if the conversion is possible. */
9332
9333 static tree
9334 try_builtin_assignconv (wfl_op1, lhs_type, rhs)
9335 tree wfl_op1, lhs_type, rhs;
9336 {
9337 tree new_rhs = NULL_TREE;
9338 tree rhs_type = TREE_TYPE (rhs);
9339
9340 /* Zero accepted everywhere */
9341 if (TREE_CODE (rhs) == INTEGER_CST
9342 && TREE_INT_CST_HIGH (rhs) == 0 && TREE_INT_CST_LOW (rhs) == 0
9343 && JPRIMITIVE_TYPE_P (rhs_type))
9344 new_rhs = convert (lhs_type, rhs);
9345
9346 /* 5.1.1 Try Identity Conversion,
9347 5.1.2 Try Widening Primitive Conversion */
9348 else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
9349 new_rhs = convert (lhs_type, rhs);
9350
9351 /* Try a narrowing primitive conversion (5.1.3):
9352 - expression is a constant expression of type int AND
9353 - variable is byte, short or char AND
9354 - The value of the expression is representable in the type of the
9355 variable */
9356 else if (rhs_type == int_type_node && TREE_CONSTANT (rhs)
9357 && (lhs_type == byte_type_node || lhs_type == char_type_node
9358 || lhs_type == short_type_node))
9359 {
9360 if (int_fits_type_p (rhs, lhs_type))
9361 new_rhs = convert (lhs_type, rhs);
9362 else if (wfl_op1) /* Might be called with a NULL */
9363 parse_warning_context
9364 (wfl_op1, "Constant expression `%s' to wide for narrowing primitive conversion to `%s'",
9365 print_int_node (rhs), lang_printable_name (lhs_type, 0));
9366 /* Reported a warning that will turn into an error further
9367 down, so we don't return */
9368 }
9369
9370 return new_rhs;
9371 }
9372
9373 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
9374 conversion (5.1.1) or widening primitve conversion (5.1.2). Return
9375 0 is the conversion test fails. This implements parts the method
9376 invocation convertion (5.3). */
9377
9378 static int
9379 valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)
9380 tree lhs_type, rhs_type;
9381 {
9382 /* 5.1.1: This is the identity conversion part. */
9383 if (lhs_type == rhs_type)
9384 return 1;
9385
9386 /* Reject non primitive types */
9387 if (!JPRIMITIVE_TYPE_P (lhs_type) || !JPRIMITIVE_TYPE_P (rhs_type))
9388 return 0;
9389
9390 /* 5.1.2: widening primitive conversion. byte, even if it's smaller
9391 than a char can't be converted into a char. Short can't too, but
9392 the < test below takes care of that */
9393 if (lhs_type == char_type_node && rhs_type == byte_type_node)
9394 return 0;
9395
9396 /* Accept all promoted type here. Note, we can't use <= in the test
9397 below, because we still need to bounce out assignments of short
9398 to char and the likes */
9399 if (lhs_type == int_type_node
9400 && (rhs_type == promoted_byte_type_node
9401 || rhs_type == promoted_short_type_node
9402 || rhs_type == promoted_char_type_node
9403 || rhs_type == promoted_boolean_type_node))
9404 return 1;
9405
9406 /* From here, an integral is widened if its precision is smaller
9407 than the precision of the LHS or if the LHS is a floating point
9408 type, or the RHS is a float and the RHS a double. */
9409 if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
9410 && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
9411 || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
9412 || (rhs_type == float_type_node && lhs_type == double_type_node))
9413 return 1;
9414
9415 return 0;
9416 }
9417
9418 /* Check that something of SOURCE type can be assigned or cast to
9419 something of DEST type at runtime. Return 1 if the operation is
9420 valid, 0 otherwise. If CAST is set to 1, we're treating the case
9421 were SOURCE is cast into DEST, which borrows a lot of the
9422 assignment check. */
9423
9424 static int
9425 valid_ref_assignconv_cast_p (source, dest, cast)
9426 tree source;
9427 tree dest;
9428 int cast;
9429 {
9430 /* SOURCE or DEST might be null if not from a declared entity. */
9431 if (!source || !dest)
9432 return 0;
9433 if (JNULLP_TYPE_P (source))
9434 return 1;
9435 if (TREE_CODE (source) == POINTER_TYPE)
9436 source = TREE_TYPE (source);
9437 if (TREE_CODE (dest) == POINTER_TYPE)
9438 dest = TREE_TYPE (dest);
9439 /* Case where SOURCE is a class type */
9440 if (TYPE_CLASS_P (source))
9441 {
9442 if (TYPE_CLASS_P (dest))
9443 return source == dest || inherits_from_p (source, dest)
9444 || (cast && inherits_from_p (dest, source));
9445 if (TYPE_INTERFACE_P (dest))
9446 {
9447 /* If doing a cast and SOURCE is final, the operation is
9448 always correct a compile time (because even if SOURCE
9449 does not implement DEST, a subclass of SOURCE might). */
9450 if (cast && !CLASS_FINAL (TYPE_NAME (source)))
9451 return 1;
9452 /* Otherwise, SOURCE must implement DEST */
9453 return interface_of_p (dest, source);
9454 }
9455 /* DEST is an array, cast permited if SOURCE is of Object type */
9456 return (cast && source == object_type_node ? 1 : 0);
9457 }
9458 if (TYPE_INTERFACE_P (source))
9459 {
9460 if (TYPE_CLASS_P (dest))
9461 {
9462 /* If not casting, DEST must be the Object type */
9463 if (!cast)
9464 return dest == object_type_node;
9465 /* We're doing a cast. The cast is always valid is class
9466 DEST is not final, otherwise, DEST must implement SOURCE */
9467 else if (!CLASS_FINAL (TYPE_NAME (dest)))
9468 return 1;
9469 else
9470 return interface_of_p (source, dest);
9471 }
9472 if (TYPE_INTERFACE_P (dest))
9473 {
9474 /* If doing a cast, then if SOURCE and DEST contain method
9475 with the same signature but different return type, then
9476 this is a (compile time) error */
9477 if (cast)
9478 {
9479 tree method_source, method_dest;
9480 tree source_type;
9481 tree source_sig;
9482 tree source_name;
9483 for (method_source = TYPE_METHODS (source); method_source;
9484 method_source = TREE_CHAIN (method_source))
9485 {
9486 source_sig =
9487 build_java_argument_signature (TREE_TYPE (method_source));
9488 source_type = TREE_TYPE (TREE_TYPE (method_source));
9489 source_name = DECL_NAME (method_source);
9490 for (method_dest = TYPE_METHODS (dest);
9491 method_dest; method_dest = TREE_CHAIN (method_dest))
9492 if (source_sig ==
9493 build_java_argument_signature (TREE_TYPE (method_dest))
9494 && source_name == DECL_NAME (method_dest)
9495 && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
9496 return 0;
9497 }
9498 return 1;
9499 }
9500 else
9501 return source == dest || interface_of_p (dest, source);
9502 }
9503 else /* Array */
9504 return (cast ?
9505 (DECL_NAME (TYPE_NAME (source)) == java_lang_cloneable) : 0);
9506 }
9507 if (TYPE_ARRAY_P (source))
9508 {
9509 if (TYPE_CLASS_P (dest))
9510 return dest == object_type_node;
9511 /* Can't cast an array to an interface unless the interface is
9512 java.lang.Cloneable */
9513 if (TYPE_INTERFACE_P (dest))
9514 return (DECL_NAME (TYPE_NAME (dest)) == java_lang_cloneable ? 1 : 0);
9515 else /* Arrays */
9516 {
9517 tree source_element_type = TYPE_ARRAY_ELEMENT (source);
9518 tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
9519
9520 /* In case of severe errors, they turn out null */
9521 if (!dest_element_type || !source_element_type)
9522 return 0;
9523 if (source_element_type == dest_element_type)
9524 return 1;
9525 return valid_ref_assignconv_cast_p (source_element_type,
9526 dest_element_type, cast);
9527 }
9528 return 0;
9529 }
9530 return 0;
9531 }
9532
9533 static int
9534 valid_cast_to_p (source, dest)
9535 tree source;
9536 tree dest;
9537 {
9538 if (TREE_CODE (source) == POINTER_TYPE)
9539 source = TREE_TYPE (source);
9540 if (TREE_CODE (dest) == POINTER_TYPE)
9541 dest = TREE_TYPE (dest);
9542
9543 if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
9544 return valid_ref_assignconv_cast_p (source, dest, 1);
9545
9546 else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
9547 return 1;
9548
9549 return 0;
9550 }
9551
9552 /* Method invocation conversion test. Return 1 if type SOURCE can be
9553 converted to type DEST through the methond invocation conversion
9554 process (5.3) */
9555
9556 static tree
9557 do_unary_numeric_promotion (arg)
9558 tree arg;
9559 {
9560 tree type = TREE_TYPE (arg);
9561 if (TREE_CODE (type) == INTEGER_TYPE ? TYPE_PRECISION (type) < 32
9562 : TREE_CODE (type) == CHAR_TYPE)
9563 arg = convert (int_type_node, arg);
9564 return arg;
9565 }
9566
9567 /* Return a non zero value if SOURCE can be converted into DEST using
9568 the method invocation conversion rule (5.3). */
9569 static int
9570 valid_method_invocation_conversion_p (dest, source)
9571 tree dest, source;
9572 {
9573 return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
9574 && valid_builtin_assignconv_identity_widening_p (dest, source))
9575 || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
9576 && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
9577 && valid_ref_assignconv_cast_p (source, dest, 0)));
9578 }
9579
9580 /* Build an incomplete binop expression. */
9581
9582 static tree
9583 build_binop (op, op_location, op1, op2)
9584 enum tree_code op;
9585 int op_location;
9586 tree op1, op2;
9587 {
9588 tree binop = build (op, NULL_TREE, op1, op2);
9589 TREE_SIDE_EFFECTS (binop) = 1;
9590 /* Store the location of the operator, for better error report. The
9591 string of the operator will be rebuild based on the OP value. */
9592 EXPR_WFL_LINECOL (binop) = op_location;
9593 return binop;
9594 }
9595
9596 /* Build the string of the operator retained by NODE. If NODE is part
9597 of a compound expression, add an '=' at the end of the string. This
9598 function is called when an error needs to be reported on an
9599 operator. The string is returned as a pointer to a static character
9600 buffer. */
9601
9602 static char *
9603 operator_string (node)
9604 tree node;
9605 {
9606 #define BUILD_OPERATOR_STRING(S) \
9607 { \
9608 sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
9609 return buffer; \
9610 }
9611
9612 static char buffer [10];
9613 switch (TREE_CODE (node))
9614 {
9615 case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
9616 case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
9617 case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
9618 case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
9619 case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
9620 case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
9621 case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
9622 case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
9623 case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
9624 case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
9625 case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
9626 case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
9627 case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
9628 case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
9629 case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
9630 case GT_EXPR: BUILD_OPERATOR_STRING (">");
9631 case GE_EXPR: BUILD_OPERATOR_STRING (">=");
9632 case LT_EXPR: BUILD_OPERATOR_STRING ("<");
9633 case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
9634 case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
9635 case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
9636 case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
9637 case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
9638 case PREINCREMENT_EXPR: /* Fall through */
9639 case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
9640 case PREDECREMENT_EXPR: /* Fall through */
9641 case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
9642 default:
9643 fatal ("unregistered operator %s - operator_string",
9644 tree_code_name [TREE_CODE (node)]);
9645 }
9646 return NULL;
9647 #undef BUILD_OPERATOR_STRING
9648 }
9649
9650 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
9651
9652 static int
9653 java_decl_equiv (var_acc1, var_acc2)
9654 tree var_acc1, var_acc2;
9655 {
9656 if (JDECL_P (var_acc1))
9657 return (var_acc1 == var_acc2);
9658
9659 return (TREE_CODE (var_acc1) == COMPONENT_REF
9660 && TREE_CODE (var_acc2) == COMPONENT_REF
9661 && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
9662 == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
9663 && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
9664 }
9665
9666 /* Return a non zero value if CODE is one of the operators that can be
9667 used in conjunction with the `=' operator in a compound assignment. */
9668
9669 static int
9670 binop_compound_p (code)
9671 enum tree_code code;
9672 {
9673 int i;
9674 for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
9675 if (binop_lookup [i] == code)
9676 break;
9677
9678 return i < BINOP_COMPOUND_CANDIDATES;
9679 }
9680
9681 /* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
9682
9683 static tree
9684 java_refold (t)
9685 tree t;
9686 {
9687 tree c, b, ns, decl;
9688
9689 if (TREE_CODE (t) != MODIFY_EXPR)
9690 return t;
9691
9692 c = TREE_OPERAND (t, 1);
9693 if (! (c && TREE_CODE (c) == COMPOUND_EXPR
9694 && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
9695 && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
9696 return t;
9697
9698 /* Now the left branch of the binary operator. */
9699 b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
9700 if (! (b && TREE_CODE (b) == NOP_EXPR
9701 && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
9702 return t;
9703
9704 ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
9705 if (! (ns && TREE_CODE (ns) == NOP_EXPR
9706 && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
9707 return t;
9708
9709 decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
9710 if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
9711 /* It's got to be the an equivalent decl */
9712 && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
9713 {
9714 /* Shorten the NOP_EXPR/SAVE_EXPR path. */
9715 TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
9716 /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
9717 TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
9718 /* Change the right part of the BINOP_EXPR */
9719 TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
9720 }
9721
9722 return t;
9723 }
9724
9725 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
9726 errors but we modify NODE so that it contains the type computed
9727 according to the expression, when it's fixed. Otherwise, we write
9728 error_mark_node as the type. It allows us to further the analysis
9729 of remaining nodes and detects more errors in certain cases. */
9730
9731 static tree
9732 patch_binop (node, wfl_op1, wfl_op2)
9733 tree node;
9734 tree wfl_op1;
9735 tree wfl_op2;
9736 {
9737 tree op1 = TREE_OPERAND (node, 0);
9738 tree op2 = TREE_OPERAND (node, 1);
9739 tree op1_type = TREE_TYPE (op1);
9740 tree op2_type = TREE_TYPE (op2);
9741 tree prom_type = NULL_TREE;
9742 int code = TREE_CODE (node);
9743
9744 /* If 1, tell the routine that we have to return error_mark_node
9745 after checking for the initialization of the RHS */
9746 int error_found = 0;
9747
9748 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
9749
9750 switch (code)
9751 {
9752 /* 15.16 Multiplicative operators */
9753 case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
9754 case RDIV_EXPR: /* 15.16.2 Division Operator / */
9755 case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
9756 if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
9757 {
9758 if (!JPRIMITIVE_TYPE_P (op1_type))
9759 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
9760 if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
9761 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
9762 TREE_TYPE (node) = error_mark_node;
9763 error_found = 1;
9764 break;
9765 }
9766 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
9767 /* Change the division operator if necessary */
9768 if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
9769 TREE_SET_CODE (node, TRUNC_DIV_EXPR);
9770
9771 if (TREE_CODE (prom_type) == INTEGER_TYPE
9772 && flag_use_divide_subroutine
9773 && ! flag_emit_class_files
9774 && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
9775 return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
9776
9777 /* This one is more complicated. FLOATs are processed by a
9778 function call to soft_fmod. Duplicate the value of the
9779 COMPOUND_ASSIGN_P flag. */
9780 if (code == TRUNC_MOD_EXPR)
9781 {
9782 tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
9783 COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
9784 TREE_SIDE_EFFECTS (mod)
9785 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
9786 return mod;
9787 }
9788 break;
9789
9790 /* 15.17 Additive Operators */
9791 case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
9792
9793 /* Operation is valid if either one argument is a string
9794 constant, a String object or a StringBuffer crafted for the
9795 purpose of the a previous usage of the String concatenation
9796 operator */
9797
9798 if (TREE_CODE (op1) == STRING_CST
9799 || TREE_CODE (op2) == STRING_CST
9800 || JSTRING_TYPE_P (op1_type)
9801 || JSTRING_TYPE_P (op2_type)
9802 || IS_CRAFTED_STRING_BUFFER_P (op1)
9803 || IS_CRAFTED_STRING_BUFFER_P (op2))
9804 return build_string_concatenation (op1, op2);
9805
9806 case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
9807 Numeric Types */
9808 if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
9809 {
9810 if (!JPRIMITIVE_TYPE_P (op1_type))
9811 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
9812 if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
9813 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
9814 TREE_TYPE (node) = error_mark_node;
9815 error_found = 1;
9816 break;
9817 }
9818 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
9819 break;
9820
9821 /* 15.18 Shift Operators */
9822 case LSHIFT_EXPR:
9823 case RSHIFT_EXPR:
9824 case URSHIFT_EXPR:
9825 if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
9826 {
9827 if (!JINTEGRAL_TYPE_P (op1_type))
9828 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
9829 else
9830 {
9831 if (JPRIMITIVE_TYPE_P (op2_type))
9832 parse_error_context (wfl_operator,
9833 "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
9834 operator_string (node),
9835 lang_printable_name (op2_type, 0));
9836 else
9837 parse_error_context (wfl_operator,
9838 "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
9839 operator_string (node),
9840 lang_printable_name (op2_type, 0));
9841 }
9842 TREE_TYPE (node) = error_mark_node;
9843 error_found = 1;
9844 break;
9845 }
9846
9847 /* Unary numeric promotion (5.6.1) is performed on each operand
9848 separatly */
9849 op1 = do_unary_numeric_promotion (op1);
9850 op2 = do_unary_numeric_promotion (op2);
9851
9852 /* The type of the shift expression is the type of the promoted
9853 type of the left-hand operand */
9854 prom_type = TREE_TYPE (op1);
9855
9856 /* Shift int only up to 0x1f and long up to 0x3f. The bytecode
9857 generator should take care of removing this operation. FIXME */
9858 op2 = fold (build (BIT_AND_EXPR, prom_type, convert (prom_type, op2),
9859 (prom_type == int_type_node ? build_int_2 (0x1f, 0) :
9860 convert (prom_type, build_int_2 (0x3f, 0)))));
9861
9862 /* The >>> operator is a >> operating on unsigned quantities */
9863 if (code == URSHIFT_EXPR && ! flag_emit_class_files)
9864 {
9865 tree to_return;
9866 tree utype = unsigned_type (prom_type);
9867 op1 = convert (utype, op1);
9868 TREE_SET_CODE (node, RSHIFT_EXPR);
9869 TREE_OPERAND (node, 0) = op1;
9870 TREE_OPERAND (node, 1) = op2;
9871 TREE_TYPE (node) = utype;
9872 to_return = convert (prom_type, node);
9873 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
9874 COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
9875 TREE_SIDE_EFFECTS (to_return)
9876 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
9877 return to_return;
9878 }
9879 break;
9880
9881 /* 15.19.1 Type Comparison Operator instaceof */
9882 case INSTANCEOF_EXPR:
9883
9884 TREE_TYPE (node) = boolean_type_node;
9885
9886 if (!(op2_type = resolve_type_during_patch (op2)))
9887 return error_mark_node;
9888
9889 /* The first operand must be a reference type or the null type */
9890 if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
9891 error_found = 1; /* Error reported further below */
9892
9893 /* The second operand must be a reference type */
9894 if (!JREFERENCE_TYPE_P (op2_type))
9895 {
9896 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
9897 parse_error_context
9898 (wfl_operator, "Invalid argument `%s' for `instanceof'",
9899 lang_printable_name (op2_type, 0));
9900 error_found = 1;
9901 }
9902
9903 if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
9904 {
9905 /* If the first operand is null, the result is always false */
9906 if (op1 == null_pointer_node)
9907 return boolean_false_node;
9908 else if (flag_emit_class_files)
9909 {
9910 TREE_OPERAND (node, 1) = op2_type;
9911 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
9912 return node;
9913 }
9914 /* Otherwise we have to invoke instance of to figure it out */
9915 else
9916 {
9917 tree call =
9918 build (CALL_EXPR, boolean_type_node,
9919 build_address_of (soft_instanceof_node),
9920 tree_cons
9921 (NULL_TREE, op1,
9922 build_tree_list (NULL_TREE,
9923 build_class_ref (op2_type))),
9924 NULL_TREE);
9925 TREE_SIDE_EFFECTS (call) = TREE_SIDE_EFFECTS (op1);
9926 return call;
9927 }
9928 }
9929 /* There is no way the expression operand can be an instance of
9930 the type operand. This is a compile time error. */
9931 else
9932 {
9933 char *t1 = xstrdup (lang_printable_name (op1_type, 0));
9934 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
9935 parse_error_context
9936 (wfl_operator, "Impossible for `%s' to be instance of `%s'",
9937 t1, lang_printable_name (op2_type, 0));
9938 free (t1);
9939 error_found = 1;
9940 }
9941
9942 break;
9943
9944 /* 15.21 Bitwise and Logical Operators */
9945 case BIT_AND_EXPR:
9946 case BIT_XOR_EXPR:
9947 case BIT_IOR_EXPR:
9948 if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
9949 /* Binary numeric promotion is performed on both operand and the
9950 expression retain that type */
9951 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
9952
9953 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
9954 && TREE_CODE (op1_type) == BOOLEAN_TYPE)
9955 /* The type of the bitwise operator expression is BOOLEAN */
9956 prom_type = boolean_type_node;
9957 else
9958 {
9959 if (!JINTEGRAL_TYPE_P (op1_type))
9960 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
9961 if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
9962 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
9963 TREE_TYPE (node) = error_mark_node;
9964 error_found = 1;
9965 /* Insert a break here if adding thing before the switch's
9966 break for this case */
9967 }
9968 break;
9969
9970 /* 15.22 Conditional-And Operator */
9971 case TRUTH_ANDIF_EXPR:
9972 /* 15.23 Conditional-Or Operator */
9973 case TRUTH_ORIF_EXPR:
9974 /* Operands must be of BOOLEAN type */
9975 if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
9976 TREE_CODE (op2_type) != BOOLEAN_TYPE)
9977 {
9978 if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
9979 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
9980 if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
9981 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
9982 TREE_TYPE (node) = boolean_type_node;
9983 error_found = 1;
9984 break;
9985 }
9986 /* The type of the conditional operators is BOOLEAN */
9987 prom_type = boolean_type_node;
9988 break;
9989
9990 /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
9991 case LT_EXPR:
9992 case GT_EXPR:
9993 case LE_EXPR:
9994 case GE_EXPR:
9995 /* The type of each of the operands must be a primitive numeric
9996 type */
9997 if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
9998 {
9999 if (!JNUMERIC_TYPE_P (op1_type))
10000 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
10001 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
10002 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
10003 TREE_TYPE (node) = boolean_type_node;
10004 error_found = 1;
10005 break;
10006 }
10007 /* Binary numeric promotion is performed on the operands */
10008 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
10009 /* The type of the relation expression is always BOOLEAN */
10010 prom_type = boolean_type_node;
10011 break;
10012
10013 /* 15.20 Equality Operator */
10014 case EQ_EXPR:
10015 case NE_EXPR:
10016 /* 15.20.1 Numerical Equality Operators == and != */
10017 /* Binary numeric promotion is performed on the operands */
10018 if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
10019 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
10020
10021 /* 15.20.2 Boolean Equality Operators == and != */
10022 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
10023 TREE_CODE (op2_type) == BOOLEAN_TYPE)
10024 ; /* Nothing to do here */
10025
10026 /* 15.20.3 Reference Equality Operators == and != */
10027 /* Types have to be either references or the null type. If
10028 they're references, it must be possible to convert either
10029 type to the other by casting conversion. */
10030 else if (op1 == null_pointer_node || op2 == null_pointer_node
10031 || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
10032 && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
10033 || valid_ref_assignconv_cast_p (op2_type,
10034 op1_type, 1))))
10035 ; /* Nothing to do here */
10036
10037 /* Else we have an error figure what can't be converted into
10038 what and report the error */
10039 else
10040 {
10041 char *t1;
10042 t1 = xstrdup (lang_printable_name (op1_type, 0));
10043 parse_error_context
10044 (wfl_operator,
10045 "Incompatible type for `%s'. Can't convert `%s' to `%s'",
10046 operator_string (node), t1,
10047 lang_printable_name (op2_type, 0));
10048 free (t1);
10049 TREE_TYPE (node) = boolean_type_node;
10050 error_found = 1;
10051 break;
10052 }
10053 prom_type = boolean_type_node;
10054 break;
10055 }
10056
10057 if (error_found)
10058 return error_mark_node;
10059
10060 TREE_OPERAND (node, 0) = op1;
10061 TREE_OPERAND (node, 1) = op2;
10062 TREE_TYPE (node) = prom_type;
10063 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
10064
10065 if (flag_emit_xref)
10066 return node;
10067
10068 /* fold does not respect side-effect order as required for Java but not C.
10069 * Also, it sometimes create SAVE_EXPRs which are bad when emitting
10070 * bytecode.
10071 */
10072 if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
10073 : ! TREE_SIDE_EFFECTS (node))
10074 node = fold (node);
10075 return node;
10076 }
10077
10078 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
10079 zero value, the value of CSTE comes after the valude of STRING */
10080
10081 static tree
10082 do_merge_string_cste (cste, string, string_len, after)
10083 tree cste;
10084 const char *string;
10085 int string_len, after;
10086 {
10087 int len = TREE_STRING_LENGTH (cste) + string_len;
10088 const char *old = TREE_STRING_POINTER (cste);
10089 TREE_STRING_LENGTH (cste) = len;
10090 TREE_STRING_POINTER (cste) = obstack_alloc (expression_obstack, len+1);
10091 if (after)
10092 {
10093 strcpy (TREE_STRING_POINTER (cste), string);
10094 strcat (TREE_STRING_POINTER (cste), old);
10095 }
10096 else
10097 {
10098 strcpy (TREE_STRING_POINTER (cste), old);
10099 strcat (TREE_STRING_POINTER (cste), string);
10100 }
10101 return cste;
10102 }
10103
10104 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
10105 new STRING_CST on success, NULL_TREE on failure */
10106
10107 static tree
10108 merge_string_cste (op1, op2, after)
10109 tree op1, op2;
10110 int after;
10111 {
10112 /* Handle two string constants right away */
10113 if (TREE_CODE (op2) == STRING_CST)
10114 return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
10115 TREE_STRING_LENGTH (op2), after);
10116
10117 /* Reasonable integer constant can be treated right away */
10118 if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
10119 {
10120 static const char *boolean_true = "true";
10121 static const char *boolean_false = "false";
10122 static const char *null_pointer = "null";
10123 char ch[3];
10124 const char *string;
10125
10126 if (op2 == boolean_true_node)
10127 string = boolean_true;
10128 else if (op2 == boolean_false_node)
10129 string = boolean_false;
10130 else if (op2 == null_pointer_node)
10131 string = null_pointer;
10132 else if (TREE_TYPE (op2) == char_type_node)
10133 {
10134 ch[0] = (char )TREE_INT_CST_LOW (op2);
10135 ch[1] = '\0';
10136 string = ch;
10137 }
10138 else
10139 string = print_int_node (op2);
10140
10141 return do_merge_string_cste (op1, string, strlen (string), after);
10142 }
10143 return NULL_TREE;
10144 }
10145
10146 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
10147 has to be a STRING_CST and the other part must be a STRING_CST or a
10148 INTEGRAL constant. Return a new STRING_CST if the operation
10149 succeed, NULL_TREE otherwise.
10150
10151 If the case we want to optimize for space, we might want to return
10152 NULL_TREE for each invocation of this routine. FIXME */
10153
10154 static tree
10155 string_constant_concatenation (op1, op2)
10156 tree op1, op2;
10157 {
10158 if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
10159 {
10160 tree string, rest;
10161 int invert;
10162
10163 string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
10164 rest = (string == op1 ? op2 : op1);
10165 invert = (string == op1 ? 0 : 1 );
10166
10167 /* Walk REST, only if it looks reasonable */
10168 if (TREE_CODE (rest) != STRING_CST
10169 && !IS_CRAFTED_STRING_BUFFER_P (rest)
10170 && !JSTRING_TYPE_P (TREE_TYPE (rest))
10171 && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
10172 {
10173 rest = java_complete_tree (rest);
10174 if (rest == error_mark_node)
10175 return error_mark_node;
10176 rest = fold (rest);
10177 }
10178 return merge_string_cste (string, rest, invert);
10179 }
10180 return NULL_TREE;
10181 }
10182
10183 /* Implement the `+' operator. Does static optimization if possible,
10184 otherwise create (if necessary) and append elements to a
10185 StringBuffer. The StringBuffer will be carried around until it is
10186 used for a function call or an assignment. Then toString() will be
10187 called on it to turn it into a String object. */
10188
10189 static tree
10190 build_string_concatenation (op1, op2)
10191 tree op1, op2;
10192 {
10193 tree result;
10194 int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
10195
10196 if (flag_emit_xref)
10197 return build (PLUS_EXPR, string_type_node, op1, op2);
10198
10199 /* Try to do some static optimization */
10200 if ((result = string_constant_concatenation (op1, op2)))
10201 return result;
10202
10203 /* Discard empty strings on either side of the expression */
10204 if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
10205 {
10206 op1 = op2;
10207 op2 = NULL_TREE;
10208 }
10209 else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
10210 op2 = NULL_TREE;
10211
10212 /* If operands are string constant, turn then into object references */
10213 if (TREE_CODE (op1) == STRING_CST)
10214 op1 = patch_string_cst (op1);
10215 if (op2 && TREE_CODE (op2) == STRING_CST)
10216 op2 = patch_string_cst (op2);
10217
10218 /* If either one of the constant is null and the other non null
10219 operand is a String object, return it. */
10220 if (JSTRING_TYPE_P (TREE_TYPE (op1)) && !op2)
10221 return op1;
10222
10223 /* If OP1 isn't already a StringBuffer, create and
10224 initialize a new one */
10225 if (!IS_CRAFTED_STRING_BUFFER_P (op1))
10226 {
10227 /* Two solutions here:
10228 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
10229 2) OP1 is something else, we call new StringBuffer().append(OP1). */
10230 if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
10231 op1 = BUILD_STRING_BUFFER (op1);
10232 else
10233 {
10234 tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
10235 op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
10236 }
10237 }
10238
10239 if (op2)
10240 {
10241 /* OP1 is no longer the last node holding a crafted StringBuffer */
10242 IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
10243 /* Create a node for `{new...,xxx}.append (op2)' */
10244 if (op2)
10245 op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
10246 }
10247
10248 /* Mark the last node holding a crafted StringBuffer */
10249 IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
10250
10251 TREE_SIDE_EFFECTS (op1) = side_effects;
10252 return op1;
10253 }
10254
10255 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
10256 StringBuffer. If no string were found to be patched, return
10257 NULL. */
10258
10259 static tree
10260 patch_string (node)
10261 tree node;
10262 {
10263 if (node == error_mark_node)
10264 return error_mark_node;
10265 if (TREE_CODE (node) == STRING_CST)
10266 return patch_string_cst (node);
10267 else if (IS_CRAFTED_STRING_BUFFER_P (node))
10268 {
10269 int saved = ctxp->explicit_constructor_p;
10270 tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
10271 tree ret;
10272 /* Temporary disable forbid the use of `this'. */
10273 ctxp->explicit_constructor_p = 0;
10274 ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
10275 /* Restore it at its previous value */
10276 ctxp->explicit_constructor_p = saved;
10277 return ret;
10278 }
10279 return NULL_TREE;
10280 }
10281
10282 /* Build the internal representation of a string constant. */
10283
10284 static tree
10285 patch_string_cst (node)
10286 tree node;
10287 {
10288 int location;
10289 if (! flag_emit_class_files)
10290 {
10291 push_obstacks (&permanent_obstack, &permanent_obstack);
10292 node = get_identifier (TREE_STRING_POINTER (node));
10293 location = alloc_name_constant (CONSTANT_String, node);
10294 node = build_ref_from_constant_pool (location);
10295 pop_obstacks ();
10296 }
10297 TREE_TYPE (node) = string_ptr_type_node;
10298 TREE_CONSTANT (node) = 1;
10299 return node;
10300 }
10301
10302 /* Build an incomplete unary operator expression. */
10303
10304 static tree
10305 build_unaryop (op_token, op_location, op1)
10306 int op_token, op_location;
10307 tree op1;
10308 {
10309 enum tree_code op;
10310 tree unaryop;
10311 switch (op_token)
10312 {
10313 case PLUS_TK: op = UNARY_PLUS_EXPR; break;
10314 case MINUS_TK: op = NEGATE_EXPR; break;
10315 case NEG_TK: op = TRUTH_NOT_EXPR; break;
10316 case NOT_TK: op = BIT_NOT_EXPR; break;
10317 default: fatal ("Unknown token `%d' for unary operator - build_unaryop",
10318 op_token);
10319 }
10320
10321 unaryop = build1 (op, NULL_TREE, op1);
10322 TREE_SIDE_EFFECTS (unaryop) = 1;
10323 /* Store the location of the operator, for better error report. The
10324 string of the operator will be rebuild based on the OP value. */
10325 EXPR_WFL_LINECOL (unaryop) = op_location;
10326 return unaryop;
10327 }
10328
10329 /* Special case for the ++/-- operators, since they require an extra
10330 argument to build, which is set to NULL and patched
10331 later. IS_POST_P is 1 if the operator, 0 otherwise. */
10332
10333 static tree
10334 build_incdec (op_token, op_location, op1, is_post_p)
10335 int op_token, op_location;
10336 tree op1;
10337 int is_post_p;
10338 {
10339 static enum tree_code lookup [2][2] =
10340 {
10341 { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
10342 { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
10343 };
10344 tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
10345 NULL_TREE, op1, NULL_TREE);
10346 TREE_SIDE_EFFECTS (node) = 1;
10347 /* Store the location of the operator, for better error report. The
10348 string of the operator will be rebuild based on the OP value. */
10349 EXPR_WFL_LINECOL (node) = op_location;
10350 return node;
10351 }
10352
10353 /* Build an incomplete cast operator, based on the use of the
10354 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
10355 set. java_complete_tree is trained to walk a CONVERT_EXPR even
10356 though its type is already set. */
10357
10358 static tree
10359 build_cast (location, type, exp)
10360 int location;
10361 tree type, exp;
10362 {
10363 tree node = build1 (CONVERT_EXPR, type, exp);
10364 EXPR_WFL_LINECOL (node) = location;
10365 return node;
10366 }
10367
10368 /* 15.14 Unary operators. We return error_mark_node in case of error,
10369 but preserve the type of NODE if the type is fixed. */
10370
10371 static tree
10372 patch_unaryop (node, wfl_op)
10373 tree node;
10374 tree wfl_op;
10375 {
10376 tree op = TREE_OPERAND (node, 0);
10377 tree op_type = TREE_TYPE (op);
10378 tree prom_type = NULL_TREE, value, decl;
10379 int code = TREE_CODE (node);
10380 int error_found = 0;
10381
10382 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10383
10384 switch (code)
10385 {
10386 /* 15.13.2 Postfix Increment Operator ++ */
10387 case POSTINCREMENT_EXPR:
10388 /* 15.13.3 Postfix Increment Operator -- */
10389 case POSTDECREMENT_EXPR:
10390 /* 15.14.1 Prefix Increment Operator ++ */
10391 case PREINCREMENT_EXPR:
10392 /* 15.14.2 Prefix Decrement Operator -- */
10393 case PREDECREMENT_EXPR:
10394 op = decl = strip_out_static_field_access_decl (op);
10395 /* We really should have a JAVA_ARRAY_EXPR to avoid this */
10396 if (!JDECL_P (decl)
10397 && TREE_CODE (decl) != COMPONENT_REF
10398 && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
10399 && TREE_CODE (decl) != INDIRECT_REF
10400 && !(TREE_CODE (decl) == COMPOUND_EXPR
10401 && TREE_OPERAND (decl, 1)
10402 && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
10403 {
10404 tree lvalue;
10405 /* Before screaming, check that we're not in fact trying to
10406 increment a optimized static final access, in which case
10407 we issue an different error message. */
10408 if (!(TREE_CODE (wfl_op) == EXPR_WITH_FILE_LOCATION
10409 && resolve_expression_name (wfl_op, &lvalue)
10410 && check_final_assignment (lvalue, wfl_op)))
10411 parse_error_context (wfl_operator, "Invalid argument to `%s'",
10412 operator_string (node));
10413 TREE_TYPE (node) = error_mark_node;
10414 error_found = 1;
10415 }
10416 else if (check_final_assignment (op, wfl_op))
10417 error_found = 1;
10418
10419 /* From now on, we know that op if a variable and that it has a
10420 valid wfl. We use wfl_op to locate errors related to the
10421 ++/-- operand. */
10422 else if (!JNUMERIC_TYPE_P (op_type))
10423 {
10424 parse_error_context
10425 (wfl_op, "Invalid argument type `%s' to `%s'",
10426 lang_printable_name (op_type, 0), operator_string (node));
10427 TREE_TYPE (node) = error_mark_node;
10428 error_found = 1;
10429 }
10430 else
10431 {
10432 /* Before the addition, binary numeric promotion is performed on
10433 both operands, if really necessary */
10434 if (JINTEGRAL_TYPE_P (op_type))
10435 {
10436 value = build_int_2 (1, 0);
10437 TREE_TYPE (value) = TREE_TYPE (node) = op_type;
10438 }
10439 else
10440 {
10441 value = build_int_2 (1, 0);
10442 TREE_TYPE (node) =
10443 binary_numeric_promotion (op_type,
10444 TREE_TYPE (value), &op, &value);
10445 }
10446 /* And write back into the node. */
10447 TREE_OPERAND (node, 0) = op;
10448 TREE_OPERAND (node, 1) = value;
10449 /* Convert the overall back into its original type, if
10450 necessary, and return */
10451 if (JINTEGRAL_TYPE_P (op_type))
10452 return fold (node);
10453 else
10454 return fold (convert (op_type, node));
10455 }
10456 break;
10457
10458 /* 15.14.3 Unary Plus Operator + */
10459 case UNARY_PLUS_EXPR:
10460 /* 15.14.4 Unary Minus Operator - */
10461 case NEGATE_EXPR:
10462 if (!JNUMERIC_TYPE_P (op_type))
10463 {
10464 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
10465 TREE_TYPE (node) = error_mark_node;
10466 error_found = 1;
10467 }
10468 /* Unary numeric promotion is performed on operand */
10469 else
10470 {
10471 op = do_unary_numeric_promotion (op);
10472 prom_type = TREE_TYPE (op);
10473 if (code == UNARY_PLUS_EXPR)
10474 return fold (op);
10475 }
10476 break;
10477
10478 /* 15.14.5 Bitwise Complement Operator ~ */
10479 case BIT_NOT_EXPR:
10480 if (!JINTEGRAL_TYPE_P (op_type))
10481 {
10482 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
10483 TREE_TYPE (node) = error_mark_node;
10484 error_found = 1;
10485 }
10486 else
10487 {
10488 op = do_unary_numeric_promotion (op);
10489 prom_type = TREE_TYPE (op);
10490 }
10491 break;
10492
10493 /* 15.14.6 Logical Complement Operator ! */
10494 case TRUTH_NOT_EXPR:
10495 if (TREE_CODE (op_type) != BOOLEAN_TYPE)
10496 {
10497 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
10498 /* But the type is known. We will report an error if further
10499 attempt of a assignment is made with this rhs */
10500 TREE_TYPE (node) = boolean_type_node;
10501 error_found = 1;
10502 }
10503 else
10504 prom_type = boolean_type_node;
10505 break;
10506
10507 /* 15.15 Cast Expression */
10508 case CONVERT_EXPR:
10509 value = patch_cast (node, wfl_operator);
10510 if (value == error_mark_node)
10511 {
10512 /* If this cast is part of an assignment, we tell the code
10513 that deals with it not to complain about a mismatch,
10514 because things have been cast, anyways */
10515 TREE_TYPE (node) = error_mark_node;
10516 error_found = 1;
10517 }
10518 else
10519 {
10520 value = fold (value);
10521 TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
10522 return value;
10523 }
10524 break;
10525 }
10526
10527 if (error_found)
10528 return error_mark_node;
10529
10530 /* There are cases where node has been replaced by something else
10531 and we don't end up returning here: UNARY_PLUS_EXPR,
10532 CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
10533 TREE_OPERAND (node, 0) = fold (op);
10534 TREE_TYPE (node) = prom_type;
10535 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
10536 return fold (node);
10537 }
10538
10539 /* Generic type resolution that sometimes takes place during node
10540 patching. Returned the resolved type or generate an error
10541 message. Return the resolved type or NULL_TREE. */
10542
10543 static tree
10544 resolve_type_during_patch (type)
10545 tree type;
10546 {
10547 if (unresolved_type_p (type, NULL))
10548 {
10549 tree type_decl = resolve_no_layout (EXPR_WFL_NODE (type), NULL_TREE);
10550 if (!type_decl)
10551 {
10552 parse_error_context (type,
10553 "Class `%s' not found in type declaration",
10554 IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
10555 return NULL_TREE;
10556 }
10557 else
10558 {
10559 CLASS_LOADED_P (TREE_TYPE (type_decl)) = 1;
10560 return TREE_TYPE (type_decl);
10561 }
10562 }
10563 return type;
10564 }
10565 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
10566 found. Otherwise NODE or something meant to replace it is returned. */
10567
10568 static tree
10569 patch_cast (node, wfl_operator)
10570 tree node;
10571 tree wfl_operator;
10572 {
10573 tree op = TREE_OPERAND (node, 0);
10574 tree op_type = TREE_TYPE (op);
10575 tree cast_type = TREE_TYPE (node);
10576 char *t1;
10577
10578 /* First resolve OP_TYPE if unresolved */
10579 if (!(cast_type = resolve_type_during_patch (cast_type)))
10580 return error_mark_node;
10581
10582 /* Check on cast that are proven correct at compile time */
10583 if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
10584 {
10585 /* Same type */
10586 if (cast_type == op_type)
10587 return node;
10588
10589 /* float and double type are converted to the original type main
10590 variant and then to the target type. */
10591 if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE)
10592 op = convert (integer_type_node, op);
10593
10594 /* Try widening/narowwing convertion. Potentially, things need
10595 to be worked out in gcc so we implement the extreme cases
10596 correctly. fold_convert() needs to be fixed. */
10597 return convert (cast_type, op);
10598 }
10599
10600 /* It's also valid to cast a boolean into a boolean */
10601 if (op_type == boolean_type_node && cast_type == boolean_type_node)
10602 return node;
10603
10604 /* null can be casted to references */
10605 if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
10606 return build_null_of_type (cast_type);
10607
10608 /* The remaining legal casts involve conversion between reference
10609 types. Check for their compile time correctness. */
10610 if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
10611 && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
10612 {
10613 TREE_TYPE (node) = promote_type (cast_type);
10614 /* Now, the case can be determined correct at compile time if
10615 OP_TYPE can be converted into CAST_TYPE by assignment
10616 conversion (5.2) */
10617
10618 if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
10619 {
10620 TREE_SET_CODE (node, NOP_EXPR);
10621 return node;
10622 }
10623
10624 if (flag_emit_class_files)
10625 {
10626 TREE_SET_CODE (node, CONVERT_EXPR);
10627 return node;
10628 }
10629
10630 /* The cast requires a run-time check */
10631 return build (CALL_EXPR, promote_type (cast_type),
10632 build_address_of (soft_checkcast_node),
10633 tree_cons (NULL_TREE, build_class_ref (cast_type),
10634 build_tree_list (NULL_TREE, op)),
10635 NULL_TREE);
10636 }
10637
10638 /* Any other casts are proven incorrect at compile time */
10639 t1 = xstrdup (lang_printable_name (op_type, 0));
10640 parse_error_context (wfl_operator, "Invalid cast from `%s' to `%s'",
10641 t1, lang_printable_name (cast_type, 0));
10642 free (t1);
10643 return error_mark_node;
10644 }
10645
10646 /* Build a null constant and give it the type TYPE. */
10647
10648 static tree
10649 build_null_of_type (type)
10650 tree type;
10651 {
10652 tree node = build_int_2 (0, 0);
10653 TREE_TYPE (node) = promote_type (type);
10654 return node;
10655 }
10656
10657 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
10658 a list of indices. */
10659 static tree
10660 build_array_ref (location, array, index)
10661 int location;
10662 tree array, index;
10663 {
10664 tree node = build (ARRAY_REF, NULL_TREE, array, index);
10665 EXPR_WFL_LINECOL (node) = location;
10666 return node;
10667 }
10668
10669 /* 15.12 Array Access Expression */
10670
10671 static tree
10672 patch_array_ref (node)
10673 tree node;
10674 {
10675 tree array = TREE_OPERAND (node, 0);
10676 tree array_type = TREE_TYPE (array);
10677 tree index = TREE_OPERAND (node, 1);
10678 tree index_type = TREE_TYPE (index);
10679 int error_found = 0;
10680
10681 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10682
10683 if (TREE_CODE (array_type) == POINTER_TYPE)
10684 array_type = TREE_TYPE (array_type);
10685
10686 /* The array reference must be an array */
10687 if (!TYPE_ARRAY_P (array_type))
10688 {
10689 parse_error_context
10690 (wfl_operator,
10691 "`[]' can only be applied to arrays. It can't be applied to `%s'",
10692 lang_printable_name (array_type, 0));
10693 TREE_TYPE (node) = error_mark_node;
10694 error_found = 1;
10695 }
10696
10697 /* The array index underdoes unary numeric promotion. The promoted
10698 type must be int */
10699 index = do_unary_numeric_promotion (index);
10700 if (TREE_TYPE (index) != int_type_node)
10701 {
10702 if (valid_cast_to_p (index_type, int_type_node))
10703 parse_error_context (wfl_operator,
10704 "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
10705 lang_printable_name (index_type, 0));
10706 else
10707 parse_error_context (wfl_operator,
10708 "Incompatible type for `[]'. Can't convert `%s' to `int'",
10709 lang_printable_name (index_type, 0));
10710 TREE_TYPE (node) = error_mark_node;
10711 error_found = 1;
10712 }
10713
10714 if (error_found)
10715 return error_mark_node;
10716
10717 array_type = TYPE_ARRAY_ELEMENT (array_type);
10718
10719 if (flag_emit_class_files || flag_emit_xref)
10720 {
10721 TREE_OPERAND (node, 0) = array;
10722 TREE_OPERAND (node, 1) = index;
10723 }
10724 else
10725 {
10726 /* The save_expr is for correct evaluation order. It would be cleaner
10727 to use force_evaluation_order (see comment there), but that is
10728 difficult when we also have to deal with bounds checking. */
10729 if (TREE_SIDE_EFFECTS (index))
10730 array = save_expr (array);
10731 node = build_java_arrayaccess (array, array_type, index);
10732 if (TREE_SIDE_EFFECTS (index))
10733 node = build (COMPOUND_EXPR, array_type, array, node);
10734 }
10735 TREE_TYPE (node) = array_type;
10736 return node;
10737 }
10738
10739 /* 15.9 Array Creation Expressions */
10740
10741 static tree
10742 build_newarray_node (type, dims, extra_dims)
10743 tree type;
10744 tree dims;
10745 int extra_dims;
10746 {
10747 tree node =
10748 build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
10749 build_int_2 (extra_dims, 0));
10750 return node;
10751 }
10752
10753 static tree
10754 patch_newarray (node)
10755 tree node;
10756 {
10757 tree type = TREE_OPERAND (node, 0);
10758 tree dims = TREE_OPERAND (node, 1);
10759 tree cdim, array_type;
10760 int error_found = 0;
10761 int ndims = 0;
10762 int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
10763
10764 /* Dimension types are verified. It's better for the types to be
10765 verified in order. */
10766 for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
10767 {
10768 int dim_error = 0;
10769 tree dim = TREE_VALUE (cdim);
10770
10771 /* Dim might have been saved during its evaluation */
10772 dim = (TREE_CODE (dim) == SAVE_EXPR ? dim = TREE_OPERAND (dim, 0) : dim);
10773
10774 /* The type of each specified dimension must be an integral type. */
10775 if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
10776 dim_error = 1;
10777
10778 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
10779 promoted type must be int. */
10780 else
10781 {
10782 dim = do_unary_numeric_promotion (dim);
10783 if (TREE_TYPE (dim) != int_type_node)
10784 dim_error = 1;
10785 }
10786
10787 /* Report errors on types here */
10788 if (dim_error)
10789 {
10790 parse_error_context
10791 (TREE_PURPOSE (cdim),
10792 "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
10793 (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
10794 "Explicit cast needed to" : "Can't"),
10795 lang_printable_name (TREE_TYPE (dim), 0));
10796 error_found = 1;
10797 }
10798
10799 TREE_PURPOSE (cdim) = NULL_TREE;
10800 }
10801
10802 /* Resolve array base type if unresolved */
10803 if (!(type = resolve_type_during_patch (type)))
10804 error_found = 1;
10805
10806 if (error_found)
10807 {
10808 /* We don't want further evaluation of this bogus array creation
10809 operation */
10810 TREE_TYPE (node) = error_mark_node;
10811 return error_mark_node;
10812 }
10813
10814 /* Set array_type to the actual (promoted) array type of the result. */
10815 if (TREE_CODE (type) == RECORD_TYPE)
10816 type = build_pointer_type (type);
10817 while (--xdims >= 0)
10818 {
10819 type = promote_type (build_java_array_type (type, -1));
10820 }
10821 dims = nreverse (dims);
10822 array_type = type;
10823 for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
10824 {
10825 type = array_type;
10826 array_type = build_java_array_type (type,
10827 TREE_CODE (cdim) == INTEGER_CST ?
10828 TREE_INT_CST_LOW (cdim) : -1);
10829 array_type = promote_type (array_type);
10830 }
10831 dims = nreverse (dims);
10832
10833 /* The node is transformed into a function call. Things are done
10834 differently according to the number of dimensions. If the number
10835 of dimension is equal to 1, then the nature of the base type
10836 (primitive or not) matters. */
10837 if (ndims == 1)
10838 return build_new_array (type, TREE_VALUE (dims));
10839
10840 /* Can't reuse what's already written in expr.c because it uses the
10841 JVM stack representation. Provide a build_multianewarray. FIXME */
10842 return build (CALL_EXPR, array_type,
10843 build_address_of (soft_multianewarray_node),
10844 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
10845 tree_cons (NULL_TREE,
10846 build_int_2 (ndims, 0), dims )),
10847 NULL_TREE);
10848 }
10849
10850 /* 10.6 Array initializer. */
10851
10852 /* Build a wfl for array element that don't have one, so we can
10853 pin-point errors. */
10854
10855 static tree
10856 maybe_build_array_element_wfl (node)
10857 tree node;
10858 {
10859 if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
10860 return build_expr_wfl (NULL_TREE, ctxp->filename,
10861 ctxp->elc.line, ctxp->elc.prev_col);
10862 else
10863 return NULL_TREE;
10864 }
10865
10866 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
10867 identification of initialized arrays easier to detect during walk
10868 and expansion. */
10869
10870 static tree
10871 build_new_array_init (location, values)
10872 int location;
10873 tree values;
10874 {
10875 tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
10876 tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
10877 EXPR_WFL_LINECOL (to_return) = location;
10878 return to_return;
10879 }
10880
10881 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
10882 occurred. Otherwise return NODE after having set its type
10883 appropriately. */
10884
10885 static tree
10886 patch_new_array_init (type, node)
10887 tree type, node;
10888 {
10889 int error_seen = 0;
10890 tree current, element_type;
10891 HOST_WIDE_INT length;
10892 int all_constant = 1;
10893 tree init = TREE_OPERAND (node, 0);
10894
10895 if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
10896 {
10897 parse_error_context (node,
10898 "Invalid array initializer for non-array type `%s'",
10899 lang_printable_name (type, 1));
10900 return error_mark_node;
10901 }
10902 type = TREE_TYPE (type);
10903 element_type = TYPE_ARRAY_ELEMENT (type);
10904
10905 CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
10906
10907 for (length = 0, current = CONSTRUCTOR_ELTS (init);
10908 current; length++, current = TREE_CHAIN (current))
10909 {
10910 tree elt = TREE_VALUE (current);
10911 if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
10912 {
10913 error_seen |= array_constructor_check_entry (element_type, current);
10914 elt = TREE_VALUE (current);
10915 /* When compiling to native code, STRING_CST is converted to
10916 INDIRECT_REF, but still with a TREE_CONSTANT flag. */
10917 if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
10918 all_constant = 0;
10919 }
10920 else
10921 {
10922 TREE_VALUE (current) = patch_new_array_init (element_type, elt);
10923 TREE_PURPOSE (current) = NULL_TREE;
10924 all_constant = 0;
10925 }
10926 if (elt && TREE_VALUE (elt) == error_mark_node)
10927 error_seen = 1;
10928 }
10929
10930 if (error_seen)
10931 return error_mark_node;
10932
10933 /* Create a new type. We can't reuse the one we have here by
10934 patching its dimension because it originally is of dimension -1
10935 hence reused by gcc. This would prevent triangular arrays. */
10936 type = build_java_array_type (element_type, length);
10937 TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
10938 TREE_TYPE (node) = promote_type (type);
10939 TREE_CONSTANT (init) = all_constant;
10940 TREE_CONSTANT (node) = all_constant;
10941 return node;
10942 }
10943
10944 /* Verify that one entry of the initializer element list can be
10945 assigned to the array base type. Report 1 if an error occurred, 0
10946 otherwise. */
10947
10948 static int
10949 array_constructor_check_entry (type, entry)
10950 tree type, entry;
10951 {
10952 char *array_type_string = NULL; /* For error reports */
10953 tree value, type_value, new_value, wfl_value, patched;
10954 int error_seen = 0;
10955
10956 new_value = NULL_TREE;
10957 wfl_value = TREE_VALUE (entry);
10958
10959 push_obstacks (&permanent_obstack, &permanent_obstack);
10960 value = java_complete_tree (TREE_VALUE (entry));
10961 /* patch_string return error_mark_node if arg is error_mark_node */
10962 if ((patched = patch_string (value)))
10963 value = patched;
10964 if (value == error_mark_node)
10965 return 1;
10966
10967 type_value = TREE_TYPE (value);
10968
10969 /* At anytime, try_builtin_assignconv can report a warning on
10970 constant overflow during narrowing. */
10971 SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
10972 new_value = try_builtin_assignconv (wfl_operator, type, value);
10973 if (!new_value && (new_value = try_reference_assignconv (type, value)))
10974 type_value = promote_type (type);
10975
10976 pop_obstacks ();
10977 /* Check and report errors */
10978 if (!new_value)
10979 {
10980 const char *msg = (!valid_cast_to_p (type_value, type) ?
10981 "Can't" : "Explicit cast needed to");
10982 if (!array_type_string)
10983 array_type_string = xstrdup (lang_printable_name (type, 1));
10984 parse_error_context
10985 (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
10986 msg, lang_printable_name (type_value, 1), array_type_string);
10987 error_seen = 1;
10988 }
10989
10990 if (new_value)
10991 {
10992 new_value = maybe_build_primttype_type_ref (new_value, wfl_operator);
10993 TREE_VALUE (entry) = new_value;
10994 }
10995
10996 if (array_type_string)
10997 free (array_type_string);
10998
10999 TREE_PURPOSE (entry) = NULL_TREE;
11000 return error_seen;
11001 }
11002
11003 static tree
11004 build_this (location)
11005 int location;
11006 {
11007 tree node = build_wfl_node (this_identifier_node);
11008 TREE_SET_CODE (node, THIS_EXPR);
11009 EXPR_WFL_LINECOL (node) = location;
11010 return node;
11011 }
11012
11013 /* 14.15 The return statement. It builds a modify expression that
11014 assigns the returned value to the RESULT_DECL that hold the value
11015 to be returned. */
11016
11017 static tree
11018 build_return (location, op)
11019 int location;
11020 tree op;
11021 {
11022 tree node = build1 (RETURN_EXPR, NULL_TREE, op);
11023 EXPR_WFL_LINECOL (node) = location;
11024 node = build_debugable_stmt (location, node);
11025 return node;
11026 }
11027
11028 static tree
11029 patch_return (node)
11030 tree node;
11031 {
11032 tree return_exp = TREE_OPERAND (node, 0);
11033 tree meth = current_function_decl;
11034 tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
11035 int error_found = 0;
11036
11037 TREE_TYPE (node) = error_mark_node;
11038 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11039
11040 /* It's invalid to have a return value within a function that is
11041 declared with the keyword void or that is a constructor */
11042 if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
11043 error_found = 1;
11044
11045 /* It's invalid to use a return statement in a static block */
11046 if (IS_CLINIT (current_function_decl))
11047 error_found = 1;
11048
11049 /* It's invalid to have a no return value within a function that
11050 isn't declared with the keyword `void' */
11051 if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
11052 error_found = 2;
11053
11054 if (error_found)
11055 {
11056 if (IS_CLINIT (current_function_decl))
11057 parse_error_context (wfl_operator,
11058 "`return' inside static initializer.");
11059
11060 else if (!DECL_CONSTRUCTOR_P (meth))
11061 {
11062 char *t = xstrdup (lang_printable_name (mtype, 0));
11063 parse_error_context (wfl_operator,
11064 "`return' with%s value from `%s %s'",
11065 (error_found == 1 ? "" : "out"),
11066 t, lang_printable_name (meth, 0));
11067 free (t);
11068 }
11069 else
11070 parse_error_context (wfl_operator,
11071 "`return' with value from constructor `%s'",
11072 lang_printable_name (meth, 0));
11073 return error_mark_node;
11074 }
11075
11076 /* If we have a return_exp, build a modify expression and expand
11077 it. Note: at that point, the assignment is declared valid, but we
11078 may want to carry some more hacks */
11079 if (return_exp)
11080 {
11081 tree exp = java_complete_tree (return_exp);
11082 tree modify, patched;
11083
11084 /* If the function returned value and EXP are booleans, EXP has
11085 to be converted into the type of DECL_RESULT, which is integer
11086 (see complete_start_java_method) */
11087 if (TREE_TYPE (exp) == boolean_type_node &&
11088 TREE_TYPE (TREE_TYPE (meth)) == boolean_type_node)
11089 exp = convert_to_integer (TREE_TYPE (DECL_RESULT (meth)), exp);
11090
11091 /* `null' can be assigned to a function returning a reference */
11092 if (JREFERENCE_TYPE_P (TREE_TYPE (TREE_TYPE (meth))) &&
11093 exp == null_pointer_node)
11094 exp = build_null_of_type (TREE_TYPE (TREE_TYPE (meth)));
11095
11096 if ((patched = patch_string (exp)))
11097 exp = patched;
11098
11099 modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
11100 EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
11101 modify = java_complete_tree (modify);
11102
11103 if (modify != error_mark_node)
11104 {
11105 TREE_SIDE_EFFECTS (modify) = 1;
11106 TREE_OPERAND (node, 0) = modify;
11107 }
11108 else
11109 return error_mark_node;
11110 }
11111 TREE_TYPE (node) = void_type_node;
11112 TREE_SIDE_EFFECTS (node) = 1;
11113 return node;
11114 }
11115
11116 /* 14.8 The if Statement */
11117
11118 static tree
11119 build_if_else_statement (location, expression, if_body, else_body)
11120 int location;
11121 tree expression, if_body, else_body;
11122 {
11123 tree node;
11124 if (!else_body)
11125 else_body = empty_stmt_node;
11126 node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
11127 EXPR_WFL_LINECOL (node) = location;
11128 node = build_debugable_stmt (location, node);
11129 return node;
11130 }
11131
11132 static tree
11133 patch_if_else_statement (node)
11134 tree node;
11135 {
11136 tree expression = TREE_OPERAND (node, 0);
11137
11138 TREE_TYPE (node) = error_mark_node;
11139 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11140
11141 /* The type of expression must be boolean */
11142 if (TREE_TYPE (expression) != boolean_type_node
11143 && TREE_TYPE (expression) != promoted_boolean_type_node)
11144 {
11145 parse_error_context
11146 (wfl_operator,
11147 "Incompatible type for `if'. Can't convert `%s' to `boolean'",
11148 lang_printable_name (TREE_TYPE (expression), 0));
11149 return error_mark_node;
11150 }
11151
11152 TREE_TYPE (node) = void_type_node;
11153 TREE_SIDE_EFFECTS (node) = 1;
11154 CAN_COMPLETE_NORMALLY (node)
11155 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
11156 | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2));
11157 return node;
11158 }
11159
11160 /* 14.6 Labeled Statements */
11161
11162 /* Action taken when a lableled statement is parsed. a new
11163 LABELED_BLOCK_EXPR is created. No statement is attached to the
11164 label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
11165
11166 static tree
11167 build_labeled_block (location, label)
11168 int location;
11169 tree label;
11170 {
11171 tree label_name ;
11172 tree label_decl, node;
11173 if (label == NULL_TREE || label == continue_identifier_node)
11174 label_name = label;
11175 else
11176 {
11177 label_name = merge_qualified_name (label_id, label);
11178 /* Issue an error if we try to reuse a label that was previously
11179 declared */
11180 if (IDENTIFIER_LOCAL_VALUE (label_name))
11181 {
11182 EXPR_WFL_LINECOL (wfl_operator) = location;
11183 parse_error_context (wfl_operator,
11184 "Declaration of `%s' shadows a previous label declaration",
11185 IDENTIFIER_POINTER (label));
11186 EXPR_WFL_LINECOL (wfl_operator) =
11187 EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
11188 parse_error_context (wfl_operator,
11189 "This is the location of the previous declaration of label `%s'",
11190 IDENTIFIER_POINTER (label));
11191 java_error_count--;
11192 }
11193 }
11194
11195 label_decl = create_label_decl (label_name);
11196 node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
11197 EXPR_WFL_LINECOL (node) = location;
11198 TREE_SIDE_EFFECTS (node) = 1;
11199 return node;
11200 }
11201
11202 /* A labeled statement LBE is attached a statement. */
11203
11204 static tree
11205 finish_labeled_statement (lbe, statement)
11206 tree lbe; /* Labeled block expr */
11207 tree statement;
11208 {
11209 /* In anyways, tie the loop to its statement */
11210 LABELED_BLOCK_BODY (lbe) = statement;
11211 pop_labeled_block ();
11212 POP_LABELED_BLOCK ();
11213 return lbe;
11214 }
11215
11216 /* 14.10, 14.11, 14.12 Loop Statements */
11217
11218 /* Create an empty LOOP_EXPR and make it the last in the nested loop
11219 list. */
11220
11221 static tree
11222 build_new_loop (loop_body)
11223 tree loop_body;
11224 {
11225 tree loop = build (LOOP_EXPR, NULL_TREE, loop_body);
11226 TREE_SIDE_EFFECTS (loop) = 1;
11227 PUSH_LOOP (loop);
11228 return loop;
11229 }
11230
11231 /* Create a loop body according to the following structure:
11232 COMPOUND_EXPR
11233 COMPOUND_EXPR (loop main body)
11234 EXIT_EXPR (this order is for while/for loops.
11235 LABELED_BLOCK_EXPR the order is reversed for do loops)
11236 LABEL_DECL (a continue occuring here branches at the
11237 BODY end of this labeled block)
11238 INCREMENT (if any)
11239
11240 REVERSED, if non zero, tells that the loop condition expr comes
11241 after the body, like in the do-while loop.
11242
11243 To obtain a loop, the loop body structure described above is
11244 encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
11245
11246 LABELED_BLOCK_EXPR
11247 LABEL_DECL (use this label to exit the loop)
11248 LOOP_EXPR
11249 <structure described above> */
11250
11251 static tree
11252 build_loop_body (location, condition, reversed)
11253 int location;
11254 tree condition;
11255 int reversed;
11256 {
11257 tree first, second, body;
11258
11259 condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
11260 EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
11261 condition = build_debugable_stmt (location, condition);
11262 TREE_SIDE_EFFECTS (condition) = 1;
11263
11264 body = build_labeled_block (0, continue_identifier_node);
11265 first = (reversed ? body : condition);
11266 second = (reversed ? condition : body);
11267 return
11268 build (COMPOUND_EXPR, NULL_TREE,
11269 build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
11270 }
11271
11272 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
11273 their order) on the current loop. Unlink the current loop from the
11274 loop list. */
11275
11276 static tree
11277 finish_loop_body (location, condition, body, reversed)
11278 int location;
11279 tree condition, body;
11280 int reversed;
11281 {
11282 tree to_return = ctxp->current_loop;
11283 tree loop_body = LOOP_EXPR_BODY (to_return);
11284 if (condition)
11285 {
11286 tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
11287 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
11288 The real EXIT_EXPR is one operand further. */
11289 EXPR_WFL_LINECOL (cnode) = location;
11290 /* This one is for accurate error reports */
11291 EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
11292 TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
11293 }
11294 LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
11295 POP_LOOP ();
11296 return to_return;
11297 }
11298
11299 /* Tailored version of finish_loop_body for FOR loops, when FOR
11300 loops feature the condition part */
11301
11302 static tree
11303 finish_for_loop (location, condition, update, body)
11304 int location;
11305 tree condition, update, body;
11306 {
11307 /* Put the condition and the loop body in place */
11308 tree loop = finish_loop_body (location, condition, body, 0);
11309 /* LOOP is the current loop which has been now popped of the loop
11310 stack. Install the update block */
11311 LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
11312 return loop;
11313 }
11314
11315 /* Try to find the loop a block might be related to. This comprises
11316 the case where the LOOP_EXPR is found as the second operand of a
11317 COMPOUND_EXPR, because the loop happens to have an initialization
11318 part, then expressed as the first operand of the COMPOUND_EXPR. If
11319 the search finds something, 1 is returned. Otherwise, 0 is
11320 returned. The search is assumed to start from a
11321 LABELED_BLOCK_EXPR's block. */
11322
11323 static tree
11324 search_loop (statement)
11325 tree statement;
11326 {
11327 if (TREE_CODE (statement) == LOOP_EXPR)
11328 return statement;
11329
11330 if (TREE_CODE (statement) == BLOCK)
11331 statement = BLOCK_SUBBLOCKS (statement);
11332 else
11333 return NULL_TREE;
11334
11335 if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
11336 while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
11337 statement = TREE_OPERAND (statement, 1);
11338
11339 return (TREE_CODE (statement) == LOOP_EXPR
11340 && IS_FOR_LOOP_P (statement) ? statement : NULL_TREE);
11341 }
11342
11343 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
11344 returned otherwise. */
11345
11346 static int
11347 labeled_block_contains_loop_p (block, loop)
11348 tree block, loop;
11349 {
11350 if (!block)
11351 return 0;
11352
11353 if (LABELED_BLOCK_BODY (block) == loop)
11354 return 1;
11355
11356 if (IS_FOR_LOOP_P (loop)
11357 && search_loop (LABELED_BLOCK_BODY (block)) == loop)
11358 return 1;
11359
11360 return 0;
11361 }
11362
11363 /* If the loop isn't surrounded by a labeled statement, create one and
11364 insert LOOP as its body. */
11365
11366 static tree
11367 patch_loop_statement (loop)
11368 tree loop;
11369 {
11370 tree loop_label;
11371
11372 TREE_TYPE (loop) = void_type_node;
11373 if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
11374 return loop;
11375
11376 loop_label = build_labeled_block (0, NULL_TREE);
11377 /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
11378 that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
11379 LABELED_BLOCK_BODY (loop_label) = loop;
11380 PUSH_LABELED_BLOCK (loop_label);
11381 return loop_label;
11382 }
11383
11384 /* 14.13, 14.14: break and continue Statements */
11385
11386 /* Build a break or a continue statement. a null NAME indicates an
11387 unlabeled break/continue statement. */
11388
11389 static tree
11390 build_bc_statement (location, is_break, name)
11391 int location, is_break;
11392 tree name;
11393 {
11394 tree break_continue, label_block_expr = NULL_TREE;
11395
11396 if (name)
11397 {
11398 if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
11399 (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
11400 /* Null means that we don't have a target for this named
11401 break/continue. In this case, we make the target to be the
11402 label name, so that the error can be reported accuratly in
11403 patch_bc_statement. */
11404 label_block_expr = EXPR_WFL_NODE (name);
11405 }
11406 /* Unlabeled break/continue will be handled during the
11407 break/continue patch operation */
11408 break_continue
11409 = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
11410
11411 IS_BREAK_STMT_P (break_continue) = is_break;
11412 TREE_SIDE_EFFECTS (break_continue) = 1;
11413 EXPR_WFL_LINECOL (break_continue) = location;
11414 break_continue = build_debugable_stmt (location, break_continue);
11415 return break_continue;
11416 }
11417
11418 /* Verification of a break/continue statement. */
11419
11420 static tree
11421 patch_bc_statement (node)
11422 tree node;
11423 {
11424 tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
11425 tree labeled_block = ctxp->current_labeled_block;
11426 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11427
11428 /* Having an identifier here means that the target is unknown. */
11429 if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
11430 {
11431 parse_error_context (wfl_operator, "No label definition found for `%s'",
11432 IDENTIFIER_POINTER (bc_label));
11433 return error_mark_node;
11434 }
11435 if (! IS_BREAK_STMT_P (node))
11436 {
11437 /* It's a continue statement. */
11438 for (;; labeled_block = TREE_CHAIN (labeled_block))
11439 {
11440 if (labeled_block == NULL_TREE)
11441 {
11442 if (bc_label == NULL_TREE)
11443 parse_error_context (wfl_operator,
11444 "`continue' must be in loop");
11445 else
11446 parse_error_context
11447 (wfl_operator, "continue label `%s' does not name a loop",
11448 IDENTIFIER_POINTER (bc_label));
11449 return error_mark_node;
11450 }
11451 if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
11452 == continue_identifier_node)
11453 && (bc_label == NULL_TREE
11454 || TREE_CHAIN (labeled_block) == bc_label))
11455 {
11456 bc_label = labeled_block;
11457 break;
11458 }
11459 }
11460 }
11461 else if (!bc_label)
11462 {
11463 for (;; labeled_block = TREE_CHAIN (labeled_block))
11464 {
11465 if (labeled_block == NULL_TREE)
11466 {
11467 parse_error_context (wfl_operator,
11468 "`break' must be in loop or switch");
11469 return error_mark_node;
11470 }
11471 target_stmt = LABELED_BLOCK_BODY (labeled_block);
11472 if (TREE_CODE (target_stmt) == SWITCH_EXPR
11473 || search_loop (target_stmt))
11474 {
11475 bc_label = labeled_block;
11476 break;
11477 }
11478 }
11479 }
11480
11481 EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
11482 CAN_COMPLETE_NORMALLY (bc_label) = 1;
11483
11484 /* Our break/continue don't return values. */
11485 TREE_TYPE (node) = void_type_node;
11486 /* Encapsulate the break within a compound statement so that it's
11487 expanded all the times by expand_expr (and not clobbered
11488 sometimes, like after a if statement) */
11489 node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
11490 TREE_SIDE_EFFECTS (node) = 1;
11491 return node;
11492 }
11493
11494 /* Process the exit expression belonging to a loop. Its type must be
11495 boolean. */
11496
11497 static tree
11498 patch_exit_expr (node)
11499 tree node;
11500 {
11501 tree expression = TREE_OPERAND (node, 0);
11502 TREE_TYPE (node) = error_mark_node;
11503 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11504
11505 /* The type of expression must be boolean */
11506 if (TREE_TYPE (expression) != boolean_type_node)
11507 {
11508 parse_error_context
11509 (wfl_operator,
11510 "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
11511 lang_printable_name (TREE_TYPE (expression), 0));
11512 return error_mark_node;
11513 }
11514 /* Now we know things are allright, invert the condition, fold and
11515 return */
11516 TREE_OPERAND (node, 0) =
11517 fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
11518
11519 if (! integer_zerop (TREE_OPERAND (node, 0))
11520 && ctxp->current_loop != NULL_TREE
11521 && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
11522 CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
11523 if (! integer_onep (TREE_OPERAND (node, 0)))
11524 CAN_COMPLETE_NORMALLY (node) = 1;
11525
11526
11527 TREE_TYPE (node) = void_type_node;
11528 return node;
11529 }
11530
11531 /* 14.9 Switch statement */
11532
11533 static tree
11534 patch_switch_statement (node)
11535 tree node;
11536 {
11537 tree se = TREE_OPERAND (node, 0), se_type;
11538
11539 /* Complete the switch expression */
11540 se = TREE_OPERAND (node, 0) = java_complete_tree (se);
11541 se_type = TREE_TYPE (se);
11542 /* The type of the switch expression must be char, byte, short or
11543 int */
11544 if (!JINTEGRAL_TYPE_P (se_type))
11545 {
11546 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11547 parse_error_context (wfl_operator,
11548 "Incompatible type for `switch'. Can't convert `%s' to `int'",
11549 lang_printable_name (se_type, 0));
11550 /* This is what java_complete_tree will check */
11551 TREE_OPERAND (node, 0) = error_mark_node;
11552 return error_mark_node;
11553 }
11554
11555 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11556
11557 /* Ready to return */
11558 if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
11559 {
11560 TREE_TYPE (node) = error_mark_node;
11561 return error_mark_node;
11562 }
11563 TREE_TYPE (node) = void_type_node;
11564 TREE_SIDE_EFFECTS (node) = 1;
11565 CAN_COMPLETE_NORMALLY (node)
11566 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
11567 || ! SWITCH_HAS_DEFAULT (node);
11568 return node;
11569 }
11570
11571 /* 14.18 The try statement */
11572
11573 static tree
11574 build_try_statement (location, try_block, catches)
11575 int location;
11576 tree try_block, catches;
11577 {
11578 tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
11579 EXPR_WFL_LINECOL (node) = location;
11580 return node;
11581 }
11582
11583 static tree
11584 build_try_finally_statement (location, try_block, finally)
11585 int location;
11586 tree try_block, finally;
11587 {
11588 tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
11589 EXPR_WFL_LINECOL (node) = location;
11590 return node;
11591 }
11592
11593 static tree
11594 patch_try_statement (node)
11595 tree node;
11596 {
11597 int error_found = 0;
11598 tree try = TREE_OPERAND (node, 0);
11599 /* Exception handlers are considered in left to right order */
11600 tree catch = nreverse (TREE_OPERAND (node, 1));
11601 tree current, caught_type_list = NULL_TREE;
11602
11603 /* Check catch clauses, if any. Every time we find an error, we try
11604 to process the next catch clause. We process the catch clause before
11605 the try block so that when processing the try block we can check thrown
11606 exceptions againts the caught type list. */
11607 for (current = catch; current; current = TREE_CHAIN (current))
11608 {
11609 tree carg_decl, carg_type;
11610 tree sub_current, catch_block, catch_clause;
11611 int unreachable;
11612
11613 /* At this point, the structure of the catch clause is
11614 CATCH_EXPR (catch node)
11615 BLOCK (with the decl of the parameter)
11616 COMPOUND_EXPR
11617 MODIFY_EXPR (assignment of the catch parameter)
11618 BLOCK (catch clause block)
11619 */
11620 catch_clause = TREE_OPERAND (current, 0);
11621 carg_decl = BLOCK_EXPR_DECLS (catch_clause);
11622 carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
11623
11624 /* Catch clauses can't have more than one parameter declared,
11625 but it's already enforced by the grammar. Make sure that the
11626 only parameter of the clause statement in of class Throwable
11627 or a subclass of Throwable, but that was done earlier. The
11628 catch clause parameter type has also been resolved. */
11629
11630 /* Just make sure that the catch clause parameter type inherits
11631 from java.lang.Throwable */
11632 if (!inherits_from_p (carg_type, throwable_type_node))
11633 {
11634 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
11635 parse_error_context (wfl_operator,
11636 "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
11637 lang_printable_name (carg_type, 0));
11638 error_found = 1;
11639 continue;
11640 }
11641
11642 /* Partial check for unreachable catch statement: The catch
11643 clause is reachable iff is no earlier catch block A in
11644 the try statement such that the type of the catch
11645 clause's parameter is the same as or a subclass of the
11646 type of A's parameter */
11647 unreachable = 0;
11648 for (sub_current = catch;
11649 sub_current != current; sub_current = TREE_CHAIN (sub_current))
11650 {
11651 tree sub_catch_clause, decl;
11652 sub_catch_clause = TREE_OPERAND (sub_current, 0);
11653 decl = BLOCK_EXPR_DECLS (sub_catch_clause);
11654
11655 if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
11656 {
11657 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
11658 parse_error_context
11659 (wfl_operator,
11660 "`catch' not reached because of the catch clause at line %d",
11661 EXPR_WFL_LINENO (sub_current));
11662 unreachable = error_found = 1;
11663 break;
11664 }
11665 }
11666 /* Complete the catch clause block */
11667 catch_block = java_complete_tree (TREE_OPERAND (current, 0));
11668 if (catch_block == error_mark_node)
11669 {
11670 error_found = 1;
11671 continue;
11672 }
11673 if (CAN_COMPLETE_NORMALLY (catch_block))
11674 CAN_COMPLETE_NORMALLY (node) = 1;
11675 TREE_OPERAND (current, 0) = catch_block;
11676
11677 if (unreachable)
11678 continue;
11679
11680 /* Things to do here: the exception must be thrown */
11681
11682 /* Link this type to the caught type list */
11683 caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
11684 }
11685
11686 PUSH_EXCEPTIONS (caught_type_list);
11687 if ((try = java_complete_tree (try)) == error_mark_node)
11688 error_found = 1;
11689 if (CAN_COMPLETE_NORMALLY (try))
11690 CAN_COMPLETE_NORMALLY (node) = 1;
11691 POP_EXCEPTIONS ();
11692
11693 /* Verification ends here */
11694 if (error_found)
11695 return error_mark_node;
11696
11697 TREE_OPERAND (node, 0) = try;
11698 TREE_OPERAND (node, 1) = catch;
11699 TREE_TYPE (node) = void_type_node;
11700 return node;
11701 }
11702
11703 /* 14.17 The synchronized Statement */
11704
11705 static tree
11706 patch_synchronized_statement (node, wfl_op1)
11707 tree node, wfl_op1;
11708 {
11709 tree expr = java_complete_tree (TREE_OPERAND (node, 0));
11710 tree block = TREE_OPERAND (node, 1);
11711
11712 tree enter, exit, expr_decl, assignment;
11713
11714 if (expr == error_mark_node)
11715 {
11716 block = java_complete_tree (block);
11717 return expr;
11718 }
11719
11720 /* The TYPE of expr must be a reference type */
11721 if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
11722 {
11723 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
11724 parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
11725 lang_printable_name (TREE_TYPE (expr), 0));
11726 return error_mark_node;
11727 }
11728
11729 if (flag_emit_xref)
11730 {
11731 TREE_OPERAND (node, 0) = expr;
11732 TREE_OPERAND (node, 1) = java_complete_tree (block);
11733 CAN_COMPLETE_NORMALLY (node) = 1;
11734 return node;
11735 }
11736
11737 /* Generate a try-finally for the synchronized statement, except
11738 that the handler that catches all throw exception calls
11739 _Jv_MonitorExit and then rethrow the exception.
11740 The synchronized statement is then implemented as:
11741 TRY
11742 {
11743 _Jv_MonitorEnter (expression)
11744 synchronized_block
11745 _Jv_MonitorExit (expression)
11746 }
11747 CATCH_ALL
11748 {
11749 e = _Jv_exception_info ();
11750 _Jv_MonitorExit (expression)
11751 Throw (e);
11752 } */
11753
11754 expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
11755 BUILD_MONITOR_ENTER (enter, expr_decl);
11756 BUILD_MONITOR_EXIT (exit, expr_decl);
11757 CAN_COMPLETE_NORMALLY (enter) = 1;
11758 CAN_COMPLETE_NORMALLY (exit) = 1;
11759 assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
11760 TREE_SIDE_EFFECTS (assignment) = 1;
11761 node = build1 (CLEANUP_POINT_EXPR, NULL_TREE,
11762 build (COMPOUND_EXPR, NULL_TREE,
11763 build (WITH_CLEANUP_EXPR, NULL_TREE,
11764 build (COMPOUND_EXPR, NULL_TREE,
11765 assignment, enter),
11766 NULL_TREE, exit),
11767 block));
11768 node = build_expr_block (node, expr_decl);
11769
11770 return java_complete_tree (node);
11771 }
11772
11773 /* 14.16 The throw Statement */
11774
11775 static tree
11776 patch_throw_statement (node, wfl_op1)
11777 tree node, wfl_op1;
11778 {
11779 tree expr = TREE_OPERAND (node, 0);
11780 tree type = TREE_TYPE (expr);
11781 int unchecked_ok = 0, tryblock_throws_ok = 0;
11782
11783 /* Thrown expression must be assignable to java.lang.Throwable */
11784 if (!try_reference_assignconv (throwable_type_node, expr))
11785 {
11786 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
11787 parse_error_context (wfl_operator,
11788 "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
11789 lang_printable_name (type, 0));
11790 /* If the thrown expression was a reference, we further the
11791 compile-time check. */
11792 if (!JREFERENCE_TYPE_P (type))
11793 return error_mark_node;
11794 }
11795
11796 /* At least one of the following must be true */
11797
11798 /* The type of the throw expression is a not checked exception,
11799 i.e. is a unchecked expression. */
11800 unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
11801
11802 /* Throw is contained in a try statement and at least one catch
11803 clause can receive the thrown expression or the current method is
11804 declared to throw such an exception. Or, the throw statement is
11805 contained in a method or constructor declaration and the type of
11806 the Expression is assignable to at least one type listed in the
11807 throws clause the declaration. */
11808 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
11809 if (!unchecked_ok)
11810 tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
11811 if (!(unchecked_ok || tryblock_throws_ok))
11812 {
11813 /* If there is a surrounding try block that has no matching
11814 clatch clause, report it first. A surrounding try block exits
11815 only if there is something after the list of checked
11816 exception thrown by the current function (if any). */
11817 if (IN_TRY_BLOCK_P ())
11818 parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
11819 lang_printable_name (type, 0));
11820 /* If we have no surrounding try statement and the method doesn't have
11821 any throws, report it now. FIXME */
11822
11823 /* We report that the exception can't be throw from a try block
11824 in all circumstances but when the `throw' is inside a static
11825 block. */
11826 else if (!EXCEPTIONS_P (currently_caught_type_list)
11827 && !tryblock_throws_ok)
11828 {
11829 if (IS_CLINIT (current_function_decl))
11830 parse_error_context (wfl_operator,
11831 "Checked exception `%s' can't be thrown in initializer",
11832 lang_printable_name (type, 0));
11833 else
11834 parse_error_context (wfl_operator,
11835 "Checked exception `%s' isn't thrown from a `try' block",
11836 lang_printable_name (type, 0));
11837 }
11838 /* Otherwise, the current method doesn't have the appropriate
11839 throws declaration */
11840 else
11841 parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
11842 lang_printable_name (type, 0));
11843 return error_mark_node;
11844 }
11845
11846 if (! flag_emit_class_files && ! flag_emit_xref)
11847 BUILD_THROW (node, expr);
11848
11849 /* If doing xrefs, keep the location where the `throw' was seen. */
11850 if (flag_emit_xref)
11851 EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
11852 return node;
11853 }
11854
11855 /* Check that exception said to be thrown by method DECL can be
11856 effectively caught from where DECL is invoked. */
11857
11858 static void
11859 check_thrown_exceptions (location, decl)
11860 int location;
11861 tree decl;
11862 {
11863 tree throws;
11864 /* For all the unchecked exceptions thrown by DECL */
11865 for (throws = DECL_FUNCTION_THROWS (decl); throws;
11866 throws = TREE_CHAIN (throws))
11867 if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
11868 {
11869 #if 1
11870 /* Temporary hack to suppresses errors about cloning arrays. FIXME */
11871 if (DECL_NAME (decl) == get_identifier ("clone"))
11872 continue;
11873 #endif
11874 EXPR_WFL_LINECOL (wfl_operator) = location;
11875 if (DECL_NAME (current_function_decl) == finit_identifier_node)
11876 parse_error_context
11877 (wfl_operator, "Exception `%s' can't be thrown in initializer",
11878 lang_printable_name (TREE_VALUE (throws), 0));
11879 else
11880 {
11881 parse_error_context
11882 (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
11883 lang_printable_name (TREE_VALUE (throws), 0),
11884 (DECL_NAME (current_function_decl) == init_identifier_node ?
11885 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
11886 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
11887 }
11888 }
11889 }
11890
11891 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
11892 try-catch blocks, OR is listed in the `throws' clause of the
11893 current method. */
11894
11895 static int
11896 check_thrown_exceptions_do (exception)
11897 tree exception;
11898 {
11899 tree list = currently_caught_type_list;
11900 resolve_and_layout (exception, NULL_TREE);
11901 /* First, all the nested try-catch-finally at that stage. The
11902 last element contains `throws' clause exceptions, if any. */
11903 if (IS_UNCHECKED_EXCEPTION_P (exception))
11904 return 1;
11905 while (list)
11906 {
11907 tree caught;
11908 for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
11909 if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
11910 return 1;
11911 list = TREE_CHAIN (list);
11912 }
11913 return 0;
11914 }
11915
11916 static void
11917 purge_unchecked_exceptions (mdecl)
11918 tree mdecl;
11919 {
11920 tree throws = DECL_FUNCTION_THROWS (mdecl);
11921 tree new = NULL_TREE;
11922
11923 while (throws)
11924 {
11925 tree next = TREE_CHAIN (throws);
11926 if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
11927 {
11928 TREE_CHAIN (throws) = new;
11929 new = throws;
11930 }
11931 throws = next;
11932 }
11933 /* List is inverted here, but it doesn't matter */
11934 DECL_FUNCTION_THROWS (mdecl) = new;
11935 }
11936
11937 /* 15.24 Conditional Operator ?: */
11938
11939 static tree
11940 patch_conditional_expr (node, wfl_cond, wfl_op1)
11941 tree node, wfl_cond, wfl_op1;
11942 {
11943 tree cond = TREE_OPERAND (node, 0);
11944 tree op1 = TREE_OPERAND (node, 1);
11945 tree op2 = TREE_OPERAND (node, 2);
11946 tree resulting_type = NULL_TREE;
11947 tree t1, t2, patched;
11948 int error_found = 0;
11949
11950 /* Operands of ?: might be StringBuffers crafted as a result of a
11951 string concatenation. Obtain a descent operand here. */
11952 if ((patched = patch_string (op1)))
11953 TREE_OPERAND (node, 1) = op1 = patched;
11954 if ((patched = patch_string (op2)))
11955 TREE_OPERAND (node, 2) = op2 = patched;
11956
11957 t1 = TREE_TYPE (op1);
11958 t2 = TREE_TYPE (op2);
11959
11960 /* The first expression must be a boolean */
11961 if (TREE_TYPE (cond) != boolean_type_node)
11962 {
11963 SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
11964 parse_error_context (wfl_operator,
11965 "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
11966 lang_printable_name (TREE_TYPE (cond), 0));
11967 error_found = 1;
11968 }
11969
11970 /* Second and third can be numeric, boolean (i.e. primitive),
11971 references or null. Anything else results in an error */
11972 if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
11973 || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
11974 && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
11975 || (t1 == boolean_type_node && t2 == boolean_type_node)))
11976 error_found = 1;
11977
11978 /* Determine the type of the conditional expression. Same types are
11979 easy to deal with */
11980 else if (t1 == t2)
11981 resulting_type = t1;
11982
11983 /* There are different rules for numeric types */
11984 else if (JNUMERIC_TYPE_P (t1))
11985 {
11986 /* if byte/short found, the resulting type is short */
11987 if ((t1 == byte_type_node && t2 == short_type_node)
11988 || (t1 == short_type_node && t2 == byte_type_node))
11989 resulting_type = short_type_node;
11990
11991 /* If t1 is a constant int and t2 is of type byte, short or char
11992 and t1's value fits in t2, then the resulting type is t2 */
11993 else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
11994 && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
11995 resulting_type = t2;
11996
11997 /* If t2 is a constant int and t1 is of type byte, short or char
11998 and t2's value fits in t1, then the resulting type is t1 */
11999 else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
12000 && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
12001 resulting_type = t1;
12002
12003 /* Otherwise, binary numeric promotion is applied and the
12004 resulting type is the promoted type of operand 1 and 2 */
12005 else
12006 resulting_type = binary_numeric_promotion (t1, t2,
12007 &TREE_OPERAND (node, 1),
12008 &TREE_OPERAND (node, 2));
12009 }
12010
12011 /* Cases of a reference and a null type */
12012 else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
12013 resulting_type = t1;
12014
12015 else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
12016 resulting_type = t2;
12017
12018 /* Last case: different reference types. If a type can be converted
12019 into the other one by assignment conversion, the latter
12020 determines the type of the expression */
12021 else if ((resulting_type = try_reference_assignconv (t1, op2)))
12022 resulting_type = promote_type (t1);
12023
12024 else if ((resulting_type = try_reference_assignconv (t2, op1)))
12025 resulting_type = promote_type (t2);
12026
12027 /* If we don't have any resulting type, we're in trouble */
12028 if (!resulting_type)
12029 {
12030 char *t = xstrdup (lang_printable_name (t1, 0));
12031 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
12032 parse_error_context (wfl_operator,
12033 "Incompatible type for `?:'. Can't convert `%s' to `%s'",
12034 t, lang_printable_name (t2, 0));
12035 free (t);
12036 error_found = 1;
12037 }
12038
12039 if (error_found)
12040 {
12041 TREE_TYPE (node) = error_mark_node;
12042 return error_mark_node;
12043 }
12044
12045 TREE_TYPE (node) = resulting_type;
12046 TREE_SET_CODE (node, COND_EXPR);
12047 CAN_COMPLETE_NORMALLY (node) = 1;
12048 return node;
12049 }
12050
12051 /* Try to constant fold NODE.
12052 If NODE is not a constant expression, return NULL_EXPR.
12053 CONTEXT is a static final VAR_DECL whose initializer we are folding. */
12054
12055 static tree
12056 fold_constant_for_init (node, context)
12057 tree node;
12058 tree context;
12059 {
12060 tree op0, op1, val;
12061 enum tree_code code = TREE_CODE (node);
12062
12063 if (code == STRING_CST)
12064 return node;
12065
12066 if (code == INTEGER_CST || code == REAL_CST)
12067 return convert (TREE_TYPE (context), node);
12068 if (TREE_TYPE (node) != NULL_TREE && code != VAR_DECL && code != FIELD_DECL)
12069 return NULL_TREE;
12070
12071 switch (code)
12072 {
12073 case PLUS_EXPR:
12074 case MINUS_EXPR:
12075 case MULT_EXPR:
12076 case TRUNC_MOD_EXPR:
12077 case RDIV_EXPR:
12078 case LSHIFT_EXPR:
12079 case RSHIFT_EXPR:
12080 case URSHIFT_EXPR:
12081 case BIT_AND_EXPR:
12082 case BIT_XOR_EXPR:
12083 case BIT_IOR_EXPR:
12084 case TRUTH_ANDIF_EXPR:
12085 case TRUTH_ORIF_EXPR:
12086 case EQ_EXPR:
12087 case NE_EXPR:
12088 case GT_EXPR:
12089 case GE_EXPR:
12090 case LT_EXPR:
12091 case LE_EXPR:
12092 op0 = TREE_OPERAND (node, 0);
12093 op1 = TREE_OPERAND (node, 1);
12094 val = fold_constant_for_init (op0, context);
12095 if (val == NULL_TREE || ! TREE_CONSTANT (val))
12096 return NULL_TREE;
12097 TREE_OPERAND (node, 0) = val;
12098 val = fold_constant_for_init (op1, context);
12099 if (val == NULL_TREE || ! TREE_CONSTANT (val))
12100 return NULL_TREE;
12101 TREE_OPERAND (node, 1) = val;
12102 return patch_binop (node, op0, op1);
12103
12104 case UNARY_PLUS_EXPR:
12105 case NEGATE_EXPR:
12106 case TRUTH_NOT_EXPR:
12107 case BIT_NOT_EXPR:
12108 case CONVERT_EXPR:
12109 op0 = TREE_OPERAND (node, 0);
12110 val = fold_constant_for_init (op0, context);
12111 if (val == NULL_TREE || ! TREE_CONSTANT (val))
12112 return NULL_TREE;
12113 TREE_OPERAND (node, 0) = val;
12114 return patch_unaryop (node, op0);
12115 break;
12116
12117 case COND_EXPR:
12118 val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
12119 if (val == NULL_TREE || ! TREE_CONSTANT (val))
12120 return NULL_TREE;
12121 TREE_OPERAND (node, 0) = val;
12122 val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
12123 if (val == NULL_TREE || ! TREE_CONSTANT (val))
12124 return NULL_TREE;
12125 TREE_OPERAND (node, 1) = val;
12126 val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
12127 if (val == NULL_TREE || ! TREE_CONSTANT (val))
12128 return NULL_TREE;
12129 TREE_OPERAND (node, 2) = val;
12130 return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
12131 : TREE_OPERAND (node, 2);
12132
12133 case VAR_DECL:
12134 case FIELD_DECL:
12135 if (! FIELD_FINAL (node)
12136 || DECL_INITIAL (node) == NULL_TREE)
12137 return NULL_TREE;
12138 val = DECL_INITIAL (node);
12139 /* Guard against infinite recursion. */
12140 DECL_INITIAL (node) = NULL_TREE;
12141 val = fold_constant_for_init (val, node);
12142 DECL_INITIAL (node) = val;
12143 return val;
12144
12145 case EXPR_WITH_FILE_LOCATION:
12146 /* Compare java_complete_tree and resolve_expression_name. */
12147 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
12148 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
12149 {
12150 tree name = EXPR_WFL_NODE (node);
12151 tree decl;
12152 if (PRIMARY_P (node))
12153 return NULL_TREE;
12154 else if (! QUALIFIED_P (name))
12155 {
12156 decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
12157 if (decl == NULL_TREE
12158 || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
12159 return NULL_TREE;
12160 return fold_constant_for_init (decl, decl);
12161 }
12162 else
12163 {
12164 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
12165 qualify_ambiguous_name (node);
12166 if (resolve_field_access (node, &decl, NULL)
12167 && decl != NULL_TREE)
12168 return fold_constant_for_init (decl, decl);
12169 return NULL_TREE;
12170 }
12171 }
12172 else
12173 {
12174 op0 = TREE_OPERAND (node, 0);
12175 val = fold_constant_for_init (op0, context);
12176 if (val == NULL_TREE || ! TREE_CONSTANT (val))
12177 return NULL_TREE;
12178 TREE_OPERAND (node, 0) = val;
12179 return val;
12180 }
12181
12182 #ifdef USE_COMPONENT_REF
12183 case IDENTIFIER:
12184 case COMPONENT_REF:
12185 ?;
12186 #endif
12187
12188 default:
12189 return NULL_TREE;
12190 }
12191 }
12192
12193 #ifdef USE_COMPONENT_REF
12194 /* Context is 'T' for TypeName, 'P' for PackageName,
12195 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
12196
12197 tree
12198 resolve_simple_name (name, context)
12199 tree name;
12200 int context;
12201 {
12202 }
12203
12204 tree
12205 resolve_qualified_name (name, context)
12206 tree name;
12207 int context;
12208 {
12209 }
12210 #endif
Mirror of the offical gcc git repository hosted at gcc.gnu.org