]> 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
Java: fixes for the PRs gcj/{271,272,275}.
[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));
98a52c2c 84static tree parser_qualified_classname PARAMS ((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);
98a52c2c 3652 tree q_name = parser_qualified_classname (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
98a52c2c 3787 class_id = parser_qualified_classname (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 /* Add the private this$<n> field, Replicate final locals still in
3844 scope as private final fields mangled like val$<local_name>.
3845 This doesn't not occur for top level (static) inner classes. */
3846 if (PURE_INNER_CLASS_DECL_P (decl))
3847 add_inner_class_fields (decl, current_function_decl);
3848
7f10c2e2
APB		 3849 /* If doing xref, store the location at which the inherited class
3850 (if any) was seen. */
3851 if (flag_emit_xref && super)
3852 DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
3853
5e942c50
APB		 3854 /* Eventually sets the @deprecated tag flag */
3855 CHECK_DEPRECATED (decl);
3856
165f37bc
APB		 3857 /* Reset the anonymous class counter when declaring non inner classes */
3858 if (!INNER_CLASS_DECL_P (decl))
c2952b01
APB		 3859 anonymous_class_counter = 1;
3860
e04a16fb
AG		 3861 return decl;
3862}
3863
c2952b01
APB		 3864/* End a class declaration: register the statements used to create
3865 $finit$ and <clinit>, pop the current class and resume the prior
3866 parser context if necessary. */
3867
3868static void
3869end_class_declaration (resume)
3870 int resume;
3871{
3872 /* If an error occured, context weren't pushed and won't need to be
3873 popped by a resume. */
3874 int no_error_occured = ctxp->next && GET_CPC () != error_mark_node;
3875
3876 java_parser_context_pop_initialized_field ();
3877 POP_CPC ();
3878 if (resume && no_error_occured)
3879 java_parser_context_resume ();
93220702
APB		 3880
3881 /* We're ending a class declaration, this is a good time to reset
3882 the interface cout. Note that might have been already done in
3883 create_interface, but if at that time an inner class was being
3884 dealt with, the interface count was reset in a context created
3885 for the sake of handling inner classes declaration. */
3886 ctxp->interface_number = 0;
c2952b01
APB		 3887}
3888
3889static void
3890add_inner_class_fields (class_decl, fct_decl)
3891 tree class_decl;
3892 tree fct_decl;
3893{
3894 tree block, marker, f;
3895
3896 f = add_field (TREE_TYPE (class_decl),
3897 build_current_thisn (TREE_TYPE (class_decl)),
3898 build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
3899 ACC_PRIVATE);
3900 FIELD_THISN (f) = 1;
3901
3902 if (!fct_decl)
3903 return;
3904
3905 for (block = GET_CURRENT_BLOCK (fct_decl);
3906 block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
3907 {
3908 tree decl;
3909 for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
3910 {
3911 char *name, *pname;
3912 tree wfl, init, list;
3913
3914 /* Avoid non final arguments. */
3915 if (!LOCAL_FINAL (decl))
3916 continue;
3917
3918 MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
3919 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
3920 wfl = build_wfl_node (get_identifier (name));
3921 init = build_wfl_node (get_identifier (pname));
3922 /* Build an initialization for the field: it will be
3923 initialized by a parameter added to $finit$, bearing a
3924 mangled name of the field itself (param$<n>.) The
3925 parameter is provided to $finit$ by the constructor
3926 invoking it (hence the constructor will also feature a
3927 hidden parameter, set to the value of the outer context
3928 local at the time the inner class is created.)
3929
3930 Note: we take into account all possible locals that can
3931 be accessed by the inner class. It's actually not trivial
3932 to minimize these aliases down to the ones really
3933 used. One way to do that would be to expand all regular
3934 methods first, then $finit$ to get a picture of what's
3935 used. It works with the exception that we would have to
3936 go back on all constructor invoked in regular methods to
3937 have their invokation reworked (to include the right amount
3938 of alias initializer parameters.)
3939
3940 The only real way around, I think, is a first pass to
3941 identify locals really used in the inner class. We leave
3942 the flag FIELD_LOCAL_ALIAS_USED around for that future
3943 use.
3944
3945 On the other hand, it only affect local inner classes,
3946 whose constructors (and $finit$ call) will be featuring
3947 unecessary arguments. It's easy for a developper to keep
3948 this number of parameter down by using the `final'
3949 keyword only when necessary. For the time being, we can
3950 issue a warning on unecessary finals. FIXME */
3951 init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
3952 wfl, init);
3953
3954 /* Register the field. The TREE_LIST holding the part
3955 initialized/initializer will be marked ARG_FINAL_P so
3956 that the created field can be marked
3957 FIELD_LOCAL_ALIAS. */
3958 list = build_tree_list (wfl, init);
3959 ARG_FINAL_P (list) = 1;
3960 register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
3961 }
3962 }
3963
3964 if (!CPC_INITIALIZER_STMT (ctxp))
3965 return;
3966
3967 /* If we ever registered an alias field, insert and marker to
3968 remeber where the list ends. The second part of the list (the one
3969 featuring initialized fields) so it can be later reversed to
3970 enforce 8.5. The marker will be removed during that operation. */
3971 marker = build_tree_list (NULL_TREE, NULL_TREE);
3972 TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
3973 SET_CPC_INITIALIZER_STMT (ctxp, marker);
3974}
3975
e04a16fb
AG		 3976/* Can't use lookup_field () since we don't want to load the class and
3977 can't set the CLASS_LOADED_P flag */
3978
3979static tree
3980find_field (class, name)
3981 tree class;
3982 tree name;
3983{
3984 tree decl;
3985 for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
3986 {
3987 if (DECL_NAME (decl) == name)
3988 return decl;
3989 }
3990 return NULL_TREE;
3991}
3992
3993/* Wrap around lookup_field that doesn't potentially upset the value
3994 of CLASS */
3995
3996static tree
3997lookup_field_wrapper (class, name)
3998 tree class, name;
3999{
4000 tree type = class;
9a7ab4b3 4001 tree decl = NULL_TREE;
c877974e 4002 java_parser_context_save_global ();
f2760b27
APB		 4003
4004 /* Last chance: if we're within the context of an inner class, we
4005 might be trying to access a local variable defined in an outer
4006 context. We try to look for it now. */
9a7ab4b3 4007 if (INNER_CLASS_TYPE_P (class))
f2760b27
APB		 4008 {
4009 char *alias_buffer;
9a7ab4b3 4010 tree new_name;
f2760b27 4011 MANGLE_OUTER_LOCAL_VARIABLE_NAME (alias_buffer, name);
9a7ab4b3
APB		 4012 new_name = get_identifier (alias_buffer);
4013 decl = lookup_field (&type, new_name);
f2760b27
APB		 4014 if (decl && decl != error_mark_node)
4015 FIELD_LOCAL_ALIAS_USED (decl) = 1;
4016 }
9a7ab4b3
APB		 4017 if (!decl || decl == error_mark_node)
4018 {
4019 type = class;
4020 decl = lookup_field (&type, name);
4021 }
f2760b27 4022
c877974e 4023 java_parser_context_restore_global ();
93024893 4024 return decl == error_mark_node ? NULL : decl;
e04a16fb
AG		 4025}
4026
4027/* Find duplicate field within the same class declarations and report
c583dd46
APB		 4028 the error. Returns 1 if a duplicated field was found, 0
4029 otherwise. */
e04a16fb
AG		 4030
4031static int
c583dd46 4032duplicate_declaration_error_p (new_field_name, new_type, cl)
0a2138e2 4033 tree new_field_name, new_type, cl;
e04a16fb
AG		 4034{
4035 /* This might be modified to work with method decl as well */
c2952b01 4036 tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
e04a16fb
AG		 4037 if (decl)
4038 {
c2e3db92 4039 char *t1 = xstrdup (purify_type_name
4a5f66c3
APB		 4040 ((TREE_CODE (new_type) == POINTER_TYPE
4041 && TREE_TYPE (new_type) == NULL_TREE) ?
4042 IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4043 lang_printable_name (new_type, 1)));
c877974e
APB		 4044 /* The type may not have been completed by the time we report
4045 the error */
c2e3db92 4046 char *t2 = xstrdup (purify_type_name
4a5f66c3 4047 ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
c877974e
APB		 4048 && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4049 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4050 lang_printable_name (TREE_TYPE (decl), 1)));
e04a16fb
AG		 4051 parse_error_context
4052 (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4053 t1, IDENTIFIER_POINTER (new_field_name),
4054 t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4055 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4056 free (t1);
4057 free (t2);
c583dd46 4058 return 1;
e04a16fb 4059 }
c583dd46 4060 return 0;
e04a16fb
AG		 4061}
4062
4063/* Field registration routine. If TYPE doesn't exist, field
4064 declarations are linked to the undefined TYPE dependency list, to
4065 be later resolved in java_complete_class () */
4066
4067static void
4068register_fields (flags, type, variable_list)
4069 int flags;
4070 tree type, variable_list;
4071{
c583dd46 4072 tree current, saved_type;
c2952b01 4073 tree class_type = NULL_TREE;
e04a16fb
AG		 4074 int saved_lineno = lineno;
4075 int must_chain = 0;
4076 tree wfl = NULL_TREE;
4077
c2952b01
APB		 4078 if (GET_CPC ())
4079 class_type = TREE_TYPE (GET_CPC ());
4080
4081 if (!class_type || class_type == error_mark_node)
4082 return;
4083
e04a16fb
AG		 4084 /* If we're adding fields to interfaces, those fields are public,
4085 static, final */
4086 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4087 {
4088 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
2884c41e 4089 flags, ACC_PUBLIC, "interface field(s)");
e04a16fb 4090 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
2884c41e 4091 flags, ACC_STATIC, "interface field(s)");
e04a16fb 4092 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
2884c41e 4093 flags, ACC_FINAL, "interface field(s)");
e04a16fb
AG		 4094 check_modifiers ("Illegal interface member modifier `%s'", flags,
4095 INTERFACE_FIELD_MODIFIERS);
4096 flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4097 }
4098
c583dd46
APB		 4099 /* Obtain a suitable type for resolution, if necessary */
4100 SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4101
4102 /* If TYPE is fully resolved and we don't have a reference, make one */
1886c9d8 4103 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
e04a16fb 4104
c583dd46
APB		 4105 for (current = variable_list, saved_type = type; current;
4106 current = TREE_CHAIN (current), type = saved_type)
e04a16fb 4107 {
c877974e 4108 tree real_type;
c583dd46 4109 tree field_decl;
e04a16fb
AG		 4110 tree cl = TREE_PURPOSE (current);
4111 tree init = TREE_VALUE (current);
4112 tree current_name = EXPR_WFL_NODE (cl);
4113
cf1748bf 4114 /* Can't declare non-final static fields in inner classes */
c2952b01 4115 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
cf1748bf 4116 && !(flags & ACC_FINAL))
c2952b01 4117 parse_error_context
cf1748bf 4118 (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
c2952b01
APB		 4119 IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4120 lang_printable_name (class_type, 0));
4121
c583dd46
APB		 4122 /* Process NAME, as it may specify extra dimension(s) for it */
4123 type = build_array_from_name (type, wfl, current_name, &current_name);
4124
c583dd46
APB		 4125 /* Type adjustment. We may have just readjusted TYPE because
4126 the variable specified more dimensions. Make sure we have
22eed1e6
APB		 4127 a reference if we can and don't have one already. Also
4128 change the name if we have an init. */
4129 if (type != saved_type)
4130 {
1886c9d8 4131 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
22eed1e6
APB		 4132 if (init)
4133 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4134 }
e04a16fb 4135
c877974e
APB		 4136 real_type = GET_REAL_TYPE (type);
4137 /* Check for redeclarations */
4138 if (duplicate_declaration_error_p (current_name, real_type, cl))
4139 continue;
4140
c583dd46 4141 /* Set lineno to the line the field was found and create a
5e942c50 4142 declaration for it. Eventually sets the @deprecated tag flag. */
f099f336
APB		 4143 if (flag_emit_xref)
4144 lineno = EXPR_WFL_LINECOL (cl);
4145 else
4146 lineno = EXPR_WFL_LINENO (cl);
c877974e 4147 field_decl = add_field (class_type, current_name, real_type, flags);
5e942c50 4148 CHECK_DEPRECATED (field_decl);
c2952b01
APB		 4149
4150 /* If the couple initializer/initialized is marked ARG_FINAL_P, we
4151 mark the created field FIELD_LOCAL_ALIAS, so that we can
4152 hide parameters to this inner class $finit$ and constructors. */
4153 if (ARG_FINAL_P (current))
4154 FIELD_LOCAL_ALIAS (field_decl) = 1;
c583dd46
APB		 4155
4156 /* Check if we must chain. */
4157 if (must_chain)
4158 register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
e04a16fb 4159
c583dd46
APB		 4160 /* If we have an initialization value tied to the field */
4161 if (init)
4162 {
4163 /* The field is declared static */
e04a16fb 4164 if (flags & ACC_STATIC)
e04a16fb 4165 {
7525cc04
APB		 4166 /* We include the field and its initialization part into
4167 a list used to generate <clinit>. After <clinit> is
ba179f9f
APB		 4168 walked, field initializations will be processed and
4169 fields initialized with known constants will be taken
4170 out of <clinit> and have their DECL_INITIAL set
7525cc04 4171 appropriately. */
c2952b01
APB		 4172 TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4173 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
7f10c2e2
APB		 4174 if (TREE_OPERAND (init, 1)
4175 && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
5bba4807 4176 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
e04a16fb 4177 }
5e942c50
APB		 4178 /* A non-static field declared with an immediate initialization is
4179 to be initialized in <init>, if any. This field is remembered
4180 to be processed at the time of the generation of <init>. */
c583dd46
APB		 4181 else
4182 {
c2952b01
APB		 4183 TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4184 SET_CPC_INITIALIZER_STMT (ctxp, init);
c583dd46 4185 }
5b09b33e 4186 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
8576f094 4187 DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
e04a16fb
AG		 4188 }
4189 }
4190 lineno = saved_lineno;
4191}
4192
c2952b01
APB		 4193/* Generate $finit$, using the list of initialized fields to populate
4194 its body. $finit$'s parameter(s) list is adjusted to include the
4195 one(s) used to initialized the field(s) caching outer context
4196 local(s). */
22eed1e6 4197
c2952b01
APB		 4198static tree
4199generate_finit (class_type)
4200 tree class_type;
22eed1e6 4201{
c2952b01
APB		 4202 int count = 0;
4203 tree list = TYPE_FINIT_STMT_LIST (class_type);
4204 tree mdecl, current, parms;
4205
4206 parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4207 class_type, NULL_TREE,
4208 &count);
4209 CRAFTED_PARAM_LIST_FIXUP (parms);
4210 mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4211 finit_identifier_node, parms);
4212 fix_method_argument_names (parms, mdecl);
4213 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4214 mdecl, NULL_TREE);
4215 DECL_FUNCTION_NAP (mdecl) = count;
22eed1e6
APB		 4216 start_artificial_method_body (mdecl);
4217
c2952b01 4218 for (current = list; current; current = TREE_CHAIN (current))
22eed1e6
APB		 4219 java_method_add_stmt (mdecl,
4220 build_debugable_stmt (EXPR_WFL_LINECOL (current),
4221 current));
22eed1e6 4222 end_artificial_method_body (mdecl);
c2952b01 4223 return mdecl;
22eed1e6
APB		 4224}
4225
e04a16fb 4226static void
c2952b01
APB		 4227add_instance_initializer (mdecl)
4228 tree mdecl;
e04a16fb 4229{
c2952b01
APB		 4230 tree current;
4231 tree stmt_list = TYPE_II_STMT_LIST (DECL_CONTEXT (mdecl));
4232 tree compound = NULL_TREE;
e04a16fb 4233
c2952b01 4234 if (stmt_list)
e04a16fb 4235 {
c2952b01
APB		 4236 for (current = stmt_list; current; current = TREE_CHAIN (current))
4237 compound = add_stmt_to_compound (compound, NULL_TREE, current);
e04a16fb 4238
c2952b01
APB		 4239 java_method_add_stmt (mdecl, build1 (INSTANCE_INITIALIZERS_EXPR,
4240 NULL_TREE, compound));
4241 }
e04a16fb
AG		 4242}
4243
4244/* Shared accros method_declarator and method_header to remember the
4245 patch stage that was reached during the declaration of the method.
4246 A method DECL is built differently is there is no patch
4247 (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4248 pending on the currently defined method. */
4249
4250static int patch_stage;
4251
4252/* Check the method declaration and add the method to its current
4253 class. If the argument list is known to contain incomplete types,
4254 the method is partially added and the registration will be resume
22eed1e6
APB		 4255 once the method arguments resolved. If TYPE is NULL, we're dealing
4256 with a constructor. */
e04a16fb
AG		 4257
4258static tree
4259method_header (flags, type, mdecl, throws)
4260 int flags;
4261 tree type, mdecl, throws;
4262{
4263 tree meth = TREE_VALUE (mdecl);
4264 tree id = TREE_PURPOSE (mdecl);
1886c9d8 4265 tree type_wfl = NULL_TREE;
79d13333 4266 tree meth_name = NULL_TREE;
c2952b01 4267 tree current, orig_arg, this_class = NULL;
e04a16fb 4268 int saved_lineno;
1886c9d8 4269 int constructor_ok = 0, must_chain;
c2952b01 4270 int count;
e04a16fb
AG		 4271
4272 check_modifiers_consistency (flags);
79d13333 4273
c2952b01
APB		 4274 if (GET_CPC ())
4275 this_class = TREE_TYPE (GET_CPC ());
4276
4277 if (!this_class || this_class == error_mark_node)
79d13333 4278 return NULL_TREE;
e04a16fb
AG		 4279
4280 /* There are some forbidden modifiers for an abstract method and its
4281 class must be abstract as well. */
22eed1e6 4282 if (type && (flags & ACC_ABSTRACT))
e04a16fb
AG		 4283 {
4284 ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4285 ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4286 ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4287 ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4288 ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED,id, "Synchronized");
2aa11e97
APB		 4289 if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4290 && !CLASS_INTERFACE (TYPE_NAME (this_class)))
e04a16fb 4291 parse_error_context
781b0558 4292 (id, "Class `%s' must be declared abstract to define abstract method `%s'",
e04a16fb
AG		 4293 IDENTIFIER_POINTER (DECL_NAME (ctxp->current_parsed_class)),
4294 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4295 }
c2952b01 4296
22eed1e6
APB		 4297 /* Things to be checked when declaring a constructor */
4298 if (!type)
4299 {
4300 int ec = java_error_count;
4301 /* 8.6: Constructor declarations: we might be trying to define a
4302 method without specifying a return type. */
c2952b01 4303 if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
22eed1e6
APB		 4304 parse_error_context
4305 (id, "Invalid method declaration, return type required");
4306 /* 8.6.3: Constructor modifiers */
4307 else
4308 {
4309 JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4310 JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4311 JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4312 JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4313 JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4314 }
4315 /* If we found error here, we don't consider it's OK to tread
4316 the method definition as a constructor, for the rest of this
4317 function */
4318 if (ec == java_error_count)
4319 constructor_ok = 1;
4320 }
e04a16fb
AG		 4321
4322 /* Method declared within the scope of an interface are implicitly
4323 abstract and public. Conflicts with other erroneously provided
c0d87ff6 4324 modifiers are checked right after. */
e04a16fb
AG		 4325
4326 if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4327 {
4328 /* If FLAGS isn't set because of a modifier, turn the
4329 corresponding modifier WFL to NULL so we issue a warning on
4330 the obsolete use of the modifier */
4331 if (!(flags & ACC_PUBLIC))
4332 MODIFIER_WFL (PUBLIC_TK) = NULL;
4333 if (!(flags & ACC_ABSTRACT))
4334 MODIFIER_WFL (ABSTRACT_TK) = NULL;
4335 flags |= ACC_PUBLIC;
4336 flags |= ACC_ABSTRACT;
4337 }
4338
c2952b01
APB		 4339 /* Inner class can't declare static methods */
4340 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4341 {
4342 parse_error_context
4343 (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4344 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4345 lang_printable_name (this_class, 0));
4346 }
4347
e04a16fb
AG		 4348 /* Modifiers context reset moved up, so abstract method declaration
4349 modifiers can be later checked. */
4350
22eed1e6
APB		 4351 /* Set constructor returned type to void and method name to <init>,
4352 unless we found an error identifier the constructor (in which
4353 case we retain the original name) */
4354 if (!type)
4355 {
4356 type = void_type_node;
4357 if (constructor_ok)
4358 meth_name = init_identifier_node;
4359 }
4360 else
4361 meth_name = EXPR_WFL_NODE (id);
e04a16fb 4362
1886c9d8
APB		 4363 /* Do the returned type resolution and registration if necessary */
4364 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4365
4a5f66c3
APB		 4366 if (meth_name)
4367 type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
1886c9d8
APB		 4368 EXPR_WFL_NODE (id) = meth_name;
4369 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4370
4371 if (must_chain)
e04a16fb 4372 {
1886c9d8
APB		 4373 patch_stage = JDEP_METHOD_RETURN;
4374 register_incomplete_type (patch_stage, type_wfl, id, type);
4375 TREE_TYPE (meth) = GET_REAL_TYPE (type);
e04a16fb
AG		 4376 }
4377 else
1886c9d8 4378 TREE_TYPE (meth) = type;
e04a16fb
AG		 4379
4380 saved_lineno = lineno;
4381 /* When defining an abstract or interface method, the curly
4382 bracket at level 1 doesn't exist because there is no function
4383 body */
4384 lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4385 EXPR_WFL_LINENO (id));
4386
5e942c50
APB		 4387 /* Remember the original argument list */
4388 orig_arg = TYPE_ARG_TYPES (meth);
4389
e04a16fb
AG		 4390 if (patch_stage) /* includes ret type and/or all args */
4391 {
4392 jdep *jdep;
4393 meth = add_method_1 (this_class, flags, meth_name, meth);
4394 /* Patch for the return type */
4395 if (patch_stage == JDEP_METHOD_RETURN)
4396 {
4397 jdep = CLASSD_LAST (ctxp->classd_list);
4398 JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4399 }
4400 /* This is the stop JDEP. METH allows the function's signature
4401 to be computed. */
4402 register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4403 }
4404 else
5e942c50
APB		 4405 meth = add_method (this_class, flags, meth_name,
4406 build_java_signature (meth));
4407
c2952b01
APB		 4408 /* Remember final parameters */
4409 MARK_FINAL_PARMS (meth, orig_arg);
4410
5e942c50
APB		 4411 /* Fix the method argument list so we have the argument name
4412 information */
4413 fix_method_argument_names (orig_arg, meth);
4414
4415 /* Register the parameter number and re-install the current line
4416 number */
e04a16fb
AG		 4417 DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4418 lineno = saved_lineno;
b9f7e36c
APB		 4419
4420 /* Register exception specified by the `throws' keyword for
4421 resolution and set the method decl appropriate field to the list.
4422 Note: the grammar ensures that what we get here are class
4423 types. */
4424 if (throws)
4425 {
4426 throws = nreverse (throws);
4427 for (current = throws; current; current = TREE_CHAIN (current))
4428 {
4429 register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4430 NULL_TREE, NULL_TREE);
4431 JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4432 &TREE_VALUE (current);
4433 }
4434 DECL_FUNCTION_THROWS (meth) = throws;
4435 }
4436
e04a16fb
AG		 4437 /* We set the DECL_NAME to ID so we can track the location where
4438 the function was declared. This allow us to report
4439 redefinition error accurately. When method are verified,
4440 DECL_NAME is reinstalled properly (using the content of the
4441 WFL node ID) (see check_method_redefinition). We don't do that
22eed1e6
APB		 4442 when Object is being defined. Constructor <init> names will be
4443 reinstalled the same way. */
c2952b01 4444 if (TREE_TYPE (GET_CPC ()) != object_type_node)
e04a16fb 4445 DECL_NAME (meth) = id;
22eed1e6
APB		 4446
4447 /* Set the flag if we correctly processed a constructor */
4448 if (constructor_ok)
c2952b01
APB		 4449 {
4450 DECL_CONSTRUCTOR_P (meth) = 1;
4451 /* Compute and store the number of artificial parameters declared
4452 for this constructor */
4453 for (count = 0, current = TYPE_FIELDS (this_class); current;
4454 current = TREE_CHAIN (current))
4455 if (FIELD_LOCAL_ALIAS (current))
4456 count++;
4457 DECL_FUNCTION_NAP (meth) = count;
4458 }
22eed1e6 4459
5e942c50
APB		 4460 /* Eventually set the @deprecated tag flag */
4461 CHECK_DEPRECATED (meth);
4462
7f10c2e2
APB		 4463 /* If doing xref, store column and line number information instead
4464 of the line number only. */
4465 if (flag_emit_xref)
4466 DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4467
e04a16fb
AG		 4468 return meth;
4469}
4470
5e942c50
APB		 4471static void
4472fix_method_argument_names (orig_arg, meth)
4473 tree orig_arg, meth;
4474{
4475 tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4476 if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4477 {
4478 TREE_PURPOSE (arg) = this_identifier_node;
4479 arg = TREE_CHAIN (arg);
4480 }
de4c7b02 4481 while (orig_arg != end_params_node)
5e942c50
APB		 4482 {
4483 TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4484 orig_arg = TREE_CHAIN (orig_arg);
4485 arg = TREE_CHAIN (arg);
4486 }
4487}
4488
22eed1e6
APB		 4489/* Complete the method declaration with METHOD_BODY. */
4490
4491static void
b635eb2f 4492finish_method_declaration (method_body)
22eed1e6
APB		 4493 tree method_body;
4494{
79d13333
APB		 4495 int flags;
4496
4497 if (!current_function_decl)
4498 return;
4499
4500 flags = get_access_flags_from_decl (current_function_decl);
5256aa37
APB		 4501
4502 /* 8.4.5 Method Body */
4503 if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4504 {
4505 tree wfl = DECL_NAME (current_function_decl);
4506 parse_error_context (wfl,
4507 "%s method `%s' can't have a body defined",
4508 (METHOD_NATIVE (current_function_decl) ?
4509 "Native" : "Abstract"),
4510 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
4511 method_body = NULL_TREE;
4512 }
4513 else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4514 {
4515 tree wfl = DECL_NAME (current_function_decl);
781b0558
KG		 4516 parse_error_context
4517 (wfl,
4518 "Non native and non abstract method `%s' must have a body defined",
4519 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
5256aa37
APB		 4520 method_body = NULL_TREE;
4521 }
4522
2c56429a
APB		 4523 if (flag_emit_class_files && method_body
4524 && TREE_CODE (method_body) == NOP_EXPR
4525 && TREE_TYPE (current_function_decl)
4526 && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4527 method_body = build1 (RETURN_EXPR, void_type_node, NULL);
e803d3b2 4528
22eed1e6
APB		 4529 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4530 maybe_absorb_scoping_blocks ();
4531 /* Exit function's body */
4532 exit_block ();
4533 /* Merge last line of the function with first line, directly in the
4534 function decl. It will be used to emit correct debug info. */
7f10c2e2
APB		 4535 if (!flag_emit_xref)
4536 DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1);
c2952b01
APB		 4537
4538 /* Since function's argument's list are shared, reset the
4539 ARG_FINAL_P parameter that might have been set on some of this
4540 function parameters. */
4541 UNMARK_FINAL_PARMS (current_function_decl);
4542
f099f336
APB		 4543 /* So we don't have an irrelevant function declaration context for
4544 the next static block we'll see. */
4545 current_function_decl = NULL_TREE;
22eed1e6
APB		 4546}
4547
4548/* Build a an error message for constructor circularity errors. */
4549
4550static char *
4551constructor_circularity_msg (from, to)
4552 tree from, to;
4553{
4554 static char string [4096];
c2e3db92 4555 char *t = xstrdup (lang_printable_name (from, 0));
22eed1e6
APB		 4556 sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4557 free (t);
4558 return string;
4559}
4560
4561/* Verify a circular call to METH. Return 1 if an error is found, 0
4562 otherwise. */
4563
4564static int
4565verify_constructor_circularity (meth, current)
4566 tree meth, current;
4567{
4568 static tree list = NULL_TREE;
4569 tree c;
4570 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4571 {
4572 if (TREE_VALUE (c) == meth)
4573 {
4574 char *t;
4575 if (list)
4576 {
4577 tree liste;
4578 list = nreverse (list);
4579 for (liste = list; liste; liste = TREE_CHAIN (liste))
4580 {
4581 parse_error_context
c63b98cd 4582 (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
22eed1e6
APB		 4583 constructor_circularity_msg
4584 (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4585 java_error_count--;
4586 }
4587 }
c2e3db92 4588 t = xstrdup (lang_printable_name (meth, 0));
22eed1e6
APB		 4589 parse_error_context (TREE_PURPOSE (c),
4590 "%s: recursive invocation of constructor `%s'",
4591 constructor_circularity_msg (current, meth), t);
4592 free (t);
4593 list = NULL_TREE;
4594 return 1;
4595 }
4596 }
4597 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4598 {
4599 list = tree_cons (c, current, list);
4600 if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4601 return 1;
4602 list = TREE_CHAIN (list);
4603 }
4604 return 0;
4605}
4606
e04a16fb
AG		 4607/* Check modifiers that can be declared but exclusively */
4608
4609static void
4610check_modifiers_consistency (flags)
4611 int flags;
4612{
4613 int acc_count = 0;
4614 tree cl = NULL_TREE;
4615
e0fc4118
TT		 4616 THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4617 THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4618 THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
e04a16fb
AG		 4619 if (acc_count > 1)
4620 parse_error_context
e0fc4118
TT		 4621 (cl, "Inconsistent member declaration. At most one of `public', `private', or `protected' may be specified");
4622
4623 acc_count = 0;
4624 cl = NULL_TREE;
14d075d8
TT		 4625 THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4626 THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
e0fc4118
TT		 4627 if (acc_count > 1)
4628 parse_error_context (cl,
4629 "Inconsistent member declaration. At most one of `final' or `volatile' may be specified");
e04a16fb
AG		 4630}
4631
4632/* Check the methode header METH for abstract specifics features */
4633
4634static void
4635check_abstract_method_header (meth)
4636 tree meth;
4637{
4638 int flags = get_access_flags_from_decl (meth);
4639 /* DECL_NAME might still be a WFL node */
c877974e 4640 tree name = GET_METHOD_NAME (meth);
e04a16fb 4641
2884c41e
KG		 4642 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4643 ACC_ABSTRACT, "abstract method",
4644 IDENTIFIER_POINTER (name));
4645 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4646 ACC_PUBLIC, "abstract method",
4647 IDENTIFIER_POINTER (name));
e04a16fb
AG		 4648
4649 check_modifiers ("Illegal modifier `%s' for interface method",
4650 flags, INTERFACE_METHOD_MODIFIERS);
4651}
4652
4653/* Create a FUNCTION_TYPE node and start augmenting it with the
4654 declared function arguments. Arguments type that can't be resolved
4655 are left as they are, but the returned node is marked as containing
4656 incomplete types. */
4657
4658static tree
4659method_declarator (id, list)
4660 tree id, list;
4661{
4662 tree arg_types = NULL_TREE, current, node;
4663 tree meth = make_node (FUNCTION_TYPE);
4664 jdep *jdep;
e04a16fb
AG		 4665
4666 patch_stage = JDEP_NO_PATCH;
c2952b01
APB		 4667
4668 /* If we're dealing with an inner class constructor, we hide the
4669 this$<n> decl in the name field of its parameter declaration. We
4670 also might have to hide the outer context local alias
4671 initializers. Not done when the class is a toplevel class. */
4672 if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4673 && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4674 {
4675 tree aliases_list, type, thisn;
4676 /* First the aliases, linked to the regular parameters */
4677 aliases_list =
4678 build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4679 TREE_TYPE (GET_CPC ()),
4680 NULL_TREE, NULL);
4681 list = chainon (nreverse (aliases_list), list);
4682
4683 /* Then this$<n> */
4684 type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
9a7ab4b3 4685 thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
c2952b01
APB		 4686 list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4687 list);
4688 }
e04a16fb
AG		 4689
4690 for (current = list; current; current = TREE_CHAIN (current))
4691 {
c583dd46 4692 int must_chain = 0;
e04a16fb
AG		 4693 tree wfl_name = TREE_PURPOSE (current);
4694 tree type = TREE_VALUE (current);
4695 tree name = EXPR_WFL_NODE (wfl_name);
c583dd46
APB		 4696 tree already, arg_node;
4697 tree type_wfl = NULL_TREE;
23a79c61 4698 tree real_type;
c583dd46
APB		 4699
4700 /* Obtain a suitable type for resolution, if necessary */
4701 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4702
4703 /* Process NAME, as it may specify extra dimension(s) for it */
4704 type = build_array_from_name (type, type_wfl, name, &name);
4705 EXPR_WFL_NODE (wfl_name) = name;
e04a16fb 4706
23a79c61
APB		 4707 real_type = GET_REAL_TYPE (type);
4708 if (TREE_CODE (real_type) == RECORD_TYPE)
4709 {
4710 real_type = promote_type (real_type);
4711 if (TREE_CODE (type) == TREE_LIST)
4712 TREE_PURPOSE (type) = real_type;
4713 }
5e942c50 4714
e04a16fb
AG		 4715 /* Check redefinition */
4716 for (already = arg_types; already; already = TREE_CHAIN (already))
4717 if (TREE_PURPOSE (already) == name)
4718 {
781b0558
KG		 4719 parse_error_context
4720 (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4721 IDENTIFIER_POINTER (name),
e04a16fb
AG		 4722 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4723 break;
4724 }
4725
4726 /* If we've an incomplete argument type, we know there is a location
4727 to patch when the type get resolved, later. */
4728 jdep = NULL;
c583dd46 4729 if (must_chain)
e04a16fb 4730 {
c583dd46
APB		 4731 patch_stage = JDEP_METHOD;
4732 type = register_incomplete_type (patch_stage,
4733 type_wfl, wfl_name, type);
4734 jdep = CLASSD_LAST (ctxp->classd_list);
4735 JDEP_MISC (jdep) = id;
e04a16fb 4736 }
c583dd46 4737
c2952b01 4738 /* The argument node: a name and a (possibly) incomplete type. */
23a79c61 4739 arg_node = build_tree_list (name, real_type);
c2952b01
APB		 4740 /* Remeber arguments declared final. */
4741 ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4742
e04a16fb
AG		 4743 if (jdep)
4744 JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4745 TREE_CHAIN (arg_node) = arg_types;
4746 arg_types = arg_node;
4747 }
de4c7b02 4748 TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
e04a16fb
AG		 4749 node = build_tree_list (id, meth);
4750 return node;
4751}
4752
4753static int
4754unresolved_type_p (wfl, returned)
4755 tree wfl;
4756 tree *returned;
4757
4758{
4759 if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
4760 {
e04a16fb 4761 if (returned)
165f37bc
APB		 4762 {
4763 tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
4764 if (decl && current_class && (decl == TYPE_NAME (current_class)))
4765 *returned = TREE_TYPE (decl);
4766 else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
4767 *returned = TREE_TYPE (GET_CPC ());
4768 else
4769 *returned = NULL_TREE;
4770 }
e04a16fb
AG		 4771 return 1;
4772 }
4773 if (returned)
4774 *returned = wfl;
4775 return 0;
4776}
4777
4778/* From NAME, build a qualified identifier node using the
4779 qualification from the current package definition. */
4780
4781static tree
98a52c2c 4782parser_qualified_classname (name)
e04a16fb
AG		 4783 tree name;
4784{
c2952b01
APB		 4785 tree nested_class_name;
4786
98a52c2c 4787 if ((nested_class_name = maybe_make_nested_class_name (name)))
c2952b01
APB		 4788 return nested_class_name;
4789
e04a16fb 4790 if (ctxp->package)
c2952b01 4791 return merge_qualified_name (ctxp->package, name);
e04a16fb 4792 else
c2952b01 4793 return name;
e04a16fb
AG		 4794}
4795
4796/* Called once the type a interface extends is resolved. Returns 0 if
4797 everything is OK. */
4798
4799static int
4800parser_check_super_interface (super_decl, this_decl, this_wfl)
4801 tree super_decl, this_decl, this_wfl;
4802{
4803 tree super_type = TREE_TYPE (super_decl);
4804
4805 /* Has to be an interface */
c2952b01 4806 if (!CLASS_INTERFACE (super_decl))
e04a16fb
AG		 4807 {
4808 parse_error_context
4809 (this_wfl, "Can't use %s `%s' to implement/extend %s `%s'",
4810 (TYPE_ARRAY_P (super_type) ? "array" : "class"),
4811 IDENTIFIER_POINTER (DECL_NAME (super_decl)),
4812 (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
4813 "interface" : "class"),
4814 IDENTIFIER_POINTER (DECL_NAME (this_decl)));
4815 return 1;
4816 }
4817
4818 /* Check scope: same package OK, other package: OK if public */
4819 if (check_pkg_class_access (DECL_NAME (super_decl), lookup_cl (this_decl)))
4820 return 1;
4821
4822 SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
4823 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4824 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
4825 return 0;
4826}
4827
4828/* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
4829 0 if everthing is OK. */
4830
4831static int
4832parser_check_super (super_decl, this_decl, wfl)
4833 tree super_decl, this_decl, wfl;
4834{
e04a16fb
AG		 4835 tree super_type = TREE_TYPE (super_decl);
4836
4837 /* SUPER should be a CLASS (neither an array nor an interface) */
4838 if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
4839 {
4840 parse_error_context
4841 (wfl, "Class `%s' can't subclass %s `%s'",
4842 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4843 (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
4844 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
4845 return 1;
4846 }
4847
4848 if (CLASS_FINAL (TYPE_NAME (super_type)))
4849 {
4850 parse_error_context (wfl, "Can't subclass final classes: %s",
4851 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
4852 return 1;
4853 }
4854
4855 /* Check scope: same package OK, other package: OK if public */
4856 if (check_pkg_class_access (DECL_NAME (super_decl), wfl))
4857 return 1;
4858
4859 SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
4860 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
4861 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
4862 return 0;
4863}
4864
4865/* Create a new dependency list and link it (in a LIFO manner) to the
4866 CTXP list of type dependency list. */
4867
4868static void
4869create_jdep_list (ctxp)
4870 struct parser_ctxt *ctxp;
4871{
23a79c61 4872 jdeplist *new = (jdeplist *)xmalloc (sizeof (jdeplist));
e04a16fb
AG		 4873 new->first = new->last = NULL;
4874 new->next = ctxp->classd_list;
4875 ctxp->classd_list = new;
4876}
4877
4878static jdeplist *
4879reverse_jdep_list (ctxp)
4880 struct parser_ctxt *ctxp;
4881{
4882 register jdeplist *prev = NULL, *current, *next;
4883 for (current = ctxp->classd_list; current; current = next)
4884 {
4885 next = current->next;
4886 current->next = prev;
4887 prev = current;
4888 }
4889 return prev;
4890}
4891
23a79c61
APB		 4892/* Create a fake pointer based on the ID stored in
4893 TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
4894 registered again. */
e04a16fb
AG		 4895
4896static tree
23a79c61
APB		 4897obtain_incomplete_type (type_name)
4898 tree type_name;
e04a16fb 4899{
23a79c61
APB		 4900 tree ptr, name;
4901
4902 if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
4903 name = EXPR_WFL_NODE (type_name);
4904 else if (INCOMPLETE_TYPE_P (type_name))
4905 name = TYPE_NAME (type_name);
4906 else
4907 fatal ("invalid type name - obtain_incomplete_type");
e04a16fb
AG		 4908
4909 for (ptr = ctxp->incomplete_class; ptr; ptr = TREE_CHAIN (ptr))
78d21f92 4910 if (TYPE_NAME (ptr) == name)
e04a16fb
AG		 4911 break;
4912
4913 if (!ptr)
4914 {
e04a16fb 4915 push_obstacks (&permanent_obstack, &permanent_obstack);
78d21f92
PB		 4916 BUILD_PTR_FROM_NAME (ptr, name);
4917 layout_type (ptr);
e04a16fb
AG		 4918 pop_obstacks ();
4919 TREE_CHAIN (ptr) = ctxp->incomplete_class;
4920 ctxp->incomplete_class = ptr;
4921 }
4922
4923 return ptr;
4924}
4925
4926/* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
4927 non NULL instead of computing a new fake type based on WFL. The new
4928 dependency is inserted in the current type dependency list, in FIFO
4929 manner. */
4930
4931static tree
4932register_incomplete_type (kind, wfl, decl, ptr)
4933 int kind;
4934 tree wfl, decl, ptr;
4935{
23a79c61 4936 jdep *new = (jdep *)xmalloc (sizeof (jdep));
e04a16fb 4937
e04a16fb
AG		 4938 if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
4939 ptr = obtain_incomplete_type (wfl);
4940
4941 JDEP_KIND (new) = kind;
4942 JDEP_DECL (new) = decl;
4943 JDEP_SOLV (new) = ptr;
4944 JDEP_WFL (new) = wfl;
4945 JDEP_CHAIN (new) = NULL;
4946 JDEP_MISC (new) = NULL_TREE;
e803d3b2
APB		 4947 /* For some dependencies, set the enclosing class of the current
4948 class to be the enclosing context */
4949 if ((kind == JDEP_SUPER || kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS)
165f37bc
APB		 4950 && GET_ENCLOSING_CPC ())
4951 JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
4952 else
324ed8fd 4953 JDEP_ENCLOSING (new) = GET_CPC ();
e04a16fb
AG		 4954 JDEP_GET_PATCH (new) = (tree *)NULL;
4955
4956 JDEP_INSERT (ctxp->classd_list, new);
4957
4958 return ptr;
4959}
4960
4961void
4962java_check_circular_reference ()
4963{
4964 tree current;
4965 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
4966 {
4967 tree type = TREE_TYPE (current);
e920ebc9 4968 if (CLASS_INTERFACE (current))
e04a16fb
AG		 4969 {
4970 /* Check all interfaces this class extends */
4971 tree basetype_vec = TYPE_BINFO_BASETYPES (type);
4972 int n, i;
4973
4974 if (!basetype_vec)
4975 return;
4976 n = TREE_VEC_LENGTH (basetype_vec);
4977 for (i = 0; i < n; i++)
4978 {
4979 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
4980 if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
4981 && interface_of_p (type, BINFO_TYPE (vec_elt)))
4982 parse_error_context (lookup_cl (current),
4983 "Cyclic interface inheritance");
4984 }
4985 }
4986 else
4987 if (inherits_from_p (CLASSTYPE_SUPER (type), type))
4988 parse_error_context (lookup_cl (current),
c2952b01
APB		 4989 "Cyclic class inheritance%s",
4990 (cyclic_inheritance_report ?
4991 cyclic_inheritance_report : ""));
4992 }
4993}
4994
4995/* Augment the parameter list PARM with parameters crafted to
4996 initialize outer context locals aliases. Through ARTIFICIAL, a
4997 count is kept of the number of crafted parameters. MODE governs
4998 what eventually gets created: something suitable for a function
4999 creation or a function invocation, either the constructor or
5000 $finit$. */
5001
5002static tree
5003build_alias_initializer_parameter_list (mode, class_type, parm, artificial)
5004 int mode;
5005 tree class_type, parm;
5006 int *artificial;
5007{
5008 tree field;
5009 for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5010 if (FIELD_LOCAL_ALIAS (field))
5011 {
5012 char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5013 tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5014
5015 switch (mode)
5016 {
5017 case AIPL_FUNCTION_DECLARATION:
5018 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
5019 purpose = build_wfl_node (get_identifier (buffer));
5020 if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5021 value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5022 else
5023 value = TREE_TYPE (field);
5024 break;
5025
5026 case AIPL_FUNCTION_CREATION:
5027 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
5028 purpose = get_identifier (buffer);
5029 value = TREE_TYPE (field);
5030 break;
5031
5032 case AIPL_FUNCTION_FINIT_INVOCATION:
5033 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (buffer, &buffer [4]);
5034 /* Now, this is wrong. purpose should always be the NAME
5035 of something and value its matching value (decl, type,
5036 etc...) FIXME -- but there is a lot to fix. */
5037
5038 /* When invoked for this kind of operation, we already
5039 know whether a field is used or not. */
5040 purpose = TREE_TYPE (field);
5041 value = build_wfl_node (get_identifier (buffer));
5042 break;
5043
5044 case AIPL_FUNCTION_CTOR_INVOCATION:
5045 /* There are two case: the constructor invokation happends
5046 outside the local inner, in which case, locales from the outer
5047 context are directly used.
5048
5049 Otherwise, we fold to using the alias directly. */
5050 if (class_type == current_class)
5051 value = field;
5052 else
5053 {
5054 name = get_identifier (&buffer[4]);
5055 value = IDENTIFIER_LOCAL_VALUE (name);
5056 }
5057 break;
5058 }
5059 parm = tree_cons (purpose, value, parm);
5060 if (artificial)
5061 *artificial +=1;
5062 }
5063 return parm;
5064}
5065
5066/* Craft a constructor for CLASS_DECL -- what we should do when none
5067 where found. ARGS is non NULL when a special signature must be
5068 enforced. This is the case for anonymous classes. */
5069
5070static void
5071craft_constructor (class_decl, args)
5072 tree class_decl, args;
5073{
5074 tree class_type = TREE_TYPE (class_decl);
5075 tree parm = NULL_TREE;
5076 int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5077 ACC_PUBLIC : 0);
5078 int i = 0, artificial = 0;
5079 tree decl, ctor_name;
5080 char buffer [80];
5081
5082 push_obstacks (&permanent_obstack, &permanent_obstack);
5083
5084 /* The constructor name is <init> unless we're dealing with an
5085 anonymous class, in which case the name will be fixed after having
5086 be expanded. */
5087 if (ANONYMOUS_CLASS_P (class_type))
5088 ctor_name = DECL_NAME (class_decl);
5089 else
5090 ctor_name = init_identifier_node;
5091
5092 /* If we're dealing with an inner class constructor, we hide the
5093 this$<n> decl in the name field of its parameter declaration. */
5094 if (PURE_INNER_CLASS_TYPE_P (class_type))
5095 {
5096 tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5097 parm = tree_cons (build_current_thisn (class_type),
5098 build_pointer_type (type), parm);
5099
5100 /* Some more arguments to be hidden here. The values of the local
5101 variables of the outer context that the inner class needs to see. */
5102 parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5103 class_type, parm,
5104 &artificial);
5105 }
5106
5107 /* Then if there are any args to be enforced, enforce them now */
5108 for (; args && args != end_params_node; args = TREE_CHAIN (args))
5109 {
5110 sprintf (buffer, "parm%d", i++);
5111 parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
e04a16fb 5112 }
c2952b01
APB		 5113
5114 CRAFTED_PARAM_LIST_FIXUP (parm);
5115 decl = create_artificial_method (class_type, flags, void_type_node,
5116 ctor_name, parm);
5117 fix_method_argument_names (parm, decl);
5118 /* Now, mark the artificial parameters. */
5119 DECL_FUNCTION_NAP (decl) = artificial;
5120
5121 pop_obstacks ();
5122 DECL_CONSTRUCTOR_P (decl) = 1;
e04a16fb
AG		 5123}
5124
c2952b01 5125
e920ebc9
APB		 5126/* Fix the constructors. This will be called right after circular
5127 references have been checked. It is necessary to fix constructors
5128 early even if no code generation will take place for that class:
5129 some generated constructor might be required by the class whose
5130 compilation triggered this one to be simply loaded. */
5131
5132void
5133java_fix_constructors ()
5134{
5135 tree current;
5136
5137 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5138 {
e920ebc9
APB		 5139 tree class_type = TREE_TYPE (current);
5140 int saw_ctor = 0;
c2952b01
APB		 5141 tree decl;
5142
5143 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5144 continue;
e920ebc9
APB		 5145
5146 for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5147 {
5148 if (DECL_CONSTRUCTOR_P (decl))
5149 {
5150 fix_constructors (decl);
5151 saw_ctor = 1;
5152 }
5153 }
5154
c2952b01
APB		 5155 /* Anonymous class constructor can't be generated that early. */
5156 if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5157 craft_constructor (current, NULL_TREE);
e920ebc9
APB		 5158 }
5159}
5160
23a79c61
APB		 5161/* safe_layout_class just makes sure that we can load a class without
5162 disrupting the current_class, input_file, lineno, etc, information
5163 about the class processed currently. */
5164
e04a16fb
AG		 5165void
5166safe_layout_class (class)
5167 tree class;
5168{
5169 tree save_current_class = current_class;
3b304f5b 5170 const char *save_input_filename = input_filename;
e04a16fb 5171 int save_lineno = lineno;
5e942c50 5172
e04a16fb 5173 push_obstacks (&permanent_obstack, &permanent_obstack);
5e942c50 5174
e04a16fb
AG		 5175 layout_class (class);
5176 pop_obstacks ();
5e942c50 5177
e04a16fb
AG		 5178 current_class = save_current_class;
5179 input_filename = save_input_filename;
5180 lineno = save_lineno;
5181 CLASS_LOADED_P (class) = 1;
5182}
5183
5184static tree
5185jdep_resolve_class (dep)
5186 jdep *dep;
5187{
5188 tree decl;
5189
23a79c61
APB		 5190 if (JDEP_RESOLVED_P (dep))
5191 decl = JDEP_RESOLVED_DECL (dep);
5192 else
e04a16fb 5193 {
c2952b01 5194 decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
23a79c61 5195 JDEP_DECL (dep), JDEP_WFL (dep));
e04a16fb
AG		 5196 JDEP_RESOLVED (dep, decl);
5197 }
23a79c61 5198
e04a16fb 5199 if (!decl)
23a79c61
APB		 5200 complete_class_report_errors (dep);
5201
cf1748bf 5202 check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
e04a16fb
AG		 5203 return decl;
5204}
5205
5206/* Complete unsatisfied class declaration and their dependencies */
5207
5208void
5209java_complete_class ()
5210{
e04a16fb
AG		 5211 tree cclass;
5212 jdeplist *cclassd;
5213 int error_found;
b67d701b 5214 tree type;
e04a16fb
AG		 5215
5216 push_obstacks (&permanent_obstack, &permanent_obstack);
5217
9a7ab4b3 5218 /* Process imports */
e04a16fb 5219 process_imports ();
e04a16fb
AG		 5220
5221 /* Rever things so we have the right order */
5222 ctxp->class_list = nreverse (ctxp->class_list);
5223 ctxp->classd_list = reverse_jdep_list (ctxp);
c877974e 5224
e04a16fb
AG		 5225 for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5226 cclass && cclassd;
5227 cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5228 {
5229 jdep *dep;
5230 for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5231 {
5232 tree decl;
e04a16fb
AG		 5233 if (!(decl = jdep_resolve_class (dep)))
5234 continue;
5235
5236 /* Now it's time to patch */
5237 switch (JDEP_KIND (dep))
5238 {
5239 case JDEP_SUPER:
5240 /* Simply patch super */
5241 if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5242 continue;
5243 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5244 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5245 break;
5246
5247 case JDEP_FIELD:
5248 {
5249 /* We do part of the job done in add_field */
5250 tree field_decl = JDEP_DECL (dep);
5251 tree field_type = TREE_TYPE (decl);
5252 push_obstacks (&permanent_obstack, &permanent_obstack);
e04a16fb 5253 if (TREE_CODE (field_type) == RECORD_TYPE)
e04a16fb
AG		 5254 field_type = promote_type (field_type);
5255 pop_obstacks ();
5256 TREE_TYPE (field_decl) = field_type;
5e942c50 5257 DECL_ALIGN (field_decl) = 0;
11cf4d18 5258 DECL_USER_ALIGN (field_decl) = 0;
5e942c50 5259 layout_decl (field_decl, 0);
e04a16fb
AG		 5260 SOURCE_FRONTEND_DEBUG
5261 (("Completed field/var decl `%s' with `%s'",
5262 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5263 IDENTIFIER_POINTER (DECL_NAME (decl))));
5264 break;
5265 }
5266 case JDEP_METHOD: /* We start patching a method */
5267 case JDEP_METHOD_RETURN:
5268 error_found = 0;
5269 while (1)
5270 {
5271 if (decl)
5272 {
b67d701b
PB		 5273 type = TREE_TYPE(decl);
5274 if (TREE_CODE (type) == RECORD_TYPE)
5275 type = promote_type (type);
e04a16fb
AG		 5276 JDEP_APPLY_PATCH (dep, type);
5277 SOURCE_FRONTEND_DEBUG
5278 (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5279 "Completing fct `%s' with ret type `%s'":
5280 "Completing arg `%s' with type `%s'"),
5281 IDENTIFIER_POINTER (EXPR_WFL_NODE
5282 (JDEP_DECL_WFL (dep))),
5283 IDENTIFIER_POINTER (DECL_NAME (decl))));
5284 }
5285 else
5286 error_found = 1;
5287 dep = JDEP_CHAIN (dep);
5288 if (JDEP_KIND (dep) == JDEP_METHOD_END)
5289 break;
5290 else
5291 decl = jdep_resolve_class (dep);
5292 }
5293 if (!error_found)
5294 {
5295 tree mdecl = JDEP_DECL (dep), signature;
5296 push_obstacks (&permanent_obstack, &permanent_obstack);
165f37bc
APB		 5297 /* Recompute and reset the signature, check first that
5298 all types are now defined. If they're not,
5299 dont build the signature. */
5300 if (check_method_types_complete (mdecl))
5301 {
5302 signature = build_java_signature (TREE_TYPE (mdecl));
5303 set_java_signature (TREE_TYPE (mdecl), signature);
5304 }
e04a16fb
AG		 5305 pop_obstacks ();
5306 }
5307 else
5308 continue;
5309 break;
5310
5311 case JDEP_INTERFACE:
5312 if (parser_check_super_interface (decl, JDEP_DECL (dep),
5313 JDEP_WFL (dep)))
5314 continue;
5315 parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5316 break;
5317
b67d701b 5318 case JDEP_PARM:
e04a16fb 5319 case JDEP_VARIABLE:
b67d701b
PB		 5320 type = TREE_TYPE(decl);
5321 if (TREE_CODE (type) == RECORD_TYPE)
5322 type = promote_type (type);
5323 JDEP_APPLY_PATCH (dep, type);
e04a16fb
AG		 5324 break;
5325
5326 case JDEP_TYPE:
5327 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5328 SOURCE_FRONTEND_DEBUG
5329 (("Completing a random type dependency on a '%s' node",
5330 tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5331 break;
5332
b9f7e36c 5333 case JDEP_EXCEPTION:
c877974e
APB		 5334 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5335 SOURCE_FRONTEND_DEBUG
5336 (("Completing `%s' `throws' argument node",
5337 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
b9f7e36c
APB		 5338 break;
5339
c2952b01
APB		 5340 case JDEP_ANONYMOUS:
5341 patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5342 break;
5343
e04a16fb 5344 default:
0a2138e2
APB		 5345 fatal ("Can't handle patch code %d - java_complete_class",
5346 JDEP_KIND (dep));
e04a16fb
AG		 5347 }
5348 }
5349 }
5350 pop_obstacks ();
5351 return;
5352}
5353
5354/* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5355 array. */
5356
5357static tree
c2952b01
APB		 5358resolve_class (enclosing, class_type, decl, cl)
5359 tree enclosing, class_type, decl, cl;
e04a16fb 5360{
49f48c71
KG		 5361 const char *name = IDENTIFIER_POINTER (TYPE_NAME (class_type));
5362 const char *base = name;
78d21f92
PB		 5363 tree resolved_type = TREE_TYPE (class_type);
5364 tree resolved_type_decl;
e04a16fb 5365
78d21f92
PB		 5366 if (resolved_type != NULL_TREE)
5367 {
5368 tree resolved_type_decl = TYPE_NAME (resolved_type);
5369 if (resolved_type_decl == NULL_TREE
5370 || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5371 {
5372 resolved_type_decl = build_decl (TYPE_DECL,
5373 TYPE_NAME (class_type),
5374 resolved_type);
5375 }
5376 return resolved_type_decl;
5377 }
5378
e04a16fb
AG		 5379 /* 1- Check to see if we have an array. If true, find what we really
5380 want to resolve */
5381 while (name[0] == '[')
5382 name++;
5383 if (base != name)
5384 TYPE_NAME (class_type) = get_identifier (name);
5385
5386 /* 2- Resolve the bare type */
c2952b01
APB		 5387 if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5388 decl, cl)))
e04a16fb
AG		 5389 return NULL_TREE;
5390 resolved_type = TREE_TYPE (resolved_type_decl);
5391
5392 /* 3- If we have and array, reconstruct the array down to its nesting */
5393 if (base != name)
5394 {
5395 while (base != name)
5396 {
5397 if (TREE_CODE (resolved_type) == RECORD_TYPE)
5398 resolved_type = promote_type (resolved_type);
5399 resolved_type = build_java_array_type (resolved_type, -1);
c583dd46 5400 CLASS_LOADED_P (resolved_type) = 1;
e04a16fb
AG		 5401 name--;
5402 }
5403 /* Build a fake decl for this, since this is what is expected to
5404 be returned. */
5405 resolved_type_decl =
5406 build_decl (TYPE_DECL, TYPE_NAME (resolved_type), resolved_type);
5407 /* Figure how those two things are important for error report. FIXME */
5408 DECL_SOURCE_LINE (resolved_type_decl) = 0;
5409 DECL_SOURCE_FILE (resolved_type_decl) = input_filename;
78d21f92 5410 TYPE_NAME (class_type) = TYPE_NAME (resolved_type);
e04a16fb 5411 }
78d21f92 5412 TREE_TYPE (class_type) = resolved_type;
e04a16fb
AG		 5413 return resolved_type_decl;
5414}
5415
5416/* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
5417 are used to report error messages. */
5418
78d21f92 5419tree
c2952b01
APB		 5420do_resolve_class (enclosing, class_type, decl, cl)
5421 tree enclosing, class_type, decl, cl;
e04a16fb
AG		 5422{
5423 tree new_class_decl;
e04a16fb
AG		 5424
5425 /* Do not try to replace TYPE_NAME (class_type) by a variable, since
9a7ab4b3
APB		 5426 it is changed by find_in_imports{_on_demand} and (but it doesn't
5427 really matter) qualify_and_find */
e04a16fb 5428
c2952b01
APB		 5429 /* 0- Search in the current class as an inner class */
5430
5431 /* Maybe some code here should be added to load the class or
5432 something, at least if the class isn't an inner class and ended
5433 being loaded from class file. FIXME. */
a40d21da
APB		 5434 while (enclosing)
5435 {
5436 tree name;
5437
5438 if ((new_class_decl = find_as_inner_class (enclosing, class_type, cl)))
5439 return new_class_decl;
5440
5441 /* Now go to the upper classes, bail out if necessary. */
5442 enclosing = CLASSTYPE_SUPER (TREE_TYPE (enclosing));
5443 if (!enclosing || enclosing == object_type_node)
5444 break;
5445
5446 if (TREE_CODE (enclosing) == RECORD_TYPE)
5447 {
5448 enclosing = TYPE_NAME (enclosing);
5449 continue;
5450 }
5451
5452 if (TREE_CODE (enclosing) == IDENTIFIER_NODE)
5453 {
5454 BUILD_PTR_FROM_NAME (name, enclosing);
5455 }
5456 else
5457 name = enclosing;
5458 enclosing = do_resolve_class (NULL, name, NULL, NULL);
5459 }
c2952b01 5460
9a7ab4b3
APB		 5461 /* 1- Check for the type in single imports. This will change
5462 TYPE_NAME() if something relevant is found */
5463 find_in_imports (class_type);
e04a16fb 5464
9a7ab4b3 5465 /* 2- And check for the type in the current compilation unit */
e04a16fb
AG		 5466 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5467 {
5468 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5469 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5470 load_class (TYPE_NAME (class_type), 0);
5471 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5472 }
5473
9a7ab4b3
APB		 5474 /* 3- Search according to the current package definition */
5475 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5476 {
5477 if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5478 TYPE_NAME (class_type))))
5479 return new_class_decl;
5480 }
5481
5482 /* 4- Check the import on demands. Don't allow bar.baz to be
5483 imported from foo.* */
5484 if (!QUALIFIED_P (TYPE_NAME (class_type)))
5485 if (find_in_imports_on_demand (class_type))
5486 return NULL_TREE;
5487
5488 /* If found in find_in_imports_on_demant, the type has already been
5489 loaded. */
5490 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5491 return new_class_decl;
5492
5493 /* 5- Try with a name qualified with the package name we've seen so far */
ee07f4f4 5494 if (!QUALIFIED_P (TYPE_NAME (class_type)))
bc3ca41b 5495 {
ee07f4f4 5496 tree package;
d6baf6f5
APB		 5497
5498 /* If there is a current package (ctxp->package), it's the first
5499 element of package_list and we can skip it. */
5500 for (package = (ctxp->package ?
5501 TREE_CHAIN (package_list) : package_list);
5502 package; package = TREE_CHAIN (package))
9a7ab4b3
APB		 5503 if ((new_class_decl = qualify_and_find (class_type,
5504 TREE_PURPOSE (package),
5505 TYPE_NAME (class_type))))
5506 return new_class_decl;
5507 }
5508
5509 /* 5- Check an other compilation unit that bears the name of type */
e04a16fb
AG		 5510 load_class (TYPE_NAME (class_type), 0);
5511 if (check_pkg_class_access (TYPE_NAME (class_type),
5512 (cl ? cl : lookup_cl (decl))))
5513 return NULL_TREE;
5514
9a7ab4b3 5515 /* 6- Last call for a resolution */
e04a16fb
AG		 5516 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5517}
5518
9a7ab4b3
APB		 5519static tree
5520qualify_and_find (class_type, package, name)
5521 tree class_type, package, name;
5522{
5523 tree new_qualified = merge_qualified_name (package, name);
5524 tree new_class_decl;
5525
5526 if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5527 load_class (new_qualified, 0);
5528 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5529 {
5530 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5531 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5532 load_class (new_qualified, 0);
5533 TYPE_NAME (class_type) = new_qualified;
5534 return IDENTIFIER_CLASS_VALUE (new_qualified);
5535 }
5536 return NULL_TREE;
5537}
5538
e04a16fb 5539/* Resolve NAME and lay it out (if not done and if not the current
23a79c61
APB		 5540 parsed class). Return a decl node. This function is meant to be
5541 called when type resolution is necessary during the walk pass. */
e04a16fb
AG		 5542
5543static tree
c877974e
APB		 5544resolve_and_layout (something, cl)
5545 tree something;
e04a16fb
AG		 5546 tree cl;
5547{
c877974e
APB		 5548 tree decl;
5549
23a79c61
APB		 5550 /* Don't do that on the current class */
5551 if (something == current_class)
5552 return TYPE_NAME (current_class);
c877974e 5553
23a79c61 5554 /* Don't do anything for void and other primitive types */
c877974e
APB		 5555 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5556 return NULL_TREE;
5557
23a79c61
APB		 5558 /* Pointer types can be reall pointer types or fake pointers. When
5559 finding a real pointer, recheck for primitive types */
5560 if (TREE_CODE (something) == POINTER_TYPE)
5561 {
5562 if (TREE_TYPE (something))
5563 {
5564 something = TREE_TYPE (something);
5565 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5566 return NULL_TREE;
5567 }
5568 else
5569 something = TYPE_NAME (something);
5570 }
5571
5572 /* Don't do anything for arrays of primitive types */
5573 if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5574 && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5575 return NULL_TREE;
5576
c2952b01
APB		 5577 /* Something might be a WFL */
5578 if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5579 something = EXPR_WFL_NODE (something);
5580
5581 /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5582 TYPE_DECL or a real TYPE */
5583 else if (TREE_CODE (something) != IDENTIFIER_NODE)
c877974e
APB		 5584 something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5585 DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5586
23a79c61
APB		 5587 if (!(decl = resolve_no_layout (something, cl)))
5588 return NULL_TREE;
5589
5590 /* Resolve and layout if necessary */
5591 layout_class_methods (TREE_TYPE (decl));
7705e9db
APB		 5592 /* Check methods, but only once */
5593 if (CLASS_FROM_SOURCE_P (TREE_TYPE (decl))
5594 && !CLASS_LOADED_P (TREE_TYPE (decl)))
23a79c61
APB		 5595 CHECK_METHODS (decl);
5596 if (TREE_TYPE (decl) != current_class && !CLASS_LOADED_P (TREE_TYPE (decl)))
e04a16fb 5597 safe_layout_class (TREE_TYPE (decl));
23a79c61 5598
e04a16fb
AG		 5599 return decl;
5600}
5601
5602/* Resolve a class, returns its decl but doesn't perform any
5603 layout. The current parsing context is saved and restored */
5604
5605static tree
5606resolve_no_layout (name, cl)
5607 tree name, cl;
5608{
5609 tree ptr, decl;
5610 BUILD_PTR_FROM_NAME (ptr, name);
5611 java_parser_context_save_global ();
c2952b01 5612 decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
e04a16fb
AG		 5613 java_parser_context_restore_global ();
5614
5615 return decl;
5616}
5617
23a79c61
APB		 5618/* Called when reporting errors. Skip leader '[' in a complex array
5619 type description that failed to be resolved. */
e04a16fb 5620
49f48c71 5621static const char *
e04a16fb 5622purify_type_name (name)
49f48c71 5623 const char *name;
e04a16fb
AG		 5624{
5625 while (*name && *name == '[')
5626 name++;
5627 return name;
5628}
5629
5630/* The type CURRENT refers to can't be found. We print error messages. */
5631
5632static void
5633complete_class_report_errors (dep)
5634 jdep *dep;
5635{
49f48c71 5636 const char *name;
23a79c61
APB		 5637
5638 if (!JDEP_WFL (dep))
5639 return;
5640
5641 name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
e04a16fb
AG		 5642 switch (JDEP_KIND (dep))
5643 {
5644 case JDEP_SUPER:
5645 parse_error_context
5646 (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
23a79c61 5647 purify_type_name (name),
e04a16fb
AG		 5648 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5649 break;
5650 case JDEP_FIELD:
5651 parse_error_context
5652 (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
23a79c61 5653 purify_type_name (name),
e04a16fb
AG		 5654 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5655 break;
5656 case JDEP_METHOD: /* Covers arguments */
5657 parse_error_context
781b0558 5658 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
23a79c61 5659 purify_type_name (name),
e04a16fb
AG		 5660 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
5661 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
5662 break;
5663 case JDEP_METHOD_RETURN: /* Covers return type */
5664 parse_error_context
781b0558 5665 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
23a79c61 5666 purify_type_name (name),
e04a16fb
AG		 5667 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
5668 break;
5669 case JDEP_INTERFACE:
5670 parse_error_context
5671 (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
5672 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
5673 (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
5674 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5675 break;
5676 case JDEP_VARIABLE:
5677 parse_error_context
781b0558 5678 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
b67d701b
PB		 5679 purify_type_name (IDENTIFIER_POINTER
5680 (EXPR_WFL_NODE (JDEP_WFL (dep)))),
e04a16fb
AG		 5681 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5682 break;
b9f7e36c
APB		 5683 case JDEP_EXCEPTION: /* As specified by `throws' */
5684 parse_error_context
5685 (JDEP_WFL (dep), "Class `%s' not found in `throws'",
5686 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
5687 break;
0a2138e2
APB		 5688 default:
5689 /* Fix for -Wall. Just break doing nothing. The error will be
5690 caught later */
5691 break;
e04a16fb
AG		 5692 }
5693}
5694
22eed1e6
APB		 5695/* Return a static string containing the DECL prototype string. If
5696 DECL is a constructor, use the class name instead of the form
5697 <init> */
5698
49f48c71 5699static const char *
22eed1e6
APB		 5700get_printable_method_name (decl)
5701 tree decl;
5702{
49f48c71 5703 const char *to_return;
9ee9b555 5704 tree name = NULL_TREE;
22eed1e6
APB		 5705
5706 if (DECL_CONSTRUCTOR_P (decl))
5707 {
5708 name = DECL_NAME (decl);
5e942c50 5709 DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
22eed1e6
APB		 5710 }
5711
5712 to_return = lang_printable_name (decl, 0);
5713 if (DECL_CONSTRUCTOR_P (decl))
5714 DECL_NAME (decl) = name;
5715
5716 return to_return;
5717}
5718
5e942c50
APB		 5719/* Reinstall the proper DECL_NAME on METHOD. Return 0 if the method
5720 nevertheless needs to be verfied, 1 otherwise. */
5721
5722static int
5723reset_method_name (method)
5724 tree method;
5725{
c2952b01 5726 if (!DECL_CLINIT_P (method) && !DECL_FINIT_P (method))
5e942c50
APB		 5727 {
5728 /* NAME is just the plain name when Object is being defined */
5729 if (DECL_CONTEXT (method) != object_type_node)
c877974e
APB		 5730 DECL_NAME (method) = (DECL_CONSTRUCTOR_P (method) ?
5731 init_identifier_node : GET_METHOD_NAME (method));
5e942c50
APB		 5732 return 0;
5733 }
5734 else
5735 return 1;
5736}
5737
c877974e
APB		 5738/* Return the name of METHOD_DECL, when DECL_NAME is a WFL */
5739
5740tree
5741java_get_real_method_name (method_decl)
5742 tree method_decl;
5743{
5744 tree method_name = DECL_NAME (method_decl);
5745 if (DECL_CONSTRUCTOR_P (method_decl))
5746 return init_identifier_node;
82371d41
APB		 5747
5748 /* Explain here why METHOD_DECL doesn't have the DECL_CONSTRUCTUR_P
5749 and still can be a constructor. FIXME */
5750
23a79c61
APB		 5751 /* Don't confuse method only bearing the name of their class as
5752 constructors */
82371d41
APB		 5753 else if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (method_decl))
5754 && ctxp
c2952b01 5755 && GET_CPC_UN () == EXPR_WFL_NODE (method_name)
23a79c61
APB		 5756 && get_access_flags_from_decl (method_decl) <= ACC_PROTECTED
5757 && TREE_TYPE (TREE_TYPE (method_decl)) == void_type_node)
c877974e
APB		 5758 return init_identifier_node;
5759 else
5760 return EXPR_WFL_NODE (method_name);
5761}
5762
22eed1e6
APB		 5763/* Track method being redefined inside the same class. As a side
5764 effect, set DECL_NAME to an IDENTIFIER (prior entering this
d77613be 5765 function it's a FWL, so we can track errors more accurately.) */
22eed1e6 5766
e04a16fb
AG		 5767static int
5768check_method_redefinition (class, method)
5769 tree class, method;
5770{
5771 tree redef, name;
5772 tree cl = DECL_NAME (method);
c3f2a476 5773 tree sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
ba179f9f
APB		 5774 /* decl name of artificial <clinit> and $finit$ doesn't need to be
5775 fixed and checked */
5e942c50
APB		 5776
5777 /* Reset the method name before running the check. If it returns 1,
5778 the method doesn't need to be verified with respect to method
5779 redeclaration and we return 0 */
5780 if (reset_method_name (method))
e04a16fb 5781 return 0;
5e942c50
APB		 5782
5783 name = DECL_NAME (method);
e04a16fb
AG		 5784 for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
5785 {
c3f2a476 5786 if (redef == method)
e04a16fb 5787 break;
c3f2a476
APB		 5788 if (DECL_NAME (redef) == name
5789 && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef)))
e04a16fb 5790 {
22eed1e6
APB		 5791 parse_error_context
5792 (cl, "Duplicate %s declaration `%s'",
5793 (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
5794 get_printable_method_name (redef));
e04a16fb
AG		 5795 return 1;
5796 }
5797 }
5798 return 0;
5799}
5800
d77613be
APB		 5801static void
5802check_abstract_method_definitions (do_interface, class_decl, type)
5803 int do_interface;
5804 tree class_decl, type;
5805{
5806 tree class = TREE_TYPE (class_decl);
5807 tree method, end_type;
5808
5809 end_type = (do_interface ? object_type_node : type);
5810 for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
5811 {
5812 tree other_super, other_method, method_sig, method_name;
5813 int found = 0;
165f37bc 5814 int end_type_reached = 0;
d77613be
APB		 5815
5816 if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
5817 continue;
5818
5819 /* Now verify that somewhere in between TYPE and CLASS,
5820 abstract method METHOD gets a non abstract definition
5821 that is inherited by CLASS. */
5822
5823 method_sig = build_java_signature (TREE_TYPE (method));
5824 method_name = DECL_NAME (method);
5825 if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
5826 method_name = EXPR_WFL_NODE (method_name);
5827
165f37bc
APB		 5828 other_super = class;
5829 do {
5830 if (other_super == end_type)
5831 end_type_reached = 1;
5832
5833 /* Method search */
5834 for (other_method = TYPE_METHODS (other_super); other_method;
5835 other_method = TREE_CHAIN (other_method))
5836 {
5837 tree s = build_java_signature (TREE_TYPE (other_method));
5838 tree other_name = DECL_NAME (other_method);
5839
5840 if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
5841 other_name = EXPR_WFL_NODE (other_name);
5842 if (!DECL_CLINIT_P (other_method)
5843 && !DECL_CONSTRUCTOR_P (other_method)
120f0c10
TT		 5844 && method_name == other_name
5845 && method_sig == s
5846 && !METHOD_ABSTRACT (other_method))
165f37bc
APB		 5847 {
5848 found = 1;
5849 break;
5850 }
5851 }
5852 other_super = CLASSTYPE_SUPER (other_super);
5853 } while (!end_type_reached);
5854
d77613be
APB		 5855 /* Report that abstract METHOD didn't find an implementation
5856 that CLASS can use. */
5857 if (!found)
5858 {
c2e3db92 5859 char *t = xstrdup (lang_printable_name
d77613be
APB		 5860 (TREE_TYPE (TREE_TYPE (method)), 0));
5861 tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
5862 tree saved_wfl = NULL_TREE;
5863
5864 if (TREE_CODE (DECL_NAME (method)) == EXPR_WITH_FILE_LOCATION)
5865 {
5866 saved_wfl = DECL_NAME (method);
5867 DECL_NAME (method) = EXPR_WFL_NODE (DECL_NAME (method));
5868 }
5869
5870 parse_error_context
5871 (lookup_cl (class_decl),
781b0558 5872 "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		 5873 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
5874 t, lang_printable_name (method, 0),
5875 (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
5876 "interface" : "class"),
5877 IDENTIFIER_POINTER (ccn),
5878 (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
5879 IDENTIFIER_POINTER (DECL_NAME (class_decl)));
5880
5881 free (t);
5882
5883 if (saved_wfl)
5884 DECL_NAME (method) = saved_wfl;
5885 }
5886 }
5887}
5888
614eaae0 5889/* Check that CLASS_DECL somehow implements all inherited abstract
d77613be
APB		 5890 methods. */
5891
5892static void
5893java_check_abstract_method_definitions (class_decl)
5894 tree class_decl;
5895{
5896 tree class = TREE_TYPE (class_decl);
5897 tree super, vector;
5898 int i;
5899
5900 if (CLASS_ABSTRACT (class_decl))
5901 return;
5902
5903 /* Check for inherited types */
165f37bc
APB		 5904 super = class;
5905 do {
5906 super = CLASSTYPE_SUPER (super);
5907 check_abstract_method_definitions (0, class_decl, super);
5908 } while (super != object_type_node);
d77613be
APB		 5909
5910 /* Check for implemented interfaces. */
5911 vector = TYPE_BINFO_BASETYPES (class);
5912 for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
5913 {
5914 super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
5915 check_abstract_method_definitions (1, class_decl, super);
5916 }
5917}
5918
165f37bc
APB		 5919/* Check all the types method DECL uses and return 1 if all of them
5920 are now complete, 0 otherwise. This is used to check whether its
5921 safe to build a method signature or not. */
5922
5923static int
5924check_method_types_complete (decl)
5925 tree decl;
5926{
5927 tree type = TREE_TYPE (decl);
5928 tree args;
5929
5930 if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
5931 return 0;
5932
5933 args = TYPE_ARG_TYPES (type);
5934 if (TREE_CODE (type) == METHOD_TYPE)
5935 args = TREE_CHAIN (args);
5936 for (; args != end_params_node; args = TREE_CHAIN (args))
5937 if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
5938 return 0;
5939
5940 return 1;
5941}
5942
d77613be
APB		 5943/* Check all the methods of CLASS_DECL. Methods are first completed
5944 then checked according to regular method existance rules. If no
5945 constructor for CLASS_DECL were encountered, then build its
5946 declaration. */
e04a16fb
AG		 5947
5948static void
5949java_check_regular_methods (class_decl)
5950 tree class_decl;
5951{
c2952b01 5952 int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
e04a16fb
AG		 5953 tree method;
5954 tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl));
5e942c50 5955 tree saved_found_wfl = NULL_TREE, found = NULL_TREE;
c877974e
APB		 5956 tree mthrows;
5957
5958 /* It is not necessary to check methods defined in java.lang.Object */
5959 if (class == object_type_node)
5960 return;
e04a16fb 5961
23a79c61
APB		 5962 if (!TYPE_NVIRTUALS (class))
5963 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
e04a16fb
AG		 5964
5965 /* Should take interfaces into account. FIXME */
5966 for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
5967 {
5e942c50 5968 tree sig;
e04a16fb
AG		 5969 tree method_wfl = DECL_NAME (method);
5970 int aflags;
5971
5e942c50
APB		 5972 /* If we previously found something and its name was saved,
5973 reinstall it now */
5974 if (found && saved_found_wfl)
ba179f9f
APB		 5975 {
5976 DECL_NAME (found) = saved_found_wfl;
5977 saved_found_wfl = NULL_TREE;
5978 }
5e942c50 5979
e04a16fb
AG		 5980 /* Check for redefinitions */
5981 if (check_method_redefinition (class, method))
5982 continue;
5983
22eed1e6
APB		 5984 /* If we see one constructor a mark so we don't generate the
5985 default one. Also skip other verifications: constructors
5986 can't be inherited hence hiden or overriden */
5987 if (DECL_CONSTRUCTOR_P (method))
5988 {
5989 saw_constructor = 1;
5990 continue;
5991 }
5992
c877974e
APB		 5993 /* We verify things thrown by the method. They must inherits from
5994 java.lang.Throwable */
5995 for (mthrows = DECL_FUNCTION_THROWS (method);
5996 mthrows; mthrows = TREE_CHAIN (mthrows))
5997 {
5998 if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
5999 parse_error_context
781b0558 6000 (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
c877974e
APB		 6001 IDENTIFIER_POINTER
6002 (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6003 }
6004
e04a16fb 6005 sig = build_java_argument_signature (TREE_TYPE (method));
614eaae0 6006 found = lookup_argument_method2 (class, DECL_NAME (method), sig);
b9f7e36c 6007
c2952b01
APB		 6008 /* Inner class can't declare static methods */
6009 if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6010 {
6011 char *t = xstrdup (lang_printable_name (class, 0));
6012 parse_error_context
6013 (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6014 lang_printable_name (method, 0), t);
6015 free (t);
6016 }
6017
5e942c50 6018 /* Nothing overrides or it's a private method. */
aabd7048 6019 if (!found)
5e942c50 6020 continue;
aabd7048
PB		 6021 if (METHOD_PRIVATE (found))
6022 {
6023 found = NULL_TREE;
6024 continue;
6025 }
5e942c50
APB		 6026
6027 /* If found wasn't verified, it's DECL_NAME won't be set properly.
6028 We set it temporarily for the sake of the error report. */
6029 saved_found_wfl = DECL_NAME (found);
6030 reset_method_name (found);
6031
614eaae0
APB		 6032 /* If `found' is declared in an interface, make sure the
6033 modifier matches. */
6034 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6035 && clinit_identifier_node != DECL_NAME (found)
6036 && !METHOD_PUBLIC (method))
6037 {
6038 tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6039 parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6040 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6041 lang_printable_name (method, 0),
6042 IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6043 }
6044
e04a16fb
AG		 6045 /* Can't override a method with the same name and different return
6046 types. */
6047 if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
b9f7e36c 6048 {
614eaae0
APB		 6049 char *t = xstrdup
6050 (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
b9f7e36c 6051 parse_error_context
7f10c2e2 6052 (method_wfl,
b9f7e36c 6053 "Method `%s' was defined with return type `%s' in class `%s'",
0a2138e2 6054 lang_printable_name (found, 0), t,
b9f7e36c
APB		 6055 IDENTIFIER_POINTER
6056 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6057 free (t);
6058 }
e04a16fb 6059
7f10c2e2
APB		 6060 aflags = get_access_flags_from_decl (found);
6061 /* If the method has default, access in an other package, then
6062 issue a warning that the current method doesn't override the
6063 one that was found elsewhere. Do not issue this warning when
6064 the match was found in java.lang.Object. */
6065 if (DECL_CONTEXT (found) != object_type_node
a003f638 6066 && ((aflags & ACC_VISIBILITY) == 0)
7f10c2e2 6067 && !class_in_current_package (DECL_CONTEXT (found))
c2952b01 6068 && !DECL_CLINIT_P (found)
7f10c2e2
APB		 6069 && flag_not_overriding)
6070 {
6071 parse_warning_context
781b0558 6072 (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		 6073 lang_printable_name (found, 0),
6074 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6075 IDENTIFIER_POINTER (DECL_NAME
6076 (TYPE_NAME (DECL_CONTEXT (found)))));
6077 continue;
6078 }
6079
e04a16fb
AG		 6080 /* Can't override final. Can't override static. */
6081 if (METHOD_FINAL (found) || METHOD_STATIC (found))
6082 {
6083 /* Static *can* override static */
6084 if (METHOD_STATIC (found) && METHOD_STATIC (method))
6085 continue;
6086 parse_error_context
6087 (method_wfl,
6088 "%s methods can't be overriden. Method `%s' is %s in class `%s'",
6089 (METHOD_FINAL (found) ? "Final" : "Static"),
0a2138e2 6090 lang_printable_name (found, 0),
e04a16fb
AG		 6091 (METHOD_FINAL (found) ? "final" : "static"),
6092 IDENTIFIER_POINTER
6093 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6094 continue;
6095 }
7f10c2e2 6096
e04a16fb
AG		 6097 /* Static method can't override instance method. */
6098 if (METHOD_STATIC (method))
6099 {
6100 parse_error_context
6101 (method_wfl,
781b0558 6102 "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
0a2138e2 6103 lang_printable_name (found, 0),
e04a16fb
AG		 6104 IDENTIFIER_POINTER
6105 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6106 continue;
6107 }
5e942c50 6108
5e942c50
APB		 6109 /* - Overriding/hiding public must be public
6110 - Overriding/hiding protected must be protected or public
6111 - If the overriden or hidden method has default (package)
6112 access, then the overriding or hiding method must not be
614eaae0
APB		 6113 private; otherwise, a compile-time error occurs. If
6114 `found' belongs to an interface, things have been already
6115 taken care of. */
6116 if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6117 && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6118 || (METHOD_PROTECTED (found)
6119 && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6120 || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6121 && METHOD_PRIVATE (method))))
e04a16fb
AG		 6122 {
6123 parse_error_context
6124 (method_wfl,
781b0558 6125 "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
5e942c50
APB		 6126 (METHOD_PUBLIC (method) ? "public" :
6127 (METHOD_PRIVATE (method) ? "private" : "protected")),
6128 IDENTIFIER_POINTER (DECL_NAME
6129 (TYPE_NAME (DECL_CONTEXT (found)))));
e04a16fb
AG		 6130 continue;
6131 }
6132
b9f7e36c
APB		 6133 /* Overriding methods must have compatible `throws' clauses on checked
6134 exceptions, if any */
6135 check_throws_clauses (method, method_wfl, found);
6136
e04a16fb
AG		 6137 /* Inheriting multiple methods with the same signature. FIXME */
6138 }
6139
5e942c50
APB		 6140 /* Don't forget eventual pending found and saved_found_wfl. Take
6141 into account that we might have exited because we saw an
d77613be 6142 artificial method as the last entry. */
5e942c50
APB		 6143
6144 if (found && !DECL_ARTIFICIAL (found) && saved_found_wfl)
6145 DECL_NAME (found) = saved_found_wfl;
6146
23a79c61
APB		 6147 if (!TYPE_NVIRTUALS (class))
6148 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
e04a16fb 6149
d77613be
APB		 6150 /* Search for inherited abstract method not yet implemented in this
6151 class. */
6152 java_check_abstract_method_definitions (class_decl);
6153
22eed1e6 6154 if (!saw_constructor)
e920ebc9 6155 fatal ("No constructor found");
e04a16fb
AG		 6156}
6157
b9f7e36c
APB		 6158/* Return a non zero value if the `throws' clause of METHOD (if any)
6159 is incompatible with the `throws' clause of FOUND (if any). */
6160
6161static void
6162check_throws_clauses (method, method_wfl, found)
6163 tree method, method_wfl, found;
6164{
6165 tree mthrows, fthrows;
6166
c877974e
APB		 6167 /* Can't check these things with class loaded from bytecode. FIXME */
6168 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6169 return;
6170
b9f7e36c
APB		 6171 for (mthrows = DECL_FUNCTION_THROWS (method);
6172 mthrows; mthrows = TREE_CHAIN (mthrows))
6173 {
6174 /* We don't verify unchecked expressions */
c877974e 6175 if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
b9f7e36c
APB		 6176 continue;
6177 /* Checked expression must be compatible */
6178 for (fthrows = DECL_FUNCTION_THROWS (found);
6179 fthrows; fthrows = TREE_CHAIN (fthrows))
6180 if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6181 break;
6182 if (!fthrows)
6183 {
6184 parse_error_context
781b0558 6185 (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 6186 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
0a2138e2 6187 lang_printable_name (found, 0),
b9f7e36c
APB		 6188 IDENTIFIER_POINTER
6189 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6190 }
6191 }
6192}
6193
e04a16fb
AG		 6194/* Check abstract method of interface INTERFACE */
6195
6196static void
5e942c50
APB		 6197java_check_abstract_methods (interface_decl)
6198 tree interface_decl;
e04a16fb
AG		 6199{
6200 int i, n;
6201 tree method, basetype_vec, found;
5e942c50 6202 tree interface = TREE_TYPE (interface_decl);
e04a16fb
AG		 6203
6204 for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6205 {
b9f7e36c 6206 tree method_wfl = DECL_NAME (method);
e04a16fb
AG		 6207
6208 /* 2- Check for double definition inside the defining interface */
6209 if (check_method_redefinition (interface, method))
6210 continue;
6211
6212 /* 3- Overriding is OK as far as we preserve the return type and
b9f7e36c 6213 the thrown exceptions (FIXME) */
e04a16fb
AG		 6214 found = lookup_java_interface_method2 (interface, method);
6215 if (found)
6216 {
5e942c50
APB		 6217 char *t;
6218 tree saved_found_wfl = DECL_NAME (found);
6219 reset_method_name (found);
c2e3db92 6220 t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
e04a16fb 6221 parse_error_context
b9f7e36c 6222 (method_wfl,
5e942c50 6223 "Method `%s' was defined with return type `%s' in class `%s'",
0a2138e2 6224 lang_printable_name (found, 0), t,
b9f7e36c
APB		 6225 IDENTIFIER_POINTER
6226 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6227 free (t);
5e942c50 6228 DECL_NAME (found) = saved_found_wfl;
c63b98cd 6229 continue;
e04a16fb
AG		 6230 }
6231 }
6232
6233 /* 4- Inherited methods can't differ by their returned types */
6234 if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6235 return;
6236 n = TREE_VEC_LENGTH (basetype_vec);
6237 for (i = 0; i < n; i++)
6238 {
6239 tree sub_interface_method, sub_interface;
6240 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6241 if (!vec_elt)
6242 continue;
6243 sub_interface = BINFO_TYPE (vec_elt);
6244 for (sub_interface_method = TYPE_METHODS (sub_interface);
6245 sub_interface_method;
6246 sub_interface_method = TREE_CHAIN (sub_interface_method))
6247 {
6248 found = lookup_java_interface_method2 (interface,
6249 sub_interface_method);
6250 if (found && (found != sub_interface_method))
5e942c50
APB		 6251 {
6252 tree saved_found_wfl = DECL_NAME (found);
6253 reset_method_name (found);
6254 parse_error_context
6255 (lookup_cl (sub_interface_method),
781b0558 6256 "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
5e942c50
APB		 6257 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6258 lang_printable_name (found, 0),
6259 IDENTIFIER_POINTER
6260 (DECL_NAME (TYPE_NAME
6261 (DECL_CONTEXT (sub_interface_method)))),
6262 IDENTIFIER_POINTER
6263 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6264 DECL_NAME (found) = saved_found_wfl;
6265 }
e04a16fb
AG		 6266 }
6267 }
6268}
6269
e04a16fb
AG		 6270/* Lookup methods in interfaces using their name and partial
6271 signature. Return a matching method only if their types differ. */
6272
6273static tree
6274lookup_java_interface_method2 (class, method_decl)
6275 tree class, method_decl;
6276{
6277 int i, n;
6278 tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6279
6280 if (!basetype_vec)
6281 return NULL_TREE;
6282
6283 n = TREE_VEC_LENGTH (basetype_vec);
6284 for (i = 0; i < n; i++)
6285 {
6286 tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6287 if ((BINFO_TYPE (vec_elt) != object_type_node)
6288 && (to_return =
6289 lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6290 return to_return;
6291 }
6292 for (i = 0; i < n; i++)
6293 {
6294 to_return = lookup_java_interface_method2
6295 (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6296 if (to_return)
6297 return to_return;
6298 }
6299
6300 return NULL_TREE;
6301}
6302
6303/* Lookup method using their name and partial signature. Return a
6304 matching method only if their types differ. */
6305
6306static tree
6307lookup_java_method2 (clas, method_decl, do_interface)
6308 tree clas, method_decl;
6309 int do_interface;
6310{
5e942c50
APB		 6311 tree method, method_signature, method_name, method_type, name;
6312
e04a16fb 6313 method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
5e942c50
APB		 6314 name = DECL_NAME (method_decl);
6315 method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6316 EXPR_WFL_NODE (name) : name);
e04a16fb
AG		 6317 method_type = TREE_TYPE (TREE_TYPE (method_decl));
6318
6319 while (clas != NULL_TREE)
6320 {
6321 for (method = TYPE_METHODS (clas);
6322 method != NULL_TREE; method = TREE_CHAIN (method))
6323 {
6324 tree method_sig = build_java_argument_signature (TREE_TYPE (method));
5e942c50
APB		 6325 tree name = DECL_NAME (method);
6326 if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6327 EXPR_WFL_NODE (name) : name) == method_name
e04a16fb
AG		 6328 && method_sig == method_signature
6329 && TREE_TYPE (TREE_TYPE (method)) != method_type)
5e942c50 6330 return method;
e04a16fb
AG		 6331 }
6332 clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6333 }
6334 return NULL_TREE;
6335}
6336
f441f671
APB		 6337/* Return the line that matches DECL line number, and try its best to
6338 position the column number. Used during error reports. */
e04a16fb
AG		 6339
6340static tree
6341lookup_cl (decl)
6342 tree decl;
6343{
6344 static tree cl = NULL_TREE;
f441f671 6345 char *line, *found;
e04a16fb
AG		 6346
6347 if (!decl)
6348 return NULL_TREE;
6349
6350 if (cl == NULL_TREE)
6351 cl = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6352
6353 EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl));
6354 EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1);
6355
f441f671
APB		 6356 line = java_get_line_col (IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE (cl)),
6357 EXPR_WFL_LINENO (cl), EXPR_WFL_COLNO (cl));
6358
6359 found = strstr ((const char *)line,
6360 (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6361 if (found)
6362 EXPR_WFL_SET_LINECOL (cl, EXPR_WFL_LINENO (cl), found - line);
6363
e04a16fb
AG		 6364 return cl;
6365}
6366
6367/* Look for a simple name in the single-type import list */
6368
6369static tree
6370find_name_in_single_imports (name)
6371 tree name;
6372{
6373 tree node;
6374
6375 for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6376 if (TREE_VALUE (node) == name)
6377 return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6378
6379 return NULL_TREE;
6380}
6381
6382/* Process all single-type import. */
6383
6384static int
6385process_imports ()
6386{
6387 tree import;
6388 int error_found;
6389
6390 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6391 {
6392 tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6393
6394 /* Don't load twice something already defined. */
6395 if (IDENTIFIER_CLASS_VALUE (to_be_found))
6396 continue;
6397 QUALIFIED_P (to_be_found) = 1;
6398 load_class (to_be_found, 0);
6399 error_found =
6400 check_pkg_class_access (to_be_found, TREE_PURPOSE (import));
6401 if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6402 {
6403 parse_error_context (TREE_PURPOSE (import),
6404 "Class or interface `%s' not found in import",
6405 IDENTIFIER_POINTER (to_be_found));
6406 return 1;
6407 }
6408 if (error_found)
6409 return 1;
6410 }
6411 return 0;
6412}
6413
9a7ab4b3
APB		 6414/* Possibly find and mark a class imported by a single-type import
6415 statement. */
e04a16fb 6416
9a7ab4b3 6417static void
e04a16fb
AG		 6418find_in_imports (class_type)
6419 tree class_type;
6420{
6421 tree import;
6422
6423 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6424 if (TREE_VALUE (import) == TYPE_NAME (class_type))
6425 {
6426 TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6427 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
e04a16fb 6428 }
e04a16fb
AG		 6429}
6430
e04a16fb 6431static int
63a212ed 6432note_possible_classname (name, len)
49f48c71 6433 const char *name;
63a212ed 6434 int len;
e04a16fb 6435{
63a212ed
PB		 6436 tree node;
6437 if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6438 len = len - 5;
6439 else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6440 len = len - 6;
e04a16fb 6441 else
63a212ed
PB		 6442 return 0;
6443 node = ident_subst (name, len, "", '/', '.', "");
6444 IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
fe0e4d76 6445 QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
63a212ed 6446 return 1;
e04a16fb
AG		 6447}
6448
6449/* Read a import directory, gathering potential match for further type
6450 references. Indifferently reads a filesystem or a ZIP archive
6451 directory. */
6452
6453static void
6454read_import_dir (wfl)
6455 tree wfl;
6456{
63a212ed 6457 tree package_id = EXPR_WFL_NODE (wfl);
49f48c71 6458 const char *package_name = IDENTIFIER_POINTER (package_id);
63a212ed 6459 int package_length = IDENTIFIER_LENGTH (package_id);
e04a16fb 6460 DIR *dirp = NULL;
d8fccff5 6461 JCF *saved_jcf = current_jcf;
e04a16fb 6462
63a212ed
PB		 6463 int found = 0;
6464 int k;
6465 void *entry;
6466 struct buffer filename[1];
6467
6468
6469 if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6470 return;
6471 IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6472
6473 BUFFER_INIT (filename);
6474 buffer_grow (filename, package_length + 100);
6475
6476 for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6477 {
49f48c71 6478 const char *entry_name = jcf_path_name (entry);
63a212ed
PB		 6479 int entry_length = strlen (entry_name);
6480 if (jcf_path_is_zipfile (entry))
6481 {
6482 ZipFile *zipf;
6483 buffer_grow (filename, entry_length);
6484 memcpy (filename->data, entry_name, entry_length - 1);
6485 filename->data[entry_length-1] = '\0';
6486 zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6487 if (zipf == NULL)
6488 error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6489 else
6490 {
6491 ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6492 BUFFER_RESET (filename);
6493 for (k = 0; k < package_length; k++)
6494 {
6495 char ch = package_name[k];
6496 *filename->ptr++ = ch == '.' ? '/' : ch;
6497 }
6498 *filename->ptr++ = '/';
6499
345137c7 6500 for (k = 0; k < zipf->count; k++, zipd = ZIPDIR_NEXT (zipd))
63a212ed 6501 {
49f48c71 6502 const char *current_entry = ZIPDIR_FILENAME (zipd);
63a212ed
PB		 6503 int current_entry_len = zipd->filename_length;
6504
345137c7
TT		 6505 if (current_entry_len >= BUFFER_LENGTH (filename)
6506 && strncmp (filename->data, current_entry,
6507 BUFFER_LENGTH (filename)) != 0)
63a212ed 6508 continue;
345137c7 6509 found |= note_possible_classname (current_entry,
63a212ed
PB		 6510 current_entry_len);
6511 }
6512 }
6513 }
6514 else
6515 {
6516 BUFFER_RESET (filename);
6517 buffer_grow (filename, entry_length + package_length + 4);
6518 strcpy (filename->data, entry_name);
6519 filename->ptr = filename->data + entry_length;
6520 for (k = 0; k < package_length; k++)
6521 {
6522 char ch = package_name[k];
6523 *filename->ptr++ = ch == '.' ? '/' : ch;
6524 }
6525 *filename->ptr = '\0';
6526
6527 dirp = opendir (filename->data);
6528 if (dirp == NULL)
6529 continue;
6530 *filename->ptr++ = '/';
6531 for (;;)
6532 {
63a212ed 6533 int len;
49f48c71 6534 const char *d_name;
63a212ed
PB		 6535 struct dirent *direntp = readdir (dirp);
6536 if (!direntp)
6537 break;
6538 d_name = direntp->d_name;
6539 len = strlen (direntp->d_name);
6540 buffer_grow (filename, len+1);
6541 strcpy (filename->ptr, d_name);
345137c7 6542 found |= note_possible_classname (filename->data + entry_length,
63a212ed
PB		 6543 package_length+len+1);
6544 }
6545 if (dirp)
6546 closedir (dirp);
6547 }
6548 }
e04a16fb 6549
63a212ed 6550 free (filename->data);
e04a16fb 6551
63a212ed
PB		 6552 /* Here we should have a unified way of retrieving an entry, to be
6553 indexed. */
6554 if (!found)
e04a16fb
AG		 6555 {
6556 static int first = 1;
6557 if (first)
6558 {
781b0558 6559 error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives.", package_name);
e04a16fb
AG		 6560 java_error_count++;
6561 first = 0;
6562 }
6563 else
63a212ed
PB		 6564 parse_error_context (wfl, "Package `%s' not found in import",
6565 package_name);
e04a16fb
AG		 6566 current_jcf = saved_jcf;
6567 return;
6568 }
e04a16fb
AG		 6569 current_jcf = saved_jcf;
6570}
6571
6572/* Possibly find a type in the import on demands specified
6573 types. Returns 1 if an error occured, 0 otherwise. Run throught the
6574 entire list, to detected potential double definitions. */
6575
6576static int
6577find_in_imports_on_demand (class_type)
6578 tree class_type;
6579{
ab3a6dd6 6580 tree node, import, node_to_use = NULL_TREE;
e04a16fb 6581 int seen_once = -1;
ab3a6dd6 6582 tree cl = NULL_TREE;
e04a16fb
AG		 6583
6584 for (import = ctxp->import_demand_list; import; import = TREE_CHAIN (import))
6585 {
49f48c71 6586 const char *id_name;
e04a16fb
AG		 6587 obstack_grow (&temporary_obstack,
6588 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
6589 IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
63a212ed 6590 obstack_1grow (&temporary_obstack, '.');
e04a16fb
AG		 6591 obstack_grow0 (&temporary_obstack,
6592 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
6593 IDENTIFIER_LENGTH (TYPE_NAME (class_type)));
6594 id_name = obstack_finish (&temporary_obstack);
6595
6596 node = maybe_get_identifier (id_name);
6597 if (node && IS_A_CLASSFILE_NAME (node))
6598 {
6599 if (seen_once < 0)
6600 {
6601 cl = TREE_PURPOSE (import);
6602 seen_once = 1;
6603 node_to_use = node;
6604 }
6605 else
6606 {
6607 seen_once++;
6608 parse_error_context
6609 (import, "Type `%s' also potentially defined in package `%s'",
6610 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
6611 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))));
6612 }
6613 }
6614 }
6615
6616 if (seen_once == 1)
6617 {
6618 /* Setup lineno so that it refers to the line of the import (in
6619 case we parse a class file and encounter errors */
6620 tree decl;
6621 int saved_lineno = lineno;
6622 lineno = EXPR_WFL_LINENO (cl);
63a212ed 6623 TYPE_NAME (class_type) = node_to_use;
e04a16fb
AG		 6624 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6625 decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
6626 /* If there is no DECL set for the class or if the class isn't
6627 loaded and not seen in source yet, the load */
6628 if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
6629 && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
6630 load_class (node_to_use, 0);
6631 lineno = saved_lineno;
6632 return check_pkg_class_access (TYPE_NAME (class_type), cl);
6633 }
6634 else
6635 return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
6636}
6637
9a7ab4b3
APB		 6638/* Add package NAME to the list of package encountered so far. To
6639 speed up class lookup in do_resolve_class, we make sure a
6640 particular package is added only once. */
6641
6642static void
6643register_package (name)
6644 tree name;
6645{
6646 static struct hash_table _pht, *pht = NULL;
6647
6648 if (!pht)
6649 {
6650 hash_table_init (&_pht, hash_newfunc,
6651 java_hash_hash_tree_node, java_hash_compare_tree_node);
6652 pht = &_pht;
6653 }
6654
6655 if (!hash_lookup (pht, (const hash_table_key) name, FALSE, NULL))
6656 {
6657 package_list = chainon (package_list, build_tree_list (name, NULL));
6658 hash_lookup (pht, (const hash_table_key) name, TRUE, NULL);
6659 }
6660}
6661
5e942c50
APB		 6662static tree
6663resolve_package (pkg, next)
6664 tree pkg, *next;
6665{
c2952b01 6666 tree current, acc;
5e942c50 6667 tree type_name = NULL_TREE;
49f48c71 6668 const char *name = IDENTIFIER_POINTER (EXPR_WFL_NODE (pkg));
5e942c50
APB		 6669
6670 /* The trick is to determine when the package name stops and were
6671 the name of something contained in the package starts. Then we
6672 return a fully qualified name of what we want to get. */
6673
6674 /* Do a quick search on well known package names */
6675 if (!strncmp (name, "java.lang.reflect", 17))
6676 {
6677 *next =
6678 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg))));
6679 type_name = lookup_package_type (name, 17);
6680 }
6681 else if (!strncmp (name, "java.lang", 9))
6682 {
6683 *next = TREE_CHAIN (TREE_CHAIN (EXPR_WFL_QUALIFICATION (pkg)));
6684 type_name = lookup_package_type (name, 9);
6685 }
5e942c50 6686
2c56429a
APB		 6687 /* If we found something here, return */
6688 if (type_name)
6689 return type_name;
6690
6691 *next = EXPR_WFL_QUALIFICATION (pkg);
6692
6693 /* Try the current package. */
6694 if (ctxp->package && !strncmp (name, IDENTIFIER_POINTER (ctxp->package),
6695 IDENTIFIER_LENGTH (ctxp->package)))
6696 {
6697 type_name =
6698 lookup_package_type_and_set_next (name,
6699 IDENTIFIER_LENGTH (ctxp->package),
6700 next );
6701 if (type_name)
6702 return type_name;
6703 }
6704
6705 /* Search in imported package */
6706 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
6707 {
6708 tree current_pkg_name = EXPR_WFL_NODE (TREE_PURPOSE (current));
6709 int len = IDENTIFIER_LENGTH (current_pkg_name);
6710 if (!strncmp (name, IDENTIFIER_POINTER (current_pkg_name), len))
6711 {
6712 tree left, dummy;
6713
6714 breakdown_qualified (&left, &dummy, current_pkg_name);
6715 len = IDENTIFIER_LENGTH (left);
6716 type_name = lookup_package_type_and_set_next (name, len, next);
6717 if (type_name)
6718 break;
6719 }
6720 }
6721
c2952b01
APB		 6722 /* Try to progressively construct a type name */
6723 if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
6724 for (acc = NULL_TREE, current = EXPR_WFL_QUALIFICATION (pkg);
6725 current; current = TREE_CHAIN (current))
6726 {
6727 acc = merge_qualified_name (acc, EXPR_WFL_NODE (QUAL_WFL (current)));
6728 if ((type_name = resolve_no_layout (acc, NULL_TREE)))
6729 {
6730 type_name = acc;
6b48deee
APB		 6731 /* resolve_package should be used in a loop, hence we
6732 point at this one to naturally process the next one at
6733 the next iteration. */
6734 *next = current;
c2952b01
APB		 6735 break;
6736 }
6737 }
2c56429a
APB		 6738 return type_name;
6739}
6740
6741static tree
6742lookup_package_type_and_set_next (name, len, next)
49f48c71 6743 const char *name;
2c56429a
APB		 6744 int len;
6745 tree *next;
6746{
49f48c71 6747 const char *ptr;
2c56429a
APB		 6748 tree type_name = lookup_package_type (name, len);
6749
6750 if (!type_name)
6751 return NULL;
6752
6753 ptr = IDENTIFIER_POINTER (type_name);
6754 while (ptr && (ptr = strchr (ptr, '.')))
6755 {
6756 *next = TREE_CHAIN (*next);
6757 ptr++;
6758 }
5e942c50
APB		 6759 return type_name;
6760}
6761
6762static tree
6763lookup_package_type (name, from)
49f48c71 6764 const char *name;
5e942c50
APB		 6765 int from;
6766{
6767 char subname [128];
49f48c71 6768 const char *sub = &name[from+1];
5e942c50
APB		 6769 while (*sub != '.' && *sub)
6770 sub++;
6771 strncpy (subname, name, sub-name);
6772 subname [sub-name] = '\0';
6773 return get_identifier (subname);
6774}
6775
cf1748bf
APB		 6776static void
6777check_inner_class_access (decl, enclosing_type, cl)
6778 tree decl, enclosing_type, cl;
6779{
6780 /* We don't issue an error message when CL is null. CL can be null
6781 as a result of processing a JDEP crafted by
6782 source_start_java_method for the purpose of patching its parm
6783 decl. But the error would have been already trapped when fixing
6784 the method's signature. */
6785 if (!(cl && PURE_INNER_CLASS_DECL_P (decl) && CLASS_PRIVATE (decl))
6786 || (PURE_INNER_CLASS_DECL_P (enclosing_type)
6787 && common_enclosing_context_p (TREE_TYPE (enclosing_type),
6788 TREE_TYPE (decl)))
6789 || enclosing_context_p (TREE_TYPE (enclosing_type), TREE_TYPE (decl)))
6790 return;
6791
6792 parse_error_context (cl, "Can't access nested %s %s. Only public classes and interfaces in other packages can be accessed",
6793 (CLASS_INTERFACE (decl) ? "interface" : "class"),
6794 lang_printable_name (decl, 0));
6795}
6796
e04a16fb
AG		 6797/* Check that CLASS_NAME refers to a PUBLIC class. Return 0 if no
6798 access violations were found, 1 otherwise. */
6799
6800static int
6801check_pkg_class_access (class_name, cl)
6802 tree class_name;
6803 tree cl;
6804{
6805 tree type;
e04a16fb
AG		 6806
6807 if (!QUALIFIED_P (class_name) || !IDENTIFIER_CLASS_VALUE (class_name))
6808 return 0;
6809
6810 if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
6811 return 0;
6812
6813 if (!CLASS_PUBLIC (TYPE_NAME (type)))
6814 {
e28cd97b
APB		 6815 /* Access to a private class within the same package is
6816 allowed. */
6817 tree l, r;
6818 breakdown_qualified (&l, &r, class_name);
6819 if (l == ctxp->package)
6820 return 0;
6821
e04a16fb 6822 parse_error_context
781b0558 6823 (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
e04a16fb
AG		 6824 (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
6825 IDENTIFIER_POINTER (class_name));
6826 return 1;
6827 }
6828 return 0;
6829}
6830
6831/* Local variable declaration. */
6832
6833static void
6834declare_local_variables (modifier, type, vlist)
6835 int modifier;
6836 tree type;
6837 tree vlist;
6838{
c583dd46
APB		 6839 tree decl, current, saved_type;
6840 tree type_wfl = NULL_TREE;
e04a16fb 6841 int must_chain = 0;
c2952b01 6842 int final_p = 0;
e04a16fb 6843
2aa11e97 6844 /* Push a new block if statements were seen between the last time we
e04a16fb 6845 pushed a block and now. Keep a cound of block to close */
f099f336 6846 if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
e04a16fb 6847 {
f099f336 6848 tree body = GET_CURRENT_BLOCK (current_function_decl);
e04a16fb 6849 tree b = enter_block ();
f099f336 6850 BLOCK_EXPR_ORIGIN (b) = body;
e04a16fb
AG		 6851 }
6852
6853 if (modifier)
6854 {
6855 int i;
6856 for (i = 0; i <= 10; i++) if (1 << i & modifier) break;
c877974e 6857 if (modifier == ACC_FINAL)
c2952b01 6858 final_p = 1;
c877974e
APB		 6859 else
6860 {
6861 parse_error_context
6862 (ctxp->modifier_ctx [i],
6863 "Only `final' is allowed as a local variables modifier");
6864 return;
6865 }
e04a16fb
AG		 6866 }
6867
c583dd46
APB		 6868 /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
6869 hold the TYPE value if a new incomplete has to be created (as
6870 opposed to being found already existing and reused). */
6871 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
6872
6873 /* If TYPE is fully resolved and we don't have a reference, make one */
1886c9d8 6874 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
c583dd46
APB		 6875
6876 /* Go through all the declared variables */
6877 for (current = vlist, saved_type = type; current;
6878 current = TREE_CHAIN (current), type = saved_type)
e04a16fb 6879 {
c877974e 6880 tree other, real_type;
e04a16fb
AG		 6881 tree wfl = TREE_PURPOSE (current);
6882 tree name = EXPR_WFL_NODE (wfl);
6883 tree init = TREE_VALUE (current);
e04a16fb 6884
c583dd46
APB		 6885 /* Process NAME, as it may specify extra dimension(s) for it */
6886 type = build_array_from_name (type, type_wfl, name, &name);
6887
6888 /* Variable redefinition check */
6889 if ((other = lookup_name_in_blocks (name)))
6890 {
6891 variable_redefinition_error (wfl, name, TREE_TYPE (other),
6892 DECL_SOURCE_LINE (other));
6893 continue;
6894 }
6895
6896 /* Type adjustment. We may have just readjusted TYPE because
6897 the variable specified more dimensions. Make sure we have
6898 a reference if we can and don't have one already. */
1886c9d8 6899 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
c877974e
APB		 6900
6901 real_type = GET_REAL_TYPE (type);
c583dd46
APB		 6902 /* Never layout this decl. This will be done when its scope
6903 will be entered */
c877974e 6904 decl = build_decl (VAR_DECL, name, real_type);
c2952b01 6905 LOCAL_FINAL (decl) = final_p;
c583dd46
APB		 6906 BLOCK_CHAIN_DECL (decl);
6907
d4370213
APB		 6908 /* If doing xreferencing, replace the line number with the WFL
6909 compound value */
6910 if (flag_emit_xref)
6911 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
6912
e04a16fb
AG		 6913 /* Don't try to use an INIT statement when an error was found */
6914 if (init && java_error_count)
6915 init = NULL_TREE;
c583dd46
APB		 6916
6917 /* Add the initialization function to the current function's code */
6918 if (init)
e04a16fb 6919 {
c583dd46
APB		 6920 /* Name might have been readjusted */
6921 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
6922 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
6923 java_method_add_stmt (current_function_decl,
6924 build_debugable_stmt (EXPR_WFL_LINECOL (init),
6925 init));
6926 }
6927
6928 /* Setup dependency the type of the decl */
6929 if (must_chain)
6930 {
6931 jdep *dep;
6932 register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
6933 dep = CLASSD_LAST (ctxp->classd_list);
6934 JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
e04a16fb
AG		 6935 }
6936 }
6937 SOURCE_FRONTEND_DEBUG (("Defined locals"));
6938}
6939
6940/* Called during parsing. Build decls from argument list. */
6941
6942static void
6943source_start_java_method (fndecl)
6944 tree fndecl;
6945{
6946 tree tem;
6947 tree parm_decl;
6948 int i;
6949
79d13333
APB		 6950 if (!fndecl)
6951 return;
6952
e04a16fb
AG		 6953 current_function_decl = fndecl;
6954
6955 /* New scope for the function */
6956 enter_block ();
6957 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
de4c7b02 6958 tem != end_params_node; tem = TREE_CHAIN (tem), i++)
e04a16fb
AG		 6959 {
6960 tree type = TREE_VALUE (tem);
6961 tree name = TREE_PURPOSE (tem);
6962
23a79c61
APB		 6963 /* If type is incomplete. Create an incomplete decl and ask for
6964 the decl to be patched later */
e04a16fb
AG		 6965 if (INCOMPLETE_TYPE_P (type))
6966 {
6967 jdep *jdep;
c877974e
APB		 6968 tree real_type = GET_REAL_TYPE (type);
6969 parm_decl = build_decl (PARM_DECL, name, real_type);
23a79c61 6970 type = obtain_incomplete_type (type);
e04a16fb
AG		 6971 register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
6972 jdep = CLASSD_LAST (ctxp->classd_list);
6973 JDEP_MISC (jdep) = name;
6974 JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
6975 }
6976 else
6977 parm_decl = build_decl (PARM_DECL, name, type);
6978
c2952b01
APB		 6979 /* Remember if a local variable was declared final (via its
6980 TREE_LIST of type/name.) Set LOCAL_FINAL accordingly. */
6981 if (ARG_FINAL_P (tem))
6982 LOCAL_FINAL (parm_decl) = 1;
6983
e04a16fb
AG		 6984 BLOCK_CHAIN_DECL (parm_decl);
6985 }
6986 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
6987 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
6988 nreverse (tem);
6989 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
c2952b01 6990 DECL_MAX_LOCALS (current_function_decl) = i;
e04a16fb
AG		 6991}
6992
22eed1e6
APB		 6993/* Called during parsing. Creates an artificial method declaration. */
6994
6995static tree
6996create_artificial_method (class, flags, type, name, args)
6997 tree class;
6998 int flags;
6999 tree type, name, args;
7000{
22eed1e6
APB		 7001 tree mdecl;
7002
c2952b01 7003 java_parser_context_save_global ();
22eed1e6
APB		 7004 lineno = 0;
7005 mdecl = make_node (FUNCTION_TYPE);
7006 TREE_TYPE (mdecl) = type;
7007 TYPE_ARG_TYPES (mdecl) = args;
7008 mdecl = add_method (class, flags, name, build_java_signature (mdecl));
c2952b01 7009 java_parser_context_restore_global ();
22eed1e6
APB		 7010 DECL_ARTIFICIAL (mdecl) = 1;
7011 return mdecl;
7012}
7013
7014/* Starts the body if an artifical method. */
7015
7016static void
7017start_artificial_method_body (mdecl)
7018 tree mdecl;
7019{
7020 DECL_SOURCE_LINE (mdecl) = 1;
7021 DECL_SOURCE_LINE_MERGE (mdecl, 1);
7022 source_start_java_method (mdecl);
7023 enter_block ();
7024}
7025
7026static void
7027end_artificial_method_body (mdecl)
7028 tree mdecl;
7029{
7030 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block ();
7031 exit_block ();
7032}
7033
e04a16fb
AG		 7034/* Called during expansion. Push decls formerly built from argument
7035 list so they're usable during expansion. */
7036
7037static void
7038expand_start_java_method (fndecl)
7039 tree fndecl;
7040{
7041 tree tem, *ptr;
e04a16fb 7042
e04a16fb
AG		 7043 current_function_decl = fndecl;
7044
c2952b01
APB		 7045 if (! quiet_flag)
7046 fprintf (stderr, " [%s.", lang_printable_name (DECL_CONTEXT (fndecl), 0));
e04a16fb 7047 announce_function (fndecl);
c2952b01
APB		 7048 if (! quiet_flag)
7049 fprintf (stderr, "]");
7050
7051 pushlevel (1); /* Prepare for a parameter push */
e04a16fb
AG		 7052 ptr = &DECL_ARGUMENTS (fndecl);
7053 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7054 while (tem)
7055 {
7056 tree next = TREE_CHAIN (tem);
b67d701b 7057 tree type = TREE_TYPE (tem);
e438e1b7
JJ		 7058 if (PROMOTE_PROTOTYPES
7059 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
b67d701b
PB		 7060 && INTEGRAL_TYPE_P (type))
7061 type = integer_type_node;
b67d701b 7062 DECL_ARG_TYPE (tem) = type;
e04a16fb
AG		 7063 layout_decl (tem, 0);
7064 pushdecl (tem);
e04a16fb
AG		 7065 *ptr = tem;
7066 ptr = &TREE_CHAIN (tem);
7067 tem = next;
7068 }
7069 *ptr = NULL_TREE;
7070 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
7071 lineno = DECL_SOURCE_LINE_FIRST (fndecl);
e04a16fb
AG		 7072}
7073
7074/* Terminate a function and expand its body. */
7075
7076static void
7077source_end_java_method ()
7078{
7079 tree fndecl = current_function_decl;
138657ec 7080 int flag_asynchronous_exceptions = asynchronous_exceptions;
e04a16fb 7081
79d13333
APB		 7082 if (!fndecl)
7083 return;
7084
e04a16fb
AG		 7085 java_parser_context_save_global ();
7086 lineno = ctxp->last_ccb_indent1;
7087
b67d701b
PB		 7088 /* Set EH language codes */
7089 java_set_exception_lang_code ();
7090
5423609c
APB		 7091 /* Turn function bodies with only a NOP expr null, so they don't get
7092 generated at all and we won't get warnings when using the -W
7093 -Wall flags. */
7094 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7095 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7096
e04a16fb
AG		 7097 /* Generate function's code */
7098 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
e8fc7396
APB		 7099 && ! flag_emit_class_files
7100 && ! flag_emit_xref)
e04a16fb
AG		 7101 expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
7102
7103 /* pop out of its parameters */
7104 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
7105 poplevel (1, 0, 1);
7106 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
7107
7108 /* Generate rtl for function exit. */
e8fc7396 7109 if (! flag_emit_class_files && ! flag_emit_xref)
e04a16fb
AG		 7110 {
7111 lineno = DECL_SOURCE_LINE_LAST (fndecl);
b67d701b
PB		 7112 /* Emit catch-finally clauses */
7113 emit_handlers ();
e04a16fb
AG		 7114 expand_function_end (input_filename, lineno, 0);
7115
138657ec
AH		 7116 /* FIXME: If the current method contains any exception handlers,
7117 force asynchronous_exceptions: this is necessary because signal
7118 handlers in libjava may throw exceptions. This is far from being
7119 a perfect solution, but it's better than doing nothing at all.*/
7120 if (catch_clauses)
7121 asynchronous_exceptions = 1;
7122
e04a16fb
AG		 7123 /* Run the optimizers and output assembler code for this function. */
7124 rest_of_compilation (fndecl);
7125 }
7126
7127 current_function_decl = NULL_TREE;
8226320b 7128 permanent_allocation (1);
e04a16fb 7129 java_parser_context_restore_global ();
138657ec 7130 asynchronous_exceptions = flag_asynchronous_exceptions;
e04a16fb
AG		 7131}
7132
7133/* Record EXPR in the current function block. Complements compound
7134 expression second operand if necessary. */
7135
7136tree
7137java_method_add_stmt (fndecl, expr)
7138 tree fndecl, expr;
7139{
b771925e
APB		 7140 if (!GET_CURRENT_BLOCK (fndecl))
7141 return NULL_TREE;
f099f336 7142 return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
b67d701b 7143}
e04a16fb 7144
b67d701b
PB		 7145static tree
7146add_stmt_to_block (b, type, stmt)
7147 tree b, type, stmt;
7148{
7149 tree body = BLOCK_EXPR_BODY (b), c;
7150
e04a16fb
AG		 7151 if (java_error_count)
7152 return body;
b67d701b
PB		 7153
7154 if ((c = add_stmt_to_compound (body, type, stmt)) == body)
e04a16fb
AG		 7155 return body;
7156
b67d701b
PB		 7157 BLOCK_EXPR_BODY (b) = c;
7158 TREE_SIDE_EFFECTS (c) = 1;
7159 return c;
e04a16fb
AG		 7160}
7161
7162/* Add STMT to EXISTING if possible, otherwise create a new
7163 COMPOUND_EXPR and add STMT to it. */
7164
7165static tree
7166add_stmt_to_compound (existing, type, stmt)
7167 tree existing, type, stmt;
7168{
15fdcfe9
PB		 7169 if (existing)
7170 return build (COMPOUND_EXPR, type, existing, stmt);
e04a16fb 7171 else
15fdcfe9 7172 return stmt;
e04a16fb
AG		 7173}
7174
7175/* Hold THIS for the scope of the current public method decl. */
7176static tree current_this;
7177
1886c9d8
APB		 7178void java_layout_seen_class_methods ()
7179{
7180 tree previous_list = all_class_list;
7181 tree end = NULL_TREE;
7182 tree current;
7183
7184 while (1)
7185 {
7186 for (current = previous_list;
7187 current != end; current = TREE_CHAIN (current))
7188 layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7189
7190 if (previous_list != all_class_list)
7191 {
7192 end = previous_list;
7193 previous_list = all_class_list;
7194 }
7195 else
7196 break;
7197 }
7198}
7199
e04a16fb 7200void
c2952b01 7201java_reorder_fields ()
e04a16fb 7202{
c2952b01 7203 static tree stop_reordering = NULL_TREE;
23a79c61 7204
c2952b01 7205 tree current;
5e942c50 7206 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
e04a16fb 7207 {
5e942c50 7208 current_class = TREE_TYPE (TREE_VALUE (current));
22eed1e6 7209
c2952b01
APB		 7210 if (current_class == stop_reordering)
7211 break;
7212
c877974e
APB		 7213 /* Reverse the fields, but leave the dummy field in front.
7214 Fields are already ordered for Object and Class */
7215 if (TYPE_FIELDS (current_class) && current_class != object_type_node
7216 && current_class != class_type_node)
7217 {
23a79c61
APB		 7218 /* If the dummy field is there, reverse the right fields and
7219 just layout the type for proper fields offset */
c877974e
APB		 7220 if (!DECL_NAME (TYPE_FIELDS (current_class)))
7221 {
7222 tree fields = TYPE_FIELDS (current_class);
7223 TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7224 TYPE_SIZE (current_class) = NULL_TREE;
c877974e 7225 }
23a79c61
APB		 7226 /* We don't have a dummy field, we need to layout the class,
7227 after having reversed the fields */
c877974e
APB		 7228 else
7229 {
7230 TYPE_FIELDS (current_class) =
7231 nreverse (TYPE_FIELDS (current_class));
7232 TYPE_SIZE (current_class) = NULL_TREE;
c877974e
APB		 7233 }
7234 }
c2952b01
APB		 7235 }
7236 stop_reordering = TREE_TYPE (TREE_VALUE (ctxp->gclass_list));
7237}
7238
7239/* Layout the methods of all classes loaded in one way on an
7240 other. Check methods of source parsed classes. Then reorder the
7241 fields and layout the classes or the type of all source parsed
7242 classes */
7243
7244void
7245java_layout_classes ()
7246{
7247 tree current;
7248 int save_error_count = java_error_count;
7249
7250 /* Layout the methods of all classes seen so far */
7251 java_layout_seen_class_methods ();
7252 java_parse_abort_on_error ();
7253 all_class_list = NULL_TREE;
7254
7255 /* Then check the methods of all parsed classes */
7256 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
7257 if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7258 CHECK_METHODS (TREE_VALUE (current));
7259 java_parse_abort_on_error ();
7260
7261 for (current = ctxp->gclass_list; current; current = TREE_CHAIN (current))
7262 {
7263 current_class = TREE_TYPE (TREE_VALUE (current));
7264 layout_class (current_class);
5e942c50 7265
c877974e
APB		 7266 /* From now on, the class is considered completely loaded */
7267 CLASS_LOADED_P (current_class) = 1;
7268
5e942c50
APB		 7269 /* Error reported by the caller */
7270 if (java_error_count)
7271 return;
e04a16fb 7272 }
23a79c61
APB		 7273
7274 /* We might have reloaded classes durign the process of laying out
7275 classes for code generation. We must layout the methods of those
7276 late additions, as constructor checks might use them */
1886c9d8 7277 java_layout_seen_class_methods ();
23a79c61 7278 java_parse_abort_on_error ();
e04a16fb
AG		 7279}
7280
c2952b01
APB		 7281/* Expand methods in the current set of classes rememebered for
7282 generation. */
e04a16fb 7283
49f48c71 7284static void
c2952b01 7285java_complete_expand_classes ()
e04a16fb
AG		 7286{
7287 tree current;
ce6e9147
APB		 7288
7289 do_not_fold = flag_emit_xref;
c2952b01 7290
e04a16fb 7291 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
c2952b01
APB		 7292 if (!INNER_CLASS_DECL_P (current))
7293 java_complete_expand_class (current);
7294}
e04a16fb 7295
c2952b01
APB		 7296/* Expand the methods found in OUTER, starting first by OUTER's inner
7297 classes, if any. */
e04a16fb 7298
c2952b01
APB		 7299static void
7300java_complete_expand_class (outer)
7301 tree outer;
7302{
7303 tree inner_list;
e04a16fb 7304
c2952b01 7305 set_nested_class_simple_name_value (outer, 1); /* Set */
cd9643f7 7306
c2952b01
APB		 7307 /* We need to go after all inner classes and start expanding them,
7308 starting with most nested ones. We have to do that because nested
7309 classes might add functions to outer classes */
e04a16fb 7310
c2952b01
APB		 7311 for (inner_list = DECL_INNER_CLASS_LIST (outer);
7312 inner_list; inner_list = TREE_CHAIN (inner_list))
7313 java_complete_expand_class (TREE_PURPOSE (inner_list));
22eed1e6 7314
c2952b01
APB		 7315 java_complete_expand_methods (outer);
7316 set_nested_class_simple_name_value (outer, 0); /* Reset */
7317}
7318
7319/* Expand methods registered in CLASS_DECL. The general idea is that
7320 we expand regular methods first. This allows us get an estimate on
7321 how outer context local alias fields are really used so we can add
7322 to the constructor just enough code to initialize them properly (it
7323 also lets us generate $finit$ correctly.) Then we expand the
7324 constructors and then <clinit>. */
7325
7326static void
7327java_complete_expand_methods (class_decl)
7328 tree class_decl;
7329{
7330 tree clinit, finit, decl, first_decl;
7331
7332 current_class = TREE_TYPE (class_decl);
7333
7334 /* Initialize a new constant pool */
7335 init_outgoing_cpool ();
7336
7337 /* Pre-expand <clinit> to figure whether we really need it or
7338 not. If we do need it, we pre-expand the static fields so they're
7339 ready to be used somewhere else. <clinit> will be fully expanded
7340 after we processed the constructors. */
7341 first_decl = TYPE_METHODS (current_class);
7342 clinit = maybe_generate_pre_expand_clinit (current_class);
7343
7344 /* Then generate $finit$ (if we need to) because constructor will
7345 try to use it.*/
7346 if (TYPE_FINIT_STMT_LIST (current_class))
7347 {
7348 finit = generate_finit (current_class);
7349 java_complete_expand_method (finit);
7350 }
7351
7352 /* Now do the constructors */
7353 for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7354 {
7355 int no_body;
7356
7357 if (!DECL_CONSTRUCTOR_P (decl))
7358 continue;
7359
7360 no_body = !DECL_FUNCTION_BODY (decl);
7361 /* Don't generate debug info on line zero when expanding a
7362 generated constructor. */
7363 if (no_body)
7364 restore_line_number_status (1);
7365
7366 java_complete_expand_method (decl);
7367
7368 if (no_body)
7369 restore_line_number_status (0);
7370 }
7371
7372 /* First, do the ordinary methods. */
7373 for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7374 {
7145d9fe
TT		 7375 /* Skip abstract or native methods -- but do handle native
7376 methods when generating JNI stubs. */
7377 if (METHOD_ABSTRACT (decl)
7378 || (! flag_jni && METHOD_NATIVE (decl))
b7805411 7379 || DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
c2952b01 7380 continue;
7145d9fe
TT		 7381
7382 if (METHOD_NATIVE (decl))
7383 {
7384 tree body = build_jni_stub (decl);
7385 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7386 }
7387
c2952b01
APB		 7388 java_complete_expand_method (decl);
7389 }
7390
7391 /* If there is indeed a <clinit>, fully expand it now */
7392 if (clinit)
7393 {
7394 /* Prevent the use of `this' inside <clinit> */
7395 ctxp->explicit_constructor_p = 1;
7396 java_complete_expand_method (clinit);
7397 ctxp->explicit_constructor_p = 0;
e04a16fb 7398 }
c2952b01 7399
165f37bc
APB		 7400 /* We might have generated a class$ that we now want to expand */
7401 if (TYPE_DOT_CLASS (current_class))
7402 java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7403
c2952b01
APB		 7404 /* Now verify constructor circularity (stop after the first one we
7405 prove wrong.) */
7406 if (!CLASS_INTERFACE (class_decl))
7407 for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7408 if (DECL_CONSTRUCTOR_P (decl)
7409 && verify_constructor_circularity (decl, decl))
7410 break;
7411
7412 /* Save the constant pool. We'll need to restore it later. */
7413 TYPE_CPOOL (current_class) = outgoing_cpool;
e04a16fb
AG		 7414}
7415
b9f7e36c
APB		 7416/* Hold a list of catch clauses list. The first element of this list is
7417 the list of the catch clauses of the currently analysed try block. */
7418static tree currently_caught_type_list;
7419
c2952b01
APB		 7420/* Attempt to create <clinit>. Pre-expand static fields so they can be
7421 safely used in some other methods/constructors. */
e920ebc9 7422
c2952b01
APB		 7423static tree
7424maybe_generate_pre_expand_clinit (class_type)
7425 tree class_type;
e920ebc9 7426{
c2952b01
APB		 7427 tree current, mdecl;
7428
7429 if (!TYPE_CLINIT_STMT_LIST (class_type))
7430 return NULL_TREE;
e920ebc9 7431
c2952b01
APB		 7432 /* Go through all static fields and pre expand them */
7433 for (current = TYPE_FIELDS (class_type); current;
7434 current = TREE_CHAIN (current))
7435 if (FIELD_STATIC (current))
7436 build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7437
7438 /* Then build the <clinit> method */
7439 mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7440 clinit_identifier_node, end_params_node);
7441 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7442 mdecl, NULL_TREE);
7443 start_artificial_method_body (mdecl);
7444
7445 /* We process the list of assignment we produced as the result of
7446 the declaration of initialized static field and add them as
7447 statement to the <clinit> method. */
7448 for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7449 current = TREE_CHAIN (current))
e920ebc9 7450 {
9a7ab4b3 7451 tree stmt = current;
c2952b01
APB		 7452 /* We build the assignment expression that will initialize the
7453 field to its value. There are strict rules on static
7454 initializers (8.5). FIXME */
98a52c2c 7455 if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
9a7ab4b3 7456 stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
c2952b01
APB		 7457 java_method_add_stmt (mdecl, stmt);
7458 }
e920ebc9 7459
c2952b01
APB		 7460 end_artificial_method_body (mdecl);
7461
92d83515
APB		 7462 /* Now we want to place <clinit> as the last method (because we need
7463 it at least for interface so that it doesn't interfere with the
7464 dispatch table based lookup. */
7465 if (TREE_CHAIN (TYPE_METHODS (class_type)))
c2952b01 7466 {
92d83515
APB		 7467 current = TREE_CHAIN (TYPE_METHODS (class_type));
7468 TYPE_METHODS (class_type) = current;
c2952b01
APB		 7469
7470 while (TREE_CHAIN (current))
7471 current = TREE_CHAIN (current);
92d83515 7472
c2952b01
APB		 7473 TREE_CHAIN (current) = mdecl;
7474 TREE_CHAIN (mdecl) = NULL_TREE;
e920ebc9 7475 }
c2952b01
APB		 7476
7477 return mdecl;
e920ebc9
APB		 7478}
7479
92d83515
APB		 7480/* See whether we could get rid of <clinit>. Criteria are: all static
7481 final fields have constant initial values and the body of <clinit>
7482 is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7483
7484static int
7485maybe_yank_clinit (mdecl)
7486 tree mdecl;
7487{
7488 tree type, current;
7489 tree fbody, bbody;
7490
7491 if (!DECL_CLINIT_P (mdecl))
7492 return 0;
7493
7494 /* If the body isn't empty, then we keep <clinit> */
7495 fbody = DECL_FUNCTION_BODY (mdecl);
7496 if ((bbody = BLOCK_EXPR_BODY (fbody)))
7497 bbody = BLOCK_EXPR_BODY (bbody);
7498 if (bbody && bbody != empty_stmt_node)
7499 return 0;
7500
7501 type = DECL_CONTEXT (mdecl);
7502 current = TYPE_FIELDS (type);
7503
7504 for (current = (current ? TREE_CHAIN (current) : current);
7505 current; current = TREE_CHAIN (current))
7506 if (!(FIELD_STATIC (current) && FIELD_FINAL (current)
7507 && DECL_INITIAL (current) && TREE_CONSTANT (DECL_INITIAL (current))))
7508 break;
7509
7510 if (current)
7511 return 0;
7512
7513 /* Get rid of <clinit> in the class' list of methods */
7514 if (TYPE_METHODS (type) == mdecl)
7515 TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7516 else
7517 for (current = TYPE_METHODS (type); current;
7518 current = TREE_CHAIN (current))
7519 if (TREE_CHAIN (current) == mdecl)
7520 {
7521 TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7522 break;
7523 }
7524
7525 return 1;
7526}
7527
7528
e04a16fb
AG		 7529/* Complete and expand a method. */
7530
7531static void
7532java_complete_expand_method (mdecl)
7533 tree mdecl;
7534{
92d83515
APB		 7535 int yank_clinit = 0;
7536
c2952b01 7537 current_function_decl = mdecl;
22eed1e6
APB		 7538 /* Fix constructors before expanding them */
7539 if (DECL_CONSTRUCTOR_P (mdecl))
7540 fix_constructors (mdecl);
e04a16fb 7541
22eed1e6 7542 /* Expand functions that have a body */
e04a16fb
AG		 7543 if (DECL_FUNCTION_BODY (mdecl))
7544 {
9bbc7d9f
PB		 7545 tree fbody = DECL_FUNCTION_BODY (mdecl);
7546 tree block_body = BLOCK_EXPR_BODY (fbody);
cd531a2e 7547 tree exception_copy = NULL_TREE;
e04a16fb 7548 expand_start_java_method (mdecl);
939d7216 7549 build_result_decl (mdecl);
e04a16fb
AG		 7550
7551 current_this
7552 = (!METHOD_STATIC (mdecl) ?
7553 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
7554
ce6e9147
APB		 7555 /* Purge the `throws' list of unchecked exceptions. If we're
7556 doing xref, save a copy of the list and re-install it
7557 later. */
7558 if (flag_emit_xref)
7559 exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
7560
b9f7e36c
APB		 7561 purge_unchecked_exceptions (mdecl);
7562
7563 /* Install exceptions thrown with `throws' */
7564 PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
7565
9bbc7d9f 7566 if (block_body != NULL_TREE)
bc3ca41b
PB		 7567 {
7568 block_body = java_complete_tree (block_body);
c2952b01 7569
7145d9fe 7570 if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
ce6e9147 7571 check_for_initialization (block_body);
f099f336 7572 ctxp->explicit_constructor_p = 0;
bc3ca41b 7573 }
e803d3b2 7574
9bbc7d9f 7575 BLOCK_EXPR_BODY (fbody) = block_body;
5e942c50 7576
c2952b01
APB		 7577 /* If we saw a return but couldn't evaluate it properly, we'll
7578 have an error_mark_node here. */
7579 if (block_body != error_mark_node
7580 && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
ce6e9147
APB		 7581 && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
7582 && !flag_emit_xref)
82371d41 7583 missing_return_error (current_function_decl);
7525cc04 7584
92d83515
APB		 7585 /* Check wether we could just get rid of clinit, now the picture
7586 is complete. */
7587 if (!(yank_clinit = maybe_yank_clinit (mdecl)))
7588 complete_start_java_method (mdecl);
7589
e04a16fb 7590 /* Don't go any further if we've found error(s) during the
92d83515
APB		 7591 expansion */
7592 if (!java_error_count && !yank_clinit)
e04a16fb 7593 source_end_java_method ();
22eed1e6
APB		 7594 else
7595 {
92d83515
APB		 7596 if (java_error_count)
7597 pushdecl_force_head (DECL_ARGUMENTS (mdecl));
22eed1e6
APB		 7598 poplevel (1, 0, 1);
7599 }
b9f7e36c
APB		 7600
7601 /* Pop the exceptions and sanity check */
7602 POP_EXCEPTIONS();
7603 if (currently_caught_type_list)
7604 fatal ("Exception list non empty - java_complete_expand_method");
ce6e9147
APB		 7605
7606 if (flag_emit_xref)
7607 DECL_FUNCTION_THROWS (mdecl) = exception_copy;
e04a16fb
AG		 7608 }
7609}
7610
c2952b01
APB		 7611\f
7612
7613/* This section of the code deals with accessing enclosing context
7614 fields either directly by using the relevant access to this$<n> or
7615 by invoking an access method crafted for that purpose. */
7616
7617/* Build the necessary access from an inner class to an outer
7618 class. This routine could be optimized to cache previous result
7619 (decl, current_class and returned access). When an access method
7620 needs to be generated, it always takes the form of a read. It might
7621 be later turned into a write by calling outer_field_access_fix. */
7622
7623static tree
7624build_outer_field_access (id, decl)
7625 tree id, decl;
7626{
7627 tree access = NULL_TREE;
7628 tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
7629
7630 /* If decl's class is the direct outer class of the current_class,
7631 build the access as `this$<n>.<field>'. Not that we will break
7632 the `private' barrier if we're not emitting bytecodes. */
7633 if (ctx == DECL_CONTEXT (decl)
7634 && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
7635 {
7636 tree thisn = build_current_thisn (current_class);
7637 access = make_qualified_primary (build_wfl_node (thisn),
7638 id, EXPR_WFL_LINECOL (id));
7639 }
7640 /* Otherwise, generate access methods to outer this and access the
7641 field (either using an access method or by direct access.) */
7642 else
7643 {
7644 int lc = EXPR_WFL_LINECOL (id);
7645
7646 /* Now we chain the required number of calls to the access$0 to
7647 get a hold to the enclosing instance we need, and the we
7648 build the field access. */
7649 access = build_access_to_thisn (ctx, DECL_CONTEXT (decl), lc);
7650
7651 /* If the field is private and we're generating bytecode, then
7652 we generate an access method */
7653 if (FIELD_PRIVATE (decl) && flag_emit_class_files )
7654 {
7655 tree name = build_outer_field_access_methods (decl);
7656 access = build_outer_field_access_expr (lc, DECL_CONTEXT (decl),
7657 name, access, NULL_TREE);
7658 }
7659 /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
7660 Once again we break the `private' access rule from a foreign
7661 class. */
7662 else
7663 access = make_qualified_primary (access, id, lc);
7664 }
7665 return resolve_expression_name (access, NULL);
7666}
7667
7668/* Return a non zero value if NODE describes an outer field inner
7669 access. */
7670
7671static int
7672outer_field_access_p (type, decl)
7673 tree type, decl;
7674{
7675 if (!INNER_CLASS_TYPE_P (type)
7676 || TREE_CODE (decl) != FIELD_DECL
7677 || DECL_CONTEXT (decl) == type)
7678 return 0;
7679
7680 for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
7681 type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
7682 {
7683 if (type == DECL_CONTEXT (decl))
7684 return 1;
7685 if (!DECL_CONTEXT (TYPE_NAME (type)))
7686 break;
7687 }
7688
7689 return 0;
7690}
7691
7692/* Return a non zero value if NODE represents an outer field inner
7693 access that was been already expanded. As a side effect, it returns
7694 the name of the field being accessed and the argument passed to the
7695 access function, suitable for a regeneration of the access method
7696 call if necessary. */
7697
7698static int
7699outer_field_expanded_access_p (node, name, arg_type, arg)
7700 tree node, *name, *arg_type, *arg;
7701{
7702 int identified = 0;
7703
7704 if (TREE_CODE (node) != CALL_EXPR)
7705 return 0;
7706
7707 /* Well, gcj generates slightly different tree nodes when compiling
7708 to native or bytecodes. It's the case for function calls. */
7709
7710 if (flag_emit_class_files
7711 && TREE_CODE (node) == CALL_EXPR
7712 && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
7713 identified = 1;
7714 else if (!flag_emit_class_files)
7715 {
7716 node = TREE_OPERAND (node, 0);
7717
7718 if (node && TREE_OPERAND (node, 0)
7719 && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
7720 {
7721 node = TREE_OPERAND (node, 0);
7722 if (TREE_OPERAND (node, 0)
7723 && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
7724 && (OUTER_FIELD_ACCESS_IDENTIFIER_P
7725 (DECL_NAME (TREE_OPERAND (node, 0)))))
7726 identified = 1;
7727 }
7728 }
7729
7730 if (identified && name && arg_type && arg)
7731 {
7732 tree argument = TREE_OPERAND (node, 1);
7733 *name = DECL_NAME (TREE_OPERAND (node, 0));
7734 *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
7735 *arg = TREE_VALUE (argument);
7736 }
7737 return identified;
7738}
7739
7740/* Detect in NODE an outer field read access from an inner class and
7741 transform it into a write with RHS as an argument. This function is
7742 called from the java_complete_lhs when an assignment to a LHS can
7743 be identified. */
7744
7745static tree
7746outer_field_access_fix (wfl, node, rhs)
7747 tree wfl, node, rhs;
7748{
7749 tree name, arg_type, arg;
7750
7751 if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
7752 {
7753 /* At any rate, check whether we're trying to assign a value to
7754 a final. */
7755 tree accessed = (JDECL_P (node) ? node :
7756 (TREE_CODE (node) == COMPONENT_REF ?
7757 TREE_OPERAND (node, 1) : node));
7758 if (check_final_assignment (accessed, wfl))
7759 return error_mark_node;
7760
7761 node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
7762 arg_type, name, arg, rhs);
7763 return java_complete_tree (node);
7764 }
7765 return NULL_TREE;
7766}
7767
7768/* Construct the expression that calls an access method:
7769 <type>.access$<n>(<arg1> [, <arg2>]);
7770
7771 ARG2 can be NULL and will be omitted in that case. It will denote a
7772 read access. */
7773
7774static tree
7775build_outer_field_access_expr (lc, type, access_method_name, arg1, arg2)
7776 int lc;
7777 tree type, access_method_name, arg1, arg2;
7778{
7779 tree args, cn, access;
7780
7781 args = arg1 ? arg1 :
7782 build_wfl_node (build_current_thisn (current_class));
7783 args = build_tree_list (NULL_TREE, args);
7784
7785 if (arg2)
7786 args = tree_cons (NULL_TREE, arg2, args);
7787
7788 access = build_method_invocation (build_wfl_node (access_method_name), args);
7789 cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
7790 return make_qualified_primary (cn, access, lc);
7791}
7792
7793static tree
7794build_new_access_id ()
7795{
7796 static int access_n_counter = 1;
7797 char buffer [128];
7798
7799 sprintf (buffer, "access$%d", access_n_counter++);
7800 return get_identifier (buffer);
7801}
7802
7803/* Create the static access functions for the outer field DECL. We define a
7804 read:
7805 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
7806 return inst$.field;
7807 }
7808 and a write access:
7809 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
7810 TREE_TYPE (<field>) value$) {
7811 return inst$.field = value$;
7812 }
7813 We should have a usage flags on the DECL so we can lazily turn the ones
7814 we're using for code generation. FIXME.
7815*/
7816
7817static tree
7818build_outer_field_access_methods (decl)
7819 tree decl;
7820{
7821 tree id, args, stmt, mdecl;
7822
7823 /* Check point, to be removed. FIXME */
7824 if (FIELD_INNER_ACCESS (decl)
7825 && TREE_CODE (FIELD_INNER_ACCESS (decl)) != IDENTIFIER_NODE)
7826 abort ();
7827
7828 if (FIELD_INNER_ACCESS (decl))
7829 return FIELD_INNER_ACCESS (decl);
7830
7831 push_obstacks (&permanent_obstack, &permanent_obstack);
7832
7833 /* Create the identifier and a function named after it. */
7834 id = build_new_access_id ();
7835
7836 /* The identifier is marked as bearing the name of a generated write
7837 access function for outer field accessed from inner classes. */
7838 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
7839
7840 /* Create the read access */
7841 args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
7842 TREE_CHAIN (args) = end_params_node;
7843 stmt = make_qualified_primary (build_wfl_node (inst_id),
7844 build_wfl_node (DECL_NAME (decl)), 0);
7845 stmt = build_return (0, stmt);
7846 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
7847 TREE_TYPE (decl), id, args, stmt);
7848 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
7849
7850 /* Create the write access method */
7851 args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
7852 TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
7853 TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
7854 stmt = make_qualified_primary (build_wfl_node (inst_id),
7855 build_wfl_node (DECL_NAME (decl)), 0);
7856 stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
7857 build_wfl_node (wpv_id)));
7858
7859 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
7860 TREE_TYPE (decl), id, args, stmt);
7861 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
7862 pop_obstacks ();
7863
7864 /* Return the access name */
7865 return FIELD_INNER_ACCESS (decl) = id;
7866}
7867
7868/* Build an field access method NAME. */
7869
7870static tree
7871build_outer_field_access_method (class, type, name, args, body)
7872 tree class, type, name, args, body;
7873{
7874 tree saved_current_function_decl, mdecl;
7875
7876 /* Create the method */
7877 mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
7878 fix_method_argument_names (args, mdecl);
7879 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
7880
7881 /* Attach the method body. */
7882 saved_current_function_decl = current_function_decl;
7883 start_artificial_method_body (mdecl);
7884 java_method_add_stmt (mdecl, body);
7885 end_artificial_method_body (mdecl);
7886 current_function_decl = saved_current_function_decl;
7887
7888 return mdecl;
7889}
7890
7891\f
7892/* This section deals with building access function necessary for
7893 certain kinds of method invocation from inner classes. */
7894
7895static tree
7896build_outer_method_access_method (decl)
7897 tree decl;
7898{
7899 tree saved_current_function_decl, mdecl;
7900 tree args = NULL_TREE, call_args = NULL_TREE;
7901 tree carg, id, body, class;
7902 char buffer [80];
7903 int parm_id_count = 0;
7904
7905 /* Test this abort with an access to a private field */
7906 if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
7907 abort ();
7908
7909 /* Check the cache first */
7910 if (DECL_FUNCTION_INNER_ACCESS (decl))
7911 return DECL_FUNCTION_INNER_ACCESS (decl);
7912
7913 class = DECL_CONTEXT (decl);
7914
7915 /* Obtain an access identifier and mark it */
7916 id = build_new_access_id ();
7917 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
7918
7919 push_obstacks (&permanent_obstack, &permanent_obstack);
7920
7921 carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
7922 /* Create the arguments, as much as the original */
7923 for (; carg && carg != end_params_node;
7924 carg = TREE_CHAIN (carg))
7925 {
7926 sprintf (buffer, "write_parm_value$%d", parm_id_count++);
7927 args = chainon (args, build_tree_list (get_identifier (buffer),
7928 TREE_VALUE (carg)));
7929 }
7930 args = chainon (args, end_params_node);
7931
7932 /* Create the method */
7933 mdecl = create_artificial_method (class, ACC_STATIC,
7934 TREE_TYPE (TREE_TYPE (decl)), id, args);
7935 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
7936 /* There is a potential bug here. We should be able to use
7937 fix_method_argument_names, but then arg names get mixed up and
7938 eventually a constructor will have its this$0 altered and the
7939 outer context won't be assignment properly. The test case is
7940 stub.java FIXME */
7941 TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
7942
7943 /* Attach the method body. */
7944 saved_current_function_decl = current_function_decl;
7945 start_artificial_method_body (mdecl);
7946
7947 /* The actual method invocation uses the same args. When invoking a
7948 static methods that way, we don't want to skip the first
7949 argument. */
7950 carg = args;
7951 if (!METHOD_STATIC (decl))
7952 carg = TREE_CHAIN (carg);
7953 for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
7954 call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
7955 call_args);
7956
7957 body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
7958 call_args);
7959 if (!METHOD_STATIC (decl))
7960 body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
7961 body, 0);
7962 if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
7963 body = build_return (0, body);
7964 java_method_add_stmt (mdecl,body);
7965 end_artificial_method_body (mdecl);
7966 current_function_decl = saved_current_function_decl;
7967 pop_obstacks ();
7968
7969 /* Back tag the access function so it know what it accesses */
7970 DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
7971
7972 /* Tag the current method so it knows it has an access generated */
7973 return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
7974}
7975
7976\f
7977/* This section of the code deals with building expressions to access
7978 the enclosing instance of an inner class. The enclosing instance is
7979 kept in a generated field called this$<n>, with <n> being the
7980 inner class nesting level (starting from 0.) */
7981
7982/* Build an access to a given this$<n>, possibly by chaining access
7983 call to others. Access methods to this$<n> are build on the fly if
7984 necessary */
7985
7986static tree
7987build_access_to_thisn (from, to, lc)
7988 tree from, to;
7989 int lc;
7990{
7991 tree access = NULL_TREE;
7992
7993 while (from != to)
7994 {
7995 tree access0_wfl, cn;
7996
7997 maybe_build_thisn_access_method (from);
7998 access0_wfl = build_wfl_node (access0_identifier_node);
7999 cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8000 EXPR_WFL_LINECOL (access0_wfl) = lc;
8001
8002 if (!access)
8003 {
8004 access = build_current_thisn (current_class);
8005 access = build_wfl_node (access);
8006 }
8007 access = build_tree_list (NULL_TREE, access);
8008 access = build_method_invocation (access0_wfl, access);
8009 access = make_qualified_primary (cn, access, lc);
8010
8011 from = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (from)));
8012 }
8013 return access;
8014}
8015
8016/* Build an access function to the this$<n> local to TYPE. NULL_TREE
8017 is returned if nothing needs to be generated. Otherwise, the method
152de068 8018 generated and a method decl is returned.
c2952b01
APB		 8019
8020 NOTE: These generated methods should be declared in a class file
8021 attribute so that they can't be referred to directly. */
8022
8023static tree
8024maybe_build_thisn_access_method (type)
8025 tree type;
8026{
8027 tree mdecl, args, stmt, rtype;
8028 tree saved_current_function_decl;
8029
8030 /* If TYPE is a top-level class, no access method is required.
8031 If there already is such an access method, bail out. */
8032 if (CLASS_ACCESS0_GENERATED_P (type) || !INNER_CLASS_TYPE_P (type))
8033 return NULL_TREE;
8034
8035 /* We generate the method. The method looks like:
8036 static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8037 */
8038 push_obstacks (&permanent_obstack, &permanent_obstack);
8039 args = build_tree_list (inst_id, build_pointer_type (type));
8040 TREE_CHAIN (args) = end_params_node;
8041 rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8042 mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8043 access0_identifier_node, args);
8044 fix_method_argument_names (args, mdecl);
8045 layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8046 stmt = build_current_thisn (type);
8047 stmt = make_qualified_primary (build_wfl_node (inst_id),
8048 build_wfl_node (stmt), 0);
8049 stmt = build_return (0, stmt);
8050
8051 saved_current_function_decl = current_function_decl;
8052 start_artificial_method_body (mdecl);
8053 java_method_add_stmt (mdecl, stmt);
8054 end_artificial_method_body (mdecl);
8055 current_function_decl = saved_current_function_decl;
8056 pop_obstacks ();
8057
8058 CLASS_ACCESS0_GENERATED_P (type) = 1;
8059
8060 return mdecl;
8061}
8062
8063/* Craft an correctly numbered `this$<n>'string. this$0 is used for
8064 the first level of innerclassing. this$1 for the next one, etc...
8065 This function can be invoked with TYPE to NULL, available and then
8066 has to count the parser context. */
8067
8068static tree
8069build_current_thisn (type)
8070 tree type;
8071{
8072 static int saved_i = -1;
8073 static tree saved_thisn = NULL_TREE;
8074
8075 tree decl;
8076 char buffer [80];
8077 int i = 0;
8078
8079 if (type)
8080 {
8081 static tree saved_type = NULL_TREE;
8082 static int saved_type_i = 0;
8083
8084 if (type == saved_type)
8085 i = saved_type_i;
8086 else
8087 {
8088 for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8089 decl; decl = DECL_CONTEXT (decl), i++)
8090 ;
8091
8092 saved_type = type;
8093 saved_type_i = i;
8094 }
8095 }
8096 else
8097 i = list_length (GET_CPC_LIST ())-2;
8098
8099 if (i == saved_i)
8100 return saved_thisn;
8101
8102 sprintf (buffer, "this$%d", i);
8103 saved_i = i;
8104 saved_thisn = get_identifier (buffer);
8105 return saved_thisn;
8106}
8107
8108/* Return the assignement to the hidden enclosing context `this$<n>'
8109 by the second incoming parameter to the innerclass constructor. The
8110 form used is `this.this$<n> = this$<n>;'. */
8111
8112static tree
8113build_thisn_assign ()
8114{
8115 if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8116 {
8117 tree thisn = build_current_thisn (current_class);
8118 tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8119 build_wfl_node (thisn), 0);
8120 tree rhs = build_wfl_node (thisn);
8121 EXPR_WFL_SET_LINECOL (lhs, lineno, 0);
8122 return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8123 }
8124 return NULL_TREE;
8125}
8126
8127\f
165f37bc
APB		 8128/* Building the synthetic `class$' used to implement the `.class' 1.1
8129 extension for non primitive types. This method looks like:
8130
8131 static Class class$(String type) throws NoClassDefFoundError
8132 {
8133 try {return (java.lang.Class.forName (String));}
8134 catch (ClassNotFoundException e) {
8135 throw new NoClassDefFoundError(e.getMessage());}
8136 } */
8137
8138static tree
8139build_dot_class_method (class)
8140 tree class;
8141{
8142#define BWF(S) build_wfl_node (get_identifier ((S)))
8143#define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8144 tree args, tmp, saved_current_function_decl, mdecl;
8145 tree stmt, throw_stmt, catch, catch_block, try_block;
8146 tree catch_clause_param;
8147 tree class_not_found_exception, no_class_def_found_error;
8148
8149 static tree get_message_wfl, type_parm_wfl;
8150
8151 if (!get_message_wfl)
8152 {
8153 get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8154 type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8155 }
8156
8157 /* Build the arguments */
8158 args = build_tree_list (get_identifier ("type$"),
8159 build_pointer_type (string_type_node));
8160 TREE_CHAIN (args) = end_params_node;
8161
8162 /* Build the qualified name java.lang.Class.forName */
8163 tmp = MQN (MQN (MQN (BWF ("java"),
8164 BWF ("lang")), BWF ("Class")), BWF ("forName"));
8165
8166 /* For things we have to catch and throw */
8167 class_not_found_exception =
8168 lookup_class (get_identifier ("java.lang.ClassNotFoundException"));
8169 no_class_def_found_error =
8170 lookup_class (get_identifier ("java.lang.NoClassDefFoundError"));
8171 load_class (class_not_found_exception, 1);
8172 load_class (no_class_def_found_error, 1);
8173
8174 /* Create the "class$" function */
8175 mdecl = create_artificial_method (class, ACC_STATIC,
8176 build_pointer_type (class_type_node),
8177 get_identifier ("class$"), args);
8178 DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
8179 no_class_def_found_error);
8180
8181 /* We start by building the try block. We need to build:
8182 return (java.lang.Class.forName (type)); */
8183 stmt = build_method_invocation (tmp,
8184 build_tree_list (NULL_TREE, type_parm_wfl));
8185 stmt = build_return (0, stmt);
8186 /* Put it in a block. That's the try block */
8187 try_block = build_expr_block (stmt, NULL_TREE);
8188
8189 /* Now onto the catch block. We start by building the expression
8190 throwing a new exception:
8191 throw new NoClassDefFoundError (_.getMessage); */
8192 throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8193 get_message_wfl, 0);
8194 throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8195
8196 /* Build new NoClassDefFoundError (_.getMessage) */
8197 throw_stmt = build_new_invocation
8198 (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8199 build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8200
8201 /* Build the throw, (it's too early to use BUILD_THROW) */
8202 throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8203
8204 /* Build the catch block to encapsulate all this. We begin by
8205 building an decl for the catch clause parameter and link it to
8206 newly created block, the catch block. */
8207 catch_clause_param =
8208 build_decl (VAR_DECL, wpv_id,
8209 build_pointer_type (class_not_found_exception));
8210 catch_block = build_expr_block (NULL_TREE, catch_clause_param);
8211
8212 /* We initialize the variable with the exception handler. */
8213 catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
8214 soft_exceptioninfo_call_node);
8215 add_stmt_to_block (catch_block, NULL_TREE, catch);
8216
8217 /* We add the statement throwing the new exception */
8218 add_stmt_to_block (catch_block, NULL_TREE, throw_stmt);
8219
8220 /* Build a catch expression for all this */
8221 catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
8222
8223 /* Build the try/catch sequence */
8224 stmt = build_try_statement (0, try_block, catch_block);
8225
8226 fix_method_argument_names (args, mdecl);
8227 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8228 saved_current_function_decl = current_function_decl;
8229 start_artificial_method_body (mdecl);
8230 java_method_add_stmt (mdecl, stmt);
8231 end_artificial_method_body (mdecl);
8232 current_function_decl = saved_current_function_decl;
8233 TYPE_DOT_CLASS (class) = mdecl;
8234
8235 return mdecl;
8236}
8237
8238static tree
8239build_dot_class_method_invocation (name)
8240 tree name;
8241{
8242 tree s = make_node (STRING_CST);
8243 TREE_STRING_LENGTH (s) = IDENTIFIER_LENGTH (name);
8244 TREE_STRING_POINTER (s) = obstack_alloc (expression_obstack,
8245 TREE_STRING_LENGTH (s)+1);
8246 strcpy (TREE_STRING_POINTER (s), IDENTIFIER_POINTER (name));
8247 return build_method_invocation (build_wfl_node (get_identifier ("class$")),
8248 build_tree_list (NULL_TREE, s));
8249}
8250
c2952b01
APB		 8251/* This section of the code deals with constructor. */
8252
22eed1e6
APB		 8253/* Craft a body for default constructor. Patch existing constructor
8254 bodies with call to super() and field initialization statements if
8255 necessary. */
8256
8257static void
8258fix_constructors (mdecl)
8259 tree mdecl;
8260{
8261 tree body = DECL_FUNCTION_BODY (mdecl);
c2952b01
APB		 8262 tree thisn_assign, compound = NULL_TREE;
8263 tree class_type = DECL_CONTEXT (mdecl);
22eed1e6 8264
22eed1e6
APB		 8265 if (!body)
8266 {
22eed1e6
APB		 8267 /* It is an error for the compiler to generate a default
8268 constructor if the superclass doesn't have a constructor that
c2952b01
APB		 8269 takes no argument, or the same args for an anonymous class */
8270 if (verify_constructor_super (mdecl))
22eed1e6 8271 {
c2952b01
APB		 8272 tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8273 tree save = DECL_NAME (mdecl);
49f48c71 8274 const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
c2952b01 8275 DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
781b0558 8276 parse_error_context
c2952b01
APB		 8277 (lookup_cl (TYPE_NAME (class_type)),
8278 "No constructor matching `%s' found in class `%s'",
8279 lang_printable_name (mdecl, 0), n);
8280 DECL_NAME (mdecl) = save;
22eed1e6
APB		 8281 }
8282
c2952b01
APB		 8283 /* The constructor body must be crafted by hand. It's the
8284 constructor we defined when we realize we didn't have the
8285 CLASSNAME() constructor */
22eed1e6
APB		 8286 start_artificial_method_body (mdecl);
8287
8288 /* We don't generate a super constructor invocation if we're
8289 compiling java.lang.Object. build_super_invocation takes care
8290 of that. */
e920ebc9 8291 compound = java_method_add_stmt (mdecl, build_super_invocation (mdecl));
22eed1e6 8292
c2952b01
APB		 8293 /* Insert the instance initializer block right here, after the
8294 super invocation. */
8295 add_instance_initializer (mdecl);
8296
8297 /* Insert an assignment to the this$<n> hidden field, if
8298 necessary */
8299 if ((thisn_assign = build_thisn_assign ()))
8300 java_method_add_stmt (mdecl, thisn_assign);
8301
22eed1e6
APB		 8302 end_artificial_method_body (mdecl);
8303 }
8304 /* Search for an explicit constructor invocation */
8305 else
8306 {
8307 int found = 0;
8308 tree main_block = BLOCK_EXPR_BODY (body);
22eed1e6
APB		 8309
8310 while (body)
8311 switch (TREE_CODE (body))
8312 {
8313 case CALL_EXPR:
8314 found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8315 body = NULL_TREE;
8316 break;
8317 case COMPOUND_EXPR:
8318 case EXPR_WITH_FILE_LOCATION:
8319 body = TREE_OPERAND (body, 0);
8320 break;
8321 case BLOCK:
8322 body = BLOCK_EXPR_BODY (body);
8323 break;
8324 default:
8325 found = 0;
8326 body = NULL_TREE;
8327 }
8328 /* The constructor is missing an invocation of super() */
8329 if (!found)
8330 compound = add_stmt_to_compound (compound, NULL_TREE,
c2952b01 8331 build_super_invocation (mdecl));
22eed1e6 8332
c2952b01
APB		 8333 /* Insert the instance initializer block right here, after the
8334 super invocation. */
8335 add_instance_initializer (mdecl);
8336
8337 /* Generate the assignment to this$<n>, if necessary */
8338 if ((thisn_assign = build_thisn_assign ()))
8339 compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8340
22eed1e6
APB		 8341 /* Fix the constructor main block if we're adding extra stmts */
8342 if (compound)
8343 {
8344 compound = add_stmt_to_compound (compound, NULL_TREE,
8345 BLOCK_EXPR_BODY (main_block));
8346 BLOCK_EXPR_BODY (main_block) = compound;
8347 }
8348 }
8349}
8350
8351/* Browse constructors in the super class, searching for a constructor
8352 that doesn't take any argument. Return 0 if one is found, 1
c2952b01
APB		 8353 otherwise. If the current class is an anonymous inner class, look
8354 for something that has the same signature. */
22eed1e6
APB		 8355
8356static int
c2952b01
APB		 8357verify_constructor_super (mdecl)
8358 tree mdecl;
22eed1e6
APB		 8359{
8360 tree class = CLASSTYPE_SUPER (current_class);
152de068 8361 int super_inner = PURE_INNER_CLASS_TYPE_P (class);
c2952b01
APB		 8362 tree sdecl;
8363
22eed1e6
APB		 8364 if (!class)
8365 return 0;
8366
c2952b01 8367 if (ANONYMOUS_CLASS_P (current_class))
22eed1e6 8368 {
c2952b01
APB		 8369 tree mdecl_arg_type;
8370 SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8371 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8372 if (DECL_CONSTRUCTOR_P (sdecl))
8373 {
cf1b2274 8374 tree m_arg_type;
152de068
APB		 8375 tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8376 if (super_inner)
8377 arg_type = TREE_CHAIN (arg_type);
cf1b2274
APB		 8378 for (m_arg_type = mdecl_arg_type;
8379 (arg_type != end_params_node
8380 && m_arg_type != end_params_node);
c2952b01 8381 arg_type = TREE_CHAIN (arg_type),
cf1b2274
APB		 8382 m_arg_type = TREE_CHAIN (m_arg_type))
8383 if (TREE_VALUE (arg_type) != TREE_VALUE (m_arg_type))
c2952b01
APB		 8384 break;
8385
cf1b2274 8386 if (arg_type == end_params_node && m_arg_type == end_params_node)
c2952b01
APB		 8387 return 0;
8388 }
8389 }
8390 else
8391 {
8392 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
22eed1e6 8393 {
152de068
APB		 8394 tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8395 if (super_inner)
8396 arg = TREE_CHAIN (arg);
8397 if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
22eed1e6
APB		 8398 return 0;
8399 }
8400 }
8401 return 1;
8402}
8403
22eed1e6 8404/* Generate code for all context remembered for code generation. */
b351b287
APB		 8405
8406void
8407java_expand_classes ()
8408{
5423609c 8409 int save_error_count = 0;
c2952b01
APB		 8410 static struct parser_ctxt *saved_ctxp = NULL;
8411
23a79c61
APB		 8412 java_parse_abort_on_error ();
8413 if (!(ctxp = ctxp_for_generation))
5e942c50
APB		 8414 return;
8415 java_layout_classes ();
8416 java_parse_abort_on_error ();
8417
c2952b01 8418 saved_ctxp = ctxp_for_generation;
b351b287
APB		 8419 for (; ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8420 {
8421 ctxp = ctxp_for_generation;
8422 lang_init_source (2); /* Error msgs have method prototypes */
c2952b01 8423 java_complete_expand_classes (); /* Complete and expand classes */
b351b287
APB		 8424 java_parse_abort_on_error ();
8425 }
c2952b01
APB		 8426
8427 /* Find anonymous classes and expand their constructor, now they
8428 have been fixed. */
8429 for (ctxp_for_generation = saved_ctxp;
8430 ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8431 {
8432 tree current;
8433 ctxp = ctxp_for_generation;
8434 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8435 {
8436 current_class = TREE_TYPE (current);
8437 if (ANONYMOUS_CLASS_P (current_class))
8438 {
8439 tree d;
8440 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
8441 {
8442 if (DECL_CONSTRUCTOR_P (d))
8443 {
8444 restore_line_number_status (1);
8445 reset_method_name (d);
8446 java_complete_expand_method (d);
8447 restore_line_number_status (0);
8448 break; /* We now there are no other ones */
8449 }
8450 }
8451 }
8452 }
8453 }
8454
8455 /* If we've found error at that stage, don't try to generate
8456 anything, unless we're emitting xrefs or checking the syntax only
8457 (but not using -fsyntax-only for the purpose of generating
8458 bytecode. */
8459 if (java_error_count && !flag_emit_xref
8460 && (!flag_syntax_only && !flag_emit_class_files))
8461 return;
8462
8463 /* Now things are stable, go for generation of the class data. */
8464 for (ctxp_for_generation = saved_ctxp;
8465 ctxp_for_generation; ctxp_for_generation = ctxp_for_generation->next)
8466 {
8467 tree current;
8468 ctxp = ctxp_for_generation;
8469 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8470 {
8471 current_class = TREE_TYPE (current);
8472 outgoing_cpool = TYPE_CPOOL (current_class);
8473 if (flag_emit_class_files)
8474 write_classfile (current_class);
8475 if (flag_emit_xref)
8476 expand_xref (current_class);
8477 else if (! flag_syntax_only)
8478 finish_class ();
8479 }
8480 }
b351b287
APB		 8481}
8482
e04a16fb
AG		 8483/* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
8484 a tree list node containing RIGHT. Fore coming RIGHTs will be
8485 chained to this hook. LOCATION contains the location of the
8486 separating `.' operator. */
8487
8488static tree
8489make_qualified_primary (primary, right, location)
8490 tree primary, right;
8491 int location;
8492{
8493 tree wfl;
8494
c2952b01 8495 if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9a7ab4b3 8496 wfl = build_wfl_wrap (primary, location);
e04a16fb
AG		 8497 else
8498 {
8499 wfl = primary;
c2952b01
APB		 8500 /* If wfl wasn't qualified, we build a first anchor */
8501 if (!EXPR_WFL_QUALIFICATION (wfl))
8502 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
e04a16fb
AG		 8503 }
8504
c2952b01 8505 /* And chain them */
e04a16fb
AG		 8506 EXPR_WFL_LINECOL (right) = location;
8507 chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
8508 PRIMARY_P (wfl) = 1;
8509 return wfl;
8510}
8511
8512/* Simple merge of two name separated by a `.' */
8513
8514static tree
8515merge_qualified_name (left, right)
8516 tree left, right;
8517{
8518 tree node;
c2952b01
APB		 8519 if (!left && !right)
8520 return NULL_TREE;
8521
8522 if (!left)
8523 return right;
8524
8525 if (!right)
8526 return left;
8527
e04a16fb
AG		 8528 obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
8529 IDENTIFIER_LENGTH (left));
8530 obstack_1grow (&temporary_obstack, '.');
8531 obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
8532 IDENTIFIER_LENGTH (right));
8533 node = get_identifier (obstack_base (&temporary_obstack));
8534 obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
8535 QUALIFIED_P (node) = 1;
8536 return node;
8537}
8538
8539/* Merge the two parts of a qualified name into LEFT. Set the
8540 location information of the resulting node to LOCATION, usually
8541 inherited from the location information of the `.' operator. */
8542
8543static tree
8544make_qualified_name (left, right, location)
8545 tree left, right;
8546 int location;
8547{
bc3ca41b
PB		 8548#ifdef USE_COMPONENT_REF
8549 tree node = build (COMPONENT_REF, NULL_TREE, left, right);
8550 EXPR_WFL_LINECOL (node) = location;
8551 return node;
8552#else
e04a16fb
AG		 8553 tree left_id = EXPR_WFL_NODE (left);
8554 tree right_id = EXPR_WFL_NODE (right);
8555 tree wfl, merge;
8556
8557 merge = merge_qualified_name (left_id, right_id);
8558
8559 /* Left wasn't qualified and is now qualified */
8560 if (!QUALIFIED_P (left_id))
8561 {
8562 tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
8563 EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
8564 EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
8565 }
8566
8567 wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
8568 EXPR_WFL_LINECOL (wfl) = location;
8569 chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
8570
8571 EXPR_WFL_NODE (left) = merge;
8572 return left;
bc3ca41b 8573#endif
e04a16fb
AG		 8574}
8575
8576/* Extract the last identifier component of the qualified in WFL. The
8577 last identifier is removed from the linked list */
8578
8579static tree
8580cut_identifier_in_qualified (wfl)
8581 tree wfl;
8582{
8583 tree q;
8584 tree previous = NULL_TREE;
8585 for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
8586 if (!TREE_CHAIN (q))
8587 {
8588 if (!previous)
781b0558 8589 fatal ("Operating on a non qualified qualified WFL - cut_identifier_in_qualified");
e04a16fb
AG		 8590 TREE_CHAIN (previous) = NULL_TREE;
8591 return TREE_PURPOSE (q);
8592 }
8593}
8594
8595/* Resolve the expression name NAME. Return its decl. */
8596
8597static tree
5e942c50 8598resolve_expression_name (id, orig)
e04a16fb 8599 tree id;
5e942c50 8600 tree *orig;
e04a16fb
AG		 8601{
8602 tree name = EXPR_WFL_NODE (id);
8603 tree decl;
8604
8605 /* 6.5.5.1: Simple expression names */
8606 if (!PRIMARY_P (id) && !QUALIFIED_P (name))
8607 {
8608 /* 15.13.1: NAME can appear within the scope of a local variable
8609 declaration */
8610 if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
8611 return decl;
8612
8613 /* 15.13.1: NAME can appear within a class declaration */
8614 else
8615 {
8616 decl = lookup_field_wrapper (current_class, name);
8617 if (decl)
8618 {
c2952b01 8619 tree access = NULL_TREE;
e04a16fb 8620 int fs = FIELD_STATIC (decl);
f2760b27
APB		 8621
8622 /* If we're accessing an outer scope local alias, make
8623 sure we change the name of the field we're going to
8624 build access to. */
8625 if (FIELD_LOCAL_ALIAS_USED (decl))
8626 name = DECL_NAME (decl);
8627
e04a16fb
AG		 8628 /* Instance variable (8.3.1.1) can't appear within
8629 static method, static initializer or initializer for
8630 a static variable. */
8631 if (!fs && METHOD_STATIC (current_function_decl))
8632 {
7f10c2e2 8633 static_ref_err (id, name, current_class);
e04a16fb
AG		 8634 return error_mark_node;
8635 }
22eed1e6
APB		 8636 /* Instance variables can't appear as an argument of
8637 an explicit constructor invocation */
8638 if (!fs && ctxp->explicit_constructor_p)
8639 {
8640 parse_error_context
781b0558 8641 (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
22eed1e6
APB		 8642 return error_mark_node;
8643 }
5e942c50 8644
c2952b01
APB		 8645 /* If we're processing an inner class and we're trying
8646 to access a field belonging to an outer class, build
8647 the access to the field */
8648 if (!fs && outer_field_access_p (current_class, decl))
8649 return build_outer_field_access (id, decl);
8650
5e942c50 8651 /* Otherwise build what it takes to access the field */
c2952b01
APB		 8652 access = build_field_ref ((fs ? NULL_TREE : current_this),
8653 DECL_CONTEXT (decl), name);
e8fc7396 8654 if (fs && !flag_emit_class_files && !flag_emit_xref)
c2952b01 8655 access = build_class_init (DECL_CONTEXT (access), access);
5e942c50
APB		 8656 /* We may be asked to save the real field access node */
8657 if (orig)
c2952b01 8658 *orig = access;
5e942c50 8659 /* And we return what we got */
c2952b01 8660 return access;
e04a16fb
AG		 8661 }
8662 /* Fall down to error report on undefined variable */
8663 }
8664 }
8665 /* 6.5.5.2 Qualified Expression Names */
8666 else
8667 {
5e942c50
APB		 8668 if (orig)
8669 *orig = NULL_TREE;
e04a16fb
AG		 8670 qualify_ambiguous_name (id);
8671 /* 15.10.1 Field Access Using a Primary and/or Expression Name */
8672 /* 15.10.2: Accessing Superclass Members using super */
98f3c1db 8673 return resolve_field_access (id, orig, NULL);
e04a16fb
AG		 8674 }
8675
8676 /* We've got an error here */
8677 parse_error_context (id, "Undefined variable `%s'",
8678 IDENTIFIER_POINTER (name));
8679
8680 return error_mark_node;
8681}
8682
7f10c2e2
APB		 8683static void
8684static_ref_err (wfl, field_id, class_type)
8685 tree wfl, field_id, class_type;
8686{
8687 parse_error_context
8688 (wfl,
8689 "Can't make a static reference to nonstatic variable `%s' in class `%s'",
8690 IDENTIFIER_POINTER (field_id),
8691 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
8692}
8693
e04a16fb
AG		 8694/* 15.10.1 Field Acess Using a Primary and/or Expression Name.
8695 We return something suitable to generate the field access. We also
8696 return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
8697 recipient's address can be null. */
8698
8699static tree
8700resolve_field_access (qual_wfl, field_decl, field_type)
8701 tree qual_wfl;
8702 tree *field_decl, *field_type;
8703{
8704 int is_static = 0;
8705 tree field_ref;
8706 tree decl, where_found, type_found;
8707
8708 if (resolve_qualified_expression_name (qual_wfl, &decl,
8709 &where_found, &type_found))
8710 return error_mark_node;
8711
8712 /* Resolve the LENGTH field of an array here */
9a7ab4b3 8713 if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
6eaeeb55 8714 && type_found && TYPE_ARRAY_P (type_found)
e8fc7396 8715 && ! flag_emit_class_files && ! flag_emit_xref)
e04a16fb
AG		 8716 {
8717 tree length = build_java_array_length_access (where_found);
8718 field_ref =
8719 build_java_arraynull_check (type_found, length, int_type_node);
611a4b87
APB		 8720
8721 /* In case we're dealing with a static array, we need to
8722 initialize its class before the array length can be fetched.
8723 It's also a good time to create a DECL_RTL for the field if
8724 none already exists, otherwise if the field was declared in a
8725 class found in an external file and hasn't been (and won't
8726 be) accessed for its value, none will be created. */
8727 if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
8728 {
8729 build_static_field_ref (where_found);
8730 field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
8731 }
e04a16fb
AG		 8732 }
8733 /* We might have been trying to resolve field.method(). In which
8734 case, the resolution is over and decl is the answer */
34f4db93 8735 else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
e04a16fb 8736 field_ref = decl;
34f4db93 8737 else if (JDECL_P (decl))
e04a16fb 8738 {
5e942c50
APB		 8739 int static_final_found = 0;
8740 if (!type_found)
8741 type_found = DECL_CONTEXT (decl);
34f4db93 8742 is_static = JDECL_P (decl) && FIELD_STATIC (decl);
5e942c50
APB		 8743 if (FIELD_FINAL (decl)
8744 && JPRIMITIVE_TYPE_P (TREE_TYPE (decl))
7525cc04 8745 && DECL_INITIAL (decl))
5e942c50 8746 {
70541f45 8747 field_ref = java_complete_tree (decl);
5e942c50
APB		 8748 static_final_found = 1;
8749 }
8750 else
7f10c2e2
APB		 8751 field_ref = build_field_ref ((is_static && !flag_emit_xref?
8752 NULL_TREE : where_found),
5e942c50 8753 type_found, DECL_NAME (decl));
e04a16fb
AG		 8754 if (field_ref == error_mark_node)
8755 return error_mark_node;
e8fc7396
APB		 8756 if (is_static && !static_final_found
8757 && !flag_emit_class_files && !flag_emit_xref)
40aaba2b 8758 field_ref = build_class_init (DECL_CONTEXT (decl), field_ref);
e04a16fb
AG		 8759 }
8760 else
8761 field_ref = decl;
8762
8763 if (field_decl)
8764 *field_decl = decl;
8765 if (field_type)
c877974e
APB		 8766 *field_type = (QUAL_DECL_TYPE (decl) ?
8767 QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
e04a16fb
AG		 8768 return field_ref;
8769}
8770
e28cd97b
APB		 8771/* If NODE is an access to f static field, strip out the class
8772 initialization part and return the field decl, otherwise, return
8773 NODE. */
8774
8775static tree
8776strip_out_static_field_access_decl (node)
8777 tree node;
8778{
8779 if (TREE_CODE (node) == COMPOUND_EXPR)
8780 {
8781 tree op1 = TREE_OPERAND (node, 1);
8782 if (TREE_CODE (op1) == COMPOUND_EXPR)
8783 {
8784 tree call = TREE_OPERAND (op1, 0);
8785 if (TREE_CODE (call) == CALL_EXPR
8786 && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
8787 && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
8788 == soft_initclass_node)
8789 return TREE_OPERAND (op1, 1);
8790 }
2f11d407
TT		 8791 else if (JDECL_P (op1))
8792 return op1;
e28cd97b
APB		 8793 }
8794 return node;
8795}
8796
e04a16fb
AG		 8797/* 6.5.5.2: Qualified Expression Names */
8798
8799static int
8800resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
8801 tree wfl;
8802 tree *found_decl, *type_found, *where_found;
8803{
8804 int from_type = 0; /* Field search initiated from a type */
c2952b01 8805 int from_super = 0, from_cast = 0, from_qualified_this = 0;
e04a16fb
AG		 8806 int previous_call_static = 0;
8807 int is_static;
8808 tree decl = NULL_TREE, type = NULL_TREE, q;
c2952b01
APB		 8809 /* For certain for of inner class instantiation */
8810 tree saved_current, saved_this;
8811#define RESTORE_THIS_AND_CURRENT_CLASS \
8812 { current_class = saved_current; current_this = saved_this;}
8813
c877974e 8814 *type_found = *where_found = NULL_TREE;
e04a16fb
AG		 8815
8816 for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
8817 {
8818 tree qual_wfl = QUAL_WFL (q);
7705e9db
APB		 8819 tree ret_decl; /* for EH checking */
8820 int location; /* for EH checking */
e04a16fb
AG		 8821
8822 /* 15.10.1 Field Access Using a Primary */
e04a16fb
AG		 8823 switch (TREE_CODE (qual_wfl))
8824 {
8825 case CALL_EXPR:
b67d701b 8826 case NEW_CLASS_EXPR:
e04a16fb
AG		 8827 /* If the access to the function call is a non static field,
8828 build the code to access it. */
34f4db93 8829 if (JDECL_P (decl) && !FIELD_STATIC (decl))
e04a16fb 8830 {
ac825856
APB		 8831 decl = maybe_access_field (decl, *where_found,
8832 DECL_CONTEXT (decl));
e04a16fb
AG		 8833 if (decl == error_mark_node)
8834 return 1;
8835 }
c2952b01 8836
e04a16fb
AG		 8837 /* And code for the function call */
8838 if (complete_function_arguments (qual_wfl))
8839 return 1;
c2952b01
APB		 8840
8841 /* We might have to setup a new current class and a new this
8842 for the search of an inner class, relative to the type of
8843 a expression resolved as `decl'. The current values are
8844 saved and restored shortly after */
8845 saved_current = current_class;
8846 saved_this = current_this;
8847 if (decl && TREE_CODE (qual_wfl) == NEW_CLASS_EXPR)
8848 {
8849 current_class = type;
8850 current_this = decl;
8851 }
8852
89e09b9a
PB		 8853 if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
8854 CALL_USING_SUPER (qual_wfl) = 1;
7705e9db
APB		 8855 location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
8856 EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
8857 *where_found = patch_method_invocation (qual_wfl, decl, type,
8858 &is_static, &ret_decl);
e04a16fb 8859 if (*where_found == error_mark_node)
c2952b01
APB		 8860 {
8861 RESTORE_THIS_AND_CURRENT_CLASS;
8862 return 1;
8863 }
e04a16fb
AG		 8864 *type_found = type = QUAL_DECL_TYPE (*where_found);
8865
c2952b01
APB		 8866 /* If we're creating an inner class instance, check for that
8867 an enclosing instance is in scope */
8868 if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
165f37bc 8869 && INNER_ENCLOSING_SCOPE_CHECK (type))
c2952b01
APB		 8870 {
8871 parse_error_context
165f37bc
APB		 8872 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
8873 lang_printable_name (type, 0),
8874 (!current_this ? "" :
8875 "; an explicit one must be provided when creating this inner class"));
c2952b01
APB		 8876 RESTORE_THIS_AND_CURRENT_CLASS;
8877 return 1;
8878 }
8879
8880 /* In case we had to change then to resolve a inner class
8881 instantiation using a primary qualified by a `new' */
8882 RESTORE_THIS_AND_CURRENT_CLASS;
8883
7705e9db
APB		 8884 /* EH check */
8885 if (location)
8886 check_thrown_exceptions (location, ret_decl);
8887
e04a16fb
AG		 8888 /* If the previous call was static and this one is too,
8889 build a compound expression to hold the two (because in
8890 that case, previous function calls aren't transported as
8891 forcoming function's argument. */
8892 if (previous_call_static && is_static)
8893 {
8894 decl = build (COMPOUND_EXPR, type, decl, *where_found);
8895 TREE_SIDE_EFFECTS (decl) = 1;
8896 }
8897 else
8898 {
8899 previous_call_static = is_static;
8900 decl = *where_found;
8901 }
c2952b01 8902 from_type = 0;
e04a16fb
AG		 8903 continue;
8904
d8fccff5 8905 case NEW_ARRAY_EXPR:
c2952b01 8906 case NEW_ANONYMOUS_ARRAY_EXPR:
d8fccff5
APB		 8907 *where_found = decl = java_complete_tree (qual_wfl);
8908 if (decl == error_mark_node)
8909 return 1;
8910 *type_found = type = QUAL_DECL_TYPE (decl);
8911 CLASS_LOADED_P (type) = 1;
8912 continue;
8913
e04a16fb
AG		 8914 case CONVERT_EXPR:
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 from_cast = 1;
8920 continue;
8921
22eed1e6 8922 case CONDITIONAL_EXPR:
5e942c50 8923 case STRING_CST:
ac22f9cb 8924 case MODIFY_EXPR:
22eed1e6
APB		 8925 *where_found = decl = java_complete_tree (qual_wfl);
8926 if (decl == error_mark_node)
8927 return 1;
8928 *type_found = type = QUAL_DECL_TYPE (decl);
8929 continue;
8930
e04a16fb
AG		 8931 case ARRAY_REF:
8932 /* If the access to the function call is a non static field,
8933 build the code to access it. */
34f4db93 8934 if (JDECL_P (decl) && !FIELD_STATIC (decl))
e04a16fb
AG		 8935 {
8936 decl = maybe_access_field (decl, *where_found, type);
8937 if (decl == error_mark_node)
8938 return 1;
8939 }
8940 /* And code for the array reference expression */
8941 decl = java_complete_tree (qual_wfl);
8942 if (decl == error_mark_node)
8943 return 1;
8944 type = QUAL_DECL_TYPE (decl);
8945 continue;
0a2138e2 8946
37feda7d
APB		 8947 case PLUS_EXPR:
8948 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
8949 return 1;
8950 if ((type = patch_string (decl)))
8951 decl = type;
8952 *where_found = QUAL_RESOLUTION (q) = decl;
8953 *type_found = type = TREE_TYPE (decl);
8954 break;
8955
165f37bc
APB		 8956 case CLASS_LITERAL:
8957 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
8958 return 1;
8959 *where_found = QUAL_RESOLUTION (q) = decl;
8960 *type_found = type = TREE_TYPE (decl);
8961 break;
8962
0a2138e2
APB		 8963 default:
8964 /* Fix for -Wall Just go to the next statement. Don't
8965 continue */
a3f406ce 8966 break;
e04a16fb
AG		 8967 }
8968
8969 /* If we fall here, we weren't processing a (static) function call. */
8970 previous_call_static = 0;
8971
8972 /* It can be the keyword THIS */
8973 if (EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
8974 {
8975 if (!current_this)
8976 {
8977 parse_error_context
8978 (wfl, "Keyword `this' used outside allowed context");
8979 return 1;
8980 }
f63991a8
APB		 8981 if (ctxp->explicit_constructor_p)
8982 {
781b0558 8983 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
f63991a8
APB		 8984 return 1;
8985 }
e04a16fb 8986 /* We have to generate code for intermediate acess */
c2952b01
APB		 8987 if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
8988 {
8989 *where_found = decl = current_this;
8990 *type_found = type = QUAL_DECL_TYPE (decl);
8991 }
8992 /* We're trying to access the this from somewhere else... */
8993 else
8994 {
8995 *where_found = decl = build_current_thisn (type);
8996 from_qualified_this = 1;
8997 }
8998
8999 from_type = 0;
e04a16fb
AG		 9000 continue;
9001 }
9002
9003 /* 15.10.2 Accessing Superclass Members using SUPER */
9004 if (EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9005 {
9006 tree node;
9007 /* Check on the restricted use of SUPER */
9008 if (METHOD_STATIC (current_function_decl)
9009 || current_class == object_type_node)
9010 {
9011 parse_error_context
9012 (wfl, "Keyword `super' used outside allowed context");
9013 return 1;
9014 }
9015 /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9016 node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9017 CLASSTYPE_SUPER (current_class),
9018 build_this (EXPR_WFL_LINECOL (qual_wfl)));
9019 *where_found = decl = java_complete_tree (node);
22eed1e6
APB		 9020 if (decl == error_mark_node)
9021 return 1;
e04a16fb
AG		 9022 *type_found = type = QUAL_DECL_TYPE (decl);
9023 from_super = from_type = 1;
9024 continue;
9025 }
9026
9027 /* 15.13.1: Can't search for field name in packages, so we
9028 assume a variable/class name was meant. */
9029 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9030 {
5e942c50
APB		 9031 tree name = resolve_package (wfl, &q);
9032 if (name)
9033 {
c2952b01 9034 tree list;
5e942c50 9035 *where_found = decl = resolve_no_layout (name, qual_wfl);
6b48deee 9036 /* We want to be absolutely sure that the class is laid
5e942c50
APB		 9037 out. We're going to search something inside it. */
9038 *type_found = type = TREE_TYPE (decl);
9039 layout_class (type);
9040 from_type = 1;
c2952b01 9041
dde1da72
APB		 9042 /* Fix them all the way down, if any are left. */
9043 if (q)
c2952b01 9044 {
dde1da72
APB		 9045 list = TREE_CHAIN (q);
9046 while (list)
9047 {
9048 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (list)) = 1;
9049 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9050 list = TREE_CHAIN (list);
9051 }
c2952b01 9052 }
5e942c50 9053 }
e04a16fb 9054 else
5e942c50
APB		 9055 {
9056 if (from_super || from_cast)
9057 parse_error_context
9058 ((from_cast ? qual_wfl : wfl),
9059 "No variable `%s' defined in class `%s'",
9060 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9061 lang_printable_name (type, 0));
9062 else
9063 parse_error_context
9064 (qual_wfl, "Undefined variable or class name: `%s'",
9065 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)));
9066 return 1;
9067 }
e04a16fb
AG		 9068 }
9069
9070 /* We have a type name. It's been already resolved when the
9071 expression was qualified. */
9072 else if (RESOLVE_TYPE_NAME_P (qual_wfl))
9073 {
9074 if (!(decl = QUAL_RESOLUTION (q)))
9075 return 1; /* Error reported already */
9076
c2952b01
APB		 9077 /* Sneak preview. If next we see a `new', we're facing a
9078 qualification with resulted in a type being selected
9079 instead of a field. Report the error */
9080 if(TREE_CHAIN (q)
9081 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9082 {
9083 parse_error_context (qual_wfl, "Undefined variable `%s'",
9084 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9085 return 1;
9086 }
9087
e04a16fb
AG		 9088 if (not_accessible_p (TREE_TYPE (decl), decl, 0))
9089 {
9090 parse_error_context
9091 (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
9092 java_accstring_lookup (get_access_flags_from_decl (decl)),
2aa11e97 9093 GET_TYPE_NAME (type),
e04a16fb
AG		 9094 IDENTIFIER_POINTER (DECL_NAME (decl)),
9095 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
9096 return 1;
9097 }
5e942c50 9098 check_deprecation (qual_wfl, decl);
c2952b01 9099
e04a16fb
AG		 9100 type = TREE_TYPE (decl);
9101 from_type = 1;
9102 }
9103 /* We resolve and expression name */
9104 else
9105 {
cd531a2e 9106 tree field_decl = NULL_TREE;
e04a16fb
AG		 9107
9108 /* If there exists an early resolution, use it. That occurs
9109 only once and we know that there are more things to
9110 come. Don't do that when processing something after SUPER
9111 (we need more thing to be put in place below */
9112 if (!from_super && QUAL_RESOLUTION (q))
b67d701b
PB		 9113 {
9114 decl = QUAL_RESOLUTION (q);
c877974e 9115 if (!type)
5e942c50 9116 {
7f10c2e2
APB		 9117 if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9118 {
9119 if (current_this)
9120 *where_found = current_this;
9121 else
9122 {
9123 static_ref_err (qual_wfl, DECL_NAME (decl),
9124 current_class);
9125 return 1;
9126 }
9127 }
c877974e
APB		 9128 else
9129 {
9130 *where_found = TREE_TYPE (decl);
9131 if (TREE_CODE (*where_found) == POINTER_TYPE)
9132 *where_found = TREE_TYPE (*where_found);
9133 }
5e942c50 9134 }
b67d701b 9135 }
e04a16fb
AG		 9136
9137 /* We have to search for a field, knowing the type of its
9138 container. The flag FROM_TYPE indicates that we resolved
9139 the last member of the expression as a type name, which
5e942c50
APB		 9140 means that for the resolution of this field, we'll look
9141 for other errors than if it was resolved as a member of
9142 an other field. */
e04a16fb
AG		 9143 else
9144 {
9145 int is_static;
5e942c50
APB		 9146 tree field_decl_type; /* For layout */
9147
e04a16fb
AG		 9148 if (!from_type && !JREFERENCE_TYPE_P (type))
9149 {
9150 parse_error_context
9151 (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9152 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
0a2138e2 9153 lang_printable_name (type, 0),
e04a16fb
AG		 9154 IDENTIFIER_POINTER (DECL_NAME (field_decl)));
9155 return 1;
9156 }
9157
dc0b3eff
PB		 9158 field_decl = lookup_field_wrapper (type,
9159 EXPR_WFL_NODE (qual_wfl));
9160 if (field_decl == NULL_TREE)
e04a16fb
AG		 9161 {
9162 parse_error_context
2aa11e97 9163 (qual_wfl, "No variable `%s' defined in type `%s'",
e04a16fb 9164 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
2aa11e97 9165 GET_TYPE_NAME (type));
e04a16fb
AG		 9166 return 1;
9167 }
dc0b3eff
PB		 9168 if (field_decl == error_mark_node)
9169 return 1;
5e942c50
APB		 9170
9171 /* Layout the type of field_decl, since we may need
c877974e
APB		 9172 it. Don't do primitive types or loaded classes. The
9173 situation of non primitive arrays may not handled
9174 properly here. FIXME */
5e942c50
APB		 9175 if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9176 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9177 else
9178 field_decl_type = TREE_TYPE (field_decl);
9179 if (!JPRIMITIVE_TYPE_P (field_decl_type)
c877974e
APB		 9180 && !CLASS_LOADED_P (field_decl_type)
9181 && !TYPE_ARRAY_P (field_decl_type))
9182 resolve_and_layout (field_decl_type, NULL_TREE);
9183 if (TYPE_ARRAY_P (field_decl_type))
9184 CLASS_LOADED_P (field_decl_type) = 1;
e04a16fb
AG		 9185
9186 /* Check on accessibility here */
9187 if (not_accessible_p (type, field_decl, from_super))
9188 {
9189 parse_error_context
9190 (qual_wfl,
9191 "Can't access %s field `%s.%s' from `%s'",
9192 java_accstring_lookup
9193 (get_access_flags_from_decl (field_decl)),
2aa11e97 9194 GET_TYPE_NAME (type),
e04a16fb
AG		 9195 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
9196 IDENTIFIER_POINTER
9197 (DECL_NAME (TYPE_NAME (current_class))));
9198 return 1;
9199 }
5e942c50 9200 check_deprecation (qual_wfl, field_decl);
e04a16fb
AG		 9201
9202 /* There are things to check when fields are accessed
9203 from type. There are no restrictions on a static
9204 declaration of the field when it is accessed from an
9205 interface */
9206 is_static = FIELD_STATIC (field_decl);
9207 if (!from_super && from_type
c2952b01
APB		 9208 && !TYPE_INTERFACE_P (type)
9209 && !is_static
9210 && (current_function_decl
9211 && METHOD_STATIC (current_function_decl)))
e04a16fb 9212 {
7f10c2e2 9213 static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
e04a16fb
AG		 9214 return 1;
9215 }
9216 from_cast = from_super = 0;
9217
c2952b01
APB		 9218 /* It's an access from a type but it isn't static, we
9219 make it relative to `this'. */
9220 if (!is_static && from_type)
9221 decl = current_this;
9222
5e942c50
APB		 9223 /* If we need to generate something to get a proper
9224 handle on what this field is accessed from, do it
9225 now. */
e04a16fb
AG		 9226 if (!is_static)
9227 {
c583dd46 9228 decl = maybe_access_field (decl, *where_found, *type_found);
e04a16fb
AG		 9229 if (decl == error_mark_node)
9230 return 1;
9231 }
9232
9233 /* We want to keep the location were found it, and the type
9234 we found. */
9235 *where_found = decl;
9236 *type_found = type;
9237
c2952b01
APB		 9238 /* Generate the correct expression for field access from
9239 qualified this */
9240 if (from_qualified_this)
9241 {
9242 field_decl = build_outer_field_access (qual_wfl, field_decl);
9243 from_qualified_this = 0;
9244 }
9245
e04a16fb
AG		 9246 /* This is the decl found and eventually the next one to
9247 search from */
9248 decl = field_decl;
9249 }
e04a16fb
AG		 9250 from_type = 0;
9251 type = QUAL_DECL_TYPE (decl);
c2952b01
APB		 9252
9253 /* Sneak preview. If decl is qualified by a `new', report
9254 the error here to be accurate on the peculiar construct */
9255 if (TREE_CHAIN (q)
9256 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
9257 && !JREFERENCE_TYPE_P (type))
9258 {
9259 parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
9260 lang_printable_name (type, 0));
9261 return 1;
9262 }
e04a16fb 9263 }
dde1da72
APB		 9264 /* `q' might have changed due to a after package resolution
9265 re-qualification */
9266 if (!q)
9267 break;
e04a16fb
AG		 9268 }
9269 *found_decl = decl;
9270 return 0;
9271}
9272
9273/* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
9274 can't be accessed from REFERENCE (a record type). */
9275
be245ac0
KG		 9276static int
9277not_accessible_p (reference, member, from_super)
e04a16fb
AG		 9278 tree reference, member;
9279 int from_super;
9280{
9281 int access_flag = get_access_flags_from_decl (member);
9282
9283 /* Access always granted for members declared public */
9284 if (access_flag & ACC_PUBLIC)
9285 return 0;
9286
9287 /* Check access on protected members */
9288 if (access_flag & ACC_PROTECTED)
9289 {
9290 /* Access granted if it occurs from within the package
9291 containing the class in which the protected member is
9292 declared */
9293 if (class_in_current_package (DECL_CONTEXT (member)))
9294 return 0;
9295
9bbc7d9f
PB		 9296 /* If accessed with the form `super.member', then access is granted */
9297 if (from_super)
9298 return 0;
e04a16fb 9299
9bbc7d9f
PB		 9300 /* Otherwise, access is granted if occuring from the class where
9301 member is declared or a subclass of it */
473e7b07 9302 if (inherits_from_p (reference, DECL_CONTEXT (member)))
9bbc7d9f 9303 return 0;
e04a16fb
AG		 9304 return 1;
9305 }
9306
9307 /* Check access on private members. Access is granted only if it
473e7b07
TT		 9308 occurs from within the class in which it is declared. Exceptions
9309 are accesses from inner-classes. This section is probably not
c2952b01 9310 complete. FIXME */
e04a16fb 9311 if (access_flag & ACC_PRIVATE)
c2952b01
APB		 9312 return (current_class == DECL_CONTEXT (member) ? 0 :
9313 (INNER_CLASS_TYPE_P (current_class) ? 0 : 1));
e04a16fb
AG		 9314
9315 /* Default access are permitted only when occuring within the
9316 package in which the type (REFERENCE) is declared. In other words,
9317 REFERENCE is defined in the current package */
9318 if (ctxp->package)
9319 return !class_in_current_package (reference);
473e7b07 9320
e04a16fb
AG		 9321 /* Otherwise, access is granted */
9322 return 0;
9323}
9324
5e942c50
APB		 9325/* Test deprecated decl access. */
9326static void
9327check_deprecation (wfl, decl)
9328 tree wfl, decl;
9329{
49f48c71 9330 const char *file = DECL_SOURCE_FILE (decl);
5e942c50
APB		 9331 /* Complain if the field is deprecated and the file it was defined
9332 in isn't compiled at the same time the file which contains its
9333 use is */
9334 if (DECL_DEPRECATED (decl)
9335 && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
9336 {
9337 char the [20];
9338 switch (TREE_CODE (decl))
9339 {
9340 case FUNCTION_DECL:
9341 strcpy (the, "method");
9342 break;
9343 case FIELD_DECL:
9344 strcpy (the, "field");
9345 break;
9346 case TYPE_DECL:
9347 strcpy (the, "class");
9348 break;
15fdcfe9
PB		 9349 default:
9350 fatal ("unexpected DECL code - check_deprecation");
5e942c50
APB		 9351 }
9352 parse_warning_context
9353 (wfl, "The %s `%s' in class `%s' has been deprecated",
9354 the, lang_printable_name (decl, 0),
9355 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
9356 }
9357}
9358
e04a16fb
AG		 9359/* Returns 1 if class was declared in the current package, 0 otherwise */
9360
9361static int
9362class_in_current_package (class)
9363 tree class;
9364{
9365 static tree cache = NULL_TREE;
9366 int qualified_flag;
9367 tree left;
9368
9369 if (cache == class)
9370 return 1;
9371
9372 qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
9373
9374 /* If the current package is empty and the name of CLASS is
9375 qualified, class isn't in the current package. If there is a
9376 current package and the name of the CLASS is not qualified, class
9377 isn't in the current package */
0a2138e2 9378 if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
e04a16fb
AG		 9379 return 0;
9380
9381 /* If there is not package and the name of CLASS isn't qualified,
9382 they belong to the same unnamed package */
9383 if (!ctxp->package && !qualified_flag)
9384 return 1;
9385
9386 /* Compare the left part of the name of CLASS with the package name */
9387 breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
9388 if (ctxp->package == left)
9389 {
9390 cache = class;
9391 return 1;
9392 }
9393 return 0;
9394}
9395
9396/* This function may generate code to access DECL from WHERE. This is
9397 done only if certain conditions meet. */
9398
9399static tree
9400maybe_access_field (decl, where, type)
9401 tree decl, where, type;
9402{
5e942c50
APB		 9403 if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
9404 && !FIELD_STATIC (decl))
e04a16fb 9405 decl = build_field_ref (where ? where : current_this,
c583dd46
APB		 9406 (type ? type : DECL_CONTEXT (decl)),
9407 DECL_NAME (decl));
e04a16fb
AG		 9408 return decl;
9409}
9410
15fdcfe9 9411/* Build a method invocation, by patching PATCH. If non NULL
e04a16fb
AG		 9412 and according to the situation, PRIMARY and WHERE may be
9413 used. IS_STATIC is set to 1 if the invoked function is static. */
9414
9415static tree
89e09b9a 9416patch_method_invocation (patch, primary, where, is_static, ret_decl)
e04a16fb
AG		 9417 tree patch, primary, where;
9418 int *is_static;
b9f7e36c 9419 tree *ret_decl;
e04a16fb
AG		 9420{
9421 tree wfl = TREE_OPERAND (patch, 0);
9422 tree args = TREE_OPERAND (patch, 1);
9423 tree name = EXPR_WFL_NODE (wfl);
5e942c50 9424 tree list;
22eed1e6 9425 int is_static_flag = 0;
89e09b9a 9426 int is_super_init = 0;
bccaf73a 9427 tree this_arg = NULL_TREE;
e04a16fb
AG		 9428
9429 /* Should be overriden if everything goes well. Otherwise, if
9430 something fails, it should keep this value. It stop the
9431 evaluation of a bogus assignment. See java_complete_tree,
9432 MODIFY_EXPR: for the reasons why we sometimes want to keep on
9433 evaluating an assignment */
9434 TREE_TYPE (patch) = error_mark_node;
9435
9436 /* Since lookup functions are messing with line numbers, save the
9437 context now. */
9438 java_parser_context_save_global ();
9439
9440 /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
9441
9442 /* Resolution of qualified name, excluding constructors */
9443 if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
9444 {
dde1da72 9445 tree identifier, identifier_wfl, type, resolved;
e04a16fb
AG		 9446 /* Extract the last IDENTIFIER of the qualified
9447 expression. This is a wfl and we will use it's location
9448 data during error report. */
9449 identifier_wfl = cut_identifier_in_qualified (wfl);
9450 identifier = EXPR_WFL_NODE (identifier_wfl);
9451
9452 /* Given the context, IDENTIFIER is syntactically qualified
9453 as a MethodName. We need to qualify what's before */
9454 qualify_ambiguous_name (wfl);
dde1da72 9455 resolved = resolve_field_access (wfl, NULL, NULL);
e04a16fb 9456
dde1da72
APB		 9457 if (resolved == error_mark_node)
9458 PATCH_METHOD_RETURN_ERROR ();
9459
9460 type = GET_SKIP_TYPE (resolved);
9461 resolve_and_layout (type, NULL_TREE);
6518c7b5
BM		 9462
9463 if (JPRIMITIVE_TYPE_P (type))
9464 {
9465 parse_error_context
9466 (identifier_wfl,
9467 "Can't invoke a method on primitive type `%s'",
9468 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
9469 PATCH_METHOD_RETURN_ERROR ();
9470 }
9471
dde1da72
APB		 9472 list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
9473 args = nreverse (args);
2c56429a 9474
e04a16fb 9475 /* We're resolving a call from a type */
dde1da72 9476 if (TREE_CODE (resolved) == TYPE_DECL)
e04a16fb 9477 {
dde1da72 9478 if (CLASS_INTERFACE (resolved))
e04a16fb
AG		 9479 {
9480 parse_error_context
781b0558
KG		 9481 (identifier_wfl,
9482 "Can't make static reference to method `%s' in interface `%s'",
9483 IDENTIFIER_POINTER (identifier),
e04a16fb 9484 IDENTIFIER_POINTER (name));
b9f7e36c 9485 PATCH_METHOD_RETURN_ERROR ();
e04a16fb 9486 }
e04a16fb
AG		 9487 if (list && !METHOD_STATIC (list))
9488 {
c2e3db92 9489 char *fct_name = xstrdup (lang_printable_name (list, 0));
e04a16fb
AG		 9490 parse_error_context
9491 (identifier_wfl,
9492 "Can't make static reference to method `%s %s' in class `%s'",
0a2138e2
APB		 9493 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
9494 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
e04a16fb 9495 free (fct_name);
b9f7e36c 9496 PATCH_METHOD_RETURN_ERROR ();
e04a16fb
AG		 9497 }
9498 }
e04a16fb 9499 else
dde1da72
APB		 9500 this_arg = primary = resolved;
9501
5e942c50 9502 /* IDENTIFIER_WFL will be used to report any problem further */
e04a16fb
AG		 9503 wfl = identifier_wfl;
9504 }
9505 /* Resolution of simple names, names generated after a primary: or
9506 constructors */
9507 else
9508 {
cd531a2e 9509 tree class_to_search = NULL_TREE;
c2952b01 9510 int lc; /* Looking for Constructor */
e04a16fb
AG		 9511
9512 /* We search constructor in their target class */
9513 if (CALL_CONSTRUCTOR_P (patch))
9514 {
22eed1e6
APB		 9515 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
9516 class_to_search = EXPR_WFL_NODE (wfl);
9517 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
9518 this_identifier_node)
9519 class_to_search = NULL_TREE;
9520 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
9521 super_identifier_node)
e04a16fb 9522 {
89e09b9a 9523 is_super_init = 1;
22eed1e6
APB		 9524 if (CLASSTYPE_SUPER (current_class))
9525 class_to_search =
9526 DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
9527 else
9528 {
781b0558 9529 parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
22eed1e6
APB		 9530 PATCH_METHOD_RETURN_ERROR ();
9531 }
e04a16fb 9532 }
22eed1e6
APB		 9533
9534 /* Class to search is NULL if we're searching the current one */
9535 if (class_to_search)
e04a16fb 9536 {
c2952b01
APB		 9537 class_to_search = resolve_and_layout (class_to_search, wfl);
9538
22eed1e6
APB		 9539 if (!class_to_search)
9540 {
9541 parse_error_context
9542 (wfl, "Class `%s' not found in type declaration",
9543 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9544 PATCH_METHOD_RETURN_ERROR ();
9545 }
9546
5e942c50
APB		 9547 /* Can't instantiate an abstract class, but we can
9548 invoke it's constructor. It's use within the `new'
9549 context is denied here. */
9550 if (CLASS_ABSTRACT (class_to_search)
9551 && TREE_CODE (patch) == NEW_CLASS_EXPR)
22eed1e6
APB		 9552 {
9553 parse_error_context
781b0558
KG		 9554 (wfl, "Class `%s' is an abstract class. It can't be instantiated",
9555 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
22eed1e6
APB		 9556 PATCH_METHOD_RETURN_ERROR ();
9557 }
c2952b01 9558
22eed1e6 9559 class_to_search = TREE_TYPE (class_to_search);
e04a16fb 9560 }
22eed1e6
APB		 9561 else
9562 class_to_search = current_class;
e04a16fb
AG		 9563 lc = 1;
9564 }
9565 /* This is a regular search in the local class, unless an
9566 alternate class is specified. */
9567 else
9568 {
9569 class_to_search = (where ? where : current_class);
9570 lc = 0;
9571 }
c2952b01 9572
e04a16fb
AG		 9573 /* NAME is a simple identifier or comes from a primary. Search
9574 in the class whose declaration contain the method being
9575 invoked. */
c877974e 9576 resolve_and_layout (class_to_search, NULL_TREE);
e04a16fb 9577
c2952b01 9578 list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
e04a16fb
AG		 9579 /* Don't continue if no method were found, as the next statement
9580 can't be executed then. */
b9f7e36c
APB		 9581 if (!list)
9582 PATCH_METHOD_RETURN_ERROR ();
e04a16fb
AG		 9583
9584 /* Check for static reference if non static methods */
9585 if (check_for_static_method_reference (wfl, patch, list,
9586 class_to_search, primary))
b9f7e36c 9587 PATCH_METHOD_RETURN_ERROR ();
e04a16fb 9588
165f37bc
APB		 9589 /* Check for inner classes creation from illegal contexts */
9590 if (lc && (INNER_CLASS_TYPE_P (class_to_search)
9591 && !CLASS_STATIC (TYPE_NAME (class_to_search)))
9592 && INNER_ENCLOSING_SCOPE_CHECK (class_to_search))
9593 {
9594 parse_error_context
9595 (wfl, "No enclosing instance for inner class `%s' is in scope%s",
9596 lang_printable_name (class_to_search, 0),
9597 (!current_this ? "" :
9598 "; an explicit one must be provided when creating this inner class"));
9599 PATCH_METHOD_RETURN_ERROR ();
9600 }
9601
22eed1e6
APB		 9602 /* Non static methods are called with the current object extra
9603 argument. If patch a `new TYPE()', the argument is the value
9604 returned by the object allocator. If method is resolved as a
9605 primary, use the primary otherwise use the current THIS. */
b9f7e36c 9606 args = nreverse (args);
bccaf73a 9607 if (TREE_CODE (patch) != NEW_CLASS_EXPR)
c2952b01
APB		 9608 {
9609 this_arg = primary ? primary : current_this;
9610
9611 /* If we're using an access method, things are different.
9612 There are two familly of cases:
9613
9614 1) We're not generating bytecodes:
9615
9616 - LIST is non static. It's invocation is transformed from
9617 x(a1,...,an) into this$<n>.x(a1,....an).
9618 - LIST is static. It's invocation is transformed from
9619 x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
9620
9621 2) We're generating bytecodes:
9622
9623 - LIST is non static. It's invocation is transformed from
9624 x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
9625 - LIST is static. It's invocation is transformed from
9626 x(a1,....,an) into TYPEOF(this$<n>).x(a1,....an).
9627
9628 Of course, this$<n> can be abitrary complex, ranging from
9629 this$0 (the immediate outer context) to
9630 access$0(access$0(...(this$0))).
9631
9632 maybe_use_access_method returns a non zero value if the
dfb99c83
APB		 9633 this_arg has to be moved into the (then generated) stub
9634 argument list. In the mean time, the selected function
9635 might have be replaced by a generated stub. */
c2952b01
APB		 9636 if (maybe_use_access_method (is_super_init, &list, &this_arg))
9637 args = tree_cons (NULL_TREE, this_arg, args);
9638 }
e04a16fb 9639 }
b67d701b 9640
e04a16fb
AG		 9641 /* Merge point of all resolution schemes. If we have nothing, this
9642 is an error, already signaled */
b9f7e36c
APB		 9643 if (!list)
9644 PATCH_METHOD_RETURN_ERROR ();
b67d701b 9645
e04a16fb
AG		 9646 /* Check accessibility, position the is_static flag, build and
9647 return the call */
9bbc7d9f 9648 if (not_accessible_p (DECL_CONTEXT (current_function_decl), list, 0))
e04a16fb 9649 {
c2e3db92 9650 char *fct_name = xstrdup (lang_printable_name (list, 0));
e04a16fb
AG		 9651 parse_error_context
9652 (wfl, "Can't access %s method `%s %s.%s' from `%s'",
9653 java_accstring_lookup (get_access_flags_from_decl (list)),
0a2138e2 9654 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
5e942c50
APB		 9655 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list)))),
9656 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
e04a16fb 9657 free (fct_name);
b9f7e36c 9658 PATCH_METHOD_RETURN_ERROR ();
e04a16fb 9659 }
5e942c50 9660 check_deprecation (wfl, list);
22eed1e6 9661
c2952b01
APB		 9662 /* If invoking a innerclass constructor, there are hidden parameters
9663 to pass */
9664 if (TREE_CODE (patch) == NEW_CLASS_EXPR
9665 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
9666 {
9667 /* And make sure we add the accessed local variables to be saved
9668 in field aliases. */
9669 args = build_alias_initializer_parameter_list
9670 (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
9671
9672 /* We have to reverse things. Find out why. FIXME */
9673 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (list)))
9674 args = nreverse (args);
9675
9676 /* Secretely pass the current_this/primary as a second argument */
165f37bc
APB		 9677 if (primary || current_this)
9678 args = tree_cons (NULL_TREE, (primary ? primary : current_this), args);
9679 else
9680 args = tree_cons (NULL_TREE, integer_zero_node, args);
c2952b01
APB		 9681 }
9682
152de068
APB		 9683 /* This handles the situation where a constructor invocation needs
9684 to have an enclosing context passed as a second parameter (the
9685 constructor is one of an inner class. We extract it from the
9686 current function. */
9687 if (is_super_init && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
9688 {
9689 tree enclosing_decl = DECL_CONTEXT (TYPE_NAME (current_class));
9690 tree extra_arg;
9691
9692 if (ANONYMOUS_CLASS_P (current_class) || !DECL_CONTEXT (enclosing_decl))
9693 {
9694 extra_arg = DECL_FUNCTION_BODY (current_function_decl);
9695 extra_arg = TREE_CHAIN (BLOCK_EXPR_DECLS (extra_arg));
9696 }
9697 else
9698 {
9699 tree dest = TREE_TYPE (DECL_CONTEXT (enclosing_decl));
9700 extra_arg =
9701 build_access_to_thisn (TREE_TYPE (enclosing_decl), dest, 0);
9702 extra_arg = java_complete_tree (extra_arg);
9703 }
9704 args = tree_cons (NULL_TREE, extra_arg, args);
9705 }
9706
22eed1e6 9707 is_static_flag = METHOD_STATIC (list);
bccaf73a
PB		 9708 if (! METHOD_STATIC (list) && this_arg != NULL_TREE)
9709 args = tree_cons (NULL_TREE, this_arg, args);
22eed1e6 9710
c3f2a476
APB		 9711 /* In the context of an explicit constructor invocation, we can't
9712 invoke any method relying on `this'. Exceptions are: we're
9713 invoking a static function, primary exists and is not the current
9714 this, we're creating a new object. */
22eed1e6 9715 if (ctxp->explicit_constructor_p
c3f2a476
APB		 9716 && !is_static_flag
9717 && (!primary || primary == current_this)
9718 && (TREE_CODE (patch) != NEW_CLASS_EXPR))
22eed1e6 9719 {
781b0558 9720 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
22eed1e6
APB		 9721 PATCH_METHOD_RETURN_ERROR ();
9722 }
e04a16fb 9723 java_parser_context_restore_global ();
22eed1e6
APB		 9724 if (is_static)
9725 *is_static = is_static_flag;
b9f7e36c
APB		 9726 /* Sometimes, we want the decl of the selected method. Such as for
9727 EH checking */
9728 if (ret_decl)
9729 *ret_decl = list;
89e09b9a
PB		 9730 patch = patch_invoke (patch, list, args);
9731 if (is_super_init && CLASS_HAS_FINIT_P (current_class))
9732 {
c2952b01
APB		 9733 tree finit_parms, finit_call;
9734
9735 /* Prepare to pass hidden parameters to $finit$, if any. */
9736 finit_parms = build_alias_initializer_parameter_list
9737 (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
89e09b9a 9738
c2952b01
APB		 9739 finit_call =
9740 build_method_invocation (build_wfl_node (finit_identifier_node),
9741 finit_parms);
9742
9743 /* Generate the code used to initialize fields declared with an
9744 initialization statement and build a compound statement along
9745 with the super constructor invocation. */
89e09b9a
PB		 9746 patch = build (COMPOUND_EXPR, void_type_node, patch,
9747 java_complete_tree (finit_call));
9748 CAN_COMPLETE_NORMALLY (patch) = 1;
9749 }
9750 return patch;
e04a16fb
AG		 9751}
9752
9753/* Check that we're not trying to do a static reference to a method in
9754 non static method. Return 1 if it's the case, 0 otherwise. */
9755
9756static int
9757check_for_static_method_reference (wfl, node, method, where, primary)
9758 tree wfl, node, method, where, primary;
9759{
9760 if (METHOD_STATIC (current_function_decl)
9761 && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
9762 {
c2e3db92 9763 char *fct_name = xstrdup (lang_printable_name (method, 0));
e04a16fb
AG		 9764 parse_error_context
9765 (wfl, "Can't make static reference to method `%s %s' in class `%s'",
0a2138e2 9766 lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
e04a16fb
AG		 9767 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
9768 free (fct_name);
9769 return 1;
9770 }
9771 return 0;
9772}
9773
c2952b01
APB		 9774/* Fix the invocation of *MDECL if necessary in the case of a
9775 invocation from an inner class. *THIS_ARG might be modified
9776 appropriately and an alternative access to *MDECL might be
9777 returned. */
9778
9779static int
9780maybe_use_access_method (is_super_init, mdecl, this_arg)
9781 int is_super_init;
9782 tree *mdecl, *this_arg;
9783{
9784 tree ctx;
9785 tree md = *mdecl, ta = *this_arg;
9786 int to_return = 0;
9787 int non_static_context = !METHOD_STATIC (md);
9788
9789 if (is_super_init
165f37bc
APB		 9790 || DECL_CONTEXT (md) == current_class
9791 || !PURE_INNER_CLASS_TYPE_P (current_class)
9792 || DECL_FINIT_P (md))
c2952b01
APB		 9793 return 0;
9794
9795 /* If we're calling a method found in an enclosing class, generate
9796 what it takes to retrieve the right this. Don't do that if we're
9797 invoking a static method. */
9798
9799 if (non_static_context)
9800 {
9801 ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
9802 if (ctx == DECL_CONTEXT (md))
9803 {
9804 ta = build_current_thisn (current_class);
9805 ta = build_wfl_node (ta);
9806 }
9807 else
9808 {
9809 tree type = ctx;
9810 while (type)
9811 {
9812 maybe_build_thisn_access_method (type);
9813 if (type == DECL_CONTEXT (md))
9814 {
9815 ta = build_access_to_thisn (ctx, type, 0);
9816 break;
9817 }
9818 type = (DECL_CONTEXT (TYPE_NAME (type)) ?
9819 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
9820 }
9821 }
9822 ta = java_complete_tree (ta);
9823 }
9824
9825 /* We might have to use an access method to get to MD. We can
9826 break the method access rule as far as we're not generating
9827 bytecode */
9828 if (METHOD_PRIVATE (md) && flag_emit_class_files)
9829 {
9830 md = build_outer_method_access_method (md);
9831 to_return = 1;
9832 }
9833
9834 *mdecl = md;
9835 *this_arg = ta;
9836
9837 /* Returnin a non zero value indicates we were doing a non static
9838 method invokation that is now a static invocation. It will have
9839 callee displace `this' to insert it in the regular argument
9840 list. */
9841 return (non_static_context && to_return);
9842}
9843
e04a16fb
AG		 9844/* Patch an invoke expression METHOD and ARGS, based on its invocation
9845 mode. */
9846
9847static tree
89e09b9a 9848patch_invoke (patch, method, args)
e04a16fb 9849 tree patch, method, args;
e04a16fb
AG		 9850{
9851 tree dtable, func;
0a2138e2 9852 tree original_call, t, ta;
e815887f 9853 tree cond = NULL_TREE;
e04a16fb 9854
5e942c50
APB		 9855 /* Last step for args: convert build-in types. If we're dealing with
9856 a new TYPE() type call, the first argument to the constructor
e815887f 9857 isn't found in the incoming argument list, but delivered by
5e942c50
APB		 9858 `new' */
9859 t = TYPE_ARG_TYPES (TREE_TYPE (method));
9860 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
9861 t = TREE_CHAIN (t);
ac825856
APB		 9862 for (ta = args; t != end_params_node && ta;
9863 t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
b9f7e36c
APB		 9864 if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
9865 TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
9866 TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
1a6d4fb7
APB		 9867
9868 /* Resolve unresolved returned type isses */
9869 t = TREE_TYPE (TREE_TYPE (method));
9870 if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
9871 resolve_and_layout (TREE_TYPE (t), NULL);
c2952b01 9872
e8fc7396 9873 if (flag_emit_class_files || flag_emit_xref)
15fdcfe9
PB		 9874 func = method;
9875 else
e04a16fb 9876 {
15fdcfe9 9877 tree signature = build_java_signature (TREE_TYPE (method));
89e09b9a 9878 switch (invocation_mode (method, CALL_USING_SUPER (patch)))
15fdcfe9
PB		 9879 {
9880 case INVOKE_VIRTUAL:
9881 dtable = invoke_build_dtable (0, args);
9882 func = build_invokevirtual (dtable, method);
9883 break;
b9f7e36c 9884
e815887f
TT		 9885 case INVOKE_NONVIRTUAL:
9886 /* If the object for the method call is null, we throw an
9887 exception. We don't do this if the object is the current
9888 method's `this'. In other cases we just rely on an
9889 optimization pass to eliminate redundant checks. */
9890 if (TREE_VALUE (args) != current_this)
9891 {
9892 /* We use a SAVE_EXPR here to make sure we only evaluate
9893 the new `self' expression once. */
9894 tree save_arg = save_expr (TREE_VALUE (args));
9895 TREE_VALUE (args) = save_arg;
9896 cond = build (EQ_EXPR, boolean_type_node, save_arg,
9897 null_pointer_node);
9898 }
9899 /* Fall through. */
9900
15fdcfe9
PB		 9901 case INVOKE_SUPER:
9902 case INVOKE_STATIC:
9903 func = build_known_method_ref (method, TREE_TYPE (method),
9904 DECL_CONTEXT (method),
9905 signature, args);
9906 break;
e04a16fb 9907
15fdcfe9
PB		 9908 case INVOKE_INTERFACE:
9909 dtable = invoke_build_dtable (1, args);
173f556c 9910 func = build_invokeinterface (dtable, method);
15fdcfe9 9911 break;
5e942c50 9912
15fdcfe9 9913 default:
89e09b9a 9914 fatal ("internal error - unknown invocation_mode result");
15fdcfe9
PB		 9915 }
9916
9917 /* Ensure self_type is initialized, (invokestatic). FIXME */
9918 func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
e04a16fb
AG		 9919 }
9920
e04a16fb
AG		 9921 TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
9922 TREE_OPERAND (patch, 0) = func;
9923 TREE_OPERAND (patch, 1) = args;
9924 original_call = patch;
9925
e815887f 9926 /* We're processing a `new TYPE ()' form. New is called and its
22eed1e6
APB		 9927 returned value is the first argument to the constructor. We build
9928 a COMPOUND_EXPR and use saved expression so that the overall NEW
9929 expression value is a pointer to a newly created and initialized
9930 class. */
9931 if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
e04a16fb
AG		 9932 {
9933 tree class = DECL_CONTEXT (method);
9934 tree c1, saved_new, size, new;
e8fc7396 9935 if (flag_emit_class_files || flag_emit_xref)
15fdcfe9
PB		 9936 {
9937 TREE_TYPE (patch) = build_pointer_type (class);
9938 return patch;
9939 }
e04a16fb
AG		 9940 if (!TYPE_SIZE (class))
9941 safe_layout_class (class);
9942 size = size_in_bytes (class);
9943 new = build (CALL_EXPR, promote_type (class),
9944 build_address_of (alloc_object_node),
9945 tree_cons (NULL_TREE, build_class_ref (class),
9946 build_tree_list (NULL_TREE,
9947 size_in_bytes (class))),
9948 NULL_TREE);
9949 saved_new = save_expr (new);
9950 c1 = build_tree_list (NULL_TREE, saved_new);
9951 TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
9952 TREE_OPERAND (original_call, 1) = c1;
9953 TREE_SET_CODE (original_call, CALL_EXPR);
9954 patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
9955 }
e815887f
TT		 9956
9957 /* If COND is set, then we are building a check to see if the object
9958 is NULL. */
9959 if (cond != NULL_TREE)
9960 {
9961 /* We have to make the `then' branch a compound expression to
9962 make the types turn out right. This seems bizarre. */
9963 patch = build (COND_EXPR, TREE_TYPE (patch), cond,
9964 build (COMPOUND_EXPR, TREE_TYPE (patch),
9965 build (CALL_EXPR, void_type_node,
9966 build_address_of (soft_nullpointer_node),
9967 NULL_TREE, NULL_TREE),
9968 (FLOAT_TYPE_P (TREE_TYPE (patch))
9969 ? build_real (TREE_TYPE (patch), dconst0)
9970 : build1 (CONVERT_EXPR, TREE_TYPE (patch),
9971 integer_zero_node))),
9972 patch);
9973 TREE_SIDE_EFFECTS (patch) = 1;
9974 }
9975
e04a16fb
AG		 9976 return patch;
9977}
9978
9979static int
9980invocation_mode (method, super)
9981 tree method;
9982 int super;
9983{
9984 int access = get_access_flags_from_decl (method);
9985
22eed1e6
APB		 9986 if (super)
9987 return INVOKE_SUPER;
9988
e815887f 9989 if (access & ACC_STATIC)
e04a16fb
AG		 9990 return INVOKE_STATIC;
9991
e815887f
TT		 9992 /* We have to look for a constructor before we handle nonvirtual
9993 calls; otherwise the constructor will look nonvirtual. */
9994 if (DECL_CONSTRUCTOR_P (method))
e04a16fb 9995 return INVOKE_STATIC;
e815887f
TT		 9996
9997 if (access & ACC_FINAL || access & ACC_PRIVATE)
9998 return INVOKE_NONVIRTUAL;
9999
10000 if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10001 return INVOKE_NONVIRTUAL;
10002
e04a16fb
AG		 10003 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10004 return INVOKE_INTERFACE;
22eed1e6 10005
e04a16fb
AG		 10006 return INVOKE_VIRTUAL;
10007}
10008
b67d701b
PB		 10009/* Retrieve a refined list of matching methods. It covers the step
10010 15.11.2 (Compile-Time Step 2) */
e04a16fb
AG		 10011
10012static tree
10013lookup_method_invoke (lc, cl, class, name, arg_list)
10014 int lc;
10015 tree cl;
10016 tree class, name, arg_list;
10017{
de4c7b02 10018 tree atl = end_params_node; /* Arg Type List */
c877974e 10019 tree method, signature, list, node;
49f48c71 10020 const char *candidates; /* Used for error report */
b5b8a0e7 10021 char *dup;
e04a16fb 10022
5e942c50 10023 /* Fix the arguments */
e04a16fb
AG		 10024 for (node = arg_list; node; node = TREE_CHAIN (node))
10025 {
e3884b71 10026 tree current_arg = TREE_TYPE (TREE_VALUE (node));
c877974e 10027 /* Non primitive type may have to be resolved */
e3884b71 10028 if (!JPRIMITIVE_TYPE_P (current_arg))
c877974e
APB		 10029 resolve_and_layout (current_arg, NULL_TREE);
10030 /* And promoted */
b67d701b 10031 if (TREE_CODE (current_arg) == RECORD_TYPE)
c877974e 10032 current_arg = promote_type (current_arg);
5e942c50 10033 atl = tree_cons (NULL_TREE, current_arg, atl);
e04a16fb 10034 }
e04a16fb 10035
c2952b01
APB		 10036 /* Presto. If we're dealing with an anonymous class and a
10037 constructor call, generate the right constructor now, since we
10038 know the arguments' types. */
10039
10040 if (lc && ANONYMOUS_CLASS_P (class))
10041 craft_constructor (TYPE_NAME (class), atl);
10042
5e942c50
APB		 10043 /* Find all candidates and then refine the list, searching for the
10044 most specific method. */
10045 list = find_applicable_accessible_methods_list (lc, class, name, atl);
10046 list = find_most_specific_methods_list (list);
b67d701b
PB		 10047 if (list && !TREE_CHAIN (list))
10048 return TREE_VALUE (list);
e04a16fb 10049
b67d701b
PB		 10050 /* Issue an error. List candidates if any. Candidates are listed
10051 only if accessible (non accessible methods may end-up here for
10052 the sake of a better error report). */
10053 candidates = NULL;
10054 if (list)
e04a16fb 10055 {
e04a16fb 10056 tree current;
b67d701b 10057 obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
e04a16fb
AG		 10058 for (current = list; current; current = TREE_CHAIN (current))
10059 {
b67d701b
PB		 10060 tree cm = TREE_VALUE (current);
10061 char string [4096];
10062 if (!cm || not_accessible_p (class, cm, 0))
10063 continue;
b67d701b 10064 sprintf
22eed1e6
APB		 10065 (string, " `%s' in `%s'%s",
10066 get_printable_method_name (cm),
b67d701b
PB		 10067 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10068 (TREE_CHAIN (current) ? "\n" : ""));
10069 obstack_grow (&temporary_obstack, string, strlen (string));
10070 }
10071 obstack_1grow (&temporary_obstack, '\0');
10072 candidates = obstack_finish (&temporary_obstack);
10073 }
10074 /* Issue the error message */
c877974e
APB		 10075 method = make_node (FUNCTION_TYPE);
10076 TYPE_ARG_TYPES (method) = atl;
b67d701b 10077 signature = build_java_argument_signature (method);
c63b98cd 10078 dup = xstrdup (lang_printable_name (class, 0));
b5b8a0e7 10079 parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
22eed1e6 10080 (lc ? "constructor" : "method"),
b5b8a0e7
APB		 10081 (lc ? dup : IDENTIFIER_POINTER (name)),
10082 IDENTIFIER_POINTER (signature), dup,
b67d701b 10083 (candidates ? candidates : ""));
b5b8a0e7 10084 free (dup);
b67d701b
PB		 10085 return NULL_TREE;
10086}
10087
5e942c50
APB		 10088/* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10089 when we're looking for a constructor. */
b67d701b
PB		 10090
10091static tree
5e942c50
APB		 10092find_applicable_accessible_methods_list (lc, class, name, arglist)
10093 int lc;
b67d701b
PB		 10094 tree class, name, arglist;
10095{
ad69b5b6
BM		 10096 static struct hash_table t, *searched_classes = NULL;
10097 static int search_not_done = 0;
b67d701b
PB		 10098 tree list = NULL_TREE, all_list = NULL_TREE;
10099
ad69b5b6
BM		 10100 /* Check the hash table to determine if this class has been searched
10101 already. */
10102 if (searched_classes)
10103 {
10104 if (hash_lookup (searched_classes,
10105 (const hash_table_key) class, FALSE, NULL))
10106 return NULL;
10107 }
10108 else
10109 {
10110 hash_table_init (&t, hash_newfunc, java_hash_hash_tree_node,
10111 java_hash_compare_tree_node);
10112 searched_classes = &t;
10113 }
10114
10115 search_not_done++;
10116 hash_lookup (searched_classes,
10117 (const hash_table_key) class, TRUE, NULL);
10118
c2952b01
APB		 10119 if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
10120 {
10121 load_class (class, 1);
10122 safe_layout_class (class);
10123 }
10124
1982388a 10125 /* Search interfaces */
9a7ab4b3
APB		 10126 if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
10127 && CLASS_INTERFACE (TYPE_NAME (class)))
b67d701b 10128 {
1982388a
APB		 10129 int i, n;
10130 tree basetype_vec = TYPE_BINFO_BASETYPES (class);
165f37bc
APB		 10131 search_applicable_methods_list (lc, TYPE_METHODS (class),
10132 name, arglist, &list, &all_list);
1982388a 10133 n = TREE_VEC_LENGTH (basetype_vec);
165f37bc 10134 for (i = 1; i < n; i++)
b67d701b 10135 {
de0b553f
APB		 10136 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
10137 tree rlist;
10138
de0b553f
APB		 10139 rlist = find_applicable_accessible_methods_list (lc, t, name,
10140 arglist);
165f37bc 10141 list = chainon (rlist, list);
e04a16fb 10142 }
e04a16fb 10143 }
1982388a
APB		 10144 /* Search classes */
10145 else
c2952b01 10146 {
165f37bc
APB		 10147 tree sc = class;
10148 int seen_inner_class = 0;
c2952b01
APB		 10149 search_applicable_methods_list (lc, TYPE_METHODS (class),
10150 name, arglist, &list, &all_list);
10151
165f37bc
APB		 10152 /* We must search all interfaces of this class */
10153 if (!lc)
10154 {
10155 tree basetype_vec = TYPE_BINFO_BASETYPES (sc);
10156 int n = TREE_VEC_LENGTH (basetype_vec), i;
165f37bc
APB		 10157 for (i = 1; i < n; i++)
10158 {
10159 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
165f37bc 10160 if (t != object_type_node)
30a3caef
ZW		 10161 {
10162 tree rlist
10163 = find_applicable_accessible_methods_list (lc, t,
10164 name, arglist);
10165 list = chainon (rlist, list);
10166 }
165f37bc 10167 }
165f37bc
APB		 10168 }
10169
c2952b01
APB		 10170 /* Search enclosing context of inner classes before looking
10171 ancestors up. */
10172 while (!lc && INNER_CLASS_TYPE_P (class))
10173 {
165f37bc
APB		 10174 tree rlist;
10175 seen_inner_class = 1;
c2952b01 10176 class = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
165f37bc
APB		 10177 rlist = find_applicable_accessible_methods_list (lc, class,
10178 name, arglist);
10179 list = chainon (rlist, list);
c2952b01 10180 }
165f37bc
APB		 10181
10182 if (!lc && seen_inner_class
10183 && TREE_TYPE (DECL_CONTEXT (TYPE_NAME (sc))) == CLASSTYPE_SUPER (sc))
10184 class = CLASSTYPE_SUPER (sc);
10185 else
10186 class = sc;
10187
ad69b5b6
BM		 10188 /* Search superclass */
10189 if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
10190 {
10191 tree rlist;
10192 class = CLASSTYPE_SUPER (class);
10193 rlist = find_applicable_accessible_methods_list (lc, class,
10194 name, arglist);
10195 list = chainon (rlist, list);
10196 }
10197 }
10198
10199 search_not_done--;
10200
10201 /* We're done. Reset the searched classes list and finally search
10202 java.lang.Object if it wasn't searched already. */
10203 if (!search_not_done)
10204 {
10205 if (!lc
10206 && TYPE_METHODS (object_type_node)
10207 && !hash_lookup (searched_classes,
10208 (const hash_table_key) object_type_node,
10209 FALSE, NULL))
10210 {
10211 search_applicable_methods_list (lc,
10212 TYPE_METHODS (object_type_node),
10213 name, arglist, &list, &all_list);
10214 }
10215 hash_table_free (searched_classes);
10216 searched_classes = NULL;
c2952b01 10217 }
1982388a 10218
b67d701b
PB		 10219 /* Either return the list obtained or all selected (but
10220 inaccessible) methods for better error report. */
10221 return (!list ? all_list : list);
10222}
e04a16fb 10223
ad69b5b6 10224/* Effectively search for the appropriate method in method */
1982388a
APB		 10225
10226static void
c2952b01 10227search_applicable_methods_list (lc, method, name, arglist, list, all_list)
1982388a
APB		 10228 int lc;
10229 tree method, name, arglist;
10230 tree *list, *all_list;
10231{
10232 for (; method; method = TREE_CHAIN (method))
10233 {
10234 /* When dealing with constructor, stop here, otherwise search
10235 other classes */
10236 if (lc && !DECL_CONSTRUCTOR_P (method))
10237 continue;
10238 else if (!lc && (DECL_CONSTRUCTOR_P (method)
10239 || (GET_METHOD_NAME (method) != name)))
10240 continue;
10241
10242 if (argument_types_convertible (method, arglist))
10243 {
10244 /* Retain accessible methods only */
10245 if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
10246 method, 0))
10247 *list = tree_cons (NULL_TREE, method, *list);
10248 else
10249 /* Also retain all selected method here */
10250 *all_list = tree_cons (NULL_TREE, method, *list);
10251 }
10252 }
ad69b5b6 10253}
1982388a 10254
b67d701b
PB		 10255/* 15.11.2.2 Choose the Most Specific Method */
10256
10257static tree
10258find_most_specific_methods_list (list)
10259 tree list;
10260{
10261 int max = 0;
9a7ab4b3 10262 int abstract, candidates;
b67d701b
PB		 10263 tree current, new_list = NULL_TREE;
10264 for (current = list; current; current = TREE_CHAIN (current))
e04a16fb 10265 {
b67d701b
PB		 10266 tree method;
10267 DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
10268
10269 for (method = list; method; method = TREE_CHAIN (method))
10270 {
10271 /* Don't test a method against itself */
10272 if (method == current)
10273 continue;
10274
10275 /* Compare arguments and location where method where declared */
10276 if (argument_types_convertible (TREE_VALUE (method),
10277 TREE_VALUE (current))
10278 && valid_method_invocation_conversion_p
10279 (DECL_CONTEXT (TREE_VALUE (method)),
10280 DECL_CONTEXT (TREE_VALUE (current))))
10281 {
10282 int v = ++DECL_SPECIFIC_COUNT (TREE_VALUE (current));
10283 max = (v > max ? v : max);
10284 }
10285 }
e04a16fb
AG		 10286 }
10287
b67d701b 10288 /* Review the list and select the maximally specific methods */
9a7ab4b3
APB		 10289 for (current = list, abstract = -1, candidates = -1;
10290 current; current = TREE_CHAIN (current))
b67d701b 10291 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
9a7ab4b3
APB		 10292 {
10293 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
10294 abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
10295 candidates++;
10296 }
b67d701b 10297
165f37bc
APB		 10298 /* If we have several and they're all abstract, just pick the
10299 closest one. */
9a7ab4b3
APB		 10300 if (candidates > 0 && (candidates == abstract))
10301 {
10302 new_list = nreverse (new_list);
10303 TREE_CHAIN (new_list) = NULL_TREE;
10304 }
165f37bc 10305
9a7ab4b3
APB		 10306 /* We have several, we couldn't find a most specific, all but one are
10307 abstract, we pick the only non abstract one. */
10308 if (candidates > 0 && !max && (candidates == abstract+1))
165f37bc 10309 {
9a7ab4b3
APB		 10310 for (current = new_list; current; current = TREE_CHAIN (current))
10311 if (!METHOD_ABSTRACT (TREE_VALUE (current)))
10312 {
10313 TREE_CHAIN (current) = NULL_TREE;
10314 new_list = current;
10315 }
165f37bc
APB		 10316 }
10317
b67d701b
PB		 10318 /* If we can't find one, lower expectations and try to gather multiple
10319 maximally specific methods */
165f37bc 10320 while (!new_list && max)
b67d701b
PB		 10321 {
10322 while (--max > 0)
10323 {
10324 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
10325 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
10326 }
b67d701b
PB		 10327 }
10328
10329 return new_list;
e04a16fb
AG		 10330}
10331
b67d701b
PB		 10332/* Make sure that the type of each M2_OR_ARGLIST arguments can be
10333 converted by method invocation conversion (5.3) to the type of the
10334 corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
10335 to change less often than M1. */
e04a16fb 10336
b67d701b
PB		 10337static int
10338argument_types_convertible (m1, m2_or_arglist)
10339 tree m1, m2_or_arglist;
e04a16fb 10340{
b67d701b
PB		 10341 static tree m2_arg_value = NULL_TREE;
10342 static tree m2_arg_cache = NULL_TREE;
e04a16fb 10343
b67d701b 10344 register tree m1_arg, m2_arg;
e04a16fb 10345
c2952b01 10346 SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
e04a16fb 10347
b67d701b
PB		 10348 if (m2_arg_value == m2_or_arglist)
10349 m2_arg = m2_arg_cache;
10350 else
10351 {
10352 /* M2_OR_ARGLIST can be a function DECL or a raw list of
10353 argument types */
10354 if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
10355 {
10356 m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
10357 if (!METHOD_STATIC (m2_or_arglist))
10358 m2_arg = TREE_CHAIN (m2_arg);
10359 }
10360 else
10361 m2_arg = m2_or_arglist;
e04a16fb 10362
b67d701b
PB		 10363 m2_arg_value = m2_or_arglist;
10364 m2_arg_cache = m2_arg;
10365 }
e04a16fb 10366
de4c7b02 10367 while (m1_arg != end_params_node && m2_arg != end_params_node)
b67d701b 10368 {
c877974e 10369 resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
b67d701b
PB		 10370 if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
10371 TREE_VALUE (m2_arg)))
10372 break;
10373 m1_arg = TREE_CHAIN (m1_arg);
10374 m2_arg = TREE_CHAIN (m2_arg);
e04a16fb 10375 }
de4c7b02 10376 return m1_arg == end_params_node && m2_arg == end_params_node;
e04a16fb
AG		 10377}
10378
10379/* Qualification routines */
10380
10381static void
10382qualify_ambiguous_name (id)
10383 tree id;
10384{
cd531a2e
KG		 10385 tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
10386 saved_current_class;
d8fccff5 10387 int again, super_found = 0, this_found = 0, new_array_found = 0;
8576f094 10388 int code;
e04a16fb
AG		 10389
10390 /* We first qualify the first element, then derive qualification of
10391 others based on the first one. If the first element is qualified
10392 by a resolution (field or type), this resolution is stored in the
10393 QUAL_RESOLUTION of the qual element being examined. We need to
10394 save the current_class since the use of SUPER might change the
10395 its value. */
10396 saved_current_class = current_class;
10397 qual = EXPR_WFL_QUALIFICATION (id);
10398 do {
10399
10400 /* Simple qualified expression feature a qual_wfl that is a
10401 WFL. Expression derived from a primary feature more complicated
10402 things like a CALL_EXPR. Expression from primary need to be
10403 worked out to extract the part on which the qualification will
10404 take place. */
10405 qual_wfl = QUAL_WFL (qual);
10406 switch (TREE_CODE (qual_wfl))
10407 {
10408 case CALL_EXPR:
10409 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10410 if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
10411 {
10412 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
10413 qual_wfl = QUAL_WFL (qual);
10414 }
10415 break;
d8fccff5 10416 case NEW_ARRAY_EXPR:
c2952b01 10417 case NEW_ANONYMOUS_ARRAY_EXPR:
d8fccff5 10418 qual = TREE_CHAIN (qual);
1a6d4fb7 10419 again = new_array_found = 1;
d8fccff5 10420 continue;
e04a16fb 10421 case CONVERT_EXPR:
f2760b27
APB		 10422 break;
10423 case NEW_CLASS_EXPR:
e04a16fb
AG		 10424 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10425 break;
c583dd46
APB		 10426 case ARRAY_REF:
10427 while (TREE_CODE (qual_wfl) == ARRAY_REF)
10428 qual_wfl = TREE_OPERAND (qual_wfl, 0);
10429 break;
8576f094
APB		 10430 case STRING_CST:
10431 qual = TREE_CHAIN (qual);
10432 qual_wfl = QUAL_WFL (qual);
10433 break;
165f37bc
APB		 10434 case CLASS_LITERAL:
10435 qual = TREE_CHAIN (qual);
10436 qual_wfl = QUAL_WFL (qual);
10437 break;
0a2138e2
APB		 10438 default:
10439 /* Fix for -Wall. Just break doing nothing */
10440 break;
e04a16fb 10441 }
8576f094 10442
e04a16fb
AG		 10443 ptr_type = current_class;
10444 again = 0;
8576f094
APB		 10445 code = TREE_CODE (qual_wfl);
10446
10447 /* Pos evaluation: non WFL leading expression nodes */
10448 if (code == CONVERT_EXPR
10449 && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
10450 name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
10451
cd7c5840
APB		 10452 else if (code == INTEGER_CST)
10453 name = qual_wfl;
10454
ac22f9cb 10455 else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
8576f094
APB		 10456 TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
10457 name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
10458
c2952b01
APB		 10459 else if (code == TREE_LIST)
10460 name = EXPR_WFL_NODE (TREE_PURPOSE (qual_wfl));
10461
37feda7d
APB		 10462 else if (code == STRING_CST || code == CONDITIONAL_EXPR
10463 || code == PLUS_EXPR)
8576f094
APB		 10464 {
10465 qual = TREE_CHAIN (qual);
10466 qual_wfl = QUAL_WFL (qual);
10467 again = 1;
10468 }
10469 else
f441f671
APB		 10470 {
10471 name = EXPR_WFL_NODE (qual_wfl);
10472 if (!name)
10473 {
10474 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
10475 again = 1;
10476 }
10477 }
10478
e04a16fb
AG		 10479 /* If we have a THIS (from a primary), we set the context accordingly */
10480 if (name == this_identifier_node)
10481 {
10482 qual = TREE_CHAIN (qual);
10483 qual_wfl = QUAL_WFL (qual);
22eed1e6
APB		 10484 if (TREE_CODE (qual_wfl) == CALL_EXPR)
10485 again = 1;
10486 else
10487 name = EXPR_WFL_NODE (qual_wfl);
e04a16fb
AG		 10488 this_found = 1;
10489 }
10490 /* If we have a SUPER, we set the context accordingly */
10491 if (name == super_identifier_node)
10492 {
10493 current_class = CLASSTYPE_SUPER (ptr_type);
10494 /* Check that there is such a thing as a super class. If not,
10495 return. The error will be caught later on, during the
10496 resolution */
10497 if (!current_class)
10498 {
10499 current_class = saved_current_class;
10500 return;
10501 }
10502 qual = TREE_CHAIN (qual);
10503 /* Do one more interation to set things up */
10504 super_found = again = 1;
10505 }
10506 } while (again);
10507
f2760b27
APB		 10508 /* If name appears within the scope of a local variable declaration
10509 or parameter declaration, then it is an expression name. We don't
10510 carry this test out if we're in the context of the use of SUPER
10511 or THIS */
cd7c5840
APB		 10512 if (!this_found && !super_found
10513 && TREE_CODE (name) != STRING_CST && TREE_CODE (name) != INTEGER_CST
10514 && (decl = IDENTIFIER_LOCAL_VALUE (name)))
e04a16fb
AG		 10515 {
10516 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
10517 QUAL_RESOLUTION (qual) = decl;
10518 }
10519
10520 /* If within the class/interface NAME was found to be used there
10521 exists a (possibly inherited) field named NAME, then this is an
d8fccff5
APB		 10522 expression name. If we saw a NEW_ARRAY_EXPR before and want to
10523 address length, it is OK. */
10524 else if ((decl = lookup_field_wrapper (ptr_type, name))
10525 || (new_array_found && name == length_identifier_node))
e04a16fb
AG		 10526 {
10527 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
d8fccff5 10528 QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
e04a16fb
AG		 10529 }
10530
1a6d4fb7 10531 /* We reclassify NAME as yielding to a type name resolution if:
e04a16fb
AG		 10532 - NAME is a class/interface declared within the compilation
10533 unit containing NAME,
10534 - NAME is imported via a single-type-import declaration,
10535 - NAME is declared in an another compilation unit of the package
10536 of the compilation unit containing NAME,
10537 - NAME is declared by exactly on type-import-on-demand declaration
1a6d4fb7
APB		 10538 of the compilation unit containing NAME.
10539 - NAME is actually a STRING_CST. */
cd7c5840
APB		 10540 else if (TREE_CODE (name) == STRING_CST || TREE_CODE (name) == INTEGER_CST
10541 || (decl = resolve_and_layout (name, NULL_TREE)))
e04a16fb
AG		 10542 {
10543 RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
10544 QUAL_RESOLUTION (qual) = decl;
10545 }
10546
f2760b27 10547 /* Method call, array references and cast are expression name */
9bbc7d9f 10548 else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
8576f094
APB		 10549 || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
10550 || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR)
e04a16fb
AG		 10551 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
10552
10553 /* Check here that NAME isn't declared by more than one
10554 type-import-on-demand declaration of the compilation unit
10555 containing NAME. FIXME */
10556
10557 /* Otherwise, NAME is reclassified as a package name */
10558 else
10559 RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
10560
10561 /* Propagate the qualification accross other components of the
10562 qualified name */
10563 for (qual = TREE_CHAIN (qual); qual;
10564 qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
10565 {
10566 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
10567 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
10568 else
10569 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
10570 }
10571
10572 /* Store the global qualification for the ambiguous part of ID back
10573 into ID fields */
10574 if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
10575 RESOLVE_EXPRESSION_NAME_P (id) = 1;
10576 else if (RESOLVE_TYPE_NAME_P (qual_wfl))
10577 RESOLVE_TYPE_NAME_P (id) = 1;
10578 else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
10579 RESOLVE_PACKAGE_NAME_P (id) = 1;
10580
10581 /* Restore the current class */
10582 current_class = saved_current_class;
10583}
10584
10585static int
10586breakdown_qualified (left, right, source)
10587 tree *left, *right, source;
10588{
10589 char *p = IDENTIFIER_POINTER (source), *base;
10590 int l = IDENTIFIER_LENGTH (source);
10591
10592 /* Breakdown NAME into REMAINDER . IDENTIFIER */
10593 base = p;
10594 p += (l-1);
10595 while (*p != '.' && p != base)
10596 p--;
10597
10598 /* We didn't find a '.'. Return an error */
10599 if (p == base)
10600 return 1;
10601
10602 *p = '\0';
10603 if (right)
10604 *right = get_identifier (p+1);
10605 *left = get_identifier (IDENTIFIER_POINTER (source));
10606 *p = '.';
10607
10608 return 0;
10609}
10610
e04a16fb 10611/* Patch tree nodes in a function body. When a BLOCK is found, push
5b09b33e
PB		 10612 local variable decls if present.
10613 Same as java_complete_lhs, but does resolve static finals to values. */
e04a16fb
AG		 10614
10615static tree
10616java_complete_tree (node)
10617 tree node;
5b09b33e
PB		 10618{
10619 node = java_complete_lhs (node);
10620 if (TREE_CODE (node) == VAR_DECL && FIELD_STATIC (node)
7f10c2e2
APB		 10621 && FIELD_FINAL (node) && DECL_INITIAL (node) != NULL_TREE
10622 && !flag_emit_xref)
5b09b33e
PB		 10623 {
10624 tree value = DECL_INITIAL (node);
10625 DECL_INITIAL (node) = NULL_TREE;
100f7cd8 10626 push_obstacks (&permanent_obstack, &permanent_obstack);
5b09b33e 10627 value = fold_constant_for_init (value, node);
100f7cd8 10628 pop_obstacks ();
5b09b33e
PB		 10629 DECL_INITIAL (node) = value;
10630 if (value != NULL_TREE)
c2952b01
APB		 10631 {
10632 /* fold_constant_for_init sometimes widen the original type
10633 of the constant (i.e. byte to int.) It's not desirable,
10634 especially if NODE is a function argument. */
10635 if (TREE_CODE (value) == INTEGER_CST
10636 && TREE_TYPE (node) != TREE_TYPE (value))
10637 return convert (TREE_TYPE (node), value);
10638 else
10639 return value;
10640 }
5b09b33e
PB		 10641 }
10642 return node;
10643}
10644
2aa11e97
APB		 10645static tree
10646java_stabilize_reference (node)
10647 tree node;
10648{
10649 if (TREE_CODE (node) == COMPOUND_EXPR)
10650 {
10651 tree op0 = TREE_OPERAND (node, 0);
10652 tree op1 = TREE_OPERAND (node, 1);
642f15d1 10653 TREE_OPERAND (node, 0) = save_expr (op0);
2aa11e97
APB		 10654 TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
10655 return node;
10656 }
5cbdba64 10657 return stabilize_reference (node);
2aa11e97
APB		 10658}
10659
5b09b33e
PB		 10660/* Patch tree nodes in a function body. When a BLOCK is found, push
10661 local variable decls if present.
10662 Same as java_complete_tree, but does not resolve static finals to values. */
10663
10664static tree
10665java_complete_lhs (node)
10666 tree node;
e04a16fb 10667{
22eed1e6 10668 tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
b67d701b 10669 int flag;
e04a16fb
AG		 10670
10671 /* CONVERT_EXPR always has its type set, even though it needs to be
b67d701b 10672 worked out. */
e04a16fb
AG		 10673 if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
10674 return node;
10675
10676 /* The switch block implements cases processing container nodes
10677 first. Contained nodes are always written back. Leaves come
10678 next and return a value. */
10679 switch (TREE_CODE (node))
10680 {
10681 case BLOCK:
10682
10683 /* 1- Block section.
10684 Set the local values on decl names so we can identify them
10685 faster when they're referenced. At that stage, identifiers
10686 are legal so we don't check for declaration errors. */
10687 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
10688 {
10689 DECL_CONTEXT (cn) = current_function_decl;
10690 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
e04a16fb 10691 }
15fdcfe9
PB		 10692 if (BLOCK_EXPR_BODY (node) == NULL_TREE)
10693 CAN_COMPLETE_NORMALLY (node) = 1;
10694 else
e04a16fb 10695 {
15fdcfe9
PB		 10696 tree stmt = BLOCK_EXPR_BODY (node);
10697 tree *ptr;
10698 int error_seen = 0;
10699 if (TREE_CODE (stmt) == COMPOUND_EXPR)
10700 {
c877974e
APB		 10701 /* Re-order from (((A; B); C); ...; Z) to
10702 (A; (B; (C ; (...; Z)))).
15fdcfe9
PB		 10703 This makes it easier to scan the statements left-to-right
10704 without using recursion (which might overflow the stack
10705 if the block has many statements. */
10706 for (;;)
10707 {
10708 tree left = TREE_OPERAND (stmt, 0);
10709 if (TREE_CODE (left) != COMPOUND_EXPR)
10710 break;
10711 TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
10712 TREE_OPERAND (left, 1) = stmt;
10713 stmt = left;
10714 }
10715 BLOCK_EXPR_BODY (node) = stmt;
10716 }
10717
c877974e
APB		 10718 /* Now do the actual complete, without deep recursion for
10719 long blocks. */
15fdcfe9 10720 ptr = &BLOCK_EXPR_BODY (node);
dc0b3eff
PB		 10721 while (TREE_CODE (*ptr) == COMPOUND_EXPR
10722 && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
15fdcfe9
PB		 10723 {
10724 tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
10725 tree *next = &TREE_OPERAND (*ptr, 1);
10726 TREE_OPERAND (*ptr, 0) = cur;
cd9643f7
PB		 10727 if (cur == empty_stmt_node)
10728 {
10729 /* Optimization; makes it easier to detect empty bodies.
10730 Most useful for <clinit> with all-constant initializer. */
10731 *ptr = *next;
10732 continue;
10733 }
15fdcfe9
PB		 10734 if (TREE_CODE (cur) == ERROR_MARK)
10735 error_seen++;
10736 else if (! CAN_COMPLETE_NORMALLY (cur))
10737 {
10738 wfl_op2 = *next;
10739 for (;;)
10740 {
10741 if (TREE_CODE (wfl_op2) == BLOCK)
10742 wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
10743 else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
10744 wfl_op2 = TREE_OPERAND (wfl_op2, 0);
10745 else
10746 break;
10747 }
10748 if (TREE_CODE (wfl_op2) != CASE_EXPR
dc0b3eff 10749 && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
82371d41 10750 unreachable_stmt_error (*ptr);
15fdcfe9
PB		 10751 }
10752 ptr = next;
10753 }
10754 *ptr = java_complete_tree (*ptr);
10755
10756 if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
e04a16fb 10757 return error_mark_node;
15fdcfe9 10758 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
e04a16fb
AG		 10759 }
10760 /* Turn local bindings to null */
10761 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
10762 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
10763
10764 TREE_TYPE (node) = void_type_node;
10765 break;
10766
10767 /* 2- They are expressions but ultimately deal with statements */
b67d701b 10768
b9f7e36c
APB		 10769 case THROW_EXPR:
10770 wfl_op1 = TREE_OPERAND (node, 0);
10771 COMPLETE_CHECK_OP_0 (node);
c2952b01
APB		 10772 /* 14.19 A throw statement cannot complete normally. */
10773 CAN_COMPLETE_NORMALLY (node) = 0;
b9f7e36c
APB		 10774 return patch_throw_statement (node, wfl_op1);
10775
10776 case SYNCHRONIZED_EXPR:
10777 wfl_op1 = TREE_OPERAND (node, 0);
b9f7e36c
APB		 10778 return patch_synchronized_statement (node, wfl_op1);
10779
b67d701b
PB		 10780 case TRY_EXPR:
10781 return patch_try_statement (node);
10782
a7d8d81f
PB		 10783 case TRY_FINALLY_EXPR:
10784 COMPLETE_CHECK_OP_0 (node);
10785 COMPLETE_CHECK_OP_1 (node);
10786 CAN_COMPLETE_NORMALLY (node)
10787 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
10788 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
10789 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
10790 return node;
10791
5a005d9e
PB		 10792 case CLEANUP_POINT_EXPR:
10793 COMPLETE_CHECK_OP_0 (node);
10794 TREE_TYPE (node) = void_type_node;
2aa11e97
APB		 10795 CAN_COMPLETE_NORMALLY (node) =
10796 CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
5a005d9e
PB		 10797 return node;
10798
10799 case WITH_CLEANUP_EXPR:
10800 COMPLETE_CHECK_OP_0 (node);
10801 COMPLETE_CHECK_OP_2 (node);
2aa11e97
APB		 10802 CAN_COMPLETE_NORMALLY (node) =
10803 CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0));
5a005d9e
PB		 10804 TREE_TYPE (node) = void_type_node;
10805 return node;
10806
e04a16fb
AG		 10807 case LABELED_BLOCK_EXPR:
10808 PUSH_LABELED_BLOCK (node);
10809 if (LABELED_BLOCK_BODY (node))
10810 COMPLETE_CHECK_OP_1 (node);
10811 TREE_TYPE (node) = void_type_node;
10812 POP_LABELED_BLOCK ();
1fb89a4d
APB		 10813
10814 if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
9dd939b2
APB		 10815 {
10816 LABELED_BLOCK_BODY (node) = NULL_TREE;
10817 CAN_COMPLETE_NORMALLY (node) = 1;
10818 }
1fb89a4d 10819 else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
15fdcfe9 10820 CAN_COMPLETE_NORMALLY (node) = 1;
e04a16fb
AG		 10821 return node;
10822
10823 case EXIT_BLOCK_EXPR:
10824 /* We don't complete operand 1, because it's the return value of
10825 the EXIT_BLOCK_EXPR which doesn't exist it Java */
10826 return patch_bc_statement (node);
10827
15fdcfe9
PB		 10828 case CASE_EXPR:
10829 cn = java_complete_tree (TREE_OPERAND (node, 0));
10830 if (cn == error_mark_node)
10831 return cn;
10832
8576f094
APB		 10833 /* First, the case expression must be constant. Values of final
10834 fields are accepted. */
15fdcfe9 10835 cn = fold (cn);
8576f094
APB		 10836 if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
10837 && JDECL_P (TREE_OPERAND (cn, 1))
10838 && FIELD_FINAL (TREE_OPERAND (cn, 1))
10839 && DECL_INITIAL (TREE_OPERAND (cn, 1)))
100f7cd8
APB		 10840 {
10841 push_obstacks (&permanent_obstack, &permanent_obstack);
10842 cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
10843 TREE_OPERAND (cn, 1));
10844 pop_obstacks ();
10845 }
15fdcfe9 10846
ce6e9147 10847 if (!TREE_CONSTANT (cn) && !flag_emit_xref)
15fdcfe9
PB		 10848 {
10849 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10850 parse_error_context (node, "Constant expression required");
10851 return error_mark_node;
10852 }
10853
10854 nn = ctxp->current_loop;
10855
10856 /* It must be assignable to the type of the switch expression. */
c877974e
APB		 10857 if (!try_builtin_assignconv (NULL_TREE,
10858 TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
15fdcfe9
PB		 10859 {
10860 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10861 parse_error_context
10862 (wfl_operator,
10863 "Incompatible type for case. Can't convert `%s' to `int'",
10864 lang_printable_name (TREE_TYPE (cn), 0));
10865 return error_mark_node;
10866 }
10867
10868 cn = fold (convert (int_type_node, cn));
10869
10870 /* Multiple instance of a case label bearing the same
10871 value is checked during code generation. The case
10872 expression is allright so far. */
10873 TREE_OPERAND (node, 0) = cn;
9bbc7d9f 10874 TREE_TYPE (node) = void_type_node;
15fdcfe9 10875 CAN_COMPLETE_NORMALLY (node) = 1;
10100cc7 10876 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9
PB		 10877 break;
10878
10879 case DEFAULT_EXPR:
10880 nn = ctxp->current_loop;
10881 /* Only one default label is allowed per switch statement */
10882 if (SWITCH_HAS_DEFAULT (nn))
10883 {
10884 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
10885 parse_error_context (wfl_operator,
10886 "Duplicate case label: `default'");
10887 return error_mark_node;
10888 }
10889 else
10890 SWITCH_HAS_DEFAULT (nn) = 1;
9bbc7d9f 10891 TREE_TYPE (node) = void_type_node;
10100cc7 10892 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9
PB		 10893 CAN_COMPLETE_NORMALLY (node) = 1;
10894 break;
10895
b67d701b 10896 case SWITCH_EXPR:
e04a16fb
AG		 10897 case LOOP_EXPR:
10898 PUSH_LOOP (node);
10899 /* Check whether the loop was enclosed in a labeled
10900 statement. If not, create one, insert the loop in it and
10901 return the node */
10902 nn = patch_loop_statement (node);
b67d701b 10903
e04a16fb 10904 /* Anyways, walk the body of the loop */
b67d701b
PB		 10905 if (TREE_CODE (node) == LOOP_EXPR)
10906 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10907 /* Switch statement: walk the switch expression and the cases */
10908 else
10909 node = patch_switch_statement (node);
10910
e04a16fb 10911 if (TREE_OPERAND (node, 0) == error_mark_node)
b635eb2f
PB		 10912 nn = error_mark_node;
10913 else
15fdcfe9 10914 {
b635eb2f
PB		 10915 TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
10916 /* If we returned something different, that's because we
10917 inserted a label. Pop the label too. */
10918 if (nn != node)
10919 {
10920 if (CAN_COMPLETE_NORMALLY (node))
10921 CAN_COMPLETE_NORMALLY (nn) = 1;
10922 POP_LABELED_BLOCK ();
10923 }
15fdcfe9 10924 }
e04a16fb
AG		 10925 POP_LOOP ();
10926 return nn;
10927
10928 case EXIT_EXPR:
10929 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10930 return patch_exit_expr (node);
10931
10932 case COND_EXPR:
10933 /* Condition */
10934 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
10935 if (TREE_OPERAND (node, 0) == error_mark_node)
10936 return error_mark_node;
10937 /* then-else branches */
10938 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
10939 if (TREE_OPERAND (node, 1) == error_mark_node)
10940 return error_mark_node;
10941 TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
10942 if (TREE_OPERAND (node, 2) == error_mark_node)
10943 return error_mark_node;
10944 return patch_if_else_statement (node);
10945 break;
10946
22eed1e6
APB		 10947 case CONDITIONAL_EXPR:
10948 /* Condition */
10949 wfl_op1 = TREE_OPERAND (node, 0);
10950 COMPLETE_CHECK_OP_0 (node);
10951 wfl_op2 = TREE_OPERAND (node, 1);
10952 COMPLETE_CHECK_OP_1 (node);
10953 wfl_op3 = TREE_OPERAND (node, 2);
10954 COMPLETE_CHECK_OP_2 (node);
10955 return patch_conditional_expr (node, wfl_op1, wfl_op2);
10956
e04a16fb
AG		 10957 /* 3- Expression section */
10958 case COMPOUND_EXPR:
15fdcfe9 10959 wfl_op2 = TREE_OPERAND (node, 1);
ac825856
APB		 10960 TREE_OPERAND (node, 0) = nn =
10961 java_complete_tree (TREE_OPERAND (node, 0));
dc0b3eff
PB		 10962 if (wfl_op2 == empty_stmt_node)
10963 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
10964 else
15fdcfe9 10965 {
dc0b3eff 10966 if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
bccaf73a 10967 {
dc0b3eff
PB		 10968 /* An unreachable condition in a do-while statement
10969 is *not* (technically) an unreachable statement. */
10970 nn = wfl_op2;
10971 if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
10972 nn = EXPR_WFL_NODE (nn);
10973 if (TREE_CODE (nn) != EXIT_EXPR)
10974 {
10975 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
10976 parse_error_context (wfl_operator, "Unreachable statement");
10977 }
bccaf73a 10978 }
dc0b3eff
PB		 10979 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
10980 if (TREE_OPERAND (node, 1) == error_mark_node)
10981 return error_mark_node;
10982 CAN_COMPLETE_NORMALLY (node)
10983 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1));
15fdcfe9 10984 }
e04a16fb
AG		 10985 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
10986 break;
10987
10988 case RETURN_EXPR:
15fdcfe9 10989 /* CAN_COMPLETE_NORMALLY (node) = 0; */
e04a16fb
AG		 10990 return patch_return (node);
10991
10992 case EXPR_WITH_FILE_LOCATION:
10993 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
10994 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
15fdcfe9 10995 {
5423609c 10996 tree wfl = node;
15fdcfe9 10997 node = resolve_expression_name (node, NULL);
dc0b3eff
PB		 10998 if (node == error_mark_node)
10999 return node;
5423609c
APB		 11000 /* Keep line number information somewhere were it doesn't
11001 disrupt the completion process. */
2c56429a 11002 if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
5423609c
APB		 11003 {
11004 EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11005 TREE_OPERAND (node, 1) = wfl;
11006 }
15fdcfe9
PB		 11007 CAN_COMPLETE_NORMALLY (node) = 1;
11008 }
e04a16fb
AG		 11009 else
11010 {
5b09b33e
PB		 11011 tree body;
11012 int save_lineno = lineno;
11013 lineno = EXPR_WFL_LINENO (node);
11014 body = java_complete_tree (EXPR_WFL_NODE (node));
11015 lineno = save_lineno;
15fdcfe9 11016 EXPR_WFL_NODE (node) = body;
dc0b3eff 11017 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
15fdcfe9 11018 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
cd9643f7
PB		 11019 if (body == empty_stmt_node)
11020 {
11021 /* Optimization; makes it easier to detect empty bodies. */
11022 return body;
11023 }
dc0b3eff 11024 if (body == error_mark_node)
e04a16fb
AG		 11025 {
11026 /* Its important for the evaluation of assignment that
11027 this mark on the TREE_TYPE is propagated. */
11028 TREE_TYPE (node) = error_mark_node;
11029 return error_mark_node;
11030 }
11031 else
11032 TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
15fdcfe9 11033
e04a16fb
AG		 11034 }
11035 break;
11036
b67d701b 11037 case NEW_ARRAY_EXPR:
e04a16fb
AG		 11038 /* Patch all the dimensions */
11039 flag = 0;
11040 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11041 {
11042 int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
3a1760ac
APB		 11043 tree dim = convert (int_type_node,
11044 java_complete_tree (TREE_VALUE (cn)));
e04a16fb
AG		 11045 if (dim == error_mark_node)
11046 {
11047 flag = 1;
11048 continue;
11049 }
11050 else
11051 {
b9f7e36c 11052 TREE_VALUE (cn) = dim;
e04a16fb
AG		 11053 /* Setup the location of the current dimension, for
11054 later error report. */
11055 TREE_PURPOSE (cn) =
11056 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11057 EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11058 }
11059 }
11060 /* They complete the array creation expression, if no errors
11061 were found. */
15fdcfe9 11062 CAN_COMPLETE_NORMALLY (node) = 1;
aee48ef8
PB		 11063 return (flag ? error_mark_node
11064 : force_evaluation_order (patch_newarray (node)));
e04a16fb 11065
c2952b01
APB		 11066 case NEW_ANONYMOUS_ARRAY_EXPR:
11067 /* Create the array type if necessary. */
11068 if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11069 {
11070 tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11071 if (!(type = resolve_type_during_patch (type)))
11072 return error_mark_node;
11073 type = build_array_from_name (type, NULL_TREE,
11074 ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11075 ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11076 }
11077 node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11078 ANONYMOUS_ARRAY_INITIALIZER (node));
11079 if (node == error_mark_node)
11080 return error_mark_node;
11081 CAN_COMPLETE_NORMALLY (node) = 1;
11082 return node;
11083
b67d701b 11084 case NEW_CLASS_EXPR:
e04a16fb 11085 case CALL_EXPR:
b67d701b 11086 /* Complete function's argument(s) first */
e04a16fb
AG		 11087 if (complete_function_arguments (node))
11088 return error_mark_node;
11089 else
b9f7e36c 11090 {
22eed1e6
APB		 11091 tree decl, wfl = TREE_OPERAND (node, 0);
11092 int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11093
c877974e 11094 node = patch_method_invocation (node, NULL_TREE,
89e09b9a 11095 NULL_TREE, 0, &decl);
c877974e
APB		 11096 if (node == error_mark_node)
11097 return error_mark_node;
11098
11099 check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
11100 /* If we call this(...), register signature and positions */
11101 if (in_this)
11102 DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11103 tree_cons (wfl, decl,
11104 DECL_CONSTRUCTOR_CALLS (current_function_decl));
de4c7b02 11105 CAN_COMPLETE_NORMALLY (node) = 1;
dc0b3eff 11106 return force_evaluation_order (node);
b9f7e36c 11107 }
e04a16fb
AG		 11108
11109 case MODIFY_EXPR:
11110 /* Save potential wfls */
11111 wfl_op1 = TREE_OPERAND (node, 0);
cd9643f7 11112 TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
c2952b01 11113
cd9643f7
PB		 11114 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11115 && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11116 && DECL_INITIAL (nn) != NULL_TREE)
11117 {
100f7cd8
APB		 11118 tree value;
11119
11120 push_obstacks (&permanent_obstack, &permanent_obstack);
11121 value = fold_constant_for_init (nn, nn);
11122 pop_obstacks ();
c2952b01 11123
cd9643f7
PB		 11124 if (value != NULL_TREE)
11125 {
11126 tree type = TREE_TYPE (value);
c2952b01
APB		 11127 if (JPRIMITIVE_TYPE_P (type) ||
11128 (type == string_ptr_type_node && ! flag_emit_class_files))
cd9643f7
PB		 11129 return empty_stmt_node;
11130 }
11131 DECL_INITIAL (nn) = NULL_TREE;
11132 }
e04a16fb 11133 wfl_op2 = TREE_OPERAND (node, 1);
cd9643f7 11134
e04a16fb
AG		 11135 if (TREE_OPERAND (node, 0) == error_mark_node)
11136 return error_mark_node;
11137
5cbdba64
APB		 11138 flag = COMPOUND_ASSIGN_P (wfl_op2);
11139 if (flag)
e04a16fb 11140 {
c2952b01
APB		 11141 /* This might break when accessing outer field from inner
11142 class. TESTME, FIXME */
2aa11e97 11143 tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
e04a16fb
AG		 11144
11145 /* Hand stablize the lhs on both places */
e04a16fb 11146 TREE_OPERAND (node, 0) = lvalue;
5cbdba64
APB		 11147 TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11148 (flag_emit_class_files ? lvalue : save_expr (lvalue));
2aa11e97 11149
5cbdba64 11150 /* 15.25.2.a: Left hand is not an array access. FIXME */
2aa11e97
APB		 11151 /* Now complete the RHS. We write it back later on. */
11152 nn = java_complete_tree (TREE_OPERAND (node, 1));
11153
642f15d1
APB		 11154 if ((cn = patch_string (nn)))
11155 nn = cn;
11156
2aa11e97
APB		 11157 /* The last part of the rewrite for E1 op= E2 is to have
11158 E1 = (T)(E1 op E2), with T being the type of E1. */
642f15d1
APB		 11159 nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
11160 TREE_TYPE (lvalue), nn));
5cbdba64
APB		 11161
11162 /* 15.25.2.b: Left hand is an array access. FIXME */
e04a16fb
AG		 11163 }
11164
f8976021 11165 /* If we're about to patch a NEW_ARRAY_INIT, we call a special
c2952b01
APB		 11166 function to complete this RHS. Note that a NEW_ARRAY_INIT
11167 might have been already fully expanded if created as a result
11168 of processing an anonymous array initializer. We avoid doing
11169 the operation twice by testing whether the node already bears
11170 a type. */
11171 else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
fdec99c6 11172 nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
f8976021 11173 TREE_OPERAND (node, 1));
2aa11e97 11174 /* Otherwise we simply complete the RHS */
f8976021
APB		 11175 else
11176 nn = java_complete_tree (TREE_OPERAND (node, 1));
11177
e04a16fb 11178 if (nn == error_mark_node)
c0d87ff6 11179 return error_mark_node;
2aa11e97
APB		 11180
11181 /* Write back the RHS as we evaluated it. */
e04a16fb 11182 TREE_OPERAND (node, 1) = nn;
b67d701b
PB		 11183
11184 /* In case we're handling = with a String as a RHS, we need to
11185 produce a String out of the RHS (it might still be a
11186 STRING_CST or a StringBuffer at this stage */
11187 if ((nn = patch_string (TREE_OPERAND (node, 1))))
11188 TREE_OPERAND (node, 1) = nn;
c2952b01
APB		 11189
11190 if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
11191 TREE_OPERAND (node, 1))))
11192 {
11193 /* We return error_mark_node if outer_field_access_fix
11194 detects we write into a final. */
11195 if (nn == error_mark_node)
11196 return error_mark_node;
11197 node = nn;
11198 }
11199 else
11200 {
11201 node = patch_assignment (node, wfl_op1, wfl_op2);
11202 /* Reorganize the tree if necessary. */
11203 if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
11204 || JSTRING_P (TREE_TYPE (node))))
11205 node = java_refold (node);
11206 }
11207
15fdcfe9
PB		 11208 CAN_COMPLETE_NORMALLY (node) = 1;
11209 return node;
e04a16fb
AG		 11210
11211 case MULT_EXPR:
11212 case PLUS_EXPR:
11213 case MINUS_EXPR:
11214 case LSHIFT_EXPR:
11215 case RSHIFT_EXPR:
11216 case URSHIFT_EXPR:
11217 case BIT_AND_EXPR:
11218 case BIT_XOR_EXPR:
11219 case BIT_IOR_EXPR:
11220 case TRUNC_MOD_EXPR:
c2952b01 11221 case TRUNC_DIV_EXPR:
e04a16fb
AG		 11222 case RDIV_EXPR:
11223 case TRUTH_ANDIF_EXPR:
11224 case TRUTH_ORIF_EXPR:
11225 case EQ_EXPR:
11226 case NE_EXPR:
11227 case GT_EXPR:
11228 case GE_EXPR:
11229 case LT_EXPR:
11230 case LE_EXPR:
11231 /* Operands 0 and 1 are WFL in certain cases only. patch_binop
11232 knows how to handle those cases. */
11233 wfl_op1 = TREE_OPERAND (node, 0);
11234 wfl_op2 = TREE_OPERAND (node, 1);
b67d701b 11235
15fdcfe9 11236 CAN_COMPLETE_NORMALLY (node) = 1;
b67d701b
PB		 11237 /* Don't complete string nodes if dealing with the PLUS operand. */
11238 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
2aa11e97
APB		 11239 {
11240 nn = java_complete_tree (wfl_op1);
11241 if (nn == error_mark_node)
11242 return error_mark_node;
48a840d9 11243
2aa11e97
APB		 11244 TREE_OPERAND (node, 0) = nn;
11245 }
b67d701b 11246 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
2aa11e97
APB		 11247 {
11248 nn = java_complete_tree (wfl_op2);
11249 if (nn == error_mark_node)
11250 return error_mark_node;
48a840d9 11251
2aa11e97
APB		 11252 TREE_OPERAND (node, 1) = nn;
11253 }
dc0b3eff 11254 return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
e04a16fb 11255
5e942c50
APB		 11256 case INSTANCEOF_EXPR:
11257 wfl_op1 = TREE_OPERAND (node, 0);
11258 COMPLETE_CHECK_OP_0 (node);
ce6e9147
APB		 11259 if (flag_emit_xref)
11260 {
11261 TREE_TYPE (node) = boolean_type_node;
11262 return node;
11263 }
5e942c50
APB		 11264 return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
11265
b67d701b 11266 case UNARY_PLUS_EXPR:
e04a16fb
AG		 11267 case NEGATE_EXPR:
11268 case TRUTH_NOT_EXPR:
11269 case BIT_NOT_EXPR:
11270 case PREDECREMENT_EXPR:
11271 case PREINCREMENT_EXPR:
11272 case POSTDECREMENT_EXPR:
11273 case POSTINCREMENT_EXPR:
11274 case CONVERT_EXPR:
11275 /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
11276 how to handle those cases. */
11277 wfl_op1 = TREE_OPERAND (node, 0);
15fdcfe9 11278 CAN_COMPLETE_NORMALLY (node) = 1;
e04a16fb
AG		 11279 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
11280 if (TREE_OPERAND (node, 0) == error_mark_node)
11281 return error_mark_node;
4a5f66c3
APB		 11282 node = patch_unaryop (node, wfl_op1);
11283 CAN_COMPLETE_NORMALLY (node) = 1;
11284 break;
e04a16fb
AG		 11285
11286 case ARRAY_REF:
11287 /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
11288 how to handle those cases. */
11289 wfl_op1 = TREE_OPERAND (node, 0);
11290 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
11291 if (TREE_OPERAND (node, 0) == error_mark_node)
11292 return error_mark_node;
7f1d4866 11293 if (!flag_emit_class_files && !flag_emit_xref)
b67d701b 11294 TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
e04a16fb
AG		 11295 /* The same applies to wfl_op2 */
11296 wfl_op2 = TREE_OPERAND (node, 1);
11297 TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
11298 if (TREE_OPERAND (node, 1) == error_mark_node)
11299 return error_mark_node;
7f1d4866 11300 if (!flag_emit_class_files && !flag_emit_xref)
22eed1e6 11301 TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
939d7216 11302 return patch_array_ref (node);
e04a16fb 11303
63a212ed
PB		 11304 case RECORD_TYPE:
11305 return node;;
11306
11307 case COMPONENT_REF:
11308 /* The first step in the re-write of qualified name handling. FIXME.
11309 So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
9bbc7d9f 11310 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
63a212ed
PB		 11311 if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
11312 {
11313 tree name = TREE_OPERAND (node, 1);
11314 tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
11315 if (field == NULL_TREE)
11316 {
11317 error ("missing static field `%s'", IDENTIFIER_POINTER (name));
11318 return error_mark_node;
11319 }
11320 if (! FIELD_STATIC (field))
11321 {
11322 error ("not a static field `%s'", IDENTIFIER_POINTER (name));
11323 return error_mark_node;
11324 }
11325 return field;
11326 }
11327 else
11328 fatal ("unimplemented java_complete_tree for COMPONENT_REF");
9bbc7d9f 11329 break;
9bbc7d9f 11330
b67d701b 11331 case THIS_EXPR:
e04a16fb
AG		 11332 /* Can't use THIS in a static environment */
11333 if (!current_this)
11334 {
11335 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
781b0558
KG		 11336 parse_error_context (wfl_operator,
11337 "Keyword `this' used outside allowed context");
e04a16fb
AG		 11338 TREE_TYPE (node) = error_mark_node;
11339 return error_mark_node;
11340 }
22eed1e6
APB		 11341 if (ctxp->explicit_constructor_p)
11342 {
11343 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11344 parse_error_context
781b0558 11345 (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
22eed1e6
APB		 11346 TREE_TYPE (node) = error_mark_node;
11347 return error_mark_node;
11348 }
e04a16fb 11349 return current_this;
c2952b01
APB		 11350
11351 case CLASS_LITERAL:
11352 CAN_COMPLETE_NORMALLY (node) = 1;
11353 node = patch_incomplete_class_ref (node);
11354 if (node == error_mark_node)
11355 return error_mark_node;
11356 break;
11357
11358 case INSTANCE_INITIALIZERS_EXPR:
11359 in_instance_initializer++;
11360 node = java_complete_tree (TREE_OPERAND (node, 0));
11361 in_instance_initializer--;
11362 if (node != error_mark_node)
11363 TREE_TYPE (node) = void_type_node;
11364 else
11365 return error_mark_node;
11366 break;
e04a16fb 11367
e04a16fb 11368 default:
15fdcfe9 11369 CAN_COMPLETE_NORMALLY (node) = 1;
b67d701b 11370 /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
c2952b01
APB		 11371 and it's time to turn it into the appropriate String object */
11372 if ((nn = patch_string (node)))
11373 node = nn;
11374 else
11375 fatal ("No case for tree code `%s' - java_complete_tree\n",
11376 tree_code_name [TREE_CODE (node)]);
e04a16fb
AG		 11377 }
11378 return node;
11379}
11380
11381/* Complete function call's argument. Return a non zero value is an
11382 error was found. */
11383
11384static int
11385complete_function_arguments (node)
11386 tree node;
11387{
11388 int flag = 0;
11389 tree cn;
11390
f63991a8 11391 ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
e04a16fb
AG		 11392 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11393 {
b67d701b 11394 tree wfl = TREE_VALUE (cn), parm, temp;
e04a16fb 11395 parm = java_complete_tree (wfl);
c2952b01 11396
e04a16fb
AG		 11397 if (parm == error_mark_node)
11398 {
11399 flag = 1;
11400 continue;
11401 }
b67d701b
PB		 11402 /* If have a string literal that we haven't transformed yet or a
11403 crafted string buffer, as a result of use of the the String
11404 `+' operator. Build `parm.toString()' and expand it. */
11405 if ((temp = patch_string (parm)))
b9f7e36c 11406 parm = temp;
5e942c50
APB		 11407 /* Inline PRIMTYPE.TYPE read access */
11408 parm = maybe_build_primttype_type_ref (parm, wfl);
b9f7e36c 11409
5e942c50 11410 TREE_VALUE (cn) = parm;
e04a16fb 11411 }
f63991a8 11412 ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
e04a16fb
AG		 11413 return flag;
11414}
11415
11416/* Sometimes (for loops and variable initialized during their
11417 declaration), we want to wrap a statement around a WFL and turn it
11418 debugable. */
11419
11420static tree
11421build_debugable_stmt (location, stmt)
11422 int location;
11423 tree stmt;
11424{
11425 if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
11426 {
11427 stmt = build_expr_wfl (stmt, input_filename, 0, 0);
11428 EXPR_WFL_LINECOL (stmt) = location;
11429 }
11430 JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
11431 return stmt;
11432}
11433
11434static tree
11435build_expr_block (body, decls)
11436 tree body, decls;
11437{
11438 tree node = make_node (BLOCK);
11439 BLOCK_EXPR_DECLS (node) = decls;
b67d701b 11440 BLOCK_EXPR_BODY (node) = body;
e04a16fb
AG		 11441 if (body)
11442 TREE_TYPE (node) = TREE_TYPE (body);
11443 TREE_SIDE_EFFECTS (node) = 1;
11444 return node;
11445}
11446
b67d701b
PB		 11447/* Create a new function block and link it approriately to current
11448 function block chain */
e04a16fb
AG		 11449
11450static tree
11451enter_block ()
11452{
b67d701b
PB		 11453 return (enter_a_block (build_expr_block (NULL_TREE, NULL_TREE)));
11454}
11455
11456/* Link block B supercontext to the previous block. The current
11457 function DECL is used as supercontext when enter_a_block is called
11458 for the first time for a given function. The current function body
11459 (DECL_FUNCTION_BODY) is set to be block B. */
11460
11461static tree
11462enter_a_block (b)
11463 tree b;
11464{
e04a16fb
AG		 11465 tree fndecl = current_function_decl;
11466
f099f336
APB		 11467 if (!fndecl) {
11468 BLOCK_SUPERCONTEXT (b) = current_static_block;
11469 current_static_block = b;
11470 }
11471
11472 else if (!DECL_FUNCTION_BODY (fndecl))
e04a16fb
AG		 11473 {
11474 BLOCK_SUPERCONTEXT (b) = fndecl;
11475 DECL_FUNCTION_BODY (fndecl) = b;
11476 }
11477 else
11478 {
11479 BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
11480 DECL_FUNCTION_BODY (fndecl) = b;
11481 }
11482 return b;
11483}
11484
11485/* Exit a block by changing the current function body
11486 (DECL_FUNCTION_BODY) to the current block super context, only if
11487 the block being exited isn't the method's top level one. */
11488
11489static tree
11490exit_block ()
11491{
f099f336
APB		 11492 tree b;
11493 if (current_function_decl)
11494 {
11495 b = DECL_FUNCTION_BODY (current_function_decl);
11496 if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
11497 DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
11498 }
11499 else
11500 {
11501 b = current_static_block;
e04a16fb 11502
f099f336
APB		 11503 if (BLOCK_SUPERCONTEXT (b))
11504 current_static_block = BLOCK_SUPERCONTEXT (b);
11505 }
e04a16fb
AG		 11506 return b;
11507}
11508
11509/* Lookup for NAME in the nested function's blocks, all the way up to
11510 the current toplevel one. It complies with Java's local variable
11511 scoping rules. */
11512
11513static tree
11514lookup_name_in_blocks (name)
11515 tree name;
11516{
f099f336 11517 tree b = GET_CURRENT_BLOCK (current_function_decl);
e04a16fb
AG		 11518
11519 while (b != current_function_decl)
11520 {
11521 tree current;
11522
11523 /* Paranoid sanity check. To be removed */
11524 if (TREE_CODE (b) != BLOCK)
11525 fatal ("non block expr function body - lookup_name_in_blocks");
11526
11527 for (current = BLOCK_EXPR_DECLS (b); current;
11528 current = TREE_CHAIN (current))
11529 if (DECL_NAME (current) == name)
11530 return current;
11531 b = BLOCK_SUPERCONTEXT (b);
11532 }
11533 return NULL_TREE;
11534}
11535
11536static void
11537maybe_absorb_scoping_blocks ()
11538{
f099f336 11539 while (BLOCK_EXPR_ORIGIN (GET_CURRENT_BLOCK (current_function_decl)))
e04a16fb
AG		 11540 {
11541 tree b = exit_block ();
11542 java_method_add_stmt (current_function_decl, b);
11543 SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
11544 }
11545}
11546
11547\f
11548/* This section of the source is reserved to build_* functions that
11549 are building incomplete tree nodes and the patch_* functions that
11550 are completing them. */
11551
c2952b01
APB		 11552/* Wrap a non WFL node around a WFL. */
11553static tree
9a7ab4b3 11554build_wfl_wrap (node, location)
c2952b01 11555 tree node;
9a7ab4b3 11556 int location;
c2952b01
APB		 11557{
11558 tree wfl, node_to_insert = node;
11559
11560 /* We want to process THIS . xxx symbolicaly, to keep it consistent
11561 with the way we're processing SUPER. A THIS from a primary as a
11562 different form than a SUPER. Turn THIS into something symbolic */
11563 if (TREE_CODE (node) == THIS_EXPR)
11564 node_to_insert = wfl = build_wfl_node (this_identifier_node);
11565 else
11566 wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
11567
9a7ab4b3 11568 EXPR_WFL_LINECOL (wfl) = location;
c2952b01
APB		 11569 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
11570 return wfl;
11571}
11572
11573
9bbc7d9f 11574/* Build a super() constructor invocation. Returns empty_stmt_node if
22eed1e6
APB		 11575 we're currently dealing with the class java.lang.Object. */
11576
11577static tree
e920ebc9
APB		 11578build_super_invocation (mdecl)
11579 tree mdecl;
22eed1e6 11580{
e920ebc9 11581 if (DECL_CONTEXT (mdecl) == object_type_node)
9bbc7d9f 11582 return empty_stmt_node;
22eed1e6
APB		 11583 else
11584 {
9ee9b555 11585 tree super_wfl = build_wfl_node (super_identifier_node);
c2952b01
APB		 11586 tree a = NULL_TREE, t;
11587 /* If we're dealing with an anonymous class, pass the arguments
11588 of the crafted constructor along. */
11589 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
11590 {
11591 SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
11592 for (; t != end_params_node; t = TREE_CHAIN (t))
11593 a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
11594 }
11595 return build_method_invocation (super_wfl, a);
22eed1e6
APB		 11596 }
11597}
11598
11599/* Build a SUPER/THIS qualified method invocation. */
11600
11601static tree
11602build_this_super_qualified_invocation (use_this, name, args, lloc, rloc)
11603 int use_this;
11604 tree name, args;
11605 int lloc, rloc;
22eed1e6
APB		 11606{
11607 tree invok;
11608 tree wfl =
9ee9b555 11609 build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
22eed1e6
APB		 11610 EXPR_WFL_LINECOL (wfl) = lloc;
11611 invok = build_method_invocation (name, args);
11612 return make_qualified_primary (wfl, invok, rloc);
11613}
11614
b67d701b 11615/* Build an incomplete CALL_EXPR node. */
e04a16fb
AG		 11616
11617static tree
11618build_method_invocation (name, args)
11619 tree name;
11620 tree args;
11621{
11622 tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
11623 TREE_SIDE_EFFECTS (call) = 1;
b67d701b
PB		 11624 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
11625 return call;
11626}
11627
11628/* Build an incomplete new xxx(...) node. */
11629
11630static tree
11631build_new_invocation (name, args)
11632 tree name, args;
11633{
11634 tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
11635 TREE_SIDE_EFFECTS (call) = 1;
e04a16fb
AG		 11636 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
11637 return call;
11638}
11639
11640/* Build an incomplete assignment expression. */
11641
11642static tree
11643build_assignment (op, op_location, lhs, rhs)
11644 int op, op_location;
11645 tree lhs, rhs;
11646{
11647 tree assignment;
11648 /* Build the corresponding binop if we deal with a Compound
11649 Assignment operator. Mark the binop sub-tree as part of a
11650 Compound Assignment expression */
11651 if (op != ASSIGN_TK)
11652 {
11653 rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
11654 COMPOUND_ASSIGN_P (rhs) = 1;
11655 }
11656 assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
11657 TREE_SIDE_EFFECTS (assignment) = 1;
11658 EXPR_WFL_LINECOL (assignment) = op_location;
11659 return assignment;
11660}
11661
11662/* Print an INTEGER_CST node in a static buffer, and return the buffer. */
11663
15fdcfe9 11664char *
e04a16fb
AG		 11665print_int_node (node)
11666 tree node;
11667{
11668 static char buffer [80];
11669 if (TREE_CONSTANT_OVERFLOW (node))
11670 sprintf (buffer, "<overflow>");
11671
11672 if (TREE_INT_CST_HIGH (node) == 0)
11673 sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
11674 TREE_INT_CST_LOW (node));
11675 else if (TREE_INT_CST_HIGH (node) == -1
11676 && TREE_INT_CST_LOW (node) != 0)
11677 {
11678 buffer [0] = '-';
11679 sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
11680 -TREE_INT_CST_LOW (node));
11681 }
11682 else
11683 sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
11684 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
11685
11686 return buffer;
11687}
11688
7f1d4866
APB		 11689/* Return 1 if an assignment to a FINAL is attempted in a non suitable
11690 context. */
5e942c50
APB		 11691
11692static int
11693check_final_assignment (lvalue, wfl)
11694 tree lvalue, wfl;
11695{
6632dcdd
APB		 11696 if (TREE_CODE (lvalue) == COMPOUND_EXPR
11697 && JDECL_P (TREE_OPERAND (lvalue, 1)))
11698 lvalue = TREE_OPERAND (lvalue, 1);
11699
bc2874c9
TT		 11700 /* When generating class files, references to the `length' field
11701 look a bit different. */
11702 if ((flag_emit_class_files
11703 && TREE_CODE (lvalue) == COMPONENT_REF
11704 && TYPE_ARRAY_P (TREE_TYPE (TREE_OPERAND (lvalue, 0)))
11705 && FIELD_FINAL (TREE_OPERAND (lvalue, 1)))
11706 || (TREE_CODE (lvalue) == FIELD_DECL
11707 && FIELD_FINAL (lvalue)
11708 && !DECL_CLINIT_P (current_function_decl)
11709 && !DECL_FINIT_P (current_function_decl)))
5e942c50
APB		 11710 {
11711 parse_error_context
11712 (wfl, "Can't assign a value to the final variable `%s'",
11713 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
11714 return 1;
11715 }
11716 return 0;
11717}
11718
11719/* Inline references to java.lang.PRIMTYPE.TYPE when accessed in
11720 read. This is needed to avoid circularities in the implementation
11721 of these fields in libjava. */
11722
11723static tree
11724maybe_build_primttype_type_ref (rhs, wfl)
11725 tree rhs, wfl;
11726{
11727 tree to_return = NULL_TREE;
11728 tree rhs_type = TREE_TYPE (rhs);
11729 if (TREE_CODE (rhs) == COMPOUND_EXPR)
11730 {
11731 tree n = TREE_OPERAND (rhs, 1);
11732 if (TREE_CODE (n) == VAR_DECL
11733 && DECL_NAME (n) == TYPE_identifier_node
9a7ab4b3
APB		 11734 && rhs_type == class_ptr_type
11735 && TREE_CODE (EXPR_WFL_NODE (wfl)) == IDENTIFIER_NODE)
5e942c50 11736 {
49f48c71 11737 const char *self_name = IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl));
5e942c50
APB		 11738 if (!strncmp (self_name, "java.lang.", 10))
11739 to_return = build_primtype_type_ref (self_name);
11740 }
11741 }
11742 return (to_return ? to_return : rhs );
11743}
11744
e04a16fb
AG		 11745/* 15.25 Assignment operators. */
11746
11747static tree
11748patch_assignment (node, wfl_op1, wfl_op2)
11749 tree node;
11750 tree wfl_op1;
11751 tree wfl_op2;
11752{
0a2138e2 11753 tree rhs = TREE_OPERAND (node, 1);
5e942c50 11754 tree lvalue = TREE_OPERAND (node, 0), llvalue;
cd531a2e 11755 tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
e04a16fb
AG		 11756 int error_found = 0;
11757 int lvalue_from_array = 0;
11758
c2952b01 11759 /* Can't assign to a (blank) final. */
5e942c50
APB		 11760 if (check_final_assignment (lvalue, wfl_op1))
11761 error_found = 1;
e04a16fb
AG		 11762
11763 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11764
11765 /* Lhs can be a named variable */
34f4db93 11766 if (JDECL_P (lvalue))
e04a16fb 11767 {
e04a16fb
AG		 11768 lhs_type = TREE_TYPE (lvalue);
11769 }
11770 /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME +
11771 comment on reason why */
11772 else if (TREE_CODE (wfl_op1) == ARRAY_REF)
11773 {
11774 lhs_type = TREE_TYPE (lvalue);
11775 lvalue_from_array = 1;
11776 }
11777 /* Or a field access */
11778 else if (TREE_CODE (lvalue) == COMPONENT_REF)
11779 lhs_type = TREE_TYPE (lvalue);
11780 /* Or a function return slot */
11781 else if (TREE_CODE (lvalue) == RESULT_DECL)
11782 lhs_type = TREE_TYPE (lvalue);
5e942c50
APB		 11783 /* Otherwise, we might want to try to write into an optimized static
11784 final, this is an of a different nature, reported further on. */
11785 else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
1504b2b4 11786 && resolve_expression_name (wfl_op1, &llvalue))
5e942c50 11787 {
6632dcdd 11788 if (!error_found && check_final_assignment (llvalue, wfl_op1))
1504b2b4
APB		 11789 {
11790 /* What we should do instead is resetting the all the flags
11791 previously set, exchange lvalue for llvalue and continue. */
11792 error_found = 1;
11793 return error_mark_node;
11794 }
11795 else
11796 lhs_type = TREE_TYPE (lvalue);
5e942c50
APB		 11797 }
11798 else
e04a16fb
AG		 11799 {
11800 parse_error_context (wfl_op1, "Invalid left hand side of assignment");
11801 error_found = 1;
11802 }
11803
11804 rhs_type = TREE_TYPE (rhs);
b67d701b 11805 /* 5.1 Try the assignment conversion for builtin type. */
0a2138e2 11806 new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
e04a16fb 11807
b67d701b 11808 /* 5.2 If it failed, try a reference conversion */
0a2138e2 11809 if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
b67d701b 11810 lhs_type = promote_type (rhs_type);
e04a16fb
AG		 11811
11812 /* 15.25.2 If we have a compound assignment, convert RHS into the
11813 type of the LHS */
11814 else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
11815 new_rhs = convert (lhs_type, rhs);
11816
11817 /* Explicit cast required. This is an error */
11818 if (!new_rhs)
11819 {
c2e3db92
KG		 11820 char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
11821 char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
e04a16fb
AG		 11822 tree wfl;
11823 char operation [32]; /* Max size known */
11824
11825 /* If the assignment is part of a declaration, we use the WFL of
11826 the declared variable to point out the error and call it a
11827 declaration problem. If the assignment is a genuine =
11828 operator, we call is a operator `=' problem, otherwise we
11829 call it an assignment problem. In both of these last cases,
11830 we use the WFL of the operator to indicate the error. */
11831
11832 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
11833 {
11834 wfl = wfl_op1;
11835 strcpy (operation, "declaration");
11836 }
11837 else
11838 {
11839 wfl = wfl_operator;
11840 if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
11841 strcpy (operation, "assignment");
11842 else if (TREE_CODE (TREE_OPERAND (node, 0)) == RESULT_DECL)
11843 strcpy (operation, "`return'");
11844 else
11845 strcpy (operation, "`='");
11846 }
11847
1ebadc60 11848 if (!valid_cast_to_p (rhs_type, lhs_type))
781b0558
KG		 11849 parse_error_context
11850 (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
11851 operation, t1, t2);
1ebadc60 11852 else
781b0558 11853 parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
1ebadc60 11854 operation, t1, t2);
e04a16fb
AG		 11855 free (t1); free (t2);
11856 error_found = 1;
11857 }
11858
c877974e
APB		 11859 /* Inline read access to java.lang.PRIMTYPE.TYPE */
11860 if (new_rhs)
11861 new_rhs = maybe_build_primttype_type_ref (new_rhs, wfl_op2);
5e942c50 11862
e04a16fb
AG		 11863 if (error_found)
11864 return error_mark_node;
11865
2622b947
APB		 11866 /* 10.10: Array Store Exception runtime check */
11867 if (!flag_emit_class_files
e8fc7396 11868 && !flag_emit_xref
2622b947 11869 && lvalue_from_array
afc390b1 11870 && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
2622b947
APB		 11871 {
11872 tree check;
11873 tree base = lvalue;
11874
11875 /* We need to retrieve the right argument for _Jv_CheckArrayStore */
11876 if (TREE_CODE (lvalue) == COMPOUND_EXPR)
11877 base = TREE_OPERAND (lvalue, 0);
11878 else
11879 {
11880 if (flag_bounds_check)
11881 base = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (base, 0), 1), 0);
11882 else
11883 base = TREE_OPERAND (TREE_OPERAND (base, 0), 0);
11884 }
11885
11886 /* Build the invocation of _Jv_CheckArrayStore */
dc4e6ccf 11887 new_rhs = save_expr (new_rhs);
2622b947
APB		 11888 check = build (CALL_EXPR, void_type_node,
11889 build_address_of (soft_checkarraystore_node),
11890 tree_cons (NULL_TREE, base,
11891 build_tree_list (NULL_TREE, new_rhs)),
11892 NULL_TREE);
11893 TREE_SIDE_EFFECTS (check) = 1;
11894
11895 /* We have to decide on an insertion point */
11896 if (TREE_CODE (lvalue) == COMPOUND_EXPR)
11897 {
11898 tree t;
11899 if (flag_bounds_check)
11900 {
11901 t = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0);
11902 TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (lvalue, 1), 0), 0) =
11903 build (COMPOUND_EXPR, void_type_node, t, check);
11904 }
11905 else
11906 TREE_OPERAND (lvalue, 1) = build (COMPOUND_EXPR, lhs_type,
11907 check, TREE_OPERAND (lvalue, 1));
11908 }
11909 else
11910 {
11911 /* Make sure the bound check will happen before the store check */
11912 if (flag_bounds_check)
11913 TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0) =
11914 build (COMPOUND_EXPR, void_type_node,
11915 TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0), check);
11916 else
11917 lvalue = build (COMPOUND_EXPR, lhs_type, check, lvalue);
11918 }
11919 }
22eed1e6 11920
e04a16fb
AG		 11921 TREE_OPERAND (node, 0) = lvalue;
11922 TREE_OPERAND (node, 1) = new_rhs;
11923 TREE_TYPE (node) = lhs_type;
11924 return node;
11925}
11926
b67d701b
PB		 11927/* Check that type SOURCE can be cast into type DEST. If the cast
11928 can't occur at all, return 0 otherwise 1. This function is used to
11929 produce accurate error messages on the reasons why an assignment
11930 failed. */
e04a16fb 11931
b67d701b
PB		 11932static tree
11933try_reference_assignconv (lhs_type, rhs)
11934 tree lhs_type, rhs;
e04a16fb 11935{
b67d701b
PB		 11936 tree new_rhs = NULL_TREE;
11937 tree rhs_type = TREE_TYPE (rhs);
e04a16fb 11938
b67d701b
PB		 11939 if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
11940 {
11941 /* `null' may be assigned to any reference type */
11942 if (rhs == null_pointer_node)
11943 new_rhs = null_pointer_node;
11944 /* Try the reference assignment conversion */
11945 else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
11946 new_rhs = rhs;
11947 /* This is a magic assignment that we process differently */
11948 else if (rhs == soft_exceptioninfo_call_node)
11949 new_rhs = rhs;
11950 }
11951 return new_rhs;
11952}
11953
11954/* Check that RHS can be converted into LHS_TYPE by the assignment
11955 conversion (5.2), for the cases of RHS being a builtin type. Return
11956 NULL_TREE if the conversion fails or if because RHS isn't of a
11957 builtin type. Return a converted RHS if the conversion is possible. */
11958
11959static tree
11960try_builtin_assignconv (wfl_op1, lhs_type, rhs)
11961 tree wfl_op1, lhs_type, rhs;
11962{
11963 tree new_rhs = NULL_TREE;
11964 tree rhs_type = TREE_TYPE (rhs);
11965
5e942c50
APB		 11966 /* Zero accepted everywhere */
11967 if (TREE_CODE (rhs) == INTEGER_CST
11968 && TREE_INT_CST_HIGH (rhs) == 0 && TREE_INT_CST_LOW (rhs) == 0
11969 && JPRIMITIVE_TYPE_P (rhs_type))
11970 new_rhs = convert (lhs_type, rhs);
11971
b67d701b
PB		 11972 /* 5.1.1 Try Identity Conversion,
11973 5.1.2 Try Widening Primitive Conversion */
5e942c50 11974 else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
b67d701b
PB		 11975 new_rhs = convert (lhs_type, rhs);
11976
11977 /* Try a narrowing primitive conversion (5.1.3):
11978 - expression is a constant expression of type int AND
11979 - variable is byte, short or char AND
11980 - The value of the expression is representable in the type of the
11981 variable */
11982 else if (rhs_type == int_type_node && TREE_CONSTANT (rhs)
11983 && (lhs_type == byte_type_node || lhs_type == char_type_node
11984 || lhs_type == short_type_node))
11985 {
11986 if (int_fits_type_p (rhs, lhs_type))
11987 new_rhs = convert (lhs_type, rhs);
11988 else if (wfl_op1) /* Might be called with a NULL */
11989 parse_warning_context
781b0558 11990 (wfl_op1, "Constant expression `%s' to wide for narrowing primitive conversion to `%s'",
0a2138e2 11991 print_int_node (rhs), lang_printable_name (lhs_type, 0));
b67d701b
PB		 11992 /* Reported a warning that will turn into an error further
11993 down, so we don't return */
11994 }
11995
11996 return new_rhs;
11997}
11998
11999/* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12000 conversion (5.1.1) or widening primitve conversion (5.1.2). Return
12001 0 is the conversion test fails. This implements parts the method
12002 invocation convertion (5.3). */
12003
12004static int
12005valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)
12006 tree lhs_type, rhs_type;
12007{
acd663ee 12008 /* 5.1.1: This is the identity conversion part. */
5e942c50
APB		 12009 if (lhs_type == rhs_type)
12010 return 1;
12011
acd663ee
APB		 12012 /* Reject non primitive types */
12013 if (!JPRIMITIVE_TYPE_P (lhs_type) || !JPRIMITIVE_TYPE_P (rhs_type))
b67d701b
PB		 12014 return 0;
12015
acd663ee
APB		 12016 /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12017 than a char can't be converted into a char. Short can't too, but
12018 the < test below takes care of that */
b67d701b
PB		 12019 if (lhs_type == char_type_node && rhs_type == byte_type_node)
12020 return 0;
12021
5e942c50
APB		 12022 /* Accept all promoted type here. Note, we can't use <= in the test
12023 below, because we still need to bounce out assignments of short
12024 to char and the likes */
12025 if (lhs_type == int_type_node
12026 && (rhs_type == promoted_byte_type_node
12027 || rhs_type == promoted_short_type_node
12028 || rhs_type == promoted_char_type_node
12029 || rhs_type == promoted_boolean_type_node))
12030 return 1;
12031
acd663ee
APB		 12032 /* From here, an integral is widened if its precision is smaller
12033 than the precision of the LHS or if the LHS is a floating point
12034 type, or the RHS is a float and the RHS a double. */
12035 if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12036 && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12037 || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12038 || (rhs_type == float_type_node && lhs_type == double_type_node))
b67d701b
PB		 12039 return 1;
12040
12041 return 0;
e04a16fb
AG		 12042}
12043
12044/* Check that something of SOURCE type can be assigned or cast to
12045 something of DEST type at runtime. Return 1 if the operation is
12046 valid, 0 otherwise. If CAST is set to 1, we're treating the case
12047 were SOURCE is cast into DEST, which borrows a lot of the
12048 assignment check. */
12049
12050static int
12051valid_ref_assignconv_cast_p (source, dest, cast)
12052 tree source;
12053 tree dest;
12054 int cast;
12055{
09ed0f70
APB		 12056 /* SOURCE or DEST might be null if not from a declared entity. */
12057 if (!source || !dest)
12058 return 0;
5e942c50
APB		 12059 if (JNULLP_TYPE_P (source))
12060 return 1;
e04a16fb
AG		 12061 if (TREE_CODE (source) == POINTER_TYPE)
12062 source = TREE_TYPE (source);
12063 if (TREE_CODE (dest) == POINTER_TYPE)
12064 dest = TREE_TYPE (dest);
12065 /* Case where SOURCE is a class type */
12066 if (TYPE_CLASS_P (source))
12067 {
12068 if (TYPE_CLASS_P (dest))
c2952b01
APB		 12069 return (source == dest
12070 || inherits_from_p (source, dest)
d6baf6f5 12071 || enclosing_context_p (source, dest)
c2952b01 12072 || (cast && inherits_from_p (dest, source)));
e04a16fb
AG		 12073 if (TYPE_INTERFACE_P (dest))
12074 {
12075 /* If doing a cast and SOURCE is final, the operation is
12076 always correct a compile time (because even if SOURCE
12077 does not implement DEST, a subclass of SOURCE might). */
12078 if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12079 return 1;
12080 /* Otherwise, SOURCE must implement DEST */
12081 return interface_of_p (dest, source);
12082 }
12083 /* DEST is an array, cast permited if SOURCE is of Object type */
12084 return (cast && source == object_type_node ? 1 : 0);
12085 }
12086 if (TYPE_INTERFACE_P (source))
12087 {
12088 if (TYPE_CLASS_P (dest))
12089 {
12090 /* If not casting, DEST must be the Object type */
12091 if (!cast)
12092 return dest == object_type_node;
12093 /* We're doing a cast. The cast is always valid is class
12094 DEST is not final, otherwise, DEST must implement SOURCE */
b67d701b 12095 else if (!CLASS_FINAL (TYPE_NAME (dest)))
e04a16fb
AG		 12096 return 1;
12097 else
12098 return interface_of_p (source, dest);
12099 }
12100 if (TYPE_INTERFACE_P (dest))
12101 {
12102 /* If doing a cast, then if SOURCE and DEST contain method
12103 with the same signature but different return type, then
12104 this is a (compile time) error */
12105 if (cast)
12106 {
12107 tree method_source, method_dest;
12108 tree source_type;
0a2138e2 12109 tree source_sig;
e04a16fb
AG		 12110 tree source_name;
12111 for (method_source = TYPE_METHODS (source); method_source;
12112 method_source = TREE_CHAIN (method_source))
12113 {
12114 source_sig =
12115 build_java_argument_signature (TREE_TYPE (method_source));
12116 source_type = TREE_TYPE (TREE_TYPE (method_source));
12117 source_name = DECL_NAME (method_source);
12118 for (method_dest = TYPE_METHODS (dest);
12119 method_dest; method_dest = TREE_CHAIN (method_dest))
12120 if (source_sig ==
12121 build_java_argument_signature (TREE_TYPE (method_dest))
12122 && source_name == DECL_NAME (method_dest)
12123 && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
12124 return 0;
12125 }
12126 return 1;
12127 }
12128 else
12129 return source == dest || interface_of_p (dest, source);
12130 }
12131 else /* Array */
93024893
APB		 12132 return (cast ?
12133 (DECL_NAME (TYPE_NAME (source)) == java_lang_cloneable) : 0);
e04a16fb
AG		 12134 }
12135 if (TYPE_ARRAY_P (source))
12136 {
12137 if (TYPE_CLASS_P (dest))
12138 return dest == object_type_node;
09ed0f70
APB		 12139 /* Can't cast an array to an interface unless the interface is
12140 java.lang.Cloneable */
e04a16fb 12141 if (TYPE_INTERFACE_P (dest))
09ed0f70 12142 return (DECL_NAME (TYPE_NAME (dest)) == java_lang_cloneable ? 1 : 0);
e04a16fb
AG		 12143 else /* Arrays */
12144 {
12145 tree source_element_type = TYPE_ARRAY_ELEMENT (source);
12146 tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
12147
b9f7e36c
APB		 12148 /* In case of severe errors, they turn out null */
12149 if (!dest_element_type || !source_element_type)
12150 return 0;
e04a16fb
AG		 12151 if (source_element_type == dest_element_type)
12152 return 1;
12153 return valid_ref_assignconv_cast_p (source_element_type,
12154 dest_element_type, cast);
12155 }
12156 return 0;
12157 }
12158 return 0;
12159}
12160
b67d701b
PB		 12161static int
12162valid_cast_to_p (source, dest)
12163 tree source;
12164 tree dest;
12165{
12166 if (TREE_CODE (source) == POINTER_TYPE)
12167 source = TREE_TYPE (source);
12168 if (TREE_CODE (dest) == POINTER_TYPE)
12169 dest = TREE_TYPE (dest);
12170
12171 if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
12172 return valid_ref_assignconv_cast_p (source, dest, 1);
12173
12174 else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
12175 return 1;
12176
12177 return 0;
12178}
12179
12180/* Method invocation conversion test. Return 1 if type SOURCE can be
12181 converted to type DEST through the methond invocation conversion
12182 process (5.3) */
12183
15fdcfe9
PB		 12184static tree
12185do_unary_numeric_promotion (arg)
12186 tree arg;
12187{
12188 tree type = TREE_TYPE (arg);
12189 if (TREE_CODE (type) == INTEGER_TYPE ? TYPE_PRECISION (type) < 32
12190 : TREE_CODE (type) == CHAR_TYPE)
12191 arg = convert (int_type_node, arg);
12192 return arg;
12193}
12194
acd663ee
APB		 12195/* Return a non zero value if SOURCE can be converted into DEST using
12196 the method invocation conversion rule (5.3). */
b67d701b
PB		 12197static int
12198valid_method_invocation_conversion_p (dest, source)
12199 tree dest, source;
12200{
e3884b71 12201 return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
acd663ee
APB		 12202 && valid_builtin_assignconv_identity_widening_p (dest, source))
12203 || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
12204 && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
12205 && valid_ref_assignconv_cast_p (source, dest, 0)));
b67d701b
PB		 12206}
12207
e04a16fb
AG		 12208/* Build an incomplete binop expression. */
12209
12210static tree
12211build_binop (op, op_location, op1, op2)
12212 enum tree_code op;
12213 int op_location;
12214 tree op1, op2;
12215{
5e942c50 12216 tree binop = build (op, NULL_TREE, op1, op2);
e04a16fb
AG		 12217 TREE_SIDE_EFFECTS (binop) = 1;
12218 /* Store the location of the operator, for better error report. The
12219 string of the operator will be rebuild based on the OP value. */
12220 EXPR_WFL_LINECOL (binop) = op_location;
12221 return binop;
12222}
12223
12224/* Build the string of the operator retained by NODE. If NODE is part
12225 of a compound expression, add an '=' at the end of the string. This
12226 function is called when an error needs to be reported on an
12227 operator. The string is returned as a pointer to a static character
12228 buffer. */
12229
12230static char *
12231operator_string (node)
12232 tree node;
12233{
12234#define BUILD_OPERATOR_STRING(S) \
12235 { \
12236 sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
12237 return buffer; \
12238 }
12239
12240 static char buffer [10];
12241 switch (TREE_CODE (node))
12242 {
12243 case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
12244 case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
12245 case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
12246 case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
12247 case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
12248 case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
12249 case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
12250 case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
12251 case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
12252 case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
12253 case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
12254 case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
12255 case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
12256 case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
12257 case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
12258 case GT_EXPR: BUILD_OPERATOR_STRING (">");
12259 case GE_EXPR: BUILD_OPERATOR_STRING (">=");
12260 case LT_EXPR: BUILD_OPERATOR_STRING ("<");
12261 case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
b67d701b 12262 case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
e04a16fb
AG		 12263 case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
12264 case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
12265 case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
12266 case PREINCREMENT_EXPR: /* Fall through */
12267 case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
12268 case PREDECREMENT_EXPR: /* Fall through */
12269 case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
12270 default:
12271 fatal ("unregistered operator %s - operator_string",
12272 tree_code_name [TREE_CODE (node)]);
12273 }
12274 return NULL;
12275#undef BUILD_OPERATOR_STRING
12276}
12277
5cbdba64
APB		 12278/* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
12279
12280static int
12281java_decl_equiv (var_acc1, var_acc2)
12282 tree var_acc1, var_acc2;
12283{
12284 if (JDECL_P (var_acc1))
12285 return (var_acc1 == var_acc2);
12286
12287 return (TREE_CODE (var_acc1) == COMPONENT_REF
12288 && TREE_CODE (var_acc2) == COMPONENT_REF
12289 && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
12290 == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
12291 && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
12292}
12293
12294/* Return a non zero value if CODE is one of the operators that can be
12295 used in conjunction with the `=' operator in a compound assignment. */
12296
12297static int
12298binop_compound_p (code)
12299 enum tree_code code;
12300{
12301 int i;
12302 for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
12303 if (binop_lookup [i] == code)
12304 break;
12305
12306 return i < BINOP_COMPOUND_CANDIDATES;
12307}
12308
12309/* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
12310
12311static tree
12312java_refold (t)
12313 tree t;
12314{
12315 tree c, b, ns, decl;
12316
12317 if (TREE_CODE (t) != MODIFY_EXPR)
12318 return t;
12319
12320 c = TREE_OPERAND (t, 1);
12321 if (! (c && TREE_CODE (c) == COMPOUND_EXPR
12322 && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
12323 && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
12324 return t;
12325
12326 /* Now the left branch of the binary operator. */
12327 b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
12328 if (! (b && TREE_CODE (b) == NOP_EXPR
12329 && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
12330 return t;
12331
12332 ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
12333 if (! (ns && TREE_CODE (ns) == NOP_EXPR
12334 && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
12335 return t;
12336
12337 decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
12338 if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
12339 /* It's got to be the an equivalent decl */
12340 && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
12341 {
12342 /* Shorten the NOP_EXPR/SAVE_EXPR path. */
12343 TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
12344 /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
12345 TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
12346 /* Change the right part of the BINOP_EXPR */
12347 TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
12348 }
12349
12350 return t;
12351}
12352
e04a16fb
AG		 12353/* Binary operators (15.16 up to 15.18). We return error_mark_node on
12354 errors but we modify NODE so that it contains the type computed
12355 according to the expression, when it's fixed. Otherwise, we write
12356 error_mark_node as the type. It allows us to further the analysis
12357 of remaining nodes and detects more errors in certain cases. */
12358
12359static tree
12360patch_binop (node, wfl_op1, wfl_op2)
12361 tree node;
12362 tree wfl_op1;
12363 tree wfl_op2;
12364{
12365 tree op1 = TREE_OPERAND (node, 0);
12366 tree op2 = TREE_OPERAND (node, 1);
12367 tree op1_type = TREE_TYPE (op1);
12368 tree op2_type = TREE_TYPE (op2);
48a840d9 12369 tree prom_type = NULL_TREE, cn;
e04a16fb 12370 int code = TREE_CODE (node);
b67d701b 12371
e04a16fb
AG		 12372 /* If 1, tell the routine that we have to return error_mark_node
12373 after checking for the initialization of the RHS */
12374 int error_found = 0;
12375
e04a16fb
AG		 12376 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12377
e04a16fb
AG		 12378 switch (code)
12379 {
12380 /* 15.16 Multiplicative operators */
12381 case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
12382 case RDIV_EXPR: /* 15.16.2 Division Operator / */
c2952b01 12383 case TRUNC_DIV_EXPR: /* 15.16.2 Integral type Division Operator / */
e04a16fb
AG		 12384 case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
12385 if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
12386 {
12387 if (!JPRIMITIVE_TYPE_P (op1_type))
12388 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12389 if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
12390 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12391 TREE_TYPE (node) = error_mark_node;
12392 error_found = 1;
12393 break;
12394 }
12395 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12396 /* Change the division operator if necessary */
12397 if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
12398 TREE_SET_CODE (node, TRUNC_DIV_EXPR);
0b4d333e 12399
aa4759c1
AH		 12400 if (TREE_CODE (prom_type) == INTEGER_TYPE
12401 && flag_use_divide_subroutine
12402 && ! flag_emit_class_files
12403 && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
12404 return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
12405
0b4d333e
APB		 12406 /* This one is more complicated. FLOATs are processed by a
12407 function call to soft_fmod. Duplicate the value of the
12408 COMPOUND_ASSIGN_P flag. */
e04a16fb 12409 if (code == TRUNC_MOD_EXPR)
0b4d333e
APB		 12410 {
12411 tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
12412 COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
dc0b3eff
PB		 12413 TREE_SIDE_EFFECTS (mod)
12414 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
0b4d333e
APB		 12415 return mod;
12416 }
e04a16fb
AG		 12417 break;
12418
12419 /* 15.17 Additive Operators */
12420 case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
b67d701b
PB		 12421
12422 /* Operation is valid if either one argument is a string
12423 constant, a String object or a StringBuffer crafted for the
12424 purpose of the a previous usage of the String concatenation
12425 operator */
12426
12427 if (TREE_CODE (op1) == STRING_CST
12428 || TREE_CODE (op2) == STRING_CST
12429 || JSTRING_TYPE_P (op1_type)
12430 || JSTRING_TYPE_P (op2_type)
12431 || IS_CRAFTED_STRING_BUFFER_P (op1)
12432 || IS_CRAFTED_STRING_BUFFER_P (op2))
12433 return build_string_concatenation (op1, op2);
12434
e04a16fb
AG		 12435 case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
12436 Numeric Types */
12437 if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
12438 {
12439 if (!JPRIMITIVE_TYPE_P (op1_type))
12440 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12441 if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
12442 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12443 TREE_TYPE (node) = error_mark_node;
12444 error_found = 1;
12445 break;
12446 }
12447 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12448 break;
12449
12450 /* 15.18 Shift Operators */
12451 case LSHIFT_EXPR:
12452 case RSHIFT_EXPR:
12453 case URSHIFT_EXPR:
12454 if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
12455 {
12456 if (!JINTEGRAL_TYPE_P (op1_type))
12457 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
12458 else
1ebadc60
KG		 12459 {
12460 if (JPRIMITIVE_TYPE_P (op2_type))
12461 parse_error_context (wfl_operator,
781b0558 12462 "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
1ebadc60
KG		 12463 operator_string (node),
12464 lang_printable_name (op2_type, 0));
12465 else
781b0558
KG		 12466 parse_error_context (wfl_operator,
12467 "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
1ebadc60
KG		 12468 operator_string (node),
12469 lang_printable_name (op2_type, 0));
12470 }
e04a16fb
AG		 12471 TREE_TYPE (node) = error_mark_node;
12472 error_found = 1;
12473 break;
12474 }
12475
12476 /* Unary numeric promotion (5.6.1) is performed on each operand
12477 separatly */
15fdcfe9
PB		 12478 op1 = do_unary_numeric_promotion (op1);
12479 op2 = do_unary_numeric_promotion (op2);
e04a16fb
AG		 12480
12481 /* The type of the shift expression is the type of the promoted
12482 type of the left-hand operand */
12483 prom_type = TREE_TYPE (op1);
12484
c2952b01
APB		 12485 /* Shift int only up to 0x1f and long up to 0x3f */
12486 if (prom_type == int_type_node)
12487 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
12488 build_int_2 (0x1f, 0)));
12489 else
12490 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
12491 build_int_2 (0x3f, 0)));
e04a16fb
AG		 12492
12493 /* The >>> operator is a >> operating on unsigned quantities */
15fdcfe9 12494 if (code == URSHIFT_EXPR && ! flag_emit_class_files)
e04a16fb 12495 {
0b4d333e 12496 tree to_return;
73333a87
AH		 12497 tree utype = unsigned_type (prom_type);
12498 op1 = convert (utype, op1);
e04a16fb 12499 TREE_SET_CODE (node, RSHIFT_EXPR);
73333a87
AH		 12500 TREE_OPERAND (node, 0) = op1;
12501 TREE_OPERAND (node, 1) = op2;
12502 TREE_TYPE (node) = utype;
0b4d333e
APB		 12503 to_return = convert (prom_type, node);
12504 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
12505 COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
dc0b3eff
PB		 12506 TREE_SIDE_EFFECTS (to_return)
12507 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
0b4d333e 12508 return to_return;
e04a16fb
AG		 12509 }
12510 break;
5e942c50
APB		 12511
12512 /* 15.19.1 Type Comparison Operator instaceof */
12513 case INSTANCEOF_EXPR:
12514
12515 TREE_TYPE (node) = boolean_type_node;
12516
12517 if (!(op2_type = resolve_type_during_patch (op2)))
12518 return error_mark_node;
12519
12520 /* The first operand must be a reference type or the null type */
12521 if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
12522 error_found = 1; /* Error reported further below */
12523
12524 /* The second operand must be a reference type */
12525 if (!JREFERENCE_TYPE_P (op2_type))
12526 {
12527 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
12528 parse_error_context
12529 (wfl_operator, "Invalid argument `%s' for `instanceof'",
12530 lang_printable_name (op2_type, 0));
12531 error_found = 1;
12532 }
12533
12534 if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
12535 {
12536 /* If the first operand is null, the result is always false */
12537 if (op1 == null_pointer_node)
12538 return boolean_false_node;
15fdcfe9
PB		 12539 else if (flag_emit_class_files)
12540 {
12541 TREE_OPERAND (node, 1) = op2_type;
dc0b3eff 12542 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
15fdcfe9
PB		 12543 return node;
12544 }
5e942c50
APB		 12545 /* Otherwise we have to invoke instance of to figure it out */
12546 else
67db0ce7 12547 return build_instanceof (op1, op2_type);
5e942c50
APB		 12548 }
12549 /* There is no way the expression operand can be an instance of
12550 the type operand. This is a compile time error. */
12551 else
12552 {
c2e3db92 12553 char *t1 = xstrdup (lang_printable_name (op1_type, 0));
5e942c50
APB		 12554 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
12555 parse_error_context
12556 (wfl_operator, "Impossible for `%s' to be instance of `%s'",
12557 t1, lang_printable_name (op2_type, 0));
12558 free (t1);
12559 error_found = 1;
12560 }
e04a16fb 12561
5e942c50 12562 break;
e04a16fb
AG		 12563
12564 /* 15.21 Bitwise and Logical Operators */
12565 case BIT_AND_EXPR:
12566 case BIT_XOR_EXPR:
12567 case BIT_IOR_EXPR:
12568 if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
12569 /* Binary numeric promotion is performed on both operand and the
12570 expression retain that type */
12571 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12572
12573 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
12574 && TREE_CODE (op1_type) == BOOLEAN_TYPE)
12575 /* The type of the bitwise operator expression is BOOLEAN */
12576 prom_type = boolean_type_node;
12577 else
12578 {
12579 if (!JINTEGRAL_TYPE_P (op1_type))
12580 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
12581 if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
12582 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
12583 TREE_TYPE (node) = error_mark_node;
12584 error_found = 1;
12585 /* Insert a break here if adding thing before the switch's
12586 break for this case */
12587 }
12588 break;
12589
12590 /* 15.22 Conditional-And Operator */
12591 case TRUTH_ANDIF_EXPR:
12592 /* 15.23 Conditional-Or Operator */
12593 case TRUTH_ORIF_EXPR:
12594 /* Operands must be of BOOLEAN type */
12595 if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
12596 TREE_CODE (op2_type) != BOOLEAN_TYPE)
12597 {
12598 if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
12599 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
12600 if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
12601 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
12602 TREE_TYPE (node) = boolean_type_node;
12603 error_found = 1;
12604 break;
12605 }
12606 /* The type of the conditional operators is BOOLEAN */
12607 prom_type = boolean_type_node;
12608 break;
12609
12610 /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
12611 case LT_EXPR:
12612 case GT_EXPR:
12613 case LE_EXPR:
12614 case GE_EXPR:
12615 /* The type of each of the operands must be a primitive numeric
12616 type */
12617 if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
12618 {
12619 if (!JNUMERIC_TYPE_P (op1_type))
12620 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
12621 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
12622 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
12623 TREE_TYPE (node) = boolean_type_node;
12624 error_found = 1;
12625 break;
12626 }
12627 /* Binary numeric promotion is performed on the operands */
12628 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12629 /* The type of the relation expression is always BOOLEAN */
12630 prom_type = boolean_type_node;
12631 break;
12632
12633 /* 15.20 Equality Operator */
12634 case EQ_EXPR:
12635 case NE_EXPR:
48a840d9
APB		 12636 /* It's time for us to patch the strings. */
12637 if ((cn = patch_string (op1)))
12638 {
12639 op1 = cn;
12640 op1_type = TREE_TYPE (op1);
12641 }
12642 if ((cn = patch_string (op2)))
12643 {
12644 op2 = cn;
12645 op2_type = TREE_TYPE (op2);
12646 }
12647
e04a16fb
AG		 12648 /* 15.20.1 Numerical Equality Operators == and != */
12649 /* Binary numeric promotion is performed on the operands */
5e942c50 12650 if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
e04a16fb
AG		 12651 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
12652
12653 /* 15.20.2 Boolean Equality Operators == and != */
12654 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
12655 TREE_CODE (op2_type) == BOOLEAN_TYPE)
12656 ; /* Nothing to do here */
12657
12658 /* 15.20.3 Reference Equality Operators == and != */
5e942c50
APB		 12659 /* Types have to be either references or the null type. If
12660 they're references, it must be possible to convert either
12661 type to the other by casting conversion. */
b9f7e36c
APB		 12662 else if (op1 == null_pointer_node || op2 == null_pointer_node
12663 || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
5e942c50
APB		 12664 && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
12665 || valid_ref_assignconv_cast_p (op2_type,
12666 op1_type, 1))))
e04a16fb
AG		 12667 ; /* Nothing to do here */
12668
12669 /* Else we have an error figure what can't be converted into
12670 what and report the error */
12671 else
12672 {
12673 char *t1;
c2e3db92 12674 t1 = xstrdup (lang_printable_name (op1_type, 0));
e04a16fb 12675 parse_error_context
781b0558
KG		 12676 (wfl_operator,
12677 "Incompatible type for `%s'. Can't convert `%s' to `%s'",
12678 operator_string (node), t1,
0a2138e2 12679 lang_printable_name (op2_type, 0));
e04a16fb
AG		 12680 free (t1);
12681 TREE_TYPE (node) = boolean_type_node;
12682 error_found = 1;
12683 break;
12684 }
12685 prom_type = boolean_type_node;
12686 break;
12687 }
12688
e04a16fb
AG		 12689 if (error_found)
12690 return error_mark_node;
12691
12692 TREE_OPERAND (node, 0) = op1;
12693 TREE_OPERAND (node, 1) = op2;
12694 TREE_TYPE (node) = prom_type;
dc0b3eff
PB		 12695 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
12696
ce6e9147
APB		 12697 if (flag_emit_xref)
12698 return node;
12699
d1472141
PB		 12700 /* fold does not respect side-effect order as required for Java but not C.
12701 * Also, it sometimes create SAVE_EXPRs which are bad when emitting
12702 * bytecode.
12703 */
12704 if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
12705 : ! TREE_SIDE_EFFECTS (node))
aee48ef8
PB		 12706 node = fold (node);
12707 return node;
e04a16fb
AG		 12708}
12709
b67d701b
PB		 12710/* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
12711 zero value, the value of CSTE comes after the valude of STRING */
12712
12713static tree
12714do_merge_string_cste (cste, string, string_len, after)
12715 tree cste;
49f48c71 12716 const char *string;
b67d701b
PB		 12717 int string_len, after;
12718{
12719 int len = TREE_STRING_LENGTH (cste) + string_len;
49f48c71 12720 const char *old = TREE_STRING_POINTER (cste);
b67d701b
PB		 12721 TREE_STRING_LENGTH (cste) = len;
12722 TREE_STRING_POINTER (cste) = obstack_alloc (expression_obstack, len+1);
12723 if (after)
12724 {
12725 strcpy (TREE_STRING_POINTER (cste), string);
12726 strcat (TREE_STRING_POINTER (cste), old);
12727 }
12728 else
12729 {
12730 strcpy (TREE_STRING_POINTER (cste), old);
12731 strcat (TREE_STRING_POINTER (cste), string);
12732 }
12733 return cste;
12734}
12735
12736/* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
12737 new STRING_CST on success, NULL_TREE on failure */
12738
12739static tree
12740merge_string_cste (op1, op2, after)
12741 tree op1, op2;
12742 int after;
12743{
12744 /* Handle two string constants right away */
12745 if (TREE_CODE (op2) == STRING_CST)
12746 return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
12747 TREE_STRING_LENGTH (op2), after);
12748
12749 /* Reasonable integer constant can be treated right away */
12750 if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
12751 {
49f48c71
KG		 12752 static const char *boolean_true = "true";
12753 static const char *boolean_false = "false";
12754 static const char *null_pointer = "null";
b67d701b 12755 char ch[3];
49f48c71 12756 const char *string;
b67d701b
PB		 12757
12758 if (op2 == boolean_true_node)
12759 string = boolean_true;
12760 else if (op2 == boolean_false_node)
12761 string = boolean_false;
12762 else if (op2 == null_pointer_node)
12763 string = null_pointer;
12764 else if (TREE_TYPE (op2) == char_type_node)
12765 {
12766 ch[0] = (char )TREE_INT_CST_LOW (op2);
12767 ch[1] = '\0';
12768 string = ch;
12769 }
12770 else
12771 string = print_int_node (op2);
12772
12773 return do_merge_string_cste (op1, string, strlen (string), after);
12774 }
12775 return NULL_TREE;
12776}
12777
12778/* Tries to statically concatenate OP1 and OP2 if possible. Either one
12779 has to be a STRING_CST and the other part must be a STRING_CST or a
12780 INTEGRAL constant. Return a new STRING_CST if the operation
12781 succeed, NULL_TREE otherwise.
12782
12783 If the case we want to optimize for space, we might want to return
12784 NULL_TREE for each invocation of this routine. FIXME */
12785
12786static tree
12787string_constant_concatenation (op1, op2)
12788 tree op1, op2;
12789{
12790 if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
12791 {
0a2138e2 12792 tree string, rest;
b67d701b
PB		 12793 int invert;
12794
12795 string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
12796 rest = (string == op1 ? op2 : op1);
12797 invert = (string == op1 ? 0 : 1 );
12798
12799 /* Walk REST, only if it looks reasonable */
12800 if (TREE_CODE (rest) != STRING_CST
12801 && !IS_CRAFTED_STRING_BUFFER_P (rest)
12802 && !JSTRING_TYPE_P (TREE_TYPE (rest))
12803 && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
12804 {
12805 rest = java_complete_tree (rest);
12806 if (rest == error_mark_node)
12807 return error_mark_node;
12808 rest = fold (rest);
12809 }
12810 return merge_string_cste (string, rest, invert);
12811 }
12812 return NULL_TREE;
12813}
12814
12815/* Implement the `+' operator. Does static optimization if possible,
12816 otherwise create (if necessary) and append elements to a
12817 StringBuffer. The StringBuffer will be carried around until it is
12818 used for a function call or an assignment. Then toString() will be
12819 called on it to turn it into a String object. */
12820
12821static tree
12822build_string_concatenation (op1, op2)
12823 tree op1, op2;
12824{
12825 tree result;
dc0b3eff 12826 int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
ce6e9147
APB		 12827
12828 if (flag_emit_xref)
12829 return build (PLUS_EXPR, string_type_node, op1, op2);
b67d701b
PB		 12830
12831 /* Try to do some static optimization */
12832 if ((result = string_constant_concatenation (op1, op2)))
12833 return result;
12834
c0d87ff6
PB		 12835 /* Discard empty strings on either side of the expression */
12836 if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
acd663ee
APB		 12837 {
12838 op1 = op2;
12839 op2 = NULL_TREE;
12840 }
c0d87ff6 12841 else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
acd663ee 12842 op2 = NULL_TREE;
b67d701b 12843
acd663ee 12844 /* If operands are string constant, turn then into object references */
b67d701b
PB		 12845 if (TREE_CODE (op1) == STRING_CST)
12846 op1 = patch_string_cst (op1);
acd663ee 12847 if (op2 && TREE_CODE (op2) == STRING_CST)
b67d701b
PB		 12848 op2 = patch_string_cst (op2);
12849
acd663ee
APB		 12850 /* If either one of the constant is null and the other non null
12851 operand is a String object, return it. */
12852 if (JSTRING_TYPE_P (TREE_TYPE (op1)) && !op2)
12853 return op1;
12854
b67d701b
PB		 12855 /* If OP1 isn't already a StringBuffer, create and
12856 initialize a new one */
12857 if (!IS_CRAFTED_STRING_BUFFER_P (op1))
12858 {
12859 /* Two solutions here:
c52b5771
AG		 12860 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
12861 2) OP1 is something else, we call new StringBuffer().append(OP1). */
12862 if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
b67d701b
PB		 12863 op1 = BUILD_STRING_BUFFER (op1);
12864 else
12865 {
12866 tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
12867 op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
12868 }
12869 }
12870
acd663ee
APB		 12871 if (op2)
12872 {
12873 /* OP1 is no longer the last node holding a crafted StringBuffer */
12874 IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
12875 /* Create a node for `{new...,xxx}.append (op2)' */
12876 if (op2)
12877 op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
12878 }
12879
b67d701b
PB		 12880 /* Mark the last node holding a crafted StringBuffer */
12881 IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
dc0b3eff
PB		 12882
12883 TREE_SIDE_EFFECTS (op1) = side_effects;
b67d701b
PB		 12884 return op1;
12885}
12886
12887/* Patch the string node NODE. NODE can be a STRING_CST of a crafted
12888 StringBuffer. If no string were found to be patched, return
12889 NULL. */
12890
12891static tree
12892patch_string (node)
12893 tree node;
12894{
1179ebc2
APB		 12895 if (node == error_mark_node)
12896 return error_mark_node;
b67d701b
PB		 12897 if (TREE_CODE (node) == STRING_CST)
12898 return patch_string_cst (node);
12899 else if (IS_CRAFTED_STRING_BUFFER_P (node))
12900 {
c877974e 12901 int saved = ctxp->explicit_constructor_p;
b67d701b 12902 tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
c877974e
APB		 12903 tree ret;
12904 /* Temporary disable forbid the use of `this'. */
12905 ctxp->explicit_constructor_p = 0;
12906 ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
1729c265
APB		 12907 /* String concatenation arguments must be evaluated in order too. */
12908 ret = force_evaluation_order (ret);
c877974e
APB		 12909 /* Restore it at its previous value */
12910 ctxp->explicit_constructor_p = saved;
12911 return ret;
b67d701b
PB		 12912 }
12913 return NULL_TREE;
12914}
12915
12916/* Build the internal representation of a string constant. */
12917
12918static tree
12919patch_string_cst (node)
12920 tree node;
12921{
12922 int location;
15fdcfe9
PB		 12923 if (! flag_emit_class_files)
12924 {
12925 push_obstacks (&permanent_obstack, &permanent_obstack);
12926 node = get_identifier (TREE_STRING_POINTER (node));
12927 location = alloc_name_constant (CONSTANT_String, node);
12928 node = build_ref_from_constant_pool (location);
8226320b 12929 pop_obstacks ();
15fdcfe9 12930 }
cd9643f7 12931 TREE_TYPE (node) = string_ptr_type_node;
b67d701b
PB		 12932 TREE_CONSTANT (node) = 1;
12933 return node;
12934}
12935
12936/* Build an incomplete unary operator expression. */
e04a16fb
AG		 12937
12938static tree
12939build_unaryop (op_token, op_location, op1)
12940 int op_token, op_location;
12941 tree op1;
12942{
12943 enum tree_code op;
12944 tree unaryop;
12945 switch (op_token)
12946 {
b67d701b 12947 case PLUS_TK: op = UNARY_PLUS_EXPR; break;
e04a16fb
AG		 12948 case MINUS_TK: op = NEGATE_EXPR; break;
12949 case NEG_TK: op = TRUTH_NOT_EXPR; break;
12950 case NOT_TK: op = BIT_NOT_EXPR; break;
12951 default: fatal ("Unknown token `%d' for unary operator - build_unaryop",
12952 op_token);
12953 }
12954
12955 unaryop = build1 (op, NULL_TREE, op1);
e04a16fb
AG		 12956 TREE_SIDE_EFFECTS (unaryop) = 1;
12957 /* Store the location of the operator, for better error report. The
12958 string of the operator will be rebuild based on the OP value. */
12959 EXPR_WFL_LINECOL (unaryop) = op_location;
12960 return unaryop;
12961}
12962
12963/* Special case for the ++/-- operators, since they require an extra
12964 argument to build, which is set to NULL and patched
12965 later. IS_POST_P is 1 if the operator, 0 otherwise. */
12966
12967static tree
12968build_incdec (op_token, op_location, op1, is_post_p)
12969 int op_token, op_location;
12970 tree op1;
12971 int is_post_p;
12972{
12973 static enum tree_code lookup [2][2] =
12974 {
12975 { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
12976 { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
12977 };
12978 tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
12979 NULL_TREE, op1, NULL_TREE);
12980 TREE_SIDE_EFFECTS (node) = 1;
12981 /* Store the location of the operator, for better error report. The
12982 string of the operator will be rebuild based on the OP value. */
12983 EXPR_WFL_LINECOL (node) = op_location;
12984 return node;
12985}
12986
12987/* Build an incomplete cast operator, based on the use of the
12988 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
12989 set. java_complete_tree is trained to walk a CONVERT_EXPR even
12990 though its type is already set. */
12991
12992static tree
12993build_cast (location, type, exp)
12994 int location;
12995 tree type, exp;
12996{
12997 tree node = build1 (CONVERT_EXPR, type, exp);
12998 EXPR_WFL_LINECOL (node) = location;
12999 return node;
13000}
13001
c2952b01
APB		 13002/* Build an incomplete class reference operator. */
13003static tree
13004build_incomplete_class_ref (location, class_name)
13005 int location;
13006 tree class_name;
13007{
13008 tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13009 EXPR_WFL_LINECOL (node) = location;
13010 return node;
13011}
13012
13013/* Complete an incomplete class reference operator. */
13014static tree
13015patch_incomplete_class_ref (node)
13016 tree node;
13017{
13018 tree type = TREE_OPERAND (node, 0);
13019 tree ref_type;
13020
13021 if (!(ref_type = resolve_type_during_patch (type)))
13022 return error_mark_node;
13023
165f37bc 13024 if (!flag_emit_class_files || JPRIMITIVE_TYPE_P (ref_type))
f1ff439a
TT		 13025 {
13026 /* A class referenced by `foo.class' is initialized. */
13027 return build_class_init (ref_type, build_class_ref (ref_type));
13028 }
165f37bc
APB		 13029
13030 /* If we're emitting class files and we have to deal with non
13031 primitive types, we invoke (and consider generating) the
13032 synthetic static method `class$'. */
13033 if (!TYPE_DOT_CLASS (current_class))
13034 build_dot_class_method (current_class);
13035 ref_type =
13036 build_dot_class_method_invocation (DECL_NAME (TYPE_NAME (ref_type)));
13037 return java_complete_tree (ref_type);
c2952b01
APB		 13038}
13039
e04a16fb
AG		 13040/* 15.14 Unary operators. We return error_mark_node in case of error,
13041 but preserve the type of NODE if the type is fixed. */
13042
13043static tree
13044patch_unaryop (node, wfl_op)
13045 tree node;
13046 tree wfl_op;
13047{
13048 tree op = TREE_OPERAND (node, 0);
13049 tree op_type = TREE_TYPE (op);
ab3a6dd6 13050 tree prom_type = NULL_TREE, value, decl;
c2952b01 13051 int outer_field_flag = 0;
e04a16fb
AG		 13052 int code = TREE_CODE (node);
13053 int error_found = 0;
13054
13055 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13056
13057 switch (code)
13058 {
13059 /* 15.13.2 Postfix Increment Operator ++ */
13060 case POSTINCREMENT_EXPR:
13061 /* 15.13.3 Postfix Increment Operator -- */
13062 case POSTDECREMENT_EXPR:
13063 /* 15.14.1 Prefix Increment Operator ++ */
13064 case PREINCREMENT_EXPR:
13065 /* 15.14.2 Prefix Decrement Operator -- */
13066 case PREDECREMENT_EXPR:
5cbdba64 13067 op = decl = strip_out_static_field_access_decl (op);
c2952b01
APB		 13068 outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
13069 /* We might be trying to change an outer field accessed using
13070 access method. */
13071 if (outer_field_flag)
13072 {
13073 /* Retrieve the decl of the field we're trying to access. We
13074 do that by first retrieving the function we would call to
13075 access the field. It has been already verified that this
13076 field isn't final */
13077 if (flag_emit_class_files)
13078 decl = TREE_OPERAND (op, 0);
13079 else
13080 decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
13081 decl = DECL_FUNCTION_ACCESS_DECL (decl);
13082 }
b3edebcf 13083 /* We really should have a JAVA_ARRAY_EXPR to avoid this */
c2952b01 13084 else if (!JDECL_P (decl)
b3edebcf
APB		 13085 && TREE_CODE (decl) != COMPONENT_REF
13086 && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
13087 && TREE_CODE (decl) != INDIRECT_REF
13088 && !(TREE_CODE (decl) == COMPOUND_EXPR
13089 && TREE_OPERAND (decl, 1)
13090 && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
e04a16fb 13091 {
5e942c50
APB		 13092 tree lvalue;
13093 /* Before screaming, check that we're not in fact trying to
13094 increment a optimized static final access, in which case
13095 we issue an different error message. */
13096 if (!(TREE_CODE (wfl_op) == EXPR_WITH_FILE_LOCATION
13097 && resolve_expression_name (wfl_op, &lvalue)
13098 && check_final_assignment (lvalue, wfl_op)))
13099 parse_error_context (wfl_operator, "Invalid argument to `%s'",
13100 operator_string (node));
e04a16fb
AG		 13101 TREE_TYPE (node) = error_mark_node;
13102 error_found = 1;
13103 }
c2952b01
APB		 13104
13105 if (check_final_assignment (op, wfl_op))
5e942c50
APB		 13106 error_found = 1;
13107
e04a16fb
AG		 13108 /* From now on, we know that op if a variable and that it has a
13109 valid wfl. We use wfl_op to locate errors related to the
13110 ++/-- operand. */
13111 else if (!JNUMERIC_TYPE_P (op_type))
13112 {
13113 parse_error_context
13114 (wfl_op, "Invalid argument type `%s' to `%s'",
0a2138e2 13115 lang_printable_name (op_type, 0), operator_string (node));
e04a16fb
AG		 13116 TREE_TYPE (node) = error_mark_node;
13117 error_found = 1;
13118 }
13119 else
13120 {
4a5f66c3 13121 /* Before the addition, binary numeric promotion is performed on
5cbdba64
APB		 13122 both operands, if really necessary */
13123 if (JINTEGRAL_TYPE_P (op_type))
13124 {
13125 value = build_int_2 (1, 0);
13126 TREE_TYPE (value) = TREE_TYPE (node) = op_type;
13127 }
13128 else
13129 {
13130 value = build_int_2 (1, 0);
13131 TREE_TYPE (node) =
13132 binary_numeric_promotion (op_type,
13133 TREE_TYPE (value), &op, &value);
13134 }
c2952b01
APB		 13135
13136 /* We remember we might be accessing an outer field */
13137 if (outer_field_flag)
13138 {
13139 /* We re-generate an access to the field */
13140 value = build (PLUS_EXPR, TREE_TYPE (op),
13141 build_outer_field_access (wfl_op, decl), value);
13142
13143 /* And we patch the original access$() into a write
13144 with plus_op as a rhs */
13145 return outer_field_access_fix (node, op, value);
13146 }
13147
5cbdba64 13148 /* And write back into the node. */
4a5f66c3 13149 TREE_OPERAND (node, 0) = op;
e04a16fb 13150 TREE_OPERAND (node, 1) = value;
5cbdba64
APB		 13151 /* Convert the overall back into its original type, if
13152 necessary, and return */
13153 if (JINTEGRAL_TYPE_P (op_type))
13154 return fold (node);
13155 else
13156 return fold (convert (op_type, node));
e04a16fb
AG		 13157 }
13158 break;
13159
13160 /* 15.14.3 Unary Plus Operator + */
b67d701b 13161 case UNARY_PLUS_EXPR:
e04a16fb
AG		 13162 /* 15.14.4 Unary Minus Operator - */
13163 case NEGATE_EXPR:
13164 if (!JNUMERIC_TYPE_P (op_type))
13165 {
13166 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
13167 TREE_TYPE (node) = error_mark_node;
13168 error_found = 1;
13169 }
13170 /* Unary numeric promotion is performed on operand */
13171 else
13172 {
15fdcfe9
PB		 13173 op = do_unary_numeric_promotion (op);
13174 prom_type = TREE_TYPE (op);
b67d701b 13175 if (code == UNARY_PLUS_EXPR)
4a5f66c3 13176 return fold (op);
e04a16fb
AG		 13177 }
13178 break;
13179
13180 /* 15.14.5 Bitwise Complement Operator ~ */
13181 case BIT_NOT_EXPR:
13182 if (!JINTEGRAL_TYPE_P (op_type))
13183 {
13184 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
13185 TREE_TYPE (node) = error_mark_node;
13186 error_found = 1;
13187 }
13188 else
13189 {
15fdcfe9
PB		 13190 op = do_unary_numeric_promotion (op);
13191 prom_type = TREE_TYPE (op);
e04a16fb
AG		 13192 }
13193 break;
13194
13195 /* 15.14.6 Logical Complement Operator ! */
13196 case TRUTH_NOT_EXPR:
13197 if (TREE_CODE (op_type) != BOOLEAN_TYPE)
13198 {
13199 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
c877974e
APB		 13200 /* But the type is known. We will report an error if further
13201 attempt of a assignment is made with this rhs */
e04a16fb
AG		 13202 TREE_TYPE (node) = boolean_type_node;
13203 error_found = 1;
13204 }
13205 else
13206 prom_type = boolean_type_node;
13207 break;
13208
13209 /* 15.15 Cast Expression */
13210 case CONVERT_EXPR:
0a2138e2 13211 value = patch_cast (node, wfl_operator);
e04a16fb 13212 if (value == error_mark_node)
c877974e
APB		 13213 {
13214 /* If this cast is part of an assignment, we tell the code
13215 that deals with it not to complain about a mismatch,
13216 because things have been cast, anyways */
13217 TREE_TYPE (node) = error_mark_node;
13218 error_found = 1;
13219 }
13220 else
dc0b3eff
PB		 13221 {
13222 value = fold (value);
13223 TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
13224 return value;
13225 }
e04a16fb
AG		 13226 break;
13227 }
13228
e04a16fb
AG		 13229 if (error_found)
13230 return error_mark_node;
4a5f66c3
APB		 13231
13232 /* There are cases where node has been replaced by something else
13233 and we don't end up returning here: UNARY_PLUS_EXPR,
13234 CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
7525cc04 13235 TREE_OPERAND (node, 0) = fold (op);
4a5f66c3 13236 TREE_TYPE (node) = prom_type;
dc0b3eff 13237 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
e04a16fb
AG		 13238 return fold (node);
13239}
13240
13241/* Generic type resolution that sometimes takes place during node
13242 patching. Returned the resolved type or generate an error
13243 message. Return the resolved type or NULL_TREE. */
13244
13245static tree
13246resolve_type_during_patch (type)
13247 tree type;
13248{
13249 if (unresolved_type_p (type, NULL))
13250 {
13251 tree type_decl = resolve_no_layout (EXPR_WFL_NODE (type), NULL_TREE);
13252 if (!type_decl)
13253 {
13254 parse_error_context (type,
13255 "Class `%s' not found in type declaration",
13256 IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
13257 return NULL_TREE;
13258 }
13259 else
5e942c50
APB		 13260 {
13261 CLASS_LOADED_P (TREE_TYPE (type_decl)) = 1;
13262 return TREE_TYPE (type_decl);
13263 }
e04a16fb
AG		 13264 }
13265 return type;
13266}
13267/* 5.5 Casting Conversion. error_mark_node is returned if an error is
13268 found. Otherwise NODE or something meant to replace it is returned. */
13269
13270static tree
0a2138e2 13271patch_cast (node, wfl_operator)
e04a16fb 13272 tree node;
e04a16fb
AG		 13273 tree wfl_operator;
13274{
13275 tree op = TREE_OPERAND (node, 0);
13276 tree op_type = TREE_TYPE (op);
13277 tree cast_type = TREE_TYPE (node);
13278 char *t1;
13279
13280 /* First resolve OP_TYPE if unresolved */
13281 if (!(cast_type = resolve_type_during_patch (cast_type)))
13282 return error_mark_node;
13283
13284 /* Check on cast that are proven correct at compile time */
13285 if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
13286 {
e04a16fb
AG		 13287 /* Same type */
13288 if (cast_type == op_type)
13289 return node;
13290
0b4d333e
APB		 13291 /* float and double type are converted to the original type main
13292 variant and then to the target type. */
13293 if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE)
13294 op = convert (integer_type_node, op);
13295
e04a16fb
AG		 13296 /* Try widening/narowwing convertion. Potentially, things need
13297 to be worked out in gcc so we implement the extreme cases
13298 correctly. fold_convert() needs to be fixed. */
13299 return convert (cast_type, op);
13300 }
13301
0b4d333e
APB		 13302 /* It's also valid to cast a boolean into a boolean */
13303 if (op_type == boolean_type_node && cast_type == boolean_type_node)
13304 return node;
13305
5e942c50
APB		 13306 /* null can be casted to references */
13307 if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
13308 return build_null_of_type (cast_type);
13309
e04a16fb
AG		 13310 /* The remaining legal casts involve conversion between reference
13311 types. Check for their compile time correctness. */
13312 if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
09ed0f70 13313 && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
e04a16fb
AG		 13314 {
13315 TREE_TYPE (node) = promote_type (cast_type);
13316 /* Now, the case can be determined correct at compile time if
13317 OP_TYPE can be converted into CAST_TYPE by assignment
13318 conversion (5.2) */
13319
13320 if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
15fdcfe9
PB		 13321 {
13322 TREE_SET_CODE (node, NOP_EXPR);
13323 return node;
13324 }
13325
13326 if (flag_emit_class_files)
13327 {
13328 TREE_SET_CODE (node, CONVERT_EXPR);
13329 return node;
13330 }
e04a16fb
AG		 13331
13332 /* The cast requires a run-time check */
13333 return build (CALL_EXPR, promote_type (cast_type),
13334 build_address_of (soft_checkcast_node),
13335 tree_cons (NULL_TREE, build_class_ref (cast_type),
13336 build_tree_list (NULL_TREE, op)),
13337 NULL_TREE);
13338 }
13339
13340 /* Any other casts are proven incorrect at compile time */
c2e3db92 13341 t1 = xstrdup (lang_printable_name (op_type, 0));
e04a16fb 13342 parse_error_context (wfl_operator, "Invalid cast from `%s' to `%s'",
0a2138e2 13343 t1, lang_printable_name (cast_type, 0));
e04a16fb
AG		 13344 free (t1);
13345 return error_mark_node;
13346}
13347
5e942c50
APB		 13348/* Build a null constant and give it the type TYPE. */
13349
13350static tree
13351build_null_of_type (type)
13352 tree type;
13353{
13354 tree node = build_int_2 (0, 0);
13355 TREE_TYPE (node) = promote_type (type);
13356 return node;
13357}
13358
e04a16fb
AG		 13359/* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
13360 a list of indices. */
13361static tree
13362build_array_ref (location, array, index)
13363 int location;
13364 tree array, index;
13365{
13366 tree node = build (ARRAY_REF, NULL_TREE, array, index);
13367 EXPR_WFL_LINECOL (node) = location;
13368 return node;
13369}
13370
13371/* 15.12 Array Access Expression */
13372
13373static tree
c877974e
APB		 13374patch_array_ref (node)
13375 tree node;
e04a16fb
AG		 13376{
13377 tree array = TREE_OPERAND (node, 0);
13378 tree array_type = TREE_TYPE (array);
13379 tree index = TREE_OPERAND (node, 1);
13380 tree index_type = TREE_TYPE (index);
e04a16fb
AG		 13381 int error_found = 0;
13382
13383 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13384
e04a16fb
AG		 13385 if (TREE_CODE (array_type) == POINTER_TYPE)
13386 array_type = TREE_TYPE (array_type);
13387
13388 /* The array reference must be an array */
13389 if (!TYPE_ARRAY_P (array_type))
13390 {
13391 parse_error_context
781b0558
KG		 13392 (wfl_operator,
13393 "`[]' can only be applied to arrays. It can't be applied to `%s'",
13394 lang_printable_name (array_type, 0));
e04a16fb
AG		 13395 TREE_TYPE (node) = error_mark_node;
13396 error_found = 1;
13397 }
13398
c2952b01 13399 /* The array index undergoes unary numeric promotion. The promoted
e04a16fb 13400 type must be int */
15fdcfe9
PB		 13401 index = do_unary_numeric_promotion (index);
13402 if (TREE_TYPE (index) != int_type_node)
e04a16fb 13403 {
1ebadc60 13404 if (valid_cast_to_p (index_type, int_type_node))
781b0558
KG		 13405 parse_error_context (wfl_operator,
13406 "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
1ebadc60
KG		 13407 lang_printable_name (index_type, 0));
13408 else
781b0558
KG		 13409 parse_error_context (wfl_operator,
13410 "Incompatible type for `[]'. Can't convert `%s' to `int'",
1ebadc60 13411 lang_printable_name (index_type, 0));
e04a16fb
AG		 13412 TREE_TYPE (node) = error_mark_node;
13413 error_found = 1;
13414 }
13415
e04a16fb
AG		 13416 if (error_found)
13417 return error_mark_node;
e04a16fb 13418
5e942c50 13419 array_type = TYPE_ARRAY_ELEMENT (array_type);
5e942c50 13420
7f1d4866 13421 if (flag_emit_class_files || flag_emit_xref)
e04a16fb 13422 {
15fdcfe9
PB		 13423 TREE_OPERAND (node, 0) = array;
13424 TREE_OPERAND (node, 1) = index;
e04a16fb
AG		 13425 }
13426 else
939d7216
PB		 13427 {
13428 /* The save_expr is for correct evaluation order. It would be cleaner
13429 to use force_evaluation_order (see comment there), but that is
13430 difficult when we also have to deal with bounds checking. */
13431 if (TREE_SIDE_EFFECTS (index))
13432 array = save_expr (array);
13433 node = build_java_arrayaccess (array, array_type, index);
13434 if (TREE_SIDE_EFFECTS (index))
13435 node = build (COMPOUND_EXPR, array_type, array, node);
13436 }
e04a16fb
AG		 13437 TREE_TYPE (node) = array_type;
13438 return node;
13439}
13440
13441/* 15.9 Array Creation Expressions */
13442
13443static tree
13444build_newarray_node (type, dims, extra_dims)
13445 tree type;
13446 tree dims;
13447 int extra_dims;
13448{
13449 tree node =
b67d701b 13450 build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
e04a16fb 13451 build_int_2 (extra_dims, 0));
e04a16fb
AG		 13452 return node;
13453}
13454
13455static tree
13456patch_newarray (node)
13457 tree node;
13458{
13459 tree type = TREE_OPERAND (node, 0);
13460 tree dims = TREE_OPERAND (node, 1);
13461 tree cdim, array_type;
13462 int error_found = 0;
13463 int ndims = 0;
13464 int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
e04a16fb
AG		 13465
13466 /* Dimension types are verified. It's better for the types to be
13467 verified in order. */
13468 for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
13469 {
13470 int dim_error = 0;
13471 tree dim = TREE_VALUE (cdim);
13472
13473 /* Dim might have been saved during its evaluation */
13474 dim = (TREE_CODE (dim) == SAVE_EXPR ? dim = TREE_OPERAND (dim, 0) : dim);
13475
13476 /* The type of each specified dimension must be an integral type. */
13477 if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
13478 dim_error = 1;
13479
13480 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
13481 promoted type must be int. */
13482 else
13483 {
15fdcfe9 13484 dim = do_unary_numeric_promotion (dim);
e04a16fb
AG		 13485 if (TREE_TYPE (dim) != int_type_node)
13486 dim_error = 1;
13487 }
13488
13489 /* Report errors on types here */
13490 if (dim_error)
13491 {
13492 parse_error_context
13493 (TREE_PURPOSE (cdim),
781b0558 13494 "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
b67d701b 13495 (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
e04a16fb 13496 "Explicit cast needed to" : "Can't"),
0a2138e2 13497 lang_printable_name (TREE_TYPE (dim), 0));
e04a16fb
AG		 13498 error_found = 1;
13499 }
13500
e04a16fb
AG		 13501 TREE_PURPOSE (cdim) = NULL_TREE;
13502 }
13503
13504 /* Resolve array base type if unresolved */
13505 if (!(type = resolve_type_during_patch (type)))
13506 error_found = 1;
13507
13508 if (error_found)
13509 {
13510 /* We don't want further evaluation of this bogus array creation
13511 operation */
13512 TREE_TYPE (node) = error_mark_node;
13513 return error_mark_node;
13514 }
13515
15fdcfe9
PB		 13516 /* Set array_type to the actual (promoted) array type of the result. */
13517 if (TREE_CODE (type) == RECORD_TYPE)
13518 type = build_pointer_type (type);
13519 while (--xdims >= 0)
13520 {
13521 type = promote_type (build_java_array_type (type, -1));
13522 }
13523 dims = nreverse (dims);
13524 array_type = type;
13525 for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
13526 {
13527 type = array_type;
05bccae2
RK		 13528 array_type
13529 = build_java_array_type (type,
13530 TREE_CODE (cdim) == INTEGER_CST
13531 ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
13532 : -1);
15fdcfe9
PB		 13533 array_type = promote_type (array_type);
13534 }
13535 dims = nreverse (dims);
13536
e04a16fb
AG		 13537 /* The node is transformed into a function call. Things are done
13538 differently according to the number of dimensions. If the number
13539 of dimension is equal to 1, then the nature of the base type
13540 (primitive or not) matters. */
15fdcfe9 13541 if (ndims == 1)
fdec99c6 13542 return build_new_array (type, TREE_VALUE (dims));
e04a16fb 13543
e04a16fb
AG		 13544 /* Can't reuse what's already written in expr.c because it uses the
13545 JVM stack representation. Provide a build_multianewarray. FIXME */
15fdcfe9 13546 return build (CALL_EXPR, array_type,
e04a16fb 13547 build_address_of (soft_multianewarray_node),
15fdcfe9 13548 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
e04a16fb 13549 tree_cons (NULL_TREE,
15fdcfe9 13550 build_int_2 (ndims, 0), dims )),
e04a16fb
AG		 13551 NULL_TREE);
13552}
13553
f8976021
APB		 13554/* 10.6 Array initializer. */
13555
13556/* Build a wfl for array element that don't have one, so we can
13557 pin-point errors. */
13558
13559static tree
13560maybe_build_array_element_wfl (node)
13561 tree node;
13562{
13563 if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
13564 return build_expr_wfl (NULL_TREE, ctxp->filename,
13565 ctxp->elc.line, ctxp->elc.prev_col);
13566 else
13567 return NULL_TREE;
13568}
13569
13570/* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
13571 identification of initialized arrays easier to detect during walk
13572 and expansion. */
13573
13574static tree
13575build_new_array_init (location, values)
13576 int location;
13577 tree values;
13578{
13579 tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
13580 tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
5bba4807 13581 EXPR_WFL_LINECOL (to_return) = location;
f8976021
APB		 13582 return to_return;
13583}
13584
13585/* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
13586 occurred. Otherwise return NODE after having set its type
13587 appropriately. */
13588
13589static tree
13590patch_new_array_init (type, node)
13591 tree type, node;
f8976021
APB		 13592{
13593 int error_seen = 0;
fdec99c6 13594 tree current, element_type;
f8976021 13595 HOST_WIDE_INT length;
fdec99c6
PB		 13596 int all_constant = 1;
13597 tree init = TREE_OPERAND (node, 0);
f8976021 13598
fdec99c6
PB		 13599 if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
13600 {
13601 parse_error_context (node,
13602 "Invalid array initializer for non-array type `%s'",
13603 lang_printable_name (type, 1));
13604 return error_mark_node;
13605 }
13606 type = TREE_TYPE (type);
13607 element_type = TYPE_ARRAY_ELEMENT (type);
f8976021 13608
fdec99c6
PB		 13609 CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
13610
13611 for (length = 0, current = CONSTRUCTOR_ELTS (init);
13612 current; length++, current = TREE_CHAIN (current))
f8976021 13613 {
fdec99c6
PB		 13614 tree elt = TREE_VALUE (current);
13615 if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
f8976021 13616 {
fdec99c6 13617 error_seen |= array_constructor_check_entry (element_type, current);
5bba4807
PB		 13618 elt = TREE_VALUE (current);
13619 /* When compiling to native code, STRING_CST is converted to
13620 INDIRECT_REF, but still with a TREE_CONSTANT flag. */
13621 if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
fdec99c6 13622 all_constant = 0;
f8976021 13623 }
fdec99c6
PB		 13624 else
13625 {
13626 TREE_VALUE (current) = patch_new_array_init (element_type, elt);
13627 TREE_PURPOSE (current) = NULL_TREE;
13628 all_constant = 0;
13629 }
9a7ab4b3
APB		 13630 if (elt && TREE_CODE (elt) == TREE_LIST
13631 && TREE_VALUE (elt) == error_mark_node)
fdec99c6 13632 error_seen = 1;
f8976021
APB		 13633 }
13634
13635 if (error_seen)
13636 return error_mark_node;
13637
13638 /* Create a new type. We can't reuse the one we have here by
13639 patching its dimension because it originally is of dimension -1
13640 hence reused by gcc. This would prevent triangular arrays. */
fdec99c6
PB		 13641 type = build_java_array_type (element_type, length);
13642 TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
13643 TREE_TYPE (node) = promote_type (type);
13644 TREE_CONSTANT (init) = all_constant;
bc3ca41b 13645 TREE_CONSTANT (node) = all_constant;
f8976021
APB		 13646 return node;
13647}
13648
13649/* Verify that one entry of the initializer element list can be
13650 assigned to the array base type. Report 1 if an error occurred, 0
13651 otherwise. */
13652
13653static int
13654array_constructor_check_entry (type, entry)
13655 tree type, entry;
13656{
13657 char *array_type_string = NULL; /* For error reports */
13658 tree value, type_value, new_value, wfl_value, patched;
13659 int error_seen = 0;
13660
13661 new_value = NULL_TREE;
13662 wfl_value = TREE_VALUE (entry);
13663
100f7cd8 13664 push_obstacks (&permanent_obstack, &permanent_obstack);
f8976021 13665 value = java_complete_tree (TREE_VALUE (entry));
1179ebc2 13666 /* patch_string return error_mark_node if arg is error_mark_node */
f8976021
APB		 13667 if ((patched = patch_string (value)))
13668 value = patched;
1179ebc2
APB		 13669 if (value == error_mark_node)
13670 return 1;
f8976021 13671
f8976021
APB		 13672 type_value = TREE_TYPE (value);
13673
1179ebc2 13674 /* At anytime, try_builtin_assignconv can report a warning on
f8976021
APB		 13675 constant overflow during narrowing. */
13676 SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
13677 new_value = try_builtin_assignconv (wfl_operator, type, value);
13678 if (!new_value && (new_value = try_reference_assignconv (type, value)))
13679 type_value = promote_type (type);
100f7cd8
APB		 13680
13681 pop_obstacks ();
f8976021
APB		 13682 /* Check and report errors */
13683 if (!new_value)
13684 {
49f48c71 13685 const char *msg = (!valid_cast_to_p (type_value, type) ?
f8976021
APB		 13686 "Can't" : "Explicit cast needed to");
13687 if (!array_type_string)
c2e3db92 13688 array_type_string = xstrdup (lang_printable_name (type, 1));
f8976021
APB		 13689 parse_error_context
13690 (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
13691 msg, lang_printable_name (type_value, 1), array_type_string);
13692 error_seen = 1;
13693 }
13694
13695 if (new_value)
13696 {
b8c5b1c6 13697 new_value = maybe_build_primttype_type_ref (new_value, wfl_value);
f8976021
APB		 13698 TREE_VALUE (entry) = new_value;
13699 }
13700
13701 if (array_type_string)
13702 free (array_type_string);
13703
13704 TREE_PURPOSE (entry) = NULL_TREE;
13705 return error_seen;
13706}
13707
e04a16fb
AG		 13708static tree
13709build_this (location)
13710 int location;
13711{
9ee9b555 13712 tree node = build_wfl_node (this_identifier_node);
b67d701b 13713 TREE_SET_CODE (node, THIS_EXPR);
e04a16fb
AG		 13714 EXPR_WFL_LINECOL (node) = location;
13715 return node;
13716}
13717
13718/* 14.15 The return statement. It builds a modify expression that
13719 assigns the returned value to the RESULT_DECL that hold the value
13720 to be returned. */
13721
13722static tree
13723build_return (location, op)
13724 int location;
13725 tree op;
13726{
13727 tree node = build1 (RETURN_EXPR, NULL_TREE, op);
13728 EXPR_WFL_LINECOL (node) = location;
b67d701b 13729 node = build_debugable_stmt (location, node);
e04a16fb
AG		 13730 return node;
13731}
13732
13733static tree
13734patch_return (node)
13735 tree node;
13736{
13737 tree return_exp = TREE_OPERAND (node, 0);
13738 tree meth = current_function_decl;
13739 tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
e04a16fb
AG		 13740 int error_found = 0;
13741
13742 TREE_TYPE (node) = error_mark_node;
13743 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13744
13745 /* It's invalid to have a return value within a function that is
13746 declared with the keyword void or that is a constructor */
13747 if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
13748 error_found = 1;
13749
f099f336 13750 /* It's invalid to use a return statement in a static block */
c2952b01 13751 if (DECL_CLINIT_P (current_function_decl))
f099f336
APB		 13752 error_found = 1;
13753
e04a16fb
AG		 13754 /* It's invalid to have a no return value within a function that
13755 isn't declared with the keyword `void' */
13756 if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
13757 error_found = 2;
c2952b01
APB		 13758
13759 if (in_instance_initializer)
13760 error_found = 1;
e04a16fb
AG		 13761
13762 if (error_found)
13763 {
c2952b01 13764 if (in_instance_initializer)
f099f336 13765 parse_error_context (wfl_operator,
c2952b01
APB		 13766 "`return' inside instance initializer");
13767
13768 else if (DECL_CLINIT_P (current_function_decl))
13769 parse_error_context (wfl_operator,
13770 "`return' inside static initializer");
f099f336
APB		 13771
13772 else if (!DECL_CONSTRUCTOR_P (meth))
22eed1e6 13773 {
c2e3db92 13774 char *t = xstrdup (lang_printable_name (mtype, 0));
22eed1e6
APB		 13775 parse_error_context (wfl_operator,
13776 "`return' with%s value from `%s %s'",
13777 (error_found == 1 ? "" : "out"),
13778 t, lang_printable_name (meth, 0));
13779 free (t);
13780 }
13781 else
13782 parse_error_context (wfl_operator,
13783 "`return' with value from constructor `%s'",
13784 lang_printable_name (meth, 0));
e04a16fb
AG		 13785 return error_mark_node;
13786 }
13787
5e942c50
APB		 13788 /* If we have a return_exp, build a modify expression and expand
13789 it. Note: at that point, the assignment is declared valid, but we
13790 may want to carry some more hacks */
e04a16fb
AG		 13791 if (return_exp)
13792 {
5e942c50
APB		 13793 tree exp = java_complete_tree (return_exp);
13794 tree modify, patched;
13795
13796 /* If the function returned value and EXP are booleans, EXP has
13797 to be converted into the type of DECL_RESULT, which is integer
13798 (see complete_start_java_method) */
13799 if (TREE_TYPE (exp) == boolean_type_node &&
13800 TREE_TYPE (TREE_TYPE (meth)) == boolean_type_node)
13801 exp = convert_to_integer (TREE_TYPE (DECL_RESULT (meth)), exp);
13802
13803 /* `null' can be assigned to a function returning a reference */
13804 if (JREFERENCE_TYPE_P (TREE_TYPE (TREE_TYPE (meth))) &&
13805 exp == null_pointer_node)
13806 exp = build_null_of_type (TREE_TYPE (TREE_TYPE (meth)));
13807
13808 if ((patched = patch_string (exp)))
13809 exp = patched;
13810
13811 modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
e04a16fb
AG		 13812 EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
13813 modify = java_complete_tree (modify);
5e942c50 13814
e04a16fb
AG		 13815 if (modify != error_mark_node)
13816 {
13817 TREE_SIDE_EFFECTS (modify) = 1;
13818 TREE_OPERAND (node, 0) = modify;
13819 }
13820 else
13821 return error_mark_node;
13822 }
13823 TREE_TYPE (node) = void_type_node;
13824 TREE_SIDE_EFFECTS (node) = 1;
13825 return node;
13826}
13827
13828/* 14.8 The if Statement */
13829
13830static tree
13831build_if_else_statement (location, expression, if_body, else_body)
13832 int location;
13833 tree expression, if_body, else_body;
13834{
13835 tree node;
e04a16fb 13836 if (!else_body)
9bbc7d9f 13837 else_body = empty_stmt_node;
e04a16fb
AG		 13838 node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
13839 EXPR_WFL_LINECOL (node) = location;
b67d701b 13840 node = build_debugable_stmt (location, node);
e04a16fb
AG		 13841 return node;
13842}
13843
13844static tree
13845patch_if_else_statement (node)
13846 tree node;
13847{
13848 tree expression = TREE_OPERAND (node, 0);
13849
13850 TREE_TYPE (node) = error_mark_node;
13851 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13852
13853 /* The type of expression must be boolean */
b67d701b
PB		 13854 if (TREE_TYPE (expression) != boolean_type_node
13855 && TREE_TYPE (expression) != promoted_boolean_type_node)
e04a16fb
AG		 13856 {
13857 parse_error_context
13858 (wfl_operator,
13859 "Incompatible type for `if'. Can't convert `%s' to `boolean'",
0a2138e2 13860 lang_printable_name (TREE_TYPE (expression), 0));
e04a16fb
AG		 13861 return error_mark_node;
13862 }
13863
13864 TREE_TYPE (node) = void_type_node;
13865 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9 13866 CAN_COMPLETE_NORMALLY (node)
9bbc7d9f
PB		 13867 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
13868 | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2));
e04a16fb
AG		 13869 return node;
13870}
13871
13872/* 14.6 Labeled Statements */
13873
13874/* Action taken when a lableled statement is parsed. a new
13875 LABELED_BLOCK_EXPR is created. No statement is attached to the
b635eb2f 13876 label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
e04a16fb
AG		 13877
13878static tree
0a2138e2 13879build_labeled_block (location, label)
e04a16fb 13880 int location;
0a2138e2 13881 tree label;
e04a16fb 13882{
b635eb2f 13883 tree label_name ;
e04a16fb 13884 tree label_decl, node;
b635eb2f
PB		 13885 if (label == NULL_TREE || label == continue_identifier_node)
13886 label_name = label;
13887 else
e04a16fb 13888 {
b635eb2f
PB		 13889 label_name = merge_qualified_name (label_id, label);
13890 /* Issue an error if we try to reuse a label that was previously
13891 declared */
13892 if (IDENTIFIER_LOCAL_VALUE (label_name))
13893 {
13894 EXPR_WFL_LINECOL (wfl_operator) = location;
781b0558
KG		 13895 parse_error_context (wfl_operator,
13896 "Declaration of `%s' shadows a previous label declaration",
b635eb2f
PB		 13897 IDENTIFIER_POINTER (label));
13898 EXPR_WFL_LINECOL (wfl_operator) =
13899 EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
781b0558
KG		 13900 parse_error_context (wfl_operator,
13901 "This is the location of the previous declaration of label `%s'",
b635eb2f
PB		 13902 IDENTIFIER_POINTER (label));
13903 java_error_count--;
13904 }
e04a16fb
AG		 13905 }
13906
13907 label_decl = create_label_decl (label_name);
13908 node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
13909 EXPR_WFL_LINECOL (node) = location;
13910 TREE_SIDE_EFFECTS (node) = 1;
13911 return node;
13912}
13913
b67d701b 13914/* A labeled statement LBE is attached a statement. */
e04a16fb
AG		 13915
13916static tree
b635eb2f 13917finish_labeled_statement (lbe, statement)
e04a16fb
AG		 13918 tree lbe; /* Labeled block expr */
13919 tree statement;
13920{
13921 /* In anyways, tie the loop to its statement */
13922 LABELED_BLOCK_BODY (lbe) = statement;
b635eb2f
PB		 13923 pop_labeled_block ();
13924 POP_LABELED_BLOCK ();
e04a16fb
AG		 13925 return lbe;
13926}
13927
13928/* 14.10, 14.11, 14.12 Loop Statements */
13929
13930/* Create an empty LOOP_EXPR and make it the last in the nested loop
13931 list. */
13932
13933static tree
13934build_new_loop (loop_body)
13935 tree loop_body;
13936{
13937 tree loop = build (LOOP_EXPR, NULL_TREE, loop_body);
13938 TREE_SIDE_EFFECTS (loop) = 1;
13939 PUSH_LOOP (loop);
13940 return loop;
13941}
13942
13943/* Create a loop body according to the following structure:
13944 COMPOUND_EXPR
13945 COMPOUND_EXPR (loop main body)
13946 EXIT_EXPR (this order is for while/for loops.
13947 LABELED_BLOCK_EXPR the order is reversed for do loops)
34f4db93 13948 LABEL_DECL (a continue occuring here branches at the
e04a16fb
AG		 13949 BODY end of this labeled block)
13950 INCREMENT (if any)
13951
13952 REVERSED, if non zero, tells that the loop condition expr comes
b67d701b
PB		 13953 after the body, like in the do-while loop.
13954
13955 To obtain a loop, the loop body structure described above is
13956 encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
13957
13958 LABELED_BLOCK_EXPR
13959 LABEL_DECL (use this label to exit the loop)
13960 LOOP_EXPR
13961 <structure described above> */
e04a16fb
AG		 13962
13963static tree
13964build_loop_body (location, condition, reversed)
13965 int location;
13966 tree condition;
13967 int reversed;
13968{
0a2138e2 13969 tree first, second, body;
e04a16fb
AG		 13970
13971 condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
13972 EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
13973 condition = build_debugable_stmt (location, condition);
13974 TREE_SIDE_EFFECTS (condition) = 1;
13975
b635eb2f 13976 body = build_labeled_block (0, continue_identifier_node);
e04a16fb
AG		 13977 first = (reversed ? body : condition);
13978 second = (reversed ? condition : body);
13979 return
13980 build (COMPOUND_EXPR, NULL_TREE,
9bbc7d9f 13981 build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
e04a16fb
AG		 13982}
13983
13984/* Install CONDITION (if any) and loop BODY (using REVERSED to tell
13985 their order) on the current loop. Unlink the current loop from the
13986 loop list. */
13987
13988static tree
b635eb2f 13989finish_loop_body (location, condition, body, reversed)
e04a16fb
AG		 13990 int location;
13991 tree condition, body;
13992 int reversed;
13993{
13994 tree to_return = ctxp->current_loop;
13995 tree loop_body = LOOP_EXPR_BODY (to_return);
13996 if (condition)
13997 {
13998 tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
13999 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14000 The real EXIT_EXPR is one operand further. */
14001 EXPR_WFL_LINECOL (cnode) = location;
14002 /* This one is for accurate error reports */
14003 EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14004 TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14005 }
14006 LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14007 POP_LOOP ();
14008 return to_return;
14009}
14010
b635eb2f 14011/* Tailored version of finish_loop_body for FOR loops, when FOR
e04a16fb
AG		 14012 loops feature the condition part */
14013
14014static tree
b635eb2f 14015finish_for_loop (location, condition, update, body)
e04a16fb
AG		 14016 int location;
14017 tree condition, update, body;
14018{
14019 /* Put the condition and the loop body in place */
b635eb2f 14020 tree loop = finish_loop_body (location, condition, body, 0);
e04a16fb
AG		 14021 /* LOOP is the current loop which has been now popped of the loop
14022 stack. Install the update block */
14023 LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14024 return loop;
14025}
14026
5cbdba64
APB		 14027/* Try to find the loop a block might be related to. This comprises
14028 the case where the LOOP_EXPR is found as the second operand of a
14029 COMPOUND_EXPR, because the loop happens to have an initialization
14030 part, then expressed as the first operand of the COMPOUND_EXPR. If
14031 the search finds something, 1 is returned. Otherwise, 0 is
14032 returned. The search is assumed to start from a
14033 LABELED_BLOCK_EXPR's block. */
14034
14035static tree
14036search_loop (statement)
14037 tree statement;
14038{
14039 if (TREE_CODE (statement) == LOOP_EXPR)
14040 return statement;
14041
14042 if (TREE_CODE (statement) == BLOCK)
14043 statement = BLOCK_SUBBLOCKS (statement);
14044 else
14045 return NULL_TREE;
14046
14047 if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14048 while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14049 statement = TREE_OPERAND (statement, 1);
14050
14051 return (TREE_CODE (statement) == LOOP_EXPR
c2952b01 14052 && FOR_LOOP_P (statement) ? statement : NULL_TREE);
5cbdba64
APB		 14053}
14054
14055/* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
14056 returned otherwise. */
14057
14058static int
14059labeled_block_contains_loop_p (block, loop)
14060 tree block, loop;
14061{
14062 if (!block)
14063 return 0;
14064
14065 if (LABELED_BLOCK_BODY (block) == loop)
14066 return 1;
14067
c2952b01 14068 if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
5cbdba64
APB		 14069 return 1;
14070
14071 return 0;
14072}
14073
e04a16fb 14074/* If the loop isn't surrounded by a labeled statement, create one and
b635eb2f 14075 insert LOOP as its body. */
e04a16fb
AG		 14076
14077static tree
14078patch_loop_statement (loop)
14079 tree loop;
14080{
cd9643f7 14081 tree loop_label;
5cbdba64 14082
cd9643f7 14083 TREE_TYPE (loop) = void_type_node;
5cbdba64
APB		 14084 if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
14085 return loop;
14086
cd9643f7 14087 loop_label = build_labeled_block (0, NULL_TREE);
5cbdba64
APB		 14088 /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
14089 that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
cd9643f7
PB		 14090 LABELED_BLOCK_BODY (loop_label) = loop;
14091 PUSH_LABELED_BLOCK (loop_label);
5cbdba64 14092 return loop_label;
e04a16fb
AG		 14093}
14094
14095/* 14.13, 14.14: break and continue Statements */
14096
14097/* Build a break or a continue statement. a null NAME indicates an
14098 unlabeled break/continue statement. */
14099
14100static tree
14101build_bc_statement (location, is_break, name)
14102 int location, is_break;
14103 tree name;
14104{
14105 tree break_continue, label_block_expr = NULL_TREE;
14106
14107 if (name)
14108 {
14109 if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
14110 (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
14111 /* Null means that we don't have a target for this named
14112 break/continue. In this case, we make the target to be the
14113 label name, so that the error can be reported accuratly in
14114 patch_bc_statement. */
14115 label_block_expr = EXPR_WFL_NODE (name);
14116 }
14117 /* Unlabeled break/continue will be handled during the
14118 break/continue patch operation */
14119 break_continue
14120 = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
14121
14122 IS_BREAK_STMT_P (break_continue) = is_break;
14123 TREE_SIDE_EFFECTS (break_continue) = 1;
14124 EXPR_WFL_LINECOL (break_continue) = location;
b67d701b 14125 break_continue = build_debugable_stmt (location, break_continue);
e04a16fb
AG		 14126 return break_continue;
14127}
14128
14129/* Verification of a break/continue statement. */
14130
14131static tree
14132patch_bc_statement (node)
14133 tree node;
14134{
14135 tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
b635eb2f 14136 tree labeled_block = ctxp->current_labeled_block;
b67d701b 14137 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
e04a16fb 14138
e04a16fb 14139 /* Having an identifier here means that the target is unknown. */
b635eb2f 14140 if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
e04a16fb
AG		 14141 {
14142 parse_error_context (wfl_operator, "No label definition found for `%s'",
14143 IDENTIFIER_POINTER (bc_label));
14144 return error_mark_node;
14145 }
b635eb2f 14146 if (! IS_BREAK_STMT_P (node))
e04a16fb 14147 {
b635eb2f
PB		 14148 /* It's a continue statement. */
14149 for (;; labeled_block = TREE_CHAIN (labeled_block))
e04a16fb 14150 {
b635eb2f
PB		 14151 if (labeled_block == NULL_TREE)
14152 {
14153 if (bc_label == NULL_TREE)
14154 parse_error_context (wfl_operator,
14155 "`continue' must be in loop");
14156 else
1504b2b4
APB		 14157 parse_error_context
14158 (wfl_operator, "continue label `%s' does not name a loop",
14159 IDENTIFIER_POINTER (bc_label));
b635eb2f
PB		 14160 return error_mark_node;
14161 }
14162 if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
14163 == continue_identifier_node)
14164 && (bc_label == NULL_TREE
14165 || TREE_CHAIN (labeled_block) == bc_label))
14166 {
14167 bc_label = labeled_block;
14168 break;
14169 }
e04a16fb 14170 }
e04a16fb 14171 }
b635eb2f 14172 else if (!bc_label)
34f4db93 14173 {
b635eb2f 14174 for (;; labeled_block = TREE_CHAIN (labeled_block))
e04a16fb 14175 {
b635eb2f
PB		 14176 if (labeled_block == NULL_TREE)
14177 {
14178 parse_error_context (wfl_operator,
14179 "`break' must be in loop or switch");
14180 return error_mark_node;
14181 }
14182 target_stmt = LABELED_BLOCK_BODY (labeled_block);
14183 if (TREE_CODE (target_stmt) == SWITCH_EXPR
5cbdba64 14184 || search_loop (target_stmt))
b635eb2f
PB		 14185 {
14186 bc_label = labeled_block;
14187 break;
14188 }
e04a16fb 14189 }
e04a16fb
AG		 14190 }
14191
b635eb2f 14192 EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15fdcfe9
PB		 14193 CAN_COMPLETE_NORMALLY (bc_label) = 1;
14194
e04a16fb
AG		 14195 /* Our break/continue don't return values. */
14196 TREE_TYPE (node) = void_type_node;
14197 /* Encapsulate the break within a compound statement so that it's
5cbdba64 14198 expanded all the times by expand_expr (and not clobbered
e04a16fb
AG		 14199 sometimes, like after a if statement) */
14200 node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
14201 TREE_SIDE_EFFECTS (node) = 1;
14202 return node;
14203}
14204
14205/* Process the exit expression belonging to a loop. Its type must be
14206 boolean. */
14207
14208static tree
14209patch_exit_expr (node)
14210 tree node;
14211{
14212 tree expression = TREE_OPERAND (node, 0);
14213 TREE_TYPE (node) = error_mark_node;
14214 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14215
14216 /* The type of expression must be boolean */
14217 if (TREE_TYPE (expression) != boolean_type_node)
14218 {
14219 parse_error_context
14220 (wfl_operator,
781b0558 14221 "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
0a2138e2 14222 lang_printable_name (TREE_TYPE (expression), 0));
e04a16fb
AG		 14223 return error_mark_node;
14224 }
14225 /* Now we know things are allright, invert the condition, fold and
14226 return */
14227 TREE_OPERAND (node, 0) =
14228 fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15fdcfe9
PB		 14229
14230 if (! integer_zerop (TREE_OPERAND (node, 0))
14231 && ctxp->current_loop != NULL_TREE
14232 && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
14233 CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
14234 if (! integer_onep (TREE_OPERAND (node, 0)))
14235 CAN_COMPLETE_NORMALLY (node) = 1;
14236
14237
e04a16fb
AG		 14238 TREE_TYPE (node) = void_type_node;
14239 return node;
14240}
b67d701b
PB		 14241
14242/* 14.9 Switch statement */
14243
14244static tree
14245patch_switch_statement (node)
14246 tree node;
14247{
c877974e 14248 tree se = TREE_OPERAND (node, 0), se_type;
b67d701b
PB		 14249
14250 /* Complete the switch expression */
14251 se = TREE_OPERAND (node, 0) = java_complete_tree (se);
14252 se_type = TREE_TYPE (se);
14253 /* The type of the switch expression must be char, byte, short or
14254 int */
14255 if (!JINTEGRAL_TYPE_P (se_type))
14256 {
14257 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
781b0558
KG		 14258 parse_error_context (wfl_operator,
14259 "Incompatible type for `switch'. Can't convert `%s' to `int'",
0a2138e2 14260 lang_printable_name (se_type, 0));
b67d701b
PB		 14261 /* This is what java_complete_tree will check */
14262 TREE_OPERAND (node, 0) = error_mark_node;
14263 return error_mark_node;
14264 }
14265
15fdcfe9 14266 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
b67d701b
PB		 14267
14268 /* Ready to return */
15fdcfe9 14269 if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
b67d701b
PB		 14270 {
14271 TREE_TYPE (node) = error_mark_node;
14272 return error_mark_node;
14273 }
14274 TREE_TYPE (node) = void_type_node;
14275 TREE_SIDE_EFFECTS (node) = 1;
15fdcfe9 14276 CAN_COMPLETE_NORMALLY (node)
c877974e
APB		 14277 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14278 || ! SWITCH_HAS_DEFAULT (node);
b67d701b
PB		 14279 return node;
14280}
14281
165f37bc 14282/* 14.18 The try/catch statements */
b67d701b 14283
b67d701b 14284static tree
a7d8d81f 14285build_try_statement (location, try_block, catches)
b67d701b 14286 int location;
a7d8d81f
PB		 14287 tree try_block, catches;
14288{
14289 tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
b67d701b 14290 EXPR_WFL_LINECOL (node) = location;
a7d8d81f 14291 return node;
b67d701b
PB		 14292}
14293
a7d8d81f
PB		 14294static tree
14295build_try_finally_statement (location, try_block, finally)
14296 int location;
14297 tree try_block, finally;
b67d701b 14298{
a7d8d81f
PB		 14299 tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
14300 EXPR_WFL_LINECOL (node) = location;
14301 return node;
b67d701b
PB		 14302}
14303
14304static tree
14305patch_try_statement (node)
14306 tree node;
14307{
14308 int error_found = 0;
14309 tree try = TREE_OPERAND (node, 0);
14310 /* Exception handlers are considered in left to right order */
14311 tree catch = nreverse (TREE_OPERAND (node, 1));
b9f7e36c 14312 tree current, caught_type_list = NULL_TREE;
b67d701b
PB		 14313
14314 /* Check catch clauses, if any. Every time we find an error, we try
b9f7e36c
APB		 14315 to process the next catch clause. We process the catch clause before
14316 the try block so that when processing the try block we can check thrown
14317 exceptions againts the caught type list. */
b67d701b
PB		 14318 for (current = catch; current; current = TREE_CHAIN (current))
14319 {
14320 tree carg_decl, carg_type;
14321 tree sub_current, catch_block, catch_clause;
14322 int unreachable;
14323
b67d701b 14324 /* At this point, the structure of the catch clause is
b67d701b
PB		 14325 CATCH_EXPR (catch node)
14326 BLOCK (with the decl of the parameter)
14327 COMPOUND_EXPR
7525cc04 14328 MODIFY_EXPR (assignment of the catch parameter)
b67d701b 14329 BLOCK (catch clause block)
a7d8d81f
PB		 14330 */
14331 catch_clause = TREE_OPERAND (current, 0);
b67d701b
PB		 14332 carg_decl = BLOCK_EXPR_DECLS (catch_clause);
14333 carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
14334
14335 /* Catch clauses can't have more than one parameter declared,
14336 but it's already enforced by the grammar. Make sure that the
14337 only parameter of the clause statement in of class Throwable
14338 or a subclass of Throwable, but that was done earlier. The
14339 catch clause parameter type has also been resolved. */
14340
14341 /* Just make sure that the catch clause parameter type inherits
14342 from java.lang.Throwable */
14343 if (!inherits_from_p (carg_type, throwable_type_node))
14344 {
14345 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
14346 parse_error_context (wfl_operator,
781b0558 14347 "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
0a2138e2 14348 lang_printable_name (carg_type, 0));
b67d701b
PB		 14349 error_found = 1;
14350 continue;
14351 }
14352
14353 /* Partial check for unreachable catch statement: The catch
14354 clause is reachable iff is no earlier catch block A in
14355 the try statement such that the type of the catch
14356 clause's parameter is the same as or a subclass of the
14357 type of A's parameter */
14358 unreachable = 0;
14359 for (sub_current = catch;
14360 sub_current != current; sub_current = TREE_CHAIN (sub_current))
14361 {
14362 tree sub_catch_clause, decl;
a7d8d81f 14363 sub_catch_clause = TREE_OPERAND (sub_current, 0);
b67d701b
PB		 14364 decl = BLOCK_EXPR_DECLS (sub_catch_clause);
14365
14366 if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
14367 {
14368 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
14369 parse_error_context
781b0558
KG		 14370 (wfl_operator,
14371 "`catch' not reached because of the catch clause at line %d",
14372 EXPR_WFL_LINENO (sub_current));
b67d701b
PB		 14373 unreachable = error_found = 1;
14374 break;
14375 }
14376 }
b67d701b
PB		 14377 /* Complete the catch clause block */
14378 catch_block = java_complete_tree (TREE_OPERAND (current, 0));
14379 if (catch_block == error_mark_node)
14380 {
14381 error_found = 1;
14382 continue;
14383 }
15fdcfe9
PB		 14384 if (CAN_COMPLETE_NORMALLY (catch_block))
14385 CAN_COMPLETE_NORMALLY (node) = 1;
b67d701b 14386 TREE_OPERAND (current, 0) = catch_block;
15fdcfe9
PB		 14387
14388 if (unreachable)
14389 continue;
14390
14391 /* Things to do here: the exception must be thrown */
14392
14393 /* Link this type to the caught type list */
14394 caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
b67d701b
PB		 14395 }
14396
b9f7e36c
APB		 14397 PUSH_EXCEPTIONS (caught_type_list);
14398 if ((try = java_complete_tree (try)) == error_mark_node)
14399 error_found = 1;
15fdcfe9
PB		 14400 if (CAN_COMPLETE_NORMALLY (try))
14401 CAN_COMPLETE_NORMALLY (node) = 1;
b9f7e36c
APB		 14402 POP_EXCEPTIONS ();
14403
b67d701b
PB		 14404 /* Verification ends here */
14405 if (error_found)
14406 return error_mark_node;
14407
14408 TREE_OPERAND (node, 0) = try;
14409 TREE_OPERAND (node, 1) = catch;
b67d701b
PB		 14410 TREE_TYPE (node) = void_type_node;
14411 return node;
14412}
b9f7e36c
APB		 14413
14414/* 14.17 The synchronized Statement */
14415
14416static tree
14417patch_synchronized_statement (node, wfl_op1)
14418 tree node, wfl_op1;
14419{
5a005d9e 14420 tree expr = java_complete_tree (TREE_OPERAND (node, 0));
b9f7e36c 14421 tree block = TREE_OPERAND (node, 1);
5a005d9e 14422
d8fccff5 14423 tree enter, exit, expr_decl, assignment;
5a005d9e
PB		 14424
14425 if (expr == error_mark_node)
14426 {
14427 block = java_complete_tree (block);
14428 return expr;
14429 }
b9f7e36c
APB		 14430
14431 /* The TYPE of expr must be a reference type */
5a005d9e 14432 if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
b9f7e36c
APB		 14433 {
14434 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
781b0558 14435 parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
0a2138e2 14436 lang_printable_name (TREE_TYPE (expr), 0));
b9f7e36c
APB		 14437 return error_mark_node;
14438 }
14439
ce6e9147
APB		 14440 if (flag_emit_xref)
14441 {
14442 TREE_OPERAND (node, 0) = expr;
14443 TREE_OPERAND (node, 1) = java_complete_tree (block);
14444 CAN_COMPLETE_NORMALLY (node) = 1;
14445 return node;
14446 }
14447
b9f7e36c
APB		 14448 /* Generate a try-finally for the synchronized statement, except
14449 that the handler that catches all throw exception calls
14450 _Jv_MonitorExit and then rethrow the exception.
14451 The synchronized statement is then implemented as:
14452 TRY
14453 {
14454 _Jv_MonitorEnter (expression)
14455 synchronized_block
14456 _Jv_MonitorExit (expression)
14457 }
14458 CATCH_ALL
14459 {
14460 e = _Jv_exception_info ();
14461 _Jv_MonitorExit (expression)
14462 Throw (e);
14463 } */
14464
5a005d9e
PB		 14465 expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
14466 BUILD_MONITOR_ENTER (enter, expr_decl);
14467 BUILD_MONITOR_EXIT (exit, expr_decl);
14468 CAN_COMPLETE_NORMALLY (enter) = 1;
14469 CAN_COMPLETE_NORMALLY (exit) = 1;
96847892
AH		 14470 assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
14471 TREE_SIDE_EFFECTS (assignment) = 1;
5a005d9e
PB		 14472 node = build1 (CLEANUP_POINT_EXPR, NULL_TREE,
14473 build (COMPOUND_EXPR, NULL_TREE,
14474 build (WITH_CLEANUP_EXPR, NULL_TREE,
14475 build (COMPOUND_EXPR, NULL_TREE,
96847892 14476 assignment, enter),
5a005d9e
PB		 14477 NULL_TREE, exit),
14478 block));
14479 node = build_expr_block (node, expr_decl);
14480
14481 return java_complete_tree (node);
b9f7e36c
APB		 14482}
14483
14484/* 14.16 The throw Statement */
14485
14486static tree
14487patch_throw_statement (node, wfl_op1)
14488 tree node, wfl_op1;
14489{
14490 tree expr = TREE_OPERAND (node, 0);
14491 tree type = TREE_TYPE (expr);
14492 int unchecked_ok = 0, tryblock_throws_ok = 0;
14493
14494 /* Thrown expression must be assignable to java.lang.Throwable */
14495 if (!try_reference_assignconv (throwable_type_node, expr))
14496 {
14497 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
781b0558
KG		 14498 parse_error_context (wfl_operator,
14499 "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
0a2138e2 14500 lang_printable_name (type, 0));
b9f7e36c
APB		 14501 /* If the thrown expression was a reference, we further the
14502 compile-time check. */
14503 if (!JREFERENCE_TYPE_P (type))
14504 return error_mark_node;
14505 }
14506
14507 /* At least one of the following must be true */
14508
14509 /* The type of the throw expression is a not checked exception,
14510 i.e. is a unchecked expression. */
c877974e 14511 unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
b9f7e36c 14512
c2952b01
APB		 14513 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
14514 /* An instance can't throw a checked excetion unless that exception
14515 is explicitely declared in the `throws' clause of each
14516 constructor. This doesn't apply to anonymous classes, since they
14517 don't have declared constructors. */
14518 if (!unchecked_ok
14519 && in_instance_initializer && !ANONYMOUS_CLASS_P (current_class))
14520 {
14521 tree current;
14522 for (current = TYPE_METHODS (current_class); current;
14523 current = TREE_CHAIN (current))
14524 if (DECL_CONSTRUCTOR_P (current)
14525 && !check_thrown_exceptions_do (TREE_TYPE (expr)))
14526 {
14527 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)",
14528 lang_printable_name (TREE_TYPE (expr), 0));
14529 return error_mark_node;
14530 }
14531 }
14532
b9f7e36c
APB		 14533 /* Throw is contained in a try statement and at least one catch
14534 clause can receive the thrown expression or the current method is
14535 declared to throw such an exception. Or, the throw statement is
14536 contained in a method or constructor declaration and the type of
14537 the Expression is assignable to at least one type listed in the
14538 throws clause the declaration. */
b9f7e36c 14539 if (!unchecked_ok)
f099f336 14540 tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
b9f7e36c
APB		 14541 if (!(unchecked_ok || tryblock_throws_ok))
14542 {
14543 /* If there is a surrounding try block that has no matching
14544 clatch clause, report it first. A surrounding try block exits
14545 only if there is something after the list of checked
14546 exception thrown by the current function (if any). */
14547 if (IN_TRY_BLOCK_P ())
781b0558 14548 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 14549 lang_printable_name (type, 0));
b9f7e36c
APB		 14550 /* If we have no surrounding try statement and the method doesn't have
14551 any throws, report it now. FIXME */
f099f336
APB		 14552
14553 /* We report that the exception can't be throw from a try block
14554 in all circumstances but when the `throw' is inside a static
14555 block. */
b9f7e36c
APB		 14556 else if (!EXCEPTIONS_P (currently_caught_type_list)
14557 && !tryblock_throws_ok)
f099f336 14558 {
c2952b01 14559 if (DECL_CLINIT_P (current_function_decl))
781b0558
KG		 14560 parse_error_context (wfl_operator,
14561 "Checked exception `%s' can't be thrown in initializer",
f099f336
APB		 14562 lang_printable_name (type, 0));
14563 else
781b0558
KG		 14564 parse_error_context (wfl_operator,
14565 "Checked exception `%s' isn't thrown from a `try' block",
f099f336
APB		 14566 lang_printable_name (type, 0));
14567 }
b9f7e36c
APB		 14568 /* Otherwise, the current method doesn't have the appropriate
14569 throws declaration */
14570 else
781b0558 14571 parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
0a2138e2 14572 lang_printable_name (type, 0));
b9f7e36c
APB		 14573 return error_mark_node;
14574 }
14575
ce6e9147 14576 if (! flag_emit_class_files && ! flag_emit_xref)
15fdcfe9 14577 BUILD_THROW (node, expr);
ce6e9147
APB		 14578
14579 /* If doing xrefs, keep the location where the `throw' was seen. */
14580 if (flag_emit_xref)
14581 EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
b9f7e36c
APB		 14582 return node;
14583}
14584
14585/* Check that exception said to be thrown by method DECL can be
14586 effectively caught from where DECL is invoked. */
14587
14588static void
14589check_thrown_exceptions (location, decl)
14590 int location;
14591 tree decl;
14592{
14593 tree throws;
14594 /* For all the unchecked exceptions thrown by DECL */
14595 for (throws = DECL_FUNCTION_THROWS (decl); throws;
14596 throws = TREE_CHAIN (throws))
0a2138e2 14597 if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
b9f7e36c 14598 {
3e78f871
PB		 14599#if 1
14600 /* Temporary hack to suppresses errors about cloning arrays. FIXME */
14601 if (DECL_NAME (decl) == get_identifier ("clone"))
14602 continue;
14603#endif
b9f7e36c 14604 EXPR_WFL_LINECOL (wfl_operator) = location;
c2952b01 14605 if (DECL_FINIT_P (current_function_decl))
7705e9db
APB		 14606 parse_error_context
14607 (wfl_operator, "Exception `%s' can't be thrown in initializer",
14608 lang_printable_name (TREE_VALUE (throws), 0));
14609 else
14610 {
14611 parse_error_context
781b0558 14612 (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
7705e9db 14613 lang_printable_name (TREE_VALUE (throws), 0),
c2952b01 14614 (DECL_INIT_P (current_function_decl) ?
7705e9db
APB		 14615 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
14616 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
14617 }
b9f7e36c
APB		 14618 }
14619}
14620
c877974e 14621/* Return 1 if checked EXCEPTION is caught at the current nesting level of
b9f7e36c
APB		 14622 try-catch blocks, OR is listed in the `throws' clause of the
14623 current method. */
14624
14625static int
0a2138e2 14626check_thrown_exceptions_do (exception)
b9f7e36c
APB		 14627 tree exception;
14628{
14629 tree list = currently_caught_type_list;
c877974e 14630 resolve_and_layout (exception, NULL_TREE);
b9f7e36c
APB		 14631 /* First, all the nested try-catch-finally at that stage. The
14632 last element contains `throws' clause exceptions, if any. */
c877974e
APB		 14633 if (IS_UNCHECKED_EXCEPTION_P (exception))
14634 return 1;
b9f7e36c
APB		 14635 while (list)
14636 {
14637 tree caught;
14638 for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
14639 if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
14640 return 1;
14641 list = TREE_CHAIN (list);
14642 }
14643 return 0;
14644}
14645
14646static void
14647purge_unchecked_exceptions (mdecl)
14648 tree mdecl;
14649{
14650 tree throws = DECL_FUNCTION_THROWS (mdecl);
14651 tree new = NULL_TREE;
14652
14653 while (throws)
14654 {
14655 tree next = TREE_CHAIN (throws);
c877974e 14656 if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
b9f7e36c
APB		 14657 {
14658 TREE_CHAIN (throws) = new;
14659 new = throws;
14660 }
14661 throws = next;
14662 }
14663 /* List is inverted here, but it doesn't matter */
14664 DECL_FUNCTION_THROWS (mdecl) = new;
14665}
22eed1e6
APB		 14666
14667/* 15.24 Conditional Operator ?: */
14668
14669static tree
14670patch_conditional_expr (node, wfl_cond, wfl_op1)
14671 tree node, wfl_cond, wfl_op1;
14672{
14673 tree cond = TREE_OPERAND (node, 0);
14674 tree op1 = TREE_OPERAND (node, 1);
14675 tree op2 = TREE_OPERAND (node, 2);
22eed1e6 14676 tree resulting_type = NULL_TREE;
ac825856 14677 tree t1, t2, patched;
22eed1e6
APB		 14678 int error_found = 0;
14679
ac825856
APB		 14680 /* Operands of ?: might be StringBuffers crafted as a result of a
14681 string concatenation. Obtain a descent operand here. */
14682 if ((patched = patch_string (op1)))
14683 TREE_OPERAND (node, 1) = op1 = patched;
14684 if ((patched = patch_string (op2)))
14685 TREE_OPERAND (node, 2) = op2 = patched;
14686
14687 t1 = TREE_TYPE (op1);
14688 t2 = TREE_TYPE (op2);
14689
22eed1e6
APB		 14690 /* The first expression must be a boolean */
14691 if (TREE_TYPE (cond) != boolean_type_node)
14692 {
14693 SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
781b0558
KG		 14694 parse_error_context (wfl_operator,
14695 "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
22eed1e6
APB		 14696 lang_printable_name (TREE_TYPE (cond), 0));
14697 error_found = 1;
14698 }
14699
14700 /* Second and third can be numeric, boolean (i.e. primitive),
14701 references or null. Anything else results in an error */
14702 if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
14703 || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
14704 && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
14705 || (t1 == boolean_type_node && t2 == boolean_type_node)))
14706 error_found = 1;
14707
14708 /* Determine the type of the conditional expression. Same types are
14709 easy to deal with */
14710 else if (t1 == t2)
14711 resulting_type = t1;
14712
14713 /* There are different rules for numeric types */
14714 else if (JNUMERIC_TYPE_P (t1))
14715 {
14716 /* if byte/short found, the resulting type is short */
14717 if ((t1 == byte_type_node && t2 == short_type_node)
14718 || (t1 == short_type_node && t2 == byte_type_node))
14719 resulting_type = short_type_node;
14720
14721 /* If t1 is a constant int and t2 is of type byte, short or char
14722 and t1's value fits in t2, then the resulting type is t2 */
14723 else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
14724 && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
14725 resulting_type = t2;
14726
14727 /* If t2 is a constant int and t1 is of type byte, short or char
14728 and t2's value fits in t1, then the resulting type is t1 */
14729 else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
14730 && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
14731 resulting_type = t1;
14732
14733 /* Otherwise, binary numeric promotion is applied and the
14734 resulting type is the promoted type of operand 1 and 2 */
14735 else
93024893 14736 resulting_type = binary_numeric_promotion (t1, t2,
22eed1e6
APB		 14737 &TREE_OPERAND (node, 1),
14738 &TREE_OPERAND (node, 2));
14739 }
14740
14741 /* Cases of a reference and a null type */
14742 else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
14743 resulting_type = t1;
14744
14745 else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
14746 resulting_type = t2;
14747
14748 /* Last case: different reference types. If a type can be converted
14749 into the other one by assignment conversion, the latter
14750 determines the type of the expression */
14751 else if ((resulting_type = try_reference_assignconv (t1, op2)))
14752 resulting_type = promote_type (t1);
14753
14754 else if ((resulting_type = try_reference_assignconv (t2, op1)))
14755 resulting_type = promote_type (t2);
14756
14757 /* If we don't have any resulting type, we're in trouble */
14758 if (!resulting_type)
14759 {
c2e3db92 14760 char *t = xstrdup (lang_printable_name (t1, 0));
22eed1e6 14761 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
781b0558
KG		 14762 parse_error_context (wfl_operator,
14763 "Incompatible type for `?:'. Can't convert `%s' to `%s'",
14764 t, lang_printable_name (t2, 0));
22eed1e6
APB		 14765 free (t);
14766 error_found = 1;
14767 }
14768
14769 if (error_found)
14770 {
14771 TREE_TYPE (node) = error_mark_node;
14772 return error_mark_node;
14773 }
14774
14775 TREE_TYPE (node) = resulting_type;
14776 TREE_SET_CODE (node, COND_EXPR);
15fdcfe9 14777 CAN_COMPLETE_NORMALLY (node) = 1;
22eed1e6
APB		 14778 return node;
14779}
ac825856 14780
5b09b33e
PB		 14781/* Try to constant fold NODE.
14782 If NODE is not a constant expression, return NULL_EXPR.
14783 CONTEXT is a static final VAR_DECL whose initializer we are folding. */
14784
14785static tree
14786fold_constant_for_init (node, context)
14787 tree node;
14788 tree context;
14789{
14790 tree op0, op1, val;
14791 enum tree_code code = TREE_CODE (node);
14792
93024893 14793 if (code == STRING_CST)
5b09b33e 14794 return node;
93024893
APB		 14795
14796 if (code == INTEGER_CST || code == REAL_CST)
14797 return convert (TREE_TYPE (context), node);
5b09b33e
PB		 14798
14799 switch (code)
14800 {
5b09b33e
PB		 14801 case PLUS_EXPR:
14802 case MINUS_EXPR:
bc3ca41b
PB		 14803 case MULT_EXPR:
14804 case TRUNC_MOD_EXPR:
14805 case RDIV_EXPR:
5b09b33e
PB		 14806 case LSHIFT_EXPR:
14807 case RSHIFT_EXPR:
14808 case URSHIFT_EXPR:
14809 case BIT_AND_EXPR:
14810 case BIT_XOR_EXPR:
14811 case BIT_IOR_EXPR:
5b09b33e
PB		 14812 case TRUTH_ANDIF_EXPR:
14813 case TRUTH_ORIF_EXPR:
14814 case EQ_EXPR:
14815 case NE_EXPR:
14816 case GT_EXPR:
14817 case GE_EXPR:
14818 case LT_EXPR:
14819 case LE_EXPR:
14820 op0 = TREE_OPERAND (node, 0);
14821 op1 = TREE_OPERAND (node, 1);
14822 val = fold_constant_for_init (op0, context);
14823 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14824 return NULL_TREE;
14825 TREE_OPERAND (node, 0) = val;
14826 val = fold_constant_for_init (op1, context);
14827 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14828 return NULL_TREE;
14829 TREE_OPERAND (node, 1) = val;
14830 return patch_binop (node, op0, op1);
14831
14832 case UNARY_PLUS_EXPR:
14833 case NEGATE_EXPR:
14834 case TRUTH_NOT_EXPR:
14835 case BIT_NOT_EXPR:
14836 case CONVERT_EXPR:
14837 op0 = TREE_OPERAND (node, 0);
14838 val = fold_constant_for_init (op0, context);
14839 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14840 return NULL_TREE;
14841 TREE_OPERAND (node, 0) = val;
5a005d9e 14842 return patch_unaryop (node, op0);
5b09b33e
PB		 14843 break;
14844
14845 case COND_EXPR:
14846 val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
14847 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14848 return NULL_TREE;
14849 TREE_OPERAND (node, 0) = val;
14850 val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
14851 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14852 return NULL_TREE;
14853 TREE_OPERAND (node, 1) = val;
14854 val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
14855 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14856 return NULL_TREE;
14857 TREE_OPERAND (node, 2) = val;
14858 return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
14859 : TREE_OPERAND (node, 2);
14860
14861 case VAR_DECL:
8576f094
APB		 14862 case FIELD_DECL:
14863 if (! FIELD_FINAL (node)
5b09b33e
PB		 14864 || DECL_INITIAL (node) == NULL_TREE)
14865 return NULL_TREE;
14866 val = DECL_INITIAL (node);
14867 /* Guard against infinite recursion. */
14868 DECL_INITIAL (node) = NULL_TREE;
cd9643f7 14869 val = fold_constant_for_init (val, node);
5b09b33e
PB		 14870 DECL_INITIAL (node) = val;
14871 return val;
14872
14873 case EXPR_WITH_FILE_LOCATION:
14874 /* Compare java_complete_tree and resolve_expression_name. */
14875 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
14876 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
14877 {
14878 tree name = EXPR_WFL_NODE (node);
14879 tree decl;
14880 if (PRIMARY_P (node))
14881 return NULL_TREE;
14882 else if (! QUALIFIED_P (name))
14883 {
14884 decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
8576f094
APB		 14885 if (decl == NULL_TREE
14886 || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
5b09b33e
PB		 14887 return NULL_TREE;
14888 return fold_constant_for_init (decl, decl);
14889 }
14890 else
14891 {
5b09b33e
PB		 14892 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
14893 qualify_ambiguous_name (node);
14894 if (resolve_field_access (node, &decl, NULL)
14895 && decl != NULL_TREE)
14896 return fold_constant_for_init (decl, decl);
5b09b33e
PB		 14897 return NULL_TREE;
14898 }
14899 }
14900 else
14901 {
14902 op0 = TREE_OPERAND (node, 0);
14903 val = fold_constant_for_init (op0, context);
14904 if (val == NULL_TREE || ! TREE_CONSTANT (val))
14905 return NULL_TREE;
14906 TREE_OPERAND (node, 0) = val;
14907 return val;
14908 }
14909
bc3ca41b
PB		 14910#ifdef USE_COMPONENT_REF
14911 case IDENTIFIER:
14912 case COMPONENT_REF:
14913 ?;
14914#endif
14915
5b09b33e
PB		 14916 default:
14917 return NULL_TREE;
14918 }
14919}
bc3ca41b
PB		 14920
14921#ifdef USE_COMPONENT_REF
14922/* Context is 'T' for TypeName, 'P' for PackageName,
14923 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
14924
14925tree
14926resolve_simple_name (name, context)
14927 tree name;
14928 int context;
14929{
14930}
14931
14932tree
14933resolve_qualified_name (name, context)
14934 tree name;
14935 int context;
14936{
14937}
14938#endif
GNU Compiler Collection
This page took 2.668864 seconds and 5 git commands to generate.