?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Dead
[official-gcc.git] / gomp-20050608-branch / gcc / java / parse.h
blob6b14ffe871e7c0da5d984aaf42791abe593dc048
1 /* Language parser definitions for the GNU compiler for the Java(TM) language.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
4 Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA.
22
23 Java and all Java-based marks are trademarks or registered trademarks
24 of Sun Microsystems, Inc. in the United States and other countries.
25 The Free Software Foundation is independent of Sun Microsystems, Inc. */
26
27 #ifndef GCC_JAVA_PARSE_H
28 #define GCC_JAVA_PARSE_H
29
30 #include "lex.h"
31
32 /* Extern global variable declarations */
33 extern int java_error_count;
34 extern struct obstack temporary_obstack;
35 extern int quiet_flag;
36
37 #ifndef JC1_LITE
38 /* Function extern to java/ */
39 extern int int_fits_type_p (tree, tree);
40 extern tree stabilize_reference (tree);
41 #endif
42
43 /* Macros for verbose debug info */
44 #ifdef VERBOSE_SKELETON
45 #define RULE( rule ) printf ( "jv_yacc:%d: rule %s\n", lineno, rule )
46 #else
47 #define RULE( rule )
48 #endif
49
50 #ifdef VERBOSE_SKELETON
51 #undef SOURCE_FRONTEND_DEBUG
52 #define SOURCE_FRONTEND_DEBUG(X) \
53 {if (!quiet_flag) {printf ("* "); printf X; putchar ('\n');} }
54 #else
55 #define SOURCE_FRONTEND_DEBUG(X)
56 #endif
57
58 /* Macro for error recovering */
59 #ifdef YYDEBUG
60 #define RECOVERED \
61 { if (!quiet_flag) {printf ("** Recovered\n");} }
62 #define DRECOVERED(s) \
63 { if (!quiet_flag) {printf ("** Recovered (%s)\n", #s);}}
64 #else
65 #define RECOVERED
66 #define DRECOVERED(s)
67 #endif
68
69 #define DRECOVER(s) {yyerrok; DRECOVERED(s);}
70 #define RECOVER {yyerrok; RECOVERED;}
71
72 #define YYERROR_NOW ctxp->java_error_flag = 1
73 #define YYNOT_TWICE if (ctxp->prevent_ese != input_line)
74
75 /* Accepted modifiers */
76 #define CLASS_MODIFIERS ACC_PUBLIC|ACC_ABSTRACT|ACC_FINAL|ACC_STRICT
77 #define FIELD_MODIFIERS ACC_PUBLIC|ACC_PROTECTED|ACC_PRIVATE|ACC_FINAL| \
78 ACC_STATIC|ACC_TRANSIENT|ACC_VOLATILE
79 #define METHOD_MODIFIERS ACC_PUBLIC|ACC_PROTECTED|ACC_PRIVATE|ACC_ABSTRACT| \
80 ACC_STATIC|ACC_FINAL|ACC_SYNCHRONIZED|ACC_NATIVE| \
81 ACC_STRICT
82 #define INTERFACE_MODIFIERS ACC_PUBLIC|ACC_ABSTRACT|ACC_STRICT
83 #define INTERFACE_INNER_MODIFIERS ACC_PUBLIC|ACC_PROTECTED|ACC_ABSTRACT| \
84 ACC_STATIC|ACC_PRIVATE
85 #define INTERFACE_METHOD_MODIFIERS ACC_PUBLIC|ACC_ABSTRACT
86 #define INTERFACE_FIELD_MODIFIERS ACC_PUBLIC|ACC_STATIC|ACC_FINAL
87
88 /* Getting a modifier WFL */
89 #define MODIFIER_WFL(M) (ctxp->modifier_ctx [(M) - PUBLIC_TK])
90
91 /* Check on modifiers */
92 #ifdef USE_MAPPED_LOCATION
93 #define THIS_MODIFIER_ONLY(f, m, v, count, l) \
94 if ((f) & (m)) \
95 { \
96 tree node = MODIFIER_WFL (v); \
97 if (!l) \
98 l = node; \
99 else \
100 { \
101 expanded_location lloc = expand_location (EXPR_LOCATION (l)); \
102 expanded_location nloc = expand_location (EXPR_LOCATION (node)); \
103 if (nloc.column > lloc.column || nloc.line > lloc.line) \
104 l = node; \
105 } \
106 count++; \
107 }
108 #else
109 #define THIS_MODIFIER_ONLY(f, m, v, count, l) \
110 if ((f) & (m)) \
111 { \
112 tree node = MODIFIER_WFL (v); \
113 if ((l) \
114 && ((EXPR_WFL_COLNO (node) > EXPR_WFL_COLNO (l)) \
115 || (EXPR_WFL_LINENO (node) > EXPR_WFL_LINENO (l)))) \
116 l = node; \
117 else if (!(l)) \
118 l = node; \
119 count++; \
120 }
121 #endif
122
123 #ifdef ATTRIBUTE_GCC_DIAG
124 extern void parse_error_context (tree cl, const char *gmsgid, ...) ATTRIBUTE_GCC_DIAG(2,3);
125 #endif
126
127 #define ABSTRACT_CHECK(FLAG, V, CL, S) \
128 if ((FLAG) & (V)) \
129 parse_error_context ((CL), "%s method can't be abstract", (S));
130
131 #define JCONSTRUCTOR_CHECK(FLAG, V, CL, S) \
132 if ((FLAG) & (V)) \
133 parse_error_context ((CL), "Constructor can't be %s", (S)); \
134
135 /* Misc. */
136 #define exit_java_complete_class() \
137 { \
138 return; \
139 }
140
141 #define CLASS_OR_INTERFACE(decl, s1, s2) \
142 (decl ? \
143 ((get_access_flags_from_decl (TYPE_NAME (TREE_TYPE (decl))) \
144 & ACC_INTERFACE) ? \
145 s2 : s1) : ((s1 [0]=='S'|| s1 [0]=='s') ? \
146 (s1 [0]=='S' ? "Supertype" : "supertype") : \
147 (s1 [0] > 'A' ? "Type" : "type")))
148
149 #define GET_REAL_TYPE(TYPE) \
150 (TREE_CODE (TYPE) == TREE_LIST ? TREE_PURPOSE (TYPE) : TYPE)
151
152 /* Get TYPE name string, regardless whether TYPE is a class or an
153 array. */
154 #define GET_TYPE_NAME(TYPE) \
155 (TREE_CODE (TYPE_NAME (TYPE)) == IDENTIFIER_NODE ? \
156 IDENTIFIER_POINTER (TYPE_NAME (TYPE)) : \
157 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TYPE))))
158
159 /* Pedantic warning on obsolete modifiers. Note: when cl is NULL,
160 flags was set artificially, such as for an interface method. */
161 #define OBSOLETE_MODIFIER_WARNING(cl, flags, __modifier, arg) \
162 { \
163 if (flag_redundant && (cl) && ((flags) & (__modifier))) \
164 parse_warning_context (cl, \
165 "Discouraged redundant use of %qs modifier in declaration of %s", \
166 java_accstring_lookup (__modifier), arg); \
167 }
168 #define OBSOLETE_MODIFIER_WARNING2(cl, flags, __modifier, arg1, arg2) \
169 { \
170 if (flag_redundant && (cl) && ((flags) & (__modifier))) \
171 parse_warning_context (cl, \
172 "Discouraged redundant use of %qs modifier in declaration of %s %qs", \
173 java_accstring_lookup (__modifier), arg1, arg2);\
174 }
175
176 /* Quickly build a temporary pointer on hypothetical type NAME. */
177 #define BUILD_PTR_FROM_NAME(ptr, name) \
178 do { \
179 ptr = make_node (POINTER_TYPE); \
180 TYPE_NAME (ptr) = name; \
181 } while (0)
182
183 #define INCOMPLETE_TYPE_P(NODE) \
184 ((TREE_CODE (NODE) == POINTER_TYPE) \
185 && !TREE_TYPE (NODE) \
186 && TREE_CODE (TYPE_NAME (NODE)) == IDENTIFIER_NODE)
187
188 #ifndef USE_MAPPED_LOCATION
189 /* Set the EMIT_LINE_NOTE flag of a EXPR_WLF to 1 if debug information
190 are requested. Works in the context of a parser rule. */
191 #define JAVA_MAYBE_GENERATE_DEBUG_INFO(node) \
192 do {if (debug_info_level != DINFO_LEVEL_NONE) \
193 EXPR_WFL_EMIT_LINE_NOTE (node) = 1; } while (0)
194 #endif
195
196 /* Types classification, according to the JLS, section 4.2 */
197 #define JFLOAT_TYPE_P(TYPE) (TYPE && TREE_CODE ((TYPE)) == REAL_TYPE)
198 #define JINTEGRAL_TYPE_P(TYPE) ((TYPE) \
199 && (TREE_CODE ((TYPE)) == INTEGER_TYPE))
200 #define JNUMERIC_TYPE_P(TYPE) ((TYPE) \
201 && (JFLOAT_TYPE_P ((TYPE)) \
202 || JINTEGRAL_TYPE_P ((TYPE))))
203 #define JPRIMITIVE_TYPE_P(TYPE) ((TYPE) \
204 && (JNUMERIC_TYPE_P ((TYPE)) \
205 || TREE_CODE ((TYPE)) == BOOLEAN_TYPE))
206
207 #define JBSC_TYPE_P(TYPE) ((TYPE) && (((TYPE) == byte_type_node) \
208 || ((TYPE) == short_type_node) \
209 || ((TYPE) == char_type_node)))
210
211 /* Not defined in the LRM */
212 #define JSTRING_TYPE_P(TYPE) ((TYPE) \
213 && ((TYPE) == string_type_node || \
214 (TREE_CODE (TYPE) == POINTER_TYPE && \
215 TREE_TYPE (TYPE) == string_type_node)))
216 #define JSTRING_P(NODE) ((NODE) \
217 && (TREE_CODE (NODE) == STRING_CST \
218 || IS_CRAFTED_STRING_BUFFER_P (NODE) \
219 || JSTRING_TYPE_P (TREE_TYPE (NODE))))
220
221 #define JREFERENCE_TYPE_P(TYPE) ((TYPE) \
222 && (TREE_CODE (TYPE) == RECORD_TYPE \
223 || (TREE_CODE (TYPE) == POINTER_TYPE \
224 && TREE_CODE (TREE_TYPE (TYPE)) == \
225 RECORD_TYPE)))
226 #define JNULLP_TYPE_P(TYPE) ((TYPE) && (TREE_CODE (TYPE) == POINTER_TYPE) \
227 && (TYPE) == TREE_TYPE (null_pointer_node))
228
229 /* Other predicates */
230 #define JDECL_P(NODE) (NODE && (TREE_CODE (NODE) == PARM_DECL \
231 || TREE_CODE (NODE) == VAR_DECL \
232 || TREE_CODE (NODE) == FIELD_DECL))
233
234 #define TYPE_INTERFACE_P(TYPE) \
235 (CLASS_P (TYPE) && CLASS_INTERFACE (TYPE_NAME (TYPE)))
236
237 #define TYPE_CLASS_P(TYPE) (CLASS_P (TYPE) \
238 && !CLASS_INTERFACE (TYPE_NAME (TYPE)))
239
240 /* Identifier business related to 1.1 language extensions. */
241
242 #define IDENTIFIER_INNER_CLASS_OUTER_FIELD_ACCESS(NODE) \
243 (TREE_CODE (NODE) == IDENTIFIER_NODE && \
244 IDENTIFIER_LENGTH (NODE) >= 8 && \
245 IDENTIFIER_POINTER (NODE)[7] != '0')
246
247 /* Build the string val$<O> and store it into N. The is used to
248 construct the name of inner class hidden fields used to alias outer
249 scope local variables. */
250 #define MANGLE_OUTER_LOCAL_VARIABLE_NAME(N, O) \
251 { \
252 char *mangled_name; \
253 obstack_grow (&temporary_obstack, "val$", 4); \
254 obstack_grow (&temporary_obstack, \
255 IDENTIFIER_POINTER ((O)), IDENTIFIER_LENGTH ((O))); \
256 obstack_1grow (&temporary_obstack, '\0'); \
257 mangled_name = obstack_finish (&temporary_obstack); \
258 (N) = get_identifier (mangled_name); \
259 obstack_free (&temporary_obstack, mangled_name); \
260 }
261
262 /* Build the string parm$<O> and store in into the identifier N. This
263 is used to construct the name of hidden parameters used to
264 initialize outer scope aliases. */
265 #define MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID(N, O) \
266 { \
267 char *mangled_name; \
268 obstack_grow (&temporary_obstack, "parm$", 5); \
269 obstack_grow (&temporary_obstack, \
270 IDENTIFIER_POINTER ((O)), IDENTIFIER_LENGTH ((O))); \
271 obstack_1grow (&temporary_obstack, '\0'); \
272 mangled_name = obstack_finish (&temporary_obstack); \
273 (N) = get_identifier (mangled_name); \
274 obstack_free (&temporary_obstack, mangled_name); \
275 }
276
277 #define MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR(N, S) \
278 { \
279 char *mangled_name; \
280 obstack_grow (&temporary_obstack, "parm$", 5); \
281 obstack_grow (&temporary_obstack, (S), strlen ((S))); \
282 obstack_1grow (&temporary_obstack, '\0'); \
283 mangled_name = obstack_finish (&temporary_obstack); \
284 (N) = get_identifier (mangled_name); \
285 obstack_free (&temporary_obstack, mangled_name); \
286 }
287
288 /* Skip THIS and artificial parameters found in function decl M and
289 assign the result to C. We don't do that for $finit$, since it's
290 knowingly called with artificial parms. */
291 #define SKIP_THIS_AND_ARTIFICIAL_PARMS(C,M) \
292 { \
293 int i; \
294 (C) = TYPE_ARG_TYPES (TREE_TYPE ((M))); \
295 if (!METHOD_STATIC ((M))) \
296 (C) = TREE_CHAIN (C); \
297 if (DECL_CONSTRUCTOR_P ((M)) \
298 && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT ((M)))) \
299 (C) = TREE_CHAIN (C); \
300 if (!DECL_FINIT_P ((M))) \
301 for (i = DECL_FUNCTION_NAP ((M)); i; i--) \
302 (C) = TREE_CHAIN (C); \
303 }
304
305 /* Mark final parameters in method M, by comparison of the argument
306 list L. This macro is used to set the flag once the method has been
307 build. */
308 #define MARK_FINAL_PARMS(M, L) \
309 { \
310 tree current = TYPE_ARG_TYPES (TREE_TYPE ((M))); \
311 tree list = (L); \
312 if (!METHOD_STATIC ((M))) \
313 current = TREE_CHAIN (current); \
314 for (; current != end_params_node; \
315 current = TREE_CHAIN (current), list = TREE_CHAIN (list)) \
316 ARG_FINAL_P (current) = ARG_FINAL_P (list); \
317 if (current != list) \
318 abort (); \
319 }
320
321 /* Reset the ARG_FINAL_P that might have been set in method M args. */
322 #define UNMARK_FINAL_PARMS(M) \
323 { \
324 tree current; \
325 for (current = TYPE_ARG_TYPES (TREE_TYPE ((M))); \
326 current != end_params_node; current = TREE_CHAIN (current)) \
327 ARG_FINAL_P (current) = 0; \
328 }
329
330 /* Reverse a crafted parameter list as required. */
331 #define CRAFTED_PARAM_LIST_FIXUP(P) \
332 { \
333 if ((P)) \
334 { \
335 tree last = (P); \
336 (P) = nreverse (P); \
337 TREE_CHAIN (last) = end_params_node; \
338 } \
339 else \
340 (P) = end_params_node; \
341 }
342
343 /* Modes governing the creation of a alias initializer parameter
344 lists. AIPL stands for Alias Initializer Parameter List. */
345 enum {
346 AIPL_FUNCTION_CREATION, /* Suitable for artificial method creation */
347 AIPL_FUNCTION_DECLARATION, /* Suitable for declared methods */
348 AIPL_FUNCTION_CTOR_INVOCATION, /* Invocation of constructors */
349 AIPL_FUNCTION_FINIT_INVOCATION /* Invocation of $finit$ */
350 };
351
352 /* Standard error messages */
353 #define ERROR_CANT_CONVERT_TO_BOOLEAN(OPERATOR, NODE, TYPE) \
354 parse_error_context ((OPERATOR), \
355 "Incompatible type for %qs. Can't convert %qs to boolean", \
356 operator_string ((NODE)), lang_printable_name ((TYPE),0))
357
358 #define ERROR_CANT_CONVERT_TO_NUMERIC(OPERATOR, NODE, TYPE) \
359 parse_error_context ((OPERATOR), \
360 "Incompatible type for %qs. Can't convert %qs to numeric type", \
361 operator_string ((NODE)), lang_printable_name ((TYPE), 0))
362
363 #define ERROR_CAST_NEEDED_TO_INTEGRAL(OPERATOR, NODE, TYPE) \
364 do { \
365 tree _operator = (OPERATOR), _node = (NODE), _type = (TYPE); \
366 if (JPRIMITIVE_TYPE_P (_type)) \
367 parse_error_context (_operator, \
368 "Incompatible type for %qs. Explicit cast needed to convert %qs to integral",\
369 operator_string(_node), \
370 lang_printable_name (_type, 0)); \
371 else \
372 parse_error_context (_operator, \
373 "Incompatible type for %qs. Can't convert %qs to integral", \
374 operator_string(_node), \
375 lang_printable_name (_type, 0)); \
376 } while (0)
377
378 #define ERROR_VARIABLE_NOT_INITIALIZED(WFL, V) \
379 parse_error_context \
380 ((WFL), "Variable %qs may not have been initialized", \
381 IDENTIFIER_POINTER (V))
382
383 /* Definition for loop handling. This is Java's own definition of a
384 loop body. See parse.y for documentation. It's valid once you hold
385 a loop's body (LOOP_EXPR_BODY) */
386
387 /* The loop main block is the one hold the condition and the loop body */
388 #define LOOP_EXPR_BODY_MAIN_BLOCK(NODE) TREE_OPERAND (NODE, 0)
389 /* And then there is the loop update block */
390 #define LOOP_EXPR_BODY_UPDATE_BLOCK(NODE) TREE_OPERAND (NODE, 1)
391
392 /* Inside the loop main block, there is the loop condition and the
393 loop body. They may be reversed if the loop being described is a
394 do-while loop. NOTE: if you use a WFL around the EXIT_EXPR so you
395 can issue debug info for it, the EXIT_EXPR will be one operand
396 further. */
397 #define LOOP_EXPR_BODY_CONDITION_EXPR(NODE, R) \
398 TREE_OPERAND (LOOP_EXPR_BODY_MAIN_BLOCK (NODE), (R ? 1 : 0))
399
400 /* Here is the labeled block the loop real body is encapsulated in */
401 #define LOOP_EXPR_BODY_LABELED_BODY(NODE, R) \
402 TREE_OPERAND (LOOP_EXPR_BODY_MAIN_BLOCK (NODE), (R ? 0 : 1))
403 /* And here is the loop's real body */
404 #define LOOP_EXPR_BODY_BODY_EXPR(NODE, R) \
405 LABELED_BLOCK_BODY (LOOP_EXPR_BODY_LABELED_BODY(NODE, R))
406
407 #define PUSH_LABELED_BLOCK(B) \
408 { \
409 TREE_CHAIN (B) = ctxp->current_labeled_block; \
410 ctxp->current_labeled_block = (B); \
411 }
412 #define POP_LABELED_BLOCK() \
413 ctxp->current_labeled_block = TREE_CHAIN (ctxp->current_labeled_block)
414
415 #define PUSH_LOOP(L) \
416 { \
417 TREE_CHAIN (L) = ctxp->current_loop; \
418 ctxp->current_loop = (L); \
419 }
420 #define POP_LOOP() ctxp->current_loop = TREE_CHAIN (ctxp->current_loop)
421
422 #define PUSH_EXCEPTIONS(E) \
423 currently_caught_type_list = \
424 tree_cons (NULL_TREE, (E), currently_caught_type_list);
425
426 #define POP_EXCEPTIONS() \
427 currently_caught_type_list = TREE_CHAIN (currently_caught_type_list)
428
429 /* Check that we're inside a try block. */
430 #define IN_TRY_BLOCK_P() \
431 (currently_caught_type_list \
432 && ((TREE_VALUE (currently_caught_type_list) != \
433 DECL_FUNCTION_THROWS (current_function_decl)) \
434 || TREE_CHAIN (currently_caught_type_list)))
435
436 /* Check that we have exceptions in E. */
437 #define EXCEPTIONS_P(E) ((E) ? TREE_VALUE (E) : NULL_TREE)
438
439 /* Anonymous array access */
440 #define ANONYMOUS_ARRAY_BASE_TYPE(N) TREE_OPERAND ((N), 0)
441 #define ANONYMOUS_ARRAY_DIMS_SIG(N) TREE_OPERAND ((N), 1)
442 #define ANONYMOUS_ARRAY_INITIALIZER(N) TREE_OPERAND ((N), 2)
443
444 /* Invocation modes, as returned by invocation_mode (). */
445 enum {
446 INVOKE_STATIC,
447 INVOKE_NONVIRTUAL,
448 INVOKE_SUPER,
449 INVOKE_INTERFACE,
450 INVOKE_VIRTUAL
451 };
452
453 /* Unresolved type identifiers handling. When we process the source
454 code, we blindly accept an unknown type identifier and try to
455 resolve it later. When an unknown type identifier is encountered
456 and used, we record in a struct jdep element what the incomplete
457 type is and what it should patch. Later, java_complete_class will
458 process all classes known to have unresolved type
459 dependencies. Within each of these classes, this routine will
460 process unresolved type dependencies (JDEP_TO_RESOLVE), patch what
461 needs to be patched in the dependent tree node (JDEP_GET_PATCH,
462 JDEP_APPLY_PATCH) and perform other actions dictated by the context
463 of the patch (JDEP_KIND). The ideas are: we patch only what needs
464 to be patched, and with java_complete_class called at the right
465 time, we will start processing incomplete function bodies tree
466 nodes with everything external to function's bodies already
467 completed, it makes things much simpler. */
468
469 enum jdep_code {
470 JDEP_NO_PATCH, /* Must be first */
471 JDEP_SUPER, /* Patch the type of one type
472 supertype. Requires some check
473 before it's done */
474 JDEP_FIELD, /* Patch the type of a class field */
475
476 /* JDEP_{METHOD,METHOD_RETURN,METHOD_END} to be kept in order */
477 JDEP_METHOD, /* Mark the beginning of the patching
478 of a method declaration, including
479 it's arguments */
480 JDEP_METHOD_RETURN, /* Mark the beginning of the patching
481 of a method declaration. Arguments
482 aren't patched, only the returned
483 type is */
484 JDEP_METHOD_END, /* Mark the end of the patching of a
485 method declaration. It indicates
486 that it's time to compute and
487 install a new signature */
488
489 JDEP_INTERFACE, /* Patch the type of a Class/interface
490 extension */
491 JDEP_VARIABLE, /* Patch the type of a variable declaration */
492 JDEP_PARM, /* Patch the type of a parm declaration */
493 JDEP_TYPE, /* Patch a random tree node type,
494 without the need for any specific
495 actions */
496 JDEP_EXCEPTION, /* Patch exceptions specified by `throws' */
497 JDEP_ANONYMOUS /* Patch anonymous classes
498 (implementation or extension.) */
499
500 };
501
502 typedef struct _jdep {
503 ENUM_BITFIELD(jdep_code) kind : 8; /* Type of patch */
504
505 unsigned int flag0 : 1; /* Some flags */
506 tree decl; /* Tied decl/or WFL */
507 tree solv; /* What to solve */
508 tree wfl; /* Where thing to resolve where found */
509 tree misc; /* Miscellaneous info (optional). */
510 tree enclosing; /* The enclosing (current) class */
511 tree *patch; /* Address of a location to patch */
512 struct _jdep *next; /* Linked list */
513 } jdep;
514
515
516 #define JDEP_DECL(J) ((J)->decl)
517 #define JDEP_DECL_WFL(J) ((J)->decl)
518 #define JDEP_KIND(J) ((J)->kind)
519 #define JDEP_WFL(J) ((J)->wfl)
520 #define JDEP_MISC(J) ((J)->misc)
521 #define JDEP_ENCLOSING(J) ((J)->enclosing)
522 #define JDEP_CLASS(J) ((J)->class)
523 #define JDEP_APPLY_PATCH(J,P) (*(J)->patch = (P))
524 #define JDEP_GET_PATCH(J) ((J)->patch)
525 #define JDEP_CHAIN(J) ((J)->next)
526 #define JDEP_TO_RESOLVE(J) ((J)->solv)
527 #define JDEP_RESOLVED_DECL(J) ((J)->solv)
528 #define JDEP_RESOLVED(J, D) ((J)->solv = D)
529 #define JDEP_RESOLVED_P(J) \
530 (!(J)->solv || TREE_CODE ((J)->solv) != POINTER_TYPE)
531
532 struct jdeplist_s {
533 jdep *first;
534 jdep *last;
535 struct jdeplist_s *next;
536 };
537 typedef struct jdeplist_s jdeplist;
538
539 #define CLASSD_FIRST(CD) ((CD)->first)
540 #define CLASSD_LAST(CD) ((CD)->last)
541 #define CLASSD_CHAIN(CD) ((CD)->next)
542
543 #define JDEP_INSERT(L,J) \
544 { \
545 if (!(L)->first) \
546 (L)->last = (L)->first = (J); \
547 else \
548 { \
549 JDEP_CHAIN ((L)->last) = (J); \
550 (L)->last = (J); \
551 } \
552 }
553
554 /* if TYPE can't be resolved, obtain something suitable for its
555 resolution (TYPE is saved in SAVE before being changed). and set
556 CHAIN to 1. Otherwise, type is set to something usable. CHAIN is
557 usually used to determine that a new DEP must be installed on TYPE.
558 Note that when compiling java.lang.Object, references to Object are
559 java.lang.Object. */
560 #define SET_TYPE_FOR_RESOLUTION(TYPE, SAVE, CHAIN) \
561 { \
562 tree _returned_type; \
563 (CHAIN) = 0; \
564 if (TREE_TYPE (GET_CPC ()) == object_type_node \
565 && TREE_CODE (TYPE) == EXPR_WITH_FILE_LOCATION \
566 && EXPR_WFL_NODE (TYPE) == unqualified_object_id_node) \
567 (TYPE) = object_type_node; \
568 else \
569 { \
570 if (unresolved_type_p (type, &_returned_type)) \
571 { \
572 if (_returned_type) \
573 (TYPE) = _returned_type; \
574 else \
575 { \
576 tree _type; \
577 WFL_STRIP_BRACKET (_type, TYPE); \
578 (SAVE) = (_type); \
579 (TYPE) = obtain_incomplete_type (TYPE); \
580 CHAIN = 1; \
581 } \
582 } \
583 } \
584 }
585
586 #define WFL_STRIP_BRACKET(TARGET, TYPE) \
587 { \
588 tree __type = (TYPE); \
589 if (TYPE && TREE_CODE (TYPE) == EXPR_WITH_FILE_LOCATION) \
590 { \
591 tree _node; \
592 if (build_type_name_from_array_name (EXPR_WFL_NODE (TYPE), &_node)) \
593 { \
594 tree _new = copy_node (TYPE); \
595 EXPR_WFL_NODE (_new) = _node; \
596 __type = _new; \
597 } \
598 } \
599 (TARGET) = __type; \
600 }
601
602 /* If NAME contains one or more trailing []s, NAMELEN will be the
603 adjusted to be the index of the last non bracket character in
604 NAME. ARRAY_DIMS will contain the number of []s found. */
605
606 #define STRING_STRIP_BRACKETS(NAME, NAMELEN, ARRAY_DIMS) \
607 { \
608 ARRAY_DIMS = 0; \
609 while (NAMELEN >= 2 && (NAME)[NAMELEN - 1] == ']') \
610 { \
611 NAMELEN -= 2; \
612 (ARRAY_DIMS)++; \
613 } \
614 }
615
616 /* Promote a type if it won't be registered as a patch */
617 #define PROMOTE_RECORD_IF_COMPLETE(TYPE, IS_INCOMPLETE) \
618 { \
619 if (!(IS_INCOMPLETE) && TREE_CODE (TYPE) == RECORD_TYPE) \
620 (TYPE) = promote_type (TYPE); \
621 }
622
623 /* Insert a DECL in the current block */
624 #define BLOCK_CHAIN_DECL(NODE) \
625 { \
626 TREE_CHAIN ((NODE)) = \
627 BLOCK_EXPR_DECLS (GET_CURRENT_BLOCK (current_function_decl)); \
628 BLOCK_EXPR_DECLS (GET_CURRENT_BLOCK (current_function_decl)) = (NODE); \
629 }
630
631 /* Return the current block, either found in the body of the currently
632 declared function or in the current static block being defined. */
633 #define GET_CURRENT_BLOCK(F) ((F) ? DECL_FUNCTION_BODY ((F)) : \
634 current_static_block)
635
636 #ifndef USE_MAPPED_LOCATION
637 /* Retrieve line/column from a WFL. */
638 #define EXPR_WFL_GET_LINECOL(V,LINE,COL) \
639 { \
640 (LINE) = (V) >> 12; \
641 (COL) = (V) & 0xfff; \
642 }
643 #endif
644
645 #define EXPR_WFL_QUALIFICATION(WFL) TREE_OPERAND ((WFL), 1)
646 #define QUAL_WFL(NODE) TREE_PURPOSE (NODE)
647 #define QUAL_RESOLUTION(NODE) TREE_VALUE (NODE)
648 #define QUAL_DECL_TYPE(NODE) GET_SKIP_TYPE (NODE)
649
650 #define GET_SKIP_TYPE(NODE) \
651 (TREE_CODE (TREE_TYPE (NODE)) == POINTER_TYPE ? \
652 TREE_TYPE (TREE_TYPE (NODE)): TREE_TYPE (NODE))
653
654 /* Handy macros for the walk operation */
655 #define COMPLETE_CHECK_OP(NODE, N) \
656 { \
657 TREE_OPERAND ((NODE), (N)) = \
658 java_complete_tree (TREE_OPERAND ((NODE), (N))); \
659 if (TREE_OPERAND ((NODE), (N)) == error_mark_node) \
660 return error_mark_node; \
661 }
662 #define COMPLETE_CHECK_OP_0(NODE) COMPLETE_CHECK_OP(NODE, 0)
663 #define COMPLETE_CHECK_OP_1(NODE) COMPLETE_CHECK_OP(NODE, 1)
664 #define COMPLETE_CHECK_OP_2(NODE) COMPLETE_CHECK_OP(NODE, 2)
665
666 /* Building invocations: append(ARG) and StringBuffer(ARG) */
667 #define BUILD_APPEND(ARG) \
668 ((JSTRING_TYPE_P (TREE_TYPE (ARG)) || JPRIMITIVE_TYPE_P (TREE_TYPE (ARG))) \
669 ? build_method_invocation (wfl_append, \
670 ARG ? build_tree_list (NULL, (ARG)) : NULL_TREE)\
671 : build_method_invocation (wfl_append, \
672 ARG ? build_tree_list (NULL, \
673 build1 (CONVERT_EXPR, \
674 object_type_node,\
675 (ARG))) \
676 : NULL_TREE))
677 #define BUILD_STRING_BUFFER(ARG) \
678 build_new_invocation (wfl_string_buffer, \
679 (ARG ? build_tree_list (NULL, (ARG)) : NULL_TREE))
680
681 #define BUILD_THROW(WHERE, WHAT) \
682 { \
683 (WHERE) = \
684 build3 (CALL_EXPR, void_type_node, \
685 build_address_of (throw_node), \
686 build_tree_list (NULL_TREE, (WHAT)), NULL_TREE); \
687 TREE_SIDE_EFFECTS ((WHERE)) = 1; \
688 }
689
690 /* Set wfl_operator for the most accurate error location */
691 #ifdef USE_MAPPED_LOCATION
692 #define SET_WFL_OPERATOR(WHICH, NODE, WFL) \
693 SET_EXPR_LOCATION (WHICH, \
694 (TREE_CODE (WFL) == EXPR_WITH_FILE_LOCATION ? \
695 EXPR_LOCATION (WFL) : EXPR_LOCATION (NODE)))
696 #else
697 #define SET_WFL_OPERATOR(WHICH, NODE, WFL) \
698 EXPR_WFL_LINECOL (WHICH) = \
699 (TREE_CODE (WFL) == EXPR_WITH_FILE_LOCATION ? \
700 EXPR_WFL_LINECOL (WFL) : EXPR_WFL_LINECOL (NODE))
701 #endif
702
703 #define PATCH_METHOD_RETURN_ERROR() \
704 { \
705 if (ret_decl) \
706 *ret_decl = NULL_TREE; \
707 return error_mark_node; \
708 }
709
710 /* Convenient macro to check. Assumes that CLASS is a CLASS_DECL. */
711 #define CHECK_METHODS(CLASS) \
712 { \
713 if (CLASS_INTERFACE ((CLASS))) \
714 java_check_abstract_methods ((CLASS)); \
715 else \
716 java_check_regular_methods ((CLASS)); \
717 }
718
719 #define CLEAR_DEPRECATED ctxp->deprecated = 0
720
721 #define CHECK_DEPRECATED_NO_RESET(DECL) \
722 { \
723 if (ctxp->deprecated) \
724 DECL_DEPRECATED (DECL) = 1; \
725 }
726
727 /* Using and reseting the @deprecated tag flag */
728 #define CHECK_DEPRECATED(DECL) \
729 { \
730 if (ctxp->deprecated) \
731 DECL_DEPRECATED (DECL) = 1; \
732 ctxp->deprecated = 0; \
733 }
734
735 /* Register an import */
736 #define REGISTER_IMPORT(WHOLE, NAME) \
737 { \
738 IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P ((NAME)) = 1; \
739 ctxp->import_list = tree_cons ((WHOLE), (NAME), ctxp->import_list); \
740 }
741
742 /* Macro to access the osb (opening square bracket) count */
743 #define CURRENT_OSB(C) (C)->osb_number [(C)->osb_depth]
744
745 /* Parser context data structure. */
746 struct parser_ctxt GTY(()) {
747 const char *filename; /* Current filename */
748 location_t file_start_location;
749 location_t save_location;
750 struct parser_ctxt *next;
751
752 java_lexer * GTY((skip)) lexer; /* Current lexer state */
753 char marker_begining; /* Marker. Should be a sub-struct */
754 int ccb_indent; /* Number of unmatched { seen. */
755 /* The next two fields are only source_location if USE_MAPPED_LOCATION.
756 Otherwise, they are integer line number, but we can't have #ifdefs
757 in GTY structures. */
758 source_location first_ccb_indent1; /* First { at ident level 1 */
759 source_location last_ccb_indent1; /* Last } at ident level 1 */
760 int parser_ccb_indent; /* Keep track of {} indent, parser */
761 int osb_depth; /* Current depth of [ in an expression */
762 int osb_limit; /* Limit of this depth */
763 int * GTY ((skip)) osb_number; /* Keep track of ['s */
764 char marker_end; /* End marker. Should be a sub-struct */
765
766 /* The flags section */
767
768 /* Indicates a context used for saving the parser status. The
769 context must be popped when the status is restored. */
770 unsigned saved_data_ctx:1;
771 /* Indicates that a context already contains saved data and that the
772 next save operation will require a new context to be created. */
773 unsigned saved_data:1;
774 /* Report error when true */
775 unsigned java_error_flag:1;
776 /* @deprecated tag seen */
777 unsigned deprecated:1;
778 /* Flag to report certain errors (fix this documentation. FIXME) */
779 unsigned class_err:1;
780
781 /* This section is used only if we compile jc1 */
782 tree modifier_ctx [12]; /* WFL of modifiers */
783 tree class_type; /* Current class */
784 tree function_decl; /* Current function decl, save/restore */
785
786 int prevent_ese; /* Prevent expression statement error */
787
788 int formal_parameter_number; /* Number of parameters found */
789 int interface_number; /* # itfs declared to extend an itf def */
790
791 tree package; /* Defined package ID */
792
793 /* These two lists won't survive file traversal */
794 tree class_list; /* List of classes in a CU */
795 jdeplist * GTY((skip)) classd_list; /* Classe dependencies in a CU */
796
797 tree current_parsed_class; /* Class currently parsed */
798 tree current_parsed_class_un; /* Curr. parsed class unqualified name */
799
800 tree non_static_initialized; /* List of non static initialized fields */
801 tree static_initialized; /* List of static non final initialized */
802 tree instance_initializers; /* List of instance initializers stmts */
803
804 tree import_list; /* List of import */
805 tree import_demand_list; /* List of import on demand */
806
807 tree current_loop; /* List of the currently nested
808 loops/switches */
809 tree current_labeled_block; /* List of currently nested
810 labeled blocks. */
811
812 int pending_block; /* Pending block to close */
813
814 int explicit_constructor_p; /* >0 when processing an explicit
815 constructor. This flag is used to trap
816 illegal argument usage during an
817 explicit constructor invocation. */
818 };
819
820 /* A set of macros to push/pop/access the currently parsed class. */
821 #define GET_CPC_LIST() ctxp->current_parsed_class
822
823 /* Currently class being parsed is an inner class if an enclosing
824 class has been already pushed. This truth value is only valid prior
825 an inner class is pushed. After, use FIXME. */
826 #define CPC_INNER_P() GET_CPC_LIST ()
827
828 /* The TYPE_DECL node of the class currently being parsed. */
829 #define GET_CPC() TREE_VALUE (GET_CPC_LIST ())
830
831 /* Get the currently parsed class unqualified IDENTIFIER_NODE. */
832 #define GET_CPC_UN() TREE_PURPOSE (GET_CPC_LIST ())
833
834 /* Get a parsed class unqualified IDENTIFIER_NODE from its CPC node. */
835 #define GET_CPC_UN_NODE(N) TREE_PURPOSE (N)
836
837 /* Get the currently parsed class DECL_TYPE from its CPC node. */
838 #define GET_CPC_DECL_NODE(N) TREE_VALUE (N)
839
840 /* The currently parsed enclosing currently parsed TREE_LIST node. */
841 #define GET_ENCLOSING_CPC() TREE_CHAIN (GET_CPC_LIST ())
842
843 /* Get the next enclosing context. */
844 #define GET_NEXT_ENCLOSING_CPC(C) TREE_CHAIN (C)
845
846 /* The DECL_TYPE node of the enclosing currently parsed
847 class. NULL_TREE if the currently parsed class isn't an inner
848 class. */
849 #define GET_ENCLOSING_CPC_CONTEXT() (GET_ENCLOSING_CPC () ? \
850 TREE_VALUE (GET_ENCLOSING_CPC ()) : \
851 NULL_TREE)
852
853 /* Make sure that innerclass T sits in an appropriate enclosing
854 context. */
855 #define INNER_ENCLOSING_SCOPE_CHECK(T) \
856 (INNER_CLASS_TYPE_P ((T)) && !ANONYMOUS_CLASS_P ((T)) \
857 && ((current_this \
858 /* We have a this and it's not the right one */ \
859 && (DECL_CONTEXT (TYPE_NAME ((T))) \
860 != TYPE_NAME (TREE_TYPE (TREE_TYPE (current_this)))) \
861 && !inherits_from_p (TREE_TYPE (TREE_TYPE (current_this)), \
862 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (T)))) \
863 && !common_enclosing_instance_p (TREE_TYPE (TREE_TYPE (current_this)),\
864 (T)) \
865 && INNER_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (current_this))) \
866 && !inherits_from_p \
867 (TREE_TYPE (DECL_CONTEXT \
868 (TYPE_NAME (TREE_TYPE (TREE_TYPE (current_this))))),\
869 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (T))))) \
870 /* We don't have a this, which is OK if the current function is \
871 static. */ \
872 || (!current_this \
873 && current_function_decl \
874 && ! METHOD_STATIC (current_function_decl))))
875
876 /* Push macro. First argument to PUSH_CPC is a DECL_TYPE, second
877 argument is the unqualified currently parsed class name. */
878 #define PUSH_CPC(C,R) { \
879 ctxp->current_parsed_class = \
880 tree_cons ((R), (C), GET_CPC_LIST ()); \
881 }
882
883 /* In case of an error, push an error. */
884 #define PUSH_ERROR() PUSH_CPC (error_mark_node, error_mark_node)
885
886 /* Pop macro. Before we pop, we link the current inner class decl (if any)
887 to its enclosing class. */
888 #define POP_CPC() { \
889 link_nested_class_to_enclosing (); \
890 ctxp->current_parsed_class = \
891 TREE_CHAIN (GET_CPC_LIST ()); \
892 }
893
894 #define DEBUG_CPC() \
895 do \
896 { \
897 tree tmp = ctxp->current_parsed_class; \
898 while (tmp) \
899 { \
900 fprintf (stderr, "%s ", \
901 IDENTIFIER_POINTER (TREE_PURPOSE (tmp))); \
902 tmp = TREE_CHAIN (tmp); \
903 } \
904 } \
905 while (0);
906
907 /* Access to the various initializer statement lists */
908 #define CPC_INITIALIZER_LIST(C) ((C)->non_static_initialized)
909 #define CPC_STATIC_INITIALIZER_LIST(C) ((C)->static_initialized)
910 #define CPC_INSTANCE_INITIALIZER_LIST(C) ((C)->instance_initializers)
911
912 /* Access to the various initializer statements */
913 #define CPC_INITIALIZER_STMT(C) (TREE_PURPOSE (CPC_INITIALIZER_LIST (C)))
914 #define CPC_STATIC_INITIALIZER_STMT(C) \
915 (TREE_PURPOSE (CPC_STATIC_INITIALIZER_LIST (C)))
916 #define CPC_INSTANCE_INITIALIZER_STMT(C) \
917 (TREE_PURPOSE (CPC_INSTANCE_INITIALIZER_LIST (C)))
918
919 /* Set various initializer statements */
920 #define SET_CPC_INITIALIZER_STMT(C,S) \
921 if (CPC_INITIALIZER_LIST (C)) \
922 TREE_PURPOSE (CPC_INITIALIZER_LIST (C)) = (S);
923 #define SET_CPC_STATIC_INITIALIZER_STMT(C,S) \
924 if (CPC_STATIC_INITIALIZER_LIST (C)) \
925 TREE_PURPOSE (CPC_STATIC_INITIALIZER_LIST (C)) = (S);
926 #define SET_CPC_INSTANCE_INITIALIZER_STMT(C,S) \
927 if (CPC_INSTANCE_INITIALIZER_LIST(C)) \
928 TREE_PURPOSE (CPC_INSTANCE_INITIALIZER_LIST (C)) = (S);
929
930 /* This is used by the lexer to communicate with the parser. It is
931 set on an integer constant if the radix is NOT 10, so that the parser
932 can correctly diagnose a numeric overflow. */
933 #define JAVA_NOT_RADIX10_FLAG(NODE) TREE_LANG_FLAG_0(NODE)
934
935 #ifndef JC1_LITE
936 void java_complete_class (void);
937 void java_check_circular_reference (void);
938 void java_fix_constructors (void);
939 void java_layout_classes (void);
940 void java_reorder_fields (void);
941 tree java_method_add_stmt (tree, tree);
942 int java_report_errors (void);
943 extern tree do_resolve_class (tree, tree, tree, tree, tree);
944 #endif
945 char *java_get_line_col (const char *, int, int);
946 extern void reset_report (void);
947
948 /* Always in use, no matter what you compile */
949 void java_push_parser_context (void);
950 void java_pop_parser_context (int);
951 void java_init_lex (FILE *, const char *);
952 extern void java_parser_context_save_global (void);
953 extern void java_parser_context_restore_global (void);
954 int yyparse (void);
955 extern int java_parse (void);
956 extern void yyerror (const char *)
957 #ifdef JC1_LITE
958 ATTRIBUTE_NORETURN
959 #endif
960 ;
961 extern void java_expand_classes (void);
962 extern void java_finish_classes (void);
963
964 extern GTY(()) struct parser_ctxt *ctxp;
965 extern GTY(()) struct parser_ctxt *ctxp_for_generation;
966 extern GTY(()) struct parser_ctxt *ctxp_for_generation_last;
967
968 #endif /* ! GCC_JAVA_PARSE_H */
Mirror of the offical gcc git repository hosted at gcc.gnu.org