#ifndef GCC_JAVA_PARSE_H
#define GCC_JAVA_PARSE_H
#include "lex.h"
extern int java_error_count;
extern struct obstack temporary_obstack;
extern int quiet_flag;
#ifndef JC1_LITE
extern int int_fits_type_p (tree, tree);
extern tree stabilize_reference (tree);
#endif
#ifdef VERBOSE_SKELETON
#define RULE( rule ) printf ( "jv_yacc:%d: rule %s\n", lineno, rule )
#else
#define RULE( rule )
#endif
#ifdef VERBOSE_SKELETON
#undef SOURCE_FRONTEND_DEBUG
#define SOURCE_FRONTEND_DEBUG(X) \
{if (!quiet_flag) {printf ("* "); printf X; putchar ('\n');} }
#else
#define SOURCE_FRONTEND_DEBUG(X)
#endif
#ifdef YYDEBUG
#define RECOVERED \
{ if (!quiet_flag) {printf ("** Recovered\n");} }
#define DRECOVERED(s) \
{ if (!quiet_flag) {printf ("** Recovered (%s)\n", #s);}}
#else
#define RECOVERED
#define DRECOVERED(s)
#endif
#define DRECOVER(s) {yyerrok; DRECOVERED(s);}
#define RECOVER {yyerrok; RECOVERED;}
#define YYERROR_NOW ctxp->java_error_flag = 1
#define YYNOT_TWICE if (ctxp->prevent_ese != input_line)
#define CLASS_MODIFIERS ACC_PUBLIC|ACC_ABSTRACT|ACC_FINAL|ACC_STRICT
#define FIELD_MODIFIERS ACC_PUBLIC|ACC_PROTECTED|ACC_PRIVATE|ACC_FINAL| \
ACC_STATIC|ACC_TRANSIENT|ACC_VOLATILE
#define METHOD_MODIFIERS ACC_PUBLIC|ACC_PROTECTED|ACC_PRIVATE|ACC_ABSTRACT| \
ACC_STATIC|ACC_FINAL|ACC_SYNCHRONIZED|ACC_NATIVE| \
ACC_STRICT
#define INTERFACE_MODIFIERS ACC_PUBLIC|ACC_ABSTRACT|ACC_STRICT
#define INTERFACE_INNER_MODIFIERS ACC_PUBLIC|ACC_PROTECTED|ACC_ABSTRACT| \
ACC_STATIC|ACC_PRIVATE
#define INTERFACE_METHOD_MODIFIERS ACC_PUBLIC|ACC_ABSTRACT
#define INTERFACE_FIELD_MODIFIERS ACC_PUBLIC|ACC_STATIC|ACC_FINAL
#define MODIFIER_WFL(M) (ctxp->modifier_ctx [(M) - PUBLIC_TK])
#ifdef USE_MAPPED_LOCATION
#define THIS_MODIFIER_ONLY(f, m, v, count, l) \
if ((f) & (m)) \
{ \
tree node = MODIFIER_WFL (v); \
if (!l) \
l = node; \
else \
{ \
expanded_location lloc = expand_location (EXPR_LOCATION (l)); \
expanded_location nloc = expand_location (EXPR_LOCATION (node)); \
if (nloc.column > lloc.column || nloc.line > lloc.line) \
l = node; \
} \
count++; \
}
#else
#define THIS_MODIFIER_ONLY(f, m, v, count, l) \
if ((f) & (m)) \
{ \
tree node = MODIFIER_WFL (v); \
if ((l) \
&& ((EXPR_WFL_COLNO (node) > EXPR_WFL_COLNO (l)) \
|| (EXPR_WFL_LINENO (node) > EXPR_WFL_LINENO (l)))) \
l = node; \
else if (!(l)) \
l = node; \
count++; \
}
#endif
#define ABSTRACT_CHECK(FLAG, V, CL, S) \
if ((FLAG) & (V)) \
parse_error_context ((CL), "%s method can't be abstract", (S));
#define JCONSTRUCTOR_CHECK(FLAG, V, CL, S) \
if ((FLAG) & (V)) \
parse_error_context ((CL), "Constructor can't be %s", (S)); \
#define exit_java_complete_class() \
{ \
return; \
}
#define CLASS_OR_INTERFACE(decl, s1, s2) \
(decl ? \
((get_access_flags_from_decl (TYPE_NAME (TREE_TYPE (decl))) \
& ACC_INTERFACE) ? \
s2 : s1) : ((s1 [0]=='S'|| s1 [0]=='s') ? \
(s1 [0]=='S' ? "Supertype" : "supertype") : \
(s1 [0] > 'A' ? "Type" : "type")))
#define GET_REAL_TYPE(TYPE) \
(TREE_CODE (TYPE) == TREE_LIST ? TREE_PURPOSE (TYPE) : TYPE)
#define GET_TYPE_NAME(TYPE) \
(TREE_CODE (TYPE_NAME (TYPE)) == IDENTIFIER_NODE ? \
IDENTIFIER_POINTER (TYPE_NAME (TYPE)) : \
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TYPE))))
#define OBSOLETE_MODIFIER_WARNING(cl, flags, __modifier, arg) \
{ \
if (flag_redundant && (cl) && ((flags) & (__modifier))) \
parse_warning_context (cl, \
"Discouraged redundant use of %qs modifier in declaration of %s", \
java_accstring_lookup (__modifier), arg); \
}
#define OBSOLETE_MODIFIER_WARNING2(cl, flags, __modifier, arg1, arg2) \
{ \
if (flag_redundant && (cl) && ((flags) & (__modifier))) \
parse_warning_context (cl, \
"Discouraged redundant use of %qs modifier in declaration of %s %qs", \
java_accstring_lookup (__modifier), arg1, arg2);\
}
#define BUILD_PTR_FROM_NAME(ptr, name) \
do { \
ptr = make_node (POINTER_TYPE); \
TYPE_NAME (ptr) = name; \
} while (0)
#define INCOMPLETE_TYPE_P(NODE) \
((TREE_CODE (NODE) == POINTER_TYPE) \
&& !TREE_TYPE (NODE) \
&& TREE_CODE (TYPE_NAME (NODE)) == IDENTIFIER_NODE)
#ifndef USE_MAPPED_LOCATION
#define JAVA_MAYBE_GENERATE_DEBUG_INFO(node) \
do {if (debug_info_level != DINFO_LEVEL_NONE) \
EXPR_WFL_EMIT_LINE_NOTE (node) = 1; } while (0)
#endif
#define JFLOAT_TYPE_P(TYPE) (TYPE && TREE_CODE ((TYPE)) == REAL_TYPE)
#define JINTEGRAL_TYPE_P(TYPE) ((TYPE) \
&& (TREE_CODE ((TYPE)) == INTEGER_TYPE \
|| TREE_CODE ((TYPE)) == CHAR_TYPE))
#define JNUMERIC_TYPE_P(TYPE) ((TYPE) \
&& (JFLOAT_TYPE_P ((TYPE)) \
|| JINTEGRAL_TYPE_P ((TYPE))))
#define JPRIMITIVE_TYPE_P(TYPE) ((TYPE) \
&& (JNUMERIC_TYPE_P ((TYPE)) \
|| TREE_CODE ((TYPE)) == BOOLEAN_TYPE))
#define JBSC_TYPE_P(TYPE) ((TYPE) && (((TYPE) == byte_type_node) \
|| ((TYPE) == short_type_node) \
|| ((TYPE) == char_type_node)))
#define JSTRING_TYPE_P(TYPE) ((TYPE) \
&& ((TYPE) == string_type_node || \
(TREE_CODE (TYPE) == POINTER_TYPE && \
TREE_TYPE (TYPE) == string_type_node)))
#define JSTRING_P(NODE) ((NODE) \
&& (TREE_CODE (NODE) == STRING_CST \
|| IS_CRAFTED_STRING_BUFFER_P (NODE) \
|| JSTRING_TYPE_P (TREE_TYPE (NODE))))
#define JREFERENCE_TYPE_P(TYPE) ((TYPE) \
&& (TREE_CODE (TYPE) == RECORD_TYPE \
|| (TREE_CODE (TYPE) == POINTER_TYPE \
&& TREE_CODE (TREE_TYPE (TYPE)) == \
RECORD_TYPE)))
#define JNULLP_TYPE_P(TYPE) ((TYPE) && (TREE_CODE (TYPE) == POINTER_TYPE) \
&& (TYPE) == TREE_TYPE (null_pointer_node))
#define JDECL_P(NODE) (NODE && (TREE_CODE (NODE) == PARM_DECL \
|| TREE_CODE (NODE) == VAR_DECL \
|| TREE_CODE (NODE) == FIELD_DECL))
#define TYPE_INTERFACE_P(TYPE) \
(CLASS_P (TYPE) && CLASS_INTERFACE (TYPE_NAME (TYPE)))
#define TYPE_CLASS_P(TYPE) (CLASS_P (TYPE) \
&& !CLASS_INTERFACE (TYPE_NAME (TYPE)))
#define IDENTIFIER_INNER_CLASS_OUTER_FIELD_ACCESS(NODE) \
(TREE_CODE (NODE) == IDENTIFIER_NODE && \
IDENTIFIER_LENGTH (NODE) >= 8 && \
IDENTIFIER_POINTER (NODE)[7] != '0')
#define MANGLE_OUTER_LOCAL_VARIABLE_NAME(N, O) \
{ \
char *mangled_name; \
obstack_grow (&temporary_obstack, "val$", 4); \
obstack_grow (&temporary_obstack, \
IDENTIFIER_POINTER ((O)), IDENTIFIER_LENGTH ((O))); \
obstack_1grow (&temporary_obstack, '\0'); \
mangled_name = obstack_finish (&temporary_obstack); \
(N) = get_identifier (mangled_name); \
obstack_free (&temporary_obstack, mangled_name); \
}
#define MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID(N, O) \
{ \
char *mangled_name; \
obstack_grow (&temporary_obstack, "parm$", 5); \
obstack_grow (&temporary_obstack, \
IDENTIFIER_POINTER ((O)), IDENTIFIER_LENGTH ((O))); \
obstack_1grow (&temporary_obstack, '\0'); \
mangled_name = obstack_finish (&temporary_obstack); \
(N) = get_identifier (mangled_name); \
obstack_free (&temporary_obstack, mangled_name); \
}
#define MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR(N, S) \
{ \
char *mangled_name; \
obstack_grow (&temporary_obstack, "parm$", 5); \
obstack_grow (&temporary_obstack, (S), strlen ((S))); \
obstack_1grow (&temporary_obstack, '\0'); \
mangled_name = obstack_finish (&temporary_obstack); \
(N) = get_identifier (mangled_name); \
obstack_free (&temporary_obstack, mangled_name); \
}
#define SKIP_THIS_AND_ARTIFICIAL_PARMS(C,M) \
{ \
int i; \
(C) = TYPE_ARG_TYPES (TREE_TYPE ((M))); \
if (!METHOD_STATIC ((M))) \
(C) = TREE_CHAIN (C); \
if (DECL_CONSTRUCTOR_P ((M)) \
&& PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT ((M)))) \
(C) = TREE_CHAIN (C); \
if (!DECL_FINIT_P ((M))) \
for (i = DECL_FUNCTION_NAP ((M)); i; i--) \
(C) = TREE_CHAIN (C); \
}
#define MARK_FINAL_PARMS(M, L) \
{ \
tree current = TYPE_ARG_TYPES (TREE_TYPE ((M))); \
tree list = (L); \
if (!METHOD_STATIC ((M))) \
current = TREE_CHAIN (current); \
for (; current != end_params_node; \
current = TREE_CHAIN (current), list = TREE_CHAIN (list)) \
ARG_FINAL_P (current) = ARG_FINAL_P (list); \
if (current != list) \
abort (); \
}
#define UNMARK_FINAL_PARMS(M) \
{ \
tree current; \
for (current = TYPE_ARG_TYPES (TREE_TYPE ((M))); \
current != end_params_node; current = TREE_CHAIN (current)) \
ARG_FINAL_P (current) = 0; \
}
#define CRAFTED_PARAM_LIST_FIXUP(P) \
{ \
if ((P)) \
{ \
tree last = (P); \
(P) = nreverse (P); \
TREE_CHAIN (last) = end_params_node; \
} \
else \
(P) = end_params_node; \
}
enum {
AIPL_FUNCTION_CREATION,
AIPL_FUNCTION_DECLARATION,
AIPL_FUNCTION_CTOR_INVOCATION,
AIPL_FUNCTION_FINIT_INVOCATION
};
#define ERROR_CANT_CONVERT_TO_BOOLEAN(OPERATOR, NODE, TYPE) \
parse_error_context ((OPERATOR), \
"Incompatible type for %qs. Can't convert %qs to boolean", \
operator_string ((NODE)), lang_printable_name ((TYPE),0))
#define ERROR_CANT_CONVERT_TO_NUMERIC(OPERATOR, NODE, TYPE) \
parse_error_context ((OPERATOR), \
"Incompatible type for %qs. Can't convert %qs to numeric type", \
operator_string ((NODE)), lang_printable_name ((TYPE), 0))
#define ERROR_CAST_NEEDED_TO_INTEGRAL(OPERATOR, NODE, TYPE) \
do { \
tree _operator = (OPERATOR), _node = (NODE), _type = (TYPE); \
if (JPRIMITIVE_TYPE_P (_type)) \
parse_error_context (_operator, \
"Incompatible type for %qs. Explicit cast needed to convert %qs to integral",\
operator_string(_node), \
lang_printable_name (_type, 0)); \
else \
parse_error_context (_operator, \
"Incompatible type for %qs. Can't convert %qs to integral", \
operator_string(_node), \
lang_printable_name (_type, 0)); \
} while (0)
#define ERROR_VARIABLE_NOT_INITIALIZED(WFL, V) \
parse_error_context \
((WFL), "Variable %qs may not have been initialized", \
IDENTIFIER_POINTER (V))
#define LOOP_EXPR_BODY_MAIN_BLOCK(NODE) TREE_OPERAND (NODE, 0)
#define LOOP_EXPR_BODY_UPDATE_BLOCK(NODE) TREE_OPERAND (NODE, 1)
#define LOOP_EXPR_BODY_CONDITION_EXPR(NODE, R) \
TREE_OPERAND (LOOP_EXPR_BODY_MAIN_BLOCK (NODE), (R ? 1 : 0))
#define LOOP_EXPR_BODY_LABELED_BODY(NODE, R) \
TREE_OPERAND (LOOP_EXPR_BODY_MAIN_BLOCK (NODE), (R ? 0 : 1))
#define LOOP_EXPR_BODY_BODY_EXPR(NODE, R) \
LABELED_BLOCK_BODY (LOOP_EXPR_BODY_LABELED_BODY(NODE, R))
#define PUSH_LABELED_BLOCK(B) \
{ \
TREE_CHAIN (B) = ctxp->current_labeled_block; \
ctxp->current_labeled_block = (B); \
}
#define POP_LABELED_BLOCK() \
ctxp->current_labeled_block = TREE_CHAIN (ctxp->current_labeled_block)
#define PUSH_LOOP(L) \
{ \
TREE_CHAIN (L) = ctxp->current_loop; \
ctxp->current_loop = (L); \
}
#define POP_LOOP() ctxp->current_loop = TREE_CHAIN (ctxp->current_loop)
#define PUSH_EXCEPTIONS(E) \
currently_caught_type_list = \
tree_cons (NULL_TREE, (E), currently_caught_type_list);
#define POP_EXCEPTIONS() \
currently_caught_type_list = TREE_CHAIN (currently_caught_type_list)
#define IN_TRY_BLOCK_P() \
(currently_caught_type_list \
&& ((TREE_VALUE (currently_caught_type_list) != \
DECL_FUNCTION_THROWS (current_function_decl)) \
|| TREE_CHAIN (currently_caught_type_list)))
#define EXCEPTIONS_P(E) ((E) ? TREE_VALUE (E) : NULL_TREE)
#define ANONYMOUS_ARRAY_BASE_TYPE(N) TREE_OPERAND ((N), 0)
#define ANONYMOUS_ARRAY_DIMS_SIG(N) TREE_OPERAND ((N), 1)
#define ANONYMOUS_ARRAY_INITIALIZER(N) TREE_OPERAND ((N), 2)
enum {
INVOKE_STATIC,
INVOKE_NONVIRTUAL,
INVOKE_SUPER,
INVOKE_INTERFACE,
INVOKE_VIRTUAL
};
enum jdep_code {
JDEP_NO_PATCH,
JDEP_SUPER,
JDEP_FIELD,
JDEP_METHOD,
JDEP_METHOD_RETURN,
JDEP_METHOD_END,
JDEP_INTERFACE,
JDEP_VARIABLE,
JDEP_PARM,
JDEP_TYPE,
JDEP_EXCEPTION,
JDEP_ANONYMOUS
};
typedef struct _jdep {
ENUM_BITFIELD(jdep_code) kind : 8;
unsigned int flag0 : 1;
tree decl;
tree solv;
tree wfl;
tree misc;
tree enclosing;
tree *patch;
struct _jdep *next;
} jdep;
#define JDEP_DECL(J) ((J)->decl)
#define JDEP_DECL_WFL(J) ((J)->decl)
#define JDEP_KIND(J) ((J)->kind)
#define JDEP_WFL(J) ((J)->wfl)
#define JDEP_MISC(J) ((J)->misc)
#define JDEP_ENCLOSING(J) ((J)->enclosing)
#define JDEP_CLASS(J) ((J)->class)
#define JDEP_APPLY_PATCH(J,P) (*(J)->patch = (P))
#define JDEP_GET_PATCH(J) ((J)->patch)
#define JDEP_CHAIN(J) ((J)->next)
#define JDEP_TO_RESOLVE(J) ((J)->solv)
#define JDEP_RESOLVED_DECL(J) ((J)->solv)
#define JDEP_RESOLVED(J, D) ((J)->solv = D)
#define JDEP_RESOLVED_P(J) \
(!(J)->solv || TREE_CODE ((J)->solv) != POINTER_TYPE)
struct jdeplist_s {
jdep *first;
jdep *last;
struct jdeplist_s *next;
};
typedef struct jdeplist_s jdeplist;
#define CLASSD_FIRST(CD) ((CD)->first)
#define CLASSD_LAST(CD) ((CD)->last)
#define CLASSD_CHAIN(CD) ((CD)->next)
#define JDEP_INSERT(L,J) \
{ \
if (!(L)->first) \
(L)->last = (L)->first = (J); \
else \
{ \
JDEP_CHAIN ((L)->last) = (J); \
(L)->last = (J); \
} \
}
#define SET_TYPE_FOR_RESOLUTION(TYPE, SAVE, CHAIN) \
{ \
tree _returned_type; \
(CHAIN) = 0; \
if (TREE_TYPE (GET_CPC ()) == object_type_node \
&& TREE_CODE (TYPE) == EXPR_WITH_FILE_LOCATION \
&& EXPR_WFL_NODE (TYPE) == unqualified_object_id_node) \
(TYPE) = object_type_node; \
else \
{ \
if (unresolved_type_p (type, &_returned_type)) \
{ \
if (_returned_type) \
(TYPE) = _returned_type; \
else \
{ \
tree _type; \
WFL_STRIP_BRACKET (_type, TYPE); \
(SAVE) = (_type); \
(TYPE) = obtain_incomplete_type (TYPE); \
CHAIN = 1; \
} \
} \
} \
}
#define WFL_STRIP_BRACKET(TARGET, TYPE) \
{ \
tree __type = (TYPE); \
if (TYPE && TREE_CODE (TYPE) == EXPR_WITH_FILE_LOCATION) \
{ \
tree _node; \
if (build_type_name_from_array_name (EXPR_WFL_NODE (TYPE), &_node)) \
{ \
tree _new = copy_node (TYPE); \
EXPR_WFL_NODE (_new) = _node; \
__type = _new; \
} \
} \
(TARGET) = __type; \
}
#define STRING_STRIP_BRACKETS(NAME, NAMELEN, ARRAY_DIMS) \
{ \
ARRAY_DIMS = 0; \
while (NAMELEN >= 2 && (NAME)[NAMELEN - 1] == ']') \
{ \
NAMELEN -= 2; \
(ARRAY_DIMS)++; \
} \
}
#define PROMOTE_RECORD_IF_COMPLETE(TYPE, IS_INCOMPLETE) \
{ \
if (!(IS_INCOMPLETE) && TREE_CODE (TYPE) == RECORD_TYPE) \
(TYPE) = promote_type (TYPE); \
}
#define BLOCK_CHAIN_DECL(NODE) \
{ \
TREE_CHAIN ((NODE)) = \
BLOCK_EXPR_DECLS (GET_CURRENT_BLOCK (current_function_decl)); \
BLOCK_EXPR_DECLS (GET_CURRENT_BLOCK (current_function_decl)) = (NODE); \
}
#define GET_CURRENT_BLOCK(F) ((F) ? DECL_FUNCTION_BODY ((F)) : \
current_static_block)
#ifndef USE_MAPPED_LOCATION
#define EXPR_WFL_GET_LINECOL(V,LINE,COL) \
{ \
(LINE) = (V) >> 12; \
(COL) = (V) & 0xfff; \
}
#endif
#define EXPR_WFL_QUALIFICATION(WFL) TREE_OPERAND ((WFL), 1)
#define QUAL_WFL(NODE) TREE_PURPOSE (NODE)
#define QUAL_RESOLUTION(NODE) TREE_VALUE (NODE)
#define QUAL_DECL_TYPE(NODE) GET_SKIP_TYPE (NODE)
#define GET_SKIP_TYPE(NODE) \
(TREE_CODE (TREE_TYPE (NODE)) == POINTER_TYPE ? \
TREE_TYPE (TREE_TYPE (NODE)): TREE_TYPE (NODE))
#define COMPLETE_CHECK_OP(NODE, N) \
{ \
TREE_OPERAND ((NODE), (N)) = \
java_complete_tree (TREE_OPERAND ((NODE), (N))); \
if (TREE_OPERAND ((NODE), (N)) == error_mark_node) \
return error_mark_node; \
}
#define COMPLETE_CHECK_OP_0(NODE) COMPLETE_CHECK_OP(NODE, 0)
#define COMPLETE_CHECK_OP_1(NODE) COMPLETE_CHECK_OP(NODE, 1)
#define COMPLETE_CHECK_OP_2(NODE) COMPLETE_CHECK_OP(NODE, 2)
#define BUILD_APPEND(ARG) \
((JSTRING_TYPE_P (TREE_TYPE (ARG)) || JPRIMITIVE_TYPE_P (TREE_TYPE (ARG))) \
? build_method_invocation (wfl_append, \
ARG ? build_tree_list (NULL, (ARG)) : NULL_TREE)\
: build_method_invocation (wfl_append, \
ARG ? build_tree_list (NULL, \
build1 (CONVERT_EXPR, \
object_type_node,\
(ARG))) \
: NULL_TREE))
#define BUILD_STRING_BUFFER(ARG) \
build_new_invocation (wfl_string_buffer, \
(ARG ? build_tree_list (NULL, (ARG)) : NULL_TREE))
#define BUILD_THROW(WHERE, WHAT) \
{ \
(WHERE) = \
build3 (CALL_EXPR, void_type_node, \
build_address_of (throw_node), \
build_tree_list (NULL_TREE, (WHAT)), NULL_TREE); \
TREE_SIDE_EFFECTS ((WHERE)) = 1; \
}
#ifdef USE_MAPPED_LOCATION
#define SET_WFL_OPERATOR(WHICH, NODE, WFL) \
SET_EXPR_LOCATION (WHICH, \
(TREE_CODE (WFL) == EXPR_WITH_FILE_LOCATION ? \
EXPR_LOCATION (WFL) : EXPR_LOCATION (NODE)))
#else
#define SET_WFL_OPERATOR(WHICH, NODE, WFL) \
EXPR_WFL_LINECOL (WHICH) = \
(TREE_CODE (WFL) == EXPR_WITH_FILE_LOCATION ? \
EXPR_WFL_LINECOL (WFL) : EXPR_WFL_LINECOL (NODE))
#endif
#define PATCH_METHOD_RETURN_ERROR() \
{ \
if (ret_decl) \
*ret_decl = NULL_TREE; \
return error_mark_node; \
}
#define CHECK_METHODS(CLASS) \
{ \
if (CLASS_INTERFACE ((CLASS))) \
java_check_abstract_methods ((CLASS)); \
else \
java_check_regular_methods ((CLASS)); \
}
#define CLEAR_DEPRECATED ctxp->deprecated = 0
#define CHECK_DEPRECATED_NO_RESET(DECL) \
{ \
if (ctxp->deprecated) \
DECL_DEPRECATED (DECL) = 1; \
}
#define CHECK_DEPRECATED(DECL) \
{ \
if (ctxp->deprecated) \
DECL_DEPRECATED (DECL) = 1; \
ctxp->deprecated = 0; \
}
#define REGISTER_IMPORT(WHOLE, NAME) \
{ \
IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P ((NAME)) = 1; \
ctxp->import_list = tree_cons ((WHOLE), (NAME), ctxp->import_list); \
}
#define CURRENT_OSB(C) (C)->osb_number [(C)->osb_depth]
#define DECL_END_SOURCE_LINE(DECL) (DECL_CHECK (DECL)->decl.u1.i)
#define DECL_INHERITED_SOURCE_LINE(DECL) (DECL_CHECK (DECL)->decl.u2.i)
struct parser_ctxt GTY(()) {
const char *filename;
location_t file_start_location;
location_t save_location;
struct parser_ctxt *next;
java_lexer * GTY((skip)) lexer;
char marker_begining;
int ccb_indent;
source_location first_ccb_indent1;
source_location last_ccb_indent1;
int parser_ccb_indent;
int osb_depth;
int osb_limit;
int * GTY ((skip)) osb_number;
char marker_end;
unsigned saved_data_ctx:1;
unsigned saved_data:1;
unsigned java_error_flag:1;
unsigned deprecated:1;
unsigned class_err:1;
tree modifier_ctx [12];
tree class_type;
tree function_decl;
int prevent_ese;
int formal_parameter_number;
int interface_number;
tree package;
tree class_list;
jdeplist * GTY((skip)) classd_list;
tree current_parsed_class;
tree current_parsed_class_un;
tree non_static_initialized;
tree static_initialized;
tree instance_initializers;
tree import_list;
tree import_demand_list;
tree current_loop;
tree current_labeled_block;
int pending_block;
int explicit_constructor_p;
};
#define GET_CPC_LIST() ctxp->current_parsed_class
#define CPC_INNER_P() GET_CPC_LIST ()
#define GET_CPC() TREE_VALUE (GET_CPC_LIST ())
#define GET_CPC_UN() TREE_PURPOSE (GET_CPC_LIST ())
#define GET_CPC_UN_NODE(N) TREE_PURPOSE (N)
#define GET_CPC_DECL_NODE(N) TREE_VALUE (N)
#define GET_ENCLOSING_CPC() TREE_CHAIN (GET_CPC_LIST ())
#define GET_NEXT_ENCLOSING_CPC(C) TREE_CHAIN (C)
#define GET_ENCLOSING_CPC_CONTEXT() (GET_ENCLOSING_CPC () ? \
TREE_VALUE (GET_ENCLOSING_CPC ()) : \
NULL_TREE)
#define INNER_ENCLOSING_SCOPE_CHECK(T) \
(INNER_CLASS_TYPE_P ((T)) && !ANONYMOUS_CLASS_P ((T)) \
&& ((current_this \
\
&& (DECL_CONTEXT (TYPE_NAME ((T))) \
!= TYPE_NAME (TREE_TYPE (TREE_TYPE (current_this)))) \
&& !inherits_from_p (TREE_TYPE (TREE_TYPE (current_this)), \
TREE_TYPE (DECL_CONTEXT (TYPE_NAME (T)))) \
&& !common_enclosing_instance_p (TREE_TYPE (TREE_TYPE (current_this)),\
(T)) \
&& INNER_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (current_this))) \
&& !inherits_from_p \
(TREE_TYPE (DECL_CONTEXT \
(TYPE_NAME (TREE_TYPE (TREE_TYPE (current_this))))),\
TREE_TYPE (DECL_CONTEXT (TYPE_NAME (T))))) \
\
|| (!current_this \
&& current_function_decl \
&& ! METHOD_STATIC (current_function_decl))))
#define PUSH_CPC(C,R) { \
ctxp->current_parsed_class = \
tree_cons ((R), (C), GET_CPC_LIST ()); \
}
#define PUSH_ERROR() PUSH_CPC (error_mark_node, error_mark_node)
#define POP_CPC() { \
link_nested_class_to_enclosing (); \
ctxp->current_parsed_class = \
TREE_CHAIN (GET_CPC_LIST ()); \
}
#define DEBUG_CPC() \
do \
{ \
tree tmp = ctxp->current_parsed_class; \
while (tmp) \
{ \
fprintf (stderr, "%s ", \
IDENTIFIER_POINTER (TREE_PURPOSE (tmp))); \
tmp = TREE_CHAIN (tmp); \
} \
} \
while (0);
#define CPC_INITIALIZER_LIST(C) ((C)->non_static_initialized)
#define CPC_STATIC_INITIALIZER_LIST(C) ((C)->static_initialized)
#define CPC_INSTANCE_INITIALIZER_LIST(C) ((C)->instance_initializers)
#define CPC_INITIALIZER_STMT(C) (TREE_PURPOSE (CPC_INITIALIZER_LIST (C)))
#define CPC_STATIC_INITIALIZER_STMT(C) \
(TREE_PURPOSE (CPC_STATIC_INITIALIZER_LIST (C)))
#define CPC_INSTANCE_INITIALIZER_STMT(C) \
(TREE_PURPOSE (CPC_INSTANCE_INITIALIZER_LIST (C)))
#define SET_CPC_INITIALIZER_STMT(C,S) \
if (CPC_INITIALIZER_LIST (C)) \
TREE_PURPOSE (CPC_INITIALIZER_LIST (C)) = (S);
#define SET_CPC_STATIC_INITIALIZER_STMT(C,S) \
if (CPC_STATIC_INITIALIZER_LIST (C)) \
TREE_PURPOSE (CPC_STATIC_INITIALIZER_LIST (C)) = (S);
#define SET_CPC_INSTANCE_INITIALIZER_STMT(C,S) \
if (CPC_INSTANCE_INITIALIZER_LIST(C)) \
TREE_PURPOSE (CPC_INSTANCE_INITIALIZER_LIST (C)) = (S);
#define JAVA_NOT_RADIX10_FLAG(NODE) TREE_LANG_FLAG_0(NODE)
#ifndef JC1_LITE
void java_complete_class (void);
void java_check_circular_reference (void);
void java_fix_constructors (void);
void java_layout_classes (void);
void java_reorder_fields (void);
tree java_method_add_stmt (tree, tree);
int java_report_errors (void);
extern tree do_resolve_class (tree, tree, tree, tree);
#endif
char *java_get_line_col (const char *, int, int);
extern void reset_report (void);
void java_push_parser_context (void);
void java_pop_parser_context (int);
void java_init_lex (FILE *, const char *);
extern void java_parser_context_save_global (void);
extern void java_parser_context_restore_global (void);
int yyparse (void);
extern int java_parse (void);
extern void yyerror (const char *)
#ifdef JC1_LITE
ATTRIBUTE_NORETURN
#endif
;
extern void java_expand_classes (void);
extern void java_finish_classes (void);
extern GTY(()) struct parser_ctxt *ctxp;
extern GTY(()) struct parser_ctxt *ctxp_for_generation;
#endif