?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* config/alpha/alpha.md, arm/arm.c, darwin.c, frv/frv.md,
[official-gcc.git] / gcc / java / parse.y
blob4b6521ca2434ac715b608756545984b47b46d16d
1 /* Source code parsing and tree node generation for the GNU compiler
2 for the Java(TM) language.
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
4 Free Software Foundation, Inc.
5 Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA.
23
24 Java and all Java-based marks are trademarks or registered trademarks
25 of Sun Microsystems, Inc. in the United States and other countries.
26 The Free Software Foundation is independent of Sun Microsystems, Inc. */
27
28 /* This file parses java source code and issues a tree node image
29 suitable for code generation (byte code and targeted CPU assembly
30 language).
31
32 The grammar conforms to the Java grammar described in "The Java(TM)
33 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
34 1996, ISBN 0-201-63451-1"
35
36 The following modifications were brought to the original grammar:
37
38 method_body: added the rule '| block SC_TK'
39 static_initializer: added the rule 'static block SC_TK'.
40
41 Note: All the extra rules described above should go away when the
42 empty_statement rule will work.
43
44 statement_nsi: 'nsi' should be read no_short_if.
45
46 Some rules have been modified to support JDK1.1 inner classes
47 definitions and other extensions. */
48
49 %{
50 #include "config.h"
51 #include "system.h"
52 #include "coretypes.h"
53 #include "tm.h"
54 #include <dirent.h>
55 #include "tree.h"
56 #include "rtl.h"
57 #include "real.h"
58 #include "obstack.h"
59 #include "toplev.h"
60 #include "pretty-print.h"
61 #include "diagnostic.h"
62 #include "flags.h"
63 #include "java-tree.h"
64 #include "jcf.h"
65 #include "lex.h"
66 #include "parse.h"
67 #include "zipfile.h"
68 #include "convert.h"
69 #include "buffer.h"
70 #include "function.h"
71 #include "except.h"
72 #include "ggc.h"
73 #include "debug.h"
74 #include "tree-inline.h"
75 #include "tree-dump.h"
76 #include "cgraph.h"
77 #include "target.h"
78
79 /* Local function prototypes */
80 static char *java_accstring_lookup (int);
81 static const char *accessibility_string (int);
82 static void classitf_redefinition_error (const char *,tree, tree, tree);
83 static void variable_redefinition_error (tree, tree, tree, int);
84 static tree create_class (int, tree, tree, tree);
85 static tree create_interface (int, tree, tree);
86 static void end_class_declaration (int);
87 static tree find_field (tree, tree);
88 static tree lookup_field_wrapper (tree, tree);
89 static int duplicate_declaration_error_p (tree, tree, tree);
90 static void register_fields (int, tree, tree);
91 static tree parser_qualified_classname (tree);
92 static int parser_check_super (tree, tree, tree);
93 static int parser_check_super_interface (tree, tree, tree);
94 static void check_modifiers_consistency (int);
95 static tree lookup_cl (tree);
96 static tree lookup_java_method2 (tree, tree, int);
97 static tree method_header (int, tree, tree, tree);
98 static void fix_method_argument_names (tree ,tree);
99 static tree method_declarator (tree, tree);
100 static void parse_warning_context (tree cl, const char *gmsgid, ...) ATTRIBUTE_GCC_DIAG(2,3);
101 #ifdef USE_MAPPED_LOCATION
102 static void issue_warning_error_from_context
103 (source_location, const char *gmsgid, va_list *);
104 #else
105 static void issue_warning_error_from_context
106 (tree, const char *gmsgid, va_list *);
107 #endif
108 static void parse_ctor_invocation_error (void);
109 static tree parse_jdk1_1_error (const char *);
110 static void complete_class_report_errors (jdep *);
111 static int process_imports (void);
112 static void read_import_dir (tree);
113 static int find_in_imports_on_demand (tree, tree);
114 static void find_in_imports (tree, tree);
115 static bool inner_class_accessible (tree, tree);
116 static void check_inner_class_access (tree, tree, tree);
117 static int check_pkg_class_access (tree, tree, bool, tree);
118 static tree resolve_package (tree, tree *, tree *);
119 static tree resolve_class (tree, tree, tree, tree);
120 static void declare_local_variables (int, tree, tree);
121 static void dump_java_tree (enum tree_dump_index, tree);
122 static void source_start_java_method (tree);
123 static void source_end_java_method (void);
124 static tree find_name_in_single_imports (tree);
125 static void check_abstract_method_header (tree);
126 static tree lookup_java_interface_method2 (tree, tree);
127 static tree resolve_expression_name (tree, tree *);
128 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
129 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
130 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
131 static tree resolve_and_layout (tree, tree);
132 static tree qualify_and_find (tree, tree, tree);
133 static tree resolve_no_layout (tree, tree);
134 static int invocation_mode (tree, int);
135 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
136 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
137 static tree find_most_specific_methods_list (tree, tree);
138 static int argument_types_convertible (tree, tree);
139 static tree patch_invoke (tree, tree, tree);
140 static int maybe_use_access_method (int, tree *, tree *);
141 static tree lookup_method_invoke (int, tree, tree, tree, tree);
142 static tree register_incomplete_type (int, tree, tree, tree);
143 static tree check_inner_circular_reference (tree, tree);
144 static tree check_circular_reference (tree);
145 static tree obtain_incomplete_type (tree);
146 static tree java_complete_lhs (tree);
147 static tree java_complete_tree (tree);
148 static tree maybe_generate_pre_expand_clinit (tree);
149 static int analyze_clinit_body (tree, tree);
150 static int maybe_yank_clinit (tree);
151 static void start_complete_expand_method (tree);
152 static void java_complete_expand_method (tree);
153 static void java_expand_method_bodies (tree);
154 static int unresolved_type_p (tree, tree *);
155 static void create_jdep_list (struct parser_ctxt *);
156 static tree build_expr_block (tree, tree);
157 static tree enter_block (void);
158 static tree exit_block (void);
159 static tree lookup_name_in_blocks (tree);
160 static void maybe_absorb_scoping_blocks (void);
161 static tree build_method_invocation (tree, tree);
162 static tree build_new_invocation (tree, tree);
163 static tree build_assignment (int, int, tree, tree);
164 static tree build_binop (enum tree_code, int, tree, tree);
165 static tree patch_assignment (tree, tree);
166 static tree patch_binop (tree, tree, tree, int);
167 static tree build_unaryop (int, int, tree);
168 static tree build_incdec (int, int, tree, int);
169 static tree patch_unaryop (tree, tree);
170 static tree build_cast (int, tree, tree);
171 static tree build_null_of_type (tree);
172 static tree patch_cast (tree, tree);
173 static int valid_ref_assignconv_cast_p (tree, tree, int);
174 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
175 static int valid_cast_to_p (tree, tree);
176 static int valid_method_invocation_conversion_p (tree, tree);
177 static tree try_builtin_assignconv (tree, tree, tree);
178 static tree try_reference_assignconv (tree, tree);
179 static tree build_unresolved_array_type (tree);
180 static int build_type_name_from_array_name (tree, tree *);
181 static tree build_array_from_name (tree, tree, tree, tree *);
182 static tree build_array_ref (int, tree, tree);
183 static tree patch_array_ref (tree);
184 #ifdef USE_MAPPED_LOCATION
185 static tree make_qualified_name (tree, tree, source_location);
186 #else
187 static tree make_qualified_name (tree, tree, int);
188 #endif
189 static tree merge_qualified_name (tree, tree);
190 static tree make_qualified_primary (tree, tree, int);
191 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
192 static void qualify_ambiguous_name (tree);
193 static tree resolve_field_access (tree, tree *, tree *);
194 static tree build_newarray_node (tree, tree, int);
195 static tree patch_newarray (tree);
196 static tree resolve_type_during_patch (tree);
197 static tree build_this (int);
198 static tree build_wfl_wrap (tree, int);
199 static tree build_return (int, tree);
200 static tree patch_return (tree);
201 static tree maybe_access_field (tree, tree, tree);
202 static int complete_function_arguments (tree);
203 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
204 static int not_accessible_p (tree, tree, tree, int);
205 static void check_deprecation (tree, tree);
206 static int class_in_current_package (tree);
207 static tree build_if_else_statement (int, tree, tree, tree);
208 static tree patch_if_else_statement (tree);
209 static tree add_stmt_to_block (tree, tree, tree);
210 static tree patch_exit_expr (tree);
211 static tree build_labeled_block (int, tree);
212 static tree finish_labeled_statement (tree, tree);
213 static tree build_bc_statement (int, int, tree);
214 static tree patch_bc_statement (tree);
215 static tree patch_loop_statement (tree);
216 static tree build_new_loop (tree);
217 static tree build_loop_body (int, tree, int);
218 static tree finish_loop_body (int, tree, tree, int);
219 static tree build_debugable_stmt (int, tree);
220 static tree finish_for_loop (int, tree, tree, tree);
221 static tree patch_switch_statement (tree);
222 static tree string_constant_concatenation (tree, tree);
223 static tree build_string_concatenation (tree, tree);
224 static tree patch_string_cst (tree);
225 static tree patch_string (tree);
226 static tree encapsulate_with_try_catch (int, tree, tree, tree);
227 #ifdef USE_MAPPED_LOCATION
228 static tree build_assertion (source_location, tree, tree);
229 #else
230 static tree build_assertion (int, tree, tree);
231 #endif
232 static tree build_try_statement (int, tree, tree);
233 static tree build_try_finally_statement (int, tree, tree);
234 static tree patch_try_statement (tree);
235 static tree patch_synchronized_statement (tree, tree);
236 static tree patch_throw_statement (tree, tree);
237 static void add_exception_to_throws (tree, tree);
238 #ifdef USE_MAPPED_LOCATION
239 static void check_thrown_exceptions (source_location, tree, tree);
240 #else
241 static void check_thrown_exceptions (int, tree, tree);
242 #endif
243 static int check_thrown_exceptions_do (tree);
244 static bool ctors_unchecked_throws_clause_p (tree);
245 static void check_concrete_throws_clauses (tree, tree, tree, tree);
246 static void check_throws_clauses (tree, tree, tree);
247 static void finish_method_declaration (tree);
248 static tree build_super_invocation (tree);
249 static int verify_constructor_circularity (tree, tree);
250 static char *constructor_circularity_msg (tree, tree);
251 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
252 static const char *get_printable_method_name (tree);
253 static tree patch_conditional_expr (tree, tree, tree);
254 static tree generate_finit (tree);
255 static tree generate_instinit (tree);
256 static tree build_instinit_invocation (tree);
257 static void fix_constructors (tree);
258 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
259 static tree craft_constructor (tree, tree);
260 static tree get_constructor_super (tree);
261 static tree create_artificial_method (tree, int, tree, tree, tree);
262 static void start_artificial_method_body (tree);
263 static void end_artificial_method_body (tree);
264 static int check_method_redefinition (tree, tree);
265 static int check_method_types_complete (tree);
266 static bool hack_is_accessible_p (tree, tree);
267 static void java_check_regular_methods (tree);
268 static void check_interface_throws_clauses (tree, tree);
269 static void java_check_abstract_methods (tree);
270 static void unreachable_stmt_error (tree);
271 static int not_accessible_field_error (tree, tree);
272 static tree find_expr_with_wfl (tree);
273 static void missing_return_error (tree);
274 static tree build_new_array_init (int, tree);
275 static tree patch_new_array_init (tree, tree);
276 static tree maybe_build_array_element_wfl (tree);
277 static int array_constructor_check_entry (tree, constructor_elt *);
278 static const char *purify_type_name (const char *);
279 static tree fold_constant_for_init (tree, tree);
280 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
281 static void static_ref_err (tree, tree, tree);
282 static void parser_add_interface (tree, tree, tree);
283 static void add_superinterfaces (tree, tree);
284 static tree jdep_resolve_class (jdep *);
285 static int note_possible_classname (const char *, int);
286 static void java_complete_expand_classes (void);
287 static void java_complete_expand_class (tree);
288 static void java_complete_expand_methods (tree);
289 static tree cut_identifier_in_qualified (tree);
290 static tree java_stabilize_reference (tree);
291 static tree do_unary_numeric_promotion (tree);
292 static char * operator_string (tree);
293 static tree do_merge_string_cste (tree, const char *, int, int);
294 static tree merge_string_cste (tree, tree, int);
295 static tree java_refold (tree);
296 static int java_decl_equiv (tree, tree);
297 static int binop_compound_p (enum tree_code);
298 static tree search_loop (tree);
299 static int labeled_block_contains_loop_p (tree, tree);
300 static int check_abstract_method_definitions (int, tree, tree);
301 static void java_check_abstract_method_definitions (tree);
302 static void java_debug_context_do (int);
303 static void java_parser_context_push_initialized_field (void);
304 static void java_parser_context_pop_initialized_field (void);
305 static tree reorder_static_initialized (tree);
306 static void java_parser_context_suspend (void);
307 static void java_parser_context_resume (void);
308 static int pop_current_osb (struct parser_ctxt *);
309
310 /* JDK 1.1 work. FIXME */
311
312 static tree maybe_make_nested_class_name (tree);
313 static int make_nested_class_name (tree);
314 static void link_nested_class_to_enclosing (void);
315 static tree resolve_inner_class (tree, tree, tree, tree);
316 static tree find_as_inner_class (tree, tree, tree);
317 static tree find_as_inner_class_do (tree, tree);
318 static int check_inner_class_redefinition (tree, tree);
319
320 static tree build_thisn_assign (void);
321 static tree build_current_thisn (tree);
322 static tree build_access_to_thisn (tree, tree, int);
323 static tree maybe_build_thisn_access_method (tree);
324
325 static tree build_nested_field_access (tree, tree);
326 static tree build_nested_field_access_methods (tree);
327 static tree build_nested_field_access_method (tree, tree, tree, tree, tree);
328 static tree build_nested_field_access_expr (int, tree, tree, tree, tree);
329 static tree build_nested_method_access_method (tree);
330 static tree build_new_access_id (void);
331
332 static int nested_member_access_p (tree, tree);
333 static int nested_field_expanded_access_p (tree, tree *, tree *, tree *);
334 static tree nested_field_access_fix (tree, tree, tree);
335
336 static tree build_incomplete_class_ref (int, tree);
337 static tree patch_incomplete_class_ref (tree);
338 static tree create_anonymous_class (tree);
339 static void patch_anonymous_class (tree, tree, tree);
340 static void add_inner_class_fields (tree, tree);
341
342 static tree build_dot_class_method (tree);
343 static tree build_dot_class_method_invocation (tree, tree);
344 static void create_new_parser_context (int);
345 static tree maybe_build_class_init_for_field (tree, tree);
346
347 static int emit_test_initialization (void **, void *);
348
349 static char *string_convert_int_cst (tree);
350
351 /* Number of error found so far. */
352 int java_error_count;
353 /* Number of warning found so far. */
354 int java_warning_count;
355 /* Cyclic inheritance report, as it can be set by layout_class */
356 const char *cyclic_inheritance_report;
357
358 /* The current parser context */
359 struct parser_ctxt *ctxp;
360
361 /* List of things that were analyzed for which code will be generated */
362 struct parser_ctxt *ctxp_for_generation = NULL;
363 struct parser_ctxt *ctxp_for_generation_last = NULL;
364
365 /* binop_lookup maps token to tree_code. It is used where binary
366 operations are involved and required by the parser. RDIV_EXPR
367 covers both integral/floating point division. The code is changed
368 once the type of both operator is worked out. */
369
370 static const enum tree_code binop_lookup[19] =
371 {
372 PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
373 LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
374 BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
375 TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
376 EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
377 };
378 #define BINOP_LOOKUP(VALUE) \
379 binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
380
381 /* This is the end index for binary operators that can also be used
382 in compound assignments. */
383 #define BINOP_COMPOUND_CANDIDATES 11
384
385 /* The "$L" identifier we use to create labels. */
386 static GTY(()) tree label_id;
387
388 /* The "StringBuffer" identifier used for the String `+' operator. */
389 static GTY(()) tree wfl_string_buffer;
390
391 /* The "append" identifier used for String `+' operator. */
392 static GTY(()) tree wfl_append;
393
394 /* The "toString" identifier used for String `+' operator. */
395 static GTY(()) tree wfl_to_string;
396
397 /* The "java.lang" import qualified name. */
398 static GTY(()) tree java_lang_id;
399
400 /* The generated `inst$' identifier used for generated enclosing
401 instance/field access functions. */
402 static GTY(()) tree inst_id;
403
404 /* Context and flag for static blocks */
405 static GTY(()) tree current_static_block;
406
407 /* The generated `write_parm_value$' identifier. */
408 static GTY(()) tree wpv_id;
409
410 /* Hold THIS for the scope of the current method decl. */
411 static GTY(()) tree current_this;
412
413 /* Hold a list of catch clauses list. The first element of this list is
414 the list of the catch clauses of the currently analyzed try block. */
415 static GTY(()) tree currently_caught_type_list;
416
417 /* This holds a linked list of all the case labels for the current
418 switch statement. It is only used when checking to see if there
419 are duplicate labels. FIXME: probably this should just be attached
420 to the switch itself; then it could be referenced via
421 `ctxp->current_loop'. */
422 static GTY(()) tree case_label_list;
423
424 /* Anonymous class counter. Will be reset to 1 every time a non
425 anonymous class gets created. */
426 static int anonymous_class_counter = 1;
427
428 static GTY(()) tree src_parse_roots[1];
429
430 /* All classes seen from source code */
431 #define gclass_list src_parse_roots[0]
432
433 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
434 line and point it out. */
435 /* Should point out the one that don't fit. ASCII/unicode, going
436 backward. FIXME */
437
438 #define check_modifiers(__message, __value, __mask) do { \
439 if ((__value) & ~(__mask)) \
440 { \
441 size_t i, remainder = (__value) & ~(__mask); \
442 for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++) \
443 if ((1 << i) & remainder) \
444 parse_error_context (ctxp->modifier_ctx [i], (__message), \
445 java_accstring_lookup (1 << i)); \
446 } \
447 } while (0)
448
449 %}
450
451 %union {
452 tree node;
453 int sub_token;
454 struct {
455 int token;
456 #ifdef USE_MAPPED_LOCATION
457 source_location location;
458 #else
459 int location;
460 #endif
461 } operator;
462 int value;
463 }
464
465 %{
466 #ifdef USE_MAPPED_LOCATION
467 #define SET_EXPR_LOCATION_FROM_TOKEN(EXPR, TOKEN) \
468 SET_EXPR_LOCATION(EXPR, (TOKEN).location)
469 #else
470 #define SET_EXPR_LOCATION_FROM_TOKEN(EXPR, TOKEN) \
471 (EXPR_WFL_LINECOL (EXPR) = (TOKEN).location)
472 #endif
473
474 #include "lex.c"
475 %}
476
477 %pure_parser
478
479 /* Things defined here have to match the order of what's in the
480 binop_lookup table. */
481
482 %token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
483 %token LS_TK SRS_TK ZRS_TK
484 %token AND_TK XOR_TK OR_TK
485 %token BOOL_AND_TK BOOL_OR_TK
486 %token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
487
488 /* This maps to the same binop_lookup entry than the token above */
489
490 %token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
491 %token REM_ASSIGN_TK
492 %token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
493 %token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
494
495
496 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
497
498 %token PUBLIC_TK PRIVATE_TK PROTECTED_TK
499 %token STATIC_TK FINAL_TK SYNCHRONIZED_TK
500 %token VOLATILE_TK TRANSIENT_TK NATIVE_TK
501 %token PAD_TK ABSTRACT_TK STRICT_TK
502 %token MODIFIER_TK
503
504 /* Keep those two in order, too */
505 %token DECR_TK INCR_TK
506
507 /* From now one, things can be in any order */
508
509 %token DEFAULT_TK IF_TK THROW_TK
510 %token BOOLEAN_TK DO_TK IMPLEMENTS_TK
511 %token THROWS_TK BREAK_TK IMPORT_TK
512 %token ELSE_TK INSTANCEOF_TK RETURN_TK
513 %token VOID_TK CATCH_TK INTERFACE_TK
514 %token CASE_TK EXTENDS_TK FINALLY_TK
515 %token SUPER_TK WHILE_TK CLASS_TK
516 %token SWITCH_TK CONST_TK TRY_TK
517 %token FOR_TK NEW_TK CONTINUE_TK
518 %token GOTO_TK PACKAGE_TK THIS_TK
519 %token ASSERT_TK
520
521 %token BYTE_TK SHORT_TK INT_TK LONG_TK
522 %token CHAR_TK INTEGRAL_TK
523
524 %token FLOAT_TK DOUBLE_TK FP_TK
525
526 %token ID_TK
527
528 %token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
529
530 %token ASSIGN_ANY_TK ASSIGN_TK
531 %token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
532
533 %token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
534 %token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
535
536 %type <value> modifiers MODIFIER_TK final synchronized
537
538 %type <node> super ID_TK identifier
539 %type <node> name simple_name qualified_name
540 %type <node> type_declaration compilation_unit
541 field_declaration method_declaration extends_interfaces
542 interfaces interface_type_list
543 import_declarations package_declaration
544 type_declarations interface_body
545 interface_member_declaration constant_declaration
546 interface_member_declarations interface_type
547 abstract_method_declaration
548 %type <node> class_body_declaration class_member_declaration
549 static_initializer constructor_declaration block
550 %type <node> class_body_declarations constructor_header
551 %type <node> class_or_interface_type class_type class_type_list
552 constructor_declarator explicit_constructor_invocation
553 %type <node> dim_expr dim_exprs this_or_super throws
554
555 %type <node> variable_declarator_id variable_declarator
556 variable_declarators variable_initializer
557 variable_initializers constructor_body
558 array_initializer
559
560 %type <node> class_body block_end constructor_block_end
561 %type <node> statement statement_without_trailing_substatement
562 labeled_statement if_then_statement label_decl
563 if_then_else_statement while_statement for_statement
564 statement_nsi labeled_statement_nsi do_statement
565 if_then_else_statement_nsi while_statement_nsi
566 for_statement_nsi statement_expression_list for_init
567 for_update statement_expression expression_statement
568 primary_no_new_array expression primary array_type
569 array_creation_initialized array_creation_uninitialized
570 class_instance_creation_expression field_access
571 method_invocation array_access something_dot_new
572 argument_list postfix_expression while_expression
573 post_increment_expression post_decrement_expression
574 unary_expression_not_plus_minus unary_expression
575 pre_increment_expression pre_decrement_expression
576 cast_expression
577 multiplicative_expression additive_expression
578 shift_expression relational_expression
579 equality_expression and_expression
580 exclusive_or_expression inclusive_or_expression
581 conditional_and_expression conditional_or_expression
582 conditional_expression assignment_expression
583 left_hand_side assignment for_header for_begin
584 constant_expression do_statement_begin empty_statement
585 switch_statement synchronized_statement throw_statement
586 try_statement assert_statement
587 switch_expression switch_block
588 catches catch_clause catch_clause_parameter finally
589 anonymous_class_creation trap_overflow_corner_case
590 %type <node> return_statement break_statement continue_statement
591
592 %type <operator> ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
593 %type <operator> REM_ASSIGN_TK PLUS_ASSIGN_TK MINUS_ASSIGN_TK
594 %type <operator> LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
595 %type <operator> AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
596 %type <operator> ASSIGN_ANY_TK assignment_operator
597 %token <operator> EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
598 %token <operator> BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
599 %token <operator> DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
600 %token <operator> NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
601 %token <operator> OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
602 %type <operator> THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
603 %type <operator> CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
604 %type <operator> NEW_TK ASSERT_TK
605
606 %type <node> method_body
607
608 %type <node> literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
609 STRING_LIT_TK NULL_TK VOID_TK
610
611 %type <node> IF_TK WHILE_TK FOR_TK
612
613 %type <node> formal_parameter_list formal_parameter
614 method_declarator method_header
615
616 %type <node> primitive_type reference_type type
617 BOOLEAN_TK INTEGRAL_TK FP_TK
618
619 /* Added or modified JDK 1.1 rule types */
620 %type <node> type_literals
621
622 %%
623 /* 19.2 Production from 2.3: The Syntactic Grammar */
624 goal: compilation_unit
625 {}
626 ;
627
628 /* 19.3 Productions from 3: Lexical structure */
629 literal:
630 INT_LIT_TK
631 | FP_LIT_TK
632 | BOOL_LIT_TK
633 | CHAR_LIT_TK
634 | STRING_LIT_TK
635 | NULL_TK
636 ;
637
638 /* 19.4 Productions from 4: Types, Values and Variables */
639 type:
640 primitive_type
641 | reference_type
642 ;
643
644 primitive_type:
645 INTEGRAL_TK
646 | FP_TK
647 | BOOLEAN_TK
648 ;
649
650 reference_type:
651 class_or_interface_type
652 | array_type
653 ;
654
655 class_or_interface_type:
656 name
657 ;
658
659 class_type:
660 class_or_interface_type /* Default rule */
661 ;
662
663 interface_type:
664 class_or_interface_type
665 ;
666
667 array_type:
668 primitive_type dims
669 {
670 int osb = pop_current_osb (ctxp);
671 tree t = build_java_array_type (($1), -1);
672 while (--osb)
673 t = build_unresolved_array_type (t);
674 $$ = t;
675 }
676 | name dims
677 {
678 int osb = pop_current_osb (ctxp);
679 tree t = $1;
680 while (osb--)
681 t = build_unresolved_array_type (t);
682 $$ = t;
683 }
684 ;
685
686 /* 19.5 Productions from 6: Names */
687 name:
688 simple_name /* Default rule */
689 | qualified_name /* Default rule */
690 ;
691
692 simple_name:
693 identifier /* Default rule */
694 ;
695
696 qualified_name:
697 name DOT_TK identifier
698 { $$ = make_qualified_name ($1, $3, $2.location); }
699 ;
700
701 identifier:
702 ID_TK
703 ;
704
705 /* 19.6: Production from 7: Packages */
706 compilation_unit:
707 {$$ = NULL;}
708 | package_declaration
709 | import_declarations
710 | type_declarations
711 | package_declaration import_declarations
712 | package_declaration type_declarations
713 | import_declarations type_declarations
714 | package_declaration import_declarations type_declarations
715 ;
716
717 import_declarations:
718 import_declaration
719 {
720 $$ = NULL;
721 }
722 | import_declarations import_declaration
723 {
724 $$ = NULL;
725 }
726 ;
727
728 type_declarations:
729 type_declaration
730 | type_declarations type_declaration
731 ;
732
733 package_declaration:
734 PACKAGE_TK name SC_TK
735 {
736 ctxp->package = EXPR_WFL_NODE ($2);
737 }
738 | PACKAGE_TK error
739 {yyerror ("Missing name"); RECOVER;}
740 | PACKAGE_TK name error
741 {yyerror ("';' expected"); RECOVER;}
742 ;
743
744 import_declaration:
745 single_type_import_declaration
746 | type_import_on_demand_declaration
747 ;
748
749 single_type_import_declaration:
750 IMPORT_TK name SC_TK
751 {
752 tree name = EXPR_WFL_NODE ($2), last_name;
753 int i = IDENTIFIER_LENGTH (name)-1;
754 const char *last = &IDENTIFIER_POINTER (name)[i];
755 while (last != IDENTIFIER_POINTER (name))
756 {
757 if (last [0] == '.')
758 break;
759 last--;
760 }
761 last_name = get_identifier (++last);
762 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
763 {
764 tree err = find_name_in_single_imports (last_name);
765 if (err && err != name)
766 parse_error_context
767 ($2, "Ambiguous class: %qs and %qs",
768 IDENTIFIER_POINTER (name),
769 IDENTIFIER_POINTER (err));
770 else
771 REGISTER_IMPORT ($2, last_name);
772 }
773 else
774 REGISTER_IMPORT ($2, last_name);
775 }
776 | IMPORT_TK error
777 {yyerror ("Missing name"); RECOVER;}
778 | IMPORT_TK name error
779 {yyerror ("';' expected"); RECOVER;}
780 ;
781
782 type_import_on_demand_declaration:
783 IMPORT_TK name DOT_TK MULT_TK SC_TK
784 {
785 tree name = EXPR_WFL_NODE ($2);
786 tree it;
787 /* Search for duplicates. */
788 for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
789 if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
790 break;
791 /* Don't import the same thing more than once, just ignore
792 duplicates (7.5.2) */
793 if (! it)
794 {
795 read_import_dir ($2);
796 ctxp->import_demand_list =
797 chainon (ctxp->import_demand_list,
798 build_tree_list ($2, NULL_TREE));
799 }
800 }
801 | IMPORT_TK name DOT_TK error
802 {yyerror ("'*' expected"); RECOVER;}
803 | IMPORT_TK name DOT_TK MULT_TK error
804 {yyerror ("';' expected"); RECOVER;}
805 ;
806
807 type_declaration:
808 class_declaration
809 { end_class_declaration (0); }
810 | interface_declaration
811 { end_class_declaration (0); }
812 | empty_statement
813 | error
814 {
815 YYERROR_NOW;
816 yyerror ("Class or interface declaration expected");
817 }
818 ;
819
820 /* 19.7 Shortened from the original:
821 modifiers: modifier | modifiers modifier
822 modifier: any of public... */
823 modifiers:
824 MODIFIER_TK
825 {
826 $$ = (1 << $1);
827 }
828 | modifiers MODIFIER_TK
829 {
830 int acc = (1 << $2);
831 if ($$ & acc)
832 parse_error_context
833 (ctxp->modifier_ctx [$2], "Modifier %qs declared twice",
834 java_accstring_lookup (acc));
835 else
836 {
837 $$ |= acc;
838 }
839 }
840 ;
841
842 /* 19.8.1 Production from $8.1: Class Declaration */
843 class_declaration:
844 modifiers CLASS_TK identifier super interfaces
845 { create_class ($1, $3, $4, $5); }
846 class_body
847 {;}
848 | CLASS_TK identifier super interfaces
849 { create_class (0, $2, $3, $4); }
850 class_body
851 {;}
852 | modifiers CLASS_TK error
853 { yyerror ("Missing class name"); RECOVER; }
854 | CLASS_TK error
855 { yyerror ("Missing class name"); RECOVER; }
856 | CLASS_TK identifier error
857 {
858 if (!ctxp->class_err) yyerror ("'{' expected");
859 DRECOVER(class1);
860 }
861 | modifiers CLASS_TK identifier error
862 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
863 ;
864
865 super:
866 { $$ = NULL; }
867 | EXTENDS_TK class_type
868 { $$ = $2; }
869 | EXTENDS_TK class_type error
870 {yyerror ("'{' expected"); ctxp->class_err=1;}
871 | EXTENDS_TK error
872 {yyerror ("Missing super class name"); ctxp->class_err=1;}
873 ;
874
875 interfaces:
876 { $$ = NULL_TREE; }
877 | IMPLEMENTS_TK interface_type_list
878 { $$ = $2; }
879 | IMPLEMENTS_TK error
880 {
881 ctxp->class_err=1;
882 yyerror ("Missing interface name");
883 }
884 ;
885
886 interface_type_list:
887 interface_type
888 {
889 ctxp->interface_number = 1;
890 $$ = build_tree_list ($1, NULL_TREE);
891 }
892 | interface_type_list C_TK interface_type
893 {
894 ctxp->interface_number++;
895 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
896 }
897 | interface_type_list C_TK error
898 {yyerror ("Missing interface name"); RECOVER;}
899 ;
900
901 class_body:
902 OCB_TK CCB_TK
903 {
904 $$ = GET_CPC ();
905 }
906 | OCB_TK class_body_declarations CCB_TK
907 {
908 $$ = GET_CPC ();
909 }
910 ;
911
912 class_body_declarations:
913 class_body_declaration
914 | class_body_declarations class_body_declaration
915 ;
916
917 class_body_declaration:
918 class_member_declaration
919 | static_initializer
920 | constructor_declaration
921 | block /* Added, JDK1.1, instance initializer */
922 {
923 if (!IS_EMPTY_STMT ($1))
924 {
925 TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
926 SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
927 }
928 }
929 ;
930
931 class_member_declaration:
932 field_declaration
933 | method_declaration
934 | class_declaration /* Added, JDK1.1 inner classes */
935 { end_class_declaration (1); }
936 | interface_declaration /* Added, JDK1.1 inner interfaces */
937 { end_class_declaration (1); }
938 | empty_statement
939 ;
940
941 /* 19.8.2 Productions from 8.3: Field Declarations */
942 field_declaration:
943 type variable_declarators SC_TK
944 { register_fields (0, $1, $2); }
945 | modifiers type variable_declarators SC_TK
946 {
947 check_modifiers
948 ("Illegal modifier %qs for field declaration",
949 $1, FIELD_MODIFIERS);
950 check_modifiers_consistency ($1);
951 register_fields ($1, $2, $3);
952 }
953 ;
954
955 variable_declarators:
956 /* Should we use build_decl_list () instead ? FIXME */
957 variable_declarator /* Default rule */
958 | variable_declarators C_TK variable_declarator
959 { $$ = chainon ($1, $3); }
960 | variable_declarators C_TK error
961 {yyerror ("Missing term"); RECOVER;}
962 ;
963
964 variable_declarator:
965 variable_declarator_id
966 { $$ = build_tree_list ($1, NULL_TREE); }
967 | variable_declarator_id ASSIGN_TK variable_initializer
968 {
969 if (java_error_count)
970 $3 = NULL_TREE;
971 $$ = build_tree_list
972 ($1, build_assignment ($2.token, $2.location, $1, $3));
973 }
974 | variable_declarator_id ASSIGN_TK error
975 {
976 yyerror ("Missing variable initializer");
977 $$ = build_tree_list ($1, NULL_TREE);
978 RECOVER;
979 }
980 | variable_declarator_id ASSIGN_TK variable_initializer error
981 {
982 yyerror ("';' expected");
983 $$ = build_tree_list ($1, NULL_TREE);
984 RECOVER;
985 }
986 ;
987
988 variable_declarator_id:
989 identifier
990 | variable_declarator_id OSB_TK CSB_TK
991 { $$ = build_unresolved_array_type ($1); }
992 | identifier error
993 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
994 | variable_declarator_id OSB_TK error
995 {
996 yyerror ("']' expected");
997 DRECOVER(vdi);
998 }
999 | variable_declarator_id CSB_TK error
1000 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
1001 ;
1002
1003 variable_initializer:
1004 expression
1005 | array_initializer
1006 ;
1007
1008 /* 19.8.3 Productions from 8.4: Method Declarations */
1009 method_declaration:
1010 method_header
1011 {
1012 current_function_decl = $1;
1013 if (current_function_decl
1014 && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1015 source_start_java_method (current_function_decl);
1016 else
1017 current_function_decl = NULL_TREE;
1018 }
1019 method_body
1020 { finish_method_declaration ($3); }
1021 | method_header error
1022 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1023 ;
1024
1025 method_header:
1026 type method_declarator throws
1027 { $$ = method_header (0, $1, $2, $3); }
1028 | VOID_TK method_declarator throws
1029 { $$ = method_header (0, void_type_node, $2, $3); }
1030 | modifiers type method_declarator throws
1031 { $$ = method_header ($1, $2, $3, $4); }
1032 | modifiers VOID_TK method_declarator throws
1033 { $$ = method_header ($1, void_type_node, $3, $4); }
1034 | type error
1035 {
1036 yyerror ("Invalid method declaration, method name required");
1037 $$ = NULL_TREE;
1038 RECOVER;
1039 }
1040 | modifiers type error
1041 {
1042 yyerror ("Identifier expected");
1043 $$ = NULL_TREE;
1044 RECOVER;
1045 }
1046 | VOID_TK error
1047 {
1048 yyerror ("Identifier expected");
1049 $$ = NULL_TREE;
1050 RECOVER;
1051 }
1052 | modifiers VOID_TK error
1053 {
1054 yyerror ("Identifier expected");
1055 $$ = NULL_TREE;
1056 RECOVER;
1057 }
1058 | modifiers error
1059 {
1060 yyerror ("Invalid method declaration, return type required");
1061 $$ = NULL_TREE;
1062 RECOVER;
1063 }
1064 ;
1065
1066 method_declarator:
1067 identifier OP_TK CP_TK
1068 {
1069 ctxp->formal_parameter_number = 0;
1070 $$ = method_declarator ($1, NULL_TREE);
1071 }
1072 | identifier OP_TK formal_parameter_list CP_TK
1073 { $$ = method_declarator ($1, $3); }
1074 | method_declarator OSB_TK CSB_TK
1075 {
1076 SET_EXPR_LOCATION_FROM_TOKEN (wfl_operator, $2);
1077 TREE_PURPOSE ($1) =
1078 build_unresolved_array_type (TREE_PURPOSE ($1));
1079 parse_warning_context
1080 (wfl_operator,
1081 "Discouraged form of returned type specification");
1082 }
1083 | identifier OP_TK error
1084 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1085 | method_declarator OSB_TK error
1086 {yyerror ("']' expected"); RECOVER;}
1087 ;
1088
1089 formal_parameter_list:
1090 formal_parameter
1091 {
1092 ctxp->formal_parameter_number = 1;
1093 }
1094 | formal_parameter_list C_TK formal_parameter
1095 {
1096 ctxp->formal_parameter_number += 1;
1097 $$ = chainon ($1, $3);
1098 }
1099 | formal_parameter_list C_TK error
1100 { yyerror ("Missing formal parameter term"); RECOVER; }
1101 ;
1102
1103 formal_parameter:
1104 type variable_declarator_id
1105 {
1106 $$ = build_tree_list ($2, $1);
1107 }
1108 | final type variable_declarator_id /* Added, JDK1.1 final parms */
1109 {
1110 $$ = build_tree_list ($3, $2);
1111 ARG_FINAL_P ($$) = 1;
1112 }
1113 | type error
1114 {
1115 yyerror ("Missing identifier"); RECOVER;
1116 $$ = NULL_TREE;
1117 }
1118 | final type error
1119 {
1120 yyerror ("Missing identifier"); RECOVER;
1121 $$ = NULL_TREE;
1122 }
1123 ;
1124
1125 final:
1126 modifiers
1127 {
1128 check_modifiers ("Illegal modifier %qs. Only %<final%> was expected here",
1129 $1, ACC_FINAL);
1130 if ($1 != ACC_FINAL)
1131 MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1132 }
1133 ;
1134
1135 throws:
1136 { $$ = NULL_TREE; }
1137 | THROWS_TK class_type_list
1138 { $$ = $2; }
1139 | THROWS_TK error
1140 {yyerror ("Missing class type term"); RECOVER;}
1141 ;
1142
1143 class_type_list:
1144 class_type
1145 { $$ = build_tree_list ($1, $1); }
1146 | class_type_list C_TK class_type
1147 { $$ = tree_cons ($3, $3, $1); }
1148 | class_type_list C_TK error
1149 {yyerror ("Missing class type term"); RECOVER;}
1150 ;
1151
1152 method_body:
1153 block
1154 | SC_TK { $$ = NULL_TREE; }
1155 ;
1156
1157 /* 19.8.4 Productions from 8.5: Static Initializers */
1158 static_initializer:
1159 static block
1160 {
1161 TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1162 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1163 current_static_block = NULL_TREE;
1164 }
1165 ;
1166
1167 static: /* Test lval.sub_token here */
1168 modifiers
1169 {
1170 check_modifiers ("Illegal modifier %qs for static initializer", $1, ACC_STATIC);
1171 /* Can't have a static initializer in an innerclass */
1172 if ($1 | ACC_STATIC &&
1173 GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1174 parse_error_context
1175 (MODIFIER_WFL (STATIC_TK),
1176 "Can't define static initializer in class %qs. Static initializer can only be defined in top-level classes",
1177 IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1178 SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1179 }
1180 ;
1181
1182 /* 19.8.5 Productions from 8.6: Constructor Declarations */
1183 constructor_declaration:
1184 constructor_header
1185 {
1186 current_function_decl = $1;
1187 source_start_java_method (current_function_decl);
1188 }
1189 constructor_body
1190 { finish_method_declaration ($3); }
1191 ;
1192
1193 constructor_header:
1194 constructor_declarator throws
1195 { $$ = method_header (0, NULL_TREE, $1, $2); }
1196 | modifiers constructor_declarator throws
1197 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1198 ;
1199
1200 constructor_declarator:
1201 simple_name OP_TK CP_TK
1202 {
1203 ctxp->formal_parameter_number = 0;
1204 $$ = method_declarator ($1, NULL_TREE);
1205 }
1206 | simple_name OP_TK formal_parameter_list CP_TK
1207 { $$ = method_declarator ($1, $3); }
1208 ;
1209
1210 constructor_body:
1211 /* Unlike regular method, we always need a complete (empty)
1212 body so we can safely perform all the required code
1213 addition (super invocation and field initialization) */
1214 block_begin constructor_block_end
1215 {
1216 BLOCK_EXPR_BODY ($2) = build_java_empty_stmt ();
1217 $$ = $2;
1218 }
1219 | block_begin explicit_constructor_invocation constructor_block_end
1220 { $$ = $3; }
1221 | block_begin block_statements constructor_block_end
1222 { $$ = $3; }
1223 | block_begin explicit_constructor_invocation block_statements constructor_block_end
1224 { $$ = $4; }
1225 ;
1226
1227 constructor_block_end:
1228 block_end
1229 ;
1230
1231 /* Error recovery for that rule moved down expression_statement: rule. */
1232 explicit_constructor_invocation:
1233 this_or_super OP_TK CP_TK SC_TK
1234 {
1235 $$ = build_method_invocation ($1, NULL_TREE);
1236 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1237 $$ = java_method_add_stmt (current_function_decl, $$);
1238 }
1239 | this_or_super OP_TK argument_list CP_TK SC_TK
1240 {
1241 $$ = build_method_invocation ($1, $3);
1242 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1243 $$ = java_method_add_stmt (current_function_decl, $$);
1244 }
1245 /* Added, JDK1.1 inner classes. Modified because the rule
1246 'primary' couldn't work. */
1247 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1248 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1249 | name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1250 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1251 ;
1252
1253 this_or_super: /* Added, simplifies error diagnostics */
1254 THIS_TK
1255 {
1256 tree wfl = build_wfl_node (this_identifier_node);
1257 SET_EXPR_LOCATION_FROM_TOKEN (wfl, $1);
1258 $$ = wfl;
1259 }
1260 | SUPER_TK
1261 {
1262 tree wfl = build_wfl_node (super_identifier_node);
1263 SET_EXPR_LOCATION_FROM_TOKEN (wfl, $1);
1264 $$ = wfl;
1265 }
1266 ;
1267
1268 /* 19.9 Productions from 9: Interfaces */
1269 /* 19.9.1 Productions from 9.1: Interfaces Declarations */
1270 interface_declaration:
1271 INTERFACE_TK identifier
1272 { create_interface (0, $2, NULL_TREE); }
1273 interface_body
1274 { ; }
1275 | modifiers INTERFACE_TK identifier
1276 { create_interface ($1, $3, NULL_TREE); }
1277 interface_body
1278 { ; }
1279 | INTERFACE_TK identifier extends_interfaces
1280 { create_interface (0, $2, $3); }
1281 interface_body
1282 { ; }
1283 | modifiers INTERFACE_TK identifier extends_interfaces
1284 { create_interface ($1, $3, $4); }
1285 interface_body
1286 { ; }
1287 | INTERFACE_TK identifier error
1288 { yyerror ("'{' expected"); RECOVER; }
1289 | modifiers INTERFACE_TK identifier error
1290 { yyerror ("'{' expected"); RECOVER; }
1291 ;
1292
1293 extends_interfaces:
1294 EXTENDS_TK interface_type
1295 {
1296 ctxp->interface_number = 1;
1297 $$ = build_tree_list ($2, NULL_TREE);
1298 }
1299 | extends_interfaces C_TK interface_type
1300 {
1301 ctxp->interface_number++;
1302 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1303 }
1304 | EXTENDS_TK error
1305 {yyerror ("Invalid interface type"); RECOVER;}
1306 | extends_interfaces C_TK error
1307 {yyerror ("Missing term"); RECOVER;}
1308 ;
1309
1310 interface_body:
1311 OCB_TK CCB_TK
1312 { $$ = NULL_TREE; }
1313 | OCB_TK interface_member_declarations CCB_TK
1314 { $$ = NULL_TREE; }
1315 ;
1316
1317 interface_member_declarations:
1318 interface_member_declaration
1319 | interface_member_declarations interface_member_declaration
1320 ;
1321
1322 interface_member_declaration:
1323 constant_declaration
1324 | abstract_method_declaration
1325 | class_declaration /* Added, JDK1.1 inner classes */
1326 { end_class_declaration (1); }
1327 | interface_declaration /* Added, JDK1.1 inner interfaces */
1328 { end_class_declaration (1); }
1329 | empty_statement
1330 ;
1331
1332 constant_declaration:
1333 field_declaration
1334 ;
1335
1336 abstract_method_declaration:
1337 method_header SC_TK
1338 {
1339 check_abstract_method_header ($1);
1340 current_function_decl = NULL_TREE; /* FIXME ? */
1341 }
1342 | method_header error
1343 {yyerror ("';' expected"); RECOVER;}
1344 ;
1345
1346 /* 19.10 Productions from 10: Arrays */
1347 array_initializer:
1348 OCB_TK CCB_TK
1349 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1350 | OCB_TK C_TK CCB_TK
1351 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1352 | OCB_TK variable_initializers CCB_TK
1353 { $$ = build_new_array_init ($1.location, $2); }
1354 | OCB_TK variable_initializers C_TK CCB_TK
1355 { $$ = build_new_array_init ($1.location, $2); }
1356 ;
1357
1358 variable_initializers:
1359 variable_initializer
1360 {
1361 $$ = tree_cons (maybe_build_array_element_wfl ($1),
1362 $1, NULL_TREE);
1363 }
1364 | variable_initializers C_TK variable_initializer
1365 {
1366 $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1367 }
1368 | variable_initializers C_TK error
1369 {yyerror ("Missing term"); RECOVER;}
1370 ;
1371
1372 /* 19.11 Production from 14: Blocks and Statements */
1373 block:
1374 block_begin block_end
1375 { $$ = $2; }
1376 | block_begin block_statements block_end
1377 { $$ = $3; }
1378 ;
1379
1380 block_begin:
1381 OCB_TK
1382 { enter_block (); }
1383 ;
1384
1385 block_end:
1386 CCB_TK
1387 {
1388 maybe_absorb_scoping_blocks ();
1389 $$ = exit_block ();
1390 if (!BLOCK_SUBBLOCKS ($$))
1391 BLOCK_SUBBLOCKS ($$) = build_java_empty_stmt ();
1392 }
1393 ;
1394
1395 block_statements:
1396 block_statement
1397 | block_statements block_statement
1398 ;
1399
1400 block_statement:
1401 local_variable_declaration_statement
1402 | statement
1403 { java_method_add_stmt (current_function_decl, $1); }
1404 | class_declaration /* Added, JDK1.1 local classes */
1405 {
1406 LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1407 end_class_declaration (1);
1408 }
1409 ;
1410
1411 local_variable_declaration_statement:
1412 local_variable_declaration SC_TK /* Can't catch missing ';' here */
1413 ;
1414
1415 local_variable_declaration:
1416 type variable_declarators
1417 { declare_local_variables (0, $1, $2); }
1418 | final type variable_declarators /* Added, JDK1.1 final locals */
1419 { declare_local_variables ($1, $2, $3); }
1420 ;
1421
1422 statement:
1423 statement_without_trailing_substatement
1424 | labeled_statement
1425 | if_then_statement
1426 | if_then_else_statement
1427 | while_statement
1428 | for_statement
1429 { $$ = exit_block (); }
1430 ;
1431
1432 statement_nsi:
1433 statement_without_trailing_substatement
1434 | labeled_statement_nsi
1435 | if_then_else_statement_nsi
1436 | while_statement_nsi
1437 | for_statement_nsi
1438 { $$ = exit_block (); }
1439 ;
1440
1441 statement_without_trailing_substatement:
1442 block
1443 | empty_statement
1444 | expression_statement
1445 | switch_statement
1446 | do_statement
1447 | break_statement
1448 | continue_statement
1449 | return_statement
1450 | synchronized_statement
1451 | throw_statement
1452 | try_statement
1453 | assert_statement
1454 ;
1455
1456 empty_statement:
1457 SC_TK
1458 {
1459 if (flag_extraneous_semicolon
1460 && ! current_static_block
1461 && (! current_function_decl ||
1462 /* Verify we're not in a inner class declaration */
1463 (GET_CPC () != TYPE_NAME
1464 (DECL_CONTEXT (current_function_decl)))))
1465
1466 {
1467 #ifdef USE_MAPPED_LOCATION
1468 SET_EXPR_LOCATION (wfl_operator, input_location);
1469 #else
1470 EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1471 #endif
1472 parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1473 }
1474 $$ = build_java_empty_stmt ();
1475 }
1476 ;
1477
1478 label_decl:
1479 identifier REL_CL_TK
1480 {
1481 $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1482 EXPR_WFL_NODE ($1));
1483 pushlevel (2);
1484 push_labeled_block ($$);
1485 PUSH_LABELED_BLOCK ($$);
1486 }
1487 ;
1488
1489 labeled_statement:
1490 label_decl statement
1491 { $$ = finish_labeled_statement ($1, $2); }
1492 | identifier error
1493 {yyerror ("':' expected"); RECOVER;}
1494 ;
1495
1496 labeled_statement_nsi:
1497 label_decl statement_nsi
1498 { $$ = finish_labeled_statement ($1, $2); }
1499 ;
1500
1501 /* We concentrate here a bunch of error handling rules that we couldn't write
1502 earlier, because expression_statement catches a missing ';'. */
1503 expression_statement:
1504 statement_expression SC_TK
1505 {
1506 /* We have a statement. Generate a WFL around it so
1507 we can debug it */
1508 #ifdef USE_MAPPED_LOCATION
1509 $$ = expr_add_location ($1, input_location, 1);
1510 #else
1511 $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1512 JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1513 #endif
1514 /* We know we have a statement, so set the debug
1515 info to be eventually generate here. */
1516 }
1517 | error SC_TK
1518 {
1519 YYNOT_TWICE yyerror ("Invalid expression statement");
1520 DRECOVER (expr_stmt);
1521 }
1522 | error OCB_TK
1523 {
1524 YYNOT_TWICE yyerror ("Invalid expression statement");
1525 DRECOVER (expr_stmt);
1526 }
1527 | error CCB_TK
1528 {
1529 YYNOT_TWICE yyerror ("Invalid expression statement");
1530 DRECOVER (expr_stmt);
1531 }
1532 | this_or_super OP_TK error
1533 {yyerror ("')' expected"); RECOVER;}
1534 | this_or_super OP_TK CP_TK error
1535 {
1536 parse_ctor_invocation_error ();
1537 RECOVER;
1538 }
1539 | this_or_super OP_TK argument_list error
1540 {yyerror ("')' expected"); RECOVER;}
1541 | this_or_super OP_TK argument_list CP_TK error
1542 {
1543 parse_ctor_invocation_error ();
1544 RECOVER;
1545 }
1546 | name DOT_TK SUPER_TK error
1547 {yyerror ("'(' expected"); RECOVER;}
1548 | name DOT_TK SUPER_TK OP_TK error
1549 {yyerror ("')' expected"); RECOVER;}
1550 | name DOT_TK SUPER_TK OP_TK argument_list error
1551 {yyerror ("')' expected"); RECOVER;}
1552 | name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1553 {yyerror ("';' expected"); RECOVER;}
1554 | name DOT_TK SUPER_TK OP_TK CP_TK error
1555 {yyerror ("';' expected"); RECOVER;}
1556 ;
1557
1558 statement_expression:
1559 assignment
1560 | pre_increment_expression
1561 | pre_decrement_expression
1562 | post_increment_expression
1563 | post_decrement_expression
1564 | method_invocation
1565 | class_instance_creation_expression
1566 ;
1567
1568 if_then_statement:
1569 IF_TK OP_TK expression CP_TK statement
1570 {
1571 $$ = build_if_else_statement ($2.location, $3,
1572 $5, NULL_TREE);
1573 }
1574 | IF_TK error
1575 {yyerror ("'(' expected"); RECOVER;}
1576 | IF_TK OP_TK error
1577 {yyerror ("Missing term"); RECOVER;}
1578 | IF_TK OP_TK expression error
1579 {yyerror ("')' expected"); RECOVER;}
1580 ;
1581
1582 if_then_else_statement:
1583 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1584 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1585 ;
1586
1587 if_then_else_statement_nsi:
1588 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1589 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1590 ;
1591
1592 switch_statement:
1593 switch_expression
1594 {
1595 enter_block ();
1596 }
1597 switch_block
1598 {
1599 /* Make into "proper list" of COMPOUND_EXPRs.
1600 I.e. make the last statement also have its own
1601 COMPOUND_EXPR. */
1602 maybe_absorb_scoping_blocks ();
1603 TREE_OPERAND ($1, 1) = exit_block ();
1604 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1605 }
1606 ;
1607
1608 switch_expression:
1609 SWITCH_TK OP_TK expression CP_TK
1610 {
1611 $$ = build3 (SWITCH_EXPR, NULL_TREE, $3,
1612 NULL_TREE, NULL_TREE);
1613 SET_EXPR_LOCATION_FROM_TOKEN ($$, $2);
1614 }
1615 | SWITCH_TK error
1616 {yyerror ("'(' expected"); RECOVER;}
1617 | SWITCH_TK OP_TK error
1618 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1619 | SWITCH_TK OP_TK expression CP_TK error
1620 {yyerror ("'{' expected"); RECOVER;}
1621 ;
1622
1623 /* Default assignment is there to avoid type node on switch_block
1624 node. */
1625
1626 switch_block:
1627 OCB_TK CCB_TK
1628 { $$ = NULL_TREE; }
1629 | OCB_TK switch_labels CCB_TK
1630 { $$ = NULL_TREE; }
1631 | OCB_TK switch_block_statement_groups CCB_TK
1632 { $$ = NULL_TREE; }
1633 | OCB_TK switch_block_statement_groups switch_labels CCB_TK
1634 { $$ = NULL_TREE; }
1635 ;
1636
1637 switch_block_statement_groups:
1638 switch_block_statement_group
1639 | switch_block_statement_groups switch_block_statement_group
1640 ;
1641
1642 switch_block_statement_group:
1643 switch_labels block_statements
1644 ;
1645
1646 switch_labels:
1647 switch_label
1648 | switch_labels switch_label
1649 ;
1650
1651 switch_label:
1652 CASE_TK constant_expression REL_CL_TK
1653 {
1654 tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1655 SET_EXPR_LOCATION_FROM_TOKEN (lab, $1);
1656 java_method_add_stmt (current_function_decl, lab);
1657 }
1658 | DEFAULT_TK REL_CL_TK
1659 {
1660 tree lab = make_node (DEFAULT_EXPR);
1661 SET_EXPR_LOCATION_FROM_TOKEN (lab, $1);
1662 java_method_add_stmt (current_function_decl, lab);
1663 }
1664 | CASE_TK error
1665 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1666 | CASE_TK constant_expression error
1667 {yyerror ("':' expected"); RECOVER;}
1668 | DEFAULT_TK error
1669 {yyerror ("':' expected"); RECOVER;}
1670 ;
1671
1672 while_expression:
1673 WHILE_TK OP_TK expression CP_TK
1674 {
1675 tree body = build_loop_body ($2.location, $3, 0);
1676 $$ = build_new_loop (body);
1677 }
1678 ;
1679
1680 while_statement:
1681 while_expression statement
1682 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1683 | WHILE_TK error
1684 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1685 | WHILE_TK OP_TK error
1686 {yyerror ("Missing term and ')' expected"); RECOVER;}
1687 | WHILE_TK OP_TK expression error
1688 {yyerror ("')' expected"); RECOVER;}
1689 ;
1690
1691 while_statement_nsi:
1692 while_expression statement_nsi
1693 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1694 ;
1695
1696 do_statement_begin:
1697 DO_TK
1698 {
1699 tree body = build_loop_body (0, NULL_TREE, 1);
1700 $$ = build_new_loop (body);
1701 }
1702 /* Need error handing here. FIXME */
1703 ;
1704
1705 do_statement:
1706 do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1707 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1708 ;
1709
1710 for_statement:
1711 for_begin SC_TK expression SC_TK for_update CP_TK statement
1712 {
1713 if (CONSTANT_CLASS_P ($3))
1714 $3 = build_wfl_node ($3);
1715 $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1716 }
1717 | for_begin SC_TK SC_TK for_update CP_TK statement
1718 {
1719 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1720 /* We have not condition, so we get rid of the EXIT_EXPR */
1721 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1722 build_java_empty_stmt ();
1723 }
1724 | for_begin SC_TK error
1725 {yyerror ("Invalid control expression"); RECOVER;}
1726 | for_begin SC_TK expression SC_TK error
1727 {yyerror ("Invalid update expression"); RECOVER;}
1728 | for_begin SC_TK SC_TK error
1729 {yyerror ("Invalid update expression"); RECOVER;}
1730 ;
1731
1732 for_statement_nsi:
1733 for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1734 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1735 | for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1736 {
1737 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1738 /* We have not condition, so we get rid of the EXIT_EXPR */
1739 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1740 build_java_empty_stmt ();
1741 }
1742 ;
1743
1744 for_header:
1745 FOR_TK OP_TK
1746 {
1747 /* This scope defined for local variable that may be
1748 defined within the scope of the for loop */
1749 enter_block ();
1750 }
1751 | FOR_TK error
1752 {yyerror ("'(' expected"); DRECOVER(for_1);}
1753 | FOR_TK OP_TK error
1754 {yyerror ("Invalid init statement"); RECOVER;}
1755 ;
1756
1757 for_begin:
1758 for_header for_init
1759 {
1760 /* We now declare the loop body. The loop is
1761 declared as a for loop. */
1762 tree body = build_loop_body (0, NULL_TREE, 0);
1763 $$ = build_new_loop (body);
1764 FOR_LOOP_P ($$) = 1;
1765 /* The loop is added to the current block the for
1766 statement is defined within */
1767 java_method_add_stmt (current_function_decl, $$);
1768 }
1769 ;
1770 for_init: /* Can be empty */
1771 { $$ = build_java_empty_stmt (); }
1772 | statement_expression_list
1773 {
1774 /* Init statement recorded within the previously
1775 defined block scope */
1776 $$ = java_method_add_stmt (current_function_decl, $1);
1777 }
1778 | local_variable_declaration
1779 {
1780 /* Local variable are recorded within the previously
1781 defined block scope */
1782 $$ = NULL_TREE;
1783 }
1784 | statement_expression_list error
1785 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1786 ;
1787
1788 for_update: /* Can be empty */
1789 {$$ = build_java_empty_stmt ();}
1790 | statement_expression_list
1791 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1792 ;
1793
1794 statement_expression_list:
1795 statement_expression
1796 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1797 | statement_expression_list C_TK statement_expression
1798 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1799 | statement_expression_list C_TK error
1800 {yyerror ("Missing term"); RECOVER;}
1801 ;
1802
1803 break_statement:
1804 BREAK_TK SC_TK
1805 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1806 | BREAK_TK identifier SC_TK
1807 { $$ = build_bc_statement ($1.location, 1, $2); }
1808 | BREAK_TK error
1809 {yyerror ("Missing term"); RECOVER;}
1810 | BREAK_TK identifier error
1811 {yyerror ("';' expected"); RECOVER;}
1812 ;
1813
1814 continue_statement:
1815 CONTINUE_TK SC_TK
1816 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1817 | CONTINUE_TK identifier SC_TK
1818 { $$ = build_bc_statement ($1.location, 0, $2); }
1819 | CONTINUE_TK error
1820 {yyerror ("Missing term"); RECOVER;}
1821 | CONTINUE_TK identifier error
1822 {yyerror ("';' expected"); RECOVER;}
1823 ;
1824
1825 return_statement:
1826 RETURN_TK SC_TK
1827 { $$ = build_return ($1.location, NULL_TREE); }
1828 | RETURN_TK expression SC_TK
1829 { $$ = build_return ($1.location, $2); }
1830 | RETURN_TK error
1831 {yyerror ("Missing term"); RECOVER;}
1832 | RETURN_TK expression error
1833 {yyerror ("';' expected"); RECOVER;}
1834 ;
1835
1836 throw_statement:
1837 THROW_TK expression SC_TK
1838 {
1839 $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1840 SET_EXPR_LOCATION_FROM_TOKEN ($$, $1);
1841 }
1842 | THROW_TK error
1843 {yyerror ("Missing term"); RECOVER;}
1844 | THROW_TK expression error
1845 {yyerror ("';' expected"); RECOVER;}
1846 ;
1847
1848 assert_statement:
1849 ASSERT_TK expression REL_CL_TK expression SC_TK
1850 {
1851 $$ = build_assertion ($1.location, $2, $4);
1852 }
1853 | ASSERT_TK expression SC_TK
1854 {
1855 $$ = build_assertion ($1.location, $2, NULL_TREE);
1856 }
1857 | ASSERT_TK error
1858 {yyerror ("Missing term"); RECOVER;}
1859 | ASSERT_TK expression error
1860 {yyerror ("';' expected"); RECOVER;}
1861 ;
1862
1863 synchronized_statement:
1864 synchronized OP_TK expression CP_TK block
1865 {
1866 $$ = build2 (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1867 EXPR_WFL_LINECOL ($$) =
1868 EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1869 }
1870 | synchronized OP_TK expression CP_TK error
1871 {yyerror ("'{' expected"); RECOVER;}
1872 | synchronized error
1873 {yyerror ("'(' expected"); RECOVER;}
1874 | synchronized OP_TK error CP_TK
1875 {yyerror ("Missing term"); RECOVER;}
1876 | synchronized OP_TK error
1877 {yyerror ("Missing term"); RECOVER;}
1878 ;
1879
1880 synchronized:
1881 modifiers
1882 {
1883 check_modifiers (
1884 "Illegal modifier %qs. Only %<synchronized%> was expected here",
1885 $1, ACC_SYNCHRONIZED);
1886 if ($1 != ACC_SYNCHRONIZED)
1887 MODIFIER_WFL (SYNCHRONIZED_TK) =
1888 build_wfl_node (NULL_TREE);
1889 }
1890 ;
1891
1892 try_statement:
1893 TRY_TK block catches
1894 { $$ = build_try_statement ($1.location, $2, $3); }
1895 | TRY_TK block finally
1896 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1897 | TRY_TK block catches finally
1898 { $$ = build_try_finally_statement
1899 ($1.location, build_try_statement ($1.location,
1900 $2, $3), $4);
1901 }
1902 | TRY_TK error
1903 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1904 ;
1905
1906 catches:
1907 catch_clause
1908 | catches catch_clause
1909 {
1910 TREE_CHAIN ($2) = $1;
1911 $$ = $2;
1912 }
1913 ;
1914
1915 catch_clause:
1916 catch_clause_parameter block
1917 {
1918 java_method_add_stmt (current_function_decl, $2);
1919 exit_block ();
1920 $$ = $1;
1921 }
1922 ;
1923
1924 catch_clause_parameter:
1925 CATCH_TK OP_TK formal_parameter CP_TK
1926 {
1927 /* We add a block to define a scope for
1928 formal_parameter (CCBP). The formal parameter is
1929 declared initialized by the appropriate function
1930 call */
1931 tree ccpb;
1932 tree init;
1933 if ($3)
1934 {
1935 ccpb = enter_block ();
1936 init = build_assignment
1937 (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1938 build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1939 declare_local_variables (0, TREE_VALUE ($3),
1940 build_tree_list
1941 (TREE_PURPOSE ($3), init));
1942 $$ = build1 (JAVA_CATCH_EXPR, NULL_TREE, ccpb);
1943 SET_EXPR_LOCATION_FROM_TOKEN ($$, $1);
1944 }
1945 else
1946 {
1947 $$ = error_mark_node;
1948 }
1949 }
1950 | CATCH_TK error
1951 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1952 | CATCH_TK OP_TK error
1953 {
1954 yyerror ("Missing term or ')' expected");
1955 RECOVER; $$ = NULL_TREE;
1956 }
1957 | CATCH_TK OP_TK error CP_TK /* That's for () */
1958 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1959 ;
1960
1961 finally:
1962 FINALLY_TK block
1963 { $$ = $2; }
1964 | FINALLY_TK error
1965 {yyerror ("'{' expected"); RECOVER; }
1966 ;
1967
1968 /* 19.12 Production from 15: Expressions */
1969 primary:
1970 primary_no_new_array
1971 | array_creation_uninitialized
1972 | array_creation_initialized
1973 ;
1974
1975 primary_no_new_array:
1976 literal
1977 | THIS_TK
1978 { $$ = build_this ($1.location); }
1979 | OP_TK expression CP_TK
1980 {$$ = $2;}
1981 | class_instance_creation_expression
1982 | field_access
1983 | method_invocation
1984 | array_access
1985 | type_literals
1986 /* Added, JDK1.1 inner classes. Documentation is wrong
1987 referring to a 'ClassName' (class_name) rule that doesn't
1988 exist. Used name: instead. */
1989 | name DOT_TK THIS_TK
1990 {
1991 tree wfl = build_wfl_node (this_identifier_node);
1992 $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1993 }
1994 | OP_TK expression error
1995 {yyerror ("')' expected"); RECOVER;}
1996 | name DOT_TK error
1997 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1998 | primitive_type DOT_TK error
1999 {yyerror ("'class' expected" ); RECOVER;}
2000 | VOID_TK DOT_TK error
2001 {yyerror ("'class' expected" ); RECOVER;}
2002 ;
2003
2004 type_literals:
2005 name DOT_TK CLASS_TK
2006 { $$ = build_incomplete_class_ref ($2.location, $1); }
2007 | array_type DOT_TK CLASS_TK
2008 { $$ = build_incomplete_class_ref ($2.location, $1); }
2009 | primitive_type DOT_TK CLASS_TK
2010 { $$ = build_incomplete_class_ref ($2.location, $1); }
2011 | VOID_TK DOT_TK CLASS_TK
2012 {
2013 $$ = build_incomplete_class_ref ($2.location,
2014 void_type_node);
2015 }
2016 ;
2017
2018 class_instance_creation_expression:
2019 NEW_TK class_type OP_TK argument_list CP_TK
2020 { $$ = build_new_invocation ($2, $4); }
2021 | NEW_TK class_type OP_TK CP_TK
2022 { $$ = build_new_invocation ($2, NULL_TREE); }
2023 | anonymous_class_creation
2024 /* Added, JDK1.1 inner classes, modified to use name or
2025 primary instead of primary solely which couldn't work in
2026 all situations. */
2027 | something_dot_new identifier OP_TK CP_TK
2028 {
2029 tree ctor = build_new_invocation ($2, NULL_TREE);
2030 $$ = make_qualified_primary ($1, ctor,
2031 EXPR_WFL_LINECOL ($1));
2032 }
2033 | something_dot_new identifier OP_TK CP_TK class_body
2034 | something_dot_new identifier OP_TK argument_list CP_TK
2035 {
2036 tree ctor = build_new_invocation ($2, $4);
2037 $$ = make_qualified_primary ($1, ctor,
2038 EXPR_WFL_LINECOL ($1));
2039 }
2040 | something_dot_new identifier OP_TK argument_list CP_TK class_body
2041 | NEW_TK error SC_TK
2042 {$$ = NULL_TREE; yyerror ("'(' expected"); DRECOVER(new_1);}
2043 | NEW_TK class_type error
2044 {$$ = NULL_TREE; yyerror ("'(' expected"); RECOVER;}
2045 | NEW_TK class_type OP_TK error
2046 {$$ = NULL_TREE; yyerror ("')' or term expected"); RECOVER;}
2047 | NEW_TK class_type OP_TK argument_list error
2048 {$$ = NULL_TREE; yyerror ("')' expected"); RECOVER;}
2049 | something_dot_new error
2050 {
2051 $$ = NULL_TREE;
2052 YYERROR_NOW;
2053 yyerror ("Identifier expected");
2054 RECOVER;
2055 }
2056 | something_dot_new identifier error
2057 {$$ = NULL_TREE; yyerror ("'(' expected"); RECOVER;}
2058 ;
2059
2060 /* Created after JDK1.1 rules originally added to
2061 class_instance_creation_expression, but modified to use
2062 'class_type' instead of 'TypeName' (type_name) which is mentioned
2063 in the documentation but doesn't exist. */
2064
2065 anonymous_class_creation:
2066 NEW_TK class_type OP_TK argument_list CP_TK
2067 { create_anonymous_class ($2); }
2068 class_body
2069 {
2070 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2071 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2072
2073 end_class_declaration (1);
2074
2075 /* Now we can craft the new expression */
2076 $$ = build_new_invocation (id, $4);
2077
2078 /* Note that we can't possibly be here if
2079 `class_type' is an interface (in which case the
2080 anonymous class extends Object and implements
2081 `class_type', hence its constructor can't have
2082 arguments.) */
2083
2084 /* Otherwise, the innerclass must feature a
2085 constructor matching `argument_list'. Anonymous
2086 classes are a bit special: it's impossible to
2087 define constructor for them, hence constructors
2088 must be generated following the hints provided by
2089 the `new' expression. Whether a super constructor
2090 of that nature exists or not is to be verified
2091 later on in get_constructor_super.
2092
2093 It's during the expansion of a `new' statement
2094 referring to an anonymous class that a ctor will
2095 be generated for the anonymous class, with the
2096 right arguments. */
2097
2098 }
2099 | NEW_TK class_type OP_TK CP_TK
2100 { create_anonymous_class ($2); }
2101 class_body
2102 {
2103 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2104 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2105
2106 end_class_declaration (1);
2107
2108 /* Now we can craft the new expression. The
2109 statement doesn't need to be remember so that a
2110 constructor can be generated, since its signature
2111 is already known. */
2112 $$ = build_new_invocation (id, NULL_TREE);
2113 }
2114 ;
2115
2116 something_dot_new: /* Added, not part of the specs. */
2117 name DOT_TK NEW_TK
2118 { $$ = $1; }
2119 | primary DOT_TK NEW_TK
2120 { $$ = $1; }
2121 ;
2122
2123 argument_list:
2124 expression
2125 {
2126 $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2127 ctxp->formal_parameter_number = 1;
2128 }
2129 | argument_list C_TK expression
2130 {
2131 ctxp->formal_parameter_number += 1;
2132 $$ = tree_cons (NULL_TREE, $3, $1);
2133 }
2134 | argument_list C_TK error
2135 {yyerror ("Missing term"); RECOVER;}
2136 ;
2137
2138 array_creation_uninitialized:
2139 NEW_TK primitive_type dim_exprs
2140 { $$ = build_newarray_node ($2, $3, 0); }
2141 | NEW_TK class_or_interface_type dim_exprs
2142 { $$ = build_newarray_node ($2, $3, 0); }
2143 | NEW_TK primitive_type dim_exprs dims
2144 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2145 | NEW_TK class_or_interface_type dim_exprs dims
2146 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2147 | NEW_TK error CSB_TK
2148 {yyerror ("'[' expected"); DRECOVER ("]");}
2149 | NEW_TK error OSB_TK
2150 {yyerror ("']' expected"); RECOVER;}
2151 ;
2152
2153 array_creation_initialized:
2154 /* Added, JDK1.1 anonymous array. Initial documentation rule
2155 modified */
2156 NEW_TK class_or_interface_type dims array_initializer
2157 {
2158 char *sig;
2159 int osb = pop_current_osb (ctxp);
2160 while (osb--)
2161 obstack_grow (&temporary_obstack, "[]", 2);
2162 obstack_1grow (&temporary_obstack, '\0');
2163 sig = obstack_finish (&temporary_obstack);
2164 $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2165 $2, get_identifier (sig), $4);
2166 }
2167 | NEW_TK primitive_type dims array_initializer
2168 {
2169 int osb = pop_current_osb (ctxp);
2170 tree type = $2;
2171 while (osb--)
2172 type = build_java_array_type (type, -1);
2173 $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2174 build_pointer_type (type), NULL_TREE, $4);
2175 }
2176 | NEW_TK error CSB_TK
2177 {yyerror ("'[' expected"); DRECOVER ("]");}
2178 | NEW_TK error OSB_TK
2179 {yyerror ("']' expected"); RECOVER;}
2180 ;
2181
2182 dim_exprs:
2183 dim_expr
2184 { $$ = build_tree_list (NULL_TREE, $1); }
2185 | dim_exprs dim_expr
2186 { $$ = tree_cons (NULL_TREE, $2, $$); }
2187 ;
2188
2189 dim_expr:
2190 OSB_TK expression CSB_TK
2191 {
2192 if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2193 {
2194 $2 = build_wfl_node ($2);
2195 TREE_TYPE ($2) = NULL_TREE;
2196 }
2197 EXPR_WFL_LINECOL ($2) = $1.location;
2198 $$ = $2;
2199 }
2200 | OSB_TK expression error
2201 {yyerror ("']' expected"); RECOVER;}
2202 | OSB_TK error
2203 {
2204 yyerror ("Missing term");
2205 yyerror ("']' expected");
2206 RECOVER;
2207 }
2208 ;
2209
2210 dims:
2211 OSB_TK CSB_TK
2212 {
2213 int allocate = 0;
2214 /* If not initialized, allocate memory for the osb
2215 numbers stack */
2216 if (!ctxp->osb_limit)
2217 {
2218 allocate = ctxp->osb_limit = 32;
2219 ctxp->osb_depth = -1;
2220 }
2221 /* If capacity overflown, reallocate a bigger chunk */
2222 else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2223 allocate = ctxp->osb_limit << 1;
2224
2225 if (allocate)
2226 {
2227 allocate *= sizeof (int);
2228 if (ctxp->osb_number)
2229 ctxp->osb_number = xrealloc (ctxp->osb_number,
2230 allocate);
2231 else
2232 ctxp->osb_number = xmalloc (allocate);
2233 }
2234 ctxp->osb_depth++;
2235 CURRENT_OSB (ctxp) = 1;
2236 }
2237 | dims OSB_TK CSB_TK
2238 { CURRENT_OSB (ctxp)++; }
2239 | dims OSB_TK error
2240 { yyerror ("']' expected"); RECOVER;}
2241 ;
2242
2243 field_access:
2244 primary DOT_TK identifier
2245 { $$ = make_qualified_primary ($1, $3, $2.location); }
2246 /* FIXME - REWRITE TO:
2247 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2248 | SUPER_TK DOT_TK identifier
2249 {
2250 tree super_wfl = build_wfl_node (super_identifier_node);
2251 SET_EXPR_LOCATION_FROM_TOKEN (super_wfl, $1);
2252 $$ = make_qualified_name (super_wfl, $3, $2.location);
2253 }
2254 | SUPER_TK error
2255 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2256 ;
2257
2258 method_invocation:
2259 name OP_TK CP_TK
2260 { $$ = build_method_invocation ($1, NULL_TREE); }
2261 | name OP_TK argument_list CP_TK
2262 { $$ = build_method_invocation ($1, $3); }
2263 | primary DOT_TK identifier OP_TK CP_TK
2264 {
2265 if (TREE_CODE ($1) == THIS_EXPR)
2266 $$ = build_this_super_qualified_invocation
2267 (1, $3, NULL_TREE, 0, $2.location);
2268 else
2269 {
2270 tree invok = build_method_invocation ($3, NULL_TREE);
2271 $$ = make_qualified_primary ($1, invok, $2.location);
2272 }
2273 }
2274 | primary DOT_TK identifier OP_TK argument_list CP_TK
2275 {
2276 if (TREE_CODE ($1) == THIS_EXPR)
2277 $$ = build_this_super_qualified_invocation
2278 (1, $3, $5, 0, $2.location);
2279 else
2280 {
2281 tree invok = build_method_invocation ($3, $5);
2282 $$ = make_qualified_primary ($1, invok, $2.location);
2283 }
2284 }
2285 | SUPER_TK DOT_TK identifier OP_TK CP_TK
2286 {
2287 $$ = build_this_super_qualified_invocation
2288 (0, $3, NULL_TREE, $1.location, $2.location);
2289 }
2290 | SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2291 {
2292 $$ = build_this_super_qualified_invocation
2293 (0, $3, $5, $1.location, $2.location);
2294 }
2295 /* Screws up thing. I let it here until I'm convinced it can
2296 be removed. FIXME
2297 | primary DOT_TK error
2298 {yyerror ("'(' expected"); DRECOVER(bad);} */
2299 | SUPER_TK DOT_TK error CP_TK
2300 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2301 | SUPER_TK DOT_TK error DOT_TK
2302 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2303 ;
2304
2305 array_access:
2306 name OSB_TK expression CSB_TK
2307 { $$ = build_array_ref ($2.location, $1, $3); }
2308 | primary_no_new_array OSB_TK expression CSB_TK
2309 { $$ = build_array_ref ($2.location, $1, $3); }
2310 | array_creation_initialized OSB_TK expression CSB_TK
2311 { $$ = build_array_ref ($2.location, $1, $3); }
2312 | name OSB_TK error
2313 {
2314 yyerror ("Missing term and ']' expected");
2315 DRECOVER(array_access);
2316 }
2317 | name OSB_TK expression error
2318 {
2319 yyerror ("']' expected");
2320 DRECOVER(array_access);
2321 }
2322 | primary_no_new_array OSB_TK error
2323 {
2324 yyerror ("Missing term and ']' expected");
2325 DRECOVER(array_access);
2326 }
2327 | primary_no_new_array OSB_TK expression error
2328 {
2329 yyerror ("']' expected");
2330 DRECOVER(array_access);
2331 }
2332 | array_creation_initialized OSB_TK error
2333 {
2334 yyerror ("Missing term and ']' expected");
2335 DRECOVER(array_access);
2336 }
2337 | array_creation_initialized OSB_TK expression error
2338 {
2339 yyerror ("']' expected");
2340 DRECOVER(array_access);
2341 }
2342 ;
2343
2344 postfix_expression:
2345 primary
2346 | name
2347 | post_increment_expression
2348 | post_decrement_expression
2349 ;
2350
2351 post_increment_expression:
2352 postfix_expression INCR_TK
2353 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2354 ;
2355
2356 post_decrement_expression:
2357 postfix_expression DECR_TK
2358 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2359 ;
2360
2361 trap_overflow_corner_case:
2362 pre_increment_expression
2363 | pre_decrement_expression
2364 | PLUS_TK unary_expression
2365 {$$ = build_unaryop ($1.token, $1.location, $2); }
2366 | unary_expression_not_plus_minus
2367 | PLUS_TK error
2368 {yyerror ("Missing term"); RECOVER}
2369 ;
2370
2371 unary_expression:
2372 trap_overflow_corner_case
2373 {
2374 if ($1)
2375 error_if_numeric_overflow ($1);
2376 $$ = $1;
2377 }
2378 | MINUS_TK trap_overflow_corner_case
2379 {$$ = build_unaryop ($1.token, $1.location, $2); }
2380 | MINUS_TK error
2381 {yyerror ("Missing term"); RECOVER}
2382 ;
2383
2384 pre_increment_expression:
2385 INCR_TK unary_expression
2386 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2387 | INCR_TK error
2388 {yyerror ("Missing term"); RECOVER}
2389 ;
2390
2391 pre_decrement_expression:
2392 DECR_TK unary_expression
2393 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2394 | DECR_TK error
2395 {yyerror ("Missing term"); RECOVER}
2396 ;
2397
2398 unary_expression_not_plus_minus:
2399 postfix_expression
2400 | NOT_TK unary_expression
2401 {$$ = build_unaryop ($1.token, $1.location, $2); }
2402 | NEG_TK unary_expression
2403 {$$ = build_unaryop ($1.token, $1.location, $2); }
2404 | cast_expression
2405 | NOT_TK error
2406 {yyerror ("Missing term"); RECOVER}
2407 | NEG_TK error
2408 {yyerror ("Missing term"); RECOVER}
2409 ;
2410
2411 cast_expression: /* Error handling here is potentially weak */
2412 OP_TK primitive_type dims CP_TK unary_expression
2413 {
2414 tree type = $2;
2415 int osb = pop_current_osb (ctxp);
2416 while (osb--)
2417 type = build_java_array_type (type, -1);
2418 $$ = build_cast ($1.location, type, $5);
2419 }
2420 | OP_TK primitive_type CP_TK unary_expression
2421 { $$ = build_cast ($1.location, $2, $4); }
2422 | OP_TK expression CP_TK unary_expression_not_plus_minus
2423 { $$ = build_cast ($1.location, $2, $4); }
2424 | OP_TK name dims CP_TK unary_expression_not_plus_minus
2425 {
2426 const char *ptr;
2427 int osb = pop_current_osb (ctxp);
2428 obstack_grow (&temporary_obstack,
2429 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2430 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2431 while (osb--)
2432 obstack_grow (&temporary_obstack, "[]", 2);
2433 obstack_1grow (&temporary_obstack, '\0');
2434 ptr = obstack_finish (&temporary_obstack);
2435 EXPR_WFL_NODE ($2) = get_identifier (ptr);
2436 $$ = build_cast ($1.location, $2, $5);
2437 }
2438 | OP_TK primitive_type OSB_TK error
2439 {yyerror ("']' expected, invalid type expression");}
2440 | OP_TK error
2441 {
2442 YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2443 RECOVER;
2444 }
2445 | OP_TK primitive_type dims CP_TK error
2446 {yyerror ("Missing term"); RECOVER;}
2447 | OP_TK primitive_type CP_TK error
2448 {yyerror ("Missing term"); RECOVER;}
2449 | OP_TK name dims CP_TK error
2450 {yyerror ("Missing term"); RECOVER;}
2451 ;
2452
2453 multiplicative_expression:
2454 unary_expression
2455 | multiplicative_expression MULT_TK unary_expression
2456 {
2457 $$ = build_binop (BINOP_LOOKUP ($2.token),
2458 $2.location, $1, $3);
2459 }
2460 | multiplicative_expression DIV_TK unary_expression
2461 {
2462 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2463 $1, $3);
2464 }
2465 | multiplicative_expression REM_TK unary_expression
2466 {
2467 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2468 $1, $3);
2469 }
2470 | multiplicative_expression MULT_TK error
2471 {yyerror ("Missing term"); RECOVER;}
2472 | multiplicative_expression DIV_TK error
2473 {yyerror ("Missing term"); RECOVER;}
2474 | multiplicative_expression REM_TK error
2475 {yyerror ("Missing term"); RECOVER;}
2476 ;
2477
2478 additive_expression:
2479 multiplicative_expression
2480 | additive_expression PLUS_TK multiplicative_expression
2481 {
2482 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2483 $1, $3);
2484 }
2485 | additive_expression MINUS_TK multiplicative_expression
2486 {
2487 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2488 $1, $3);
2489 }
2490 | additive_expression PLUS_TK error
2491 {yyerror ("Missing term"); RECOVER;}
2492 | additive_expression MINUS_TK error
2493 {yyerror ("Missing term"); RECOVER;}
2494 ;
2495
2496 shift_expression:
2497 additive_expression
2498 | shift_expression LS_TK additive_expression
2499 {
2500 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2501 $1, $3);
2502 }
2503 | shift_expression SRS_TK additive_expression
2504 {
2505 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2506 $1, $3);
2507 }
2508 | shift_expression ZRS_TK additive_expression
2509 {
2510 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2511 $1, $3);
2512 }
2513 | shift_expression LS_TK error
2514 {yyerror ("Missing term"); RECOVER;}
2515 | shift_expression SRS_TK error
2516 {yyerror ("Missing term"); RECOVER;}
2517 | shift_expression ZRS_TK error
2518 {yyerror ("Missing term"); RECOVER;}
2519 ;
2520
2521 relational_expression:
2522 shift_expression
2523 | relational_expression LT_TK shift_expression
2524 {
2525 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2526 $1, $3);
2527 }
2528 | relational_expression GT_TK shift_expression
2529 {
2530 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2531 $1, $3);
2532 }
2533 | relational_expression LTE_TK shift_expression
2534 {
2535 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2536 $1, $3);
2537 }
2538 | relational_expression GTE_TK shift_expression
2539 {
2540 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2541 $1, $3);
2542 }
2543 | relational_expression INSTANCEOF_TK reference_type
2544 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2545 | relational_expression LT_TK error
2546 {yyerror ("Missing term"); RECOVER;}
2547 | relational_expression GT_TK error
2548 {yyerror ("Missing term"); RECOVER;}
2549 | relational_expression LTE_TK error
2550 {yyerror ("Missing term"); RECOVER;}
2551 | relational_expression GTE_TK error
2552 {yyerror ("Missing term"); RECOVER;}
2553 | relational_expression INSTANCEOF_TK error
2554 {yyerror ("Invalid reference type"); RECOVER;}
2555 ;
2556
2557 equality_expression:
2558 relational_expression
2559 | equality_expression EQ_TK relational_expression
2560 {
2561 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2562 $1, $3);
2563 }
2564 | equality_expression NEQ_TK relational_expression
2565 {
2566 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2567 $1, $3);
2568 }
2569 | equality_expression EQ_TK error
2570 {yyerror ("Missing term"); RECOVER;}
2571 | equality_expression NEQ_TK error
2572 {yyerror ("Missing term"); RECOVER;}
2573 ;
2574
2575 and_expression:
2576 equality_expression
2577 | and_expression AND_TK equality_expression
2578 {
2579 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2580 $1, $3);
2581 }
2582 | and_expression AND_TK error
2583 {yyerror ("Missing term"); RECOVER;}
2584 ;
2585
2586 exclusive_or_expression:
2587 and_expression
2588 | exclusive_or_expression XOR_TK and_expression
2589 {
2590 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2591 $1, $3);
2592 }
2593 | exclusive_or_expression XOR_TK error
2594 {yyerror ("Missing term"); RECOVER;}
2595 ;
2596
2597 inclusive_or_expression:
2598 exclusive_or_expression
2599 | inclusive_or_expression OR_TK exclusive_or_expression
2600 {
2601 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2602 $1, $3);
2603 }
2604 | inclusive_or_expression OR_TK error
2605 {yyerror ("Missing term"); RECOVER;}
2606 ;
2607
2608 conditional_and_expression:
2609 inclusive_or_expression
2610 | conditional_and_expression BOOL_AND_TK inclusive_or_expression
2611 {
2612 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2613 $1, $3);
2614 }
2615 | conditional_and_expression BOOL_AND_TK error
2616 {yyerror ("Missing term"); RECOVER;}
2617 ;
2618
2619 conditional_or_expression:
2620 conditional_and_expression
2621 | conditional_or_expression BOOL_OR_TK conditional_and_expression
2622 {
2623 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2624 $1, $3);
2625 }
2626 | conditional_or_expression BOOL_OR_TK error
2627 {yyerror ("Missing term"); RECOVER;}
2628 ;
2629
2630 conditional_expression: /* Error handling here is weak */
2631 conditional_or_expression
2632 | conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2633 {
2634 $$ = build3 (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2635 SET_EXPR_LOCATION_FROM_TOKEN ($$, $2);
2636 }
2637 | conditional_or_expression REL_QM_TK REL_CL_TK error
2638 {
2639 YYERROR_NOW;
2640 yyerror ("Missing term");
2641 DRECOVER (1);
2642 }
2643 | conditional_or_expression REL_QM_TK error
2644 {yyerror ("Missing term"); DRECOVER (2);}
2645 | conditional_or_expression REL_QM_TK expression REL_CL_TK error
2646 {yyerror ("Missing term"); DRECOVER (3);}
2647 ;
2648
2649 assignment_expression:
2650 conditional_expression
2651 | assignment
2652 ;
2653
2654 assignment:
2655 left_hand_side assignment_operator assignment_expression
2656 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2657 | left_hand_side assignment_operator error
2658 {
2659 YYNOT_TWICE yyerror ("Missing term");
2660 DRECOVER (assign);
2661 }
2662 ;
2663
2664 left_hand_side:
2665 name
2666 | field_access
2667 | array_access
2668 ;
2669
2670 assignment_operator:
2671 ASSIGN_ANY_TK
2672 | ASSIGN_TK
2673 ;
2674
2675 expression:
2676 assignment_expression
2677 ;
2678
2679 constant_expression:
2680 expression
2681 ;
2682
2683 %%
2684
2685 /* Helper function to retrieve an OSB count. Should be used when the
2686 `dims:' rule is being used. */
2687
2688 static int
2689 pop_current_osb (struct parser_ctxt *ctxp)
2690 {
2691 int to_return;
2692
2693 if (ctxp->osb_depth < 0)
2694 abort ();
2695
2696 to_return = CURRENT_OSB (ctxp);
2697 ctxp->osb_depth--;
2698
2699 return to_return;
2700 }
2701
2702 \f
2703
2704 /* This section of the code deal with save/restoring parser contexts.
2705 Add mode documentation here. FIXME */
2706
2707 /* Helper function. Create a new parser context. With
2708 COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2709 context is copied, otherwise, the new context is zeroed. The newly
2710 created context becomes the current one. */
2711
2712 static void
2713 create_new_parser_context (int copy_from_previous)
2714 {
2715 struct parser_ctxt *new;
2716
2717 new = ggc_alloc (sizeof (struct parser_ctxt));
2718 if (copy_from_previous)
2719 {
2720 memcpy (new, ctxp, sizeof (struct parser_ctxt));
2721 /* This flag, indicating the context saves global values,
2722 should only be set by java_parser_context_save_global. */
2723 new->saved_data_ctx = 0;
2724 }
2725 else
2726 memset (new, 0, sizeof (struct parser_ctxt));
2727
2728 new->next = ctxp;
2729 ctxp = new;
2730 }
2731
2732 /* Create a new parser context and make it the current one. */
2733
2734 void
2735 java_push_parser_context (void)
2736 {
2737 create_new_parser_context (0);
2738 }
2739
2740 void
2741 java_pop_parser_context (int generate)
2742 {
2743 tree current;
2744 struct parser_ctxt *next;
2745
2746 if (!ctxp)
2747 return;
2748
2749 next = ctxp->next;
2750 if (next)
2751 {
2752 input_location = ctxp->save_location;
2753 current_class = ctxp->class_type;
2754 }
2755
2756 /* If the old and new lexers differ, then free the old one. */
2757 if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2758 java_destroy_lexer (ctxp->lexer);
2759
2760 /* Set the single import class file flag to 0 for the current list
2761 of imported things */
2762 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2763 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2764
2765 /* If we pushed a context to parse a class intended to be generated,
2766 we keep it so we can remember the class. What we could actually
2767 do is to just update a list of class names. */
2768 if (generate)
2769 {
2770 if (ctxp_for_generation_last == NULL)
2771 ctxp_for_generation = ctxp;
2772 else
2773 ctxp_for_generation_last->next = ctxp;
2774 ctxp->next = NULL;
2775 ctxp_for_generation_last = ctxp;
2776 }
2777
2778 /* And restore those of the previous context */
2779 if ((ctxp = next)) /* Assignment is really meant here */
2780 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2781 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2782 }
2783
2784 /* Create a parser context for the use of saving some global
2785 variables. */
2786
2787 void
2788 java_parser_context_save_global (void)
2789 {
2790 if (!ctxp)
2791 {
2792 java_push_parser_context ();
2793 ctxp->saved_data_ctx = 1;
2794 }
2795
2796 /* If this context already stores data, create a new one suitable
2797 for data storage. */
2798 else if (ctxp->saved_data)
2799 {
2800 create_new_parser_context (1);
2801 ctxp->saved_data_ctx = 1;
2802 }
2803
2804 ctxp->save_location = input_location;
2805 ctxp->class_type = current_class;
2806 ctxp->function_decl = current_function_decl;
2807 ctxp->saved_data = 1;
2808 }
2809
2810 /* Restore some global variables from the previous context. Make the
2811 previous context the current one. */
2812
2813 void
2814 java_parser_context_restore_global (void)
2815 {
2816 input_location = ctxp->save_location;
2817 current_class = ctxp->class_type;
2818 if (wfl_operator)
2819 #ifdef USE_MAPPED_LOCATION
2820 SET_EXPR_LOCATION (wfl_operator, ctxp->save_location);
2821 #else
2822 EXPR_WFL_FILENAME_NODE (wfl_operator) = get_identifier (input_filename);
2823 #endif
2824 current_function_decl = ctxp->function_decl;
2825 ctxp->saved_data = 0;
2826 if (ctxp->saved_data_ctx)
2827 java_pop_parser_context (0);
2828 }
2829
2830 /* Suspend vital data for the current class/function being parsed so
2831 that an other class can be parsed. Used to let local/anonymous
2832 classes be parsed. */
2833
2834 static void
2835 java_parser_context_suspend (void)
2836 {
2837 /* This makes debugging through java_debug_context easier */
2838 static const char *const name = "<inner buffer context>";
2839
2840 /* Duplicate the previous context, use it to save the globals we're
2841 interested in */
2842 create_new_parser_context (1);
2843 ctxp->function_decl = current_function_decl;
2844 ctxp->class_type = current_class;
2845
2846 /* Then create a new context which inherits all data from the
2847 previous one. This will be the new current context */
2848 create_new_parser_context (1);
2849
2850 /* Help debugging */
2851 ctxp->next->filename = name;
2852 }
2853
2854 /* Resume vital data for the current class/function being parsed so
2855 that an other class can be parsed. Used to let local/anonymous
2856 classes be parsed. The trick is the data storing file position
2857 informations must be restored to their current value, so parsing
2858 can resume as if no context was ever saved. */
2859
2860 static void
2861 java_parser_context_resume (void)
2862 {
2863 struct parser_ctxt *old = ctxp; /* This one is to be discarded */
2864 struct parser_ctxt *saver = old->next; /* This one contain saved info */
2865 struct parser_ctxt *restored = saver->next; /* This one is the old current */
2866
2867 /* We need to inherit the list of classes to complete/generate */
2868 restored->classd_list = old->classd_list;
2869 restored->class_list = old->class_list;
2870
2871 /* Restore the current class and function from the saver */
2872 current_class = saver->class_type;
2873 current_function_decl = saver->function_decl;
2874
2875 /* Retrieve the restored context */
2876 ctxp = restored;
2877
2878 /* Re-installed the data for the parsing to carry on */
2879 memcpy (&ctxp->marker_begining, &old->marker_begining,
2880 (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2881 }
2882
2883 /* Add a new anchor node to which all statement(s) initializing static
2884 and non static initialized upon declaration field(s) will be
2885 linked. */
2886
2887 static void
2888 java_parser_context_push_initialized_field (void)
2889 {
2890 tree node;
2891
2892 node = build_tree_list (NULL_TREE, NULL_TREE);
2893 TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2894 CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2895
2896 node = build_tree_list (NULL_TREE, NULL_TREE);
2897 TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2898 CPC_INITIALIZER_LIST (ctxp) = node;
2899
2900 node = build_tree_list (NULL_TREE, NULL_TREE);
2901 TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2902 CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2903 }
2904
2905 /* Pop the lists of initialized field. If this lists aren't empty,
2906 remember them so we can use it to create and populate the finit$
2907 or <clinit> functions. */
2908
2909 static void
2910 java_parser_context_pop_initialized_field (void)
2911 {
2912 tree stmts;
2913 tree class_type = TREE_TYPE (GET_CPC ());
2914
2915 if (CPC_INITIALIZER_LIST (ctxp))
2916 {
2917 stmts = CPC_INITIALIZER_STMT (ctxp);
2918 CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2919 if (stmts && !java_error_count)
2920 TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2921 }
2922
2923 if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2924 {
2925 stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2926 CPC_STATIC_INITIALIZER_LIST (ctxp) =
2927 TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2928 /* Keep initialization in order to enforce 8.5 */
2929 if (stmts && !java_error_count)
2930 TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2931 }
2932
2933 /* JDK 1.1 instance initializers */
2934 if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2935 {
2936 stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2937 CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2938 TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2939 if (stmts && !java_error_count)
2940 TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2941 }
2942 }
2943
2944 static tree
2945 reorder_static_initialized (tree list)
2946 {
2947 /* We have to keep things in order. The alias initializer have to
2948 come first, then the initialized regular field, in reverse to
2949 keep them in lexical order. */
2950 tree marker, previous = NULL_TREE;
2951 for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2952 if (TREE_CODE (marker) == TREE_LIST
2953 && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2954 break;
2955
2956 /* No static initialized, the list is fine as is */
2957 if (!previous)
2958 list = TREE_CHAIN (marker);
2959
2960 /* No marker? reverse the whole list */
2961 else if (!marker)
2962 list = nreverse (list);
2963
2964 /* Otherwise, reverse what's after the marker and the new reordered
2965 sublist will replace the marker. */
2966 else
2967 {
2968 TREE_CHAIN (previous) = NULL_TREE;
2969 list = nreverse (list);
2970 list = chainon (TREE_CHAIN (marker), list);
2971 }
2972 return list;
2973 }
2974
2975 /* Helper functions to dump the parser context stack. */
2976
2977 #define TAB_CONTEXT(C) \
2978 {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2979
2980 static void
2981 java_debug_context_do (int tab)
2982 {
2983 struct parser_ctxt *copy = ctxp;
2984 while (copy)
2985 {
2986 TAB_CONTEXT (tab);
2987 fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2988 TAB_CONTEXT (tab);
2989 fprintf (stderr, "filename: %s\n", copy->filename);
2990 TAB_CONTEXT (tab);
2991 fprintf (stderr, "package: %s\n",
2992 (copy->package ?
2993 IDENTIFIER_POINTER (copy->package) : "<none>"));
2994 TAB_CONTEXT (tab);
2995 fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2996 TAB_CONTEXT (tab);
2997 fprintf (stderr, "saved data: %d\n", copy->saved_data);
2998 copy = copy->next;
2999 tab += 2;
3000 }
3001 }
3002
3003 /* Dump the stacked up parser contexts. Intended to be called from a
3004 debugger. */
3005
3006 void
3007 java_debug_context (void)
3008 {
3009 java_debug_context_do (0);
3010 }
3011
3012 \f
3013
3014 /* Flag for the error report routine to issue the error the first time
3015 it's called (overriding the default behavior which is to drop the
3016 first invocation and honor the second one, taking advantage of a
3017 richer context. */
3018 static int force_error = 0;
3019
3020 /* Reporting an constructor invocation error. */
3021 static void
3022 parse_ctor_invocation_error (void)
3023 {
3024 if (DECL_CONSTRUCTOR_P (current_function_decl))
3025 yyerror ("Constructor invocation must be first thing in a constructor");
3026 else
3027 yyerror ("Only constructors can invoke constructors");
3028 }
3029
3030 /* Reporting JDK1.1 features not implemented. */
3031
3032 static tree
3033 parse_jdk1_1_error (const char *msg)
3034 {
3035 sorry (": %qs JDK1.1(TM) feature", msg);
3036 java_error_count++;
3037 return build_java_empty_stmt ();
3038 }
3039
3040 static int do_warning = 0;
3041
3042 void
3043 yyerror (const char *msgid)
3044 {
3045 #ifdef USE_MAPPED_LOCATION
3046 static source_location elc;
3047 expanded_location xloc = expand_location (input_location);
3048 int current_line = xloc.line;
3049 #else
3050 static java_lc elc;
3051 int save_lineno;
3052 int current_line = input_line;
3053 #endif
3054 static int prev_lineno;
3055 static const char *prev_msg;
3056
3057 char *remainder, *code_from_source;
3058
3059 if (!force_error && prev_lineno == current_line)
3060 return;
3061 #ifndef USE_MAPPED_LOCATION
3062 current_line = ctxp->lexer->token_start.line;
3063 #endif
3064
3065 /* Save current error location but report latter, when the context is
3066 richer. */
3067 if (ctxp->java_error_flag == 0)
3068 {
3069 ctxp->java_error_flag = 1;
3070 #ifdef USE_MAPPED_LOCATION
3071 elc = input_location;
3072 #else
3073 elc = ctxp->lexer->token_start;
3074 #endif
3075 /* Do something to use the previous line if we're reaching the
3076 end of the file... */
3077 #ifdef VERBOSE_SKELETON
3078 printf ("* Error detected (%s)\n", (msgid ? msgid : "(null)"));
3079 #endif
3080 return;
3081 }
3082
3083 /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3084 if (!force_error && msgid == prev_msg && prev_lineno == current_line)
3085 return;
3086
3087 ctxp->java_error_flag = 0;
3088 if (do_warning)
3089 java_warning_count++;
3090 else
3091 java_error_count++;
3092
3093 #if 0 /* FIXME */
3094 if (elc.col == 0 && msgid && msgid[1] == ';')
3095 elc = ctxp->prev_line_end;
3096 #endif
3097
3098 prev_msg = msgid;
3099
3100 #ifdef USE_MAPPED_LOCATION
3101 prev_lineno = current_line;
3102 code_from_source = java_get_line_col (xloc.file, current_line, xloc.column);
3103 #else
3104 save_lineno = input_line;
3105 prev_lineno = input_line = current_line;
3106 code_from_source = java_get_line_col (input_filename, current_line,
3107 ctxp->lexer->token_start.col);
3108 #endif
3109
3110
3111 obstack_grow0 (&temporary_obstack,
3112 code_from_source, strlen (code_from_source));
3113 remainder = obstack_finish (&temporary_obstack);
3114 if (do_warning)
3115 warning (0, "%s.\n%s", msgid, remainder);
3116 else
3117 error ("%s.\n%s", msgid, remainder);
3118
3119 /* This allow us to cheaply avoid an extra 'Invalid expression
3120 statement' error report when errors have been already reported on
3121 the same line. This occurs when we report an error but don't have
3122 a synchronization point other than ';', which
3123 expression_statement is the only one to take care of. */
3124 #ifndef USE_MAPPED_LOCATION
3125 input_line = save_lineno;
3126 #endif
3127 ctxp->prevent_ese = input_line;
3128 }
3129
3130 static void
3131 issue_warning_error_from_context (
3132 #ifdef USE_MAPPED_LOCATION
3133 source_location cl,
3134 #else
3135 tree cl,
3136 #endif
3137 const char *gmsgid, va_list *ap)
3138 {
3139 #ifdef USE_MAPPED_LOCATION
3140 source_location saved_location = input_location;
3141 expanded_location xloc = expand_location (cl);
3142 #else
3143 java_lc save_lc = ctxp->lexer->token_start;
3144 const char *saved = ctxp->filename, *saved_input_filename;
3145 #endif
3146 char buffer [4096];
3147 text_info text;
3148
3149 text.err_no = errno;
3150 text.args_ptr = ap;
3151 text.format_spec = gmsgid;
3152 pp_format (global_dc->printer, &text);
3153 pp_output_formatted_text (global_dc->printer);
3154 strncpy (buffer, pp_formatted_text (global_dc->printer), sizeof (buffer) - 1);
3155 buffer[sizeof (buffer) - 1] = '\0';
3156 pp_clear_output_area (global_dc->printer);
3157
3158 force_error = 1;
3159
3160 #ifdef USE_MAPPED_LOCATION
3161 if (xloc.file != NULL)
3162 {
3163 ctxp->filename = xloc.file;
3164 input_location = cl;
3165 }
3166 #else
3167 ctxp->lexer->token_start.line = EXPR_WFL_LINENO (cl);
3168 ctxp->lexer->token_start.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1
3169 : EXPR_WFL_COLNO (cl) == 0xffe ? -2
3170 : EXPR_WFL_COLNO (cl));
3171
3172 /* We have a CL, that's a good reason for using it if it contains data */
3173 if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3174 ctxp->filename = EXPR_WFL_FILENAME (cl);
3175 saved_input_filename = input_filename;
3176 input_filename = ctxp->filename;
3177 #endif
3178 java_error (NULL);
3179 java_error (buffer);
3180 #ifdef USE_MAPPED_LOCATION
3181 input_location = saved_location;
3182 #else
3183 ctxp->filename = saved;
3184 input_filename = saved_input_filename;
3185 ctxp->lexer->token_start = save_lc;
3186 #endif
3187 force_error = 0;
3188 }
3189
3190 /* Issue an error message at a current source line CL.
3191 FUTURE/FIXME: change cl to be a source_location. */
3192
3193 void
3194 parse_error_context (tree cl, const char *gmsgid, ...)
3195 {
3196 va_list ap;
3197 va_start (ap, gmsgid);
3198 #ifdef USE_MAPPED_LOCATION
3199 issue_warning_error_from_context (EXPR_LOCATION (cl), gmsgid, &ap);
3200 #else
3201 issue_warning_error_from_context (cl, gmsgid, &ap);
3202 #endif
3203 va_end (ap);
3204 }
3205
3206 /* Issue a warning at a current source line CL.
3207 FUTURE/FIXME: change cl to be a source_location. */
3208
3209 static void
3210 parse_warning_context (tree cl, const char *gmsgid, ...)
3211 {
3212 va_list ap;
3213 va_start (ap, gmsgid);
3214
3215 do_warning = 1;
3216 #ifdef USE_MAPPED_LOCATION
3217 issue_warning_error_from_context (EXPR_LOCATION (cl), gmsgid, &ap);
3218 #else
3219 issue_warning_error_from_context (cl, gmsgid, &ap);
3220 #endif
3221 do_warning = 0;
3222 va_end (ap);
3223 }
3224
3225 static tree
3226 find_expr_with_wfl (tree node)
3227 {
3228 while (node)
3229 {
3230 enum tree_code_class code;
3231 tree to_return;
3232
3233 switch (TREE_CODE (node))
3234 {
3235 case BLOCK:
3236 node = BLOCK_EXPR_BODY (node);
3237 continue;
3238
3239 case COMPOUND_EXPR:
3240 to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3241 if (to_return)
3242 return to_return;
3243 node = TREE_OPERAND (node, 1);
3244 continue;
3245
3246 case LOOP_EXPR:
3247 node = TREE_OPERAND (node, 0);
3248 continue;
3249
3250 case LABELED_BLOCK_EXPR:
3251 node = LABELED_BLOCK_BODY (node);
3252 continue;
3253
3254 default:
3255 code = TREE_CODE_CLASS (TREE_CODE (node));
3256 if (((code == tcc_unary) || (code == tcc_binary)
3257 || (code == tcc_expression))
3258 && EXPR_WFL_LINECOL (node))
3259 return node;
3260 return NULL_TREE;
3261 }
3262 }
3263 return NULL_TREE;
3264 }
3265
3266 /* Issue a missing return statement error. Uses METHOD to figure the
3267 last line of the method the error occurs in. */
3268
3269 static void
3270 missing_return_error (tree method)
3271 {
3272 #ifdef USE_MAPPED_LOCATION
3273 SET_EXPR_LOCATION (wfl_operator, DECL_FUNCTION_LAST_LINE (method));
3274 #else
3275 EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3276 #endif
3277 parse_error_context (wfl_operator, "Missing return statement");
3278 }
3279
3280 /* Issue an unreachable statement error. From NODE, find the next
3281 statement to report appropriately. */
3282 static void
3283 unreachable_stmt_error (tree node)
3284 {
3285 /* Browse node to find the next expression node that has a WFL. Use
3286 the location to report the error */
3287 if (TREE_CODE (node) == COMPOUND_EXPR)
3288 node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3289 else
3290 node = find_expr_with_wfl (node);
3291
3292 if (node)
3293 {
3294 #ifdef USE_MAPPED_LOCATION
3295 SET_EXPR_LOCATION (wfl_operator, EXPR_LOCATION (node));
3296 #else
3297 EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3298 #endif
3299 parse_error_context (wfl_operator, "Unreachable statement");
3300 }
3301 else
3302 abort ();
3303 }
3304
3305 static int
3306 not_accessible_field_error (tree wfl, tree decl)
3307 {
3308 parse_error_context
3309 (wfl, "Can't access %s field %<%s.%s%> from %qs",
3310 accessibility_string (get_access_flags_from_decl (decl)),
3311 GET_TYPE_NAME (DECL_CONTEXT (decl)),
3312 IDENTIFIER_POINTER (DECL_NAME (decl)),
3313 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3314 return 1;
3315 }
3316
3317 int
3318 java_report_errors (void)
3319 {
3320 if (java_error_count)
3321 fprintf (stderr, "%d error%s",
3322 java_error_count, (java_error_count == 1 ? "" : "s"));
3323 if (java_warning_count)
3324 fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3325 java_warning_count, (java_warning_count == 1 ? "" : "s"));
3326 if (java_error_count || java_warning_count)
3327 putc ('\n', stderr);
3328 return java_error_count;
3329 }
3330
3331 static char *
3332 java_accstring_lookup (int flags)
3333 {
3334 static char buffer [80];
3335 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3336
3337 /* Access modifier looked-up first for easier report on forbidden
3338 access. */
3339 if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3340 if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3341 if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3342 if (flags & ACC_STATIC) COPY_RETURN ("static");
3343 if (flags & ACC_FINAL) COPY_RETURN ("final");
3344 if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3345 if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3346 if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3347 if (flags & ACC_NATIVE) COPY_RETURN ("native");
3348 if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3349 if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3350
3351 buffer [0] = '\0';
3352 return buffer;
3353 #undef COPY_RETURN
3354 }
3355
3356 /* Returns a string denoting the accessibility of a class or a member as
3357 indicated by FLAGS. We need a separate function from
3358 java_accstring_lookup, as the latter can return spurious "static", etc.
3359 if package-private access is defined (in which case none of the
3360 relevant access control bits in FLAGS is set). */
3361
3362 static const char *
3363 accessibility_string (int flags)
3364 {
3365 if (flags & ACC_PRIVATE) return "private";
3366 if (flags & ACC_PROTECTED) return "protected";
3367 if (flags & ACC_PUBLIC) return "public";
3368
3369 return "package-private";
3370 }
3371
3372 /* Issuing error messages upon redefinition of classes, interfaces or
3373 variables. */
3374
3375 static void
3376 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3377 {
3378 parse_error_context (cl, "%s %qs already defined in %s:%d",
3379 context, IDENTIFIER_POINTER (id),
3380 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3381 /* Here we should point out where its redefined. It's a unicode. FIXME */
3382 }
3383
3384 static void
3385 variable_redefinition_error (tree context, tree name, tree type, int line)
3386 {
3387 const char *type_name;
3388
3389 /* Figure a proper name for type. We might haven't resolved it */
3390 if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3391 type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3392 else
3393 type_name = lang_printable_name (type, 0);
3394
3395 parse_error_context (context,
3396 "Variable %qs is already defined in this method and was declared %<%s %s%> at line %d",
3397 IDENTIFIER_POINTER (name),
3398 type_name, IDENTIFIER_POINTER (name), line);
3399 }
3400
3401 /* If ANAME is terminated with `[]', it indicates an array. This
3402 function returns the number of `[]' found and if this number is
3403 greater than zero, it extracts the array type name and places it in
3404 the node pointed to by TRIMMED unless TRIMMED is null. */
3405
3406 static int
3407 build_type_name_from_array_name (tree aname, tree *trimmed)
3408 {
3409 const char *name = IDENTIFIER_POINTER (aname);
3410 int len = IDENTIFIER_LENGTH (aname);
3411 int array_dims;
3412
3413 STRING_STRIP_BRACKETS (name, len, array_dims);
3414
3415 if (array_dims && trimmed)
3416 *trimmed = get_identifier_with_length (name, len);
3417
3418 return array_dims;
3419 }
3420
3421 static tree
3422 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3423 {
3424 int more_dims = 0;
3425
3426 /* Eventually get more dims */
3427 more_dims = build_type_name_from_array_name (name, &name);
3428
3429 /* If we have, then craft a new type for this variable */
3430 if (more_dims)
3431 {
3432 tree save = type;
3433
3434 /* If we have a pointer, use its type */
3435 if (TREE_CODE (type) == POINTER_TYPE)
3436 type = TREE_TYPE (type);
3437
3438 /* Building the first dimension of a primitive type uses this
3439 function */
3440 if (JPRIMITIVE_TYPE_P (type))
3441 {
3442 type = build_java_array_type (type, -1);
3443 more_dims--;
3444 }
3445 /* Otherwise, if we have a WFL for this type, use it (the type
3446 is already an array on an unresolved type, and we just keep
3447 on adding dimensions) */
3448 else if (type_wfl)
3449 {
3450 type = type_wfl;
3451 more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3452 NULL);
3453 }
3454
3455 /* Add all the dimensions */
3456 while (more_dims--)
3457 type = build_unresolved_array_type (type);
3458
3459 /* The type may have been incomplete in the first place */
3460 if (type_wfl)
3461 type = obtain_incomplete_type (type);
3462 }
3463
3464 if (ret_name)
3465 *ret_name = name;
3466 return type;
3467 }
3468
3469 /* Build something that the type identifier resolver will identify as
3470 being an array to an unresolved type. TYPE_WFL is a WFL on a
3471 identifier. */
3472
3473 static tree
3474 build_unresolved_array_type (tree type_or_wfl)
3475 {
3476 const char *ptr;
3477 tree wfl;
3478
3479 /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3480 just create a array type */
3481 if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3482 return build_java_array_type (type_or_wfl, -1);
3483
3484 obstack_grow (&temporary_obstack,
3485 IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3486 IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3487 obstack_grow0 (&temporary_obstack, "[]", 2);
3488 ptr = obstack_finish (&temporary_obstack);
3489 #ifdef USE_MAPPED_LOCATION
3490 wfl = build_expr_wfl (get_identifier (ptr), EXPR_LOCATION (type_or_wfl));
3491 #else
3492 wfl = build_expr_wfl (get_identifier (ptr),
3493 EXPR_WFL_FILENAME (type_or_wfl),
3494 EXPR_WFL_LINENO (type_or_wfl),
3495 EXPR_WFL_COLNO (type_or_wfl));
3496 #endif
3497 /* Re-install the existing qualifications so that the type can be
3498 resolved properly. */
3499 EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3500 return wfl;
3501 }
3502
3503 static void
3504 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3505 {
3506 if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3507 parse_error_context (wfl, "Interface %qs repeated",
3508 IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3509 }
3510
3511 /* Bulk of common class/interface checks. Return 1 if an error was
3512 encountered. TAG is 0 for a class, 1 for an interface. */
3513
3514 static int
3515 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3516 tree qualified_name, tree decl, tree cl)
3517 {
3518 tree node;
3519 int sca = 0; /* Static class allowed */
3520 int icaf = 0; /* Inner class allowed flags */
3521 int uaaf = CLASS_MODIFIERS; /* Usually allowed access flags */
3522
3523 if (!quiet_flag)
3524 fprintf (stderr, " %s%s %s",
3525 (CPC_INNER_P () ? "inner" : ""),
3526 (is_interface ? "interface" : "class"),
3527 IDENTIFIER_POINTER (qualified_name));
3528
3529 /* Scope of an interface/class type name:
3530 - Can't be imported by a single type import
3531 - Can't already exists in the package */
3532 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3533 && (node = find_name_in_single_imports (raw_name))
3534 && !CPC_INNER_P ())
3535 {
3536 parse_error_context
3537 (cl, "%s name %qs clashes with imported type %qs",
3538 (is_interface ? "Interface" : "Class"),
3539 IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3540 return 1;
3541 }
3542 if (decl && CLASS_COMPLETE_P (decl))
3543 {
3544 classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3545 qualified_name, decl, cl);
3546 return 1;
3547 }
3548
3549 if (check_inner_class_redefinition (raw_name, cl))
3550 return 1;
3551
3552 /* If public, file name should match class/interface name, except
3553 when dealing with an inner class */
3554 if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3555 {
3556 const char *fname = input_filename;
3557 const char *f;
3558
3559 for (f = fname + strlen (fname);
3560 f != fname && ! IS_DIR_SEPARATOR (*f);
3561 f--)
3562 ;
3563 if (IS_DIR_SEPARATOR (*f))
3564 f++;
3565 if (strncmp (IDENTIFIER_POINTER (raw_name),
3566 f , IDENTIFIER_LENGTH (raw_name)) ||
3567 f [IDENTIFIER_LENGTH (raw_name)] != '.')
3568 parse_error_context
3569 (cl, "Public %s %qs must be defined in a file called %<%s.java%>",
3570 (is_interface ? "interface" : "class"),
3571 IDENTIFIER_POINTER (qualified_name),
3572 IDENTIFIER_POINTER (raw_name));
3573 }
3574
3575 /* Static classes can be declared only in top level classes. Note:
3576 once static, a inner class is a top level class. */
3577 if (flags & ACC_STATIC)
3578 {
3579 /* Catch the specific error of declaring an class inner class
3580 with no toplevel enclosing class. Prevent check_modifiers from
3581 complaining a second time */
3582 if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3583 {
3584 parse_error_context (cl, "Inner class %qs can't be static. Static classes can only occur in interfaces and top-level classes",
3585 IDENTIFIER_POINTER (qualified_name));
3586 sca = ACC_STATIC;
3587 }
3588 /* Else, in the context of a top-level class declaration, let
3589 `check_modifiers' do its job, otherwise, give it a go */
3590 else
3591 sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3592 }
3593
3594 /* Inner classes can be declared private or protected
3595 within their enclosing classes. */
3596 if (CPC_INNER_P ())
3597 {
3598 /* A class which is local to a block can't be public, private,
3599 protected or static. But it is created final, so allow this
3600 one. */
3601 if (current_function_decl)
3602 icaf = sca = uaaf = ACC_FINAL;
3603 else
3604 {
3605 check_modifiers_consistency (flags);
3606 icaf = ACC_PROTECTED;
3607 if (! CLASS_INTERFACE (GET_CPC ()))
3608 icaf |= ACC_PRIVATE;
3609 }
3610 }
3611
3612 if (is_interface)
3613 {
3614 if (CPC_INNER_P ())
3615 uaaf = INTERFACE_INNER_MODIFIERS;
3616 else
3617 uaaf = INTERFACE_MODIFIERS;
3618
3619 check_modifiers ("Illegal modifier %qs for interface declaration",
3620 flags, uaaf);
3621 }
3622 else
3623 check_modifiers ((current_function_decl ?
3624 "Illegal modifier %qs for local class declaration" :
3625 "Illegal modifier %qs for class declaration"),
3626 flags, uaaf|sca|icaf);
3627 return 0;
3628 }
3629
3630 /* Construct a nested class name. If the final component starts with
3631 a digit, return true. Otherwise return false. */
3632 static int
3633 make_nested_class_name (tree cpc_list)
3634 {
3635 tree name;
3636
3637 if (!cpc_list)
3638 return 0;
3639
3640 make_nested_class_name (TREE_CHAIN (cpc_list));
3641
3642 /* Pick the qualified name when dealing with the first upmost
3643 enclosing class */
3644 name = (TREE_CHAIN (cpc_list)
3645 ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3646 obstack_grow (&temporary_obstack,
3647 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3648 obstack_1grow (&temporary_obstack, '$');
3649
3650 return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3651 }
3652
3653 /* Can't redefine a class already defined in an earlier scope. */
3654
3655 static int
3656 check_inner_class_redefinition (tree raw_name, tree cl)
3657 {
3658 tree scope_list;
3659
3660 for (scope_list = GET_CPC_LIST (); scope_list;
3661 scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3662 if (raw_name == GET_CPC_UN_NODE (scope_list))
3663 {
3664 parse_error_context
3665 (cl, "The class name %qs is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
3666 IDENTIFIER_POINTER (raw_name));
3667 return 1;
3668 }
3669 return 0;
3670 }
3671
3672 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. May return an
3673 invisible/non-accessible matching decl when an accessible one could not be
3674 found, in order to give a better error message when accessibility is
3675 checked later. */
3676
3677 static tree
3678 resolve_inner_class (tree context, tree cl, tree enclosing, tree class_type)
3679 {
3680 tree local_super = NULL_TREE;
3681 tree candidate = NULL_TREE;
3682
3683 /* This hash table is used to register the classes we're going
3684 through when searching the current class as an inner class, in
3685 order to detect circular references. */
3686 htab_t circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
3687 NULL);
3688
3689 while (enclosing)
3690 {
3691 tree decl;
3692
3693 *htab_find_slot (circularity_hash, enclosing, INSERT) = enclosing;
3694
3695 if ((decl = find_as_inner_class (enclosing, class_type, cl)))
3696 {
3697 if (inner_class_accessible (decl, context))
3698 {
3699 candidate = decl;
3700 break;
3701 }
3702 else
3703 if (candidate == NULL_TREE)
3704 candidate = decl;
3705 }
3706
3707 /* Now go to the upper classes, bail out if necessary. We will
3708 analyze the returned SUPER and act accordingly (see
3709 do_resolve_class). */
3710 if (JPRIMITIVE_TYPE_P (TREE_TYPE (enclosing))
3711 || TREE_TYPE (enclosing) == void_type_node)
3712 {
3713 parse_error_context (cl, "Qualifier must be a reference");
3714 enclosing = NULL_TREE;
3715 break;
3716 }
3717 local_super = CLASSTYPE_SUPER (TREE_TYPE (enclosing));
3718 if (!local_super || local_super == object_type_node)
3719 break;
3720
3721 if (TREE_CODE (local_super) == POINTER_TYPE)
3722 local_super = do_resolve_class (NULL, NULL, local_super, NULL, NULL);
3723 else
3724 local_super = TYPE_NAME (local_super);
3725
3726 /* We may not have checked for circular inheritance yet, so do so
3727 here to prevent an infinite loop. */
3728 if (htab_find (circularity_hash, local_super) != NULL)
3729 {
3730 if (!cl)
3731 cl = lookup_cl (enclosing);
3732
3733 parse_error_context
3734 (cl, "Cyclic inheritance involving %s",
3735 IDENTIFIER_POINTER (DECL_NAME (enclosing)));
3736 enclosing = NULL_TREE;
3737 }
3738 else
3739 enclosing = local_super;
3740 }
3741
3742 htab_delete (circularity_hash);
3743
3744 /* We failed, but we might have found a matching class that wasn't
3745 accessible. Return that to get a better error message. */
3746 return candidate;
3747 }
3748
3749 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3750 qualified. */
3751
3752 static tree
3753 find_as_inner_class (tree enclosing, tree name, tree cl)
3754 {
3755 tree qual, to_return;
3756 if (!enclosing)
3757 return NULL_TREE;
3758
3759 name = TYPE_NAME (name);
3760
3761 /* First search: within the scope of `enclosing', search for name */
3762 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3763 qual = EXPR_WFL_QUALIFICATION (cl);
3764 else if (cl)
3765 qual = build_tree_list (cl, NULL_TREE);
3766 else
3767 qual = build_tree_list (build_unknown_wfl (name), NULL_TREE);
3768
3769 if ((to_return = find_as_inner_class_do (qual, enclosing)))
3770 return to_return;
3771
3772 /* We're dealing with a qualified name. Try to resolve thing until
3773 we get something that is an enclosing class. */
3774 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3775 {
3776 tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3777
3778 for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3779 qual = TREE_CHAIN (qual))
3780 {
3781 acc = merge_qualified_name (acc,
3782 EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3783 BUILD_PTR_FROM_NAME (ptr, acc);
3784 decl = do_resolve_class (NULL_TREE, NULL_TREE, ptr, NULL_TREE, cl);
3785 }
3786
3787 /* A NULL qual and a decl means that the search ended
3788 successfully?!? We have to do something then. FIXME */
3789
3790 if (decl)
3791 enclosing = decl;
3792 else
3793 qual = EXPR_WFL_QUALIFICATION (cl);
3794 }
3795 /* Otherwise, create a qual for the other part of the resolution. */
3796 else
3797 qual = build_tree_list (build_unknown_wfl (name), NULL_TREE);
3798
3799 return find_as_inner_class_do (qual, enclosing);
3800 }
3801
3802 /* We go inside the list of sub classes and try to find a way
3803 through. */
3804
3805 static tree
3806 find_as_inner_class_do (tree qual, tree enclosing)
3807 {
3808 if (!qual)
3809 return NULL_TREE;
3810
3811 for (; qual && enclosing; qual = TREE_CHAIN (qual))
3812 {
3813 tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3814 tree next_enclosing = NULL_TREE;
3815 tree inner_list;
3816
3817 for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3818 inner_list; inner_list = TREE_CHAIN (inner_list))
3819 {
3820 if (TREE_VALUE (inner_list) == name_to_match)
3821 {
3822 next_enclosing = TREE_PURPOSE (inner_list);
3823 break;
3824 }
3825 }
3826 enclosing = next_enclosing;
3827 }
3828
3829 return (!qual && enclosing ? enclosing : NULL_TREE);
3830 }
3831
3832 static void
3833 link_nested_class_to_enclosing (void)
3834 {
3835 if (GET_ENCLOSING_CPC ())
3836 {
3837 tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3838 DECL_INNER_CLASS_LIST (enclosing) =
3839 tree_cons (GET_CPC (), GET_CPC_UN (),
3840 DECL_INNER_CLASS_LIST (enclosing));
3841 }
3842 }
3843
3844 static tree
3845 maybe_make_nested_class_name (tree name)
3846 {
3847 tree id = NULL_TREE;
3848
3849 if (CPC_INNER_P ())
3850 {
3851 /* If we're in a function, we must append a number to create the
3852 nested class name. However, we don't do this if the class we
3853 are constructing is anonymous, because in that case we'll
3854 already have a number as the class name. */
3855 if (! make_nested_class_name (GET_CPC_LIST ())
3856 && current_function_decl != NULL_TREE
3857 && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3858 {
3859 char buf[10];
3860 sprintf (buf, "%d", anonymous_class_counter);
3861 ++anonymous_class_counter;
3862 obstack_grow (&temporary_obstack, buf, strlen (buf));
3863 obstack_1grow (&temporary_obstack, '$');
3864 }
3865 obstack_grow0 (&temporary_obstack,
3866 IDENTIFIER_POINTER (name),
3867 IDENTIFIER_LENGTH (name));
3868 id = get_identifier (obstack_finish (&temporary_obstack));
3869 if (ctxp->package)
3870 QUALIFIED_P (id) = 1;
3871 }
3872 return id;
3873 }
3874
3875 /* If DECL is NULL, create and push a new DECL, record the current
3876 line CL and do other maintenance things. */
3877
3878 static tree
3879 maybe_create_class_interface_decl (tree decl, tree raw_name,
3880 tree qualified_name, tree cl)
3881 {
3882 if (!decl)
3883 decl = push_class (make_class (), qualified_name);
3884
3885 /* Take care of the file and line business */
3886 #ifdef USE_MAPPED_LOCATION
3887 DECL_SOURCE_LOCATION (decl) = EXPR_LOCATION (cl);
3888 #else
3889 DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3890 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3891 #endif
3892 CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3893 CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3894 #ifdef USE_MAPPED_LOCATION
3895 {
3896 tree tmp = maybe_get_identifier (EXPR_FILENAME (cl));
3897 CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3898 tmp && IS_A_COMMAND_LINE_FILENAME_P (tmp);
3899 }
3900 #else
3901 CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3902 IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3903 #endif
3904
3905 PUSH_CPC (decl, raw_name);
3906 DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3907
3908 /* Link the declaration to the already seen ones */
3909 TREE_CHAIN (decl) = ctxp->class_list;
3910 ctxp->class_list = decl;
3911
3912 /* Create a new nodes in the global lists */
3913 gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3914 all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3915
3916 /* Install a new dependency list element */
3917 create_jdep_list (ctxp);
3918
3919 /* We keep the compilation unit imports in the class so that
3920 they can be used later to resolve type dependencies that
3921 aren't necessary to solve now. */
3922 TYPE_IMPORT_LIST (TREE_TYPE (decl)) = ctxp->import_list;
3923 TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (decl)) = ctxp->import_demand_list;
3924
3925 TYPE_PACKAGE (TREE_TYPE (decl)) = ctxp->package;
3926
3927 SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3928 IDENTIFIER_POINTER (qualified_name)));
3929 return decl;
3930 }
3931
3932 static void
3933 add_superinterfaces (tree decl, tree interface_list)
3934 {
3935 tree node;
3936 /* Superinterface(s): if present and defined, parser_check_super_interface ()
3937 takes care of ensuring that:
3938 - This is an accessible interface type,
3939 - Circularity detection.
3940 parser_add_interface is then called. If present but not defined,
3941 the check operation is delayed until the super interface gets
3942 defined. */
3943 for (node = interface_list; node; node = TREE_CHAIN (node))
3944 {
3945 tree current = TREE_PURPOSE (node);
3946 tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3947 if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3948 {
3949 if (!parser_check_super_interface (idecl, decl, current))
3950 parser_add_interface (decl, idecl, current);
3951 }
3952 else
3953 register_incomplete_type (JDEP_INTERFACE,
3954 current, decl, NULL_TREE);
3955 }
3956 }
3957
3958 /* Create an interface in pass1 and return its decl. Return the
3959 interface's decl in pass 2. */
3960
3961 static tree
3962 create_interface (int flags, tree id, tree super)
3963 {
3964 tree raw_name = EXPR_WFL_NODE (id);
3965 tree q_name = parser_qualified_classname (raw_name);
3966 tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3967
3968 /* Certain syntax errors are making SUPER be like ID. Avoid this
3969 case. */
3970 if (ctxp->class_err && id == super)
3971 super = NULL;
3972
3973 EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */
3974
3975 /* Basic checks: scope, redefinition, modifiers */
3976 if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3977 {
3978 PUSH_ERROR ();
3979 return NULL_TREE;
3980 }
3981
3982 /* Suspend the current parsing context if we're parsing an inner
3983 interface */
3984 if (CPC_INNER_P ())
3985 {
3986 java_parser_context_suspend ();
3987 /* Interface members are public. */
3988 if (CLASS_INTERFACE (GET_CPC ()))
3989 flags |= ACC_PUBLIC;
3990 }
3991
3992 /* Push a new context for (static) initialized upon declaration fields */
3993 java_parser_context_push_initialized_field ();
3994
3995 /* Interface modifiers check
3996 - public/abstract allowed (already done at that point)
3997 - abstract is obsolete (comes first, it's a warning, or should be)
3998 - Can't use twice the same (checked in the modifier rule) */
3999 if ((flags & ACC_ABSTRACT) && flag_redundant)
4000 parse_warning_context
4001 (MODIFIER_WFL (ABSTRACT_TK),
4002 "Redundant use of %<abstract%> modifier. Interface %qs is implicitly abstract", IDENTIFIER_POINTER (raw_name));
4003
4004 /* Create a new decl if DECL is NULL, otherwise fix it */
4005 decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
4006
4007 /* Interfaces are always abstract. */
4008 flags |= ACC_ABSTRACT;
4009
4010 /* Inner interfaces are always static. */
4011 if (INNER_CLASS_DECL_P (decl))
4012 flags |= ACC_STATIC;
4013
4014 /* Set super info and mark the class a complete */
4015 set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
4016 object_type_node, ctxp->interface_number);
4017 ctxp->interface_number = 0;
4018 CLASS_COMPLETE_P (decl) = 1;
4019 add_superinterfaces (decl, super);
4020
4021 /* Eventually sets the @deprecated tag flag */
4022 CHECK_DEPRECATED (decl);
4023
4024 return decl;
4025 }
4026
4027 /* Patch anonymous class CLASS, by either extending or implementing
4028 DEP. */
4029
4030 static void
4031 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
4032 {
4033 tree class = TREE_TYPE (class_decl);
4034 tree type = TREE_TYPE (type_decl);
4035 tree binfo = TYPE_BINFO (class);
4036
4037 /* If it's an interface, implement it */
4038 if (CLASS_INTERFACE (type_decl))
4039 {
4040 if (parser_check_super_interface (type_decl, class_decl, wfl))
4041 return;
4042
4043 if (!VEC_space (tree, BINFO_BASE_BINFOS (binfo), 1))
4044 {
4045 /* Extend the binfo - by reallocating and copying it. */
4046 tree new_binfo;
4047 tree base_binfo;
4048 int i;
4049
4050 new_binfo = make_tree_binfo ((BINFO_N_BASE_BINFOS (binfo) + 1) * 2);
4051 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4052 BINFO_BASE_APPEND (new_binfo, base_binfo);
4053 CLASS_HAS_SUPER_FLAG (new_binfo) = CLASS_HAS_SUPER_FLAG (binfo);
4054 BINFO_VTABLE (new_binfo) = BINFO_VTABLE (binfo);
4055 TYPE_BINFO (class) = new_binfo;
4056 }
4057
4058 /* And add the interface */
4059 parser_add_interface (class_decl, type_decl, wfl);
4060 }
4061 /* Otherwise, it's a type we want to extend */
4062 else
4063 {
4064 if (parser_check_super (type_decl, class_decl, wfl))
4065 return;
4066 BINFO_TYPE (BINFO_BASE_BINFO (binfo, 0)) = type;
4067 }
4068 }
4069
4070 /* Create an anonymous class which extends/implements TYPE_NAME, and return
4071 its decl. */
4072
4073 static tree
4074 create_anonymous_class (tree type_name)
4075 {
4076 char buffer [80];
4077 tree super = NULL_TREE, itf = NULL_TREE;
4078 tree id, type_decl, class;
4079
4080 /* The unqualified name of the anonymous class. It's just a number. */
4081 sprintf (buffer, "%d", anonymous_class_counter++);
4082 id = build_wfl_node (get_identifier (buffer));
4083 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL (type_name);
4084
4085 /* We know about the type to extend/implement. We go ahead */
4086 if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
4087 {
4088 /* Create a class which either implements on extends the designated
4089 class. The class bears an inaccessible name. */
4090 if (CLASS_INTERFACE (type_decl))
4091 {
4092 /* It's OK to modify it here. It's been already used and
4093 shouldn't be reused */
4094 ctxp->interface_number = 1;
4095 /* Interfaces should presented as a list of WFLs */
4096 itf = build_tree_list (type_name, NULL_TREE);
4097 }
4098 else
4099 super = type_name;
4100 }
4101
4102 class = create_class (ACC_FINAL, id, super, itf);
4103
4104 /* We didn't know anything about the stuff. We register a dependence. */
4105 if (!type_decl)
4106 register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
4107
4108 ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
4109 return class;
4110 }
4111
4112 /* Create a class in pass1 and return its decl. Return class
4113 interface's decl in pass 2. */
4114
4115 static tree
4116 create_class (int flags, tree id, tree super, tree interfaces)
4117 {
4118 tree raw_name = EXPR_WFL_NODE (id);
4119 tree class_id, decl;
4120 tree super_decl_type;
4121
4122 /* Certain syntax errors are making SUPER be like ID. Avoid this
4123 case. */
4124 if (ctxp->class_err && id == super)
4125 super = NULL;
4126
4127 class_id = parser_qualified_classname (raw_name);
4128 decl = IDENTIFIER_CLASS_VALUE (class_id);
4129 EXPR_WFL_NODE (id) = class_id;
4130
4131 /* Basic check: scope, redefinition, modifiers */
4132 if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
4133 {
4134 PUSH_ERROR ();
4135 return NULL_TREE;
4136 }
4137
4138 /* Suspend the current parsing context if we're parsing an inner
4139 class or an anonymous class. */
4140 if (CPC_INNER_P ())
4141 {
4142 java_parser_context_suspend ();
4143 /* Interface members are public. */
4144 if (CLASS_INTERFACE (GET_CPC ()))
4145 flags |= ACC_PUBLIC;
4146 }
4147
4148 /* Push a new context for (static) initialized upon declaration fields */
4149 java_parser_context_push_initialized_field ();
4150
4151 /* Class modifier check:
4152 - Allowed modifier (already done at that point)
4153 - abstract AND final forbidden
4154 - Public classes defined in the correct file */
4155 if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
4156 parse_error_context
4157 (id, "Class %qs can't be declared both abstract and final",
4158 IDENTIFIER_POINTER (raw_name));
4159
4160 /* Create a new decl if DECL is NULL, otherwise fix it */
4161 decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
4162
4163 /* If SUPER exists, use it, otherwise use Object */
4164 if (super)
4165 {
4166 /* java.lang.Object can't extend anything. */
4167 if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4168 {
4169 parse_error_context (id, "%<java.lang.Object%> can't extend anything");
4170 return NULL_TREE;
4171 }
4172
4173 super_decl_type =
4174 register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4175 }
4176 else if (TREE_TYPE (decl) != object_type_node)
4177 super_decl_type = object_type_node;
4178 /* We're defining java.lang.Object */
4179 else
4180 super_decl_type = NULL_TREE;
4181
4182 /* A class nested in an interface is implicitly static. */
4183 if (INNER_CLASS_DECL_P (decl)
4184 && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4185 {
4186 flags |= ACC_STATIC;
4187 }
4188
4189 /* Set super info and mark the class as complete. */
4190 set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4191 ctxp->interface_number);
4192 ctxp->interface_number = 0;
4193 CLASS_COMPLETE_P (decl) = 1;
4194 add_superinterfaces (decl, interfaces);
4195
4196 /* TYPE_VFIELD' is a compiler-generated field used to point to
4197 virtual function tables. In gcj, every class has a common base
4198 virtual function table in java.lang.object. */
4199 TYPE_VFIELD (TREE_TYPE (decl)) = TYPE_VFIELD (object_type_node);
4200
4201 /* Add the private this$<n> field, Replicate final locals still in
4202 scope as private final fields mangled like val$<local_name>.
4203 This does not occur for top level (static) inner classes. */
4204 if (PURE_INNER_CLASS_DECL_P (decl))
4205 add_inner_class_fields (decl, current_function_decl);
4206
4207 /* Eventually sets the @deprecated tag flag */
4208 CHECK_DEPRECATED (decl);
4209
4210 /* Reset the anonymous class counter when declaring non inner classes */
4211 if (!INNER_CLASS_DECL_P (decl))
4212 anonymous_class_counter = 1;
4213
4214 return decl;
4215 }
4216
4217 /* End a class declaration: register the statements used to create
4218 finit$ and <clinit>, pop the current class and resume the prior
4219 parser context if necessary. */
4220
4221 static void
4222 end_class_declaration (int resume)
4223 {
4224 /* If an error occurred, context weren't pushed and won't need to be
4225 popped by a resume. */
4226 int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4227
4228 if (GET_CPC () != error_mark_node)
4229 dump_java_tree (TDI_class, GET_CPC ());
4230
4231 java_parser_context_pop_initialized_field ();
4232 POP_CPC ();
4233 if (resume && no_error_occurred)
4234 java_parser_context_resume ();
4235
4236 /* We're ending a class declaration, this is a good time to reset
4237 the interface cout. Note that might have been already done in
4238 create_interface, but if at that time an inner class was being
4239 dealt with, the interface count was reset in a context created
4240 for the sake of handling inner classes declaration. */
4241 ctxp->interface_number = 0;
4242 }
4243
4244 static void
4245 add_inner_class_fields (tree class_decl, tree fct_decl)
4246 {
4247 tree block, marker, f;
4248
4249 f = add_field (TREE_TYPE (class_decl),
4250 build_current_thisn (TREE_TYPE (class_decl)),
4251 build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4252 ACC_PRIVATE);
4253 FIELD_THISN (f) = 1;
4254
4255 if (!fct_decl)
4256 return;
4257
4258 for (block = GET_CURRENT_BLOCK (fct_decl);
4259 block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4260 {
4261 tree decl;
4262 for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4263 {
4264 tree name, pname;
4265 tree wfl, init, list;
4266
4267 /* Avoid non final arguments. */
4268 if (!LOCAL_FINAL_P (decl))
4269 continue;
4270
4271 MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4272 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4273 wfl = build_wfl_node (name);
4274 init = build_wfl_node (pname);
4275 /* Build an initialization for the field: it will be
4276 initialized by a parameter added to finit$, bearing a
4277 mangled name of the field itself (param$<n>.) The
4278 parameter is provided to finit$ by the constructor
4279 invoking it (hence the constructor will also feature a
4280 hidden parameter, set to the value of the outer context
4281 local at the time the inner class is created.)
4282
4283 Note: we take into account all possible locals that can
4284 be accessed by the inner class. It's actually not trivial
4285 to minimize these aliases down to the ones really
4286 used. One way to do that would be to expand all regular
4287 methods first, then finit$ to get a picture of what's
4288 used. It works with the exception that we would have to
4289 go back on all constructor invoked in regular methods to
4290 have their invocation reworked (to include the right amount
4291 of alias initializer parameters.)
4292
4293 The only real way around, I think, is a first pass to
4294 identify locals really used in the inner class. We leave
4295 the flag FIELD_LOCAL_ALIAS_USED around for that future
4296 use.
4297
4298 On the other hand, it only affect local inner classes,
4299 whose constructors (and finit$ call) will be featuring
4300 unnecessary arguments. It's easy for a developer to keep
4301 this number of parameter down by using the `final'
4302 keyword only when necessary. For the time being, we can
4303 issue a warning on unnecessary finals. FIXME */
4304 init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4305 wfl, init);
4306
4307 /* Register the field. The TREE_LIST holding the part
4308 initialized/initializer will be marked ARG_FINAL_P so
4309 that the created field can be marked
4310 FIELD_LOCAL_ALIAS. */
4311 list = build_tree_list (wfl, init);
4312 ARG_FINAL_P (list) = 1;
4313 register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4314 }
4315 }
4316
4317 if (!CPC_INITIALIZER_STMT (ctxp))
4318 return;
4319
4320 /* If we ever registered an alias field, insert and marker to
4321 remember where the list ends. The second part of the list (the one
4322 featuring initialized fields) so it can be later reversed to
4323 enforce 8.5. The marker will be removed during that operation. */
4324 marker = build_tree_list (NULL_TREE, NULL_TREE);
4325 TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4326 SET_CPC_INITIALIZER_STMT (ctxp, marker);
4327 }
4328
4329 /* Can't use lookup_field () since we don't want to load the class and
4330 can't set the CLASS_LOADED_P flag */
4331
4332 static tree
4333 find_field (tree class, tree name)
4334 {
4335 tree decl;
4336 for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4337 {
4338 if (DECL_NAME (decl) == name)
4339 return decl;
4340 }
4341 return NULL_TREE;
4342 }
4343
4344 /* Wrap around lookup_field that doesn't potentially upset the value
4345 of CLASS */
4346
4347 static tree
4348 lookup_field_wrapper (tree class, tree name)
4349 {
4350 tree type = class;
4351 tree decl = NULL_TREE;
4352 java_parser_context_save_global ();
4353
4354 /* Last chance: if we're within the context of an inner class, we
4355 might be trying to access a local variable defined in an outer
4356 context. We try to look for it now. */
4357 if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4358 {
4359 tree new_name;
4360 MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4361 decl = lookup_field (&type, new_name);
4362 if (decl && decl != error_mark_node)
4363 FIELD_LOCAL_ALIAS_USED (decl) = 1;
4364 }
4365 if (!decl || decl == error_mark_node)
4366 {
4367 type = class;
4368 decl = lookup_field (&type, name);
4369 }
4370
4371 /* If the field still hasn't been found, try the next enclosing context. */
4372 if (!decl && INNER_CLASS_TYPE_P (class))
4373 {
4374 tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4375 decl = lookup_field_wrapper (outer_type, name);
4376 }
4377
4378 java_parser_context_restore_global ();
4379 return decl == error_mark_node ? NULL : decl;
4380 }
4381
4382 /* Find duplicate field within the same class declarations and report
4383 the error. Returns 1 if a duplicated field was found, 0
4384 otherwise. */
4385
4386 static int
4387 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4388 {
4389 /* This might be modified to work with method decl as well */
4390 tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4391 if (decl)
4392 {
4393 char *t1 = xstrdup (purify_type_name
4394 ((TREE_CODE (new_type) == POINTER_TYPE
4395 && TREE_TYPE (new_type) == NULL_TREE) ?
4396 IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4397 lang_printable_name (new_type, 1)));
4398 /* The type may not have been completed by the time we report
4399 the error */
4400 char *t2 = xstrdup (purify_type_name
4401 ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4402 && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4403 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4404 lang_printable_name (TREE_TYPE (decl), 1)));
4405 parse_error_context
4406 (cl, "Duplicate variable declaration: %<%s %s%> was %<%s %s%> (%s:%d)",
4407 t1, IDENTIFIER_POINTER (new_field_name),
4408 t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4409 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4410 free (t1);
4411 free (t2);
4412 return 1;
4413 }
4414 return 0;
4415 }
4416
4417 /* Field registration routine. If TYPE doesn't exist, field
4418 declarations are linked to the undefined TYPE dependency list, to
4419 be later resolved in java_complete_class () */
4420
4421 static void
4422 register_fields (int flags, tree type, tree variable_list)
4423 {
4424 tree current, saved_type;
4425 tree class_type = NULL_TREE;
4426 location_t saved_location = input_location;
4427 int must_chain = 0;
4428 tree wfl = NULL_TREE;
4429
4430 if (GET_CPC ())
4431 class_type = TREE_TYPE (GET_CPC ());
4432
4433 if (!class_type || class_type == error_mark_node)
4434 return;
4435
4436 /* If we're adding fields to interfaces, those fields are public,
4437 static, final */
4438 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4439 {
4440 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4441 flags, ACC_PUBLIC, "interface field(s)");
4442 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4443 flags, ACC_STATIC, "interface field(s)");
4444 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4445 flags, ACC_FINAL, "interface field(s)");
4446 check_modifiers ("Illegal interface member modifier %qs", flags,
4447 INTERFACE_FIELD_MODIFIERS);
4448 flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4449 }
4450
4451 /* Obtain a suitable type for resolution, if necessary */
4452 SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4453
4454 /* If TYPE is fully resolved and we don't have a reference, make one */
4455 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4456
4457 for (current = variable_list, saved_type = type; current;
4458 current = TREE_CHAIN (current), type = saved_type)
4459 {
4460 tree real_type;
4461 tree field_decl;
4462 tree cl = TREE_PURPOSE (current);
4463 tree init = TREE_VALUE (current);
4464 tree current_name = EXPR_WFL_NODE (cl);
4465
4466 /* Can't declare non-final static fields in inner classes */
4467 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4468 && !(flags & ACC_FINAL))
4469 parse_error_context
4470 (cl, "Field %qs can't be static in inner class %qs unless it is final",
4471 IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4472 lang_printable_name (class_type, 0));
4473
4474 /* Process NAME, as it may specify extra dimension(s) for it */
4475 type = build_array_from_name (type, wfl, current_name, &current_name);
4476
4477 /* Type adjustment. We may have just readjusted TYPE because
4478 the variable specified more dimensions. Make sure we have
4479 a reference if we can and don't have one already. Also
4480 change the name if we have an init. */
4481 if (type != saved_type)
4482 {
4483 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4484 if (init)
4485 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4486 }
4487
4488 real_type = GET_REAL_TYPE (type);
4489 /* Check for redeclarations */
4490 if (duplicate_declaration_error_p (current_name, real_type, cl))
4491 continue;
4492
4493 /* Set input_line to the line the field was found and create a
4494 declaration for it. Eventually sets the @deprecated tag flag. */
4495 #ifdef USE_MAPPED_LOCATION
4496 input_location = EXPR_LOCATION (cl);
4497 #else
4498 input_line = EXPR_WFL_LINENO (cl);
4499 #endif
4500 field_decl = add_field (class_type, current_name, real_type, flags);
4501 CHECK_DEPRECATED_NO_RESET (field_decl);
4502
4503 /* If the field denotes a final instance variable, then we
4504 allocate a LANG_DECL_SPECIFIC part to keep track of its
4505 initialization. We also mark whether the field was
4506 initialized upon its declaration. We don't do that if the
4507 created field is an alias to a final local. */
4508 if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4509 {
4510 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4511 DECL_FIELD_FINAL_WFL (field_decl) = cl;
4512 }
4513
4514 /* If the couple initializer/initialized is marked ARG_FINAL_P,
4515 we mark the created field FIELD_LOCAL_ALIAS, so that we can
4516 hide parameters to this inner class finit$ and
4517 constructors. It also means that the field isn't final per
4518 say. */
4519 if (ARG_FINAL_P (current))
4520 {
4521 FIELD_LOCAL_ALIAS (field_decl) = 1;
4522 FIELD_FINAL (field_decl) = 0;
4523 }
4524
4525 /* Check if we must chain. */
4526 if (must_chain)
4527 register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4528
4529 /* If we have an initialization value tied to the field */
4530 if (init)
4531 {
4532 /* The field is declared static */
4533 if (flags & ACC_STATIC)
4534 {
4535 /* We include the field and its initialization part into
4536 a list used to generate <clinit>. After <clinit> is
4537 walked, field initializations will be processed and
4538 fields initialized with known constants will be taken
4539 out of <clinit> and have their DECL_INITIAL set
4540 appropriately. */
4541 TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4542 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4543 if (TREE_OPERAND (init, 1)
4544 && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4545 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4546 }
4547 /* A non-static field declared with an immediate initialization is
4548 to be initialized in <init>, if any. This field is remembered
4549 to be processed at the time of the generation of <init>. */
4550 else
4551 {
4552 TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4553 SET_CPC_INITIALIZER_STMT (ctxp, init);
4554 }
4555 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4556 DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4557 }
4558 }
4559
4560 CLEAR_DEPRECATED;
4561 input_location = saved_location;
4562 }
4563
4564 /* Generate finit$, using the list of initialized fields to populate
4565 its body. finit$'s parameter(s) list is adjusted to include the
4566 one(s) used to initialized the field(s) caching outer context
4567 local(s). */
4568
4569 static tree
4570 generate_finit (tree class_type)
4571 {
4572 int count = 0;
4573 tree list = TYPE_FINIT_STMT_LIST (class_type);
4574 tree mdecl, current, parms;
4575
4576 parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4577 class_type, NULL_TREE,
4578 &count);
4579 CRAFTED_PARAM_LIST_FIXUP (parms);
4580 mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4581 finit_identifier_node, parms);
4582 fix_method_argument_names (parms, mdecl);
4583 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4584 mdecl, NULL_TREE);
4585 DECL_FUNCTION_NAP (mdecl) = count;
4586 start_artificial_method_body (mdecl);
4587
4588 for (current = list; current; current = TREE_CHAIN (current))
4589 java_method_add_stmt (mdecl,
4590 build_debugable_stmt (EXPR_WFL_LINECOL (current),
4591 current));
4592 end_artificial_method_body (mdecl);
4593 return mdecl;
4594 }
4595
4596 /* Generate a function to run the instance initialization code. The
4597 private method is called `instinit$'. Unless we're dealing with an
4598 anonymous class, we determine whether all ctors of CLASS_TYPE
4599 declare a checked exception in their `throws' clause in order to
4600 see whether it's necessary to encapsulate the instance initializer
4601 statements in a try/catch/rethrow sequence. */
4602
4603 static tree
4604 generate_instinit (tree class_type)
4605 {
4606 tree current;
4607 tree compound = NULL_TREE;
4608 tree parms = tree_cons (this_identifier_node,
4609 build_pointer_type (class_type), end_params_node);
4610 tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4611 void_type_node,
4612 instinit_identifier_node, parms);
4613
4614 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4615 mdecl, NULL_TREE);
4616
4617 /* Gather all the statements in a compound */
4618 for (current = TYPE_II_STMT_LIST (class_type);
4619 current; current = TREE_CHAIN (current))
4620 compound = add_stmt_to_compound (compound, NULL_TREE, current);
4621
4622 /* We need to encapsulate COMPOUND by a try/catch statement to
4623 rethrow exceptions that might occur in the instance initializer.
4624 We do that only if all ctors of CLASS_TYPE are set to catch a
4625 checked exception. This doesn't apply to anonymous classes (since
4626 they don't have declared ctors.) */
4627 if (!ANONYMOUS_CLASS_P (class_type) &&
4628 ctors_unchecked_throws_clause_p (class_type))
4629 {
4630 compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4631 build1 (THROW_EXPR, NULL_TREE,
4632 build_wfl_node (wpv_id)));
4633 DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4634 exception_type_node);
4635 }
4636
4637 start_artificial_method_body (mdecl);
4638 java_method_add_stmt (mdecl, compound);
4639 end_artificial_method_body (mdecl);
4640
4641 return mdecl;
4642 }
4643
4644 /* FIXME */
4645 static tree
4646 build_instinit_invocation (tree class_type)
4647 {
4648 tree to_return = NULL_TREE;
4649
4650 if (TYPE_II_STMT_LIST (class_type))
4651 {
4652 tree parm = build_tree_list (NULL_TREE,
4653 build_wfl_node (this_identifier_node));
4654 to_return =
4655 build_method_invocation (build_wfl_node (instinit_identifier_node),
4656 parm);
4657 }
4658 return to_return;
4659 }
4660
4661 /* Shared across method_declarator and method_header to remember the
4662 patch stage that was reached during the declaration of the method.
4663 A method DECL is built differently is there is no patch
4664 (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4665 pending on the currently defined method. */
4666
4667 static int patch_stage;
4668
4669 /* Check the method declaration and add the method to its current
4670 class. If the argument list is known to contain incomplete types,
4671 the method is partially added and the registration will be resume
4672 once the method arguments resolved. If TYPE is NULL, we're dealing
4673 with a constructor. */
4674
4675 static tree
4676 method_header (int flags, tree type, tree mdecl, tree throws)
4677 {
4678 tree type_wfl = NULL_TREE;
4679 tree meth_name = NULL_TREE;
4680 tree current, orig_arg, this_class = NULL;
4681 tree id, meth;
4682 location_t saved_location;
4683 int constructor_ok = 0, must_chain;
4684 int count;
4685
4686 if (mdecl == error_mark_node)
4687 return error_mark_node;
4688 meth = TREE_VALUE (mdecl);
4689 id = TREE_PURPOSE (mdecl);
4690
4691 check_modifiers_consistency (flags);
4692
4693 if (GET_CPC ())
4694 this_class = TREE_TYPE (GET_CPC ());
4695
4696 if (!this_class || this_class == error_mark_node)
4697 return NULL_TREE;
4698
4699 /* There are some forbidden modifiers for an abstract method and its
4700 class must be abstract as well. */
4701 if (type && (flags & ACC_ABSTRACT))
4702 {
4703 ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4704 ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4705 ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4706 ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4707 ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4708 ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4709 if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4710 && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4711 parse_error_context
4712 (id,
4713 "Class %qs must be declared abstract to define abstract method %qs",
4714 IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4715 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4716 }
4717
4718 /* A native method can't be strictfp. */
4719 if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4720 parse_error_context (id, "native method %qs can't be strictfp",
4721 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4722 /* No such thing as a transient or volatile method. */
4723 if ((flags & ACC_TRANSIENT))
4724 parse_error_context (id, "method %qs can't be transient",
4725 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4726 if ((flags & ACC_VOLATILE))
4727 parse_error_context (id, "method %qs can't be volatile",
4728 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4729
4730 /* Things to be checked when declaring a constructor */
4731 if (!type)
4732 {
4733 int ec = java_error_count;
4734 /* 8.6: Constructor declarations: we might be trying to define a
4735 method without specifying a return type. */
4736 if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4737 parse_error_context
4738 (id, "Invalid method declaration, return type required");
4739 /* 8.6.3: Constructor modifiers */
4740 else
4741 {
4742 JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4743 JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4744 JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4745 JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4746 JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4747 JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4748 }
4749 /* If we found error here, we don't consider it's OK to tread
4750 the method definition as a constructor, for the rest of this
4751 function */
4752 if (ec == java_error_count)
4753 constructor_ok = 1;
4754 }
4755
4756 /* Method declared within the scope of an interface are implicitly
4757 abstract and public. Conflicts with other erroneously provided
4758 modifiers are checked right after. */
4759
4760 if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4761 {
4762 /* If FLAGS isn't set because of a modifier, turn the
4763 corresponding modifier WFL to NULL so we issue a warning on
4764 the obsolete use of the modifier */
4765 if (!(flags & ACC_PUBLIC))
4766 MODIFIER_WFL (PUBLIC_TK) = NULL;
4767 if (!(flags & ACC_ABSTRACT))
4768 MODIFIER_WFL (ABSTRACT_TK) = NULL;
4769 flags |= ACC_PUBLIC;
4770 flags |= ACC_ABSTRACT;
4771 }
4772
4773 /* Inner class can't declare static methods */
4774 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4775 {
4776 parse_error_context
4777 (id, "Method %qs can't be static in inner class %qs. Only members of interfaces and top-level classes can be static",
4778 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4779 lang_printable_name (this_class, 0));
4780 }
4781
4782 /* Modifiers context reset moved up, so abstract method declaration
4783 modifiers can be later checked. */
4784
4785 /* Set constructor returned type to void and method name to <init>,
4786 unless we found an error identifier the constructor (in which
4787 case we retain the original name) */
4788 if (!type)
4789 {
4790 type = void_type_node;
4791 if (constructor_ok)
4792 meth_name = init_identifier_node;
4793 }
4794 else
4795 meth_name = EXPR_WFL_NODE (id);
4796
4797 /* Do the returned type resolution and registration if necessary */
4798 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4799
4800 if (meth_name)
4801 type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4802 EXPR_WFL_NODE (id) = meth_name;
4803 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4804
4805 if (must_chain)
4806 {
4807 patch_stage = JDEP_METHOD_RETURN;
4808 register_incomplete_type (patch_stage, type_wfl, id, type);
4809 TREE_TYPE (meth) = GET_REAL_TYPE (type);
4810 }
4811 else
4812 TREE_TYPE (meth) = type;
4813
4814 saved_location = input_location;
4815 /* When defining an abstract or interface method, the curly
4816 bracket at level 1 doesn't exist because there is no function
4817 body */
4818 #ifdef USE_MAPPED_LOCATION
4819 input_location = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4820 EXPR_LOCATION (id));
4821 #else
4822 input_line = (ctxp->first_ccb_indent1 ? (int) ctxp->first_ccb_indent1 :
4823 EXPR_WFL_LINENO (id));
4824 #endif
4825
4826 /* Remember the original argument list */
4827 orig_arg = TYPE_ARG_TYPES (meth);
4828
4829 if (patch_stage) /* includes ret type and/or all args */
4830 {
4831 jdep *jdep;
4832 meth = add_method_1 (this_class, flags, meth_name, meth);
4833 /* Patch for the return type */
4834 if (patch_stage == JDEP_METHOD_RETURN)
4835 {
4836 jdep = CLASSD_LAST (ctxp->classd_list);
4837 JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4838 }
4839 /* This is the stop JDEP. METH allows the function's signature
4840 to be computed. */
4841 register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4842 }
4843 else
4844 meth = add_method (this_class, flags, meth_name,
4845 build_java_signature (meth));
4846
4847 /* Remember final parameters */
4848 MARK_FINAL_PARMS (meth, orig_arg);
4849
4850 /* Fix the method argument list so we have the argument name
4851 information */
4852 fix_method_argument_names (orig_arg, meth);
4853
4854 /* Register the parameter number and re-install the current line
4855 number */
4856 DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4857 input_location = saved_location;
4858
4859 /* Register exception specified by the `throws' keyword for
4860 resolution and set the method decl appropriate field to the list.
4861 Note: the grammar ensures that what we get here are class
4862 types. */
4863 if (throws)
4864 {
4865 throws = nreverse (throws);
4866 for (current = throws; current; current = TREE_CHAIN (current))
4867 {
4868 register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4869 NULL_TREE, NULL_TREE);
4870 JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4871 &TREE_VALUE (current);
4872 }
4873 DECL_FUNCTION_THROWS (meth) = throws;
4874 }
4875
4876 if (TREE_TYPE (GET_CPC ()) != object_type_node)
4877 DECL_FUNCTION_WFL (meth) = id;
4878
4879 /* Set the flag if we correctly processed a constructor */
4880 if (constructor_ok)
4881 {
4882 DECL_CONSTRUCTOR_P (meth) = 1;
4883 /* Compute and store the number of artificial parameters declared
4884 for this constructor */
4885 for (count = 0, current = TYPE_FIELDS (this_class); current;
4886 current = TREE_CHAIN (current))
4887 if (FIELD_LOCAL_ALIAS (current))
4888 count++;
4889 DECL_FUNCTION_NAP (meth) = count;
4890 }
4891
4892 /* Eventually set the @deprecated tag flag */
4893 CHECK_DEPRECATED (meth);
4894
4895 return meth;
4896 }
4897
4898 static void
4899 fix_method_argument_names (tree orig_arg, tree meth)
4900 {
4901 tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4902 if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4903 {
4904 TREE_PURPOSE (arg) = this_identifier_node;
4905 arg = TREE_CHAIN (arg);
4906 }
4907 while (orig_arg != end_params_node)
4908 {
4909 TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4910 orig_arg = TREE_CHAIN (orig_arg);
4911 arg = TREE_CHAIN (arg);
4912 }
4913 }
4914
4915 /* Complete the method declaration with METHOD_BODY. */
4916
4917 static void
4918 finish_method_declaration (tree method_body)
4919 {
4920 int flags;
4921
4922 if (!current_function_decl)
4923 return;
4924
4925 flags = get_access_flags_from_decl (current_function_decl);
4926
4927 /* 8.4.5 Method Body */
4928 if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4929 {
4930 tree name = DECL_NAME (current_function_decl);
4931 parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4932 "%s method %qs can't have a body defined",
4933 (METHOD_NATIVE (current_function_decl) ?
4934 "Native" : "Abstract"),
4935 IDENTIFIER_POINTER (name));
4936 method_body = NULL_TREE;
4937 }
4938 else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4939 {
4940 tree name = DECL_NAME (current_function_decl);
4941 parse_error_context
4942 (DECL_FUNCTION_WFL (current_function_decl),
4943 "Non native and non abstract method %qs must have a body defined",
4944 IDENTIFIER_POINTER (name));
4945 method_body = NULL_TREE;
4946 }
4947
4948 if (flag_emit_class_files && method_body
4949 && TREE_CODE (method_body) == NOP_EXPR
4950 && TREE_TYPE (current_function_decl)
4951 && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4952 method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4953
4954 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4955 maybe_absorb_scoping_blocks ();
4956 /* Exit function's body */
4957 exit_block ();
4958 /* Merge last line of the function with first line, directly in the
4959 function decl. It will be used to emit correct debug info. */
4960 DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4961
4962 /* Since function's argument's list are shared, reset the
4963 ARG_FINAL_P parameter that might have been set on some of this
4964 function parameters. */
4965 UNMARK_FINAL_PARMS (current_function_decl);
4966
4967 /* So we don't have an irrelevant function declaration context for
4968 the next static block we'll see. */
4969 current_function_decl = NULL_TREE;
4970 }
4971
4972 /* Build a an error message for constructor circularity errors. */
4973
4974 static char *
4975 constructor_circularity_msg (tree from, tree to)
4976 {
4977 static char string [4096];
4978 char *t = xstrdup (lang_printable_name (from, 2));
4979 sprintf (string, "'%s' invokes '%s'", t, lang_printable_name (to, 2));
4980 free (t);
4981 return string;
4982 }
4983
4984 /* Verify a circular call to METH. Return 1 if an error is found, 0
4985 otherwise. */
4986
4987 static GTY(()) tree vcc_list;
4988 static int
4989 verify_constructor_circularity (tree meth, tree current)
4990 {
4991 tree c;
4992
4993 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4994 {
4995 if (TREE_VALUE (c) == meth)
4996 {
4997 char *t;
4998 if (vcc_list)
4999 {
5000 tree liste;
5001 vcc_list = nreverse (vcc_list);
5002 for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
5003 {
5004 parse_error_context
5005 (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
5006 constructor_circularity_msg
5007 (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
5008 java_error_count--;
5009 }
5010 }
5011 t = xstrdup (lang_printable_name (meth, 2));
5012 parse_error_context (TREE_PURPOSE (c),
5013 "%s: recursive invocation of constructor %qs",
5014 constructor_circularity_msg (current, meth), t);
5015 free (t);
5016 vcc_list = NULL_TREE;
5017 return 1;
5018 }
5019 }
5020 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
5021 {
5022 vcc_list = tree_cons (c, current, vcc_list);
5023 if (verify_constructor_circularity (meth, TREE_VALUE (c)))
5024 return 1;
5025 vcc_list = TREE_CHAIN (vcc_list);
5026 }
5027 return 0;
5028 }
5029
5030 /* Check modifiers that can be declared but exclusively */
5031
5032 static void
5033 check_modifiers_consistency (int flags)
5034 {
5035 int acc_count = 0;
5036 tree cl = NULL_TREE;
5037
5038 THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
5039 THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
5040 THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
5041 if (acc_count > 1)
5042 parse_error_context
5043 (cl, "Inconsistent member declaration. At most one of %<public%>, %<private%>, or %<protected%> may be specified");
5044
5045 acc_count = 0;
5046 cl = NULL_TREE;
5047 THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
5048 THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
5049 if (acc_count > 1)
5050 parse_error_context (cl,
5051 "Inconsistent member declaration. At most one of %<final%> or %<volatile%> may be specified");
5052 }
5053
5054 /* Check the methode header METH for abstract specifics features */
5055
5056 static void
5057 check_abstract_method_header (tree meth)
5058 {
5059 int flags = get_access_flags_from_decl (meth);
5060
5061 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
5062 ACC_ABSTRACT, "abstract method",
5063 IDENTIFIER_POINTER (DECL_NAME (meth)));
5064 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
5065 ACC_PUBLIC, "abstract method",
5066 IDENTIFIER_POINTER (DECL_NAME (meth)));
5067
5068 check_modifiers ("Illegal modifier %qs for interface method",
5069 flags, INTERFACE_METHOD_MODIFIERS);
5070 }
5071
5072 /* Create a FUNCTION_TYPE node and start augmenting it with the
5073 declared function arguments. Arguments type that can't be resolved
5074 are left as they are, but the returned node is marked as containing
5075 incomplete types. */
5076
5077 static tree
5078 method_declarator (tree id, tree list)
5079 {
5080 tree arg_types = NULL_TREE, current, node;
5081 tree meth = make_node (FUNCTION_TYPE);
5082 jdep *jdep;
5083
5084 patch_stage = JDEP_NO_PATCH;
5085
5086 if (GET_CPC () == error_mark_node)
5087 return error_mark_node;
5088
5089 /* If we're dealing with an inner class constructor, we hide the
5090 this$<n> decl in the name field of its parameter declaration. We
5091 also might have to hide the outer context local alias
5092 initializers. Not done when the class is a toplevel class. */
5093 if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
5094 && EXPR_WFL_NODE (id) == GET_CPC_UN ())
5095 {
5096 tree aliases_list, type, thisn;
5097 /* First the aliases, linked to the regular parameters */
5098 aliases_list =
5099 build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
5100 TREE_TYPE (GET_CPC ()),
5101 NULL_TREE, NULL);
5102 list = chainon (nreverse (aliases_list), list);
5103
5104 /* Then this$<n> */
5105 type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
5106 thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
5107 list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
5108 list);
5109 }
5110
5111 for (current = list; current; current = TREE_CHAIN (current))
5112 {
5113 int must_chain = 0;
5114 tree wfl_name = TREE_PURPOSE (current);
5115 tree type = TREE_VALUE (current);
5116 tree name = EXPR_WFL_NODE (wfl_name);
5117 tree already, arg_node;
5118 tree type_wfl = NULL_TREE;
5119 tree real_type;
5120
5121 /* Obtain a suitable type for resolution, if necessary */
5122 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
5123
5124 /* Process NAME, as it may specify extra dimension(s) for it */
5125 type = build_array_from_name (type, type_wfl, name, &name);
5126 EXPR_WFL_NODE (wfl_name) = name;
5127
5128 real_type = GET_REAL_TYPE (type);
5129 if (TREE_CODE (real_type) == RECORD_TYPE)
5130 {
5131 real_type = promote_type (real_type);
5132 if (TREE_CODE (type) == TREE_LIST)
5133 TREE_PURPOSE (type) = real_type;
5134 }
5135
5136 /* Check redefinition */
5137 for (already = arg_types; already; already = TREE_CHAIN (already))
5138 if (TREE_PURPOSE (already) == name)
5139 {
5140 parse_error_context
5141 (wfl_name, "Variable %qs is used more than once in the argument list of method %qs",
5142 IDENTIFIER_POINTER (name),
5143 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
5144 break;
5145 }
5146
5147 /* If we've an incomplete argument type, we know there is a location
5148 to patch when the type get resolved, later. */
5149 jdep = NULL;
5150 if (must_chain)
5151 {
5152 patch_stage = JDEP_METHOD;
5153 type = register_incomplete_type (patch_stage,
5154 type_wfl, wfl_name, type);
5155 jdep = CLASSD_LAST (ctxp->classd_list);
5156 JDEP_MISC (jdep) = id;
5157 }
5158
5159 /* The argument node: a name and a (possibly) incomplete type. */
5160 arg_node = build_tree_list (name, real_type);
5161 /* Remember arguments declared final. */
5162 ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5163
5164 if (jdep)
5165 JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5166 TREE_CHAIN (arg_node) = arg_types;
5167 arg_types = arg_node;
5168 }
5169 TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5170 node = build_tree_list (id, meth);
5171 return node;
5172 }
5173
5174 static int
5175 unresolved_type_p (tree wfl, tree *returned)
5176 {
5177 if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5178 {
5179 if (returned)
5180 {
5181 tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5182 if (decl && current_class && (decl == TYPE_NAME (current_class)))
5183 *returned = TREE_TYPE (decl);
5184 else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5185 *returned = TREE_TYPE (GET_CPC ());
5186 else
5187 *returned = NULL_TREE;
5188 }
5189 return 1;
5190 }
5191 if (returned)
5192 *returned = wfl;
5193 return 0;
5194 }
5195
5196 /* From NAME, build a qualified identifier node using the
5197 qualification from the current package definition. */
5198
5199 static tree
5200 parser_qualified_classname (tree name)
5201 {
5202 tree nested_class_name;
5203
5204 if ((nested_class_name = maybe_make_nested_class_name (name)))
5205 return nested_class_name;
5206
5207 if (ctxp->package)
5208 return merge_qualified_name (ctxp->package, name);
5209 else
5210 return name;
5211 }
5212
5213 /* Called once the type a interface extends is resolved. Returns 0 if
5214 everything is OK. */
5215
5216 static int
5217 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5218 {
5219 tree super_type = TREE_TYPE (super_decl);
5220
5221 /* Has to be an interface */
5222 if (!CLASS_INTERFACE (super_decl))
5223 {
5224 parse_error_context
5225 (this_wfl, "%s %qs can't implement/extend %s %qs",
5226 (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5227 "Interface" : "Class"),
5228 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5229 (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5230 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5231 return 1;
5232 }
5233
5234 /* Check top-level interface access. Inner classes are subject to member
5235 access rules (6.6.1). */
5236 if (! INNER_CLASS_P (super_type)
5237 && check_pkg_class_access (DECL_NAME (super_decl),
5238 NULL_TREE, true, this_decl))
5239 return 1;
5240
5241 SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5242 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5243 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5244 return 0;
5245 }
5246
5247 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5248 0 if everything is OK. */
5249
5250 static int
5251 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5252 {
5253 tree super_type = TREE_TYPE (super_decl);
5254
5255 /* SUPER should be a CLASS (neither an array nor an interface) */
5256 if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5257 {
5258 parse_error_context
5259 (wfl, "Class %qs can't subclass %s %qs",
5260 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5261 (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5262 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5263 return 1;
5264 }
5265
5266 if (CLASS_FINAL (TYPE_NAME (super_type)))
5267 {
5268 parse_error_context (wfl, "Can't subclass final classes: %s",
5269 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5270 return 1;
5271 }
5272
5273 /* Check top-level class scope. Inner classes are subject to member access
5274 rules (6.6.1). */
5275 if (! INNER_CLASS_P (super_type)
5276 && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true, NULL_TREE)))
5277 return 1;
5278
5279 SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5280 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5281 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5282 return 0;
5283 }
5284
5285 /* Create a new dependency list and link it (in a LIFO manner) to the
5286 CTXP list of type dependency list. */
5287
5288 static void
5289 create_jdep_list (struct parser_ctxt *ctxp)
5290 {
5291 jdeplist *new = xmalloc (sizeof (jdeplist));
5292 new->first = new->last = NULL;
5293 new->next = ctxp->classd_list;
5294 ctxp->classd_list = new;
5295 }
5296
5297 static jdeplist *
5298 reverse_jdep_list (struct parser_ctxt *ctxp)
5299 {
5300 jdeplist *prev = NULL, *current, *next;
5301 for (current = ctxp->classd_list; current; current = next)
5302 {
5303 next = current->next;
5304 current->next = prev;
5305 prev = current;
5306 }
5307 return prev;
5308 }
5309
5310 /* Create a fake pointer based on the ID stored in
5311 TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5312 registered again. */
5313
5314 static tree
5315 obtain_incomplete_type (tree type_name)
5316 {
5317 tree ptr = NULL_TREE, name;
5318
5319 if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5320 name = EXPR_WFL_NODE (type_name);
5321 else if (INCOMPLETE_TYPE_P (type_name))
5322 name = TYPE_NAME (type_name);
5323 else
5324 abort ();
5325
5326 /* Workaround from build_pointer_type for incomplete types. */
5327 BUILD_PTR_FROM_NAME (ptr, name);
5328 TYPE_MODE (ptr) = ptr_mode;
5329 layout_type (ptr);
5330
5331 return ptr;
5332 }
5333
5334 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5335 non NULL instead of computing a new fake type based on WFL. The new
5336 dependency is inserted in the current type dependency list, in FIFO
5337 manner. */
5338
5339 static tree
5340 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5341 {
5342 jdep *new = xmalloc (sizeof (jdep));
5343
5344 if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5345 ptr = obtain_incomplete_type (wfl);
5346
5347 JDEP_KIND (new) = kind;
5348 JDEP_DECL (new) = decl;
5349 JDEP_TO_RESOLVE (new) = ptr;
5350 JDEP_WFL (new) = wfl;
5351 JDEP_CHAIN (new) = NULL;
5352 JDEP_MISC (new) = NULL_TREE;
5353 /* For some dependencies, set the enclosing class of the current
5354 class to be the enclosing context */
5355 if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS || kind == JDEP_SUPER)
5356 && GET_ENCLOSING_CPC ())
5357 JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5358 else
5359 JDEP_ENCLOSING (new) = GET_CPC ();
5360 JDEP_GET_PATCH (new) = (tree *)NULL;
5361
5362 JDEP_INSERT (ctxp->classd_list, new);
5363
5364 return ptr;
5365 }
5366
5367 /* This checks for circular references with innerclasses. We start
5368 from SOURCE and should never reach TARGET. Extended/implemented
5369 types in SOURCE have their enclosing context checked not to reach
5370 TARGET. When the last enclosing context of SOURCE is reached, its
5371 extended/implemented types are also checked not to reach TARGET.
5372 In case of error, WFL of the offending type is returned; NULL_TREE
5373 otherwise. */
5374
5375 static tree
5376 check_inner_circular_reference (tree source, tree target)
5377 {
5378 tree base_binfo;
5379 tree ctx, cl;
5380 int i;
5381
5382 for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (source), i, base_binfo); i++)
5383 {
5384 tree su;
5385
5386 /* We can end up with a NULL_TREE or an incomplete type here if
5387 we encountered previous type resolution errors. It's safe to
5388 simply ignore these cases. */
5389 su = BINFO_TYPE (base_binfo);
5390 if (INCOMPLETE_TYPE_P (su))
5391 continue;
5392
5393 if (inherits_from_p (su, target))
5394 return lookup_cl (TYPE_NAME (su));
5395
5396 for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5397 {
5398 /* An enclosing context shouldn't be TARGET */
5399 if (ctx == TYPE_NAME (target))
5400 return lookup_cl (TYPE_NAME (su));
5401
5402 /* When we reach the enclosing last context, start a check
5403 on it, with the same target */
5404 if (! DECL_CONTEXT (ctx) &&
5405 (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5406 return cl;
5407 }
5408 }
5409 return NULL_TREE;
5410 }
5411
5412 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5413 offending type if a circularity is detected. NULL_TREE is returned
5414 otherwise. TYPE can be an interface or a class. */
5415
5416 static tree
5417 check_circular_reference (tree type)
5418 {
5419 tree base_binfo;
5420 int i;
5421
5422 if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
5423 return NULL_TREE;
5424
5425 if (! CLASS_INTERFACE (TYPE_NAME (type)))
5426 {
5427 if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5428 return lookup_cl (TYPE_NAME (type));
5429 return NULL_TREE;
5430 }
5431
5432 for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo); i++)
5433 {
5434 if (BINFO_TYPE (base_binfo) != object_type_node
5435 && interface_of_p (type, BINFO_TYPE (base_binfo)))
5436 return lookup_cl (TYPE_NAME (BINFO_TYPE (base_binfo)));
5437 }
5438 return NULL_TREE;
5439 }
5440
5441 void
5442 java_check_circular_reference (void)
5443 {
5444 tree current;
5445 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5446 {
5447 tree type = TREE_TYPE (current);
5448 tree cl;
5449
5450 cl = check_circular_reference (type);
5451 if (! cl)
5452 cl = check_inner_circular_reference (type, type);
5453 if (cl)
5454 parse_error_context (cl, "Cyclic class inheritance%s",
5455 (cyclic_inheritance_report ?
5456 cyclic_inheritance_report : ""));
5457 }
5458 }
5459
5460 /* Augment the parameter list PARM with parameters crafted to
5461 initialize outer context locals aliases. Through ARTIFICIAL, a
5462 count is kept of the number of crafted parameters. MODE governs
5463 what eventually gets created: something suitable for a function
5464 creation or a function invocation, either the constructor or
5465 finit$. */
5466
5467 static tree
5468 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5469 int *artificial)
5470 {
5471 tree field;
5472 tree additional_parms = NULL_TREE;
5473
5474 for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5475 if (FIELD_LOCAL_ALIAS (field))
5476 {
5477 const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5478 tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5479 tree mangled_id;
5480
5481 switch (mode)
5482 {
5483 case AIPL_FUNCTION_DECLARATION:
5484 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5485 &buffer [4]);
5486 purpose = build_wfl_node (mangled_id);
5487 if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5488 value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5489 else
5490 value = TREE_TYPE (field);
5491 break;
5492
5493 case AIPL_FUNCTION_CREATION:
5494 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5495 &buffer [4]);
5496 value = TREE_TYPE (field);
5497 break;
5498
5499 case AIPL_FUNCTION_FINIT_INVOCATION:
5500 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5501 &buffer [4]);
5502 /* Now, this is wrong. purpose should always be the NAME
5503 of something and value its matching value (decl, type,
5504 etc...) FIXME -- but there is a lot to fix. */
5505
5506 /* When invoked for this kind of operation, we already
5507 know whether a field is used or not. */
5508 purpose = TREE_TYPE (field);
5509 value = build_wfl_node (mangled_id);
5510 break;
5511
5512 case AIPL_FUNCTION_CTOR_INVOCATION:
5513 /* There are two case: the constructor invocation happens
5514 outside the local inner, in which case, locales from the outer
5515 context are directly used.
5516
5517 Otherwise, we fold to using the alias directly. */
5518 if (class_type == current_class)
5519 value = field;
5520 else
5521 {
5522 name = get_identifier (&buffer[4]);
5523 value = IDENTIFIER_LOCAL_VALUE (name);
5524 }
5525 break;
5526 }
5527 additional_parms = tree_cons (purpose, value, additional_parms);
5528 if (artificial)
5529 *artificial +=1;
5530 }
5531 if (additional_parms)
5532 {
5533 if (ANONYMOUS_CLASS_P (class_type)
5534 && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5535 additional_parms = nreverse (additional_parms);
5536 parm = chainon (additional_parms, parm);
5537 }
5538
5539 return parm;
5540 }
5541
5542 /* Craft a constructor for CLASS_DECL -- what we should do when none
5543 where found. ARGS is non NULL when a special signature must be
5544 enforced. This is the case for anonymous classes. */
5545
5546 static tree
5547 craft_constructor (tree class_decl, tree args)
5548 {
5549 tree class_type = TREE_TYPE (class_decl);
5550 tree parm = NULL_TREE;
5551 /* Inherit access flags for the constructor from its enclosing class. */
5552 int valid_ctor_flags = ACC_PUBLIC | ACC_PROTECTED | ACC_PRIVATE;
5553 int flags = (get_access_flags_from_decl (class_decl) & valid_ctor_flags);
5554 int i = 0, artificial = 0;
5555 tree decl, ctor_name;
5556 char buffer [80];
5557
5558 ctor_name = init_identifier_node;
5559
5560 /* If we're dealing with an inner class constructor, we hide the
5561 this$<n> decl in the name field of its parameter declaration. */
5562 if (PURE_INNER_CLASS_TYPE_P (class_type))
5563 {
5564 tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5565 parm = tree_cons (build_current_thisn (class_type),
5566 build_pointer_type (type), parm);
5567
5568 /* Some more arguments to be hidden here. The values of the local
5569 variables of the outer context that the inner class needs to see. */
5570 parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5571 class_type, parm,
5572 &artificial);
5573 }
5574
5575 /* Then if there are any args to be enforced, enforce them now */
5576 for (; args && args != end_params_node; args = TREE_CHAIN (args))
5577 {
5578 /* If we see a `void *', we need to change it to Object. */
5579 if (TREE_VALUE (args) == TREE_TYPE (null_pointer_node))
5580 TREE_VALUE (args) = object_ptr_type_node;
5581
5582 sprintf (buffer, "parm%d", i++);
5583 parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5584 }
5585
5586 CRAFTED_PARAM_LIST_FIXUP (parm);
5587 decl = create_artificial_method (class_type, flags, void_type_node,
5588 ctor_name, parm);
5589 fix_method_argument_names (parm, decl);
5590 /* Now, mark the artificial parameters. */
5591 DECL_FUNCTION_NAP (decl) = artificial;
5592 DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5593 DECL_INLINE (decl) = 1;
5594 return decl;
5595 }
5596
5597
5598 /* Fix the constructors. This will be called right after circular
5599 references have been checked. It is necessary to fix constructors
5600 early even if no code generation will take place for that class:
5601 some generated constructor might be required by the class whose
5602 compilation triggered this one to be simply loaded. */
5603
5604 void
5605 java_fix_constructors (void)
5606 {
5607 tree current;
5608
5609 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5610 {
5611 tree class_type = TREE_TYPE (current);
5612 int saw_ctor = 0;
5613 tree decl;
5614
5615 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5616 continue;
5617
5618 output_class = current_class = class_type;
5619 for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5620 {
5621 if (DECL_CONSTRUCTOR_P (decl))
5622 {
5623 fix_constructors (decl);
5624 saw_ctor = 1;
5625 }
5626 }
5627
5628 /* Anonymous class constructor can't be generated that early. */
5629 if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5630 craft_constructor (current, NULL_TREE);
5631 }
5632 }
5633
5634 /* safe_layout_class just makes sure that we can load a class without
5635 disrupting the current_class, input_file, input_line, etc, information
5636 about the class processed currently. */
5637
5638 void
5639 safe_layout_class (tree class)
5640 {
5641 tree save_current_class = current_class;
5642 location_t save_location = input_location;
5643
5644 layout_class (class);
5645
5646 current_class = save_current_class;
5647 input_location = save_location;
5648 }
5649
5650 static tree
5651 jdep_resolve_class (jdep *dep)
5652 {
5653 tree decl;
5654
5655 /* Set the correct context for class resolution. */
5656 current_class = TREE_TYPE (JDEP_ENCLOSING (dep));
5657
5658 if (JDEP_RESOLVED_P (dep))
5659 decl = JDEP_RESOLVED_DECL (dep);
5660 else
5661 {
5662 decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5663 JDEP_DECL (dep), JDEP_WFL (dep));
5664 JDEP_RESOLVED (dep, decl);
5665 /* If there is no WFL, that's ok. We generate this warning
5666 elsewhere. */
5667 if (decl && JDEP_WFL (dep) != NULL_TREE)
5668 check_deprecation (JDEP_WFL (dep), decl);
5669 }
5670
5671 if (!decl)
5672 complete_class_report_errors (dep);
5673 else if (INNER_CLASS_DECL_P (decl))
5674 {
5675 tree inner = TREE_TYPE (decl);
5676 if (! CLASS_LOADED_P (inner))
5677 {
5678 safe_layout_class (inner);
5679 if (TYPE_SIZE (inner) == error_mark_node)
5680 TYPE_SIZE (inner) = NULL_TREE;
5681 }
5682 check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5683 }
5684 return decl;
5685 }
5686
5687 /* Complete unsatisfied class declaration and their dependencies */
5688
5689 void
5690 java_complete_class (void)
5691 {
5692 tree cclass;
5693 jdeplist *cclassd;
5694 int error_found;
5695 tree type;
5696
5697 /* Process imports */
5698 process_imports ();
5699
5700 /* Reverse things so we have the right order */
5701 ctxp->class_list = nreverse (ctxp->class_list);
5702 ctxp->classd_list = reverse_jdep_list (ctxp);
5703
5704 for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5705 cclass && cclassd;
5706 cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5707 {
5708 jdep *dep;
5709
5710 for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5711 {
5712 tree decl;
5713 if (!(decl = jdep_resolve_class (dep)))
5714 continue;
5715
5716 /* Now it's time to patch */
5717 switch (JDEP_KIND (dep))
5718 {
5719 case JDEP_SUPER:
5720 /* Simply patch super */
5721 if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5722 continue;
5723 BINFO_TYPE (BINFO_BASE_BINFO
5724 (TYPE_BINFO (TREE_TYPE (JDEP_DECL (dep))), 0))
5725 = TREE_TYPE (decl);
5726 break;
5727
5728 case JDEP_FIELD:
5729 {
5730 /* We do part of the job done in add_field */
5731 tree field_decl = JDEP_DECL (dep);
5732 tree field_type = TREE_TYPE (decl);
5733 if (TREE_CODE (field_type) == RECORD_TYPE)
5734 field_type = promote_type (field_type);
5735 TREE_TYPE (field_decl) = field_type;
5736 DECL_ALIGN (field_decl) = 0;
5737 DECL_USER_ALIGN (field_decl) = 0;
5738 layout_decl (field_decl, 0);
5739 SOURCE_FRONTEND_DEBUG
5740 (("Completed field/var decl '%s' with '%s'",
5741 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5742 IDENTIFIER_POINTER (DECL_NAME (decl))));
5743 break;
5744 }
5745 case JDEP_METHOD: /* We start patching a method */
5746 case JDEP_METHOD_RETURN:
5747 error_found = 0;
5748 while (1)
5749 {
5750 if (decl)
5751 {
5752 type = TREE_TYPE(decl);
5753 if (TREE_CODE (type) == RECORD_TYPE)
5754 type = promote_type (type);
5755 JDEP_APPLY_PATCH (dep, type);
5756 SOURCE_FRONTEND_DEBUG
5757 (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5758 "Completing fct '%s' with ret type '%s'":
5759 "Completing arg '%s' with type '%s'"),
5760 IDENTIFIER_POINTER (EXPR_WFL_NODE
5761 (JDEP_DECL_WFL (dep))),
5762 IDENTIFIER_POINTER (DECL_NAME (decl))));
5763 }
5764 else
5765 error_found = 1;
5766 dep = JDEP_CHAIN (dep);
5767 if (JDEP_KIND (dep) == JDEP_METHOD_END)
5768 break;
5769 else
5770 decl = jdep_resolve_class (dep);
5771 }
5772 if (!error_found)
5773 {
5774 tree mdecl = JDEP_DECL (dep), signature;
5775 /* Recompute and reset the signature, check first that
5776 all types are now defined. If they're not,
5777 don't build the signature. */
5778 if (check_method_types_complete (mdecl))
5779 {
5780 signature = build_java_signature (TREE_TYPE (mdecl));
5781 set_java_signature (TREE_TYPE (mdecl), signature);
5782 }
5783 }
5784 else
5785 continue;
5786 break;
5787
5788 case JDEP_INTERFACE:
5789 if (parser_check_super_interface (decl, JDEP_DECL (dep),
5790 JDEP_WFL (dep)))
5791 continue;
5792 parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5793 break;
5794
5795 case JDEP_PARM:
5796 case JDEP_VARIABLE:
5797 type = TREE_TYPE(decl);
5798 if (TREE_CODE (type) == RECORD_TYPE)
5799 type = promote_type (type);
5800 JDEP_APPLY_PATCH (dep, type);
5801 break;
5802
5803 case JDEP_TYPE:
5804 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5805 SOURCE_FRONTEND_DEBUG
5806 (("Completing a random type dependency on a '%s' node",
5807 tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5808 break;
5809
5810 case JDEP_EXCEPTION:
5811 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5812 SOURCE_FRONTEND_DEBUG
5813 (("Completing '%s' 'throws' argument node",
5814 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5815 break;
5816
5817 case JDEP_ANONYMOUS:
5818 patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5819 break;
5820
5821 default:
5822 abort ();
5823 }
5824 }
5825 }
5826 return;
5827 }
5828
5829 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5830 array. */
5831
5832 static tree
5833 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5834 {
5835 tree tname = TYPE_NAME (class_type);
5836 tree resolved_type = TREE_TYPE (class_type);
5837 int array_dims = 0;
5838 tree resolved_type_decl;
5839
5840 if (resolved_type != NULL_TREE)
5841 {
5842 tree resolved_type_decl = TYPE_NAME (resolved_type);
5843 if (resolved_type_decl == NULL_TREE
5844 || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5845 {
5846 resolved_type_decl = build_decl (TYPE_DECL,
5847 TYPE_NAME (class_type),
5848 resolved_type);
5849 }
5850 return resolved_type_decl;
5851 }
5852
5853 /* 1- Check to see if we have an array. If true, find what we really
5854 want to resolve */
5855 if ((array_dims = build_type_name_from_array_name (tname,
5856 &TYPE_NAME (class_type))))
5857 WFL_STRIP_BRACKET (cl, cl);
5858
5859 /* 2- Resolve the bare type */
5860 if (!(resolved_type_decl = do_resolve_class (enclosing, NULL_TREE, class_type,
5861 decl, cl)))
5862 return NULL_TREE;
5863 resolved_type = TREE_TYPE (resolved_type_decl);
5864
5865 /* 3- If we have an array, reconstruct the array down to its nesting */
5866 if (array_dims)
5867 {
5868 for (; array_dims; array_dims--)
5869 resolved_type = build_java_array_type (resolved_type, -1);
5870 resolved_type_decl = TYPE_NAME (resolved_type);
5871 }
5872 TREE_TYPE (class_type) = resolved_type;
5873 return resolved_type_decl;
5874 }
5875
5876 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5877 are used to report error messages; CL must either be NULL_TREE or a
5878 WFL wrapping a class. Do not try to replace TYPE_NAME (class_type)
5879 by a variable, since it is changed by find_in_imports{_on_demand}
5880 and (but it doesn't really matter) qualify_and_find. */
5881
5882 tree
5883 do_resolve_class (tree enclosing, tree import_type, tree class_type, tree decl,
5884 tree cl)
5885 {
5886 tree new_class_decl = NULL_TREE;
5887 tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5888 tree candidate = NULL_TREE;
5889 tree decl_result;
5890
5891 if (QUALIFIED_P (TYPE_NAME (class_type)))
5892 {
5893 /* If the type name is of the form `Q . Id', then Q is either a
5894 package name or a class name. First we try to find Q as a
5895 class and then treat Id as a member type. If we can't find Q
5896 as a class then we fall through. */
5897 tree q, left, left_type, right;
5898 if (split_qualified_name (&left, &right, TYPE_NAME (class_type)) == 0)
5899 {
5900 BUILD_PTR_FROM_NAME (left_type, left);
5901 q = do_resolve_class (enclosing, import_type, left_type, decl, cl);
5902 if (q)
5903 {
5904 enclosing = q;
5905 saved_enclosing_type = TREE_TYPE (q);
5906 BUILD_PTR_FROM_NAME (class_type, right);
5907 }
5908 }
5909 }
5910
5911 if (enclosing)
5912 {
5913 tree context = enclosing;
5914
5915 /* 0- Search in the current class as an inner class.
5916 Maybe some code here should be added to load the class or
5917 something, at least if the class isn't an inner class and ended
5918 being loaded from class file. FIXME. */
5919 while (enclosing)
5920 {
5921 new_class_decl = resolve_inner_class (context, cl, enclosing, class_type);
5922
5923 if (new_class_decl)
5924 {
5925 if (inner_class_accessible (new_class_decl, context))
5926 break;
5927 else
5928 if (candidate == NULL_TREE)
5929 candidate = new_class_decl;
5930 new_class_decl = NULL_TREE;
5931 }
5932
5933 /* Now that we've looked through all superclasses, try the enclosing
5934 context. */
5935 enclosing = DECL_CONTEXT (enclosing);
5936 }
5937
5938 if (new_class_decl)
5939 return new_class_decl;
5940 }
5941
5942 /* 1- Check for the type in single imports. Look at enclosing classes and,
5943 if we're laying out a superclass, at the import list for the subclass.
5944 This will change TYPE_NAME() if something relevant is found. */
5945 if (import_type && TYPE_IMPORT_LIST (import_type))
5946 find_in_imports (import_type, class_type);
5947 find_in_imports (saved_enclosing_type, class_type);
5948
5949 /* 2- And check for the type in the current compilation unit */
5950 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5951 {
5952 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5953 load_class (TYPE_NAME (class_type), 0);
5954 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5955 }
5956
5957 /* 3- Search according to the current package definition */
5958 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5959 {
5960 if ((new_class_decl = qualify_and_find (class_type,
5961 TYPE_PACKAGE (current_class), TYPE_NAME (class_type))))
5962 return new_class_decl;
5963 }
5964
5965 /* 4- Check the import on demands. Don't allow bar.baz to be
5966 imported from foo.* */
5967 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5968 {
5969 if (import_type
5970 && TYPE_IMPORT_DEMAND_LIST (import_type)
5971 && find_in_imports_on_demand (import_type, class_type))
5972 return NULL_TREE;
5973 if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5974 return NULL_TREE;
5975 }
5976
5977 /* If found in find_in_imports_on_demand, the type has already been
5978 loaded. */
5979 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5980 return new_class_decl;
5981
5982 /* 5- Check another compilation unit that bears the name of type */
5983 load_class (TYPE_NAME (class_type), 0);
5984
5985 if (!cl)
5986 cl = lookup_cl (decl);
5987
5988 /* If we don't have a value for CL, then we're being called recursively.
5989 We can't check package access just yet, but it will be taken care of
5990 by the caller. */
5991 if (cl)
5992 {
5993 if (check_pkg_class_access (TYPE_NAME (class_type), cl, true, NULL_TREE))
5994 return NULL_TREE;
5995 }
5996
5997 /* 6- Last call for a resolution */
5998 decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5999
6000 /* The final lookup might have registered a.b.c into a.b$c If we
6001 failed at the first lookup, progressively change the name if
6002 applicable and use the matching DECL instead. */
6003 if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
6004 {
6005 char *separator;
6006 tree name = TYPE_NAME (class_type);
6007 char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
6008
6009 strcpy (namebuffer, IDENTIFIER_POINTER (name));
6010
6011 do {
6012
6013 /* Reach the last '.', and if applicable, replace it by a `$' and
6014 see if this exists as a type. */
6015 if ((separator = strrchr (namebuffer, '.')))
6016 {
6017 *separator = '$';
6018 name = get_identifier (namebuffer);
6019 decl_result = IDENTIFIER_CLASS_VALUE (name);
6020 }
6021 } while (!decl_result && separator);
6022 }
6023 if (decl_result)
6024 return decl_result;
6025 else
6026 return candidate;
6027 }
6028
6029 static tree
6030 qualify_and_find (tree class_type, tree package, tree name)
6031 {
6032 tree new_qualified = merge_qualified_name (package, name);
6033 tree new_class_decl;
6034
6035 if (!IDENTIFIER_CLASS_VALUE (new_qualified))
6036 load_class (new_qualified, 0);
6037 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
6038 {
6039 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
6040 load_class (TREE_TYPE (new_class_decl), 0);
6041 TYPE_NAME (class_type) = new_qualified;
6042 return IDENTIFIER_CLASS_VALUE (new_qualified);
6043 }
6044 return NULL_TREE;
6045 }
6046
6047 /* Resolve NAME and lay it out (if not done and if not the current
6048 parsed class). Return a decl node. This function is meant to be
6049 called when type resolution is necessary during the walk pass. */
6050
6051 static tree
6052 resolve_and_layout (tree something, tree cl)
6053 {
6054 tree decl, decl_type;
6055
6056 /* Don't do that on the current class */
6057 if (something == current_class)
6058 return TYPE_NAME (current_class);
6059
6060 /* Don't do anything for void and other primitive types */
6061 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
6062 return NULL_TREE;
6063
6064 /* Pointer types can be reall pointer types or fake pointers. When
6065 finding a real pointer, recheck for primitive types */
6066 if (TREE_CODE (something) == POINTER_TYPE)
6067 {
6068 if (TREE_TYPE (something))
6069 {
6070 something = TREE_TYPE (something);
6071 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
6072 return NULL_TREE;
6073 }
6074 else
6075 something = TYPE_NAME (something);
6076 }
6077
6078 /* Don't do anything for arrays of primitive types */
6079 if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
6080 && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
6081 return NULL_TREE;
6082
6083 /* Something might be a WFL */
6084 if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
6085 something = EXPR_WFL_NODE (something);
6086
6087 /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a
6088 TYPE_DECL or a real TYPE. */
6089 else if (TREE_CODE (something) != IDENTIFIER_NODE)
6090 something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
6091 DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
6092
6093 if (!(decl = resolve_no_layout (something, cl)))
6094 return NULL_TREE;
6095
6096 /* Resolve and layout if necessary */
6097 decl_type = TREE_TYPE (decl);
6098 layout_class_methods (decl_type);
6099 /* Check methods */
6100 if (CLASS_FROM_SOURCE_P (decl_type))
6101 java_check_methods (decl);
6102 /* Layout the type if necessary */
6103 if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
6104 safe_layout_class (decl_type);
6105
6106 return decl;
6107 }
6108
6109 /* Resolve a class, returns its decl but doesn't perform any
6110 layout. The current parsing context is saved and restored */
6111
6112 static tree
6113 resolve_no_layout (tree name, tree cl)
6114 {
6115 tree ptr, decl;
6116 BUILD_PTR_FROM_NAME (ptr, name);
6117 java_parser_context_save_global ();
6118 decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
6119 java_parser_context_restore_global ();
6120
6121 return decl;
6122 }
6123
6124 /* Called when reporting errors. Skip the '[]'s in a complex array
6125 type description that failed to be resolved. purify_type_name can't
6126 use an identifier tree. */
6127
6128 static const char *
6129 purify_type_name (const char *name)
6130 {
6131 int len = strlen (name);
6132 int bracket_found;
6133
6134 STRING_STRIP_BRACKETS (name, len, bracket_found);
6135 if (bracket_found)
6136 {
6137 char *stripped_name = xmemdup (name, len, len+1);
6138 stripped_name [len] = '\0';
6139 return stripped_name;
6140 }
6141 return name;
6142 }
6143
6144 /* The type CURRENT refers to can't be found. We print error messages. */
6145
6146 static void
6147 complete_class_report_errors (jdep *dep)
6148 {
6149 const char *name;
6150
6151 if (!JDEP_WFL (dep))
6152 return;
6153
6154 name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6155 switch (JDEP_KIND (dep))
6156 {
6157 case JDEP_SUPER:
6158 parse_error_context
6159 (JDEP_WFL (dep), "Superclass %qs of class %qs not found",
6160 purify_type_name (name),
6161 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6162 break;
6163 case JDEP_FIELD:
6164 parse_error_context
6165 (JDEP_WFL (dep), "Type %qs not found in declaration of field %qs",
6166 purify_type_name (name),
6167 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6168 break;
6169 case JDEP_METHOD: /* Covers arguments */
6170 parse_error_context
6171 (JDEP_WFL (dep), "Type %qs not found in the declaration of the argument %qs of method %qs",
6172 purify_type_name (name),
6173 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6174 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6175 break;
6176 case JDEP_METHOD_RETURN: /* Covers return type */
6177 parse_error_context
6178 (JDEP_WFL (dep), "Type %qs not found in the declaration of the return type of method %qs",
6179 purify_type_name (name),
6180 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6181 break;
6182 case JDEP_INTERFACE:
6183 parse_error_context
6184 (JDEP_WFL (dep), "Superinterface %qs of %s %qs not found",
6185 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6186 (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6187 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6188 break;
6189 case JDEP_VARIABLE:
6190 parse_error_context
6191 (JDEP_WFL (dep), "Type %qs not found in the declaration of the local variable %qs",
6192 purify_type_name (IDENTIFIER_POINTER
6193 (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6194 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6195 break;
6196 case JDEP_EXCEPTION: /* As specified by `throws' */
6197 parse_error_context
6198 (JDEP_WFL (dep), "Class %qs not found in %<throws%>",
6199 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6200 break;
6201 default:
6202 /* Fix for -Wall. Just break doing nothing. The error will be
6203 caught later */
6204 break;
6205 }
6206 }
6207
6208 /* Return a static string containing the DECL prototype string. If
6209 DECL is a constructor, use the class name instead of the form
6210 <init> */
6211
6212 static const char *
6213 get_printable_method_name (tree decl)
6214 {
6215 const char *to_return;
6216 tree name = NULL_TREE;
6217
6218 if (DECL_CONSTRUCTOR_P (decl))
6219 {
6220 name = DECL_NAME (decl);
6221 DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6222 }
6223
6224 to_return = lang_printable_name (decl, 2);
6225 if (DECL_CONSTRUCTOR_P (decl))
6226 DECL_NAME (decl) = name;
6227
6228 return to_return;
6229 }
6230
6231 /* Track method being redefined inside the same class. As a side
6232 effect, set DECL_NAME to an IDENTIFIER (prior entering this
6233 function it's a FWL, so we can track errors more accurately.) */
6234
6235 static int
6236 check_method_redefinition (tree class, tree method)
6237 {
6238 tree redef, sig;
6239
6240 /* There's no need to verify <clinit> and finit$ and instinit$ */
6241 if (DECL_CLINIT_P (method)
6242 || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6243 return 0;
6244
6245 sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6246 for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6247 {
6248 if (redef == method)
6249 break;
6250 if (DECL_NAME (redef) == DECL_NAME (method)
6251 && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6252 && !DECL_ARTIFICIAL (method))
6253 {
6254 parse_error_context
6255 (DECL_FUNCTION_WFL (method), "Duplicate %s declaration %qs",
6256 (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6257 get_printable_method_name (redef));
6258 return 1;
6259 }
6260 }
6261 return 0;
6262 }
6263
6264 /* Return 1 if check went ok, 0 otherwise. */
6265 static int
6266 check_abstract_method_definitions (int do_interface, tree class_decl,
6267 tree type)
6268 {
6269 tree class = TREE_TYPE (class_decl);
6270 tree method, end_type;
6271 int ok = 1;
6272
6273 end_type = (do_interface ? object_type_node : type);
6274 for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6275 {
6276 tree other_super, other_method, method_sig, method_name;
6277 int found = 0;
6278 int end_type_reached = 0;
6279
6280 if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6281 continue;
6282
6283 /* Now verify that somewhere in between TYPE and CLASS,
6284 abstract method METHOD gets a non abstract definition
6285 that is inherited by CLASS. */
6286
6287 method_sig = build_java_signature (TREE_TYPE (method));
6288 method_name = DECL_NAME (method);
6289 if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6290 method_name = EXPR_WFL_NODE (method_name);
6291
6292 other_super = class;
6293 do {
6294 if (other_super == end_type)
6295 end_type_reached = 1;
6296
6297 /* Method search */
6298 for (other_method = TYPE_METHODS (other_super); other_method;
6299 other_method = TREE_CHAIN (other_method))
6300 {
6301 tree s = build_java_signature (TREE_TYPE (other_method));
6302 tree other_name = DECL_NAME (other_method);
6303
6304 if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6305 other_name = EXPR_WFL_NODE (other_name);
6306 if (!DECL_CLINIT_P (other_method)
6307 && !DECL_CONSTRUCTOR_P (other_method)
6308 && method_name == other_name
6309 && method_sig == s
6310 && !METHOD_ABSTRACT (other_method))
6311 {
6312 found = 1;
6313 break;
6314 }
6315 }
6316 other_super = CLASSTYPE_SUPER (other_super);
6317 } while (!end_type_reached);
6318
6319 /* Report that abstract METHOD didn't find an implementation
6320 that CLASS can use. */
6321 if (!found)
6322 {
6323 char *t = xstrdup (lang_printable_name
6324 (TREE_TYPE (TREE_TYPE (method)), 0));
6325 tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6326
6327 parse_error_context
6328 (lookup_cl (class_decl),
6329 "Class %qs doesn't define the abstract method %<%s %s%> from %s %<%s%>. This method must be defined or %s %qs must be declared abstract",
6330 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6331 t, lang_printable_name (method, 2),
6332 (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6333 "interface" : "class"),
6334 IDENTIFIER_POINTER (ccn),
6335 (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6336 IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6337 ok = 0;
6338 free (t);
6339 }
6340 }
6341
6342 if (ok && do_interface)
6343 {
6344 /* Check for implemented interfaces. */
6345 int i;
6346 tree base_binfo;
6347
6348 for (i = 1;
6349 ok && BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo);
6350 i++)
6351 ok = check_abstract_method_definitions (1, class_decl,
6352 BINFO_TYPE (base_binfo));
6353 }
6354
6355 return ok;
6356 }
6357
6358 /* Check that CLASS_DECL somehow implements all inherited abstract
6359 methods. */
6360
6361 static void
6362 java_check_abstract_method_definitions (tree class_decl)
6363 {
6364 tree class = TREE_TYPE (class_decl);
6365 tree super, base_binfo;
6366 int i;
6367
6368 if (CLASS_ABSTRACT (class_decl))
6369 return;
6370
6371 /* Check for inherited types */
6372 super = class;
6373 do {
6374 super = CLASSTYPE_SUPER (super);
6375 check_abstract_method_definitions (0, class_decl, super);
6376 } while (super != object_type_node);
6377
6378 /* Check for implemented interfaces. */
6379 for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6380 check_abstract_method_definitions (1, class_decl, BINFO_TYPE (base_binfo));
6381 }
6382
6383 /* Check all the types method DECL uses and return 1 if all of them
6384 are now complete, 0 otherwise. This is used to check whether its
6385 safe to build a method signature or not. */
6386
6387 static int
6388 check_method_types_complete (tree decl)
6389 {
6390 tree type = TREE_TYPE (decl);
6391 tree args;
6392
6393 if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6394 return 0;
6395
6396 args = TYPE_ARG_TYPES (type);
6397 if (TREE_CODE (type) == METHOD_TYPE)
6398 args = TREE_CHAIN (args);
6399 for (; args != end_params_node; args = TREE_CHAIN (args))
6400 if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6401 return 0;
6402
6403 return 1;
6404 }
6405
6406 /* Visible interface to check methods contained in CLASS_DECL */
6407
6408 void
6409 java_check_methods (tree class_decl)
6410 {
6411 if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6412 return;
6413
6414 if (CLASS_INTERFACE (class_decl))
6415 java_check_abstract_methods (class_decl);
6416 else
6417 java_check_regular_methods (class_decl);
6418
6419 CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6420 }
6421
6422 /* Like not_accessible_p, but doesn't refer to the current class at
6423 all. */
6424 static bool
6425 hack_is_accessible_p (tree member, tree from_where)
6426 {
6427 int flags = get_access_flags_from_decl (member);
6428
6429 if (from_where == DECL_CONTEXT (member)
6430 || (flags & ACC_PUBLIC))
6431 return true;
6432
6433 if ((flags & ACC_PROTECTED))
6434 {
6435 if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6436 return true;
6437 }
6438
6439 if ((flags & ACC_PRIVATE))
6440 return false;
6441
6442 /* Package private, or protected. */
6443 return in_same_package (TYPE_NAME (from_where),
6444 TYPE_NAME (DECL_CONTEXT (member)));
6445 }
6446
6447 /* Check all the methods of CLASS_DECL. Methods are first completed
6448 then checked according to regular method existence rules. If no
6449 constructor for CLASS_DECL were encountered, then build its
6450 declaration. */
6451 static void
6452 java_check_regular_methods (tree class_decl)
6453 {
6454 int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6455 tree method;
6456 tree class = TREE_TYPE (class_decl);
6457 tree found = NULL_TREE;
6458 tree mthrows;
6459
6460 /* It is not necessary to check methods defined in java.lang.Object */
6461 if (class == object_type_node)
6462 return;
6463
6464 if (!TYPE_NVIRTUALS (class))
6465 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6466
6467 /* Should take interfaces into account. FIXME */
6468 for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6469 {
6470 tree sig;
6471 tree method_wfl = DECL_FUNCTION_WFL (method);
6472 int aflags;
6473
6474 /* Check for redefinitions */
6475 if (check_method_redefinition (class, method))
6476 continue;
6477
6478 /* We verify things thrown by the method. They must inherit from
6479 java.lang.Throwable. */
6480 for (mthrows = DECL_FUNCTION_THROWS (method);
6481 mthrows; mthrows = TREE_CHAIN (mthrows))
6482 {
6483 if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6484 parse_error_context
6485 (TREE_PURPOSE (mthrows), "Class %qs in %<throws%> clause must be a subclass of class %<java.lang.Throwable%>",
6486 IDENTIFIER_POINTER
6487 (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6488 }
6489
6490 /* If we see one constructor a mark so we don't generate the
6491 default one. Also skip other verifications: constructors
6492 can't be inherited hence hidden or overridden. */
6493 if (DECL_CONSTRUCTOR_P (method))
6494 {
6495 saw_constructor = 1;
6496 continue;
6497 }
6498
6499 sig = build_java_argument_signature (TREE_TYPE (method));
6500 found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6501 SEARCH_SUPER | SEARCH_INTERFACE);
6502
6503 /* Inner class can't declare static methods */
6504 if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6505 {
6506 char *t = xstrdup (lang_printable_name (class, 0));
6507 parse_error_context
6508 (method_wfl, "Method %qs can't be static in inner class %qs. Only members of interfaces and top-level classes can be static",
6509 lang_printable_name (method, 2), t);
6510 free (t);
6511 }
6512
6513 /* Nothing overrides or it's a private method. */
6514 if (!found)
6515 continue;
6516 if (METHOD_PRIVATE (found))
6517 {
6518 found = NULL_TREE;
6519 continue;
6520 }
6521
6522 /* If `found' is declared in an interface, make sure the
6523 modifier matches. */
6524 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6525 && clinit_identifier_node != DECL_NAME (found)
6526 && !METHOD_PUBLIC (method))
6527 {
6528 tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6529 parse_error_context (method_wfl, "Class %qs must override %qs with a public method in order to implement interface %qs",
6530 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6531 lang_printable_name (found, 0),
6532 IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6533 }
6534
6535 /* Can't override a method with the same name and different return
6536 types. */
6537 if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6538 {
6539 char *t = xstrdup
6540 (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6541 parse_error_context
6542 (method_wfl,
6543 "Method %qs was defined with return type %qs in class %qs",
6544 lang_printable_name (found, 2), t,
6545 IDENTIFIER_POINTER
6546 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6547 free (t);
6548 }
6549
6550 aflags = get_access_flags_from_decl (found);
6551
6552 /* Can't override final. Can't override static. */
6553 if (METHOD_FINAL (found) || METHOD_STATIC (found))
6554 {
6555 /* Static *can* override static */
6556 if (METHOD_STATIC (found) && METHOD_STATIC (method))
6557 continue;
6558 parse_error_context
6559 (method_wfl,
6560 "%s methods can't be overridden. Method %qs is %s in class %qs",
6561 (METHOD_FINAL (found) ? "Final" : "Static"),
6562 lang_printable_name (found, 2),
6563 (METHOD_FINAL (found) ? "final" : "static"),
6564 IDENTIFIER_POINTER
6565 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6566 continue;
6567 }
6568
6569 /* Static method can't override instance method. */
6570 if (METHOD_STATIC (method))
6571 {
6572 parse_error_context
6573 (method_wfl,
6574 "Instance methods can't be overridden by a static method. Method %qs is an instance method in class %qs",
6575 lang_printable_name (found, 2),
6576 IDENTIFIER_POINTER
6577 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6578 continue;
6579 }
6580
6581 /* - Overriding/hiding public must be public
6582 - Overriding/hiding protected must be protected or public
6583 - If the overridden or hidden method has default (package)
6584 access, then the overriding or hiding method must not be
6585 private; otherwise, a compile-time error occurs. If
6586 `found' belongs to an interface, things have been already
6587 taken care of. */
6588 if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6589 && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6590 || (METHOD_PROTECTED (found)
6591 && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6592 || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6593 && METHOD_PRIVATE (method))))
6594 {
6595 parse_error_context
6596 (method_wfl,
6597 "Methods can't be overridden to be more private. Method %qs is not %s in class %qs", lang_printable_name (method, 2),
6598 (METHOD_PUBLIC (method) ? "public" :
6599 (METHOD_PRIVATE (method) ? "private" : "protected")),
6600 IDENTIFIER_POINTER (DECL_NAME
6601 (TYPE_NAME (DECL_CONTEXT (found)))));
6602 continue;
6603 }
6604
6605 /* Check this method against all the other implementations it
6606 overrides. Here we only check the class hierarchy; the rest
6607 of the checking is done later. If this method is just a
6608 Miranda method, we can skip the check. */
6609 if (! METHOD_INVISIBLE (method))
6610 check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6611 }
6612
6613 /* The above throws clause check only looked at superclasses. Now
6614 we must also make sure that all methods declared in interfaces
6615 have compatible throws clauses. FIXME: there are more efficient
6616 ways to organize this checking; we should implement one. */
6617 check_interface_throws_clauses (class, class);
6618
6619 if (!TYPE_NVIRTUALS (class))
6620 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6621
6622 /* Search for inherited abstract method not yet implemented in this
6623 class. */
6624 java_check_abstract_method_definitions (class_decl);
6625
6626 if (!saw_constructor)
6627 abort ();
6628 }
6629
6630 /* Check to make sure that all the methods in all the interfaces
6631 implemented by CLASS_DECL are compatible with the concrete
6632 implementations available in CHECK_CLASS_DECL. */
6633 static void
6634 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6635 {
6636 for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6637 {
6638 int i;
6639
6640 if (! CLASS_LOADED_P (class_decl))
6641 {
6642 if (CLASS_FROM_SOURCE_P (class_decl))
6643 safe_layout_class (class_decl);
6644 else
6645 load_class (class_decl, 1);
6646 }
6647
6648 for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (class_decl)) - 1; i > 0; --i)
6649 {
6650 tree interface
6651 = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (class_decl), i));
6652 tree iface_method;
6653
6654 for (iface_method = TYPE_METHODS (interface);
6655 iface_method != NULL_TREE;
6656 iface_method = TREE_CHAIN (iface_method))
6657 {
6658 tree sig, method;
6659
6660 /* First look for a concrete method implemented or
6661 inherited by this class. No need to search
6662 interfaces here, since we're already looking through
6663 all of them. */
6664 sig = build_java_argument_signature (TREE_TYPE (iface_method));
6665 method
6666 = lookup_argument_method_generic (check_class_decl,
6667 DECL_NAME (iface_method),
6668 sig, SEARCH_VISIBLE);
6669 /* If we don't find an implementation, that is ok. Any
6670 potential errors from that are diagnosed elsewhere.
6671 Also, multiple inheritance with conflicting throws
6672 clauses is fine in the absence of a concrete
6673 implementation. */
6674 if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6675 && !METHOD_INVISIBLE (iface_method))
6676 {
6677 tree method_wfl = DECL_FUNCTION_WFL (method);
6678 check_throws_clauses (method, method_wfl, iface_method);
6679 }
6680 }
6681
6682 /* Now check superinterfaces. */
6683 check_interface_throws_clauses (check_class_decl, interface);
6684 }
6685 }
6686 }
6687
6688 /* Check throws clauses of a method against the clauses of all the
6689 methods it overrides. We do this by searching up the class
6690 hierarchy, examining all matching accessible methods. */
6691 static void
6692 check_concrete_throws_clauses (tree class, tree self_method,
6693 tree name, tree signature)
6694 {
6695 tree method = lookup_argument_method_generic (class, name, signature,
6696 SEARCH_SUPER | SEARCH_VISIBLE);
6697 while (method != NULL_TREE)
6698 {
6699 if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6700 check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6701 method);
6702
6703 method = lookup_argument_method_generic (DECL_CONTEXT (method),
6704 name, signature,
6705 SEARCH_SUPER | SEARCH_VISIBLE);
6706 }
6707 }
6708
6709 /* Generate an error if the `throws' clause of METHOD (if any) is
6710 incompatible with the `throws' clause of FOUND (if any). */
6711 static void
6712 check_throws_clauses (tree method, tree method_wfl, tree found)
6713 {
6714 tree mthrows;
6715
6716 for (mthrows = DECL_FUNCTION_THROWS (method);
6717 mthrows; mthrows = TREE_CHAIN (mthrows))
6718 {
6719 tree fthrows;
6720
6721 /* We don't verify unchecked expressions */
6722 if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6723 continue;
6724 /* Checked expression must be compatible */
6725 for (fthrows = DECL_FUNCTION_THROWS (found);
6726 fthrows; fthrows = TREE_CHAIN (fthrows))
6727 {
6728 if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6729 break;
6730 }
6731 if (!fthrows)
6732 {
6733 parse_error_context
6734 (method_wfl, "Invalid checked exception class %qs in %<throws%> clause. The exception must be a subclass of an exception thrown by %qs from class %qs",
6735 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6736 lang_printable_name (found, 2),
6737 IDENTIFIER_POINTER
6738 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6739 }
6740 }
6741 }
6742
6743 /* Check abstract method of interface INTERFACE */
6744 static void
6745 java_check_abstract_methods (tree interface_decl)
6746 {
6747 int i;
6748 tree method, found;
6749 tree interface = TREE_TYPE (interface_decl);
6750 tree base_binfo;
6751
6752 for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6753 {
6754 /* 2- Check for double definition inside the defining interface */
6755 if (check_method_redefinition (interface, method))
6756 continue;
6757
6758 /* 3- Overriding is OK as far as we preserve the return type. */
6759 found = lookup_java_interface_method2 (interface, method);
6760 if (found)
6761 {
6762 char *t;
6763 t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6764 parse_error_context
6765 (DECL_FUNCTION_WFL (found),
6766 "Method %qs was defined with return type %qs in class %qs",
6767 lang_printable_name (found, 2), t,
6768 IDENTIFIER_POINTER
6769 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6770 free (t);
6771 continue;
6772 }
6773 }
6774
6775 /* 4- Inherited methods can't differ by their returned types */
6776 for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (interface), i, base_binfo); i++)
6777 {
6778 tree sub_interface_method, sub_interface;
6779
6780 sub_interface = BINFO_TYPE (base_binfo);
6781 for (sub_interface_method = TYPE_METHODS (sub_interface);
6782 sub_interface_method;
6783 sub_interface_method = TREE_CHAIN (sub_interface_method))
6784 {
6785 found = lookup_java_interface_method2 (interface,
6786 sub_interface_method);
6787 if (found && (found != sub_interface_method))
6788 {
6789 parse_error_context
6790 (lookup_cl (sub_interface_method),
6791 "Interface %qs inherits method %qs from interface %qs. This method is redefined with a different return type in interface %qs",
6792 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6793 lang_printable_name (found, 2),
6794 IDENTIFIER_POINTER
6795 (DECL_NAME (TYPE_NAME
6796 (DECL_CONTEXT (sub_interface_method)))),
6797 IDENTIFIER_POINTER
6798 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6799 }
6800 }
6801 }
6802 }
6803
6804 /* Lookup methods in interfaces using their name and partial
6805 signature. Return a matching method only if their types differ. */
6806
6807 static tree
6808 lookup_java_interface_method2 (tree class, tree method_decl)
6809 {
6810 int i;
6811 tree base_binfo;
6812 tree to_return;
6813
6814 for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6815 {
6816 if ((BINFO_TYPE (base_binfo) != object_type_node)
6817 && (to_return =
6818 lookup_java_method2 (BINFO_TYPE (base_binfo), method_decl, 1)))
6819 return to_return;
6820 }
6821 for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6822 {
6823 to_return = lookup_java_interface_method2
6824 (BINFO_TYPE (base_binfo), method_decl);
6825 if (to_return)
6826 return to_return;
6827 }
6828
6829 return NULL_TREE;
6830 }
6831
6832 /* Lookup method using their name and partial signature. Return a
6833 matching method only if their types differ. */
6834
6835 static tree
6836 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6837 {
6838 tree method, method_signature, method_name, method_type, name;
6839
6840 method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6841 name = DECL_NAME (method_decl);
6842 method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6843 EXPR_WFL_NODE (name) : name);
6844 method_type = TREE_TYPE (TREE_TYPE (method_decl));
6845
6846 while (clas != NULL_TREE)
6847 {
6848 for (method = TYPE_METHODS (clas);
6849 method != NULL_TREE; method = TREE_CHAIN (method))
6850 {
6851 tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6852 tree name = DECL_NAME (method);
6853 if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6854 EXPR_WFL_NODE (name) : name) == method_name
6855 && method_sig == method_signature
6856 && TREE_TYPE (TREE_TYPE (method)) != method_type)
6857 return method;
6858 }
6859 clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6860 }
6861 return NULL_TREE;
6862 }
6863
6864 /* Return the line that matches DECL line number, and try its best to
6865 position the column number. Used during error reports.
6866 FUTURE/FIXME: return source_location instead of node. */
6867
6868 static GTY(()) tree cl_v;
6869 static tree
6870 lookup_cl (tree decl)
6871 {
6872 #ifndef USE_MAPPED_LOCATION
6873 char *line, *found;
6874 #endif
6875
6876 if (!decl)
6877 return NULL_TREE;
6878
6879 if (cl_v == NULL_TREE)
6880 {
6881 cl_v = build_unknown_wfl (NULL_TREE);
6882 }
6883
6884 #ifdef USE_MAPPED_LOCATION
6885 SET_EXPR_LOCATION (cl_v, DECL_SOURCE_LOCATION (decl));
6886 #else
6887 EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6888 EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6889
6890 line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6891 EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6892
6893 found = strstr ((const char *)line,
6894 (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6895 if (found)
6896 EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6897 #endif
6898
6899 return cl_v;
6900 }
6901
6902 /* Look for a simple name in the single-type import list */
6903
6904 static tree
6905 find_name_in_single_imports (tree name)
6906 {
6907 tree node;
6908
6909 for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6910 if (TREE_VALUE (node) == name)
6911 return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6912
6913 return NULL_TREE;
6914 }
6915
6916 /* Process all single-type import. */
6917
6918 static int
6919 process_imports (void)
6920 {
6921 tree import;
6922 int error_found;
6923
6924 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6925 {
6926 tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6927 char *original_name;
6928
6929 /* Don't load twice something already defined. */
6930 if (IDENTIFIER_CLASS_VALUE (to_be_found))
6931 continue;
6932
6933 original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6934 IDENTIFIER_LENGTH (to_be_found),
6935 IDENTIFIER_LENGTH (to_be_found) + 1);
6936
6937 while (1)
6938 {
6939 tree left;
6940
6941 QUALIFIED_P (to_be_found) = 1;
6942 load_class (to_be_found, 0);
6943 error_found =
6944 check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true, NULL_TREE);
6945
6946 /* We found it, we can bail out */
6947 if (IDENTIFIER_CLASS_VALUE (to_be_found))
6948 {
6949 check_deprecation (TREE_PURPOSE (import),
6950 IDENTIFIER_CLASS_VALUE (to_be_found));
6951 break;
6952 }
6953
6954 /* We haven't found it. Maybe we're trying to access an
6955 inner class. The only way for us to know is to try again
6956 after having dropped a qualifier. If we can't break it further,
6957 we have an error. */
6958 if (split_qualified_name (&left, NULL, to_be_found))
6959 break;
6960
6961 to_be_found = left;
6962 }
6963 if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6964 {
6965 parse_error_context (TREE_PURPOSE (import),
6966 "Class or interface %qs not found in import",
6967 original_name);
6968 error_found = 1;
6969 }
6970
6971 free (original_name);
6972 if (error_found)
6973 return 1;
6974 }
6975 return 0;
6976 }
6977
6978 /* Possibly find and mark a class imported by a single-type import
6979 statement. */
6980
6981 static void
6982 find_in_imports (tree enclosing_type, tree class_type)
6983 {
6984 tree import;
6985 if (enclosing_type && TYPE_IMPORT_LIST (enclosing_type))
6986 import = TYPE_IMPORT_LIST (enclosing_type);
6987 else
6988 import = ctxp->import_list;
6989
6990 while (import)
6991 {
6992 if (TREE_VALUE (import) == TYPE_NAME (class_type))
6993 {
6994 TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6995 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6996 return;
6997 }
6998 import = TREE_CHAIN (import);
6999 }
7000 }
7001
7002 static int
7003 note_possible_classname (const char *name, int len)
7004 {
7005 tree node;
7006 if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
7007 len = len - 5;
7008 else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
7009 len = len - 6;
7010 else
7011 return 0;
7012 node = ident_subst (name, len, "", '/', '.', "");
7013 IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
7014 QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
7015 return 1;
7016 }
7017
7018 /* Read a import directory, gathering potential match for further type
7019 references. Indifferently reads a filesystem or a ZIP archive
7020 directory. */
7021
7022 static void
7023 read_import_dir (tree wfl)
7024 {
7025 tree package_id = EXPR_WFL_NODE (wfl);
7026 const char *package_name = IDENTIFIER_POINTER (package_id);
7027 int package_length = IDENTIFIER_LENGTH (package_id);
7028 DIR *dirp = NULL;
7029 JCF *saved_jcf = current_jcf;
7030
7031 int found = 0;
7032 int k;
7033 void *entry;
7034 struct buffer filename[1];
7035
7036 if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
7037 return;
7038 IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
7039
7040 BUFFER_INIT (filename);
7041 buffer_grow (filename, package_length + 100);
7042
7043 for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
7044 {
7045 const char *entry_name = jcf_path_name (entry);
7046 int entry_length = strlen (entry_name);
7047 if (jcf_path_is_zipfile (entry))
7048 {
7049 ZipFile *zipf;
7050 buffer_grow (filename, entry_length);
7051 memcpy (filename->data, entry_name, entry_length - 1);
7052 filename->data[entry_length-1] = '\0';
7053 zipf = opendir_in_zip ((const char *) filename->data, jcf_path_is_system (entry));
7054 if (zipf == NULL)
7055 error ("malformed .zip archive in CLASSPATH: %s", entry_name);
7056 else
7057 {
7058 ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
7059 BUFFER_RESET (filename);
7060 for (k = 0; k < package_length; k++)
7061 {
7062 char ch = package_name[k];
7063 *filename->ptr++ = ch == '.' ? '/' : ch;
7064 }
7065 *filename->ptr++ = '/';
7066
7067 for (k = 0; k < zipf->count; k++, zipd = ZIPDIR_NEXT (zipd))
7068 {
7069 const char *current_entry = ZIPDIR_FILENAME (zipd);
7070 int current_entry_len = zipd->filename_length;
7071
7072 if (current_entry_len >= BUFFER_LENGTH (filename)
7073 && strncmp ((const char *) filename->data, current_entry,
7074 BUFFER_LENGTH (filename)) != 0)
7075 continue;
7076 found |= note_possible_classname (current_entry,
7077 current_entry_len);
7078 }
7079 }
7080 }
7081 else
7082 {
7083 BUFFER_RESET (filename);
7084 buffer_grow (filename, entry_length + package_length + 4);
7085 strcpy ((char *) filename->data, entry_name);
7086 filename->ptr = filename->data + entry_length;
7087 for (k = 0; k < package_length; k++)
7088 {
7089 char ch = package_name[k];
7090 *filename->ptr++ = ch == '.' ? '/' : ch;
7091 }
7092 *filename->ptr = '\0';
7093
7094 dirp = opendir ((const char *) filename->data);
7095 if (dirp == NULL)
7096 continue;
7097 *filename->ptr++ = '/';
7098 for (;;)
7099 {
7100 int len;
7101 const char *d_name;
7102 struct dirent *direntp = readdir (dirp);
7103 if (!direntp)
7104 break;
7105 d_name = direntp->d_name;
7106 len = strlen (direntp->d_name);
7107 buffer_grow (filename, len+1);
7108 strcpy ((char *) filename->ptr, d_name);
7109 found |= note_possible_classname ((const char *) filename->data + entry_length,
7110 package_length+len+1);
7111 }
7112 if (dirp)
7113 closedir (dirp);
7114 }
7115 }
7116
7117 free (filename->data);
7118
7119 /* Here we should have a unified way of retrieving an entry, to be
7120 indexed. */
7121 if (!found)
7122 {
7123 static int first = 1;
7124 if (first)
7125 {
7126 error ("Can't find default package %qs. Check the CLASSPATH environment variable and the access to the archives", package_name);
7127 java_error_count++;
7128 first = 0;
7129 }
7130 else
7131 parse_error_context (wfl, "Package %qs not found in import",
7132 package_name);
7133 current_jcf = saved_jcf;
7134 return;
7135 }
7136 current_jcf = saved_jcf;
7137 }
7138
7139 /* Possibly find a type in the import on demands specified
7140 types. Returns 1 if an error occurred, 0 otherwise. Run through the
7141 entire list, to detected potential double definitions. */
7142
7143 static int
7144 find_in_imports_on_demand (tree enclosing_type, tree class_type)
7145 {
7146 tree class_type_name = TYPE_NAME (class_type);
7147 tree cl = NULL_TREE;
7148 int seen_once = -1; /* -1 when not set, 1 if seen once, >1 otherwise. */
7149 int to_return = -1; /* -1 when not set, 0 or 1 otherwise */
7150 tree node;
7151 tree import;
7152
7153 if (enclosing_type && TYPE_IMPORT_DEMAND_LIST (enclosing_type))
7154 import = TYPE_IMPORT_DEMAND_LIST (enclosing_type);
7155 else
7156 import = ctxp->import_demand_list;
7157
7158 for (; import; import = TREE_CHAIN (import))
7159 {
7160 location_t saved_location = input_location;
7161 int access_check;
7162 const char *id_name;
7163 tree decl, type_name_copy;
7164
7165 obstack_grow (&temporary_obstack,
7166 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7167 IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7168 obstack_1grow (&temporary_obstack, '.');
7169 obstack_grow0 (&temporary_obstack,
7170 IDENTIFIER_POINTER (class_type_name),
7171 IDENTIFIER_LENGTH (class_type_name));
7172 id_name = obstack_finish (&temporary_obstack);
7173
7174 if (! (node = maybe_get_identifier (id_name)))
7175 continue;
7176
7177 /* Setup input_line so that it refers to the line of the import (in
7178 case we parse a class file and encounter errors */
7179 #ifdef USE_MAPPED_LOCATION
7180 input_location = EXPR_LOCATION (TREE_PURPOSE (import));
7181 #else
7182 input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7183 #endif
7184
7185 type_name_copy = TYPE_NAME (class_type);
7186 TYPE_NAME (class_type) = node;
7187 QUALIFIED_P (node) = 1;
7188 decl = IDENTIFIER_CLASS_VALUE (node);
7189 access_check = -1;
7190 /* If there is no DECL set for the class or if the class isn't
7191 loaded and not seen in source yet, then load */
7192 if (!decl || ! CLASS_LOADED_P (TREE_TYPE (decl)))
7193 {
7194 load_class (node, 0);
7195 decl = IDENTIFIER_CLASS_VALUE (node);
7196 }
7197 if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7198 access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7199 false, NULL_TREE);
7200 else
7201 /* 6.6.1: Inner classes are subject to member access rules. */
7202 access_check = 0;
7203
7204 input_location = saved_location;
7205
7206 /* If the loaded class is not accessible or couldn't be loaded,
7207 we restore the original TYPE_NAME and process the next
7208 import. */
7209 if (access_check || !decl)
7210 {
7211 TYPE_NAME (class_type) = type_name_copy;
7212 continue;
7213 }
7214
7215 /* If the loaded class is accessible, we keep a tab on it to
7216 detect and report multiple inclusions. */
7217 if (IS_A_CLASSFILE_NAME (node))
7218 {
7219 if (seen_once < 0)
7220 {
7221 cl = TREE_PURPOSE (import);
7222 seen_once = 1;
7223 }
7224 else if (seen_once >= 0)
7225 {
7226 tree location = (cl ? cl : TREE_PURPOSE (import));
7227 tree package = (cl ? EXPR_WFL_NODE (cl) :
7228 EXPR_WFL_NODE (TREE_PURPOSE (import)));
7229 seen_once++;
7230 parse_error_context
7231 (location,
7232 "Type %qs also potentially defined in package %qs",
7233 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7234 IDENTIFIER_POINTER (package));
7235 }
7236 }
7237 to_return = access_check;
7238 }
7239
7240 if (seen_once == 1)
7241 return to_return;
7242 else
7243 return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7244 }
7245
7246 static tree
7247 resolve_package (tree pkg, tree *next, tree *type_name)
7248 {
7249 tree current;
7250 tree decl = NULL_TREE;
7251 *type_name = NULL_TREE;
7252
7253 /* The trick is to determine when the package name stops and were
7254 the name of something contained in the package starts. Then we
7255 return a fully qualified name of what we want to get. */
7256
7257 *next = EXPR_WFL_QUALIFICATION (pkg);
7258
7259 /* Try to progressively construct a type name */
7260 if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7261 for (current = EXPR_WFL_QUALIFICATION (pkg);
7262 current; current = TREE_CHAIN (current))
7263 {
7264 /* If we don't have what we're expecting, exit now. TYPE_NAME
7265 will be null and the error caught later. */
7266 if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7267 break;
7268 *type_name =
7269 merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7270 if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7271 {
7272 /* resolve_package should be used in a loop, hence we
7273 point at this one to naturally process the next one at
7274 the next iteration. */
7275 *next = current;
7276 break;
7277 }
7278 }
7279 return decl;
7280 }
7281
7282 /* Check accessibility of inner class DECL, from the context ENCLOSING_DECL,
7283 according to member access rules. */
7284
7285 static bool
7286 inner_class_accessible (tree decl, tree enclosing_decl)
7287 {
7288 tree enclosing_decl_type;
7289
7290 enclosing_decl_type = TREE_TYPE (enclosing_decl);
7291
7292 if (CLASS_PRIVATE (decl))
7293 {
7294 /* Access is permitted only within the body of the top-level
7295 class in which DECL is declared. */
7296 tree top_level = decl;
7297 while (DECL_CONTEXT (top_level))
7298 top_level = DECL_CONTEXT (top_level);
7299 while (DECL_CONTEXT (enclosing_decl))
7300 enclosing_decl = DECL_CONTEXT (enclosing_decl);
7301 if (top_level == enclosing_decl)
7302 return true;
7303 }
7304 else if (CLASS_PROTECTED (decl))
7305 {
7306 tree decl_context;
7307 /* Access is permitted from within the same package... */
7308 if (in_same_package (decl, enclosing_decl))
7309 return true;
7310
7311 /* ... or from within the body of a subtype of the context in which
7312 DECL is declared. */
7313 decl_context = DECL_CONTEXT (decl);
7314 while (enclosing_decl)
7315 {
7316 if (CLASS_INTERFACE (decl))
7317 {
7318 if (interface_of_p (TREE_TYPE (decl_context),
7319 enclosing_decl_type))
7320 return true;
7321 }
7322 else
7323 {
7324 /* Eww. The order of the arguments is different!! */
7325 if (inherits_from_p (enclosing_decl_type,
7326 TREE_TYPE (decl_context)))
7327 return true;
7328 }
7329 enclosing_decl = DECL_CONTEXT (enclosing_decl);
7330 }
7331 }
7332 else if (! CLASS_PUBLIC (decl))
7333 {
7334 /* Access is permitted only from within the same package as DECL. */
7335 if (in_same_package (decl, enclosing_decl))
7336 return true;
7337 }
7338 else
7339 /* Class is public. */
7340 return true;
7341
7342 return false;
7343 }
7344
7345 /* Check accessibility of inner classes according to member access rules.
7346 DECL is the inner class, ENCLOSING_DECL is the class from which the
7347 access is being attempted. */
7348
7349 static void
7350 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7351 {
7352 const char *access;
7353
7354 /* We don't issue an error message when CL is null. CL can be null
7355 as a result of processing a JDEP crafted by source_start_java_method
7356 for the purpose of patching its parm decl. But the error would
7357 have been already trapped when fixing the method's signature.
7358 DECL can also be NULL in case of earlier errors. */
7359 if (!decl || !cl)
7360 return;
7361
7362 if (inner_class_accessible (decl, enclosing_decl))
7363 return;
7364
7365 if (CLASS_PRIVATE (decl))
7366 access = "private";
7367 else if (CLASS_PROTECTED (decl))
7368 access = "protected";
7369 else
7370 access = "non-public";
7371
7372 parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7373 (CLASS_INTERFACE (decl) ? "interface" : "class"),
7374 lang_printable_name (decl, 2), access);
7375 }
7376
7377 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7378 foreign package, it must be PUBLIC. Return 0 if no access
7379 violations were found, 1 otherwise. If VERBOSE is true and an error
7380 was found, it is reported and accounted for. If CL is NULL then
7381 look it up with THIS_DECL. */
7382
7383 static int
7384 check_pkg_class_access (tree class_name, tree cl, bool verbose, tree this_decl)
7385 {
7386 tree type;
7387
7388 if (!IDENTIFIER_CLASS_VALUE (class_name))
7389 return 0;
7390
7391 if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7392 return 0;
7393
7394 if (!CLASS_PUBLIC (TYPE_NAME (type)))
7395 {
7396 /* Access to a private class within the same package is
7397 allowed. */
7398 tree l, r;
7399 split_qualified_name (&l, &r, class_name);
7400 if (!QUALIFIED_P (class_name) && !ctxp->package)
7401 /* Both in the empty package. */
7402 return 0;
7403 if (l == ctxp->package)
7404 /* Both in the same package. */
7405 return 0;
7406
7407 if (verbose)
7408 parse_error_context
7409 (cl == NULL ? lookup_cl (this_decl): cl,
7410 "Can't access %s %qs. Only public classes and interfaces in other packages can be accessed",
7411 (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7412 IDENTIFIER_POINTER (class_name));
7413 return 1;
7414 }
7415 return 0;
7416 }
7417
7418 /* Local variable declaration. */
7419
7420 static void
7421 declare_local_variables (int modifier, tree type, tree vlist)
7422 {
7423 tree decl, current, saved_type;
7424 tree type_wfl = NULL_TREE;
7425 int must_chain = 0;
7426 int final_p = 0;
7427
7428 /* Push a new block if statements were seen between the last time we
7429 pushed a block and now. Keep a count of blocks to close */
7430 if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7431 {
7432 tree b = enter_block ();
7433 BLOCK_IS_IMPLICIT (b) = 1;
7434 }
7435
7436 if (modifier)
7437 {
7438 size_t i;
7439 for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7440 if (1 << i & modifier)
7441 break;
7442 if (modifier == ACC_FINAL)
7443 final_p = 1;
7444 else
7445 {
7446 parse_error_context
7447 (ctxp->modifier_ctx [i],
7448 "Only %<final%> is allowed as a local variables modifier");
7449 return;
7450 }
7451 }
7452
7453 /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7454 hold the TYPE value if a new incomplete has to be created (as
7455 opposed to being found already existing and reused). */
7456 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7457
7458 /* If TYPE is fully resolved and we don't have a reference, make one */
7459 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7460
7461 /* Go through all the declared variables */
7462 for (current = vlist, saved_type = type; current;
7463 current = TREE_CHAIN (current), type = saved_type)
7464 {
7465 tree other, real_type;
7466 tree wfl = TREE_PURPOSE (current);
7467 tree name = EXPR_WFL_NODE (wfl);
7468 tree init = TREE_VALUE (current);
7469
7470 /* Process NAME, as it may specify extra dimension(s) for it */
7471 type = build_array_from_name (type, type_wfl, name, &name);
7472
7473 /* Variable redefinition check */
7474 if ((other = lookup_name_in_blocks (name)))
7475 {
7476 variable_redefinition_error (wfl, name, TREE_TYPE (other),
7477 DECL_SOURCE_LINE (other));
7478 continue;
7479 }
7480
7481 /* Type adjustment. We may have just readjusted TYPE because
7482 the variable specified more dimensions. Make sure we have
7483 a reference if we can and don't have one already. */
7484 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7485
7486 real_type = GET_REAL_TYPE (type);
7487 /* Never layout this decl. This will be done when its scope
7488 will be entered */
7489 decl = build_decl (VAR_DECL, name, real_type);
7490 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7491 DECL_FINAL (decl) = final_p;
7492 BLOCK_CHAIN_DECL (decl);
7493
7494 /* Don't try to use an INIT statement when an error was found */
7495 if (init && java_error_count)
7496 init = NULL_TREE;
7497
7498 /* Remember it if this is an initialized-upon-declaration final
7499 variable. */
7500 if (init && final_p)
7501 {
7502 DECL_LOCAL_FINAL_IUD (decl) = 1;
7503 }
7504
7505 /* Add the initialization function to the current function's code */
7506 if (init)
7507 {
7508 /* Name might have been readjusted */
7509 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7510 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7511 java_method_add_stmt (current_function_decl,
7512 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7513 init));
7514 }
7515
7516 /* Setup dependency the type of the decl */
7517 if (must_chain)
7518 {
7519 jdep *dep;
7520 register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7521 dep = CLASSD_LAST (ctxp->classd_list);
7522 JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7523 }
7524 }
7525 SOURCE_FRONTEND_DEBUG (("Defined locals"));
7526 }
7527
7528 /* Called during parsing. Build decls from argument list. */
7529
7530 static void
7531 source_start_java_method (tree fndecl)
7532 {
7533 tree tem;
7534 tree parm_decl;
7535 int i;
7536
7537 if (!fndecl)
7538 return;
7539
7540 current_function_decl = fndecl;
7541
7542 /* New scope for the function */
7543 enter_block ();
7544 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7545 tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7546 {
7547 tree type = TREE_VALUE (tem);
7548 tree name = TREE_PURPOSE (tem);
7549
7550 /* If type is incomplete. Create an incomplete decl and ask for
7551 the decl to be patched later */
7552 if (INCOMPLETE_TYPE_P (type))
7553 {
7554 jdep *jdep;
7555 tree real_type = GET_REAL_TYPE (type);
7556 parm_decl = build_decl (PARM_DECL, name, real_type);
7557 type = obtain_incomplete_type (type);
7558 register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7559 jdep = CLASSD_LAST (ctxp->classd_list);
7560 JDEP_MISC (jdep) = name;
7561 JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7562 }
7563 else
7564 parm_decl = build_decl (PARM_DECL, name, type);
7565
7566 /* Remember if a local variable was declared final (via its
7567 TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7568 if (ARG_FINAL_P (tem))
7569 {
7570 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7571 DECL_FINAL (parm_decl) = 1;
7572 }
7573
7574 if (name == this_identifier_node)
7575 DECL_ARTIFICIAL (parm_decl) = 1;
7576
7577 BLOCK_CHAIN_DECL (parm_decl);
7578 }
7579 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7580 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7581 nreverse (tem);
7582 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7583 DECL_MAX_LOCALS (current_function_decl) = i;
7584 }
7585
7586 /* Called during parsing. Creates an artificial method declaration. */
7587
7588 static tree
7589 create_artificial_method (tree class, int flags, tree type,
7590 tree name, tree args)
7591 {
7592 tree mdecl;
7593 location_t save_location = input_location;
7594
7595 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (class));
7596 mdecl = make_node (FUNCTION_TYPE);
7597 TREE_TYPE (mdecl) = type;
7598 TYPE_ARG_TYPES (mdecl) = args;
7599 /* We used to compute the signature of MDECL here and then use
7600 add_method(), but that failed because our caller might modify
7601 the type of the returned method, which trashes the cache in
7602 get_type_from_signature(). */
7603 mdecl = add_method_1 (class, flags, name, mdecl);
7604 input_location = save_location;
7605 DECL_ARTIFICIAL (mdecl) = 1;
7606 return mdecl;
7607 }
7608
7609 /* Starts the body if an artificial method. */
7610
7611 static void
7612 start_artificial_method_body (tree mdecl)
7613 {
7614 #ifdef USE_MAPPED_LOCATION
7615 DECL_SOURCE_LOCATION (mdecl) = ctxp->file_start_location;
7616 DECL_FUNCTION_LAST_LINE (mdecl) = ctxp->file_start_location;
7617 #else
7618 DECL_SOURCE_LINE (mdecl) = 1;
7619 DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7620 #endif
7621 source_start_java_method (mdecl);
7622 enter_block ();
7623 }
7624
7625 static void
7626 end_artificial_method_body (tree mdecl)
7627 {
7628 /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7629 It has to be evaluated first. (if mdecl is current_function_decl,
7630 we have an undefined behavior if no temporary variable is used.) */
7631 tree b = exit_block ();
7632 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7633 exit_block ();
7634 }
7635
7636 /* Dump a tree of some kind. This is a convenience wrapper for the
7637 dump_* functions in tree-dump.c. */
7638 static void
7639 dump_java_tree (enum tree_dump_index phase, tree t)
7640 {
7641 FILE *stream;
7642 int flags;
7643
7644 stream = dump_begin (phase, &flags);
7645 flags |= TDF_SLIM;
7646 if (stream)
7647 {
7648 dump_node (t, flags, stream);
7649 dump_end (phase, stream);
7650 }
7651 }
7652
7653 /* Terminate a function and expand its body. */
7654
7655 static void
7656 source_end_java_method (void)
7657 {
7658 tree fndecl = current_function_decl;
7659
7660 if (!fndecl)
7661 return;
7662
7663 java_parser_context_save_global ();
7664 #ifdef USE_MAPPED_LOCATION
7665 input_location = ctxp->last_ccb_indent1;
7666 #else
7667 input_line = ctxp->last_ccb_indent1;
7668 #endif
7669
7670 /* Turn function bodies with only a NOP expr null, so they don't get
7671 generated at all and we won't get warnings when using the -W
7672 -Wall flags. */
7673 if (IS_EMPTY_STMT (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))))
7674 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7675
7676 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7677 && ! flag_emit_class_files)
7678 finish_method (fndecl);
7679
7680 current_function_decl = NULL_TREE;
7681 java_parser_context_restore_global ();
7682 current_function_decl = NULL_TREE;
7683 }
7684
7685 /* Record EXPR in the current function block. Complements compound
7686 expression second operand if necessary. */
7687
7688 tree
7689 java_method_add_stmt (tree fndecl, tree expr)
7690 {
7691 if (!GET_CURRENT_BLOCK (fndecl))
7692 return NULL_TREE;
7693 return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7694 }
7695
7696 static tree
7697 add_stmt_to_block (tree b, tree type, tree stmt)
7698 {
7699 tree body = BLOCK_EXPR_BODY (b), c;
7700
7701 if (java_error_count)
7702 return body;
7703
7704 if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7705 return body;
7706
7707 BLOCK_EXPR_BODY (b) = c;
7708 TREE_SIDE_EFFECTS (c) = 1;
7709 return c;
7710 }
7711
7712 /* Lays out the methods for the classes seen so far. */
7713
7714 void
7715 java_layout_seen_class_methods (void)
7716 {
7717 tree previous_list = all_class_list;
7718 tree end = NULL_TREE;
7719 tree current;
7720
7721 while (1)
7722 {
7723 for (current = previous_list;
7724 current != end; current = TREE_CHAIN (current))
7725 {
7726 tree decl = TREE_VALUE (current);
7727 tree cls = TREE_TYPE (decl);
7728
7729 input_location = DECL_SOURCE_LOCATION (decl);
7730
7731 if (! CLASS_LOADED_P (cls))
7732 load_class (cls, 0);
7733
7734 layout_class_methods (cls);
7735 }
7736
7737 /* Note that new classes might have been added while laying out
7738 methods, changing the value of all_class_list. */
7739
7740 if (previous_list != all_class_list)
7741 {
7742 end = previous_list;
7743 previous_list = all_class_list;
7744 }
7745 else
7746 break;
7747 }
7748 }
7749
7750 static GTY(()) tree stop_reordering;
7751 void
7752 java_reorder_fields (void)
7753 {
7754 tree current;
7755
7756 for (current = gclass_list; current; current = TREE_CHAIN (current))
7757 {
7758 output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7759
7760 if (current_class == stop_reordering)
7761 break;
7762
7763 /* Reverse the fields, but leave the dummy field in front.
7764 Fields are already ordered for Object and Class */
7765 if (TYPE_FIELDS (current_class) && current_class != object_type_node
7766 && current_class != class_type_node)
7767 {
7768 /* If the dummy field is there, reverse the right fields and
7769 just layout the type for proper fields offset */
7770 if (!DECL_NAME (TYPE_FIELDS (current_class)))
7771 {
7772 tree fields = TYPE_FIELDS (current_class);
7773 /* This works around a problem where on some platforms,
7774 the field might be given its size incorrectly. */
7775 DECL_SIZE (fields) = NULL_TREE;
7776 DECL_SIZE_UNIT (fields) = NULL_TREE;
7777 TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7778 TYPE_SIZE (current_class) = NULL_TREE;
7779 }
7780 /* We don't have a dummy field, we need to layout the class,
7781 after having reversed the fields */
7782 else
7783 {
7784 TYPE_FIELDS (current_class) =
7785 nreverse (TYPE_FIELDS (current_class));
7786 TYPE_SIZE (current_class) = NULL_TREE;
7787 }
7788 }
7789 }
7790 /* There are cases were gclass_list will be empty. */
7791 if (gclass_list)
7792 stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7793 }
7794
7795 /* Layout the methods of all classes loaded in one way or another.
7796 Check methods of source parsed classes. Then reorder the
7797 fields and layout the classes or the type of all source parsed
7798 classes */
7799
7800 void
7801 java_layout_classes (void)
7802 {
7803 tree current;
7804 int save_error_count = java_error_count;
7805
7806 /* Layout the methods of all classes seen so far */
7807 java_layout_seen_class_methods ();
7808 java_parse_abort_on_error ();
7809 all_class_list = NULL_TREE;
7810
7811 /* Then check the methods of all parsed classes */
7812 for (current = gclass_list; current; current = TREE_CHAIN (current))
7813 if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7814 java_check_methods (TREE_VALUE (current));
7815 java_parse_abort_on_error ();
7816
7817 for (current = gclass_list; current; current = TREE_CHAIN (current))
7818 {
7819 output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7820 layout_class (current_class);
7821
7822 /* Error reported by the caller */
7823 if (java_error_count)
7824 return;
7825 }
7826
7827 /* We might have reloaded classes durign the process of laying out
7828 classes for code generation. We must layout the methods of those
7829 late additions, as constructor checks might use them */
7830 java_layout_seen_class_methods ();
7831 java_parse_abort_on_error ();
7832 }
7833
7834 /* Expand methods in the current set of classes remembered for
7835 generation. */
7836
7837 static void
7838 java_complete_expand_classes (void)
7839 {
7840 tree current;
7841
7842 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7843 if (!INNER_CLASS_DECL_P (current))
7844 java_complete_expand_class (current);
7845 }
7846
7847 /* Expand the methods found in OUTER, starting first by OUTER's inner
7848 classes, if any. */
7849
7850 static void
7851 java_complete_expand_class (tree outer)
7852 {
7853 tree inner_list;
7854
7855 /* We need to go after all inner classes and start expanding them,
7856 starting with most nested ones. We have to do that because nested
7857 classes might add functions to outer classes */
7858
7859 for (inner_list = DECL_INNER_CLASS_LIST (outer);
7860 inner_list; inner_list = TREE_CHAIN (inner_list))
7861 java_complete_expand_class (TREE_PURPOSE (inner_list));
7862
7863 java_complete_expand_methods (outer);
7864 }
7865
7866 /* Expand methods registered in CLASS_DECL. The general idea is that
7867 we expand regular methods first. This allows us get an estimate on
7868 how outer context local alias fields are really used so we can add
7869 to the constructor just enough code to initialize them properly (it
7870 also lets us generate finit$ correctly.) Then we expand the
7871 constructors and then <clinit>. */
7872
7873 static void
7874 java_complete_expand_methods (tree class_decl)
7875 {
7876 tree clinit, decl, first_decl;
7877
7878 output_class = current_class = TREE_TYPE (class_decl);
7879
7880 /* Pre-expand <clinit> to figure whether we really need it or
7881 not. If we do need it, we pre-expand the static fields so they're
7882 ready to be used somewhere else. <clinit> will be fully expanded
7883 after we processed the constructors. */
7884 first_decl = TYPE_METHODS (current_class);
7885 clinit = maybe_generate_pre_expand_clinit (current_class);
7886
7887 /* Then generate finit$ (if we need to) because constructors will
7888 try to use it.*/
7889 if (TYPE_FINIT_STMT_LIST (current_class))
7890 java_complete_expand_method (generate_finit (current_class));
7891
7892 /* Then generate instinit$ (if we need to) because constructors will
7893 try to use it. */
7894 if (TYPE_II_STMT_LIST (current_class))
7895 java_complete_expand_method (generate_instinit (current_class));
7896
7897 /* Now do the constructors */
7898 for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7899 {
7900 if (!DECL_CONSTRUCTOR_P (decl))
7901 continue;
7902 java_complete_expand_method (decl);
7903 }
7904
7905 /* First, do the ordinary methods. */
7906 for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7907 {
7908 /* Ctors aren't part of this batch. */
7909 if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7910 continue;
7911
7912 /* Skip abstract or native methods -- but do handle native
7913 methods when generating JNI stubs. */
7914 if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7915 {
7916 DECL_FUNCTION_BODY (decl) = NULL_TREE;
7917 continue;
7918 }
7919
7920 if (METHOD_NATIVE (decl))
7921 {
7922 tree body;
7923 current_function_decl = decl;
7924 body = build_jni_stub (decl);
7925 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7926 }
7927
7928 java_complete_expand_method (decl);
7929 }
7930
7931 /* If there is indeed a <clinit>, fully expand it now */
7932 if (clinit)
7933 {
7934 /* Prevent the use of `this' inside <clinit> */
7935 ctxp->explicit_constructor_p = 1;
7936 java_complete_expand_method (clinit);
7937 ctxp->explicit_constructor_p = 0;
7938 }
7939
7940 /* We might have generated a class$ that we now want to expand */
7941 if (TYPE_DOT_CLASS (current_class))
7942 java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7943
7944 /* Now verify constructor circularity (stop after the first one we
7945 prove wrong.) */
7946 if (!CLASS_INTERFACE (class_decl))
7947 for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7948 if (DECL_CONSTRUCTOR_P (decl)
7949 && verify_constructor_circularity (decl, decl))
7950 break;
7951 }
7952
7953 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7954 safely used in some other methods/constructors. */
7955
7956 static tree
7957 maybe_generate_pre_expand_clinit (tree class_type)
7958 {
7959 tree current, mdecl;
7960
7961 if (!TYPE_CLINIT_STMT_LIST (class_type))
7962 return NULL_TREE;
7963
7964 /* Go through all static fields and pre expand them */
7965 for (current = TYPE_FIELDS (class_type); current;
7966 current = TREE_CHAIN (current))
7967 if (FIELD_STATIC (current))
7968 build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7969
7970 /* Then build the <clinit> method */
7971 mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7972 clinit_identifier_node, end_params_node);
7973 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7974 mdecl, NULL_TREE);
7975 start_artificial_method_body (mdecl);
7976
7977 /* We process the list of assignment we produced as the result of
7978 the declaration of initialized static field and add them as
7979 statement to the <clinit> method. */
7980 for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7981 current = TREE_CHAIN (current))
7982 {
7983 tree stmt = current;
7984 /* We build the assignment expression that will initialize the
7985 field to its value. There are strict rules on static
7986 initializers (8.5). FIXME */
7987 if (TREE_CODE (stmt) != BLOCK && !IS_EMPTY_STMT (stmt))
7988 stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7989 java_method_add_stmt (mdecl, stmt);
7990 }
7991
7992 end_artificial_method_body (mdecl);
7993
7994 /* Now we want to place <clinit> as the last method (because we need
7995 it at least for interface so that it doesn't interfere with the
7996 dispatch table based lookup. */
7997 if (TREE_CHAIN (TYPE_METHODS (class_type)))
7998 {
7999 current = TREE_CHAIN (TYPE_METHODS (class_type));
8000 TYPE_METHODS (class_type) = current;
8001
8002 while (TREE_CHAIN (current))
8003 current = TREE_CHAIN (current);
8004
8005 TREE_CHAIN (current) = mdecl;
8006 TREE_CHAIN (mdecl) = NULL_TREE;
8007 }
8008
8009 return mdecl;
8010 }
8011
8012 /* Analyzes a method body and look for something that isn't a
8013 MODIFY_EXPR with a constant value. Return true if <clinit> is
8014 needed, false otherwise. */
8015
8016 static int
8017 analyze_clinit_body (tree this_class, tree bbody)
8018 {
8019 while (bbody)
8020 switch (TREE_CODE (bbody))
8021 {
8022 case BLOCK:
8023 bbody = BLOCK_EXPR_BODY (bbody);
8024 break;
8025
8026 case EXPR_WITH_FILE_LOCATION:
8027 bbody = EXPR_WFL_NODE (bbody);
8028 break;
8029
8030 case COMPOUND_EXPR:
8031 if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
8032 return 1;
8033 bbody = TREE_OPERAND (bbody, 1);
8034 break;
8035
8036 case MODIFY_EXPR:
8037 /* If we're generating to class file and we're dealing with an
8038 array initialization, we return 1 to keep <clinit> */
8039 if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
8040 && flag_emit_class_files)
8041 return 1;
8042
8043 /* There are a few cases where we're required to keep
8044 <clinit>:
8045 - If this is an assignment whose operand is not constant,
8046 - If this is an assignment to a non-initialized field,
8047 - If this field is not a member of the current class.
8048 */
8049 return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
8050 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
8051 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
8052
8053 case NOP_EXPR:
8054 /* We might see an empty statement here, which is
8055 ignorable. */
8056 return ! IS_EMPTY_STMT (bbody);
8057
8058 default:
8059 return 1;
8060 }
8061 return 0;
8062 }
8063
8064
8065 /* See whether we could get rid of <clinit>. Criteria are: all static
8066 final fields have constant initial values and the body of <clinit>
8067 is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
8068
8069 static int
8070 maybe_yank_clinit (tree mdecl)
8071 {
8072 tree type, current;
8073 tree fbody, bbody;
8074
8075 if (!DECL_CLINIT_P (mdecl))
8076 return 0;
8077
8078 /* If the body isn't empty, then we keep <clinit>. Note that if
8079 we're emitting classfiles, this isn't enough not to rule it
8080 out. */
8081 fbody = DECL_FUNCTION_BODY (mdecl);
8082 bbody = BLOCK_EXPR_BODY (fbody);
8083 if (bbody && bbody != error_mark_node)
8084 bbody = BLOCK_EXPR_BODY (bbody);
8085 else
8086 return 0;
8087 if (bbody && ! flag_emit_class_files && !IS_EMPTY_STMT (bbody))
8088 return 0;
8089
8090 type = DECL_CONTEXT (mdecl);
8091 current = TYPE_FIELDS (type);
8092
8093 for (current = (current ? TREE_CHAIN (current) : current);
8094 current; current = TREE_CHAIN (current))
8095 {
8096 tree f_init;
8097
8098 /* We're not interested in non-static fields. */
8099 if (!FIELD_STATIC (current))
8100 continue;
8101
8102 /* Nor in fields without initializers. */
8103 f_init = DECL_INITIAL (current);
8104 if (f_init == NULL_TREE)
8105 continue;
8106
8107 /* Anything that isn't String or a basic type is ruled out -- or
8108 if we know how to deal with it (when doing things natively) we
8109 should generated an empty <clinit> so that SUID are computed
8110 correctly. */
8111 if (! JSTRING_TYPE_P (TREE_TYPE (current))
8112 && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
8113 return 0;
8114
8115 if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
8116 return 0;
8117 }
8118
8119 /* Now we analyze the method body and look for something that
8120 isn't a MODIFY_EXPR */
8121 if (bbody && !IS_EMPTY_STMT (bbody) && analyze_clinit_body (type, bbody))
8122 return 0;
8123
8124 /* Get rid of <clinit> in the class' list of methods */
8125 if (TYPE_METHODS (type) == mdecl)
8126 TYPE_METHODS (type) = TREE_CHAIN (mdecl);
8127 else
8128 for (current = TYPE_METHODS (type); current;
8129 current = TREE_CHAIN (current))
8130 if (TREE_CHAIN (current) == mdecl)
8131 {
8132 TREE_CHAIN (current) = TREE_CHAIN (mdecl);
8133 break;
8134 }
8135
8136 return 1;
8137 }
8138
8139 /* Install the argument from MDECL. Suitable to completion and
8140 expansion of mdecl's body. */
8141
8142 void
8143 start_complete_expand_method (tree mdecl)
8144 {
8145 tree tem;
8146
8147 pushlevel (1); /* Prepare for a parameter push */
8148 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
8149 DECL_ARGUMENTS (mdecl) = tem;
8150
8151 for (; tem; tem = TREE_CHAIN (tem))
8152 {
8153 /* TREE_CHAIN (tem) will change after pushdecl. */
8154 tree next = TREE_CHAIN (tem);
8155 tree type = TREE_TYPE (tem);
8156 if (targetm.calls.promote_prototypes (type)
8157 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
8158 && INTEGRAL_TYPE_P (type))
8159 type = integer_type_node;
8160 DECL_ARG_TYPE (tem) = type;
8161 layout_decl (tem, 0);
8162 pushdecl (tem);
8163 /* Re-install the next so that the list is kept and the loop
8164 advances. */
8165 TREE_CHAIN (tem) = next;
8166 }
8167 pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8168 input_location = DECL_SOURCE_LOCATION (mdecl);
8169 build_result_decl (mdecl);
8170 }
8171
8172
8173 /* Complete and expand a method. */
8174
8175 static void
8176 java_complete_expand_method (tree mdecl)
8177 {
8178 tree fbody, block_body, exception_copy;
8179
8180 current_function_decl = mdecl;
8181 /* Fix constructors before expanding them */
8182 if (DECL_CONSTRUCTOR_P (mdecl))
8183 fix_constructors (mdecl);
8184
8185 /* Expand functions that have a body */
8186 if (!DECL_FUNCTION_BODY (mdecl))
8187 return;
8188
8189 fbody = DECL_FUNCTION_BODY (mdecl);
8190 block_body = BLOCK_EXPR_BODY (fbody);
8191 exception_copy = NULL_TREE;
8192
8193 current_function_decl = mdecl;
8194
8195 if (! quiet_flag)
8196 fprintf (stderr, " [%s.",
8197 lang_printable_name (DECL_CONTEXT (mdecl), 0));
8198 announce_function (mdecl);
8199 if (! quiet_flag)
8200 fprintf (stderr, "]");
8201
8202 /* Prepare the function for tree completion */
8203 start_complete_expand_method (mdecl);
8204
8205 /* Install the current this */
8206 current_this = (!METHOD_STATIC (mdecl) ?
8207 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8208
8209 /* Install exceptions thrown with `throws' */
8210 PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8211
8212 if (block_body != NULL_TREE)
8213 {
8214 block_body = java_complete_tree (block_body);
8215
8216 /* Before we check initialization, attached all class initialization
8217 variable to the block_body */
8218 htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8219 attach_init_test_initialization_flags, block_body);
8220
8221 if (! METHOD_NATIVE (mdecl))
8222 {
8223 check_for_initialization (block_body, mdecl);
8224
8225 /* Go through all the flags marking the initialization of
8226 static variables and see whether they're definitively
8227 assigned, in which case the type is remembered as
8228 definitively initialized in MDECL. */
8229 if (STATIC_CLASS_INIT_OPT_P ())
8230 {
8231 /* Always register the context as properly initialized in
8232 MDECL. This used with caution helps removing extra
8233 initialization of self. */
8234 if (METHOD_STATIC (mdecl))
8235 {
8236 *(htab_find_slot
8237 (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8238 DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8239 }
8240 }
8241 }
8242 ctxp->explicit_constructor_p = 0;
8243 }
8244
8245 BLOCK_EXPR_BODY (fbody) = block_body;
8246
8247 /* If we saw a return but couldn't evaluate it properly, we'll have
8248 an error_mark_node here. */
8249 if (block_body != error_mark_node
8250 && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8251 && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE)
8252 missing_return_error (current_function_decl);
8253
8254 /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8255 maybe_yank_clinit (mdecl);
8256
8257 /* Pop the current level, with special measures if we found errors. */
8258 if (java_error_count)
8259 pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8260 poplevel (1, 0, 1);
8261
8262 /* Pop the exceptions and sanity check */
8263 POP_EXCEPTIONS();
8264 if (currently_caught_type_list)
8265 abort ();
8266 }
8267
8268 /* For with each class for which there's code to generate. */
8269
8270 static void
8271 java_expand_method_bodies (tree class)
8272 {
8273 tree decl;
8274 for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8275 {
8276 tree block;
8277
8278 if (! DECL_FUNCTION_BODY (decl))
8279 continue;
8280
8281 current_function_decl = decl;
8282
8283 block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8284
8285 /* Save the function body for gimplify and inlining. */
8286 DECL_SAVED_TREE (decl) = block;
8287
8288 /* It's time to assign the variable flagging static class
8289 initialization based on which classes invoked static methods
8290 are definitely initializing. This should be flagged. */
8291 if (STATIC_CLASS_INIT_OPT_P ())
8292 {
8293 tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8294 for (; list != NULL_TREE; list = TREE_CHAIN (list))
8295 {
8296 /* Executed for each statement calling a static function.
8297 LIST is a TREE_LIST whose PURPOSE is the called function
8298 and VALUE is a compound whose second operand can be patched
8299 with static class initialization flag assignments. */
8300
8301 tree called_method = TREE_PURPOSE (list);
8302 tree compound = TREE_VALUE (list);
8303 tree assignment_compound_list
8304 = build_tree_list (called_method, NULL);
8305
8306 /* For each class definitely initialized in
8307 CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8308 assignment to the class initialization flag. */
8309 htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8310 emit_test_initialization,
8311 assignment_compound_list);
8312
8313 if (TREE_VALUE (assignment_compound_list))
8314 TREE_OPERAND (compound, 1)
8315 = TREE_VALUE (assignment_compound_list);
8316 }
8317 }
8318
8319 /* Expand the function body. */
8320 source_end_java_method ();
8321 }
8322 }
8323
8324 \f
8325
8326 /* This section of the code deals with accessing enclosing context
8327 fields either directly by using the relevant access to this$<n> or
8328 by invoking an access method crafted for that purpose. */
8329
8330 /* Build the necessary access across nested class boundaries.
8331 This routine could be optimized to cache previous result
8332 (decl, current_class and returned access). When an access method
8333 needs to be generated, it always takes the form of a read. It might
8334 be later turned into a write by calling nested_field_access_fix. */
8335
8336 static tree
8337 build_nested_field_access (tree id, tree decl)
8338 {
8339 tree access = NULL_TREE;
8340 tree ctx = NULL_TREE;
8341 tree decl_ctx = DECL_CONTEXT (decl);
8342 bool is_static = FIELD_STATIC (decl);
8343
8344 if (DECL_CONTEXT (TYPE_NAME (current_class)))
8345 ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8346
8347 /* For non-static fields, if the immediate enclosing context of the
8348 current class is the field decl's class or inherits from it,
8349 build the access as `this$<n>.<field>'. Note that we will break
8350 the `private' barrier if we're not emitting bytecodes. */
8351 if (!is_static
8352 && ctx
8353 && (ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8354 && (!FIELD_PRIVATE (decl) || !flag_emit_class_files))
8355 {
8356 tree thisn = build_current_thisn (current_class);
8357 access = make_qualified_primary (build_wfl_node (thisn),
8358 id, EXPR_WFL_LINECOL (id));
8359 }
8360 /* Otherwise, generate and use accessor methods for the field as
8361 needed. */
8362 else
8363 {
8364 int lc = EXPR_WFL_LINECOL (id);
8365
8366 /* Now we chain the required number of calls to the access$0 to
8367 get a hold to the enclosing instance we need for a non-static
8368 field, and then we build the field access. */
8369 if (!is_static)
8370 access = build_access_to_thisn (current_class, decl_ctx, lc);
8371
8372 /* If the field is private and we're generating bytecode, then
8373 we generate an access method. */
8374 if (FIELD_PRIVATE (decl) && flag_emit_class_files)
8375 {
8376 tree name = build_nested_field_access_methods (decl);
8377 access = build_nested_field_access_expr (lc, decl_ctx,
8378 name, access, NULL_TREE);
8379 }
8380 /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'
8381 for non-static fields.
8382 Once again we break the `private' access rule from a foreign
8383 class. */
8384 else if (is_static)
8385 {
8386 tree class_name = DECL_NAME (TYPE_NAME (decl_ctx));
8387 access
8388 = make_qualified_primary (build_wfl_node (class_name), id, lc);
8389 }
8390 else
8391 access = make_qualified_primary (access, id, lc);
8392 }
8393
8394 return resolve_expression_name (access, NULL);
8395 }
8396
8397 /* Return a nonzero value if DECL describes a member access across nested
8398 class boundaries. That is, DECL is in a class that either encloses,
8399 is enclosed by or shares a common enclosing class with the class
8400 TYPE. */
8401
8402 static int
8403 nested_member_access_p (tree type, tree decl)
8404 {
8405 bool is_static = false;
8406 tree decl_type = DECL_CONTEXT (decl);
8407 tree type_root, decl_type_root;
8408
8409 if (decl_type == type
8410 || (TREE_CODE (decl) != FIELD_DECL
8411 && TREE_CODE (decl) != VAR_DECL
8412 && TREE_CODE (decl) != FUNCTION_DECL))
8413 return 0;
8414
8415 if (!INNER_CLASS_TYPE_P (type)
8416 && !(TREE_CODE (decl_type) == RECORD_TYPE
8417 && INNER_CLASS_TYPE_P (decl_type)))
8418 return 0;
8419
8420 is_static = (TREE_CODE (decl) == FUNCTION_DECL)
8421 ? METHOD_STATIC (decl)
8422 : FIELD_STATIC (decl);
8423
8424 /* If TYPE extends the declaration context of the non-static
8425 member we're trying to access, then this isn't a nested member
8426 access we need to worry about. */
8427 if (!is_static && inherits_from_p (type, decl_type))
8428 return 0;
8429
8430 for (type_root = type;
8431 DECL_CONTEXT (TYPE_NAME (type_root));
8432 type_root = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type_root))))
8433 {
8434 if (type_root == decl_type)
8435 return 1;
8436 }
8437
8438 if (TREE_CODE (decl_type) == RECORD_TYPE
8439 && INNER_CLASS_TYPE_P (decl_type))
8440 {
8441 for (decl_type_root = decl_type;
8442 DECL_CONTEXT (TYPE_NAME (decl_type_root));
8443 decl_type_root
8444 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (decl_type_root))))
8445 {
8446 if (decl_type_root == type)
8447 return 1;
8448 }
8449 }
8450 else
8451 decl_type_root = decl_type;
8452
8453 if (type_root == decl_type_root)
8454 return 1;
8455
8456 /* Before we give up, see whether it is a non-static field
8457 inherited from the enclosing context we are considering. */
8458 if (!DECL_CONTEXT (TYPE_NAME (type_root))
8459 && !is_static
8460 && inherits_from_p (type_root, decl_type))
8461 return 1;
8462
8463 return 0;
8464 }
8465
8466 /* Return a nonzero value if NODE represents a cross-nested-class
8467 access that has already been expanded. As a side effect, it returns
8468 the name of the field being accessed and the argument passed to the
8469 access function, suitable for a regeneration of the access method
8470 call if necessary. */
8471
8472 static int
8473 nested_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8474 tree *arg)
8475 {
8476 int identified = 0;
8477
8478 if (TREE_CODE (node) != CALL_EXPR)
8479 return 0;
8480
8481 /* Well, GCJ generates slightly different tree nodes when compiling
8482 to native or bytecodes. It's the case for function calls. */
8483
8484 if (flag_emit_class_files
8485 && TREE_CODE (node) == CALL_EXPR
8486 && NESTED_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8487 identified = 1;
8488 else if (!flag_emit_class_files)
8489 {
8490 node = TREE_OPERAND (node, 0);
8491
8492 if (node && TREE_OPERAND (node, 0)
8493 && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8494 {
8495 node = TREE_OPERAND (node, 0);
8496 if (TREE_OPERAND (node, 0)
8497 && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8498 && (NESTED_FIELD_ACCESS_IDENTIFIER_P
8499 (DECL_NAME (TREE_OPERAND (node, 0)))))
8500 identified = 1;
8501 }
8502 }
8503
8504 if (identified && name && arg_type && arg)
8505 {
8506 tree argument = TREE_OPERAND (node, 1);
8507 *name = DECL_NAME (TREE_OPERAND (node, 0));
8508
8509 /* The accessors for static fields do not take in a this$<n> argument,
8510 so we take the class name from the accessor's context instead. */
8511 if (argument)
8512 {
8513 *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8514 *arg = TREE_VALUE (argument);
8515 }
8516 else
8517 {
8518 *arg_type = DECL_CONTEXT (TREE_OPERAND (node, 0));
8519 *arg = NULL_TREE;
8520 }
8521 }
8522 return identified;
8523 }
8524
8525 /* Detect in NODE cross-nested-class field read access and
8526 transform it into a write with RHS as an argument. This function
8527 is called from the java_complete_lhs when an assignment to a LHS can
8528 be identified. */
8529
8530 static tree
8531 nested_field_access_fix (tree wfl, tree node, tree rhs)
8532 {
8533 tree name, arg_type, arg;
8534
8535 if (nested_field_expanded_access_p (node, &name, &arg_type, &arg))
8536 {
8537 node = build_nested_field_access_expr (EXPR_WFL_LINECOL (wfl),
8538 arg_type, name, arg, rhs);
8539 return java_complete_tree (node);
8540 }
8541 return NULL_TREE;
8542 }
8543
8544 /* Construct the expression that calls an access method:
8545 <type>.access$<n>(<arg1> [, <arg2>]);
8546
8547 ARG2 can be NULL and will be omitted in that case. It will denote a
8548 read access. */
8549
8550 static tree
8551 build_nested_field_access_expr (int lc, tree type, tree access_method_name,
8552 tree arg1, tree arg2)
8553 {
8554 tree args, cn, access;
8555
8556 if (arg1)
8557 args = build_tree_list (NULL_TREE, arg1);
8558 else
8559 args = NULL_TREE;
8560
8561 if (arg2)
8562 {
8563 if (args)
8564 args = tree_cons (NULL_TREE, arg2, args);
8565 else
8566 args = build_tree_list (NULL_TREE, arg2);
8567 }
8568
8569 access
8570 = build_method_invocation (build_wfl_node (access_method_name), args);
8571 cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8572
8573 return make_qualified_primary (cn, access, lc);
8574 }
8575
8576 /* Build the name of a synthetic accessor used to access class members
8577 across nested class boundaries. */
8578
8579 static tree
8580 build_new_access_id (void)
8581 {
8582 static int access_n_counter = 1;
8583 char buffer [128];
8584
8585 sprintf (buffer, "access$%d", access_n_counter++);
8586 return get_identifier (buffer);
8587 }
8588
8589 /* Create the static access functions for the cross-nested-class field DECL.
8590 We define a read:
8591 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8592 return inst$.field;
8593 }
8594 and a write access:
8595 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8596 TREE_TYPE (<field>) value$) {
8597 return inst$.field = value$;
8598 }
8599 For static fields, these methods are generated without the instance
8600 parameter.
8601 We should have a usage flag on the DECL so we can lazily turn the ones
8602 we're using for code generation. FIXME.
8603 */
8604
8605 static tree
8606 build_nested_field_access_methods (tree decl)
8607 {
8608 tree id, args, stmt, mdecl, class_name = NULL_TREE;
8609 bool is_static = FIELD_STATIC (decl);
8610
8611 if (FIELD_NESTED_ACCESS_P (decl))
8612 return FIELD_NESTED_ACCESS (decl);
8613
8614 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8615
8616 /* Create the identifier and a function named after it. */
8617 id = build_new_access_id ();
8618
8619 /* The identifier is marked as bearing the name of a generated write
8620 access function for outer field accessed from inner classes. */
8621 NESTED_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8622
8623 /* Create the read access. */
8624 if (!is_static)
8625 {
8626 args = build_tree_list (inst_id,
8627 build_pointer_type (DECL_CONTEXT (decl)));
8628 TREE_CHAIN (args) = end_params_node;
8629 stmt = make_qualified_primary (build_wfl_node (inst_id),
8630 build_wfl_node (DECL_NAME (decl)), 0);
8631 }
8632 else
8633 {
8634 args = end_params_node;
8635 class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
8636 stmt = make_qualified_primary (build_wfl_node (class_name),
8637 build_wfl_node (DECL_NAME (decl)), 0);
8638 }
8639 stmt = build_return (0, stmt);
8640 mdecl = build_nested_field_access_method (DECL_CONTEXT (decl),
8641 TREE_TYPE (decl), id, args, stmt);
8642 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8643
8644 /* Create the write access method. No write access for final variable */
8645 if (!FIELD_FINAL (decl))
8646 {
8647 if (!is_static)
8648 {
8649 args = build_tree_list (inst_id,
8650 build_pointer_type (DECL_CONTEXT (decl)));
8651 TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8652 TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8653 stmt = make_qualified_primary (build_wfl_node (inst_id),
8654 build_wfl_node (DECL_NAME (decl)),
8655 0);
8656 }
8657 else
8658 {
8659 args = build_tree_list (wpv_id, TREE_TYPE (decl));
8660 TREE_CHAIN (args) = end_params_node;
8661 stmt = make_qualified_primary (build_wfl_node (class_name),
8662 build_wfl_node (DECL_NAME (decl)),
8663 0);
8664 }
8665 stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8666 build_wfl_node (wpv_id)));
8667 mdecl = build_nested_field_access_method (DECL_CONTEXT (decl),
8668 TREE_TYPE (decl), id,
8669 args, stmt);
8670 }
8671 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8672
8673 /* Return the access name */
8674 return FIELD_NESTED_ACCESS (decl) = id;
8675 }
8676
8677 /* Build a field access method NAME. */
8678
8679 static tree
8680 build_nested_field_access_method (tree class, tree type, tree name,
8681 tree args, tree body)
8682 {
8683 tree saved_current_function_decl, mdecl;
8684
8685 /* Create the method */
8686 mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8687 fix_method_argument_names (args, mdecl);
8688 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8689
8690 /* Attach the method body. */
8691 saved_current_function_decl = current_function_decl;
8692 start_artificial_method_body (mdecl);
8693 java_method_add_stmt (mdecl, body);
8694 end_artificial_method_body (mdecl);
8695 current_function_decl = saved_current_function_decl;
8696
8697 return mdecl;
8698 }
8699
8700 \f
8701 /* This section deals with building access function necessary for
8702 certain kinds of method invocation across nested class boundaries. */
8703
8704 static tree
8705 build_nested_method_access_method (tree decl)
8706 {
8707 tree saved_current_function_decl, mdecl;
8708 tree args = NULL_TREE, call_args = NULL_TREE;
8709 tree carg, id, body, class;
8710 char buffer [80];
8711 int parm_id_count = 0;
8712
8713 /* Test this abort with an access to a private field */
8714 if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8715 abort ();
8716
8717 /* Check the cache first */
8718 if (DECL_FUNCTION_INNER_ACCESS (decl))
8719 return DECL_FUNCTION_INNER_ACCESS (decl);
8720
8721 class = DECL_CONTEXT (decl);
8722
8723 /* Obtain an access identifier and mark it */
8724 id = build_new_access_id ();
8725 NESTED_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8726
8727 carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8728 /* Create the arguments, as much as the original */
8729 for (; carg && carg != end_params_node;
8730 carg = TREE_CHAIN (carg))
8731 {
8732 sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8733 args = chainon (args, build_tree_list (get_identifier (buffer),
8734 TREE_VALUE (carg)));
8735 }
8736 args = chainon (args, end_params_node);
8737
8738 /* Create the method */
8739 mdecl = create_artificial_method (class, ACC_STATIC,
8740 TREE_TYPE (TREE_TYPE (decl)), id, args);
8741 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8742 /* There is a potential bug here. We should be able to use
8743 fix_method_argument_names, but then arg names get mixed up and
8744 eventually a constructor will have its this$0 altered and the
8745 outer context won't be assignment properly. The testcase is
8746 stub.java FIXME */
8747 TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8748
8749 /* Attach the method body. */
8750 saved_current_function_decl = current_function_decl;
8751 start_artificial_method_body (mdecl);
8752
8753 /* The actual method invocation uses the same args. When invoking a
8754 static methods that way, we don't want to skip the first argument. */
8755 carg = args;
8756 if (!METHOD_STATIC (decl))
8757 carg = TREE_CHAIN (carg);
8758 for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8759 call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8760 call_args);
8761
8762 body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8763 call_args);
8764 if (!METHOD_STATIC (decl))
8765 body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8766 body, 0);
8767 if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8768 body = build_return (0, body);
8769 java_method_add_stmt (mdecl,body);
8770 end_artificial_method_body (mdecl);
8771 current_function_decl = saved_current_function_decl;
8772
8773 /* Back tag the access function so it know what it accesses. */
8774 DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8775
8776 /* Tag the current method so it knows it has an access generated. */
8777 return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8778 }
8779
8780 \f
8781 /* This section of the code deals with building expressions to access
8782 the enclosing instance of an inner class. The enclosing instance is
8783 kept in a generated field called this$<n>, with <n> being the
8784 inner class nesting level (starting from 0.) */
8785
8786 /* Build an access to a given this$<n>, always chaining access call to
8787 others. Access methods to this$<n> are build on the fly if
8788 necessary. This CAN'T be used to solely access this$<n-1> from
8789 this$<n> (which alway yield to special cases and optimization, see
8790 for example build_nested_field_access). */
8791
8792 static tree
8793 build_access_to_thisn (tree from, tree to, int lc)
8794 {
8795 tree access = NULL_TREE;
8796
8797 while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8798 {
8799 if (!access)
8800 {
8801 access = build_current_thisn (from);
8802 access = build_wfl_node (access);
8803 }
8804 else
8805 {
8806 tree access0_wfl, cn;
8807
8808 maybe_build_thisn_access_method (from);
8809 access0_wfl = build_wfl_node (access0_identifier_node);
8810 cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8811 EXPR_WFL_LINECOL (access0_wfl) = lc;
8812 access = build_tree_list (NULL_TREE, access);
8813 access = build_method_invocation (access0_wfl, access);
8814 access = make_qualified_primary (cn, access, lc);
8815 }
8816
8817 /* If FROM isn't an inner class, that's fine, we've done enough.
8818 What we're looking for can be accessed from there. */
8819 from = DECL_CONTEXT (TYPE_NAME (from));
8820 if (!from)
8821 break;
8822 from = TREE_TYPE (from);
8823 }
8824 return access;
8825 }
8826
8827 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8828 is returned if nothing needs to be generated. Otherwise, the method
8829 generated and a method decl is returned.
8830
8831 NOTE: These generated methods should be declared in a class file
8832 attribute so that they can't be referred to directly. */
8833
8834 static tree
8835 maybe_build_thisn_access_method (tree type)
8836 {
8837 tree mdecl, args, stmt, rtype;
8838 tree saved_current_function_decl;
8839
8840 /* If TYPE is a top-level class, no access method is required.
8841 If there already is such an access method, bail out. */
8842 if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8843 return NULL_TREE;
8844
8845 /* We generate the method. The method looks like:
8846 static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8847 */
8848 args = build_tree_list (inst_id, build_pointer_type (type));
8849 TREE_CHAIN (args) = end_params_node;
8850 rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8851 mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8852 access0_identifier_node, args);
8853 fix_method_argument_names (args, mdecl);
8854 layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8855 stmt = build_current_thisn (type);
8856 stmt = make_qualified_primary (build_wfl_node (inst_id),
8857 build_wfl_node (stmt), 0);
8858 stmt = build_return (0, stmt);
8859
8860 saved_current_function_decl = current_function_decl;
8861 start_artificial_method_body (mdecl);
8862 java_method_add_stmt (mdecl, stmt);
8863 end_artificial_method_body (mdecl);
8864 current_function_decl = saved_current_function_decl;
8865
8866 CLASS_ACCESS0_GENERATED_P (type) = 1;
8867
8868 return mdecl;
8869 }
8870
8871 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8872 the first level of innerclassing. this$1 for the next one, etc...
8873 This function can be invoked with TYPE to NULL, available and then
8874 has to count the parser context. */
8875
8876 static GTY(()) tree saved_thisn;
8877 static GTY(()) tree saved_type;
8878
8879 static tree
8880 build_current_thisn (tree type)
8881 {
8882 static int saved_i = -1;
8883 static int saved_type_i = 0;
8884 tree decl;
8885 char buffer [24];
8886 int i = 0;
8887
8888 if (type)
8889 {
8890 if (type == saved_type)
8891 i = saved_type_i;
8892 else
8893 {
8894 for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8895 decl; decl = DECL_CONTEXT (decl), i++)
8896 ;
8897
8898 saved_type = type;
8899 saved_type_i = i;
8900 }
8901 }
8902 else
8903 i = list_length (GET_CPC_LIST ())-2;
8904
8905 if (i == saved_i)
8906 return saved_thisn;
8907
8908 sprintf (buffer, "this$%d", i);
8909 saved_i = i;
8910 saved_thisn = get_identifier (buffer);
8911 return saved_thisn;
8912 }
8913
8914 /* Return the assignment to the hidden enclosing context `this$<n>'
8915 by the second incoming parameter to the innerclass constructor. The
8916 form used is `this.this$<n> = this$<n>;'. */
8917
8918 static tree
8919 build_thisn_assign (void)
8920 {
8921 if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8922 {
8923 tree thisn = build_current_thisn (current_class);
8924 tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8925 build_wfl_node (thisn), 0);
8926 tree rhs = build_wfl_node (thisn);
8927 #ifdef USE_MAPPED_LOCATION
8928 SET_EXPR_LOCATION (lhs, input_location);
8929 #else
8930 EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8931 #endif
8932 return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8933 }
8934 return NULL_TREE;
8935 }
8936
8937 \f
8938 /* Building the synthetic `class$' used to implement the `.class' 1.1
8939 extension for non primitive types. This method looks like:
8940
8941 static Class class$(String type) throws NoClassDefFoundError
8942 {
8943 try {return (java.lang.Class.forName (String));}
8944 catch (ClassNotFoundException e) {
8945 throw new NoClassDefFoundError(e.getMessage());}
8946 } */
8947
8948 static GTY(()) tree get_message_wfl;
8949 static GTY(()) tree type_parm_wfl;
8950
8951 static tree
8952 build_dot_class_method (tree class)
8953 {
8954 #define BWF(S) build_wfl_node (get_identifier ((S)))
8955 #ifdef USE_MAPPED_LOCATION
8956 #define MQN(X,Y) make_qualified_name ((X), (Y), UNKNOWN_LOCATION)
8957 #else
8958 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8959 #endif
8960 tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8961 tree stmt, throw_stmt;
8962
8963 if (!get_message_wfl)
8964 {
8965 get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8966 type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8967 }
8968
8969 /* Build the arguments */
8970 args = build_tree_list (get_identifier ("type$"),
8971 build_pointer_type (string_type_node));
8972 TREE_CHAIN (args) = end_params_node;
8973
8974 /* Build the qualified name java.lang.Class.forName */
8975 tmp = MQN (MQN (MQN (BWF ("java"),
8976 BWF ("lang")), BWF ("Class")), BWF ("forName"));
8977
8978 /* Create the "class$" function */
8979 mdecl = create_artificial_method (class, ACC_STATIC,
8980 build_pointer_type (class_type_node),
8981 classdollar_identifier_node, args);
8982 qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8983 BWF ("NoClassDefFoundError"));
8984 DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8985 register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8986 JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8987 &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8988
8989 /* We start by building the try block. We need to build:
8990 return (java.lang.Class.forName (type)); */
8991 stmt = build_method_invocation (tmp,
8992 build_tree_list (NULL_TREE, type_parm_wfl));
8993 stmt = build_return (0, stmt);
8994
8995 /* Now onto the catch block. We start by building the expression
8996 throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8997 #ifdef USE_MAPPED_LOCATION
8998 throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8999 get_message_wfl, UNKNOWN_LOCATION);
9000 #else
9001 throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
9002 get_message_wfl, 0);
9003 #endif
9004 throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
9005
9006 /* Build new NoClassDefFoundError (_.getMessage) */
9007 throw_stmt = build_new_invocation
9008 (build_wfl_node (get_identifier ("NoClassDefFoundError")),
9009 build_tree_list (build_pointer_type (string_type_node), throw_stmt));
9010
9011 /* Build the throw, (it's too early to use BUILD_THROW) */
9012 throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
9013
9014 /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
9015 qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
9016 BWF ("ClassNotFoundException"));
9017 stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
9018
9019 fix_method_argument_names (args, mdecl);
9020 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
9021 saved_current_function_decl = current_function_decl;
9022 start_artificial_method_body (mdecl);
9023 java_method_add_stmt (mdecl, stmt);
9024 end_artificial_method_body (mdecl);
9025 current_function_decl = saved_current_function_decl;
9026 TYPE_DOT_CLASS (class) = mdecl;
9027
9028 return mdecl;
9029 }
9030
9031 static tree
9032 build_dot_class_method_invocation (tree this_class, tree type)
9033 {
9034 tree dot_class_method = TYPE_DOT_CLASS (this_class);
9035 tree sig_id, s, t;
9036
9037 if (TYPE_ARRAY_P (type))
9038 sig_id = build_java_signature (type);
9039 else
9040 sig_id = DECL_NAME (TYPE_NAME (type));
9041
9042 /* Ensure that the proper name separator is used */
9043 sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
9044 IDENTIFIER_LENGTH (sig_id));
9045
9046 s = build_string (IDENTIFIER_LENGTH (sig_id),
9047 IDENTIFIER_POINTER (sig_id));
9048 t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
9049 build_tree_list (NULL_TREE, s));
9050 if (DECL_CONTEXT (dot_class_method) != this_class)
9051 {
9052 tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
9053 t = make_qualified_primary (build_wfl_node (class_name), t, 0);
9054 }
9055 return t;
9056 }
9057
9058 /* This section of the code deals with constructor. */
9059
9060 /* Craft a body for default constructor. Patch existing constructor
9061 bodies with call to super() and field initialization statements if
9062 necessary. */
9063
9064 static void
9065 fix_constructors (tree mdecl)
9066 {
9067 tree iii; /* Instance Initializer Invocation */
9068 tree *bodyp = &DECL_FUNCTION_BODY (mdecl);
9069 tree thisn_assign, compound = NULL_TREE;
9070 tree class_type = DECL_CONTEXT (mdecl);
9071
9072 if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
9073 return;
9074 DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
9075
9076 if (!*bodyp)
9077 {
9078 /* It is an error for the compiler to generate a default
9079 constructor if the superclass doesn't have a constructor that
9080 takes no argument, or the same args for an anonymous class */
9081 tree sdecl = get_constructor_super (mdecl);
9082 if (sdecl == NULL_TREE)
9083 {
9084 tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
9085 tree save = DECL_NAME (mdecl);
9086 const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
9087 DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
9088 parse_error_context
9089 (lookup_cl (TYPE_NAME (class_type)),
9090 "No constructor matching %qs found in class %qs",
9091 lang_printable_name (mdecl, 2), n);
9092 DECL_NAME (mdecl) = save;
9093 }
9094
9095 if (ANONYMOUS_CLASS_P (class_type))
9096 {
9097 /* Copy throws clause from the super constructor. */
9098 tree throws = DECL_FUNCTION_THROWS (sdecl);
9099 DECL_FUNCTION_THROWS (mdecl) = copy_list (throws);
9100 }
9101
9102 /* The constructor body must be crafted by hand. It's the
9103 constructor we defined when we realize we didn't have the
9104 CLASSNAME() constructor */
9105 start_artificial_method_body (mdecl);
9106
9107 /* Insert an assignment to the this$<n> hidden field, if
9108 necessary */
9109 if ((thisn_assign = build_thisn_assign ()))
9110 java_method_add_stmt (mdecl, thisn_assign);
9111
9112 /* We don't generate a super constructor invocation if we're
9113 compiling java.lang.Object. build_super_invocation takes care
9114 of that. */
9115 java_method_add_stmt (mdecl, build_super_invocation (mdecl));
9116
9117 /* FIXME */
9118 if ((iii = build_instinit_invocation (class_type)))
9119 java_method_add_stmt (mdecl, iii);
9120
9121 end_artificial_method_body (mdecl);
9122 }
9123 /* Search for an explicit constructor invocation */
9124 else
9125 {
9126 int found = 0;
9127 int invokes_this = 0;
9128 tree main_block = BLOCK_EXPR_BODY (*bodyp);
9129
9130 while (*bodyp)
9131 {
9132 tree body = *bodyp;
9133 switch (TREE_CODE (body))
9134 {
9135 case CALL_EXPR:
9136 found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
9137 if (CALL_THIS_CONSTRUCTOR_P (body))
9138 invokes_this = 1;
9139 break;
9140 case COMPOUND_EXPR:
9141 case EXPR_WITH_FILE_LOCATION:
9142 bodyp = &TREE_OPERAND (body, 0);
9143 continue;
9144 case BLOCK:
9145 bodyp = &BLOCK_EXPR_BODY (body);
9146 continue;
9147 default:
9148 break;
9149 }
9150 break;
9151 }
9152
9153 /* Generate the assignment to this$<n>, if necessary */
9154 if ((thisn_assign = build_thisn_assign ()))
9155 compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
9156
9157 /* The constructor is missing an invocation of super() */
9158 if (!found)
9159 compound = add_stmt_to_compound (compound, NULL_TREE,
9160 build_super_invocation (mdecl));
9161 /* Explicit super() invocation should take place before the
9162 instance initializer blocks. */
9163 else
9164 {
9165 compound = add_stmt_to_compound (compound, NULL_TREE, *bodyp);
9166 *bodyp = build_java_empty_stmt ();
9167 }
9168
9169 DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
9170
9171 /* Insert the instance initializer block right after. */
9172 if (!invokes_this && (iii = build_instinit_invocation (class_type)))
9173 compound = add_stmt_to_compound (compound, NULL_TREE, iii);
9174
9175 /* Fix the constructor main block if we're adding extra stmts */
9176 if (compound)
9177 {
9178 compound = add_stmt_to_compound (compound, NULL_TREE,
9179 BLOCK_EXPR_BODY (main_block));
9180 BLOCK_EXPR_BODY (main_block) = compound;
9181 }
9182 }
9183 }
9184
9185 /* Browse constructors in the super class, searching for a constructor
9186 that doesn't take any argument. Return the constructor if one is found,
9187 NULL_TREE otherwise. If the current class is an anonymous inner class,
9188 look for something that has the same signature. */
9189 static tree
9190 get_constructor_super (tree mdecl)
9191 {
9192 tree class = CLASSTYPE_SUPER (current_class);
9193 int super_inner = PURE_INNER_CLASS_TYPE_P (class);
9194 tree sdecl;
9195
9196 if (!class)
9197 return NULL_TREE;
9198
9199 if (ANONYMOUS_CLASS_P (current_class))
9200 {
9201 tree mdecl_arg_type;
9202 SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
9203 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9204 if (DECL_CONSTRUCTOR_P (sdecl))
9205 {
9206 tree m_arg_type;
9207 tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9208 if (super_inner)
9209 arg_type = TREE_CHAIN (arg_type);
9210 for (m_arg_type = mdecl_arg_type;
9211 (arg_type != end_params_node
9212 && m_arg_type != end_params_node);
9213 arg_type = TREE_CHAIN (arg_type),
9214 m_arg_type = TREE_CHAIN (m_arg_type))
9215 if (!valid_method_invocation_conversion_p
9216 (TREE_VALUE (arg_type),
9217 TREE_VALUE (m_arg_type)))
9218 break;
9219
9220 if (arg_type == end_params_node && m_arg_type == end_params_node)
9221 return sdecl;
9222 }
9223 }
9224 else
9225 {
9226 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9227 {
9228 tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9229 if (super_inner)
9230 arg = TREE_CHAIN (arg);
9231 if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
9232 return sdecl;
9233 }
9234 }
9235 return NULL_TREE;
9236 }
9237
9238 /* Generate code for all context remembered for code generation. */
9239
9240 static GTY(()) tree reversed_class_list;
9241 void
9242 java_expand_classes (void)
9243 {
9244 int save_error_count = 0;
9245 static struct parser_ctxt *cur_ctxp = NULL;
9246 location_t save_location;
9247
9248 java_parse_abort_on_error ();
9249 if (!(ctxp = ctxp_for_generation))
9250 return;
9251 java_layout_classes ();
9252 java_parse_abort_on_error ();
9253 save_location = input_location;
9254
9255 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9256 {
9257 tree current;
9258 for (current = cur_ctxp->class_list;
9259 current;
9260 current = TREE_CHAIN (current))
9261 gen_indirect_dispatch_tables (TREE_TYPE (current));
9262 }
9263
9264 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9265 {
9266 ctxp = cur_ctxp;
9267 input_location = ctxp->file_start_location;
9268 lang_init_source (2); /* Error msgs have method prototypes */
9269 java_complete_expand_classes (); /* Complete and expand classes */
9270 java_parse_abort_on_error ();
9271 }
9272 input_location = save_location;
9273
9274 /* Find anonymous classes and expand their constructor. This extra pass is
9275 necessary because the constructor itself is only generated when the
9276 method in which it is defined is expanded. */
9277 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9278 {
9279 tree current;
9280 ctxp = cur_ctxp;
9281 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9282 {
9283 output_class = current_class = TREE_TYPE (current);
9284 if (ANONYMOUS_CLASS_P (current_class))
9285 {
9286 tree d;
9287 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9288 {
9289 if (DECL_CONSTRUCTOR_P (d))
9290 {
9291 java_complete_expand_method (d);
9292 break; /* There is only one constructor. */
9293 }
9294 }
9295 }
9296 }
9297 }
9298
9299 /* Expanding the constructors of anonymous classes generates access
9300 methods. Scan all the methods looking for null DECL_RESULTs --
9301 this will be the case if a method hasn't been expanded. */
9302 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9303 {
9304 tree current;
9305 ctxp = cur_ctxp;
9306 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9307 {
9308 tree d;
9309 output_class = current_class = TREE_TYPE (current);
9310 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9311 {
9312 if (DECL_RESULT (d) == NULL_TREE)
9313 java_complete_expand_method (d);
9314 }
9315 }
9316 }
9317
9318 /* ??? Instead of all this we could iterate around the list of
9319 classes until there were no more un-expanded methods. It would
9320 take a little longer -- one pass over the whole list of methods
9321 -- but it would be simpler. Like this: */
9322 #if 0
9323 {
9324 int something_changed;
9325
9326 do
9327 {
9328 something_changed = 0;
9329 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9330 {
9331 tree current;
9332 ctxp = cur_ctxp;
9333 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9334 {
9335 tree d;
9336 output_class = current_class = TREE_TYPE (current);
9337 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9338 {
9339 if (DECL_RESULT (d) == NULL_TREE)
9340 {
9341 something_changed = 1;
9342 java_complete_expand_method (d);
9343 }
9344 }
9345 }
9346 }
9347 }
9348 while (something_changed);
9349 }
9350 #endif
9351
9352 /* If we've found error at that stage, don't try to generate
9353 anything, unless we're checking the syntax only
9354 (but not using -fsyntax-only for the purpose of generating
9355 bytecode). */
9356 if (java_error_count
9357 && (!flag_syntax_only && !flag_emit_class_files))
9358 return;
9359
9360 /* Now things are stable, go for generation of the class data. */
9361
9362 /* We pessimistically marked all methods and fields external until
9363 we knew what set of classes we were planning to compile. Now mark
9364 those that will be generated locally as not external. */
9365 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9366 {
9367 tree current;
9368 ctxp = cur_ctxp;
9369 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9370 java_mark_class_local (TREE_TYPE (current));
9371 }
9372
9373 /* Compile the classes. */
9374 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9375 {
9376 tree current;
9377 reversed_class_list = NULL;
9378
9379 ctxp = cur_ctxp;
9380
9381 /* We write out the classes in reverse order. This ensures that
9382 inner classes are written before their containing classes,
9383 which is important for parallel builds. Otherwise, the
9384 class file for the outer class may be found, but the class
9385 file for the inner class may not be present. In that
9386 situation, the compiler cannot fall back to the original
9387 source, having already read the outer class, so we must
9388 prevent that situation. */
9389 for (current = ctxp->class_list;
9390 current;
9391 current = TREE_CHAIN (current))
9392 reversed_class_list
9393 = tree_cons (NULL_TREE, current, reversed_class_list);
9394
9395 for (current = reversed_class_list;
9396 current;
9397 current = TREE_CHAIN (current))
9398 {
9399 output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9400 if (flag_emit_class_files)
9401 write_classfile (current_class);
9402 else if (! flag_syntax_only)
9403 java_expand_method_bodies (current_class);
9404 }
9405 }
9406 }
9407
9408 void
9409 java_finish_classes (void)
9410 {
9411 static struct parser_ctxt *cur_ctxp = NULL;
9412 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9413 {
9414 tree current;
9415 ctxp = cur_ctxp;
9416 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9417 {
9418 output_class = current_class = TREE_TYPE (current);
9419 finish_class ();
9420 }
9421 }
9422 }
9423
9424 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9425 a tree list node containing RIGHT. Fore coming RIGHTs will be
9426 chained to this hook. LOCATION contains the location of the
9427 separating `.' operator. */
9428
9429 static tree
9430 make_qualified_primary (tree primary, tree right, int location)
9431 {
9432 tree wfl;
9433
9434 if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9435 wfl = build_wfl_wrap (primary, location);
9436 else
9437 {
9438 wfl = primary;
9439 /* If wfl wasn't qualified, we build a first anchor */
9440 if (!EXPR_WFL_QUALIFICATION (wfl))
9441 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9442 }
9443
9444 /* And chain them */
9445 EXPR_WFL_LINECOL (right) = location;
9446 chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9447 PRIMARY_P (wfl) = 1;
9448 return wfl;
9449 }
9450
9451 /* Simple merge of two name separated by a `.' */
9452
9453 static tree
9454 merge_qualified_name (tree left, tree right)
9455 {
9456 tree node;
9457 if (!left && !right)
9458 return NULL_TREE;
9459
9460 if (!left)
9461 return right;
9462
9463 if (!right)
9464 return left;
9465
9466 obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9467 IDENTIFIER_LENGTH (left));
9468 obstack_1grow (&temporary_obstack, '.');
9469 obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9470 IDENTIFIER_LENGTH (right));
9471 node = get_identifier (obstack_base (&temporary_obstack));
9472 obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9473 QUALIFIED_P (node) = 1;
9474 return node;
9475 }
9476
9477 /* Merge the two parts of a qualified name into LEFT. Set the
9478 location information of the resulting node to LOCATION, usually
9479 inherited from the location information of the `.' operator. */
9480
9481 static tree
9482 make_qualified_name (tree left, tree right,
9483 #ifdef USE_MAPPED_LOCATION
9484 source_location location
9485 #else
9486 int location
9487 #endif
9488 )
9489 {
9490 #ifdef USE_COMPONENT_REF
9491 tree node = build3 (COMPONENT_REF, NULL_TREE, left, right, NULL_TREE);
9492 SET_EXPR_LOCATION (node, location);
9493 return node;
9494 #else
9495 tree left_id = EXPR_WFL_NODE (left);
9496 tree right_id = EXPR_WFL_NODE (right);
9497 tree wfl, merge;
9498
9499 merge = merge_qualified_name (left_id, right_id);
9500
9501 /* Left wasn't qualified and is now qualified */
9502 #ifdef USE_MAPPED_LOCATION
9503 if (!QUALIFIED_P (left_id))
9504 {
9505 tree wfl = build_expr_wfl (left_id, EXPR_LOCATION (left));
9506 EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9507 }
9508
9509 wfl = build_expr_wfl (right_id, location);
9510 #else
9511 if (!QUALIFIED_P (left_id))
9512 {
9513 tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9514 EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9515 EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9516 }
9517
9518 wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9519 EXPR_WFL_LINECOL (wfl) = location;
9520 #endif
9521 chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9522 EXPR_WFL_NODE (left) = merge;
9523 return left;
9524 #endif
9525 }
9526
9527 /* Extract the last identifier component of the qualified in WFL. The
9528 last identifier is removed from the linked list */
9529
9530 static tree
9531 cut_identifier_in_qualified (tree wfl)
9532 {
9533 tree q;
9534 tree previous = NULL_TREE;
9535 for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9536 if (!TREE_CHAIN (q))
9537 {
9538 if (!previous)
9539 /* Operating on a non qualified qualified WFL. */
9540 abort ();
9541
9542 TREE_CHAIN (previous) = NULL_TREE;
9543 return TREE_PURPOSE (q);
9544 }
9545 }
9546
9547 /* Resolve the expression name NAME. Return its decl. */
9548
9549 static tree
9550 resolve_expression_name (tree id, tree *orig)
9551 {
9552 tree name = EXPR_WFL_NODE (id);
9553 tree decl;
9554
9555 /* 6.5.5.1: Simple expression names */
9556 if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9557 {
9558 /* 15.13.1: NAME can appear within the scope of a local variable
9559 declaration */
9560 if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9561 return decl;
9562
9563 /* 15.13.1: NAME can appear within a class declaration */
9564 else
9565 {
9566 decl = lookup_field_wrapper (current_class, name);
9567 if (decl)
9568 {
9569 tree access = NULL_TREE;
9570 int fs = FIELD_STATIC (decl);
9571
9572 /* If we're accessing an outer scope local alias, make
9573 sure we change the name of the field we're going to
9574 build access to. */
9575 if (FIELD_LOCAL_ALIAS_USED (decl))
9576 name = DECL_NAME (decl);
9577
9578 check_deprecation (id, decl);
9579
9580 /* Instance variable (8.3.1.1) can't appear within
9581 static method, static initializer or initializer for
9582 a static variable. */
9583 if (!fs && METHOD_STATIC (current_function_decl))
9584 {
9585 static_ref_err (id, name, current_class);
9586 return error_mark_node;
9587 }
9588 /* Instance variables can't appear as an argument of
9589 an explicit constructor invocation */
9590 if (!fs && ctxp->explicit_constructor_p
9591 && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9592 {
9593 parse_error_context
9594 (id, "Can't reference %qs before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9595 return error_mark_node;
9596 }
9597
9598 /* If we're processing an inner class and we're trying
9599 to access a field belonging to an outer class, build
9600 the access to the field.
9601 As usual, we have to treat initialized static final
9602 variables as a special case. */
9603 if (nested_member_access_p (current_class, decl)
9604 && ! (JDECL_P (decl) && CLASS_FINAL_VARIABLE_P (decl)
9605 && DECL_INITIAL (decl) != NULL_TREE
9606 && (JSTRING_TYPE_P (TREE_TYPE (decl))
9607 || JNUMERIC_TYPE_P (TREE_TYPE (decl)))
9608 && TREE_CONSTANT (DECL_INITIAL (decl))))
9609 {
9610 if (!fs && CLASS_STATIC (TYPE_NAME (current_class)))
9611 {
9612 static_ref_err (id, DECL_NAME (decl), current_class);
9613 return error_mark_node;
9614 }
9615 access = build_nested_field_access (id, decl);
9616 if (orig)
9617 *orig = access;
9618 return access;
9619 }
9620
9621 /* Otherwise build what it takes to access the field */
9622 access = build_field_ref ((fs ? NULL_TREE : current_this),
9623 DECL_CONTEXT (decl), name);
9624 if (fs)
9625 access = maybe_build_class_init_for_field (decl, access);
9626 /* We may be asked to save the real field access node */
9627 if (orig)
9628 *orig = access;
9629 /* Last check: can we access the field? */
9630 if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9631 {
9632 not_accessible_field_error (id, decl);
9633 return error_mark_node;
9634 }
9635 /* And we return what we got */
9636 return access;
9637 }
9638 /* Fall down to error report on undefined variable */
9639 }
9640 }
9641 /* 6.5.5.2 Qualified Expression Names */
9642 else
9643 {
9644 if (orig)
9645 *orig = NULL_TREE;
9646 qualify_ambiguous_name (id);
9647 /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9648 /* 15.10.2: Accessing Superclass Members using super */
9649 return resolve_field_access (id, orig, NULL);
9650 }
9651
9652 /* We've got an error here */
9653 if (INNER_CLASS_TYPE_P (current_class))
9654 parse_error_context (id,
9655 "Local variable %qs can't be accessed from within the inner class %qs unless it is declared final",
9656 IDENTIFIER_POINTER (name),
9657 IDENTIFIER_POINTER (DECL_NAME
9658 (TYPE_NAME (current_class))));
9659 else
9660 parse_error_context (id, "Undefined variable %qs",
9661 IDENTIFIER_POINTER (name));
9662
9663 return error_mark_node;
9664 }
9665
9666 static void
9667 static_ref_err (tree wfl, tree field_id, tree class_type)
9668 {
9669 parse_error_context
9670 (wfl,
9671 "Can't make a static reference to nonstatic variable %qs in class %qs",
9672 IDENTIFIER_POINTER (field_id),
9673 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9674 }
9675
9676 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9677 We return something suitable to generate the field access. We also
9678 return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
9679 recipient's address can be null. */
9680
9681 static tree
9682 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9683 {
9684 int is_static = 0;
9685 tree field_ref;
9686 tree decl = NULL_TREE, where_found, type_found;
9687
9688 if (resolve_qualified_expression_name (qual_wfl, &decl,
9689 &where_found, &type_found))
9690 return error_mark_node;
9691
9692 /* Resolve the LENGTH field of an array here */
9693 if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9694 && type_found && TYPE_ARRAY_P (type_found)
9695 && ! flag_emit_class_files)
9696 {
9697 tree length = build_java_array_length_access (where_found);
9698 field_ref = length;
9699
9700 /* In case we're dealing with a static array, we need to
9701 initialize its class before the array length can be fetched. */
9702 if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9703 {
9704 build_static_field_ref (where_found);
9705 field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9706 }
9707 }
9708 /* We might have been trying to resolve field.method(). In which
9709 case, the resolution is over and decl is the answer */
9710 else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9711 field_ref = decl;
9712 else if (JDECL_P (decl))
9713 {
9714 if (!type_found)
9715 type_found = DECL_CONTEXT (decl);
9716 is_static = FIELD_STATIC (decl);
9717 field_ref = build_field_ref ((is_static ?
9718 NULL_TREE : where_found),
9719 type_found, DECL_NAME (decl));
9720 if (field_ref == error_mark_node)
9721 return error_mark_node;
9722 if (is_static)
9723 field_ref = maybe_build_class_init_for_field (decl, field_ref);
9724
9725 /* If we're looking at a static field, we may need to generate a
9726 class initialization for it. This can happen when the access
9727 looks like `field.ref', where `field' is a static field in an
9728 interface we implement. */
9729 if (!flag_emit_class_files
9730 && TREE_CODE (where_found) == VAR_DECL
9731 && FIELD_STATIC (where_found))
9732 {
9733 build_static_field_ref (where_found);
9734 field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9735 }
9736 }
9737 else
9738 field_ref = decl;
9739
9740 if (field_decl)
9741 *field_decl = decl;
9742 if (field_type)
9743 *field_type = (QUAL_DECL_TYPE (decl) ?
9744 QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9745 return field_ref;
9746 }
9747
9748 /* If NODE is an access to a static field, strip out the class
9749 initialization part and return the field decl, otherwise, return
9750 NODE. */
9751
9752 tree
9753 extract_field_decl (tree node)
9754 {
9755 if (TREE_CODE (node) == COMPOUND_EXPR)
9756 {
9757 tree op1 = TREE_OPERAND (node, 1);
9758 if (TREE_CODE (op1) == COMPOUND_EXPR)
9759 {
9760 tree call = TREE_OPERAND (op1, 0);
9761 if (TREE_CODE (call) == CALL_EXPR
9762 && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9763 && (TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9764 == soft_initclass_node))
9765 return TREE_OPERAND (op1, 1);
9766 }
9767 else if (JDECL_P (op1))
9768 return op1;
9769 }
9770 return node;
9771 }
9772
9773 /* 6.5.5.2: Qualified Expression Names */
9774
9775 static int
9776 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9777 tree *where_found, tree *type_found)
9778 {
9779 int from_type = 0; /* Field search initiated from a type */
9780 int from_super = 0, from_cast = 0, from_qualified_this = 0;
9781 int previous_call_static = 0;
9782 int is_static;
9783 tree decl = NULL_TREE, type = NULL_TREE, q;
9784 /* For certain for of inner class instantiation */
9785 tree saved_current, saved_this;
9786 #define RESTORE_THIS_AND_CURRENT_CLASS \
9787 { current_class = saved_current; current_this = saved_this;}
9788
9789 *type_found = *where_found = NULL_TREE;
9790
9791 for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9792 {
9793 tree qual_wfl = QUAL_WFL (q);
9794 tree ret_decl; /* for EH checking */
9795 #ifdef USE_MAPPED_LOCATION
9796 source_location location; /* for EH checking */
9797 #else
9798 int location; /* for EH checking */
9799 #endif
9800
9801 /* 15.10.1 Field Access Using a Primary */
9802 switch (TREE_CODE (qual_wfl))
9803 {
9804 case CALL_EXPR:
9805 case NEW_CLASS_EXPR:
9806 /* If the access to the function call is a non static field,
9807 build the code to access it. */
9808 if (JDECL_P (decl) && !FIELD_STATIC (decl))
9809 {
9810 decl = maybe_access_field (decl, *where_found,
9811 DECL_CONTEXT (decl));
9812 if (decl == error_mark_node)
9813 return 1;
9814 }
9815
9816 /* And code for the function call */
9817 if (complete_function_arguments (qual_wfl))
9818 return 1;
9819
9820 /* We might have to setup a new current class and a new this
9821 for the search of an inner class, relative to the type of
9822 a expression resolved as `decl'. The current values are
9823 saved and restored shortly after */
9824 saved_current = current_class;
9825 saved_this = current_this;
9826 if (decl
9827 && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9828 || from_qualified_this))
9829 {
9830 /* If we still have `from_qualified_this', we have the form
9831 <T>.this.f() and we need to build <T>.this */
9832 if (from_qualified_this)
9833 {
9834 decl = build_access_to_thisn (current_class, type, 0);
9835 decl = java_complete_tree (decl);
9836 type = TREE_TYPE (TREE_TYPE (decl));
9837 }
9838 current_class = type;
9839 current_this = decl;
9840 from_qualified_this = 0;
9841 }
9842
9843 if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9844 CALL_USING_SUPER (qual_wfl) = 1;
9845 #ifdef USE_MAPPED_LOCATION
9846 location = (TREE_CODE (qual_wfl) == CALL_EXPR
9847 ? EXPR_LOCATION (TREE_OPERAND (qual_wfl, 0))
9848 : UNKNOWN_LOCATION);
9849 #else
9850 location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9851 EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9852 #endif
9853 *where_found = patch_method_invocation (qual_wfl, decl, type,
9854 from_super,
9855 &is_static, &ret_decl);
9856 from_super = 0;
9857 if (*where_found == error_mark_node)
9858 {
9859 RESTORE_THIS_AND_CURRENT_CLASS;
9860 return 1;
9861 }
9862 *type_found = type = QUAL_DECL_TYPE (*where_found);
9863
9864 *where_found = force_evaluation_order (*where_found);
9865
9866 /* If we're creating an inner class instance, check for that
9867 an enclosing instance is in scope */
9868 if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9869 && INNER_ENCLOSING_SCOPE_CHECK (type))
9870 {
9871 parse_error_context
9872 (qual_wfl, "No enclosing instance for inner class %qs is in scope%s",
9873 lang_printable_name (type, 0),
9874 (!current_this ? "" :
9875 "; an explicit one must be provided when creating this inner class"));
9876 RESTORE_THIS_AND_CURRENT_CLASS;
9877 return 1;
9878 }
9879
9880 /* In case we had to change then to resolve a inner class
9881 instantiation using a primary qualified by a `new' */
9882 RESTORE_THIS_AND_CURRENT_CLASS;
9883
9884 #ifdef USE_MAPPED_LOCATION
9885 if (location != UNKNOWN_LOCATION)
9886 #else
9887 if (location)
9888 #endif
9889 {
9890 tree arguments = NULL_TREE;
9891 if (TREE_CODE (qual_wfl) == CALL_EXPR
9892 && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9893 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9894 check_thrown_exceptions (location, ret_decl, arguments);
9895 }
9896
9897 /* If the previous call was static and this one is too,
9898 build a compound expression to hold the two (because in
9899 that case, previous function calls aren't transported as
9900 forcoming function's argument. */
9901 if (previous_call_static && is_static)
9902 {
9903 /* We must set CAN_COMPLETE_NORMALLY for the first call
9904 since it is done nowhere else. */
9905 CAN_COMPLETE_NORMALLY (decl) = 1;
9906 decl = build2 (COMPOUND_EXPR, TREE_TYPE (*where_found),
9907 decl, *where_found);
9908 TREE_SIDE_EFFECTS (decl) = 1;
9909 }
9910 else
9911 {
9912 previous_call_static = is_static;
9913 decl = *where_found;
9914 }
9915 from_type = 0;
9916 continue;
9917
9918 case NEW_ARRAY_EXPR:
9919 case NEW_ANONYMOUS_ARRAY_EXPR:
9920 *where_found = decl = java_complete_tree (qual_wfl);
9921 if (decl == error_mark_node)
9922 return 1;
9923 *type_found = type = QUAL_DECL_TYPE (decl);
9924 continue;
9925
9926 case CONVERT_EXPR:
9927 *where_found = decl = java_complete_tree (qual_wfl);
9928 if (decl == error_mark_node)
9929 return 1;
9930 *type_found = type = QUAL_DECL_TYPE (decl);
9931 from_cast = 1;
9932 continue;
9933
9934 case CONDITIONAL_EXPR:
9935 case STRING_CST:
9936 case MODIFY_EXPR:
9937 *where_found = decl = java_complete_tree (qual_wfl);
9938 if (decl == error_mark_node)
9939 return 1;
9940 *type_found = type = QUAL_DECL_TYPE (decl);
9941 continue;
9942
9943 case ARRAY_REF:
9944 /* If the access to the function call is a non static field,
9945 build the code to access it. */
9946 if (JDECL_P (decl) && !FIELD_STATIC (decl))
9947 {
9948 decl = maybe_access_field (decl, *where_found, type);
9949 if (decl == error_mark_node)
9950 return 1;
9951 }
9952 /* And code for the array reference expression */
9953 decl = java_complete_tree (qual_wfl);
9954 if (decl == error_mark_node)
9955 return 1;
9956 type = QUAL_DECL_TYPE (decl);
9957 continue;
9958
9959 case PLUS_EXPR:
9960 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9961 return 1;
9962 if ((type = patch_string (decl)))
9963 decl = type;
9964 *where_found = QUAL_RESOLUTION (q) = decl;
9965 *type_found = type = TREE_TYPE (decl);
9966 break;
9967
9968 case CLASS_LITERAL:
9969 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9970 return 1;
9971 *where_found = QUAL_RESOLUTION (q) = decl;
9972 *type_found = type = TREE_TYPE (decl);
9973 break;
9974
9975 default:
9976 /* Fix for -Wall Just go to the next statement. Don't
9977 continue */
9978 break;
9979 }
9980
9981 /* If we fall here, we weren't processing a (static) function call. */
9982 previous_call_static = 0;
9983
9984 /* It can be the keyword THIS */
9985 if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9986 && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9987 {
9988 if (!current_this)
9989 {
9990 parse_error_context
9991 (wfl, "Keyword %<this%> used outside allowed context");
9992 return 1;
9993 }
9994 if (ctxp->explicit_constructor_p
9995 && type == current_class)
9996 {
9997 parse_error_context (wfl, "Can't reference %<this%> before the superclass constructor has been called");
9998 return 1;
9999 }
10000 /* We have to generate code for intermediate access */
10001 if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
10002 {
10003 *where_found = decl = current_this;
10004 *type_found = type = QUAL_DECL_TYPE (decl);
10005 }
10006 /* We're trying to access the this from somewhere else. Make sure
10007 it's allowed before doing so. */
10008 else
10009 {
10010 if (!enclosing_context_p (type, current_class))
10011 {
10012 char *p = xstrdup (lang_printable_name (type, 0));
10013 parse_error_context (qual_wfl, "Can't use variable %<%s.this%>: type %qs isn't an outer type of type %qs",
10014 p, p,
10015 lang_printable_name (current_class, 0));
10016 free (p);
10017 return 1;
10018 }
10019 from_qualified_this = 1;
10020 /* If there's nothing else after that, we need to
10021 produce something now, otherwise, the section of the
10022 code that needs to produce <T>.this will generate
10023 what is necessary. */
10024 if (!TREE_CHAIN (q))
10025 {
10026 decl = build_access_to_thisn (current_class, type, 0);
10027 *where_found = decl = java_complete_tree (decl);
10028 *type_found = type = TREE_TYPE (decl);
10029 }
10030 }
10031
10032 from_type = 0;
10033 continue;
10034 }
10035
10036 /* 15.10.2 Accessing Superclass Members using SUPER */
10037 if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
10038 && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
10039 {
10040 tree node;
10041 /* Check on the restricted use of SUPER */
10042 if (METHOD_STATIC (current_function_decl)
10043 || current_class == object_type_node)
10044 {
10045 parse_error_context
10046 (wfl, "Keyword %<super%> used outside allowed context");
10047 return 1;
10048 }
10049 /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
10050 node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
10051 CLASSTYPE_SUPER (current_class),
10052 build_this (EXPR_WFL_LINECOL (qual_wfl)));
10053 *where_found = decl = java_complete_tree (node);
10054 if (decl == error_mark_node)
10055 return 1;
10056 *type_found = type = QUAL_DECL_TYPE (decl);
10057 from_super = from_type = 1;
10058 continue;
10059 }
10060
10061 /* 15.13.1: Can't search for field name in packages, so we
10062 assume a variable/class name was meant. */
10063 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
10064 {
10065 tree name;
10066 if ((decl = resolve_package (wfl, &q, &name)))
10067 {
10068 tree list;
10069 *where_found = decl;
10070
10071 check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
10072
10073 /* We want to be absolutely sure that the class is laid
10074 out. We're going to search something inside it. */
10075 *type_found = type = TREE_TYPE (decl);
10076 layout_class (type);
10077 from_type = 1;
10078
10079 /* Fix them all the way down, if any are left. */
10080 if (q)
10081 {
10082 list = TREE_CHAIN (q);
10083 while (list)
10084 {
10085 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
10086 list = TREE_CHAIN (list);
10087 }
10088 }
10089 }
10090 else
10091 {
10092 if (from_super || from_cast)
10093 parse_error_context
10094 ((from_cast ? qual_wfl : wfl),
10095 "No variable %qs defined in class %qs",
10096 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
10097 lang_printable_name (type, 0));
10098 else
10099 parse_error_context
10100 (qual_wfl, "Undefined variable or class name: %qs",
10101 IDENTIFIER_POINTER (name));
10102 return 1;
10103 }
10104 }
10105
10106 /* We have a type name. It's been already resolved when the
10107 expression was qualified. */
10108 else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
10109 {
10110 decl = QUAL_RESOLUTION (q);
10111
10112 /* Sneak preview. If next we see a `new', we're facing a
10113 qualification which resulted in a type being selected
10114 instead of a field. Report the error. */
10115 if(TREE_CHAIN (q)
10116 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
10117 {
10118 parse_error_context (qual_wfl, "Undefined variable %qs",
10119 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10120 return 1;
10121 }
10122
10123 check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
10124
10125 check_deprecation (qual_wfl, decl);
10126
10127 type = TREE_TYPE (decl);
10128 from_type = 1;
10129 }
10130 /* We resolve an expression name */
10131 else
10132 {
10133 tree field_decl = NULL_TREE;
10134
10135 /* If there exists an early resolution, use it. That occurs
10136 only once and we know that there are more things to
10137 come. Don't do that when processing something after SUPER
10138 (we need more thing to be put in place below */
10139 if (!from_super && QUAL_RESOLUTION (q))
10140 {
10141 decl = QUAL_RESOLUTION (q);
10142 if (!type)
10143 {
10144 if (TREE_CODE (decl) == FIELD_DECL
10145 || TREE_CODE (decl) == VAR_DECL)
10146 {
10147 if (TREE_CODE (decl) == FIELD_DECL
10148 && !FIELD_STATIC (decl))
10149 {
10150 if (current_this)
10151 *where_found = current_this;
10152 else
10153 {
10154 static_ref_err (qual_wfl, DECL_NAME (decl),
10155 current_class);
10156 return 1;
10157 }
10158 }
10159 else
10160 {
10161 *where_found = TREE_TYPE (decl);
10162 if (TREE_CODE (*where_found) == POINTER_TYPE)
10163 *where_found = TREE_TYPE (*where_found);
10164 }
10165 if (nested_member_access_p (current_class, decl))
10166 decl = build_nested_field_access (qual_wfl, decl);
10167 }
10168 else
10169 {
10170 *where_found = TREE_TYPE (decl);
10171 if (TREE_CODE (*where_found) == POINTER_TYPE)
10172 *where_found = TREE_TYPE (*where_found);
10173 }
10174 }
10175 }
10176
10177 /* Report and error if we're using a numerical literal as a
10178 qualifier. It can only be an INTEGER_CST. */
10179 else if (TREE_CODE (qual_wfl) == INTEGER_CST)
10180 {
10181 parse_error_context
10182 (wfl, "Can't use type %qs as a qualifier",
10183 lang_printable_name (TREE_TYPE (qual_wfl), 0));
10184 return 1;
10185 }
10186
10187 /* We have to search for a field, knowing the type of its
10188 container. The flag FROM_TYPE indicates that we resolved
10189 the last member of the expression as a type name, which
10190 means that for the resolution of this field, we'll look
10191 for other errors than if it was resolved as a member of
10192 an other field. */
10193 else
10194 {
10195 int is_static;
10196 tree field_decl_type; /* For layout */
10197
10198 if (!from_type && !JREFERENCE_TYPE_P (type))
10199 {
10200 parse_error_context
10201 (qual_wfl, "Attempt to reference field %qs in %<%s %s%>",
10202 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
10203 lang_printable_name (type, 0),
10204 IDENTIFIER_POINTER (DECL_NAME (decl)));
10205 return 1;
10206 }
10207
10208 field_decl = lookup_field_wrapper (type,
10209 EXPR_WFL_NODE (qual_wfl));
10210
10211 /* Maybe what we're trying to access to is an inner
10212 class, only if decl is a TYPE_DECL. */
10213 if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
10214 {
10215 tree ptr, inner_decl;
10216
10217 BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
10218 inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
10219 if (inner_decl)
10220 {
10221 check_inner_class_access (inner_decl, decl, qual_wfl);
10222 type = TREE_TYPE (inner_decl);
10223 decl = inner_decl;
10224 from_type = 1;
10225 continue;
10226 }
10227 }
10228
10229 if (field_decl == NULL_TREE)
10230 {
10231 parse_error_context
10232 (qual_wfl, "No variable %qs defined in type %qs",
10233 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
10234 GET_TYPE_NAME (type));
10235 return 1;
10236 }
10237 if (field_decl == error_mark_node)
10238 return 1;
10239
10240 /* Layout the type of field_decl, since we may need
10241 it. Don't do primitive types or loaded classes. The
10242 situation of non primitive arrays may not handled
10243 properly here. FIXME */
10244 if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
10245 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
10246 else
10247 field_decl_type = TREE_TYPE (field_decl);
10248 if (!JPRIMITIVE_TYPE_P (field_decl_type)
10249 && !CLASS_LOADED_P (field_decl_type)
10250 && !TYPE_ARRAY_P (field_decl_type))
10251 resolve_and_layout (field_decl_type, NULL_TREE);
10252
10253 /* Check on accessibility here */
10254 if (not_accessible_p (current_class, field_decl,
10255 *type_found, from_super))
10256 return not_accessible_field_error (qual_wfl,field_decl);
10257 check_deprecation (qual_wfl, field_decl);
10258
10259 /* There are things to check when fields are accessed
10260 from type. There are no restrictions on a static
10261 declaration of the field when it is accessed from an
10262 interface */
10263 is_static = FIELD_STATIC (field_decl);
10264 if (!from_super && from_type
10265 && !TYPE_INTERFACE_P (type)
10266 && !is_static
10267 && (current_function_decl
10268 && METHOD_STATIC (current_function_decl)))
10269 {
10270 static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
10271 return 1;
10272 }
10273 from_cast = from_super = 0;
10274
10275 /* If it's an access from a type but isn't static, we
10276 make it relative to `this'. */
10277 if (!is_static && from_type)
10278 decl = current_this;
10279
10280 /* If we need to generate something to get a proper
10281 handle on what this field is accessed from, do it
10282 now. */
10283 if (!is_static)
10284 {
10285 decl = maybe_access_field (decl, *where_found, *type_found);
10286 if (decl == error_mark_node)
10287 return 1;
10288 }
10289
10290 /* We want to keep the location where we found it, and the
10291 type we found. */
10292 *where_found = decl;
10293 *type_found = type;
10294
10295 /* Generate the correct expression for field access from
10296 qualified this */
10297 if (from_qualified_this)
10298 {
10299 field_decl
10300 = build_nested_field_access (qual_wfl, field_decl);
10301 from_qualified_this = 0;
10302 }
10303
10304 /* If needed, generate accessors for static field access. */
10305 if (is_static
10306 && FIELD_PRIVATE (field_decl)
10307 && flag_emit_class_files
10308 && nested_member_access_p (current_class, field_decl))
10309 field_decl = build_nested_field_access (qual_wfl, field_decl);
10310
10311 /* This is the decl found and eventually the next one to
10312 search from */
10313 decl = field_decl;
10314 }
10315 from_type = 0;
10316 type = QUAL_DECL_TYPE (decl);
10317
10318 /* Sneak preview. If decl is qualified by a `new', report
10319 the error here to be accurate on the peculiar construct */
10320 if (TREE_CHAIN (q)
10321 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10322 && !JREFERENCE_TYPE_P (type))
10323 {
10324 parse_error_context (qual_wfl, "Attempt to reference field %<new%> in a %qs",
10325 lang_printable_name (type, 0));
10326 return 1;
10327 }
10328 }
10329 /* `q' might have changed due to a after package resolution
10330 re-qualification */
10331 if (!q)
10332 break;
10333 }
10334 *found_decl = decl;
10335 return 0;
10336 }
10337
10338 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10339 can't be accessed from REFERENCE (a record type). If MEMBER
10340 features a protected access, we then use WHERE which, if non null,
10341 holds the type of MEMBER's access that is checked against
10342 6.6.2.1. This function should be used when decl is a field or a
10343 method. */
10344
10345 static int
10346 not_accessible_p (tree reference, tree member, tree where, int from_super)
10347 {
10348 int access_flag = get_access_flags_from_decl (member);
10349 bool is_static = false;
10350
10351 if (TREE_CODE (member) == FIELD_DECL ||
10352 TREE_CODE (member) == VAR_DECL)
10353 is_static = FIELD_STATIC (member);
10354 else
10355 is_static = METHOD_STATIC (member);
10356
10357 /* Access always granted for members declared public */
10358 if (access_flag & ACC_PUBLIC)
10359 return 0;
10360
10361 /* Check access on protected members */
10362 if (access_flag & ACC_PROTECTED)
10363 {
10364 /* Access granted if it occurs from within the package
10365 containing the class in which the protected member is
10366 declared */
10367 if (class_in_current_package (DECL_CONTEXT (member)))
10368 return 0;
10369
10370 /* If accessed with the form `super.member', then access is granted */
10371 if (from_super)
10372 return 0;
10373
10374 /* If WHERE is active, access was made through a qualifier. For
10375 non-static members, access is granted if the type of the qualifier
10376 is or is a sublass of the type the access is made from (6.6.2.1.) */
10377 if (where && !is_static)
10378 {
10379 while (reference)
10380 {
10381 if (inherits_from_p (where, reference))
10382 return 0;
10383 if (INNER_CLASS_TYPE_P (reference))
10384 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10385 else
10386 break;
10387 }
10388 return 1;
10389 }
10390
10391 /* Otherwise, access is granted if occurring from within the class
10392 where member is declared, or a subclass of it. */
10393 while (reference)
10394 {
10395 if (inherits_from_p (reference, DECL_CONTEXT (member)))
10396 return 0;
10397 if (INNER_CLASS_TYPE_P (reference))
10398 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10399 else
10400 break;
10401 }
10402 return 1;
10403 }
10404
10405 /* Check access on private members. Access is granted only if it
10406 occurs from within the class in which it is declared -- that does
10407 it for innerclasses too. */
10408 if (access_flag & ACC_PRIVATE)
10409 {
10410 if (reference == DECL_CONTEXT (member) ||
10411 common_enclosing_context_p (DECL_CONTEXT (member), reference))
10412 return 0;
10413 return 1;
10414 }
10415
10416 /* Default access is permitted only when occurring from within the
10417 package in which the context (MEMBER) is declared. */
10418 return !class_in_current_package (DECL_CONTEXT (member));
10419 }
10420
10421 /* Test deprecated decl access. */
10422 static void
10423 check_deprecation (tree wfl, tree decl)
10424 {
10425 const char *file;
10426 tree elt;
10427
10428 if (! warn_deprecated)
10429 return;
10430
10431 /* We want to look at the element type of arrays here, so we strip
10432 all surrounding array types. */
10433 if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10434 {
10435 elt = TREE_TYPE (decl);
10436 while (TYPE_ARRAY_P (elt))
10437 elt = TYPE_ARRAY_ELEMENT (elt);
10438 /* We'll end up with a pointer type, so we use TREE_TYPE to go
10439 to the record. */
10440 decl = TYPE_NAME (TREE_TYPE (elt));
10441 }
10442 file = DECL_SOURCE_FILE (decl);
10443
10444 /* Complain if the field is deprecated and the file it was defined
10445 in isn't compiled at the same time the file which contains its
10446 use is */
10447 if (DECL_DEPRECATED (decl)
10448 && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10449 {
10450 const char *the;
10451 switch (TREE_CODE (decl))
10452 {
10453 case FUNCTION_DECL:
10454 the = "method";
10455 break;
10456 case FIELD_DECL:
10457 case VAR_DECL:
10458 the = "field";
10459 break;
10460 case TYPE_DECL:
10461 parse_warning_context (wfl, "The class %qs has been deprecated",
10462 IDENTIFIER_POINTER (DECL_NAME (decl)));
10463 return;
10464 default:
10465 abort ();
10466 }
10467 /* Don't issue a message if the context as been deprecated as a
10468 whole. */
10469 if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10470 parse_warning_context
10471 (wfl, "The %s %qs in class %qs has been deprecated",
10472 the, lang_printable_name (decl, 0),
10473 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10474 }
10475 }
10476
10477 /* Returns 1 if class was declared in the current package, 0 otherwise */
10478
10479 static int
10480 class_in_current_package (tree class)
10481 {
10482 if (TYPE_PACKAGE (current_class) == TYPE_PACKAGE (class))
10483 return 1;
10484 return 0;
10485 }
10486
10487 /* This function may generate code to access DECL from WHERE. This is
10488 done only if certain conditions meet. */
10489
10490 static tree
10491 maybe_access_field (tree decl, tree where, tree type)
10492 {
10493 if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10494 && !FIELD_STATIC (decl))
10495 decl = build_field_ref (where ? where : current_this,
10496 (type ? type : DECL_CONTEXT (decl)),
10497 DECL_NAME (decl));
10498 return decl;
10499 }
10500
10501 /* Build a method invocation, by patching PATCH. If non NULL
10502 and according to the situation, PRIMARY and WHERE may be
10503 used. IS_STATIC is set to 1 if the invoked function is static. */
10504
10505 static tree
10506 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10507 int *is_static, tree *ret_decl)
10508 {
10509 tree wfl = TREE_OPERAND (patch, 0);
10510 tree args = TREE_OPERAND (patch, 1);
10511 tree name = EXPR_WFL_NODE (wfl);
10512 tree list;
10513 int is_static_flag = 0;
10514 int is_super_init = 0;
10515 tree this_arg = NULL_TREE;
10516 int is_array_clone_call = 0;
10517
10518 /* Should be overridden if everything goes well. Otherwise, if
10519 something fails, it should keep this value. It stop the
10520 evaluation of a bogus assignment. See java_complete_tree,
10521 MODIFY_EXPR: for the reasons why we sometimes want to keep on
10522 evaluating an assignment */
10523 TREE_TYPE (patch) = error_mark_node;
10524
10525 /* Since lookup functions are messing with line numbers, save the
10526 context now. */
10527 java_parser_context_save_global ();
10528
10529 /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10530
10531 /* Resolution of qualified name, excluding constructors */
10532 if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10533 {
10534 tree identifier, identifier_wfl, type, resolved;
10535 /* Extract the last IDENTIFIER of the qualified
10536 expression. This is a wfl and we will use it's location
10537 data during error report. */
10538 identifier_wfl = cut_identifier_in_qualified (wfl);
10539 identifier = EXPR_WFL_NODE (identifier_wfl);
10540
10541 /* Given the context, IDENTIFIER is syntactically qualified
10542 as a MethodName. We need to qualify what's before */
10543 qualify_ambiguous_name (wfl);
10544 resolved = resolve_field_access (wfl, NULL, NULL);
10545
10546 if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10547 && FIELD_FINAL (resolved)
10548 && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10549 && !flag_emit_class_files)
10550 resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10551
10552 if (resolved == error_mark_node)
10553 PATCH_METHOD_RETURN_ERROR ();
10554
10555 type = GET_SKIP_TYPE (resolved);
10556 resolve_and_layout (type, NULL_TREE);
10557
10558 if (JPRIMITIVE_TYPE_P (type))
10559 {
10560 parse_error_context
10561 (identifier_wfl,
10562 "Can't invoke a method on primitive type %qs",
10563 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10564 PATCH_METHOD_RETURN_ERROR ();
10565 }
10566
10567 list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10568 args = nreverse (args);
10569
10570 /* We're resolving a call from a type */
10571 if (TREE_CODE (resolved) == TYPE_DECL)
10572 {
10573 if (CLASS_INTERFACE (resolved))
10574 {
10575 parse_error_context
10576 (identifier_wfl,
10577 "Can't make static reference to method %qs in interface %qs",
10578 IDENTIFIER_POINTER (identifier),
10579 IDENTIFIER_POINTER (name));
10580 PATCH_METHOD_RETURN_ERROR ();
10581 }
10582 if (list)
10583 {
10584 if (METHOD_STATIC (list))
10585 maybe_use_access_method (0, &list, NULL);
10586 else
10587 {
10588 char *fct_name = xstrdup (lang_printable_name (list, 2));
10589 parse_error_context
10590 (identifier_wfl,
10591 "Can't make static reference to method %<%s %s%> in class %qs",
10592 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10593 fct_name,
10594 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10595 free (fct_name);
10596 PATCH_METHOD_RETURN_ERROR ();
10597 }
10598 }
10599 }
10600 else
10601 this_arg = primary = resolved;
10602
10603 if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10604 is_array_clone_call = 1;
10605
10606 /* IDENTIFIER_WFL will be used to report any problem further */
10607 wfl = identifier_wfl;
10608 }
10609 /* Resolution of simple names, names generated after a primary: or
10610 constructors */
10611 else
10612 {
10613 tree class_to_search = NULL_TREE;
10614 int lc; /* Looking for Constructor */
10615
10616 /* We search constructor in their target class */
10617 if (CALL_CONSTRUCTOR_P (patch))
10618 {
10619 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10620 class_to_search = EXPR_WFL_NODE (wfl);
10621 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10622 this_identifier_node)
10623 class_to_search = NULL_TREE;
10624 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10625 super_identifier_node)
10626 {
10627 is_super_init = 1;
10628 if (CLASSTYPE_SUPER (current_class))
10629 class_to_search =
10630 DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10631 else
10632 {
10633 parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10634 PATCH_METHOD_RETURN_ERROR ();
10635 }
10636 }
10637
10638 /* Class to search is NULL if we're searching the current one */
10639 if (class_to_search)
10640 {
10641 class_to_search = resolve_and_layout (class_to_search, wfl);
10642
10643 if (!class_to_search)
10644 {
10645 parse_error_context
10646 (wfl, "Class %qs not found in type declaration",
10647 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10648 PATCH_METHOD_RETURN_ERROR ();
10649 }
10650
10651 /* Can't instantiate an abstract class, but we can
10652 invoke it's constructor. It's use within the `new'
10653 context is denied here. */
10654 if (CLASS_ABSTRACT (class_to_search)
10655 && TREE_CODE (patch) == NEW_CLASS_EXPR)
10656 {
10657 parse_error_context
10658 (wfl, "Class %qs is an abstract class. It can't be instantiated",
10659 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10660 PATCH_METHOD_RETURN_ERROR ();
10661 }
10662
10663 class_to_search = TREE_TYPE (class_to_search);
10664 }
10665 else
10666 class_to_search = current_class;
10667 lc = 1;
10668 }
10669 /* This is a regular search in the local class, unless an
10670 alternate class is specified. */
10671 else
10672 {
10673 if (where != NULL_TREE)
10674 class_to_search = where;
10675 else if (QUALIFIED_P (name))
10676 class_to_search = current_class;
10677 else
10678 {
10679 class_to_search = current_class;
10680
10681 for (;;)
10682 {
10683 if (has_method (class_to_search, name))
10684 break;
10685 if (! INNER_CLASS_TYPE_P (class_to_search))
10686 {
10687 parse_error_context (wfl,
10688 "No method named %qs in scope",
10689 IDENTIFIER_POINTER (name));
10690 PATCH_METHOD_RETURN_ERROR ();
10691 }
10692 class_to_search
10693 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10694 }
10695 }
10696 lc = 0;
10697 }
10698
10699 /* NAME is a simple identifier or comes from a primary. Search
10700 in the class whose declaration contain the method being
10701 invoked. */
10702 resolve_and_layout (class_to_search, NULL_TREE);
10703
10704 list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10705 /* Don't continue if no method were found, as the next statement
10706 can't be executed then. */
10707 if (!list)
10708 PATCH_METHOD_RETURN_ERROR ();
10709
10710 if (TYPE_ARRAY_P (class_to_search)
10711 && DECL_NAME (list) == get_identifier ("clone"))
10712 is_array_clone_call = 1;
10713
10714 /* Check for static reference of non static methods. */
10715 if (check_for_static_method_reference (wfl, patch, list,
10716 class_to_search, primary))
10717 PATCH_METHOD_RETURN_ERROR ();
10718
10719 /* Check for inner classes creation from illegal contexts */
10720 if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10721 && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10722 && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10723 && !DECL_INIT_P (current_function_decl))
10724 {
10725 parse_error_context
10726 (wfl, "No enclosing instance for inner class %qs is in scope%s",
10727 lang_printable_name (class_to_search, 0),
10728 (!current_this ? "" :
10729 "; an explicit one must be provided when creating this inner class"));
10730 PATCH_METHOD_RETURN_ERROR ();
10731 }
10732
10733 /* Non static methods are called with the current object extra
10734 argument. If PATCH is a `new TYPE()', the argument is the value
10735 returned by the object allocator. If method is resolved as a
10736 primary, use the primary otherwise use the current THIS. */
10737 args = nreverse (args);
10738 if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10739 {
10740 this_arg = primary ? primary : current_this;
10741
10742 /* If we're using an access method, things are different.
10743 There are two family of cases:
10744
10745 1) We're not generating bytecodes:
10746
10747 - LIST is non-static. Its invocation is transformed from
10748 x(a1,...,an) into this$<n>.x(a1,....an).
10749 - LIST is static. Its invocation is transformed from
10750 x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10751
10752 2) We're generating bytecodes:
10753
10754 - LIST is non-static. Its invocation is transformed from
10755 x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10756 - LIST is static. Its invocation is transformed from
10757 x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10758
10759 Of course, this$<n> can be arbitrarily complex, ranging from
10760 this$0 (the immediate outer context) to
10761 access$0(access$0(...(this$0))).
10762
10763 maybe_use_access_method returns a nonzero value if the
10764 this_arg has to be moved into the (then generated) stub
10765 argument list. In the meantime, the selected function
10766 might have been replaced by a generated stub. */
10767 if (METHOD_STATIC (list))
10768 maybe_use_access_method (0, &list, NULL);
10769 else if (!primary &&
10770 maybe_use_access_method (is_super_init, &list, &this_arg))
10771 {
10772 args = tree_cons (NULL_TREE, this_arg, args);
10773 this_arg = NULL_TREE; /* So it doesn't get chained twice */
10774 }
10775 }
10776 }
10777
10778 /* Merge point of all resolution schemes. If we have nothing, this
10779 is an error, already signaled */
10780 if (!list)
10781 PATCH_METHOD_RETURN_ERROR ();
10782
10783 /* Check accessibility, position the is_static flag, build and
10784 return the call */
10785 if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10786 (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10787 NULL_TREE), from_super)
10788 /* Calls to clone() on array types are permitted as a special-case. */
10789 && !is_array_clone_call)
10790 {
10791 const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10792 const char *const access =
10793 accessibility_string (get_access_flags_from_decl (list));
10794 const char *const klass =
10795 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10796 const char *const refklass =
10797 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10798 const char *const what = (DECL_CONSTRUCTOR_P (list)
10799 ? "constructor" : "method");
10800 parse_error_context (wfl,
10801 "Can't access %s %s %<%s.%s%> from %qs",
10802 access, what, klass, fct_name, refklass);
10803 PATCH_METHOD_RETURN_ERROR ();
10804 }
10805
10806 /* Deprecation check: check whether the method being invoked or the
10807 instance-being-created's type are deprecated. */
10808 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10809 check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10810 check_deprecation (wfl, list);
10811
10812 /* If invoking a innerclass constructor, there are hidden parameters
10813 to pass */
10814 if (TREE_CODE (patch) == NEW_CLASS_EXPR
10815 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10816 {
10817 /* And make sure we add the accessed local variables to be saved
10818 in field aliases. */
10819 args = build_alias_initializer_parameter_list
10820 (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10821
10822 /* Secretly pass the current_this/primary as a second argument */
10823 if (primary || current_this)
10824 {
10825 tree extra_arg;
10826 tree this_type = (current_this ?
10827 TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10828 /* Method's (list) enclosing context */
10829 tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10830 /* If we have a primary, use it. */
10831 if (primary)
10832 extra_arg = primary;
10833 /* The current `this' is an inner class but isn't a direct
10834 enclosing context for the inner class we're trying to
10835 create. Build an access to the proper enclosing context
10836 and use it. */
10837 else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10838 && this_type != TREE_TYPE (mec))
10839 {
10840
10841 extra_arg = build_access_to_thisn (current_class,
10842 TREE_TYPE (mec), 0);
10843 extra_arg = java_complete_tree (extra_arg);
10844 }
10845 /* Otherwise, just use the current `this' as an enclosing
10846 context. */
10847 else
10848 extra_arg = current_this;
10849 args = tree_cons (NULL_TREE, extra_arg, args);
10850 }
10851 else
10852 args = tree_cons (NULL_TREE, integer_zero_node, args);
10853 }
10854
10855 /* This handles the situation where a constructor invocation needs
10856 to have an enclosing context passed as a second parameter (the
10857 constructor is one of an inner class). */
10858 if ((is_super_init ||
10859 (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10860 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10861 {
10862 tree dest = TYPE_NAME (DECL_CONTEXT (list));
10863 tree extra_arg =
10864 build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10865 extra_arg = java_complete_tree (extra_arg);
10866 args = tree_cons (NULL_TREE, extra_arg, args);
10867 }
10868
10869 is_static_flag = METHOD_STATIC (list);
10870 if (! is_static_flag && this_arg != NULL_TREE)
10871 args = tree_cons (NULL_TREE, this_arg, args);
10872
10873 /* In the context of an explicit constructor invocation, we can't
10874 invoke any method relying on `this'. Exceptions are: we're
10875 invoking a static function, primary exists and is not the current
10876 this, we're creating a new object. */
10877 if (ctxp->explicit_constructor_p
10878 && !is_static_flag
10879 && (!primary || primary == current_this)
10880 && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10881 {
10882 parse_error_context (wfl, "Can't reference %<this%> before the superclass constructor has been called");
10883 PATCH_METHOD_RETURN_ERROR ();
10884 }
10885 java_parser_context_restore_global ();
10886 if (is_static)
10887 *is_static = is_static_flag;
10888 /* Sometimes, we want the decl of the selected method. Such as for
10889 EH checking */
10890 if (ret_decl)
10891 *ret_decl = list;
10892 patch = patch_invoke (patch, list, args);
10893
10894 /* Now is a good time to insert the call to finit$ */
10895 if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10896 {
10897 tree finit_parms, finit_call;
10898
10899 /* Prepare to pass hidden parameters to finit$, if any. */
10900 finit_parms = build_alias_initializer_parameter_list
10901 (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10902
10903 finit_call =
10904 build_method_invocation (build_wfl_node (finit_identifier_node),
10905 finit_parms);
10906
10907 /* Generate the code used to initialize fields declared with an
10908 initialization statement and build a compound statement along
10909 with the super constructor invocation. */
10910 CAN_COMPLETE_NORMALLY (patch) = 1;
10911 patch = build2 (COMPOUND_EXPR, void_type_node, patch,
10912 java_complete_tree (finit_call));
10913 }
10914 return patch;
10915 }
10916
10917 /* Check that we're not trying to do a static reference to a method in
10918 non static method. Return 1 if it's the case, 0 otherwise. */
10919
10920 static int
10921 check_for_static_method_reference (tree wfl, tree node, tree method,
10922 tree where, tree primary)
10923 {
10924 if (METHOD_STATIC (current_function_decl)
10925 && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10926 {
10927 char *fct_name = xstrdup (lang_printable_name (method, 0));
10928 parse_error_context
10929 (wfl, "Can't make static reference to method %<%s %s%> in class %qs",
10930 lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10931 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10932 free (fct_name);
10933 return 1;
10934 }
10935 return 0;
10936 }
10937
10938 /* Fix the invocation of *MDECL if necessary in the case of an
10939 invocation across a nested class. *THIS_ARG might be modified
10940 appropriately and an alternative access to *MDECL might be
10941 returned. */
10942
10943 static int
10944 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10945 {
10946 tree ctx;
10947 tree md = *mdecl, ta = NULL_TREE;
10948 int to_return = 0;
10949 int non_static_context = !METHOD_STATIC (md);
10950
10951 if (is_super_init
10952 || DECL_FINIT_P (md)
10953 || DECL_INSTINIT_P (md)
10954 || !nested_member_access_p (current_class, md))
10955 return 0;
10956
10957 /* If we're calling a method found in an enclosing class, generate
10958 what it takes to retrieve the right `this'. Don't do that if we're
10959 invoking a static method. Note that if MD's type is unrelated to
10960 CURRENT_CLASS, then the current this can be used. */
10961
10962 if (non_static_context
10963 && !inherits_from_p (current_class, DECL_CONTEXT (md))
10964 && DECL_CONTEXT (TYPE_NAME (current_class)))
10965 {
10966 ta = *this_arg;
10967 ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10968 if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10969 {
10970 ta = build_current_thisn (current_class);
10971 ta = build_wfl_node (ta);
10972 }
10973 else
10974 {
10975 tree type = ctx;
10976 while (type)
10977 {
10978 maybe_build_thisn_access_method (type);
10979 if (inherits_from_p (type, DECL_CONTEXT (md)))
10980 {
10981 ta = build_access_to_thisn (ctx, type, 0);
10982 break;
10983 }
10984 type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10985 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10986 }
10987 }
10988 ta = java_complete_tree (ta);
10989 }
10990
10991 /* We might have to use an access method to get to MD. We can
10992 break the method access rule as long as we're not generating
10993 bytecode. */
10994 if (METHOD_PRIVATE (md) && flag_emit_class_files)
10995 {
10996 md = build_nested_method_access_method (md);
10997 to_return = 1;
10998 }
10999
11000 *mdecl = md;
11001 if (this_arg)
11002 *this_arg = ta;
11003
11004 /* Returning a nonzero value indicates we were doing a non static
11005 method invocation that is now a static invocation. It will have
11006 callee displace `this' to insert it in the regular argument
11007 list. */
11008 return (non_static_context && to_return);
11009 }
11010
11011 /* Patch an invoke expression METHOD and ARGS, based on its invocation
11012 mode. */
11013
11014 static tree
11015 patch_invoke (tree patch, tree method, tree args)
11016 {
11017 tree dtable, func;
11018 tree original_call, t, ta;
11019 tree check = NULL_TREE;
11020
11021 /* Last step for args: convert build-in types. If we're dealing with
11022 a new TYPE() type call, the first argument to the constructor
11023 isn't found in the incoming argument list, but delivered by
11024 `new' */
11025 t = TYPE_ARG_TYPES (TREE_TYPE (method));
11026 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
11027 t = TREE_CHAIN (t);
11028 for (ta = args; t != end_params_node && ta;
11029 t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
11030 if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
11031 TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
11032 TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
11033
11034 /* Resolve unresolved returned type issues */
11035 t = TREE_TYPE (TREE_TYPE (method));
11036 if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
11037 resolve_and_layout (TREE_TYPE (t), NULL);
11038
11039 if (flag_emit_class_files)
11040 func = method;
11041 else
11042 {
11043 switch (invocation_mode (method, CALL_USING_SUPER (patch)))
11044 {
11045 case INVOKE_VIRTUAL:
11046 {
11047 tree signature = build_java_signature (TREE_TYPE (method));
11048 tree special;
11049 maybe_rewrite_invocation (&method, &args, &signature, &special);
11050
11051 dtable = invoke_build_dtable (0, args);
11052 func = build_invokevirtual (dtable, method, special);
11053 }
11054 break;
11055
11056 case INVOKE_NONVIRTUAL:
11057 /* If the object for the method call is null, we throw an
11058 exception. We don't do this if the object is the current
11059 method's `this'. In other cases we just rely on an
11060 optimization pass to eliminate redundant checks. */
11061 if (TREE_VALUE (args) != current_this)
11062 {
11063 /* We use a save_expr here to make sure we only evaluate
11064 the new `self' expression once. */
11065 tree save_arg = save_expr (TREE_VALUE (args));
11066 TREE_VALUE (args) = save_arg;
11067 check = java_check_reference (save_arg, 1);
11068 }
11069 /* Fall through. */
11070
11071 case INVOKE_SUPER:
11072 case INVOKE_STATIC:
11073 {
11074 tree signature = build_java_signature (TREE_TYPE (method));
11075 tree special;
11076 maybe_rewrite_invocation (&method, &args, &signature, &special);
11077 func = build_known_method_ref (method, TREE_TYPE (method),
11078 DECL_CONTEXT (method),
11079 signature, args, special);
11080 }
11081 break;
11082
11083 case INVOKE_INTERFACE:
11084 dtable = invoke_build_dtable (1, args);
11085 func = build_invokeinterface (dtable, method);
11086 break;
11087
11088 default:
11089 abort ();
11090 }
11091
11092 /* Ensure self_type is initialized, (invokestatic). FIXME */
11093 func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
11094 }
11095
11096 TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
11097 TREE_OPERAND (patch, 0) = func;
11098 TREE_OPERAND (patch, 1) = args;
11099 patch = check_for_builtin (method, patch);
11100 original_call = patch;
11101
11102 /* We're processing a `new TYPE ()' form. New is called and its
11103 returned value is the first argument to the constructor. We build
11104 a COMPOUND_EXPR and use saved expression so that the overall NEW
11105 expression value is a pointer to a newly created and initialized
11106 class. */
11107 if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
11108 {
11109 tree class = DECL_CONTEXT (method);
11110 tree c1, saved_new, new;
11111 tree alloc_node;
11112
11113 if (flag_emit_class_files)
11114 {
11115 TREE_TYPE (patch) = build_pointer_type (class);
11116 return patch;
11117 }
11118 if (!TYPE_SIZE (class))
11119 safe_layout_class (class);
11120 alloc_node =
11121 (class_has_finalize_method (class) ? alloc_object_node
11122 : alloc_no_finalizer_node);
11123 new = build3 (CALL_EXPR, promote_type (class),
11124 build_address_of (alloc_node),
11125 build_tree_list (NULL_TREE, build_class_ref (class)),
11126 NULL_TREE);
11127 saved_new = save_expr (new);
11128 c1 = build_tree_list (NULL_TREE, saved_new);
11129 TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
11130 TREE_OPERAND (original_call, 1) = c1;
11131 TREE_SET_CODE (original_call, CALL_EXPR);
11132 patch = build2 (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
11133 }
11134
11135 /* If CHECK is set, then we are building a check to see if the object
11136 is NULL. */
11137 if (check != NULL_TREE)
11138 {
11139 /* We have to call force_evaluation_order now because creating a
11140 COMPOUND_EXPR wraps the arg list in a way that makes it
11141 unrecognizable by force_evaluation_order later. Yuk. */
11142 patch = build2 (COMPOUND_EXPR, TREE_TYPE (patch), check,
11143 force_evaluation_order (patch));
11144 TREE_SIDE_EFFECTS (patch) = 1;
11145 }
11146
11147 /* In order to be able to modify PATCH later, we SAVE_EXPR it and
11148 put it as the first expression of a COMPOUND_EXPR. The second
11149 expression being an empty statement to be later patched if
11150 necessary. We remember a TREE_LIST (the PURPOSE is the method,
11151 the VALUE is the compound) in a hashtable and return a
11152 COMPOUND_EXPR built so that the result of the evaluation of the
11153 original PATCH node is returned. */
11154 if (STATIC_CLASS_INIT_OPT_P ()
11155 && current_function_decl && METHOD_STATIC (method))
11156 {
11157 tree list;
11158 tree fndecl = current_function_decl;
11159 /* We have to call force_evaluation_order now because creating a
11160 COMPOUND_EXPR wraps the arg list in a way that makes it
11161 unrecognizable by force_evaluation_order later. Yuk. */
11162 tree save = force_evaluation_order (patch);
11163 tree type = TREE_TYPE (patch);
11164
11165 patch = build2 (COMPOUND_EXPR, type, save, build_java_empty_stmt ());
11166 list = tree_cons (method, patch,
11167 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
11168
11169 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
11170
11171 patch = build2 (COMPOUND_EXPR, type, patch, save);
11172 }
11173
11174 return patch;
11175 }
11176
11177 static int
11178 invocation_mode (tree method, int super)
11179 {
11180 int access = get_access_flags_from_decl (method);
11181
11182 if (super)
11183 return INVOKE_SUPER;
11184
11185 if (access & ACC_STATIC)
11186 return INVOKE_STATIC;
11187
11188 /* We have to look for a constructor before we handle nonvirtual
11189 calls; otherwise the constructor will look nonvirtual. */
11190 if (DECL_CONSTRUCTOR_P (method))
11191 return INVOKE_STATIC;
11192
11193 if (access & ACC_PRIVATE)
11194 return INVOKE_NONVIRTUAL;
11195
11196 /* Binary compatibility: just because it's final today, that doesn't
11197 mean it'll be final tomorrow. */
11198 if (! flag_indirect_dispatch
11199 || DECL_CONTEXT (method) == object_type_node)
11200 {
11201 if (access & ACC_FINAL)
11202 return INVOKE_NONVIRTUAL;
11203
11204 if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
11205 return INVOKE_NONVIRTUAL;
11206 }
11207
11208 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
11209 return INVOKE_INTERFACE;
11210
11211 return INVOKE_VIRTUAL;
11212 }
11213
11214 /* Retrieve a refined list of matching methods. It covers the step
11215 15.11.2 (Compile-Time Step 2) */
11216
11217 static tree
11218 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
11219 {
11220 tree atl = end_params_node; /* Arg Type List */
11221 tree method, signature, list, node;
11222 const char *candidates; /* Used for error report */
11223 char *dup;
11224
11225 /* Fix the arguments */
11226 for (node = arg_list; node; node = TREE_CHAIN (node))
11227 {
11228 tree current_arg = TREE_TYPE (TREE_VALUE (node));
11229 /* Non primitive type may have to be resolved */
11230 if (!JPRIMITIVE_TYPE_P (current_arg))
11231 resolve_and_layout (current_arg, NULL_TREE);
11232 /* And promoted */
11233 if (TREE_CODE (current_arg) == RECORD_TYPE)
11234 current_arg = promote_type (current_arg);
11235 /* If we're building an anonymous constructor call, and one of
11236 the arguments has array type, cast it to a size-less array
11237 type. This prevents us from getting a strange gcj-specific
11238 "sized array" signature in the constructor's signature. */
11239 if (lc && ANONYMOUS_CLASS_P (class)
11240 && TREE_CODE (current_arg) == POINTER_TYPE
11241 && TYPE_ARRAY_P (TREE_TYPE (current_arg)))
11242 {
11243 tree elt = TYPE_ARRAY_ELEMENT (TREE_TYPE (current_arg));
11244 current_arg = build_pointer_type (build_java_array_type (elt, -1));
11245 }
11246 atl = tree_cons (NULL_TREE, current_arg, atl);
11247 }
11248
11249 /* Presto. If we're dealing with an anonymous class and a
11250 constructor call, generate the right constructor now, since we
11251 know the arguments' types. */
11252
11253 if (lc && ANONYMOUS_CLASS_P (class))
11254 {
11255 tree mdecl = craft_constructor (TYPE_NAME (class), atl);
11256 /* The anonymous class may have already been laid out, so make sure
11257 the new constructor is laid out here. */
11258 layout_class_method (class, CLASSTYPE_SUPER (class), mdecl, NULL_TREE);
11259 }
11260
11261 /* Find all candidates and then refine the list, searching for the
11262 most specific method. */
11263 list = find_applicable_accessible_methods_list (lc, class, name, atl);
11264 list = find_most_specific_methods_list (list, class);
11265 if (list && !TREE_CHAIN (list))
11266 return TREE_VALUE (list);
11267
11268 /* Issue an error. List candidates if any. Candidates are listed
11269 only if accessible (non accessible methods may end-up here for
11270 the sake of a better error report). */
11271 candidates = NULL;
11272 if (list)
11273 {
11274 tree current;
11275 obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
11276 for (current = list; current; current = TREE_CHAIN (current))
11277 {
11278 tree cm = TREE_VALUE (current);
11279 char string [4096];
11280 if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
11281 continue;
11282 sprintf
11283 (string, " '%s' in '%s'%s",
11284 get_printable_method_name (cm),
11285 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
11286 (TREE_CHAIN (current) ? "\n" : ""));
11287 obstack_grow (&temporary_obstack, string, strlen (string));
11288 }
11289 obstack_1grow (&temporary_obstack, '\0');
11290 candidates = obstack_finish (&temporary_obstack);
11291 }
11292 /* Issue the error message */
11293 method = make_node (FUNCTION_TYPE);
11294 TYPE_ARG_TYPES (method) = atl;
11295 signature = build_java_argument_signature (method);
11296 dup = xstrdup (lang_printable_name (class, 0));
11297 parse_error_context (cl, "Can't find %s %<%s(%s)%> in type %qs%s",
11298 (lc ? "constructor" : "method"),
11299 (lc ? dup : IDENTIFIER_POINTER (name)),
11300 IDENTIFIER_POINTER (signature), dup,
11301 (candidates ? candidates : ""));
11302 free (dup);
11303 return NULL_TREE;
11304 }
11305
11306 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11307 when we're looking for a constructor. */
11308
11309 static tree
11310 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11311 tree arglist)
11312 {
11313 static htab_t searched_classes;
11314 static int search_not_done = 0;
11315 tree list = NULL_TREE, all_list = NULL_TREE;
11316 tree base_binfo;
11317 int i;
11318
11319 /* Check the hash table to determine if this class has been searched
11320 already. */
11321 if (searched_classes)
11322 {
11323 if (htab_find (searched_classes, class) != NULL)
11324 return NULL;
11325 }
11326 else
11327 {
11328 searched_classes = htab_create (10, htab_hash_pointer,
11329 htab_eq_pointer, NULL);
11330 }
11331
11332 search_not_done++;
11333 *htab_find_slot (searched_classes, class, INSERT) = class;
11334
11335 if (!CLASS_LOADED_P (class))
11336 {
11337 load_class (class, 1);
11338 safe_layout_class (class);
11339 }
11340
11341 /* Search interfaces */
11342 if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11343 && CLASS_INTERFACE (TYPE_NAME (class)))
11344 {
11345 search_applicable_methods_list (lc, TYPE_METHODS (class),
11346 name, arglist, &list, &all_list);
11347 for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11348 {
11349 tree t = BINFO_TYPE (base_binfo);
11350 tree rlist;
11351
11352 rlist = find_applicable_accessible_methods_list (lc, t, name,
11353 arglist);
11354 list = chainon (rlist, list);
11355 }
11356 }
11357 /* Search classes */
11358 else
11359 {
11360 search_applicable_methods_list (lc, TYPE_METHODS (class),
11361 name, arglist, &list, &all_list);
11362
11363 /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11364 that we only search in class. Note that we should have found
11365 something at this point. */
11366 if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11367 {
11368 lc = 1;
11369 if (!list)
11370 abort ();
11371 }
11372
11373 /* We must search all interfaces of this class */
11374 if (!lc)
11375 {
11376 for (i = 1;
11377 BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11378 {
11379 tree t = BINFO_TYPE (base_binfo);
11380 if (t != object_type_node)
11381 {
11382 tree rlist
11383 = find_applicable_accessible_methods_list (lc, t,
11384 name, arglist);
11385 list = chainon (rlist, list);
11386 }
11387 }
11388 }
11389
11390 /* Search superclass */
11391 if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11392 {
11393 tree rlist;
11394 class = CLASSTYPE_SUPER (class);
11395 rlist = find_applicable_accessible_methods_list (lc, class,
11396 name, arglist);
11397 list = chainon (rlist, list);
11398 }
11399 }
11400
11401 search_not_done--;
11402
11403 /* We're done. Reset the searched classes list and finally search
11404 java.lang.Object if it wasn't searched already. */
11405 if (!search_not_done)
11406 {
11407 if (!lc
11408 && TYPE_METHODS (object_type_node)
11409 && htab_find (searched_classes, object_type_node) == NULL)
11410 {
11411 search_applicable_methods_list (lc,
11412 TYPE_METHODS (object_type_node),
11413 name, arglist, &list, &all_list);
11414 }
11415 htab_delete (searched_classes);
11416 searched_classes = NULL;
11417 }
11418
11419 /* Either return the list obtained or all selected (but
11420 inaccessible) methods for better error report. */
11421 return (!list ? all_list : list);
11422 }
11423
11424 /* Effectively search for the appropriate method in method */
11425
11426 static void
11427 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11428 tree *list, tree *all_list)
11429 {
11430 for (; method; method = TREE_CHAIN (method))
11431 {
11432 /* When dealing with constructor, stop here, otherwise search
11433 other classes */
11434 if (lc && !DECL_CONSTRUCTOR_P (method))
11435 continue;
11436 else if (!lc && (DECL_CONSTRUCTOR_P (method)
11437 || (DECL_NAME (method) != name)))
11438 continue;
11439
11440 if (argument_types_convertible (method, arglist))
11441 {
11442 /* Retain accessible methods only */
11443 if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11444 method, NULL_TREE, 0))
11445 *list = tree_cons (NULL_TREE, method, *list);
11446 else
11447 /* Also retain all selected method here */
11448 *all_list = tree_cons (NULL_TREE, method, *list);
11449 }
11450 }
11451 }
11452
11453 /* 15.11.2.2 Choose the Most Specific Method */
11454
11455 static tree
11456 find_most_specific_methods_list (tree list, tree class)
11457 {
11458 int max = 0;
11459 int abstract, candidates;
11460 tree current, new_list = NULL_TREE;
11461 for (current = list; current; current = TREE_CHAIN (current))
11462 {
11463 tree method;
11464 DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11465
11466 for (method = list; method; method = TREE_CHAIN (method))
11467 {
11468 tree method_v, current_v;
11469 /* Don't test a method against itself */
11470 if (method == current)
11471 continue;
11472
11473 method_v = TREE_VALUE (method);
11474 current_v = TREE_VALUE (current);
11475
11476 /* Compare arguments and location where methods where declared */
11477 if (argument_types_convertible (method_v, current_v))
11478 {
11479 /* We have a rather odd special case here. The front
11480 end doesn't properly implement inheritance, so we
11481 work around it here. The idea is, if we are
11482 comparing a method declared in a class to one
11483 declared in an interface, and the invocation's
11484 qualifying class is a class (and not an interface),
11485 then we consider the method's class to be the
11486 qualifying class of the invocation. This lets us
11487 fake the result of ordinary inheritance. */
11488 tree context_v = DECL_CONTEXT (current_v);
11489 if (TYPE_INTERFACE_P (DECL_CONTEXT (method_v))
11490 && ! TYPE_INTERFACE_P (context_v)
11491 && ! TYPE_INTERFACE_P (class))
11492 context_v = class;
11493
11494 if (valid_method_invocation_conversion_p
11495 (DECL_CONTEXT (method_v), context_v))
11496 {
11497 int v = (DECL_SPECIFIC_COUNT (current_v) += 1);
11498 max = (v > max ? v : max);
11499 }
11500 }
11501 }
11502 }
11503
11504 /* Review the list and select the maximally specific methods */
11505 for (current = list, abstract = -1, candidates = -1;
11506 current; current = TREE_CHAIN (current))
11507 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11508 {
11509 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11510 abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11511 candidates++;
11512 }
11513
11514 /* If we have several and they're all abstract, just pick the
11515 closest one. */
11516 if (candidates > 0 && candidates == abstract)
11517 {
11518 /* FIXME: merge the throws clauses. There is no convenient way
11519 to do this in gcj right now, since ideally we'd like to
11520 introduce a new METHOD_DECL here, but that is really not
11521 possible. */
11522 new_list = nreverse (new_list);
11523 TREE_CHAIN (new_list) = NULL_TREE;
11524 return new_list;
11525 }
11526
11527 /* We have several (we couldn't find a most specific), all but one
11528 are abstract, we pick the only non abstract one. */
11529 if (candidates > 0 && (candidates == abstract+1))
11530 {
11531 for (current = new_list; current; current = TREE_CHAIN (current))
11532 if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11533 {
11534 TREE_CHAIN (current) = NULL_TREE;
11535 new_list = current;
11536 }
11537 }
11538
11539 /* If we can't find one, lower expectations and try to gather multiple
11540 maximally specific methods */
11541 while (!new_list && max)
11542 {
11543 while (--max > 0)
11544 {
11545 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11546 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11547 }
11548 }
11549
11550 return new_list;
11551 }
11552
11553 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11554 converted by method invocation conversion (5.3) to the type of the
11555 corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11556 to change less often than M1. */
11557
11558 static GTY(()) tree m2_arg_value;
11559 static GTY(()) tree m2_arg_cache;
11560
11561 static int
11562 argument_types_convertible (tree m1, tree m2_or_arglist)
11563 {
11564 tree m1_arg, m2_arg;
11565
11566 SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11567
11568 if (m2_arg_value == m2_or_arglist)
11569 m2_arg = m2_arg_cache;
11570 else
11571 {
11572 /* M2_OR_ARGLIST can be a function DECL or a raw list of
11573 argument types */
11574 if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11575 {
11576 m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11577 if (!METHOD_STATIC (m2_or_arglist))
11578 m2_arg = TREE_CHAIN (m2_arg);
11579 }
11580 else
11581 m2_arg = m2_or_arglist;
11582
11583 m2_arg_value = m2_or_arglist;
11584 m2_arg_cache = m2_arg;
11585 }
11586
11587 while (m1_arg != end_params_node && m2_arg != end_params_node)
11588 {
11589 resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11590 if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11591 TREE_VALUE (m2_arg)))
11592 break;
11593 m1_arg = TREE_CHAIN (m1_arg);
11594 m2_arg = TREE_CHAIN (m2_arg);
11595 }
11596 return m1_arg == end_params_node && m2_arg == end_params_node;
11597 }
11598
11599 /* Qualification routines */
11600
11601 /* Given a name x.y.z, look up x locally. If it's found, save the
11602 decl. If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11603 so that we later try and load the appropriate classes. */
11604 static void
11605 qualify_ambiguous_name (tree id)
11606 {
11607 tree name, decl;
11608
11609 /* We inspect the first item of the qualification list. As a sanity
11610 check, make sure that it is an identfier node. */
11611 tree qual = EXPR_WFL_QUALIFICATION (id);
11612 tree qual_wfl = QUAL_WFL (qual);
11613
11614 if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11615 return;
11616
11617 name = EXPR_WFL_NODE (qual_wfl);
11618
11619 /* If we don't have an identifier, or we have a 'this' or 'super',
11620 then field access processing is all we need : there is nothing
11621 for us to do. */
11622 if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11623 name == this_identifier_node ||
11624 name == super_identifier_node)
11625 return;
11626
11627 /* If name appears within the scope of a local variable declaration
11628 or parameter declaration, or is a field within an enclosing
11629 class, then it is an expression name. Save the decl and let
11630 resolve_field_access do it's work. */
11631 if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11632 (decl = lookup_field_wrapper (current_class, name)))
11633 {
11634 QUAL_RESOLUTION (qual) = decl;
11635 return;
11636 }
11637
11638 /* If name is a known class name (either declared or imported), mark
11639 us as a type name. */
11640 if ((decl = resolve_and_layout (name, NULL_TREE)))
11641 {
11642 RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11643 QUAL_RESOLUTION (qual) = decl;
11644 }
11645
11646 /* Check here that NAME isn't declared by more than one
11647 type-import-on-demand declaration of the compilation unit
11648 containing NAME. FIXME */
11649
11650 /* We couldn't find a declaration for the name. Assume for now that
11651 we have a qualified class name that needs to be loaded from an
11652 external class file. */
11653 else
11654 RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11655
11656 /* Propagate the qualification across other components of the
11657 qualified name */
11658 for (qual = TREE_CHAIN (qual); qual;
11659 qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11660 {
11661 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11662 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11663 }
11664
11665 /* Store the global qualification for the ambiguous part of ID back
11666 into ID fields */
11667 if (RESOLVE_TYPE_NAME_P (qual_wfl))
11668 RESOLVE_TYPE_NAME_P (id) = 1;
11669 else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11670 RESOLVE_PACKAGE_NAME_P (id) = 1;
11671 }
11672
11673 /* Patch tree nodes in a function body. When a BLOCK is found, push
11674 local variable decls if present.
11675 Same as java_complete_lhs, but does resolve static finals to values. */
11676
11677 static tree
11678 java_complete_tree (tree node)
11679 {
11680 node = java_complete_lhs (node);
11681 if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11682 && DECL_INITIAL (node) != NULL_TREE)
11683 {
11684 tree value = fold_constant_for_init (node, node);
11685 if (value != NULL_TREE)
11686 return value;
11687 }
11688 return node;
11689 }
11690
11691 static tree
11692 java_stabilize_reference (tree node)
11693 {
11694 if (TREE_CODE (node) == COMPOUND_EXPR)
11695 {
11696 tree op0 = TREE_OPERAND (node, 0);
11697 tree op1 = TREE_OPERAND (node, 1);
11698 TREE_OPERAND (node, 0) = save_expr (op0);
11699 TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11700 return node;
11701 }
11702 return stabilize_reference (node);
11703 }
11704
11705 /* Patch tree nodes in a function body. When a BLOCK is found, push
11706 local variable decls if present.
11707 Same as java_complete_tree, but does not resolve static finals to values. */
11708
11709 static tree
11710 java_complete_lhs (tree node)
11711 {
11712 tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11713 int flag;
11714
11715 /* CONVERT_EXPR always has its type set, even though it needs to be
11716 worked out. */
11717 if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11718 return node;
11719
11720 /* The switch block implements cases processing container nodes
11721 first. Contained nodes are always written back. Leaves come
11722 next and return a value. */
11723 switch (TREE_CODE (node))
11724 {
11725 case BLOCK:
11726
11727 /* 1- Block section.
11728 Set the local values on decl names so we can identify them
11729 faster when they're referenced. At that stage, identifiers
11730 are legal so we don't check for declaration errors. */
11731 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11732 {
11733 DECL_CONTEXT (cn) = current_function_decl;
11734 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11735 }
11736 if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11737 CAN_COMPLETE_NORMALLY (node) = 1;
11738 else
11739 {
11740 tree stmt = BLOCK_EXPR_BODY (node);
11741 tree *ptr;
11742 int error_seen = 0;
11743 if (TREE_CODE (stmt) == COMPOUND_EXPR)
11744 {
11745 /* Re-order from (((A; B); C); ...; Z) to
11746 (A; (B; (C ; (...; Z)))).
11747 This makes it easier to scan the statements left-to-right
11748 without using recursion (which might overflow the stack
11749 if the block has many statements. */
11750 for (;;)
11751 {
11752 tree left = TREE_OPERAND (stmt, 0);
11753 if (TREE_CODE (left) != COMPOUND_EXPR)
11754 break;
11755 TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11756 TREE_OPERAND (left, 1) = stmt;
11757 stmt = left;
11758 }
11759 BLOCK_EXPR_BODY (node) = stmt;
11760 }
11761
11762 /* Now do the actual complete, without deep recursion for
11763 long blocks. */
11764 ptr = &BLOCK_EXPR_BODY (node);
11765 while (TREE_CODE (*ptr) == COMPOUND_EXPR
11766 && !IS_EMPTY_STMT (TREE_OPERAND (*ptr, 1)))
11767 {
11768 tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11769 tree *next = &TREE_OPERAND (*ptr, 1);
11770 TREE_OPERAND (*ptr, 0) = cur;
11771 if (IS_EMPTY_STMT (cur))
11772 {
11773 /* Optimization; makes it easier to detect empty bodies.
11774 Most useful for <clinit> with all-constant initializer. */
11775 *ptr = *next;
11776 continue;
11777 }
11778 if (TREE_CODE (cur) == ERROR_MARK)
11779 error_seen++;
11780 else if (! CAN_COMPLETE_NORMALLY (cur))
11781 {
11782 wfl_op2 = *next;
11783 for (;;)
11784 {
11785 if (TREE_CODE (wfl_op2) == BLOCK)
11786 wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11787 else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11788 wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11789 else
11790 break;
11791 }
11792 if (TREE_CODE (wfl_op2) != CASE_EXPR
11793 && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11794 unreachable_stmt_error (*ptr);
11795 }
11796 if (TREE_TYPE (*ptr) == NULL_TREE)
11797 TREE_TYPE (*ptr) = void_type_node;
11798 ptr = next;
11799 }
11800 *ptr = java_complete_tree (*ptr);
11801
11802 if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11803 return error_mark_node;
11804 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11805 }
11806 /* Turn local bindings to null */
11807 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11808 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11809
11810 TREE_TYPE (node) = void_type_node;
11811 break;
11812
11813 /* 2- They are expressions but ultimately deal with statements */
11814
11815 case THROW_EXPR:
11816 wfl_op1 = TREE_OPERAND (node, 0);
11817 COMPLETE_CHECK_OP_0 (node);
11818 /* 14.19 A throw statement cannot complete normally. */
11819 CAN_COMPLETE_NORMALLY (node) = 0;
11820 return patch_throw_statement (node, wfl_op1);
11821
11822 case SYNCHRONIZED_EXPR:
11823 wfl_op1 = TREE_OPERAND (node, 0);
11824 return patch_synchronized_statement (node, wfl_op1);
11825
11826 case TRY_EXPR:
11827 return patch_try_statement (node);
11828
11829 case TRY_FINALLY_EXPR:
11830 COMPLETE_CHECK_OP_0 (node);
11831 COMPLETE_CHECK_OP_1 (node);
11832 if (IS_EMPTY_STMT (TREE_OPERAND (node, 0)))
11833 /* Reduce try/finally nodes with an empty try block. */
11834 return TREE_OPERAND (node, 1);
11835 if (IS_EMPTY_STMT (TREE_OPERAND (node, 1)))
11836 /* Likewise for an empty finally block. */
11837 return TREE_OPERAND (node, 0);
11838 CAN_COMPLETE_NORMALLY (node)
11839 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11840 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11841 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11842 return node;
11843
11844 case LABELED_BLOCK_EXPR:
11845 PUSH_LABELED_BLOCK (node);
11846 if (LABELED_BLOCK_BODY (node))
11847 COMPLETE_CHECK_OP_1 (node);
11848 TREE_TYPE (node) = void_type_node;
11849 POP_LABELED_BLOCK ();
11850
11851 if (IS_EMPTY_STMT (LABELED_BLOCK_BODY (node)))
11852 {
11853 LABELED_BLOCK_BODY (node) = NULL_TREE;
11854 CAN_COMPLETE_NORMALLY (node) = 1;
11855 }
11856 else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11857 CAN_COMPLETE_NORMALLY (node) = 1;
11858 return node;
11859
11860 case EXIT_BLOCK_EXPR:
11861 return patch_bc_statement (node);
11862
11863 case CASE_EXPR:
11864 cn = java_complete_tree (TREE_OPERAND (node, 0));
11865 if (cn == error_mark_node)
11866 return cn;
11867
11868 /* First, the case expression must be constant. Values of final
11869 fields are accepted. */
11870 nn = fold_constant_for_init (cn, NULL_TREE);
11871 if (nn != NULL_TREE)
11872 cn = nn;
11873
11874 cn = fold (cn);
11875 if ((TREE_CODE (cn) == COMPOUND_EXPR
11876 || TREE_CODE (cn) == COMPONENT_REF)
11877 && JDECL_P (TREE_OPERAND (cn, 1))
11878 && FIELD_FINAL (TREE_OPERAND (cn, 1))
11879 && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11880 {
11881 cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11882 TREE_OPERAND (cn, 1));
11883 }
11884 /* Accept final locals too. */
11885 else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
11886 && DECL_INITIAL (cn))
11887 cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11888
11889 if (!TREE_CONSTANT (cn))
11890 {
11891 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11892 parse_error_context (node, "Constant expression required");
11893 return error_mark_node;
11894 }
11895
11896 nn = ctxp->current_loop;
11897
11898 /* It must be assignable to the type of the switch expression. */
11899 if (!try_builtin_assignconv (NULL_TREE,
11900 TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11901 {
11902 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11903 parse_error_context
11904 (wfl_operator,
11905 "Incompatible type for case. Can't convert %qs to %<int%>",
11906 lang_printable_name (TREE_TYPE (cn), 0));
11907 return error_mark_node;
11908 }
11909
11910 cn = fold (convert (int_type_node, cn));
11911 TREE_CONSTANT_OVERFLOW (cn) = 0;
11912 CAN_COMPLETE_NORMALLY (cn) = 1;
11913
11914 /* Save the label on a list so that we can later check for
11915 duplicates. */
11916 case_label_list = tree_cons (node, cn, case_label_list);
11917
11918 /* Multiple instance of a case label bearing the same value is
11919 checked later. The case expression is all right so far. */
11920 if (TREE_CODE (cn) == VAR_DECL)
11921 cn = DECL_INITIAL (cn);
11922 TREE_OPERAND (node, 0) = cn;
11923 TREE_TYPE (node) = void_type_node;
11924 CAN_COMPLETE_NORMALLY (node) = 1;
11925 TREE_SIDE_EFFECTS (node) = 1;
11926 break;
11927
11928 case DEFAULT_EXPR:
11929 nn = ctxp->current_loop;
11930 /* Only one default label is allowed per switch statement */
11931 if (SWITCH_HAS_DEFAULT (nn))
11932 {
11933 #ifdef USE_MAPPED_LOCATION
11934 SET_EXPR_LOCATION (wfl_operator, EXPR_LOCATION (node));
11935 #else
11936 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11937 #endif
11938 parse_error_context (wfl_operator,
11939 "Duplicate case label: %<default%>");
11940 return error_mark_node;
11941 }
11942 else
11943 SWITCH_HAS_DEFAULT (nn) = 1;
11944 TREE_TYPE (node) = void_type_node;
11945 TREE_SIDE_EFFECTS (node) = 1;
11946 CAN_COMPLETE_NORMALLY (node) = 1;
11947 break;
11948
11949 case SWITCH_EXPR:
11950 case LOOP_EXPR:
11951 PUSH_LOOP (node);
11952 /* Check whether the loop was enclosed in a labeled
11953 statement. If not, create one, insert the loop in it and
11954 return the node */
11955 nn = patch_loop_statement (node);
11956
11957 /* Anyways, walk the body of the loop */
11958 if (TREE_CODE (node) == LOOP_EXPR)
11959 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11960 /* Switch statement: walk the switch expression and the cases */
11961 else
11962 node = patch_switch_statement (node);
11963
11964 if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11965 nn = error_mark_node;
11966 else
11967 {
11968 TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11969 /* If we returned something different, that's because we
11970 inserted a label. Pop the label too. */
11971 if (nn != node)
11972 {
11973 if (CAN_COMPLETE_NORMALLY (node))
11974 CAN_COMPLETE_NORMALLY (nn) = 1;
11975 POP_LABELED_BLOCK ();
11976 }
11977 }
11978 POP_LOOP ();
11979 return nn;
11980
11981 case EXIT_EXPR:
11982 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11983 return patch_exit_expr (node);
11984
11985 case COND_EXPR:
11986 /* Condition */
11987 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11988 if (TREE_OPERAND (node, 0) == error_mark_node)
11989 return error_mark_node;
11990 /* then-else branches */
11991 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11992 if (TREE_OPERAND (node, 1) == error_mark_node)
11993 return error_mark_node;
11994 {
11995 /* This is a special case due to build_assertion(). When
11996 assertions are disabled we build a COND_EXPR in which
11997 Operand 1 is the body of the assertion. If that happens to
11998 be a string concatenation we'll need to patch it here. */
11999 tree patched = patch_string (TREE_OPERAND (node, 1));
12000 if (patched)
12001 TREE_OPERAND (node, 1) = patched;
12002 }
12003 TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
12004 if (TREE_OPERAND (node, 2) == error_mark_node)
12005 return error_mark_node;
12006 return patch_if_else_statement (node);
12007 break;
12008
12009 case CONDITIONAL_EXPR:
12010 /* Condition */
12011 wfl_op1 = TREE_OPERAND (node, 0);
12012 COMPLETE_CHECK_OP_0 (node);
12013 wfl_op2 = TREE_OPERAND (node, 1);
12014 COMPLETE_CHECK_OP_1 (node);
12015 wfl_op3 = TREE_OPERAND (node, 2);
12016 COMPLETE_CHECK_OP_2 (node);
12017 return patch_conditional_expr (node, wfl_op1, wfl_op2);
12018
12019 /* 3- Expression section */
12020 case COMPOUND_EXPR:
12021 wfl_op2 = TREE_OPERAND (node, 1);
12022 TREE_OPERAND (node, 0) = nn =
12023 java_complete_tree (TREE_OPERAND (node, 0));
12024 if (IS_EMPTY_STMT (wfl_op2))
12025 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
12026 else
12027 {
12028 if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
12029 {
12030 /* An unreachable condition in a do-while statement
12031 is *not* (technically) an unreachable statement. */
12032 nn = wfl_op2;
12033 if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
12034 nn = EXPR_WFL_NODE (nn);
12035 /* NN can be NULL_TREE exactly when UPDATE is, in
12036 finish_for_loop. */
12037 if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
12038 {
12039 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
12040 if (SUPPRESS_UNREACHABLE_ERROR (nn))
12041 {
12042 /* Perhaps this warning should have an
12043 associated flag. The code being compiled is
12044 pedantically correct, but useless. */
12045 parse_warning_context (wfl_operator,
12046 "Unreachable statement");
12047 }
12048 else
12049 parse_error_context (wfl_operator,
12050 "Unreachable statement");
12051 }
12052 }
12053 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
12054 if (TREE_OPERAND (node, 1) == error_mark_node)
12055 return error_mark_node;
12056 /* Even though we might allow the case where the first
12057 operand doesn't return normally, we still should compute
12058 CAN_COMPLETE_NORMALLY correctly. */
12059 CAN_COMPLETE_NORMALLY (node)
12060 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
12061 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
12062 }
12063 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
12064 break;
12065
12066 case RETURN_EXPR:
12067 /* CAN_COMPLETE_NORMALLY (node) = 0; */
12068 return patch_return (node);
12069
12070 case EXPR_WITH_FILE_LOCATION:
12071 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
12072 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
12073 {
12074 node = resolve_expression_name (node, NULL);
12075 if (node == error_mark_node)
12076 return node;
12077 CAN_COMPLETE_NORMALLY (node) = 1;
12078 }
12079 else
12080 {
12081 tree body;
12082 location_t save_location = input_location;
12083 #ifdef USE_MAPPED_LOCATION
12084 input_location = EXPR_LOCATION (node);
12085 if (input_location == UNKNOWN_LOCATION)
12086 input_location = save_location;
12087 #else
12088 input_line = EXPR_WFL_LINENO (node);
12089 #endif
12090 body = java_complete_tree (EXPR_WFL_NODE (node));
12091 input_location = save_location;
12092 EXPR_WFL_NODE (node) = body;
12093 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
12094 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
12095 if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
12096 {
12097 /* Makes it easier to constant fold, detect empty bodies. */
12098 return body;
12099 }
12100 if (body == error_mark_node)
12101 {
12102 /* Its important for the evaluation of assignment that
12103 this mark on the TREE_TYPE is propagated. */
12104 TREE_TYPE (node) = error_mark_node;
12105 return error_mark_node;
12106 }
12107 else
12108 TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
12109
12110 }
12111 break;
12112
12113 case NEW_ARRAY_EXPR:
12114 /* Patch all the dimensions */
12115 flag = 0;
12116 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12117 {
12118 int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
12119 tree dim = convert (int_type_node,
12120 java_complete_tree (TREE_VALUE (cn)));
12121 if (dim == error_mark_node)
12122 {
12123 flag = 1;
12124 continue;
12125 }
12126 else
12127 {
12128 TREE_VALUE (cn) = dim;
12129 /* Setup the location of the current dimension, for
12130 later error report. */
12131 #ifdef USE_MAPPED_LOCATION
12132 TREE_PURPOSE (cn) = expr_add_location (NULL_TREE, location, 0);
12133 #else
12134 TREE_PURPOSE (cn) =
12135 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
12136 EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
12137 #endif
12138 }
12139 }
12140 /* They complete the array creation expression, if no errors
12141 were found. */
12142 CAN_COMPLETE_NORMALLY (node) = 1;
12143 return (flag ? error_mark_node
12144 : force_evaluation_order (patch_newarray (node)));
12145
12146 case NEW_ANONYMOUS_ARRAY_EXPR:
12147 /* Create the array type if necessary. */
12148 if (ANONYMOUS_ARRAY_DIMS_SIG (node))
12149 {
12150 tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
12151 if (!(type = resolve_type_during_patch (type)))
12152 return error_mark_node;
12153 type = build_array_from_name (type, NULL_TREE,
12154 ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
12155 ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
12156 }
12157 node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
12158 ANONYMOUS_ARRAY_INITIALIZER (node));
12159 if (node == error_mark_node)
12160 return error_mark_node;
12161 CAN_COMPLETE_NORMALLY (node) = 1;
12162 return node;
12163
12164 case NEW_CLASS_EXPR:
12165 case CALL_EXPR:
12166 /* Complete function's argument(s) first */
12167 if (complete_function_arguments (node))
12168 return error_mark_node;
12169 else
12170 {
12171 tree decl, wfl = TREE_OPERAND (node, 0);
12172 int in_this = CALL_THIS_CONSTRUCTOR_P (node);
12173 int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
12174 super_identifier_node);
12175 tree arguments;
12176 #ifdef USE_MAPPED_LOCATION
12177 source_location location = EXPR_LOCATION (node);
12178 #else
12179 int location = EXPR_WFL_LINECOL (node);
12180 #endif
12181
12182 node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
12183 from_super, 0, &decl);
12184 if (node == error_mark_node)
12185 return error_mark_node;
12186
12187 if (TREE_CODE (node) == CALL_EXPR
12188 && TREE_OPERAND (node, 1) != NULL_TREE)
12189 arguments = TREE_VALUE (TREE_OPERAND (node, 1));
12190 else
12191 arguments = NULL_TREE;
12192 check_thrown_exceptions (location, decl, arguments);
12193 /* If we call this(...), register signature and positions */
12194 if (in_this)
12195 DECL_CONSTRUCTOR_CALLS (current_function_decl) =
12196 tree_cons (wfl, decl,
12197 DECL_CONSTRUCTOR_CALLS (current_function_decl));
12198 CAN_COMPLETE_NORMALLY (node) = 1;
12199 return force_evaluation_order (node);
12200 }
12201
12202 case MODIFY_EXPR:
12203 /* Save potential wfls */
12204 wfl_op1 = TREE_OPERAND (node, 0);
12205 TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
12206
12207 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
12208 && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
12209 && DECL_INITIAL (nn) != NULL_TREE)
12210 {
12211 tree value;
12212
12213 value = fold_constant_for_init (nn, nn);
12214
12215 /* When we have a primitype type, or a string and we're not
12216 emitting a class file, we actually don't want to generate
12217 anything for the assignment. */
12218 if (value != NULL_TREE &&
12219 (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
12220 (TREE_TYPE (value) == string_ptr_type_node &&
12221 ! flag_emit_class_files)))
12222 {
12223 /* Prepare node for patch_assignment */
12224 TREE_OPERAND (node, 1) = value;
12225 /* Call patch assignment to verify the assignment */
12226 if (patch_assignment (node, wfl_op1) == error_mark_node)
12227 return error_mark_node;
12228 /* Set DECL_INITIAL properly (a conversion might have
12229 been decided by patch_assignment) and return the
12230 empty statement. */
12231 else
12232 {
12233 tree patched = patch_string (TREE_OPERAND (node, 1));
12234 if (patched)
12235 DECL_INITIAL (nn) = patched;
12236 else
12237 DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12238 DECL_FIELD_FINAL_IUD (nn) = 1;
12239 return build_java_empty_stmt ();
12240 }
12241 }
12242 if (! flag_emit_class_files)
12243 DECL_INITIAL (nn) = NULL_TREE;
12244 }
12245 wfl_op2 = TREE_OPERAND (node, 1);
12246
12247 if (TREE_OPERAND (node, 0) == error_mark_node)
12248 return error_mark_node;
12249
12250 flag = COMPOUND_ASSIGN_P (wfl_op2);
12251 if (flag)
12252 {
12253 /* This might break when accessing outer field from inner
12254 class. TESTME, FIXME */
12255 tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12256
12257 /* Hand stabilize the lhs on both places */
12258 TREE_OPERAND (node, 0) = lvalue;
12259 TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12260 (flag_emit_class_files ? lvalue : save_expr (lvalue));
12261
12262 /* 15.25.2.a: Left hand is not an array access. FIXME */
12263 /* Now complete the RHS. We write it back later on. */
12264 nn = java_complete_tree (TREE_OPERAND (node, 1));
12265
12266 if ((cn = patch_string (nn)))
12267 nn = cn;
12268
12269 /* The last part of the rewrite for E1 op= E2 is to have
12270 E1 = (T)(E1 op E2), with T being the type of E1. */
12271 nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12272 TREE_TYPE (lvalue), nn));
12273
12274 /* If the assignment is compound and has reference type,
12275 then ensure the LHS has type String and nothing else. */
12276 if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12277 && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12278 parse_error_context (wfl_op2,
12279 "Incompatible type for %<+=%>. Can't convert %qs to %<java.lang.String%>",
12280 lang_printable_name (TREE_TYPE (lvalue), 0));
12281
12282 /* 15.25.2.b: Left hand is an array access. FIXME */
12283 }
12284
12285 /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12286 function to complete this RHS. Note that a NEW_ARRAY_INIT
12287 might have been already fully expanded if created as a result
12288 of processing an anonymous array initializer. We avoid doing
12289 the operation twice by testing whether the node already bears
12290 a type. */
12291 else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12292 nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12293 TREE_OPERAND (node, 1));
12294 /* Otherwise we simply complete the RHS */
12295 else
12296 nn = java_complete_tree (TREE_OPERAND (node, 1));
12297
12298 if (nn == error_mark_node)
12299 return error_mark_node;
12300
12301 /* Write back the RHS as we evaluated it. */
12302 TREE_OPERAND (node, 1) = nn;
12303
12304 /* In case we're handling = with a String as a RHS, we need to
12305 produce a String out of the RHS (it might still be a
12306 STRING_CST or a StringBuffer at this stage */
12307 if ((nn = patch_string (TREE_OPERAND (node, 1))))
12308 TREE_OPERAND (node, 1) = nn;
12309
12310 if ((nn = nested_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12311 TREE_OPERAND (node, 1))))
12312 {
12313 /* We return error_mark_node if nested_field_access_fix
12314 detects we write into a final. */
12315 if (nn == error_mark_node)
12316 return error_mark_node;
12317 node = nn;
12318 }
12319 else
12320 {
12321 node = patch_assignment (node, wfl_op1);
12322 if (node == error_mark_node)
12323 return error_mark_node;
12324 /* Reorganize the tree if necessary. */
12325 if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12326 || JSTRING_P (TREE_TYPE (node))))
12327 node = java_refold (node);
12328 }
12329
12330 /* Seek to set DECL_INITIAL to a proper value, since it might have
12331 undergone a conversion in patch_assignment. We do that only when
12332 it's necessary to have DECL_INITIAL properly set. */
12333 nn = TREE_OPERAND (node, 0);
12334 if (TREE_CODE (nn) == VAR_DECL
12335 && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12336 && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12337 && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12338 || TREE_TYPE (nn) == string_ptr_type_node))
12339 DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12340
12341 CAN_COMPLETE_NORMALLY (node) = 1;
12342 return node;
12343
12344 case MULT_EXPR:
12345 case PLUS_EXPR:
12346 case MINUS_EXPR:
12347 case LSHIFT_EXPR:
12348 case RSHIFT_EXPR:
12349 case URSHIFT_EXPR:
12350 case BIT_AND_EXPR:
12351 case BIT_XOR_EXPR:
12352 case BIT_IOR_EXPR:
12353 case TRUNC_MOD_EXPR:
12354 case TRUNC_DIV_EXPR:
12355 case RDIV_EXPR:
12356 case TRUTH_ANDIF_EXPR:
12357 case TRUTH_ORIF_EXPR:
12358 case EQ_EXPR:
12359 case NE_EXPR:
12360 case GT_EXPR:
12361 case GE_EXPR:
12362 case LT_EXPR:
12363 case LE_EXPR:
12364 /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12365 knows how to handle those cases. */
12366 wfl_op1 = TREE_OPERAND (node, 0);
12367 wfl_op2 = TREE_OPERAND (node, 1);
12368
12369 CAN_COMPLETE_NORMALLY (node) = 1;
12370 /* Don't complete string nodes if dealing with the PLUS operand. */
12371 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12372 {
12373 nn = java_complete_tree (wfl_op1);
12374 if (nn == error_mark_node)
12375 return error_mark_node;
12376
12377 TREE_OPERAND (node, 0) = nn;
12378 }
12379 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12380 {
12381 nn = java_complete_tree (wfl_op2);
12382 if (nn == error_mark_node)
12383 return error_mark_node;
12384
12385 TREE_OPERAND (node, 1) = nn;
12386 }
12387 return patch_binop (node, wfl_op1, wfl_op2, 0);
12388
12389 case INSTANCEOF_EXPR:
12390 wfl_op1 = TREE_OPERAND (node, 0);
12391 COMPLETE_CHECK_OP_0 (node);
12392 return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1), 0);
12393
12394 case UNARY_PLUS_EXPR:
12395 case NEGATE_EXPR:
12396 case TRUTH_NOT_EXPR:
12397 case BIT_NOT_EXPR:
12398 case PREDECREMENT_EXPR:
12399 case PREINCREMENT_EXPR:
12400 case POSTDECREMENT_EXPR:
12401 case POSTINCREMENT_EXPR:
12402 case CONVERT_EXPR:
12403 /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12404 how to handle those cases. */
12405 wfl_op1 = TREE_OPERAND (node, 0);
12406 CAN_COMPLETE_NORMALLY (node) = 1;
12407 if (TREE_CODE (node) == PREDECREMENT_EXPR
12408 || TREE_CODE (node) == PREINCREMENT_EXPR
12409 || TREE_CODE (node) == POSTDECREMENT_EXPR
12410 || TREE_CODE (node) == POSTINCREMENT_EXPR)
12411 { /* We don't want static finals to be resolved to their value
12412 to avoid ICEing later. It solves PR8923. */
12413 TREE_OPERAND (node, 0) = java_complete_lhs (wfl_op1);
12414 }
12415 else
12416 {
12417 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12418 }
12419 if (TREE_OPERAND (node, 0) == error_mark_node)
12420 return error_mark_node;
12421 node = patch_unaryop (node, wfl_op1);
12422 CAN_COMPLETE_NORMALLY (node) = 1;
12423 break;
12424
12425 case ARRAY_REF:
12426 /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12427 how to handle those cases. */
12428 wfl_op1 = TREE_OPERAND (node, 0);
12429 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12430 if (TREE_OPERAND (node, 0) == error_mark_node)
12431 return error_mark_node;
12432 if (!flag_emit_class_files)
12433 TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12434 /* The same applies to wfl_op2 */
12435 wfl_op2 = TREE_OPERAND (node, 1);
12436 TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12437 if (TREE_OPERAND (node, 1) == error_mark_node)
12438 return error_mark_node;
12439 if (!flag_emit_class_files)
12440 TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12441 return patch_array_ref (node);
12442
12443 case RECORD_TYPE:
12444 return node;;
12445
12446 case COMPONENT_REF:
12447 /* The first step in the re-write of qualified name handling. FIXME.
12448 So far, this is only to support PRIMTYPE.class ->
12449 PRIMCLASS.TYPE. */
12450 {
12451 tree prim_class = TREE_OPERAND (node, 0);
12452 tree name = TREE_OPERAND (node, 1);
12453 tree field;
12454
12455 gcc_assert (TREE_CODE (prim_class) == NOP_EXPR);
12456 prim_class = java_complete_tree (TREE_TYPE (prim_class));
12457 gcc_assert (TREE_CODE (prim_class) == RECORD_TYPE);
12458 field = lookup_field_wrapper (prim_class, name);
12459
12460 if (field == NULL_TREE)
12461 {
12462 error ("missing static field %qs", IDENTIFIER_POINTER (name));
12463 return error_mark_node;
12464 }
12465 if (! FIELD_STATIC (field))
12466 {
12467 error ("not a static field %qs", IDENTIFIER_POINTER (name));
12468 return error_mark_node;
12469 }
12470 return field;
12471 }
12472 break;
12473
12474 case THIS_EXPR:
12475 /* Can't use THIS in a static environment */
12476 if (!current_this)
12477 {
12478 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12479 parse_error_context (wfl_operator,
12480 "Keyword %<this%> used outside allowed context");
12481 TREE_TYPE (node) = error_mark_node;
12482 return error_mark_node;
12483 }
12484 if (ctxp->explicit_constructor_p)
12485 {
12486 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12487 parse_error_context
12488 (wfl_operator, "Can't reference %<this%> or %<super%> before the superclass constructor has been called");
12489 TREE_TYPE (node) = error_mark_node;
12490 return error_mark_node;
12491 }
12492 return current_this;
12493
12494 case CLASS_LITERAL:
12495 CAN_COMPLETE_NORMALLY (node) = 1;
12496 node = patch_incomplete_class_ref (node);
12497 if (node == error_mark_node)
12498 return error_mark_node;
12499 break;
12500
12501 default:
12502 CAN_COMPLETE_NORMALLY (node) = 1;
12503 /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12504 and it's time to turn it into the appropriate String object */
12505 if ((nn = patch_string (node)))
12506 node = nn;
12507 else
12508 internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12509 }
12510 return node;
12511 }
12512
12513 /* Complete function call's argument. Return a nonzero value is an
12514 error was found. */
12515
12516 static int
12517 complete_function_arguments (tree node)
12518 {
12519 int flag = 0;
12520 tree cn;
12521
12522 ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12523 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12524 {
12525 tree wfl = TREE_VALUE (cn), parm, temp;
12526 parm = java_complete_tree (wfl);
12527
12528 if (parm == error_mark_node)
12529 {
12530 flag = 1;
12531 continue;
12532 }
12533 /* If we have a string literal that we haven't transformed yet or a
12534 crafted string buffer, as a result of the use of the String
12535 `+' operator. Build `parm.toString()' and expand it. */
12536 if ((temp = patch_string (parm)))
12537 parm = temp;
12538
12539 TREE_VALUE (cn) = parm;
12540 }
12541 ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12542 return flag;
12543 }
12544
12545 /* Sometimes (for loops and variable initialized during their
12546 declaration), we want to wrap a statement around a WFL and turn it
12547 debugable. */
12548
12549 static tree
12550 build_debugable_stmt (int location, tree stmt)
12551 {
12552 if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12553 {
12554 #ifdef USE_MAPPED_LOCATION
12555 stmt = expr_add_location (stmt, location, 1);
12556 #else
12557 stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12558 EXPR_WFL_LINECOL (stmt) = location;
12559 JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12560 #endif
12561 }
12562 return stmt;
12563 }
12564
12565 static tree
12566 build_expr_block (tree body, tree decls)
12567 {
12568 tree node = make_node (BLOCK);
12569 BLOCK_EXPR_DECLS (node) = decls;
12570 BLOCK_EXPR_BODY (node) = body;
12571 if (body)
12572 TREE_TYPE (node) = TREE_TYPE (body);
12573 TREE_SIDE_EFFECTS (node) = 1;
12574 return node;
12575 }
12576
12577 /* Create a new function block and link it appropriately to current
12578 function block chain */
12579
12580 static tree
12581 enter_block (void)
12582 {
12583 tree b = build_expr_block (NULL_TREE, NULL_TREE);
12584
12585 /* Link block B supercontext to the previous block. The current
12586 function DECL is used as supercontext when enter_a_block is called
12587 for the first time for a given function. The current function body
12588 (DECL_FUNCTION_BODY) is set to be block B. */
12589
12590 tree fndecl = current_function_decl;
12591
12592 if (!fndecl) {
12593 BLOCK_SUPERCONTEXT (b) = current_static_block;
12594 current_static_block = b;
12595 }
12596
12597 else if (!DECL_FUNCTION_BODY (fndecl))
12598 {
12599 BLOCK_SUPERCONTEXT (b) = fndecl;
12600 DECL_FUNCTION_BODY (fndecl) = b;
12601 }
12602 else
12603 {
12604 BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12605 DECL_FUNCTION_BODY (fndecl) = b;
12606 }
12607 return b;
12608 }
12609
12610 /* Exit a block by changing the current function body
12611 (DECL_FUNCTION_BODY) to the current block super context, only if
12612 the block being exited isn't the method's top level one. */
12613
12614 static tree
12615 exit_block (void)
12616 {
12617 tree b;
12618 if (current_function_decl)
12619 {
12620 b = DECL_FUNCTION_BODY (current_function_decl);
12621 if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12622 DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12623 }
12624 else
12625 {
12626 b = current_static_block;
12627
12628 if (BLOCK_SUPERCONTEXT (b))
12629 current_static_block = BLOCK_SUPERCONTEXT (b);
12630 }
12631 return b;
12632 }
12633
12634 /* Lookup for NAME in the nested function's blocks, all the way up to
12635 the current toplevel one. It complies with Java's local variable
12636 scoping rules. */
12637
12638 static tree
12639 lookup_name_in_blocks (tree name)
12640 {
12641 tree b = GET_CURRENT_BLOCK (current_function_decl);
12642
12643 while (b != current_function_decl)
12644 {
12645 tree current;
12646
12647 /* Paranoid sanity check. To be removed */
12648 if (TREE_CODE (b) != BLOCK)
12649 abort ();
12650
12651 for (current = BLOCK_EXPR_DECLS (b); current;
12652 current = TREE_CHAIN (current))
12653 if (DECL_NAME (current) == name)
12654 return current;
12655 b = BLOCK_SUPERCONTEXT (b);
12656 }
12657 return NULL_TREE;
12658 }
12659
12660 static void
12661 maybe_absorb_scoping_blocks (void)
12662 {
12663 while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12664 {
12665 tree b = exit_block ();
12666 java_method_add_stmt (current_function_decl, b);
12667 SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12668 }
12669 }
12670
12671 \f
12672 /* This section of the source is reserved to build_* functions that
12673 are building incomplete tree nodes and the patch_* functions that
12674 are completing them. */
12675
12676 /* Wrap a non WFL node around a WFL. */
12677
12678 static tree
12679 build_wfl_wrap (tree node, int location)
12680 {
12681 tree wfl, node_to_insert = node;
12682
12683 /* We want to process THIS . xxx symbolically, to keep it consistent
12684 with the way we're processing SUPER. A THIS from a primary as a
12685 different form than a SUPER. Turn THIS into something symbolic */
12686 if (TREE_CODE (node) == THIS_EXPR)
12687 node_to_insert = wfl = build_wfl_node (this_identifier_node);
12688 else
12689 #ifdef USE_MAPPED_LOCATION
12690 wfl = build_unknown_wfl (NULL_TREE);
12691
12692 SET_EXPR_LOCATION (wfl, location);
12693 #else
12694 wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12695
12696 EXPR_WFL_LINECOL (wfl) = location;
12697 #endif
12698 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12699 return wfl;
12700 }
12701
12702 /* Build a super() constructor invocation. Returns an empty statement if
12703 we're currently dealing with the class java.lang.Object. */
12704
12705 static tree
12706 build_super_invocation (tree mdecl)
12707 {
12708 if (DECL_CONTEXT (mdecl) == object_type_node)
12709 return build_java_empty_stmt ();
12710 else
12711 {
12712 tree super_wfl = build_wfl_node (super_identifier_node);
12713 tree a = NULL_TREE, t;
12714
12715 /* This is called after parsing is done, so the parser context
12716 won't be accurate. Set location info from current_class decl. */
12717 tree class_wfl = lookup_cl (TYPE_NAME (current_class));
12718 EXPR_WFL_LINECOL (super_wfl) = EXPR_WFL_LINECOL (class_wfl);
12719
12720 /* If we're dealing with an anonymous class, pass the arguments
12721 of the crafted constructor along. */
12722 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12723 {
12724 SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12725 for (; t != end_params_node; t = TREE_CHAIN (t))
12726 a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12727 }
12728 return build_method_invocation (super_wfl, a);
12729 }
12730 }
12731
12732 /* Build a SUPER/THIS qualified method invocation. */
12733
12734 static tree
12735 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12736 int lloc, int rloc)
12737 {
12738 tree invok;
12739 tree wfl =
12740 build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12741 EXPR_WFL_LINECOL (wfl) = lloc;
12742 invok = build_method_invocation (name, args);
12743 return make_qualified_primary (wfl, invok, rloc);
12744 }
12745
12746 /* Build an incomplete CALL_EXPR node. */
12747
12748 static tree
12749 build_method_invocation (tree name, tree args)
12750 {
12751 tree call = build3 (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12752 TREE_SIDE_EFFECTS (call) = 1;
12753 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12754 return call;
12755 }
12756
12757 /* Build an incomplete new xxx(...) node. */
12758
12759 static tree
12760 build_new_invocation (tree name, tree args)
12761 {
12762 tree call = build3 (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12763 TREE_SIDE_EFFECTS (call) = 1;
12764 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12765 return call;
12766 }
12767
12768 /* Build an incomplete assignment expression. */
12769
12770 static tree
12771 build_assignment (int op, int op_location, tree lhs, tree rhs)
12772 {
12773 tree assignment;
12774 /* Build the corresponding binop if we deal with a Compound
12775 Assignment operator. Mark the binop sub-tree as part of a
12776 Compound Assignment expression */
12777 if (op != ASSIGN_TK)
12778 {
12779 rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12780 COMPOUND_ASSIGN_P (rhs) = 1;
12781 }
12782 assignment = build2 (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12783 TREE_SIDE_EFFECTS (assignment) = 1;
12784 EXPR_WFL_LINECOL (assignment) = op_location;
12785 return assignment;
12786 }
12787
12788 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12789 the buffer. This is used only for string conversion. */
12790 static char *
12791 string_convert_int_cst (tree node)
12792 {
12793 /* Long.MIN_VALUE is -9223372036854775808, 20 characters. */
12794 static char buffer[21];
12795
12796 unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12797 unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12798 char *p = buffer + sizeof (buffer);
12799 int neg = 0;
12800
12801 unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12802 << (HOST_BITS_PER_WIDE_INT - 1));
12803
12804 *--p = '\0';
12805
12806 /* If negative, note the fact and negate the value. */
12807 if ((hi & hibit))
12808 {
12809 lo = ~lo;
12810 hi = ~hi;
12811 if (++lo == 0)
12812 ++hi;
12813 neg = 1;
12814 }
12815
12816 /* Divide by 10 until there are no bits left. */
12817 do
12818 {
12819 unsigned HOST_WIDE_INT acc = 0;
12820 unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12821 unsigned int i;
12822
12823 /* Use long division to compute the result and the remainder. */
12824 for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12825 {
12826 /* Shift a bit into accumulator. */
12827 acc <<= 1;
12828 if ((hi & hibit))
12829 acc |= 1;
12830
12831 /* Shift the value. */
12832 hi <<= 1;
12833 if ((lo & hibit))
12834 hi |= 1;
12835 lo <<= 1;
12836
12837 /* Shift the correct bit into the result. */
12838 outhi <<= 1;
12839 if ((outlo & hibit))
12840 outhi |= 1;
12841 outlo <<= 1;
12842 if (acc >= 10)
12843 {
12844 acc -= 10;
12845 outlo |= 1;
12846 }
12847 }
12848
12849 /* '0' == 060 in Java, but might not be here (think EBCDIC). */
12850 *--p = '\060' + acc;
12851
12852 hi = outhi;
12853 lo = outlo;
12854 }
12855 while (hi || lo);
12856
12857 if (neg)
12858 *--p = '\055'; /* '-' == 055 in Java, but might not be here. */
12859
12860 return p;
12861 }
12862
12863 /* Print an INTEGER_CST node in a static buffer, and return the
12864 buffer. This is used only for error handling. */
12865 char *
12866 print_int_node (tree node)
12867 {
12868 static char buffer [80];
12869 if (TREE_CONSTANT_OVERFLOW (node))
12870 sprintf (buffer, "<overflow>");
12871
12872 if (TREE_INT_CST_HIGH (node) == 0)
12873 sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12874 TREE_INT_CST_LOW (node));
12875 else if (TREE_INT_CST_HIGH (node) == -1
12876 && TREE_INT_CST_LOW (node) != 0)
12877 sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12878 -TREE_INT_CST_LOW (node));
12879 else
12880 sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12881 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12882
12883 return buffer;
12884 }
12885
12886 \f
12887 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12888 context. */
12889
12890 /* 15.25 Assignment operators. */
12891
12892 static tree
12893 patch_assignment (tree node, tree wfl_op1)
12894 {
12895 tree rhs = TREE_OPERAND (node, 1);
12896 tree lvalue = TREE_OPERAND (node, 0), llvalue;
12897 tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12898 int error_found = 0;
12899 int lvalue_from_array = 0;
12900 int is_return = 0;
12901
12902 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12903
12904 /* Lhs can be a named variable */
12905 if (JDECL_P (lvalue))
12906 {
12907 lhs_type = TREE_TYPE (lvalue);
12908 }
12909 /* Or Lhs can be an array access. */
12910 else if (TREE_CODE (lvalue) == ARRAY_REF)
12911 {
12912 lhs_type = TREE_TYPE (lvalue);
12913 lvalue_from_array = 1;
12914 }
12915 /* Or a field access */
12916 else if (TREE_CODE (lvalue) == COMPONENT_REF)
12917 lhs_type = TREE_TYPE (lvalue);
12918 /* Or a function return slot */
12919 else if (TREE_CODE (lvalue) == RESULT_DECL)
12920 {
12921 /* If the return type is an integral type, then we create the
12922 RESULT_DECL with a promoted type, but we need to do these
12923 checks against the unpromoted type to ensure type safety. So
12924 here we look at the real type, not the type of the decl we
12925 are modifying. */
12926 lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12927 is_return = 1;
12928 }
12929 /* Otherwise, we might want to try to write into an optimized static
12930 final, this is an of a different nature, reported further on. */
12931 else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12932 && resolve_expression_name (wfl_op1, &llvalue))
12933 {
12934 lhs_type = TREE_TYPE (lvalue);
12935 }
12936 else
12937 {
12938 parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12939 error_found = 1;
12940 }
12941
12942 rhs_type = TREE_TYPE (rhs);
12943
12944 /* 5.1 Try the assignment conversion for builtin type. */
12945 new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12946
12947 /* 5.2 If it failed, try a reference conversion */
12948 if (!new_rhs)
12949 new_rhs = try_reference_assignconv (lhs_type, rhs);
12950
12951 /* 15.25.2 If we have a compound assignment, convert RHS into the
12952 type of the LHS */
12953 else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12954 new_rhs = convert (lhs_type, rhs);
12955
12956 /* Explicit cast required. This is an error */
12957 if (!new_rhs)
12958 {
12959 char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12960 char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12961 tree wfl;
12962 char operation [32]; /* Max size known */
12963
12964 /* If the assignment is part of a declaration, we use the WFL of
12965 the declared variable to point out the error and call it a
12966 declaration problem. If the assignment is a genuine =
12967 operator, we call is a operator `=' problem, otherwise we
12968 call it an assignment problem. In both of these last cases,
12969 we use the WFL of the operator to indicate the error. */
12970
12971 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12972 {
12973 wfl = wfl_op1;
12974 strcpy (operation, "declaration");
12975 }
12976 else
12977 {
12978 wfl = wfl_operator;
12979 if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12980 strcpy (operation, "assignment");
12981 else if (is_return)
12982 strcpy (operation, "'return'");
12983 else
12984 strcpy (operation, "'='");
12985 }
12986
12987 if (!valid_cast_to_p (rhs_type, lhs_type))
12988 parse_error_context
12989 (wfl, "Incompatible type for %s. Can't convert %qs to %qs",
12990 operation, t1, t2);
12991 else
12992 parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert %qs to %qs",
12993 operation, t1, t2);
12994 free (t1); free (t2);
12995 error_found = 1;
12996 }
12997
12998 if (error_found)
12999 return error_mark_node;
13000
13001 /* If we're processing a `return' statement, promote the actual type
13002 to the promoted type. */
13003 if (is_return)
13004 new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
13005
13006 /* 10.10: Array Store Exception runtime check */
13007 if (!flag_emit_class_files
13008 && lvalue_from_array
13009 && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
13010 {
13011 tree array, store_check, base, index_expr;
13012
13013 /* Save RHS so that it doesn't get re-evaluated by the store check. */
13014 new_rhs = save_expr (new_rhs);
13015
13016 /* Get the INDIRECT_REF. */
13017 array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
13018 /* Get the array pointer expr. */
13019 array = TREE_OPERAND (array, 0);
13020 store_check = build_java_arraystore_check (array, new_rhs);
13021
13022 index_expr = TREE_OPERAND (lvalue, 1);
13023
13024 if (TREE_CODE (index_expr) == COMPOUND_EXPR)
13025 {
13026 /* A COMPOUND_EXPR here is a bounds check. The bounds check must
13027 happen before the store check, so prepare to insert the store
13028 check within the second operand of the existing COMPOUND_EXPR. */
13029 base = index_expr;
13030 }
13031 else
13032 base = lvalue;
13033
13034 index_expr = TREE_OPERAND (base, 1);
13035 TREE_OPERAND (base, 1) = build2 (COMPOUND_EXPR, TREE_TYPE (index_expr),
13036 store_check, index_expr);
13037 }
13038
13039 /* Final locals can be used as case values in switch
13040 statement. Prepare them for this eventuality. */
13041 if (TREE_CODE (lvalue) == VAR_DECL
13042 && DECL_FINAL (lvalue)
13043 && TREE_CONSTANT (new_rhs)
13044 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
13045 && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
13046 )
13047 {
13048 TREE_CONSTANT (lvalue) = 1;
13049 TREE_INVARIANT (lvalue) = 1;
13050 DECL_INITIAL (lvalue) = new_rhs;
13051 }
13052
13053 /* Copy the rhs if it's a reference. */
13054 if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
13055 {
13056 switch (TREE_CODE (new_rhs))
13057 {
13058 case ARRAY_REF:
13059 case INDIRECT_REF:
13060 case COMPONENT_REF:
13061 /* Transform a = foo.bar
13062 into a = ({int tmp; tmp = foo.bar;}).
13063 We need to ensure that if a read from memory fails
13064 because of a NullPointerException, a destination variable
13065 will remain unchanged. An explicit temporary does what
13066 we need.
13067
13068 If flag_check_references is set, this is unnecessary
13069 because we'll check each reference before doing any
13070 reads. If optimize is not set the result will never be
13071 written to a stack slot that contains the LHS. */
13072 {
13073 tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
13074 TREE_TYPE (new_rhs));
13075 tree block = make_node (BLOCK);
13076 tree assignment
13077 = build2 (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
13078 DECL_CONTEXT (tmp) = current_function_decl;
13079 TREE_TYPE (block) = TREE_TYPE (new_rhs);
13080 BLOCK_VARS (block) = tmp;
13081 BLOCK_EXPR_BODY (block) = assignment;
13082 TREE_SIDE_EFFECTS (block) = 1;
13083 new_rhs = block;
13084 }
13085 break;
13086 default:
13087 break;
13088 }
13089 }
13090
13091 TREE_OPERAND (node, 0) = lvalue;
13092 TREE_OPERAND (node, 1) = new_rhs;
13093 TREE_TYPE (node) = lhs_type;
13094 return node;
13095 }
13096
13097 /* Check that type SOURCE can be cast into type DEST. If the cast
13098 can't occur at all, return NULL; otherwise, return a possibly
13099 modified rhs. */
13100
13101 static tree
13102 try_reference_assignconv (tree lhs_type, tree rhs)
13103 {
13104 tree new_rhs = NULL_TREE;
13105 tree rhs_type = TREE_TYPE (rhs);
13106
13107 if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
13108 {
13109 /* `null' may be assigned to any reference type */
13110 if (rhs == null_pointer_node)
13111 new_rhs = null_pointer_node;
13112 /* Try the reference assignment conversion */
13113 else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
13114 new_rhs = rhs;
13115 /* This is a magic assignment that we process differently */
13116 else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
13117 new_rhs = rhs;
13118 }
13119 return new_rhs;
13120 }
13121
13122 /* Check that RHS can be converted into LHS_TYPE by the assignment
13123 conversion (5.2), for the cases of RHS being a builtin type. Return
13124 NULL_TREE if the conversion fails or if because RHS isn't of a
13125 builtin type. Return a converted RHS if the conversion is possible. */
13126
13127 static tree
13128 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
13129 {
13130 tree new_rhs = NULL_TREE;
13131 tree rhs_type = TREE_TYPE (rhs);
13132
13133 /* Handle boolean specially. */
13134 if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
13135 || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
13136 {
13137 if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
13138 && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
13139 new_rhs = rhs;
13140 }
13141
13142 /* 5.1.1 Try Identity Conversion,
13143 5.1.2 Try Widening Primitive Conversion */
13144 else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
13145 new_rhs = convert (lhs_type, rhs);
13146
13147 /* Try a narrowing primitive conversion (5.1.3):
13148 - expression is a constant expression of type byte, short, char,
13149 or int, AND
13150 - variable is byte, short or char AND
13151 - The value of the expression is representable in the type of the
13152 variable */
13153 else if ((rhs_type == byte_type_node || rhs_type == short_type_node
13154 || rhs_type == char_type_node || rhs_type == int_type_node)
13155 && TREE_CONSTANT (rhs)
13156 && (lhs_type == byte_type_node || lhs_type == char_type_node
13157 || lhs_type == short_type_node))
13158 {
13159 if (int_fits_type_p (rhs, lhs_type))
13160 new_rhs = convert (lhs_type, rhs);
13161 else if (wfl_op1) /* Might be called with a NULL */
13162 parse_warning_context
13163 (wfl_op1,
13164 "Constant expression %qs too wide for narrowing primitive conversion to %qs",
13165 print_int_node (rhs), lang_printable_name (lhs_type, 0));
13166 /* Reported a warning that will turn into an error further
13167 down, so we don't return */
13168 }
13169
13170 return new_rhs;
13171 }
13172
13173 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
13174 conversion (5.1.1) or widening primitive conversion (5.1.2). Return
13175 0 is the conversion test fails. This implements parts the method
13176 invocation conversion (5.3). */
13177
13178 static int
13179 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
13180 {
13181 /* 5.1.1: This is the identity conversion part. */
13182 if (lhs_type == rhs_type)
13183 return 1;
13184
13185 /* Reject non primitive types and boolean conversions. */
13186 if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
13187 return 0;
13188
13189 /* 5.1.2: widening primitive conversion. byte, even if it's smaller
13190 than a char can't be converted into a char. Short can't too, but
13191 the < test below takes care of that */
13192 if (lhs_type == char_type_node && rhs_type == byte_type_node)
13193 return 0;
13194
13195 /* Accept all promoted type here. Note, we can't use <= in the test
13196 below, because we still need to bounce out assignments of short
13197 to char and the likes */
13198 if (lhs_type == int_type_node
13199 && (rhs_type == promoted_byte_type_node
13200 || rhs_type == promoted_short_type_node
13201 || rhs_type == promoted_char_type_node
13202 || rhs_type == promoted_boolean_type_node))
13203 return 1;
13204
13205 /* From here, an integral is widened if its precision is smaller
13206 than the precision of the LHS or if the LHS is a floating point
13207 type, or the RHS is a float and the RHS a double. */
13208 if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
13209 && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
13210 || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
13211 || (rhs_type == float_type_node && lhs_type == double_type_node))
13212 return 1;
13213
13214 return 0;
13215 }
13216
13217 /* Check that something of SOURCE type can be assigned or cast to
13218 something of DEST type at runtime. Return 1 if the operation is
13219 valid, 0 otherwise. If CAST is set to 1, we're treating the case
13220 were SOURCE is cast into DEST, which borrows a lot of the
13221 assignment check. */
13222
13223 static int
13224 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
13225 {
13226 /* SOURCE or DEST might be null if not from a declared entity. */
13227 if (!source || !dest)
13228 return 0;
13229 if (JNULLP_TYPE_P (source))
13230 return 1;
13231 if (TREE_CODE (source) == POINTER_TYPE)
13232 source = TREE_TYPE (source);
13233 if (TREE_CODE (dest) == POINTER_TYPE)
13234 dest = TREE_TYPE (dest);
13235
13236 /* If source and dest are being compiled from bytecode, they may need to
13237 be loaded. */
13238 if (CLASS_P (source) && !CLASS_LOADED_P (source))
13239 {
13240 load_class (source, 1);
13241 safe_layout_class (source);
13242 }
13243 if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
13244 {
13245 load_class (dest, 1);
13246 safe_layout_class (dest);
13247 }
13248
13249 /* Case where SOURCE is a class type */
13250 if (TYPE_CLASS_P (source))
13251 {
13252 if (TYPE_CLASS_P (dest))
13253 return (source == dest
13254 || inherits_from_p (source, dest)
13255 || (cast && inherits_from_p (dest, source)));
13256 if (TYPE_INTERFACE_P (dest))
13257 {
13258 /* If doing a cast and SOURCE is final, the operation is
13259 always correct a compile time (because even if SOURCE
13260 does not implement DEST, a subclass of SOURCE might). */
13261 if (cast && !CLASS_FINAL (TYPE_NAME (source)))
13262 return 1;
13263 /* Otherwise, SOURCE must implement DEST */
13264 return interface_of_p (dest, source);
13265 }
13266 /* DEST is an array, cast permitted if SOURCE is of Object type */
13267 return (cast && source == object_type_node ? 1 : 0);
13268 }
13269 if (TYPE_INTERFACE_P (source))
13270 {
13271 if (TYPE_CLASS_P (dest))
13272 {
13273 /* If not casting, DEST must be the Object type */
13274 if (!cast)
13275 return dest == object_type_node;
13276 /* We're doing a cast. The cast is always valid is class
13277 DEST is not final, otherwise, DEST must implement SOURCE */
13278 else if (!CLASS_FINAL (TYPE_NAME (dest)))
13279 return 1;
13280 else
13281 return interface_of_p (source, dest);
13282 }
13283 if (TYPE_INTERFACE_P (dest))
13284 {
13285 /* If doing a cast, then if SOURCE and DEST contain method
13286 with the same signature but different return type, then
13287 this is a (compile time) error */
13288 if (cast)
13289 {
13290 tree method_source, method_dest;
13291 tree source_type;
13292 tree source_sig;
13293 tree source_name;
13294 for (method_source = TYPE_METHODS (source); method_source;
13295 method_source = TREE_CHAIN (method_source))
13296 {
13297 source_sig =
13298 build_java_argument_signature (TREE_TYPE (method_source));
13299 source_type = TREE_TYPE (TREE_TYPE (method_source));
13300 source_name = DECL_NAME (method_source);
13301 for (method_dest = TYPE_METHODS (dest);
13302 method_dest; method_dest = TREE_CHAIN (method_dest))
13303 if (source_sig ==
13304 build_java_argument_signature (TREE_TYPE (method_dest))
13305 && source_name == DECL_NAME (method_dest)
13306 && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13307 return 0;
13308 }
13309 return 1;
13310 }
13311 else
13312 return source == dest || interface_of_p (dest, source);
13313 }
13314 else
13315 {
13316 /* Array */
13317 return (cast
13318 && (DECL_NAME (TYPE_NAME (source))
13319 == java_lang_cloneable_identifier_node
13320 || (DECL_NAME (TYPE_NAME (source))
13321 == java_io_serializable_identifier_node)));
13322 }
13323 }
13324 if (TYPE_ARRAY_P (source))
13325 {
13326 if (TYPE_CLASS_P (dest))
13327 return dest == object_type_node;
13328 /* Can't cast an array to an interface unless the interface is
13329 java.lang.Cloneable or java.io.Serializable. */
13330 if (TYPE_INTERFACE_P (dest))
13331 return (DECL_NAME (TYPE_NAME (dest))
13332 == java_lang_cloneable_identifier_node
13333 || (DECL_NAME (TYPE_NAME (dest))
13334 == java_io_serializable_identifier_node));
13335 else /* Arrays */
13336 {
13337 tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13338 tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13339
13340 /* In case of severe errors, they turn out null */
13341 if (!dest_element_type || !source_element_type)
13342 return 0;
13343 if (source_element_type == dest_element_type)
13344 return 1;
13345 return valid_ref_assignconv_cast_p (source_element_type,
13346 dest_element_type, cast);
13347 }
13348 return 0;
13349 }
13350 return 0;
13351 }
13352
13353 static int
13354 valid_cast_to_p (tree source, tree dest)
13355 {
13356 if (TREE_CODE (source) == POINTER_TYPE)
13357 source = TREE_TYPE (source);
13358 if (TREE_CODE (dest) == POINTER_TYPE)
13359 dest = TREE_TYPE (dest);
13360
13361 if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13362 return valid_ref_assignconv_cast_p (source, dest, 1);
13363
13364 else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13365 return 1;
13366
13367 else if (TREE_CODE (source) == BOOLEAN_TYPE
13368 && TREE_CODE (dest) == BOOLEAN_TYPE)
13369 return 1;
13370
13371 return 0;
13372 }
13373
13374 static tree
13375 do_unary_numeric_promotion (tree arg)
13376 {
13377 tree type = TREE_TYPE (arg);
13378 if (TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13379 arg = convert (int_type_node, arg);
13380 return arg;
13381 }
13382
13383 /* Return a nonzero value if SOURCE can be converted into DEST using
13384 the method invocation conversion rule (5.3). */
13385 static int
13386 valid_method_invocation_conversion_p (tree dest, tree source)
13387 {
13388 return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13389 && valid_builtin_assignconv_identity_widening_p (dest, source))
13390 || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13391 && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13392 && valid_ref_assignconv_cast_p (source, dest, 0)));
13393 }
13394
13395 /* Build an incomplete binop expression. */
13396
13397 static tree
13398 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13399 {
13400 tree binop = build2 (op, NULL_TREE, op1, op2);
13401 TREE_SIDE_EFFECTS (binop) = 1;
13402 /* Store the location of the operator, for better error report. The
13403 string of the operator will be rebuild based on the OP value. */
13404 EXPR_WFL_LINECOL (binop) = op_location;
13405 return binop;
13406 }
13407
13408 /* Build the string of the operator retained by NODE. If NODE is part
13409 of a compound expression, add an '=' at the end of the string. This
13410 function is called when an error needs to be reported on an
13411 operator. The string is returned as a pointer to a static character
13412 buffer. */
13413
13414 static char *
13415 operator_string (tree node)
13416 {
13417 #define BUILD_OPERATOR_STRING(S) \
13418 { \
13419 sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13420 return buffer; \
13421 }
13422
13423 static char buffer [10];
13424 switch (TREE_CODE (node))
13425 {
13426 case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13427 case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13428 case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13429 case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13430 case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13431 case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13432 case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13433 case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13434 case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13435 case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13436 case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13437 case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13438 case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13439 case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13440 case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13441 case GT_EXPR: BUILD_OPERATOR_STRING (">");
13442 case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13443 case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13444 case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13445 case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13446 case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13447 case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13448 case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13449 case PREINCREMENT_EXPR: /* Fall through */
13450 case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13451 case PREDECREMENT_EXPR: /* Fall through */
13452 case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13453 default:
13454 internal_error ("unregistered operator %s",
13455 tree_code_name [TREE_CODE (node)]);
13456 }
13457 return NULL;
13458 #undef BUILD_OPERATOR_STRING
13459 }
13460
13461 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
13462
13463 static int
13464 java_decl_equiv (tree var_acc1, tree var_acc2)
13465 {
13466 if (JDECL_P (var_acc1))
13467 return (var_acc1 == var_acc2);
13468
13469 return (TREE_CODE (var_acc1) == COMPONENT_REF
13470 && TREE_CODE (var_acc2) == COMPONENT_REF
13471 && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13472 == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13473 && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13474 }
13475
13476 /* Return a nonzero value if CODE is one of the operators that can be
13477 used in conjunction with the `=' operator in a compound assignment. */
13478
13479 static int
13480 binop_compound_p (enum tree_code code)
13481 {
13482 int i;
13483 for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13484 if (binop_lookup [i] == code)
13485 break;
13486
13487 return i < BINOP_COMPOUND_CANDIDATES;
13488 }
13489
13490 /* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
13491
13492 static tree
13493 java_refold (tree t)
13494 {
13495 tree c, b, ns, decl;
13496
13497 if (TREE_CODE (t) != MODIFY_EXPR)
13498 return t;
13499
13500 c = TREE_OPERAND (t, 1);
13501 if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13502 && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13503 && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13504 return t;
13505
13506 /* Now the left branch of the binary operator. */
13507 b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13508 if (! (b && TREE_CODE (b) == NOP_EXPR
13509 && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13510 return t;
13511
13512 ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13513 if (! (ns && TREE_CODE (ns) == NOP_EXPR
13514 && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13515 return t;
13516
13517 decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13518 if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13519 /* It's got to be the an equivalent decl */
13520 && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13521 {
13522 /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13523 TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13524 /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13525 TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13526 /* Change the right part of the BINOP_EXPR */
13527 TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13528 }
13529
13530 return t;
13531 }
13532
13533 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13534 errors but we modify NODE so that it contains the type computed
13535 according to the expression, when it's fixed. Otherwise, we write
13536 error_mark_node as the type. It allows us to further the analysis
13537 of remaining nodes and detects more errors in certain cases. */
13538
13539 static tree
13540 patch_binop (tree node, tree wfl_op1, tree wfl_op2, int folding)
13541 {
13542 tree op1 = TREE_OPERAND (node, 0);
13543 tree op2 = TREE_OPERAND (node, 1);
13544 tree op1_type = TREE_TYPE (op1);
13545 tree op2_type = TREE_TYPE (op2);
13546 tree prom_type = NULL_TREE, cn;
13547 enum tree_code code = TREE_CODE (node);
13548
13549 /* If 1, tell the routine that we have to return error_mark_node
13550 after checking for the initialization of the RHS */
13551 int error_found = 0;
13552
13553 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13554
13555 /* If either op<n>_type are NULL, this might be early signs of an
13556 error situation, unless it's too early to tell (in case we're
13557 handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13558 correctly so the error can be later on reported accurately. */
13559 if (! (code == PLUS_EXPR || code == NE_EXPR
13560 || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13561 {
13562 tree n;
13563 if (! op1_type)
13564 {
13565 n = java_complete_tree (op1);
13566 op1_type = TREE_TYPE (n);
13567 }
13568 if (! op2_type)
13569 {
13570 n = java_complete_tree (op2);
13571 op2_type = TREE_TYPE (n);
13572 }
13573 }
13574
13575 switch (code)
13576 {
13577 /* 15.16 Multiplicative operators */
13578 case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
13579 case RDIV_EXPR: /* 15.16.2 Division Operator / */
13580 case TRUNC_DIV_EXPR: /* 15.16.2 Integral type Division Operator / */
13581 case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
13582 if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13583 {
13584 if (!JNUMERIC_TYPE_P (op1_type))
13585 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13586 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13587 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13588 TREE_TYPE (node) = error_mark_node;
13589 error_found = 1;
13590 break;
13591 }
13592 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13593
13594 /* Detect integral division by zero */
13595 if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13596 && TREE_CODE (prom_type) == INTEGER_TYPE
13597 && (op2 == integer_zero_node || op2 == long_zero_node ||
13598 (TREE_CODE (op2) == INTEGER_CST &&
13599 ! TREE_INT_CST_LOW (op2) && ! TREE_INT_CST_HIGH (op2))))
13600 {
13601 parse_warning_context
13602 (wfl_operator,
13603 "Evaluating this expression will result in an arithmetic exception being thrown");
13604 TREE_CONSTANT (node) = 0;
13605 TREE_INVARIANT (node) = 0;
13606 }
13607
13608 /* Change the division operator if necessary */
13609 if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13610 TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13611
13612 /* Before divisions as is disappear, try to simplify and bail if
13613 applicable, otherwise we won't perform even simple
13614 simplifications like (1-1)/3. We can't do that with floating
13615 point number, folds can't handle them at this stage. */
13616 if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13617 && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13618 {
13619 TREE_TYPE (node) = prom_type;
13620 node = fold (node);
13621 if (TREE_CODE (node) != code)
13622 return node;
13623 }
13624
13625 if (TREE_CODE (prom_type) == INTEGER_TYPE
13626 && flag_use_divide_subroutine
13627 && ! flag_emit_class_files
13628 && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13629 return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13630
13631 /* This one is more complicated. FLOATs are processed by a
13632 function call to soft_fmod. Duplicate the value of the
13633 COMPOUND_ASSIGN_P flag. */
13634 if (code == TRUNC_MOD_EXPR)
13635 {
13636 tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13637 COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13638 return mod;
13639 }
13640 break;
13641
13642 /* 15.17 Additive Operators */
13643 case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
13644
13645 /* Operation is valid if either one argument is a string
13646 constant, a String object or a StringBuffer crafted for the
13647 purpose of the a previous usage of the String concatenation
13648 operator */
13649
13650 if (TREE_CODE (op1) == STRING_CST
13651 || TREE_CODE (op2) == STRING_CST
13652 || JSTRING_TYPE_P (op1_type)
13653 || JSTRING_TYPE_P (op2_type)
13654 || IS_CRAFTED_STRING_BUFFER_P (op1)
13655 || IS_CRAFTED_STRING_BUFFER_P (op2))
13656 return build_string_concatenation (op1, op2);
13657
13658 case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
13659 Numeric Types */
13660 if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13661 {
13662 if (!JNUMERIC_TYPE_P (op1_type))
13663 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13664 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13665 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13666 TREE_TYPE (node) = error_mark_node;
13667 error_found = 1;
13668 break;
13669 }
13670 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13671 break;
13672
13673 /* 15.18 Shift Operators */
13674 case LSHIFT_EXPR:
13675 case RSHIFT_EXPR:
13676 case URSHIFT_EXPR:
13677 if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13678 {
13679 if (!JINTEGRAL_TYPE_P (op1_type))
13680 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13681 else
13682 {
13683 if (JNUMERIC_TYPE_P (op2_type))
13684 parse_error_context (wfl_operator,
13685 "Incompatible type for %qs. Explicit cast needed to convert shift distance from %qs to integral",
13686 operator_string (node),
13687 lang_printable_name (op2_type, 0));
13688 else
13689 parse_error_context (wfl_operator,
13690 "Incompatible type for %qs. Can't convert shift distance from %qs to integral",
13691 operator_string (node),
13692 lang_printable_name (op2_type, 0));
13693 }
13694 TREE_TYPE (node) = error_mark_node;
13695 error_found = 1;
13696 break;
13697 }
13698
13699 /* Unary numeric promotion (5.6.1) is performed on each operand
13700 separately */
13701 op1 = do_unary_numeric_promotion (op1);
13702 op2 = do_unary_numeric_promotion (op2);
13703
13704 /* If the right hand side is of type `long', first cast it to
13705 `int'. */
13706 if (TREE_TYPE (op2) == long_type_node)
13707 op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13708
13709 /* The type of the shift expression is the type of the promoted
13710 type of the left-hand operand */
13711 prom_type = TREE_TYPE (op1);
13712
13713 /* Shift int only up to 0x1f and long up to 0x3f */
13714 if (prom_type == int_type_node)
13715 op2 = fold_build2 (BIT_AND_EXPR, int_type_node, op2,
13716 build_int_cst (NULL_TREE, 0x1f));
13717 else
13718 op2 = fold_build2 (BIT_AND_EXPR, int_type_node, op2,
13719 build_int_cst (NULL_TREE, 0x3f));
13720
13721 /* The >>> operator is a >> operating on unsigned quantities */
13722 if (code == URSHIFT_EXPR && (folding || ! flag_emit_class_files))
13723 {
13724 tree to_return;
13725 tree utype = java_unsigned_type (prom_type);
13726 op1 = convert (utype, op1);
13727
13728 to_return = fold_build2 (RSHIFT_EXPR, utype, op1, op2);
13729 to_return = convert (prom_type, to_return);
13730 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13731 COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13732 TREE_SIDE_EFFECTS (to_return)
13733 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13734 return to_return;
13735 }
13736 break;
13737
13738 /* 15.19.1 Type Comparison Operator instanceof */
13739 case INSTANCEOF_EXPR:
13740
13741 TREE_TYPE (node) = boolean_type_node;
13742
13743 /* OP1_TYPE might be NULL when OP1 is a string constant. */
13744 if ((cn = patch_string (op1)))
13745 {
13746 op1 = cn;
13747 op1_type = TREE_TYPE (op1);
13748 }
13749 if (op1_type == NULL_TREE)
13750 abort ();
13751
13752 if (!(op2_type = resolve_type_during_patch (op2)))
13753 return error_mark_node;
13754
13755 /* The first operand must be a reference type or the null type */
13756 if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13757 error_found = 1; /* Error reported further below */
13758
13759 /* The second operand must be a reference type */
13760 if (!JREFERENCE_TYPE_P (op2_type))
13761 {
13762 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13763 parse_error_context
13764 (wfl_operator, "Invalid argument %qs for %<instanceof%>",
13765 lang_printable_name (op2_type, 0));
13766 error_found = 1;
13767 }
13768
13769 if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13770 {
13771 /* If the first operand is null, the result is always false */
13772 if (op1 == null_pointer_node)
13773 return boolean_false_node;
13774 else if (flag_emit_class_files)
13775 {
13776 TREE_OPERAND (node, 1) = op2_type;
13777 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13778 return node;
13779 }
13780 /* Otherwise we have to invoke instance of to figure it out */
13781 else
13782 return build_instanceof (op1, op2_type);
13783 }
13784 /* There is no way the expression operand can be an instance of
13785 the type operand. This is a compile time error. */
13786 else
13787 {
13788 char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13789 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13790 parse_error_context
13791 (wfl_operator, "Impossible for %qs to be instance of %qs",
13792 t1, lang_printable_name (op2_type, 0));
13793 free (t1);
13794 error_found = 1;
13795 }
13796
13797 break;
13798
13799 /* 15.21 Bitwise and Logical Operators */
13800 case BIT_AND_EXPR:
13801 case BIT_XOR_EXPR:
13802 case BIT_IOR_EXPR:
13803 if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13804 /* Binary numeric promotion is performed on both operand and the
13805 expression retain that type */
13806 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13807
13808 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13809 && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13810 /* The type of the bitwise operator expression is BOOLEAN */
13811 prom_type = boolean_type_node;
13812 else
13813 {
13814 if (!JINTEGRAL_TYPE_P (op1_type))
13815 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13816 if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13817 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13818 TREE_TYPE (node) = error_mark_node;
13819 error_found = 1;
13820 /* Insert a break here if adding thing before the switch's
13821 break for this case */
13822 }
13823 break;
13824
13825 /* 15.22 Conditional-And Operator */
13826 case TRUTH_ANDIF_EXPR:
13827 /* 15.23 Conditional-Or Operator */
13828 case TRUTH_ORIF_EXPR:
13829 /* Operands must be of BOOLEAN type */
13830 if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13831 TREE_CODE (op2_type) != BOOLEAN_TYPE)
13832 {
13833 if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13834 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13835 if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13836 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13837 TREE_TYPE (node) = boolean_type_node;
13838 error_found = 1;
13839 break;
13840 }
13841 else if (integer_zerop (op1))
13842 {
13843 return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13844 }
13845 else if (integer_onep (op1))
13846 {
13847 return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13848 }
13849 /* The type of the conditional operators is BOOLEAN */
13850 prom_type = boolean_type_node;
13851 break;
13852
13853 /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13854 case LT_EXPR:
13855 case GT_EXPR:
13856 case LE_EXPR:
13857 case GE_EXPR:
13858 /* The type of each of the operands must be a primitive numeric
13859 type */
13860 if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13861 {
13862 if (!JNUMERIC_TYPE_P (op1_type))
13863 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13864 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13865 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13866 TREE_TYPE (node) = boolean_type_node;
13867 error_found = 1;
13868 break;
13869 }
13870 /* Binary numeric promotion is performed on the operands */
13871 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13872 /* The type of the relation expression is always BOOLEAN */
13873 prom_type = boolean_type_node;
13874 break;
13875
13876 /* 15.20 Equality Operator */
13877 case EQ_EXPR:
13878 case NE_EXPR:
13879 /* It's time for us to patch the strings. */
13880 if ((cn = patch_string (op1)))
13881 {
13882 op1 = cn;
13883 op1_type = TREE_TYPE (op1);
13884 }
13885 if ((cn = patch_string (op2)))
13886 {
13887 op2 = cn;
13888 op2_type = TREE_TYPE (op2);
13889 }
13890
13891 /* 15.20.1 Numerical Equality Operators == and != */
13892 /* Binary numeric promotion is performed on the operands */
13893 if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13894 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13895
13896 /* 15.20.2 Boolean Equality Operators == and != */
13897 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13898 TREE_CODE (op2_type) == BOOLEAN_TYPE)
13899 ; /* Nothing to do here */
13900
13901 /* 15.20.3 Reference Equality Operators == and != */
13902 /* Types have to be either references or the null type. If
13903 they're references, it must be possible to convert either
13904 type to the other by casting conversion. */
13905 else if ((op1 == null_pointer_node && op2 == null_pointer_node)
13906 || (op1 == null_pointer_node && JREFERENCE_TYPE_P (op2_type))
13907 || (JREFERENCE_TYPE_P (op1_type) && op2 == null_pointer_node)
13908 || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13909 && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13910 || valid_ref_assignconv_cast_p (op2_type,
13911 op1_type, 1))))
13912 ; /* Nothing to do here */
13913
13914 /* Else we have an error figure what can't be converted into
13915 what and report the error */
13916 else
13917 {
13918 char *t1;
13919 t1 = xstrdup (lang_printable_name (op1_type, 0));
13920 parse_error_context
13921 (wfl_operator,
13922 "Incompatible type for %qs. Can't convert %qs to %qs",
13923 operator_string (node), t1,
13924 lang_printable_name (op2_type, 0));
13925 free (t1);
13926 TREE_TYPE (node) = boolean_type_node;
13927 error_found = 1;
13928 break;
13929 }
13930 prom_type = boolean_type_node;
13931 break;
13932 default:
13933 abort ();
13934 }
13935
13936 if (error_found)
13937 return error_mark_node;
13938
13939 TREE_OPERAND (node, 0) = op1;
13940 TREE_OPERAND (node, 1) = op2;
13941 TREE_TYPE (node) = prom_type;
13942 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13943
13944 /* fold does not respect side-effect order as required for Java but not C.
13945 * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13946 * bytecode.
13947 */
13948 if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13949 : ! TREE_SIDE_EFFECTS (node))
13950 node = fold (node);
13951 return node;
13952 }
13953
13954 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13955 zero value, the value of CSTE comes after the valude of STRING */
13956
13957 static tree
13958 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13959 {
13960 const char *old = TREE_STRING_POINTER (cste);
13961 int old_len = TREE_STRING_LENGTH (cste);
13962 int len = old_len + string_len;
13963 char *new = alloca (len+1);
13964
13965 if (after)
13966 {
13967 memcpy (new, string, string_len);
13968 memcpy (&new [string_len], old, old_len);
13969 }
13970 else
13971 {
13972 memcpy (new, old, old_len);
13973 memcpy (&new [old_len], string, string_len);
13974 }
13975 new [len] = '\0';
13976 return build_string (len, new);
13977 }
13978
13979 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13980 new STRING_CST on success, NULL_TREE on failure. */
13981
13982 static tree
13983 merge_string_cste (tree op1, tree op2, int after)
13984 {
13985 /* Handle two string constants right away. */
13986 if (TREE_CODE (op2) == STRING_CST)
13987 return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13988 TREE_STRING_LENGTH (op2), after);
13989
13990 /* Reasonable integer constant can be treated right away. */
13991 if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13992 {
13993 static const char *const boolean_true = "true";
13994 static const char *const boolean_false = "false";
13995 static const char *const null_pointer = "null";
13996 char ch[4];
13997 const char *string;
13998
13999 if (op2 == boolean_true_node)
14000 string = boolean_true;
14001 else if (op2 == boolean_false_node)
14002 string = boolean_false;
14003 else if (op2 == null_pointer_node
14004 || (integer_zerop (op2)
14005 && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
14006 /* FIXME: null is not a compile-time constant, so it is only safe to
14007 merge if the overall expression is non-constant. However, this
14008 code always merges without checking the overall expression. */
14009 string = null_pointer;
14010 else if (TREE_TYPE (op2) == char_type_node)
14011 {
14012 /* Convert the character into UTF-8. */
14013 unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
14014 unsigned char *p = (unsigned char *) ch;
14015 if (0x01 <= c && c <= 0x7f)
14016 *p++ = (unsigned char) c;
14017 else if (c < 0x7ff)
14018 {
14019 *p++ = (unsigned char) (c >> 6 | 0xc0);
14020 *p++ = (unsigned char) ((c & 0x3f) | 0x80);
14021 }
14022 else
14023 {
14024 *p++ = (unsigned char) (c >> 12 | 0xe0);
14025 *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
14026 *p++ = (unsigned char) ((c & 0x3f) | 0x80);
14027 }
14028 *p = '\0';
14029
14030 string = ch;
14031 }
14032 else
14033 string = string_convert_int_cst (op2);
14034
14035 return do_merge_string_cste (op1, string, strlen (string), after);
14036 }
14037 return NULL_TREE;
14038 }
14039
14040 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
14041 has to be a STRING_CST and the other part must be a STRING_CST or a
14042 INTEGRAL constant. Return a new STRING_CST if the operation
14043 succeed, NULL_TREE otherwise.
14044
14045 If the case we want to optimize for space, we might want to return
14046 NULL_TREE for each invocation of this routine. FIXME */
14047
14048 static tree
14049 string_constant_concatenation (tree op1, tree op2)
14050 {
14051 if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
14052 {
14053 tree string, rest;
14054 int invert;
14055
14056 string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
14057 rest = (string == op1 ? op2 : op1);
14058 invert = (string == op1 ? 0 : 1 );
14059
14060 /* Walk REST, only if it looks reasonable */
14061 if (TREE_CODE (rest) != STRING_CST
14062 && !IS_CRAFTED_STRING_BUFFER_P (rest)
14063 && !JSTRING_TYPE_P (TREE_TYPE (rest))
14064 && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
14065 {
14066 rest = java_complete_tree (rest);
14067 if (rest == error_mark_node)
14068 return error_mark_node;
14069 rest = fold (rest);
14070 }
14071 return merge_string_cste (string, rest, invert);
14072 }
14073 return NULL_TREE;
14074 }
14075
14076 /* Implement the `+' operator. Does static optimization if possible,
14077 otherwise create (if necessary) and append elements to a
14078 StringBuffer. The StringBuffer will be carried around until it is
14079 used for a function call or an assignment. Then toString() will be
14080 called on it to turn it into a String object. */
14081
14082 static tree
14083 build_string_concatenation (tree op1, tree op2)
14084 {
14085 tree result;
14086 int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
14087
14088 /* Try to do some static optimization */
14089 if ((result = string_constant_concatenation (op1, op2)))
14090 return result;
14091
14092 /* Discard empty strings on either side of the expression */
14093 if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
14094 {
14095 op1 = op2;
14096 op2 = NULL_TREE;
14097 }
14098 else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
14099 op2 = NULL_TREE;
14100
14101 /* If operands are string constant, turn then into object references */
14102 if (TREE_CODE (op1) == STRING_CST)
14103 op1 = patch_string_cst (op1);
14104 if (op2 && TREE_CODE (op2) == STRING_CST)
14105 op2 = patch_string_cst (op2);
14106
14107 /* If either one of the constant is null and the other non null
14108 operand is a String constant, return it. */
14109 if ((TREE_CODE (op1) == STRING_CST) && !op2)
14110 return op1;
14111
14112 /* If OP1 isn't already a StringBuffer, create and
14113 initialize a new one */
14114 if (!IS_CRAFTED_STRING_BUFFER_P (op1))
14115 {
14116 /* Two solutions here:
14117 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
14118 2) OP1 is something else, we call new StringBuffer().append(OP1). */
14119 if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
14120 op1 = BUILD_STRING_BUFFER (op1);
14121 else
14122 {
14123 tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
14124 op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
14125 }
14126 }
14127
14128 if (op2)
14129 {
14130 /* OP1 is no longer the last node holding a crafted StringBuffer */
14131 IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
14132 /* Create a node for `{new...,xxx}.append (op2)' */
14133 op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
14134 }
14135
14136 /* Mark the last node holding a crafted StringBuffer */
14137 IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
14138
14139 TREE_SIDE_EFFECTS (op1) = side_effects;
14140 return op1;
14141 }
14142
14143 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
14144 StringBuffer. If no string were found to be patched, return
14145 NULL. */
14146
14147 static tree
14148 patch_string (tree node)
14149 {
14150 if (node == error_mark_node)
14151 return error_mark_node;
14152 if (TREE_CODE (node) == STRING_CST)
14153 return patch_string_cst (node);
14154 else if (IS_CRAFTED_STRING_BUFFER_P (node))
14155 {
14156 int saved = ctxp->explicit_constructor_p;
14157 tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
14158 tree ret;
14159 /* Temporary disable forbid the use of `this'. */
14160 ctxp->explicit_constructor_p = 0;
14161 ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
14162 /* String concatenation arguments must be evaluated in order too. */
14163 ret = force_evaluation_order (ret);
14164 /* Restore it at its previous value */
14165 ctxp->explicit_constructor_p = saved;
14166 return ret;
14167 }
14168 return NULL_TREE;
14169 }
14170
14171 /* Build the internal representation of a string constant. */
14172
14173 static tree
14174 patch_string_cst (tree node)
14175 {
14176 int location;
14177 if (! flag_emit_class_files)
14178 {
14179 node = get_identifier (TREE_STRING_POINTER (node));
14180 location = alloc_name_constant (CONSTANT_String, node);
14181 node = build_ref_from_constant_pool (location);
14182 }
14183 TREE_CONSTANT (node) = 1;
14184 TREE_INVARIANT (node) = 1;
14185
14186 /* ??? Guessing that the class file code can't handle casts. */
14187 if (! flag_emit_class_files)
14188 node = convert (string_ptr_type_node, node);
14189 else
14190 TREE_TYPE (node) = string_ptr_type_node;
14191
14192 return node;
14193 }
14194
14195 /* Build an incomplete unary operator expression. */
14196
14197 static tree
14198 build_unaryop (int op_token, int op_location, tree op1)
14199 {
14200 enum tree_code op;
14201 tree unaryop;
14202 switch (op_token)
14203 {
14204 case PLUS_TK: op = UNARY_PLUS_EXPR; break;
14205 case MINUS_TK: op = NEGATE_EXPR; break;
14206 case NEG_TK: op = TRUTH_NOT_EXPR; break;
14207 case NOT_TK: op = BIT_NOT_EXPR; break;
14208 default: abort ();
14209 }
14210
14211 unaryop = build1 (op, NULL_TREE, op1);
14212 TREE_SIDE_EFFECTS (unaryop) = 1;
14213 /* Store the location of the operator, for better error report. The
14214 string of the operator will be rebuild based on the OP value. */
14215 EXPR_WFL_LINECOL (unaryop) = op_location;
14216 return unaryop;
14217 }
14218
14219 /* Special case for the ++/-- operators, since they require an extra
14220 argument to build, which is set to NULL and patched
14221 later. IS_POST_P is 1 if the operator, 0 otherwise. */
14222
14223 static tree
14224 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
14225 {
14226 static const enum tree_code lookup [2][2] =
14227 {
14228 { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
14229 { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
14230 };
14231 tree node = build2 (lookup [is_post_p][(op_token - DECR_TK)],
14232 NULL_TREE, op1, NULL_TREE);
14233 TREE_SIDE_EFFECTS (node) = 1;
14234 /* Store the location of the operator, for better error report. The
14235 string of the operator will be rebuild based on the OP value. */
14236 EXPR_WFL_LINECOL (node) = op_location;
14237
14238 /* Report an error if the operand is a constant. */
14239 if (TREE_CONSTANT (op1)) {
14240 parse_error_context (node, "%qs cannot be used with a constant",
14241 operator_string (node));
14242 return error_mark_node;
14243 }
14244
14245 return node;
14246 }
14247
14248 /* Build an incomplete cast operator, based on the use of the
14249 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
14250 set. java_complete_tree is trained to walk a CONVERT_EXPR even
14251 though its type is already set. */
14252
14253 static tree
14254 build_cast (int location, tree type, tree exp)
14255 {
14256 tree node = build1 (CONVERT_EXPR, type, exp);
14257 EXPR_WFL_LINECOL (node) = location;
14258 return node;
14259 }
14260
14261 /* Build an incomplete class reference operator. */
14262 static tree
14263 build_incomplete_class_ref (int location, tree class_name)
14264 {
14265 tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
14266 tree class_decl = GET_CPC ();
14267 tree this_class = TREE_TYPE (class_decl);
14268
14269 /* Generate the synthetic static method `class$'. (Previously we
14270 deferred this, causing different method tables to be emitted
14271 for native code and bytecode.) */
14272 if (!TYPE_DOT_CLASS (this_class)
14273 && !JPRIMITIVE_TYPE_P (class_name)
14274 && !(TREE_CODE (class_name) == VOID_TYPE))
14275 {
14276 tree cpc_list = GET_CPC_LIST();
14277 tree cpc = cpc_list;
14278 tree target_class;
14279
14280 /* For inner classes, add a 'class$' method to their outermost
14281 context, creating it if necessary. */
14282
14283 while (GET_NEXT_ENCLOSING_CPC(cpc))
14284 cpc = GET_NEXT_ENCLOSING_CPC(cpc);
14285 class_decl = TREE_VALUE (cpc);
14286
14287 target_class = TREE_TYPE (class_decl);
14288
14289 if (CLASS_INTERFACE (TYPE_NAME (target_class)))
14290 {
14291 /* For interfaces, adding a static 'class$' method directly
14292 is illegal. So create an inner class to contain the new
14293 method. Empirically this matches the behavior of javac. */
14294 tree t, inner;
14295 /* We want the generated inner class inside the outermost class. */
14296 GET_CPC_LIST() = cpc;
14297 t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
14298 inner = create_anonymous_class (t);
14299 target_class = TREE_TYPE (inner);
14300 end_class_declaration (1);
14301 GET_CPC_LIST() = cpc_list;
14302 }
14303
14304 if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
14305 build_dot_class_method (target_class);
14306
14307 if (this_class != target_class)
14308 TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14309 }
14310
14311 EXPR_WFL_LINECOL (node) = location;
14312 return node;
14313 }
14314
14315 /* Complete an incomplete class reference operator. */
14316 static tree
14317 patch_incomplete_class_ref (tree node)
14318 {
14319 tree type = TREE_OPERAND (node, 0);
14320 tree ref_type;
14321
14322 if (!(ref_type = resolve_type_during_patch (type)))
14323 return error_mark_node;
14324
14325 /* If we're not emitting class files and we know ref_type is a
14326 compiled class, build a direct reference. */
14327 if ((! flag_emit_class_files && is_compiled_class (ref_type))
14328 || JPRIMITIVE_TYPE_P (ref_type)
14329 || TREE_CODE (ref_type) == VOID_TYPE)
14330 {
14331 tree dot = build_class_ref (ref_type);
14332 /* A class referenced by `foo.class' is initialized. */
14333 if (!flag_emit_class_files)
14334 dot = build_class_init (ref_type, dot);
14335 return java_complete_tree (dot);
14336 }
14337
14338 /* If we're emitting class files and we have to deal with non
14339 primitive types, we invoke the synthetic static method `class$'. */
14340 ref_type = build_dot_class_method_invocation (current_class, ref_type);
14341 return java_complete_tree (ref_type);
14342 }
14343
14344 /* 15.14 Unary operators. We return error_mark_node in case of error,
14345 but preserve the type of NODE if the type is fixed. */
14346
14347 static tree
14348 patch_unaryop (tree node, tree wfl_op)
14349 {
14350 tree op = TREE_OPERAND (node, 0);
14351 tree op_type = TREE_TYPE (op);
14352 tree prom_type = NULL_TREE, value, decl;
14353 int nested_field_flag = 0;
14354 int code = TREE_CODE (node);
14355 int error_found = 0;
14356
14357 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14358
14359 switch (code)
14360 {
14361 /* 15.13.2 Postfix Increment Operator ++ */
14362 case POSTINCREMENT_EXPR:
14363 /* 15.13.3 Postfix Increment Operator -- */
14364 case POSTDECREMENT_EXPR:
14365 /* 15.14.1 Prefix Increment Operator ++ */
14366 case PREINCREMENT_EXPR:
14367 /* 15.14.2 Prefix Decrement Operator -- */
14368 case PREDECREMENT_EXPR:
14369 op = decl = extract_field_decl (op);
14370 nested_field_flag
14371 = nested_field_expanded_access_p (op, NULL, NULL, NULL);
14372 /* We might be trying to change an outer field accessed using
14373 access method. */
14374 if (nested_field_flag)
14375 {
14376 /* Retrieve the decl of the field we're trying to access. We
14377 do that by first retrieving the function we would call to
14378 access the field. It has been already verified that this
14379 field isn't final */
14380 if (flag_emit_class_files)
14381 decl = TREE_OPERAND (op, 0);
14382 else
14383 decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14384 decl = DECL_FUNCTION_ACCESS_DECL (decl);
14385 }
14386 /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14387 else if (!JDECL_P (decl)
14388 && TREE_CODE (decl) != COMPONENT_REF
14389 && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14390 && TREE_CODE (decl) != INDIRECT_REF
14391 && !(TREE_CODE (decl) == COMPOUND_EXPR
14392 && TREE_OPERAND (decl, 1)
14393 && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14394 {
14395 TREE_TYPE (node) = error_mark_node;
14396 error_found = 1;
14397 }
14398
14399 /* From now on, we know that op is a variable and that it has a
14400 valid wfl. We use wfl_op to locate errors related to the
14401 ++/-- operand. */
14402 if (!JNUMERIC_TYPE_P (op_type))
14403 {
14404 parse_error_context
14405 (wfl_op, "Invalid argument type %qs to %qs",
14406 lang_printable_name (op_type, 0), operator_string (node));
14407 TREE_TYPE (node) = error_mark_node;
14408 error_found = 1;
14409 }
14410 else
14411 {
14412 /* Before the addition, binary numeric promotion is performed on
14413 both operands, if really necessary */
14414 if (JINTEGRAL_TYPE_P (op_type))
14415 {
14416 value = build_int_cst (op_type, 1);
14417 TREE_TYPE (node) = op_type;
14418 }
14419 else
14420 {
14421 value = build_int_cst (NULL_TREE, 1);
14422 TREE_TYPE (node) =
14423 binary_numeric_promotion (op_type,
14424 TREE_TYPE (value), &op, &value);
14425 }
14426
14427 /* We remember we might be accessing an outer field */
14428 if (nested_field_flag)
14429 {
14430 /* We re-generate an access to the field */
14431 value = build2 (PLUS_EXPR, TREE_TYPE (op),
14432 build_nested_field_access (wfl_op, decl), value);
14433
14434 /* And we patch the original access$() into a write
14435 with plus_op as a rhs */
14436 return nested_field_access_fix (node, op, value);
14437 }
14438
14439 /* And write back into the node. */
14440 TREE_OPERAND (node, 0) = op;
14441 TREE_OPERAND (node, 1) = value;
14442 /* Convert the overall back into its original type, if
14443 necessary, and return */
14444 if (JINTEGRAL_TYPE_P (op_type))
14445 return fold (node);
14446 else
14447 return fold (convert (op_type, node));
14448 }
14449 break;
14450
14451 /* 15.14.3 Unary Plus Operator + */
14452 case UNARY_PLUS_EXPR:
14453 /* 15.14.4 Unary Minus Operator - */
14454 case NEGATE_EXPR:
14455 if (!JNUMERIC_TYPE_P (op_type))
14456 {
14457 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14458 TREE_TYPE (node) = error_mark_node;
14459 error_found = 1;
14460 }
14461 /* Unary numeric promotion is performed on operand */
14462 else
14463 {
14464 op = do_unary_numeric_promotion (op);
14465 prom_type = TREE_TYPE (op);
14466 if (code == UNARY_PLUS_EXPR)
14467 return fold (op);
14468 }
14469 break;
14470
14471 /* 15.14.5 Bitwise Complement Operator ~ */
14472 case BIT_NOT_EXPR:
14473 if (!JINTEGRAL_TYPE_P (op_type))
14474 {
14475 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14476 TREE_TYPE (node) = error_mark_node;
14477 error_found = 1;
14478 }
14479 else
14480 {
14481 op = do_unary_numeric_promotion (op);
14482 prom_type = TREE_TYPE (op);
14483 }
14484 break;
14485
14486 /* 15.14.6 Logical Complement Operator ! */
14487 case TRUTH_NOT_EXPR:
14488 if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14489 {
14490 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14491 /* But the type is known. We will report an error if further
14492 attempt of a assignment is made with this rhs */
14493 TREE_TYPE (node) = boolean_type_node;
14494 error_found = 1;
14495 }
14496 else
14497 prom_type = boolean_type_node;
14498 break;
14499
14500 /* 15.15 Cast Expression */
14501 case CONVERT_EXPR:
14502 value = patch_cast (node, wfl_operator);
14503 if (value == error_mark_node)
14504 {
14505 /* If this cast is part of an assignment, we tell the code
14506 that deals with it not to complain about a mismatch,
14507 because things have been cast, anyways */
14508 TREE_TYPE (node) = error_mark_node;
14509 error_found = 1;
14510 }
14511 else
14512 {
14513 value = fold (value);
14514 return value;
14515 }
14516 break;
14517
14518 case NOP_EXPR:
14519 /* This can only happen when the type is already known. */
14520 gcc_assert (TREE_TYPE (node) != NULL_TREE);
14521 prom_type = TREE_TYPE (node);
14522 break;
14523 }
14524
14525 if (error_found)
14526 return error_mark_node;
14527
14528 /* There are cases where node has been replaced by something else
14529 and we don't end up returning here: UNARY_PLUS_EXPR,
14530 CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14531 TREE_OPERAND (node, 0) = fold (op);
14532 TREE_TYPE (node) = prom_type;
14533 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14534 return fold (node);
14535 }
14536
14537 /* Generic type resolution that sometimes takes place during node
14538 patching. Returned the resolved type or generate an error
14539 message. Return the resolved type or NULL_TREE. */
14540
14541 static tree
14542 resolve_type_during_patch (tree type)
14543 {
14544 if (unresolved_type_p (type, NULL))
14545 {
14546 tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14547 if (!type_decl)
14548 {
14549 parse_error_context (type,
14550 "Class %qs not found in type declaration",
14551 IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14552 return NULL_TREE;
14553 }
14554
14555 check_deprecation (type, type_decl);
14556
14557 return TREE_TYPE (type_decl);
14558 }
14559 return type;
14560 }
14561
14562 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14563 found. Otherwise NODE or something meant to replace it is returned. */
14564
14565 static tree
14566 patch_cast (tree node, tree wfl_op)
14567 {
14568 tree op = TREE_OPERAND (node, 0);
14569 tree cast_type = TREE_TYPE (node);
14570 tree patched, op_type;
14571 char *t1;
14572
14573 /* Some string patching might be necessary at this stage */
14574 if ((patched = patch_string (op)))
14575 TREE_OPERAND (node, 0) = op = patched;
14576 op_type = TREE_TYPE (op);
14577
14578 /* First resolve OP_TYPE if unresolved */
14579 if (!(cast_type = resolve_type_during_patch (cast_type)))
14580 return error_mark_node;
14581
14582 /* Check on cast that are proven correct at compile time */
14583 if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14584 {
14585 /* Same type */
14586 if (cast_type == op_type)
14587 return node;
14588
14589 /* A narrowing conversion from a floating-point number to an
14590 integral type requires special handling (5.1.3). */
14591 if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14592 if (cast_type != long_type_node)
14593 op = convert (integer_type_node, op);
14594
14595 /* Try widening/narrowing conversion. Potentially, things need
14596 to be worked out in gcc so we implement the extreme cases
14597 correctly. fold_convert() needs to be fixed. */
14598 return convert (cast_type, op);
14599 }
14600
14601 /* It's also valid to cast a boolean into a boolean */
14602 if (op_type == boolean_type_node && cast_type == boolean_type_node)
14603 return node;
14604
14605 /* null can be casted to references */
14606 if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14607 return build_null_of_type (cast_type);
14608
14609 /* The remaining legal casts involve conversion between reference
14610 types. Check for their compile time correctness. */
14611 if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14612 && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14613 {
14614 TREE_TYPE (node) = promote_type (cast_type);
14615 /* Now, the case can be determined correct at compile time if
14616 OP_TYPE can be converted into CAST_TYPE by assignment
14617 conversion (5.2) */
14618
14619 if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14620 {
14621 TREE_SET_CODE (node, NOP_EXPR);
14622 return node;
14623 }
14624
14625 if (flag_emit_class_files)
14626 {
14627 TREE_SET_CODE (node, CONVERT_EXPR);
14628 return node;
14629 }
14630
14631 /* The cast requires a run-time check */
14632 return build3 (CALL_EXPR, promote_type (cast_type),
14633 build_address_of (soft_checkcast_node),
14634 tree_cons (NULL_TREE, build_class_ref (cast_type),
14635 build_tree_list (NULL_TREE, op)),
14636 NULL_TREE);
14637 }
14638
14639 /* Any other casts are proven incorrect at compile time */
14640 t1 = xstrdup (lang_printable_name (op_type, 0));
14641 parse_error_context (wfl_op, "Invalid cast from %qs to %qs",
14642 t1, lang_printable_name (cast_type, 0));
14643 free (t1);
14644 return error_mark_node;
14645 }
14646
14647 /* Build a null constant and give it the type TYPE. */
14648
14649 static tree
14650 build_null_of_type (tree type)
14651 {
14652 tree node = build_int_cst (promote_type (type), 0);
14653 return node;
14654 }
14655
14656 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14657 a list of indices. */
14658 static tree
14659 build_array_ref (int location, tree array, tree index)
14660 {
14661 tree node = build4 (ARRAY_REF, NULL_TREE, array, index,
14662 NULL_TREE, NULL_TREE);
14663 EXPR_WFL_LINECOL (node) = location;
14664 return node;
14665 }
14666
14667 /* 15.12 Array Access Expression */
14668
14669 static tree
14670 patch_array_ref (tree node)
14671 {
14672 tree array = TREE_OPERAND (node, 0);
14673 tree array_type = TREE_TYPE (array);
14674 tree index = TREE_OPERAND (node, 1);
14675 tree index_type = TREE_TYPE (index);
14676 int error_found = 0;
14677
14678 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14679
14680 if (TREE_CODE (array_type) == POINTER_TYPE)
14681 array_type = TREE_TYPE (array_type);
14682
14683 /* The array reference must be an array */
14684 if (!TYPE_ARRAY_P (array_type))
14685 {
14686 parse_error_context
14687 (wfl_operator,
14688 "%<[]%> can only be applied to arrays. It can't be applied to %qs",
14689 lang_printable_name (array_type, 0));
14690 TREE_TYPE (node) = error_mark_node;
14691 error_found = 1;
14692 }
14693
14694 /* The array index undergoes unary numeric promotion. The promoted
14695 type must be int */
14696 index = do_unary_numeric_promotion (index);
14697 if (TREE_TYPE (index) != int_type_node)
14698 {
14699 if (valid_cast_to_p (index_type, int_type_node))
14700 parse_error_context (wfl_operator,
14701 "Incompatible type for %<[]%>. Explicit cast needed to convert %qs to %<int%>",
14702 lang_printable_name (index_type, 0));
14703 else
14704 parse_error_context (wfl_operator,
14705 "Incompatible type for %<[]%>. Can't convert %qs to %<int%>",
14706 lang_printable_name (index_type, 0));
14707 TREE_TYPE (node) = error_mark_node;
14708 error_found = 1;
14709 }
14710
14711 if (error_found)
14712 return error_mark_node;
14713
14714 array_type = TYPE_ARRAY_ELEMENT (array_type);
14715
14716 if (flag_emit_class_files)
14717 {
14718 TREE_OPERAND (node, 0) = array;
14719 TREE_OPERAND (node, 1) = index;
14720 }
14721 else
14722 node = build_java_arrayaccess (array, array_type, index);
14723 TREE_TYPE (node) = array_type;
14724 return node;
14725 }
14726
14727 /* 15.9 Array Creation Expressions */
14728
14729 static tree
14730 build_newarray_node (tree type, tree dims, int extra_dims)
14731 {
14732 tree node = build3 (NEW_ARRAY_EXPR, NULL_TREE, type,
14733 nreverse (dims),
14734 build_int_cst (NULL_TREE, extra_dims));
14735 return node;
14736 }
14737
14738 static tree
14739 patch_newarray (tree node)
14740 {
14741 tree type = TREE_OPERAND (node, 0);
14742 tree dims = TREE_OPERAND (node, 1);
14743 tree cdim, array_type;
14744 int error_found = 0;
14745 int ndims = 0;
14746 int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14747
14748 /* Dimension types are verified. It's better for the types to be
14749 verified in order. */
14750 for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14751 {
14752 int dim_error = 0;
14753 tree dim = TREE_VALUE (cdim);
14754
14755 /* Dim might have been saved during its evaluation */
14756 dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14757
14758 /* The type of each specified dimension must be an integral type. */
14759 if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14760 dim_error = 1;
14761
14762 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14763 promoted type must be int. */
14764 else
14765 {
14766 dim = do_unary_numeric_promotion (dim);
14767 if (TREE_TYPE (dim) != int_type_node)
14768 dim_error = 1;
14769 }
14770
14771 /* Report errors on types here */
14772 if (dim_error)
14773 {
14774 parse_error_context
14775 (TREE_PURPOSE (cdim),
14776 "Incompatible type for dimension in array creation expression. %s convert %qs to %<int%>",
14777 (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14778 "Explicit cast needed to" : "Can't"),
14779 lang_printable_name (TREE_TYPE (dim), 0));
14780 error_found = 1;
14781 }
14782
14783 TREE_PURPOSE (cdim) = NULL_TREE;
14784 }
14785
14786 /* Resolve array base type if unresolved */
14787 if (!(type = resolve_type_during_patch (type)))
14788 error_found = 1;
14789
14790 if (error_found)
14791 {
14792 /* We don't want further evaluation of this bogus array creation
14793 operation */
14794 TREE_TYPE (node) = error_mark_node;
14795 return error_mark_node;
14796 }
14797
14798 /* Set array_type to the actual (promoted) array type of the result. */
14799 if (TREE_CODE (type) == RECORD_TYPE)
14800 type = build_pointer_type (type);
14801 while (--xdims >= 0)
14802 {
14803 type = promote_type (build_java_array_type (type, -1));
14804 }
14805 dims = nreverse (dims);
14806 array_type = type;
14807 for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14808 {
14809 type = array_type;
14810 array_type
14811 = build_java_array_type (type,
14812 TREE_CODE (cdim) == INTEGER_CST
14813 ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14814 : -1);
14815 array_type = promote_type (array_type);
14816 }
14817 dims = nreverse (dims);
14818
14819 /* The node is transformed into a function call. Things are done
14820 differently according to the number of dimensions. If the number
14821 of dimension is equal to 1, then the nature of the base type
14822 (primitive or not) matters. */
14823 if (ndims == 1)
14824 return build_new_array (type, TREE_VALUE (dims));
14825
14826 /* Can't reuse what's already written in expr.c because it uses the
14827 JVM stack representation. Provide a build_multianewarray. FIXME */
14828 return build3 (CALL_EXPR, array_type,
14829 build_address_of (soft_multianewarray_node),
14830 tree_cons (NULL_TREE,
14831 build_class_ref (TREE_TYPE (array_type)),
14832 tree_cons (NULL_TREE,
14833 build_int_cst (NULL_TREE, ndims),
14834 dims)),
14835 NULL_TREE);
14836 }
14837
14838 /* 10.6 Array initializer. */
14839
14840 /* Build a wfl for array element that don't have one, so we can
14841 pin-point errors. */
14842
14843 static tree
14844 maybe_build_array_element_wfl (tree node)
14845 {
14846 if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14847 {
14848 /* FIXME - old code used "prev_lc.line" and "elc.prev_col */
14849 return build_expr_wfl (NULL_TREE,
14850 #ifdef USE_MAPPED_LOCATION
14851 input_location
14852 #else
14853 ctxp->filename,
14854 ctxp->lexer->token_start.line,
14855 ctxp->lexer->token_start.col
14856 #endif
14857 );
14858 }
14859 else
14860 return NULL_TREE;
14861 }
14862
14863 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14864 identification of initialized arrays easier to detect during walk
14865 and expansion. */
14866
14867 static tree
14868 build_new_array_init (int location, tree values)
14869 {
14870 tree constructor = build_constructor_from_list (NULL_TREE,
14871 nreverse (values));
14872 tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14873 EXPR_WFL_LINECOL (to_return) = location;
14874 return to_return;
14875 }
14876
14877 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14878 occurred. Otherwise return NODE after having set its type
14879 appropriately. */
14880
14881 static tree
14882 patch_new_array_init (tree type, tree node)
14883 {
14884 int error_seen = 0;
14885 tree element_type;
14886 unsigned HOST_WIDE_INT length;
14887 constructor_elt *current;
14888 int all_constant = 1;
14889 tree init = TREE_OPERAND (node, 0);
14890
14891 if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14892 {
14893 parse_error_context (node,
14894 "Invalid array initializer for non-array type %qs",
14895 lang_printable_name (type, 1));
14896 return error_mark_node;
14897 }
14898 type = TREE_TYPE (type);
14899 element_type = TYPE_ARRAY_ELEMENT (type);
14900
14901 for (length = 0;
14902 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init),
14903 length, current);
14904 length++)
14905 {
14906 tree elt = current->value;
14907 if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14908 {
14909 error_seen |= array_constructor_check_entry (element_type, current);
14910 elt = current->value;
14911 /* When compiling to native code, STRING_CST is converted to
14912 INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14913 if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14914 all_constant = 0;
14915 }
14916 else
14917 {
14918 current->value = patch_new_array_init (element_type, elt);
14919 current->index = NULL_TREE;
14920 all_constant = 0;
14921 }
14922 if (elt && TREE_CODE (elt) == TREE_LIST
14923 && TREE_VALUE (elt) == error_mark_node)
14924 error_seen = 1;
14925 }
14926
14927 if (error_seen)
14928 return error_mark_node;
14929
14930 /* Create a new type. We can't reuse the one we have here by
14931 patching its dimension because it originally is of dimension -1
14932 hence reused by gcc. This would prevent triangular arrays. */
14933 type = build_java_array_type (element_type, length);
14934 TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14935 TREE_TYPE (node) = promote_type (type);
14936 TREE_CONSTANT (init) = all_constant;
14937 TREE_INVARIANT (init) = all_constant;
14938 TREE_CONSTANT (node) = all_constant;
14939 TREE_INVARIANT (node) = all_constant;
14940 return node;
14941 }
14942
14943 /* Verify that one entry of the initializer element list can be
14944 assigned to the array base type. Report 1 if an error occurred, 0
14945 otherwise. */
14946
14947 static int
14948 array_constructor_check_entry (tree type, constructor_elt *entry)
14949 {
14950 char *array_type_string = NULL; /* For error reports */
14951 tree value, type_value, new_value, wfl_value, patched;
14952 int error_seen = 0;
14953
14954 new_value = NULL_TREE;
14955 wfl_value = entry->value;
14956
14957 value = java_complete_tree (entry->value);
14958 /* patch_string return error_mark_node if arg is error_mark_node */
14959 if ((patched = patch_string (value)))
14960 value = patched;
14961 if (value == error_mark_node)
14962 return 1;
14963
14964 type_value = TREE_TYPE (value);
14965
14966 /* At anytime, try_builtin_assignconv can report a warning on
14967 constant overflow during narrowing. */
14968 SET_WFL_OPERATOR (wfl_operator, entry->index, wfl_value);
14969 new_value = try_builtin_assignconv (wfl_operator, type, value);
14970 if (!new_value && (new_value = try_reference_assignconv (type, value)))
14971 type_value = promote_type (type);
14972
14973 /* Check and report errors */
14974 if (!new_value)
14975 {
14976 const char *const msg = (!valid_cast_to_p (type_value, type) ?
14977 "Can't" : "Explicit cast needed to");
14978 if (!array_type_string)
14979 array_type_string = xstrdup (lang_printable_name (type, 1));
14980 parse_error_context
14981 (wfl_operator, "Incompatible type for array. %s convert %qs to %qs",
14982 msg, lang_printable_name (type_value, 1), array_type_string);
14983 error_seen = 1;
14984 }
14985
14986 if (new_value)
14987 entry->value = new_value;
14988
14989 if (array_type_string)
14990 free (array_type_string);
14991
14992 entry->index = NULL_TREE;
14993 return error_seen;
14994 }
14995
14996 static tree
14997 build_this (int location)
14998 {
14999 tree node = build_wfl_node (this_identifier_node);
15000 TREE_SET_CODE (node, THIS_EXPR);
15001 EXPR_WFL_LINECOL (node) = location;
15002 return node;
15003 }
15004
15005 /* 14.15 The return statement. It builds a modify expression that
15006 assigns the returned value to the RESULT_DECL that hold the value
15007 to be returned. */
15008
15009 static tree
15010 build_return (int location, tree op)
15011 {
15012 tree node = build1 (RETURN_EXPR, NULL_TREE, op);
15013 EXPR_WFL_LINECOL (node) = location;
15014 node = build_debugable_stmt (location, node);
15015 return node;
15016 }
15017
15018 static tree
15019 patch_return (tree node)
15020 {
15021 tree return_exp = TREE_OPERAND (node, 0);
15022 tree meth = current_function_decl;
15023 tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
15024 int error_found = 0;
15025
15026 TREE_TYPE (node) = error_mark_node;
15027 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15028
15029 /* It's invalid to have a return value within a function that is
15030 declared with the keyword void or that is a constructor */
15031 if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
15032 error_found = 1;
15033
15034 /* It's invalid to use a return statement in a static block */
15035 if (DECL_CLINIT_P (current_function_decl))
15036 error_found = 1;
15037
15038 /* It's invalid to have a no return value within a function that
15039 isn't declared with the keyword `void' */
15040 if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
15041 error_found = 2;
15042
15043 if (DECL_INSTINIT_P (current_function_decl))
15044 error_found = 1;
15045
15046 if (error_found)
15047 {
15048 if (DECL_INSTINIT_P (current_function_decl))
15049 parse_error_context (wfl_operator,
15050 "%<return%> inside instance initializer");
15051
15052 else if (DECL_CLINIT_P (current_function_decl))
15053 parse_error_context (wfl_operator,
15054 "%<return%> inside static initializer");
15055
15056 else if (!DECL_CONSTRUCTOR_P (meth))
15057 {
15058 char *t = xstrdup (lang_printable_name (mtype, 0));
15059 parse_error_context (wfl_operator,
15060 "%<return%> with%s value from %<%s %s%>",
15061 (error_found == 1 ? "" : "out"),
15062 t, lang_printable_name (meth, 2));
15063 free (t);
15064 }
15065 else
15066 parse_error_context (wfl_operator,
15067 "%<return%> with value from constructor %qs",
15068 lang_printable_name (meth, 2));
15069 return error_mark_node;
15070 }
15071
15072 /* If we have a return_exp, build a modify expression and expand
15073 it. Note: at that point, the assignment is declared valid, but we
15074 may want to carry some more hacks */
15075 if (return_exp)
15076 {
15077 tree exp = java_complete_tree (return_exp);
15078 tree modify, patched;
15079
15080 if ((patched = patch_string (exp)))
15081 exp = patched;
15082
15083 modify = build2 (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
15084 EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
15085 modify = java_complete_tree (modify);
15086
15087 if (modify != error_mark_node)
15088 {
15089 TREE_SIDE_EFFECTS (modify) = 1;
15090 TREE_OPERAND (node, 0) = modify;
15091 }
15092 else
15093 return error_mark_node;
15094 }
15095 TREE_TYPE (node) = void_type_node;
15096 TREE_SIDE_EFFECTS (node) = 1;
15097 return node;
15098 }
15099
15100 /* 14.8 The if Statement */
15101
15102 static tree
15103 build_if_else_statement (int location, tree expression, tree if_body,
15104 tree else_body)
15105 {
15106 tree node;
15107 if (!else_body)
15108 else_body = build_java_empty_stmt ();
15109 node = build3 (COND_EXPR, NULL_TREE, expression, if_body, else_body);
15110 EXPR_WFL_LINECOL (node) = location;
15111 node = build_debugable_stmt (location, node);
15112 return node;
15113 }
15114
15115 static tree
15116 patch_if_else_statement (tree node)
15117 {
15118 tree expression = TREE_OPERAND (node, 0);
15119 int can_complete_normally
15120 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15121 | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
15122
15123 TREE_TYPE (node) = error_mark_node;
15124 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15125
15126 /* The type of expression must be boolean */
15127 if (TREE_TYPE (expression) != boolean_type_node
15128 && TREE_TYPE (expression) != promoted_boolean_type_node)
15129 {
15130 parse_error_context
15131 (wfl_operator,
15132 "Incompatible type for %<if%>. Can't convert %qs to %<boolean%>",
15133 lang_printable_name (TREE_TYPE (expression), 0));
15134 return error_mark_node;
15135 }
15136
15137 TREE_TYPE (node) = void_type_node;
15138 TREE_SIDE_EFFECTS (node) = 1;
15139 CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
15140 return node;
15141 }
15142
15143 /* 14.6 Labeled Statements */
15144
15145 /* Action taken when a labeled statement is parsed. a new
15146 LABELED_BLOCK_EXPR is created. No statement is attached to the
15147 label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
15148
15149 static tree
15150 build_labeled_block (int location, tree label)
15151 {
15152 tree label_name ;
15153 tree label_decl, node;
15154 if (label == NULL_TREE || label == continue_identifier_node)
15155 label_name = label;
15156 else
15157 {
15158 label_name = merge_qualified_name (label_id, label);
15159 /* Issue an error if we try to reuse a label that was previously
15160 declared */
15161 if (IDENTIFIER_LOCAL_VALUE (label_name))
15162 {
15163 EXPR_WFL_LINECOL (wfl_operator) = location;
15164 parse_error_context (wfl_operator,
15165 "Declaration of %qs shadows a previous label declaration",
15166 IDENTIFIER_POINTER (label));
15167 EXPR_WFL_LINECOL (wfl_operator) =
15168 EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
15169 parse_error_context (wfl_operator,
15170 "This is the location of the previous declaration of label %qs",
15171 IDENTIFIER_POINTER (label));
15172 java_error_count--;
15173 }
15174 }
15175
15176 label_decl = create_label_decl (label_name);
15177 node = build2 (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
15178 EXPR_WFL_LINECOL (node) = location;
15179 TREE_SIDE_EFFECTS (node) = 1;
15180 return node;
15181 }
15182
15183 /* A labeled statement LBE is attached a statement. */
15184
15185 static tree
15186 finish_labeled_statement (tree lbe, /* Labeled block expr */
15187 tree statement)
15188 {
15189 /* In anyways, tie the loop to its statement */
15190 LABELED_BLOCK_BODY (lbe) = statement;
15191 pop_labeled_block ();
15192 POP_LABELED_BLOCK ();
15193 return lbe;
15194 }
15195
15196 /* 14.10, 14.11, 14.12 Loop Statements */
15197
15198 /* Create an empty LOOP_EXPR and make it the last in the nested loop
15199 list. */
15200
15201 static tree
15202 build_new_loop (tree loop_body)
15203 {
15204 tree loop = build1 (LOOP_EXPR, NULL_TREE, loop_body);
15205 TREE_SIDE_EFFECTS (loop) = 1;
15206 PUSH_LOOP (loop);
15207 return loop;
15208 }
15209
15210 /* Create a loop body according to the following structure:
15211 COMPOUND_EXPR
15212 COMPOUND_EXPR (loop main body)
15213 EXIT_EXPR (this order is for while/for loops.
15214 LABELED_BLOCK_EXPR the order is reversed for do loops)
15215 LABEL_DECL (a continue occurring here branches at the
15216 BODY end of this labeled block)
15217 INCREMENT (if any)
15218
15219 REVERSED, if nonzero, tells that the loop condition expr comes
15220 after the body, like in the do-while loop.
15221
15222 To obtain a loop, the loop body structure described above is
15223 encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
15224
15225 LABELED_BLOCK_EXPR
15226 LABEL_DECL (use this label to exit the loop)
15227 LOOP_EXPR
15228 <structure described above> */
15229
15230 static tree
15231 build_loop_body (int location, tree condition, int reversed)
15232 {
15233 tree first, second, body;
15234
15235 condition = build1 (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
15236 EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
15237 condition = build_debugable_stmt (location, condition);
15238 TREE_SIDE_EFFECTS (condition) = 1;
15239
15240 body = build_labeled_block (0, continue_identifier_node);
15241 first = (reversed ? body : condition);
15242 second = (reversed ? condition : body);
15243 return build2 (COMPOUND_EXPR, NULL_TREE,
15244 build2 (COMPOUND_EXPR, NULL_TREE, first, second),
15245 build_java_empty_stmt ());
15246 }
15247
15248 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
15249 their order) on the current loop. Unlink the current loop from the
15250 loop list. */
15251
15252 static tree
15253 finish_loop_body (int location, tree condition, tree body, int reversed)
15254 {
15255 tree to_return = ctxp->current_loop;
15256 tree loop_body = LOOP_EXPR_BODY (to_return);
15257 if (condition)
15258 {
15259 tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
15260 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
15261 The real EXIT_EXPR is one operand further. */
15262 EXPR_WFL_LINECOL (cnode) = location;
15263 if (TREE_CODE (cnode) == EXPR_WITH_FILE_LOCATION)
15264 {
15265 cnode = EXPR_WFL_NODE (cnode);
15266 /* This one is for accurate error reports */
15267 EXPR_WFL_LINECOL (cnode) = location;
15268 }
15269 TREE_OPERAND (cnode, 0) = condition;
15270 }
15271 LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
15272 POP_LOOP ();
15273 return to_return;
15274 }
15275
15276 /* Tailored version of finish_loop_body for FOR loops, when FOR
15277 loops feature the condition part */
15278
15279 static tree
15280 finish_for_loop (int location, tree condition, tree update, tree body)
15281 {
15282 /* Put the condition and the loop body in place */
15283 tree loop = finish_loop_body (location, condition, body, 0);
15284 /* LOOP is the current loop which has been now popped of the loop
15285 stack. Mark the update block as reachable and install it. We do
15286 this because the (current interpretation of the) JLS requires
15287 that the update expression be considered reachable even if the
15288 for loop's body doesn't complete normally. */
15289 if (update != NULL_TREE && !IS_EMPTY_STMT (update))
15290 {
15291 tree up2 = update;
15292 if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
15293 up2 = EXPR_WFL_NODE (up2);
15294 /* It is possible for the update expression to be an
15295 EXPR_WFL_NODE wrapping nothing. */
15296 if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
15297 {
15298 /* Try to detect constraint violations. These would be
15299 programming errors somewhere. */
15300 if (! EXPR_P (up2) || TREE_CODE (up2) == LOOP_EXPR)
15301 abort ();
15302 SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
15303 }
15304 }
15305 LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
15306 return loop;
15307 }
15308
15309 /* Try to find the loop a block might be related to. This comprises
15310 the case where the LOOP_EXPR is found as the second operand of a
15311 COMPOUND_EXPR, because the loop happens to have an initialization
15312 part, then expressed as the first operand of the COMPOUND_EXPR. If
15313 the search finds something, 1 is returned. Otherwise, 0 is
15314 returned. The search is assumed to start from a
15315 LABELED_BLOCK_EXPR's block. */
15316
15317 static tree
15318 search_loop (tree statement)
15319 {
15320 if (TREE_CODE (statement) == LOOP_EXPR)
15321 return statement;
15322
15323 if (TREE_CODE (statement) == BLOCK)
15324 statement = BLOCK_SUBBLOCKS (statement);
15325 else
15326 return NULL_TREE;
15327
15328 if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15329 while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15330 statement = TREE_OPERAND (statement, 1);
15331
15332 return (TREE_CODE (statement) == LOOP_EXPR
15333 && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15334 }
15335
15336 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15337 returned otherwise. */
15338
15339 static int
15340 labeled_block_contains_loop_p (tree block, tree loop)
15341 {
15342 if (!block)
15343 return 0;
15344
15345 if (LABELED_BLOCK_BODY (block) == loop)
15346 return 1;
15347
15348 if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15349 return 1;
15350
15351 return 0;
15352 }
15353
15354 /* If the loop isn't surrounded by a labeled statement, create one and
15355 insert LOOP as its body. */
15356
15357 static tree
15358 patch_loop_statement (tree loop)
15359 {
15360 tree loop_label;
15361
15362 TREE_TYPE (loop) = void_type_node;
15363 if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15364 return loop;
15365
15366 loop_label = build_labeled_block (0, NULL_TREE);
15367 /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15368 that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15369 LABELED_BLOCK_BODY (loop_label) = loop;
15370 PUSH_LABELED_BLOCK (loop_label);
15371 return loop_label;
15372 }
15373
15374 /* 14.13, 14.14: break and continue Statements */
15375
15376 /* Build a break or a continue statement. a null NAME indicates an
15377 unlabeled break/continue statement. */
15378
15379 static tree
15380 build_bc_statement (int location, int is_break, tree name)
15381 {
15382 tree break_continue, label_block_expr = NULL_TREE;
15383
15384 if (name)
15385 {
15386 if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15387 (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15388 /* Null means that we don't have a target for this named
15389 break/continue. In this case, we make the target to be the
15390 label name, so that the error can be reported accurately in
15391 patch_bc_statement. */
15392 label_block_expr = EXPR_WFL_NODE (name);
15393 }
15394 /* Unlabeled break/continue will be handled during the
15395 break/continue patch operation */
15396 break_continue = build1 (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr);
15397
15398 IS_BREAK_STMT_P (break_continue) = is_break;
15399 TREE_SIDE_EFFECTS (break_continue) = 1;
15400 EXPR_WFL_LINECOL (break_continue) = location;
15401 break_continue = build_debugable_stmt (location, break_continue);
15402 return break_continue;
15403 }
15404
15405 /* Verification of a break/continue statement. */
15406
15407 static tree
15408 patch_bc_statement (tree node)
15409 {
15410 tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15411 tree labeled_block = ctxp->current_labeled_block;
15412 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15413
15414 /* Having an identifier here means that the target is unknown. */
15415 if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15416 {
15417 parse_error_context (wfl_operator, "No label definition found for %qs",
15418 IDENTIFIER_POINTER (bc_label));
15419 return error_mark_node;
15420 }
15421 if (! IS_BREAK_STMT_P (node))
15422 {
15423 /* It's a continue statement. */
15424 for (;; labeled_block = TREE_CHAIN (labeled_block))
15425 {
15426 if (labeled_block == NULL_TREE)
15427 {
15428 if (bc_label == NULL_TREE)
15429 parse_error_context (wfl_operator,
15430 "%<continue%> must be in loop");
15431 else
15432 parse_error_context
15433 (wfl_operator, "continue label %qs does not name a loop",
15434 IDENTIFIER_POINTER (bc_label));
15435 return error_mark_node;
15436 }
15437 if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15438 == continue_identifier_node)
15439 && (bc_label == NULL_TREE
15440 || TREE_CHAIN (labeled_block) == bc_label))
15441 {
15442 bc_label = labeled_block;
15443 break;
15444 }
15445 }
15446 }
15447 else if (!bc_label)
15448 {
15449 for (;; labeled_block = TREE_CHAIN (labeled_block))
15450 {
15451 if (labeled_block == NULL_TREE)
15452 {
15453 parse_error_context (wfl_operator,
15454 "%<break%> must be in loop or switch");
15455 return error_mark_node;
15456 }
15457 target_stmt = LABELED_BLOCK_BODY (labeled_block);
15458 if (TREE_CODE (target_stmt) == SWITCH_EXPR
15459 || search_loop (target_stmt))
15460 {
15461 bc_label = labeled_block;
15462 break;
15463 }
15464 }
15465 }
15466
15467 EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15468 CAN_COMPLETE_NORMALLY (bc_label) = 1;
15469
15470 /* Our break/continue don't return values. */
15471 TREE_TYPE (node) = void_type_node;
15472 /* Encapsulate the break within a compound statement so that it's
15473 expanded all the times by expand_expr (and not clobbered
15474 sometimes, like after a if statement) */
15475 node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15476 TREE_SIDE_EFFECTS (node) = 1;
15477 return node;
15478 }
15479
15480 /* Process the exit expression belonging to a loop. Its type must be
15481 boolean. */
15482
15483 static tree
15484 patch_exit_expr (tree node)
15485 {
15486 tree expression = TREE_OPERAND (node, 0);
15487 TREE_TYPE (node) = error_mark_node;
15488 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15489
15490 /* The type of expression must be boolean */
15491 if (TREE_TYPE (expression) != boolean_type_node)
15492 {
15493 parse_error_context
15494 (wfl_operator,
15495 "Incompatible type for loop conditional. Can't convert %qs to %<boolean%>",
15496 lang_printable_name (TREE_TYPE (expression), 0));
15497 return error_mark_node;
15498 }
15499 /* Now we know things are allright, invert the condition, fold and
15500 return */
15501 TREE_OPERAND (node, 0) =
15502 fold_build1 (TRUTH_NOT_EXPR, boolean_type_node, expression);
15503
15504 if (! integer_zerop (TREE_OPERAND (node, 0))
15505 && ctxp->current_loop != NULL_TREE
15506 && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15507 CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15508 if (! integer_onep (TREE_OPERAND (node, 0)))
15509 CAN_COMPLETE_NORMALLY (node) = 1;
15510
15511
15512 TREE_TYPE (node) = void_type_node;
15513 return node;
15514 }
15515
15516 /* 14.9 Switch statement */
15517
15518 static tree
15519 patch_switch_statement (tree node)
15520 {
15521 tree se = TREE_OPERAND (node, 0), se_type;
15522 tree save, iter;
15523
15524 /* Complete the switch expression */
15525 se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15526 se_type = TREE_TYPE (se);
15527 /* The type of the switch expression must be char, byte, short or
15528 int */
15529 if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15530 {
15531 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15532 parse_error_context (wfl_operator,
15533 "Incompatible type for %<switch%>. Can't convert %qs to %<int%>",
15534 lang_printable_name (se_type, 0));
15535 /* This is what java_complete_tree will check */
15536 TREE_OPERAND (node, 0) = error_mark_node;
15537 return error_mark_node;
15538 }
15539
15540 /* Save and restore the outer case label list. */
15541 save = case_label_list;
15542 case_label_list = NULL_TREE;
15543
15544 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15545
15546 /* See if we've found a duplicate label. We can't leave this until
15547 code generation, because in `--syntax-only' and `-C' modes we
15548 don't do ordinary code generation. */
15549 for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15550 {
15551 HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15552 tree subiter;
15553 for (subiter = TREE_CHAIN (iter);
15554 subiter != NULL_TREE;
15555 subiter = TREE_CHAIN (subiter))
15556 {
15557 HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15558 if (val == subval)
15559 {
15560 EXPR_WFL_LINECOL (wfl_operator)
15561 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15562 /* The case_label_list is in reverse order, so print the
15563 outer label first. */
15564 parse_error_context (wfl_operator, "duplicate case label: %<"
15565 HOST_WIDE_INT_PRINT_DEC "%>", subval);
15566 EXPR_WFL_LINECOL (wfl_operator)
15567 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15568 parse_error_context (wfl_operator, "original label is here");
15569
15570 break;
15571 }
15572 }
15573 }
15574
15575 case_label_list = save;
15576
15577 /* Ready to return */
15578 if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15579 {
15580 TREE_TYPE (node) = error_mark_node;
15581 return error_mark_node;
15582 }
15583 TREE_TYPE (node) = void_type_node;
15584 TREE_SIDE_EFFECTS (node) = 1;
15585 CAN_COMPLETE_NORMALLY (node)
15586 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15587 || ! SWITCH_HAS_DEFAULT (node);
15588 return node;
15589 }
15590
15591 /* Assertions. */
15592
15593 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15594 might be NULL_TREE. */
15595 static tree
15596 build_assertion (
15597 #ifdef USE_MAPPED_LOCATION
15598 source_location location,
15599 #else
15600 int location,
15601 #endif
15602 tree condition, tree value)
15603 {
15604 tree node;
15605 tree klass = GET_CPC ();
15606
15607 if (! enable_assertions (klass))
15608 {
15609 condition = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15610 boolean_false_node, condition);
15611 if (value == NULL_TREE)
15612 value = build_java_empty_stmt ();
15613 return build_if_else_statement (location, condition,
15614 value, NULL_TREE);
15615 }
15616
15617 if (! CLASS_USES_ASSERTIONS (klass))
15618 {
15619 tree field, classdollar, id, call;
15620 tree class_type = TREE_TYPE (klass);
15621
15622 field = add_field (class_type,
15623 get_identifier ("$assertionsDisabled"),
15624 boolean_type_node,
15625 ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15626 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15627 FIELD_SYNTHETIC (field) = 1;
15628
15629 classdollar = build_incomplete_class_ref (location, class_type);
15630
15631 /* Call CLASS.desiredAssertionStatus(). */
15632 id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15633 call = build3 (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15634 call = make_qualified_primary (classdollar, call, location);
15635 TREE_SIDE_EFFECTS (call) = 1;
15636
15637 /* Invert to obtain !CLASS.desiredAssertionStatus(). This may
15638 seem odd, but we do it to generate code identical to that of
15639 the JDK. */
15640 call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15641 TREE_SIDE_EFFECTS (call) = 1;
15642 DECL_INITIAL (field) = call;
15643
15644 /* Record the initializer in the initializer statement list. */
15645 call = build2 (MODIFY_EXPR, NULL_TREE, field, call);
15646 TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15647 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15648 MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15649
15650 CLASS_USES_ASSERTIONS (klass) = 1;
15651 }
15652
15653 if (value != NULL_TREE)
15654 value = tree_cons (NULL_TREE, value, NULL_TREE);
15655
15656 node = build_wfl_node (get_identifier ("java"));
15657 node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15658 location);
15659 node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15660 location);
15661
15662 node = build3 (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15663 TREE_SIDE_EFFECTS (node) = 1;
15664 /* It is too early to use BUILD_THROW. */
15665 node = build1 (THROW_EXPR, NULL_TREE, node);
15666 TREE_SIDE_EFFECTS (node) = 1;
15667
15668 /* We invert the condition; if we just put NODE as the `else' part
15669 then we generate weird-looking bytecode. */
15670 condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15671 /* Check $assertionsDisabled. */
15672 condition
15673 = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15674 build1 (TRUTH_NOT_EXPR, NULL_TREE,
15675 build_wfl_node (get_identifier ("$assertionsDisabled"))),
15676 condition);
15677 node = build_if_else_statement (location, condition, node, NULL_TREE);
15678 return node;
15679 }
15680
15681 /* 14.18 The try/catch statements */
15682
15683 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15684 catches TYPE and executes CATCH_STMTS. */
15685
15686 static tree
15687 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15688 tree catch_stmts)
15689 {
15690 tree try_block, catch_clause_param, catch_block, catch;
15691
15692 /* First build a try block */
15693 try_block = build_expr_block (try_stmts, NULL_TREE);
15694
15695 /* Build a catch block: we need a catch clause parameter */
15696 if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15697 {
15698 tree catch_type = obtain_incomplete_type (type_or_name);
15699 jdep *dep;
15700 catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15701 register_incomplete_type (JDEP_VARIABLE, type_or_name,
15702 catch_clause_param, catch_type);
15703 dep = CLASSD_LAST (ctxp->classd_list);
15704 JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15705 }
15706 else
15707 catch_clause_param = build_decl (VAR_DECL, wpv_id,
15708 build_pointer_type (type_or_name));
15709
15710 /* And a block */
15711 catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15712
15713 /* Initialize the variable and store in the block */
15714 catch = build2 (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15715 build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15716 add_stmt_to_block (catch_block, NULL_TREE, catch);
15717
15718 /* Add the catch statements */
15719 add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15720
15721 /* Now we can build a JAVA_CATCH_EXPR */
15722 catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
15723
15724 return build_try_statement (location, try_block, catch_block);
15725 }
15726
15727 static tree
15728 build_try_statement (int location, tree try_block, tree catches)
15729 {
15730 tree node = build2 (TRY_EXPR, NULL_TREE, try_block, catches);
15731 EXPR_WFL_LINECOL (node) = location;
15732 return node;
15733 }
15734
15735 static tree
15736 build_try_finally_statement (int location, tree try_block, tree finally)
15737 {
15738 tree node = build2 (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15739 EXPR_WFL_LINECOL (node) = location;
15740 return node;
15741 }
15742
15743 static tree
15744 patch_try_statement (tree node)
15745 {
15746 int error_found = 0;
15747 tree try = TREE_OPERAND (node, 0);
15748 /* Exception handlers are considered in left to right order */
15749 tree catch = nreverse (TREE_OPERAND (node, 1));
15750 tree current, caught_type_list = NULL_TREE;
15751
15752 /* Check catch clauses, if any. Every time we find an error, we try
15753 to process the next catch clause. We process the catch clause before
15754 the try block so that when processing the try block we can check thrown
15755 exceptions against the caught type list. */
15756 for (current = catch; current; current = TREE_CHAIN (current))
15757 {
15758 tree carg_decl, carg_type;
15759 tree sub_current, catch_block, catch_clause;
15760 int unreachable;
15761
15762 /* At this point, the structure of the catch clause is
15763 JAVA_CATCH_EXPR (catch node)
15764 BLOCK (with the decl of the parameter)
15765 COMPOUND_EXPR
15766 MODIFY_EXPR (assignment of the catch parameter)
15767 BLOCK (catch clause block)
15768 */
15769 catch_clause = TREE_OPERAND (current, 0);
15770 carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15771 carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15772
15773 /* Catch clauses can't have more than one parameter declared,
15774 but it's already enforced by the grammar. Make sure that the
15775 only parameter of the clause statement in of class Throwable
15776 or a subclass of Throwable, but that was done earlier. The
15777 catch clause parameter type has also been resolved. */
15778
15779 /* Just make sure that the catch clause parameter type inherits
15780 from java.lang.Throwable */
15781 if (!inherits_from_p (carg_type, throwable_type_node))
15782 {
15783 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15784 parse_error_context (wfl_operator,
15785 "Can't catch class %qs. Catch clause parameter type must be a subclass of class %<java.lang.Throwable%>",
15786 lang_printable_name (carg_type, 0));
15787 error_found = 1;
15788 continue;
15789 }
15790
15791 /* Partial check for unreachable catch statement: The catch
15792 clause is reachable iff is no earlier catch block A in
15793 the try statement such that the type of the catch
15794 clause's parameter is the same as or a subclass of the
15795 type of A's parameter */
15796 unreachable = 0;
15797 for (sub_current = catch;
15798 sub_current != current; sub_current = TREE_CHAIN (sub_current))
15799 {
15800 tree sub_catch_clause, decl;
15801 sub_catch_clause = TREE_OPERAND (sub_current, 0);
15802 decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15803
15804 if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15805 {
15806 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15807 parse_error_context
15808 (wfl_operator,
15809 "%<catch%> not reached because of the catch clause at line %d",
15810 EXPR_WFL_LINENO (sub_current));
15811 unreachable = error_found = 1;
15812 break;
15813 }
15814 }
15815 /* Complete the catch clause block */
15816 catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15817 if (catch_block == error_mark_node)
15818 {
15819 error_found = 1;
15820 continue;
15821 }
15822 if (CAN_COMPLETE_NORMALLY (catch_block))
15823 CAN_COMPLETE_NORMALLY (node) = 1;
15824 TREE_OPERAND (current, 0) = catch_block;
15825
15826 if (unreachable)
15827 continue;
15828
15829 /* Things to do here: the exception must be thrown */
15830
15831 /* Link this type to the caught type list */
15832 caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15833 }
15834
15835 PUSH_EXCEPTIONS (caught_type_list);
15836 if ((try = java_complete_tree (try)) == error_mark_node)
15837 error_found = 1;
15838 if (CAN_COMPLETE_NORMALLY (try))
15839 CAN_COMPLETE_NORMALLY (node) = 1;
15840 POP_EXCEPTIONS ();
15841
15842 /* Verification ends here */
15843 if (error_found)
15844 return error_mark_node;
15845
15846 TREE_OPERAND (node, 0) = try;
15847 TREE_OPERAND (node, 1) = catch;
15848 TREE_TYPE (node) = void_type_node;
15849 return node;
15850 }
15851
15852 /* 14.17 The synchronized Statement */
15853
15854 static tree
15855 patch_synchronized_statement (tree node, tree wfl_op1)
15856 {
15857 tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15858 tree block = TREE_OPERAND (node, 1);
15859
15860 tree tmp, enter, exit, expr_decl, assignment;
15861
15862 if (expr == error_mark_node)
15863 {
15864 block = java_complete_tree (block);
15865 return expr;
15866 }
15867
15868 /* We might be trying to synchronize on a STRING_CST */
15869 if ((tmp = patch_string (expr)))
15870 expr = tmp;
15871
15872 /* The TYPE of expr must be a reference type */
15873 if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15874 {
15875 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15876 parse_error_context (wfl_operator, "Incompatible type for %<synchronized%>. Can't convert %qs to %<java.lang.Object%>",
15877 lang_printable_name (TREE_TYPE (expr), 0));
15878 return error_mark_node;
15879 }
15880
15881 /* Generate a try-finally for the synchronized statement, except
15882 that the handler that catches all throw exception calls
15883 _Jv_MonitorExit and then rethrow the exception.
15884 The synchronized statement is then implemented as:
15885 TRY
15886 {
15887 _Jv_MonitorEnter (expression)
15888 synchronized_block
15889 _Jv_MonitorExit (expression)
15890 }
15891 CATCH_ALL
15892 {
15893 e = _Jv_exception_info ();
15894 _Jv_MonitorExit (expression)
15895 Throw (e);
15896 } */
15897
15898 expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15899 BUILD_MONITOR_ENTER (enter, expr_decl);
15900 BUILD_MONITOR_EXIT (exit, expr_decl);
15901 CAN_COMPLETE_NORMALLY (enter) = 1;
15902 CAN_COMPLETE_NORMALLY (exit) = 1;
15903 assignment = build2 (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15904 TREE_SIDE_EFFECTS (assignment) = 1;
15905 node = build2 (COMPOUND_EXPR, NULL_TREE,
15906 build2 (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15907 build2 (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15908 node = build_expr_block (node, expr_decl);
15909
15910 return java_complete_tree (node);
15911 }
15912
15913 /* 14.16 The throw Statement */
15914
15915 static tree
15916 patch_throw_statement (tree node, tree wfl_op1)
15917 {
15918 tree expr = TREE_OPERAND (node, 0);
15919 tree type = TREE_TYPE (expr);
15920 int unchecked_ok = 0, tryblock_throws_ok = 0;
15921
15922 /* Thrown expression must be assignable to java.lang.Throwable */
15923 if (!try_reference_assignconv (throwable_type_node, expr))
15924 {
15925 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15926 parse_error_context (wfl_operator,
15927 "Can't throw %qs; it must be a subclass of class %<java.lang.Throwable%>",
15928 lang_printable_name (type, 0));
15929 /* If the thrown expression was a reference, we further the
15930 compile-time check. */
15931 if (!JREFERENCE_TYPE_P (type))
15932 return error_mark_node;
15933 }
15934
15935 /* At least one of the following must be true */
15936
15937 /* The type of the throw expression is a not checked exception,
15938 i.e. is a unchecked expression. */
15939 unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15940
15941 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15942 /* An instance can't throw a checked exception unless that exception
15943 is explicitly declared in the `throws' clause of each
15944 constructor. This doesn't apply to anonymous classes, since they
15945 don't have declared constructors. */
15946 if (!unchecked_ok
15947 && DECL_INSTINIT_P (current_function_decl)
15948 && !ANONYMOUS_CLASS_P (current_class))
15949 {
15950 tree current;
15951 for (current = TYPE_METHODS (current_class); current;
15952 current = TREE_CHAIN (current))
15953 if (DECL_CONSTRUCTOR_P (current)
15954 && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15955 {
15956 parse_error_context (wfl_operator, "Checked exception %qs can't be thrown in instance initializer (not all declared constructor are declaring it in their %<throws%> clause)",
15957 lang_printable_name (TREE_TYPE (expr), 0));
15958 return error_mark_node;
15959 }
15960 }
15961
15962 /* Throw is contained in a try statement and at least one catch
15963 clause can receive the thrown expression or the current method is
15964 declared to throw such an exception. Or, the throw statement is
15965 contained in a method or constructor declaration and the type of
15966 the Expression is assignable to at least one type listed in the
15967 throws clause the declaration. */
15968 if (!unchecked_ok)
15969 tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15970 if (!(unchecked_ok || tryblock_throws_ok))
15971 {
15972 /* If there is a surrounding try block that has no matching
15973 clatch clause, report it first. A surrounding try block exits
15974 only if there is something after the list of checked
15975 exception thrown by the current function (if any). */
15976 if (IN_TRY_BLOCK_P ())
15977 parse_error_context (wfl_operator, "Checked exception %qs can't be caught by any of the catch clause(s) of the surrounding %<try%> block",
15978 lang_printable_name (type, 0));
15979 /* If we have no surrounding try statement and the method doesn't have
15980 any throws, report it now. FIXME */
15981
15982 /* We report that the exception can't be throw from a try block
15983 in all circumstances but when the `throw' is inside a static
15984 block. */
15985 else if (!EXCEPTIONS_P (currently_caught_type_list)
15986 && !tryblock_throws_ok)
15987 {
15988 if (DECL_CLINIT_P (current_function_decl))
15989 parse_error_context (wfl_operator,
15990 "Checked exception %qs can't be thrown in initializer",
15991 lang_printable_name (type, 0));
15992 else
15993 parse_error_context (wfl_operator,
15994 "Checked exception %qs isn't thrown from a %<try%> block",
15995 lang_printable_name (type, 0));
15996 }
15997 /* Otherwise, the current method doesn't have the appropriate
15998 throws declaration */
15999 else
16000 parse_error_context (wfl_operator, "Checked exception %qs doesn't match any of current method's %<throws%> declaration(s)",
16001 lang_printable_name (type, 0));
16002 return error_mark_node;
16003 }
16004
16005 if (! flag_emit_class_files)
16006 BUILD_THROW (node, expr);
16007
16008 return node;
16009 }
16010
16011 /* Add EXCEPTION to the throws clause of MDECL. If MDECL already throws
16012 a super-class of EXCEPTION, keep the superclass instead. If MDECL already
16013 throws a sub-class of EXCEPTION, replace the sub-class with EXCEPTION. */
16014 static void
16015 add_exception_to_throws (tree mdecl, tree exception)
16016 {
16017 tree mthrows;
16018
16019 /* Ignore unchecked exceptions. */
16020 if (IS_UNCHECKED_EXCEPTION_P (exception))
16021 return;
16022
16023 for (mthrows = DECL_FUNCTION_THROWS (mdecl);
16024 mthrows; mthrows = TREE_CHAIN (mthrows))
16025 {
16026 if (inherits_from_p (exception, TREE_VALUE (mthrows)))
16027 return;
16028 if (inherits_from_p (TREE_VALUE (mthrows), exception))
16029 {
16030 TREE_VALUE (mthrows) = exception;
16031 return;
16032 }
16033 }
16034
16035 mthrows = DECL_FUNCTION_THROWS (mdecl);
16036 DECL_FUNCTION_THROWS (mdecl) = build_tree_list (mthrows, exception);
16037 }
16038
16039 /* Check that exception said to be thrown by method DECL can be
16040 effectively caught from where DECL is invoked. THIS_EXPR is the
16041 expression that computes `this' for the method call. */
16042 static void
16043 check_thrown_exceptions (
16044 #ifdef USE_MAPPED_LOCATION
16045 source_location location,
16046 #else
16047
16048 int location,
16049 #endif
16050 tree decl, tree this_expr)
16051 {
16052 tree throws;
16053 int is_array_call = 0;
16054
16055 /* Skip check within generated methods, such as access$<n>. */
16056 if (NESTED_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
16057 return;
16058
16059 if (this_expr != NULL_TREE
16060 && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
16061 && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
16062 is_array_call = 1;
16063
16064 /* For all the unchecked exceptions thrown by DECL. */
16065 for (throws = DECL_FUNCTION_THROWS (decl); throws;
16066 throws = TREE_CHAIN (throws))
16067 if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
16068 {
16069 /* Suppress errors about cloning arrays. */
16070 if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
16071 continue;
16072
16073 #ifdef USE_MAPPED_LOCATION
16074 SET_EXPR_LOCATION (wfl_operator, location);
16075 #else
16076 EXPR_WFL_LINECOL (wfl_operator) = location;
16077 #endif
16078 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (current_function_decl))
16079 && (DECL_FINIT_P (current_function_decl)
16080 || DECL_INIT_P (current_function_decl)
16081 || DECL_CONSTRUCTOR_P (current_function_decl)))
16082 {
16083 /* Add "throws" to the initializer's exception list */
16084 tree exception = TREE_VALUE (throws);
16085 add_exception_to_throws (current_function_decl, exception);
16086 }
16087 else if (DECL_FINIT_P (current_function_decl))
16088 {
16089 parse_error_context
16090 (wfl_operator, "Exception %qs can't be thrown in initializer",
16091 lang_printable_name (TREE_VALUE (throws), 0));
16092 }
16093 else
16094 {
16095 parse_error_context
16096 (wfl_operator, "Exception %qs must be caught, or it must be declared in the %<throws%> clause of %qs",
16097 lang_printable_name (TREE_VALUE (throws), 0),
16098 (DECL_INIT_P (current_function_decl) ?
16099 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
16100 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
16101 }
16102 }
16103 }
16104
16105 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
16106 try-catch blocks, OR is listed in the `throws' clause of the
16107 current method. */
16108
16109 static int
16110 check_thrown_exceptions_do (tree exception)
16111 {
16112 tree list = currently_caught_type_list;
16113 resolve_and_layout (exception, NULL_TREE);
16114 /* First, all the nested try-catch-finally at that stage. The
16115 last element contains `throws' clause exceptions, if any. */
16116 if (IS_UNCHECKED_EXCEPTION_P (exception))
16117 return 1;
16118 while (list)
16119 {
16120 tree caught;
16121 for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
16122 if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
16123 return 1;
16124 list = TREE_CHAIN (list);
16125 }
16126 return 0;
16127 }
16128
16129 /* This function goes over all of CLASS_TYPE ctors and checks whether
16130 each of them features at least one unchecked exception in its
16131 `throws' clause. If it's the case, it returns `true', `false'
16132 otherwise. */
16133
16134 static bool
16135 ctors_unchecked_throws_clause_p (tree class_type)
16136 {
16137 tree current;
16138
16139 for (current = TYPE_METHODS (class_type); current;
16140 current = TREE_CHAIN (current))
16141 {
16142 bool ctu = false; /* Ctor Throws Unchecked */
16143 if (DECL_CONSTRUCTOR_P (current))
16144 {
16145 tree throws;
16146 for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
16147 throws = TREE_CHAIN (throws))
16148 if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
16149 ctu = true;
16150 }
16151 /* We return false as we found one ctor that is unfit. */
16152 if (!ctu && DECL_CONSTRUCTOR_P (current))
16153 return false;
16154 }
16155 /* All ctors feature at least one unchecked exception in their
16156 `throws' clause. */
16157 return true;
16158 }
16159
16160 /* 15.24 Conditional Operator ?: */
16161
16162 static tree
16163 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
16164 {
16165 tree cond = TREE_OPERAND (node, 0);
16166 tree op1 = TREE_OPERAND (node, 1);
16167 tree op2 = TREE_OPERAND (node, 2);
16168 tree resulting_type = NULL_TREE;
16169 tree t1, t2, patched;
16170 int error_found = 0;
16171
16172 /* The condition and operands of ?: might be StringBuffers crafted
16173 as a result of a string concatenation. Obtain decent ones here. */
16174 if ((patched = patch_string (cond)))
16175 TREE_OPERAND (node, 0) = cond = patched;
16176 if ((patched = patch_string (op1)))
16177 TREE_OPERAND (node, 1) = op1 = patched;
16178 if ((patched = patch_string (op2)))
16179 TREE_OPERAND (node, 2) = op2 = patched;
16180
16181 t1 = TREE_TYPE (op1);
16182 t2 = TREE_TYPE (op2);
16183
16184 /* The first expression must be a boolean */
16185 if (TREE_TYPE (cond) != boolean_type_node)
16186 {
16187 SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
16188 parse_error_context (wfl_operator,
16189 "Incompatible type for %<?:%>. Can't convert %qs to %<boolean%>",
16190 lang_printable_name (TREE_TYPE (cond), 0));
16191 error_found = 1;
16192 }
16193
16194 /* Second and third can be numeric, boolean (i.e. primitive),
16195 references or null. Anything else results in an error */
16196 if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
16197 || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
16198 && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
16199 || (t1 == boolean_type_node && t2 == boolean_type_node)))
16200 error_found = 1;
16201
16202 /* Determine the type of the conditional expression. Same types are
16203 easy to deal with */
16204 else if (t1 == t2)
16205 resulting_type = t1;
16206
16207 /* There are different rules for numeric types */
16208 else if (JNUMERIC_TYPE_P (t1))
16209 {
16210 /* if byte/short found, the resulting type is short */
16211 if ((t1 == byte_type_node && t2 == short_type_node)
16212 || (t1 == short_type_node && t2 == byte_type_node))
16213 resulting_type = short_type_node;
16214
16215 /* If t1 is a constant int and t2 is of type byte, short or char
16216 and t1's value fits in t2, then the resulting type is t2 */
16217 else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
16218 && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
16219 resulting_type = t2;
16220
16221 /* If t2 is a constant int and t1 is of type byte, short or char
16222 and t2's value fits in t1, then the resulting type is t1 */
16223 else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
16224 && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
16225 resulting_type = t1;
16226
16227 /* Otherwise, binary numeric promotion is applied and the
16228 resulting type is the promoted type of operand 1 and 2 */
16229 else
16230 resulting_type = binary_numeric_promotion (t1, t2,
16231 &TREE_OPERAND (node, 1),
16232 &TREE_OPERAND (node, 2));
16233 }
16234
16235 /* Cases of a reference and a null type */
16236 else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
16237 resulting_type = t1;
16238
16239 else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
16240 resulting_type = t2;
16241
16242 /* Last case: different reference types. If a type can be converted
16243 into the other one by assignment conversion, the latter
16244 determines the type of the expression */
16245 else if ((resulting_type = try_reference_assignconv (t1, op2)))
16246 resulting_type = promote_type (t1);
16247
16248 else if ((resulting_type = try_reference_assignconv (t2, op1)))
16249 resulting_type = promote_type (t2);
16250
16251 /* If we don't have any resulting type, we're in trouble */
16252 if (!resulting_type)
16253 {
16254 char *t = xstrdup (lang_printable_name (t1, 0));
16255 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
16256 parse_error_context (wfl_operator,
16257 "Incompatible type for %<?:%>. Can't convert %qs to %qs",
16258 t, lang_printable_name (t2, 0));
16259 free (t);
16260 error_found = 1;
16261 }
16262
16263 if (error_found)
16264 {
16265 TREE_TYPE (node) = error_mark_node;
16266 return error_mark_node;
16267 }
16268
16269 TREE_TYPE (node) = resulting_type;
16270 TREE_SET_CODE (node, COND_EXPR);
16271 CAN_COMPLETE_NORMALLY (node) = 1;
16272 return node;
16273 }
16274
16275 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
16276
16277 static tree
16278 maybe_build_class_init_for_field (tree decl, tree expr)
16279 {
16280 tree clas = DECL_CONTEXT (decl);
16281 if (flag_emit_class_files)
16282 return expr;
16283
16284 if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
16285 && FIELD_FINAL (decl))
16286 {
16287 tree init = DECL_INITIAL (decl);
16288 if (init != NULL_TREE)
16289 init = fold_constant_for_init (init, decl);
16290 if (init != NULL_TREE && CONSTANT_VALUE_P (init))
16291 return expr;
16292 }
16293
16294 return build_class_init (clas, expr);
16295 }
16296
16297 /* Try to constant fold NODE.
16298 If NODE is not a constant expression, return NULL_EXPR.
16299 CONTEXT is a static final VAR_DECL whose initializer we are folding. */
16300
16301 static tree
16302 fold_constant_for_init (tree node, tree context)
16303 {
16304 tree op0, op1, val;
16305 enum tree_code code = TREE_CODE (node);
16306
16307 switch (code)
16308 {
16309 case INTEGER_CST:
16310 if (node == null_pointer_node)
16311 return NULL_TREE;
16312 case STRING_CST:
16313 case REAL_CST:
16314 return node;
16315
16316 case PLUS_EXPR:
16317 case MINUS_EXPR:
16318 case MULT_EXPR:
16319 case TRUNC_MOD_EXPR:
16320 case RDIV_EXPR:
16321 case LSHIFT_EXPR:
16322 case RSHIFT_EXPR:
16323 case URSHIFT_EXPR:
16324 case BIT_AND_EXPR:
16325 case BIT_XOR_EXPR:
16326 case BIT_IOR_EXPR:
16327 case TRUTH_ANDIF_EXPR:
16328 case TRUTH_ORIF_EXPR:
16329 case EQ_EXPR:
16330 case NE_EXPR:
16331 case GT_EXPR:
16332 case GE_EXPR:
16333 case LT_EXPR:
16334 case LE_EXPR:
16335 op0 = TREE_OPERAND (node, 0);
16336 op1 = TREE_OPERAND (node, 1);
16337 val = fold_constant_for_init (op0, context);
16338 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16339 return NULL_TREE;
16340 TREE_OPERAND (node, 0) = val;
16341 val = fold_constant_for_init (op1, context);
16342 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16343 return NULL_TREE;
16344 TREE_OPERAND (node, 1) = val;
16345 return patch_binop (node, op0, op1, 1);
16346
16347 case UNARY_PLUS_EXPR:
16348 case NEGATE_EXPR:
16349 case TRUTH_NOT_EXPR:
16350 case BIT_NOT_EXPR:
16351 case CONVERT_EXPR:
16352 case NOP_EXPR:
16353 op0 = TREE_OPERAND (node, 0);
16354 val = fold_constant_for_init (op0, context);
16355 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16356 return NULL_TREE;
16357 TREE_OPERAND (node, 0) = val;
16358 val = patch_unaryop (node, op0);
16359 if (! TREE_CONSTANT (val))
16360 return NULL_TREE;
16361 return val;
16362
16363 break;
16364
16365 case COND_EXPR:
16366 val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16367 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16368 return NULL_TREE;
16369 TREE_OPERAND (node, 0) = val;
16370 val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16371 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16372 return NULL_TREE;
16373 TREE_OPERAND (node, 1) = val;
16374 val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16375 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16376 return NULL_TREE;
16377 TREE_OPERAND (node, 2) = val;
16378 return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 2)
16379 : TREE_OPERAND (node, 1);
16380
16381 case VAR_DECL:
16382 case FIELD_DECL:
16383 if (! FIELD_FINAL (node)
16384 || DECL_INITIAL (node) == NULL_TREE)
16385 return NULL_TREE;
16386 val = DECL_INITIAL (node);
16387 /* Guard against infinite recursion. */
16388 DECL_INITIAL (node) = NULL_TREE;
16389 val = fold_constant_for_init (val, node);
16390 if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16391 val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16392 DECL_INITIAL (node) = val;
16393 return val;
16394
16395 case EXPR_WITH_FILE_LOCATION:
16396 /* Compare java_complete_tree and resolve_expression_name. */
16397 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16398 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16399 {
16400 tree name = EXPR_WFL_NODE (node);
16401 tree decl;
16402 if (PRIMARY_P (node))
16403 return NULL_TREE;
16404 else if (! QUALIFIED_P (name))
16405 {
16406 decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16407 if (decl == NULL_TREE
16408 || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16409 return NULL_TREE;
16410 return fold_constant_for_init (decl, decl);
16411 }
16412 else
16413 {
16414 tree r = NULL_TREE;
16415 /* Install the proper context for the field resolution. */
16416 tree saved_current_class = current_class;
16417 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
16418 current_class = DECL_CONTEXT (context);
16419 qualify_ambiguous_name (node);
16420 r = resolve_field_access (node, &decl, NULL);
16421 /* Restore prior context. */
16422 current_class = saved_current_class;
16423 if (r != error_mark_node && decl != NULL_TREE)
16424 return fold_constant_for_init (decl, decl);
16425 return NULL_TREE;
16426 }
16427 }
16428 else
16429 {
16430 op0 = TREE_OPERAND (node, 0);
16431 val = fold_constant_for_init (op0, context);
16432 if (val == NULL_TREE || ! TREE_CONSTANT (val))
16433 return NULL_TREE;
16434 TREE_OPERAND (node, 0) = val;
16435 return val;
16436 }
16437
16438 #ifdef USE_COMPONENT_REF
16439 case IDENTIFIER:
16440 case COMPONENT_REF:
16441 ?;
16442 #endif
16443
16444 default:
16445 return NULL_TREE;
16446 }
16447 }
16448
16449 #ifdef USE_COMPONENT_REF
16450 /* Context is 'T' for TypeName, 'P' for PackageName,
16451 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16452
16453 tree
16454 resolve_simple_name (tree name, int context)
16455 {
16456 }
16457
16458 tree
16459 resolve_qualified_name (tree name, int context)
16460 {
16461 }
16462 #endif
16463
16464 void
16465 init_src_parse (void)
16466 {
16467 /* Sanity check; we've been bit by this before. */
16468 if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16469 abort ();
16470 }
16471
16472 \f
16473
16474 /* This section deals with the functions that are called when tables
16475 recording class initialization information are traversed. */
16476
16477 /* This function is called for each class that is known definitely
16478 initialized when a given static method was called. This function
16479 augments a compound expression (INFO) storing all assignment to
16480 initialized static class flags if a flag already existed, otherwise
16481 a new one is created. */
16482
16483 static int
16484 emit_test_initialization (void **entry_p, void *info)
16485 {
16486 tree l = (tree) info;
16487 tree decl, init;
16488 tree key = (tree) *entry_p;
16489 tree *ite;
16490 htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16491
16492 /* If we haven't found a flag and we're dealing with self registered
16493 with current_function_decl, then don't do anything. Self is
16494 always added as definitely initialized but this information is
16495 valid only if used outside the current function. */
16496 if (current_function_decl == TREE_PURPOSE (l)
16497 && java_treetreehash_find (cf_ht, key) == NULL)
16498 return true;
16499
16500 ite = java_treetreehash_new (cf_ht, key);
16501
16502 /* If we don't have a variable, create one and install it. */
16503 if (*ite == NULL)
16504 {
16505 tree block;
16506
16507 decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16508 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16509 LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16510 DECL_CONTEXT (decl) = current_function_decl;
16511 DECL_INITIAL (decl) = boolean_true_node;
16512 /* Don't emit any symbolic debugging info for this decl. */
16513 DECL_IGNORED_P (decl) = 1;
16514
16515 /* The trick is to find the right context for it. */
16516 block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16517 TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16518 BLOCK_EXPR_DECLS (block) = decl;
16519 *ite = decl;
16520 }
16521 else
16522 decl = *ite;
16523
16524 /* Now simply augment the compound that holds all the assignments
16525 pertaining to this method invocation. */
16526 init = build2 (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16527 TREE_SIDE_EFFECTS (init) = 1;
16528 TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16529 TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16530
16531 return true;
16532 }
16533
16534 #ifdef __XGETTEXT__
16535 /* Depending on the version of Bison used to compile this grammar,
16536 it may issue generic diagnostics spelled "syntax error" or
16537 "parse error". To prevent this from changing the translation
16538 template randomly, we list all the variants of this particular
16539 diagnostic here. Translators: there is no fine distinction
16540 between diagnostics with "syntax error" in them, and diagnostics
16541 with "parse error" in them. It's okay to give them both the same
16542 translation. */
16543 const char d1[] = N_("syntax error");
16544 const char d2[] = N_("parse error");
16545 const char d3[] = N_("syntax error; also virtual memory exhausted");
16546 const char d4[] = N_("parse error; also virtual memory exhausted");
16547 const char d5[] = N_("syntax error: cannot back up");
16548 const char d6[] = N_("parse error: cannot back up");
16549 #endif
16550
16551 #include "gt-java-parse.h"
16552 #include "gtype-java.h"
Mirror of the offical gcc git repository hosted at gcc.gnu.org