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