]> 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
PropertyChangeEvent.java (oldVal): Renamed to oldValue.
[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));
9a7ab4b3 102static void find_in_imports PARAMS ((tree));
cf1748bf 103static void check_inner_class_access PARAMS ((tree, tree, tree));
df32d2ce 104static int check_pkg_class_access PARAMS ((tree, tree));
9a7ab4b3 105static void register_package PARAMS ((tree));
df32d2ce
KG		 106static tree resolve_package PARAMS ((tree, tree *));
107static tree lookup_package_type PARAMS ((const char *, int));
108static tree lookup_package_type_and_set_next PARAMS ((const char *, int, tree *));
c2952b01 109static tree resolve_class PARAMS ((tree, tree, tree, tree));
df32d2ce
KG		 110static void declare_local_variables PARAMS ((int, tree, tree));
111static void source_start_java_method PARAMS ((tree));
112static void source_end_java_method PARAMS ((void));
113static void expand_start_java_method PARAMS ((tree));
114static tree find_name_in_single_imports PARAMS ((tree));
115static void check_abstract_method_header PARAMS ((tree));
116static tree lookup_java_interface_method2 PARAMS ((tree, tree));
117static tree resolve_expression_name PARAMS ((tree, tree *));
c2952b01 118static tree maybe_create_class_interface_decl PARAMS ((tree, tree, tree, tree));
df32d2ce 119static int check_class_interface_creation PARAMS ((int, int, tree,
82371d41 120 tree, tree, tree));
df32d2ce 121static tree patch_method_invocation PARAMS ((tree, tree, tree,
89e09b9a 122 int *, tree *));
df32d2ce
KG		 123static int breakdown_qualified PARAMS ((tree *, tree *, tree));
124static tree resolve_and_layout PARAMS ((tree, tree));
9a7ab4b3 125static tree qualify_and_find PARAMS ((tree, tree, tree));
df32d2ce
KG		 126static tree resolve_no_layout PARAMS ((tree, tree));
127static int invocation_mode PARAMS ((tree, int));
128static tree find_applicable_accessible_methods_list PARAMS ((int, tree,
82371d41 129 tree, tree));
df32d2ce 130static void search_applicable_methods_list PARAMS ((int, tree, tree, tree,
1982388a 131 tree *, tree *));
df32d2ce
KG		 132static tree find_most_specific_methods_list PARAMS ((tree));
133static int argument_types_convertible PARAMS ((tree, tree));
134static tree patch_invoke PARAMS ((tree, tree, tree));
c2952b01 135static int maybe_use_access_method PARAMS ((int, tree *, tree *));
df32d2ce
KG		 136static tree lookup_method_invoke PARAMS ((int, tree, tree, tree, tree));
137static tree register_incomplete_type PARAMS ((int, tree, tree, tree));
138static tree obtain_incomplete_type PARAMS ((tree));
139static tree java_complete_lhs PARAMS ((tree));
140static tree java_complete_tree PARAMS ((tree));
c2952b01 141static tree maybe_generate_pre_expand_clinit PARAMS ((tree));
92d83515 142static int maybe_yank_clinit PARAMS ((tree));
df32d2ce
KG		 143static void java_complete_expand_method PARAMS ((tree));
144static int unresolved_type_p PARAMS ((tree, tree *));
145static void create_jdep_list PARAMS ((struct parser_ctxt *));
146static tree build_expr_block PARAMS ((tree, tree));
147static tree enter_block PARAMS ((void));
148static tree enter_a_block PARAMS ((tree));
149static tree exit_block PARAMS ((void));
150static tree lookup_name_in_blocks PARAMS ((tree));
151static void maybe_absorb_scoping_blocks PARAMS ((void));
152static tree build_method_invocation PARAMS ((tree, tree));
153static tree build_new_invocation PARAMS ((tree, tree));
154static tree build_assignment PARAMS ((int, int, tree, tree));
155static tree build_binop PARAMS ((enum tree_code, int, tree, tree));
156static int check_final_assignment PARAMS ((tree ,tree));
157static tree patch_assignment PARAMS ((tree, tree, tree ));
158static tree patch_binop PARAMS ((tree, tree, tree));
159static tree build_unaryop PARAMS ((int, int, tree));
160static tree build_incdec PARAMS ((int, int, tree, int));
161static tree patch_unaryop PARAMS ((tree, tree));
162static tree build_cast PARAMS ((int, tree, tree));
163static tree build_null_of_type PARAMS ((tree));
164static tree patch_cast PARAMS ((tree, tree));
165static int valid_ref_assignconv_cast_p PARAMS ((tree, tree, int));
166static int valid_builtin_assignconv_identity_widening_p PARAMS ((tree, tree));
167static int valid_cast_to_p PARAMS ((tree, tree));
168static int valid_method_invocation_conversion_p PARAMS ((tree, tree));
169static tree try_builtin_assignconv PARAMS ((tree, tree, tree));
170static tree try_reference_assignconv PARAMS ((tree, tree));
171static tree build_unresolved_array_type PARAMS ((tree));
172static tree build_array_from_name PARAMS ((tree, tree, tree, tree *));
173static tree build_array_ref PARAMS ((int, tree, tree));
174static tree patch_array_ref PARAMS ((tree));
175static tree make_qualified_name PARAMS ((tree, tree, int));
176static tree merge_qualified_name PARAMS ((tree, tree));
177static tree make_qualified_primary PARAMS ((tree, tree, int));
178static int resolve_qualified_expression_name PARAMS ((tree, tree *,
82371d41 179 tree *, tree *));
df32d2ce 180static void qualify_ambiguous_name PARAMS ((tree));
df32d2ce
KG		 181static tree resolve_field_access PARAMS ((tree, tree *, tree *));
182static tree build_newarray_node PARAMS ((tree, tree, int));
183static tree patch_newarray PARAMS ((tree));
184static tree resolve_type_during_patch PARAMS ((tree));
185static tree build_this PARAMS ((int));
9a7ab4b3 186static tree build_wfl_wrap PARAMS ((tree, int));
df32d2ce
KG		 187static tree build_return PARAMS ((int, tree));
188static tree patch_return PARAMS ((tree));
189static tree maybe_access_field PARAMS ((tree, tree, tree));
190static int complete_function_arguments PARAMS ((tree));
c2952b01
APB		 191static int check_for_static_method_reference PARAMS ((tree, tree, tree,
192 tree, tree));
df32d2ce
KG		 193static int not_accessible_p PARAMS ((tree, tree, int));
194static void check_deprecation PARAMS ((tree, tree));
195static int class_in_current_package PARAMS ((tree));
196static tree build_if_else_statement PARAMS ((int, tree, tree, tree));
197static tree patch_if_else_statement PARAMS ((tree));
198static tree add_stmt_to_compound PARAMS ((tree, tree, tree));
199static tree add_stmt_to_block PARAMS ((tree, tree, tree));
200static tree patch_exit_expr PARAMS ((tree));
201static tree build_labeled_block PARAMS ((int, tree));
202static tree finish_labeled_statement PARAMS ((tree, tree));
203static tree build_bc_statement PARAMS ((int, int, tree));
204static tree patch_bc_statement PARAMS ((tree));
205static tree patch_loop_statement PARAMS ((tree));
206static tree build_new_loop PARAMS ((tree));
207static tree build_loop_body PARAMS ((int, tree, int));
208static tree finish_loop_body PARAMS ((int, tree, tree, int));
209static tree build_debugable_stmt PARAMS ((int, tree));
210static tree finish_for_loop PARAMS ((int, tree, tree, tree));
211static tree patch_switch_statement PARAMS ((tree));
212static tree string_constant_concatenation PARAMS ((tree, tree));
213static tree build_string_concatenation PARAMS ((tree, tree));
214static tree patch_string_cst PARAMS ((tree));
215static tree patch_string PARAMS ((tree));
216static tree build_try_statement PARAMS ((int, tree, tree));
217static tree build_try_finally_statement PARAMS ((int, tree, tree));
218static tree patch_try_statement PARAMS ((tree));
219static tree patch_synchronized_statement PARAMS ((tree, tree));
220static tree patch_throw_statement PARAMS ((tree, tree));
221static void check_thrown_exceptions PARAMS ((int, tree));
222static int check_thrown_exceptions_do PARAMS ((tree));
223static void purge_unchecked_exceptions PARAMS ((tree));
224static void check_throws_clauses PARAMS ((tree, tree, tree));
225static void finish_method_declaration PARAMS ((tree));
226static tree build_super_invocation PARAMS ((tree));
227static int verify_constructor_circularity PARAMS ((tree, tree));
228static char *constructor_circularity_msg PARAMS ((tree, tree));
229static tree build_this_super_qualified_invocation PARAMS ((int, tree, tree,
82371d41 230 int, int));
df32d2ce
KG		 231static const char *get_printable_method_name PARAMS ((tree));
232static tree patch_conditional_expr PARAMS ((tree, tree, tree));
c2952b01
APB		 233static tree generate_finit PARAMS ((tree));
234static void add_instance_initializer PARAMS ((tree));
df32d2ce 235static void fix_constructors PARAMS ((tree));
c2952b01
APB		 236static tree build_alias_initializer_parameter_list PARAMS ((int, tree,
237 tree, int *));
238static void craft_constructor PARAMS ((tree, tree));
239static int verify_constructor_super PARAMS ((tree));
df32d2ce
KG		 240static tree create_artificial_method PARAMS ((tree, int, tree, tree, tree));
241static void start_artificial_method_body PARAMS ((tree));
242static void end_artificial_method_body PARAMS ((tree));
243static int check_method_redefinition PARAMS ((tree, tree));
244static int reset_method_name PARAMS ((tree));
165f37bc 245static int check_method_types_complete PARAMS ((tree));
df32d2ce
KG		 246static void java_check_regular_methods PARAMS ((tree));
247static void java_check_abstract_methods PARAMS ((tree));
248static tree maybe_build_primttype_type_ref PARAMS ((tree, tree));
249static void unreachable_stmt_error PARAMS ((tree));
250static tree find_expr_with_wfl PARAMS ((tree));
251static void missing_return_error PARAMS ((tree));
252static tree build_new_array_init PARAMS ((int, tree));
253static tree patch_new_array_init PARAMS ((tree, tree));
254static tree maybe_build_array_element_wfl PARAMS ((tree));
255static int array_constructor_check_entry PARAMS ((tree, tree));
256static const char *purify_type_name PARAMS ((const char *));
257static tree fold_constant_for_init PARAMS ((tree, tree));
258static tree strip_out_static_field_access_decl PARAMS ((tree));
259static jdeplist *reverse_jdep_list PARAMS ((struct parser_ctxt *));
260static void static_ref_err PARAMS ((tree, tree, tree));
261static void parser_add_interface PARAMS ((tree, tree, tree));
262static void add_superinterfaces PARAMS ((tree, tree));
263static tree jdep_resolve_class PARAMS ((jdep *));
264static int note_possible_classname PARAMS ((const char *, int));
c2952b01
APB		 265static void java_complete_expand_classes PARAMS ((void));
266static void java_complete_expand_class PARAMS ((tree));
267static void java_complete_expand_methods PARAMS ((tree));
df32d2ce
KG		 268static tree cut_identifier_in_qualified PARAMS ((tree));
269static tree java_stabilize_reference PARAMS ((tree));
270static tree do_unary_numeric_promotion PARAMS ((tree));
271static char * operator_string PARAMS ((tree));
272static tree do_merge_string_cste PARAMS ((tree, const char *, int, int));
273static tree merge_string_cste PARAMS ((tree, tree, int));
274static tree java_refold PARAMS ((tree));
275static int java_decl_equiv PARAMS ((tree, tree));
276static int binop_compound_p PARAMS ((enum tree_code));
277static tree search_loop PARAMS ((tree));
278static int labeled_block_contains_loop_p PARAMS ((tree, tree));
279static void check_abstract_method_definitions PARAMS ((int, tree, tree));
280static void java_check_abstract_method_definitions PARAMS ((tree));
281static void java_debug_context_do PARAMS ((int));
c2952b01
APB		 282static void java_parser_context_push_initialized_field PARAMS ((void));
283static void java_parser_context_pop_initialized_field PARAMS ((void));
284static tree reorder_static_initialized PARAMS ((tree));
285static void java_parser_context_suspend PARAMS ((void));
286static void java_parser_context_resume PARAMS ((void));
287
288/* JDK 1.1 work. FIXME */
289
290static tree maybe_make_nested_class_name PARAMS ((tree));
291static void make_nested_class_name PARAMS ((tree));
292static void set_nested_class_simple_name_value PARAMS ((tree, int));
293static void link_nested_class_to_enclosing PARAMS ((void));
294static tree find_as_inner_class PARAMS ((tree, tree, tree));
295static tree find_as_inner_class_do PARAMS ((tree, tree));
296static int check_inner_class_redefinition PARAMS ((tree, tree));
297
298static tree build_thisn_assign PARAMS ((void));
299static tree build_current_thisn PARAMS ((tree));
300static tree build_access_to_thisn PARAMS ((tree, tree, int));
301static tree maybe_build_thisn_access_method PARAMS ((tree));
302
303static tree build_outer_field_access PARAMS ((tree, tree));
304static tree build_outer_field_access_methods PARAMS ((tree));
305static tree build_outer_field_access_expr PARAMS ((int, tree, tree,
306 tree, tree));
307static tree build_outer_method_access_method PARAMS ((tree));
308static tree build_new_access_id PARAMS ((void));
309static tree build_outer_field_access_method PARAMS ((tree, tree, tree,
310 tree, tree));
311
312static int outer_field_access_p PARAMS ((tree, tree));
313static int outer_field_expanded_access_p PARAMS ((tree, tree *,
314 tree *, tree *));
315static tree outer_field_access_fix PARAMS ((tree, tree, tree));
316static tree build_incomplete_class_ref PARAMS ((int, tree));
317static tree patch_incomplete_class_ref PARAMS ((tree));
318static tree create_anonymous_class PARAMS ((int, tree));
319static void patch_anonymous_class PARAMS ((tree, tree, tree));
320static void add_inner_class_fields PARAMS ((tree, tree));
82371d41 321
165f37bc
APB		 322static tree build_dot_class_method PARAMS ((tree));
323static tree build_dot_class_method_invocation PARAMS ((tree));
c0b864fc 324static void create_new_parser_context PARAMS ((int));
165f37bc 325
e04a16fb
AG		 326/* Number of error found so far. */
327int java_error_count;
328/* Number of warning found so far. */
329int java_warning_count;
ce6e9147
APB		 330/* Tell when not to fold, when doing xrefs */
331int do_not_fold;
c2952b01
APB		 332/* Cyclic inheritance report, as it can be set by layout_class */
333char *cyclic_inheritance_report;
334
335/* Tell when we're within an instance initializer */
336static int in_instance_initializer;
e04a16fb
AG		 337
338/* The current parser context */
d4370213 339struct parser_ctxt *ctxp;
e04a16fb 340
d4370213 341/* List of things that were analyzed for which code will be generated */
b351b287
APB		 342static struct parser_ctxt *ctxp_for_generation = NULL;
343
e04a16fb
AG		 344/* binop_lookup maps token to tree_code. It is used where binary
345 operations are involved and required by the parser. RDIV_EXPR
346 covers both integral/floating point division. The code is changed
347 once the type of both operator is worked out. */
348
349static enum tree_code binop_lookup[19] =
350 {
351 PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
352 LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
353 BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
354 TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
355 EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
356 };
357#define BINOP_LOOKUP(VALUE) \
358 binop_lookup [((VALUE) - PLUS_TK)% \
359 (sizeof (binop_lookup) / sizeof (binop_lookup[0]))]
360
5cbdba64
APB		 361/* This is the end index for binary operators that can also be used
362 in compound assignements. */
363#define BINOP_COMPOUND_CANDIDATES 11
364
e04a16fb
AG		 365/* Fake WFL used to report error message. It is initialized once if
366 needed and reused with it's location information is overriden. */
15fdcfe9 367tree wfl_operator = NULL_TREE;
e04a16fb
AG		 368
369/* The "$L" identifier we use to create labels. */
b67d701b
PB		 370static tree label_id = NULL_TREE;
371
372/* The "StringBuffer" identifier used for the String `+' operator. */
373static tree wfl_string_buffer = NULL_TREE;
374
375/* The "append" identifier used for String `+' operator. */
376static tree wfl_append = NULL_TREE;
377
378/* The "toString" identifier used for String `+' operator. */
379static tree wfl_to_string = NULL_TREE;
ba179f9f
APB		 380
381/* The "java.lang" import qualified name. */
382static tree java_lang_id = NULL_TREE;
09ed0f70 383
c2952b01
APB		 384/* The generated `inst$' identifier used for generated enclosing
385 instance/field access functions. */
386static tree inst_id = NULL_TREE;
387
09ed0f70
APB		 388/* The "java.lang.Cloneable" qualified name. */
389static tree java_lang_cloneable = NULL_TREE;
f099f336
APB		 390
391/* Context and flag for static blocks */
392static tree current_static_block = NULL_TREE;
393
c2952b01
APB		 394/* The generated `write_parm_value$' identifier. */
395static tree wpv_id;
396
ee07f4f4
APB		 397/* The list of all packages we've seen so far */
398static tree package_list = NULL_TREE;
2884c41e
KG		 399
400/* Check modifiers. If one doesn't fit, retrieve it in its declaration
401 line and point it out. */
402/* Should point out the one that don't fit. ASCII/unicode, going
403 backward. FIXME */
404
405#define check_modifiers(__message, __value, __mask) do { \
406 if ((__value) & ~(__mask)) \
407 { \
408 int i, remainder = (__value) & ~(__mask); \
409 for (i = 0; i <= 10; i++) \
410 if ((1 << i) & remainder) \
411 parse_error_context (ctxp->modifier_ctx [i], (__message), \
412 java_accstring_lookup (1 << i)); \
413 } \
414} while (0)
ee07f4f4 415
e04a16fb
AG		 416%}
417
418%union {
419 tree node;
420 int sub_token;
421 struct {
422 int token;
423 int location;
424 } operator;
425 int value;
426}
427
9ee9b555
KG		 428%{
429#include "lex.c"
430%}
431
e04a16fb
AG		 432%pure_parser
433
434/* Things defined here have to match the order of what's in the
435 binop_lookup table. */
436
437%token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
438%token LS_TK SRS_TK ZRS_TK
439%token AND_TK XOR_TK OR_TK
440%token BOOL_AND_TK BOOL_OR_TK
441%token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
442
443/* This maps to the same binop_lookup entry than the token above */
444
445%token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
446%token REM_ASSIGN_TK
447%token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
448%token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
449
450
451/* Modifier TOKEN have to be kept in this order. Don't scramble it */
452
453%token PUBLIC_TK PRIVATE_TK PROTECTED_TK
454%token STATIC_TK FINAL_TK SYNCHRONIZED_TK
455%token VOLATILE_TK TRANSIENT_TK NATIVE_TK
456%token PAD_TK ABSTRACT_TK MODIFIER_TK
457
458/* Keep those two in order, too */
459%token DECR_TK INCR_TK
460
461/* From now one, things can be in any order */
462
463%token DEFAULT_TK IF_TK THROW_TK
464%token BOOLEAN_TK DO_TK IMPLEMENTS_TK
465%token THROWS_TK BREAK_TK IMPORT_TK
466%token ELSE_TK INSTANCEOF_TK RETURN_TK
467%token VOID_TK CATCH_TK INTERFACE_TK
468%token CASE_TK EXTENDS_TK FINALLY_TK
469%token SUPER_TK WHILE_TK CLASS_TK
470%token SWITCH_TK CONST_TK TRY_TK
471%token FOR_TK NEW_TK CONTINUE_TK
472%token GOTO_TK PACKAGE_TK THIS_TK
473
474%token BYTE_TK SHORT_TK INT_TK LONG_TK
475%token CHAR_TK INTEGRAL_TK
476
477%token FLOAT_TK DOUBLE_TK FP_TK
478
479%token ID_TK
480
481%token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
482
483%token ASSIGN_ANY_TK ASSIGN_TK
484%token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
485
486%token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
487%token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
488
c2952b01 489%type <value> modifiers MODIFIER_TK final synchronized
e04a16fb
AG		 490
491%type <node> super ID_TK identifier
492%type <node> name simple_name qualified_name
c2952b01 493%type <node> type_declaration compilation_unit
e04a16fb
AG		 494 field_declaration method_declaration extends_interfaces
495 interfaces interface_type_list
c2952b01 496 class_member_declaration
e04a16fb
AG		 497 import_declarations package_declaration
498 type_declarations interface_body
499 interface_member_declaration constant_declaration
500 interface_member_declarations interface_type
501 abstract_method_declaration interface_type_list
502%type <node> class_body_declaration class_member_declaration
503 static_initializer constructor_declaration block
22eed1e6 504%type <node> class_body_declarations constructor_header
e04a16fb
AG		 505%type <node> class_or_interface_type class_type class_type_list
506 constructor_declarator explicit_constructor_invocation
b9f7e36c 507%type <node> dim_expr dim_exprs this_or_super throws
e04a16fb
AG		 508
509%type <node> variable_declarator_id variable_declarator
510 variable_declarators variable_initializer
22eed1e6 511 variable_initializers constructor_body
ac825856 512 array_initializer
e04a16fb 513
2e5eb5c5 514%type <node> class_body block_end constructor_block_end
e04a16fb
AG		 515%type <node> statement statement_without_trailing_substatement
516 labeled_statement if_then_statement label_decl
517 if_then_else_statement while_statement for_statement
518 statement_nsi labeled_statement_nsi do_statement
519 if_then_else_statement_nsi while_statement_nsi
520 for_statement_nsi statement_expression_list for_init
521 for_update statement_expression expression_statement
522 primary_no_new_array expression primary
523 array_creation_expression array_type
524 class_instance_creation_expression field_access
525 method_invocation array_access something_dot_new
526 argument_list postfix_expression while_expression
527 post_increment_expression post_decrement_expression
528 unary_expression_not_plus_minus unary_expression
529 pre_increment_expression pre_decrement_expression
530 unary_expression_not_plus_minus cast_expression
531 multiplicative_expression additive_expression
532 shift_expression relational_expression
533 equality_expression and_expression
534 exclusive_or_expression inclusive_or_expression
535 conditional_and_expression conditional_or_expression
536 conditional_expression assignment_expression
537 left_hand_side assignment for_header for_begin
538 constant_expression do_statement_begin empty_statement
b67d701b 539 switch_statement synchronized_statement throw_statement
f8976021 540 try_statement switch_expression switch_block
15fdcfe9 541 catches catch_clause catch_clause_parameter finally
c2952b01 542 anonymous_class_creation
e04a16fb
AG		 543%type <node> return_statement break_statement continue_statement
544
545%type <operator> ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
546%type <operator> REM_ASSIGN_TK PLUS_ASSIGN_TK MINUS_ASSIGN_TK
547%type <operator> LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
548%type <operator> AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
549%type <operator> ASSIGN_ANY_TK assignment_operator
550%token <operator> EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
551%token <operator> BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
552%token <operator> DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
7f10c2e2 553%token <operator> NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
5e942c50 554%token <operator> OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
b9f7e36c
APB		 555%type <operator> THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
556%type <operator> CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
c2952b01 557%type <operator> NEW_TK
e04a16fb
AG		 558
559%type <node> method_body
560
561%type <node> literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
562 STRING_LIT_TK NULL_TK VOID_TK
563
564%type <node> IF_TK WHILE_TK FOR_TK
565
566%type <node> formal_parameter_list formal_parameter
567 method_declarator method_header
568
c2952b01 569%type <node> primitive_type reference_type type
e04a16fb
AG		 570 BOOLEAN_TK INTEGRAL_TK FP_TK
571
c2952b01
APB		 572/* Added or modified JDK 1.1 rule types */
573%type <node> type_literals array_type_literal
574
e04a16fb
AG		 575%%
576/* 19.2 Production from 2.3: The Syntactic Grammar */
577goal:
578 compilation_unit
579 {}
580;
581
582/* 19.3 Productions from 3: Lexical structure */
583literal:
584 INT_LIT_TK
585| FP_LIT_TK
586| BOOL_LIT_TK
587| CHAR_LIT_TK
588| STRING_LIT_TK
589| NULL_TK
590;
591
592/* 19.4 Productions from 4: Types, Values and Variables */
593type:
594 primitive_type
595| reference_type
596;
597
598primitive_type:
599 INTEGRAL_TK
600| FP_TK
601| BOOLEAN_TK
602;
603
604reference_type:
605 class_or_interface_type
606| array_type
607;
608
609class_or_interface_type:
610 name
611;
612
613class_type:
614 class_or_interface_type /* Default rule */
615;
616
617interface_type:
618 class_or_interface_type
619;
620
621array_type:
622 primitive_type OSB_TK CSB_TK
623 {
624 $$ = build_java_array_type ($1, -1);
625 CLASS_LOADED_P ($$) = 1;
626 }
627| name OSB_TK CSB_TK
628 { $$ = build_unresolved_array_type ($1); }
629| array_type OSB_TK CSB_TK
630 { $$ = build_unresolved_array_type ($1); }
631| primitive_type OSB_TK error
632 {RULE ("']' expected"); RECOVER;}
633| array_type OSB_TK error
634 {RULE ("']' expected"); RECOVER;}
635;
636
637/* 19.5 Productions from 6: Names */
638name:
639 simple_name /* Default rule */
640| qualified_name /* Default rule */
641;
642
643simple_name:
644 identifier /* Default rule */
645;
646
647qualified_name:
648 name DOT_TK identifier
649 { $$ = make_qualified_name ($1, $3, $2.location); }
650;
651
652identifier:
653 ID_TK
654;
655
656/* 19.6: Production from 7: Packages */
657compilation_unit:
658 {$$ = NULL;}
659| package_declaration
660| import_declarations
661| type_declarations
662| package_declaration import_declarations
663| package_declaration type_declarations
664| import_declarations type_declarations
665| package_declaration import_declarations type_declarations
666;
667
668import_declarations:
669 import_declaration
670 {
671 $$ = NULL;
672 }
673| import_declarations import_declaration
674 {
675 $$ = NULL;
676 }
677;
678
679type_declarations:
680 type_declaration
681| type_declarations type_declaration
682;
683
684package_declaration:
685 PACKAGE_TK name SC_TK
ee07f4f4
APB		 686 {
687 ctxp->package = EXPR_WFL_NODE ($2);
9a7ab4b3 688 register_package (ctxp->package);
ee07f4f4 689 }
e04a16fb
AG		 690| PACKAGE_TK error
691 {yyerror ("Missing name"); RECOVER;}
692| PACKAGE_TK name error
693 {yyerror ("';' expected"); RECOVER;}
694;
695
696import_declaration:
697 single_type_import_declaration
698| type_import_on_demand_declaration
699;
700
701single_type_import_declaration:
702 IMPORT_TK name SC_TK
703 {
9a7ab4b3 704 tree name = EXPR_WFL_NODE ($2), last_name;
e04a16fb 705 int i = IDENTIFIER_LENGTH (name)-1;
49f48c71 706 const char *last = &IDENTIFIER_POINTER (name)[i];
e04a16fb
AG		 707 while (last != IDENTIFIER_POINTER (name))
708 {
709 if (last [0] == '.')
710 break;
711 last--;
712 }
713 last_name = get_identifier (++last);
714 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
715 {
716 tree err = find_name_in_single_imports (last_name);
717 if (err && err != name)
718 parse_error_context
719 ($2, "Ambiguous class: `%s' and `%s'",
720 IDENTIFIER_POINTER (name),
721 IDENTIFIER_POINTER (err));
5e942c50 722 else
9a7ab4b3 723 REGISTER_IMPORT ($2, last_name);
e04a16fb
AG		 724 }
725 else
5e942c50 726 REGISTER_IMPORT ($2, last_name);
e04a16fb
AG		 727 }
728| IMPORT_TK error
729 {yyerror ("Missing name"); RECOVER;}
730| IMPORT_TK name error
731 {yyerror ("';' expected"); RECOVER;}
732;
733
734type_import_on_demand_declaration:
735 IMPORT_TK name DOT_TK MULT_TK SC_TK
736 {
737 tree name = EXPR_WFL_NODE ($2);
ba179f9f
APB		 738 /* Don't import java.lang.* twice. */
739 if (name != java_lang_id)
740 {
ba179f9f 741 read_import_dir ($2);
9a7ab4b3
APB		 742 ctxp->import_demand_list =
743 chainon (ctxp->import_demand_list,
744 build_tree_list ($2, NULL_TREE));
ba179f9f 745 }
e04a16fb
AG		 746 }
747| IMPORT_TK name DOT_TK error
748 {yyerror ("'*' expected"); RECOVER;}
749| IMPORT_TK name DOT_TK MULT_TK error
750 {yyerror ("';' expected"); RECOVER;}
751;
752
753type_declaration:
754 class_declaration
c2952b01 755 { end_class_declaration (0); }
e04a16fb 756| interface_declaration
c2952b01 757 { end_class_declaration (0); }
e04a16fb
AG		 758| SC_TK
759 { $$ = NULL; }
760| error
761 {
762 YYERROR_NOW;
763 yyerror ("Class or interface declaration expected");
764 }
765;
766
767/* 19.7 Shortened from the original:
768 modifiers: modifier | modifiers modifier
769 modifier: any of public... */
770modifiers:
771 MODIFIER_TK
772 {
773 $$ = (1 << $1);
774 }
775| modifiers MODIFIER_TK
776 {
777 int acc = (1 << $2);
778 if ($$ & acc)
779 parse_error_context
780 (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
781 java_accstring_lookup (acc));
782 else
783 {
784 $$ |= acc;
785 }
786 }
787;
788
789/* 19.8.1 Production from $8.1: Class Declaration */
790class_declaration:
791 modifiers CLASS_TK identifier super interfaces
792 { create_class ($1, $3, $4, $5); }
793 class_body
e04a16fb
AG		 794| CLASS_TK identifier super interfaces
795 { create_class (0, $2, $3, $4); }
796 class_body
e04a16fb
AG		 797| modifiers CLASS_TK error
798 {yyerror ("Missing class name"); RECOVER;}
799| CLASS_TK error
800 {yyerror ("Missing class name"); RECOVER;}
801| CLASS_TK identifier error
0b4d333e
APB		 802 {
803 if (!ctxp->class_err) yyerror ("'{' expected");
804 DRECOVER(class1);
805 }
e04a16fb
AG		 806| modifiers CLASS_TK identifier error
807 {if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER;}
808;
809
810super:
811 { $$ = NULL; }
812| EXTENDS_TK class_type
813 { $$ = $2; }
814| EXTENDS_TK class_type error
815 {yyerror ("'{' expected"); ctxp->class_err=1;}
816| EXTENDS_TK error
817 {yyerror ("Missing super class name"); ctxp->class_err=1;}
818;
819
820interfaces:
821 { $$ = NULL_TREE; }
822| IMPLEMENTS_TK interface_type_list
823 { $$ = $2; }
824| IMPLEMENTS_TK error
825 {
826 ctxp->class_err=1;
827 yyerror ("Missing interface name");
828 }
829;
830
831interface_type_list:
832 interface_type
833 {
834 ctxp->interface_number = 1;
835 $$ = build_tree_list ($1, NULL_TREE);
836 }
837| interface_type_list C_TK interface_type
838 {
839 ctxp->interface_number++;
840 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
841 }
842| interface_type_list C_TK error
843 {yyerror ("Missing interface name"); RECOVER;}
844;
845
846class_body:
847 OCB_TK CCB_TK
7f10c2e2
APB		 848 {
849 /* Store the location of the `}' when doing xrefs */
850 if (flag_emit_xref)
c2952b01 851 DECL_END_SOURCE_LINE (GET_CPC ()) =
7f10c2e2 852 EXPR_WFL_ADD_COL ($2.location, 1);
c2952b01 853 $$ = GET_CPC ();
7f10c2e2 854 }
e04a16fb 855| OCB_TK class_body_declarations CCB_TK
7f10c2e2
APB		 856 {
857 /* Store the location of the `}' when doing xrefs */
858 if (flag_emit_xref)
c2952b01 859 DECL_END_SOURCE_LINE (GET_CPC ()) =
7f10c2e2 860 EXPR_WFL_ADD_COL ($3.location, 1);
c2952b01 861 $$ = GET_CPC ();
7f10c2e2 862 }
e04a16fb
AG		 863;
864
865class_body_declarations:
866 class_body_declaration
867| class_body_declarations class_body_declaration
868;
869
870class_body_declaration:
871 class_member_declaration
872| static_initializer
873| constructor_declaration
874| block /* Added, JDK1.1, instance initializer */
c2952b01
APB		 875 {
876 TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
877 SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
878 }
e04a16fb
AG		 879;
880
881class_member_declaration:
882 field_declaration
0b4d333e
APB		 883| field_declaration SC_TK
884 { $$ = $1; }
e04a16fb
AG		 885| method_declaration
886| class_declaration /* Added, JDK1.1 inner classes */
c2952b01
APB		 887 { end_class_declaration (1); }
888| interface_declaration /* Added, JDK1.1 inner interfaces */
889 { end_class_declaration (1); }
e04a16fb
AG		 890;
891
892/* 19.8.2 Productions from 8.3: Field Declarations */
893field_declaration:
894 type variable_declarators SC_TK
895 { register_fields (0, $1, $2); }
896| modifiers type variable_declarators SC_TK
897 {
e04a16fb
AG		 898 check_modifiers
899 ("Illegal modifier `%s' for field declaration",
900 $1, FIELD_MODIFIERS);
901 check_modifiers_consistency ($1);
902 register_fields ($1, $2, $3);
903 }
904;
905
906variable_declarators:
907 /* Should we use build_decl_list () instead ? FIXME */
908 variable_declarator /* Default rule */
909| variable_declarators C_TK variable_declarator
910 { $$ = chainon ($1, $3); }
911| variable_declarators C_TK error
912 {yyerror ("Missing term"); RECOVER;}
913;
914
915variable_declarator:
916 variable_declarator_id
917 { $$ = build_tree_list ($1, NULL_TREE); }
918| variable_declarator_id ASSIGN_TK variable_initializer
919 {
920 if (java_error_count)
921 $3 = NULL_TREE;
922 $$ = build_tree_list
923 ($1, build_assignment ($2.token, $2.location, $1, $3));
924 }
925| variable_declarator_id ASSIGN_TK error
926 {
927 yyerror ("Missing variable initializer");
928 $$ = build_tree_list ($1, NULL_TREE);
929 RECOVER;
930 }
931| variable_declarator_id ASSIGN_TK variable_initializer error
932 {
933 yyerror ("';' expected");
934 $$ = build_tree_list ($1, NULL_TREE);
935 RECOVER;
936 }
937;
938
939variable_declarator_id:
940 identifier
941| variable_declarator_id OSB_TK CSB_TK
c583dd46 942 { $$ = build_unresolved_array_type ($1); }
e04a16fb
AG		 943| identifier error
944 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
945| variable_declarator_id OSB_TK error
946 {yyerror ("']' expected"); DRECOVER(vdi);}
947| variable_declarator_id CSB_TK error
948 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
949;
950
951variable_initializer:
952 expression
953| array_initializer
e04a16fb
AG		 954;
955
956/* 19.8.3 Productions from 8.4: Method Declarations */
957method_declaration:
958 method_header
959 {
960 current_function_decl = $1;
c2952b01
APB		 961 if (current_function_decl
962 && TREE_CODE (current_function_decl) == FUNCTION_DECL)
963 source_start_java_method (current_function_decl);
964 else
965 current_function_decl = NULL_TREE;
e04a16fb
AG		 966 }
967 method_body
b635eb2f 968 { finish_method_declaration ($3); }
e04a16fb
AG		 969| method_header error
970 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
971;
972
973method_header:
974 type method_declarator throws
b9f7e36c 975 { $$ = method_header (0, $1, $2, $3); }
e04a16fb 976| VOID_TK method_declarator throws
b9f7e36c 977 { $$ = method_header (0, void_type_node, $2, $3); }
e04a16fb 978| modifiers type method_declarator throws
b9f7e36c 979 { $$ = method_header ($1, $2, $3, $4); }
e04a16fb 980| modifiers VOID_TK method_declarator throws
b9f7e36c 981 { $$ = method_header ($1, void_type_node, $3, $4); }
e04a16fb 982| type error
efa0a23f
APB		 983 {
984 yyerror ("Invalid method declaration, method name required");
985 RECOVER;
986 }
e04a16fb
AG		 987| modifiers type error
988 {RECOVER;}
989| VOID_TK error
990 {yyerror ("Identifier expected"); RECOVER;}
991| modifiers VOID_TK error
992 {yyerror ("Identifier expected"); RECOVER;}
993| modifiers error
994 {
995 yyerror ("Invalid method declaration, return type required");
996 RECOVER;
997 }
998;
999
1000method_declarator:
1001 identifier OP_TK CP_TK
c2952b01
APB		 1002 {
1003 ctxp->formal_parameter_number = 0;
1004 $$ = method_declarator ($1, NULL_TREE);
1005 }
e04a16fb
AG		 1006| identifier OP_TK formal_parameter_list CP_TK
1007 { $$ = method_declarator ($1, $3); }
1008| method_declarator OSB_TK CSB_TK
1009 {
1886c9d8
APB		 1010 EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1011 TREE_PURPOSE ($1) =
1012 build_unresolved_array_type (TREE_PURPOSE ($1));
1013 parse_warning_context
1014 (wfl_operator,
1015 "Discouraged form of returned type specification");
e04a16fb
AG		 1016 }
1017| identifier OP_TK error
1018 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1019| method_declarator OSB_TK error
1020 {yyerror ("']' expected"); RECOVER;}
1021;
1022
1023formal_parameter_list:
1024 formal_parameter
1025 {
1026 ctxp->formal_parameter_number = 1;
1027 }
1028| formal_parameter_list C_TK formal_parameter
1029 {
1030 ctxp->formal_parameter_number += 1;
1031 $$ = chainon ($1, $3);
1032 }
1033| formal_parameter_list C_TK error
c2952b01 1034 { yyerror ("Missing formal parameter term"); RECOVER; }
e04a16fb
AG		 1035;
1036
1037formal_parameter:
1038 type variable_declarator_id
1039 {
1040 $$ = build_tree_list ($2, $1);
1041 }
18990de5 1042| final type variable_declarator_id /* Added, JDK1.1 final parms */
5256aa37 1043 {
5256aa37 1044 $$ = build_tree_list ($3, $2);
c2952b01 1045 ARG_FINAL_P ($$) = 1;
5256aa37 1046 }
e04a16fb 1047| type error
f8989a66
APB		 1048 {
1049 yyerror ("Missing identifier"); RECOVER;
1050 $$ = NULL_TREE;
1051 }
18990de5 1052| final type error
e04a16fb 1053 {
e04a16fb 1054 yyerror ("Missing identifier"); RECOVER;
f8989a66 1055 $$ = NULL_TREE;
e04a16fb
AG		 1056 }
1057;
1058
18990de5
JB		 1059final:
1060 modifiers
1061 {
1062 check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1063 $1, ACC_FINAL);
1064 if ($1 != ACC_FINAL)
1065 MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1066 }
1067;
1068
e04a16fb 1069throws:
b9f7e36c 1070 { $$ = NULL_TREE; }
e04a16fb 1071| THROWS_TK class_type_list
b9f7e36c 1072 { $$ = $2; }
e04a16fb
AG		 1073| THROWS_TK error
1074 {yyerror ("Missing class type term"); RECOVER;}
1075;
1076
1077class_type_list:
1078 class_type
c877974e 1079 { $$ = build_tree_list ($1, $1); }
e04a16fb 1080| class_type_list C_TK class_type
c877974e 1081 { $$ = tree_cons ($3, $3, $1); }
e04a16fb
AG		 1082| class_type_list C_TK error
1083 {yyerror ("Missing class type term"); RECOVER;}
1084;
1085
1086method_body:
1087 block
1088| block SC_TK
1089| SC_TK
1090 { $$ = NULL_TREE; } /* Probably not the right thing to do. */
1091;
1092
1093/* 19.8.4 Productions from 8.5: Static Initializers */
1094static_initializer:
1095 static block
1096 {
c2952b01
APB		 1097 TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1098 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
e04a16fb
AG		 1099 }
1100| static block SC_TK /* Shouldn't be here. FIXME */
1101 {
c2952b01
APB		 1102 TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1103 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
e04a16fb
AG		 1104 }
1105;
1106
1107static: /* Test lval.sub_token here */
c2952b01 1108 modifiers
e04a16fb 1109 {
c2952b01
APB		 1110 check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1111 /* Can't have a static initializer in an innerclass */
1112 if ($1 | ACC_STATIC &&
1113 GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1114 parse_error_context
1115 (MODIFIER_WFL (STATIC_TK),
1116 "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1117 IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
e04a16fb
AG		 1118 SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1119 }
1120;
1121
1122/* 19.8.5 Productions from 8.6: Constructor Declarations */
e04a16fb 1123constructor_declaration:
22eed1e6 1124 constructor_header
e04a16fb 1125 {
22eed1e6
APB		 1126 current_function_decl = $1;
1127 source_start_java_method (current_function_decl);
e04a16fb 1128 }
22eed1e6 1129 constructor_body
b635eb2f 1130 { finish_method_declaration ($3); }
22eed1e6
APB		 1131;
1132
1133constructor_header:
1134 constructor_declarator throws
1135 { $$ = method_header (0, NULL_TREE, $1, $2); }
1136| modifiers constructor_declarator throws
1137 { $$ = method_header ($1, NULL_TREE, $2, $3); }
e04a16fb
AG		 1138;
1139
1140constructor_declarator:
1141 simple_name OP_TK CP_TK
c2952b01
APB		 1142 {
1143 ctxp->formal_parameter_number = 0;
1144 $$ = method_declarator ($1, NULL_TREE);
1145 }
e04a16fb 1146| simple_name OP_TK formal_parameter_list CP_TK
22eed1e6 1147 { $$ = method_declarator ($1, $3); }
e04a16fb
AG		 1148;
1149
1150constructor_body:
22eed1e6
APB		 1151 /* Unlike regular method, we always need a complete (empty)
1152 body so we can safely perform all the required code
1153 addition (super invocation and field initialization) */
2e5eb5c5 1154 block_begin constructor_block_end
22eed1e6 1155 {
9bbc7d9f 1156 BLOCK_EXPR_BODY ($2) = empty_stmt_node;
22eed1e6
APB		 1157 $$ = $2;
1158 }
2e5eb5c5 1159| block_begin explicit_constructor_invocation constructor_block_end
22eed1e6 1160 { $$ = $3; }
2e5eb5c5 1161| block_begin block_statements constructor_block_end
22eed1e6 1162 { $$ = $3; }
2e5eb5c5 1163| block_begin explicit_constructor_invocation block_statements constructor_block_end
22eed1e6 1164 { $$ = $4; }
e04a16fb
AG		 1165;
1166
2e5eb5c5
APB		 1167constructor_block_end:
1168 block_end
1169| block_end SC_TK
1170
e04a16fb
AG		 1171/* Error recovery for that rule moved down expression_statement: rule. */
1172explicit_constructor_invocation:
1173 this_or_super OP_TK CP_TK SC_TK
22eed1e6
APB		 1174 {
1175 $$ = build_method_invocation ($1, NULL_TREE);
1176 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1177 $$ = java_method_add_stmt (current_function_decl, $$);
1178 }
e04a16fb 1179| this_or_super OP_TK argument_list CP_TK SC_TK
22eed1e6
APB		 1180 {
1181 $$ = build_method_invocation ($1, $3);
1182 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1183 $$ = java_method_add_stmt (current_function_decl, $$);
1184 }
e04a16fb
AG		 1185 /* Added, JDK1.1 inner classes. Modified because the rule
1186 'primary' couldn't work. */
1187| name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
b67d701b 1188 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
e04a16fb 1189| name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
b67d701b 1190 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
e04a16fb
AG		 1191;
1192
1193this_or_super: /* Added, simplifies error diagnostics */
1194 THIS_TK
1195 {
9ee9b555 1196 tree wfl = build_wfl_node (this_identifier_node);
e04a16fb
AG		 1197 EXPR_WFL_LINECOL (wfl) = $1.location;
1198 $$ = wfl;
1199 }
1200| SUPER_TK
1201 {
9ee9b555 1202 tree wfl = build_wfl_node (super_identifier_node);
e04a16fb
AG		 1203 EXPR_WFL_LINECOL (wfl) = $1.location;
1204 $$ = wfl;
1205 }
1206;
1207
1208/* 19.9 Productions from 9: Interfaces */
1209/* 19.9.1 Productions from 9.1: Interfaces Declarations */
1210interface_declaration:
1211 INTERFACE_TK identifier
1212 { create_interface (0, $2, NULL_TREE); }
1213 interface_body
e04a16fb
AG		 1214| modifiers INTERFACE_TK identifier
1215 { create_interface ($1, $3, NULL_TREE); }
1216 interface_body
e04a16fb
AG		 1217| INTERFACE_TK identifier extends_interfaces
1218 { create_interface (0, $2, $3); }
1219 interface_body
e04a16fb
AG		 1220| modifiers INTERFACE_TK identifier extends_interfaces
1221 { create_interface ($1, $3, $4); }
1222 interface_body
e04a16fb 1223| INTERFACE_TK identifier error
0b4d333e 1224 {yyerror ("'{' expected"); RECOVER;}
e04a16fb 1225| modifiers INTERFACE_TK identifier error
0b4d333e 1226 {yyerror ("'{' expected"); RECOVER;}
e04a16fb
AG		 1227;
1228
1229extends_interfaces:
1230 EXTENDS_TK interface_type
1231 {
1232 ctxp->interface_number = 1;
1233 $$ = build_tree_list ($2, NULL_TREE);
1234 }
1235| extends_interfaces C_TK interface_type
1236 {
1237 ctxp->interface_number++;
1238 $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1239 }
1240| EXTENDS_TK error
1241 {yyerror ("Invalid interface type"); RECOVER;}
1242| extends_interfaces C_TK error
1243 {yyerror ("Missing term"); RECOVER;}
1244;
1245
1246interface_body:
1247 OCB_TK CCB_TK
1248 { $$ = NULL_TREE; }
1249| OCB_TK interface_member_declarations CCB_TK
1250 { $$ = NULL_TREE; }
1251;
1252
1253interface_member_declarations:
1254 interface_member_declaration
1255| interface_member_declarations interface_member_declaration
1256;
1257
1258interface_member_declaration:
1259 constant_declaration
1260| abstract_method_declaration
1261| class_declaration /* Added, JDK1.1 inner classes */
c2952b01
APB		 1262 { end_class_declaration (1); }
1263| interface_declaration /* Added, JDK1.1 inner interfaces */
1264 { end_class_declaration (1); }
e04a16fb
AG		 1265;
1266
1267constant_declaration:
1268 field_declaration
1269;
1270
1271abstract_method_declaration:
1272 method_header SC_TK
1273 {
1274 check_abstract_method_header ($1);
1275 current_function_decl = NULL_TREE; /* FIXME ? */
1276 }
1277| method_header error
1278 {yyerror ("';' expected"); RECOVER;}
1279;
1280
1281/* 19.10 Productions from 10: Arrays */
1282array_initializer:
1283 OCB_TK CCB_TK
1179ebc2 1284 { $$ = build_new_array_init ($1.location, NULL_TREE); }
e04a16fb 1285| OCB_TK variable_initializers CCB_TK
f8976021 1286 { $$ = build_new_array_init ($1.location, $2); }
e04a16fb 1287| OCB_TK variable_initializers C_TK CCB_TK
f8976021 1288 { $$ = build_new_array_init ($1.location, $2); }
e04a16fb
AG		 1289;
1290
1291variable_initializers:
1292 variable_initializer
f8976021
APB		 1293 {
1294 $$ = tree_cons (maybe_build_array_element_wfl ($1),
1295 $1, NULL_TREE);
1296 }
e04a16fb 1297| variable_initializers C_TK variable_initializer
1179ebc2
APB		 1298 {
1299 $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1300 }
e04a16fb
AG		 1301| variable_initializers C_TK error
1302 {yyerror ("Missing term"); RECOVER;}
1303;
1304
1305/* 19.11 Production from 14: Blocks and Statements */
1306block:
1307 OCB_TK CCB_TK
7f10c2e2
APB		 1308 {
1309 /* Store the location of the `}' when doing xrefs */
1310 if (current_function_decl && flag_emit_xref)
1311 DECL_END_SOURCE_LINE (current_function_decl) =
1312 EXPR_WFL_ADD_COL ($2.location, 1);
1313 $$ = empty_stmt_node;
1314 }
22eed1e6
APB		 1315| block_begin block_statements block_end
1316 { $$ = $3; }
1317;
1318
1319block_begin:
1320 OCB_TK
e04a16fb 1321 { enter_block (); }
22eed1e6
APB		 1322;
1323
1324block_end:
e04a16fb
AG		 1325 CCB_TK
1326 {
1327 maybe_absorb_scoping_blocks ();
7f10c2e2
APB		 1328 /* Store the location of the `}' when doing xrefs */
1329 if (current_function_decl && flag_emit_xref)
1330 DECL_END_SOURCE_LINE (current_function_decl) =
1331 EXPR_WFL_ADD_COL ($1.location, 1);
e04a16fb 1332 $$ = exit_block ();
c280e37a
APB		 1333 if (!BLOCK_SUBBLOCKS ($$))
1334 BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
e04a16fb
AG		 1335 }
1336;
1337
1338block_statements:
1339 block_statement
1340| block_statements block_statement
1341;
1342
1343block_statement:
1344 local_variable_declaration_statement
1345| statement
15fdcfe9 1346 { java_method_add_stmt (current_function_decl, $1); }
c2952b01
APB		 1347| class_declaration /* Added, JDK1.1 local classes */
1348 {
1349 LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1350 end_class_declaration (1);
1351 }
e04a16fb
AG		 1352;
1353
1354local_variable_declaration_statement:
1355 local_variable_declaration SC_TK /* Can't catch missing ';' here */
1356;
1357
1358local_variable_declaration:
1359 type variable_declarators
1360 { declare_local_variables (0, $1, $2); }
a003f638 1361| final type variable_declarators /* Added, JDK1.1 final locals */
e04a16fb
AG		 1362 { declare_local_variables ($1, $2, $3); }
1363;
1364
1365statement:
1366 statement_without_trailing_substatement
1367| labeled_statement
e04a16fb 1368| if_then_statement
e04a16fb 1369| if_then_else_statement
e04a16fb 1370| while_statement
e04a16fb 1371| for_statement
cd9643f7 1372 { $$ = exit_block (); }
e04a16fb
AG		 1373;
1374
1375statement_nsi:
1376 statement_without_trailing_substatement
1377| labeled_statement_nsi
e04a16fb 1378| if_then_else_statement_nsi
e04a16fb 1379| while_statement_nsi
e04a16fb 1380| for_statement_nsi
9dd939b2 1381 { $$ = exit_block (); }
e04a16fb
AG		 1382;
1383
1384statement_without_trailing_substatement:
1385 block
e04a16fb 1386| empty_statement
e04a16fb 1387| expression_statement
e04a16fb 1388| switch_statement
e04a16fb 1389| do_statement
e04a16fb 1390| break_statement
e04a16fb 1391| continue_statement
e04a16fb
AG		 1392| return_statement
1393| synchronized_statement
e04a16fb 1394| throw_statement
e04a16fb 1395| try_statement
e04a16fb
AG		 1396;
1397
1398empty_statement:
1399 SC_TK
9bbc7d9f 1400 { $$ = empty_stmt_node; }
e04a16fb
AG		 1401;
1402
1403label_decl:
1404 identifier REL_CL_TK
1405 {
1406 $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
0a2138e2 1407 EXPR_WFL_NODE ($1));
e04a16fb
AG		 1408 pushlevel (2);
1409 push_labeled_block ($$);
1410 PUSH_LABELED_BLOCK ($$);
1411 }
1412;
1413
1414labeled_statement:
1415 label_decl statement
b635eb2f 1416 { $$ = finish_labeled_statement ($1, $2); }
e04a16fb
AG		 1417| identifier error
1418 {yyerror ("':' expected"); RECOVER;}
1419;
1420
1421labeled_statement_nsi:
1422 label_decl statement_nsi
b635eb2f 1423 { $$ = finish_labeled_statement ($1, $2); }
e04a16fb
AG		 1424;
1425
1426/* We concentrate here a bunch of error handling rules that we couldn't write
1427 earlier, because expression_statement catches a missing ';'. */
1428expression_statement:
1429 statement_expression SC_TK
1430 {
1431 /* We have a statement. Generate a WFL around it so
1432 we can debug it */
1433 $$ = build_expr_wfl ($1, input_filename, lineno, 0);
1434 /* We know we have a statement, so set the debug
1435 info to be eventually generate here. */
1436 $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1437 }
1438| error SC_TK
1439 {
1440 if (ctxp->prevent_ese != lineno)
1441 yyerror ("Invalid expression statement");
1442 DRECOVER (expr_stmt);
1443 }
1444| error OCB_TK
1445 {
1446 if (ctxp->prevent_ese != lineno)
1447 yyerror ("Invalid expression statement");
1448 DRECOVER (expr_stmt);
1449 }
1450| error CCB_TK
1451 {
1452 if (ctxp->prevent_ese != lineno)
1453 yyerror ("Invalid expression statement");
1454 DRECOVER (expr_stmt);
1455 }
1456| this_or_super OP_TK error
1457 {yyerror ("')' expected"); RECOVER;}
1458| this_or_super OP_TK CP_TK error
22eed1e6 1459 {
8119c720 1460 parse_ctor_invocation_error ();
22eed1e6
APB		 1461 RECOVER;
1462 }
e04a16fb
AG		 1463| this_or_super OP_TK argument_list error
1464 {yyerror ("')' expected"); RECOVER;}
1465| this_or_super OP_TK argument_list CP_TK error
22eed1e6 1466 {
8119c720 1467 parse_ctor_invocation_error ();
22eed1e6
APB		 1468 RECOVER;
1469 }
e04a16fb
AG		 1470| name DOT_TK SUPER_TK error
1471 {yyerror ("'(' expected"); RECOVER;}
1472| name DOT_TK SUPER_TK OP_TK error
1473 {yyerror ("')' expected"); RECOVER;}
1474| name DOT_TK SUPER_TK OP_TK argument_list error
1475 {yyerror ("')' expected"); RECOVER;}
1476| name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1477 {yyerror ("';' expected"); RECOVER;}
1478| name DOT_TK SUPER_TK OP_TK CP_TK error
1479 {yyerror ("';' expected"); RECOVER;}
1480;
1481
1482statement_expression:
1483 assignment
1484| pre_increment_expression
e04a16fb 1485| pre_decrement_expression
e04a16fb 1486| post_increment_expression
e04a16fb 1487| post_decrement_expression
e04a16fb
AG		 1488| method_invocation
1489| class_instance_creation_expression
e04a16fb
AG		 1490;
1491
1492if_then_statement:
1493 IF_TK OP_TK expression CP_TK statement
2aa11e97
APB		 1494 {
1495 $$ = build_if_else_statement ($2.location, $3,
1496 $5, NULL_TREE);
1497 }
e04a16fb
AG		 1498| IF_TK error
1499 {yyerror ("'(' expected"); RECOVER;}
1500| IF_TK OP_TK error
1501 {yyerror ("Missing term"); RECOVER;}
1502| IF_TK OP_TK expression error
1503 {yyerror ("')' expected"); RECOVER;}
1504;
1505
1506if_then_else_statement:
1507 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
2aa11e97 1508 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
e04a16fb
AG		 1509;
1510
1511if_then_else_statement_nsi:
1512 IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
2aa11e97 1513 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
e04a16fb
AG		 1514;
1515
1516switch_statement:
15fdcfe9
PB		 1517 switch_expression
1518 {
1519 enter_block ();
1520 }
1521 switch_block
b67d701b 1522 {
15fdcfe9 1523 /* Make into "proper list" of COMPOUND_EXPRs.
f8976021
APB		 1524 I.e. make the last statment also have its own
1525 COMPOUND_EXPR. */
15fdcfe9
PB		 1526 maybe_absorb_scoping_blocks ();
1527 TREE_OPERAND ($1, 1) = exit_block ();
b67d701b
PB		 1528 $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1529 }
1530;
1531
1532switch_expression:
1533 SWITCH_TK OP_TK expression CP_TK
1534 {
1535 $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1536 EXPR_WFL_LINECOL ($$) = $2.location;
1537 }
e04a16fb
AG		 1538| SWITCH_TK error
1539 {yyerror ("'(' expected"); RECOVER;}
1540| SWITCH_TK OP_TK error
1541 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1542| SWITCH_TK OP_TK expression CP_TK error
1543 {yyerror ("'{' expected"); RECOVER;}
1544;
1545
f8976021
APB		 1546/* Default assignment is there to avoid type node on switch_block
1547 node. */
1548
e04a16fb
AG		 1549switch_block:
1550 OCB_TK CCB_TK
f8976021 1551 { $$ = NULL_TREE; }
e04a16fb 1552| OCB_TK switch_labels CCB_TK
f8976021 1553 { $$ = NULL_TREE; }
e04a16fb 1554| OCB_TK switch_block_statement_groups CCB_TK
f8976021 1555 { $$ = NULL_TREE; }
e04a16fb 1556| OCB_TK switch_block_statement_groups switch_labels CCB_TK
f8976021 1557 { $$ = NULL_TREE; }
e04a16fb
AG		 1558;
1559
1560switch_block_statement_groups:
1561 switch_block_statement_group
1562| switch_block_statement_groups switch_block_statement_group
1563;
1564
1565switch_block_statement_group:
15fdcfe9 1566 switch_labels block_statements
e04a16fb
AG		 1567;
1568
e04a16fb
AG		 1569switch_labels:
1570 switch_label
1571| switch_labels switch_label
1572;
1573
1574switch_label:
1575 CASE_TK constant_expression REL_CL_TK
b67d701b 1576 {
15fdcfe9
PB		 1577 tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1578 EXPR_WFL_LINECOL (lab) = $1.location;
1579 java_method_add_stmt (current_function_decl, lab);
b67d701b 1580 }
e04a16fb 1581| DEFAULT_TK REL_CL_TK
b67d701b 1582 {
15fdcfe9
PB		 1583 tree lab = build1 (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1584 EXPR_WFL_LINECOL (lab) = $1.location;
1585 java_method_add_stmt (current_function_decl, lab);
b67d701b 1586 }
e04a16fb
AG		 1587| CASE_TK error
1588 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1589| CASE_TK constant_expression error
1590 {yyerror ("':' expected"); RECOVER;}
1591| DEFAULT_TK error
1592 {yyerror ("':' expected"); RECOVER;}
1593;
1594
1595while_expression:
1596 WHILE_TK OP_TK expression CP_TK
1597 {
1598 tree body = build_loop_body ($2.location, $3, 0);
1599 $$ = build_new_loop (body);
1600 }
1601;
1602
1603while_statement:
1604 while_expression statement
b635eb2f 1605 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
e04a16fb
AG		 1606| WHILE_TK error
1607 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1608| WHILE_TK OP_TK error
1609 {yyerror ("Missing term and ')' expected"); RECOVER;}
1610| WHILE_TK OP_TK expression error
1611 {yyerror ("')' expected"); RECOVER;}
1612;
1613
1614while_statement_nsi:
1615 while_expression statement_nsi
b635eb2f 1616 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
e04a16fb
AG		 1617;
1618
1619do_statement_begin:
1620 DO_TK
1621 {
1622 tree body = build_loop_body (0, NULL_TREE, 1);
1623 $$ = build_new_loop (body);
1624 }
1625 /* Need error handing here. FIXME */
1626;
1627
1628do_statement:
1629 do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
b635eb2f 1630 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
e04a16fb
AG		 1631;
1632
1633for_statement:
1634 for_begin SC_TK expression SC_TK for_update CP_TK statement
774d2baf
TT		 1635 {
1636 if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1637 $3 = build_wfl_node ($3);
1638 $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1639 }
e04a16fb
AG		 1640| for_begin SC_TK SC_TK for_update CP_TK statement
1641 {
b635eb2f 1642 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
e04a16fb
AG		 1643 /* We have not condition, so we get rid of the EXIT_EXPR */
1644 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
9bbc7d9f 1645 empty_stmt_node;
e04a16fb
AG		 1646 }
1647| for_begin SC_TK error
1648 {yyerror ("Invalid control expression"); RECOVER;}
1649| for_begin SC_TK expression SC_TK error
1650 {yyerror ("Invalid update expression"); RECOVER;}
1651| for_begin SC_TK SC_TK error
1652 {yyerror ("Invalid update expression"); RECOVER;}
1653;
1654
1655for_statement_nsi:
1656 for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
b635eb2f 1657 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
e04a16fb
AG		 1658| for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1659 {
b635eb2f 1660 $$ = finish_for_loop (0, NULL_TREE, $4, $6);
e04a16fb
AG		 1661 /* We have not condition, so we get rid of the EXIT_EXPR */
1662 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
9bbc7d9f 1663 empty_stmt_node;
e04a16fb
AG		 1664 }
1665;
1666
1667for_header:
1668 FOR_TK OP_TK
1669 {
1670 /* This scope defined for local variable that may be
1671 defined within the scope of the for loop */
1672 enter_block ();
1673 }
1674| FOR_TK error
1675 {yyerror ("'(' expected"); DRECOVER(for_1);}
1676| FOR_TK OP_TK error
1677 {yyerror ("Invalid init statement"); RECOVER;}
1678;
1679
1680for_begin:
1681 for_header for_init
1682 {
1683 /* We now declare the loop body. The loop is
1684 declared as a for loop. */
1685 tree body = build_loop_body (0, NULL_TREE, 0);
1686 $$ = build_new_loop (body);
c2952b01 1687 FOR_LOOP_P ($$) = 1;
e04a16fb
AG		 1688 /* The loop is added to the current block the for
1689 statement is defined within */
1690 java_method_add_stmt (current_function_decl, $$);
1691 }
1692;
1693for_init: /* Can be empty */
9bbc7d9f 1694 { $$ = empty_stmt_node; }
e04a16fb
AG		 1695| statement_expression_list
1696 {
1697 /* Init statement recorded within the previously
1698 defined block scope */
1699 $$ = java_method_add_stmt (current_function_decl, $1);
1700 }
1701| local_variable_declaration
1702 {
1703 /* Local variable are recorded within the previously
1704 defined block scope */
1705 $$ = NULL_TREE;
1706 }
1707| statement_expression_list error
1708 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1709;
1710
1711for_update: /* Can be empty */
9bbc7d9f 1712 {$$ = empty_stmt_node;}
e04a16fb
AG		 1713| statement_expression_list
1714 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1715;
1716
1717statement_expression_list:
1718 statement_expression
1719 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1720| statement_expression_list C_TK statement_expression
1721 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1722| statement_expression_list C_TK error
1723 {yyerror ("Missing term"); RECOVER;}
1724;
1725
1726break_statement:
1727 BREAK_TK SC_TK
1728 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1729| BREAK_TK identifier SC_TK
1730 { $$ = build_bc_statement ($1.location, 1, $2); }
1731| BREAK_TK error
1732 {yyerror ("Missing term"); RECOVER;}
1733| BREAK_TK identifier error
1734 {yyerror ("';' expected"); RECOVER;}
1735;
1736
1737continue_statement:
1738 CONTINUE_TK SC_TK
1739 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1740| CONTINUE_TK identifier SC_TK
1741 { $$ = build_bc_statement ($1.location, 0, $2); }
1742| CONTINUE_TK error
1743 {yyerror ("Missing term"); RECOVER;}
1744| CONTINUE_TK identifier error
1745 {yyerror ("';' expected"); RECOVER;}
1746;
1747
1748return_statement:
1749 RETURN_TK SC_TK
1750 { $$ = build_return ($1.location, NULL_TREE); }
1751| RETURN_TK expression SC_TK
1752 { $$ = build_return ($1.location, $2); }
1753| RETURN_TK error
1754 {yyerror ("Missing term"); RECOVER;}
1755| RETURN_TK expression error
1756 {yyerror ("';' expected"); RECOVER;}
1757;
1758
1759throw_statement:
1760 THROW_TK expression SC_TK
b9f7e36c
APB		 1761 {
1762 $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1763 EXPR_WFL_LINECOL ($$) = $1.location;
1764 }
e04a16fb
AG		 1765| THROW_TK error
1766 {yyerror ("Missing term"); RECOVER;}
1767| THROW_TK expression error
1768 {yyerror ("';' expected"); RECOVER;}
1769;
1770
1771synchronized_statement:
1772 synchronized OP_TK expression CP_TK block
b9f7e36c
APB		 1773 {
1774 $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1775 EXPR_WFL_LINECOL ($$) =
1776 EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1777 }
e04a16fb
AG		 1778| synchronized OP_TK expression CP_TK error
1779 {yyerror ("'{' expected"); RECOVER;}
1780| synchronized error
1781 {yyerror ("'(' expected"); RECOVER;}
1782| synchronized OP_TK error CP_TK
1783 {yyerror ("Missing term"); RECOVER;}
1784| synchronized OP_TK error
1785 {yyerror ("Missing term"); RECOVER;}
1786;
1787
b9f7e36c 1788synchronized:
efa0a23f 1789 modifiers
e04a16fb 1790 {
781b0558
KG		 1791 check_modifiers (
1792 "Illegal modifier `%s'. Only `synchronized' was expected here",
efa0a23f
APB		 1793 $1, ACC_SYNCHRONIZED);
1794 if ($1 != ACC_SYNCHRONIZED)
1795 MODIFIER_WFL (SYNCHRONIZED_TK) =
1796 build_wfl_node (NULL_TREE);
e04a16fb
AG		 1797 }
1798;
1799
1800try_statement:
1801 TRY_TK block catches
a7d8d81f 1802 { $$ = build_try_statement ($1.location, $2, $3); }
e04a16fb 1803| TRY_TK block finally
a7d8d81f 1804 { $$ = build_try_finally_statement ($1.location, $2, $3); }
e04a16fb 1805| TRY_TK block catches finally
2aa11e97
APB		 1806 { $$ = build_try_finally_statement
1807 ($1.location, build_try_statement ($1.location,
1808 $2, $3), $4);
1809 }
e04a16fb
AG		 1810| TRY_TK error
1811 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1812;
1813
1814catches:
1815 catch_clause
1816| catches catch_clause
b67d701b
PB		 1817 {
1818 TREE_CHAIN ($2) = $1;
1819 $$ = $2;
1820 }
e04a16fb
AG		 1821;
1822
1823catch_clause:
b67d701b
PB		 1824 catch_clause_parameter block
1825 {
1826 java_method_add_stmt (current_function_decl, $2);
1827 exit_block ();
1828 $$ = $1;
1829 }
1830
1831catch_clause_parameter:
1832 CATCH_TK OP_TK formal_parameter CP_TK
1833 {
1834 /* We add a block to define a scope for
1835 formal_parameter (CCBP). The formal parameter is
1836 declared initialized by the appropriate function
1837 call */
1838 tree ccpb = enter_block ();
1839 tree init = build_assignment (ASSIGN_TK, $2.location,
1840 TREE_PURPOSE ($3),
1841 soft_exceptioninfo_call_node);
1842 declare_local_variables (0, TREE_VALUE ($3),
1843 build_tree_list (TREE_PURPOSE ($3),
1844 init));
1845 $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1846 EXPR_WFL_LINECOL ($$) = $1.location;
1847 }
e04a16fb 1848| CATCH_TK error
97f30284 1849 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
e04a16fb 1850| CATCH_TK OP_TK error
97f30284
APB		 1851 {
1852 yyerror ("Missing term or ')' expected");
1853 RECOVER; $$ = NULL_TREE;
1854 }
b67d701b 1855| CATCH_TK OP_TK error CP_TK /* That's for () */
97f30284 1856 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
e04a16fb
AG		 1857;
1858
1859finally:
1860 FINALLY_TK block
a7d8d81f 1861 { $$ = $2; }
e04a16fb
AG		 1862| FINALLY_TK error
1863 {yyerror ("'{' expected"); RECOVER; }
1864;
1865
1866/* 19.12 Production from 15: Expressions */
1867primary:
1868 primary_no_new_array
1869| array_creation_expression
1870;
1871
1872primary_no_new_array:
1873 literal
1874| THIS_TK
1875 { $$ = build_this ($1.location); }
1876| OP_TK expression CP_TK
1877 {$$ = $2;}
1878| class_instance_creation_expression
1879| field_access
1880| method_invocation
1881| array_access
c2952b01 1882| type_literals
e04a16fb
AG		 1883 /* Added, JDK1.1 inner classes. Documentation is wrong
1884 refering to a 'ClassName' (class_name) rule that doesn't
c2952b01 1885 exist. Used name: instead. */
e04a16fb 1886| name DOT_TK THIS_TK
c2952b01
APB		 1887 {
1888 tree wfl = build_wfl_node (this_identifier_node);
1889 $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1890 }
e04a16fb
AG		 1891| OP_TK expression error
1892 {yyerror ("')' expected"); RECOVER;}
1893| name DOT_TK error
1894 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1895| primitive_type DOT_TK error
1896 {yyerror ("'class' expected" ); RECOVER;}
1897| VOID_TK DOT_TK error
1898 {yyerror ("'class' expected" ); RECOVER;}
1899;
1900
c2952b01
APB		 1901/* Added, JDK1.1 type literals. We can't use `type' directly, so we
1902 broke the rule down a bit. */
1903
1904array_type_literal:
1905 primitive_type OSB_TK CSB_TK
1906 {
1907 $$ = build_java_array_type ($1, -1);
1908 CLASS_LOADED_P ($$) = 1;
1909 }
1910| name OSB_TK CSB_TK
1911 { $$ = build_unresolved_array_type ($1); }
1912/* This triggers two reduce/reduce conflict between array_type_literal and
1913 dims. FIXME.
1914| array_type OSB_TK CSB_TK
1915 { $$ = build_unresolved_array_type ($1); }
1916*/
1917;
1918
1919type_literals:
1920 name DOT_TK CLASS_TK
1921 { $$ = build_incomplete_class_ref ($2.location, $1); }
1922| array_type_literal DOT_TK CLASS_TK
1923 { $$ = build_incomplete_class_ref ($2.location, $1); }
1924| primitive_type DOT_TK CLASS_TK
1925 { $$ = build_class_ref ($1); }
1926| VOID_TK DOT_TK CLASS_TK
1927 { $$ = build_class_ref (void_type_node); }
1928;
1929
e04a16fb
AG		 1930class_instance_creation_expression:
1931 NEW_TK class_type OP_TK argument_list CP_TK
b67d701b 1932 { $$ = build_new_invocation ($2, $4); }
e04a16fb 1933| NEW_TK class_type OP_TK CP_TK
b67d701b 1934 { $$ = build_new_invocation ($2, NULL_TREE); }
c2952b01 1935| anonymous_class_creation
e04a16fb
AG		 1936 /* Added, JDK1.1 inner classes, modified to use name or
1937 primary instead of primary solely which couldn't work in
1938 all situations. */
1939| something_dot_new identifier OP_TK CP_TK
c2952b01
APB		 1940 {
1941 tree ctor = build_new_invocation ($2, NULL_TREE);
1942 $$ = make_qualified_primary ($1, ctor,
1943 EXPR_WFL_LINECOL ($1));
1944 }
e04a16fb
AG		 1945| something_dot_new identifier OP_TK CP_TK class_body
1946| something_dot_new identifier OP_TK argument_list CP_TK
c2952b01
APB		 1947 {
1948 tree ctor = build_new_invocation ($2, $4);
1949 $$ = make_qualified_primary ($1, ctor,
1950 EXPR_WFL_LINECOL ($1));
1951 }
e04a16fb
AG		 1952| something_dot_new identifier OP_TK argument_list CP_TK class_body
1953| NEW_TK error SC_TK
1954 {yyerror ("'(' expected"); DRECOVER(new_1);}
1955| NEW_TK class_type error
1956 {yyerror ("'(' expected"); RECOVER;}
1957| NEW_TK class_type OP_TK error
1958 {yyerror ("')' or term expected"); RECOVER;}
1959| NEW_TK class_type OP_TK argument_list error
1960 {yyerror ("')' expected"); RECOVER;}
1961| something_dot_new error
1962 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
1963| something_dot_new identifier error
1964 {yyerror ("'(' expected"); RECOVER;}
1965;
1966
c2952b01
APB		 1967/* Created after JDK1.1 rules originally added to
1968 class_instance_creation_expression, but modified to use
1969 'class_type' instead of 'TypeName' (type_name) which is mentionned
1970 in the documentation but doesn't exist. */
1971
1972anonymous_class_creation:
1973 NEW_TK class_type OP_TK argument_list CP_TK
1974 { create_anonymous_class ($1.location, $2); }
1975 class_body
1976 {
1977 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
1978 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
1979
1980 end_class_declaration (1);
1981
1982 /* Now we can craft the new expression */
1983 $$ = build_new_invocation (id, $4);
1984
1985 /* Note that we can't possibly be here if
1986 `class_type' is an interface (in which case the
1987 anonymous class extends Object and implements
1988 `class_type', hence its constructor can't have
1989 arguments.) */
1990
1991 /* Otherwise, the innerclass must feature a
1992 constructor matching `argument_list'. Anonymous
1993 classes are a bit special: it's impossible to
1994 define constructor for them, hence constructors
1995 must be generated following the hints provided by
1996 the `new' expression. Whether a super constructor
1997 of that nature exists or not is to be verified
1998 later on in verify_constructor_super.
1999
2000 It's during the expansion of a `new' statement
2001 refering to an anonymous class that a ctor will
2002 be generated for the anonymous class, with the
2003 right arguments. */
2004
2005 }
2006| NEW_TK class_type OP_TK CP_TK
2007 { create_anonymous_class ($1.location, $2); }
2008 class_body
2009 {
2010 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2011 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2012
2013 end_class_declaration (1);
2014
2015 /* Now we can craft the new expression. The
2016 statement doesn't need to be remember so that a
2017 constructor can be generated, since its signature
2018 is already known. */
2019 $$ = build_new_invocation (id, NULL_TREE);
2020 }
2021;
2022
e04a16fb
AG		 2023something_dot_new: /* Added, not part of the specs. */
2024 name DOT_TK NEW_TK
c2952b01 2025 { $$ = $1; }
e04a16fb 2026| primary DOT_TK NEW_TK
c2952b01 2027 { $$ = $1; }
e04a16fb
AG		 2028;
2029
2030argument_list:
2031 expression
2032 {
2033 $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2034 ctxp->formal_parameter_number = 1;
2035 }
2036| argument_list C_TK expression
2037 {
2038 ctxp->formal_parameter_number += 1;
2039 $$ = tree_cons (NULL_TREE, $3, $1);
2040 }
2041| argument_list C_TK error
2042 {yyerror ("Missing term"); RECOVER;}
2043;
2044
2045array_creation_expression:
2046 NEW_TK primitive_type dim_exprs
2047 { $$ = build_newarray_node ($2, $3, 0); }
2048| NEW_TK class_or_interface_type dim_exprs
2049 { $$ = build_newarray_node ($2, $3, 0); }
2050| NEW_TK primitive_type dim_exprs dims
ba179f9f 2051 { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
e04a16fb 2052| NEW_TK class_or_interface_type dim_exprs dims
ba179f9f 2053 { $$ = build_newarray_node ($2, $3, CURRENT_OSB (ctxp));}
e04a16fb
AG		 2054 /* Added, JDK1.1 anonymous array. Initial documentation rule
2055 modified */
2056| NEW_TK class_or_interface_type dims array_initializer
c2952b01
APB		 2057 {
2058 char *sig;
2059 while (CURRENT_OSB (ctxp)--)
2060 obstack_1grow (&temporary_obstack, '[');
2061 sig = obstack_finish (&temporary_obstack);
2062 $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2063 $2, get_identifier (sig), $4);
2064 }
e04a16fb 2065| NEW_TK primitive_type dims array_initializer
c2952b01
APB		 2066 {
2067 tree type = $2;
2068 while (CURRENT_OSB (ctxp)--)
2069 type = build_java_array_type (type, -1);
2070 $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2071 build_pointer_type (type), NULL_TREE, $4);
2072 }
e04a16fb
AG		 2073| NEW_TK error CSB_TK
2074 {yyerror ("'[' expected"); DRECOVER ("]");}
2075| NEW_TK error OSB_TK
2076 {yyerror ("']' expected"); RECOVER;}
2077;
2078
2079dim_exprs:
2080 dim_expr
2081 { $$ = build_tree_list (NULL_TREE, $1); }
2082| dim_exprs dim_expr
2083 { $$ = tree_cons (NULL_TREE, $2, $$); }
2084;
2085
2086dim_expr:
2087 OSB_TK expression CSB_TK
2088 {
9a7ab4b3
APB		 2089 if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2090 {
2091 $2 = build_wfl_node ($2);
2092 TREE_TYPE ($2) = NULL_TREE;
2093 }
e04a16fb
AG		 2094 EXPR_WFL_LINECOL ($2) = $1.location;
2095 $$ = $2;
2096 }
2097| OSB_TK expression error
2098 {yyerror ("']' expected"); RECOVER;}
2099| OSB_TK error
2100 {
2101 yyerror ("Missing term");
2102 yyerror ("']' expected");
2103 RECOVER;
2104 }
2105;
2106
2107dims:
2108 OSB_TK CSB_TK
ba179f9f
APB		 2109 {
2110 int allocate = 0;
2111 /* If not initialized, allocate memory for the osb
2112 numbers stack */
2113 if (!ctxp->osb_limit)
2114 {
2115 allocate = ctxp->osb_limit = 32;
2116 ctxp->osb_depth = -1;
2117 }
c2952b01 2118 /* If capacity overflown, reallocate a bigger chunk */
ba179f9f
APB		 2119 else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2120 allocate = ctxp->osb_limit << 1;
2121
2122 if (allocate)
2123 {
2124 allocate *= sizeof (int);
2125 if (ctxp->osb_number)
2126 ctxp->osb_number = (int *)xrealloc (ctxp->osb_number,
2127 allocate);
2128 else
2129 ctxp->osb_number = (int *)xmalloc (allocate);
2130 }
2131 ctxp->osb_depth++;
2132 CURRENT_OSB (ctxp) = 1;
2133 }
e04a16fb 2134| dims OSB_TK CSB_TK
ba179f9f 2135 { CURRENT_OSB (ctxp)++; }
e04a16fb
AG		 2136| dims OSB_TK error
2137 { yyerror ("']' expected"); RECOVER;}
2138;
2139
2140field_access:
2141 primary DOT_TK identifier
2142 { $$ = make_qualified_primary ($1, $3, $2.location); }
9bbc7d9f
PB		 2143 /* FIXME - REWRITE TO:
2144 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
e04a16fb
AG		 2145| SUPER_TK DOT_TK identifier
2146 {
2147 tree super_wfl =
9ee9b555 2148 build_wfl_node (super_identifier_node);
e04a16fb
AG		 2149 EXPR_WFL_LINECOL (super_wfl) = $1.location;
2150 $$ = make_qualified_name (super_wfl, $3, $2.location);
2151 }
2152| SUPER_TK error
2153 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2154;
2155
2156method_invocation:
2157 name OP_TK CP_TK
2158 { $$ = build_method_invocation ($1, NULL_TREE); }
2159| name OP_TK argument_list CP_TK
2160 { $$ = build_method_invocation ($1, $3); }
2161| primary DOT_TK identifier OP_TK CP_TK
2162 {
22eed1e6
APB		 2163 if (TREE_CODE ($1) == THIS_EXPR)
2164 $$ = build_this_super_qualified_invocation
2165 (1, $3, NULL_TREE, 0, $2.location);
2166 else
2167 {
2168 tree invok = build_method_invocation ($3, NULL_TREE);
2169 $$ = make_qualified_primary ($1, invok, $2.location);
2170 }
e04a16fb
AG		 2171 }
2172| primary DOT_TK identifier OP_TK argument_list CP_TK
2173 {
22eed1e6
APB		 2174 if (TREE_CODE ($1) == THIS_EXPR)
2175 $$ = build_this_super_qualified_invocation
2176 (1, $3, $5, 0, $2.location);
2177 else
2178 {
2179 tree invok = build_method_invocation ($3, $5);
2180 $$ = make_qualified_primary ($1, invok, $2.location);
2181 }
e04a16fb
AG		 2182 }
2183| SUPER_TK DOT_TK identifier OP_TK CP_TK
22eed1e6
APB		 2184 {
2185 $$ = build_this_super_qualified_invocation
2186 (0, $3, NULL_TREE, $1.location, $2.location);
e04a16fb
AG		 2187 }
2188| SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2189 {
22eed1e6
APB		 2190 $$ = build_this_super_qualified_invocation
2191 (0, $3, $5, $1.location, $2.location);
e04a16fb
AG		 2192 }
2193 /* Screws up thing. I let it here until I'm convinced it can
2194 be removed. FIXME
2195| primary DOT_TK error
2196 {yyerror ("'(' expected"); DRECOVER(bad);} */
2197| SUPER_TK DOT_TK error CP_TK
2198 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2199| SUPER_TK DOT_TK error DOT_TK
2200 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2201;
2202
2203array_access:
2204 name OSB_TK expression CSB_TK
2205 { $$ = build_array_ref ($2.location, $1, $3); }
2206| primary_no_new_array OSB_TK expression CSB_TK
2207 { $$ = build_array_ref ($2.location, $1, $3); }
2208| name OSB_TK error
2209 {
2210 yyerror ("Missing term and ']' expected");
2211 DRECOVER(array_access);
2212 }
2213| name OSB_TK expression error
2214 {
2215 yyerror ("']' expected");
2216 DRECOVER(array_access);
2217 }
2218| primary_no_new_array OSB_TK error
2219 {
2220 yyerror ("Missing term and ']' expected");
2221 DRECOVER(array_access);
2222 }
2223| primary_no_new_array OSB_TK expression error
2224 {
2225 yyerror ("']' expected");
2226 DRECOVER(array_access);
2227 }
2228;
2229
2230postfix_expression:
2231 primary
2232| name
2233| post_increment_expression
2234| post_decrement_expression
2235;
2236
2237post_increment_expression:
2238 postfix_expression INCR_TK
2239 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2240;
2241
2242post_decrement_expression:
2243 postfix_expression DECR_TK
2244 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2245;
2246
2247unary_expression:
2248 pre_increment_expression
2249| pre_decrement_expression
2250| PLUS_TK unary_expression
2251 {$$ = build_unaryop ($1.token, $1.location, $2); }
2252| MINUS_TK unary_expression
2253 {$$ = build_unaryop ($1.token, $1.location, $2); }
2254| unary_expression_not_plus_minus
2255| PLUS_TK error
2256 {yyerror ("Missing term"); RECOVER}
2257| MINUS_TK error
2258 {yyerror ("Missing term"); RECOVER}
2259;
2260
2261pre_increment_expression:
2262 INCR_TK unary_expression
2263 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2264| INCR_TK error
2265 {yyerror ("Missing term"); RECOVER}
2266;
2267
2268pre_decrement_expression:
2269 DECR_TK unary_expression
2270 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2271| DECR_TK error
2272 {yyerror ("Missing term"); RECOVER}
2273;
2274
2275unary_expression_not_plus_minus:
2276 postfix_expression
2277| NOT_TK unary_expression
2278 {$$ = build_unaryop ($1.token, $1.location, $2); }
2279| NEG_TK unary_expression
2280 {$$ = build_unaryop ($1.token, $1.location, $2); }
2281| cast_expression
2282| NOT_TK error
2283 {yyerror ("Missing term"); RECOVER}
2284| NEG_TK error
2285 {yyerror ("Missing term"); RECOVER}
2286;
2287
2288cast_expression: /* Error handling here is potentially weak */
2289 OP_TK primitive_type dims CP_TK unary_expression
2290 {
2291 tree type = $2;
ba179f9f 2292 while (CURRENT_OSB (ctxp)--)
e04a16fb 2293 type = build_java_array_type (type, -1);
ba179f9f 2294 ctxp->osb_depth--;
e04a16fb
AG		 2295 $$ = build_cast ($1.location, type, $5);
2296 }
2297| OP_TK primitive_type CP_TK unary_expression
2298 { $$ = build_cast ($1.location, $2, $4); }
2299| OP_TK expression CP_TK unary_expression_not_plus_minus
2300 { $$ = build_cast ($1.location, $2, $4); }
2301| OP_TK name dims CP_TK unary_expression_not_plus_minus
2302 {
49f48c71 2303 const char *ptr;
ba179f9f 2304 while (CURRENT_OSB (ctxp)--)
e04a16fb 2305 obstack_1grow (&temporary_obstack, '[');
ba179f9f 2306 ctxp->osb_depth--;
e04a16fb
AG		 2307 obstack_grow0 (&temporary_obstack,
2308 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2309 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2310 ptr = obstack_finish (&temporary_obstack);
2311 EXPR_WFL_NODE ($2) = get_identifier (ptr);
2312 $$ = build_cast ($1.location, $2, $5);
2313 }
2314| OP_TK primitive_type OSB_TK error
2315 {yyerror ("']' expected, invalid type expression");}
2316| OP_TK error
2317 {
2318 if (ctxp->prevent_ese != lineno)
2319 yyerror ("Invalid type expression"); RECOVER;
2320 RECOVER;
2321 }
2322| OP_TK primitive_type dims CP_TK error
2323 {yyerror ("Missing term"); RECOVER;}
2324| OP_TK primitive_type CP_TK error
2325 {yyerror ("Missing term"); RECOVER;}
2326| OP_TK name dims CP_TK error
2327 {yyerror ("Missing term"); RECOVER;}
2328;
2329
2330multiplicative_expression:
2331 unary_expression
2332| multiplicative_expression MULT_TK unary_expression
2333 {
2334 $$ = build_binop (BINOP_LOOKUP ($2.token),
2335 $2.location, $1, $3);
2336 }
2337| multiplicative_expression DIV_TK unary_expression
2338 {
2339 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2340 $1, $3);
2341 }
2342| multiplicative_expression REM_TK unary_expression
2343 {
2344 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2345 $1, $3);
2346 }
2347| multiplicative_expression MULT_TK error
2348 {yyerror ("Missing term"); RECOVER;}
2349| multiplicative_expression DIV_TK error
2350 {yyerror ("Missing term"); RECOVER;}
2351| multiplicative_expression REM_TK error
2352 {yyerror ("Missing term"); RECOVER;}
2353;
2354
2355additive_expression:
2356 multiplicative_expression
2357| additive_expression PLUS_TK multiplicative_expression
2358 {
2359 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2360 $1, $3);
2361 }
2362| additive_expression MINUS_TK multiplicative_expression
2363 {
2364 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2365 $1, $3);
2366 }
2367| additive_expression PLUS_TK error
2368 {yyerror ("Missing term"); RECOVER;}
2369| additive_expression MINUS_TK error
2370 {yyerror ("Missing term"); RECOVER;}
2371;
2372
2373shift_expression:
2374 additive_expression
2375| shift_expression LS_TK additive_expression
2376 {
2377 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2378 $1, $3);
2379 }
2380| shift_expression SRS_TK additive_expression
2381 {
2382 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2383 $1, $3);
2384 }
2385| shift_expression ZRS_TK additive_expression
2386 {
2387 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2388 $1, $3);
2389 }
2390| shift_expression LS_TK error
2391 {yyerror ("Missing term"); RECOVER;}
2392| shift_expression SRS_TK error
2393 {yyerror ("Missing term"); RECOVER;}
2394| shift_expression ZRS_TK error
2395 {yyerror ("Missing term"); RECOVER;}
2396;
2397
2398relational_expression:
2399 shift_expression
2400| relational_expression LT_TK shift_expression
2401 {
2402 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2403 $1, $3);
2404 }
2405| relational_expression GT_TK shift_expression
2406 {
2407 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2408 $1, $3);
2409 }
2410| relational_expression LTE_TK shift_expression
2411 {
2412 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2413 $1, $3);
2414 }
2415| relational_expression GTE_TK shift_expression
2416 {
2417 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2418 $1, $3);
2419 }
2420| relational_expression INSTANCEOF_TK reference_type
5e942c50 2421 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
e04a16fb
AG		 2422| relational_expression LT_TK error
2423 {yyerror ("Missing term"); RECOVER;}
2424| relational_expression GT_TK error
2425 {yyerror ("Missing term"); RECOVER;}
2426| relational_expression LTE_TK error
2427 {yyerror ("Missing term"); RECOVER;}
2428| relational_expression GTE_TK error
2429 {yyerror ("Missing term"); RECOVER;}
2430| relational_expression INSTANCEOF_TK error
2431 {yyerror ("Invalid reference type"); RECOVER;}
2432;
2433
2434equality_expression:
2435 relational_expression
2436| equality_expression EQ_TK relational_expression
2437 {
2438 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2439 $1, $3);
2440 }
2441| equality_expression NEQ_TK relational_expression
2442 {
2443 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2444 $1, $3);
2445 }
2446| equality_expression EQ_TK error
2447 {yyerror ("Missing term"); RECOVER;}
2448| equality_expression NEQ_TK error
2449 {yyerror ("Missing term"); RECOVER;}
2450;
2451
2452and_expression:
2453 equality_expression
2454| and_expression AND_TK equality_expression
2455 {
2456 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2457 $1, $3);
2458 }
2459| and_expression AND_TK error
2460 {yyerror ("Missing term"); RECOVER;}
2461;
2462
2463exclusive_or_expression:
2464 and_expression
2465| exclusive_or_expression XOR_TK and_expression
2466 {
2467 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2468 $1, $3);
2469 }
2470| exclusive_or_expression XOR_TK error
2471 {yyerror ("Missing term"); RECOVER;}
2472;
2473
2474inclusive_or_expression:
2475 exclusive_or_expression
2476| inclusive_or_expression OR_TK exclusive_or_expression
2477 {
2478 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2479 $1, $3);
2480 }
2481| inclusive_or_expression OR_TK error
2482 {yyerror ("Missing term"); RECOVER;}
2483;
2484
2485conditional_and_expression:
2486 inclusive_or_expression
2487| conditional_and_expression BOOL_AND_TK inclusive_or_expression
2488 {
2489 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2490 $1, $3);
2491 }
2492| conditional_and_expression BOOL_AND_TK error
2493 {yyerror ("Missing term"); RECOVER;}
2494;
2495
2496conditional_or_expression:
2497 conditional_and_expression
2498| conditional_or_expression BOOL_OR_TK conditional_and_expression
2499 {
2500 $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2501 $1, $3);
2502 }
2503| conditional_or_expression BOOL_OR_TK error
2504 {yyerror ("Missing term"); RECOVER;}
2505;
2506
2507conditional_expression: /* Error handling here is weak */
2508 conditional_or_expression
2509| conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
22eed1e6
APB		 2510 {
2511 $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2512 EXPR_WFL_LINECOL ($$) = $2.location;
2513 }
e04a16fb
AG		 2514| conditional_or_expression REL_QM_TK REL_CL_TK error
2515 {
2516 YYERROR_NOW;
2517 yyerror ("Missing term");
2518 DRECOVER (1);
2519 }
2520| conditional_or_expression REL_QM_TK error
2521 {yyerror ("Missing term"); DRECOVER (2);}
2522| conditional_or_expression REL_QM_TK expression REL_CL_TK error
2523 {yyerror ("Missing term"); DRECOVER (3);}
2524;
2525
2526assignment_expression:
2527 conditional_expression
2528| assignment
2529;
2530
2531assignment:
2532 left_hand_side assignment_operator assignment_expression
2533 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2534| left_hand_side assignment_operator error
2535 {
2536 if (ctxp->prevent_ese != lineno)
2537 yyerror ("Missing term");
2538 DRECOVER (assign);
2539 }
2540;
2541
2542left_hand_side:
2543 name
2544| field_access
2545| array_access
2546;
2547
2548assignment_operator:
2549 ASSIGN_ANY_TK
2550| ASSIGN_TK
2551;
2552
2553expression:
2554 assignment_expression
2555;
2556
2557constant_expression:
2558 expression
2559;
2560
2561%%
2562\f
2563
c2952b01
APB		 2564/* This section of the code deal with save/restoring parser contexts.
2565 Add mode documentation here. FIXME */
e04a16fb 2566
c2952b01
APB		 2567/* Helper function. Create a new parser context. With
2568 COPY_FROM_PREVIOUS set to a non zero value, content of the previous
2569 context is copied, otherwise, the new context is zeroed. The newly
2570 created context becomes the current one. */
e04a16fb 2571
c2952b01
APB		 2572static void
2573create_new_parser_context (copy_from_previous)
2574 int copy_from_previous;
e04a16fb 2575{
c2952b01 2576 struct parser_ctxt *new;
e04a16fb 2577
c2952b01
APB		 2578 new = (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt));
2579 if (copy_from_previous)
2580 {
2581 memcpy ((PTR)new, (PTR)ctxp, sizeof (struct parser_ctxt));
2582 new->saved_data_ctx = 1;
2583 }
2584 else
2585 bzero ((PTR) new, sizeof (struct parser_ctxt));
2586
e04a16fb
AG		 2587 new->next = ctxp;
2588 ctxp = new;
c2952b01
APB		 2589}
2590
2591/* Create a new parser context and make it the current one. */
2592
2593void
2594java_push_parser_context ()
2595{
2596 create_new_parser_context (0);
e04a16fb 2597 if (ctxp->next)
5e942c50
APB		 2598 {
2599 ctxp->incomplete_class = ctxp->next->incomplete_class;
2600 ctxp->gclass_list = ctxp->next->gclass_list;
2601 }
e04a16fb
AG		 2602}
2603
c2952b01
APB		 2604void
2605java_pop_parser_context (generate)
2606 int generate;
2607{
2608 tree current;
2609 struct parser_ctxt *toFree, *next;
2610
2611 if (!ctxp)
2612 return;
2613
2614 toFree = ctxp;
2615 next = ctxp->next;
2616 if (next)
2617 {
2618 next->incomplete_class = ctxp->incomplete_class;
2619 next->gclass_list = ctxp->gclass_list;
2620 lineno = ctxp->lineno;
2621 finput = ctxp->finput;
2622 current_class = ctxp->current_class;
2623 }
2624
2625 /* Set the single import class file flag to 0 for the current list
2626 of imported things */
2627 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2628 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 0;
2629
2630 /* And restore those of the previous context */
2631 if ((ctxp = next)) /* Assignment is really meant here */
2632 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2633 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 1;
2634
2635 /* If we pushed a context to parse a class intended to be generated,
2636 we keep it so we can remember the class. What we could actually
2637 do is to just update a list of class names. */
2638 if (generate)
2639 {
2640 toFree->next = ctxp_for_generation;
2641 ctxp_for_generation = toFree;
2642 }
2643 else
2644 free (toFree);
2645}
2646
2647/* Create a parser context for the use of saving some global
2648 variables. */
2649
e04a16fb
AG		 2650void
2651java_parser_context_save_global ()
2652{
22eed1e6
APB		 2653 if (!ctxp)
2654 {
2655 java_push_parser_context ();
ee07f4f4
APB		 2656 ctxp->saved_data_ctx = 1;
2657 }
c2952b01
APB		 2658
2659 /* If this context already stores data, create a new one suitable
2660 for data storage. */
ee07f4f4 2661 else if (ctxp->saved_data)
c2952b01
APB		 2662 create_new_parser_context (1);
2663
e04a16fb
AG		 2664 ctxp->finput = finput;
2665 ctxp->lineno = lineno;
2666 ctxp->current_class = current_class;
2667 ctxp->filename = input_filename;
2668 ctxp->current_function_decl = current_function_decl;
ee07f4f4 2669 ctxp->saved_data = 1;
e04a16fb
AG		 2670}
2671
c2952b01
APB		 2672/* Restore some global variables from the previous context. Make the
2673 previous context the current one. */
2674
e04a16fb
AG		 2675void
2676java_parser_context_restore_global ()
2677{
2678 finput = ctxp->finput;
2679 lineno = ctxp->lineno;
2680 current_class = ctxp->current_class;
2681 input_filename = ctxp->filename;
2682 current_function_decl = ctxp->current_function_decl;
c2952b01 2683 ctxp->saved_data = 0;
ee07f4f4
APB		 2684 if (ctxp->saved_data_ctx)
2685 java_pop_parser_context (0);
e04a16fb
AG		 2686}
2687
c2952b01
APB		 2688/* Suspend vital data for the current class/function being parsed so
2689 that an other class can be parsed. Used to let local/anonymous
2690 classes be parsed. */
2691
2692static void
2693java_parser_context_suspend ()
e04a16fb 2694{
c2952b01 2695 /* This makes debugging through java_debug_context easier */
3b304f5b 2696 static const char *name = "<inner buffer context>";
e04a16fb 2697
c2952b01
APB		 2698 /* Duplicate the previous context, use it to save the globals we're
2699 interested in */
2700 create_new_parser_context (1);
2701 ctxp->current_function_decl = current_function_decl;
2702 ctxp->current_class = current_class;
5e942c50 2703
c2952b01
APB		 2704 /* Then create a new context which inherits all data from the
2705 previous one. This will be the new current context */
2706 create_new_parser_context (1);
2707
2708 /* Help debugging */
2709 ctxp->next->filename = name;
2710}
2711
2712/* Resume vital data for the current class/function being parsed so
2713 that an other class can be parsed. Used to let local/anonymous
2714 classes be parsed. The trick is the data storing file position
2715 informations must be restored to their current value, so parsing
2716 can resume as if no context was ever saved. */
2717
2718static void
2719java_parser_context_resume ()
2720{
2721 struct parser_ctxt *old = ctxp; /* This one is to be discarded */
2722 struct parser_ctxt *saver = old->next; /* This one contain saved info */
2723 struct parser_ctxt *restored = saver->next; /* This one is the old current */
2724
2725 /* We need to inherit the list of classes to complete/generate */
2726 restored->incomplete_class = old->incomplete_class;
2727 restored->gclass_list = old->gclass_list;
2728 restored->classd_list = old->classd_list;
2729 restored->class_list = old->class_list;
2730
2731 /* Restore the current class and function from the saver */
2732 current_class = saver->current_class;
2733 current_function_decl = saver->current_function_decl;
2734
2735 /* Retrive the restored context */
2736 ctxp = restored;
2737
2738 /* Re-installed the data for the parsing to carry on */
2739 bcopy (&old->marker_begining, &ctxp->marker_begining,
2740 (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2741
2742 /* Buffer context can now be discarded */
2743 free (saver);
2744 free (old);
2745}
2746
2747/* Add a new anchor node to which all statement(s) initializing static
2748 and non static initialized upon declaration field(s) will be
2749 linked. */
2750
2751static void
2752java_parser_context_push_initialized_field ()
2753{
2754 tree node;
2755
2756 node = build_tree_list (NULL_TREE, NULL_TREE);
2757 TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2758 CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2759
2760 node = build_tree_list (NULL_TREE, NULL_TREE);
2761 TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2762 CPC_INITIALIZER_LIST (ctxp) = node;
2763
2764 node = build_tree_list (NULL_TREE, NULL_TREE);
2765 TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2766 CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2767}
2768
2769/* Pop the lists of initialized field. If this lists aren't empty,
2770 remember them so we can use it to create and populate the $finit$
2771 or <clinit> functions. */
2772
2773static void
2774java_parser_context_pop_initialized_field ()
2775{
2776 tree stmts;
2777 tree class_type = TREE_TYPE (GET_CPC ());
2778
2779 if (CPC_INITIALIZER_LIST (ctxp))
e04a16fb 2780 {
c2952b01
APB		 2781 stmts = CPC_INITIALIZER_STMT (ctxp);
2782 CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2783 if (stmts && !java_error_count)
2784 TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
e04a16fb
AG		 2785 }
2786
c2952b01
APB		 2787 if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2788 {
2789 stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2790 CPC_STATIC_INITIALIZER_LIST (ctxp) =
2791 TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2792 /* Keep initialization in order to enforce 8.5 */
2793 if (stmts && !java_error_count)
2794 TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2795 }
e04a16fb 2796
c2952b01
APB		 2797 /* JDK 1.1 instance initializers */
2798 if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
b351b287 2799 {
c2952b01
APB		 2800 stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2801 CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2802 TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2803 if (stmts && !java_error_count)
2804 TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
b351b287 2805 }
c2952b01
APB		 2806}
2807
2808static tree
2809reorder_static_initialized (list)
2810 tree list;
2811{
2812 /* We have to keep things in order. The alias initializer have to
2813 come first, then the initialized regular field, in reverse to
2814 keep them in lexical order. */
2815 tree marker, previous = NULL_TREE;
2816 for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2817 if (TREE_CODE (marker) == TREE_LIST
2818 && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2819 break;
2820
2821 /* No static initialized, the list is fine as is */
2822 if (!previous)
2823 list = TREE_CHAIN (marker);
2824
2825 /* No marker? reverse the whole list */
2826 else if (!marker)
2827 list = nreverse (list);
2828
2829 /* Otherwise, reverse what's after the marker and the new reordered
2830 sublist will replace the marker. */
b351b287 2831 else
c2952b01
APB		 2832 {
2833 TREE_CHAIN (previous) = NULL_TREE;
2834 list = nreverse (list);
2835 list = chainon (TREE_CHAIN (marker), list);
2836 }
2837 return list;
e04a16fb
AG		 2838}
2839
c2952b01
APB		 2840/* Helper functions to dump the parser context stack. */
2841
2842#define TAB_CONTEXT(C) \
2843 {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
ee07f4f4
APB		 2844
2845static void
2846java_debug_context_do (tab)
2847 int tab;
2848{
ee07f4f4
APB		 2849 struct parser_ctxt *copy = ctxp;
2850 while (copy)
2851 {
c2952b01 2852 TAB_CONTEXT (tab);
ee07f4f4 2853 fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
c2952b01 2854 TAB_CONTEXT (tab);
ee07f4f4 2855 fprintf (stderr, "filename: %s\n", copy->filename);
c2952b01
APB		 2856 TAB_CONTEXT (tab);
2857 fprintf (stderr, "lineno: %d\n", copy->lineno);
2858 TAB_CONTEXT (tab);
ee07f4f4
APB		 2859 fprintf (stderr, "package: %s\n",
2860 (copy->package ?
2861 IDENTIFIER_POINTER (copy->package) : "<none>"));
c2952b01 2862 TAB_CONTEXT (tab);
ee07f4f4 2863 fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
c2952b01 2864 TAB_CONTEXT (tab);
ee07f4f4
APB		 2865 fprintf (stderr, "saved data: %d\n", copy->saved_data);
2866 copy = copy->next;
2867 tab += 2;
2868 }
ee07f4f4
APB		 2869}
2870
c2952b01
APB		 2871/* Dump the stacked up parser contexts. Intended to be called from a
2872 debugger. */
2873
ee07f4f4
APB		 2874void
2875java_debug_context ()
2876{
2877 java_debug_context_do (0);
2878}
2879
c2952b01
APB		 2880\f
2881
2882/* Flag for the error report routine to issue the error the first time
2883 it's called (overriding the default behavior which is to drop the
2884 first invocation and honor the second one, taking advantage of a
2885 richer context. */
2886static int force_error = 0;
ee07f4f4 2887
8119c720
APB		 2888/* Reporting an constructor invocation error. */
2889static void
2890parse_ctor_invocation_error ()
2891{
2892 if (DECL_CONSTRUCTOR_P (current_function_decl))
2893 yyerror ("Constructor invocation must be first thing in a constructor");
2894 else
2895 yyerror ("Only constructors can invoke constructors");
2896}
2897
2898/* Reporting JDK1.1 features not implemented. */
b67d701b
PB		 2899
2900static tree
2901parse_jdk1_1_error (msg)
49f48c71 2902 const char *msg;
b67d701b
PB		 2903{
2904 sorry (": `%s' JDK1.1(TM) feature", msg);
2905 java_error_count++;
9bbc7d9f 2906 return empty_stmt_node;
b67d701b
PB		 2907}
2908
e04a16fb
AG		 2909static int do_warning = 0;
2910
2911void
2912yyerror (msg)
49f48c71 2913 const char *msg;
e04a16fb
AG		 2914{
2915 static java_lc elc;
2916 static int prev_lineno;
49f48c71 2917 static const char *prev_msg;
e04a16fb 2918
0a2138e2 2919 int save_lineno;
e04a16fb
AG		 2920 char *remainder, *code_from_source;
2921 extern struct obstack temporary_obstack;
2922
2923 if (!force_error && prev_lineno == lineno)
2924 return;
2925
2926 /* Save current error location but report latter, when the context is
2927 richer. */
2928 if (ctxp->java_error_flag == 0)
2929 {
2930 ctxp->java_error_flag = 1;
2931 elc = ctxp->elc;
2932 /* Do something to use the previous line if we're reaching the
2933 end of the file... */
2934#ifdef VERBOSE_SKELETON
2935 printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
2936#endif
2937 return;
2938 }
2939
2940 /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
2941 if (!force_error && msg == prev_msg && prev_lineno == elc.line)
2942 return;
2943
2944 ctxp->java_error_flag = 0;
2945 if (do_warning)
2946 java_warning_count++;
2947 else
2948 java_error_count++;
2949
807bc1db 2950 if (elc.col == 0 && msg && msg[1] == ';')
e04a16fb
AG		 2951 {
2952 elc.col = ctxp->p_line->char_col-1;
2953 elc.line = ctxp->p_line->lineno;
2954 }
2955
2956 save_lineno = lineno;
2957 prev_lineno = lineno = elc.line;
2958 prev_msg = msg;
2959
2960 code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
2961 obstack_grow0 (&temporary_obstack,
2962 code_from_source, strlen (code_from_source));
2963 remainder = obstack_finish (&temporary_obstack);
2964 if (do_warning)
2965 warning ("%s.\n%s", msg, remainder);
2966 else
2967 error ("%s.\n%s", msg, remainder);
2968
2969 /* This allow us to cheaply avoid an extra 'Invalid expression
2970 statement' error report when errors have been already reported on
2971 the same line. This occurs when we report an error but don't have
2972 a synchronization point other than ';', which
2973 expression_statement is the only one to take care of. */
2974 ctxp->prevent_ese = lineno = save_lineno;
2975}
2976
2977static void
15fdcfe9 2978issue_warning_error_from_context (cl, msg, ap)
5e942c50 2979 tree cl;
d4476be2 2980 const char *msg;
15fdcfe9 2981 va_list ap;
5e942c50 2982{
3b304f5b 2983 const char *saved, *saved_input_filename;
15fdcfe9
PB		 2984 char buffer [4096];
2985 vsprintf (buffer, msg, ap);
2986 force_error = 1;
5e942c50
APB		 2987
2988 ctxp->elc.line = EXPR_WFL_LINENO (cl);
82371d41
APB		 2989 ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
2990 (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
5e942c50
APB		 2991
2992 /* We have a CL, that's a good reason for using it if it contains data */
2993 saved = ctxp->filename;
2994 if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
2995 ctxp->filename = EXPR_WFL_FILENAME (cl);
1886c9d8
APB		 2996 saved_input_filename = input_filename;
2997 input_filename = ctxp->filename;
15fdcfe9
PB		 2998 java_error (NULL);
2999 java_error (buffer);
5e942c50 3000 ctxp->filename = saved;
1886c9d8 3001 input_filename = saved_input_filename;
15fdcfe9 3002 force_error = 0;
5e942c50
APB		 3003}
3004
e04a16fb
AG		 3005/* Issue an error message at a current source line CL */
3006
15fdcfe9 3007void
df32d2ce 3008parse_error_context VPARAMS ((tree cl, const char *msg, ...))
e04a16fb 3009{
d4476be2 3010#ifndef ANSI_PROTOTYPES
e04a16fb 3011 tree cl;
d4476be2 3012 const char *msg;
e04a16fb 3013#endif
e04a16fb
AG		 3014 va_list ap;
3015
3016 VA_START (ap, msg);
d4476be2 3017#ifndef ANSI_PROTOTYPES
e04a16fb 3018 cl = va_arg (ap, tree);
d4476be2 3019 msg = va_arg (ap, const char *);
e04a16fb 3020#endif
15fdcfe9
PB		 3021 issue_warning_error_from_context (cl, msg, ap);
3022 va_end (ap);
e04a16fb
AG		 3023}
3024
3025/* Issue a warning at a current source line CL */
3026
3027static void
df32d2ce 3028parse_warning_context VPARAMS ((tree cl, const char *msg, ...))
e04a16fb 3029{
d4476be2 3030#ifndef ANSI_PROTOTYPES
e04a16fb 3031 tree cl;
d4476be2 3032 const char *msg;
e04a16fb 3033#endif
e04a16fb
AG		 3034 va_list ap;
3035
3036 VA_START (ap, msg);
d4476be2 3037#ifndef ANSI_PROTOTYPES
e04a16fb 3038 cl = va_arg (ap, tree);
d4476be2 3039 msg = va_arg (ap, const char *);
e04a16fb 3040#endif
e04a16fb 3041
c877974e 3042 force_error = do_warning = 1;
15fdcfe9 3043 issue_warning_error_from_context (cl, msg, ap);
c877974e 3044 do_warning = force_error = 0;
15fdcfe9 3045 va_end (ap);
e04a16fb
AG		 3046}
3047
82371d41
APB		 3048static tree
3049find_expr_with_wfl (node)
3050 tree node;
3051{
3052 while (node)
3053 {
3054 char code;
3055 tree to_return;
3056
3057 switch (TREE_CODE (node))
3058 {
3059 case BLOCK:
c0d87ff6
PB		 3060 node = BLOCK_EXPR_BODY (node);
3061 continue;
82371d41
APB		 3062
3063 case COMPOUND_EXPR:
3064 to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3065 if (to_return)
3066 return to_return;
c0d87ff6
PB		 3067 node = TREE_OPERAND (node, 1);
3068 continue;
82371d41
APB		 3069
3070 case LOOP_EXPR:
c0d87ff6
PB		 3071 node = TREE_OPERAND (node, 0);
3072 continue;
82371d41
APB		 3073
3074 case LABELED_BLOCK_EXPR:
c0d87ff6
PB		 3075 node = TREE_OPERAND (node, 1);
3076 continue;
3077
82371d41
APB		 3078 default:
3079 code = TREE_CODE_CLASS (TREE_CODE (node));
3080 if (((code == '1') || (code == '2') || (code == 'e'))
3081 && EXPR_WFL_LINECOL (node))
3082 return node;
ba179f9f 3083 return NULL_TREE;
82371d41
APB		 3084 }
3085 }
3086 return NULL_TREE;
3087}
3088
3089/* Issue a missing return statement error. Uses METHOD to figure the
3090 last line of the method the error occurs in. */
3091
3092static void
3093missing_return_error (method)
3094 tree method;
3095{
3096 EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
3097 parse_error_context (wfl_operator, "Missing return statement");
3098}
3099
3100/* Issue an unreachable statement error. From NODE, find the next
3101 statement to report appropriately. */
3102static void
3103unreachable_stmt_error (node)
3104 tree node;
3105{
3106 /* Browse node to find the next expression node that has a WFL. Use
3107 the location to report the error */
3108 if (TREE_CODE (node) == COMPOUND_EXPR)
3109 node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3110 else
3111 node = find_expr_with_wfl (node);
3112
3113 if (node)
3114 {
3115 EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3116 parse_error_context (wfl_operator, "Unreachable statement");
3117 }
3118 else
3119 fatal ("Can't get valid statement - unreachable_stmt_error");
3120}
3121
c877974e 3122int
e04a16fb
AG		 3123java_report_errors ()
3124{
3125 if (java_error_count)
3126 fprintf (stderr, "%d error%s",
3127 java_error_count, (java_error_count == 1 ? "" : "s"));
3128 if (java_warning_count)
3129 fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3130 java_warning_count, (java_warning_count == 1 ? "" : "s"));
3131 if (java_error_count || java_warning_count)
3132 putc ('\n', stderr);
c877974e 3133 return java_error_count;
e04a16fb
AG		 3134}
3135
3136static char *
3137java_accstring_lookup (flags)
3138 int flags;
3139{
3140 static char buffer [80];
3141#define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3142
3143 /* Access modifier looked-up first for easier report on forbidden
3144 access. */
3145 if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3146 if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3147 if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3148 if (flags & ACC_STATIC) COPY_RETURN ("static");
3149 if (flags & ACC_FINAL) COPY_RETURN ("final");
3150 if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3151 if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3152 if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3153 if (flags & ACC_NATIVE) COPY_RETURN ("native");
3154 if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3155 if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3156
3157 buffer [0] = '\0';
3158 return buffer;
3159#undef COPY_RETURN
3160}
3161
b67d701b
PB		 3162/* Issuing error messages upon redefinition of classes, interfaces or
3163 variables. */
3164
e04a16fb 3165static void
b67d701b 3166classitf_redefinition_error (context, id, decl, cl)
49f48c71 3167 const char *context;
e04a16fb
AG		 3168 tree id, decl, cl;
3169{
3170 parse_error_context (cl, "%s `%s' already defined in %s:%d",
3171 context, IDENTIFIER_POINTER (id),
3172 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3173 /* Here we should point out where its redefined. It's a unicode. FIXME */
3174}
3175
b67d701b
PB		 3176static void
3177variable_redefinition_error (context, name, type, line)
3178 tree context, name, type;
3179 int line;
3180{
49f48c71 3181 const char *type_name;
b67d701b
PB		 3182
3183 /* Figure a proper name for type. We might haven't resolved it */
c877974e
APB		 3184 if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3185 type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
b67d701b 3186 else
0a2138e2 3187 type_name = lang_printable_name (type, 0);
b67d701b
PB		 3188
3189 parse_error_context (context,
781b0558 3190 "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
b67d701b
PB		 3191 IDENTIFIER_POINTER (name),
3192 type_name, IDENTIFIER_POINTER (name), line);
3193}
3194
c583dd46
APB		 3195static tree
3196build_array_from_name (type, type_wfl, name, ret_name)
3197 tree type, type_wfl, name, *ret_name;
3198{
3199 int more_dims = 0;
49f48c71 3200 const char *string;
c583dd46
APB		 3201
3202 /* Eventually get more dims */
3203 string = IDENTIFIER_POINTER (name);
3204 while (string [more_dims] == '[')
3205 more_dims++;
3206
3207 /* If we have, then craft a new type for this variable */
3208 if (more_dims)
3209 {
c0d87ff6 3210 name = get_identifier (&string [more_dims]);
c583dd46 3211
34f4db93
APB		 3212 /* If we have a pointer, use its type */
3213 if (TREE_CODE (type) == POINTER_TYPE)
3214 type = TREE_TYPE (type);
c583dd46
APB		 3215
3216 /* Building the first dimension of a primitive type uses this
3217 function */
3218 if (JPRIMITIVE_TYPE_P (type))
3219 {
3220 type = build_java_array_type (type, -1);
22eed1e6 3221 CLASS_LOADED_P (type) = 1;
c583dd46
APB		 3222 more_dims--;
3223 }
3224 /* Otherwise, if we have a WFL for this type, use it (the type
3225 is already an array on an unresolved type, and we just keep
3226 on adding dimensions) */
3227 else if (type_wfl)
3228 type = type_wfl;
3229
3230 /* Add all the dimensions */
3231 while (more_dims--)
3232 type = build_unresolved_array_type (type);
3233
3234 /* The type may have been incomplete in the first place */
3235 if (type_wfl)
3236 type = obtain_incomplete_type (type);
3237 }
3238
c2952b01
APB		 3239 if (ret_name)
3240 *ret_name = name;
c583dd46
APB		 3241 return type;
3242}
3243
e04a16fb
AG		 3244/* Build something that the type identifier resolver will identify as
3245 being an array to an unresolved type. TYPE_WFL is a WFL on a
3246 identifier. */
3247
3248static tree
3249build_unresolved_array_type (type_or_wfl)
3250 tree type_or_wfl;
3251{
49f48c71 3252 const char *ptr;
e04a16fb 3253
1886c9d8 3254 /* TYPE_OR_WFL might be an array on a resolved type. In this case,
e04a16fb
AG		 3255 just create a array type */
3256 if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3257 {
3258 tree type = build_java_array_type (type_or_wfl, -1);
3259 CLASS_LOADED_P (type) = CLASS_LOADED_P (type_or_wfl);
3260 return type;
3261 }
3262
3263 obstack_1grow (&temporary_obstack, '[');
3264 obstack_grow0 (&temporary_obstack,
3265 IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3266 IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3267 ptr = obstack_finish (&temporary_obstack);
3268 return build_expr_wfl (get_identifier (ptr),
3269 EXPR_WFL_FILENAME (type_or_wfl),
3270 EXPR_WFL_LINENO (type_or_wfl),
3271 EXPR_WFL_COLNO (type_or_wfl));
3272}
3273
e04a16fb
AG		 3274static void
3275parser_add_interface (class_decl, interface_decl, wfl)
3276 tree class_decl, interface_decl, wfl;
3277{
3278 if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3279 parse_error_context (wfl, "Interface `%s' repeated",
3280 IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3281}
3282
3283/* Bulk of common class/interface checks. Return 1 if an error was
3284 encountered. TAG is 0 for a class, 1 for an interface. */
3285
3286static int
3287check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
3288 int is_interface, flags;
3289 tree raw_name, qualified_name, decl, cl;
3290{
3291 tree node;
c2952b01
APB		 3292 int sca = 0; /* Static class allowed */
3293 int icaf = 0; /* Inner class allowed flags */
3294 int uaaf = CLASS_MODIFIERS; /* Usually allowed access flags */
e04a16fb
AG		 3295
3296 if (!quiet_flag)
c2952b01
APB		 3297 fprintf (stderr, " %s%s %s",
3298 (CPC_INNER_P () ? "inner" : ""),
3299 (is_interface ? "interface" : "class"),
e04a16fb
AG		 3300 IDENTIFIER_POINTER (qualified_name));
3301
3302 /* Scope of an interface/class type name:
3303 - Can't be imported by a single type import
3304 - Can't already exists in the package */
3305 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3306 && (node = find_name_in_single_imports (raw_name)))
3307 {
3308 parse_error_context
3309 (cl, "%s name `%s' clashes with imported type `%s'",
3310 (is_interface ? "Interface" : "Class"),
3311 IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3312 return 1;
3313 }
3314 if (decl && CLASS_COMPLETE_P (decl))
3315 {
b67d701b
PB		 3316 classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3317 qualified_name, decl, cl);
e04a16fb
AG		 3318 return 1;
3319 }
3320
c2952b01
APB		 3321 if (check_inner_class_redefinition (raw_name, cl))
3322 return 1;
3323
3324 /* If public, file name should match class/interface name, except
3325 when dealing with an inner class */
3326 if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
e04a16fb 3327 {
49f48c71 3328 const char *f;
e04a16fb
AG		 3329
3330 /* Contains OS dependent assumption on path separator. FIXME */
3331 for (f = &input_filename [strlen (input_filename)];
fa322ab5
TT		 3332 f != input_filename && f[0] != '/' && f[0] != DIR_SEPARATOR;
3333 f--)
3334 ;
847fe791 3335 if (f[0] == '/' || f[0] == DIR_SEPARATOR)
e04a16fb
AG		 3336 f++;
3337 if (strncmp (IDENTIFIER_POINTER (raw_name),
3338 f , IDENTIFIER_LENGTH (raw_name)) ||
3339 f [IDENTIFIER_LENGTH (raw_name)] != '.')
781b0558
KG		 3340 parse_error_context
3341 (cl, "Public %s `%s' must be defined in a file called `%s.java'",
e04a16fb
AG		 3342 (is_interface ? "interface" : "class"),
3343 IDENTIFIER_POINTER (qualified_name),
3344 IDENTIFIER_POINTER (raw_name));
3345 }
3346
c2952b01
APB		 3347 /* Static classes can be declared only in top level classes. Note:
3348 once static, a inner class is a top level class. */
3349 if (flags & ACC_STATIC)
3350 {
3351 /* Catch the specific error of declaring an class inner class
3352 with no toplevel enclosing class. Prevent check_modifiers from
3353 complaining a second time */
3354 if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3355 {
3356 parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3357 IDENTIFIER_POINTER (qualified_name));
3358 sca = ACC_STATIC;
3359 }
3360 /* Else, in the context of a top-level class declaration, let
3361 `check_modifiers' do its job, otherwise, give it a go */
3362 else
3363 sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3364 }
3365
a40d21da 3366 /* Inner classes can be declared private or protected
c2952b01
APB		 3367 within their enclosing classes. */
3368 if (CPC_INNER_P ())
3369 {
3370 /* A class which is local to a block can't be public, private,
3371 protected or static. But it is created final, so allow this
3372 one. */
3373 if (current_function_decl)
3374 icaf = sca = uaaf = ACC_FINAL;
3375 else
3376 {
3377 check_modifiers_consistency (flags);
3378 icaf = ACC_PRIVATE|ACC_PROTECTED;
3379 }
3380 }
3381
a40d21da
APB		 3382 if (is_interface)
3383 {
3384 if (CPC_INNER_P ())
3385 uaaf = INTERFACE_INNER_MODIFIERS;
3386 else
3387 uaaf = INTERFACE_MODIFIERS;
3388
3389 check_modifiers ("Illegal modifier `%s' for interface declaration",
3390 flags, uaaf);
3391 }
2884c41e 3392 else
a40d21da
APB		 3393 check_modifiers ((current_function_decl ?
3394 "Illegal modifier `%s' for local class declaration" :
3395 "Illegal modifier `%s' for class declaration"),
c2952b01 3396 flags, uaaf|sca|icaf);
e04a16fb
AG		 3397 return 0;
3398}
3399
c2952b01
APB		 3400static void
3401make_nested_class_name (cpc_list)
3402 tree cpc_list;
3403{
3404 tree name;
3405
3406 if (!cpc_list)
3407 return;
3408 else
3409 make_nested_class_name (TREE_CHAIN (cpc_list));
3410
3411 /* Pick the qualified name when dealing with the first upmost
3412 enclosing class */
3413 name = (TREE_CHAIN (cpc_list) ?
3414 TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3415 obstack_grow (&temporary_obstack,
3416 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3417 /* Why is NO_DOLLAR_IN_LABEL defined? */
3418#if 0
3419#ifdef NO_DOLLAR_IN_LABEL
3420 fatal ("make_nested_class_name: Can't use '$' as a separator "
3421 "for inner classes");
3422#endif
3423#endif
3424 obstack_1grow (&temporary_obstack, '$');
3425}
3426
3427/* Can't redefine a class already defined in an earlier scope. */
3428
3429static int
3430check_inner_class_redefinition (raw_name, cl)
3431 tree raw_name, cl;
3432{
3433 tree scope_list;
3434
3435 for (scope_list = GET_CPC_LIST (); scope_list;
3436 scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3437 if (raw_name == GET_CPC_UN_NODE (scope_list))
3438 {
3439 parse_error_context
3440 (cl, "The class name `%s' is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
3441 IDENTIFIER_POINTER (raw_name));
3442 return 1;
3443 }
3444 return 0;
3445}
3446
3447static tree
3448find_as_inner_class (enclosing, name, cl)
3449 tree enclosing, name, cl;
3450{
3451 tree qual, to_return;
3452 if (!enclosing)
3453 return NULL_TREE;
3454
3455 name = TYPE_NAME (name);
3456
3457 /* First search: within the scope of `enclosing', search for name */
3458 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3459 qual = EXPR_WFL_QUALIFICATION (cl);
3460 else if (cl)
3461 qual = build_tree_list (cl, NULL_TREE);
3462 else
3463 qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3464
3465 if ((to_return = find_as_inner_class_do (qual, enclosing)))
3466 return to_return;
3467
3468 /* We're dealing with a qualified name. Try to resolve thing until
3469 we get something that is an enclosing class. */
3470 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3471 {
3472 tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3473
3474 for(qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3475 qual = TREE_CHAIN (qual))
3476 {
3477 acc = merge_qualified_name (acc,
3478 EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3479 BUILD_PTR_FROM_NAME (ptr, acc);
3480 decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3481 }
3482
3483 /* A NULL qual and a decl means that the search ended
3484 successfully?!? We have to do something then. FIXME */
3485
3486 if (decl)
3487 enclosing = decl;
3488 else
3489 qual = EXPR_WFL_QUALIFICATION (cl);
3490 }
3491 /* Otherwise, create a qual for the other part of the resolution. */
3492 else
3493 qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3494
3495 return find_as_inner_class_do (qual, enclosing);
3496}
3497
3498/* We go inside the list of sub classes and try to find a way
3499 through. */
3500
3501static tree
3502find_as_inner_class_do (qual, enclosing)
3503 tree qual, enclosing;
3504{
3505 if (!qual)
3506 return NULL_TREE;
3507
3508 for (; qual && enclosing; qual = TREE_CHAIN (qual))
3509 {
3510 tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3511 tree next_enclosing = NULL_TREE;
3512 tree inner_list;
3513
3514 for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3515 inner_list; inner_list = TREE_CHAIN (inner_list))
3516 {
3517 if (TREE_VALUE (inner_list) == name_to_match)
3518 {
3519 next_enclosing = TREE_PURPOSE (inner_list);
3520 break;
3521 }
3522 }
3523 enclosing = next_enclosing;
3524 }
3525
3526 return (!qual && enclosing ? enclosing : NULL_TREE);
3527}
3528
3529/* Reach all inner classes and tie their unqualified name to a
3530 DECL. */
3531
3532static void
3533set_nested_class_simple_name_value (outer, set)
3534 tree outer;
3535 int set;
3536{
3537 tree l;
3538
3539 for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3540 IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3541 TREE_PURPOSE (l) : NULL_TREE);
3542}
3543
3544static void
3545link_nested_class_to_enclosing ()
3546{
3547 if (GET_ENCLOSING_CPC ())
3548 {
3549 tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3550 DECL_INNER_CLASS_LIST (enclosing) =
3551 tree_cons (GET_CPC (), GET_CPC_UN (),
3552 DECL_INNER_CLASS_LIST (enclosing));
3553 enclosing = enclosing;
3554 }
3555}
3556
3557static tree
3558maybe_make_nested_class_name (name)
3559 tree name;
3560{
3561 tree id = NULL_TREE;
3562
3563 if (CPC_INNER_P ())
3564 {
3565 make_nested_class_name (GET_CPC_LIST ());
48a840d9
APB		 3566 obstack_grow0 (&temporary_obstack,
3567 IDENTIFIER_POINTER (name),
3568 IDENTIFIER_LENGTH (name));
c2952b01
APB		 3569 id = get_identifier (obstack_finish (&temporary_obstack));
3570 if (ctxp->package)
3571 QUALIFIED_P (id) = 1;
3572 }
3573 return id;
3574}
3575
3576/* If DECL is NULL, create and push a new DECL, record the current
3577 line CL and do other maintenance things. */
3578
e04a16fb 3579static tree
c2952b01
APB		 3580maybe_create_class_interface_decl (decl, raw_name, qualified_name, cl)
3581 tree decl, raw_name, qualified_name, cl;
e04a16fb 3582{
5e942c50 3583 if (!decl)
e04a16fb 3584 decl = push_class (make_class (), qualified_name);
c2952b01 3585
e04a16fb
AG		 3586 /* Take care of the file and line business */
3587 DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
f099f336
APB		 3588 /* If we're emiting xrefs, store the line/col number information */
3589 if (flag_emit_xref)
3590 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3591 else
3592 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
e04a16fb 3593 CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
b351b287
APB		 3594 CLASS_FROM_CURRENTLY_COMPILED_SOURCE_P (TREE_TYPE (decl)) =
3595 IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
e04a16fb 3596
c2952b01
APB		 3597 PUSH_CPC (decl, raw_name);
3598 DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3599
e04a16fb
AG		 3600 /* Link the declaration to the already seen ones */
3601 TREE_CHAIN (decl) = ctxp->class_list;
3602 ctxp->class_list = decl;
5e942c50 3603
23a79c61 3604 /* Create a new nodes in the global lists */
5e942c50 3605 ctxp->gclass_list = tree_cons (NULL_TREE, decl, ctxp->gclass_list);
23a79c61 3606 all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
5e942c50 3607
e04a16fb
AG		 3608 /* Install a new dependency list element */
3609 create_jdep_list (ctxp);
3610
3611 SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3612 IDENTIFIER_POINTER (qualified_name)));
3613 return decl;
3614}
3615
3616static void
3617add_superinterfaces (decl, interface_list)
3618 tree decl, interface_list;
3619{
3620 tree node;
3621 /* Superinterface(s): if present and defined, parser_check_super_interface ()
3622 takes care of ensuring that:
3623 - This is an accessible interface type,
3624 - Circularity detection.
3625 parser_add_interface is then called. If present but not defined,
3626 the check operation is delayed until the super interface gets
3627 defined. */
3628 for (node = interface_list; node; node = TREE_CHAIN (node))
3629 {
15fdcfe9 3630 tree current = TREE_PURPOSE (node);
5e942c50
APB		 3631 tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3632 if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
e04a16fb 3633 {
5e942c50
APB		 3634 if (!parser_check_super_interface (idecl, decl, current))
3635 parser_add_interface (decl, idecl, current);
e04a16fb
AG		 3636 }
3637 else
3638 register_incomplete_type (JDEP_INTERFACE,
3639 current, decl, NULL_TREE);
3640 }
3641}
3642
3643/* Create an interface in pass1 and return its decl. Return the
3644 interface's decl in pass 2. */
3645
3646static tree
3647create_interface (flags, id, super)
3648 int flags;
3649 tree id, super;
3650{
e04a16fb 3651 tree raw_name = EXPR_WFL_NODE (id);
c2952b01 3652 tree q_name = parser_qualified_classname (flags & ACC_STATIC, raw_name);
e04a16fb
AG		 3653 tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3654
3655 EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */
3656
3657 /* Basic checks: scope, redefinition, modifiers */
3658 if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
c2952b01
APB		 3659 {
3660 PUSH_ERROR ();
3661 return NULL_TREE;
3662 }
3663
3664 /* Suspend the current parsing context if we're parsing an inner
3665 interface */
3666 if (CPC_INNER_P ())
3667 java_parser_context_suspend ();
3668
3669 /* Push a new context for (static) initialized upon declaration fields */
3670 java_parser_context_push_initialized_field ();
e04a16fb
AG		 3671
3672 /* Interface modifiers check
3673 - public/abstract allowed (already done at that point)
3674 - abstract is obsolete (comes first, it's a warning, or should be)
3675 - Can't use twice the same (checked in the modifier rule) */
c877974e 3676 if ((flags & ACC_ABSTRACT) && flag_redundant)
e04a16fb
AG		 3677 parse_warning_context
3678 (MODIFIER_WFL (ABSTRACT_TK),
781b0558 3679 "Redundant use of `abstract' modifier. Interface `%s' is implicitely abstract", IDENTIFIER_POINTER (raw_name));
e04a16fb
AG		 3680
3681 /* Create a new decl if DECL is NULL, otherwise fix it */
c2952b01 3682 decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
e04a16fb
AG		 3683
3684 /* Set super info and mark the class a complete */
2aa11e97 3685 set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
e04a16fb
AG		 3686 object_type_node, ctxp->interface_number);
3687 ctxp->interface_number = 0;
3688 CLASS_COMPLETE_P (decl) = 1;
3689 add_superinterfaces (decl, super);
3690
3691 return decl;
3692}
3693
c2952b01
APB		 3694/* Anonymous class counter. Will be reset to 1 every time a non
3695 anonymous class gets created. */
3696static int anonymous_class_counter = 1;
3697
3698/* Patch anonymous class CLASS, by either extending or implementing
3699 DEP. */
3700
3701static void
3702patch_anonymous_class (type_decl, class_decl, wfl)
3703 tree type_decl, class_decl, wfl;
3704{
3705 tree class = TREE_TYPE (class_decl);
3706 tree type = TREE_TYPE (type_decl);
3707 tree binfo = TYPE_BINFO (class);
3708
3709 /* If it's an interface, implement it */
3710 if (CLASS_INTERFACE (type_decl))
3711 {
3712 tree s_binfo;
3713 int length;
3714
3715 if (parser_check_super_interface (type_decl, class_decl, wfl))
3716 return;
3717
3718 s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3719 length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3720 TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3721 TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3722 /* And add the interface */
3723 parser_add_interface (class_decl, type_decl, wfl);
3724 }
3725 /* Otherwise, it's a type we want to extend */
3726 else
3727 {
3728 if (parser_check_super (type_decl, class_decl, wfl))
3729 return;
3730 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3731 }
3732}
3733
3734static tree
3735create_anonymous_class (location, type_name)
3736 int location;
3737 tree type_name;
3738{
3739 char buffer [80];
3740 tree super = NULL_TREE, itf = NULL_TREE;
3741 tree id, type_decl, class;
3742
3743 /* The unqualified name of the anonymous class. It's just a number. */
3744 sprintf (buffer, "%d", anonymous_class_counter++);
3745 id = build_wfl_node (get_identifier (buffer));
3746 EXPR_WFL_LINECOL (id) = location;
3747
3748 /* We know about the type to extend/implement. We go ahead */
3749 if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3750 {
3751 /* Create a class which either implements on extends the designated
3752 class. The class bears an innacessible name. */
3753 if (CLASS_INTERFACE (type_decl))
3754 {
3755 /* It's OK to modify it here. It's been already used and
3756 shouldn't be reused */
3757 ctxp->interface_number = 1;
3758 /* Interfaces should presented as a list of WFLs */
3759 itf = build_tree_list (type_name, NULL_TREE);
3760 }
3761 else
3762 super = type_name;
3763 }
3764
3765 class = create_class (ACC_FINAL, id, super, itf);
3766
3767 /* We didn't know anything about the stuff. We register a dependence. */
3768 if (!type_decl)
3769 register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3770
3771 ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3772 return class;
3773}
3774
a40d21da 3775/* Create a class in pass1 and return its decl. Return class
e04a16fb
AG		 3776 interface's decl in pass 2. */
3777
3778static tree
3779create_class (flags, id, super, interfaces)
3780 int flags;
3781 tree id, super, interfaces;
3782{
e04a16fb
AG		 3783 tree raw_name = EXPR_WFL_NODE (id);
3784 tree class_id, decl;
9ee9b555 3785 tree super_decl_type;
e04a16fb 3786
c2952b01 3787 class_id = parser_qualified_classname (0, raw_name);
e04a16fb
AG		 3788 decl = IDENTIFIER_CLASS_VALUE (class_id);
3789 EXPR_WFL_NODE (id) = class_id;
3790
3791 /* Basic check: scope, redefinition, modifiers */
3792 if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
c2952b01
APB		 3793 {
3794 PUSH_ERROR ();
3795 return NULL_TREE;
3796 }
3797
3798 /* Suspend the current parsing context if we're parsing an inner
3799 class or an anonymous class. */
3800 if (CPC_INNER_P ())
3801 java_parser_context_suspend ();
3802 /* Push a new context for (static) initialized upon declaration fields */
3803 java_parser_context_push_initialized_field ();
e04a16fb
AG		 3804
3805 /* Class modifier check:
3806 - Allowed modifier (already done at that point)
3807 - abstract AND final forbidden
3808 - Public classes defined in the correct file */
3809 if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
781b0558
KG		 3810 parse_error_context
3811 (id, "Class `%s' can't be declared both abstract and final",
3812 IDENTIFIER_POINTER (raw_name));
e04a16fb
AG		 3813
3814 /* Create a new decl if DECL is NULL, otherwise fix it */
c2952b01 3815 decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
e04a16fb
AG		 3816
3817 /* If SUPER exists, use it, otherwise use Object */
3818 if (super)
3819 {
3820 /* Can't extend java.lang.Object */
3821 if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3822 {
3823 parse_error_context (id, "Can't extend `java.lang.Object'");
3824 return NULL_TREE;
3825 }
3826
2c3199bc
PB		 3827 super_decl_type =
3828 register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
e04a16fb
AG		 3829 }
3830 else if (TREE_TYPE (decl) != object_type_node)
3831 super_decl_type = object_type_node;
3832 /* We're defining java.lang.Object */
3833 else
3834 super_decl_type = NULL_TREE;
3835
3836 /* Set super info and mark the class a complete */
3837 set_super_info (flags, TREE_TYPE (decl), super_decl_type,
3838 ctxp->interface_number);
3839 ctxp->interface_number = 0;
3840 CLASS_COMPLETE_P (decl) = 1;
3841 add_superinterfaces (decl, interfaces);
3842
c2952b01
APB		 3843 /* If the class is a top level inner class, install an alias. */
3844 if (INNER_CLASS_DECL_P (decl) && CLASS_STATIC (decl))
3845 {
3846 tree alias = parser_qualified_classname (1, raw_name);
3847 IDENTIFIER_GLOBAL_VALUE (alias) = decl;
3848 }
3849
3850 /* Add the private this$<n> field, Replicate final locals still in
3851 scope as private final fields mangled like val$<local_name>.
3852 This doesn't not occur for top level (static) inner classes. */
3853 if (PURE_INNER_CLASS_DECL_P (decl))
3854 add_inner_class_fields (decl, current_function_decl);
3855
7f10c2e2
APB		 3856 /* If doing xref, store the location at which the inherited class
3857 (if any) was seen. */
3858 if (flag_emit_xref && super)
3859 DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
3860
5e942c50
APB		 3861 /* Eventually sets the @deprecated tag flag */
3862 CHECK_DEPRECATED (decl);
3863
165f37bc
APB		 3864 /* Reset the anonymous class counter when declaring non inner classes */
3865 if (!INNER_CLASS_DECL_P (decl))
c2952b01
APB		 3866 anonymous_class_counter = 1;
3867
e04a16fb
AG		 3868 return decl;
3869}
3870
c2952b01
APB		 3871/* End a class declaration: register the statements used to create
3872 $finit$ and <clinit>, pop the current class and resume the prior
3873 parser context if necessary. */
3874
3875static void
3876end_class_declaration (resume)
3877 int resume;
3878{
3879 /* If an error occured, context weren't pushed and won't need to be
3880 popped by a resume. */
3881 int no_error_occured = ctxp->next && GET_CPC () != error_mark_node;
3882
3883 java_parser_context_pop_initialized_field ();
3884 POP_CPC ();
3885 if (resume && no_error_occured)
3886 java_parser_context_resume ();
93220702
APB		 3887
3888 /* We're ending a class declaration, this is a good time to reset
3889 the interface cout. Note that might have been already done in
3890 create_interface, but if at that time an inner class was being
3891 dealt with, the interface count was reset in a context created
3892 for the sake of handling inner classes declaration. */
3893 ctxp->interface_number = 0;
c2952b01
APB		 3894}
3895
3896static void
3897add_inner_class_fields (class_decl, fct_decl)
3898 tree class_decl;
3899 tree fct_decl;
3900{
3901 tree block, marker, f;
3902
3903 f = add_field (TREE_TYPE (class_decl),
3904 build_current_thisn (TREE_TYPE (class_decl)),
3905 build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
3906 ACC_PRIVATE);
3907 FIELD_THISN (f) = 1;
3908
3909 if (!fct_decl)
3910 return;
3911
3912 for (block = GET_CURRENT_BLOCK (fct_decl);
3913 block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
3914 {
3915 tree decl;
3916 for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
3917 {
3918 char *name, *pname;
3919 tree wfl, init, list;
3920
3921 /* Avoid non final arguments. */
3922 if (!LOCAL_FINAL (decl))
3923 continue;
3924
3925 MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
3926 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
3927 wfl = build_wfl_node (get_identifier (name));
3928 init = build_wfl_node (get_identifier (pname));
3929 /* Build an initialization for the field: it will be
3930 initialized by a parameter added to $finit$, bearing a
3931 mangled name of the field itself (param$<n>.) The
3932 parameter is provided to $finit$ by the constructor
3933 invoking it (hence the constructor will also feature a
3934 hidden parameter, set to the value of the outer context
3935 local at the time the inner class is created.)
3936
3937 Note: we take into account all possible locals that can
3938 be accessed by the inner class. It's actually not trivial
3939 to minimize these aliases down to the ones really
3940 used. One way to do that would be to expand all regular
3941 methods first, then $finit$ to get a picture of what's
3942 used. It works with the exception that we would have to
3943 go back on all constructor invoked in regular methods to
3944 have their invokation reworked (to include the right amount
3945 of alias initializer parameters.)
3946
3947 The only real way around, I think, is a first pass to
3948 identify locals really used in the inner class. We leave
3949 the flag FIELD_LOCAL_ALIAS_USED around for that future
3950 use.
3951
3952 On the other hand, it only affect local inner classes,
3953 whose constructors (and $finit$ call) will be featuring
3954 unecessary arguments. It's easy for a developper to keep
3955 this number of parameter down by using the `final'
3956 keyword only when necessary. For the time being, we can
3957 issue a warning on unecessary finals. FIXME */
3958 init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
3959 wfl, init);
3960
3961 /* Register the field. The TREE_LIST holding the part
3962 initialized/initializer will be marked ARG_FINAL_P so
3963 that the created field can be marked
3964 FIELD_LOCAL_ALIAS. */
3965 list = build_tree_list (wfl, init);
3966 ARG_FINAL_P (list) = 1;
3967 register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
3968 }
3969 }
3970
3971 if (!CPC_INITIALIZER_STMT (ctxp))
3972 return;
3973
3974 /* If we ever registered an alias field, insert and marker to
3975 remeber where the list ends. The second part of the list (the one
3976 featuring initialized fields) so it can be later reversed to
3977 enforce 8.5. The marker will be removed during that operation. */
3978 marker = build_tree_list (NULL_TREE, NULL_TREE);
3979 TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
3980 SET_CPC_INITIALIZER_STMT (ctxp, marker);
3981}
3982
e04a16fb
AG		 3983/* Can't use lookup_field () since we don't want to load the class and
3984 can't set the CLASS_LOADED_P flag */
3985
3986static tree
3987find_field (class, name)
3988 tree class;
3989 tree name;
3990{
3991 tree decl;
3992 for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
3993 {
3994 if (DECL_NAME (decl) == name)
3995 return decl;
3996 }
3997 return NULL_TREE;
3998}
3999
4000/* Wrap around lookup_field that doesn't potentially upset the value
4001 of CLASS */
4002
4003static tree
4004lookup_field_wrapper (class, name)
4005 tree class, name;
4006{
4007 tree type = class;
9a7ab4b3 4008 tree decl = NULL_TREE;
c877974e 4009 java_parser_context_save_global ();
f2760b27
APB		 4010
4011 /* Last chance: if we're within the context of an inner class, we
4012 might be trying to access a local variable defined in an outer
4013 context. We try to look for it now. */
9a7ab4b3 4014 if (INNER_CLASS_TYPE_P (class))
f2760b27
APB		 4015 {
4016 char *alias_buffer;
9a7ab4b3 4017 tree new_name;
f2760b27 4018 MANGLE_OUTER_LOCAL_VARIABLE_NAME (alias_buffer, name);
9a7ab4b3
APB		 4019 new_name = get_identifier (alias_buffer);
4020 decl = lookup_field (&type, new_name);
f2760b27
APB		 4021 if (decl && decl != error_mark_node)
4022 FIELD_LOCAL_ALIAS_USED (decl) = 1;
4023 }
9a7ab4b3
APB		 4024 if (!decl || decl == error_mark_node)
4025 {
4026 type = class;
4027 decl = lookup_field (&type, name);
4028 }
f2760b27 4029
c877974e 4030 java_parser_context_restore_global ();
93024893 4031 return decl == error_mark_node ? NULL : decl;
e04a16fb
AG		 4032}
4033
4034/* Find duplicate field within the same class declarations and report
c583dd46
APB		 4035 the error. Returns 1 if a duplicated field was found, 0
4036 otherwise. */
e04a16fb
AG		 4037
4038static int
c583dd46 4039duplicate_declaration_error_p (new_field_name, new_type, cl)
0a2138e2 4040 tree new_field_name, new_type, cl;
e04a16fb
AG		 4041{
4042 /* This might be modified to work with method decl as well */
c2952b01 4043 tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
e04a16fb
AG		 4044 if (decl)
4045 {
c2e3db92 4046 char *t1 = xstrdup (purify_type_name
4a5f66c3
APB		 4047 ((TREE_CODE (new_type) == POINTER_TYPE
4048 && TREE_TYPE (new_type) == NULL_TREE) ?
4049 IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4050 lang_printable_name (new_type, 1)));
c877974e
APB		 4051 /* The type may not have been completed by the time we report
4052 the error */
c2e3db92 4053 char *t2 = xstrdup (purify_type_name
4a5f66c3 4054 ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
c877974e
APB		 4055 && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4056 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4057 lang_printable_name (TREE_TYPE (decl), 1)));
e04a16fb
AG		 4058 parse_error_context
4059 (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4060 t1, IDENTIFIER_POINTER (new_field_name),
4061 t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4062 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4063 free (t1);
4064 free (t2);
c583dd46 4065 return 1;
e04a16fb 4066 }
c583dd46 4067 return 0;
e04a16fb
AG		 4068}
4069
4070/* Field registration routine. If TYPE doesn't exist, field
4071 declarations are linked to the undefined TYPE dependency list, to
4072 be later resolved in java_complete_class () */
4073
4074static void
4075register_fields (flags, type, variable_list)
4076 int flags;
4077 tree type, variable_list;
4078{
c583dd46 4079 tree current, saved_type;
c2952b01 4080 tree class_type = NULL_TREE;
e04a16fb
AG		 4081 int saved_lineno = lineno;
4082 int must_chain = 0;
4083 tree wfl = NULL_TREE;
4084
c2952b01
APB		 4085 if (GET_CPC ())
4086 class_type = TREE_TYPE (GET_CPC ());
4087
4088 if (!class_type || class_type == error_mark_node)
4089 return;
4090
e04a16fb
AG		 4091 /* If we're adding fields to interfaces, those fields are public,
4092 static, final */
4093 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4094 {
4095 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
2884c41e 4096 flags, ACC_PUBLIC, "interface field(s)");
e04a16fb 4097 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
2884c41e 4098 flags, ACC_STATIC, "interface field(s)");
e04a16fb 4099 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
2884c41e 4100 flags, ACC_FINAL, "interface field(s)");
e04a16fb
AG		 4101 check_modifiers ("Illegal interface member modifier `%s'", flags,
4102 INTERFACE_FIELD_MODIFIERS);
4103 flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4104 }
4105
c583dd46
APB		 4106 /* Obtain a suitable type for resolution, if necessary */
4107 SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4108
4109 /* If TYPE is fully resolved and we don't have a reference, make one */
1886c9d8 4110 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
e04a16fb 4111
c583dd46
APB		 4112 for (current = variable_list, saved_type = type; current;
4113 current = TREE_CHAIN (current), type = saved_type)
e04a16fb 4114 {
c877974e 4115 tree real_type;
c583dd46 4116 tree field_decl;
e04a16fb
AG		 4117 tree cl = TREE_PURPOSE (current);
4118 tree init = TREE_VALUE (current);
4119 tree current_name = EXPR_WFL_NODE (cl);
4120
cf1748bf 4121 /* Can't declare non-final static fields in inner classes */
c2952b01 4122 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
cf1748bf 4123 && !(flags & ACC_FINAL))
c2952b01 4124 parse_error_context
cf1748bf 4125 (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
c2952b01
APB		 4126 IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4127 lang_printable_name (class_type, 0));
4128
c583dd46
APB		 4129 /* Process NAME, as it may specify extra dimension(s) for it */
4130 type = build_array_from_name (type, wfl, current_name, &current_name);
4131
c583dd46
APB		 4132 /* Type adjustment. We may have just readjusted TYPE because
4133 the variable specified more dimensions. Make sure we have
22eed1e6
APB		 4134 a reference if we can and don't have one already. Also
4135 change the name if we have an init. */
4136 if (type != saved_type)
4137 {
1886c9d8 4138 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
22eed1e6
APB		 4139 if (init)
4140 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4141 }
e04a16fb 4142
c877974e
APB		 4143 real_type = GET_REAL_TYPE (type);
4144 /* Check for redeclarations */
4145 if (duplicate_declaration_error_p (current_name, real_type, cl))
4146 continue;
4147
c583dd46 4148 /* Set lineno to the line the field was found and create a
5e942c50 4149 declaration for it. Eventually sets the @deprecated tag flag. */
f099f336
APB		 4150 if (flag_emit_xref)
4151 lineno = EXPR_WFL_LINECOL (cl);
4152 else
4153 lineno = EXPR_WFL_LINENO (cl);
c877974e 4154 field_decl = add_field (class_type, current_name, real_type, flags);
5e942c50 4155 CHECK_DEPRECATED (field_decl);
c2952b01
APB		 4156
4157 /* If the couple initializer/initialized is marked ARG_FINAL_P, we
4158 mark the created field FIELD_LOCAL_ALIAS, so that we can
4159 hide parameters to this inner class $finit$ and constructors. */
4160 if (ARG_FINAL_P (current))
4161 FIELD_LOCAL_ALIAS (field_decl) = 1;
c583dd46
APB		 4162
4163 /* Check if we must chain. */
4164 if (must_chain)
4165 register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
e04a16fb 4166
c583dd46
APB		 4167 /* If we have an initialization value tied to the field */
4168 if (init)
4169 {
4170 /* The field is declared static */
e04a16fb 4171 if (flags & ACC_STATIC)
e04a16fb 4172 {
7525cc04
APB		 4173 /* We include the field and its initialization part into
4174 a list used to generate <clinit>. After <clinit> is
ba179f9f
APB		 4175 walked, field initializations will be processed and
4176 fields initialized with known constants will be taken
4177 out of <clinit> and have their DECL_INITIAL set
7525cc04 4178 appropriately. */
c2952b01
APB		 4179 TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4180 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
7f10c2e2
APB		 4181 if (TREE_OPERAND (init, 1)
4182 && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
5bba4807 4183 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
e04a16fb 4184 }
5e942c50
APB		 4185 /* A non-static field declared with an immediate initialization is
4186 to be initialized in <init>, if any. This field is remembered
4187 to be processed at the time of the generation of <init>. */
c583dd46
APB		 4188 else
4189 {
c2952b01
APB		 4190 TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4191 SET_CPC_INITIALIZER_STMT (ctxp, init);
c583dd46 4192 }
5b09b33e 4193 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
8576f094 4194 DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
e04a16fb
AG		 4195 }
4196 }
4197 lineno = saved_lineno;
4198}
4199
c2952b01
APB		 4200/* Generate $finit$, using the list of initialized fields to populate
4201 its body. $finit$'s parameter(s) list is adjusted to include the
4202 one(s) used to initialized the field(s) caching outer context
4203 local(s). */
22eed1e6 4204
c2952b01
APB		 4205static tree
4206generate_finit (class_type)
4207 tree class_type;
22eed1e6 4208{
c2952b01
APB		 4209 int count = 0;
4210 tree list = TYPE_FINIT_STMT_LIST (class_type);
4211 tree mdecl, current, parms;
4212
4213 parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4214 class_type, NULL_TREE,
4215 &count);
4216 CRAFTED_PARAM_LIST_FIXUP (parms);
4217 mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4218 finit_identifier_node, parms);
4219 fix_method_argument_names (parms, mdecl);
4220 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4221 mdecl, NULL_TREE);
4222 DECL_FUNCTION_NAP (mdecl) = count;
22eed1e6
APB		 4223 start_artificial_method_body (mdecl);
4224
c2952b01 4225 for (current = list; current; current = TREE_CHAIN (current))
22eed1e6
APB		 4226 java_method_add_stmt (mdecl,
4227 build_debugable_stmt (EXPR_WFL_LINECOL (current),
4228 current));
22eed1e6 4229 end_artificial_method_body (mdecl);
c2952b01 4230 return mdecl;
22eed1e6
APB		 4231}
4232
e04a16fb 4233static void
c2952b01
APB		 4234add_instance_initializer (mdecl)
4235 tree mdecl;
e04a16fb 4236{
c2952b01
APB		 4237 tree current;
4238 tree stmt_list = TYPE_II_STMT_LIST (DECL_CONTEXT (mdecl));
4239 tree compound = NULL_TREE;
e04a16fb 4240
c2952b01 4241 if (stmt_list)
e04a16fb 4242 {
c2952b01
APB		 4243 for (current = stmt_list; current; current = TREE_CHAIN (current))
4244 compound = add_stmt_to_compound (compound, NULL_TREE, current);
e04a16fb 4245
c2952b01
APB		 4246 java_method_add_stmt (mdecl, build1 (INSTANCE_INITIALIZERS_EXPR,
4247 NULL_TREE, compound));
4248 }
e04a16fb
AG		 4249}
4250
4251/* Shared accros method_declarator and method_header to remember the
4252 patch stage that was reached during the declaration of the method.
4253 A method DECL is built differently is there is no patch
4254 (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4255 pending on the currently defined method. */
4256
4257static int patch_stage;
4258
4259/* Check the method declaration and add the method to its current
4260 class. If the argument list is known to contain incomplete types,
4261 the method is partially added and the registration will be resume
22eed1e6
APB		 4262 once the method arguments resolved. If TYPE is NULL, we're dealing
4263 with a constructor. */
e04a16fb
AG		 4264
4265static tree
4266method_header (flags, type, mdecl, throws)
4267 int flags;
4268 tree type, mdecl, throws;
4269{
4270 tree meth = TREE_VALUE (mdecl);
4271 tree id = TREE_PURPOSE (mdecl);
1886c9d8 4272 tree type_wfl = NULL_TREE;
79d13333 4273 tree meth_name = NULL_TREE;
c2952b01 4274 tree current, orig_arg, this_class = NULL;
e04a16fb 4275 int saved_lineno;
1886c9d8 4276 int constructor_ok = 0, must_chain;
c2952b01 4277 int count;
e04a16fb
AG		 4278
4279 check_modifiers_consistency (flags);
79d13333 4280
c2952b01
APB		 4281 if (GET_CPC ())
4282 this_class = TREE_TYPE (GET_CPC ());
4283
4284 if (!this_class || this_class == error_mark_node)
79d13333 4285 return NULL_TREE;
e04a16fb
AG		 4286
4287 /* There are some forbidden modifiers for an abstract method and its
4288 class must be abstract as well. */
22eed1e6 4289 if (type && (flags & ACC_ABSTRACT))
e04a16fb
AG		 4290 {
4291 ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4292 ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4293 ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4294 ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4295 ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED,id, "Synchronized");
2aa11e97
APB		 4296 if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4297 && !CLASS_INTERFACE (TYPE_NAME (this_class)))
e04a16fb 4298 parse_error_context
781b0558 4299 (id, "Class `%s' must be declared abstract to define abstract method `%s'",
e04a16fb
AG		 4300 IDENTIFIER_POINTER (DECL_NAME (ctxp->current_parsed_class)),
4301 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4302 }
c2952b01 4303
22eed1e6
APB		 4304 /* Things to be checked when declaring a constructor */
4305 if (!type)
4306 {
4307 int ec = java_error_count;
4308 /* 8.6: Constructor declarations: we might be trying to define a
4309 method without specifying a return type. */
c2952b01 4310 if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
22eed1e6
APB		 4311 parse_error_context
4312 (id, "Invalid method declaration, return type required");
4313 /* 8.6.3: Constructor modifiers */
4314 else
4315 {
4316 JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4317 JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4318 JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4319 JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4320 JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4321 }
4322 /* If we found error here, we don't consider it's OK to tread
4323 the method definition as a constructor, for the rest of this
4324 function */
4325 if (ec == java_error_count)
4326 constructor_ok = 1;
4327 }
e04a16fb
AG		 4328
4329 /* Method declared within the scope of an interface are implicitly
4330 abstract and public. Conflicts with other erroneously provided
c0d87ff6 4331 modifiers are checked right after. */
e04a16fb
AG		 4332
4333 if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4334 {
4335 /* If FLAGS isn't set because of a modifier, turn the
4336 corresponding modifier WFL to NULL so we issue a warning on
4337 the obsolete use of the modifier */
4338 if (!(flags & ACC_PUBLIC))
4339 MODIFIER_WFL (PUBLIC_TK) = NULL;
4340 if (!(flags & ACC_ABSTRACT))
4341 MODIFIER_WFL (ABSTRACT_TK) = NULL;
4342 flags |= ACC_PUBLIC;
4343 flags |= ACC_ABSTRACT;
4344 }
4345
c2952b01
APB		 4346 /* Inner class can't declare static methods */
4347 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4348 {
4349 parse_error_context
4350 (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4351 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4352 lang_printable_name (this_class, 0));
4353 }
4354
e04a16fb
AG		 4355 /* Modifiers context reset moved up, so abstract method declaration
4356 modifiers can be later checked. */
4357
22eed1e6
APB		 4358 /* Set constructor returned type to void and method name to <init>,
4359 unless we found an error identifier the constructor (in which
4360 case we retain the original name) */
4361 if (!type)
4362 {
4363 type = void_type_node;
4364 if (constructor_ok)
4365 meth_name = init_identifier_node;
4366 }
4367 else
4368 meth_name = EXPR_WFL_NODE (id);
e04a16fb 4369
1886c9d8
APB		 4370 /* Do the returned type resolution and registration if necessary */
4371 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4372
4a5f66c3
APB		 4373 if (meth_name)
4374 type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
1886c9d8
APB		 4375 EXPR_WFL_NODE (id) = meth_name;
4376 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4377
4378 if (must_chain)
e04a16fb 4379 {
1886c9d8
APB		 4380 patch_stage = JDEP_METHOD_RETURN;
4381 register_incomplete_type (patch_stage, type_wfl, id, type);
4382 TREE_TYPE (meth) = GET_REAL_TYPE (type);
e04a16fb
AG		 4383 }
4384 else
1886c9d8 4385 TREE_TYPE (meth) = type;
e04a16fb
AG		 4386
4387 saved_lineno = lineno;
4388 /* When defining an abstract or interface method, the curly
4389 bracket at level 1 doesn't exist because there is no function
4390 body */
4391 lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4392 EXPR_WFL_LINENO (id));
4393
5e942c50
APB		 4394 /* Remember the original argument list */
4395 orig_arg = TYPE_ARG_TYPES (meth);
4396
e04a16fb
AG		 4397 if (patch_stage) /* includes ret type and/or all args */
4398 {
4399 jdep *jdep;
4400 meth = add_method_1 (this_class, flags, meth_name, meth);
4401 /* Patch for the return type */
4402 if (patch_stage == JDEP_METHOD_RETURN)
4403 {
4404 jdep = CLASSD_LAST (ctxp->classd_list);
4405 JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4406 }
4407 /* This is the stop JDEP. METH allows the function's signature
4408 to be computed. */
4409 register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4410 }
4411 else
5e942c50
APB		 4412 meth = add_method (this_class, flags, meth_name,
4413 build_java_signature (meth));
4414
c2952b01
APB		 4415 /* Remember final parameters */
4416 MARK_FINAL_PARMS (meth, orig_arg);
4417
5e942c50
APB		 4418 /* Fix the method argument list so we have the argument name
4419 information */
4420 fix_method_argument_names (orig_arg, meth);
4421
4422 /* Register the parameter number and re-install the current line
4423 number */
e04a16fb
AG		 4424 DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4425 lineno = saved_lineno;
b9f7e36c
APB		 4426
4427 /* Register exception specified by the `throws' keyword for
4428 resolution and set the method decl appropriate field to the list.
4429 Note: the grammar ensures that what we get here are class
4430 types. */
4431 if (throws)
4432 {
4433 throws = nreverse (throws);
4434 for (current = throws; current; current = TREE_CHAIN (current))
4435 {
4436 register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4437 NULL_TREE, NULL_TREE);
4438 JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4439 &TREE_VALUE (current);
4440 }
4441 DECL_FUNCTION_THROWS (meth) = throws;
4442 }
4443
e04a16fb
AG		 4444 /* We set the DECL_NAME to ID so we can track the location where
4445 the function was declared. This allow us to report
4446 redefinition error accurately. When method are verified,
4447 DECL_NAME is reinstalled properly (using the content of the
4448 WFL node ID) (see check_method_redefinition). We don't do that
22eed1e6
APB		 4449 when Object is being defined. Constructor <init> names will be
4450 reinstalled the same way. */
c2952b01 4451 if (TREE_TYPE (GET_CPC ()) != object_type_node)
e04a16fb 4452 DECL_NAME (meth) = id;
22eed1e6
APB		 4453
4454 /* Set the flag if we correctly processed a constructor */
4455 if (constructor_ok)
c2952b01
APB		 4456 {
4457 DECL_CONSTRUCTOR_P (meth) = 1;
4458 /* Compute and store the number of artificial parameters declared
4459 for this constructor */
4460 for (count = 0, current = TYPE_FIELDS (this_class); current;
4461 current = TREE_CHAIN (current))
4462 if (FIELD_LOCAL_ALIAS (current))
4463 count++;
4464 DECL_FUNCTION_NAP (meth) = count;
4465 }
22eed1e6 4466
5e942c50
APB		 4467 /* Eventually set the @deprecated tag flag */
4468 CHECK_DEPRECATED (meth);
4469
7f10c2e2
APB		 4470 /* If doing xref, store column and line number information instead
4471 of the line number only. */
4472 if (flag_emit_xref)
4473 DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4474
e04a16fb
AG		 4475 return meth;
4476}
4477
5e942c50
APB		 4478static void
4479fix_method_argument_names (orig_arg, meth)
4480 tree orig_arg, meth;
4481{
4482 tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4483 if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4484 {
4485 TREE_PURPOSE (arg) = this_identifier_node;
4486 arg = TREE_CHAIN (arg);
4487 }
de4c7b02 4488 while (orig_arg != end_params_node)
5e942c50
APB		 4489 {
4490 TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4491 orig_arg = TREE_CHAIN (orig_arg);
4492 arg = TREE_CHAIN (arg);
4493 }
4494}
4495
22eed1e6
APB		 4496/* Complete the method declaration with METHOD_BODY. */
4497
4498static void
b635eb2f 4499finish_method_declaration (method_body)
22eed1e6
APB		 4500 tree method_body;
4501{
79d13333
APB		 4502 int flags;
4503
4504 if (!current_function_decl)
4505 return;
4506
4507 flags = get_access_flags_from_decl (current_function_decl);
5256aa37
APB		 4508
4509 /* 8.4.5 Method Body */
4510 if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4511 {
4512 tree wfl = DECL_NAME (current_function_decl);
4513 parse_error_context (wfl,
4514 "%s method `%s' can't have a body defined",
4515 (METHOD_NATIVE (current_function_decl) ?
4516 "Native" : "Abstract"),
4517 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
4518 method_body = NULL_TREE;
4519 }
4520 else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4521 {
4522 tree wfl = DECL_NAME (current_function_decl);
781b0558
KG		 4523 parse_error_context
4524 (wfl,
4525 "Non native and non abstract method `%s' must have a body defined",
4526 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
5256aa37
APB		 4527 method_body = NULL_TREE;
4528 }
4529
2c56429a
APB		 4530 if (flag_emit_class_files && method_body
4531 && TREE_CODE (method_body) == NOP_EXPR
4532 && TREE_TYPE (current_function_decl)
4533 && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4534 method_body = build1 (RETURN_EXPR, void_type_node, NULL);
e803d3b2 4535
22eed1e6
APB		 4536 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4537 maybe_absorb_scoping_blocks ();
4538 /* Exit function's body */
4539 exit_block ();
4540 /* Merge last line of the function with first line, directly in the
4541 function decl. It will be used to emit correct debug info. */
7f10c2e2
APB		 4542 if (!flag_emit_xref)
4543 DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1);
c2952b01
APB		 4544
4545 /* Since function's argument's list are shared, reset the
4546 ARG_FINAL_P parameter that might have been set on some of this
4547 function parameters. */
4548 UNMARK_FINAL_PARMS (current_function_decl);
4549
f099f336
APB		 4550 /* So we don't have an irrelevant function declaration context for
4551 the next static block we'll see. */
4552 current_function_decl = NULL_TREE;
22eed1e6
APB		 4553}
4554
4555/* Build a an error message for constructor circularity errors. */
4556
4557static char *
4558constructor_circularity_msg (from, to)
4559 tree from, to;
4560{
4561 static char string [4096];
c2e3db92 4562 char *t = xstrdup (lang_printable_name (from, 0));
22eed1e6
APB		 4563 sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4564 free (t);
4565 return string;
4566}
4567
4568/* Verify a circular call to METH. Return 1 if an error is found, 0
4569 otherwise. */
4570
4571static int
4572verify_constructor_circularity (meth, current)
4573 tree meth, current;
4574{
4575 static tree list = NULL_TREE;
4576 tree c;
4577 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4578 {
4579 if (TREE_VALUE (c) == meth)
4580 {
4581 char *t;
4582 if (list)
4583 {
4584 tree liste;
4585 list = nreverse (list);
4586 for (liste = list; liste; liste = TREE_CHAIN (liste))
4587 {
4588 parse_error_context
c63b98cd 4589 (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
22eed1e6
APB		 4590 constructor_circularity_msg
4591 (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4592 java_error_count--;
4593 }
4594 }
c2e3db92 4595 t = xstrdup (lang_printable_name (meth, 0));
22eed1e6
APB		 4596 parse_error_context (TREE_PURPOSE (c),
4597 "%s: recursive invocation of constructor `%s'",
4598 constructor_circularity_msg (current, meth), t);
4599 free (t);
4600 list = NULL_TREE;
4601 return 1;
4602 }
4603 }
4604 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4605 {
4606 list = tree_cons (c, current, list);
4607 if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4608 return 1;
4609 list = TREE_CHAIN (list);
4610 }
4611 return 0;
4612}
4613
e04a16fb
AG		 4614/* Check modifiers that can be declared but exclusively */
4615
4616static void
4617check_modifiers_consistency (flags)
4618 int flags;
4619{
4620 int acc_count = 0;
4621 tree cl = NULL_TREE;
4622
e0fc4118
TT		 4623 THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4624 THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4625 THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
e04a16fb
AG		 4626 if (acc_count > 1)
4627 parse_error_context
e0fc4118
TT		 4628 (cl, "Inconsistent member declaration. At most one of `public', `private', or `protected' may be specified");
4629
4630 acc_count = 0;
4631 cl = NULL_TREE;
14d075d8
TT		 4632 THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4633 THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
e0fc4118
TT		 4634 if (acc_count > 1)
4635 parse_error_context (cl,
4636 "Inconsistent member declaration. At most one of `final' or `volatile' may be specified");
e04a16fb
AG		 4637}
4638
4639/* Check the methode header METH for abstract specifics features */
4640
4641static void
4642check_abstract_method_header (meth)
4643 tree meth;
4644{
4645 int flags = get_access_flags_from_decl (meth);
4646 /* DECL_NAME might still be a WFL node */
c877974e 4647 tree name = GET_METHOD_NAME (meth);
e04a16fb 4648
2884c41e
KG		 4649 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4650 ACC_ABSTRACT, "abstract method",
4651 IDENTIFIER_POINTER (name));
4652 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4653 ACC_PUBLIC, "abstract method",
4654 IDENTIFIER_POINTER (name));
e04a16fb
AG		 4655
4656 check_modifiers ("Illegal modifier `%s' for interface method",
4657 flags, INTERFACE_METHOD_MODIFIERS);
4658}
4659
4660/* Create a FUNCTION_TYPE node and start augmenting it with the
4661 declared function arguments. Arguments type that can't be resolved
4662 are left as they are, but the returned node is marked as containing
4663 incomplete types. */
4664
4665static tree
4666method_declarator (id, list)
4667 tree id, list;
4668{
4669 tree arg_types = NULL_TREE, current, node;
4670 tree meth = make_node (FUNCTION_TYPE);
4671 jdep *jdep;
e04a16fb
AG		 4672
4673 patch_stage = JDEP_NO_PATCH;
c2952b01
APB		 4674
4675 /* If we're dealing with an inner class constructor, we hide the
4676 this$<n> decl in the name field of its parameter declaration. We
4677 also might have to hide the outer context local alias
4678 initializers. Not done when the class is a toplevel class. */
4679 if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4680 && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4681 {
4682 tree aliases_list, type, thisn;
4683 /* First the aliases, linked to the regular parameters */
4684 aliases_list =
4685 build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4686 TREE_TYPE (GET_CPC ()),
4687 NULL_TREE, NULL);
4688 list = chainon (nreverse (aliases_list), list);
4689
4690 /* Then this$<n> */
4691 type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
9a7ab4b3 4692 thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
c2952b01
APB		 4693 list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4694 list);
4695 }
e04a16fb
AG		 4696
4697 for (current = list; current; current = TREE_CHAIN (current))
4698 {
c583dd46 4699 int must_chain = 0;
e04a16fb
AG		 4700 tree wfl_name = TREE_PURPOSE (current);
4701 tree type = TREE_VALUE (current);
4702 tree name = EXPR_WFL_NODE (wfl_name);
c583dd46
APB		 4703 tree already, arg_node;
4704 tree type_wfl = NULL_TREE;
23a79c61 4705 tree real_type;
c583dd46
APB		 4706
4707 /* Obtain a suitable type for resolution, if necessary */
4708 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4709
4710 /* Process NAME, as it may specify extra dimension(s) for it */
4711 type = build_array_from_name (type, type_wfl, name, &name);
4712 EXPR_WFL_NODE (wfl_name) = name;
e04a16fb 4713
23a79c61
APB		 4714 real_type = GET_REAL_TYPE (type);
4715 if (TREE_CODE (real_type) == RECORD_TYPE)
4716 {
4717 real_type = promote_type (real_type);
4718 if (TREE_CODE (type) == TREE_LIST)
4719 TREE_PURPOSE (type) = real_type;
4720 }
5e942c50 4721
e04a16fb
AG		 4722 /* Check redefinition */
4723 for (already = arg_types; already; already = TREE_CHAIN (already))
4724 if (TREE_PURPOSE (already) == name)
4725 {
781b0558
KG		 4726 parse_error_context
4727 (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4728 IDENTIFIER_POINTER (name),
e04a16fb
AG		 4729 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4730 break;
4731 }
4732
4733 /* If we've an incomplete argument type, we know there is a location
4734 to patch when the type get resolved, later. */
4735 jdep = NULL;
c583dd46 4736 if (must_chain)
e04a16fb 4737 {
c583dd46
APB		 4738 patch_stage = JDEP_METHOD;
4739 type = register_incomplete_type (patch_stage,
4740 type_wfl, wfl_name, type);
4741 jdep = CLASSD_LAST (ctxp->classd_list);
4742 JDEP_MISC (jdep) = id;
e04a16fb 4743 }
c583dd46 4744
c2952b01 4745 /* The argument node: a name and a (possibly) incomplete type. */
23a79c61 4746 arg_node = build_tree_list (name, real_type);
c2952b01
APB		 4747 /* Remeber arguments declared final. */
4748 ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4749
e04a16fb
AG		 4750 if (jdep)
4751 JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4752 TREE_CHAIN (arg_node) = arg_types;
4753 arg_types = arg_node;
4754 }
de4c7b02 4755 TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
e04a16fb
AG		 4756 node = build_tree_list (id, meth);
4757 return node;
4758}
4759
4760static int
4761unresolved_type_p (wfl, returned)
4762 tree wfl;
4763 tree *returned;
4764
4765{
4766 if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
4767 {
e04a16fb 4768 if (returned)
165f37bc
APB		 4769 {
4770 tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
4771 if (decl && current_class && (decl == TYPE_NAME (current_class)))
4772 *returned = TREE_TYPE (decl);
4773 else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
4774 *returned = TREE_TYPE (GET_CPC ());
4775 else
4776 *returned = NULL_TREE;
4777 }
e04a16fb
AG		 4778 return 1;
4779 }
4780 if (returned)
4781 *returned = wfl;
4782 return 0;
4783}
4784
4785/* From NAME, build a qualified identifier node using the
4786 qualification from the current package definition. */
4787
4788static tree
c2952b01
APB		 4789parser_qualified_classname (is_static, name)
4790 int is_static;
e04a16fb
AG		 4791 tree name;
4792{
c2952b01
APB		 4793 tree nested_class_name;
4794
4795 if (!is_static
4796 && (nested_class_name = maybe_make_nested_class_name (name)))
4797 return nested_class_name;
4798
e04a16fb 4799 if (ctxp->package)
c2952b01 4800 return merge_qualified_name (ctxp->package, name);
e04a16fb 4801 else
c2952b01 4802 return name;
e04a16fb
AG		 4803}
4804
4805/* Called once the type a interface extends is resolved. Returns 0 if
4806 everything is OK. */
4807
4808static int
4809parser_check_super_interface (super_decl, this_decl, this_wfl)
4810 tree super_decl, this_decl, this_wfl;
4811{
4812 tree super_type = TREE_TYPE (super_decl);
4813
4814 /* Has to be an interface */
c2952b01 4815 if (!CLASS_INTERFACE (super_decl))
e04a16fb
AG		 4816 {
4817 parse_error_context
4818 (this_wfl, "Can't use %s `%s' to implement/extend %s `%s'",
4819 (TYPE_ARRAY_P (super_type) ? "array" : "class"),
4820 IDENTIFIER_POINTER (DECL_NAME (super_decl)),
4821 (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
4822 "interface" : "class"),
4823 IDENTIFIER_POINTER (DECL_NAME (this_decl)));
4824 return 1;
4825 }
4826
4827 /* Check scope: same package OK, other package: OK if public */
4828 if (check_pkg_class_access (DECL_NAME (super_decl), lookup_cl (this_decl)))
4829 return 1;
4830
4831 SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
4832 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4833 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
4834 return 0;
4835}
4836
4837/* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
4838 0 if everthing is OK. */
4839
4840static int
4841parser_check_super (super_decl, this_decl, wfl)
4842 tree super_decl, this_decl, wfl;
4843{
e04a16fb
AG		 4844 tree super_type = TREE_TYPE (super_decl);
4845
4846 /* SUPER should be a CLASS (neither an array nor an interface) */
4847 if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
4848 {
4849 parse_error_context
4850 (wfl, "Class `%s' can't subclass %s `%s'",
4851 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4852 (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
4853 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
4854 return 1;
4855 }
4856
4857 if (CLASS_FINAL (TYPE_NAME (super_type)))
4858 {
4859 parse_error_context (wfl, "Can't subclass final classes: %s",
4860 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
4861 return 1;
4862 }
4863
4864 /* Check scope: same package OK, other package: OK if public */
4865 if (check_pkg_class_access (DECL_NAME (super_decl), wfl))
4866 return 1;
4867
4868 SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
4869 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4870 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
4871 return 0;
4872}
4873
4874/* Create a new dependency list and link it (in a LIFO manner) to the
4875 CTXP list of type dependency list. */
4876
4877static void
4878create_jdep_list (ctxp)
4879 struct parser_ctxt *ctxp;
4880{
23a79c61 4881 jdeplist *new = (jdeplist *)xmalloc (sizeof (jdeplist));
e04a16fb
AG		 4882 new->first = new->last = NULL;
4883 new->next = ctxp->classd_list;
4884 ctxp->classd_list = new;
4885}
4886
4887static jdeplist *
4888reverse_jdep_list (ctxp)
4889 struct parser_ctxt *ctxp;
4890{
4891 register jdeplist *prev = NULL, *current, *next;
4892 for (current = ctxp->classd_list; current; current = next)
4893 {
4894 next = current->next;
4895 current->next = prev;
4896 prev = current;
4897 }
4898 return prev;
4899}
4900
23a79c61
APB		 4901/* Create a fake pointer based on the ID stored in
4902 TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
4903 registered again. */
e04a16fb
AG		 4904
4905static tree
23a79c61
APB		 4906obtain_incomplete_type (type_name)
4907 tree type_name;
e04a16fb 4908{
23a79c61
APB		 4909 tree ptr, name;
4910
4911 if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
4912 name = EXPR_WFL_NODE (type_name);
4913 else if (INCOMPLETE_TYPE_P (type_name))
4914 name = TYPE_NAME (type_name);
4915 else
4916 fatal ("invalid type name - obtain_incomplete_type");
e04a16fb
AG		 4917
4918 for (ptr = ctxp->incomplete_class; ptr; ptr = TREE_CHAIN (ptr))
78d21f92 4919 if (TYPE_NAME (ptr) == name)
e04a16fb
AG		 4920 break;
4921
4922 if (!ptr)
4923 {
e04a16fb 4924 push_obstacks (&permanent_obstack, &permanent_obstack);
78d21f92
PB		 4925 BUILD_PTR_FROM_NAME (ptr, name);
4926 layout_type (ptr);
e04a16fb
AG		 4927 pop_obstacks ();
4928 TREE_CHAIN (ptr) = ctxp->incomplete_class;
4929 ctxp->incomplete_class = ptr;
4930 }
4931
4932 return ptr;
4933}
4934
4935/* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
4936 non NULL instead of computing a new fake type based on WFL. The new
4937 dependency is inserted in the current type dependency list, in FIFO
4938 manner. */
4939
4940static tree
4941register_incomplete_type (kind, wfl, decl, ptr)
4942 int kind;
4943 tree wfl, decl, ptr;
4944{
23a79c61 4945 jdep *new = (jdep *)xmalloc (sizeof (jdep));
e04a16fb 4946
e04a16fb
AG		 4947 if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
4948 ptr = obtain_incomplete_type (wfl);
4949
4950 JDEP_KIND (new) = kind;
4951 JDEP_DECL (new) = decl;
4952 JDEP_SOLV (new) = ptr;
4953 JDEP_WFL (new) = wfl;
4954 JDEP_CHAIN (new) = NULL;
4955 JDEP_MISC (new) = NULL_TREE;
e803d3b2
APB		 4956 /* For some dependencies, set the enclosing class of the current
4957 class to be the enclosing context */
4958 if ((kind == JDEP_SUPER || kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS)
165f37bc
APB		 4959 && GET_ENCLOSING_CPC ())
4960 JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
4961 else
324ed8fd 4962 JDEP_ENCLOSING (new) = GET_CPC ();
e04a16fb
AG		 4963 JDEP_GET_PATCH (new) = (tree *)NULL;
4964
4965 JDEP_INSERT (ctxp->classd_list, new);
4966
4967 return ptr;
4968}
4969
4970void
4971java_check_circular_reference ()
4972{
4973 tree current;
4974 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
4975 {
4976 tree type = TREE_TYPE (current);
e920ebc9 4977 if (CLASS_INTERFACE (current))
e04a16fb
AG		 4978 {
4979 /* Check all interfaces this class extends */
4980 tree basetype_vec = TYPE_BINFO_BASETYPES (type);
4981 int n, i;
4982
4983 if (!basetype_vec)
4984 return;
4985 n = TREE_VEC_LENGTH (basetype_vec);
4986 for (i = 0; i < n; i++)
4987 {
4988 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
4989 if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
4990 && interface_of_p (type, BINFO_TYPE (vec_elt)))
4991 parse_error_context (lookup_cl (current),
4992 "Cyclic interface inheritance");
4993 }
4994 }
4995 else
4996 if (inherits_from_p (CLASSTYPE_SUPER (type), type))
4997 parse_error_context (lookup_cl (current),
c2952b01
APB		 4998 "Cyclic class inheritance%s",
4999 (cyclic_inheritance_report ?
5000 cyclic_inheritance_report : ""));
5001 }
5002}
5003
5004/* Augment the parameter list PARM with parameters crafted to
5005 initialize outer context locals aliases. Through ARTIFICIAL, a
5006 count is kept of the number of crafted parameters. MODE governs
5007 what eventually gets created: something suitable for a function
5008 creation or a function invocation, either the constructor or
5009 $finit$. */
5010
5011static tree
5012build_alias_initializer_parameter_list (mode, class_type, parm, artificial)
5013 int mode;
5014 tree class_type, parm;
5015 int *artificial;
5016{
5017 tree field;
5018 for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5019 if (FIELD_LOCAL_ALIAS (field))
5020 {
5021 char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5022 tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5023
5024 switch (mode)
5025 {
5026 case AIPL_FUNCTION_DECLARATION:
5027 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
5028 purpose = build_wfl_node (get_identifier (buffer));
5029 if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5030 value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5031 else
5032 value = TREE_TYPE (field);
5033 break;
5034
5035 case AIPL_FUNCTION_CREATION:
5036 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
5037 purpose = get_identifier (buffer);
5038 value = TREE_TYPE (field);
5039 break;
5040
5041 case AIPL_FUNCTION_FINIT_INVOCATION:
5042 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
5043 /* Now, this is wrong. purpose should always be the NAME
5044 of something and value its matching value (decl, type,
5045 etc...) FIXME -- but there is a lot to fix. */
5046
5047 /* When invoked for this kind of operation, we already
5048 know whether a field is used or not. */
5049 purpose = TREE_TYPE (field);
5050 value = build_wfl_node (get_identifier (buffer));
5051 break;
5052
5053 case AIPL_FUNCTION_CTOR_INVOCATION:
5054 /* There are two case: the constructor invokation happends
5055 outside the local inner, in which case, locales from the outer
5056 context are directly used.
5057
5058 Otherwise, we fold to using the alias directly. */
5059 if (class_type == current_class)
5060 value = field;
5061 else
5062 {
5063 name = get_identifier (&buffer[4]);
5064 value = IDENTIFIER_LOCAL_VALUE (name);
5065 }
5066 break;
5067 }
5068 parm = tree_cons (purpose, value, parm);
5069 if (artificial)
5070 *artificial +=1;
5071 }
5072 return parm;
5073}
5074
5075/* Craft a constructor for CLASS_DECL -- what we should do when none
5076 where found. ARGS is non NULL when a special signature must be
5077 enforced. This is the case for anonymous classes. */
5078
5079static void
5080craft_constructor (class_decl, args)
5081 tree class_decl, args;
5082{
5083 tree class_type = TREE_TYPE (class_decl);
5084 tree parm = NULL_TREE;
5085 int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5086 ACC_PUBLIC : 0);
5087 int i = 0, artificial = 0;
5088 tree decl, ctor_name;
5089 char buffer [80];
5090
5091 push_obstacks (&permanent_obstack, &permanent_obstack);
5092
5093 /* The constructor name is <init> unless we're dealing with an
5094 anonymous class, in which case the name will be fixed after having
5095 be expanded. */
5096 if (ANONYMOUS_CLASS_P (class_type))
5097 ctor_name = DECL_NAME (class_decl);
5098 else
5099 ctor_name = init_identifier_node;
5100
5101 /* If we're dealing with an inner class constructor, we hide the
5102 this$<n> decl in the name field of its parameter declaration. */
5103 if (PURE_INNER_CLASS_TYPE_P (class_type))
5104 {
5105 tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5106 parm = tree_cons (build_current_thisn (class_type),
5107 build_pointer_type (type), parm);
5108
5109 /* Some more arguments to be hidden here. The values of the local
5110 variables of the outer context that the inner class needs to see. */
5111 parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5112 class_type, parm,
5113 &artificial);
5114 }
5115
5116 /* Then if there are any args to be enforced, enforce them now */
5117 for (; args && args != end_params_node; args = TREE_CHAIN (args))
5118 {
5119 sprintf (buffer, "parm%d", i++);
5120 parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
e04a16fb 5121 }
c2952b01
APB		 5122
5123 CRAFTED_PARAM_LIST_FIXUP (parm);
5124 decl = create_artificial_method (class_type, flags, void_type_node,
5125 ctor_name, parm);
5126 fix_method_argument_names (parm, decl);
5127 /* Now, mark the artificial parameters. */
5128 DECL_FUNCTION_NAP (decl) = artificial;
5129
5130 pop_obstacks ();
5131 DECL_CONSTRUCTOR_P (decl) = 1;
e04a16fb
AG		 5132}
5133
c2952b01 5134
e920ebc9
APB		 5135/* Fix the constructors. This will be called right after circular
5136 references have been checked. It is necessary to fix constructors
5137 early even if no code generation will take place for that class:
5138 some generated constructor might be required by the class whose
5139 compilation triggered this one to be simply loaded. */
5140
5141void
5142java_fix_constructors ()
5143{
5144 tree current;
5145
5146 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5147 {
e920ebc9
APB		 5148 tree class_type = TREE_TYPE (current);
5149 int saw_ctor = 0;
c2952b01
APB		 5150 tree decl;
5151
5152 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5153 continue;
e920ebc9
APB		 5154
5155 for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5156 {
5157 if (DECL_CONSTRUCTOR_P (decl))
5158 {
5159 fix_constructors (decl);
5160 saw_ctor = 1;
5161 }
5162 }
5163
c2952b01
APB		 5164 /* Anonymous class constructor can't be generated that early. */
5165 if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5166 craft_constructor (current, NULL_TREE);
e920ebc9
APB		 5167 }
5168}
5169
23a79c61
APB		 5170/* safe_layout_class just makes sure that we can load a class without
5171 disrupting the current_class, input_file, lineno, etc, information
5172 about the class processed currently. */
5173
e04a16fb
AG		 5174void
5175safe_layout_class (class)
5176 tree class;
5177{
5178 tree save_current_class = current_class;
3b304f5b 5179 const char *save_input_filename = input_filename;
e04a16fb 5180 int save_lineno = lineno;
5e942c50 5181
e04a16fb 5182 push_obstacks (&permanent_obstack, &permanent_obstack);
5e942c50 5183
e04a16fb
AG		 5184 layout_class (class);
5185 pop_obstacks ();
5e942c50 5186
e04a16fb
AG		 5187 current_class = save_current_class;
5188 input_filename = save_input_filename;
5189 lineno = save_lineno;
5190 CLASS_LOADED_P (class) = 1;
5191}
5192
5193static tree
5194jdep_resolve_class (dep)
5195 jdep *dep;
5196{
5197 tree decl;
5198
23a79c61
APB		 5199 if (JDEP_RESOLVED_P (dep))
5200 decl = JDEP_RESOLVED_DECL (dep);
5201 else
e04a16fb 5202 {
c2952b01 5203 decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
23a79c61 5204 JDEP_DECL (dep), JDEP_WFL (dep));
e04a16fb
AG		 5205 JDEP_RESOLVED (dep, decl);
5206 }
23a79c61 5207
e04a16fb 5208 if (!decl)
23a79c61
APB		 5209 complete_class_report_errors (dep);
5210
cf1748bf 5211 check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
e04a16fb
AG		 5212 return decl;
5213}
5214
5215/* Complete unsatisfied class declaration and their dependencies */
5216
5217void
5218java_complete_class ()
5219{
e04a16fb
AG		 5220 tree cclass;
5221 jdeplist *cclassd;
5222 int error_found;
b67d701b 5223 tree type;
e04a16fb
AG		 5224
5225 push_obstacks (&permanent_obstack, &permanent_obstack);
5226
9a7ab4b3 5227 /* Process imports */
e04a16fb 5228 process_imports ();
e04a16fb
AG		 5229
5230 /* Rever things so we have the right order */
5231 ctxp->class_list = nreverse (ctxp->class_list);
5232 ctxp->classd_list = reverse_jdep_list (ctxp);
c877974e 5233
e04a16fb
AG		 5234 for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5235 cclass && cclassd;
5236 cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5237 {
5238 jdep *dep;
5239 for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5240 {
5241 tree decl;
e04a16fb
AG		 5242 if (!(decl = jdep_resolve_class (dep)))
5243 continue;
5244
5245 /* Now it's time to patch */
5246 switch (JDEP_KIND (dep))
5247 {
5248 case JDEP_SUPER:
5249 /* Simply patch super */
5250 if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5251 continue;
5252 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5253 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5254 break;
5255
5256 case JDEP_FIELD:
5257 {
5258 /* We do part of the job done in add_field */
5259 tree field_decl = JDEP_DECL (dep);
5260 tree field_type = TREE_TYPE (decl);
5261 push_obstacks (&permanent_obstack, &permanent_obstack);
e04a16fb 5262 if (TREE_CODE (field_type) == RECORD_TYPE)
e04a16fb
AG		 5263 field_type = promote_type (field_type);
5264 pop_obstacks ();
5265 TREE_TYPE (field_decl) = field_type;
5e942c50 5266 DECL_ALIGN (field_decl) = 0;
11cf4d18 5267 DECL_USER_ALIGN (field_decl) = 0;
5e942c50 5268 layout_decl (field_decl, 0);
e04a16fb
AG		 5269 SOURCE_FRONTEND_DEBUG
5270 (("Completed field/var decl `%s' with `%s'",
5271 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5272 IDENTIFIER_POINTER (DECL_NAME (decl))));
5273 break;
5274 }
5275 case JDEP_METHOD: /* We start patching a method */
5276 case JDEP_METHOD_RETURN:
5277 error_found = 0;
5278 while (1)
5279 {
5280 if (decl)
5281 {
b67d701b
PB		 5282 type = TREE_TYPE(decl);
5283 if (TREE_CODE (type) == RECORD_TYPE)
5284 type = promote_type (type);
e04a16fb
AG		 5285 JDEP_APPLY_PATCH (dep, type);
5286 SOURCE_FRONTEND_DEBUG
5287 (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5288 "Completing fct `%s' with ret type `%s'":
5289 "Completing arg `%s' with type `%s'"),
5290 IDENTIFIER_POINTER (EXPR_WFL_NODE
5291 (JDEP_DECL_WFL (dep))),
5292 IDENTIFIER_POINTER (DECL_NAME (decl))));
5293 }
5294 else
5295 error_found = 1;
5296 dep = JDEP_CHAIN (dep);
5297 if (JDEP_KIND (dep) == JDEP_METHOD_END)
5298 break;
5299 else
5300 decl = jdep_resolve_class (dep);
5301 }
5302 if (!error_found)
5303 {
5304 tree mdecl = JDEP_DECL (dep), signature;
5305 push_obstacks (&permanent_obstack, &permanent_obstack);
165f37bc
APB		 5306 /* Recompute and reset the signature, check first that
5307 all types are now defined. If they're not,
5308 dont build the signature. */
5309 if (check_method_types_complete (mdecl))
5310 {
5311 signature = build_java_signature (TREE_TYPE (mdecl));
5312 set_java_signature (TREE_TYPE (mdecl), signature);
5313 }
e04a16fb
AG		 5314 pop_obstacks ();
5315 }
5316 else
5317 continue;
5318 break;
5319
5320 case JDEP_INTERFACE:
5321 if (parser_check_super_interface (decl, JDEP_DECL (dep),
5322 JDEP_WFL (dep)))
5323 continue;
5324 parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5325 break;
5326
b67d701b 5327 case JDEP_PARM:
e04a16fb 5328 case JDEP_VARIABLE:
b67d701b
PB		 5329 type = TREE_TYPE(decl);
5330 if (TREE_CODE (type) == RECORD_TYPE)
5331 type = promote_type (type);
5332 JDEP_APPLY_PATCH (dep, type);
e04a16fb
AG		 5333 break;
5334
5335 case JDEP_TYPE:
5336 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5337 SOURCE_FRONTEND_DEBUG
5338 (("Completing a random type dependency on a '%s' node",
5339 tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5340 break;
5341
b9f7e36c 5342 case JDEP_EXCEPTION:
c877974e
APB		 5343 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5344 SOURCE_FRONTEND_DEBUG
5345 (("Completing `%s' `throws' argument node",
5346 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
b9f7e36c
APB		 5347 break;
5348
c2952b01
APB		 5349 case JDEP_ANONYMOUS:
5350 patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5351 break;
5352
e04a16fb 5353 default:
0a2138e2
APB		 5354 fatal ("Can't handle patch code %d - java_complete_class",
5355 JDEP_KIND (dep));
e04a16fb
AG		 5356 }
5357 }
5358 }
5359 pop_obstacks ();
5360 return;
5361}
5362
5363/* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5364 array. */
5365
5366static tree
c2952b01
APB		 5367resolve_class (enclosing, class_type, decl, cl)
5368 tree enclosing, class_type, decl, cl;
e04a16fb 5369{
49f48c71
KG		 5370 const char *name = IDENTIFIER_POINTER (TYPE_NAME (class_type));
5371 const char *base = name;
78d21f92
PB		 5372 tree resolved_type = TREE_TYPE (class_type);
5373 tree resolved_type_decl;
e04a16fb 5374
78d21f92
PB		 5375 if (resolved_type != NULL_TREE)
5376 {
5377 tree resolved_type_decl = TYPE_NAME (resolved_type);
5378 if (resolved_type_decl == NULL_TREE
5379 || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5380 {
5381 resolved_type_decl = build_decl (TYPE_DECL,
5382 TYPE_NAME (class_type),
5383 resolved_type);
5384 }
5385 return resolved_type_decl;
5386 }
5387
e04a16fb
AG		 5388 /* 1- Check to see if we have an array. If true, find what we really
5389 want to resolve */
5390 while (name[0] == '[')
5391 name++;
5392 if (base != name)
5393 TYPE_NAME (class_type) = get_identifier (name);
5394
5395 /* 2- Resolve the bare type */
c2952b01
APB		 5396 if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5397 decl, cl)))
e04a16fb
AG		 5398 return NULL_TREE;
5399 resolved_type = TREE_TYPE (resolved_type_decl);
5400
5401 /* 3- If we have and array, reconstruct the array down to its nesting */
5402 if (base != name)
5403 {
5404 while (base != name)
5405 {
5406 if (TREE_CODE (resolved_type) == RECORD_TYPE)
5407 resolved_type = promote_type (resolved_type);
5408 resolved_type = build_java_array_type (resolved_type, -1);
c583dd46 5409 CLASS_LOADED_P (resolved_type) = 1;
e04a16fb
AG		 5410 name--;
5411 }
5412 /* Build a fake decl for this, since this is what is expected to
5413 be returned. */
5414 resolved_type_decl =
5415 build_decl (TYPE_DECL, TYPE_NAME (resolved_type), resolved_type);
5416 /* Figure how those two things are important for error report. FIXME */
5417 DECL_SOURCE_LINE (resolved_type_decl) = 0;
5418 DECL_SOURCE_FILE (resolved_type_decl) = input_filename;
78d21f92 5419 TYPE_NAME (class_type) = TYPE_NAME (resolved_type);
e04a16fb 5420 }
78d21f92 5421 TREE_TYPE (class_type) = resolved_type;
e04a16fb
AG		 5422 return resolved_type_decl;
5423}
5424
5425/* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5426 are used to report error messages. */
5427
78d21f92 5428tree
c2952b01
APB		 5429do_resolve_class (enclosing, class_type, decl, cl)
5430 tree enclosing, class_type, decl, cl;
e04a16fb
AG		 5431{
5432 tree new_class_decl;
e04a16fb
AG		 5433
5434 /* Do not try to replace TYPE_NAME (class_type) by a variable, since
9a7ab4b3
APB		 5435 it is changed by find_in_imports{_on_demand} and (but it doesn't
5436 really matter) qualify_and_find */
e04a16fb 5437
c2952b01
APB		 5438 /* 0- Search in the current class as an inner class */
5439
5440 /* Maybe some code here should be added to load the class or
5441 something, at least if the class isn't an inner class and ended
5442 being loaded from class file. FIXME. */
a40d21da
APB		 5443 while (enclosing)
5444 {
5445 tree name;
5446
5447 if ((new_class_decl = find_as_inner_class (enclosing, class_type, cl)))
5448 return new_class_decl;
5449
5450 /* Now go to the upper classes, bail out if necessary. */
5451 enclosing = CLASSTYPE_SUPER (TREE_TYPE (enclosing));
5452 if (!enclosing || enclosing == object_type_node)
5453 break;
5454
5455 if (TREE_CODE (enclosing) == RECORD_TYPE)
5456 {
5457 enclosing = TYPE_NAME (enclosing);
5458 continue;
5459 }
5460
5461 if (TREE_CODE (enclosing) == IDENTIFIER_NODE)
5462 {
5463 BUILD_PTR_FROM_NAME (name, enclosing);
5464 }
5465 else
5466 name = enclosing;
5467 enclosing = do_resolve_class (NULL, name, NULL, NULL);
5468 }
c2952b01 5469
9a7ab4b3
APB		 5470 /* 1- Check for the type in single imports. This will change
5471 TYPE_NAME() if something relevant is found */
5472 find_in_imports (class_type);
e04a16fb 5473
9a7ab4b3 5474 /* 2- And check for the type in the current compilation unit */
e04a16fb
AG		 5475 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5476 {
5477 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5478 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5479 load_class (TYPE_NAME (class_type), 0);
5480 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5481 }
5482
9a7ab4b3
APB		 5483 /* 3- Search according to the current package definition */
5484 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5485 {
5486 if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5487 TYPE_NAME (class_type))))
5488 return new_class_decl;
5489 }
5490
5491 /* 4- Check the import on demands. Don't allow bar.baz to be
5492 imported from foo.* */
5493 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5494 if (find_in_imports_on_demand (class_type))
5495 return NULL_TREE;
5496
5497 /* If found in find_in_imports_on_demant, the type has already been
5498 loaded. */
5499 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5500 return new_class_decl;
5501
5502 /* 5- Try with a name qualified with the package name we've seen so far */
ee07f4f4 5503 if (!QUALIFIED_P (TYPE_NAME (class_type)))
bc3ca41b 5504 {
ee07f4f4 5505 tree package;
d6baf6f5
APB		 5506
5507 /* If there is a current package (ctxp->package), it's the first
5508 element of package_list and we can skip it. */
5509 for (package = (ctxp->package ?
5510 TREE_CHAIN (package_list) : package_list);
5511 package; package = TREE_CHAIN (package))
9a7ab4b3
APB		 5512 if ((new_class_decl = qualify_and_find (class_type,
5513 TREE_PURPOSE (package),
5514 TYPE_NAME (class_type))))
5515 return new_class_decl;
5516 }
5517
5518 /* 5- Check an other compilation unit that bears the name of type */
e04a16fb
AG		 5519 load_class (TYPE_NAME (class_type), 0);
5520 if (check_pkg_class_access (TYPE_NAME (class_type),
5521 (cl ? cl : lookup_cl (decl))))
5522 return NULL_TREE;
5523
9a7ab4b3 5524 /* 6- Last call for a resolution */
e04a16fb
AG		 5525 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5526}
5527
9a7ab4b3
APB		 5528static tree
5529qualify_and_find (class_type, package, name)
5530 tree class_type, package, name;
5531{
5532 tree new_qualified = merge_qualified_name (package, name);
5533 tree new_class_decl;
5534
5535 if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5536 load_class (new_qualified, 0);
5537 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5538 {
5539 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5540 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5541 load_class (new_qualified, 0);
5542 TYPE_NAME (class_type) = new_qualified;
5543 return IDENTIFIER_CLASS_VALUE (new_qualified);
5544 }
5545 return NULL_TREE;
5546}
5547
e04a16fb 5548/* Resolve NAME and lay it out (if not done and if not the current
23a79c61
APB		 5549 parsed class). Return a decl node. This function is meant to be
5550 called when type resolution is necessary during the walk pass. */
e04a16fb
AG		 5551
5552static tree
c877974e
APB		 5553resolve_and_layout (something, cl)
5554 tree something;
e04a16fb
AG		 5555 tree cl;
5556{
c877974e
APB		 5557 tree decl;
5558
23a79c61
APB		 5559 /* Don't do that on the current class */
5560 if (something == current_class)
5561 return TYPE_NAME (current_class);
c877974e 5562
23a79c61 5563 /* Don't do anything for void and other primitive types */
c877974e
APB		 5564 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5565 return NULL_TREE;
5566
23a79c61
APB		 5567 /* Pointer types can be reall pointer types or fake pointers. When
5568 finding a real pointer, recheck for primitive types */
5569 if (TREE_CODE (something) == POINTER_TYPE)
5570 {
5571 if (TREE_TYPE (something))
5572 {
5573 something = TREE_TYPE (something);
5574 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5575 return NULL_TREE;
5576 }
5577 else
5578 something = TYPE_NAME (something);
5579 }
5580
5581 /* Don't do anything for arrays of primitive types */
5582 if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5583 && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5584 return NULL_TREE;
5585
c2952b01
APB		 5586 /* Something might be a WFL */
5587 if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5588 something = EXPR_WFL_NODE (something);
5589
5590 /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5591 TYPE_DECL or a real TYPE */
5592 else if (TREE_CODE (something) != IDENTIFIER_NODE)
c877974e
APB		 5593 something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5594 DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5595
23a79c61
APB		 5596 if (!(decl = resolve_no_layout (something, cl)))
5597 return NULL_TREE;
5598
5599 /* Resolve and layout if necessary */
5600 layout_class_methods (TREE_TYPE (decl));
7705e9db
APB		 5601 /* Check methods, but only once */
5602 if (CLASS_FROM_SOURCE_P (TREE_TYPE (decl))
5603 && !CLASS_LOADED_P (TREE_TYPE (decl)))
23a79c61
APB		 5604 CHECK_METHODS (decl);
5605 if (TREE_TYPE (decl) != current_class && !CLASS_LOADED_P (TREE_TYPE (decl)))
e04a16fb 5606 safe_layout_class (TREE_TYPE (decl));
23a79c61 5607
e04a16fb
AG		 5608 return decl;
5609}
5610
5611/* Resolve a class, returns its decl but doesn't perform any
5612 layout. The current parsing context is saved and restored */
5613
5614static tree
5615resolve_no_layout (name, cl)
5616 tree name, cl;
5617{
5618 tree ptr, decl;
5619 BUILD_PTR_FROM_NAME (ptr, name);
5620 java_parser_context_save_global ();
c2952b01 5621 decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
e04a16fb
AG		 5622 java_parser_context_restore_global ();
5623
5624 return decl;
5625}
5626
23a79c61
APB		 5627/* Called when reporting errors. Skip leader '[' in a complex array
5628 type description that failed to be resolved. */
e04a16fb 5629
49f48c71 5630static const char *
e04a16fb 5631purify_type_name (name)
49f48c71 5632 const char *name;
e04a16fb
AG		 5633{
5634 while (*name && *name == '[')
5635 name++;
5636 return name;
5637}
5638
5639/* The type CURRENT refers to can't be found. We print error messages. */
5640
5641static void
5642complete_class_report_errors (dep)
5643 jdep *dep;
5644{
49f48c71 5645 const char *name;
23a79c61
APB		 5646
5647 if (!JDEP_WFL (dep))
5648 return;
5649
5650 name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
e04a16fb
AG		 5651 switch (JDEP_KIND (dep))
5652 {
5653 case JDEP_SUPER:
5654 parse_error_context
5655 (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
23a79c61 5656 purify_type_name (name),
e04a16fb
AG		 5657 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5658 break;
5659 case JDEP_FIELD:
5660 parse_error_context
5661 (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
23a79c61 5662 purify_type_name (name),
e04a16fb
AG		 5663 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5664 break;
5665 case JDEP_METHOD: /* Covers arguments */
5666 parse_error_context
781b0558 5667 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
23a79c61 5668 purify_type_name (name),
e04a16fb
AG		 5669 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
5670 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
5671 break;
5672 case JDEP_METHOD_RETURN: /* Covers return type */
5673 parse_error_context
781b0558 5674 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
23a79c61 5675 purify_type_name (name),
e04a16fb
AG		 5676 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
5677 break;
5678 case JDEP_INTERFACE:
5679 parse_error_context
5680 (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
5681 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
5682 (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
5683 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5684 break;
5685 case JDEP_VARIABLE:
5686 parse_error_context
781b0558 5687 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
b67d701b
PB		 5688 purify_type_name (IDENTIFIER_POINTER
5689 (EXPR_WFL_NODE (JDEP_WFL (dep)))),
e04a16fb
AG		 5690 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5691 break;
b9f7e36c
APB		 5692 case JDEP_EXCEPTION: /* As specified by `throws' */
5693 parse_error_context
5694 (JDEP_WFL (dep), "Class `%s' not found in `throws'",
5695 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
5696 break;
0a2138e2
APB		 5697 default:
5698 /* Fix for -Wall. Just break doing nothing. The error will be
5699 caught later */
5700 break;
e04a16fb
AG		 5701 }
5702}
5703
22eed1e6
APB		 5704/* Return a static string containing the DECL prototype string. If
5705 DECL is a constructor, use the class name instead of the form
5706 <init> */
5707
49f48c71 5708static const char *
22eed1e6
APB		 5709get_printable_method_name (decl)
5710 tree decl;
5711{
49f48c71 5712 const char *to_return;
9ee9b555 5713 tree name = NULL_TREE;
22eed1e6
APB		 5714
5715 if (DECL_CONSTRUCTOR_P (decl))
5716 {
5717 name = DECL_NAME (decl);
5e942c50 5718 DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
22eed1e6
APB		 5719 }
5720
5721 to_return = lang_printable_name (decl, 0);
5722 if (DECL_CONSTRUCTOR_P (decl))
5723 DECL_NAME (decl) = name;
5724
5725 return to_return;
5726}
5727
5e942c50
APB		 5728/* Reinstall the proper DECL_NAME on METHOD. Return 0 if the method
5729 nevertheless needs to be verfied, 1 otherwise. */
5730
5731static int
5732reset_method_name (method)
5733 tree method;
5734{
c2952b01 5735 if (!DECL_CLINIT_P (method) && !DECL_FINIT_P (method))
5e942c50
APB		 5736 {
5737 /* NAME is just the plain name when Object is being defined */
5738 if (DECL_CONTEXT (method) != object_type_node)
c877974e
APB		 5739 DECL_NAME (method) = (DECL_CONSTRUCTOR_P (method) ?
5740 init_identifier_node : GET_METHOD_NAME (method));
5e942c50
APB		 5741 return 0;
5742 }
5743 else
5744 return 1;
5745}
5746
c877974e
APB		 5747/* Return the name of METHOD_DECL, when DECL_NAME is a WFL */
5748
5749tree
5750java_get_real_method_name (method_decl)
5751 tree method_decl;
5752{
5753 tree method_name = DECL_NAME (method_decl);
5754 if (DECL_CONSTRUCTOR_P (method_decl))
5755 return init_identifier_node;
82371d41
APB		 5756
5757 /* Explain here why METHOD_DECL doesn't have the DECL_CONSTRUCTUR_P
5758 and still can be a constructor. FIXME */
5759
23a79c61
APB		 5760 /* Don't confuse method only bearing the name of their class as
5761 constructors */
82371d41
APB		 5762 else if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (method_decl))
5763 && ctxp
c2952b01 5764 && GET_CPC_UN () == EXPR_WFL_NODE (method_name)
23a79c61
APB		 5765 && get_access_flags_from_decl (method_decl) <= ACC_PROTECTED
5766 && TREE_TYPE (TREE_TYPE (method_decl)) == void_type_node)
c877974e
APB		 5767 return init_identifier_node;
5768 else
5769 return EXPR_WFL_NODE (method_name);
5770}
5771
22eed1e6
APB		 5772/* Track method being redefined inside the same class. As a side
5773 effect, set DECL_NAME to an IDENTIFIER (prior entering this
d77613be 5774 function it's a FWL, so we can track errors more accurately.) */
22eed1e6 5775
e04a16fb
AG		 5776static int
5777check_method_redefinition (class, method)
5778 tree class, method;
5779{
5780 tree redef, name;
5781 tree cl = DECL_NAME (method);
c3f2a476 5782 tree sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
ba179f9f
APB		 5783 /* decl name of artificial <clinit> and $finit$ doesn't need to be
5784 fixed and checked */
5e942c50
APB		 5785
5786 /* Reset the method name before running the check. If it returns 1,
5787 the method doesn't need to be verified with respect to method
5788 redeclaration and we return 0 */
5789 if (reset_method_name (method))
e04a16fb 5790 return 0;
5e942c50
APB		 5791
5792 name = DECL_NAME (method);
e04a16fb
AG		 5793 for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
5794 {
c3f2a476 5795 if (redef == method)
e04a16fb 5796 break;
c3f2a476
APB		 5797 if (DECL_NAME (redef) == name
5798 && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef)))
e04a16fb 5799 {
22eed1e6
APB		 5800 parse_error_context
5801 (cl, "Duplicate %s declaration `%s'",
5802 (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
5803 get_printable_method_name (redef));
e04a16fb
AG		 5804 return 1;
5805 }
5806 }
5807 return 0;
5808}
5809
d77613be
APB		 5810static void
5811check_abstract_method_definitions (do_interface, class_decl, type)
5812 int do_interface;
5813 tree class_decl, type;
5814{
5815 tree class = TREE_TYPE (class_decl);
5816 tree method, end_type;
5817
5818 end_type = (do_interface ? object_type_node : type);
5819 for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
5820 {
5821 tree other_super, other_method, method_sig, method_name;
5822 int found = 0;
165f37bc 5823 int end_type_reached = 0;
d77613be
APB		 5824
5825 if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
5826 continue;
5827
5828 /* Now verify that somewhere in between TYPE and CLASS,
5829 abstract method METHOD gets a non abstract definition
5830 that is inherited by CLASS. */
5831
5832 method_sig = build_java_signature (TREE_TYPE (method));
5833 method_name = DECL_NAME (method);
5834 if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
5835 method_name = EXPR_WFL_NODE (method_name);
5836
165f37bc
APB		 5837 other_super = class;
5838 do {
5839 if (other_super == end_type)
5840 end_type_reached = 1;
5841
5842 /* Method search */
5843 for (other_method = TYPE_METHODS (other_super); other_method;
5844 other_method = TREE_CHAIN (other_method))
5845 {
5846 tree s = build_java_signature (TREE_TYPE (other_method));
5847 tree other_name = DECL_NAME (other_method);
5848
5849 if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
5850 other_name = EXPR_WFL_NODE (other_name);
5851 if (!DECL_CLINIT_P (other_method)
5852 && !DECL_CONSTRUCTOR_P (other_method)
120f0c10
TT		 5853 && method_name == other_name
5854 && method_sig == s
5855 && !METHOD_ABSTRACT (other_method))
165f37bc
APB		 5856 {
5857 found = 1;
5858 break;
5859 }
5860 }
5861 other_super = CLASSTYPE_SUPER (other_super);
5862 } while (!end_type_reached);
5863
d77613be
APB		 5864 /* Report that abstract METHOD didn't find an implementation
5865 that CLASS can use. */
5866 if (!found)
5867 {
c2e3db92 5868 char *t = xstrdup (lang_printable_name
d77613be
APB		 5869 (TREE_TYPE (TREE_TYPE (method)), 0));
5870 tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
5871 tree saved_wfl = NULL_TREE;
5872
5873 if (TREE_CODE (DECL_NAME (method)) == EXPR_WITH_FILE_LOCATION)
5874 {
5875 saved_wfl = DECL_NAME (method);
5876 DECL_NAME (method) = EXPR_WFL_NODE (DECL_NAME (method));
5877 }
5878
5879 parse_error_context
5880 (lookup_cl (class_decl),
781b0558 5881 "Class `%s' doesn't define the abstract method `%s %s' from %s `%s'. This method must be defined or %s `%s' must be declared abstract",
d77613be
APB		 5882 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
5883 t, lang_printable_name (method, 0),
5884 (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
5885 "interface" : "class"),
5886 IDENTIFIER_POINTER (ccn),
5887 (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
5888 IDENTIFIER_POINTER (DECL_NAME (class_decl)));
5889
5890 free (t);
5891
5892 if (saved_wfl)
5893 DECL_NAME (method) = saved_wfl;
5894 }
5895 }
5896}
5897
614eaae0 5898/* Check that CLASS_DECL somehow implements all inherited abstract
d77613be
APB		 5899 methods. */
5900
5901static void
5902java_check_abstract_method_definitions (class_decl)
5903 tree class_decl;
5904{
5905 tree class = TREE_TYPE (class_decl);
5906 tree super, vector;
5907 int i;
5908
5909 if (CLASS_ABSTRACT (class_decl))
5910 return;
5911
5912 /* Check for inherited types */
165f37bc
APB		 5913 super = class;
5914 do {
5915 super = CLASSTYPE_SUPER (super);
5916 check_abstract_method_definitions (0, class_decl, super);
5917 } while (super != object_type_node);
d77613be
APB		 5918
5919 /* Check for implemented interfaces. */
5920 vector = TYPE_BINFO_BASETYPES (class);
5921 for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
5922 {
5923 super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
5924 check_abstract_method_definitions (1, class_decl, super);
5925 }
5926}
5927
165f37bc
APB		 5928/* Check all the types method DECL uses and return 1 if all of them
5929 are now complete, 0 otherwise. This is used to check whether its
5930 safe to build a method signature or not. */
5931
5932static int
5933check_method_types_complete (decl)
5934 tree decl;
5935{
5936 tree type = TREE_TYPE (decl);
5937 tree args;
5938
5939 if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
5940 return 0;
5941
5942 args = TYPE_ARG_TYPES (type);
5943 if (TREE_CODE (type) == METHOD_TYPE)
5944 args = TREE_CHAIN (args);
5945 for (; args != end_params_node; args = TREE_CHAIN (args))
5946 if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
5947 return 0;
5948
5949 return 1;
5950}
5951
d77613be
APB		 5952/* Check all the methods of CLASS_DECL. Methods are first completed
5953 then checked according to regular method existance rules. If no
5954 constructor for CLASS_DECL were encountered, then build its
5955 declaration. */
e04a16fb
AG		 5956
5957static void
5958java_check_regular_methods (class_decl)
5959 tree class_decl;
5960{
c2952b01 5961 int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
e04a16fb
AG		 5962 tree method;
5963 tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl));
5e942c50 5964 tree saved_found_wfl = NULL_TREE, found = NULL_TREE;
c877974e
APB		 5965 tree mthrows;
5966
5967 /* It is not necessary to check methods defined in java.lang.Object */
5968 if (class == object_type_node)
5969 return;
e04a16fb 5970
23a79c61
APB		 5971 if (!TYPE_NVIRTUALS (class))
5972 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
e04a16fb
AG		 5973
5974 /* Should take interfaces into account. FIXME */
5975 for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
5976 {
5e942c50 5977 tree sig;
e04a16fb
AG		 5978 tree method_wfl = DECL_NAME (method);
5979 int aflags;
5980
5e942c50
APB		 5981 /* If we previously found something and its name was saved,
5982 reinstall it now */
5983 if (found && saved_found_wfl)
ba179f9f
APB		 5984 {
5985 DECL_NAME (found) = saved_found_wfl;
5986 saved_found_wfl = NULL_TREE;
5987 }
5e942c50 5988
e04a16fb
AG		 5989 /* Check for redefinitions */
5990 if (check_method_redefinition (class, method))
5991 continue;
5992
22eed1e6
APB		 5993 /* If we see one constructor a mark so we don't generate the
5994 default one. Also skip other verifications: constructors
5995 can't be inherited hence hiden or overriden */
5996 if (DECL_CONSTRUCTOR_P (method))
5997 {
5998 saw_constructor = 1;
5999 continue;
6000 }
6001
c877974e
APB		 6002 /* We verify things thrown by the method. They must inherits from
6003 java.lang.Throwable */
6004 for (mthrows = DECL_FUNCTION_THROWS (method);
6005 mthrows; mthrows = TREE_CHAIN (mthrows))
6006 {
6007 if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6008 parse_error_context
781b0558 6009 (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
c877974e
APB		 6010 IDENTIFIER_POINTER
6011 (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6012 }
6013
e04a16fb 6014 sig = build_java_argument_signature (TREE_TYPE (method));
614eaae0 6015 found = lookup_argument_method2 (class, DECL_NAME (method), sig);
b9f7e36c 6016
c2952b01
APB		 6017 /* Inner class can't declare static methods */
6018 if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6019 {
6020 char *t = xstrdup (lang_printable_name (class, 0));
6021 parse_error_context
6022 (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6023 lang_printable_name (method, 0), t);
6024 free (t);
6025 }
6026
5e942c50 6027 /* Nothing overrides or it's a private method. */
aabd7048 6028 if (!found)
5e942c50 6029 continue;
aabd7048
PB		 6030 if (METHOD_PRIVATE (found))
6031 {
6032 found = NULL_TREE;
6033 continue;
6034 }
5e942c50
APB		 6035
6036 /* If found wasn't verified, it's DECL_NAME won't be set properly.
6037 We set it temporarily for the sake of the error report. */
6038 saved_found_wfl = DECL_NAME (found);
6039 reset_method_name (found);
6040
614eaae0
APB		 6041 /* If `found' is declared in an interface, make sure the
6042 modifier matches. */
6043 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6044 && clinit_identifier_node != DECL_NAME (found)
6045 && !METHOD_PUBLIC (method))
6046 {
6047 tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6048 parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6049 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6050 lang_printable_name (method, 0),
6051 IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6052 }
6053
e04a16fb
AG		 6054 /* Can't override a method with the same name and different return
6055 types. */
6056 if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
b9f7e36c 6057 {
614eaae0
APB		 6058 char *t = xstrdup
6059 (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
b9f7e36c 6060 parse_error_context
7f10c2e2 6061 (method_wfl,
b9f7e36c 6062 "Method `%s' was defined with return type `%s' in class `%s'",
0a2138e2 6063 lang_printable_name (found, 0), t,
b9f7e36c
APB		 6064 IDENTIFIER_POINTER
6065 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6066 free (t);
6067 }
e04a16fb 6068
7f10c2e2
APB		 6069 aflags = get_access_flags_from_decl (found);
6070 /* If the method has default, access in an other package, then
6071 issue a warning that the current method doesn't override the
6072 one that was found elsewhere. Do not issue this warning when
6073 the match was found in java.lang.Object. */
6074 if (DECL_CONTEXT (found) != object_type_node
a003f638 6075 && ((aflags & ACC_VISIBILITY) == 0)
7f10c2e2 6076 && !class_in_current_package (DECL_CONTEXT (found))
c2952b01 6077 && !DECL_CLINIT_P (found)
7f10c2e2
APB		 6078 && flag_not_overriding)
6079 {
6080 parse_warning_context
781b0558 6081 (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		 6082 lang_printable_name (found, 0),
6083 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6084 IDENTIFIER_POINTER (DECL_NAME
6085 (TYPE_NAME (DECL_CONTEXT (found)))));
6086 continue;
6087 }
6088
e04a16fb
AG		 6089 /* Can't override final. Can't override static. */
6090 if (METHOD_FINAL (found) || METHOD_STATIC (found))
6091 {
6092 /* Static *can* override static */
6093 if (METHOD_STATIC (found) && METHOD_STATIC (method))
6094 continue;
6095 parse_error_context
6096 (method_wfl,
6097 "%s methods can't be overriden. Method `%s' is %s in class `%s'",
6098 (METHOD_FINAL (found) ? "Final" : "Static"),
0a2138e2 6099 lang_printable_name (found, 0),
e04a16fb
AG		 6100 (METHOD_FINAL (found) ? "final" : "static"),
6101 IDENTIFIER_POINTER
6102 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6103 continue;
6104 }
7f10c2e2 6105
e04a16fb
AG		 6106 /* Static method can't override instance method. */
6107 if (METHOD_STATIC (method))
6108 {
6109 parse_error_context
6110 (method_wfl,
781b0558 6111 "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
0a2138e2 6112 lang_printable_name (found, 0),
e04a16fb
AG		 6113 IDENTIFIER_POINTER
6114 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6115 continue;
6116 }
5e942c50 6117
5e942c50
APB		 6118 /* - Overriding/hiding public must be public
6119 - Overriding/hiding protected must be protected or public
6120 - If the overriden or hidden method has default (package)
6121 access, then the overriding or hiding method must not be
614eaae0
APB		 6122 private; otherwise, a compile-time error occurs. If
6123 `found' belongs to an interface, things have been already
6124 taken care of. */
6125 if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6126 && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6127 || (METHOD_PROTECTED (found)
6128 && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6129 || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6130 && METHOD_PRIVATE (method))))
e04a16fb
AG		 6131 {
6132 parse_error_context
6133 (method_wfl,
781b0558 6134 "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
5e942c50
APB		 6135 (METHOD_PUBLIC (method) ? "public" :
6136 (METHOD_PRIVATE (method) ? "private" : "protected")),
6137 IDENTIFIER_POINTER (DECL_NAME
6138 (TYPE_NAME (DECL_CONTEXT (found)))));
e04a16fb
AG		 6139 continue;
6140 }
6141
b9f7e36c
APB		 6142 /* Overriding methods must have compatible `throws' clauses on checked
6143 exceptions, if any */
6144 check_throws_clauses (method, method_wfl, found);
6145
e04a16fb
AG		 6146 /* Inheriting multiple methods with the same signature. FIXME */
6147 }
6148
5e942c50
APB		 6149 /* Don't forget eventual pending found and saved_found_wfl. Take
6150 into account that we might have exited because we saw an
d77613be 6151 artificial method as the last entry. */
5e942c50
APB		 6152
6153 if (found && !DECL_ARTIFICIAL (found) && saved_found_wfl)
6154 DECL_NAME (found) = saved_found_wfl;
6155
23a79c61
APB		 6156 if (!TYPE_NVIRTUALS (class))
6157 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
e04a16fb 6158
d77613be
APB		 6159 /* Search for inherited abstract method not yet implemented in this
6160 class. */
6161 java_check_abstract_method_definitions (class_decl);
6162
22eed1e6 6163 if (!saw_constructor)
e920ebc9 6164 fatal ("No constructor found");
e04a16fb
AG		 6165}
6166
b9f7e36c
APB		 6167/* Return a non zero value if the `throws' clause of METHOD (if any)
6168 is incompatible with the `throws' clause of FOUND (if any). */
6169
6170static void
6171check_throws_clauses (method, method_wfl, found)
6172 tree method, method_wfl, found;
6173{
6174 tree mthrows, fthrows;
6175
c877974e
APB		 6176 /* Can't check these things with class loaded from bytecode. FIXME */
6177 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6178 return;
6179
b9f7e36c
APB		 6180 for (mthrows = DECL_FUNCTION_THROWS (method);
6181 mthrows; mthrows = TREE_CHAIN (mthrows))
6182 {
6183 /* We don't verify unchecked expressions */
c877974e 6184 if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
b9f7e36c
APB		 6185 continue;
6186 /* Checked expression must be compatible */
6187 for (fthrows = DECL_FUNCTION_THROWS (found);
6188 fthrows; fthrows = TREE_CHAIN (fthrows))
6189 if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6190 break;
6191 if (!fthrows)
6192 {
6193 parse_error_context
781b0558 6194 (method_wfl, "Invalid checked exception class `%s' in `throws' clause. The exception must be a subclass of an exception thrown by `%s' from class `%s'",
b9f7e36c 6195 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
0a2138e2 6196 lang_printable_name (found, 0),
b9f7e36c
APB		 6197 IDENTIFIER_POINTER
6198 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6199 }
6200 }
6201}
6202
e04a16fb
AG		 6203/* Check abstract method of interface INTERFACE */
6204
6205static void
5e942c50
APB		 6206java_check_abstract_methods (interface_decl)
6207 tree interface_decl;
e04a16fb
AG		 6208{
6209 int i, n;
6210 tree method, basetype_vec, found;
5e942c50 6211 tree interface = TREE_TYPE (interface_decl);
e04a16fb
AG		 6212
6213 for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6214 {
b9f7e36c 6215 tree method_wfl = DECL_NAME (method);
e04a16fb
AG		 6216
6217 /* 2- Check for double definition inside the defining interface */
6218 if (check_method_redefinition (interface, method))
6219 continue;
6220
6221 /* 3- Overriding is OK as far as we preserve the return type and
b9f7e36c 6222 the thrown exceptions (FIXME) */
e04a16fb
AG		 6223 found = lookup_java_interface_method2 (interface, method);
6224 if (found)
6225 {
5e942c50
APB		 6226 char *t;
6227 tree saved_found_wfl = DECL_NAME (found);
6228 reset_method_name (found);
c2e3db92 6229 t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
e04a16fb 6230 parse_error_context
b9f7e36c 6231 (method_wfl,
5e942c50 6232 "Method `%s' was defined with return type `%s' in class `%s'",
0a2138e2 6233 lang_printable_name (found, 0), t,
b9f7e36c
APB		 6234 IDENTIFIER_POINTER
6235 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6236 free (t);
5e942c50 6237 DECL_NAME (found) = saved_found_wfl;
c63b98cd 6238 continue;
e04a16fb
AG		 6239 }
6240 }
6241
6242 /* 4- Inherited methods can't differ by their returned types */
6243 if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6244 return;
6245 n = TREE_VEC_LENGTH (basetype_vec);
6246 for (i = 0; i < n; i++)
6247 {
6248 tree sub_interface_method, sub_interface;
6249 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6250 if (!vec_elt)
6251 continue;
6252 sub_interface = BINFO_TYPE (vec_elt);
6253 for (sub_interface_method = TYPE_METHODS (sub_interface);
6254 sub_interface_method;
6255 sub_interface_method = TREE_CHAIN (sub_interface_method))
6256 {
6257 found = lookup_java_interface_method2 (interface,
6258 sub_interface_method);
6259 if (found && (found != sub_interface_method))
5e942c50
APB		 6260 {
6261 tree saved_found_wfl = DECL_NAME (found);
6262 reset_method_name (found);
6263 parse_error_context
6264 (lookup_cl (sub_interface_method),
781b0558 6265 "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
5e942c50
APB		 6266 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6267 lang_printable_name (found, 0),
6268 IDENTIFIER_POINTER
6269 (DECL_NAME (TYPE_NAME
6270 (DECL_CONTEXT (sub_interface_method)))),
6271 IDENTIFIER_POINTER
6272 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6273 DECL_NAME (found) = saved_found_wfl;
6274 }
e04a16fb
AG		 6275 }
6276 }
6277}
6278
e04a16fb
AG		 6279/* Lookup methods in interfaces using their name and partial
6280 signature. Return a matching method only if their types differ. */
6281
6282static tree
6283lookup_java_interface_method2 (class, method_decl)
6284 tree class, method_decl;
6285{
6286 int i, n;
6287 tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6288
6289 if (!basetype_vec)
6290 return NULL_TREE;
6291
6292 n = TREE_VEC_LENGTH (basetype_vec);
6293 for (i = 0; i < n; i++)
6294 {
6295 tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6296 if ((BINFO_TYPE (vec_elt) != object_type_node)
6297 && (to_return =
6298 lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6299 return to_return;
6300 }
6301 for (i = 0; i < n; i++)
6302 {
6303 to_return = lookup_java_interface_method2
6304 (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6305 if (to_return)
6306 return to_return;
6307 }
6308
6309 return NULL_TREE;
6310}
6311
6312/* Lookup method using their name and partial signature. Return a
6313 matching method only if their types differ. */
6314
6315static tree
6316lookup_java_method2 (clas, method_decl, do_interface)
6317 tree clas, method_decl;
6318 int do_interface;
6319{
5e942c50
APB		 6320 tree method, method_signature, method_name, method_type, name;
6321
e04a16fb 6322 method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
5e942c50
APB		 6323 name = DECL_NAME (method_decl);
6324 method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6325 EXPR_WFL_NODE (name) : name);
e04a16fb
AG		 6326 method_type = TREE_TYPE (TREE_TYPE (method_decl));
6327
6328 while (clas != NULL_TREE)
6329 {
6330 for (method = TYPE_METHODS (clas);
6331 method != NULL_TREE; method = TREE_CHAIN (method))
6332 {
6333 tree method_sig = build_java_argument_signature (TREE_TYPE (method));
5e942c50
APB		 6334 tree name = DECL_NAME (method);
6335 if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6336 EXPR_WFL_NODE (name) : name) == method_name
e04a16fb
AG		 6337 && method_sig == method_signature
6338 && TREE_TYPE (TREE_TYPE (method)) != method_type)
5e942c50 6339 return method;
e04a16fb
AG		 6340 }
6341 clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6342 }
6343 return NULL_TREE;
6344}
6345
f441f671
APB		 6346/* Return the line that matches DECL line number, and try its best to
6347 position the column number. Used during error reports. */
e04a16fb
AG		 6348
6349static tree
6350lookup_cl (decl)
6351 tree decl;
6352{
6353 static tree cl = NULL_TREE;
f441f671 6354 char *line, *found;
e04a16fb
AG		 6355
6356 if (!decl)
6357 return NULL_TREE;
6358
6359 if (cl == NULL_TREE)
6360 cl = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6361
6362 EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl));
6363 EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1);
6364
f441f671
APB		 6365 line = java_get_line_col (IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE (cl)),
6366 EXPR_WFL_LINENO (cl), EXPR_WFL_COLNO (cl));
6367
6368 found = strstr ((const char *)line,
6369 (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6370 if (found)
6371 EXPR_WFL_SET_LINECOL (cl, EXPR_WFL_LINENO (cl), found - line);
6372
e04a16fb
AG		 6373 return cl;
6374}
6375
6376/* Look for a simple name in the single-type import list */
6377
6378static tree
6379find_name_in_single_imports (name)
6380 tree name;
6381{
6382 tree node;
6383
6384 for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6385 if (TREE_VALUE (node) == name)
6386 return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6387
6388 return NULL_TREE;
6389}
6390
6391/* Process all single-type import. */
6392
6393static int
6394process_imports ()
6395{
6396 tree import;
6397 int error_found;
6398
6399 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6400 {
6401 tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6402
6403 /* Don't load twice something already defined. */
6404 if (IDENTIFIER_CLASS_VALUE (to_be_found))
6405 continue;
6406 QUALIFIED_P (to_be_found) = 1;
6407 load_class (to_be_found, 0);
6408 error_found =
6409 check_pkg_class_access (to_be_found, TREE_PURPOSE (import));
6410 if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6411 {
6412 parse_error_context (TREE_PURPOSE (import),
6413 "Class or interface `%s' not found in import",
6414 IDENTIFIER_POINTER (to_be_found));
6415 return 1;
6416 }
6417 if (error_found)
6418 return 1;
6419 }
6420 return 0;
6421}
6422
9a7ab4b3
APB		 6423/* Possibly find and mark a class imported by a single-type import
6424 statement. */
e04a16fb 6425
9a7ab4b3 6426static void
e04a16fb
AG		 6427find_in_imports (class_type)
6428 tree class_type;
6429{
6430 tree import;
6431
6432 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6433 if (TREE_VALUE (import) == TYPE_NAME (class_type))
6434 {
6435 TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6436 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
e04a16fb 6437 }
e04a16fb
AG		 6438}
6439
e04a16fb 6440static int
63a212ed 6441note_possible_classname (name, len)
49f48c71 6442 const char *name;
63a212ed 6443 int len;
e04a16fb 6444{
63a212ed
PB		 6445 tree node;
6446 if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6447 len = len - 5;
6448 else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6449 len = len - 6;
e04a16fb 6450 else
63a212ed
PB		 6451 return 0;
6452 node = ident_subst (name, len, "", '/', '.', "");
6453 IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
fe0e4d76 6454 QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
63a212ed 6455 return 1;
e04a16fb
AG		 6456}
6457
6458/* Read a import directory, gathering potential match for further type
6459 references. Indifferently reads a filesystem or a ZIP archive
6460 directory. */
6461
6462static void
6463read_import_dir (wfl)
6464 tree wfl;
6465{
63a212ed 6466 tree package_id = EXPR_WFL_NODE (wfl);
49f48c71 6467 const char *package_name = IDENTIFIER_POINTER (package_id);
63a212ed 6468 int package_length = IDENTIFIER_LENGTH (package_id);
e04a16fb 6469 DIR *dirp = NULL;
d8fccff5 6470 JCF *saved_jcf = current_jcf;
e04a16fb 6471
63a212ed
PB		 6472 int found = 0;
6473 int k;
6474 void *entry;
6475 struct buffer filename[1];
6476
6477
6478 if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6479 return;
6480 IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6481
6482 BUFFER_INIT (filename);
6483 buffer_grow (filename, package_length + 100);
6484
6485 for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6486 {
49f48c71 6487 const char *entry_name = jcf_path_name (entry);
63a212ed
PB		 6488 int entry_length = strlen (entry_name);
6489 if (jcf_path_is_zipfile (entry))
6490 {
6491 ZipFile *zipf;
6492 buffer_grow (filename, entry_length);
6493 memcpy (filename->data, entry_name, entry_length - 1);
6494 filename->data[entry_length-1] = '\0';
6495 zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6496 if (zipf == NULL)
6497 error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6498 else
6499 {
6500 ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6501 BUFFER_RESET (filename);
6502 for (k = 0; k < package_length; k++)
6503 {
6504 char ch = package_name[k];
6505 *filename->ptr++ = ch == '.' ? '/' : ch;
6506 }
6507 *filename->ptr++ = '/';
6508
345137c7 6509 for (k = 0; k < zipf->count; k++, zipd = ZIPDIR_NEXT (zipd))
63a212ed 6510 {
49f48c71 6511 const char *current_entry = ZIPDIR_FILENAME (zipd);
63a212ed
PB		 6512 int current_entry_len = zipd->filename_length;
6513
345137c7
TT		 6514 if (current_entry_len >= BUFFER_LENGTH (filename)
6515 && strncmp (filename->data, current_entry,
6516 BUFFER_LENGTH (filename)) != 0)
63a212ed 6517 continue;
345137c7 6518 found |= note_possible_classname (current_entry,
63a212ed
PB		 6519 current_entry_len);
6520 }
6521 }
6522 }
6523 else
6524 {
6525 BUFFER_RESET (filename);
6526 buffer_grow (filename, entry_length + package_length + 4);
6527 strcpy (filename->data, entry_name);
6528 filename->ptr = filename->data + entry_length;
6529 for (k = 0; k < package_length; k++)
6530 {
6531 char ch = package_name[k];
6532 *filename->ptr++ = ch == '.' ? '/' : ch;
6533 }
6534 *filename->ptr = '\0';
6535
6536 dirp = opendir (filename->data);
6537 if (dirp == NULL)
6538 continue;
6539 *filename->ptr++ = '/';
6540 for (;;)
6541 {
63a212ed 6542 int len;
49f48c71 6543 const char *d_name;
63a212ed
PB		 6544 struct dirent *direntp = readdir (dirp);
6545 if (!direntp)
6546 break;
6547 d_name = direntp->d_name;
6548 len = strlen (direntp->d_name);
6549 buffer_grow (filename, len+1);
6550 strcpy (filename->ptr, d_name);
345137c7 6551 found |= note_possible_classname (filename->data + entry_length,
63a212ed
PB		 6552 package_length+len+1);
6553 }
6554 if (dirp)
6555 closedir (dirp);
6556 }
6557 }
e04a16fb 6558
63a212ed 6559 free (filename->data);
e04a16fb 6560
63a212ed
PB		 6561 /* Here we should have a unified way of retrieving an entry, to be
6562 indexed. */
6563 if (!found)
e04a16fb
AG		 6564 {
6565 static int first = 1;
6566 if (first)
6567 {
781b0558 6568 error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives.", package_name);
e04a16fb
AG		 6569 java_error_count++;
6570 first = 0;
6571 }
6572 else
63a212ed
PB		 6573 parse_error_context (wfl, "Package `%s' not found in import",
6574 package_name);
e04a16fb
AG		 6575 current_jcf = saved_jcf;
6576 return;
6577 }
e04a16fb
AG		 6578 current_jcf = saved_jcf;
6579}
6580
6581/* Possibly find a type in the import on demands specified
6582 types. Returns 1 if an error occured, 0 otherwise. Run throught the
6583 entire list, to detected potential double definitions. */
6584
6585static int
6586find_in_imports_on_demand (class_type)
6587 tree class_type;
6588{
ab3a6dd6 6589 tree node, import, node_to_use = NULL_TREE;
e04a16fb 6590 int seen_once = -1;
ab3a6dd6 6591 tree cl = NULL_TREE;
e04a16fb
AG		 6592
6593 for (import = ctxp->import_demand_list; import; import = TREE_CHAIN (import))
6594 {
49f48c71 6595 const char *id_name;
e04a16fb
AG		 6596 obstack_grow (&temporary_obstack,
6597 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
6598 IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
63a212ed 6599 obstack_1grow (&temporary_obstack, '.');
e04a16fb
AG		 6600 obstack_grow0 (&temporary_obstack,
6601 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
6602 IDENTIFIER_LENGTH (TYPE_NAME (class_type)));
6603 id_name = obstack_finish (&temporary_obstack);
6604
6605 node = maybe_get_identifier (id_name);
6606 if (node && IS_A_CLASSFILE_NAME (node))
6607 {
6608 if (seen_once < 0)
6609 {
6610 cl = TREE_PURPOSE (import);
6611 seen_once = 1;
6612 node_to_use = node;
6613 }
6614 else
6615 {
6616 seen_once++;
6617 parse_error_context
6618 (import, "Type `%s' also potentially defined in package `%s'",
6619 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
6620 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))));
6621 }
6622 }
6623 }
6624
6625 if (seen_once == 1)
6626 {
6627 /* Setup lineno so that it refers to the line of the import (in
6628 case we parse a class file and encounter errors */
6629 tree decl;
6630 int saved_lineno = lineno;
6631 lineno = EXPR_WFL_LINENO (cl);
63a212ed 6632 TYPE_NAME (class_type) = node_to_use;
e04a16fb
AG		 6633 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6634 decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
6635 /* If there is no DECL set for the class or if the class isn't
6636 loaded and not seen in source yet, the load */
6637 if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
6638 && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
6639 load_class (node_to_use, 0);
6640 lineno = saved_lineno;
6641 return check_pkg_class_access (TYPE_NAME (class_type), cl);
6642 }
6643 else
6644 return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
6645}
6646
9a7ab4b3
APB		 6647/* Add package NAME to the list of package encountered so far. To
6648 speed up class lookup in do_resolve_class, we make sure a
6649 particular package is added only once. */
6650
6651static void
6652register_package (name)
6653 tree name;
6654{
6655 static struct hash_table _pht, *pht = NULL;
6656
6657 if (!pht)
6658 {
6659 hash_table_init (&_pht, hash_newfunc,
6660 java_hash_hash_tree_node, java_hash_compare_tree_node);
6661 pht = &_pht;
6662 }
6663
6664 if (!hash_lookup (pht, (const hash_table_key) name, FALSE, NULL))
6665 {
6666 package_list = chainon (package_list, build_tree_list (name, NULL));
6667 hash_lookup (pht, (const hash_table_key) name, TRUE, NULL);
6668 }
6669}
6670
5e942c50
APB		 6671static tree
6672resolve_package (pkg, next)
6673 tree pkg, *next;
6674{
c2952b01 6675 tree current, acc;
5e942c50 6676 tree type_name = NULL_TREE;
49f48c71 6677 const char *name = IDENTIFIER_POINTER (EXPR_WFL_NODE (pkg));
5e942c50
APB		 6678
6679 /* The trick is to determine when the package name stops and were
6680 the name of something contained in the package starts. Then we
6681 return a fully qualified name of what we want to get. */
6682
6683 /* Do a quick search on well known package names */
6684 if (!strncmp (name, "java.lang.reflect", 17))
6685 {
6686 *next =
6687 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg))));
6688 type_name = lookup_package_type (name, 17);
6689 }
6690 else if (!strncmp (name, "java.lang", 9))
6691 {
6692 *next = TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg)));
6693 type_name = lookup_package_type (name, 9);
6694 }
5e942c50 6695
2c56429a
APB		 6696 /* If we found something here, return */
6697 if (type_name)
6698 return type_name;
6699
6700 *next = EXPR_WFL_QUALIFICATION (pkg);
6701
6702 /* Try the current package. */
6703 if (ctxp->package && !strncmp (name, IDENTIFIER_POINTER (ctxp->package),
6704 IDENTIFIER_LENGTH (ctxp->package)))
6705 {
6706 type_name =
6707 lookup_package_type_and_set_next (name,
6708 IDENTIFIER_LENGTH (ctxp->package),
6709 next );
6710 if (type_name)
6711 return type_name;
6712 }
6713
6714 /* Search in imported package */
6715 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
6716 {
6717 tree current_pkg_name = EXPR_WFL_NODE (TREE_PURPOSE (current));
6718 int len = IDENTIFIER_LENGTH (current_pkg_name);
6719 if (!strncmp (name, IDENTIFIER_POINTER (current_pkg_name), len))
6720 {
6721 tree left, dummy;
6722
6723 breakdown_qualified (&left, &dummy, current_pkg_name);
6724 len = IDENTIFIER_LENGTH (left);
6725 type_name = lookup_package_type_and_set_next (name, len, next);
6726 if (type_name)
6727 break;
6728 }
6729 }
6730
c2952b01
APB		 6731 /* Try to progressively construct a type name */
6732 if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
6733 for (acc = NULL_TREE, current = EXPR_WFL_QUALIFICATION (pkg);
6734 current; current = TREE_CHAIN (current))
6735 {
6736 acc = merge_qualified_name (acc, EXPR_WFL_NODE (QUAL_WFL (current)));
6737 if ((type_name = resolve_no_layout (acc, NULL_TREE)))
6738 {
6739 type_name = acc;
6b48deee
APB		 6740 /* resolve_package should be used in a loop, hence we
6741 point at this one to naturally process the next one at
6742 the next iteration. */
6743 *next = current;
c2952b01
APB		 6744 break;
6745 }
6746 }
2c56429a
APB		 6747 return type_name;
6748}
6749
6750static tree
6751lookup_package_type_and_set_next (name, len, next)
49f48c71 6752 const char *name;
2c56429a
APB		 6753 int len;
6754 tree *next;
6755{
49f48c71 6756 const char *ptr;
2c56429a
APB		 6757 tree type_name = lookup_package_type (name, len);
6758
6759 if (!type_name)
6760 return NULL;
6761
6762 ptr = IDENTIFIER_POINTER (type_name);
6763 while (ptr && (ptr = strchr (ptr, '.')))
6764 {
6765 *next = TREE_CHAIN (*next);
6766 ptr++;
6767 }
5e942c50
APB		 6768 return type_name;
6769}
6770
6771static tree
6772lookup_package_type (name, from)
49f48c71 6773 const char *name;
5e942c50
APB		 6774 int from;
6775{
6776 char subname [128];
49f48c71 6777 const char *sub = &name[from+1];
5e942c50
APB		 6778 while (*sub != '.' && *sub)
6779 sub++;
6780 strncpy (subname, name, sub-name);
6781 subname [sub-name] = '\0';
6782 return get_identifier (subname);
6783}
6784
cf1748bf
APB		 6785static void
6786check_inner_class_access (decl, enclosing_type, cl)
6787 tree decl, enclosing_type, cl;
6788{
6789 /* We don't issue an error message when CL is null. CL can be null
6790 as a result of processing a JDEP crafted by
6791 source_start_java_method for the purpose of patching its parm
6792 decl. But the error would have been already trapped when fixing
6793 the method's signature. */
6794 if (!(cl && PURE_INNER_CLASS_DECL_P (decl) && CLASS_PRIVATE (decl))
6795 || (PURE_INNER_CLASS_DECL_P (enclosing_type)
6796 && common_enclosing_context_p (TREE_TYPE (enclosing_type),
6797 TREE_TYPE (decl)))
6798 || enclosing_context_p (TREE_TYPE (enclosing_type), TREE_TYPE (decl)))
6799 return;
6800
6801 parse_error_context (cl, "Can't access nested %s %s. Only public classes and interfaces in other packages can be accessed",
6802 (CLASS_INTERFACE (decl) ? "interface" : "class"),
6803 lang_printable_name (decl, 0));
6804}
6805
e04a16fb
AG		 6806/* Check that CLASS_NAME refers to a PUBLIC class. Return 0 if no
6807 access violations were found, 1 otherwise. */
6808
6809static int
6810check_pkg_class_access (class_name, cl)
6811 tree class_name;
6812 tree cl;
6813{
6814 tree type;
e04a16fb
AG		 6815
6816 if (!QUALIFIED_P (class_name) || !IDENTIFIER_CLASS_VALUE (class_name))
6817 return 0;
6818
6819 if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
6820 return 0;
6821
6822 if (!CLASS_PUBLIC (TYPE_NAME (type)))
6823 {
e28cd97b
APB		 6824 /* Access to a private class within the same package is
6825 allowed. */
6826 tree l, r;
6827 breakdown_qualified (&l, &r, class_name);
6828 if (l == ctxp->package)
6829 return 0;
6830
e04a16fb 6831 parse_error_context
781b0558 6832 (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
e04a16fb
AG		 6833 (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
6834 IDENTIFIER_POINTER (class_name));
6835 return 1;
6836 }
6837 return 0;
6838}
6839
6840/* Local variable declaration. */
6841
6842static void
6843declare_local_variables (modifier, type, vlist)
6844 int modifier;
6845 tree type;
6846 tree vlist;
6847{
c583dd46
APB		 6848 tree decl, current, saved_type;
6849 tree type_wfl = NULL_TREE;
e04a16fb 6850 int must_chain = 0;
c2952b01 6851 int final_p = 0;
e04a16fb 6852
2aa11e97 6853 /* Push a new block if statements were seen between the last time we
e04a16fb 6854 pushed a block and now. Keep a cound of block to close */
f099f336 6855 if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
e04a16fb 6856 {
f099f336 6857 tree body = GET_CURRENT_BLOCK (current_function_decl);
e04a16fb 6858 tree b = enter_block ();
f099f336 6859 BLOCK_EXPR_ORIGIN (b) = body;
e04a16fb
AG		 6860 }
6861
6862 if (modifier)
6863 {
6864 int i;
6865 for (i = 0; i <= 10; i++) if (1 << i & modifier) break;
c877974e 6866 if (modifier == ACC_FINAL)
c2952b01 6867 final_p = 1;
c877974e
APB		 6868 else
6869 {
6870 parse_error_context
6871 (ctxp->modifier_ctx [i],
6872 "Only `final' is allowed as a local variables modifier");
6873 return;
6874 }
e04a16fb
AG		 6875 }
6876
c583dd46
APB		 6877 /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
6878 hold the TYPE value if a new incomplete has to be created (as
6879 opposed to being found already existing and reused). */
6880 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
6881
6882 /* If TYPE is fully resolved and we don't have a reference, make one */
1886c9d8 6883 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
c583dd46
APB		 6884
6885 /* Go through all the declared variables */
6886 for (current = vlist, saved_type = type; current;
6887 current = TREE_CHAIN (current), type = saved_type)
e04a16fb 6888 {
c877974e 6889 tree other, real_type;
e04a16fb
AG		 6890 tree wfl = TREE_PURPOSE (current);
6891 tree name = EXPR_WFL_NODE (wfl);
6892 tree init = TREE_VALUE (current);
e04a16fb 6893
c583dd46
APB		 6894 /* Process NAME, as it may specify extra dimension(s) for it */
6895 type = build_array_from_name (type, type_wfl, name, &name);
6896
6897 /* Variable redefinition check */
6898 if ((other = lookup_name_in_blocks (name)))
6899 {
6900 variable_redefinition_error (wfl, name, TREE_TYPE (other),
6901 DECL_SOURCE_LINE (other));
6902 continue;
6903 }
6904
6905 /* Type adjustment. We may have just readjusted TYPE because
6906 the variable specified more dimensions. Make sure we have
6907 a reference if we can and don't have one already. */
1886c9d8 6908 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
c877974e
APB		 6909
6910 real_type = GET_REAL_TYPE (type);
c583dd46
APB		 6911 /* Never layout this decl. This will be done when its scope
6912 will be entered */
c877974e 6913 decl = build_decl (VAR_DECL, name, real_type);
c2952b01 6914 LOCAL_FINAL (decl) = final_p;
c583dd46
APB		 6915 BLOCK_CHAIN_DECL (decl);
6916
d4370213
APB		 6917 /* If doing xreferencing, replace the line number with the WFL
6918 compound value */
6919 if (flag_emit_xref)
6920 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
6921
e04a16fb
AG		 6922 /* Don't try to use an INIT statement when an error was found */
6923 if (init && java_error_count)
6924 init = NULL_TREE;
c583dd46
APB		 6925
6926 /* Add the initialization function to the current function's code */
6927 if (init)
e04a16fb 6928 {
c583dd46
APB		 6929 /* Name might have been readjusted */
6930 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
6931 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
6932 java_method_add_stmt (current_function_decl,
6933 build_debugable_stmt (EXPR_WFL_LINECOL (init),
6934 init));
6935 }
6936
6937 /* Setup dependency the type of the decl */
6938 if (must_chain)
6939 {
6940 jdep *dep;
6941 register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
6942 dep = CLASSD_LAST (ctxp->classd_list);
6943 JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
e04a16fb
AG		 6944 }
6945 }
6946 SOURCE_FRONTEND_DEBUG (("Defined locals"));
6947}
6948
6949/* Called during parsing. Build decls from argument list. */
6950
6951static void
6952source_start_java_method (fndecl)
6953 tree fndecl;
6954{
6955 tree tem;
6956 tree parm_decl;
6957 int i;
6958
79d13333
APB		 6959 if (!fndecl)
6960 return;
6961
e04a16fb
AG		 6962 current_function_decl = fndecl;
6963
6964 /* New scope for the function */
6965 enter_block ();
6966 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
de4c7b02 6967 tem != end_params_node; tem = TREE_CHAIN (tem), i++)
e04a16fb
AG		 6968 {
6969 tree type = TREE_VALUE (tem);
6970 tree name = TREE_PURPOSE (tem);
6971
23a79c61
APB		 6972 /* If type is incomplete. Create an incomplete decl and ask for
6973 the decl to be patched later */
e04a16fb
AG		 6974 if (INCOMPLETE_TYPE_P (type))
6975 {
6976 jdep *jdep;
c877974e
APB		 6977 tree real_type = GET_REAL_TYPE (type);
6978 parm_decl = build_decl (PARM_DECL, name, real_type);
23a79c61 6979 type = obtain_incomplete_type (type);
e04a16fb
AG		 6980 register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
6981 jdep = CLASSD_LAST (ctxp->classd_list);
6982 JDEP_MISC (jdep) = name;
6983 JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
6984 }
6985 else
6986 parm_decl = build_decl (PARM_DECL, name, type);
6987
c2952b01
APB		 6988 /* Remember if a local variable was declared final (via its
6989 TREE_LIST of type/name.) Set LOCAL_FINAL accordingly. */
6990 if (ARG_FINAL_P (tem))
6991 LOCAL_FINAL (parm_decl) = 1;
6992
e04a16fb
AG		 6993 BLOCK_CHAIN_DECL (parm_decl);
6994 }
6995 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
6996 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
6997 nreverse (tem);
6998 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
c2952b01 6999 DECL_MAX_LOCALS (current_function_decl) = i;
e04a16fb
AG		 7000}
7001
22eed1e6
APB		 7002/* Called during parsing. Creates an artificial method declaration. */
7003
7004static tree
7005create_artificial_method (class, flags, type, name, args)
7006 tree class;
7007 int flags;
7008 tree type, name, args;
7009{
22eed1e6
APB		 7010 tree mdecl;
7011
c2952b01 7012 java_parser_context_save_global ();
22eed1e6
APB		 7013 lineno = 0;
7014 mdecl = make_node (FUNCTION_TYPE);
7015 TREE_TYPE (mdecl) = type;
7016 TYPE_ARG_TYPES (mdecl) = args;
7017 mdecl = add_method (class, flags, name, build_java_signature (mdecl));
c2952b01 7018 java_parser_context_restore_global ();
22eed1e6
APB		 7019 DECL_ARTIFICIAL (mdecl) = 1;
7020 return mdecl;
7021}
7022
7023/* Starts the body if an artifical method. */
7024
7025static void
7026start_artificial_method_body (mdecl)
7027 tree mdecl;
7028{
7029 DECL_SOURCE_LINE (mdecl) = 1;
7030 DECL_SOURCE_LINE_MERGE (mdecl, 1);
7031 source_start_java_method (mdecl);
7032 enter_block ();
7033}
7034
7035static void
7036end_artificial_method_body (mdecl)
7037 tree mdecl;
7038{
7039 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block ();
7040 exit_block ();
7041}
7042
e04a16fb
AG		 7043/* Called during expansion. Push decls formerly built from argument
7044 list so they're usable during expansion. */
7045
7046static void
7047expand_start_java_method (fndecl)
7048 tree fndecl;
7049{
7050 tree tem, *ptr;
e04a16fb 7051
e04a16fb
AG		 7052 current_function_decl = fndecl;
7053
c2952b01
APB		 7054 if (! quiet_flag)
7055 fprintf (stderr, " [%s.", lang_printable_name (DECL_CONTEXT (fndecl), 0));
e04a16fb 7056 announce_function (fndecl);
c2952b01
APB		 7057 if (! quiet_flag)
7058 fprintf (stderr, "]");
7059
7060 pushlevel (1); /* Prepare for a parameter push */
e04a16fb
AG		 7061 ptr = &DECL_ARGUMENTS (fndecl);
7062 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7063 while (tem)
7064 {
7065 tree next = TREE_CHAIN (tem);
b67d701b 7066 tree type = TREE_TYPE (tem);
e438e1b7
JJ		 7067 if (PROMOTE_PROTOTYPES
7068 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
b67d701b
PB		 7069 && INTEGRAL_TYPE_P (type))
7070 type = integer_type_node;
b67d701b 7071 DECL_ARG_TYPE (tem) = type;
e04a16fb
AG		 7072 layout_decl (tem, 0);
7073 pushdecl (tem);
e04a16fb
AG		 7074 *ptr = tem;
7075 ptr = &TREE_CHAIN (tem);
7076 tem = next;
7077 }
7078 *ptr = NULL_TREE;
7079 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
7080 lineno = DECL_SOURCE_LINE_FIRST (fndecl);
e04a16fb
AG		 7081}
7082
7083/* Terminate a function and expand its body. */
7084
7085static void
7086source_end_java_method ()
7087{
7088 tree fndecl = current_function_decl;
138657ec 7089 int flag_asynchronous_exceptions = asynchronous_exceptions;
e04a16fb 7090
79d13333
APB		 7091 if (!fndecl)
7092 return;
7093
e04a16fb
AG		 7094 java_parser_context_save_global ();
7095 lineno = ctxp->last_ccb_indent1;
7096
b67d701b
PB		 7097 /* Set EH language codes */
7098 java_set_exception_lang_code ();
7099
5423609c
APB		 7100 /* Turn function bodies with only a NOP expr null, so they don't get
7101 generated at all and we won't get warnings when using the -W
7102 -Wall flags. */
7103 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7104 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7105
e04a16fb
AG		 7106 /* Generate function's code */
7107 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
e8fc7396
APB		 7108 && ! flag_emit_class_files
7109 && ! flag_emit_xref)
e04a16fb
AG		 7110 expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
7111
7112 /* pop out of its parameters */
7113 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
7114 poplevel (1, 0, 1);
7115 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
7116
7117 /* Generate rtl for function exit. */
e8fc7396 7118 if (! flag_emit_class_files && ! flag_emit_xref)
e04a16fb
AG		 7119 {
7120 lineno = DECL_SOURCE_LINE_LAST (fndecl);
b67d701b
PB		 7121 /* Emit catch-finally clauses */
7122 emit_handlers ();
e04a16fb
AG		 7123 expand_function_end (input_filename, lineno, 0);
7124
138657ec
AH		 7125 /* FIXME: If the current method contains any exception handlers,
7126 force asynchronous_exceptions: this is necessary because signal
7127 handlers in libjava may throw exceptions. This is far from being
7128 a perfect solution, but it's better than doing nothing at all.*/
7129 if (catch_clauses)
7130 asynchronous_exceptions = 1;
7131
e04a16fb
AG		 7132 /* Run the optimizers and output assembler code for this function. */
7133 rest_of_compilation (fndecl);
7134 }
7135
7136 current_function_decl = NULL_TREE;
8226320b 7137 permanent_allocation (1);
e04a16fb 7138 java_parser_context_restore_global ();
138657ec 7139 asynchronous_exceptions = flag_asynchronous_exceptions;
e04a16fb
AG		 7140}
7141
7142/* Record EXPR in the current function block. Complements compound
7143 expression second operand if necessary. */
7144
7145tree
7146java_method_add_stmt (fndecl, expr)
7147 tree fndecl, expr;
7148{
b771925e
APB		 7149 if (!GET_CURRENT_BLOCK (fndecl))
7150 return NULL_TREE;
f099f336 7151 return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
b67d701b 7152}
e04a16fb 7153
b67d701b
PB		 7154static tree
7155add_stmt_to_block (b, type, stmt)
7156 tree b, type, stmt;
7157{
7158 tree body = BLOCK_EXPR_BODY (b), c;
7159
e04a16fb
AG		 7160 if (java_error_count)
7161 return body;
b67d701b
PB		 7162
7163 if ((c = add_stmt_to_compound (body, type, stmt)) == body)
e04a16fb
AG		 7164 return body;
7165
b67d701b
PB		 7166 BLOCK_EXPR_BODY (b) = c;
7167 TREE_SIDE_EFFECTS (c) = 1;
7168 return c;
e04a16fb
AG		 7169}
7170
7171/* Add STMT to EXISTING if possible, otherwise create a new
7172 COMPOUND_EXPR and add STMT to it. */
7173
7174static tree
7175add_stmt_to_compound (existing, type, stmt)
7176 tree existing, type, stmt;
7177{
15fdcfe9
PB		 7178 if (existing)
7179 return build (COMPOUND_EXPR, type, existing, stmt);
e04a16fb 7180 else
15fdcfe9 7181 return stmt;
e04a16fb
AG		 7182}
7183
7184/* Hold THIS for the scope of the current public method decl. */
7185static tree current_this;
7186
1886c9d8
APB		 7187void java_layout_seen_class_methods ()
7188{
7189 tree previous_list = all_class_list;
7190 tree end = NULL_TREE;
7191 tree current;
7192
7193 while (1)
7194 {
7195 for (current = previous_list;
7196 current != end; current = TREE_CHAIN (current))
7197 layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7198
7199 if (previous_list != all_class_list)
7200 {
7201 end = previous_list;
7202 previous_list = all_class_list;
7203 }
7204 else
7205 break;
7206 }
7207}
7208
e04a16fb 7209void
c2952b01 7210java_reorder_fields ()
e04a16fb 7211{
c2952b01 7212 static tree stop_reordering = NULL_TREE;
23a79c61 7213
c2952b01 7214 tree current;
5e942c50 7215 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
e04a16fb 7216 {
5e942c50 7217 current_class = TREE_TYPE (TREE_VALUE (current));
22eed1e6 7218
c2952b01
APB		 7219 if (current_class == stop_reordering)
7220 break;
7221
c877974e
APB		 7222 /* Reverse the fields, but leave the dummy field in front.
7223 Fields are already ordered for Object and Class */
7224 if (TYPE_FIELDS (current_class) && current_class != object_type_node
7225 && current_class != class_type_node)
7226 {
23a79c61
APB		 7227 /* If the dummy field is there, reverse the right fields and
7228 just layout the type for proper fields offset */
c877974e
APB		 7229 if (!DECL_NAME (TYPE_FIELDS (current_class)))
7230 {
7231 tree fields = TYPE_FIELDS (current_class);
7232 TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7233 TYPE_SIZE (current_class) = NULL_TREE;
c877974e 7234 }
23a79c61
APB		 7235 /* We don't have a dummy field, we need to layout the class,
7236 after having reversed the fields */
c877974e
APB		 7237 else
7238 {
7239 TYPE_FIELDS (current_class) =
7240 nreverse (TYPE_FIELDS (current_class));
7241 TYPE_SIZE (current_class) = NULL_TREE;
c877974e
APB		 7242 }
7243 }
c2952b01
APB		 7244 }
7245 stop_reordering = TREE_TYPE (TREE_VALUE (ctxp->gclass_list));
7246}
7247
7248/* Layout the methods of all classes loaded in one way on an
7249 other. Check methods of source parsed classes. Then reorder the
7250 fields and layout the classes or the type of all source parsed
7251 classes */
7252
7253void
7254java_layout_classes ()
7255{
7256 tree current;
7257 int save_error_count = java_error_count;
7258
7259 /* Layout the methods of all classes seen so far */
7260 java_layout_seen_class_methods ();
7261 java_parse_abort_on_error ();
7262 all_class_list = NULL_TREE;
7263
7264 /* Then check the methods of all parsed classes */
7265 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
7266 if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7267 CHECK_METHODS (TREE_VALUE (current));
7268 java_parse_abort_on_error ();
7269
7270 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
7271 {
7272 current_class = TREE_TYPE (TREE_VALUE (current));
7273 layout_class (current_class);
5e942c50 7274
c877974e
APB		 7275 /* From now on, the class is considered completely loaded */
7276 CLASS_LOADED_P (current_class) = 1;
7277
5e942c50
APB		 7278 /* Error reported by the caller */
7279 if (java_error_count)
7280 return;
e04a16fb 7281 }
23a79c61
APB		 7282
7283 /* We might have reloaded classes durign the process of laying out
7284 classes for code generation. We must layout the methods of those
7285 late additions, as constructor checks might use them */
1886c9d8 7286 java_layout_seen_class_methods ();
23a79c61 7287 java_parse_abort_on_error ();
e04a16fb
AG		 7288}
7289
c2952b01
APB		 7290/* Expand methods in the current set of classes rememebered for
7291 generation. */
e04a16fb 7292
49f48c71 7293static void
c2952b01 7294java_complete_expand_classes ()
e04a16fb
AG		 7295{
7296 tree current;
ce6e9147
APB		 7297
7298 do_not_fold = flag_emit_xref;
c2952b01 7299
e04a16fb 7300 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
c2952b01
APB		 7301 if (!INNER_CLASS_DECL_P (current))
7302 java_complete_expand_class (current);
7303}
e04a16fb 7304
c2952b01
APB		 7305/* Expand the methods found in OUTER, starting first by OUTER's inner
7306 classes, if any. */
e04a16fb 7307
c2952b01
APB		 7308static void
7309java_complete_expand_class (outer)
7310 tree outer;
7311{
7312 tree inner_list;
e04a16fb 7313
c2952b01 7314 set_nested_class_simple_name_value (outer, 1); /* Set */
cd9643f7 7315
c2952b01
APB		 7316 /* We need to go after all inner classes and start expanding them,
7317 starting with most nested ones. We have to do that because nested
7318 classes might add functions to outer classes */
e04a16fb 7319
c2952b01
APB		 7320 for (inner_list = DECL_INNER_CLASS_LIST (outer);
7321 inner_list; inner_list = TREE_CHAIN (inner_list))
7322 java_complete_expand_class (TREE_PURPOSE (inner_list));
22eed1e6 7323
c2952b01
APB		 7324 java_complete_expand_methods (outer);
7325 set_nested_class_simple_name_value (outer, 0); /* Reset */
7326}
7327
7328/* Expand methods registered in CLASS_DECL. The general idea is that
7329 we expand regular methods first. This allows us get an estimate on
7330 how outer context local alias fields are really used so we can add
7331 to the constructor just enough code to initialize them properly (it
7332 also lets us generate $finit$ correctly.) Then we expand the
7333 constructors and then <clinit>. */
7334
7335static void
7336java_complete_expand_methods (class_decl)
7337 tree class_decl;
7338{
7339 tree clinit, finit, decl, first_decl;
7340
7341 current_class = TREE_TYPE (class_decl);
7342
7343 /* Initialize a new constant pool */
7344 init_outgoing_cpool ();
7345
7346 /* Pre-expand <clinit> to figure whether we really need it or
7347 not. If we do need it, we pre-expand the static fields so they're
7348 ready to be used somewhere else. <clinit> will be fully expanded
7349 after we processed the constructors. */
7350 first_decl = TYPE_METHODS (current_class);
7351 clinit = maybe_generate_pre_expand_clinit (current_class);
7352
7353 /* Then generate $finit$ (if we need to) because constructor will
7354 try to use it.*/
7355 if (TYPE_FINIT_STMT_LIST (current_class))
7356 {
7357 finit = generate_finit (current_class);
7358 java_complete_expand_method (finit);
7359 }
7360
7361 /* Now do the constructors */
7362 for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7363 {
7364 int no_body;
7365
7366 if (!DECL_CONSTRUCTOR_P (decl))
7367 continue;
7368
7369 no_body = !DECL_FUNCTION_BODY (decl);
7370 /* Don't generate debug info on line zero when expanding a
7371 generated constructor. */
7372 if (no_body)
7373 restore_line_number_status (1);
7374
7375 java_complete_expand_method (decl);
7376
7377 if (no_body)
7378 restore_line_number_status (0);
7379 }
7380
7381 /* First, do the ordinary methods. */
7382 for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7383 {
7145d9fe
TT		 7384 /* Skip abstract or native methods -- but do handle native
7385 methods when generating JNI stubs. */
7386 if (METHOD_ABSTRACT (decl)
7387 || (! flag_jni && METHOD_NATIVE (decl))
b7805411 7388 || DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
c2952b01 7389 continue;
7145d9fe
TT		 7390
7391 if (METHOD_NATIVE (decl))
7392 {
7393 tree body = build_jni_stub (decl);
7394 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7395 }
7396
c2952b01
APB		 7397 java_complete_expand_method (decl);
7398 }
7399
7400 /* If there is indeed a <clinit>, fully expand it now */
7401 if (clinit)
7402 {
7403 /* Prevent the use of `this' inside <clinit> */
7404 ctxp->explicit_constructor_p = 1;
7405 java_complete_expand_method (clinit);
7406 ctxp->explicit_constructor_p = 0;
e04a16fb 7407 }
c2952b01 7408
165f37bc
APB		 7409 /* We might have generated a class$ that we now want to expand */
7410 if (TYPE_DOT_CLASS (current_class))
7411 java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7412
c2952b01
APB		 7413 /* Now verify constructor circularity (stop after the first one we
7414 prove wrong.) */
7415 if (!CLASS_INTERFACE (class_decl))
7416 for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7417 if (DECL_CONSTRUCTOR_P (decl)
7418 && verify_constructor_circularity (decl, decl))
7419 break;
7420
7421 /* Save the constant pool. We'll need to restore it later. */
7422 TYPE_CPOOL (current_class) = outgoing_cpool;
e04a16fb
AG		 7423}
7424
b9f7e36c
APB		 7425/* Hold a list of catch clauses list. The first element of this list is
7426 the list of the catch clauses of the currently analysed try block. */
7427static tree currently_caught_type_list;
7428
c2952b01
APB		 7429/* Attempt to create <clinit>. Pre-expand static fields so they can be
7430 safely used in some other methods/constructors. */
e920ebc9 7431
c2952b01
APB		 7432static tree
7433maybe_generate_pre_expand_clinit (class_type)
7434 tree class_type;
e920ebc9 7435{
c2952b01
APB		 7436 tree current, mdecl;
7437
7438 if (!TYPE_CLINIT_STMT_LIST (class_type))
7439 return NULL_TREE;
e920ebc9 7440
c2952b01
APB		 7441 /* Go through all static fields and pre expand them */
7442 for (current = TYPE_FIELDS (class_type); current;
7443 current = TREE_CHAIN (current))
7444 if (FIELD_STATIC (current))
7445 build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7446
7447 /* Then build the <clinit> method */
7448 mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7449 clinit_identifier_node, end_params_node);
7450 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7451 mdecl, NULL_TREE);
7452 start_artificial_method_body (mdecl);
7453
7454 /* We process the list of assignment we produced as the result of
7455 the declaration of initialized static field and add them as
7456 statement to the <clinit> method. */
7457 for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7458 current = TREE_CHAIN (current))
e920ebc9 7459 {
9a7ab4b3 7460 tree stmt = current;
c2952b01
APB		 7461 /* We build the assignment expression that will initialize the
7462 field to its value. There are strict rules on static
7463 initializers (8.5). FIXME */
9a7ab4b3
APB		 7464 if (TREE_CODE (stmt) != BLOCK)
7465 stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
c2952b01
APB		 7466 java_method_add_stmt (mdecl, stmt);
7467 }
e920ebc9 7468
c2952b01
APB		 7469 end_artificial_method_body (mdecl);
7470
92d83515
APB		 7471 /* Now we want to place <clinit> as the last method (because we need
7472 it at least for interface so that it doesn't interfere with the
7473 dispatch table based lookup. */
7474 if (TREE_CHAIN (TYPE_METHODS (class_type)))
c2952b01 7475 {
92d83515
APB		 7476 current = TREE_CHAIN (TYPE_METHODS (class_type));
7477 TYPE_METHODS (class_type) = current;
c2952b01
APB		 7478
7479 while (TREE_CHAIN (current))
7480 current = TREE_CHAIN (current);
92d83515 7481
c2952b01
APB		 7482 TREE_CHAIN (current) = mdecl;
7483 TREE_CHAIN (mdecl) = NULL_TREE;
e920ebc9 7484 }
c2952b01
APB		 7485
7486 return mdecl;
e920ebc9
APB		 7487}
7488
92d83515
APB		 7489/* See whether we could get rid of <clinit>. Criteria are: all static
7490 final fields have constant initial values and the body of <clinit>
7491 is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7492
7493static int
7494maybe_yank_clinit (mdecl)
7495 tree mdecl;
7496{
7497 tree type, current;
7498 tree fbody, bbody;
7499
7500 if (!DECL_CLINIT_P (mdecl))
7501 return 0;
7502
7503 /* If the body isn't empty, then we keep <clinit> */
7504 fbody = DECL_FUNCTION_BODY (mdecl);
7505 if ((bbody = BLOCK_EXPR_BODY (fbody)))
7506 bbody = BLOCK_EXPR_BODY (bbody);
7507 if (bbody && bbody != empty_stmt_node)
7508 return 0;
7509
7510 type = DECL_CONTEXT (mdecl);
7511 current = TYPE_FIELDS (type);
7512
7513 for (current = (current ? TREE_CHAIN (current) : current);
7514 current; current = TREE_CHAIN (current))
7515 if (!(FIELD_STATIC (current) && FIELD_FINAL (current)
7516 && DECL_INITIAL (current) && TREE_CONSTANT (DECL_INITIAL (current))))
7517 break;
7518
7519 if (current)
7520 return 0;
7521
7522 /* Get rid of <clinit> in the class' list of methods */
7523 if (TYPE_METHODS (type) == mdecl)
7524 TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7525 else
7526 for (current = TYPE_METHODS (type); current;
7527 current = TREE_CHAIN (current))
7528 if (TREE_CHAIN (current) == mdecl)
7529 {
7530 TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7531 break;
7532 }
7533
7534 return 1;
7535}
7536
7537
e04a16fb
AG		 7538/* Complete and expand a method. */
7539
7540static void
7541java_complete_expand_method (mdecl)
7542 tree mdecl;
7543{
92d83515
APB		 7544 int yank_clinit = 0;
7545
c2952b01 7546 current_function_decl = mdecl;
22eed1e6
APB		 7547 /* Fix constructors before expanding them */
7548 if (DECL_CONSTRUCTOR_P (mdecl))
7549 fix_constructors (mdecl);
e04a16fb 7550
22eed1e6 7551 /* Expand functions that have a body */
e04a16fb
AG		 7552 if (DECL_FUNCTION_BODY (mdecl))
7553 {
9bbc7d9f
PB		 7554 tree fbody = DECL_FUNCTION_BODY (mdecl);
7555 tree block_body = BLOCK_EXPR_BODY (fbody);
cd531a2e 7556 tree exception_copy = NULL_TREE;
e04a16fb 7557 expand_start_java_method (mdecl);
939d7216 7558 build_result_decl (mdecl);
e04a16fb
AG		 7559
7560 current_this
7561 = (!METHOD_STATIC (mdecl) ?
7562 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
7563
ce6e9147
APB		 7564 /* Purge the `throws' list of unchecked exceptions. If we're
7565 doing xref, save a copy of the list and re-install it
7566 later. */
7567 if (flag_emit_xref)
7568 exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
7569
b9f7e36c
APB		 7570 purge_unchecked_exceptions (mdecl);
7571
7572 /* Install exceptions thrown with `throws' */
7573 PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
7574
9bbc7d9f 7575 if (block_body != NULL_TREE)
bc3ca41b
PB		 7576 {
7577 block_body = java_complete_tree (block_body);
c2952b01 7578
7145d9fe 7579 if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
ce6e9147 7580 check_for_initialization (block_body);
f099f336 7581 ctxp->explicit_constructor_p = 0;
bc3ca41b 7582 }
e803d3b2 7583
9bbc7d9f 7584 BLOCK_EXPR_BODY (fbody) = block_body;
5e942c50 7585
c2952b01
APB		 7586 /* If we saw a return but couldn't evaluate it properly, we'll
7587 have an error_mark_node here. */
7588 if (block_body != error_mark_node
7589 && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
ce6e9147
APB		 7590 && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
7591 && !flag_emit_xref)
82371d41 7592 missing_return_error (current_function_decl);
7525cc04 7593
92d83515
APB		 7594 /* Check wether we could just get rid of clinit, now the picture
7595 is complete. */
7596 if (!(yank_clinit = maybe_yank_clinit (mdecl)))
7597 complete_start_java_method (mdecl);
7598
e04a16fb 7599 /* Don't go any further if we've found error(s) during the
92d83515
APB		 7600 expansion */
7601 if (!java_error_count && !yank_clinit)
e04a16fb 7602 source_end_java_method ();
22eed1e6
APB		 7603 else
7604 {
92d83515
APB		 7605 if (java_error_count)
7606 pushdecl_force_head (DECL_ARGUMENTS (mdecl));
22eed1e6
APB		 7607 poplevel (1, 0, 1);
7608 }
b9f7e36c
APB		 7609
7610 /* Pop the exceptions and sanity check */
7611 POP_EXCEPTIONS();
7612 if (currently_caught_type_list)
7613 fatal ("Exception list non empty - java_complete_expand_method");
ce6e9147
APB		 7614
7615 if (flag_emit_xref)
7616 DECL_FUNCTION_THROWS (mdecl) = exception_copy;
e04a16fb
AG		 7617 }
7618}
7619
c2952b01
APB		 7620\f
7621
7622/* This section of the code deals with accessing enclosing context
7623 fields either directly by using the relevant access to this$<n> or
7624 by invoking an access method crafted for that purpose. */
7625
7626/* Build the necessary access from an inner class to an outer
7627 class. This routine could be optimized to cache previous result
7628 (decl, current_class and returned access). When an access method
7629 needs to be generated, it always takes the form of a read. It might
7630 be later turned into a write by calling outer_field_access_fix. */
7631
7632static tree
7633build_outer_field_access (id, decl)
7634 tree id, decl;
7635{
7636 tree access = NULL_TREE;
7637 tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
7638
7639 /* If decl's class is the direct outer class of the current_class,
7640 build the access as `this$<n>.<field>'. Not that we will break
7641 the `private' barrier if we're not emitting bytecodes. */
7642 if (ctx == DECL_CONTEXT (decl)
7643 && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
7644 {
7645 tree thisn = build_current_thisn (current_class);
7646 access = make_qualified_primary (build_wfl_node (thisn),
7647 id, EXPR_WFL_LINECOL (id));
7648 }
7649 /* Otherwise, generate access methods to outer this and access the
7650 field (either using an access method or by direct access.) */
7651 else
7652 {
7653 int lc = EXPR_WFL_LINECOL (id);
7654
7655 /* Now we chain the required number of calls to the access$0 to
7656 get a hold to the enclosing instance we need, and the we
7657 build the field access. */
7658 access = build_access_to_thisn (ctx, DECL_CONTEXT (decl), lc);
7659
7660 /* If the field is private and we're generating bytecode, then
7661 we generate an access method */
7662 if (FIELD_PRIVATE (decl) && flag_emit_class_files )
7663 {
7664 tree name = build_outer_field_access_methods (decl);
7665 access = build_outer_field_access_expr (lc, DECL_CONTEXT (decl),
7666 name, access, NULL_TREE);
7667 }
7668 /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
7669 Once again we break the `private' access rule from a foreign
7670 class. */
7671 else
7672 access = make_qualified_primary (access, id, lc);
7673 }
7674 return resolve_expression_name (access, NULL);
7675}
7676
7677/* Return a non zero value if NODE describes an outer field inner
7678 access. */
7679
7680static int
7681outer_field_access_p (type, decl)
7682 tree type, decl;
7683{
7684 if (!INNER_CLASS_TYPE_P (type)
7685 || TREE_CODE (decl) != FIELD_DECL
7686 || DECL_CONTEXT (decl) == type)
7687 return 0;
7688
7689 for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
7690 type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
7691 {
7692 if (type == DECL_CONTEXT (decl))
7693 return 1;
7694 if (!DECL_CONTEXT (TYPE_NAME (type)))
7695 break;
7696 }
7697
7698 return 0;
7699}
7700
7701/* Return a non zero value if NODE represents an outer field inner
7702 access that was been already expanded. As a side effect, it returns
7703 the name of the field being accessed and the argument passed to the
7704 access function, suitable for a regeneration of the access method
7705 call if necessary. */
7706
7707static int
7708outer_field_expanded_access_p (node, name, arg_type, arg)
7709 tree node, *name, *arg_type, *arg;
7710{
7711 int identified = 0;
7712
7713 if (TREE_CODE (node) != CALL_EXPR)
7714 return 0;
7715
7716 /* Well, gcj generates slightly different tree nodes when compiling
7717 to native or bytecodes. It's the case for function calls. */
7718
7719 if (flag_emit_class_files
7720 && TREE_CODE (node) == CALL_EXPR
7721 && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
7722 identified = 1;
7723 else if (!flag_emit_class_files)
7724 {
7725 node = TREE_OPERAND (node, 0);
7726
7727 if (node && TREE_OPERAND (node, 0)
7728 && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
7729 {
7730 node = TREE_OPERAND (node, 0);
7731 if (TREE_OPERAND (node, 0)
7732 && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
7733 && (OUTER_FIELD_ACCESS_IDENTIFIER_P
7734 (DECL_NAME (TREE_OPERAND (node, 0)))))
7735 identified = 1;
7736 }
7737 }
7738
7739 if (identified && name && arg_type && arg)
7740 {
7741 tree argument = TREE_OPERAND (node, 1);
7742 *name = DECL_NAME (TREE_OPERAND (node, 0));
7743 *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
7744 *arg = TREE_VALUE (argument);
7745 }
7746 return identified;
7747}
7748
7749/* Detect in NODE an outer field read access from an inner class and
7750 transform it into a write with RHS as an argument. This function is
7751 called from the java_complete_lhs when an assignment to a LHS can
7752 be identified. */
7753
7754static tree
7755outer_field_access_fix (wfl, node, rhs)
7756 tree wfl, node, rhs;
7757{
7758 tree name, arg_type, arg;
7759
7760 if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
7761 {
7762 /* At any rate, check whether we're trying to assign a value to
7763 a final. */
7764 tree accessed = (JDECL_P (node) ? node :
7765 (TREE_CODE (node) == COMPONENT_REF ?
7766 TREE_OPERAND (node, 1) : node));
7767 if (check_final_assignment (accessed, wfl))
7768 return error_mark_node;
7769
7770 node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
7771 arg_type, name, arg, rhs);
7772 return java_complete_tree (node);
7773 }
7774 return NULL_TREE;
7775}
7776
7777/* Construct the expression that calls an access method:
7778 <type>.access$<n>(<arg1> [, <arg2>]);
7779
7780 ARG2 can be NULL and will be omitted in that case. It will denote a
7781 read access. */
7782
7783static tree
7784build_outer_field_access_expr (lc, type, access_method_name, arg1, arg2)
7785 int lc;
7786 tree type, access_method_name, arg1, arg2;
7787{
7788 tree args, cn, access;
7789
7790 args = arg1 ? arg1 :
7791 build_wfl_node (build_current_thisn (current_class));
7792 args = build_tree_list (NULL_TREE, args);
7793
7794 if (arg2)
7795 args = tree_cons (NULL_TREE, arg2, args);
7796
7797 access = build_method_invocation (build_wfl_node (access_method_name), args);
7798 cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
7799 return make_qualified_primary (cn, access, lc);
7800}
7801
7802static tree
7803build_new_access_id ()
7804{
7805 static int access_n_counter = 1;
7806 char buffer [128];
7807
7808 sprintf (buffer, "access$%d", access_n_counter++);
7809 return get_identifier (buffer);
7810}
7811
7812/* Create the static access functions for the outer field DECL. We define a
7813 read:
7814 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
7815 return inst$.field;
7816 }
7817 and a write access:
7818 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
7819 TREE_TYPE (<field>) value$) {
7820 return inst$.field = value$;
7821 }
7822 We should have a usage flags on the DECL so we can lazily turn the ones
7823 we're using for code generation. FIXME.
7824*/
7825
7826static tree
7827build_outer_field_access_methods (decl)
7828 tree decl;
7829{
7830 tree id, args, stmt, mdecl;
7831
7832 /* Check point, to be removed. FIXME */
7833 if (FIELD_INNER_ACCESS (decl)
7834 && TREE_CODE (FIELD_INNER_ACCESS (decl)) != IDENTIFIER_NODE)
7835 abort ();
7836
7837 if (FIELD_INNER_ACCESS (decl))
7838 return FIELD_INNER_ACCESS (decl);
7839
7840 push_obstacks (&permanent_obstack, &permanent_obstack);
7841
7842 /* Create the identifier and a function named after it. */
7843 id = build_new_access_id ();
7844
7845 /* The identifier is marked as bearing the name of a generated write
7846 access function for outer field accessed from inner classes. */
7847 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
7848
7849 /* Create the read access */
7850 args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
7851 TREE_CHAIN (args) = end_params_node;
7852 stmt = make_qualified_primary (build_wfl_node (inst_id),
7853 build_wfl_node (DECL_NAME (decl)), 0);
7854 stmt = build_return (0, stmt);
7855 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
7856 TREE_TYPE (decl), id, args, stmt);
7857 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
7858
7859 /* Create the write access method */
7860 args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
7861 TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
7862 TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
7863 stmt = make_qualified_primary (build_wfl_node (inst_id),
7864 build_wfl_node (DECL_NAME (decl)), 0);
7865 stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
7866 build_wfl_node (wpv_id)));
7867
7868 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
7869 TREE_TYPE (decl), id, args, stmt);
7870 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
7871 pop_obstacks ();
7872
7873 /* Return the access name */
7874 return FIELD_INNER_ACCESS (decl) = id;
7875}
7876
7877/* Build an field access method NAME. */
7878
7879static tree
7880build_outer_field_access_method (class, type, name, args, body)
7881 tree class, type, name, args, body;
7882{
7883 tree saved_current_function_decl, mdecl;
7884
7885 /* Create the method */
7886 mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
7887 fix_method_argument_names (args, mdecl);
7888 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
7889
7890 /* Attach the method body. */
7891 saved_current_function_decl = current_function_decl;
7892 start_artificial_method_body (mdecl);
7893 java_method_add_stmt (mdecl, body);
7894 end_artificial_method_body (mdecl);
7895 current_function_decl = saved_current_function_decl;
7896
7897 return mdecl;
7898}
7899
7900\f
7901/* This section deals with building access function necessary for
7902 certain kinds of method invocation from inner classes. */
7903
7904static tree
7905build_outer_method_access_method (decl)
7906 tree decl;
7907{
7908 tree saved_current_function_decl, mdecl;
7909 tree args = NULL_TREE, call_args = NULL_TREE;
7910 tree carg, id, body, class;
7911 char buffer [80];
7912 int parm_id_count = 0;
7913
7914 /* Test this abort with an access to a private field */
7915 if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
7916 abort ();
7917
7918 /* Check the cache first */
7919 if (DECL_FUNCTION_INNER_ACCESS (decl))
7920 return DECL_FUNCTION_INNER_ACCESS (decl);
7921
7922 class = DECL_CONTEXT (decl);
7923
7924 /* Obtain an access identifier and mark it */
7925 id = build_new_access_id ();
7926 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
7927
7928 push_obstacks (&permanent_obstack, &permanent_obstack);
7929
7930 carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
7931 /* Create the arguments, as much as the original */
7932 for (; carg && carg != end_params_node;
7933 carg = TREE_CHAIN (carg))
7934 {
7935 sprintf (buffer, "write_parm_value$%d", parm_id_count++);
7936 args = chainon (args, build_tree_list (get_identifier (buffer),
7937 TREE_VALUE (carg)));
7938 }
7939 args = chainon (args, end_params_node);
7940
7941 /* Create the method */
7942 mdecl = create_artificial_method (class, ACC_STATIC,
7943 TREE_TYPE (TREE_TYPE (decl)), id, args);
7944 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
7945 /* There is a potential bug here. We should be able to use
7946 fix_method_argument_names, but then arg names get mixed up and
7947 eventually a constructor will have its this$0 altered and the
7948 outer context won't be assignment properly. The test case is
7949 stub.java FIXME */
7950 TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
7951
7952 /* Attach the method body. */
7953 saved_current_function_decl = current_function_decl;
7954 start_artificial_method_body (mdecl);
7955
7956 /* The actual method invocation uses the same args. When invoking a
7957 static methods that way, we don't want to skip the first
7958 argument. */
7959 carg = args;
7960 if (!METHOD_STATIC (decl))
7961 carg = TREE_CHAIN (carg);
7962 for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
7963 call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
7964 call_args);
7965
7966 body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
7967 call_args);
7968 if (!METHOD_STATIC (decl))
7969 body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
7970 body, 0);
7971 if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
7972 body = build_return (0, body);
7973 java_method_add_stmt (mdecl,body);
7974 end_artificial_method_body (mdecl);
7975 current_function_decl = saved_current_function_decl;
7976 pop_obstacks ();
7977
7978 /* Back tag the access function so it know what it accesses */
7979 DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
7980
7981 /* Tag the current method so it knows it has an access generated */
7982 return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
7983}
7984
7985\f
7986/* This section of the code deals with building expressions to access
7987 the enclosing instance of an inner class. The enclosing instance is
7988 kept in a generated field called this$<n>, with <n> being the
7989 inner class nesting level (starting from 0.) */
7990
7991/* Build an access to a given this$<n>, possibly by chaining access
7992 call to others. Access methods to this$<n> are build on the fly if
7993 necessary */
7994
7995static tree
7996build_access_to_thisn (from, to, lc)
7997 tree from, to;
7998 int lc;
7999{
8000 tree access = NULL_TREE;
8001
8002 while (from != to)
8003 {
8004 tree access0_wfl, cn;
8005
8006 maybe_build_thisn_access_method (from);
8007 access0_wfl = build_wfl_node (access0_identifier_node);
8008 cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8009 EXPR_WFL_LINECOL (access0_wfl) = lc;
8010
8011 if (!access)
8012 {
8013 access = build_current_thisn (current_class);
8014 access = build_wfl_node (access);
8015 }
8016 access = build_tree_list (NULL_TREE, access);
8017 access = build_method_invocation (access0_wfl, access);
8018 access = make_qualified_primary (cn, access, lc);
8019
8020 from = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (from)));
8021 }
8022 return access;
8023}
8024
8025/* Build an access function to the this$<n> local to TYPE. NULL_TREE
8026 is returned if nothing needs to be generated. Otherwise, the method
152de068 8027 generated and a method decl is returned.
c2952b01
APB		 8028
8029 NOTE: These generated methods should be declared in a class file
8030 attribute so that they can't be referred to directly. */
8031
8032static tree
8033maybe_build_thisn_access_method (type)
8034 tree type;
8035{
8036 tree mdecl, args, stmt, rtype;
8037 tree saved_current_function_decl;
8038
8039 /* If TYPE is a top-level class, no access method is required.
8040 If there already is such an access method, bail out. */
8041 if (CLASS_ACCESS0_GENERATED_P (type) || !INNER_CLASS_TYPE_P (type))
8042 return NULL_TREE;
8043
8044 /* We generate the method. The method looks like:
8045 static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8046 */
8047 push_obstacks (&permanent_obstack, &permanent_obstack);
8048 args = build_tree_list (inst_id, build_pointer_type (type));
8049 TREE_CHAIN (args) = end_params_node;
8050 rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8051 mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8052 access0_identifier_node, args);
8053 fix_method_argument_names (args, mdecl);
8054 layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8055 stmt = build_current_thisn (type);
8056 stmt = make_qualified_primary (build_wfl_node (inst_id),
8057 build_wfl_node (stmt), 0);
8058 stmt = build_return (0, stmt);
8059
8060 saved_current_function_decl = current_function_decl;
8061 start_artificial_method_body (mdecl);
8062 java_method_add_stmt (mdecl, stmt);
8063 end_artificial_method_body (mdecl);
8064 current_function_decl = saved_current_function_decl;
8065 pop_obstacks ();
8066
8067 CLASS_ACCESS0_GENERATED_P (type) = 1;
8068
8069 return mdecl;
8070}
8071
8072/* Craft an correctly numbered `this$<n>'string. this$0 is used for
8073 the first level of innerclassing. this$1 for the next one, etc...
8074 This function can be invoked with TYPE to NULL, available and then
8075 has to count the parser context. */
8076
8077static tree
8078build_current_thisn (type)
8079 tree type;
8080{
8081 static int saved_i = -1;
8082 static tree saved_thisn = NULL_TREE;
8083
8084 tree decl;
8085 char buffer [80];
8086 int i = 0;
8087
8088 if (type)
8089 {
8090 static tree saved_type = NULL_TREE;
8091 static int saved_type_i = 0;
8092
8093 if (type == saved_type)
8094 i = saved_type_i;
8095 else
8096 {
8097 for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8098 decl; decl = DECL_CONTEXT (decl), i++)
8099 ;
8100
8101 saved_type = type;
8102 saved_type_i = i;
8103 }
8104 }
8105 else
8106 i = list_length (GET_CPC_LIST ())-2;
8107
8108 if (i == saved_i)
8109 return saved_thisn;
8110
8111 sprintf (buffer, "this$%d", i);
8112 saved_i = i;
8113 saved_thisn = get_identifier (buffer);
8114 return saved_thisn;
8115}
8116
8117/* Return the assignement to the hidden enclosing context `this$<n>'
8118 by the second incoming parameter to the innerclass constructor. The
8119 form used is `this.this$<n> = this$<n>;'. */
8120
8121static tree
8122build_thisn_assign ()
8123{
8124 if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8125 {
8126 tree thisn = build_current_thisn (current_class);
8127 tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8128 build_wfl_node (thisn), 0);
8129 tree rhs = build_wfl_node (thisn);
8130 EXPR_WFL_SET_LINECOL (lhs, lineno, 0);
8131 return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8132 }
8133 return NULL_TREE;
8134}
8135
8136\f
165f37bc
APB		 8137/* Building the synthetic `class$' used to implement the `.class' 1.1
8138 extension for non primitive types. This method looks like:
8139
8140 static Class class$(String type) throws NoClassDefFoundError
8141 {
8142 try {return (java.lang.Class.forName (String));}
8143 catch (ClassNotFoundException e) {
8144 throw new NoClassDefFoundError(e.getMessage());}
8145 } */
8146
8147static tree
8148build_dot_class_method (class)
8149 tree class;
8150{
8151#define BWF(S) build_wfl_node (get_identifier ((S)))
8152#define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8153 tree args, tmp, saved_current_function_decl, mdecl;
8154 tree stmt, throw_stmt, catch, catch_block, try_block;
8155 tree catch_clause_param;
8156 tree class_not_found_exception, no_class_def_found_error;
8157
8158 static tree get_message_wfl, type_parm_wfl;
8159
8160 if (!get_message_wfl)
8161 {
8162 get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8163 type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8164 }
8165
8166 /* Build the arguments */
8167 args = build_tree_list (get_identifier ("type$"),
8168 build_pointer_type (string_type_node));
8169 TREE_CHAIN (args) = end_params_node;
8170
8171 /* Build the qualified name java.lang.Class.forName */
8172 tmp = MQN (MQN (MQN (BWF ("java"),
8173 BWF ("lang")), BWF ("Class")), BWF ("forName"));
8174
8175 /* For things we have to catch and throw */
8176 class_not_found_exception =
8177 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
8178 no_class_def_found_error =
8179 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
8180 load_class (class_not_found_exception, 1);
8181 load_class (no_class_def_found_error, 1);
8182
8183 /* Create the "class$" function */
8184 mdecl = create_artificial_method (class, ACC_STATIC,
8185 build_pointer_type (class_type_node),
8186 get_identifier ("class$"), args);
8187 DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
8188 no_class_def_found_error);
8189
8190 /* We start by building the try block. We need to build:
8191 return (java.lang.Class.forName (type)); */
8192 stmt = build_method_invocation (tmp,
8193 build_tree_list (NULL_TREE, type_parm_wfl));
8194 stmt = build_return (0, stmt);
8195 /* Put it in a block. That's the try block */
8196 try_block = build_expr_block (stmt, NULL_TREE);
8197
8198 /* Now onto the catch block. We start by building the expression
8199 throwing a new exception:
8200 throw new NoClassDefFoundError (_.getMessage); */
8201 throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8202 get_message_wfl, 0);
8203 throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8204
8205 /* Build new NoClassDefFoundError (_.getMessage) */
8206 throw_stmt = build_new_invocation
8207 (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8208 build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8209
8210 /* Build the throw, (it's too early to use BUILD_THROW) */
8211 throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8212
8213 /* Build the catch block to encapsulate all this. We begin by
8214 building an decl for the catch clause parameter and link it to
8215 newly created block, the catch block. */
8216 catch_clause_param =
8217 build_decl (VAR_DECL, wpv_id,
8218 build_pointer_type (class_not_found_exception));
8219 catch_block = build_expr_block (NULL_TREE, catch_clause_param);
8220
8221 /* We initialize the variable with the exception handler. */
8222 catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
8223 soft_exceptioninfo_call_node);
8224 add_stmt_to_block (catch_block, NULL_TREE, catch);
8225
8226 /* We add the statement throwing the new exception */
8227 add_stmt_to_block (catch_block, NULL_TREE, throw_stmt);
8228
8229 /* Build a catch expression for all this */
8230 catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
8231
8232 /* Build the try/catch sequence */
8233 stmt = build_try_statement (0, try_block, catch_block);
8234
8235 fix_method_argument_names (args, mdecl);
8236 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8237 saved_current_function_decl = current_function_decl;
8238 start_artificial_method_body (mdecl);
8239 java_method_add_stmt (mdecl, stmt);
8240 end_artificial_method_body (mdecl);
8241 current_function_decl = saved_current_function_decl;
8242 TYPE_DOT_CLASS (class) = mdecl;
8243
8244 return mdecl;
8245}
8246
8247static tree
8248build_dot_class_method_invocation (name)
8249 tree name;
8250{
8251 tree s = make_node (STRING_CST);
8252 TREE_STRING_LENGTH (s) = IDENTIFIER_LENGTH (name);
8253 TREE_STRING_POINTER (s) = obstack_alloc (expression_obstack,
8254 TREE_STRING_LENGTH (s)+1);
8255 strcpy (TREE_STRING_POINTER (s), IDENTIFIER_POINTER (name));
8256 return build_method_invocation (build_wfl_node (get_identifier ("class$")),
8257 build_tree_list (NULL_TREE, s));
8258}
8259
c2952b01
APB		 8260/* This section of the code deals with constructor. */
8261
22eed1e6
APB		 8262/* Craft a body for default constructor. Patch existing constructor
8263 bodies with call to super() and field initialization statements if
8264 necessary. */
8265
8266static void
8267fix_constructors (mdecl)
8268 tree mdecl;
8269{
8270 tree body = DECL_FUNCTION_BODY (mdecl);
c2952b01
APB		 8271 tree thisn_assign, compound = NULL_TREE;
8272 tree class_type = DECL_CONTEXT (mdecl);
22eed1e6 8273
22eed1e6
APB		 8274 if (!body)
8275 {
22eed1e6
APB		 8276 /* It is an error for the compiler to generate a default
8277 constructor if the superclass doesn't have a constructor that
c2952b01
APB		 8278 takes no argument, or the same args for an anonymous class */
8279 if (verify_constructor_super (mdecl))
22eed1e6 8280 {
c2952b01
APB		 8281 tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8282 tree save = DECL_NAME (mdecl);
49f48c71 8283 const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
c2952b01 8284 DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
781b0558 8285 parse_error_context
c2952b01
APB		 8286 (lookup_cl (TYPE_NAME (class_type)),
8287 "No constructor matching `%s' found in class `%s'",
8288 lang_printable_name (mdecl, 0), n);
8289 DECL_NAME (mdecl) = save;
22eed1e6
APB		 8290 }
8291
c2952b01
APB		 8292 /* The constructor body must be crafted by hand. It's the
8293 constructor we defined when we realize we didn't have the
8294 CLASSNAME() constructor */
22eed1e6
APB		 8295 start_artificial_method_body (mdecl);
8296
8297 /* We don't generate a super constructor invocation if we're
8298 compiling java.lang.Object. build_super_invocation takes care
8299 of that. */
e920ebc9 8300 compound = java_method_add_stmt (mdecl, build_super_invocation (mdecl));
22eed1e6 8301
c2952b01
APB		 8302 /* Insert the instance initializer block right here, after the
8303 super invocation. */
8304 add_instance_initializer (mdecl);
8305
8306 /* Insert an assignment to the this$<n> hidden field, if
8307 necessary */
8308 if ((thisn_assign = build_thisn_assign ()))
8309 java_method_add_stmt (mdecl, thisn_assign);
8310
22eed1e6
APB		 8311 end_artificial_method_body (mdecl);
8312 }
8313 /* Search for an explicit constructor invocation */
8314 else
8315 {
8316 int found = 0;
8317 tree main_block = BLOCK_EXPR_BODY (body);
22eed1e6
APB		 8318
8319 while (body)
8320 switch (TREE_CODE (body))
8321 {
8322 case CALL_EXPR:
8323 found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8324 body = NULL_TREE;
8325 break;
8326 case COMPOUND_EXPR:
8327 case EXPR_WITH_FILE_LOCATION:
8328 body = TREE_OPERAND (body, 0);
8329 break;
8330 case BLOCK:
8331 body = BLOCK_EXPR_BODY (body);
8332 break;
8333 default:
8334 found = 0;
8335 body = NULL_TREE;
8336 }
8337 /* The constructor is missing an invocation of super() */
8338 if (!found)
8339 compound = add_stmt_to_compound (compound, NULL_TREE,
c2952b01 8340 build_super_invocation (mdecl));
22eed1e6 8341
c2952b01
APB		 8342 /* Insert the instance initializer block right here, after the
8343 super invocation. */
8344 add_instance_initializer (mdecl);
8345
8346 /* Generate the assignment to this$<n>, if necessary */
8347 if ((thisn_assign = build_thisn_assign ()))
8348 compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8349
22eed1e6
APB		 8350 /* Fix the constructor main block if we're adding extra stmts */
8351 if (compound)
8352 {
8353 compound = add_stmt_to_compound (compound, NULL_TREE,
8354 BLOCK_EXPR_BODY (main_block));
8355 BLOCK_EXPR_BODY (main_block) = compound;
8356 }
8357 }
8358}
8359
8360/* Browse constructors in the super class, searching for a constructor
8361 that doesn't take any argument. Return 0 if one is found, 1
c2952b01
APB		 8362 otherwise. If the current class is an anonymous inner class, look
8363 for something that has the same signature. */
22eed1e6
APB		 8364
8365static int
c2952b01
APB		 8366verify_constructor_super (mdecl)
8367 tree mdecl;
22eed1e6
APB		 8368{
8369 tree class = CLASSTYPE_SUPER (current_class);
152de068 8370 int super_inner = PURE_INNER_CLASS_TYPE_P (class);
c2952b01
APB		 8371 tree sdecl;
8372
22eed1e6
APB		 8373 if (!class)
8374 return 0;
8375
c2952b01 8376 if (ANONYMOUS_CLASS_P (current_class))
22eed1e6 8377 {
c2952b01
APB		 8378 tree mdecl_arg_type;
8379 SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8380 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8381 if (DECL_CONSTRUCTOR_P (sdecl))
8382 {
152de068
APB		 8383 tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8384 if (super_inner)
8385 arg_type = TREE_CHAIN (arg_type);
8386 for (; (arg_type != end_params_node
8387 && mdecl_arg_type != end_params_node);
c2952b01
APB		 8388 arg_type = TREE_CHAIN (arg_type),
8389 mdecl_arg_type = TREE_CHAIN (mdecl_arg_type))
8390 if (TREE_VALUE (arg_type) != TREE_VALUE (mdecl_arg_type))
8391 break;
8392
8393 if (arg_type == end_params_node &&
8394 mdecl_arg_type == end_params_node)
8395 return 0;
8396 }
8397 }
8398 else
8399 {
8400 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
22eed1e6 8401 {
152de068
APB		 8402 tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8403 if (super_inner)
8404 arg = TREE_CHAIN (arg);
8405 if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
22eed1e6
APB		 8406 return 0;
8407 }
8408 }
8409 return 1;
8410}
8411
22eed1e6 8412/* Generate code for all context remembered for code generation. */
b351b287
APB		 8413
8414void
8415java_expand_classes ()
8416{
5423609c 8417 int save_error_count = 0;
c2952b01
APB		 8418 static struct parser_ctxt *saved_ctxp = NULL;
8419
23a79c61
APB		 8420 java_parse_abort_on_error ();
8421 if (!(ctxp = ctxp_for_generation))
5e942c50
APB		 8422 return;
8423 java_layout_classes ();
8424 java_parse_abort_on_error ();
8425
c2952b01 8426 saved_ctxp = ctxp_for_generation;
b351b287
APB		 8427 for (; ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8428 {
8429 ctxp = ctxp_for_generation;
8430 lang_init_source (2); /* Error msgs have method prototypes */
c2952b01 8431 java_complete_expand_classes (); /* Complete and expand classes */
b351b287
APB		 8432 java_parse_abort_on_error ();
8433 }
c2952b01
APB		 8434
8435 /* Find anonymous classes and expand their constructor, now they
8436 have been fixed. */
8437 for (ctxp_for_generation = saved_ctxp;
8438 ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8439 {
8440 tree current;
8441 ctxp = ctxp_for_generation;
8442 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8443 {
8444 current_class = TREE_TYPE (current);
8445 if (ANONYMOUS_CLASS_P (current_class))
8446 {
8447 tree d;
8448 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
8449 {
8450 if (DECL_CONSTRUCTOR_P (d))
8451 {
8452 restore_line_number_status (1);
8453 reset_method_name (d);
8454 java_complete_expand_method (d);
8455 restore_line_number_status (0);
8456 break; /* We now there are no other ones */
8457 }
8458 }
8459 }
8460 }
8461 }
8462
8463 /* If we've found error at that stage, don't try to generate
8464 anything, unless we're emitting xrefs or checking the syntax only
8465 (but not using -fsyntax-only for the purpose of generating
8466 bytecode. */
8467 if (java_error_count && !flag_emit_xref
8468 && (!flag_syntax_only && !flag_emit_class_files))
8469 return;
8470
8471 /* Now things are stable, go for generation of the class data. */
8472 for (ctxp_for_generation = saved_ctxp;
8473 ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8474 {
8475 tree current;
8476 ctxp = ctxp_for_generation;
8477 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8478 {
8479 current_class = TREE_TYPE (current);
8480 outgoing_cpool = TYPE_CPOOL (current_class);
8481 if (flag_emit_class_files)
8482 write_classfile (current_class);
8483 if (flag_emit_xref)
8484 expand_xref (current_class);
8485 else if (! flag_syntax_only)
8486 finish_class ();
8487 }
8488 }
b351b287
APB		 8489}
8490
e04a16fb
AG		 8491/* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
8492 a tree list node containing RIGHT. Fore coming RIGHTs will be
8493 chained to this hook. LOCATION contains the location of the
8494 separating `.' operator. */
8495
8496static tree
8497make_qualified_primary (primary, right, location)
8498 tree primary, right;
8499 int location;
8500{
8501 tree wfl;
8502
c2952b01 8503 if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9a7ab4b3 8504 wfl = build_wfl_wrap (primary, location);
e04a16fb
AG		 8505 else
8506 {
8507 wfl = primary;
c2952b01
APB		 8508 /* If wfl wasn't qualified, we build a first anchor */
8509 if (!EXPR_WFL_QUALIFICATION (wfl))
8510 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
e04a16fb
AG		 8511 }
8512
c2952b01 8513 /* And chain them */
e04a16fb
AG		 8514 EXPR_WFL_LINECOL (right) = location;
8515 chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
8516 PRIMARY_P (wfl) = 1;
8517 return wfl;
8518}
8519
8520/* Simple merge of two name separated by a `.' */
8521
8522static tree
8523merge_qualified_name (left, right)
8524 tree left, right;
8525{
8526 tree node;
c2952b01
APB		 8527 if (!left && !right)
8528 return NULL_TREE;
8529
8530 if (!left)
8531 return right;
8532
8533 if (!right)
8534 return left;
8535
e04a16fb
AG		 8536 obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
8537 IDENTIFIER_LENGTH (left));
8538 obstack_1grow (&temporary_obstack, '.');
8539 obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
8540 IDENTIFIER_LENGTH (right));
8541 node = get_identifier (obstack_base (&temporary_obstack));
8542 obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
8543 QUALIFIED_P (node) = 1;
8544 return node;
8545}
8546
8547/* Merge the two parts of a qualified name into LEFT. Set the
8548 location information of the resulting node to LOCATION, usually
8549 inherited from the location information of the `.' operator. */
8550
8551static tree
8552make_qualified_name (left, right, location)
8553 tree left, right;
8554 int location;
8555{
bc3ca41b
PB		 8556#ifdef USE_COMPONENT_REF
8557 tree node = build (COMPONENT_REF, NULL_TREE, left, right);
8558 EXPR_WFL_LINECOL (node) = location;
8559 return node;
8560#else
e04a16fb
AG		 8561 tree left_id = EXPR_WFL_NODE (left);
8562 tree right_id = EXPR_WFL_NODE (right);
8563 tree wfl, merge;
8564
8565 merge = merge_qualified_name (left_id, right_id);
8566
8567 /* Left wasn't qualified and is now qualified */
8568 if (!QUALIFIED_P (left_id))
8569 {
8570 tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
8571 EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
8572 EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
8573 }
8574
8575 wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
8576 EXPR_WFL_LINECOL (wfl) = location;
8577 chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
8578
8579 EXPR_WFL_NODE (left) = merge;
8580 return left;
bc3ca41b 8581#endif
e04a16fb
AG		 8582}
8583
8584/* Extract the last identifier component of the qualified in WFL. The
8585 last identifier is removed from the linked list */
8586
8587static tree
8588cut_identifier_in_qualified (wfl)
8589 tree wfl;
8590{
8591 tree q;
8592 tree previous = NULL_TREE;
8593 for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
8594 if (!TREE_CHAIN (q))
8595 {
8596 if (!previous)
781b0558 8597 fatal ("Operating on a non qualified qualified WFL - cut_identifier_in_qualified");
e04a16fb
AG		 8598 TREE_CHAIN (previous) = NULL_TREE;
8599 return TREE_PURPOSE (q);
8600 }
8601}
8602
8603/* Resolve the expression name NAME. Return its decl. */
8604
8605static tree
5e942c50 8606resolve_expression_name (id, orig)
e04a16fb 8607 tree id;
5e942c50 8608 tree *orig;
e04a16fb
AG		 8609{
8610 tree name = EXPR_WFL_NODE (id);
8611 tree decl;
8612
8613 /* 6.5.5.1: Simple expression names */
8614 if (!PRIMARY_P (id) && !QUALIFIED_P (name))
8615 {
8616 /* 15.13.1: NAME can appear within the scope of a local variable
8617 declaration */
8618 if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
8619 return decl;
8620
8621 /* 15.13.1: NAME can appear within a class declaration */
8622 else
8623 {
8624 decl = lookup_field_wrapper (current_class, name);
8625 if (decl)
8626 {
c2952b01 8627 tree access = NULL_TREE;
e04a16fb 8628 int fs = FIELD_STATIC (decl);
f2760b27
APB		 8629
8630 /* If we're accessing an outer scope local alias, make
8631 sure we change the name of the field we're going to
8632 build access to. */
8633 if (FIELD_LOCAL_ALIAS_USED (decl))
8634 name = DECL_NAME (decl);
8635
e04a16fb
AG		 8636 /* Instance variable (8.3.1.1) can't appear within
8637 static method, static initializer or initializer for
8638 a static variable. */
8639 if (!fs && METHOD_STATIC (current_function_decl))
8640 {
7f10c2e2 8641 static_ref_err (id, name, current_class);
e04a16fb
AG		 8642 return error_mark_node;
8643 }
22eed1e6
APB		 8644 /* Instance variables can't appear as an argument of
8645 an explicit constructor invocation */
8646 if (!fs && ctxp->explicit_constructor_p)
8647 {
8648 parse_error_context
781b0558 8649 (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
22eed1e6
APB		 8650 return error_mark_node;
8651 }
5e942c50 8652
c2952b01
APB		 8653 /* If we're processing an inner class and we're trying
8654 to access a field belonging to an outer class, build
8655 the access to the field */
8656 if (!fs && outer_field_access_p (current_class, decl))
8657 return build_outer_field_access (id, decl);
8658
5e942c50 8659 /* Otherwise build what it takes to access the field */
c2952b01
APB		 8660 access = build_field_ref ((fs ? NULL_TREE : current_this),
8661 DECL_CONTEXT (decl), name);
e8fc7396 8662 if (fs && !flag_emit_class_files && !flag_emit_xref)
c2952b01 8663 access = build_class_init (DECL_CONTEXT (access), access);
5e942c50
APB		 8664 /* We may be asked to save the real field access node */
8665 if (orig)
c2952b01 8666 *orig = access;
5e942c50 8667 /* And we return what we got */
c2952b01 8668 return access;
e04a16fb
AG		 8669 }
8670 /* Fall down to error report on undefined variable */
8671 }
8672 }
8673 /* 6.5.5.2 Qualified Expression Names */
8674 else
8675 {
5e942c50
APB		 8676 if (orig)
8677 *orig = NULL_TREE;
e04a16fb
AG		 8678 qualify_ambiguous_name (id);
8679 /* 15.10.1 Field Access Using a Primary and/or Expression Name */
8680 /* 15.10.2: Accessing Superclass Members using super */
98f3c1db 8681 return resolve_field_access (id, orig, NULL);
e04a16fb
AG		 8682 }
8683
8684 /* We've got an error here */
8685 parse_error_context (id, "Undefined variable `%s'",
8686 IDENTIFIER_POINTER (name));
8687
8688 return error_mark_node;
8689}
8690
7f10c2e2
APB		 8691static void
8692static_ref_err (wfl, field_id, class_type)
8693 tree wfl, field_id, class_type;
8694{
8695 parse_error_context
8696 (wfl,
8697 "Can't make a static reference to nonstatic variable `%s' in class `%s'",
8698 IDENTIFIER_POINTER (field_id),
8699 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
8700}
8701
e04a16fb
AG		 8702/* 15.10.1 Field Acess Using a Primary and/or Expression Name.
8703 We return something suitable to generate the field access. We also
8704 return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
8705 recipient's address can be null. */
8706
8707static tree
8708resolve_field_access (qual_wfl, field_decl, field_type)
8709 tree qual_wfl;
8710 tree *field_decl, *field_type;
8711{
8712 int is_static = 0;
8713 tree field_ref;
8714 tree decl, where_found, type_found;
8715
8716 if (resolve_qualified_expression_name (qual_wfl, &decl,
8717 &where_found, &type_found))
8718 return error_mark_node;
8719
8720 /* Resolve the LENGTH field of an array here */
9a7ab4b3
APB		 8721 if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
8722 && TYPE_ARRAY_P (type_found)
e8fc7396 8723 && ! flag_emit_class_files && ! flag_emit_xref)
e04a16fb
AG		 8724 {
8725 tree length = build_java_array_length_access (where_found);
8726 field_ref =
8727 build_java_arraynull_check (type_found, length, int_type_node);
611a4b87
APB		 8728
8729 /* In case we're dealing with a static array, we need to
8730 initialize its class before the array length can be fetched.
8731 It's also a good time to create a DECL_RTL for the field if
8732 none already exists, otherwise if the field was declared in a
8733 class found in an external file and hasn't been (and won't
8734 be) accessed for its value, none will be created. */
8735 if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
8736 {
8737 build_static_field_ref (where_found);
8738 field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
8739 }
e04a16fb
AG		 8740 }
8741 /* We might have been trying to resolve field.method(). In which
8742 case, the resolution is over and decl is the answer */
34f4db93 8743 else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
e04a16fb 8744 field_ref = decl;
34f4db93 8745 else if (JDECL_P (decl))
e04a16fb 8746 {
5e942c50
APB		 8747 int static_final_found = 0;
8748 if (!type_found)
8749 type_found = DECL_CONTEXT (decl);
34f4db93 8750 is_static = JDECL_P (decl) && FIELD_STATIC (decl);
5e942c50
APB		 8751 if (FIELD_FINAL (decl)
8752 && JPRIMITIVE_TYPE_P (TREE_TYPE (decl))
7525cc04 8753 && DECL_INITIAL (decl))
5e942c50 8754 {
0f145be8 8755 field_ref = java_complete_tree (DECL_INITIAL (decl));
5e942c50
APB		 8756 static_final_found = 1;
8757 }
8758 else
7f10c2e2
APB		 8759 field_ref = build_field_ref ((is_static && !flag_emit_xref?
8760 NULL_TREE : where_found),
5e942c50 8761 type_found, DECL_NAME (decl));
e04a16fb
AG		 8762 if (field_ref == error_mark_node)
8763 return error_mark_node;
e8fc7396
APB		 8764 if (is_static && !static_final_found
8765 && !flag_emit_class_files && !flag_emit_xref)
40aaba2b 8766 field_ref = build_class_init (DECL_CONTEXT (decl), field_ref);
e04a16fb
AG		 8767 }
8768 else
8769 field_ref = decl;
8770
8771 if (field_decl)
8772 *field_decl = decl;
8773 if (field_type)
c877974e
APB		 8774 *field_type = (QUAL_DECL_TYPE (decl) ?
8775 QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
e04a16fb
AG		 8776 return field_ref;
8777}
8778
e28cd97b
APB		 8779/* If NODE is an access to f static field, strip out the class
8780 initialization part and return the field decl, otherwise, return
8781 NODE. */
8782
8783static tree
8784strip_out_static_field_access_decl (node)
8785 tree node;
8786{
8787 if (TREE_CODE (node) == COMPOUND_EXPR)
8788 {
8789 tree op1 = TREE_OPERAND (node, 1);
8790 if (TREE_CODE (op1) == COMPOUND_EXPR)
8791 {
8792 tree call = TREE_OPERAND (op1, 0);
8793 if (TREE_CODE (call) == CALL_EXPR
8794 && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
8795 && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
8796 == soft_initclass_node)
8797 return TREE_OPERAND (op1, 1);
8798 }
2f11d407
TT		 8799 else if (JDECL_P (op1))
8800 return op1;
e28cd97b
APB		 8801 }
8802 return node;
8803}
8804
e04a16fb
AG		 8805/* 6.5.5.2: Qualified Expression Names */
8806
8807static int
8808resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
8809 tree wfl;
8810 tree *found_decl, *type_found, *where_found;
8811{
8812 int from_type = 0; /* Field search initiated from a type */
c2952b01 8813 int from_super = 0, from_cast = 0, from_qualified_this = 0;
e04a16fb
AG		 8814 int previous_call_static = 0;
8815 int is_static;
8816 tree decl = NULL_TREE, type = NULL_TREE, q;
c2952b01
APB		 8817 /* For certain for of inner class instantiation */
8818 tree saved_current, saved_this;
8819#define RESTORE_THIS_AND_CURRENT_CLASS \
8820 { current_class = saved_current; current_this = saved_this;}
8821
c877974e 8822 *type_found = *where_found = NULL_TREE;
e04a16fb
AG		 8823
8824 for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
8825 {
8826 tree qual_wfl = QUAL_WFL (q);
7705e9db
APB		 8827 tree ret_decl; /* for EH checking */
8828 int location; /* for EH checking */
e04a16fb
AG		 8829
8830 /* 15.10.1 Field Access Using a Primary */
e04a16fb
AG		 8831 switch (TREE_CODE (qual_wfl))
8832 {
8833 case CALL_EXPR:
b67d701b 8834 case NEW_CLASS_EXPR:
e04a16fb
AG		 8835 /* If the access to the function call is a non static field,
8836 build the code to access it. */
34f4db93 8837 if (JDECL_P (decl) && !FIELD_STATIC (decl))
e04a16fb 8838 {
ac825856
APB		 8839 decl = maybe_access_field (decl, *where_found,
8840 DECL_CONTEXT (decl));
e04a16fb
AG		 8841 if (decl == error_mark_node)
8842 return 1;
8843 }
c2952b01 8844
e04a16fb
AG		 8845 /* And code for the function call */
8846 if (complete_function_arguments (qual_wfl))
8847 return 1;
c2952b01
APB		 8848
8849 /* We might have to setup a new current class and a new this
8850 for the search of an inner class, relative to the type of
8851 a expression resolved as `decl'. The current values are
8852 saved and restored shortly after */
8853 saved_current = current_class;
8854 saved_this = current_this;
8855 if (decl && TREE_CODE (qual_wfl) == NEW_CLASS_EXPR)
8856 {
8857 current_class = type;
8858 current_this = decl;
8859 }
8860
89e09b9a
PB		 8861 if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
8862 CALL_USING_SUPER (qual_wfl) = 1;
7705e9db
APB		 8863 location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
8864 EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
8865 *where_found = patch_method_invocation (qual_wfl, decl, type,
8866 &is_static, &ret_decl);
e04a16fb 8867 if (*where_found == error_mark_node)
c2952b01
APB		 8868 {
8869 RESTORE_THIS_AND_CURRENT_CLASS;
8870 return 1;
8871 }
e04a16fb
AG		 8872 *type_found = type = QUAL_DECL_TYPE (*where_found);
8873
c2952b01
APB		 8874 /* If we're creating an inner class instance, check for that
8875 an enclosing instance is in scope */
8876 if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
165f37bc 8877 && INNER_ENCLOSING_SCOPE_CHECK (type))
c2952b01
APB		 8878 {
8879 parse_error_context
165f37bc
APB		 8880 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
8881 lang_printable_name (type, 0),
8882 (!current_this ? "" :
8883 "; an explicit one must be provided when creating this inner class"));
c2952b01
APB		 8884 RESTORE_THIS_AND_CURRENT_CLASS;
8885 return 1;
8886 }
8887
8888 /* In case we had to change then to resolve a inner class
8889 instantiation using a primary qualified by a `new' */
8890 RESTORE_THIS_AND_CURRENT_CLASS;
8891
7705e9db
APB		 8892 /* EH check */
8893 if (location)
8894 check_thrown_exceptions (location, ret_decl);
8895
e04a16fb
AG		 8896 /* If the previous call was static and this one is too,
8897 build a compound expression to hold the two (because in
8898 that case, previous function calls aren't transported as
8899 forcoming function's argument. */
8900 if (previous_call_static && is_static)
8901 {
8902 decl = build (COMPOUND_EXPR, type, decl, *where_found);
8903 TREE_SIDE_EFFECTS (decl) = 1;
8904 }
8905 else
8906 {
8907 previous_call_static = is_static;
8908 decl = *where_found;
8909 }
c2952b01 8910 from_type = 0;
e04a16fb
AG		 8911 continue;
8912
d8fccff5 8913 case NEW_ARRAY_EXPR:
c2952b01 8914 case NEW_ANONYMOUS_ARRAY_EXPR:
d8fccff5
APB		 8915 *where_found = decl = java_complete_tree (qual_wfl);
8916 if (decl == error_mark_node)
8917 return 1;
8918 *type_found = type = QUAL_DECL_TYPE (decl);
8919 CLASS_LOADED_P (type) = 1;
8920 continue;
8921
e04a16fb
AG		 8922 case CONVERT_EXPR:
8923 *where_found = decl = java_complete_tree (qual_wfl);
8924 if (decl == error_mark_node)
8925 return 1;
8926 *type_found = type = QUAL_DECL_TYPE (decl);
8927 from_cast = 1;
8928 continue;
8929
22eed1e6 8930 case CONDITIONAL_EXPR:
5e942c50 8931 case STRING_CST:
ac22f9cb 8932 case MODIFY_EXPR:
22eed1e6
APB		 8933 *where_found = decl = java_complete_tree (qual_wfl);
8934 if (decl == error_mark_node)
8935 return 1;
8936 *type_found = type = QUAL_DECL_TYPE (decl);
8937 continue;
8938
e04a16fb
AG		 8939 case ARRAY_REF:
8940 /* If the access to the function call is a non static field,
8941 build the code to access it. */
34f4db93 8942 if (JDECL_P (decl) && !FIELD_STATIC (decl))
e04a16fb
AG		 8943 {
8944 decl = maybe_access_field (decl, *where_found, type);
8945 if (decl == error_mark_node)
8946 return 1;
8947 }
8948 /* And code for the array reference expression */
8949 decl = java_complete_tree (qual_wfl);
8950 if (decl == error_mark_node)
8951 return 1;
8952 type = QUAL_DECL_TYPE (decl);
8953 continue;
0a2138e2 8954
37feda7d
APB		 8955 case PLUS_EXPR:
8956 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
8957 return 1;
8958 if ((type = patch_string (decl)))
8959 decl = type;
8960 *where_found = QUAL_RESOLUTION (q) = decl;
8961 *type_found = type = TREE_TYPE (decl);
8962 break;
8963
165f37bc
APB		 8964 case CLASS_LITERAL:
8965 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
8966 return 1;
8967 *where_found = QUAL_RESOLUTION (q) = decl;
8968 *type_found = type = TREE_TYPE (decl);
8969 break;
8970
0a2138e2
APB		 8971 default:
8972 /* Fix for -Wall Just go to the next statement. Don't
8973 continue */
a3f406ce 8974 break;
e04a16fb
AG		 8975 }
8976
8977 /* If we fall here, we weren't processing a (static) function call. */
8978 previous_call_static = 0;
8979
8980 /* It can be the keyword THIS */
8981 if (EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
8982 {
8983 if (!current_this)
8984 {
8985 parse_error_context
8986 (wfl, "Keyword `this' used outside allowed context");
8987 return 1;
8988 }
f63991a8
APB		 8989 if (ctxp->explicit_constructor_p)
8990 {
781b0558 8991 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
f63991a8
APB		 8992 return 1;
8993 }
e04a16fb 8994 /* We have to generate code for intermediate acess */
c2952b01
APB		 8995 if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
8996 {
8997 *where_found = decl = current_this;
8998 *type_found = type = QUAL_DECL_TYPE (decl);
8999 }
9000 /* We're trying to access the this from somewhere else... */
9001 else
9002 {
9003 *where_found = decl = build_current_thisn (type);
9004 from_qualified_this = 1;
9005 }
9006
9007 from_type = 0;
e04a16fb
AG		 9008 continue;
9009 }
9010
9011 /* 15.10.2 Accessing Superclass Members using SUPER */
9012 if (EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9013 {
9014 tree node;
9015 /* Check on the restricted use of SUPER */
9016 if (METHOD_STATIC (current_function_decl)
9017 || current_class == object_type_node)
9018 {
9019 parse_error_context
9020 (wfl, "Keyword `super' used outside allowed context");
9021 return 1;
9022 }
9023 /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9024 node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9025 CLASSTYPE_SUPER (current_class),
9026 build_this (EXPR_WFL_LINECOL (qual_wfl)));
9027 *where_found = decl = java_complete_tree (node);
22eed1e6
APB		 9028 if (decl == error_mark_node)
9029 return 1;
e04a16fb
AG		 9030 *type_found = type = QUAL_DECL_TYPE (decl);
9031 from_super = from_type = 1;
9032 continue;
9033 }
9034
9035 /* 15.13.1: Can't search for field name in packages, so we
9036 assume a variable/class name was meant. */
9037 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9038 {
5e942c50
APB		 9039 tree name = resolve_package (wfl, &q);
9040 if (name)
9041 {
c2952b01 9042 tree list;
5e942c50 9043 *where_found = decl = resolve_no_layout (name, qual_wfl);
6b48deee 9044 /* We want to be absolutely sure that the class is laid
5e942c50
APB		 9045 out. We're going to search something inside it. */
9046 *type_found = type = TREE_TYPE (decl);
9047 layout_class (type);
9048 from_type = 1;
c2952b01 9049
dde1da72
APB		 9050 /* Fix them all the way down, if any are left. */
9051 if (q)
c2952b01 9052 {
dde1da72
APB		 9053 list = TREE_CHAIN (q);
9054 while (list)
9055 {
9056 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (list)) = 1;
9057 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9058 list = TREE_CHAIN (list);
9059 }
c2952b01 9060 }
5e942c50 9061 }
e04a16fb 9062 else
5e942c50
APB		 9063 {
9064 if (from_super || from_cast)
9065 parse_error_context
9066 ((from_cast ? qual_wfl : wfl),
9067 "No variable `%s' defined in class `%s'",
9068 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9069 lang_printable_name (type, 0));
9070 else
9071 parse_error_context
9072 (qual_wfl, "Undefined variable or class name: `%s'",
9073 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)));
9074 return 1;
9075 }
e04a16fb
AG		 9076 }
9077
9078 /* We have a type name. It's been already resolved when the
9079 expression was qualified. */
9080 else if (RESOLVE_TYPE_NAME_P (qual_wfl))
9081 {
9082 if (!(decl = QUAL_RESOLUTION (q)))
9083 return 1; /* Error reported already */
9084
c2952b01
APB		 9085 /* Sneak preview. If next we see a `new', we're facing a
9086 qualification with resulted in a type being selected
9087 instead of a field. Report the error */
9088 if(TREE_CHAIN (q)
9089 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9090 {
9091 parse_error_context (qual_wfl, "Undefined variable `%s'",
9092 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9093 return 1;
9094 }
9095
e04a16fb
AG		 9096 if (not_accessible_p (TREE_TYPE (decl), decl, 0))
9097 {
9098 parse_error_context
9099 (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
9100 java_accstring_lookup (get_access_flags_from_decl (decl)),
2aa11e97 9101 GET_TYPE_NAME (type),
e04a16fb
AG		 9102 IDENTIFIER_POINTER (DECL_NAME (decl)),
9103 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
9104 return 1;
9105 }
5e942c50 9106 check_deprecation (qual_wfl, decl);
c2952b01 9107
e04a16fb
AG		 9108 type = TREE_TYPE (decl);
9109 from_type = 1;
9110 }
9111 /* We resolve and expression name */
9112 else
9113 {
cd531a2e 9114 tree field_decl = NULL_TREE;
e04a16fb
AG		 9115
9116 /* If there exists an early resolution, use it. That occurs
9117 only once and we know that there are more things to
9118 come. Don't do that when processing something after SUPER
9119 (we need more thing to be put in place below */
9120 if (!from_super && QUAL_RESOLUTION (q))
b67d701b
PB		 9121 {
9122 decl = QUAL_RESOLUTION (q);
c877974e 9123 if (!type)
5e942c50 9124 {
7f10c2e2
APB		 9125 if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9126 {
9127 if (current_this)
9128 *where_found = current_this;
9129 else
9130 {
9131 static_ref_err (qual_wfl, DECL_NAME (decl),
9132 current_class);
9133 return 1;
9134 }
9135 }
c877974e
APB		 9136 else
9137 {
9138 *where_found = TREE_TYPE (decl);
9139 if (TREE_CODE (*where_found) == POINTER_TYPE)
9140 *where_found = TREE_TYPE (*where_found);
9141 }
5e942c50 9142 }
b67d701b 9143 }
e04a16fb
AG		 9144
9145 /* We have to search for a field, knowing the type of its
9146 container. The flag FROM_TYPE indicates that we resolved
9147 the last member of the expression as a type name, which
5e942c50
APB		 9148 means that for the resolution of this field, we'll look
9149 for other errors than if it was resolved as a member of
9150 an other field. */
e04a16fb
AG		 9151 else
9152 {
9153 int is_static;
5e942c50
APB		 9154 tree field_decl_type; /* For layout */
9155
e04a16fb
AG		 9156 if (!from_type && !JREFERENCE_TYPE_P (type))
9157 {
9158 parse_error_context
9159 (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9160 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
0a2138e2 9161 lang_printable_name (type, 0),
e04a16fb
AG		 9162 IDENTIFIER_POINTER (DECL_NAME (field_decl)));
9163 return 1;
9164 }
9165
dc0b3eff
PB		 9166 field_decl = lookup_field_wrapper (type,
9167 EXPR_WFL_NODE (qual_wfl));
9168 if (field_decl == NULL_TREE)
e04a16fb
AG		 9169 {
9170 parse_error_context
2aa11e97 9171 (qual_wfl, "No variable `%s' defined in type `%s'",
e04a16fb 9172 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
2aa11e97 9173 GET_TYPE_NAME (type));
e04a16fb
AG		 9174 return 1;
9175 }
dc0b3eff
PB		 9176 if (field_decl == error_mark_node)
9177 return 1;
5e942c50
APB		 9178
9179 /* Layout the type of field_decl, since we may need
c877974e
APB		 9180 it. Don't do primitive types or loaded classes. The
9181 situation of non primitive arrays may not handled
9182 properly here. FIXME */
5e942c50
APB		 9183 if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9184 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9185 else
9186 field_decl_type = TREE_TYPE (field_decl);
9187 if (!JPRIMITIVE_TYPE_P (field_decl_type)
c877974e
APB		 9188 && !CLASS_LOADED_P (field_decl_type)
9189 && !TYPE_ARRAY_P (field_decl_type))
9190 resolve_and_layout (field_decl_type, NULL_TREE);
9191 if (TYPE_ARRAY_P (field_decl_type))
9192 CLASS_LOADED_P (field_decl_type) = 1;
e04a16fb
AG		 9193
9194 /* Check on accessibility here */
9195 if (not_accessible_p (type, field_decl, from_super))
9196 {
9197 parse_error_context
9198 (qual_wfl,
9199 "Can't access %s field `%s.%s' from `%s'",
9200 java_accstring_lookup
9201 (get_access_flags_from_decl (field_decl)),
2aa11e97 9202 GET_TYPE_NAME (type),
e04a16fb
AG		 9203 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
9204 IDENTIFIER_POINTER
9205 (DECL_NAME (TYPE_NAME (current_class))));
9206 return 1;
9207 }
5e942c50 9208 check_deprecation (qual_wfl, field_decl);
e04a16fb
AG		 9209
9210 /* There are things to check when fields are accessed
9211 from type. There are no restrictions on a static
9212 declaration of the field when it is accessed from an
9213 interface */
9214 is_static = FIELD_STATIC (field_decl);
9215 if (!from_super && from_type
c2952b01
APB		 9216 && !TYPE_INTERFACE_P (type)
9217 && !is_static
9218 && (current_function_decl
9219 && METHOD_STATIC (current_function_decl)))
e04a16fb 9220 {
7f10c2e2 9221 static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
e04a16fb
AG		 9222 return 1;
9223 }
9224 from_cast = from_super = 0;
9225
c2952b01
APB		 9226 /* It's an access from a type but it isn't static, we
9227 make it relative to `this'. */
9228 if (!is_static && from_type)
9229 decl = current_this;
9230
5e942c50
APB		 9231 /* If we need to generate something to get a proper
9232 handle on what this field is accessed from, do it
9233 now. */
e04a16fb
AG		 9234 if (!is_static)
9235 {
c583dd46 9236 decl = maybe_access_field (decl, *where_found, *type_found);
e04a16fb
AG		 9237 if (decl == error_mark_node)
9238 return 1;
9239 }
9240
9241 /* We want to keep the location were found it, and the type
9242 we found. */
9243 *where_found = decl;
9244 *type_found = type;
9245
c2952b01
APB		 9246 /* Generate the correct expression for field access from
9247 qualified this */
9248 if (from_qualified_this)
9249 {
9250 field_decl = build_outer_field_access (qual_wfl, field_decl);
9251 from_qualified_this = 0;
9252 }
9253
e04a16fb
AG		 9254 /* This is the decl found and eventually the next one to
9255 search from */
9256 decl = field_decl;
9257 }
e04a16fb
AG		 9258 from_type = 0;
9259 type = QUAL_DECL_TYPE (decl);
c2952b01
APB		 9260
9261 /* Sneak preview. If decl is qualified by a `new', report
9262 the error here to be accurate on the peculiar construct */
9263 if (TREE_CHAIN (q)
9264 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
9265 && !JREFERENCE_TYPE_P (type))
9266 {
9267 parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
9268 lang_printable_name (type, 0));
9269 return 1;
9270 }
e04a16fb 9271 }
dde1da72
APB		 9272 /* `q' might have changed due to a after package resolution
9273 re-qualification */
9274 if (!q)
9275 break;
e04a16fb
AG		 9276 }
9277 *found_decl = decl;
9278 return 0;
9279}
9280
9281/* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
9282 can't be accessed from REFERENCE (a record type). */
9283
be245ac0
KG		 9284static int
9285not_accessible_p (reference, member, from_super)
e04a16fb
AG		 9286 tree reference, member;
9287 int from_super;
9288{
9289 int access_flag = get_access_flags_from_decl (member);
9290
9291 /* Access always granted for members declared public */
9292 if (access_flag & ACC_PUBLIC)
9293 return 0;
9294
9295 /* Check access on protected members */
9296 if (access_flag & ACC_PROTECTED)
9297 {
9298 /* Access granted if it occurs from within the package
9299 containing the class in which the protected member is
9300 declared */
9301 if (class_in_current_package (DECL_CONTEXT (member)))
9302 return 0;
9303
9bbc7d9f
PB		 9304 /* If accessed with the form `super.member', then access is granted */
9305 if (from_super)
9306 return 0;
e04a16fb 9307
9bbc7d9f
PB		 9308 /* Otherwise, access is granted if occuring from the class where
9309 member is declared or a subclass of it */
473e7b07 9310 if (inherits_from_p (reference, DECL_CONTEXT (member)))
9bbc7d9f 9311 return 0;
e04a16fb
AG		 9312 return 1;
9313 }
9314
9315 /* Check access on private members. Access is granted only if it
473e7b07
TT		 9316 occurs from within the class in which it is declared. Exceptions
9317 are accesses from inner-classes. This section is probably not
c2952b01 9318 complete. FIXME */
e04a16fb 9319 if (access_flag & ACC_PRIVATE)
c2952b01
APB		 9320 return (current_class == DECL_CONTEXT (member) ? 0 :
9321 (INNER_CLASS_TYPE_P (current_class) ? 0 : 1));
e04a16fb
AG		 9322
9323 /* Default access are permitted only when occuring within the
9324 package in which the type (REFERENCE) is declared. In other words,
9325 REFERENCE is defined in the current package */
9326 if (ctxp->package)
9327 return !class_in_current_package (reference);
473e7b07 9328
e04a16fb
AG		 9329 /* Otherwise, access is granted */
9330 return 0;
9331}
9332
5e942c50
APB		 9333/* Test deprecated decl access. */
9334static void
9335check_deprecation (wfl, decl)
9336 tree wfl, decl;
9337{
49f48c71 9338 const char *file = DECL_SOURCE_FILE (decl);
5e942c50
APB		 9339 /* Complain if the field is deprecated and the file it was defined
9340 in isn't compiled at the same time the file which contains its
9341 use is */
9342 if (DECL_DEPRECATED (decl)
9343 && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
9344 {
9345 char the [20];
9346 switch (TREE_CODE (decl))
9347 {
9348 case FUNCTION_DECL:
9349 strcpy (the, "method");
9350 break;
9351 case FIELD_DECL:
9352 strcpy (the, "field");
9353 break;
9354 case TYPE_DECL:
9355 strcpy (the, "class");
9356 break;
15fdcfe9
PB		 9357 default:
9358 fatal ("unexpected DECL code - check_deprecation");
5e942c50
APB		 9359 }
9360 parse_warning_context
9361 (wfl, "The %s `%s' in class `%s' has been deprecated",
9362 the, lang_printable_name (decl, 0),
9363 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
9364 }
9365}
9366
e04a16fb
AG		 9367/* Returns 1 if class was declared in the current package, 0 otherwise */
9368
9369static int
9370class_in_current_package (class)
9371 tree class;
9372{
9373 static tree cache = NULL_TREE;
9374 int qualified_flag;
9375 tree left;
9376
9377 if (cache == class)
9378 return 1;
9379
9380 qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
9381
9382 /* If the current package is empty and the name of CLASS is
9383 qualified, class isn't in the current package. If there is a
9384 current package and the name of the CLASS is not qualified, class
9385 isn't in the current package */
0a2138e2 9386 if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
e04a16fb
AG		 9387 return 0;
9388
9389 /* If there is not package and the name of CLASS isn't qualified,
9390 they belong to the same unnamed package */
9391 if (!ctxp->package && !qualified_flag)
9392 return 1;
9393
9394 /* Compare the left part of the name of CLASS with the package name */
9395 breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
9396 if (ctxp->package == left)
9397 {
9398 cache = class;
9399 return 1;
9400 }
9401 return 0;
9402}
9403
9404/* This function may generate code to access DECL from WHERE. This is
9405 done only if certain conditions meet. */
9406
9407static tree
9408maybe_access_field (decl, where, type)
9409 tree decl, where, type;
9410{
5e942c50
APB		 9411 if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
9412 && !FIELD_STATIC (decl))
e04a16fb 9413 decl = build_field_ref (where ? where : current_this,
c583dd46
APB		 9414 (type ? type : DECL_CONTEXT (decl)),
9415 DECL_NAME (decl));
e04a16fb
AG		 9416 return decl;
9417}
9418
15fdcfe9 9419/* Build a method invocation, by patching PATCH. If non NULL
e04a16fb
AG		 9420 and according to the situation, PRIMARY and WHERE may be
9421 used. IS_STATIC is set to 1 if the invoked function is static. */
9422
9423static tree
89e09b9a 9424patch_method_invocation (patch, primary, where, is_static, ret_decl)
e04a16fb
AG		 9425 tree patch, primary, where;
9426 int *is_static;
b9f7e36c 9427 tree *ret_decl;
e04a16fb
AG		 9428{
9429 tree wfl = TREE_OPERAND (patch, 0);
9430 tree args = TREE_OPERAND (patch, 1);
9431 tree name = EXPR_WFL_NODE (wfl);
5e942c50 9432 tree list;
22eed1e6 9433 int is_static_flag = 0;
89e09b9a 9434 int is_super_init = 0;
bccaf73a 9435 tree this_arg = NULL_TREE;
e04a16fb
AG		 9436
9437 /* Should be overriden if everything goes well. Otherwise, if
9438 something fails, it should keep this value. It stop the
9439 evaluation of a bogus assignment. See java_complete_tree,
9440 MODIFY_EXPR: for the reasons why we sometimes want to keep on
9441 evaluating an assignment */
9442 TREE_TYPE (patch) = error_mark_node;
9443
9444 /* Since lookup functions are messing with line numbers, save the
9445 context now. */
9446 java_parser_context_save_global ();
9447
9448 /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
9449
9450 /* Resolution of qualified name, excluding constructors */
9451 if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
9452 {
dde1da72 9453 tree identifier, identifier_wfl, type, resolved;
e04a16fb
AG		 9454 /* Extract the last IDENTIFIER of the qualified
9455 expression. This is a wfl and we will use it's location
9456 data during error report. */
9457 identifier_wfl = cut_identifier_in_qualified (wfl);
9458 identifier = EXPR_WFL_NODE (identifier_wfl);
9459
9460 /* Given the context, IDENTIFIER is syntactically qualified
9461 as a MethodName. We need to qualify what's before */
9462 qualify_ambiguous_name (wfl);
dde1da72 9463 resolved = resolve_field_access (wfl, NULL, NULL);
e04a16fb 9464
dde1da72
APB		 9465 if (resolved == error_mark_node)
9466 PATCH_METHOD_RETURN_ERROR ();
9467
9468 type = GET_SKIP_TYPE (resolved);
9469 resolve_and_layout (type, NULL_TREE);
6518c7b5
BM		 9470
9471 if (JPRIMITIVE_TYPE_P (type))
9472 {
9473 parse_error_context
9474 (identifier_wfl,
9475 "Can't invoke a method on primitive type `%s'",
9476 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
9477 PATCH_METHOD_RETURN_ERROR ();
9478 }
9479
dde1da72
APB		 9480 list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
9481 args = nreverse (args);
2c56429a 9482
e04a16fb 9483 /* We're resolving a call from a type */
dde1da72 9484 if (TREE_CODE (resolved) == TYPE_DECL)
e04a16fb 9485 {
dde1da72 9486 if (CLASS_INTERFACE (resolved))
e04a16fb
AG		 9487 {
9488 parse_error_context
781b0558
KG		 9489 (identifier_wfl,
9490 "Can't make static reference to method `%s' in interface `%s'",
9491 IDENTIFIER_POINTER (identifier),
e04a16fb 9492 IDENTIFIER_POINTER (name));
b9f7e36c 9493 PATCH_METHOD_RETURN_ERROR ();
e04a16fb 9494 }
e04a16fb
AG		 9495 if (list && !METHOD_STATIC (list))
9496 {
c2e3db92 9497 char *fct_name = xstrdup (lang_printable_name (list, 0));
e04a16fb
AG		 9498 parse_error_context
9499 (identifier_wfl,
9500 "Can't make static reference to method `%s %s' in class `%s'",
0a2138e2
APB		 9501 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
9502 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
e04a16fb 9503 free (fct_name);
b9f7e36c 9504 PATCH_METHOD_RETURN_ERROR ();
e04a16fb
AG		 9505 }
9506 }
e04a16fb 9507 else
dde1da72
APB		 9508 this_arg = primary = resolved;
9509
5e942c50 9510 /* IDENTIFIER_WFL will be used to report any problem further */
e04a16fb
AG		 9511 wfl = identifier_wfl;
9512 }
9513 /* Resolution of simple names, names generated after a primary: or
9514 constructors */
9515 else
9516 {
cd531a2e 9517 tree class_to_search = NULL_TREE;
c2952b01 9518 int lc; /* Looking for Constructor */
e04a16fb
AG		 9519
9520 /* We search constructor in their target class */
9521 if (CALL_CONSTRUCTOR_P (patch))
9522 {
22eed1e6
APB		 9523 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
9524 class_to_search = EXPR_WFL_NODE (wfl);
9525 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
9526 this_identifier_node)
9527 class_to_search = NULL_TREE;
9528 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
9529 super_identifier_node)
e04a16fb 9530 {
89e09b9a 9531 is_super_init = 1;
22eed1e6
APB		 9532 if (CLASSTYPE_SUPER (current_class))
9533 class_to_search =
9534 DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
9535 else
9536 {
781b0558 9537 parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
22eed1e6
APB		 9538 PATCH_METHOD_RETURN_ERROR ();
9539 }
e04a16fb 9540 }
22eed1e6
APB		 9541
9542 /* Class to search is NULL if we're searching the current one */
9543 if (class_to_search)
e04a16fb 9544 {
c2952b01
APB		 9545 class_to_search = resolve_and_layout (class_to_search, wfl);
9546
22eed1e6
APB		 9547 if (!class_to_search)
9548 {
9549 parse_error_context
9550 (wfl, "Class `%s' not found in type declaration",
9551 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9552 PATCH_METHOD_RETURN_ERROR ();
9553 }
9554
5e942c50
APB		 9555 /* Can't instantiate an abstract class, but we can
9556 invoke it's constructor. It's use within the `new'
9557 context is denied here. */
9558 if (CLASS_ABSTRACT (class_to_search)
9559 && TREE_CODE (patch) == NEW_CLASS_EXPR)
22eed1e6
APB		 9560 {
9561 parse_error_context
781b0558
KG		 9562 (wfl, "Class `%s' is an abstract class. It can't be instantiated",
9563 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
22eed1e6
APB		 9564 PATCH_METHOD_RETURN_ERROR ();
9565 }
c2952b01 9566
22eed1e6 9567 class_to_search = TREE_TYPE (class_to_search);
e04a16fb 9568 }
22eed1e6
APB		 9569 else
9570 class_to_search = current_class;
e04a16fb
AG		 9571 lc = 1;
9572 }
9573 /* This is a regular search in the local class, unless an
9574 alternate class is specified. */
9575 else
9576 {
9577 class_to_search = (where ? where : current_class);
9578 lc = 0;
9579 }
c2952b01 9580
e04a16fb
AG		 9581 /* NAME is a simple identifier or comes from a primary. Search
9582 in the class whose declaration contain the method being
9583 invoked. */
c877974e 9584 resolve_and_layout (class_to_search, NULL_TREE);
e04a16fb 9585
c2952b01 9586 list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
e04a16fb
AG		 9587 /* Don't continue if no method were found, as the next statement
9588 can't be executed then. */
b9f7e36c
APB		 9589 if (!list)
9590 PATCH_METHOD_RETURN_ERROR ();
e04a16fb
AG		 9591
9592 /* Check for static reference if non static methods */
9593 if (check_for_static_method_reference (wfl, patch, list,
9594 class_to_search, primary))
b9f7e36c 9595 PATCH_METHOD_RETURN_ERROR ();
e04a16fb 9596
165f37bc
APB		 9597 /* Check for inner classes creation from illegal contexts */
9598 if (lc && (INNER_CLASS_TYPE_P (class_to_search)
9599 && !CLASS_STATIC (TYPE_NAME (class_to_search)))
9600 && INNER_ENCLOSING_SCOPE_CHECK (class_to_search))
9601 {
9602 parse_error_context
9603 (wfl, "No enclosing instance for inner class `%s' is in scope%s",
9604 lang_printable_name (class_to_search, 0),
9605 (!current_this ? "" :
9606 "; an explicit one must be provided when creating this inner class"));
9607 PATCH_METHOD_RETURN_ERROR ();
9608 }
9609
22eed1e6
APB		 9610 /* Non static methods are called with the current object extra
9611 argument. If patch a `new TYPE()', the argument is the value
9612 returned by the object allocator. If method is resolved as a
9613 primary, use the primary otherwise use the current THIS. */
b9f7e36c 9614 args = nreverse (args);
bccaf73a 9615 if (TREE_CODE (patch) != NEW_CLASS_EXPR)
c2952b01
APB		 9616 {
9617 this_arg = primary ? primary : current_this;
9618
9619 /* If we're using an access method, things are different.
9620 There are two familly of cases:
9621
9622 1) We're not generating bytecodes:
9623
9624 - LIST is non static. It's invocation is transformed from
9625 x(a1,...,an) into this$<n>.x(a1,....an).
9626 - LIST is static. It's invocation is transformed from
9627 x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
9628
9629 2) We're generating bytecodes:
9630
9631 - LIST is non static. It's invocation is transformed from
9632 x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
9633 - LIST is static. It's invocation is transformed from
9634 x(a1,....,an) into TYPEOF(this$<n>).x(a1,....an).
9635
9636 Of course, this$<n> can be abitrary complex, ranging from
9637 this$0 (the immediate outer context) to
9638 access$0(access$0(...(this$0))).
9639
9640 maybe_use_access_method returns a non zero value if the
dfb99c83
APB		 9641 this_arg has to be moved into the (then generated) stub
9642 argument list. In the mean time, the selected function
9643 might have be replaced by a generated stub. */
c2952b01
APB		 9644 if (maybe_use_access_method (is_super_init, &list, &this_arg))
9645 args = tree_cons (NULL_TREE, this_arg, args);
9646 }
e04a16fb 9647 }
b67d701b 9648
e04a16fb
AG		 9649 /* Merge point of all resolution schemes. If we have nothing, this
9650 is an error, already signaled */
b9f7e36c
APB		 9651 if (!list)
9652 PATCH_METHOD_RETURN_ERROR ();
b67d701b 9653
e04a16fb
AG		 9654 /* Check accessibility, position the is_static flag, build and
9655 return the call */
9bbc7d9f 9656 if (not_accessible_p (DECL_CONTEXT (current_function_decl), list, 0))
e04a16fb 9657 {
c2e3db92 9658 char *fct_name = xstrdup (lang_printable_name (list, 0));
e04a16fb
AG		 9659 parse_error_context
9660 (wfl, "Can't access %s method `%s %s.%s' from `%s'",
9661 java_accstring_lookup (get_access_flags_from_decl (list)),
0a2138e2 9662 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
5e942c50
APB		 9663 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list)))),
9664 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
e04a16fb 9665 free (fct_name);
b9f7e36c 9666 PATCH_METHOD_RETURN_ERROR ();
e04a16fb 9667 }
5e942c50 9668 check_deprecation (wfl, list);
22eed1e6 9669
c2952b01
APB		 9670 /* If invoking a innerclass constructor, there are hidden parameters
9671 to pass */
9672 if (TREE_CODE (patch) == NEW_CLASS_EXPR
9673 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
9674 {
9675 /* And make sure we add the accessed local variables to be saved
9676 in field aliases. */
9677 args = build_alias_initializer_parameter_list
9678 (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
9679
9680 /* We have to reverse things. Find out why. FIXME */
9681 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (list)))
9682 args = nreverse (args);
9683
9684 /* Secretely pass the current_this/primary as a second argument */
165f37bc
APB		 9685 if (primary || current_this)
9686 args = tree_cons (NULL_TREE, (primary ? primary : current_this), args);
9687 else
9688 args = tree_cons (NULL_TREE, integer_zero_node, args);
c2952b01
APB		 9689 }
9690
152de068
APB		 9691 /* This handles the situation where a constructor invocation needs
9692 to have an enclosing context passed as a second parameter (the
9693 constructor is one of an inner class. We extract it from the
9694 current function. */
9695 if (is_super_init && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
9696 {
9697 tree enclosing_decl = DECL_CONTEXT (TYPE_NAME (current_class));
9698 tree extra_arg;
9699
9700 if (ANONYMOUS_CLASS_P (current_class) || !DECL_CONTEXT (enclosing_decl))
9701 {
9702 extra_arg = DECL_FUNCTION_BODY (current_function_decl);
9703 extra_arg = TREE_CHAIN (BLOCK_EXPR_DECLS (extra_arg));
9704 }
9705 else
9706 {
9707 tree dest = TREE_TYPE (DECL_CONTEXT (enclosing_decl));
9708 extra_arg =
9709 build_access_to_thisn (TREE_TYPE (enclosing_decl), dest, 0);
9710 extra_arg = java_complete_tree (extra_arg);
9711 }
9712 args = tree_cons (NULL_TREE, extra_arg, args);
9713 }
9714
22eed1e6 9715 is_static_flag = METHOD_STATIC (list);
bccaf73a
PB		 9716 if (! METHOD_STATIC (list) && this_arg != NULL_TREE)
9717 args = tree_cons (NULL_TREE, this_arg, args);
22eed1e6 9718
c3f2a476
APB		 9719 /* In the context of an explicit constructor invocation, we can't
9720 invoke any method relying on `this'. Exceptions are: we're
9721 invoking a static function, primary exists and is not the current
9722 this, we're creating a new object. */
22eed1e6 9723 if (ctxp->explicit_constructor_p
c3f2a476
APB		 9724 && !is_static_flag
9725 && (!primary || primary == current_this)
9726 && (TREE_CODE (patch) != NEW_CLASS_EXPR))
22eed1e6 9727 {
781b0558 9728 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
22eed1e6
APB		 9729 PATCH_METHOD_RETURN_ERROR ();
9730 }
e04a16fb 9731 java_parser_context_restore_global ();
22eed1e6
APB		 9732 if (is_static)
9733 *is_static = is_static_flag;
b9f7e36c
APB		 9734 /* Sometimes, we want the decl of the selected method. Such as for
9735 EH checking */
9736 if (ret_decl)
9737 *ret_decl = list;
89e09b9a
PB		 9738 patch = patch_invoke (patch, list, args);
9739 if (is_super_init && CLASS_HAS_FINIT_P (current_class))
9740 {
c2952b01
APB		 9741 tree finit_parms, finit_call;
9742
9743 /* Prepare to pass hidden parameters to $finit$, if any. */
9744 finit_parms = build_alias_initializer_parameter_list
9745 (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
89e09b9a 9746
c2952b01
APB		 9747 finit_call =
9748 build_method_invocation (build_wfl_node (finit_identifier_node),
9749 finit_parms);
9750
9751 /* Generate the code used to initialize fields declared with an
9752 initialization statement and build a compound statement along
9753 with the super constructor invocation. */
89e09b9a
PB		 9754 patch = build (COMPOUND_EXPR, void_type_node, patch,
9755 java_complete_tree (finit_call));
9756 CAN_COMPLETE_NORMALLY (patch) = 1;
9757 }
9758 return patch;
e04a16fb
AG		 9759}
9760
9761/* Check that we're not trying to do a static reference to a method in
9762 non static method. Return 1 if it's the case, 0 otherwise. */
9763
9764static int
9765check_for_static_method_reference (wfl, node, method, where, primary)
9766 tree wfl, node, method, where, primary;
9767{
9768 if (METHOD_STATIC (current_function_decl)
9769 && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
9770 {
c2e3db92 9771 char *fct_name = xstrdup (lang_printable_name (method, 0));
e04a16fb
AG		 9772 parse_error_context
9773 (wfl, "Can't make static reference to method `%s %s' in class `%s'",
0a2138e2 9774 lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
e04a16fb
AG		 9775 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
9776 free (fct_name);
9777 return 1;
9778 }
9779 return 0;
9780}
9781
c2952b01
APB		 9782/* Fix the invocation of *MDECL if necessary in the case of a
9783 invocation from an inner class. *THIS_ARG might be modified
9784 appropriately and an alternative access to *MDECL might be
9785 returned. */
9786
9787static int
9788maybe_use_access_method (is_super_init, mdecl, this_arg)
9789 int is_super_init;
9790 tree *mdecl, *this_arg;
9791{
9792 tree ctx;
9793 tree md = *mdecl, ta = *this_arg;
9794 int to_return = 0;
9795 int non_static_context = !METHOD_STATIC (md);
9796
9797 if (is_super_init
165f37bc
APB		 9798 || DECL_CONTEXT (md) == current_class
9799 || !PURE_INNER_CLASS_TYPE_P (current_class)
9800 || DECL_FINIT_P (md))
c2952b01
APB		 9801 return 0;
9802
9803 /* If we're calling a method found in an enclosing class, generate
9804 what it takes to retrieve the right this. Don't do that if we're
9805 invoking a static method. */
9806
9807 if (non_static_context)
9808 {
9809 ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
9810 if (ctx == DECL_CONTEXT (md))
9811 {
9812 ta = build_current_thisn (current_class);
9813 ta = build_wfl_node (ta);
9814 }
9815 else
9816 {
9817 tree type = ctx;
9818 while (type)
9819 {
9820 maybe_build_thisn_access_method (type);
9821 if (type == DECL_CONTEXT (md))
9822 {
9823 ta = build_access_to_thisn (ctx, type, 0);
9824 break;
9825 }
9826 type = (DECL_CONTEXT (TYPE_NAME (type)) ?
9827 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
9828 }
9829 }
9830 ta = java_complete_tree (ta);
9831 }
9832
9833 /* We might have to use an access method to get to MD. We can
9834 break the method access rule as far as we're not generating
9835 bytecode */
9836 if (METHOD_PRIVATE (md) && flag_emit_class_files)
9837 {
9838 md = build_outer_method_access_method (md);
9839 to_return = 1;
9840 }
9841
9842 *mdecl = md;
9843 *this_arg = ta;
9844
9845 /* Returnin a non zero value indicates we were doing a non static
9846 method invokation that is now a static invocation. It will have
9847 callee displace `this' to insert it in the regular argument
9848 list. */
9849 return (non_static_context && to_return);
9850}
9851
e04a16fb
AG		 9852/* Patch an invoke expression METHOD and ARGS, based on its invocation
9853 mode. */
9854
9855static tree
89e09b9a 9856patch_invoke (patch, method, args)
e04a16fb 9857 tree patch, method, args;
e04a16fb
AG		 9858{
9859 tree dtable, func;
0a2138e2 9860 tree original_call, t, ta;
e815887f 9861 tree cond = NULL_TREE;
e04a16fb 9862
5e942c50
APB		 9863 /* Last step for args: convert build-in types. If we're dealing with
9864 a new TYPE() type call, the first argument to the constructor
e815887f 9865 isn't found in the incoming argument list, but delivered by
5e942c50
APB		 9866 `new' */
9867 t = TYPE_ARG_TYPES (TREE_TYPE (method));
9868 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
9869 t = TREE_CHAIN (t);
ac825856
APB		 9870 for (ta = args; t != end_params_node && ta;
9871 t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
b9f7e36c
APB		 9872 if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
9873 TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
9874 TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
1a6d4fb7
APB		 9875
9876 /* Resolve unresolved returned type isses */
9877 t = TREE_TYPE (TREE_TYPE (method));
9878 if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
9879 resolve_and_layout (TREE_TYPE (t), NULL);
c2952b01 9880
e8fc7396 9881 if (flag_emit_class_files || flag_emit_xref)
15fdcfe9
PB		 9882 func = method;
9883 else
e04a16fb 9884 {
15fdcfe9 9885 tree signature = build_java_signature (TREE_TYPE (method));
89e09b9a 9886 switch (invocation_mode (method, CALL_USING_SUPER (patch)))
15fdcfe9
PB		 9887 {
9888 case INVOKE_VIRTUAL:
9889 dtable = invoke_build_dtable (0, args);
9890 func = build_invokevirtual (dtable, method);
9891 break;
b9f7e36c 9892
e815887f
TT		 9893 case INVOKE_NONVIRTUAL:
9894 /* If the object for the method call is null, we throw an
9895 exception. We don't do this if the object is the current
9896 method's `this'. In other cases we just rely on an
9897 optimization pass to eliminate redundant checks. */
9898 if (TREE_VALUE (args) != current_this)
9899 {
9900 /* We use a SAVE_EXPR here to make sure we only evaluate
9901 the new `self' expression once. */
9902 tree save_arg = save_expr (TREE_VALUE (args));
9903 TREE_VALUE (args) = save_arg;
9904 cond = build (EQ_EXPR, boolean_type_node, save_arg,
9905 null_pointer_node);
9906 }
9907 /* Fall through. */
9908
15fdcfe9
PB		 9909 case INVOKE_SUPER:
9910 case INVOKE_STATIC:
9911 func = build_known_method_ref (method, TREE_TYPE (method),
9912 DECL_CONTEXT (method),
9913 signature, args);
9914 break;
e04a16fb 9915
15fdcfe9
PB		 9916 case INVOKE_INTERFACE:
9917 dtable = invoke_build_dtable (1, args);
173f556c 9918 func = build_invokeinterface (dtable, method);
15fdcfe9 9919 break;
5e942c50 9920
15fdcfe9 9921 default:
89e09b9a 9922 fatal ("internal error - unknown invocation_mode result");
15fdcfe9
PB		 9923 }
9924
9925 /* Ensure self_type is initialized, (invokestatic). FIXME */
9926 func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
e04a16fb
AG		 9927 }
9928
e04a16fb
AG		 9929 TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
9930 TREE_OPERAND (patch, 0) = func;
9931 TREE_OPERAND (patch, 1) = args;
9932 original_call = patch;
9933
e815887f 9934 /* We're processing a `new TYPE ()' form. New is called and its
22eed1e6
APB		 9935 returned value is the first argument to the constructor. We build
9936 a COMPOUND_EXPR and use saved expression so that the overall NEW
9937 expression value is a pointer to a newly created and initialized
9938 class. */
9939 if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
e04a16fb
AG		 9940 {
9941 tree class = DECL_CONTEXT (method);
9942 tree c1, saved_new, size, new;
e8fc7396 9943 if (flag_emit_class_files || flag_emit_xref)
15fdcfe9
PB		 9944 {
9945 TREE_TYPE (patch) = build_pointer_type (class);
9946 return patch;
9947 }
e04a16fb
AG		 9948 if (!TYPE_SIZE (class))
9949 safe_layout_class (class);
9950 size = size_in_bytes (class);
9951 new = build (CALL_EXPR, promote_type (class),
9952 build_address_of (alloc_object_node),
9953 tree_cons (NULL_TREE, build_class_ref (class),
9954 build_tree_list (NULL_TREE,
9955 size_in_bytes (class))),
9956 NULL_TREE);
9957 saved_new = save_expr (new);
9958 c1 = build_tree_list (NULL_TREE, saved_new);
9959 TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
9960 TREE_OPERAND (original_call, 1) = c1;
9961 TREE_SET_CODE (original_call, CALL_EXPR);
9962 patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
9963 }
e815887f
TT		 9964
9965 /* If COND is set, then we are building a check to see if the object
9966 is NULL. */
9967 if (cond != NULL_TREE)
9968 {
9969 /* We have to make the `then' branch a compound expression to
9970 make the types turn out right. This seems bizarre. */
9971 patch = build (COND_EXPR, TREE_TYPE (patch), cond,
9972 build (COMPOUND_EXPR, TREE_TYPE (patch),
9973 build (CALL_EXPR, void_type_node,
9974 build_address_of (soft_nullpointer_node),
9975 NULL_TREE, NULL_TREE),
9976 (FLOAT_TYPE_P (TREE_TYPE (patch))
9977 ? build_real (TREE_TYPE (patch), dconst0)
9978 : build1 (CONVERT_EXPR, TREE_TYPE (patch),
9979 integer_zero_node))),
9980 patch);
9981 TREE_SIDE_EFFECTS (patch) = 1;
9982 }
9983
e04a16fb
AG		 9984 return patch;
9985}
9986
9987static int
9988invocation_mode (method, super)
9989 tree method;
9990 int super;
9991{
9992 int access = get_access_flags_from_decl (method);
9993
22eed1e6
APB		 9994 if (super)
9995 return INVOKE_SUPER;
9996
e815887f 9997 if (access & ACC_STATIC)
e04a16fb
AG		 9998 return INVOKE_STATIC;
9999
e815887f
TT		 10000 /* We have to look for a constructor before we handle nonvirtual
10001 calls; otherwise the constructor will look nonvirtual. */
10002 if (DECL_CONSTRUCTOR_P (method))
e04a16fb 10003 return INVOKE_STATIC;
e815887f
TT		 10004
10005 if (access & ACC_FINAL || access & ACC_PRIVATE)
10006 return INVOKE_NONVIRTUAL;
10007
10008 if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10009 return INVOKE_NONVIRTUAL;
10010
e04a16fb
AG		 10011 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10012 return INVOKE_INTERFACE;
22eed1e6 10013
e04a16fb
AG		 10014 return INVOKE_VIRTUAL;
10015}
10016
b67d701b
PB		 10017/* Retrieve a refined list of matching methods. It covers the step
10018 15.11.2 (Compile-Time Step 2) */
e04a16fb
AG		 10019
10020static tree
10021lookup_method_invoke (lc, cl, class, name, arg_list)
10022 int lc;
10023 tree cl;
10024 tree class, name, arg_list;
10025{
de4c7b02 10026 tree atl = end_params_node; /* Arg Type List */
c877974e 10027 tree method, signature, list, node;
49f48c71 10028 const char *candidates; /* Used for error report */
b5b8a0e7 10029 char *dup;
e04a16fb 10030
5e942c50 10031 /* Fix the arguments */
e04a16fb
AG		 10032 for (node = arg_list; node; node = TREE_CHAIN (node))
10033 {
e3884b71 10034 tree current_arg = TREE_TYPE (TREE_VALUE (node));
c877974e 10035 /* Non primitive type may have to be resolved */
e3884b71 10036 if (!JPRIMITIVE_TYPE_P (current_arg))
c877974e
APB		 10037 resolve_and_layout (current_arg, NULL_TREE);
10038 /* And promoted */
b67d701b 10039 if (TREE_CODE (current_arg) == RECORD_TYPE)
c877974e 10040 current_arg = promote_type (current_arg);
5e942c50 10041 atl = tree_cons (NULL_TREE, current_arg, atl);
e04a16fb 10042 }
e04a16fb 10043
c2952b01
APB		 10044 /* Presto. If we're dealing with an anonymous class and a
10045 constructor call, generate the right constructor now, since we
10046 know the arguments' types. */
10047
10048 if (lc && ANONYMOUS_CLASS_P (class))
10049 craft_constructor (TYPE_NAME (class), atl);
10050
5e942c50
APB		 10051 /* Find all candidates and then refine the list, searching for the
10052 most specific method. */
10053 list = find_applicable_accessible_methods_list (lc, class, name, atl);
10054 list = find_most_specific_methods_list (list);
b67d701b
PB		 10055 if (list && !TREE_CHAIN (list))
10056 return TREE_VALUE (list);
e04a16fb 10057
b67d701b
PB		 10058 /* Issue an error. List candidates if any. Candidates are listed
10059 only if accessible (non accessible methods may end-up here for
10060 the sake of a better error report). */
10061 candidates = NULL;
10062 if (list)
e04a16fb 10063 {
e04a16fb 10064 tree current;
b67d701b 10065 obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
e04a16fb
AG		 10066 for (current = list; current; current = TREE_CHAIN (current))
10067 {
b67d701b
PB		 10068 tree cm = TREE_VALUE (current);
10069 char string [4096];
10070 if (!cm || not_accessible_p (class, cm, 0))
10071 continue;
b67d701b 10072 sprintf
22eed1e6
APB		 10073 (string, " `%s' in `%s'%s",
10074 get_printable_method_name (cm),
b67d701b
PB		 10075 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10076 (TREE_CHAIN (current) ? "\n" : ""));
10077 obstack_grow (&temporary_obstack, string, strlen (string));
10078 }
10079 obstack_1grow (&temporary_obstack, '\0');
10080 candidates = obstack_finish (&temporary_obstack);
10081 }
10082 /* Issue the error message */
c877974e
APB		 10083 method = make_node (FUNCTION_TYPE);
10084 TYPE_ARG_TYPES (method) = atl;
b67d701b 10085 signature = build_java_argument_signature (method);
c63b98cd 10086 dup = xstrdup (lang_printable_name (class, 0));
b5b8a0e7 10087 parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
22eed1e6 10088 (lc ? "constructor" : "method"),
b5b8a0e7
APB		 10089 (lc ? dup : IDENTIFIER_POINTER (name)),
10090 IDENTIFIER_POINTER (signature), dup,
b67d701b 10091 (candidates ? candidates : ""));
b5b8a0e7 10092 free (dup);
b67d701b
PB		 10093 return NULL_TREE;
10094}
10095
5e942c50
APB		 10096/* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10097 when we're looking for a constructor. */
b67d701b
PB		 10098
10099static tree
5e942c50
APB		 10100find_applicable_accessible_methods_list (lc, class, name, arglist)
10101 int lc;
b67d701b
PB		 10102 tree class, name, arglist;
10103{
165f37bc 10104 static int object_done = 0;
b67d701b
PB		 10105 tree list = NULL_TREE, all_list = NULL_TREE;
10106
c2952b01
APB		 10107 if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
10108 {
10109 load_class (class, 1);
10110 safe_layout_class (class);
10111 }
10112
1982388a 10113 /* Search interfaces */
9a7ab4b3
APB		 10114 if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
10115 && CLASS_INTERFACE (TYPE_NAME (class)))
b67d701b 10116 {
e0422ed0 10117 static struct hash_table t, *searched_interfaces = NULL;
de0b553f 10118 static int search_not_done = 0;
1982388a
APB		 10119 int i, n;
10120 tree basetype_vec = TYPE_BINFO_BASETYPES (class);
10121
e0422ed0
APB		 10122 /* Search in the hash table, otherwise create a new one if
10123 necessary and insert the new entry. */
10124
de0b553f 10125 if (searched_interfaces)
e0422ed0
APB		 10126 {
10127 if (hash_lookup (searched_interfaces,
10128 (const hash_table_key) class, FALSE, NULL))
10129 return NULL;
de0b553f 10130 }
e0422ed0
APB		 10131 else
10132 {
10133 hash_table_init (&t, hash_newfunc, java_hash_hash_tree_node,
10134 java_hash_compare_tree_node);
10135 searched_interfaces = &t;
10136 }
10137
10138 hash_lookup (searched_interfaces,
10139 (const hash_table_key) class, TRUE, NULL);
de0b553f 10140
165f37bc
APB		 10141 search_applicable_methods_list (lc, TYPE_METHODS (class),
10142 name, arglist, &list, &all_list);
1982388a 10143 n = TREE_VEC_LENGTH (basetype_vec);
165f37bc 10144 for (i = 1; i < n; i++)
b67d701b 10145 {
de0b553f
APB		 10146 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
10147 tree rlist;
10148
de0b553f
APB		 10149 search_not_done++;
10150 rlist = find_applicable_accessible_methods_list (lc, t, name,
10151 arglist);
165f37bc 10152 list = chainon (rlist, list);
de0b553f
APB		 10153 search_not_done--;
10154 }
10155
10156 /* We're done. Reset the searched interfaces list and finally search
10157 java.lang.Object */
10158 if (!search_not_done)
10159 {
165f37bc
APB		 10160 if (!object_done)
10161 search_applicable_methods_list (lc,
10162 TYPE_METHODS (object_type_node),
10163 name, arglist, &list, &all_list);
e0422ed0
APB		 10164 hash_table_free (searched_interfaces);
10165 searched_interfaces = NULL;
e04a16fb 10166 }
e04a16fb 10167 }
1982388a
APB		 10168 /* Search classes */
10169 else
c2952b01 10170 {
165f37bc
APB		 10171 tree sc = class;
10172 int seen_inner_class = 0;
c2952b01
APB		 10173 search_applicable_methods_list (lc, TYPE_METHODS (class),
10174 name, arglist, &list, &all_list);
10175
165f37bc
APB		 10176 /* We must search all interfaces of this class */
10177 if (!lc)
10178 {
10179 tree basetype_vec = TYPE_BINFO_BASETYPES (sc);
10180 int n = TREE_VEC_LENGTH (basetype_vec), i;
10181 object_done = 1;
10182 for (i = 1; i < n; i++)
10183 {
10184 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
165f37bc 10185 if (t != object_type_node)
30a3caef
ZW		 10186 {
10187 tree rlist
10188 = find_applicable_accessible_methods_list (lc, t,
10189 name, arglist);
10190 list = chainon (rlist, list);
10191 }
165f37bc
APB		 10192 }
10193 object_done = 0;
10194 }
10195
c2952b01
APB		 10196 /* Search enclosing context of inner classes before looking
10197 ancestors up. */
10198 while (!lc && INNER_CLASS_TYPE_P (class))
10199 {
165f37bc
APB		 10200 tree rlist;
10201 seen_inner_class = 1;
c2952b01 10202 class = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
165f37bc
APB		 10203 rlist = find_applicable_accessible_methods_list (lc, class,
10204 name, arglist);
10205 list = chainon (rlist, list);
c2952b01 10206 }
165f37bc
APB		 10207
10208 if (!lc && seen_inner_class
10209 && TREE_TYPE (DECL_CONTEXT (TYPE_NAME (sc))) == CLASSTYPE_SUPER (sc))
10210 class = CLASSTYPE_SUPER (sc);
10211 else
10212 class = sc;
10213
10214 for (class = (lc ? NULL_TREE : CLASSTYPE_SUPER (class));
10215 class; class = CLASSTYPE_SUPER (class))
10216 search_applicable_methods_list (lc, TYPE_METHODS (class),
10217 name, arglist, &list, &all_list);
c2952b01 10218 }
1982388a 10219
b67d701b
PB		 10220 /* Either return the list obtained or all selected (but
10221 inaccessible) methods for better error report. */
10222 return (!list ? all_list : list);
10223}
e04a16fb 10224
1982388a
APB		 10225/* Effectively search for the approriate method in method */
10226
10227static void
c2952b01 10228search_applicable_methods_list (lc, method, name, arglist, list, all_list)
1982388a
APB		 10229 int lc;
10230 tree method, name, arglist;
10231 tree *list, *all_list;
10232{
10233 for (; method; method = TREE_CHAIN (method))
10234 {
10235 /* When dealing with constructor, stop here, otherwise search
10236 other classes */
10237 if (lc && !DECL_CONSTRUCTOR_P (method))
10238 continue;
10239 else if (!lc && (DECL_CONSTRUCTOR_P (method)
10240 || (GET_METHOD_NAME (method) != name)))
10241 continue;
10242
10243 if (argument_types_convertible (method, arglist))
10244 {
10245 /* Retain accessible methods only */
10246 if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
10247 method, 0))
10248 *list = tree_cons (NULL_TREE, method, *list);
10249 else
10250 /* Also retain all selected method here */
10251 *all_list = tree_cons (NULL_TREE, method, *list);
10252 }
10253 }
10254}
10255
b67d701b
PB		 10256/* 15.11.2.2 Choose the Most Specific Method */
10257
10258static tree
10259find_most_specific_methods_list (list)
10260 tree list;
10261{
10262 int max = 0;
9a7ab4b3 10263 int abstract, candidates;
b67d701b
PB		 10264 tree current, new_list = NULL_TREE;
10265 for (current = list; current; current = TREE_CHAIN (current))
e04a16fb 10266 {
b67d701b
PB		 10267 tree method;
10268 DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
10269
10270 for (method = list; method; method = TREE_CHAIN (method))
10271 {
10272 /* Don't test a method against itself */
10273 if (method == current)
10274 continue;
10275
10276 /* Compare arguments and location where method where declared */
10277 if (argument_types_convertible (TREE_VALUE (method),
10278 TREE_VALUE (current))
10279 && valid_method_invocation_conversion_p
10280 (DECL_CONTEXT (TREE_VALUE (method)),
10281 DECL_CONTEXT (TREE_VALUE (current))))
10282 {
10283 int v = ++DECL_SPECIFIC_COUNT (TREE_VALUE (current));
10284 max = (v > max ? v : max);
10285 }
10286 }
e04a16fb
AG		 10287 }
10288
b67d701b 10289 /* Review the list and select the maximally specific methods */
9a7ab4b3
APB		 10290 for (current = list, abstract = -1, candidates = -1;
10291 current; current = TREE_CHAIN (current))
b67d701b 10292 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
9a7ab4b3
APB		 10293 {
10294 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
10295 abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
10296 candidates++;
10297 }
b67d701b 10298
165f37bc
APB		 10299 /* If we have several and they're all abstract, just pick the
10300 closest one. */
9a7ab4b3
APB		 10301 if (candidates > 0 && (candidates == abstract))
10302 {
10303 new_list = nreverse (new_list);
10304 TREE_CHAIN (new_list) = NULL_TREE;
10305 }
165f37bc 10306
9a7ab4b3
APB		 10307 /* We have several, we couldn't find a most specific, all but one are
10308 abstract, we pick the only non abstract one. */
10309 if (candidates > 0 && !max && (candidates == abstract+1))
165f37bc 10310 {
9a7ab4b3
APB		 10311 for (current = new_list; current; current = TREE_CHAIN (current))
10312 if (!METHOD_ABSTRACT (TREE_VALUE (current)))
10313 {
10314 TREE_CHAIN (current) = NULL_TREE;
10315 new_list = current;
10316 }
165f37bc
APB		 10317 }
10318
b67d701b
PB		 10319 /* If we can't find one, lower expectations and try to gather multiple
10320 maximally specific methods */
165f37bc 10321 while (!new_list && max)
b67d701b
PB		 10322 {
10323 while (--max > 0)
10324 {
10325 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
10326 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
10327 }
b67d701b
PB		 10328 }
10329
10330 return new_list;
e04a16fb
AG		 10331}
10332
b67d701b
PB		 10333/* Make sure that the type of each M2_OR_ARGLIST arguments can be
10334 converted by method invocation conversion (5.3) to the type of the
10335 corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
10336 to change less often than M1. */
e04a16fb 10337
b67d701b
PB		 10338static int
10339argument_types_convertible (m1, m2_or_arglist)
10340 tree m1, m2_or_arglist;
e04a16fb 10341{
b67d701b
PB		 10342 static tree m2_arg_value = NULL_TREE;
10343 static tree m2_arg_cache = NULL_TREE;
e04a16fb 10344
b67d701b 10345 register tree m1_arg, m2_arg;
e04a16fb 10346
c2952b01 10347 SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
e04a16fb 10348
b67d701b
PB		 10349 if (m2_arg_value == m2_or_arglist)
10350 m2_arg = m2_arg_cache;
10351 else
10352 {
10353 /* M2_OR_ARGLIST can be a function DECL or a raw list of
10354 argument types */
10355 if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
10356 {
10357 m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
10358 if (!METHOD_STATIC (m2_or_arglist))
10359 m2_arg = TREE_CHAIN (m2_arg);
10360 }
10361 else
10362 m2_arg = m2_or_arglist;
e04a16fb 10363
b67d701b
PB		 10364 m2_arg_value = m2_or_arglist;
10365 m2_arg_cache = m2_arg;
10366 }
e04a16fb 10367
de4c7b02 10368 while (m1_arg != end_params_node && m2_arg != end_params_node)
b67d701b 10369 {
c877974e 10370 resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
b67d701b
PB		 10371 if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
10372 TREE_VALUE (m2_arg)))
10373 break;
10374 m1_arg = TREE_CHAIN (m1_arg);
10375 m2_arg = TREE_CHAIN (m2_arg);
e04a16fb 10376 }
de4c7b02 10377 return m1_arg == end_params_node && m2_arg == end_params_node;
e04a16fb
AG		 10378}
10379
10380/* Qualification routines */
10381
10382static void
10383qualify_ambiguous_name (id)
10384 tree id;
10385{
cd531a2e
KG		 10386 tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
10387 saved_current_class;
d8fccff5 10388 int again, super_found = 0, this_found = 0, new_array_found = 0;
8576f094 10389 int code;
e04a16fb
AG		 10390
10391 /* We first qualify the first element, then derive qualification of
10392 others based on the first one. If the first element is qualified
10393 by a resolution (field or type), this resolution is stored in the
10394 QUAL_RESOLUTION of the qual element being examined. We need to
10395 save the current_class since the use of SUPER might change the
10396 its value. */
10397 saved_current_class = current_class;
10398 qual = EXPR_WFL_QUALIFICATION (id);
10399 do {
10400
10401 /* Simple qualified expression feature a qual_wfl that is a
10402 WFL. Expression derived from a primary feature more complicated
10403 things like a CALL_EXPR. Expression from primary need to be
10404 worked out to extract the part on which the qualification will
10405 take place. */
10406 qual_wfl = QUAL_WFL (qual);
10407 switch (TREE_CODE (qual_wfl))
10408 {
10409 case CALL_EXPR:
10410 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10411 if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
10412 {
10413 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
10414 qual_wfl = QUAL_WFL (qual);
10415 }
10416 break;
d8fccff5 10417 case NEW_ARRAY_EXPR:
c2952b01 10418 case NEW_ANONYMOUS_ARRAY_EXPR:
d8fccff5 10419 qual = TREE_CHAIN (qual);
1a6d4fb7 10420 again = new_array_found = 1;
d8fccff5 10421 continue;
e04a16fb 10422 case CONVERT_EXPR:
f2760b27
APB		 10423 break;
10424 case NEW_CLASS_EXPR:
e04a16fb
AG		 10425 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10426 break;
c583dd46
APB		 10427 case ARRAY_REF:
10428 while (TREE_CODE (qual_wfl) == ARRAY_REF)
10429 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10430 break;
8576f094
APB		 10431 case STRING_CST:
10432 qual = TREE_CHAIN (qual);
10433 qual_wfl = QUAL_WFL (qual);
10434 break;
165f37bc
APB		 10435 case CLASS_LITERAL:
10436 qual = TREE_CHAIN (qual);
10437 qual_wfl = QUAL_WFL (qual);
10438 break;
0a2138e2
APB		 10439 default:
10440 /* Fix for -Wall. Just break doing nothing */
10441 break;
e04a16fb 10442 }
8576f094 10443
e04a16fb
AG		 10444 ptr_type = current_class;
10445 again = 0;
8576f094
APB		 10446 code = TREE_CODE (qual_wfl);
10447
10448 /* Pos evaluation: non WFL leading expression nodes */
10449 if (code == CONVERT_EXPR
10450 && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
10451 name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
10452
cd7c5840
APB		 10453 else if (code == INTEGER_CST)
10454 name = qual_wfl;
10455
ac22f9cb 10456 else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
8576f094
APB		 10457 TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
10458 name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
10459
c2952b01
APB		 10460 else if (code == TREE_LIST)
10461 name = EXPR_WFL_NODE (TREE_PURPOSE (qual_wfl));
10462
37feda7d
APB		 10463 else if (code == STRING_CST || code == CONDITIONAL_EXPR
10464 || code == PLUS_EXPR)
8576f094
APB		 10465 {
10466 qual = TREE_CHAIN (qual);
10467 qual_wfl = QUAL_WFL (qual);
10468 again = 1;
10469 }
10470 else
f441f671
APB		 10471 {
10472 name = EXPR_WFL_NODE (qual_wfl);
10473 if (!name)
10474 {
10475 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
10476 again = 1;
10477 }
10478 }
10479
e04a16fb
AG		 10480 /* If we have a THIS (from a primary), we set the context accordingly */
10481 if (name == this_identifier_node)
10482 {
10483 qual = TREE_CHAIN (qual);
10484 qual_wfl = QUAL_WFL (qual);
22eed1e6
APB		 10485 if (TREE_CODE (qual_wfl) == CALL_EXPR)
10486 again = 1;
10487 else
10488 name = EXPR_WFL_NODE (qual_wfl);
e04a16fb
AG		 10489 this_found = 1;
10490 }
10491 /* If we have a SUPER, we set the context accordingly */
10492 if (name == super_identifier_node)
10493 {
10494 current_class = CLASSTYPE_SUPER (ptr_type);
10495 /* Check that there is such a thing as a super class. If not,
10496 return. The error will be caught later on, during the
10497 resolution */
10498 if (!current_class)
10499 {
10500 current_class = saved_current_class;
10501 return;
10502 }
10503 qual = TREE_CHAIN (qual);
10504 /* Do one more interation to set things up */
10505 super_found = again = 1;
10506 }
10507 } while (again);
10508
f2760b27
APB		 10509 /* If name appears within the scope of a local variable declaration
10510 or parameter declaration, then it is an expression name. We don't
10511 carry this test out if we're in the context of the use of SUPER
10512 or THIS */
cd7c5840
APB		 10513 if (!this_found && !super_found
10514 && TREE_CODE (name) != STRING_CST && TREE_CODE (name) != INTEGER_CST
10515 && (decl = IDENTIFIER_LOCAL_VALUE (name)))
e04a16fb
AG		 10516 {
10517 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
10518 QUAL_RESOLUTION (qual) = decl;
10519 }
10520
10521 /* If within the class/interface NAME was found to be used there
10522 exists a (possibly inherited) field named NAME, then this is an
d8fccff5
APB		 10523 expression name. If we saw a NEW_ARRAY_EXPR before and want to
10524 address length, it is OK. */
10525 else if ((decl = lookup_field_wrapper (ptr_type, name))
10526 || (new_array_found && name == length_identifier_node))
e04a16fb
AG		 10527 {
10528 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
d8fccff5 10529 QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
e04a16fb
AG		 10530 }
10531
1a6d4fb7 10532 /* We reclassify NAME as yielding to a type name resolution if:
e04a16fb
AG		 10533 - NAME is a class/interface declared within the compilation
10534 unit containing NAME,
10535 - NAME is imported via a single-type-import declaration,
10536 - NAME is declared in an another compilation unit of the package
10537 of the compilation unit containing NAME,
10538 - NAME is declared by exactly on type-import-on-demand declaration
1a6d4fb7
APB		 10539 of the compilation unit containing NAME.
10540 - NAME is actually a STRING_CST. */
cd7c5840
APB		 10541 else if (TREE_CODE (name) == STRING_CST || TREE_CODE (name) == INTEGER_CST
10542 || (decl = resolve_and_layout (name, NULL_TREE)))
e04a16fb
AG		 10543 {
10544 RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
10545 QUAL_RESOLUTION (qual) = decl;
10546 }
10547
f2760b27 10548 /* Method call, array references and cast are expression name */
9bbc7d9f 10549 else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
8576f094
APB		 10550 || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
10551 || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR)
e04a16fb
AG		 10552 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
10553
10554 /* Check here that NAME isn't declared by more than one
10555 type-import-on-demand declaration of the compilation unit
10556 containing NAME. FIXME */
10557
10558 /* Otherwise, NAME is reclassified as a package name */
10559 else
10560 RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
10561
10562 /* Propagate the qualification accross other components of the
10563 qualified name */
10564 for (qual = TREE_CHAIN (qual); qual;
10565 qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
10566 {
10567 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
10568 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
10569 else
10570 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
10571 }
10572
10573 /* Store the global qualification for the ambiguous part of ID back
10574 into ID fields */
10575 if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
10576 RESOLVE_EXPRESSION_NAME_P (id) = 1;
10577 else if (RESOLVE_TYPE_NAME_P (qual_wfl))
10578 RESOLVE_TYPE_NAME_P (id) = 1;
10579 else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
10580 RESOLVE_PACKAGE_NAME_P (id) = 1;
10581
10582 /* Restore the current class */
10583 current_class = saved_current_class;
10584}
10585
10586static int
10587breakdown_qualified (left, right, source)
10588 tree *left, *right, source;
10589{
10590 char *p = IDENTIFIER_POINTER (source), *base;
10591 int l = IDENTIFIER_LENGTH (source);
10592
10593 /* Breakdown NAME into REMAINDER . IDENTIFIER */
10594 base = p;
10595 p += (l-1);
10596 while (*p != '.' && p != base)
10597 p--;
10598
10599 /* We didn't find a '.'. Return an error */
10600 if (p == base)
10601 return 1;
10602
10603 *p = '\0';
10604 if (right)
10605 *right = get_identifier (p+1);
10606 *left = get_identifier (IDENTIFIER_POINTER (source));
10607 *p = '.';
10608
10609 return 0;
10610}
10611
e04a16fb 10612/* Patch tree nodes in a function body. When a BLOCK is found, push
5b09b33e
PB		 10613 local variable decls if present.
10614 Same as java_complete_lhs, but does resolve static finals to values. */
e04a16fb
AG		 10615
10616static tree
10617java_complete_tree (node)
10618 tree node;
5b09b33e
PB		 10619{
10620 node = java_complete_lhs (node);
10621 if (TREE_CODE (node) == VAR_DECL && FIELD_STATIC (node)
7f10c2e2
APB		 10622 && FIELD_FINAL (node) && DECL_INITIAL (node) != NULL_TREE
10623 && !flag_emit_xref)
5b09b33e
PB		 10624 {
10625 tree value = DECL_INITIAL (node);
10626 DECL_INITIAL (node) = NULL_TREE;
100f7cd8 10627 push_obstacks (&permanent_obstack, &permanent_obstack);
5b09b33e 10628 value = fold_constant_for_init (value, node);
100f7cd8 10629 pop_obstacks ();
5b09b33e
PB		 10630 DECL_INITIAL (node) = value;
10631 if (value != NULL_TREE)
c2952b01
APB		 10632 {
10633 /* fold_constant_for_init sometimes widen the original type
10634 of the constant (i.e. byte to int.) It's not desirable,
10635 especially if NODE is a function argument. */
10636 if (TREE_CODE (value) == INTEGER_CST
10637 && TREE_TYPE (node) != TREE_TYPE (value))
10638 return convert (TREE_TYPE (node), value);
10639 else
10640 return value;
10641 }
5b09b33e
PB		 10642 }
10643 return node;
10644}
10645
2aa11e97
APB		 10646static tree
10647java_stabilize_reference (node)
10648 tree node;
10649{
10650 if (TREE_CODE (node) == COMPOUND_EXPR)
10651 {
10652 tree op0 = TREE_OPERAND (node, 0);
10653 tree op1 = TREE_OPERAND (node, 1);
642f15d1 10654 TREE_OPERAND (node, 0) = save_expr (op0);
2aa11e97
APB		 10655 TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
10656 return node;
10657 }
5cbdba64 10658 return stabilize_reference (node);
2aa11e97
APB		 10659}
10660
5b09b33e
PB		 10661/* Patch tree nodes in a function body. When a BLOCK is found, push
10662 local variable decls if present.
10663 Same as java_complete_tree, but does not resolve static finals to values. */
10664
10665static tree
10666java_complete_lhs (node)
10667 tree node;
e04a16fb 10668{
22eed1e6 10669 tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
b67d701b 10670 int flag;
e04a16fb
AG		 10671
10672 /* CONVERT_EXPR always has its type set, even though it needs to be
b67d701b 10673 worked out. */
e04a16fb
AG		 10674 if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
10675 return node;
10676
10677 /* The switch block implements cases processing container nodes
10678 first. Contained nodes are always written back. Leaves come
10679 next and return a value. */
10680 switch (TREE_CODE (node))
10681 {
10682 case BLOCK:
10683
10684 /* 1- Block section.
10685 Set the local values on decl names so we can identify them
10686 faster when they're referenced. At that stage, identifiers
10687 are legal so we don't check for declaration errors. */
10688 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
10689 {
10690 DECL_CONTEXT (cn) = current_function_decl;
10691 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
e04a16fb 10692 }
15fdcfe9
PB		 10693 if (BLOCK_EXPR_BODY (node) == NULL_TREE)
10694 CAN_COMPLETE_NORMALLY (node) = 1;
10695 else
e04a16fb 10696 {
15fdcfe9
PB		 10697 tree stmt = BLOCK_EXPR_BODY (node);
10698 tree *ptr;
10699 int error_seen = 0;
10700 if (TREE_CODE (stmt) == COMPOUND_EXPR)
10701 {
c877974e
APB		 10702 /* Re-order from (((A; B); C); ...; Z) to
10703 (A; (B; (C ; (...; Z)))).
15fdcfe9
PB		 10704 This makes it easier to scan the statements left-to-right
10705 without using recursion (which might overflow the stack
10706 if the block has many statements. */
10707 for (;;)
10708 {
10709 tree left = TREE_OPERAND (stmt, 0);
10710 if (TREE_CODE (left) != COMPOUND_EXPR)
10711 break;
10712 TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
10713 TREE_OPERAND (left, 1) = stmt;
10714 stmt = left;
10715 }
10716 BLOCK_EXPR_BODY (node) = stmt;
10717 }
10718
c877974e
APB		 10719 /* Now do the actual complete, without deep recursion for
10720 long blocks. */
15fdcfe9 10721 ptr = &BLOCK_EXPR_BODY (node);
dc0b3eff
PB		 10722 while (TREE_CODE (*ptr) == COMPOUND_EXPR
10723 && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
15fdcfe9
PB		 10724 {
10725 tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
10726 tree *next = &TREE_OPERAND (*ptr, 1);
10727 TREE_OPERAND (*ptr, 0) = cur;
cd9643f7
PB		 10728 if (cur == empty_stmt_node)
10729 {
10730 /* Optimization; makes it easier to detect empty bodies.
10731 Most useful for <clinit> with all-constant initializer. */
10732 *ptr = *next;
10733 continue;
10734 }
15fdcfe9
PB		 10735 if (TREE_CODE (cur) == ERROR_MARK)
10736 error_seen++;
10737 else if (! CAN_COMPLETE_NORMALLY (cur))
10738 {
10739 wfl_op2 = *next;
10740 for (;;)
10741 {
10742 if (TREE_CODE (wfl_op2) == BLOCK)
10743 wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
10744 else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
10745 wfl_op2 = TREE_OPERAND (wfl_op2, 0);
10746 else
10747 break;
10748 }
10749 if (TREE_CODE (wfl_op2) != CASE_EXPR
dc0b3eff 10750 && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
82371d41 10751 unreachable_stmt_error (*ptr);
15fdcfe9
PB		 10752 }
10753 ptr = next;
10754 }
10755 *ptr = java_complete_tree (*ptr);
10756
10757 if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
e04a16fb 10758 return error_mark_node;
15fdcfe9 10759 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
e04a16fb
AG		 10760 }
10761 /* Turn local bindings to null */
10762 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
10763 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
10764
10765 TREE_TYPE (node) = void_type_node;
10766 break;
10767
10768 /* 2- They are expressions but ultimately deal with statements */
b67d701b 10769
b9f7e36c
APB		 10770 case THROW_EXPR:
10771 wfl_op1 = TREE_OPERAND (node, 0);
10772 COMPLETE_CHECK_OP_0 (node);
c2952b01
APB		 10773 /* 14.19 A throw statement cannot complete normally. */
10774 CAN_COMPLETE_NORMALLY (node) = 0;
b9f7e36c
APB		 10775 return patch_throw_statement (node, wfl_op1);
10776
10777 case SYNCHRONIZED_EXPR:
10778 wfl_op1 = TREE_OPERAND (node, 0);
b9f7e36c
APB		 10779 return patch_synchronized_statement (node, wfl_op1);
10780
b67d701b
PB		 10781 case TRY_EXPR:
10782 return patch_try_statement (node);
10783
a7d8d81f
PB		 10784 case TRY_FINALLY_EXPR:
10785 COMPLETE_CHECK_OP_0 (node);
10786 COMPLETE_CHECK_OP_1 (node);
10787 CAN_COMPLETE_NORMALLY (node)
10788 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
10789 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
10790 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
10791 return node;
10792
5a005d9e
PB		 10793 case CLEANUP_POINT_EXPR:
10794 COMPLETE_CHECK_OP_0 (node);
10795 TREE_TYPE (node) = void_type_node;
2aa11e97
APB		 10796 CAN_COMPLETE_NORMALLY (node) =
10797 CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
5a005d9e
PB		 10798 return node;
10799
10800 case WITH_CLEANUP_EXPR:
10801 COMPLETE_CHECK_OP_0 (node);
10802 COMPLETE_CHECK_OP_2 (node);
2aa11e97
APB		 10803 CAN_COMPLETE_NORMALLY (node) =
10804 CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
5a005d9e
PB		 10805 TREE_TYPE (node) = void_type_node;
10806 return node;
10807
e04a16fb
AG		 10808 case LABELED_BLOCK_EXPR:
10809 PUSH_LABELED_BLOCK (node);
10810 if (LABELED_BLOCK_BODY (node))
10811 COMPLETE_CHECK_OP_1 (node);
10812 TREE_TYPE (node) = void_type_node;
10813 POP_LABELED_BLOCK ();
1fb89a4d
APB		 10814
10815 if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
9dd939b2
APB		 10816 {
10817 LABELED_BLOCK_BODY (node) = NULL_TREE;
10818 CAN_COMPLETE_NORMALLY (node) = 1;
10819 }
1fb89a4d 10820 else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
15fdcfe9 10821 CAN_COMPLETE_NORMALLY (node) = 1;
e04a16fb
AG		 10822 return node;
10823
10824 case EXIT_BLOCK_EXPR:
10825 /* We don't complete operand 1, because it's the return value of
10826 the EXIT_BLOCK_EXPR which doesn't exist it Java */
10827 return patch_bc_statement (node);
10828
15fdcfe9
PB		 10829 case CASE_EXPR:
10830 cn = java_complete_tree (TREE_OPERAND (node, 0));
10831 if (cn == error_mark_node)
10832 return cn;
10833
8576f094
APB		 10834 /* First, the case expression must be constant. Values of final
10835 fields are accepted. */
15fdcfe9 10836 cn = fold (cn);
8576f094
APB		 10837 if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
10838 && JDECL_P (TREE_OPERAND (cn, 1))
10839 && FIELD_FINAL (TREE_OPERAND (cn, 1))
10840 && DECL_INITIAL (TREE_OPERAND (cn, 1)))
100f7cd8
APB		 10841 {
10842 push_obstacks (&permanent_obstack, &permanent_obstack);
10843 cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
10844 TREE_OPERAND (cn, 1));
10845 pop_obstacks ();
10846 }
15fdcfe9 10847
ce6e9147 10848 if (!TREE_CONSTANT (cn) && !flag_emit_xref)
15fdcfe9
PB		 10849 {
10850 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10851 parse_error_context (node, "Constant expression required");
10852 return error_mark_node;
10853 }
10854
10855 nn = ctxp->current_loop;
10856
10857 /* It must be assignable to the type of the switch expression. */
c877974e
APB		 10858 if (!try_builtin_assignconv (NULL_TREE,
10859 TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
15fdcfe9
PB		 10860 {
10861 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10862 parse_error_context
10863 (wfl_operator,
10864 "Incompatible type for case. Can't convert `%s' to `int'",
10865 lang_printable_name (TREE_TYPE (cn), 0));
10866 return error_mark_node;
10867 }
10868
10869 cn = fold (convert (int_type_node, cn));
10870
10871 /* Multiple instance of a case label bearing the same
10872 value is checked during code generation. The case
10873 expression is allright so far. */
10874 TREE_OPERAND (node, 0) = cn;
9bbc7d9f 10875 TREE_TYPE (node) = void_type_node;
15fdcfe9 10876 CAN_COMPLETE_NORMALLY (node) = 1;
10100cc7 10877 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9
PB		 10878 break;
10879
10880 case DEFAULT_EXPR:
10881 nn = ctxp->current_loop;
10882 /* Only one default label is allowed per switch statement */
10883 if (SWITCH_HAS_DEFAULT (nn))
10884 {
10885 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10886 parse_error_context (wfl_operator,
10887 "Duplicate case label: `default'");
10888 return error_mark_node;
10889 }
10890 else
10891 SWITCH_HAS_DEFAULT (nn) = 1;
9bbc7d9f 10892 TREE_TYPE (node) = void_type_node;
10100cc7 10893 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9
PB		 10894 CAN_COMPLETE_NORMALLY (node) = 1;
10895 break;
10896
b67d701b 10897 case SWITCH_EXPR:
e04a16fb
AG		 10898 case LOOP_EXPR:
10899 PUSH_LOOP (node);
10900 /* Check whether the loop was enclosed in a labeled
10901 statement. If not, create one, insert the loop in it and
10902 return the node */
10903 nn = patch_loop_statement (node);
b67d701b 10904
e04a16fb 10905 /* Anyways, walk the body of the loop */
b67d701b
PB		 10906 if (TREE_CODE (node) == LOOP_EXPR)
10907 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10908 /* Switch statement: walk the switch expression and the cases */
10909 else
10910 node = patch_switch_statement (node);
10911
e04a16fb 10912 if (TREE_OPERAND (node, 0) == error_mark_node)
b635eb2f
PB		 10913 nn = error_mark_node;
10914 else
15fdcfe9 10915 {
b635eb2f
PB		 10916 TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
10917 /* If we returned something different, that's because we
10918 inserted a label. Pop the label too. */
10919 if (nn != node)
10920 {
10921 if (CAN_COMPLETE_NORMALLY (node))
10922 CAN_COMPLETE_NORMALLY (nn) = 1;
10923 POP_LABELED_BLOCK ();
10924 }
15fdcfe9 10925 }
e04a16fb
AG		 10926 POP_LOOP ();
10927 return nn;
10928
10929 case EXIT_EXPR:
10930 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10931 return patch_exit_expr (node);
10932
10933 case COND_EXPR:
10934 /* Condition */
10935 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10936 if (TREE_OPERAND (node, 0) == error_mark_node)
10937 return error_mark_node;
10938 /* then-else branches */
10939 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
10940 if (TREE_OPERAND (node, 1) == error_mark_node)
10941 return error_mark_node;
10942 TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
10943 if (TREE_OPERAND (node, 2) == error_mark_node)
10944 return error_mark_node;
10945 return patch_if_else_statement (node);
10946 break;
10947
22eed1e6
APB		 10948 case CONDITIONAL_EXPR:
10949 /* Condition */
10950 wfl_op1 = TREE_OPERAND (node, 0);
10951 COMPLETE_CHECK_OP_0 (node);
10952 wfl_op2 = TREE_OPERAND (node, 1);
10953 COMPLETE_CHECK_OP_1 (node);
10954 wfl_op3 = TREE_OPERAND (node, 2);
10955 COMPLETE_CHECK_OP_2 (node);
10956 return patch_conditional_expr (node, wfl_op1, wfl_op2);
10957
e04a16fb
AG		 10958 /* 3- Expression section */
10959 case COMPOUND_EXPR:
15fdcfe9 10960 wfl_op2 = TREE_OPERAND (node, 1);
ac825856
APB		 10961 TREE_OPERAND (node, 0) = nn =
10962 java_complete_tree (TREE_OPERAND (node, 0));
dc0b3eff
PB		 10963 if (wfl_op2 == empty_stmt_node)
10964 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
10965 else
15fdcfe9 10966 {
dc0b3eff 10967 if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
bccaf73a 10968 {
dc0b3eff
PB		 10969 /* An unreachable condition in a do-while statement
10970 is *not* (technically) an unreachable statement. */
10971 nn = wfl_op2;
10972 if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
10973 nn = EXPR_WFL_NODE (nn);
10974 if (TREE_CODE (nn) != EXIT_EXPR)
10975 {
10976 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
10977 parse_error_context (wfl_operator, "Unreachable statement");
10978 }
bccaf73a 10979 }
dc0b3eff
PB		 10980 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
10981 if (TREE_OPERAND (node, 1) == error_mark_node)
10982 return error_mark_node;
10983 CAN_COMPLETE_NORMALLY (node)
10984 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1));
15fdcfe9 10985 }
e04a16fb
AG		 10986 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
10987 break;
10988
10989 case RETURN_EXPR:
15fdcfe9 10990 /* CAN_COMPLETE_NORMALLY (node) = 0; */
e04a16fb
AG		 10991 return patch_return (node);
10992
10993 case EXPR_WITH_FILE_LOCATION:
10994 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
10995 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
15fdcfe9 10996 {
5423609c 10997 tree wfl = node;
15fdcfe9 10998 node = resolve_expression_name (node, NULL);
dc0b3eff
PB		 10999 if (node == error_mark_node)
11000 return node;
5423609c
APB		 11001 /* Keep line number information somewhere were it doesn't
11002 disrupt the completion process. */
2c56429a 11003 if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
5423609c
APB		 11004 {
11005 EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11006 TREE_OPERAND (node, 1) = wfl;
11007 }
15fdcfe9
PB		 11008 CAN_COMPLETE_NORMALLY (node) = 1;
11009 }
e04a16fb
AG		 11010 else
11011 {
5b09b33e
PB		 11012 tree body;
11013 int save_lineno = lineno;
11014 lineno = EXPR_WFL_LINENO (node);
11015 body = java_complete_tree (EXPR_WFL_NODE (node));
11016 lineno = save_lineno;
15fdcfe9 11017 EXPR_WFL_NODE (node) = body;
dc0b3eff 11018 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
15fdcfe9 11019 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
cd9643f7
PB		 11020 if (body == empty_stmt_node)
11021 {
11022 /* Optimization; makes it easier to detect empty bodies. */
11023 return body;
11024 }
dc0b3eff 11025 if (body == error_mark_node)
e04a16fb
AG		 11026 {
11027 /* Its important for the evaluation of assignment that
11028 this mark on the TREE_TYPE is propagated. */
11029 TREE_TYPE (node) = error_mark_node;
11030 return error_mark_node;
11031 }
11032 else
11033 TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
15fdcfe9 11034
e04a16fb
AG		 11035 }
11036 break;
11037
b67d701b 11038 case NEW_ARRAY_EXPR:
e04a16fb
AG		 11039 /* Patch all the dimensions */
11040 flag = 0;
11041 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11042 {
11043 int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
3a1760ac
APB		 11044 tree dim = convert (int_type_node,
11045 java_complete_tree (TREE_VALUE (cn)));
e04a16fb
AG		 11046 if (dim == error_mark_node)
11047 {
11048 flag = 1;
11049 continue;
11050 }
11051 else
11052 {
b9f7e36c 11053 TREE_VALUE (cn) = dim;
e04a16fb
AG		 11054 /* Setup the location of the current dimension, for
11055 later error report. */
11056 TREE_PURPOSE (cn) =
11057 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11058 EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11059 }
11060 }
11061 /* They complete the array creation expression, if no errors
11062 were found. */
15fdcfe9 11063 CAN_COMPLETE_NORMALLY (node) = 1;
aee48ef8
PB		 11064 return (flag ? error_mark_node
11065 : force_evaluation_order (patch_newarray (node)));
e04a16fb 11066
c2952b01
APB		 11067 case NEW_ANONYMOUS_ARRAY_EXPR:
11068 /* Create the array type if necessary. */
11069 if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11070 {
11071 tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11072 if (!(type = resolve_type_during_patch (type)))
11073 return error_mark_node;
11074 type = build_array_from_name (type, NULL_TREE,
11075 ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11076 ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11077 }
11078 node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11079 ANONYMOUS_ARRAY_INITIALIZER (node));
11080 if (node == error_mark_node)
11081 return error_mark_node;
11082 CAN_COMPLETE_NORMALLY (node) = 1;
11083 return node;
11084
b67d701b 11085 case NEW_CLASS_EXPR:
e04a16fb 11086 case CALL_EXPR:
b67d701b 11087 /* Complete function's argument(s) first */
e04a16fb
AG		 11088 if (complete_function_arguments (node))
11089 return error_mark_node;
11090 else
b9f7e36c 11091 {
22eed1e6
APB		 11092 tree decl, wfl = TREE_OPERAND (node, 0);
11093 int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11094
c877974e 11095 node = patch_method_invocation (node, NULL_TREE,
89e09b9a 11096 NULL_TREE, 0, &decl);
c877974e
APB		 11097 if (node == error_mark_node)
11098 return error_mark_node;
11099
11100 check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
11101 /* If we call this(...), register signature and positions */
11102 if (in_this)
11103 DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11104 tree_cons (wfl, decl,
11105 DECL_CONSTRUCTOR_CALLS (current_function_decl));
de4c7b02 11106 CAN_COMPLETE_NORMALLY (node) = 1;
dc0b3eff 11107 return force_evaluation_order (node);
b9f7e36c 11108 }
e04a16fb
AG		 11109
11110 case MODIFY_EXPR:
11111 /* Save potential wfls */
11112 wfl_op1 = TREE_OPERAND (node, 0);
cd9643f7 11113 TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
c2952b01 11114
cd9643f7
PB		 11115 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11116 && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11117 && DECL_INITIAL (nn) != NULL_TREE)
11118 {
100f7cd8
APB		 11119 tree value;
11120
11121 push_obstacks (&permanent_obstack, &permanent_obstack);
11122 value = fold_constant_for_init (nn, nn);
11123 pop_obstacks ();
c2952b01 11124
cd9643f7
PB		 11125 if (value != NULL_TREE)
11126 {
11127 tree type = TREE_TYPE (value);
c2952b01
APB		 11128 if (JPRIMITIVE_TYPE_P (type) ||
11129 (type == string_ptr_type_node && ! flag_emit_class_files))
cd9643f7
PB		 11130 return empty_stmt_node;
11131 }
11132 DECL_INITIAL (nn) = NULL_TREE;
11133 }
e04a16fb 11134 wfl_op2 = TREE_OPERAND (node, 1);
cd9643f7 11135
e04a16fb
AG		 11136 if (TREE_OPERAND (node, 0) == error_mark_node)
11137 return error_mark_node;
11138
5cbdba64
APB		 11139 flag = COMPOUND_ASSIGN_P (wfl_op2);
11140 if (flag)
e04a16fb 11141 {
c2952b01
APB		 11142 /* This might break when accessing outer field from inner
11143 class. TESTME, FIXME */
2aa11e97 11144 tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
e04a16fb
AG		 11145
11146 /* Hand stablize the lhs on both places */
e04a16fb 11147 TREE_OPERAND (node, 0) = lvalue;
5cbdba64
APB		 11148 TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11149 (flag_emit_class_files ? lvalue : save_expr (lvalue));
2aa11e97 11150
5cbdba64 11151 /* 15.25.2.a: Left hand is not an array access. FIXME */
2aa11e97
APB		 11152 /* Now complete the RHS. We write it back later on. */
11153 nn = java_complete_tree (TREE_OPERAND (node, 1));
11154
642f15d1
APB		 11155 if ((cn = patch_string (nn)))
11156 nn = cn;
11157
2aa11e97
APB		 11158 /* The last part of the rewrite for E1 op= E2 is to have
11159 E1 = (T)(E1 op E2), with T being the type of E1. */
642f15d1
APB		 11160 nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
11161 TREE_TYPE (lvalue), nn));
5cbdba64
APB		 11162
11163 /* 15.25.2.b: Left hand is an array access. FIXME */
e04a16fb
AG		 11164 }
11165
f8976021 11166 /* If we're about to patch a NEW_ARRAY_INIT, we call a special
c2952b01
APB		 11167 function to complete this RHS. Note that a NEW_ARRAY_INIT
11168 might have been already fully expanded if created as a result
11169 of processing an anonymous array initializer. We avoid doing
11170 the operation twice by testing whether the node already bears
11171 a type. */
11172 else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
fdec99c6 11173 nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
f8976021 11174 TREE_OPERAND (node, 1));
2aa11e97 11175 /* Otherwise we simply complete the RHS */
f8976021
APB		 11176 else
11177 nn = java_complete_tree (TREE_OPERAND (node, 1));
11178
e04a16fb 11179 if (nn == error_mark_node)
c0d87ff6 11180 return error_mark_node;
2aa11e97
APB		 11181
11182 /* Write back the RHS as we evaluated it. */
e04a16fb 11183 TREE_OPERAND (node, 1) = nn;
b67d701b
PB		 11184
11185 /* In case we're handling = with a String as a RHS, we need to
11186 produce a String out of the RHS (it might still be a
11187 STRING_CST or a StringBuffer at this stage */
11188 if ((nn = patch_string (TREE_OPERAND (node, 1))))
11189 TREE_OPERAND (node, 1) = nn;
c2952b01
APB		 11190
11191 if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
11192 TREE_OPERAND (node, 1))))
11193 {
11194 /* We return error_mark_node if outer_field_access_fix
11195 detects we write into a final. */
11196 if (nn == error_mark_node)
11197 return error_mark_node;
11198 node = nn;
11199 }
11200 else
11201 {
11202 node = patch_assignment (node, wfl_op1, wfl_op2);
11203 /* Reorganize the tree if necessary. */
11204 if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
11205 || JSTRING_P (TREE_TYPE (node))))
11206 node = java_refold (node);
11207 }
11208
15fdcfe9
PB		 11209 CAN_COMPLETE_NORMALLY (node) = 1;
11210 return node;
e04a16fb
AG		 11211
11212 case MULT_EXPR:
11213 case PLUS_EXPR:
11214 case MINUS_EXPR:
11215 case LSHIFT_EXPR:
11216 case RSHIFT_EXPR:
11217 case URSHIFT_EXPR:
11218 case BIT_AND_EXPR:
11219 case BIT_XOR_EXPR:
11220 case BIT_IOR_EXPR:
11221 case TRUNC_MOD_EXPR:
c2952b01 11222 case TRUNC_DIV_EXPR:
e04a16fb
AG		 11223 case RDIV_EXPR:
11224 case TRUTH_ANDIF_EXPR:
11225 case TRUTH_ORIF_EXPR:
11226 case EQ_EXPR:
11227 case NE_EXPR:
11228 case GT_EXPR:
11229 case GE_EXPR:
11230 case LT_EXPR:
11231 case LE_EXPR:
11232 /* Operands 0 and 1 are WFL in certain cases only. patch_binop
11233 knows how to handle those cases. */
11234 wfl_op1 = TREE_OPERAND (node, 0);
11235 wfl_op2 = TREE_OPERAND (node, 1);
b67d701b 11236
15fdcfe9 11237 CAN_COMPLETE_NORMALLY (node) = 1;
b67d701b
PB		 11238 /* Don't complete string nodes if dealing with the PLUS operand. */
11239 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
2aa11e97
APB		 11240 {
11241 nn = java_complete_tree (wfl_op1);
11242 if (nn == error_mark_node)
11243 return error_mark_node;
48a840d9 11244
2aa11e97
APB		 11245 TREE_OPERAND (node, 0) = nn;
11246 }
b67d701b 11247 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
2aa11e97
APB		 11248 {
11249 nn = java_complete_tree (wfl_op2);
11250 if (nn == error_mark_node)
11251 return error_mark_node;
48a840d9 11252
2aa11e97
APB		 11253 TREE_OPERAND (node, 1) = nn;
11254 }
dc0b3eff 11255 return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
e04a16fb 11256
5e942c50
APB		 11257 case INSTANCEOF_EXPR:
11258 wfl_op1 = TREE_OPERAND (node, 0);
11259 COMPLETE_CHECK_OP_0 (node);
ce6e9147
APB		 11260 if (flag_emit_xref)
11261 {
11262 TREE_TYPE (node) = boolean_type_node;
11263 return node;
11264 }
5e942c50
APB		 11265 return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
11266
b67d701b 11267 case UNARY_PLUS_EXPR:
e04a16fb
AG		 11268 case NEGATE_EXPR:
11269 case TRUTH_NOT_EXPR:
11270 case BIT_NOT_EXPR:
11271 case PREDECREMENT_EXPR:
11272 case PREINCREMENT_EXPR:
11273 case POSTDECREMENT_EXPR:
11274 case POSTINCREMENT_EXPR:
11275 case CONVERT_EXPR:
11276 /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
11277 how to handle those cases. */
11278 wfl_op1 = TREE_OPERAND (node, 0);
15fdcfe9 11279 CAN_COMPLETE_NORMALLY (node) = 1;
e04a16fb
AG		 11280 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
11281 if (TREE_OPERAND (node, 0) == error_mark_node)
11282 return error_mark_node;
4a5f66c3
APB		 11283 node = patch_unaryop (node, wfl_op1);
11284 CAN_COMPLETE_NORMALLY (node) = 1;
11285 break;
e04a16fb
AG		 11286
11287 case ARRAY_REF:
11288 /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
11289 how to handle those cases. */
11290 wfl_op1 = TREE_OPERAND (node, 0);
11291 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
11292 if (TREE_OPERAND (node, 0) == error_mark_node)
11293 return error_mark_node;
7f1d4866 11294 if (!flag_emit_class_files && !flag_emit_xref)
b67d701b 11295 TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
e04a16fb
AG		 11296 /* The same applies to wfl_op2 */
11297 wfl_op2 = TREE_OPERAND (node, 1);
11298 TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
11299 if (TREE_OPERAND (node, 1) == error_mark_node)
11300 return error_mark_node;
7f1d4866 11301 if (!flag_emit_class_files && !flag_emit_xref)
22eed1e6 11302 TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
939d7216 11303 return patch_array_ref (node);
e04a16fb 11304
63a212ed
PB		 11305 case RECORD_TYPE:
11306 return node;;
11307
11308 case COMPONENT_REF:
11309 /* The first step in the re-write of qualified name handling. FIXME.
11310 So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
9bbc7d9f 11311 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
63a212ed
PB		 11312 if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
11313 {
11314 tree name = TREE_OPERAND (node, 1);
11315 tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
11316 if (field == NULL_TREE)
11317 {
11318 error ("missing static field `%s'", IDENTIFIER_POINTER (name));
11319 return error_mark_node;
11320 }
11321 if (! FIELD_STATIC (field))
11322 {
11323 error ("not a static field `%s'", IDENTIFIER_POINTER (name));
11324 return error_mark_node;
11325 }
11326 return field;
11327 }
11328 else
11329 fatal ("unimplemented java_complete_tree for COMPONENT_REF");
9bbc7d9f 11330 break;
9bbc7d9f 11331
b67d701b 11332 case THIS_EXPR:
e04a16fb
AG		 11333 /* Can't use THIS in a static environment */
11334 if (!current_this)
11335 {
11336 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
781b0558
KG		 11337 parse_error_context (wfl_operator,
11338 "Keyword `this' used outside allowed context");
e04a16fb
AG		 11339 TREE_TYPE (node) = error_mark_node;
11340 return error_mark_node;
11341 }
22eed1e6
APB		 11342 if (ctxp->explicit_constructor_p)
11343 {
11344 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11345 parse_error_context
781b0558 11346 (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
22eed1e6
APB		 11347 TREE_TYPE (node) = error_mark_node;
11348 return error_mark_node;
11349 }
e04a16fb 11350 return current_this;
c2952b01
APB		 11351
11352 case CLASS_LITERAL:
11353 CAN_COMPLETE_NORMALLY (node) = 1;
11354 node = patch_incomplete_class_ref (node);
11355 if (node == error_mark_node)
11356 return error_mark_node;
11357 break;
11358
11359 case INSTANCE_INITIALIZERS_EXPR:
11360 in_instance_initializer++;
11361 node = java_complete_tree (TREE_OPERAND (node, 0));
11362 in_instance_initializer--;
11363 if (node != error_mark_node)
11364 TREE_TYPE (node) = void_type_node;
11365 else
11366 return error_mark_node;
11367 break;
e04a16fb 11368
e04a16fb 11369 default:
15fdcfe9 11370 CAN_COMPLETE_NORMALLY (node) = 1;
b67d701b 11371 /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
c2952b01
APB		 11372 and it's time to turn it into the appropriate String object */
11373 if ((nn = patch_string (node)))
11374 node = nn;
11375 else
11376 fatal ("No case for tree code `%s' - java_complete_tree\n",
11377 tree_code_name [TREE_CODE (node)]);
e04a16fb
AG		 11378 }
11379 return node;
11380}
11381
11382/* Complete function call's argument. Return a non zero value is an
11383 error was found. */
11384
11385static int
11386complete_function_arguments (node)
11387 tree node;
11388{
11389 int flag = 0;
11390 tree cn;
11391
f63991a8 11392 ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
e04a16fb
AG		 11393 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11394 {
b67d701b 11395 tree wfl = TREE_VALUE (cn), parm, temp;
e04a16fb 11396 parm = java_complete_tree (wfl);
c2952b01 11397
e04a16fb
AG		 11398 if (parm == error_mark_node)
11399 {
11400 flag = 1;
11401 continue;
11402 }
b67d701b
PB		 11403 /* If have a string literal that we haven't transformed yet or a
11404 crafted string buffer, as a result of use of the the String
11405 `+' operator. Build `parm.toString()' and expand it. */
11406 if ((temp = patch_string (parm)))
b9f7e36c 11407 parm = temp;
5e942c50
APB		 11408 /* Inline PRIMTYPE.TYPE read access */
11409 parm = maybe_build_primttype_type_ref (parm, wfl);
b9f7e36c 11410
5e942c50 11411 TREE_VALUE (cn) = parm;
e04a16fb 11412 }
f63991a8 11413 ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
e04a16fb
AG		 11414 return flag;
11415}
11416
11417/* Sometimes (for loops and variable initialized during their
11418 declaration), we want to wrap a statement around a WFL and turn it
11419 debugable. */
11420
11421static tree
11422build_debugable_stmt (location, stmt)
11423 int location;
11424 tree stmt;
11425{
11426 if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
11427 {
11428 stmt = build_expr_wfl (stmt, input_filename, 0, 0);
11429 EXPR_WFL_LINECOL (stmt) = location;
11430 }
11431 JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
11432 return stmt;
11433}
11434
11435static tree
11436build_expr_block (body, decls)
11437 tree body, decls;
11438{
11439 tree node = make_node (BLOCK);
11440 BLOCK_EXPR_DECLS (node) = decls;
b67d701b 11441 BLOCK_EXPR_BODY (node) = body;
e04a16fb
AG		 11442 if (body)
11443 TREE_TYPE (node) = TREE_TYPE (body);
11444 TREE_SIDE_EFFECTS (node) = 1;
11445 return node;
11446}
11447
b67d701b
PB		 11448/* Create a new function block and link it approriately to current
11449 function block chain */
e04a16fb
AG		 11450
11451static tree
11452enter_block ()
11453{
b67d701b
PB		 11454 return (enter_a_block (build_expr_block (NULL_TREE, NULL_TREE)));
11455}
11456
11457/* Link block B supercontext to the previous block. The current
11458 function DECL is used as supercontext when enter_a_block is called
11459 for the first time for a given function. The current function body
11460 (DECL_FUNCTION_BODY) is set to be block B. */
11461
11462static tree
11463enter_a_block (b)
11464 tree b;
11465{
e04a16fb
AG		 11466 tree fndecl = current_function_decl;
11467
f099f336
APB		 11468 if (!fndecl) {
11469 BLOCK_SUPERCONTEXT (b) = current_static_block;
11470 current_static_block = b;
11471 }
11472
11473 else if (!DECL_FUNCTION_BODY (fndecl))
e04a16fb
AG		 11474 {
11475 BLOCK_SUPERCONTEXT (b) = fndecl;
11476 DECL_FUNCTION_BODY (fndecl) = b;
11477 }
11478 else
11479 {
11480 BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
11481 DECL_FUNCTION_BODY (fndecl) = b;
11482 }
11483 return b;
11484}
11485
11486/* Exit a block by changing the current function body
11487 (DECL_FUNCTION_BODY) to the current block super context, only if
11488 the block being exited isn't the method's top level one. */
11489
11490static tree
11491exit_block ()
11492{
f099f336
APB		 11493 tree b;
11494 if (current_function_decl)
11495 {
11496 b = DECL_FUNCTION_BODY (current_function_decl);
11497 if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
11498 DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
11499 }
11500 else
11501 {
11502 b = current_static_block;
e04a16fb 11503
f099f336
APB		 11504 if (BLOCK_SUPERCONTEXT (b))
11505 current_static_block = BLOCK_SUPERCONTEXT (b);
11506 }
e04a16fb
AG		 11507 return b;
11508}
11509
11510/* Lookup for NAME in the nested function's blocks, all the way up to
11511 the current toplevel one. It complies with Java's local variable
11512 scoping rules. */
11513
11514static tree
11515lookup_name_in_blocks (name)
11516 tree name;
11517{
f099f336 11518 tree b = GET_CURRENT_BLOCK (current_function_decl);
e04a16fb
AG		 11519
11520 while (b != current_function_decl)
11521 {
11522 tree current;
11523
11524 /* Paranoid sanity check. To be removed */
11525 if (TREE_CODE (b) != BLOCK)
11526 fatal ("non block expr function body - lookup_name_in_blocks");
11527
11528 for (current = BLOCK_EXPR_DECLS (b); current;
11529 current = TREE_CHAIN (current))
11530 if (DECL_NAME (current) == name)
11531 return current;
11532 b = BLOCK_SUPERCONTEXT (b);
11533 }
11534 return NULL_TREE;
11535}
11536
11537static void
11538maybe_absorb_scoping_blocks ()
11539{
f099f336 11540 while (BLOCK_EXPR_ORIGIN (GET_CURRENT_BLOCK (current_function_decl)))
e04a16fb
AG		 11541 {
11542 tree b = exit_block ();
11543 java_method_add_stmt (current_function_decl, b);
11544 SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
11545 }
11546}
11547
11548\f
11549/* This section of the source is reserved to build_* functions that
11550 are building incomplete tree nodes and the patch_* functions that
11551 are completing them. */
11552
c2952b01
APB		 11553/* Wrap a non WFL node around a WFL. */
11554static tree
9a7ab4b3 11555build_wfl_wrap (node, location)
c2952b01 11556 tree node;
9a7ab4b3 11557 int location;
c2952b01
APB		 11558{
11559 tree wfl, node_to_insert = node;
11560
11561 /* We want to process THIS . xxx symbolicaly, to keep it consistent
11562 with the way we're processing SUPER. A THIS from a primary as a
11563 different form than a SUPER. Turn THIS into something symbolic */
11564 if (TREE_CODE (node) == THIS_EXPR)
11565 node_to_insert = wfl = build_wfl_node (this_identifier_node);
11566 else
11567 wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
11568
9a7ab4b3 11569 EXPR_WFL_LINECOL (wfl) = location;
c2952b01
APB		 11570 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
11571 return wfl;
11572}
11573
11574
9bbc7d9f 11575/* Build a super() constructor invocation. Returns empty_stmt_node if
22eed1e6
APB		 11576 we're currently dealing with the class java.lang.Object. */
11577
11578static tree
e920ebc9
APB		 11579build_super_invocation (mdecl)
11580 tree mdecl;
22eed1e6 11581{
e920ebc9 11582 if (DECL_CONTEXT (mdecl) == object_type_node)
9bbc7d9f 11583 return empty_stmt_node;
22eed1e6
APB		 11584 else
11585 {
9ee9b555 11586 tree super_wfl = build_wfl_node (super_identifier_node);
c2952b01
APB		 11587 tree a = NULL_TREE, t;
11588 /* If we're dealing with an anonymous class, pass the arguments
11589 of the crafted constructor along. */
11590 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
11591 {
11592 SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
11593 for (; t != end_params_node; t = TREE_CHAIN (t))
11594 a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
11595 }
11596 return build_method_invocation (super_wfl, a);
22eed1e6
APB		 11597 }
11598}
11599
11600/* Build a SUPER/THIS qualified method invocation. */
11601
11602static tree
11603build_this_super_qualified_invocation (use_this, name, args, lloc, rloc)
11604 int use_this;
11605 tree name, args;
11606 int lloc, rloc;
22eed1e6
APB		 11607{
11608 tree invok;
11609 tree wfl =
9ee9b555 11610 build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
22eed1e6
APB		 11611 EXPR_WFL_LINECOL (wfl) = lloc;
11612 invok = build_method_invocation (name, args);
11613 return make_qualified_primary (wfl, invok, rloc);
11614}
11615
b67d701b 11616/* Build an incomplete CALL_EXPR node. */
e04a16fb
AG		 11617
11618static tree
11619build_method_invocation (name, args)
11620 tree name;
11621 tree args;
11622{
11623 tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
11624 TREE_SIDE_EFFECTS (call) = 1;
b67d701b
PB		 11625 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
11626 return call;
11627}
11628
11629/* Build an incomplete new xxx(...) node. */
11630
11631static tree
11632build_new_invocation (name, args)
11633 tree name, args;
11634{
11635 tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
11636 TREE_SIDE_EFFECTS (call) = 1;
e04a16fb
AG		 11637 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
11638 return call;
11639}
11640
11641/* Build an incomplete assignment expression. */
11642
11643static tree
11644build_assignment (op, op_location, lhs, rhs)
11645 int op, op_location;
11646 tree lhs, rhs;
11647{
11648 tree assignment;
11649 /* Build the corresponding binop if we deal with a Compound
11650 Assignment operator. Mark the binop sub-tree as part of a
11651 Compound Assignment expression */
11652 if (op != ASSIGN_TK)
11653 {
11654 rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
11655 COMPOUND_ASSIGN_P (rhs) = 1;
11656 }
11657 assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
11658 TREE_SIDE_EFFECTS (assignment) = 1;
11659 EXPR_WFL_LINECOL (assignment) = op_location;
11660 return assignment;
11661}
11662
11663/* Print an INTEGER_CST node in a static buffer, and return the buffer. */
11664
15fdcfe9 11665char *
e04a16fb
AG		 11666print_int_node (node)
11667 tree node;
11668{
11669 static char buffer [80];
11670 if (TREE_CONSTANT_OVERFLOW (node))
11671 sprintf (buffer, "<overflow>");
11672
11673 if (TREE_INT_CST_HIGH (node) == 0)
11674 sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
11675 TREE_INT_CST_LOW (node));
11676 else if (TREE_INT_CST_HIGH (node) == -1
11677 && TREE_INT_CST_LOW (node) != 0)
11678 {
11679 buffer [0] = '-';
11680 sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
11681 -TREE_INT_CST_LOW (node));
11682 }
11683 else
11684 sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
11685 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
11686
11687 return buffer;
11688}
11689
7f1d4866
APB		 11690/* Return 1 if an assignment to a FINAL is attempted in a non suitable
11691 context. */
5e942c50
APB		 11692
11693static int
11694check_final_assignment (lvalue, wfl)
11695 tree lvalue, wfl;
11696{
6632dcdd
APB		 11697 if (TREE_CODE (lvalue) == COMPOUND_EXPR
11698 && JDECL_P (TREE_OPERAND (lvalue, 1)))
11699 lvalue = TREE_OPERAND (lvalue, 1);
11700
bc2874c9
TT		 11701 /* When generating class files, references to the `length' field
11702 look a bit different. */
11703 if ((flag_emit_class_files
11704 && TREE_CODE (lvalue) == COMPONENT_REF
11705 && TYPE_ARRAY_P (TREE_TYPE (TREE_OPERAND (lvalue, 0)))
11706 && FIELD_FINAL (TREE_OPERAND (lvalue, 1)))
11707 || (TREE_CODE (lvalue) == FIELD_DECL
11708 && FIELD_FINAL (lvalue)
11709 && !DECL_CLINIT_P (current_function_decl)
11710 && !DECL_FINIT_P (current_function_decl)))
5e942c50
APB		 11711 {
11712 parse_error_context
11713 (wfl, "Can't assign a value to the final variable `%s'",
11714 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
11715 return 1;
11716 }
11717 return 0;
11718}
11719
11720/* Inline references to java.lang.PRIMTYPE.TYPE when accessed in
11721 read. This is needed to avoid circularities in the implementation
11722 of these fields in libjava. */
11723
11724static tree
11725maybe_build_primttype_type_ref (rhs, wfl)
11726 tree rhs, wfl;
11727{
11728 tree to_return = NULL_TREE;
11729 tree rhs_type = TREE_TYPE (rhs);
11730 if (TREE_CODE (rhs) == COMPOUND_EXPR)
11731 {
11732 tree n = TREE_OPERAND (rhs, 1);
11733 if (TREE_CODE (n) == VAR_DECL
11734 && DECL_NAME (n) == TYPE_identifier_node
9a7ab4b3
APB		 11735 && rhs_type == class_ptr_type
11736 && TREE_CODE (EXPR_WFL_NODE (wfl)) == IDENTIFIER_NODE)
5e942c50 11737 {
49f48c71 11738 const char *self_name = IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl));
5e942c50
APB		 11739 if (!strncmp (self_name, "java.lang.", 10))
11740 to_return = build_primtype_type_ref (self_name);
11741 }
11742 }
11743 return (to_return ? to_return : rhs );
11744}
11745
e04a16fb
AG		 11746/* 15.25 Assignment operators. */
11747
11748static tree
11749patch_assignment (node, wfl_op1, wfl_op2)
11750 tree node;
11751 tree wfl_op1;
11752 tree wfl_op2;
11753{
0a2138e2 11754 tree rhs = TREE_OPERAND (node, 1);
5e942c50 11755 tree lvalue = TREE_OPERAND (node, 0), llvalue;
cd531a2e 11756 tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
e04a16fb
AG		 11757 int error_found = 0;
11758 int lvalue_from_array = 0;
11759
c2952b01 11760 /* Can't assign to a (blank) final. */
5e942c50
APB		 11761 if (check_final_assignment (lvalue, wfl_op1))
11762 error_found = 1;
e04a16fb
AG		 11763
11764 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11765
11766 /* Lhs can be a named variable */
34f4db93 11767 if (JDECL_P (lvalue))
e04a16fb 11768 {
e04a16fb
AG		 11769 lhs_type = TREE_TYPE (lvalue);
11770 }
11771 /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME +
11772 comment on reason why */
11773 else if (TREE_CODE (wfl_op1) == ARRAY_REF)
11774 {
11775 lhs_type = TREE_TYPE (lvalue);
11776 lvalue_from_array = 1;
11777 }
11778 /* Or a field access */
11779 else if (TREE_CODE (lvalue) == COMPONENT_REF)
11780 lhs_type = TREE_TYPE (lvalue);
11781 /* Or a function return slot */
11782 else if (TREE_CODE (lvalue) == RESULT_DECL)
11783 lhs_type = TREE_TYPE (lvalue);
5e942c50
APB		 11784 /* Otherwise, we might want to try to write into an optimized static
11785 final, this is an of a different nature, reported further on. */
11786 else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
1504b2b4 11787 && resolve_expression_name (wfl_op1, &llvalue))
5e942c50 11788 {
6632dcdd 11789 if (!error_found && check_final_assignment (llvalue, wfl_op1))
1504b2b4
APB		 11790 {
11791 /* What we should do instead is resetting the all the flags
11792 previously set, exchange lvalue for llvalue and continue. */
11793 error_found = 1;
11794 return error_mark_node;
11795 }
11796 else
11797 lhs_type = TREE_TYPE (lvalue);
5e942c50
APB		 11798 }
11799 else
e04a16fb
AG		 11800 {
11801 parse_error_context (wfl_op1, "Invalid left hand side of assignment");
11802 error_found = 1;
11803 }
11804
11805 rhs_type = TREE_TYPE (rhs);
b67d701b 11806 /* 5.1 Try the assignment conversion for builtin type. */
0a2138e2 11807 new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
e04a16fb 11808
b67d701b 11809 /* 5.2 If it failed, try a reference conversion */
0a2138e2 11810 if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
b67d701b 11811 lhs_type = promote_type (rhs_type);
e04a16fb
AG		 11812
11813 /* 15.25.2 If we have a compound assignment, convert RHS into the
11814 type of the LHS */
11815 else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
11816 new_rhs = convert (lhs_type, rhs);
11817
11818 /* Explicit cast required. This is an error */
11819 if (!new_rhs)
11820 {
c2e3db92
KG		 11821 char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
11822 char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
e04a16fb
AG		 11823 tree wfl;
11824 char operation [32]; /* Max size known */
11825
11826 /* If the assignment is part of a declaration, we use the WFL of
11827 the declared variable to point out the error and call it a
11828 declaration problem. If the assignment is a genuine =
11829 operator, we call is a operator `=' problem, otherwise we
11830 call it an assignment problem. In both of these last cases,
11831 we use the WFL of the operator to indicate the error. */
11832
11833 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
11834 {
11835 wfl = wfl_op1;
11836 strcpy (operation, "declaration");
11837 }
11838 else
11839 {
11840 wfl = wfl_operator;
11841 if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
11842 strcpy (operation, "assignment");
11843 else if (TREE_CODE (TREE_OPERAND (node, 0)) == RESULT_DECL)
11844 strcpy (operation, "`return'");
11845 else
11846 strcpy (operation, "`='");
11847 }
11848
1ebadc60 11849 if (!valid_cast_to_p (rhs_type, lhs_type))
781b0558
KG		 11850 parse_error_context
11851 (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
11852 operation, t1, t2);
1ebadc60 11853 else
781b0558 11854 parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
1ebadc60 11855 operation, t1, t2);
e04a16fb
AG		 11856 free (t1); free (t2);
11857 error_found = 1;
11858 }
11859
c877974e
APB		 11860 /* Inline read access to java.lang.PRIMTYPE.TYPE */
11861 if (new_rhs)
11862 new_rhs = maybe_build_primttype_type_ref (new_rhs, wfl_op2);
5e942c50 11863
e04a16fb
AG		 11864 if (error_found)
11865 return error_mark_node;
11866
2622b947
APB		 11867 /* 10.10: Array Store Exception runtime check */
11868 if (!flag_emit_class_files
e8fc7396 11869 && !flag_emit_xref
2622b947 11870 && lvalue_from_array
afc390b1 11871 && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
2622b947
APB		 11872 {
11873 tree check;
11874 tree base = lvalue;
11875
11876 /* We need to retrieve the right argument for _Jv_CheckArrayStore */
11877 if (TREE_CODE (lvalue) == COMPOUND_EXPR)
11878 base = TREE_OPERAND (lvalue, 0);
11879 else
11880 {
11881 if (flag_bounds_check)
11882 base = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (base, 0), 1), 0);
11883 else
11884 base = TREE_OPERAND (TREE_OPERAND (base, 0), 0);
11885 }
11886
11887 /* Build the invocation of _Jv_CheckArrayStore */
dc4e6ccf 11888 new_rhs = save_expr (new_rhs);
2622b947
APB		 11889 check = build (CALL_EXPR, void_type_node,
11890 build_address_of (soft_checkarraystore_node),
11891 tree_cons (NULL_TREE, base,
11892 build_tree_list (NULL_TREE, new_rhs)),
11893 NULL_TREE);
11894 TREE_SIDE_EFFECTS (check) = 1;
11895
11896 /* We have to decide on an insertion point */
11897 if (TREE_CODE (lvalue) == COMPOUND_EXPR)
11898 {
11899 tree t;
11900 if (flag_bounds_check)
11901 {
11902 t = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0);
11903 TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0) =
11904 build (COMPOUND_EXPR, void_type_node, t, check);
11905 }
11906 else
11907 TREE_OPERAND (lvalue, 1) = build (COMPOUND_EXPR, lhs_type,
11908 check, TREE_OPERAND (lvalue, 1));
11909 }
11910 else
11911 {
11912 /* Make sure the bound check will happen before the store check */
11913 if (flag_bounds_check)
11914 TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0) =
11915 build (COMPOUND_EXPR, void_type_node,
11916 TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0), check);
11917 else
11918 lvalue = build (COMPOUND_EXPR, lhs_type, check, lvalue);
11919 }
11920 }
22eed1e6 11921
e04a16fb
AG		 11922 TREE_OPERAND (node, 0) = lvalue;
11923 TREE_OPERAND (node, 1) = new_rhs;
11924 TREE_TYPE (node) = lhs_type;
11925 return node;
11926}
11927
b67d701b
PB		 11928/* Check that type SOURCE can be cast into type DEST. If the cast
11929 can't occur at all, return 0 otherwise 1. This function is used to
11930 produce accurate error messages on the reasons why an assignment
11931 failed. */
e04a16fb 11932
b67d701b
PB		 11933static tree
11934try_reference_assignconv (lhs_type, rhs)
11935 tree lhs_type, rhs;
e04a16fb 11936{
b67d701b
PB		 11937 tree new_rhs = NULL_TREE;
11938 tree rhs_type = TREE_TYPE (rhs);
e04a16fb 11939
b67d701b
PB		 11940 if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
11941 {
11942 /* `null' may be assigned to any reference type */
11943 if (rhs == null_pointer_node)
11944 new_rhs = null_pointer_node;
11945 /* Try the reference assignment conversion */
11946 else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
11947 new_rhs = rhs;
11948 /* This is a magic assignment that we process differently */
11949 else if (rhs == soft_exceptioninfo_call_node)
11950 new_rhs = rhs;
11951 }
11952 return new_rhs;
11953}
11954
11955/* Check that RHS can be converted into LHS_TYPE by the assignment
11956 conversion (5.2), for the cases of RHS being a builtin type. Return
11957 NULL_TREE if the conversion fails or if because RHS isn't of a
11958 builtin type. Return a converted RHS if the conversion is possible. */
11959
11960static tree
11961try_builtin_assignconv (wfl_op1, lhs_type, rhs)
11962 tree wfl_op1, lhs_type, rhs;
11963{
11964 tree new_rhs = NULL_TREE;
11965 tree rhs_type = TREE_TYPE (rhs);
11966
5e942c50
APB		 11967 /* Zero accepted everywhere */
11968 if (TREE_CODE (rhs) == INTEGER_CST
11969 && TREE_INT_CST_HIGH (rhs) == 0 && TREE_INT_CST_LOW (rhs) == 0
11970 && JPRIMITIVE_TYPE_P (rhs_type))
11971 new_rhs = convert (lhs_type, rhs);
11972
b67d701b
PB		 11973 /* 5.1.1 Try Identity Conversion,
11974 5.1.2 Try Widening Primitive Conversion */
5e942c50 11975 else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
b67d701b
PB		 11976 new_rhs = convert (lhs_type, rhs);
11977
11978 /* Try a narrowing primitive conversion (5.1.3):
11979 - expression is a constant expression of type int AND
11980 - variable is byte, short or char AND
11981 - The value of the expression is representable in the type of the
11982 variable */
11983 else if (rhs_type == int_type_node && TREE_CONSTANT (rhs)
11984 && (lhs_type == byte_type_node || lhs_type == char_type_node
11985 || lhs_type == short_type_node))
11986 {
11987 if (int_fits_type_p (rhs, lhs_type))
11988 new_rhs = convert (lhs_type, rhs);
11989 else if (wfl_op1) /* Might be called with a NULL */
11990 parse_warning_context
781b0558 11991 (wfl_op1, "Constant expression `%s' to wide for narrowing primitive conversion to `%s'",
0a2138e2 11992 print_int_node (rhs), lang_printable_name (lhs_type, 0));
b67d701b
PB		 11993 /* Reported a warning that will turn into an error further
11994 down, so we don't return */
11995 }
11996
11997 return new_rhs;
11998}
11999
12000/* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12001 conversion (5.1.1) or widening primitve conversion (5.1.2). Return
12002 0 is the conversion test fails. This implements parts the method
12003 invocation convertion (5.3). */
12004
12005static int
12006valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)
12007 tree lhs_type, rhs_type;
12008{
acd663ee 12009 /* 5.1.1: This is the identity conversion part. */
5e942c50
APB		 12010 if (lhs_type == rhs_type)
12011 return 1;
12012
acd663ee
APB		 12013 /* Reject non primitive types */
12014 if (!JPRIMITIVE_TYPE_P (lhs_type) || !JPRIMITIVE_TYPE_P (rhs_type))
b67d701b
PB		 12015 return 0;
12016
acd663ee
APB		 12017 /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12018 than a char can't be converted into a char. Short can't too, but
12019 the < test below takes care of that */
b67d701b
PB		 12020 if (lhs_type == char_type_node && rhs_type == byte_type_node)
12021 return 0;
12022
5e942c50
APB		 12023 /* Accept all promoted type here. Note, we can't use <= in the test
12024 below, because we still need to bounce out assignments of short
12025 to char and the likes */
12026 if (lhs_type == int_type_node
12027 && (rhs_type == promoted_byte_type_node
12028 || rhs_type == promoted_short_type_node
12029 || rhs_type == promoted_char_type_node
12030 || rhs_type == promoted_boolean_type_node))
12031 return 1;
12032
acd663ee
APB		 12033 /* From here, an integral is widened if its precision is smaller
12034 than the precision of the LHS or if the LHS is a floating point
12035 type, or the RHS is a float and the RHS a double. */
12036 if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12037 && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12038 || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12039 || (rhs_type == float_type_node && lhs_type == double_type_node))
b67d701b
PB		 12040 return 1;
12041
12042 return 0;
e04a16fb
AG		 12043}
12044
12045/* Check that something of SOURCE type can be assigned or cast to
12046 something of DEST type at runtime. Return 1 if the operation is
12047 valid, 0 otherwise. If CAST is set to 1, we're treating the case
12048 were SOURCE is cast into DEST, which borrows a lot of the
12049 assignment check. */
12050
12051static int
12052valid_ref_assignconv_cast_p (source, dest, cast)
12053 tree source;
12054 tree dest;
12055 int cast;
12056{
09ed0f70
APB		 12057 /* SOURCE or DEST might be null if not from a declared entity. */
12058 if (!source || !dest)
12059 return 0;
5e942c50
APB		 12060 if (JNULLP_TYPE_P (source))
12061 return 1;
e04a16fb
AG		 12062 if (TREE_CODE (source) == POINTER_TYPE)
12063 source = TREE_TYPE (source);
12064 if (TREE_CODE (dest) == POINTER_TYPE)
12065 dest = TREE_TYPE (dest);
12066 /* Case where SOURCE is a class type */
12067 if (TYPE_CLASS_P (source))
12068 {
12069 if (TYPE_CLASS_P (dest))
c2952b01
APB		 12070 return (source == dest
12071 || inherits_from_p (source, dest)
d6baf6f5 12072 || enclosing_context_p (source, dest)
c2952b01 12073 || (cast && inherits_from_p (dest, source)));
e04a16fb
AG		 12074 if (TYPE_INTERFACE_P (dest))
12075 {
12076 /* If doing a cast and SOURCE is final, the operation is
12077 always correct a compile time (because even if SOURCE
12078 does not implement DEST, a subclass of SOURCE might). */
12079 if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12080 return 1;
12081 /* Otherwise, SOURCE must implement DEST */
12082 return interface_of_p (dest, source);
12083 }
12084 /* DEST is an array, cast permited if SOURCE is of Object type */
12085 return (cast && source == object_type_node ? 1 : 0);
12086 }
12087 if (TYPE_INTERFACE_P (source))
12088 {
12089 if (TYPE_CLASS_P (dest))
12090 {
12091 /* If not casting, DEST must be the Object type */
12092 if (!cast)
12093 return dest == object_type_node;
12094 /* We're doing a cast. The cast is always valid is class
12095 DEST is not final, otherwise, DEST must implement SOURCE */
b67d701b 12096 else if (!CLASS_FINAL (TYPE_NAME (dest)))
e04a16fb
AG		 12097 return 1;
12098 else
12099 return interface_of_p (source, dest);
12100 }
12101 if (TYPE_INTERFACE_P (dest))
12102 {
12103 /* If doing a cast, then if SOURCE and DEST contain method
12104 with the same signature but different return type, then
12105 this is a (compile time) error */
12106 if (cast)
12107 {
12108 tree method_source, method_dest;
12109 tree source_type;
0a2138e2 12110 tree source_sig;
e04a16fb
AG		 12111 tree source_name;
12112 for (method_source = TYPE_METHODS (source); method_source;
12113 method_source = TREE_CHAIN (method_source))
12114 {
12115 source_sig =
12116 build_java_argument_signature (TREE_TYPE (method_source));
12117 source_type = TREE_TYPE (TREE_TYPE (method_source));
12118 source_name = DECL_NAME (method_source);
12119 for (method_dest = TYPE_METHODS (dest);
12120 method_dest; method_dest = TREE_CHAIN (method_dest))
12121 if (source_sig ==
12122 build_java_argument_signature (TREE_TYPE (method_dest))
12123 && source_name == DECL_NAME (method_dest)
12124 && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
12125 return 0;
12126 }
12127 return 1;
12128 }
12129 else
12130 return source == dest || interface_of_p (dest, source);
12131 }
12132 else /* Array */
93024893
APB		 12133 return (cast ?
12134 (DECL_NAME (TYPE_NAME (source)) == java_lang_cloneable) : 0);
e04a16fb
AG		 12135 }
12136 if (TYPE_ARRAY_P (source))
12137 {
12138 if (TYPE_CLASS_P (dest))
12139 return dest == object_type_node;
09ed0f70
APB		 12140 /* Can't cast an array to an interface unless the interface is
12141 java.lang.Cloneable */
e04a16fb 12142 if (TYPE_INTERFACE_P (dest))
09ed0f70 12143 return (DECL_NAME (TYPE_NAME (dest)) == java_lang_cloneable ? 1 : 0);
e04a16fb
AG		 12144 else /* Arrays */
12145 {
12146 tree source_element_type = TYPE_ARRAY_ELEMENT (source);
12147 tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
12148
b9f7e36c
APB		 12149 /* In case of severe errors, they turn out null */
12150 if (!dest_element_type || !source_element_type)
12151 return 0;
e04a16fb
AG		 12152 if (source_element_type == dest_element_type)
12153 return 1;
12154 return valid_ref_assignconv_cast_p (source_element_type,
12155 dest_element_type, cast);
12156 }
12157 return 0;
12158 }
12159 return 0;
12160}
12161
b67d701b
PB		 12162static int
12163valid_cast_to_p (source, dest)
12164 tree source;
12165 tree dest;
12166{
12167 if (TREE_CODE (source) == POINTER_TYPE)
12168 source = TREE_TYPE (source);
12169 if (TREE_CODE (dest) == POINTER_TYPE)
12170 dest = TREE_TYPE (dest);
12171
12172 if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
12173 return valid_ref_assignconv_cast_p (source, dest, 1);
12174
12175 else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
12176 return 1;
12177
12178 return 0;
12179}
12180
12181/* Method invocation conversion test. Return 1 if type SOURCE can be
12182 converted to type DEST through the methond invocation conversion
12183 process (5.3) */
12184
15fdcfe9
PB		 12185static tree
12186do_unary_numeric_promotion (arg)
12187 tree arg;
12188{
12189 tree type = TREE_TYPE (arg);
12190 if (TREE_CODE (type) == INTEGER_TYPE ? TYPE_PRECISION (type) < 32
12191 : TREE_CODE (type) == CHAR_TYPE)
12192 arg = convert (int_type_node, arg);
12193 return arg;
12194}
12195
acd663ee
APB		 12196/* Return a non zero value if SOURCE can be converted into DEST using
12197 the method invocation conversion rule (5.3). */
b67d701b
PB		 12198static int
12199valid_method_invocation_conversion_p (dest, source)
12200 tree dest, source;
12201{
e3884b71 12202 return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
acd663ee
APB		 12203 && valid_builtin_assignconv_identity_widening_p (dest, source))
12204 || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
12205 && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
12206 && valid_ref_assignconv_cast_p (source, dest, 0)));
b67d701b
PB		 12207}
12208
e04a16fb
AG		 12209/* Build an incomplete binop expression. */
12210
12211static tree
12212build_binop (op, op_location, op1, op2)
12213 enum tree_code op;
12214 int op_location;
12215 tree op1, op2;
12216{
5e942c50 12217 tree binop = build (op, NULL_TREE, op1, op2);
e04a16fb
AG		 12218 TREE_SIDE_EFFECTS (binop) = 1;
12219 /* Store the location of the operator, for better error report. The
12220 string of the operator will be rebuild based on the OP value. */
12221 EXPR_WFL_LINECOL (binop) = op_location;
12222 return binop;
12223}
12224
12225/* Build the string of the operator retained by NODE. If NODE is part
12226 of a compound expression, add an '=' at the end of the string. This
12227 function is called when an error needs to be reported on an
12228 operator. The string is returned as a pointer to a static character
12229 buffer. */
12230
12231static char *
12232operator_string (node)
12233 tree node;
12234{
12235#define BUILD_OPERATOR_STRING(S) \
12236 { \
12237 sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
12238 return buffer; \
12239 }
12240
12241 static char buffer [10];
12242 switch (TREE_CODE (node))
12243 {
12244 case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
12245 case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
12246 case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
12247 case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
12248 case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
12249 case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
12250 case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
12251 case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
12252 case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
12253 case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
12254 case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
12255 case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
12256 case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
12257 case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
12258 case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
12259 case GT_EXPR: BUILD_OPERATOR_STRING (">");
12260 case GE_EXPR: BUILD_OPERATOR_STRING (">=");
12261 case LT_EXPR: BUILD_OPERATOR_STRING ("<");
12262 case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
b67d701b 12263 case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
e04a16fb
AG		 12264 case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
12265 case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
12266 case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
12267 case PREINCREMENT_EXPR: /* Fall through */
12268 case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
12269 case PREDECREMENT_EXPR: /* Fall through */
12270 case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
12271 default:
12272 fatal ("unregistered operator %s - operator_string",
12273 tree_code_name [TREE_CODE (node)]);
12274 }
12275 return NULL;
12276#undef BUILD_OPERATOR_STRING
12277}
12278
5cbdba64
APB		 12279/* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
12280
12281static int
12282java_decl_equiv (var_acc1, var_acc2)
12283 tree var_acc1, var_acc2;
12284{
12285 if (JDECL_P (var_acc1))
12286 return (var_acc1 == var_acc2);
12287
12288 return (TREE_CODE (var_acc1) == COMPONENT_REF
12289 && TREE_CODE (var_acc2) == COMPONENT_REF
12290 && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
12291 == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
12292 && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
12293}
12294
12295/* Return a non zero value if CODE is one of the operators that can be
12296 used in conjunction with the `=' operator in a compound assignment. */
12297
12298static int
12299binop_compound_p (code)
12300 enum tree_code code;
12301{
12302 int i;
12303 for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
12304 if (binop_lookup [i] == code)
12305 break;
12306
12307 return i < BINOP_COMPOUND_CANDIDATES;
12308}
12309
12310/* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
12311
12312static tree
12313java_refold (t)
12314 tree t;
12315{
12316 tree c, b, ns, decl;
12317
12318 if (TREE_CODE (t) != MODIFY_EXPR)
12319 return t;
12320
12321 c = TREE_OPERAND (t, 1);
12322 if (! (c && TREE_CODE (c) == COMPOUND_EXPR
12323 && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
12324 && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
12325 return t;
12326
12327 /* Now the left branch of the binary operator. */
12328 b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
12329 if (! (b && TREE_CODE (b) == NOP_EXPR
12330 && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
12331 return t;
12332
12333 ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
12334 if (! (ns && TREE_CODE (ns) == NOP_EXPR
12335 && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
12336 return t;
12337
12338 decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
12339 if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
12340 /* It's got to be the an equivalent decl */
12341 && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
12342 {
12343 /* Shorten the NOP_EXPR/SAVE_EXPR path. */
12344 TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
12345 /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
12346 TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
12347 /* Change the right part of the BINOP_EXPR */
12348 TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
12349 }
12350
12351 return t;
12352}
12353
e04a16fb
AG		 12354/* Binary operators (15.16 up to 15.18). We return error_mark_node on
12355 errors but we modify NODE so that it contains the type computed
12356 according to the expression, when it's fixed. Otherwise, we write
12357 error_mark_node as the type. It allows us to further the analysis
12358 of remaining nodes and detects more errors in certain cases. */
12359
12360static tree
12361patch_binop (node, wfl_op1, wfl_op2)
12362 tree node;
12363 tree wfl_op1;
12364 tree wfl_op2;
12365{
12366 tree op1 = TREE_OPERAND (node, 0);
12367 tree op2 = TREE_OPERAND (node, 1);
12368 tree op1_type = TREE_TYPE (op1);
12369 tree op2_type = TREE_TYPE (op2);
48a840d9 12370 tree prom_type = NULL_TREE, cn;
e04a16fb 12371 int code = TREE_CODE (node);
b67d701b 12372
e04a16fb
AG		 12373 /* If 1, tell the routine that we have to return error_mark_node
12374 after checking for the initialization of the RHS */
12375 int error_found = 0;
12376
e04a16fb
AG		 12377 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12378
e04a16fb
AG		 12379 switch (code)
12380 {
12381 /* 15.16 Multiplicative operators */
12382 case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
12383 case RDIV_EXPR: /* 15.16.2 Division Operator / */
c2952b01 12384 case TRUNC_DIV_EXPR: /* 15.16.2 Integral type Division Operator / */
e04a16fb
AG		 12385 case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
12386 if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
12387 {
12388 if (!JPRIMITIVE_TYPE_P (op1_type))
12389 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12390 if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
12391 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12392 TREE_TYPE (node) = error_mark_node;
12393 error_found = 1;
12394 break;
12395 }
12396 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12397 /* Change the division operator if necessary */
12398 if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
12399 TREE_SET_CODE (node, TRUNC_DIV_EXPR);
0b4d333e 12400
aa4759c1
AH		 12401 if (TREE_CODE (prom_type) == INTEGER_TYPE
12402 && flag_use_divide_subroutine
12403 && ! flag_emit_class_files
12404 && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
12405 return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
12406
0b4d333e
APB		 12407 /* This one is more complicated. FLOATs are processed by a
12408 function call to soft_fmod. Duplicate the value of the
12409 COMPOUND_ASSIGN_P flag. */
e04a16fb 12410 if (code == TRUNC_MOD_EXPR)
0b4d333e
APB		 12411 {
12412 tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
12413 COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
dc0b3eff
PB		 12414 TREE_SIDE_EFFECTS (mod)
12415 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
0b4d333e
APB		 12416 return mod;
12417 }
e04a16fb
AG		 12418 break;
12419
12420 /* 15.17 Additive Operators */
12421 case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
b67d701b
PB		 12422
12423 /* Operation is valid if either one argument is a string
12424 constant, a String object or a StringBuffer crafted for the
12425 purpose of the a previous usage of the String concatenation
12426 operator */
12427
12428 if (TREE_CODE (op1) == STRING_CST
12429 || TREE_CODE (op2) == STRING_CST
12430 || JSTRING_TYPE_P (op1_type)
12431 || JSTRING_TYPE_P (op2_type)
12432 || IS_CRAFTED_STRING_BUFFER_P (op1)
12433 || IS_CRAFTED_STRING_BUFFER_P (op2))
12434 return build_string_concatenation (op1, op2);
12435
e04a16fb
AG		 12436 case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
12437 Numeric Types */
12438 if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
12439 {
12440 if (!JPRIMITIVE_TYPE_P (op1_type))
12441 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12442 if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
12443 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12444 TREE_TYPE (node) = error_mark_node;
12445 error_found = 1;
12446 break;
12447 }
12448 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12449 break;
12450
12451 /* 15.18 Shift Operators */
12452 case LSHIFT_EXPR:
12453 case RSHIFT_EXPR:
12454 case URSHIFT_EXPR:
12455 if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
12456 {
12457 if (!JINTEGRAL_TYPE_P (op1_type))
12458 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
12459 else
1ebadc60
KG		 12460 {
12461 if (JPRIMITIVE_TYPE_P (op2_type))
12462 parse_error_context (wfl_operator,
781b0558 12463 "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
1ebadc60
KG		 12464 operator_string (node),
12465 lang_printable_name (op2_type, 0));
12466 else
781b0558
KG		 12467 parse_error_context (wfl_operator,
12468 "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
1ebadc60
KG		 12469 operator_string (node),
12470 lang_printable_name (op2_type, 0));
12471 }
e04a16fb
AG		 12472 TREE_TYPE (node) = error_mark_node;
12473 error_found = 1;
12474 break;
12475 }
12476
12477 /* Unary numeric promotion (5.6.1) is performed on each operand
12478 separatly */
15fdcfe9
PB		 12479 op1 = do_unary_numeric_promotion (op1);
12480 op2 = do_unary_numeric_promotion (op2);
e04a16fb
AG		 12481
12482 /* The type of the shift expression is the type of the promoted
12483 type of the left-hand operand */
12484 prom_type = TREE_TYPE (op1);
12485
c2952b01
APB		 12486 /* Shift int only up to 0x1f and long up to 0x3f */
12487 if (prom_type == int_type_node)
12488 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
12489 build_int_2 (0x1f, 0)));
12490 else
12491 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
12492 build_int_2 (0x3f, 0)));
e04a16fb
AG		 12493
12494 /* The >>> operator is a >> operating on unsigned quantities */
15fdcfe9 12495 if (code == URSHIFT_EXPR && ! flag_emit_class_files)
e04a16fb 12496 {
0b4d333e 12497 tree to_return;
73333a87
AH		 12498 tree utype = unsigned_type (prom_type);
12499 op1 = convert (utype, op1);
e04a16fb 12500 TREE_SET_CODE (node, RSHIFT_EXPR);
73333a87
AH		 12501 TREE_OPERAND (node, 0) = op1;
12502 TREE_OPERAND (node, 1) = op2;
12503 TREE_TYPE (node) = utype;
0b4d333e
APB		 12504 to_return = convert (prom_type, node);
12505 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
12506 COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
dc0b3eff
PB		 12507 TREE_SIDE_EFFECTS (to_return)
12508 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
0b4d333e 12509 return to_return;
e04a16fb
AG		 12510 }
12511 break;
5e942c50
APB		 12512
12513 /* 15.19.1 Type Comparison Operator instaceof */
12514 case INSTANCEOF_EXPR:
12515
12516 TREE_TYPE (node) = boolean_type_node;
12517
12518 if (!(op2_type = resolve_type_during_patch (op2)))
12519 return error_mark_node;
12520
12521 /* The first operand must be a reference type or the null type */
12522 if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
12523 error_found = 1; /* Error reported further below */
12524
12525 /* The second operand must be a reference type */
12526 if (!JREFERENCE_TYPE_P (op2_type))
12527 {
12528 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
12529 parse_error_context
12530 (wfl_operator, "Invalid argument `%s' for `instanceof'",
12531 lang_printable_name (op2_type, 0));
12532 error_found = 1;
12533 }
12534
12535 if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
12536 {
12537 /* If the first operand is null, the result is always false */
12538 if (op1 == null_pointer_node)
12539 return boolean_false_node;
15fdcfe9
PB		 12540 else if (flag_emit_class_files)
12541 {
12542 TREE_OPERAND (node, 1) = op2_type;
dc0b3eff 12543 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
15fdcfe9
PB		 12544 return node;
12545 }
5e942c50
APB		 12546 /* Otherwise we have to invoke instance of to figure it out */
12547 else
67db0ce7 12548 return build_instanceof (op1, op2_type);
5e942c50
APB		 12549 }
12550 /* There is no way the expression operand can be an instance of
12551 the type operand. This is a compile time error. */
12552 else
12553 {
c2e3db92 12554 char *t1 = xstrdup (lang_printable_name (op1_type, 0));
5e942c50
APB		 12555 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
12556 parse_error_context
12557 (wfl_operator, "Impossible for `%s' to be instance of `%s'",
12558 t1, lang_printable_name (op2_type, 0));
12559 free (t1);
12560 error_found = 1;
12561 }
e04a16fb 12562
5e942c50 12563 break;
e04a16fb
AG		 12564
12565 /* 15.21 Bitwise and Logical Operators */
12566 case BIT_AND_EXPR:
12567 case BIT_XOR_EXPR:
12568 case BIT_IOR_EXPR:
12569 if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
12570 /* Binary numeric promotion is performed on both operand and the
12571 expression retain that type */
12572 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12573
12574 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
12575 && TREE_CODE (op1_type) == BOOLEAN_TYPE)
12576 /* The type of the bitwise operator expression is BOOLEAN */
12577 prom_type = boolean_type_node;
12578 else
12579 {
12580 if (!JINTEGRAL_TYPE_P (op1_type))
12581 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
12582 if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
12583 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
12584 TREE_TYPE (node) = error_mark_node;
12585 error_found = 1;
12586 /* Insert a break here if adding thing before the switch's
12587 break for this case */
12588 }
12589 break;
12590
12591 /* 15.22 Conditional-And Operator */
12592 case TRUTH_ANDIF_EXPR:
12593 /* 15.23 Conditional-Or Operator */
12594 case TRUTH_ORIF_EXPR:
12595 /* Operands must be of BOOLEAN type */
12596 if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
12597 TREE_CODE (op2_type) != BOOLEAN_TYPE)
12598 {
12599 if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
12600 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
12601 if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
12602 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
12603 TREE_TYPE (node) = boolean_type_node;
12604 error_found = 1;
12605 break;
12606 }
12607 /* The type of the conditional operators is BOOLEAN */
12608 prom_type = boolean_type_node;
12609 break;
12610
12611 /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
12612 case LT_EXPR:
12613 case GT_EXPR:
12614 case LE_EXPR:
12615 case GE_EXPR:
12616 /* The type of each of the operands must be a primitive numeric
12617 type */
12618 if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
12619 {
12620 if (!JNUMERIC_TYPE_P (op1_type))
12621 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12622 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
12623 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12624 TREE_TYPE (node) = boolean_type_node;
12625 error_found = 1;
12626 break;
12627 }
12628 /* Binary numeric promotion is performed on the operands */
12629 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12630 /* The type of the relation expression is always BOOLEAN */
12631 prom_type = boolean_type_node;
12632 break;
12633
12634 /* 15.20 Equality Operator */
12635 case EQ_EXPR:
12636 case NE_EXPR:
48a840d9
APB		 12637 /* It's time for us to patch the strings. */
12638 if ((cn = patch_string (op1)))
12639 {
12640 op1 = cn;
12641 op1_type = TREE_TYPE (op1);
12642 }
12643 if ((cn = patch_string (op2)))
12644 {
12645 op2 = cn;
12646 op2_type = TREE_TYPE (op2);
12647 }
12648
e04a16fb
AG		 12649 /* 15.20.1 Numerical Equality Operators == and != */
12650 /* Binary numeric promotion is performed on the operands */
5e942c50 12651 if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
e04a16fb
AG		 12652 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12653
12654 /* 15.20.2 Boolean Equality Operators == and != */
12655 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
12656 TREE_CODE (op2_type) == BOOLEAN_TYPE)
12657 ; /* Nothing to do here */
12658
12659 /* 15.20.3 Reference Equality Operators == and != */
5e942c50
APB		 12660 /* Types have to be either references or the null type. If
12661 they're references, it must be possible to convert either
12662 type to the other by casting conversion. */
b9f7e36c
APB		 12663 else if (op1 == null_pointer_node || op2 == null_pointer_node
12664 || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
5e942c50
APB		 12665 && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
12666 || valid_ref_assignconv_cast_p (op2_type,
12667 op1_type, 1))))
e04a16fb
AG		 12668 ; /* Nothing to do here */
12669
12670 /* Else we have an error figure what can't be converted into
12671 what and report the error */
12672 else
12673 {
12674 char *t1;
c2e3db92 12675 t1 = xstrdup (lang_printable_name (op1_type, 0));
e04a16fb 12676 parse_error_context
781b0558
KG		 12677 (wfl_operator,
12678 "Incompatible type for `%s'. Can't convert `%s' to `%s'",
12679 operator_string (node), t1,
0a2138e2 12680 lang_printable_name (op2_type, 0));
e04a16fb
AG		 12681 free (t1);
12682 TREE_TYPE (node) = boolean_type_node;
12683 error_found = 1;
12684 break;
12685 }
12686 prom_type = boolean_type_node;
12687 break;
12688 }
12689
e04a16fb
AG		 12690 if (error_found)
12691 return error_mark_node;
12692
12693 TREE_OPERAND (node, 0) = op1;
12694 TREE_OPERAND (node, 1) = op2;
12695 TREE_TYPE (node) = prom_type;
dc0b3eff
PB		 12696 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
12697
ce6e9147
APB		 12698 if (flag_emit_xref)
12699 return node;
12700
d1472141
PB		 12701 /* fold does not respect side-effect order as required for Java but not C.
12702 * Also, it sometimes create SAVE_EXPRs which are bad when emitting
12703 * bytecode.
12704 */
12705 if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
12706 : ! TREE_SIDE_EFFECTS (node))
aee48ef8
PB		 12707 node = fold (node);
12708 return node;
e04a16fb
AG		 12709}
12710
b67d701b
PB		 12711/* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
12712 zero value, the value of CSTE comes after the valude of STRING */
12713
12714static tree
12715do_merge_string_cste (cste, string, string_len, after)
12716 tree cste;
49f48c71 12717 const char *string;
b67d701b
PB		 12718 int string_len, after;
12719{
12720 int len = TREE_STRING_LENGTH (cste) + string_len;
49f48c71 12721 const char *old = TREE_STRING_POINTER (cste);
b67d701b
PB		 12722 TREE_STRING_LENGTH (cste) = len;
12723 TREE_STRING_POINTER (cste) = obstack_alloc (expression_obstack, len+1);
12724 if (after)
12725 {
12726 strcpy (TREE_STRING_POINTER (cste), string);
12727 strcat (TREE_STRING_POINTER (cste), old);
12728 }
12729 else
12730 {
12731 strcpy (TREE_STRING_POINTER (cste), old);
12732 strcat (TREE_STRING_POINTER (cste), string);
12733 }
12734 return cste;
12735}
12736
12737/* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
12738 new STRING_CST on success, NULL_TREE on failure */
12739
12740static tree
12741merge_string_cste (op1, op2, after)
12742 tree op1, op2;
12743 int after;
12744{
12745 /* Handle two string constants right away */
12746 if (TREE_CODE (op2) == STRING_CST)
12747 return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
12748 TREE_STRING_LENGTH (op2), after);
12749
12750 /* Reasonable integer constant can be treated right away */
12751 if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
12752 {
49f48c71
KG		 12753 static const char *boolean_true = "true";
12754 static const char *boolean_false = "false";
12755 static const char *null_pointer = "null";
b67d701b 12756 char ch[3];
49f48c71 12757 const char *string;
b67d701b
PB		 12758
12759 if (op2 == boolean_true_node)
12760 string = boolean_true;
12761 else if (op2 == boolean_false_node)
12762 string = boolean_false;
12763 else if (op2 == null_pointer_node)
12764 string = null_pointer;
12765 else if (TREE_TYPE (op2) == char_type_node)
12766 {
12767 ch[0] = (char )TREE_INT_CST_LOW (op2);
12768 ch[1] = '\0';
12769 string = ch;
12770 }
12771 else
12772 string = print_int_node (op2);
12773
12774 return do_merge_string_cste (op1, string, strlen (string), after);
12775 }
12776 return NULL_TREE;
12777}
12778
12779/* Tries to statically concatenate OP1 and OP2 if possible. Either one
12780 has to be a STRING_CST and the other part must be a STRING_CST or a
12781 INTEGRAL constant. Return a new STRING_CST if the operation
12782 succeed, NULL_TREE otherwise.
12783
12784 If the case we want to optimize for space, we might want to return
12785 NULL_TREE for each invocation of this routine. FIXME */
12786
12787static tree
12788string_constant_concatenation (op1, op2)
12789 tree op1, op2;
12790{
12791 if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
12792 {
0a2138e2 12793 tree string, rest;
b67d701b
PB		 12794 int invert;
12795
12796 string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
12797 rest = (string == op1 ? op2 : op1);
12798 invert = (string == op1 ? 0 : 1 );
12799
12800 /* Walk REST, only if it looks reasonable */
12801 if (TREE_CODE (rest) != STRING_CST
12802 && !IS_CRAFTED_STRING_BUFFER_P (rest)
12803 && !JSTRING_TYPE_P (TREE_TYPE (rest))
12804 && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
12805 {
12806 rest = java_complete_tree (rest);
12807 if (rest == error_mark_node)
12808 return error_mark_node;
12809 rest = fold (rest);
12810 }
12811 return merge_string_cste (string, rest, invert);
12812 }
12813 return NULL_TREE;
12814}
12815
12816/* Implement the `+' operator. Does static optimization if possible,
12817 otherwise create (if necessary) and append elements to a
12818 StringBuffer. The StringBuffer will be carried around until it is
12819 used for a function call or an assignment. Then toString() will be
12820 called on it to turn it into a String object. */
12821
12822static tree
12823build_string_concatenation (op1, op2)
12824 tree op1, op2;
12825{
12826 tree result;
dc0b3eff 12827 int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
ce6e9147
APB		 12828
12829 if (flag_emit_xref)
12830 return build (PLUS_EXPR, string_type_node, op1, op2);
b67d701b
PB		 12831
12832 /* Try to do some static optimization */
12833 if ((result = string_constant_concatenation (op1, op2)))
12834 return result;
12835
c0d87ff6
PB		 12836 /* Discard empty strings on either side of the expression */
12837 if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
acd663ee
APB		 12838 {
12839 op1 = op2;
12840 op2 = NULL_TREE;
12841 }
c0d87ff6 12842 else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
acd663ee 12843 op2 = NULL_TREE;
b67d701b 12844
acd663ee 12845 /* If operands are string constant, turn then into object references */
b67d701b
PB		 12846 if (TREE_CODE (op1) == STRING_CST)
12847 op1 = patch_string_cst (op1);
acd663ee 12848 if (op2 && TREE_CODE (op2) == STRING_CST)
b67d701b
PB		 12849 op2 = patch_string_cst (op2);
12850
acd663ee
APB		 12851 /* If either one of the constant is null and the other non null
12852 operand is a String object, return it. */
12853 if (JSTRING_TYPE_P (TREE_TYPE (op1)) && !op2)
12854 return op1;
12855
b67d701b
PB		 12856 /* If OP1 isn't already a StringBuffer, create and
12857 initialize a new one */
12858 if (!IS_CRAFTED_STRING_BUFFER_P (op1))
12859 {
12860 /* Two solutions here:
c52b5771
AG		 12861 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
12862 2) OP1 is something else, we call new StringBuffer().append(OP1). */
12863 if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
b67d701b
PB		 12864 op1 = BUILD_STRING_BUFFER (op1);
12865 else
12866 {
12867 tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
12868 op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
12869 }
12870 }
12871
acd663ee
APB		 12872 if (op2)
12873 {
12874 /* OP1 is no longer the last node holding a crafted StringBuffer */
12875 IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
12876 /* Create a node for `{new...,xxx}.append (op2)' */
12877 if (op2)
12878 op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
12879 }
12880
b67d701b
PB		 12881 /* Mark the last node holding a crafted StringBuffer */
12882 IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
dc0b3eff
PB		 12883
12884 TREE_SIDE_EFFECTS (op1) = side_effects;
b67d701b
PB		 12885 return op1;
12886}
12887
12888/* Patch the string node NODE. NODE can be a STRING_CST of a crafted
12889 StringBuffer. If no string were found to be patched, return
12890 NULL. */
12891
12892static tree
12893patch_string (node)
12894 tree node;
12895{
1179ebc2
APB		 12896 if (node == error_mark_node)
12897 return error_mark_node;
b67d701b
PB		 12898 if (TREE_CODE (node) == STRING_CST)
12899 return patch_string_cst (node);
12900 else if (IS_CRAFTED_STRING_BUFFER_P (node))
12901 {
c877974e 12902 int saved = ctxp->explicit_constructor_p;
b67d701b 12903 tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
c877974e
APB		 12904 tree ret;
12905 /* Temporary disable forbid the use of `this'. */
12906 ctxp->explicit_constructor_p = 0;
12907 ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
1729c265
APB		 12908 /* String concatenation arguments must be evaluated in order too. */
12909 ret = force_evaluation_order (ret);
c877974e
APB		 12910 /* Restore it at its previous value */
12911 ctxp->explicit_constructor_p = saved;
12912 return ret;
b67d701b
PB		 12913 }
12914 return NULL_TREE;
12915}
12916
12917/* Build the internal representation of a string constant. */
12918
12919static tree
12920patch_string_cst (node)
12921 tree node;
12922{
12923 int location;
15fdcfe9
PB		 12924 if (! flag_emit_class_files)
12925 {
12926 push_obstacks (&permanent_obstack, &permanent_obstack);
12927 node = get_identifier (TREE_STRING_POINTER (node));
12928 location = alloc_name_constant (CONSTANT_String, node);
12929 node = build_ref_from_constant_pool (location);
8226320b 12930 pop_obstacks ();
15fdcfe9 12931 }
cd9643f7 12932 TREE_TYPE (node) = string_ptr_type_node;
b67d701b
PB		 12933 TREE_CONSTANT (node) = 1;
12934 return node;
12935}
12936
12937/* Build an incomplete unary operator expression. */
e04a16fb
AG		 12938
12939static tree
12940build_unaryop (op_token, op_location, op1)
12941 int op_token, op_location;
12942 tree op1;
12943{
12944 enum tree_code op;
12945 tree unaryop;
12946 switch (op_token)
12947 {
b67d701b 12948 case PLUS_TK: op = UNARY_PLUS_EXPR; break;
e04a16fb
AG		 12949 case MINUS_TK: op = NEGATE_EXPR; break;
12950 case NEG_TK: op = TRUTH_NOT_EXPR; break;
12951 case NOT_TK: op = BIT_NOT_EXPR; break;
12952 default: fatal ("Unknown token `%d' for unary operator - build_unaryop",
12953 op_token);
12954 }
12955
12956 unaryop = build1 (op, NULL_TREE, op1);
e04a16fb
AG		 12957 TREE_SIDE_EFFECTS (unaryop) = 1;
12958 /* Store the location of the operator, for better error report. The
12959 string of the operator will be rebuild based on the OP value. */
12960 EXPR_WFL_LINECOL (unaryop) = op_location;
12961 return unaryop;
12962}
12963
12964/* Special case for the ++/-- operators, since they require an extra
12965 argument to build, which is set to NULL and patched
12966 later. IS_POST_P is 1 if the operator, 0 otherwise. */
12967
12968static tree
12969build_incdec (op_token, op_location, op1, is_post_p)
12970 int op_token, op_location;
12971 tree op1;
12972 int is_post_p;
12973{
12974 static enum tree_code lookup [2][2] =
12975 {
12976 { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
12977 { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
12978 };
12979 tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
12980 NULL_TREE, op1, NULL_TREE);
12981 TREE_SIDE_EFFECTS (node) = 1;
12982 /* Store the location of the operator, for better error report. The
12983 string of the operator will be rebuild based on the OP value. */
12984 EXPR_WFL_LINECOL (node) = op_location;
12985 return node;
12986}
12987
12988/* Build an incomplete cast operator, based on the use of the
12989 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
12990 set. java_complete_tree is trained to walk a CONVERT_EXPR even
12991 though its type is already set. */
12992
12993static tree
12994build_cast (location, type, exp)
12995 int location;
12996 tree type, exp;
12997{
12998 tree node = build1 (CONVERT_EXPR, type, exp);
12999 EXPR_WFL_LINECOL (node) = location;
13000 return node;
13001}
13002
c2952b01
APB		 13003/* Build an incomplete class reference operator. */
13004static tree
13005build_incomplete_class_ref (location, class_name)
13006 int location;
13007 tree class_name;
13008{
13009 tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13010 EXPR_WFL_LINECOL (node) = location;
13011 return node;
13012}
13013
13014/* Complete an incomplete class reference operator. */
13015static tree
13016patch_incomplete_class_ref (node)
13017 tree node;
13018{
13019 tree type = TREE_OPERAND (node, 0);
13020 tree ref_type;
13021
13022 if (!(ref_type = resolve_type_during_patch (type)))
13023 return error_mark_node;
13024
165f37bc 13025 if (!flag_emit_class_files || JPRIMITIVE_TYPE_P (ref_type))
f1ff439a
TT		 13026 {
13027 /* A class referenced by `foo.class' is initialized. */
13028 return build_class_init (ref_type, build_class_ref (ref_type));
13029 }
165f37bc
APB		 13030
13031 /* If we're emitting class files and we have to deal with non
13032 primitive types, we invoke (and consider generating) the
13033 synthetic static method `class$'. */
13034 if (!TYPE_DOT_CLASS (current_class))
13035 build_dot_class_method (current_class);
13036 ref_type =
13037 build_dot_class_method_invocation (DECL_NAME (TYPE_NAME (ref_type)));
13038 return java_complete_tree (ref_type);
c2952b01
APB		 13039}
13040
e04a16fb
AG		 13041/* 15.14 Unary operators. We return error_mark_node in case of error,
13042 but preserve the type of NODE if the type is fixed. */
13043
13044static tree
13045patch_unaryop (node, wfl_op)
13046 tree node;
13047 tree wfl_op;
13048{
13049 tree op = TREE_OPERAND (node, 0);
13050 tree op_type = TREE_TYPE (op);
ab3a6dd6 13051 tree prom_type = NULL_TREE, value, decl;
c2952b01 13052 int outer_field_flag = 0;
e04a16fb
AG		 13053 int code = TREE_CODE (node);
13054 int error_found = 0;
13055
13056 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13057
13058 switch (code)
13059 {
13060 /* 15.13.2 Postfix Increment Operator ++ */
13061 case POSTINCREMENT_EXPR:
13062 /* 15.13.3 Postfix Increment Operator -- */
13063 case POSTDECREMENT_EXPR:
13064 /* 15.14.1 Prefix Increment Operator ++ */
13065 case PREINCREMENT_EXPR:
13066 /* 15.14.2 Prefix Decrement Operator -- */
13067 case PREDECREMENT_EXPR:
5cbdba64 13068 op = decl = strip_out_static_field_access_decl (op);
c2952b01
APB		 13069 outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
13070 /* We might be trying to change an outer field accessed using
13071 access method. */
13072 if (outer_field_flag)
13073 {
13074 /* Retrieve the decl of the field we're trying to access. We
13075 do that by first retrieving the function we would call to
13076 access the field. It has been already verified that this
13077 field isn't final */
13078 if (flag_emit_class_files)
13079 decl = TREE_OPERAND (op, 0);
13080 else
13081 decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
13082 decl = DECL_FUNCTION_ACCESS_DECL (decl);
13083 }
b3edebcf 13084 /* We really should have a JAVA_ARRAY_EXPR to avoid this */
c2952b01 13085 else if (!JDECL_P (decl)
b3edebcf
APB		 13086 && TREE_CODE (decl) != COMPONENT_REF
13087 && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
13088 && TREE_CODE (decl) != INDIRECT_REF
13089 && !(TREE_CODE (decl) == COMPOUND_EXPR
13090 && TREE_OPERAND (decl, 1)
13091 && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
e04a16fb 13092 {
5e942c50
APB		 13093 tree lvalue;
13094 /* Before screaming, check that we're not in fact trying to
13095 increment a optimized static final access, in which case
13096 we issue an different error message. */
13097 if (!(TREE_CODE (wfl_op) == EXPR_WITH_FILE_LOCATION
13098 && resolve_expression_name (wfl_op, &lvalue)
13099 && check_final_assignment (lvalue, wfl_op)))
13100 parse_error_context (wfl_operator, "Invalid argument to `%s'",
13101 operator_string (node));
e04a16fb
AG		 13102 TREE_TYPE (node) = error_mark_node;
13103 error_found = 1;
13104 }
c2952b01
APB		 13105
13106 if (check_final_assignment (op, wfl_op))
5e942c50
APB		 13107 error_found = 1;
13108
e04a16fb
AG		 13109 /* From now on, we know that op if a variable and that it has a
13110 valid wfl. We use wfl_op to locate errors related to the
13111 ++/-- operand. */
13112 else if (!JNUMERIC_TYPE_P (op_type))
13113 {
13114 parse_error_context
13115 (wfl_op, "Invalid argument type `%s' to `%s'",
0a2138e2 13116 lang_printable_name (op_type, 0), operator_string (node));
e04a16fb
AG		 13117 TREE_TYPE (node) = error_mark_node;
13118 error_found = 1;
13119 }
13120 else
13121 {
4a5f66c3 13122 /* Before the addition, binary numeric promotion is performed on
5cbdba64
APB		 13123 both operands, if really necessary */
13124 if (JINTEGRAL_TYPE_P (op_type))
13125 {
13126 value = build_int_2 (1, 0);
13127 TREE_TYPE (value) = TREE_TYPE (node) = op_type;
13128 }
13129 else
13130 {
13131 value = build_int_2 (1, 0);
13132 TREE_TYPE (node) =
13133 binary_numeric_promotion (op_type,
13134 TREE_TYPE (value), &op, &value);
13135 }
c2952b01
APB		 13136
13137 /* We remember we might be accessing an outer field */
13138 if (outer_field_flag)
13139 {
13140 /* We re-generate an access to the field */
13141 value = build (PLUS_EXPR, TREE_TYPE (op),
13142 build_outer_field_access (wfl_op, decl), value);
13143
13144 /* And we patch the original access$() into a write
13145 with plus_op as a rhs */
13146 return outer_field_access_fix (node, op, value);
13147 }
13148
5cbdba64 13149 /* And write back into the node. */
4a5f66c3 13150 TREE_OPERAND (node, 0) = op;
e04a16fb 13151 TREE_OPERAND (node, 1) = value;
5cbdba64
APB		 13152 /* Convert the overall back into its original type, if
13153 necessary, and return */
13154 if (JINTEGRAL_TYPE_P (op_type))
13155 return fold (node);
13156 else
13157 return fold (convert (op_type, node));
e04a16fb
AG		 13158 }
13159 break;
13160
13161 /* 15.14.3 Unary Plus Operator + */
b67d701b 13162 case UNARY_PLUS_EXPR:
e04a16fb
AG		 13163 /* 15.14.4 Unary Minus Operator - */
13164 case NEGATE_EXPR:
13165 if (!JNUMERIC_TYPE_P (op_type))
13166 {
13167 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
13168 TREE_TYPE (node) = error_mark_node;
13169 error_found = 1;
13170 }
13171 /* Unary numeric promotion is performed on operand */
13172 else
13173 {
15fdcfe9
PB		 13174 op = do_unary_numeric_promotion (op);
13175 prom_type = TREE_TYPE (op);
b67d701b 13176 if (code == UNARY_PLUS_EXPR)
4a5f66c3 13177 return fold (op);
e04a16fb
AG		 13178 }
13179 break;
13180
13181 /* 15.14.5 Bitwise Complement Operator ~ */
13182 case BIT_NOT_EXPR:
13183 if (!JINTEGRAL_TYPE_P (op_type))
13184 {
13185 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
13186 TREE_TYPE (node) = error_mark_node;
13187 error_found = 1;
13188 }
13189 else
13190 {
15fdcfe9
PB		 13191 op = do_unary_numeric_promotion (op);
13192 prom_type = TREE_TYPE (op);
e04a16fb
AG		 13193 }
13194 break;
13195
13196 /* 15.14.6 Logical Complement Operator ! */
13197 case TRUTH_NOT_EXPR:
13198 if (TREE_CODE (op_type) != BOOLEAN_TYPE)
13199 {
13200 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
c877974e
APB		 13201 /* But the type is known. We will report an error if further
13202 attempt of a assignment is made with this rhs */
e04a16fb
AG		 13203 TREE_TYPE (node) = boolean_type_node;
13204 error_found = 1;
13205 }
13206 else
13207 prom_type = boolean_type_node;
13208 break;
13209
13210 /* 15.15 Cast Expression */
13211 case CONVERT_EXPR:
0a2138e2 13212 value = patch_cast (node, wfl_operator);
e04a16fb 13213 if (value == error_mark_node)
c877974e
APB		 13214 {
13215 /* If this cast is part of an assignment, we tell the code
13216 that deals with it not to complain about a mismatch,
13217 because things have been cast, anyways */
13218 TREE_TYPE (node) = error_mark_node;
13219 error_found = 1;
13220 }
13221 else
dc0b3eff
PB		 13222 {
13223 value = fold (value);
13224 TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
13225 return value;
13226 }
e04a16fb
AG		 13227 break;
13228 }
13229
e04a16fb
AG		 13230 if (error_found)
13231 return error_mark_node;
4a5f66c3
APB		 13232
13233 /* There are cases where node has been replaced by something else
13234 and we don't end up returning here: UNARY_PLUS_EXPR,
13235 CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
7525cc04 13236 TREE_OPERAND (node, 0) = fold (op);
4a5f66c3 13237 TREE_TYPE (node) = prom_type;
dc0b3eff 13238 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
e04a16fb
AG		 13239 return fold (node);
13240}
13241
13242/* Generic type resolution that sometimes takes place during node
13243 patching. Returned the resolved type or generate an error
13244 message. Return the resolved type or NULL_TREE. */
13245
13246static tree
13247resolve_type_during_patch (type)
13248 tree type;
13249{
13250 if (unresolved_type_p (type, NULL))
13251 {
13252 tree type_decl = resolve_no_layout (EXPR_WFL_NODE (type), NULL_TREE);
13253 if (!type_decl)
13254 {
13255 parse_error_context (type,
13256 "Class `%s' not found in type declaration",
13257 IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
13258 return NULL_TREE;
13259 }
13260 else
5e942c50
APB		 13261 {
13262 CLASS_LOADED_P (TREE_TYPE (type_decl)) = 1;
13263 return TREE_TYPE (type_decl);
13264 }
e04a16fb
AG		 13265 }
13266 return type;
13267}
13268/* 5.5 Casting Conversion. error_mark_node is returned if an error is
13269 found. Otherwise NODE or something meant to replace it is returned. */
13270
13271static tree
0a2138e2 13272patch_cast (node, wfl_operator)
e04a16fb 13273 tree node;
e04a16fb
AG		 13274 tree wfl_operator;
13275{
13276 tree op = TREE_OPERAND (node, 0);
13277 tree op_type = TREE_TYPE (op);
13278 tree cast_type = TREE_TYPE (node);
13279 char *t1;
13280
13281 /* First resolve OP_TYPE if unresolved */
13282 if (!(cast_type = resolve_type_during_patch (cast_type)))
13283 return error_mark_node;
13284
13285 /* Check on cast that are proven correct at compile time */
13286 if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
13287 {
e04a16fb
AG		 13288 /* Same type */
13289 if (cast_type == op_type)
13290 return node;
13291
0b4d333e
APB		 13292 /* float and double type are converted to the original type main
13293 variant and then to the target type. */
13294 if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE)
13295 op = convert (integer_type_node, op);
13296
e04a16fb
AG		 13297 /* Try widening/narowwing convertion. Potentially, things need
13298 to be worked out in gcc so we implement the extreme cases
13299 correctly. fold_convert() needs to be fixed. */
13300 return convert (cast_type, op);
13301 }
13302
0b4d333e
APB		 13303 /* It's also valid to cast a boolean into a boolean */
13304 if (op_type == boolean_type_node && cast_type == boolean_type_node)
13305 return node;
13306
5e942c50
APB		 13307 /* null can be casted to references */
13308 if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
13309 return build_null_of_type (cast_type);
13310
e04a16fb
AG		 13311 /* The remaining legal casts involve conversion between reference
13312 types. Check for their compile time correctness. */
13313 if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
09ed0f70 13314 && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
e04a16fb
AG		 13315 {
13316 TREE_TYPE (node) = promote_type (cast_type);
13317 /* Now, the case can be determined correct at compile time if
13318 OP_TYPE can be converted into CAST_TYPE by assignment
13319 conversion (5.2) */
13320
13321 if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
15fdcfe9
PB		 13322 {
13323 TREE_SET_CODE (node, NOP_EXPR);
13324 return node;
13325 }
13326
13327 if (flag_emit_class_files)
13328 {
13329 TREE_SET_CODE (node, CONVERT_EXPR);
13330 return node;
13331 }
e04a16fb
AG		 13332
13333 /* The cast requires a run-time check */
13334 return build (CALL_EXPR, promote_type (cast_type),
13335 build_address_of (soft_checkcast_node),
13336 tree_cons (NULL_TREE, build_class_ref (cast_type),
13337 build_tree_list (NULL_TREE, op)),
13338 NULL_TREE);
13339 }
13340
13341 /* Any other casts are proven incorrect at compile time */
c2e3db92 13342 t1 = xstrdup (lang_printable_name (op_type, 0));
e04a16fb 13343 parse_error_context (wfl_operator, "Invalid cast from `%s' to `%s'",
0a2138e2 13344 t1, lang_printable_name (cast_type, 0));
e04a16fb
AG		 13345 free (t1);
13346 return error_mark_node;
13347}
13348
5e942c50
APB		 13349/* Build a null constant and give it the type TYPE. */
13350
13351static tree
13352build_null_of_type (type)
13353 tree type;
13354{
13355 tree node = build_int_2 (0, 0);
13356 TREE_TYPE (node) = promote_type (type);
13357 return node;
13358}
13359
e04a16fb
AG		 13360/* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
13361 a list of indices. */
13362static tree
13363build_array_ref (location, array, index)
13364 int location;
13365 tree array, index;
13366{
13367 tree node = build (ARRAY_REF, NULL_TREE, array, index);
13368 EXPR_WFL_LINECOL (node) = location;
13369 return node;
13370}
13371
13372/* 15.12 Array Access Expression */
13373
13374static tree
c877974e
APB		 13375patch_array_ref (node)
13376 tree node;
e04a16fb
AG		 13377{
13378 tree array = TREE_OPERAND (node, 0);
13379 tree array_type = TREE_TYPE (array);
13380 tree index = TREE_OPERAND (node, 1);
13381 tree index_type = TREE_TYPE (index);
e04a16fb
AG		 13382 int error_found = 0;
13383
13384 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13385
e04a16fb
AG		 13386 if (TREE_CODE (array_type) == POINTER_TYPE)
13387 array_type = TREE_TYPE (array_type);
13388
13389 /* The array reference must be an array */
13390 if (!TYPE_ARRAY_P (array_type))
13391 {
13392 parse_error_context
781b0558
KG		 13393 (wfl_operator,
13394 "`[]' can only be applied to arrays. It can't be applied to `%s'",
13395 lang_printable_name (array_type, 0));
e04a16fb
AG		 13396 TREE_TYPE (node) = error_mark_node;
13397 error_found = 1;
13398 }
13399
c2952b01 13400 /* The array index undergoes unary numeric promotion. The promoted
e04a16fb 13401 type must be int */
15fdcfe9
PB		 13402 index = do_unary_numeric_promotion (index);
13403 if (TREE_TYPE (index) != int_type_node)
e04a16fb 13404 {
1ebadc60 13405 if (valid_cast_to_p (index_type, int_type_node))
781b0558
KG		 13406 parse_error_context (wfl_operator,
13407 "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
1ebadc60
KG		 13408 lang_printable_name (index_type, 0));
13409 else
781b0558
KG		 13410 parse_error_context (wfl_operator,
13411 "Incompatible type for `[]'. Can't convert `%s' to `int'",
1ebadc60 13412 lang_printable_name (index_type, 0));
e04a16fb
AG		 13413 TREE_TYPE (node) = error_mark_node;
13414 error_found = 1;
13415 }
13416
e04a16fb
AG		 13417 if (error_found)
13418 return error_mark_node;
e04a16fb 13419
5e942c50 13420 array_type = TYPE_ARRAY_ELEMENT (array_type);
5e942c50 13421
7f1d4866 13422 if (flag_emit_class_files || flag_emit_xref)
e04a16fb 13423 {
15fdcfe9
PB		 13424 TREE_OPERAND (node, 0) = array;
13425 TREE_OPERAND (node, 1) = index;
e04a16fb
AG		 13426 }
13427 else
939d7216
PB		 13428 {
13429 /* The save_expr is for correct evaluation order. It would be cleaner
13430 to use force_evaluation_order (see comment there), but that is
13431 difficult when we also have to deal with bounds checking. */
13432 if (TREE_SIDE_EFFECTS (index))
13433 array = save_expr (array);
13434 node = build_java_arrayaccess (array, array_type, index);
13435 if (TREE_SIDE_EFFECTS (index))
13436 node = build (COMPOUND_EXPR, array_type, array, node);
13437 }
e04a16fb
AG		 13438 TREE_TYPE (node) = array_type;
13439 return node;
13440}
13441
13442/* 15.9 Array Creation Expressions */
13443
13444static tree
13445build_newarray_node (type, dims, extra_dims)
13446 tree type;
13447 tree dims;
13448 int extra_dims;
13449{
13450 tree node =
b67d701b 13451 build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
e04a16fb 13452 build_int_2 (extra_dims, 0));
e04a16fb
AG		 13453 return node;
13454}
13455
13456static tree
13457patch_newarray (node)
13458 tree node;
13459{
13460 tree type = TREE_OPERAND (node, 0);
13461 tree dims = TREE_OPERAND (node, 1);
13462 tree cdim, array_type;
13463 int error_found = 0;
13464 int ndims = 0;
13465 int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
e04a16fb
AG		 13466
13467 /* Dimension types are verified. It's better for the types to be
13468 verified in order. */
13469 for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
13470 {
13471 int dim_error = 0;
13472 tree dim = TREE_VALUE (cdim);
13473
13474 /* Dim might have been saved during its evaluation */
13475 dim = (TREE_CODE (dim) == SAVE_EXPR ? dim = TREE_OPERAND (dim, 0) : dim);
13476
13477 /* The type of each specified dimension must be an integral type. */
13478 if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
13479 dim_error = 1;
13480
13481 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
13482 promoted type must be int. */
13483 else
13484 {
15fdcfe9 13485 dim = do_unary_numeric_promotion (dim);
e04a16fb
AG		 13486 if (TREE_TYPE (dim) != int_type_node)
13487 dim_error = 1;
13488 }
13489
13490 /* Report errors on types here */
13491 if (dim_error)
13492 {
13493 parse_error_context
13494 (TREE_PURPOSE (cdim),
781b0558 13495 "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
b67d701b 13496 (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
e04a16fb 13497 "Explicit cast needed to" : "Can't"),
0a2138e2 13498 lang_printable_name (TREE_TYPE (dim), 0));
e04a16fb
AG		 13499 error_found = 1;
13500 }
13501
e04a16fb
AG		 13502 TREE_PURPOSE (cdim) = NULL_TREE;
13503 }
13504
13505 /* Resolve array base type if unresolved */
13506 if (!(type = resolve_type_during_patch (type)))
13507 error_found = 1;
13508
13509 if (error_found)
13510 {
13511 /* We don't want further evaluation of this bogus array creation
13512 operation */
13513 TREE_TYPE (node) = error_mark_node;
13514 return error_mark_node;
13515 }
13516
15fdcfe9
PB		 13517 /* Set array_type to the actual (promoted) array type of the result. */
13518 if (TREE_CODE (type) == RECORD_TYPE)
13519 type = build_pointer_type (type);
13520 while (--xdims >= 0)
13521 {
13522 type = promote_type (build_java_array_type (type, -1));
13523 }
13524 dims = nreverse (dims);
13525 array_type = type;
13526 for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
13527 {
13528 type = array_type;
05bccae2
RK		 13529 array_type
13530 = build_java_array_type (type,
13531 TREE_CODE (cdim) == INTEGER_CST
13532 ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
13533 : -1);
15fdcfe9
PB		 13534 array_type = promote_type (array_type);
13535 }
13536 dims = nreverse (dims);
13537
e04a16fb
AG		 13538 /* The node is transformed into a function call. Things are done
13539 differently according to the number of dimensions. If the number
13540 of dimension is equal to 1, then the nature of the base type
13541 (primitive or not) matters. */
15fdcfe9 13542 if (ndims == 1)
fdec99c6 13543 return build_new_array (type, TREE_VALUE (dims));
e04a16fb 13544
e04a16fb
AG		 13545 /* Can't reuse what's already written in expr.c because it uses the
13546 JVM stack representation. Provide a build_multianewarray. FIXME */
15fdcfe9 13547 return build (CALL_EXPR, array_type,
e04a16fb 13548 build_address_of (soft_multianewarray_node),
15fdcfe9 13549 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
e04a16fb 13550 tree_cons (NULL_TREE,
15fdcfe9 13551 build_int_2 (ndims, 0), dims )),
e04a16fb
AG		 13552 NULL_TREE);
13553}
13554
f8976021
APB		 13555/* 10.6 Array initializer. */
13556
13557/* Build a wfl for array element that don't have one, so we can
13558 pin-point errors. */
13559
13560static tree
13561maybe_build_array_element_wfl (node)
13562 tree node;
13563{
13564 if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
13565 return build_expr_wfl (NULL_TREE, ctxp->filename,
13566 ctxp->elc.line, ctxp->elc.prev_col);
13567 else
13568 return NULL_TREE;
13569}
13570
13571/* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
13572 identification of initialized arrays easier to detect during walk
13573 and expansion. */
13574
13575static tree
13576build_new_array_init (location, values)
13577 int location;
13578 tree values;
13579{
13580 tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
13581 tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
5bba4807 13582 EXPR_WFL_LINECOL (to_return) = location;
f8976021
APB		 13583 return to_return;
13584}
13585
13586/* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
13587 occurred. Otherwise return NODE after having set its type
13588 appropriately. */
13589
13590static tree
13591patch_new_array_init (type, node)
13592 tree type, node;
f8976021
APB		 13593{
13594 int error_seen = 0;
fdec99c6 13595 tree current, element_type;
f8976021 13596 HOST_WIDE_INT length;
fdec99c6
PB		 13597 int all_constant = 1;
13598 tree init = TREE_OPERAND (node, 0);
f8976021 13599
fdec99c6
PB		 13600 if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
13601 {
13602 parse_error_context (node,
13603 "Invalid array initializer for non-array type `%s'",
13604 lang_printable_name (type, 1));
13605 return error_mark_node;
13606 }
13607 type = TREE_TYPE (type);
13608 element_type = TYPE_ARRAY_ELEMENT (type);
f8976021 13609
fdec99c6
PB		 13610 CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
13611
13612 for (length = 0, current = CONSTRUCTOR_ELTS (init);
13613 current; length++, current = TREE_CHAIN (current))
f8976021 13614 {
fdec99c6
PB		 13615 tree elt = TREE_VALUE (current);
13616 if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
f8976021 13617 {
fdec99c6 13618 error_seen |= array_constructor_check_entry (element_type, current);
5bba4807
PB		 13619 elt = TREE_VALUE (current);
13620 /* When compiling to native code, STRING_CST is converted to
13621 INDIRECT_REF, but still with a TREE_CONSTANT flag. */
13622 if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
fdec99c6 13623 all_constant = 0;
f8976021 13624 }
fdec99c6
PB		 13625 else
13626 {
13627 TREE_VALUE (current) = patch_new_array_init (element_type, elt);
13628 TREE_PURPOSE (current) = NULL_TREE;
13629 all_constant = 0;
13630 }
9a7ab4b3
APB		 13631 if (elt && TREE_CODE (elt) == TREE_LIST
13632 && TREE_VALUE (elt) == error_mark_node)
fdec99c6 13633 error_seen = 1;
f8976021
APB		 13634 }
13635
13636 if (error_seen)
13637 return error_mark_node;
13638
13639 /* Create a new type. We can't reuse the one we have here by
13640 patching its dimension because it originally is of dimension -1
13641 hence reused by gcc. This would prevent triangular arrays. */
fdec99c6
PB		 13642 type = build_java_array_type (element_type, length);
13643 TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
13644 TREE_TYPE (node) = promote_type (type);
13645 TREE_CONSTANT (init) = all_constant;
bc3ca41b 13646 TREE_CONSTANT (node) = all_constant;
f8976021
APB		 13647 return node;
13648}
13649
13650/* Verify that one entry of the initializer element list can be
13651 assigned to the array base type. Report 1 if an error occurred, 0
13652 otherwise. */
13653
13654static int
13655array_constructor_check_entry (type, entry)
13656 tree type, entry;
13657{
13658 char *array_type_string = NULL; /* For error reports */
13659 tree value, type_value, new_value, wfl_value, patched;
13660 int error_seen = 0;
13661
13662 new_value = NULL_TREE;
13663 wfl_value = TREE_VALUE (entry);
13664
100f7cd8 13665 push_obstacks (&permanent_obstack, &permanent_obstack);
f8976021 13666 value = java_complete_tree (TREE_VALUE (entry));
1179ebc2 13667 /* patch_string return error_mark_node if arg is error_mark_node */
f8976021
APB		 13668 if ((patched = patch_string (value)))
13669 value = patched;
1179ebc2
APB		 13670 if (value == error_mark_node)
13671 return 1;
f8976021 13672
f8976021
APB		 13673 type_value = TREE_TYPE (value);
13674
1179ebc2 13675 /* At anytime, try_builtin_assignconv can report a warning on
f8976021
APB		 13676 constant overflow during narrowing. */
13677 SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
13678 new_value = try_builtin_assignconv (wfl_operator, type, value);
13679 if (!new_value && (new_value = try_reference_assignconv (type, value)))
13680 type_value = promote_type (type);
100f7cd8
APB		 13681
13682 pop_obstacks ();
f8976021
APB		 13683 /* Check and report errors */
13684 if (!new_value)
13685 {
49f48c71 13686 const char *msg = (!valid_cast_to_p (type_value, type) ?
f8976021
APB		 13687 "Can't" : "Explicit cast needed to");
13688 if (!array_type_string)
c2e3db92 13689 array_type_string = xstrdup (lang_printable_name (type, 1));
f8976021
APB		 13690 parse_error_context
13691 (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
13692 msg, lang_printable_name (type_value, 1), array_type_string);
13693 error_seen = 1;
13694 }
13695
13696 if (new_value)
13697 {
b8c5b1c6 13698 new_value = maybe_build_primttype_type_ref (new_value, wfl_value);
f8976021
APB		 13699 TREE_VALUE (entry) = new_value;
13700 }
13701
13702 if (array_type_string)
13703 free (array_type_string);
13704
13705 TREE_PURPOSE (entry) = NULL_TREE;
13706 return error_seen;
13707}
13708
e04a16fb
AG		 13709static tree
13710build_this (location)
13711 int location;
13712{
9ee9b555 13713 tree node = build_wfl_node (this_identifier_node);
b67d701b 13714 TREE_SET_CODE (node, THIS_EXPR);
e04a16fb
AG		 13715 EXPR_WFL_LINECOL (node) = location;
13716 return node;
13717}
13718
13719/* 14.15 The return statement. It builds a modify expression that
13720 assigns the returned value to the RESULT_DECL that hold the value
13721 to be returned. */
13722
13723static tree
13724build_return (location, op)
13725 int location;
13726 tree op;
13727{
13728 tree node = build1 (RETURN_EXPR, NULL_TREE, op);
13729 EXPR_WFL_LINECOL (node) = location;
b67d701b 13730 node = build_debugable_stmt (location, node);
e04a16fb
AG		 13731 return node;
13732}
13733
13734static tree
13735patch_return (node)
13736 tree node;
13737{
13738 tree return_exp = TREE_OPERAND (node, 0);
13739 tree meth = current_function_decl;
13740 tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
e04a16fb
AG		 13741 int error_found = 0;
13742
13743 TREE_TYPE (node) = error_mark_node;
13744 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13745
13746 /* It's invalid to have a return value within a function that is
13747 declared with the keyword void or that is a constructor */
13748 if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
13749 error_found = 1;
13750
f099f336 13751 /* It's invalid to use a return statement in a static block */
c2952b01 13752 if (DECL_CLINIT_P (current_function_decl))
f099f336
APB		 13753 error_found = 1;
13754
e04a16fb
AG		 13755 /* It's invalid to have a no return value within a function that
13756 isn't declared with the keyword `void' */
13757 if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
13758 error_found = 2;
c2952b01
APB		 13759
13760 if (in_instance_initializer)
13761 error_found = 1;
e04a16fb
AG		 13762
13763 if (error_found)
13764 {
c2952b01 13765 if (in_instance_initializer)
f099f336 13766 parse_error_context (wfl_operator,
c2952b01
APB		 13767 "`return' inside instance initializer");
13768
13769 else if (DECL_CLINIT_P (current_function_decl))
13770 parse_error_context (wfl_operator,
13771 "`return' inside static initializer");
f099f336
APB		 13772
13773 else if (!DECL_CONSTRUCTOR_P (meth))
22eed1e6 13774 {
c2e3db92 13775 char *t = xstrdup (lang_printable_name (mtype, 0));
22eed1e6
APB		 13776 parse_error_context (wfl_operator,
13777 "`return' with%s value from `%s %s'",
13778 (error_found == 1 ? "" : "out"),
13779 t, lang_printable_name (meth, 0));
13780 free (t);
13781 }
13782 else
13783 parse_error_context (wfl_operator,
13784 "`return' with value from constructor `%s'",
13785 lang_printable_name (meth, 0));
e04a16fb
AG		 13786 return error_mark_node;
13787 }
13788
5e942c50
APB		 13789 /* If we have a return_exp, build a modify expression and expand
13790 it. Note: at that point, the assignment is declared valid, but we
13791 may want to carry some more hacks */
e04a16fb
AG		 13792 if (return_exp)
13793 {
5e942c50
APB		 13794 tree exp = java_complete_tree (return_exp);
13795 tree modify, patched;
13796
13797 /* If the function returned value and EXP are booleans, EXP has
13798 to be converted into the type of DECL_RESULT, which is integer
13799 (see complete_start_java_method) */
13800 if (TREE_TYPE (exp) == boolean_type_node &&
13801 TREE_TYPE (TREE_TYPE (meth)) == boolean_type_node)
13802 exp = convert_to_integer (TREE_TYPE (DECL_RESULT (meth)), exp);
13803
13804 /* `null' can be assigned to a function returning a reference */
13805 if (JREFERENCE_TYPE_P (TREE_TYPE (TREE_TYPE (meth))) &&
13806 exp == null_pointer_node)
13807 exp = build_null_of_type (TREE_TYPE (TREE_TYPE (meth)));
13808
13809 if ((patched = patch_string (exp)))
13810 exp = patched;
13811
13812 modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
e04a16fb
AG		 13813 EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
13814 modify = java_complete_tree (modify);
5e942c50 13815
e04a16fb
AG		 13816 if (modify != error_mark_node)
13817 {
13818 TREE_SIDE_EFFECTS (modify) = 1;
13819 TREE_OPERAND (node, 0) = modify;
13820 }
13821 else
13822 return error_mark_node;
13823 }
13824 TREE_TYPE (node) = void_type_node;
13825 TREE_SIDE_EFFECTS (node) = 1;
13826 return node;
13827}
13828
13829/* 14.8 The if Statement */
13830
13831static tree
13832build_if_else_statement (location, expression, if_body, else_body)
13833 int location;
13834 tree expression, if_body, else_body;
13835{
13836 tree node;
e04a16fb 13837 if (!else_body)
9bbc7d9f 13838 else_body = empty_stmt_node;
e04a16fb
AG		 13839 node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
13840 EXPR_WFL_LINECOL (node) = location;
b67d701b 13841 node = build_debugable_stmt (location, node);
e04a16fb
AG		 13842 return node;
13843}
13844
13845static tree
13846patch_if_else_statement (node)
13847 tree node;
13848{
13849 tree expression = TREE_OPERAND (node, 0);
13850
13851 TREE_TYPE (node) = error_mark_node;
13852 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13853
13854 /* The type of expression must be boolean */
b67d701b
PB		 13855 if (TREE_TYPE (expression) != boolean_type_node
13856 && TREE_TYPE (expression) != promoted_boolean_type_node)
e04a16fb
AG		 13857 {
13858 parse_error_context
13859 (wfl_operator,
13860 "Incompatible type for `if'. Can't convert `%s' to `boolean'",
0a2138e2 13861 lang_printable_name (TREE_TYPE (expression), 0));
e04a16fb
AG		 13862 return error_mark_node;
13863 }
13864
13865 TREE_TYPE (node) = void_type_node;
13866 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9 13867 CAN_COMPLETE_NORMALLY (node)
9bbc7d9f
PB		 13868 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
13869 | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2));
e04a16fb
AG		 13870 return node;
13871}
13872
13873/* 14.6 Labeled Statements */
13874
13875/* Action taken when a lableled statement is parsed. a new
13876 LABELED_BLOCK_EXPR is created. No statement is attached to the
b635eb2f 13877 label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
e04a16fb
AG		 13878
13879static tree
0a2138e2 13880build_labeled_block (location, label)
e04a16fb 13881 int location;
0a2138e2 13882 tree label;
e04a16fb 13883{
b635eb2f 13884 tree label_name ;
e04a16fb 13885 tree label_decl, node;
b635eb2f
PB		 13886 if (label == NULL_TREE || label == continue_identifier_node)
13887 label_name = label;
13888 else
e04a16fb 13889 {
b635eb2f
PB		 13890 label_name = merge_qualified_name (label_id, label);
13891 /* Issue an error if we try to reuse a label that was previously
13892 declared */
13893 if (IDENTIFIER_LOCAL_VALUE (label_name))
13894 {
13895 EXPR_WFL_LINECOL (wfl_operator) = location;
781b0558
KG		 13896 parse_error_context (wfl_operator,
13897 "Declaration of `%s' shadows a previous label declaration",
b635eb2f
PB		 13898 IDENTIFIER_POINTER (label));
13899 EXPR_WFL_LINECOL (wfl_operator) =
13900 EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
781b0558
KG		 13901 parse_error_context (wfl_operator,
13902 "This is the location of the previous declaration of label `%s'",
b635eb2f
PB		 13903 IDENTIFIER_POINTER (label));
13904 java_error_count--;
13905 }
e04a16fb
AG		 13906 }
13907
13908 label_decl = create_label_decl (label_name);
13909 node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
13910 EXPR_WFL_LINECOL (node) = location;
13911 TREE_SIDE_EFFECTS (node) = 1;
13912 return node;
13913}
13914
b67d701b 13915/* A labeled statement LBE is attached a statement. */
e04a16fb
AG		 13916
13917static tree
b635eb2f 13918finish_labeled_statement (lbe, statement)
e04a16fb
AG		 13919 tree lbe; /* Labeled block expr */
13920 tree statement;
13921{
13922 /* In anyways, tie the loop to its statement */
13923 LABELED_BLOCK_BODY (lbe) = statement;
b635eb2f
PB		 13924 pop_labeled_block ();
13925 POP_LABELED_BLOCK ();
e04a16fb
AG		 13926 return lbe;
13927}
13928
13929/* 14.10, 14.11, 14.12 Loop Statements */
13930
13931/* Create an empty LOOP_EXPR and make it the last in the nested loop
13932 list. */
13933
13934static tree
13935build_new_loop (loop_body)
13936 tree loop_body;
13937{
13938 tree loop = build (LOOP_EXPR, NULL_TREE, loop_body);
13939 TREE_SIDE_EFFECTS (loop) = 1;
13940 PUSH_LOOP (loop);
13941 return loop;
13942}
13943
13944/* Create a loop body according to the following structure:
13945 COMPOUND_EXPR
13946 COMPOUND_EXPR (loop main body)
13947 EXIT_EXPR (this order is for while/for loops.
13948 LABELED_BLOCK_EXPR the order is reversed for do loops)
34f4db93 13949 LABEL_DECL (a continue occuring here branches at the
e04a16fb
AG		 13950 BODY end of this labeled block)
13951 INCREMENT (if any)
13952
13953 REVERSED, if non zero, tells that the loop condition expr comes
b67d701b
PB		 13954 after the body, like in the do-while loop.
13955
13956 To obtain a loop, the loop body structure described above is
13957 encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
13958
13959 LABELED_BLOCK_EXPR
13960 LABEL_DECL (use this label to exit the loop)
13961 LOOP_EXPR
13962 <structure described above> */
e04a16fb
AG		 13963
13964static tree
13965build_loop_body (location, condition, reversed)
13966 int location;
13967 tree condition;
13968 int reversed;
13969{
0a2138e2 13970 tree first, second, body;
e04a16fb
AG		 13971
13972 condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
13973 EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
13974 condition = build_debugable_stmt (location, condition);
13975 TREE_SIDE_EFFECTS (condition) = 1;
13976
b635eb2f 13977 body = build_labeled_block (0, continue_identifier_node);
e04a16fb
AG		 13978 first = (reversed ? body : condition);
13979 second = (reversed ? condition : body);
13980 return
13981 build (COMPOUND_EXPR, NULL_TREE,
9bbc7d9f 13982 build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
e04a16fb
AG		 13983}
13984
13985/* Install CONDITION (if any) and loop BODY (using REVERSED to tell
13986 their order) on the current loop. Unlink the current loop from the
13987 loop list. */
13988
13989static tree
b635eb2f 13990finish_loop_body (location, condition, body, reversed)
e04a16fb
AG		 13991 int location;
13992 tree condition, body;
13993 int reversed;
13994{
13995 tree to_return = ctxp->current_loop;
13996 tree loop_body = LOOP_EXPR_BODY (to_return);
13997 if (condition)
13998 {
13999 tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14000 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14001 The real EXIT_EXPR is one operand further. */
14002 EXPR_WFL_LINECOL (cnode) = location;
14003 /* This one is for accurate error reports */
14004 EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14005 TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14006 }
14007 LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14008 POP_LOOP ();
14009 return to_return;
14010}
14011
b635eb2f 14012/* Tailored version of finish_loop_body for FOR loops, when FOR
e04a16fb
AG		 14013 loops feature the condition part */
14014
14015static tree
b635eb2f 14016finish_for_loop (location, condition, update, body)
e04a16fb
AG		 14017 int location;
14018 tree condition, update, body;
14019{
14020 /* Put the condition and the loop body in place */
b635eb2f 14021 tree loop = finish_loop_body (location, condition, body, 0);
e04a16fb
AG		 14022 /* LOOP is the current loop which has been now popped of the loop
14023 stack. Install the update block */
14024 LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14025 return loop;
14026}
14027
5cbdba64
APB		 14028/* Try to find the loop a block might be related to. This comprises
14029 the case where the LOOP_EXPR is found as the second operand of a
14030 COMPOUND_EXPR, because the loop happens to have an initialization
14031 part, then expressed as the first operand of the COMPOUND_EXPR. If
14032 the search finds something, 1 is returned. Otherwise, 0 is
14033 returned. The search is assumed to start from a
14034 LABELED_BLOCK_EXPR's block. */
14035
14036static tree
14037search_loop (statement)
14038 tree statement;
14039{
14040 if (TREE_CODE (statement) == LOOP_EXPR)
14041 return statement;
14042
14043 if (TREE_CODE (statement) == BLOCK)
14044 statement = BLOCK_SUBBLOCKS (statement);
14045 else
14046 return NULL_TREE;
14047
14048 if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14049 while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14050 statement = TREE_OPERAND (statement, 1);
14051
14052 return (TREE_CODE (statement) == LOOP_EXPR
c2952b01 14053 && FOR_LOOP_P (statement) ? statement : NULL_TREE);
5cbdba64
APB		 14054}
14055
14056/* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
14057 returned otherwise. */
14058
14059static int
14060labeled_block_contains_loop_p (block, loop)
14061 tree block, loop;
14062{
14063 if (!block)
14064 return 0;
14065
14066 if (LABELED_BLOCK_BODY (block) == loop)
14067 return 1;
14068
c2952b01 14069 if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
5cbdba64
APB		 14070 return 1;
14071
14072 return 0;
14073}
14074
e04a16fb 14075/* If the loop isn't surrounded by a labeled statement, create one and
b635eb2f 14076 insert LOOP as its body. */
e04a16fb
AG		 14077
14078static tree
14079patch_loop_statement (loop)
14080 tree loop;
14081{
cd9643f7 14082 tree loop_label;
5cbdba64 14083
cd9643f7 14084 TREE_TYPE (loop) = void_type_node;
5cbdba64
APB		 14085 if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
14086 return loop;
14087
cd9643f7 14088 loop_label = build_labeled_block (0, NULL_TREE);
5cbdba64
APB		 14089 /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
14090 that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
cd9643f7
PB		 14091 LABELED_BLOCK_BODY (loop_label) = loop;
14092 PUSH_LABELED_BLOCK (loop_label);
5cbdba64 14093 return loop_label;
e04a16fb
AG		 14094}
14095
14096/* 14.13, 14.14: break and continue Statements */
14097
14098/* Build a break or a continue statement. a null NAME indicates an
14099 unlabeled break/continue statement. */
14100
14101static tree
14102build_bc_statement (location, is_break, name)
14103 int location, is_break;
14104 tree name;
14105{
14106 tree break_continue, label_block_expr = NULL_TREE;
14107
14108 if (name)
14109 {
14110 if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
14111 (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
14112 /* Null means that we don't have a target for this named
14113 break/continue. In this case, we make the target to be the
14114 label name, so that the error can be reported accuratly in
14115 patch_bc_statement. */
14116 label_block_expr = EXPR_WFL_NODE (name);
14117 }
14118 /* Unlabeled break/continue will be handled during the
14119 break/continue patch operation */
14120 break_continue
14121 = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
14122
14123 IS_BREAK_STMT_P (break_continue) = is_break;
14124 TREE_SIDE_EFFECTS (break_continue) = 1;
14125 EXPR_WFL_LINECOL (break_continue) = location;
b67d701b 14126 break_continue = build_debugable_stmt (location, break_continue);
e04a16fb
AG		 14127 return break_continue;
14128}
14129
14130/* Verification of a break/continue statement. */
14131
14132static tree
14133patch_bc_statement (node)
14134 tree node;
14135{
14136 tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
b635eb2f 14137 tree labeled_block = ctxp->current_labeled_block;
b67d701b 14138 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
e04a16fb 14139
e04a16fb 14140 /* Having an identifier here means that the target is unknown. */
b635eb2f 14141 if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
e04a16fb
AG		 14142 {
14143 parse_error_context (wfl_operator, "No label definition found for `%s'",
14144 IDENTIFIER_POINTER (bc_label));
14145 return error_mark_node;
14146 }
b635eb2f 14147 if (! IS_BREAK_STMT_P (node))
e04a16fb 14148 {
b635eb2f
PB		 14149 /* It's a continue statement. */
14150 for (;; labeled_block = TREE_CHAIN (labeled_block))
e04a16fb 14151 {
b635eb2f
PB		 14152 if (labeled_block == NULL_TREE)
14153 {
14154 if (bc_label == NULL_TREE)
14155 parse_error_context (wfl_operator,
14156 "`continue' must be in loop");
14157 else
1504b2b4
APB		 14158 parse_error_context
14159 (wfl_operator, "continue label `%s' does not name a loop",
14160 IDENTIFIER_POINTER (bc_label));
b635eb2f
PB		 14161 return error_mark_node;
14162 }
14163 if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
14164 == continue_identifier_node)
14165 && (bc_label == NULL_TREE
14166 || TREE_CHAIN (labeled_block) == bc_label))
14167 {
14168 bc_label = labeled_block;
14169 break;
14170 }
e04a16fb 14171 }
e04a16fb 14172 }
b635eb2f 14173 else if (!bc_label)
34f4db93 14174 {
b635eb2f 14175 for (;; labeled_block = TREE_CHAIN (labeled_block))
e04a16fb 14176 {
b635eb2f
PB		 14177 if (labeled_block == NULL_TREE)
14178 {
14179 parse_error_context (wfl_operator,
14180 "`break' must be in loop or switch");
14181 return error_mark_node;
14182 }
14183 target_stmt = LABELED_BLOCK_BODY (labeled_block);
14184 if (TREE_CODE (target_stmt) == SWITCH_EXPR
5cbdba64 14185 || search_loop (target_stmt))
b635eb2f
PB		 14186 {
14187 bc_label = labeled_block;
14188 break;
14189 }
e04a16fb 14190 }
e04a16fb
AG		 14191 }
14192
b635eb2f 14193 EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15fdcfe9
PB		 14194 CAN_COMPLETE_NORMALLY (bc_label) = 1;
14195
e04a16fb
AG		 14196 /* Our break/continue don't return values. */
14197 TREE_TYPE (node) = void_type_node;
14198 /* Encapsulate the break within a compound statement so that it's
5cbdba64 14199 expanded all the times by expand_expr (and not clobbered
e04a16fb
AG		 14200 sometimes, like after a if statement) */
14201 node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
14202 TREE_SIDE_EFFECTS (node) = 1;
14203 return node;
14204}
14205
14206/* Process the exit expression belonging to a loop. Its type must be
14207 boolean. */
14208
14209static tree
14210patch_exit_expr (node)
14211 tree node;
14212{
14213 tree expression = TREE_OPERAND (node, 0);
14214 TREE_TYPE (node) = error_mark_node;
14215 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14216
14217 /* The type of expression must be boolean */
14218 if (TREE_TYPE (expression) != boolean_type_node)
14219 {
14220 parse_error_context
14221 (wfl_operator,
781b0558 14222 "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
0a2138e2 14223 lang_printable_name (TREE_TYPE (expression), 0));
e04a16fb
AG		 14224 return error_mark_node;
14225 }
14226 /* Now we know things are allright, invert the condition, fold and
14227 return */
14228 TREE_OPERAND (node, 0) =
14229 fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15fdcfe9
PB		 14230
14231 if (! integer_zerop (TREE_OPERAND (node, 0))
14232 && ctxp->current_loop != NULL_TREE
14233 && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
14234 CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
14235 if (! integer_onep (TREE_OPERAND (node, 0)))
14236 CAN_COMPLETE_NORMALLY (node) = 1;
14237
14238
e04a16fb
AG		 14239 TREE_TYPE (node) = void_type_node;
14240 return node;
14241}
b67d701b
PB		 14242
14243/* 14.9 Switch statement */
14244
14245static tree
14246patch_switch_statement (node)
14247 tree node;
14248{
c877974e 14249 tree se = TREE_OPERAND (node, 0), se_type;
b67d701b
PB		 14250
14251 /* Complete the switch expression */
14252 se = TREE_OPERAND (node, 0) = java_complete_tree (se);
14253 se_type = TREE_TYPE (se);
14254 /* The type of the switch expression must be char, byte, short or
14255 int */
14256 if (!JINTEGRAL_TYPE_P (se_type))
14257 {
14258 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
781b0558
KG		 14259 parse_error_context (wfl_operator,
14260 "Incompatible type for `switch'. Can't convert `%s' to `int'",
0a2138e2 14261 lang_printable_name (se_type, 0));
b67d701b
PB		 14262 /* This is what java_complete_tree will check */
14263 TREE_OPERAND (node, 0) = error_mark_node;
14264 return error_mark_node;
14265 }
14266
15fdcfe9 14267 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
b67d701b
PB		 14268
14269 /* Ready to return */
15fdcfe9 14270 if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
b67d701b
PB		 14271 {
14272 TREE_TYPE (node) = error_mark_node;
14273 return error_mark_node;
14274 }
14275 TREE_TYPE (node) = void_type_node;
14276 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9 14277 CAN_COMPLETE_NORMALLY (node)
c877974e
APB		 14278 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14279 || ! SWITCH_HAS_DEFAULT (node);
b67d701b
PB		 14280 return node;
14281}
14282
165f37bc 14283/* 14.18 The try/catch statements */
b67d701b 14284
b67d701b 14285static tree
a7d8d81f 14286build_try_statement (location, try_block, catches)
b67d701b 14287 int location;
a7d8d81f
PB		 14288 tree try_block, catches;
14289{
14290 tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
b67d701b 14291 EXPR_WFL_LINECOL (node) = location;
a7d8d81f 14292 return node;
b67d701b
PB		 14293}
14294
a7d8d81f
PB		 14295static tree
14296build_try_finally_statement (location, try_block, finally)
14297 int location;
14298 tree try_block, finally;
b67d701b 14299{
a7d8d81f
PB		 14300 tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
14301 EXPR_WFL_LINECOL (node) = location;
14302 return node;
b67d701b
PB		 14303}
14304
14305static tree
14306patch_try_statement (node)
14307 tree node;
14308{
14309 int error_found = 0;
14310 tree try = TREE_OPERAND (node, 0);
14311 /* Exception handlers are considered in left to right order */
14312 tree catch = nreverse (TREE_OPERAND (node, 1));
b9f7e36c 14313 tree current, caught_type_list = NULL_TREE;
b67d701b
PB		 14314
14315 /* Check catch clauses, if any. Every time we find an error, we try
b9f7e36c
APB		 14316 to process the next catch clause. We process the catch clause before
14317 the try block so that when processing the try block we can check thrown
14318 exceptions againts the caught type list. */
b67d701b
PB		 14319 for (current = catch; current; current = TREE_CHAIN (current))
14320 {
14321 tree carg_decl, carg_type;
14322 tree sub_current, catch_block, catch_clause;
14323 int unreachable;
14324
b67d701b 14325 /* At this point, the structure of the catch clause is
b67d701b
PB		 14326 CATCH_EXPR (catch node)
14327 BLOCK (with the decl of the parameter)
14328 COMPOUND_EXPR
7525cc04 14329 MODIFY_EXPR (assignment of the catch parameter)
b67d701b 14330 BLOCK (catch clause block)
a7d8d81f
PB		 14331 */
14332 catch_clause = TREE_OPERAND (current, 0);
b67d701b
PB		 14333 carg_decl = BLOCK_EXPR_DECLS (catch_clause);
14334 carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
14335
14336 /* Catch clauses can't have more than one parameter declared,
14337 but it's already enforced by the grammar. Make sure that the
14338 only parameter of the clause statement in of class Throwable
14339 or a subclass of Throwable, but that was done earlier. The
14340 catch clause parameter type has also been resolved. */
14341
14342 /* Just make sure that the catch clause parameter type inherits
14343 from java.lang.Throwable */
14344 if (!inherits_from_p (carg_type, throwable_type_node))
14345 {
14346 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
14347 parse_error_context (wfl_operator,
781b0558 14348 "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
0a2138e2 14349 lang_printable_name (carg_type, 0));
b67d701b
PB		 14350 error_found = 1;
14351 continue;
14352 }
14353
14354 /* Partial check for unreachable catch statement: The catch
14355 clause is reachable iff is no earlier catch block A in
14356 the try statement such that the type of the catch
14357 clause's parameter is the same as or a subclass of the
14358 type of A's parameter */
14359 unreachable = 0;
14360 for (sub_current = catch;
14361 sub_current != current; sub_current = TREE_CHAIN (sub_current))
14362 {
14363 tree sub_catch_clause, decl;
a7d8d81f 14364 sub_catch_clause = TREE_OPERAND (sub_current, 0);
b67d701b
PB		 14365 decl = BLOCK_EXPR_DECLS (sub_catch_clause);
14366
14367 if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
14368 {
14369 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
14370 parse_error_context
781b0558
KG		 14371 (wfl_operator,
14372 "`catch' not reached because of the catch clause at line %d",
14373 EXPR_WFL_LINENO (sub_current));
b67d701b
PB		 14374 unreachable = error_found = 1;
14375 break;
14376 }
14377 }
b67d701b
PB		 14378 /* Complete the catch clause block */
14379 catch_block = java_complete_tree (TREE_OPERAND (current, 0));
14380 if (catch_block == error_mark_node)
14381 {
14382 error_found = 1;
14383 continue;
14384 }
15fdcfe9
PB		 14385 if (CAN_COMPLETE_NORMALLY (catch_block))
14386 CAN_COMPLETE_NORMALLY (node) = 1;
b67d701b 14387 TREE_OPERAND (current, 0) = catch_block;
15fdcfe9
PB		 14388
14389 if (unreachable)
14390 continue;
14391
14392 /* Things to do here: the exception must be thrown */
14393
14394 /* Link this type to the caught type list */
14395 caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
b67d701b
PB		 14396 }
14397
b9f7e36c
APB		 14398 PUSH_EXCEPTIONS (caught_type_list);
14399 if ((try = java_complete_tree (try)) == error_mark_node)
14400 error_found = 1;
15fdcfe9
PB		 14401 if (CAN_COMPLETE_NORMALLY (try))
14402 CAN_COMPLETE_NORMALLY (node) = 1;
b9f7e36c
APB		 14403 POP_EXCEPTIONS ();
14404
b67d701b
PB		 14405 /* Verification ends here */
14406 if (error_found)
14407 return error_mark_node;
14408
14409 TREE_OPERAND (node, 0) = try;
14410 TREE_OPERAND (node, 1) = catch;
b67d701b
PB		 14411 TREE_TYPE (node) = void_type_node;
14412 return node;
14413}
b9f7e36c
APB		 14414
14415/* 14.17 The synchronized Statement */
14416
14417static tree
14418patch_synchronized_statement (node, wfl_op1)
14419 tree node, wfl_op1;
14420{
5a005d9e 14421 tree expr = java_complete_tree (TREE_OPERAND (node, 0));
b9f7e36c 14422 tree block = TREE_OPERAND (node, 1);
5a005d9e 14423
d8fccff5 14424 tree enter, exit, expr_decl, assignment;
5a005d9e
PB		 14425
14426 if (expr == error_mark_node)
14427 {
14428 block = java_complete_tree (block);
14429 return expr;
14430 }
b9f7e36c
APB		 14431
14432 /* The TYPE of expr must be a reference type */
5a005d9e 14433 if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
b9f7e36c
APB		 14434 {
14435 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
781b0558 14436 parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
0a2138e2 14437 lang_printable_name (TREE_TYPE (expr), 0));
b9f7e36c
APB		 14438 return error_mark_node;
14439 }
14440
ce6e9147
APB		 14441 if (flag_emit_xref)
14442 {
14443 TREE_OPERAND (node, 0) = expr;
14444 TREE_OPERAND (node, 1) = java_complete_tree (block);
14445 CAN_COMPLETE_NORMALLY (node) = 1;
14446 return node;
14447 }
14448
b9f7e36c
APB		 14449 /* Generate a try-finally for the synchronized statement, except
14450 that the handler that catches all throw exception calls
14451 _Jv_MonitorExit and then rethrow the exception.
14452 The synchronized statement is then implemented as:
14453 TRY
14454 {
14455 _Jv_MonitorEnter (expression)
14456 synchronized_block
14457 _Jv_MonitorExit (expression)
14458 }
14459 CATCH_ALL
14460 {
14461 e = _Jv_exception_info ();
14462 _Jv_MonitorExit (expression)
14463 Throw (e);
14464 } */
14465
5a005d9e
PB		 14466 expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
14467 BUILD_MONITOR_ENTER (enter, expr_decl);
14468 BUILD_MONITOR_EXIT (exit, expr_decl);
14469 CAN_COMPLETE_NORMALLY (enter) = 1;
14470 CAN_COMPLETE_NORMALLY (exit) = 1;
96847892
AH		 14471 assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
14472 TREE_SIDE_EFFECTS (assignment) = 1;
5a005d9e
PB		 14473 node = build1 (CLEANUP_POINT_EXPR, NULL_TREE,
14474 build (COMPOUND_EXPR, NULL_TREE,
14475 build (WITH_CLEANUP_EXPR, NULL_TREE,
14476 build (COMPOUND_EXPR, NULL_TREE,
96847892 14477 assignment, enter),
5a005d9e
PB		 14478 NULL_TREE, exit),
14479 block));
14480 node = build_expr_block (node, expr_decl);
14481
14482 return java_complete_tree (node);
b9f7e36c
APB		 14483}
14484
14485/* 14.16 The throw Statement */
14486
14487static tree
14488patch_throw_statement (node, wfl_op1)
14489 tree node, wfl_op1;
14490{
14491 tree expr = TREE_OPERAND (node, 0);
14492 tree type = TREE_TYPE (expr);
14493 int unchecked_ok = 0, tryblock_throws_ok = 0;
14494
14495 /* Thrown expression must be assignable to java.lang.Throwable */
14496 if (!try_reference_assignconv (throwable_type_node, expr))
14497 {
14498 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
781b0558
KG		 14499 parse_error_context (wfl_operator,
14500 "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
0a2138e2 14501 lang_printable_name (type, 0));
b9f7e36c
APB		 14502 /* If the thrown expression was a reference, we further the
14503 compile-time check. */
14504 if (!JREFERENCE_TYPE_P (type))
14505 return error_mark_node;
14506 }
14507
14508 /* At least one of the following must be true */
14509
14510 /* The type of the throw expression is a not checked exception,
14511 i.e. is a unchecked expression. */
c877974e 14512 unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
b9f7e36c 14513
c2952b01
APB		 14514 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
14515 /* An instance can't throw a checked excetion unless that exception
14516 is explicitely declared in the `throws' clause of each
14517 constructor. This doesn't apply to anonymous classes, since they
14518 don't have declared constructors. */
14519 if (!unchecked_ok
14520 && in_instance_initializer && !ANONYMOUS_CLASS_P (current_class))
14521 {
14522 tree current;
14523 for (current = TYPE_METHODS (current_class); current;
14524 current = TREE_CHAIN (current))
14525 if (DECL_CONSTRUCTOR_P (current)
14526 && !check_thrown_exceptions_do (TREE_TYPE (expr)))
14527 {
14528 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)",
14529 lang_printable_name (TREE_TYPE (expr), 0));
14530 return error_mark_node;
14531 }
14532 }
14533
b9f7e36c
APB		 14534 /* Throw is contained in a try statement and at least one catch
14535 clause can receive the thrown expression or the current method is
14536 declared to throw such an exception. Or, the throw statement is
14537 contained in a method or constructor declaration and the type of
14538 the Expression is assignable to at least one type listed in the
14539 throws clause the declaration. */
b9f7e36c 14540 if (!unchecked_ok)
f099f336 14541 tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
b9f7e36c
APB		 14542 if (!(unchecked_ok || tryblock_throws_ok))
14543 {
14544 /* If there is a surrounding try block that has no matching
14545 clatch clause, report it first. A surrounding try block exits
14546 only if there is something after the list of checked
14547 exception thrown by the current function (if any). */
14548 if (IN_TRY_BLOCK_P ())
781b0558 14549 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 14550 lang_printable_name (type, 0));
b9f7e36c
APB		 14551 /* If we have no surrounding try statement and the method doesn't have
14552 any throws, report it now. FIXME */
f099f336
APB		 14553
14554 /* We report that the exception can't be throw from a try block
14555 in all circumstances but when the `throw' is inside a static
14556 block. */
b9f7e36c
APB		 14557 else if (!EXCEPTIONS_P (currently_caught_type_list)
14558 && !tryblock_throws_ok)
f099f336 14559 {
c2952b01 14560 if (DECL_CLINIT_P (current_function_decl))
781b0558
KG		 14561 parse_error_context (wfl_operator,
14562 "Checked exception `%s' can't be thrown in initializer",
f099f336
APB		 14563 lang_printable_name (type, 0));
14564 else
781b0558
KG		 14565 parse_error_context (wfl_operator,
14566 "Checked exception `%s' isn't thrown from a `try' block",
f099f336
APB		 14567 lang_printable_name (type, 0));
14568 }
b9f7e36c
APB		 14569 /* Otherwise, the current method doesn't have the appropriate
14570 throws declaration */
14571 else
781b0558 14572 parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
0a2138e2 14573 lang_printable_name (type, 0));
b9f7e36c
APB		 14574 return error_mark_node;
14575 }
14576
ce6e9147 14577 if (! flag_emit_class_files && ! flag_emit_xref)
15fdcfe9 14578 BUILD_THROW (node, expr);
ce6e9147
APB		 14579
14580 /* If doing xrefs, keep the location where the `throw' was seen. */
14581 if (flag_emit_xref)
14582 EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
b9f7e36c
APB		 14583 return node;
14584}
14585
14586/* Check that exception said to be thrown by method DECL can be
14587 effectively caught from where DECL is invoked. */
14588
14589static void
14590check_thrown_exceptions (location, decl)
14591 int location;
14592 tree decl;
14593{
14594 tree throws;
14595 /* For all the unchecked exceptions thrown by DECL */
14596 for (throws = DECL_FUNCTION_THROWS (decl); throws;
14597 throws = TREE_CHAIN (throws))
0a2138e2 14598 if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
b9f7e36c 14599 {
3e78f871
PB		 14600#if 1
14601 /* Temporary hack to suppresses errors about cloning arrays. FIXME */
14602 if (DECL_NAME (decl) == get_identifier ("clone"))
14603 continue;
14604#endif
b9f7e36c 14605 EXPR_WFL_LINECOL (wfl_operator) = location;
c2952b01 14606 if (DECL_FINIT_P (current_function_decl))
7705e9db
APB		 14607 parse_error_context
14608 (wfl_operator, "Exception `%s' can't be thrown in initializer",
14609 lang_printable_name (TREE_VALUE (throws), 0));
14610 else
14611 {
14612 parse_error_context
781b0558 14613 (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
7705e9db 14614 lang_printable_name (TREE_VALUE (throws), 0),
c2952b01 14615 (DECL_INIT_P (current_function_decl) ?
7705e9db
APB		 14616 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
14617 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
14618 }
b9f7e36c
APB		 14619 }
14620}
14621
c877974e 14622/* Return 1 if checked EXCEPTION is caught at the current nesting level of
b9f7e36c
APB		 14623 try-catch blocks, OR is listed in the `throws' clause of the
14624 current method. */
14625
14626static int
0a2138e2 14627check_thrown_exceptions_do (exception)
b9f7e36c
APB		 14628 tree exception;
14629{
14630 tree list = currently_caught_type_list;
c877974e 14631 resolve_and_layout (exception, NULL_TREE);
b9f7e36c
APB		 14632 /* First, all the nested try-catch-finally at that stage. The
14633 last element contains `throws' clause exceptions, if any. */
c877974e
APB		 14634 if (IS_UNCHECKED_EXCEPTION_P (exception))
14635 return 1;
b9f7e36c
APB		 14636 while (list)
14637 {
14638 tree caught;
14639 for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
14640 if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
14641 return 1;
14642 list = TREE_CHAIN (list);
14643 }
14644 return 0;
14645}
14646
14647static void
14648purge_unchecked_exceptions (mdecl)
14649 tree mdecl;
14650{
14651 tree throws = DECL_FUNCTION_THROWS (mdecl);
14652 tree new = NULL_TREE;
14653
14654 while (throws)
14655 {
14656 tree next = TREE_CHAIN (throws);
c877974e 14657 if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
b9f7e36c
APB		 14658 {
14659 TREE_CHAIN (throws) = new;
14660 new = throws;
14661 }
14662 throws = next;
14663 }
14664 /* List is inverted here, but it doesn't matter */
14665 DECL_FUNCTION_THROWS (mdecl) = new;
14666}
22eed1e6
APB		 14667
14668/* 15.24 Conditional Operator ?: */
14669
14670static tree
14671patch_conditional_expr (node, wfl_cond, wfl_op1)
14672 tree node, wfl_cond, wfl_op1;
14673{
14674 tree cond = TREE_OPERAND (node, 0);
14675 tree op1 = TREE_OPERAND (node, 1);
14676 tree op2 = TREE_OPERAND (node, 2);
22eed1e6 14677 tree resulting_type = NULL_TREE;
ac825856 14678 tree t1, t2, patched;
22eed1e6
APB		 14679 int error_found = 0;
14680
ac825856
APB		 14681 /* Operands of ?: might be StringBuffers crafted as a result of a
14682 string concatenation. Obtain a descent operand here. */
14683 if ((patched = patch_string (op1)))
14684 TREE_OPERAND (node, 1) = op1 = patched;
14685 if ((patched = patch_string (op2)))
14686 TREE_OPERAND (node, 2) = op2 = patched;
14687
14688 t1 = TREE_TYPE (op1);
14689 t2 = TREE_TYPE (op2);
14690
22eed1e6
APB		 14691 /* The first expression must be a boolean */
14692 if (TREE_TYPE (cond) != boolean_type_node)
14693 {
14694 SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
781b0558
KG		 14695 parse_error_context (wfl_operator,
14696 "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
22eed1e6
APB		 14697 lang_printable_name (TREE_TYPE (cond), 0));
14698 error_found = 1;
14699 }
14700
14701 /* Second and third can be numeric, boolean (i.e. primitive),
14702 references or null. Anything else results in an error */
14703 if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
14704 || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
14705 && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
14706 || (t1 == boolean_type_node && t2 == boolean_type_node)))
14707 error_found = 1;
14708
14709 /* Determine the type of the conditional expression. Same types are
14710 easy to deal with */
14711 else if (t1 == t2)
14712 resulting_type = t1;
14713
14714 /* There are different rules for numeric types */
14715 else if (JNUMERIC_TYPE_P (t1))
14716 {
14717 /* if byte/short found, the resulting type is short */
14718 if ((t1 == byte_type_node && t2 == short_type_node)
14719 || (t1 == short_type_node && t2 == byte_type_node))
14720 resulting_type = short_type_node;
14721
14722 /* If t1 is a constant int and t2 is of type byte, short or char
14723 and t1's value fits in t2, then the resulting type is t2 */
14724 else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
14725 && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
14726 resulting_type = t2;
14727
14728 /* If t2 is a constant int and t1 is of type byte, short or char
14729 and t2's value fits in t1, then the resulting type is t1 */
14730 else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
14731 && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
14732 resulting_type = t1;
14733
14734 /* Otherwise, binary numeric promotion is applied and the
14735 resulting type is the promoted type of operand 1 and 2 */
14736 else
93024893 14737 resulting_type = binary_numeric_promotion (t1, t2,
22eed1e6
APB		 14738 &TREE_OPERAND (node, 1),
14739 &TREE_OPERAND (node, 2));
14740 }
14741
14742 /* Cases of a reference and a null type */
14743 else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
14744 resulting_type = t1;
14745
14746 else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
14747 resulting_type = t2;
14748
14749 /* Last case: different reference types. If a type can be converted
14750 into the other one by assignment conversion, the latter
14751 determines the type of the expression */
14752 else if ((resulting_type = try_reference_assignconv (t1, op2)))
14753 resulting_type = promote_type (t1);
14754
14755 else if ((resulting_type = try_reference_assignconv (t2, op1)))
14756 resulting_type = promote_type (t2);
14757
14758 /* If we don't have any resulting type, we're in trouble */
14759 if (!resulting_type)
14760 {
c2e3db92 14761 char *t = xstrdup (lang_printable_name (t1, 0));
22eed1e6 14762 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
781b0558
KG		 14763 parse_error_context (wfl_operator,
14764 "Incompatible type for `?:'. Can't convert `%s' to `%s'",
14765 t, lang_printable_name (t2, 0));
22eed1e6
APB		 14766 free (t);
14767 error_found = 1;
14768 }
14769
14770 if (error_found)
14771 {
14772 TREE_TYPE (node) = error_mark_node;
14773 return error_mark_node;
14774 }
14775
14776 TREE_TYPE (node) = resulting_type;
14777 TREE_SET_CODE (node, COND_EXPR);
15fdcfe9 14778 CAN_COMPLETE_NORMALLY (node) = 1;
22eed1e6
APB		 14779 return node;
14780}
ac825856 14781
5b09b33e
PB		 14782/* Try to constant fold NODE.
14783 If NODE is not a constant expression, return NULL_EXPR.
14784 CONTEXT is a static final VAR_DECL whose initializer we are folding. */
14785
14786static tree
14787fold_constant_for_init (node, context)
14788 tree node;
14789 tree context;
14790{
14791 tree op0, op1, val;
14792 enum tree_code code = TREE_CODE (node);
14793
93024893 14794 if (code == STRING_CST)
5b09b33e 14795 return node;
93024893
APB		 14796
14797 if (code == INTEGER_CST || code == REAL_CST)
14798 return convert (TREE_TYPE (context), node);
5b09b33e
PB		 14799
14800 switch (code)
14801 {
5b09b33e
PB		 14802 case PLUS_EXPR:
14803 case MINUS_EXPR:
bc3ca41b
PB		 14804 case MULT_EXPR:
14805 case TRUNC_MOD_EXPR:
14806 case RDIV_EXPR:
5b09b33e
PB		 14807 case LSHIFT_EXPR:
14808 case RSHIFT_EXPR:
14809 case URSHIFT_EXPR:
14810 case BIT_AND_EXPR:
14811 case BIT_XOR_EXPR:
14812 case BIT_IOR_EXPR:
5b09b33e
PB		 14813 case TRUTH_ANDIF_EXPR:
14814 case TRUTH_ORIF_EXPR:
14815 case EQ_EXPR:
14816 case NE_EXPR:
14817 case GT_EXPR:
14818 case GE_EXPR:
14819 case LT_EXPR:
14820 case LE_EXPR:
14821 op0 = TREE_OPERAND (node, 0);
14822 op1 = TREE_OPERAND (node, 1);
14823 val = fold_constant_for_init (op0, context);
14824 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14825 return NULL_TREE;
14826 TREE_OPERAND (node, 0) = val;
14827 val = fold_constant_for_init (op1, context);
14828 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14829 return NULL_TREE;
14830 TREE_OPERAND (node, 1) = val;
14831 return patch_binop (node, op0, op1);
14832
14833 case UNARY_PLUS_EXPR:
14834 case NEGATE_EXPR:
14835 case TRUTH_NOT_EXPR:
14836 case BIT_NOT_EXPR:
14837 case CONVERT_EXPR:
14838 op0 = TREE_OPERAND (node, 0);
14839 val = fold_constant_for_init (op0, context);
14840 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14841 return NULL_TREE;
14842 TREE_OPERAND (node, 0) = val;
5a005d9e 14843 return patch_unaryop (node, op0);
5b09b33e
PB		 14844 break;
14845
14846 case COND_EXPR:
14847 val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
14848 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14849 return NULL_TREE;
14850 TREE_OPERAND (node, 0) = val;
14851 val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
14852 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14853 return NULL_TREE;
14854 TREE_OPERAND (node, 1) = val;
14855 val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
14856 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14857 return NULL_TREE;
14858 TREE_OPERAND (node, 2) = val;
14859 return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
14860 : TREE_OPERAND (node, 2);
14861
14862 case VAR_DECL:
8576f094
APB		 14863 case FIELD_DECL:
14864 if (! FIELD_FINAL (node)
5b09b33e
PB		 14865 || DECL_INITIAL (node) == NULL_TREE)
14866 return NULL_TREE;
14867 val = DECL_INITIAL (node);
14868 /* Guard against infinite recursion. */
14869 DECL_INITIAL (node) = NULL_TREE;
cd9643f7 14870 val = fold_constant_for_init (val, node);
5b09b33e
PB		 14871 DECL_INITIAL (node) = val;
14872 return val;
14873
14874 case EXPR_WITH_FILE_LOCATION:
14875 /* Compare java_complete_tree and resolve_expression_name. */
14876 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
14877 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
14878 {
14879 tree name = EXPR_WFL_NODE (node);
14880 tree decl;
14881 if (PRIMARY_P (node))
14882 return NULL_TREE;
14883 else if (! QUALIFIED_P (name))
14884 {
14885 decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
8576f094
APB		 14886 if (decl == NULL_TREE
14887 || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
5b09b33e
PB		 14888 return NULL_TREE;
14889 return fold_constant_for_init (decl, decl);
14890 }
14891 else
14892 {
5b09b33e
PB		 14893 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
14894 qualify_ambiguous_name (node);
14895 if (resolve_field_access (node, &decl, NULL)
14896 && decl != NULL_TREE)
14897 return fold_constant_for_init (decl, decl);
5b09b33e
PB		 14898 return NULL_TREE;
14899 }
14900 }
14901 else
14902 {
14903 op0 = TREE_OPERAND (node, 0);
14904 val = fold_constant_for_init (op0, context);
14905 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14906 return NULL_TREE;
14907 TREE_OPERAND (node, 0) = val;
14908 return val;
14909 }
14910
bc3ca41b
PB		 14911#ifdef USE_COMPONENT_REF
14912 case IDENTIFIER:
14913 case COMPONENT_REF:
14914 ?;
14915#endif
14916
5b09b33e
PB		 14917 default:
14918 return NULL_TREE;
14919 }
14920}
bc3ca41b
PB		 14921
14922#ifdef USE_COMPONENT_REF
14923/* Context is 'T' for TypeName, 'P' for PackageName,
14924 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
14925
14926tree
14927resolve_simple_name (name, context)
14928 tree name;
14929 int context;
14930{
14931}
14932
14933tree
14934resolve_qualified_name (name, context)
14935 tree name;
14936 int context;
14937{
14938}
14939#endif
GNU Compiler Collection
This page took 2.286142 seconds and 5 git commands to generate.