1 /* A Bison parser, made from /home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y, by GNU bison 1.75. */
2
3 /* Skeleton parser for Yacc-like parsing with Bison,
4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
20
21 /* As a special exception, when this file is copied by Bison into a
22 Bison output file, you may use that output file without restriction.
23 This special exception was added by the Free Software Foundation
24 in version 1.24 of Bison. */
25
26 /* Written by Richard Stallman by simplifying the original so called
27 ``semantic'' parser. */
28
29 /* All symbols defined below should begin with yy or YY, to avoid
30 infringing on user name space. This should be done even for local
31 variables, as they might otherwise be expanded by user macros.
32 There are some unavoidable exceptions within include files to
33 define necessary library symbols; they are noted "INFRINGES ON
34 USER NAME SPACE" below. */
35
36 /* Identify Bison output. */
37 #define YYBISON 1
38
39 /* Pure parsers. */
40 #define YYPURE 1
41
42 /* Using locations. */
43 #define YYLSP_NEEDED 0
44
45 /* If NAME_PREFIX is specified substitute the variables and functions
46 names. */
47 #define yyparse java_parse
48 #define yylex java_lex
49 #define yyerror java_error
50 #define yylval java_lval
51 #define yychar java_char
52 #define yydebug java_debug
53 #define yynerrs java_nerrs
54
55
56 /* Tokens. */
57 #ifndef YYTOKENTYPE
58 # define YYTOKENTYPE
59 /* Put the tokens into the symbol table, so that GDB and other debuggers
60 know about them. */
61 enum yytokentype {
62 PLUS_TK = 258,
63 MINUS_TK = 259,
64 MULT_TK = 260,
65 DIV_TK = 261,
66 REM_TK = 262,
67 LS_TK = 263,
68 SRS_TK = 264,
69 ZRS_TK = 265,
70 AND_TK = 266,
71 XOR_TK = 267,
72 OR_TK = 268,
73 BOOL_AND_TK = 269,
74 BOOL_OR_TK = 270,
75 EQ_TK = 271,
76 NEQ_TK = 272,
77 GT_TK = 273,
78 GTE_TK = 274,
79 LT_TK = 275,
80 LTE_TK = 276,
81 PLUS_ASSIGN_TK = 277,
82 MINUS_ASSIGN_TK = 278,
83 MULT_ASSIGN_TK = 279,
84 DIV_ASSIGN_TK = 280,
85 REM_ASSIGN_TK = 281,
86 LS_ASSIGN_TK = 282,
87 SRS_ASSIGN_TK = 283,
88 ZRS_ASSIGN_TK = 284,
89 AND_ASSIGN_TK = 285,
90 XOR_ASSIGN_TK = 286,
91 OR_ASSIGN_TK = 287,
92 PUBLIC_TK = 288,
93 PRIVATE_TK = 289,
94 PROTECTED_TK = 290,
95 STATIC_TK = 291,
96 FINAL_TK = 292,
97 SYNCHRONIZED_TK = 293,
98 VOLATILE_TK = 294,
99 TRANSIENT_TK = 295,
100 NATIVE_TK = 296,
101 PAD_TK = 297,
102 ABSTRACT_TK = 298,
103 STRICT_TK = 299,
104 MODIFIER_TK = 300,
105 DECR_TK = 301,
106 INCR_TK = 302,
107 DEFAULT_TK = 303,
108 IF_TK = 304,
109 THROW_TK = 305,
110 BOOLEAN_TK = 306,
111 DO_TK = 307,
112 IMPLEMENTS_TK = 308,
113 THROWS_TK = 309,
114 BREAK_TK = 310,
115 IMPORT_TK = 311,
116 ELSE_TK = 312,
117 INSTANCEOF_TK = 313,
118 RETURN_TK = 314,
119 VOID_TK = 315,
120 CATCH_TK = 316,
121 INTERFACE_TK = 317,
122 CASE_TK = 318,
123 EXTENDS_TK = 319,
124 FINALLY_TK = 320,
125 SUPER_TK = 321,
126 WHILE_TK = 322,
127 CLASS_TK = 323,
128 SWITCH_TK = 324,
129 CONST_TK = 325,
130 TRY_TK = 326,
131 FOR_TK = 327,
132 NEW_TK = 328,
133 CONTINUE_TK = 329,
134 GOTO_TK = 330,
135 PACKAGE_TK = 331,
136 THIS_TK = 332,
137 ASSERT_TK = 333,
138 BYTE_TK = 334,
139 SHORT_TK = 335,
140 INT_TK = 336,
141 LONG_TK = 337,
142 CHAR_TK = 338,
143 INTEGRAL_TK = 339,
144 FLOAT_TK = 340,
145 DOUBLE_TK = 341,
146 FP_TK = 342,
147 ID_TK = 343,
148 REL_QM_TK = 344,
149 REL_CL_TK = 345,
150 NOT_TK = 346,
151 NEG_TK = 347,
152 ASSIGN_ANY_TK = 348,
153 ASSIGN_TK = 349,
154 OP_TK = 350,
155 CP_TK = 351,
156 OCB_TK = 352,
157 CCB_TK = 353,
158 OSB_TK = 354,
159 CSB_TK = 355,
160 SC_TK = 356,
161 C_TK = 357,
162 DOT_TK = 358,
163 STRING_LIT_TK = 359,
164 CHAR_LIT_TK = 360,
165 INT_LIT_TK = 361,
166 FP_LIT_TK = 362,
167 TRUE_TK = 363,
168 FALSE_TK = 364,
169 BOOL_LIT_TK = 365,
170 NULL_TK = 366
171 };
172 #endif
173 #define PLUS_TK 258
174 #define MINUS_TK 259
175 #define MULT_TK 260
176 #define DIV_TK 261
177 #define REM_TK 262
178 #define LS_TK 263
179 #define SRS_TK 264
180 #define ZRS_TK 265
181 #define AND_TK 266
182 #define XOR_TK 267
183 #define OR_TK 268
184 #define BOOL_AND_TK 269
185 #define BOOL_OR_TK 270
186 #define EQ_TK 271
187 #define NEQ_TK 272
188 #define GT_TK 273
189 #define GTE_TK 274
190 #define LT_TK 275
191 #define LTE_TK 276
192 #define PLUS_ASSIGN_TK 277
193 #define MINUS_ASSIGN_TK 278
194 #define MULT_ASSIGN_TK 279
195 #define DIV_ASSIGN_TK 280
196 #define REM_ASSIGN_TK 281
197 #define LS_ASSIGN_TK 282
198 #define SRS_ASSIGN_TK 283
199 #define ZRS_ASSIGN_TK 284
200 #define AND_ASSIGN_TK 285
201 #define XOR_ASSIGN_TK 286
202 #define OR_ASSIGN_TK 287
203 #define PUBLIC_TK 288
204 #define PRIVATE_TK 289
205 #define PROTECTED_TK 290
206 #define STATIC_TK 291
207 #define FINAL_TK 292
208 #define SYNCHRONIZED_TK 293
209 #define VOLATILE_TK 294
210 #define TRANSIENT_TK 295
211 #define NATIVE_TK 296
212 #define PAD_TK 297
213 #define ABSTRACT_TK 298
214 #define STRICT_TK 299
215 #define MODIFIER_TK 300
216 #define DECR_TK 301
217 #define INCR_TK 302
218 #define DEFAULT_TK 303
219 #define IF_TK 304
220 #define THROW_TK 305
221 #define BOOLEAN_TK 306
222 #define DO_TK 307
223 #define IMPLEMENTS_TK 308
224 #define THROWS_TK 309
225 #define BREAK_TK 310
226 #define IMPORT_TK 311
227 #define ELSE_TK 312
228 #define INSTANCEOF_TK 313
229 #define RETURN_TK 314
230 #define VOID_TK 315
231 #define CATCH_TK 316
232 #define INTERFACE_TK 317
233 #define CASE_TK 318
234 #define EXTENDS_TK 319
235 #define FINALLY_TK 320
236 #define SUPER_TK 321
237 #define WHILE_TK 322
238 #define CLASS_TK 323
239 #define SWITCH_TK 324
240 #define CONST_TK 325
241 #define TRY_TK 326
242 #define FOR_TK 327
243 #define NEW_TK 328
244 #define CONTINUE_TK 329
245 #define GOTO_TK 330
246 #define PACKAGE_TK 331
247 #define THIS_TK 332
248 #define ASSERT_TK 333
249 #define BYTE_TK 334
250 #define SHORT_TK 335
251 #define INT_TK 336
252 #define LONG_TK 337
253 #define CHAR_TK 338
254 #define INTEGRAL_TK 339
255 #define FLOAT_TK 340
256 #define DOUBLE_TK 341
257 #define FP_TK 342
258 #define ID_TK 343
259 #define REL_QM_TK 344
260 #define REL_CL_TK 345
261 #define NOT_TK 346
262 #define NEG_TK 347
263 #define ASSIGN_ANY_TK 348
264 #define ASSIGN_TK 349
265 #define OP_TK 350
266 #define CP_TK 351
267 #define OCB_TK 352
268 #define CCB_TK 353
269 #define OSB_TK 354
270 #define CSB_TK 355
271 #define SC_TK 356
272 #define C_TK 357
273 #define DOT_TK 358
274 #define STRING_LIT_TK 359
275 #define CHAR_LIT_TK 360
276 #define INT_LIT_TK 361
277 #define FP_LIT_TK 362
278 #define TRUE_TK 363
279 #define FALSE_TK 364
280 #define BOOL_LIT_TK 365
281 #define NULL_TK 366
282
283
284
285
286 /* Copy the first part of user declarations. */
287 #line 5 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
288
289 #include "config.h"
290 #include "system.h"
291 #include <dirent.h>
292 #include "tree.h"
293 #include "rtl.h"
294 #include "real.h"
295 #include "obstack.h"
296 #include "toplev.h"
297 #include "flags.h"
298 #include "java-tree.h"
299 #include "jcf.h"
300 #include "lex.h"
301 #include "parse.h"
302 #include "zipfile.h"
303 #include "convert.h"
304 #include "buffer.h"
305 #include "xref.h"
306 #include "function.h"
307 #include "except.h"
308 #include "ggc.h"
309 #include "debug.h"
310 #include "tree-inline.h"
311
312 /* Local function prototypes */
313 static char *java_accstring_lookup PARAMS ((int));
314 static void classitf_redefinition_error PARAMS ((const char *,tree, tree, tree));
315 static void variable_redefinition_error PARAMS ((tree, tree, tree, int));
316 static tree create_class PARAMS ((int, tree, tree, tree));
317 static tree create_interface PARAMS ((int, tree, tree));
318 static void end_class_declaration PARAMS ((int));
319 static tree find_field PARAMS ((tree, tree));
320 static tree lookup_field_wrapper PARAMS ((tree, tree));
321 static int duplicate_declaration_error_p PARAMS ((tree, tree, tree));
322 static void register_fields PARAMS ((int, tree, tree));
323 static tree parser_qualified_classname PARAMS ((tree));
324 static int parser_check_super PARAMS ((tree, tree, tree));
325 static int parser_check_super_interface PARAMS ((tree, tree, tree));
326 static void check_modifiers_consistency PARAMS ((int));
327 static tree lookup_cl PARAMS ((tree));
328 static tree lookup_java_method2 PARAMS ((tree, tree, int));
329 static tree method_header PARAMS ((int, tree, tree, tree));
330 static void fix_method_argument_names PARAMS ((tree ,tree));
331 static tree method_declarator PARAMS ((tree, tree));
332 static void parse_warning_context PARAMS ((tree cl, const char *msg, ...))
333 ATTRIBUTE_PRINTF_2;
334 static void issue_warning_error_from_context PARAMS ((tree, const char *msg, va_list))
335 ATTRIBUTE_PRINTF (2, 0);
336 static void parse_ctor_invocation_error PARAMS ((void));
337 static tree parse_jdk1_1_error PARAMS ((const char *));
338 static void complete_class_report_errors PARAMS ((jdep *));
339 static int process_imports PARAMS ((void));
340 static void read_import_dir PARAMS ((tree));
341 static int find_in_imports_on_demand PARAMS ((tree, tree));
342 static void find_in_imports PARAMS ((tree, tree));
343 static void check_inner_class_access PARAMS ((tree, tree, tree));
344 static int check_pkg_class_access PARAMS ((tree, tree, bool));
345 static void register_package PARAMS ((tree));
346 static tree resolve_package PARAMS ((tree, tree *, tree *));
347 static tree resolve_class PARAMS ((tree, tree, tree, tree));
348 static void declare_local_variables PARAMS ((int, tree, tree));
349 static void dump_java_tree PARAMS ((enum tree_dump_index, tree));
350 static void source_start_java_method PARAMS ((tree));
351 static void source_end_java_method PARAMS ((void));
352 static tree find_name_in_single_imports PARAMS ((tree));
353 static void check_abstract_method_header PARAMS ((tree));
354 static tree lookup_java_interface_method2 PARAMS ((tree, tree));
355 static tree resolve_expression_name PARAMS ((tree, tree *));
356 static tree maybe_create_class_interface_decl PARAMS ((tree, tree, tree, tree));
357 static int check_class_interface_creation PARAMS ((int, int, tree,
358 tree, tree, tree));
359 static tree patch_method_invocation PARAMS ((tree, tree, tree, int,
360 int *, tree *));
361 static int breakdown_qualified PARAMS ((tree *, tree *, tree));
362 static int in_same_package PARAMS ((tree, tree));
363 static tree resolve_and_layout PARAMS ((tree, tree));
364 static tree qualify_and_find PARAMS ((tree, tree, tree));
365 static tree resolve_no_layout PARAMS ((tree, tree));
366 static int invocation_mode PARAMS ((tree, int));
367 static tree find_applicable_accessible_methods_list PARAMS ((int, tree,
368 tree, tree));
369 static void search_applicable_methods_list PARAMS ((int, tree, tree, tree,
370 tree *, tree *));
371 static tree find_most_specific_methods_list PARAMS ((tree));
372 static int argument_types_convertible PARAMS ((tree, tree));
373 static tree patch_invoke PARAMS ((tree, tree, tree));
374 static int maybe_use_access_method PARAMS ((int, tree *, tree *));
375 static tree lookup_method_invoke PARAMS ((int, tree, tree, tree, tree));
376 static tree register_incomplete_type PARAMS ((int, tree, tree, tree));
377 static tree check_inner_circular_reference PARAMS ((tree, tree));
378 static tree check_circular_reference PARAMS ((tree));
379 static tree obtain_incomplete_type PARAMS ((tree));
380 static tree java_complete_lhs PARAMS ((tree));
381 static tree java_complete_tree PARAMS ((tree));
382 static tree maybe_generate_pre_expand_clinit PARAMS ((tree));
383 static int analyze_clinit_body PARAMS ((tree, tree));
384 static int maybe_yank_clinit PARAMS ((tree));
385 static void start_complete_expand_method PARAMS ((tree));
386 static void java_complete_expand_method PARAMS ((tree));
387 static void java_expand_method_bodies PARAMS ((tree));
388 static int unresolved_type_p PARAMS ((tree, tree *));
389 static void create_jdep_list PARAMS ((struct parser_ctxt *));
390 static tree build_expr_block PARAMS ((tree, tree));
391 static tree enter_block PARAMS ((void));
392 static tree exit_block PARAMS ((void));
393 static tree lookup_name_in_blocks PARAMS ((tree));
394 static void maybe_absorb_scoping_blocks PARAMS ((void));
395 static tree build_method_invocation PARAMS ((tree, tree));
396 static tree build_new_invocation PARAMS ((tree, tree));
397 static tree build_assignment PARAMS ((int, int, tree, tree));
398 static tree build_binop PARAMS ((enum tree_code, int, tree, tree));
399 static tree patch_assignment PARAMS ((tree, tree));
400 static tree patch_binop PARAMS ((tree, tree, tree));
401 static tree build_unaryop PARAMS ((int, int, tree));
402 static tree build_incdec PARAMS ((int, int, tree, int));
403 static tree patch_unaryop PARAMS ((tree, tree));
404 static tree build_cast PARAMS ((int, tree, tree));
405 static tree build_null_of_type PARAMS ((tree));
406 static tree patch_cast PARAMS ((tree, tree));
407 static int valid_ref_assignconv_cast_p PARAMS ((tree, tree, int));
408 static int valid_builtin_assignconv_identity_widening_p PARAMS ((tree, tree));
409 static int valid_cast_to_p PARAMS ((tree, tree));
410 static int valid_method_invocation_conversion_p PARAMS ((tree, tree));
411 static tree try_builtin_assignconv PARAMS ((tree, tree, tree));
412 static tree try_reference_assignconv PARAMS ((tree, tree));
413 static tree build_unresolved_array_type PARAMS ((tree));
414 static int build_type_name_from_array_name PARAMS ((tree, tree *));
415 static tree build_array_from_name PARAMS ((tree, tree, tree, tree *));
416 static tree build_array_ref PARAMS ((int, tree, tree));
417 static tree patch_array_ref PARAMS ((tree));
418 static tree make_qualified_name PARAMS ((tree, tree, int));
419 static tree merge_qualified_name PARAMS ((tree, tree));
420 static tree make_qualified_primary PARAMS ((tree, tree, int));
421 static int resolve_qualified_expression_name PARAMS ((tree, tree *,
422 tree *, tree *));
423 static void qualify_ambiguous_name PARAMS ((tree));
424 static tree resolve_field_access PARAMS ((tree, tree *, tree *));
425 static tree build_newarray_node PARAMS ((tree, tree, int));
426 static tree patch_newarray PARAMS ((tree));
427 static tree resolve_type_during_patch PARAMS ((tree));
428 static tree build_this PARAMS ((int));
429 static tree build_wfl_wrap PARAMS ((tree, int));
430 static tree build_return PARAMS ((int, tree));
431 static tree patch_return PARAMS ((tree));
432 static tree maybe_access_field PARAMS ((tree, tree, tree));
433 static int complete_function_arguments PARAMS ((tree));
434 static int check_for_static_method_reference PARAMS ((tree, tree, tree,
435 tree, tree));
436 static int not_accessible_p PARAMS ((tree, tree, tree, int));
437 static void check_deprecation PARAMS ((tree, tree));
438 static int class_in_current_package PARAMS ((tree));
439 static tree build_if_else_statement PARAMS ((int, tree, tree, tree));
440 static tree patch_if_else_statement PARAMS ((tree));
441 static tree add_stmt_to_compound PARAMS ((tree, tree, tree));
442 static tree add_stmt_to_block PARAMS ((tree, tree, tree));
443 static tree patch_exit_expr PARAMS ((tree));
444 static tree build_labeled_block PARAMS ((int, tree));
445 static tree finish_labeled_statement PARAMS ((tree, tree));
446 static tree build_bc_statement PARAMS ((int, int, tree));
447 static tree patch_bc_statement PARAMS ((tree));
448 static tree patch_loop_statement PARAMS ((tree));
449 static tree build_new_loop PARAMS ((tree));
450 static tree build_loop_body PARAMS ((int, tree, int));
451 static tree finish_loop_body PARAMS ((int, tree, tree, int));
452 static tree build_debugable_stmt PARAMS ((int, tree));
453 static tree finish_for_loop PARAMS ((int, tree, tree, tree));
454 static tree patch_switch_statement PARAMS ((tree));
455 static tree string_constant_concatenation PARAMS ((tree, tree));
456 static tree build_string_concatenation PARAMS ((tree, tree));
457 static tree patch_string_cst PARAMS ((tree));
458 static tree patch_string PARAMS ((tree));
459 static tree encapsulate_with_try_catch PARAMS ((int, tree, tree, tree));
460 static tree build_assertion PARAMS ((int, tree, tree));
461 static tree build_try_statement PARAMS ((int, tree, tree));
462 static tree build_try_finally_statement PARAMS ((int, tree, tree));
463 static tree patch_try_statement PARAMS ((tree));
464 static tree patch_synchronized_statement PARAMS ((tree, tree));
465 static tree patch_throw_statement PARAMS ((tree, tree));
466 static void check_thrown_exceptions PARAMS ((int, tree));
467 static int check_thrown_exceptions_do PARAMS ((tree));
468 static void purge_unchecked_exceptions PARAMS ((tree));
469 static bool ctors_unchecked_throws_clause_p PARAMS ((tree));
470 static void check_throws_clauses PARAMS ((tree, tree, tree));
471 static void finish_method_declaration PARAMS ((tree));
472 static tree build_super_invocation PARAMS ((tree));
473 static int verify_constructor_circularity PARAMS ((tree, tree));
474 static char *constructor_circularity_msg PARAMS ((tree, tree));
475 static tree build_this_super_qualified_invocation PARAMS ((int, tree, tree,
476 int, int));
477 static const char *get_printable_method_name PARAMS ((tree));
478 static tree patch_conditional_expr PARAMS ((tree, tree, tree));
479 static tree generate_finit PARAMS ((tree));
480 static tree generate_instinit PARAMS ((tree));
481 static tree build_instinit_invocation PARAMS ((tree));
482 static void fix_constructors PARAMS ((tree));
483 static tree build_alias_initializer_parameter_list PARAMS ((int, tree,
484 tree, int *));
485 static tree craft_constructor PARAMS ((tree, tree));
486 static int verify_constructor_super PARAMS ((tree));
487 static tree create_artificial_method PARAMS ((tree, int, tree, tree, tree));
488 static void start_artificial_method_body PARAMS ((tree));
489 static void end_artificial_method_body PARAMS ((tree));
490 static int check_method_redefinition PARAMS ((tree, tree));
491 static int check_method_types_complete PARAMS ((tree));
492 static void java_check_regular_methods PARAMS ((tree));
493 static void java_check_abstract_methods PARAMS ((tree));
494 static void unreachable_stmt_error PARAMS ((tree));
495 static tree find_expr_with_wfl PARAMS ((tree));
496 static void missing_return_error PARAMS ((tree));
497 static tree build_new_array_init PARAMS ((int, tree));
498 static tree patch_new_array_init PARAMS ((tree, tree));
499 static tree maybe_build_array_element_wfl PARAMS ((tree));
500 static int array_constructor_check_entry PARAMS ((tree, tree));
501 static const char *purify_type_name PARAMS ((const char *));
502 static tree fold_constant_for_init PARAMS ((tree, tree));
503 static tree strip_out_static_field_access_decl PARAMS ((tree));
504 static jdeplist *reverse_jdep_list PARAMS ((struct parser_ctxt *));
505 static void static_ref_err PARAMS ((tree, tree, tree));
506 static void parser_add_interface PARAMS ((tree, tree, tree));
507 static void add_superinterfaces PARAMS ((tree, tree));
508 static tree jdep_resolve_class PARAMS ((jdep *));
509 static int note_possible_classname PARAMS ((const char *, int));
510 static void java_complete_expand_classes PARAMS ((void));
511 static void java_complete_expand_class PARAMS ((tree));
512 static void java_complete_expand_methods PARAMS ((tree));
513 static tree cut_identifier_in_qualified PARAMS ((tree));
514 static tree java_stabilize_reference PARAMS ((tree));
515 static tree do_unary_numeric_promotion PARAMS ((tree));
516 static char * operator_string PARAMS ((tree));
517 static tree do_merge_string_cste PARAMS ((tree, const char *, int, int));
518 static tree merge_string_cste PARAMS ((tree, tree, int));
519 static tree java_refold PARAMS ((tree));
520 static int java_decl_equiv PARAMS ((tree, tree));
521 static int binop_compound_p PARAMS ((enum tree_code));
522 static tree search_loop PARAMS ((tree));
523 static int labeled_block_contains_loop_p PARAMS ((tree, tree));
524 static int check_abstract_method_definitions PARAMS ((int, tree, tree));
525 static void java_check_abstract_method_definitions PARAMS ((tree));
526 static void java_debug_context_do PARAMS ((int));
527 static void java_parser_context_push_initialized_field PARAMS ((void));
528 static void java_parser_context_pop_initialized_field PARAMS ((void));
529 static tree reorder_static_initialized PARAMS ((tree));
530 static void java_parser_context_suspend PARAMS ((void));
531 static void java_parser_context_resume PARAMS ((void));
532 static int pop_current_osb PARAMS ((struct parser_ctxt *));
533
534 /* JDK 1.1 work. FIXME */
535
536 static tree maybe_make_nested_class_name PARAMS ((tree));
537 static int make_nested_class_name PARAMS ((tree));
538 static void set_nested_class_simple_name_value PARAMS ((tree, int));
539 static void link_nested_class_to_enclosing PARAMS ((void));
540 static tree resolve_inner_class PARAMS ((htab_t, tree, tree *, tree *, tree));
541 static tree find_as_inner_class PARAMS ((tree, tree, tree));
542 static tree find_as_inner_class_do PARAMS ((tree, tree));
543 static int check_inner_class_redefinition PARAMS ((tree, tree));
544
545 static tree build_thisn_assign PARAMS ((void));
546 static tree build_current_thisn PARAMS ((tree));
547 static tree build_access_to_thisn PARAMS ((tree, tree, int));
548 static tree maybe_build_thisn_access_method PARAMS ((tree));
549
550 static tree build_outer_field_access PARAMS ((tree, tree));
551 static tree build_outer_field_access_methods PARAMS ((tree));
552 static tree build_outer_field_access_expr PARAMS ((int, tree, tree,
553 tree, tree));
554 static tree build_outer_method_access_method PARAMS ((tree));
555 static tree build_new_access_id PARAMS ((void));
556 static tree build_outer_field_access_method PARAMS ((tree, tree, tree,
557 tree, tree));
558
559 static int outer_field_access_p PARAMS ((tree, tree));
560 static int outer_field_expanded_access_p PARAMS ((tree, tree *,
561 tree *, tree *));
562 static tree outer_field_access_fix PARAMS ((tree, tree, tree));
563 static tree build_incomplete_class_ref PARAMS ((int, tree));
564 static tree patch_incomplete_class_ref PARAMS ((tree));
565 static tree create_anonymous_class PARAMS ((int, tree));
566 static void patch_anonymous_class PARAMS ((tree, tree, tree));
567 static void add_inner_class_fields PARAMS ((tree, tree));
568
569 static tree build_dot_class_method PARAMS ((tree));
570 static tree build_dot_class_method_invocation PARAMS ((tree));
571 static void create_new_parser_context PARAMS ((int));
572 static void mark_parser_ctxt PARAMS ((void *));
573 static tree maybe_build_class_init_for_field PARAMS ((tree, tree));
574
575 static int attach_init_test_initialization_flags PARAMS ((PTR *, PTR));
576 static int emit_test_initialization PARAMS ((PTR *, PTR));
577
578 static char *string_convert_int_cst PARAMS ((tree));
579
580 /* Number of error found so far. */
581 int java_error_count;
582 /* Number of warning found so far. */
583 int java_warning_count;
584 /* Tell when not to fold, when doing xrefs */
585 int do_not_fold;
586 /* Cyclic inheritance report, as it can be set by layout_class */
587 const char *cyclic_inheritance_report;
588
589 /* The current parser context */
590 struct parser_ctxt *ctxp;
591
592 /* List of things that were analyzed for which code will be generated */
593 struct parser_ctxt *ctxp_for_generation = NULL;
594
595 /* binop_lookup maps token to tree_code. It is used where binary
596 operations are involved and required by the parser. RDIV_EXPR
597 covers both integral/floating point division. The code is changed
598 once the type of both operator is worked out. */
599
600 static const enum tree_code binop_lookup[19] =
601 {
602 PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
603 LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
604 BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
605 TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
606 EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
607 };
608 #define BINOP_LOOKUP(VALUE) \
609 binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
610
611 /* This is the end index for binary operators that can also be used
612 in compound assignements. */
613 #define BINOP_COMPOUND_CANDIDATES 11
614
615 /* The "$L" identifier we use to create labels. */
616 static GTY(()) tree label_id;
617
618 /* The "StringBuffer" identifier used for the String `+' operator. */
619 static GTY(()) tree wfl_string_buffer;
620
621 /* The "append" identifier used for String `+' operator. */
622 static GTY(()) tree wfl_append;
623
624 /* The "toString" identifier used for String `+' operator. */
625 static GTY(()) tree wfl_to_string;
626
627 /* The "java.lang" import qualified name. */
628 static GTY(()) tree java_lang_id;
629
630 /* The generated `inst$' identifier used for generated enclosing
631 instance/field access functions. */
632 static GTY(()) tree inst_id;
633
634 /* Context and flag for static blocks */
635 static GTY(()) tree current_static_block;
636
637 /* The generated `write_parm_value$' identifier. */
638 static GTY(()) tree wpv_id;
639
640 /* The list of all packages we've seen so far */
641 static GTY(()) tree package_list;
642
643 /* Hold THIS for the scope of the current method decl. */
644 static GTY(()) tree current_this;
645
646 /* Hold a list of catch clauses list. The first element of this list is
647 the list of the catch clauses of the currently analysed try block. */
648 static GTY(()) tree currently_caught_type_list;
649
650 /* This holds a linked list of all the case labels for the current
651 switch statement. It is only used when checking to see if there
652 are duplicate labels. FIXME: probably this should just be attached
653 to the switch itself; then it could be referenced via
654 `ctxp->current_loop'. */
655 static GTY(()) tree case_label_list;
656
657 /* Anonymous class counter. Will be reset to 1 every time a non
658 anonymous class gets created. */
659 static int anonymous_class_counter = 1;
660
661 static GTY(()) tree src_parse_roots[1];
662
663 /* All classes seen from source code */
664 #define gclass_list src_parse_roots[0]
665
666 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
667 line and point it out. */
668 /* Should point out the one that don't fit. ASCII/unicode, going
669 backward. FIXME */
670
671 #define check_modifiers(__message, __value, __mask) do { \
672 if ((__value) & ~(__mask)) \
673 { \
674 size_t i, remainder = (__value) & ~(__mask); \
675 for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++) \
676 if ((1 << i) & remainder) \
677 parse_error_context (ctxp->modifier_ctx [i], (__message), \
678 java_accstring_lookup (1 << i)); \
679 } \
680 } while (0)
681
682
683
684 /* Enabling traces. */
685 #ifndef YYDEBUG
686 # define YYDEBUG 1
687 #endif
688
689 /* Enabling verbose error messages. */
690 #ifdef YYERROR_VERBOSE
691 # undef YYERROR_VERBOSE
692 # define YYERROR_VERBOSE 1
693 #else
694 # define YYERROR_VERBOSE 0
695 #endif
696
697 #ifndef YYSTYPE
698 #line 401 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
699 typedef union {
700 tree node;
701 int sub_token;
702 struct {
703 int token;
704 int location;
705 } operator;
706 int value;
707 } yystype;
708 /* Line 193 of /usr/share/bison/yacc.c. */
709 #line 710 "p13913.c"
710 # define YYSTYPE yystype
711 # define YYSTYPE_IS_TRIVIAL 1
712 #endif
713
714 #ifndef YYLTYPE
715 typedef struct yyltype
716 {
717 int first_line;
718 int first_column;
719 int last_line;
720 int last_column;
721 } yyltype;
722 # define YYLTYPE yyltype
723 # define YYLTYPE_IS_TRIVIAL 1
724 #endif
725
726 /* Copy the second part of user declarations. */
727 #line 411 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
728
729 #include "lex.c"
730
731
732 /* Line 213 of /usr/share/bison/yacc.c. */
733 #line 734 "p13913.c"
734
735 #if ! defined (yyoverflow) || YYERROR_VERBOSE
736
737 /* The parser invokes alloca or malloc; define the necessary symbols. */
738
739 # if YYSTACK_USE_ALLOCA
740 # define YYSTACK_ALLOC alloca
741 # else
742 # ifndef YYSTACK_USE_ALLOCA
743 # if defined (alloca) || defined (_ALLOCA_H)
744 # define YYSTACK_ALLOC alloca
745 # else
746 # ifdef __GNUC__
747 # define YYSTACK_ALLOC __builtin_alloca
748 # endif
749 # endif
750 # endif
751 # endif
752
753 # ifdef YYSTACK_ALLOC
754 /* Pacify GCC's `empty if-body' warning. */
755 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
756 # else
757 # if defined (__STDC__) || defined (__cplusplus)
758 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
759 # define YYSIZE_T size_t
760 # endif
761 # define YYSTACK_ALLOC malloc
762 # define YYSTACK_FREE free
763 # endif
764 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
765
766
767 #if (! defined (yyoverflow) \
768 && (! defined (__cplusplus) \
769 || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
770
771 /* A type that is properly aligned for any stack member. */
772 union yyalloc
773 {
774 short yyss;
775 YYSTYPE yyvs;
776 };
777
778 /* The size of the maximum gap between one aligned stack and the next. */
779 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
780
781 /* The size of an array large to enough to hold all stacks, each with
782 N elements. */
783 # define YYSTACK_BYTES(N) \
784 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
785 + YYSTACK_GAP_MAX)
786
787 /* Copy COUNT objects from FROM to TO. The source and destination do
788 not overlap. */
789 # ifndef YYCOPY
790 # if 1 < __GNUC__
791 # define YYCOPY(To, From, Count) \
792 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
793 # else
794 # define YYCOPY(To, From, Count) \
795 do \
796 { \
797 register YYSIZE_T yyi; \
798 for (yyi = 0; yyi < (Count); yyi++) \
799 (To)[yyi] = (From)[yyi]; \
800 } \
801 while (0)
802 # endif
803 # endif
804
805 /* Relocate STACK from its old location to the new one. The
806 local variables YYSIZE and YYSTACKSIZE give the old and new number of
807 elements in the stack, and YYPTR gives the new location of the
808 stack. Advance YYPTR to a properly aligned location for the next
809 stack. */
810 # define YYSTACK_RELOCATE(Stack) \
811 do \
812 { \
813 YYSIZE_T yynewbytes; \
814 YYCOPY (&yyptr->Stack, Stack, yysize); \
815 Stack = &yyptr->Stack; \
816 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \
817 yyptr += yynewbytes / sizeof (*yyptr); \
818 } \
819 while (0)
820
821 #endif
822
823 #if defined (__STDC__) || defined (__cplusplus)
824 typedef signed char yysigned_char;
825 #else
826 typedef short yysigned_char;
827 #endif
828
829 /* YYFINAL -- State number of the termination state. */
830 #define YYFINAL 3
831 #define YYLAST 5787
832
833 /* YYNTOKENS -- Number of terminals. */
834 #define YYNTOKENS 112
835 /* YYNNTS -- Number of nonterminals. */
836 #define YYNNTS 165
837 /* YYNRULES -- Number of rules. */
838 #define YYNRULES 511
839 /* YYNRULES -- Number of states. */
840 #define YYNSTATES 787
841
842 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
843 #define YYUNDEFTOK 2
844 #define YYMAXUTOK 366
845
846 #define YYTRANSLATE(X) \
847 ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK)
848
849 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
850 static const unsigned char yytranslate[] =
851 {
852 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
853 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
854 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
855 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
856 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
857 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
858 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
859 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
860 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
861 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
862 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
863 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
864 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
865 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
866 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
867 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
868 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
869 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
870 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
871 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
872 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
873 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
874 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
875 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
876 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
877 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
878 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
879 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
880 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
881 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
882 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
883 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
884 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
885 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
886 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
887 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
888 105, 106, 107, 108, 109, 110, 111
889 };
890
891 #if YYDEBUG
892 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
893 YYRHS. */
894 static const unsigned short yyprhs[] =
895 {
896 0, 0, 3, 4, 7, 9, 11, 13, 15, 17,
897 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
898 39, 42, 45, 47, 49, 51, 55, 57, 58, 60,
899 62, 64, 67, 70, 73, 77, 79, 82, 84, 87,
900 91, 94, 98, 100, 102, 106, 109, 113, 119, 124,
901 130, 132, 134, 136, 138, 140, 143, 144, 152, 153,
902 160, 164, 167, 171, 176, 177, 180, 184, 187, 188,
903 191, 194, 196, 200, 204, 207, 211, 213, 216, 218,
904 220, 222, 224, 226, 228, 230, 232, 234, 238, 243,
905 245, 249, 253, 255, 259, 263, 268, 270, 274, 277,
906 281, 285, 287, 289, 290, 294, 297, 301, 305, 310,
907 315, 318, 322, 325, 329, 332, 336, 341, 345, 349,
908 353, 355, 359, 363, 366, 370, 373, 377, 379, 380,
909 383, 386, 388, 392, 396, 398, 400, 403, 405, 406,
910 410, 413, 417, 421, 426, 429, 433, 437, 442, 444,
911 449, 455, 463, 470, 472, 474, 475, 480, 481, 487,
912 488, 494, 495, 502, 506, 511, 514, 518, 521, 525,
913 528, 532, 534, 537, 539, 541, 543, 545, 547, 550,
914 553, 556, 560, 564, 569, 571, 575, 579, 582, 586,
915 588, 590, 592, 595, 597, 599, 601, 604, 607, 611,
916 613, 615, 617, 619, 621, 623, 625, 627, 629, 631,
917 633, 635, 637, 639, 641, 643, 645, 647, 649, 651,
918 653, 655, 657, 659, 662, 665, 668, 671, 674, 677,
919 680, 683, 687, 692, 697, 703, 708, 714, 721, 729,
920 736, 738, 740, 742, 744, 746, 748, 750, 756, 759,
921 763, 768, 776, 784, 785, 789, 794, 797, 801, 807,
922 810, 814, 818, 823, 825, 828, 831, 833, 836, 840,
923 843, 846, 850, 853, 858, 861, 864, 868, 873, 876,
924 878, 886, 894, 901, 905, 911, 916, 924, 931, 934,
925 937, 941, 944, 945, 947, 949, 952, 953, 955, 957,
926 961, 965, 968, 972, 975, 979, 982, 986, 989, 993,
927 996, 1000, 1003, 1007, 1011, 1014, 1018, 1024, 1028, 1031,
928 1035, 1041, 1047, 1050, 1055, 1059, 1061, 1065, 1069, 1074,
929 1077, 1079, 1082, 1085, 1090, 1093, 1097, 1102, 1105, 1108,
930 1110, 1112, 1114, 1116, 1120, 1122, 1124, 1126, 1128, 1130,
931 1134, 1138, 1142, 1146, 1150, 1154, 1158, 1162, 1166, 1172,
932 1177, 1179, 1184, 1190, 1196, 1203, 1207, 1211, 1216, 1222,
933 1225, 1229, 1230, 1238, 1239, 1246, 1250, 1254, 1256, 1260,
934 1264, 1268, 1272, 1277, 1282, 1287, 1292, 1296, 1300, 1302,
935 1305, 1309, 1313, 1316, 1319, 1323, 1327, 1331, 1335, 1338,
936 1342, 1347, 1353, 1360, 1366, 1373, 1378, 1383, 1388, 1393,
937 1397, 1402, 1406, 1411, 1413, 1415, 1417, 1419, 1422, 1425,
938 1427, 1429, 1432, 1434, 1437, 1439, 1442, 1445, 1448, 1451,
939 1454, 1457, 1459, 1462, 1465, 1467, 1470, 1473, 1479, 1484,
940 1489, 1495, 1500, 1503, 1509, 1514, 1520, 1522, 1526, 1530,
941 1534, 1538, 1542, 1546, 1548, 1552, 1556, 1560, 1564, 1566,
942 1570, 1574, 1578, 1582, 1586, 1590, 1592, 1596, 1600, 1604,
943 1608, 1612, 1616, 1620, 1624, 1628, 1632, 1634, 1638, 1642,
944 1646, 1650, 1652, 1656, 1660, 1662, 1666, 1670, 1672, 1676,
945 1680, 1682, 1686, 1690, 1692, 1696, 1700, 1702, 1708, 1713,
946 1717, 1723, 1725, 1727, 1731, 1735, 1737, 1739, 1741, 1743,
947 1745, 1747
948 };
949
950 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
951 static const short yyrhs[] =
952 {
953 113, 0, -1, -1, 114, 127, -1, 106, -1, 107,
954 -1, 110, -1, 105, -1, 104, -1, 111, -1, 117,
955 -1, 118, -1, 84, -1, 87, -1, 51, -1, 119,
956 -1, 122, -1, 123, -1, 119, -1, 119, -1, 117,
957 247, -1, 123, 247, -1, 124, -1, 125, -1, 126,
958 -1, 123, 103, 126, -1, 88, -1, -1, 130, -1,
959 128, -1, 129, -1, 130, 128, -1, 130, 129, -1,
960 128, 129, -1, 130, 128, 129, -1, 131, -1, 128,
961 131, -1, 134, -1, 129, 134, -1, 76, 123, 101,
962 -1, 76, 1, -1, 76, 123, 1, -1, 132, -1,
963 133, -1, 56, 123, 101, -1, 56, 1, -1, 56,
964 123, 1, -1, 56, 123, 103, 5, 101, -1, 56,
965 123, 103, 1, -1, 56, 123, 103, 5, 1, -1,
966 136, -1, 171, -1, 194, -1, 1, -1, 45, -1,
967 135, 45, -1, -1, 135, 68, 126, 139, 140, 137,
968 142, -1, -1, 68, 126, 139, 140, 138, 142, -1,
969 135, 68, 1, -1, 68, 1, -1, 68, 126, 1,
970 -1, 135, 68, 126, 1, -1, -1, 64, 120, -1,
971 64, 120, 1, -1, 64, 1, -1, -1, 53, 141,
972 -1, 53, 1, -1, 121, -1, 141, 102, 121, -1,
973 141, 102, 1, -1, 97, 98, -1, 97, 143, 98,
974 -1, 144, -1, 143, 144, -1, 145, -1, 161, -1,
975 163, -1, 184, -1, 146, -1, 151, -1, 136, -1,
976 171, -1, 194, -1, 116, 147, 101, -1, 135, 116,
977 147, 101, -1, 148, -1, 147, 102, 148, -1, 147,
978 102, 1, -1, 149, -1, 149, 94, 150, -1, 149,
979 94, 1, -1, 149, 94, 150, 1, -1, 126, -1,
980 149, 99, 100, -1, 126, 1, -1, 149, 99, 1,
981 -1, 149, 100, 1, -1, 275, -1, 182, -1, -1,
982 153, 152, 160, -1, 153, 1, -1, 116, 154, 158,
983 -1, 60, 154, 158, -1, 135, 116, 154, 158, -1,
984 135, 60, 154, 158, -1, 116, 1, -1, 135, 116,
985 1, -1, 60, 1, -1, 135, 60, 1, -1, 135,
986 1, -1, 126, 95, 96, -1, 126, 95, 155, 96,
987 -1, 154, 99, 100, -1, 126, 95, 1, -1, 154,
988 99, 1, -1, 156, -1, 155, 102, 156, -1, 155,
989 102, 1, -1, 116, 149, -1, 157, 116, 149, -1,
990 116, 1, -1, 157, 116, 1, -1, 135, -1, -1,
991 54, 159, -1, 54, 1, -1, 120, -1, 159, 102,
992 120, -1, 159, 102, 1, -1, 184, -1, 101, -1,
993 162, 184, -1, 135, -1, -1, 165, 164, 167, -1,
994 166, 158, -1, 135, 166, 158, -1, 124, 95, 96,
995 -1, 124, 95, 155, 96, -1, 185, 168, -1, 185,
996 169, 168, -1, 185, 187, 168, -1, 185, 169, 187,
997 168, -1, 186, -1, 170, 95, 96, 101, -1, 170,
998 95, 243, 96, 101, -1, 123, 103, 66, 95, 243,
999 96, 101, -1, 123, 103, 66, 95, 96, 101, -1,
1000 77, -1, 66, -1, -1, 62, 126, 172, 177, -1,
1001 -1, 135, 62, 126, 173, 177, -1, -1, 62, 126,
1002 176, 174, 177, -1, -1, 135, 62, 126, 176, 175,
1003 177, -1, 62, 126, 1, -1, 135, 62, 126, 1,
1004 -1, 64, 121, -1, 176, 102, 121, -1, 64, 1,
1005 -1, 176, 102, 1, -1, 97, 98, -1, 97, 178,
1006 98, -1, 179, -1, 178, 179, -1, 180, -1, 181,
1007 -1, 136, -1, 171, -1, 146, -1, 153, 101, -1,
1008 153, 1, -1, 97, 98, -1, 97, 102, 98, -1,
1009 97, 183, 98, -1, 97, 183, 102, 98, -1, 150,
1010 -1, 183, 102, 150, -1, 183, 102, 1, -1, 97,
1011 98, -1, 185, 187, 186, -1, 97, -1, 98, -1,
1012 188, -1, 187, 188, -1, 189, -1, 191, -1, 136,
1013 -1, 190, 101, -1, 116, 147, -1, 157, 116, 147,
1014 -1, 193, -1, 196, -1, 200, -1, 201, -1, 212,
1015 -1, 216, -1, 193, -1, 197, -1, 202, -1, 213,
1016 -1, 217, -1, 184, -1, 194, -1, 198, -1, 203,
1017 -1, 215, -1, 223, -1, 224, -1, 225, -1, 228,
1018 -1, 226, -1, 230, -1, 227, -1, 101, -1, 126,
1019 90, -1, 195, 191, -1, 126, 1, -1, 195, 192,
1020 -1, 199, 101, -1, 1, 101, -1, 1, 97, -1,
1021 1, 98, -1, 170, 95, 1, -1, 170, 95, 96,
1022 1, -1, 170, 95, 243, 1, -1, 170, 95, 243,
1023 96, 1, -1, 123, 103, 66, 1, -1, 123, 103,
1024 66, 95, 1, -1, 123, 103, 66, 95, 243, 1,
1025 -1, 123, 103, 66, 95, 243, 96, 1, -1, 123,
1026 103, 66, 95, 96, 1, -1, 272, -1, 256, -1,
1027 257, -1, 252, -1, 253, -1, 249, -1, 238, -1,
1028 49, 95, 275, 96, 191, -1, 49, 1, -1, 49,
1029 95, 1, -1, 49, 95, 275, 1, -1, 49, 95,
1030 275, 96, 192, 57, 191, -1, 49, 95, 275, 96,
1031 192, 57, 192, -1, -1, 205, 204, 206, -1, 69,
1032 95, 275, 96, -1, 69, 1, -1, 69, 95, 1,
1033 -1, 69, 95, 275, 96, 1, -1, 97, 98, -1,
1034 97, 209, 98, -1, 97, 207, 98, -1, 97, 207,
1035 209, 98, -1, 208, -1, 207, 208, -1, 209, 187,
1036 -1, 210, -1, 209, 210, -1, 63, 276, 90, -1,
1037 48, 90, -1, 63, 1, -1, 63, 276, 1, -1,
1038 48, 1, -1, 67, 95, 275, 96, -1, 211, 191,
1039 -1, 67, 1, -1, 67, 95, 1, -1, 67, 95,
1040 275, 1, -1, 211, 192, -1, 52, -1, 214, 191,
1041 67, 95, 275, 96, 101, -1, 219, 101, 275, 101,
1042 221, 96, 191, -1, 219, 101, 101, 221, 96, 191,
1043 -1, 219, 101, 1, -1, 219, 101, 275, 101, 1,
1044 -1, 219, 101, 101, 1, -1, 219, 101, 275, 101,
1045 221, 96, 192, -1, 219, 101, 101, 221, 96, 192,
1046 -1, 72, 95, -1, 72, 1, -1, 72, 95, 1,
1047 -1, 218, 220, -1, -1, 222, -1, 190, -1, 222,
1048 1, -1, -1, 222, -1, 199, -1, 222, 102, 199,
1049 -1, 222, 102, 1, -1, 55, 101, -1, 55, 126,
1050 101, -1, 55, 1, -1, 55, 126, 1, -1, 74,
1051 101, -1, 74, 126, 101, -1, 74, 1, -1, 74,
1052 126, 1, -1, 59, 101, -1, 59, 275, 101, -1,
1053 59, 1, -1, 59, 275, 1, -1, 50, 275, 101,
1054 -1, 50, 1, -1, 50, 275, 1, -1, 78, 275,
1055 90, 275, 101, -1, 78, 275, 101, -1, 78, 1,
1056 -1, 78, 275, 1, -1, 229, 95, 275, 96, 184,
1057 -1, 229, 95, 275, 96, 1, -1, 229, 1, -1,
1058 229, 95, 1, 96, -1, 229, 95, 1, -1, 135,
1059 -1, 71, 184, 231, -1, 71, 184, 234, -1, 71,
1060 184, 231, 234, -1, 71, 1, -1, 232, -1, 231,
1061 232, -1, 233, 184, -1, 61, 95, 156, 96, -1,
1062 61, 1, -1, 61, 95, 1, -1, 61, 95, 1,
1063 96, -1, 65, 184, -1, 65, 1, -1, 236, -1,
1064 244, -1, 115, -1, 77, -1, 95, 275, 96, -1,
1065 238, -1, 248, -1, 249, -1, 250, -1, 237, -1,
1066 123, 103, 77, -1, 95, 275, 1, -1, 123, 103,
1067 1, -1, 117, 103, 1, -1, 60, 103, 1, -1,
1068 123, 103, 68, -1, 122, 103, 68, -1, 117, 103,
1069 68, -1, 60, 103, 68, -1, 73, 120, 95, 243,
1070 96, -1, 73, 120, 95, 96, -1, 239, -1, 242,
1071 126, 95, 96, -1, 242, 126, 95, 96, 142, -1,
1072 242, 126, 95, 243, 96, -1, 242, 126, 95, 243,
1073 96, 142, -1, 73, 1, 101, -1, 73, 120, 1,
1074 -1, 73, 120, 95, 1, -1, 73, 120, 95, 243,
1075 1, -1, 242, 1, -1, 242, 126, 1, -1, -1,
1076 73, 120, 95, 243, 96, 240, 142, -1, -1, 73,
1077 120, 95, 96, 241, 142, -1, 123, 103, 73, -1,
1078 235, 103, 73, -1, 275, -1, 243, 102, 275, -1,
1079 243, 102, 1, -1, 73, 117, 245, -1, 73, 119,
1080 245, -1, 73, 117, 245, 247, -1, 73, 119, 245,
1081 247, -1, 73, 119, 247, 182, -1, 73, 117, 247,
1082 182, -1, 73, 1, 100, -1, 73, 1, 99, -1,
1083 246, -1, 245, 246, -1, 99, 275, 100, -1, 99,
1084 275, 1, -1, 99, 1, -1, 99, 100, -1, 247,
1085 99, 100, -1, 247, 99, 1, -1, 235, 103, 126,
1086 -1, 66, 103, 126, -1, 66, 1, -1, 123, 95,
1087 96, -1, 123, 95, 243, 96, -1, 235, 103, 126,
1088 95, 96, -1, 235, 103, 126, 95, 243, 96, -1,
1089 66, 103, 126, 95, 96, -1, 66, 103, 126, 95,
1090 243, 96, -1, 66, 103, 1, 96, -1, 66, 103,
1091 1, 103, -1, 123, 99, 275, 100, -1, 236, 99,
1092 275, 100, -1, 123, 99, 1, -1, 123, 99, 275,
1093 1, -1, 236, 99, 1, -1, 236, 99, 275, 1,
1094 -1, 235, -1, 123, -1, 252, -1, 253, -1, 251,
1095 47, -1, 251, 46, -1, 256, -1, 257, -1, 3,
1096 255, -1, 258, -1, 3, 1, -1, 254, -1, 4,
1097 254, -1, 4, 1, -1, 47, 255, -1, 47, 1,
1098 -1, 46, 255, -1, 46, 1, -1, 251, -1, 91,
1099 255, -1, 92, 255, -1, 259, -1, 91, 1, -1,
1100 92, 1, -1, 95, 117, 247, 96, 255, -1, 95,
1101 117, 96, 255, -1, 95, 275, 96, 258, -1, 95,
1102 123, 247, 96, 258, -1, 95, 117, 99, 1, -1,
1103 95, 1, -1, 95, 117, 247, 96, 1, -1, 95,
1104 117, 96, 1, -1, 95, 123, 247, 96, 1, -1,
1105 255, -1, 260, 5, 255, -1, 260, 6, 255, -1,
1106 260, 7, 255, -1, 260, 5, 1, -1, 260, 6,
1107 1, -1, 260, 7, 1, -1, 260, -1, 261, 3,
1108 260, -1, 261, 4, 260, -1, 261, 3, 1, -1,
1109 261, 4, 1, -1, 261, -1, 262, 8, 261, -1,
1110 262, 9, 261, -1, 262, 10, 261, -1, 262, 8,
1111 1, -1, 262, 9, 1, -1, 262, 10, 1, -1,
1112 262, -1, 263, 20, 262, -1, 263, 18, 262, -1,
1113 263, 21, 262, -1, 263, 19, 262, -1, 263, 58,
1114 118, -1, 263, 20, 1, -1, 263, 18, 1, -1,
1115 263, 21, 1, -1, 263, 19, 1, -1, 263, 58,
1116 1, -1, 263, -1, 264, 16, 263, -1, 264, 17,
1117 263, -1, 264, 16, 1, -1, 264, 17, 1, -1,
1118 264, -1, 265, 11, 264, -1, 265, 11, 1, -1,
1119 265, -1, 266, 12, 265, -1, 266, 12, 1, -1,
1120 266, -1, 267, 13, 266, -1, 267, 13, 1, -1,
1121 267, -1, 268, 14, 267, -1, 268, 14, 1, -1,
1122 268, -1, 269, 15, 268, -1, 269, 15, 1, -1,
1123 269, -1, 269, 89, 275, 90, 270, -1, 269, 89,
1124 90, 1, -1, 269, 89, 1, -1, 269, 89, 275,
1125 90, 1, -1, 270, -1, 272, -1, 273, 274, 271,
1126 -1, 273, 274, 1, -1, 123, -1, 248, -1, 250,
1127 -1, 93, -1, 94, -1, 271, -1, 275, -1
1128 };
1129
1130 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1131 static const unsigned short yyrline[] =
1132 {
1133 0, 562, 562, 561, 577, 579, 580, 581, 582, 583,
1134 587, 589, 592, 594, 595, 598, 600, 603, 607, 611,
1135 615, 624, 635, 637, 640, 644, 649, 654, 656, 657,
1136 658, 659, 660, 661, 662, 665, 670, 676, 678, 681,
1137 687, 689, 693, 695, 698, 725, 727, 731, 750, 752,
1138 756, 759, 761, 762, 770, 775, 792, 790, 796, 795,
1139 799, 801, 803, 808, 812, 814, 816, 818, 822, 824,
1140 826, 833, 839, 844, 848, 857, 867, 869, 872, 874,
1141 875, 876, 886, 888, 889, 891, 893, 897, 900, 910,
1142 913, 915, 919, 922, 929, 935, 943, 945, 947, 949,
1143 954, 958, 960, 966, 964, 976, 980, 983, 985, 987,
1144 989, 994, 999, 1004, 1009, 1016, 1022, 1024, 1033, 1035,
1145 1039, 1044, 1049, 1053, 1058, 1063, 1068, 1075, 1085, 1087,
1146 1089, 1093, 1096, 1098, 1102, 1104, 1108, 1117, 1135, 1133,
1147 1143, 1146, 1150, 1156, 1160, 1167, 1169, 1171, 1175, 1180,
1148 1187, 1194, 1196, 1200, 1207, 1219, 1217, 1223, 1222, 1227,
1149 1226, 1231, 1230, 1234, 1236, 1240, 1246, 1251, 1253, 1257,
1150 1260, 1264, 1266, 1269, 1271, 1272, 1274, 1278, 1282, 1288,
1151 1293, 1296, 1298, 1300, 1304, 1310, 1314, 1319, 1328, 1332,
1152 1337, 1351, 1353, 1356, 1358, 1360, 1367, 1371, 1374, 1378,
1153 1380, 1381, 1382, 1383, 1384, 1388, 1390, 1391, 1392, 1393,
1154 1397, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407,
1155 1408, 1409, 1412, 1430, 1441, 1444, 1448, 1454, 1464, 1469,
1156 1474, 1479, 1481, 1486, 1488, 1493, 1495, 1497, 1499, 1501,
1157 1505, 1507, 1508, 1509, 1510, 1511, 1512, 1515, 1521, 1523,
1158 1525, 1529, 1534, 1541, 1539, 1555, 1561, 1563, 1565, 1571,
1159 1574, 1576, 1578, 1582, 1584, 1587, 1591, 1593, 1596, 1603,
1160 1609, 1611, 1613, 1617, 1625, 1628, 1630, 1632, 1636, 1641,
1161 1650, 1655, 1662, 1669, 1671, 1673, 1677, 1680, 1689, 1696,
1162 1698, 1702, 1715, 1717, 1723, 1729, 1733, 1735, 1739, 1742,
1163 1744, 1748, 1751, 1753, 1755, 1759, 1762, 1764, 1766, 1770,
1164 1773, 1775, 1777, 1781, 1787, 1789, 1793, 1798, 1802, 1804,
1165 1808, 1815, 1817, 1819, 1821, 1825, 1837, 1840, 1842, 1847,
1166 1851, 1853, 1860, 1869, 1886, 1888, 1893, 1897, 1900, 1905,
1167 1907, 1910, 1912, 1914, 1916, 1917, 1918, 1919, 1920, 1922,
1168 1927, 1929, 1931, 1933, 1937, 1940, 1942, 1944, 1951, 1954,
1169 1956, 1958, 1964, 1965, 1971, 1972, 1974, 1976, 1978, 1980,
1170 1982, 1990, 1988, 2023, 2022, 2039, 2042, 2046, 2052, 2057,
1171 2061, 2064, 2066, 2068, 2071, 2082, 2091, 2093, 2097, 2100,
1172 2104, 2115, 2117, 2125, 2152, 2154, 2158, 2162, 2168, 2172,
1173 2175, 2177, 2188, 2199, 2204, 2210, 2212, 2216, 2219, 2221,
1174 2226, 2231, 2236, 2243, 2245, 2246, 2247, 2250, 2255, 2260,
1175 2262, 2263, 2265, 2266, 2270, 2276, 2278, 2282, 2285, 2289,
1176 2292, 2296, 2298, 2300, 2302, 2303, 2305, 2309, 2318, 2320,
1177 2322, 2336, 2338, 2343, 2345, 2347, 2351, 2353, 2358, 2363,
1178 2368, 2370, 2372, 2376, 2378, 2383, 2388, 2390, 2394, 2396,
1179 2401, 2406, 2411, 2413, 2415, 2419, 2421, 2426, 2431, 2436,
1180 2441, 2443, 2445, 2447, 2449, 2451, 2455, 2457, 2462, 2467,
1181 2469, 2473, 2475, 2480, 2484, 2486, 2491, 2495, 2497, 2502,
1182 2506, 2508, 2513, 2517, 2519, 2524, 2528, 2530, 2535, 2541,
1183 2543, 2547, 2549, 2552, 2555, 2562, 2564, 2565, 2568, 2570,
1184 2573, 2577
1185 };
1186 #endif
1187
1188 #if YYDEBUG || YYERROR_VERBOSE
1189 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1190 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1191 static const char *const yytname[] =
1192 {
1193 "$end", "error", "$undefined", "PLUS_TK", "MINUS_TK", "MULT_TK", "DIV_TK",
1194 "REM_TK", "LS_TK", "SRS_TK", "ZRS_TK", "AND_TK", "XOR_TK", "OR_TK",
1195 "BOOL_AND_TK", "BOOL_OR_TK", "EQ_TK", "NEQ_TK", "GT_TK", "GTE_TK",
1196 "LT_TK", "LTE_TK", "PLUS_ASSIGN_TK", "MINUS_ASSIGN_TK",
1197 "MULT_ASSIGN_TK", "DIV_ASSIGN_TK", "REM_ASSIGN_TK", "LS_ASSIGN_TK",
1198 "SRS_ASSIGN_TK", "ZRS_ASSIGN_TK", "AND_ASSIGN_TK", "XOR_ASSIGN_TK",
1199 "OR_ASSIGN_TK", "PUBLIC_TK", "PRIVATE_TK", "PROTECTED_TK", "STATIC_TK",
1200 "FINAL_TK", "SYNCHRONIZED_TK", "VOLATILE_TK", "TRANSIENT_TK",
1201 "NATIVE_TK", "PAD_TK", "ABSTRACT_TK", "STRICT_TK", "MODIFIER_TK",
1202 "DECR_TK", "INCR_TK", "DEFAULT_TK", "IF_TK", "THROW_TK", "BOOLEAN_TK",
1203 "DO_TK", "IMPLEMENTS_TK", "THROWS_TK", "BREAK_TK", "IMPORT_TK",
1204 "ELSE_TK", "INSTANCEOF_TK", "RETURN_TK", "VOID_TK", "CATCH_TK",
1205 "INTERFACE_TK", "CASE_TK", "EXTENDS_TK", "FINALLY_TK", "SUPER_TK",
1206 "WHILE_TK", "CLASS_TK", "SWITCH_TK", "CONST_TK", "TRY_TK", "FOR_TK",
1207 "NEW_TK", "CONTINUE_TK", "GOTO_TK", "PACKAGE_TK", "THIS_TK",
1208 "ASSERT_TK", "BYTE_TK", "SHORT_TK", "INT_TK", "LONG_TK", "CHAR_TK",
1209 "INTEGRAL_TK", "FLOAT_TK", "DOUBLE_TK", "FP_TK", "ID_TK", "REL_QM_TK",
1210 "REL_CL_TK", "NOT_TK", "NEG_TK", "ASSIGN_ANY_TK", "ASSIGN_TK", "OP_TK",
1211 "CP_TK", "OCB_TK", "CCB_TK", "OSB_TK", "CSB_TK", "SC_TK", "C_TK",
1212 "DOT_TK", "STRING_LIT_TK", "CHAR_LIT_TK", "INT_LIT_TK", "FP_LIT_TK",
1213 "TRUE_TK", "FALSE_TK", "BOOL_LIT_TK", "NULL_TK", "$accept", "goal",
1214 "@1", "literal", "type", "primitive_type", "reference_type",
1215 "class_or_interface_type", "class_type", "interface_type", "array_type",
1216 "name", "simple_name", "qualified_name", "identifier",
1217 "compilation_unit", "import_declarations", "type_declarations",
1218 "package_declaration", "import_declaration",
1219 "single_type_import_declaration", "type_import_on_demand_declaration",
1220 "type_declaration", "modifiers", "class_declaration", "@2", "@3",
1221 "super", "interfaces", "interface_type_list", "class_body",
1222 "class_body_declarations", "class_body_declaration",
1223 "class_member_declaration", "field_declaration", "variable_declarators",
1224 "variable_declarator", "variable_declarator_id", "variable_initializer",
1225 "method_declaration", "@4", "method_header", "method_declarator",
1226 "formal_parameter_list", "formal_parameter", "final", "throws",
1227 "class_type_list", "method_body", "static_initializer", "static",
1228 "constructor_declaration", "@5", "constructor_header",
1229 "constructor_declarator", "constructor_body", "constructor_block_end",
1230 "explicit_constructor_invocation", "this_or_super",
1231 "interface_declaration", "@6", "@7", "@8", "@9", "extends_interfaces",
1232 "interface_body", "interface_member_declarations",
1233 "interface_member_declaration", "constant_declaration",
1234 "abstract_method_declaration", "array_initializer",
1235 "variable_initializers", "block", "block_begin", "block_end",
1236 "block_statements", "block_statement",
1237 "local_variable_declaration_statement", "local_variable_declaration",
1238 "statement", "statement_nsi", "statement_without_trailing_substatement",
1239 "empty_statement", "label_decl", "labeled_statement",
1240 "labeled_statement_nsi", "expression_statement", "statement_expression",
1241 "if_then_statement", "if_then_else_statement",
1242 "if_then_else_statement_nsi", "switch_statement", "@10",
1243 "switch_expression", "switch_block", "switch_block_statement_groups",
1244 "switch_block_statement_group", "switch_labels", "switch_label",
1245 "while_expression", "while_statement", "while_statement_nsi",
1246 "do_statement_begin", "do_statement", "for_statement",
1247 "for_statement_nsi", "for_header", "for_begin", "for_init",
1248 "for_update", "statement_expression_list", "break_statement",
1249 "continue_statement", "return_statement", "throw_statement",
1250 "assert_statement", "synchronized_statement", "synchronized",
1251 "try_statement", "catches", "catch_clause", "catch_clause_parameter",
1252 "finally", "primary", "primary_no_new_array", "type_literals",
1253 "class_instance_creation_expression", "anonymous_class_creation", "@11",
1254 "@12", "something_dot_new", "argument_list",
1255 "array_creation_expression", "dim_exprs", "dim_expr", "dims",
1256 "field_access", "method_invocation", "array_access",
1257 "postfix_expression", "post_increment_expression",
1258 "post_decrement_expression", "trap_overflow_corner_case",
1259 "unary_expression", "pre_increment_expression",
1260 "pre_decrement_expression", "unary_expression_not_plus_minus",
1261 "cast_expression", "multiplicative_expression", "additive_expression",
1262 "shift_expression", "relational_expression", "equality_expression",
1263 "and_expression", "exclusive_or_expression", "inclusive_or_expression",
1264 "conditional_and_expression", "conditional_or_expression",
1265 "conditional_expression", "assignment_expression", "assignment",
1266 "left_hand_side", "assignment_operator", "expression",
1267 "constant_expression", 0
1268 };
1269 #endif
1270
1271 # ifdef YYPRINT
1272 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1273 token YYLEX-NUM. */
1274 static const unsigned short yytoknum[] =
1275 {
1276 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1277 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1278 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1279 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1280 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1281 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1282 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1283 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1284 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1285 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1286 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
1287 365, 366
1288 };
1289 # endif
1290
1291 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1292 static const unsigned short yyr1[] =
1293 {
1294 0, 112, 114, 113, 115, 115, 115, 115, 115, 115,
1295 116, 116, 117, 117, 117, 118, 118, 119, 120, 121,
1296 122, 122, 123, 123, 124, 125, 126, 127, 127, 127,
1297 127, 127, 127, 127, 127, 128, 128, 129, 129, 130,
1298 130, 130, 131, 131, 132, 132, 132, 133, 133, 133,
1299 134, 134, 134, 134, 135, 135, 137, 136, 138, 136,
1300 136, 136, 136, 136, 139, 139, 139, 139, 140, 140,
1301 140, 141, 141, 141, 142, 142, 143, 143, 144, 144,
1302 144, 144, 145, 145, 145, 145, 145, 146, 146, 147,
1303 147, 147, 148, 148, 148, 148, 149, 149, 149, 149,
1304 149, 150, 150, 152, 151, 151, 153, 153, 153, 153,
1305 153, 153, 153, 153, 153, 154, 154, 154, 154, 154,
1306 155, 155, 155, 156, 156, 156, 156, 157, 158, 158,
1307 158, 159, 159, 159, 160, 160, 161, 162, 164, 163,
1308 165, 165, 166, 166, 167, 167, 167, 167, 168, 169,
1309 169, 169, 169, 170, 170, 172, 171, 173, 171, 174,
1310 171, 175, 171, 171, 171, 176, 176, 176, 176, 177,
1311 177, 178, 178, 179, 179, 179, 179, 180, 181, 181,
1312 182, 182, 182, 182, 183, 183, 183, 184, 184, 185,
1313 186, 187, 187, 188, 188, 188, 189, 190, 190, 191,
1314 191, 191, 191, 191, 191, 192, 192, 192, 192, 192,
1315 193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
1316 193, 193, 194, 195, 196, 196, 197, 198, 198, 198,
1317 198, 198, 198, 198, 198, 198, 198, 198, 198, 198,
1318 199, 199, 199, 199, 199, 199, 199, 200, 200, 200,
1319 200, 201, 202, 204, 203, 205, 205, 205, 205, 206,
1320 206, 206, 206, 207, 207, 208, 209, 209, 210, 210,
1321 210, 210, 210, 211, 212, 212, 212, 212, 213, 214,
1322 215, 216, 216, 216, 216, 216, 217, 217, 218, 218,
1323 218, 219, 220, 220, 220, 220, 221, 221, 222, 222,
1324 222, 223, 223, 223, 223, 224, 224, 224, 224, 225,
1325 225, 225, 225, 226, 226, 226, 227, 227, 227, 227,
1326 228, 228, 228, 228, 228, 229, 230, 230, 230, 230,
1327 231, 231, 232, 233, 233, 233, 233, 234, 234, 235,
1328 235, 236, 236, 236, 236, 236, 236, 236, 236, 236,
1329 236, 236, 236, 236, 237, 237, 237, 237, 238, 238,
1330 238, 238, 238, 238, 238, 238, 238, 238, 238, 238,
1331 238, 240, 239, 241, 239, 242, 242, 243, 243, 243,
1332 244, 244, 244, 244, 244, 244, 244, 244, 245, 245,
1333 246, 246, 246, 247, 247, 247, 248, 248, 248, 249,
1334 249, 249, 249, 249, 249, 249, 249, 250, 250, 250,
1335 250, 250, 250, 251, 251, 251, 251, 252, 253, 254,
1336 254, 254, 254, 254, 255, 255, 255, 256, 256, 257,
1337 257, 258, 258, 258, 258, 258, 258, 259, 259, 259,
1338 259, 259, 259, 259, 259, 259, 260, 260, 260, 260,
1339 260, 260, 260, 261, 261, 261, 261, 261, 262, 262,
1340 262, 262, 262, 262, 262, 263, 263, 263, 263, 263,
1341 263, 263, 263, 263, 263, 263, 264, 264, 264, 264,
1342 264, 265, 265, 265, 266, 266, 266, 267, 267, 267,
1343 268, 268, 268, 269, 269, 269, 270, 270, 270, 270,
1344 270, 271, 271, 272, 272, 273, 273, 273, 274, 274,
1345 275, 276
1346 };
1347
1348 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1349 static const unsigned char yyr2[] =
1350 {
1351 0, 2, 0, 2, 1, 1, 1, 1, 1, 1,
1352 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1353 2, 2, 1, 1, 1, 3, 1, 0, 1, 1,
1354 1, 2, 2, 2, 3, 1, 2, 1, 2, 3,
1355 2, 3, 1, 1, 3, 2, 3, 5, 4, 5,
1356 1, 1, 1, 1, 1, 2, 0, 7, 0, 6,
1357 3, 2, 3, 4, 0, 2, 3, 2, 0, 2,
1358 2, 1, 3, 3, 2, 3, 1, 2, 1, 1,
1359 1, 1, 1, 1, 1, 1, 1, 3, 4, 1,
1360 3, 3, 1, 3, 3, 4, 1, 3, 2, 3,
1361 3, 1, 1, 0, 3, 2, 3, 3, 4, 4,
1362 2, 3, 2, 3, 2, 3, 4, 3, 3, 3,
1363 1, 3, 3, 2, 3, 2, 3, 1, 0, 2,
1364 2, 1, 3, 3, 1, 1, 2, 1, 0, 3,
1365 2, 3, 3, 4, 2, 3, 3, 4, 1, 4,
1366 5, 7, 6, 1, 1, 0, 4, 0, 5, 0,
1367 5, 0, 6, 3, 4, 2, 3, 2, 3, 2,
1368 3, 1, 2, 1, 1, 1, 1, 1, 2, 2,
1369 2, 3, 3, 4, 1, 3, 3, 2, 3, 1,
1370 1, 1, 2, 1, 1, 1, 2, 2, 3, 1,
1371 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1372 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1373 1, 1, 1, 2, 2, 2, 2, 2, 2, 2,
1374 2, 3, 4, 4, 5, 4, 5, 6, 7, 6,
1375 1, 1, 1, 1, 1, 1, 1, 5, 2, 3,
1376 4, 7, 7, 0, 3, 4, 2, 3, 5, 2,
1377 3, 3, 4, 1, 2, 2, 1, 2, 3, 2,
1378 2, 3, 2, 4, 2, 2, 3, 4, 2, 1,
1379 7, 7, 6, 3, 5, 4, 7, 6, 2, 2,
1380 3, 2, 0, 1, 1, 2, 0, 1, 1, 3,
1381 3, 2, 3, 2, 3, 2, 3, 2, 3, 2,
1382 3, 2, 3, 3, 2, 3, 5, 3, 2, 3,
1383 5, 5, 2, 4, 3, 1, 3, 3, 4, 2,
1384 1, 2, 2, 4, 2, 3, 4, 2, 2, 1,
1385 1, 1, 1, 3, 1, 1, 1, 1, 1, 3,
1386 3, 3, 3, 3, 3, 3, 3, 3, 5, 4,
1387 1, 4, 5, 5, 6, 3, 3, 4, 5, 2,
1388 3, 0, 7, 0, 6, 3, 3, 1, 3, 3,
1389 3, 3, 4, 4, 4, 4, 3, 3, 1, 2,
1390 3, 3, 2, 2, 3, 3, 3, 3, 2, 3,
1391 4, 5, 6, 5, 6, 4, 4, 4, 4, 3,
1392 4, 3, 4, 1, 1, 1, 1, 2, 2, 1,
1393 1, 2, 1, 2, 1, 2, 2, 2, 2, 2,
1394 2, 1, 2, 2, 1, 2, 2, 5, 4, 4,
1395 5, 4, 2, 5, 4, 5, 1, 3, 3, 3,
1396 3, 3, 3, 1, 3, 3, 3, 3, 1, 3,
1397 3, 3, 3, 3, 3, 1, 3, 3, 3, 3,
1398 3, 3, 3, 3, 3, 3, 1, 3, 3, 3,
1399 3, 1, 3, 3, 1, 3, 3, 1, 3, 3,
1400 1, 3, 3, 1, 3, 3, 1, 5, 4, 3,
1401 5, 1, 1, 3, 3, 1, 1, 1, 1, 1,
1402 1, 1
1403 };
1404
1405 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1406 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
1407 means the default is an error. */
1408 static const unsigned short yydefact[] =
1409 {
1410 2, 0, 0, 1, 53, 54, 0, 0, 0, 0,
1411 222, 3, 0, 0, 0, 35, 42, 43, 37, 0,
1412 50, 51, 52, 45, 26, 0, 22, 23, 24, 0,
1413 61, 0, 40, 0, 0, 36, 38, 0, 0, 55,
1414 0, 0, 46, 44, 0, 163, 0, 0, 159, 62,
1415 0, 68, 41, 39, 0, 0, 0, 60, 0, 48,
1416 0, 25, 167, 19, 165, 17, 0, 156, 0, 0,
1417 67, 18, 0, 0, 58, 164, 0, 161, 63, 68,
1418 49, 47, 14, 0, 12, 13, 169, 0, 10, 11,
1419 15, 16, 17, 0, 175, 177, 0, 176, 0, 171,
1420 173, 174, 168, 166, 160, 66, 70, 71, 69, 0,
1421 158, 0, 56, 112, 0, 128, 110, 0, 0, 89,
1422 92, 128, 0, 20, 21, 114, 0, 0, 179, 178,
1423 170, 172, 0, 0, 59, 162, 0, 0, 0, 0,
1424 107, 98, 87, 0, 0, 0, 0, 106, 393, 0,
1425 113, 128, 111, 0, 128, 73, 72, 189, 74, 22,
1426 0, 84, 0, 76, 78, 82, 83, 0, 79, 0,
1427 80, 138, 128, 85, 81, 0, 86, 57, 118, 115,
1428 0, 127, 0, 120, 0, 130, 131, 129, 119, 117,
1429 91, 0, 90, 94, 0, 0, 0, 0, 0, 0,
1430 0, 342, 0, 0, 0, 0, 8, 7, 4, 5,
1431 6, 9, 341, 0, 0, 414, 0, 102, 413, 339,
1432 348, 344, 360, 0, 340, 345, 346, 347, 431, 415,
1433 416, 424, 446, 419, 420, 422, 434, 453, 458, 465,
1434 476, 481, 484, 487, 490, 493, 496, 501, 510, 502,
1435 0, 101, 99, 97, 100, 395, 394, 109, 88, 108,
1436 187, 0, 128, 75, 77, 105, 0, 136, 0, 140,
1437 0, 0, 0, 279, 0, 0, 0, 0, 0, 0,
1438 0, 0, 342, 0, 0, 0, 10, 16, 414, 0,
1439 127, 195, 0, 0, 210, 0, 191, 193, 0, 194,
1440 199, 211, 0, 200, 212, 0, 201, 202, 213, 253,
1441 0, 203, 0, 214, 204, 292, 0, 215, 216, 217,
1442 219, 221, 218, 0, 220, 246, 245, 0, 243, 244,
1443 241, 242, 240, 125, 123, 116, 0, 0, 0, 423,
1444 414, 345, 347, 421, 426, 425, 430, 429, 428, 427,
1445 0, 398, 0, 0, 0, 18, 0, 435, 432, 436,
1446 433, 442, 0, 414, 0, 180, 0, 184, 0, 0,
1447 0, 0, 0, 0, 95, 0, 0, 369, 0, 418,
1448 417, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1449 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1450 0, 0, 508, 509, 0, 142, 0, 141, 135, 104,
1451 134, 189, 139, 0, 229, 230, 228, 248, 0, 314,
1452 0, 303, 301, 0, 311, 309, 0, 275, 0, 256,
1453 0, 329, 0, 289, 0, 307, 305, 0, 318, 0,
1454 0, 197, 0, 225, 223, 0, 0, 190, 188, 192,
1455 196, 414, 325, 224, 227, 0, 274, 0, 414, 294,
1456 298, 291, 0, 0, 322, 0, 122, 121, 126, 124,
1457 133, 132, 353, 357, 0, 397, 387, 386, 365, 0,
1458 380, 388, 0, 381, 0, 366, 0, 0, 0, 20,
1459 21, 350, 343, 181, 182, 0, 352, 356, 355, 399,
1460 0, 377, 409, 0, 351, 354, 375, 349, 376, 396,
1461 411, 0, 370, 0, 450, 447, 451, 448, 452, 449,
1462 456, 454, 457, 455, 462, 459, 463, 460, 464, 461,
1463 472, 467, 474, 469, 471, 466, 473, 468, 475, 0,
1464 470, 479, 477, 480, 478, 483, 482, 486, 485, 489,
1465 488, 492, 491, 495, 494, 499, 0, 0, 504, 503,
1466 143, 414, 144, 0, 0, 148, 0, 249, 0, 315,
1467 313, 304, 302, 312, 310, 276, 0, 257, 0, 0,
1468 0, 326, 330, 0, 327, 290, 308, 306, 319, 0,
1469 317, 343, 0, 198, 231, 0, 0, 0, 254, 0,
1470 295, 0, 283, 0, 0, 324, 0, 405, 406, 0,
1471 392, 0, 389, 382, 385, 383, 384, 367, 359, 0,
1472 444, 438, 441, 0, 0, 439, 186, 183, 185, 400,
1473 0, 410, 407, 0, 412, 408, 361, 0, 498, 0,
1474 0, 145, 0, 0, 146, 250, 0, 277, 273, 0,
1475 334, 0, 338, 337, 331, 328, 332, 0, 235, 0,
1476 232, 233, 0, 0, 0, 259, 0, 263, 0, 266,
1477 0, 300, 299, 285, 0, 297, 0, 323, 0, 403,
1478 0, 391, 390, 0, 368, 358, 443, 437, 445, 440,
1479 379, 378, 401, 0, 362, 363, 500, 497, 0, 147,
1480 0, 0, 0, 247, 0, 199, 0, 206, 207, 0,
1481 208, 209, 0, 258, 335, 0, 316, 236, 0, 0,
1482 234, 272, 269, 270, 511, 0, 261, 264, 0, 260,
1483 0, 267, 0, 0, 284, 0, 321, 320, 404, 374,
1484 0, 402, 364, 0, 149, 0, 0, 0, 226, 278,
1485 0, 336, 333, 239, 237, 0, 271, 268, 262, 0,
1486 282, 0, 372, 0, 0, 150, 0, 251, 0, 0,
1487 238, 280, 281, 152, 0, 0, 0, 0, 151, 0,
1488 0, 0, 0, 287, 0, 252, 286
1489 };
1490
1491 /* YYDEFGOTO[NTERM-NUM]. */
1492 static const short yydefgoto[] =
1493 {
1494 -1, 1, 2, 212, 285, 213, 89, 90, 72, 64,
1495 214, 215, 26, 27, 28, 11, 12, 13, 14, 15,
1496 16, 17, 18, 452, 291, 136, 109, 51, 74, 108,
1497 134, 162, 163, 164, 95, 118, 119, 120, 216, 166,
1498 266, 96, 115, 182, 183, 292, 140, 187, 409, 168,
1499 169, 170, 268, 171, 172, 412, 562, 563, 293, 21,
1500 47, 76, 69, 111, 48, 67, 98, 99, 100, 101,
1501 217, 368, 294, 175, 565, 730, 296, 297, 298, 299,
1502 704, 300, 301, 302, 303, 707, 304, 305, 306, 307,
1503 708, 308, 455, 309, 598, 666, 667, 668, 669, 310,
1504 311, 710, 312, 313, 314, 711, 315, 316, 461, 674,
1505 675, 317, 318, 319, 320, 321, 322, 323, 324, 581,
1506 582, 583, 584, 218, 219, 220, 221, 222, 740, 683,
1507 223, 500, 224, 480, 481, 124, 225, 226, 227, 228,
1508 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
1509 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
1510 249, 250, 404, 501, 725
1511 };
1512
1513 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1514 STATE-NUM. */
1515 #define YYPACT_NINF -630
1516 static const short yypact[] =
1517 {
1518 -630, 57, 108, -630, -630, -630, 411, -9, 471, 482,
1519 -630, -630, 518, 627, 576, -630, -630, -630, -630, 493,
1520 -630, -630, -630, -630, -630, 20, -630, -630, -630, 338,
1521 -630, 307, -630, 27, 692, -630, -630, 614, 757, -630,
1522 -9, 553, -630, -630, 25, -630, 563, 4, 122, -630,
1523 568, 210, -630, -630, -9, 782, 399, -630, 397, -630,
1524 40, -630, -630, -630, -630, 151, 1250, -630, 572, 4,
1525 -630, -630, 355, 596, -630, -630, 4, 122, -630, 210,
1526 -630, -630, -630, 597, -630, -630, -630, 598, 195, -630,
1527 -630, -630, -19, 975, -630, -630, 54, -630, 1302, -630,
1528 -630, -630, -630, -630, -630, -630, -630, -630, 264, 256,
1529 -630, 4, -630, -630, 316, -22, -630, 118, 131, -630,
1530 191, -22, 301, 319, 319, -630, 603, 622, -630, -630,
1531 -630, -630, 638, 1032, -630, -630, 256, 610, 663, 17,
1532 -630, -630, -630, 673, 2245, 110, 424, -630, -630, 150,
1533 -630, -22, -630, 182, -22, -630, -630, 360, -630, 376,
1534 864, -630, 1076, -630, -630, -630, -630, 47, -630, 392,
1535 -630, -630, 448, -630, -630, 1965, -630, -630, -630, -630,
1536 677, 490, 259, -630, 721, -630, -630, 438, -630, -630,
1537 -630, 157, -630, -630, 2953, 5191, 3005, 3071, 469, 21,
1538 491, -630, 3123, 3189, 3241, 1490, -630, -630, -630, -630,
1539 -630, -630, -630, -10, 513, 972, 33, -630, 521, 530,
1540 -630, -630, -630, 706, -630, 710, -630, 740, 817, -630,
1541 -630, -630, -630, -630, -630, -630, -630, 928, 884, 585,
1542 965, 922, 631, 655, 621, 636, 8, -630, -630, -630,
1543 866, -630, -630, -630, -630, -630, -630, -630, -630, -630,
1544 -630, 891, 448, -630, -630, -630, 245, -630, 574, -630,
1545 719, 248, 3307, -630, 71, 2297, 15, 277, 405, 267,
1546 415, 94, 584, 3359, 5624, -9, -10, 513, 985, 241,
1547 414, -630, 721, 664, -630, 1896, -630, -630, 582, -630,
1548 -630, -630, 2034, -630, -630, 587, -630, -630, -630, -630,
1549 2034, -630, 2034, -630, -630, 5676, 662, -630, -630, -630,
1550 -630, -630, -630, 422, -630, 850, 870, 817, 946, 951,
1551 -630, -630, -630, -630, 905, -630, 645, 708, 711, -630,
1552 809, -630, -630, -630, -630, -630, -630, -630, -630, -630,
1553 26, -630, 734, 871, 678, 678, 425, -630, -630, -630,
1554 -630, -630, 743, 972, 261, -630, 713, -630, 555, 28,
1555 722, 5388, 2363, 581, -630, 207, 3425, -630, 426, -630,
1556 -630, 3477, 3543, 3595, 3661, 3713, 3779, 3831, 3897, 3949,
1557 4015, 4067, 4133, 630, 4185, 4251, 4303, 4369, 4421, 4487,
1558 4539, 2415, -630, -630, 4605, -630, 377, -630, -630, -630,
1559 -630, -630, -630, 1896, -630, -630, -630, -630, 4657, -630,
1560 84, -630, -630, 204, -630, -630, 214, -630, 4723, -630,
1561 4775, -630, 463, -630, 5243, -630, -630, 220, -630, 124,
1562 272, 712, 679, -630, -630, -9, 2481, -630, -630, -630,
1563 -630, 996, 490, -630, -630, 727, -630, 759, 1019, -630,
1564 -630, -630, 36, 2533, -630, 4841, -630, -630, -630, 905,
1565 -630, -630, -630, -630, -13, 736, -630, -630, -630, 2599,
1566 678, -630, 381, 678, 381, -630, 2651, 4893, 170, 417,
1567 640, -630, 1752, -630, -630, 2179, -630, -630, -630, -630,
1568 510, -630, -630, 202, -630, -630, -630, -630, -630, 748,
1569 -630, 237, -630, 5454, -630, -630, -630, -630, -630, -630,
1570 -630, 928, -630, 928, -630, 884, -630, 884, -630, 884,
1571 -630, 585, -630, 585, -630, 585, -630, 585, -630, 195,
1572 -630, -630, 965, -630, 965, -630, 922, -630, 631, -630,
1573 655, -630, 621, -630, 636, -630, 828, 762, -630, -630,
1574 -630, 1077, -630, 1896, 764, -630, 1896, -630, 325, -630,
1575 -630, -630, -630, -630, -630, -630, 366, -630, 765, 427,
1576 268, 463, -630, 392, -630, -630, -630, -630, -630, 5624,
1577 -630, -630, 430, 712, -630, 873, 65, 686, -630, 776,
1578 -630, 5336, -630, 5268, 778, 786, 789, -630, -630, 5506,
1579 -630, 251, -630, 319, -630, 319, -630, -630, 793, 85,
1580 -630, -630, -630, 4959, 1158, -630, -630, -630, -630, -630,
1581 5011, -630, -630, 5572, -630, -630, 256, 617, -630, 5077,
1582 698, -630, 1896, 2717, -630, -630, 2101, -630, -630, 306,
1583 -630, 811, -630, -630, -630, -630, -630, 800, -630, 2769,
1584 -630, -630, 893, 75, 5129, -630, 725, -630, 1604, -630,
1585 5624, -630, -630, -630, 822, 805, 5311, -630, 317, -630,
1586 629, -630, -630, 256, -630, 831, -630, -630, -630, -630,
1587 -630, -630, -630, 666, -630, 256, -630, -630, 453, -630,
1588 222, 90, 476, -630, 874, 889, 2101, -630, -630, 2101,
1589 -630, -630, 876, -630, 878, 903, -630, -630, 979, 165,
1590 -630, -630, -630, -630, -630, 442, -630, -630, 1694, -630,
1591 1827, -630, 910, 2034, -630, 917, -630, -630, -630, -630,
1592 256, -630, -630, 2835, -630, 227, 4657, 2034, -630, -630,
1593 2887, -630, -630, -630, -630, 1000, -630, -630, -630, 920,
1594 -630, 2034, -630, 240, 201, -630, 394, -630, 5268, 921,
1595 -630, -630, -630, -630, 246, 2101, 934, 5311, -630, 967,
1596 2101, 937, 2101, -630, 2101, -630, -630
1597 };
1598
1599 /* YYPGOTO[NTERM-NUM]. */
1600 static const short yypgoto[] =
1601 {
1602 -630, -630, -630, -630, -62, -55, 641, -26, -131, 161,
1603 138, -6, 475, -630, 139, -630, 1022, 593, -630, 51,
1604 -630, -630, 815, 102, 554, -630, -630, 980, 960, -630,
1605 -130, -630, 879, -630, -88, -112, 901, -175, -203, -630,
1606 -630, -60, 400, 785, -324, -128, -102, -630, -630, -630,
1607 -630, -630, -630, -630, 887, -630, 100, -630, 637, 371,
1608 -630, -630, -630, -630, 993, -8, -630, 953, -630, -630,
1609 101, -630, -116, 784, 758, -167, -294, -630, 739, -277,
1610 109, -430, 588, -336, -630, -630, -630, -302, -630, -630,
1611 -630, -630, -630, -630, -630, -630, 389, 390, -629, -287,
1612 -630, -630, -630, -630, -630, -630, -630, -241, -630, -625,
1613 742, -630, -630, -630, -630, -630, -630, -630, -630, -630,
1614 477, -630, 483, -630, -630, -630, 145, -630, -630, -630,
1615 -630, -432, -630, 714, 312, -38, 1226, 234, 1246, 235,
1616 428, 545, 877, -138, 635, 730, -482, -630, 623, 602,
1617 565, 633, 672, 684, 687, 683, 676, -630, 458, 694,
1618 791, -630, -630, 856, -630
1619 };
1620
1621 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1622 positive, shift that token. If negative, reduce the rule which
1623 number is the opposite. If zero, do what YYDEFACT says.
1624 If YYTABLE_NINF, parse error. */
1625 #define YYTABLE_NINF -508
1626 static const short yytable[] =
1627 {
1628 25, 449, 367, 33, 87, 334, 177, 186, 295, 184,
1629 625, 88, 467, 460, 596, 153, 351, 174, 188, 147,
1630 63, 42, 351, 400, 71, 453, 59, 472, 52, 496,
1631 60, 127, 138, 456, 374, 457, 87, 600, 88, 731,
1632 65, 80, 63, 88, 65, 165, 174, 63, 265, 257,
1633 123, 735, 259, 267, 619, 128, 343, 3, 347, 349,
1634 92, 104, 65, 35, 358, 360, 661, 65, 110, 356,
1635 269, 87, 421, 167, 165, 180, 721, 139, 88, 24,
1636 122, 637, 88, 607, 54, 569, 684, 92, 35, 122,
1637 608, 661, 92, 369, 473, 435, 497, 401, 127, 731,
1638 87, 66, 167, 135, 19, 88, 63, 88, -27, 4,
1639 -154, 252, 71, 24, 19, 19, 19, 189, 352, 141,
1640 286, 43, 337, 44, 352, 588, 65, 92, 53, 88,
1641 54, 92, 65, 184, -93, -93, 19, -293, 601, 19,
1642 19, 81, 689, 776, -103, 354, 29, 31, -103, 362,
1643 410, 255, 781, 5, 92, 129, 92, 19, 141, 24,
1644 407, 662, 469, 432, 6, 722, 754, 630, 93, 288,
1645 7, 622, 422, 441, 355, 123, 8, 680, 92, 56,
1646 58, 685, 24, 61, 9, 570, 745, 630, 340, 340,
1647 340, 340, 630, 61, 65, 436, 340, 340, 363, 180,
1648 93, 693, 754, 631, 91, 571, 88, 471, 184, 10,
1649 253, 701, -96, 137, 589, 573, 705, -96, -96, -96,
1650 -96, 586, 114, 660, 68, 590, 117, 719, 720, 103,
1651 445, 91, 142, 143, 107, 160, 91, 88, 634, 181,
1652 286, 753, 443, 515, 517, 519, 566, 770, 123, 417,
1653 256, -96, 681, -96, 54, 92, -96, -96, -96, -96,
1654 286, 755, 491, 73, 160, 114, 117, 630, 431, 652,
1655 148, 91, 449, 491, 180, 91, 705, 290, 427, 705,
1656 508, 88, 191, 258, 143, 144, 92, -24, -24, 288,
1657 145, 146, 628, 156, 122, 24, 451, 774, 91, 672,
1658 91, 460, 632, 630, 451, 572, 451, 713, 49, 458,
1659 706, 764, 71, 287, 289, 574, 482, 484, 736, 191,
1660 325, 587, 91, 744, 489, 490, 645, 715, 765, -24,
1661 92, 444, 65, 593, -24, -24, -24, 635, 539, 45,
1662 -24, 773, 157, 418, -24, 705, 408, 778, 449, 621,
1663 705, 682, 705, 133, 705, 335, 105, 492, 286, 709,
1664 -64, 336, 378, 181, 157, 157, 132, 647, 591, 703,
1665 706, 50, 428, 706, 460, 340, 340, 340, 340, 340,
1666 340, 340, 340, 340, 340, 340, 340, 92, 340, 340,
1667 340, 340, 340, 340, 340, 645, 642, 290, 78, 91,
1668 75, 148, 46, -255, -64, 712, 429, 561, -65, 326,
1669 327, 137, 23, 423, 157, -325, 433, 181, 149, 709,
1670 437, 646, 709, 464, 191, 254, 485, 512, 650, 453,
1671 91, 658, 456, 287, 289, -155, 449, 97, 181, 706,
1672 325, 289, 613, 756, 706, 615, 706, 325, 706, 289,
1673 -64, 289, -65, 287, 658, 325, 760, 325, 260, 39,
1674 325, 50, 648, 46, 653, 712, 460, 656, 712, 97,
1675 767, 261, 30, 560, 91, 460, 191, 417, 205, 336,
1676 149, 340, 41, 32, 772, 687, 340, 121, 709, 157,
1677 775, 475, 353, 709, -64, 709, -157, 709, 703, 24,
1678 430, 123, 138, 760, 173, 767, 694, 772, 286, -325,
1679 434, 286, 61, 623, 509, 290, 149, 465, -29, 4,
1680 486, 513, 651, 184, 579, 659, 151, 154, 580, 326,
1681 327, 91, 757, 173, 712, 39, 326, 327, 39, 712,
1682 338, 712, 82, 712, 326, 327, 326, 327, 743, 326,
1683 327, 287, 289, 739, 57, 40, 20, 288, 325, 24,
1684 288, 41, 737, 5, 62, 742, 20, 20, 20, 70,
1685 24, 746, 350, 102, 6, 84, -28, 4, 85, 24,
1686 7, 61, 504, 614, 191, 616, 8, 286, 20, 180,
1687 22, 20, 20, 386, 387, 388, 88, 106, 113, 116,
1688 22, 22, 22, 328, 150, 34, 629, 38, 159, 20,
1689 762, 178, 630, 286, -31, 4, 370, 340, 340, 10,
1690 94, 5, 22, 152, 375, 22, 22, -30, 4, 376,
1691 55, 538, 6, 340, 398, 159, 288, 159, 7, 155,
1692 451, 24, 396, 22, 8, 92, 466, 326, 327, 505,
1693 399, 24, 94, 494, 506, 5, 24, 495, 507, 5,
1694 24, 82, 288, 641, 185, 290, 644, 397, 290, 24,
1695 6, 411, 5, 286, 190, 286, 7, 10, 333, -153,
1696 504, 82, 8, 450, 24, 24, 24, 161, 454, 7,
1697 5, 24, -33, 4, 84, 8, 82, 85, 24, 504,
1698 451, 287, 289, 451, 287, 289, 179, 377, 325, 468,
1699 24, 325, 470, 695, 84, 10, 161, 85, 24, 630,
1700 329, 176, 288, 328, 288, 738, 24, 451, 10, 84,
1701 328, 630, 85, 24, 663, 474, 624, 5, 328, 149,
1702 328, 451, 699, 328, 290, 592, 325, 505, 325, 664,
1703 176, 24, 506, 181, 7, 451, 507, -32, 4, 446,
1704 8, 24, 741, 463, 698, 24, 505, 24, 630, 451,
1705 290, 506, 82, 663, 451, 507, 451, 479, 451, 61,
1706 287, 289, -34, 4, 665, 289, 24, 325, 664, 91,
1707 498, 325, 612, 10, 24, 612, 24, 326, 327, 24,
1708 326, 327, 5, -506, -506, 84, 287, 289, 85, 24,
1709 330, 493, 714, 325, 143, 748, 414, 415, 749, 7,
1710 416, 325, 24, 726, 597, 8, 599, 5, 36, 638,
1711 290, 609, 290, -507, -507, 326, 327, 326, 327, 487,
1712 329, 328, 488, 633, 7, 289, 369, 329, 289, 36,
1713 8, 325, 639, 36, 325, 329, 5, 329, 10, 643,
1714 329, 649, 82, 379, 380, 125, 287, 289, 287, 289,
1715 36, 670, 289, 325, 660, 325, 326, 327, 325, 676,
1716 326, 327, 677, 10, 779, 678, 289, 384, 385, 783,
1717 -373, 785, 325, 786, 720, 84, -344, -344, 85, 24,
1718 289, 716, 326, 327, 371, 331, 325, 601, 372, 39,
1719 326, 327, 373, 325, 289, 82, -346, -346, 733, 289,
1720 325, 289, 325, 289, 126, 325, 40, 325, -371, 325,
1721 330, 747, 41, 381, 382, 383, 5, 330, 394, 395,
1722 326, 327, 82, 326, 327, 330, -205, 330, 84, -344,
1723 330, 85, 24, -344, 531, 533, 535, 537, 329, 402,
1724 403, -137, 326, 327, 326, 327, 332, 326, 327, -346,
1725 476, 477, 478, -346, 751, 84, 125, 750, 85, 24,
1726 753, 326, 327, 389, 390, 391, 392, 405, 525, 527,
1727 529, 328, -415, -415, 328, 326, 327, -416, -416, 752,
1728 251, 770, 326, 327, 145, 146, 759, 521, 523, 326,
1729 327, 326, 327, 761, 326, 327, 326, 327, 326, 327,
1730 39, 771, 777, 393, 782, 331, 82, 542, 544, 328,
1731 780, 328, 331, 784, 540, 126, 37, 40, 79, 112,
1732 331, 264, 331, 41, 192, 331, 406, 262, 330, 77,
1733 564, 131, 413, 448, 459, 727, 728, 462, 654, 84,
1734 364, 251, 85, 24, 655, -505, -505, 371, 546, 483,
1735 328, 372, 345, -17, 328, 373, 554, 5, -505, -505,
1736 371, 548, 552, 82, 372, 550, 332, 0, 442, -505,
1737 -505, 371, 83, 332, 7, 372, 328, 697, 559, 442,
1738 8, 332, 0, 332, 328, 0, 332, -17, 329, 0,
1739 0, 329, -505, -505, 371, 0, 84, 0, 372, 85,
1740 24, 5, 373, 0, 0, 0, 0, 82, 420, 157,
1741 158, 426, 0, 10, 328, 0, 83, 328, 7, 439,
1742 440, 0, 0, 331, 8, 0, 329, 0, 329, 0,
1743 0, 0, 0, 0, 0, 0, 328, 0, 328, 688,
1744 84, 328, 0, 85, 24, -17, 0, 0, 0, 0,
1745 -505, -505, 371, 157, 263, 328, 372, 10, 0, 0,
1746 640, 0, 0, 0, 0, 0, 0, 329, 0, 328,
1747 0, 329, 0, 0, 0, 0, 328, 0, 330, 0,
1748 0, 330, 0, 328, 332, 328, 0, 0, 328, 82,
1749 328, 0, 328, 329, 0, 0, 0, 0, 198, 0,
1750 0, 329, 0, 0, 199, 0, 0, 0, 503, 0,
1751 0, 200, 511, 0, 0, 201, 330, 0, 330, 0,
1752 0, 0, 84, 0, 0, 85, 24, 0, 0, 202,
1753 203, 329, 0, 204, 329, 0, 0, 557, 0, 0,
1754 0, 0, 206, 207, 208, 209, 0, 0, 210, 211,
1755 0, 0, 0, 329, 568, 329, 0, 330, 329, 0,
1756 0, 330, 0, 0, 576, 0, 578, 0, 0, 0,
1757 0, 0, 329, 331, 0, 5, 331, 0, 0, 0,
1758 0, 82, 0, 330, 0, 0, 329, 0, 0, 0,
1759 83, 330, 7, 329, 0, 0, 0, 0, 8, 604,
1760 329, 606, 329, 0, 0, 329, 0, 329, 0, 329,
1761 0, 331, 0, 331, 84, 611, 0, 85, 24, 0,
1762 0, 330, 0, 0, 330, 0, 0, 5, 86, 0,
1763 0, 251, 0, 82, 332, 0, 0, 332, 0, 0,
1764 0, 0, 83, 330, 7, 330, 0, 0, 330, 0,
1765 8, 0, 331, 0, 0, 0, 331, 0, 0, 0,
1766 0, 0, 330, 0, 0, 0, 84, 0, 0, 85,
1767 24, 0, 332, 0, 332, 0, 330, 0, 331, 0,
1768 130, 0, 0, 330, 0, 0, 331, 0, 0, 0,
1769 330, 0, 330, 0, 0, 330, 0, 330, 0, 330,
1770 341, 341, 341, 341, 0, 0, 0, 0, 341, 341,
1771 0, 0, 0, 332, 0, 0, 331, 332, 0, 331,
1772 342, 342, 342, 342, 0, 657, 0, 0, 342, 342,
1773 0, 0, 0, 0, 0, 0, 0, 0, 331, 332,
1774 331, 0, 0, 331, 0, 0, 0, 332, 0, 0,
1775 0, 0, 0, 0, 0, 0, 0, 331, 0, 0,
1776 0, 0, 0, 0, 0, 0, 691, 0, 0, 0,
1777 0, 331, 0, 194, 195, 0, 0, 332, 331, 0,
1778 332, 0, 0, 0, 0, 331, 0, 331, 0, 0,
1779 331, 0, 331, 0, 331, 0, 0, 0, 0, 332,
1780 724, 332, 0, 0, 332, 0, 732, 0, 0, 0,
1781 0, 0, 0, 0, 0, 0, 196, 197, 332, 0,
1782 0, 82, 0, 0, 0, 0, 0, 0, 0, 0,
1783 198, 0, 332, 0, 0, 0, 199, 0, 0, 332,
1784 0, 0, 0, 200, 0, 0, 332, 201, 332, 0,
1785 0, 332, 0, 332, 84, 332, 0, 85, 24, 0,
1786 0, 202, 203, 0, 0, 204, 0, 205, 365, 0,
1787 0, 0, 366, 0, 206, 207, 208, 209, 0, 0,
1788 210, 211, 766, 0, 0, 270, 769, 341, 341, 341,
1789 341, 341, 341, 341, 341, 341, 341, 341, 341, 0,
1790 341, 341, 341, 341, 341, 341, 341, 342, 342, 342,
1791 342, 342, 342, 342, 342, 342, 342, 342, 342, 0,
1792 342, 342, 342, 342, 342, 342, 342, 0, 0, 5,
1793 196, 197, 663, 271, 272, 82, 273, 0, 0, 274,
1794 0, 0, 0, 275, 198, 0, 0, 664, 0, 0,
1795 276, 277, 8, 278, 0, 279, 280, 200, 281, 0,
1796 0, 282, 283, 0, 0, 0, 0, 0, 84, 0,
1797 0, 85, 24, 0, 0, 270, 0, 0, 0, 284,
1798 0, 157, 729, 0, 0, 10, 0, 0, 206, 207,
1799 208, 209, 0, 341, 210, 211, 0, 0, 341, 0,
1800 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1801 0, 0, 0, 342, 0, 0, 0, 0, 342, 5,
1802 196, 197, 663, 271, 272, 82, 273, 0, 0, 274,
1803 0, 0, 0, 275, 198, 0, 0, 664, 0, 0,
1804 276, 277, 8, 278, 0, 279, 280, 200, 281, 0,
1805 0, 282, 283, 0, 0, 0, 0, 0, 84, 0,
1806 0, 85, 24, 0, 0, 0, 0, 0, 0, 284,
1807 0, 157, 758, 0, 0, 10, 0, 0, 206, 207,
1808 208, 209, 0, 82, 210, 211, 0, 0, 0, 0,
1809 0, 0, 198, 0, 0, 0, 0, 0, 199, 0,
1810 0, 0, 0, 0, 0, 200, 0, 0, 270, 201,
1811 0, 0, 0, 0, 0, 0, 84, 0, 0, 85,
1812 24, 0, 0, 202, 203, 0, 0, 204, 0, 341,
1813 341, 0, 0, 0, 0, 0, 206, 207, 208, 209,
1814 0, 0, 210, 211, 0, 341, 0, 0, 0, 342,
1815 342, 0, 5, 196, 197, -265, 271, 272, 82, 273,
1816 0, 0, 274, 0, 0, 342, 275, 198, 0, 0,
1817 -265, 0, 0, 276, 277, 8, 278, 270, 279, 280,
1818 200, 281, 0, 0, 282, 283, 0, 0, 0, 0,
1819 0, 84, 0, 0, 85, 24, 0, 0, 0, 0,
1820 0, 0, 284, 0, 157, -265, 0, 0, 10, 0,
1821 0, 206, 207, 208, 209, 0, 0, 210, 211, 0,
1822 0, 5, 196, 197, 0, 271, 272, 82, 273, 0,
1823 0, 274, 0, 0, 0, 275, 198, 0, 0, 0,
1824 0, 0, 276, 277, 8, 278, 270, 279, 280, 200,
1825 281, 0, 0, 282, 283, 0, 0, 0, 0, 0,
1826 84, 0, 0, 85, 24, 0, 0, 0, 0, 0,
1827 0, 284, 0, 157, 447, 0, 0, 10, 0, 0,
1828 206, 207, 208, 209, 0, 0, 210, 211, 0, 0,
1829 5, 196, 197, 0, 271, 272, 82, 273, 0, 0,
1830 274, 0, 0, 0, 275, 198, 0, 0, 0, 0,
1831 0, 276, 277, 8, 278, 270, 279, 280, 200, 281,
1832 0, 0, 282, 283, 0, 0, 0, 0, 0, 84,
1833 0, 0, 85, 24, 0, 0, 0, 0, 0, 0,
1834 284, 0, 157, 0, 0, 0, 10, 0, 0, 206,
1835 207, 208, 209, 0, 0, 210, 211, 0, 0, 5,
1836 196, 197, 0, 271, 272, 82, 273, 0, 0, 274,
1837 0, 0, 0, 275, 198, 0, 0, 0, 0, 0,
1838 276, 277, 270, 278, 0, 279, 280, 200, 281, 0,
1839 0, 282, 283, 0, 0, 0, 0, 0, 84, 0,
1840 0, 85, 24, 0, 0, 0, 0, 0, 0, 284,
1841 0, 157, 0, 0, 0, 10, 0, 0, 206, 207,
1842 208, 209, 0, 0, 210, 211, 5, 196, 197, 0,
1843 702, 272, 82, 273, 0, 0, 274, 0, 0, 0,
1844 275, 198, 0, 0, 0, 0, 0, 276, 277, 0,
1845 278, 0, 279, 280, 200, 281, 0, 0, 282, 283,
1846 626, 0, 194, 195, 0, 84, 0, 0, 85, 24,
1847 0, 0, 0, 0, 0, 0, 284, 0, 157, 0,
1848 0, 0, 10, 0, 0, 206, 207, 208, 209, 0,
1849 0, 210, 211, 0, 0, 0, 0, 0, 0, 0,
1850 0, 0, 0, 0, 0, 196, 197, 0, 0, 0,
1851 82, 0, 0, 0, 0, 0, 0, 0, 0, 198,
1852 0, 0, 0, 0, 0, 199, 193, 0, 194, 195,
1853 0, 0, 200, 0, 0, 0, 201, 0, 0, 0,
1854 0, 0, 0, 84, 0, 0, 85, 24, 0, 0,
1855 202, 203, 0, 0, 204, 0, 205, 627, 0, 0,
1856 0, 0, 0, 206, 207, 208, 209, 0, 0, 210,
1857 211, 196, 197, 0, 0, 0, 82, 0, 424, 0,
1858 194, 195, 0, 0, 0, 198, 0, 0, 0, 0,
1859 0, 199, 0, 0, 0, 0, 0, 0, 200, 0,
1860 0, 0, 201, 0, 0, 0, 0, 0, 0, 84,
1861 0, 0, 85, 24, 0, 0, 202, 203, 0, 0,
1862 204, 0, 205, 196, 197, 0, 0, 0, 82, 206,
1863 207, 208, 209, 0, 0, 210, 211, 198, 0, 0,
1864 0, 0, 0, 199, 502, 0, 194, 195, 0, 0,
1865 200, 0, 0, 0, 201, 0, 0, 0, 0, 0,
1866 0, 84, 0, 0, 85, 24, 0, 0, 202, 203,
1867 0, 0, 204, 0, 0, 0, 0, 0, 425, 0,
1868 0, 206, 207, 208, 209, 0, 0, 210, 211, 196,
1869 197, 0, 0, 0, 82, 0, 555, 0, 194, 195,
1870 0, 0, 0, 198, 0, 0, 0, 0, 0, 199,
1871 0, 0, 0, 0, 0, 0, 200, 0, 0, 0,
1872 201, 0, 0, 0, 0, 0, 0, 84, 0, 0,
1873 85, 24, 0, 0, 202, 203, 0, 0, 204, 0,
1874 0, 196, 197, 148, 0, 0, 82, 206, 207, 208,
1875 209, 0, 0, 210, 211, 198, 0, 0, 0, 0,
1876 0, 199, 594, 0, 194, 195, 0, 0, 200, 0,
1877 0, 0, 201, 0, 0, 0, 0, 0, 0, 84,
1878 0, 0, 85, 24, 0, 556, 202, 203, 0, 0,
1879 204, 0, 0, 0, 0, 0, 0, 0, 0, 206,
1880 207, 208, 209, 0, 0, 210, 211, 196, 197, 0,
1881 0, 0, 82, 0, 602, 0, 194, 195, 0, 0,
1882 0, 198, 0, 0, 0, 0, 0, 199, 0, 0,
1883 0, 0, 0, 0, 200, 0, 0, 0, 201, 0,
1884 0, 0, 0, 0, 0, 84, 0, 0, 85, 24,
1885 0, 0, 202, 203, 0, 0, 204, 595, 0, 196,
1886 197, 0, 0, 0, 82, 206, 207, 208, 209, 0,
1887 0, 210, 211, 198, 0, 0, 0, 0, 0, 199,
1888 610, 0, 194, 195, 0, 0, 200, 0, 0, 0,
1889 201, 0, 0, 0, 0, 0, 0, 84, 0, 0,
1890 85, 24, 0, 0, 202, 203, 0, 0, 204, 0,
1891 0, 0, 0, 0, 603, 0, 0, 206, 207, 208,
1892 209, 0, 0, 210, 211, 196, 197, 0, 0, 0,
1893 82, 0, 617, 0, 194, 195, 0, 0, 0, 198,
1894 0, 0, 0, 0, 0, 199, 0, 0, 0, 0,
1895 0, 0, 200, 0, 0, 0, 201, 0, 0, 0,
1896 0, 0, 0, 84, 0, 0, 85, 24, 0, 0,
1897 202, 203, 0, 0, 204, 0, 0, 196, 197, 148,
1898 0, 0, 82, 206, 207, 208, 209, 0, 0, 210,
1899 211, 198, 0, 0, 0, 0, 0, 199, 594, 0,
1900 194, 195, 0, 0, 200, 0, 0, 0, 201, 0,
1901 0, 0, 0, 0, 0, 84, 0, 0, 85, 24,
1902 0, 0, 202, 203, 0, 0, 204, 618, 0, 0,
1903 0, 0, 0, 0, 0, 206, 207, 208, 209, 0,
1904 0, 210, 211, 196, 197, 0, 0, 0, 82, 0,
1905 717, 0, 194, 195, 0, 0, 0, 198, 0, 0,
1906 0, 0, 0, 199, 0, 0, 0, 0, 0, 0,
1907 200, 0, 0, 0, 201, 0, 0, 0, 0, 0,
1908 0, 84, 0, 0, 85, 24, 0, 0, 202, 203,
1909 0, 0, 204, 700, 0, 196, 197, 0, 0, 0,
1910 82, 206, 207, 208, 209, 0, 0, 210, 211, 198,
1911 0, 0, 0, 0, 0, 199, 717, 0, 194, 195,
1912 0, 0, 200, 0, 0, 0, 201, 0, 0, 0,
1913 0, 0, 0, 84, 0, 0, 85, 24, 0, 0,
1914 202, 203, 0, 0, 204, 718, 0, 0, 0, 0,
1915 0, 0, 0, 206, 207, 208, 209, 0, 0, 210,
1916 211, 196, 197, 0, 0, 0, 82, 0, 602, 0,
1917 194, 195, 0, 0, 0, 198, 0, 0, 0, 0,
1918 0, 199, 0, 0, 0, 0, 0, 0, 200, 0,
1919 0, 0, 201, 0, 0, 0, 0, 0, 0, 84,
1920 0, 0, 85, 24, 0, 0, 202, 203, 0, 0,
1921 204, 763, 0, 196, 197, 0, 0, 0, 82, 206,
1922 207, 208, 209, 0, 0, 210, 211, 198, 0, 0,
1923 0, 0, 0, 199, 339, 0, 194, 195, 0, 0,
1924 200, 0, 0, 0, 201, 0, 0, 0, 0, 0,
1925 0, 84, 0, 0, 85, 24, 0, 0, 202, 203,
1926 0, 0, 204, 0, 0, 0, 0, 0, 768, 0,
1927 0, 206, 207, 208, 209, 0, 0, 210, 211, 196,
1928 197, 0, 0, 0, 82, 0, 346, 0, 194, 195,
1929 0, 0, 0, 198, 0, 0, 0, 0, 0, 199,
1930 0, 0, 0, 0, 0, 0, 200, 0, 0, 0,
1931 201, 0, 0, 0, 0, 0, 0, 84, 0, 0,
1932 85, 24, 0, 0, 202, 203, 0, 0, 204, 0,
1933 0, 196, 197, 0, 0, 0, 82, 206, 207, 208,
1934 209, 0, 0, 210, 211, 198, 0, 0, 0, 0,
1935 0, 199, 348, 0, 194, 195, 0, 0, 200, 0,
1936 0, 0, 201, 0, 0, 0, 0, 0, 0, 84,
1937 0, 0, 85, 24, 0, 0, 202, 203, 0, 0,
1938 204, 0, 0, 0, 0, 0, 0, 0, 0, 206,
1939 207, 208, 209, 0, 0, 210, 211, 196, 197, 0,
1940 0, 0, 82, 0, 357, 0, 194, 195, 0, 0,
1941 0, 198, 0, 0, 0, 0, 0, 199, 0, 0,
1942 0, 0, 0, 0, 200, 0, 0, 0, 201, 0,
1943 0, 0, 0, 0, 0, 84, 0, 0, 85, 24,
1944 0, 0, 202, 203, 0, 0, 204, 0, 0, 196,
1945 197, 0, 0, 0, 82, 206, 207, 208, 209, 0,
1946 0, 210, 211, 198, 0, 0, 0, 0, 0, 199,
1947 359, 0, 194, 195, 0, 0, 200, 0, 0, 0,
1948 201, 0, 0, 0, 0, 0, 0, 84, 0, 0,
1949 85, 24, 0, 0, 202, 203, 0, 0, 204, 0,
1950 0, 0, 0, 0, 0, 0, 0, 206, 207, 208,
1951 209, 0, 0, 210, 211, 196, 197, 0, 0, 0,
1952 82, 0, 361, 0, 194, 195, 0, 0, 0, 198,
1953 0, 0, 0, 0, 0, 199, 0, 0, 0, 0,
1954 0, 0, 200, 0, 0, 0, 201, 0, 0, 0,
1955 0, 0, 0, 84, 0, 0, 85, 24, 0, 0,
1956 202, 203, 0, 0, 204, 0, 0, 196, 197, 0,
1957 0, 0, 82, 206, 207, 208, 209, 0, 0, 210,
1958 211, 198, 0, 0, 0, 0, 0, 199, 419, 0,
1959 194, 195, 0, 0, 200, 0, 0, 0, 201, 0,
1960 0, 0, 0, 0, 0, 84, 0, 0, 85, 24,
1961 0, 0, 202, 203, 0, 0, 204, 0, 0, 0,
1962 0, 0, 0, 0, 0, 206, 207, 208, 209, 0,
1963 0, 210, 211, 196, 197, 0, 0, 0, 82, 0,
1964 438, 0, 194, 195, 0, 0, 0, 198, 0, 0,
1965 0, 0, 0, 199, 0, 0, 0, 0, 0, 0,
1966 200, 0, 0, 0, 201, 0, 0, 0, 0, 0,
1967 0, 84, 0, 0, 85, 24, 0, 0, 202, 203,
1968 0, 0, 204, 0, 0, 196, 197, 0, 0, 0,
1969 82, 206, 207, 208, 209, 0, 0, 210, 211, 198,
1970 0, 0, 0, 0, 0, 199, 510, 0, 194, 195,
1971 0, 0, 200, 0, 0, 0, 201, 0, 0, 0,
1972 0, 0, 0, 84, 0, 0, 85, 24, 0, 0,
1973 202, 203, 0, 0, 204, 0, 0, 0, 0, 0,
1974 0, 0, 0, 206, 207, 208, 209, 0, 0, 210,
1975 211, 196, 197, 0, 0, 0, 82, 0, 514, 0,
1976 194, 195, 0, 0, 0, 198, 0, 0, 0, 0,
1977 0, 199, 0, 0, 0, 0, 0, 0, 200, 0,
1978 0, 0, 201, 0, 0, 0, 0, 0, 0, 84,
1979 0, 0, 85, 24, 0, 0, 202, 203, 0, 0,
1980 204, 0, 0, 196, 197, 0, 0, 0, 82, 206,
1981 207, 208, 209, 0, 0, 210, 211, 198, 0, 0,
1982 0, 0, 0, 199, 516, 0, 194, 195, 0, 0,
1983 200, 0, 0, 0, 201, 0, 0, 0, 0, 0,
1984 0, 84, 0, 0, 85, 24, 0, 0, 202, 203,
1985 0, 0, 204, 0, 0, 0, 0, 0, 0, 0,
1986 0, 206, 207, 208, 209, 0, 0, 210, 211, 196,
1987 197, 0, 0, 0, 82, 0, 518, 0, 194, 195,
1988 0, 0, 0, 198, 0, 0, 0, 0, 0, 199,
1989 0, 0, 0, 0, 0, 0, 200, 0, 0, 0,
1990 201, 0, 0, 0, 0, 0, 0, 84, 0, 0,
1991 85, 24, 0, 0, 202, 203, 0, 0, 204, 0,
1992 0, 196, 197, 0, 0, 0, 82, 206, 207, 208,
1993 209, 0, 0, 210, 211, 198, 0, 0, 0, 0,
1994 0, 199, 520, 0, 194, 195, 0, 0, 200, 0,
1995 0, 0, 201, 0, 0, 0, 0, 0, 0, 84,
1996 0, 0, 85, 24, 0, 0, 202, 203, 0, 0,
1997 204, 0, 0, 0, 0, 0, 0, 0, 0, 206,
1998 207, 208, 209, 0, 0, 210, 211, 196, 197, 0,
1999 0, 0, 82, 0, 522, 0, 194, 195, 0, 0,
2000 0, 198, 0, 0, 0, 0, 0, 199, 0, 0,
2001 0, 0, 0, 0, 200, 0, 0, 0, 201, 0,
2002 0, 0, 0, 0, 0, 84, 0, 0, 85, 24,
2003 0, 0, 202, 203, 0, 0, 204, 0, 0, 196,
2004 197, 0, 0, 0, 82, 206, 207, 208, 209, 0,
2005 0, 210, 211, 198, 0, 0, 0, 0, 0, 199,
2006 524, 0, 194, 195, 0, 0, 200, 0, 0, 0,
2007 201, 0, 0, 0, 0, 0, 0, 84, 0, 0,
2008 85, 24, 0, 0, 202, 203, 0, 0, 204, 0,
2009 0, 0, 0, 0, 0, 0, 0, 206, 207, 208,
2010 209, 0, 0, 210, 211, 196, 197, 0, 0, 0,
2011 82, 0, 526, 0, 194, 195, 0, 0, 0, 198,
2012 0, 0, 0, 0, 0, 199, 0, 0, 0, 0,
2013 0, 0, 200, 0, 0, 0, 201, 0, 0, 0,
2014 0, 0, 0, 84, 0, 0, 85, 24, 0, 0,
2015 202, 203, 0, 0, 204, 0, 0, 196, 197, 0,
2016 0, 0, 82, 206, 207, 208, 209, 0, 0, 210,
2017 211, 198, 0, 0, 0, 0, 0, 199, 528, 0,
2018 194, 195, 0, 0, 200, 0, 0, 0, 201, 0,
2019 0, 0, 0, 0, 0, 84, 0, 0, 85, 24,
2020 0, 0, 202, 203, 0, 0, 204, 0, 0, 0,
2021 0, 0, 0, 0, 0, 206, 207, 208, 209, 0,
2022 0, 210, 211, 196, 197, 0, 0, 0, 82, 0,
2023 530, 0, 194, 195, 0, 0, 0, 198, 0, 0,
2024 0, 0, 0, 199, 0, 0, 0, 0, 0, 0,
2025 200, 0, 0, 0, 201, 0, 0, 0, 0, 0,
2026 0, 84, 0, 0, 85, 24, 0, 0, 202, 203,
2027 0, 0, 204, 0, 0, 196, 197, 0, 0, 0,
2028 82, 206, 207, 208, 209, 0, 0, 210, 211, 198,
2029 0, 0, 0, 0, 0, 199, 532, 0, 194, 195,
2030 0, 0, 200, 0, 0, 0, 201, 0, 0, 0,
2031 0, 0, 0, 84, 0, 0, 85, 24, 0, 0,
2032 202, 203, 0, 0, 204, 0, 0, 0, 0, 0,
2033 0, 0, 0, 206, 207, 208, 209, 0, 0, 210,
2034 211, 196, 197, 0, 0, 0, 82, 0, 534, 0,
2035 194, 195, 0, 0, 0, 198, 0, 0, 0, 0,
2036 0, 199, 0, 0, 0, 0, 0, 0, 200, 0,
2037 0, 0, 201, 0, 0, 0, 0, 0, 0, 84,
2038 0, 0, 85, 24, 0, 0, 202, 203, 0, 0,
2039 204, 0, 0, 196, 197, 0, 0, 0, 82, 206,
2040 207, 208, 209, 0, 0, 210, 211, 198, 0, 0,
2041 0, 0, 0, 199, 536, 0, 194, 195, 0, 0,
2042 200, 0, 0, 0, 201, 0, 0, 0, 0, 0,
2043 0, 84, 0, 0, 85, 24, 0, 0, 202, 203,
2044 0, 0, 204, 0, 0, 0, 0, 0, 0, 0,
2045 0, 206, 207, 208, 209, 0, 0, 210, 211, 196,
2046 197, 0, 0, 0, 82, 0, 541, 0, 194, 195,
2047 0, 0, 0, 198, 0, 0, 0, 0, 0, 199,
2048 0, 0, 0, 0, 0, 0, 200, 0, 0, 0,
2049 201, 0, 0, 0, 0, 0, 0, 84, 0, 0,
2050 85, 24, 0, 0, 202, 203, 0, 0, 204, 0,
2051 0, 196, 197, 0, 0, 0, 82, 206, 207, 208,
2052 209, 0, 0, 210, 211, 198, 0, 0, 0, 0,
2053 0, 199, 543, 0, 194, 195, 0, 0, 200, 0,
2054 0, 0, 201, 0, 0, 0, 0, 0, 0, 84,
2055 0, 0, 85, 24, 0, 0, 202, 203, 0, 0,
2056 204, 0, 0, 0, 0, 0, 0, 0, 0, 206,
2057 207, 208, 209, 0, 0, 210, 211, 196, 197, 0,
2058 0, 0, 82, 0, 545, 0, 194, 195, 0, 0,
2059 0, 198, 0, 0, 0, 0, 0, 199, 0, 0,
2060 0, 0, 0, 0, 200, 0, 0, 0, 201, 0,
2061 0, 0, 0, 0, 0, 84, 0, 0, 85, 24,
2062 0, 0, 202, 203, 0, 0, 204, 0, 0, 196,
2063 197, 0, 0, 0, 82, 206, 207, 208, 209, 0,
2064 0, 210, 211, 198, 0, 0, 0, 0, 0, 199,
2065 547, 0, 194, 195, 0, 0, 200, 0, 0, 0,
2066 201, 0, 0, 0, 0, 0, 0, 84, 0, 0,
2067 85, 24, 0, 0, 202, 203, 0, 0, 204, 0,
2068 0, 0, 0, 0, 0, 0, 0, 206, 207, 208,
2069 209, 0, 0, 210, 211, 196, 197, 0, 0, 0,
2070 82, 0, 549, 0, 194, 195, 0, 0, 0, 198,
2071 0, 0, 0, 0, 0, 199, 0, 0, 0, 0,
2072 0, 0, 200, 0, 0, 0, 201, 0, 0, 0,
2073 0, 0, 0, 84, 0, 0, 85, 24, 0, 0,
2074 202, 203, 0, 0, 204, 0, 0, 196, 197, 0,
2075 0, 0, 82, 206, 207, 208, 209, 0, 0, 210,
2076 211, 198, 0, 0, 0, 0, 0, 199, 551, 0,
2077 194, 195, 0, 0, 200, 0, 0, 0, 201, 0,
2078 0, 0, 0, 0, 0, 84, 0, 0, 85, 24,
2079 0, 0, 202, 203, 0, 0, 204, 0, 0, 0,
2080 0, 0, 0, 0, 0, 206, 207, 208, 209, 0,
2081 0, 210, 211, 196, 197, 0, 0, 0, 82, 0,
2082 553, 0, 194, 195, 0, 0, 0, 198, 0, 0,
2083 0, 0, 0, 199, 0, 0, 0, 0, 0, 0,
2084 200, 0, 0, 0, 201, 0, 0, 0, 0, 0,
2085 0, 84, 0, 0, 85, 24, 0, 0, 202, 203,
2086 0, 0, 204, 0, 0, 196, 197, 0, 0, 0,
2087 82, 206, 207, 208, 209, 0, 0, 210, 211, 198,
2088 0, 0, 0, 0, 0, 199, 558, 0, 194, 195,
2089 0, 0, 200, 0, 0, 0, 201, 0, 0, 0,
2090 0, 0, 0, 84, 0, 0, 85, 24, 0, 0,
2091 202, 203, 0, 0, 204, 0, 0, 0, 0, 0,
2092 0, 0, 0, 206, 207, 208, 209, 0, 0, 210,
2093 211, 196, 197, 0, 0, 0, 82, 0, 567, 0,
2094 194, 195, 0, 0, 0, 198, 0, 0, 0, 0,
2095 0, 199, 0, 0, 0, 0, 0, 0, 200, 0,
2096 0, 0, 201, 0, 0, 0, 0, 0, 0, 84,
2097 0, 0, 85, 24, 0, 0, 202, 203, 0, 0,
2098 204, 0, 0, 196, 197, 0, 0, 0, 82, 206,
2099 207, 208, 209, 0, 0, 210, 211, 198, 0, 0,
2100 0, 0, 0, 199, 575, 0, 194, 195, 0, 0,
2101 200, 0, 0, 0, 201, 0, 0, 0, 0, 0,
2102 0, 84, 0, 0, 85, 24, 0, 0, 202, 203,
2103 0, 0, 204, 0, 0, 0, 0, 0, 0, 0,
2104 0, 206, 207, 208, 209, 0, 0, 210, 211, 196,
2105 197, 0, 0, 0, 82, 0, 577, 0, 194, 195,
2106 0, 0, 0, 198, 0, 0, 0, 0, 0, 199,
2107 0, 0, 0, 0, 0, 0, 200, 0, 0, 0,
2108 201, 0, 0, 0, 0, 0, 0, 84, 0, 0,
2109 85, 24, 0, 0, 202, 203, 0, 0, 204, 0,
2110 0, 196, 197, 0, 0, 0, 82, 206, 207, 208,
2111 209, 0, 0, 210, 211, 198, 0, 0, 0, 0,
2112 0, 199, 605, 0, 194, 195, 0, 0, 200, 0,
2113 0, 0, 201, 0, 0, 0, 0, 0, 0, 84,
2114 0, 0, 85, 24, 0, 0, 202, 203, 0, 0,
2115 204, 0, 0, 0, 0, 0, 0, 0, 0, 206,
2116 207, 208, 209, 0, 0, 210, 211, 196, 197, 0,
2117 0, 0, 82, 0, 620, 0, 194, 195, 0, 0,
2118 0, 198, 0, 0, 0, 0, 0, 199, 0, 0,
2119 0, 0, 0, 0, 200, 0, 0, 0, 201, 0,
2120 0, 0, 0, 0, 0, 84, 0, 0, 85, 24,
2121 0, 0, 202, 203, 0, 0, 204, 0, 0, 196,
2122 197, 0, 0, 0, 82, 206, 207, 208, 209, 0,
2123 0, 210, 211, 198, 0, 0, 0, 0, 0, 199,
2124 686, 0, 194, 195, 0, 0, 200, 0, 0, 0,
2125 201, 0, 0, 0, 0, 0, 0, 84, 0, 0,
2126 85, 24, 0, 0, 202, 203, 0, 0, 204, 0,
2127 0, 0, 0, 0, 0, 0, 0, 206, 207, 208,
2128 209, 0, 0, 210, 211, 196, 197, 0, 0, 0,
2129 82, 0, 690, 0, 194, 195, 0, 0, 0, 198,
2130 0, 0, 0, 0, 0, 199, 0, 0, 0, 0,
2131 0, 0, 200, 0, 0, 0, 201, 0, 0, 0,
2132 0, 0, 0, 84, 0, 0, 85, 24, 0, 0,
2133 202, 203, 0, 0, 204, 0, 0, 196, 197, 0,
2134 0, 0, 82, 206, 207, 208, 209, 0, 0, 210,
2135 211, 198, 0, 0, 0, 0, 0, 199, 696, 0,
2136 194, 195, 0, 0, 200, 0, 0, 0, 201, 0,
2137 0, 0, 0, 0, 0, 84, 0, 0, 85, 24,
2138 0, 0, 202, 203, 0, 0, 204, 0, 0, 0,
2139 0, 0, 0, 0, 0, 206, 207, 208, 209, 0,
2140 0, 210, 211, 196, 197, 0, 0, 0, 82, 0,
2141 723, 0, 194, 195, 0, 0, 0, 198, 0, 0,
2142 0, 0, 0, 199, 0, 0, 0, 0, 0, 0,
2143 200, 0, 0, 0, 201, 0, 0, 0, 0, 0,
2144 0, 84, 0, 0, 85, 24, 0, 0, 202, 203,
2145 0, 0, 204, 0, 0, 196, 197, 0, 0, 0,
2146 82, 206, 207, 208, 209, 0, 0, 210, 211, 198,
2147 0, 0, 344, 0, 194, 199, 0, 0, 0, 0,
2148 0, 0, 200, 0, 0, 0, 201, 0, 0, 0,
2149 0, 0, 0, 84, 0, 0, 85, 24, 0, 0,
2150 202, 203, 0, 0, 204, 0, 0, 0, 0, 0,
2151 0, 0, 0, 206, 207, 208, 209, 196, 197, 210,
2152 211, 0, 82, 0, 585, 0, 0, 0, 0, 0,
2153 0, 198, 0, 0, 0, 0, 0, 199, 0, 0,
2154 0, 0, 0, 0, 200, 0, 0, 0, 201, 673,
2155 0, 0, 0, 0, 0, 84, 0, 0, 85, 24,
2156 0, 0, 202, 203, 0, 0, 204, 0, -288, -288,
2157 -288, 0, 0, 0, -288, 206, 207, 208, 209, 0,
2158 0, 210, 211, -288, 0, 0, 0, 0, 0, -288,
2159 0, 0, 734, 0, 196, 197, -288, 0, 0, 82,
2160 -288, 0, 0, 0, 0, 0, 0, -288, 198, 0,
2161 -288, -288, 0, 0, 199, 0, 0, 671, -288, 0,
2162 0, 200, 0, 0, -288, 201, 0, -288, -288, -288,
2163 -288, 0, 84, -288, -288, 85, 24, 196, 197, 0,
2164 0, 0, 82, 284, -296, 0, 0, 0, 0, 0,
2165 0, 198, 206, 207, 208, 209, 0, 199, 210, 211,
2166 0, 0, 196, 197, 200, 0, 0, 82, 201, 0,
2167 0, 194, 195, 0, 0, 84, 198, 0, 85, 24,
2168 0, 0, 199, 0, 0, 0, 284, -296, 0, 200,
2169 0, 0, 0, 201, 0, 206, 207, 208, 209, 0,
2170 84, 210, 211, 85, 24, 0, 0, 0, 0, 0,
2171 0, 284, 0, 0, 196, 197, 0, 0, 0, 82,
2172 206, 207, 208, 209, 0, 0, 210, 211, 198, 0,
2173 0, 0, 0, 0, 199, 0, 0, 194, 195, 0,
2174 0, 200, 0, 0, 0, 201, 0, 0, 0, 0,
2175 0, 0, 84, 0, 0, 85, 24, 0, 0, 202,
2176 203, 0, 0, 204, 499, 0, 0, 0, 0, 0,
2177 0, 0, 206, 207, 208, 209, 0, 0, 210, 211,
2178 196, 197, 0, 0, 0, 82, 0, 0, 0, 194,
2179 195, 0, 0, 0, 198, 0, 0, 0, 0, 0,
2180 199, 0, 0, 0, 0, 0, 0, 200, 0, 0,
2181 0, 201, 0, 0, 0, 0, 0, 0, 84, 0,
2182 0, 85, 24, 0, 0, 202, 203, 0, 0, 204,
2183 636, 0, 196, 197, 0, 0, 0, 82, 206, 207,
2184 208, 209, 0, 0, 210, 211, 198, 0, 0, 0,
2185 0, 0, 199, 0, 0, 194, 195, 0, 0, 200,
2186 0, 0, 0, 201, 0, 0, 0, 0, 0, 0,
2187 84, 0, 0, 85, 24, 0, 0, 202, 203, 0,
2188 0, 204, 679, 0, 0, 0, 0, 0, 0, 0,
2189 206, 207, 208, 209, 0, 0, 210, 211, 196, 197,
2190 0, 0, 0, 82, 0, 0, 0, 194, 195, 0,
2191 0, 0, 198, 0, 0, 0, 0, 0, 199, 0,
2192 0, 0, 0, 0, 0, 200, 0, 0, 0, 201,
2193 0, 0, 0, 0, 0, 0, 84, 0, 0, 85,
2194 24, 0, 0, 202, 203, 0, 0, 204, 692, 0,
2195 196, 197, 0, 0, 0, 82, 206, 207, 208, 209,
2196 0, 0, 210, 211, 198, 0, 0, 0, 0, 0,
2197 199, 0, 0, 0, 0, 0, 0, 200, 0, 0,
2198 0, 201, 0, 0, 0, 0, 0, 0, 84, 0,
2199 0, 85, 24, 0, 0, 202, 203, 0, 0, 204,
2200 0, 5, 196, 197, 0, 0, 0, 82, 206, 207,
2201 208, 209, 0, 0, 210, 211, 198, 0, 0, 0,
2202 0, 0, 199, 0, 0, 0, 0, 0, 0, 200,
2203 0, 0, 0, 201, 0, 0, 0, 0, 0, 0,
2204 84, 0, 0, 85, 24, 0, 0, 0, 0, 0,
2205 0, 284, 0, 0, 0, 0, 0, 0, 0, 0,
2206 206, 207, 208, 209, 0, 0, 210, 211
2207 };
2208
2209 static const short yycheck[] =
2210 {
2211 6, 295, 205, 9, 66, 180, 136, 138, 175, 137,
2212 492, 66, 336, 315, 446, 127, 1, 133, 1, 121,
2213 46, 1, 1, 15, 50, 302, 1, 1, 1, 1,
2214 5, 93, 54, 310, 1, 312, 98, 1, 93, 668,
2215 46, 1, 68, 98, 50, 133, 162, 73, 1, 151,
2216 88, 676, 154, 169, 486, 1, 194, 0, 196, 197,
2217 66, 69, 68, 12, 202, 203, 1, 73, 76, 200,
2218 172, 133, 1, 133, 162, 137, 1, 99, 133, 88,
2219 99, 513, 137, 96, 103, 1, 1, 93, 37, 99,
2220 103, 1, 98, 103, 68, 1, 68, 89, 160, 728,
2221 162, 97, 162, 111, 2, 160, 132, 162, 0, 1,
2222 95, 1, 138, 88, 12, 13, 14, 100, 103, 1,
2223 175, 101, 184, 103, 103, 1, 132, 133, 101, 184,
2224 103, 137, 138, 261, 101, 102, 34, 101, 102, 37,
2225 38, 101, 624, 768, 97, 200, 7, 8, 101, 204,
2226 266, 1, 777, 45, 160, 101, 162, 55, 1, 88,
2227 262, 96, 337, 279, 56, 90, 1, 102, 66, 175,
2228 62, 1, 101, 285, 200, 213, 68, 609, 184, 40,
2229 41, 96, 88, 44, 76, 101, 96, 102, 194, 195,
2230 196, 197, 102, 54, 200, 101, 202, 203, 204, 261,
2231 98, 633, 1, 1, 66, 1, 261, 338, 336, 101,
2232 100, 643, 94, 95, 90, 1, 646, 99, 100, 101,
2233 102, 1, 83, 1, 102, 101, 87, 659, 1, 68,
2234 292, 93, 101, 102, 73, 133, 98, 292, 1, 137,
2235 295, 1, 1, 381, 382, 383, 413, 1, 286, 1,
2236 100, 94, 1, 96, 103, 261, 99, 100, 101, 102,
2237 315, 96, 1, 53, 162, 126, 127, 102, 1, 1,
2238 100, 133, 566, 1, 336, 137, 706, 175, 1, 709,
2239 73, 336, 143, 101, 102, 94, 292, 46, 47, 295,
2240 99, 100, 495, 132, 99, 88, 302, 96, 160, 601,
2241 162, 603, 100, 102, 310, 101, 312, 1, 1, 315,
2242 646, 743, 338, 175, 175, 101, 354, 355, 1, 180,
2243 175, 101, 184, 101, 362, 363, 1, 651, 101, 88,
2244 336, 90, 338, 445, 93, 94, 95, 100, 393, 1,
2245 99, 101, 97, 95, 103, 775, 101, 101, 642, 487,
2246 780, 100, 782, 97, 784, 96, 1, 96, 413, 646,
2247 53, 102, 223, 261, 97, 97, 102, 1, 96, 646,
2248 706, 64, 95, 709, 676, 381, 382, 383, 384, 385,
2249 386, 387, 388, 389, 390, 391, 392, 393, 394, 395,
2250 396, 397, 398, 399, 400, 1, 563, 295, 1, 261,
2251 1, 100, 64, 97, 97, 646, 1, 413, 53, 175,
2252 175, 95, 1, 274, 97, 1, 1, 315, 99, 706,
2253 281, 96, 709, 1, 285, 1, 1, 1, 1, 706,
2254 292, 1, 709, 295, 295, 97, 730, 66, 336, 775,
2255 295, 302, 480, 1, 780, 483, 782, 302, 784, 310,
2256 53, 312, 97, 315, 1, 310, 733, 312, 98, 45,
2257 315, 64, 96, 64, 580, 706, 768, 583, 709, 98,
2258 747, 95, 1, 96, 336, 777, 337, 1, 97, 102,
2259 99, 487, 68, 1, 761, 623, 492, 87, 775, 97,
2260 96, 352, 1, 780, 97, 782, 97, 784, 775, 88,
2261 95, 539, 54, 780, 133, 782, 636, 784, 563, 95,
2262 95, 566, 373, 96, 375, 413, 99, 95, 0, 1,
2263 95, 95, 95, 651, 61, 95, 126, 127, 65, 295,
2264 295, 393, 90, 162, 775, 45, 302, 302, 45, 780,
2265 102, 782, 51, 784, 310, 310, 312, 312, 95, 315,
2266 315, 413, 413, 683, 1, 62, 2, 563, 413, 88,
2267 566, 68, 678, 45, 1, 695, 12, 13, 14, 1,
2268 88, 95, 103, 1, 56, 84, 0, 1, 87, 88,
2269 62, 442, 1, 482, 445, 484, 68, 642, 34, 651,
2270 2, 37, 38, 8, 9, 10, 651, 1, 1, 1,
2271 12, 13, 14, 175, 1, 12, 96, 14, 133, 55,
2272 740, 1, 102, 668, 0, 1, 103, 623, 624, 101,
2273 66, 45, 34, 1, 103, 37, 38, 0, 1, 99,
2274 37, 1, 56, 639, 13, 160, 642, 162, 62, 1,
2275 646, 88, 11, 55, 68, 651, 1, 413, 413, 68,
2276 14, 88, 98, 98, 73, 45, 88, 102, 77, 45,
2277 88, 51, 668, 563, 1, 563, 566, 12, 566, 88,
2278 56, 97, 45, 728, 1, 730, 62, 101, 1, 95,
2279 1, 51, 68, 101, 88, 88, 88, 133, 101, 62,
2280 45, 88, 0, 1, 84, 68, 51, 87, 88, 1,
2281 706, 563, 563, 709, 566, 566, 96, 1, 563, 1,
2282 88, 566, 1, 96, 84, 101, 162, 87, 88, 102,
2283 175, 133, 728, 295, 730, 96, 88, 733, 101, 84,
2284 302, 102, 87, 88, 48, 1, 96, 45, 310, 99,
2285 312, 747, 642, 315, 642, 66, 601, 68, 603, 63,
2286 162, 88, 73, 651, 62, 761, 77, 0, 1, 95,
2287 68, 88, 96, 101, 66, 88, 68, 88, 102, 775,
2288 668, 73, 51, 48, 780, 77, 782, 99, 784, 640,
2289 642, 642, 0, 1, 98, 646, 88, 642, 63, 651,
2290 68, 646, 480, 101, 88, 483, 88, 563, 563, 88,
2291 566, 566, 45, 93, 94, 84, 668, 668, 87, 88,
2292 175, 98, 1, 668, 102, 706, 97, 98, 709, 62,
2293 101, 676, 88, 98, 97, 68, 67, 45, 13, 1,
2294 728, 95, 730, 93, 94, 601, 601, 603, 603, 96,
2295 295, 413, 99, 95, 62, 706, 103, 302, 709, 34,
2296 68, 706, 90, 38, 709, 310, 45, 312, 101, 95,
2297 315, 96, 51, 46, 47, 1, 728, 728, 730, 730,
2298 55, 95, 733, 728, 1, 730, 642, 642, 733, 101,
2299 646, 646, 96, 101, 775, 96, 747, 3, 4, 780,
2300 97, 782, 747, 784, 1, 84, 46, 47, 87, 88,
2301 761, 101, 668, 668, 95, 175, 761, 102, 99, 45,
2302 676, 676, 103, 768, 775, 51, 46, 47, 96, 780,
2303 775, 782, 777, 784, 60, 780, 62, 782, 97, 784,
2304 295, 57, 68, 5, 6, 7, 45, 302, 16, 17,
2305 706, 706, 51, 709, 709, 310, 57, 312, 84, 99,
2306 315, 87, 88, 103, 389, 390, 391, 392, 413, 93,
2307 94, 97, 728, 728, 730, 730, 175, 733, 733, 99,
2308 99, 100, 101, 103, 96, 84, 1, 101, 87, 88,
2309 1, 747, 747, 18, 19, 20, 21, 96, 386, 387,
2310 388, 563, 46, 47, 566, 761, 761, 46, 47, 96,
2311 144, 1, 768, 768, 99, 100, 96, 384, 385, 775,
2312 775, 777, 777, 96, 780, 780, 782, 782, 784, 784,
2313 45, 101, 101, 58, 57, 295, 51, 394, 395, 601,
2314 96, 603, 302, 96, 393, 60, 14, 62, 58, 79,
2315 310, 162, 312, 68, 143, 315, 261, 160, 413, 56,
2316 413, 98, 268, 295, 315, 666, 666, 315, 581, 84,
2317 204, 205, 87, 88, 581, 93, 94, 95, 396, 355,
2318 642, 99, 195, 88, 646, 103, 400, 45, 93, 94,
2319 95, 397, 399, 51, 99, 398, 295, -1, 103, 93,
2320 94, 95, 60, 302, 62, 99, 668, 639, 404, 103,
2321 68, 310, -1, 312, 676, -1, 315, 88, 563, -1,
2322 -1, 566, 93, 94, 95, -1, 84, -1, 99, 87,
2323 88, 45, 103, -1, -1, -1, -1, 51, 272, 97,
2324 98, 275, -1, 101, 706, -1, 60, 709, 62, 283,
2325 284, -1, -1, 413, 68, -1, 601, -1, 603, -1,
2326 -1, -1, -1, -1, -1, -1, 728, -1, 730, 1,
2327 84, 733, -1, 87, 88, 88, -1, -1, -1, -1,
2328 93, 94, 95, 97, 98, 747, 99, 101, -1, -1,
2329 103, -1, -1, -1, -1, -1, -1, 642, -1, 761,
2330 -1, 646, -1, -1, -1, -1, 768, -1, 563, -1,
2331 -1, 566, -1, 775, 413, 777, -1, -1, 780, 51,
2332 782, -1, 784, 668, -1, -1, -1, -1, 60, -1,
2333 -1, 676, -1, -1, 66, -1, -1, -1, 372, -1,
2334 -1, 73, 376, -1, -1, 77, 601, -1, 603, -1,
2335 -1, -1, 84, -1, -1, 87, 88, -1, -1, 91,
2336 92, 706, -1, 95, 709, -1, -1, 401, -1, -1,
2337 -1, -1, 104, 105, 106, 107, -1, -1, 110, 111,
2338 -1, -1, -1, 728, 418, 730, -1, 642, 733, -1,
2339 -1, 646, -1, -1, 428, -1, 430, -1, -1, -1,
2340 -1, -1, 747, 563, -1, 45, 566, -1, -1, -1,
2341 -1, 51, -1, 668, -1, -1, 761, -1, -1, -1,
2342 60, 676, 62, 768, -1, -1, -1, -1, 68, 463,
2343 775, 465, 777, -1, -1, 780, -1, 782, -1, 784,
2344 -1, 601, -1, 603, 84, 479, -1, 87, 88, -1,
2345 -1, 706, -1, -1, 709, -1, -1, 45, 98, -1,
2346 -1, 495, -1, 51, 563, -1, -1, 566, -1, -1,
2347 -1, -1, 60, 728, 62, 730, -1, -1, 733, -1,
2348 68, -1, 642, -1, -1, -1, 646, -1, -1, -1,
2349 -1, -1, 747, -1, -1, -1, 84, -1, -1, 87,
2350 88, -1, 601, -1, 603, -1, 761, -1, 668, -1,
2351 98, -1, -1, 768, -1, -1, 676, -1, -1, -1,
2352 775, -1, 777, -1, -1, 780, -1, 782, -1, 784,
2353 194, 195, 196, 197, -1, -1, -1, -1, 202, 203,
2354 -1, -1, -1, 642, -1, -1, 706, 646, -1, 709,
2355 194, 195, 196, 197, -1, 589, -1, -1, 202, 203,
2356 -1, -1, -1, -1, -1, -1, -1, -1, 728, 668,
2357 730, -1, -1, 733, -1, -1, -1, 676, -1, -1,
2358 -1, -1, -1, -1, -1, -1, -1, 747, -1, -1,
2359 -1, -1, -1, -1, -1, -1, 630, -1, -1, -1,
2360 -1, 761, -1, 3, 4, -1, -1, 706, 768, -1,
2361 709, -1, -1, -1, -1, 775, -1, 777, -1, -1,
2362 780, -1, 782, -1, 784, -1, -1, -1, -1, 728,
2363 664, 730, -1, -1, 733, -1, 670, -1, -1, -1,
2364 -1, -1, -1, -1, -1, -1, 46, 47, 747, -1,
2365 -1, 51, -1, -1, -1, -1, -1, -1, -1, -1,
2366 60, -1, 761, -1, -1, -1, 66, -1, -1, 768,
2367 -1, -1, -1, 73, -1, -1, 775, 77, 777, -1,
2368 -1, 780, -1, 782, 84, 784, -1, 87, 88, -1,
2369 -1, 91, 92, -1, -1, 95, -1, 97, 98, -1,
2370 -1, -1, 102, -1, 104, 105, 106, 107, -1, -1,
2371 110, 111, 746, -1, -1, 1, 750, 381, 382, 383,
2372 384, 385, 386, 387, 388, 389, 390, 391, 392, -1,
2373 394, 395, 396, 397, 398, 399, 400, 381, 382, 383,
2374 384, 385, 386, 387, 388, 389, 390, 391, 392, -1,
2375 394, 395, 396, 397, 398, 399, 400, -1, -1, 45,
2376 46, 47, 48, 49, 50, 51, 52, -1, -1, 55,
2377 -1, -1, -1, 59, 60, -1, -1, 63, -1, -1,
2378 66, 67, 68, 69, -1, 71, 72, 73, 74, -1,
2379 -1, 77, 78, -1, -1, -1, -1, -1, 84, -1,
2380 -1, 87, 88, -1, -1, 1, -1, -1, -1, 95,
2381 -1, 97, 98, -1, -1, 101, -1, -1, 104, 105,
2382 106, 107, -1, 487, 110, 111, -1, -1, 492, -1,
2383 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2384 -1, -1, -1, 487, -1, -1, -1, -1, 492, 45,
2385 46, 47, 48, 49, 50, 51, 52, -1, -1, 55,
2386 -1, -1, -1, 59, 60, -1, -1, 63, -1, -1,
2387 66, 67, 68, 69, -1, 71, 72, 73, 74, -1,
2388 -1, 77, 78, -1, -1, -1, -1, -1, 84, -1,
2389 -1, 87, 88, -1, -1, -1, -1, -1, -1, 95,
2390 -1, 97, 98, -1, -1, 101, -1, -1, 104, 105,
2391 106, 107, -1, 51, 110, 111, -1, -1, -1, -1,
2392 -1, -1, 60, -1, -1, -1, -1, -1, 66, -1,
2393 -1, -1, -1, -1, -1, 73, -1, -1, 1, 77,
2394 -1, -1, -1, -1, -1, -1, 84, -1, -1, 87,
2395 88, -1, -1, 91, 92, -1, -1, 95, -1, 623,
2396 624, -1, -1, -1, -1, -1, 104, 105, 106, 107,
2397 -1, -1, 110, 111, -1, 639, -1, -1, -1, 623,
2398 624, -1, 45, 46, 47, 48, 49, 50, 51, 52,
2399 -1, -1, 55, -1, -1, 639, 59, 60, -1, -1,
2400 63, -1, -1, 66, 67, 68, 69, 1, 71, 72,
2401 73, 74, -1, -1, 77, 78, -1, -1, -1, -1,
2402 -1, 84, -1, -1, 87, 88, -1, -1, -1, -1,
2403 -1, -1, 95, -1, 97, 98, -1, -1, 101, -1,
2404 -1, 104, 105, 106, 107, -1, -1, 110, 111, -1,
2405 -1, 45, 46, 47, -1, 49, 50, 51, 52, -1,
2406 -1, 55, -1, -1, -1, 59, 60, -1, -1, -1,
2407 -1, -1, 66, 67, 68, 69, 1, 71, 72, 73,
2408 74, -1, -1, 77, 78, -1, -1, -1, -1, -1,
2409 84, -1, -1, 87, 88, -1, -1, -1, -1, -1,
2410 -1, 95, -1, 97, 98, -1, -1, 101, -1, -1,
2411 104, 105, 106, 107, -1, -1, 110, 111, -1, -1,
2412 45, 46, 47, -1, 49, 50, 51, 52, -1, -1,
2413 55, -1, -1, -1, 59, 60, -1, -1, -1, -1,
2414 -1, 66, 67, 68, 69, 1, 71, 72, 73, 74,
2415 -1, -1, 77, 78, -1, -1, -1, -1, -1, 84,
2416 -1, -1, 87, 88, -1, -1, -1, -1, -1, -1,
2417 95, -1, 97, -1, -1, -1, 101, -1, -1, 104,
2418 105, 106, 107, -1, -1, 110, 111, -1, -1, 45,
2419 46, 47, -1, 49, 50, 51, 52, -1, -1, 55,
2420 -1, -1, -1, 59, 60, -1, -1, -1, -1, -1,
2421 66, 67, 1, 69, -1, 71, 72, 73, 74, -1,
2422 -1, 77, 78, -1, -1, -1, -1, -1, 84, -1,
2423 -1, 87, 88, -1, -1, -1, -1, -1, -1, 95,
2424 -1, 97, -1, -1, -1, 101, -1, -1, 104, 105,
2425 106, 107, -1, -1, 110, 111, 45, 46, 47, -1,
2426 49, 50, 51, 52, -1, -1, 55, -1, -1, -1,
2427 59, 60, -1, -1, -1, -1, -1, 66, 67, -1,
2428 69, -1, 71, 72, 73, 74, -1, -1, 77, 78,
2429 1, -1, 3, 4, -1, 84, -1, -1, 87, 88,
2430 -1, -1, -1, -1, -1, -1, 95, -1, 97, -1,
2431 -1, -1, 101, -1, -1, 104, 105, 106, 107, -1,
2432 -1, 110, 111, -1, -1, -1, -1, -1, -1, -1,
2433 -1, -1, -1, -1, -1, 46, 47, -1, -1, -1,
2434 51, -1, -1, -1, -1, -1, -1, -1, -1, 60,
2435 -1, -1, -1, -1, -1, 66, 1, -1, 3, 4,
2436 -1, -1, 73, -1, -1, -1, 77, -1, -1, -1,
2437 -1, -1, -1, 84, -1, -1, 87, 88, -1, -1,
2438 91, 92, -1, -1, 95, -1, 97, 98, -1, -1,
2439 -1, -1, -1, 104, 105, 106, 107, -1, -1, 110,
2440 111, 46, 47, -1, -1, -1, 51, -1, 1, -1,
2441 3, 4, -1, -1, -1, 60, -1, -1, -1, -1,
2442 -1, 66, -1, -1, -1, -1, -1, -1, 73, -1,
2443 -1, -1, 77, -1, -1, -1, -1, -1, -1, 84,
2444 -1, -1, 87, 88, -1, -1, 91, 92, -1, -1,
2445 95, -1, 97, 46, 47, -1, -1, -1, 51, 104,
2446 105, 106, 107, -1, -1, 110, 111, 60, -1, -1,
2447 -1, -1, -1, 66, 1, -1, 3, 4, -1, -1,
2448 73, -1, -1, -1, 77, -1, -1, -1, -1, -1,
2449 -1, 84, -1, -1, 87, 88, -1, -1, 91, 92,
2450 -1, -1, 95, -1, -1, -1, -1, -1, 101, -1,
2451 -1, 104, 105, 106, 107, -1, -1, 110, 111, 46,
2452 47, -1, -1, -1, 51, -1, 1, -1, 3, 4,
2453 -1, -1, -1, 60, -1, -1, -1, -1, -1, 66,
2454 -1, -1, -1, -1, -1, -1, 73, -1, -1, -1,
2455 77, -1, -1, -1, -1, -1, -1, 84, -1, -1,
2456 87, 88, -1, -1, 91, 92, -1, -1, 95, -1,
2457 -1, 46, 47, 100, -1, -1, 51, 104, 105, 106,
2458 107, -1, -1, 110, 111, 60, -1, -1, -1, -1,
2459 -1, 66, 1, -1, 3, 4, -1, -1, 73, -1,
2460 -1, -1, 77, -1, -1, -1, -1, -1, -1, 84,
2461 -1, -1, 87, 88, -1, 90, 91, 92, -1, -1,
2462 95, -1, -1, -1, -1, -1, -1, -1, -1, 104,
2463 105, 106, 107, -1, -1, 110, 111, 46, 47, -1,
2464 -1, -1, 51, -1, 1, -1, 3, 4, -1, -1,
2465 -1, 60, -1, -1, -1, -1, -1, 66, -1, -1,
2466 -1, -1, -1, -1, 73, -1, -1, -1, 77, -1,
2467 -1, -1, -1, -1, -1, 84, -1, -1, 87, 88,
2468 -1, -1, 91, 92, -1, -1, 95, 96, -1, 46,
2469 47, -1, -1, -1, 51, 104, 105, 106, 107, -1,
2470 -1, 110, 111, 60, -1, -1, -1, -1, -1, 66,
2471 1, -1, 3, 4, -1, -1, 73, -1, -1, -1,
2472 77, -1, -1, -1, -1, -1, -1, 84, -1, -1,
2473 87, 88, -1, -1, 91, 92, -1, -1, 95, -1,
2474 -1, -1, -1, -1, 101, -1, -1, 104, 105, 106,
2475 107, -1, -1, 110, 111, 46, 47, -1, -1, -1,
2476 51, -1, 1, -1, 3, 4, -1, -1, -1, 60,
2477 -1, -1, -1, -1, -1, 66, -1, -1, -1, -1,
2478 -1, -1, 73, -1, -1, -1, 77, -1, -1, -1,
2479 -1, -1, -1, 84, -1, -1, 87, 88, -1, -1,
2480 91, 92, -1, -1, 95, -1, -1, 46, 47, 100,
2481 -1, -1, 51, 104, 105, 106, 107, -1, -1, 110,
2482 111, 60, -1, -1, -1, -1, -1, 66, 1, -1,
2483 3, 4, -1, -1, 73, -1, -1, -1, 77, -1,
2484 -1, -1, -1, -1, -1, 84, -1, -1, 87, 88,
2485 -1, -1, 91, 92, -1, -1, 95, 96, -1, -1,
2486 -1, -1, -1, -1, -1, 104, 105, 106, 107, -1,
2487 -1, 110, 111, 46, 47, -1, -1, -1, 51, -1,
2488 1, -1, 3, 4, -1, -1, -1, 60, -1, -1,
2489 -1, -1, -1, 66, -1, -1, -1, -1, -1, -1,
2490 73, -1, -1, -1, 77, -1, -1, -1, -1, -1,
2491 -1, 84, -1, -1, 87, 88, -1, -1, 91, 92,
2492 -1, -1, 95, 96, -1, 46, 47, -1, -1, -1,
2493 51, 104, 105, 106, 107, -1, -1, 110, 111, 60,
2494 -1, -1, -1, -1, -1, 66, 1, -1, 3, 4,
2495 -1, -1, 73, -1, -1, -1, 77, -1, -1, -1,
2496 -1, -1, -1, 84, -1, -1, 87, 88, -1, -1,
2497 91, 92, -1, -1, 95, 96, -1, -1, -1, -1,
2498 -1, -1, -1, 104, 105, 106, 107, -1, -1, 110,
2499 111, 46, 47, -1, -1, -1, 51, -1, 1, -1,
2500 3, 4, -1, -1, -1, 60, -1, -1, -1, -1,
2501 -1, 66, -1, -1, -1, -1, -1, -1, 73, -1,
2502 -1, -1, 77, -1, -1, -1, -1, -1, -1, 84,
2503 -1, -1, 87, 88, -1, -1, 91, 92, -1, -1,
2504 95, 96, -1, 46, 47, -1, -1, -1, 51, 104,
2505 105, 106, 107, -1, -1, 110, 111, 60, -1, -1,
2506 -1, -1, -1, 66, 1, -1, 3, 4, -1, -1,
2507 73, -1, -1, -1, 77, -1, -1, -1, -1, -1,
2508 -1, 84, -1, -1, 87, 88, -1, -1, 91, 92,
2509 -1, -1, 95, -1, -1, -1, -1, -1, 101, -1,
2510 -1, 104, 105, 106, 107, -1, -1, 110, 111, 46,
2511 47, -1, -1, -1, 51, -1, 1, -1, 3, 4,
2512 -1, -1, -1, 60, -1, -1, -1, -1, -1, 66,
2513 -1, -1, -1, -1, -1, -1, 73, -1, -1, -1,
2514 77, -1, -1, -1, -1, -1, -1, 84, -1, -1,
2515 87, 88, -1, -1, 91, 92, -1, -1, 95, -1,
2516 -1, 46, 47, -1, -1, -1, 51, 104, 105, 106,
2517 107, -1, -1, 110, 111, 60, -1, -1, -1, -1,
2518 -1, 66, 1, -1, 3, 4, -1, -1, 73, -1,
2519 -1, -1, 77, -1, -1, -1, -1, -1, -1, 84,
2520 -1, -1, 87, 88, -1, -1, 91, 92, -1, -1,
2521 95, -1, -1, -1, -1, -1, -1, -1, -1, 104,
2522 105, 106, 107, -1, -1, 110, 111, 46, 47, -1,
2523 -1, -1, 51, -1, 1, -1, 3, 4, -1, -1,
2524 -1, 60, -1, -1, -1, -1, -1, 66, -1, -1,
2525 -1, -1, -1, -1, 73, -1, -1, -1, 77, -1,
2526 -1, -1, -1, -1, -1, 84, -1, -1, 87, 88,
2527 -1, -1, 91, 92, -1, -1, 95, -1, -1, 46,
2528 47, -1, -1, -1, 51, 104, 105, 106, 107, -1,
2529 -1, 110, 111, 60, -1, -1, -1, -1, -1, 66,
2530 1, -1, 3, 4, -1, -1, 73, -1, -1, -1,
2531 77, -1, -1, -1, -1, -1, -1, 84, -1, -1,
2532 87, 88, -1, -1, 91, 92, -1, -1, 95, -1,
2533 -1, -1, -1, -1, -1, -1, -1, 104, 105, 106,
2534 107, -1, -1, 110, 111, 46, 47, -1, -1, -1,
2535 51, -1, 1, -1, 3, 4, -1, -1, -1, 60,
2536 -1, -1, -1, -1, -1, 66, -1, -1, -1, -1,
2537 -1, -1, 73, -1, -1, -1, 77, -1, -1, -1,
2538 -1, -1, -1, 84, -1, -1, 87, 88, -1, -1,
2539 91, 92, -1, -1, 95, -1, -1, 46, 47, -1,
2540 -1, -1, 51, 104, 105, 106, 107, -1, -1, 110,
2541 111, 60, -1, -1, -1, -1, -1, 66, 1, -1,
2542 3, 4, -1, -1, 73, -1, -1, -1, 77, -1,
2543 -1, -1, -1, -1, -1, 84, -1, -1, 87, 88,
2544 -1, -1, 91, 92, -1, -1, 95, -1, -1, -1,
2545 -1, -1, -1, -1, -1, 104, 105, 106, 107, -1,
2546 -1, 110, 111, 46, 47, -1, -1, -1, 51, -1,
2547 1, -1, 3, 4, -1, -1, -1, 60, -1, -1,
2548 -1, -1, -1, 66, -1, -1, -1, -1, -1, -1,
2549 73, -1, -1, -1, 77, -1, -1, -1, -1, -1,
2550 -1, 84, -1, -1, 87, 88, -1, -1, 91, 92,
2551 -1, -1, 95, -1, -1, 46, 47, -1, -1, -1,
2552 51, 104, 105, 106, 107, -1, -1, 110, 111, 60,
2553 -1, -1, -1, -1, -1, 66, 1, -1, 3, 4,
2554 -1, -1, 73, -1, -1, -1, 77, -1, -1, -1,
2555 -1, -1, -1, 84, -1, -1, 87, 88, -1, -1,
2556 91, 92, -1, -1, 95, -1, -1, -1, -1, -1,
2557 -1, -1, -1, 104, 105, 106, 107, -1, -1, 110,
2558 111, 46, 47, -1, -1, -1, 51, -1, 1, -1,
2559 3, 4, -1, -1, -1, 60, -1, -1, -1, -1,
2560 -1, 66, -1, -1, -1, -1, -1, -1, 73, -1,
2561 -1, -1, 77, -1, -1, -1, -1, -1, -1, 84,
2562 -1, -1, 87, 88, -1, -1, 91, 92, -1, -1,
2563 95, -1, -1, 46, 47, -1, -1, -1, 51, 104,
2564 105, 106, 107, -1, -1, 110, 111, 60, -1, -1,
2565 -1, -1, -1, 66, 1, -1, 3, 4, -1, -1,
2566 73, -1, -1, -1, 77, -1, -1, -1, -1, -1,
2567 -1, 84, -1, -1, 87, 88, -1, -1, 91, 92,
2568 -1, -1, 95, -1, -1, -1, -1, -1, -1, -1,
2569 -1, 104, 105, 106, 107, -1, -1, 110, 111, 46,
2570 47, -1, -1, -1, 51, -1, 1, -1, 3, 4,
2571 -1, -1, -1, 60, -1, -1, -1, -1, -1, 66,
2572 -1, -1, -1, -1, -1, -1, 73, -1, -1, -1,
2573 77, -1, -1, -1, -1, -1, -1, 84, -1, -1,
2574 87, 88, -1, -1, 91, 92, -1, -1, 95, -1,
2575 -1, 46, 47, -1, -1, -1, 51, 104, 105, 106,
2576 107, -1, -1, 110, 111, 60, -1, -1, -1, -1,
2577 -1, 66, 1, -1, 3, 4, -1, -1, 73, -1,
2578 -1, -1, 77, -1, -1, -1, -1, -1, -1, 84,
2579 -1, -1, 87, 88, -1, -1, 91, 92, -1, -1,
2580 95, -1, -1, -1, -1, -1, -1, -1, -1, 104,
2581 105, 106, 107, -1, -1, 110, 111, 46, 47, -1,
2582 -1, -1, 51, -1, 1, -1, 3, 4, -1, -1,
2583 -1, 60, -1, -1, -1, -1, -1, 66, -1, -1,
2584 -1, -1, -1, -1, 73, -1, -1, -1, 77, -1,
2585 -1, -1, -1, -1, -1, 84, -1, -1, 87, 88,
2586 -1, -1, 91, 92, -1, -1, 95, -1, -1, 46,
2587 47, -1, -1, -1, 51, 104, 105, 106, 107, -1,
2588 -1, 110, 111, 60, -1, -1, -1, -1, -1, 66,
2589 1, -1, 3, 4, -1, -1, 73, -1, -1, -1,
2590 77, -1, -1, -1, -1, -1, -1, 84, -1, -1,
2591 87, 88, -1, -1, 91, 92, -1, -1, 95, -1,
2592 -1, -1, -1, -1, -1, -1, -1, 104, 105, 106,
2593 107, -1, -1, 110, 111, 46, 47, -1, -1, -1,
2594 51, -1, 1, -1, 3, 4, -1, -1, -1, 60,
2595 -1, -1, -1, -1, -1, 66, -1, -1, -1, -1,
2596 -1, -1, 73, -1, -1, -1, 77, -1, -1, -1,
2597 -1, -1, -1, 84, -1, -1, 87, 88, -1, -1,
2598 91, 92, -1, -1, 95, -1, -1, 46, 47, -1,
2599 -1, -1, 51, 104, 105, 106, 107, -1, -1, 110,
2600 111, 60, -1, -1, -1, -1, -1, 66, 1, -1,
2601 3, 4, -1, -1, 73, -1, -1, -1, 77, -1,
2602 -1, -1, -1, -1, -1, 84, -1, -1, 87, 88,
2603 -1, -1, 91, 92, -1, -1, 95, -1, -1, -1,
2604 -1, -1, -1, -1, -1, 104, 105, 106, 107, -1,
2605 -1, 110, 111, 46, 47, -1, -1, -1, 51, -1,
2606 1, -1, 3, 4, -1, -1, -1, 60, -1, -1,
2607 -1, -1, -1, 66, -1, -1, -1, -1, -1, -1,
2608 73, -1, -1, -1, 77, -1, -1, -1, -1, -1,
2609 -1, 84, -1, -1, 87, 88, -1, -1, 91, 92,
2610 -1, -1, 95, -1, -1, 46, 47, -1, -1, -1,
2611 51, 104, 105, 106, 107, -1, -1, 110, 111, 60,
2612 -1, -1, -1, -1, -1, 66, 1, -1, 3, 4,
2613 -1, -1, 73, -1, -1, -1, 77, -1, -1, -1,
2614 -1, -1, -1, 84, -1, -1, 87, 88, -1, -1,
2615 91, 92, -1, -1, 95, -1, -1, -1, -1, -1,
2616 -1, -1, -1, 104, 105, 106, 107, -1, -1, 110,
2617 111, 46, 47, -1, -1, -1, 51, -1, 1, -1,
2618 3, 4, -1, -1, -1, 60, -1, -1, -1, -1,
2619 -1, 66, -1, -1, -1, -1, -1, -1, 73, -1,
2620 -1, -1, 77, -1, -1, -1, -1, -1, -1, 84,
2621 -1, -1, 87, 88, -1, -1, 91, 92, -1, -1,
2622 95, -1, -1, 46, 47, -1, -1, -1, 51, 104,
2623 105, 106, 107, -1, -1, 110, 111, 60, -1, -1,
2624 -1, -1, -1, 66, 1, -1, 3, 4, -1, -1,
2625 73, -1, -1, -1, 77, -1, -1, -1, -1, -1,
2626 -1, 84, -1, -1, 87, 88, -1, -1, 91, 92,
2627 -1, -1, 95, -1, -1, -1, -1, -1, -1, -1,
2628 -1, 104, 105, 106, 107, -1, -1, 110, 111, 46,
2629 47, -1, -1, -1, 51, -1, 1, -1, 3, 4,
2630 -1, -1, -1, 60, -1, -1, -1, -1, -1, 66,
2631 -1, -1, -1, -1, -1, -1, 73, -1, -1, -1,
2632 77, -1, -1, -1, -1, -1, -1, 84, -1, -1,
2633 87, 88, -1, -1, 91, 92, -1, -1, 95, -1,
2634 -1, 46, 47, -1, -1, -1, 51, 104, 105, 106,
2635 107, -1, -1, 110, 111, 60, -1, -1, -1, -1,
2636 -1, 66, 1, -1, 3, 4, -1, -1, 73, -1,
2637 -1, -1, 77, -1, -1, -1, -1, -1, -1, 84,
2638 -1, -1, 87, 88, -1, -1, 91, 92, -1, -1,
2639 95, -1, -1, -1, -1, -1, -1, -1, -1, 104,
2640 105, 106, 107, -1, -1, 110, 111, 46, 47, -1,
2641 -1, -1, 51, -1, 1, -1, 3, 4, -1, -1,
2642 -1, 60, -1, -1, -1, -1, -1, 66, -1, -1,
2643 -1, -1, -1, -1, 73, -1, -1, -1, 77, -1,
2644 -1, -1, -1, -1, -1, 84, -1, -1, 87, 88,
2645 -1, -1, 91, 92, -1, -1, 95, -1, -1, 46,
2646 47, -1, -1, -1, 51, 104, 105, 106, 107, -1,
2647 -1, 110, 111, 60, -1, -1, -1, -1, -1, 66,
2648 1, -1, 3, 4, -1, -1, 73, -1, -1, -1,
2649 77, -1, -1, -1, -1, -1, -1, 84, -1, -1,
2650 87, 88, -1, -1, 91, 92, -1, -1, 95, -1,
2651 -1, -1, -1, -1, -1, -1, -1, 104, 105, 106,
2652 107, -1, -1, 110, 111, 46, 47, -1, -1, -1,
2653 51, -1, 1, -1, 3, 4, -1, -1, -1, 60,
2654 -1, -1, -1, -1, -1, 66, -1, -1, -1, -1,
2655 -1, -1, 73, -1, -1, -1, 77, -1, -1, -1,
2656 -1, -1, -1, 84, -1, -1, 87, 88, -1, -1,
2657 91, 92, -1, -1, 95, -1, -1, 46, 47, -1,
2658 -1, -1, 51, 104, 105, 106, 107, -1, -1, 110,
2659 111, 60, -1, -1, -1, -1, -1, 66, 1, -1,
2660 3, 4, -1, -1, 73, -1, -1, -1, 77, -1,
2661 -1, -1, -1, -1, -1, 84, -1, -1, 87, 88,
2662 -1, -1, 91, 92, -1, -1, 95, -1, -1, -1,
2663 -1, -1, -1, -1, -1, 104, 105, 106, 107, -1,
2664 -1, 110, 111, 46, 47, -1, -1, -1, 51, -1,
2665 1, -1, 3, 4, -1, -1, -1, 60, -1, -1,
2666 -1, -1, -1, 66, -1, -1, -1, -1, -1, -1,
2667 73, -1, -1, -1, 77, -1, -1, -1, -1, -1,
2668 -1, 84, -1, -1, 87, 88, -1, -1, 91, 92,
2669 -1, -1, 95, -1, -1, 46, 47, -1, -1, -1,
2670 51, 104, 105, 106, 107, -1, -1, 110, 111, 60,
2671 -1, -1, -1, -1, -1, 66, 1, -1, 3, 4,
2672 -1, -1, 73, -1, -1, -1, 77, -1, -1, -1,
2673 -1, -1, -1, 84, -1, -1, 87, 88, -1, -1,
2674 91, 92, -1, -1, 95, -1, -1, -1, -1, -1,
2675 -1, -1, -1, 104, 105, 106, 107, -1, -1, 110,
2676 111, 46, 47, -1, -1, -1, 51, -1, 1, -1,
2677 3, 4, -1, -1, -1, 60, -1, -1, -1, -1,
2678 -1, 66, -1, -1, -1, -1, -1, -1, 73, -1,
2679 -1, -1, 77, -1, -1, -1, -1, -1, -1, 84,
2680 -1, -1, 87, 88, -1, -1, 91, 92, -1, -1,
2681 95, -1, -1, 46, 47, -1, -1, -1, 51, 104,
2682 105, 106, 107, -1, -1, 110, 111, 60, -1, -1,
2683 -1, -1, -1, 66, 1, -1, 3, 4, -1, -1,
2684 73, -1, -1, -1, 77, -1, -1, -1, -1, -1,
2685 -1, 84, -1, -1, 87, 88, -1, -1, 91, 92,
2686 -1, -1, 95, -1, -1, -1, -1, -1, -1, -1,
2687 -1, 104, 105, 106, 107, -1, -1, 110, 111, 46,
2688 47, -1, -1, -1, 51, -1, 1, -1, 3, 4,
2689 -1, -1, -1, 60, -1, -1, -1, -1, -1, 66,
2690 -1, -1, -1, -1, -1, -1, 73, -1, -1, -1,
2691 77, -1, -1, -1, -1, -1, -1, 84, -1, -1,
2692 87, 88, -1, -1, 91, 92, -1, -1, 95, -1,
2693 -1, 46, 47, -1, -1, -1, 51, 104, 105, 106,
2694 107, -1, -1, 110, 111, 60, -1, -1, -1, -1,
2695 -1, 66, 1, -1, 3, 4, -1, -1, 73, -1,
2696 -1, -1, 77, -1, -1, -1, -1, -1, -1, 84,
2697 -1, -1, 87, 88, -1, -1, 91, 92, -1, -1,
2698 95, -1, -1, -1, -1, -1, -1, -1, -1, 104,
2699 105, 106, 107, -1, -1, 110, 111, 46, 47, -1,
2700 -1, -1, 51, -1, 1, -1, 3, 4, -1, -1,
2701 -1, 60, -1, -1, -1, -1, -1, 66, -1, -1,
2702 -1, -1, -1, -1, 73, -1, -1, -1, 77, -1,
2703 -1, -1, -1, -1, -1, 84, -1, -1, 87, 88,
2704 -1, -1, 91, 92, -1, -1, 95, -1, -1, 46,
2705 47, -1, -1, -1, 51, 104, 105, 106, 107, -1,
2706 -1, 110, 111, 60, -1, -1, -1, -1, -1, 66,
2707 1, -1, 3, 4, -1, -1, 73, -1, -1, -1,
2708 77, -1, -1, -1, -1, -1, -1, 84, -1, -1,
2709 87, 88, -1, -1, 91, 92, -1, -1, 95, -1,
2710 -1, -1, -1, -1, -1, -1, -1, 104, 105, 106,
2711 107, -1, -1, 110, 111, 46, 47, -1, -1, -1,
2712 51, -1, 1, -1, 3, 4, -1, -1, -1, 60,
2713 -1, -1, -1, -1, -1, 66, -1, -1, -1, -1,
2714 -1, -1, 73, -1, -1, -1, 77, -1, -1, -1,
2715 -1, -1, -1, 84, -1, -1, 87, 88, -1, -1,
2716 91, 92, -1, -1, 95, -1, -1, 46, 47, -1,
2717 -1, -1, 51, 104, 105, 106, 107, -1, -1, 110,
2718 111, 60, -1, -1, -1, -1, -1, 66, 1, -1,
2719 3, 4, -1, -1, 73, -1, -1, -1, 77, -1,
2720 -1, -1, -1, -1, -1, 84, -1, -1, 87, 88,
2721 -1, -1, 91, 92, -1, -1, 95, -1, -1, -1,
2722 -1, -1, -1, -1, -1, 104, 105, 106, 107, -1,
2723 -1, 110, 111, 46, 47, -1, -1, -1, 51, -1,
2724 1, -1, 3, 4, -1, -1, -1, 60, -1, -1,
2725 -1, -1, -1, 66, -1, -1, -1, -1, -1, -1,
2726 73, -1, -1, -1, 77, -1, -1, -1, -1, -1,
2727 -1, 84, -1, -1, 87, 88, -1, -1, 91, 92,
2728 -1, -1, 95, -1, -1, 46, 47, -1, -1, -1,
2729 51, 104, 105, 106, 107, -1, -1, 110, 111, 60,
2730 -1, -1, 1, -1, 3, 66, -1, -1, -1, -1,
2731 -1, -1, 73, -1, -1, -1, 77, -1, -1, -1,
2732 -1, -1, -1, 84, -1, -1, 87, 88, -1, -1,
2733 91, 92, -1, -1, 95, -1, -1, -1, -1, -1,
2734 -1, -1, -1, 104, 105, 106, 107, 46, 47, 110,
2735 111, -1, 51, -1, 1, -1, -1, -1, -1, -1,
2736 -1, 60, -1, -1, -1, -1, -1, 66, -1, -1,
2737 -1, -1, -1, -1, 73, -1, -1, -1, 77, 1,
2738 -1, -1, -1, -1, -1, 84, -1, -1, 87, 88,
2739 -1, -1, 91, 92, -1, -1, 95, -1, 45, 46,
2740 47, -1, -1, -1, 51, 104, 105, 106, 107, -1,
2741 -1, 110, 111, 60, -1, -1, -1, -1, -1, 66,
2742 -1, -1, 1, -1, 46, 47, 73, -1, -1, 51,
2743 77, -1, -1, -1, -1, -1, -1, 84, 60, -1,
2744 87, 88, -1, -1, 66, -1, -1, 1, 95, -1,
2745 -1, 73, -1, -1, 101, 77, -1, 104, 105, 106,
2746 107, -1, 84, 110, 111, 87, 88, 46, 47, -1,
2747 -1, -1, 51, 95, 96, -1, -1, -1, -1, -1,
2748 -1, 60, 104, 105, 106, 107, -1, 66, 110, 111,
2749 -1, -1, 46, 47, 73, -1, -1, 51, 77, -1,
2750 -1, 3, 4, -1, -1, 84, 60, -1, 87, 88,
2751 -1, -1, 66, -1, -1, -1, 95, 96, -1, 73,
2752 -1, -1, -1, 77, -1, 104, 105, 106, 107, -1,
2753 84, 110, 111, 87, 88, -1, -1, -1, -1, -1,
2754 -1, 95, -1, -1, 46, 47, -1, -1, -1, 51,
2755 104, 105, 106, 107, -1, -1, 110, 111, 60, -1,
2756 -1, -1, -1, -1, 66, -1, -1, 3, 4, -1,
2757 -1, 73, -1, -1, -1, 77, -1, -1, -1, -1,
2758 -1, -1, 84, -1, -1, 87, 88, -1, -1, 91,
2759 92, -1, -1, 95, 96, -1, -1, -1, -1, -1,
2760 -1, -1, 104, 105, 106, 107, -1, -1, 110, 111,
2761 46, 47, -1, -1, -1, 51, -1, -1, -1, 3,
2762 4, -1, -1, -1, 60, -1, -1, -1, -1, -1,
2763 66, -1, -1, -1, -1, -1, -1, 73, -1, -1,
2764 -1, 77, -1, -1, -1, -1, -1, -1, 84, -1,
2765 -1, 87, 88, -1, -1, 91, 92, -1, -1, 95,
2766 96, -1, 46, 47, -1, -1, -1, 51, 104, 105,
2767 106, 107, -1, -1, 110, 111, 60, -1, -1, -1,
2768 -1, -1, 66, -1, -1, 3, 4, -1, -1, 73,
2769 -1, -1, -1, 77, -1, -1, -1, -1, -1, -1,
2770 84, -1, -1, 87, 88, -1, -1, 91, 92, -1,
2771 -1, 95, 96, -1, -1, -1, -1, -1, -1, -1,
2772 104, 105, 106, 107, -1, -1, 110, 111, 46, 47,
2773 -1, -1, -1, 51, -1, -1, -1, 3, 4, -1,
2774 -1, -1, 60, -1, -1, -1, -1, -1, 66, -1,
2775 -1, -1, -1, -1, -1, 73, -1, -1, -1, 77,
2776 -1, -1, -1, -1, -1, -1, 84, -1, -1, 87,
2777 88, -1, -1, 91, 92, -1, -1, 95, 96, -1,
2778 46, 47, -1, -1, -1, 51, 104, 105, 106, 107,
2779 -1, -1, 110, 111, 60, -1, -1, -1, -1, -1,
2780 66, -1, -1, -1, -1, -1, -1, 73, -1, -1,
2781 -1, 77, -1, -1, -1, -1, -1, -1, 84, -1,
2782 -1, 87, 88, -1, -1, 91, 92, -1, -1, 95,
2783 -1, 45, 46, 47, -1, -1, -1, 51, 104, 105,
2784 106, 107, -1, -1, 110, 111, 60, -1, -1, -1,
2785 -1, -1, 66, -1, -1, -1, -1, -1, -1, 73,
2786 -1, -1, -1, 77, -1, -1, -1, -1, -1, -1,
2787 84, -1, -1, 87, 88, -1, -1, -1, -1, -1,
2788 -1, 95, -1, -1, -1, -1, -1, -1, -1, -1,
2789 104, 105, 106, 107, -1, -1, 110, 111
2790 };
2791
2792 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2793 symbol of state STATE-NUM. */
2794 static const unsigned short yystos[] =
2795 {
2796 0, 113, 114, 0, 1, 45, 56, 62, 68, 76,
2797 101, 127, 128, 129, 130, 131, 132, 133, 134, 135,
2798 136, 171, 194, 1, 88, 123, 124, 125, 126, 126,
2799 1, 126, 1, 123, 129, 131, 134, 128, 129, 45,
2800 62, 68, 1, 101, 103, 1, 64, 172, 176, 1,
2801 64, 139, 1, 101, 103, 129, 126, 1, 126, 1,
2802 5, 126, 1, 119, 121, 123, 97, 177, 102, 174,
2803 1, 119, 120, 53, 140, 1, 173, 176, 1, 139,
2804 1, 101, 51, 60, 84, 87, 98, 116, 117, 118,
2805 119, 122, 123, 135, 136, 146, 153, 171, 178, 179,
2806 180, 181, 1, 121, 177, 1, 1, 121, 141, 138,
2807 177, 175, 140, 1, 126, 154, 1, 126, 147, 148,
2808 149, 154, 99, 247, 247, 1, 60, 116, 1, 101,
2809 98, 179, 102, 97, 142, 177, 137, 95, 54, 99,
2810 158, 1, 101, 102, 94, 99, 100, 158, 100, 99,
2811 1, 154, 1, 147, 154, 1, 121, 97, 98, 124,
2812 135, 136, 143, 144, 145, 146, 151, 153, 161, 162,
2813 163, 165, 166, 171, 184, 185, 194, 142, 1, 96,
2814 116, 135, 155, 156, 157, 1, 120, 159, 1, 100,
2815 1, 126, 148, 1, 3, 4, 46, 47, 60, 66,
2816 73, 77, 91, 92, 95, 97, 104, 105, 106, 107,
2817 110, 111, 115, 117, 122, 123, 150, 182, 235, 236,
2818 237, 238, 239, 242, 244, 248, 249, 250, 251, 252,
2819 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
2820 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
2821 273, 275, 1, 100, 1, 1, 100, 158, 101, 158,
2822 98, 95, 166, 98, 144, 1, 152, 184, 164, 158,
2823 1, 49, 50, 52, 55, 59, 66, 67, 69, 71,
2824 72, 74, 77, 78, 95, 116, 117, 122, 123, 126,
2825 135, 136, 157, 170, 184, 187, 188, 189, 190, 191,
2826 193, 194, 195, 196, 198, 199, 200, 201, 203, 205,
2827 211, 212, 214, 215, 216, 218, 219, 223, 224, 225,
2828 226, 227, 228, 229, 230, 238, 249, 251, 252, 253,
2829 256, 257, 272, 1, 149, 96, 102, 116, 102, 1,
2830 123, 248, 250, 255, 1, 254, 1, 255, 1, 255,
2831 103, 1, 103, 1, 117, 119, 120, 1, 255, 1,
2832 255, 1, 117, 123, 275, 98, 102, 150, 183, 103,
2833 103, 95, 99, 103, 1, 103, 99, 1, 126, 46,
2834 47, 5, 6, 7, 3, 4, 8, 9, 10, 18,
2835 19, 20, 21, 58, 16, 17, 11, 12, 13, 14,
2836 15, 89, 93, 94, 274, 96, 155, 158, 101, 160,
2837 184, 97, 167, 185, 97, 98, 101, 1, 95, 1,
2838 275, 1, 101, 126, 1, 101, 275, 1, 95, 1,
2839 95, 1, 184, 1, 95, 1, 101, 126, 1, 275,
2840 275, 147, 103, 1, 90, 116, 95, 98, 186, 188,
2841 101, 123, 135, 191, 101, 204, 191, 191, 123, 190,
2842 199, 220, 222, 101, 1, 95, 1, 156, 1, 149,
2843 1, 120, 1, 68, 1, 126, 99, 100, 101, 99,
2844 245, 246, 247, 245, 247, 1, 95, 96, 99, 247,
2845 247, 1, 96, 98, 98, 102, 1, 68, 68, 96,
2846 243, 275, 1, 275, 1, 68, 73, 77, 73, 126,
2847 1, 275, 1, 95, 1, 255, 1, 255, 1, 255,
2848 1, 260, 1, 260, 1, 261, 1, 261, 1, 261,
2849 1, 262, 1, 262, 1, 262, 1, 262, 1, 117,
2850 118, 1, 263, 1, 263, 1, 264, 1, 265, 1,
2851 266, 1, 267, 1, 268, 1, 90, 275, 1, 271,
2852 96, 123, 168, 169, 170, 186, 187, 1, 275, 1,
2853 101, 1, 101, 1, 101, 1, 275, 1, 275, 61,
2854 65, 231, 232, 233, 234, 1, 1, 101, 1, 90,
2855 101, 96, 66, 147, 1, 96, 243, 97, 206, 67,
2856 1, 102, 1, 101, 275, 1, 275, 96, 103, 95,
2857 1, 275, 246, 247, 182, 247, 182, 1, 96, 243,
2858 1, 255, 1, 96, 96, 258, 1, 98, 150, 96,
2859 102, 1, 100, 95, 1, 100, 96, 243, 1, 90,
2860 103, 168, 187, 95, 168, 1, 96, 1, 96, 96,
2861 1, 95, 1, 184, 232, 234, 184, 275, 1, 95,
2862 1, 1, 96, 48, 63, 98, 207, 208, 209, 210,
2863 95, 1, 199, 1, 221, 222, 101, 96, 96, 96,
2864 243, 1, 100, 241, 1, 96, 1, 255, 1, 258,
2865 1, 275, 96, 243, 142, 96, 1, 270, 66, 168,
2866 96, 243, 49, 191, 192, 193, 195, 197, 202, 211,
2867 213, 217, 219, 1, 1, 156, 101, 1, 96, 243,
2868 1, 1, 90, 1, 275, 276, 98, 208, 209, 98,
2869 187, 210, 275, 96, 1, 221, 1, 184, 96, 142,
2870 240, 96, 142, 95, 101, 96, 95, 57, 192, 192,
2871 101, 96, 96, 1, 1, 96, 1, 90, 98, 96,
2872 191, 96, 142, 96, 243, 101, 275, 191, 101, 275,
2873 1, 101, 191, 101, 96, 96, 221, 101, 101, 192,
2874 96, 221, 57, 192, 96, 192, 192
2875 };
2876
2877 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
2878 # define YYSIZE_T __SIZE_TYPE__
2879 #endif
2880 #if ! defined (YYSIZE_T) && defined (size_t)
2881 # define YYSIZE_T size_t
2882 #endif
2883 #if ! defined (YYSIZE_T)
2884 # if defined (__STDC__) || defined (__cplusplus)
2885 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
2886 # define YYSIZE_T size_t
2887 # endif
2888 #endif
2889 #if ! defined (YYSIZE_T)
2890 # define YYSIZE_T unsigned int
2891 #endif
2892
2893 #define yyerrok (yyerrstatus = 0)
2894 #define yyclearin (yychar = YYEMPTY)
2895 #define YYEMPTY -2
2896 #define YYEOF 0
2897
2898 #define YYACCEPT goto yyacceptlab
2899 #define YYABORT goto yyabortlab
2900 #define YYERROR goto yyerrlab1
2901
2902 /* Like YYERROR except do call yyerror. This remains here temporarily
2903 to ease the transition to the new meaning of YYERROR, for GCC.
2904 Once GCC version 2 has supplanted version 1, this can go. */
2905
2906 #define YYFAIL goto yyerrlab
2907
2908 #define YYRECOVERING() (!!yyerrstatus)
2909
2910 #define YYBACKUP(Token, Value) \
2911 do \
2912 if (yychar == YYEMPTY && yylen == 1) \
2913 { \
2914 yychar = (Token); \
2915 yylval = (Value); \
2916 yychar1 = YYTRANSLATE (yychar); \
2917 YYPOPSTACK; \
2918 goto yybackup; \
2919 } \
2920 else \
2921 { \
2922 yyerror ("syntax error: cannot back up"); \
2923 YYERROR; \
2924 } \
2925 while (0)
2926
2927 #define YYTERROR 1
2928 #define YYERRCODE 256
2929
2930 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
2931 are run). */
2932
2933 #ifndef YYLLOC_DEFAULT
2934 # define YYLLOC_DEFAULT(Current, Rhs, N) \
2935 Current.first_line = Rhs[1].first_line; \
2936 Current.first_column = Rhs[1].first_column; \
2937 Current.last_line = Rhs[N].last_line; \
2938 Current.last_column = Rhs[N].last_column;
2939 #endif
2940
2941 /* YYLEX -- calling `yylex' with the right arguments. */
2942
2943 #ifdef YYLEX_PARAM
2944 # define YYLEX yylex (&yylval, YYLEX_PARAM)
2945 #else
2946 # define YYLEX yylex (&yylval)
2947 #endif
2948
2949 /* Enable debugging if requested. */
2950 #if YYDEBUG
2951
2952 # ifndef YYFPRINTF
2953 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
2954 # define YYFPRINTF fprintf
2955 # endif
2956
2957 # define YYDPRINTF(Args) \
2958 do { \
2959 if (yydebug) \
2960 YYFPRINTF Args; \
2961 } while (0)
2962 # define YYDSYMPRINT(Args) \
2963 do { \
2964 if (yydebug) \
2965 yysymprint Args; \
2966 } while (0)
2967 /* Nonzero means print parse trace. It is left uninitialized so that
2968 multiple parsers can coexist. */
2969 int yydebug;
2970 #else /* !YYDEBUG */
2971 # define YYDPRINTF(Args)
2972 # define YYDSYMPRINT(Args)
2973 #endif /* !YYDEBUG */
2974
2975 /* YYINITDEPTH -- initial size of the parser's stacks. */
2976 #ifndef YYINITDEPTH
2977 # define YYINITDEPTH 200
2978 #endif
2979
2980 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2981 if the built-in stack extension method is used).
2982
2983 Do not make this value too large; the results are undefined if
2984 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
2985 evaluated with infinite-precision integer arithmetic. */
2986
2987 #if YYMAXDEPTH == 0
2988 # undef YYMAXDEPTH
2989 #endif
2990
2991 #ifndef YYMAXDEPTH
2992 # define YYMAXDEPTH 10000
2993 #endif
2994
2995
2996
2997 #if YYERROR_VERBOSE
2998
2999 # ifndef yystrlen
3000 # if defined (__GLIBC__) && defined (_STRING_H)
3001 # define yystrlen strlen
3002 # else
3003 /* Return the length of YYSTR. */
3004 static YYSIZE_T
3005 # if defined (__STDC__) || defined (__cplusplus)
yystrlen(const char * yystr)3006 yystrlen (const char *yystr)
3007 # else
3008 yystrlen (yystr)
3009 const char *yystr;
3010 # endif
3011 {
3012 register const char *yys = yystr;
3013
3014 while (*yys++ != '\0')
3015 continue;
3016
3017 return yys - yystr - 1;
3018 }
3019 # endif
3020 # endif
3021
3022 # ifndef yystpcpy
3023 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
3024 # define yystpcpy stpcpy
3025 # else
3026 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3027 YYDEST. */
3028 static char *
3029 # if defined (__STDC__) || defined (__cplusplus)
yystpcpy(char * yydest,const char * yysrc)3030 yystpcpy (char *yydest, const char *yysrc)
3031 # else
3032 yystpcpy (yydest, yysrc)
3033 char *yydest;
3034 const char *yysrc;
3035 # endif
3036 {
3037 register char *yyd = yydest;
3038 register const char *yys = yysrc;
3039
3040 while ((*yyd++ = *yys++) != '\0')
3041 continue;
3042
3043 return yyd - 1;
3044 }
3045 # endif
3046 # endif
3047
3048 #endif /* !YYERROR_VERBOSE */
3049
3050
3051
3052 #if YYDEBUG
3053 /*-----------------------------.
3054 | Print this symbol on YYOUT. |
3055 `-----------------------------*/
3056
3057 static void
3058 #if defined (__STDC__) || defined (__cplusplus)
yysymprint(FILE * yyout,int yytype,YYSTYPE yyvalue)3059 yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue)
3060 #else
3061 yysymprint (yyout, yytype, yyvalue)
3062 FILE* yyout;
3063 int yytype;
3064 YYSTYPE yyvalue;
3065 #endif
3066 {
3067 /* Pacify ``unused variable'' warnings. */
3068 (void) yyvalue;
3069
3070 if (yytype < YYNTOKENS)
3071 {
3072 YYFPRINTF (yyout, "token %s (", yytname[yytype]);
3073 # ifdef YYPRINT
3074 YYPRINT (yyout, yytoknum[yytype], yyvalue);
3075 # endif
3076 }
3077 else
3078 YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);
3079
3080 switch (yytype)
3081 {
3082 default:
3083 break;
3084 }
3085 YYFPRINTF (yyout, ")");
3086 }
3087 #endif /* YYDEBUG. */
3088
3089
3090 /*-----------------------------------------------.
3091 | Release the memory associated to this symbol. |
3092 `-----------------------------------------------*/
3093
3094 static void
3095 #if defined (__STDC__) || defined (__cplusplus)
yydestruct(int yytype,YYSTYPE yyvalue)3096 yydestruct (int yytype, YYSTYPE yyvalue)
3097 #else
3098 yydestruct (yytype, yyvalue)
3099 int yytype;
3100 YYSTYPE yyvalue;
3101 #endif
3102 {
3103 /* Pacify ``unused variable'' warnings. */
3104 (void) yyvalue;
3105
3106 switch (yytype)
3107 {
3108 default:
3109 break;
3110 }
3111 }
3112
3113
3114
3115 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
3116 into yyparse. The argument should have type void *.
3117 It should actually point to an object.
3118 Grammar actions can access the variable by casting it
3119 to the proper pointer type. */
3120
3121 #ifdef YYPARSE_PARAM
3122 # if defined (__STDC__) || defined (__cplusplus)
3123 # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
3124 # define YYPARSE_PARAM_DECL
3125 # else
3126 # define YYPARSE_PARAM_ARG YYPARSE_PARAM
3127 # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
3128 # endif
3129 #else /* !YYPARSE_PARAM */
3130 # define YYPARSE_PARAM_ARG
3131 # define YYPARSE_PARAM_DECL
3132 #endif /* !YYPARSE_PARAM */
3133
3134 /* Prevent warning if -Wstrict-prototypes. */
3135 #ifdef __GNUC__
3136 # ifdef YYPARSE_PARAM
3137 int yyparse (void *);
3138 # else
3139 int yyparse (void);
3140 # endif
3141 #endif
3142
3143
3144
3145
3146 int
yyparse(YYPARSE_PARAM_ARG)3147 yyparse (YYPARSE_PARAM_ARG)
3148 YYPARSE_PARAM_DECL
3149 {
3150 /* The lookahead symbol. */
3151 int yychar;
3152
3153 /* The semantic value of the lookahead symbol. */
3154 YYSTYPE yylval;
3155
3156 /* Number of parse errors so far. */
3157 int yynerrs;
3158
3159 register int yystate;
3160 register int yyn;
3161 int yyresult;
3162 /* Number of tokens to shift before error messages enabled. */
3163 int yyerrstatus;
3164 /* Lookahead token as an internal (translated) token number. */
3165 int yychar1 = 0;
3166
3167 /* Three stacks and their tools:
3168 `yyss': related to states,
3169 `yyvs': related to semantic values,
3170 `yyls': related to locations.
3171
3172 Refer to the stacks thru separate pointers, to allow yyoverflow
3173 to reallocate them elsewhere. */
3174
3175 /* The state stack. */
3176 short yyssa[YYINITDEPTH];
3177 short *yyss = yyssa;
3178 register short *yyssp;
3179
3180 /* The semantic value stack. */
3181 YYSTYPE yyvsa[YYINITDEPTH];
3182 YYSTYPE *yyvs = yyvsa;
3183 register YYSTYPE *yyvsp;
3184
3185
3186
3187 #define YYPOPSTACK (yyvsp--, yyssp--)
3188
3189 YYSIZE_T yystacksize = YYINITDEPTH;
3190
3191 /* The variables used to return semantic value and location from the
3192 action routines. */
3193 YYSTYPE yyval;
3194
3195
3196 /* When reducing, the number of symbols on the RHS of the reduced
3197 rule. */
3198 int yylen;
3199
3200 YYDPRINTF ((stderr, "Starting parse\n"));
3201
3202 yystate = 0;
3203 yyerrstatus = 0;
3204 yynerrs = 0;
3205 yychar = YYEMPTY; /* Cause a token to be read. */
3206
3207 /* Initialize stack pointers.
3208 Waste one element of value and location stack
3209 so that they stay on the same level as the state stack.
3210 The wasted elements are never initialized. */
3211
3212 yyssp = yyss;
3213 yyvsp = yyvs;
3214
3215 goto yysetstate;
3216
3217 /*------------------------------------------------------------.
3218 | yynewstate -- Push a new state, which is found in yystate. |
3219 `------------------------------------------------------------*/
3220 yynewstate:
3221 /* In all cases, when you get here, the value and location stacks
3222 have just been pushed. so pushing a state here evens the stacks.
3223 */
3224 yyssp++;
3225
3226 yysetstate:
3227 *yyssp = yystate;
3228
3229 if (yyssp >= yyss + yystacksize - 1)
3230 {
3231 /* Get the current used size of the three stacks, in elements. */
3232 YYSIZE_T yysize = yyssp - yyss + 1;
3233
3234 #ifdef yyoverflow
3235 {
3236 /* Give user a chance to reallocate the stack. Use copies of
3237 these so that the &'s don't force the real ones into
3238 memory. */
3239 YYSTYPE *yyvs1 = yyvs;
3240 short *yyss1 = yyss;
3241
3242
3243 /* Each stack pointer address is followed by the size of the
3244 data in use in that stack, in bytes. This used to be a
3245 conditional around just the two extra args, but that might
3246 be undefined if yyoverflow is a macro. */
3247 yyoverflow ("parser stack overflow",
3248 &yyss1, yysize * sizeof (*yyssp),
3249 &yyvs1, yysize * sizeof (*yyvsp),
3250
3251 &yystacksize);
3252
3253 yyss = yyss1;
3254 yyvs = yyvs1;
3255 }
3256 #else /* no yyoverflow */
3257 # ifndef YYSTACK_RELOCATE
3258 goto yyoverflowlab;
3259 # else
3260 /* Extend the stack our own way. */
3261 if (yystacksize >= YYMAXDEPTH)
3262 goto yyoverflowlab;
3263 yystacksize *= 2;
3264 if (yystacksize > YYMAXDEPTH)
3265 yystacksize = YYMAXDEPTH;
3266
3267 {
3268 short *yyss1 = yyss;
3269 union yyalloc *yyptr =
3270 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3271 if (! yyptr)
3272 goto yyoverflowlab;
3273 YYSTACK_RELOCATE (yyss);
3274 YYSTACK_RELOCATE (yyvs);
3275
3276 # undef YYSTACK_RELOCATE
3277 if (yyss1 != yyssa)
3278 YYSTACK_FREE (yyss1);
3279 }
3280 # endif
3281 #endif /* no yyoverflow */
3282
3283 yyssp = yyss + yysize - 1;
3284 yyvsp = yyvs + yysize - 1;
3285
3286
3287 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3288 (unsigned long int) yystacksize));
3289
3290 if (yyssp >= yyss + yystacksize - 1)
3291 YYABORT;
3292 }
3293
3294 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3295
3296 goto yybackup;
3297
3298 /*-----------.
3299 | yybackup. |
3300 `-----------*/
3301 yybackup:
3302
3303 /* Do appropriate processing given the current state. */
3304 /* Read a lookahead token if we need one and don't already have one. */
3305 /* yyresume: */
3306
3307 /* First try to decide what to do without reference to lookahead token. */
3308
3309 yyn = yypact[yystate];
3310 if (yyn == YYPACT_NINF)
3311 goto yydefault;
3312
3313 /* Not known => get a lookahead token if don't already have one. */
3314
3315 /* yychar is either YYEMPTY or YYEOF
3316 or a valid token in external form. */
3317
3318 if (yychar == YYEMPTY)
3319 {
3320 YYDPRINTF ((stderr, "Reading a token: "));
3321 yychar = YYLEX;
3322 }
3323
3324 /* Convert token to internal form (in yychar1) for indexing tables with. */
3325
3326 if (yychar <= 0) /* This means end of input. */
3327 {
3328 yychar1 = 0;
3329 yychar = YYEOF; /* Don't call YYLEX any more. */
3330
3331 YYDPRINTF ((stderr, "Now at end of input.\n"));
3332 }
3333 else
3334 {
3335 yychar1 = YYTRANSLATE (yychar);
3336
3337 /* We have to keep this `#if YYDEBUG', since we use variables
3338 which are defined only if `YYDEBUG' is set. */
3339 YYDPRINTF ((stderr, "Next token is "));
3340 YYDSYMPRINT ((stderr, yychar1, yylval));
3341 YYDPRINTF ((stderr, "\n"));
3342 }
3343
3344 /* If the proper action on seeing token YYCHAR1 is to reduce or to
3345 detect an error, take that action. */
3346 yyn += yychar1;
3347 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
3348 goto yydefault;
3349 yyn = yytable[yyn];
3350 if (yyn <= 0)
3351 {
3352 if (yyn == 0 || yyn == YYTABLE_NINF)
3353 goto yyerrlab;
3354 yyn = -yyn;
3355 goto yyreduce;
3356 }
3357
3358 if (yyn == YYFINAL)
3359 YYACCEPT;
3360
3361 /* Shift the lookahead token. */
3362 YYDPRINTF ((stderr, "Shifting token %d (%s), ",
3363 yychar, yytname[yychar1]));
3364
3365 /* Discard the token being shifted unless it is eof. */
3366 if (yychar != YYEOF)
3367 yychar = YYEMPTY;
3368
3369 *++yyvsp = yylval;
3370
3371
3372 /* Count tokens shifted since error; after three, turn off error
3373 status. */
3374 if (yyerrstatus)
3375 yyerrstatus--;
3376
3377 yystate = yyn;
3378 goto yynewstate;
3379
3380
3381 /*-----------------------------------------------------------.
3382 | yydefault -- do the default action for the current state. |
3383 `-----------------------------------------------------------*/
3384 yydefault:
3385 yyn = yydefact[yystate];
3386 if (yyn == 0)
3387 goto yyerrlab;
3388 goto yyreduce;
3389
3390
3391 /*-----------------------------.
3392 | yyreduce -- Do a reduction. |
3393 `-----------------------------*/
3394 yyreduce:
3395 /* yyn is the number of a rule to reduce with. */
3396 yylen = yyr2[yyn];
3397
3398 /* If YYLEN is nonzero, implement the default value of the action:
3399 `$$ = $1'.
3400
3401 Otherwise, the following line sets YYVAL to garbage.
3402 This behavior is undocumented and Bison
3403 users should not rely upon it. Assigning to YYVAL
3404 unconditionally makes the parser a bit smaller, and it avoids a
3405 GCC warning that YYVAL may be used uninitialized. */
3406 yyval = yyvsp[1-yylen];
3407
3408
3409
3410 #if YYDEBUG
3411 /* We have to keep this `#if YYDEBUG', since we use variables which
3412 are defined only if `YYDEBUG' is set. */
3413 if (yydebug)
3414 {
3415 int yyi;
3416
3417 YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
3418 yyn - 1, yyrline[yyn]);
3419
3420 /* Print the symbols being reduced, and their result. */
3421 for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
3422 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
3423 YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
3424 }
3425 #endif
3426 switch (yyn)
3427 {
3428 case 2:
3429 #line 562 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3430 {
3431 /* Register static variables with the garbage
3432 collector. */
3433 ggc_add_root (&ctxp, 1,
3434 sizeof (struct parser_ctxt *),
3435 mark_parser_ctxt);
3436 ggc_add_root (&ctxp_for_generation, 1,
3437 sizeof (struct parser_ctxt *),
3438 mark_parser_ctxt);
3439 }
3440 break;
3441
3442 case 3:
3443 #line 573 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3444 {}
3445 break;
3446
3447 case 20:
3448 #line 617 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3449 {
3450 int osb = pop_current_osb (ctxp);
3451 tree t = build_java_array_type ((yyvsp[-1].node), -1);
3452 while (--osb)
3453 t = build_unresolved_array_type (t);
3454 yyval.node = t;
3455 }
3456 break;
3457
3458 case 21:
3459 #line 625 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3460 {
3461 int osb = pop_current_osb (ctxp);
3462 tree t = yyvsp[-1].node;
3463 while (osb--)
3464 t = build_unresolved_array_type (t);
3465 yyval.node = t;
3466 }
3467 break;
3468
3469 case 25:
3470 #line 646 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3471 { yyval.node = make_qualified_name (yyvsp[-2].node, yyvsp[0].node, yyvsp[-1].operator.location); }
3472 break;
3473
3474 case 27:
3475 #line 655 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3476 {yyval.node = NULL;}
3477 break;
3478
3479 case 35:
3480 #line 667 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3481 {
3482 yyval.node = NULL;
3483 }
3484 break;
3485
3486 case 36:
3487 #line 671 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3488 {
3489 yyval.node = NULL;
3490 }
3491 break;
3492
3493 case 39:
3494 #line 683 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3495 {
3496 ctxp->package = EXPR_WFL_NODE (yyvsp[-1].node);
3497 register_package (ctxp->package);
3498 }
3499 break;
3500
3501 case 40:
3502 #line 688 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3503 {yyerror ("Missing name"); RECOVER;}
3504 break;
3505
3506 case 41:
3507 #line 690 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3508 {yyerror ("';' expected"); RECOVER;}
3509 break;
3510
3511 case 44:
3512 #line 700 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3513 {
3514 tree name = EXPR_WFL_NODE (yyvsp[-1].node), last_name;
3515 int i = IDENTIFIER_LENGTH (name)-1;
3516 const char *last = &IDENTIFIER_POINTER (name)[i];
3517 while (last != IDENTIFIER_POINTER (name))
3518 {
3519 if (last [0] == '.')
3520 break;
3521 last--;
3522 }
3523 last_name = get_identifier (++last);
3524 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
3525 {
3526 tree err = find_name_in_single_imports (last_name);
3527 if (err && err != name)
3528 parse_error_context
3529 (yyvsp[-1].node, "Ambiguous class: `%s' and `%s'",
3530 IDENTIFIER_POINTER (name),
3531 IDENTIFIER_POINTER (err));
3532 else
3533 REGISTER_IMPORT (yyvsp[-1].node, last_name);
3534 }
3535 else
3536 REGISTER_IMPORT (yyvsp[-1].node, last_name);
3537 }
3538 break;
3539
3540 case 45:
3541 #line 726 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3542 {yyerror ("Missing name"); RECOVER;}
3543 break;
3544
3545 case 46:
3546 #line 728 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3547 {yyerror ("';' expected"); RECOVER;}
3548 break;
3549
3550 case 47:
3551 #line 733 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3552 {
3553 tree name = EXPR_WFL_NODE (yyvsp[-3].node);
3554 tree it;
3555 /* Search for duplicates. */
3556 for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
3557 if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
3558 break;
3559 /* Don't import the same thing more than once, just ignore
3560 duplicates (7.5.2) */
3561 if (! it)
3562 {
3563 read_import_dir (yyvsp[-3].node);
3564 ctxp->import_demand_list =
3565 chainon (ctxp->import_demand_list,
3566 build_tree_list (yyvsp[-3].node, NULL_TREE));
3567 }
3568 }
3569 break;
3570
3571 case 48:
3572 #line 751 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3573 {yyerror ("'*' expected"); RECOVER;}
3574 break;
3575
3576 case 49:
3577 #line 753 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3578 {yyerror ("';' expected"); RECOVER;}
3579 break;
3580
3581 case 50:
3582 #line 758 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3583 { end_class_declaration (0); }
3584 break;
3585
3586 case 51:
3587 #line 760 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3588 { end_class_declaration (0); }
3589 break;
3590
3591 case 53:
3592 #line 763 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3593 {
3594 YYERROR_NOW;
3595 yyerror ("Class or interface declaration expected");
3596 }
3597 break;
3598
3599 case 54:
3600 #line 772 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3601 {
3602 yyval.value = (1 << yyvsp[0].value);
3603 }
3604 break;
3605
3606 case 55:
3607 #line 776 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3608 {
3609 int acc = (1 << yyvsp[0].value);
3610 if (yyval.value & acc)
3611 parse_error_context
3612 (ctxp->modifier_ctx [yyvsp[0].value], "Modifier `%s' declared twice",
3613 java_accstring_lookup (acc));
3614 else
3615 {
3616 yyval.value |= acc;
3617 }
3618 }
3619 break;
3620
3621 case 56:
3622 #line 792 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3623 { create_class (yyvsp[-4].value, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); }
3624 break;
3625
3626 case 57:
3627 #line 794 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3628 {;}
3629 break;
3630
3631 case 58:
3632 #line 796 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3633 { create_class (0, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); }
3634 break;
3635
3636 case 59:
3637 #line 798 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3638 {;}
3639 break;
3640
3641 case 60:
3642 #line 800 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3643 { yyerror ("Missing class name"); RECOVER; }
3644 break;
3645
3646 case 61:
3647 #line 802 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3648 { yyerror ("Missing class name"); RECOVER; }
3649 break;
3650
3651 case 62:
3652 #line 804 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3653 {
3654 if (!ctxp->class_err) yyerror ("'{' expected");
3655 DRECOVER(class1);
3656 }
3657 break;
3658
3659 case 63:
3660 #line 809 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3661 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
3662 break;
3663
3664 case 64:
3665 #line 813 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3666 { yyval.node = NULL; }
3667 break;
3668
3669 case 65:
3670 #line 815 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3671 { yyval.node = yyvsp[0].node; }
3672 break;
3673
3674 case 66:
3675 #line 817 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3676 {yyerror ("'{' expected"); ctxp->class_err=1;}
3677 break;
3678
3679 case 67:
3680 #line 819 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3681 {yyerror ("Missing super class name"); ctxp->class_err=1;}
3682 break;
3683
3684 case 68:
3685 #line 823 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3686 { yyval.node = NULL_TREE; }
3687 break;
3688
3689 case 69:
3690 #line 825 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3691 { yyval.node = yyvsp[0].node; }
3692 break;
3693
3694 case 70:
3695 #line 827 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3696 {
3697 ctxp->class_err=1;
3698 yyerror ("Missing interface name");
3699 }
3700 break;
3701
3702 case 71:
3703 #line 835 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3704 {
3705 ctxp->interface_number = 1;
3706 yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE);
3707 }
3708 break;
3709
3710 case 72:
3711 #line 840 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3712 {
3713 ctxp->interface_number++;
3714 yyval.node = chainon (yyvsp[-2].node, build_tree_list (yyvsp[0].node, NULL_TREE));
3715 }
3716 break;
3717
3718 case 73:
3719 #line 845 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3720 {yyerror ("Missing interface name"); RECOVER;}
3721 break;
3722
3723 case 74:
3724 #line 850 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3725 {
3726 /* Store the location of the `}' when doing xrefs */
3727 if (flag_emit_xref)
3728 DECL_END_SOURCE_LINE (GET_CPC ()) =
3729 EXPR_WFL_ADD_COL (yyvsp[0].operator.location, 1);
3730 yyval.node = GET_CPC ();
3731 }
3732 break;
3733
3734 case 75:
3735 #line 858 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3736 {
3737 /* Store the location of the `}' when doing xrefs */
3738 if (flag_emit_xref)
3739 DECL_END_SOURCE_LINE (GET_CPC ()) =
3740 EXPR_WFL_ADD_COL (yyvsp[0].operator.location, 1);
3741 yyval.node = GET_CPC ();
3742 }
3743 break;
3744
3745 case 81:
3746 #line 877 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3747 {
3748 if (yyvsp[0].node != empty_stmt_node)
3749 {
3750 TREE_CHAIN (yyvsp[0].node) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
3751 SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, yyvsp[0].node);
3752 }
3753 }
3754 break;
3755
3756 case 84:
3757 #line 890 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3758 { end_class_declaration (1); }
3759 break;
3760
3761 case 85:
3762 #line 892 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3763 { end_class_declaration (1); }
3764 break;
3765
3766 case 87:
3767 #line 899 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3768 { register_fields (0, yyvsp[-2].node, yyvsp[-1].node); }
3769 break;
3770
3771 case 88:
3772 #line 901 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3773 {
3774 check_modifiers
3775 ("Illegal modifier `%s' for field declaration",
3776 yyvsp[-3].value, FIELD_MODIFIERS);
3777 check_modifiers_consistency (yyvsp[-3].value);
3778 register_fields (yyvsp[-3].value, yyvsp[-2].node, yyvsp[-1].node);
3779 }
3780 break;
3781
3782 case 90:
3783 #line 914 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3784 { yyval.node = chainon (yyvsp[-2].node, yyvsp[0].node); }
3785 break;
3786
3787 case 91:
3788 #line 916 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3789 {yyerror ("Missing term"); RECOVER;}
3790 break;
3791
3792 case 92:
3793 #line 921 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3794 { yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE); }
3795 break;
3796
3797 case 93:
3798 #line 923 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3799 {
3800 if (java_error_count)
3801 yyvsp[0].node = NULL_TREE;
3802 yyval.node = build_tree_list
3803 (yyvsp[-2].node, build_assignment (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node));
3804 }
3805 break;
3806
3807 case 94:
3808 #line 930 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3809 {
3810 yyerror ("Missing variable initializer");
3811 yyval.node = build_tree_list (yyvsp[-2].node, NULL_TREE);
3812 RECOVER;
3813 }
3814 break;
3815
3816 case 95:
3817 #line 936 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3818 {
3819 yyerror ("';' expected");
3820 yyval.node = build_tree_list (yyvsp[-3].node, NULL_TREE);
3821 RECOVER;
3822 }
3823 break;
3824
3825 case 97:
3826 #line 946 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3827 { yyval.node = build_unresolved_array_type (yyvsp[-2].node); }
3828 break;
3829
3830 case 98:
3831 #line 948 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3832 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
3833 break;
3834
3835 case 99:
3836 #line 950 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3837 {
3838 yyerror ("']' expected");
3839 DRECOVER(vdi);
3840 }
3841 break;
3842
3843 case 100:
3844 #line 955 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3845 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
3846 break;
3847
3848 case 103:
3849 #line 966 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3850 {
3851 current_function_decl = yyvsp[0].node;
3852 if (current_function_decl
3853 && TREE_CODE (current_function_decl) == FUNCTION_DECL)
3854 source_start_java_method (current_function_decl);
3855 else
3856 current_function_decl = NULL_TREE;
3857 }
3858 break;
3859
3860 case 104:
3861 #line 975 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3862 { finish_method_declaration (yyvsp[0].node); }
3863 break;
3864
3865 case 105:
3866 #line 977 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3867 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
3868 break;
3869
3870 case 106:
3871 #line 982 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3872 { yyval.node = method_header (0, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); }
3873 break;
3874
3875 case 107:
3876 #line 984 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3877 { yyval.node = method_header (0, void_type_node, yyvsp[-1].node, yyvsp[0].node); }
3878 break;
3879
3880 case 108:
3881 #line 986 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3882 { yyval.node = method_header (yyvsp[-3].value, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); }
3883 break;
3884
3885 case 109:
3886 #line 988 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3887 { yyval.node = method_header (yyvsp[-3].value, void_type_node, yyvsp[-1].node, yyvsp[0].node); }
3888 break;
3889
3890 case 110:
3891 #line 990 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3892 {
3893 yyerror ("Invalid method declaration, method name required");
3894 RECOVER;
3895 }
3896 break;
3897
3898 case 111:
3899 #line 995 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3900 {
3901 yyerror ("Identifier expected");
3902 RECOVER;
3903 }
3904 break;
3905
3906 case 112:
3907 #line 1000 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3908 {
3909 yyerror ("Identifier expected");
3910 RECOVER;
3911 }
3912 break;
3913
3914 case 113:
3915 #line 1005 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3916 {
3917 yyerror ("Identifier expected");
3918 RECOVER;
3919 }
3920 break;
3921
3922 case 114:
3923 #line 1010 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3924 {
3925 yyerror ("Invalid method declaration, return type required");
3926 RECOVER;
3927 }
3928 break;
3929
3930 case 115:
3931 #line 1018 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3932 {
3933 ctxp->formal_parameter_number = 0;
3934 yyval.node = method_declarator (yyvsp[-2].node, NULL_TREE);
3935 }
3936 break;
3937
3938 case 116:
3939 #line 1023 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3940 { yyval.node = method_declarator (yyvsp[-3].node, yyvsp[-1].node); }
3941 break;
3942
3943 case 117:
3944 #line 1025 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3945 {
3946 EXPR_WFL_LINECOL (wfl_operator) = yyvsp[-1].operator.location;
3947 TREE_PURPOSE (yyvsp[-2].node) =
3948 build_unresolved_array_type (TREE_PURPOSE (yyvsp[-2].node));
3949 parse_warning_context
3950 (wfl_operator,
3951 "Discouraged form of returned type specification");
3952 }
3953 break;
3954
3955 case 118:
3956 #line 1034 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3957 {yyerror ("')' expected"); DRECOVER(method_declarator);}
3958 break;
3959
3960 case 119:
3961 #line 1036 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3962 {yyerror ("']' expected"); RECOVER;}
3963 break;
3964
3965 case 120:
3966 #line 1041 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3967 {
3968 ctxp->formal_parameter_number = 1;
3969 }
3970 break;
3971
3972 case 121:
3973 #line 1045 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3974 {
3975 ctxp->formal_parameter_number += 1;
3976 yyval.node = chainon (yyvsp[-2].node, yyvsp[0].node);
3977 }
3978 break;
3979
3980 case 122:
3981 #line 1050 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3982 { yyerror ("Missing formal parameter term"); RECOVER; }
3983 break;
3984
3985 case 123:
3986 #line 1055 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3987 {
3988 yyval.node = build_tree_list (yyvsp[0].node, yyvsp[-1].node);
3989 }
3990 break;
3991
3992 case 124:
3993 #line 1059 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
3994 {
3995 yyval.node = build_tree_list (yyvsp[0].node, yyvsp[-1].node);
3996 ARG_FINAL_P (yyval.node) = 1;
3997 }
3998 break;
3999
4000 case 125:
4001 #line 1064 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4002 {
4003 yyerror ("Missing identifier"); RECOVER;
4004 yyval.node = NULL_TREE;
4005 }
4006 break;
4007
4008 case 126:
4009 #line 1069 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4010 {
4011 yyerror ("Missing identifier"); RECOVER;
4012 yyval.node = NULL_TREE;
4013 }
4014 break;
4015
4016 case 127:
4017 #line 1077 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4018 {
4019 check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
4020 yyvsp[0].value, ACC_FINAL);
4021 if (yyvsp[0].value != ACC_FINAL)
4022 MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
4023 }
4024 break;
4025
4026 case 128:
4027 #line 1086 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4028 { yyval.node = NULL_TREE; }
4029 break;
4030
4031 case 129:
4032 #line 1088 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4033 { yyval.node = yyvsp[0].node; }
4034 break;
4035
4036 case 130:
4037 #line 1090 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4038 {yyerror ("Missing class type term"); RECOVER;}
4039 break;
4040
4041 case 131:
4042 #line 1095 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4043 { yyval.node = build_tree_list (yyvsp[0].node, yyvsp[0].node); }
4044 break;
4045
4046 case 132:
4047 #line 1097 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4048 { yyval.node = tree_cons (yyvsp[0].node, yyvsp[0].node, yyvsp[-2].node); }
4049 break;
4050
4051 case 133:
4052 #line 1099 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4053 {yyerror ("Missing class type term"); RECOVER;}
4054 break;
4055
4056 case 135:
4057 #line 1104 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4058 { yyval.node = NULL_TREE; }
4059 break;
4060
4061 case 136:
4062 #line 1110 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4063 {
4064 TREE_CHAIN (yyvsp[0].node) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4065 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, yyvsp[0].node);
4066 current_static_block = NULL_TREE;
4067 }
4068 break;
4069
4070 case 137:
4071 #line 1119 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4072 {
4073 check_modifiers ("Illegal modifier `%s' for static initializer", yyvsp[0].value, ACC_STATIC);
4074 /* Can't have a static initializer in an innerclass */
4075 if (yyvsp[0].value | ACC_STATIC &&
4076 GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
4077 parse_error_context
4078 (MODIFIER_WFL (STATIC_TK),
4079 "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
4080 IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
4081 SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[0].value));
4082 }
4083 break;
4084
4085 case 138:
4086 #line 1135 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4087 {
4088 current_function_decl = yyvsp[0].node;
4089 source_start_java_method (current_function_decl);
4090 }
4091 break;
4092
4093 case 139:
4094 #line 1140 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4095 { finish_method_declaration (yyvsp[0].node); }
4096 break;
4097
4098 case 140:
4099 #line 1145 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4100 { yyval.node = method_header (0, NULL_TREE, yyvsp[-1].node, yyvsp[0].node); }
4101 break;
4102
4103 case 141:
4104 #line 1147 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4105 { yyval.node = method_header (yyvsp[-2].value, NULL_TREE, yyvsp[-1].node, yyvsp[0].node); }
4106 break;
4107
4108 case 142:
4109 #line 1152 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4110 {
4111 ctxp->formal_parameter_number = 0;
4112 yyval.node = method_declarator (yyvsp[-2].node, NULL_TREE);
4113 }
4114 break;
4115
4116 case 143:
4117 #line 1157 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4118 { yyval.node = method_declarator (yyvsp[-3].node, yyvsp[-1].node); }
4119 break;
4120
4121 case 144:
4122 #line 1163 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4123 {
4124 BLOCK_EXPR_BODY (yyvsp[0].node) = empty_stmt_node;
4125 yyval.node = yyvsp[0].node;
4126 }
4127 break;
4128
4129 case 145:
4130 #line 1168 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4131 { yyval.node = yyvsp[0].node; }
4132 break;
4133
4134 case 146:
4135 #line 1170 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4136 { yyval.node = yyvsp[0].node; }
4137 break;
4138
4139 case 147:
4140 #line 1172 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4141 { yyval.node = yyvsp[0].node; }
4142 break;
4143
4144 case 149:
4145 #line 1182 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4146 {
4147 yyval.node = build_method_invocation (yyvsp[-3].node, NULL_TREE);
4148 yyval.node = build_debugable_stmt (EXPR_WFL_LINECOL (yyvsp[-3].node), yyval.node);
4149 yyval.node = java_method_add_stmt (current_function_decl, yyval.node);
4150 }
4151 break;
4152
4153 case 150:
4154 #line 1188 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4155 {
4156 yyval.node = build_method_invocation (yyvsp[-4].node, yyvsp[-2].node);
4157 yyval.node = build_debugable_stmt (EXPR_WFL_LINECOL (yyvsp[-4].node), yyval.node);
4158 yyval.node = java_method_add_stmt (current_function_decl, yyval.node);
4159 }
4160 break;
4161
4162 case 151:
4163 #line 1195 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4164 {yyval.node = parse_jdk1_1_error ("explicit constructor invocation"); }
4165 break;
4166
4167 case 152:
4168 #line 1197 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4169 {yyval.node = parse_jdk1_1_error ("explicit constructor invocation"); }
4170 break;
4171
4172 case 153:
4173 #line 1202 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4174 {
4175 tree wfl = build_wfl_node (this_identifier_node);
4176 EXPR_WFL_LINECOL (wfl) = yyvsp[0].operator.location;
4177 yyval.node = wfl;
4178 }
4179 break;
4180
4181 case 154:
4182 #line 1208 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4183 {
4184 tree wfl = build_wfl_node (super_identifier_node);
4185 EXPR_WFL_LINECOL (wfl) = yyvsp[0].operator.location;
4186 yyval.node = wfl;
4187 }
4188 break;
4189
4190 case 155:
4191 #line 1219 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4192 { create_interface (0, yyvsp[0].node, NULL_TREE); }
4193 break;
4194
4195 case 156:
4196 #line 1221 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4197 { ; }
4198 break;
4199
4200 case 157:
4201 #line 1223 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4202 { create_interface (yyvsp[-2].value, yyvsp[0].node, NULL_TREE); }
4203 break;
4204
4205 case 158:
4206 #line 1225 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4207 { ; }
4208 break;
4209
4210 case 159:
4211 #line 1227 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4212 { create_interface (0, yyvsp[-1].node, yyvsp[0].node); }
4213 break;
4214
4215 case 160:
4216 #line 1229 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4217 { ; }
4218 break;
4219
4220 case 161:
4221 #line 1231 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4222 { create_interface (yyvsp[-3].value, yyvsp[-1].node, yyvsp[0].node); }
4223 break;
4224
4225 case 162:
4226 #line 1233 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4227 { ; }
4228 break;
4229
4230 case 163:
4231 #line 1235 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4232 { yyerror ("'{' expected"); RECOVER; }
4233 break;
4234
4235 case 164:
4236 #line 1237 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4237 { yyerror ("'{' expected"); RECOVER; }
4238 break;
4239
4240 case 165:
4241 #line 1242 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4242 {
4243 ctxp->interface_number = 1;
4244 yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE);
4245 }
4246 break;
4247
4248 case 166:
4249 #line 1247 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4250 {
4251 ctxp->interface_number++;
4252 yyval.node = chainon (yyvsp[-2].node, build_tree_list (yyvsp[0].node, NULL_TREE));
4253 }
4254 break;
4255
4256 case 167:
4257 #line 1252 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4258 {yyerror ("Invalid interface type"); RECOVER;}
4259 break;
4260
4261 case 168:
4262 #line 1254 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4263 {yyerror ("Missing term"); RECOVER;}
4264 break;
4265
4266 case 169:
4267 #line 1259 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4268 { yyval.node = NULL_TREE; }
4269 break;
4270
4271 case 170:
4272 #line 1261 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4273 { yyval.node = NULL_TREE; }
4274 break;
4275
4276 case 175:
4277 #line 1273 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4278 { end_class_declaration (1); }
4279 break;
4280
4281 case 176:
4282 #line 1275 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4283 { end_class_declaration (1); }
4284 break;
4285
4286 case 178:
4287 #line 1284 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4288 {
4289 check_abstract_method_header (yyvsp[-1].node);
4290 current_function_decl = NULL_TREE; /* FIXME ? */
4291 }
4292 break;
4293
4294 case 179:
4295 #line 1289 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4296 {yyerror ("';' expected"); RECOVER;}
4297 break;
4298
4299 case 180:
4300 #line 1295 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4301 { yyval.node = build_new_array_init (yyvsp[-1].operator.location, NULL_TREE); }
4302 break;
4303
4304 case 181:
4305 #line 1297 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4306 { yyval.node = build_new_array_init (yyvsp[-2].operator.location, NULL_TREE); }
4307 break;
4308
4309 case 182:
4310 #line 1299 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4311 { yyval.node = build_new_array_init (yyvsp[-2].operator.location, yyvsp[-1].node); }
4312 break;
4313
4314 case 183:
4315 #line 1301 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4316 { yyval.node = build_new_array_init (yyvsp[-3].operator.location, yyvsp[-2].node); }
4317 break;
4318
4319 case 184:
4320 #line 1306 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4321 {
4322 yyval.node = tree_cons (maybe_build_array_element_wfl (yyvsp[0].node),
4323 yyvsp[0].node, NULL_TREE);
4324 }
4325 break;
4326
4327 case 185:
4328 #line 1311 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4329 {
4330 yyval.node = tree_cons (maybe_build_array_element_wfl (yyvsp[0].node), yyvsp[0].node, yyvsp[-2].node);
4331 }
4332 break;
4333
4334 case 186:
4335 #line 1315 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4336 {yyerror ("Missing term"); RECOVER;}
4337 break;
4338
4339 case 187:
4340 #line 1321 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4341 {
4342 /* Store the location of the `}' when doing xrefs */
4343 if (current_function_decl && flag_emit_xref)
4344 DECL_END_SOURCE_LINE (current_function_decl) =
4345 EXPR_WFL_ADD_COL (yyvsp[0].operator.location, 1);
4346 yyval.node = empty_stmt_node;
4347 }
4348 break;
4349
4350 case 188:
4351 #line 1329 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4352 { yyval.node = yyvsp[0].node; }
4353 break;
4354
4355 case 189:
4356 #line 1334 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4357 { enter_block (); }
4358 break;
4359
4360 case 190:
4361 #line 1339 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4362 {
4363 maybe_absorb_scoping_blocks ();
4364 /* Store the location of the `}' when doing xrefs */
4365 if (current_function_decl && flag_emit_xref)
4366 DECL_END_SOURCE_LINE (current_function_decl) =
4367 EXPR_WFL_ADD_COL (yyvsp[0].operator.location, 1);
4368 yyval.node = exit_block ();
4369 if (!BLOCK_SUBBLOCKS (yyval.node))
4370 BLOCK_SUBBLOCKS (yyval.node) = empty_stmt_node;
4371 }
4372 break;
4373
4374 case 194:
4375 #line 1359 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4376 { java_method_add_stmt (current_function_decl, yyvsp[0].node); }
4377 break;
4378
4379 case 195:
4380 #line 1361 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4381 {
4382 LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
4383 end_class_declaration (1);
4384 }
4385 break;
4386
4387 case 197:
4388 #line 1373 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4389 { declare_local_variables (0, yyvsp[-1].node, yyvsp[0].node); }
4390 break;
4391
4392 case 198:
4393 #line 1375 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4394 { declare_local_variables (yyvsp[-2].value, yyvsp[-1].node, yyvsp[0].node); }
4395 break;
4396
4397 case 204:
4398 #line 1385 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4399 { yyval.node = exit_block (); }
4400 break;
4401
4402 case 209:
4403 #line 1394 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4404 { yyval.node = exit_block (); }
4405 break;
4406
4407 case 222:
4408 #line 1414 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4409 {
4410 if (flag_extraneous_semicolon
4411 && ! current_static_block
4412 && (! current_function_decl ||
4413 /* Verify we're not in a inner class declaration */
4414 (GET_CPC () != TYPE_NAME
4415 (DECL_CONTEXT (current_function_decl)))))
4416
4417 {
4418 EXPR_WFL_SET_LINECOL (wfl_operator, lineno, -1);
4419 parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
4420 }
4421 yyval.node = empty_stmt_node;
4422 }
4423 break;
4424
4425 case 223:
4426 #line 1432 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4427 {
4428 yyval.node = build_labeled_block (EXPR_WFL_LINECOL (yyvsp[-1].node),
4429 EXPR_WFL_NODE (yyvsp[-1].node));
4430 pushlevel (2);
4431 push_labeled_block (yyval.node);
4432 PUSH_LABELED_BLOCK (yyval.node);
4433 }
4434 break;
4435
4436 case 224:
4437 #line 1443 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4438 { yyval.node = finish_labeled_statement (yyvsp[-1].node, yyvsp[0].node); }
4439 break;
4440
4441 case 225:
4442 #line 1445 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4443 {yyerror ("':' expected"); RECOVER;}
4444 break;
4445
4446 case 226:
4447 #line 1450 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4448 { yyval.node = finish_labeled_statement (yyvsp[-1].node, yyvsp[0].node); }
4449 break;
4450
4451 case 227:
4452 #line 1456 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4453 {
4454 /* We have a statement. Generate a WFL around it so
4455 we can debug it */
4456 yyval.node = build_expr_wfl (yyvsp[-1].node, input_filename, lineno, 0);
4457 /* We know we have a statement, so set the debug
4458 info to be eventually generate here. */
4459 yyval.node = JAVA_MAYBE_GENERATE_DEBUG_INFO (yyval.node);
4460 }
4461 break;
4462
4463 case 228:
4464 #line 1465 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4465 {
4466 YYNOT_TWICE yyerror ("Invalid expression statement");
4467 DRECOVER (expr_stmt);
4468 }
4469 break;
4470
4471 case 229:
4472 #line 1470 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4473 {
4474 YYNOT_TWICE yyerror ("Invalid expression statement");
4475 DRECOVER (expr_stmt);
4476 }
4477 break;
4478
4479 case 230:
4480 #line 1475 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4481 {
4482 YYNOT_TWICE yyerror ("Invalid expression statement");
4483 DRECOVER (expr_stmt);
4484 }
4485 break;
4486
4487 case 231:
4488 #line 1480 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4489 {yyerror ("')' expected"); RECOVER;}
4490 break;
4491
4492 case 232:
4493 #line 1482 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4494 {
4495 parse_ctor_invocation_error ();
4496 RECOVER;
4497 }
4498 break;
4499
4500 case 233:
4501 #line 1487 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4502 {yyerror ("')' expected"); RECOVER;}
4503 break;
4504
4505 case 234:
4506 #line 1489 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4507 {
4508 parse_ctor_invocation_error ();
4509 RECOVER;
4510 }
4511 break;
4512
4513 case 235:
4514 #line 1494 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4515 {yyerror ("'(' expected"); RECOVER;}
4516 break;
4517
4518 case 236:
4519 #line 1496 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4520 {yyerror ("')' expected"); RECOVER;}
4521 break;
4522
4523 case 237:
4524 #line 1498 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4525 {yyerror ("')' expected"); RECOVER;}
4526 break;
4527
4528 case 238:
4529 #line 1500 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4530 {yyerror ("';' expected"); RECOVER;}
4531 break;
4532
4533 case 239:
4534 #line 1502 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4535 {yyerror ("';' expected"); RECOVER;}
4536 break;
4537
4538 case 247:
4539 #line 1517 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4540 {
4541 yyval.node = build_if_else_statement (yyvsp[-3].operator.location, yyvsp[-2].node,
4542 yyvsp[0].node, NULL_TREE);
4543 }
4544 break;
4545
4546 case 248:
4547 #line 1522 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4548 {yyerror ("'(' expected"); RECOVER;}
4549 break;
4550
4551 case 249:
4552 #line 1524 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4553 {yyerror ("Missing term"); RECOVER;}
4554 break;
4555
4556 case 250:
4557 #line 1526 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4558 {yyerror ("')' expected"); RECOVER;}
4559 break;
4560
4561 case 251:
4562 #line 1531 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4563 { yyval.node = build_if_else_statement (yyvsp[-5].operator.location, yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); }
4564 break;
4565
4566 case 252:
4567 #line 1536 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4568 { yyval.node = build_if_else_statement (yyvsp[-5].operator.location, yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); }
4569 break;
4570
4571 case 253:
4572 #line 1541 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4573 {
4574 enter_block ();
4575 }
4576 break;
4577
4578 case 254:
4579 #line 1545 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4580 {
4581 /* Make into "proper list" of COMPOUND_EXPRs.
4582 I.e. make the last statement also have its own
4583 COMPOUND_EXPR. */
4584 maybe_absorb_scoping_blocks ();
4585 TREE_OPERAND (yyvsp[-2].node, 1) = exit_block ();
4586 yyval.node = build_debugable_stmt (EXPR_WFL_LINECOL (yyvsp[-2].node), yyvsp[-2].node);
4587 }
4588 break;
4589
4590 case 255:
4591 #line 1557 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4592 {
4593 yyval.node = build (SWITCH_EXPR, NULL_TREE, yyvsp[-1].node, NULL_TREE);
4594 EXPR_WFL_LINECOL (yyval.node) = yyvsp[-2].operator.location;
4595 }
4596 break;
4597
4598 case 256:
4599 #line 1562 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4600 {yyerror ("'(' expected"); RECOVER;}
4601 break;
4602
4603 case 257:
4604 #line 1564 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4605 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
4606 break;
4607
4608 case 258:
4609 #line 1566 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4610 {yyerror ("'{' expected"); RECOVER;}
4611 break;
4612
4613 case 259:
4614 #line 1573 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4615 { yyval.node = NULL_TREE; }
4616 break;
4617
4618 case 260:
4619 #line 1575 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4620 { yyval.node = NULL_TREE; }
4621 break;
4622
4623 case 261:
4624 #line 1577 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4625 { yyval.node = NULL_TREE; }
4626 break;
4627
4628 case 262:
4629 #line 1579 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4630 { yyval.node = NULL_TREE; }
4631 break;
4632
4633 case 268:
4634 #line 1598 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4635 {
4636 tree lab = build1 (CASE_EXPR, NULL_TREE, yyvsp[-1].node);
4637 EXPR_WFL_LINECOL (lab) = yyvsp[-2].operator.location;
4638 java_method_add_stmt (current_function_decl, lab);
4639 }
4640 break;
4641
4642 case 269:
4643 #line 1604 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4644 {
4645 tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
4646 EXPR_WFL_LINECOL (lab) = yyvsp[-1].operator.location;
4647 java_method_add_stmt (current_function_decl, lab);
4648 }
4649 break;
4650
4651 case 270:
4652 #line 1610 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4653 {yyerror ("Missing or invalid constant expression"); RECOVER;}
4654 break;
4655
4656 case 271:
4657 #line 1612 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4658 {yyerror ("':' expected"); RECOVER;}
4659 break;
4660
4661 case 272:
4662 #line 1614 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4663 {yyerror ("':' expected"); RECOVER;}
4664 break;
4665
4666 case 273:
4667 #line 1619 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4668 {
4669 tree body = build_loop_body (yyvsp[-2].operator.location, yyvsp[-1].node, 0);
4670 yyval.node = build_new_loop (body);
4671 }
4672 break;
4673
4674 case 274:
4675 #line 1627 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4676 { yyval.node = finish_loop_body (0, NULL_TREE, yyvsp[0].node, 0); }
4677 break;
4678
4679 case 275:
4680 #line 1629 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4681 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
4682 break;
4683
4684 case 276:
4685 #line 1631 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4686 {yyerror ("Missing term and ')' expected"); RECOVER;}
4687 break;
4688
4689 case 277:
4690 #line 1633 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4691 {yyerror ("')' expected"); RECOVER;}
4692 break;
4693
4694 case 278:
4695 #line 1638 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4696 { yyval.node = finish_loop_body (0, NULL_TREE, yyvsp[0].node, 0); }
4697 break;
4698
4699 case 279:
4700 #line 1643 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4701 {
4702 tree body = build_loop_body (0, NULL_TREE, 1);
4703 yyval.node = build_new_loop (body);
4704 }
4705 break;
4706
4707 case 280:
4708 #line 1652 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4709 { yyval.node = finish_loop_body (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[-5].node, 1); }
4710 break;
4711
4712 case 281:
4713 #line 1657 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4714 {
4715 if (TREE_CODE_CLASS (TREE_CODE (yyvsp[-4].node)) == 'c')
4716 yyvsp[-4].node = build_wfl_node (yyvsp[-4].node);
4717 yyval.node = finish_for_loop (EXPR_WFL_LINECOL (yyvsp[-4].node), yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node);
4718 }
4719 break;
4720
4721 case 282:
4722 #line 1663 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4723 {
4724 yyval.node = finish_for_loop (0, NULL_TREE, yyvsp[-2].node, yyvsp[0].node);
4725 /* We have not condition, so we get rid of the EXIT_EXPR */
4726 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY (yyval.node), 0) =
4727 empty_stmt_node;
4728 }
4729 break;
4730
4731 case 283:
4732 #line 1670 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4733 {yyerror ("Invalid control expression"); RECOVER;}
4734 break;
4735
4736 case 284:
4737 #line 1672 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4738 {yyerror ("Invalid update expression"); RECOVER;}
4739 break;
4740
4741 case 285:
4742 #line 1674 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4743 {yyerror ("Invalid update expression"); RECOVER;}
4744 break;
4745
4746 case 286:
4747 #line 1679 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4748 { yyval.node = finish_for_loop (EXPR_WFL_LINECOL (yyvsp[-4].node), yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node);}
4749 break;
4750
4751 case 287:
4752 #line 1681 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4753 {
4754 yyval.node = finish_for_loop (0, NULL_TREE, yyvsp[-2].node, yyvsp[0].node);
4755 /* We have not condition, so we get rid of the EXIT_EXPR */
4756 LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY (yyval.node), 0) =
4757 empty_stmt_node;
4758 }
4759 break;
4760
4761 case 288:
4762 #line 1691 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4763 {
4764 /* This scope defined for local variable that may be
4765 defined within the scope of the for loop */
4766 enter_block ();
4767 }
4768 break;
4769
4770 case 289:
4771 #line 1697 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4772 {yyerror ("'(' expected"); DRECOVER(for_1);}
4773 break;
4774
4775 case 290:
4776 #line 1699 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4777 {yyerror ("Invalid init statement"); RECOVER;}
4778 break;
4779
4780 case 291:
4781 #line 1704 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4782 {
4783 /* We now declare the loop body. The loop is
4784 declared as a for loop. */
4785 tree body = build_loop_body (0, NULL_TREE, 0);
4786 yyval.node = build_new_loop (body);
4787 FOR_LOOP_P (yyval.node) = 1;
4788 /* The loop is added to the current block the for
4789 statement is defined within */
4790 java_method_add_stmt (current_function_decl, yyval.node);
4791 }
4792 break;
4793
4794 case 292:
4795 #line 1716 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4796 { yyval.node = empty_stmt_node; }
4797 break;
4798
4799 case 293:
4800 #line 1718 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4801 {
4802 /* Init statement recorded within the previously
4803 defined block scope */
4804 yyval.node = java_method_add_stmt (current_function_decl, yyvsp[0].node);
4805 }
4806 break;
4807
4808 case 294:
4809 #line 1724 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4810 {
4811 /* Local variable are recorded within the previously
4812 defined block scope */
4813 yyval.node = NULL_TREE;
4814 }
4815 break;
4816
4817 case 295:
4818 #line 1730 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4819 {yyerror ("';' expected"); DRECOVER(for_init_1);}
4820 break;
4821
4822 case 296:
4823 #line 1734 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4824 {yyval.node = empty_stmt_node;}
4825 break;
4826
4827 case 297:
4828 #line 1736 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4829 { yyval.node = build_debugable_stmt (BUILD_LOCATION (), yyvsp[0].node); }
4830 break;
4831
4832 case 298:
4833 #line 1741 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4834 { yyval.node = add_stmt_to_compound (NULL_TREE, NULL_TREE, yyvsp[0].node); }
4835 break;
4836
4837 case 299:
4838 #line 1743 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4839 { yyval.node = add_stmt_to_compound (yyvsp[-2].node, NULL_TREE, yyvsp[0].node); }
4840 break;
4841
4842 case 300:
4843 #line 1745 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4844 {yyerror ("Missing term"); RECOVER;}
4845 break;
4846
4847 case 301:
4848 #line 1750 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4849 { yyval.node = build_bc_statement (yyvsp[-1].operator.location, 1, NULL_TREE); }
4850 break;
4851
4852 case 302:
4853 #line 1752 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4854 { yyval.node = build_bc_statement (yyvsp[-2].operator.location, 1, yyvsp[-1].node); }
4855 break;
4856
4857 case 303:
4858 #line 1754 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4859 {yyerror ("Missing term"); RECOVER;}
4860 break;
4861
4862 case 304:
4863 #line 1756 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4864 {yyerror ("';' expected"); RECOVER;}
4865 break;
4866
4867 case 305:
4868 #line 1761 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4869 { yyval.node = build_bc_statement (yyvsp[-1].operator.location, 0, NULL_TREE); }
4870 break;
4871
4872 case 306:
4873 #line 1763 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4874 { yyval.node = build_bc_statement (yyvsp[-2].operator.location, 0, yyvsp[-1].node); }
4875 break;
4876
4877 case 307:
4878 #line 1765 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4879 {yyerror ("Missing term"); RECOVER;}
4880 break;
4881
4882 case 308:
4883 #line 1767 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4884 {yyerror ("';' expected"); RECOVER;}
4885 break;
4886
4887 case 309:
4888 #line 1772 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4889 { yyval.node = build_return (yyvsp[-1].operator.location, NULL_TREE); }
4890 break;
4891
4892 case 310:
4893 #line 1774 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4894 { yyval.node = build_return (yyvsp[-2].operator.location, yyvsp[-1].node); }
4895 break;
4896
4897 case 311:
4898 #line 1776 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4899 {yyerror ("Missing term"); RECOVER;}
4900 break;
4901
4902 case 312:
4903 #line 1778 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4904 {yyerror ("';' expected"); RECOVER;}
4905 break;
4906
4907 case 313:
4908 #line 1783 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4909 {
4910 yyval.node = build1 (THROW_EXPR, NULL_TREE, yyvsp[-1].node);
4911 EXPR_WFL_LINECOL (yyval.node) = yyvsp[-2].operator.location;
4912 }
4913 break;
4914
4915 case 314:
4916 #line 1788 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4917 {yyerror ("Missing term"); RECOVER;}
4918 break;
4919
4920 case 315:
4921 #line 1790 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4922 {yyerror ("';' expected"); RECOVER;}
4923 break;
4924
4925 case 316:
4926 #line 1795 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4927 {
4928 yyval.node = build_assertion (yyvsp[-4].operator.location, yyvsp[-3].node, yyvsp[-1].node);
4929 }
4930 break;
4931
4932 case 317:
4933 #line 1799 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4934 {
4935 yyval.node = build_assertion (yyvsp[-2].operator.location, yyvsp[-1].node, NULL_TREE);
4936 }
4937 break;
4938
4939 case 318:
4940 #line 1803 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4941 {yyerror ("Missing term"); RECOVER;}
4942 break;
4943
4944 case 319:
4945 #line 1805 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4946 {yyerror ("';' expected"); RECOVER;}
4947 break;
4948
4949 case 320:
4950 #line 1810 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4951 {
4952 yyval.node = build (SYNCHRONIZED_EXPR, NULL_TREE, yyvsp[-2].node, yyvsp[0].node);
4953 EXPR_WFL_LINECOL (yyval.node) =
4954 EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
4955 }
4956 break;
4957
4958 case 321:
4959 #line 1816 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4960 {yyerror ("'{' expected"); RECOVER;}
4961 break;
4962
4963 case 322:
4964 #line 1818 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4965 {yyerror ("'(' expected"); RECOVER;}
4966 break;
4967
4968 case 323:
4969 #line 1820 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4970 {yyerror ("Missing term"); RECOVER;}
4971 break;
4972
4973 case 324:
4974 #line 1822 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4975 {yyerror ("Missing term"); RECOVER;}
4976 break;
4977
4978 case 325:
4979 #line 1827 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4980 {
4981 check_modifiers (
4982 "Illegal modifier `%s'. Only `synchronized' was expected here",
4983 yyvsp[0].value, ACC_SYNCHRONIZED);
4984 if (yyvsp[0].value != ACC_SYNCHRONIZED)
4985 MODIFIER_WFL (SYNCHRONIZED_TK) =
4986 build_wfl_node (NULL_TREE);
4987 }
4988 break;
4989
4990 case 326:
4991 #line 1839 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4992 { yyval.node = build_try_statement (yyvsp[-2].operator.location, yyvsp[-1].node, yyvsp[0].node); }
4993 break;
4994
4995 case 327:
4996 #line 1841 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
4997 { yyval.node = build_try_finally_statement (yyvsp[-2].operator.location, yyvsp[-1].node, yyvsp[0].node); }
4998 break;
4999
5000 case 328:
5001 #line 1843 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5002 { yyval.node = build_try_finally_statement
5003 (yyvsp[-3].operator.location, build_try_statement (yyvsp[-3].operator.location,
5004 yyvsp[-2].node, yyvsp[-1].node), yyvsp[0].node);
5005 }
5006 break;
5007
5008 case 329:
5009 #line 1848 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5010 {yyerror ("'{' expected"); DRECOVER (try_statement);}
5011 break;
5012
5013 case 331:
5014 #line 1854 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5015 {
5016 TREE_CHAIN (yyvsp[0].node) = yyvsp[-1].node;
5017 yyval.node = yyvsp[0].node;
5018 }
5019 break;
5020
5021 case 332:
5022 #line 1862 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5023 {
5024 java_method_add_stmt (current_function_decl, yyvsp[0].node);
5025 exit_block ();
5026 yyval.node = yyvsp[-1].node;
5027 }
5028 break;
5029
5030 case 333:
5031 #line 1871 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5032 {
5033 /* We add a block to define a scope for
5034 formal_parameter (CCBP). The formal parameter is
5035 declared initialized by the appropriate function
5036 call */
5037 tree ccpb = enter_block ();
5038 tree init = build_assignment
5039 (ASSIGN_TK, yyvsp[-2].operator.location, TREE_PURPOSE (yyvsp[-1].node),
5040 build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
5041 declare_local_variables (0, TREE_VALUE (yyvsp[-1].node),
5042 build_tree_list (TREE_PURPOSE (yyvsp[-1].node),
5043 init));
5044 yyval.node = build1 (CATCH_EXPR, NULL_TREE, ccpb);
5045 EXPR_WFL_LINECOL (yyval.node) = yyvsp[-3].operator.location;
5046 }
5047 break;
5048
5049 case 334:
5050 #line 1887 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5051 {yyerror ("'(' expected"); RECOVER; yyval.node = NULL_TREE;}
5052 break;
5053
5054 case 335:
5055 #line 1889 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5056 {
5057 yyerror ("Missing term or ')' expected");
5058 RECOVER; yyval.node = NULL_TREE;
5059 }
5060 break;
5061
5062 case 336:
5063 #line 1894 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5064 {yyerror ("Missing term"); RECOVER; yyval.node = NULL_TREE;}
5065 break;
5066
5067 case 337:
5068 #line 1899 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5069 { yyval.node = yyvsp[0].node; }
5070 break;
5071
5072 case 338:
5073 #line 1901 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5074 {yyerror ("'{' expected"); RECOVER; }
5075 break;
5076
5077 case 342:
5078 #line 1913 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5079 { yyval.node = build_this (yyvsp[0].operator.location); }
5080 break;
5081
5082 case 343:
5083 #line 1915 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5084 {yyval.node = yyvsp[-1].node;}
5085 break;
5086
5087 case 349:
5088 #line 1923 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5089 {
5090 tree wfl = build_wfl_node (this_identifier_node);
5091 yyval.node = make_qualified_primary (yyvsp[-2].node, wfl, EXPR_WFL_LINECOL (yyvsp[-2].node));
5092 }
5093 break;
5094
5095 case 350:
5096 #line 1928 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5097 {yyerror ("')' expected"); RECOVER;}
5098 break;
5099
5100 case 351:
5101 #line 1930 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5102 {yyerror ("'class' or 'this' expected" ); RECOVER;}
5103 break;
5104
5105 case 352:
5106 #line 1932 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5107 {yyerror ("'class' expected" ); RECOVER;}
5108 break;
5109
5110 case 353:
5111 #line 1934 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5112 {yyerror ("'class' expected" ); RECOVER;}
5113 break;
5114
5115 case 354:
5116 #line 1939 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5117 { yyval.node = build_incomplete_class_ref (yyvsp[-1].operator.location, yyvsp[-2].node); }
5118 break;
5119
5120 case 355:
5121 #line 1941 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5122 { yyval.node = build_incomplete_class_ref (yyvsp[-1].operator.location, yyvsp[-2].node); }
5123 break;
5124
5125 case 356:
5126 #line 1943 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5127 { yyval.node = build_incomplete_class_ref (yyvsp[-1].operator.location, yyvsp[-2].node); }
5128 break;
5129
5130 case 357:
5131 #line 1945 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5132 {
5133 yyval.node = build_incomplete_class_ref (yyvsp[-1].operator.location,
5134 void_type_node);
5135 }
5136 break;
5137
5138 case 358:
5139 #line 1953 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5140 { yyval.node = build_new_invocation (yyvsp[-3].node, yyvsp[-1].node); }
5141 break;
5142
5143 case 359:
5144 #line 1955 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5145 { yyval.node = build_new_invocation (yyvsp[-2].node, NULL_TREE); }
5146 break;
5147
5148 case 361:
5149 #line 1959 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5150 {
5151 tree ctor = build_new_invocation (yyvsp[-2].node, NULL_TREE);
5152 yyval.node = make_qualified_primary (yyvsp[-3].node, ctor,
5153 EXPR_WFL_LINECOL (yyvsp[-3].node));
5154 }
5155 break;
5156
5157 case 363:
5158 #line 1966 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5159 {
5160 tree ctor = build_new_invocation (yyvsp[-3].node, yyvsp[-1].node);
5161 yyval.node = make_qualified_primary (yyvsp[-4].node, ctor,
5162 EXPR_WFL_LINECOL (yyvsp[-4].node));
5163 }
5164 break;
5165
5166 case 365:
5167 #line 1973 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5168 {yyerror ("'(' expected"); DRECOVER(new_1);}
5169 break;
5170
5171 case 366:
5172 #line 1975 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5173 {yyerror ("'(' expected"); RECOVER;}
5174 break;
5175
5176 case 367:
5177 #line 1977 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5178 {yyerror ("')' or term expected"); RECOVER;}
5179 break;
5180
5181 case 368:
5182 #line 1979 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5183 {yyerror ("')' expected"); RECOVER;}
5184 break;
5185
5186 case 369:
5187 #line 1981 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5188 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
5189 break;
5190
5191 case 370:
5192 #line 1983 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5193 {yyerror ("'(' expected"); RECOVER;}
5194 break;
5195
5196 case 371:
5197 #line 1990 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5198 { create_anonymous_class (yyvsp[-4].operator.location, yyvsp[-3].node); }
5199 break;
5200
5201 case 372:
5202 #line 1992 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5203 {
5204 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
5205 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL (yyvsp[-5].node);
5206
5207 end_class_declaration (1);
5208
5209 /* Now we can craft the new expression */
5210 yyval.node = build_new_invocation (id, yyvsp[-3].node);
5211
5212 /* Note that we can't possibly be here if
5213 `class_type' is an interface (in which case the
5214 anonymous class extends Object and implements
5215 `class_type', hence its constructor can't have
5216 arguments.) */
5217
5218 /* Otherwise, the innerclass must feature a
5219 constructor matching `argument_list'. Anonymous
5220 classes are a bit special: it's impossible to
5221 define constructor for them, hence constructors
5222 must be generated following the hints provided by
5223 the `new' expression. Whether a super constructor
5224 of that nature exists or not is to be verified
5225 later on in verify_constructor_super.
5226
5227 It's during the expansion of a `new' statement
5228 refering to an anonymous class that a ctor will
5229 be generated for the anonymous class, with the
5230 right arguments. */
5231
5232 }
5233 break;
5234
5235 case 373:
5236 #line 2023 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5237 { create_anonymous_class (yyvsp[-3].operator.location, yyvsp[-2].node); }
5238 break;
5239
5240 case 374:
5241 #line 2025 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5242 {
5243 tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
5244 EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL (yyvsp[-4].node);
5245
5246 end_class_declaration (1);
5247
5248 /* Now we can craft the new expression. The
5249 statement doesn't need to be remember so that a
5250 constructor can be generated, since its signature
5251 is already known. */
5252 yyval.node = build_new_invocation (id, NULL_TREE);
5253 }
5254 break;
5255
5256 case 375:
5257 #line 2041 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5258 { yyval.node = yyvsp[-2].node; }
5259 break;
5260
5261 case 376:
5262 #line 2043 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5263 { yyval.node = yyvsp[-2].node; }
5264 break;
5265
5266 case 377:
5267 #line 2048 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5268 {
5269 yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, NULL_TREE);
5270 ctxp->formal_parameter_number = 1;
5271 }
5272 break;
5273
5274 case 378:
5275 #line 2053 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5276 {
5277 ctxp->formal_parameter_number += 1;
5278 yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, yyvsp[-2].node);
5279 }
5280 break;
5281
5282 case 379:
5283 #line 2058 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5284 {yyerror ("Missing term"); RECOVER;}
5285 break;
5286
5287 case 380:
5288 #line 2063 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5289 { yyval.node = build_newarray_node (yyvsp[-1].node, yyvsp[0].node, 0); }
5290 break;
5291
5292 case 381:
5293 #line 2065 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5294 { yyval.node = build_newarray_node (yyvsp[-1].node, yyvsp[0].node, 0); }
5295 break;
5296
5297 case 382:
5298 #line 2067 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5299 { yyval.node = build_newarray_node (yyvsp[-2].node, yyvsp[-1].node, pop_current_osb (ctxp));}
5300 break;
5301
5302 case 383:
5303 #line 2069 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5304 { yyval.node = build_newarray_node (yyvsp[-2].node, yyvsp[-1].node, pop_current_osb (ctxp));}
5305 break;
5306
5307 case 384:
5308 #line 2072 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5309 {
5310 char *sig;
5311 int osb = pop_current_osb (ctxp);
5312 while (osb--)
5313 obstack_grow (&temporary_obstack, "[]", 2);
5314 obstack_1grow (&temporary_obstack, '\0');
5315 sig = obstack_finish (&temporary_obstack);
5316 yyval.node = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
5317 yyvsp[-2].node, get_identifier (sig), yyvsp[0].node);
5318 }
5319 break;
5320
5321 case 385:
5322 #line 2083 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5323 {
5324 int osb = pop_current_osb (ctxp);
5325 tree type = yyvsp[-2].node;
5326 while (osb--)
5327 type = build_java_array_type (type, -1);
5328 yyval.node = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
5329 build_pointer_type (type), NULL_TREE, yyvsp[0].node);
5330 }
5331 break;
5332
5333 case 386:
5334 #line 2092 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5335 {yyerror ("'[' expected"); DRECOVER ("]");}
5336 break;
5337
5338 case 387:
5339 #line 2094 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5340 {yyerror ("']' expected"); RECOVER;}
5341 break;
5342
5343 case 388:
5344 #line 2099 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5345 { yyval.node = build_tree_list (NULL_TREE, yyvsp[0].node); }
5346 break;
5347
5348 case 389:
5349 #line 2101 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5350 { yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, yyval.node); }
5351 break;
5352
5353 case 390:
5354 #line 2106 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5355 {
5356 if (JNUMERIC_TYPE_P (TREE_TYPE (yyvsp[-1].node)))
5357 {
5358 yyvsp[-1].node = build_wfl_node (yyvsp[-1].node);
5359 TREE_TYPE (yyvsp[-1].node) = NULL_TREE;
5360 }
5361 EXPR_WFL_LINECOL (yyvsp[-1].node) = yyvsp[-2].operator.location;
5362 yyval.node = yyvsp[-1].node;
5363 }
5364 break;
5365
5366 case 391:
5367 #line 2116 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5368 {yyerror ("']' expected"); RECOVER;}
5369 break;
5370
5371 case 392:
5372 #line 2118 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5373 {
5374 yyerror ("Missing term");
5375 yyerror ("']' expected");
5376 RECOVER;
5377 }
5378 break;
5379
5380 case 393:
5381 #line 2127 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5382 {
5383 int allocate = 0;
5384 /* If not initialized, allocate memory for the osb
5385 numbers stack */
5386 if (!ctxp->osb_limit)
5387 {
5388 allocate = ctxp->osb_limit = 32;
5389 ctxp->osb_depth = -1;
5390 }
5391 /* If capacity overflown, reallocate a bigger chunk */
5392 else if (ctxp->osb_depth+1 == ctxp->osb_limit)
5393 allocate = ctxp->osb_limit << 1;
5394
5395 if (allocate)
5396 {
5397 allocate *= sizeof (int);
5398 if (ctxp->osb_number)
5399 ctxp->osb_number = (int *)xrealloc (ctxp->osb_number,
5400 allocate);
5401 else
5402 ctxp->osb_number = (int *)xmalloc (allocate);
5403 }
5404 ctxp->osb_depth++;
5405 CURRENT_OSB (ctxp) = 1;
5406 }
5407 break;
5408
5409 case 394:
5410 #line 2153 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5411 { CURRENT_OSB (ctxp)++; }
5412 break;
5413
5414 case 395:
5415 #line 2155 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5416 { yyerror ("']' expected"); RECOVER;}
5417 break;
5418
5419 case 396:
5420 #line 2160 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5421 { yyval.node = make_qualified_primary (yyvsp[-2].node, yyvsp[0].node, yyvsp[-1].operator.location); }
5422 break;
5423
5424 case 397:
5425 #line 2163 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5426 {
5427 tree super_wfl = build_wfl_node (super_identifier_node);
5428 EXPR_WFL_LINECOL (super_wfl) = yyvsp[-2].operator.location;
5429 yyval.node = make_qualified_name (super_wfl, yyvsp[0].node, yyvsp[-1].operator.location);
5430 }
5431 break;
5432
5433 case 398:
5434 #line 2169 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5435 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
5436 break;
5437
5438 case 399:
5439 #line 2174 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5440 { yyval.node = build_method_invocation (yyvsp[-2].node, NULL_TREE); }
5441 break;
5442
5443 case 400:
5444 #line 2176 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5445 { yyval.node = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node); }
5446 break;
5447
5448 case 401:
5449 #line 2178 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5450 {
5451 if (TREE_CODE (yyvsp[-4].node) == THIS_EXPR)
5452 yyval.node = build_this_super_qualified_invocation
5453 (1, yyvsp[-2].node, NULL_TREE, 0, yyvsp[-3].operator.location);
5454 else
5455 {
5456 tree invok = build_method_invocation (yyvsp[-2].node, NULL_TREE);
5457 yyval.node = make_qualified_primary (yyvsp[-4].node, invok, yyvsp[-3].operator.location);
5458 }
5459 }
5460 break;
5461
5462 case 402:
5463 #line 2189 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5464 {
5465 if (TREE_CODE (yyvsp[-5].node) == THIS_EXPR)
5466 yyval.node = build_this_super_qualified_invocation
5467 (1, yyvsp[-3].node, yyvsp[-1].node, 0, yyvsp[-4].operator.location);
5468 else
5469 {
5470 tree invok = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node);
5471 yyval.node = make_qualified_primary (yyvsp[-5].node, invok, yyvsp[-4].operator.location);
5472 }
5473 }
5474 break;
5475
5476 case 403:
5477 #line 2200 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5478 {
5479 yyval.node = build_this_super_qualified_invocation
5480 (0, yyvsp[-2].node, NULL_TREE, yyvsp[-4].operator.location, yyvsp[-3].operator.location);
5481 }
5482 break;
5483
5484 case 404:
5485 #line 2205 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5486 {
5487 yyval.node = build_this_super_qualified_invocation
5488 (0, yyvsp[-3].node, yyvsp[-1].node, yyvsp[-5].operator.location, yyvsp[-4].operator.location);
5489 }
5490 break;
5491
5492 case 405:
5493 #line 2211 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5494 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
5495 break;
5496
5497 case 406:
5498 #line 2213 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5499 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
5500 break;
5501
5502 case 407:
5503 #line 2218 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5504 { yyval.node = build_array_ref (yyvsp[-2].operator.location, yyvsp[-3].node, yyvsp[-1].node); }
5505 break;
5506
5507 case 408:
5508 #line 2220 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5509 { yyval.node = build_array_ref (yyvsp[-2].operator.location, yyvsp[-3].node, yyvsp[-1].node); }
5510 break;
5511
5512 case 409:
5513 #line 2222 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5514 {
5515 yyerror ("Missing term and ']' expected");
5516 DRECOVER(array_access);
5517 }
5518 break;
5519
5520 case 410:
5521 #line 2227 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5522 {
5523 yyerror ("']' expected");
5524 DRECOVER(array_access);
5525 }
5526 break;
5527
5528 case 411:
5529 #line 2232 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5530 {
5531 yyerror ("Missing term and ']' expected");
5532 DRECOVER(array_access);
5533 }
5534 break;
5535
5536 case 412:
5537 #line 2237 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5538 {
5539 yyerror ("']' expected");
5540 DRECOVER(array_access);
5541 }
5542 break;
5543
5544 case 417:
5545 #line 2252 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5546 { yyval.node = build_incdec (yyvsp[0].operator.token, yyvsp[0].operator.location, yyvsp[-1].node, 1); }
5547 break;
5548
5549 case 418:
5550 #line 2257 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5551 { yyval.node = build_incdec (yyvsp[0].operator.token, yyvsp[0].operator.location, yyvsp[-1].node, 1); }
5552 break;
5553
5554 case 421:
5555 #line 2264 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5556 {yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); }
5557 break;
5558
5559 case 423:
5560 #line 2267 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5561 {yyerror ("Missing term"); RECOVER}
5562 break;
5563
5564 case 424:
5565 #line 2272 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5566 {
5567 error_if_numeric_overflow (yyvsp[0].node);
5568 yyval.node = yyvsp[0].node;
5569 }
5570 break;
5571
5572 case 425:
5573 #line 2277 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5574 {yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); }
5575 break;
5576
5577 case 426:
5578 #line 2279 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5579 {yyerror ("Missing term"); RECOVER}
5580 break;
5581
5582 case 427:
5583 #line 2284 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5584 {yyval.node = build_incdec (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node, 0); }
5585 break;
5586
5587 case 428:
5588 #line 2286 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5589 {yyerror ("Missing term"); RECOVER}
5590 break;
5591
5592 case 429:
5593 #line 2291 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5594 {yyval.node = build_incdec (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node, 0); }
5595 break;
5596
5597 case 430:
5598 #line 2293 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5599 {yyerror ("Missing term"); RECOVER}
5600 break;
5601
5602 case 432:
5603 #line 2299 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5604 {yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); }
5605 break;
5606
5607 case 433:
5608 #line 2301 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5609 {yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); }
5610 break;
5611
5612 case 435:
5613 #line 2304 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5614 {yyerror ("Missing term"); RECOVER}
5615 break;
5616
5617 case 436:
5618 #line 2306 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5619 {yyerror ("Missing term"); RECOVER}
5620 break;
5621
5622 case 437:
5623 #line 2311 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5624 {
5625 tree type = yyvsp[-3].node;
5626 int osb = pop_current_osb (ctxp);
5627 while (osb--)
5628 type = build_java_array_type (type, -1);
5629 yyval.node = build_cast (yyvsp[-4].operator.location, type, yyvsp[0].node);
5630 }
5631 break;
5632
5633 case 438:
5634 #line 2319 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5635 { yyval.node = build_cast (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[0].node); }
5636 break;
5637
5638 case 439:
5639 #line 2321 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5640 { yyval.node = build_cast (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[0].node); }
5641 break;
5642
5643 case 440:
5644 #line 2323 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5645 {
5646 const char *ptr;
5647 int osb = pop_current_osb (ctxp);
5648 obstack_grow (&temporary_obstack,
5649 IDENTIFIER_POINTER (EXPR_WFL_NODE (yyvsp[-3].node)),
5650 IDENTIFIER_LENGTH (EXPR_WFL_NODE (yyvsp[-3].node)));
5651 while (osb--)
5652 obstack_grow (&temporary_obstack, "[]", 2);
5653 obstack_1grow (&temporary_obstack, '\0');
5654 ptr = obstack_finish (&temporary_obstack);
5655 EXPR_WFL_NODE (yyvsp[-3].node) = get_identifier (ptr);
5656 yyval.node = build_cast (yyvsp[-4].operator.location, yyvsp[-3].node, yyvsp[0].node);
5657 }
5658 break;
5659
5660 case 441:
5661 #line 2337 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5662 {yyerror ("']' expected, invalid type expression");}
5663 break;
5664
5665 case 442:
5666 #line 2339 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5667 {
5668 YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
5669 RECOVER;
5670 }
5671 break;
5672
5673 case 443:
5674 #line 2344 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5675 {yyerror ("Missing term"); RECOVER;}
5676 break;
5677
5678 case 444:
5679 #line 2346 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5680 {yyerror ("Missing term"); RECOVER;}
5681 break;
5682
5683 case 445:
5684 #line 2348 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5685 {yyerror ("Missing term"); RECOVER;}
5686 break;
5687
5688 case 447:
5689 #line 2354 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5690 {
5691 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token),
5692 yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node);
5693 }
5694 break;
5695
5696 case 448:
5697 #line 2359 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5698 {
5699 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5700 yyvsp[-2].node, yyvsp[0].node);
5701 }
5702 break;
5703
5704 case 449:
5705 #line 2364 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5706 {
5707 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5708 yyvsp[-2].node, yyvsp[0].node);
5709 }
5710 break;
5711
5712 case 450:
5713 #line 2369 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5714 {yyerror ("Missing term"); RECOVER;}
5715 break;
5716
5717 case 451:
5718 #line 2371 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5719 {yyerror ("Missing term"); RECOVER;}
5720 break;
5721
5722 case 452:
5723 #line 2373 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5724 {yyerror ("Missing term"); RECOVER;}
5725 break;
5726
5727 case 454:
5728 #line 2379 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5729 {
5730 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5731 yyvsp[-2].node, yyvsp[0].node);
5732 }
5733 break;
5734
5735 case 455:
5736 #line 2384 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5737 {
5738 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5739 yyvsp[-2].node, yyvsp[0].node);
5740 }
5741 break;
5742
5743 case 456:
5744 #line 2389 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5745 {yyerror ("Missing term"); RECOVER;}
5746 break;
5747
5748 case 457:
5749 #line 2391 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5750 {yyerror ("Missing term"); RECOVER;}
5751 break;
5752
5753 case 459:
5754 #line 2397 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5755 {
5756 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5757 yyvsp[-2].node, yyvsp[0].node);
5758 }
5759 break;
5760
5761 case 460:
5762 #line 2402 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5763 {
5764 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5765 yyvsp[-2].node, yyvsp[0].node);
5766 }
5767 break;
5768
5769 case 461:
5770 #line 2407 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5771 {
5772 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5773 yyvsp[-2].node, yyvsp[0].node);
5774 }
5775 break;
5776
5777 case 462:
5778 #line 2412 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5779 {yyerror ("Missing term"); RECOVER;}
5780 break;
5781
5782 case 463:
5783 #line 2414 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5784 {yyerror ("Missing term"); RECOVER;}
5785 break;
5786
5787 case 464:
5788 #line 2416 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5789 {yyerror ("Missing term"); RECOVER;}
5790 break;
5791
5792 case 466:
5793 #line 2422 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5794 {
5795 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5796 yyvsp[-2].node, yyvsp[0].node);
5797 }
5798 break;
5799
5800 case 467:
5801 #line 2427 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5802 {
5803 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5804 yyvsp[-2].node, yyvsp[0].node);
5805 }
5806 break;
5807
5808 case 468:
5809 #line 2432 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5810 {
5811 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5812 yyvsp[-2].node, yyvsp[0].node);
5813 }
5814 break;
5815
5816 case 469:
5817 #line 2437 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5818 {
5819 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5820 yyvsp[-2].node, yyvsp[0].node);
5821 }
5822 break;
5823
5824 case 470:
5825 #line 2442 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5826 { yyval.node = build_binop (INSTANCEOF_EXPR, yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); }
5827 break;
5828
5829 case 471:
5830 #line 2444 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5831 {yyerror ("Missing term"); RECOVER;}
5832 break;
5833
5834 case 472:
5835 #line 2446 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5836 {yyerror ("Missing term"); RECOVER;}
5837 break;
5838
5839 case 473:
5840 #line 2448 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5841 {yyerror ("Missing term"); RECOVER;}
5842 break;
5843
5844 case 474:
5845 #line 2450 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5846 {yyerror ("Missing term"); RECOVER;}
5847 break;
5848
5849 case 475:
5850 #line 2452 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5851 {yyerror ("Invalid reference type"); RECOVER;}
5852 break;
5853
5854 case 477:
5855 #line 2458 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5856 {
5857 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5858 yyvsp[-2].node, yyvsp[0].node);
5859 }
5860 break;
5861
5862 case 478:
5863 #line 2463 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5864 {
5865 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5866 yyvsp[-2].node, yyvsp[0].node);
5867 }
5868 break;
5869
5870 case 479:
5871 #line 2468 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5872 {yyerror ("Missing term"); RECOVER;}
5873 break;
5874
5875 case 480:
5876 #line 2470 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5877 {yyerror ("Missing term"); RECOVER;}
5878 break;
5879
5880 case 482:
5881 #line 2476 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5882 {
5883 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5884 yyvsp[-2].node, yyvsp[0].node);
5885 }
5886 break;
5887
5888 case 483:
5889 #line 2481 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5890 {yyerror ("Missing term"); RECOVER;}
5891 break;
5892
5893 case 485:
5894 #line 2487 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5895 {
5896 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5897 yyvsp[-2].node, yyvsp[0].node);
5898 }
5899 break;
5900
5901 case 486:
5902 #line 2492 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5903 {yyerror ("Missing term"); RECOVER;}
5904 break;
5905
5906 case 488:
5907 #line 2498 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5908 {
5909 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5910 yyvsp[-2].node, yyvsp[0].node);
5911 }
5912 break;
5913
5914 case 489:
5915 #line 2503 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5916 {yyerror ("Missing term"); RECOVER;}
5917 break;
5918
5919 case 491:
5920 #line 2509 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5921 {
5922 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5923 yyvsp[-2].node, yyvsp[0].node);
5924 }
5925 break;
5926
5927 case 492:
5928 #line 2514 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5929 {yyerror ("Missing term"); RECOVER;}
5930 break;
5931
5932 case 494:
5933 #line 2520 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5934 {
5935 yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
5936 yyvsp[-2].node, yyvsp[0].node);
5937 }
5938 break;
5939
5940 case 495:
5941 #line 2525 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5942 {yyerror ("Missing term"); RECOVER;}
5943 break;
5944
5945 case 497:
5946 #line 2531 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5947 {
5948 yyval.node = build (CONDITIONAL_EXPR, NULL_TREE, yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node);
5949 EXPR_WFL_LINECOL (yyval.node) = yyvsp[-3].operator.location;
5950 }
5951 break;
5952
5953 case 498:
5954 #line 2536 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5955 {
5956 YYERROR_NOW;
5957 yyerror ("Missing term");
5958 DRECOVER (1);
5959 }
5960 break;
5961
5962 case 499:
5963 #line 2542 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5964 {yyerror ("Missing term"); DRECOVER (2);}
5965 break;
5966
5967 case 500:
5968 #line 2544 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5969 {yyerror ("Missing term"); DRECOVER (3);}
5970 break;
5971
5972 case 503:
5973 #line 2554 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5974 { yyval.node = build_assignment (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); }
5975 break;
5976
5977 case 504:
5978 #line 2556 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
5979 {
5980 YYNOT_TWICE yyerror ("Missing term");
5981 DRECOVER (assign);
5982 }
5983 break;
5984
5985
5986 }
5987
5988 /* Line 1016 of /usr/share/bison/yacc.c. */
5989 #line 5990 "p13913.c"
5990
5991 yyvsp -= yylen;
5992 yyssp -= yylen;
5993
5994
5995 #if YYDEBUG
5996 if (yydebug)
5997 {
5998 short *yyssp1 = yyss - 1;
5999 YYFPRINTF (stderr, "state stack now");
6000 while (yyssp1 != yyssp)
6001 YYFPRINTF (stderr, " %d", *++yyssp1);
6002 YYFPRINTF (stderr, "\n");
6003 }
6004 #endif
6005
6006 *++yyvsp = yyval;
6007
6008
6009 /* Now `shift' the result of the reduction. Determine what state
6010 that goes to, based on the state we popped back to and the rule
6011 number reduced by. */
6012
6013 yyn = yyr1[yyn];
6014
6015 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
6016 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
6017 yystate = yytable[yystate];
6018 else
6019 yystate = yydefgoto[yyn - YYNTOKENS];
6020
6021 goto yynewstate;
6022
6023
6024 /*------------------------------------.
6025 | yyerrlab -- here on detecting error |
6026 `------------------------------------*/
6027 yyerrlab:
6028 /* If not already recovering from an error, report this error. */
6029 if (!yyerrstatus)
6030 {
6031 ++yynerrs;
6032 #if YYERROR_VERBOSE
6033 yyn = yypact[yystate];
6034
6035 if (YYPACT_NINF < yyn && yyn < YYLAST)
6036 {
6037 YYSIZE_T yysize = 0;
6038 int yytype = YYTRANSLATE (yychar);
6039 char *yymsg;
6040 int yyx, yycount;
6041
6042 yycount = 0;
6043 /* Start YYX at -YYN if negative to avoid negative indexes in
6044 YYCHECK. */
6045 for (yyx = yyn < 0 ? -yyn : 0;
6046 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
6047 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
6048 yysize += yystrlen (yytname[yyx]) + 15, yycount++;
6049 yysize += yystrlen ("parse error, unexpected ") + 1;
6050 yysize += yystrlen (yytname[yytype]);
6051 yymsg = (char *) YYSTACK_ALLOC (yysize);
6052 if (yymsg != 0)
6053 {
6054 char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
6055 yyp = yystpcpy (yyp, yytname[yytype]);
6056
6057 if (yycount < 5)
6058 {
6059 yycount = 0;
6060 for (yyx = yyn < 0 ? -yyn : 0;
6061 yyx < (int) (sizeof (yytname) / sizeof (char *));
6062 yyx++)
6063 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
6064 {
6065 const char *yyq = ! yycount ? ", expecting " : " or ";
6066 yyp = yystpcpy (yyp, yyq);
6067 yyp = yystpcpy (yyp, yytname[yyx]);
6068 yycount++;
6069 }
6070 }
6071 yyerror (yymsg);
6072 YYSTACK_FREE (yymsg);
6073 }
6074 else
6075 yyerror ("parse error; also virtual memory exhausted");
6076 }
6077 else
6078 #endif /* YYERROR_VERBOSE */
6079 yyerror ("parse error");
6080 }
6081 goto yyerrlab1;
6082
6083
6084 /*----------------------------------------------------.
6085 | yyerrlab1 -- error raised explicitly by an action. |
6086 `----------------------------------------------------*/
6087 yyerrlab1:
6088 if (yyerrstatus == 3)
6089 {
6090 /* If just tried and failed to reuse lookahead token after an
6091 error, discard it. */
6092
6093 /* Return failure if at end of input. */
6094 if (yychar == YYEOF)
6095 {
6096 /* Pop the error token. */
6097 YYPOPSTACK;
6098 /* Pop the rest of the stack. */
6099 while (yyssp > yyss)
6100 {
6101 YYDPRINTF ((stderr, "Error: popping "));
6102 YYDSYMPRINT ((stderr,
6103 yystos[*yyssp],
6104 *yyvsp));
6105 YYDPRINTF ((stderr, "\n"));
6106 yydestruct (yystos[*yyssp], *yyvsp);
6107 YYPOPSTACK;
6108 }
6109 YYABORT;
6110 }
6111
6112 YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
6113 yychar, yytname[yychar1]));
6114 yydestruct (yychar1, yylval);
6115 yychar = YYEMPTY;
6116 }
6117
6118 /* Else will try to reuse lookahead token after shifting the error
6119 token. */
6120
6121 yyerrstatus = 3; /* Each real token shifted decrements this. */
6122
6123 for (;;)
6124 {
6125 yyn = yypact[yystate];
6126 if (yyn != YYPACT_NINF)
6127 {
6128 yyn += YYTERROR;
6129 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6130 {
6131 yyn = yytable[yyn];
6132 if (0 < yyn)
6133 break;
6134 }
6135 }
6136
6137 /* Pop the current state because it cannot handle the error token. */
6138 if (yyssp == yyss)
6139 YYABORT;
6140
6141 YYDPRINTF ((stderr, "Error: popping "));
6142 YYDSYMPRINT ((stderr,
6143 yystos[*yyssp], *yyvsp));
6144 YYDPRINTF ((stderr, "\n"));
6145
6146 yydestruct (yystos[yystate], *yyvsp);
6147 yyvsp--;
6148 yystate = *--yyssp;
6149
6150
6151 #if YYDEBUG
6152 if (yydebug)
6153 {
6154 short *yyssp1 = yyss - 1;
6155 YYFPRINTF (stderr, "Error: state stack now");
6156 while (yyssp1 != yyssp)
6157 YYFPRINTF (stderr, " %d", *++yyssp1);
6158 YYFPRINTF (stderr, "\n");
6159 }
6160 #endif
6161 }
6162
6163 if (yyn == YYFINAL)
6164 YYACCEPT;
6165
6166 YYDPRINTF ((stderr, "Shifting error token, "));
6167
6168 *++yyvsp = yylval;
6169
6170
6171 yystate = yyn;
6172 goto yynewstate;
6173
6174
6175 /*-------------------------------------.
6176 | yyacceptlab -- YYACCEPT comes here. |
6177 `-------------------------------------*/
6178 yyacceptlab:
6179 yyresult = 0;
6180 goto yyreturn;
6181
6182 /*-----------------------------------.
6183 | yyabortlab -- YYABORT comes here. |
6184 `-----------------------------------*/
6185 yyabortlab:
6186 yyresult = 1;
6187 goto yyreturn;
6188
6189 #ifndef yyoverflow
6190 /*----------------------------------------------.
6191 | yyoverflowlab -- parser overflow comes here. |
6192 `----------------------------------------------*/
6193 yyoverflowlab:
6194 yyerror ("parser stack overflow");
6195 yyresult = 2;
6196 /* Fall through. */
6197 #endif
6198
6199 yyreturn:
6200 #ifndef yyoverflow
6201 if (yyss != yyssa)
6202 YYSTACK_FREE (yyss);
6203 #endif
6204 return yyresult;
6205 }
6206
6207
6208 #line 2581 "/home/gdr/gcc-3.3.5/gcc-3.3.5/gcc/java/parse.y"
6209
6210
6211 /* Helper function to retrieve an OSB count. Should be used when the
6212 `dims:' rule is being used. */
6213
6214 static int
pop_current_osb(ctxp)6215 pop_current_osb (ctxp)
6216 struct parser_ctxt *ctxp;
6217 {
6218 int to_return;
6219
6220 if (ctxp->osb_depth < 0)
6221 abort ();
6222
6223 to_return = CURRENT_OSB (ctxp);
6224 ctxp->osb_depth--;
6225
6226 return to_return;
6227 }
6228
6229
6230
6231 /* This section of the code deal with save/restoring parser contexts.
6232 Add mode documentation here. FIXME */
6233
6234 /* Helper function. Create a new parser context. With
6235 COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
6236 context is copied, otherwise, the new context is zeroed. The newly
6237 created context becomes the current one. */
6238
6239 static void
create_new_parser_context(copy_from_previous)6240 create_new_parser_context (copy_from_previous)
6241 int copy_from_previous;
6242 {
6243 struct parser_ctxt *new;
6244
6245 new = (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt));
6246 if (copy_from_previous)
6247 {
6248 memcpy ((PTR)new, (PTR)ctxp, sizeof (struct parser_ctxt));
6249 new->saved_data_ctx = 1;
6250 }
6251 else
6252 memset ((PTR) new, 0, sizeof (struct parser_ctxt));
6253
6254 new->next = ctxp;
6255 ctxp = new;
6256 }
6257
6258 /* Create a new parser context and make it the current one. */
6259
6260 void
java_push_parser_context()6261 java_push_parser_context ()
6262 {
6263 create_new_parser_context (0);
6264 }
6265
6266 void
java_pop_parser_context(generate)6267 java_pop_parser_context (generate)
6268 int generate;
6269 {
6270 tree current;
6271 struct parser_ctxt *toFree, *next;
6272
6273 if (!ctxp)
6274 return;
6275
6276 toFree = ctxp;
6277 next = ctxp->next;
6278 if (next)
6279 {
6280 lineno = ctxp->lineno;
6281 current_class = ctxp->class_type;
6282 }
6283
6284 /* If the old and new lexers differ, then free the old one. */
6285 if (ctxp->lexer && next && ctxp->lexer != next->lexer)
6286 java_destroy_lexer (ctxp->lexer);
6287
6288 /* Set the single import class file flag to 0 for the current list
6289 of imported things */
6290 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
6291 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
6292
6293 /* And restore those of the previous context */
6294 if ((ctxp = next)) /* Assignment is really meant here */
6295 for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
6296 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
6297
6298 /* If we pushed a context to parse a class intended to be generated,
6299 we keep it so we can remember the class. What we could actually
6300 do is to just update a list of class names. */
6301 if (generate)
6302 {
6303 toFree->next = ctxp_for_generation;
6304 ctxp_for_generation = toFree;
6305 }
6306 else
6307 free (toFree);
6308 }
6309
6310 /* Create a parser context for the use of saving some global
6311 variables. */
6312
6313 void
java_parser_context_save_global()6314 java_parser_context_save_global ()
6315 {
6316 if (!ctxp)
6317 {
6318 java_push_parser_context ();
6319 ctxp->saved_data_ctx = 1;
6320 }
6321
6322 /* If this context already stores data, create a new one suitable
6323 for data storage. */
6324 else if (ctxp->saved_data)
6325 create_new_parser_context (1);
6326
6327 ctxp->lineno = lineno;
6328 ctxp->class_type = current_class;
6329 ctxp->filename = input_filename;
6330 ctxp->function_decl = current_function_decl;
6331 ctxp->saved_data = 1;
6332 }
6333
6334 /* Restore some global variables from the previous context. Make the
6335 previous context the current one. */
6336
6337 void
java_parser_context_restore_global()6338 java_parser_context_restore_global ()
6339 {
6340 lineno = ctxp->lineno;
6341 current_class = ctxp->class_type;
6342 input_filename = ctxp->filename;
6343 if (wfl_operator)
6344 {
6345 tree s;
6346 BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
6347 EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
6348 }
6349 current_function_decl = ctxp->function_decl;
6350 ctxp->saved_data = 0;
6351 if (ctxp->saved_data_ctx)
6352 java_pop_parser_context (0);
6353 }
6354
6355 /* Suspend vital data for the current class/function being parsed so
6356 that an other class can be parsed. Used to let local/anonymous
6357 classes be parsed. */
6358
6359 static void
java_parser_context_suspend()6360 java_parser_context_suspend ()
6361 {
6362 /* This makes debugging through java_debug_context easier */
6363 static const char *const name = "<inner buffer context>";
6364
6365 /* Duplicate the previous context, use it to save the globals we're
6366 interested in */
6367 create_new_parser_context (1);
6368 ctxp->function_decl = current_function_decl;
6369 ctxp->class_type = current_class;
6370
6371 /* Then create a new context which inherits all data from the
6372 previous one. This will be the new current context */
6373 create_new_parser_context (1);
6374
6375 /* Help debugging */
6376 ctxp->next->filename = name;
6377 }
6378
6379 /* Resume vital data for the current class/function being parsed so
6380 that an other class can be parsed. Used to let local/anonymous
6381 classes be parsed. The trick is the data storing file position
6382 informations must be restored to their current value, so parsing
6383 can resume as if no context was ever saved. */
6384
6385 static void
java_parser_context_resume()6386 java_parser_context_resume ()
6387 {
6388 struct parser_ctxt *old = ctxp; /* This one is to be discarded */
6389 struct parser_ctxt *saver = old->next; /* This one contain saved info */
6390 struct parser_ctxt *restored = saver->next; /* This one is the old current */
6391
6392 /* We need to inherit the list of classes to complete/generate */
6393 restored->classd_list = old->classd_list;
6394 restored->class_list = old->class_list;
6395
6396 /* Restore the current class and function from the saver */
6397 current_class = saver->class_type;
6398 current_function_decl = saver->function_decl;
6399
6400 /* Retrive the restored context */
6401 ctxp = restored;
6402
6403 /* Re-installed the data for the parsing to carry on */
6404 memcpy (&ctxp->marker_begining, &old->marker_begining,
6405 (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
6406
6407 /* Buffer context can now be discarded */
6408 free (saver);
6409 free (old);
6410 }
6411
6412 /* Add a new anchor node to which all statement(s) initializing static
6413 and non static initialized upon declaration field(s) will be
6414 linked. */
6415
6416 static void
java_parser_context_push_initialized_field()6417 java_parser_context_push_initialized_field ()
6418 {
6419 tree node;
6420
6421 node = build_tree_list (NULL_TREE, NULL_TREE);
6422 TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
6423 CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
6424
6425 node = build_tree_list (NULL_TREE, NULL_TREE);
6426 TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
6427 CPC_INITIALIZER_LIST (ctxp) = node;
6428
6429 node = build_tree_list (NULL_TREE, NULL_TREE);
6430 TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
6431 CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
6432 }
6433
6434 /* Pop the lists of initialized field. If this lists aren't empty,
6435 remember them so we can use it to create and populate the finit$
6436 or <clinit> functions. */
6437
6438 static void
java_parser_context_pop_initialized_field()6439 java_parser_context_pop_initialized_field ()
6440 {
6441 tree stmts;
6442 tree class_type = TREE_TYPE (GET_CPC ());
6443
6444 if (CPC_INITIALIZER_LIST (ctxp))
6445 {
6446 stmts = CPC_INITIALIZER_STMT (ctxp);
6447 CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
6448 if (stmts && !java_error_count)
6449 TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
6450 }
6451
6452 if (CPC_STATIC_INITIALIZER_LIST (ctxp))
6453 {
6454 stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
6455 CPC_STATIC_INITIALIZER_LIST (ctxp) =
6456 TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
6457 /* Keep initialization in order to enforce 8.5 */
6458 if (stmts && !java_error_count)
6459 TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
6460 }
6461
6462 /* JDK 1.1 instance initializers */
6463 if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
6464 {
6465 stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
6466 CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
6467 TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
6468 if (stmts && !java_error_count)
6469 TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
6470 }
6471 }
6472
6473 static tree
reorder_static_initialized(list)6474 reorder_static_initialized (list)
6475 tree list;
6476 {
6477 /* We have to keep things in order. The alias initializer have to
6478 come first, then the initialized regular field, in reverse to
6479 keep them in lexical order. */
6480 tree marker, previous = NULL_TREE;
6481 for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
6482 if (TREE_CODE (marker) == TREE_LIST
6483 && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
6484 break;
6485
6486 /* No static initialized, the list is fine as is */
6487 if (!previous)
6488 list = TREE_CHAIN (marker);
6489
6490 /* No marker? reverse the whole list */
6491 else if (!marker)
6492 list = nreverse (list);
6493
6494 /* Otherwise, reverse what's after the marker and the new reordered
6495 sublist will replace the marker. */
6496 else
6497 {
6498 TREE_CHAIN (previous) = NULL_TREE;
6499 list = nreverse (list);
6500 list = chainon (TREE_CHAIN (marker), list);
6501 }
6502 return list;
6503 }
6504
6505 /* Helper functions to dump the parser context stack. */
6506
6507 #define TAB_CONTEXT(C) \
6508 {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
6509
6510 static void
java_debug_context_do(tab)6511 java_debug_context_do (tab)
6512 int tab;
6513 {
6514 struct parser_ctxt *copy = ctxp;
6515 while (copy)
6516 {
6517 TAB_CONTEXT (tab);
6518 fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
6519 TAB_CONTEXT (tab);
6520 fprintf (stderr, "filename: %s\n", copy->filename);
6521 TAB_CONTEXT (tab);
6522 fprintf (stderr, "lineno: %d\n", copy->lineno);
6523 TAB_CONTEXT (tab);
6524 fprintf (stderr, "package: %s\n",
6525 (copy->package ?
6526 IDENTIFIER_POINTER (copy->package) : "<none>"));
6527 TAB_CONTEXT (tab);
6528 fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
6529 TAB_CONTEXT (tab);
6530 fprintf (stderr, "saved data: %d\n", copy->saved_data);
6531 copy = copy->next;
6532 tab += 2;
6533 }
6534 }
6535
6536 /* Dump the stacked up parser contexts. Intended to be called from a
6537 debugger. */
6538
6539 void
java_debug_context()6540 java_debug_context ()
6541 {
6542 java_debug_context_do (0);
6543 }
6544
6545
6546
6547 /* Flag for the error report routine to issue the error the first time
6548 it's called (overriding the default behavior which is to drop the
6549 first invocation and honor the second one, taking advantage of a
6550 richer context. */
6551 static int force_error = 0;
6552
6553 /* Reporting an constructor invocation error. */
6554 static void
parse_ctor_invocation_error()6555 parse_ctor_invocation_error ()
6556 {
6557 if (DECL_CONSTRUCTOR_P (current_function_decl))
6558 yyerror ("Constructor invocation must be first thing in a constructor");
6559 else
6560 yyerror ("Only constructors can invoke constructors");
6561 }
6562
6563 /* Reporting JDK1.1 features not implemented. */
6564
6565 static tree
parse_jdk1_1_error(msg)6566 parse_jdk1_1_error (msg)
6567 const char *msg;
6568 {
6569 sorry (": `%s' JDK1.1(TM) feature", msg);
6570 java_error_count++;
6571 return empty_stmt_node;
6572 }
6573
6574 static int do_warning = 0;
6575
6576 void
yyerror(msg)6577 yyerror (msg)
6578 const char *msg;
6579 {
6580 static java_lc elc;
6581 static int prev_lineno;
6582 static const char *prev_msg;
6583
6584 int save_lineno;
6585 char *remainder, *code_from_source;
6586
6587 if (!force_error && prev_lineno == lineno)
6588 return;
6589
6590 /* Save current error location but report latter, when the context is
6591 richer. */
6592 if (ctxp->java_error_flag == 0)
6593 {
6594 ctxp->java_error_flag = 1;
6595 elc = ctxp->elc;
6596 /* Do something to use the previous line if we're reaching the
6597 end of the file... */
6598 #ifdef VERBOSE_SKELETON
6599 printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
6600 #endif
6601 return;
6602 }
6603
6604 /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
6605 if (!force_error && msg == prev_msg && prev_lineno == elc.line)
6606 return;
6607
6608 ctxp->java_error_flag = 0;
6609 if (do_warning)
6610 java_warning_count++;
6611 else
6612 java_error_count++;
6613
6614 if (elc.col == 0 && msg && msg[1] == ';')
6615 {
6616 elc.col = ctxp->p_line->char_col-1;
6617 elc.line = ctxp->p_line->lineno;
6618 }
6619
6620 save_lineno = lineno;
6621 prev_lineno = lineno = elc.line;
6622 prev_msg = msg;
6623
6624 code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
6625 obstack_grow0 (&temporary_obstack,
6626 code_from_source, strlen (code_from_source));
6627 remainder = obstack_finish (&temporary_obstack);
6628 if (do_warning)
6629 warning ("%s.\n%s", msg, remainder);
6630 else
6631 error ("%s.\n%s", msg, remainder);
6632
6633 /* This allow us to cheaply avoid an extra 'Invalid expression
6634 statement' error report when errors have been already reported on
6635 the same line. This occurs when we report an error but don't have
6636 a synchronization point other than ';', which
6637 expression_statement is the only one to take care of. */
6638 ctxp->prevent_ese = lineno = save_lineno;
6639 }
6640
6641 static void
issue_warning_error_from_context(cl,msg,ap)6642 issue_warning_error_from_context (cl, msg, ap)
6643 tree cl;
6644 const char *msg;
6645 va_list ap;
6646 {
6647 const char *saved, *saved_input_filename;
6648 char buffer [4096];
6649 vsprintf (buffer, msg, ap);
6650 force_error = 1;
6651
6652 ctxp->elc.line = EXPR_WFL_LINENO (cl);
6653 ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
6654 (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
6655
6656 /* We have a CL, that's a good reason for using it if it contains data */
6657 saved = ctxp->filename;
6658 if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
6659 ctxp->filename = EXPR_WFL_FILENAME (cl);
6660 saved_input_filename = input_filename;
6661 input_filename = ctxp->filename;
6662 java_error (NULL);
6663 java_error (buffer);
6664 ctxp->filename = saved;
6665 input_filename = saved_input_filename;
6666 force_error = 0;
6667 }
6668
6669 /* Issue an error message at a current source line CL */
6670
6671 void
parse_error_context(tree cl,const char * msg,...)6672 parse_error_context VPARAMS ((tree cl, const char *msg, ...))
6673 {
6674 VA_OPEN (ap, msg);
6675 VA_FIXEDARG (ap, tree, cl);
6676 VA_FIXEDARG (ap, const char *, msg);
6677 issue_warning_error_from_context (cl, msg, ap);
6678 VA_CLOSE (ap);
6679 }
6680
6681 /* Issue a warning at a current source line CL */
6682
6683 static void
parse_warning_context(tree cl,const char * msg,...)6684 parse_warning_context VPARAMS ((tree cl, const char *msg, ...))
6685 {
6686 VA_OPEN (ap, msg);
6687 VA_FIXEDARG (ap, tree, cl);
6688 VA_FIXEDARG (ap, const char *, msg);
6689
6690 force_error = do_warning = 1;
6691 issue_warning_error_from_context (cl, msg, ap);
6692 do_warning = force_error = 0;
6693 VA_CLOSE (ap);
6694 }
6695
6696 static tree
find_expr_with_wfl(node)6697 find_expr_with_wfl (node)
6698 tree node;
6699 {
6700 while (node)
6701 {
6702 char code;
6703 tree to_return;
6704
6705 switch (TREE_CODE (node))
6706 {
6707 case BLOCK:
6708 node = BLOCK_EXPR_BODY (node);
6709 continue;
6710
6711 case COMPOUND_EXPR:
6712 to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
6713 if (to_return)
6714 return to_return;
6715 node = TREE_OPERAND (node, 1);
6716 continue;
6717
6718 case LOOP_EXPR:
6719 node = TREE_OPERAND (node, 0);
6720 continue;
6721
6722 case LABELED_BLOCK_EXPR:
6723 node = TREE_OPERAND (node, 1);
6724 continue;
6725
6726 default:
6727 code = TREE_CODE_CLASS (TREE_CODE (node));
6728 if (((code == '1') || (code == '2') || (code == 'e'))
6729 && EXPR_WFL_LINECOL (node))
6730 return node;
6731 return NULL_TREE;
6732 }
6733 }
6734 return NULL_TREE;
6735 }
6736
6737 /* Issue a missing return statement error. Uses METHOD to figure the
6738 last line of the method the error occurs in. */
6739
6740 static void
missing_return_error(method)6741 missing_return_error (method)
6742 tree method;
6743 {
6744 EXPR_WFL_SET_LINECOL (wfl_operator, DECL_SOURCE_LINE_LAST (method), -2);
6745 parse_error_context (wfl_operator, "Missing return statement");
6746 }
6747
6748 /* Issue an unreachable statement error. From NODE, find the next
6749 statement to report appropriately. */
6750 static void
unreachable_stmt_error(node)6751 unreachable_stmt_error (node)
6752 tree node;
6753 {
6754 /* Browse node to find the next expression node that has a WFL. Use
6755 the location to report the error */
6756 if (TREE_CODE (node) == COMPOUND_EXPR)
6757 node = find_expr_with_wfl (TREE_OPERAND (node, 1));
6758 else
6759 node = find_expr_with_wfl (node);
6760
6761 if (node)
6762 {
6763 EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
6764 parse_error_context (wfl_operator, "Unreachable statement");
6765 }
6766 else
6767 abort ();
6768 }
6769
6770 int
java_report_errors()6771 java_report_errors ()
6772 {
6773 if (java_error_count)
6774 fprintf (stderr, "%d error%s",
6775 java_error_count, (java_error_count == 1 ? "" : "s"));
6776 if (java_warning_count)
6777 fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
6778 java_warning_count, (java_warning_count == 1 ? "" : "s"));
6779 if (java_error_count || java_warning_count)
6780 putc ('\n', stderr);
6781 return java_error_count;
6782 }
6783
6784 static char *
java_accstring_lookup(flags)6785 java_accstring_lookup (flags)
6786 int flags;
6787 {
6788 static char buffer [80];
6789 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
6790
6791 /* Access modifier looked-up first for easier report on forbidden
6792 access. */
6793 if (flags & ACC_PUBLIC) COPY_RETURN ("public");
6794 if (flags & ACC_PRIVATE) COPY_RETURN ("private");
6795 if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
6796 if (flags & ACC_STATIC) COPY_RETURN ("static");
6797 if (flags & ACC_FINAL) COPY_RETURN ("final");
6798 if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
6799 if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
6800 if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
6801 if (flags & ACC_NATIVE) COPY_RETURN ("native");
6802 if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
6803 if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
6804
6805 buffer [0] = '\0';
6806 return buffer;
6807 #undef COPY_RETURN
6808 }
6809
6810 /* Issuing error messages upon redefinition of classes, interfaces or
6811 variables. */
6812
6813 static void
classitf_redefinition_error(context,id,decl,cl)6814 classitf_redefinition_error (context, id, decl, cl)
6815 const char *context;
6816 tree id, decl, cl;
6817 {
6818 parse_error_context (cl, "%s `%s' already defined in %s:%d",
6819 context, IDENTIFIER_POINTER (id),
6820 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
6821 /* Here we should point out where its redefined. It's a unicode. FIXME */
6822 }
6823
6824 static void
variable_redefinition_error(context,name,type,line)6825 variable_redefinition_error (context, name, type, line)
6826 tree context, name, type;
6827 int line;
6828 {
6829 const char *type_name;
6830
6831 /* Figure a proper name for type. We might haven't resolved it */
6832 if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
6833 type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
6834 else
6835 type_name = lang_printable_name (type, 0);
6836
6837 parse_error_context (context,
6838 "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
6839 IDENTIFIER_POINTER (name),
6840 type_name, IDENTIFIER_POINTER (name), line);
6841 }
6842
6843 /* If ANAME is terminated with `[]', it indicates an array. This
6844 function returns the number of `[]' found and if this number is
6845 greater than zero, it extracts the array type name and places it in
6846 the node pointed to by TRIMMED unless TRIMMED is null. */
6847
6848 static int
build_type_name_from_array_name(aname,trimmed)6849 build_type_name_from_array_name (aname, trimmed)
6850 tree aname;
6851 tree *trimmed;
6852 {
6853 const char *name = IDENTIFIER_POINTER (aname);
6854 int len = IDENTIFIER_LENGTH (aname);
6855 int array_dims;
6856
6857 STRING_STRIP_BRACKETS (name, len, array_dims);
6858
6859 if (array_dims && trimmed)
6860 *trimmed = get_identifier_with_length (name, len);
6861
6862 return array_dims;
6863 }
6864
6865 static tree
build_array_from_name(type,type_wfl,name,ret_name)6866 build_array_from_name (type, type_wfl, name, ret_name)
6867 tree type, type_wfl, name, *ret_name;
6868 {
6869 int more_dims = 0;
6870
6871 /* Eventually get more dims */
6872 more_dims = build_type_name_from_array_name (name, &name);
6873
6874 /* If we have, then craft a new type for this variable */
6875 if (more_dims)
6876 {
6877 tree save = type;
6878
6879 /* If we have a pointer, use its type */
6880 if (TREE_CODE (type) == POINTER_TYPE)
6881 type = TREE_TYPE (type);
6882
6883 /* Building the first dimension of a primitive type uses this
6884 function */
6885 if (JPRIMITIVE_TYPE_P (type))
6886 {
6887 type = build_java_array_type (type, -1);
6888 more_dims--;
6889 }
6890 /* Otherwise, if we have a WFL for this type, use it (the type
6891 is already an array on an unresolved type, and we just keep
6892 on adding dimensions) */
6893 else if (type_wfl)
6894 {
6895 type = type_wfl;
6896 more_dims += build_type_name_from_array_name (TYPE_NAME (save),
6897 NULL);
6898 }
6899
6900 /* Add all the dimensions */
6901 while (more_dims--)
6902 type = build_unresolved_array_type (type);
6903
6904 /* The type may have been incomplete in the first place */
6905 if (type_wfl)
6906 type = obtain_incomplete_type (type);
6907 }
6908
6909 if (ret_name)
6910 *ret_name = name;
6911 return type;
6912 }
6913
6914 /* Build something that the type identifier resolver will identify as
6915 being an array to an unresolved type. TYPE_WFL is a WFL on a
6916 identifier. */
6917
6918 static tree
build_unresolved_array_type(type_or_wfl)6919 build_unresolved_array_type (type_or_wfl)
6920 tree type_or_wfl;
6921 {
6922 const char *ptr;
6923 tree wfl;
6924
6925 /* TYPE_OR_WFL might be an array on a resolved type. In this case,
6926 just create a array type */
6927 if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
6928 return build_java_array_type (type_or_wfl, -1);
6929
6930 obstack_grow (&temporary_obstack,
6931 IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
6932 IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
6933 obstack_grow0 (&temporary_obstack, "[]", 2);
6934 ptr = obstack_finish (&temporary_obstack);
6935 wfl = build_expr_wfl (get_identifier (ptr),
6936 EXPR_WFL_FILENAME (type_or_wfl),
6937 EXPR_WFL_LINENO (type_or_wfl),
6938 EXPR_WFL_COLNO (type_or_wfl));
6939 /* Re-install the existing qualifications so that the type can be
6940 resolved properly. */
6941 EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
6942 return wfl;
6943 }
6944
6945 static void
parser_add_interface(class_decl,interface_decl,wfl)6946 parser_add_interface (class_decl, interface_decl, wfl)
6947 tree class_decl, interface_decl, wfl;
6948 {
6949 if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
6950 parse_error_context (wfl, "Interface `%s' repeated",
6951 IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
6952 }
6953
6954 /* Bulk of common class/interface checks. Return 1 if an error was
6955 encountered. TAG is 0 for a class, 1 for an interface. */
6956
6957 static int
check_class_interface_creation(is_interface,flags,raw_name,qualified_name,decl,cl)6958 check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
6959 int is_interface, flags;
6960 tree raw_name, qualified_name, decl, cl;
6961 {
6962 tree node;
6963 int sca = 0; /* Static class allowed */
6964 int icaf = 0; /* Inner class allowed flags */
6965 int uaaf = CLASS_MODIFIERS; /* Usually allowed access flags */
6966
6967 if (!quiet_flag)
6968 fprintf (stderr, " %s%s %s",
6969 (CPC_INNER_P () ? "inner" : ""),
6970 (is_interface ? "interface" : "class"),
6971 IDENTIFIER_POINTER (qualified_name));
6972
6973 /* Scope of an interface/class type name:
6974 - Can't be imported by a single type import
6975 - Can't already exists in the package */
6976 if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
6977 && (node = find_name_in_single_imports (raw_name))
6978 && !CPC_INNER_P ())
6979 {
6980 parse_error_context
6981 (cl, "%s name `%s' clashes with imported type `%s'",
6982 (is_interface ? "Interface" : "Class"),
6983 IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
6984 return 1;
6985 }
6986 if (decl && CLASS_COMPLETE_P (decl))
6987 {
6988 classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
6989 qualified_name, decl, cl);
6990 return 1;
6991 }
6992
6993 if (check_inner_class_redefinition (raw_name, cl))
6994 return 1;
6995
6996 /* If public, file name should match class/interface name, except
6997 when dealing with an inner class */
6998 if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
6999 {
7000 const char *f;
7001
7002 for (f = &input_filename [strlen (input_filename)];
7003 f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
7004 f--)
7005 ;
7006 if (IS_DIR_SEPARATOR (f[0]))
7007 f++;
7008 if (strncmp (IDENTIFIER_POINTER (raw_name),
7009 f , IDENTIFIER_LENGTH (raw_name)) ||
7010 f [IDENTIFIER_LENGTH (raw_name)] != '.')
7011 parse_error_context
7012 (cl, "Public %s `%s' must be defined in a file called `%s.java'",
7013 (is_interface ? "interface" : "class"),
7014 IDENTIFIER_POINTER (qualified_name),
7015 IDENTIFIER_POINTER (raw_name));
7016 }
7017
7018 /* Static classes can be declared only in top level classes. Note:
7019 once static, a inner class is a top level class. */
7020 if (flags & ACC_STATIC)
7021 {
7022 /* Catch the specific error of declaring an class inner class
7023 with no toplevel enclosing class. Prevent check_modifiers from
7024 complaining a second time */
7025 if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
7026 {
7027 parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
7028 IDENTIFIER_POINTER (qualified_name));
7029 sca = ACC_STATIC;
7030 }
7031 /* Else, in the context of a top-level class declaration, let
7032 `check_modifiers' do its job, otherwise, give it a go */
7033 else
7034 sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
7035 }
7036
7037 /* Inner classes can be declared private or protected
7038 within their enclosing classes. */
7039 if (CPC_INNER_P ())
7040 {
7041 /* A class which is local to a block can't be public, private,
7042 protected or static. But it is created final, so allow this
7043 one. */
7044 if (current_function_decl)
7045 icaf = sca = uaaf = ACC_FINAL;
7046 else
7047 {
7048 check_modifiers_consistency (flags);
7049 icaf = ACC_PROTECTED;
7050 if (! CLASS_INTERFACE (GET_CPC ()))
7051 icaf |= ACC_PRIVATE;
7052 }
7053 }
7054
7055 if (is_interface)
7056 {
7057 if (CPC_INNER_P ())
7058 uaaf = INTERFACE_INNER_MODIFIERS;
7059 else
7060 uaaf = INTERFACE_MODIFIERS;
7061
7062 check_modifiers ("Illegal modifier `%s' for interface declaration",
7063 flags, uaaf);
7064 }
7065 else
7066 check_modifiers ((current_function_decl ?
7067 "Illegal modifier `%s' for local class declaration" :
7068 "Illegal modifier `%s' for class declaration"),
7069 flags, uaaf|sca|icaf);
7070 return 0;
7071 }
7072
7073 /* Construct a nested class name. If the final component starts with
7074 a digit, return true. Otherwise return false. */
7075 static int
make_nested_class_name(cpc_list)7076 make_nested_class_name (cpc_list)
7077 tree cpc_list;
7078 {
7079 tree name;
7080
7081 if (!cpc_list)
7082 return 0;
7083
7084 make_nested_class_name (TREE_CHAIN (cpc_list));
7085
7086 /* Pick the qualified name when dealing with the first upmost
7087 enclosing class */
7088 name = (TREE_CHAIN (cpc_list)
7089 ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
7090 obstack_grow (&temporary_obstack,
7091 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
7092 obstack_1grow (&temporary_obstack, '$');
7093
7094 return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
7095 }
7096
7097 /* Can't redefine a class already defined in an earlier scope. */
7098
7099 static int
check_inner_class_redefinition(raw_name,cl)7100 check_inner_class_redefinition (raw_name, cl)
7101 tree raw_name, cl;
7102 {
7103 tree scope_list;
7104
7105 for (scope_list = GET_CPC_LIST (); scope_list;
7106 scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
7107 if (raw_name == GET_CPC_UN_NODE (scope_list))
7108 {
7109 parse_error_context
7110 (cl, "The class name `%s' is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
7111 IDENTIFIER_POINTER (raw_name));
7112 return 1;
7113 }
7114 return 0;
7115 }
7116
7117 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
7118 we remember ENCLOSING and SUPER. */
7119
7120 static tree
resolve_inner_class(circularity_hash,cl,enclosing,super,class_type)7121 resolve_inner_class (circularity_hash, cl, enclosing, super, class_type)
7122 htab_t circularity_hash;
7123 tree cl, *enclosing, *super, class_type;
7124 {
7125 tree local_enclosing = *enclosing;
7126 tree local_super = NULL_TREE;
7127
7128 while (local_enclosing)
7129 {
7130 tree intermediate, decl;
7131
7132 *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
7133 local_enclosing;
7134
7135 if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
7136 return decl;
7137
7138 intermediate = local_enclosing;
7139 /* Explore enclosing contexts. */
7140 while (INNER_CLASS_DECL_P (intermediate))
7141 {
7142 intermediate = DECL_CONTEXT (intermediate);
7143 if ((decl = find_as_inner_class (intermediate, class_type, cl)))
7144 return decl;
7145 }
7146
7147 /* Now go to the upper classes, bail out if necessary. We will
7148 analyze the returned SUPER and act accordingly (see
7149 do_resolve_class.) */
7150 local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
7151 if (!local_super || local_super == object_type_node)
7152 break;
7153
7154 if (TREE_CODE (local_super) == POINTER_TYPE)
7155 local_super = do_resolve_class (NULL, local_super, NULL, NULL);
7156 else
7157 local_super = TYPE_NAME (local_super);
7158
7159 /* We may not have checked for circular inheritance yet, so do so
7160 here to prevent an infinite loop. */
7161 if (htab_find (circularity_hash, local_super) != NULL)
7162 {
7163 if (!cl)
7164 cl = lookup_cl (local_enclosing);
7165
7166 parse_error_context
7167 (cl, "Cyclic inheritance involving %s",
7168 IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
7169 local_enclosing = NULL_TREE;
7170 }
7171 else
7172 local_enclosing = local_super;
7173 }
7174
7175 /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
7176 *super = local_super;
7177 *enclosing = local_enclosing;
7178
7179 return NULL_TREE;
7180 }
7181
7182 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
7183 qualified. */
7184
7185 static tree
find_as_inner_class(enclosing,name,cl)7186 find_as_inner_class (enclosing, name, cl)
7187 tree enclosing, name, cl;
7188 {
7189 tree qual, to_return;
7190 if (!enclosing)
7191 return NULL_TREE;
7192
7193 name = TYPE_NAME (name);
7194
7195 /* First search: within the scope of `enclosing', search for name */
7196 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
7197 qual = EXPR_WFL_QUALIFICATION (cl);
7198 else if (cl)
7199 qual = build_tree_list (cl, NULL_TREE);
7200 else
7201 qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
7202
7203 if ((to_return = find_as_inner_class_do (qual, enclosing)))
7204 return to_return;
7205
7206 /* We're dealing with a qualified name. Try to resolve thing until
7207 we get something that is an enclosing class. */
7208 if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
7209 {
7210 tree acc = NULL_TREE, decl = NULL_TREE, ptr;
7211
7212 for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
7213 qual = TREE_CHAIN (qual))
7214 {
7215 acc = merge_qualified_name (acc,
7216 EXPR_WFL_NODE (TREE_PURPOSE (qual)));
7217 BUILD_PTR_FROM_NAME (ptr, acc);
7218 decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
7219 }
7220
7221 /* A NULL qual and a decl means that the search ended
7222 successfully?!? We have to do something then. FIXME */
7223
7224 if (decl)
7225 enclosing = decl;
7226 else
7227 qual = EXPR_WFL_QUALIFICATION (cl);
7228 }
7229 /* Otherwise, create a qual for the other part of the resolution. */
7230 else
7231 qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
7232
7233 return find_as_inner_class_do (qual, enclosing);
7234 }
7235
7236 /* We go inside the list of sub classes and try to find a way
7237 through. */
7238
7239 static tree
find_as_inner_class_do(qual,enclosing)7240 find_as_inner_class_do (qual, enclosing)
7241 tree qual, enclosing;
7242 {
7243 if (!qual)
7244 return NULL_TREE;
7245
7246 for (; qual && enclosing; qual = TREE_CHAIN (qual))
7247 {
7248 tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
7249 tree next_enclosing = NULL_TREE;
7250 tree inner_list;
7251
7252 for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
7253 inner_list; inner_list = TREE_CHAIN (inner_list))
7254 {
7255 if (TREE_VALUE (inner_list) == name_to_match)
7256 {
7257 next_enclosing = TREE_PURPOSE (inner_list);
7258 break;
7259 }
7260 }
7261 enclosing = next_enclosing;
7262 }
7263
7264 return (!qual && enclosing ? enclosing : NULL_TREE);
7265 }
7266
7267 /* Reach all inner classes and tie their unqualified name to a
7268 DECL. */
7269
7270 static void
set_nested_class_simple_name_value(outer,set)7271 set_nested_class_simple_name_value (outer, set)
7272 tree outer;
7273 int set;
7274 {
7275 tree l;
7276
7277 for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
7278 IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
7279 TREE_PURPOSE (l) : NULL_TREE);
7280 }
7281
7282 static void
link_nested_class_to_enclosing()7283 link_nested_class_to_enclosing ()
7284 {
7285 if (GET_ENCLOSING_CPC ())
7286 {
7287 tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
7288 DECL_INNER_CLASS_LIST (enclosing) =
7289 tree_cons (GET_CPC (), GET_CPC_UN (),
7290 DECL_INNER_CLASS_LIST (enclosing));
7291 }
7292 }
7293
7294 static tree
maybe_make_nested_class_name(name)7295 maybe_make_nested_class_name (name)
7296 tree name;
7297 {
7298 tree id = NULL_TREE;
7299
7300 if (CPC_INNER_P ())
7301 {
7302 /* If we're in a function, we must append a number to create the
7303 nested class name. However, we don't do this if the class we
7304 are constructing is anonymous, because in that case we'll
7305 already have a number as the class name. */
7306 if (! make_nested_class_name (GET_CPC_LIST ())
7307 && current_function_decl != NULL_TREE
7308 && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
7309 {
7310 char buf[10];
7311 sprintf (buf, "%d", anonymous_class_counter);
7312 ++anonymous_class_counter;
7313 obstack_grow (&temporary_obstack, buf, strlen (buf));
7314 obstack_1grow (&temporary_obstack, '$');
7315 }
7316 obstack_grow0 (&temporary_obstack,
7317 IDENTIFIER_POINTER (name),
7318 IDENTIFIER_LENGTH (name));
7319 id = get_identifier (obstack_finish (&temporary_obstack));
7320 if (ctxp->package)
7321 QUALIFIED_P (id) = 1;
7322 }
7323 return id;
7324 }
7325
7326 /* If DECL is NULL, create and push a new DECL, record the current
7327 line CL and do other maintenance things. */
7328
7329 static tree
maybe_create_class_interface_decl(decl,raw_name,qualified_name,cl)7330 maybe_create_class_interface_decl (decl, raw_name, qualified_name, cl)
7331 tree decl, raw_name, qualified_name, cl;
7332 {
7333 if (!decl)
7334 decl = push_class (make_class (), qualified_name);
7335
7336 /* Take care of the file and line business */
7337 DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
7338 /* If we're emiting xrefs, store the line/col number information */
7339 if (flag_emit_xref)
7340 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
7341 else
7342 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
7343 CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
7344 CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
7345 CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
7346 IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
7347
7348 PUSH_CPC (decl, raw_name);
7349 DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
7350
7351 /* Link the declaration to the already seen ones */
7352 TREE_CHAIN (decl) = ctxp->class_list;
7353 ctxp->class_list = decl;
7354
7355 /* Create a new nodes in the global lists */
7356 gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
7357 all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
7358
7359 /* Install a new dependency list element */
7360 create_jdep_list (ctxp);
7361
7362 SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
7363 IDENTIFIER_POINTER (qualified_name)));
7364 return decl;
7365 }
7366
7367 static void
add_superinterfaces(decl,interface_list)7368 add_superinterfaces (decl, interface_list)
7369 tree decl, interface_list;
7370 {
7371 tree node;
7372 /* Superinterface(s): if present and defined, parser_check_super_interface ()
7373 takes care of ensuring that:
7374 - This is an accessible interface type,
7375 - Circularity detection.
7376 parser_add_interface is then called. If present but not defined,
7377 the check operation is delayed until the super interface gets
7378 defined. */
7379 for (node = interface_list; node; node = TREE_CHAIN (node))
7380 {
7381 tree current = TREE_PURPOSE (node);
7382 tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
7383 if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
7384 {
7385 if (!parser_check_super_interface (idecl, decl, current))
7386 parser_add_interface (decl, idecl, current);
7387 }
7388 else
7389 register_incomplete_type (JDEP_INTERFACE,
7390 current, decl, NULL_TREE);
7391 }
7392 }
7393
7394 /* Create an interface in pass1 and return its decl. Return the
7395 interface's decl in pass 2. */
7396
7397 static tree
create_interface(flags,id,super)7398 create_interface (flags, id, super)
7399 int flags;
7400 tree id, super;
7401 {
7402 tree raw_name = EXPR_WFL_NODE (id);
7403 tree q_name = parser_qualified_classname (raw_name);
7404 tree decl = IDENTIFIER_CLASS_VALUE (q_name);
7405
7406 /* Certain syntax errors are making SUPER be like ID. Avoid this
7407 case. */
7408 if (ctxp->class_err && id == super)
7409 super = NULL;
7410
7411 EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */
7412
7413 /* Basic checks: scope, redefinition, modifiers */
7414 if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
7415 {
7416 PUSH_ERROR ();
7417 return NULL_TREE;
7418 }
7419
7420 /* Suspend the current parsing context if we're parsing an inner
7421 interface */
7422 if (CPC_INNER_P ())
7423 {
7424 java_parser_context_suspend ();
7425 /* Interface members are public. */
7426 if (CLASS_INTERFACE (GET_CPC ()))
7427 flags |= ACC_PUBLIC;
7428 }
7429
7430 /* Push a new context for (static) initialized upon declaration fields */
7431 java_parser_context_push_initialized_field ();
7432
7433 /* Interface modifiers check
7434 - public/abstract allowed (already done at that point)
7435 - abstract is obsolete (comes first, it's a warning, or should be)
7436 - Can't use twice the same (checked in the modifier rule) */
7437 if ((flags & ACC_ABSTRACT) && flag_redundant)
7438 parse_warning_context
7439 (MODIFIER_WFL (ABSTRACT_TK),
7440 "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
7441
7442 /* Create a new decl if DECL is NULL, otherwise fix it */
7443 decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
7444
7445 /* Set super info and mark the class a complete */
7446 set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
7447 object_type_node, ctxp->interface_number);
7448 ctxp->interface_number = 0;
7449 CLASS_COMPLETE_P (decl) = 1;
7450 add_superinterfaces (decl, super);
7451
7452 return decl;
7453 }
7454
7455 /* Patch anonymous class CLASS, by either extending or implementing
7456 DEP. */
7457
7458 static void
patch_anonymous_class(type_decl,class_decl,wfl)7459 patch_anonymous_class (type_decl, class_decl, wfl)
7460 tree type_decl, class_decl, wfl;
7461 {
7462 tree class = TREE_TYPE (class_decl);
7463 tree type = TREE_TYPE (type_decl);
7464 tree binfo = TYPE_BINFO (class);
7465
7466 /* If it's an interface, implement it */
7467 if (CLASS_INTERFACE (type_decl))
7468 {
7469 tree s_binfo;
7470 int length;
7471
7472 if (parser_check_super_interface (type_decl, class_decl, wfl))
7473 return;
7474
7475 s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
7476 length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
7477 TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
7478 TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
7479 /* And add the interface */
7480 parser_add_interface (class_decl, type_decl, wfl);
7481 }
7482 /* Otherwise, it's a type we want to extend */
7483 else
7484 {
7485 if (parser_check_super (type_decl, class_decl, wfl))
7486 return;
7487 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
7488 }
7489 }
7490
7491 static tree
create_anonymous_class(location,type_name)7492 create_anonymous_class (location, type_name)
7493 int location;
7494 tree type_name;
7495 {
7496 char buffer [80];
7497 tree super = NULL_TREE, itf = NULL_TREE;
7498 tree id, type_decl, class;
7499
7500 /* The unqualified name of the anonymous class. It's just a number. */
7501 sprintf (buffer, "%d", anonymous_class_counter++);
7502 id = build_wfl_node (get_identifier (buffer));
7503 EXPR_WFL_LINECOL (id) = location;
7504
7505 /* We know about the type to extend/implement. We go ahead */
7506 if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
7507 {
7508 /* Create a class which either implements on extends the designated
7509 class. The class bears an innacessible name. */
7510 if (CLASS_INTERFACE (type_decl))
7511 {
7512 /* It's OK to modify it here. It's been already used and
7513 shouldn't be reused */
7514 ctxp->interface_number = 1;
7515 /* Interfaces should presented as a list of WFLs */
7516 itf = build_tree_list (type_name, NULL_TREE);
7517 }
7518 else
7519 super = type_name;
7520 }
7521
7522 class = create_class (ACC_FINAL, id, super, itf);
7523
7524 /* We didn't know anything about the stuff. We register a dependence. */
7525 if (!type_decl)
7526 register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
7527
7528 ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
7529 return class;
7530 }
7531
7532 /* Create a class in pass1 and return its decl. Return class
7533 interface's decl in pass 2. */
7534
7535 static tree
create_class(flags,id,super,interfaces)7536 create_class (flags, id, super, interfaces)
7537 int flags;
7538 tree id, super, interfaces;
7539 {
7540 tree raw_name = EXPR_WFL_NODE (id);
7541 tree class_id, decl;
7542 tree super_decl_type;
7543
7544 /* Certain syntax errors are making SUPER be like ID. Avoid this
7545 case. */
7546 if (ctxp->class_err && id == super)
7547 super = NULL;
7548
7549 class_id = parser_qualified_classname (raw_name);
7550 decl = IDENTIFIER_CLASS_VALUE (class_id);
7551 EXPR_WFL_NODE (id) = class_id;
7552
7553 /* Basic check: scope, redefinition, modifiers */
7554 if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
7555 {
7556 PUSH_ERROR ();
7557 return NULL_TREE;
7558 }
7559
7560 /* Suspend the current parsing context if we're parsing an inner
7561 class or an anonymous class. */
7562 if (CPC_INNER_P ())
7563 {
7564 java_parser_context_suspend ();
7565 /* Interface members are public. */
7566 if (CLASS_INTERFACE (GET_CPC ()))
7567 flags |= ACC_PUBLIC;
7568 }
7569
7570 /* Push a new context for (static) initialized upon declaration fields */
7571 java_parser_context_push_initialized_field ();
7572
7573 /* Class modifier check:
7574 - Allowed modifier (already done at that point)
7575 - abstract AND final forbidden
7576 - Public classes defined in the correct file */
7577 if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
7578 parse_error_context
7579 (id, "Class `%s' can't be declared both abstract and final",
7580 IDENTIFIER_POINTER (raw_name));
7581
7582 /* Create a new decl if DECL is NULL, otherwise fix it */
7583 decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
7584
7585 /* If SUPER exists, use it, otherwise use Object */
7586 if (super)
7587 {
7588 /* Can't extend java.lang.Object */
7589 if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
7590 {
7591 parse_error_context (id, "Can't extend `java.lang.Object'");
7592 return NULL_TREE;
7593 }
7594
7595 super_decl_type =
7596 register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
7597 }
7598 else if (TREE_TYPE (decl) != object_type_node)
7599 super_decl_type = object_type_node;
7600 /* We're defining java.lang.Object */
7601 else
7602 super_decl_type = NULL_TREE;
7603
7604 /* A class nested in an interface is implicitly static. */
7605 if (INNER_CLASS_DECL_P (decl)
7606 && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
7607 {
7608 flags |= ACC_STATIC;
7609 }
7610
7611 /* Set super info and mark the class as complete. */
7612 set_super_info (flags, TREE_TYPE (decl), super_decl_type,
7613 ctxp->interface_number);
7614 ctxp->interface_number = 0;
7615 CLASS_COMPLETE_P (decl) = 1;
7616 add_superinterfaces (decl, interfaces);
7617
7618 /* Add the private this$<n> field, Replicate final locals still in
7619 scope as private final fields mangled like val$<local_name>.
7620 This doesn't not occur for top level (static) inner classes. */
7621 if (PURE_INNER_CLASS_DECL_P (decl))
7622 add_inner_class_fields (decl, current_function_decl);
7623
7624 /* If doing xref, store the location at which the inherited class
7625 (if any) was seen. */
7626 if (flag_emit_xref && super)
7627 DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
7628
7629 /* Eventually sets the @deprecated tag flag */
7630 CHECK_DEPRECATED (decl);
7631
7632 /* Reset the anonymous class counter when declaring non inner classes */
7633 if (!INNER_CLASS_DECL_P (decl))
7634 anonymous_class_counter = 1;
7635
7636 return decl;
7637 }
7638
7639 /* End a class declaration: register the statements used to create
7640 finit$ and <clinit>, pop the current class and resume the prior
7641 parser context if necessary. */
7642
7643 static void
end_class_declaration(resume)7644 end_class_declaration (resume)
7645 int resume;
7646 {
7647 /* If an error occurred, context weren't pushed and won't need to be
7648 popped by a resume. */
7649 int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
7650
7651 if (GET_CPC () != error_mark_node)
7652 dump_java_tree (TDI_class, GET_CPC ());
7653
7654 java_parser_context_pop_initialized_field ();
7655 POP_CPC ();
7656 if (resume && no_error_occurred)
7657 java_parser_context_resume ();
7658
7659 /* We're ending a class declaration, this is a good time to reset
7660 the interface cout. Note that might have been already done in
7661 create_interface, but if at that time an inner class was being
7662 dealt with, the interface count was reset in a context created
7663 for the sake of handling inner classes declaration. */
7664 ctxp->interface_number = 0;
7665 }
7666
7667 static void
add_inner_class_fields(class_decl,fct_decl)7668 add_inner_class_fields (class_decl, fct_decl)
7669 tree class_decl;
7670 tree fct_decl;
7671 {
7672 tree block, marker, f;
7673
7674 f = add_field (TREE_TYPE (class_decl),
7675 build_current_thisn (TREE_TYPE (class_decl)),
7676 build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
7677 ACC_PRIVATE);
7678 FIELD_THISN (f) = 1;
7679
7680 if (!fct_decl)
7681 return;
7682
7683 for (block = GET_CURRENT_BLOCK (fct_decl);
7684 block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
7685 {
7686 tree decl;
7687 for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
7688 {
7689 tree name, pname;
7690 tree wfl, init, list;
7691
7692 /* Avoid non final arguments. */
7693 if (!LOCAL_FINAL_P (decl))
7694 continue;
7695
7696 MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
7697 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
7698 wfl = build_wfl_node (name);
7699 init = build_wfl_node (pname);
7700 /* Build an initialization for the field: it will be
7701 initialized by a parameter added to finit$, bearing a
7702 mangled name of the field itself (param$<n>.) The
7703 parameter is provided to finit$ by the constructor
7704 invoking it (hence the constructor will also feature a
7705 hidden parameter, set to the value of the outer context
7706 local at the time the inner class is created.)
7707
7708 Note: we take into account all possible locals that can
7709 be accessed by the inner class. It's actually not trivial
7710 to minimize these aliases down to the ones really
7711 used. One way to do that would be to expand all regular
7712 methods first, then finit$ to get a picture of what's
7713 used. It works with the exception that we would have to
7714 go back on all constructor invoked in regular methods to
7715 have their invokation reworked (to include the right amount
7716 of alias initializer parameters.)
7717
7718 The only real way around, I think, is a first pass to
7719 identify locals really used in the inner class. We leave
7720 the flag FIELD_LOCAL_ALIAS_USED around for that future
7721 use.
7722
7723 On the other hand, it only affect local inner classes,
7724 whose constructors (and finit$ call) will be featuring
7725 unecessary arguments. It's easy for a developper to keep
7726 this number of parameter down by using the `final'
7727 keyword only when necessary. For the time being, we can
7728 issue a warning on unecessary finals. FIXME */
7729 init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
7730 wfl, init);
7731
7732 /* Register the field. The TREE_LIST holding the part
7733 initialized/initializer will be marked ARG_FINAL_P so
7734 that the created field can be marked
7735 FIELD_LOCAL_ALIAS. */
7736 list = build_tree_list (wfl, init);
7737 ARG_FINAL_P (list) = 1;
7738 register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
7739 }
7740 }
7741
7742 if (!CPC_INITIALIZER_STMT (ctxp))
7743 return;
7744
7745 /* If we ever registered an alias field, insert and marker to
7746 remeber where the list ends. The second part of the list (the one
7747 featuring initialized fields) so it can be later reversed to
7748 enforce 8.5. The marker will be removed during that operation. */
7749 marker = build_tree_list (NULL_TREE, NULL_TREE);
7750 TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
7751 SET_CPC_INITIALIZER_STMT (ctxp, marker);
7752 }
7753
7754 /* Can't use lookup_field () since we don't want to load the class and
7755 can't set the CLASS_LOADED_P flag */
7756
7757 static tree
find_field(class,name)7758 find_field (class, name)
7759 tree class;
7760 tree name;
7761 {
7762 tree decl;
7763 for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
7764 {
7765 if (DECL_NAME (decl) == name)
7766 return decl;
7767 }
7768 return NULL_TREE;
7769 }
7770
7771 /* Wrap around lookup_field that doesn't potentially upset the value
7772 of CLASS */
7773
7774 static tree
lookup_field_wrapper(class,name)7775 lookup_field_wrapper (class, name)
7776 tree class, name;
7777 {
7778 tree type = class;
7779 tree decl = NULL_TREE;
7780 java_parser_context_save_global ();
7781
7782 /* Last chance: if we're within the context of an inner class, we
7783 might be trying to access a local variable defined in an outer
7784 context. We try to look for it now. */
7785 if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
7786 {
7787 tree new_name;
7788 MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
7789 decl = lookup_field (&type, new_name);
7790 if (decl && decl != error_mark_node)
7791 FIELD_LOCAL_ALIAS_USED (decl) = 1;
7792 }
7793 if (!decl || decl == error_mark_node)
7794 {
7795 type = class;
7796 decl = lookup_field (&type, name);
7797 }
7798
7799 /* If the field still hasn't been found, try the next enclosing context. */
7800 if (!decl && INNER_CLASS_TYPE_P (class))
7801 {
7802 tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
7803 decl = lookup_field_wrapper (outer_type, name);
7804 }
7805
7806 java_parser_context_restore_global ();
7807 return decl == error_mark_node ? NULL : decl;
7808 }
7809
7810 /* Find duplicate field within the same class declarations and report
7811 the error. Returns 1 if a duplicated field was found, 0
7812 otherwise. */
7813
7814 static int
duplicate_declaration_error_p(new_field_name,new_type,cl)7815 duplicate_declaration_error_p (new_field_name, new_type, cl)
7816 tree new_field_name, new_type, cl;
7817 {
7818 /* This might be modified to work with method decl as well */
7819 tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
7820 if (decl)
7821 {
7822 char *t1 = xstrdup (purify_type_name
7823 ((TREE_CODE (new_type) == POINTER_TYPE
7824 && TREE_TYPE (new_type) == NULL_TREE) ?
7825 IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
7826 lang_printable_name (new_type, 1)));
7827 /* The type may not have been completed by the time we report
7828 the error */
7829 char *t2 = xstrdup (purify_type_name
7830 ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
7831 && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
7832 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
7833 lang_printable_name (TREE_TYPE (decl), 1)));
7834 parse_error_context
7835 (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
7836 t1, IDENTIFIER_POINTER (new_field_name),
7837 t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
7838 DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
7839 free (t1);
7840 free (t2);
7841 return 1;
7842 }
7843 return 0;
7844 }
7845
7846 /* Field registration routine. If TYPE doesn't exist, field
7847 declarations are linked to the undefined TYPE dependency list, to
7848 be later resolved in java_complete_class () */
7849
7850 static void
register_fields(flags,type,variable_list)7851 register_fields (flags, type, variable_list)
7852 int flags;
7853 tree type, variable_list;
7854 {
7855 tree current, saved_type;
7856 tree class_type = NULL_TREE;
7857 int saved_lineno = lineno;
7858 int must_chain = 0;
7859 tree wfl = NULL_TREE;
7860
7861 if (GET_CPC ())
7862 class_type = TREE_TYPE (GET_CPC ());
7863
7864 if (!class_type || class_type == error_mark_node)
7865 return;
7866
7867 /* If we're adding fields to interfaces, those fields are public,
7868 static, final */
7869 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
7870 {
7871 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
7872 flags, ACC_PUBLIC, "interface field(s)");
7873 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
7874 flags, ACC_STATIC, "interface field(s)");
7875 OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
7876 flags, ACC_FINAL, "interface field(s)");
7877 check_modifiers ("Illegal interface member modifier `%s'", flags,
7878 INTERFACE_FIELD_MODIFIERS);
7879 flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
7880 }
7881
7882 /* Obtain a suitable type for resolution, if necessary */
7883 SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
7884
7885 /* If TYPE is fully resolved and we don't have a reference, make one */
7886 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7887
7888 for (current = variable_list, saved_type = type; current;
7889 current = TREE_CHAIN (current), type = saved_type)
7890 {
7891 tree real_type;
7892 tree field_decl;
7893 tree cl = TREE_PURPOSE (current);
7894 tree init = TREE_VALUE (current);
7895 tree current_name = EXPR_WFL_NODE (cl);
7896
7897 /* Can't declare non-final static fields in inner classes */
7898 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
7899 && !(flags & ACC_FINAL))
7900 parse_error_context
7901 (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
7902 IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
7903 lang_printable_name (class_type, 0));
7904
7905 /* Process NAME, as it may specify extra dimension(s) for it */
7906 type = build_array_from_name (type, wfl, current_name, ¤t_name);
7907
7908 /* Type adjustment. We may have just readjusted TYPE because
7909 the variable specified more dimensions. Make sure we have
7910 a reference if we can and don't have one already. Also
7911 change the name if we have an init. */
7912 if (type != saved_type)
7913 {
7914 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7915 if (init)
7916 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
7917 }
7918
7919 real_type = GET_REAL_TYPE (type);
7920 /* Check for redeclarations */
7921 if (duplicate_declaration_error_p (current_name, real_type, cl))
7922 continue;
7923
7924 /* Set lineno to the line the field was found and create a
7925 declaration for it. Eventually sets the @deprecated tag flag. */
7926 if (flag_emit_xref)
7927 lineno = EXPR_WFL_LINECOL (cl);
7928 else
7929 lineno = EXPR_WFL_LINENO (cl);
7930 field_decl = add_field (class_type, current_name, real_type, flags);
7931 CHECK_DEPRECATED (field_decl);
7932
7933 /* If the field denotes a final instance variable, then we
7934 allocate a LANG_DECL_SPECIFIC part to keep track of its
7935 initialization. We also mark whether the field was
7936 initialized upon its declaration. We don't do that if the
7937 created field is an alias to a final local. */
7938 if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
7939 {
7940 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
7941 DECL_FIELD_FINAL_WFL (field_decl) = cl;
7942 }
7943
7944 /* If the couple initializer/initialized is marked ARG_FINAL_P,
7945 we mark the created field FIELD_LOCAL_ALIAS, so that we can
7946 hide parameters to this inner class finit$ and
7947 constructors. It also means that the field isn't final per
7948 say. */
7949 if (ARG_FINAL_P (current))
7950 {
7951 FIELD_LOCAL_ALIAS (field_decl) = 1;
7952 FIELD_FINAL (field_decl) = 0;
7953 }
7954
7955 /* Check if we must chain. */
7956 if (must_chain)
7957 register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
7958
7959 /* If we have an initialization value tied to the field */
7960 if (init)
7961 {
7962 /* The field is declared static */
7963 if (flags & ACC_STATIC)
7964 {
7965 /* We include the field and its initialization part into
7966 a list used to generate <clinit>. After <clinit> is
7967 walked, field initializations will be processed and
7968 fields initialized with known constants will be taken
7969 out of <clinit> and have their DECL_INITIAL set
7970 appropriately. */
7971 TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
7972 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
7973 if (TREE_OPERAND (init, 1)
7974 && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
7975 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
7976 }
7977 /* A non-static field declared with an immediate initialization is
7978 to be initialized in <init>, if any. This field is remembered
7979 to be processed at the time of the generation of <init>. */
7980 else
7981 {
7982 TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
7983 SET_CPC_INITIALIZER_STMT (ctxp, init);
7984 }
7985 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7986 DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
7987 }
7988 }
7989 lineno = saved_lineno;
7990 }
7991
7992 /* Generate finit$, using the list of initialized fields to populate
7993 its body. finit$'s parameter(s) list is adjusted to include the
7994 one(s) used to initialized the field(s) caching outer context
7995 local(s). */
7996
7997 static tree
generate_finit(class_type)7998 generate_finit (class_type)
7999 tree class_type;
8000 {
8001 int count = 0;
8002 tree list = TYPE_FINIT_STMT_LIST (class_type);
8003 tree mdecl, current, parms;
8004
8005 parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
8006 class_type, NULL_TREE,
8007 &count);
8008 CRAFTED_PARAM_LIST_FIXUP (parms);
8009 mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
8010 finit_identifier_node, parms);
8011 fix_method_argument_names (parms, mdecl);
8012 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
8013 mdecl, NULL_TREE);
8014 DECL_FUNCTION_NAP (mdecl) = count;
8015 start_artificial_method_body (mdecl);
8016
8017 for (current = list; current; current = TREE_CHAIN (current))
8018 java_method_add_stmt (mdecl,
8019 build_debugable_stmt (EXPR_WFL_LINECOL (current),
8020 current));
8021 end_artificial_method_body (mdecl);
8022 return mdecl;
8023 }
8024
8025 /* Generate a function to run the instance initialization code. The
8026 private method is called `instinit$'. Unless we're dealing with an
8027 anonymous class, we determine whether all ctors of CLASS_TYPE
8028 declare a checked exception in their `throws' clause in order to
8029 see whether it's necessary to encapsulate the instance initializer
8030 statements in a try/catch/rethrow sequence. */
8031
8032 static tree
generate_instinit(class_type)8033 generate_instinit (class_type)
8034 tree class_type;
8035 {
8036 tree current;
8037 tree compound = NULL_TREE;
8038 tree parms = tree_cons (this_identifier_node,
8039 build_pointer_type (class_type), end_params_node);
8040 tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
8041 void_type_node,
8042 instinit_identifier_node, parms);
8043
8044 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
8045 mdecl, NULL_TREE);
8046
8047 /* Gather all the statements in a compound */
8048 for (current = TYPE_II_STMT_LIST (class_type);
8049 current; current = TREE_CHAIN (current))
8050 compound = add_stmt_to_compound (compound, NULL_TREE, current);
8051
8052 /* We need to encapsulate COMPOUND by a try/catch statement to
8053 rethrow exceptions that might occur in the instance initializer.
8054 We do that only if all ctors of CLASS_TYPE are set to catch a
8055 checked exception. This doesn't apply to anonymous classes (since
8056 they don't have declared ctors.) */
8057 if (!ANONYMOUS_CLASS_P (class_type) &&
8058 ctors_unchecked_throws_clause_p (class_type))
8059 {
8060 compound = encapsulate_with_try_catch (0, exception_type_node, compound,
8061 build1 (THROW_EXPR, NULL_TREE,
8062 build_wfl_node (wpv_id)));
8063 DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
8064 exception_type_node);
8065 }
8066
8067 start_artificial_method_body (mdecl);
8068 java_method_add_stmt (mdecl, compound);
8069 end_artificial_method_body (mdecl);
8070
8071 return mdecl;
8072 }
8073
8074 /* FIXME */
8075 static tree
build_instinit_invocation(class_type)8076 build_instinit_invocation (class_type)
8077 tree class_type;
8078 {
8079 tree to_return = NULL_TREE;
8080
8081 if (TYPE_II_STMT_LIST (class_type))
8082 {
8083 tree parm = build_tree_list (NULL_TREE,
8084 build_wfl_node (this_identifier_node));
8085 to_return =
8086 build_method_invocation (build_wfl_node (instinit_identifier_node),
8087 parm);
8088 }
8089 return to_return;
8090 }
8091
8092 /* Shared accros method_declarator and method_header to remember the
8093 patch stage that was reached during the declaration of the method.
8094 A method DECL is built differently is there is no patch
8095 (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
8096 pending on the currently defined method. */
8097
8098 static int patch_stage;
8099
8100 /* Check the method declaration and add the method to its current
8101 class. If the argument list is known to contain incomplete types,
8102 the method is partially added and the registration will be resume
8103 once the method arguments resolved. If TYPE is NULL, we're dealing
8104 with a constructor. */
8105
8106 static tree
method_header(flags,type,mdecl,throws)8107 method_header (flags, type, mdecl, throws)
8108 int flags;
8109 tree type, mdecl, throws;
8110 {
8111 tree type_wfl = NULL_TREE;
8112 tree meth_name = NULL_TREE;
8113 tree current, orig_arg, this_class = NULL;
8114 tree id, meth;
8115 int saved_lineno;
8116 int constructor_ok = 0, must_chain;
8117 int count;
8118
8119 if (mdecl == error_mark_node)
8120 return error_mark_node;
8121 meth = TREE_VALUE (mdecl);
8122 id = TREE_PURPOSE (mdecl);
8123
8124 check_modifiers_consistency (flags);
8125
8126 if (GET_CPC ())
8127 this_class = TREE_TYPE (GET_CPC ());
8128
8129 if (!this_class || this_class == error_mark_node)
8130 return NULL_TREE;
8131
8132 /* There are some forbidden modifiers for an abstract method and its
8133 class must be abstract as well. */
8134 if (type && (flags & ACC_ABSTRACT))
8135 {
8136 ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
8137 ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
8138 ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
8139 ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
8140 ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
8141 ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
8142 if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
8143 && !CLASS_INTERFACE (TYPE_NAME (this_class)))
8144 parse_error_context
8145 (id, "Class `%s' must be declared abstract to define abstract method `%s'",
8146 IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
8147 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
8148 }
8149
8150 /* A native method can't be strictfp. */
8151 if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
8152 parse_error_context (id, "native method `%s' can't be strictfp",
8153 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
8154 /* No such thing as a transient or volatile method. */
8155 if ((flags & ACC_TRANSIENT))
8156 parse_error_context (id, "method `%s' can't be transient",
8157 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
8158 if ((flags & ACC_VOLATILE))
8159 parse_error_context (id, "method `%s' can't be volatile",
8160 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
8161
8162 /* Things to be checked when declaring a constructor */
8163 if (!type)
8164 {
8165 int ec = java_error_count;
8166 /* 8.6: Constructor declarations: we might be trying to define a
8167 method without specifying a return type. */
8168 if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
8169 parse_error_context
8170 (id, "Invalid method declaration, return type required");
8171 /* 8.6.3: Constructor modifiers */
8172 else
8173 {
8174 JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
8175 JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
8176 JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
8177 JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
8178 JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
8179 JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
8180 }
8181 /* If we found error here, we don't consider it's OK to tread
8182 the method definition as a constructor, for the rest of this
8183 function */
8184 if (ec == java_error_count)
8185 constructor_ok = 1;
8186 }
8187
8188 /* Method declared within the scope of an interface are implicitly
8189 abstract and public. Conflicts with other erroneously provided
8190 modifiers are checked right after. */
8191
8192 if (CLASS_INTERFACE (TYPE_NAME (this_class)))
8193 {
8194 /* If FLAGS isn't set because of a modifier, turn the
8195 corresponding modifier WFL to NULL so we issue a warning on
8196 the obsolete use of the modifier */
8197 if (!(flags & ACC_PUBLIC))
8198 MODIFIER_WFL (PUBLIC_TK) = NULL;
8199 if (!(flags & ACC_ABSTRACT))
8200 MODIFIER_WFL (ABSTRACT_TK) = NULL;
8201 flags |= ACC_PUBLIC;
8202 flags |= ACC_ABSTRACT;
8203 }
8204
8205 /* Inner class can't declare static methods */
8206 if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
8207 {
8208 parse_error_context
8209 (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
8210 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
8211 lang_printable_name (this_class, 0));
8212 }
8213
8214 /* Modifiers context reset moved up, so abstract method declaration
8215 modifiers can be later checked. */
8216
8217 /* Set constructor returned type to void and method name to <init>,
8218 unless we found an error identifier the constructor (in which
8219 case we retain the original name) */
8220 if (!type)
8221 {
8222 type = void_type_node;
8223 if (constructor_ok)
8224 meth_name = init_identifier_node;
8225 }
8226 else
8227 meth_name = EXPR_WFL_NODE (id);
8228
8229 /* Do the returned type resolution and registration if necessary */
8230 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
8231
8232 if (meth_name)
8233 type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
8234 EXPR_WFL_NODE (id) = meth_name;
8235 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
8236
8237 if (must_chain)
8238 {
8239 patch_stage = JDEP_METHOD_RETURN;
8240 register_incomplete_type (patch_stage, type_wfl, id, type);
8241 TREE_TYPE (meth) = GET_REAL_TYPE (type);
8242 }
8243 else
8244 TREE_TYPE (meth) = type;
8245
8246 saved_lineno = lineno;
8247 /* When defining an abstract or interface method, the curly
8248 bracket at level 1 doesn't exist because there is no function
8249 body */
8250 lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
8251 EXPR_WFL_LINENO (id));
8252
8253 /* Remember the original argument list */
8254 orig_arg = TYPE_ARG_TYPES (meth);
8255
8256 if (patch_stage) /* includes ret type and/or all args */
8257 {
8258 jdep *jdep;
8259 meth = add_method_1 (this_class, flags, meth_name, meth);
8260 /* Patch for the return type */
8261 if (patch_stage == JDEP_METHOD_RETURN)
8262 {
8263 jdep = CLASSD_LAST (ctxp->classd_list);
8264 JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
8265 }
8266 /* This is the stop JDEP. METH allows the function's signature
8267 to be computed. */
8268 register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
8269 }
8270 else
8271 meth = add_method (this_class, flags, meth_name,
8272 build_java_signature (meth));
8273
8274 /* Remember final parameters */
8275 MARK_FINAL_PARMS (meth, orig_arg);
8276
8277 /* Fix the method argument list so we have the argument name
8278 information */
8279 fix_method_argument_names (orig_arg, meth);
8280
8281 /* Register the parameter number and re-install the current line
8282 number */
8283 DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
8284 lineno = saved_lineno;
8285
8286 /* Register exception specified by the `throws' keyword for
8287 resolution and set the method decl appropriate field to the list.
8288 Note: the grammar ensures that what we get here are class
8289 types. */
8290 if (throws)
8291 {
8292 throws = nreverse (throws);
8293 for (current = throws; current; current = TREE_CHAIN (current))
8294 {
8295 register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
8296 NULL_TREE, NULL_TREE);
8297 JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8298 &TREE_VALUE (current);
8299 }
8300 DECL_FUNCTION_THROWS (meth) = throws;
8301 }
8302
8303 if (TREE_TYPE (GET_CPC ()) != object_type_node)
8304 DECL_FUNCTION_WFL (meth) = id;
8305
8306 /* Set the flag if we correctly processed a constructor */
8307 if (constructor_ok)
8308 {
8309 DECL_CONSTRUCTOR_P (meth) = 1;
8310 /* Compute and store the number of artificial parameters declared
8311 for this constructor */
8312 for (count = 0, current = TYPE_FIELDS (this_class); current;
8313 current = TREE_CHAIN (current))
8314 if (FIELD_LOCAL_ALIAS (current))
8315 count++;
8316 DECL_FUNCTION_NAP (meth) = count;
8317 }
8318
8319 /* Eventually set the @deprecated tag flag */
8320 CHECK_DEPRECATED (meth);
8321
8322 /* If doing xref, store column and line number information instead
8323 of the line number only. */
8324 if (flag_emit_xref)
8325 DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
8326
8327 return meth;
8328 }
8329
8330 static void
fix_method_argument_names(orig_arg,meth)8331 fix_method_argument_names (orig_arg, meth)
8332 tree orig_arg, meth;
8333 {
8334 tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
8335 if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
8336 {
8337 TREE_PURPOSE (arg) = this_identifier_node;
8338 arg = TREE_CHAIN (arg);
8339 }
8340 while (orig_arg != end_params_node)
8341 {
8342 TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
8343 orig_arg = TREE_CHAIN (orig_arg);
8344 arg = TREE_CHAIN (arg);
8345 }
8346 }
8347
8348 /* Complete the method declaration with METHOD_BODY. */
8349
8350 static void
finish_method_declaration(method_body)8351 finish_method_declaration (method_body)
8352 tree method_body;
8353 {
8354 int flags;
8355
8356 if (!current_function_decl)
8357 return;
8358
8359 flags = get_access_flags_from_decl (current_function_decl);
8360
8361 /* 8.4.5 Method Body */
8362 if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
8363 {
8364 tree name = DECL_NAME (current_function_decl);
8365 parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
8366 "%s method `%s' can't have a body defined",
8367 (METHOD_NATIVE (current_function_decl) ?
8368 "Native" : "Abstract"),
8369 IDENTIFIER_POINTER (name));
8370 method_body = NULL_TREE;
8371 }
8372 else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
8373 {
8374 tree name = DECL_NAME (current_function_decl);
8375 parse_error_context
8376 (DECL_FUNCTION_WFL (current_function_decl),
8377 "Non native and non abstract method `%s' must have a body defined",
8378 IDENTIFIER_POINTER (name));
8379 method_body = NULL_TREE;
8380 }
8381
8382 if (flag_emit_class_files && method_body
8383 && TREE_CODE (method_body) == NOP_EXPR
8384 && TREE_TYPE (current_function_decl)
8385 && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
8386 method_body = build1 (RETURN_EXPR, void_type_node, NULL);
8387
8388 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
8389 maybe_absorb_scoping_blocks ();
8390 /* Exit function's body */
8391 exit_block ();
8392 /* Merge last line of the function with first line, directly in the
8393 function decl. It will be used to emit correct debug info. */
8394 if (!flag_emit_xref)
8395 DECL_SOURCE_LINE_MERGE (current_function_decl, ctxp->last_ccb_indent1);
8396
8397 /* Since function's argument's list are shared, reset the
8398 ARG_FINAL_P parameter that might have been set on some of this
8399 function parameters. */
8400 UNMARK_FINAL_PARMS (current_function_decl);
8401
8402 /* So we don't have an irrelevant function declaration context for
8403 the next static block we'll see. */
8404 current_function_decl = NULL_TREE;
8405 }
8406
8407 /* Build a an error message for constructor circularity errors. */
8408
8409 static char *
constructor_circularity_msg(from,to)8410 constructor_circularity_msg (from, to)
8411 tree from, to;
8412 {
8413 static char string [4096];
8414 char *t = xstrdup (lang_printable_name (from, 0));
8415 sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
8416 free (t);
8417 return string;
8418 }
8419
8420 /* Verify a circular call to METH. Return 1 if an error is found, 0
8421 otherwise. */
8422
8423 static GTY(()) tree vcc_list;
8424 static int
verify_constructor_circularity(meth,current)8425 verify_constructor_circularity (meth, current)
8426 tree meth, current;
8427 {
8428 tree c;
8429
8430 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
8431 {
8432 if (TREE_VALUE (c) == meth)
8433 {
8434 char *t;
8435 if (vcc_list)
8436 {
8437 tree liste;
8438 vcc_list = nreverse (vcc_list);
8439 for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
8440 {
8441 parse_error_context
8442 (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
8443 constructor_circularity_msg
8444 (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
8445 java_error_count--;
8446 }
8447 }
8448 t = xstrdup (lang_printable_name (meth, 0));
8449 parse_error_context (TREE_PURPOSE (c),
8450 "%s: recursive invocation of constructor `%s'",
8451 constructor_circularity_msg (current, meth), t);
8452 free (t);
8453 vcc_list = NULL_TREE;
8454 return 1;
8455 }
8456 }
8457 for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
8458 {
8459 vcc_list = tree_cons (c, current, vcc_list);
8460 if (verify_constructor_circularity (meth, TREE_VALUE (c)))
8461 return 1;
8462 vcc_list = TREE_CHAIN (vcc_list);
8463 }
8464 return 0;
8465 }
8466
8467 /* Check modifiers that can be declared but exclusively */
8468
8469 static void
check_modifiers_consistency(flags)8470 check_modifiers_consistency (flags)
8471 int flags;
8472 {
8473 int acc_count = 0;
8474 tree cl = NULL_TREE;
8475
8476 THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
8477 THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
8478 THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
8479 if (acc_count > 1)
8480 parse_error_context
8481 (cl, "Inconsistent member declaration. At most one of `public', `private', or `protected' may be specified");
8482
8483 acc_count = 0;
8484 cl = NULL_TREE;
8485 THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
8486 THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
8487 if (acc_count > 1)
8488 parse_error_context (cl,
8489 "Inconsistent member declaration. At most one of `final' or `volatile' may be specified");
8490 }
8491
8492 /* Check the methode header METH for abstract specifics features */
8493
8494 static void
check_abstract_method_header(meth)8495 check_abstract_method_header (meth)
8496 tree meth;
8497 {
8498 int flags = get_access_flags_from_decl (meth);
8499
8500 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
8501 ACC_ABSTRACT, "abstract method",
8502 IDENTIFIER_POINTER (DECL_NAME (meth)));
8503 OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
8504 ACC_PUBLIC, "abstract method",
8505 IDENTIFIER_POINTER (DECL_NAME (meth)));
8506
8507 check_modifiers ("Illegal modifier `%s' for interface method",
8508 flags, INTERFACE_METHOD_MODIFIERS);
8509 }
8510
8511 /* Create a FUNCTION_TYPE node and start augmenting it with the
8512 declared function arguments. Arguments type that can't be resolved
8513 are left as they are, but the returned node is marked as containing
8514 incomplete types. */
8515
8516 static tree
method_declarator(id,list)8517 method_declarator (id, list)
8518 tree id, list;
8519 {
8520 tree arg_types = NULL_TREE, current, node;
8521 tree meth = make_node (FUNCTION_TYPE);
8522 jdep *jdep;
8523
8524 patch_stage = JDEP_NO_PATCH;
8525
8526 if (GET_CPC () == error_mark_node)
8527 return error_mark_node;
8528
8529 /* If we're dealing with an inner class constructor, we hide the
8530 this$<n> decl in the name field of its parameter declaration. We
8531 also might have to hide the outer context local alias
8532 initializers. Not done when the class is a toplevel class. */
8533 if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
8534 && EXPR_WFL_NODE (id) == GET_CPC_UN ())
8535 {
8536 tree aliases_list, type, thisn;
8537 /* First the aliases, linked to the regular parameters */
8538 aliases_list =
8539 build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
8540 TREE_TYPE (GET_CPC ()),
8541 NULL_TREE, NULL);
8542 list = chainon (nreverse (aliases_list), list);
8543
8544 /* Then this$<n> */
8545 type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
8546 thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
8547 list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
8548 list);
8549 }
8550
8551 for (current = list; current; current = TREE_CHAIN (current))
8552 {
8553 int must_chain = 0;
8554 tree wfl_name = TREE_PURPOSE (current);
8555 tree type = TREE_VALUE (current);
8556 tree name = EXPR_WFL_NODE (wfl_name);
8557 tree already, arg_node;
8558 tree type_wfl = NULL_TREE;
8559 tree real_type;
8560
8561 /* Obtain a suitable type for resolution, if necessary */
8562 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
8563
8564 /* Process NAME, as it may specify extra dimension(s) for it */
8565 type = build_array_from_name (type, type_wfl, name, &name);
8566 EXPR_WFL_NODE (wfl_name) = name;
8567
8568 real_type = GET_REAL_TYPE (type);
8569 if (TREE_CODE (real_type) == RECORD_TYPE)
8570 {
8571 real_type = promote_type (real_type);
8572 if (TREE_CODE (type) == TREE_LIST)
8573 TREE_PURPOSE (type) = real_type;
8574 }
8575
8576 /* Check redefinition */
8577 for (already = arg_types; already; already = TREE_CHAIN (already))
8578 if (TREE_PURPOSE (already) == name)
8579 {
8580 parse_error_context
8581 (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
8582 IDENTIFIER_POINTER (name),
8583 IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
8584 break;
8585 }
8586
8587 /* If we've an incomplete argument type, we know there is a location
8588 to patch when the type get resolved, later. */
8589 jdep = NULL;
8590 if (must_chain)
8591 {
8592 patch_stage = JDEP_METHOD;
8593 type = register_incomplete_type (patch_stage,
8594 type_wfl, wfl_name, type);
8595 jdep = CLASSD_LAST (ctxp->classd_list);
8596 JDEP_MISC (jdep) = id;
8597 }
8598
8599 /* The argument node: a name and a (possibly) incomplete type. */
8600 arg_node = build_tree_list (name, real_type);
8601 /* Remeber arguments declared final. */
8602 ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
8603
8604 if (jdep)
8605 JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
8606 TREE_CHAIN (arg_node) = arg_types;
8607 arg_types = arg_node;
8608 }
8609 TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
8610 node = build_tree_list (id, meth);
8611 return node;
8612 }
8613
8614 static int
unresolved_type_p(wfl,returned)8615 unresolved_type_p (wfl, returned)
8616 tree wfl;
8617 tree *returned;
8618
8619 {
8620 if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
8621 {
8622 if (returned)
8623 {
8624 tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
8625 if (decl && current_class && (decl == TYPE_NAME (current_class)))
8626 *returned = TREE_TYPE (decl);
8627 else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
8628 *returned = TREE_TYPE (GET_CPC ());
8629 else
8630 *returned = NULL_TREE;
8631 }
8632 return 1;
8633 }
8634 if (returned)
8635 *returned = wfl;
8636 return 0;
8637 }
8638
8639 /* From NAME, build a qualified identifier node using the
8640 qualification from the current package definition. */
8641
8642 static tree
parser_qualified_classname(name)8643 parser_qualified_classname (name)
8644 tree name;
8645 {
8646 tree nested_class_name;
8647
8648 if ((nested_class_name = maybe_make_nested_class_name (name)))
8649 return nested_class_name;
8650
8651 if (ctxp->package)
8652 return merge_qualified_name (ctxp->package, name);
8653 else
8654 return name;
8655 }
8656
8657 /* Called once the type a interface extends is resolved. Returns 0 if
8658 everything is OK. */
8659
8660 static int
parser_check_super_interface(super_decl,this_decl,this_wfl)8661 parser_check_super_interface (super_decl, this_decl, this_wfl)
8662 tree super_decl, this_decl, this_wfl;
8663 {
8664 tree super_type = TREE_TYPE (super_decl);
8665
8666 /* Has to be an interface */
8667 if (!CLASS_INTERFACE (super_decl))
8668 {
8669 parse_error_context
8670 (this_wfl, "%s `%s' can't implement/extend %s `%s'",
8671 (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
8672 "Interface" : "Class"),
8673 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
8674 (TYPE_ARRAY_P (super_type) ? "array" : "class"),
8675 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
8676 return 1;
8677 }
8678
8679 /* Check top-level interface access. Inner classes are subject to member
8680 access rules (6.6.1). */
8681 if (! INNER_CLASS_P (super_type)
8682 && check_pkg_class_access (DECL_NAME (super_decl),
8683 lookup_cl (this_decl), true))
8684 return 1;
8685
8686 SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
8687 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
8688 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
8689 return 0;
8690 }
8691
8692 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
8693 0 if everthing is OK. */
8694
8695 static int
parser_check_super(super_decl,this_decl,wfl)8696 parser_check_super (super_decl, this_decl, wfl)
8697 tree super_decl, this_decl, wfl;
8698 {
8699 tree super_type = TREE_TYPE (super_decl);
8700
8701 /* SUPER should be a CLASS (neither an array nor an interface) */
8702 if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
8703 {
8704 parse_error_context
8705 (wfl, "Class `%s' can't subclass %s `%s'",
8706 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
8707 (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
8708 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
8709 return 1;
8710 }
8711
8712 if (CLASS_FINAL (TYPE_NAME (super_type)))
8713 {
8714 parse_error_context (wfl, "Can't subclass final classes: %s",
8715 IDENTIFIER_POINTER (DECL_NAME (super_decl)));
8716 return 1;
8717 }
8718
8719 /* Check top-level class scope. Inner classes are subject to member access
8720 rules (6.6.1). */
8721 if (! INNER_CLASS_P (super_type)
8722 && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
8723 return 1;
8724
8725 SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
8726 IDENTIFIER_POINTER (DECL_NAME (this_decl)),
8727 IDENTIFIER_POINTER (DECL_NAME (super_decl))));
8728 return 0;
8729 }
8730
8731 /* Create a new dependency list and link it (in a LIFO manner) to the
8732 CTXP list of type dependency list. */
8733
8734 static void
create_jdep_list(ctxp)8735 create_jdep_list (ctxp)
8736 struct parser_ctxt *ctxp;
8737 {
8738 jdeplist *new = (jdeplist *)xmalloc (sizeof (jdeplist));
8739 new->first = new->last = NULL;
8740 new->next = ctxp->classd_list;
8741 ctxp->classd_list = new;
8742 }
8743
8744 static jdeplist *
reverse_jdep_list(ctxp)8745 reverse_jdep_list (ctxp)
8746 struct parser_ctxt *ctxp;
8747 {
8748 register jdeplist *prev = NULL, *current, *next;
8749 for (current = ctxp->classd_list; current; current = next)
8750 {
8751 next = current->next;
8752 current->next = prev;
8753 prev = current;
8754 }
8755 return prev;
8756 }
8757
8758 /* Create a fake pointer based on the ID stored in
8759 TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
8760 registered again. */
8761
8762 static tree
obtain_incomplete_type(type_name)8763 obtain_incomplete_type (type_name)
8764 tree type_name;
8765 {
8766 tree ptr = NULL_TREE, name;
8767
8768 if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
8769 name = EXPR_WFL_NODE (type_name);
8770 else if (INCOMPLETE_TYPE_P (type_name))
8771 name = TYPE_NAME (type_name);
8772 else
8773 abort ();
8774
8775 BUILD_PTR_FROM_NAME (ptr, name);
8776 layout_type (ptr);
8777
8778 return ptr;
8779 }
8780
8781 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
8782 non NULL instead of computing a new fake type based on WFL. The new
8783 dependency is inserted in the current type dependency list, in FIFO
8784 manner. */
8785
8786 static tree
register_incomplete_type(kind,wfl,decl,ptr)8787 register_incomplete_type (kind, wfl, decl, ptr)
8788 int kind;
8789 tree wfl, decl, ptr;
8790 {
8791 jdep *new = (jdep *)xmalloc (sizeof (jdep));
8792
8793 if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
8794 ptr = obtain_incomplete_type (wfl);
8795
8796 JDEP_KIND (new) = kind;
8797 JDEP_DECL (new) = decl;
8798 JDEP_TO_RESOLVE (new) = ptr;
8799 JDEP_WFL (new) = wfl;
8800 JDEP_CHAIN (new) = NULL;
8801 JDEP_MISC (new) = NULL_TREE;
8802 /* For some dependencies, set the enclosing class of the current
8803 class to be the enclosing context */
8804 if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS)
8805 && GET_ENCLOSING_CPC ())
8806 JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
8807 else if (kind == JDEP_SUPER)
8808 JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
8809 TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
8810 else
8811 JDEP_ENCLOSING (new) = GET_CPC ();
8812 JDEP_GET_PATCH (new) = (tree *)NULL;
8813
8814 JDEP_INSERT (ctxp->classd_list, new);
8815
8816 return ptr;
8817 }
8818
8819 /* This checks for circular references with innerclasses. We start
8820 from SOURCE and should never reach TARGET. Extended/implemented
8821 types in SOURCE have their enclosing context checked not to reach
8822 TARGET. When the last enclosing context of SOURCE is reached, its
8823 extended/implemented types are also checked not to reach TARGET.
8824 In case of error, WFL of the offending type is returned; NULL_TREE
8825 otherwise. */
8826
8827 static tree
check_inner_circular_reference(source,target)8828 check_inner_circular_reference (source, target)
8829 tree source;
8830 tree target;
8831 {
8832 tree basetype_vec = TYPE_BINFO_BASETYPES (source);
8833 tree ctx, cl;
8834 int i;
8835
8836 if (!basetype_vec)
8837 return NULL_TREE;
8838
8839 for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
8840 {
8841 tree su;
8842
8843 /* We can end up with a NULL_TREE or an incomplete type here if
8844 we encountered previous type resolution errors. It's safe to
8845 simply ignore these cases. */
8846 if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
8847 continue;
8848 su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
8849 if (INCOMPLETE_TYPE_P (su))
8850 continue;
8851
8852 if (inherits_from_p (su, target))
8853 return lookup_cl (TYPE_NAME (su));
8854
8855 for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
8856 {
8857 /* An enclosing context shouldn't be TARGET */
8858 if (ctx == TYPE_NAME (target))
8859 return lookup_cl (TYPE_NAME (su));
8860
8861 /* When we reach the enclosing last context, start a check
8862 on it, with the same target */
8863 if (! DECL_CONTEXT (ctx) &&
8864 (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
8865 return cl;
8866 }
8867 }
8868 return NULL_TREE;
8869 }
8870
8871 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
8872 offending type if a circularity is detected. NULL_TREE is returned
8873 otherwise. TYPE can be an interface or a class. */
8874
8875 static tree
check_circular_reference(type)8876 check_circular_reference (type)
8877 tree type;
8878 {
8879 tree basetype_vec = TYPE_BINFO_BASETYPES (type);
8880 int i;
8881
8882 if (!basetype_vec)
8883 return NULL_TREE;
8884
8885 if (! CLASS_INTERFACE (TYPE_NAME (type)))
8886 {
8887 if (inherits_from_p (CLASSTYPE_SUPER (type), type))
8888 return lookup_cl (TYPE_NAME (type));
8889 return NULL_TREE;
8890 }
8891
8892 for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
8893 {
8894 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
8895 if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
8896 && interface_of_p (type, BINFO_TYPE (vec_elt)))
8897 return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
8898 }
8899 return NULL_TREE;
8900 }
8901
8902 void
java_check_circular_reference()8903 java_check_circular_reference ()
8904 {
8905 tree current;
8906 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
8907 {
8908 tree type = TREE_TYPE (current);
8909 tree cl;
8910
8911 cl = check_circular_reference (type);
8912 if (! cl)
8913 cl = check_inner_circular_reference (type, type);
8914 if (cl)
8915 parse_error_context (cl, "Cyclic class inheritance%s",
8916 (cyclic_inheritance_report ?
8917 cyclic_inheritance_report : ""));
8918 }
8919 }
8920
8921 /* Augment the parameter list PARM with parameters crafted to
8922 initialize outer context locals aliases. Through ARTIFICIAL, a
8923 count is kept of the number of crafted parameters. MODE governs
8924 what eventually gets created: something suitable for a function
8925 creation or a function invocation, either the constructor or
8926 finit$. */
8927
8928 static tree
build_alias_initializer_parameter_list(mode,class_type,parm,artificial)8929 build_alias_initializer_parameter_list (mode, class_type, parm, artificial)
8930 int mode;
8931 tree class_type, parm;
8932 int *artificial;
8933 {
8934 tree field;
8935 tree additional_parms = NULL_TREE;
8936
8937 for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
8938 if (FIELD_LOCAL_ALIAS (field))
8939 {
8940 const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
8941 tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
8942 tree mangled_id;
8943
8944 switch (mode)
8945 {
8946 case AIPL_FUNCTION_DECLARATION:
8947 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
8948 &buffer [4]);
8949 purpose = build_wfl_node (mangled_id);
8950 if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
8951 value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
8952 else
8953 value = TREE_TYPE (field);
8954 break;
8955
8956 case AIPL_FUNCTION_CREATION:
8957 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
8958 &buffer [4]);
8959 value = TREE_TYPE (field);
8960 break;
8961
8962 case AIPL_FUNCTION_FINIT_INVOCATION:
8963 MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
8964 &buffer [4]);
8965 /* Now, this is wrong. purpose should always be the NAME
8966 of something and value its matching value (decl, type,
8967 etc...) FIXME -- but there is a lot to fix. */
8968
8969 /* When invoked for this kind of operation, we already
8970 know whether a field is used or not. */
8971 purpose = TREE_TYPE (field);
8972 value = build_wfl_node (mangled_id);
8973 break;
8974
8975 case AIPL_FUNCTION_CTOR_INVOCATION:
8976 /* There are two case: the constructor invokation happends
8977 outside the local inner, in which case, locales from the outer
8978 context are directly used.
8979
8980 Otherwise, we fold to using the alias directly. */
8981 if (class_type == current_class)
8982 value = field;
8983 else
8984 {
8985 name = get_identifier (&buffer[4]);
8986 value = IDENTIFIER_LOCAL_VALUE (name);
8987 }
8988 break;
8989 }
8990 additional_parms = tree_cons (purpose, value, additional_parms);
8991 if (artificial)
8992 *artificial +=1;
8993 }
8994 if (additional_parms)
8995 {
8996 if (ANONYMOUS_CLASS_P (class_type)
8997 && mode == AIPL_FUNCTION_CTOR_INVOCATION)
8998 additional_parms = nreverse (additional_parms);
8999 parm = chainon (additional_parms, parm);
9000 }
9001
9002 return parm;
9003 }
9004
9005 /* Craft a constructor for CLASS_DECL -- what we should do when none
9006 where found. ARGS is non NULL when a special signature must be
9007 enforced. This is the case for anonymous classes. */
9008
9009 static tree
craft_constructor(class_decl,args)9010 craft_constructor (class_decl, args)
9011 tree class_decl, args;
9012 {
9013 tree class_type = TREE_TYPE (class_decl);
9014 tree parm = NULL_TREE;
9015 int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
9016 ACC_PUBLIC : 0);
9017 int i = 0, artificial = 0;
9018 tree decl, ctor_name;
9019 char buffer [80];
9020
9021 /* The constructor name is <init> unless we're dealing with an
9022 anonymous class, in which case the name will be fixed after having
9023 be expanded. */
9024 if (ANONYMOUS_CLASS_P (class_type))
9025 ctor_name = DECL_NAME (class_decl);
9026 else
9027 ctor_name = init_identifier_node;
9028
9029 /* If we're dealing with an inner class constructor, we hide the
9030 this$<n> decl in the name field of its parameter declaration. */
9031 if (PURE_INNER_CLASS_TYPE_P (class_type))
9032 {
9033 tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
9034 parm = tree_cons (build_current_thisn (class_type),
9035 build_pointer_type (type), parm);
9036
9037 /* Some more arguments to be hidden here. The values of the local
9038 variables of the outer context that the inner class needs to see. */
9039 parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
9040 class_type, parm,
9041 &artificial);
9042 }
9043
9044 /* Then if there are any args to be enforced, enforce them now */
9045 for (; args && args != end_params_node; args = TREE_CHAIN (args))
9046 {
9047 sprintf (buffer, "parm%d", i++);
9048 parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
9049 }
9050
9051 CRAFTED_PARAM_LIST_FIXUP (parm);
9052 decl = create_artificial_method (class_type, flags, void_type_node,
9053 ctor_name, parm);
9054 fix_method_argument_names (parm, decl);
9055 /* Now, mark the artificial parameters. */
9056 DECL_FUNCTION_NAP (decl) = artificial;
9057 DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
9058 return decl;
9059 }
9060
9061
9062 /* Fix the constructors. This will be called right after circular
9063 references have been checked. It is necessary to fix constructors
9064 early even if no code generation will take place for that class:
9065 some generated constructor might be required by the class whose
9066 compilation triggered this one to be simply loaded. */
9067
9068 void
java_fix_constructors()9069 java_fix_constructors ()
9070 {
9071 tree current;
9072
9073 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9074 {
9075 tree class_type = TREE_TYPE (current);
9076 int saw_ctor = 0;
9077 tree decl;
9078
9079 if (CLASS_INTERFACE (TYPE_NAME (class_type)))
9080 continue;
9081
9082 current_class = class_type;
9083 for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
9084 {
9085 if (DECL_CONSTRUCTOR_P (decl))
9086 {
9087 fix_constructors (decl);
9088 saw_ctor = 1;
9089 }
9090 }
9091
9092 /* Anonymous class constructor can't be generated that early. */
9093 if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
9094 craft_constructor (current, NULL_TREE);
9095 }
9096 }
9097
9098 /* safe_layout_class just makes sure that we can load a class without
9099 disrupting the current_class, input_file, lineno, etc, information
9100 about the class processed currently. */
9101
9102 void
safe_layout_class(class)9103 safe_layout_class (class)
9104 tree class;
9105 {
9106 tree save_current_class = current_class;
9107 const char *save_input_filename = input_filename;
9108 int save_lineno = lineno;
9109
9110 layout_class (class);
9111
9112 current_class = save_current_class;
9113 input_filename = save_input_filename;
9114 lineno = save_lineno;
9115 }
9116
9117 static tree
jdep_resolve_class(dep)9118 jdep_resolve_class (dep)
9119 jdep *dep;
9120 {
9121 tree decl;
9122
9123 if (JDEP_RESOLVED_P (dep))
9124 decl = JDEP_RESOLVED_DECL (dep);
9125 else
9126 {
9127 decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
9128 JDEP_DECL (dep), JDEP_WFL (dep));
9129 JDEP_RESOLVED (dep, decl);
9130 }
9131
9132 if (!decl)
9133 complete_class_report_errors (dep);
9134 else if (PURE_INNER_CLASS_DECL_P (decl))
9135 {
9136 tree inner = TREE_TYPE (decl);
9137 if (! CLASS_LOADED_P (inner))
9138 {
9139 safe_layout_class (inner);
9140 if (TYPE_SIZE (inner) == error_mark_node)
9141 TYPE_SIZE (inner) = NULL_TREE;
9142 }
9143 check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
9144 }
9145 return decl;
9146 }
9147
9148 /* Complete unsatisfied class declaration and their dependencies */
9149
9150 void
java_complete_class()9151 java_complete_class ()
9152 {
9153 tree cclass;
9154 jdeplist *cclassd;
9155 int error_found;
9156 tree type;
9157
9158 /* Process imports */
9159 process_imports ();
9160
9161 /* Reverse things so we have the right order */
9162 ctxp->class_list = nreverse (ctxp->class_list);
9163 ctxp->classd_list = reverse_jdep_list (ctxp);
9164
9165 for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
9166 cclass && cclassd;
9167 cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
9168 {
9169 jdep *dep;
9170
9171 /* We keep the compilation unit imports in the class so that
9172 they can be used later to resolve type dependencies that
9173 aren't necessary to solve now. */
9174 TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
9175 TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
9176
9177 for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
9178 {
9179 tree decl;
9180 if (!(decl = jdep_resolve_class (dep)))
9181 continue;
9182
9183 /* Now it's time to patch */
9184 switch (JDEP_KIND (dep))
9185 {
9186 case JDEP_SUPER:
9187 /* Simply patch super */
9188 if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
9189 continue;
9190 BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
9191 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
9192 break;
9193
9194 case JDEP_FIELD:
9195 {
9196 /* We do part of the job done in add_field */
9197 tree field_decl = JDEP_DECL (dep);
9198 tree field_type = TREE_TYPE (decl);
9199 if (TREE_CODE (field_type) == RECORD_TYPE)
9200 field_type = promote_type (field_type);
9201 TREE_TYPE (field_decl) = field_type;
9202 DECL_ALIGN (field_decl) = 0;
9203 DECL_USER_ALIGN (field_decl) = 0;
9204 layout_decl (field_decl, 0);
9205 SOURCE_FRONTEND_DEBUG
9206 (("Completed field/var decl `%s' with `%s'",
9207 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
9208 IDENTIFIER_POINTER (DECL_NAME (decl))));
9209 break;
9210 }
9211 case JDEP_METHOD: /* We start patching a method */
9212 case JDEP_METHOD_RETURN:
9213 error_found = 0;
9214 while (1)
9215 {
9216 if (decl)
9217 {
9218 type = TREE_TYPE(decl);
9219 if (TREE_CODE (type) == RECORD_TYPE)
9220 type = promote_type (type);
9221 JDEP_APPLY_PATCH (dep, type);
9222 SOURCE_FRONTEND_DEBUG
9223 (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
9224 "Completing fct `%s' with ret type `%s'":
9225 "Completing arg `%s' with type `%s'"),
9226 IDENTIFIER_POINTER (EXPR_WFL_NODE
9227 (JDEP_DECL_WFL (dep))),
9228 IDENTIFIER_POINTER (DECL_NAME (decl))));
9229 }
9230 else
9231 error_found = 1;
9232 dep = JDEP_CHAIN (dep);
9233 if (JDEP_KIND (dep) == JDEP_METHOD_END)
9234 break;
9235 else
9236 decl = jdep_resolve_class (dep);
9237 }
9238 if (!error_found)
9239 {
9240 tree mdecl = JDEP_DECL (dep), signature;
9241 /* Recompute and reset the signature, check first that
9242 all types are now defined. If they're not,
9243 don't build the signature. */
9244 if (check_method_types_complete (mdecl))
9245 {
9246 signature = build_java_signature (TREE_TYPE (mdecl));
9247 set_java_signature (TREE_TYPE (mdecl), signature);
9248 }
9249 }
9250 else
9251 continue;
9252 break;
9253
9254 case JDEP_INTERFACE:
9255 if (parser_check_super_interface (decl, JDEP_DECL (dep),
9256 JDEP_WFL (dep)))
9257 continue;
9258 parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
9259 break;
9260
9261 case JDEP_PARM:
9262 case JDEP_VARIABLE:
9263 type = TREE_TYPE(decl);
9264 if (TREE_CODE (type) == RECORD_TYPE)
9265 type = promote_type (type);
9266 JDEP_APPLY_PATCH (dep, type);
9267 break;
9268
9269 case JDEP_TYPE:
9270 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
9271 SOURCE_FRONTEND_DEBUG
9272 (("Completing a random type dependency on a '%s' node",
9273 tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
9274 break;
9275
9276 case JDEP_EXCEPTION:
9277 JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
9278 SOURCE_FRONTEND_DEBUG
9279 (("Completing `%s' `throws' argument node",
9280 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
9281 break;
9282
9283 case JDEP_ANONYMOUS:
9284 patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
9285 break;
9286
9287 default:
9288 abort ();
9289 }
9290 }
9291 }
9292 return;
9293 }
9294
9295 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
9296 array. */
9297
9298 static tree
resolve_class(enclosing,class_type,decl,cl)9299 resolve_class (enclosing, class_type, decl, cl)
9300 tree enclosing, class_type, decl, cl;
9301 {
9302 tree tname = TYPE_NAME (class_type);
9303 tree resolved_type = TREE_TYPE (class_type);
9304 int array_dims = 0;
9305 tree resolved_type_decl;
9306
9307 if (resolved_type != NULL_TREE)
9308 {
9309 tree resolved_type_decl = TYPE_NAME (resolved_type);
9310 if (resolved_type_decl == NULL_TREE
9311 || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
9312 {
9313 resolved_type_decl = build_decl (TYPE_DECL,
9314 TYPE_NAME (class_type),
9315 resolved_type);
9316 }
9317 return resolved_type_decl;
9318 }
9319
9320 /* 1- Check to see if we have an array. If true, find what we really
9321 want to resolve */
9322 if ((array_dims = build_type_name_from_array_name (tname,
9323 &TYPE_NAME (class_type))))
9324 WFL_STRIP_BRACKET (cl, cl);
9325
9326 /* 2- Resolve the bare type */
9327 if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
9328 decl, cl)))
9329 return NULL_TREE;
9330 resolved_type = TREE_TYPE (resolved_type_decl);
9331
9332 /* 3- If we have an array, reconstruct the array down to its nesting */
9333 if (array_dims)
9334 {
9335 for (; array_dims; array_dims--)
9336 resolved_type = build_java_array_type (resolved_type, -1);
9337 resolved_type_decl = TYPE_NAME (resolved_type);
9338 }
9339 TREE_TYPE (class_type) = resolved_type;
9340 return resolved_type_decl;
9341 }
9342
9343 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
9344 are used to report error messages; CL must either be NULL_TREE or a
9345 WFL wrapping a class. Do not try to replace TYPE_NAME (class_type)
9346 by a variable, since it is changed by find_in_imports{_on_demand}
9347 and (but it doesn't really matter) qualify_and_find. */
9348
9349 tree
do_resolve_class(enclosing,class_type,decl,cl)9350 do_resolve_class (enclosing, class_type, decl, cl)
9351 tree enclosing, class_type, decl, cl;
9352 {
9353 tree new_class_decl = NULL_TREE, super = NULL_TREE;
9354 tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
9355 tree decl_result;
9356 htab_t circularity_hash;
9357
9358 if (QUALIFIED_P (TYPE_NAME (class_type)))
9359 {
9360 /* If the type name is of the form `Q . Id', then Q is either a
9361 package name or a class name. First we try to find Q as a
9362 class and then treat Id as a member type. If we can't find Q
9363 as a class then we fall through. */
9364 tree q, left, left_type, right;
9365 if (breakdown_qualified (&left, &right, TYPE_NAME (class_type)) == 0)
9366 {
9367 BUILD_PTR_FROM_NAME (left_type, left);
9368 q = do_resolve_class (enclosing, left_type, decl, cl);
9369 if (q)
9370 {
9371 enclosing = q;
9372 saved_enclosing_type = TREE_TYPE (q);
9373 BUILD_PTR_FROM_NAME (class_type, right);
9374 }
9375 }
9376 }
9377
9378 if (enclosing)
9379 {
9380 /* This hash table is used to register the classes we're going
9381 through when searching the current class as an inner class, in
9382 order to detect circular references. Remember to free it before
9383 returning the section 0- of this function. */
9384 circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
9385 NULL);
9386
9387 /* 0- Search in the current class as an inner class.
9388 Maybe some code here should be added to load the class or
9389 something, at least if the class isn't an inner class and ended
9390 being loaded from class file. FIXME. */
9391 while (enclosing)
9392 {
9393 new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
9394 &super, class_type);
9395 if (new_class_decl)
9396 break;
9397
9398 /* If we haven't found anything because SUPER reached Object and
9399 ENCLOSING happens to be an innerclass, try the enclosing context. */
9400 if ((!super || super == object_type_node) &&
9401 enclosing && INNER_CLASS_DECL_P (enclosing))
9402 enclosing = DECL_CONTEXT (enclosing);
9403 else
9404 enclosing = NULL_TREE;
9405 }
9406
9407 htab_delete (circularity_hash);
9408
9409 if (new_class_decl)
9410 return new_class_decl;
9411 }
9412
9413 /* 1- Check for the type in single imports. This will change
9414 TYPE_NAME() if something relevant is found */
9415 find_in_imports (saved_enclosing_type, class_type);
9416
9417 /* 2- And check for the type in the current compilation unit */
9418 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
9419 {
9420 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
9421 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
9422 load_class (TYPE_NAME (class_type), 0);
9423 return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
9424 }
9425
9426 /* 3- Search according to the current package definition */
9427 if (!QUALIFIED_P (TYPE_NAME (class_type)))
9428 {
9429 if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
9430 TYPE_NAME (class_type))))
9431 return new_class_decl;
9432 }
9433
9434 /* 4- Check the import on demands. Don't allow bar.baz to be
9435 imported from foo.* */
9436 if (!QUALIFIED_P (TYPE_NAME (class_type)))
9437 if (find_in_imports_on_demand (saved_enclosing_type, class_type))
9438 return NULL_TREE;
9439
9440 /* If found in find_in_imports_on_demand, the type has already been
9441 loaded. */
9442 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
9443 return new_class_decl;
9444
9445 /* 5- Try with a name qualified with the package name we've seen so far */
9446 if (!QUALIFIED_P (TYPE_NAME (class_type)))
9447 {
9448 tree package;
9449
9450 /* If there is a current package (ctxp->package), it's the first
9451 element of package_list and we can skip it. */
9452 for (package = (ctxp->package ?
9453 TREE_CHAIN (package_list) : package_list);
9454 package; package = TREE_CHAIN (package))
9455 if ((new_class_decl = qualify_and_find (class_type,
9456 TREE_PURPOSE (package),
9457 TYPE_NAME (class_type))))
9458 return new_class_decl;
9459 }
9460
9461 /* 5- Check another compilation unit that bears the name of type */
9462 load_class (TYPE_NAME (class_type), 0);
9463
9464 if (!cl)
9465 cl = lookup_cl (decl);
9466
9467 /* If we don't have a value for CL, then we're being called recursively.
9468 We can't check package access just yet, but it will be taken care of
9469 by the caller. */
9470 if (cl)
9471 {
9472 if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
9473 return NULL_TREE;
9474 }
9475
9476 /* 6- Last call for a resolution */
9477 decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
9478
9479 /* The final lookup might have registered a.b.c into a.b$c If we
9480 failed at the first lookup, progressively change the name if
9481 applicable and use the matching DECL instead. */
9482 if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
9483 {
9484 char *separator;
9485 tree name = TYPE_NAME (class_type);
9486 char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
9487
9488 strcpy (namebuffer, IDENTIFIER_POINTER (name));
9489
9490 do {
9491
9492 /* Reach the last '.', and if applicable, replace it by a `$' and
9493 see if this exists as a type. */
9494 if ((separator = strrchr (namebuffer, '.')))
9495 {
9496 *separator = '$';
9497 name = get_identifier (namebuffer);
9498 decl_result = IDENTIFIER_CLASS_VALUE (name);
9499 }
9500 } while (!decl_result && separator);
9501 }
9502 return decl_result;
9503 }
9504
9505 static tree
qualify_and_find(class_type,package,name)9506 qualify_and_find (class_type, package, name)
9507 tree class_type, package, name;
9508 {
9509 tree new_qualified = merge_qualified_name (package, name);
9510 tree new_class_decl;
9511
9512 if (!IDENTIFIER_CLASS_VALUE (new_qualified))
9513 load_class (new_qualified, 0);
9514 if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
9515 {
9516 if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
9517 !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
9518 load_class (new_qualified, 0);
9519 TYPE_NAME (class_type) = new_qualified;
9520 return IDENTIFIER_CLASS_VALUE (new_qualified);
9521 }
9522 return NULL_TREE;
9523 }
9524
9525 /* Resolve NAME and lay it out (if not done and if not the current
9526 parsed class). Return a decl node. This function is meant to be
9527 called when type resolution is necessary during the walk pass. */
9528
9529 static tree
resolve_and_layout(something,cl)9530 resolve_and_layout (something, cl)
9531 tree something;
9532 tree cl;
9533 {
9534 tree decl, decl_type;
9535
9536 /* Don't do that on the current class */
9537 if (something == current_class)
9538 return TYPE_NAME (current_class);
9539
9540 /* Don't do anything for void and other primitive types */
9541 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
9542 return NULL_TREE;
9543
9544 /* Pointer types can be reall pointer types or fake pointers. When
9545 finding a real pointer, recheck for primitive types */
9546 if (TREE_CODE (something) == POINTER_TYPE)
9547 {
9548 if (TREE_TYPE (something))
9549 {
9550 something = TREE_TYPE (something);
9551 if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
9552 return NULL_TREE;
9553 }
9554 else
9555 something = TYPE_NAME (something);
9556 }
9557
9558 /* Don't do anything for arrays of primitive types */
9559 if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
9560 && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
9561 return NULL_TREE;
9562
9563 /* Something might be a WFL */
9564 if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
9565 something = EXPR_WFL_NODE (something);
9566
9567 /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
9568 TYPE_DECL or a real TYPE */
9569 else if (TREE_CODE (something) != IDENTIFIER_NODE)
9570 something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
9571 DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
9572
9573 if (!(decl = resolve_no_layout (something, cl)))
9574 return NULL_TREE;
9575
9576 /* Resolve and layout if necessary */
9577 decl_type = TREE_TYPE (decl);
9578 layout_class_methods (decl_type);
9579 /* Check methods */
9580 if (CLASS_FROM_SOURCE_P (decl_type))
9581 java_check_methods (decl);
9582 /* Layout the type if necessary */
9583 if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
9584 safe_layout_class (decl_type);
9585
9586 return decl;
9587 }
9588
9589 /* Resolve a class, returns its decl but doesn't perform any
9590 layout. The current parsing context is saved and restored */
9591
9592 static tree
resolve_no_layout(name,cl)9593 resolve_no_layout (name, cl)
9594 tree name, cl;
9595 {
9596 tree ptr, decl;
9597 BUILD_PTR_FROM_NAME (ptr, name);
9598 java_parser_context_save_global ();
9599 decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
9600 java_parser_context_restore_global ();
9601
9602 return decl;
9603 }
9604
9605 /* Called when reporting errors. Skip the '[]'s in a complex array
9606 type description that failed to be resolved. purify_type_name can't
9607 use an identifier tree. */
9608
9609 static const char *
purify_type_name(name)9610 purify_type_name (name)
9611 const char *name;
9612 {
9613 int len = strlen (name);
9614 int bracket_found;
9615
9616 STRING_STRIP_BRACKETS (name, len, bracket_found);
9617 if (bracket_found)
9618 {
9619 char *stripped_name = xmemdup (name, len, len+1);
9620 stripped_name [len] = '\0';
9621 return stripped_name;
9622 }
9623 return name;
9624 }
9625
9626 /* The type CURRENT refers to can't be found. We print error messages. */
9627
9628 static void
complete_class_report_errors(dep)9629 complete_class_report_errors (dep)
9630 jdep *dep;
9631 {
9632 const char *name;
9633
9634 if (!JDEP_WFL (dep))
9635 return;
9636
9637 name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
9638 switch (JDEP_KIND (dep))
9639 {
9640 case JDEP_SUPER:
9641 parse_error_context
9642 (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
9643 purify_type_name (name),
9644 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
9645 break;
9646 case JDEP_FIELD:
9647 parse_error_context
9648 (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
9649 purify_type_name (name),
9650 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
9651 break;
9652 case JDEP_METHOD: /* Covers arguments */
9653 parse_error_context
9654 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
9655 purify_type_name (name),
9656 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
9657 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
9658 break;
9659 case JDEP_METHOD_RETURN: /* Covers return type */
9660 parse_error_context
9661 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
9662 purify_type_name (name),
9663 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
9664 break;
9665 case JDEP_INTERFACE:
9666 parse_error_context
9667 (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
9668 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
9669 (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
9670 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
9671 break;
9672 case JDEP_VARIABLE:
9673 parse_error_context
9674 (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
9675 purify_type_name (IDENTIFIER_POINTER
9676 (EXPR_WFL_NODE (JDEP_WFL (dep)))),
9677 IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
9678 break;
9679 case JDEP_EXCEPTION: /* As specified by `throws' */
9680 parse_error_context
9681 (JDEP_WFL (dep), "Class `%s' not found in `throws'",
9682 IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
9683 break;
9684 default:
9685 /* Fix for -Wall. Just break doing nothing. The error will be
9686 caught later */
9687 break;
9688 }
9689 }
9690
9691 /* Return a static string containing the DECL prototype string. If
9692 DECL is a constructor, use the class name instead of the form
9693 <init> */
9694
9695 static const char *
get_printable_method_name(decl)9696 get_printable_method_name (decl)
9697 tree decl;
9698 {
9699 const char *to_return;
9700 tree name = NULL_TREE;
9701
9702 if (DECL_CONSTRUCTOR_P (decl))
9703 {
9704 name = DECL_NAME (decl);
9705 DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
9706 }
9707
9708 to_return = lang_printable_name (decl, 0);
9709 if (DECL_CONSTRUCTOR_P (decl))
9710 DECL_NAME (decl) = name;
9711
9712 return to_return;
9713 }
9714
9715 /* Track method being redefined inside the same class. As a side
9716 effect, set DECL_NAME to an IDENTIFIER (prior entering this
9717 function it's a FWL, so we can track errors more accurately.) */
9718
9719 static int
check_method_redefinition(class,method)9720 check_method_redefinition (class, method)
9721 tree class, method;
9722 {
9723 tree redef, sig;
9724
9725 /* There's no need to verify <clinit> and finit$ and instinit$ */
9726 if (DECL_CLINIT_P (method)
9727 || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
9728 return 0;
9729
9730 sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
9731 for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
9732 {
9733 if (redef == method)
9734 break;
9735 if (DECL_NAME (redef) == DECL_NAME (method)
9736 && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
9737 && !DECL_ARTIFICIAL (method))
9738 {
9739 parse_error_context
9740 (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
9741 (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
9742 get_printable_method_name (redef));
9743 return 1;
9744 }
9745 }
9746 return 0;
9747 }
9748
9749 /* Return 1 if check went ok, 0 otherwise. */
9750 static int
check_abstract_method_definitions(do_interface,class_decl,type)9751 check_abstract_method_definitions (do_interface, class_decl, type)
9752 int do_interface;
9753 tree class_decl, type;
9754 {
9755 tree class = TREE_TYPE (class_decl);
9756 tree method, end_type;
9757 int ok = 1;
9758
9759 end_type = (do_interface ? object_type_node : type);
9760 for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
9761 {
9762 tree other_super, other_method, method_sig, method_name;
9763 int found = 0;
9764 int end_type_reached = 0;
9765
9766 if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
9767 continue;
9768
9769 /* Now verify that somewhere in between TYPE and CLASS,
9770 abstract method METHOD gets a non abstract definition
9771 that is inherited by CLASS. */
9772
9773 method_sig = build_java_signature (TREE_TYPE (method));
9774 method_name = DECL_NAME (method);
9775 if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
9776 method_name = EXPR_WFL_NODE (method_name);
9777
9778 other_super = class;
9779 do {
9780 if (other_super == end_type)
9781 end_type_reached = 1;
9782
9783 /* Method search */
9784 for (other_method = TYPE_METHODS (other_super); other_method;
9785 other_method = TREE_CHAIN (other_method))
9786 {
9787 tree s = build_java_signature (TREE_TYPE (other_method));
9788 tree other_name = DECL_NAME (other_method);
9789
9790 if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
9791 other_name = EXPR_WFL_NODE (other_name);
9792 if (!DECL_CLINIT_P (other_method)
9793 && !DECL_CONSTRUCTOR_P (other_method)
9794 && method_name == other_name
9795 && method_sig == s
9796 && !METHOD_ABSTRACT (other_method))
9797 {
9798 found = 1;
9799 break;
9800 }
9801 }
9802 other_super = CLASSTYPE_SUPER (other_super);
9803 } while (!end_type_reached);
9804
9805 /* Report that abstract METHOD didn't find an implementation
9806 that CLASS can use. */
9807 if (!found)
9808 {
9809 char *t = xstrdup (lang_printable_name
9810 (TREE_TYPE (TREE_TYPE (method)), 0));
9811 tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
9812
9813 parse_error_context
9814 (lookup_cl (class_decl),
9815 "Class `%s' doesn't define the abstract method `%s %s' from %s `%s'. This method must be defined or %s `%s' must be declared abstract",
9816 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
9817 t, lang_printable_name (method, 0),
9818 (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
9819 "interface" : "class"),
9820 IDENTIFIER_POINTER (ccn),
9821 (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
9822 IDENTIFIER_POINTER (DECL_NAME (class_decl)));
9823 ok = 0;
9824 free (t);
9825 }
9826 }
9827
9828 if (ok && do_interface)
9829 {
9830 /* Check for implemented interfaces. */
9831 int i;
9832 tree vector = TYPE_BINFO_BASETYPES (type);
9833 for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
9834 {
9835 tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
9836 ok = check_abstract_method_definitions (1, class_decl, super);
9837 }
9838 }
9839
9840 return ok;
9841 }
9842
9843 /* Check that CLASS_DECL somehow implements all inherited abstract
9844 methods. */
9845
9846 static void
java_check_abstract_method_definitions(class_decl)9847 java_check_abstract_method_definitions (class_decl)
9848 tree class_decl;
9849 {
9850 tree class = TREE_TYPE (class_decl);
9851 tree super, vector;
9852 int i;
9853
9854 if (CLASS_ABSTRACT (class_decl))
9855 return;
9856
9857 /* Check for inherited types */
9858 super = class;
9859 do {
9860 super = CLASSTYPE_SUPER (super);
9861 check_abstract_method_definitions (0, class_decl, super);
9862 } while (super != object_type_node);
9863
9864 /* Check for implemented interfaces. */
9865 vector = TYPE_BINFO_BASETYPES (class);
9866 for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
9867 {
9868 super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
9869 check_abstract_method_definitions (1, class_decl, super);
9870 }
9871 }
9872
9873 /* Check all the types method DECL uses and return 1 if all of them
9874 are now complete, 0 otherwise. This is used to check whether its
9875 safe to build a method signature or not. */
9876
9877 static int
check_method_types_complete(decl)9878 check_method_types_complete (decl)
9879 tree decl;
9880 {
9881 tree type = TREE_TYPE (decl);
9882 tree args;
9883
9884 if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
9885 return 0;
9886
9887 args = TYPE_ARG_TYPES (type);
9888 if (TREE_CODE (type) == METHOD_TYPE)
9889 args = TREE_CHAIN (args);
9890 for (; args != end_params_node; args = TREE_CHAIN (args))
9891 if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
9892 return 0;
9893
9894 return 1;
9895 }
9896
9897 /* Visible interface to check methods contained in CLASS_DECL */
9898
9899 void
java_check_methods(class_decl)9900 java_check_methods (class_decl)
9901 tree class_decl;
9902 {
9903 if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
9904 return;
9905
9906 if (CLASS_INTERFACE (class_decl))
9907 java_check_abstract_methods (class_decl);
9908 else
9909 java_check_regular_methods (class_decl);
9910
9911 CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
9912 }
9913
9914 /* Check all the methods of CLASS_DECL. Methods are first completed
9915 then checked according to regular method existence rules. If no
9916 constructor for CLASS_DECL were encountered, then build its
9917 declaration. */
9918
9919 static void
java_check_regular_methods(class_decl)9920 java_check_regular_methods (class_decl)
9921 tree class_decl;
9922 {
9923 int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
9924 tree method;
9925 tree class = TREE_TYPE (class_decl);
9926 tree found = NULL_TREE;
9927 tree mthrows;
9928
9929 /* It is not necessary to check methods defined in java.lang.Object */
9930 if (class == object_type_node)
9931 return;
9932
9933 if (!TYPE_NVIRTUALS (class))
9934 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
9935
9936 /* Should take interfaces into account. FIXME */
9937 for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
9938 {
9939 tree sig;
9940 tree method_wfl = DECL_FUNCTION_WFL (method);
9941 int aflags;
9942
9943 /* Check for redefinitions */
9944 if (check_method_redefinition (class, method))
9945 continue;
9946
9947 /* We verify things thrown by the method. They must inherit from
9948 java.lang.Throwable. */
9949 for (mthrows = DECL_FUNCTION_THROWS (method);
9950 mthrows; mthrows = TREE_CHAIN (mthrows))
9951 {
9952 if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
9953 parse_error_context
9954 (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
9955 IDENTIFIER_POINTER
9956 (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
9957 }
9958
9959 /* If we see one constructor a mark so we don't generate the
9960 default one. Also skip other verifications: constructors
9961 can't be inherited hence hidden or overridden. */
9962 if (DECL_CONSTRUCTOR_P (method))
9963 {
9964 saw_constructor = 1;
9965 continue;
9966 }
9967
9968 sig = build_java_argument_signature (TREE_TYPE (method));
9969 found = lookup_argument_method2 (class, DECL_NAME (method), sig);
9970
9971 /* Inner class can't declare static methods */
9972 if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
9973 {
9974 char *t = xstrdup (lang_printable_name (class, 0));
9975 parse_error_context
9976 (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
9977 lang_printable_name (method, 0), t);
9978 free (t);
9979 }
9980
9981 /* Nothing overrides or it's a private method. */
9982 if (!found)
9983 continue;
9984 if (METHOD_PRIVATE (found))
9985 {
9986 found = NULL_TREE;
9987 continue;
9988 }
9989
9990 /* If `found' is declared in an interface, make sure the
9991 modifier matches. */
9992 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
9993 && clinit_identifier_node != DECL_NAME (found)
9994 && !METHOD_PUBLIC (method))
9995 {
9996 tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
9997 parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
9998 IDENTIFIER_POINTER (DECL_NAME (class_decl)),
9999 lang_printable_name (method, 0),
10000 IDENTIFIER_POINTER (DECL_NAME (found_decl)));
10001 }
10002
10003 /* Can't override a method with the same name and different return
10004 types. */
10005 if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
10006 {
10007 char *t = xstrdup
10008 (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
10009 parse_error_context
10010 (method_wfl,
10011 "Method `%s' was defined with return type `%s' in class `%s'",
10012 lang_printable_name (found, 0), t,
10013 IDENTIFIER_POINTER
10014 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
10015 free (t);
10016 }
10017
10018 aflags = get_access_flags_from_decl (found);
10019
10020 /* Can't override final. Can't override static. */
10021 if (METHOD_FINAL (found) || METHOD_STATIC (found))
10022 {
10023 /* Static *can* override static */
10024 if (METHOD_STATIC (found) && METHOD_STATIC (method))
10025 continue;
10026 parse_error_context
10027 (method_wfl,
10028 "%s methods can't be overriden. Method `%s' is %s in class `%s'",
10029 (METHOD_FINAL (found) ? "Final" : "Static"),
10030 lang_printable_name (found, 0),
10031 (METHOD_FINAL (found) ? "final" : "static"),
10032 IDENTIFIER_POINTER
10033 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
10034 continue;
10035 }
10036
10037 /* Static method can't override instance method. */
10038 if (METHOD_STATIC (method))
10039 {
10040 parse_error_context
10041 (method_wfl,
10042 "Instance methods can't be overriden by a static method. Method `%s' is an instance method in class `%s'",
10043 lang_printable_name (found, 0),
10044 IDENTIFIER_POINTER
10045 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
10046 continue;
10047 }
10048
10049 /* - Overriding/hiding public must be public
10050 - Overriding/hiding protected must be protected or public
10051 - If the overriden or hidden method has default (package)
10052 access, then the overriding or hiding method must not be
10053 private; otherwise, a compile-time error occurs. If
10054 `found' belongs to an interface, things have been already
10055 taken care of. */
10056 if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
10057 && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
10058 || (METHOD_PROTECTED (found)
10059 && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
10060 || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
10061 && METHOD_PRIVATE (method))))
10062 {
10063 parse_error_context
10064 (method_wfl,
10065 "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
10066 (METHOD_PUBLIC (method) ? "public" :
10067 (METHOD_PRIVATE (method) ? "private" : "protected")),
10068 IDENTIFIER_POINTER (DECL_NAME
10069 (TYPE_NAME (DECL_CONTEXT (found)))));
10070 continue;
10071 }
10072
10073 /* Overriding methods must have compatible `throws' clauses on checked
10074 exceptions, if any */
10075 check_throws_clauses (method, method_wfl, found);
10076
10077 /* Inheriting multiple methods with the same signature. FIXME */
10078 }
10079
10080 if (!TYPE_NVIRTUALS (class))
10081 TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
10082
10083 /* Search for inherited abstract method not yet implemented in this
10084 class. */
10085 java_check_abstract_method_definitions (class_decl);
10086
10087 if (!saw_constructor)
10088 abort ();
10089 }
10090
10091 /* Return a nonzero value if the `throws' clause of METHOD (if any)
10092 is incompatible with the `throws' clause of FOUND (if any). */
10093
10094 static void
check_throws_clauses(method,method_wfl,found)10095 check_throws_clauses (method, method_wfl, found)
10096 tree method, method_wfl, found;
10097 {
10098 tree mthrows, fthrows;
10099
10100 /* Can't check these things with class loaded from bytecode. FIXME */
10101 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
10102 return;
10103
10104 for (mthrows = DECL_FUNCTION_THROWS (method);
10105 mthrows; mthrows = TREE_CHAIN (mthrows))
10106 {
10107 /* We don't verify unchecked expressions */
10108 if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
10109 continue;
10110 /* Checked expression must be compatible */
10111 for (fthrows = DECL_FUNCTION_THROWS (found);
10112 fthrows; fthrows = TREE_CHAIN (fthrows))
10113 if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
10114 break;
10115 if (!fthrows)
10116 {
10117 parse_error_context
10118 (method_wfl, "Invalid checked exception class `%s' in `throws' clause. The exception must be a subclass of an exception thrown by `%s' from class `%s'",
10119 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
10120 lang_printable_name (found, 0),
10121 IDENTIFIER_POINTER
10122 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
10123 }
10124 }
10125 }
10126
10127 /* Check abstract method of interface INTERFACE */
10128
10129 static void
java_check_abstract_methods(interface_decl)10130 java_check_abstract_methods (interface_decl)
10131 tree interface_decl;
10132 {
10133 int i, n;
10134 tree method, basetype_vec, found;
10135 tree interface = TREE_TYPE (interface_decl);
10136
10137 for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
10138 {
10139 /* 2- Check for double definition inside the defining interface */
10140 if (check_method_redefinition (interface, method))
10141 continue;
10142
10143 /* 3- Overriding is OK as far as we preserve the return type and
10144 the thrown exceptions (FIXME) */
10145 found = lookup_java_interface_method2 (interface, method);
10146 if (found)
10147 {
10148 char *t;
10149 t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
10150 parse_error_context
10151 (DECL_FUNCTION_WFL (found),
10152 "Method `%s' was defined with return type `%s' in class `%s'",
10153 lang_printable_name (found, 0), t,
10154 IDENTIFIER_POINTER
10155 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
10156 free (t);
10157 continue;
10158 }
10159 }
10160
10161 /* 4- Inherited methods can't differ by their returned types */
10162 if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
10163 return;
10164 n = TREE_VEC_LENGTH (basetype_vec);
10165 for (i = 0; i < n; i++)
10166 {
10167 tree sub_interface_method, sub_interface;
10168 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
10169 if (!vec_elt)
10170 continue;
10171 sub_interface = BINFO_TYPE (vec_elt);
10172 for (sub_interface_method = TYPE_METHODS (sub_interface);
10173 sub_interface_method;
10174 sub_interface_method = TREE_CHAIN (sub_interface_method))
10175 {
10176 found = lookup_java_interface_method2 (interface,
10177 sub_interface_method);
10178 if (found && (found != sub_interface_method))
10179 {
10180 parse_error_context
10181 (lookup_cl (sub_interface_method),
10182 "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
10183 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
10184 lang_printable_name (found, 0),
10185 IDENTIFIER_POINTER
10186 (DECL_NAME (TYPE_NAME
10187 (DECL_CONTEXT (sub_interface_method)))),
10188 IDENTIFIER_POINTER
10189 (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
10190 }
10191 }
10192 }
10193 }
10194
10195 /* Lookup methods in interfaces using their name and partial
10196 signature. Return a matching method only if their types differ. */
10197
10198 static tree
lookup_java_interface_method2(class,method_decl)10199 lookup_java_interface_method2 (class, method_decl)
10200 tree class, method_decl;
10201 {
10202 int i, n;
10203 tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
10204
10205 if (!basetype_vec)
10206 return NULL_TREE;
10207
10208 n = TREE_VEC_LENGTH (basetype_vec);
10209 for (i = 0; i < n; i++)
10210 {
10211 tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
10212 if ((BINFO_TYPE (vec_elt) != object_type_node)
10213 && (to_return =
10214 lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
10215 return to_return;
10216 }
10217 for (i = 0; i < n; i++)
10218 {
10219 to_return = lookup_java_interface_method2
10220 (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
10221 if (to_return)
10222 return to_return;
10223 }
10224
10225 return NULL_TREE;
10226 }
10227
10228 /* Lookup method using their name and partial signature. Return a
10229 matching method only if their types differ. */
10230
10231 static tree
lookup_java_method2(clas,method_decl,do_interface)10232 lookup_java_method2 (clas, method_decl, do_interface)
10233 tree clas, method_decl;
10234 int do_interface;
10235 {
10236 tree method, method_signature, method_name, method_type, name;
10237
10238 method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
10239 name = DECL_NAME (method_decl);
10240 method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
10241 EXPR_WFL_NODE (name) : name);
10242 method_type = TREE_TYPE (TREE_TYPE (method_decl));
10243
10244 while (clas != NULL_TREE)
10245 {
10246 for (method = TYPE_METHODS (clas);
10247 method != NULL_TREE; method = TREE_CHAIN (method))
10248 {
10249 tree method_sig = build_java_argument_signature (TREE_TYPE (method));
10250 tree name = DECL_NAME (method);
10251 if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
10252 EXPR_WFL_NODE (name) : name) == method_name
10253 && method_sig == method_signature
10254 && TREE_TYPE (TREE_TYPE (method)) != method_type)
10255 return method;
10256 }
10257 clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
10258 }
10259 return NULL_TREE;
10260 }
10261
10262 /* Return the line that matches DECL line number, and try its best to
10263 position the column number. Used during error reports. */
10264
10265 static GTY(()) tree cl_v;
10266 static tree
lookup_cl(decl)10267 lookup_cl (decl)
10268 tree decl;
10269 {
10270 char *line, *found;
10271
10272 if (!decl)
10273 return NULL_TREE;
10274
10275 if (cl_v == NULL_TREE)
10276 {
10277 cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
10278 }
10279
10280 EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
10281 EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE_FIRST (decl), -1);
10282
10283 line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
10284 EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
10285
10286 found = strstr ((const char *)line,
10287 (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
10288 if (found)
10289 EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
10290
10291 return cl_v;
10292 }
10293
10294 /* Look for a simple name in the single-type import list */
10295
10296 static tree
find_name_in_single_imports(name)10297 find_name_in_single_imports (name)
10298 tree name;
10299 {
10300 tree node;
10301
10302 for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
10303 if (TREE_VALUE (node) == name)
10304 return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
10305
10306 return NULL_TREE;
10307 }
10308
10309 /* Process all single-type import. */
10310
10311 static int
process_imports()10312 process_imports ()
10313 {
10314 tree import;
10315 int error_found;
10316
10317 for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
10318 {
10319 tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
10320 char *original_name;
10321
10322 obstack_grow0 (&temporary_obstack,
10323 IDENTIFIER_POINTER (to_be_found),
10324 IDENTIFIER_LENGTH (to_be_found));
10325 original_name = obstack_finish (&temporary_obstack);
10326
10327 /* Don't load twice something already defined. */
10328 if (IDENTIFIER_CLASS_VALUE (to_be_found))
10329 continue;
10330
10331 while (1)
10332 {
10333 tree left;
10334
10335 QUALIFIED_P (to_be_found) = 1;
10336 load_class (to_be_found, 0);
10337 error_found =
10338 check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
10339
10340 /* We found it, we can bail out */
10341 if (IDENTIFIER_CLASS_VALUE (to_be_found))
10342 break;
10343
10344 /* We haven't found it. Maybe we're trying to access an
10345 inner class. The only way for us to know is to try again
10346 after having dropped a qualifier. If we can't break it further,
10347 we have an error. */
10348 if (breakdown_qualified (&left, NULL, to_be_found))
10349 break;
10350
10351 to_be_found = left;
10352 }
10353 if (!IDENTIFIER_CLASS_VALUE (to_be_found))
10354 {
10355 parse_error_context (TREE_PURPOSE (import),
10356 "Class or interface `%s' not found in import",
10357 original_name);
10358 error_found = 1;
10359 }
10360
10361 obstack_free (&temporary_obstack, original_name);
10362 if (error_found)
10363 return 1;
10364 }
10365 return 0;
10366 }
10367
10368 /* Possibly find and mark a class imported by a single-type import
10369 statement. */
10370
10371 static void
find_in_imports(enclosing_type,class_type)10372 find_in_imports (enclosing_type, class_type)
10373 tree enclosing_type;
10374 tree class_type;
10375 {
10376 tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
10377 ctxp->import_list);
10378 while (import)
10379 {
10380 if (TREE_VALUE (import) == TYPE_NAME (class_type))
10381 {
10382 TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
10383 QUALIFIED_P (TYPE_NAME (class_type)) = 1;
10384 return;
10385 }
10386 import = TREE_CHAIN (import);
10387 }
10388 }
10389
10390 static int
note_possible_classname(name,len)10391 note_possible_classname (name, len)
10392 const char *name;
10393 int len;
10394 {
10395 tree node;
10396 if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
10397 len = len - 5;
10398 else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
10399 len = len - 6;
10400 else
10401 return 0;
10402 node = ident_subst (name, len, "", '/', '.', "");
10403 IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
10404 QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
10405 return 1;
10406 }
10407
10408 /* Read a import directory, gathering potential match for further type
10409 references. Indifferently reads a filesystem or a ZIP archive
10410 directory. */
10411
10412 static void
read_import_dir(wfl)10413 read_import_dir (wfl)
10414 tree wfl;
10415 {
10416 tree package_id = EXPR_WFL_NODE (wfl);
10417 const char *package_name = IDENTIFIER_POINTER (package_id);
10418 int package_length = IDENTIFIER_LENGTH (package_id);
10419 DIR *dirp = NULL;
10420 JCF *saved_jcf = current_jcf;
10421
10422 int found = 0;
10423 int k;
10424 void *entry;
10425 struct buffer filename[1];
10426
10427 if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
10428 return;
10429 IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
10430
10431 BUFFER_INIT (filename);
10432 buffer_grow (filename, package_length + 100);
10433
10434 for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
10435 {
10436 const char *entry_name = jcf_path_name (entry);
10437 int entry_length = strlen (entry_name);
10438 if (jcf_path_is_zipfile (entry))
10439 {
10440 ZipFile *zipf;
10441 buffer_grow (filename, entry_length);
10442 memcpy (filename->data, entry_name, entry_length - 1);
10443 filename->data[entry_length-1] = '\0';
10444 zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
10445 if (zipf == NULL)
10446 error ("malformed .zip archive in CLASSPATH: %s", entry_name);
10447 else
10448 {
10449 ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
10450 BUFFER_RESET (filename);
10451 for (k = 0; k < package_length; k++)
10452 {
10453 char ch = package_name[k];
10454 *filename->ptr++ = ch == '.' ? '/' : ch;
10455 }
10456 *filename->ptr++ = '/';
10457
10458 for (k = 0; k < zipf->count; k++, zipd = ZIPDIR_NEXT (zipd))
10459 {
10460 const char *current_entry = ZIPDIR_FILENAME (zipd);
10461 int current_entry_len = zipd->filename_length;
10462
10463 if (current_entry_len >= BUFFER_LENGTH (filename)
10464 && strncmp (filename->data, current_entry,
10465 BUFFER_LENGTH (filename)) != 0)
10466 continue;
10467 found |= note_possible_classname (current_entry,
10468 current_entry_len);
10469 }
10470 }
10471 }
10472 else
10473 {
10474 BUFFER_RESET (filename);
10475 buffer_grow (filename, entry_length + package_length + 4);
10476 strcpy (filename->data, entry_name);
10477 filename->ptr = filename->data + entry_length;
10478 for (k = 0; k < package_length; k++)
10479 {
10480 char ch = package_name[k];
10481 *filename->ptr++ = ch == '.' ? '/' : ch;
10482 }
10483 *filename->ptr = '\0';
10484
10485 dirp = opendir (filename->data);
10486 if (dirp == NULL)
10487 continue;
10488 *filename->ptr++ = '/';
10489 for (;;)
10490 {
10491 int len;
10492 const char *d_name;
10493 struct dirent *direntp = readdir (dirp);
10494 if (!direntp)
10495 break;
10496 d_name = direntp->d_name;
10497 len = strlen (direntp->d_name);
10498 buffer_grow (filename, len+1);
10499 strcpy (filename->ptr, d_name);
10500 found |= note_possible_classname (filename->data + entry_length,
10501 package_length+len+1);
10502 }
10503 if (dirp)
10504 closedir (dirp);
10505 }
10506 }
10507
10508 free (filename->data);
10509
10510 /* Here we should have a unified way of retrieving an entry, to be
10511 indexed. */
10512 if (!found)
10513 {
10514 static int first = 1;
10515 if (first)
10516 {
10517 error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
10518 java_error_count++;
10519 first = 0;
10520 }
10521 else
10522 parse_error_context (wfl, "Package `%s' not found in import",
10523 package_name);
10524 current_jcf = saved_jcf;
10525 return;
10526 }
10527 current_jcf = saved_jcf;
10528 }
10529
10530 /* Possibly find a type in the import on demands specified
10531 types. Returns 1 if an error occurred, 0 otherwise. Run through the
10532 entire list, to detected potential double definitions. */
10533
10534 static int
find_in_imports_on_demand(enclosing_type,class_type)10535 find_in_imports_on_demand (enclosing_type, class_type)
10536 tree enclosing_type;
10537 tree class_type;
10538 {
10539 tree class_type_name = TYPE_NAME (class_type);
10540 tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
10541 ctxp->import_demand_list);
10542 tree cl = NULL_TREE;
10543 int seen_once = -1; /* -1 when not set, 1 if seen once, >1 otherwise. */
10544 int to_return = -1; /* -1 when not set, 0 or 1 otherwise */
10545 tree node;
10546
10547 for (; import; import = TREE_CHAIN (import))
10548 {
10549 int saved_lineno = lineno;
10550 int access_check;
10551 const char *id_name;
10552 tree decl, type_name_copy;
10553
10554 obstack_grow (&temporary_obstack,
10555 IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
10556 IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
10557 obstack_1grow (&temporary_obstack, '.');
10558 obstack_grow0 (&temporary_obstack,
10559 IDENTIFIER_POINTER (class_type_name),
10560 IDENTIFIER_LENGTH (class_type_name));
10561 id_name = obstack_finish (&temporary_obstack);
10562
10563 if (! (node = maybe_get_identifier (id_name)))
10564 continue;
10565
10566 /* Setup lineno so that it refers to the line of the import (in
10567 case we parse a class file and encounter errors */
10568 lineno = EXPR_WFL_LINENO (TREE_PURPOSE (import));
10569
10570 type_name_copy = TYPE_NAME (class_type);
10571 TYPE_NAME (class_type) = node;
10572 QUALIFIED_P (node) = 1;
10573 decl = IDENTIFIER_CLASS_VALUE (node);
10574 access_check = -1;
10575 /* If there is no DECL set for the class or if the class isn't
10576 loaded and not seen in source yet, then load */
10577 if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
10578 && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
10579 {
10580 load_class (node, 0);
10581 decl = IDENTIFIER_CLASS_VALUE (node);
10582 }
10583 if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
10584 access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
10585 false);
10586 else
10587 /* 6.6.1: Inner classes are subject to member access rules. */
10588 access_check = 0;
10589
10590 lineno = saved_lineno;
10591
10592 /* If the loaded class is not accessible or couldn't be loaded,
10593 we restore the original TYPE_NAME and process the next
10594 import. */
10595 if (access_check || !decl)
10596 {
10597 TYPE_NAME (class_type) = type_name_copy;
10598 continue;
10599 }
10600
10601 /* If the loaded class is accessible, we keep a tab on it to
10602 detect and report multiple inclusions. */
10603 if (IS_A_CLASSFILE_NAME (node))
10604 {
10605 if (seen_once < 0)
10606 {
10607 cl = TREE_PURPOSE (import);
10608 seen_once = 1;
10609 }
10610 else if (seen_once >= 0)
10611 {
10612 tree location = (cl ? cl : TREE_PURPOSE (import));
10613 tree package = (cl ? EXPR_WFL_NODE (cl) :
10614 EXPR_WFL_NODE (TREE_PURPOSE (import)));
10615 seen_once++;
10616 parse_error_context
10617 (location,
10618 "Type `%s' also potentially defined in package `%s'",
10619 IDENTIFIER_POINTER (TYPE_NAME (class_type)),
10620 IDENTIFIER_POINTER (package));
10621 }
10622 }
10623 to_return = access_check;
10624 }
10625
10626 if (seen_once == 1)
10627 return to_return;
10628 else
10629 return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
10630 }
10631
10632 /* Add package NAME to the list of packages encountered so far. To
10633 speed up class lookup in do_resolve_class, we make sure a
10634 particular package is added only once. */
10635
10636 static void
register_package(name)10637 register_package (name)
10638 tree name;
10639 {
10640 static htab_t pht;
10641 PTR *e;
10642
10643 if (pht == NULL)
10644 pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
10645
10646 e = htab_find_slot (pht, name, INSERT);
10647 if (*e == NULL)
10648 {
10649 package_list = chainon (package_list, build_tree_list (name, NULL));
10650 *e = name;
10651 }
10652 }
10653
10654 static tree
resolve_package(pkg,next,type_name)10655 resolve_package (pkg, next, type_name)
10656 tree pkg, *next, *type_name;
10657 {
10658 tree current;
10659 tree decl = NULL_TREE;
10660 *type_name = NULL_TREE;
10661
10662 /* The trick is to determine when the package name stops and were
10663 the name of something contained in the package starts. Then we
10664 return a fully qualified name of what we want to get. */
10665
10666 *next = EXPR_WFL_QUALIFICATION (pkg);
10667
10668 /* Try to progressively construct a type name */
10669 if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
10670 for (current = EXPR_WFL_QUALIFICATION (pkg);
10671 current; current = TREE_CHAIN (current))
10672 {
10673 /* If we don't have what we're expecting, exit now. TYPE_NAME
10674 will be null and the error caught later. */
10675 if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
10676 break;
10677 *type_name =
10678 merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
10679 if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
10680 {
10681 /* resolve_package should be used in a loop, hence we
10682 point at this one to naturally process the next one at
10683 the next iteration. */
10684 *next = current;
10685 break;
10686 }
10687 }
10688 return decl;
10689 }
10690
10691
10692 /* Check accessibility of inner classes according to member access rules.
10693 DECL is the inner class, ENCLOSING_DECL is the class from which the
10694 access is being attempted. */
10695
10696 static void
check_inner_class_access(decl,enclosing_decl,cl)10697 check_inner_class_access (decl, enclosing_decl, cl)
10698 tree decl, enclosing_decl, cl;
10699 {
10700 const char *access;
10701 tree enclosing_decl_type;
10702
10703 /* We don't issue an error message when CL is null. CL can be null
10704 as a result of processing a JDEP crafted by source_start_java_method
10705 for the purpose of patching its parm decl. But the error would
10706 have been already trapped when fixing the method's signature.
10707 DECL can also be NULL in case of earlier errors. */
10708 if (!decl || !cl)
10709 return;
10710
10711 enclosing_decl_type = TREE_TYPE (enclosing_decl);
10712
10713 if (CLASS_PRIVATE (decl))
10714 {
10715 /* Access is permitted only within the body of the top-level
10716 class in which DECL is declared. */
10717 tree top_level = decl;
10718 while (DECL_CONTEXT (top_level))
10719 top_level = DECL_CONTEXT (top_level);
10720 while (DECL_CONTEXT (enclosing_decl))
10721 enclosing_decl = DECL_CONTEXT (enclosing_decl);
10722 if (top_level == enclosing_decl)
10723 return;
10724 access = "private";
10725 }
10726 else if (CLASS_PROTECTED (decl))
10727 {
10728 tree decl_context;
10729 /* Access is permitted from within the same package... */
10730 if (in_same_package (decl, enclosing_decl))
10731 return;
10732
10733 /* ... or from within the body of a subtype of the context in which
10734 DECL is declared. */
10735 decl_context = DECL_CONTEXT (decl);
10736 while (enclosing_decl)
10737 {
10738 if (CLASS_INTERFACE (decl))
10739 {
10740 if (interface_of_p (TREE_TYPE (decl_context),
10741 enclosing_decl_type))
10742 return;
10743 }
10744 else
10745 {
10746 /* Eww. The order of the arguments is different!! */
10747 if (inherits_from_p (enclosing_decl_type,
10748 TREE_TYPE (decl_context)))
10749 return;
10750 }
10751 enclosing_decl = DECL_CONTEXT (enclosing_decl);
10752 }
10753 access = "protected";
10754 }
10755 else if (! CLASS_PUBLIC (decl))
10756 {
10757 /* Access is permitted only from within the same package as DECL. */
10758 if (in_same_package (decl, enclosing_decl))
10759 return;
10760 access = "non-public";
10761 }
10762 else
10763 /* Class is public. */
10764 return;
10765
10766 parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
10767 (CLASS_INTERFACE (decl) ? "interface" : "class"),
10768 lang_printable_name (decl, 0), access);
10769 }
10770
10771 /* Accessibility check for top-level classes. If CLASS_NAME is in a
10772 foreign package, it must be PUBLIC. Return 0 if no access
10773 violations were found, 1 otherwise. If VERBOSE is true and an error
10774 was found, it is reported and accounted for. */
10775
10776 static int
check_pkg_class_access(class_name,cl,verbose)10777 check_pkg_class_access (class_name, cl, verbose)
10778 tree class_name;
10779 tree cl;
10780 bool verbose;
10781 {
10782 tree type;
10783
10784 if (!IDENTIFIER_CLASS_VALUE (class_name))
10785 return 0;
10786
10787 if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
10788 return 0;
10789
10790 if (!CLASS_PUBLIC (TYPE_NAME (type)))
10791 {
10792 /* Access to a private class within the same package is
10793 allowed. */
10794 tree l, r;
10795 breakdown_qualified (&l, &r, class_name);
10796 if (!QUALIFIED_P (class_name) && !ctxp->package)
10797 /* Both in the empty package. */
10798 return 0;
10799 if (l == ctxp->package)
10800 /* Both in the same package. */
10801 return 0;
10802
10803 if (verbose)
10804 parse_error_context
10805 (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
10806 (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
10807 IDENTIFIER_POINTER (class_name));
10808 return 1;
10809 }
10810 return 0;
10811 }
10812
10813 /* Local variable declaration. */
10814
10815 static void
declare_local_variables(modifier,type,vlist)10816 declare_local_variables (modifier, type, vlist)
10817 int modifier;
10818 tree type;
10819 tree vlist;
10820 {
10821 tree decl, current, saved_type;
10822 tree type_wfl = NULL_TREE;
10823 int must_chain = 0;
10824 int final_p = 0;
10825
10826 /* Push a new block if statements were seen between the last time we
10827 pushed a block and now. Keep a count of blocks to close */
10828 if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
10829 {
10830 tree b = enter_block ();
10831 BLOCK_IS_IMPLICIT (b) = 1;
10832 }
10833
10834 if (modifier)
10835 {
10836 size_t i;
10837 for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
10838 if (1 << i & modifier)
10839 break;
10840 if (modifier == ACC_FINAL)
10841 final_p = 1;
10842 else
10843 {
10844 parse_error_context
10845 (ctxp->modifier_ctx [i],
10846 "Only `final' is allowed as a local variables modifier");
10847 return;
10848 }
10849 }
10850
10851 /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
10852 hold the TYPE value if a new incomplete has to be created (as
10853 opposed to being found already existing and reused). */
10854 SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
10855
10856 /* If TYPE is fully resolved and we don't have a reference, make one */
10857 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
10858
10859 /* Go through all the declared variables */
10860 for (current = vlist, saved_type = type; current;
10861 current = TREE_CHAIN (current), type = saved_type)
10862 {
10863 tree other, real_type;
10864 tree wfl = TREE_PURPOSE (current);
10865 tree name = EXPR_WFL_NODE (wfl);
10866 tree init = TREE_VALUE (current);
10867
10868 /* Process NAME, as it may specify extra dimension(s) for it */
10869 type = build_array_from_name (type, type_wfl, name, &name);
10870
10871 /* Variable redefinition check */
10872 if ((other = lookup_name_in_blocks (name)))
10873 {
10874 variable_redefinition_error (wfl, name, TREE_TYPE (other),
10875 DECL_SOURCE_LINE (other));
10876 continue;
10877 }
10878
10879 /* Type adjustment. We may have just readjusted TYPE because
10880 the variable specified more dimensions. Make sure we have
10881 a reference if we can and don't have one already. */
10882 PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
10883
10884 real_type = GET_REAL_TYPE (type);
10885 /* Never layout this decl. This will be done when its scope
10886 will be entered */
10887 decl = build_decl (VAR_DECL, name, real_type);
10888 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
10889 DECL_FINAL (decl) = final_p;
10890 BLOCK_CHAIN_DECL (decl);
10891
10892 /* If doing xreferencing, replace the line number with the WFL
10893 compound value */
10894 if (flag_emit_xref)
10895 DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
10896
10897 /* Don't try to use an INIT statement when an error was found */
10898 if (init && java_error_count)
10899 init = NULL_TREE;
10900
10901 /* Add the initialization function to the current function's code */
10902 if (init)
10903 {
10904 /* Name might have been readjusted */
10905 EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
10906 MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
10907 java_method_add_stmt (current_function_decl,
10908 build_debugable_stmt (EXPR_WFL_LINECOL (init),
10909 init));
10910 }
10911
10912 /* Setup dependency the type of the decl */
10913 if (must_chain)
10914 {
10915 jdep *dep;
10916 register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
10917 dep = CLASSD_LAST (ctxp->classd_list);
10918 JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
10919 }
10920 }
10921 SOURCE_FRONTEND_DEBUG (("Defined locals"));
10922 }
10923
10924 /* Called during parsing. Build decls from argument list. */
10925
10926 static void
source_start_java_method(fndecl)10927 source_start_java_method (fndecl)
10928 tree fndecl;
10929 {
10930 tree tem;
10931 tree parm_decl;
10932 int i;
10933
10934 if (!fndecl)
10935 return;
10936
10937 current_function_decl = fndecl;
10938
10939 /* New scope for the function */
10940 enter_block ();
10941 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
10942 tem != end_params_node; tem = TREE_CHAIN (tem), i++)
10943 {
10944 tree type = TREE_VALUE (tem);
10945 tree name = TREE_PURPOSE (tem);
10946
10947 /* If type is incomplete. Create an incomplete decl and ask for
10948 the decl to be patched later */
10949 if (INCOMPLETE_TYPE_P (type))
10950 {
10951 jdep *jdep;
10952 tree real_type = GET_REAL_TYPE (type);
10953 parm_decl = build_decl (PARM_DECL, name, real_type);
10954 type = obtain_incomplete_type (type);
10955 register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
10956 jdep = CLASSD_LAST (ctxp->classd_list);
10957 JDEP_MISC (jdep) = name;
10958 JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
10959 }
10960 else
10961 parm_decl = build_decl (PARM_DECL, name, type);
10962
10963 /* Remember if a local variable was declared final (via its
10964 TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
10965 if (ARG_FINAL_P (tem))
10966 {
10967 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
10968 DECL_FINAL (parm_decl) = 1;
10969 }
10970
10971 BLOCK_CHAIN_DECL (parm_decl);
10972 }
10973 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
10974 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
10975 nreverse (tem);
10976 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
10977 DECL_MAX_LOCALS (current_function_decl) = i;
10978 }
10979
10980 /* Called during parsing. Creates an artificial method declaration. */
10981
10982 static tree
create_artificial_method(class,flags,type,name,args)10983 create_artificial_method (class, flags, type, name, args)
10984 tree class;
10985 int flags;
10986 tree type, name, args;
10987 {
10988 tree mdecl;
10989
10990 java_parser_context_save_global ();
10991 lineno = 0;
10992 mdecl = make_node (FUNCTION_TYPE);
10993 TREE_TYPE (mdecl) = type;
10994 TYPE_ARG_TYPES (mdecl) = args;
10995 mdecl = add_method (class, flags, name, build_java_signature (mdecl));
10996 java_parser_context_restore_global ();
10997 DECL_ARTIFICIAL (mdecl) = 1;
10998 return mdecl;
10999 }
11000
11001 /* Starts the body if an artificial method. */
11002
11003 static void
start_artificial_method_body(mdecl)11004 start_artificial_method_body (mdecl)
11005 tree mdecl;
11006 {
11007 DECL_SOURCE_LINE (mdecl) = 1;
11008 DECL_SOURCE_LINE_MERGE (mdecl, 1);
11009 source_start_java_method (mdecl);
11010 enter_block ();
11011 }
11012
11013 static void
end_artificial_method_body(mdecl)11014 end_artificial_method_body (mdecl)
11015 tree mdecl;
11016 {
11017 /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
11018 It has to be evaluated first. (if mdecl is current_function_decl,
11019 we have an undefined behavior if no temporary variable is used.) */
11020 tree b = exit_block ();
11021 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
11022 exit_block ();
11023 }
11024
11025 /* Dump a tree of some kind. This is a convenience wrapper for the
11026 dump_* functions in tree-dump.c. */
11027 static void
dump_java_tree(phase,t)11028 dump_java_tree (phase, t)
11029 enum tree_dump_index phase;
11030 tree t;
11031 {
11032 FILE *stream;
11033 int flags;
11034
11035 stream = dump_begin (phase, &flags);
11036 flags |= TDF_SLIM;
11037 if (stream)
11038 {
11039 dump_node (t, flags, stream);
11040 dump_end (phase, stream);
11041 }
11042 }
11043
11044 /* Terminate a function and expand its body. */
11045
11046 static void
source_end_java_method()11047 source_end_java_method ()
11048 {
11049 tree fndecl = current_function_decl;
11050
11051 if (!fndecl)
11052 return;
11053
11054 java_parser_context_save_global ();
11055 lineno = ctxp->last_ccb_indent1;
11056
11057 /* Turn function bodies with only a NOP expr null, so they don't get
11058 generated at all and we won't get warnings when using the -W
11059 -Wall flags. */
11060 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
11061 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
11062
11063 /* We've generated all the trees for this function, and it has been
11064 patched. Dump it to a file if the user requested it. */
11065 dump_java_tree (TDI_original, fndecl);
11066
11067 java_optimize_inline (fndecl);
11068
11069 /* Generate function's code */
11070 if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
11071 && ! flag_emit_class_files
11072 && ! flag_emit_xref)
11073 expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
11074
11075 /* pop out of its parameters */
11076 pushdecl_force_head (DECL_ARGUMENTS (fndecl));
11077 poplevel (1, 0, 1);
11078 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11079
11080 /* Generate rtl for function exit. */
11081 if (! flag_emit_class_files && ! flag_emit_xref)
11082 {
11083 lineno = DECL_SOURCE_LINE_LAST (fndecl);
11084 expand_function_end (input_filename, lineno, 0);
11085
11086 DECL_SOURCE_LINE (fndecl) = DECL_SOURCE_LINE_FIRST (fndecl);
11087
11088 /* Run the optimizers and output assembler code for this function. */
11089 rest_of_compilation (fndecl);
11090 }
11091
11092 current_function_decl = NULL_TREE;
11093 java_parser_context_restore_global ();
11094 }
11095
11096 /* Record EXPR in the current function block. Complements compound
11097 expression second operand if necessary. */
11098
11099 tree
java_method_add_stmt(fndecl,expr)11100 java_method_add_stmt (fndecl, expr)
11101 tree fndecl, expr;
11102 {
11103 if (!GET_CURRENT_BLOCK (fndecl))
11104 return NULL_TREE;
11105 return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
11106 }
11107
11108 static tree
add_stmt_to_block(b,type,stmt)11109 add_stmt_to_block (b, type, stmt)
11110 tree b, type, stmt;
11111 {
11112 tree body = BLOCK_EXPR_BODY (b), c;
11113
11114 if (java_error_count)
11115 return body;
11116
11117 if ((c = add_stmt_to_compound (body, type, stmt)) == body)
11118 return body;
11119
11120 BLOCK_EXPR_BODY (b) = c;
11121 TREE_SIDE_EFFECTS (c) = 1;
11122 return c;
11123 }
11124
11125 /* Add STMT to EXISTING if possible, otherwise create a new
11126 COMPOUND_EXPR and add STMT to it. */
11127
11128 static tree
add_stmt_to_compound(existing,type,stmt)11129 add_stmt_to_compound (existing, type, stmt)
11130 tree existing, type, stmt;
11131 {
11132 /* Keep track of this for inlining. */
11133 if (current_function_decl)
11134 ++DECL_NUM_STMTS (current_function_decl);
11135
11136 if (existing)
11137 return build (COMPOUND_EXPR, type, existing, stmt);
11138 else
11139 return stmt;
11140 }
11141
java_layout_seen_class_methods()11142 void java_layout_seen_class_methods ()
11143 {
11144 tree previous_list = all_class_list;
11145 tree end = NULL_TREE;
11146 tree current;
11147
11148 while (1)
11149 {
11150 for (current = previous_list;
11151 current != end; current = TREE_CHAIN (current))
11152 layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
11153
11154 if (previous_list != all_class_list)
11155 {
11156 end = previous_list;
11157 previous_list = all_class_list;
11158 }
11159 else
11160 break;
11161 }
11162 }
11163
11164 static GTY(()) tree stop_reordering;
11165 void
java_reorder_fields()11166 java_reorder_fields ()
11167 {
11168 tree current;
11169
11170 for (current = gclass_list; current; current = TREE_CHAIN (current))
11171 {
11172 current_class = TREE_TYPE (TREE_VALUE (current));
11173
11174 if (current_class == stop_reordering)
11175 break;
11176
11177 /* Reverse the fields, but leave the dummy field in front.
11178 Fields are already ordered for Object and Class */
11179 if (TYPE_FIELDS (current_class) && current_class != object_type_node
11180 && current_class != class_type_node)
11181 {
11182 /* If the dummy field is there, reverse the right fields and
11183 just layout the type for proper fields offset */
11184 if (!DECL_NAME (TYPE_FIELDS (current_class)))
11185 {
11186 tree fields = TYPE_FIELDS (current_class);
11187 TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
11188 TYPE_SIZE (current_class) = NULL_TREE;
11189 }
11190 /* We don't have a dummy field, we need to layout the class,
11191 after having reversed the fields */
11192 else
11193 {
11194 TYPE_FIELDS (current_class) =
11195 nreverse (TYPE_FIELDS (current_class));
11196 TYPE_SIZE (current_class) = NULL_TREE;
11197 }
11198 }
11199 }
11200 /* There are cases were gclass_list will be empty. */
11201 if (gclass_list)
11202 stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
11203 }
11204
11205 /* Layout the methods of all classes loaded in one way or another.
11206 Check methods of source parsed classes. Then reorder the
11207 fields and layout the classes or the type of all source parsed
11208 classes */
11209
11210 void
java_layout_classes()11211 java_layout_classes ()
11212 {
11213 tree current;
11214 int save_error_count = java_error_count;
11215
11216 /* Layout the methods of all classes seen so far */
11217 java_layout_seen_class_methods ();
11218 java_parse_abort_on_error ();
11219 all_class_list = NULL_TREE;
11220
11221 /* Then check the methods of all parsed classes */
11222 for (current = gclass_list; current; current = TREE_CHAIN (current))
11223 if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
11224 java_check_methods (TREE_VALUE (current));
11225 java_parse_abort_on_error ();
11226
11227 for (current = gclass_list; current; current = TREE_CHAIN (current))
11228 {
11229 current_class = TREE_TYPE (TREE_VALUE (current));
11230 layout_class (current_class);
11231
11232 /* Error reported by the caller */
11233 if (java_error_count)
11234 return;
11235 }
11236
11237 /* We might have reloaded classes durign the process of laying out
11238 classes for code generation. We must layout the methods of those
11239 late additions, as constructor checks might use them */
11240 java_layout_seen_class_methods ();
11241 java_parse_abort_on_error ();
11242 }
11243
11244 /* Expand methods in the current set of classes rememebered for
11245 generation. */
11246
11247 static void
java_complete_expand_classes()11248 java_complete_expand_classes ()
11249 {
11250 tree current;
11251
11252 do_not_fold = flag_emit_xref;
11253
11254 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
11255 if (!INNER_CLASS_DECL_P (current))
11256 java_complete_expand_class (current);
11257 }
11258
11259 /* Expand the methods found in OUTER, starting first by OUTER's inner
11260 classes, if any. */
11261
11262 static void
java_complete_expand_class(outer)11263 java_complete_expand_class (outer)
11264 tree outer;
11265 {
11266 tree inner_list;
11267
11268 set_nested_class_simple_name_value (outer, 1); /* Set */
11269
11270 /* We need to go after all inner classes and start expanding them,
11271 starting with most nested ones. We have to do that because nested
11272 classes might add functions to outer classes */
11273
11274 for (inner_list = DECL_INNER_CLASS_LIST (outer);
11275 inner_list; inner_list = TREE_CHAIN (inner_list))
11276 java_complete_expand_class (TREE_PURPOSE (inner_list));
11277
11278 java_complete_expand_methods (outer);
11279 set_nested_class_simple_name_value (outer, 0); /* Reset */
11280 }
11281
11282 /* Expand methods registered in CLASS_DECL. The general idea is that
11283 we expand regular methods first. This allows us get an estimate on
11284 how outer context local alias fields are really used so we can add
11285 to the constructor just enough code to initialize them properly (it
11286 also lets us generate finit$ correctly.) Then we expand the
11287 constructors and then <clinit>. */
11288
11289 static void
java_complete_expand_methods(class_decl)11290 java_complete_expand_methods (class_decl)
11291 tree class_decl;
11292 {
11293 tree clinit, decl, first_decl;
11294
11295 current_class = TREE_TYPE (class_decl);
11296
11297 /* Initialize a new constant pool */
11298 init_outgoing_cpool ();
11299
11300 /* Pre-expand <clinit> to figure whether we really need it or
11301 not. If we do need it, we pre-expand the static fields so they're
11302 ready to be used somewhere else. <clinit> will be fully expanded
11303 after we processed the constructors. */
11304 first_decl = TYPE_METHODS (current_class);
11305 clinit = maybe_generate_pre_expand_clinit (current_class);
11306
11307 /* Then generate finit$ (if we need to) because constructors will
11308 try to use it.*/
11309 if (TYPE_FINIT_STMT_LIST (current_class))
11310 java_complete_expand_method (generate_finit (current_class));
11311
11312 /* Then generate instinit$ (if we need to) because constructors will
11313 try to use it. */
11314 if (TYPE_II_STMT_LIST (current_class))
11315 java_complete_expand_method (generate_instinit (current_class));
11316
11317 /* Now do the constructors */
11318 for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
11319 {
11320 int no_body;
11321
11322 if (!DECL_CONSTRUCTOR_P (decl))
11323 continue;
11324
11325 no_body = !DECL_FUNCTION_BODY (decl);
11326 /* Don't generate debug info on line zero when expanding a
11327 generated constructor. */
11328 if (no_body)
11329 restore_line_number_status (1);
11330
11331 java_complete_expand_method (decl);
11332
11333 if (no_body)
11334 restore_line_number_status (0);
11335 }
11336
11337 /* First, do the ordinary methods. */
11338 for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
11339 {
11340 /* Ctors aren't part of this batch. */
11341 if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
11342 continue;
11343
11344 /* Skip abstract or native methods -- but do handle native
11345 methods when generating JNI stubs. */
11346 if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
11347 {
11348 DECL_FUNCTION_BODY (decl) = NULL_TREE;
11349 continue;
11350 }
11351
11352 if (METHOD_NATIVE (decl))
11353 {
11354 tree body;
11355 current_function_decl = decl;
11356 body = build_jni_stub (decl);
11357 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
11358 }
11359
11360 java_complete_expand_method (decl);
11361 }
11362
11363 /* If there is indeed a <clinit>, fully expand it now */
11364 if (clinit)
11365 {
11366 /* Prevent the use of `this' inside <clinit> */
11367 ctxp->explicit_constructor_p = 1;
11368 java_complete_expand_method (clinit);
11369 ctxp->explicit_constructor_p = 0;
11370 }
11371
11372 /* We might have generated a class$ that we now want to expand */
11373 if (TYPE_DOT_CLASS (current_class))
11374 java_complete_expand_method (TYPE_DOT_CLASS (current_class));
11375
11376 /* Now verify constructor circularity (stop after the first one we
11377 prove wrong.) */
11378 if (!CLASS_INTERFACE (class_decl))
11379 for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
11380 if (DECL_CONSTRUCTOR_P (decl)
11381 && verify_constructor_circularity (decl, decl))
11382 break;
11383
11384 /* Save the constant pool. We'll need to restore it later. */
11385 TYPE_CPOOL (current_class) = outgoing_cpool;
11386 }
11387
11388 /* Attempt to create <clinit>. Pre-expand static fields so they can be
11389 safely used in some other methods/constructors. */
11390
11391 static tree
maybe_generate_pre_expand_clinit(class_type)11392 maybe_generate_pre_expand_clinit (class_type)
11393 tree class_type;
11394 {
11395 tree current, mdecl;
11396
11397 if (!TYPE_CLINIT_STMT_LIST (class_type))
11398 return NULL_TREE;
11399
11400 /* Go through all static fields and pre expand them */
11401 for (current = TYPE_FIELDS (class_type); current;
11402 current = TREE_CHAIN (current))
11403 if (FIELD_STATIC (current))
11404 build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
11405
11406 /* Then build the <clinit> method */
11407 mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
11408 clinit_identifier_node, end_params_node);
11409 layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
11410 mdecl, NULL_TREE);
11411 start_artificial_method_body (mdecl);
11412
11413 /* We process the list of assignment we produced as the result of
11414 the declaration of initialized static field and add them as
11415 statement to the <clinit> method. */
11416 for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
11417 current = TREE_CHAIN (current))
11418 {
11419 tree stmt = current;
11420 /* We build the assignment expression that will initialize the
11421 field to its value. There are strict rules on static
11422 initializers (8.5). FIXME */
11423 if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
11424 stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
11425 java_method_add_stmt (mdecl, stmt);
11426 }
11427
11428 end_artificial_method_body (mdecl);
11429
11430 /* Now we want to place <clinit> as the last method (because we need
11431 it at least for interface so that it doesn't interfere with the
11432 dispatch table based lookup. */
11433 if (TREE_CHAIN (TYPE_METHODS (class_type)))
11434 {
11435 current = TREE_CHAIN (TYPE_METHODS (class_type));
11436 TYPE_METHODS (class_type) = current;
11437
11438 while (TREE_CHAIN (current))
11439 current = TREE_CHAIN (current);
11440
11441 TREE_CHAIN (current) = mdecl;
11442 TREE_CHAIN (mdecl) = NULL_TREE;
11443 }
11444
11445 return mdecl;
11446 }
11447
11448 /* Analyzes a method body and look for something that isn't a
11449 MODIFY_EXPR with a constant value. */
11450
11451 static int
analyze_clinit_body(this_class,bbody)11452 analyze_clinit_body (this_class, bbody)
11453 tree this_class, bbody;
11454 {
11455 while (bbody)
11456 switch (TREE_CODE (bbody))
11457 {
11458 case BLOCK:
11459 bbody = BLOCK_EXPR_BODY (bbody);
11460 break;
11461
11462 case EXPR_WITH_FILE_LOCATION:
11463 bbody = EXPR_WFL_NODE (bbody);
11464 break;
11465
11466 case COMPOUND_EXPR:
11467 if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
11468 return 1;
11469 bbody = TREE_OPERAND (bbody, 1);
11470 break;
11471
11472 case MODIFY_EXPR:
11473 /* If we're generating to class file and we're dealing with an
11474 array initialization, we return 1 to keep <clinit> */
11475 if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
11476 && flag_emit_class_files)
11477 return 1;
11478
11479 /* There are a few cases where we're required to keep
11480 <clinit>:
11481 - If this is an assignment whose operand is not constant,
11482 - If this is an assignment to a non-initialized field,
11483 - If this field is not a member of the current class.
11484 */
11485 return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
11486 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
11487 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
11488
11489 default:
11490 return 1;
11491 }
11492 return 0;
11493 }
11494
11495
11496 /* See whether we could get rid of <clinit>. Criteria are: all static
11497 final fields have constant initial values and the body of <clinit>
11498 is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
11499
11500 static int
maybe_yank_clinit(mdecl)11501 maybe_yank_clinit (mdecl)
11502 tree mdecl;
11503 {
11504 tree type, current;
11505 tree fbody, bbody;
11506
11507 if (!DECL_CLINIT_P (mdecl))
11508 return 0;
11509
11510 /* If the body isn't empty, then we keep <clinit>. Note that if
11511 we're emitting classfiles, this isn't enough not to rule it
11512 out. */
11513 fbody = DECL_FUNCTION_BODY (mdecl);
11514 bbody = BLOCK_EXPR_BODY (fbody);
11515 if (bbody && bbody != error_mark_node)
11516 bbody = BLOCK_EXPR_BODY (bbody);
11517 else
11518 return 0;
11519 if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
11520 return 0;
11521
11522 type = DECL_CONTEXT (mdecl);
11523 current = TYPE_FIELDS (type);
11524
11525 for (current = (current ? TREE_CHAIN (current) : current);
11526 current; current = TREE_CHAIN (current))
11527 {
11528 tree f_init;
11529
11530 /* We're not interested in non-static fields. */
11531 if (!FIELD_STATIC (current))
11532 continue;
11533
11534 /* Nor in fields without initializers. */
11535 f_init = DECL_INITIAL (current);
11536 if (f_init == NULL_TREE)
11537 continue;
11538
11539 /* Anything that isn't String or a basic type is ruled out -- or
11540 if we know how to deal with it (when doing things natively) we
11541 should generated an empty <clinit> so that SUID are computed
11542 correctly. */
11543 if (! JSTRING_TYPE_P (TREE_TYPE (current))
11544 && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
11545 return 0;
11546
11547 if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
11548 return 0;
11549 }
11550
11551 /* Now we analyze the method body and look for something that
11552 isn't a MODIFY_EXPR */
11553 if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
11554 return 0;
11555
11556 /* Get rid of <clinit> in the class' list of methods */
11557 if (TYPE_METHODS (type) == mdecl)
11558 TYPE_METHODS (type) = TREE_CHAIN (mdecl);
11559 else
11560 for (current = TYPE_METHODS (type); current;
11561 current = TREE_CHAIN (current))
11562 if (TREE_CHAIN (current) == mdecl)
11563 {
11564 TREE_CHAIN (current) = TREE_CHAIN (mdecl);
11565 break;
11566 }
11567
11568 return 1;
11569 }
11570
11571 /* Install the argument from MDECL. Suitable to completion and
11572 expansion of mdecl's body. */
11573
11574 static void
start_complete_expand_method(mdecl)11575 start_complete_expand_method (mdecl)
11576 tree mdecl;
11577 {
11578 tree tem;
11579
11580 pushlevel (1); /* Prepare for a parameter push */
11581 tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
11582 DECL_ARGUMENTS (mdecl) = tem;
11583
11584 for (; tem; tem = TREE_CHAIN (tem))
11585 {
11586 /* TREE_CHAIN (tem) will change after pushdecl. */
11587 tree next = TREE_CHAIN (tem);
11588 tree type = TREE_TYPE (tem);
11589 if (PROMOTE_PROTOTYPES
11590 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
11591 && INTEGRAL_TYPE_P (type))
11592 type = integer_type_node;
11593 DECL_ARG_TYPE (tem) = type;
11594 layout_decl (tem, 0);
11595 pushdecl (tem);
11596 /* Re-install the next so that the list is kept and the loop
11597 advances. */
11598 TREE_CHAIN (tem) = next;
11599 }
11600 pushdecl_force_head (DECL_ARGUMENTS (mdecl));
11601 lineno = DECL_SOURCE_LINE_FIRST (mdecl);
11602 build_result_decl (mdecl);
11603 }
11604
11605
11606 /* Complete and expand a method. */
11607
11608 static void
java_complete_expand_method(mdecl)11609 java_complete_expand_method (mdecl)
11610 tree mdecl;
11611 {
11612 tree fbody, block_body, exception_copy;
11613
11614 current_function_decl = mdecl;
11615 /* Fix constructors before expanding them */
11616 if (DECL_CONSTRUCTOR_P (mdecl))
11617 fix_constructors (mdecl);
11618
11619 /* Expand functions that have a body */
11620 if (!DECL_FUNCTION_BODY (mdecl))
11621 return;
11622
11623 fbody = DECL_FUNCTION_BODY (mdecl);
11624 block_body = BLOCK_EXPR_BODY (fbody);
11625 exception_copy = NULL_TREE;
11626
11627 current_function_decl = mdecl;
11628
11629 if (! quiet_flag)
11630 fprintf (stderr, " [%s.",
11631 lang_printable_name (DECL_CONTEXT (mdecl), 0));
11632 announce_function (mdecl);
11633 if (! quiet_flag)
11634 fprintf (stderr, "]");
11635
11636 /* Prepare the function for tree completion */
11637 start_complete_expand_method (mdecl);
11638
11639 /* Install the current this */
11640 current_this = (!METHOD_STATIC (mdecl) ?
11641 BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
11642
11643 /* Purge the `throws' list of unchecked exceptions (we save a copy
11644 of the list and re-install it later.) */
11645 exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
11646 purge_unchecked_exceptions (mdecl);
11647
11648 /* Install exceptions thrown with `throws' */
11649 PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
11650
11651 if (block_body != NULL_TREE)
11652 {
11653 block_body = java_complete_tree (block_body);
11654
11655 /* Before we check initialization, attached all class initialization
11656 variable to the block_body */
11657 htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
11658 attach_init_test_initialization_flags, block_body);
11659
11660 if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
11661 {
11662 check_for_initialization (block_body, mdecl);
11663
11664 /* Go through all the flags marking the initialization of
11665 static variables and see whether they're definitively
11666 assigned, in which case the type is remembered as
11667 definitively initialized in MDECL. */
11668 if (STATIC_CLASS_INIT_OPT_P ())
11669 {
11670 /* Always register the context as properly initialized in
11671 MDECL. This used with caution helps removing extra
11672 initialization of self. */
11673 if (METHOD_STATIC (mdecl))
11674 {
11675 *(htab_find_slot
11676 (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
11677 DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
11678 }
11679 }
11680 }
11681 ctxp->explicit_constructor_p = 0;
11682 }
11683
11684 BLOCK_EXPR_BODY (fbody) = block_body;
11685
11686 /* If we saw a return but couldn't evaluate it properly, we'll have
11687 an error_mark_node here. */
11688 if (block_body != error_mark_node
11689 && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
11690 && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
11691 && !flag_emit_xref)
11692 missing_return_error (current_function_decl);
11693
11694 /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
11695 maybe_yank_clinit (mdecl);
11696
11697 /* Pop the current level, with special measures if we found errors. */
11698 if (java_error_count)
11699 pushdecl_force_head (DECL_ARGUMENTS (mdecl));
11700 poplevel (1, 0, 1);
11701
11702 /* Pop the exceptions and sanity check */
11703 POP_EXCEPTIONS();
11704 if (currently_caught_type_list)
11705 abort ();
11706
11707 /* Restore the copy of the list of exceptions if emitting xrefs. */
11708 DECL_FUNCTION_THROWS (mdecl) = exception_copy;
11709 }
11710
11711 /* For with each class for which there's code to generate. */
11712
11713 static void
java_expand_method_bodies(class)11714 java_expand_method_bodies (class)
11715 tree class;
11716 {
11717 tree decl;
11718 for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
11719 {
11720 if (!DECL_FUNCTION_BODY (decl))
11721 continue;
11722
11723 current_function_decl = decl;
11724
11725 /* Save the function for inlining. */
11726 if (flag_inline_trees)
11727 DECL_SAVED_TREE (decl) =
11728 BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
11729
11730 /* It's time to assign the variable flagging static class
11731 initialization based on which classes invoked static methods
11732 are definitely initializing. This should be flagged. */
11733 if (STATIC_CLASS_INIT_OPT_P ())
11734 {
11735 tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
11736 for (; list != NULL_TREE; list = TREE_CHAIN (list))
11737 {
11738 /* Executed for each statement calling a static function.
11739 LIST is a TREE_LIST whose PURPOSE is the called function
11740 and VALUE is a compound whose second operand can be patched
11741 with static class initialization flag assignments. */
11742
11743 tree called_method = TREE_PURPOSE (list);
11744 tree compound = TREE_VALUE (list);
11745 tree assignment_compound_list
11746 = build_tree_list (called_method, NULL);
11747
11748 /* For each class definitely initialized in
11749 CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
11750 assignment to the class initialization flag. */
11751 htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
11752 emit_test_initialization,
11753 assignment_compound_list);
11754
11755 if (TREE_VALUE (assignment_compound_list))
11756 TREE_OPERAND (compound, 1)
11757 = TREE_VALUE (assignment_compound_list);
11758 }
11759 }
11760
11761 /* Prepare the function for RTL expansion */
11762 start_complete_expand_method (decl);
11763
11764 /* Expand function start, generate initialization flag
11765 assignment, and handle synchronized methods. */
11766 complete_start_java_method (decl);
11767
11768 /* Expand the rest of the function body and terminate
11769 expansion. */
11770 source_end_java_method ();
11771 }
11772 }
11773
11774
11775
11776 /* This section of the code deals with accessing enclosing context
11777 fields either directly by using the relevant access to this$<n> or
11778 by invoking an access method crafted for that purpose. */
11779
11780 /* Build the necessary access from an inner class to an outer
11781 class. This routine could be optimized to cache previous result
11782 (decl, current_class and returned access). When an access method
11783 needs to be generated, it always takes the form of a read. It might
11784 be later turned into a write by calling outer_field_access_fix. */
11785
11786 static tree
build_outer_field_access(id,decl)11787 build_outer_field_access (id, decl)
11788 tree id, decl;
11789 {
11790 tree access = NULL_TREE;
11791 tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
11792 tree decl_ctx = DECL_CONTEXT (decl);
11793
11794 /* If the immediate enclosing context of the current class is the
11795 field decl's class or inherits from it; build the access as
11796 `this$<n>.<field>'. Note that we will break the `private' barrier
11797 if we're not emitting bytecodes. */
11798 if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
11799 && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
11800 {
11801 tree thisn = build_current_thisn (current_class);
11802 access = make_qualified_primary (build_wfl_node (thisn),
11803 id, EXPR_WFL_LINECOL (id));
11804 }
11805 /* Otherwise, generate access methods to outer this and access the
11806 field (either using an access method or by direct access.) */
11807 else
11808 {
11809 int lc = EXPR_WFL_LINECOL (id);
11810
11811 /* Now we chain the required number of calls to the access$0 to
11812 get a hold to the enclosing instance we need, and then we
11813 build the field access. */
11814 access = build_access_to_thisn (current_class, decl_ctx, lc);
11815
11816 /* If the field is private and we're generating bytecode, then
11817 we generate an access method */
11818 if (FIELD_PRIVATE (decl) && flag_emit_class_files )
11819 {
11820 tree name = build_outer_field_access_methods (decl);
11821 access = build_outer_field_access_expr (lc, decl_ctx,
11822 name, access, NULL_TREE);
11823 }
11824 /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
11825 Once again we break the `private' access rule from a foreign
11826 class. */
11827 else
11828 access = make_qualified_primary (access, id, lc);
11829 }
11830 return resolve_expression_name (access, NULL);
11831 }
11832
11833 /* Return a nonzero value if NODE describes an outer field inner
11834 access. */
11835
11836 static int
outer_field_access_p(type,decl)11837 outer_field_access_p (type, decl)
11838 tree type, decl;
11839 {
11840 if (!INNER_CLASS_TYPE_P (type)
11841 || TREE_CODE (decl) != FIELD_DECL
11842 || DECL_CONTEXT (decl) == type)
11843 return 0;
11844
11845 /* If the inner class extends the declaration context of the field
11846 we're try to acces, then this isn't an outer field access */
11847 if (inherits_from_p (type, DECL_CONTEXT (decl)))
11848 return 0;
11849
11850 for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
11851 type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
11852 {
11853 if (type == DECL_CONTEXT (decl))
11854 return 1;
11855
11856 if (!DECL_CONTEXT (TYPE_NAME (type)))
11857 {
11858 /* Before we give up, see whether the field is inherited from
11859 the enclosing context we're considering. */
11860 if (inherits_from_p (type, DECL_CONTEXT (decl)))
11861 return 1;
11862 break;
11863 }
11864 }
11865
11866 return 0;
11867 }
11868
11869 /* Return a nonzero value if NODE represents an outer field inner
11870 access that was been already expanded. As a side effect, it returns
11871 the name of the field being accessed and the argument passed to the
11872 access function, suitable for a regeneration of the access method
11873 call if necessary. */
11874
11875 static int
outer_field_expanded_access_p(node,name,arg_type,arg)11876 outer_field_expanded_access_p (node, name, arg_type, arg)
11877 tree node, *name, *arg_type, *arg;
11878 {
11879 int identified = 0;
11880
11881 if (TREE_CODE (node) != CALL_EXPR)
11882 return 0;
11883
11884 /* Well, gcj generates slightly different tree nodes when compiling
11885 to native or bytecodes. It's the case for function calls. */
11886
11887 if (flag_emit_class_files
11888 && TREE_CODE (node) == CALL_EXPR
11889 && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
11890 identified = 1;
11891 else if (!flag_emit_class_files)
11892 {
11893 node = TREE_OPERAND (node, 0);
11894
11895 if (node && TREE_OPERAND (node, 0)
11896 && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
11897 {
11898 node = TREE_OPERAND (node, 0);
11899 if (TREE_OPERAND (node, 0)
11900 && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
11901 && (OUTER_FIELD_ACCESS_IDENTIFIER_P
11902 (DECL_NAME (TREE_OPERAND (node, 0)))))
11903 identified = 1;
11904 }
11905 }
11906
11907 if (identified && name && arg_type && arg)
11908 {
11909 tree argument = TREE_OPERAND (node, 1);
11910 *name = DECL_NAME (TREE_OPERAND (node, 0));
11911 *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
11912 *arg = TREE_VALUE (argument);
11913 }
11914 return identified;
11915 }
11916
11917 /* Detect in NODE an outer field read access from an inner class and
11918 transform it into a write with RHS as an argument. This function is
11919 called from the java_complete_lhs when an assignment to a LHS can
11920 be identified. */
11921
11922 static tree
outer_field_access_fix(wfl,node,rhs)11923 outer_field_access_fix (wfl, node, rhs)
11924 tree wfl, node, rhs;
11925 {
11926 tree name, arg_type, arg;
11927
11928 if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
11929 {
11930 node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
11931 arg_type, name, arg, rhs);
11932 return java_complete_tree (node);
11933 }
11934 return NULL_TREE;
11935 }
11936
11937 /* Construct the expression that calls an access method:
11938 <type>.access$<n>(<arg1> [, <arg2>]);
11939
11940 ARG2 can be NULL and will be omitted in that case. It will denote a
11941 read access. */
11942
11943 static tree
build_outer_field_access_expr(lc,type,access_method_name,arg1,arg2)11944 build_outer_field_access_expr (lc, type, access_method_name, arg1, arg2)
11945 int lc;
11946 tree type, access_method_name, arg1, arg2;
11947 {
11948 tree args, cn, access;
11949
11950 args = arg1 ? arg1 :
11951 build_wfl_node (build_current_thisn (current_class));
11952 args = build_tree_list (NULL_TREE, args);
11953
11954 if (arg2)
11955 args = tree_cons (NULL_TREE, arg2, args);
11956
11957 access = build_method_invocation (build_wfl_node (access_method_name), args);
11958 cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
11959 return make_qualified_primary (cn, access, lc);
11960 }
11961
11962 static tree
build_new_access_id()11963 build_new_access_id ()
11964 {
11965 static int access_n_counter = 1;
11966 char buffer [128];
11967
11968 sprintf (buffer, "access$%d", access_n_counter++);
11969 return get_identifier (buffer);
11970 }
11971
11972 /* Create the static access functions for the outer field DECL. We define a
11973 read:
11974 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
11975 return inst$.field;
11976 }
11977 and a write access:
11978 TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
11979 TREE_TYPE (<field>) value$) {
11980 return inst$.field = value$;
11981 }
11982 We should have a usage flags on the DECL so we can lazily turn the ones
11983 we're using for code generation. FIXME.
11984 */
11985
11986 static tree
build_outer_field_access_methods(decl)11987 build_outer_field_access_methods (decl)
11988 tree decl;
11989 {
11990 tree id, args, stmt, mdecl;
11991
11992 if (FIELD_INNER_ACCESS_P (decl))
11993 return FIELD_INNER_ACCESS (decl);
11994
11995 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
11996
11997 /* Create the identifier and a function named after it. */
11998 id = build_new_access_id ();
11999
12000 /* The identifier is marked as bearing the name of a generated write
12001 access function for outer field accessed from inner classes. */
12002 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
12003
12004 /* Create the read access */
12005 args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
12006 TREE_CHAIN (args) = end_params_node;
12007 stmt = make_qualified_primary (build_wfl_node (inst_id),
12008 build_wfl_node (DECL_NAME (decl)), 0);
12009 stmt = build_return (0, stmt);
12010 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
12011 TREE_TYPE (decl), id, args, stmt);
12012 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
12013
12014 /* Create the write access method. No write access for final variable */
12015 if (!FIELD_FINAL (decl))
12016 {
12017 args = build_tree_list (inst_id,
12018 build_pointer_type (DECL_CONTEXT (decl)));
12019 TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
12020 TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
12021 stmt = make_qualified_primary (build_wfl_node (inst_id),
12022 build_wfl_node (DECL_NAME (decl)), 0);
12023 stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
12024 build_wfl_node (wpv_id)));
12025 mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
12026 TREE_TYPE (decl), id,
12027 args, stmt);
12028 }
12029 DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
12030
12031 /* Return the access name */
12032 return FIELD_INNER_ACCESS (decl) = id;
12033 }
12034
12035 /* Build an field access method NAME. */
12036
12037 static tree
build_outer_field_access_method(class,type,name,args,body)12038 build_outer_field_access_method (class, type, name, args, body)
12039 tree class, type, name, args, body;
12040 {
12041 tree saved_current_function_decl, mdecl;
12042
12043 /* Create the method */
12044 mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
12045 fix_method_argument_names (args, mdecl);
12046 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
12047
12048 /* Attach the method body. */
12049 saved_current_function_decl = current_function_decl;
12050 start_artificial_method_body (mdecl);
12051 java_method_add_stmt (mdecl, body);
12052 end_artificial_method_body (mdecl);
12053 current_function_decl = saved_current_function_decl;
12054
12055 return mdecl;
12056 }
12057
12058
12059 /* This section deals with building access function necessary for
12060 certain kinds of method invocation from inner classes. */
12061
12062 static tree
build_outer_method_access_method(decl)12063 build_outer_method_access_method (decl)
12064 tree decl;
12065 {
12066 tree saved_current_function_decl, mdecl;
12067 tree args = NULL_TREE, call_args = NULL_TREE;
12068 tree carg, id, body, class;
12069 char buffer [80];
12070 int parm_id_count = 0;
12071
12072 /* Test this abort with an access to a private field */
12073 if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
12074 abort ();
12075
12076 /* Check the cache first */
12077 if (DECL_FUNCTION_INNER_ACCESS (decl))
12078 return DECL_FUNCTION_INNER_ACCESS (decl);
12079
12080 class = DECL_CONTEXT (decl);
12081
12082 /* Obtain an access identifier and mark it */
12083 id = build_new_access_id ();
12084 OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
12085
12086 carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
12087 /* Create the arguments, as much as the original */
12088 for (; carg && carg != end_params_node;
12089 carg = TREE_CHAIN (carg))
12090 {
12091 sprintf (buffer, "write_parm_value$%d", parm_id_count++);
12092 args = chainon (args, build_tree_list (get_identifier (buffer),
12093 TREE_VALUE (carg)));
12094 }
12095 args = chainon (args, end_params_node);
12096
12097 /* Create the method */
12098 mdecl = create_artificial_method (class, ACC_STATIC,
12099 TREE_TYPE (TREE_TYPE (decl)), id, args);
12100 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
12101 /* There is a potential bug here. We should be able to use
12102 fix_method_argument_names, but then arg names get mixed up and
12103 eventually a constructor will have its this$0 altered and the
12104 outer context won't be assignment properly. The test case is
12105 stub.java FIXME */
12106 TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
12107
12108 /* Attach the method body. */
12109 saved_current_function_decl = current_function_decl;
12110 start_artificial_method_body (mdecl);
12111
12112 /* The actual method invocation uses the same args. When invoking a
12113 static methods that way, we don't want to skip the first
12114 argument. */
12115 carg = args;
12116 if (!METHOD_STATIC (decl))
12117 carg = TREE_CHAIN (carg);
12118 for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
12119 call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
12120 call_args);
12121
12122 body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
12123 call_args);
12124 if (!METHOD_STATIC (decl))
12125 body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
12126 body, 0);
12127 if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
12128 body = build_return (0, body);
12129 java_method_add_stmt (mdecl,body);
12130 end_artificial_method_body (mdecl);
12131 current_function_decl = saved_current_function_decl;
12132
12133 /* Back tag the access function so it know what it accesses */
12134 DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
12135
12136 /* Tag the current method so it knows it has an access generated */
12137 return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
12138 }
12139
12140
12141 /* This section of the code deals with building expressions to access
12142 the enclosing instance of an inner class. The enclosing instance is
12143 kept in a generated field called this$<n>, with <n> being the
12144 inner class nesting level (starting from 0.) */
12145
12146 /* Build an access to a given this$<n>, always chaining access call to
12147 others. Access methods to this$<n> are build on the fly if
12148 necessary. This CAN'T be used to solely access this$<n-1> from
12149 this$<n> (which alway yield to special cases and optimization, see
12150 for example build_outer_field_access). */
12151
12152 static tree
build_access_to_thisn(from,to,lc)12153 build_access_to_thisn (from, to, lc)
12154 tree from, to;
12155 int lc;
12156 {
12157 tree access = NULL_TREE;
12158
12159 while (from != to && PURE_INNER_CLASS_TYPE_P (from))
12160 {
12161 if (!access)
12162 {
12163 access = build_current_thisn (from);
12164 access = build_wfl_node (access);
12165 }
12166 else
12167 {
12168 tree access0_wfl, cn;
12169
12170 maybe_build_thisn_access_method (from);
12171 access0_wfl = build_wfl_node (access0_identifier_node);
12172 cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
12173 EXPR_WFL_LINECOL (access0_wfl) = lc;
12174 access = build_tree_list (NULL_TREE, access);
12175 access = build_method_invocation (access0_wfl, access);
12176 access = make_qualified_primary (cn, access, lc);
12177 }
12178
12179 /* If FROM isn't an inner class, that's fine, we've done enough.
12180 What we're looking for can be accessed from there. */
12181 from = DECL_CONTEXT (TYPE_NAME (from));
12182 if (!from)
12183 break;
12184 from = TREE_TYPE (from);
12185 }
12186 return access;
12187 }
12188
12189 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
12190 is returned if nothing needs to be generated. Otherwise, the method
12191 generated and a method decl is returned.
12192
12193 NOTE: These generated methods should be declared in a class file
12194 attribute so that they can't be referred to directly. */
12195
12196 static tree
maybe_build_thisn_access_method(type)12197 maybe_build_thisn_access_method (type)
12198 tree type;
12199 {
12200 tree mdecl, args, stmt, rtype;
12201 tree saved_current_function_decl;
12202
12203 /* If TYPE is a top-level class, no access method is required.
12204 If there already is such an access method, bail out. */
12205 if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
12206 return NULL_TREE;
12207
12208 /* We generate the method. The method looks like:
12209 static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
12210 */
12211 args = build_tree_list (inst_id, build_pointer_type (type));
12212 TREE_CHAIN (args) = end_params_node;
12213 rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
12214 mdecl = create_artificial_method (type, ACC_STATIC, rtype,
12215 access0_identifier_node, args);
12216 fix_method_argument_names (args, mdecl);
12217 layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
12218 stmt = build_current_thisn (type);
12219 stmt = make_qualified_primary (build_wfl_node (inst_id),
12220 build_wfl_node (stmt), 0);
12221 stmt = build_return (0, stmt);
12222
12223 saved_current_function_decl = current_function_decl;
12224 start_artificial_method_body (mdecl);
12225 java_method_add_stmt (mdecl, stmt);
12226 end_artificial_method_body (mdecl);
12227 current_function_decl = saved_current_function_decl;
12228
12229 CLASS_ACCESS0_GENERATED_P (type) = 1;
12230
12231 return mdecl;
12232 }
12233
12234 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
12235 the first level of innerclassing. this$1 for the next one, etc...
12236 This function can be invoked with TYPE to NULL, available and then
12237 has to count the parser context. */
12238
12239 static GTY(()) tree saved_thisn;
12240 static GTY(()) tree saved_type;
12241
12242 static tree
build_current_thisn(type)12243 build_current_thisn (type)
12244 tree type;
12245 {
12246 static int saved_i = -1;
12247 static int saved_type_i = 0;
12248 tree decl;
12249 char buffer [24];
12250 int i = 0;
12251
12252 if (type)
12253 {
12254 if (type == saved_type)
12255 i = saved_type_i;
12256 else
12257 {
12258 for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
12259 decl; decl = DECL_CONTEXT (decl), i++)
12260 ;
12261
12262 saved_type = type;
12263 saved_type_i = i;
12264 }
12265 }
12266 else
12267 i = list_length (GET_CPC_LIST ())-2;
12268
12269 if (i == saved_i)
12270 return saved_thisn;
12271
12272 sprintf (buffer, "this$%d", i);
12273 saved_i = i;
12274 saved_thisn = get_identifier (buffer);
12275 return saved_thisn;
12276 }
12277
12278 /* Return the assignement to the hidden enclosing context `this$<n>'
12279 by the second incoming parameter to the innerclass constructor. The
12280 form used is `this.this$<n> = this$<n>;'. */
12281
12282 static tree
build_thisn_assign()12283 build_thisn_assign ()
12284 {
12285 if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
12286 {
12287 tree thisn = build_current_thisn (current_class);
12288 tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
12289 build_wfl_node (thisn), 0);
12290 tree rhs = build_wfl_node (thisn);
12291 EXPR_WFL_SET_LINECOL (lhs, lineno, 0);
12292 return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
12293 }
12294 return NULL_TREE;
12295 }
12296
12297
12298 /* Building the synthetic `class$' used to implement the `.class' 1.1
12299 extension for non primitive types. This method looks like:
12300
12301 static Class class$(String type) throws NoClassDefFoundError
12302 {
12303 try {return (java.lang.Class.forName (String));}
12304 catch (ClassNotFoundException e) {
12305 throw new NoClassDefFoundError(e.getMessage());}
12306 } */
12307
12308 static GTY(()) tree get_message_wfl;
12309 static GTY(()) tree type_parm_wfl;
12310
12311 static tree
build_dot_class_method(class)12312 build_dot_class_method (class)
12313 tree class;
12314 {
12315 #define BWF(S) build_wfl_node (get_identifier ((S)))
12316 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
12317 tree args, tmp, saved_current_function_decl, mdecl;
12318 tree stmt, throw_stmt;
12319
12320 if (!get_message_wfl)
12321 {
12322 get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
12323 type_parm_wfl = build_wfl_node (get_identifier ("type$"));
12324 }
12325
12326 /* Build the arguments */
12327 args = build_tree_list (get_identifier ("type$"),
12328 build_pointer_type (string_type_node));
12329 TREE_CHAIN (args) = end_params_node;
12330
12331 /* Build the qualified name java.lang.Class.forName */
12332 tmp = MQN (MQN (MQN (BWF ("java"),
12333 BWF ("lang")), BWF ("Class")), BWF ("forName"));
12334 load_class (class_not_found_type_node, 1);
12335 load_class (no_class_def_found_type_node, 1);
12336
12337 /* Create the "class$" function */
12338 mdecl = create_artificial_method (class, ACC_STATIC,
12339 build_pointer_type (class_type_node),
12340 classdollar_identifier_node, args);
12341 DECL_FUNCTION_THROWS (mdecl) =
12342 build_tree_list (NULL_TREE, no_class_def_found_type_node);
12343
12344 /* We start by building the try block. We need to build:
12345 return (java.lang.Class.forName (type)); */
12346 stmt = build_method_invocation (tmp,
12347 build_tree_list (NULL_TREE, type_parm_wfl));
12348 stmt = build_return (0, stmt);
12349
12350 /* Now onto the catch block. We start by building the expression
12351 throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
12352 throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
12353 get_message_wfl, 0);
12354 throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
12355
12356 /* Build new NoClassDefFoundError (_.getMessage) */
12357 throw_stmt = build_new_invocation
12358 (build_wfl_node (get_identifier ("NoClassDefFoundError")),
12359 build_tree_list (build_pointer_type (string_type_node), throw_stmt));
12360
12361 /* Build the throw, (it's too early to use BUILD_THROW) */
12362 throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
12363
12364 /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
12365 stmt = encapsulate_with_try_catch (0, class_not_found_type_node,
12366 stmt, throw_stmt);
12367
12368 fix_method_argument_names (args, mdecl);
12369 layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
12370 saved_current_function_decl = current_function_decl;
12371 start_artificial_method_body (mdecl);
12372 java_method_add_stmt (mdecl, stmt);
12373 end_artificial_method_body (mdecl);
12374 current_function_decl = saved_current_function_decl;
12375 TYPE_DOT_CLASS (class) = mdecl;
12376
12377 return mdecl;
12378 }
12379
12380 static tree
build_dot_class_method_invocation(type)12381 build_dot_class_method_invocation (type)
12382 tree type;
12383 {
12384 tree sig_id, s;
12385
12386 if (TYPE_ARRAY_P (type))
12387 sig_id = build_java_signature (type);
12388 else
12389 sig_id = DECL_NAME (TYPE_NAME (type));
12390
12391 /* Ensure that the proper name separator is used */
12392 sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
12393 IDENTIFIER_LENGTH (sig_id));
12394
12395 s = build_string (IDENTIFIER_LENGTH (sig_id),
12396 IDENTIFIER_POINTER (sig_id));
12397 return build_method_invocation (build_wfl_node (classdollar_identifier_node),
12398 build_tree_list (NULL_TREE, s));
12399 }
12400
12401 /* This section of the code deals with constructor. */
12402
12403 /* Craft a body for default constructor. Patch existing constructor
12404 bodies with call to super() and field initialization statements if
12405 necessary. */
12406
12407 static void
fix_constructors(mdecl)12408 fix_constructors (mdecl)
12409 tree mdecl;
12410 {
12411 tree iii; /* Instance Initializer Invocation */
12412 tree body = DECL_FUNCTION_BODY (mdecl);
12413 tree thisn_assign, compound = NULL_TREE;
12414 tree class_type = DECL_CONTEXT (mdecl);
12415
12416 if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
12417 return;
12418 DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
12419
12420 if (!body)
12421 {
12422 /* It is an error for the compiler to generate a default
12423 constructor if the superclass doesn't have a constructor that
12424 takes no argument, or the same args for an anonymous class */
12425 if (verify_constructor_super (mdecl))
12426 {
12427 tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
12428 tree save = DECL_NAME (mdecl);
12429 const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
12430 DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
12431 parse_error_context
12432 (lookup_cl (TYPE_NAME (class_type)),
12433 "No constructor matching `%s' found in class `%s'",
12434 lang_printable_name (mdecl, 0), n);
12435 DECL_NAME (mdecl) = save;
12436 }
12437
12438 /* The constructor body must be crafted by hand. It's the
12439 constructor we defined when we realize we didn't have the
12440 CLASSNAME() constructor */
12441 start_artificial_method_body (mdecl);
12442
12443 /* Insert an assignment to the this$<n> hidden field, if
12444 necessary */
12445 if ((thisn_assign = build_thisn_assign ()))
12446 java_method_add_stmt (mdecl, thisn_assign);
12447
12448 /* We don't generate a super constructor invocation if we're
12449 compiling java.lang.Object. build_super_invocation takes care
12450 of that. */
12451 java_method_add_stmt (mdecl, build_super_invocation (mdecl));
12452
12453 /* FIXME */
12454 if ((iii = build_instinit_invocation (class_type)))
12455 java_method_add_stmt (mdecl, iii);
12456
12457 end_artificial_method_body (mdecl);
12458 }
12459 /* Search for an explicit constructor invocation */
12460 else
12461 {
12462 int found = 0;
12463 int invokes_this = 0;
12464 tree found_call = NULL_TREE;
12465 tree main_block = BLOCK_EXPR_BODY (body);
12466
12467 while (body)
12468 switch (TREE_CODE (body))
12469 {
12470 case CALL_EXPR:
12471 found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
12472 if (CALL_THIS_CONSTRUCTOR_P (body))
12473 invokes_this = 1;
12474 body = NULL_TREE;
12475 break;
12476 case COMPOUND_EXPR:
12477 case EXPR_WITH_FILE_LOCATION:
12478 found_call = body;
12479 body = TREE_OPERAND (body, 0);
12480 break;
12481 case BLOCK:
12482 found_call = body;
12483 body = BLOCK_EXPR_BODY (body);
12484 break;
12485 default:
12486 found = 0;
12487 body = NULL_TREE;
12488 }
12489
12490 /* Generate the assignment to this$<n>, if necessary */
12491 if ((thisn_assign = build_thisn_assign ()))
12492 compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
12493
12494 /* The constructor is missing an invocation of super() */
12495 if (!found)
12496 compound = add_stmt_to_compound (compound, NULL_TREE,
12497 build_super_invocation (mdecl));
12498 /* Explicit super() invokation should take place before the
12499 instance initializer blocks. */
12500 else
12501 {
12502 compound = add_stmt_to_compound (compound, NULL_TREE,
12503 TREE_OPERAND (found_call, 0));
12504 TREE_OPERAND (found_call, 0) = empty_stmt_node;
12505 }
12506
12507 DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
12508
12509 /* Insert the instance initializer block right after. */
12510 if (!invokes_this && (iii = build_instinit_invocation (class_type)))
12511 compound = add_stmt_to_compound (compound, NULL_TREE, iii);
12512
12513 /* Fix the constructor main block if we're adding extra stmts */
12514 if (compound)
12515 {
12516 compound = add_stmt_to_compound (compound, NULL_TREE,
12517 BLOCK_EXPR_BODY (main_block));
12518 BLOCK_EXPR_BODY (main_block) = compound;
12519 }
12520 }
12521 }
12522
12523 /* Browse constructors in the super class, searching for a constructor
12524 that doesn't take any argument. Return 0 if one is found, 1
12525 otherwise. If the current class is an anonymous inner class, look
12526 for something that has the same signature. */
12527
12528 static int
verify_constructor_super(mdecl)12529 verify_constructor_super (mdecl)
12530 tree mdecl;
12531 {
12532 tree class = CLASSTYPE_SUPER (current_class);
12533 int super_inner = PURE_INNER_CLASS_TYPE_P (class);
12534 tree sdecl;
12535
12536 if (!class)
12537 return 0;
12538
12539 if (ANONYMOUS_CLASS_P (current_class))
12540 {
12541 tree mdecl_arg_type;
12542 SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
12543 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
12544 if (DECL_CONSTRUCTOR_P (sdecl))
12545 {
12546 tree m_arg_type;
12547 tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
12548 if (super_inner)
12549 arg_type = TREE_CHAIN (arg_type);
12550 for (m_arg_type = mdecl_arg_type;
12551 (arg_type != end_params_node
12552 && m_arg_type != end_params_node);
12553 arg_type = TREE_CHAIN (arg_type),
12554 m_arg_type = TREE_CHAIN (m_arg_type))
12555 if (!valid_method_invocation_conversion_p
12556 (TREE_VALUE (arg_type),
12557 TREE_VALUE (m_arg_type)))
12558 break;
12559
12560 if (arg_type == end_params_node && m_arg_type == end_params_node)
12561 return 0;
12562 }
12563 }
12564 else
12565 {
12566 for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
12567 {
12568 tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
12569 if (super_inner)
12570 arg = TREE_CHAIN (arg);
12571 if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
12572 return 0;
12573 }
12574 }
12575 return 1;
12576 }
12577
12578 /* Generate code for all context remembered for code generation. */
12579
12580 static GTY(()) tree reversed_class_list;
12581 void
java_expand_classes()12582 java_expand_classes ()
12583 {
12584 int save_error_count = 0;
12585 static struct parser_ctxt *cur_ctxp = NULL;
12586
12587 java_parse_abort_on_error ();
12588 if (!(ctxp = ctxp_for_generation))
12589 return;
12590 java_layout_classes ();
12591 java_parse_abort_on_error ();
12592
12593 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
12594 {
12595 ctxp = cur_ctxp;
12596 input_filename = ctxp->filename;
12597 lang_init_source (2); /* Error msgs have method prototypes */
12598 java_complete_expand_classes (); /* Complete and expand classes */
12599 java_parse_abort_on_error ();
12600 }
12601 input_filename = main_input_filename;
12602
12603
12604 /* Find anonymous classes and expand their constructor. This extra pass is
12605 neccessary because the constructor itself is only generated when the
12606 method in which it is defined is expanded. */
12607 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
12608 {
12609 tree current;
12610 ctxp = cur_ctxp;
12611 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
12612 {
12613 current_class = TREE_TYPE (current);
12614 if (ANONYMOUS_CLASS_P (current_class))
12615 {
12616 tree d;
12617 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
12618 {
12619 if (DECL_CONSTRUCTOR_P (d))
12620 {
12621 restore_line_number_status (1);
12622 java_complete_expand_method (d);
12623 restore_line_number_status (0);
12624 break; /* There is only one constructor. */
12625 }
12626 }
12627 }
12628 }
12629 }
12630
12631 /* Expanding the constructors of anonymous classes generates access
12632 methods. Scan all the methods looking for null DECL_RESULTs --
12633 this will be the case if a method hasn't been expanded. */
12634 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
12635 {
12636 tree current;
12637 ctxp = cur_ctxp;
12638 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
12639 {
12640 tree d;
12641 current_class = TREE_TYPE (current);
12642 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
12643 {
12644 if (DECL_RESULT (d) == NULL_TREE)
12645 {
12646 restore_line_number_status (1);
12647 java_complete_expand_method (d);
12648 restore_line_number_status (0);
12649 }
12650 }
12651 }
12652 }
12653
12654 /* ??? Instead of all this we could iterate around the list of
12655 classes until there were no more un-expanded methods. It would
12656 take a little longer -- one pass over the whole list of methods
12657 -- but it would be simpler. Like this: */
12658 #if 0
12659 {
12660 int something_changed;
12661
12662 do
12663 {
12664 something_changed = 0;
12665 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
12666 {
12667 tree current;
12668 ctxp = cur_ctxp;
12669 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
12670 {
12671 tree d;
12672 current_class = TREE_TYPE (current);
12673 for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
12674 {
12675 if (DECL_RESULT (d) == NULL_TREE)
12676 {
12677 something_changed = 1;
12678 restore_line_number_status (1);
12679 java_complete_expand_method (d);
12680 restore_line_number_status (0);
12681 }
12682 }
12683 }
12684 }
12685 }
12686 while (something_changed);
12687 }
12688 #endif
12689
12690 /* If we've found error at that stage, don't try to generate
12691 anything, unless we're emitting xrefs or checking the syntax only
12692 (but not using -fsyntax-only for the purpose of generating
12693 bytecode. */
12694 if (java_error_count && !flag_emit_xref
12695 && (!flag_syntax_only && !flag_emit_class_files))
12696 return;
12697
12698 /* Now things are stable, go for generation of the class data. */
12699
12700 /* We pessimistically marked all fields external until we knew
12701 what set of classes we were planning to compile. Now mark
12702 those that will be generated locally as not external. */
12703 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
12704 {
12705 tree current;
12706 ctxp = cur_ctxp;
12707 for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
12708 {
12709 tree class = TREE_TYPE (current);
12710 tree field;
12711 for (field = TYPE_FIELDS (class); field ; field = TREE_CHAIN (field))
12712 if (FIELD_STATIC (field))
12713 DECL_EXTERNAL (field) = 0;
12714 }
12715 }
12716
12717 /* Compile the classes. */
12718 for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
12719 {
12720 tree current;
12721 reversed_class_list = NULL;
12722
12723 ctxp = cur_ctxp;
12724
12725 /* We write out the classes in reverse order. This ensures that
12726 inner classes are written before their containing classes,
12727 which is important for parallel builds. Otherwise, the
12728 class file for the outer class may be found, but the class
12729 file for the inner class may not be present. In that
12730 situation, the compiler cannot fall back to the original
12731 source, having already read the outer class, so we must
12732 prevent that situation. */
12733 for (current = ctxp->class_list;
12734 current;
12735 current = TREE_CHAIN (current))
12736 reversed_class_list
12737 = tree_cons (NULL_TREE, current, reversed_class_list);
12738
12739 for (current = reversed_class_list;
12740 current;
12741 current = TREE_CHAIN (current))
12742 {
12743 current_class = TREE_TYPE (TREE_VALUE (current));
12744 outgoing_cpool = TYPE_CPOOL (current_class);
12745 if (flag_emit_class_files)
12746 write_classfile (current_class);
12747 if (flag_emit_xref)
12748 expand_xref (current_class);
12749 else if (! flag_syntax_only)
12750 {
12751 java_expand_method_bodies (current_class);
12752 finish_class ();
12753 }
12754 }
12755 }
12756 }
12757
12758 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
12759 a tree list node containing RIGHT. Fore coming RIGHTs will be
12760 chained to this hook. LOCATION contains the location of the
12761 separating `.' operator. */
12762
12763 static tree
make_qualified_primary(primary,right,location)12764 make_qualified_primary (primary, right, location)
12765 tree primary, right;
12766 int location;
12767 {
12768 tree wfl;
12769
12770 if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
12771 wfl = build_wfl_wrap (primary, location);
12772 else
12773 {
12774 wfl = primary;
12775 /* If wfl wasn't qualified, we build a first anchor */
12776 if (!EXPR_WFL_QUALIFICATION (wfl))
12777 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
12778 }
12779
12780 /* And chain them */
12781 EXPR_WFL_LINECOL (right) = location;
12782 chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
12783 PRIMARY_P (wfl) = 1;
12784 return wfl;
12785 }
12786
12787 /* Simple merge of two name separated by a `.' */
12788
12789 static tree
merge_qualified_name(left,right)12790 merge_qualified_name (left, right)
12791 tree left, right;
12792 {
12793 tree node;
12794 if (!left && !right)
12795 return NULL_TREE;
12796
12797 if (!left)
12798 return right;
12799
12800 if (!right)
12801 return left;
12802
12803 obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
12804 IDENTIFIER_LENGTH (left));
12805 obstack_1grow (&temporary_obstack, '.');
12806 obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
12807 IDENTIFIER_LENGTH (right));
12808 node = get_identifier (obstack_base (&temporary_obstack));
12809 obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
12810 QUALIFIED_P (node) = 1;
12811 return node;
12812 }
12813
12814 /* Merge the two parts of a qualified name into LEFT. Set the
12815 location information of the resulting node to LOCATION, usually
12816 inherited from the location information of the `.' operator. */
12817
12818 static tree
make_qualified_name(left,right,location)12819 make_qualified_name (left, right, location)
12820 tree left, right;
12821 int location;
12822 {
12823 #ifdef USE_COMPONENT_REF
12824 tree node = build (COMPONENT_REF, NULL_TREE, left, right);
12825 EXPR_WFL_LINECOL (node) = location;
12826 return node;
12827 #else
12828 tree left_id = EXPR_WFL_NODE (left);
12829 tree right_id = EXPR_WFL_NODE (right);
12830 tree wfl, merge;
12831
12832 merge = merge_qualified_name (left_id, right_id);
12833
12834 /* Left wasn't qualified and is now qualified */
12835 if (!QUALIFIED_P (left_id))
12836 {
12837 tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
12838 EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
12839 EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
12840 }
12841
12842 wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
12843 EXPR_WFL_LINECOL (wfl) = location;
12844 chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
12845
12846 EXPR_WFL_NODE (left) = merge;
12847 return left;
12848 #endif
12849 }
12850
12851 /* Extract the last identifier component of the qualified in WFL. The
12852 last identifier is removed from the linked list */
12853
12854 static tree
cut_identifier_in_qualified(wfl)12855 cut_identifier_in_qualified (wfl)
12856 tree wfl;
12857 {
12858 tree q;
12859 tree previous = NULL_TREE;
12860 for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
12861 if (!TREE_CHAIN (q))
12862 {
12863 if (!previous)
12864 /* Operating on a non qualified qualified WFL. */
12865 abort ();
12866
12867 TREE_CHAIN (previous) = NULL_TREE;
12868 return TREE_PURPOSE (q);
12869 }
12870 }
12871
12872 /* Resolve the expression name NAME. Return its decl. */
12873
12874 static tree
resolve_expression_name(id,orig)12875 resolve_expression_name (id, orig)
12876 tree id;
12877 tree *orig;
12878 {
12879 tree name = EXPR_WFL_NODE (id);
12880 tree decl;
12881
12882 /* 6.5.5.1: Simple expression names */
12883 if (!PRIMARY_P (id) && !QUALIFIED_P (name))
12884 {
12885 /* 15.13.1: NAME can appear within the scope of a local variable
12886 declaration */
12887 if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
12888 return decl;
12889
12890 /* 15.13.1: NAME can appear within a class declaration */
12891 else
12892 {
12893 decl = lookup_field_wrapper (current_class, name);
12894 if (decl)
12895 {
12896 tree access = NULL_TREE;
12897 int fs = FIELD_STATIC (decl);
12898
12899 /* If we're accessing an outer scope local alias, make
12900 sure we change the name of the field we're going to
12901 build access to. */
12902 if (FIELD_LOCAL_ALIAS_USED (decl))
12903 name = DECL_NAME (decl);
12904
12905 /* Instance variable (8.3.1.1) can't appear within
12906 static method, static initializer or initializer for
12907 a static variable. */
12908 if (!fs && METHOD_STATIC (current_function_decl))
12909 {
12910 static_ref_err (id, name, current_class);
12911 return error_mark_node;
12912 }
12913 /* Instance variables can't appear as an argument of
12914 an explicit constructor invocation */
12915 if (!fs && ctxp->explicit_constructor_p
12916 && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
12917 {
12918 parse_error_context
12919 (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
12920 return error_mark_node;
12921 }
12922
12923 /* If we're processing an inner class and we're trying
12924 to access a field belonging to an outer class, build
12925 the access to the field */
12926 if (!fs && outer_field_access_p (current_class, decl))
12927 {
12928 if (CLASS_STATIC (TYPE_NAME (current_class)))
12929 {
12930 static_ref_err (id, DECL_NAME (decl), current_class);
12931 return error_mark_node;
12932 }
12933 access = build_outer_field_access (id, decl);
12934 if (orig)
12935 *orig = access;
12936 return access;
12937 }
12938
12939 /* Otherwise build what it takes to access the field */
12940 access = build_field_ref ((fs ? NULL_TREE : current_this),
12941 DECL_CONTEXT (decl), name);
12942 if (fs)
12943 access = maybe_build_class_init_for_field (decl, access);
12944 /* We may be asked to save the real field access node */
12945 if (orig)
12946 *orig = access;
12947 /* And we return what we got */
12948 return access;
12949 }
12950 /* Fall down to error report on undefined variable */
12951 }
12952 }
12953 /* 6.5.5.2 Qualified Expression Names */
12954 else
12955 {
12956 if (orig)
12957 *orig = NULL_TREE;
12958 qualify_ambiguous_name (id);
12959 /* 15.10.1 Field Access Using a Primary and/or Expression Name */
12960 /* 15.10.2: Accessing Superclass Members using super */
12961 return resolve_field_access (id, orig, NULL);
12962 }
12963
12964 /* We've got an error here */
12965 if (INNER_CLASS_TYPE_P (current_class))
12966 parse_error_context (id,
12967 "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
12968 IDENTIFIER_POINTER (name),
12969 IDENTIFIER_POINTER (DECL_NAME
12970 (TYPE_NAME (current_class))));
12971 else
12972 parse_error_context (id, "Undefined variable `%s'",
12973 IDENTIFIER_POINTER (name));
12974
12975 return error_mark_node;
12976 }
12977
12978 static void
static_ref_err(wfl,field_id,class_type)12979 static_ref_err (wfl, field_id, class_type)
12980 tree wfl, field_id, class_type;
12981 {
12982 parse_error_context
12983 (wfl,
12984 "Can't make a static reference to nonstatic variable `%s' in class `%s'",
12985 IDENTIFIER_POINTER (field_id),
12986 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
12987 }
12988
12989 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
12990 We return something suitable to generate the field access. We also
12991 return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
12992 recipient's address can be null. */
12993
12994 static tree
resolve_field_access(qual_wfl,field_decl,field_type)12995 resolve_field_access (qual_wfl, field_decl, field_type)
12996 tree qual_wfl;
12997 tree *field_decl, *field_type;
12998 {
12999 int is_static = 0;
13000 tree field_ref;
13001 tree decl, where_found, type_found;
13002
13003 if (resolve_qualified_expression_name (qual_wfl, &decl,
13004 &where_found, &type_found))
13005 return error_mark_node;
13006
13007 /* Resolve the LENGTH field of an array here */
13008 if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
13009 && type_found && TYPE_ARRAY_P (type_found)
13010 && ! flag_emit_class_files && ! flag_emit_xref)
13011 {
13012 tree length = build_java_array_length_access (where_found);
13013 field_ref = length;
13014
13015 /* In case we're dealing with a static array, we need to
13016 initialize its class before the array length can be fetched.
13017 It's also a good time to create a DECL_RTL for the field if
13018 none already exists, otherwise if the field was declared in a
13019 class found in an external file and hasn't been (and won't
13020 be) accessed for its value, none will be created. */
13021 if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
13022 {
13023 build_static_field_ref (where_found);
13024 field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
13025 }
13026 }
13027 /* We might have been trying to resolve field.method(). In which
13028 case, the resolution is over and decl is the answer */
13029 else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
13030 field_ref = decl;
13031 else if (JDECL_P (decl))
13032 {
13033 if (!type_found)
13034 type_found = DECL_CONTEXT (decl);
13035 is_static = FIELD_STATIC (decl);
13036 field_ref = build_field_ref ((is_static && !flag_emit_xref?
13037 NULL_TREE : where_found),
13038 type_found, DECL_NAME (decl));
13039 if (field_ref == error_mark_node)
13040 return error_mark_node;
13041 if (is_static)
13042 field_ref = maybe_build_class_init_for_field (decl, field_ref);
13043
13044 /* If we're looking at a static field, we may need to generate a
13045 class initialization for it. This can happen when the access
13046 looks like `field.ref', where `field' is a static field in an
13047 interface we implement. */
13048 if (!flag_emit_class_files
13049 && !flag_emit_xref
13050 && TREE_CODE (where_found) == VAR_DECL
13051 && FIELD_STATIC (where_found))
13052 {
13053 build_static_field_ref (where_found);
13054 field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
13055 }
13056 }
13057 else
13058 field_ref = decl;
13059
13060 if (field_decl)
13061 *field_decl = decl;
13062 if (field_type)
13063 *field_type = (QUAL_DECL_TYPE (decl) ?
13064 QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
13065 return field_ref;
13066 }
13067
13068 /* If NODE is an access to f static field, strip out the class
13069 initialization part and return the field decl, otherwise, return
13070 NODE. */
13071
13072 static tree
strip_out_static_field_access_decl(node)13073 strip_out_static_field_access_decl (node)
13074 tree node;
13075 {
13076 if (TREE_CODE (node) == COMPOUND_EXPR)
13077 {
13078 tree op1 = TREE_OPERAND (node, 1);
13079 if (TREE_CODE (op1) == COMPOUND_EXPR)
13080 {
13081 tree call = TREE_OPERAND (op1, 0);
13082 if (TREE_CODE (call) == CALL_EXPR
13083 && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
13084 && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
13085 == soft_initclass_node)
13086 return TREE_OPERAND (op1, 1);
13087 }
13088 else if (JDECL_P (op1))
13089 return op1;
13090 }
13091 return node;
13092 }
13093
13094 /* 6.5.5.2: Qualified Expression Names */
13095
13096 static int
resolve_qualified_expression_name(wfl,found_decl,where_found,type_found)13097 resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
13098 tree wfl;
13099 tree *found_decl, *type_found, *where_found;
13100 {
13101 int from_type = 0; /* Field search initiated from a type */
13102 int from_super = 0, from_cast = 0, from_qualified_this = 0;
13103 int previous_call_static = 0;
13104 int is_static;
13105 tree decl = NULL_TREE, type = NULL_TREE, q;
13106 /* For certain for of inner class instantiation */
13107 tree saved_current, saved_this;
13108 #define RESTORE_THIS_AND_CURRENT_CLASS \
13109 { current_class = saved_current; current_this = saved_this;}
13110
13111 *type_found = *where_found = NULL_TREE;
13112
13113 for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
13114 {
13115 tree qual_wfl = QUAL_WFL (q);
13116 tree ret_decl; /* for EH checking */
13117 int location; /* for EH checking */
13118
13119 /* 15.10.1 Field Access Using a Primary */
13120 switch (TREE_CODE (qual_wfl))
13121 {
13122 case CALL_EXPR:
13123 case NEW_CLASS_EXPR:
13124 /* If the access to the function call is a non static field,
13125 build the code to access it. */
13126 if (JDECL_P (decl) && !FIELD_STATIC (decl))
13127 {
13128 decl = maybe_access_field (decl, *where_found,
13129 DECL_CONTEXT (decl));
13130 if (decl == error_mark_node)
13131 return 1;
13132 }
13133
13134 /* And code for the function call */
13135 if (complete_function_arguments (qual_wfl))
13136 return 1;
13137
13138 /* We might have to setup a new current class and a new this
13139 for the search of an inner class, relative to the type of
13140 a expression resolved as `decl'. The current values are
13141 saved and restored shortly after */
13142 saved_current = current_class;
13143 saved_this = current_this;
13144 if (decl
13145 && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
13146 || from_qualified_this))
13147 {
13148 /* If we still have `from_qualified_this', we have the form
13149 <T>.this.f() and we need to build <T>.this */
13150 if (from_qualified_this)
13151 {
13152 decl = build_access_to_thisn (current_class, type, 0);
13153 decl = java_complete_tree (decl);
13154 type = TREE_TYPE (TREE_TYPE (decl));
13155 }
13156 current_class = type;
13157 current_this = decl;
13158 from_qualified_this = 0;
13159 }
13160
13161 if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
13162 CALL_USING_SUPER (qual_wfl) = 1;
13163 location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
13164 EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
13165 *where_found = patch_method_invocation (qual_wfl, decl, type,
13166 from_super,
13167 &is_static, &ret_decl);
13168 from_super = 0;
13169 if (*where_found == error_mark_node)
13170 {
13171 RESTORE_THIS_AND_CURRENT_CLASS;
13172 return 1;
13173 }
13174 *type_found = type = QUAL_DECL_TYPE (*where_found);
13175
13176 *where_found = force_evaluation_order (*where_found);
13177
13178 /* If we're creating an inner class instance, check for that
13179 an enclosing instance is in scope */
13180 if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
13181 && INNER_ENCLOSING_SCOPE_CHECK (type))
13182 {
13183 parse_error_context
13184 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
13185 lang_printable_name (type, 0),
13186 (!current_this ? "" :
13187 "; an explicit one must be provided when creating this inner class"));
13188 RESTORE_THIS_AND_CURRENT_CLASS;
13189 return 1;
13190 }
13191
13192 /* In case we had to change then to resolve a inner class
13193 instantiation using a primary qualified by a `new' */
13194 RESTORE_THIS_AND_CURRENT_CLASS;
13195
13196 /* EH check. No check on access$<n> functions */
13197 if (location
13198 && !OUTER_FIELD_ACCESS_IDENTIFIER_P
13199 (DECL_NAME (current_function_decl)))
13200 check_thrown_exceptions (location, ret_decl);
13201
13202 /* If the previous call was static and this one is too,
13203 build a compound expression to hold the two (because in
13204 that case, previous function calls aren't transported as
13205 forcoming function's argument. */
13206 if (previous_call_static && is_static)
13207 {
13208 decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
13209 decl, *where_found);
13210 TREE_SIDE_EFFECTS (decl) = 1;
13211 }
13212 else
13213 {
13214 previous_call_static = is_static;
13215 decl = *where_found;
13216 }
13217 from_type = 0;
13218 continue;
13219
13220 case NEW_ARRAY_EXPR:
13221 case NEW_ANONYMOUS_ARRAY_EXPR:
13222 *where_found = decl = java_complete_tree (qual_wfl);
13223 if (decl == error_mark_node)
13224 return 1;
13225 *type_found = type = QUAL_DECL_TYPE (decl);
13226 continue;
13227
13228 case CONVERT_EXPR:
13229 *where_found = decl = java_complete_tree (qual_wfl);
13230 if (decl == error_mark_node)
13231 return 1;
13232 *type_found = type = QUAL_DECL_TYPE (decl);
13233 from_cast = 1;
13234 continue;
13235
13236 case CONDITIONAL_EXPR:
13237 case STRING_CST:
13238 case MODIFY_EXPR:
13239 *where_found = decl = java_complete_tree (qual_wfl);
13240 if (decl == error_mark_node)
13241 return 1;
13242 *type_found = type = QUAL_DECL_TYPE (decl);
13243 continue;
13244
13245 case ARRAY_REF:
13246 /* If the access to the function call is a non static field,
13247 build the code to access it. */
13248 if (JDECL_P (decl) && !FIELD_STATIC (decl))
13249 {
13250 decl = maybe_access_field (decl, *where_found, type);
13251 if (decl == error_mark_node)
13252 return 1;
13253 }
13254 /* And code for the array reference expression */
13255 decl = java_complete_tree (qual_wfl);
13256 if (decl == error_mark_node)
13257 return 1;
13258 type = QUAL_DECL_TYPE (decl);
13259 continue;
13260
13261 case PLUS_EXPR:
13262 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
13263 return 1;
13264 if ((type = patch_string (decl)))
13265 decl = type;
13266 *where_found = QUAL_RESOLUTION (q) = decl;
13267 *type_found = type = TREE_TYPE (decl);
13268 break;
13269
13270 case CLASS_LITERAL:
13271 if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
13272 return 1;
13273 *where_found = QUAL_RESOLUTION (q) = decl;
13274 *type_found = type = TREE_TYPE (decl);
13275 break;
13276
13277 default:
13278 /* Fix for -Wall Just go to the next statement. Don't
13279 continue */
13280 break;
13281 }
13282
13283 /* If we fall here, we weren't processing a (static) function call. */
13284 previous_call_static = 0;
13285
13286 /* It can be the keyword THIS */
13287 if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
13288 && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
13289 {
13290 if (!current_this)
13291 {
13292 parse_error_context
13293 (wfl, "Keyword `this' used outside allowed context");
13294 return 1;
13295 }
13296 if (ctxp->explicit_constructor_p
13297 && type == current_class)
13298 {
13299 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
13300 return 1;
13301 }
13302 /* We have to generate code for intermediate access */
13303 if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
13304 {
13305 *where_found = decl = current_this;
13306 *type_found = type = QUAL_DECL_TYPE (decl);
13307 }
13308 /* We're trying to access the this from somewhere else. Make sure
13309 it's allowed before doing so. */
13310 else
13311 {
13312 if (!enclosing_context_p (type, current_class))
13313 {
13314 char *p = xstrdup (lang_printable_name (type, 0));
13315 parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
13316 p, p,
13317 lang_printable_name (current_class, 0));
13318 free (p);
13319 return 1;
13320 }
13321 from_qualified_this = 1;
13322 /* If there's nothing else after that, we need to
13323 produce something now, otherwise, the section of the
13324 code that needs to produce <T>.this will generate
13325 what is necessary. */
13326 if (!TREE_CHAIN (q))
13327 {
13328 decl = build_access_to_thisn (current_class, type, 0);
13329 *where_found = decl = java_complete_tree (decl);
13330 *type_found = type = TREE_TYPE (decl);
13331 }
13332 }
13333
13334 from_type = 0;
13335 continue;
13336 }
13337
13338 /* 15.10.2 Accessing Superclass Members using SUPER */
13339 if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
13340 && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
13341 {
13342 tree node;
13343 /* Check on the restricted use of SUPER */
13344 if (METHOD_STATIC (current_function_decl)
13345 || current_class == object_type_node)
13346 {
13347 parse_error_context
13348 (wfl, "Keyword `super' used outside allowed context");
13349 return 1;
13350 }
13351 /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
13352 node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
13353 CLASSTYPE_SUPER (current_class),
13354 build_this (EXPR_WFL_LINECOL (qual_wfl)));
13355 *where_found = decl = java_complete_tree (node);
13356 if (decl == error_mark_node)
13357 return 1;
13358 *type_found = type = QUAL_DECL_TYPE (decl);
13359 from_super = from_type = 1;
13360 continue;
13361 }
13362
13363 /* 15.13.1: Can't search for field name in packages, so we
13364 assume a variable/class name was meant. */
13365 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
13366 {
13367 tree name;
13368 if ((decl = resolve_package (wfl, &q, &name)))
13369 {
13370 tree list;
13371 *where_found = decl;
13372
13373 /* We want to be absolutely sure that the class is laid
13374 out. We're going to search something inside it. */
13375 *type_found = type = TREE_TYPE (decl);
13376 layout_class (type);
13377 from_type = 1;
13378
13379 /* Fix them all the way down, if any are left. */
13380 if (q)
13381 {
13382 list = TREE_CHAIN (q);
13383 while (list)
13384 {
13385 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (list)) = 1;
13386 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
13387 list = TREE_CHAIN (list);
13388 }
13389 }
13390 }
13391 else
13392 {
13393 if (from_super || from_cast)
13394 parse_error_context
13395 ((from_cast ? qual_wfl : wfl),
13396 "No variable `%s' defined in class `%s'",
13397 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
13398 lang_printable_name (type, 0));
13399 else
13400 parse_error_context
13401 (qual_wfl, "Undefined variable or class name: `%s'",
13402 IDENTIFIER_POINTER (name));
13403 return 1;
13404 }
13405 }
13406
13407 /* We have a type name. It's been already resolved when the
13408 expression was qualified. */
13409 else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
13410 {
13411 decl = QUAL_RESOLUTION (q);
13412
13413 /* Sneak preview. If next we see a `new', we're facing a
13414 qualification with resulted in a type being selected
13415 instead of a field. Report the error */
13416 if(TREE_CHAIN (q)
13417 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
13418 {
13419 parse_error_context (qual_wfl, "Undefined variable `%s'",
13420 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
13421 return 1;
13422 }
13423
13424 if (not_accessible_p (TREE_TYPE (decl), decl, type, 0))
13425 {
13426 parse_error_context
13427 (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
13428 java_accstring_lookup (get_access_flags_from_decl (decl)),
13429 GET_TYPE_NAME (type),
13430 IDENTIFIER_POINTER (DECL_NAME (decl)),
13431 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
13432 return 1;
13433 }
13434 check_deprecation (qual_wfl, decl);
13435
13436 type = TREE_TYPE (decl);
13437 from_type = 1;
13438 }
13439 /* We resolve an expression name */
13440 else
13441 {
13442 tree field_decl = NULL_TREE;
13443
13444 /* If there exists an early resolution, use it. That occurs
13445 only once and we know that there are more things to
13446 come. Don't do that when processing something after SUPER
13447 (we need more thing to be put in place below */
13448 if (!from_super && QUAL_RESOLUTION (q))
13449 {
13450 decl = QUAL_RESOLUTION (q);
13451 if (!type)
13452 {
13453 if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
13454 {
13455 if (current_this)
13456 *where_found = current_this;
13457 else
13458 {
13459 static_ref_err (qual_wfl, DECL_NAME (decl),
13460 current_class);
13461 return 1;
13462 }
13463 if (outer_field_access_p (current_class, decl))
13464 decl = build_outer_field_access (qual_wfl, decl);
13465 }
13466 else
13467 {
13468 *where_found = TREE_TYPE (decl);
13469 if (TREE_CODE (*where_found) == POINTER_TYPE)
13470 *where_found = TREE_TYPE (*where_found);
13471 }
13472 }
13473 }
13474
13475 /* Report and error if we're using a numerical litteral as a
13476 qualifier. It can only be an INTEGER_CST. */
13477 else if (TREE_CODE (qual_wfl) == INTEGER_CST)
13478 {
13479 parse_error_context
13480 (wfl, "Can't use type `%s' as a qualifier",
13481 lang_printable_name (TREE_TYPE (qual_wfl), 0));
13482 return 1;
13483 }
13484
13485 /* We have to search for a field, knowing the type of its
13486 container. The flag FROM_TYPE indicates that we resolved
13487 the last member of the expression as a type name, which
13488 means that for the resolution of this field, we'll look
13489 for other errors than if it was resolved as a member of
13490 an other field. */
13491 else
13492 {
13493 int is_static;
13494 tree field_decl_type; /* For layout */
13495
13496 if (!from_type && !JREFERENCE_TYPE_P (type))
13497 {
13498 parse_error_context
13499 (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
13500 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
13501 lang_printable_name (type, 0),
13502 IDENTIFIER_POINTER (DECL_NAME (decl)));
13503 return 1;
13504 }
13505
13506 field_decl = lookup_field_wrapper (type,
13507 EXPR_WFL_NODE (qual_wfl));
13508
13509 /* Maybe what we're trying to access to is an inner
13510 class, only if decl is a TYPE_DECL. */
13511 if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
13512 {
13513 tree ptr, inner_decl;
13514
13515 BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
13516 inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
13517 if (inner_decl)
13518 {
13519 check_inner_class_access (inner_decl, decl, qual_wfl);
13520 type = TREE_TYPE (inner_decl);
13521 decl = inner_decl;
13522 from_type = 1;
13523 continue;
13524 }
13525 }
13526
13527 if (field_decl == NULL_TREE)
13528 {
13529 parse_error_context
13530 (qual_wfl, "No variable `%s' defined in type `%s'",
13531 IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
13532 GET_TYPE_NAME (type));
13533 return 1;
13534 }
13535 if (field_decl == error_mark_node)
13536 return 1;
13537
13538 /* Layout the type of field_decl, since we may need
13539 it. Don't do primitive types or loaded classes. The
13540 situation of non primitive arrays may not handled
13541 properly here. FIXME */
13542 if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
13543 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
13544 else
13545 field_decl_type = TREE_TYPE (field_decl);
13546 if (!JPRIMITIVE_TYPE_P (field_decl_type)
13547 && !CLASS_LOADED_P (field_decl_type)
13548 && !TYPE_ARRAY_P (field_decl_type))
13549 resolve_and_layout (field_decl_type, NULL_TREE);
13550
13551 /* Check on accessibility here */
13552 if (not_accessible_p (current_class, field_decl,
13553 DECL_CONTEXT (field_decl), from_super))
13554 {
13555 parse_error_context
13556 (qual_wfl,
13557 "Can't access %s field `%s.%s' from `%s'",
13558 java_accstring_lookup
13559 (get_access_flags_from_decl (field_decl)),
13560 GET_TYPE_NAME (type),
13561 IDENTIFIER_POINTER (DECL_NAME (field_decl)),
13562 IDENTIFIER_POINTER
13563 (DECL_NAME (TYPE_NAME (current_class))));
13564 return 1;
13565 }
13566 check_deprecation (qual_wfl, field_decl);
13567
13568 /* There are things to check when fields are accessed
13569 from type. There are no restrictions on a static
13570 declaration of the field when it is accessed from an
13571 interface */
13572 is_static = FIELD_STATIC (field_decl);
13573 if (!from_super && from_type
13574 && !TYPE_INTERFACE_P (type)
13575 && !is_static
13576 && (current_function_decl
13577 && METHOD_STATIC (current_function_decl)))
13578 {
13579 static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
13580 return 1;
13581 }
13582 from_cast = from_super = 0;
13583
13584 /* It's an access from a type but it isn't static, we
13585 make it relative to `this'. */
13586 if (!is_static && from_type)
13587 decl = current_this;
13588
13589 /* If we need to generate something to get a proper
13590 handle on what this field is accessed from, do it
13591 now. */
13592 if (!is_static)
13593 {
13594 decl = maybe_access_field (decl, *where_found, *type_found);
13595 if (decl == error_mark_node)
13596 return 1;
13597 }
13598
13599 /* We want to keep the location were found it, and the type
13600 we found. */
13601 *where_found = decl;
13602 *type_found = type;
13603
13604 /* Generate the correct expression for field access from
13605 qualified this */
13606 if (from_qualified_this)
13607 {
13608 field_decl = build_outer_field_access (qual_wfl, field_decl);
13609 from_qualified_this = 0;
13610 }
13611
13612 /* This is the decl found and eventually the next one to
13613 search from */
13614 decl = field_decl;
13615 }
13616 from_type = 0;
13617 type = QUAL_DECL_TYPE (decl);
13618
13619 /* Sneak preview. If decl is qualified by a `new', report
13620 the error here to be accurate on the peculiar construct */
13621 if (TREE_CHAIN (q)
13622 && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
13623 && !JREFERENCE_TYPE_P (type))
13624 {
13625 parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
13626 lang_printable_name (type, 0));
13627 return 1;
13628 }
13629 }
13630 /* `q' might have changed due to a after package resolution
13631 re-qualification */
13632 if (!q)
13633 break;
13634 }
13635 *found_decl = decl;
13636 return 0;
13637 }
13638
13639 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
13640 can't be accessed from REFERENCE (a record type). If MEMBER
13641 features a protected access, we then use WHERE which, if non null,
13642 holds the type of MEMBER's access that is checked against
13643 6.6.2.1. This function should be used when decl is a field or a
13644 method. */
13645
13646 static int
not_accessible_p(reference,member,where,from_super)13647 not_accessible_p (reference, member, where, from_super)
13648 tree reference, member;
13649 tree where;
13650 int from_super;
13651 {
13652 int access_flag = get_access_flags_from_decl (member);
13653
13654 /* Inner classes are processed by check_inner_class_access */
13655 if (INNER_CLASS_TYPE_P (reference))
13656 return 0;
13657
13658 /* Access always granted for members declared public */
13659 if (access_flag & ACC_PUBLIC)
13660 return 0;
13661
13662 /* Check access on protected members */
13663 if (access_flag & ACC_PROTECTED)
13664 {
13665 /* Access granted if it occurs from within the package
13666 containing the class in which the protected member is
13667 declared */
13668 if (class_in_current_package (DECL_CONTEXT (member)))
13669 return 0;
13670
13671 /* If accessed with the form `super.member', then access is granted */
13672 if (from_super)
13673 return 0;
13674
13675 /* If where is active, access was made through a
13676 qualifier. Access is granted if the type of the qualifier is
13677 or is a sublass of the type the access made from (6.6.2.1.) */
13678 if (where && !inherits_from_p (reference, where))
13679 return 1;
13680
13681 /* Otherwise, access is granted if occurring from the class where
13682 member is declared or a subclass of it. Find the right
13683 context to perform the check */
13684 if (PURE_INNER_CLASS_TYPE_P (reference))
13685 {
13686 while (INNER_CLASS_TYPE_P (reference))
13687 {
13688 if (inherits_from_p (reference, DECL_CONTEXT (member)))
13689 return 0;
13690 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
13691 }
13692 }
13693 if (inherits_from_p (reference, DECL_CONTEXT (member)))
13694 return 0;
13695 return 1;
13696 }
13697
13698 /* Check access on private members. Access is granted only if it
13699 occurs from within the class in which it is declared -- that does
13700 it for innerclasses too. */
13701 if (access_flag & ACC_PRIVATE)
13702 {
13703 if (reference == DECL_CONTEXT (member))
13704 return 0;
13705 if (enclosing_context_p (reference, DECL_CONTEXT (member)))
13706 return 0;
13707 return 1;
13708 }
13709
13710 /* Default access are permitted only when occurring within the
13711 package in which the type (REFERENCE) is declared. In other words,
13712 REFERENCE is defined in the current package */
13713 if (ctxp->package)
13714 return !class_in_current_package (reference);
13715
13716 /* Otherwise, access is granted */
13717 return 0;
13718 }
13719
13720 /* Test deprecated decl access. */
13721 static void
check_deprecation(wfl,decl)13722 check_deprecation (wfl, decl)
13723 tree wfl, decl;
13724 {
13725 const char *file = DECL_SOURCE_FILE (decl);
13726 /* Complain if the field is deprecated and the file it was defined
13727 in isn't compiled at the same time the file which contains its
13728 use is */
13729 if (DECL_DEPRECATED (decl)
13730 && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
13731 {
13732 char the [20];
13733 switch (TREE_CODE (decl))
13734 {
13735 case FUNCTION_DECL:
13736 strcpy (the, "method");
13737 break;
13738 case FIELD_DECL:
13739 case VAR_DECL:
13740 strcpy (the, "field");
13741 break;
13742 case TYPE_DECL:
13743 parse_warning_context (wfl, "The class `%s' has been deprecated",
13744 IDENTIFIER_POINTER (DECL_NAME (decl)));
13745 return;
13746 default:
13747 abort ();
13748 }
13749 /* Don't issue a message if the context as been deprecated as a
13750 whole. */
13751 if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
13752 parse_warning_context
13753 (wfl, "The %s `%s' in class `%s' has been deprecated",
13754 the, lang_printable_name (decl, 0),
13755 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
13756 }
13757 }
13758
13759 /* Returns 1 if class was declared in the current package, 0 otherwise */
13760
13761 static GTY(()) tree cicp_cache;
13762 static int
class_in_current_package(class)13763 class_in_current_package (class)
13764 tree class;
13765 {
13766 int qualified_flag;
13767 tree left;
13768
13769 if (cicp_cache == class)
13770 return 1;
13771
13772 qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
13773
13774 /* If the current package is empty and the name of CLASS is
13775 qualified, class isn't in the current package. If there is a
13776 current package and the name of the CLASS is not qualified, class
13777 isn't in the current package */
13778 if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
13779 return 0;
13780
13781 /* If there is not package and the name of CLASS isn't qualified,
13782 they belong to the same unnamed package */
13783 if (!ctxp->package && !qualified_flag)
13784 return 1;
13785
13786 /* Compare the left part of the name of CLASS with the package name */
13787 breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
13788 if (ctxp->package == left)
13789 {
13790 cicp_cache = class;
13791 return 1;
13792 }
13793 return 0;
13794 }
13795
13796 /* This function may generate code to access DECL from WHERE. This is
13797 done only if certain conditions meet. */
13798
13799 static tree
maybe_access_field(decl,where,type)13800 maybe_access_field (decl, where, type)
13801 tree decl, where, type;
13802 {
13803 if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
13804 && !FIELD_STATIC (decl))
13805 decl = build_field_ref (where ? where : current_this,
13806 (type ? type : DECL_CONTEXT (decl)),
13807 DECL_NAME (decl));
13808 return decl;
13809 }
13810
13811 /* Build a method invocation, by patching PATCH. If non NULL
13812 and according to the situation, PRIMARY and WHERE may be
13813 used. IS_STATIC is set to 1 if the invoked function is static. */
13814
13815 static tree
patch_method_invocation(patch,primary,where,from_super,is_static,ret_decl)13816 patch_method_invocation (patch, primary, where, from_super,
13817 is_static, ret_decl)
13818 tree patch, primary, where;
13819 int from_super;
13820 int *is_static;
13821 tree *ret_decl;
13822 {
13823 tree wfl = TREE_OPERAND (patch, 0);
13824 tree args = TREE_OPERAND (patch, 1);
13825 tree name = EXPR_WFL_NODE (wfl);
13826 tree list;
13827 int is_static_flag = 0;
13828 int is_super_init = 0;
13829 tree this_arg = NULL_TREE;
13830 int is_array_clone_call = 0;
13831
13832 /* Should be overriden if everything goes well. Otherwise, if
13833 something fails, it should keep this value. It stop the
13834 evaluation of a bogus assignment. See java_complete_tree,
13835 MODIFY_EXPR: for the reasons why we sometimes want to keep on
13836 evaluating an assignment */
13837 TREE_TYPE (patch) = error_mark_node;
13838
13839 /* Since lookup functions are messing with line numbers, save the
13840 context now. */
13841 java_parser_context_save_global ();
13842
13843 /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
13844
13845 /* Resolution of qualified name, excluding constructors */
13846 if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
13847 {
13848 tree identifier, identifier_wfl, type, resolved;
13849 /* Extract the last IDENTIFIER of the qualified
13850 expression. This is a wfl and we will use it's location
13851 data during error report. */
13852 identifier_wfl = cut_identifier_in_qualified (wfl);
13853 identifier = EXPR_WFL_NODE (identifier_wfl);
13854
13855 /* Given the context, IDENTIFIER is syntactically qualified
13856 as a MethodName. We need to qualify what's before */
13857 qualify_ambiguous_name (wfl);
13858 resolved = resolve_field_access (wfl, NULL, NULL);
13859
13860 if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
13861 && FIELD_FINAL (resolved)
13862 && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
13863 && !flag_emit_class_files && !flag_emit_xref)
13864 resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
13865
13866 if (resolved == error_mark_node)
13867 PATCH_METHOD_RETURN_ERROR ();
13868
13869 type = GET_SKIP_TYPE (resolved);
13870 resolve_and_layout (type, NULL_TREE);
13871
13872 if (JPRIMITIVE_TYPE_P (type))
13873 {
13874 parse_error_context
13875 (identifier_wfl,
13876 "Can't invoke a method on primitive type `%s'",
13877 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
13878 PATCH_METHOD_RETURN_ERROR ();
13879 }
13880
13881 list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
13882 args = nreverse (args);
13883
13884 /* We're resolving a call from a type */
13885 if (TREE_CODE (resolved) == TYPE_DECL)
13886 {
13887 if (CLASS_INTERFACE (resolved))
13888 {
13889 parse_error_context
13890 (identifier_wfl,
13891 "Can't make static reference to method `%s' in interface `%s'",
13892 IDENTIFIER_POINTER (identifier),
13893 IDENTIFIER_POINTER (name));
13894 PATCH_METHOD_RETURN_ERROR ();
13895 }
13896 if (list && !METHOD_STATIC (list))
13897 {
13898 char *fct_name = xstrdup (lang_printable_name (list, 0));
13899 parse_error_context
13900 (identifier_wfl,
13901 "Can't make static reference to method `%s %s' in class `%s'",
13902 lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
13903 fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
13904 free (fct_name);
13905 PATCH_METHOD_RETURN_ERROR ();
13906 }
13907 }
13908 else
13909 this_arg = primary = resolved;
13910
13911 if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
13912 is_array_clone_call = 1;
13913
13914 /* IDENTIFIER_WFL will be used to report any problem further */
13915 wfl = identifier_wfl;
13916 }
13917 /* Resolution of simple names, names generated after a primary: or
13918 constructors */
13919 else
13920 {
13921 tree class_to_search = NULL_TREE;
13922 int lc; /* Looking for Constructor */
13923
13924 /* We search constructor in their target class */
13925 if (CALL_CONSTRUCTOR_P (patch))
13926 {
13927 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
13928 class_to_search = EXPR_WFL_NODE (wfl);
13929 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
13930 this_identifier_node)
13931 class_to_search = NULL_TREE;
13932 else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
13933 super_identifier_node)
13934 {
13935 is_super_init = 1;
13936 if (CLASSTYPE_SUPER (current_class))
13937 class_to_search =
13938 DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
13939 else
13940 {
13941 parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
13942 PATCH_METHOD_RETURN_ERROR ();
13943 }
13944 }
13945
13946 /* Class to search is NULL if we're searching the current one */
13947 if (class_to_search)
13948 {
13949 class_to_search = resolve_and_layout (class_to_search, wfl);
13950
13951 if (!class_to_search)
13952 {
13953 parse_error_context
13954 (wfl, "Class `%s' not found in type declaration",
13955 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
13956 PATCH_METHOD_RETURN_ERROR ();
13957 }
13958
13959 /* Can't instantiate an abstract class, but we can
13960 invoke it's constructor. It's use within the `new'
13961 context is denied here. */
13962 if (CLASS_ABSTRACT (class_to_search)
13963 && TREE_CODE (patch) == NEW_CLASS_EXPR)
13964 {
13965 parse_error_context
13966 (wfl, "Class `%s' is an abstract class. It can't be instantiated",
13967 IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
13968 PATCH_METHOD_RETURN_ERROR ();
13969 }
13970
13971 class_to_search = TREE_TYPE (class_to_search);
13972 }
13973 else
13974 class_to_search = current_class;
13975 lc = 1;
13976 }
13977 /* This is a regular search in the local class, unless an
13978 alternate class is specified. */
13979 else
13980 {
13981 if (where != NULL_TREE)
13982 class_to_search = where;
13983 else if (QUALIFIED_P (name))
13984 class_to_search = current_class;
13985 else
13986 {
13987 class_to_search = current_class;
13988
13989 for (;;)
13990 {
13991 if (has_method (class_to_search, name))
13992 break;
13993 if (! INNER_CLASS_TYPE_P (class_to_search))
13994 {
13995 parse_error_context (wfl,
13996 "No method named `%s' in scope",
13997 IDENTIFIER_POINTER (name));
13998 PATCH_METHOD_RETURN_ERROR ();
13999 }
14000 class_to_search
14001 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
14002 }
14003 }
14004 lc = 0;
14005 }
14006
14007 /* NAME is a simple identifier or comes from a primary. Search
14008 in the class whose declaration contain the method being
14009 invoked. */
14010 resolve_and_layout (class_to_search, NULL_TREE);
14011
14012 list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
14013 /* Don't continue if no method were found, as the next statement
14014 can't be executed then. */
14015 if (!list)
14016 PATCH_METHOD_RETURN_ERROR ();
14017
14018 if (TYPE_ARRAY_P (class_to_search)
14019 && DECL_NAME (list) == get_identifier ("clone"))
14020 is_array_clone_call = 1;
14021
14022 /* Check for static reference if non static methods */
14023 if (check_for_static_method_reference (wfl, patch, list,
14024 class_to_search, primary))
14025 PATCH_METHOD_RETURN_ERROR ();
14026
14027 /* Check for inner classes creation from illegal contexts */
14028 if (lc && (INNER_CLASS_TYPE_P (class_to_search)
14029 && !CLASS_STATIC (TYPE_NAME (class_to_search)))
14030 && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
14031 && !DECL_INIT_P (current_function_decl))
14032 {
14033 parse_error_context
14034 (wfl, "No enclosing instance for inner class `%s' is in scope%s",
14035 lang_printable_name (class_to_search, 0),
14036 (!current_this ? "" :
14037 "; an explicit one must be provided when creating this inner class"));
14038 PATCH_METHOD_RETURN_ERROR ();
14039 }
14040
14041 /* Non static methods are called with the current object extra
14042 argument. If patch a `new TYPE()', the argument is the value
14043 returned by the object allocator. If method is resolved as a
14044 primary, use the primary otherwise use the current THIS. */
14045 args = nreverse (args);
14046 if (TREE_CODE (patch) != NEW_CLASS_EXPR)
14047 {
14048 this_arg = primary ? primary : current_this;
14049
14050 /* If we're using an access method, things are different.
14051 There are two familly of cases:
14052
14053 1) We're not generating bytecodes:
14054
14055 - LIST is non static. It's invocation is transformed from
14056 x(a1,...,an) into this$<n>.x(a1,....an).
14057 - LIST is static. It's invocation is transformed from
14058 x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
14059
14060 2) We're generating bytecodes:
14061
14062 - LIST is non static. It's invocation is transformed from
14063 x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
14064 - LIST is static. It's invocation is transformed from
14065 x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
14066
14067 Of course, this$<n> can be abitrary complex, ranging from
14068 this$0 (the immediate outer context) to
14069 access$0(access$0(...(this$0))).
14070
14071 maybe_use_access_method returns a nonzero value if the
14072 this_arg has to be moved into the (then generated) stub
14073 argument list. In the meantime, the selected function
14074 might have be replaced by a generated stub. */
14075 if (!primary &&
14076 maybe_use_access_method (is_super_init, &list, &this_arg))
14077 {
14078 args = tree_cons (NULL_TREE, this_arg, args);
14079 this_arg = NULL_TREE; /* So it doesn't get chained twice */
14080 }
14081 }
14082 }
14083
14084 /* Merge point of all resolution schemes. If we have nothing, this
14085 is an error, already signaled */
14086 if (!list)
14087 PATCH_METHOD_RETURN_ERROR ();
14088
14089 /* Check accessibility, position the is_static flag, build and
14090 return the call */
14091 if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
14092 (primary ? TREE_TYPE (TREE_TYPE (primary)) :
14093 NULL_TREE), from_super)
14094 /* Calls to clone() on array types are permitted as a special-case. */
14095 && !is_array_clone_call)
14096 {
14097 const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
14098 const char *const access =
14099 java_accstring_lookup (get_access_flags_from_decl (list));
14100 const char *const klass =
14101 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
14102 const char *const refklass =
14103 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
14104 const char *const what = (DECL_CONSTRUCTOR_P (list)
14105 ? "constructor" : "method");
14106 /* FIXME: WFL yields the wrong message here but I don't know
14107 what else to use. */
14108 parse_error_context (wfl,
14109 "Can't access %s %s `%s.%s' from `%s'",
14110 access, what, klass, fct_name, refklass);
14111 PATCH_METHOD_RETURN_ERROR ();
14112 }
14113
14114 /* Deprecation check: check whether the method being invoked or the
14115 instance-being-created's type are deprecated. */
14116 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
14117 check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
14118 else
14119 check_deprecation (wfl, list);
14120
14121 /* If invoking a innerclass constructor, there are hidden parameters
14122 to pass */
14123 if (TREE_CODE (patch) == NEW_CLASS_EXPR
14124 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
14125 {
14126 /* And make sure we add the accessed local variables to be saved
14127 in field aliases. */
14128 args = build_alias_initializer_parameter_list
14129 (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
14130
14131 /* Secretly pass the current_this/primary as a second argument */
14132 if (primary || current_this)
14133 {
14134 tree extra_arg;
14135 tree this_type = (current_this ?
14136 TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
14137 /* Method's (list) enclosing context */
14138 tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
14139 /* If we have a primary, use it. */
14140 if (primary)
14141 extra_arg = primary;
14142 /* The current `this' is an inner class but isn't a direct
14143 enclosing context for the inner class we're trying to
14144 create. Build an access to the proper enclosing context
14145 and use it. */
14146 else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
14147 && this_type != TREE_TYPE (mec))
14148 {
14149
14150 extra_arg = build_access_to_thisn (current_class,
14151 TREE_TYPE (mec), 0);
14152 extra_arg = java_complete_tree (extra_arg);
14153 }
14154 /* Otherwise, just use the current `this' as an enclosing
14155 context. */
14156 else
14157 extra_arg = current_this;
14158 args = tree_cons (NULL_TREE, extra_arg, args);
14159 }
14160 else
14161 args = tree_cons (NULL_TREE, integer_zero_node, args);
14162 }
14163
14164 /* This handles the situation where a constructor invocation needs
14165 to have an enclosing context passed as a second parameter (the
14166 constructor is one of an inner class). */
14167 if ((is_super_init ||
14168 (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
14169 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
14170 {
14171 tree dest = TYPE_NAME (DECL_CONTEXT (list));
14172 tree extra_arg =
14173 build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
14174 extra_arg = java_complete_tree (extra_arg);
14175 args = tree_cons (NULL_TREE, extra_arg, args);
14176 }
14177
14178 is_static_flag = METHOD_STATIC (list);
14179 if (! is_static_flag && this_arg != NULL_TREE)
14180 args = tree_cons (NULL_TREE, this_arg, args);
14181
14182 /* In the context of an explicit constructor invocation, we can't
14183 invoke any method relying on `this'. Exceptions are: we're
14184 invoking a static function, primary exists and is not the current
14185 this, we're creating a new object. */
14186 if (ctxp->explicit_constructor_p
14187 && !is_static_flag
14188 && (!primary || primary == current_this)
14189 && (TREE_CODE (patch) != NEW_CLASS_EXPR))
14190 {
14191 parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
14192 PATCH_METHOD_RETURN_ERROR ();
14193 }
14194 java_parser_context_restore_global ();
14195 if (is_static)
14196 *is_static = is_static_flag;
14197 /* Sometimes, we want the decl of the selected method. Such as for
14198 EH checking */
14199 if (ret_decl)
14200 *ret_decl = list;
14201 patch = patch_invoke (patch, list, args);
14202
14203 /* Now is a good time to insert the call to finit$ */
14204 if (is_super_init && CLASS_HAS_FINIT_P (current_class))
14205 {
14206 tree finit_parms, finit_call;
14207
14208 /* Prepare to pass hidden parameters to finit$, if any. */
14209 finit_parms = build_alias_initializer_parameter_list
14210 (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
14211
14212 finit_call =
14213 build_method_invocation (build_wfl_node (finit_identifier_node),
14214 finit_parms);
14215
14216 /* Generate the code used to initialize fields declared with an
14217 initialization statement and build a compound statement along
14218 with the super constructor invocation. */
14219 CAN_COMPLETE_NORMALLY (patch) = 1;
14220 patch = build (COMPOUND_EXPR, void_type_node, patch,
14221 java_complete_tree (finit_call));
14222 }
14223 return patch;
14224 }
14225
14226 /* Check that we're not trying to do a static reference to a method in
14227 non static method. Return 1 if it's the case, 0 otherwise. */
14228
14229 static int
check_for_static_method_reference(wfl,node,method,where,primary)14230 check_for_static_method_reference (wfl, node, method, where, primary)
14231 tree wfl, node, method, where, primary;
14232 {
14233 if (METHOD_STATIC (current_function_decl)
14234 && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
14235 {
14236 char *fct_name = xstrdup (lang_printable_name (method, 0));
14237 parse_error_context
14238 (wfl, "Can't make static reference to method `%s %s' in class `%s'",
14239 lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
14240 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
14241 free (fct_name);
14242 return 1;
14243 }
14244 return 0;
14245 }
14246
14247 /* Fix the invocation of *MDECL if necessary in the case of a
14248 invocation from an inner class. *THIS_ARG might be modified
14249 appropriately and an alternative access to *MDECL might be
14250 returned. */
14251
14252 static int
maybe_use_access_method(is_super_init,mdecl,this_arg)14253 maybe_use_access_method (is_super_init, mdecl, this_arg)
14254 int is_super_init;
14255 tree *mdecl, *this_arg;
14256 {
14257 tree ctx;
14258 tree md = *mdecl, ta = *this_arg;
14259 int to_return = 0;
14260 int non_static_context = !METHOD_STATIC (md);
14261
14262 if (is_super_init
14263 || DECL_CONTEXT (md) == current_class
14264 || !PURE_INNER_CLASS_TYPE_P (current_class)
14265 || DECL_FINIT_P (md)
14266 || DECL_INSTINIT_P (md))
14267 return 0;
14268
14269 /* If we're calling a method found in an enclosing class, generate
14270 what it takes to retrieve the right this. Don't do that if we're
14271 invoking a static method. Note that if MD's type is unrelated to
14272 CURRENT_CLASS, then the current this can be used. */
14273
14274 if (non_static_context && DECL_CONTEXT (md) != object_type_node)
14275 {
14276 ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
14277 if (inherits_from_p (ctx, DECL_CONTEXT (md)))
14278 {
14279 ta = build_current_thisn (current_class);
14280 ta = build_wfl_node (ta);
14281 }
14282 else
14283 {
14284 tree type = ctx;
14285 while (type)
14286 {
14287 maybe_build_thisn_access_method (type);
14288 if (inherits_from_p (type, DECL_CONTEXT (md)))
14289 {
14290 ta = build_access_to_thisn (ctx, type, 0);
14291 break;
14292 }
14293 type = (DECL_CONTEXT (TYPE_NAME (type)) ?
14294 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
14295 }
14296 }
14297 ta = java_complete_tree (ta);
14298 }
14299
14300 /* We might have to use an access method to get to MD. We can
14301 break the method access rule as far as we're not generating
14302 bytecode */
14303 if (METHOD_PRIVATE (md) && flag_emit_class_files)
14304 {
14305 md = build_outer_method_access_method (md);
14306 to_return = 1;
14307 }
14308
14309 *mdecl = md;
14310 *this_arg = ta;
14311
14312 /* Returnin a nonzero value indicates we were doing a non static
14313 method invokation that is now a static invocation. It will have
14314 callee displace `this' to insert it in the regular argument
14315 list. */
14316 return (non_static_context && to_return);
14317 }
14318
14319 /* Patch an invoke expression METHOD and ARGS, based on its invocation
14320 mode. */
14321
14322 static tree
patch_invoke(patch,method,args)14323 patch_invoke (patch, method, args)
14324 tree patch, method, args;
14325 {
14326 tree dtable, func;
14327 tree original_call, t, ta;
14328 tree check = NULL_TREE;
14329
14330 /* Last step for args: convert build-in types. If we're dealing with
14331 a new TYPE() type call, the first argument to the constructor
14332 isn't found in the incoming argument list, but delivered by
14333 `new' */
14334 t = TYPE_ARG_TYPES (TREE_TYPE (method));
14335 if (TREE_CODE (patch) == NEW_CLASS_EXPR)
14336 t = TREE_CHAIN (t);
14337 for (ta = args; t != end_params_node && ta;
14338 t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
14339 if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
14340 TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
14341 TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
14342
14343 /* Resolve unresolved returned type isses */
14344 t = TREE_TYPE (TREE_TYPE (method));
14345 if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
14346 resolve_and_layout (TREE_TYPE (t), NULL);
14347
14348 if (flag_emit_class_files || flag_emit_xref)
14349 func = method;
14350 else
14351 {
14352 switch (invocation_mode (method, CALL_USING_SUPER (patch)))
14353 {
14354 case INVOKE_VIRTUAL:
14355 dtable = invoke_build_dtable (0, args);
14356 func = build_invokevirtual (dtable, method);
14357 break;
14358
14359 case INVOKE_NONVIRTUAL:
14360 /* If the object for the method call is null, we throw an
14361 exception. We don't do this if the object is the current
14362 method's `this'. In other cases we just rely on an
14363 optimization pass to eliminate redundant checks. */
14364 if (TREE_VALUE (args) != current_this)
14365 {
14366 /* We use a save_expr here to make sure we only evaluate
14367 the new `self' expression once. */
14368 tree save_arg = save_expr (TREE_VALUE (args));
14369 TREE_VALUE (args) = save_arg;
14370 check = java_check_reference (save_arg, 1);
14371 }
14372 /* Fall through. */
14373
14374 case INVOKE_SUPER:
14375 case INVOKE_STATIC:
14376 {
14377 tree signature = build_java_signature (TREE_TYPE (method));
14378 func = build_known_method_ref (method, TREE_TYPE (method),
14379 DECL_CONTEXT (method),
14380 signature, args);
14381 }
14382 break;
14383
14384 case INVOKE_INTERFACE:
14385 dtable = invoke_build_dtable (1, args);
14386 func = build_invokeinterface (dtable, method);
14387 break;
14388
14389 default:
14390 abort ();
14391 }
14392
14393 /* Ensure self_type is initialized, (invokestatic). FIXME */
14394 func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
14395 }
14396
14397 TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
14398 TREE_OPERAND (patch, 0) = func;
14399 TREE_OPERAND (patch, 1) = args;
14400 patch = check_for_builtin (method, patch);
14401 original_call = patch;
14402
14403 /* We're processing a `new TYPE ()' form. New is called and its
14404 returned value is the first argument to the constructor. We build
14405 a COMPOUND_EXPR and use saved expression so that the overall NEW
14406 expression value is a pointer to a newly created and initialized
14407 class. */
14408 if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
14409 {
14410 tree class = DECL_CONTEXT (method);
14411 tree c1, saved_new, size, new;
14412 tree alloc_node;
14413
14414 if (flag_emit_class_files || flag_emit_xref)
14415 {
14416 TREE_TYPE (patch) = build_pointer_type (class);
14417 return patch;
14418 }
14419 if (!TYPE_SIZE (class))
14420 safe_layout_class (class);
14421 size = size_in_bytes (class);
14422 alloc_node =
14423 (class_has_finalize_method (class) ? alloc_object_node
14424 : alloc_no_finalizer_node);
14425 new = build (CALL_EXPR, promote_type (class),
14426 build_address_of (alloc_node),
14427 tree_cons (NULL_TREE, build_class_ref (class),
14428 build_tree_list (NULL_TREE,
14429 size_in_bytes (class))),
14430 NULL_TREE);
14431 saved_new = save_expr (new);
14432 c1 = build_tree_list (NULL_TREE, saved_new);
14433 TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
14434 TREE_OPERAND (original_call, 1) = c1;
14435 TREE_SET_CODE (original_call, CALL_EXPR);
14436 patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
14437 }
14438
14439 /* If CHECK is set, then we are building a check to see if the object
14440 is NULL. */
14441 if (check != NULL_TREE)
14442 {
14443 /* We have to call force_evaluation_order now because creating a
14444 COMPOUND_EXPR wraps the arg list in a way that makes it
14445 unrecognizable by force_evaluation_order later. Yuk. */
14446 patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
14447 force_evaluation_order (patch));
14448 TREE_SIDE_EFFECTS (patch) = 1;
14449 }
14450
14451 /* In order to be able to modify PATCH later, we SAVE_EXPR it and
14452 put it as the first expression of a COMPOUND_EXPR. The second
14453 expression being an empty statement to be later patched if
14454 necessary. We remember a TREE_LIST (the PURPOSE is the method,
14455 the VALUE is the compound) in a hashtable and return a
14456 COMPOUND_EXPR built so that the result of the evaluation of the
14457 original PATCH node is returned. */
14458 if (STATIC_CLASS_INIT_OPT_P ()
14459 && current_function_decl && METHOD_STATIC (method))
14460 {
14461 tree list;
14462 tree fndecl = current_function_decl;
14463 /* We have to call force_evaluation_order now because creating a
14464 COMPOUND_EXPR wraps the arg list in a way that makes it
14465 unrecognizable by force_evaluation_order later. Yuk. */
14466 tree save = save_expr (force_evaluation_order (patch));
14467 tree type = TREE_TYPE (patch);
14468
14469 patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
14470 list = tree_cons (method, patch,
14471 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
14472
14473 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
14474
14475 patch = build (COMPOUND_EXPR, type, patch, save);
14476 }
14477
14478 return patch;
14479 }
14480
14481 static int
invocation_mode(method,super)14482 invocation_mode (method, super)
14483 tree method;
14484 int super;
14485 {
14486 int access = get_access_flags_from_decl (method);
14487
14488 if (super)
14489 return INVOKE_SUPER;
14490
14491 if (access & ACC_STATIC)
14492 return INVOKE_STATIC;
14493
14494 /* We have to look for a constructor before we handle nonvirtual
14495 calls; otherwise the constructor will look nonvirtual. */
14496 if (DECL_CONSTRUCTOR_P (method))
14497 return INVOKE_STATIC;
14498
14499 if (access & ACC_FINAL || access & ACC_PRIVATE)
14500 return INVOKE_NONVIRTUAL;
14501
14502 if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
14503 return INVOKE_NONVIRTUAL;
14504
14505 if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
14506 return INVOKE_INTERFACE;
14507
14508 return INVOKE_VIRTUAL;
14509 }
14510
14511 /* Retrieve a refined list of matching methods. It covers the step
14512 15.11.2 (Compile-Time Step 2) */
14513
14514 static tree
lookup_method_invoke(lc,cl,class,name,arg_list)14515 lookup_method_invoke (lc, cl, class, name, arg_list)
14516 int lc;
14517 tree cl;
14518 tree class, name, arg_list;
14519 {
14520 tree atl = end_params_node; /* Arg Type List */
14521 tree method, signature, list, node;
14522 const char *candidates; /* Used for error report */
14523 char *dup;
14524
14525 /* Fix the arguments */
14526 for (node = arg_list; node; node = TREE_CHAIN (node))
14527 {
14528 tree current_arg = TREE_TYPE (TREE_VALUE (node));
14529 /* Non primitive type may have to be resolved */
14530 if (!JPRIMITIVE_TYPE_P (current_arg))
14531 resolve_and_layout (current_arg, NULL_TREE);
14532 /* And promoted */
14533 if (TREE_CODE (current_arg) == RECORD_TYPE)
14534 current_arg = promote_type (current_arg);
14535 atl = tree_cons (NULL_TREE, current_arg, atl);
14536 }
14537
14538 /* Presto. If we're dealing with an anonymous class and a
14539 constructor call, generate the right constructor now, since we
14540 know the arguments' types. */
14541
14542 if (lc && ANONYMOUS_CLASS_P (class))
14543 {
14544 tree saved_current_class;
14545 tree mdecl = craft_constructor (TYPE_NAME (class), atl);
14546 saved_current_class = current_class;
14547 current_class = class;
14548 fix_constructors (mdecl);
14549 current_class = saved_current_class;
14550 }
14551
14552 /* Find all candidates and then refine the list, searching for the
14553 most specific method. */
14554 list = find_applicable_accessible_methods_list (lc, class, name, atl);
14555 list = find_most_specific_methods_list (list);
14556 if (list && !TREE_CHAIN (list))
14557 return TREE_VALUE (list);
14558
14559 /* Issue an error. List candidates if any. Candidates are listed
14560 only if accessible (non accessible methods may end-up here for
14561 the sake of a better error report). */
14562 candidates = NULL;
14563 if (list)
14564 {
14565 tree current;
14566 obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
14567 for (current = list; current; current = TREE_CHAIN (current))
14568 {
14569 tree cm = TREE_VALUE (current);
14570 char string [4096];
14571 if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
14572 continue;
14573 sprintf
14574 (string, " `%s' in `%s'%s",
14575 get_printable_method_name (cm),
14576 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
14577 (TREE_CHAIN (current) ? "\n" : ""));
14578 obstack_grow (&temporary_obstack, string, strlen (string));
14579 }
14580 obstack_1grow (&temporary_obstack, '\0');
14581 candidates = obstack_finish (&temporary_obstack);
14582 }
14583 /* Issue the error message */
14584 method = make_node (FUNCTION_TYPE);
14585 TYPE_ARG_TYPES (method) = atl;
14586 signature = build_java_argument_signature (method);
14587 dup = xstrdup (lang_printable_name (class, 0));
14588 parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
14589 (lc ? "constructor" : "method"),
14590 (lc ? dup : IDENTIFIER_POINTER (name)),
14591 IDENTIFIER_POINTER (signature), dup,
14592 (candidates ? candidates : ""));
14593 free (dup);
14594 return NULL_TREE;
14595 }
14596
14597 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
14598 when we're looking for a constructor. */
14599
14600 static tree
find_applicable_accessible_methods_list(lc,class,name,arglist)14601 find_applicable_accessible_methods_list (lc, class, name, arglist)
14602 int lc;
14603 tree class, name, arglist;
14604 {
14605 static htab_t searched_classes;
14606 static int search_not_done = 0;
14607 tree list = NULL_TREE, all_list = NULL_TREE;
14608
14609 /* Check the hash table to determine if this class has been searched
14610 already. */
14611 if (searched_classes)
14612 {
14613 if (htab_find (searched_classes, class) != NULL)
14614 return NULL;
14615 }
14616 else
14617 {
14618 searched_classes = htab_create (10, htab_hash_pointer,
14619 htab_eq_pointer, NULL);
14620 }
14621
14622 search_not_done++;
14623 *htab_find_slot (searched_classes, class, INSERT) = class;
14624
14625 if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
14626 {
14627 load_class (class, 1);
14628 safe_layout_class (class);
14629 }
14630
14631 /* Search interfaces */
14632 if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
14633 && CLASS_INTERFACE (TYPE_NAME (class)))
14634 {
14635 int i, n;
14636 tree basetype_vec = TYPE_BINFO_BASETYPES (class);
14637 search_applicable_methods_list (lc, TYPE_METHODS (class),
14638 name, arglist, &list, &all_list);
14639 n = TREE_VEC_LENGTH (basetype_vec);
14640 for (i = 1; i < n; i++)
14641 {
14642 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
14643 tree rlist;
14644
14645 rlist = find_applicable_accessible_methods_list (lc, t, name,
14646 arglist);
14647 list = chainon (rlist, list);
14648 }
14649 }
14650 /* Search classes */
14651 else
14652 {
14653 search_applicable_methods_list (lc, TYPE_METHODS (class),
14654 name, arglist, &list, &all_list);
14655
14656 /* When looking finit$, class$ or instinit$, we turn LC to 1 so
14657 that we only search in class. Note that we should have found
14658 something at this point. */
14659 if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
14660 {
14661 lc = 1;
14662 if (!list)
14663 abort ();
14664 }
14665
14666 /* We must search all interfaces of this class */
14667 if (!lc)
14668 {
14669 tree basetype_vec = TYPE_BINFO_BASETYPES (class);
14670 int n = TREE_VEC_LENGTH (basetype_vec), i;
14671 for (i = 1; i < n; i++)
14672 {
14673 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
14674 if (t != object_type_node)
14675 {
14676 tree rlist
14677 = find_applicable_accessible_methods_list (lc, t,
14678 name, arglist);
14679 list = chainon (rlist, list);
14680 }
14681 }
14682 }
14683
14684 /* Search superclass */
14685 if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
14686 {
14687 tree rlist;
14688 class = CLASSTYPE_SUPER (class);
14689 rlist = find_applicable_accessible_methods_list (lc, class,
14690 name, arglist);
14691 list = chainon (rlist, list);
14692 }
14693 }
14694
14695 search_not_done--;
14696
14697 /* We're done. Reset the searched classes list and finally search
14698 java.lang.Object if it wasn't searched already. */
14699 if (!search_not_done)
14700 {
14701 if (!lc
14702 && TYPE_METHODS (object_type_node)
14703 && htab_find (searched_classes, object_type_node) == NULL)
14704 {
14705 search_applicable_methods_list (lc,
14706 TYPE_METHODS (object_type_node),
14707 name, arglist, &list, &all_list);
14708 }
14709 htab_delete (searched_classes);
14710 searched_classes = NULL;
14711 }
14712
14713 /* Either return the list obtained or all selected (but
14714 inaccessible) methods for better error report. */
14715 return (!list ? all_list : list);
14716 }
14717
14718 /* Effectively search for the appropriate method in method */
14719
14720 static void
search_applicable_methods_list(lc,method,name,arglist,list,all_list)14721 search_applicable_methods_list (lc, method, name, arglist, list, all_list)
14722 int lc;
14723 tree method, name, arglist;
14724 tree *list, *all_list;
14725 {
14726 for (; method; method = TREE_CHAIN (method))
14727 {
14728 /* When dealing with constructor, stop here, otherwise search
14729 other classes */
14730 if (lc && !DECL_CONSTRUCTOR_P (method))
14731 continue;
14732 else if (!lc && (DECL_CONSTRUCTOR_P (method)
14733 || (DECL_NAME (method) != name)))
14734 continue;
14735
14736 if (argument_types_convertible (method, arglist))
14737 {
14738 /* Retain accessible methods only */
14739 if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
14740 method, NULL_TREE, 0))
14741 *list = tree_cons (NULL_TREE, method, *list);
14742 else
14743 /* Also retain all selected method here */
14744 *all_list = tree_cons (NULL_TREE, method, *list);
14745 }
14746 }
14747 }
14748
14749 /* 15.11.2.2 Choose the Most Specific Method */
14750
14751 static tree
find_most_specific_methods_list(list)14752 find_most_specific_methods_list (list)
14753 tree list;
14754 {
14755 int max = 0;
14756 int abstract, candidates;
14757 tree current, new_list = NULL_TREE;
14758 for (current = list; current; current = TREE_CHAIN (current))
14759 {
14760 tree method;
14761 DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
14762
14763 for (method = list; method; method = TREE_CHAIN (method))
14764 {
14765 tree method_v, current_v;
14766 /* Don't test a method against itself */
14767 if (method == current)
14768 continue;
14769
14770 method_v = TREE_VALUE (method);
14771 current_v = TREE_VALUE (current);
14772
14773 /* Compare arguments and location where methods where declared */
14774 if (argument_types_convertible (method_v, current_v))
14775 {
14776 if (valid_method_invocation_conversion_p
14777 (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
14778 || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
14779 && enclosing_context_p (DECL_CONTEXT (method_v),
14780 DECL_CONTEXT (current_v))))
14781 {
14782 int v = (DECL_SPECIFIC_COUNT (current_v) +=
14783 (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
14784 max = (v > max ? v : max);
14785 }
14786 }
14787 }
14788 }
14789
14790 /* Review the list and select the maximally specific methods */
14791 for (current = list, abstract = -1, candidates = -1;
14792 current; current = TREE_CHAIN (current))
14793 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
14794 {
14795 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
14796 abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
14797 candidates++;
14798 }
14799
14800 /* If we have several and they're all abstract, just pick the
14801 closest one. */
14802 if (candidates > 0 && (candidates == abstract))
14803 {
14804 new_list = nreverse (new_list);
14805 TREE_CHAIN (new_list) = NULL_TREE;
14806 }
14807
14808 /* We have several (we couldn't find a most specific), all but one
14809 are abstract, we pick the only non abstract one. */
14810 if (candidates > 0 && (candidates == abstract+1))
14811 {
14812 for (current = new_list; current; current = TREE_CHAIN (current))
14813 if (!METHOD_ABSTRACT (TREE_VALUE (current)))
14814 {
14815 TREE_CHAIN (current) = NULL_TREE;
14816 new_list = current;
14817 }
14818 }
14819
14820 /* If we can't find one, lower expectations and try to gather multiple
14821 maximally specific methods */
14822 while (!new_list && max)
14823 {
14824 while (--max > 0)
14825 {
14826 if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
14827 new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
14828 }
14829 }
14830
14831 return new_list;
14832 }
14833
14834 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
14835 converted by method invocation conversion (5.3) to the type of the
14836 corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
14837 to change less often than M1. */
14838
14839 static GTY(()) tree m2_arg_value;
14840 static GTY(()) tree m2_arg_cache;
14841
14842 static int
argument_types_convertible(m1,m2_or_arglist)14843 argument_types_convertible (m1, m2_or_arglist)
14844 tree m1, m2_or_arglist;
14845 {
14846 register tree m1_arg, m2_arg;
14847
14848 SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
14849
14850 if (m2_arg_value == m2_or_arglist)
14851 m2_arg = m2_arg_cache;
14852 else
14853 {
14854 /* M2_OR_ARGLIST can be a function DECL or a raw list of
14855 argument types */
14856 if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
14857 {
14858 m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
14859 if (!METHOD_STATIC (m2_or_arglist))
14860 m2_arg = TREE_CHAIN (m2_arg);
14861 }
14862 else
14863 m2_arg = m2_or_arglist;
14864
14865 m2_arg_value = m2_or_arglist;
14866 m2_arg_cache = m2_arg;
14867 }
14868
14869 while (m1_arg != end_params_node && m2_arg != end_params_node)
14870 {
14871 resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
14872 if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
14873 TREE_VALUE (m2_arg)))
14874 break;
14875 m1_arg = TREE_CHAIN (m1_arg);
14876 m2_arg = TREE_CHAIN (m2_arg);
14877 }
14878 return m1_arg == end_params_node && m2_arg == end_params_node;
14879 }
14880
14881 /* Qualification routines */
14882
14883 static void
qualify_ambiguous_name(id)14884 qualify_ambiguous_name (id)
14885 tree id;
14886 {
14887 tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
14888 saved_current_class;
14889 int again, super_found = 0, this_found = 0, new_array_found = 0;
14890 int code;
14891
14892 /* We first qualify the first element, then derive qualification of
14893 others based on the first one. If the first element is qualified
14894 by a resolution (field or type), this resolution is stored in the
14895 QUAL_RESOLUTION of the qual element being examined. We need to
14896 save the current_class since the use of SUPER might change the
14897 its value. */
14898 saved_current_class = current_class;
14899 qual = EXPR_WFL_QUALIFICATION (id);
14900 do {
14901
14902 /* Simple qualified expression feature a qual_wfl that is a
14903 WFL. Expression derived from a primary feature more complicated
14904 things like a CALL_EXPR. Expression from primary need to be
14905 worked out to extract the part on which the qualification will
14906 take place. */
14907 qual_wfl = QUAL_WFL (qual);
14908 switch (TREE_CODE (qual_wfl))
14909 {
14910 case CALL_EXPR:
14911 qual_wfl = TREE_OPERAND (qual_wfl, 0);
14912 if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION
14913 || (EXPR_WFL_QUALIFICATION (qual_wfl)
14914 && TREE_CODE (EXPR_WFL_QUALIFICATION (qual_wfl)) == TREE_LIST))
14915 {
14916 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
14917 qual_wfl = QUAL_WFL (qual);
14918 }
14919 break;
14920 case NEW_ARRAY_EXPR:
14921 case NEW_ANONYMOUS_ARRAY_EXPR:
14922 qual = TREE_CHAIN (qual);
14923 again = new_array_found = 1;
14924 continue;
14925 case CONVERT_EXPR:
14926 break;
14927 case NEW_CLASS_EXPR:
14928 qual_wfl = TREE_OPERAND (qual_wfl, 0);
14929 break;
14930 case ARRAY_REF:
14931 while (TREE_CODE (qual_wfl) == ARRAY_REF)
14932 qual_wfl = TREE_OPERAND (qual_wfl, 0);
14933 break;
14934 case STRING_CST:
14935 qual = TREE_CHAIN (qual);
14936 qual_wfl = QUAL_WFL (qual);
14937 break;
14938 case CLASS_LITERAL:
14939 qual = TREE_CHAIN (qual);
14940 qual_wfl = QUAL_WFL (qual);
14941 break;
14942 default:
14943 /* Fix for -Wall. Just break doing nothing */
14944 break;
14945 }
14946
14947 ptr_type = current_class;
14948 again = 0;
14949 code = TREE_CODE (qual_wfl);
14950
14951 /* Pos evaluation: non WFL leading expression nodes */
14952 if (code == CONVERT_EXPR
14953 && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
14954 name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
14955
14956 else if (code == INTEGER_CST)
14957 name = qual_wfl;
14958
14959 else if (code == CONVERT_EXPR &&
14960 TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
14961 name = TREE_OPERAND (qual_wfl, 0);
14962
14963 else if (code == CONVERT_EXPR
14964 && TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == CALL_EXPR
14965 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0))
14966 == EXPR_WITH_FILE_LOCATION))
14967 name = TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0);
14968
14969 else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
14970 TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
14971 name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
14972
14973 else if (code == TREE_LIST)
14974 name = EXPR_WFL_NODE (TREE_PURPOSE (qual_wfl));
14975
14976 else if (code == STRING_CST || code == CONDITIONAL_EXPR
14977 || code == PLUS_EXPR)
14978 {
14979 qual = TREE_CHAIN (qual);
14980 qual_wfl = QUAL_WFL (qual);
14981 again = 1;
14982 }
14983 else
14984 {
14985 name = EXPR_WFL_NODE (qual_wfl);
14986 if (!name)
14987 {
14988 qual = EXPR_WFL_QUALIFICATION (qual_wfl);
14989 again = 1;
14990 }
14991 }
14992
14993 /* If we have a THIS (from a primary), we set the context accordingly */
14994 if (name == this_identifier_node)
14995 {
14996 /* This isn't really elegant. One more added irregularity
14997 before I start using COMPONENT_REF (hopefully very soon.) */
14998 if (TREE_CODE (TREE_PURPOSE (qual)) == ARRAY_REF
14999 && TREE_CODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
15000 EXPR_WITH_FILE_LOCATION
15001 && EXPR_WFL_NODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
15002 this_identifier_node)
15003 {
15004 qual = TREE_OPERAND (TREE_PURPOSE (qual), 0);
15005 qual = EXPR_WFL_QUALIFICATION (qual);
15006 }
15007 qual = TREE_CHAIN (qual);
15008 qual_wfl = QUAL_WFL (qual);
15009 if (TREE_CODE (qual_wfl) == CALL_EXPR)
15010 again = 1;
15011 else if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION)
15012 name = EXPR_WFL_NODE (qual_wfl);
15013 else if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR)
15014 name = TREE_OPERAND (qual_wfl, 0);
15015 this_found = 1;
15016 }
15017 /* If we have a SUPER, we set the context accordingly */
15018 if (name == super_identifier_node)
15019 {
15020 current_class = CLASSTYPE_SUPER (ptr_type);
15021 /* Check that there is such a thing as a super class. If not,
15022 return. The error will be caught later on, during the
15023 resolution */
15024 if (!current_class)
15025 {
15026 current_class = saved_current_class;
15027 return;
15028 }
15029 qual = TREE_CHAIN (qual);
15030 /* Do one more interation to set things up */
15031 super_found = again = 1;
15032 }
15033 } while (again);
15034
15035 /* If name appears within the scope of a local variable declaration
15036 or parameter declaration, then it is an expression name. We don't
15037 carry this test out if we're in the context of the use of SUPER
15038 or THIS */
15039 if (!this_found && !super_found
15040 && TREE_CODE (name) != STRING_CST && TREE_CODE (name) != INTEGER_CST
15041 && (decl = IDENTIFIER_LOCAL_VALUE (name)))
15042 {
15043 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
15044 QUAL_RESOLUTION (qual) = decl;
15045 }
15046
15047 /* If within the class/interface NAME was found to be used there
15048 exists a (possibly inherited) field named NAME, then this is an
15049 expression name. If we saw a NEW_ARRAY_EXPR before and want to
15050 address length, it is OK. */
15051 else if ((decl = lookup_field_wrapper (ptr_type, name))
15052 || name == length_identifier_node)
15053 {
15054 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
15055 QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
15056 }
15057
15058 /* We reclassify NAME as yielding to a type name resolution if:
15059 - NAME is a class/interface declared within the compilation
15060 unit containing NAME,
15061 - NAME is imported via a single-type-import declaration,
15062 - NAME is declared in an another compilation unit of the package
15063 of the compilation unit containing NAME,
15064 - NAME is declared by exactly on type-import-on-demand declaration
15065 of the compilation unit containing NAME.
15066 - NAME is actually a STRING_CST.
15067 This can't happen if the expression was qualified by `this.' */
15068 else if (! this_found &&
15069 (TREE_CODE (name) == STRING_CST ||
15070 TREE_CODE (name) == INTEGER_CST ||
15071 (decl = resolve_and_layout (name, NULL_TREE))))
15072 {
15073 RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
15074 QUAL_RESOLUTION (qual) = decl;
15075 }
15076
15077 /* Method call, array references and cast are expression name */
15078 else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
15079 || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
15080 || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR
15081 || TREE_CODE (QUAL_WFL (qual)) == MODIFY_EXPR)
15082 RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
15083
15084 /* Check here that NAME isn't declared by more than one
15085 type-import-on-demand declaration of the compilation unit
15086 containing NAME. FIXME */
15087
15088 /* Otherwise, NAME is reclassified as a package name */
15089 else
15090 RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
15091
15092 /* Propagate the qualification accross other components of the
15093 qualified name */
15094 for (qual = TREE_CHAIN (qual); qual;
15095 qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
15096 {
15097 if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
15098 RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
15099 else
15100 RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
15101 }
15102
15103 /* Store the global qualification for the ambiguous part of ID back
15104 into ID fields */
15105 if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
15106 RESOLVE_EXPRESSION_NAME_P (id) = 1;
15107 else if (RESOLVE_TYPE_NAME_P (qual_wfl))
15108 RESOLVE_TYPE_NAME_P (id) = 1;
15109 else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
15110 RESOLVE_PACKAGE_NAME_P (id) = 1;
15111
15112 /* Restore the current class */
15113 current_class = saved_current_class;
15114 }
15115
15116 static int
breakdown_qualified(left,right,source)15117 breakdown_qualified (left, right, source)
15118 tree *left, *right, source;
15119 {
15120 char *p, *base;
15121 int l = IDENTIFIER_LENGTH (source);
15122
15123 base = alloca (l + 1);
15124 memcpy (base, IDENTIFIER_POINTER (source), l + 1);
15125
15126 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
15127 p = base + l - 1;
15128 while (*p != '.' && p != base)
15129 p--;
15130
15131 /* We didn't find a '.'. Return an error. */
15132 if (p == base)
15133 return 1;
15134
15135 *p = '\0';
15136 if (right)
15137 *right = get_identifier (p+1);
15138 *left = get_identifier (base);
15139
15140 return 0;
15141 }
15142
15143 /* Return TRUE if two classes are from the same package. */
15144
15145 static int
in_same_package(name1,name2)15146 in_same_package (name1, name2)
15147 tree name1, name2;
15148 {
15149 tree tmp;
15150 tree pkg1;
15151 tree pkg2;
15152
15153 if (TREE_CODE (name1) == TYPE_DECL)
15154 name1 = DECL_NAME (name1);
15155 if (TREE_CODE (name2) == TYPE_DECL)
15156 name2 = DECL_NAME (name2);
15157
15158 if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
15159 /* One in empty package. */
15160 return 0;
15161
15162 if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
15163 /* Both in empty package. */
15164 return 1;
15165
15166 breakdown_qualified (&pkg1, &tmp, name1);
15167 breakdown_qualified (&pkg2, &tmp, name2);
15168
15169 return (pkg1 == pkg2);
15170 }
15171
15172 /* Patch tree nodes in a function body. When a BLOCK is found, push
15173 local variable decls if present.
15174 Same as java_complete_lhs, but does resolve static finals to values. */
15175
15176 static tree
java_complete_tree(node)15177 java_complete_tree (node)
15178 tree node;
15179 {
15180 node = java_complete_lhs (node);
15181 if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
15182 && DECL_INITIAL (node) != NULL_TREE
15183 && !flag_emit_xref)
15184 {
15185 tree value = fold_constant_for_init (node, node);
15186 if (value != NULL_TREE)
15187 return value;
15188 }
15189 return node;
15190 }
15191
15192 static tree
java_stabilize_reference(node)15193 java_stabilize_reference (node)
15194 tree node;
15195 {
15196 if (TREE_CODE (node) == COMPOUND_EXPR)
15197 {
15198 tree op0 = TREE_OPERAND (node, 0);
15199 tree op1 = TREE_OPERAND (node, 1);
15200 TREE_OPERAND (node, 0) = save_expr (op0);
15201 TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
15202 return node;
15203 }
15204 return stabilize_reference (node);
15205 }
15206
15207 /* Patch tree nodes in a function body. When a BLOCK is found, push
15208 local variable decls if present.
15209 Same as java_complete_tree, but does not resolve static finals to values. */
15210
15211 static tree
java_complete_lhs(node)15212 java_complete_lhs (node)
15213 tree node;
15214 {
15215 tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
15216 int flag;
15217
15218 /* CONVERT_EXPR always has its type set, even though it needs to be
15219 worked out. */
15220 if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
15221 return node;
15222
15223 /* The switch block implements cases processing container nodes
15224 first. Contained nodes are always written back. Leaves come
15225 next and return a value. */
15226 switch (TREE_CODE (node))
15227 {
15228 case BLOCK:
15229
15230 /* 1- Block section.
15231 Set the local values on decl names so we can identify them
15232 faster when they're referenced. At that stage, identifiers
15233 are legal so we don't check for declaration errors. */
15234 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
15235 {
15236 DECL_CONTEXT (cn) = current_function_decl;
15237 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
15238 }
15239 if (BLOCK_EXPR_BODY (node) == NULL_TREE)
15240 CAN_COMPLETE_NORMALLY (node) = 1;
15241 else
15242 {
15243 tree stmt = BLOCK_EXPR_BODY (node);
15244 tree *ptr;
15245 int error_seen = 0;
15246 if (TREE_CODE (stmt) == COMPOUND_EXPR)
15247 {
15248 /* Re-order from (((A; B); C); ...; Z) to
15249 (A; (B; (C ; (...; Z)))).
15250 This makes it easier to scan the statements left-to-right
15251 without using recursion (which might overflow the stack
15252 if the block has many statements. */
15253 for (;;)
15254 {
15255 tree left = TREE_OPERAND (stmt, 0);
15256 if (TREE_CODE (left) != COMPOUND_EXPR)
15257 break;
15258 TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
15259 TREE_OPERAND (left, 1) = stmt;
15260 stmt = left;
15261 }
15262 BLOCK_EXPR_BODY (node) = stmt;
15263 }
15264
15265 /* Now do the actual complete, without deep recursion for
15266 long blocks. */
15267 ptr = &BLOCK_EXPR_BODY (node);
15268 while (TREE_CODE (*ptr) == COMPOUND_EXPR
15269 && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
15270 {
15271 tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
15272 tree *next = &TREE_OPERAND (*ptr, 1);
15273 TREE_OPERAND (*ptr, 0) = cur;
15274 if (cur == empty_stmt_node)
15275 {
15276 /* Optimization; makes it easier to detect empty bodies.
15277 Most useful for <clinit> with all-constant initializer. */
15278 *ptr = *next;
15279 continue;
15280 }
15281 if (TREE_CODE (cur) == ERROR_MARK)
15282 error_seen++;
15283 else if (! CAN_COMPLETE_NORMALLY (cur))
15284 {
15285 wfl_op2 = *next;
15286 for (;;)
15287 {
15288 if (TREE_CODE (wfl_op2) == BLOCK)
15289 wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
15290 else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
15291 wfl_op2 = TREE_OPERAND (wfl_op2, 0);
15292 else
15293 break;
15294 }
15295 if (TREE_CODE (wfl_op2) != CASE_EXPR
15296 && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
15297 unreachable_stmt_error (*ptr);
15298 }
15299 ptr = next;
15300 }
15301 *ptr = java_complete_tree (*ptr);
15302
15303 if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
15304 return error_mark_node;
15305 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
15306 }
15307 /* Turn local bindings to null */
15308 for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
15309 IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
15310
15311 TREE_TYPE (node) = void_type_node;
15312 break;
15313
15314 /* 2- They are expressions but ultimately deal with statements */
15315
15316 case THROW_EXPR:
15317 wfl_op1 = TREE_OPERAND (node, 0);
15318 COMPLETE_CHECK_OP_0 (node);
15319 /* 14.19 A throw statement cannot complete normally. */
15320 CAN_COMPLETE_NORMALLY (node) = 0;
15321 return patch_throw_statement (node, wfl_op1);
15322
15323 case SYNCHRONIZED_EXPR:
15324 wfl_op1 = TREE_OPERAND (node, 0);
15325 return patch_synchronized_statement (node, wfl_op1);
15326
15327 case TRY_EXPR:
15328 return patch_try_statement (node);
15329
15330 case TRY_FINALLY_EXPR:
15331 COMPLETE_CHECK_OP_0 (node);
15332 COMPLETE_CHECK_OP_1 (node);
15333 if (TREE_OPERAND (node, 0) == empty_stmt_node)
15334 return TREE_OPERAND (node, 1);
15335 if (TREE_OPERAND (node, 1) == empty_stmt_node)
15336 return TREE_OPERAND (node, 0);
15337 CAN_COMPLETE_NORMALLY (node)
15338 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
15339 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
15340 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
15341 return node;
15342
15343 case LABELED_BLOCK_EXPR:
15344 PUSH_LABELED_BLOCK (node);
15345 if (LABELED_BLOCK_BODY (node))
15346 COMPLETE_CHECK_OP_1 (node);
15347 TREE_TYPE (node) = void_type_node;
15348 POP_LABELED_BLOCK ();
15349
15350 if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
15351 {
15352 LABELED_BLOCK_BODY (node) = NULL_TREE;
15353 CAN_COMPLETE_NORMALLY (node) = 1;
15354 }
15355 else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
15356 CAN_COMPLETE_NORMALLY (node) = 1;
15357 return node;
15358
15359 case EXIT_BLOCK_EXPR:
15360 /* We don't complete operand 1, because it's the return value of
15361 the EXIT_BLOCK_EXPR which doesn't exist it Java */
15362 return patch_bc_statement (node);
15363
15364 case CASE_EXPR:
15365 cn = java_complete_tree (TREE_OPERAND (node, 0));
15366 if (cn == error_mark_node)
15367 return cn;
15368
15369 /* First, the case expression must be constant. Values of final
15370 fields are accepted. */
15371 cn = fold (cn);
15372 if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
15373 && JDECL_P (TREE_OPERAND (cn, 1))
15374 && FIELD_FINAL (TREE_OPERAND (cn, 1))
15375 && DECL_INITIAL (TREE_OPERAND (cn, 1)))
15376 {
15377 cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
15378 TREE_OPERAND (cn, 1));
15379 }
15380 /* Accept final locals too. */
15381 else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
15382 cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
15383
15384 if (!TREE_CONSTANT (cn) && !flag_emit_xref)
15385 {
15386 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15387 parse_error_context (node, "Constant expression required");
15388 return error_mark_node;
15389 }
15390
15391 nn = ctxp->current_loop;
15392
15393 /* It must be assignable to the type of the switch expression. */
15394 if (!try_builtin_assignconv (NULL_TREE,
15395 TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
15396 {
15397 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15398 parse_error_context
15399 (wfl_operator,
15400 "Incompatible type for case. Can't convert `%s' to `int'",
15401 lang_printable_name (TREE_TYPE (cn), 0));
15402 return error_mark_node;
15403 }
15404
15405 cn = fold (convert (int_type_node, cn));
15406 TREE_CONSTANT_OVERFLOW (cn) = 0;
15407 CAN_COMPLETE_NORMALLY (cn) = 1;
15408
15409 /* Save the label on a list so that we can later check for
15410 duplicates. */
15411 case_label_list = tree_cons (node, cn, case_label_list);
15412
15413 /* Multiple instance of a case label bearing the same value is
15414 checked later. The case expression is all right so far. */
15415 if (TREE_CODE (cn) == VAR_DECL)
15416 cn = DECL_INITIAL (cn);
15417 TREE_OPERAND (node, 0) = cn;
15418 TREE_TYPE (node) = void_type_node;
15419 CAN_COMPLETE_NORMALLY (node) = 1;
15420 TREE_SIDE_EFFECTS (node) = 1;
15421 break;
15422
15423 case DEFAULT_EXPR:
15424 nn = ctxp->current_loop;
15425 /* Only one default label is allowed per switch statement */
15426 if (SWITCH_HAS_DEFAULT (nn))
15427 {
15428 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15429 parse_error_context (wfl_operator,
15430 "Duplicate case label: `default'");
15431 return error_mark_node;
15432 }
15433 else
15434 SWITCH_HAS_DEFAULT (nn) = 1;
15435 TREE_TYPE (node) = void_type_node;
15436 TREE_SIDE_EFFECTS (node) = 1;
15437 CAN_COMPLETE_NORMALLY (node) = 1;
15438 break;
15439
15440 case SWITCH_EXPR:
15441 case LOOP_EXPR:
15442 PUSH_LOOP (node);
15443 /* Check whether the loop was enclosed in a labeled
15444 statement. If not, create one, insert the loop in it and
15445 return the node */
15446 nn = patch_loop_statement (node);
15447
15448 /* Anyways, walk the body of the loop */
15449 if (TREE_CODE (node) == LOOP_EXPR)
15450 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
15451 /* Switch statement: walk the switch expression and the cases */
15452 else
15453 node = patch_switch_statement (node);
15454
15455 if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
15456 nn = error_mark_node;
15457 else
15458 {
15459 TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
15460 /* If we returned something different, that's because we
15461 inserted a label. Pop the label too. */
15462 if (nn != node)
15463 {
15464 if (CAN_COMPLETE_NORMALLY (node))
15465 CAN_COMPLETE_NORMALLY (nn) = 1;
15466 POP_LABELED_BLOCK ();
15467 }
15468 }
15469 POP_LOOP ();
15470 return nn;
15471
15472 case EXIT_EXPR:
15473 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
15474 return patch_exit_expr (node);
15475
15476 case COND_EXPR:
15477 /* Condition */
15478 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
15479 if (TREE_OPERAND (node, 0) == error_mark_node)
15480 return error_mark_node;
15481 /* then-else branches */
15482 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15483 if (TREE_OPERAND (node, 1) == error_mark_node)
15484 return error_mark_node;
15485 TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
15486 if (TREE_OPERAND (node, 2) == error_mark_node)
15487 return error_mark_node;
15488 return patch_if_else_statement (node);
15489 break;
15490
15491 case CONDITIONAL_EXPR:
15492 /* Condition */
15493 wfl_op1 = TREE_OPERAND (node, 0);
15494 COMPLETE_CHECK_OP_0 (node);
15495 wfl_op2 = TREE_OPERAND (node, 1);
15496 COMPLETE_CHECK_OP_1 (node);
15497 wfl_op3 = TREE_OPERAND (node, 2);
15498 COMPLETE_CHECK_OP_2 (node);
15499 return patch_conditional_expr (node, wfl_op1, wfl_op2);
15500
15501 /* 3- Expression section */
15502 case COMPOUND_EXPR:
15503 wfl_op2 = TREE_OPERAND (node, 1);
15504 TREE_OPERAND (node, 0) = nn =
15505 java_complete_tree (TREE_OPERAND (node, 0));
15506 if (wfl_op2 == empty_stmt_node)
15507 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
15508 else
15509 {
15510 if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
15511 {
15512 /* An unreachable condition in a do-while statement
15513 is *not* (technically) an unreachable statement. */
15514 nn = wfl_op2;
15515 if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
15516 nn = EXPR_WFL_NODE (nn);
15517 /* NN can be NULL_TREE exactly when UPDATE is, in
15518 finish_for_loop. */
15519 if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
15520 {
15521 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
15522 if (SUPPRESS_UNREACHABLE_ERROR (nn))
15523 {
15524 /* Perhaps this warning should have an
15525 associated flag. The code being compiled is
15526 pedantically correct, but useless. */
15527 parse_warning_context (wfl_operator,
15528 "Unreachable statement");
15529 }
15530 else
15531 parse_error_context (wfl_operator,
15532 "Unreachable statement");
15533 }
15534 }
15535 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15536 if (TREE_OPERAND (node, 1) == error_mark_node)
15537 return error_mark_node;
15538 /* Even though we might allow the case where the first
15539 operand doesn't return normally, we still should compute
15540 CAN_COMPLETE_NORMALLY correctly. */
15541 CAN_COMPLETE_NORMALLY (node)
15542 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
15543 && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
15544 }
15545 TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
15546 break;
15547
15548 case RETURN_EXPR:
15549 /* CAN_COMPLETE_NORMALLY (node) = 0; */
15550 return patch_return (node);
15551
15552 case EXPR_WITH_FILE_LOCATION:
15553 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
15554 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
15555 {
15556 tree wfl = node;
15557 node = resolve_expression_name (node, NULL);
15558 if (node == error_mark_node)
15559 return node;
15560 /* Keep line number information somewhere were it doesn't
15561 disrupt the completion process. */
15562 if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
15563 {
15564 EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
15565 TREE_OPERAND (node, 1) = wfl;
15566 }
15567 CAN_COMPLETE_NORMALLY (node) = 1;
15568 }
15569 else
15570 {
15571 tree body;
15572 int save_lineno = lineno;
15573 lineno = EXPR_WFL_LINENO (node);
15574 body = java_complete_tree (EXPR_WFL_NODE (node));
15575 lineno = save_lineno;
15576 EXPR_WFL_NODE (node) = body;
15577 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
15578 CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
15579 if (body == empty_stmt_node || TREE_CONSTANT (body))
15580 {
15581 /* Makes it easier to constant fold, detect empty bodies. */
15582 return body;
15583 }
15584 if (body == error_mark_node)
15585 {
15586 /* Its important for the evaluation of assignment that
15587 this mark on the TREE_TYPE is propagated. */
15588 TREE_TYPE (node) = error_mark_node;
15589 return error_mark_node;
15590 }
15591 else
15592 TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
15593
15594 }
15595 break;
15596
15597 case NEW_ARRAY_EXPR:
15598 /* Patch all the dimensions */
15599 flag = 0;
15600 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
15601 {
15602 int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
15603 tree dim = convert (int_type_node,
15604 java_complete_tree (TREE_VALUE (cn)));
15605 if (dim == error_mark_node)
15606 {
15607 flag = 1;
15608 continue;
15609 }
15610 else
15611 {
15612 TREE_VALUE (cn) = dim;
15613 /* Setup the location of the current dimension, for
15614 later error report. */
15615 TREE_PURPOSE (cn) =
15616 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
15617 EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
15618 }
15619 }
15620 /* They complete the array creation expression, if no errors
15621 were found. */
15622 CAN_COMPLETE_NORMALLY (node) = 1;
15623 return (flag ? error_mark_node
15624 : force_evaluation_order (patch_newarray (node)));
15625
15626 case NEW_ANONYMOUS_ARRAY_EXPR:
15627 /* Create the array type if necessary. */
15628 if (ANONYMOUS_ARRAY_DIMS_SIG (node))
15629 {
15630 tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
15631 if (!(type = resolve_type_during_patch (type)))
15632 return error_mark_node;
15633 type = build_array_from_name (type, NULL_TREE,
15634 ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
15635 ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
15636 }
15637 node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
15638 ANONYMOUS_ARRAY_INITIALIZER (node));
15639 if (node == error_mark_node)
15640 return error_mark_node;
15641 CAN_COMPLETE_NORMALLY (node) = 1;
15642 return node;
15643
15644 case NEW_CLASS_EXPR:
15645 case CALL_EXPR:
15646 /* Complete function's argument(s) first */
15647 if (complete_function_arguments (node))
15648 return error_mark_node;
15649 else
15650 {
15651 tree decl, wfl = TREE_OPERAND (node, 0);
15652 int in_this = CALL_THIS_CONSTRUCTOR_P (node);
15653 int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
15654 super_identifier_node);
15655
15656 node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
15657 from_super, 0, &decl);
15658 if (node == error_mark_node)
15659 return error_mark_node;
15660
15661 check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl);
15662 /* If we call this(...), register signature and positions */
15663 if (in_this)
15664 DECL_CONSTRUCTOR_CALLS (current_function_decl) =
15665 tree_cons (wfl, decl,
15666 DECL_CONSTRUCTOR_CALLS (current_function_decl));
15667 CAN_COMPLETE_NORMALLY (node) = 1;
15668 return force_evaluation_order (node);
15669 }
15670
15671 case MODIFY_EXPR:
15672 /* Save potential wfls */
15673 wfl_op1 = TREE_OPERAND (node, 0);
15674 TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
15675
15676 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
15677 && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
15678 && DECL_INITIAL (nn) != NULL_TREE)
15679 {
15680 tree value;
15681
15682 value = fold_constant_for_init (nn, nn);
15683
15684 /* When we have a primitype type, or a string and we're not
15685 emitting a class file, we actually don't want to generate
15686 anything for the assignment. */
15687 if (value != NULL_TREE &&
15688 (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
15689 (TREE_TYPE (value) == string_ptr_type_node &&
15690 ! flag_emit_class_files)))
15691 {
15692 /* Prepare node for patch_assignment */
15693 TREE_OPERAND (node, 1) = value;
15694 /* Call patch assignment to verify the assignment */
15695 if (patch_assignment (node, wfl_op1) == error_mark_node)
15696 return error_mark_node;
15697 /* Set DECL_INITIAL properly (a conversion might have
15698 been decided by patch_assignment) and return the
15699 empty statement. */
15700 else
15701 {
15702 tree patched = patch_string (TREE_OPERAND (node, 1));
15703 if (patched)
15704 DECL_INITIAL (nn) = patched;
15705 else
15706 DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
15707 DECL_FIELD_FINAL_IUD (nn) = 1;
15708 return empty_stmt_node;
15709 }
15710 }
15711 if (! flag_emit_class_files)
15712 DECL_INITIAL (nn) = NULL_TREE;
15713 }
15714 wfl_op2 = TREE_OPERAND (node, 1);
15715
15716 if (TREE_OPERAND (node, 0) == error_mark_node)
15717 return error_mark_node;
15718
15719 flag = COMPOUND_ASSIGN_P (wfl_op2);
15720 if (flag)
15721 {
15722 /* This might break when accessing outer field from inner
15723 class. TESTME, FIXME */
15724 tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
15725
15726 /* Hand stabilize the lhs on both places */
15727 TREE_OPERAND (node, 0) = lvalue;
15728 TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
15729 (flag_emit_class_files ? lvalue : save_expr (lvalue));
15730
15731 /* 15.25.2.a: Left hand is not an array access. FIXME */
15732 /* Now complete the RHS. We write it back later on. */
15733 nn = java_complete_tree (TREE_OPERAND (node, 1));
15734
15735 if ((cn = patch_string (nn)))
15736 nn = cn;
15737
15738 /* The last part of the rewrite for E1 op= E2 is to have
15739 E1 = (T)(E1 op E2), with T being the type of E1. */
15740 nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
15741 TREE_TYPE (lvalue), nn));
15742
15743 /* If the assignment is compound and has reference type,
15744 then ensure the LHS has type String and nothing else. */
15745 if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
15746 && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
15747 parse_error_context (wfl_op2,
15748 "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
15749 lang_printable_name (TREE_TYPE (lvalue), 0));
15750
15751 /* 15.25.2.b: Left hand is an array access. FIXME */
15752 }
15753
15754 /* If we're about to patch a NEW_ARRAY_INIT, we call a special
15755 function to complete this RHS. Note that a NEW_ARRAY_INIT
15756 might have been already fully expanded if created as a result
15757 of processing an anonymous array initializer. We avoid doing
15758 the operation twice by testing whether the node already bears
15759 a type. */
15760 else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
15761 nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
15762 TREE_OPERAND (node, 1));
15763 /* Otherwise we simply complete the RHS */
15764 else
15765 nn = java_complete_tree (TREE_OPERAND (node, 1));
15766
15767 if (nn == error_mark_node)
15768 return error_mark_node;
15769
15770 /* Write back the RHS as we evaluated it. */
15771 TREE_OPERAND (node, 1) = nn;
15772
15773 /* In case we're handling = with a String as a RHS, we need to
15774 produce a String out of the RHS (it might still be a
15775 STRING_CST or a StringBuffer at this stage */
15776 if ((nn = patch_string (TREE_OPERAND (node, 1))))
15777 TREE_OPERAND (node, 1) = nn;
15778
15779 if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
15780 TREE_OPERAND (node, 1))))
15781 {
15782 /* We return error_mark_node if outer_field_access_fix
15783 detects we write into a final. */
15784 if (nn == error_mark_node)
15785 return error_mark_node;
15786 node = nn;
15787 }
15788 else
15789 {
15790 node = patch_assignment (node, wfl_op1);
15791 if (node == error_mark_node)
15792 return error_mark_node;
15793 /* Reorganize the tree if necessary. */
15794 if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
15795 || JSTRING_P (TREE_TYPE (node))))
15796 node = java_refold (node);
15797 }
15798
15799 /* Seek to set DECL_INITIAL to a proper value, since it might have
15800 undergone a conversion in patch_assignment. We do that only when
15801 it's necessary to have DECL_INITIAL properly set. */
15802 nn = TREE_OPERAND (node, 0);
15803 if (TREE_CODE (nn) == VAR_DECL
15804 && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
15805 && FIELD_STATIC (nn) && FIELD_FINAL (nn)
15806 && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
15807 || TREE_TYPE (nn) == string_ptr_type_node))
15808 DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
15809
15810 CAN_COMPLETE_NORMALLY (node) = 1;
15811 return node;
15812
15813 case MULT_EXPR:
15814 case PLUS_EXPR:
15815 case MINUS_EXPR:
15816 case LSHIFT_EXPR:
15817 case RSHIFT_EXPR:
15818 case URSHIFT_EXPR:
15819 case BIT_AND_EXPR:
15820 case BIT_XOR_EXPR:
15821 case BIT_IOR_EXPR:
15822 case TRUNC_MOD_EXPR:
15823 case TRUNC_DIV_EXPR:
15824 case RDIV_EXPR:
15825 case TRUTH_ANDIF_EXPR:
15826 case TRUTH_ORIF_EXPR:
15827 case EQ_EXPR:
15828 case NE_EXPR:
15829 case GT_EXPR:
15830 case GE_EXPR:
15831 case LT_EXPR:
15832 case LE_EXPR:
15833 /* Operands 0 and 1 are WFL in certain cases only. patch_binop
15834 knows how to handle those cases. */
15835 wfl_op1 = TREE_OPERAND (node, 0);
15836 wfl_op2 = TREE_OPERAND (node, 1);
15837
15838 CAN_COMPLETE_NORMALLY (node) = 1;
15839 /* Don't complete string nodes if dealing with the PLUS operand. */
15840 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
15841 {
15842 nn = java_complete_tree (wfl_op1);
15843 if (nn == error_mark_node)
15844 return error_mark_node;
15845
15846 TREE_OPERAND (node, 0) = nn;
15847 }
15848 if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
15849 {
15850 nn = java_complete_tree (wfl_op2);
15851 if (nn == error_mark_node)
15852 return error_mark_node;
15853
15854 TREE_OPERAND (node, 1) = nn;
15855 }
15856 return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
15857
15858 case INSTANCEOF_EXPR:
15859 wfl_op1 = TREE_OPERAND (node, 0);
15860 COMPLETE_CHECK_OP_0 (node);
15861 if (flag_emit_xref)
15862 {
15863 TREE_TYPE (node) = boolean_type_node;
15864 return node;
15865 }
15866 return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
15867
15868 case UNARY_PLUS_EXPR:
15869 case NEGATE_EXPR:
15870 case TRUTH_NOT_EXPR:
15871 case BIT_NOT_EXPR:
15872 case PREDECREMENT_EXPR:
15873 case PREINCREMENT_EXPR:
15874 case POSTDECREMENT_EXPR:
15875 case POSTINCREMENT_EXPR:
15876 case CONVERT_EXPR:
15877 /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
15878 how to handle those cases. */
15879 wfl_op1 = TREE_OPERAND (node, 0);
15880 CAN_COMPLETE_NORMALLY (node) = 1;
15881 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
15882 if (TREE_OPERAND (node, 0) == error_mark_node)
15883 return error_mark_node;
15884 node = patch_unaryop (node, wfl_op1);
15885 CAN_COMPLETE_NORMALLY (node) = 1;
15886 break;
15887
15888 case ARRAY_REF:
15889 /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
15890 how to handle those cases. */
15891 wfl_op1 = TREE_OPERAND (node, 0);
15892 TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
15893 if (TREE_OPERAND (node, 0) == error_mark_node)
15894 return error_mark_node;
15895 if (!flag_emit_class_files && !flag_emit_xref)
15896 TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
15897 /* The same applies to wfl_op2 */
15898 wfl_op2 = TREE_OPERAND (node, 1);
15899 TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
15900 if (TREE_OPERAND (node, 1) == error_mark_node)
15901 return error_mark_node;
15902 if (!flag_emit_class_files && !flag_emit_xref)
15903 TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
15904 return patch_array_ref (node);
15905
15906 case RECORD_TYPE:
15907 return node;;
15908
15909 case COMPONENT_REF:
15910 /* The first step in the re-write of qualified name handling. FIXME.
15911 So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
15912 TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
15913 if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
15914 {
15915 tree name = TREE_OPERAND (node, 1);
15916 tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
15917 if (field == NULL_TREE)
15918 {
15919 error ("missing static field `%s'", IDENTIFIER_POINTER (name));
15920 return error_mark_node;
15921 }
15922 if (! FIELD_STATIC (field))
15923 {
15924 error ("not a static field `%s'", IDENTIFIER_POINTER (name));
15925 return error_mark_node;
15926 }
15927 return field;
15928 }
15929 else
15930 abort ();
15931 break;
15932
15933 case THIS_EXPR:
15934 /* Can't use THIS in a static environment */
15935 if (!current_this)
15936 {
15937 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15938 parse_error_context (wfl_operator,
15939 "Keyword `this' used outside allowed context");
15940 TREE_TYPE (node) = error_mark_node;
15941 return error_mark_node;
15942 }
15943 if (ctxp->explicit_constructor_p)
15944 {
15945 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15946 parse_error_context
15947 (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
15948 TREE_TYPE (node) = error_mark_node;
15949 return error_mark_node;
15950 }
15951 return current_this;
15952
15953 case CLASS_LITERAL:
15954 CAN_COMPLETE_NORMALLY (node) = 1;
15955 node = patch_incomplete_class_ref (node);
15956 if (node == error_mark_node)
15957 return error_mark_node;
15958 break;
15959
15960 default:
15961 CAN_COMPLETE_NORMALLY (node) = 1;
15962 /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
15963 and it's time to turn it into the appropriate String object */
15964 if ((nn = patch_string (node)))
15965 node = nn;
15966 else
15967 internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
15968 }
15969 return node;
15970 }
15971
15972 /* Complete function call's argument. Return a nonzero value is an
15973 error was found. */
15974
15975 static int
complete_function_arguments(node)15976 complete_function_arguments (node)
15977 tree node;
15978 {
15979 int flag = 0;
15980 tree cn;
15981
15982 ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
15983 for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
15984 {
15985 tree wfl = TREE_VALUE (cn), parm, temp;
15986 parm = java_complete_tree (wfl);
15987
15988 if (parm == error_mark_node)
15989 {
15990 flag = 1;
15991 continue;
15992 }
15993 /* If have a string literal that we haven't transformed yet or a
15994 crafted string buffer, as a result of use of the the String
15995 `+' operator. Build `parm.toString()' and expand it. */
15996 if ((temp = patch_string (parm)))
15997 parm = temp;
15998
15999 TREE_VALUE (cn) = parm;
16000 }
16001 ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
16002 return flag;
16003 }
16004
16005 /* Sometimes (for loops and variable initialized during their
16006 declaration), we want to wrap a statement around a WFL and turn it
16007 debugable. */
16008
16009 static tree
build_debugable_stmt(location,stmt)16010 build_debugable_stmt (location, stmt)
16011 int location;
16012 tree stmt;
16013 {
16014 if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
16015 {
16016 stmt = build_expr_wfl (stmt, input_filename, 0, 0);
16017 EXPR_WFL_LINECOL (stmt) = location;
16018 }
16019 JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
16020 return stmt;
16021 }
16022
16023 static tree
build_expr_block(body,decls)16024 build_expr_block (body, decls)
16025 tree body, decls;
16026 {
16027 tree node = make_node (BLOCK);
16028 BLOCK_EXPR_DECLS (node) = decls;
16029 BLOCK_EXPR_BODY (node) = body;
16030 if (body)
16031 TREE_TYPE (node) = TREE_TYPE (body);
16032 TREE_SIDE_EFFECTS (node) = 1;
16033 return node;
16034 }
16035
16036 /* Create a new function block and link it appropriately to current
16037 function block chain */
16038
16039 static tree
enter_block()16040 enter_block ()
16041 {
16042 tree b = build_expr_block (NULL_TREE, NULL_TREE);
16043
16044 /* Link block B supercontext to the previous block. The current
16045 function DECL is used as supercontext when enter_a_block is called
16046 for the first time for a given function. The current function body
16047 (DECL_FUNCTION_BODY) is set to be block B. */
16048
16049 tree fndecl = current_function_decl;
16050
16051 if (!fndecl) {
16052 BLOCK_SUPERCONTEXT (b) = current_static_block;
16053 current_static_block = b;
16054 }
16055
16056 else if (!DECL_FUNCTION_BODY (fndecl))
16057 {
16058 BLOCK_SUPERCONTEXT (b) = fndecl;
16059 DECL_FUNCTION_BODY (fndecl) = b;
16060 }
16061 else
16062 {
16063 BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
16064 DECL_FUNCTION_BODY (fndecl) = b;
16065 }
16066 return b;
16067 }
16068
16069 /* Exit a block by changing the current function body
16070 (DECL_FUNCTION_BODY) to the current block super context, only if
16071 the block being exited isn't the method's top level one. */
16072
16073 static tree
exit_block()16074 exit_block ()
16075 {
16076 tree b;
16077 if (current_function_decl)
16078 {
16079 b = DECL_FUNCTION_BODY (current_function_decl);
16080 if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
16081 DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
16082 }
16083 else
16084 {
16085 b = current_static_block;
16086
16087 if (BLOCK_SUPERCONTEXT (b))
16088 current_static_block = BLOCK_SUPERCONTEXT (b);
16089 }
16090 return b;
16091 }
16092
16093 /* Lookup for NAME in the nested function's blocks, all the way up to
16094 the current toplevel one. It complies with Java's local variable
16095 scoping rules. */
16096
16097 static tree
lookup_name_in_blocks(name)16098 lookup_name_in_blocks (name)
16099 tree name;
16100 {
16101 tree b = GET_CURRENT_BLOCK (current_function_decl);
16102
16103 while (b != current_function_decl)
16104 {
16105 tree current;
16106
16107 /* Paranoid sanity check. To be removed */
16108 if (TREE_CODE (b) != BLOCK)
16109 abort ();
16110
16111 for (current = BLOCK_EXPR_DECLS (b); current;
16112 current = TREE_CHAIN (current))
16113 if (DECL_NAME (current) == name)
16114 return current;
16115 b = BLOCK_SUPERCONTEXT (b);
16116 }
16117 return NULL_TREE;
16118 }
16119
16120 static void
maybe_absorb_scoping_blocks()16121 maybe_absorb_scoping_blocks ()
16122 {
16123 while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
16124 {
16125 tree b = exit_block ();
16126 java_method_add_stmt (current_function_decl, b);
16127 SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
16128 }
16129 }
16130
16131
16132 /* This section of the source is reserved to build_* functions that
16133 are building incomplete tree nodes and the patch_* functions that
16134 are completing them. */
16135
16136 /* Wrap a non WFL node around a WFL. */
16137
16138 static tree
build_wfl_wrap(node,location)16139 build_wfl_wrap (node, location)
16140 tree node;
16141 int location;
16142 {
16143 tree wfl, node_to_insert = node;
16144
16145 /* We want to process THIS . xxx symbolicaly, to keep it consistent
16146 with the way we're processing SUPER. A THIS from a primary as a
16147 different form than a SUPER. Turn THIS into something symbolic */
16148 if (TREE_CODE (node) == THIS_EXPR)
16149 node_to_insert = wfl = build_wfl_node (this_identifier_node);
16150 else
16151 wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
16152
16153 EXPR_WFL_LINECOL (wfl) = location;
16154 EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
16155 return wfl;
16156 }
16157
16158 /* Build a super() constructor invocation. Returns empty_stmt_node if
16159 we're currently dealing with the class java.lang.Object. */
16160
16161 static tree
build_super_invocation(mdecl)16162 build_super_invocation (mdecl)
16163 tree mdecl;
16164 {
16165 if (DECL_CONTEXT (mdecl) == object_type_node)
16166 return empty_stmt_node;
16167 else
16168 {
16169 tree super_wfl = build_wfl_node (super_identifier_node);
16170 tree a = NULL_TREE, t;
16171 /* If we're dealing with an anonymous class, pass the arguments
16172 of the crafted constructor along. */
16173 if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
16174 {
16175 SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
16176 for (; t != end_params_node; t = TREE_CHAIN (t))
16177 a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
16178 }
16179 return build_method_invocation (super_wfl, a);
16180 }
16181 }
16182
16183 /* Build a SUPER/THIS qualified method invocation. */
16184
16185 static tree
build_this_super_qualified_invocation(use_this,name,args,lloc,rloc)16186 build_this_super_qualified_invocation (use_this, name, args, lloc, rloc)
16187 int use_this;
16188 tree name, args;
16189 int lloc, rloc;
16190 {
16191 tree invok;
16192 tree wfl =
16193 build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
16194 EXPR_WFL_LINECOL (wfl) = lloc;
16195 invok = build_method_invocation (name, args);
16196 return make_qualified_primary (wfl, invok, rloc);
16197 }
16198
16199 /* Build an incomplete CALL_EXPR node. */
16200
16201 static tree
build_method_invocation(name,args)16202 build_method_invocation (name, args)
16203 tree name;
16204 tree args;
16205 {
16206 tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
16207 TREE_SIDE_EFFECTS (call) = 1;
16208 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
16209 return call;
16210 }
16211
16212 /* Build an incomplete new xxx(...) node. */
16213
16214 static tree
build_new_invocation(name,args)16215 build_new_invocation (name, args)
16216 tree name, args;
16217 {
16218 tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
16219 TREE_SIDE_EFFECTS (call) = 1;
16220 EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
16221 return call;
16222 }
16223
16224 /* Build an incomplete assignment expression. */
16225
16226 static tree
build_assignment(op,op_location,lhs,rhs)16227 build_assignment (op, op_location, lhs, rhs)
16228 int op, op_location;
16229 tree lhs, rhs;
16230 {
16231 tree assignment;
16232 /* Build the corresponding binop if we deal with a Compound
16233 Assignment operator. Mark the binop sub-tree as part of a
16234 Compound Assignment expression */
16235 if (op != ASSIGN_TK)
16236 {
16237 rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
16238 COMPOUND_ASSIGN_P (rhs) = 1;
16239 }
16240 assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
16241 TREE_SIDE_EFFECTS (assignment) = 1;
16242 EXPR_WFL_LINECOL (assignment) = op_location;
16243 return assignment;
16244 }
16245
16246 /* Print an INTEGER_CST node as decimal in a static buffer, and return
16247 the buffer. This is used only for string conversion. */
16248 static char *
string_convert_int_cst(node)16249 string_convert_int_cst (node)
16250 tree node;
16251 {
16252 /* Long.MIN_VALUE is -9223372036854775808, 20 characters. */
16253 static char buffer[21];
16254
16255 unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
16256 unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
16257 char *p = buffer + sizeof (buffer);
16258 int neg = 0;
16259
16260 unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
16261 << (HOST_BITS_PER_WIDE_INT - 1));
16262
16263 *--p = '\0';
16264
16265 /* If negative, note the fact and negate the value. */
16266 if ((hi & hibit))
16267 {
16268 lo = ~lo;
16269 hi = ~hi;
16270 if (++lo == 0)
16271 ++hi;
16272 neg = 1;
16273 }
16274
16275 /* Divide by 10 until there are no bits left. */
16276 do
16277 {
16278 unsigned HOST_WIDE_INT acc = 0;
16279 unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
16280 unsigned int i;
16281
16282 /* Use long division to compute the result and the remainder. */
16283 for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
16284 {
16285 /* Shift a bit into accumulator. */
16286 acc <<= 1;
16287 if ((hi & hibit))
16288 acc |= 1;
16289
16290 /* Shift the value. */
16291 hi <<= 1;
16292 if ((lo & hibit))
16293 hi |= 1;
16294 lo <<= 1;
16295
16296 /* Shift the correct bit into the result. */
16297 outhi <<= 1;
16298 if ((outlo & hibit))
16299 outhi |= 1;
16300 outlo <<= 1;
16301 if (acc >= 10)
16302 {
16303 acc -= 10;
16304 outlo |= 1;
16305 }
16306 }
16307
16308 /* '0' == 060 in Java, but might not be here (think EBCDIC). */
16309 *--p = '\060' + acc;
16310
16311 hi = outhi;
16312 lo = outlo;
16313 }
16314 while (hi || lo);
16315
16316 if (neg)
16317 *--p = '\055'; /* '-' == 055 in Java, but might not be here. */
16318
16319 return p;
16320 }
16321
16322 /* Print an INTEGER_CST node in a static buffer, and return the
16323 buffer. This is used only for error handling. */
16324 char *
print_int_node(node)16325 print_int_node (node)
16326 tree node;
16327 {
16328 static char buffer [80];
16329 if (TREE_CONSTANT_OVERFLOW (node))
16330 sprintf (buffer, "<overflow>");
16331
16332 if (TREE_INT_CST_HIGH (node) == 0)
16333 sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
16334 TREE_INT_CST_LOW (node));
16335 else if (TREE_INT_CST_HIGH (node) == -1
16336 && TREE_INT_CST_LOW (node) != 0)
16337 {
16338 buffer [0] = '-';
16339 sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
16340 -TREE_INT_CST_LOW (node));
16341 }
16342 else
16343 sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
16344 TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
16345
16346 return buffer;
16347 }
16348
16349
16350 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
16351 context. */
16352
16353 /* 15.25 Assignment operators. */
16354
16355 static tree
patch_assignment(node,wfl_op1)16356 patch_assignment (node, wfl_op1)
16357 tree node;
16358 tree wfl_op1;
16359 {
16360 tree rhs = TREE_OPERAND (node, 1);
16361 tree lvalue = TREE_OPERAND (node, 0), llvalue;
16362 tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
16363 int error_found = 0;
16364 int lvalue_from_array = 0;
16365 int is_return = 0;
16366
16367 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
16368
16369 /* Lhs can be a named variable */
16370 if (JDECL_P (lvalue))
16371 {
16372 lhs_type = TREE_TYPE (lvalue);
16373 }
16374 /* Or Lhs can be an array access. */
16375 else if (TREE_CODE (lvalue) == ARRAY_REF)
16376 {
16377 lhs_type = TREE_TYPE (lvalue);
16378 lvalue_from_array = 1;
16379 }
16380 /* Or a field access */
16381 else if (TREE_CODE (lvalue) == COMPONENT_REF)
16382 lhs_type = TREE_TYPE (lvalue);
16383 /* Or a function return slot */
16384 else if (TREE_CODE (lvalue) == RESULT_DECL)
16385 {
16386 /* If the return type is an integral type, then we create the
16387 RESULT_DECL with a promoted type, but we need to do these
16388 checks against the unpromoted type to ensure type safety. So
16389 here we look at the real type, not the type of the decl we
16390 are modifying. */
16391 lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
16392 is_return = 1;
16393 }
16394 /* Otherwise, we might want to try to write into an optimized static
16395 final, this is an of a different nature, reported further on. */
16396 else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
16397 && resolve_expression_name (wfl_op1, &llvalue))
16398 {
16399 lhs_type = TREE_TYPE (lvalue);
16400 }
16401 else
16402 {
16403 parse_error_context (wfl_op1, "Invalid left hand side of assignment");
16404 error_found = 1;
16405 }
16406
16407 rhs_type = TREE_TYPE (rhs);
16408
16409 /* 5.1 Try the assignment conversion for builtin type. */
16410 new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
16411
16412 /* 5.2 If it failed, try a reference conversion */
16413 if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
16414 lhs_type = promote_type (rhs_type);
16415
16416 /* 15.25.2 If we have a compound assignment, convert RHS into the
16417 type of the LHS */
16418 else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
16419 new_rhs = convert (lhs_type, rhs);
16420
16421 /* Explicit cast required. This is an error */
16422 if (!new_rhs)
16423 {
16424 char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
16425 char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
16426 tree wfl;
16427 char operation [32]; /* Max size known */
16428
16429 /* If the assignment is part of a declaration, we use the WFL of
16430 the declared variable to point out the error and call it a
16431 declaration problem. If the assignment is a genuine =
16432 operator, we call is a operator `=' problem, otherwise we
16433 call it an assignment problem. In both of these last cases,
16434 we use the WFL of the operator to indicate the error. */
16435
16436 if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
16437 {
16438 wfl = wfl_op1;
16439 strcpy (operation, "declaration");
16440 }
16441 else
16442 {
16443 wfl = wfl_operator;
16444 if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
16445 strcpy (operation, "assignment");
16446 else if (is_return)
16447 strcpy (operation, "`return'");
16448 else
16449 strcpy (operation, "`='");
16450 }
16451
16452 if (!valid_cast_to_p (rhs_type, lhs_type))
16453 parse_error_context
16454 (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
16455 operation, t1, t2);
16456 else
16457 parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
16458 operation, t1, t2);
16459 free (t1); free (t2);
16460 error_found = 1;
16461 }
16462
16463 if (error_found)
16464 return error_mark_node;
16465
16466 /* If we're processing a `return' statement, promote the actual type
16467 to the promoted type. */
16468 if (is_return)
16469 new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
16470
16471 /* 10.10: Array Store Exception runtime check */
16472 if (!flag_emit_class_files
16473 && !flag_emit_xref
16474 && lvalue_from_array
16475 && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
16476 {
16477 tree array, store_check, base, index_expr;
16478
16479 /* Save RHS so that it doesn't get re-evaluated by the store check. */
16480 new_rhs = save_expr (new_rhs);
16481
16482 /* Get the INDIRECT_REF. */
16483 array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
16484 /* Get the array pointer expr. */
16485 array = TREE_OPERAND (array, 0);
16486 store_check = build_java_arraystore_check (array, new_rhs);
16487
16488 index_expr = TREE_OPERAND (lvalue, 1);
16489
16490 if (TREE_CODE (index_expr) == COMPOUND_EXPR)
16491 {
16492 /* A COMPOUND_EXPR here is a bounds check. The bounds check must
16493 happen before the store check, so prepare to insert the store
16494 check within the second operand of the existing COMPOUND_EXPR. */
16495 base = index_expr;
16496 }
16497 else
16498 base = lvalue;
16499
16500 index_expr = TREE_OPERAND (base, 1);
16501 TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
16502 store_check, index_expr);
16503 }
16504
16505 /* Final locals can be used as case values in switch
16506 statement. Prepare them for this eventuality. */
16507 if (TREE_CODE (lvalue) == VAR_DECL
16508 && DECL_FINAL (lvalue)
16509 && TREE_CONSTANT (new_rhs)
16510 && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
16511 && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
16512 )
16513 {
16514 TREE_CONSTANT (lvalue) = 1;
16515 DECL_INITIAL (lvalue) = new_rhs;
16516 }
16517
16518 /* Copy the rhs if it's a reference. */
16519 if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
16520 {
16521 switch (TREE_CODE (new_rhs))
16522 {
16523 case ARRAY_REF:
16524 case INDIRECT_REF:
16525 case COMPONENT_REF:
16526 /* Transform a = foo.bar
16527 into a = { int tmp; tmp = foo.bar; tmp; ).
16528 We need to ensure that if a read from memory fails
16529 because of a NullPointerException, a destination variable
16530 will remain unchanged. An explicit temporary does what
16531 we need.
16532
16533 If flag_check_references is set, this is unnecessary
16534 because we'll check each reference before doing any
16535 reads. If optimize is not set the result will never be
16536 written to a stack slot that contains the LHS. */
16537 {
16538 tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
16539 TREE_TYPE (new_rhs));
16540 tree block = build (BLOCK, TREE_TYPE (new_rhs), NULL);
16541 tree assignment
16542 = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
16543 BLOCK_VARS (block) = tmp;
16544 BLOCK_EXPR_BODY (block)
16545 = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
16546 TREE_SIDE_EFFECTS (block) = 1;
16547 new_rhs = block;
16548 }
16549 break;
16550 default:
16551 break;
16552 }
16553 }
16554
16555 TREE_OPERAND (node, 0) = lvalue;
16556 TREE_OPERAND (node, 1) = new_rhs;
16557 TREE_TYPE (node) = lhs_type;
16558 return node;
16559 }
16560
16561 /* Check that type SOURCE can be cast into type DEST. If the cast
16562 can't occur at all, return NULL; otherwise, return a possibly
16563 modified rhs. */
16564
16565 static tree
try_reference_assignconv(lhs_type,rhs)16566 try_reference_assignconv (lhs_type, rhs)
16567 tree lhs_type, rhs;
16568 {
16569 tree new_rhs = NULL_TREE;
16570 tree rhs_type = TREE_TYPE (rhs);
16571
16572 if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
16573 {
16574 /* `null' may be assigned to any reference type */
16575 if (rhs == null_pointer_node)
16576 new_rhs = null_pointer_node;
16577 /* Try the reference assignment conversion */
16578 else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
16579 new_rhs = rhs;
16580 /* This is a magic assignment that we process differently */
16581 else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
16582 new_rhs = rhs;
16583 }
16584 return new_rhs;
16585 }
16586
16587 /* Check that RHS can be converted into LHS_TYPE by the assignment
16588 conversion (5.2), for the cases of RHS being a builtin type. Return
16589 NULL_TREE if the conversion fails or if because RHS isn't of a
16590 builtin type. Return a converted RHS if the conversion is possible. */
16591
16592 static tree
try_builtin_assignconv(wfl_op1,lhs_type,rhs)16593 try_builtin_assignconv (wfl_op1, lhs_type, rhs)
16594 tree wfl_op1, lhs_type, rhs;
16595 {
16596 tree new_rhs = NULL_TREE;
16597 tree rhs_type = TREE_TYPE (rhs);
16598
16599 /* Handle boolean specially. */
16600 if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
16601 || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
16602 {
16603 if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
16604 && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
16605 new_rhs = rhs;
16606 }
16607
16608 /* 5.1.1 Try Identity Conversion,
16609 5.1.2 Try Widening Primitive Conversion */
16610 else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
16611 new_rhs = convert (lhs_type, rhs);
16612
16613 /* Try a narrowing primitive conversion (5.1.3):
16614 - expression is a constant expression of type byte, short, char,
16615 or int, AND
16616 - variable is byte, short or char AND
16617 - The value of the expression is representable in the type of the
16618 variable */
16619 else if ((rhs_type == byte_type_node || rhs_type == short_type_node
16620 || rhs_type == char_type_node || rhs_type == int_type_node)
16621 && TREE_CONSTANT (rhs)
16622 && (lhs_type == byte_type_node || lhs_type == char_type_node
16623 || lhs_type == short_type_node))
16624 {
16625 if (int_fits_type_p (rhs, lhs_type))
16626 new_rhs = convert (lhs_type, rhs);
16627 else if (wfl_op1) /* Might be called with a NULL */
16628 parse_warning_context
16629 (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
16630 print_int_node (rhs), lang_printable_name (lhs_type, 0));
16631 /* Reported a warning that will turn into an error further
16632 down, so we don't return */
16633 }
16634
16635 return new_rhs;
16636 }
16637
16638 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
16639 conversion (5.1.1) or widening primitive conversion (5.1.2). Return
16640 0 is the conversion test fails. This implements parts the method
16641 invocation convertion (5.3). */
16642
16643 static int
valid_builtin_assignconv_identity_widening_p(lhs_type,rhs_type)16644 valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type)
16645 tree lhs_type, rhs_type;
16646 {
16647 /* 5.1.1: This is the identity conversion part. */
16648 if (lhs_type == rhs_type)
16649 return 1;
16650
16651 /* Reject non primitive types and boolean conversions. */
16652 if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
16653 return 0;
16654
16655 /* 5.1.2: widening primitive conversion. byte, even if it's smaller
16656 than a char can't be converted into a char. Short can't too, but
16657 the < test below takes care of that */
16658 if (lhs_type == char_type_node && rhs_type == byte_type_node)
16659 return 0;
16660
16661 /* Accept all promoted type here. Note, we can't use <= in the test
16662 below, because we still need to bounce out assignments of short
16663 to char and the likes */
16664 if (lhs_type == int_type_node
16665 && (rhs_type == promoted_byte_type_node
16666 || rhs_type == promoted_short_type_node
16667 || rhs_type == promoted_char_type_node
16668 || rhs_type == promoted_boolean_type_node))
16669 return 1;
16670
16671 /* From here, an integral is widened if its precision is smaller
16672 than the precision of the LHS or if the LHS is a floating point
16673 type, or the RHS is a float and the RHS a double. */
16674 if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
16675 && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
16676 || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
16677 || (rhs_type == float_type_node && lhs_type == double_type_node))
16678 return 1;
16679
16680 return 0;
16681 }
16682
16683 /* Check that something of SOURCE type can be assigned or cast to
16684 something of DEST type at runtime. Return 1 if the operation is
16685 valid, 0 otherwise. If CAST is set to 1, we're treating the case
16686 were SOURCE is cast into DEST, which borrows a lot of the
16687 assignment check. */
16688
16689 static int
valid_ref_assignconv_cast_p(source,dest,cast)16690 valid_ref_assignconv_cast_p (source, dest, cast)
16691 tree source;
16692 tree dest;
16693 int cast;
16694 {
16695 /* SOURCE or DEST might be null if not from a declared entity. */
16696 if (!source || !dest)
16697 return 0;
16698 if (JNULLP_TYPE_P (source))
16699 return 1;
16700 if (TREE_CODE (source) == POINTER_TYPE)
16701 source = TREE_TYPE (source);
16702 if (TREE_CODE (dest) == POINTER_TYPE)
16703 dest = TREE_TYPE (dest);
16704
16705 /* If source and dest are being compiled from bytecode, they may need to
16706 be loaded. */
16707 if (CLASS_P (source) && !CLASS_LOADED_P (source))
16708 {
16709 load_class (source, 1);
16710 safe_layout_class (source);
16711 }
16712 if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
16713 {
16714 load_class (dest, 1);
16715 safe_layout_class (dest);
16716 }
16717
16718 /* Case where SOURCE is a class type */
16719 if (TYPE_CLASS_P (source))
16720 {
16721 if (TYPE_CLASS_P (dest))
16722 return (source == dest
16723 || inherits_from_p (source, dest)
16724 || (cast && inherits_from_p (dest, source)));
16725 if (TYPE_INTERFACE_P (dest))
16726 {
16727 /* If doing a cast and SOURCE is final, the operation is
16728 always correct a compile time (because even if SOURCE
16729 does not implement DEST, a subclass of SOURCE might). */
16730 if (cast && !CLASS_FINAL (TYPE_NAME (source)))
16731 return 1;
16732 /* Otherwise, SOURCE must implement DEST */
16733 return interface_of_p (dest, source);
16734 }
16735 /* DEST is an array, cast permited if SOURCE is of Object type */
16736 return (cast && source == object_type_node ? 1 : 0);
16737 }
16738 if (TYPE_INTERFACE_P (source))
16739 {
16740 if (TYPE_CLASS_P (dest))
16741 {
16742 /* If not casting, DEST must be the Object type */
16743 if (!cast)
16744 return dest == object_type_node;
16745 /* We're doing a cast. The cast is always valid is class
16746 DEST is not final, otherwise, DEST must implement SOURCE */
16747 else if (!CLASS_FINAL (TYPE_NAME (dest)))
16748 return 1;
16749 else
16750 return interface_of_p (source, dest);
16751 }
16752 if (TYPE_INTERFACE_P (dest))
16753 {
16754 /* If doing a cast, then if SOURCE and DEST contain method
16755 with the same signature but different return type, then
16756 this is a (compile time) error */
16757 if (cast)
16758 {
16759 tree method_source, method_dest;
16760 tree source_type;
16761 tree source_sig;
16762 tree source_name;
16763 for (method_source = TYPE_METHODS (source); method_source;
16764 method_source = TREE_CHAIN (method_source))
16765 {
16766 source_sig =
16767 build_java_argument_signature (TREE_TYPE (method_source));
16768 source_type = TREE_TYPE (TREE_TYPE (method_source));
16769 source_name = DECL_NAME (method_source);
16770 for (method_dest = TYPE_METHODS (dest);
16771 method_dest; method_dest = TREE_CHAIN (method_dest))
16772 if (source_sig ==
16773 build_java_argument_signature (TREE_TYPE (method_dest))
16774 && source_name == DECL_NAME (method_dest)
16775 && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
16776 return 0;
16777 }
16778 return 1;
16779 }
16780 else
16781 return source == dest || interface_of_p (dest, source);
16782 }
16783 else
16784 {
16785 /* Array */
16786 return (cast
16787 && (DECL_NAME (TYPE_NAME (source))
16788 == java_lang_cloneable_identifier_node
16789 || (DECL_NAME (TYPE_NAME (source))
16790 == java_io_serializable_identifier_node)));
16791 }
16792 }
16793 if (TYPE_ARRAY_P (source))
16794 {
16795 if (TYPE_CLASS_P (dest))
16796 return dest == object_type_node;
16797 /* Can't cast an array to an interface unless the interface is
16798 java.lang.Cloneable or java.io.Serializable. */
16799 if (TYPE_INTERFACE_P (dest))
16800 return (DECL_NAME (TYPE_NAME (dest))
16801 == java_lang_cloneable_identifier_node
16802 || (DECL_NAME (TYPE_NAME (dest))
16803 == java_io_serializable_identifier_node));
16804 else /* Arrays */
16805 {
16806 tree source_element_type = TYPE_ARRAY_ELEMENT (source);
16807 tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
16808
16809 /* In case of severe errors, they turn out null */
16810 if (!dest_element_type || !source_element_type)
16811 return 0;
16812 if (source_element_type == dest_element_type)
16813 return 1;
16814 return valid_ref_assignconv_cast_p (source_element_type,
16815 dest_element_type, cast);
16816 }
16817 return 0;
16818 }
16819 return 0;
16820 }
16821
16822 static int
valid_cast_to_p(source,dest)16823 valid_cast_to_p (source, dest)
16824 tree source;
16825 tree dest;
16826 {
16827 if (TREE_CODE (source) == POINTER_TYPE)
16828 source = TREE_TYPE (source);
16829 if (TREE_CODE (dest) == POINTER_TYPE)
16830 dest = TREE_TYPE (dest);
16831
16832 if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
16833 return valid_ref_assignconv_cast_p (source, dest, 1);
16834
16835 else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
16836 return 1;
16837
16838 else if (TREE_CODE (source) == BOOLEAN_TYPE
16839 && TREE_CODE (dest) == BOOLEAN_TYPE)
16840 return 1;
16841
16842 return 0;
16843 }
16844
16845 static tree
do_unary_numeric_promotion(arg)16846 do_unary_numeric_promotion (arg)
16847 tree arg;
16848 {
16849 tree type = TREE_TYPE (arg);
16850 if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
16851 || TREE_CODE (type) == CHAR_TYPE)
16852 arg = convert (int_type_node, arg);
16853 return arg;
16854 }
16855
16856 /* Return a nonzero value if SOURCE can be converted into DEST using
16857 the method invocation conversion rule (5.3). */
16858 static int
valid_method_invocation_conversion_p(dest,source)16859 valid_method_invocation_conversion_p (dest, source)
16860 tree dest, source;
16861 {
16862 return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
16863 && valid_builtin_assignconv_identity_widening_p (dest, source))
16864 || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
16865 && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
16866 && valid_ref_assignconv_cast_p (source, dest, 0)));
16867 }
16868
16869 /* Build an incomplete binop expression. */
16870
16871 static tree
build_binop(op,op_location,op1,op2)16872 build_binop (op, op_location, op1, op2)
16873 enum tree_code op;
16874 int op_location;
16875 tree op1, op2;
16876 {
16877 tree binop = build (op, NULL_TREE, op1, op2);
16878 TREE_SIDE_EFFECTS (binop) = 1;
16879 /* Store the location of the operator, for better error report. The
16880 string of the operator will be rebuild based on the OP value. */
16881 EXPR_WFL_LINECOL (binop) = op_location;
16882 return binop;
16883 }
16884
16885 /* Build the string of the operator retained by NODE. If NODE is part
16886 of a compound expression, add an '=' at the end of the string. This
16887 function is called when an error needs to be reported on an
16888 operator. The string is returned as a pointer to a static character
16889 buffer. */
16890
16891 static char *
operator_string(node)16892 operator_string (node)
16893 tree node;
16894 {
16895 #define BUILD_OPERATOR_STRING(S) \
16896 { \
16897 sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
16898 return buffer; \
16899 }
16900
16901 static char buffer [10];
16902 switch (TREE_CODE (node))
16903 {
16904 case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
16905 case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
16906 case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
16907 case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
16908 case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
16909 case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
16910 case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
16911 case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
16912 case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
16913 case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
16914 case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
16915 case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
16916 case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
16917 case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
16918 case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
16919 case GT_EXPR: BUILD_OPERATOR_STRING (">");
16920 case GE_EXPR: BUILD_OPERATOR_STRING (">=");
16921 case LT_EXPR: BUILD_OPERATOR_STRING ("<");
16922 case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
16923 case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
16924 case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
16925 case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
16926 case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
16927 case PREINCREMENT_EXPR: /* Fall through */
16928 case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
16929 case PREDECREMENT_EXPR: /* Fall through */
16930 case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
16931 default:
16932 internal_error ("unregistered operator %s",
16933 tree_code_name [TREE_CODE (node)]);
16934 }
16935 return NULL;
16936 #undef BUILD_OPERATOR_STRING
16937 }
16938
16939 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2. */
16940
16941 static int
java_decl_equiv(var_acc1,var_acc2)16942 java_decl_equiv (var_acc1, var_acc2)
16943 tree var_acc1, var_acc2;
16944 {
16945 if (JDECL_P (var_acc1))
16946 return (var_acc1 == var_acc2);
16947
16948 return (TREE_CODE (var_acc1) == COMPONENT_REF
16949 && TREE_CODE (var_acc2) == COMPONENT_REF
16950 && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
16951 == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
16952 && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
16953 }
16954
16955 /* Return a nonzero value if CODE is one of the operators that can be
16956 used in conjunction with the `=' operator in a compound assignment. */
16957
16958 static int
binop_compound_p(code)16959 binop_compound_p (code)
16960 enum tree_code code;
16961 {
16962 int i;
16963 for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
16964 if (binop_lookup [i] == code)
16965 break;
16966
16967 return i < BINOP_COMPOUND_CANDIDATES;
16968 }
16969
16970 /* Reorganize after a fold to get SAVE_EXPR to generate what we want. */
16971
16972 static tree
java_refold(t)16973 java_refold (t)
16974 tree t;
16975 {
16976 tree c, b, ns, decl;
16977
16978 if (TREE_CODE (t) != MODIFY_EXPR)
16979 return t;
16980
16981 c = TREE_OPERAND (t, 1);
16982 if (! (c && TREE_CODE (c) == COMPOUND_EXPR
16983 && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
16984 && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
16985 return t;
16986
16987 /* Now the left branch of the binary operator. */
16988 b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
16989 if (! (b && TREE_CODE (b) == NOP_EXPR
16990 && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
16991 return t;
16992
16993 ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
16994 if (! (ns && TREE_CODE (ns) == NOP_EXPR
16995 && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
16996 return t;
16997
16998 decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
16999 if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
17000 /* It's got to be the an equivalent decl */
17001 && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
17002 {
17003 /* Shorten the NOP_EXPR/SAVE_EXPR path. */
17004 TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
17005 /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
17006 TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
17007 /* Change the right part of the BINOP_EXPR */
17008 TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
17009 }
17010
17011 return t;
17012 }
17013
17014 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
17015 errors but we modify NODE so that it contains the type computed
17016 according to the expression, when it's fixed. Otherwise, we write
17017 error_mark_node as the type. It allows us to further the analysis
17018 of remaining nodes and detects more errors in certain cases. */
17019
17020 static tree
patch_binop(node,wfl_op1,wfl_op2)17021 patch_binop (node, wfl_op1, wfl_op2)
17022 tree node;
17023 tree wfl_op1;
17024 tree wfl_op2;
17025 {
17026 tree op1 = TREE_OPERAND (node, 0);
17027 tree op2 = TREE_OPERAND (node, 1);
17028 tree op1_type = TREE_TYPE (op1);
17029 tree op2_type = TREE_TYPE (op2);
17030 tree prom_type = NULL_TREE, cn;
17031 enum tree_code code = TREE_CODE (node);
17032
17033 /* If 1, tell the routine that we have to return error_mark_node
17034 after checking for the initialization of the RHS */
17035 int error_found = 0;
17036
17037 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
17038
17039 /* If either op<n>_type are NULL, this might be early signs of an
17040 error situation, unless it's too early to tell (in case we're
17041 handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
17042 correctly so the error can be later on reported accurately. */
17043 if (! (code == PLUS_EXPR || code == NE_EXPR
17044 || code == EQ_EXPR || code == INSTANCEOF_EXPR))
17045 {
17046 tree n;
17047 if (! op1_type)
17048 {
17049 n = java_complete_tree (op1);
17050 op1_type = TREE_TYPE (n);
17051 }
17052 if (! op2_type)
17053 {
17054 n = java_complete_tree (op2);
17055 op2_type = TREE_TYPE (n);
17056 }
17057 }
17058
17059 switch (code)
17060 {
17061 /* 15.16 Multiplicative operators */
17062 case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
17063 case RDIV_EXPR: /* 15.16.2 Division Operator / */
17064 case TRUNC_DIV_EXPR: /* 15.16.2 Integral type Division Operator / */
17065 case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
17066 if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
17067 {
17068 if (!JNUMERIC_TYPE_P (op1_type))
17069 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
17070 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
17071 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
17072 TREE_TYPE (node) = error_mark_node;
17073 error_found = 1;
17074 break;
17075 }
17076 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
17077
17078 /* Detect integral division by zero */
17079 if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
17080 && TREE_CODE (prom_type) == INTEGER_TYPE
17081 && (op2 == integer_zero_node || op2 == long_zero_node ||
17082 (TREE_CODE (op2) == INTEGER_CST &&
17083 ! TREE_INT_CST_LOW (op2) && ! TREE_INT_CST_HIGH (op2))))
17084 {
17085 parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
17086 TREE_CONSTANT (node) = 0;
17087 }
17088
17089 /* Change the division operator if necessary */
17090 if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
17091 TREE_SET_CODE (node, TRUNC_DIV_EXPR);
17092
17093 /* Before divisions as is disapear, try to simplify and bail if
17094 applicable, otherwise we won't perform even simple
17095 simplifications like (1-1)/3. We can't do that with floating
17096 point number, folds can't handle them at this stage. */
17097 if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
17098 && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
17099 {
17100 TREE_TYPE (node) = prom_type;
17101 node = fold (node);
17102 if (TREE_CODE (node) != code)
17103 return node;
17104 }
17105
17106 if (TREE_CODE (prom_type) == INTEGER_TYPE
17107 && flag_use_divide_subroutine
17108 && ! flag_emit_class_files
17109 && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
17110 return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
17111
17112 /* This one is more complicated. FLOATs are processed by a
17113 function call to soft_fmod. Duplicate the value of the
17114 COMPOUND_ASSIGN_P flag. */
17115 if (code == TRUNC_MOD_EXPR)
17116 {
17117 tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
17118 COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
17119 TREE_SIDE_EFFECTS (mod)
17120 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
17121 return mod;
17122 }
17123 break;
17124
17125 /* 15.17 Additive Operators */
17126 case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
17127
17128 /* Operation is valid if either one argument is a string
17129 constant, a String object or a StringBuffer crafted for the
17130 purpose of the a previous usage of the String concatenation
17131 operator */
17132
17133 if (TREE_CODE (op1) == STRING_CST
17134 || TREE_CODE (op2) == STRING_CST
17135 || JSTRING_TYPE_P (op1_type)
17136 || JSTRING_TYPE_P (op2_type)
17137 || IS_CRAFTED_STRING_BUFFER_P (op1)
17138 || IS_CRAFTED_STRING_BUFFER_P (op2))
17139 return build_string_concatenation (op1, op2);
17140
17141 case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
17142 Numeric Types */
17143 if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
17144 {
17145 if (!JNUMERIC_TYPE_P (op1_type))
17146 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
17147 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
17148 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
17149 TREE_TYPE (node) = error_mark_node;
17150 error_found = 1;
17151 break;
17152 }
17153 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
17154 break;
17155
17156 /* 15.18 Shift Operators */
17157 case LSHIFT_EXPR:
17158 case RSHIFT_EXPR:
17159 case URSHIFT_EXPR:
17160 if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
17161 {
17162 if (!JINTEGRAL_TYPE_P (op1_type))
17163 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
17164 else
17165 {
17166 if (JNUMERIC_TYPE_P (op2_type))
17167 parse_error_context (wfl_operator,
17168 "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
17169 operator_string (node),
17170 lang_printable_name (op2_type, 0));
17171 else
17172 parse_error_context (wfl_operator,
17173 "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
17174 operator_string (node),
17175 lang_printable_name (op2_type, 0));
17176 }
17177 TREE_TYPE (node) = error_mark_node;
17178 error_found = 1;
17179 break;
17180 }
17181
17182 /* Unary numeric promotion (5.6.1) is performed on each operand
17183 separately */
17184 op1 = do_unary_numeric_promotion (op1);
17185 op2 = do_unary_numeric_promotion (op2);
17186
17187 /* If the right hand side is of type `long', first cast it to
17188 `int'. */
17189 if (TREE_TYPE (op2) == long_type_node)
17190 op2 = build1 (CONVERT_EXPR, int_type_node, op2);
17191
17192 /* The type of the shift expression is the type of the promoted
17193 type of the left-hand operand */
17194 prom_type = TREE_TYPE (op1);
17195
17196 /* Shift int only up to 0x1f and long up to 0x3f */
17197 if (prom_type == int_type_node)
17198 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
17199 build_int_2 (0x1f, 0)));
17200 else
17201 op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
17202 build_int_2 (0x3f, 0)));
17203
17204 /* The >>> operator is a >> operating on unsigned quantities */
17205 if (code == URSHIFT_EXPR && ! flag_emit_class_files)
17206 {
17207 tree to_return;
17208 tree utype = java_unsigned_type (prom_type);
17209 op1 = convert (utype, op1);
17210 TREE_SET_CODE (node, RSHIFT_EXPR);
17211 TREE_OPERAND (node, 0) = op1;
17212 TREE_OPERAND (node, 1) = op2;
17213 TREE_TYPE (node) = utype;
17214 to_return = convert (prom_type, node);
17215 /* Copy the original value of the COMPOUND_ASSIGN_P flag */
17216 COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
17217 TREE_SIDE_EFFECTS (to_return)
17218 = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
17219 return to_return;
17220 }
17221 break;
17222
17223 /* 15.19.1 Type Comparison Operator instaceof */
17224 case INSTANCEOF_EXPR:
17225
17226 TREE_TYPE (node) = boolean_type_node;
17227
17228 /* OP1_TYPE might be NULL when OP1 is a string constant. */
17229 if ((cn = patch_string (op1)))
17230 {
17231 op1 = cn;
17232 op1_type = TREE_TYPE (op1);
17233 }
17234 if (op1_type == NULL_TREE)
17235 abort ();
17236
17237 if (!(op2_type = resolve_type_during_patch (op2)))
17238 return error_mark_node;
17239
17240 /* The first operand must be a reference type or the null type */
17241 if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
17242 error_found = 1; /* Error reported further below */
17243
17244 /* The second operand must be a reference type */
17245 if (!JREFERENCE_TYPE_P (op2_type))
17246 {
17247 SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
17248 parse_error_context
17249 (wfl_operator, "Invalid argument `%s' for `instanceof'",
17250 lang_printable_name (op2_type, 0));
17251 error_found = 1;
17252 }
17253
17254 if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
17255 {
17256 /* If the first operand is null, the result is always false */
17257 if (op1 == null_pointer_node)
17258 return boolean_false_node;
17259 else if (flag_emit_class_files)
17260 {
17261 TREE_OPERAND (node, 1) = op2_type;
17262 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
17263 return node;
17264 }
17265 /* Otherwise we have to invoke instance of to figure it out */
17266 else
17267 return build_instanceof (op1, op2_type);
17268 }
17269 /* There is no way the expression operand can be an instance of
17270 the type operand. This is a compile time error. */
17271 else
17272 {
17273 char *t1 = xstrdup (lang_printable_name (op1_type, 0));
17274 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
17275 parse_error_context
17276 (wfl_operator, "Impossible for `%s' to be instance of `%s'",
17277 t1, lang_printable_name (op2_type, 0));
17278 free (t1);
17279 error_found = 1;
17280 }
17281
17282 break;
17283
17284 /* 15.21 Bitwise and Logical Operators */
17285 case BIT_AND_EXPR:
17286 case BIT_XOR_EXPR:
17287 case BIT_IOR_EXPR:
17288 if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
17289 /* Binary numeric promotion is performed on both operand and the
17290 expression retain that type */
17291 prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
17292
17293 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
17294 && TREE_CODE (op1_type) == BOOLEAN_TYPE)
17295 /* The type of the bitwise operator expression is BOOLEAN */
17296 prom_type = boolean_type_node;
17297 else
17298 {
17299 if (!JINTEGRAL_TYPE_P (op1_type))
17300 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
17301 if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
17302 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
17303 TREE_TYPE (node) = error_mark_node;
17304 error_found = 1;
17305 /* Insert a break here if adding thing before the switch's
17306 break for this case */
17307 }
17308 break;
17309
17310 /* 15.22 Conditional-And Operator */
17311 case TRUTH_ANDIF_EXPR:
17312 /* 15.23 Conditional-Or Operator */
17313 case TRUTH_ORIF_EXPR:
17314 /* Operands must be of BOOLEAN type */
17315 if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
17316 TREE_CODE (op2_type) != BOOLEAN_TYPE)
17317 {
17318 if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
17319 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
17320 if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
17321 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
17322 TREE_TYPE (node) = boolean_type_node;
17323 error_found = 1;
17324 break;
17325 }
17326 else if (integer_zerop (op1))
17327 {
17328 return code == TRUTH_ANDIF_EXPR ? op1 : op2;
17329 }
17330 else if (integer_onep (op1))
17331 {
17332 return code == TRUTH_ANDIF_EXPR ? op2 : op1;
17333 }
17334 /* The type of the conditional operators is BOOLEAN */
17335 prom_type = boolean_type_node;
17336 break;
17337
17338 /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
17339 case LT_EXPR:
17340 case GT_EXPR:
17341 case LE_EXPR:
17342 case GE_EXPR:
17343 /* The type of each of the operands must be a primitive numeric
17344 type */
17345 if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
17346 {
17347 if (!JNUMERIC_TYPE_P (op1_type))
17348 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
17349 if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
17350 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
17351 TREE_TYPE (node) = boolean_type_node;
17352 error_found = 1;
17353 break;
17354 }
17355 /* Binary numeric promotion is performed on the operands */
17356 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
17357 /* The type of the relation expression is always BOOLEAN */
17358 prom_type = boolean_type_node;
17359 break;
17360
17361 /* 15.20 Equality Operator */
17362 case EQ_EXPR:
17363 case NE_EXPR:
17364 /* It's time for us to patch the strings. */
17365 if ((cn = patch_string (op1)))
17366 {
17367 op1 = cn;
17368 op1_type = TREE_TYPE (op1);
17369 }
17370 if ((cn = patch_string (op2)))
17371 {
17372 op2 = cn;
17373 op2_type = TREE_TYPE (op2);
17374 }
17375
17376 /* 15.20.1 Numerical Equality Operators == and != */
17377 /* Binary numeric promotion is performed on the operands */
17378 if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
17379 binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
17380
17381 /* 15.20.2 Boolean Equality Operators == and != */
17382 else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
17383 TREE_CODE (op2_type) == BOOLEAN_TYPE)
17384 ; /* Nothing to do here */
17385
17386 /* 15.20.3 Reference Equality Operators == and != */
17387 /* Types have to be either references or the null type. If
17388 they're references, it must be possible to convert either
17389 type to the other by casting conversion. */
17390 else if (op1 == null_pointer_node || op2 == null_pointer_node
17391 || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
17392 && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
17393 || valid_ref_assignconv_cast_p (op2_type,
17394 op1_type, 1))))
17395 ; /* Nothing to do here */
17396
17397 /* Else we have an error figure what can't be converted into
17398 what and report the error */
17399 else
17400 {
17401 char *t1;
17402 t1 = xstrdup (lang_printable_name (op1_type, 0));
17403 parse_error_context
17404 (wfl_operator,
17405 "Incompatible type for `%s'. Can't convert `%s' to `%s'",
17406 operator_string (node), t1,
17407 lang_printable_name (op2_type, 0));
17408 free (t1);
17409 TREE_TYPE (node) = boolean_type_node;
17410 error_found = 1;
17411 break;
17412 }
17413 prom_type = boolean_type_node;
17414 break;
17415 default:
17416 abort ();
17417 }
17418
17419 if (error_found)
17420 return error_mark_node;
17421
17422 TREE_OPERAND (node, 0) = op1;
17423 TREE_OPERAND (node, 1) = op2;
17424 TREE_TYPE (node) = prom_type;
17425 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
17426
17427 if (flag_emit_xref)
17428 return node;
17429
17430 /* fold does not respect side-effect order as required for Java but not C.
17431 * Also, it sometimes create SAVE_EXPRs which are bad when emitting
17432 * bytecode.
17433 */
17434 if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
17435 : ! TREE_SIDE_EFFECTS (node))
17436 node = fold (node);
17437 return node;
17438 }
17439
17440 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
17441 zero value, the value of CSTE comes after the valude of STRING */
17442
17443 static tree
do_merge_string_cste(cste,string,string_len,after)17444 do_merge_string_cste (cste, string, string_len, after)
17445 tree cste;
17446 const char *string;
17447 int string_len, after;
17448 {
17449 const char *old = TREE_STRING_POINTER (cste);
17450 int old_len = TREE_STRING_LENGTH (cste);
17451 int len = old_len + string_len;
17452 char *new = alloca (len+1);
17453
17454 if (after)
17455 {
17456 memcpy (new, string, string_len);
17457 memcpy (&new [string_len], old, old_len);
17458 }
17459 else
17460 {
17461 memcpy (new, old, old_len);
17462 memcpy (&new [old_len], string, string_len);
17463 }
17464 new [len] = '\0';
17465 return build_string (len, new);
17466 }
17467
17468 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
17469 new STRING_CST on success, NULL_TREE on failure. */
17470
17471 static tree
merge_string_cste(op1,op2,after)17472 merge_string_cste (op1, op2, after)
17473 tree op1, op2;
17474 int after;
17475 {
17476 /* Handle two string constants right away. */
17477 if (TREE_CODE (op2) == STRING_CST)
17478 return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
17479 TREE_STRING_LENGTH (op2), after);
17480
17481 /* Reasonable integer constant can be treated right away. */
17482 if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
17483 {
17484 static const char *const boolean_true = "true";
17485 static const char *const boolean_false = "false";
17486 static const char *const null_pointer = "null";
17487 char ch[4];
17488 const char *string;
17489
17490 if (op2 == boolean_true_node)
17491 string = boolean_true;
17492 else if (op2 == boolean_false_node)
17493 string = boolean_false;
17494 else if (op2 == null_pointer_node)
17495 /* FIXME: null is not a compile-time constant, so it is only safe to
17496 merge if the overall expression is non-constant. However, this
17497 code always merges without checking the overall expression. */
17498 string = null_pointer;
17499 else if (TREE_TYPE (op2) == char_type_node)
17500 {
17501 /* Convert the character into UTF-8. */
17502 unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
17503 unsigned char *p = (unsigned char *) ch;
17504 if (0x01 <= c && c <= 0x7f)
17505 *p++ = (unsigned char) c;
17506 else if (c < 0x7ff)
17507 {
17508 *p++ = (unsigned char) (c >> 6 | 0xc0);
17509 *p++ = (unsigned char) ((c & 0x3f) | 0x80);
17510 }
17511 else
17512 {
17513 *p++ = (unsigned char) (c >> 12 | 0xe0);
17514 *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
17515 *p++ = (unsigned char) ((c & 0x3f) | 0x80);
17516 }
17517 *p = '\0';
17518
17519 string = ch;
17520 }
17521 else
17522 string = string_convert_int_cst (op2);
17523
17524 return do_merge_string_cste (op1, string, strlen (string), after);
17525 }
17526 return NULL_TREE;
17527 }
17528
17529 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
17530 has to be a STRING_CST and the other part must be a STRING_CST or a
17531 INTEGRAL constant. Return a new STRING_CST if the operation
17532 succeed, NULL_TREE otherwise.
17533
17534 If the case we want to optimize for space, we might want to return
17535 NULL_TREE for each invocation of this routine. FIXME */
17536
17537 static tree
string_constant_concatenation(op1,op2)17538 string_constant_concatenation (op1, op2)
17539 tree op1, op2;
17540 {
17541 if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
17542 {
17543 tree string, rest;
17544 int invert;
17545
17546 string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
17547 rest = (string == op1 ? op2 : op1);
17548 invert = (string == op1 ? 0 : 1 );
17549
17550 /* Walk REST, only if it looks reasonable */
17551 if (TREE_CODE (rest) != STRING_CST
17552 && !IS_CRAFTED_STRING_BUFFER_P (rest)
17553 && !JSTRING_TYPE_P (TREE_TYPE (rest))
17554 && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
17555 {
17556 rest = java_complete_tree (rest);
17557 if (rest == error_mark_node)
17558 return error_mark_node;
17559 rest = fold (rest);
17560 }
17561 return merge_string_cste (string, rest, invert);
17562 }
17563 return NULL_TREE;
17564 }
17565
17566 /* Implement the `+' operator. Does static optimization if possible,
17567 otherwise create (if necessary) and append elements to a
17568 StringBuffer. The StringBuffer will be carried around until it is
17569 used for a function call or an assignment. Then toString() will be
17570 called on it to turn it into a String object. */
17571
17572 static tree
build_string_concatenation(op1,op2)17573 build_string_concatenation (op1, op2)
17574 tree op1, op2;
17575 {
17576 tree result;
17577 int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
17578
17579 if (flag_emit_xref)
17580 return build (PLUS_EXPR, string_type_node, op1, op2);
17581
17582 /* Try to do some static optimization */
17583 if ((result = string_constant_concatenation (op1, op2)))
17584 return result;
17585
17586 /* Discard empty strings on either side of the expression */
17587 if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
17588 {
17589 op1 = op2;
17590 op2 = NULL_TREE;
17591 }
17592 else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
17593 op2 = NULL_TREE;
17594
17595 /* If operands are string constant, turn then into object references */
17596 if (TREE_CODE (op1) == STRING_CST)
17597 op1 = patch_string_cst (op1);
17598 if (op2 && TREE_CODE (op2) == STRING_CST)
17599 op2 = patch_string_cst (op2);
17600
17601 /* If either one of the constant is null and the other non null
17602 operand is a String constant, return it. */
17603 if ((TREE_CODE (op1) == STRING_CST) && !op2)
17604 return op1;
17605
17606 /* If OP1 isn't already a StringBuffer, create and
17607 initialize a new one */
17608 if (!IS_CRAFTED_STRING_BUFFER_P (op1))
17609 {
17610 /* Two solutions here:
17611 1) OP1 is a constant string reference, we call new StringBuffer(OP1)
17612 2) OP1 is something else, we call new StringBuffer().append(OP1). */
17613 if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
17614 op1 = BUILD_STRING_BUFFER (op1);
17615 else
17616 {
17617 tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
17618 op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
17619 }
17620 }
17621
17622 if (op2)
17623 {
17624 /* OP1 is no longer the last node holding a crafted StringBuffer */
17625 IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
17626 /* Create a node for `{new...,xxx}.append (op2)' */
17627 if (op2)
17628 op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
17629 }
17630
17631 /* Mark the last node holding a crafted StringBuffer */
17632 IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
17633
17634 TREE_SIDE_EFFECTS (op1) = side_effects;
17635 return op1;
17636 }
17637
17638 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
17639 StringBuffer. If no string were found to be patched, return
17640 NULL. */
17641
17642 static tree
patch_string(node)17643 patch_string (node)
17644 tree node;
17645 {
17646 if (node == error_mark_node)
17647 return error_mark_node;
17648 if (TREE_CODE (node) == STRING_CST)
17649 return patch_string_cst (node);
17650 else if (IS_CRAFTED_STRING_BUFFER_P (node))
17651 {
17652 int saved = ctxp->explicit_constructor_p;
17653 tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
17654 tree ret;
17655 /* Temporary disable forbid the use of `this'. */
17656 ctxp->explicit_constructor_p = 0;
17657 ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
17658 /* String concatenation arguments must be evaluated in order too. */
17659 ret = force_evaluation_order (ret);
17660 /* Restore it at its previous value */
17661 ctxp->explicit_constructor_p = saved;
17662 return ret;
17663 }
17664 return NULL_TREE;
17665 }
17666
17667 /* Build the internal representation of a string constant. */
17668
17669 static tree
patch_string_cst(node)17670 patch_string_cst (node)
17671 tree node;
17672 {
17673 int location;
17674 if (! flag_emit_class_files)
17675 {
17676 node = get_identifier (TREE_STRING_POINTER (node));
17677 location = alloc_name_constant (CONSTANT_String, node);
17678 node = build_ref_from_constant_pool (location);
17679 }
17680 TREE_TYPE (node) = string_ptr_type_node;
17681 TREE_CONSTANT (node) = 1;
17682 return node;
17683 }
17684
17685 /* Build an incomplete unary operator expression. */
17686
17687 static tree
build_unaryop(op_token,op_location,op1)17688 build_unaryop (op_token, op_location, op1)
17689 int op_token, op_location;
17690 tree op1;
17691 {
17692 enum tree_code op;
17693 tree unaryop;
17694 switch (op_token)
17695 {
17696 case PLUS_TK: op = UNARY_PLUS_EXPR; break;
17697 case MINUS_TK: op = NEGATE_EXPR; break;
17698 case NEG_TK: op = TRUTH_NOT_EXPR; break;
17699 case NOT_TK: op = BIT_NOT_EXPR; break;
17700 default: abort ();
17701 }
17702
17703 unaryop = build1 (op, NULL_TREE, op1);
17704 TREE_SIDE_EFFECTS (unaryop) = 1;
17705 /* Store the location of the operator, for better error report. The
17706 string of the operator will be rebuild based on the OP value. */
17707 EXPR_WFL_LINECOL (unaryop) = op_location;
17708 return unaryop;
17709 }
17710
17711 /* Special case for the ++/-- operators, since they require an extra
17712 argument to build, which is set to NULL and patched
17713 later. IS_POST_P is 1 if the operator, 0 otherwise. */
17714
17715 static tree
build_incdec(op_token,op_location,op1,is_post_p)17716 build_incdec (op_token, op_location, op1, is_post_p)
17717 int op_token, op_location;
17718 tree op1;
17719 int is_post_p;
17720 {
17721 static const enum tree_code lookup [2][2] =
17722 {
17723 { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
17724 { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
17725 };
17726 tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
17727 NULL_TREE, op1, NULL_TREE);
17728 TREE_SIDE_EFFECTS (node) = 1;
17729 /* Store the location of the operator, for better error report. The
17730 string of the operator will be rebuild based on the OP value. */
17731 EXPR_WFL_LINECOL (node) = op_location;
17732 return node;
17733 }
17734
17735 /* Build an incomplete cast operator, based on the use of the
17736 CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
17737 set. java_complete_tree is trained to walk a CONVERT_EXPR even
17738 though its type is already set. */
17739
17740 static tree
build_cast(location,type,exp)17741 build_cast (location, type, exp)
17742 int location;
17743 tree type, exp;
17744 {
17745 tree node = build1 (CONVERT_EXPR, type, exp);
17746 EXPR_WFL_LINECOL (node) = location;
17747 return node;
17748 }
17749
17750 /* Build an incomplete class reference operator. */
17751 static tree
build_incomplete_class_ref(location,class_name)17752 build_incomplete_class_ref (location, class_name)
17753 int location;
17754 tree class_name;
17755 {
17756 tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
17757 EXPR_WFL_LINECOL (node) = location;
17758 return node;
17759 }
17760
17761 /* Complete an incomplete class reference operator. */
17762 static tree
patch_incomplete_class_ref(node)17763 patch_incomplete_class_ref (node)
17764 tree node;
17765 {
17766 tree type = TREE_OPERAND (node, 0);
17767 tree ref_type;
17768
17769 if (!(ref_type = resolve_type_during_patch (type)))
17770 return error_mark_node;
17771
17772 if (!flag_emit_class_files || JPRIMITIVE_TYPE_P (ref_type)
17773 || TREE_CODE (ref_type) == VOID_TYPE)
17774 {
17775 tree dot = build_class_ref (ref_type);
17776 /* A class referenced by `foo.class' is initialized. */
17777 if (!flag_emit_class_files)
17778 dot = build_class_init (ref_type, dot);
17779 return java_complete_tree (dot);
17780 }
17781
17782 /* If we're emitting class files and we have to deal with non
17783 primitive types, we invoke (and consider generating) the
17784 synthetic static method `class$'. */
17785 if (!TYPE_DOT_CLASS (current_class))
17786 build_dot_class_method (current_class);
17787 ref_type = build_dot_class_method_invocation (ref_type);
17788 return java_complete_tree (ref_type);
17789 }
17790
17791 /* 15.14 Unary operators. We return error_mark_node in case of error,
17792 but preserve the type of NODE if the type is fixed. */
17793
17794 static tree
patch_unaryop(node,wfl_op)17795 patch_unaryop (node, wfl_op)
17796 tree node;
17797 tree wfl_op;
17798 {
17799 tree op = TREE_OPERAND (node, 0);
17800 tree op_type = TREE_TYPE (op);
17801 tree prom_type = NULL_TREE, value, decl;
17802 int outer_field_flag = 0;
17803 int code = TREE_CODE (node);
17804 int error_found = 0;
17805
17806 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
17807
17808 switch (code)
17809 {
17810 /* 15.13.2 Postfix Increment Operator ++ */
17811 case POSTINCREMENT_EXPR:
17812 /* 15.13.3 Postfix Increment Operator -- */
17813 case POSTDECREMENT_EXPR:
17814 /* 15.14.1 Prefix Increment Operator ++ */
17815 case PREINCREMENT_EXPR:
17816 /* 15.14.2 Prefix Decrement Operator -- */
17817 case PREDECREMENT_EXPR:
17818 op = decl = strip_out_static_field_access_decl (op);
17819 outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
17820 /* We might be trying to change an outer field accessed using
17821 access method. */
17822 if (outer_field_flag)
17823 {
17824 /* Retrieve the decl of the field we're trying to access. We
17825 do that by first retrieving the function we would call to
17826 access the field. It has been already verified that this
17827 field isn't final */
17828 if (flag_emit_class_files)
17829 decl = TREE_OPERAND (op, 0);
17830 else
17831 decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
17832 decl = DECL_FUNCTION_ACCESS_DECL (decl);
17833 }
17834 /* We really should have a JAVA_ARRAY_EXPR to avoid this */
17835 else if (!JDECL_P (decl)
17836 && TREE_CODE (decl) != COMPONENT_REF
17837 && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
17838 && TREE_CODE (decl) != INDIRECT_REF
17839 && !(TREE_CODE (decl) == COMPOUND_EXPR
17840 && TREE_OPERAND (decl, 1)
17841 && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
17842 {
17843 TREE_TYPE (node) = error_mark_node;
17844 error_found = 1;
17845 }
17846
17847 /* From now on, we know that op if a variable and that it has a
17848 valid wfl. We use wfl_op to locate errors related to the
17849 ++/-- operand. */
17850 if (!JNUMERIC_TYPE_P (op_type))
17851 {
17852 parse_error_context
17853 (wfl_op, "Invalid argument type `%s' to `%s'",
17854 lang_printable_name (op_type, 0), operator_string (node));
17855 TREE_TYPE (node) = error_mark_node;
17856 error_found = 1;
17857 }
17858 else
17859 {
17860 /* Before the addition, binary numeric promotion is performed on
17861 both operands, if really necessary */
17862 if (JINTEGRAL_TYPE_P (op_type))
17863 {
17864 value = build_int_2 (1, 0);
17865 TREE_TYPE (value) = TREE_TYPE (node) = op_type;
17866 }
17867 else
17868 {
17869 value = build_int_2 (1, 0);
17870 TREE_TYPE (node) =
17871 binary_numeric_promotion (op_type,
17872 TREE_TYPE (value), &op, &value);
17873 }
17874
17875 /* We remember we might be accessing an outer field */
17876 if (outer_field_flag)
17877 {
17878 /* We re-generate an access to the field */
17879 value = build (PLUS_EXPR, TREE_TYPE (op),
17880 build_outer_field_access (wfl_op, decl), value);
17881
17882 /* And we patch the original access$() into a write
17883 with plus_op as a rhs */
17884 return outer_field_access_fix (node, op, value);
17885 }
17886
17887 /* And write back into the node. */
17888 TREE_OPERAND (node, 0) = op;
17889 TREE_OPERAND (node, 1) = value;
17890 /* Convert the overall back into its original type, if
17891 necessary, and return */
17892 if (JINTEGRAL_TYPE_P (op_type))
17893 return fold (node);
17894 else
17895 return fold (convert (op_type, node));
17896 }
17897 break;
17898
17899 /* 15.14.3 Unary Plus Operator + */
17900 case UNARY_PLUS_EXPR:
17901 /* 15.14.4 Unary Minus Operator - */
17902 case NEGATE_EXPR:
17903 if (!JNUMERIC_TYPE_P (op_type))
17904 {
17905 ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
17906 TREE_TYPE (node) = error_mark_node;
17907 error_found = 1;
17908 }
17909 /* Unary numeric promotion is performed on operand */
17910 else
17911 {
17912 op = do_unary_numeric_promotion (op);
17913 prom_type = TREE_TYPE (op);
17914 if (code == UNARY_PLUS_EXPR)
17915 return fold (op);
17916 }
17917 break;
17918
17919 /* 15.14.5 Bitwise Complement Operator ~ */
17920 case BIT_NOT_EXPR:
17921 if (!JINTEGRAL_TYPE_P (op_type))
17922 {
17923 ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
17924 TREE_TYPE (node) = error_mark_node;
17925 error_found = 1;
17926 }
17927 else
17928 {
17929 op = do_unary_numeric_promotion (op);
17930 prom_type = TREE_TYPE (op);
17931 }
17932 break;
17933
17934 /* 15.14.6 Logical Complement Operator ! */
17935 case TRUTH_NOT_EXPR:
17936 if (TREE_CODE (op_type) != BOOLEAN_TYPE)
17937 {
17938 ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
17939 /* But the type is known. We will report an error if further
17940 attempt of a assignment is made with this rhs */
17941 TREE_TYPE (node) = boolean_type_node;
17942 error_found = 1;
17943 }
17944 else
17945 prom_type = boolean_type_node;
17946 break;
17947
17948 /* 15.15 Cast Expression */
17949 case CONVERT_EXPR:
17950 value = patch_cast (node, wfl_operator);
17951 if (value == error_mark_node)
17952 {
17953 /* If this cast is part of an assignment, we tell the code
17954 that deals with it not to complain about a mismatch,
17955 because things have been cast, anyways */
17956 TREE_TYPE (node) = error_mark_node;
17957 error_found = 1;
17958 }
17959 else
17960 {
17961 value = fold (value);
17962 TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
17963 return value;
17964 }
17965 break;
17966 }
17967
17968 if (error_found)
17969 return error_mark_node;
17970
17971 /* There are cases where node has been replaced by something else
17972 and we don't end up returning here: UNARY_PLUS_EXPR,
17973 CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
17974 TREE_OPERAND (node, 0) = fold (op);
17975 TREE_TYPE (node) = prom_type;
17976 TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
17977 return fold (node);
17978 }
17979
17980 /* Generic type resolution that sometimes takes place during node
17981 patching. Returned the resolved type or generate an error
17982 message. Return the resolved type or NULL_TREE. */
17983
17984 static tree
resolve_type_during_patch(type)17985 resolve_type_during_patch (type)
17986 tree type;
17987 {
17988 if (unresolved_type_p (type, NULL))
17989 {
17990 tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
17991 if (!type_decl)
17992 {
17993 parse_error_context (type,
17994 "Class `%s' not found in type declaration",
17995 IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
17996 return NULL_TREE;
17997 }
17998 return TREE_TYPE (type_decl);
17999 }
18000 return type;
18001 }
18002 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
18003 found. Otherwise NODE or something meant to replace it is returned. */
18004
18005 static tree
patch_cast(node,wfl_op)18006 patch_cast (node, wfl_op)
18007 tree node;
18008 tree wfl_op;
18009 {
18010 tree op = TREE_OPERAND (node, 0);
18011 tree cast_type = TREE_TYPE (node);
18012 tree patched, op_type;
18013 char *t1;
18014
18015 /* Some string patching might be necessary at this stage */
18016 if ((patched = patch_string (op)))
18017 TREE_OPERAND (node, 0) = op = patched;
18018 op_type = TREE_TYPE (op);
18019
18020 /* First resolve OP_TYPE if unresolved */
18021 if (!(cast_type = resolve_type_during_patch (cast_type)))
18022 return error_mark_node;
18023
18024 /* Check on cast that are proven correct at compile time */
18025 if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
18026 {
18027 /* Same type */
18028 if (cast_type == op_type)
18029 return node;
18030
18031 /* float and double type are converted to the original type main
18032 variant and then to the target type. */
18033 if (JFLOAT_TYPE_P (op_type) && TREE_CODE (cast_type) == CHAR_TYPE)
18034 op = convert (integer_type_node, op);
18035
18036 /* Try widening/narowwing convertion. Potentially, things need
18037 to be worked out in gcc so we implement the extreme cases
18038 correctly. fold_convert() needs to be fixed. */
18039 return convert (cast_type, op);
18040 }
18041
18042 /* It's also valid to cast a boolean into a boolean */
18043 if (op_type == boolean_type_node && cast_type == boolean_type_node)
18044 return node;
18045
18046 /* null can be casted to references */
18047 if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
18048 return build_null_of_type (cast_type);
18049
18050 /* The remaining legal casts involve conversion between reference
18051 types. Check for their compile time correctness. */
18052 if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
18053 && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
18054 {
18055 TREE_TYPE (node) = promote_type (cast_type);
18056 /* Now, the case can be determined correct at compile time if
18057 OP_TYPE can be converted into CAST_TYPE by assignment
18058 conversion (5.2) */
18059
18060 if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
18061 {
18062 TREE_SET_CODE (node, NOP_EXPR);
18063 return node;
18064 }
18065
18066 if (flag_emit_class_files)
18067 {
18068 TREE_SET_CODE (node, CONVERT_EXPR);
18069 return node;
18070 }
18071
18072 /* The cast requires a run-time check */
18073 return build (CALL_EXPR, promote_type (cast_type),
18074 build_address_of (soft_checkcast_node),
18075 tree_cons (NULL_TREE, build_class_ref (cast_type),
18076 build_tree_list (NULL_TREE, op)),
18077 NULL_TREE);
18078 }
18079
18080 /* Any other casts are proven incorrect at compile time */
18081 t1 = xstrdup (lang_printable_name (op_type, 0));
18082 parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
18083 t1, lang_printable_name (cast_type, 0));
18084 free (t1);
18085 return error_mark_node;
18086 }
18087
18088 /* Build a null constant and give it the type TYPE. */
18089
18090 static tree
build_null_of_type(type)18091 build_null_of_type (type)
18092 tree type;
18093 {
18094 tree node = build_int_2 (0, 0);
18095 TREE_TYPE (node) = promote_type (type);
18096 return node;
18097 }
18098
18099 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
18100 a list of indices. */
18101 static tree
build_array_ref(location,array,index)18102 build_array_ref (location, array, index)
18103 int location;
18104 tree array, index;
18105 {
18106 tree node = build (ARRAY_REF, NULL_TREE, array, index);
18107 EXPR_WFL_LINECOL (node) = location;
18108 return node;
18109 }
18110
18111 /* 15.12 Array Access Expression */
18112
18113 static tree
patch_array_ref(node)18114 patch_array_ref (node)
18115 tree node;
18116 {
18117 tree array = TREE_OPERAND (node, 0);
18118 tree array_type = TREE_TYPE (array);
18119 tree index = TREE_OPERAND (node, 1);
18120 tree index_type = TREE_TYPE (index);
18121 int error_found = 0;
18122
18123 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
18124
18125 if (TREE_CODE (array_type) == POINTER_TYPE)
18126 array_type = TREE_TYPE (array_type);
18127
18128 /* The array reference must be an array */
18129 if (!TYPE_ARRAY_P (array_type))
18130 {
18131 parse_error_context
18132 (wfl_operator,
18133 "`[]' can only be applied to arrays. It can't be applied to `%s'",
18134 lang_printable_name (array_type, 0));
18135 TREE_TYPE (node) = error_mark_node;
18136 error_found = 1;
18137 }
18138
18139 /* The array index undergoes unary numeric promotion. The promoted
18140 type must be int */
18141 index = do_unary_numeric_promotion (index);
18142 if (TREE_TYPE (index) != int_type_node)
18143 {
18144 if (valid_cast_to_p (index_type, int_type_node))
18145 parse_error_context (wfl_operator,
18146 "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
18147 lang_printable_name (index_type, 0));
18148 else
18149 parse_error_context (wfl_operator,
18150 "Incompatible type for `[]'. Can't convert `%s' to `int'",
18151 lang_printable_name (index_type, 0));
18152 TREE_TYPE (node) = error_mark_node;
18153 error_found = 1;
18154 }
18155
18156 if (error_found)
18157 return error_mark_node;
18158
18159 array_type = TYPE_ARRAY_ELEMENT (array_type);
18160
18161 if (flag_emit_class_files || flag_emit_xref)
18162 {
18163 TREE_OPERAND (node, 0) = array;
18164 TREE_OPERAND (node, 1) = index;
18165 }
18166 else
18167 node = build_java_arrayaccess (array, array_type, index);
18168 TREE_TYPE (node) = array_type;
18169 return node;
18170 }
18171
18172 /* 15.9 Array Creation Expressions */
18173
18174 static tree
build_newarray_node(type,dims,extra_dims)18175 build_newarray_node (type, dims, extra_dims)
18176 tree type;
18177 tree dims;
18178 int extra_dims;
18179 {
18180 tree node =
18181 build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
18182 build_int_2 (extra_dims, 0));
18183 return node;
18184 }
18185
18186 static tree
patch_newarray(node)18187 patch_newarray (node)
18188 tree node;
18189 {
18190 tree type = TREE_OPERAND (node, 0);
18191 tree dims = TREE_OPERAND (node, 1);
18192 tree cdim, array_type;
18193 int error_found = 0;
18194 int ndims = 0;
18195 int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
18196
18197 /* Dimension types are verified. It's better for the types to be
18198 verified in order. */
18199 for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
18200 {
18201 int dim_error = 0;
18202 tree dim = TREE_VALUE (cdim);
18203
18204 /* Dim might have been saved during its evaluation */
18205 dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
18206
18207 /* The type of each specified dimension must be an integral type. */
18208 if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
18209 dim_error = 1;
18210
18211 /* Each expression undergoes an unary numeric promotion (5.6.1) and the
18212 promoted type must be int. */
18213 else
18214 {
18215 dim = do_unary_numeric_promotion (dim);
18216 if (TREE_TYPE (dim) != int_type_node)
18217 dim_error = 1;
18218 }
18219
18220 /* Report errors on types here */
18221 if (dim_error)
18222 {
18223 parse_error_context
18224 (TREE_PURPOSE (cdim),
18225 "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
18226 (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
18227 "Explicit cast needed to" : "Can't"),
18228 lang_printable_name (TREE_TYPE (dim), 0));
18229 error_found = 1;
18230 }
18231
18232 TREE_PURPOSE (cdim) = NULL_TREE;
18233 }
18234
18235 /* Resolve array base type if unresolved */
18236 if (!(type = resolve_type_during_patch (type)))
18237 error_found = 1;
18238
18239 if (error_found)
18240 {
18241 /* We don't want further evaluation of this bogus array creation
18242 operation */
18243 TREE_TYPE (node) = error_mark_node;
18244 return error_mark_node;
18245 }
18246
18247 /* Set array_type to the actual (promoted) array type of the result. */
18248 if (TREE_CODE (type) == RECORD_TYPE)
18249 type = build_pointer_type (type);
18250 while (--xdims >= 0)
18251 {
18252 type = promote_type (build_java_array_type (type, -1));
18253 }
18254 dims = nreverse (dims);
18255 array_type = type;
18256 for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
18257 {
18258 type = array_type;
18259 array_type
18260 = build_java_array_type (type,
18261 TREE_CODE (cdim) == INTEGER_CST
18262 ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
18263 : -1);
18264 array_type = promote_type (array_type);
18265 }
18266 dims = nreverse (dims);
18267
18268 /* The node is transformed into a function call. Things are done
18269 differently according to the number of dimensions. If the number
18270 of dimension is equal to 1, then the nature of the base type
18271 (primitive or not) matters. */
18272 if (ndims == 1)
18273 return build_new_array (type, TREE_VALUE (dims));
18274
18275 /* Can't reuse what's already written in expr.c because it uses the
18276 JVM stack representation. Provide a build_multianewarray. FIXME */
18277 return build (CALL_EXPR, array_type,
18278 build_address_of (soft_multianewarray_node),
18279 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
18280 tree_cons (NULL_TREE,
18281 build_int_2 (ndims, 0), dims )),
18282 NULL_TREE);
18283 }
18284
18285 /* 10.6 Array initializer. */
18286
18287 /* Build a wfl for array element that don't have one, so we can
18288 pin-point errors. */
18289
18290 static tree
maybe_build_array_element_wfl(node)18291 maybe_build_array_element_wfl (node)
18292 tree node;
18293 {
18294 if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
18295 return build_expr_wfl (NULL_TREE, ctxp->filename,
18296 ctxp->elc.line, ctxp->elc.prev_col);
18297 else
18298 return NULL_TREE;
18299 }
18300
18301 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
18302 identification of initialized arrays easier to detect during walk
18303 and expansion. */
18304
18305 static tree
build_new_array_init(location,values)18306 build_new_array_init (location, values)
18307 int location;
18308 tree values;
18309 {
18310 tree constructor = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, values);
18311 tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
18312 EXPR_WFL_LINECOL (to_return) = location;
18313 return to_return;
18314 }
18315
18316 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
18317 occurred. Otherwise return NODE after having set its type
18318 appropriately. */
18319
18320 static tree
patch_new_array_init(type,node)18321 patch_new_array_init (type, node)
18322 tree type, node;
18323 {
18324 int error_seen = 0;
18325 tree current, element_type;
18326 HOST_WIDE_INT length;
18327 int all_constant = 1;
18328 tree init = TREE_OPERAND (node, 0);
18329
18330 if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
18331 {
18332 parse_error_context (node,
18333 "Invalid array initializer for non-array type `%s'",
18334 lang_printable_name (type, 1));
18335 return error_mark_node;
18336 }
18337 type = TREE_TYPE (type);
18338 element_type = TYPE_ARRAY_ELEMENT (type);
18339
18340 CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
18341
18342 for (length = 0, current = CONSTRUCTOR_ELTS (init);
18343 current; length++, current = TREE_CHAIN (current))
18344 {
18345 tree elt = TREE_VALUE (current);
18346 if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
18347 {
18348 error_seen |= array_constructor_check_entry (element_type, current);
18349 elt = TREE_VALUE (current);
18350 /* When compiling to native code, STRING_CST is converted to
18351 INDIRECT_REF, but still with a TREE_CONSTANT flag. */
18352 if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
18353 all_constant = 0;
18354 }
18355 else
18356 {
18357 TREE_VALUE (current) = patch_new_array_init (element_type, elt);
18358 TREE_PURPOSE (current) = NULL_TREE;
18359 all_constant = 0;
18360 }
18361 if (elt && TREE_CODE (elt) == TREE_LIST
18362 && TREE_VALUE (elt) == error_mark_node)
18363 error_seen = 1;
18364 }
18365
18366 if (error_seen)
18367 return error_mark_node;
18368
18369 /* Create a new type. We can't reuse the one we have here by
18370 patching its dimension because it originally is of dimension -1
18371 hence reused by gcc. This would prevent triangular arrays. */
18372 type = build_java_array_type (element_type, length);
18373 TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
18374 TREE_TYPE (node) = promote_type (type);
18375 TREE_CONSTANT (init) = all_constant;
18376 TREE_CONSTANT (node) = all_constant;
18377 return node;
18378 }
18379
18380 /* Verify that one entry of the initializer element list can be
18381 assigned to the array base type. Report 1 if an error occurred, 0
18382 otherwise. */
18383
18384 static int
array_constructor_check_entry(type,entry)18385 array_constructor_check_entry (type, entry)
18386 tree type, entry;
18387 {
18388 char *array_type_string = NULL; /* For error reports */
18389 tree value, type_value, new_value, wfl_value, patched;
18390 int error_seen = 0;
18391
18392 new_value = NULL_TREE;
18393 wfl_value = TREE_VALUE (entry);
18394
18395 value = java_complete_tree (TREE_VALUE (entry));
18396 /* patch_string return error_mark_node if arg is error_mark_node */
18397 if ((patched = patch_string (value)))
18398 value = patched;
18399 if (value == error_mark_node)
18400 return 1;
18401
18402 type_value = TREE_TYPE (value);
18403
18404 /* At anytime, try_builtin_assignconv can report a warning on
18405 constant overflow during narrowing. */
18406 SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
18407 new_value = try_builtin_assignconv (wfl_operator, type, value);
18408 if (!new_value && (new_value = try_reference_assignconv (type, value)))
18409 type_value = promote_type (type);
18410
18411 /* Check and report errors */
18412 if (!new_value)
18413 {
18414 const char *const msg = (!valid_cast_to_p (type_value, type) ?
18415 "Can't" : "Explicit cast needed to");
18416 if (!array_type_string)
18417 array_type_string = xstrdup (lang_printable_name (type, 1));
18418 parse_error_context
18419 (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
18420 msg, lang_printable_name (type_value, 1), array_type_string);
18421 error_seen = 1;
18422 }
18423
18424 if (new_value)
18425 TREE_VALUE (entry) = new_value;
18426
18427 if (array_type_string)
18428 free (array_type_string);
18429
18430 TREE_PURPOSE (entry) = NULL_TREE;
18431 return error_seen;
18432 }
18433
18434 static tree
build_this(location)18435 build_this (location)
18436 int location;
18437 {
18438 tree node = build_wfl_node (this_identifier_node);
18439 TREE_SET_CODE (node, THIS_EXPR);
18440 EXPR_WFL_LINECOL (node) = location;
18441 return node;
18442 }
18443
18444 /* 14.15 The return statement. It builds a modify expression that
18445 assigns the returned value to the RESULT_DECL that hold the value
18446 to be returned. */
18447
18448 static tree
build_return(location,op)18449 build_return (location, op)
18450 int location;
18451 tree op;
18452 {
18453 tree node = build1 (RETURN_EXPR, NULL_TREE, op);
18454 EXPR_WFL_LINECOL (node) = location;
18455 node = build_debugable_stmt (location, node);
18456 return node;
18457 }
18458
18459 static tree
patch_return(node)18460 patch_return (node)
18461 tree node;
18462 {
18463 tree return_exp = TREE_OPERAND (node, 0);
18464 tree meth = current_function_decl;
18465 tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
18466 int error_found = 0;
18467
18468 TREE_TYPE (node) = error_mark_node;
18469 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
18470
18471 /* It's invalid to have a return value within a function that is
18472 declared with the keyword void or that is a constructor */
18473 if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
18474 error_found = 1;
18475
18476 /* It's invalid to use a return statement in a static block */
18477 if (DECL_CLINIT_P (current_function_decl))
18478 error_found = 1;
18479
18480 /* It's invalid to have a no return value within a function that
18481 isn't declared with the keyword `void' */
18482 if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
18483 error_found = 2;
18484
18485 if (DECL_INSTINIT_P (current_function_decl))
18486 error_found = 1;
18487
18488 if (error_found)
18489 {
18490 if (DECL_INSTINIT_P (current_function_decl))
18491 parse_error_context (wfl_operator,
18492 "`return' inside instance initializer");
18493
18494 else if (DECL_CLINIT_P (current_function_decl))
18495 parse_error_context (wfl_operator,
18496 "`return' inside static initializer");
18497
18498 else if (!DECL_CONSTRUCTOR_P (meth))
18499 {
18500 char *t = xstrdup (lang_printable_name (mtype, 0));
18501 parse_error_context (wfl_operator,
18502 "`return' with%s value from `%s %s'",
18503 (error_found == 1 ? "" : "out"),
18504 t, lang_printable_name (meth, 0));
18505 free (t);
18506 }
18507 else
18508 parse_error_context (wfl_operator,
18509 "`return' with value from constructor `%s'",
18510 lang_printable_name (meth, 0));
18511 return error_mark_node;
18512 }
18513
18514 /* If we have a return_exp, build a modify expression and expand
18515 it. Note: at that point, the assignment is declared valid, but we
18516 may want to carry some more hacks */
18517 if (return_exp)
18518 {
18519 tree exp = java_complete_tree (return_exp);
18520 tree modify, patched;
18521
18522 if ((patched = patch_string (exp)))
18523 exp = patched;
18524
18525 modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
18526 EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
18527 modify = java_complete_tree (modify);
18528
18529 if (modify != error_mark_node)
18530 {
18531 TREE_SIDE_EFFECTS (modify) = 1;
18532 TREE_OPERAND (node, 0) = modify;
18533 }
18534 else
18535 return error_mark_node;
18536 }
18537 TREE_TYPE (node) = void_type_node;
18538 TREE_SIDE_EFFECTS (node) = 1;
18539 return node;
18540 }
18541
18542 /* 14.8 The if Statement */
18543
18544 static tree
build_if_else_statement(location,expression,if_body,else_body)18545 build_if_else_statement (location, expression, if_body, else_body)
18546 int location;
18547 tree expression, if_body, else_body;
18548 {
18549 tree node;
18550 if (!else_body)
18551 else_body = empty_stmt_node;
18552 node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
18553 EXPR_WFL_LINECOL (node) = location;
18554 node = build_debugable_stmt (location, node);
18555 return node;
18556 }
18557
18558 static tree
patch_if_else_statement(node)18559 patch_if_else_statement (node)
18560 tree node;
18561 {
18562 tree expression = TREE_OPERAND (node, 0);
18563 int can_complete_normally
18564 = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
18565 | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
18566
18567 TREE_TYPE (node) = error_mark_node;
18568 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
18569
18570 /* The type of expression must be boolean */
18571 if (TREE_TYPE (expression) != boolean_type_node
18572 && TREE_TYPE (expression) != promoted_boolean_type_node)
18573 {
18574 parse_error_context
18575 (wfl_operator,
18576 "Incompatible type for `if'. Can't convert `%s' to `boolean'",
18577 lang_printable_name (TREE_TYPE (expression), 0));
18578 return error_mark_node;
18579 }
18580
18581 if (TREE_CODE (expression) == INTEGER_CST)
18582 {
18583 if (integer_zerop (expression))
18584 node = TREE_OPERAND (node, 2);
18585 else
18586 node = TREE_OPERAND (node, 1);
18587 if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
18588 {
18589 node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
18590 CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
18591 }
18592 return node;
18593 }
18594 TREE_TYPE (node) = void_type_node;
18595 TREE_SIDE_EFFECTS (node) = 1;
18596 CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
18597 return node;
18598 }
18599
18600 /* 14.6 Labeled Statements */
18601
18602 /* Action taken when a lableled statement is parsed. a new
18603 LABELED_BLOCK_EXPR is created. No statement is attached to the
18604 label, yet. LABEL can be NULL_TREE for artificially-generated blocks. */
18605
18606 static tree
build_labeled_block(location,label)18607 build_labeled_block (location, label)
18608 int location;
18609 tree label;
18610 {
18611 tree label_name ;
18612 tree label_decl, node;
18613 if (label == NULL_TREE || label == continue_identifier_node)
18614 label_name = label;
18615 else
18616 {
18617 label_name = merge_qualified_name (label_id, label);
18618 /* Issue an error if we try to reuse a label that was previously
18619 declared */
18620 if (IDENTIFIER_LOCAL_VALUE (label_name))
18621 {
18622 EXPR_WFL_LINECOL (wfl_operator) = location;
18623 parse_error_context (wfl_operator,
18624 "Declaration of `%s' shadows a previous label declaration",
18625 IDENTIFIER_POINTER (label));
18626 EXPR_WFL_LINECOL (wfl_operator) =
18627 EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
18628 parse_error_context (wfl_operator,
18629 "This is the location of the previous declaration of label `%s'",
18630 IDENTIFIER_POINTER (label));
18631 java_error_count--;
18632 }
18633 }
18634
18635 label_decl = create_label_decl (label_name);
18636 node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
18637 EXPR_WFL_LINECOL (node) = location;
18638 TREE_SIDE_EFFECTS (node) = 1;
18639 return node;
18640 }
18641
18642 /* A labeled statement LBE is attached a statement. */
18643
18644 static tree
finish_labeled_statement(lbe,statement)18645 finish_labeled_statement (lbe, statement)
18646 tree lbe; /* Labeled block expr */
18647 tree statement;
18648 {
18649 /* In anyways, tie the loop to its statement */
18650 LABELED_BLOCK_BODY (lbe) = statement;
18651 pop_labeled_block ();
18652 POP_LABELED_BLOCK ();
18653 return lbe;
18654 }
18655
18656 /* 14.10, 14.11, 14.12 Loop Statements */
18657
18658 /* Create an empty LOOP_EXPR and make it the last in the nested loop
18659 list. */
18660
18661 static tree
build_new_loop(loop_body)18662 build_new_loop (loop_body)
18663 tree loop_body;
18664 {
18665 tree loop = build (LOOP_EXPR, NULL_TREE, loop_body);
18666 TREE_SIDE_EFFECTS (loop) = 1;
18667 PUSH_LOOP (loop);
18668 return loop;
18669 }
18670
18671 /* Create a loop body according to the following structure:
18672 COMPOUND_EXPR
18673 COMPOUND_EXPR (loop main body)
18674 EXIT_EXPR (this order is for while/for loops.
18675 LABELED_BLOCK_EXPR the order is reversed for do loops)
18676 LABEL_DECL (a continue occurring here branches at the
18677 BODY end of this labeled block)
18678 INCREMENT (if any)
18679
18680 REVERSED, if nonzero, tells that the loop condition expr comes
18681 after the body, like in the do-while loop.
18682
18683 To obtain a loop, the loop body structure described above is
18684 encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
18685
18686 LABELED_BLOCK_EXPR
18687 LABEL_DECL (use this label to exit the loop)
18688 LOOP_EXPR
18689 <structure described above> */
18690
18691 static tree
build_loop_body(location,condition,reversed)18692 build_loop_body (location, condition, reversed)
18693 int location;
18694 tree condition;
18695 int reversed;
18696 {
18697 tree first, second, body;
18698
18699 condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
18700 EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
18701 condition = build_debugable_stmt (location, condition);
18702 TREE_SIDE_EFFECTS (condition) = 1;
18703
18704 body = build_labeled_block (0, continue_identifier_node);
18705 first = (reversed ? body : condition);
18706 second = (reversed ? condition : body);
18707 return
18708 build (COMPOUND_EXPR, NULL_TREE,
18709 build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
18710 }
18711
18712 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
18713 their order) on the current loop. Unlink the current loop from the
18714 loop list. */
18715
18716 static tree
finish_loop_body(location,condition,body,reversed)18717 finish_loop_body (location, condition, body, reversed)
18718 int location;
18719 tree condition, body;
18720 int reversed;
18721 {
18722 tree to_return = ctxp->current_loop;
18723 tree loop_body = LOOP_EXPR_BODY (to_return);
18724 if (condition)
18725 {
18726 tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
18727 /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
18728 The real EXIT_EXPR is one operand further. */
18729 EXPR_WFL_LINECOL (cnode) = location;
18730 /* This one is for accurate error reports */
18731 EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
18732 TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
18733 }
18734 LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
18735 POP_LOOP ();
18736 return to_return;
18737 }
18738
18739 /* Tailored version of finish_loop_body for FOR loops, when FOR
18740 loops feature the condition part */
18741
18742 static tree
finish_for_loop(location,condition,update,body)18743 finish_for_loop (location, condition, update, body)
18744 int location;
18745 tree condition, update, body;
18746 {
18747 /* Put the condition and the loop body in place */
18748 tree loop = finish_loop_body (location, condition, body, 0);
18749 /* LOOP is the current loop which has been now popped of the loop
18750 stack. Mark the update block as reachable and install it. We do
18751 this because the (current interpretation of the) JLS requires
18752 that the update expression be considered reachable even if the
18753 for loop's body doesn't complete normally. */
18754 if (update != NULL_TREE && update != empty_stmt_node)
18755 {
18756 tree up2 = update;
18757 if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
18758 up2 = EXPR_WFL_NODE (up2);
18759 /* It is possible for the update expression to be an
18760 EXPR_WFL_NODE wrapping nothing. */
18761 if (up2 != NULL_TREE && up2 != empty_stmt_node)
18762 {
18763 /* Try to detect constraint violations. These would be
18764 programming errors somewhere. */
18765 if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
18766 || TREE_CODE (up2) == LOOP_EXPR)
18767 abort ();
18768 SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
18769 }
18770 }
18771 LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
18772 return loop;
18773 }
18774
18775 /* Try to find the loop a block might be related to. This comprises
18776 the case where the LOOP_EXPR is found as the second operand of a
18777 COMPOUND_EXPR, because the loop happens to have an initialization
18778 part, then expressed as the first operand of the COMPOUND_EXPR. If
18779 the search finds something, 1 is returned. Otherwise, 0 is
18780 returned. The search is assumed to start from a
18781 LABELED_BLOCK_EXPR's block. */
18782
18783 static tree
search_loop(statement)18784 search_loop (statement)
18785 tree statement;
18786 {
18787 if (TREE_CODE (statement) == LOOP_EXPR)
18788 return statement;
18789
18790 if (TREE_CODE (statement) == BLOCK)
18791 statement = BLOCK_SUBBLOCKS (statement);
18792 else
18793 return NULL_TREE;
18794
18795 if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
18796 while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
18797 statement = TREE_OPERAND (statement, 1);
18798
18799 return (TREE_CODE (statement) == LOOP_EXPR
18800 && FOR_LOOP_P (statement) ? statement : NULL_TREE);
18801 }
18802
18803 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
18804 returned otherwise. */
18805
18806 static int
labeled_block_contains_loop_p(block,loop)18807 labeled_block_contains_loop_p (block, loop)
18808 tree block, loop;
18809 {
18810 if (!block)
18811 return 0;
18812
18813 if (LABELED_BLOCK_BODY (block) == loop)
18814 return 1;
18815
18816 if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
18817 return 1;
18818
18819 return 0;
18820 }
18821
18822 /* If the loop isn't surrounded by a labeled statement, create one and
18823 insert LOOP as its body. */
18824
18825 static tree
patch_loop_statement(loop)18826 patch_loop_statement (loop)
18827 tree loop;
18828 {
18829 tree loop_label;
18830
18831 TREE_TYPE (loop) = void_type_node;
18832 if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
18833 return loop;
18834
18835 loop_label = build_labeled_block (0, NULL_TREE);
18836 /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
18837 that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
18838 LABELED_BLOCK_BODY (loop_label) = loop;
18839 PUSH_LABELED_BLOCK (loop_label);
18840 return loop_label;
18841 }
18842
18843 /* 14.13, 14.14: break and continue Statements */
18844
18845 /* Build a break or a continue statement. a null NAME indicates an
18846 unlabeled break/continue statement. */
18847
18848 static tree
build_bc_statement(location,is_break,name)18849 build_bc_statement (location, is_break, name)
18850 int location, is_break;
18851 tree name;
18852 {
18853 tree break_continue, label_block_expr = NULL_TREE;
18854
18855 if (name)
18856 {
18857 if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
18858 (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
18859 /* Null means that we don't have a target for this named
18860 break/continue. In this case, we make the target to be the
18861 label name, so that the error can be reported accuratly in
18862 patch_bc_statement. */
18863 label_block_expr = EXPR_WFL_NODE (name);
18864 }
18865 /* Unlabeled break/continue will be handled during the
18866 break/continue patch operation */
18867 break_continue
18868 = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
18869
18870 IS_BREAK_STMT_P (break_continue) = is_break;
18871 TREE_SIDE_EFFECTS (break_continue) = 1;
18872 EXPR_WFL_LINECOL (break_continue) = location;
18873 break_continue = build_debugable_stmt (location, break_continue);
18874 return break_continue;
18875 }
18876
18877 /* Verification of a break/continue statement. */
18878
18879 static tree
patch_bc_statement(node)18880 patch_bc_statement (node)
18881 tree node;
18882 {
18883 tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
18884 tree labeled_block = ctxp->current_labeled_block;
18885 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
18886
18887 /* Having an identifier here means that the target is unknown. */
18888 if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
18889 {
18890 parse_error_context (wfl_operator, "No label definition found for `%s'",
18891 IDENTIFIER_POINTER (bc_label));
18892 return error_mark_node;
18893 }
18894 if (! IS_BREAK_STMT_P (node))
18895 {
18896 /* It's a continue statement. */
18897 for (;; labeled_block = TREE_CHAIN (labeled_block))
18898 {
18899 if (labeled_block == NULL_TREE)
18900 {
18901 if (bc_label == NULL_TREE)
18902 parse_error_context (wfl_operator,
18903 "`continue' must be in loop");
18904 else
18905 parse_error_context
18906 (wfl_operator, "continue label `%s' does not name a loop",
18907 IDENTIFIER_POINTER (bc_label));
18908 return error_mark_node;
18909 }
18910 if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
18911 == continue_identifier_node)
18912 && (bc_label == NULL_TREE
18913 || TREE_CHAIN (labeled_block) == bc_label))
18914 {
18915 bc_label = labeled_block;
18916 break;
18917 }
18918 }
18919 }
18920 else if (!bc_label)
18921 {
18922 for (;; labeled_block = TREE_CHAIN (labeled_block))
18923 {
18924 if (labeled_block == NULL_TREE)
18925 {
18926 parse_error_context (wfl_operator,
18927 "`break' must be in loop or switch");
18928 return error_mark_node;
18929 }
18930 target_stmt = LABELED_BLOCK_BODY (labeled_block);
18931 if (TREE_CODE (target_stmt) == SWITCH_EXPR
18932 || search_loop (target_stmt))
18933 {
18934 bc_label = labeled_block;
18935 break;
18936 }
18937 }
18938 }
18939
18940 EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
18941 CAN_COMPLETE_NORMALLY (bc_label) = 1;
18942
18943 /* Our break/continue don't return values. */
18944 TREE_TYPE (node) = void_type_node;
18945 /* Encapsulate the break within a compound statement so that it's
18946 expanded all the times by expand_expr (and not clobbered
18947 sometimes, like after a if statement) */
18948 node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
18949 TREE_SIDE_EFFECTS (node) = 1;
18950 return node;
18951 }
18952
18953 /* Process the exit expression belonging to a loop. Its type must be
18954 boolean. */
18955
18956 static tree
patch_exit_expr(node)18957 patch_exit_expr (node)
18958 tree node;
18959 {
18960 tree expression = TREE_OPERAND (node, 0);
18961 TREE_TYPE (node) = error_mark_node;
18962 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
18963
18964 /* The type of expression must be boolean */
18965 if (TREE_TYPE (expression) != boolean_type_node)
18966 {
18967 parse_error_context
18968 (wfl_operator,
18969 "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
18970 lang_printable_name (TREE_TYPE (expression), 0));
18971 return error_mark_node;
18972 }
18973 /* Now we know things are allright, invert the condition, fold and
18974 return */
18975 TREE_OPERAND (node, 0) =
18976 fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
18977
18978 if (! integer_zerop (TREE_OPERAND (node, 0))
18979 && ctxp->current_loop != NULL_TREE
18980 && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
18981 CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
18982 if (! integer_onep (TREE_OPERAND (node, 0)))
18983 CAN_COMPLETE_NORMALLY (node) = 1;
18984
18985
18986 TREE_TYPE (node) = void_type_node;
18987 return node;
18988 }
18989
18990 /* 14.9 Switch statement */
18991
18992 static tree
patch_switch_statement(node)18993 patch_switch_statement (node)
18994 tree node;
18995 {
18996 tree se = TREE_OPERAND (node, 0), se_type;
18997 tree save, iter;
18998
18999 /* Complete the switch expression */
19000 se = TREE_OPERAND (node, 0) = java_complete_tree (se);
19001 se_type = TREE_TYPE (se);
19002 /* The type of the switch expression must be char, byte, short or
19003 int */
19004 if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
19005 {
19006 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
19007 parse_error_context (wfl_operator,
19008 "Incompatible type for `switch'. Can't convert `%s' to `int'",
19009 lang_printable_name (se_type, 0));
19010 /* This is what java_complete_tree will check */
19011 TREE_OPERAND (node, 0) = error_mark_node;
19012 return error_mark_node;
19013 }
19014
19015 /* Save and restore the outer case label list. */
19016 save = case_label_list;
19017 case_label_list = NULL_TREE;
19018
19019 TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
19020
19021 /* See if we've found a duplicate label. We can't leave this until
19022 code generation, because in `--syntax-only' and `-C' modes we
19023 don't do ordinary code generation. */
19024 for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
19025 {
19026 HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
19027 tree subiter;
19028 for (subiter = TREE_CHAIN (iter);
19029 subiter != NULL_TREE;
19030 subiter = TREE_CHAIN (subiter))
19031 {
19032 HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
19033 if (val == subval)
19034 {
19035 EXPR_WFL_LINECOL (wfl_operator)
19036 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
19037 /* The case_label_list is in reverse order, so print the
19038 outer label first. */
19039 parse_error_context (wfl_operator, "duplicate case label: `"
19040 HOST_WIDE_INT_PRINT_DEC "'", subval);
19041 EXPR_WFL_LINECOL (wfl_operator)
19042 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
19043 parse_error_context (wfl_operator, "original label is here");
19044
19045 break;
19046 }
19047 }
19048 }
19049
19050 case_label_list = save;
19051
19052 /* Ready to return */
19053 if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
19054 {
19055 TREE_TYPE (node) = error_mark_node;
19056 return error_mark_node;
19057 }
19058 TREE_TYPE (node) = void_type_node;
19059 TREE_SIDE_EFFECTS (node) = 1;
19060 CAN_COMPLETE_NORMALLY (node)
19061 = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
19062 || ! SWITCH_HAS_DEFAULT (node);
19063 return node;
19064 }
19065
19066 /* Assertions. */
19067
19068 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
19069 might be NULL_TREE. */
19070 static tree
build_assertion(location,condition,value)19071 build_assertion (location, condition, value)
19072 int location;
19073 tree condition, value;
19074 {
19075 tree node;
19076 tree klass = GET_CPC ();
19077
19078 if (! CLASS_USES_ASSERTIONS (klass))
19079 {
19080 tree field, classdollar, id, call;
19081 tree class_type = TREE_TYPE (klass);
19082
19083 field = add_field (class_type,
19084 get_identifier ("$assertionsDisabled"),
19085 boolean_type_node,
19086 ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
19087 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
19088 FIELD_SYNTHETIC (field) = 1;
19089
19090 if (!TYPE_DOT_CLASS (class_type))
19091 build_dot_class_method (class_type);
19092 classdollar = build_dot_class_method_invocation (class_type);
19093
19094 /* Call CLASS.desiredAssertionStatus(). */
19095 id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
19096 call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
19097 call = make_qualified_primary (classdollar, call, location);
19098 TREE_SIDE_EFFECTS (call) = 1;
19099
19100 /* Invert to obtain !CLASS.desiredAssertionStatus(). This may
19101 seem odd, but we do it to generate code identical to that of
19102 the JDK. */
19103 call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
19104 TREE_SIDE_EFFECTS (call) = 1;
19105 DECL_INITIAL (field) = call;
19106
19107 /* Record the initializer in the initializer statement list. */
19108 call = build (MODIFY_EXPR, NULL_TREE, field, call);
19109 TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
19110 SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
19111 MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
19112
19113 CLASS_USES_ASSERTIONS (klass) = 1;
19114 }
19115
19116 if (value != NULL_TREE)
19117 value = tree_cons (NULL_TREE, value, NULL_TREE);
19118
19119 node = build_wfl_node (get_identifier ("java"));
19120 node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
19121 location);
19122 node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
19123 location);
19124
19125 node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
19126 TREE_SIDE_EFFECTS (node) = 1;
19127 /* It is too early to use BUILD_THROW. */
19128 node = build1 (THROW_EXPR, NULL_TREE, node);
19129 TREE_SIDE_EFFECTS (node) = 1;
19130
19131 /* We invert the condition; if we just put NODE as the `else' part
19132 then we generate weird-looking bytecode. */
19133 condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
19134 /* Check $assertionsDisabled. */
19135 condition
19136 = build (TRUTH_ANDIF_EXPR, NULL_TREE,
19137 build1 (TRUTH_NOT_EXPR, NULL_TREE,
19138 build_wfl_node (get_identifier ("$assertionsDisabled"))),
19139 condition);
19140 node = build_if_else_statement (location, condition, node, NULL_TREE);
19141 return node;
19142 }
19143
19144 /* 14.18 The try/catch statements */
19145
19146 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
19147 catches TYPE and executes CATCH_STMTS. */
19148
19149 static tree
encapsulate_with_try_catch(location,type,try_stmts,catch_stmts)19150 encapsulate_with_try_catch (location, type, try_stmts, catch_stmts)
19151 int location;
19152 tree type, try_stmts, catch_stmts;
19153 {
19154 tree try_block, catch_clause_param, catch_block, catch;
19155
19156 /* First build a try block */
19157 try_block = build_expr_block (try_stmts, NULL_TREE);
19158
19159 /* Build a catch block: we need a catch clause parameter */
19160 catch_clause_param = build_decl (VAR_DECL,
19161 wpv_id, build_pointer_type (type));
19162 /* And a block */
19163 catch_block = build_expr_block (NULL_TREE, catch_clause_param);
19164
19165 /* Initialize the variable and store in the block */
19166 catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
19167 build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
19168 add_stmt_to_block (catch_block, NULL_TREE, catch);
19169
19170 /* Add the catch statements */
19171 add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
19172
19173 /* Now we can build a CATCH_EXPR */
19174 catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
19175
19176 return build_try_statement (location, try_block, catch_block);
19177 }
19178
19179 static tree
build_try_statement(location,try_block,catches)19180 build_try_statement (location, try_block, catches)
19181 int location;
19182 tree try_block, catches;
19183 {
19184 tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
19185 EXPR_WFL_LINECOL (node) = location;
19186 return node;
19187 }
19188
19189 static tree
build_try_finally_statement(location,try_block,finally)19190 build_try_finally_statement (location, try_block, finally)
19191 int location;
19192 tree try_block, finally;
19193 {
19194 tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
19195 EXPR_WFL_LINECOL (node) = location;
19196 return node;
19197 }
19198
19199 static tree
patch_try_statement(node)19200 patch_try_statement (node)
19201 tree node;
19202 {
19203 int error_found = 0;
19204 tree try = TREE_OPERAND (node, 0);
19205 /* Exception handlers are considered in left to right order */
19206 tree catch = nreverse (TREE_OPERAND (node, 1));
19207 tree current, caught_type_list = NULL_TREE;
19208
19209 /* Check catch clauses, if any. Every time we find an error, we try
19210 to process the next catch clause. We process the catch clause before
19211 the try block so that when processing the try block we can check thrown
19212 exceptions againts the caught type list. */
19213 for (current = catch; current; current = TREE_CHAIN (current))
19214 {
19215 tree carg_decl, carg_type;
19216 tree sub_current, catch_block, catch_clause;
19217 int unreachable;
19218
19219 /* At this point, the structure of the catch clause is
19220 CATCH_EXPR (catch node)
19221 BLOCK (with the decl of the parameter)
19222 COMPOUND_EXPR
19223 MODIFY_EXPR (assignment of the catch parameter)
19224 BLOCK (catch clause block)
19225 */
19226 catch_clause = TREE_OPERAND (current, 0);
19227 carg_decl = BLOCK_EXPR_DECLS (catch_clause);
19228 carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
19229
19230 /* Catch clauses can't have more than one parameter declared,
19231 but it's already enforced by the grammar. Make sure that the
19232 only parameter of the clause statement in of class Throwable
19233 or a subclass of Throwable, but that was done earlier. The
19234 catch clause parameter type has also been resolved. */
19235
19236 /* Just make sure that the catch clause parameter type inherits
19237 from java.lang.Throwable */
19238 if (!inherits_from_p (carg_type, throwable_type_node))
19239 {
19240 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
19241 parse_error_context (wfl_operator,
19242 "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
19243 lang_printable_name (carg_type, 0));
19244 error_found = 1;
19245 continue;
19246 }
19247
19248 /* Partial check for unreachable catch statement: The catch
19249 clause is reachable iff is no earlier catch block A in
19250 the try statement such that the type of the catch
19251 clause's parameter is the same as or a subclass of the
19252 type of A's parameter */
19253 unreachable = 0;
19254 for (sub_current = catch;
19255 sub_current != current; sub_current = TREE_CHAIN (sub_current))
19256 {
19257 tree sub_catch_clause, decl;
19258 sub_catch_clause = TREE_OPERAND (sub_current, 0);
19259 decl = BLOCK_EXPR_DECLS (sub_catch_clause);
19260
19261 if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
19262 {
19263 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
19264 parse_error_context
19265 (wfl_operator,
19266 "`catch' not reached because of the catch clause at line %d",
19267 EXPR_WFL_LINENO (sub_current));
19268 unreachable = error_found = 1;
19269 break;
19270 }
19271 }
19272 /* Complete the catch clause block */
19273 catch_block = java_complete_tree (TREE_OPERAND (current, 0));
19274 if (catch_block == error_mark_node)
19275 {
19276 error_found = 1;
19277 continue;
19278 }
19279 if (CAN_COMPLETE_NORMALLY (catch_block))
19280 CAN_COMPLETE_NORMALLY (node) = 1;
19281 TREE_OPERAND (current, 0) = catch_block;
19282
19283 if (unreachable)
19284 continue;
19285
19286 /* Things to do here: the exception must be thrown */
19287
19288 /* Link this type to the caught type list */
19289 caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
19290 }
19291
19292 PUSH_EXCEPTIONS (caught_type_list);
19293 if ((try = java_complete_tree (try)) == error_mark_node)
19294 error_found = 1;
19295 if (CAN_COMPLETE_NORMALLY (try))
19296 CAN_COMPLETE_NORMALLY (node) = 1;
19297 POP_EXCEPTIONS ();
19298
19299 /* Verification ends here */
19300 if (error_found)
19301 return error_mark_node;
19302
19303 TREE_OPERAND (node, 0) = try;
19304 TREE_OPERAND (node, 1) = catch;
19305 TREE_TYPE (node) = void_type_node;
19306 return node;
19307 }
19308
19309 /* 14.17 The synchronized Statement */
19310
19311 static tree
patch_synchronized_statement(node,wfl_op1)19312 patch_synchronized_statement (node, wfl_op1)
19313 tree node, wfl_op1;
19314 {
19315 tree expr = java_complete_tree (TREE_OPERAND (node, 0));
19316 tree block = TREE_OPERAND (node, 1);
19317
19318 tree tmp, enter, exit, expr_decl, assignment;
19319
19320 if (expr == error_mark_node)
19321 {
19322 block = java_complete_tree (block);
19323 return expr;
19324 }
19325
19326 /* We might be trying to synchronize on a STRING_CST */
19327 if ((tmp = patch_string (expr)))
19328 expr = tmp;
19329
19330 /* The TYPE of expr must be a reference type */
19331 if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
19332 {
19333 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
19334 parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
19335 lang_printable_name (TREE_TYPE (expr), 0));
19336 return error_mark_node;
19337 }
19338
19339 if (flag_emit_xref)
19340 {
19341 TREE_OPERAND (node, 0) = expr;
19342 TREE_OPERAND (node, 1) = java_complete_tree (block);
19343 CAN_COMPLETE_NORMALLY (node) = 1;
19344 return node;
19345 }
19346
19347 /* Generate a try-finally for the synchronized statement, except
19348 that the handler that catches all throw exception calls
19349 _Jv_MonitorExit and then rethrow the exception.
19350 The synchronized statement is then implemented as:
19351 TRY
19352 {
19353 _Jv_MonitorEnter (expression)
19354 synchronized_block
19355 _Jv_MonitorExit (expression)
19356 }
19357 CATCH_ALL
19358 {
19359 e = _Jv_exception_info ();
19360 _Jv_MonitorExit (expression)
19361 Throw (e);
19362 } */
19363
19364 expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
19365 BUILD_MONITOR_ENTER (enter, expr_decl);
19366 BUILD_MONITOR_EXIT (exit, expr_decl);
19367 CAN_COMPLETE_NORMALLY (enter) = 1;
19368 CAN_COMPLETE_NORMALLY (exit) = 1;
19369 assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
19370 TREE_SIDE_EFFECTS (assignment) = 1;
19371 node = build (COMPOUND_EXPR, NULL_TREE,
19372 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
19373 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
19374 node = build_expr_block (node, expr_decl);
19375
19376 return java_complete_tree (node);
19377 }
19378
19379 /* 14.16 The throw Statement */
19380
19381 static tree
patch_throw_statement(node,wfl_op1)19382 patch_throw_statement (node, wfl_op1)
19383 tree node, wfl_op1;
19384 {
19385 tree expr = TREE_OPERAND (node, 0);
19386 tree type = TREE_TYPE (expr);
19387 int unchecked_ok = 0, tryblock_throws_ok = 0;
19388
19389 /* Thrown expression must be assignable to java.lang.Throwable */
19390 if (!try_reference_assignconv (throwable_type_node, expr))
19391 {
19392 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
19393 parse_error_context (wfl_operator,
19394 "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
19395 lang_printable_name (type, 0));
19396 /* If the thrown expression was a reference, we further the
19397 compile-time check. */
19398 if (!JREFERENCE_TYPE_P (type))
19399 return error_mark_node;
19400 }
19401
19402 /* At least one of the following must be true */
19403
19404 /* The type of the throw expression is a not checked exception,
19405 i.e. is a unchecked expression. */
19406 unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
19407
19408 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
19409 /* An instance can't throw a checked exception unless that exception
19410 is explicitly declared in the `throws' clause of each
19411 constructor. This doesn't apply to anonymous classes, since they
19412 don't have declared constructors. */
19413 if (!unchecked_ok
19414 && DECL_INSTINIT_P (current_function_decl)
19415 && !ANONYMOUS_CLASS_P (current_class))
19416 {
19417 tree current;
19418 for (current = TYPE_METHODS (current_class); current;
19419 current = TREE_CHAIN (current))
19420 if (DECL_CONSTRUCTOR_P (current)
19421 && !check_thrown_exceptions_do (TREE_TYPE (expr)))
19422 {
19423 parse_error_context (wfl_operator, "Checked exception `%s' can't be thrown in instance initializer (not all declared constructor are declaring it in their `throws' clause)",
19424 lang_printable_name (TREE_TYPE (expr), 0));
19425 return error_mark_node;
19426 }
19427 }
19428
19429 /* Throw is contained in a try statement and at least one catch
19430 clause can receive the thrown expression or the current method is
19431 declared to throw such an exception. Or, the throw statement is
19432 contained in a method or constructor declaration and the type of
19433 the Expression is assignable to at least one type listed in the
19434 throws clause the declaration. */
19435 if (!unchecked_ok)
19436 tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
19437 if (!(unchecked_ok || tryblock_throws_ok))
19438 {
19439 /* If there is a surrounding try block that has no matching
19440 clatch clause, report it first. A surrounding try block exits
19441 only if there is something after the list of checked
19442 exception thrown by the current function (if any). */
19443 if (IN_TRY_BLOCK_P ())
19444 parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
19445 lang_printable_name (type, 0));
19446 /* If we have no surrounding try statement and the method doesn't have
19447 any throws, report it now. FIXME */
19448
19449 /* We report that the exception can't be throw from a try block
19450 in all circumstances but when the `throw' is inside a static
19451 block. */
19452 else if (!EXCEPTIONS_P (currently_caught_type_list)
19453 && !tryblock_throws_ok)
19454 {
19455 if (DECL_CLINIT_P (current_function_decl))
19456 parse_error_context (wfl_operator,
19457 "Checked exception `%s' can't be thrown in initializer",
19458 lang_printable_name (type, 0));
19459 else
19460 parse_error_context (wfl_operator,
19461 "Checked exception `%s' isn't thrown from a `try' block",
19462 lang_printable_name (type, 0));
19463 }
19464 /* Otherwise, the current method doesn't have the appropriate
19465 throws declaration */
19466 else
19467 parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
19468 lang_printable_name (type, 0));
19469 return error_mark_node;
19470 }
19471
19472 if (! flag_emit_class_files && ! flag_emit_xref)
19473 BUILD_THROW (node, expr);
19474
19475 /* If doing xrefs, keep the location where the `throw' was seen. */
19476 if (flag_emit_xref)
19477 EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
19478 return node;
19479 }
19480
19481 /* Check that exception said to be thrown by method DECL can be
19482 effectively caught from where DECL is invoked. */
19483
19484 static void
check_thrown_exceptions(location,decl)19485 check_thrown_exceptions (location, decl)
19486 int location;
19487 tree decl;
19488 {
19489 tree throws;
19490 /* For all the unchecked exceptions thrown by DECL */
19491 for (throws = DECL_FUNCTION_THROWS (decl); throws;
19492 throws = TREE_CHAIN (throws))
19493 if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
19494 {
19495 #if 1
19496 /* Temporary hack to suppresses errors about cloning arrays. FIXME */
19497 if (DECL_NAME (decl) == get_identifier ("clone"))
19498 continue;
19499 #endif
19500 EXPR_WFL_LINECOL (wfl_operator) = location;
19501 if (DECL_FINIT_P (current_function_decl))
19502 parse_error_context
19503 (wfl_operator, "Exception `%s' can't be thrown in initializer",
19504 lang_printable_name (TREE_VALUE (throws), 0));
19505 else
19506 {
19507 parse_error_context
19508 (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
19509 lang_printable_name (TREE_VALUE (throws), 0),
19510 (DECL_INIT_P (current_function_decl) ?
19511 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
19512 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
19513 }
19514 }
19515 }
19516
19517 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
19518 try-catch blocks, OR is listed in the `throws' clause of the
19519 current method. */
19520
19521 static int
check_thrown_exceptions_do(exception)19522 check_thrown_exceptions_do (exception)
19523 tree exception;
19524 {
19525 tree list = currently_caught_type_list;
19526 resolve_and_layout (exception, NULL_TREE);
19527 /* First, all the nested try-catch-finally at that stage. The
19528 last element contains `throws' clause exceptions, if any. */
19529 if (IS_UNCHECKED_EXCEPTION_P (exception))
19530 return 1;
19531 while (list)
19532 {
19533 tree caught;
19534 for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
19535 if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
19536 return 1;
19537 list = TREE_CHAIN (list);
19538 }
19539 return 0;
19540 }
19541
19542 static void
purge_unchecked_exceptions(mdecl)19543 purge_unchecked_exceptions (mdecl)
19544 tree mdecl;
19545 {
19546 tree throws = DECL_FUNCTION_THROWS (mdecl);
19547 tree new = NULL_TREE;
19548
19549 while (throws)
19550 {
19551 tree next = TREE_CHAIN (throws);
19552 if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
19553 {
19554 TREE_CHAIN (throws) = new;
19555 new = throws;
19556 }
19557 throws = next;
19558 }
19559 /* List is inverted here, but it doesn't matter */
19560 DECL_FUNCTION_THROWS (mdecl) = new;
19561 }
19562
19563 /* This function goes over all of CLASS_TYPE ctors and checks whether
19564 each of them features at least one unchecked exception in its
19565 `throws' clause. If it's the case, it returns `true', `false'
19566 otherwise. */
19567
19568 static bool
ctors_unchecked_throws_clause_p(class_type)19569 ctors_unchecked_throws_clause_p (class_type)
19570 tree class_type;
19571 {
19572 tree current;
19573
19574 for (current = TYPE_METHODS (class_type); current;
19575 current = TREE_CHAIN (current))
19576 {
19577 bool ctu = false; /* Ctor Throws Unchecked */
19578 if (DECL_CONSTRUCTOR_P (current))
19579 {
19580 tree throws;
19581 for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
19582 throws = TREE_CHAIN (throws))
19583 if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
19584 ctu = true;
19585 }
19586 /* We return false as we found one ctor that is unfit. */
19587 if (!ctu && DECL_CONSTRUCTOR_P (current))
19588 return false;
19589 }
19590 /* All ctors feature at least one unchecked exception in their
19591 `throws' clause. */
19592 return true;
19593 }
19594
19595 /* 15.24 Conditional Operator ?: */
19596
19597 static tree
patch_conditional_expr(node,wfl_cond,wfl_op1)19598 patch_conditional_expr (node, wfl_cond, wfl_op1)
19599 tree node, wfl_cond, wfl_op1;
19600 {
19601 tree cond = TREE_OPERAND (node, 0);
19602 tree op1 = TREE_OPERAND (node, 1);
19603 tree op2 = TREE_OPERAND (node, 2);
19604 tree resulting_type = NULL_TREE;
19605 tree t1, t2, patched;
19606 int error_found = 0;
19607
19608 /* Operands of ?: might be StringBuffers crafted as a result of a
19609 string concatenation. Obtain a descent operand here. */
19610 if ((patched = patch_string (op1)))
19611 TREE_OPERAND (node, 1) = op1 = patched;
19612 if ((patched = patch_string (op2)))
19613 TREE_OPERAND (node, 2) = op2 = patched;
19614
19615 t1 = TREE_TYPE (op1);
19616 t2 = TREE_TYPE (op2);
19617
19618 /* The first expression must be a boolean */
19619 if (TREE_TYPE (cond) != boolean_type_node)
19620 {
19621 SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
19622 parse_error_context (wfl_operator,
19623 "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
19624 lang_printable_name (TREE_TYPE (cond), 0));
19625 error_found = 1;
19626 }
19627
19628 /* Second and third can be numeric, boolean (i.e. primitive),
19629 references or null. Anything else results in an error */
19630 if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
19631 || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
19632 && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
19633 || (t1 == boolean_type_node && t2 == boolean_type_node)))
19634 error_found = 1;
19635
19636 /* Determine the type of the conditional expression. Same types are
19637 easy to deal with */
19638 else if (t1 == t2)
19639 resulting_type = t1;
19640
19641 /* There are different rules for numeric types */
19642 else if (JNUMERIC_TYPE_P (t1))
19643 {
19644 /* if byte/short found, the resulting type is short */
19645 if ((t1 == byte_type_node && t2 == short_type_node)
19646 || (t1 == short_type_node && t2 == byte_type_node))
19647 resulting_type = short_type_node;
19648
19649 /* If t1 is a constant int and t2 is of type byte, short or char
19650 and t1's value fits in t2, then the resulting type is t2 */
19651 else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
19652 && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
19653 resulting_type = t2;
19654
19655 /* If t2 is a constant int and t1 is of type byte, short or char
19656 and t2's value fits in t1, then the resulting type is t1 */
19657 else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
19658 && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
19659 resulting_type = t1;
19660
19661 /* Otherwise, binary numeric promotion is applied and the
19662 resulting type is the promoted type of operand 1 and 2 */
19663 else
19664 resulting_type = binary_numeric_promotion (t1, t2,
19665 &TREE_OPERAND (node, 1),
19666 &TREE_OPERAND (node, 2));
19667 }
19668
19669 /* Cases of a reference and a null type */
19670 else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
19671 resulting_type = t1;
19672
19673 else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
19674 resulting_type = t2;
19675
19676 /* Last case: different reference types. If a type can be converted
19677 into the other one by assignment conversion, the latter
19678 determines the type of the expression */
19679 else if ((resulting_type = try_reference_assignconv (t1, op2)))
19680 resulting_type = promote_type (t1);
19681
19682 else if ((resulting_type = try_reference_assignconv (t2, op1)))
19683 resulting_type = promote_type (t2);
19684
19685 /* If we don't have any resulting type, we're in trouble */
19686 if (!resulting_type)
19687 {
19688 char *t = xstrdup (lang_printable_name (t1, 0));
19689 SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
19690 parse_error_context (wfl_operator,
19691 "Incompatible type for `?:'. Can't convert `%s' to `%s'",
19692 t, lang_printable_name (t2, 0));
19693 free (t);
19694 error_found = 1;
19695 }
19696
19697 if (error_found)
19698 {
19699 TREE_TYPE (node) = error_mark_node;
19700 return error_mark_node;
19701 }
19702
19703 TREE_TYPE (node) = resulting_type;
19704 TREE_SET_CODE (node, COND_EXPR);
19705 CAN_COMPLETE_NORMALLY (node) = 1;
19706 return node;
19707 }
19708
19709 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
19710
19711 static tree
maybe_build_class_init_for_field(decl,expr)19712 maybe_build_class_init_for_field (decl, expr)
19713 tree decl, expr;
19714 {
19715 tree clas = DECL_CONTEXT (decl);
19716 if (flag_emit_class_files || flag_emit_xref)
19717 return expr;
19718
19719 if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
19720 && FIELD_FINAL (decl))
19721 {
19722 tree init = DECL_INITIAL (decl);
19723 if (init != NULL_TREE)
19724 init = fold_constant_for_init (init, decl);
19725 if (init != NULL_TREE && CONSTANT_VALUE_P (init))
19726 return expr;
19727 }
19728
19729 return build_class_init (clas, expr);
19730 }
19731
19732 /* Try to constant fold NODE.
19733 If NODE is not a constant expression, return NULL_EXPR.
19734 CONTEXT is a static final VAR_DECL whose initializer we are folding. */
19735
19736 static tree
fold_constant_for_init(node,context)19737 fold_constant_for_init (node, context)
19738 tree node;
19739 tree context;
19740 {
19741 tree op0, op1, val;
19742 enum tree_code code = TREE_CODE (node);
19743
19744 switch (code)
19745 {
19746 case INTEGER_CST:
19747 if (node == null_pointer_node)
19748 return NULL_TREE;
19749 case STRING_CST:
19750 case REAL_CST:
19751 return node;
19752
19753 case PLUS_EXPR:
19754 case MINUS_EXPR:
19755 case MULT_EXPR:
19756 case TRUNC_MOD_EXPR:
19757 case RDIV_EXPR:
19758 case LSHIFT_EXPR:
19759 case RSHIFT_EXPR:
19760 case URSHIFT_EXPR:
19761 case BIT_AND_EXPR:
19762 case BIT_XOR_EXPR:
19763 case BIT_IOR_EXPR:
19764 case TRUTH_ANDIF_EXPR:
19765 case TRUTH_ORIF_EXPR:
19766 case EQ_EXPR:
19767 case NE_EXPR:
19768 case GT_EXPR:
19769 case GE_EXPR:
19770 case LT_EXPR:
19771 case LE_EXPR:
19772 op0 = TREE_OPERAND (node, 0);
19773 op1 = TREE_OPERAND (node, 1);
19774 val = fold_constant_for_init (op0, context);
19775 if (val == NULL_TREE || ! TREE_CONSTANT (val))
19776 return NULL_TREE;
19777 TREE_OPERAND (node, 0) = val;
19778 val = fold_constant_for_init (op1, context);
19779 if (val == NULL_TREE || ! TREE_CONSTANT (val))
19780 return NULL_TREE;
19781 TREE_OPERAND (node, 1) = val;
19782 return patch_binop (node, op0, op1);
19783
19784 case UNARY_PLUS_EXPR:
19785 case NEGATE_EXPR:
19786 case TRUTH_NOT_EXPR:
19787 case BIT_NOT_EXPR:
19788 case CONVERT_EXPR:
19789 op0 = TREE_OPERAND (node, 0);
19790 val = fold_constant_for_init (op0, context);
19791 if (val == NULL_TREE || ! TREE_CONSTANT (val))
19792 return NULL_TREE;
19793 TREE_OPERAND (node, 0) = val;
19794 return patch_unaryop (node, op0);
19795 break;
19796
19797 case COND_EXPR:
19798 val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
19799 if (val == NULL_TREE || ! TREE_CONSTANT (val))
19800 return NULL_TREE;
19801 TREE_OPERAND (node, 0) = val;
19802 val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
19803 if (val == NULL_TREE || ! TREE_CONSTANT (val))
19804 return NULL_TREE;
19805 TREE_OPERAND (node, 1) = val;
19806 val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
19807 if (val == NULL_TREE || ! TREE_CONSTANT (val))
19808 return NULL_TREE;
19809 TREE_OPERAND (node, 2) = val;
19810 return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
19811 : TREE_OPERAND (node, 2);
19812
19813 case VAR_DECL:
19814 case FIELD_DECL:
19815 if (! FIELD_FINAL (node)
19816 || DECL_INITIAL (node) == NULL_TREE)
19817 return NULL_TREE;
19818 val = DECL_INITIAL (node);
19819 /* Guard against infinite recursion. */
19820 DECL_INITIAL (node) = NULL_TREE;
19821 val = fold_constant_for_init (val, node);
19822 if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
19823 val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
19824 DECL_INITIAL (node) = val;
19825 return val;
19826
19827 case EXPR_WITH_FILE_LOCATION:
19828 /* Compare java_complete_tree and resolve_expression_name. */
19829 if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
19830 || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
19831 {
19832 tree name = EXPR_WFL_NODE (node);
19833 tree decl;
19834 if (PRIMARY_P (node))
19835 return NULL_TREE;
19836 else if (! QUALIFIED_P (name))
19837 {
19838 decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
19839 if (decl == NULL_TREE
19840 || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
19841 return NULL_TREE;
19842 return fold_constant_for_init (decl, decl);
19843 }
19844 else
19845 {
19846 /* Install the proper context for the field resolution.
19847 The prior context is restored once the name is
19848 properly qualified. */
19849 tree saved_current_class = current_class;
19850 /* Wait until the USE_COMPONENT_REF re-write. FIXME. */
19851 current_class = DECL_CONTEXT (context);
19852 qualify_ambiguous_name (node);
19853 current_class = saved_current_class;
19854 if (resolve_field_access (node, &decl, NULL)
19855 && decl != NULL_TREE)
19856 return fold_constant_for_init (decl, decl);
19857 return NULL_TREE;
19858 }
19859 }
19860 else
19861 {
19862 op0 = TREE_OPERAND (node, 0);
19863 val = fold_constant_for_init (op0, context);
19864 if (val == NULL_TREE || ! TREE_CONSTANT (val))
19865 return NULL_TREE;
19866 TREE_OPERAND (node, 0) = val;
19867 return val;
19868 }
19869
19870 #ifdef USE_COMPONENT_REF
19871 case IDENTIFIER:
19872 case COMPONENT_REF:
19873 ?;
19874 #endif
19875
19876 default:
19877 return NULL_TREE;
19878 }
19879 }
19880
19881 #ifdef USE_COMPONENT_REF
19882 /* Context is 'T' for TypeName, 'P' for PackageName,
19883 'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
19884
19885 tree
resolve_simple_name(name,context)19886 resolve_simple_name (name, context)
19887 tree name;
19888 int context;
19889 {
19890 }
19891
19892 tree
resolve_qualified_name(name,context)19893 resolve_qualified_name (name, context)
19894 tree name;
19895 int context;
19896 {
19897 }
19898 #endif
19899
19900 /* Mark P, which is really a `struct parser_ctxt **' for GC. */
19901
19902 static void
mark_parser_ctxt(p)19903 mark_parser_ctxt (p)
19904 void *p;
19905 {
19906 struct parser_ctxt *pc = *((struct parser_ctxt **) p);
19907 #ifndef JC1_LITE
19908 size_t i;
19909 #endif
19910
19911 if (!pc)
19912 return;
19913
19914 #ifndef JC1_LITE
19915 for (i = 0; i < ARRAY_SIZE (pc->modifier_ctx); ++i)
19916 ggc_mark_tree (pc->modifier_ctx[i]);
19917 ggc_mark_tree (pc->class_type);
19918 ggc_mark_tree (pc->function_decl);
19919 ggc_mark_tree (pc->package);
19920 ggc_mark_tree (pc->class_list);
19921 ggc_mark_tree (pc->current_parsed_class);
19922 ggc_mark_tree (pc->current_parsed_class_un);
19923 ggc_mark_tree (pc->non_static_initialized);
19924 ggc_mark_tree (pc->static_initialized);
19925 ggc_mark_tree (pc->instance_initializers);
19926 ggc_mark_tree (pc->import_list);
19927 ggc_mark_tree (pc->import_demand_list);
19928 ggc_mark_tree (pc->current_loop);
19929 ggc_mark_tree (pc->current_labeled_block);
19930 #endif /* JC1_LITE */
19931
19932 if (pc->next)
19933 mark_parser_ctxt (&pc->next);
19934 }
19935
19936 void
init_src_parse()19937 init_src_parse ()
19938 {
19939 /* Sanity check; we've been bit by this before. */
19940 if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
19941 abort ();
19942 }
19943
19944
19945
19946 /* This section deals with the functions that are called when tables
19947 recording class initialization information are traversed. */
19948
19949 /* Attach to PTR (a block) the declaration found in ENTRY. */
19950
19951 static int
attach_init_test_initialization_flags(entry,ptr)19952 attach_init_test_initialization_flags (entry, ptr)
19953 PTR *entry;
19954 PTR ptr;
19955 {
19956 tree block = (tree)ptr;
19957 struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
19958
19959 if (block != error_mark_node)
19960 {
19961 TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
19962 BLOCK_EXPR_DECLS (block) = ite->value;
19963 }
19964 return true;
19965 }
19966
19967 /* This function is called for each classes that is known definitely
19968 assigned when a given static method was called. This function
19969 augments a compound expression (INFO) storing all assignment to
19970 initialized static class flags if a flag already existed, otherwise
19971 a new one is created. */
19972
19973 static int
emit_test_initialization(entry_p,info)19974 emit_test_initialization (entry_p, info)
19975 PTR *entry_p;
19976 PTR info;
19977 {
19978 tree l = (tree) info;
19979 tree decl, init;
19980 tree key = (tree) *entry_p;
19981 tree *ite;
19982 htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
19983
19984 /* If we haven't found a flag and we're dealing with self registered
19985 with current_function_decl, then don't do anything. Self is
19986 always added as definitely initialized but this information is
19987 valid only if used outside the current function. */
19988 if (current_function_decl == TREE_PURPOSE (l)
19989 && java_treetreehash_find (cf_ht, key) == NULL)
19990 return true;
19991
19992 ite = java_treetreehash_new (cf_ht, key);
19993
19994 /* If we don't have a variable, create one and install it. */
19995 if (*ite == NULL)
19996 {
19997 tree block;
19998
19999 decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
20000 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
20001 LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
20002 DECL_CONTEXT (decl) = current_function_decl;
20003 DECL_INITIAL (decl) = boolean_true_node;
20004
20005 /* The trick is to find the right context for it. */
20006 block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
20007 TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
20008 BLOCK_EXPR_DECLS (block) = decl;
20009 *ite = decl;
20010 }
20011 else
20012 decl = *ite;
20013
20014 /* Now simply augment the compound that holds all the assignments
20015 pertaining to this method invocation. */
20016 init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
20017 TREE_SIDE_EFFECTS (init) = 1;
20018 TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
20019 TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
20020
20021 return true;
20022 }
20023
20024 #include "gt-java-parse.h"
20025 #include "gtype-java.h"
20026
20027
20028