]> gcc.gnu.org Git - gcc.git/blame - gcc/java/parse.y
git://gcc.gnu.org / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix problem with relocs in read-only sections for C++ code.
[gcc.git] / gcc / java / parse.y
CommitLineData
e04a16fb
AG		 1/* Source code parsing and tree node generation for the GNU compiler
2 for the Java(TM) language.
df32d2ce 3 Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
e04a16fb
AG		 4 Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
5
6This file is part of GNU CC.
7
8GNU CC is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2, or (at your option)
11any later version.
12
13GNU CC is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with GNU CC; see the file COPYING. If not, write to
20the Free Software Foundation, 59 Temple Place - Suite 330,
21Boston, MA 02111-1307, USA.
22
23Java and all Java-based marks are trademarks or registered trademarks
24of Sun Microsystems, Inc. in the United States and other countries.
25The Free Software Foundation is independent of Sun Microsystems, Inc. */
26
27/* This file parses java source code and issues a tree node image
28suitable for code generation (byte code and targeted CPU assembly
29language).
30
31The grammar conforms to the Java grammar described in "The Java(TM)
32Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
331996, ISBN 0-201-63451-1"
34
35The following modifications were brought to the original grammar:
36
37method_body: added the rule '| block SC_TK'
e04a16fb
AG		 38static_initializer: added the rule 'static block SC_TK'.
39
40Note: All the extra rules described above should go away when the
41 empty_statement rule will work.
42
43statement_nsi: 'nsi' should be read no_short_if.
44
45Some rules have been modified to support JDK1.1 inner classes
46definitions and other extensions. */
47
48%{
e04a16fb 49#include "config.h"
36635152
GS		 50#include "system.h"
51#include <dirent.h>
e04a16fb
AG		 52#include "tree.h"
53#include "rtl.h"
54#include "obstack.h"
0a2138e2 55#include "toplev.h"
e04a16fb
AG		 56#include "flags.h"
57#include "java-tree.h"
58#include "jcf.h"
59#include "lex.h"
60#include "parse.h"
61#include "zipfile.h"
5e942c50 62#include "convert.h"
63a212ed 63#include "buffer.h"
f099f336 64#include "xref.h"
b384405b 65#include "function.h"
138657ec 66#include "except.h"
0ae70c6a 67#include "defaults.h"
e04a16fb 68
c2952b01
APB		 69#ifndef DIR_SEPARATOR
70#define DIR_SEPARATOR '/'
71#endif
72
82371d41 73/* Local function prototypes */
df32d2ce
KG		 74static char *java_accstring_lookup PARAMS ((int));
75static void classitf_redefinition_error PARAMS ((const char *,tree, tree, tree));
76static void variable_redefinition_error PARAMS ((tree, tree, tree, int));
df32d2ce
KG		 77static tree create_class PARAMS ((int, tree, tree, tree));
78static tree create_interface PARAMS ((int, tree, tree));
c2952b01 79static void end_class_declaration PARAMS ((int));
df32d2ce
KG		 80static tree find_field PARAMS ((tree, tree));
81static tree lookup_field_wrapper PARAMS ((tree, tree));
82static int duplicate_declaration_error_p PARAMS ((tree, tree, tree));
83static void register_fields PARAMS ((int, tree, tree));
c2952b01 84static tree parser_qualified_classname PARAMS ((int, tree));
df32d2ce
KG		 85static int parser_check_super PARAMS ((tree, tree, tree));
86static int parser_check_super_interface PARAMS ((tree, tree, tree));
87static void check_modifiers_consistency PARAMS ((int));
88static tree lookup_cl PARAMS ((tree));
89static tree lookup_java_method2 PARAMS ((tree, tree, int));
90static tree method_header PARAMS ((int, tree, tree, tree));
91static void fix_method_argument_names PARAMS ((tree ,tree));
92static tree method_declarator PARAMS ((tree, tree));
93static void parse_warning_context PARAMS ((tree cl, const char *msg, ...))
d4476be2 94 ATTRIBUTE_PRINTF_2;
df32d2ce
KG		 95static void issue_warning_error_from_context PARAMS ((tree, const char *msg, va_list));
96static void parse_ctor_invocation_error PARAMS ((void));
97static tree parse_jdk1_1_error PARAMS ((const char *));
98static void complete_class_report_errors PARAMS ((jdep *));
99static int process_imports PARAMS ((void));
100static void read_import_dir PARAMS ((tree));
101static int find_in_imports_on_demand PARAMS ((tree));
102static int find_in_imports PARAMS ((tree));
103static int check_pkg_class_access PARAMS ((tree, tree));
104static tree resolve_package PARAMS ((tree, tree *));
105static tree lookup_package_type PARAMS ((const char *, int));
106static tree lookup_package_type_and_set_next PARAMS ((const char *, int, tree *));
c2952b01 107static tree resolve_class PARAMS ((tree, tree, tree, tree));
df32d2ce
KG		 108static void declare_local_variables PARAMS ((int, tree, tree));
109static void source_start_java_method PARAMS ((tree));
110static void source_end_java_method PARAMS ((void));
111static void expand_start_java_method PARAMS ((tree));
112static tree find_name_in_single_imports PARAMS ((tree));
113static void check_abstract_method_header PARAMS ((tree));
114static tree lookup_java_interface_method2 PARAMS ((tree, tree));
115static tree resolve_expression_name PARAMS ((tree, tree *));
c2952b01 116static tree maybe_create_class_interface_decl PARAMS ((tree, tree, tree, tree));
df32d2ce 117static int check_class_interface_creation PARAMS ((int, int, tree,
82371d41 118 tree, tree, tree));
df32d2ce 119static tree patch_method_invocation PARAMS ((tree, tree, tree,
89e09b9a 120 int *, tree *));
df32d2ce
KG		 121static int breakdown_qualified PARAMS ((tree *, tree *, tree));
122static tree resolve_and_layout PARAMS ((tree, tree));
123static tree resolve_no_layout PARAMS ((tree, tree));
124static int invocation_mode PARAMS ((tree, int));
125static tree find_applicable_accessible_methods_list PARAMS ((int, tree,
82371d41 126 tree, tree));
df32d2ce 127static void search_applicable_methods_list PARAMS ((int, tree, tree, tree,
1982388a 128 tree *, tree *));
df32d2ce
KG		 129static tree find_most_specific_methods_list PARAMS ((tree));
130static int argument_types_convertible PARAMS ((tree, tree));
131static tree patch_invoke PARAMS ((tree, tree, tree));
c2952b01 132static int maybe_use_access_method PARAMS ((int, tree *, tree *));
df32d2ce
KG		 133static tree lookup_method_invoke PARAMS ((int, tree, tree, tree, tree));
134static tree register_incomplete_type PARAMS ((int, tree, tree, tree));
135static tree obtain_incomplete_type PARAMS ((tree));
136static tree java_complete_lhs PARAMS ((tree));
137static tree java_complete_tree PARAMS ((tree));
c2952b01 138static tree maybe_generate_pre_expand_clinit PARAMS ((tree));
df32d2ce
KG		 139static void java_complete_expand_method PARAMS ((tree));
140static int unresolved_type_p PARAMS ((tree, tree *));
141static void create_jdep_list PARAMS ((struct parser_ctxt *));
142static tree build_expr_block PARAMS ((tree, tree));
143static tree enter_block PARAMS ((void));
144static tree enter_a_block PARAMS ((tree));
145static tree exit_block PARAMS ((void));
146static tree lookup_name_in_blocks PARAMS ((tree));
147static void maybe_absorb_scoping_blocks PARAMS ((void));
148static tree build_method_invocation PARAMS ((tree, tree));
149static tree build_new_invocation PARAMS ((tree, tree));
150static tree build_assignment PARAMS ((int, int, tree, tree));
151static tree build_binop PARAMS ((enum tree_code, int, tree, tree));
152static int check_final_assignment PARAMS ((tree ,tree));
153static tree patch_assignment PARAMS ((tree, tree, tree ));
154static tree patch_binop PARAMS ((tree, tree, tree));
155static tree build_unaryop PARAMS ((int, int, tree));
156static tree build_incdec PARAMS ((int, int, tree, int));
157static tree patch_unaryop PARAMS ((tree, tree));
158static tree build_cast PARAMS ((int, tree, tree));
159static tree build_null_of_type PARAMS ((tree));
160static tree patch_cast PARAMS ((tree, tree));
161static int valid_ref_assignconv_cast_p PARAMS ((tree, tree, int));
162static int valid_builtin_assignconv_identity_widening_p PARAMS ((tree, tree));
163static int valid_cast_to_p PARAMS ((tree, tree));
164static int valid_method_invocation_conversion_p PARAMS ((tree, tree));
165static tree try_builtin_assignconv PARAMS ((tree, tree, tree));
166static tree try_reference_assignconv PARAMS ((tree, tree));
167static tree build_unresolved_array_type PARAMS ((tree));
168static tree build_array_from_name PARAMS ((tree, tree, tree, tree *));
169static tree build_array_ref PARAMS ((int, tree, tree));
170static tree patch_array_ref PARAMS ((tree));
171static tree make_qualified_name PARAMS ((tree, tree, int));
172static tree merge_qualified_name PARAMS ((tree, tree));
173static tree make_qualified_primary PARAMS ((tree, tree, int));
174static int resolve_qualified_expression_name PARAMS ((tree, tree *,
82371d41 175 tree *, tree *));
df32d2ce 176static void qualify_ambiguous_name PARAMS ((tree));
df32d2ce
KG		 177static tree resolve_field_access PARAMS ((tree, tree *, tree *));
178static tree build_newarray_node PARAMS ((tree, tree, int));
179static tree patch_newarray PARAMS ((tree));
180static tree resolve_type_during_patch PARAMS ((tree));
181static tree build_this PARAMS ((int));
c2952b01 182static tree build_wfl_wrap PARAMS ((tree));
df32d2ce
KG		 183static tree build_return PARAMS ((int, tree));
184static tree patch_return PARAMS ((tree));
185static tree maybe_access_field PARAMS ((tree, tree, tree));
186static int complete_function_arguments PARAMS ((tree));
c2952b01
APB		 187static int check_for_static_method_reference PARAMS ((tree, tree, tree,
188 tree, tree));
df32d2ce
KG		 189static int not_accessible_p PARAMS ((tree, tree, int));
190static void check_deprecation PARAMS ((tree, tree));
191static int class_in_current_package PARAMS ((tree));
192static tree build_if_else_statement PARAMS ((int, tree, tree, tree));
193static tree patch_if_else_statement PARAMS ((tree));
194static tree add_stmt_to_compound PARAMS ((tree, tree, tree));
195static tree add_stmt_to_block PARAMS ((tree, tree, tree));
196static tree patch_exit_expr PARAMS ((tree));
197static tree build_labeled_block PARAMS ((int, tree));
198static tree finish_labeled_statement PARAMS ((tree, tree));
199static tree build_bc_statement PARAMS ((int, int, tree));
200static tree patch_bc_statement PARAMS ((tree));
201static tree patch_loop_statement PARAMS ((tree));
202static tree build_new_loop PARAMS ((tree));
203static tree build_loop_body PARAMS ((int, tree, int));
204static tree finish_loop_body PARAMS ((int, tree, tree, int));
205static tree build_debugable_stmt PARAMS ((int, tree));
206static tree finish_for_loop PARAMS ((int, tree, tree, tree));
207static tree patch_switch_statement PARAMS ((tree));
208static tree string_constant_concatenation PARAMS ((tree, tree));
209static tree build_string_concatenation PARAMS ((tree, tree));
210static tree patch_string_cst PARAMS ((tree));
211static tree patch_string PARAMS ((tree));
212static tree build_try_statement PARAMS ((int, tree, tree));
213static tree build_try_finally_statement PARAMS ((int, tree, tree));
214static tree patch_try_statement PARAMS ((tree));
215static tree patch_synchronized_statement PARAMS ((tree, tree));
216static tree patch_throw_statement PARAMS ((tree, tree));
217static void check_thrown_exceptions PARAMS ((int, tree));
218static int check_thrown_exceptions_do PARAMS ((tree));
219static void purge_unchecked_exceptions PARAMS ((tree));
220static void check_throws_clauses PARAMS ((tree, tree, tree));
221static void finish_method_declaration PARAMS ((tree));
222static tree build_super_invocation PARAMS ((tree));
223static int verify_constructor_circularity PARAMS ((tree, tree));
224static char *constructor_circularity_msg PARAMS ((tree, tree));
225static tree build_this_super_qualified_invocation PARAMS ((int, tree, tree,
82371d41 226 int, int));
df32d2ce
KG		 227static const char *get_printable_method_name PARAMS ((tree));
228static tree patch_conditional_expr PARAMS ((tree, tree, tree));
c2952b01
APB		 229static tree generate_finit PARAMS ((tree));
230static void add_instance_initializer PARAMS ((tree));
df32d2ce 231static void fix_constructors PARAMS ((tree));
c2952b01
APB		 232static tree build_alias_initializer_parameter_list PARAMS ((int, tree,
233 tree, int *));
234static void craft_constructor PARAMS ((tree, tree));
235static int verify_constructor_super PARAMS ((tree));
df32d2ce
KG		 236static tree create_artificial_method PARAMS ((tree, int, tree, tree, tree));
237static void start_artificial_method_body PARAMS ((tree));
238static void end_artificial_method_body PARAMS ((tree));
239static int check_method_redefinition PARAMS ((tree, tree));
240static int reset_method_name PARAMS ((tree));
165f37bc 241static int check_method_types_complete PARAMS ((tree));
df32d2ce
KG		 242static void java_check_regular_methods PARAMS ((tree));
243static void java_check_abstract_methods PARAMS ((tree));
244static tree maybe_build_primttype_type_ref PARAMS ((tree, tree));
245static void unreachable_stmt_error PARAMS ((tree));
246static tree find_expr_with_wfl PARAMS ((tree));
247static void missing_return_error PARAMS ((tree));
248static tree build_new_array_init PARAMS ((int, tree));
249static tree patch_new_array_init PARAMS ((tree, tree));
250static tree maybe_build_array_element_wfl PARAMS ((tree));
251static int array_constructor_check_entry PARAMS ((tree, tree));
252static const char *purify_type_name PARAMS ((const char *));
253static tree fold_constant_for_init PARAMS ((tree, tree));
254static tree strip_out_static_field_access_decl PARAMS ((tree));
255static jdeplist *reverse_jdep_list PARAMS ((struct parser_ctxt *));
256static void static_ref_err PARAMS ((tree, tree, tree));
257static void parser_add_interface PARAMS ((tree, tree, tree));
258static void add_superinterfaces PARAMS ((tree, tree));
259static tree jdep_resolve_class PARAMS ((jdep *));
260static int note_possible_classname PARAMS ((const char *, int));
c2952b01
APB		 261static void java_complete_expand_classes PARAMS ((void));
262static void java_complete_expand_class PARAMS ((tree));
263static void java_complete_expand_methods PARAMS ((tree));
df32d2ce
KG		 264static tree cut_identifier_in_qualified PARAMS ((tree));
265static tree java_stabilize_reference PARAMS ((tree));
266static tree do_unary_numeric_promotion PARAMS ((tree));
267static char * operator_string PARAMS ((tree));
268static tree do_merge_string_cste PARAMS ((tree, const char *, int, int));
269static tree merge_string_cste PARAMS ((tree, tree, int));
270static tree java_refold PARAMS ((tree));
271static int java_decl_equiv PARAMS ((tree, tree));
272static int binop_compound_p PARAMS ((enum tree_code));
273static tree search_loop PARAMS ((tree));
274static int labeled_block_contains_loop_p PARAMS ((tree, tree));
275static void check_abstract_method_definitions PARAMS ((int, tree, tree));
276static void java_check_abstract_method_definitions PARAMS ((tree));
277static void java_debug_context_do PARAMS ((int));
c2952b01
APB		 278static void java_parser_context_push_initialized_field PARAMS ((void));
279static void java_parser_context_pop_initialized_field PARAMS ((void));
280static tree reorder_static_initialized PARAMS ((tree));
281static void java_parser_context_suspend PARAMS ((void));
282static void java_parser_context_resume PARAMS ((void));
283
284/* JDK 1.1 work. FIXME */
285
286static tree maybe_make_nested_class_name PARAMS ((tree));
287static void make_nested_class_name PARAMS ((tree));
288static void set_nested_class_simple_name_value PARAMS ((tree, int));
289static void link_nested_class_to_enclosing PARAMS ((void));
290static tree find_as_inner_class PARAMS ((tree, tree, tree));
291static tree find_as_inner_class_do PARAMS ((tree, tree));
292static int check_inner_class_redefinition PARAMS ((tree, tree));
293
294static tree build_thisn_assign PARAMS ((void));
295static tree build_current_thisn PARAMS ((tree));
296static tree build_access_to_thisn PARAMS ((tree, tree, int));
297static tree maybe_build_thisn_access_method PARAMS ((tree));
298
299static tree build_outer_field_access PARAMS ((tree, tree));
300static tree build_outer_field_access_methods PARAMS ((tree));
301static tree build_outer_field_access_expr PARAMS ((int, tree, tree,
302 tree, tree));
303static tree build_outer_method_access_method PARAMS ((tree));
304static tree build_new_access_id PARAMS ((void));
305static tree build_outer_field_access_method PARAMS ((tree, tree, tree,
306 tree, tree));
307
308static int outer_field_access_p PARAMS ((tree, tree));
309static int outer_field_expanded_access_p PARAMS ((tree, tree *,
310 tree *, tree *));
311static tree outer_field_access_fix PARAMS ((tree, tree, tree));
312static tree build_incomplete_class_ref PARAMS ((int, tree));
313static tree patch_incomplete_class_ref PARAMS ((tree));
314static tree create_anonymous_class PARAMS ((int, tree));
315static void patch_anonymous_class PARAMS ((tree, tree, tree));
316static void add_inner_class_fields PARAMS ((tree, tree));
82371d41 317
165f37bc
APB		 318static tree build_dot_class_method PARAMS ((tree));
319static tree build_dot_class_method_invocation PARAMS ((tree));
c0b864fc 320static void create_new_parser_context PARAMS ((int));
165f37bc 321
e04a16fb
AG		 322/* Number of error found so far. */
323int java_error_count;
324/* Number of warning found so far. */
325int java_warning_count;
ce6e9147
APB		 326/* Tell when not to fold, when doing xrefs */
327int do_not_fold;
c2952b01
APB		 328/* Cyclic inheritance report, as it can be set by layout_class */
329char *cyclic_inheritance_report;
330
331/* Tell when we're within an instance initializer */
332static int in_instance_initializer;
e04a16fb
AG		 333
334/* The current parser context */
d4370213 335struct parser_ctxt *ctxp;
e04a16fb 336
d4370213 337/* List of things that were analyzed for which code will be generated */
b351b287
APB		 338static struct parser_ctxt *ctxp_for_generation = NULL;
339
e04a16fb
AG		 340/* binop_lookup maps token to tree_code. It is used where binary
341 operations are involved and required by the parser. RDIV_EXPR
342 covers both integral/floating point division. The code is changed
343 once the type of both operator is worked out. */
344
345static enum tree_code binop_lookup[19] =
346 {
347 PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
348 LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
349 BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
350 TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
351 EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
352 };
353#define BINOP_LOOKUP(VALUE) \
354 binop_lookup [((VALUE) - PLUS_TK)% \
355 (sizeof (binop_lookup) / sizeof (binop_lookup[0]))]
356
5cbdba64
APB		 357/* This is the end index for binary operators that can also be used
358 in compound assignements. */
359#define BINOP_COMPOUND_CANDIDATES 11
360
e04a16fb
AG		 361/* Fake WFL used to report error message. It is initialized once if
362 needed and reused with it's location information is overriden. */
15fdcfe9 363tree wfl_operator = NULL_TREE;
e04a16fb
AG		 364
365/* The "$L" identifier we use to create labels. */
b67d701b
PB		 366static tree label_id = NULL_TREE;
367
368/* The "StringBuffer" identifier used for the String `+' operator. */
369static tree wfl_string_buffer = NULL_TREE;
370
371/* The "append" identifier used for String `+' operator. */
372static tree wfl_append = NULL_TREE;
373
374/* The "toString" identifier used for String `+' operator. */
375static tree wfl_to_string = NULL_TREE;
ba179f9f
APB		 376
377/* The "java.lang" import qualified name. */
378static tree java_lang_id = NULL_TREE;
09ed0f70 379
c2952b01
APB		 380/* The generated `inst$' identifier used for generated enclosing
381 instance/field access functions. */
382static tree inst_id = NULL_TREE;
383
09ed0f70
APB		 384/* The "java.lang.Cloneable" qualified name. */
385static tree java_lang_cloneable = NULL_TREE;
f099f336
APB		 386
387/* Context and flag for static blocks */
388static tree current_static_block = NULL_TREE;
389
c2952b01
APB		 390/* The generated `write_parm_value$' identifier. */
391static tree wpv_id;
392
ee07f4f4
APB		 393/* The list of all packages we've seen so far */
394static tree package_list = NULL_TREE;
2884c41e
KG		 395
396/* Check modifiers. If one doesn't fit, retrieve it in its declaration
397 line and point it out. */
398/* Should point out the one that don't fit. ASCII/unicode, going
399 backward. FIXME */
400
401#define check_modifiers(__message, __value, __mask) do { \
402 if ((__value) & ~(__mask)) \
403 { \
404 int i, remainder = (__value) & ~(__mask); \
405 for (i = 0; i <= 10; i++) \
406 if ((1 << i) & remainder) \
407 parse_error_context (ctxp->modifier_ctx [i], (__message), \
408 java_accstring_lookup (1 << i)); \
409 } \
410} while (0)
ee07f4f4 411
e04a16fb
AG		 412%}
413
414%union {
415 tree node;
416 int sub_token;
417 struct {
418 int token;
419 int location;
420 } operator;
421 int value;
422}
423
9ee9b555
KG		 424%{
425#include "lex.c"
426%}
427
e04a16fb
AG		 428%pure_parser
429
430/* Things defined here have to match the order of what's in the
431 binop_lookup table. */
432
433%token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
434%token LS_TK SRS_TK ZRS_TK
435%token AND_TK XOR_TK OR_TK
436%token BOOL_AND_TK BOOL_OR_TK
437%token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
438
439/* This maps to the same binop_lookup entry than the token above */
440
441%token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
442%token REM_ASSIGN_TK
443%token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
444%token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
445
446
447/* Modifier TOKEN have to be kept in this order. Don't scramble it */
448
449%token PUBLIC_TK PRIVATE_TK PROTECTED_TK
450%token STATIC_TK FINAL_TK SYNCHRONIZED_TK
451%token VOLATILE_TK TRANSIENT_TK NATIVE_TK
452%token PAD_TK ABSTRACT_TK MODIFIER_TK
453
454/* Keep those two in order, too */
455%token DECR_TK INCR_TK
456
457/* From now one, things can be in any order */
458
459%token DEFAULT_TK IF_TK THROW_TK
460%token BOOLEAN_TK DO_TK IMPLEMENTS_TK
461%token THROWS_TK BREAK_TK IMPORT_TK
462%token ELSE_TK INSTANCEOF_TK RETURN_TK
463%token VOID_TK CATCH_TK INTERFACE_TK
464%token CASE_TK EXTENDS_TK FINALLY_TK
465%token SUPER_TK WHILE_TK CLASS_TK
466%token SWITCH_TK CONST_TK TRY_TK
467%token FOR_TK NEW_TK CONTINUE_TK
468%token GOTO_TK PACKAGE_TK THIS_TK
469
470%token BYTE_TK SHORT_TK INT_TK LONG_TK
471%token CHAR_TK INTEGRAL_TK
472
473%token FLOAT_TK DOUBLE_TK FP_TK
474
475%token ID_TK
476
477%token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
478
479%token ASSIGN_ANY_TK ASSIGN_TK
480%token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
481
482%token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
483%token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
484
c2952b01 485%type <value> modifiers MODIFIER_TK final synchronized
e04a16fb
AG		 486
487%type <node> super ID_TK identifier
488%type <node> name simple_name qualified_name
c2952b01 489%type <node> type_declaration compilation_unit
e04a16fb
AG		 490 field_declaration method_declaration extends_interfaces
491 interfaces interface_type_list
c2952b01 492 class_member_declaration
e04a16fb
AG		 493 import_declarations package_declaration
494 type_declarations interface_body
495 interface_member_declaration constant_declaration
496 interface_member_declarations interface_type
497 abstract_method_declaration interface_type_list
498%type <node> class_body_declaration class_member_declaration
499 static_initializer constructor_declaration block
22eed1e6 500%type <node> class_body_declarations constructor_header
e04a16fb
AG		 501%type <node> class_or_interface_type class_type class_type_list
502 constructor_declarator explicit_constructor_invocation
b9f7e36c 503%type <node> dim_expr dim_exprs this_or_super throws
e04a16fb
AG		 504
505%type <node> variable_declarator_id variable_declarator
506 variable_declarators variable_initializer
22eed1e6 507 variable_initializers constructor_body
ac825856 508 array_initializer
e04a16fb 509
2e5eb5c5 510%type <node> class_body block_end constructor_block_end
e04a16fb
AG		 511%type <node> statement statement_without_trailing_substatement
512 labeled_statement if_then_statement label_decl
513 if_then_else_statement while_statement for_statement
514 statement_nsi labeled_statement_nsi do_statement
515 if_then_else_statement_nsi while_statement_nsi
516 for_statement_nsi statement_expression_list for_init
517 for_update statement_expression expression_statement
518 primary_no_new_array expression primary
519 array_creation_expression array_type
520 class_instance_creation_expression field_access
521 method_invocation array_access something_dot_new
522 argument_list postfix_expression while_expression
523 post_increment_expression post_decrement_expression
524 unary_expression_not_plus_minus unary_expression
525 pre_increment_expression pre_decrement_expression
526 unary_expression_not_plus_minus cast_expression
527 multiplicative_expression additive_expression
528 shift_expression relational_expression
529 equality_expression and_expression
530 exclusive_or_expression inclusive_or_expression
531 conditional_and_expression conditional_or_expression
532 conditional_expression assignment_expression
533 left_hand_side assignment for_header for_begin
534 constant_expression do_statement_begin empty_statement
b67d701b 535 switch_statement synchronized_statement throw_statement
f8976021 536 try_statement switch_expression switch_block
15fdcfe9 537 catches catch_clause catch_clause_parameter finally
c2952b01 538 anonymous_class_creation
e04a16fb
AG		 539%type <node> return_statement break_statement continue_statement
540
541%type <operator> ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
542%type <operator> REM_ASSIGN_TK PLUS_ASSIGN_TK MINUS_ASSIGN_TK
543%type <operator> LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
544%type <operator> AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
545%type <operator> ASSIGN_ANY_TK assignment_operator
546%token <operator> EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
547%token <operator> BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
548%token <operator> DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
7f10c2e2 549%token <operator> NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
5e942c50 550%token <operator> OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
b9f7e36c
APB		 551%type <operator> THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
552%type <operator> CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
c2952b01 553%type <operator> NEW_TK
e04a16fb
AG		 554
555%type <node> method_body
556
557%type <node> literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
558 STRING_LIT_TK NULL_TK VOID_TK
559
560%type <node> IF_TK WHILE_TK FOR_TK
561
562%type <node> formal_parameter_list formal_parameter
563 method_declarator method_header
564
c2952b01 565%type <node> primitive_type reference_type type
e04a16fb
AG		 566 BOOLEAN_TK INTEGRAL_TK FP_TK
567
c2952b01
APB		 568/* Added or modified JDK 1.1 rule types */
569%type <node> type_literals array_type_literal
570
e04a16fb
AG		 571%%
572/* 19.2 Production from 2.3: The Syntactic Grammar */
573goal:
574 compilation_unit
575 {}
576;
577
578/* 19.3 Productions from 3: Lexical structure */
579literal:
580 INT_LIT_TK
581| FP_LIT_TK
582| BOOL_LIT_TK
583| CHAR_LIT_TK
584| STRING_LIT_TK
585| NULL_TK
586;
587
588/* 19.4 Productions from 4: Types, Values and Variables */
589type:
590 primitive_type
591| reference_type
592;
593
594primitive_type:
595 INTEGRAL_TK
596| FP_TK
597| BOOLEAN_TK
598;
599
600reference_type:
601 class_or_interface_type
602| array_type
603;
604
605class_or_interface_type:
606 name
607;
608
609class_type:
610 class_or_interface_type /* Default rule */
611;
612
613interface_type:
614 class_or_interface_type
615;
616
617array_type:
618 primitive_type OSB_TK CSB_TK
619 {
620 $$ = build_java_array_type ($1, -1);
621 CLASS_LOADED_P ($$) = 1;
622 }
623| name OSB_TK CSB_TK
624 { $$ = build_unresolved_array_type ($1); }
625| array_type OSB_TK CSB_TK
626 { $$ = build_unresolved_array_type ($1); }
627| primitive_type OSB_TK error
628 {RULE ("']' expected"); RECOVER;}
629| array_type OSB_TK error
630 {RULE ("']' expected"); RECOVER;}
631;
632
633/* 19.5 Productions from 6: Names */
634name:
635 simple_name /* Default rule */
636| qualified_name /* Default rule */
637;
638
639simple_name:
640 identifier /* Default rule */
641;
642
643qualified_name:
644 name DOT_TK identifier
645 { $$ = make_qualified_name ($1, $3, $2.location); }
646;
647
648identifier:
649 ID_TK
650;
651
652/* 19.6: Production from 7: Packages */
653compilation_unit:
654 {$$ = NULL;}
655| package_declaration
656| import_declarations
657| type_declarations
658| package_declaration import_declarations
659| package_declaration type_declarations
660| import_declarations type_declarations
661| package_declaration import_declarations type_declarations
662;
663
664import_declarations:
665 import_declaration
666 {
667 $$ = NULL;
668 }
669| import_declarations import_declaration
670 {
671 $$ = NULL;
672 }
673;
674
675type_declarations:
676 type_declaration
677| type_declarations type_declaration
678;
679
680package_declaration:
681 PACKAGE_TK name SC_TK
ee07f4f4
APB		 682 {
683 ctxp->package = EXPR_WFL_NODE ($2);
684 package_list = tree_cons (ctxp->package, NULL, package_list);
685 }
e04a16fb
AG		 686| PACKAGE_TK error
687 {yyerror ("Missing name"); RECOVER;}
688| PACKAGE_TK name error
689 {yyerror ("';' expected"); RECOVER;}
690;
691
692import_declaration:
693 single_type_import_declaration
694| type_import_on_demand_declaration
695;
696
697single_type_import_declaration:
698 IMPORT_TK name SC_TK
699 {
700 tree name = EXPR_WFL_NODE ($2), node, last_name;
701 int i = IDENTIFIER_LENGTH (name)-1;
49f48c71 702 const char *last = &IDENTIFIER_POINTER (name)[i];
e04a16fb
AG		 703 while (last != IDENTIFIER_POINTER (name))
704 {
705 if (last [0] == '.')
706 break;
707 last--;
708 }
709 last_name = get_identifier (++last);
710 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
711 {
712 tree err = find_name_in_single_imports (last_name);
713 if (err && err != name)
714 parse_error_context
715 ($2, "Ambiguous class: `%s' and `%s'",
716 IDENTIFIER_POINTER (name),
717 IDENTIFIER_POINTER (err));
5e942c50
APB		 718 else
719 REGISTER_IMPORT ($2, last_name)
e04a16fb
AG		 720 }
721 else
5e942c50 722 REGISTER_IMPORT ($2, last_name);
e04a16fb
AG		 723 }
724| IMPORT_TK error
725 {yyerror ("Missing name"); RECOVER;}
726| IMPORT_TK name error
727 {yyerror ("';' expected"); RECOVER;}
728;
729
730type_import_on_demand_declaration:
731 IMPORT_TK name DOT_TK MULT_TK SC_TK
732 {
733 tree name = EXPR_WFL_NODE ($2);
ba179f9f
APB		 734 /* Don't import java.lang.* twice. */
735 if (name != java_lang_id)
736 {
737 tree node = build_tree_list ($2, NULL_TREE);
738 read_import_dir ($2);
739 TREE_CHAIN (node) = ctxp->import_demand_list;
740 ctxp->import_demand_list = node;
741 }
e04a16fb
AG		 742 }
743| IMPORT_TK name DOT_TK error
744 {yyerror ("'*' expected"); RECOVER;}
745| IMPORT_TK name DOT_TK MULT_TK error
746 {yyerror ("';' expected"); RECOVER;}
747;
748
749type_declaration:
750 class_declaration
c2952b01 751 { end_class_declaration (0); }
e04a16fb 752| interface_declaration
c2952b01 753 { end_class_declaration (0); }
e04a16fb
AG		 754| SC_TK
755 { $$ = NULL; }
756| error
757 {
758 YYERROR_NOW;
759 yyerror ("Class or interface declaration expected");
760 }
761;
762
763/* 19.7 Shortened from the original:
764 modifiers: modifier | modifiers modifier
765 modifier: any of public... */
766modifiers:
767 MODIFIER_TK
768 {
769 $$ = (1 << $1);
770 }
771| modifiers MODIFIER_TK
772 {
773 int acc = (1 << $2);
774 if ($$ & acc)
775 parse_error_context
776 (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
777 java_accstring_lookup (acc));
778 else
779 {
780 $$ |= acc;
781 }
782 }
783;
784
785/* 19.8.1 Production from $8.1: Class Declaration */
786class_declaration:
787 modifiers CLASS_TK identifier super interfaces
788 { create_class ($1, $3, $4, $5); }
789 class_body
e04a16fb
AG		 790| CLASS_TK identifier super interfaces
791 { create_class (0, $2, $3, $4); }
792 class_body
e04a16fb
AG		 793| modifiers CLASS_TK error
794 {yyerror ("Missing class name"); RECOVER;}
795| CLASS_TK error
796 {yyerror ("Missing class name"); RECOVER;}
797| CLASS_TK identifier error
0b4d333e
APB		 798 {
799 if (!ctxp->class_err) yyerror ("'{' expected");
800 DRECOVER(class1);
801 }
e04a16fb
AG		 802| modifiers CLASS_TK identifier error
803 {if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER;}
804;
805
806super:
807 { $$ = NULL; }
808| EXTENDS_TK class_type
809 { $$ = $2; }
810| EXTENDS_TK class_type error
811 {yyerror ("'{' expected"); ctxp->class_err=1;}
812| EXTENDS_TK error
813 {yyerror ("Missing super class name"); ctxp->class_err=1;}
814;
815
816interfaces:
817 { $$ = NULL_TREE; }
818| IMPLEMENTS_TK interface_type_list
819 { $$ = $2; }
820| IMPLEMENTS_TK error
821 {
822 ctxp->class_err=1;
823 yyerror ("Missing interface name");
824 }
825;
826
827interface_type_list:
828 interface_type
829 {
830 ctxp->interface_number = 1;
831 $$ = build_tree_list ($1, NULL_TREE);
832 }
833| interface_type_list C_TK interface_type
834 {
835 ctxp->interface_number++;
836 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
837 }
838| interface_type_list C_TK error
839 {yyerror ("Missing interface name"); RECOVER;}
840;
841
842class_body:
843 OCB_TK CCB_TK
7f10c2e2
APB		 844 {
845 /* Store the location of the `}' when doing xrefs */
846 if (flag_emit_xref)
c2952b01 847 DECL_END_SOURCE_LINE (GET_CPC ()) =
7f10c2e2 848 EXPR_WFL_ADD_COL ($2.location, 1);
c2952b01 849 $$ = GET_CPC ();
7f10c2e2 850 }
e04a16fb 851| OCB_TK class_body_declarations CCB_TK
7f10c2e2
APB		 852 {
853 /* Store the location of the `}' when doing xrefs */
854 if (flag_emit_xref)
c2952b01 855 DECL_END_SOURCE_LINE (GET_CPC ()) =
7f10c2e2 856 EXPR_WFL_ADD_COL ($3.location, 1);
c2952b01 857 $$ = GET_CPC ();
7f10c2e2 858 }
e04a16fb
AG		 859;
860
861class_body_declarations:
862 class_body_declaration
863| class_body_declarations class_body_declaration
864;
865
866class_body_declaration:
867 class_member_declaration
868| static_initializer
869| constructor_declaration
870| block /* Added, JDK1.1, instance initializer */
c2952b01
APB		 871 {
872 TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
873 SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
874 }
e04a16fb
AG		 875;
876
877class_member_declaration:
878 field_declaration
0b4d333e
APB		 879| field_declaration SC_TK
880 { $$ = $1; }
e04a16fb
AG		 881| method_declaration
882| class_declaration /* Added, JDK1.1 inner classes */
c2952b01
APB		 883 { end_class_declaration (1); }
884| interface_declaration /* Added, JDK1.1 inner interfaces */
885 { end_class_declaration (1); }
e04a16fb
AG		 886;
887
888/* 19.8.2 Productions from 8.3: Field Declarations */
889field_declaration:
890 type variable_declarators SC_TK
891 { register_fields (0, $1, $2); }
892| modifiers type variable_declarators SC_TK
893 {
e04a16fb
AG		 894 check_modifiers
895 ("Illegal modifier `%s' for field declaration",
896 $1, FIELD_MODIFIERS);
897 check_modifiers_consistency ($1);
898 register_fields ($1, $2, $3);
899 }
900;
901
902variable_declarators:
903 /* Should we use build_decl_list () instead ? FIXME */
904 variable_declarator /* Default rule */
905| variable_declarators C_TK variable_declarator
906 { $$ = chainon ($1, $3); }
907| variable_declarators C_TK error
908 {yyerror ("Missing term"); RECOVER;}
909;
910
911variable_declarator:
912 variable_declarator_id
913 { $$ = build_tree_list ($1, NULL_TREE); }
914| variable_declarator_id ASSIGN_TK variable_initializer
915 {
916 if (java_error_count)
917 $3 = NULL_TREE;
918 $$ = build_tree_list
919 ($1, build_assignment ($2.token, $2.location, $1, $3));
920 }
921| variable_declarator_id ASSIGN_TK error
922 {
923 yyerror ("Missing variable initializer");
924 $$ = build_tree_list ($1, NULL_TREE);
925 RECOVER;
926 }
927| variable_declarator_id ASSIGN_TK variable_initializer error
928 {
929 yyerror ("';' expected");
930 $$ = build_tree_list ($1, NULL_TREE);
931 RECOVER;
932 }
933;
934
935variable_declarator_id:
936 identifier
937| variable_declarator_id OSB_TK CSB_TK
c583dd46 938 { $$ = build_unresolved_array_type ($1); }
e04a16fb
AG		 939| identifier error
940 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
941| variable_declarator_id OSB_TK error
942 {yyerror ("']' expected"); DRECOVER(vdi);}
943| variable_declarator_id CSB_TK error
944 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
945;
946
947variable_initializer:
948 expression
949| array_initializer
e04a16fb
AG		 950;
951
952/* 19.8.3 Productions from 8.4: Method Declarations */
953method_declaration:
954 method_header
955 {
956 current_function_decl = $1;
c2952b01
APB		 957 if (current_function_decl
958 && TREE_CODE (current_function_decl) == FUNCTION_DECL)
959 source_start_java_method (current_function_decl);
960 else
961 current_function_decl = NULL_TREE;
e04a16fb
AG		 962 }
963 method_body
b635eb2f 964 { finish_method_declaration ($3); }
e04a16fb
AG		 965| method_header error
966 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
967;
968
969method_header:
970 type method_declarator throws
b9f7e36c 971 { $$ = method_header (0, $1, $2, $3); }
e04a16fb 972| VOID_TK method_declarator throws
b9f7e36c 973 { $$ = method_header (0, void_type_node, $2, $3); }
e04a16fb 974| modifiers type method_declarator throws
b9f7e36c 975 { $$ = method_header ($1, $2, $3, $4); }
e04a16fb 976| modifiers VOID_TK method_declarator throws
b9f7e36c 977 { $$ = method_header ($1, void_type_node, $3, $4); }
e04a16fb 978| type error
efa0a23f
APB		 979 {
980 yyerror ("Invalid method declaration, method name required");
981 RECOVER;
982 }
e04a16fb
AG		 983| modifiers type error
984 {RECOVER;}
985| VOID_TK error
986 {yyerror ("Identifier expected"); RECOVER;}
987| modifiers VOID_TK error
988 {yyerror ("Identifier expected"); RECOVER;}
989| modifiers error
990 {
991 yyerror ("Invalid method declaration, return type required");
992 RECOVER;
993 }
994;
995
996method_declarator:
997 identifier OP_TK CP_TK
c2952b01
APB		 998 {
999 ctxp->formal_parameter_number = 0;
1000 $$ = method_declarator ($1, NULL_TREE);
1001 }
e04a16fb
AG		 1002| identifier OP_TK formal_parameter_list CP_TK
1003 { $$ = method_declarator ($1, $3); }
1004| method_declarator OSB_TK CSB_TK
1005 {
1886c9d8
APB		 1006 EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1007 TREE_PURPOSE ($1) =
1008 build_unresolved_array_type (TREE_PURPOSE ($1));
1009 parse_warning_context
1010 (wfl_operator,
1011 "Discouraged form of returned type specification");
e04a16fb
AG		 1012 }
1013| identifier OP_TK error
1014 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1015| method_declarator OSB_TK error
1016 {yyerror ("']' expected"); RECOVER;}
1017;
1018
1019formal_parameter_list:
1020 formal_parameter
1021 {
1022 ctxp->formal_parameter_number = 1;
1023 }
1024| formal_parameter_list C_TK formal_parameter
1025 {
1026 ctxp->formal_parameter_number += 1;
1027 $$ = chainon ($1, $3);
1028 }
1029| formal_parameter_list C_TK error
c2952b01 1030 { yyerror ("Missing formal parameter term"); RECOVER; }
e04a16fb
AG		 1031;
1032
1033formal_parameter:
1034 type variable_declarator_id
1035 {
1036 $$ = build_tree_list ($2, $1);
1037 }
18990de5 1038| final type variable_declarator_id /* Added, JDK1.1 final parms */
5256aa37 1039 {
5256aa37 1040 $$ = build_tree_list ($3, $2);
c2952b01 1041 ARG_FINAL_P ($$) = 1;
5256aa37 1042 }
e04a16fb 1043| type error
f8989a66
APB		 1044 {
1045 yyerror ("Missing identifier"); RECOVER;
1046 $$ = NULL_TREE;
1047 }
18990de5 1048| final type error
e04a16fb 1049 {
e04a16fb 1050 yyerror ("Missing identifier"); RECOVER;
f8989a66 1051 $$ = NULL_TREE;
e04a16fb
AG		 1052 }
1053;
1054
18990de5
JB		 1055final:
1056 modifiers
1057 {
1058 check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1059 $1, ACC_FINAL);
1060 if ($1 != ACC_FINAL)
1061 MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1062 }
1063;
1064
e04a16fb 1065throws:
b9f7e36c 1066 { $$ = NULL_TREE; }
e04a16fb 1067| THROWS_TK class_type_list
b9f7e36c 1068 { $$ = $2; }
e04a16fb
AG		 1069| THROWS_TK error
1070 {yyerror ("Missing class type term"); RECOVER;}
1071;
1072
1073class_type_list:
1074 class_type
c877974e 1075 { $$ = build_tree_list ($1, $1); }
e04a16fb 1076| class_type_list C_TK class_type
c877974e 1077 { $$ = tree_cons ($3, $3, $1); }
e04a16fb
AG		 1078| class_type_list C_TK error
1079 {yyerror ("Missing class type term"); RECOVER;}
1080;
1081
1082method_body:
1083 block
1084| block SC_TK
1085| SC_TK
1086 { $$ = NULL_TREE; } /* Probably not the right thing to do. */
1087;
1088
1089/* 19.8.4 Productions from 8.5: Static Initializers */
1090static_initializer:
1091 static block
1092 {
c2952b01
APB		 1093 TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1094 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
e04a16fb
AG		 1095 }
1096| static block SC_TK /* Shouldn't be here. FIXME */
1097 {
c2952b01
APB		 1098 TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1099 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
e04a16fb
AG		 1100 }
1101;
1102
1103static: /* Test lval.sub_token here */
c2952b01 1104 modifiers
e04a16fb 1105 {
c2952b01
APB		 1106 check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1107 /* Can't have a static initializer in an innerclass */
1108 if ($1 | ACC_STATIC &&
1109 GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1110 parse_error_context
1111 (MODIFIER_WFL (STATIC_TK),
1112 "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1113 IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
e04a16fb
AG		 1114 SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1115 }
1116;
1117
1118/* 19.8.5 Productions from 8.6: Constructor Declarations */
e04a16fb 1119constructor_declaration:
22eed1e6 1120 constructor_header
e04a16fb 1121 {
22eed1e6
APB		 1122 current_function_decl = $1;
1123 source_start_java_method (current_function_decl);
e04a16fb 1124 }
22eed1e6 1125 constructor_body
b635eb2f 1126 { finish_method_declaration ($3); }
22eed1e6
APB		 1127;
1128
1129constructor_header:
1130 constructor_declarator throws
1131 { $$ = method_header (0, NULL_TREE, $1, $2); }
1132| modifiers constructor_declarator throws
1133 { $$ = method_header ($1, NULL_TREE, $2, $3); }
e04a16fb
AG		 1134;
1135
1136constructor_declarator:
1137 simple_name OP_TK CP_TK
c2952b01
APB		 1138 {
1139 ctxp->formal_parameter_number = 0;
1140 $$ = method_declarator ($1, NULL_TREE);
1141 }
e04a16fb 1142| simple_name OP_TK formal_parameter_list CP_TK
22eed1e6 1143 { $$ = method_declarator ($1, $3); }
e04a16fb
AG		 1144;
1145
1146constructor_body:
22eed1e6
APB		 1147 /* Unlike regular method, we always need a complete (empty)
1148 body so we can safely perform all the required code
1149 addition (super invocation and field initialization) */
2e5eb5c5 1150 block_begin constructor_block_end
22eed1e6 1151 {
9bbc7d9f 1152 BLOCK_EXPR_BODY ($2) = empty_stmt_node;
22eed1e6
APB		 1153 $$ = $2;
1154 }
2e5eb5c5 1155| block_begin explicit_constructor_invocation constructor_block_end
22eed1e6 1156 { $$ = $3; }
2e5eb5c5 1157| block_begin block_statements constructor_block_end
22eed1e6 1158 { $$ = $3; }
2e5eb5c5 1159| block_begin explicit_constructor_invocation block_statements constructor_block_end
22eed1e6 1160 { $$ = $4; }
e04a16fb
AG		 1161;
1162
2e5eb5c5
APB		 1163constructor_block_end:
1164 block_end
1165| block_end SC_TK
1166
e04a16fb
AG		 1167/* Error recovery for that rule moved down expression_statement: rule. */
1168explicit_constructor_invocation:
1169 this_or_super OP_TK CP_TK SC_TK
22eed1e6
APB		 1170 {
1171 $$ = build_method_invocation ($1, NULL_TREE);
1172 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1173 $$ = java_method_add_stmt (current_function_decl, $$);
1174 }
e04a16fb 1175| this_or_super OP_TK argument_list CP_TK SC_TK
22eed1e6
APB		 1176 {
1177 $$ = build_method_invocation ($1, $3);
1178 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1179 $$ = java_method_add_stmt (current_function_decl, $$);
1180 }
e04a16fb
AG		 1181 /* Added, JDK1.1 inner classes. Modified because the rule
1182 'primary' couldn't work. */
1183| name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
b67d701b 1184 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
e04a16fb 1185| name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
b67d701b 1186 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
e04a16fb
AG		 1187;
1188
1189this_or_super: /* Added, simplifies error diagnostics */
1190 THIS_TK
1191 {
9ee9b555 1192 tree wfl = build_wfl_node (this_identifier_node);
e04a16fb
AG		 1193 EXPR_WFL_LINECOL (wfl) = $1.location;
1194 $$ = wfl;
1195 }
1196| SUPER_TK
1197 {
9ee9b555 1198 tree wfl = build_wfl_node (super_identifier_node);
e04a16fb
AG		 1199 EXPR_WFL_LINECOL (wfl) = $1.location;
1200 $$ = wfl;
1201 }
1202;
1203
1204/* 19.9 Productions from 9: Interfaces */
1205/* 19.9.1 Productions from 9.1: Interfaces Declarations */
1206interface_declaration:
1207 INTERFACE_TK identifier
1208 { create_interface (0, $2, NULL_TREE); }
1209 interface_body
e04a16fb
AG		 1210| modifiers INTERFACE_TK identifier
1211 { create_interface ($1, $3, NULL_TREE); }
1212 interface_body
e04a16fb
AG		 1213| INTERFACE_TK identifier extends_interfaces
1214 { create_interface (0, $2, $3); }
1215 interface_body
e04a16fb
AG		 1216| modifiers INTERFACE_TK identifier extends_interfaces
1217 { create_interface ($1, $3, $4); }
1218 interface_body
e04a16fb 1219| INTERFACE_TK identifier error
0b4d333e 1220 {yyerror ("'{' expected"); RECOVER;}
e04a16fb 1221| modifiers INTERFACE_TK identifier error
0b4d333e 1222 {yyerror ("'{' expected"); RECOVER;}
e04a16fb
AG		 1223;
1224
1225extends_interfaces:
1226 EXTENDS_TK interface_type
1227 {
1228 ctxp->interface_number = 1;
1229 $$ = build_tree_list ($2, NULL_TREE);
1230 }
1231| extends_interfaces C_TK interface_type
1232 {
1233 ctxp->interface_number++;
1234 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1235 }
1236| EXTENDS_TK error
1237 {yyerror ("Invalid interface type"); RECOVER;}
1238| extends_interfaces C_TK error
1239 {yyerror ("Missing term"); RECOVER;}
1240;
1241
1242interface_body:
1243 OCB_TK CCB_TK
1244 { $$ = NULL_TREE; }
1245| OCB_TK interface_member_declarations CCB_TK
1246 { $$ = NULL_TREE; }
1247;
1248
1249interface_member_declarations:
1250 interface_member_declaration
1251| interface_member_declarations interface_member_declaration
1252;
1253
1254interface_member_declaration:
1255 constant_declaration
1256| abstract_method_declaration
1257| class_declaration /* Added, JDK1.1 inner classes */
c2952b01
APB		 1258 { end_class_declaration (1); }
1259| interface_declaration /* Added, JDK1.1 inner interfaces */
1260 { end_class_declaration (1); }
e04a16fb
AG		 1261;
1262
1263constant_declaration:
1264 field_declaration
1265;
1266
1267abstract_method_declaration:
1268 method_header SC_TK
1269 {
1270 check_abstract_method_header ($1);
1271 current_function_decl = NULL_TREE; /* FIXME ? */
1272 }
1273| method_header error
1274 {yyerror ("';' expected"); RECOVER;}
1275;
1276
1277/* 19.10 Productions from 10: Arrays */
1278array_initializer:
1279 OCB_TK CCB_TK
1179ebc2 1280 { $$ = build_new_array_init ($1.location, NULL_TREE); }
e04a16fb 1281| OCB_TK variable_initializers CCB_TK
f8976021 1282 { $$ = build_new_array_init ($1.location, $2); }
e04a16fb 1283| OCB_TK variable_initializers C_TK CCB_TK
f8976021 1284 { $$ = build_new_array_init ($1.location, $2); }
e04a16fb
AG		 1285;
1286
1287variable_initializers:
1288 variable_initializer
f8976021
APB		 1289 {
1290 $$ = tree_cons (maybe_build_array_element_wfl ($1),
1291 $1, NULL_TREE);
1292 }
e04a16fb 1293| variable_initializers C_TK variable_initializer
1179ebc2
APB		 1294 {
1295 $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1296 }
e04a16fb
AG		 1297| variable_initializers C_TK error
1298 {yyerror ("Missing term"); RECOVER;}
1299;
1300
1301/* 19.11 Production from 14: Blocks and Statements */
1302block:
1303 OCB_TK CCB_TK
7f10c2e2
APB		 1304 {
1305 /* Store the location of the `}' when doing xrefs */
1306 if (current_function_decl && flag_emit_xref)
1307 DECL_END_SOURCE_LINE (current_function_decl) =
1308 EXPR_WFL_ADD_COL ($2.location, 1);
1309 $$ = empty_stmt_node;
1310 }
22eed1e6
APB		 1311| block_begin block_statements block_end
1312 { $$ = $3; }
1313;
1314
1315block_begin:
1316 OCB_TK
e04a16fb 1317 { enter_block (); }
22eed1e6
APB		 1318;
1319
1320block_end:
e04a16fb
AG		 1321 CCB_TK
1322 {
1323 maybe_absorb_scoping_blocks ();
7f10c2e2
APB		 1324 /* Store the location of the `}' when doing xrefs */
1325 if (current_function_decl && flag_emit_xref)
1326 DECL_END_SOURCE_LINE (current_function_decl) =
1327 EXPR_WFL_ADD_COL ($1.location, 1);
e04a16fb
AG		 1328 $$ = exit_block ();
1329 }
1330;
1331
1332block_statements:
1333 block_statement
1334| block_statements block_statement
1335;
1336
1337block_statement:
1338 local_variable_declaration_statement
1339| statement
15fdcfe9 1340 { java_method_add_stmt (current_function_decl, $1); }
c2952b01
APB		 1341| class_declaration /* Added, JDK1.1 local classes */
1342 {
1343 LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1344 end_class_declaration (1);
1345 }
e04a16fb
AG		 1346;
1347
1348local_variable_declaration_statement:
1349 local_variable_declaration SC_TK /* Can't catch missing ';' here */
1350;
1351
1352local_variable_declaration:
1353 type variable_declarators
1354 { declare_local_variables (0, $1, $2); }
a003f638 1355| final type variable_declarators /* Added, JDK1.1 final locals */
e04a16fb
AG		 1356 { declare_local_variables ($1, $2, $3); }
1357;
1358
1359statement:
1360 statement_without_trailing_substatement
1361| labeled_statement
e04a16fb 1362| if_then_statement
e04a16fb 1363| if_then_else_statement
e04a16fb 1364| while_statement
e04a16fb 1365| for_statement
cd9643f7 1366 { $$ = exit_block (); }
e04a16fb
AG		 1367;
1368
1369statement_nsi:
1370 statement_without_trailing_substatement
1371| labeled_statement_nsi
e04a16fb 1372| if_then_else_statement_nsi
e04a16fb 1373| while_statement_nsi
e04a16fb 1374| for_statement_nsi
9dd939b2 1375 { $$ = exit_block (); }
e04a16fb
AG		 1376;
1377
1378statement_without_trailing_substatement:
1379 block
e04a16fb 1380| empty_statement
e04a16fb 1381| expression_statement
e04a16fb 1382| switch_statement
e04a16fb 1383| do_statement
e04a16fb 1384| break_statement
e04a16fb 1385| continue_statement
e04a16fb
AG		 1386| return_statement
1387| synchronized_statement
e04a16fb 1388| throw_statement
e04a16fb 1389| try_statement
e04a16fb
AG		 1390;
1391
1392empty_statement:
1393 SC_TK
9bbc7d9f 1394 { $$ = empty_stmt_node; }
e04a16fb
AG		 1395;
1396
1397label_decl:
1398 identifier REL_CL_TK
1399 {
1400 $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
0a2138e2 1401 EXPR_WFL_NODE ($1));
e04a16fb
AG		 1402 pushlevel (2);
1403 push_labeled_block ($$);
1404 PUSH_LABELED_BLOCK ($$);
1405 }
1406;
1407
1408labeled_statement:
1409 label_decl statement
b635eb2f 1410 { $$ = finish_labeled_statement ($1, $2); }
e04a16fb
AG		 1411| identifier error
1412 {yyerror ("':' expected"); RECOVER;}
1413;
1414
1415labeled_statement_nsi:
1416 label_decl statement_nsi
b635eb2f 1417 { $$ = finish_labeled_statement ($1, $2); }
e04a16fb
AG		 1418;
1419
1420/* We concentrate here a bunch of error handling rules that we couldn't write
1421 earlier, because expression_statement catches a missing ';'. */
1422expression_statement:
1423 statement_expression SC_TK
1424 {
1425 /* We have a statement. Generate a WFL around it so
1426 we can debug it */
1427 $$ = build_expr_wfl ($1, input_filename, lineno, 0);
1428 /* We know we have a statement, so set the debug
1429 info to be eventually generate here. */
1430 $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1431 }
1432| error SC_TK
1433 {
1434 if (ctxp->prevent_ese != lineno)
1435 yyerror ("Invalid expression statement");
1436 DRECOVER (expr_stmt);
1437 }
1438| error OCB_TK
1439 {
1440 if (ctxp->prevent_ese != lineno)
1441 yyerror ("Invalid expression statement");
1442 DRECOVER (expr_stmt);
1443 }
1444| error CCB_TK
1445 {
1446 if (ctxp->prevent_ese != lineno)
1447 yyerror ("Invalid expression statement");
1448 DRECOVER (expr_stmt);
1449 }
1450| this_or_super OP_TK error
1451 {yyerror ("')' expected"); RECOVER;}
1452| this_or_super OP_TK CP_TK error
22eed1e6 1453 {
8119c720 1454 parse_ctor_invocation_error ();
22eed1e6
APB		 1455 RECOVER;
1456 }
e04a16fb
AG		 1457| this_or_super OP_TK argument_list error
1458 {yyerror ("')' expected"); RECOVER;}
1459| this_or_super OP_TK argument_list CP_TK error
22eed1e6 1460 {
8119c720 1461 parse_ctor_invocation_error ();
22eed1e6
APB		 1462 RECOVER;
1463 }
e04a16fb
AG		 1464| name DOT_TK SUPER_TK error
1465 {yyerror ("'(' expected"); RECOVER;}
1466| name DOT_TK SUPER_TK OP_TK error
1467 {yyerror ("')' expected"); RECOVER;}
1468| name DOT_TK SUPER_TK OP_TK argument_list error
1469 {yyerror ("')' expected"); RECOVER;}
1470| name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1471 {yyerror ("';' expected"); RECOVER;}
1472| name DOT_TK SUPER_TK OP_TK CP_TK error
1473 {yyerror ("';' expected"); RECOVER;}
1474;
1475
1476statement_expression:
1477 assignment
1478| pre_increment_expression
e04a16fb 1479| pre_decrement_expression
e04a16fb 1480| post_increment_expression
e04a16fb 1481| post_decrement_expression
e04a16fb
AG		 1482| method_invocation
1483| class_instance_creation_expression
e04a16fb
AG		 1484;
1485
1486if_then_statement:
1487 IF_TK OP_TK expression CP_TK statement
2aa11e97
APB		 1488 {
1489 $$ = build_if_else_statement ($2.location, $3,
1490 $5, NULL_TREE);
1491 }
e04a16fb
AG		 1492| IF_TK error
1493 {yyerror ("'(' expected"); RECOVER;}
1494| IF_TK OP_TK error
1495 {yyerror ("Missing term"); RECOVER;}
1496| IF_TK OP_TK expression error
1497 {yyerror ("')' expected"); RECOVER;}
1498;
1499
1500if_then_else_statement:
1501 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
2aa11e97 1502 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
e04a16fb
AG		 1503;
1504
1505if_then_else_statement_nsi:
1506 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
2aa11e97 1507 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
e04a16fb
AG		 1508;
1509
1510switch_statement:
15fdcfe9
PB		 1511 switch_expression
1512 {
1513 enter_block ();
1514 }
1515 switch_block
b67d701b 1516 {
15fdcfe9 1517 /* Make into "proper list" of COMPOUND_EXPRs.
f8976021
APB		 1518 I.e. make the last statment also have its own
1519 COMPOUND_EXPR. */
15fdcfe9
PB		 1520 maybe_absorb_scoping_blocks ();
1521 TREE_OPERAND ($1, 1) = exit_block ();
b67d701b
PB		 1522 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1523 }
1524;
1525
1526switch_expression:
1527 SWITCH_TK OP_TK expression CP_TK
1528 {
1529 $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1530 EXPR_WFL_LINECOL ($$) = $2.location;
1531 }
e04a16fb
AG		 1532| SWITCH_TK error
1533 {yyerror ("'(' expected"); RECOVER;}
1534| SWITCH_TK OP_TK error
1535 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1536| SWITCH_TK OP_TK expression CP_TK error
1537 {yyerror ("'{' expected"); RECOVER;}
1538;
1539
f8976021
APB		 1540/* Default assignment is there to avoid type node on switch_block
1541 node. */
1542
e04a16fb
AG		 1543switch_block:
1544 OCB_TK CCB_TK
f8976021 1545 { $$ = NULL_TREE; }
e04a16fb 1546| OCB_TK switch_labels CCB_TK
f8976021 1547 { $$ = NULL_TREE; }
e04a16fb 1548| OCB_TK switch_block_statement_groups CCB_TK
f8976021 1549 { $$ = NULL_TREE; }
e04a16fb 1550| OCB_TK switch_block_statement_groups switch_labels CCB_TK
f8976021 1551 { $$ = NULL_TREE; }
e04a16fb
AG		 1552;
1553
1554switch_block_statement_groups:
1555 switch_block_statement_group
1556| switch_block_statement_groups switch_block_statement_group
1557;
1558
1559switch_block_statement_group:
15fdcfe9 1560 switch_labels block_statements
e04a16fb
AG		 1561;
1562
e04a16fb
AG		 1563switch_labels:
1564 switch_label
1565| switch_labels switch_label
1566;
1567
1568switch_label:
1569 CASE_TK constant_expression REL_CL_TK
b67d701b 1570 {
15fdcfe9
PB		 1571 tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1572 EXPR_WFL_LINECOL (lab) = $1.location;
1573 java_method_add_stmt (current_function_decl, lab);
b67d701b 1574 }
e04a16fb 1575| DEFAULT_TK REL_CL_TK
b67d701b 1576 {
15fdcfe9
PB		 1577 tree lab = build1 (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1578 EXPR_WFL_LINECOL (lab) = $1.location;
1579 java_method_add_stmt (current_function_decl, lab);
b67d701b 1580 }
e04a16fb
AG		 1581| CASE_TK error
1582 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1583| CASE_TK constant_expression error
1584 {yyerror ("':' expected"); RECOVER;}
1585| DEFAULT_TK error
1586 {yyerror ("':' expected"); RECOVER;}
1587;
1588
1589while_expression:
1590 WHILE_TK OP_TK expression CP_TK
1591 {
1592 tree body = build_loop_body ($2.location, $3, 0);
1593 $$ = build_new_loop (body);
1594 }
1595;
1596
1597while_statement:
1598 while_expression statement
b635eb2f 1599 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
e04a16fb
AG		 1600| WHILE_TK error
1601 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1602| WHILE_TK OP_TK error
1603 {yyerror ("Missing term and ')' expected"); RECOVER;}
1604| WHILE_TK OP_TK expression error
1605 {yyerror ("')' expected"); RECOVER;}
1606;
1607
1608while_statement_nsi:
1609 while_expression statement_nsi
b635eb2f 1610 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
e04a16fb
AG		 1611;
1612
1613do_statement_begin:
1614 DO_TK
1615 {
1616 tree body = build_loop_body (0, NULL_TREE, 1);
1617 $$ = build_new_loop (body);
1618 }
1619 /* Need error handing here. FIXME */
1620;
1621
1622do_statement:
1623 do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
b635eb2f 1624 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
e04a16fb
AG		 1625;
1626
1627for_statement:
1628 for_begin SC_TK expression SC_TK for_update CP_TK statement
b635eb2f 1629 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7); }
e04a16fb
AG		 1630| for_begin SC_TK SC_TK for_update CP_TK statement
1631 {
b635eb2f 1632 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
e04a16fb
AG		 1633 /* We have not condition, so we get rid of the EXIT_EXPR */
1634 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
9bbc7d9f 1635 empty_stmt_node;
e04a16fb
AG		 1636 }
1637| for_begin SC_TK error
1638 {yyerror ("Invalid control expression"); RECOVER;}
1639| for_begin SC_TK expression SC_TK error
1640 {yyerror ("Invalid update expression"); RECOVER;}
1641| for_begin SC_TK SC_TK error
1642 {yyerror ("Invalid update expression"); RECOVER;}
1643;
1644
1645for_statement_nsi:
1646 for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
b635eb2f 1647 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
e04a16fb
AG		 1648| for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1649 {
b635eb2f 1650 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
e04a16fb
AG		 1651 /* We have not condition, so we get rid of the EXIT_EXPR */
1652 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
9bbc7d9f 1653 empty_stmt_node;
e04a16fb
AG		 1654 }
1655;
1656
1657for_header:
1658 FOR_TK OP_TK
1659 {
1660 /* This scope defined for local variable that may be
1661 defined within the scope of the for loop */
1662 enter_block ();
1663 }
1664| FOR_TK error
1665 {yyerror ("'(' expected"); DRECOVER(for_1);}
1666| FOR_TK OP_TK error
1667 {yyerror ("Invalid init statement"); RECOVER;}
1668;
1669
1670for_begin:
1671 for_header for_init
1672 {
1673 /* We now declare the loop body. The loop is
1674 declared as a for loop. */
1675 tree body = build_loop_body (0, NULL_TREE, 0);
1676 $$ = build_new_loop (body);
c2952b01 1677 FOR_LOOP_P ($$) = 1;
e04a16fb
AG		 1678 /* The loop is added to the current block the for
1679 statement is defined within */
1680 java_method_add_stmt (current_function_decl, $$);
1681 }
1682;
1683for_init: /* Can be empty */
9bbc7d9f 1684 { $$ = empty_stmt_node; }
e04a16fb
AG		 1685| statement_expression_list
1686 {
1687 /* Init statement recorded within the previously
1688 defined block scope */
1689 $$ = java_method_add_stmt (current_function_decl, $1);
1690 }
1691| local_variable_declaration
1692 {
1693 /* Local variable are recorded within the previously
1694 defined block scope */
1695 $$ = NULL_TREE;
1696 }
1697| statement_expression_list error
1698 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1699;
1700
1701for_update: /* Can be empty */
9bbc7d9f 1702 {$$ = empty_stmt_node;}
e04a16fb
AG		 1703| statement_expression_list
1704 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1705;
1706
1707statement_expression_list:
1708 statement_expression
1709 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1710| statement_expression_list C_TK statement_expression
1711 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1712| statement_expression_list C_TK error
1713 {yyerror ("Missing term"); RECOVER;}
1714;
1715
1716break_statement:
1717 BREAK_TK SC_TK
1718 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1719| BREAK_TK identifier SC_TK
1720 { $$ = build_bc_statement ($1.location, 1, $2); }
1721| BREAK_TK error
1722 {yyerror ("Missing term"); RECOVER;}
1723| BREAK_TK identifier error
1724 {yyerror ("';' expected"); RECOVER;}
1725;
1726
1727continue_statement:
1728 CONTINUE_TK SC_TK
1729 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1730| CONTINUE_TK identifier SC_TK
1731 { $$ = build_bc_statement ($1.location, 0, $2); }
1732| CONTINUE_TK error
1733 {yyerror ("Missing term"); RECOVER;}
1734| CONTINUE_TK identifier error
1735 {yyerror ("';' expected"); RECOVER;}
1736;
1737
1738return_statement:
1739 RETURN_TK SC_TK
1740 { $$ = build_return ($1.location, NULL_TREE); }
1741| RETURN_TK expression SC_TK
1742 { $$ = build_return ($1.location, $2); }
1743| RETURN_TK error
1744 {yyerror ("Missing term"); RECOVER;}
1745| RETURN_TK expression error
1746 {yyerror ("';' expected"); RECOVER;}
1747;
1748
1749throw_statement:
1750 THROW_TK expression SC_TK
b9f7e36c
APB		 1751 {
1752 $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1753 EXPR_WFL_LINECOL ($$) = $1.location;
1754 }
e04a16fb
AG		 1755| THROW_TK error
1756 {yyerror ("Missing term"); RECOVER;}
1757| THROW_TK expression error
1758 {yyerror ("';' expected"); RECOVER;}
1759;
1760
1761synchronized_statement:
1762 synchronized OP_TK expression CP_TK block
b9f7e36c
APB		 1763 {
1764 $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1765 EXPR_WFL_LINECOL ($$) =
1766 EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1767 }
e04a16fb
AG		 1768| synchronized OP_TK expression CP_TK error
1769 {yyerror ("'{' expected"); RECOVER;}
1770| synchronized error
1771 {yyerror ("'(' expected"); RECOVER;}
1772| synchronized OP_TK error CP_TK
1773 {yyerror ("Missing term"); RECOVER;}
1774| synchronized OP_TK error
1775 {yyerror ("Missing term"); RECOVER;}
1776;
1777
b9f7e36c 1778synchronized:
efa0a23f 1779 modifiers
e04a16fb 1780 {
781b0558
KG		 1781 check_modifiers (
1782 "Illegal modifier `%s'. Only `synchronized' was expected here",
efa0a23f
APB		 1783 $1, ACC_SYNCHRONIZED);
1784 if ($1 != ACC_SYNCHRONIZED)
1785 MODIFIER_WFL (SYNCHRONIZED_TK) =
1786 build_wfl_node (NULL_TREE);
e04a16fb
AG		 1787 }
1788;
1789
1790try_statement:
1791 TRY_TK block catches
a7d8d81f 1792 { $$ = build_try_statement ($1.location, $2, $3); }
e04a16fb 1793| TRY_TK block finally
a7d8d81f 1794 { $$ = build_try_finally_statement ($1.location, $2, $3); }
e04a16fb 1795| TRY_TK block catches finally
2aa11e97
APB		 1796 { $$ = build_try_finally_statement
1797 ($1.location, build_try_statement ($1.location,
1798 $2, $3), $4);
1799 }
e04a16fb
AG		 1800| TRY_TK error
1801 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1802;
1803
1804catches:
1805 catch_clause
1806| catches catch_clause
b67d701b
PB		 1807 {
1808 TREE_CHAIN ($2) = $1;
1809 $$ = $2;
1810 }
e04a16fb
AG		 1811;
1812
1813catch_clause:
b67d701b
PB		 1814 catch_clause_parameter block
1815 {
1816 java_method_add_stmt (current_function_decl, $2);
1817 exit_block ();
1818 $$ = $1;
1819 }
1820
1821catch_clause_parameter:
1822 CATCH_TK OP_TK formal_parameter CP_TK
1823 {
1824 /* We add a block to define a scope for
1825 formal_parameter (CCBP). The formal parameter is
1826 declared initialized by the appropriate function
1827 call */
1828 tree ccpb = enter_block ();
1829 tree init = build_assignment (ASSIGN_TK, $2.location,
1830 TREE_PURPOSE ($3),
1831 soft_exceptioninfo_call_node);
1832 declare_local_variables (0, TREE_VALUE ($3),
1833 build_tree_list (TREE_PURPOSE ($3),
1834 init));
1835 $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1836 EXPR_WFL_LINECOL ($$) = $1.location;
1837 }
e04a16fb 1838| CATCH_TK error
97f30284 1839 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
e04a16fb 1840| CATCH_TK OP_TK error
97f30284
APB		 1841 {
1842 yyerror ("Missing term or ')' expected");
1843 RECOVER; $$ = NULL_TREE;
1844 }
b67d701b 1845| CATCH_TK OP_TK error CP_TK /* That's for () */
97f30284 1846 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
e04a16fb
AG		 1847;
1848
1849finally:
1850 FINALLY_TK block
a7d8d81f 1851 { $$ = $2; }
e04a16fb
AG		 1852| FINALLY_TK error
1853 {yyerror ("'{' expected"); RECOVER; }
1854;
1855
1856/* 19.12 Production from 15: Expressions */
1857primary:
1858 primary_no_new_array
1859| array_creation_expression
1860;
1861
1862primary_no_new_array:
1863 literal
1864| THIS_TK
1865 { $$ = build_this ($1.location); }
1866| OP_TK expression CP_TK
1867 {$$ = $2;}
1868| class_instance_creation_expression
1869| field_access
1870| method_invocation
1871| array_access
c2952b01 1872| type_literals
e04a16fb
AG		 1873 /* Added, JDK1.1 inner classes. Documentation is wrong
1874 refering to a 'ClassName' (class_name) rule that doesn't
c2952b01 1875 exist. Used name: instead. */
e04a16fb 1876| name DOT_TK THIS_TK
c2952b01
APB		 1877 {
1878 tree wfl = build_wfl_node (this_identifier_node);
1879 $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1880 }
e04a16fb
AG		 1881| OP_TK expression error
1882 {yyerror ("')' expected"); RECOVER;}
1883| name DOT_TK error
1884 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1885| primitive_type DOT_TK error
1886 {yyerror ("'class' expected" ); RECOVER;}
1887| VOID_TK DOT_TK error
1888 {yyerror ("'class' expected" ); RECOVER;}
1889;
1890
c2952b01
APB		 1891/* Added, JDK1.1 type literals. We can't use `type' directly, so we
1892 broke the rule down a bit. */
1893
1894array_type_literal:
1895 primitive_type OSB_TK CSB_TK
1896 {
1897 $$ = build_java_array_type ($1, -1);
1898 CLASS_LOADED_P ($$) = 1;
1899 }
1900| name OSB_TK CSB_TK
1901 { $$ = build_unresolved_array_type ($1); }
1902/* This triggers two reduce/reduce conflict between array_type_literal and
1903 dims. FIXME.
1904| array_type OSB_TK CSB_TK
1905 { $$ = build_unresolved_array_type ($1); }
1906*/
1907;
1908
1909type_literals:
1910 name DOT_TK CLASS_TK
1911 { $$ = build_incomplete_class_ref ($2.location, $1); }
1912| array_type_literal DOT_TK CLASS_TK
1913 { $$ = build_incomplete_class_ref ($2.location, $1); }
1914| primitive_type DOT_TK CLASS_TK
1915 { $$ = build_class_ref ($1); }
1916| VOID_TK DOT_TK CLASS_TK
1917 { $$ = build_class_ref (void_type_node); }
1918;
1919
e04a16fb
AG		 1920class_instance_creation_expression:
1921 NEW_TK class_type OP_TK argument_list CP_TK
b67d701b 1922 { $$ = build_new_invocation ($2, $4); }
e04a16fb 1923| NEW_TK class_type OP_TK CP_TK
b67d701b 1924 { $$ = build_new_invocation ($2, NULL_TREE); }
c2952b01 1925| anonymous_class_creation
e04a16fb
AG		 1926 /* Added, JDK1.1 inner classes, modified to use name or
1927 primary instead of primary solely which couldn't work in
1928 all situations. */
1929| something_dot_new identifier OP_TK CP_TK
c2952b01
APB		 1930 {
1931 tree ctor = build_new_invocation ($2, NULL_TREE);
1932 $$ = make_qualified_primary ($1, ctor,
1933 EXPR_WFL_LINECOL ($1));
1934 }
e04a16fb
AG		 1935| something_dot_new identifier OP_TK CP_TK class_body
1936| something_dot_new identifier OP_TK argument_list CP_TK
c2952b01
APB		 1937 {
1938 tree ctor = build_new_invocation ($2, $4);
1939 $$ = make_qualified_primary ($1, ctor,
1940 EXPR_WFL_LINECOL ($1));
1941 }
e04a16fb
AG		 1942| something_dot_new identifier OP_TK argument_list CP_TK class_body
1943| NEW_TK error SC_TK
1944 {yyerror ("'(' expected"); DRECOVER(new_1);}
1945| NEW_TK class_type error
1946 {yyerror ("'(' expected"); RECOVER;}
1947| NEW_TK class_type OP_TK error
1948 {yyerror ("')' or term expected"); RECOVER;}
1949| NEW_TK class_type OP_TK argument_list error
1950 {yyerror ("')' expected"); RECOVER;}
1951| something_dot_new error
1952 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
1953| something_dot_new identifier error
1954 {yyerror ("'(' expected"); RECOVER;}
1955;
1956
c2952b01
APB		 1957/* Created after JDK1.1 rules originally added to
1958 class_instance_creation_expression, but modified to use
1959 'class_type' instead of 'TypeName' (type_name) which is mentionned
1960 in the documentation but doesn't exist. */
1961
1962anonymous_class_creation:
1963 NEW_TK class_type OP_TK argument_list CP_TK
1964 { create_anonymous_class ($1.location, $2); }
1965 class_body
1966 {
1967 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
1968 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
1969
1970 end_class_declaration (1);
1971
1972 /* Now we can craft the new expression */
1973 $$ = build_new_invocation (id, $4);
1974
1975 /* Note that we can't possibly be here if
1976 `class_type' is an interface (in which case the
1977 anonymous class extends Object and implements
1978 `class_type', hence its constructor can't have
1979 arguments.) */
1980
1981 /* Otherwise, the innerclass must feature a
1982 constructor matching `argument_list'. Anonymous
1983 classes are a bit special: it's impossible to
1984 define constructor for them, hence constructors
1985 must be generated following the hints provided by
1986 the `new' expression. Whether a super constructor
1987 of that nature exists or not is to be verified
1988 later on in verify_constructor_super.
1989
1990 It's during the expansion of a `new' statement
1991 refering to an anonymous class that a ctor will
1992 be generated for the anonymous class, with the
1993 right arguments. */
1994
1995 }
1996| NEW_TK class_type OP_TK CP_TK
1997 { create_anonymous_class ($1.location, $2); }
1998 class_body
1999 {
2000 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2001 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2002
2003 end_class_declaration (1);
2004
2005 /* Now we can craft the new expression. The
2006 statement doesn't need to be remember so that a
2007 constructor can be generated, since its signature
2008 is already known. */
2009 $$ = build_new_invocation (id, NULL_TREE);
2010 }
2011;
2012
e04a16fb
AG		 2013something_dot_new: /* Added, not part of the specs. */
2014 name DOT_TK NEW_TK
c2952b01 2015 { $$ = $1; }
e04a16fb 2016| primary DOT_TK NEW_TK
c2952b01 2017 { $$ = $1; }
e04a16fb
AG		 2018;
2019
2020argument_list:
2021 expression
2022 {
2023 $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2024 ctxp->formal_parameter_number = 1;
2025 }
2026| argument_list C_TK expression
2027 {
2028 ctxp->formal_parameter_number += 1;
2029 $$ = tree_cons (NULL_TREE, $3, $1);
2030 }
2031| argument_list C_TK error
2032 {yyerror ("Missing term"); RECOVER;}
2033;
2034
2035array_creation_expression:
2036 NEW_TK primitive_type dim_exprs
2037 { $$ = build_newarray_node ($2, $3, 0); }
2038| NEW_TK class_or_interface_type dim_exprs
2039 { $$ = build_newarray_node ($2, $3, 0); }
2040| NEW_TK primitive_type dim_exprs dims
ba179f9f 2041 { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
e04a16fb 2042| NEW_TK class_or_interface_type dim_exprs dims
ba179f9f 2043 { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
e04a16fb
AG		 2044 /* Added, JDK1.1 anonymous array. Initial documentation rule
2045 modified */
2046| NEW_TK class_or_interface_type dims array_initializer
c2952b01
APB		 2047 {
2048 char *sig;
2049 while (CURRENT_OSB (ctxp)--)
2050 obstack_1grow (&temporary_obstack, '[');
2051 sig = obstack_finish (&temporary_obstack);
2052 $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2053 $2, get_identifier (sig), $4);
2054 }
e04a16fb 2055| NEW_TK primitive_type dims array_initializer
c2952b01
APB		 2056 {
2057 tree type = $2;
2058 while (CURRENT_OSB (ctxp)--)
2059 type = build_java_array_type (type, -1);
2060 $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2061 build_pointer_type (type), NULL_TREE, $4);
2062 }
e04a16fb
AG		 2063| NEW_TK error CSB_TK
2064 {yyerror ("'[' expected"); DRECOVER ("]");}
2065| NEW_TK error OSB_TK
2066 {yyerror ("']' expected"); RECOVER;}
2067;
2068
2069dim_exprs:
2070 dim_expr
2071 { $$ = build_tree_list (NULL_TREE, $1); }
2072| dim_exprs dim_expr
2073 { $$ = tree_cons (NULL_TREE, $2, $$); }
2074;
2075
2076dim_expr:
2077 OSB_TK expression CSB_TK
2078 {
2079 EXPR_WFL_LINECOL ($2) = $1.location;
2080 $$ = $2;
2081 }
2082| OSB_TK expression error
2083 {yyerror ("']' expected"); RECOVER;}
2084| OSB_TK error
2085 {
2086 yyerror ("Missing term");
2087 yyerror ("']' expected");
2088 RECOVER;
2089 }
2090;
2091
2092dims:
2093 OSB_TK CSB_TK
ba179f9f
APB		 2094 {
2095 int allocate = 0;
2096 /* If not initialized, allocate memory for the osb
2097 numbers stack */
2098 if (!ctxp->osb_limit)
2099 {
2100 allocate = ctxp->osb_limit = 32;
2101 ctxp->osb_depth = -1;
2102 }
c2952b01 2103 /* If capacity overflown, reallocate a bigger chunk */
ba179f9f
APB		 2104 else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2105 allocate = ctxp->osb_limit << 1;
2106
2107 if (allocate)
2108 {
2109 allocate *= sizeof (int);
2110 if (ctxp->osb_number)
2111 ctxp->osb_number = (int *)xrealloc (ctxp->osb_number,
2112 allocate);
2113 else
2114 ctxp->osb_number = (int *)xmalloc (allocate);
2115 }
2116 ctxp->osb_depth++;
2117 CURRENT_OSB (ctxp) = 1;
2118 }
e04a16fb 2119| dims OSB_TK CSB_TK
ba179f9f 2120 { CURRENT_OSB (ctxp)++; }
e04a16fb
AG		 2121| dims OSB_TK error
2122 { yyerror ("']' expected"); RECOVER;}
2123;
2124
2125field_access:
2126 primary DOT_TK identifier
2127 { $$ = make_qualified_primary ($1, $3, $2.location); }
9bbc7d9f
PB		 2128 /* FIXME - REWRITE TO:
2129 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
e04a16fb
AG		 2130| SUPER_TK DOT_TK identifier
2131 {
2132 tree super_wfl =
9ee9b555 2133 build_wfl_node (super_identifier_node);
e04a16fb
AG		 2134 EXPR_WFL_LINECOL (super_wfl) = $1.location;
2135 $$ = make_qualified_name (super_wfl, $3, $2.location);
2136 }
2137| SUPER_TK error
2138 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2139;
2140
2141method_invocation:
2142 name OP_TK CP_TK
2143 { $$ = build_method_invocation ($1, NULL_TREE); }
2144| name OP_TK argument_list CP_TK
2145 { $$ = build_method_invocation ($1, $3); }
2146| primary DOT_TK identifier OP_TK CP_TK
2147 {
22eed1e6
APB		 2148 if (TREE_CODE ($1) == THIS_EXPR)
2149 $$ = build_this_super_qualified_invocation
2150 (1, $3, NULL_TREE, 0, $2.location);
2151 else
2152 {
2153 tree invok = build_method_invocation ($3, NULL_TREE);
2154 $$ = make_qualified_primary ($1, invok, $2.location);
2155 }
e04a16fb
AG		 2156 }
2157| primary DOT_TK identifier OP_TK argument_list CP_TK
2158 {
22eed1e6
APB		 2159 if (TREE_CODE ($1) == THIS_EXPR)
2160 $$ = build_this_super_qualified_invocation
2161 (1, $3, $5, 0, $2.location);
2162 else
2163 {
2164 tree invok = build_method_invocation ($3, $5);
2165 $$ = make_qualified_primary ($1, invok, $2.location);
2166 }
e04a16fb
AG		 2167 }
2168| SUPER_TK DOT_TK identifier OP_TK CP_TK
22eed1e6
APB		 2169 {
2170 $$ = build_this_super_qualified_invocation
2171 (0, $3, NULL_TREE, $1.location, $2.location);
e04a16fb
AG		 2172 }
2173| SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2174 {
22eed1e6
APB		 2175 $$ = build_this_super_qualified_invocation
2176 (0, $3, $5, $1.location, $2.location);
e04a16fb
AG		 2177 }
2178 /* Screws up thing. I let it here until I'm convinced it can
2179 be removed. FIXME
2180| primary DOT_TK error
2181 {yyerror ("'(' expected"); DRECOVER(bad);} */
2182| SUPER_TK DOT_TK error CP_TK
2183 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2184| SUPER_TK DOT_TK error DOT_TK
2185 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2186;
2187
2188array_access:
2189 name OSB_TK expression CSB_TK
2190 { $$ = build_array_ref ($2.location, $1, $3); }
2191| primary_no_new_array OSB_TK expression CSB_TK
2192 { $$ = build_array_ref ($2.location, $1, $3); }
2193| name OSB_TK error
2194 {
2195 yyerror ("Missing term and ']' expected");
2196 DRECOVER(array_access);
2197 }
2198| name OSB_TK expression error
2199 {
2200 yyerror ("']' expected");
2201 DRECOVER(array_access);
2202 }
2203| primary_no_new_array OSB_TK error
2204 {
2205 yyerror ("Missing term and ']' expected");
2206 DRECOVER(array_access);
2207 }
2208| primary_no_new_array OSB_TK expression error
2209 {
2210 yyerror ("']' expected");
2211 DRECOVER(array_access);
2212 }
2213;
2214
2215postfix_expression:
2216 primary
2217| name
2218| post_increment_expression
2219| post_decrement_expression
2220;
2221
2222post_increment_expression:
2223 postfix_expression INCR_TK
2224 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2225;
2226
2227post_decrement_expression:
2228 postfix_expression DECR_TK
2229 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2230;
2231
2232unary_expression:
2233 pre_increment_expression
2234| pre_decrement_expression
2235| PLUS_TK unary_expression
2236 {$$ = build_unaryop ($1.token, $1.location, $2); }
2237| MINUS_TK unary_expression
2238 {$$ = build_unaryop ($1.token, $1.location, $2); }
2239| unary_expression_not_plus_minus
2240| PLUS_TK error
2241 {yyerror ("Missing term"); RECOVER}
2242| MINUS_TK error
2243 {yyerror ("Missing term"); RECOVER}
2244;
2245
2246pre_increment_expression:
2247 INCR_TK unary_expression
2248 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2249| INCR_TK error
2250 {yyerror ("Missing term"); RECOVER}
2251;
2252
2253pre_decrement_expression:
2254 DECR_TK unary_expression
2255 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2256| DECR_TK error
2257 {yyerror ("Missing term"); RECOVER}
2258;
2259
2260unary_expression_not_plus_minus:
2261 postfix_expression
2262| NOT_TK unary_expression
2263 {$$ = build_unaryop ($1.token, $1.location, $2); }
2264| NEG_TK unary_expression
2265 {$$ = build_unaryop ($1.token, $1.location, $2); }
2266| cast_expression
2267| NOT_TK error
2268 {yyerror ("Missing term"); RECOVER}
2269| NEG_TK error
2270 {yyerror ("Missing term"); RECOVER}
2271;
2272
2273cast_expression: /* Error handling here is potentially weak */
2274 OP_TK primitive_type dims CP_TK unary_expression
2275 {
2276 tree type = $2;
ba179f9f 2277 while (CURRENT_OSB (ctxp)--)
e04a16fb 2278 type = build_java_array_type (type, -1);
ba179f9f 2279 ctxp->osb_depth--;
e04a16fb
AG		 2280 $$ = build_cast ($1.location, type, $5);
2281 }
2282| OP_TK primitive_type CP_TK unary_expression
2283 { $$ = build_cast ($1.location, $2, $4); }
2284| OP_TK expression CP_TK unary_expression_not_plus_minus
2285 { $$ = build_cast ($1.location, $2, $4); }
2286| OP_TK name dims CP_TK unary_expression_not_plus_minus
2287 {
49f48c71 2288 const char *ptr;
ba179f9f 2289 while (CURRENT_OSB (ctxp)--)
e04a16fb 2290 obstack_1grow (&temporary_obstack, '[');
ba179f9f 2291 ctxp->osb_depth--;
e04a16fb
AG		 2292 obstack_grow0 (&temporary_obstack,
2293 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2294 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2295 ptr = obstack_finish (&temporary_obstack);
2296 EXPR_WFL_NODE ($2) = get_identifier (ptr);
2297 $$ = build_cast ($1.location, $2, $5);
2298 }
2299| OP_TK primitive_type OSB_TK error
2300 {yyerror ("']' expected, invalid type expression");}
2301| OP_TK error
2302 {
2303 if (ctxp->prevent_ese != lineno)
2304 yyerror ("Invalid type expression"); RECOVER;
2305 RECOVER;
2306 }
2307| OP_TK primitive_type dims CP_TK error
2308 {yyerror ("Missing term"); RECOVER;}
2309| OP_TK primitive_type CP_TK error
2310 {yyerror ("Missing term"); RECOVER;}
2311| OP_TK name dims CP_TK error
2312 {yyerror ("Missing term"); RECOVER;}
2313;
2314
2315multiplicative_expression:
2316 unary_expression
2317| multiplicative_expression MULT_TK unary_expression
2318 {
2319 $$ = build_binop (BINOP_LOOKUP ($2.token),
2320 $2.location, $1, $3);
2321 }
2322| multiplicative_expression DIV_TK unary_expression
2323 {
2324 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2325 $1, $3);
2326 }
2327| multiplicative_expression REM_TK unary_expression
2328 {
2329 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2330 $1, $3);
2331 }
2332| multiplicative_expression MULT_TK error
2333 {yyerror ("Missing term"); RECOVER;}
2334| multiplicative_expression DIV_TK error
2335 {yyerror ("Missing term"); RECOVER;}
2336| multiplicative_expression REM_TK error
2337 {yyerror ("Missing term"); RECOVER;}
2338;
2339
2340additive_expression:
2341 multiplicative_expression
2342| additive_expression PLUS_TK multiplicative_expression
2343 {
2344 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2345 $1, $3);
2346 }
2347| additive_expression MINUS_TK multiplicative_expression
2348 {
2349 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2350 $1, $3);
2351 }
2352| additive_expression PLUS_TK error
2353 {yyerror ("Missing term"); RECOVER;}
2354| additive_expression MINUS_TK error
2355 {yyerror ("Missing term"); RECOVER;}
2356;
2357
2358shift_expression:
2359 additive_expression
2360| shift_expression LS_TK additive_expression
2361 {
2362 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2363 $1, $3);
2364 }
2365| shift_expression SRS_TK additive_expression
2366 {
2367 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2368 $1, $3);
2369 }
2370| shift_expression ZRS_TK additive_expression
2371 {
2372 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2373 $1, $3);
2374 }
2375| shift_expression LS_TK error
2376 {yyerror ("Missing term"); RECOVER;}
2377| shift_expression SRS_TK error
2378 {yyerror ("Missing term"); RECOVER;}
2379| shift_expression ZRS_TK error
2380 {yyerror ("Missing term"); RECOVER;}
2381;
2382
2383relational_expression:
2384 shift_expression
2385| relational_expression LT_TK shift_expression
2386 {
2387 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2388 $1, $3);
2389 }
2390| relational_expression GT_TK shift_expression
2391 {
2392 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2393 $1, $3);
2394 }
2395| relational_expression LTE_TK shift_expression
2396 {
2397 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2398 $1, $3);
2399 }
2400| relational_expression GTE_TK shift_expression
2401 {
2402 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2403 $1, $3);
2404 }
2405| relational_expression INSTANCEOF_TK reference_type
5e942c50 2406 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
e04a16fb
AG		 2407| relational_expression LT_TK error
2408 {yyerror ("Missing term"); RECOVER;}
2409| relational_expression GT_TK error
2410 {yyerror ("Missing term"); RECOVER;}
2411| relational_expression LTE_TK error
2412 {yyerror ("Missing term"); RECOVER;}
2413| relational_expression GTE_TK error
2414 {yyerror ("Missing term"); RECOVER;}
2415| relational_expression INSTANCEOF_TK error
2416 {yyerror ("Invalid reference type"); RECOVER;}
2417;
2418
2419equality_expression:
2420 relational_expression
2421| equality_expression EQ_TK relational_expression
2422 {
2423 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2424 $1, $3);
2425 }
2426| equality_expression NEQ_TK relational_expression
2427 {
2428 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2429 $1, $3);
2430 }
2431| equality_expression EQ_TK error
2432 {yyerror ("Missing term"); RECOVER;}
2433| equality_expression NEQ_TK error
2434 {yyerror ("Missing term"); RECOVER;}
2435;
2436
2437and_expression:
2438 equality_expression
2439| and_expression AND_TK equality_expression
2440 {
2441 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2442 $1, $3);
2443 }
2444| and_expression AND_TK error
2445 {yyerror ("Missing term"); RECOVER;}
2446;
2447
2448exclusive_or_expression:
2449 and_expression
2450| exclusive_or_expression XOR_TK and_expression
2451 {
2452 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2453 $1, $3);
2454 }
2455| exclusive_or_expression XOR_TK error
2456 {yyerror ("Missing term"); RECOVER;}
2457;
2458
2459inclusive_or_expression:
2460 exclusive_or_expression
2461| inclusive_or_expression OR_TK exclusive_or_expression
2462 {
2463 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2464 $1, $3);
2465 }
2466| inclusive_or_expression OR_TK error
2467 {yyerror ("Missing term"); RECOVER;}
2468;
2469
2470conditional_and_expression:
2471 inclusive_or_expression
2472| conditional_and_expression BOOL_AND_TK inclusive_or_expression
2473 {
2474 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2475 $1, $3);
2476 }
2477| conditional_and_expression BOOL_AND_TK error
2478 {yyerror ("Missing term"); RECOVER;}
2479;
2480
2481conditional_or_expression:
2482 conditional_and_expression
2483| conditional_or_expression BOOL_OR_TK conditional_and_expression
2484 {
2485 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2486 $1, $3);
2487 }
2488| conditional_or_expression BOOL_OR_TK error
2489 {yyerror ("Missing term"); RECOVER;}
2490;
2491
2492conditional_expression: /* Error handling here is weak */
2493 conditional_or_expression
2494| conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
22eed1e6
APB		 2495 {
2496 $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2497 EXPR_WFL_LINECOL ($$) = $2.location;
2498 }
e04a16fb
AG		 2499| conditional_or_expression REL_QM_TK REL_CL_TK error
2500 {
2501 YYERROR_NOW;
2502 yyerror ("Missing term");
2503 DRECOVER (1);
2504 }
2505| conditional_or_expression REL_QM_TK error
2506 {yyerror ("Missing term"); DRECOVER (2);}
2507| conditional_or_expression REL_QM_TK expression REL_CL_TK error
2508 {yyerror ("Missing term"); DRECOVER (3);}
2509;
2510
2511assignment_expression:
2512 conditional_expression
2513| assignment
2514;
2515
2516assignment:
2517 left_hand_side assignment_operator assignment_expression
2518 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2519| left_hand_side assignment_operator error
2520 {
2521 if (ctxp->prevent_ese != lineno)
2522 yyerror ("Missing term");
2523 DRECOVER (assign);
2524 }
2525;
2526
2527left_hand_side:
2528 name
2529| field_access
2530| array_access
2531;
2532
2533assignment_operator:
2534 ASSIGN_ANY_TK
2535| ASSIGN_TK
2536;
2537
2538expression:
2539 assignment_expression
2540;
2541
2542constant_expression:
2543 expression
2544;
2545
2546%%
2547\f
2548
c2952b01
APB		 2549/* This section of the code deal with save/restoring parser contexts.
2550 Add mode documentation here. FIXME */
e04a16fb 2551
c2952b01
APB		 2552/* Helper function. Create a new parser context. With
2553 COPY_FROM_PREVIOUS set to a non zero value, content of the previous
2554 context is copied, otherwise, the new context is zeroed. The newly
2555 created context becomes the current one. */
e04a16fb 2556
c2952b01
APB		 2557static void
2558create_new_parser_context (copy_from_previous)
2559 int copy_from_previous;
e04a16fb 2560{
c2952b01 2561 struct parser_ctxt *new;
e04a16fb 2562
c2952b01
APB		 2563 new = (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt));
2564 if (copy_from_previous)
2565 {
2566 memcpy ((PTR)new, (PTR)ctxp, sizeof (struct parser_ctxt));
2567 new->saved_data_ctx = 1;
2568 }
2569 else
2570 bzero ((PTR) new, sizeof (struct parser_ctxt));
2571
e04a16fb
AG		 2572 new->next = ctxp;
2573 ctxp = new;
c2952b01
APB		 2574}
2575
2576/* Create a new parser context and make it the current one. */
2577
2578void
2579java_push_parser_context ()
2580{
2581 create_new_parser_context (0);
e04a16fb 2582 if (ctxp->next)
5e942c50
APB		 2583 {
2584 ctxp->incomplete_class = ctxp->next->incomplete_class;
2585 ctxp->gclass_list = ctxp->next->gclass_list;
2586 }
e04a16fb
AG		 2587}
2588
c2952b01
APB		 2589void
2590java_pop_parser_context (generate)
2591 int generate;
2592{
2593 tree current;
2594 struct parser_ctxt *toFree, *next;
2595
2596 if (!ctxp)
2597 return;
2598
2599 toFree = ctxp;
2600 next = ctxp->next;
2601 if (next)
2602 {
2603 next->incomplete_class = ctxp->incomplete_class;
2604 next->gclass_list = ctxp->gclass_list;
2605 lineno = ctxp->lineno;
2606 finput = ctxp->finput;
2607 current_class = ctxp->current_class;
2608 }
2609
2610 /* Set the single import class file flag to 0 for the current list
2611 of imported things */
2612 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2613 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 0;
2614
2615 /* And restore those of the previous context */
2616 if ((ctxp = next)) /* Assignment is really meant here */
2617 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2618 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 1;
2619
2620 /* If we pushed a context to parse a class intended to be generated,
2621 we keep it so we can remember the class. What we could actually
2622 do is to just update a list of class names. */
2623 if (generate)
2624 {
2625 toFree->next = ctxp_for_generation;
2626 ctxp_for_generation = toFree;
2627 }
2628 else
2629 free (toFree);
2630}
2631
2632/* Create a parser context for the use of saving some global
2633 variables. */
2634
e04a16fb
AG		 2635void
2636java_parser_context_save_global ()
2637{
22eed1e6
APB		 2638 if (!ctxp)
2639 {
2640 java_push_parser_context ();
ee07f4f4
APB		 2641 ctxp->saved_data_ctx = 1;
2642 }
c2952b01
APB		 2643
2644 /* If this context already stores data, create a new one suitable
2645 for data storage. */
ee07f4f4 2646 else if (ctxp->saved_data)
c2952b01
APB		 2647 create_new_parser_context (1);
2648
e04a16fb
AG		 2649 ctxp->finput = finput;
2650 ctxp->lineno = lineno;
2651 ctxp->current_class = current_class;
2652 ctxp->filename = input_filename;
2653 ctxp->current_function_decl = current_function_decl;
ee07f4f4 2654 ctxp->saved_data = 1;
e04a16fb
AG		 2655}
2656
c2952b01
APB		 2657/* Restore some global variables from the previous context. Make the
2658 previous context the current one. */
2659
e04a16fb
AG		 2660void
2661java_parser_context_restore_global ()
2662{
2663 finput = ctxp->finput;
2664 lineno = ctxp->lineno;
2665 current_class = ctxp->current_class;
2666 input_filename = ctxp->filename;
2667 current_function_decl = ctxp->current_function_decl;
c2952b01 2668 ctxp->saved_data = 0;
ee07f4f4
APB		 2669 if (ctxp->saved_data_ctx)
2670 java_pop_parser_context (0);
e04a16fb
AG		 2671}
2672
c2952b01
APB		 2673/* Suspend vital data for the current class/function being parsed so
2674 that an other class can be parsed. Used to let local/anonymous
2675 classes be parsed. */
2676
2677static void
2678java_parser_context_suspend ()
e04a16fb 2679{
c2952b01
APB		 2680 /* This makes debugging through java_debug_context easier */
2681 static char *name = "<inner buffer context>";
e04a16fb 2682
c2952b01
APB		 2683 /* Duplicate the previous context, use it to save the globals we're
2684 interested in */
2685 create_new_parser_context (1);
2686 ctxp->current_function_decl = current_function_decl;
2687 ctxp->current_class = current_class;
5e942c50 2688
c2952b01
APB		 2689 /* Then create a new context which inherits all data from the
2690 previous one. This will be the new current context */
2691 create_new_parser_context (1);
2692
2693 /* Help debugging */
2694 ctxp->next->filename = name;
2695}
2696
2697/* Resume vital data for the current class/function being parsed so
2698 that an other class can be parsed. Used to let local/anonymous
2699 classes be parsed. The trick is the data storing file position
2700 informations must be restored to their current value, so parsing
2701 can resume as if no context was ever saved. */
2702
2703static void
2704java_parser_context_resume ()
2705{
2706 struct parser_ctxt *old = ctxp; /* This one is to be discarded */
2707 struct parser_ctxt *saver = old->next; /* This one contain saved info */
2708 struct parser_ctxt *restored = saver->next; /* This one is the old current */
2709
2710 /* We need to inherit the list of classes to complete/generate */
2711 restored->incomplete_class = old->incomplete_class;
2712 restored->gclass_list = old->gclass_list;
2713 restored->classd_list = old->classd_list;
2714 restored->class_list = old->class_list;
2715
2716 /* Restore the current class and function from the saver */
2717 current_class = saver->current_class;
2718 current_function_decl = saver->current_function_decl;
2719
2720 /* Retrive the restored context */
2721 ctxp = restored;
2722
2723 /* Re-installed the data for the parsing to carry on */
2724 bcopy (&old->marker_begining, &ctxp->marker_begining,
2725 (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2726
2727 /* Buffer context can now be discarded */
2728 free (saver);
2729 free (old);
2730}
2731
2732/* Add a new anchor node to which all statement(s) initializing static
2733 and non static initialized upon declaration field(s) will be
2734 linked. */
2735
2736static void
2737java_parser_context_push_initialized_field ()
2738{
2739 tree node;
2740
2741 node = build_tree_list (NULL_TREE, NULL_TREE);
2742 TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2743 CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2744
2745 node = build_tree_list (NULL_TREE, NULL_TREE);
2746 TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2747 CPC_INITIALIZER_LIST (ctxp) = node;
2748
2749 node = build_tree_list (NULL_TREE, NULL_TREE);
2750 TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2751 CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2752}
2753
2754/* Pop the lists of initialized field. If this lists aren't empty,
2755 remember them so we can use it to create and populate the $finit$
2756 or <clinit> functions. */
2757
2758static void
2759java_parser_context_pop_initialized_field ()
2760{
2761 tree stmts;
2762 tree class_type = TREE_TYPE (GET_CPC ());
2763
2764 if (CPC_INITIALIZER_LIST (ctxp))
e04a16fb 2765 {
c2952b01
APB		 2766 stmts = CPC_INITIALIZER_STMT (ctxp);
2767 CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2768 if (stmts && !java_error_count)
2769 TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
e04a16fb
AG		 2770 }
2771
c2952b01
APB		 2772 if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2773 {
2774 stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2775 CPC_STATIC_INITIALIZER_LIST (ctxp) =
2776 TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2777 /* Keep initialization in order to enforce 8.5 */
2778 if (stmts && !java_error_count)
2779 TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2780 }
e04a16fb 2781
c2952b01
APB		 2782 /* JDK 1.1 instance initializers */
2783 if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
b351b287 2784 {
c2952b01
APB		 2785 stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2786 CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2787 TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2788 if (stmts && !java_error_count)
2789 TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
b351b287 2790 }
c2952b01
APB		 2791}
2792
2793static tree
2794reorder_static_initialized (list)
2795 tree list;
2796{
2797 /* We have to keep things in order. The alias initializer have to
2798 come first, then the initialized regular field, in reverse to
2799 keep them in lexical order. */
2800 tree marker, previous = NULL_TREE;
2801 for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2802 if (TREE_CODE (marker) == TREE_LIST
2803 && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2804 break;
2805
2806 /* No static initialized, the list is fine as is */
2807 if (!previous)
2808 list = TREE_CHAIN (marker);
2809
2810 /* No marker? reverse the whole list */
2811 else if (!marker)
2812 list = nreverse (list);
2813
2814 /* Otherwise, reverse what's after the marker and the new reordered
2815 sublist will replace the marker. */
b351b287 2816 else
c2952b01
APB		 2817 {
2818 TREE_CHAIN (previous) = NULL_TREE;
2819 list = nreverse (list);
2820 list = chainon (TREE_CHAIN (marker), list);
2821 }
2822 return list;
e04a16fb
AG		 2823}
2824
c2952b01
APB		 2825/* Helper functions to dump the parser context stack. */
2826
2827#define TAB_CONTEXT(C) \
2828 {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
ee07f4f4
APB		 2829
2830static void
2831java_debug_context_do (tab)
2832 int tab;
2833{
ee07f4f4
APB		 2834 struct parser_ctxt *copy = ctxp;
2835 while (copy)
2836 {
c2952b01 2837 TAB_CONTEXT (tab);
ee07f4f4 2838 fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
c2952b01 2839 TAB_CONTEXT (tab);
ee07f4f4 2840 fprintf (stderr, "filename: %s\n", copy->filename);
c2952b01
APB		 2841 TAB_CONTEXT (tab);
2842 fprintf (stderr, "lineno: %d\n", copy->lineno);
2843 TAB_CONTEXT (tab);
ee07f4f4
APB		 2844 fprintf (stderr, "package: %s\n",
2845 (copy->package ?
2846 IDENTIFIER_POINTER (copy->package) : "<none>"));
c2952b01 2847 TAB_CONTEXT (tab);
ee07f4f4 2848 fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
c2952b01 2849 TAB_CONTEXT (tab);
ee07f4f4
APB		 2850 fprintf (stderr, "saved data: %d\n", copy->saved_data);
2851 copy = copy->next;
2852 tab += 2;
2853 }
ee07f4f4
APB		 2854}
2855
c2952b01
APB		 2856/* Dump the stacked up parser contexts. Intended to be called from a
2857 debugger. */
2858
ee07f4f4
APB		 2859void
2860java_debug_context ()
2861{
2862 java_debug_context_do (0);
2863}
2864
c2952b01
APB		 2865\f
2866
2867/* Flag for the error report routine to issue the error the first time
2868 it's called (overriding the default behavior which is to drop the
2869 first invocation and honor the second one, taking advantage of a
2870 richer context. */
2871static int force_error = 0;
ee07f4f4 2872
8119c720
APB		 2873/* Reporting an constructor invocation error. */
2874static void
2875parse_ctor_invocation_error ()
2876{
2877 if (DECL_CONSTRUCTOR_P (current_function_decl))
2878 yyerror ("Constructor invocation must be first thing in a constructor");
2879 else
2880 yyerror ("Only constructors can invoke constructors");
2881}
2882
2883/* Reporting JDK1.1 features not implemented. */
b67d701b
PB		 2884
2885static tree
2886parse_jdk1_1_error (msg)
49f48c71 2887 const char *msg;
b67d701b
PB		 2888{
2889 sorry (": `%s' JDK1.1(TM) feature", msg);
2890 java_error_count++;
9bbc7d9f 2891 return empty_stmt_node;
b67d701b
PB		 2892}
2893
e04a16fb
AG		 2894static int do_warning = 0;
2895
2896void
2897yyerror (msg)
49f48c71 2898 const char *msg;
e04a16fb
AG		 2899{
2900 static java_lc elc;
2901 static int prev_lineno;
49f48c71 2902 static const char *prev_msg;
e04a16fb 2903
0a2138e2 2904 int save_lineno;
e04a16fb
AG		 2905 char *remainder, *code_from_source;
2906 extern struct obstack temporary_obstack;
2907
2908 if (!force_error && prev_lineno == lineno)
2909 return;
2910
2911 /* Save current error location but report latter, when the context is
2912 richer. */
2913 if (ctxp->java_error_flag == 0)
2914 {
2915 ctxp->java_error_flag = 1;
2916 elc = ctxp->elc;
2917 /* Do something to use the previous line if we're reaching the
2918 end of the file... */
2919#ifdef VERBOSE_SKELETON
2920 printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
2921#endif
2922 return;
2923 }
2924
2925 /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
2926 if (!force_error && msg == prev_msg && prev_lineno == elc.line)
2927 return;
2928
2929 ctxp->java_error_flag = 0;
2930 if (do_warning)
2931 java_warning_count++;
2932 else
2933 java_error_count++;
2934
2935 if (elc.col == 0 && msg[1] == ';')
2936 {
2937 elc.col = ctxp->p_line->char_col-1;
2938 elc.line = ctxp->p_line->lineno;
2939 }
2940
2941 save_lineno = lineno;
2942 prev_lineno = lineno = elc.line;
2943 prev_msg = msg;
2944
2945 code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
2946 obstack_grow0 (&temporary_obstack,
2947 code_from_source, strlen (code_from_source));
2948 remainder = obstack_finish (&temporary_obstack);
2949 if (do_warning)
2950 warning ("%s.\n%s", msg, remainder);
2951 else
2952 error ("%s.\n%s", msg, remainder);
2953
2954 /* This allow us to cheaply avoid an extra 'Invalid expression
2955 statement' error report when errors have been already reported on
2956 the same line. This occurs when we report an error but don't have
2957 a synchronization point other than ';', which
2958 expression_statement is the only one to take care of. */
2959 ctxp->prevent_ese = lineno = save_lineno;
2960}
2961
2962static void
15fdcfe9 2963issue_warning_error_from_context (cl, msg, ap)
5e942c50 2964 tree cl;
d4476be2 2965 const char *msg;
15fdcfe9 2966 va_list ap;
5e942c50 2967{
1886c9d8 2968 char *saved, *saved_input_filename;
15fdcfe9
PB		 2969 char buffer [4096];
2970 vsprintf (buffer, msg, ap);
2971 force_error = 1;
5e942c50
APB		 2972
2973 ctxp->elc.line = EXPR_WFL_LINENO (cl);
82371d41
APB		 2974 ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
2975 (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
5e942c50
APB		 2976
2977 /* We have a CL, that's a good reason for using it if it contains data */
2978 saved = ctxp->filename;
2979 if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
2980 ctxp->filename = EXPR_WFL_FILENAME (cl);
1886c9d8
APB		 2981 saved_input_filename = input_filename;
2982 input_filename = ctxp->filename;
15fdcfe9
PB		 2983 java_error (NULL);
2984 java_error (buffer);
5e942c50 2985 ctxp->filename = saved;
1886c9d8 2986 input_filename = saved_input_filename;
15fdcfe9 2987 force_error = 0;
5e942c50
APB		 2988}
2989
e04a16fb
AG		 2990/* Issue an error message at a current source line CL */
2991
15fdcfe9 2992void
df32d2ce 2993parse_error_context VPARAMS ((tree cl, const char *msg, ...))
e04a16fb 2994{
d4476be2 2995#ifndef ANSI_PROTOTYPES
e04a16fb 2996 tree cl;
d4476be2 2997 const char *msg;
e04a16fb 2998#endif
e04a16fb
AG		 2999 va_list ap;
3000
3001 VA_START (ap, msg);
d4476be2 3002#ifndef ANSI_PROTOTYPES
e04a16fb 3003 cl = va_arg (ap, tree);
d4476be2 3004 msg = va_arg (ap, const char *);
e04a16fb 3005#endif
15fdcfe9
PB		 3006 issue_warning_error_from_context (cl, msg, ap);
3007 va_end (ap);
e04a16fb
AG		 3008}
3009
3010/* Issue a warning at a current source line CL */
3011
3012static void
df32d2ce 3013parse_warning_context VPARAMS ((tree cl, const char *msg, ...))
e04a16fb 3014{
d4476be2 3015#ifndef ANSI_PROTOTYPES
e04a16fb 3016 tree cl;
d4476be2 3017 const char *msg;
e04a16fb 3018#endif
e04a16fb
AG		 3019 va_list ap;
3020
3021 VA_START (ap, msg);
d4476be2 3022#ifndef ANSI_PROTOTYPES
e04a16fb 3023 cl = va_arg (ap, tree);
d4476be2 3024 msg = va_arg (ap, const char *);
e04a16fb 3025#endif
e04a16fb 3026
c877974e 3027 force_error = do_warning = 1;
15fdcfe9 3028 issue_warning_error_from_context (cl, msg, ap);
c877974e 3029 do_warning = force_error = 0;
15fdcfe9 3030 va_end (ap);
e04a16fb
AG		 3031}
3032
82371d41
APB		 3033static tree
3034find_expr_with_wfl (node)
3035 tree node;
3036{
3037 while (node)
3038 {
3039 char code;
3040 tree to_return;
3041
3042 switch (TREE_CODE (node))
3043 {
3044 case BLOCK:
c0d87ff6
PB		 3045 node = BLOCK_EXPR_BODY (node);
3046 continue;
82371d41
APB		 3047
3048 case COMPOUND_EXPR:
3049 to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3050 if (to_return)
3051 return to_return;
c0d87ff6
PB		 3052 node = TREE_OPERAND (node, 1);
3053 continue;
82371d41
APB		 3054
3055 case LOOP_EXPR:
c0d87ff6
PB		 3056 node = TREE_OPERAND (node, 0);
3057 continue;
82371d41
APB		 3058
3059 case LABELED_BLOCK_EXPR:
c0d87ff6
PB		 3060 node = TREE_OPERAND (node, 1);
3061 continue;
3062
82371d41
APB		 3063 default:
3064 code = TREE_CODE_CLASS (TREE_CODE (node));
3065 if (((code == '1') || (code == '2') || (code == 'e'))
3066 && EXPR_WFL_LINECOL (node))
3067 return node;
ba179f9f 3068 return NULL_TREE;
82371d41
APB		 3069 }
3070 }
3071 return NULL_TREE;
3072}
3073
3074/* Issue a missing return statement error. Uses METHOD to figure the
3075 last line of the method the error occurs in. */
3076
3077static void
3078missing_return_error (method)
3079 tree method;
3080{
3081 EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
3082 parse_error_context (wfl_operator, "Missing return statement");
3083}
3084
3085/* Issue an unreachable statement error. From NODE, find the next
3086 statement to report appropriately. */
3087static void
3088unreachable_stmt_error (node)
3089 tree node;
3090{
3091 /* Browse node to find the next expression node that has a WFL. Use
3092 the location to report the error */
3093 if (TREE_CODE (node) == COMPOUND_EXPR)
3094 node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3095 else
3096 node = find_expr_with_wfl (node);
3097
3098 if (node)
3099 {
3100 EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3101 parse_error_context (wfl_operator, "Unreachable statement");
3102 }
3103 else
3104 fatal ("Can't get valid statement - unreachable_stmt_error");
3105}
3106
c877974e 3107int
e04a16fb
AG		 3108java_report_errors ()
3109{
3110 if (java_error_count)
3111 fprintf (stderr, "%d error%s",
3112 java_error_count, (java_error_count == 1 ? "" : "s"));
3113 if (java_warning_count)
3114 fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3115 java_warning_count, (java_warning_count == 1 ? "" : "s"));
3116 if (java_error_count || java_warning_count)
3117 putc ('\n', stderr);
c877974e 3118 return java_error_count;
e04a16fb
AG		 3119}
3120
3121static char *
3122java_accstring_lookup (flags)
3123 int flags;
3124{
3125 static char buffer [80];
3126#define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3127
3128 /* Access modifier looked-up first for easier report on forbidden
3129 access. */
3130 if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3131 if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3132 if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3133 if (flags & ACC_STATIC) COPY_RETURN ("static");
3134 if (flags & ACC_FINAL) COPY_RETURN ("final");
3135 if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3136 if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3137 if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3138 if (flags & ACC_NATIVE) COPY_RETURN ("native");
3139 if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3140 if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3141
3142 buffer [0] = '\0';
3143 return buffer;
3144#undef COPY_RETURN
3145}
3146
b67d701b
PB		 3147/* Issuing error messages upon redefinition of classes, interfaces or
3148 variables. */
3149
e04a16fb 3150static void
b67d701b 3151classitf_redefinition_error (context, id, decl, cl)
49f48c71 3152 const char *context;
e04a16fb
AG		 3153 tree id, decl, cl;
3154{
3155 parse_error_context (cl, "%s `%s' already defined in %s:%d",
3156 context, IDENTIFIER_POINTER (id),
3157 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3158 /* Here we should point out where its redefined. It's a unicode. FIXME */
3159}
3160
b67d701b
PB		 3161static void
3162variable_redefinition_error (context, name, type, line)
3163 tree context, name, type;
3164 int line;
3165{
49f48c71 3166 const char *type_name;
b67d701b
PB		 3167
3168 /* Figure a proper name for type. We might haven't resolved it */
c877974e
APB		 3169 if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3170 type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
b67d701b 3171 else
0a2138e2 3172 type_name = lang_printable_name (type, 0);
b67d701b
PB		 3173
3174 parse_error_context (context,
781b0558 3175 "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
b67d701b
PB		 3176 IDENTIFIER_POINTER (name),
3177 type_name, IDENTIFIER_POINTER (name), line);
3178}
3179
c583dd46
APB		 3180static tree
3181build_array_from_name (type, type_wfl, name, ret_name)
3182 tree type, type_wfl, name, *ret_name;
3183{
3184 int more_dims = 0;
49f48c71 3185 const char *string;
c583dd46
APB		 3186
3187 /* Eventually get more dims */
3188 string = IDENTIFIER_POINTER (name);
3189 while (string [more_dims] == '[')
3190 more_dims++;
3191
3192 /* If we have, then craft a new type for this variable */
3193 if (more_dims)
3194 {
c0d87ff6 3195 name = get_identifier (&string [more_dims]);
c583dd46 3196
34f4db93
APB		 3197 /* If we have a pointer, use its type */
3198 if (TREE_CODE (type) == POINTER_TYPE)
3199 type = TREE_TYPE (type);
c583dd46
APB		 3200
3201 /* Building the first dimension of a primitive type uses this
3202 function */
3203 if (JPRIMITIVE_TYPE_P (type))
3204 {
3205 type = build_java_array_type (type, -1);
22eed1e6 3206 CLASS_LOADED_P (type) = 1;
c583dd46
APB		 3207 more_dims--;
3208 }
3209 /* Otherwise, if we have a WFL for this type, use it (the type
3210 is already an array on an unresolved type, and we just keep
3211 on adding dimensions) */
3212 else if (type_wfl)
3213 type = type_wfl;
3214
3215 /* Add all the dimensions */
3216 while (more_dims--)
3217 type = build_unresolved_array_type (type);
3218
3219 /* The type may have been incomplete in the first place */
3220 if (type_wfl)
3221 type = obtain_incomplete_type (type);
3222 }
3223
c2952b01
APB		 3224 if (ret_name)
3225 *ret_name = name;
c583dd46
APB		 3226 return type;
3227}
3228
e04a16fb
AG		 3229/* Build something that the type identifier resolver will identify as
3230 being an array to an unresolved type. TYPE_WFL is a WFL on a
3231 identifier. */
3232
3233static tree
3234build_unresolved_array_type (type_or_wfl)
3235 tree type_or_wfl;
3236{
49f48c71 3237 const char *ptr;
e04a16fb 3238
1886c9d8 3239 /* TYPE_OR_WFL might be an array on a resolved type. In this case,
e04a16fb
AG		 3240 just create a array type */
3241 if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3242 {
3243 tree type = build_java_array_type (type_or_wfl, -1);
3244 CLASS_LOADED_P (type) = CLASS_LOADED_P (type_or_wfl);
3245 return type;
3246 }
3247
3248 obstack_1grow (&temporary_obstack, '[');
3249 obstack_grow0 (&temporary_obstack,
3250 IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3251 IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3252 ptr = obstack_finish (&temporary_obstack);
3253 return build_expr_wfl (get_identifier (ptr),
3254 EXPR_WFL_FILENAME (type_or_wfl),
3255 EXPR_WFL_LINENO (type_or_wfl),
3256 EXPR_WFL_COLNO (type_or_wfl));
3257}
3258
e04a16fb
AG		 3259static void
3260parser_add_interface (class_decl, interface_decl, wfl)
3261 tree class_decl, interface_decl, wfl;
3262{
3263 if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3264 parse_error_context (wfl, "Interface `%s' repeated",
3265 IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3266}
3267
3268/* Bulk of common class/interface checks. Return 1 if an error was
3269 encountered. TAG is 0 for a class, 1 for an interface. */
3270
3271static int
3272check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
3273 int is_interface, flags;
3274 tree raw_name, qualified_name, decl, cl;
3275{
3276 tree node;
c2952b01
APB		 3277 int sca = 0; /* Static class allowed */
3278 int icaf = 0; /* Inner class allowed flags */
3279 int uaaf = CLASS_MODIFIERS; /* Usually allowed access flags */
e04a16fb
AG		 3280
3281 if (!quiet_flag)
c2952b01
APB		 3282 fprintf (stderr, " %s%s %s",
3283 (CPC_INNER_P () ? "inner" : ""),
3284 (is_interface ? "interface" : "class"),
e04a16fb
AG		 3285 IDENTIFIER_POINTER (qualified_name));
3286
3287 /* Scope of an interface/class type name:
3288 - Can't be imported by a single type import
3289 - Can't already exists in the package */
3290 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3291 && (node = find_name_in_single_imports (raw_name)))
3292 {
3293 parse_error_context
3294 (cl, "%s name `%s' clashes with imported type `%s'",
3295 (is_interface ? "Interface" : "Class"),
3296 IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3297 return 1;
3298 }
3299 if (decl && CLASS_COMPLETE_P (decl))
3300 {
b67d701b
PB		 3301 classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3302 qualified_name, decl, cl);
e04a16fb
AG		 3303 return 1;
3304 }
3305
c2952b01
APB		 3306 if (check_inner_class_redefinition (raw_name, cl))
3307 return 1;
3308
3309 /* If public, file name should match class/interface name, except
3310 when dealing with an inner class */
3311 if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
e04a16fb 3312 {
49f48c71 3313 const char *f;
e04a16fb
AG		 3314
3315 /* Contains OS dependent assumption on path separator. FIXME */
3316 for (f = &input_filename [strlen (input_filename)];
fa322ab5
TT		 3317 f != input_filename && f[0] != '/' && f[0] != DIR_SEPARATOR;
3318 f--)
3319 ;
847fe791 3320 if (f[0] == '/' || f[0] == DIR_SEPARATOR)
e04a16fb
AG		 3321 f++;
3322 if (strncmp (IDENTIFIER_POINTER (raw_name),
3323 f , IDENTIFIER_LENGTH (raw_name)) ||
3324 f [IDENTIFIER_LENGTH (raw_name)] != '.')
781b0558
KG		 3325 parse_error_context
3326 (cl, "Public %s `%s' must be defined in a file called `%s.java'",
e04a16fb
AG		 3327 (is_interface ? "interface" : "class"),
3328 IDENTIFIER_POINTER (qualified_name),
3329 IDENTIFIER_POINTER (raw_name));
3330 }
3331
c2952b01
APB		 3332 /* Static classes can be declared only in top level classes. Note:
3333 once static, a inner class is a top level class. */
3334 if (flags & ACC_STATIC)
3335 {
3336 /* Catch the specific error of declaring an class inner class
3337 with no toplevel enclosing class. Prevent check_modifiers from
3338 complaining a second time */
3339 if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3340 {
3341 parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3342 IDENTIFIER_POINTER (qualified_name));
3343 sca = ACC_STATIC;
3344 }
3345 /* Else, in the context of a top-level class declaration, let
3346 `check_modifiers' do its job, otherwise, give it a go */
3347 else
3348 sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3349 }
3350
3351 /* Inner classes and interfaces can be declared private or protected
3352 within their enclosing classes. */
3353 if (CPC_INNER_P ())
3354 {
3355 /* A class which is local to a block can't be public, private,
3356 protected or static. But it is created final, so allow this
3357 one. */
3358 if (current_function_decl)
3359 icaf = sca = uaaf = ACC_FINAL;
3360 else
3361 {
3362 check_modifiers_consistency (flags);
3363 icaf = ACC_PRIVATE|ACC_PROTECTED;
3364 }
3365 }
3366
2884c41e
KG		 3367 if (is_interface)
3368 check_modifiers ("Illegal modifier `%s' for interface declaration",
3369 flags, INTERFACE_MODIFIERS);
3370 else
3371 check_modifiers ("Illegal modifier `%s' for class declaration",
c2952b01 3372 flags, uaaf|sca|icaf);
e04a16fb
AG		 3373 return 0;
3374}
3375
c2952b01
APB		 3376static void
3377make_nested_class_name (cpc_list)
3378 tree cpc_list;
3379{
3380 tree name;
3381
3382 if (!cpc_list)
3383 return;
3384 else
3385 make_nested_class_name (TREE_CHAIN (cpc_list));
3386
3387 /* Pick the qualified name when dealing with the first upmost
3388 enclosing class */
3389 name = (TREE_CHAIN (cpc_list) ?
3390 TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3391 obstack_grow (&temporary_obstack,
3392 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3393 /* Why is NO_DOLLAR_IN_LABEL defined? */
3394#if 0
3395#ifdef NO_DOLLAR_IN_LABEL
3396 fatal ("make_nested_class_name: Can't use '$' as a separator "
3397 "for inner classes");
3398#endif
3399#endif
3400 obstack_1grow (&temporary_obstack, '$');
3401}
3402
3403/* Can't redefine a class already defined in an earlier scope. */
3404
3405static int
3406check_inner_class_redefinition (raw_name, cl)
3407 tree raw_name, cl;
3408{
3409 tree scope_list;
3410
3411 for (scope_list = GET_CPC_LIST (); scope_list;
3412 scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3413 if (raw_name == GET_CPC_UN_NODE (scope_list))
3414 {
3415 parse_error_context
3416 (cl, "The class name `%s' is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
3417 IDENTIFIER_POINTER (raw_name));
3418 return 1;
3419 }
3420 return 0;
3421}
3422
3423static tree
3424find_as_inner_class (enclosing, name, cl)
3425 tree enclosing, name, cl;
3426{
3427 tree qual, to_return;
3428 if (!enclosing)
3429 return NULL_TREE;
3430
3431 name = TYPE_NAME (name);
3432
3433 /* First search: within the scope of `enclosing', search for name */
3434 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3435 qual = EXPR_WFL_QUALIFICATION (cl);
3436 else if (cl)
3437 qual = build_tree_list (cl, NULL_TREE);
3438 else
3439 qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3440
3441 if ((to_return = find_as_inner_class_do (qual, enclosing)))
3442 return to_return;
3443
3444 /* We're dealing with a qualified name. Try to resolve thing until
3445 we get something that is an enclosing class. */
3446 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3447 {
3448 tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3449
3450 for(qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3451 qual = TREE_CHAIN (qual))
3452 {
3453 acc = merge_qualified_name (acc,
3454 EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3455 BUILD_PTR_FROM_NAME (ptr, acc);
3456 decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3457 }
3458
3459 /* A NULL qual and a decl means that the search ended
3460 successfully?!? We have to do something then. FIXME */
3461
3462 if (decl)
3463 enclosing = decl;
3464 else
3465 qual = EXPR_WFL_QUALIFICATION (cl);
3466 }
3467 /* Otherwise, create a qual for the other part of the resolution. */
3468 else
3469 qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3470
3471 return find_as_inner_class_do (qual, enclosing);
3472}
3473
3474/* We go inside the list of sub classes and try to find a way
3475 through. */
3476
3477static tree
3478find_as_inner_class_do (qual, enclosing)
3479 tree qual, enclosing;
3480{
3481 if (!qual)
3482 return NULL_TREE;
3483
3484 for (; qual && enclosing; qual = TREE_CHAIN (qual))
3485 {
3486 tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3487 tree next_enclosing = NULL_TREE;
3488 tree inner_list;
3489
3490 for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3491 inner_list; inner_list = TREE_CHAIN (inner_list))
3492 {
3493 if (TREE_VALUE (inner_list) == name_to_match)
3494 {
3495 next_enclosing = TREE_PURPOSE (inner_list);
3496 break;
3497 }
3498 }
3499 enclosing = next_enclosing;
3500 }
3501
3502 return (!qual && enclosing ? enclosing : NULL_TREE);
3503}
3504
3505/* Reach all inner classes and tie their unqualified name to a
3506 DECL. */
3507
3508static void
3509set_nested_class_simple_name_value (outer, set)
3510 tree outer;
3511 int set;
3512{
3513 tree l;
3514
3515 for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3516 IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3517 TREE_PURPOSE (l) : NULL_TREE);
3518}
3519
3520static void
3521link_nested_class_to_enclosing ()
3522{
3523 if (GET_ENCLOSING_CPC ())
3524 {
3525 tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3526 DECL_INNER_CLASS_LIST (enclosing) =
3527 tree_cons (GET_CPC (), GET_CPC_UN (),
3528 DECL_INNER_CLASS_LIST (enclosing));
3529 enclosing = enclosing;
3530 }
3531}
3532
3533static tree
3534maybe_make_nested_class_name (name)
3535 tree name;
3536{
3537 tree id = NULL_TREE;
3538
3539 if (CPC_INNER_P ())
3540 {
3541 make_nested_class_name (GET_CPC_LIST ());
3542 obstack_grow (&temporary_obstack,
3543 IDENTIFIER_POINTER (name),
3544 IDENTIFIER_LENGTH (name));
3545 id = get_identifier (obstack_finish (&temporary_obstack));
3546 if (ctxp->package)
3547 QUALIFIED_P (id) = 1;
3548 }
3549 return id;
3550}
3551
3552/* If DECL is NULL, create and push a new DECL, record the current
3553 line CL and do other maintenance things. */
3554
e04a16fb 3555static tree
c2952b01
APB		 3556maybe_create_class_interface_decl (decl, raw_name, qualified_name, cl)
3557 tree decl, raw_name, qualified_name, cl;
e04a16fb 3558{
5e942c50 3559 if (!decl)
e04a16fb 3560 decl = push_class (make_class (), qualified_name);
c2952b01 3561
e04a16fb
AG		 3562 /* Take care of the file and line business */
3563 DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
f099f336
APB		 3564 /* If we're emiting xrefs, store the line/col number information */
3565 if (flag_emit_xref)
3566 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3567 else
3568 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
e04a16fb 3569 CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
b351b287
APB		 3570 CLASS_FROM_CURRENTLY_COMPILED_SOURCE_P (TREE_TYPE (decl)) =
3571 IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
e04a16fb 3572
c2952b01
APB		 3573 PUSH_CPC (decl, raw_name);
3574 DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3575
e04a16fb
AG		 3576 /* Link the declaration to the already seen ones */
3577 TREE_CHAIN (decl) = ctxp->class_list;
3578 ctxp->class_list = decl;
5e942c50 3579
23a79c61 3580 /* Create a new nodes in the global lists */
5e942c50 3581 ctxp->gclass_list = tree_cons (NULL_TREE, decl, ctxp->gclass_list);
23a79c61 3582 all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
5e942c50 3583
e04a16fb
AG		 3584 /* Install a new dependency list element */
3585 create_jdep_list (ctxp);
3586
3587 SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3588 IDENTIFIER_POINTER (qualified_name)));
3589 return decl;
3590}
3591
3592static void
3593add_superinterfaces (decl, interface_list)
3594 tree decl, interface_list;
3595{
3596 tree node;
3597 /* Superinterface(s): if present and defined, parser_check_super_interface ()
3598 takes care of ensuring that:
3599 - This is an accessible interface type,
3600 - Circularity detection.
3601 parser_add_interface is then called. If present but not defined,
3602 the check operation is delayed until the super interface gets
3603 defined. */
3604 for (node = interface_list; node; node = TREE_CHAIN (node))
3605 {
15fdcfe9 3606 tree current = TREE_PURPOSE (node);
5e942c50
APB		 3607 tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3608 if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
e04a16fb 3609 {
5e942c50
APB		 3610 if (!parser_check_super_interface (idecl, decl, current))
3611 parser_add_interface (decl, idecl, current);
e04a16fb
AG		 3612 }
3613 else
3614 register_incomplete_type (JDEP_INTERFACE,
3615 current, decl, NULL_TREE);
3616 }
3617}
3618
3619/* Create an interface in pass1 and return its decl. Return the
3620 interface's decl in pass 2. */
3621
3622static tree
3623create_interface (flags, id, super)
3624 int flags;
3625 tree id, super;
3626{
e04a16fb 3627 tree raw_name = EXPR_WFL_NODE (id);
c2952b01 3628 tree q_name = parser_qualified_classname (flags & ACC_STATIC, raw_name);
e04a16fb
AG		 3629 tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3630
3631 EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */
3632
3633 /* Basic checks: scope, redefinition, modifiers */
3634 if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
c2952b01
APB		 3635 {
3636 PUSH_ERROR ();
3637 return NULL_TREE;
3638 }
3639
3640 /* Suspend the current parsing context if we're parsing an inner
3641 interface */
3642 if (CPC_INNER_P ())
3643 java_parser_context_suspend ();
3644
3645 /* Push a new context for (static) initialized upon declaration fields */
3646 java_parser_context_push_initialized_field ();
e04a16fb
AG		 3647
3648 /* Interface modifiers check
3649 - public/abstract allowed (already done at that point)
3650 - abstract is obsolete (comes first, it's a warning, or should be)
3651 - Can't use twice the same (checked in the modifier rule) */
c877974e 3652 if ((flags & ACC_ABSTRACT) && flag_redundant)
e04a16fb
AG		 3653 parse_warning_context
3654 (MODIFIER_WFL (ABSTRACT_TK),
781b0558 3655 "Redundant use of `abstract' modifier. Interface `%s' is implicitely abstract", IDENTIFIER_POINTER (raw_name));
e04a16fb
AG		 3656
3657 /* Create a new decl if DECL is NULL, otherwise fix it */
c2952b01 3658 decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
e04a16fb
AG		 3659
3660 /* Set super info and mark the class a complete */
2aa11e97 3661 set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
e04a16fb
AG		 3662 object_type_node, ctxp->interface_number);
3663 ctxp->interface_number = 0;
3664 CLASS_COMPLETE_P (decl) = 1;
3665 add_superinterfaces (decl, super);
3666
3667 return decl;
3668}
3669
c2952b01
APB		 3670/* Anonymous class counter. Will be reset to 1 every time a non
3671 anonymous class gets created. */
3672static int anonymous_class_counter = 1;
3673
3674/* Patch anonymous class CLASS, by either extending or implementing
3675 DEP. */
3676
3677static void
3678patch_anonymous_class (type_decl, class_decl, wfl)
3679 tree type_decl, class_decl, wfl;
3680{
3681 tree class = TREE_TYPE (class_decl);
3682 tree type = TREE_TYPE (type_decl);
3683 tree binfo = TYPE_BINFO (class);
3684
3685 /* If it's an interface, implement it */
3686 if (CLASS_INTERFACE (type_decl))
3687 {
3688 tree s_binfo;
3689 int length;
3690
3691 if (parser_check_super_interface (type_decl, class_decl, wfl))
3692 return;
3693
3694 s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3695 length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3696 TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3697 TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3698 /* And add the interface */
3699 parser_add_interface (class_decl, type_decl, wfl);
3700 }
3701 /* Otherwise, it's a type we want to extend */
3702 else
3703 {
3704 if (parser_check_super (type_decl, class_decl, wfl))
3705 return;
3706 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3707 }
3708}
3709
3710static tree
3711create_anonymous_class (location, type_name)
3712 int location;
3713 tree type_name;
3714{
3715 char buffer [80];
3716 tree super = NULL_TREE, itf = NULL_TREE;
3717 tree id, type_decl, class;
3718
3719 /* The unqualified name of the anonymous class. It's just a number. */
3720 sprintf (buffer, "%d", anonymous_class_counter++);
3721 id = build_wfl_node (get_identifier (buffer));
3722 EXPR_WFL_LINECOL (id) = location;
3723
3724 /* We know about the type to extend/implement. We go ahead */
3725 if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3726 {
3727 /* Create a class which either implements on extends the designated
3728 class. The class bears an innacessible name. */
3729 if (CLASS_INTERFACE (type_decl))
3730 {
3731 /* It's OK to modify it here. It's been already used and
3732 shouldn't be reused */
3733 ctxp->interface_number = 1;
3734 /* Interfaces should presented as a list of WFLs */
3735 itf = build_tree_list (type_name, NULL_TREE);
3736 }
3737 else
3738 super = type_name;
3739 }
3740
3741 class = create_class (ACC_FINAL, id, super, itf);
3742
3743 /* We didn't know anything about the stuff. We register a dependence. */
3744 if (!type_decl)
3745 register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3746
3747 ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3748 return class;
3749}
3750
e04a16fb
AG		 3751/* Create an class in pass1 and return its decl. Return class
3752 interface's decl in pass 2. */
3753
3754static tree
3755create_class (flags, id, super, interfaces)
3756 int flags;
3757 tree id, super, interfaces;
3758{
e04a16fb
AG		 3759 tree raw_name = EXPR_WFL_NODE (id);
3760 tree class_id, decl;
9ee9b555 3761 tree super_decl_type;
e04a16fb 3762
c2952b01 3763 class_id = parser_qualified_classname (0, raw_name);
e04a16fb
AG		 3764 decl = IDENTIFIER_CLASS_VALUE (class_id);
3765 EXPR_WFL_NODE (id) = class_id;
3766
3767 /* Basic check: scope, redefinition, modifiers */
3768 if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
c2952b01
APB		 3769 {
3770 PUSH_ERROR ();
3771 return NULL_TREE;
3772 }
3773
3774 /* Suspend the current parsing context if we're parsing an inner
3775 class or an anonymous class. */
3776 if (CPC_INNER_P ())
3777 java_parser_context_suspend ();
3778 /* Push a new context for (static) initialized upon declaration fields */
3779 java_parser_context_push_initialized_field ();
e04a16fb
AG		 3780
3781 /* Class modifier check:
3782 - Allowed modifier (already done at that point)
3783 - abstract AND final forbidden
3784 - Public classes defined in the correct file */
3785 if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
781b0558
KG		 3786 parse_error_context
3787 (id, "Class `%s' can't be declared both abstract and final",
3788 IDENTIFIER_POINTER (raw_name));
e04a16fb
AG		 3789
3790 /* Create a new decl if DECL is NULL, otherwise fix it */
c2952b01 3791 decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
e04a16fb
AG		 3792
3793 /* If SUPER exists, use it, otherwise use Object */
3794 if (super)
3795 {
3796 /* Can't extend java.lang.Object */
3797 if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3798 {
3799 parse_error_context (id, "Can't extend `java.lang.Object'");
3800 return NULL_TREE;
3801 }
3802
2c3199bc
PB		 3803 super_decl_type =
3804 register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
e04a16fb
AG		 3805 }
3806 else if (TREE_TYPE (decl) != object_type_node)
3807 super_decl_type = object_type_node;
3808 /* We're defining java.lang.Object */
3809 else
3810 super_decl_type = NULL_TREE;
3811
3812 /* Set super info and mark the class a complete */
3813 set_super_info (flags, TREE_TYPE (decl), super_decl_type,
3814 ctxp->interface_number);
3815 ctxp->interface_number = 0;
3816 CLASS_COMPLETE_P (decl) = 1;
3817 add_superinterfaces (decl, interfaces);
3818
c2952b01
APB		 3819 /* If the class is a top level inner class, install an alias. */
3820 if (INNER_CLASS_DECL_P (decl) && CLASS_STATIC (decl))
3821 {
3822 tree alias = parser_qualified_classname (1, raw_name);
3823 IDENTIFIER_GLOBAL_VALUE (alias) = decl;
3824 }
3825
3826 /* Add the private this$<n> field, Replicate final locals still in
3827 scope as private final fields mangled like val$<local_name>.
3828 This doesn't not occur for top level (static) inner classes. */
3829 if (PURE_INNER_CLASS_DECL_P (decl))
3830 add_inner_class_fields (decl, current_function_decl);
3831
7f10c2e2
APB		 3832 /* If doing xref, store the location at which the inherited class
3833 (if any) was seen. */
3834 if (flag_emit_xref && super)
3835 DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
3836
5e942c50
APB		 3837 /* Eventually sets the @deprecated tag flag */
3838 CHECK_DEPRECATED (decl);
3839
165f37bc
APB		 3840 /* Reset the anonymous class counter when declaring non inner classes */
3841 if (!INNER_CLASS_DECL_P (decl))
c2952b01
APB		 3842 anonymous_class_counter = 1;
3843
e04a16fb
AG		 3844 return decl;
3845}
3846
c2952b01
APB		 3847/* End a class declaration: register the statements used to create
3848 $finit$ and <clinit>, pop the current class and resume the prior
3849 parser context if necessary. */
3850
3851static void
3852end_class_declaration (resume)
3853 int resume;
3854{
3855 /* If an error occured, context weren't pushed and won't need to be
3856 popped by a resume. */
3857 int no_error_occured = ctxp->next && GET_CPC () != error_mark_node;
3858
3859 java_parser_context_pop_initialized_field ();
3860 POP_CPC ();
3861 if (resume && no_error_occured)
3862 java_parser_context_resume ();
3863}
3864
3865static void
3866add_inner_class_fields (class_decl, fct_decl)
3867 tree class_decl;
3868 tree fct_decl;
3869{
3870 tree block, marker, f;
3871
3872 f = add_field (TREE_TYPE (class_decl),
3873 build_current_thisn (TREE_TYPE (class_decl)),
3874 build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
3875 ACC_PRIVATE);
3876 FIELD_THISN (f) = 1;
3877
3878 if (!fct_decl)
3879 return;
3880
3881 for (block = GET_CURRENT_BLOCK (fct_decl);
3882 block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
3883 {
3884 tree decl;
3885 for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
3886 {
3887 char *name, *pname;
3888 tree wfl, init, list;
3889
3890 /* Avoid non final arguments. */
3891 if (!LOCAL_FINAL (decl))
3892 continue;
3893
3894 MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
3895 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
3896 wfl = build_wfl_node (get_identifier (name));
3897 init = build_wfl_node (get_identifier (pname));
3898 /* Build an initialization for the field: it will be
3899 initialized by a parameter added to $finit$, bearing a
3900 mangled name of the field itself (param$<n>.) The
3901 parameter is provided to $finit$ by the constructor
3902 invoking it (hence the constructor will also feature a
3903 hidden parameter, set to the value of the outer context
3904 local at the time the inner class is created.)
3905
3906 Note: we take into account all possible locals that can
3907 be accessed by the inner class. It's actually not trivial
3908 to minimize these aliases down to the ones really
3909 used. One way to do that would be to expand all regular
3910 methods first, then $finit$ to get a picture of what's
3911 used. It works with the exception that we would have to
3912 go back on all constructor invoked in regular methods to
3913 have their invokation reworked (to include the right amount
3914 of alias initializer parameters.)
3915
3916 The only real way around, I think, is a first pass to
3917 identify locals really used in the inner class. We leave
3918 the flag FIELD_LOCAL_ALIAS_USED around for that future
3919 use.
3920
3921 On the other hand, it only affect local inner classes,
3922 whose constructors (and $finit$ call) will be featuring
3923 unecessary arguments. It's easy for a developper to keep
3924 this number of parameter down by using the `final'
3925 keyword only when necessary. For the time being, we can
3926 issue a warning on unecessary finals. FIXME */
3927 init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
3928 wfl, init);
3929
3930 /* Register the field. The TREE_LIST holding the part
3931 initialized/initializer will be marked ARG_FINAL_P so
3932 that the created field can be marked
3933 FIELD_LOCAL_ALIAS. */
3934 list = build_tree_list (wfl, init);
3935 ARG_FINAL_P (list) = 1;
3936 register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
3937 }
3938 }
3939
3940 if (!CPC_INITIALIZER_STMT (ctxp))
3941 return;
3942
3943 /* If we ever registered an alias field, insert and marker to
3944 remeber where the list ends. The second part of the list (the one
3945 featuring initialized fields) so it can be later reversed to
3946 enforce 8.5. The marker will be removed during that operation. */
3947 marker = build_tree_list (NULL_TREE, NULL_TREE);
3948 TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
3949 SET_CPC_INITIALIZER_STMT (ctxp, marker);
3950}
3951
e04a16fb
AG		 3952/* Can't use lookup_field () since we don't want to load the class and
3953 can't set the CLASS_LOADED_P flag */
3954
3955static tree
3956find_field (class, name)
3957 tree class;
3958 tree name;
3959{
3960 tree decl;
3961 for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
3962 {
3963 if (DECL_NAME (decl) == name)
3964 return decl;
3965 }
3966 return NULL_TREE;
3967}
3968
3969/* Wrap around lookup_field that doesn't potentially upset the value
3970 of CLASS */
3971
3972static tree
3973lookup_field_wrapper (class, name)
3974 tree class, name;
3975{
3976 tree type = class;
5b09b33e 3977 tree decl;
c877974e 3978 java_parser_context_save_global ();
5b09b33e 3979 decl = lookup_field (&type, name);
c877974e 3980 java_parser_context_restore_global ();
93024893 3981 return decl == error_mark_node ? NULL : decl;
e04a16fb
AG		 3982}
3983
3984/* Find duplicate field within the same class declarations and report
c583dd46
APB		 3985 the error. Returns 1 if a duplicated field was found, 0
3986 otherwise. */
e04a16fb
AG		 3987
3988static int
c583dd46 3989duplicate_declaration_error_p (new_field_name, new_type, cl)
0a2138e2 3990 tree new_field_name, new_type, cl;
e04a16fb
AG		 3991{
3992 /* This might be modified to work with method decl as well */
c2952b01 3993 tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
e04a16fb
AG		 3994 if (decl)
3995 {
c2e3db92 3996 char *t1 = xstrdup (purify_type_name
4a5f66c3
APB		 3997 ((TREE_CODE (new_type) == POINTER_TYPE
3998 && TREE_TYPE (new_type) == NULL_TREE) ?
3999 IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4000 lang_printable_name (new_type, 1)));
c877974e
APB		 4001 /* The type may not have been completed by the time we report
4002 the error */
c2e3db92 4003 char *t2 = xstrdup (purify_type_name
4a5f66c3 4004 ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
c877974e
APB		 4005 && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4006 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4007 lang_printable_name (TREE_TYPE (decl), 1)));
e04a16fb
AG		 4008 parse_error_context
4009 (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4010 t1, IDENTIFIER_POINTER (new_field_name),
4011 t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4012 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4013 free (t1);
4014 free (t2);
c583dd46 4015 return 1;
e04a16fb 4016 }
c583dd46 4017 return 0;
e04a16fb
AG		 4018}
4019
4020/* Field registration routine. If TYPE doesn't exist, field
4021 declarations are linked to the undefined TYPE dependency list, to
4022 be later resolved in java_complete_class () */
4023
4024static void
4025register_fields (flags, type, variable_list)
4026 int flags;
4027 tree type, variable_list;
4028{
c583dd46 4029 tree current, saved_type;
c2952b01 4030 tree class_type = NULL_TREE;
e04a16fb
AG		 4031 int saved_lineno = lineno;
4032 int must_chain = 0;
4033 tree wfl = NULL_TREE;
4034
c2952b01
APB		 4035 if (GET_CPC ())
4036 class_type = TREE_TYPE (GET_CPC ());
4037
4038 if (!class_type || class_type == error_mark_node)
4039 return;
4040
e04a16fb
AG		 4041 /* If we're adding fields to interfaces, those fields are public,
4042 static, final */
4043 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4044 {
4045 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
2884c41e 4046 flags, ACC_PUBLIC, "interface field(s)");
e04a16fb 4047 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
2884c41e 4048 flags, ACC_STATIC, "interface field(s)");
e04a16fb 4049 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
2884c41e 4050 flags, ACC_FINAL, "interface field(s)");
e04a16fb
AG		 4051 check_modifiers ("Illegal interface member modifier `%s'", flags,
4052 INTERFACE_FIELD_MODIFIERS);
4053 flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4054 }
4055
c583dd46
APB		 4056 /* Obtain a suitable type for resolution, if necessary */
4057 SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4058
4059 /* If TYPE is fully resolved and we don't have a reference, make one */
1886c9d8 4060 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
e04a16fb 4061
c583dd46
APB		 4062 for (current = variable_list, saved_type = type; current;
4063 current = TREE_CHAIN (current), type = saved_type)
e04a16fb 4064 {
c877974e 4065 tree real_type;
c583dd46 4066 tree field_decl;
e04a16fb
AG		 4067 tree cl = TREE_PURPOSE (current);
4068 tree init = TREE_VALUE (current);
4069 tree current_name = EXPR_WFL_NODE (cl);
4070
c2952b01
APB		 4071 /* Can't declare static fields in inner classes */
4072 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4073 && !CLASS_INTERFACE (TYPE_NAME (class_type)))
4074 parse_error_context
4075 (cl, "Field `%s' can't be static in innerclass `%s'. Only members of interfaces and top-level classes can be static",
4076 IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4077 lang_printable_name (class_type, 0));
4078
c583dd46
APB		 4079 /* Process NAME, as it may specify extra dimension(s) for it */
4080 type = build_array_from_name (type, wfl, current_name, &current_name);
4081
c583dd46
APB		 4082 /* Type adjustment. We may have just readjusted TYPE because
4083 the variable specified more dimensions. Make sure we have
22eed1e6
APB		 4084 a reference if we can and don't have one already. Also
4085 change the name if we have an init. */
4086 if (type != saved_type)
4087 {
1886c9d8 4088 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
22eed1e6
APB		 4089 if (init)
4090 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4091 }
e04a16fb 4092
c877974e
APB		 4093 real_type = GET_REAL_TYPE (type);
4094 /* Check for redeclarations */
4095 if (duplicate_declaration_error_p (current_name, real_type, cl))
4096 continue;
4097
c583dd46 4098 /* Set lineno to the line the field was found and create a
5e942c50 4099 declaration for it. Eventually sets the @deprecated tag flag. */
f099f336
APB		 4100 if (flag_emit_xref)
4101 lineno = EXPR_WFL_LINECOL (cl);
4102 else
4103 lineno = EXPR_WFL_LINENO (cl);
c877974e 4104 field_decl = add_field (class_type, current_name, real_type, flags);
5e942c50 4105 CHECK_DEPRECATED (field_decl);
c2952b01
APB		 4106
4107 /* If the couple initializer/initialized is marked ARG_FINAL_P, we
4108 mark the created field FIELD_LOCAL_ALIAS, so that we can
4109 hide parameters to this inner class $finit$ and constructors. */
4110 if (ARG_FINAL_P (current))
4111 FIELD_LOCAL_ALIAS (field_decl) = 1;
c583dd46
APB		 4112
4113 /* Check if we must chain. */
4114 if (must_chain)
4115 register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
e04a16fb 4116
c583dd46
APB		 4117 /* If we have an initialization value tied to the field */
4118 if (init)
4119 {
4120 /* The field is declared static */
e04a16fb 4121 if (flags & ACC_STATIC)
e04a16fb 4122 {
7525cc04
APB		 4123 /* We include the field and its initialization part into
4124 a list used to generate <clinit>. After <clinit> is
ba179f9f
APB		 4125 walked, field initializations will be processed and
4126 fields initialized with known constants will be taken
4127 out of <clinit> and have their DECL_INITIAL set
7525cc04 4128 appropriately. */
c2952b01
APB		 4129 TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4130 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
7f10c2e2
APB		 4131 if (TREE_OPERAND (init, 1)
4132 && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
5bba4807 4133 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
e04a16fb 4134 }
5e942c50
APB		 4135 /* A non-static field declared with an immediate initialization is
4136 to be initialized in <init>, if any. This field is remembered
4137 to be processed at the time of the generation of <init>. */
c583dd46
APB		 4138 else
4139 {
c2952b01
APB		 4140 TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4141 SET_CPC_INITIALIZER_STMT (ctxp, init);
c583dd46 4142 }
5b09b33e 4143 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
8576f094 4144 DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
e04a16fb
AG		 4145 }
4146 }
4147 lineno = saved_lineno;
4148}
4149
c2952b01
APB		 4150/* Generate $finit$, using the list of initialized fields to populate
4151 its body. $finit$'s parameter(s) list is adjusted to include the
4152 one(s) used to initialized the field(s) caching outer context
4153 local(s). */
22eed1e6 4154
c2952b01
APB		 4155static tree
4156generate_finit (class_type)
4157 tree class_type;
22eed1e6 4158{
c2952b01
APB		 4159 int count = 0;
4160 tree list = TYPE_FINIT_STMT_LIST (class_type);
4161 tree mdecl, current, parms;
4162
4163 parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4164 class_type, NULL_TREE,
4165 &count);
4166 CRAFTED_PARAM_LIST_FIXUP (parms);
4167 mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4168 finit_identifier_node, parms);
4169 fix_method_argument_names (parms, mdecl);
4170 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4171 mdecl, NULL_TREE);
4172 DECL_FUNCTION_NAP (mdecl) = count;
22eed1e6
APB		 4173 start_artificial_method_body (mdecl);
4174
c2952b01 4175 for (current = list; current; current = TREE_CHAIN (current))
22eed1e6
APB		 4176 java_method_add_stmt (mdecl,
4177 build_debugable_stmt (EXPR_WFL_LINECOL (current),
4178 current));
22eed1e6 4179 end_artificial_method_body (mdecl);
c2952b01 4180 return mdecl;
22eed1e6
APB		 4181}
4182
e04a16fb 4183static void
c2952b01
APB		 4184add_instance_initializer (mdecl)
4185 tree mdecl;
e04a16fb 4186{
c2952b01
APB		 4187 tree current;
4188 tree stmt_list = TYPE_II_STMT_LIST (DECL_CONTEXT (mdecl));
4189 tree compound = NULL_TREE;
e04a16fb 4190
c2952b01 4191 if (stmt_list)
e04a16fb 4192 {
c2952b01
APB		 4193 for (current = stmt_list; current; current = TREE_CHAIN (current))
4194 compound = add_stmt_to_compound (compound, NULL_TREE, current);
e04a16fb 4195
c2952b01
APB		 4196 java_method_add_stmt (mdecl, build1 (INSTANCE_INITIALIZERS_EXPR,
4197 NULL_TREE, compound));
4198 }
e04a16fb
AG		 4199}
4200
4201/* Shared accros method_declarator and method_header to remember the
4202 patch stage that was reached during the declaration of the method.
4203 A method DECL is built differently is there is no patch
4204 (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4205 pending on the currently defined method. */
4206
4207static int patch_stage;
4208
4209/* Check the method declaration and add the method to its current
4210 class. If the argument list is known to contain incomplete types,
4211 the method is partially added and the registration will be resume
22eed1e6
APB		 4212 once the method arguments resolved. If TYPE is NULL, we're dealing
4213 with a constructor. */
e04a16fb
AG		 4214
4215static tree
4216method_header (flags, type, mdecl, throws)
4217 int flags;
4218 tree type, mdecl, throws;
4219{
4220 tree meth = TREE_VALUE (mdecl);
4221 tree id = TREE_PURPOSE (mdecl);
1886c9d8 4222 tree type_wfl = NULL_TREE;
79d13333 4223 tree meth_name = NULL_TREE;
c2952b01 4224 tree current, orig_arg, this_class = NULL;
e04a16fb 4225 int saved_lineno;
1886c9d8 4226 int constructor_ok = 0, must_chain;
c2952b01 4227 int count;
e04a16fb
AG		 4228
4229 check_modifiers_consistency (flags);
79d13333 4230
c2952b01
APB		 4231 if (GET_CPC ())
4232 this_class = TREE_TYPE (GET_CPC ());
4233
4234 if (!this_class || this_class == error_mark_node)
79d13333 4235 return NULL_TREE;
e04a16fb
AG		 4236
4237 /* There are some forbidden modifiers for an abstract method and its
4238 class must be abstract as well. */
22eed1e6 4239 if (type && (flags & ACC_ABSTRACT))
e04a16fb
AG		 4240 {
4241 ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4242 ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4243 ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4244 ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4245 ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED,id, "Synchronized");
2aa11e97
APB		 4246 if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4247 && !CLASS_INTERFACE (TYPE_NAME (this_class)))
e04a16fb 4248 parse_error_context
781b0558 4249 (id, "Class `%s' must be declared abstract to define abstract method `%s'",
e04a16fb
AG		 4250 IDENTIFIER_POINTER (DECL_NAME (ctxp->current_parsed_class)),
4251 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4252 }
c2952b01 4253
22eed1e6
APB		 4254 /* Things to be checked when declaring a constructor */
4255 if (!type)
4256 {
4257 int ec = java_error_count;
4258 /* 8.6: Constructor declarations: we might be trying to define a
4259 method without specifying a return type. */
c2952b01 4260 if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
22eed1e6
APB		 4261 parse_error_context
4262 (id, "Invalid method declaration, return type required");
4263 /* 8.6.3: Constructor modifiers */
4264 else
4265 {
4266 JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4267 JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4268 JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4269 JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4270 JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4271 }
4272 /* If we found error here, we don't consider it's OK to tread
4273 the method definition as a constructor, for the rest of this
4274 function */
4275 if (ec == java_error_count)
4276 constructor_ok = 1;
4277 }
e04a16fb
AG		 4278
4279 /* Method declared within the scope of an interface are implicitly
4280 abstract and public. Conflicts with other erroneously provided
c0d87ff6 4281 modifiers are checked right after. */
e04a16fb
AG		 4282
4283 if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4284 {
4285 /* If FLAGS isn't set because of a modifier, turn the
4286 corresponding modifier WFL to NULL so we issue a warning on
4287 the obsolete use of the modifier */
4288 if (!(flags & ACC_PUBLIC))
4289 MODIFIER_WFL (PUBLIC_TK) = NULL;
4290 if (!(flags & ACC_ABSTRACT))
4291 MODIFIER_WFL (ABSTRACT_TK) = NULL;
4292 flags |= ACC_PUBLIC;
4293 flags |= ACC_ABSTRACT;
4294 }
4295
c2952b01
APB		 4296 /* Inner class can't declare static methods */
4297 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4298 {
4299 parse_error_context
4300 (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4301 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4302 lang_printable_name (this_class, 0));
4303 }
4304
e04a16fb
AG		 4305 /* Modifiers context reset moved up, so abstract method declaration
4306 modifiers can be later checked. */
4307
22eed1e6
APB		 4308 /* Set constructor returned type to void and method name to <init>,
4309 unless we found an error identifier the constructor (in which
4310 case we retain the original name) */
4311 if (!type)
4312 {
4313 type = void_type_node;
4314 if (constructor_ok)
4315 meth_name = init_identifier_node;
4316 }
4317 else
4318 meth_name = EXPR_WFL_NODE (id);
e04a16fb 4319
1886c9d8
APB		 4320 /* Do the returned type resolution and registration if necessary */
4321 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4322
4a5f66c3
APB		 4323 if (meth_name)
4324 type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
1886c9d8
APB		 4325 EXPR_WFL_NODE (id) = meth_name;
4326 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4327
4328 if (must_chain)
e04a16fb 4329 {
1886c9d8
APB		 4330 patch_stage = JDEP_METHOD_RETURN;
4331 register_incomplete_type (patch_stage, type_wfl, id, type);
4332 TREE_TYPE (meth) = GET_REAL_TYPE (type);
e04a16fb
AG		 4333 }
4334 else
1886c9d8 4335 TREE_TYPE (meth) = type;
e04a16fb
AG		 4336
4337 saved_lineno = lineno;
4338 /* When defining an abstract or interface method, the curly
4339 bracket at level 1 doesn't exist because there is no function
4340 body */
4341 lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4342 EXPR_WFL_LINENO (id));
4343
5e942c50
APB		 4344 /* Remember the original argument list */
4345 orig_arg = TYPE_ARG_TYPES (meth);
4346
e04a16fb
AG		 4347 if (patch_stage) /* includes ret type and/or all args */
4348 {
4349 jdep *jdep;
4350 meth = add_method_1 (this_class, flags, meth_name, meth);
4351 /* Patch for the return type */
4352 if (patch_stage == JDEP_METHOD_RETURN)
4353 {
4354 jdep = CLASSD_LAST (ctxp->classd_list);
4355 JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4356 }
4357 /* This is the stop JDEP. METH allows the function's signature
4358 to be computed. */
4359 register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4360 }
4361 else
5e942c50
APB		 4362 meth = add_method (this_class, flags, meth_name,
4363 build_java_signature (meth));
4364
c2952b01
APB		 4365 /* Remember final parameters */
4366 MARK_FINAL_PARMS (meth, orig_arg);
4367
5e942c50
APB		 4368 /* Fix the method argument list so we have the argument name
4369 information */
4370 fix_method_argument_names (orig_arg, meth);
4371
4372 /* Register the parameter number and re-install the current line
4373 number */
e04a16fb
AG		 4374 DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4375 lineno = saved_lineno;
b9f7e36c
APB		 4376
4377 /* Register exception specified by the `throws' keyword for
4378 resolution and set the method decl appropriate field to the list.
4379 Note: the grammar ensures that what we get here are class
4380 types. */
4381 if (throws)
4382 {
4383 throws = nreverse (throws);
4384 for (current = throws; current; current = TREE_CHAIN (current))
4385 {
4386 register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4387 NULL_TREE, NULL_TREE);
4388 JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4389 &TREE_VALUE (current);
4390 }
4391 DECL_FUNCTION_THROWS (meth) = throws;
4392 }
4393
e04a16fb
AG		 4394 /* We set the DECL_NAME to ID so we can track the location where
4395 the function was declared. This allow us to report
4396 redefinition error accurately. When method are verified,
4397 DECL_NAME is reinstalled properly (using the content of the
4398 WFL node ID) (see check_method_redefinition). We don't do that
22eed1e6
APB		 4399 when Object is being defined. Constructor <init> names will be
4400 reinstalled the same way. */
c2952b01 4401 if (TREE_TYPE (GET_CPC ()) != object_type_node)
e04a16fb 4402 DECL_NAME (meth) = id;
22eed1e6
APB		 4403
4404 /* Set the flag if we correctly processed a constructor */
4405 if (constructor_ok)
c2952b01
APB		 4406 {
4407 DECL_CONSTRUCTOR_P (meth) = 1;
4408 /* Compute and store the number of artificial parameters declared
4409 for this constructor */
4410 for (count = 0, current = TYPE_FIELDS (this_class); current;
4411 current = TREE_CHAIN (current))
4412 if (FIELD_LOCAL_ALIAS (current))
4413 count++;
4414 DECL_FUNCTION_NAP (meth) = count;
4415 }
22eed1e6 4416
5e942c50
APB		 4417 /* Eventually set the @deprecated tag flag */
4418 CHECK_DEPRECATED (meth);
4419
7f10c2e2
APB		 4420 /* If doing xref, store column and line number information instead
4421 of the line number only. */
4422 if (flag_emit_xref)
4423 DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4424
e04a16fb
AG		 4425 return meth;
4426}
4427
5e942c50
APB		 4428static void
4429fix_method_argument_names (orig_arg, meth)
4430 tree orig_arg, meth;
4431{
4432 tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4433 if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4434 {
4435 TREE_PURPOSE (arg) = this_identifier_node;
4436 arg = TREE_CHAIN (arg);
4437 }
de4c7b02 4438 while (orig_arg != end_params_node)
5e942c50
APB		 4439 {
4440 TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4441 orig_arg = TREE_CHAIN (orig_arg);
4442 arg = TREE_CHAIN (arg);
4443 }
4444}
4445
22eed1e6
APB		 4446/* Complete the method declaration with METHOD_BODY. */
4447
4448static void
b635eb2f 4449finish_method_declaration (method_body)
22eed1e6
APB		 4450 tree method_body;
4451{
79d13333
APB		 4452 int flags;
4453
4454 if (!current_function_decl)
4455 return;
4456
4457 flags = get_access_flags_from_decl (current_function_decl);
5256aa37
APB		 4458
4459 /* 8.4.5 Method Body */
4460 if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4461 {
4462 tree wfl = DECL_NAME (current_function_decl);
4463 parse_error_context (wfl,
4464 "%s method `%s' can't have a body defined",
4465 (METHOD_NATIVE (current_function_decl) ?
4466 "Native" : "Abstract"),
4467 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
4468 method_body = NULL_TREE;
4469 }
4470 else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4471 {
4472 tree wfl = DECL_NAME (current_function_decl);
781b0558
KG		 4473 parse_error_context
4474 (wfl,
4475 "Non native and non abstract method `%s' must have a body defined",
4476 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
5256aa37
APB		 4477 method_body = NULL_TREE;
4478 }
4479
2c56429a
APB		 4480 if (flag_emit_class_files && method_body
4481 && TREE_CODE (method_body) == NOP_EXPR
4482 && TREE_TYPE (current_function_decl)
4483 && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4484 method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4485
22eed1e6
APB		 4486 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4487 maybe_absorb_scoping_blocks ();
4488 /* Exit function's body */
4489 exit_block ();
4490 /* Merge last line of the function with first line, directly in the
4491 function decl. It will be used to emit correct debug info. */
7f10c2e2
APB		 4492 if (!flag_emit_xref)
4493 DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1);
c2952b01
APB		 4494
4495 /* Since function's argument's list are shared, reset the
4496 ARG_FINAL_P parameter that might have been set on some of this
4497 function parameters. */
4498 UNMARK_FINAL_PARMS (current_function_decl);
4499
f099f336
APB		 4500 /* So we don't have an irrelevant function declaration context for
4501 the next static block we'll see. */
4502 current_function_decl = NULL_TREE;
22eed1e6
APB		 4503}
4504
4505/* Build a an error message for constructor circularity errors. */
4506
4507static char *
4508constructor_circularity_msg (from, to)
4509 tree from, to;
4510{
4511 static char string [4096];
c2e3db92 4512 char *t = xstrdup (lang_printable_name (from, 0));
22eed1e6
APB		 4513 sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4514 free (t);
4515 return string;
4516}
4517
4518/* Verify a circular call to METH. Return 1 if an error is found, 0
4519 otherwise. */
4520
4521static int
4522verify_constructor_circularity (meth, current)
4523 tree meth, current;
4524{
4525 static tree list = NULL_TREE;
4526 tree c;
4527 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4528 {
4529 if (TREE_VALUE (c) == meth)
4530 {
4531 char *t;
4532 if (list)
4533 {
4534 tree liste;
4535 list = nreverse (list);
4536 for (liste = list; liste; liste = TREE_CHAIN (liste))
4537 {
4538 parse_error_context
c63b98cd 4539 (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
22eed1e6
APB		 4540 constructor_circularity_msg
4541 (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4542 java_error_count--;
4543 }
4544 }
c2e3db92 4545 t = xstrdup (lang_printable_name (meth, 0));
22eed1e6
APB		 4546 parse_error_context (TREE_PURPOSE (c),
4547 "%s: recursive invocation of constructor `%s'",
4548 constructor_circularity_msg (current, meth), t);
4549 free (t);
4550 list = NULL_TREE;
4551 return 1;
4552 }
4553 }
4554 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4555 {
4556 list = tree_cons (c, current, list);
4557 if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4558 return 1;
4559 list = TREE_CHAIN (list);
4560 }
4561 return 0;
4562}
4563
e04a16fb
AG		 4564/* Check modifiers that can be declared but exclusively */
4565
4566static void
4567check_modifiers_consistency (flags)
4568 int flags;
4569{
4570 int acc_count = 0;
4571 tree cl = NULL_TREE;
4572
e0fc4118
TT		 4573 THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4574 THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4575 THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
e04a16fb
AG		 4576 if (acc_count > 1)
4577 parse_error_context
e0fc4118
TT		 4578 (cl, "Inconsistent member declaration. At most one of `public', `private', or `protected' may be specified");
4579
4580 acc_count = 0;
4581 cl = NULL_TREE;
4582 THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK - PUBLIC_TK,
4583 acc_count, cl);
4584 THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK - PUBLIC_TK,
4585 acc_count, cl);
4586 if (acc_count > 1)
4587 parse_error_context (cl,
4588 "Inconsistent member declaration. At most one of `final' or `volatile' may be specified");
e04a16fb
AG		 4589}
4590
4591/* Check the methode header METH for abstract specifics features */
4592
4593static void
4594check_abstract_method_header (meth)
4595 tree meth;
4596{
4597 int flags = get_access_flags_from_decl (meth);
4598 /* DECL_NAME might still be a WFL node */
c877974e 4599 tree name = GET_METHOD_NAME (meth);
e04a16fb 4600
2884c41e
KG		 4601 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4602 ACC_ABSTRACT, "abstract method",
4603 IDENTIFIER_POINTER (name));
4604 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4605 ACC_PUBLIC, "abstract method",
4606 IDENTIFIER_POINTER (name));
e04a16fb
AG		 4607
4608 check_modifiers ("Illegal modifier `%s' for interface method",
4609 flags, INTERFACE_METHOD_MODIFIERS);
4610}
4611
4612/* Create a FUNCTION_TYPE node and start augmenting it with the
4613 declared function arguments. Arguments type that can't be resolved
4614 are left as they are, but the returned node is marked as containing
4615 incomplete types. */
4616
4617static tree
4618method_declarator (id, list)
4619 tree id, list;
4620{
4621 tree arg_types = NULL_TREE, current, node;
4622 tree meth = make_node (FUNCTION_TYPE);
4623 jdep *jdep;
e04a16fb
AG		 4624
4625 patch_stage = JDEP_NO_PATCH;
c2952b01
APB		 4626
4627 /* If we're dealing with an inner class constructor, we hide the
4628 this$<n> decl in the name field of its parameter declaration. We
4629 also might have to hide the outer context local alias
4630 initializers. Not done when the class is a toplevel class. */
4631 if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4632 && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4633 {
4634 tree aliases_list, type, thisn;
4635 /* First the aliases, linked to the regular parameters */
4636 aliases_list =
4637 build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4638 TREE_TYPE (GET_CPC ()),
4639 NULL_TREE, NULL);
4640 list = chainon (nreverse (aliases_list), list);
4641
4642 /* Then this$<n> */
4643 type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4644 thisn = build_current_thisn (TYPE_NAME (GET_CPC ()));
4645 list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4646 list);
4647 }
e04a16fb
AG		 4648
4649 for (current = list; current; current = TREE_CHAIN (current))
4650 {
c583dd46 4651 int must_chain = 0;
e04a16fb
AG		 4652 tree wfl_name = TREE_PURPOSE (current);
4653 tree type = TREE_VALUE (current);
4654 tree name = EXPR_WFL_NODE (wfl_name);
c583dd46
APB		 4655 tree already, arg_node;
4656 tree type_wfl = NULL_TREE;
23a79c61 4657 tree real_type;
c583dd46
APB		 4658
4659 /* Obtain a suitable type for resolution, if necessary */
4660 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4661
4662 /* Process NAME, as it may specify extra dimension(s) for it */
4663 type = build_array_from_name (type, type_wfl, name, &name);
4664 EXPR_WFL_NODE (wfl_name) = name;
e04a16fb 4665
23a79c61
APB		 4666 real_type = GET_REAL_TYPE (type);
4667 if (TREE_CODE (real_type) == RECORD_TYPE)
4668 {
4669 real_type = promote_type (real_type);
4670 if (TREE_CODE (type) == TREE_LIST)
4671 TREE_PURPOSE (type) = real_type;
4672 }
5e942c50 4673
e04a16fb
AG		 4674 /* Check redefinition */
4675 for (already = arg_types; already; already = TREE_CHAIN (already))
4676 if (TREE_PURPOSE (already) == name)
4677 {
781b0558
KG		 4678 parse_error_context
4679 (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4680 IDENTIFIER_POINTER (name),
e04a16fb
AG		 4681 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4682 break;
4683 }
4684
4685 /* If we've an incomplete argument type, we know there is a location
4686 to patch when the type get resolved, later. */
4687 jdep = NULL;
c583dd46 4688 if (must_chain)
e04a16fb 4689 {
c583dd46
APB		 4690 patch_stage = JDEP_METHOD;
4691 type = register_incomplete_type (patch_stage,
4692 type_wfl, wfl_name, type);
4693 jdep = CLASSD_LAST (ctxp->classd_list);
4694 JDEP_MISC (jdep) = id;
e04a16fb 4695 }
c583dd46 4696
c2952b01 4697 /* The argument node: a name and a (possibly) incomplete type. */
23a79c61 4698 arg_node = build_tree_list (name, real_type);
c2952b01
APB		 4699 /* Remeber arguments declared final. */
4700 ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4701
e04a16fb
AG		 4702 if (jdep)
4703 JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4704 TREE_CHAIN (arg_node) = arg_types;
4705 arg_types = arg_node;
4706 }
de4c7b02 4707 TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
e04a16fb
AG		 4708 node = build_tree_list (id, meth);
4709 return node;
4710}
4711
4712static int
4713unresolved_type_p (wfl, returned)
4714 tree wfl;
4715 tree *returned;
4716
4717{
4718 if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
4719 {
e04a16fb 4720 if (returned)
165f37bc
APB		 4721 {
4722 tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
4723 if (decl && current_class && (decl == TYPE_NAME (current_class)))
4724 *returned = TREE_TYPE (decl);
4725 else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
4726 *returned = TREE_TYPE (GET_CPC ());
4727 else
4728 *returned = NULL_TREE;
4729 }
e04a16fb
AG		 4730 return 1;
4731 }
4732 if (returned)
4733 *returned = wfl;
4734 return 0;
4735}
4736
4737/* From NAME, build a qualified identifier node using the
4738 qualification from the current package definition. */
4739
4740static tree
c2952b01
APB		 4741parser_qualified_classname (is_static, name)
4742 int is_static;
e04a16fb
AG		 4743 tree name;
4744{
c2952b01
APB		 4745 tree nested_class_name;
4746
4747 if (!is_static
4748 && (nested_class_name = maybe_make_nested_class_name (name)))
4749 return nested_class_name;
4750
e04a16fb 4751 if (ctxp->package)
c2952b01 4752 return merge_qualified_name (ctxp->package, name);
e04a16fb 4753 else
c2952b01 4754 return name;
e04a16fb
AG		 4755}
4756
4757/* Called once the type a interface extends is resolved. Returns 0 if
4758 everything is OK. */
4759
4760static int
4761parser_check_super_interface (super_decl, this_decl, this_wfl)
4762 tree super_decl, this_decl, this_wfl;
4763{
4764 tree super_type = TREE_TYPE (super_decl);
4765
4766 /* Has to be an interface */
c2952b01 4767 if (!CLASS_INTERFACE (super_decl))
e04a16fb
AG		 4768 {
4769 parse_error_context
4770 (this_wfl, "Can't use %s `%s' to implement/extend %s `%s'",
4771 (TYPE_ARRAY_P (super_type) ? "array" : "class"),
4772 IDENTIFIER_POINTER (DECL_NAME (super_decl)),
4773 (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
4774 "interface" : "class"),
4775 IDENTIFIER_POINTER (DECL_NAME (this_decl)));
4776 return 1;
4777 }
4778
4779 /* Check scope: same package OK, other package: OK if public */
4780 if (check_pkg_class_access (DECL_NAME (super_decl), lookup_cl (this_decl)))
4781 return 1;
4782
4783 SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
4784 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4785 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
4786 return 0;
4787}
4788
4789/* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
4790 0 if everthing is OK. */
4791
4792static int
4793parser_check_super (super_decl, this_decl, wfl)
4794 tree super_decl, this_decl, wfl;
4795{
e04a16fb
AG		 4796 tree super_type = TREE_TYPE (super_decl);
4797
4798 /* SUPER should be a CLASS (neither an array nor an interface) */
4799 if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
4800 {
4801 parse_error_context
4802 (wfl, "Class `%s' can't subclass %s `%s'",
4803 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4804 (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
4805 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
4806 return 1;
4807 }
4808
4809 if (CLASS_FINAL (TYPE_NAME (super_type)))
4810 {
4811 parse_error_context (wfl, "Can't subclass final classes: %s",
4812 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
4813 return 1;
4814 }
4815
4816 /* Check scope: same package OK, other package: OK if public */
4817 if (check_pkg_class_access (DECL_NAME (super_decl), wfl))
4818 return 1;
4819
4820 SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
4821 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4822 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
4823 return 0;
4824}
4825
4826/* Create a new dependency list and link it (in a LIFO manner) to the
4827 CTXP list of type dependency list. */
4828
4829static void
4830create_jdep_list (ctxp)
4831 struct parser_ctxt *ctxp;
4832{
23a79c61 4833 jdeplist *new = (jdeplist *)xmalloc (sizeof (jdeplist));
e04a16fb
AG		 4834 new->first = new->last = NULL;
4835 new->next = ctxp->classd_list;
4836 ctxp->classd_list = new;
4837}
4838
4839static jdeplist *
4840reverse_jdep_list (ctxp)
4841 struct parser_ctxt *ctxp;
4842{
4843 register jdeplist *prev = NULL, *current, *next;
4844 for (current = ctxp->classd_list; current; current = next)
4845 {
4846 next = current->next;
4847 current->next = prev;
4848 prev = current;
4849 }
4850 return prev;
4851}
4852
23a79c61
APB		 4853/* Create a fake pointer based on the ID stored in
4854 TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
4855 registered again. */
e04a16fb
AG		 4856
4857static tree
23a79c61
APB		 4858obtain_incomplete_type (type_name)
4859 tree type_name;
e04a16fb 4860{
23a79c61
APB		 4861 tree ptr, name;
4862
4863 if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
4864 name = EXPR_WFL_NODE (type_name);
4865 else if (INCOMPLETE_TYPE_P (type_name))
4866 name = TYPE_NAME (type_name);
4867 else
4868 fatal ("invalid type name - obtain_incomplete_type");
e04a16fb
AG		 4869
4870 for (ptr = ctxp->incomplete_class; ptr; ptr = TREE_CHAIN (ptr))
78d21f92 4871 if (TYPE_NAME (ptr) == name)
e04a16fb
AG		 4872 break;
4873
4874 if (!ptr)
4875 {
e04a16fb 4876 push_obstacks (&permanent_obstack, &permanent_obstack);
78d21f92
PB		 4877 BUILD_PTR_FROM_NAME (ptr, name);
4878 layout_type (ptr);
e04a16fb
AG		 4879 pop_obstacks ();
4880 TREE_CHAIN (ptr) = ctxp->incomplete_class;
4881 ctxp->incomplete_class = ptr;
4882 }
4883
4884 return ptr;
4885}
4886
4887/* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
4888 non NULL instead of computing a new fake type based on WFL. The new
4889 dependency is inserted in the current type dependency list, in FIFO
4890 manner. */
4891
4892static tree
4893register_incomplete_type (kind, wfl, decl, ptr)
4894 int kind;
4895 tree wfl, decl, ptr;
4896{
23a79c61 4897 jdep *new = (jdep *)xmalloc (sizeof (jdep));
e04a16fb 4898
e04a16fb
AG		 4899 if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
4900 ptr = obtain_incomplete_type (wfl);
4901
4902 JDEP_KIND (new) = kind;
4903 JDEP_DECL (new) = decl;
4904 JDEP_SOLV (new) = ptr;
4905 JDEP_WFL (new) = wfl;
4906 JDEP_CHAIN (new) = NULL;
4907 JDEP_MISC (new) = NULL_TREE;
165f37bc
APB		 4908 if ((kind == JDEP_SUPER || kind == JDEP_INTERFACE)
4909 && GET_ENCLOSING_CPC ())
4910 JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
4911 else
324ed8fd 4912 JDEP_ENCLOSING (new) = GET_CPC ();
e04a16fb
AG		 4913 JDEP_GET_PATCH (new) = (tree *)NULL;
4914
4915 JDEP_INSERT (ctxp->classd_list, new);
4916
4917 return ptr;
4918}
4919
4920void
4921java_check_circular_reference ()
4922{
4923 tree current;
4924 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
4925 {
4926 tree type = TREE_TYPE (current);
e920ebc9 4927 if (CLASS_INTERFACE (current))
e04a16fb
AG		 4928 {
4929 /* Check all interfaces this class extends */
4930 tree basetype_vec = TYPE_BINFO_BASETYPES (type);
4931 int n, i;
4932
4933 if (!basetype_vec)
4934 return;
4935 n = TREE_VEC_LENGTH (basetype_vec);
4936 for (i = 0; i < n; i++)
4937 {
4938 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
4939 if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
4940 && interface_of_p (type, BINFO_TYPE (vec_elt)))
4941 parse_error_context (lookup_cl (current),
4942 "Cyclic interface inheritance");
4943 }
4944 }
4945 else
4946 if (inherits_from_p (CLASSTYPE_SUPER (type), type))
4947 parse_error_context (lookup_cl (current),
c2952b01
APB		 4948 "Cyclic class inheritance%s",
4949 (cyclic_inheritance_report ?
4950 cyclic_inheritance_report : ""));
4951 }
4952}
4953
4954/* Augment the parameter list PARM with parameters crafted to
4955 initialize outer context locals aliases. Through ARTIFICIAL, a
4956 count is kept of the number of crafted parameters. MODE governs
4957 what eventually gets created: something suitable for a function
4958 creation or a function invocation, either the constructor or
4959 $finit$. */
4960
4961static tree
4962build_alias_initializer_parameter_list (mode, class_type, parm, artificial)
4963 int mode;
4964 tree class_type, parm;
4965 int *artificial;
4966{
4967 tree field;
4968 for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
4969 if (FIELD_LOCAL_ALIAS (field))
4970 {
4971 char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
4972 tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
4973
4974 switch (mode)
4975 {
4976 case AIPL_FUNCTION_DECLARATION:
4977 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
4978 purpose = build_wfl_node (get_identifier (buffer));
4979 if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
4980 value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
4981 else
4982 value = TREE_TYPE (field);
4983 break;
4984
4985 case AIPL_FUNCTION_CREATION:
4986 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
4987 purpose = get_identifier (buffer);
4988 value = TREE_TYPE (field);
4989 break;
4990
4991 case AIPL_FUNCTION_FINIT_INVOCATION:
4992 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
4993 /* Now, this is wrong. purpose should always be the NAME
4994 of something and value its matching value (decl, type,
4995 etc...) FIXME -- but there is a lot to fix. */
4996
4997 /* When invoked for this kind of operation, we already
4998 know whether a field is used or not. */
4999 purpose = TREE_TYPE (field);
5000 value = build_wfl_node (get_identifier (buffer));
5001 break;
5002
5003 case AIPL_FUNCTION_CTOR_INVOCATION:
5004 /* There are two case: the constructor invokation happends
5005 outside the local inner, in which case, locales from the outer
5006 context are directly used.
5007
5008 Otherwise, we fold to using the alias directly. */
5009 if (class_type == current_class)
5010 value = field;
5011 else
5012 {
5013 name = get_identifier (&buffer[4]);
5014 value = IDENTIFIER_LOCAL_VALUE (name);
5015 }
5016 break;
5017 }
5018 parm = tree_cons (purpose, value, parm);
5019 if (artificial)
5020 *artificial +=1;
5021 }
5022 return parm;
5023}
5024
5025/* Craft a constructor for CLASS_DECL -- what we should do when none
5026 where found. ARGS is non NULL when a special signature must be
5027 enforced. This is the case for anonymous classes. */
5028
5029static void
5030craft_constructor (class_decl, args)
5031 tree class_decl, args;
5032{
5033 tree class_type = TREE_TYPE (class_decl);
5034 tree parm = NULL_TREE;
5035 int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5036 ACC_PUBLIC : 0);
5037 int i = 0, artificial = 0;
5038 tree decl, ctor_name;
5039 char buffer [80];
5040
5041 push_obstacks (&permanent_obstack, &permanent_obstack);
5042
5043 /* The constructor name is <init> unless we're dealing with an
5044 anonymous class, in which case the name will be fixed after having
5045 be expanded. */
5046 if (ANONYMOUS_CLASS_P (class_type))
5047 ctor_name = DECL_NAME (class_decl);
5048 else
5049 ctor_name = init_identifier_node;
5050
5051 /* If we're dealing with an inner class constructor, we hide the
5052 this$<n> decl in the name field of its parameter declaration. */
5053 if (PURE_INNER_CLASS_TYPE_P (class_type))
5054 {
5055 tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5056 parm = tree_cons (build_current_thisn (class_type),
5057 build_pointer_type (type), parm);
5058
5059 /* Some more arguments to be hidden here. The values of the local
5060 variables of the outer context that the inner class needs to see. */
5061 parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5062 class_type, parm,
5063 &artificial);
5064 }
5065
5066 /* Then if there are any args to be enforced, enforce them now */
5067 for (; args && args != end_params_node; args = TREE_CHAIN (args))
5068 {
5069 sprintf (buffer, "parm%d", i++);
5070 parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
e04a16fb 5071 }
c2952b01
APB		 5072
5073 CRAFTED_PARAM_LIST_FIXUP (parm);
5074 decl = create_artificial_method (class_type, flags, void_type_node,
5075 ctor_name, parm);
5076 fix_method_argument_names (parm, decl);
5077 /* Now, mark the artificial parameters. */
5078 DECL_FUNCTION_NAP (decl) = artificial;
5079
5080 pop_obstacks ();
5081 DECL_CONSTRUCTOR_P (decl) = 1;
e04a16fb
AG		 5082}
5083
c2952b01 5084
e920ebc9
APB		 5085/* Fix the constructors. This will be called right after circular
5086 references have been checked. It is necessary to fix constructors
5087 early even if no code generation will take place for that class:
5088 some generated constructor might be required by the class whose
5089 compilation triggered this one to be simply loaded. */
5090
5091void
5092java_fix_constructors ()
5093{
5094 tree current;
5095
5096 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5097 {
e920ebc9
APB		 5098 tree class_type = TREE_TYPE (current);
5099 int saw_ctor = 0;
c2952b01
APB		 5100 tree decl;
5101
5102 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5103 continue;
e920ebc9
APB		 5104
5105 for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5106 {
5107 if (DECL_CONSTRUCTOR_P (decl))
5108 {
5109 fix_constructors (decl);
5110 saw_ctor = 1;
5111 }
5112 }
5113
c2952b01
APB		 5114 /* Anonymous class constructor can't be generated that early. */
5115 if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5116 craft_constructor (current, NULL_TREE);
e920ebc9
APB		 5117 }
5118}
5119
23a79c61
APB		 5120/* safe_layout_class just makes sure that we can load a class without
5121 disrupting the current_class, input_file, lineno, etc, information
5122 about the class processed currently. */
5123
e04a16fb
AG		 5124void
5125safe_layout_class (class)
5126 tree class;
5127{
5128 tree save_current_class = current_class;
5129 char *save_input_filename = input_filename;
5130 int save_lineno = lineno;
5e942c50 5131
e04a16fb 5132 push_obstacks (&permanent_obstack, &permanent_obstack);
5e942c50 5133
e04a16fb
AG		 5134 layout_class (class);
5135 pop_obstacks ();
5e942c50 5136
e04a16fb
AG		 5137 current_class = save_current_class;
5138 input_filename = save_input_filename;
5139 lineno = save_lineno;
5140 CLASS_LOADED_P (class) = 1;
5141}
5142
5143static tree
5144jdep_resolve_class (dep)
5145 jdep *dep;
5146{
5147 tree decl;
5148
23a79c61
APB		 5149 if (JDEP_RESOLVED_P (dep))
5150 decl = JDEP_RESOLVED_DECL (dep);
5151 else
e04a16fb 5152 {
c2952b01 5153 decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
23a79c61 5154 JDEP_DECL (dep), JDEP_WFL (dep));
e04a16fb
AG		 5155 JDEP_RESOLVED (dep, decl);
5156 }
23a79c61 5157
e04a16fb 5158 if (!decl)
23a79c61
APB		 5159 complete_class_report_errors (dep);
5160
e04a16fb
AG		 5161 return decl;
5162}
5163
5164/* Complete unsatisfied class declaration and their dependencies */
5165
5166void
5167java_complete_class ()
5168{
e04a16fb
AG		 5169 tree cclass;
5170 jdeplist *cclassd;
5171 int error_found;
b67d701b 5172 tree type;
e04a16fb
AG		 5173
5174 push_obstacks (&permanent_obstack, &permanent_obstack);
5175
5176 /* Process imports and reverse the import on demand list */
5177 process_imports ();
5178 if (ctxp->import_demand_list)
5179 ctxp->import_demand_list = nreverse (ctxp->import_demand_list);
5180
5181 /* Rever things so we have the right order */
5182 ctxp->class_list = nreverse (ctxp->class_list);
5183 ctxp->classd_list = reverse_jdep_list (ctxp);
c877974e 5184
e04a16fb
AG		 5185 for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5186 cclass && cclassd;
5187 cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5188 {
5189 jdep *dep;
5190 for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5191 {
5192 tree decl;
e04a16fb
AG		 5193 if (!(decl = jdep_resolve_class (dep)))
5194 continue;
5195
5196 /* Now it's time to patch */
5197 switch (JDEP_KIND (dep))
5198 {
5199 case JDEP_SUPER:
5200 /* Simply patch super */
5201 if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5202 continue;
5203 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5204 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5205 break;
5206
5207 case JDEP_FIELD:
5208 {
5209 /* We do part of the job done in add_field */
5210 tree field_decl = JDEP_DECL (dep);
5211 tree field_type = TREE_TYPE (decl);
5212 push_obstacks (&permanent_obstack, &permanent_obstack);
e04a16fb 5213 if (TREE_CODE (field_type) == RECORD_TYPE)
e04a16fb
AG		 5214 field_type = promote_type (field_type);
5215 pop_obstacks ();
5216 TREE_TYPE (field_decl) = field_type;
5e942c50
APB		 5217 DECL_ALIGN (field_decl) = 0;
5218 layout_decl (field_decl, 0);
e04a16fb
AG		 5219 SOURCE_FRONTEND_DEBUG
5220 (("Completed field/var decl `%s' with `%s'",
5221 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5222 IDENTIFIER_POINTER (DECL_NAME (decl))));
5223 break;
5224 }
5225 case JDEP_METHOD: /* We start patching a method */
5226 case JDEP_METHOD_RETURN:
5227 error_found = 0;
5228 while (1)
5229 {
5230 if (decl)
5231 {
b67d701b
PB		 5232 type = TREE_TYPE(decl);
5233 if (TREE_CODE (type) == RECORD_TYPE)
5234 type = promote_type (type);
e04a16fb
AG		 5235 JDEP_APPLY_PATCH (dep, type);
5236 SOURCE_FRONTEND_DEBUG
5237 (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5238 "Completing fct `%s' with ret type `%s'":
5239 "Completing arg `%s' with type `%s'"),
5240 IDENTIFIER_POINTER (EXPR_WFL_NODE
5241 (JDEP_DECL_WFL (dep))),
5242 IDENTIFIER_POINTER (DECL_NAME (decl))));
5243 }
5244 else
5245 error_found = 1;
5246 dep = JDEP_CHAIN (dep);
5247 if (JDEP_KIND (dep) == JDEP_METHOD_END)
5248 break;
5249 else
5250 decl = jdep_resolve_class (dep);
5251 }
5252 if (!error_found)
5253 {
5254 tree mdecl = JDEP_DECL (dep), signature;
5255 push_obstacks (&permanent_obstack, &permanent_obstack);
165f37bc
APB		 5256 /* Recompute and reset the signature, check first that
5257 all types are now defined. If they're not,
5258 dont build the signature. */
5259 if (check_method_types_complete (mdecl))
5260 {
5261 signature = build_java_signature (TREE_TYPE (mdecl));
5262 set_java_signature (TREE_TYPE (mdecl), signature);
5263 }
e04a16fb
AG		 5264 pop_obstacks ();
5265 }
5266 else
5267 continue;
5268 break;
5269
5270 case JDEP_INTERFACE:
5271 if (parser_check_super_interface (decl, JDEP_DECL (dep),
5272 JDEP_WFL (dep)))
5273 continue;
5274 parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5275 break;
5276
b67d701b 5277 case JDEP_PARM:
e04a16fb 5278 case JDEP_VARIABLE:
b67d701b
PB		 5279 type = TREE_TYPE(decl);
5280 if (TREE_CODE (type) == RECORD_TYPE)
5281 type = promote_type (type);
5282 JDEP_APPLY_PATCH (dep, type);
e04a16fb
AG		 5283 break;
5284
5285 case JDEP_TYPE:
5286 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5287 SOURCE_FRONTEND_DEBUG
5288 (("Completing a random type dependency on a '%s' node",
5289 tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5290 break;
5291
b9f7e36c 5292 case JDEP_EXCEPTION:
c877974e
APB		 5293 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5294 SOURCE_FRONTEND_DEBUG
5295 (("Completing `%s' `throws' argument node",
5296 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
b9f7e36c
APB		 5297 break;
5298
c2952b01
APB		 5299 case JDEP_ANONYMOUS:
5300 patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5301 break;
5302
e04a16fb 5303 default:
0a2138e2
APB		 5304 fatal ("Can't handle patch code %d - java_complete_class",
5305 JDEP_KIND (dep));
e04a16fb
AG		 5306 }
5307 }
5308 }
5309 pop_obstacks ();
5310 return;
5311}
5312
5313/* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5314 array. */
5315
5316static tree
c2952b01
APB		 5317resolve_class (enclosing, class_type, decl, cl)
5318 tree enclosing, class_type, decl, cl;
e04a16fb 5319{
49f48c71
KG		 5320 const char *name = IDENTIFIER_POINTER (TYPE_NAME (class_type));
5321 const char *base = name;
78d21f92
PB		 5322 tree resolved_type = TREE_TYPE (class_type);
5323 tree resolved_type_decl;
e04a16fb 5324
78d21f92
PB		 5325 if (resolved_type != NULL_TREE)
5326 {
5327 tree resolved_type_decl = TYPE_NAME (resolved_type);
5328 if (resolved_type_decl == NULL_TREE
5329 || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5330 {
5331 resolved_type_decl = build_decl (TYPE_DECL,
5332 TYPE_NAME (class_type),
5333 resolved_type);
5334 }
5335 return resolved_type_decl;
5336 }
5337
e04a16fb
AG		 5338 /* 1- Check to see if we have an array. If true, find what we really
5339 want to resolve */
5340 while (name[0] == '[')
5341 name++;
5342 if (base != name)
5343 TYPE_NAME (class_type) = get_identifier (name);
5344
5345 /* 2- Resolve the bare type */
c2952b01
APB		 5346 if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5347 decl, cl)))
e04a16fb
AG		 5348 return NULL_TREE;
5349 resolved_type = TREE_TYPE (resolved_type_decl);
5350
5351 /* 3- If we have and array, reconstruct the array down to its nesting */
5352 if (base != name)
5353 {
5354 while (base != name)
5355 {
5356 if (TREE_CODE (resolved_type) == RECORD_TYPE)
5357 resolved_type = promote_type (resolved_type);
5358 resolved_type = build_java_array_type (resolved_type, -1);
c583dd46 5359 CLASS_LOADED_P (resolved_type) = 1;
e04a16fb
AG		 5360 name--;
5361 }
5362 /* Build a fake decl for this, since this is what is expected to
5363 be returned. */
5364 resolved_type_decl =
5365 build_decl (TYPE_DECL, TYPE_NAME (resolved_type), resolved_type);
5366 /* Figure how those two things are important for error report. FIXME */
5367 DECL_SOURCE_LINE (resolved_type_decl) = 0;
5368 DECL_SOURCE_FILE (resolved_type_decl) = input_filename;
78d21f92 5369 TYPE_NAME (class_type) = TYPE_NAME (resolved_type);
e04a16fb 5370 }
78d21f92 5371 TREE_TYPE (class_type) = resolved_type;
e04a16fb
AG		 5372 return resolved_type_decl;
5373}
5374
5375/* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5376 are used to report error messages. */
5377
78d21f92 5378tree
c2952b01
APB		 5379do_resolve_class (enclosing, class_type, decl, cl)
5380 tree enclosing, class_type, decl, cl;
e04a16fb
AG		 5381{
5382 tree new_class_decl;
5383 tree original_name = NULL_TREE;
5384
5385 /* Do not try to replace TYPE_NAME (class_type) by a variable, since
5386 its is changed by find_in_imports{_on_demand} */
5387
c2952b01
APB		 5388 /* 0- Search in the current class as an inner class */
5389
5390 /* Maybe some code here should be added to load the class or
5391 something, at least if the class isn't an inner class and ended
5392 being loaded from class file. FIXME. */
5393 if ((new_class_decl = find_as_inner_class (enclosing, class_type, cl)))
5394 return new_class_decl;
5395
e04a16fb
AG		 5396 /* 1- Check for the type in single imports */
5397 if (find_in_imports (class_type))
5398 return NULL_TREE;
5399
5400 /* 2- And check for the type in the current compilation unit. If it fails,
ee07f4f4 5401 try with a name qualified with the package name we've seen so far */
e04a16fb
AG		 5402 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5403 {
5404 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5405 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5406 load_class (TYPE_NAME (class_type), 0);
5407 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5408 }
5409
5410 original_name = TYPE_NAME (class_type);
ee07f4f4 5411 if (!QUALIFIED_P (TYPE_NAME (class_type)))
bc3ca41b 5412 {
ee07f4f4
APB		 5413 tree package;
5414 for (package = package_list; package; package = TREE_CHAIN (package))
c2952b01
APB		 5415 {
5416 tree new_qualified;
5417
5418 new_qualified = merge_qualified_name (TREE_PURPOSE (package),
5419 original_name);
5420 TYPE_NAME (class_type) = new_qualified;
5421 new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5422 if (!new_class_decl)
5423 load_class (TYPE_NAME (class_type), 0);
5424 new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5425 if (new_class_decl)
5426 {
5427 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5428 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5429 load_class (TYPE_NAME (class_type), 0);
5430 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5431 }
bc3ca41b
PB		 5432 }
5433 }
c2952b01 5434
e04a16fb
AG		 5435 TYPE_NAME (class_type) = original_name;
5436
5437 /* 3- Check an other compilation unit that bears the name of type */
5438 load_class (TYPE_NAME (class_type), 0);
5439 if (check_pkg_class_access (TYPE_NAME (class_type),
5440 (cl ? cl : lookup_cl (decl))))
5441 return NULL_TREE;
5442
5443 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5444 return new_class_decl;
5445
5446 /* 4- Check the import on demands. Don't allow bar.baz to be
5447 imported from foo.* */
5448 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5449 if (find_in_imports_on_demand (class_type))
5450 return NULL_TREE;
5451
5452 /* 5- Last call for a resolution */
5453 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5454}
5455
5456/* Resolve NAME and lay it out (if not done and if not the current
23a79c61
APB		 5457 parsed class). Return a decl node. This function is meant to be
5458 called when type resolution is necessary during the walk pass. */
e04a16fb
AG		 5459
5460static tree
c877974e
APB		 5461resolve_and_layout (something, cl)
5462 tree something;
e04a16fb
AG		 5463 tree cl;
5464{
c877974e
APB		 5465 tree decl;
5466
23a79c61
APB		 5467 /* Don't do that on the current class */
5468 if (something == current_class)
5469 return TYPE_NAME (current_class);
c877974e 5470
23a79c61 5471 /* Don't do anything for void and other primitive types */
c877974e
APB		 5472 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5473 return NULL_TREE;
5474
23a79c61
APB		 5475 /* Pointer types can be reall pointer types or fake pointers. When
5476 finding a real pointer, recheck for primitive types */
5477 if (TREE_CODE (something) == POINTER_TYPE)
5478 {
5479 if (TREE_TYPE (something))
5480 {
5481 something = TREE_TYPE (something);
5482 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5483 return NULL_TREE;
5484 }
5485 else
5486 something = TYPE_NAME (something);
5487 }
5488
5489 /* Don't do anything for arrays of primitive types */
5490 if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5491 && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5492 return NULL_TREE;
5493
c2952b01
APB		 5494 /* Something might be a WFL */
5495 if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5496 something = EXPR_WFL_NODE (something);
5497
5498 /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5499 TYPE_DECL or a real TYPE */
5500 else if (TREE_CODE (something) != IDENTIFIER_NODE)
c877974e
APB		 5501 something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5502 DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5503
23a79c61
APB		 5504 if (!(decl = resolve_no_layout (something, cl)))
5505 return NULL_TREE;
5506
5507 /* Resolve and layout if necessary */
5508 layout_class_methods (TREE_TYPE (decl));
7705e9db
APB		 5509 /* Check methods, but only once */
5510 if (CLASS_FROM_SOURCE_P (TREE_TYPE (decl))
5511 && !CLASS_LOADED_P (TREE_TYPE (decl)))
23a79c61
APB		 5512 CHECK_METHODS (decl);
5513 if (TREE_TYPE (decl) != current_class && !CLASS_LOADED_P (TREE_TYPE (decl)))
e04a16fb 5514 safe_layout_class (TREE_TYPE (decl));
23a79c61 5515
e04a16fb
AG		 5516 return decl;
5517}
5518
5519/* Resolve a class, returns its decl but doesn't perform any
5520 layout. The current parsing context is saved and restored */
5521
5522static tree
5523resolve_no_layout (name, cl)
5524 tree name, cl;
5525{
5526 tree ptr, decl;
5527 BUILD_PTR_FROM_NAME (ptr, name);
5528 java_parser_context_save_global ();
c2952b01 5529 decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
e04a16fb
AG		 5530 java_parser_context_restore_global ();
5531
5532 return decl;
5533}
5534
23a79c61
APB		 5535/* Called when reporting errors. Skip leader '[' in a complex array
5536 type description that failed to be resolved. */
e04a16fb 5537
49f48c71 5538static const char *
e04a16fb 5539purify_type_name (name)
49f48c71 5540 const char *name;
e04a16fb
AG		 5541{
5542 while (*name && *name == '[')
5543 name++;
5544 return name;
5545}
5546
5547/* The type CURRENT refers to can't be found. We print error messages. */
5548
5549static void
5550complete_class_report_errors (dep)
5551 jdep *dep;
5552{
49f48c71 5553 const char *name;
23a79c61
APB		 5554
5555 if (!JDEP_WFL (dep))
5556 return;
5557
5558 name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
e04a16fb
AG		 5559 switch (JDEP_KIND (dep))
5560 {
5561 case JDEP_SUPER:
5562 parse_error_context
5563 (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
23a79c61 5564 purify_type_name (name),
e04a16fb
AG		 5565 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5566 break;
5567 case JDEP_FIELD:
5568 parse_error_context
5569 (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
23a79c61 5570 purify_type_name (name),
e04a16fb
AG		 5571 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5572 break;
5573 case JDEP_METHOD: /* Covers arguments */
5574 parse_error_context
781b0558 5575 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
23a79c61 5576 purify_type_name (name),
e04a16fb
AG		 5577 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
5578 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
5579 break;
5580 case JDEP_METHOD_RETURN: /* Covers return type */
5581 parse_error_context
781b0558 5582 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
23a79c61 5583 purify_type_name (name),
e04a16fb
AG		 5584 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
5585 break;
5586 case JDEP_INTERFACE:
5587 parse_error_context
5588 (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
5589 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
5590 (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
5591 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5592 break;
5593 case JDEP_VARIABLE:
5594 parse_error_context
781b0558 5595 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
b67d701b
PB		 5596 purify_type_name (IDENTIFIER_POINTER
5597 (EXPR_WFL_NODE (JDEP_WFL (dep)))),
e04a16fb
AG		 5598 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5599 break;
b9f7e36c
APB		 5600 case JDEP_EXCEPTION: /* As specified by `throws' */
5601 parse_error_context
5602 (JDEP_WFL (dep), "Class `%s' not found in `throws'",
5603 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
5604 break;
0a2138e2
APB		 5605 default:
5606 /* Fix for -Wall. Just break doing nothing. The error will be
5607 caught later */
5608 break;
e04a16fb
AG		 5609 }
5610}
5611
22eed1e6
APB		 5612/* Return a static string containing the DECL prototype string. If
5613 DECL is a constructor, use the class name instead of the form
5614 <init> */
5615
49f48c71 5616static const char *
22eed1e6
APB		 5617get_printable_method_name (decl)
5618 tree decl;
5619{
49f48c71 5620 const char *to_return;
9ee9b555 5621 tree name = NULL_TREE;
22eed1e6
APB		 5622
5623 if (DECL_CONSTRUCTOR_P (decl))
5624 {
5625 name = DECL_NAME (decl);
5e942c50 5626 DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
22eed1e6
APB		 5627 }
5628
5629 to_return = lang_printable_name (decl, 0);
5630 if (DECL_CONSTRUCTOR_P (decl))
5631 DECL_NAME (decl) = name;
5632
5633 return to_return;
5634}
5635
5e942c50
APB		 5636/* Reinstall the proper DECL_NAME on METHOD. Return 0 if the method
5637 nevertheless needs to be verfied, 1 otherwise. */
5638
5639static int
5640reset_method_name (method)
5641 tree method;
5642{
c2952b01 5643 if (!DECL_CLINIT_P (method) && !DECL_FINIT_P (method))
5e942c50
APB		 5644 {
5645 /* NAME is just the plain name when Object is being defined */
5646 if (DECL_CONTEXT (method) != object_type_node)
c877974e
APB		 5647 DECL_NAME (method) = (DECL_CONSTRUCTOR_P (method) ?
5648 init_identifier_node : GET_METHOD_NAME (method));
5e942c50
APB		 5649 return 0;
5650 }
5651 else
5652 return 1;
5653}
5654
c877974e
APB		 5655/* Return the name of METHOD_DECL, when DECL_NAME is a WFL */
5656
5657tree
5658java_get_real_method_name (method_decl)
5659 tree method_decl;
5660{
5661 tree method_name = DECL_NAME (method_decl);
5662 if (DECL_CONSTRUCTOR_P (method_decl))
5663 return init_identifier_node;
82371d41
APB		 5664
5665 /* Explain here why METHOD_DECL doesn't have the DECL_CONSTRUCTUR_P
5666 and still can be a constructor. FIXME */
5667
23a79c61
APB		 5668 /* Don't confuse method only bearing the name of their class as
5669 constructors */
82371d41
APB		 5670 else if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (method_decl))
5671 && ctxp
c2952b01 5672 && GET_CPC_UN () == EXPR_WFL_NODE (method_name)
23a79c61
APB		 5673 && get_access_flags_from_decl (method_decl) <= ACC_PROTECTED
5674 && TREE_TYPE (TREE_TYPE (method_decl)) == void_type_node)
c877974e
APB		 5675 return init_identifier_node;
5676 else
5677 return EXPR_WFL_NODE (method_name);
5678}
5679
22eed1e6
APB		 5680/* Track method being redefined inside the same class. As a side
5681 effect, set DECL_NAME to an IDENTIFIER (prior entering this
d77613be 5682 function it's a FWL, so we can track errors more accurately.) */
22eed1e6 5683
e04a16fb
AG		 5684static int
5685check_method_redefinition (class, method)
5686 tree class, method;
5687{
5688 tree redef, name;
5689 tree cl = DECL_NAME (method);
c3f2a476 5690 tree sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
ba179f9f
APB		 5691 /* decl name of artificial <clinit> and $finit$ doesn't need to be
5692 fixed and checked */
5e942c50
APB		 5693
5694 /* Reset the method name before running the check. If it returns 1,
5695 the method doesn't need to be verified with respect to method
5696 redeclaration and we return 0 */
5697 if (reset_method_name (method))
e04a16fb 5698 return 0;
5e942c50
APB		 5699
5700 name = DECL_NAME (method);
e04a16fb
AG		 5701 for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
5702 {
c3f2a476 5703 if (redef == method)
e04a16fb 5704 break;
c3f2a476
APB		 5705 if (DECL_NAME (redef) == name
5706 && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef)))
e04a16fb 5707 {
22eed1e6
APB		 5708 parse_error_context
5709 (cl, "Duplicate %s declaration `%s'",
5710 (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
5711 get_printable_method_name (redef));
e04a16fb
AG		 5712 return 1;
5713 }
5714 }
5715 return 0;
5716}
5717
d77613be
APB		 5718static void
5719check_abstract_method_definitions (do_interface, class_decl, type)
5720 int do_interface;
5721 tree class_decl, type;
5722{
5723 tree class = TREE_TYPE (class_decl);
5724 tree method, end_type;
5725
5726 end_type = (do_interface ? object_type_node : type);
5727 for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
5728 {
5729 tree other_super, other_method, method_sig, method_name;
5730 int found = 0;
165f37bc 5731 int end_type_reached = 0;
d77613be
APB		 5732
5733 if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
5734 continue;
5735
5736 /* Now verify that somewhere in between TYPE and CLASS,
5737 abstract method METHOD gets a non abstract definition
5738 that is inherited by CLASS. */
5739
5740 method_sig = build_java_signature (TREE_TYPE (method));
5741 method_name = DECL_NAME (method);
5742 if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
5743 method_name = EXPR_WFL_NODE (method_name);
5744
165f37bc
APB		 5745 other_super = class;
5746 do {
5747 if (other_super == end_type)
5748 end_type_reached = 1;
5749
5750 /* Method search */
5751 for (other_method = TYPE_METHODS (other_super); other_method;
5752 other_method = TREE_CHAIN (other_method))
5753 {
5754 tree s = build_java_signature (TREE_TYPE (other_method));
5755 tree other_name = DECL_NAME (other_method);
5756
5757 if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
5758 other_name = EXPR_WFL_NODE (other_name);
5759 if (!DECL_CLINIT_P (other_method)
5760 && !DECL_CONSTRUCTOR_P (other_method)
5761 && method_name == other_name && method_sig == s)
5762 {
5763 found = 1;
5764 break;
5765 }
5766 }
5767 other_super = CLASSTYPE_SUPER (other_super);
5768 } while (!end_type_reached);
5769
d77613be
APB		 5770 /* Report that abstract METHOD didn't find an implementation
5771 that CLASS can use. */
5772 if (!found)
5773 {
c2e3db92 5774 char *t = xstrdup (lang_printable_name
d77613be
APB		 5775 (TREE_TYPE (TREE_TYPE (method)), 0));
5776 tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
5777 tree saved_wfl = NULL_TREE;
5778
5779 if (TREE_CODE (DECL_NAME (method)) == EXPR_WITH_FILE_LOCATION)
5780 {
5781 saved_wfl = DECL_NAME (method);
5782 DECL_NAME (method) = EXPR_WFL_NODE (DECL_NAME (method));
5783 }
5784
5785 parse_error_context
5786 (lookup_cl (class_decl),
781b0558 5787 "Class `%s' doesn't define the abstract method `%s %s' from %s `%s'. This method must be defined or %s `%s' must be declared abstract",
d77613be
APB		 5788 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
5789 t, lang_printable_name (method, 0),
5790 (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
5791 "interface" : "class"),
5792 IDENTIFIER_POINTER (ccn),
5793 (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
5794 IDENTIFIER_POINTER (DECL_NAME (class_decl)));
5795
5796 free (t);
5797
5798 if (saved_wfl)
5799 DECL_NAME (method) = saved_wfl;
5800 }
5801 }
5802}
5803
614eaae0 5804/* Check that CLASS_DECL somehow implements all inherited abstract
d77613be
APB		 5805 methods. */
5806
5807static void
5808java_check_abstract_method_definitions (class_decl)
5809 tree class_decl;
5810{
5811 tree class = TREE_TYPE (class_decl);
5812 tree super, vector;
5813 int i;
5814
5815 if (CLASS_ABSTRACT (class_decl))
5816 return;
5817
5818 /* Check for inherited types */
165f37bc
APB		 5819 super = class;
5820 do {
5821 super = CLASSTYPE_SUPER (super);
5822 check_abstract_method_definitions (0, class_decl, super);
5823 } while (super != object_type_node);
d77613be
APB		 5824
5825 /* Check for implemented interfaces. */
5826 vector = TYPE_BINFO_BASETYPES (class);
5827 for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
5828 {
5829 super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
5830 check_abstract_method_definitions (1, class_decl, super);
5831 }
5832}
5833
165f37bc
APB		 5834/* Check all the types method DECL uses and return 1 if all of them
5835 are now complete, 0 otherwise. This is used to check whether its
5836 safe to build a method signature or not. */
5837
5838static int
5839check_method_types_complete (decl)
5840 tree decl;
5841{
5842 tree type = TREE_TYPE (decl);
5843 tree args;
5844
5845 if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
5846 return 0;
5847
5848 args = TYPE_ARG_TYPES (type);
5849 if (TREE_CODE (type) == METHOD_TYPE)
5850 args = TREE_CHAIN (args);
5851 for (; args != end_params_node; args = TREE_CHAIN (args))
5852 if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
5853 return 0;
5854
5855 return 1;
5856}
5857
d77613be
APB		 5858/* Check all the methods of CLASS_DECL. Methods are first completed
5859 then checked according to regular method existance rules. If no
5860 constructor for CLASS_DECL were encountered, then build its
5861 declaration. */
e04a16fb
AG		 5862
5863static void
5864java_check_regular_methods (class_decl)
5865 tree class_decl;
5866{
c2952b01 5867 int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
e04a16fb
AG		 5868 tree method;
5869 tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl));
5e942c50 5870 tree saved_found_wfl = NULL_TREE, found = NULL_TREE;
c877974e
APB		 5871 tree mthrows;
5872
5873 /* It is not necessary to check methods defined in java.lang.Object */
5874 if (class == object_type_node)
5875 return;
e04a16fb 5876
23a79c61
APB		 5877 if (!TYPE_NVIRTUALS (class))
5878 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
e04a16fb
AG		 5879
5880 /* Should take interfaces into account. FIXME */
5881 for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
5882 {
5e942c50 5883 tree sig;
e04a16fb
AG		 5884 tree method_wfl = DECL_NAME (method);
5885 int aflags;
5886
5e942c50
APB		 5887 /* If we previously found something and its name was saved,
5888 reinstall it now */
5889 if (found && saved_found_wfl)
ba179f9f
APB		 5890 {
5891 DECL_NAME (found) = saved_found_wfl;
5892 saved_found_wfl = NULL_TREE;
5893 }
5e942c50 5894
e04a16fb
AG		 5895 /* Check for redefinitions */
5896 if (check_method_redefinition (class, method))
5897 continue;
5898
22eed1e6
APB		 5899 /* If we see one constructor a mark so we don't generate the
5900 default one. Also skip other verifications: constructors
5901 can't be inherited hence hiden or overriden */
5902 if (DECL_CONSTRUCTOR_P (method))
5903 {
5904 saw_constructor = 1;
5905 continue;
5906 }
5907
c877974e
APB		 5908 /* We verify things thrown by the method. They must inherits from
5909 java.lang.Throwable */
5910 for (mthrows = DECL_FUNCTION_THROWS (method);
5911 mthrows; mthrows = TREE_CHAIN (mthrows))
5912 {
5913 if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
5914 parse_error_context
781b0558 5915 (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
c877974e
APB		 5916 IDENTIFIER_POINTER
5917 (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
5918 }
5919
e04a16fb 5920 sig = build_java_argument_signature (TREE_TYPE (method));
614eaae0 5921 found = lookup_argument_method2 (class, DECL_NAME (method), sig);
b9f7e36c 5922
c2952b01
APB		 5923 /* Inner class can't declare static methods */
5924 if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
5925 {
5926 char *t = xstrdup (lang_printable_name (class, 0));
5927 parse_error_context
5928 (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
5929 lang_printable_name (method, 0), t);
5930 free (t);
5931 }
5932
5e942c50 5933 /* Nothing overrides or it's a private method. */
aabd7048 5934 if (!found)
5e942c50 5935 continue;
aabd7048
PB		 5936 if (METHOD_PRIVATE (found))
5937 {
5938 found = NULL_TREE;
5939 continue;
5940 }
5e942c50
APB		 5941
5942 /* If found wasn't verified, it's DECL_NAME won't be set properly.
5943 We set it temporarily for the sake of the error report. */
5944 saved_found_wfl = DECL_NAME (found);
5945 reset_method_name (found);
5946
614eaae0
APB		 5947 /* If `found' is declared in an interface, make sure the
5948 modifier matches. */
5949 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
5950 && clinit_identifier_node != DECL_NAME (found)
5951 && !METHOD_PUBLIC (method))
5952 {
5953 tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
5954 parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
5955 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
5956 lang_printable_name (method, 0),
5957 IDENTIFIER_POINTER (DECL_NAME (found_decl)));
5958 }
5959
e04a16fb
AG		 5960 /* Can't override a method with the same name and different return
5961 types. */
5962 if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
b9f7e36c 5963 {
614eaae0
APB		 5964 char *t = xstrdup
5965 (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
b9f7e36c 5966 parse_error_context
7f10c2e2 5967 (method_wfl,
b9f7e36c 5968 "Method `%s' was defined with return type `%s' in class `%s'",
0a2138e2 5969 lang_printable_name (found, 0), t,
b9f7e36c
APB		 5970 IDENTIFIER_POINTER
5971 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
5972 free (t);
5973 }
e04a16fb 5974
7f10c2e2
APB		 5975 aflags = get_access_flags_from_decl (found);
5976 /* If the method has default, access in an other package, then
5977 issue a warning that the current method doesn't override the
5978 one that was found elsewhere. Do not issue this warning when
5979 the match was found in java.lang.Object. */
5980 if (DECL_CONTEXT (found) != object_type_node
a003f638 5981 && ((aflags & ACC_VISIBILITY) == 0)
7f10c2e2 5982 && !class_in_current_package (DECL_CONTEXT (found))
c2952b01 5983 && !DECL_CLINIT_P (found)
7f10c2e2
APB		 5984 && flag_not_overriding)
5985 {
5986 parse_warning_context
781b0558 5987 (method_wfl, "Method `%s' in class `%s' does not override the corresponding method in class `%s', which is private to a different package",
7f10c2e2
APB		 5988 lang_printable_name (found, 0),
5989 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
5990 IDENTIFIER_POINTER (DECL_NAME
5991 (TYPE_NAME (DECL_CONTEXT (found)))));
5992 continue;
5993 }
5994
e04a16fb
AG		 5995 /* Can't override final. Can't override static. */
5996 if (METHOD_FINAL (found) || METHOD_STATIC (found))
5997 {
5998 /* Static *can* override static */
5999 if (METHOD_STATIC (found) && METHOD_STATIC (method))
6000 continue;
6001 parse_error_context
6002 (method_wfl,
6003 "%s methods can't be overriden. Method `%s' is %s in class `%s'",
6004 (METHOD_FINAL (found) ? "Final" : "Static"),
0a2138e2 6005 lang_printable_name (found, 0),
e04a16fb
AG		 6006 (METHOD_FINAL (found) ? "final" : "static"),
6007 IDENTIFIER_POINTER
6008 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6009 continue;
6010 }
7f10c2e2 6011
e04a16fb
AG		 6012 /* Static method can't override instance method. */
6013 if (METHOD_STATIC (method))
6014 {
6015 parse_error_context
6016 (method_wfl,
781b0558 6017 "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
0a2138e2 6018 lang_printable_name (found, 0),
e04a16fb
AG		 6019 IDENTIFIER_POINTER
6020 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6021 continue;
6022 }
5e942c50 6023
5e942c50
APB		 6024 /* - Overriding/hiding public must be public
6025 - Overriding/hiding protected must be protected or public
6026 - If the overriden or hidden method has default (package)
6027 access, then the overriding or hiding method must not be
614eaae0
APB		 6028 private; otherwise, a compile-time error occurs. If
6029 `found' belongs to an interface, things have been already
6030 taken care of. */
6031 if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6032 && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6033 || (METHOD_PROTECTED (found)
6034 && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6035 || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6036 && METHOD_PRIVATE (method))))
e04a16fb
AG		 6037 {
6038 parse_error_context
6039 (method_wfl,
781b0558 6040 "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
5e942c50
APB		 6041 (METHOD_PUBLIC (method) ? "public" :
6042 (METHOD_PRIVATE (method) ? "private" : "protected")),
6043 IDENTIFIER_POINTER (DECL_NAME
6044 (TYPE_NAME (DECL_CONTEXT (found)))));
e04a16fb
AG		 6045 continue;
6046 }
6047
b9f7e36c
APB		 6048 /* Overriding methods must have compatible `throws' clauses on checked
6049 exceptions, if any */
6050 check_throws_clauses (method, method_wfl, found);
6051
e04a16fb
AG		 6052 /* Inheriting multiple methods with the same signature. FIXME */
6053 }
6054
5e942c50
APB		 6055 /* Don't forget eventual pending found and saved_found_wfl. Take
6056 into account that we might have exited because we saw an
d77613be 6057 artificial method as the last entry. */
5e942c50
APB		 6058
6059 if (found && !DECL_ARTIFICIAL (found) && saved_found_wfl)
6060 DECL_NAME (found) = saved_found_wfl;
6061
23a79c61
APB		 6062 if (!TYPE_NVIRTUALS (class))
6063 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
e04a16fb 6064
d77613be
APB		 6065 /* Search for inherited abstract method not yet implemented in this
6066 class. */
6067 java_check_abstract_method_definitions (class_decl);
6068
22eed1e6 6069 if (!saw_constructor)
e920ebc9 6070 fatal ("No constructor found");
e04a16fb
AG		 6071}
6072
b9f7e36c
APB		 6073/* Return a non zero value if the `throws' clause of METHOD (if any)
6074 is incompatible with the `throws' clause of FOUND (if any). */
6075
6076static void
6077check_throws_clauses (method, method_wfl, found)
6078 tree method, method_wfl, found;
6079{
6080 tree mthrows, fthrows;
6081
c877974e
APB		 6082 /* Can't check these things with class loaded from bytecode. FIXME */
6083 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6084 return;
6085
b9f7e36c
APB		 6086 for (mthrows = DECL_FUNCTION_THROWS (method);
6087 mthrows; mthrows = TREE_CHAIN (mthrows))
6088 {
6089 /* We don't verify unchecked expressions */
c877974e 6090 if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
b9f7e36c
APB		 6091 continue;
6092 /* Checked expression must be compatible */
6093 for (fthrows = DECL_FUNCTION_THROWS (found);
6094 fthrows; fthrows = TREE_CHAIN (fthrows))
6095 if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6096 break;
6097 if (!fthrows)
6098 {
6099 parse_error_context
781b0558 6100 (method_wfl, "Invalid checked exception class `%s' in `throws' clause. The exception must be a subclass of an exception thrown by `%s' from class `%s'",
b9f7e36c 6101 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
0a2138e2 6102 lang_printable_name (found, 0),
b9f7e36c
APB		 6103 IDENTIFIER_POINTER
6104 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6105 }
6106 }
6107}
6108
e04a16fb
AG		 6109/* Check abstract method of interface INTERFACE */
6110
6111static void
5e942c50
APB		 6112java_check_abstract_methods (interface_decl)
6113 tree interface_decl;
e04a16fb
AG		 6114{
6115 int i, n;
6116 tree method, basetype_vec, found;
5e942c50 6117 tree interface = TREE_TYPE (interface_decl);
e04a16fb
AG		 6118
6119 for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6120 {
b9f7e36c 6121 tree method_wfl = DECL_NAME (method);
e04a16fb
AG		 6122
6123 /* 2- Check for double definition inside the defining interface */
6124 if (check_method_redefinition (interface, method))
6125 continue;
6126
6127 /* 3- Overriding is OK as far as we preserve the return type and
b9f7e36c 6128 the thrown exceptions (FIXME) */
e04a16fb
AG		 6129 found = lookup_java_interface_method2 (interface, method);
6130 if (found)
6131 {
5e942c50
APB		 6132 char *t;
6133 tree saved_found_wfl = DECL_NAME (found);
6134 reset_method_name (found);
c2e3db92 6135 t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
e04a16fb 6136 parse_error_context
b9f7e36c 6137 (method_wfl,
5e942c50 6138 "Method `%s' was defined with return type `%s' in class `%s'",
0a2138e2 6139 lang_printable_name (found, 0), t,
b9f7e36c
APB		 6140 IDENTIFIER_POINTER
6141 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6142 free (t);
5e942c50 6143 DECL_NAME (found) = saved_found_wfl;
c63b98cd 6144 continue;
e04a16fb
AG		 6145 }
6146 }
6147
6148 /* 4- Inherited methods can't differ by their returned types */
6149 if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6150 return;
6151 n = TREE_VEC_LENGTH (basetype_vec);
6152 for (i = 0; i < n; i++)
6153 {
6154 tree sub_interface_method, sub_interface;
6155 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6156 if (!vec_elt)
6157 continue;
6158 sub_interface = BINFO_TYPE (vec_elt);
6159 for (sub_interface_method = TYPE_METHODS (sub_interface);
6160 sub_interface_method;
6161 sub_interface_method = TREE_CHAIN (sub_interface_method))
6162 {
6163 found = lookup_java_interface_method2 (interface,
6164 sub_interface_method);
6165 if (found && (found != sub_interface_method))
5e942c50
APB		 6166 {
6167 tree saved_found_wfl = DECL_NAME (found);
6168 reset_method_name (found);
6169 parse_error_context
6170 (lookup_cl (sub_interface_method),
781b0558 6171 "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
5e942c50
APB		 6172 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6173 lang_printable_name (found, 0),
6174 IDENTIFIER_POINTER
6175 (DECL_NAME (TYPE_NAME
6176 (DECL_CONTEXT (sub_interface_method)))),
6177 IDENTIFIER_POINTER
6178 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6179 DECL_NAME (found) = saved_found_wfl;
6180 }
e04a16fb
AG		 6181 }
6182 }
6183}
6184
e04a16fb
AG		 6185/* Lookup methods in interfaces using their name and partial
6186 signature. Return a matching method only if their types differ. */
6187
6188static tree
6189lookup_java_interface_method2 (class, method_decl)
6190 tree class, method_decl;
6191{
6192 int i, n;
6193 tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6194
6195 if (!basetype_vec)
6196 return NULL_TREE;
6197
6198 n = TREE_VEC_LENGTH (basetype_vec);
6199 for (i = 0; i < n; i++)
6200 {
6201 tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6202 if ((BINFO_TYPE (vec_elt) != object_type_node)
6203 && (to_return =
6204 lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6205 return to_return;
6206 }
6207 for (i = 0; i < n; i++)
6208 {
6209 to_return = lookup_java_interface_method2
6210 (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6211 if (to_return)
6212 return to_return;
6213 }
6214
6215 return NULL_TREE;
6216}
6217
6218/* Lookup method using their name and partial signature. Return a
6219 matching method only if their types differ. */
6220
6221static tree
6222lookup_java_method2 (clas, method_decl, do_interface)
6223 tree clas, method_decl;
6224 int do_interface;
6225{
5e942c50
APB		 6226 tree method, method_signature, method_name, method_type, name;
6227
e04a16fb 6228 method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
5e942c50
APB		 6229 name = DECL_NAME (method_decl);
6230 method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6231 EXPR_WFL_NODE (name) : name);
e04a16fb
AG		 6232 method_type = TREE_TYPE (TREE_TYPE (method_decl));
6233
6234 while (clas != NULL_TREE)
6235 {
6236 for (method = TYPE_METHODS (clas);
6237 method != NULL_TREE; method = TREE_CHAIN (method))
6238 {
6239 tree method_sig = build_java_argument_signature (TREE_TYPE (method));
5e942c50
APB		 6240 tree name = DECL_NAME (method);
6241 if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6242 EXPR_WFL_NODE (name) : name) == method_name
e04a16fb
AG		 6243 && method_sig == method_signature
6244 && TREE_TYPE (TREE_TYPE (method)) != method_type)
5e942c50 6245 return method;
e04a16fb
AG		 6246 }
6247 clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6248 }
6249 return NULL_TREE;
6250}
6251
f441f671
APB		 6252/* Return the line that matches DECL line number, and try its best to
6253 position the column number. Used during error reports. */
e04a16fb
AG		 6254
6255static tree
6256lookup_cl (decl)
6257 tree decl;
6258{
6259 static tree cl = NULL_TREE;
f441f671 6260 char *line, *found;
e04a16fb
AG		 6261
6262 if (!decl)
6263 return NULL_TREE;
6264
6265 if (cl == NULL_TREE)
6266 cl = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6267
6268 EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl));
6269 EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1);
6270
f441f671
APB		 6271 line = java_get_line_col (IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE (cl)),
6272 EXPR_WFL_LINENO (cl), EXPR_WFL_COLNO (cl));
6273
6274 found = strstr ((const char *)line,
6275 (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6276 if (found)
6277 EXPR_WFL_SET_LINECOL (cl, EXPR_WFL_LINENO (cl), found - line);
6278
e04a16fb
AG		 6279 return cl;
6280}
6281
6282/* Look for a simple name in the single-type import list */
6283
6284static tree
6285find_name_in_single_imports (name)
6286 tree name;
6287{
6288 tree node;
6289
6290 for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6291 if (TREE_VALUE (node) == name)
6292 return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6293
6294 return NULL_TREE;
6295}
6296
6297/* Process all single-type import. */
6298
6299static int
6300process_imports ()
6301{
6302 tree import;
6303 int error_found;
6304
6305 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6306 {
6307 tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6308
6309 /* Don't load twice something already defined. */
6310 if (IDENTIFIER_CLASS_VALUE (to_be_found))
6311 continue;
6312 QUALIFIED_P (to_be_found) = 1;
6313 load_class (to_be_found, 0);
6314 error_found =
6315 check_pkg_class_access (to_be_found, TREE_PURPOSE (import));
6316 if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6317 {
6318 parse_error_context (TREE_PURPOSE (import),
6319 "Class or interface `%s' not found in import",
6320 IDENTIFIER_POINTER (to_be_found));
6321 return 1;
6322 }
6323 if (error_found)
6324 return 1;
6325 }
6326 return 0;
6327}
6328
6329/* Possibly find a class imported by a single-type import statement. Return
6330 1 if an error occured, 0 otherwise. */
6331
6332static int
6333find_in_imports (class_type)
6334 tree class_type;
6335{
6336 tree import;
6337
6338 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6339 if (TREE_VALUE (import) == TYPE_NAME (class_type))
6340 {
6341 TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6342 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
e04a16fb
AG		 6343 }
6344 return 0;
6345}
6346
e04a16fb 6347static int
63a212ed 6348note_possible_classname (name, len)
49f48c71 6349 const char *name;
63a212ed 6350 int len;
e04a16fb 6351{
63a212ed
PB		 6352 tree node;
6353 if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6354 len = len - 5;
6355 else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6356 len = len - 6;
e04a16fb 6357 else
63a212ed
PB		 6358 return 0;
6359 node = ident_subst (name, len, "", '/', '.', "");
6360 IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
fe0e4d76 6361 QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
63a212ed 6362 return 1;
e04a16fb
AG		 6363}
6364
6365/* Read a import directory, gathering potential match for further type
6366 references. Indifferently reads a filesystem or a ZIP archive
6367 directory. */
6368
6369static void
6370read_import_dir (wfl)
6371 tree wfl;
6372{
63a212ed 6373 tree package_id = EXPR_WFL_NODE (wfl);
49f48c71 6374 const char *package_name = IDENTIFIER_POINTER (package_id);
63a212ed 6375 int package_length = IDENTIFIER_LENGTH (package_id);
e04a16fb 6376 DIR *dirp = NULL;
d8fccff5 6377 JCF *saved_jcf = current_jcf;
e04a16fb 6378
63a212ed
PB		 6379 int found = 0;
6380 int k;
6381 void *entry;
6382 struct buffer filename[1];
6383
6384
6385 if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6386 return;
6387 IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6388
6389 BUFFER_INIT (filename);
6390 buffer_grow (filename, package_length + 100);
6391
6392 for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6393 {
49f48c71 6394 const char *entry_name = jcf_path_name (entry);
63a212ed
PB		 6395 int entry_length = strlen (entry_name);
6396 if (jcf_path_is_zipfile (entry))
6397 {
6398 ZipFile *zipf;
6399 buffer_grow (filename, entry_length);
6400 memcpy (filename->data, entry_name, entry_length - 1);
6401 filename->data[entry_length-1] = '\0';
6402 zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6403 if (zipf == NULL)
6404 error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6405 else
6406 {
6407 ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6408 BUFFER_RESET (filename);
6409 for (k = 0; k < package_length; k++)
6410 {
6411 char ch = package_name[k];
6412 *filename->ptr++ = ch == '.' ? '/' : ch;
6413 }
6414 *filename->ptr++ = '/';
6415
345137c7 6416 for (k = 0; k < zipf->count; k++, zipd = ZIPDIR_NEXT (zipd))
63a212ed 6417 {
49f48c71 6418 const char *current_entry = ZIPDIR_FILENAME (zipd);
63a212ed
PB		 6419 int current_entry_len = zipd->filename_length;
6420
345137c7
TT		 6421 if (current_entry_len >= BUFFER_LENGTH (filename)
6422 && strncmp (filename->data, current_entry,
6423 BUFFER_LENGTH (filename)) != 0)
63a212ed 6424 continue;
345137c7 6425 found |= note_possible_classname (current_entry,
63a212ed
PB		 6426 current_entry_len);
6427 }
6428 }
6429 }
6430 else
6431 {
6432 BUFFER_RESET (filename);
6433 buffer_grow (filename, entry_length + package_length + 4);
6434 strcpy (filename->data, entry_name);
6435 filename->ptr = filename->data + entry_length;
6436 for (k = 0; k < package_length; k++)
6437 {
6438 char ch = package_name[k];
6439 *filename->ptr++ = ch == '.' ? '/' : ch;
6440 }
6441 *filename->ptr = '\0';
6442
6443 dirp = opendir (filename->data);
6444 if (dirp == NULL)
6445 continue;
6446 *filename->ptr++ = '/';
6447 for (;;)
6448 {
63a212ed 6449 int len;
49f48c71 6450 const char *d_name;
63a212ed
PB		 6451 struct dirent *direntp = readdir (dirp);
6452 if (!direntp)
6453 break;
6454 d_name = direntp->d_name;
6455 len = strlen (direntp->d_name);
6456 buffer_grow (filename, len+1);
6457 strcpy (filename->ptr, d_name);
345137c7 6458 found |= note_possible_classname (filename->data + entry_length,
63a212ed
PB		 6459 package_length+len+1);
6460 }
6461 if (dirp)
6462 closedir (dirp);
6463 }
6464 }
e04a16fb 6465
63a212ed 6466 free (filename->data);
e04a16fb 6467
63a212ed
PB		 6468 /* Here we should have a unified way of retrieving an entry, to be
6469 indexed. */
6470 if (!found)
e04a16fb
AG		 6471 {
6472 static int first = 1;
6473 if (first)
6474 {
781b0558 6475 error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives.", package_name);
e04a16fb
AG		 6476 java_error_count++;
6477 first = 0;
6478 }
6479 else
63a212ed
PB		 6480 parse_error_context (wfl, "Package `%s' not found in import",
6481 package_name);
e04a16fb
AG		 6482 current_jcf = saved_jcf;
6483 return;
6484 }
e04a16fb
AG		 6485 current_jcf = saved_jcf;
6486}
6487
6488/* Possibly find a type in the import on demands specified
6489 types. Returns 1 if an error occured, 0 otherwise. Run throught the
6490 entire list, to detected potential double definitions. */
6491
6492static int
6493find_in_imports_on_demand (class_type)
6494 tree class_type;
6495{
ab3a6dd6 6496 tree node, import, node_to_use = NULL_TREE;
e04a16fb 6497 int seen_once = -1;
ab3a6dd6 6498 tree cl = NULL_TREE;
e04a16fb
AG		 6499
6500 for (import = ctxp->import_demand_list; import; import = TREE_CHAIN (import))
6501 {
49f48c71 6502 const char *id_name;
e04a16fb
AG		 6503 obstack_grow (&temporary_obstack,
6504 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
6505 IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
63a212ed 6506 obstack_1grow (&temporary_obstack, '.');
e04a16fb
AG		 6507 obstack_grow0 (&temporary_obstack,
6508 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
6509 IDENTIFIER_LENGTH (TYPE_NAME (class_type)));
6510 id_name = obstack_finish (&temporary_obstack);
6511
6512 node = maybe_get_identifier (id_name);
6513 if (node && IS_A_CLASSFILE_NAME (node))
6514 {
6515 if (seen_once < 0)
6516 {
6517 cl = TREE_PURPOSE (import);
6518 seen_once = 1;
6519 node_to_use = node;
6520 }
6521 else
6522 {
6523 seen_once++;
6524 parse_error_context
6525 (import, "Type `%s' also potentially defined in package `%s'",
6526 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
6527 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))));
6528 }
6529 }
6530 }
6531
6532 if (seen_once == 1)
6533 {
6534 /* Setup lineno so that it refers to the line of the import (in
6535 case we parse a class file and encounter errors */
6536 tree decl;
6537 int saved_lineno = lineno;
6538 lineno = EXPR_WFL_LINENO (cl);
63a212ed 6539 TYPE_NAME (class_type) = node_to_use;
e04a16fb
AG		 6540 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6541 decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
6542 /* If there is no DECL set for the class or if the class isn't
6543 loaded and not seen in source yet, the load */
6544 if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
6545 && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
6546 load_class (node_to_use, 0);
6547 lineno = saved_lineno;
6548 return check_pkg_class_access (TYPE_NAME (class_type), cl);
6549 }
6550 else
6551 return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
6552}
6553
5e942c50
APB		 6554static tree
6555resolve_package (pkg, next)
6556 tree pkg, *next;
6557{
c2952b01 6558 tree current, acc;
5e942c50 6559 tree type_name = NULL_TREE;
49f48c71 6560 const char *name = IDENTIFIER_POINTER (EXPR_WFL_NODE (pkg));
5e942c50
APB		 6561
6562 /* The trick is to determine when the package name stops and were
6563 the name of something contained in the package starts. Then we
6564 return a fully qualified name of what we want to get. */
6565
6566 /* Do a quick search on well known package names */
6567 if (!strncmp (name, "java.lang.reflect", 17))
6568 {
6569 *next =
6570 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg))));
6571 type_name = lookup_package_type (name, 17);
6572 }
6573 else if (!strncmp (name, "java.lang", 9))
6574 {
6575 *next = TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg)));
6576 type_name = lookup_package_type (name, 9);
6577 }
5e942c50 6578
2c56429a
APB		 6579 /* If we found something here, return */
6580 if (type_name)
6581 return type_name;
6582
6583 *next = EXPR_WFL_QUALIFICATION (pkg);
6584
6585 /* Try the current package. */
6586 if (ctxp->package && !strncmp (name, IDENTIFIER_POINTER (ctxp->package),
6587 IDENTIFIER_LENGTH (ctxp->package)))
6588 {
6589 type_name =
6590 lookup_package_type_and_set_next (name,
6591 IDENTIFIER_LENGTH (ctxp->package),
6592 next );
6593 if (type_name)
6594 return type_name;
6595 }
6596
6597 /* Search in imported package */
6598 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
6599 {
6600 tree current_pkg_name = EXPR_WFL_NODE (TREE_PURPOSE (current));
6601 int len = IDENTIFIER_LENGTH (current_pkg_name);
6602 if (!strncmp (name, IDENTIFIER_POINTER (current_pkg_name), len))
6603 {
6604 tree left, dummy;
6605
6606 breakdown_qualified (&left, &dummy, current_pkg_name);
6607 len = IDENTIFIER_LENGTH (left);
6608 type_name = lookup_package_type_and_set_next (name, len, next);
6609 if (type_name)
6610 break;
6611 }
6612 }
6613
c2952b01
APB		 6614 /* Try to progressively construct a type name */
6615 if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
6616 for (acc = NULL_TREE, current = EXPR_WFL_QUALIFICATION (pkg);
6617 current; current = TREE_CHAIN (current))
6618 {
6619 acc = merge_qualified_name (acc, EXPR_WFL_NODE (QUAL_WFL (current)));
6620 if ((type_name = resolve_no_layout (acc, NULL_TREE)))
6621 {
6622 type_name = acc;
dde1da72 6623 *next = TREE_CHAIN (current);
c2952b01
APB		 6624 break;
6625 }
6626 }
2c56429a
APB		 6627 return type_name;
6628}
6629
6630static tree
6631lookup_package_type_and_set_next (name, len, next)
49f48c71 6632 const char *name;
2c56429a
APB		 6633 int len;
6634 tree *next;
6635{
49f48c71 6636 const char *ptr;
2c56429a
APB		 6637 tree type_name = lookup_package_type (name, len);
6638
6639 if (!type_name)
6640 return NULL;
6641
6642 ptr = IDENTIFIER_POINTER (type_name);
6643 while (ptr && (ptr = strchr (ptr, '.')))
6644 {
6645 *next = TREE_CHAIN (*next);
6646 ptr++;
6647 }
5e942c50
APB		 6648 return type_name;
6649}
6650
6651static tree
6652lookup_package_type (name, from)
49f48c71 6653 const char *name;
5e942c50
APB		 6654 int from;
6655{
6656 char subname [128];
49f48c71 6657 const char *sub = &name[from+1];
5e942c50
APB		 6658 while (*sub != '.' && *sub)
6659 sub++;
6660 strncpy (subname, name, sub-name);
6661 subname [sub-name] = '\0';
6662 return get_identifier (subname);
6663}
6664
e04a16fb
AG		 6665/* Check that CLASS_NAME refers to a PUBLIC class. Return 0 if no
6666 access violations were found, 1 otherwise. */
6667
6668static int
6669check_pkg_class_access (class_name, cl)
6670 tree class_name;
6671 tree cl;
6672{
6673 tree type;
e04a16fb
AG		 6674
6675 if (!QUALIFIED_P (class_name) || !IDENTIFIER_CLASS_VALUE (class_name))
6676 return 0;
6677
6678 if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
6679 return 0;
6680
6681 if (!CLASS_PUBLIC (TYPE_NAME (type)))
6682 {
e28cd97b
APB		 6683 /* Access to a private class within the same package is
6684 allowed. */
6685 tree l, r;
6686 breakdown_qualified (&l, &r, class_name);
6687 if (l == ctxp->package)
6688 return 0;
6689
e04a16fb 6690 parse_error_context
781b0558 6691 (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
e04a16fb
AG		 6692 (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
6693 IDENTIFIER_POINTER (class_name));
6694 return 1;
6695 }
6696 return 0;
6697}
6698
6699/* Local variable declaration. */
6700
6701static void
6702declare_local_variables (modifier, type, vlist)
6703 int modifier;
6704 tree type;
6705 tree vlist;
6706{
c583dd46
APB		 6707 tree decl, current, saved_type;
6708 tree type_wfl = NULL_TREE;
e04a16fb 6709 int must_chain = 0;
c2952b01 6710 int final_p = 0;
e04a16fb 6711
2aa11e97 6712 /* Push a new block if statements were seen between the last time we
e04a16fb 6713 pushed a block and now. Keep a cound of block to close */
f099f336 6714 if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
e04a16fb 6715 {
f099f336 6716 tree body = GET_CURRENT_BLOCK (current_function_decl);
e04a16fb 6717 tree b = enter_block ();
f099f336 6718 BLOCK_EXPR_ORIGIN (b) = body;
e04a16fb
AG		 6719 }
6720
6721 if (modifier)
6722 {
6723 int i;
6724 for (i = 0; i <= 10; i++) if (1 << i & modifier) break;
c877974e 6725 if (modifier == ACC_FINAL)
c2952b01 6726 final_p = 1;
c877974e
APB		 6727 else
6728 {
6729 parse_error_context
6730 (ctxp->modifier_ctx [i],
6731 "Only `final' is allowed as a local variables modifier");
6732 return;
6733 }
e04a16fb
AG		 6734 }
6735
c583dd46
APB		 6736 /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
6737 hold the TYPE value if a new incomplete has to be created (as
6738 opposed to being found already existing and reused). */
6739 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
6740
6741 /* If TYPE is fully resolved and we don't have a reference, make one */
1886c9d8 6742 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
c583dd46
APB		 6743
6744 /* Go through all the declared variables */
6745 for (current = vlist, saved_type = type; current;
6746 current = TREE_CHAIN (current), type = saved_type)
e04a16fb 6747 {
c877974e 6748 tree other, real_type;
e04a16fb
AG		 6749 tree wfl = TREE_PURPOSE (current);
6750 tree name = EXPR_WFL_NODE (wfl);
6751 tree init = TREE_VALUE (current);
e04a16fb 6752
c583dd46
APB		 6753 /* Process NAME, as it may specify extra dimension(s) for it */
6754 type = build_array_from_name (type, type_wfl, name, &name);
6755
6756 /* Variable redefinition check */
6757 if ((other = lookup_name_in_blocks (name)))
6758 {
6759 variable_redefinition_error (wfl, name, TREE_TYPE (other),
6760 DECL_SOURCE_LINE (other));
6761 continue;
6762 }
6763
6764 /* Type adjustment. We may have just readjusted TYPE because
6765 the variable specified more dimensions. Make sure we have
6766 a reference if we can and don't have one already. */
1886c9d8 6767 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
c877974e
APB		 6768
6769 real_type = GET_REAL_TYPE (type);
c583dd46
APB		 6770 /* Never layout this decl. This will be done when its scope
6771 will be entered */
c877974e 6772 decl = build_decl (VAR_DECL, name, real_type);
c2952b01 6773 LOCAL_FINAL (decl) = final_p;
c583dd46
APB		 6774 BLOCK_CHAIN_DECL (decl);
6775
d4370213
APB		 6776 /* If doing xreferencing, replace the line number with the WFL
6777 compound value */
6778 if (flag_emit_xref)
6779 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
6780
e04a16fb
AG		 6781 /* Don't try to use an INIT statement when an error was found */
6782 if (init && java_error_count)
6783 init = NULL_TREE;
c583dd46
APB		 6784
6785 /* Add the initialization function to the current function's code */
6786 if (init)
e04a16fb 6787 {
c583dd46
APB		 6788 /* Name might have been readjusted */
6789 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
6790 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
6791 java_method_add_stmt (current_function_decl,
6792 build_debugable_stmt (EXPR_WFL_LINECOL (init),
6793 init));
6794 }
6795
6796 /* Setup dependency the type of the decl */
6797 if (must_chain)
6798 {
6799 jdep *dep;
6800 register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
6801 dep = CLASSD_LAST (ctxp->classd_list);
6802 JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
e04a16fb
AG		 6803 }
6804 }
6805 SOURCE_FRONTEND_DEBUG (("Defined locals"));
6806}
6807
6808/* Called during parsing. Build decls from argument list. */
6809
6810static void
6811source_start_java_method (fndecl)
6812 tree fndecl;
6813{
6814 tree tem;
6815 tree parm_decl;
6816 int i;
c2952b01
APB		 6817#if 0
6818 int flag_inner = DECL_CONSTRUCTOR_P (fndecl)
6819 && (INNER_CLASS_TYPE_P (DECL_CONTEXT (fndecl)) ? 1 : 0);
6820#endif
e04a16fb 6821
79d13333
APB		 6822 if (!fndecl)
6823 return;
6824
e04a16fb
AG		 6825 current_function_decl = fndecl;
6826
6827 /* New scope for the function */
6828 enter_block ();
6829 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
de4c7b02 6830 tem != end_params_node; tem = TREE_CHAIN (tem), i++)
e04a16fb
AG		 6831 {
6832 tree type = TREE_VALUE (tem);
6833 tree name = TREE_PURPOSE (tem);
6834
23a79c61
APB		 6835 /* If type is incomplete. Create an incomplete decl and ask for
6836 the decl to be patched later */
e04a16fb
AG		 6837 if (INCOMPLETE_TYPE_P (type))
6838 {
6839 jdep *jdep;
c877974e
APB		 6840 tree real_type = GET_REAL_TYPE (type);
6841 parm_decl = build_decl (PARM_DECL, name, real_type);
23a79c61 6842 type = obtain_incomplete_type (type);
e04a16fb
AG		 6843 register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
6844 jdep = CLASSD_LAST (ctxp->classd_list);
6845 JDEP_MISC (jdep) = name;
6846 JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
6847 }
6848 else
6849 parm_decl = build_decl (PARM_DECL, name, type);
6850
c2952b01
APB		 6851 /* Remember if a local variable was declared final (via its
6852 TREE_LIST of type/name.) Set LOCAL_FINAL accordingly. */
6853 if (ARG_FINAL_P (tem))
6854 LOCAL_FINAL (parm_decl) = 1;
6855
e04a16fb 6856 BLOCK_CHAIN_DECL (parm_decl);
c2952b01
APB		 6857
6858#if 0
6859 /* If this is a constructor of a inner class, hide the extra
6860 this$<n> parameter */
6861 if (i == 0 && flag_inner)
6862 {
6863 tree link = TREE_CHAIN (tem);
6864 tree type = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (fndecl)));
6865
6866 type = build_pointer_type (TREE_TYPE (type));
6867 parm_decl = build_decl (PARM_DECL,
6868 build_current_thisn (current_class), type);
6869 BLOCK_CHAIN_DECL (parm_decl);
6870 /* We hide the this$<n> decl in the name field of its
6871 parameter declaration. */
6872 parm_decl = build_tree_list (DECL_NAME (parm_decl), type);
6873 TREE_CHAIN (tem) = parm_decl;
6874 TREE_CHAIN (parm_decl) = link;
6875 tem = parm_decl;
6876 i++;
6877 }
6878#endif
6879
e04a16fb
AG		 6880 }
6881 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
6882 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
6883 nreverse (tem);
6884 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
c2952b01 6885 DECL_MAX_LOCALS (current_function_decl) = i;
e04a16fb
AG		 6886}
6887
22eed1e6
APB		 6888/* Called during parsing. Creates an artificial method declaration. */
6889
6890static tree
6891create_artificial_method (class, flags, type, name, args)
6892 tree class;
6893 int flags;
6894 tree type, name, args;
6895{
22eed1e6
APB		 6896 tree mdecl;
6897
c2952b01 6898 java_parser_context_save_global ();
22eed1e6
APB		 6899 lineno = 0;
6900 mdecl = make_node (FUNCTION_TYPE);
6901 TREE_TYPE (mdecl) = type;
6902 TYPE_ARG_TYPES (mdecl) = args;
6903 mdecl = add_method (class, flags, name, build_java_signature (mdecl));
c2952b01 6904 java_parser_context_restore_global ();
22eed1e6
APB		 6905 DECL_ARTIFICIAL (mdecl) = 1;
6906 return mdecl;
6907}
6908
6909/* Starts the body if an artifical method. */
6910
6911static void
6912start_artificial_method_body (mdecl)
6913 tree mdecl;
6914{
6915 DECL_SOURCE_LINE (mdecl) = 1;
6916 DECL_SOURCE_LINE_MERGE (mdecl, 1);
6917 source_start_java_method (mdecl);
6918 enter_block ();
6919}
6920
6921static void
6922end_artificial_method_body (mdecl)
6923 tree mdecl;
6924{
6925 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block ();
6926 exit_block ();
6927}
6928
e04a16fb
AG		 6929/* Called during expansion. Push decls formerly built from argument
6930 list so they're usable during expansion. */
6931
6932static void
6933expand_start_java_method (fndecl)
6934 tree fndecl;
6935{
6936 tree tem, *ptr;
e04a16fb 6937
e04a16fb
AG		 6938 current_function_decl = fndecl;
6939
c2952b01
APB		 6940 if (! quiet_flag)
6941 fprintf (stderr, " [%s.", lang_printable_name (DECL_CONTEXT (fndecl), 0));
e04a16fb 6942 announce_function (fndecl);
c2952b01
APB		 6943 if (! quiet_flag)
6944 fprintf (stderr, "]");
6945
6946 pushlevel (1); /* Prepare for a parameter push */
e04a16fb
AG		 6947 ptr = &DECL_ARGUMENTS (fndecl);
6948 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
6949 while (tem)
6950 {
6951 tree next = TREE_CHAIN (tem);
b67d701b 6952 tree type = TREE_TYPE (tem);
e438e1b7
JJ		 6953 if (PROMOTE_PROTOTYPES
6954 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
b67d701b
PB		 6955 && INTEGRAL_TYPE_P (type))
6956 type = integer_type_node;
b67d701b 6957 DECL_ARG_TYPE (tem) = type;
e04a16fb
AG		 6958 layout_decl (tem, 0);
6959 pushdecl (tem);
e04a16fb
AG		 6960 *ptr = tem;
6961 ptr = &TREE_CHAIN (tem);
6962 tem = next;
6963 }
6964 *ptr = NULL_TREE;
6965 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
6966 lineno = DECL_SOURCE_LINE_FIRST (fndecl);
e04a16fb
AG		 6967}
6968
6969/* Terminate a function and expand its body. */
6970
6971static void
6972source_end_java_method ()
6973{
6974 tree fndecl = current_function_decl;
138657ec 6975 int flag_asynchronous_exceptions = asynchronous_exceptions;
e04a16fb 6976
79d13333
APB		 6977 if (!fndecl)
6978 return;
6979
e04a16fb
AG		 6980 java_parser_context_save_global ();
6981 lineno = ctxp->last_ccb_indent1;
6982
b67d701b
PB		 6983 /* Set EH language codes */
6984 java_set_exception_lang_code ();
6985
5423609c
APB		 6986 /* Turn function bodies with only a NOP expr null, so they don't get
6987 generated at all and we won't get warnings when using the -W
6988 -Wall flags. */
6989 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
6990 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
6991
e04a16fb
AG		 6992 /* Generate function's code */
6993 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
e8fc7396
APB		 6994 && ! flag_emit_class_files
6995 && ! flag_emit_xref)
e04a16fb
AG		 6996 expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
6997
6998 /* pop out of its parameters */
6999 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
7000 poplevel (1, 0, 1);
7001 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
7002
7003 /* Generate rtl for function exit. */
e8fc7396 7004 if (! flag_emit_class_files && ! flag_emit_xref)
e04a16fb
AG		 7005 {
7006 lineno = DECL_SOURCE_LINE_LAST (fndecl);
b67d701b
PB		 7007 /* Emit catch-finally clauses */
7008 emit_handlers ();
e04a16fb
AG		 7009 expand_function_end (input_filename, lineno, 0);
7010
138657ec
AH		 7011 /* FIXME: If the current method contains any exception handlers,
7012 force asynchronous_exceptions: this is necessary because signal
7013 handlers in libjava may throw exceptions. This is far from being
7014 a perfect solution, but it's better than doing nothing at all.*/
7015 if (catch_clauses)
7016 asynchronous_exceptions = 1;
7017
e04a16fb
AG		 7018 /* Run the optimizers and output assembler code for this function. */
7019 rest_of_compilation (fndecl);
7020 }
7021
7022 current_function_decl = NULL_TREE;
8226320b 7023 permanent_allocation (1);
e04a16fb 7024 java_parser_context_restore_global ();
138657ec 7025 asynchronous_exceptions = flag_asynchronous_exceptions;
e04a16fb
AG		 7026}
7027
7028/* Record EXPR in the current function block. Complements compound
7029 expression second operand if necessary. */
7030
7031tree
7032java_method_add_stmt (fndecl, expr)
7033 tree fndecl, expr;
7034{
b771925e
APB		 7035 if (!GET_CURRENT_BLOCK (fndecl))
7036 return NULL_TREE;
f099f336 7037 return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
b67d701b 7038}
e04a16fb 7039
b67d701b
PB		 7040static tree
7041add_stmt_to_block (b, type, stmt)
7042 tree b, type, stmt;
7043{
7044 tree body = BLOCK_EXPR_BODY (b), c;
7045
e04a16fb
AG		 7046 if (java_error_count)
7047 return body;
b67d701b
PB		 7048
7049 if ((c = add_stmt_to_compound (body, type, stmt)) == body)
e04a16fb
AG		 7050 return body;
7051
b67d701b
PB		 7052 BLOCK_EXPR_BODY (b) = c;
7053 TREE_SIDE_EFFECTS (c) = 1;
7054 return c;
e04a16fb
AG		 7055}
7056
7057/* Add STMT to EXISTING if possible, otherwise create a new
7058 COMPOUND_EXPR and add STMT to it. */
7059
7060static tree
7061add_stmt_to_compound (existing, type, stmt)
7062 tree existing, type, stmt;
7063{
15fdcfe9
PB		 7064 if (existing)
7065 return build (COMPOUND_EXPR, type, existing, stmt);
e04a16fb 7066 else
15fdcfe9 7067 return stmt;
e04a16fb
AG		 7068}
7069
7070/* Hold THIS for the scope of the current public method decl. */
7071static tree current_this;
7072
1886c9d8
APB		 7073void java_layout_seen_class_methods ()
7074{
7075 tree previous_list = all_class_list;
7076 tree end = NULL_TREE;
7077 tree current;
7078
7079 while (1)
7080 {
7081 for (current = previous_list;
7082 current != end; current = TREE_CHAIN (current))
7083 layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7084
7085 if (previous_list != all_class_list)
7086 {
7087 end = previous_list;
7088 previous_list = all_class_list;
7089 }
7090 else
7091 break;
7092 }
7093}
7094
e04a16fb 7095void
c2952b01 7096java_reorder_fields ()
e04a16fb 7097{
c2952b01 7098 static tree stop_reordering = NULL_TREE;
23a79c61 7099
c2952b01 7100 tree current;
5e942c50 7101 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
e04a16fb 7102 {
5e942c50 7103 current_class = TREE_TYPE (TREE_VALUE (current));
22eed1e6 7104
c2952b01
APB		 7105 if (current_class == stop_reordering)
7106 break;
7107
c877974e
APB		 7108 /* Reverse the fields, but leave the dummy field in front.
7109 Fields are already ordered for Object and Class */
7110 if (TYPE_FIELDS (current_class) && current_class != object_type_node
7111 && current_class != class_type_node)
7112 {
23a79c61
APB		 7113 /* If the dummy field is there, reverse the right fields and
7114 just layout the type for proper fields offset */
c877974e
APB		 7115 if (!DECL_NAME (TYPE_FIELDS (current_class)))
7116 {
7117 tree fields = TYPE_FIELDS (current_class);
7118 TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7119 TYPE_SIZE (current_class) = NULL_TREE;
c877974e 7120 }
23a79c61
APB		 7121 /* We don't have a dummy field, we need to layout the class,
7122 after having reversed the fields */
c877974e
APB		 7123 else
7124 {
7125 TYPE_FIELDS (current_class) =
7126 nreverse (TYPE_FIELDS (current_class));
7127 TYPE_SIZE (current_class) = NULL_TREE;
c877974e
APB		 7128 }
7129 }
c2952b01
APB		 7130 }
7131 stop_reordering = TREE_TYPE (TREE_VALUE (ctxp->gclass_list));
7132}
7133
7134/* Layout the methods of all classes loaded in one way on an
7135 other. Check methods of source parsed classes. Then reorder the
7136 fields and layout the classes or the type of all source parsed
7137 classes */
7138
7139void
7140java_layout_classes ()
7141{
7142 tree current;
7143 int save_error_count = java_error_count;
7144
7145 /* Layout the methods of all classes seen so far */
7146 java_layout_seen_class_methods ();
7147 java_parse_abort_on_error ();
7148 all_class_list = NULL_TREE;
7149
7150 /* Then check the methods of all parsed classes */
7151 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
7152 if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7153 CHECK_METHODS (TREE_VALUE (current));
7154 java_parse_abort_on_error ();
7155
7156 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
7157 {
7158 current_class = TREE_TYPE (TREE_VALUE (current));
7159 layout_class (current_class);
5e942c50 7160
c877974e
APB		 7161 /* From now on, the class is considered completely loaded */
7162 CLASS_LOADED_P (current_class) = 1;
7163
5e942c50
APB		 7164 /* Error reported by the caller */
7165 if (java_error_count)
7166 return;
e04a16fb 7167 }
23a79c61
APB		 7168
7169 /* We might have reloaded classes durign the process of laying out
7170 classes for code generation. We must layout the methods of those
7171 late additions, as constructor checks might use them */
1886c9d8 7172 java_layout_seen_class_methods ();
23a79c61 7173 java_parse_abort_on_error ();
e04a16fb
AG		 7174}
7175
c2952b01
APB		 7176/* Expand methods in the current set of classes rememebered for
7177 generation. */
e04a16fb 7178
49f48c71 7179static void
c2952b01 7180java_complete_expand_classes ()
e04a16fb
AG		 7181{
7182 tree current;
ce6e9147
APB		 7183
7184 do_not_fold = flag_emit_xref;
c2952b01 7185
e04a16fb 7186 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
c2952b01
APB		 7187 if (!INNER_CLASS_DECL_P (current))
7188 java_complete_expand_class (current);
7189}
e04a16fb 7190
c2952b01
APB		 7191/* Expand the methods found in OUTER, starting first by OUTER's inner
7192 classes, if any. */
e04a16fb 7193
c2952b01
APB		 7194static void
7195java_complete_expand_class (outer)
7196 tree outer;
7197{
7198 tree inner_list;
e04a16fb 7199
c2952b01 7200 set_nested_class_simple_name_value (outer, 1); /* Set */
cd9643f7 7201
c2952b01
APB		 7202 /* We need to go after all inner classes and start expanding them,
7203 starting with most nested ones. We have to do that because nested
7204 classes might add functions to outer classes */
e04a16fb 7205
c2952b01
APB		 7206 for (inner_list = DECL_INNER_CLASS_LIST (outer);
7207 inner_list; inner_list = TREE_CHAIN (inner_list))
7208 java_complete_expand_class (TREE_PURPOSE (inner_list));
22eed1e6 7209
c2952b01
APB		 7210 java_complete_expand_methods (outer);
7211 set_nested_class_simple_name_value (outer, 0); /* Reset */
7212}
7213
7214/* Expand methods registered in CLASS_DECL. The general idea is that
7215 we expand regular methods first. This allows us get an estimate on
7216 how outer context local alias fields are really used so we can add
7217 to the constructor just enough code to initialize them properly (it
7218 also lets us generate $finit$ correctly.) Then we expand the
7219 constructors and then <clinit>. */
7220
7221static void
7222java_complete_expand_methods (class_decl)
7223 tree class_decl;
7224{
7225 tree clinit, finit, decl, first_decl;
7226
7227 current_class = TREE_TYPE (class_decl);
7228
7229 /* Initialize a new constant pool */
7230 init_outgoing_cpool ();
7231
7232 /* Pre-expand <clinit> to figure whether we really need it or
7233 not. If we do need it, we pre-expand the static fields so they're
7234 ready to be used somewhere else. <clinit> will be fully expanded
7235 after we processed the constructors. */
7236 first_decl = TYPE_METHODS (current_class);
7237 clinit = maybe_generate_pre_expand_clinit (current_class);
7238
7239 /* Then generate $finit$ (if we need to) because constructor will
7240 try to use it.*/
7241 if (TYPE_FINIT_STMT_LIST (current_class))
7242 {
7243 finit = generate_finit (current_class);
7244 java_complete_expand_method (finit);
7245 }
7246
7247 /* Now do the constructors */
7248 for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7249 {
7250 int no_body;
7251
7252 if (!DECL_CONSTRUCTOR_P (decl))
7253 continue;
7254
7255 no_body = !DECL_FUNCTION_BODY (decl);
7256 /* Don't generate debug info on line zero when expanding a
7257 generated constructor. */
7258 if (no_body)
7259 restore_line_number_status (1);
7260
7261 java_complete_expand_method (decl);
7262
7263 if (no_body)
7264 restore_line_number_status (0);
7265 }
7266
7267 /* First, do the ordinary methods. */
7268 for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7269 {
7270 /* Skip abstract or native methods */
7271 if (METHOD_ABSTRACT (decl) || METHOD_NATIVE (decl)
7272 || DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7273 continue;
7274 java_complete_expand_method (decl);
7275 }
7276
7277 /* If there is indeed a <clinit>, fully expand it now */
7278 if (clinit)
7279 {
7280 /* Prevent the use of `this' inside <clinit> */
7281 ctxp->explicit_constructor_p = 1;
7282 java_complete_expand_method (clinit);
7283 ctxp->explicit_constructor_p = 0;
e04a16fb 7284 }
c2952b01 7285
165f37bc
APB		 7286 /* We might have generated a class$ that we now want to expand */
7287 if (TYPE_DOT_CLASS (current_class))
7288 java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7289
c2952b01
APB		 7290 /* Now verify constructor circularity (stop after the first one we
7291 prove wrong.) */
7292 if (!CLASS_INTERFACE (class_decl))
7293 for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7294 if (DECL_CONSTRUCTOR_P (decl)
7295 && verify_constructor_circularity (decl, decl))
7296 break;
7297
7298 /* Save the constant pool. We'll need to restore it later. */
7299 TYPE_CPOOL (current_class) = outgoing_cpool;
e04a16fb
AG		 7300}
7301
b9f7e36c
APB		 7302/* Hold a list of catch clauses list. The first element of this list is
7303 the list of the catch clauses of the currently analysed try block. */
7304static tree currently_caught_type_list;
7305
c2952b01
APB		 7306/* Attempt to create <clinit>. Pre-expand static fields so they can be
7307 safely used in some other methods/constructors. */
e920ebc9 7308
c2952b01
APB		 7309static tree
7310maybe_generate_pre_expand_clinit (class_type)
7311 tree class_type;
e920ebc9 7312{
c2952b01
APB		 7313 tree current, mdecl;
7314
7315 if (!TYPE_CLINIT_STMT_LIST (class_type))
7316 return NULL_TREE;
e920ebc9 7317
c2952b01
APB		 7318 /* Go through all static fields and pre expand them */
7319 for (current = TYPE_FIELDS (class_type); current;
7320 current = TREE_CHAIN (current))
7321 if (FIELD_STATIC (current))
7322 build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7323
7324 /* Then build the <clinit> method */
7325 mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7326 clinit_identifier_node, end_params_node);
7327 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7328 mdecl, NULL_TREE);
7329 start_artificial_method_body (mdecl);
7330
7331 /* We process the list of assignment we produced as the result of
7332 the declaration of initialized static field and add them as
7333 statement to the <clinit> method. */
7334 for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7335 current = TREE_CHAIN (current))
e920ebc9 7336 {
c2952b01
APB		 7337 /* We build the assignment expression that will initialize the
7338 field to its value. There are strict rules on static
7339 initializers (8.5). FIXME */
7340 tree stmt = build_debugable_stmt (EXPR_WFL_LINECOL (current), current);
7341 java_method_add_stmt (mdecl, stmt);
7342 }
e920ebc9 7343
c2952b01
APB		 7344 end_artificial_method_body (mdecl);
7345
7346 /* Now we want to place <clinit> as the last method for interface so
7347 that it doesn't interfere with the dispatch table based
7348 lookup. */
7349 if (CLASS_INTERFACE (TYPE_NAME (class_type))
7350 && TREE_CHAIN (TYPE_METHODS (class_type)))
7351 {
7352 tree current =
7353 TYPE_METHODS (class_type) = TREE_CHAIN (TYPE_METHODS (class_type));
7354
7355 while (TREE_CHAIN (current))
7356 current = TREE_CHAIN (current);
7357 TREE_CHAIN (current) = mdecl;
7358 TREE_CHAIN (mdecl) = NULL_TREE;
e920ebc9 7359 }
c2952b01
APB		 7360
7361 return mdecl;
e920ebc9
APB		 7362}
7363
e04a16fb
AG		 7364/* Complete and expand a method. */
7365
7366static void
7367java_complete_expand_method (mdecl)
7368 tree mdecl;
7369{
c2952b01 7370 current_function_decl = mdecl;
22eed1e6
APB		 7371 /* Fix constructors before expanding them */
7372 if (DECL_CONSTRUCTOR_P (mdecl))
7373 fix_constructors (mdecl);
e04a16fb 7374
22eed1e6 7375 /* Expand functions that have a body */
e04a16fb
AG		 7376 if (DECL_FUNCTION_BODY (mdecl))
7377 {
9bbc7d9f
PB		 7378 tree fbody = DECL_FUNCTION_BODY (mdecl);
7379 tree block_body = BLOCK_EXPR_BODY (fbody);
cd531a2e 7380 tree exception_copy = NULL_TREE;
e04a16fb 7381 expand_start_java_method (mdecl);
939d7216 7382 build_result_decl (mdecl);
e04a16fb
AG		 7383
7384 current_this
7385 = (!METHOD_STATIC (mdecl) ?
7386 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
7387
ce6e9147
APB		 7388 /* Purge the `throws' list of unchecked exceptions. If we're
7389 doing xref, save a copy of the list and re-install it
7390 later. */
7391 if (flag_emit_xref)
7392 exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
7393
b9f7e36c
APB		 7394 purge_unchecked_exceptions (mdecl);
7395
7396 /* Install exceptions thrown with `throws' */
7397 PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
7398
9bbc7d9f 7399 if (block_body != NULL_TREE)
bc3ca41b
PB		 7400 {
7401 block_body = java_complete_tree (block_body);
c2952b01 7402
ce6e9147
APB		 7403 if (!flag_emit_xref)
7404 check_for_initialization (block_body);
f099f336 7405 ctxp->explicit_constructor_p = 0;
bc3ca41b 7406 }
9bbc7d9f 7407 BLOCK_EXPR_BODY (fbody) = block_body;
5e942c50 7408
c2952b01
APB		 7409 /* If we saw a return but couldn't evaluate it properly, we'll
7410 have an error_mark_node here. */
7411 if (block_body != error_mark_node
7412 && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
ce6e9147
APB		 7413 && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
7414 && !flag_emit_xref)
82371d41 7415 missing_return_error (current_function_decl);
7525cc04 7416
939d7216
PB		 7417 complete_start_java_method (mdecl);
7418
e04a16fb
AG		 7419 /* Don't go any further if we've found error(s) during the
7420 expansion */
7421 if (!java_error_count)
7422 source_end_java_method ();
22eed1e6
APB		 7423 else
7424 {
7425 pushdecl_force_head (DECL_ARGUMENTS (mdecl));
7426 poplevel (1, 0, 1);
7427 }
b9f7e36c
APB		 7428
7429 /* Pop the exceptions and sanity check */
7430 POP_EXCEPTIONS();
7431 if (currently_caught_type_list)
7432 fatal ("Exception list non empty - java_complete_expand_method");
ce6e9147
APB		 7433
7434 if (flag_emit_xref)
7435 DECL_FUNCTION_THROWS (mdecl) = exception_copy;
e04a16fb
AG		 7436 }
7437}
7438
c2952b01
APB		 7439\f
7440
7441/* This section of the code deals with accessing enclosing context
7442 fields either directly by using the relevant access to this$<n> or
7443 by invoking an access method crafted for that purpose. */
7444
7445/* Build the necessary access from an inner class to an outer
7446 class. This routine could be optimized to cache previous result
7447 (decl, current_class and returned access). When an access method
7448 needs to be generated, it always takes the form of a read. It might
7449 be later turned into a write by calling outer_field_access_fix. */
7450
7451static tree
7452build_outer_field_access (id, decl)
7453 tree id, decl;
7454{
7455 tree access = NULL_TREE;
7456 tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
7457
7458 /* If decl's class is the direct outer class of the current_class,
7459 build the access as `this$<n>.<field>'. Not that we will break
7460 the `private' barrier if we're not emitting bytecodes. */
7461 if (ctx == DECL_CONTEXT (decl)
7462 && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
7463 {
7464 tree thisn = build_current_thisn (current_class);
7465 access = make_qualified_primary (build_wfl_node (thisn),
7466 id, EXPR_WFL_LINECOL (id));
7467 }
7468 /* Otherwise, generate access methods to outer this and access the
7469 field (either using an access method or by direct access.) */
7470 else
7471 {
7472 int lc = EXPR_WFL_LINECOL (id);
7473
7474 /* Now we chain the required number of calls to the access$0 to
7475 get a hold to the enclosing instance we need, and the we
7476 build the field access. */
7477 access = build_access_to_thisn (ctx, DECL_CONTEXT (decl), lc);
7478
7479 /* If the field is private and we're generating bytecode, then
7480 we generate an access method */
7481 if (FIELD_PRIVATE (decl) && flag_emit_class_files )
7482 {
7483 tree name = build_outer_field_access_methods (decl);
7484 access = build_outer_field_access_expr (lc, DECL_CONTEXT (decl),
7485 name, access, NULL_TREE);
7486 }
7487 /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
7488 Once again we break the `private' access rule from a foreign
7489 class. */
7490 else
7491 access = make_qualified_primary (access, id, lc);
7492 }
7493 return resolve_expression_name (access, NULL);
7494}
7495
7496/* Return a non zero value if NODE describes an outer field inner
7497 access. */
7498
7499static int
7500outer_field_access_p (type, decl)
7501 tree type, decl;
7502{
7503 if (!INNER_CLASS_TYPE_P (type)
7504 || TREE_CODE (decl) != FIELD_DECL
7505 || DECL_CONTEXT (decl) == type)
7506 return 0;
7507
7508 for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
7509 type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
7510 {
7511 if (type == DECL_CONTEXT (decl))
7512 return 1;
7513 if (!DECL_CONTEXT (TYPE_NAME (type)))
7514 break;
7515 }
7516
7517 return 0;
7518}
7519
7520/* Return a non zero value if NODE represents an outer field inner
7521 access that was been already expanded. As a side effect, it returns
7522 the name of the field being accessed and the argument passed to the
7523 access function, suitable for a regeneration of the access method
7524 call if necessary. */
7525
7526static int
7527outer_field_expanded_access_p (node, name, arg_type, arg)
7528 tree node, *name, *arg_type, *arg;
7529{
7530 int identified = 0;
7531
7532 if (TREE_CODE (node) != CALL_EXPR)
7533 return 0;
7534
7535 /* Well, gcj generates slightly different tree nodes when compiling
7536 to native or bytecodes. It's the case for function calls. */
7537
7538 if (flag_emit_class_files
7539 && TREE_CODE (node) == CALL_EXPR
7540 && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
7541 identified = 1;
7542 else if (!flag_emit_class_files)
7543 {
7544 node = TREE_OPERAND (node, 0);
7545
7546 if (node && TREE_OPERAND (node, 0)
7547 && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
7548 {
7549 node = TREE_OPERAND (node, 0);
7550 if (TREE_OPERAND (node, 0)
7551 && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
7552 && (OUTER_FIELD_ACCESS_IDENTIFIER_P
7553 (DECL_NAME (TREE_OPERAND (node, 0)))))
7554 identified = 1;
7555 }
7556 }
7557
7558 if (identified && name && arg_type && arg)
7559 {
7560 tree argument = TREE_OPERAND (node, 1);
7561 *name = DECL_NAME (TREE_OPERAND (node, 0));
7562 *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
7563 *arg = TREE_VALUE (argument);
7564 }
7565 return identified;
7566}
7567
7568/* Detect in NODE an outer field read access from an inner class and
7569 transform it into a write with RHS as an argument. This function is
7570 called from the java_complete_lhs when an assignment to a LHS can
7571 be identified. */
7572
7573static tree
7574outer_field_access_fix (wfl, node, rhs)
7575 tree wfl, node, rhs;
7576{
7577 tree name, arg_type, arg;
7578
7579 if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
7580 {
7581 /* At any rate, check whether we're trying to assign a value to
7582 a final. */
7583 tree accessed = (JDECL_P (node) ? node :
7584 (TREE_CODE (node) == COMPONENT_REF ?
7585 TREE_OPERAND (node, 1) : node));
7586 if (check_final_assignment (accessed, wfl))
7587 return error_mark_node;
7588
7589 node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
7590 arg_type, name, arg, rhs);
7591 return java_complete_tree (node);
7592 }
7593 return NULL_TREE;
7594}
7595
7596/* Construct the expression that calls an access method:
7597 <type>.access$<n>(<arg1> [, <arg2>]);
7598
7599 ARG2 can be NULL and will be omitted in that case. It will denote a
7600 read access. */
7601
7602static tree
7603build_outer_field_access_expr (lc, type, access_method_name, arg1, arg2)
7604 int lc;
7605 tree type, access_method_name, arg1, arg2;
7606{
7607 tree args, cn, access;
7608
7609 args = arg1 ? arg1 :
7610 build_wfl_node (build_current_thisn (current_class));
7611 args = build_tree_list (NULL_TREE, args);
7612
7613 if (arg2)
7614 args = tree_cons (NULL_TREE, arg2, args);
7615
7616 access = build_method_invocation (build_wfl_node (access_method_name), args);
7617 cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
7618 return make_qualified_primary (cn, access, lc);
7619}
7620
7621static tree
7622build_new_access_id ()
7623{
7624 static int access_n_counter = 1;
7625 char buffer [128];
7626
7627 sprintf (buffer, "access$%d", access_n_counter++);
7628 return get_identifier (buffer);
7629}
7630
7631/* Create the static access functions for the outer field DECL. We define a
7632 read:
7633 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
7634 return inst$.field;
7635 }
7636 and a write access:
7637 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
7638 TREE_TYPE (<field>) value$) {
7639 return inst$.field = value$;
7640 }
7641 We should have a usage flags on the DECL so we can lazily turn the ones
7642 we're using for code generation. FIXME.
7643*/
7644
7645static tree
7646build_outer_field_access_methods (decl)
7647 tree decl;
7648{
7649 tree id, args, stmt, mdecl;
7650
7651 /* Check point, to be removed. FIXME */
7652 if (FIELD_INNER_ACCESS (decl)
7653 && TREE_CODE (FIELD_INNER_ACCESS (decl)) != IDENTIFIER_NODE)
7654 abort ();
7655
7656 if (FIELD_INNER_ACCESS (decl))
7657 return FIELD_INNER_ACCESS (decl);
7658
7659 push_obstacks (&permanent_obstack, &permanent_obstack);
7660
7661 /* Create the identifier and a function named after it. */
7662 id = build_new_access_id ();
7663
7664 /* The identifier is marked as bearing the name of a generated write
7665 access function for outer field accessed from inner classes. */
7666 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
7667
7668 /* Create the read access */
7669 args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
7670 TREE_CHAIN (args) = end_params_node;
7671 stmt = make_qualified_primary (build_wfl_node (inst_id),
7672 build_wfl_node (DECL_NAME (decl)), 0);
7673 stmt = build_return (0, stmt);
7674 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
7675 TREE_TYPE (decl), id, args, stmt);
7676 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
7677
7678 /* Create the write access method */
7679 args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
7680 TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
7681 TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
7682 stmt = make_qualified_primary (build_wfl_node (inst_id),
7683 build_wfl_node (DECL_NAME (decl)), 0);
7684 stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
7685 build_wfl_node (wpv_id)));
7686
7687 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
7688 TREE_TYPE (decl), id, args, stmt);
7689 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
7690 pop_obstacks ();
7691
7692 /* Return the access name */
7693 return FIELD_INNER_ACCESS (decl) = id;
7694}
7695
7696/* Build an field access method NAME. */
7697
7698static tree
7699build_outer_field_access_method (class, type, name, args, body)
7700 tree class, type, name, args, body;
7701{
7702 tree saved_current_function_decl, mdecl;
7703
7704 /* Create the method */
7705 mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
7706 fix_method_argument_names (args, mdecl);
7707 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
7708
7709 /* Attach the method body. */
7710 saved_current_function_decl = current_function_decl;
7711 start_artificial_method_body (mdecl);
7712 java_method_add_stmt (mdecl, body);
7713 end_artificial_method_body (mdecl);
7714 current_function_decl = saved_current_function_decl;
7715
7716 return mdecl;
7717}
7718
7719\f
7720/* This section deals with building access function necessary for
7721 certain kinds of method invocation from inner classes. */
7722
7723static tree
7724build_outer_method_access_method (decl)
7725 tree decl;
7726{
7727 tree saved_current_function_decl, mdecl;
7728 tree args = NULL_TREE, call_args = NULL_TREE;
7729 tree carg, id, body, class;
7730 char buffer [80];
7731 int parm_id_count = 0;
7732
7733 /* Test this abort with an access to a private field */
7734 if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
7735 abort ();
7736
7737 /* Check the cache first */
7738 if (DECL_FUNCTION_INNER_ACCESS (decl))
7739 return DECL_FUNCTION_INNER_ACCESS (decl);
7740
7741 class = DECL_CONTEXT (decl);
7742
7743 /* Obtain an access identifier and mark it */
7744 id = build_new_access_id ();
7745 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
7746
7747 push_obstacks (&permanent_obstack, &permanent_obstack);
7748
7749 carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
7750 /* Create the arguments, as much as the original */
7751 for (; carg && carg != end_params_node;
7752 carg = TREE_CHAIN (carg))
7753 {
7754 sprintf (buffer, "write_parm_value$%d", parm_id_count++);
7755 args = chainon (args, build_tree_list (get_identifier (buffer),
7756 TREE_VALUE (carg)));
7757 }
7758 args = chainon (args, end_params_node);
7759
7760 /* Create the method */
7761 mdecl = create_artificial_method (class, ACC_STATIC,
7762 TREE_TYPE (TREE_TYPE (decl)), id, args);
7763 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
7764 /* There is a potential bug here. We should be able to use
7765 fix_method_argument_names, but then arg names get mixed up and
7766 eventually a constructor will have its this$0 altered and the
7767 outer context won't be assignment properly. The test case is
7768 stub.java FIXME */
7769 TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
7770
7771 /* Attach the method body. */
7772 saved_current_function_decl = current_function_decl;
7773 start_artificial_method_body (mdecl);
7774
7775 /* The actual method invocation uses the same args. When invoking a
7776 static methods that way, we don't want to skip the first
7777 argument. */
7778 carg = args;
7779 if (!METHOD_STATIC (decl))
7780 carg = TREE_CHAIN (carg);
7781 for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
7782 call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
7783 call_args);
7784
7785 body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
7786 call_args);
7787 if (!METHOD_STATIC (decl))
7788 body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
7789 body, 0);
7790 if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
7791 body = build_return (0, body);
7792 java_method_add_stmt (mdecl,body);
7793 end_artificial_method_body (mdecl);
7794 current_function_decl = saved_current_function_decl;
7795 pop_obstacks ();
7796
7797 /* Back tag the access function so it know what it accesses */
7798 DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
7799
7800 /* Tag the current method so it knows it has an access generated */
7801 return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
7802}
7803
7804\f
7805/* This section of the code deals with building expressions to access
7806 the enclosing instance of an inner class. The enclosing instance is
7807 kept in a generated field called this$<n>, with <n> being the
7808 inner class nesting level (starting from 0.) */
7809
7810/* Build an access to a given this$<n>, possibly by chaining access
7811 call to others. Access methods to this$<n> are build on the fly if
7812 necessary */
7813
7814static tree
7815build_access_to_thisn (from, to, lc)
7816 tree from, to;
7817 int lc;
7818{
7819 tree access = NULL_TREE;
7820
7821 while (from != to)
7822 {
7823 tree access0_wfl, cn;
7824
7825 maybe_build_thisn_access_method (from);
7826 access0_wfl = build_wfl_node (access0_identifier_node);
7827 cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
7828 EXPR_WFL_LINECOL (access0_wfl) = lc;
7829
7830 if (!access)
7831 {
7832 access = build_current_thisn (current_class);
7833 access = build_wfl_node (access);
7834 }
7835 access = build_tree_list (NULL_TREE, access);
7836 access = build_method_invocation (access0_wfl, access);
7837 access = make_qualified_primary (cn, access, lc);
7838
7839 from = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (from)));
7840 }
7841 return access;
7842}
7843
7844/* Build an access function to the this$<n> local to TYPE. NULL_TREE
7845 is returned if nothing needs to be generated. Otherwise, the method
7846 generated, fully walked and a method decl is returned.
7847
7848 NOTE: These generated methods should be declared in a class file
7849 attribute so that they can't be referred to directly. */
7850
7851static tree
7852maybe_build_thisn_access_method (type)
7853 tree type;
7854{
7855 tree mdecl, args, stmt, rtype;
7856 tree saved_current_function_decl;
7857
7858 /* If TYPE is a top-level class, no access method is required.
7859 If there already is such an access method, bail out. */
7860 if (CLASS_ACCESS0_GENERATED_P (type) || !INNER_CLASS_TYPE_P (type))
7861 return NULL_TREE;
7862
7863 /* We generate the method. The method looks like:
7864 static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
7865 */
7866 push_obstacks (&permanent_obstack, &permanent_obstack);
7867 args = build_tree_list (inst_id, build_pointer_type (type));
7868 TREE_CHAIN (args) = end_params_node;
7869 rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
7870 mdecl = create_artificial_method (type, ACC_STATIC, rtype,
7871 access0_identifier_node, args);
7872 fix_method_argument_names (args, mdecl);
7873 layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
7874 stmt = build_current_thisn (type);
7875 stmt = make_qualified_primary (build_wfl_node (inst_id),
7876 build_wfl_node (stmt), 0);
7877 stmt = build_return (0, stmt);
7878
7879 saved_current_function_decl = current_function_decl;
7880 start_artificial_method_body (mdecl);
7881 java_method_add_stmt (mdecl, stmt);
7882 end_artificial_method_body (mdecl);
7883 current_function_decl = saved_current_function_decl;
7884 pop_obstacks ();
7885
7886 CLASS_ACCESS0_GENERATED_P (type) = 1;
7887
7888 return mdecl;
7889}
7890
7891/* Craft an correctly numbered `this$<n>'string. this$0 is used for
7892 the first level of innerclassing. this$1 for the next one, etc...
7893 This function can be invoked with TYPE to NULL, available and then
7894 has to count the parser context. */
7895
7896static tree
7897build_current_thisn (type)
7898 tree type;
7899{
7900 static int saved_i = -1;
7901 static tree saved_thisn = NULL_TREE;
7902
7903 tree decl;
7904 char buffer [80];
7905 int i = 0;
7906
7907 if (type)
7908 {
7909 static tree saved_type = NULL_TREE;
7910 static int saved_type_i = 0;
7911
7912 if (type == saved_type)
7913 i = saved_type_i;
7914 else
7915 {
7916 for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
7917 decl; decl = DECL_CONTEXT (decl), i++)
7918 ;
7919
7920 saved_type = type;
7921 saved_type_i = i;
7922 }
7923 }
7924 else
7925 i = list_length (GET_CPC_LIST ())-2;
7926
7927 if (i == saved_i)
7928 return saved_thisn;
7929
7930 sprintf (buffer, "this$%d", i);
7931 saved_i = i;
7932 saved_thisn = get_identifier (buffer);
7933 return saved_thisn;
7934}
7935
7936/* Return the assignement to the hidden enclosing context `this$<n>'
7937 by the second incoming parameter to the innerclass constructor. The
7938 form used is `this.this$<n> = this$<n>;'. */
7939
7940static tree
7941build_thisn_assign ()
7942{
7943 if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
7944 {
7945 tree thisn = build_current_thisn (current_class);
7946 tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
7947 build_wfl_node (thisn), 0);
7948 tree rhs = build_wfl_node (thisn);
7949 EXPR_WFL_SET_LINECOL (lhs, lineno, 0);
7950 return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
7951 }
7952 return NULL_TREE;
7953}
7954
7955\f
165f37bc
APB		 7956/* Building the synthetic `class$' used to implement the `.class' 1.1
7957 extension for non primitive types. This method looks like:
7958
7959 static Class class$(String type) throws NoClassDefFoundError
7960 {
7961 try {return (java.lang.Class.forName (String));}
7962 catch (ClassNotFoundException e) {
7963 throw new NoClassDefFoundError(e.getMessage());}
7964 } */
7965
7966static tree
7967build_dot_class_method (class)
7968 tree class;
7969{
7970#define BWF(S) build_wfl_node (get_identifier ((S)))
7971#define MQN(X,Y) make_qualified_name ((X), (Y), 0)
7972 tree args, tmp, saved_current_function_decl, mdecl;
7973 tree stmt, throw_stmt, catch, catch_block, try_block;
7974 tree catch_clause_param;
7975 tree class_not_found_exception, no_class_def_found_error;
7976
7977 static tree get_message_wfl, type_parm_wfl;
7978
7979 if (!get_message_wfl)
7980 {
7981 get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
7982 type_parm_wfl = build_wfl_node (get_identifier ("type$"));
7983 }
7984
7985 /* Build the arguments */
7986 args = build_tree_list (get_identifier ("type$"),
7987 build_pointer_type (string_type_node));
7988 TREE_CHAIN (args) = end_params_node;
7989
7990 /* Build the qualified name java.lang.Class.forName */
7991 tmp = MQN (MQN (MQN (BWF ("java"),
7992 BWF ("lang")), BWF ("Class")), BWF ("forName"));
7993
7994 /* For things we have to catch and throw */
7995 class_not_found_exception =
7996 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
7997 no_class_def_found_error =
7998 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
7999 load_class (class_not_found_exception, 1);
8000 load_class (no_class_def_found_error, 1);
8001
8002 /* Create the "class$" function */
8003 mdecl = create_artificial_method (class, ACC_STATIC,
8004 build_pointer_type (class_type_node),
8005 get_identifier ("class$"), args);
8006 DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
8007 no_class_def_found_error);
8008
8009 /* We start by building the try block. We need to build:
8010 return (java.lang.Class.forName (type)); */
8011 stmt = build_method_invocation (tmp,
8012 build_tree_list (NULL_TREE, type_parm_wfl));
8013 stmt = build_return (0, stmt);
8014 /* Put it in a block. That's the try block */
8015 try_block = build_expr_block (stmt, NULL_TREE);
8016
8017 /* Now onto the catch block. We start by building the expression
8018 throwing a new exception:
8019 throw new NoClassDefFoundError (_.getMessage); */
8020 throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8021 get_message_wfl, 0);
8022 throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8023
8024 /* Build new NoClassDefFoundError (_.getMessage) */
8025 throw_stmt = build_new_invocation
8026 (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8027 build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8028
8029 /* Build the throw, (it's too early to use BUILD_THROW) */
8030 throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8031
8032 /* Build the catch block to encapsulate all this. We begin by
8033 building an decl for the catch clause parameter and link it to
8034 newly created block, the catch block. */
8035 catch_clause_param =
8036 build_decl (VAR_DECL, wpv_id,
8037 build_pointer_type (class_not_found_exception));
8038 catch_block = build_expr_block (NULL_TREE, catch_clause_param);
8039
8040 /* We initialize the variable with the exception handler. */
8041 catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
8042 soft_exceptioninfo_call_node);
8043 add_stmt_to_block (catch_block, NULL_TREE, catch);
8044
8045 /* We add the statement throwing the new exception */
8046 add_stmt_to_block (catch_block, NULL_TREE, throw_stmt);
8047
8048 /* Build a catch expression for all this */
8049 catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
8050
8051 /* Build the try/catch sequence */
8052 stmt = build_try_statement (0, try_block, catch_block);
8053
8054 fix_method_argument_names (args, mdecl);
8055 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8056 saved_current_function_decl = current_function_decl;
8057 start_artificial_method_body (mdecl);
8058 java_method_add_stmt (mdecl, stmt);
8059 end_artificial_method_body (mdecl);
8060 current_function_decl = saved_current_function_decl;
8061 TYPE_DOT_CLASS (class) = mdecl;
8062
8063 return mdecl;
8064}
8065
8066static tree
8067build_dot_class_method_invocation (name)
8068 tree name;
8069{
8070 tree s = make_node (STRING_CST);
8071 TREE_STRING_LENGTH (s) = IDENTIFIER_LENGTH (name);
8072 TREE_STRING_POINTER (s) = obstack_alloc (expression_obstack,
8073 TREE_STRING_LENGTH (s)+1);
8074 strcpy (TREE_STRING_POINTER (s), IDENTIFIER_POINTER (name));
8075 return build_method_invocation (build_wfl_node (get_identifier ("class$")),
8076 build_tree_list (NULL_TREE, s));
8077}
8078
c2952b01
APB		 8079/* This section of the code deals with constructor. */
8080
22eed1e6
APB		 8081/* Craft a body for default constructor. Patch existing constructor
8082 bodies with call to super() and field initialization statements if
8083 necessary. */
8084
8085static void
8086fix_constructors (mdecl)
8087 tree mdecl;
8088{
8089 tree body = DECL_FUNCTION_BODY (mdecl);
c2952b01
APB		 8090 tree thisn_assign, compound = NULL_TREE;
8091 tree class_type = DECL_CONTEXT (mdecl);
22eed1e6 8092
22eed1e6
APB		 8093 if (!body)
8094 {
22eed1e6
APB		 8095 /* It is an error for the compiler to generate a default
8096 constructor if the superclass doesn't have a constructor that
c2952b01
APB		 8097 takes no argument, or the same args for an anonymous class */
8098 if (verify_constructor_super (mdecl))
22eed1e6 8099 {
c2952b01
APB		 8100 tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8101 tree save = DECL_NAME (mdecl);
49f48c71 8102 const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
c2952b01 8103 DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
781b0558 8104 parse_error_context
c2952b01
APB		 8105 (lookup_cl (TYPE_NAME (class_type)),
8106 "No constructor matching `%s' found in class `%s'",
8107 lang_printable_name (mdecl, 0), n);
8108 DECL_NAME (mdecl) = save;
22eed1e6
APB		 8109 }
8110
c2952b01
APB		 8111 /* The constructor body must be crafted by hand. It's the
8112 constructor we defined when we realize we didn't have the
8113 CLASSNAME() constructor */
22eed1e6
APB		 8114 start_artificial_method_body (mdecl);
8115
8116 /* We don't generate a super constructor invocation if we're
8117 compiling java.lang.Object. build_super_invocation takes care
8118 of that. */
e920ebc9 8119 compound = java_method_add_stmt (mdecl, build_super_invocation (mdecl));
22eed1e6 8120
c2952b01
APB		 8121 /* Insert the instance initializer block right here, after the
8122 super invocation. */
8123 add_instance_initializer (mdecl);
8124
8125 /* Insert an assignment to the this$<n> hidden field, if
8126 necessary */
8127 if ((thisn_assign = build_thisn_assign ()))
8128 java_method_add_stmt (mdecl, thisn_assign);
8129
22eed1e6
APB		 8130 end_artificial_method_body (mdecl);
8131 }
8132 /* Search for an explicit constructor invocation */
8133 else
8134 {
8135 int found = 0;
8136 tree main_block = BLOCK_EXPR_BODY (body);
22eed1e6
APB		 8137
8138 while (body)
8139 switch (TREE_CODE (body))
8140 {
8141 case CALL_EXPR:
8142 found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8143 body = NULL_TREE;
8144 break;
8145 case COMPOUND_EXPR:
8146 case EXPR_WITH_FILE_LOCATION:
8147 body = TREE_OPERAND (body, 0);
8148 break;
8149 case BLOCK:
8150 body = BLOCK_EXPR_BODY (body);
8151 break;
8152 default:
8153 found = 0;
8154 body = NULL_TREE;
8155 }
8156 /* The constructor is missing an invocation of super() */
8157 if (!found)
8158 compound = add_stmt_to_compound (compound, NULL_TREE,
c2952b01 8159 build_super_invocation (mdecl));
22eed1e6 8160
c2952b01
APB		 8161 /* Insert the instance initializer block right here, after the
8162 super invocation. */
8163 add_instance_initializer (mdecl);
8164
8165 /* Generate the assignment to this$<n>, if necessary */
8166 if ((thisn_assign = build_thisn_assign ()))
8167 compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8168
22eed1e6
APB		 8169 /* Fix the constructor main block if we're adding extra stmts */
8170 if (compound)
8171 {
8172 compound = add_stmt_to_compound (compound, NULL_TREE,
8173 BLOCK_EXPR_BODY (main_block));
8174 BLOCK_EXPR_BODY (main_block) = compound;
8175 }
8176 }
8177}
8178
8179/* Browse constructors in the super class, searching for a constructor
8180 that doesn't take any argument. Return 0 if one is found, 1
c2952b01
APB		 8181 otherwise. If the current class is an anonymous inner class, look
8182 for something that has the same signature. */
22eed1e6
APB		 8183
8184static int
c2952b01
APB		 8185verify_constructor_super (mdecl)
8186 tree mdecl;
22eed1e6
APB		 8187{
8188 tree class = CLASSTYPE_SUPER (current_class);
c2952b01
APB		 8189 tree sdecl;
8190
22eed1e6
APB		 8191 if (!class)
8192 return 0;
8193
c2952b01 8194 if (ANONYMOUS_CLASS_P (current_class))
22eed1e6 8195 {
c2952b01
APB		 8196 tree mdecl_arg_type;
8197 SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8198 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8199 if (DECL_CONSTRUCTOR_P (sdecl))
8200 {
8201 tree arg_type;
8202 for (arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8203 arg_type != end_params_node &&
8204 mdecl_arg_type != end_params_node;
8205 arg_type = TREE_CHAIN (arg_type),
8206 mdecl_arg_type = TREE_CHAIN (mdecl_arg_type))
8207 if (TREE_VALUE (arg_type) != TREE_VALUE (mdecl_arg_type))
8208 break;
8209
8210 if (arg_type == end_params_node &&
8211 mdecl_arg_type == end_params_node)
8212 return 0;
8213 }
8214 }
8215 else
8216 {
8217 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
22eed1e6 8218 {
c2952b01
APB		 8219 if (DECL_CONSTRUCTOR_P (sdecl)
8220 && TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)))
d77613be 8221 == end_params_node)
22eed1e6
APB		 8222 return 0;
8223 }
8224 }
8225 return 1;
8226}
8227
22eed1e6 8228/* Generate code for all context remembered for code generation. */
b351b287
APB		 8229
8230void
8231java_expand_classes ()
8232{
5423609c 8233 int save_error_count = 0;
c2952b01
APB		 8234 static struct parser_ctxt *saved_ctxp = NULL;
8235
23a79c61
APB		 8236 java_parse_abort_on_error ();
8237 if (!(ctxp = ctxp_for_generation))
5e942c50
APB		 8238 return;
8239 java_layout_classes ();
8240 java_parse_abort_on_error ();
8241
c2952b01 8242 saved_ctxp = ctxp_for_generation;
b351b287
APB		 8243 for (; ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8244 {
8245 ctxp = ctxp_for_generation;
8246 lang_init_source (2); /* Error msgs have method prototypes */
c2952b01 8247 java_complete_expand_classes (); /* Complete and expand classes */
b351b287
APB		 8248 java_parse_abort_on_error ();
8249 }
c2952b01
APB		 8250
8251 /* Find anonymous classes and expand their constructor, now they
8252 have been fixed. */
8253 for (ctxp_for_generation = saved_ctxp;
8254 ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8255 {
8256 tree current;
8257 ctxp = ctxp_for_generation;
8258 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8259 {
8260 current_class = TREE_TYPE (current);
8261 if (ANONYMOUS_CLASS_P (current_class))
8262 {
8263 tree d;
8264 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
8265 {
8266 if (DECL_CONSTRUCTOR_P (d))
8267 {
8268 restore_line_number_status (1);
8269 reset_method_name (d);
8270 java_complete_expand_method (d);
8271 restore_line_number_status (0);
8272 break; /* We now there are no other ones */
8273 }
8274 }
8275 }
8276 }
8277 }
8278
8279 /* If we've found error at that stage, don't try to generate
8280 anything, unless we're emitting xrefs or checking the syntax only
8281 (but not using -fsyntax-only for the purpose of generating
8282 bytecode. */
8283 if (java_error_count && !flag_emit_xref
8284 && (!flag_syntax_only && !flag_emit_class_files))
8285 return;
8286
8287 /* Now things are stable, go for generation of the class data. */
8288 for (ctxp_for_generation = saved_ctxp;
8289 ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8290 {
8291 tree current;
8292 ctxp = ctxp_for_generation;
8293 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8294 {
8295 current_class = TREE_TYPE (current);
8296 outgoing_cpool = TYPE_CPOOL (current_class);
8297 if (flag_emit_class_files)
8298 write_classfile (current_class);
8299 if (flag_emit_xref)
8300 expand_xref (current_class);
8301 else if (! flag_syntax_only)
8302 finish_class ();
8303 }
8304 }
b351b287
APB		 8305}
8306
e04a16fb
AG		 8307/* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
8308 a tree list node containing RIGHT. Fore coming RIGHTs will be
8309 chained to this hook. LOCATION contains the location of the
8310 separating `.' operator. */
8311
8312static tree
8313make_qualified_primary (primary, right, location)
8314 tree primary, right;
8315 int location;
8316{
8317 tree wfl;
8318
c2952b01
APB		 8319 if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
8320 wfl = build_wfl_wrap (primary);
e04a16fb
AG		 8321 else
8322 {
8323 wfl = primary;
c2952b01
APB		 8324 /* If wfl wasn't qualified, we build a first anchor */
8325 if (!EXPR_WFL_QUALIFICATION (wfl))
8326 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
e04a16fb
AG		 8327 }
8328
c2952b01 8329 /* And chain them */
e04a16fb
AG		 8330 EXPR_WFL_LINECOL (right) = location;
8331 chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
8332 PRIMARY_P (wfl) = 1;
8333 return wfl;
8334}
8335
8336/* Simple merge of two name separated by a `.' */
8337
8338static tree
8339merge_qualified_name (left, right)
8340 tree left, right;
8341{
8342 tree node;
c2952b01
APB		 8343 if (!left && !right)
8344 return NULL_TREE;
8345
8346 if (!left)
8347 return right;
8348
8349 if (!right)
8350 return left;
8351
e04a16fb
AG		 8352 obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
8353 IDENTIFIER_LENGTH (left));
8354 obstack_1grow (&temporary_obstack, '.');
8355 obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
8356 IDENTIFIER_LENGTH (right));
8357 node = get_identifier (obstack_base (&temporary_obstack));
8358 obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
8359 QUALIFIED_P (node) = 1;
8360 return node;
8361}
8362
8363/* Merge the two parts of a qualified name into LEFT. Set the
8364 location information of the resulting node to LOCATION, usually
8365 inherited from the location information of the `.' operator. */
8366
8367static tree
8368make_qualified_name (left, right, location)
8369 tree left, right;
8370 int location;
8371{
bc3ca41b
PB		 8372#ifdef USE_COMPONENT_REF
8373 tree node = build (COMPONENT_REF, NULL_TREE, left, right);
8374 EXPR_WFL_LINECOL (node) = location;
8375 return node;
8376#else
e04a16fb
AG		 8377 tree left_id = EXPR_WFL_NODE (left);
8378 tree right_id = EXPR_WFL_NODE (right);
8379 tree wfl, merge;
8380
8381 merge = merge_qualified_name (left_id, right_id);
8382
8383 /* Left wasn't qualified and is now qualified */
8384 if (!QUALIFIED_P (left_id))
8385 {
8386 tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
8387 EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
8388 EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
8389 }
8390
8391 wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
8392 EXPR_WFL_LINECOL (wfl) = location;
8393 chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
8394
8395 EXPR_WFL_NODE (left) = merge;
8396 return left;
bc3ca41b 8397#endif
e04a16fb
AG		 8398}
8399
8400/* Extract the last identifier component of the qualified in WFL. The
8401 last identifier is removed from the linked list */
8402
8403static tree
8404cut_identifier_in_qualified (wfl)
8405 tree wfl;
8406{
8407 tree q;
8408 tree previous = NULL_TREE;
8409 for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
8410 if (!TREE_CHAIN (q))
8411 {
8412 if (!previous)
781b0558 8413 fatal ("Operating on a non qualified qualified WFL - cut_identifier_in_qualified");
e04a16fb
AG		 8414 TREE_CHAIN (previous) = NULL_TREE;
8415 return TREE_PURPOSE (q);
8416 }
8417}
8418
8419/* Resolve the expression name NAME. Return its decl. */
8420
8421static tree
5e942c50 8422resolve_expression_name (id, orig)
e04a16fb 8423 tree id;
5e942c50 8424 tree *orig;
e04a16fb
AG		 8425{
8426 tree name = EXPR_WFL_NODE (id);
8427 tree decl;
8428
8429 /* 6.5.5.1: Simple expression names */
8430 if (!PRIMARY_P (id) && !QUALIFIED_P (name))
8431 {
8432 /* 15.13.1: NAME can appear within the scope of a local variable
8433 declaration */
8434 if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
8435 return decl;
8436
8437 /* 15.13.1: NAME can appear within a class declaration */
8438 else
8439 {
8440 decl = lookup_field_wrapper (current_class, name);
c2952b01
APB		 8441
8442 /* Last chance: if we're within the context of an inner
8443 class, we might be trying to access a local variable
8444 defined in an outer context. We try to look for it
8445 now. */
8446 if (!decl && INNER_CLASS_TYPE_P (current_class))
8447 {
8448 char *alias_buffer;
8449 MANGLE_OUTER_LOCAL_VARIABLE_NAME (alias_buffer, name);
8450 name = get_identifier (alias_buffer);
8451 decl = lookup_field_wrapper (current_class, name);
8452 if (decl)
8453 FIELD_LOCAL_ALIAS_USED (decl) = 1;
8454 }
8455
e04a16fb
AG		 8456 if (decl)
8457 {
c2952b01 8458 tree access = NULL_TREE;
e04a16fb
AG		 8459 int fs = FIELD_STATIC (decl);
8460 /* Instance variable (8.3.1.1) can't appear within
8461 static method, static initializer or initializer for
8462 a static variable. */
8463 if (!fs && METHOD_STATIC (current_function_decl))
8464 {
7f10c2e2 8465 static_ref_err (id, name, current_class);
e04a16fb
AG		 8466 return error_mark_node;
8467 }
22eed1e6
APB		 8468 /* Instance variables can't appear as an argument of
8469 an explicit constructor invocation */
8470 if (!fs && ctxp->explicit_constructor_p)
8471 {
8472 parse_error_context
781b0558 8473 (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
22eed1e6
APB		 8474 return error_mark_node;
8475 }
5e942c50 8476
c2952b01
APB		 8477 /* If we're processing an inner class and we're trying
8478 to access a field belonging to an outer class, build
8479 the access to the field */
8480 if (!fs && outer_field_access_p (current_class, decl))
8481 return build_outer_field_access (id, decl);
8482
5e942c50 8483 /* Otherwise build what it takes to access the field */
c2952b01
APB		 8484 access = build_field_ref ((fs ? NULL_TREE : current_this),
8485 DECL_CONTEXT (decl), name);
e8fc7396 8486 if (fs && !flag_emit_class_files && !flag_emit_xref)
c2952b01 8487 access = build_class_init (DECL_CONTEXT (access), access);
5e942c50
APB		 8488 /* We may be asked to save the real field access node */
8489 if (orig)
c2952b01 8490 *orig = access;
5e942c50 8491 /* And we return what we got */
c2952b01 8492 return access;
e04a16fb
AG		 8493 }
8494 /* Fall down to error report on undefined variable */
8495 }
8496 }
8497 /* 6.5.5.2 Qualified Expression Names */
8498 else
8499 {
5e942c50
APB		 8500 if (orig)
8501 *orig = NULL_TREE;
e04a16fb
AG		 8502 qualify_ambiguous_name (id);
8503 /* 15.10.1 Field Access Using a Primary and/or Expression Name */
8504 /* 15.10.2: Accessing Superclass Members using super */
98f3c1db 8505 return resolve_field_access (id, orig, NULL);
e04a16fb
AG		 8506 }
8507
8508 /* We've got an error here */
8509 parse_error_context (id, "Undefined variable `%s'",
8510 IDENTIFIER_POINTER (name));
8511
8512 return error_mark_node;
8513}
8514
7f10c2e2
APB		 8515static void
8516static_ref_err (wfl, field_id, class_type)
8517 tree wfl, field_id, class_type;
8518{
8519 parse_error_context
8520 (wfl,
8521 "Can't make a static reference to nonstatic variable `%s' in class `%s'",
8522 IDENTIFIER_POINTER (field_id),
8523 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
8524}
8525
e04a16fb
AG		 8526/* 15.10.1 Field Acess Using a Primary and/or Expression Name.
8527 We return something suitable to generate the field access. We also
8528 return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
8529 recipient's address can be null. */
8530
8531static tree
8532resolve_field_access (qual_wfl, field_decl, field_type)
8533 tree qual_wfl;
8534 tree *field_decl, *field_type;
8535{
8536 int is_static = 0;
8537 tree field_ref;
8538 tree decl, where_found, type_found;
8539
8540 if (resolve_qualified_expression_name (qual_wfl, &decl,
8541 &where_found, &type_found))
8542 return error_mark_node;
8543
8544 /* Resolve the LENGTH field of an array here */
8545 if (DECL_NAME (decl) == length_identifier_node && TYPE_ARRAY_P (type_found)
e8fc7396 8546 && ! flag_emit_class_files && ! flag_emit_xref)
e04a16fb
AG		 8547 {
8548 tree length = build_java_array_length_access (where_found);
8549 field_ref =
8550 build_java_arraynull_check (type_found, length, int_type_node);
8551 }
8552 /* We might have been trying to resolve field.method(). In which
8553 case, the resolution is over and decl is the answer */
34f4db93 8554 else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
e04a16fb 8555 field_ref = decl;
34f4db93 8556 else if (JDECL_P (decl))
e04a16fb 8557 {
5e942c50
APB		 8558 int static_final_found = 0;
8559 if (!type_found)
8560 type_found = DECL_CONTEXT (decl);
34f4db93 8561 is_static = JDECL_P (decl) && FIELD_STATIC (decl);
5e942c50
APB		 8562 if (FIELD_FINAL (decl)
8563 && JPRIMITIVE_TYPE_P (TREE_TYPE (decl))
8564 && DECL_LANG_SPECIFIC (decl)
7525cc04 8565 && DECL_INITIAL (decl))
5e942c50 8566 {
7525cc04 8567 field_ref = DECL_INITIAL (decl);
5e942c50
APB		 8568 static_final_found = 1;
8569 }
8570 else
7f10c2e2
APB		 8571 field_ref = build_field_ref ((is_static && !flag_emit_xref?
8572 NULL_TREE : where_found),
5e942c50 8573 type_found, DECL_NAME (decl));
e04a16fb
AG		 8574 if (field_ref == error_mark_node)
8575 return error_mark_node;
e8fc7396
APB		 8576 if (is_static && !static_final_found
8577 && !flag_emit_class_files && !flag_emit_xref)
98f3c1db 8578 field_ref = build_class_init (type_found, field_ref);
e04a16fb
AG		 8579 }
8580 else
8581 field_ref = decl;
8582
8583 if (field_decl)
8584 *field_decl = decl;
8585 if (field_type)
c877974e
APB		 8586 *field_type = (QUAL_DECL_TYPE (decl) ?
8587 QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
e04a16fb
AG		 8588 return field_ref;
8589}
8590
e28cd97b
APB		 8591/* If NODE is an access to f static field, strip out the class
8592 initialization part and return the field decl, otherwise, return
8593 NODE. */
8594
8595static tree
8596strip_out_static_field_access_decl (node)
8597 tree node;
8598{
8599 if (TREE_CODE (node) == COMPOUND_EXPR)
8600 {
8601 tree op1 = TREE_OPERAND (node, 1);
8602 if (TREE_CODE (op1) == COMPOUND_EXPR)
8603 {
8604 tree call = TREE_OPERAND (op1, 0);
8605 if (TREE_CODE (call) == CALL_EXPR
8606 && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
8607 && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
8608 == soft_initclass_node)
8609 return TREE_OPERAND (op1, 1);
8610 }
2f11d407
TT		 8611 else if (JDECL_P (op1))
8612 return op1;
e28cd97b
APB		 8613 }
8614 return node;
8615}
8616
e04a16fb
AG		 8617/* 6.5.5.2: Qualified Expression Names */
8618
8619static int
8620resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
8621 tree wfl;
8622 tree *found_decl, *type_found, *where_found;
8623{
8624 int from_type = 0; /* Field search initiated from a type */
c2952b01 8625 int from_super = 0, from_cast = 0, from_qualified_this = 0;
e04a16fb
AG		 8626 int previous_call_static = 0;
8627 int is_static;
8628 tree decl = NULL_TREE, type = NULL_TREE, q;
c2952b01
APB		 8629 /* For certain for of inner class instantiation */
8630 tree saved_current, saved_this;
8631#define RESTORE_THIS_AND_CURRENT_CLASS \
8632 { current_class = saved_current; current_this = saved_this;}
8633
c877974e 8634 *type_found = *where_found = NULL_TREE;
e04a16fb
AG		 8635
8636 for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
8637 {
8638 tree qual_wfl = QUAL_WFL (q);
7705e9db
APB		 8639 tree ret_decl; /* for EH checking */
8640 int location; /* for EH checking */
e04a16fb
AG		 8641
8642 /* 15.10.1 Field Access Using a Primary */
e04a16fb
AG		 8643 switch (TREE_CODE (qual_wfl))
8644 {
8645 case CALL_EXPR:
b67d701b 8646 case NEW_CLASS_EXPR:
e04a16fb
AG		 8647 /* If the access to the function call is a non static field,
8648 build the code to access it. */
34f4db93 8649 if (JDECL_P (decl) && !FIELD_STATIC (decl))
e04a16fb 8650 {
ac825856
APB		 8651 decl = maybe_access_field (decl, *where_found,
8652 DECL_CONTEXT (decl));
e04a16fb
AG		 8653 if (decl == error_mark_node)
8654 return 1;
8655 }
c2952b01 8656
e04a16fb
AG		 8657 /* And code for the function call */
8658 if (complete_function_arguments (qual_wfl))
8659 return 1;
c2952b01
APB		 8660
8661 /* We might have to setup a new current class and a new this
8662 for the search of an inner class, relative to the type of
8663 a expression resolved as `decl'. The current values are
8664 saved and restored shortly after */
8665 saved_current = current_class;
8666 saved_this = current_this;
8667 if (decl && TREE_CODE (qual_wfl) == NEW_CLASS_EXPR)
8668 {
8669 current_class = type;
8670 current_this = decl;
8671 }
8672
89e09b9a
PB		 8673 if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
8674 CALL_USING_SUPER (qual_wfl) = 1;
7705e9db
APB		 8675 location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
8676 EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
8677 *where_found = patch_method_invocation (qual_wfl, decl, type,
8678 &is_static, &ret_decl);
e04a16fb 8679 if (*where_found == error_mark_node)
c2952b01
APB		 8680 {
8681 RESTORE_THIS_AND_CURRENT_CLASS;
8682 return 1;
8683 }
e04a16fb
AG		 8684 *type_found = type = QUAL_DECL_TYPE (*where_found);
8685
c2952b01
APB		 8686 /* If we're creating an inner class instance, check for that
8687 an enclosing instance is in scope */
8688 if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
165f37bc 8689 && INNER_ENCLOSING_SCOPE_CHECK (type))
c2952b01
APB		 8690 {
8691 parse_error_context
165f37bc
APB		 8692 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
8693 lang_printable_name (type, 0),
8694 (!current_this ? "" :
8695 "; an explicit one must be provided when creating this inner class"));
c2952b01
APB		 8696 RESTORE_THIS_AND_CURRENT_CLASS;
8697 return 1;
8698 }
8699
8700 /* In case we had to change then to resolve a inner class
8701 instantiation using a primary qualified by a `new' */
8702 RESTORE_THIS_AND_CURRENT_CLASS;
8703
7705e9db
APB		 8704 /* EH check */
8705 if (location)
8706 check_thrown_exceptions (location, ret_decl);
8707
e04a16fb
AG		 8708 /* If the previous call was static and this one is too,
8709 build a compound expression to hold the two (because in
8710 that case, previous function calls aren't transported as
8711 forcoming function's argument. */
8712 if (previous_call_static && is_static)
8713 {
8714 decl = build (COMPOUND_EXPR, type, decl, *where_found);
8715 TREE_SIDE_EFFECTS (decl) = 1;
8716 }
8717 else
8718 {
8719 previous_call_static = is_static;
8720 decl = *where_found;
8721 }
c2952b01 8722 from_type = 0;
e04a16fb
AG		 8723 continue;
8724
d8fccff5 8725 case NEW_ARRAY_EXPR:
c2952b01 8726 case NEW_ANONYMOUS_ARRAY_EXPR:
d8fccff5
APB		 8727 *where_found = decl = java_complete_tree (qual_wfl);
8728 if (decl == error_mark_node)
8729 return 1;
8730 *type_found = type = QUAL_DECL_TYPE (decl);
8731 CLASS_LOADED_P (type) = 1;
8732 continue;
8733
e04a16fb
AG		 8734 case CONVERT_EXPR:
8735 *where_found = decl = java_complete_tree (qual_wfl);
8736 if (decl == error_mark_node)
8737 return 1;
8738 *type_found = type = QUAL_DECL_TYPE (decl);
8739 from_cast = 1;
8740 continue;
8741
22eed1e6 8742 case CONDITIONAL_EXPR:
5e942c50 8743 case STRING_CST:
ac22f9cb 8744 case MODIFY_EXPR:
22eed1e6
APB		 8745 *where_found = decl = java_complete_tree (qual_wfl);
8746 if (decl == error_mark_node)
8747 return 1;
8748 *type_found = type = QUAL_DECL_TYPE (decl);
8749 continue;
8750
e04a16fb
AG		 8751 case ARRAY_REF:
8752 /* If the access to the function call is a non static field,
8753 build the code to access it. */
34f4db93 8754 if (JDECL_P (decl) && !FIELD_STATIC (decl))
e04a16fb
AG		 8755 {
8756 decl = maybe_access_field (decl, *where_found, type);
8757 if (decl == error_mark_node)
8758 return 1;
8759 }
8760 /* And code for the array reference expression */
8761 decl = java_complete_tree (qual_wfl);
8762 if (decl == error_mark_node)
8763 return 1;
8764 type = QUAL_DECL_TYPE (decl);
8765 continue;
0a2138e2 8766
37feda7d
APB		 8767 case PLUS_EXPR:
8768 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
8769 return 1;
8770 if ((type = patch_string (decl)))
8771 decl = type;
8772 *where_found = QUAL_RESOLUTION (q) = decl;
8773 *type_found = type = TREE_TYPE (decl);
8774 break;
8775
165f37bc
APB		 8776 case CLASS_LITERAL:
8777 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
8778 return 1;
8779 *where_found = QUAL_RESOLUTION (q) = decl;
8780 *type_found = type = TREE_TYPE (decl);
8781 break;
8782
0a2138e2
APB		 8783 default:
8784 /* Fix for -Wall Just go to the next statement. Don't
8785 continue */
a3f406ce 8786 break;
e04a16fb
AG		 8787 }
8788
8789 /* If we fall here, we weren't processing a (static) function call. */
8790 previous_call_static = 0;
8791
8792 /* It can be the keyword THIS */
8793 if (EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
8794 {
8795 if (!current_this)
8796 {
8797 parse_error_context
8798 (wfl, "Keyword `this' used outside allowed context");
8799 return 1;
8800 }
f63991a8
APB		 8801 if (ctxp->explicit_constructor_p)
8802 {
781b0558 8803 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
f63991a8
APB		 8804 return 1;
8805 }
e04a16fb 8806 /* We have to generate code for intermediate acess */
c2952b01
APB		 8807 if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
8808 {
8809 *where_found = decl = current_this;
8810 *type_found = type = QUAL_DECL_TYPE (decl);
8811 }
8812 /* We're trying to access the this from somewhere else... */
8813 else
8814 {
8815 *where_found = decl = build_current_thisn (type);
8816 from_qualified_this = 1;
8817 }
8818
8819 from_type = 0;
e04a16fb
AG		 8820 continue;
8821 }
8822
8823 /* 15.10.2 Accessing Superclass Members using SUPER */
8824 if (EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
8825 {
8826 tree node;
8827 /* Check on the restricted use of SUPER */
8828 if (METHOD_STATIC (current_function_decl)
8829 || current_class == object_type_node)
8830 {
8831 parse_error_context
8832 (wfl, "Keyword `super' used outside allowed context");
8833 return 1;
8834 }
8835 /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
8836 node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
8837 CLASSTYPE_SUPER (current_class),
8838 build_this (EXPR_WFL_LINECOL (qual_wfl)));
8839 *where_found = decl = java_complete_tree (node);
22eed1e6
APB		 8840 if (decl == error_mark_node)
8841 return 1;
e04a16fb
AG		 8842 *type_found = type = QUAL_DECL_TYPE (decl);
8843 from_super = from_type = 1;
8844 continue;
8845 }
8846
8847 /* 15.13.1: Can't search for field name in packages, so we
8848 assume a variable/class name was meant. */
8849 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
8850 {
5e942c50
APB		 8851 tree name = resolve_package (wfl, &q);
8852 if (name)
8853 {
c2952b01 8854 tree list;
5e942c50
APB		 8855 *where_found = decl = resolve_no_layout (name, qual_wfl);
8856 /* We wan't to be absolutely that the class is laid
8857 out. We're going to search something inside it. */
8858 *type_found = type = TREE_TYPE (decl);
8859 layout_class (type);
8860 from_type = 1;
c2952b01 8861
dde1da72
APB		 8862 /* Fix them all the way down, if any are left. */
8863 if (q)
c2952b01 8864 {
dde1da72
APB		 8865 list = TREE_CHAIN (q);
8866 while (list)
8867 {
8868 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (list)) = 1;
8869 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
8870 list = TREE_CHAIN (list);
8871 }
c2952b01 8872 }
5e942c50 8873 }
e04a16fb 8874 else
5e942c50
APB		 8875 {
8876 if (from_super || from_cast)
8877 parse_error_context
8878 ((from_cast ? qual_wfl : wfl),
8879 "No variable `%s' defined in class `%s'",
8880 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
8881 lang_printable_name (type, 0));
8882 else
8883 parse_error_context
8884 (qual_wfl, "Undefined variable or class name: `%s'",
8885 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)));
8886 return 1;
8887 }
e04a16fb
AG		 8888 }
8889
8890 /* We have a type name. It's been already resolved when the
8891 expression was qualified. */
8892 else if (RESOLVE_TYPE_NAME_P (qual_wfl))
8893 {
8894 if (!(decl = QUAL_RESOLUTION (q)))
8895 return 1; /* Error reported already */
8896
c2952b01
APB		 8897 /* Sneak preview. If next we see a `new', we're facing a
8898 qualification with resulted in a type being selected
8899 instead of a field. Report the error */
8900 if(TREE_CHAIN (q)
8901 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
8902 {
8903 parse_error_context (qual_wfl, "Undefined variable `%s'",
8904 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
8905 return 1;
8906 }
8907
e04a16fb
AG		 8908 if (not_accessible_p (TREE_TYPE (decl), decl, 0))
8909 {
8910 parse_error_context
8911 (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
8912 java_accstring_lookup (get_access_flags_from_decl (decl)),
2aa11e97 8913 GET_TYPE_NAME (type),
e04a16fb
AG		 8914 IDENTIFIER_POINTER (DECL_NAME (decl)),
8915 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
8916 return 1;
8917 }
5e942c50 8918 check_deprecation (qual_wfl, decl);
c2952b01 8919
e04a16fb
AG		 8920 type = TREE_TYPE (decl);
8921 from_type = 1;
8922 }
8923 /* We resolve and expression name */
8924 else
8925 {
cd531a2e 8926 tree field_decl = NULL_TREE;
e04a16fb
AG		 8927
8928 /* If there exists an early resolution, use it. That occurs
8929 only once and we know that there are more things to
8930 come. Don't do that when processing something after SUPER
8931 (we need more thing to be put in place below */
8932 if (!from_super && QUAL_RESOLUTION (q))
b67d701b
PB		 8933 {
8934 decl = QUAL_RESOLUTION (q);
c877974e 8935 if (!type)
5e942c50 8936 {
7f10c2e2
APB		 8937 if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
8938 {
8939 if (current_this)
8940 *where_found = current_this;
8941 else
8942 {
8943 static_ref_err (qual_wfl, DECL_NAME (decl),
8944 current_class);
8945 return 1;
8946 }
8947 }
c877974e
APB		 8948 else
8949 {
8950 *where_found = TREE_TYPE (decl);
8951 if (TREE_CODE (*where_found) == POINTER_TYPE)
8952 *where_found = TREE_TYPE (*where_found);
8953 }
5e942c50 8954 }
b67d701b 8955 }
e04a16fb
AG		 8956
8957 /* We have to search for a field, knowing the type of its
8958 container. The flag FROM_TYPE indicates that we resolved
8959 the last member of the expression as a type name, which
5e942c50
APB		 8960 means that for the resolution of this field, we'll look
8961 for other errors than if it was resolved as a member of
8962 an other field. */
e04a16fb
AG		 8963 else
8964 {
8965 int is_static;
5e942c50
APB		 8966 tree field_decl_type; /* For layout */
8967
e04a16fb
AG		 8968 if (!from_type && !JREFERENCE_TYPE_P (type))
8969 {
8970 parse_error_context
8971 (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
8972 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
0a2138e2 8973 lang_printable_name (type, 0),
e04a16fb
AG		 8974 IDENTIFIER_POINTER (DECL_NAME (field_decl)));
8975 return 1;
8976 }
8977
dc0b3eff
PB		 8978 field_decl = lookup_field_wrapper (type,
8979 EXPR_WFL_NODE (qual_wfl));
8980 if (field_decl == NULL_TREE)
e04a16fb
AG		 8981 {
8982 parse_error_context
2aa11e97 8983 (qual_wfl, "No variable `%s' defined in type `%s'",
e04a16fb 8984 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
2aa11e97 8985 GET_TYPE_NAME (type));
e04a16fb
AG		 8986 return 1;
8987 }
dc0b3eff
PB		 8988 if (field_decl == error_mark_node)
8989 return 1;
5e942c50
APB		 8990
8991 /* Layout the type of field_decl, since we may need
c877974e
APB		 8992 it. Don't do primitive types or loaded classes. The
8993 situation of non primitive arrays may not handled
8994 properly here. FIXME */
5e942c50
APB		 8995 if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
8996 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
8997 else
8998 field_decl_type = TREE_TYPE (field_decl);
8999 if (!JPRIMITIVE_TYPE_P (field_decl_type)
c877974e
APB		 9000 && !CLASS_LOADED_P (field_decl_type)
9001 && !TYPE_ARRAY_P (field_decl_type))
9002 resolve_and_layout (field_decl_type, NULL_TREE);
9003 if (TYPE_ARRAY_P (field_decl_type))
9004 CLASS_LOADED_P (field_decl_type) = 1;
e04a16fb
AG		 9005
9006 /* Check on accessibility here */
9007 if (not_accessible_p (type, field_decl, from_super))
9008 {
9009 parse_error_context
9010 (qual_wfl,
9011 "Can't access %s field `%s.%s' from `%s'",
9012 java_accstring_lookup
9013 (get_access_flags_from_decl (field_decl)),
2aa11e97 9014 GET_TYPE_NAME (type),
e04a16fb
AG		 9015 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
9016 IDENTIFIER_POINTER
9017 (DECL_NAME (TYPE_NAME (current_class))));
9018 return 1;
9019 }
5e942c50 9020 check_deprecation (qual_wfl, field_decl);
e04a16fb
AG		 9021
9022 /* There are things to check when fields are accessed
9023 from type. There are no restrictions on a static
9024 declaration of the field when it is accessed from an
9025 interface */
9026 is_static = FIELD_STATIC (field_decl);
9027 if (!from_super && from_type
c2952b01
APB		 9028 && !TYPE_INTERFACE_P (type)
9029 && !is_static
9030 && (current_function_decl
9031 && METHOD_STATIC (current_function_decl)))
e04a16fb 9032 {
7f10c2e2 9033 static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
e04a16fb
AG		 9034 return 1;
9035 }
9036 from_cast = from_super = 0;
9037
c2952b01
APB		 9038 /* It's an access from a type but it isn't static, we
9039 make it relative to `this'. */
9040 if (!is_static && from_type)
9041 decl = current_this;
9042
5e942c50
APB		 9043 /* If we need to generate something to get a proper
9044 handle on what this field is accessed from, do it
9045 now. */
e04a16fb
AG		 9046 if (!is_static)
9047 {
c583dd46 9048 decl = maybe_access_field (decl, *where_found, *type_found);
e04a16fb
AG		 9049 if (decl == error_mark_node)
9050 return 1;
9051 }
9052
9053 /* We want to keep the location were found it, and the type
9054 we found. */
9055 *where_found = decl;
9056 *type_found = type;
9057
c2952b01
APB		 9058 /* Generate the correct expression for field access from
9059 qualified this */
9060 if (from_qualified_this)
9061 {
9062 field_decl = build_outer_field_access (qual_wfl, field_decl);
9063 from_qualified_this = 0;
9064 }
9065
e04a16fb
AG		 9066 /* This is the decl found and eventually the next one to
9067 search from */
9068 decl = field_decl;
9069 }
e04a16fb
AG		 9070 from_type = 0;
9071 type = QUAL_DECL_TYPE (decl);
c2952b01
APB		 9072
9073 /* Sneak preview. If decl is qualified by a `new', report
9074 the error here to be accurate on the peculiar construct */
9075 if (TREE_CHAIN (q)
9076 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
9077 && !JREFERENCE_TYPE_P (type))
9078 {
9079 parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
9080 lang_printable_name (type, 0));
9081 return 1;
9082 }
e04a16fb 9083 }
dde1da72
APB		 9084 /* `q' might have changed due to a after package resolution
9085 re-qualification */
9086 if (!q)
9087 break;
e04a16fb
AG		 9088 }
9089 *found_decl = decl;
9090 return 0;
9091}
9092
9093/* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
9094 can't be accessed from REFERENCE (a record type). */
9095
be245ac0
KG		 9096static int
9097not_accessible_p (reference, member, from_super)
e04a16fb
AG		 9098 tree reference, member;
9099 int from_super;
9100{
9101 int access_flag = get_access_flags_from_decl (member);
9102
9103 /* Access always granted for members declared public */
9104 if (access_flag & ACC_PUBLIC)
9105 return 0;
9106
9107 /* Check access on protected members */
9108 if (access_flag & ACC_PROTECTED)
9109 {
9110 /* Access granted if it occurs from within the package
9111 containing the class in which the protected member is
9112 declared */
9113 if (class_in_current_package (DECL_CONTEXT (member)))
9114 return 0;
9115
9bbc7d9f
PB		 9116 /* If accessed with the form `super.member', then access is granted */
9117 if (from_super)
9118 return 0;
e04a16fb 9119
9bbc7d9f
PB		 9120 /* Otherwise, access is granted if occuring from the class where
9121 member is declared or a subclass of it */
9122 if (inherits_from_p (reference, current_class))
9123 return 0;
e04a16fb
AG		 9124 return 1;
9125 }
9126
9127 /* Check access on private members. Access is granted only if it
c2952b01
APB		 9128 occurs from within the class in witch it is declared. Exceptions
9129 are access from inner-classes. This section is probably not
9130 complete. FIXME */
e04a16fb 9131 if (access_flag & ACC_PRIVATE)
c2952b01
APB		 9132 return (current_class == DECL_CONTEXT (member) ? 0 :
9133 (INNER_CLASS_TYPE_P (current_class) ? 0 : 1));
e04a16fb
AG		 9134
9135 /* Default access are permitted only when occuring within the
9136 package in which the type (REFERENCE) is declared. In other words,
9137 REFERENCE is defined in the current package */
9138 if (ctxp->package)
9139 return !class_in_current_package (reference);
9140
9141 /* Otherwise, access is granted */
9142 return 0;
9143}
9144
5e942c50
APB		 9145/* Test deprecated decl access. */
9146static void
9147check_deprecation (wfl, decl)
9148 tree wfl, decl;
9149{
49f48c71 9150 const char *file = DECL_SOURCE_FILE (decl);
5e942c50
APB		 9151 /* Complain if the field is deprecated and the file it was defined
9152 in isn't compiled at the same time the file which contains its
9153 use is */
9154 if (DECL_DEPRECATED (decl)
9155 && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
9156 {
9157 char the [20];
9158 switch (TREE_CODE (decl))
9159 {
9160 case FUNCTION_DECL:
9161 strcpy (the, "method");
9162 break;
9163 case FIELD_DECL:
9164 strcpy (the, "field");
9165 break;
9166 case TYPE_DECL:
9167 strcpy (the, "class");
9168 break;
15fdcfe9
PB		 9169 default:
9170 fatal ("unexpected DECL code - check_deprecation");
5e942c50
APB		 9171 }
9172 parse_warning_context
9173 (wfl, "The %s `%s' in class `%s' has been deprecated",
9174 the, lang_printable_name (decl, 0),
9175 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
9176 }
9177}
9178
e04a16fb
AG		 9179/* Returns 1 if class was declared in the current package, 0 otherwise */
9180
9181static int
9182class_in_current_package (class)
9183 tree class;
9184{
9185 static tree cache = NULL_TREE;
9186 int qualified_flag;
9187 tree left;
9188
9189 if (cache == class)
9190 return 1;
9191
9192 qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
9193
9194 /* If the current package is empty and the name of CLASS is
9195 qualified, class isn't in the current package. If there is a
9196 current package and the name of the CLASS is not qualified, class
9197 isn't in the current package */
0a2138e2 9198 if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
e04a16fb
AG		 9199 return 0;
9200
9201 /* If there is not package and the name of CLASS isn't qualified,
9202 they belong to the same unnamed package */
9203 if (!ctxp->package && !qualified_flag)
9204 return 1;
9205
9206 /* Compare the left part of the name of CLASS with the package name */
9207 breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
9208 if (ctxp->package == left)
9209 {
9210 cache = class;
9211 return 1;
9212 }
9213 return 0;
9214}
9215
9216/* This function may generate code to access DECL from WHERE. This is
9217 done only if certain conditions meet. */
9218
9219static tree
9220maybe_access_field (decl, where, type)
9221 tree decl, where, type;
9222{
5e942c50
APB		 9223 if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
9224 && !FIELD_STATIC (decl))
e04a16fb 9225 decl = build_field_ref (where ? where : current_this,
c583dd46
APB		 9226 (type ? type : DECL_CONTEXT (decl)),
9227 DECL_NAME (decl));
e04a16fb
AG		 9228 return decl;
9229}
9230
15fdcfe9 9231/* Build a method invocation, by patching PATCH. If non NULL
e04a16fb
AG		 9232 and according to the situation, PRIMARY and WHERE may be
9233 used. IS_STATIC is set to 1 if the invoked function is static. */
9234
9235static tree
89e09b9a 9236patch_method_invocation (patch, primary, where, is_static, ret_decl)
e04a16fb
AG		 9237 tree patch, primary, where;
9238 int *is_static;
b9f7e36c 9239 tree *ret_decl;
e04a16fb
AG		 9240{
9241 tree wfl = TREE_OPERAND (patch, 0);
9242 tree args = TREE_OPERAND (patch, 1);
9243 tree name = EXPR_WFL_NODE (wfl);
5e942c50 9244 tree list;
22eed1e6 9245 int is_static_flag = 0;
89e09b9a 9246 int is_super_init = 0;
bccaf73a 9247 tree this_arg = NULL_TREE;
e04a16fb
AG		 9248
9249 /* Should be overriden if everything goes well. Otherwise, if
9250 something fails, it should keep this value. It stop the
9251 evaluation of a bogus assignment. See java_complete_tree,
9252 MODIFY_EXPR: for the reasons why we sometimes want to keep on
9253 evaluating an assignment */
9254 TREE_TYPE (patch) = error_mark_node;
9255
9256 /* Since lookup functions are messing with line numbers, save the
9257 context now. */
9258 java_parser_context_save_global ();
9259
9260 /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
9261
9262 /* Resolution of qualified name, excluding constructors */
9263 if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
9264 {
dde1da72 9265 tree identifier, identifier_wfl, type, resolved;
e04a16fb
AG		 9266 /* Extract the last IDENTIFIER of the qualified
9267 expression. This is a wfl and we will use it's location
9268 data during error report. */
9269 identifier_wfl = cut_identifier_in_qualified (wfl);
9270 identifier = EXPR_WFL_NODE (identifier_wfl);
9271
9272 /* Given the context, IDENTIFIER is syntactically qualified
9273 as a MethodName. We need to qualify what's before */
9274 qualify_ambiguous_name (wfl);
dde1da72 9275 resolved = resolve_field_access (wfl, NULL, NULL);
e04a16fb 9276
dde1da72
APB		 9277 if (resolved == error_mark_node)
9278 PATCH_METHOD_RETURN_ERROR ();
9279
9280 type = GET_SKIP_TYPE (resolved);
9281 resolve_and_layout (type, NULL_TREE);
9282 list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
9283 args = nreverse (args);
2c56429a 9284
e04a16fb 9285 /* We're resolving a call from a type */
dde1da72 9286 if (TREE_CODE (resolved) == TYPE_DECL)
e04a16fb 9287 {
dde1da72 9288 if (CLASS_INTERFACE (resolved))
e04a16fb
AG		 9289 {
9290 parse_error_context
781b0558
KG		 9291 (identifier_wfl,
9292 "Can't make static reference to method `%s' in interface `%s'",
9293 IDENTIFIER_POINTER (identifier),
e04a16fb 9294 IDENTIFIER_POINTER (name));
b9f7e36c 9295 PATCH_METHOD_RETURN_ERROR ();
e04a16fb 9296 }
e04a16fb
AG		 9297 if (list && !METHOD_STATIC (list))
9298 {
c2e3db92 9299 char *fct_name = xstrdup (lang_printable_name (list, 0));
e04a16fb
AG		 9300 parse_error_context
9301 (identifier_wfl,
9302 "Can't make static reference to method `%s %s' in class `%s'",
0a2138e2
APB		 9303 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
9304 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
e04a16fb 9305 free (fct_name);
b9f7e36c 9306 PATCH_METHOD_RETURN_ERROR ();
e04a16fb
AG		 9307 }
9308 }
e04a16fb 9309 else
dde1da72
APB		 9310 this_arg = primary = resolved;
9311
5e942c50 9312 /* IDENTIFIER_WFL will be used to report any problem further */
e04a16fb
AG		 9313 wfl = identifier_wfl;
9314 }
9315 /* Resolution of simple names, names generated after a primary: or
9316 constructors */
9317 else
9318 {
cd531a2e 9319 tree class_to_search = NULL_TREE;
c2952b01 9320 int lc; /* Looking for Constructor */
e04a16fb
AG		 9321
9322 /* We search constructor in their target class */
9323 if (CALL_CONSTRUCTOR_P (patch))
9324 {
22eed1e6
APB		 9325 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
9326 class_to_search = EXPR_WFL_NODE (wfl);
9327 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
9328 this_identifier_node)
9329 class_to_search = NULL_TREE;
9330 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
9331 super_identifier_node)
e04a16fb 9332 {
89e09b9a 9333 is_super_init = 1;
22eed1e6
APB		 9334 if (CLASSTYPE_SUPER (current_class))
9335 class_to_search =
9336 DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
9337 else
9338 {
781b0558 9339 parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
22eed1e6
APB		 9340 PATCH_METHOD_RETURN_ERROR ();
9341 }
e04a16fb 9342 }
22eed1e6
APB		 9343
9344 /* Class to search is NULL if we're searching the current one */
9345 if (class_to_search)
e04a16fb 9346 {
c2952b01
APB		 9347 class_to_search = resolve_and_layout (class_to_search, wfl);
9348
22eed1e6
APB		 9349 if (!class_to_search)
9350 {
9351 parse_error_context
9352 (wfl, "Class `%s' not found in type declaration",
9353 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9354 PATCH_METHOD_RETURN_ERROR ();
9355 }
9356
5e942c50
APB		 9357 /* Can't instantiate an abstract class, but we can
9358 invoke it's constructor. It's use within the `new'
9359 context is denied here. */
9360 if (CLASS_ABSTRACT (class_to_search)
9361 && TREE_CODE (patch) == NEW_CLASS_EXPR)
22eed1e6
APB		 9362 {
9363 parse_error_context
781b0558
KG		 9364 (wfl, "Class `%s' is an abstract class. It can't be instantiated",
9365 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
22eed1e6
APB		 9366 PATCH_METHOD_RETURN_ERROR ();
9367 }
c2952b01 9368
22eed1e6 9369 class_to_search = TREE_TYPE (class_to_search);
e04a16fb 9370 }
22eed1e6
APB		 9371 else
9372 class_to_search = current_class;
e04a16fb
AG		 9373 lc = 1;
9374 }
9375 /* This is a regular search in the local class, unless an
9376 alternate class is specified. */
9377 else
9378 {
9379 class_to_search = (where ? where : current_class);
9380 lc = 0;
9381 }
c2952b01 9382
e04a16fb
AG		 9383 /* NAME is a simple identifier or comes from a primary. Search
9384 in the class whose declaration contain the method being
9385 invoked. */
c877974e 9386 resolve_and_layout (class_to_search, NULL_TREE);
e04a16fb 9387
c2952b01 9388 list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
e04a16fb
AG		 9389 /* Don't continue if no method were found, as the next statement
9390 can't be executed then. */
b9f7e36c
APB		 9391 if (!list)
9392 PATCH_METHOD_RETURN_ERROR ();
e04a16fb
AG		 9393
9394 /* Check for static reference if non static methods */
9395 if (check_for_static_method_reference (wfl, patch, list,
9396 class_to_search, primary))
b9f7e36c 9397 PATCH_METHOD_RETURN_ERROR ();
e04a16fb 9398
165f37bc
APB		 9399 /* Check for inner classes creation from illegal contexts */
9400 if (lc && (INNER_CLASS_TYPE_P (class_to_search)
9401 && !CLASS_STATIC (TYPE_NAME (class_to_search)))
9402 && INNER_ENCLOSING_SCOPE_CHECK (class_to_search))
9403 {
9404 parse_error_context
9405 (wfl, "No enclosing instance for inner class `%s' is in scope%s",
9406 lang_printable_name (class_to_search, 0),
9407 (!current_this ? "" :
9408 "; an explicit one must be provided when creating this inner class"));
9409 PATCH_METHOD_RETURN_ERROR ();
9410 }
9411
22eed1e6
APB		 9412 /* Non static methods are called with the current object extra
9413 argument. If patch a `new TYPE()', the argument is the value
9414 returned by the object allocator. If method is resolved as a
9415 primary, use the primary otherwise use the current THIS. */
b9f7e36c 9416 args = nreverse (args);
bccaf73a 9417 if (TREE_CODE (patch) != NEW_CLASS_EXPR)
c2952b01
APB		 9418 {
9419 this_arg = primary ? primary : current_this;
9420
9421 /* If we're using an access method, things are different.
9422 There are two familly of cases:
9423
9424 1) We're not generating bytecodes:
9425
9426 - LIST is non static. It's invocation is transformed from
9427 x(a1,...,an) into this$<n>.x(a1,....an).
9428 - LIST is static. It's invocation is transformed from
9429 x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
9430
9431 2) We're generating bytecodes:
9432
9433 - LIST is non static. It's invocation is transformed from
9434 x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
9435 - LIST is static. It's invocation is transformed from
9436 x(a1,....,an) into TYPEOF(this$<n>).x(a1,....an).
9437
9438 Of course, this$<n> can be abitrary complex, ranging from
9439 this$0 (the immediate outer context) to
9440 access$0(access$0(...(this$0))).
9441
9442 maybe_use_access_method returns a non zero value if the
9443 this_arg has to be deplaced into the (then generated)
9444 stub argument list. In the mean time, the selected
9445 function might have be replaced by a generated stub. */
9446 if (maybe_use_access_method (is_super_init, &list, &this_arg))
9447 args = tree_cons (NULL_TREE, this_arg, args);
9448 }
e04a16fb 9449 }
b67d701b 9450
e04a16fb
AG		 9451 /* Merge point of all resolution schemes. If we have nothing, this
9452 is an error, already signaled */
b9f7e36c
APB		 9453 if (!list)
9454 PATCH_METHOD_RETURN_ERROR ();
b67d701b 9455
e04a16fb
AG		 9456 /* Check accessibility, position the is_static flag, build and
9457 return the call */
9bbc7d9f 9458 if (not_accessible_p (DECL_CONTEXT (current_function_decl), list, 0))
e04a16fb 9459 {
c2e3db92 9460 char *fct_name = xstrdup (lang_printable_name (list, 0));
e04a16fb
AG		 9461 parse_error_context
9462 (wfl, "Can't access %s method `%s %s.%s' from `%s'",
9463 java_accstring_lookup (get_access_flags_from_decl (list)),
0a2138e2 9464 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
5e942c50
APB		 9465 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list)))),
9466 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
e04a16fb 9467 free (fct_name);
b9f7e36c 9468 PATCH_METHOD_RETURN_ERROR ();
e04a16fb 9469 }
5e942c50 9470 check_deprecation (wfl, list);
22eed1e6 9471
c2952b01
APB		 9472 /* If invoking a innerclass constructor, there are hidden parameters
9473 to pass */
9474 if (TREE_CODE (patch) == NEW_CLASS_EXPR
9475 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
9476 {
9477 /* And make sure we add the accessed local variables to be saved
9478 in field aliases. */
9479 args = build_alias_initializer_parameter_list
9480 (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
9481
9482 /* We have to reverse things. Find out why. FIXME */
9483 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (list)))
9484 args = nreverse (args);
9485
9486 /* Secretely pass the current_this/primary as a second argument */
165f37bc
APB		 9487 if (primary || current_this)
9488 args = tree_cons (NULL_TREE, (primary ? primary : current_this), args);
9489 else
9490 args = tree_cons (NULL_TREE, integer_zero_node, args);
c2952b01
APB		 9491 }
9492
22eed1e6 9493 is_static_flag = METHOD_STATIC (list);
bccaf73a
PB		 9494 if (! METHOD_STATIC (list) && this_arg != NULL_TREE)
9495 args = tree_cons (NULL_TREE, this_arg, args);
22eed1e6 9496
c3f2a476
APB		 9497 /* In the context of an explicit constructor invocation, we can't
9498 invoke any method relying on `this'. Exceptions are: we're
9499 invoking a static function, primary exists and is not the current
9500 this, we're creating a new object. */
22eed1e6 9501 if (ctxp->explicit_constructor_p
c3f2a476
APB		 9502 && !is_static_flag
9503 && (!primary || primary == current_this)
9504 && (TREE_CODE (patch) != NEW_CLASS_EXPR))
22eed1e6 9505 {
781b0558 9506 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
22eed1e6
APB		 9507 PATCH_METHOD_RETURN_ERROR ();
9508 }
e04a16fb 9509 java_parser_context_restore_global ();
22eed1e6
APB		 9510 if (is_static)
9511 *is_static = is_static_flag;
b9f7e36c
APB		 9512 /* Sometimes, we want the decl of the selected method. Such as for
9513 EH checking */
9514 if (ret_decl)
9515 *ret_decl = list;
89e09b9a
PB		 9516 patch = patch_invoke (patch, list, args);
9517 if (is_super_init && CLASS_HAS_FINIT_P (current_class))
9518 {
c2952b01
APB		 9519 tree finit_parms, finit_call;
9520
9521 /* Prepare to pass hidden parameters to $finit$, if any. */
9522 finit_parms = build_alias_initializer_parameter_list
9523 (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
89e09b9a 9524
c2952b01
APB		 9525 finit_call =
9526 build_method_invocation (build_wfl_node (finit_identifier_node),
9527 finit_parms);
9528
9529 /* Generate the code used to initialize fields declared with an
9530 initialization statement and build a compound statement along
9531 with the super constructor invocation. */
89e09b9a
PB		 9532 patch = build (COMPOUND_EXPR, void_type_node, patch,
9533 java_complete_tree (finit_call));
9534 CAN_COMPLETE_NORMALLY (patch) = 1;
9535 }
9536 return patch;
e04a16fb
AG		 9537}
9538
9539/* Check that we're not trying to do a static reference to a method in
9540 non static method. Return 1 if it's the case, 0 otherwise. */
9541
9542static int
9543check_for_static_method_reference (wfl, node, method, where, primary)
9544 tree wfl, node, method, where, primary;
9545{
9546 if (METHOD_STATIC (current_function_decl)
9547 && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
9548 {
c2e3db92 9549 char *fct_name = xstrdup (lang_printable_name (method, 0));
e04a16fb
AG		 9550 parse_error_context
9551 (wfl, "Can't make static reference to method `%s %s' in class `%s'",
0a2138e2 9552 lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
e04a16fb
AG		 9553 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
9554 free (fct_name);
9555 return 1;
9556 }
9557 return 0;
9558}
9559
c2952b01
APB		 9560/* Fix the invocation of *MDECL if necessary in the case of a
9561 invocation from an inner class. *THIS_ARG might be modified
9562 appropriately and an alternative access to *MDECL might be
9563 returned. */
9564
9565static int
9566maybe_use_access_method (is_super_init, mdecl, this_arg)
9567 int is_super_init;
9568 tree *mdecl, *this_arg;
9569{
9570 tree ctx;
9571 tree md = *mdecl, ta = *this_arg;
9572 int to_return = 0;
9573 int non_static_context = !METHOD_STATIC (md);
9574
9575 if (is_super_init
165f37bc
APB		 9576 || DECL_CONTEXT (md) == current_class
9577 || !PURE_INNER_CLASS_TYPE_P (current_class)
9578 || DECL_FINIT_P (md))
c2952b01
APB		 9579 return 0;
9580
9581 /* If we're calling a method found in an enclosing class, generate
9582 what it takes to retrieve the right this. Don't do that if we're
9583 invoking a static method. */
9584
9585 if (non_static_context)
9586 {
9587 ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
9588 if (ctx == DECL_CONTEXT (md))
9589 {
9590 ta = build_current_thisn (current_class);
9591 ta = build_wfl_node (ta);
9592 }
9593 else
9594 {
9595 tree type = ctx;
9596 while (type)
9597 {
9598 maybe_build_thisn_access_method (type);
9599 if (type == DECL_CONTEXT (md))
9600 {
9601 ta = build_access_to_thisn (ctx, type, 0);
9602 break;
9603 }
9604 type = (DECL_CONTEXT (TYPE_NAME (type)) ?
9605 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
9606 }
9607 }
9608 ta = java_complete_tree (ta);
9609 }
9610
9611 /* We might have to use an access method to get to MD. We can
9612 break the method access rule as far as we're not generating
9613 bytecode */
9614 if (METHOD_PRIVATE (md) && flag_emit_class_files)
9615 {
9616 md = build_outer_method_access_method (md);
9617 to_return = 1;
9618 }
9619
9620 *mdecl = md;
9621 *this_arg = ta;
9622
9623 /* Returnin a non zero value indicates we were doing a non static
9624 method invokation that is now a static invocation. It will have
9625 callee displace `this' to insert it in the regular argument
9626 list. */
9627 return (non_static_context && to_return);
9628}
9629
e04a16fb
AG		 9630/* Patch an invoke expression METHOD and ARGS, based on its invocation
9631 mode. */
9632
9633static tree
89e09b9a 9634patch_invoke (patch, method, args)
e04a16fb 9635 tree patch, method, args;
e04a16fb
AG		 9636{
9637 tree dtable, func;
0a2138e2 9638 tree original_call, t, ta;
e04a16fb 9639
5e942c50
APB		 9640 /* Last step for args: convert build-in types. If we're dealing with
9641 a new TYPE() type call, the first argument to the constructor
9642 isn't found in the incomming argument list, but delivered by
9643 `new' */
9644 t = TYPE_ARG_TYPES (TREE_TYPE (method));
9645 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
9646 t = TREE_CHAIN (t);
ac825856
APB		 9647 for (ta = args; t != end_params_node && ta;
9648 t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
b9f7e36c
APB		 9649 if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
9650 TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
9651 TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
1a6d4fb7
APB		 9652
9653 /* Resolve unresolved returned type isses */
9654 t = TREE_TYPE (TREE_TYPE (method));
9655 if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
9656 resolve_and_layout (TREE_TYPE (t), NULL);
c2952b01 9657
e8fc7396 9658 if (flag_emit_class_files || flag_emit_xref)
15fdcfe9
PB		 9659 func = method;
9660 else
e04a16fb 9661 {
15fdcfe9 9662 tree signature = build_java_signature (TREE_TYPE (method));
89e09b9a 9663 switch (invocation_mode (method, CALL_USING_SUPER (patch)))
15fdcfe9
PB		 9664 {
9665 case INVOKE_VIRTUAL:
9666 dtable = invoke_build_dtable (0, args);
9667 func = build_invokevirtual (dtable, method);
9668 break;
b9f7e36c 9669
15fdcfe9
PB		 9670 case INVOKE_SUPER:
9671 case INVOKE_STATIC:
9672 func = build_known_method_ref (method, TREE_TYPE (method),
9673 DECL_CONTEXT (method),
9674 signature, args);
9675 break;
e04a16fb 9676
15fdcfe9
PB		 9677 case INVOKE_INTERFACE:
9678 dtable = invoke_build_dtable (1, args);
173f556c 9679 func = build_invokeinterface (dtable, method);
15fdcfe9 9680 break;
5e942c50 9681
15fdcfe9 9682 default:
89e09b9a 9683 fatal ("internal error - unknown invocation_mode result");
15fdcfe9
PB		 9684 }
9685
9686 /* Ensure self_type is initialized, (invokestatic). FIXME */
9687 func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
e04a16fb
AG		 9688 }
9689
e04a16fb
AG		 9690 TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
9691 TREE_OPERAND (patch, 0) = func;
9692 TREE_OPERAND (patch, 1) = args;
9693 original_call = patch;
9694
22eed1e6
APB		 9695 /* We're processing a `new TYPE ()' form. New is called an its
9696 returned value is the first argument to the constructor. We build
9697 a COMPOUND_EXPR and use saved expression so that the overall NEW
9698 expression value is a pointer to a newly created and initialized
9699 class. */
9700 if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
e04a16fb
AG		 9701 {
9702 tree class = DECL_CONTEXT (method);
9703 tree c1, saved_new, size, new;
e8fc7396 9704 if (flag_emit_class_files || flag_emit_xref)
15fdcfe9
PB		 9705 {
9706 TREE_TYPE (patch) = build_pointer_type (class);
9707 return patch;
9708 }
e04a16fb
AG		 9709 if (!TYPE_SIZE (class))
9710 safe_layout_class (class);
9711 size = size_in_bytes (class);
9712 new = build (CALL_EXPR, promote_type (class),
9713 build_address_of (alloc_object_node),
9714 tree_cons (NULL_TREE, build_class_ref (class),
9715 build_tree_list (NULL_TREE,
9716 size_in_bytes (class))),
9717 NULL_TREE);
9718 saved_new = save_expr (new);
9719 c1 = build_tree_list (NULL_TREE, saved_new);
9720 TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
9721 TREE_OPERAND (original_call, 1) = c1;
9722 TREE_SET_CODE (original_call, CALL_EXPR);
9723 patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
9724 }
9725 return patch;
9726}
9727
9728static int
9729invocation_mode (method, super)
9730 tree method;
9731 int super;
9732{
9733 int access = get_access_flags_from_decl (method);
9734
22eed1e6
APB		 9735 if (super)
9736 return INVOKE_SUPER;
9737
82371d41 9738 if (access & ACC_STATIC || access & ACC_FINAL || access & ACC_PRIVATE)
e04a16fb
AG		 9739 return INVOKE_STATIC;
9740
9741 if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
9742 return INVOKE_STATIC;
9743
e04a16fb
AG		 9744 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
9745 return INVOKE_INTERFACE;
9746
9747 if (DECL_CONSTRUCTOR_P (method))
9748 return INVOKE_STATIC;
22eed1e6 9749
e04a16fb
AG		 9750 return INVOKE_VIRTUAL;
9751}
9752
b67d701b
PB		 9753/* Retrieve a refined list of matching methods. It covers the step
9754 15.11.2 (Compile-Time Step 2) */
e04a16fb
AG		 9755
9756static tree
9757lookup_method_invoke (lc, cl, class, name, arg_list)
9758 int lc;
9759 tree cl;
9760 tree class, name, arg_list;
9761{
de4c7b02 9762 tree atl = end_params_node; /* Arg Type List */
c877974e 9763 tree method, signature, list, node;
49f48c71 9764 const char *candidates; /* Used for error report */
b5b8a0e7 9765 char *dup;
e04a16fb 9766
5e942c50 9767 /* Fix the arguments */
e04a16fb
AG		 9768 for (node = arg_list; node; node = TREE_CHAIN (node))
9769 {
e3884b71 9770 tree current_arg = TREE_TYPE (TREE_VALUE (node));
c877974e 9771 /* Non primitive type may have to be resolved */
e3884b71 9772 if (!JPRIMITIVE_TYPE_P (current_arg))
c877974e
APB		 9773 resolve_and_layout (current_arg, NULL_TREE);
9774 /* And promoted */
b67d701b 9775 if (TREE_CODE (current_arg) == RECORD_TYPE)
c877974e 9776 current_arg = promote_type (current_arg);
5e942c50 9777 atl = tree_cons (NULL_TREE, current_arg, atl);
e04a16fb 9778 }
e04a16fb 9779
c2952b01
APB		 9780 /* Presto. If we're dealing with an anonymous class and a
9781 constructor call, generate the right constructor now, since we
9782 know the arguments' types. */
9783
9784 if (lc && ANONYMOUS_CLASS_P (class))
9785 craft_constructor (TYPE_NAME (class), atl);
9786
5e942c50
APB		 9787 /* Find all candidates and then refine the list, searching for the
9788 most specific method. */
9789 list = find_applicable_accessible_methods_list (lc, class, name, atl);
9790 list = find_most_specific_methods_list (list);
b67d701b
PB		 9791 if (list && !TREE_CHAIN (list))
9792 return TREE_VALUE (list);
e04a16fb 9793
b67d701b
PB		 9794 /* Issue an error. List candidates if any. Candidates are listed
9795 only if accessible (non accessible methods may end-up here for
9796 the sake of a better error report). */
9797 candidates = NULL;
9798 if (list)
e04a16fb 9799 {
e04a16fb 9800 tree current;
b67d701b 9801 obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
e04a16fb
AG		 9802 for (current = list; current; current = TREE_CHAIN (current))
9803 {
b67d701b
PB		 9804 tree cm = TREE_VALUE (current);
9805 char string [4096];
9806 if (!cm || not_accessible_p (class, cm, 0))
9807 continue;
b67d701b 9808 sprintf
22eed1e6
APB		 9809 (string, " `%s' in `%s'%s",
9810 get_printable_method_name (cm),
b67d701b
PB		 9811 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
9812 (TREE_CHAIN (current) ? "\n" : ""));
9813 obstack_grow (&temporary_obstack, string, strlen (string));
9814 }
9815 obstack_1grow (&temporary_obstack, '\0');
9816 candidates = obstack_finish (&temporary_obstack);
9817 }
9818 /* Issue the error message */
c877974e
APB		 9819 method = make_node (FUNCTION_TYPE);
9820 TYPE_ARG_TYPES (method) = atl;
b67d701b 9821 signature = build_java_argument_signature (method);
c63b98cd 9822 dup = xstrdup (lang_printable_name (class, 0));
b5b8a0e7 9823 parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
22eed1e6 9824 (lc ? "constructor" : "method"),
b5b8a0e7
APB		 9825 (lc ? dup : IDENTIFIER_POINTER (name)),
9826 IDENTIFIER_POINTER (signature), dup,
b67d701b 9827 (candidates ? candidates : ""));
b5b8a0e7 9828 free (dup);
b67d701b
PB		 9829 return NULL_TREE;
9830}
9831
5e942c50
APB		 9832/* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
9833 when we're looking for a constructor. */
b67d701b
PB		 9834
9835static tree
5e942c50
APB		 9836find_applicable_accessible_methods_list (lc, class, name, arglist)
9837 int lc;
b67d701b
PB		 9838 tree class, name, arglist;
9839{
165f37bc 9840 static int object_done = 0;
b67d701b
PB		 9841 tree list = NULL_TREE, all_list = NULL_TREE;
9842
c2952b01
APB		 9843 if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
9844 {
9845 load_class (class, 1);
9846 safe_layout_class (class);
9847 }
9848
1982388a 9849 /* Search interfaces */
165f37bc 9850 if (CLASS_INTERFACE (TYPE_NAME (class)))
b67d701b 9851 {
e0422ed0 9852 static struct hash_table t, *searched_interfaces = NULL;
de0b553f 9853 static int search_not_done = 0;
1982388a
APB		 9854 int i, n;
9855 tree basetype_vec = TYPE_BINFO_BASETYPES (class);
9856
e0422ed0
APB		 9857 /* Search in the hash table, otherwise create a new one if
9858 necessary and insert the new entry. */
9859
de0b553f 9860 if (searched_interfaces)
e0422ed0
APB		 9861 {
9862 if (hash_lookup (searched_interfaces,
9863 (const hash_table_key) class, FALSE, NULL))
9864 return NULL;
de0b553f 9865 }
e0422ed0
APB		 9866 else
9867 {
9868 hash_table_init (&t, hash_newfunc, java_hash_hash_tree_node,
9869 java_hash_compare_tree_node);
9870 searched_interfaces = &t;
9871 }
9872
9873 hash_lookup (searched_interfaces,
9874 (const hash_table_key) class, TRUE, NULL);
de0b553f 9875
165f37bc
APB		 9876 search_applicable_methods_list (lc, TYPE_METHODS (class),
9877 name, arglist, &list, &all_list);
1982388a 9878 n = TREE_VEC_LENGTH (basetype_vec);
165f37bc 9879 for (i = 1; i < n; i++)
b67d701b 9880 {
de0b553f
APB		 9881 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
9882 tree rlist;
9883
de0b553f
APB		 9884 search_not_done++;
9885 rlist = find_applicable_accessible_methods_list (lc, t, name,
9886 arglist);
165f37bc 9887 list = chainon (rlist, list);
de0b553f
APB		 9888 search_not_done--;
9889 }
9890
9891 /* We're done. Reset the searched interfaces list and finally search
9892 java.lang.Object */
9893 if (!search_not_done)
9894 {
165f37bc
APB		 9895 if (!object_done)
9896 search_applicable_methods_list (lc,
9897 TYPE_METHODS (object_type_node),
9898 name, arglist, &list, &all_list);
e0422ed0
APB		 9899 hash_table_free (searched_interfaces);
9900 searched_interfaces = NULL;
e04a16fb 9901 }
e04a16fb 9902 }
1982388a
APB		 9903 /* Search classes */
9904 else
c2952b01 9905 {
165f37bc
APB		 9906 tree sc = class;
9907 int seen_inner_class = 0;
c2952b01
APB		 9908 search_applicable_methods_list (lc, TYPE_METHODS (class),
9909 name, arglist, &list, &all_list);
9910
165f37bc
APB		 9911 /* We must search all interfaces of this class */
9912 if (!lc)
9913 {
9914 tree basetype_vec = TYPE_BINFO_BASETYPES (sc);
9915 int n = TREE_VEC_LENGTH (basetype_vec), i;
9916 object_done = 1;
9917 for (i = 1; i < n; i++)
9918 {
9919 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
9920 tree rlist;
9921 if (t != object_type_node)
9922 rlist = find_applicable_accessible_methods_list (lc, t,
9923 name, arglist);
9924 list = chainon (rlist, list);
9925 }
9926 object_done = 0;
9927 }
9928
c2952b01
APB		 9929 /* Search enclosing context of inner classes before looking
9930 ancestors up. */
9931 while (!lc && INNER_CLASS_TYPE_P (class))
9932 {
165f37bc
APB		 9933 tree rlist;
9934 seen_inner_class = 1;
c2952b01 9935 class = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
165f37bc
APB		 9936 rlist = find_applicable_accessible_methods_list (lc, class,
9937 name, arglist);
9938 list = chainon (rlist, list);
c2952b01 9939 }
165f37bc
APB		 9940
9941 if (!lc && seen_inner_class
9942 && TREE_TYPE (DECL_CONTEXT (TYPE_NAME (sc))) == CLASSTYPE_SUPER (sc))
9943 class = CLASSTYPE_SUPER (sc);
9944 else
9945 class = sc;
9946
9947 for (class = (lc ? NULL_TREE : CLASSTYPE_SUPER (class));
9948 class; class = CLASSTYPE_SUPER (class))
9949 search_applicable_methods_list (lc, TYPE_METHODS (class),
9950 name, arglist, &list, &all_list);
c2952b01 9951 }
1982388a 9952
b67d701b
PB		 9953 /* Either return the list obtained or all selected (but
9954 inaccessible) methods for better error report. */
9955 return (!list ? all_list : list);
9956}
e04a16fb 9957
1982388a
APB		 9958/* Effectively search for the approriate method in method */
9959
9960static void
c2952b01 9961search_applicable_methods_list (lc, method, name, arglist, list, all_list)
1982388a
APB		 9962 int lc;
9963 tree method, name, arglist;
9964 tree *list, *all_list;
9965{
9966 for (; method; method = TREE_CHAIN (method))
9967 {
9968 /* When dealing with constructor, stop here, otherwise search
9969 other classes */
9970 if (lc && !DECL_CONSTRUCTOR_P (method))
9971 continue;
9972 else if (!lc && (DECL_CONSTRUCTOR_P (method)
9973 || (GET_METHOD_NAME (method) != name)))
9974 continue;
9975
9976 if (argument_types_convertible (method, arglist))
9977 {
9978 /* Retain accessible methods only */
9979 if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
9980 method, 0))
9981 *list = tree_cons (NULL_TREE, method, *list);
9982 else
9983 /* Also retain all selected method here */
9984 *all_list = tree_cons (NULL_TREE, method, *list);
9985 }
9986 }
9987}
9988
b67d701b
PB		 9989/* 15.11.2.2 Choose the Most Specific Method */
9990
9991static tree
9992find_most_specific_methods_list (list)
9993 tree list;
9994{
9995 int max = 0;
9996 tree current, new_list = NULL_TREE;
9997 for (current = list; current; current = TREE_CHAIN (current))
e04a16fb 9998 {
b67d701b
PB		 9999 tree method;
10000 DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
10001
10002 for (method = list; method; method = TREE_CHAIN (method))
10003 {
10004 /* Don't test a method against itself */
10005 if (method == current)
10006 continue;
10007
10008 /* Compare arguments and location where method where declared */
10009 if (argument_types_convertible (TREE_VALUE (method),
10010 TREE_VALUE (current))
10011 && valid_method_invocation_conversion_p
10012 (DECL_CONTEXT (TREE_VALUE (method)),
10013 DECL_CONTEXT (TREE_VALUE (current))))
10014 {
10015 int v = ++DECL_SPECIFIC_COUNT (TREE_VALUE (current));
10016 max = (v > max ? v : max);
10017 }
10018 }
e04a16fb
AG		 10019 }
10020
b67d701b
PB		 10021 /* Review the list and select the maximally specific methods */
10022 for (current = list; current; current = TREE_CHAIN (current))
10023 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
10024 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
10025
165f37bc
APB		 10026 /* If we have several and they're all abstract, just pick the
10027 closest one. */
10028
10029 if (new_list && TREE_CHAIN (new_list))
10030 {
10031 tree c;
10032 for (c = new_list; c && METHOD_ABSTRACT (TREE_VALUE (c));
10033 c = TREE_CHAIN (c))
10034 ;
10035 if (!c)
10036 {
10037 new_list = nreverse (new_list);
10038 TREE_CHAIN (new_list) = NULL_TREE;
10039 }
10040 }
10041
b67d701b
PB		 10042 /* If we can't find one, lower expectations and try to gather multiple
10043 maximally specific methods */
165f37bc 10044 while (!new_list && max)
b67d701b
PB		 10045 {
10046 while (--max > 0)
10047 {
10048 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
10049 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
10050 }
b67d701b
PB		 10051 }
10052
10053 return new_list;
e04a16fb
AG		 10054}
10055
b67d701b
PB		 10056/* Make sure that the type of each M2_OR_ARGLIST arguments can be
10057 converted by method invocation conversion (5.3) to the type of the
10058 corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
10059 to change less often than M1. */
e04a16fb 10060
b67d701b
PB		 10061static int
10062argument_types_convertible (m1, m2_or_arglist)
10063 tree m1, m2_or_arglist;
e04a16fb 10064{
b67d701b
PB		 10065 static tree m2_arg_value = NULL_TREE;
10066 static tree m2_arg_cache = NULL_TREE;
e04a16fb 10067
b67d701b 10068 register tree m1_arg, m2_arg;
e04a16fb 10069
c2952b01 10070 SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
e04a16fb 10071
b67d701b
PB		 10072 if (m2_arg_value == m2_or_arglist)
10073 m2_arg = m2_arg_cache;
10074 else
10075 {
10076 /* M2_OR_ARGLIST can be a function DECL or a raw list of
10077 argument types */
10078 if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
10079 {
10080 m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
10081 if (!METHOD_STATIC (m2_or_arglist))
10082 m2_arg = TREE_CHAIN (m2_arg);
10083 }
10084 else
10085 m2_arg = m2_or_arglist;
e04a16fb 10086
b67d701b
PB		 10087 m2_arg_value = m2_or_arglist;
10088 m2_arg_cache = m2_arg;
10089 }
e04a16fb 10090
de4c7b02 10091 while (m1_arg != end_params_node && m2_arg != end_params_node)
b67d701b 10092 {
c877974e 10093 resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
b67d701b
PB		 10094 if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
10095 TREE_VALUE (m2_arg)))
10096 break;
10097 m1_arg = TREE_CHAIN (m1_arg);
10098 m2_arg = TREE_CHAIN (m2_arg);
e04a16fb 10099 }
de4c7b02 10100 return m1_arg == end_params_node && m2_arg == end_params_node;
e04a16fb
AG		 10101}
10102
10103/* Qualification routines */
10104
10105static void
10106qualify_ambiguous_name (id)
10107 tree id;
10108{
cd531a2e
KG		 10109 tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
10110 saved_current_class;
d8fccff5 10111 int again, super_found = 0, this_found = 0, new_array_found = 0;
8576f094 10112 int code;
e04a16fb
AG		 10113
10114 /* We first qualify the first element, then derive qualification of
10115 others based on the first one. If the first element is qualified
10116 by a resolution (field or type), this resolution is stored in the
10117 QUAL_RESOLUTION of the qual element being examined. We need to
10118 save the current_class since the use of SUPER might change the
10119 its value. */
10120 saved_current_class = current_class;
10121 qual = EXPR_WFL_QUALIFICATION (id);
10122 do {
10123
10124 /* Simple qualified expression feature a qual_wfl that is a
10125 WFL. Expression derived from a primary feature more complicated
10126 things like a CALL_EXPR. Expression from primary need to be
10127 worked out to extract the part on which the qualification will
10128 take place. */
10129 qual_wfl = QUAL_WFL (qual);
10130 switch (TREE_CODE (qual_wfl))
10131 {
10132 case CALL_EXPR:
10133 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10134 if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
10135 {
10136 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
10137 qual_wfl = QUAL_WFL (qual);
10138 }
10139 break;
d8fccff5 10140 case NEW_ARRAY_EXPR:
c2952b01 10141 case NEW_ANONYMOUS_ARRAY_EXPR:
d8fccff5 10142 qual = TREE_CHAIN (qual);
1a6d4fb7 10143 again = new_array_found = 1;
d8fccff5 10144 continue;
b67d701b 10145 case NEW_CLASS_EXPR:
e04a16fb 10146 case CONVERT_EXPR:
e04a16fb
AG		 10147 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10148 break;
c583dd46
APB		 10149 case ARRAY_REF:
10150 while (TREE_CODE (qual_wfl) == ARRAY_REF)
10151 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10152 break;
8576f094
APB		 10153 case STRING_CST:
10154 qual = TREE_CHAIN (qual);
10155 qual_wfl = QUAL_WFL (qual);
10156 break;
165f37bc
APB		 10157 case CLASS_LITERAL:
10158 qual = TREE_CHAIN (qual);
10159 qual_wfl = QUAL_WFL (qual);
10160 break;
0a2138e2
APB		 10161 default:
10162 /* Fix for -Wall. Just break doing nothing */
10163 break;
e04a16fb 10164 }
8576f094 10165
e04a16fb
AG		 10166 ptr_type = current_class;
10167 again = 0;
8576f094
APB		 10168 code = TREE_CODE (qual_wfl);
10169
10170 /* Pos evaluation: non WFL leading expression nodes */
10171 if (code == CONVERT_EXPR
10172 && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
10173 name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
10174
cd7c5840
APB		 10175 else if (code == INTEGER_CST)
10176 name = qual_wfl;
10177
ac22f9cb 10178 else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
8576f094
APB		 10179 TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
10180 name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
10181
c2952b01
APB		 10182 else if (code == TREE_LIST)
10183 name = EXPR_WFL_NODE (TREE_PURPOSE (qual_wfl));
10184
37feda7d
APB		 10185 else if (code == STRING_CST || code == CONDITIONAL_EXPR
10186 || code == PLUS_EXPR)
8576f094
APB		 10187 {
10188 qual = TREE_CHAIN (qual);
10189 qual_wfl = QUAL_WFL (qual);
10190 again = 1;
10191 }
10192 else
f441f671
APB		 10193 {
10194 name = EXPR_WFL_NODE (qual_wfl);
10195 if (!name)
10196 {
10197 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
10198 again = 1;
10199 }
10200 }
10201
e04a16fb
AG		 10202 /* If we have a THIS (from a primary), we set the context accordingly */
10203 if (name == this_identifier_node)
10204 {
10205 qual = TREE_CHAIN (qual);
10206 qual_wfl = QUAL_WFL (qual);
22eed1e6
APB		 10207 if (TREE_CODE (qual_wfl) == CALL_EXPR)
10208 again = 1;
10209 else
10210 name = EXPR_WFL_NODE (qual_wfl);
e04a16fb
AG		 10211 this_found = 1;
10212 }
10213 /* If we have a SUPER, we set the context accordingly */
10214 if (name == super_identifier_node)
10215 {
10216 current_class = CLASSTYPE_SUPER (ptr_type);
10217 /* Check that there is such a thing as a super class. If not,
10218 return. The error will be caught later on, during the
10219 resolution */
10220 if (!current_class)
10221 {
10222 current_class = saved_current_class;
10223 return;
10224 }
10225 qual = TREE_CHAIN (qual);
10226 /* Do one more interation to set things up */
10227 super_found = again = 1;
10228 }
10229 } while (again);
10230
10231 /* If name appears within the scope of a location variable
10232 declaration or parameter declaration, then it is an expression
10233 name. We don't carry this test out if we're in the context of the
10234 use of SUPER or THIS */
cd7c5840
APB		 10235 if (!this_found && !super_found
10236 && TREE_CODE (name) != STRING_CST && TREE_CODE (name) != INTEGER_CST
10237 && (decl = IDENTIFIER_LOCAL_VALUE (name)))
e04a16fb
AG		 10238 {
10239 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
10240 QUAL_RESOLUTION (qual) = decl;
10241 }
10242
10243 /* If within the class/interface NAME was found to be used there
10244 exists a (possibly inherited) field named NAME, then this is an
d8fccff5
APB		 10245 expression name. If we saw a NEW_ARRAY_EXPR before and want to
10246 address length, it is OK. */
10247 else if ((decl = lookup_field_wrapper (ptr_type, name))
10248 || (new_array_found && name == length_identifier_node))
e04a16fb
AG		 10249 {
10250 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
d8fccff5 10251 QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
e04a16fb
AG		 10252 }
10253
1a6d4fb7 10254 /* We reclassify NAME as yielding to a type name resolution if:
e04a16fb
AG		 10255 - NAME is a class/interface declared within the compilation
10256 unit containing NAME,
10257 - NAME is imported via a single-type-import declaration,
10258 - NAME is declared in an another compilation unit of the package
10259 of the compilation unit containing NAME,
10260 - NAME is declared by exactly on type-import-on-demand declaration
1a6d4fb7
APB		 10261 of the compilation unit containing NAME.
10262 - NAME is actually a STRING_CST. */
cd7c5840
APB		 10263 else if (TREE_CODE (name) == STRING_CST || TREE_CODE (name) == INTEGER_CST
10264 || (decl = resolve_and_layout (name, NULL_TREE)))
e04a16fb
AG		 10265 {
10266 RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
10267 QUAL_RESOLUTION (qual) = decl;
10268 }
10269
10270 /* Method call are expression name */
9bbc7d9f 10271 else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
8576f094
APB		 10272 || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
10273 || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR)
e04a16fb
AG		 10274 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
10275
10276 /* Check here that NAME isn't declared by more than one
10277 type-import-on-demand declaration of the compilation unit
10278 containing NAME. FIXME */
10279
10280 /* Otherwise, NAME is reclassified as a package name */
10281 else
10282 RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
10283
10284 /* Propagate the qualification accross other components of the
10285 qualified name */
10286 for (qual = TREE_CHAIN (qual); qual;
10287 qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
10288 {
10289 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
10290 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
10291 else
10292 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
10293 }
10294
10295 /* Store the global qualification for the ambiguous part of ID back
10296 into ID fields */
10297 if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
10298 RESOLVE_EXPRESSION_NAME_P (id) = 1;
10299 else if (RESOLVE_TYPE_NAME_P (qual_wfl))
10300 RESOLVE_TYPE_NAME_P (id) = 1;
10301 else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
10302 RESOLVE_PACKAGE_NAME_P (id) = 1;
10303
10304 /* Restore the current class */
10305 current_class = saved_current_class;
10306}
10307
10308static int
10309breakdown_qualified (left, right, source)
10310 tree *left, *right, source;
10311{
10312 char *p = IDENTIFIER_POINTER (source), *base;
10313 int l = IDENTIFIER_LENGTH (source);
10314
10315 /* Breakdown NAME into REMAINDER . IDENTIFIER */
10316 base = p;
10317 p += (l-1);
10318 while (*p != '.' && p != base)
10319 p--;
10320
10321 /* We didn't find a '.'. Return an error */
10322 if (p == base)
10323 return 1;
10324
10325 *p = '\0';
10326 if (right)
10327 *right = get_identifier (p+1);
10328 *left = get_identifier (IDENTIFIER_POINTER (source));
10329 *p = '.';
10330
10331 return 0;
10332}
10333
e04a16fb 10334/* Patch tree nodes in a function body. When a BLOCK is found, push
5b09b33e
PB		 10335 local variable decls if present.
10336 Same as java_complete_lhs, but does resolve static finals to values. */
e04a16fb
AG		 10337
10338static tree
10339java_complete_tree (node)
10340 tree node;
5b09b33e
PB		 10341{
10342 node = java_complete_lhs (node);
10343 if (TREE_CODE (node) == VAR_DECL && FIELD_STATIC (node)
7f10c2e2
APB		 10344 && FIELD_FINAL (node) && DECL_INITIAL (node) != NULL_TREE
10345 && !flag_emit_xref)
5b09b33e
PB		 10346 {
10347 tree value = DECL_INITIAL (node);
10348 DECL_INITIAL (node) = NULL_TREE;
100f7cd8 10349 push_obstacks (&permanent_obstack, &permanent_obstack);
5b09b33e 10350 value = fold_constant_for_init (value, node);
100f7cd8 10351 pop_obstacks ();
5b09b33e
PB		 10352 DECL_INITIAL (node) = value;
10353 if (value != NULL_TREE)
c2952b01
APB		 10354 {
10355 /* fold_constant_for_init sometimes widen the original type
10356 of the constant (i.e. byte to int.) It's not desirable,
10357 especially if NODE is a function argument. */
10358 if (TREE_CODE (value) == INTEGER_CST
10359 && TREE_TYPE (node) != TREE_TYPE (value))
10360 return convert (TREE_TYPE (node), value);
10361 else
10362 return value;
10363 }
5b09b33e
PB		 10364 }
10365 return node;
10366}
10367
2aa11e97
APB		 10368static tree
10369java_stabilize_reference (node)
10370 tree node;
10371{
10372 if (TREE_CODE (node) == COMPOUND_EXPR)
10373 {
10374 tree op0 = TREE_OPERAND (node, 0);
10375 tree op1 = TREE_OPERAND (node, 1);
642f15d1 10376 TREE_OPERAND (node, 0) = save_expr (op0);
2aa11e97
APB		 10377 TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
10378 return node;
10379 }
5cbdba64 10380 return stabilize_reference (node);
2aa11e97
APB		 10381}
10382
5b09b33e
PB		 10383/* Patch tree nodes in a function body. When a BLOCK is found, push
10384 local variable decls if present.
10385 Same as java_complete_tree, but does not resolve static finals to values. */
10386
10387static tree
10388java_complete_lhs (node)
10389 tree node;
e04a16fb 10390{
22eed1e6 10391 tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
b67d701b 10392 int flag;
e04a16fb
AG		 10393
10394 /* CONVERT_EXPR always has its type set, even though it needs to be
b67d701b 10395 worked out. */
e04a16fb
AG		 10396 if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
10397 return node;
10398
10399 /* The switch block implements cases processing container nodes
10400 first. Contained nodes are always written back. Leaves come
10401 next and return a value. */
10402 switch (TREE_CODE (node))
10403 {
10404 case BLOCK:
10405
10406 /* 1- Block section.
10407 Set the local values on decl names so we can identify them
10408 faster when they're referenced. At that stage, identifiers
10409 are legal so we don't check for declaration errors. */
10410 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
10411 {
10412 DECL_CONTEXT (cn) = current_function_decl;
10413 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
e04a16fb 10414 }
15fdcfe9
PB		 10415 if (BLOCK_EXPR_BODY (node) == NULL_TREE)
10416 CAN_COMPLETE_NORMALLY (node) = 1;
10417 else
e04a16fb 10418 {
15fdcfe9
PB		 10419 tree stmt = BLOCK_EXPR_BODY (node);
10420 tree *ptr;
10421 int error_seen = 0;
10422 if (TREE_CODE (stmt) == COMPOUND_EXPR)
10423 {
c877974e
APB		 10424 /* Re-order from (((A; B); C); ...; Z) to
10425 (A; (B; (C ; (...; Z)))).
15fdcfe9
PB		 10426 This makes it easier to scan the statements left-to-right
10427 without using recursion (which might overflow the stack
10428 if the block has many statements. */
10429 for (;;)
10430 {
10431 tree left = TREE_OPERAND (stmt, 0);
10432 if (TREE_CODE (left) != COMPOUND_EXPR)
10433 break;
10434 TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
10435 TREE_OPERAND (left, 1) = stmt;
10436 stmt = left;
10437 }
10438 BLOCK_EXPR_BODY (node) = stmt;
10439 }
10440
c877974e
APB		 10441 /* Now do the actual complete, without deep recursion for
10442 long blocks. */
15fdcfe9 10443 ptr = &BLOCK_EXPR_BODY (node);
dc0b3eff
PB		 10444 while (TREE_CODE (*ptr) == COMPOUND_EXPR
10445 && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
15fdcfe9
PB		 10446 {
10447 tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
10448 tree *next = &TREE_OPERAND (*ptr, 1);
10449 TREE_OPERAND (*ptr, 0) = cur;
cd9643f7
PB		 10450 if (cur == empty_stmt_node)
10451 {
10452 /* Optimization; makes it easier to detect empty bodies.
10453 Most useful for <clinit> with all-constant initializer. */
10454 *ptr = *next;
10455 continue;
10456 }
15fdcfe9
PB		 10457 if (TREE_CODE (cur) == ERROR_MARK)
10458 error_seen++;
10459 else if (! CAN_COMPLETE_NORMALLY (cur))
10460 {
10461 wfl_op2 = *next;
10462 for (;;)
10463 {
10464 if (TREE_CODE (wfl_op2) == BLOCK)
10465 wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
10466 else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
10467 wfl_op2 = TREE_OPERAND (wfl_op2, 0);
10468 else
10469 break;
10470 }
10471 if (TREE_CODE (wfl_op2) != CASE_EXPR
dc0b3eff 10472 && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
82371d41 10473 unreachable_stmt_error (*ptr);
15fdcfe9
PB		 10474 }
10475 ptr = next;
10476 }
10477 *ptr = java_complete_tree (*ptr);
10478
10479 if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
e04a16fb 10480 return error_mark_node;
15fdcfe9 10481 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
e04a16fb
AG		 10482 }
10483 /* Turn local bindings to null */
10484 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
10485 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
10486
10487 TREE_TYPE (node) = void_type_node;
10488 break;
10489
10490 /* 2- They are expressions but ultimately deal with statements */
b67d701b 10491
b9f7e36c
APB		 10492 case THROW_EXPR:
10493 wfl_op1 = TREE_OPERAND (node, 0);
10494 COMPLETE_CHECK_OP_0 (node);
c2952b01
APB		 10495 /* 14.19 A throw statement cannot complete normally. */
10496 CAN_COMPLETE_NORMALLY (node) = 0;
b9f7e36c
APB		 10497 return patch_throw_statement (node, wfl_op1);
10498
10499 case SYNCHRONIZED_EXPR:
10500 wfl_op1 = TREE_OPERAND (node, 0);
b9f7e36c
APB		 10501 return patch_synchronized_statement (node, wfl_op1);
10502
b67d701b
PB		 10503 case TRY_EXPR:
10504 return patch_try_statement (node);
10505
a7d8d81f
PB		 10506 case TRY_FINALLY_EXPR:
10507 COMPLETE_CHECK_OP_0 (node);
10508 COMPLETE_CHECK_OP_1 (node);
10509 CAN_COMPLETE_NORMALLY (node)
10510 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
10511 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
10512 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
10513 return node;
10514
5a005d9e
PB		 10515 case CLEANUP_POINT_EXPR:
10516 COMPLETE_CHECK_OP_0 (node);
10517 TREE_TYPE (node) = void_type_node;
2aa11e97
APB		 10518 CAN_COMPLETE_NORMALLY (node) =
10519 CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
5a005d9e
PB		 10520 return node;
10521
10522 case WITH_CLEANUP_EXPR:
10523 COMPLETE_CHECK_OP_0 (node);
10524 COMPLETE_CHECK_OP_2 (node);
2aa11e97
APB		 10525 CAN_COMPLETE_NORMALLY (node) =
10526 CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
5a005d9e
PB		 10527 TREE_TYPE (node) = void_type_node;
10528 return node;
10529
e04a16fb
AG		 10530 case LABELED_BLOCK_EXPR:
10531 PUSH_LABELED_BLOCK (node);
10532 if (LABELED_BLOCK_BODY (node))
10533 COMPLETE_CHECK_OP_1 (node);
10534 TREE_TYPE (node) = void_type_node;
10535 POP_LABELED_BLOCK ();
1fb89a4d
APB		 10536
10537 if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
9dd939b2
APB		 10538 {
10539 LABELED_BLOCK_BODY (node) = NULL_TREE;
10540 CAN_COMPLETE_NORMALLY (node) = 1;
10541 }
1fb89a4d 10542 else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
15fdcfe9 10543 CAN_COMPLETE_NORMALLY (node) = 1;
e04a16fb
AG		 10544 return node;
10545
10546 case EXIT_BLOCK_EXPR:
10547 /* We don't complete operand 1, because it's the return value of
10548 the EXIT_BLOCK_EXPR which doesn't exist it Java */
10549 return patch_bc_statement (node);
10550
15fdcfe9
PB		 10551 case CASE_EXPR:
10552 cn = java_complete_tree (TREE_OPERAND (node, 0));
10553 if (cn == error_mark_node)
10554 return cn;
10555
8576f094
APB		 10556 /* First, the case expression must be constant. Values of final
10557 fields are accepted. */
15fdcfe9 10558 cn = fold (cn);
8576f094
APB		 10559 if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
10560 && JDECL_P (TREE_OPERAND (cn, 1))
10561 && FIELD_FINAL (TREE_OPERAND (cn, 1))
10562 && DECL_INITIAL (TREE_OPERAND (cn, 1)))
100f7cd8
APB		 10563 {
10564 push_obstacks (&permanent_obstack, &permanent_obstack);
10565 cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
10566 TREE_OPERAND (cn, 1));
10567 pop_obstacks ();
10568 }
15fdcfe9 10569
ce6e9147 10570 if (!TREE_CONSTANT (cn) && !flag_emit_xref)
15fdcfe9
PB		 10571 {
10572 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10573 parse_error_context (node, "Constant expression required");
10574 return error_mark_node;
10575 }
10576
10577 nn = ctxp->current_loop;
10578
10579 /* It must be assignable to the type of the switch expression. */
c877974e
APB		 10580 if (!try_builtin_assignconv (NULL_TREE,
10581 TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
15fdcfe9
PB		 10582 {
10583 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10584 parse_error_context
10585 (wfl_operator,
10586 "Incompatible type for case. Can't convert `%s' to `int'",
10587 lang_printable_name (TREE_TYPE (cn), 0));
10588 return error_mark_node;
10589 }
10590
10591 cn = fold (convert (int_type_node, cn));
10592
10593 /* Multiple instance of a case label bearing the same
10594 value is checked during code generation. The case
10595 expression is allright so far. */
10596 TREE_OPERAND (node, 0) = cn;
9bbc7d9f 10597 TREE_TYPE (node) = void_type_node;
15fdcfe9 10598 CAN_COMPLETE_NORMALLY (node) = 1;
10100cc7 10599 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9
PB		 10600 break;
10601
10602 case DEFAULT_EXPR:
10603 nn = ctxp->current_loop;
10604 /* Only one default label is allowed per switch statement */
10605 if (SWITCH_HAS_DEFAULT (nn))
10606 {
10607 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10608 parse_error_context (wfl_operator,
10609 "Duplicate case label: `default'");
10610 return error_mark_node;
10611 }
10612 else
10613 SWITCH_HAS_DEFAULT (nn) = 1;
9bbc7d9f 10614 TREE_TYPE (node) = void_type_node;
10100cc7 10615 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9
PB		 10616 CAN_COMPLETE_NORMALLY (node) = 1;
10617 break;
10618
b67d701b 10619 case SWITCH_EXPR:
e04a16fb
AG		 10620 case LOOP_EXPR:
10621 PUSH_LOOP (node);
10622 /* Check whether the loop was enclosed in a labeled
10623 statement. If not, create one, insert the loop in it and
10624 return the node */
10625 nn = patch_loop_statement (node);
b67d701b 10626
e04a16fb 10627 /* Anyways, walk the body of the loop */
b67d701b
PB		 10628 if (TREE_CODE (node) == LOOP_EXPR)
10629 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10630 /* Switch statement: walk the switch expression and the cases */
10631 else
10632 node = patch_switch_statement (node);
10633
e04a16fb 10634 if (TREE_OPERAND (node, 0) == error_mark_node)
b635eb2f
PB		 10635 nn = error_mark_node;
10636 else
15fdcfe9 10637 {
b635eb2f
PB		 10638 TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
10639 /* If we returned something different, that's because we
10640 inserted a label. Pop the label too. */
10641 if (nn != node)
10642 {
10643 if (CAN_COMPLETE_NORMALLY (node))
10644 CAN_COMPLETE_NORMALLY (nn) = 1;
10645 POP_LABELED_BLOCK ();
10646 }
15fdcfe9 10647 }
e04a16fb
AG		 10648 POP_LOOP ();
10649 return nn;
10650
10651 case EXIT_EXPR:
10652 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10653 return patch_exit_expr (node);
10654
10655 case COND_EXPR:
10656 /* Condition */
10657 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10658 if (TREE_OPERAND (node, 0) == error_mark_node)
10659 return error_mark_node;
10660 /* then-else branches */
10661 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
10662 if (TREE_OPERAND (node, 1) == error_mark_node)
10663 return error_mark_node;
10664 TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
10665 if (TREE_OPERAND (node, 2) == error_mark_node)
10666 return error_mark_node;
10667 return patch_if_else_statement (node);
10668 break;
10669
22eed1e6
APB		 10670 case CONDITIONAL_EXPR:
10671 /* Condition */
10672 wfl_op1 = TREE_OPERAND (node, 0);
10673 COMPLETE_CHECK_OP_0 (node);
10674 wfl_op2 = TREE_OPERAND (node, 1);
10675 COMPLETE_CHECK_OP_1 (node);
10676 wfl_op3 = TREE_OPERAND (node, 2);
10677 COMPLETE_CHECK_OP_2 (node);
10678 return patch_conditional_expr (node, wfl_op1, wfl_op2);
10679
e04a16fb
AG		 10680 /* 3- Expression section */
10681 case COMPOUND_EXPR:
15fdcfe9 10682 wfl_op2 = TREE_OPERAND (node, 1);
ac825856
APB		 10683 TREE_OPERAND (node, 0) = nn =
10684 java_complete_tree (TREE_OPERAND (node, 0));
dc0b3eff
PB		 10685 if (wfl_op2 == empty_stmt_node)
10686 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
10687 else
15fdcfe9 10688 {
dc0b3eff 10689 if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
bccaf73a 10690 {
dc0b3eff
PB		 10691 /* An unreachable condition in a do-while statement
10692 is *not* (technically) an unreachable statement. */
10693 nn = wfl_op2;
10694 if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
10695 nn = EXPR_WFL_NODE (nn);
10696 if (TREE_CODE (nn) != EXIT_EXPR)
10697 {
10698 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
10699 parse_error_context (wfl_operator, "Unreachable statement");
10700 }
bccaf73a 10701 }
dc0b3eff
PB		 10702 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
10703 if (TREE_OPERAND (node, 1) == error_mark_node)
10704 return error_mark_node;
10705 CAN_COMPLETE_NORMALLY (node)
10706 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1));
15fdcfe9 10707 }
e04a16fb
AG		 10708 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
10709 break;
10710
10711 case RETURN_EXPR:
15fdcfe9 10712 /* CAN_COMPLETE_NORMALLY (node) = 0; */
e04a16fb
AG		 10713 return patch_return (node);
10714
10715 case EXPR_WITH_FILE_LOCATION:
10716 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
10717 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
15fdcfe9 10718 {
5423609c 10719 tree wfl = node;
15fdcfe9 10720 node = resolve_expression_name (node, NULL);
dc0b3eff
PB		 10721 if (node == error_mark_node)
10722 return node;
5423609c
APB		 10723 /* Keep line number information somewhere were it doesn't
10724 disrupt the completion process. */
2c56429a 10725 if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
5423609c
APB		 10726 {
10727 EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
10728 TREE_OPERAND (node, 1) = wfl;
10729 }
15fdcfe9
PB		 10730 CAN_COMPLETE_NORMALLY (node) = 1;
10731 }
e04a16fb
AG		 10732 else
10733 {
5b09b33e
PB		 10734 tree body;
10735 int save_lineno = lineno;
10736 lineno = EXPR_WFL_LINENO (node);
10737 body = java_complete_tree (EXPR_WFL_NODE (node));
10738 lineno = save_lineno;
15fdcfe9 10739 EXPR_WFL_NODE (node) = body;
dc0b3eff 10740 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
15fdcfe9 10741 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
cd9643f7
PB		 10742 if (body == empty_stmt_node)
10743 {
10744 /* Optimization; makes it easier to detect empty bodies. */
10745 return body;
10746 }
dc0b3eff 10747 if (body == error_mark_node)
e04a16fb
AG		 10748 {
10749 /* Its important for the evaluation of assignment that
10750 this mark on the TREE_TYPE is propagated. */
10751 TREE_TYPE (node) = error_mark_node;
10752 return error_mark_node;
10753 }
10754 else
10755 TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
15fdcfe9 10756
e04a16fb
AG		 10757 }
10758 break;
10759
b67d701b 10760 case NEW_ARRAY_EXPR:
e04a16fb
AG		 10761 /* Patch all the dimensions */
10762 flag = 0;
10763 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
10764 {
10765 int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
3a1760ac
APB		 10766 tree dim = convert (int_type_node,
10767 java_complete_tree (TREE_VALUE (cn)));
e04a16fb
AG		 10768 if (dim == error_mark_node)
10769 {
10770 flag = 1;
10771 continue;
10772 }
10773 else
10774 {
b9f7e36c 10775 TREE_VALUE (cn) = dim;
e04a16fb
AG		 10776 /* Setup the location of the current dimension, for
10777 later error report. */
10778 TREE_PURPOSE (cn) =
10779 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
10780 EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
10781 }
10782 }
10783 /* They complete the array creation expression, if no errors
10784 were found. */
15fdcfe9 10785 CAN_COMPLETE_NORMALLY (node) = 1;
aee48ef8
PB		 10786 return (flag ? error_mark_node
10787 : force_evaluation_order (patch_newarray (node)));
e04a16fb 10788
c2952b01
APB		 10789 case NEW_ANONYMOUS_ARRAY_EXPR:
10790 /* Create the array type if necessary. */
10791 if (ANONYMOUS_ARRAY_DIMS_SIG (node))
10792 {
10793 tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
10794 if (!(type = resolve_type_during_patch (type)))
10795 return error_mark_node;
10796 type = build_array_from_name (type, NULL_TREE,
10797 ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
10798 ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
10799 }
10800 node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
10801 ANONYMOUS_ARRAY_INITIALIZER (node));
10802 if (node == error_mark_node)
10803 return error_mark_node;
10804 CAN_COMPLETE_NORMALLY (node) = 1;
10805 return node;
10806
b67d701b 10807 case NEW_CLASS_EXPR:
e04a16fb 10808 case CALL_EXPR:
b67d701b 10809 /* Complete function's argument(s) first */
e04a16fb
AG		 10810 if (complete_function_arguments (node))
10811 return error_mark_node;
10812 else
b9f7e36c 10813 {
22eed1e6
APB		 10814 tree decl, wfl = TREE_OPERAND (node, 0);
10815 int in_this = CALL_THIS_CONSTRUCTOR_P (node);
10816
c877974e 10817 node = patch_method_invocation (node, NULL_TREE,
89e09b9a 10818 NULL_TREE, 0, &decl);
c877974e
APB		 10819 if (node == error_mark_node)
10820 return error_mark_node;
10821
10822 check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
10823 /* If we call this(...), register signature and positions */
10824 if (in_this)
10825 DECL_CONSTRUCTOR_CALLS (current_function_decl) =
10826 tree_cons (wfl, decl,
10827 DECL_CONSTRUCTOR_CALLS (current_function_decl));
de4c7b02 10828 CAN_COMPLETE_NORMALLY (node) = 1;
dc0b3eff 10829 return force_evaluation_order (node);
b9f7e36c 10830 }
e04a16fb
AG		 10831
10832 case MODIFY_EXPR:
10833 /* Save potential wfls */
10834 wfl_op1 = TREE_OPERAND (node, 0);
cd9643f7 10835 TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
c2952b01 10836
cd9643f7
PB		 10837 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
10838 && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
10839 && DECL_INITIAL (nn) != NULL_TREE)
10840 {
100f7cd8
APB		 10841 tree value;
10842
10843 push_obstacks (&permanent_obstack, &permanent_obstack);
10844 value = fold_constant_for_init (nn, nn);
10845 pop_obstacks ();
c2952b01 10846
cd9643f7
PB		 10847 if (value != NULL_TREE)
10848 {
10849 tree type = TREE_TYPE (value);
c2952b01
APB		 10850 if (JPRIMITIVE_TYPE_P (type) ||
10851 (type == string_ptr_type_node && ! flag_emit_class_files))
cd9643f7
PB		 10852 return empty_stmt_node;
10853 }
10854 DECL_INITIAL (nn) = NULL_TREE;
10855 }
e04a16fb 10856 wfl_op2 = TREE_OPERAND (node, 1);
cd9643f7 10857
e04a16fb
AG		 10858 if (TREE_OPERAND (node, 0) == error_mark_node)
10859 return error_mark_node;
10860
5cbdba64
APB		 10861 flag = COMPOUND_ASSIGN_P (wfl_op2);
10862 if (flag)
e04a16fb 10863 {
c2952b01
APB		 10864 /* This might break when accessing outer field from inner
10865 class. TESTME, FIXME */
2aa11e97 10866 tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
e04a16fb
AG		 10867
10868 /* Hand stablize the lhs on both places */
e04a16fb 10869 TREE_OPERAND (node, 0) = lvalue;
5cbdba64
APB		 10870 TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
10871 (flag_emit_class_files ? lvalue : save_expr (lvalue));
2aa11e97 10872
5cbdba64 10873 /* 15.25.2.a: Left hand is not an array access. FIXME */
2aa11e97
APB		 10874 /* Now complete the RHS. We write it back later on. */
10875 nn = java_complete_tree (TREE_OPERAND (node, 1));
10876
642f15d1
APB		 10877 if ((cn = patch_string (nn)))
10878 nn = cn;
10879
2aa11e97
APB		 10880 /* The last part of the rewrite for E1 op= E2 is to have
10881 E1 = (T)(E1 op E2), with T being the type of E1. */
642f15d1
APB		 10882 nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
10883 TREE_TYPE (lvalue), nn));
5cbdba64
APB		 10884
10885 /* 15.25.2.b: Left hand is an array access. FIXME */
e04a16fb
AG		 10886 }
10887
f8976021 10888 /* If we're about to patch a NEW_ARRAY_INIT, we call a special
c2952b01
APB		 10889 function to complete this RHS. Note that a NEW_ARRAY_INIT
10890 might have been already fully expanded if created as a result
10891 of processing an anonymous array initializer. We avoid doing
10892 the operation twice by testing whether the node already bears
10893 a type. */
10894 else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
fdec99c6 10895 nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
f8976021 10896 TREE_OPERAND (node, 1));
2aa11e97 10897 /* Otherwise we simply complete the RHS */
f8976021
APB		 10898 else
10899 nn = java_complete_tree (TREE_OPERAND (node, 1));
10900
e04a16fb 10901 if (nn == error_mark_node)
c0d87ff6 10902 return error_mark_node;
2aa11e97
APB		 10903
10904 /* Write back the RHS as we evaluated it. */
e04a16fb 10905 TREE_OPERAND (node, 1) = nn;
b67d701b
PB		 10906
10907 /* In case we're handling = with a String as a RHS, we need to
10908 produce a String out of the RHS (it might still be a
10909 STRING_CST or a StringBuffer at this stage */
10910 if ((nn = patch_string (TREE_OPERAND (node, 1))))
10911 TREE_OPERAND (node, 1) = nn;
c2952b01
APB		 10912
10913 if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
10914 TREE_OPERAND (node, 1))))
10915 {
10916 /* We return error_mark_node if outer_field_access_fix
10917 detects we write into a final. */
10918 if (nn == error_mark_node)
10919 return error_mark_node;
10920 node = nn;
10921 }
10922 else
10923 {
10924 node = patch_assignment (node, wfl_op1, wfl_op2);
10925 /* Reorganize the tree if necessary. */
10926 if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
10927 || JSTRING_P (TREE_TYPE (node))))
10928 node = java_refold (node);
10929 }
10930
15fdcfe9
PB		 10931 CAN_COMPLETE_NORMALLY (node) = 1;
10932 return node;
e04a16fb
AG		 10933
10934 case MULT_EXPR:
10935 case PLUS_EXPR:
10936 case MINUS_EXPR:
10937 case LSHIFT_EXPR:
10938 case RSHIFT_EXPR:
10939 case URSHIFT_EXPR:
10940 case BIT_AND_EXPR:
10941 case BIT_XOR_EXPR:
10942 case BIT_IOR_EXPR:
10943 case TRUNC_MOD_EXPR:
c2952b01 10944 case TRUNC_DIV_EXPR:
e04a16fb
AG		 10945 case RDIV_EXPR:
10946 case TRUTH_ANDIF_EXPR:
10947 case TRUTH_ORIF_EXPR:
10948 case EQ_EXPR:
10949 case NE_EXPR:
10950 case GT_EXPR:
10951 case GE_EXPR:
10952 case LT_EXPR:
10953 case LE_EXPR:
10954 /* Operands 0 and 1 are WFL in certain cases only. patch_binop
10955 knows how to handle those cases. */
10956 wfl_op1 = TREE_OPERAND (node, 0);
10957 wfl_op2 = TREE_OPERAND (node, 1);
b67d701b 10958
15fdcfe9 10959 CAN_COMPLETE_NORMALLY (node) = 1;
b67d701b
PB		 10960 /* Don't complete string nodes if dealing with the PLUS operand. */
10961 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
2aa11e97
APB		 10962 {
10963 nn = java_complete_tree (wfl_op1);
10964 if (nn == error_mark_node)
10965 return error_mark_node;
10966 if ((cn = patch_string (nn)))
10967 nn = cn;
10968 TREE_OPERAND (node, 0) = nn;
10969 }
b67d701b 10970 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
2aa11e97
APB		 10971 {
10972 nn = java_complete_tree (wfl_op2);
10973 if (nn == error_mark_node)
10974 return error_mark_node;
10975 if ((cn = patch_string (nn)))
10976 nn = cn;
10977 TREE_OPERAND (node, 1) = nn;
10978 }
dc0b3eff 10979 return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
e04a16fb 10980
5e942c50
APB		 10981 case INSTANCEOF_EXPR:
10982 wfl_op1 = TREE_OPERAND (node, 0);
10983 COMPLETE_CHECK_OP_0 (node);
ce6e9147
APB		 10984 if (flag_emit_xref)
10985 {
10986 TREE_TYPE (node) = boolean_type_node;
10987 return node;
10988 }
5e942c50
APB		 10989 return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
10990
b67d701b 10991 case UNARY_PLUS_EXPR:
e04a16fb
AG		 10992 case NEGATE_EXPR:
10993 case TRUTH_NOT_EXPR:
10994 case BIT_NOT_EXPR:
10995 case PREDECREMENT_EXPR:
10996 case PREINCREMENT_EXPR:
10997 case POSTDECREMENT_EXPR:
10998 case POSTINCREMENT_EXPR:
10999 case CONVERT_EXPR:
11000 /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
11001 how to handle those cases. */
11002 wfl_op1 = TREE_OPERAND (node, 0);
15fdcfe9 11003 CAN_COMPLETE_NORMALLY (node) = 1;
e04a16fb
AG		 11004 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
11005 if (TREE_OPERAND (node, 0) == error_mark_node)
11006 return error_mark_node;
4a5f66c3
APB		 11007 node = patch_unaryop (node, wfl_op1);
11008 CAN_COMPLETE_NORMALLY (node) = 1;
11009 break;
e04a16fb
AG		 11010
11011 case ARRAY_REF:
11012 /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
11013 how to handle those cases. */
11014 wfl_op1 = TREE_OPERAND (node, 0);
11015 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
11016 if (TREE_OPERAND (node, 0) == error_mark_node)
11017 return error_mark_node;
7f1d4866 11018 if (!flag_emit_class_files && !flag_emit_xref)
b67d701b 11019 TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
e04a16fb
AG		 11020 /* The same applies to wfl_op2 */
11021 wfl_op2 = TREE_OPERAND (node, 1);
11022 TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
11023 if (TREE_OPERAND (node, 1) == error_mark_node)
11024 return error_mark_node;
7f1d4866 11025 if (!flag_emit_class_files && !flag_emit_xref)
22eed1e6 11026 TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
939d7216 11027 return patch_array_ref (node);
e04a16fb 11028
63a212ed
PB		 11029 case RECORD_TYPE:
11030 return node;;
11031
11032 case COMPONENT_REF:
11033 /* The first step in the re-write of qualified name handling. FIXME.
11034 So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
9bbc7d9f 11035 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
63a212ed
PB		 11036 if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
11037 {
11038 tree name = TREE_OPERAND (node, 1);
11039 tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
11040 if (field == NULL_TREE)
11041 {
11042 error ("missing static field `%s'", IDENTIFIER_POINTER (name));
11043 return error_mark_node;
11044 }
11045 if (! FIELD_STATIC (field))
11046 {
11047 error ("not a static field `%s'", IDENTIFIER_POINTER (name));
11048 return error_mark_node;
11049 }
11050 return field;
11051 }
11052 else
11053 fatal ("unimplemented java_complete_tree for COMPONENT_REF");
9bbc7d9f 11054 break;
9bbc7d9f 11055
b67d701b 11056 case THIS_EXPR:
e04a16fb
AG		 11057 /* Can't use THIS in a static environment */
11058 if (!current_this)
11059 {
11060 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
781b0558
KG		 11061 parse_error_context (wfl_operator,
11062 "Keyword `this' used outside allowed context");
e04a16fb
AG		 11063 TREE_TYPE (node) = error_mark_node;
11064 return error_mark_node;
11065 }
22eed1e6
APB		 11066 if (ctxp->explicit_constructor_p)
11067 {
11068 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11069 parse_error_context
781b0558 11070 (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
22eed1e6
APB		 11071 TREE_TYPE (node) = error_mark_node;
11072 return error_mark_node;
11073 }
e04a16fb 11074 return current_this;
c2952b01
APB		 11075
11076 case CLASS_LITERAL:
11077 CAN_COMPLETE_NORMALLY (node) = 1;
11078 node = patch_incomplete_class_ref (node);
11079 if (node == error_mark_node)
11080 return error_mark_node;
11081 break;
11082
11083 case INSTANCE_INITIALIZERS_EXPR:
11084 in_instance_initializer++;
11085 node = java_complete_tree (TREE_OPERAND (node, 0));
11086 in_instance_initializer--;
11087 if (node != error_mark_node)
11088 TREE_TYPE (node) = void_type_node;
11089 else
11090 return error_mark_node;
11091 break;
e04a16fb 11092
e04a16fb 11093 default:
15fdcfe9 11094 CAN_COMPLETE_NORMALLY (node) = 1;
b67d701b 11095 /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
c2952b01
APB		 11096 and it's time to turn it into the appropriate String object */
11097 if ((nn = patch_string (node)))
11098 node = nn;
11099 else
11100 fatal ("No case for tree code `%s' - java_complete_tree\n",
11101 tree_code_name [TREE_CODE (node)]);
e04a16fb
AG		 11102 }
11103 return node;
11104}
11105
11106/* Complete function call's argument. Return a non zero value is an
11107 error was found. */
11108
11109static int
11110complete_function_arguments (node)
11111 tree node;
11112{
11113 int flag = 0;
11114 tree cn;
11115
f63991a8 11116 ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
e04a16fb
AG		 11117 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11118 {
b67d701b 11119 tree wfl = TREE_VALUE (cn), parm, temp;
e04a16fb 11120 parm = java_complete_tree (wfl);
c2952b01 11121
e04a16fb
AG		 11122 if (parm == error_mark_node)
11123 {
11124 flag = 1;
11125 continue;
11126 }
b67d701b
PB		 11127 /* If have a string literal that we haven't transformed yet or a
11128 crafted string buffer, as a result of use of the the String
11129 `+' operator. Build `parm.toString()' and expand it. */
11130 if ((temp = patch_string (parm)))
b9f7e36c 11131 parm = temp;
5e942c50
APB		 11132 /* Inline PRIMTYPE.TYPE read access */
11133 parm = maybe_build_primttype_type_ref (parm, wfl);
b9f7e36c 11134
5e942c50 11135 TREE_VALUE (cn) = parm;
e04a16fb 11136 }
f63991a8 11137 ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
e04a16fb
AG		 11138 return flag;
11139}
11140
11141/* Sometimes (for loops and variable initialized during their
11142 declaration), we want to wrap a statement around a WFL and turn it
11143 debugable. */
11144
11145static tree
11146build_debugable_stmt (location, stmt)
11147 int location;
11148 tree stmt;
11149{
11150 if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
11151 {
11152 stmt = build_expr_wfl (stmt, input_filename, 0, 0);
11153 EXPR_WFL_LINECOL (stmt) = location;
11154 }
11155 JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
11156 return stmt;
11157}
11158
11159static tree
11160build_expr_block (body, decls)
11161 tree body, decls;
11162{
11163 tree node = make_node (BLOCK);
11164 BLOCK_EXPR_DECLS (node) = decls;
b67d701b 11165 BLOCK_EXPR_BODY (node) = body;
e04a16fb
AG		 11166 if (body)
11167 TREE_TYPE (node) = TREE_TYPE (body);
11168 TREE_SIDE_EFFECTS (node) = 1;
11169 return node;
11170}
11171
b67d701b
PB		 11172/* Create a new function block and link it approriately to current
11173 function block chain */
e04a16fb
AG		 11174
11175static tree
11176enter_block ()
11177{
b67d701b
PB		 11178 return (enter_a_block (build_expr_block (NULL_TREE, NULL_TREE)));
11179}
11180
11181/* Link block B supercontext to the previous block. The current
11182 function DECL is used as supercontext when enter_a_block is called
11183 for the first time for a given function. The current function body
11184 (DECL_FUNCTION_BODY) is set to be block B. */
11185
11186static tree
11187enter_a_block (b)
11188 tree b;
11189{
e04a16fb
AG		 11190 tree fndecl = current_function_decl;
11191
f099f336
APB		 11192 if (!fndecl) {
11193 BLOCK_SUPERCONTEXT (b) = current_static_block;
11194 current_static_block = b;
11195 }
11196
11197 else if (!DECL_FUNCTION_BODY (fndecl))
e04a16fb
AG		 11198 {
11199 BLOCK_SUPERCONTEXT (b) = fndecl;
11200 DECL_FUNCTION_BODY (fndecl) = b;
11201 }
11202 else
11203 {
11204 BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
11205 DECL_FUNCTION_BODY (fndecl) = b;
11206 }
11207 return b;
11208}
11209
11210/* Exit a block by changing the current function body
11211 (DECL_FUNCTION_BODY) to the current block super context, only if
11212 the block being exited isn't the method's top level one. */
11213
11214static tree
11215exit_block ()
11216{
f099f336
APB		 11217 tree b;
11218 if (current_function_decl)
11219 {
11220 b = DECL_FUNCTION_BODY (current_function_decl);
11221 if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
11222 DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
11223 }
11224 else
11225 {
11226 b = current_static_block;
e04a16fb 11227
f099f336
APB		 11228 if (BLOCK_SUPERCONTEXT (b))
11229 current_static_block = BLOCK_SUPERCONTEXT (b);
11230 }
e04a16fb
AG		 11231 return b;
11232}
11233
11234/* Lookup for NAME in the nested function's blocks, all the way up to
11235 the current toplevel one. It complies with Java's local variable
11236 scoping rules. */
11237
11238static tree
11239lookup_name_in_blocks (name)
11240 tree name;
11241{
f099f336 11242 tree b = GET_CURRENT_BLOCK (current_function_decl);
e04a16fb
AG		 11243
11244 while (b != current_function_decl)
11245 {
11246 tree current;
11247
11248 /* Paranoid sanity check. To be removed */
11249 if (TREE_CODE (b) != BLOCK)
11250 fatal ("non block expr function body - lookup_name_in_blocks");
11251
11252 for (current = BLOCK_EXPR_DECLS (b); current;
11253 current = TREE_CHAIN (current))
11254 if (DECL_NAME (current) == name)
11255 return current;
11256 b = BLOCK_SUPERCONTEXT (b);
11257 }
11258 return NULL_TREE;
11259}
11260
11261static void
11262maybe_absorb_scoping_blocks ()
11263{
f099f336 11264 while (BLOCK_EXPR_ORIGIN (GET_CURRENT_BLOCK (current_function_decl)))
e04a16fb
AG		 11265 {
11266 tree b = exit_block ();
11267 java_method_add_stmt (current_function_decl, b);
11268 SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
11269 }
11270}
11271
11272\f
11273/* This section of the source is reserved to build_* functions that
11274 are building incomplete tree nodes and the patch_* functions that
11275 are completing them. */
11276
c2952b01
APB		 11277/* Wrap a non WFL node around a WFL. */
11278static tree
11279build_wfl_wrap (node)
11280 tree node;
11281{
11282 tree wfl, node_to_insert = node;
11283
11284 /* We want to process THIS . xxx symbolicaly, to keep it consistent
11285 with the way we're processing SUPER. A THIS from a primary as a
11286 different form than a SUPER. Turn THIS into something symbolic */
11287 if (TREE_CODE (node) == THIS_EXPR)
11288 node_to_insert = wfl = build_wfl_node (this_identifier_node);
11289 else
11290 wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
11291
11292 EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (node);
11293 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
11294 return wfl;
11295}
11296
11297
9bbc7d9f 11298/* Build a super() constructor invocation. Returns empty_stmt_node if
22eed1e6
APB		 11299 we're currently dealing with the class java.lang.Object. */
11300
11301static tree
e920ebc9
APB		 11302build_super_invocation (mdecl)
11303 tree mdecl;
22eed1e6 11304{
e920ebc9 11305 if (DECL_CONTEXT (mdecl) == object_type_node)
9bbc7d9f 11306 return empty_stmt_node;
22eed1e6
APB		 11307 else
11308 {
9ee9b555 11309 tree super_wfl = build_wfl_node (super_identifier_node);
c2952b01
APB		 11310 tree a = NULL_TREE, t;
11311 /* If we're dealing with an anonymous class, pass the arguments
11312 of the crafted constructor along. */
11313 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
11314 {
11315 SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
11316 for (; t != end_params_node; t = TREE_CHAIN (t))
11317 a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
11318 }
11319 return build_method_invocation (super_wfl, a);
22eed1e6
APB		 11320 }
11321}
11322
11323/* Build a SUPER/THIS qualified method invocation. */
11324
11325static tree
11326build_this_super_qualified_invocation (use_this, name, args, lloc, rloc)
11327 int use_this;
11328 tree name, args;
11329 int lloc, rloc;
22eed1e6
APB		 11330{
11331 tree invok;
11332 tree wfl =
9ee9b555 11333 build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
22eed1e6
APB		 11334 EXPR_WFL_LINECOL (wfl) = lloc;
11335 invok = build_method_invocation (name, args);
11336 return make_qualified_primary (wfl, invok, rloc);
11337}
11338
b67d701b 11339/* Build an incomplete CALL_EXPR node. */
e04a16fb
AG		 11340
11341static tree
11342build_method_invocation (name, args)
11343 tree name;
11344 tree args;
11345{
11346 tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
11347 TREE_SIDE_EFFECTS (call) = 1;
b67d701b
PB		 11348 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
11349 return call;
11350}
11351
11352/* Build an incomplete new xxx(...) node. */
11353
11354static tree
11355build_new_invocation (name, args)
11356 tree name, args;
11357{
11358 tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
11359 TREE_SIDE_EFFECTS (call) = 1;
e04a16fb
AG		 11360 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
11361 return call;
11362}
11363
11364/* Build an incomplete assignment expression. */
11365
11366static tree
11367build_assignment (op, op_location, lhs, rhs)
11368 int op, op_location;
11369 tree lhs, rhs;
11370{
11371 tree assignment;
11372 /* Build the corresponding binop if we deal with a Compound
11373 Assignment operator. Mark the binop sub-tree as part of a
11374 Compound Assignment expression */
11375 if (op != ASSIGN_TK)
11376 {
11377 rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
11378 COMPOUND_ASSIGN_P (rhs) = 1;
11379 }
11380 assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
11381 TREE_SIDE_EFFECTS (assignment) = 1;
11382 EXPR_WFL_LINECOL (assignment) = op_location;
11383 return assignment;
11384}
11385
11386/* Print an INTEGER_CST node in a static buffer, and return the buffer. */
11387
15fdcfe9 11388char *
e04a16fb
AG		 11389print_int_node (node)
11390 tree node;
11391{
11392 static char buffer [80];
11393 if (TREE_CONSTANT_OVERFLOW (node))
11394 sprintf (buffer, "<overflow>");
11395
11396 if (TREE_INT_CST_HIGH (node) == 0)
11397 sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
11398 TREE_INT_CST_LOW (node));
11399 else if (TREE_INT_CST_HIGH (node) == -1
11400 && TREE_INT_CST_LOW (node) != 0)
11401 {
11402 buffer [0] = '-';
11403 sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
11404 -TREE_INT_CST_LOW (node));
11405 }
11406 else
11407 sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
11408 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
11409
11410 return buffer;
11411}
11412
7f1d4866
APB		 11413/* Return 1 if an assignment to a FINAL is attempted in a non suitable
11414 context. */
5e942c50
APB		 11415
11416static int
11417check_final_assignment (lvalue, wfl)
11418 tree lvalue, wfl;
11419{
6632dcdd
APB		 11420 if (TREE_CODE (lvalue) == COMPOUND_EXPR
11421 && JDECL_P (TREE_OPERAND (lvalue, 1)))
11422 lvalue = TREE_OPERAND (lvalue, 1);
11423
bc2874c9
TT		 11424 /* When generating class files, references to the `length' field
11425 look a bit different. */
11426 if ((flag_emit_class_files
11427 && TREE_CODE (lvalue) == COMPONENT_REF
11428 && TYPE_ARRAY_P (TREE_TYPE (TREE_OPERAND (lvalue, 0)))
11429 && FIELD_FINAL (TREE_OPERAND (lvalue, 1)))
11430 || (TREE_CODE (lvalue) == FIELD_DECL
11431 && FIELD_FINAL (lvalue)
11432 && !DECL_CLINIT_P (current_function_decl)
11433 && !DECL_FINIT_P (current_function_decl)))
5e942c50
APB		 11434 {
11435 parse_error_context
11436 (wfl, "Can't assign a value to the final variable `%s'",
11437 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
11438 return 1;
11439 }
11440 return 0;
11441}
11442
11443/* Inline references to java.lang.PRIMTYPE.TYPE when accessed in
11444 read. This is needed to avoid circularities in the implementation
11445 of these fields in libjava. */
11446
11447static tree
11448maybe_build_primttype_type_ref (rhs, wfl)
11449 tree rhs, wfl;
11450{
11451 tree to_return = NULL_TREE;
11452 tree rhs_type = TREE_TYPE (rhs);
11453 if (TREE_CODE (rhs) == COMPOUND_EXPR)
11454 {
11455 tree n = TREE_OPERAND (rhs, 1);
11456 if (TREE_CODE (n) == VAR_DECL
11457 && DECL_NAME (n) == TYPE_identifier_node
11458 && rhs_type == class_ptr_type)
11459 {
49f48c71 11460 const char *self_name = IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl));
5e942c50
APB		 11461 if (!strncmp (self_name, "java.lang.", 10))
11462 to_return = build_primtype_type_ref (self_name);
11463 }
11464 }
11465 return (to_return ? to_return : rhs );
11466}
11467
e04a16fb
AG		 11468/* 15.25 Assignment operators. */
11469
11470static tree
11471patch_assignment (node, wfl_op1, wfl_op2)
11472 tree node;
11473 tree wfl_op1;
11474 tree wfl_op2;
11475{
0a2138e2 11476 tree rhs = TREE_OPERAND (node, 1);
5e942c50 11477 tree lvalue = TREE_OPERAND (node, 0), llvalue;
cd531a2e 11478 tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
e04a16fb
AG		 11479 int error_found = 0;
11480 int lvalue_from_array = 0;
11481
c2952b01 11482 /* Can't assign to a (blank) final. */
5e942c50
APB		 11483 if (check_final_assignment (lvalue, wfl_op1))
11484 error_found = 1;
e04a16fb
AG		 11485
11486 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11487
11488 /* Lhs can be a named variable */
34f4db93 11489 if (JDECL_P (lvalue))
e04a16fb 11490 {
e04a16fb
AG		 11491 lhs_type = TREE_TYPE (lvalue);
11492 }
11493 /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME +
11494 comment on reason why */
11495 else if (TREE_CODE (wfl_op1) == ARRAY_REF)
11496 {
11497 lhs_type = TREE_TYPE (lvalue);
11498 lvalue_from_array = 1;
11499 }
11500 /* Or a field access */
11501 else if (TREE_CODE (lvalue) == COMPONENT_REF)
11502 lhs_type = TREE_TYPE (lvalue);
11503 /* Or a function return slot */
11504 else if (TREE_CODE (lvalue) == RESULT_DECL)
11505 lhs_type = TREE_TYPE (lvalue);
5e942c50
APB		 11506 /* Otherwise, we might want to try to write into an optimized static
11507 final, this is an of a different nature, reported further on. */
11508 else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
1504b2b4 11509 && resolve_expression_name (wfl_op1, &llvalue))
5e942c50 11510 {
6632dcdd 11511 if (!error_found && check_final_assignment (llvalue, wfl_op1))
1504b2b4
APB		 11512 {
11513 /* What we should do instead is resetting the all the flags
11514 previously set, exchange lvalue for llvalue and continue. */
11515 error_found = 1;
11516 return error_mark_node;
11517 }
11518 else
11519 lhs_type = TREE_TYPE (lvalue);
5e942c50
APB		 11520 }
11521 else
e04a16fb
AG		 11522 {
11523 parse_error_context (wfl_op1, "Invalid left hand side of assignment");
11524 error_found = 1;
11525 }
11526
11527 rhs_type = TREE_TYPE (rhs);
b67d701b 11528 /* 5.1 Try the assignment conversion for builtin type. */
0a2138e2 11529 new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
e04a16fb 11530
b67d701b 11531 /* 5.2 If it failed, try a reference conversion */
0a2138e2 11532 if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
b67d701b 11533 lhs_type = promote_type (rhs_type);
e04a16fb
AG		 11534
11535 /* 15.25.2 If we have a compound assignment, convert RHS into the
11536 type of the LHS */
11537 else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
11538 new_rhs = convert (lhs_type, rhs);
11539
11540 /* Explicit cast required. This is an error */
11541 if (!new_rhs)
11542 {
c2e3db92
KG		 11543 char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
11544 char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
e04a16fb
AG		 11545 tree wfl;
11546 char operation [32]; /* Max size known */
11547
11548 /* If the assignment is part of a declaration, we use the WFL of
11549 the declared variable to point out the error and call it a
11550 declaration problem. If the assignment is a genuine =
11551 operator, we call is a operator `=' problem, otherwise we
11552 call it an assignment problem. In both of these last cases,
11553 we use the WFL of the operator to indicate the error. */
11554
11555 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
11556 {
11557 wfl = wfl_op1;
11558 strcpy (operation, "declaration");
11559 }
11560 else
11561 {
11562 wfl = wfl_operator;
11563 if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
11564 strcpy (operation, "assignment");
11565 else if (TREE_CODE (TREE_OPERAND (node, 0)) == RESULT_DECL)
11566 strcpy (operation, "`return'");
11567 else
11568 strcpy (operation, "`='");
11569 }
11570
1ebadc60 11571 if (!valid_cast_to_p (rhs_type, lhs_type))
781b0558
KG		 11572 parse_error_context
11573 (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
11574 operation, t1, t2);
1ebadc60 11575 else
781b0558 11576 parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
1ebadc60 11577 operation, t1, t2);
e04a16fb
AG		 11578 free (t1); free (t2);
11579 error_found = 1;
11580 }
11581
c877974e
APB		 11582 /* Inline read access to java.lang.PRIMTYPE.TYPE */
11583 if (new_rhs)
11584 new_rhs = maybe_build_primttype_type_ref (new_rhs, wfl_op2);
5e942c50 11585
e04a16fb
AG		 11586 if (error_found)
11587 return error_mark_node;
11588
2622b947
APB		 11589 /* 10.10: Array Store Exception runtime check */
11590 if (!flag_emit_class_files
e8fc7396 11591 && !flag_emit_xref
2622b947 11592 && lvalue_from_array
afc390b1 11593 && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
2622b947
APB		 11594 {
11595 tree check;
11596 tree base = lvalue;
11597
11598 /* We need to retrieve the right argument for _Jv_CheckArrayStore */
11599 if (TREE_CODE (lvalue) == COMPOUND_EXPR)
11600 base = TREE_OPERAND (lvalue, 0);
11601 else
11602 {
11603 if (flag_bounds_check)
11604 base = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (base, 0), 1), 0);
11605 else
11606 base = TREE_OPERAND (TREE_OPERAND (base, 0), 0);
11607 }
11608
11609 /* Build the invocation of _Jv_CheckArrayStore */
dc4e6ccf 11610 new_rhs = save_expr (new_rhs);
2622b947
APB		 11611 check = build (CALL_EXPR, void_type_node,
11612 build_address_of (soft_checkarraystore_node),
11613 tree_cons (NULL_TREE, base,
11614 build_tree_list (NULL_TREE, new_rhs)),
11615 NULL_TREE);
11616 TREE_SIDE_EFFECTS (check) = 1;
11617
11618 /* We have to decide on an insertion point */
11619 if (TREE_CODE (lvalue) == COMPOUND_EXPR)
11620 {
11621 tree t;
11622 if (flag_bounds_check)
11623 {
11624 t = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0);
11625 TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0) =
11626 build (COMPOUND_EXPR, void_type_node, t, check);
11627 }
11628 else
11629 TREE_OPERAND (lvalue, 1) = build (COMPOUND_EXPR, lhs_type,
11630 check, TREE_OPERAND (lvalue, 1));
11631 }
11632 else
11633 {
11634 /* Make sure the bound check will happen before the store check */
11635 if (flag_bounds_check)
11636 TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0) =
11637 build (COMPOUND_EXPR, void_type_node,
11638 TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0), check);
11639 else
11640 lvalue = build (COMPOUND_EXPR, lhs_type, check, lvalue);
11641 }
11642 }
22eed1e6 11643
e04a16fb
AG		 11644 TREE_OPERAND (node, 0) = lvalue;
11645 TREE_OPERAND (node, 1) = new_rhs;
11646 TREE_TYPE (node) = lhs_type;
11647 return node;
11648}
11649
b67d701b
PB		 11650/* Check that type SOURCE can be cast into type DEST. If the cast
11651 can't occur at all, return 0 otherwise 1. This function is used to
11652 produce accurate error messages on the reasons why an assignment
11653 failed. */
e04a16fb 11654
b67d701b
PB		 11655static tree
11656try_reference_assignconv (lhs_type, rhs)
11657 tree lhs_type, rhs;
e04a16fb 11658{
b67d701b
PB		 11659 tree new_rhs = NULL_TREE;
11660 tree rhs_type = TREE_TYPE (rhs);
e04a16fb 11661
b67d701b
PB		 11662 if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
11663 {
11664 /* `null' may be assigned to any reference type */
11665 if (rhs == null_pointer_node)
11666 new_rhs = null_pointer_node;
11667 /* Try the reference assignment conversion */
11668 else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
11669 new_rhs = rhs;
11670 /* This is a magic assignment that we process differently */
11671 else if (rhs == soft_exceptioninfo_call_node)
11672 new_rhs = rhs;
11673 }
11674 return new_rhs;
11675}
11676
11677/* Check that RHS can be converted into LHS_TYPE by the assignment
11678 conversion (5.2), for the cases of RHS being a builtin type. Return
11679 NULL_TREE if the conversion fails or if because RHS isn't of a
11680 builtin type. Return a converted RHS if the conversion is possible. */
11681
11682static tree
11683try_builtin_assignconv (wfl_op1, lhs_type, rhs)
11684 tree wfl_op1, lhs_type, rhs;
11685{
11686 tree new_rhs = NULL_TREE;
11687 tree rhs_type = TREE_TYPE (rhs);
11688
5e942c50
APB		 11689 /* Zero accepted everywhere */
11690 if (TREE_CODE (rhs) == INTEGER_CST
11691 && TREE_INT_CST_HIGH (rhs) == 0 && TREE_INT_CST_LOW (rhs) == 0
11692 && JPRIMITIVE_TYPE_P (rhs_type))
11693 new_rhs = convert (lhs_type, rhs);
11694
b67d701b
PB		 11695 /* 5.1.1 Try Identity Conversion,
11696 5.1.2 Try Widening Primitive Conversion */
5e942c50 11697 else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
b67d701b
PB		 11698 new_rhs = convert (lhs_type, rhs);
11699
11700 /* Try a narrowing primitive conversion (5.1.3):
11701 - expression is a constant expression of type int AND
11702 - variable is byte, short or char AND
11703 - The value of the expression is representable in the type of the
11704 variable */
11705 else if (rhs_type == int_type_node && TREE_CONSTANT (rhs)
11706 && (lhs_type == byte_type_node || lhs_type == char_type_node
11707 || lhs_type == short_type_node))
11708 {
11709 if (int_fits_type_p (rhs, lhs_type))
11710 new_rhs = convert (lhs_type, rhs);
11711 else if (wfl_op1) /* Might be called with a NULL */
11712 parse_warning_context
781b0558 11713 (wfl_op1, "Constant expression `%s' to wide for narrowing primitive conversion to `%s'",
0a2138e2 11714 print_int_node (rhs), lang_printable_name (lhs_type, 0));
b67d701b
PB		 11715 /* Reported a warning that will turn into an error further
11716 down, so we don't return */
11717 }
11718
11719 return new_rhs;
11720}
11721
11722/* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
11723 conversion (5.1.1) or widening primitve conversion (5.1.2). Return
11724 0 is the conversion test fails. This implements parts the method
11725 invocation convertion (5.3). */
11726
11727static int
11728valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)
11729 tree lhs_type, rhs_type;
11730{
acd663ee 11731 /* 5.1.1: This is the identity conversion part. */
5e942c50
APB		 11732 if (lhs_type == rhs_type)
11733 return 1;
11734
acd663ee
APB		 11735 /* Reject non primitive types */
11736 if (!JPRIMITIVE_TYPE_P (lhs_type) || !JPRIMITIVE_TYPE_P (rhs_type))
b67d701b
PB		 11737 return 0;
11738
acd663ee
APB		 11739 /* 5.1.2: widening primitive conversion. byte, even if it's smaller
11740 than a char can't be converted into a char. Short can't too, but
11741 the < test below takes care of that */
b67d701b
PB		 11742 if (lhs_type == char_type_node && rhs_type == byte_type_node)
11743 return 0;
11744
5e942c50
APB		 11745 /* Accept all promoted type here. Note, we can't use <= in the test
11746 below, because we still need to bounce out assignments of short
11747 to char and the likes */
11748 if (lhs_type == int_type_node
11749 && (rhs_type == promoted_byte_type_node
11750 || rhs_type == promoted_short_type_node
11751 || rhs_type == promoted_char_type_node
11752 || rhs_type == promoted_boolean_type_node))
11753 return 1;
11754
acd663ee
APB		 11755 /* From here, an integral is widened if its precision is smaller
11756 than the precision of the LHS or if the LHS is a floating point
11757 type, or the RHS is a float and the RHS a double. */
11758 if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
11759 && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
11760 || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
11761 || (rhs_type == float_type_node && lhs_type == double_type_node))
b67d701b
PB		 11762 return 1;
11763
11764 return 0;
e04a16fb
AG		 11765}
11766
11767/* Check that something of SOURCE type can be assigned or cast to
11768 something of DEST type at runtime. Return 1 if the operation is
11769 valid, 0 otherwise. If CAST is set to 1, we're treating the case
11770 were SOURCE is cast into DEST, which borrows a lot of the
11771 assignment check. */
11772
11773static int
11774valid_ref_assignconv_cast_p (source, dest, cast)
11775 tree source;
11776 tree dest;
11777 int cast;
11778{
09ed0f70
APB		 11779 /* SOURCE or DEST might be null if not from a declared entity. */
11780 if (!source || !dest)
11781 return 0;
5e942c50
APB		 11782 if (JNULLP_TYPE_P (source))
11783 return 1;
e04a16fb
AG		 11784 if (TREE_CODE (source) == POINTER_TYPE)
11785 source = TREE_TYPE (source);
11786 if (TREE_CODE (dest) == POINTER_TYPE)
11787 dest = TREE_TYPE (dest);
11788 /* Case where SOURCE is a class type */
11789 if (TYPE_CLASS_P (source))
11790 {
11791 if (TYPE_CLASS_P (dest))
c2952b01
APB		 11792 return (source == dest
11793 || inherits_from_p (source, dest)
11794 || enclosing_context_p (dest, source /*source, dest*/)
11795 || (cast && inherits_from_p (dest, source)));
e04a16fb
AG		 11796 if (TYPE_INTERFACE_P (dest))
11797 {
11798 /* If doing a cast and SOURCE is final, the operation is
11799 always correct a compile time (because even if SOURCE
11800 does not implement DEST, a subclass of SOURCE might). */
11801 if (cast && !CLASS_FINAL (TYPE_NAME (source)))
11802 return 1;
11803 /* Otherwise, SOURCE must implement DEST */
11804 return interface_of_p (dest, source);
11805 }
11806 /* DEST is an array, cast permited if SOURCE is of Object type */
11807 return (cast && source == object_type_node ? 1 : 0);
11808 }
11809 if (TYPE_INTERFACE_P (source))
11810 {
11811 if (TYPE_CLASS_P (dest))
11812 {
11813 /* If not casting, DEST must be the Object type */
11814 if (!cast)
11815 return dest == object_type_node;
11816 /* We're doing a cast. The cast is always valid is class
11817 DEST is not final, otherwise, DEST must implement SOURCE */
b67d701b 11818 else if (!CLASS_FINAL (TYPE_NAME (dest)))
e04a16fb
AG		 11819 return 1;
11820 else
11821 return interface_of_p (source, dest);
11822 }
11823 if (TYPE_INTERFACE_P (dest))
11824 {
11825 /* If doing a cast, then if SOURCE and DEST contain method
11826 with the same signature but different return type, then
11827 this is a (compile time) error */
11828 if (cast)
11829 {
11830 tree method_source, method_dest;
11831 tree source_type;
0a2138e2 11832 tree source_sig;
e04a16fb
AG		 11833 tree source_name;
11834 for (method_source = TYPE_METHODS (source); method_source;
11835 method_source = TREE_CHAIN (method_source))
11836 {
11837 source_sig =
11838 build_java_argument_signature (TREE_TYPE (method_source));
11839 source_type = TREE_TYPE (TREE_TYPE (method_source));
11840 source_name = DECL_NAME (method_source);
11841 for (method_dest = TYPE_METHODS (dest);
11842 method_dest; method_dest = TREE_CHAIN (method_dest))
11843 if (source_sig ==
11844 build_java_argument_signature (TREE_TYPE (method_dest))
11845 && source_name == DECL_NAME (method_dest)
11846 && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
11847 return 0;
11848 }
11849 return 1;
11850 }
11851 else
11852 return source == dest || interface_of_p (dest, source);
11853 }
11854 else /* Array */
93024893
APB		 11855 return (cast ?
11856 (DECL_NAME (TYPE_NAME (source)) == java_lang_cloneable) : 0);
e04a16fb
AG		 11857 }
11858 if (TYPE_ARRAY_P (source))
11859 {
11860 if (TYPE_CLASS_P (dest))
11861 return dest == object_type_node;
09ed0f70
APB		 11862 /* Can't cast an array to an interface unless the interface is
11863 java.lang.Cloneable */
e04a16fb 11864 if (TYPE_INTERFACE_P (dest))
09ed0f70 11865 return (DECL_NAME (TYPE_NAME (dest)) == java_lang_cloneable ? 1 : 0);
e04a16fb
AG		 11866 else /* Arrays */
11867 {
11868 tree source_element_type = TYPE_ARRAY_ELEMENT (source);
11869 tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
11870
b9f7e36c
APB		 11871 /* In case of severe errors, they turn out null */
11872 if (!dest_element_type || !source_element_type)
11873 return 0;
e04a16fb
AG		 11874 if (source_element_type == dest_element_type)
11875 return 1;
11876 return valid_ref_assignconv_cast_p (source_element_type,
11877 dest_element_type, cast);
11878 }
11879 return 0;
11880 }
11881 return 0;
11882}
11883
b67d701b
PB		 11884static int
11885valid_cast_to_p (source, dest)
11886 tree source;
11887 tree dest;
11888{
11889 if (TREE_CODE (source) == POINTER_TYPE)
11890 source = TREE_TYPE (source);
11891 if (TREE_CODE (dest) == POINTER_TYPE)
11892 dest = TREE_TYPE (dest);
11893
11894 if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
11895 return valid_ref_assignconv_cast_p (source, dest, 1);
11896
11897 else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
11898 return 1;
11899
11900 return 0;
11901}
11902
11903/* Method invocation conversion test. Return 1 if type SOURCE can be
11904 converted to type DEST through the methond invocation conversion
11905 process (5.3) */
11906
15fdcfe9
PB		 11907static tree
11908do_unary_numeric_promotion (arg)
11909 tree arg;
11910{
11911 tree type = TREE_TYPE (arg);
11912 if (TREE_CODE (type) == INTEGER_TYPE ? TYPE_PRECISION (type) < 32
11913 : TREE_CODE (type) == CHAR_TYPE)
11914 arg = convert (int_type_node, arg);
11915 return arg;
11916}
11917
acd663ee
APB		 11918/* Return a non zero value if SOURCE can be converted into DEST using
11919 the method invocation conversion rule (5.3). */
b67d701b
PB		 11920static int
11921valid_method_invocation_conversion_p (dest, source)
11922 tree dest, source;
11923{
e3884b71 11924 return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
acd663ee
APB		 11925 && valid_builtin_assignconv_identity_widening_p (dest, source))
11926 || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
11927 && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
11928 && valid_ref_assignconv_cast_p (source, dest, 0)));
b67d701b
PB		 11929}
11930
e04a16fb
AG		 11931/* Build an incomplete binop expression. */
11932
11933static tree
11934build_binop (op, op_location, op1, op2)
11935 enum tree_code op;
11936 int op_location;
11937 tree op1, op2;
11938{
5e942c50 11939 tree binop = build (op, NULL_TREE, op1, op2);
e04a16fb
AG		 11940 TREE_SIDE_EFFECTS (binop) = 1;
11941 /* Store the location of the operator, for better error report. The
11942 string of the operator will be rebuild based on the OP value. */
11943 EXPR_WFL_LINECOL (binop) = op_location;
11944 return binop;
11945}
11946
11947/* Build the string of the operator retained by NODE. If NODE is part
11948 of a compound expression, add an '=' at the end of the string. This
11949 function is called when an error needs to be reported on an
11950 operator. The string is returned as a pointer to a static character
11951 buffer. */
11952
11953static char *
11954operator_string (node)
11955 tree node;
11956{
11957#define BUILD_OPERATOR_STRING(S) \
11958 { \
11959 sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
11960 return buffer; \
11961 }
11962
11963 static char buffer [10];
11964 switch (TREE_CODE (node))
11965 {
11966 case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
11967 case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
11968 case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
11969 case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
11970 case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
11971 case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
11972 case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
11973 case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
11974 case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
11975 case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
11976 case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
11977 case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
11978 case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
11979 case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
11980 case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
11981 case GT_EXPR: BUILD_OPERATOR_STRING (">");
11982 case GE_EXPR: BUILD_OPERATOR_STRING (">=");
11983 case LT_EXPR: BUILD_OPERATOR_STRING ("<");
11984 case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
b67d701b 11985 case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
e04a16fb
AG		 11986 case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
11987 case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
11988 case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
11989 case PREINCREMENT_EXPR: /* Fall through */
11990 case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
11991 case PREDECREMENT_EXPR: /* Fall through */
11992 case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
11993 default:
11994 fatal ("unregistered operator %s - operator_string",
11995 tree_code_name [TREE_CODE (node)]);
11996 }
11997 return NULL;
11998#undef BUILD_OPERATOR_STRING
11999}
12000
5cbdba64
APB		 12001/* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
12002
12003static int
12004java_decl_equiv (var_acc1, var_acc2)
12005 tree var_acc1, var_acc2;
12006{
12007 if (JDECL_P (var_acc1))
12008 return (var_acc1 == var_acc2);
12009
12010 return (TREE_CODE (var_acc1) == COMPONENT_REF
12011 && TREE_CODE (var_acc2) == COMPONENT_REF
12012 && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
12013 == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
12014 && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
12015}
12016
12017/* Return a non zero value if CODE is one of the operators that can be
12018 used in conjunction with the `=' operator in a compound assignment. */
12019
12020static int
12021binop_compound_p (code)
12022 enum tree_code code;
12023{
12024 int i;
12025 for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
12026 if (binop_lookup [i] == code)
12027 break;
12028
12029 return i < BINOP_COMPOUND_CANDIDATES;
12030}
12031
12032/* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
12033
12034static tree
12035java_refold (t)
12036 tree t;
12037{
12038 tree c, b, ns, decl;
12039
12040 if (TREE_CODE (t) != MODIFY_EXPR)
12041 return t;
12042
12043 c = TREE_OPERAND (t, 1);
12044 if (! (c && TREE_CODE (c) == COMPOUND_EXPR
12045 && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
12046 && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
12047 return t;
12048
12049 /* Now the left branch of the binary operator. */
12050 b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
12051 if (! (b && TREE_CODE (b) == NOP_EXPR
12052 && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
12053 return t;
12054
12055 ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
12056 if (! (ns && TREE_CODE (ns) == NOP_EXPR
12057 && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
12058 return t;
12059
12060 decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
12061 if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
12062 /* It's got to be the an equivalent decl */
12063 && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
12064 {
12065 /* Shorten the NOP_EXPR/SAVE_EXPR path. */
12066 TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
12067 /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
12068 TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
12069 /* Change the right part of the BINOP_EXPR */
12070 TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
12071 }
12072
12073 return t;
12074}
12075
e04a16fb
AG		 12076/* Binary operators (15.16 up to 15.18). We return error_mark_node on
12077 errors but we modify NODE so that it contains the type computed
12078 according to the expression, when it's fixed. Otherwise, we write
12079 error_mark_node as the type. It allows us to further the analysis
12080 of remaining nodes and detects more errors in certain cases. */
12081
12082static tree
12083patch_binop (node, wfl_op1, wfl_op2)
12084 tree node;
12085 tree wfl_op1;
12086 tree wfl_op2;
12087{
12088 tree op1 = TREE_OPERAND (node, 0);
12089 tree op2 = TREE_OPERAND (node, 1);
12090 tree op1_type = TREE_TYPE (op1);
12091 tree op2_type = TREE_TYPE (op2);
ab3a6dd6 12092 tree prom_type = NULL_TREE;
e04a16fb 12093 int code = TREE_CODE (node);
b67d701b 12094
e04a16fb
AG		 12095 /* If 1, tell the routine that we have to return error_mark_node
12096 after checking for the initialization of the RHS */
12097 int error_found = 0;
12098
e04a16fb
AG		 12099 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12100
e04a16fb
AG		 12101 switch (code)
12102 {
12103 /* 15.16 Multiplicative operators */
12104 case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
12105 case RDIV_EXPR: /* 15.16.2 Division Operator / */
c2952b01 12106 case TRUNC_DIV_EXPR: /* 15.16.2 Integral type Division Operator / */
e04a16fb
AG		 12107 case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
12108 if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
12109 {
12110 if (!JPRIMITIVE_TYPE_P (op1_type))
12111 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12112 if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
12113 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12114 TREE_TYPE (node) = error_mark_node;
12115 error_found = 1;
12116 break;
12117 }
12118 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12119 /* Change the division operator if necessary */
12120 if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
12121 TREE_SET_CODE (node, TRUNC_DIV_EXPR);
0b4d333e 12122
aa4759c1
AH		 12123 if (TREE_CODE (prom_type) == INTEGER_TYPE
12124 && flag_use_divide_subroutine
12125 && ! flag_emit_class_files
12126 && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
12127 return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
12128
0b4d333e
APB		 12129 /* This one is more complicated. FLOATs are processed by a
12130 function call to soft_fmod. Duplicate the value of the
12131 COMPOUND_ASSIGN_P flag. */
e04a16fb 12132 if (code == TRUNC_MOD_EXPR)
0b4d333e
APB		 12133 {
12134 tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
12135 COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
dc0b3eff
PB		 12136 TREE_SIDE_EFFECTS (mod)
12137 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
0b4d333e
APB		 12138 return mod;
12139 }
e04a16fb
AG		 12140 break;
12141
12142 /* 15.17 Additive Operators */
12143 case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
b67d701b
PB		 12144
12145 /* Operation is valid if either one argument is a string
12146 constant, a String object or a StringBuffer crafted for the
12147 purpose of the a previous usage of the String concatenation
12148 operator */
12149
12150 if (TREE_CODE (op1) == STRING_CST
12151 || TREE_CODE (op2) == STRING_CST
12152 || JSTRING_TYPE_P (op1_type)
12153 || JSTRING_TYPE_P (op2_type)
12154 || IS_CRAFTED_STRING_BUFFER_P (op1)
12155 || IS_CRAFTED_STRING_BUFFER_P (op2))
12156 return build_string_concatenation (op1, op2);
12157
e04a16fb
AG		 12158 case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
12159 Numeric Types */
12160 if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
12161 {
12162 if (!JPRIMITIVE_TYPE_P (op1_type))
12163 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12164 if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
12165 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12166 TREE_TYPE (node) = error_mark_node;
12167 error_found = 1;
12168 break;
12169 }
12170 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12171 break;
12172
12173 /* 15.18 Shift Operators */
12174 case LSHIFT_EXPR:
12175 case RSHIFT_EXPR:
12176 case URSHIFT_EXPR:
12177 if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
12178 {
12179 if (!JINTEGRAL_TYPE_P (op1_type))
12180 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
12181 else
1ebadc60
KG		 12182 {
12183 if (JPRIMITIVE_TYPE_P (op2_type))
12184 parse_error_context (wfl_operator,
781b0558 12185 "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
1ebadc60
KG		 12186 operator_string (node),
12187 lang_printable_name (op2_type, 0));
12188 else
781b0558
KG		 12189 parse_error_context (wfl_operator,
12190 "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
1ebadc60
KG		 12191 operator_string (node),
12192 lang_printable_name (op2_type, 0));
12193 }
e04a16fb
AG		 12194 TREE_TYPE (node) = error_mark_node;
12195 error_found = 1;
12196 break;
12197 }
12198
12199 /* Unary numeric promotion (5.6.1) is performed on each operand
12200 separatly */
15fdcfe9
PB		 12201 op1 = do_unary_numeric_promotion (op1);
12202 op2 = do_unary_numeric_promotion (op2);
e04a16fb
AG		 12203
12204 /* The type of the shift expression is the type of the promoted
12205 type of the left-hand operand */
12206 prom_type = TREE_TYPE (op1);
12207
c2952b01
APB		 12208 /* Shift int only up to 0x1f and long up to 0x3f */
12209 if (prom_type == int_type_node)
12210 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
12211 build_int_2 (0x1f, 0)));
12212 else
12213 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
12214 build_int_2 (0x3f, 0)));
e04a16fb
AG		 12215
12216 /* The >>> operator is a >> operating on unsigned quantities */
15fdcfe9 12217 if (code == URSHIFT_EXPR && ! flag_emit_class_files)
e04a16fb 12218 {
0b4d333e 12219 tree to_return;
73333a87
AH		 12220 tree utype = unsigned_type (prom_type);
12221 op1 = convert (utype, op1);
e04a16fb 12222 TREE_SET_CODE (node, RSHIFT_EXPR);
73333a87
AH		 12223 TREE_OPERAND (node, 0) = op1;
12224 TREE_OPERAND (node, 1) = op2;
12225 TREE_TYPE (node) = utype;
0b4d333e
APB		 12226 to_return = convert (prom_type, node);
12227 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
12228 COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
dc0b3eff
PB		 12229 TREE_SIDE_EFFECTS (to_return)
12230 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
0b4d333e 12231 return to_return;
e04a16fb
AG		 12232 }
12233 break;
5e942c50
APB		 12234
12235 /* 15.19.1 Type Comparison Operator instaceof */
12236 case INSTANCEOF_EXPR:
12237
12238 TREE_TYPE (node) = boolean_type_node;
12239
12240 if (!(op2_type = resolve_type_during_patch (op2)))
12241 return error_mark_node;
12242
12243 /* The first operand must be a reference type or the null type */
12244 if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
12245 error_found = 1; /* Error reported further below */
12246
12247 /* The second operand must be a reference type */
12248 if (!JREFERENCE_TYPE_P (op2_type))
12249 {
12250 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
12251 parse_error_context
12252 (wfl_operator, "Invalid argument `%s' for `instanceof'",
12253 lang_printable_name (op2_type, 0));
12254 error_found = 1;
12255 }
12256
12257 if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
12258 {
12259 /* If the first operand is null, the result is always false */
12260 if (op1 == null_pointer_node)
12261 return boolean_false_node;
15fdcfe9
PB		 12262 else if (flag_emit_class_files)
12263 {
12264 TREE_OPERAND (node, 1) = op2_type;
dc0b3eff 12265 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
15fdcfe9
PB		 12266 return node;
12267 }
5e942c50
APB		 12268 /* Otherwise we have to invoke instance of to figure it out */
12269 else
12270 {
12271 tree call =
12272 build (CALL_EXPR, boolean_type_node,
12273 build_address_of (soft_instanceof_node),
12274 tree_cons
12275 (NULL_TREE, op1,
12276 build_tree_list (NULL_TREE,
12277 build_class_ref (op2_type))),
12278 NULL_TREE);
dc0b3eff 12279 TREE_SIDE_EFFECTS (call) = TREE_SIDE_EFFECTS (op1);
5e942c50
APB		 12280 return call;
12281 }
12282 }
12283 /* There is no way the expression operand can be an instance of
12284 the type operand. This is a compile time error. */
12285 else
12286 {
c2e3db92 12287 char *t1 = xstrdup (lang_printable_name (op1_type, 0));
5e942c50
APB		 12288 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
12289 parse_error_context
12290 (wfl_operator, "Impossible for `%s' to be instance of `%s'",
12291 t1, lang_printable_name (op2_type, 0));
12292 free (t1);
12293 error_found = 1;
12294 }
e04a16fb 12295
5e942c50 12296 break;
e04a16fb
AG		 12297
12298 /* 15.21 Bitwise and Logical Operators */
12299 case BIT_AND_EXPR:
12300 case BIT_XOR_EXPR:
12301 case BIT_IOR_EXPR:
12302 if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
12303 /* Binary numeric promotion is performed on both operand and the
12304 expression retain that type */
12305 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12306
12307 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
12308 && TREE_CODE (op1_type) == BOOLEAN_TYPE)
12309 /* The type of the bitwise operator expression is BOOLEAN */
12310 prom_type = boolean_type_node;
12311 else
12312 {
12313 if (!JINTEGRAL_TYPE_P (op1_type))
12314 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
12315 if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
12316 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
12317 TREE_TYPE (node) = error_mark_node;
12318 error_found = 1;
12319 /* Insert a break here if adding thing before the switch's
12320 break for this case */
12321 }
12322 break;
12323
12324 /* 15.22 Conditional-And Operator */
12325 case TRUTH_ANDIF_EXPR:
12326 /* 15.23 Conditional-Or Operator */
12327 case TRUTH_ORIF_EXPR:
12328 /* Operands must be of BOOLEAN type */
12329 if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
12330 TREE_CODE (op2_type) != BOOLEAN_TYPE)
12331 {
12332 if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
12333 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
12334 if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
12335 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
12336 TREE_TYPE (node) = boolean_type_node;
12337 error_found = 1;
12338 break;
12339 }
12340 /* The type of the conditional operators is BOOLEAN */
12341 prom_type = boolean_type_node;
12342 break;
12343
12344 /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
12345 case LT_EXPR:
12346 case GT_EXPR:
12347 case LE_EXPR:
12348 case GE_EXPR:
12349 /* The type of each of the operands must be a primitive numeric
12350 type */
12351 if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
12352 {
12353 if (!JNUMERIC_TYPE_P (op1_type))
12354 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12355 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
12356 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12357 TREE_TYPE (node) = boolean_type_node;
12358 error_found = 1;
12359 break;
12360 }
12361 /* Binary numeric promotion is performed on the operands */
12362 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12363 /* The type of the relation expression is always BOOLEAN */
12364 prom_type = boolean_type_node;
12365 break;
12366
12367 /* 15.20 Equality Operator */
12368 case EQ_EXPR:
12369 case NE_EXPR:
12370 /* 15.20.1 Numerical Equality Operators == and != */
12371 /* Binary numeric promotion is performed on the operands */
5e942c50 12372 if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
e04a16fb
AG		 12373 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12374
12375 /* 15.20.2 Boolean Equality Operators == and != */
12376 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
12377 TREE_CODE (op2_type) == BOOLEAN_TYPE)
12378 ; /* Nothing to do here */
12379
12380 /* 15.20.3 Reference Equality Operators == and != */
5e942c50
APB		 12381 /* Types have to be either references or the null type. If
12382 they're references, it must be possible to convert either
12383 type to the other by casting conversion. */
b9f7e36c
APB		 12384 else if (op1 == null_pointer_node || op2 == null_pointer_node
12385 || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
5e942c50
APB		 12386 && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
12387 || valid_ref_assignconv_cast_p (op2_type,
12388 op1_type, 1))))
e04a16fb
AG		 12389 ; /* Nothing to do here */
12390
12391 /* Else we have an error figure what can't be converted into
12392 what and report the error */
12393 else
12394 {
12395 char *t1;
c2e3db92 12396 t1 = xstrdup (lang_printable_name (op1_type, 0));
e04a16fb 12397 parse_error_context
781b0558
KG		 12398 (wfl_operator,
12399 "Incompatible type for `%s'. Can't convert `%s' to `%s'",
12400 operator_string (node), t1,
0a2138e2 12401 lang_printable_name (op2_type, 0));
e04a16fb
AG		 12402 free (t1);
12403 TREE_TYPE (node) = boolean_type_node;
12404 error_found = 1;
12405 break;
12406 }
12407 prom_type = boolean_type_node;
12408 break;
12409 }
12410
e04a16fb
AG		 12411 if (error_found)
12412 return error_mark_node;
12413
12414 TREE_OPERAND (node, 0) = op1;
12415 TREE_OPERAND (node, 1) = op2;
12416 TREE_TYPE (node) = prom_type;
dc0b3eff
PB		 12417 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
12418
ce6e9147
APB		 12419 if (flag_emit_xref)
12420 return node;
12421
d1472141
PB		 12422 /* fold does not respect side-effect order as required for Java but not C.
12423 * Also, it sometimes create SAVE_EXPRs which are bad when emitting
12424 * bytecode.
12425 */
12426 if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
12427 : ! TREE_SIDE_EFFECTS (node))
aee48ef8
PB		 12428 node = fold (node);
12429 return node;
e04a16fb
AG		 12430}
12431
b67d701b
PB		 12432/* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
12433 zero value, the value of CSTE comes after the valude of STRING */
12434
12435static tree
12436do_merge_string_cste (cste, string, string_len, after)
12437 tree cste;
49f48c71 12438 const char *string;
b67d701b
PB		 12439 int string_len, after;
12440{
12441 int len = TREE_STRING_LENGTH (cste) + string_len;
49f48c71 12442 const char *old = TREE_STRING_POINTER (cste);
b67d701b
PB		 12443 TREE_STRING_LENGTH (cste) = len;
12444 TREE_STRING_POINTER (cste) = obstack_alloc (expression_obstack, len+1);
12445 if (after)
12446 {
12447 strcpy (TREE_STRING_POINTER (cste), string);
12448 strcat (TREE_STRING_POINTER (cste), old);
12449 }
12450 else
12451 {
12452 strcpy (TREE_STRING_POINTER (cste), old);
12453 strcat (TREE_STRING_POINTER (cste), string);
12454 }
12455 return cste;
12456}
12457
12458/* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
12459 new STRING_CST on success, NULL_TREE on failure */
12460
12461static tree
12462merge_string_cste (op1, op2, after)
12463 tree op1, op2;
12464 int after;
12465{
12466 /* Handle two string constants right away */
12467 if (TREE_CODE (op2) == STRING_CST)
12468 return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
12469 TREE_STRING_LENGTH (op2), after);
12470
12471 /* Reasonable integer constant can be treated right away */
12472 if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
12473 {
49f48c71
KG		 12474 static const char *boolean_true = "true";
12475 static const char *boolean_false = "false";
12476 static const char *null_pointer = "null";
b67d701b 12477 char ch[3];
49f48c71 12478 const char *string;
b67d701b
PB		 12479
12480 if (op2 == boolean_true_node)
12481 string = boolean_true;
12482 else if (op2 == boolean_false_node)
12483 string = boolean_false;
12484 else if (op2 == null_pointer_node)
12485 string = null_pointer;
12486 else if (TREE_TYPE (op2) == char_type_node)
12487 {
12488 ch[0] = (char )TREE_INT_CST_LOW (op2);
12489 ch[1] = '\0';
12490 string = ch;
12491 }
12492 else
12493 string = print_int_node (op2);
12494
12495 return do_merge_string_cste (op1, string, strlen (string), after);
12496 }
12497 return NULL_TREE;
12498}
12499
12500/* Tries to statically concatenate OP1 and OP2 if possible. Either one
12501 has to be a STRING_CST and the other part must be a STRING_CST or a
12502 INTEGRAL constant. Return a new STRING_CST if the operation
12503 succeed, NULL_TREE otherwise.
12504
12505 If the case we want to optimize for space, we might want to return
12506 NULL_TREE for each invocation of this routine. FIXME */
12507
12508static tree
12509string_constant_concatenation (op1, op2)
12510 tree op1, op2;
12511{
12512 if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
12513 {
0a2138e2 12514 tree string, rest;
b67d701b
PB		 12515 int invert;
12516
12517 string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
12518 rest = (string == op1 ? op2 : op1);
12519 invert = (string == op1 ? 0 : 1 );
12520
12521 /* Walk REST, only if it looks reasonable */
12522 if (TREE_CODE (rest) != STRING_CST
12523 && !IS_CRAFTED_STRING_BUFFER_P (rest)
12524 && !JSTRING_TYPE_P (TREE_TYPE (rest))
12525 && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
12526 {
12527 rest = java_complete_tree (rest);
12528 if (rest == error_mark_node)
12529 return error_mark_node;
12530 rest = fold (rest);
12531 }
12532 return merge_string_cste (string, rest, invert);
12533 }
12534 return NULL_TREE;
12535}
12536
12537/* Implement the `+' operator. Does static optimization if possible,
12538 otherwise create (if necessary) and append elements to a
12539 StringBuffer. The StringBuffer will be carried around until it is
12540 used for a function call or an assignment. Then toString() will be
12541 called on it to turn it into a String object. */
12542
12543static tree
12544build_string_concatenation (op1, op2)
12545 tree op1, op2;
12546{
12547 tree result;
dc0b3eff 12548 int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
ce6e9147
APB		 12549
12550 if (flag_emit_xref)
12551 return build (PLUS_EXPR, string_type_node, op1, op2);
b67d701b
PB		 12552
12553 /* Try to do some static optimization */
12554 if ((result = string_constant_concatenation (op1, op2)))
12555 return result;
12556
c0d87ff6
PB		 12557 /* Discard empty strings on either side of the expression */
12558 if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
acd663ee
APB		 12559 {
12560 op1 = op2;
12561 op2 = NULL_TREE;
12562 }
c0d87ff6 12563 else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
acd663ee 12564 op2 = NULL_TREE;
b67d701b 12565
acd663ee 12566 /* If operands are string constant, turn then into object references */
b67d701b
PB		 12567 if (TREE_CODE (op1) == STRING_CST)
12568 op1 = patch_string_cst (op1);
acd663ee 12569 if (op2 && TREE_CODE (op2) == STRING_CST)
b67d701b
PB		 12570 op2 = patch_string_cst (op2);
12571
acd663ee
APB		 12572 /* If either one of the constant is null and the other non null
12573 operand is a String object, return it. */
12574 if (JSTRING_TYPE_P (TREE_TYPE (op1)) && !op2)
12575 return op1;
12576
b67d701b
PB		 12577 /* If OP1 isn't already a StringBuffer, create and
12578 initialize a new one */
12579 if (!IS_CRAFTED_STRING_BUFFER_P (op1))
12580 {
12581 /* Two solutions here:
c52b5771
AG		 12582 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
12583 2) OP1 is something else, we call new StringBuffer().append(OP1). */
12584 if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
b67d701b
PB		 12585 op1 = BUILD_STRING_BUFFER (op1);
12586 else
12587 {
12588 tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
12589 op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
12590 }
12591 }
12592
acd663ee
APB		 12593 if (op2)
12594 {
12595 /* OP1 is no longer the last node holding a crafted StringBuffer */
12596 IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
12597 /* Create a node for `{new...,xxx}.append (op2)' */
12598 if (op2)
12599 op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
12600 }
12601
b67d701b
PB		 12602 /* Mark the last node holding a crafted StringBuffer */
12603 IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
dc0b3eff
PB		 12604
12605 TREE_SIDE_EFFECTS (op1) = side_effects;
b67d701b
PB		 12606 return op1;
12607}
12608
12609/* Patch the string node NODE. NODE can be a STRING_CST of a crafted
12610 StringBuffer. If no string were found to be patched, return
12611 NULL. */
12612
12613static tree
12614patch_string (node)
12615 tree node;
12616{
1179ebc2
APB		 12617 if (node == error_mark_node)
12618 return error_mark_node;
b67d701b
PB		 12619 if (TREE_CODE (node) == STRING_CST)
12620 return patch_string_cst (node);
12621 else if (IS_CRAFTED_STRING_BUFFER_P (node))
12622 {
c877974e 12623 int saved = ctxp->explicit_constructor_p;
b67d701b 12624 tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
c877974e
APB		 12625 tree ret;
12626 /* Temporary disable forbid the use of `this'. */
12627 ctxp->explicit_constructor_p = 0;
12628 ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
1729c265
APB		 12629 /* String concatenation arguments must be evaluated in order too. */
12630 ret = force_evaluation_order (ret);
c877974e
APB		 12631 /* Restore it at its previous value */
12632 ctxp->explicit_constructor_p = saved;
12633 return ret;
b67d701b
PB		 12634 }
12635 return NULL_TREE;
12636}
12637
12638/* Build the internal representation of a string constant. */
12639
12640static tree
12641patch_string_cst (node)
12642 tree node;
12643{
12644 int location;
15fdcfe9
PB		 12645 if (! flag_emit_class_files)
12646 {
12647 push_obstacks (&permanent_obstack, &permanent_obstack);
12648 node = get_identifier (TREE_STRING_POINTER (node));
12649 location = alloc_name_constant (CONSTANT_String, node);
12650 node = build_ref_from_constant_pool (location);
8226320b 12651 pop_obstacks ();
15fdcfe9 12652 }
cd9643f7 12653 TREE_TYPE (node) = string_ptr_type_node;
b67d701b
PB		 12654 TREE_CONSTANT (node) = 1;
12655 return node;
12656}
12657
12658/* Build an incomplete unary operator expression. */
e04a16fb
AG		 12659
12660static tree
12661build_unaryop (op_token, op_location, op1)
12662 int op_token, op_location;
12663 tree op1;
12664{
12665 enum tree_code op;
12666 tree unaryop;
12667 switch (op_token)
12668 {
b67d701b 12669 case PLUS_TK: op = UNARY_PLUS_EXPR; break;
e04a16fb
AG		 12670 case MINUS_TK: op = NEGATE_EXPR; break;
12671 case NEG_TK: op = TRUTH_NOT_EXPR; break;
12672 case NOT_TK: op = BIT_NOT_EXPR; break;
12673 default: fatal ("Unknown token `%d' for unary operator - build_unaryop",
12674 op_token);
12675 }
12676
12677 unaryop = build1 (op, NULL_TREE, op1);
e04a16fb
AG		 12678 TREE_SIDE_EFFECTS (unaryop) = 1;
12679 /* Store the location of the operator, for better error report. The
12680 string of the operator will be rebuild based on the OP value. */
12681 EXPR_WFL_LINECOL (unaryop) = op_location;
12682 return unaryop;
12683}
12684
12685/* Special case for the ++/-- operators, since they require an extra
12686 argument to build, which is set to NULL and patched
12687 later. IS_POST_P is 1 if the operator, 0 otherwise. */
12688
12689static tree
12690build_incdec (op_token, op_location, op1, is_post_p)
12691 int op_token, op_location;
12692 tree op1;
12693 int is_post_p;
12694{
12695 static enum tree_code lookup [2][2] =
12696 {
12697 { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
12698 { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
12699 };
12700 tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
12701 NULL_TREE, op1, NULL_TREE);
12702 TREE_SIDE_EFFECTS (node) = 1;
12703 /* Store the location of the operator, for better error report. The
12704 string of the operator will be rebuild based on the OP value. */
12705 EXPR_WFL_LINECOL (node) = op_location;
12706 return node;
12707}
12708
12709/* Build an incomplete cast operator, based on the use of the
12710 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
12711 set. java_complete_tree is trained to walk a CONVERT_EXPR even
12712 though its type is already set. */
12713
12714static tree
12715build_cast (location, type, exp)
12716 int location;
12717 tree type, exp;
12718{
12719 tree node = build1 (CONVERT_EXPR, type, exp);
12720 EXPR_WFL_LINECOL (node) = location;
12721 return node;
12722}
12723
c2952b01
APB		 12724/* Build an incomplete class reference operator. */
12725static tree
12726build_incomplete_class_ref (location, class_name)
12727 int location;
12728 tree class_name;
12729{
12730 tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
12731 EXPR_WFL_LINECOL (node) = location;
12732 return node;
12733}
12734
12735/* Complete an incomplete class reference operator. */
12736static tree
12737patch_incomplete_class_ref (node)
12738 tree node;
12739{
12740 tree type = TREE_OPERAND (node, 0);
12741 tree ref_type;
12742
12743 if (!(ref_type = resolve_type_during_patch (type)))
12744 return error_mark_node;
12745
165f37bc
APB		 12746 if (!flag_emit_class_files || JPRIMITIVE_TYPE_P (ref_type))
12747 return build_class_ref (ref_type);
12748
12749 /* If we're emitting class files and we have to deal with non
12750 primitive types, we invoke (and consider generating) the
12751 synthetic static method `class$'. */
12752 if (!TYPE_DOT_CLASS (current_class))
12753 build_dot_class_method (current_class);
12754 ref_type =
12755 build_dot_class_method_invocation (DECL_NAME (TYPE_NAME (ref_type)));
12756 return java_complete_tree (ref_type);
c2952b01
APB		 12757}
12758
e04a16fb
AG		 12759/* 15.14 Unary operators. We return error_mark_node in case of error,
12760 but preserve the type of NODE if the type is fixed. */
12761
12762static tree
12763patch_unaryop (node, wfl_op)
12764 tree node;
12765 tree wfl_op;
12766{
12767 tree op = TREE_OPERAND (node, 0);
12768 tree op_type = TREE_TYPE (op);
ab3a6dd6 12769 tree prom_type = NULL_TREE, value, decl;
c2952b01 12770 int outer_field_flag = 0;
e04a16fb
AG		 12771 int code = TREE_CODE (node);
12772 int error_found = 0;
12773
12774 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12775
12776 switch (code)
12777 {
12778 /* 15.13.2 Postfix Increment Operator ++ */
12779 case POSTINCREMENT_EXPR:
12780 /* 15.13.3 Postfix Increment Operator -- */
12781 case POSTDECREMENT_EXPR:
12782 /* 15.14.1 Prefix Increment Operator ++ */
12783 case PREINCREMENT_EXPR:
12784 /* 15.14.2 Prefix Decrement Operator -- */
12785 case PREDECREMENT_EXPR:
5cbdba64 12786 op = decl = strip_out_static_field_access_decl (op);
c2952b01
APB		 12787 outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
12788 /* We might be trying to change an outer field accessed using
12789 access method. */
12790 if (outer_field_flag)
12791 {
12792 /* Retrieve the decl of the field we're trying to access. We
12793 do that by first retrieving the function we would call to
12794 access the field. It has been already verified that this
12795 field isn't final */
12796 if (flag_emit_class_files)
12797 decl = TREE_OPERAND (op, 0);
12798 else
12799 decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
12800 decl = DECL_FUNCTION_ACCESS_DECL (decl);
12801 }
b3edebcf 12802 /* We really should have a JAVA_ARRAY_EXPR to avoid this */
c2952b01 12803 else if (!JDECL_P (decl)
b3edebcf
APB		 12804 && TREE_CODE (decl) != COMPONENT_REF
12805 && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
12806 && TREE_CODE (decl) != INDIRECT_REF
12807 && !(TREE_CODE (decl) == COMPOUND_EXPR
12808 && TREE_OPERAND (decl, 1)
12809 && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
e04a16fb 12810 {
5e942c50
APB		 12811 tree lvalue;
12812 /* Before screaming, check that we're not in fact trying to
12813 increment a optimized static final access, in which case
12814 we issue an different error message. */
12815 if (!(TREE_CODE (wfl_op) == EXPR_WITH_FILE_LOCATION
12816 && resolve_expression_name (wfl_op, &lvalue)
12817 && check_final_assignment (lvalue, wfl_op)))
12818 parse_error_context (wfl_operator, "Invalid argument to `%s'",
12819 operator_string (node));
e04a16fb
AG		 12820 TREE_TYPE (node) = error_mark_node;
12821 error_found = 1;
12822 }
c2952b01
APB		 12823
12824 if (check_final_assignment (op, wfl_op))
5e942c50
APB		 12825 error_found = 1;
12826
e04a16fb
AG		 12827 /* From now on, we know that op if a variable and that it has a
12828 valid wfl. We use wfl_op to locate errors related to the
12829 ++/-- operand. */
12830 else if (!JNUMERIC_TYPE_P (op_type))
12831 {
12832 parse_error_context
12833 (wfl_op, "Invalid argument type `%s' to `%s'",
0a2138e2 12834 lang_printable_name (op_type, 0), operator_string (node));
e04a16fb
AG		 12835 TREE_TYPE (node) = error_mark_node;
12836 error_found = 1;
12837 }
12838 else
12839 {
4a5f66c3 12840 /* Before the addition, binary numeric promotion is performed on
5cbdba64
APB		 12841 both operands, if really necessary */
12842 if (JINTEGRAL_TYPE_P (op_type))
12843 {
12844 value = build_int_2 (1, 0);
12845 TREE_TYPE (value) = TREE_TYPE (node) = op_type;
12846 }
12847 else
12848 {
12849 value = build_int_2 (1, 0);
12850 TREE_TYPE (node) =
12851 binary_numeric_promotion (op_type,
12852 TREE_TYPE (value), &op, &value);
12853 }
c2952b01
APB		 12854
12855 /* We remember we might be accessing an outer field */
12856 if (outer_field_flag)
12857 {
12858 /* We re-generate an access to the field */
12859 value = build (PLUS_EXPR, TREE_TYPE (op),
12860 build_outer_field_access (wfl_op, decl), value);
12861
12862 /* And we patch the original access$() into a write
12863 with plus_op as a rhs */
12864 return outer_field_access_fix (node, op, value);
12865 }
12866
5cbdba64 12867 /* And write back into the node. */
4a5f66c3 12868 TREE_OPERAND (node, 0) = op;
e04a16fb 12869 TREE_OPERAND (node, 1) = value;
5cbdba64
APB		 12870 /* Convert the overall back into its original type, if
12871 necessary, and return */
12872 if (JINTEGRAL_TYPE_P (op_type))
12873 return fold (node);
12874 else
12875 return fold (convert (op_type, node));
e04a16fb
AG		 12876 }
12877 break;
12878
12879 /* 15.14.3 Unary Plus Operator + */
b67d701b 12880 case UNARY_PLUS_EXPR:
e04a16fb
AG		 12881 /* 15.14.4 Unary Minus Operator - */
12882 case NEGATE_EXPR:
12883 if (!JNUMERIC_TYPE_P (op_type))
12884 {
12885 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
12886 TREE_TYPE (node) = error_mark_node;
12887 error_found = 1;
12888 }
12889 /* Unary numeric promotion is performed on operand */
12890 else
12891 {
15fdcfe9
PB		 12892 op = do_unary_numeric_promotion (op);
12893 prom_type = TREE_TYPE (op);
b67d701b 12894 if (code == UNARY_PLUS_EXPR)
4a5f66c3 12895 return fold (op);
e04a16fb
AG		 12896 }
12897 break;
12898
12899 /* 15.14.5 Bitwise Complement Operator ~ */
12900 case BIT_NOT_EXPR:
12901 if (!JINTEGRAL_TYPE_P (op_type))
12902 {
12903 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
12904 TREE_TYPE (node) = error_mark_node;
12905 error_found = 1;
12906 }
12907 else
12908 {
15fdcfe9
PB		 12909 op = do_unary_numeric_promotion (op);
12910 prom_type = TREE_TYPE (op);
e04a16fb
AG		 12911 }
12912 break;
12913
12914 /* 15.14.6 Logical Complement Operator ! */
12915 case TRUTH_NOT_EXPR:
12916 if (TREE_CODE (op_type) != BOOLEAN_TYPE)
12917 {
12918 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
c877974e
APB		 12919 /* But the type is known. We will report an error if further
12920 attempt of a assignment is made with this rhs */
e04a16fb
AG		 12921 TREE_TYPE (node) = boolean_type_node;
12922 error_found = 1;
12923 }
12924 else
12925 prom_type = boolean_type_node;
12926 break;
12927
12928 /* 15.15 Cast Expression */
12929 case CONVERT_EXPR:
0a2138e2 12930 value = patch_cast (node, wfl_operator);
e04a16fb 12931 if (value == error_mark_node)
c877974e
APB		 12932 {
12933 /* If this cast is part of an assignment, we tell the code
12934 that deals with it not to complain about a mismatch,
12935 because things have been cast, anyways */
12936 TREE_TYPE (node) = error_mark_node;
12937 error_found = 1;
12938 }
12939 else
dc0b3eff
PB		 12940 {
12941 value = fold (value);
12942 TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
12943 return value;
12944 }
e04a16fb
AG		 12945 break;
12946 }
12947
e04a16fb
AG		 12948 if (error_found)
12949 return error_mark_node;
4a5f66c3
APB		 12950
12951 /* There are cases where node has been replaced by something else
12952 and we don't end up returning here: UNARY_PLUS_EXPR,
12953 CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
7525cc04 12954 TREE_OPERAND (node, 0) = fold (op);
4a5f66c3 12955 TREE_TYPE (node) = prom_type;
dc0b3eff 12956 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
e04a16fb
AG		 12957 return fold (node);
12958}
12959
12960/* Generic type resolution that sometimes takes place during node
12961 patching. Returned the resolved type or generate an error
12962 message. Return the resolved type or NULL_TREE. */
12963
12964static tree
12965resolve_type_during_patch (type)
12966 tree type;
12967{
12968 if (unresolved_type_p (type, NULL))
12969 {
12970 tree type_decl = resolve_no_layout (EXPR_WFL_NODE (type), NULL_TREE);
12971 if (!type_decl)
12972 {
12973 parse_error_context (type,
12974 "Class `%s' not found in type declaration",
12975 IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
12976 return NULL_TREE;
12977 }
12978 else
5e942c50
APB		 12979 {
12980 CLASS_LOADED_P (TREE_TYPE (type_decl)) = 1;
12981 return TREE_TYPE (type_decl);
12982 }
e04a16fb
AG		 12983 }
12984 return type;
12985}
12986/* 5.5 Casting Conversion. error_mark_node is returned if an error is
12987 found. Otherwise NODE or something meant to replace it is returned. */
12988
12989static tree
0a2138e2 12990patch_cast (node, wfl_operator)
e04a16fb 12991 tree node;
e04a16fb
AG		 12992 tree wfl_operator;
12993{
12994 tree op = TREE_OPERAND (node, 0);
12995 tree op_type = TREE_TYPE (op);
12996 tree cast_type = TREE_TYPE (node);
12997 char *t1;
12998
12999 /* First resolve OP_TYPE if unresolved */
13000 if (!(cast_type = resolve_type_during_patch (cast_type)))
13001 return error_mark_node;
13002
13003 /* Check on cast that are proven correct at compile time */
13004 if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
13005 {
e04a16fb
AG		 13006 /* Same type */
13007 if (cast_type == op_type)
13008 return node;
13009
0b4d333e
APB		 13010 /* float and double type are converted to the original type main
13011 variant and then to the target type. */
13012 if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE)
13013 op = convert (integer_type_node, op);
13014
e04a16fb
AG		 13015 /* Try widening/narowwing convertion. Potentially, things need
13016 to be worked out in gcc so we implement the extreme cases
13017 correctly. fold_convert() needs to be fixed. */
13018 return convert (cast_type, op);
13019 }
13020
0b4d333e
APB		 13021 /* It's also valid to cast a boolean into a boolean */
13022 if (op_type == boolean_type_node && cast_type == boolean_type_node)
13023 return node;
13024
5e942c50
APB		 13025 /* null can be casted to references */
13026 if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
13027 return build_null_of_type (cast_type);
13028
e04a16fb
AG		 13029 /* The remaining legal casts involve conversion between reference
13030 types. Check for their compile time correctness. */
13031 if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
09ed0f70 13032 && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
e04a16fb
AG		 13033 {
13034 TREE_TYPE (node) = promote_type (cast_type);
13035 /* Now, the case can be determined correct at compile time if
13036 OP_TYPE can be converted into CAST_TYPE by assignment
13037 conversion (5.2) */
13038
13039 if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
15fdcfe9
PB		 13040 {
13041 TREE_SET_CODE (node, NOP_EXPR);
13042 return node;
13043 }
13044
13045 if (flag_emit_class_files)
13046 {
13047 TREE_SET_CODE (node, CONVERT_EXPR);
13048 return node;
13049 }
e04a16fb
AG		 13050
13051 /* The cast requires a run-time check */
13052 return build (CALL_EXPR, promote_type (cast_type),
13053 build_address_of (soft_checkcast_node),
13054 tree_cons (NULL_TREE, build_class_ref (cast_type),
13055 build_tree_list (NULL_TREE, op)),
13056 NULL_TREE);
13057 }
13058
13059 /* Any other casts are proven incorrect at compile time */
c2e3db92 13060 t1 = xstrdup (lang_printable_name (op_type, 0));
e04a16fb 13061 parse_error_context (wfl_operator, "Invalid cast from `%s' to `%s'",
0a2138e2 13062 t1, lang_printable_name (cast_type, 0));
e04a16fb
AG		 13063 free (t1);
13064 return error_mark_node;
13065}
13066
5e942c50
APB		 13067/* Build a null constant and give it the type TYPE. */
13068
13069static tree
13070build_null_of_type (type)
13071 tree type;
13072{
13073 tree node = build_int_2 (0, 0);
13074 TREE_TYPE (node) = promote_type (type);
13075 return node;
13076}
13077
e04a16fb
AG		 13078/* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
13079 a list of indices. */
13080static tree
13081build_array_ref (location, array, index)
13082 int location;
13083 tree array, index;
13084{
13085 tree node = build (ARRAY_REF, NULL_TREE, array, index);
13086 EXPR_WFL_LINECOL (node) = location;
13087 return node;
13088}
13089
13090/* 15.12 Array Access Expression */
13091
13092static tree
c877974e
APB		 13093patch_array_ref (node)
13094 tree node;
e04a16fb
AG		 13095{
13096 tree array = TREE_OPERAND (node, 0);
13097 tree array_type = TREE_TYPE (array);
13098 tree index = TREE_OPERAND (node, 1);
13099 tree index_type = TREE_TYPE (index);
e04a16fb
AG		 13100 int error_found = 0;
13101
13102 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13103
e04a16fb
AG		 13104 if (TREE_CODE (array_type) == POINTER_TYPE)
13105 array_type = TREE_TYPE (array_type);
13106
13107 /* The array reference must be an array */
13108 if (!TYPE_ARRAY_P (array_type))
13109 {
13110 parse_error_context
781b0558
KG		 13111 (wfl_operator,
13112 "`[]' can only be applied to arrays. It can't be applied to `%s'",
13113 lang_printable_name (array_type, 0));
e04a16fb
AG		 13114 TREE_TYPE (node) = error_mark_node;
13115 error_found = 1;
13116 }
13117
c2952b01 13118 /* The array index undergoes unary numeric promotion. The promoted
e04a16fb 13119 type must be int */
15fdcfe9
PB		 13120 index = do_unary_numeric_promotion (index);
13121 if (TREE_TYPE (index) != int_type_node)
e04a16fb 13122 {
1ebadc60 13123 if (valid_cast_to_p (index_type, int_type_node))
781b0558
KG		 13124 parse_error_context (wfl_operator,
13125 "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
1ebadc60
KG		 13126 lang_printable_name (index_type, 0));
13127 else
781b0558
KG		 13128 parse_error_context (wfl_operator,
13129 "Incompatible type for `[]'. Can't convert `%s' to `int'",
1ebadc60 13130 lang_printable_name (index_type, 0));
e04a16fb
AG		 13131 TREE_TYPE (node) = error_mark_node;
13132 error_found = 1;
13133 }
13134
e04a16fb
AG		 13135 if (error_found)
13136 return error_mark_node;
e04a16fb 13137
5e942c50 13138 array_type = TYPE_ARRAY_ELEMENT (array_type);
5e942c50 13139
7f1d4866 13140 if (flag_emit_class_files || flag_emit_xref)
e04a16fb 13141 {
15fdcfe9
PB		 13142 TREE_OPERAND (node, 0) = array;
13143 TREE_OPERAND (node, 1) = index;
e04a16fb
AG		 13144 }
13145 else
939d7216
PB		 13146 {
13147 /* The save_expr is for correct evaluation order. It would be cleaner
13148 to use force_evaluation_order (see comment there), but that is
13149 difficult when we also have to deal with bounds checking. */
13150 if (TREE_SIDE_EFFECTS (index))
13151 array = save_expr (array);
13152 node = build_java_arrayaccess (array, array_type, index);
13153 if (TREE_SIDE_EFFECTS (index))
13154 node = build (COMPOUND_EXPR, array_type, array, node);
13155 }
e04a16fb
AG		 13156 TREE_TYPE (node) = array_type;
13157 return node;
13158}
13159
13160/* 15.9 Array Creation Expressions */
13161
13162static tree
13163build_newarray_node (type, dims, extra_dims)
13164 tree type;
13165 tree dims;
13166 int extra_dims;
13167{
13168 tree node =
b67d701b 13169 build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
e04a16fb 13170 build_int_2 (extra_dims, 0));
e04a16fb
AG		 13171 return node;
13172}
13173
13174static tree
13175patch_newarray (node)
13176 tree node;
13177{
13178 tree type = TREE_OPERAND (node, 0);
13179 tree dims = TREE_OPERAND (node, 1);
13180 tree cdim, array_type;
13181 int error_found = 0;
13182 int ndims = 0;
13183 int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
e04a16fb
AG		 13184
13185 /* Dimension types are verified. It's better for the types to be
13186 verified in order. */
13187 for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
13188 {
13189 int dim_error = 0;
13190 tree dim = TREE_VALUE (cdim);
13191
13192 /* Dim might have been saved during its evaluation */
13193 dim = (TREE_CODE (dim) == SAVE_EXPR ? dim = TREE_OPERAND (dim, 0) : dim);
13194
13195 /* The type of each specified dimension must be an integral type. */
13196 if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
13197 dim_error = 1;
13198
13199 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
13200 promoted type must be int. */
13201 else
13202 {
15fdcfe9 13203 dim = do_unary_numeric_promotion (dim);
e04a16fb
AG		 13204 if (TREE_TYPE (dim) != int_type_node)
13205 dim_error = 1;
13206 }
13207
13208 /* Report errors on types here */
13209 if (dim_error)
13210 {
13211 parse_error_context
13212 (TREE_PURPOSE (cdim),
781b0558 13213 "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
b67d701b 13214 (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
e04a16fb 13215 "Explicit cast needed to" : "Can't"),
0a2138e2 13216 lang_printable_name (TREE_TYPE (dim), 0));
e04a16fb
AG		 13217 error_found = 1;
13218 }
13219
e04a16fb
AG		 13220 TREE_PURPOSE (cdim) = NULL_TREE;
13221 }
13222
13223 /* Resolve array base type if unresolved */
13224 if (!(type = resolve_type_during_patch (type)))
13225 error_found = 1;
13226
13227 if (error_found)
13228 {
13229 /* We don't want further evaluation of this bogus array creation
13230 operation */
13231 TREE_TYPE (node) = error_mark_node;
13232 return error_mark_node;
13233 }
13234
15fdcfe9
PB		 13235 /* Set array_type to the actual (promoted) array type of the result. */
13236 if (TREE_CODE (type) == RECORD_TYPE)
13237 type = build_pointer_type (type);
13238 while (--xdims >= 0)
13239 {
13240 type = promote_type (build_java_array_type (type, -1));
13241 }
13242 dims = nreverse (dims);
13243 array_type = type;
13244 for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
13245 {
13246 type = array_type;
05bccae2
RK		 13247 array_type
13248 = build_java_array_type (type,
13249 TREE_CODE (cdim) == INTEGER_CST
13250 ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
13251 : -1);
15fdcfe9
PB		 13252 array_type = promote_type (array_type);
13253 }
13254 dims = nreverse (dims);
13255
e04a16fb
AG		 13256 /* The node is transformed into a function call. Things are done
13257 differently according to the number of dimensions. If the number
13258 of dimension is equal to 1, then the nature of the base type
13259 (primitive or not) matters. */
15fdcfe9 13260 if (ndims == 1)
fdec99c6 13261 return build_new_array (type, TREE_VALUE (dims));
e04a16fb 13262
e04a16fb
AG		 13263 /* Can't reuse what's already written in expr.c because it uses the
13264 JVM stack representation. Provide a build_multianewarray. FIXME */
15fdcfe9 13265 return build (CALL_EXPR, array_type,
e04a16fb 13266 build_address_of (soft_multianewarray_node),
15fdcfe9 13267 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
e04a16fb 13268 tree_cons (NULL_TREE,
15fdcfe9 13269 build_int_2 (ndims, 0), dims )),
e04a16fb
AG		 13270 NULL_TREE);
13271}
13272
f8976021
APB		 13273/* 10.6 Array initializer. */
13274
13275/* Build a wfl for array element that don't have one, so we can
13276 pin-point errors. */
13277
13278static tree
13279maybe_build_array_element_wfl (node)
13280 tree node;
13281{
13282 if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
13283 return build_expr_wfl (NULL_TREE, ctxp->filename,
13284 ctxp->elc.line, ctxp->elc.prev_col);
13285 else
13286 return NULL_TREE;
13287}
13288
13289/* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
13290 identification of initialized arrays easier to detect during walk
13291 and expansion. */
13292
13293static tree
13294build_new_array_init (location, values)
13295 int location;
13296 tree values;
13297{
13298 tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
13299 tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
5bba4807 13300 EXPR_WFL_LINECOL (to_return) = location;
f8976021
APB		 13301 return to_return;
13302}
13303
13304/* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
13305 occurred. Otherwise return NODE after having set its type
13306 appropriately. */
13307
13308static tree
13309patch_new_array_init (type, node)
13310 tree type, node;
f8976021
APB		 13311{
13312 int error_seen = 0;
fdec99c6 13313 tree current, element_type;
f8976021 13314 HOST_WIDE_INT length;
fdec99c6
PB		 13315 int all_constant = 1;
13316 tree init = TREE_OPERAND (node, 0);
f8976021 13317
fdec99c6
PB		 13318 if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
13319 {
13320 parse_error_context (node,
13321 "Invalid array initializer for non-array type `%s'",
13322 lang_printable_name (type, 1));
13323 return error_mark_node;
13324 }
13325 type = TREE_TYPE (type);
13326 element_type = TYPE_ARRAY_ELEMENT (type);
f8976021 13327
fdec99c6
PB		 13328 CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
13329
13330 for (length = 0, current = CONSTRUCTOR_ELTS (init);
13331 current; length++, current = TREE_CHAIN (current))
f8976021 13332 {
fdec99c6
PB		 13333 tree elt = TREE_VALUE (current);
13334 if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
f8976021 13335 {
fdec99c6 13336 error_seen |= array_constructor_check_entry (element_type, current);
5bba4807
PB		 13337 elt = TREE_VALUE (current);
13338 /* When compiling to native code, STRING_CST is converted to
13339 INDIRECT_REF, but still with a TREE_CONSTANT flag. */
13340 if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
fdec99c6 13341 all_constant = 0;
f8976021 13342 }
fdec99c6
PB		 13343 else
13344 {
13345 TREE_VALUE (current) = patch_new_array_init (element_type, elt);
13346 TREE_PURPOSE (current) = NULL_TREE;
13347 all_constant = 0;
13348 }
13349 if (elt && TREE_VALUE (elt) == error_mark_node)
13350 error_seen = 1;
f8976021
APB		 13351 }
13352
13353 if (error_seen)
13354 return error_mark_node;
13355
13356 /* Create a new type. We can't reuse the one we have here by
13357 patching its dimension because it originally is of dimension -1
13358 hence reused by gcc. This would prevent triangular arrays. */
fdec99c6
PB		 13359 type = build_java_array_type (element_type, length);
13360 TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
13361 TREE_TYPE (node) = promote_type (type);
13362 TREE_CONSTANT (init) = all_constant;
bc3ca41b 13363 TREE_CONSTANT (node) = all_constant;
f8976021
APB		 13364 return node;
13365}
13366
13367/* Verify that one entry of the initializer element list can be
13368 assigned to the array base type. Report 1 if an error occurred, 0
13369 otherwise. */
13370
13371static int
13372array_constructor_check_entry (type, entry)
13373 tree type, entry;
13374{
13375 char *array_type_string = NULL; /* For error reports */
13376 tree value, type_value, new_value, wfl_value, patched;
13377 int error_seen = 0;
13378
13379 new_value = NULL_TREE;
13380 wfl_value = TREE_VALUE (entry);
13381
100f7cd8 13382 push_obstacks (&permanent_obstack, &permanent_obstack);
f8976021 13383 value = java_complete_tree (TREE_VALUE (entry));
1179ebc2 13384 /* patch_string return error_mark_node if arg is error_mark_node */
f8976021
APB		 13385 if ((patched = patch_string (value)))
13386 value = patched;
1179ebc2
APB		 13387 if (value == error_mark_node)
13388 return 1;
f8976021 13389
f8976021
APB		 13390 type_value = TREE_TYPE (value);
13391
1179ebc2 13392 /* At anytime, try_builtin_assignconv can report a warning on
f8976021
APB		 13393 constant overflow during narrowing. */
13394 SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
13395 new_value = try_builtin_assignconv (wfl_operator, type, value);
13396 if (!new_value && (new_value = try_reference_assignconv (type, value)))
13397 type_value = promote_type (type);
100f7cd8
APB		 13398
13399 pop_obstacks ();
f8976021
APB		 13400 /* Check and report errors */
13401 if (!new_value)
13402 {
49f48c71 13403 const char *msg = (!valid_cast_to_p (type_value, type) ?
f8976021
APB		 13404 "Can't" : "Explicit cast needed to");
13405 if (!array_type_string)
c2e3db92 13406 array_type_string = xstrdup (lang_printable_name (type, 1));
f8976021
APB		 13407 parse_error_context
13408 (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
13409 msg, lang_printable_name (type_value, 1), array_type_string);
13410 error_seen = 1;
13411 }
13412
13413 if (new_value)
13414 {
13415 new_value = maybe_build_primttype_type_ref (new_value, wfl_operator);
13416 TREE_VALUE (entry) = new_value;
13417 }
13418
13419 if (array_type_string)
13420 free (array_type_string);
13421
13422 TREE_PURPOSE (entry) = NULL_TREE;
13423 return error_seen;
13424}
13425
e04a16fb
AG		 13426static tree
13427build_this (location)
13428 int location;
13429{
9ee9b555 13430 tree node = build_wfl_node (this_identifier_node);
b67d701b 13431 TREE_SET_CODE (node, THIS_EXPR);
e04a16fb
AG		 13432 EXPR_WFL_LINECOL (node) = location;
13433 return node;
13434}
13435
13436/* 14.15 The return statement. It builds a modify expression that
13437 assigns the returned value to the RESULT_DECL that hold the value
13438 to be returned. */
13439
13440static tree
13441build_return (location, op)
13442 int location;
13443 tree op;
13444{
13445 tree node = build1 (RETURN_EXPR, NULL_TREE, op);
13446 EXPR_WFL_LINECOL (node) = location;
b67d701b 13447 node = build_debugable_stmt (location, node);
e04a16fb
AG		 13448 return node;
13449}
13450
13451static tree
13452patch_return (node)
13453 tree node;
13454{
13455 tree return_exp = TREE_OPERAND (node, 0);
13456 tree meth = current_function_decl;
13457 tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
e04a16fb
AG		 13458 int error_found = 0;
13459
13460 TREE_TYPE (node) = error_mark_node;
13461 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13462
13463 /* It's invalid to have a return value within a function that is
13464 declared with the keyword void or that is a constructor */
13465 if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
13466 error_found = 1;
13467
f099f336 13468 /* It's invalid to use a return statement in a static block */
c2952b01 13469 if (DECL_CLINIT_P (current_function_decl))
f099f336
APB		 13470 error_found = 1;
13471
e04a16fb
AG		 13472 /* It's invalid to have a no return value within a function that
13473 isn't declared with the keyword `void' */
13474 if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
13475 error_found = 2;
c2952b01
APB		 13476
13477 if (in_instance_initializer)
13478 error_found = 1;
e04a16fb
AG		 13479
13480 if (error_found)
13481 {
c2952b01 13482 if (in_instance_initializer)
f099f336 13483 parse_error_context (wfl_operator,
c2952b01
APB		 13484 "`return' inside instance initializer");
13485
13486 else if (DECL_CLINIT_P (current_function_decl))
13487 parse_error_context (wfl_operator,
13488 "`return' inside static initializer");
f099f336
APB		 13489
13490 else if (!DECL_CONSTRUCTOR_P (meth))
22eed1e6 13491 {
c2e3db92 13492 char *t = xstrdup (lang_printable_name (mtype, 0));
22eed1e6
APB		 13493 parse_error_context (wfl_operator,
13494 "`return' with%s value from `%s %s'",
13495 (error_found == 1 ? "" : "out"),
13496 t, lang_printable_name (meth, 0));
13497 free (t);
13498 }
13499 else
13500 parse_error_context (wfl_operator,
13501 "`return' with value from constructor `%s'",
13502 lang_printable_name (meth, 0));
e04a16fb
AG		 13503 return error_mark_node;
13504 }
13505
5e942c50
APB		 13506 /* If we have a return_exp, build a modify expression and expand
13507 it. Note: at that point, the assignment is declared valid, but we
13508 may want to carry some more hacks */
e04a16fb
AG		 13509 if (return_exp)
13510 {
5e942c50
APB		 13511 tree exp = java_complete_tree (return_exp);
13512 tree modify, patched;
13513
13514 /* If the function returned value and EXP are booleans, EXP has
13515 to be converted into the type of DECL_RESULT, which is integer
13516 (see complete_start_java_method) */
13517 if (TREE_TYPE (exp) == boolean_type_node &&
13518 TREE_TYPE (TREE_TYPE (meth)) == boolean_type_node)
13519 exp = convert_to_integer (TREE_TYPE (DECL_RESULT (meth)), exp);
13520
13521 /* `null' can be assigned to a function returning a reference */
13522 if (JREFERENCE_TYPE_P (TREE_TYPE (TREE_TYPE (meth))) &&
13523 exp == null_pointer_node)
13524 exp = build_null_of_type (TREE_TYPE (TREE_TYPE (meth)));
13525
13526 if ((patched = patch_string (exp)))
13527 exp = patched;
13528
13529 modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
e04a16fb
AG		 13530 EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
13531 modify = java_complete_tree (modify);
5e942c50 13532
e04a16fb
AG		 13533 if (modify != error_mark_node)
13534 {
13535 TREE_SIDE_EFFECTS (modify) = 1;
13536 TREE_OPERAND (node, 0) = modify;
13537 }
13538 else
13539 return error_mark_node;
13540 }
13541 TREE_TYPE (node) = void_type_node;
13542 TREE_SIDE_EFFECTS (node) = 1;
13543 return node;
13544}
13545
13546/* 14.8 The if Statement */
13547
13548static tree
13549build_if_else_statement (location, expression, if_body, else_body)
13550 int location;
13551 tree expression, if_body, else_body;
13552{
13553 tree node;
e04a16fb 13554 if (!else_body)
9bbc7d9f 13555 else_body = empty_stmt_node;
e04a16fb
AG		 13556 node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
13557 EXPR_WFL_LINECOL (node) = location;
b67d701b 13558 node = build_debugable_stmt (location, node);
e04a16fb
AG		 13559 return node;
13560}
13561
13562static tree
13563patch_if_else_statement (node)
13564 tree node;
13565{
13566 tree expression = TREE_OPERAND (node, 0);
13567
13568 TREE_TYPE (node) = error_mark_node;
13569 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13570
13571 /* The type of expression must be boolean */
b67d701b
PB		 13572 if (TREE_TYPE (expression) != boolean_type_node
13573 && TREE_TYPE (expression) != promoted_boolean_type_node)
e04a16fb
AG		 13574 {
13575 parse_error_context
13576 (wfl_operator,
13577 "Incompatible type for `if'. Can't convert `%s' to `boolean'",
0a2138e2 13578 lang_printable_name (TREE_TYPE (expression), 0));
e04a16fb
AG		 13579 return error_mark_node;
13580 }
13581
13582 TREE_TYPE (node) = void_type_node;
13583 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9 13584 CAN_COMPLETE_NORMALLY (node)
9bbc7d9f
PB		 13585 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
13586 | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2));
e04a16fb
AG		 13587 return node;
13588}
13589
13590/* 14.6 Labeled Statements */
13591
13592/* Action taken when a lableled statement is parsed. a new
13593 LABELED_BLOCK_EXPR is created. No statement is attached to the
b635eb2f 13594 label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
e04a16fb
AG		 13595
13596static tree
0a2138e2 13597build_labeled_block (location, label)
e04a16fb 13598 int location;
0a2138e2 13599 tree label;
e04a16fb 13600{
b635eb2f 13601 tree label_name ;
e04a16fb 13602 tree label_decl, node;
b635eb2f
PB		 13603 if (label == NULL_TREE || label == continue_identifier_node)
13604 label_name = label;
13605 else
e04a16fb 13606 {
b635eb2f
PB		 13607 label_name = merge_qualified_name (label_id, label);
13608 /* Issue an error if we try to reuse a label that was previously
13609 declared */
13610 if (IDENTIFIER_LOCAL_VALUE (label_name))
13611 {
13612 EXPR_WFL_LINECOL (wfl_operator) = location;
781b0558
KG		 13613 parse_error_context (wfl_operator,
13614 "Declaration of `%s' shadows a previous label declaration",
b635eb2f
PB		 13615 IDENTIFIER_POINTER (label));
13616 EXPR_WFL_LINECOL (wfl_operator) =
13617 EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
781b0558
KG		 13618 parse_error_context (wfl_operator,
13619 "This is the location of the previous declaration of label `%s'",
b635eb2f
PB		 13620 IDENTIFIER_POINTER (label));
13621 java_error_count--;
13622 }
e04a16fb
AG		 13623 }
13624
13625 label_decl = create_label_decl (label_name);
13626 node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
13627 EXPR_WFL_LINECOL (node) = location;
13628 TREE_SIDE_EFFECTS (node) = 1;
13629 return node;
13630}
13631
b67d701b 13632/* A labeled statement LBE is attached a statement. */
e04a16fb
AG		 13633
13634static tree
b635eb2f 13635finish_labeled_statement (lbe, statement)
e04a16fb
AG		 13636 tree lbe; /* Labeled block expr */
13637 tree statement;
13638{
13639 /* In anyways, tie the loop to its statement */
13640 LABELED_BLOCK_BODY (lbe) = statement;
b635eb2f
PB		 13641 pop_labeled_block ();
13642 POP_LABELED_BLOCK ();
e04a16fb
AG		 13643 return lbe;
13644}
13645
13646/* 14.10, 14.11, 14.12 Loop Statements */
13647
13648/* Create an empty LOOP_EXPR and make it the last in the nested loop
13649 list. */
13650
13651static tree
13652build_new_loop (loop_body)
13653 tree loop_body;
13654{
13655 tree loop = build (LOOP_EXPR, NULL_TREE, loop_body);
13656 TREE_SIDE_EFFECTS (loop) = 1;
13657 PUSH_LOOP (loop);
13658 return loop;
13659}
13660
13661/* Create a loop body according to the following structure:
13662 COMPOUND_EXPR
13663 COMPOUND_EXPR (loop main body)
13664 EXIT_EXPR (this order is for while/for loops.
13665 LABELED_BLOCK_EXPR the order is reversed for do loops)
34f4db93 13666 LABEL_DECL (a continue occuring here branches at the
e04a16fb
AG		 13667 BODY end of this labeled block)
13668 INCREMENT (if any)
13669
13670 REVERSED, if non zero, tells that the loop condition expr comes
b67d701b
PB		 13671 after the body, like in the do-while loop.
13672
13673 To obtain a loop, the loop body structure described above is
13674 encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
13675
13676 LABELED_BLOCK_EXPR
13677 LABEL_DECL (use this label to exit the loop)
13678 LOOP_EXPR
13679 <structure described above> */
e04a16fb
AG		 13680
13681static tree
13682build_loop_body (location, condition, reversed)
13683 int location;
13684 tree condition;
13685 int reversed;
13686{
0a2138e2 13687 tree first, second, body;
e04a16fb
AG		 13688
13689 condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
13690 EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
13691 condition = build_debugable_stmt (location, condition);
13692 TREE_SIDE_EFFECTS (condition) = 1;
13693
b635eb2f 13694 body = build_labeled_block (0, continue_identifier_node);
e04a16fb
AG		 13695 first = (reversed ? body : condition);
13696 second = (reversed ? condition : body);
13697 return
13698 build (COMPOUND_EXPR, NULL_TREE,
9bbc7d9f 13699 build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
e04a16fb
AG		 13700}
13701
13702/* Install CONDITION (if any) and loop BODY (using REVERSED to tell
13703 their order) on the current loop. Unlink the current loop from the
13704 loop list. */
13705
13706static tree
b635eb2f 13707finish_loop_body (location, condition, body, reversed)
e04a16fb
AG		 13708 int location;
13709 tree condition, body;
13710 int reversed;
13711{
13712 tree to_return = ctxp->current_loop;
13713 tree loop_body = LOOP_EXPR_BODY (to_return);
13714 if (condition)
13715 {
13716 tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
13717 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
13718 The real EXIT_EXPR is one operand further. */
13719 EXPR_WFL_LINECOL (cnode) = location;
13720 /* This one is for accurate error reports */
13721 EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
13722 TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
13723 }
13724 LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
13725 POP_LOOP ();
13726 return to_return;
13727}
13728
b635eb2f 13729/* Tailored version of finish_loop_body for FOR loops, when FOR
e04a16fb
AG		 13730 loops feature the condition part */
13731
13732static tree
b635eb2f 13733finish_for_loop (location, condition, update, body)
e04a16fb
AG		 13734 int location;
13735 tree condition, update, body;
13736{
13737 /* Put the condition and the loop body in place */
b635eb2f 13738 tree loop = finish_loop_body (location, condition, body, 0);
e04a16fb
AG		 13739 /* LOOP is the current loop which has been now popped of the loop
13740 stack. Install the update block */
13741 LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
13742 return loop;
13743}
13744
5cbdba64
APB		 13745/* Try to find the loop a block might be related to. This comprises
13746 the case where the LOOP_EXPR is found as the second operand of a
13747 COMPOUND_EXPR, because the loop happens to have an initialization
13748 part, then expressed as the first operand of the COMPOUND_EXPR. If
13749 the search finds something, 1 is returned. Otherwise, 0 is
13750 returned. The search is assumed to start from a
13751 LABELED_BLOCK_EXPR's block. */
13752
13753static tree
13754search_loop (statement)
13755 tree statement;
13756{
13757 if (TREE_CODE (statement) == LOOP_EXPR)
13758 return statement;
13759
13760 if (TREE_CODE (statement) == BLOCK)
13761 statement = BLOCK_SUBBLOCKS (statement);
13762 else
13763 return NULL_TREE;
13764
13765 if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
13766 while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
13767 statement = TREE_OPERAND (statement, 1);
13768
13769 return (TREE_CODE (statement) == LOOP_EXPR
c2952b01 13770 && FOR_LOOP_P (statement) ? statement : NULL_TREE);
5cbdba64
APB		 13771}
13772
13773/* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
13774 returned otherwise. */
13775
13776static int
13777labeled_block_contains_loop_p (block, loop)
13778 tree block, loop;
13779{
13780 if (!block)
13781 return 0;
13782
13783 if (LABELED_BLOCK_BODY (block) == loop)
13784 return 1;
13785
c2952b01 13786 if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
5cbdba64
APB		 13787 return 1;
13788
13789 return 0;
13790}
13791
e04a16fb 13792/* If the loop isn't surrounded by a labeled statement, create one and
b635eb2f 13793 insert LOOP as its body. */
e04a16fb
AG		 13794
13795static tree
13796patch_loop_statement (loop)
13797 tree loop;
13798{
cd9643f7 13799 tree loop_label;
5cbdba64 13800
cd9643f7 13801 TREE_TYPE (loop) = void_type_node;
5cbdba64
APB		 13802 if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
13803 return loop;
13804
cd9643f7 13805 loop_label = build_labeled_block (0, NULL_TREE);
5cbdba64
APB		 13806 /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
13807 that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
cd9643f7
PB		 13808 LABELED_BLOCK_BODY (loop_label) = loop;
13809 PUSH_LABELED_BLOCK (loop_label);
5cbdba64 13810 return loop_label;
e04a16fb
AG		 13811}
13812
13813/* 14.13, 14.14: break and continue Statements */
13814
13815/* Build a break or a continue statement. a null NAME indicates an
13816 unlabeled break/continue statement. */
13817
13818static tree
13819build_bc_statement (location, is_break, name)
13820 int location, is_break;
13821 tree name;
13822{
13823 tree break_continue, label_block_expr = NULL_TREE;
13824
13825 if (name)
13826 {
13827 if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
13828 (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
13829 /* Null means that we don't have a target for this named
13830 break/continue. In this case, we make the target to be the
13831 label name, so that the error can be reported accuratly in
13832 patch_bc_statement. */
13833 label_block_expr = EXPR_WFL_NODE (name);
13834 }
13835 /* Unlabeled break/continue will be handled during the
13836 break/continue patch operation */
13837 break_continue
13838 = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
13839
13840 IS_BREAK_STMT_P (break_continue) = is_break;
13841 TREE_SIDE_EFFECTS (break_continue) = 1;
13842 EXPR_WFL_LINECOL (break_continue) = location;
b67d701b 13843 break_continue = build_debugable_stmt (location, break_continue);
e04a16fb
AG		 13844 return break_continue;
13845}
13846
13847/* Verification of a break/continue statement. */
13848
13849static tree
13850patch_bc_statement (node)
13851 tree node;
13852{
13853 tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
b635eb2f 13854 tree labeled_block = ctxp->current_labeled_block;
b67d701b 13855 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
e04a16fb 13856
e04a16fb 13857 /* Having an identifier here means that the target is unknown. */
b635eb2f 13858 if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
e04a16fb
AG		 13859 {
13860 parse_error_context (wfl_operator, "No label definition found for `%s'",
13861 IDENTIFIER_POINTER (bc_label));
13862 return error_mark_node;
13863 }
b635eb2f 13864 if (! IS_BREAK_STMT_P (node))
e04a16fb 13865 {
b635eb2f
PB		 13866 /* It's a continue statement. */
13867 for (;; labeled_block = TREE_CHAIN (labeled_block))
e04a16fb 13868 {
b635eb2f
PB		 13869 if (labeled_block == NULL_TREE)
13870 {
13871 if (bc_label == NULL_TREE)
13872 parse_error_context (wfl_operator,
13873 "`continue' must be in loop");
13874 else
1504b2b4
APB		 13875 parse_error_context
13876 (wfl_operator, "continue label `%s' does not name a loop",
13877 IDENTIFIER_POINTER (bc_label));
b635eb2f
PB		 13878 return error_mark_node;
13879 }
13880 if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
13881 == continue_identifier_node)
13882 && (bc_label == NULL_TREE
13883 || TREE_CHAIN (labeled_block) == bc_label))
13884 {
13885 bc_label = labeled_block;
13886 break;
13887 }
e04a16fb 13888 }
e04a16fb 13889 }
b635eb2f 13890 else if (!bc_label)
34f4db93 13891 {
b635eb2f 13892 for (;; labeled_block = TREE_CHAIN (labeled_block))
e04a16fb 13893 {
b635eb2f
PB		 13894 if (labeled_block == NULL_TREE)
13895 {
13896 parse_error_context (wfl_operator,
13897 "`break' must be in loop or switch");
13898 return error_mark_node;
13899 }
13900 target_stmt = LABELED_BLOCK_BODY (labeled_block);
13901 if (TREE_CODE (target_stmt) == SWITCH_EXPR
5cbdba64 13902 || search_loop (target_stmt))
b635eb2f
PB		 13903 {
13904 bc_label = labeled_block;
13905 break;
13906 }
e04a16fb 13907 }
e04a16fb
AG		 13908 }
13909
b635eb2f 13910 EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15fdcfe9
PB		 13911 CAN_COMPLETE_NORMALLY (bc_label) = 1;
13912
e04a16fb
AG		 13913 /* Our break/continue don't return values. */
13914 TREE_TYPE (node) = void_type_node;
13915 /* Encapsulate the break within a compound statement so that it's
5cbdba64 13916 expanded all the times by expand_expr (and not clobbered
e04a16fb
AG		 13917 sometimes, like after a if statement) */
13918 node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
13919 TREE_SIDE_EFFECTS (node) = 1;
13920 return node;
13921}
13922
13923/* Process the exit expression belonging to a loop. Its type must be
13924 boolean. */
13925
13926static tree
13927patch_exit_expr (node)
13928 tree node;
13929{
13930 tree expression = TREE_OPERAND (node, 0);
13931 TREE_TYPE (node) = error_mark_node;
13932 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13933
13934 /* The type of expression must be boolean */
13935 if (TREE_TYPE (expression) != boolean_type_node)
13936 {
13937 parse_error_context
13938 (wfl_operator,
781b0558 13939 "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
0a2138e2 13940 lang_printable_name (TREE_TYPE (expression), 0));
e04a16fb
AG		 13941 return error_mark_node;
13942 }
13943 /* Now we know things are allright, invert the condition, fold and
13944 return */
13945 TREE_OPERAND (node, 0) =
13946 fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15fdcfe9
PB		 13947
13948 if (! integer_zerop (TREE_OPERAND (node, 0))
13949 && ctxp->current_loop != NULL_TREE
13950 && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
13951 CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
13952 if (! integer_onep (TREE_OPERAND (node, 0)))
13953 CAN_COMPLETE_NORMALLY (node) = 1;
13954
13955
e04a16fb
AG		 13956 TREE_TYPE (node) = void_type_node;
13957 return node;
13958}
b67d701b
PB		 13959
13960/* 14.9 Switch statement */
13961
13962static tree
13963patch_switch_statement (node)
13964 tree node;
13965{
c877974e 13966 tree se = TREE_OPERAND (node, 0), se_type;
b67d701b
PB		 13967
13968 /* Complete the switch expression */
13969 se = TREE_OPERAND (node, 0) = java_complete_tree (se);
13970 se_type = TREE_TYPE (se);
13971 /* The type of the switch expression must be char, byte, short or
13972 int */
13973 if (!JINTEGRAL_TYPE_P (se_type))
13974 {
13975 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
781b0558
KG		 13976 parse_error_context (wfl_operator,
13977 "Incompatible type for `switch'. Can't convert `%s' to `int'",
0a2138e2 13978 lang_printable_name (se_type, 0));
b67d701b
PB		 13979 /* This is what java_complete_tree will check */
13980 TREE_OPERAND (node, 0) = error_mark_node;
13981 return error_mark_node;
13982 }
13983
15fdcfe9 13984 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
b67d701b
PB		 13985
13986 /* Ready to return */
15fdcfe9 13987 if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
b67d701b
PB		 13988 {
13989 TREE_TYPE (node) = error_mark_node;
13990 return error_mark_node;
13991 }
13992 TREE_TYPE (node) = void_type_node;
13993 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9 13994 CAN_COMPLETE_NORMALLY (node)
c877974e
APB		 13995 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
13996 || ! SWITCH_HAS_DEFAULT (node);
b67d701b
PB		 13997 return node;
13998}
13999
165f37bc 14000/* 14.18 The try/catch statements */
b67d701b 14001
b67d701b 14002static tree
a7d8d81f 14003build_try_statement (location, try_block, catches)
b67d701b 14004 int location;
a7d8d81f
PB		 14005 tree try_block, catches;
14006{
14007 tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
b67d701b 14008 EXPR_WFL_LINECOL (node) = location;
a7d8d81f 14009 return node;
b67d701b
PB		 14010}
14011
a7d8d81f
PB		 14012static tree
14013build_try_finally_statement (location, try_block, finally)
14014 int location;
14015 tree try_block, finally;
b67d701b 14016{
a7d8d81f
PB		 14017 tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
14018 EXPR_WFL_LINECOL (node) = location;
14019 return node;
b67d701b
PB		 14020}
14021
14022static tree
14023patch_try_statement (node)
14024 tree node;
14025{
14026 int error_found = 0;
14027 tree try = TREE_OPERAND (node, 0);
14028 /* Exception handlers are considered in left to right order */
14029 tree catch = nreverse (TREE_OPERAND (node, 1));
b9f7e36c 14030 tree current, caught_type_list = NULL_TREE;
b67d701b
PB		 14031
14032 /* Check catch clauses, if any. Every time we find an error, we try
b9f7e36c
APB		 14033 to process the next catch clause. We process the catch clause before
14034 the try block so that when processing the try block we can check thrown
14035 exceptions againts the caught type list. */
b67d701b
PB		 14036 for (current = catch; current; current = TREE_CHAIN (current))
14037 {
14038 tree carg_decl, carg_type;
14039 tree sub_current, catch_block, catch_clause;
14040 int unreachable;
14041
b67d701b 14042 /* At this point, the structure of the catch clause is
b67d701b
PB		 14043 CATCH_EXPR (catch node)
14044 BLOCK (with the decl of the parameter)
14045 COMPOUND_EXPR
7525cc04 14046 MODIFY_EXPR (assignment of the catch parameter)
b67d701b 14047 BLOCK (catch clause block)
a7d8d81f
PB		 14048 */
14049 catch_clause = TREE_OPERAND (current, 0);
b67d701b
PB		 14050 carg_decl = BLOCK_EXPR_DECLS (catch_clause);
14051 carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
14052
14053 /* Catch clauses can't have more than one parameter declared,
14054 but it's already enforced by the grammar. Make sure that the
14055 only parameter of the clause statement in of class Throwable
14056 or a subclass of Throwable, but that was done earlier. The
14057 catch clause parameter type has also been resolved. */
14058
14059 /* Just make sure that the catch clause parameter type inherits
14060 from java.lang.Throwable */
14061 if (!inherits_from_p (carg_type, throwable_type_node))
14062 {
14063 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
14064 parse_error_context (wfl_operator,
781b0558 14065 "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
0a2138e2 14066 lang_printable_name (carg_type, 0));
b67d701b
PB		 14067 error_found = 1;
14068 continue;
14069 }
14070
14071 /* Partial check for unreachable catch statement: The catch
14072 clause is reachable iff is no earlier catch block A in
14073 the try statement such that the type of the catch
14074 clause's parameter is the same as or a subclass of the
14075 type of A's parameter */
14076 unreachable = 0;
14077 for (sub_current = catch;
14078 sub_current != current; sub_current = TREE_CHAIN (sub_current))
14079 {
14080 tree sub_catch_clause, decl;
a7d8d81f 14081 sub_catch_clause = TREE_OPERAND (sub_current, 0);
b67d701b
PB		 14082 decl = BLOCK_EXPR_DECLS (sub_catch_clause);
14083
14084 if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
14085 {
14086 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
14087 parse_error_context
781b0558
KG		 14088 (wfl_operator,
14089 "`catch' not reached because of the catch clause at line %d",
14090 EXPR_WFL_LINENO (sub_current));
b67d701b
PB		 14091 unreachable = error_found = 1;
14092 break;
14093 }
14094 }
b67d701b
PB		 14095 /* Complete the catch clause block */
14096 catch_block = java_complete_tree (TREE_OPERAND (current, 0));
14097 if (catch_block == error_mark_node)
14098 {
14099 error_found = 1;
14100 continue;
14101 }
15fdcfe9
PB		 14102 if (CAN_COMPLETE_NORMALLY (catch_block))
14103 CAN_COMPLETE_NORMALLY (node) = 1;
b67d701b 14104 TREE_OPERAND (current, 0) = catch_block;
15fdcfe9
PB		 14105
14106 if (unreachable)
14107 continue;
14108
14109 /* Things to do here: the exception must be thrown */
14110
14111 /* Link this type to the caught type list */
14112 caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
b67d701b
PB		 14113 }
14114
b9f7e36c
APB		 14115 PUSH_EXCEPTIONS (caught_type_list);
14116 if ((try = java_complete_tree (try)) == error_mark_node)
14117 error_found = 1;
15fdcfe9
PB		 14118 if (CAN_COMPLETE_NORMALLY (try))
14119 CAN_COMPLETE_NORMALLY (node) = 1;
b9f7e36c
APB		 14120 POP_EXCEPTIONS ();
14121
b67d701b
PB		 14122 /* Verification ends here */
14123 if (error_found)
14124 return error_mark_node;
14125
14126 TREE_OPERAND (node, 0) = try;
14127 TREE_OPERAND (node, 1) = catch;
b67d701b
PB		 14128 TREE_TYPE (node) = void_type_node;
14129 return node;
14130}
b9f7e36c
APB		 14131
14132/* 14.17 The synchronized Statement */
14133
14134static tree
14135patch_synchronized_statement (node, wfl_op1)
14136 tree node, wfl_op1;
14137{
5a005d9e 14138 tree expr = java_complete_tree (TREE_OPERAND (node, 0));
b9f7e36c 14139 tree block = TREE_OPERAND (node, 1);
5a005d9e 14140
d8fccff5 14141 tree enter, exit, expr_decl, assignment;
5a005d9e
PB		 14142
14143 if (expr == error_mark_node)
14144 {
14145 block = java_complete_tree (block);
14146 return expr;
14147 }
b9f7e36c
APB		 14148
14149 /* The TYPE of expr must be a reference type */
5a005d9e 14150 if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
b9f7e36c
APB		 14151 {
14152 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
781b0558 14153 parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
0a2138e2 14154 lang_printable_name (TREE_TYPE (expr), 0));
b9f7e36c
APB		 14155 return error_mark_node;
14156 }
14157
ce6e9147
APB		 14158 if (flag_emit_xref)
14159 {
14160 TREE_OPERAND (node, 0) = expr;
14161 TREE_OPERAND (node, 1) = java_complete_tree (block);
14162 CAN_COMPLETE_NORMALLY (node) = 1;
14163 return node;
14164 }
14165
b9f7e36c
APB		 14166 /* Generate a try-finally for the synchronized statement, except
14167 that the handler that catches all throw exception calls
14168 _Jv_MonitorExit and then rethrow the exception.
14169 The synchronized statement is then implemented as:
14170 TRY
14171 {
14172 _Jv_MonitorEnter (expression)
14173 synchronized_block
14174 _Jv_MonitorExit (expression)
14175 }
14176 CATCH_ALL
14177 {
14178 e = _Jv_exception_info ();
14179 _Jv_MonitorExit (expression)
14180 Throw (e);
14181 } */
14182
5a005d9e
PB		 14183 expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
14184 BUILD_MONITOR_ENTER (enter, expr_decl);
14185 BUILD_MONITOR_EXIT (exit, expr_decl);
14186 CAN_COMPLETE_NORMALLY (enter) = 1;
14187 CAN_COMPLETE_NORMALLY (exit) = 1;
96847892
AH		 14188 assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
14189 TREE_SIDE_EFFECTS (assignment) = 1;
5a005d9e
PB		 14190 node = build1 (CLEANUP_POINT_EXPR, NULL_TREE,
14191 build (COMPOUND_EXPR, NULL_TREE,
14192 build (WITH_CLEANUP_EXPR, NULL_TREE,
14193 build (COMPOUND_EXPR, NULL_TREE,
96847892 14194 assignment, enter),
5a005d9e
PB		 14195 NULL_TREE, exit),
14196 block));
14197 node = build_expr_block (node, expr_decl);
14198
14199 return java_complete_tree (node);
b9f7e36c
APB		 14200}
14201
14202/* 14.16 The throw Statement */
14203
14204static tree
14205patch_throw_statement (node, wfl_op1)
14206 tree node, wfl_op1;
14207{
14208 tree expr = TREE_OPERAND (node, 0);
14209 tree type = TREE_TYPE (expr);
14210 int unchecked_ok = 0, tryblock_throws_ok = 0;
14211
14212 /* Thrown expression must be assignable to java.lang.Throwable */
14213 if (!try_reference_assignconv (throwable_type_node, expr))
14214 {
14215 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
781b0558
KG		 14216 parse_error_context (wfl_operator,
14217 "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
0a2138e2 14218 lang_printable_name (type, 0));
b9f7e36c
APB		 14219 /* If the thrown expression was a reference, we further the
14220 compile-time check. */
14221 if (!JREFERENCE_TYPE_P (type))
14222 return error_mark_node;
14223 }
14224
14225 /* At least one of the following must be true */
14226
14227 /* The type of the throw expression is a not checked exception,
14228 i.e. is a unchecked expression. */
c877974e 14229 unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
b9f7e36c 14230
c2952b01
APB		 14231 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
14232 /* An instance can't throw a checked excetion unless that exception
14233 is explicitely declared in the `throws' clause of each
14234 constructor. This doesn't apply to anonymous classes, since they
14235 don't have declared constructors. */
14236 if (!unchecked_ok
14237 && in_instance_initializer && !ANONYMOUS_CLASS_P (current_class))
14238 {
14239 tree current;
14240 for (current = TYPE_METHODS (current_class); current;
14241 current = TREE_CHAIN (current))
14242 if (DECL_CONSTRUCTOR_P (current)
14243 && !check_thrown_exceptions_do (TREE_TYPE (expr)))
14244 {
14245 parse_error_context (wfl_operator, "Checked exception `%s' can't be thrown in instance initializer (not all declared constructor are declaring it in their `throws' clause)",
14246 lang_printable_name (TREE_TYPE (expr), 0));
14247 return error_mark_node;
14248 }
14249 }
14250
b9f7e36c
APB		 14251 /* Throw is contained in a try statement and at least one catch
14252 clause can receive the thrown expression or the current method is
14253 declared to throw such an exception. Or, the throw statement is
14254 contained in a method or constructor declaration and the type of
14255 the Expression is assignable to at least one type listed in the
14256 throws clause the declaration. */
b9f7e36c 14257 if (!unchecked_ok)
f099f336 14258 tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
b9f7e36c
APB		 14259 if (!(unchecked_ok || tryblock_throws_ok))
14260 {
14261 /* If there is a surrounding try block that has no matching
14262 clatch clause, report it first. A surrounding try block exits
14263 only if there is something after the list of checked
14264 exception thrown by the current function (if any). */
14265 if (IN_TRY_BLOCK_P ())
781b0558 14266 parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
0a2138e2 14267 lang_printable_name (type, 0));
b9f7e36c
APB		 14268 /* If we have no surrounding try statement and the method doesn't have
14269 any throws, report it now. FIXME */
f099f336
APB		 14270
14271 /* We report that the exception can't be throw from a try block
14272 in all circumstances but when the `throw' is inside a static
14273 block. */
b9f7e36c
APB		 14274 else if (!EXCEPTIONS_P (currently_caught_type_list)
14275 && !tryblock_throws_ok)
f099f336 14276 {
c2952b01 14277 if (DECL_CLINIT_P (current_function_decl))
781b0558
KG		 14278 parse_error_context (wfl_operator,
14279 "Checked exception `%s' can't be thrown in initializer",
f099f336
APB		 14280 lang_printable_name (type, 0));
14281 else
781b0558
KG		 14282 parse_error_context (wfl_operator,
14283 "Checked exception `%s' isn't thrown from a `try' block",
f099f336
APB		 14284 lang_printable_name (type, 0));
14285 }
b9f7e36c
APB		 14286 /* Otherwise, the current method doesn't have the appropriate
14287 throws declaration */
14288 else
781b0558 14289 parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
0a2138e2 14290 lang_printable_name (type, 0));
b9f7e36c
APB		 14291 return error_mark_node;
14292 }
14293
ce6e9147 14294 if (! flag_emit_class_files && ! flag_emit_xref)
15fdcfe9 14295 BUILD_THROW (node, expr);
ce6e9147
APB		 14296
14297 /* If doing xrefs, keep the location where the `throw' was seen. */
14298 if (flag_emit_xref)
14299 EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
b9f7e36c
APB		 14300 return node;
14301}
14302
14303/* Check that exception said to be thrown by method DECL can be
14304 effectively caught from where DECL is invoked. */
14305
14306static void
14307check_thrown_exceptions (location, decl)
14308 int location;
14309 tree decl;
14310{
14311 tree throws;
14312 /* For all the unchecked exceptions thrown by DECL */
14313 for (throws = DECL_FUNCTION_THROWS (decl); throws;
14314 throws = TREE_CHAIN (throws))
0a2138e2 14315 if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
b9f7e36c 14316 {
3e78f871
PB		 14317#if 1
14318 /* Temporary hack to suppresses errors about cloning arrays. FIXME */
14319 if (DECL_NAME (decl) == get_identifier ("clone"))
14320 continue;
14321#endif
b9f7e36c 14322 EXPR_WFL_LINECOL (wfl_operator) = location;
c2952b01 14323 if (DECL_FINIT_P (current_function_decl))
7705e9db
APB		 14324 parse_error_context
14325 (wfl_operator, "Exception `%s' can't be thrown in initializer",
14326 lang_printable_name (TREE_VALUE (throws), 0));
14327 else
14328 {
14329 parse_error_context
781b0558 14330 (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
7705e9db 14331 lang_printable_name (TREE_VALUE (throws), 0),
c2952b01 14332 (DECL_INIT_P (current_function_decl) ?
7705e9db
APB		 14333 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
14334 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
14335 }
b9f7e36c
APB		 14336 }
14337}
14338
c877974e 14339/* Return 1 if checked EXCEPTION is caught at the current nesting level of
b9f7e36c
APB		 14340 try-catch blocks, OR is listed in the `throws' clause of the
14341 current method. */
14342
14343static int
0a2138e2 14344check_thrown_exceptions_do (exception)
b9f7e36c
APB		 14345 tree exception;
14346{
14347 tree list = currently_caught_type_list;
c877974e 14348 resolve_and_layout (exception, NULL_TREE);
b9f7e36c
APB		 14349 /* First, all the nested try-catch-finally at that stage. The
14350 last element contains `throws' clause exceptions, if any. */
c877974e
APB		 14351 if (IS_UNCHECKED_EXCEPTION_P (exception))
14352 return 1;
b9f7e36c
APB		 14353 while (list)
14354 {
14355 tree caught;
14356 for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
14357 if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
14358 return 1;
14359 list = TREE_CHAIN (list);
14360 }
14361 return 0;
14362}
14363
14364static void
14365purge_unchecked_exceptions (mdecl)
14366 tree mdecl;
14367{
14368 tree throws = DECL_FUNCTION_THROWS (mdecl);
14369 tree new = NULL_TREE;
14370
14371 while (throws)
14372 {
14373 tree next = TREE_CHAIN (throws);
c877974e 14374 if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
b9f7e36c
APB		 14375 {
14376 TREE_CHAIN (throws) = new;
14377 new = throws;
14378 }
14379 throws = next;
14380 }
14381 /* List is inverted here, but it doesn't matter */
14382 DECL_FUNCTION_THROWS (mdecl) = new;
14383}
22eed1e6
APB		 14384
14385/* 15.24 Conditional Operator ?: */
14386
14387static tree
14388patch_conditional_expr (node, wfl_cond, wfl_op1)
14389 tree node, wfl_cond, wfl_op1;
14390{
14391 tree cond = TREE_OPERAND (node, 0);
14392 tree op1 = TREE_OPERAND (node, 1);
14393 tree op2 = TREE_OPERAND (node, 2);
22eed1e6 14394 tree resulting_type = NULL_TREE;
ac825856 14395 tree t1, t2, patched;
22eed1e6
APB		 14396 int error_found = 0;
14397
ac825856
APB		 14398 /* Operands of ?: might be StringBuffers crafted as a result of a
14399 string concatenation. Obtain a descent operand here. */
14400 if ((patched = patch_string (op1)))
14401 TREE_OPERAND (node, 1) = op1 = patched;
14402 if ((patched = patch_string (op2)))
14403 TREE_OPERAND (node, 2) = op2 = patched;
14404
14405 t1 = TREE_TYPE (op1);
14406 t2 = TREE_TYPE (op2);
14407
22eed1e6
APB		 14408 /* The first expression must be a boolean */
14409 if (TREE_TYPE (cond) != boolean_type_node)
14410 {
14411 SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
781b0558
KG		 14412 parse_error_context (wfl_operator,
14413 "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
22eed1e6
APB		 14414 lang_printable_name (TREE_TYPE (cond), 0));
14415 error_found = 1;
14416 }
14417
14418 /* Second and third can be numeric, boolean (i.e. primitive),
14419 references or null. Anything else results in an error */
14420 if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
14421 || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
14422 && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
14423 || (t1 == boolean_type_node && t2 == boolean_type_node)))
14424 error_found = 1;
14425
14426 /* Determine the type of the conditional expression. Same types are
14427 easy to deal with */
14428 else if (t1 == t2)
14429 resulting_type = t1;
14430
14431 /* There are different rules for numeric types */
14432 else if (JNUMERIC_TYPE_P (t1))
14433 {
14434 /* if byte/short found, the resulting type is short */
14435 if ((t1 == byte_type_node && t2 == short_type_node)
14436 || (t1 == short_type_node && t2 == byte_type_node))
14437 resulting_type = short_type_node;
14438
14439 /* If t1 is a constant int and t2 is of type byte, short or char
14440 and t1's value fits in t2, then the resulting type is t2 */
14441 else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
14442 && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
14443 resulting_type = t2;
14444
14445 /* If t2 is a constant int and t1 is of type byte, short or char
14446 and t2's value fits in t1, then the resulting type is t1 */
14447 else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
14448 && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
14449 resulting_type = t1;
14450
14451 /* Otherwise, binary numeric promotion is applied and the
14452 resulting type is the promoted type of operand 1 and 2 */
14453 else
93024893 14454 resulting_type = binary_numeric_promotion (t1, t2,
22eed1e6
APB		 14455 &TREE_OPERAND (node, 1),
14456 &TREE_OPERAND (node, 2));
14457 }
14458
14459 /* Cases of a reference and a null type */
14460 else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
14461 resulting_type = t1;
14462
14463 else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
14464 resulting_type = t2;
14465
14466 /* Last case: different reference types. If a type can be converted
14467 into the other one by assignment conversion, the latter
14468 determines the type of the expression */
14469 else if ((resulting_type = try_reference_assignconv (t1, op2)))
14470 resulting_type = promote_type (t1);
14471
14472 else if ((resulting_type = try_reference_assignconv (t2, op1)))
14473 resulting_type = promote_type (t2);
14474
14475 /* If we don't have any resulting type, we're in trouble */
14476 if (!resulting_type)
14477 {
c2e3db92 14478 char *t = xstrdup (lang_printable_name (t1, 0));
22eed1e6 14479 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
781b0558
KG		 14480 parse_error_context (wfl_operator,
14481 "Incompatible type for `?:'. Can't convert `%s' to `%s'",
14482 t, lang_printable_name (t2, 0));
22eed1e6
APB		 14483 free (t);
14484 error_found = 1;
14485 }
14486
14487 if (error_found)
14488 {
14489 TREE_TYPE (node) = error_mark_node;
14490 return error_mark_node;
14491 }
14492
14493 TREE_TYPE (node) = resulting_type;
14494 TREE_SET_CODE (node, COND_EXPR);
15fdcfe9 14495 CAN_COMPLETE_NORMALLY (node) = 1;
22eed1e6
APB		 14496 return node;
14497}
ac825856 14498
5b09b33e
PB		 14499/* Try to constant fold NODE.
14500 If NODE is not a constant expression, return NULL_EXPR.
14501 CONTEXT is a static final VAR_DECL whose initializer we are folding. */
14502
14503static tree
14504fold_constant_for_init (node, context)
14505 tree node;
14506 tree context;
14507{
14508 tree op0, op1, val;
14509 enum tree_code code = TREE_CODE (node);
14510
93024893 14511 if (code == STRING_CST)
5b09b33e 14512 return node;
93024893
APB		 14513
14514 if (code == INTEGER_CST || code == REAL_CST)
14515 return convert (TREE_TYPE (context), node);
8576f094 14516 if (TREE_TYPE (node) != NULL_TREE && code != VAR_DECL && code != FIELD_DECL)
5b09b33e
PB		 14517 return NULL_TREE;
14518
14519 switch (code)
14520 {
5b09b33e
PB		 14521 case PLUS_EXPR:
14522 case MINUS_EXPR:
bc3ca41b
PB		 14523 case MULT_EXPR:
14524 case TRUNC_MOD_EXPR:
14525 case RDIV_EXPR:
5b09b33e
PB		 14526 case LSHIFT_EXPR:
14527 case RSHIFT_EXPR:
14528 case URSHIFT_EXPR:
14529 case BIT_AND_EXPR:
14530 case BIT_XOR_EXPR:
14531 case BIT_IOR_EXPR:
5b09b33e
PB		 14532 case TRUTH_ANDIF_EXPR:
14533 case TRUTH_ORIF_EXPR:
14534 case EQ_EXPR:
14535 case NE_EXPR:
14536 case GT_EXPR:
14537 case GE_EXPR:
14538 case LT_EXPR:
14539 case LE_EXPR:
14540 op0 = TREE_OPERAND (node, 0);
14541 op1 = TREE_OPERAND (node, 1);
14542 val = fold_constant_for_init (op0, context);
14543 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14544 return NULL_TREE;
14545 TREE_OPERAND (node, 0) = val;
14546 val = fold_constant_for_init (op1, context);
14547 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14548 return NULL_TREE;
14549 TREE_OPERAND (node, 1) = val;
14550 return patch_binop (node, op0, op1);
14551
14552 case UNARY_PLUS_EXPR:
14553 case NEGATE_EXPR:
14554 case TRUTH_NOT_EXPR:
14555 case BIT_NOT_EXPR:
14556 case CONVERT_EXPR:
14557 op0 = TREE_OPERAND (node, 0);
14558 val = fold_constant_for_init (op0, context);
14559 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14560 return NULL_TREE;
14561 TREE_OPERAND (node, 0) = val;
5a005d9e 14562 return patch_unaryop (node, op0);
5b09b33e
PB		 14563 break;
14564
14565 case COND_EXPR:
14566 val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
14567 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14568 return NULL_TREE;
14569 TREE_OPERAND (node, 0) = val;
14570 val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
14571 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14572 return NULL_TREE;
14573 TREE_OPERAND (node, 1) = val;
14574 val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
14575 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14576 return NULL_TREE;
14577 TREE_OPERAND (node, 2) = val;
14578 return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
14579 : TREE_OPERAND (node, 2);
14580
14581 case VAR_DECL:
8576f094
APB		 14582 case FIELD_DECL:
14583 if (! FIELD_FINAL (node)
5b09b33e
PB		 14584 || DECL_INITIAL (node) == NULL_TREE)
14585 return NULL_TREE;
14586 val = DECL_INITIAL (node);
14587 /* Guard against infinite recursion. */
14588 DECL_INITIAL (node) = NULL_TREE;
cd9643f7 14589 val = fold_constant_for_init (val, node);
5b09b33e
PB		 14590 DECL_INITIAL (node) = val;
14591 return val;
14592
14593 case EXPR_WITH_FILE_LOCATION:
14594 /* Compare java_complete_tree and resolve_expression_name. */
14595 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
14596 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
14597 {
14598 tree name = EXPR_WFL_NODE (node);
14599 tree decl;
14600 if (PRIMARY_P (node))
14601 return NULL_TREE;
14602 else if (! QUALIFIED_P (name))
14603 {
14604 decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
8576f094
APB		 14605 if (decl == NULL_TREE
14606 || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
5b09b33e
PB		 14607 return NULL_TREE;
14608 return fold_constant_for_init (decl, decl);
14609 }
14610 else
14611 {
5b09b33e
PB		 14612 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
14613 qualify_ambiguous_name (node);
14614 if (resolve_field_access (node, &decl, NULL)
14615 && decl != NULL_TREE)
14616 return fold_constant_for_init (decl, decl);
5b09b33e
PB		 14617 return NULL_TREE;
14618 }
14619 }
14620 else
14621 {
14622 op0 = TREE_OPERAND (node, 0);
14623 val = fold_constant_for_init (op0, context);
14624 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14625 return NULL_TREE;
14626 TREE_OPERAND (node, 0) = val;
14627 return val;
14628 }
14629
bc3ca41b
PB		 14630#ifdef USE_COMPONENT_REF
14631 case IDENTIFIER:
14632 case COMPONENT_REF:
14633 ?;
14634#endif
14635
5b09b33e
PB		 14636 default:
14637 return NULL_TREE;
14638 }
14639}
bc3ca41b
PB		 14640
14641#ifdef USE_COMPONENT_REF
14642/* Context is 'T' for TypeName, 'P' for PackageName,
14643 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
14644
14645tree
14646resolve_simple_name (name, context)
14647 tree name;
14648 int context;
14649{
14650}
14651
14652tree
14653resolve_qualified_name (name, context)
14654 tree name;
14655 int context;
14656{
14657}
14658#endif
GNU Compiler Collection
This page took 2.180154 seconds and 5 git commands to generate.