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