Index: gcc/c-parse.in =================================================================== --- gcc/c-parse.in (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/c-parse.in (.../trunk) (revision 23) @@ -2357,10 +2357,16 @@ save_location for_cond_expr ';' for_incr_expr ';' save_location upc_affinity_expr ')' start_break start_continue c99_block_lineno_labeled_stmt - { $15 = upc_affinity_test ($10, $15, $11); + { tree t = upc_forall_gasp($5, 1); + if (t != NULL_TREE) + add_stmt(t); + $15 = upc_affinity_test ($10, $15, $11); c_finish_loop ($5, $6, $8, $15, c_break_label, c_cont_label, true); add_stmt (c_end_compound_stmt ($2, flag_isoc99)); + t = upc_forall_gasp($5, 0); + if (t != NULL_TREE) + add_stmt(t); c_break_label = $13; c_cont_label = $14; } ; @@end_ifupc Index: gcc/c.opt =================================================================== --- gcc/c.opt (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/c.opt (.../trunk) (revision 23) @@ -714,6 +714,14 @@ UPC Joined RejectNegative UInteger Specify the number of POSIX threads per process that are mapped to UPC threads +finstrument-gasp +C UPC +Compile with GASP instrumentation support + +finstrument-gasp-functions +C UPC +Compile with GASP function instrumentation (implies -finstrument-gasp) + fuse-cxa-atexit C++ ObjC++ Use __cxa_atexit to register destructors Index: gcc/gimplify.c =================================================================== --- gcc/gimplify.c (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/gimplify.c (.../trunk) (revision 23) @@ -47,6 +47,41 @@ #include "ggc.h" #include "target.h" +#ifndef DISABLE_GASP +extern int flag_gasp_instrument_functions; +extern int get_upc_pupc_mode(void); +extern tree lookup_name (tree); +extern tree build_function_call (tree, tree); +static tree add_gasp_fnargs(tree, const char *, const char *, int); + +/* Add source args to the tree of function arguments */ +static tree add_gasp_fnargs(tree lib_args, const char *func, const char *filename, int lineno) +{ + tree filename_string, func_string; + int filename_len, func_len; + + /* translate const char * into an appropriate tree element */ + filename_len = strlen(filename); + filename_string = build_string(filename_len + 1, filename); + TREE_TYPE (filename_string) = build_array_type + (char_type_node, build_index_type + (build_int_cst (NULL_TREE, filename_len))); + /* same for func */ + func_len = strlen(func); + func_string = build_string(func_len + 1, func); + TREE_TYPE (func_string) = build_array_type + (char_type_node, build_index_type + (build_int_cst (NULL_TREE, func_len))); + /* append __FILE__ and __LINE__ to arglist */ + lib_args = chainon(lib_args, + tree_cons (NULL_TREE, func_string, + tree_cons (NULL_TREE, filename_string, + tree_cons (NULL_TREE, build_int_cst(NULL_TREE, lineno), + NULL_TREE)))); + return lib_args; +} +#endif + static struct gimplify_ctx { tree current_bind_expr; @@ -4715,6 +4750,53 @@ DECL_SAVED_TREE (fndecl) = bind; } +#ifndef DISABLE_GASP + /* add GASP instrumentation function callbacks */ + if (flag_gasp_instrument_functions && get_upc_pupc_mode() + && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl)) + { + tree tf, x, pfunc, bind, libargs1, libargs2; + + location_t xloc; + const char *file, *funcname; + int line; + + xloc = expand_location (DECL_SOURCE_LOCATION (fndecl)); + line = xloc.line; + file = xloc.file; + funcname = 0; + if (DECL_NAME(fndecl)) + funcname = IDENTIFIER_POINTER(DECL_NAME(fndecl)); + + pfunc = implicit_built_in_decls[BUILT_IN_PROFILE_GASP_FUNC]; + + /* use same try - finally trick above */ + tf = build (TRY_FINALLY_EXPR, void_type_node, NULL, NULL); + TREE_SIDE_EFFECTS (tf) = 1; + x = DECL_SAVED_TREE (fndecl); + append_to_statement_list (x, &TREE_OPERAND (tf, 0)); + + libargs1 = tree_cons (NULL_TREE, + build_int_cst(NULL_TREE, 0), NULL_TREE); + libargs1 = add_gasp_fnargs(libargs1, funcname, file, line); + x = build_function_call (pfunc, libargs1); + append_to_statement_list (x, &TREE_OPERAND (tf, 1)); + + bind = build (BIND_EXPR, void_type_node, NULL, NULL, NULL); + TREE_SIDE_EFFECTS (bind) = 1; + + libargs2 = tree_cons (NULL_TREE, + build_int_cst(NULL_TREE, 1), NULL_TREE); + libargs2 = add_gasp_fnargs(libargs2, funcname, file, line); + x = build_function_call (pfunc, libargs2); + append_to_statement_list (x, &BIND_EXPR_BODY (bind)); + + append_to_statement_list (tf, &BIND_EXPR_BODY (bind)); + + DECL_SAVED_TREE (fndecl) = bind; + } +#endif + current_function_decl = oldfn; cfun = oldfn ? DECL_STRUCT_FUNCTION (oldfn) : NULL; } Index: gcc/c-pragma.c =================================================================== --- gcc/c-pragma.c (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/c-pragma.c (.../trunk) (revision 23) @@ -506,6 +506,46 @@ static void init_pragma_upc PARAMS((void)); static void handle_pragma_upc PARAMS ((cpp_reader *)); +#ifndef DISABLE_GASP +static int pragma_pupc_on; +static void init_pragma_pupc(); +static void handle_pragma_pupc(cpp_reader *); + +/* Pragma pupc defaults to being on */ +static void init_pragma_pupc() { + pragma_pupc_on = 1; +} + +int get_upc_pupc_mode() { + return pragma_pupc_on; +} + +/* + * #pragma pupc on + * #pragma pupc off + */ +static void handle_pragma_pupc (cpp_reader *dummy ATTRIBUTE_UNUSED) +{ + tree x; + enum cpp_ttype t; + + t = c_lex(&x); + if (t == CPP_NAME) { + const char *op = IDENTIFIER_POINTER (x); + if (!strcmp (op, "on")) + pragma_pupc_on = 1; + else if (!strcmp (op, "off")) + pragma_pupc_on = 0; + else + GCC_BAD2 ("unknown action '%s' for '#pragma pupc' - ignored", op); + } + + t = c_lex (&x); + if (t != CPP_EOF) + warning ("junk at end of #pragma pupc"); +} +#endif + /* Initialize the variables used to manage the current UPC consistency mode (strict/relaxed) */ @@ -866,6 +906,11 @@ init_pragma_upc (); #endif +#ifndef DISABLE_GASP + c_register_pragma (0, "pupc", handle_pragma_pupc); + init_pragma_pupc (); +#endif + #ifdef REGISTER_TARGET_PRAGMAS REGISTER_TARGET_PRAGMAS (); #endif Index: gcc/optabs.c =================================================================== --- gcc/optabs.c (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/optabs.c (.../trunk) (revision 23) @@ -5061,6 +5061,18 @@ xgets_optab = init_optab (UNKNOWN); xputs_optab = init_optab (UNKNOWN); +#ifndef DISABLE_GASP + /* UPC operations (profiled) */ + getg_optab = init_optab (UNKNOWN); + putg_optab = init_optab (UNKNOWN); + getsg_optab = init_optab (UNKNOWN); + putsg_optab = init_optab (UNKNOWN); + xgetg_optab = init_optab (UNKNOWN); + xputg_optab = init_optab (UNKNOWN); + xgetsg_optab = init_optab (UNKNOWN); + xputsg_optab = init_optab (UNKNOWN); +#endif + vec_extract_optab = init_optab (UNKNOWN); vec_set_optab = init_optab (UNKNOWN); vec_init_optab = init_optab (UNKNOWN); @@ -5175,6 +5187,37 @@ init_libfuncs (xputs_optab, BLKmode, BLKmode, "puts", '3'); init_floating_libfuncs (xputs_optab, "puts", '2'); +#ifndef DISABLE_GASP + /* UPC operations (profiled) */ + init_all_integral_libfuncs (getg_optab, "getg", '4'); + init_libfuncs (getg_optab, BLKmode, BLKmode, "getg", '5'); + init_floating_libfuncs (getg_optab, "getg", '4'); + init_all_integral_libfuncs (putg_optab, "putg", '4'); + init_libfuncs (putg_optab, BLKmode, BLKmode, "putg", '5'); + init_floating_libfuncs (putg_optab, "putg", '4'); + init_all_integral_libfuncs (getsg_optab, "getsg", '4'); + init_libfuncs (getsg_optab, BLKmode, BLKmode, "getsg", '5'); + init_floating_libfuncs (getsg_optab, "getsg", '4'); + init_all_integral_libfuncs (putsg_optab, "putsg", '4'); + init_libfuncs (putsg_optab, BLKmode, BLKmode, "putsg", '5'); + init_floating_libfuncs (putsg_optab, "putsg", '4'); + /* 64 bit targeted functions: we don't change the library + call names, because multilibs will handle the overloading + if necessary. */ + init_all_integral_libfuncs (xgetg_optab, "getg", '4'); + init_libfuncs (xgetg_optab, BLKmode, BLKmode, "getg", '5'); + init_floating_libfuncs (xgetg_optab, "getg", '4'); + init_all_integral_libfuncs (xputg_optab, "putg", '4'); + init_libfuncs (xputg_optab, BLKmode, BLKmode, "putg", '5'); + init_floating_libfuncs (xputg_optab, "putg", '4'); + init_all_integral_libfuncs (xgetsg_optab, "getsg", '4'); + init_libfuncs (xgetsg_optab, BLKmode, BLKmode, "getsg", '5'); + init_floating_libfuncs (xgetsg_optab, "getsg", '4'); + init_all_integral_libfuncs (xputsg_optab, "putsg", '4'); + init_libfuncs (xputsg_optab, BLKmode, BLKmode, "putsg", '5'); + init_floating_libfuncs (xputsg_optab, "putsg", '4'); +#endif + /* EQ etc are floating point only. */ init_floating_libfuncs (eq_optab, "eq", '2'); init_floating_libfuncs (ne_optab, "ne", '2'); Index: gcc/optabs.h =================================================================== --- gcc/optabs.h (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/optabs.h (.../trunk) (revision 23) @@ -235,6 +235,18 @@ OTI_upcxgets, OTI_upcxputs, +#ifndef DISABLE_GASP + /* Profiled UPC-related optabs */ + OTI_upcgetg, + OTI_upcputg, + OTI_upcgetsg, + OTI_upcputsg, + OTI_upcxgetg, + OTI_upcxputg, + OTI_upcxgetsg, + OTI_upcxputsg, +#endif + /* Conditional add instruction. */ OTI_addcc, @@ -368,6 +380,18 @@ #define xgets_optab (optab_table[OTI_upcxgets]) #define xputs_optab (optab_table[OTI_upcxputs]) +#ifndef DISABLE_GASP +/* UPC-related operation tables (profiled) */ +#define getg_optab (optab_table[OTI_upcgetg]) +#define putg_optab (optab_table[OTI_upcputg]) +#define getsg_optab (optab_table[OTI_upcgetsg]) +#define putsg_optab (optab_table[OTI_upcputsg]) +#define xgetg_optab (optab_table[OTI_upcxgetg]) +#define xputg_optab (optab_table[OTI_upcxputg]) +#define xgetsg_optab (optab_table[OTI_upcxgetsg]) +#define xputsg_optab (optab_table[OTI_upcxputsg]) +#endif + /* Conversion optabs have their own table and indexes. */ enum convert_optab_index { Index: gcc/upc/upc-act.h =================================================================== --- gcc/upc/upc-act.h (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/upc/upc-act.h (.../trunk) (revision 23) @@ -35,6 +35,7 @@ /* used by yyparse */ extern tree upc_build_sync_stmt (tree, tree); extern tree upc_affinity_test (location_t, tree, tree); +extern tree upc_forall_gasp (location_t, int); extern struct c_expr upc_blocksizeof_expr (struct c_expr); extern struct c_expr upc_blocksizeof_type (struct c_type_name *); extern struct c_expr upc_elemsizeof_expr (struct c_expr); Index: gcc/upc/upc-gimplify.c =================================================================== --- gcc/upc/upc-gimplify.c (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/upc/upc-gimplify.c (.../trunk) (revision 23) @@ -71,6 +71,29 @@ static int upc_gimplify_shared_var_ref (tree *, tree *, tree *); static int upc_gimplify_sync_stmt (tree *, tree *, tree *); +#ifndef DISABLE_GASP +static tree add_gasp_srcargs(tree, const char *, int); + +/* Add source args to the tree of function arguments */ +static tree add_gasp_srcargs(tree lib_args, const char *filename, int lineno) +{ + tree filename_string; + int filename_len; + filename_len = strlen(filename); + /* translate const char * into an appropriate tree element */ + filename_string = build_string(filename_len + 1, filename); + TREE_TYPE (filename_string) = build_array_type + (char_type_node, build_index_type + (build_int_cst (NULL_TREE, filename_len))); + /* append __FILE__ and __LINE__ to arglist */ + lib_args = chainon(lib_args, + tree_cons (NULL_TREE, filename_string, + tree_cons (NULL_TREE, build_int_cst(NULL_TREE, lineno), + NULL_TREE))); + return lib_args; +} +#endif + /* Generate call to runtime to implement a 'get' of a shared * object. EXP is a pointer to shared value that references * the shared object. */ @@ -83,15 +106,33 @@ tree result_type = TYPE_MAIN_VARIANT (type); int strict_mode = TYPE_STRICT (type) || (!TYPE_RELAXED (type) && get_upc_consistency_mode ()); - optab get_op = (POINTER_SIZE == 64) - ? (strict_mode ? xgets_optab : xget_optab) - : (strict_mode ? gets_optab : get_optab); enum machine_mode mode = TYPE_MODE (type); enum machine_mode op_mode = (mode == TImode) ? BLKmode : mode; - rtx lib_op = get_op->handlers[(int) op_mode].libfunc; const char *libfunc_name; tree src = build1 (NOP_EXPR, upc_sptr_rep_type_node, exp); tree result, libfunc, lib_args, lib_call; + optab get_op; + rtx lib_op; +#ifndef DISABLE_GASP + int doprofcall = get_upc_pupc_mode() && flag_gasp_instrument; + if (doprofcall) + { + get_op = (POINTER_SIZE == 64) + ? (strict_mode ? xgetsg_optab : xgetg_optab) + : (strict_mode ? getsg_optab : getg_optab); + } + else + { + get_op = (POINTER_SIZE == 64) + ? (strict_mode ? xgets_optab : xget_optab) + : (strict_mode ? gets_optab : get_optab); + } +#else + get_op = (POINTER_SIZE == 64) + ? (strict_mode ? xgets_optab : xget_optab) + : (strict_mode ? gets_optab : get_optab); +#endif + lib_op = get_op->handlers[(int) op_mode].libfunc; if (!lib_op) abort (); libfunc_name = XSTR (lib_op, 0); @@ -107,12 +148,24 @@ lib_args = tree_cons (NULL_TREE, result_addr, tree_cons (NULL_TREE, src, tree_cons (NULL_TREE, size, NULL_TREE))); +#ifndef DISABLE_GASP + if (doprofcall) + { + lib_args = add_gasp_srcargs(lib_args, input_filename, input_line); + } +#endif lib_call = build_function_call (libfunc, lib_args); gimplify_and_add (lib_call, pre_p); } else { lib_args = tree_cons (NULL_TREE, src, NULL_TREE); +#ifndef DISABLE_GASP + if (doprofcall) + { + lib_args = add_gasp_srcargs(lib_args, input_filename, input_line); + } +#endif lib_call = build_function_call (libfunc, lib_args); if (!lang_hooks.types_compatible_p (result_type, TREE_TYPE (lib_call))) lib_call = build1 (NOP_EXPR, result_type, lib_call); @@ -131,17 +184,40 @@ tree type = TREE_TYPE (src); int strict_mode = TYPE_STRICT (type) || (!TYPE_RELAXED (type) && get_upc_consistency_mode ()); - optab put_op = (POINTER_SIZE == 64) - ? (strict_mode ? xputs_optab : xput_optab) - : (strict_mode ? puts_optab : put_optab); enum machine_mode mode = TYPE_MODE (type); enum machine_mode op_mode = (mode == TImode) ? BLKmode : mode; int is_src_shared = (TREE_SHARED (src) || TYPE_SHARED (TREE_TYPE (src))); int is_shared_copy = (mode == BLKmode) && is_src_shared; const char *libfunc_name; tree libfunc, lib_args, lib_call; + optab put_op; +#ifndef DISABLE_GASP + int doprofcall = get_upc_pupc_mode() && flag_gasp_instrument; + if (doprofcall) + { + put_op = (POINTER_SIZE == 64) + ? (strict_mode ? xputsg_optab : xputg_optab) + : (strict_mode ? putsg_optab : putg_optab); + } + else + { + put_op = (POINTER_SIZE == 64) + ? (strict_mode ? xputs_optab : xput_optab) + : (strict_mode ? puts_optab : put_optab); + } +#else + put_op = (POINTER_SIZE == 64) + ? (strict_mode ? xputs_optab : xput_optab) + : (strict_mode ? puts_optab : put_optab); +#endif if (is_shared_copy) - libfunc_name = strict_mode ? "__copysblk3" : "__copyblk3"; + { + libfunc_name = strict_mode ? "__copysblk3" : "__copyblk3"; +#ifndef DISABLE_GASP + if (doprofcall) + libfunc_name = strict_mode ? "__copygsblk5" : "__copygblk5"; +#endif + } else { rtx lib_op = put_op->handlers[(int) op_mode].libfunc; @@ -180,6 +256,12 @@ ? VIEW_CONVERT_EXPR : NOP_EXPR, src_type, src); lib_args = chainon (lib_args, tree_cons (NULL_TREE, src, NULL_TREE)); } +#ifndef DISABLE_GASP + if (doprofcall) + { + lib_args = add_gasp_srcargs(lib_args, input_filename, input_line); + } +#endif lib_call = build_function_call (libfunc, lib_args); return lib_call; } @@ -440,7 +522,10 @@ tree sync_id = UPC_SYNC_ID (stmt); const int op = (int)tree_low_cst (sync_op, 1); const char *libfunc_name = (char *)0; - tree libfunc; +#ifndef DISABLE_GASP + int doprofcall = get_upc_pupc_mode() && flag_gasp_instrument; +#endif + tree libfunc, lib_args; switch (op) { case UPC_SYNC_NOTIFY_OP: @@ -452,13 +537,32 @@ default: abort(); } +#ifndef DISABLE_GASP + if (doprofcall) + { + switch (op) + { + case UPC_SYNC_NOTIFY_OP: libfunc_name = UPC_NOTIFYG_LIBCALL; break; + case UPC_SYNC_WAIT_OP: libfunc_name = UPC_WAITG_LIBCALL; break; + case UPC_SYNC_BARRIER_OP: libfunc_name = UPC_BARRIERG_LIBCALL; break; + default: abort(); + } + } +#endif libfunc = lookup_name (get_identifier (libfunc_name)); if (!libfunc) internal_error ("runtime function %s not found", libfunc_name); if (!sync_id) sync_id = build_int_cst (NULL_TREE, INT_MIN); - *stmt_p = build_function_call_expr (libfunc, - tree_cons (NULL_TREE, sync_id, NULL_TREE)); + + lib_args = tree_cons (NULL_TREE, sync_id, NULL_TREE); +#ifndef DISABLE_GASP + if (doprofcall) + { + lib_args = add_gasp_srcargs(lib_args, input_filename, input_line); + } +#endif + *stmt_p = build_function_call (libfunc, lib_args); return GS_UNHANDLED; } Index: gcc/upc/upc-lang.c =================================================================== --- gcc/upc/upc-lang.c (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/upc/upc-lang.c (.../trunk) (revision 23) @@ -177,6 +177,11 @@ flag_upc_pthreads = 0; upc_pthreads_model = upc_pthreads_no_model; flag_upc_pthreads_per_process = 0; +#ifndef DISABLE_GASP + /* don't instrument for GASP unless someone requests it */ + flag_gasp_instrument = 0; + flag_gasp_instrument_functions = 0; +#endif return result; } Index: gcc/upc/upc-act.c =================================================================== --- gcc/upc/upc-act.c (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/upc/upc-act.c (.../trunk) (revision 23) @@ -138,6 +138,16 @@ case OPT_lang_upc: flag_upc = value; break; +#ifndef DISABLE_GASP + case OPT_finstrument_gasp: + flag_gasp_instrument = value; + break; + + case OPT_finstrument_gasp_functions: + flag_gasp_instrument = value; + flag_gasp_instrument_functions = value; + break; +#endif } return result; } @@ -168,6 +178,12 @@ { char def_buf[256]; cpp_define (parse_in, "__GCC_UPC__=1"); +#ifndef DISABLE_GASP + if (flag_gasp_instrument) + { + cpp_define (parse_in, "__UPC_PUPC__=1"); + } +#endif cpp_define (parse_in, "__UPC__=1"); cpp_define (parse_in, "__UPC_VERSION__=200310L"); (void) sprintf (def_buf, "UPC_MAX_BLOCK_SIZE=%s", UPC_MAX_BLOCK_SIZE_STRING); @@ -899,6 +915,51 @@ bitsize_unit_node)); } +/* + * Handle UPC_FORALL GASP events. Return a libupc function call if + * appropriate. + */ +tree +upc_forall_gasp (location_t loc, int start) +{ +#ifndef DISABLE_GASP + int docall = get_upc_pupc_mode() && flag_gasp_instrument; + if (docall) + { + int filename_len; + const char *filename, *funcname = "__upc_forallg"; + tree lib_args, filename_string, func; + + filename = loc.file; + filename_len = strlen(loc.file); + + /* add start/end flag to arg list */ + lib_args = tree_cons (NULL_TREE, + build_int_cst(NULL_TREE, start), NULL_TREE); + + /* translate const char * into an appropriate tree element */ + filename_string = build_string(filename_len + 1, filename); + TREE_TYPE (filename_string) = build_array_type + (char_type_node, build_index_type + (build_int_cst (NULL_TREE, filename_len))); + + /* append __FILE__ and __LINE__ to arglist */ + lib_args = chainon(lib_args, + tree_cons (NULL_TREE, filename_string, + tree_cons (NULL_TREE, build_int_cst(NULL_TREE, loc.line), + NULL_TREE))); + + /* assemble the call to libupc forall profiled function */ + func = lookup_name(get_identifier(funcname)); + if (!func) + internal_error ("runtime function %s not found", funcname); + + return build_function_call (func, lib_args); + } +#endif + return NULL_TREE; +} + /* Implement UPC's upc_forall `affinity' test, by augmenting the for statement's for_body by rewriting it into: if (affinity == MYTHREAD) for_body; */ Index: gcc/genopinit.c =================================================================== --- gcc/genopinit.c (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/genopinit.c (.../trunk) (revision 23) @@ -172,6 +172,18 @@ "xput_optab->handlers[$A].insn_code = CODE_FOR_$(xput$a2$)", "xputs_optab->handlers[$A].insn_code = CODE_FOR_$(xputs$a2$)", +#ifndef DISABLE_GASP + /* Profiled UPC opcodes */ + "getg_optab->handlers[$A].insn_code = CODE_FOR_$(getg$a4$)", + "getsg_optab->handlers[$A].insn_code = CODE_FOR_$(getsg$a4$)", + "putg_optab->handlers[$A].insn_code = CODE_FOR_$(putg$a4$)", + "putsg_optab->handlers[$A].insn_code = CODE_FOR_$(putsg$a4$)", + "xgetg_optab->handlers[$A].insn_code = CODE_FOR_$(xgetg$a4$)", + "xgetsg_optab->handlers[$A].insn_code = CODE_FOR_$(xgetsg$a4$)", + "xputg_optab->handlers[$A].insn_code = CODE_FOR_$(xputg$a4$)", + "xputsg_optab->handlers[$A].insn_code = CODE_FOR_$(xputsg$a4$)", +#endif + "reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)", "reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)", "movmem_optab[$A] = CODE_FOR_$(movmem$a$)", Index: gcc/tree.c =================================================================== --- gcc/tree.c (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/tree.c (.../trunk) (revision 23) @@ -5938,6 +5938,20 @@ local_define_builtin ("__builtin_profile_func_exit", ftype, BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0); +#ifndef DISABLE_GASP + /* + * arg list to __gasp_functiong: + * int start, const char *func, const char *file, int line + */ + tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node); + tmp = tree_cons (NULL_TREE, ptr_type_node, tmp); + tmp = tree_cons (NULL_TREE, ptr_type_node, tmp); + tmp = tree_cons (NULL_TREE, integer_type_node, tmp); + ftype = build_function_type (void_type_node, tmp); + local_define_builtin ("__builtin_gasp_functiong", ftype, + BUILT_IN_PROFILE_GASP_FUNC, "__gasp_functiong", 0); +#endif + /* Complex multiplication and division. These are handled as builtins rather than optabs because emit_library_call_value doesn't support complex. Further, we can do slightly better with folding these Index: gcc/c-opts.c =================================================================== --- gcc/c-opts.c (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/c-opts.c (.../trunk) (revision 23) @@ -845,6 +845,19 @@ cpp_set_lang (parse_in, CLK_UPC); break; +#ifndef DISABLE_GASP + case OPT_finstrument_gasp: + case OPT_finstrument_gasp_functions: + /* processed in UPC routine */ + break; +#else + /* no GASP support -> error */ + case OPT_finstrument_gasp: + case OPT_finstrument_gasp_functions: + error("GASP support has been disabled in this compiler"); + break; +#endif + case OPT_fupc_pthreads_model_tls: case OPT_fupc_pthreads_per_process_: case OPT_fupc_threads_: Index: gcc/builtins.def =================================================================== --- gcc/builtins.def (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/builtins.def (.../trunk) (revision 23) @@ -641,3 +641,4 @@ /* Profiling hooks. */ DEF_BUILTIN_STUB (BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter") DEF_BUILTIN_STUB (BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit") +DEF_BUILTIN_STUB (BUILT_IN_PROFILE_GASP_FUNC, "__gasp_functiong") Index: gcc/c-common.c =================================================================== --- gcc/c-common.c (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/c-common.c (.../trunk) (revision 23) @@ -262,6 +262,14 @@ time by the -fupc-pthreads-model-* switch. */ upc_pthreads_model_kind upc_pthreads_model; +#ifndef DISABLE_GASP +/* Nonzero if -finstrument-gasp was given */ +int flag_gasp_instrument; + +/* Nonzero if -finstrument-gasp-functions was given */ +int flag_gasp_instrument_functions; +#endif + /* Nonzero if -undef was given. It suppresses target built-in macros and assertions. */ int flag_undef; Index: gcc/c-common.h =================================================================== --- gcc/c-common.h (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/c-common.h (.../trunk) (revision 23) @@ -412,6 +412,14 @@ time by the -fupc-pthreads-model-* switch. */ extern upc_pthreads_model_kind upc_pthreads_model; +#ifndef DISABLE_GASP +/* Nonzero if -finstrument-gasp was given */ +extern int flag_gasp_instrument; + +/* Nonzero if -finstrument-gasp-functions was given */ +extern int flag_gasp_instrument_functions; +#endif + /* Nonzero if -undef was given. It suppresses target built-in macros and assertions. */ Index: gcc/c-tree.h =================================================================== --- gcc/c-tree.h (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/c-tree.h (.../trunk) (revision 23) @@ -191,6 +191,11 @@ extern void push_upc_consistency_mode PARAMS((void)); extern void pop_upc_consistency_mode PARAMS((void)); +#ifndef DISABLE_GASP +/* querying if pupc is on or off */ +extern int get_upc_pupc_mode(void); +#endif + /* A kind of type specifier. Note that this information is currently only used to distinguish tag definitions, tag references and typeof uses. */ Index: gcc/config/upc-conf.h =================================================================== --- gcc/config/upc-conf.h (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/config/upc-conf.h (.../trunk) (revision 23) @@ -111,3 +111,10 @@ #define UPC_GETADDR_LIBCALL "__getaddr" #define UPC_NOTIFY_LIBCALL "__upc_notify" #define UPC_WAIT_LIBCALL "__upc_wait" + +/* Names of profiled versions of the UPC library functions */ +#ifndef DISABLE_GASP +#define UPC_BARRIERG_LIBCALL "__upc_barrierg" +#define UPC_NOTIFYG_LIBCALL "__upc_notifyg" +#define UPC_WAITG_LIBCALL "__upc_waitg" +#endif Index: gcc/c-parse.c =================================================================== --- gcc/c-parse.c (.../vendor/gcc-upc-4/current) (revision 23) +++ gcc/c-parse.c (.../trunk) (revision 23) @@ -1,5994 +0,0 @@ -/* A Bison parser, made by GNU Bison 2.0. */ - -/* Skeleton parser for Yacc-like parsing with Bison, - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -/* As a special exception, when this file is copied by Bison into a - Bison output file, you may use that output file without restriction. - This special exception was added by the Free Software Foundation - in version 1.24 of Bison. */ - -/* Written by Richard Stallman by simplifying the original so called - ``semantic'' parser. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -/* Identify Bison output. */ -#define YYBISON 1 - -/* Skeleton name. */ -#define YYSKELETON_NAME "yacc.c" - -/* Pure parsers. */ -#define YYPURE 0 - -/* Using locations. */ -#define YYLSP_NEEDED 0 - - - -/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum yytokentype { - IDENTIFIER = 258, - TYPENAME = 259, - SCSPEC = 260, - STATIC = 261, - TYPESPEC = 262, - TYPE_QUAL = 263, - OBJC_TYPE_QUAL = 264, - CONSTANT = 265, - STRING = 266, - ELLIPSIS = 267, - SIZEOF = 268, - ENUM = 269, - STRUCT = 270, - UNION = 271, - IF = 272, - ELSE = 273, - WHILE = 274, - DO = 275, - FOR = 276, - SWITCH = 277, - CASE = 278, - DEFAULT = 279, - BREAK = 280, - CONTINUE = 281, - RETURN = 282, - GOTO = 283, - ASM_KEYWORD = 284, - TYPEOF = 285, - ALIGNOF = 286, - ATTRIBUTE = 287, - EXTENSION = 288, - LABEL = 289, - REALPART = 290, - IMAGPART = 291, - VA_ARG = 292, - CHOOSE_EXPR = 293, - TYPES_COMPATIBLE_P = 294, - FUNC_NAME = 295, - OFFSETOF = 296, - ASSIGN = 297, - OROR = 298, - ANDAND = 299, - EQCOMPARE = 300, - ARITHCOMPARE = 301, - RSHIFT = 302, - LSHIFT = 303, - MINUSMINUS = 304, - PLUSPLUS = 305, - UNARY = 306, - HYPERUNARY = 307, - POINTSAT = 308, - AT_INTERFACE = 309, - AT_IMPLEMENTATION = 310, - AT_END = 311, - AT_SELECTOR = 312, - AT_DEFS = 313, - AT_ENCODE = 314, - CLASSNAME = 315, - AT_PUBLIC = 316, - AT_PRIVATE = 317, - AT_PROTECTED = 318, - AT_PROTOCOL = 319, - AT_CLASS = 320, - AT_ALIAS = 321, - AT_THROW = 322, - AT_TRY = 323, - AT_CATCH = 324, - AT_FINALLY = 325, - AT_SYNCHRONIZED = 326, - OBJC_STRING = 327 - }; -#endif -#define IDENTIFIER 258 -#define TYPENAME 259 -#define SCSPEC 260 -#define STATIC 261 -#define TYPESPEC 262 -#define TYPE_QUAL 263 -#define OBJC_TYPE_QUAL 264 -#define CONSTANT 265 -#define STRING 266 -#define ELLIPSIS 267 -#define SIZEOF 268 -#define ENUM 269 -#define STRUCT 270 -#define UNION 271 -#define IF 272 -#define ELSE 273 -#define WHILE 274 -#define DO 275 -#define FOR 276 -#define SWITCH 277 -#define CASE 278 -#define DEFAULT 279 -#define BREAK 280 -#define CONTINUE 281 -#define RETURN 282 -#define GOTO 283 -#define ASM_KEYWORD 284 -#define TYPEOF 285 -#define ALIGNOF 286 -#define ATTRIBUTE 287 -#define EXTENSION 288 -#define LABEL 289 -#define REALPART 290 -#define IMAGPART 291 -#define VA_ARG 292 -#define CHOOSE_EXPR 293 -#define TYPES_COMPATIBLE_P 294 -#define FUNC_NAME 295 -#define OFFSETOF 296 -#define ASSIGN 297 -#define OROR 298 -#define ANDAND 299 -#define EQCOMPARE 300 -#define ARITHCOMPARE 301 -#define RSHIFT 302 -#define LSHIFT 303 -#define MINUSMINUS 304 -#define PLUSPLUS 305 -#define UNARY 306 -#define HYPERUNARY 307 -#define POINTSAT 308 -#define AT_INTERFACE 309 -#define AT_IMPLEMENTATION 310 -#define AT_END 311 -#define AT_SELECTOR 312 -#define AT_DEFS 313 -#define AT_ENCODE 314 -#define CLASSNAME 315 -#define AT_PUBLIC 316 -#define AT_PRIVATE 317 -#define AT_PROTECTED 318 -#define AT_PROTOCOL 319 -#define AT_CLASS 320 -#define AT_ALIAS 321 -#define AT_THROW 322 -#define AT_TRY 323 -#define AT_CATCH 324 -#define AT_FINALLY 325 -#define AT_SYNCHRONIZED 326 -#define OBJC_STRING 327 - - - - -/* Copy the first part of user declarations. */ -#line 34 "c-parse.y" - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "tm.h" -#include "tree.h" -#include "langhooks.h" -#include "input.h" -#include "cpplib.h" -#include "intl.h" -#include "timevar.h" -#include "c-pragma.h" /* For YYDEBUG definition, and parse_in. */ -#include "c-tree.h" -#include "flags.h" -#include "varray.h" -#include "output.h" -#include "toplev.h" -#include "ggc.h" -#include "c-common.h" - -#define YYERROR1 { yyerror ("syntax error"); YYERROR; } - -/* Like the default stack expander, except (1) use realloc when possible, - (2) impose no hard maxiumum on stack size, (3) REALLY do not use alloca. - - Irritatingly, YYSTYPE is defined after this %{ %} block, so we cannot - give malloced_yyvs its proper type. This is ok since all we need from - it is to be able to free it. */ - -static short *malloced_yyss; -static void *malloced_yyvs; - -#define yyoverflow(MSG, SS, SSSIZE, VS, VSSIZE, YYSSZ) \ -do { \ - size_t newsize; \ - short *newss; \ - YYSTYPE *newvs; \ - newsize = *(YYSSZ) *= 2; \ - if (malloced_yyss) \ - { \ - newss = really_call_realloc (*(SS), newsize * sizeof (short)); \ - newvs = really_call_realloc (*(VS), newsize * sizeof (YYSTYPE)); \ - } \ - else \ - { \ - newss = really_call_malloc (newsize * sizeof (short)); \ - newvs = really_call_malloc (newsize * sizeof (YYSTYPE)); \ - if (newss) \ - memcpy (newss, *(SS), (SSSIZE)); \ - if (newvs) \ - memcpy (newvs, *(VS), (VSSIZE)); \ - } \ - if (!newss || !newvs) \ - { \ - yyerror (MSG); \ - return 2; \ - } \ - *(SS) = newss; \ - *(VS) = newvs; \ - malloced_yyss = newss; \ - malloced_yyvs = (void *) newvs; \ -} while (0) - - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif - -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE 0 -#endif - -#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) -#line 100 "c-parse.y" -typedef union YYSTYPE {long itype; tree ttype; void *otype; struct c_expr exprtype; - struct c_arg_info *arginfotype; struct c_declarator *dtrtype; - struct c_type_name *typenametype; struct c_parm *parmtype; - struct c_declspecs *dsptype; struct c_typespec tstype; - enum tree_code code; location_t location; } YYSTYPE; -/* Line 190 of yacc.c. */ -#line 290 "c-parse.c" -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 -#endif - - - -/* Copy the second part of user declarations. */ -#line 251 "c-parse.y" - -/* Declaration specifiers of the current declaration. */ -static struct c_declspecs *current_declspecs; -static GTY(()) tree prefix_attributes; - -/* List of all the attributes applying to the identifier currently being - declared; includes prefix_attributes and possibly some more attributes - just after a comma. */ -static GTY(()) tree all_prefix_attributes; - -/* Structure to save declaration specifiers. */ -struct c_declspec_stack { - /* Saved value of current_declspecs. */ - struct c_declspecs *current_declspecs; - /* Saved value of prefix_attributes. */ - tree prefix_attributes; - /* Saved value of all_prefix_attributes. */ - tree all_prefix_attributes; - /* Next level of stack. */ - struct c_declspec_stack *next; -}; - -/* Stack of saved values of current_declspecs, prefix_attributes and - all_prefix_attributes. */ -static struct c_declspec_stack *declspec_stack; - -/* INDIRECT_REF with a TREE_TYPE of the type being queried for offsetof. */ -static tree offsetof_base; - -/* PUSH_DECLSPEC_STACK is called from setspecs; POP_DECLSPEC_STACK - should be called from the productions making use of setspecs. */ -#define PUSH_DECLSPEC_STACK \ - do { \ - struct c_declspec_stack *t = XOBNEW (&parser_obstack, \ - struct c_declspec_stack); \ - t->current_declspecs = current_declspecs; \ - t->prefix_attributes = prefix_attributes; \ - t->all_prefix_attributes = all_prefix_attributes; \ - t->next = declspec_stack; \ - declspec_stack = t; \ - } while (0) - -#define POP_DECLSPEC_STACK \ - do { \ - current_declspecs = declspec_stack->current_declspecs; \ - prefix_attributes = declspec_stack->prefix_attributes; \ - all_prefix_attributes = declspec_stack->all_prefix_attributes; \ - declspec_stack = declspec_stack->next; \ - } while (0) - -/* For __extension__, save/restore the warning flags which are - controlled by __extension__. */ -#define SAVE_EXT_FLAGS() \ - (pedantic \ - | (warn_pointer_arith << 1) \ - | (warn_traditional << 2) \ - | (flag_iso << 3)) - -#define RESTORE_EXT_FLAGS(val) \ - do { \ - pedantic = val & 1; \ - warn_pointer_arith = (val >> 1) & 1; \ - warn_traditional = (val >> 2) & 1; \ - flag_iso = (val >> 3) & 1; \ - } while (0) - - -#define OBJC_NEED_RAW_IDENTIFIER(VAL) /* nothing */ - -/* Tell yyparse how to print a token's value, if yydebug is set. */ - -#define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL) - -static void yyprint (FILE *, int, YYSTYPE); -static void yyerror (const char *); -static int yylexname (void); -static inline int _yylex (void); -static int yylex (void); -static void init_reswords (void); - - /* Initialization routine for this file. */ -void -c_parse_init (void) -{ - init_reswords (); -} - - - -/* Line 213 of yacc.c. */ -#line 390 "c-parse.c" - -#if ! defined (yyoverflow) || YYERROR_VERBOSE - -# ifndef YYFREE -# define YYFREE free -# endif -# ifndef YYMALLOC -# define YYMALLOC malloc -# endif - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# ifdef YYSTACK_USE_ALLOCA -# if YYSTACK_USE_ALLOCA -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# else -# define YYSTACK_ALLOC alloca -# endif -# endif -# endif - -# ifdef YYSTACK_ALLOC - /* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) -# else -# if defined (__STDC__) || defined (__cplusplus) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# endif -# define YYSTACK_ALLOC YYMALLOC -# define YYSTACK_FREE YYFREE -# endif -#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ - - -#if (! defined (yyoverflow) \ - && (! defined (__cplusplus) \ - || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union yyalloc -{ - short int yyss; - YYSTYPE yyvs; - }; - -/* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAXIMUM) - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if defined (__GNUC__) && 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - register YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ - while (0) -# endif -# endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -# define YYSTACK_RELOCATE(Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof (*yyptr); \ - } \ - while (0) - -#endif - -#if defined (__STDC__) || defined (__cplusplus) - typedef signed char yysigned_char; -#else - typedef short int yysigned_char; -#endif - -/* YYFINAL -- State number of the termination state. */ -#define YYFINAL 4 -/* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 3307 - -/* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 95 -/* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 209 -/* YYNRULES -- Number of rules. */ -#define YYNRULES 574 -/* YYNRULES -- Number of states. */ -#define YYNSTATES 933 - -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#define YYUNDEFTOK 2 -#define YYMAXUTOK 327 - -#define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) - -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ -static const unsigned char yytranslate[] = -{ - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 90, 2, 2, 2, 59, 50, 2, - 65, 92, 57, 55, 91, 56, 64, 58, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 45, 87, - 2, 42, 2, 44, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 66, 2, 94, 49, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 93, 48, 88, 89, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 43, 46, 47, - 51, 52, 53, 54, 60, 61, 62, 63, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - 79, 80, 81, 82, 83, 84, 85, 86 -}; - -#if YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const unsigned short int yyprhs[] = -{ - 0, 0, 3, 4, 6, 7, 11, 12, 17, 19, - 21, 23, 26, 27, 31, 36, 41, 44, 47, 50, - 52, 53, 54, 63, 68, 69, 70, 79, 84, 85, - 86, 94, 98, 100, 102, 104, 106, 108, 110, 112, - 114, 116, 118, 122, 123, 125, 127, 131, 133, 136, - 139, 142, 145, 148, 153, 156, 161, 164, 167, 169, - 171, 173, 175, 180, 182, 186, 190, 194, 198, 202, - 206, 210, 214, 218, 222, 226, 230, 231, 236, 237, - 242, 243, 244, 252, 253, 259, 263, 267, 269, 271, - 273, 275, 276, 284, 288, 292, 296, 300, 305, 312, - 313, 321, 326, 335, 340, 347, 352, 357, 361, 365, - 368, 371, 373, 377, 382, 383, 385, 388, 390, 392, - 395, 398, 403, 408, 411, 414, 417, 418, 420, 425, - 430, 434, 438, 441, 444, 446, 449, 452, 455, 458, - 461, 463, 466, 468, 471, 474, 477, 480, 483, 486, - 488, 491, 494, 497, 500, 503, 506, 509, 512, 515, - 518, 521, 524, 527, 530, 533, 536, 538, 541, 544, - 547, 550, 553, 556, 559, 562, 565, 568, 571, 574, - 577, 580, 583, 586, 589, 592, 595, 598, 601, 604, - 607, 610, 613, 616, 619, 622, 625, 628, 631, 634, - 637, 640, 643, 646, 649, 652, 655, 658, 661, 664, - 667, 670, 672, 674, 676, 678, 680, 682, 684, 686, - 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, - 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, - 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, - 748, 750, 752, 754, 756, 758, 760, 762, 764, 766, - 768, 770, 772, 774, 776, 778, 780, 782, 783, 785, - 787, 789, 791, 793, 795, 797, 799, 804, 809, 811, - 816, 818, 823, 824, 831, 835, 836, 843, 847, 848, - 850, 852, 855, 864, 868, 870, 874, 875, 877, 882, - 889, 894, 896, 898, 900, 902, 904, 906, 908, 909, - 914, 916, 917, 920, 922, 926, 930, 933, 934, 939, - 941, 942, 947, 949, 951, 953, 956, 959, 961, 967, - 971, 972, 973, 980, 981, 982, 989, 991, 993, 998, - 1002, 1005, 1009, 1011, 1013, 1015, 1019, 1022, 1024, 1028, - 1031, 1035, 1039, 1044, 1048, 1053, 1057, 1060, 1062, 1064, - 1067, 1069, 1072, 1074, 1077, 1078, 1086, 1092, 1093, 1101, - 1107, 1108, 1117, 1118, 1126, 1129, 1132, 1135, 1136, 1138, - 1139, 1141, 1143, 1146, 1147, 1151, 1154, 1158, 1161, 1165, - 1167, 1169, 1172, 1174, 1179, 1181, 1186, 1189, 1194, 1198, - 1201, 1206, 1210, 1212, 1216, 1218, 1220, 1224, 1225, 1229, - 1230, 1232, 1233, 1235, 1238, 1240, 1242, 1244, 1248, 1251, - 1255, 1260, 1264, 1267, 1270, 1272, 1277, 1281, 1286, 1292, - 1298, 1300, 1302, 1304, 1306, 1308, 1311, 1314, 1317, 1320, - 1322, 1325, 1328, 1331, 1333, 1336, 1339, 1342, 1345, 1347, - 1350, 1352, 1354, 1356, 1358, 1361, 1362, 1363, 1365, 1367, - 1370, 1374, 1376, 1379, 1381, 1383, 1387, 1389, 1391, 1394, - 1397, 1398, 1399, 1402, 1406, 1409, 1412, 1415, 1419, 1423, - 1425, 1435, 1445, 1453, 1461, 1462, 1463, 1473, 1474, 1475, - 1489, 1490, 1492, 1495, 1497, 1500, 1502, 1515, 1516, 1525, - 1528, 1530, 1532, 1534, 1536, 1538, 1541, 1544, 1547, 1551, - 1553, 1557, 1562, 1564, 1566, 1568, 1572, 1578, 1581, 1586, - 1593, 1594, 1596, 1599, 1604, 1613, 1615, 1619, 1625, 1633, - 1634, 1636, 1637, 1639, 1641, 1645, 1652, 1662, 1664, 1668, - 1670, 1671, 1672, 1673, 1677, 1680, 1681, 1682, 1689, 1692, - 1693, 1695, 1697, 1701, 1703, 1707, 1712, 1717, 1721, 1726, - 1730, 1735, 1740, 1744, 1749, 1753, 1755, 1756, 1760, 1762, - 1765, 1767, 1771, 1773, 1777 -}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const short int yyrhs[] = -{ - 96, 0, -1, -1, 97, -1, -1, 101, 98, 100, - -1, -1, 97, 101, 99, 100, -1, 103, -1, 102, - -1, 277, -1, 303, 100, -1, -1, 135, 169, 87, - -1, 155, 135, 169, 87, -1, 154, 135, 168, 87, - -1, 161, 87, -1, 1, 87, -1, 1, 88, -1, - 87, -1, -1, -1, 154, 135, 198, 104, 130, 250, - 105, 244, -1, 154, 135, 198, 1, -1, -1, -1, - 155, 135, 203, 106, 130, 250, 107, 244, -1, 155, - 135, 203, 1, -1, -1, -1, 135, 203, 108, 130, - 250, 109, 244, -1, 135, 203, 1, -1, 3, -1, - 4, -1, 50, -1, 56, -1, 55, -1, 61, -1, - 60, -1, 89, -1, 90, -1, 120, -1, 112, 91, - 120, -1, -1, 114, -1, 120, -1, 114, 91, 120, - -1, 126, -1, 57, 119, -1, 303, 119, -1, 111, - 119, -1, 47, 110, -1, 116, 115, -1, 116, 65, - 224, 92, -1, 117, 115, -1, 117, 65, 224, 92, - -1, 35, 119, -1, 36, 119, -1, 13, -1, 31, - -1, 30, -1, 115, -1, 65, 224, 92, 119, -1, - 119, -1, 120, 55, 120, -1, 120, 56, 120, -1, - 120, 57, 120, -1, 120, 58, 120, -1, 120, 59, - 120, -1, 120, 54, 120, -1, 120, 53, 120, -1, - 120, 52, 120, -1, 120, 51, 120, -1, 120, 50, - 120, -1, 120, 48, 120, -1, 120, 49, 120, -1, - -1, 120, 47, 121, 120, -1, -1, 120, 46, 122, - 120, -1, -1, -1, 120, 44, 123, 112, 45, 124, - 120, -1, -1, 120, 44, 125, 45, 120, -1, 120, - 42, 120, -1, 120, 43, 120, -1, 3, -1, 10, - -1, 11, -1, 40, -1, -1, 65, 224, 92, 93, - 127, 183, 88, -1, 65, 112, 92, -1, 65, 1, - 92, -1, 248, 246, 92, -1, 248, 1, 92, -1, - 126, 65, 113, 92, -1, 37, 65, 120, 91, 224, - 92, -1, -1, 41, 65, 224, 91, 128, 129, 92, - -1, 41, 65, 1, 92, -1, 38, 65, 120, 91, - 120, 91, 120, 92, -1, 38, 65, 1, 92, -1, - 39, 65, 224, 91, 224, 92, -1, 39, 65, 1, - 92, -1, 126, 66, 112, 94, -1, 126, 64, 110, - -1, 126, 67, 110, -1, 126, 61, -1, 126, 60, - -1, 110, -1, 129, 64, 110, -1, 129, 66, 112, - 94, -1, -1, 132, -1, 250, 133, -1, 131, -1, - 239, -1, 132, 131, -1, 131, 239, -1, 156, 135, - 168, 87, -1, 157, 135, 169, 87, -1, 156, 87, - -1, 157, 87, -1, 250, 137, -1, -1, 174, -1, - 154, 135, 168, 87, -1, 155, 135, 169, 87, -1, - 154, 135, 192, -1, 155, 135, 195, -1, 161, 87, - -1, 303, 137, -1, 8, -1, 138, 8, -1, 139, - 8, -1, 138, 175, -1, 140, 8, -1, 141, 8, - -1, 175, -1, 140, 175, -1, 163, -1, 142, 8, - -1, 143, 8, -1, 142, 165, -1, 143, 165, -1, - 138, 163, -1, 139, 163, -1, 164, -1, 142, 175, - -1, 142, 166, -1, 143, 166, -1, 138, 164, -1, - 139, 164, -1, 144, 8, -1, 145, 8, -1, 144, - 165, -1, 145, 165, -1, 140, 163, -1, 141, 163, - -1, 144, 175, -1, 144, 166, -1, 145, 166, -1, - 140, 164, -1, 141, 164, -1, 180, -1, 146, 8, - -1, 147, 8, -1, 138, 180, -1, 139, 180, -1, - 146, 180, -1, 147, 180, -1, 146, 175, -1, 148, - 8, -1, 149, 8, -1, 140, 180, -1, 141, 180, - -1, 148, 180, -1, 149, 180, -1, 148, 175, -1, - 150, 8, -1, 151, 8, -1, 150, 165, -1, 151, - 165, -1, 146, 163, -1, 147, 163, -1, 142, 180, - -1, 143, 180, -1, 150, 180, -1, 151, 180, -1, - 150, 175, -1, 150, 166, -1, 151, 166, -1, 146, - 164, -1, 147, 164, -1, 152, 8, -1, 153, 8, - -1, 152, 165, -1, 153, 165, -1, 148, 163, -1, - 149, 163, -1, 144, 180, -1, 145, 180, -1, 152, - 180, -1, 153, 180, -1, 152, 175, -1, 152, 166, - -1, 153, 166, -1, 148, 164, -1, 149, 164, -1, - 142, -1, 143, -1, 144, -1, 145, -1, 150, -1, - 151, -1, 152, -1, 153, -1, 138, -1, 139, -1, - 140, -1, 141, -1, 146, -1, 147, -1, 148, -1, - 149, -1, 142, -1, 143, -1, 150, -1, 151, -1, - 138, -1, 139, -1, 146, -1, 147, -1, 142, -1, - 143, -1, 144, -1, 145, -1, 138, -1, 139, -1, - 140, -1, 141, -1, 142, -1, 143, -1, 144, -1, - 145, -1, 138, -1, 139, -1, 140, -1, 141, -1, - 138, -1, 139, -1, 140, -1, 141, -1, 142, -1, - 143, -1, 144, -1, 145, -1, 146, -1, 147, -1, - 148, -1, 149, -1, 150, -1, 151, -1, 152, -1, - 153, -1, -1, 159, -1, 165, -1, 167, -1, 166, - -1, 7, -1, 212, -1, 207, -1, 4, -1, 118, - 65, 112, 92, -1, 118, 65, 224, 92, -1, 170, - -1, 168, 91, 136, 170, -1, 172, -1, 169, 91, - 136, 172, -1, -1, 198, 276, 174, 42, 171, 181, - -1, 198, 276, 174, -1, -1, 203, 276, 174, 42, - 173, 181, -1, 203, 276, 174, -1, -1, 175, -1, - 176, -1, 175, 176, -1, 32, 286, 65, 65, 177, - 92, 92, 287, -1, 32, 1, 287, -1, 178, -1, - 177, 91, 178, -1, -1, 179, -1, 179, 65, 3, - 92, -1, 179, 65, 3, 91, 114, 92, -1, 179, - 65, 113, 92, -1, 110, -1, 180, -1, 7, -1, - 8, -1, 6, -1, 5, -1, 120, -1, -1, 93, - 182, 183, 88, -1, 1, -1, -1, 184, 213, -1, - 185, -1, 184, 91, 185, -1, 189, 42, 187, -1, - 191, 187, -1, -1, 110, 45, 186, 187, -1, 187, - -1, -1, 93, 188, 183, 88, -1, 120, -1, 1, - -1, 190, -1, 189, 190, -1, 64, 110, -1, 191, - -1, 66, 120, 12, 120, 94, -1, 66, 120, 94, - -1, -1, -1, 198, 193, 130, 250, 194, 249, -1, - -1, -1, 203, 196, 130, 250, 197, 249, -1, 199, - -1, 203, -1, 65, 174, 199, 92, -1, 199, 65, - 298, -1, 199, 232, -1, 57, 162, 199, -1, 4, - -1, 201, -1, 202, -1, 201, 65, 298, -1, 201, - 232, -1, 4, -1, 202, 65, 298, -1, 202, 232, - -1, 57, 162, 201, -1, 57, 162, 202, -1, 65, - 174, 202, 92, -1, 203, 65, 298, -1, 65, 174, - 203, 92, -1, 57, 162, 203, -1, 203, 232, -1, - 3, -1, 15, -1, 15, 175, -1, 16, -1, 16, - 175, -1, 14, -1, 14, 175, -1, -1, 204, 110, - 93, 208, 215, 88, 174, -1, 204, 93, 215, 88, - 174, -1, -1, 205, 110, 93, 209, 215, 88, 174, - -1, 205, 93, 215, 88, 174, -1, -1, 206, 110, - 93, 210, 222, 214, 88, 174, -1, -1, 206, 93, - 211, 222, 214, 88, 174, -1, 204, 110, -1, 205, - 110, -1, 206, 110, -1, -1, 91, -1, -1, 91, - -1, 216, -1, 216, 217, -1, -1, 216, 217, 87, - -1, 216, 87, -1, 158, 135, 218, -1, 158, 135, - -1, 159, 135, 219, -1, 159, -1, 1, -1, 303, - 217, -1, 220, -1, 218, 91, 136, 220, -1, 221, - -1, 219, 91, 136, 221, -1, 198, 174, -1, 198, - 45, 120, 174, -1, 45, 120, 174, -1, 203, 174, - -1, 203, 45, 120, 174, -1, 45, 120, 174, -1, - 223, -1, 222, 91, 223, -1, 1, -1, 110, -1, - 110, 42, 120, -1, -1, 160, 225, 226, -1, -1, - 228, -1, -1, 228, -1, 229, 175, -1, 230, -1, - 229, -1, 231, -1, 57, 162, 229, -1, 57, 162, - -1, 57, 162, 230, -1, 65, 174, 228, 92, -1, - 231, 65, 288, -1, 231, 232, -1, 65, 288, -1, - 232, -1, 66, 162, 120, 94, -1, 66, 162, 94, - -1, 66, 162, 57, 94, -1, 66, 6, 162, 120, - 94, -1, 66, 159, 6, 120, 94, -1, 234, -1, - 235, -1, 236, -1, 237, -1, 253, -1, 234, 253, - -1, 235, 253, -1, 236, 253, -1, 237, 253, -1, - 134, -1, 234, 134, -1, 235, 134, -1, 237, 134, - -1, 254, -1, 234, 254, -1, 235, 254, -1, 236, - 254, -1, 237, 254, -1, 239, -1, 238, 239, -1, - 234, -1, 235, -1, 236, -1, 237, -1, 1, 87, - -1, -1, -1, 242, -1, 243, -1, 242, 243, -1, - 34, 302, 87, -1, 249, -1, 1, 249, -1, 93, - -1, 88, -1, 241, 247, 88, -1, 233, -1, 1, - -1, 65, 93, -1, 245, 246, -1, -1, -1, 251, - 254, -1, 240, 251, 253, -1, 250, 273, -1, 250, - 274, -1, 250, 112, -1, 240, 251, 258, -1, 240, - 251, 87, -1, 252, -1, 17, 240, 250, 65, 255, - 92, 256, 18, 257, -1, 17, 240, 250, 65, 255, - 92, 257, 18, 257, -1, 17, 240, 250, 65, 255, - 92, 256, -1, 17, 240, 250, 65, 255, 92, 257, - -1, -1, -1, 19, 240, 250, 65, 255, 92, 259, - 260, 252, -1, -1, -1, 20, 240, 250, 259, 260, - 252, 19, 263, 264, 65, 255, 92, 87, -1, -1, - 112, -1, 265, 87, -1, 137, -1, 250, 265, -1, - 265, -1, 21, 240, 65, 266, 250, 267, 87, 268, - 92, 259, 260, 252, -1, -1, 22, 240, 65, 112, - 92, 271, 259, 252, -1, 112, 87, -1, 258, -1, - 261, -1, 262, -1, 269, -1, 270, -1, 25, 87, - -1, 26, 87, -1, 27, 87, -1, 27, 112, 87, - -1, 278, -1, 28, 110, 87, -1, 28, 57, 112, - 87, -1, 87, -1, 249, -1, 272, -1, 23, 120, - 45, -1, 23, 120, 12, 120, 45, -1, 24, 45, - -1, 110, 250, 45, 174, -1, 29, 286, 65, 285, - 92, 287, -1, -1, 275, -1, 275, 87, -1, 29, - 1, 287, 87, -1, 29, 280, 286, 65, 279, 92, - 287, 87, -1, 285, -1, 285, 45, 281, -1, 285, - 45, 281, 45, 281, -1, 285, 45, 281, 45, 281, - 45, 284, -1, -1, 8, -1, -1, 282, -1, 283, - -1, 282, 91, 283, -1, 285, 287, 65, 112, 92, - 286, -1, 66, 110, 94, 285, 287, 65, 112, 92, - 286, -1, 285, -1, 284, 91, 285, -1, 11, -1, - -1, -1, -1, 174, 289, 290, -1, 293, 92, -1, - -1, -1, 294, 87, 291, 174, 292, 290, -1, 1, - 92, -1, -1, 12, -1, 294, -1, 294, 91, 12, - -1, 296, -1, 294, 91, 295, -1, 154, 135, 200, - 174, -1, 154, 135, 203, 174, -1, 154, 135, 227, - -1, 155, 135, 203, 174, -1, 155, 135, 227, -1, - 156, 297, 200, 174, -1, 156, 297, 203, 174, -1, - 156, 297, 227, -1, 157, 297, 203, 174, -1, 157, - 297, 227, -1, 135, -1, -1, 174, 299, 300, -1, - 290, -1, 301, 92, -1, 3, -1, 301, 91, 3, - -1, 110, -1, 302, 91, 110, -1, 33, -1 -}; - -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const unsigned short int yyrline[] = -{ - 0, 342, 342, 345, 353, 353, 356, 355, 361, 362, - 363, 364, 371, 375, 378, 380, 382, 384, 385, 386, - 393, 398, 392, 403, 406, 411, 405, 416, 419, 424, - 418, 429, 434, 435, 438, 440, 442, 447, 449, 451, - 453, 457, 458, 465, 466, 470, 472, 477, 478, 482, - 485, 490, 493, 500, 504, 509, 514, 517, 523, 527, - 531, 535, 536, 542, 543, 545, 547, 549, 551, 553, - 555, 557, 559, 561, 563, 565, 568, 567, 575, 574, - 582, 586, 581, 594, 593, 605, 609, 617, 624, 626, - 628, 632, 631, 652, 657, 659, 665, 670, 673, 678, - 677, 687, 689, 701, 703, 715, 717, 720, 723, 729, - 732, 742, 744, 746, 750, 752, 759, 764, 765, 766, - 767, 775, 777, 779, 782, 791, 800, 820, 825, 827, - 829, 831, 833, 835, 881, 883, 885, 890, 895, 897, - 902, 904, 909, 911, 913, 915, 917, 919, 921, 926, - 928, 930, 932, 934, 936, 941, 943, 945, 947, 949, - 951, 956, 958, 960, 962, 964, 969, 971, 973, 975, - 977, 979, 981, 986, 991, 993, 995, 997, 999, 1001, - 1006, 1011, 1013, 1015, 1017, 1019, 1021, 1023, 1025, 1027, - 1029, 1034, 1036, 1038, 1040, 1042, 1047, 1049, 1051, 1053, - 1055, 1057, 1059, 1061, 1063, 1065, 1070, 1072, 1074, 1076, - 1078, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1095, - 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1106, 1107, 1108, - 1109, 1113, 1114, 1115, 1116, 1120, 1121, 1122, 1123, 1127, - 1128, 1129, 1130, 1134, 1135, 1136, 1137, 1138, 1139, 1140, - 1141, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, - 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1166, 1167, 1193, - 1194, 1198, 1202, 1206, 1210, 1214, 1219, 1229, 1241, 1242, - 1246, 1247, 1252, 1251, 1266, 1276, 1275, 1290, 1300, 1301, - 1306, 1308, 1313, 1316, 1321, 1323, 1329, 1330, 1332, 1334, - 1336, 1344, 1345, 1346, 1347, 1351, 1352, 1358, 1361, 1360, - 1364, 1371, 1373, 1377, 1378, 1384, 1387, 1391, 1390, 1396, - 1401, 1400, 1404, 1406, 1410, 1411, 1415, 1417, 1421, 1425, - 1431, 1443, 1430, 1461, 1473, 1460, 1493, 1494, 1500, 1502, - 1504, 1506, 1508, 1517, 1518, 1522, 1524, 1526, 1531, 1533, - 1535, 1537, 1539, 1547, 1549, 1551, 1553, 1555, 1560, 1562, - 1567, 1569, 1574, 1576, 1588, 1587, 1595, 1602, 1601, 1607, - 1614, 1613, 1620, 1619, 1628, 1630, 1632, 1640, 1642, 1645, - 1647, 1665, 1667, 1673, 1674, 1676, 1682, 1685, 1693, 1696, - 1701, 1703, 1709, 1710, 1715, 1716, 1721, 1725, 1729, 1737, - 1741, 1745, 1756, 1757, 1762, 1768, 1770, 1776, 1775, 1786, - 1787, 1792, 1794, 1797, 1804, 1805, 1809, 1810, 1815, 1818, - 1823, 1825, 1827, 1829, 1832, 1840, 1842, 1844, 1846, 1849, - 1860, 1861, 1862, 1866, 1870, 1871, 1872, 1873, 1874, 1878, - 1879, 1885, 1886, 1890, 1891, 1892, 1893, 1894, 1898, 1899, - 1903, 1904, 1905, 1906, 1909, 1914, 1919, 1921, 1927, 1928, - 1932, 1946, 1948, 1951, 1954, 1955, 1959, 1960, 1964, 1975, - 1984, 1989, 1991, 1996, 2001, 2019, 2023, 2036, 2041, 2045, - 2049, 2053, 2057, 2061, 2068, 2072, 2076, 2087, 2088, 2085, - 2097, 2098, 2103, 2105, 2109, 2121, 2126, 2137, 2136, 2149, - 2151, 2153, 2155, 2157, 2159, 2161, 2163, 2165, 2167, 2169, - 2170, 2172, 2174, 2180, 2182, 2189, 2191, 2193, 2195, 2212, - 2220, 2221, 2226, 2228, 2235, 2242, 2245, 2248, 2251, 2259, - 2260, 2274, 2275, 2279, 2280, 2285, 2289, 2297, 2299, 2305, - 2317, 2321, 2332, 2331, 2340, 2342, 2344, 2341, 2348, 2359, - 2364, 2373, 2375, 2380, 2382, 2389, 2393, 2397, 2400, 2405, - 2413, 2417, 2421, 2424, 2429, 2435, 2445, 2444, 2453, 2454, - 2469, 2471, 2477, 2479, 2484 -}; -#endif - -#if YYDEBUG || YYERROR_VERBOSE -/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - First, the terminals, then, starting at YYNTOKENS, nonterminals. */ -static const char *const yytname[] = -{ - "$end", "error", "$undefined", "IDENTIFIER", "TYPENAME", "SCSPEC", - "STATIC", "TYPESPEC", "TYPE_QUAL", "OBJC_TYPE_QUAL", "CONSTANT", - "STRING", "ELLIPSIS", "SIZEOF", "ENUM", "STRUCT", "UNION", "IF", "ELSE", - "WHILE", "DO", "FOR", "SWITCH", "CASE", "DEFAULT", "BREAK", "CONTINUE", - "RETURN", "GOTO", "ASM_KEYWORD", "TYPEOF", "ALIGNOF", "ATTRIBUTE", - "EXTENSION", "LABEL", "REALPART", "IMAGPART", "VA_ARG", "CHOOSE_EXPR", - "TYPES_COMPATIBLE_P", "FUNC_NAME", "OFFSETOF", "'='", "ASSIGN", "'?'", - "':'", "OROR", "ANDAND", "'|'", "'^'", "'&'", "EQCOMPARE", - "ARITHCOMPARE", "RSHIFT", "LSHIFT", "'+'", "'-'", "'*'", "'/'", "'%'", - "MINUSMINUS", "PLUSPLUS", "UNARY", "HYPERUNARY", "'.'", "'('", "'['", - "POINTSAT", "AT_INTERFACE", "AT_IMPLEMENTATION", "AT_END", "AT_SELECTOR", - "AT_DEFS", "AT_ENCODE", "CLASSNAME", "AT_PUBLIC", "AT_PRIVATE", - "AT_PROTECTED", "AT_PROTOCOL", "AT_CLASS", "AT_ALIAS", "AT_THROW", - "AT_TRY", "AT_CATCH", "AT_FINALLY", "AT_SYNCHRONIZED", "OBJC_STRING", - "';'", "'}'", "'~'", "'!'", "','", "')'", "'{'", "']'", "$accept", - "program", "extdefs", "@1", "@2", "extdef", "save_obstack_position", - "datadef", "fndef", "@3", "@4", "@5", "@6", "@7", "@8", "identifier", - "unop", "expr", "exprlist", "nonnull_exprlist", "unary_expr", "sizeof", - "alignof", "typeof", "cast_expr", "expr_no_commas", "@9", "@10", "@11", - "@12", "@13", "primary", "@14", "@15", "offsetof_member_designator", - "old_style_parm_decls", "lineno_datadecl", "datadecls", "datadecl", - "lineno_decl", "setspecs", "maybe_resetattrs", "decl", - "declspecs_nosc_nots_nosa_noea", "declspecs_nosc_nots_nosa_ea", - "declspecs_nosc_nots_sa_noea", "declspecs_nosc_nots_sa_ea", - "declspecs_nosc_ts_nosa_noea", "declspecs_nosc_ts_nosa_ea", - "declspecs_nosc_ts_sa_noea", "declspecs_nosc_ts_sa_ea", - "declspecs_sc_nots_nosa_noea", "declspecs_sc_nots_nosa_ea", - "declspecs_sc_nots_sa_noea", "declspecs_sc_nots_sa_ea", - "declspecs_sc_ts_nosa_noea", "declspecs_sc_ts_nosa_ea", - "declspecs_sc_ts_sa_noea", "declspecs_sc_ts_sa_ea", "declspecs_ts", - "declspecs_nots", "declspecs_ts_nosa", "declspecs_nots_nosa", - "declspecs_nosc_ts", "declspecs_nosc_nots", "declspecs_nosc", - "declspecs", "maybe_type_quals_attrs", "typespec_nonattr", - "typespec_attr", "typespec_reserved_nonattr", "typespec_reserved_attr", - "typespec_nonreserved_nonattr", "initdecls", "notype_initdecls", - "initdcl", "@16", "notype_initdcl", "@17", "maybe_attribute", - "attributes", "attribute", "attribute_list", "attrib", "any_word", - "scspec", "init", "@18", "initlist_maybe_comma", "initlist1", "initelt", - "@19", "initval", "@20", "designator_list", "designator", - "array_designator", "nested_function", "@21", "@22", - "notype_nested_function", "@23", "@24", "declarator", - "after_type_declarator", "parm_declarator", - "parm_declarator_starttypename", "parm_declarator_nostarttypename", - "notype_declarator", "struct_head", "union_head", "enum_head", - "structsp_attr", "@25", "@26", "@27", "@28", "structsp_nonattr", - "maybecomma", "maybecomma_warn", "component_decl_list", - "component_decl_list2", "component_decl", "components", - "components_notype", "component_declarator", - "component_notype_declarator", "enumlist", "enumerator", "typename", - "@29", "absdcl", "absdcl_maybe_attribute", "absdcl1", "absdcl1_noea", - "absdcl1_ea", "direct_absdcl1", "array_declarator", "stmts_and_decls", - "lineno_stmt_decl_or_labels_ending_stmt", - "lineno_stmt_decl_or_labels_ending_decl", - "lineno_stmt_decl_or_labels_ending_label", - "lineno_stmt_decl_or_labels_ending_error", "lineno_stmt_decl_or_labels", - "errstmt", "c99_block_start", "maybe_label_decls", "label_decls", - "label_decl", "compstmt_or_error", "compstmt_start", "compstmt_nostart", - "compstmt_contents_nonempty", "compstmt_primary_start", "compstmt", - "save_location", "lineno_labels", "c99_block_lineno_labeled_stmt", - "lineno_stmt", "lineno_label", "condition", "if_statement_1", - "if_statement_2", "if_statement", "start_break", "start_continue", - "while_statement", "do_statement", "@30", "@31", "xexpr", - "for_init_stmt", "for_cond_expr", "for_incr_expr", "for_statement", - "switch_statement", "@32", "stmt_nocomp", "stmt", "label", - "simple_asm_expr", "maybeasm", "asmdef", "asm_stmt", "asm_argument", - "maybe_volatile", "asm_operands", "nonnull_asm_operands", "asm_operand", - "asm_clobbers", "asm_string", "stop_string_translation", - "start_string_translation", "parmlist", "@33", "parmlist_1", "@34", - "@35", "parmlist_2", "parms", "parm", "firstparm", "setspecs_fp", - "parmlist_or_identifiers", "@36", "parmlist_or_identifiers_1", - "identifiers", "identifiers_or_typenames", "extension", 0 -}; -#endif - -# ifdef YYPRINT -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ -static const unsigned short int yytoknum[] = -{ - 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 61, 297, 63, 58, 298, 299, 124, 94, - 38, 300, 301, 302, 303, 43, 45, 42, 47, 37, - 304, 305, 306, 307, 46, 40, 91, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 59, 125, 126, - 33, 44, 41, 123, 93 -}; -# endif - -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const unsigned short int yyr1[] = -{ - 0, 95, 96, 96, 98, 97, 99, 97, 100, 100, - 100, 100, 101, 102, 102, 102, 102, 102, 102, 102, - 104, 105, 103, 103, 106, 107, 103, 103, 108, 109, - 103, 103, 110, 110, 111, 111, 111, 111, 111, 111, - 111, 112, 112, 113, 113, 114, 114, 115, 115, 115, - 115, 115, 115, 115, 115, 115, 115, 115, 116, 117, - 118, 119, 119, 120, 120, 120, 120, 120, 120, 120, - 120, 120, 120, 120, 120, 120, 121, 120, 122, 120, - 123, 124, 120, 125, 120, 120, 120, 126, 126, 126, - 126, 127, 126, 126, 126, 126, 126, 126, 126, 128, - 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, - 126, 129, 129, 129, 130, 130, 131, 132, 132, 132, - 132, 133, 133, 133, 133, 134, 135, 136, 137, 137, - 137, 137, 137, 137, 138, 138, 138, 139, 140, 140, - 141, 141, 142, 142, 142, 142, 142, 142, 142, 143, - 143, 143, 143, 143, 143, 144, 144, 144, 144, 144, - 144, 145, 145, 145, 145, 145, 146, 146, 146, 146, - 146, 146, 146, 147, 148, 148, 148, 148, 148, 148, - 149, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 151, 151, 151, 151, 151, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 153, 153, 153, 153, - 153, 154, 154, 154, 154, 154, 154, 154, 154, 155, - 155, 155, 155, 155, 155, 155, 155, 156, 156, 156, - 156, 157, 157, 157, 157, 158, 158, 158, 158, 159, - 159, 159, 159, 160, 160, 160, 160, 160, 160, 160, - 160, 161, 161, 161, 161, 161, 161, 161, 161, 161, - 161, 161, 161, 161, 161, 161, 161, 162, 162, 163, - 163, 164, 165, 165, 166, 167, 167, 167, 168, 168, - 169, 169, 171, 170, 170, 173, 172, 172, 174, 174, - 175, 175, 176, 176, 177, 177, 178, 178, 178, 178, - 178, 179, 179, 179, 179, 180, 180, 181, 182, 181, - 181, 183, 183, 184, 184, 185, 185, 186, 185, 185, - 188, 187, 187, 187, 189, 189, 190, 190, 191, 191, - 193, 194, 192, 196, 197, 195, 198, 198, 199, 199, - 199, 199, 199, 200, 200, 201, 201, 201, 202, 202, - 202, 202, 202, 203, 203, 203, 203, 203, 204, 204, - 205, 205, 206, 206, 208, 207, 207, 209, 207, 207, - 210, 207, 211, 207, 212, 212, 212, 213, 213, 214, - 214, 215, 215, 216, 216, 216, 217, 217, 217, 217, - 217, 217, 218, 218, 219, 219, 220, 220, 220, 221, - 221, 221, 222, 222, 222, 223, 223, 225, 224, 226, - 226, 227, 227, 227, 228, 228, 229, 229, 230, 230, - 231, 231, 231, 231, 231, 232, 232, 232, 232, 232, - 233, 233, 233, 233, 234, 234, 234, 234, 234, 235, - 235, 235, 235, 236, 236, 236, 236, 236, 237, 237, - 238, 238, 238, 238, 239, 240, 241, 241, 242, 242, - 243, 244, 244, 245, 246, 246, 247, 247, 248, 249, - 250, 251, 251, 252, 253, 254, 255, 256, 257, 257, - 258, 258, 258, 258, 259, 260, 261, 263, 264, 262, - 265, 265, 266, 266, 267, 268, 269, 271, 270, 272, - 272, 272, 272, 272, 272, 272, 272, 272, 272, 272, - 272, 272, 272, 273, 273, 274, 274, 274, 274, 275, - 276, 276, 277, 277, 278, 279, 279, 279, 279, 280, - 280, 281, 281, 282, 282, 283, 283, 284, 284, 285, - 286, 287, 289, 288, 290, 291, 292, 290, 290, 293, - 293, 293, 293, 294, 294, 295, 295, 295, 295, 295, - 296, 296, 296, 296, 296, 297, 299, 298, 300, 300, - 301, 301, 302, 302, 303 -}; - -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const unsigned char yyr2[] = -{ - 0, 2, 0, 1, 0, 3, 0, 4, 1, 1, - 1, 2, 0, 3, 4, 4, 2, 2, 2, 1, - 0, 0, 8, 4, 0, 0, 8, 4, 0, 0, - 7, 3, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 3, 0, 1, 1, 3, 1, 2, 2, - 2, 2, 2, 4, 2, 4, 2, 2, 1, 1, - 1, 1, 4, 1, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 0, 4, 0, 4, - 0, 0, 7, 0, 5, 3, 3, 1, 1, 1, - 1, 0, 7, 3, 3, 3, 3, 4, 6, 0, - 7, 4, 8, 4, 6, 4, 4, 3, 3, 2, - 2, 1, 3, 4, 0, 1, 2, 1, 1, 2, - 2, 4, 4, 2, 2, 2, 0, 1, 4, 4, - 3, 3, 2, 2, 1, 2, 2, 2, 2, 2, - 1, 2, 1, 2, 2, 2, 2, 2, 2, 1, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, - 1, 1, 1, 1, 1, 1, 4, 4, 1, 4, - 1, 4, 0, 6, 3, 0, 6, 3, 0, 1, - 1, 2, 8, 3, 1, 3, 0, 1, 4, 6, - 4, 1, 1, 1, 1, 1, 1, 1, 0, 4, - 1, 0, 2, 1, 3, 3, 2, 0, 4, 1, - 0, 4, 1, 1, 1, 2, 2, 1, 5, 3, - 0, 0, 6, 0, 0, 6, 1, 1, 4, 3, - 2, 3, 1, 1, 1, 3, 2, 1, 3, 2, - 3, 3, 4, 3, 4, 3, 2, 1, 1, 2, - 1, 2, 1, 2, 0, 7, 5, 0, 7, 5, - 0, 8, 0, 7, 2, 2, 2, 0, 1, 0, - 1, 1, 2, 0, 3, 2, 3, 2, 3, 1, - 1, 2, 1, 4, 1, 4, 2, 4, 3, 2, - 4, 3, 1, 3, 1, 1, 3, 0, 3, 0, - 1, 0, 1, 2, 1, 1, 1, 3, 2, 3, - 4, 3, 2, 2, 1, 4, 3, 4, 5, 5, - 1, 1, 1, 1, 1, 2, 2, 2, 2, 1, - 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, - 1, 1, 1, 1, 2, 0, 0, 1, 1, 2, - 3, 1, 2, 1, 1, 3, 1, 1, 2, 2, - 0, 0, 2, 3, 2, 2, 2, 3, 3, 1, - 9, 9, 7, 7, 0, 0, 9, 0, 0, 13, - 0, 1, 2, 1, 2, 1, 12, 0, 8, 2, - 1, 1, 1, 1, 1, 2, 2, 2, 3, 1, - 3, 4, 1, 1, 1, 3, 5, 2, 4, 6, - 0, 1, 2, 4, 8, 1, 3, 5, 7, 0, - 1, 0, 1, 1, 3, 6, 9, 1, 3, 1, - 0, 0, 0, 3, 2, 0, 0, 6, 2, 0, - 1, 1, 3, 1, 3, 4, 4, 3, 4, 3, - 4, 4, 3, 4, 3, 1, 0, 3, 1, 2, - 1, 3, 1, 3, 1 -}; - -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero - means the default is an error. */ -static const unsigned short int yydefact[] = -{ - 12, 0, 12, 4, 1, 6, 0, 0, 0, 275, - 306, 305, 272, 134, 362, 358, 360, 0, 60, 0, - 574, 19, 5, 9, 8, 0, 0, 219, 220, 221, - 222, 211, 212, 213, 214, 223, 224, 225, 226, 215, - 216, 217, 218, 126, 126, 0, 142, 149, 269, 271, - 270, 140, 290, 166, 0, 0, 0, 274, 273, 0, - 10, 0, 7, 17, 18, 363, 359, 361, 541, 0, - 541, 0, 0, 357, 267, 288, 0, 280, 0, 135, - 147, 153, 137, 169, 136, 148, 154, 170, 138, 159, - 164, 141, 176, 139, 160, 165, 177, 143, 145, 151, - 150, 187, 144, 146, 152, 188, 155, 157, 162, 161, - 202, 156, 158, 163, 203, 167, 185, 194, 173, 171, - 168, 186, 195, 172, 174, 200, 209, 180, 178, 175, - 201, 210, 179, 181, 183, 192, 191, 189, 182, 184, - 193, 190, 196, 198, 207, 206, 204, 197, 199, 208, - 205, 0, 0, 16, 291, 32, 33, 383, 374, 383, - 375, 372, 376, 522, 11, 0, 0, 293, 0, 87, - 88, 89, 58, 59, 0, 0, 0, 0, 0, 90, - 0, 0, 34, 36, 35, 0, 38, 37, 0, 39, - 40, 0, 0, 61, 0, 0, 63, 41, 47, 247, - 248, 249, 250, 243, 244, 245, 246, 407, 0, 0, - 0, 239, 240, 241, 242, 268, 0, 0, 289, 13, - 288, 31, 540, 288, 267, 0, 356, 521, 288, 342, - 267, 288, 0, 278, 0, 336, 337, 0, 0, 0, - 0, 364, 0, 367, 0, 370, 523, 539, 0, 296, - 56, 57, 0, 0, 0, 0, 51, 48, 0, 468, - 0, 0, 50, 0, 276, 0, 52, 0, 54, 0, - 0, 80, 78, 76, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 110, 109, 0, 43, - 0, 0, 409, 277, 0, 0, 464, 0, 457, 458, - 0, 49, 355, 0, 0, 127, 566, 353, 267, 268, - 0, 0, 470, 0, 470, 118, 0, 287, 0, 0, - 15, 288, 23, 0, 288, 288, 340, 14, 27, 0, - 288, 390, 385, 239, 240, 241, 242, 235, 236, 237, - 238, 126, 126, 382, 0, 383, 288, 383, 404, 405, - 379, 402, 0, 541, 303, 304, 301, 0, 294, 297, - 302, 0, 0, 0, 0, 0, 0, 0, 94, 93, - 0, 42, 0, 0, 85, 86, 0, 0, 0, 0, - 74, 75, 73, 72, 71, 70, 69, 64, 65, 66, - 67, 68, 107, 0, 44, 45, 0, 108, 267, 288, - 408, 410, 415, 414, 416, 424, 96, 572, 0, 467, - 439, 466, 470, 470, 470, 470, 0, 448, 0, 0, - 434, 443, 459, 95, 354, 281, 520, 0, 0, 0, - 0, 426, 0, 454, 29, 120, 119, 116, 231, 232, - 227, 228, 233, 234, 229, 230, 126, 126, 285, 341, - 0, 0, 470, 284, 339, 470, 366, 387, 0, 384, - 391, 0, 369, 0, 0, 380, 0, 379, 519, 296, - 0, 43, 0, 103, 0, 105, 0, 101, 99, 91, - 62, 53, 55, 0, 0, 79, 77, 97, 0, 106, - 418, 542, 423, 288, 422, 460, 0, 440, 435, 444, - 441, 436, 445, 0, 437, 446, 442, 438, 447, 449, - 465, 87, 275, 455, 455, 455, 455, 455, 0, 0, - 0, 0, 0, 0, 529, 512, 463, 470, 0, 125, - 126, 126, 0, 456, 513, 500, 501, 502, 503, 504, - 514, 474, 475, 509, 0, 0, 570, 550, 126, 126, - 568, 0, 551, 553, 567, 0, 0, 0, 427, 425, - 0, 123, 0, 124, 0, 0, 338, 279, 520, 21, - 282, 25, 0, 288, 386, 392, 0, 288, 388, 394, - 288, 288, 406, 403, 288, 0, 295, 541, 87, 0, - 0, 0, 0, 0, 0, 81, 84, 46, 417, 419, - 0, 0, 542, 421, 573, 470, 470, 470, 0, 0, - 0, 517, 505, 506, 507, 0, 0, 0, 530, 540, - 0, 499, 0, 0, 132, 469, 133, 548, 565, 411, - 411, 544, 545, 0, 0, 569, 428, 429, 0, 30, - 461, 0, 0, 310, 308, 307, 286, 0, 0, 0, - 288, 0, 396, 288, 288, 0, 399, 288, 365, 368, - 373, 288, 292, 0, 298, 300, 98, 0, 104, 111, - 0, 323, 0, 0, 320, 0, 322, 0, 377, 313, - 319, 0, 324, 0, 0, 420, 543, 0, 0, 484, - 490, 0, 0, 515, 508, 0, 510, 0, 288, 0, - 130, 330, 0, 131, 333, 347, 267, 288, 288, 343, - 344, 288, 562, 412, 415, 267, 288, 288, 564, 288, - 552, 219, 220, 221, 222, 211, 212, 213, 214, 223, - 224, 225, 226, 215, 216, 217, 218, 126, 126, 554, - 571, 462, 121, 122, 0, 22, 283, 26, 398, 288, - 0, 401, 288, 0, 371, 0, 0, 0, 0, 100, - 326, 0, 0, 317, 92, 0, 312, 0, 325, 327, - 316, 82, 470, 470, 485, 491, 493, 0, 470, 0, - 0, 511, 0, 518, 128, 0, 129, 0, 418, 542, - 560, 288, 346, 288, 349, 561, 413, 418, 542, 563, - 546, 411, 411, 0, 397, 393, 400, 395, 299, 102, - 112, 0, 0, 329, 0, 0, 314, 315, 0, 0, - 0, 455, 492, 470, 497, 516, 0, 525, 470, 470, - 350, 351, 0, 345, 348, 0, 288, 288, 557, 288, - 559, 309, 113, 0, 321, 318, 476, 455, 484, 471, - 0, 490, 0, 484, 541, 531, 331, 334, 352, 547, - 555, 556, 558, 328, 471, 479, 482, 483, 485, 470, - 487, 494, 490, 455, 0, 0, 526, 532, 533, 541, - 0, 0, 470, 455, 455, 455, 473, 472, 488, 495, - 0, 498, 524, 0, 531, 0, 0, 332, 335, 478, - 477, 471, 480, 481, 486, 0, 484, 0, 527, 534, - 0, 470, 470, 485, 541, 0, 0, 0, 455, 0, - 528, 537, 540, 0, 496, 0, 0, 535, 489, 0, - 538, 540, 536 -}; - -/* YYDEFGOTO[NTERM-NUM]. */ -static const short int yydefgoto[] = -{ - -1, 1, 2, 6, 7, 22, 3, 23, 24, 323, - 647, 329, 649, 225, 560, 675, 191, 260, 393, 394, - 193, 194, 195, 25, 196, 197, 379, 378, 376, 684, - 377, 198, 594, 593, 670, 312, 313, 314, 437, 410, - 26, 304, 529, 199, 200, 201, 202, 203, 204, 205, - 206, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 548, 549, 341, 215, 207, 45, 216, 46, 47, - 48, 49, 50, 232, 76, 233, 648, 77, 565, 305, - 218, 52, 357, 358, 359, 53, 646, 744, 677, 678, - 679, 815, 680, 762, 681, 682, 683, 700, 785, 880, - 703, 787, 881, 568, 235, 708, 709, 710, 236, 54, - 55, 56, 57, 345, 347, 352, 244, 58, 766, 466, - 239, 240, 343, 574, 578, 575, 579, 350, 351, 208, - 292, 400, 712, 713, 402, 403, 404, 226, 411, 412, - 413, 414, 415, 416, 315, 849, 297, 298, 299, 639, - 533, 300, 418, 209, 640, 316, 869, 865, 886, 887, - 819, 866, 867, 535, 774, 821, 536, 537, 888, 905, - 777, 778, 852, 890, 538, 539, 853, 540, 541, 542, - 227, 228, 60, 543, 826, 619, 876, 877, 878, 920, - 879, 69, 165, 492, 601, 550, 719, 835, 551, 552, - 739, 553, 629, 307, 427, 554, 555, 408, 210 -}; - -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF -781 -static const short int yypact[] = -{ - 109, 117, 136, -781, -781, -781, 2777, 2777, 215, -781, - -781, -781, -781, -781, 106, 106, 106, 84, -781, 94, - -781, -781, -781, -781, -781, 61, 131, 1169, 663, 1640, - 1064, 913, 450, 970, 1431, 1809, 1361, 1887, 1541, 1980, - 2238, 2116, 2242, -781, -781, 108, -781, -781, -781, -781, - -781, 106, -781, -781, 104, 110, 116, -781, -781, 111, - -781, 2777, -781, -781, -781, 106, 106, 106, -781, 139, - -781, 148, 2509, -781, 89, 106, 179, -781, 1293, -781, - -781, -781, 106, -781, -781, -781, -781, -781, -781, -781, - -781, 106, -781, -781, -781, -781, -781, -781, -781, -781, - 106, -781, -781, -781, -781, -781, -781, -781, -781, 106, - -781, -781, -781, -781, -781, -781, -781, -781, 106, -781, - -781, -781, -781, -781, -781, -781, -781, 106, -781, -781, - -781, -781, -781, -781, -781, -781, 106, -781, -781, -781, - -781, -781, -781, -781, -781, 106, -781, -781, -781, -781, - -781, 197, 131, -781, -781, -781, -781, -781, 125, -781, - 130, -781, 159, -781, -781, 147, 266, -781, 230, -781, - -781, -781, -781, -781, 2591, 2591, 248, 256, 268, -781, - 278, 495, -781, -781, -781, 2591, -781, -781, 1089, -781, - -781, 2591, 425, -781, 2632, 2673, -781, 3209, 718, 957, - 525, 1839, 1288, 506, 780, 597, 1148, -781, 272, 1771, - 2591, 347, 382, 352, 395, -781, 131, 131, 106, -781, - 106, -781, -781, 106, 361, 400, -781, -781, 106, -781, - 89, 106, 213, -781, 1219, 482, 487, 283, 2111, 330, - 875, -781, 340, -781, 432, -781, -781, -781, 353, 473, - -781, -781, 2591, 2383, 1323, 3052, -781, -781, 360, -781, - 475, 377, -781, 2591, -781, 1089, -781, 1089, -781, 2591, - 2591, 441, -781, -781, 2591, 2591, 2591, 2591, 2591, 2591, - 2591, 2591, 2591, 2591, 2591, 2591, -781, -781, 495, 2591, - 2591, 495, 226, -781, 402, 495, -781, 1575, 466, -781, - 416, -781, 487, 38, 131, -781, -781, -781, 89, 512, - 2134, 436, -781, 936, 49, -781, 2484, 493, 197, 197, - -781, 106, -781, 400, 106, 106, -781, -781, -781, 400, - 106, -781, -781, 957, 525, 1839, 1288, 506, 780, 597, - 1148, -781, 474, 463, 1214, -781, 106, -781, -781, 514, - 485, -781, 432, -781, -781, -781, -781, 477, -781, 489, - -781, 2921, 472, 2942, 510, 488, 524, 539, -781, -781, - 1473, 3209, 540, 542, 3209, 3209, 2591, 596, 2591, 2591, - 2105, 3248, 1030, 1626, 1969, 354, 354, 403, 403, -781, - -781, -781, -781, 567, 581, 3209, 289, -781, 89, 106, - -781, -781, -781, -781, 505, -781, -781, -781, 286, 436, - -781, -781, 63, 70, 81, 90, 685, -781, 601, 2267, - -781, -781, -781, -781, -781, -781, 222, 1003, 2591, 2591, - 2175, -781, 2797, -781, -781, -781, -781, -781, 2305, 3167, - 1487, 730, 3086, 3172, 1545, 857, 607, 609, -781, 482, - 261, 197, -781, 656, -781, -781, -781, 254, 337, -781, - -781, 613, -781, 615, 2591, 495, 617, 485, -781, 473, - 618, 2714, 2728, -781, 2591, -781, 2728, -781, -781, -781, - -781, 619, 619, 36, 2591, 3238, 3171, -781, 2591, -781, - 226, 226, -781, 106, -781, -781, 495, -781, -781, -781, - -781, -781, -781, 2342, -781, -781, -781, -781, -781, -781, - -781, 666, 669, -781, -781, -781, -781, -781, 2591, 671, - 630, 632, 2550, 275, 715, -781, -781, -781, 298, -781, - -781, -781, 638, 126, -781, -781, -781, -781, -781, -781, - -781, -781, -781, -781, 2446, 635, -781, -781, -781, -781, - -781, 639, 301, -781, -781, 515, 2823, 2846, -781, -781, - 64, -781, 197, -781, 131, 2008, -781, -781, 704, -781, - -781, -781, 2591, 80, 650, -781, 2591, 216, 651, -781, - 106, 106, 3209, -781, 106, 667, -781, -781, 518, 664, - 672, 2967, 676, 495, 1874, -781, 3225, 3209, -781, -781, - 680, 1389, -781, -781, -781, -781, -781, -781, 696, 708, - 2992, -781, -781, -781, -781, 308, 2591, 688, -781, -781, - 736, -781, 197, 131, -781, -781, -781, -781, -781, 97, - 178, -781, -781, 3057, 786, -781, -781, -781, 698, -781, - -781, 333, 351, -781, -781, 3209, -781, 64, 2008, 64, - 3111, 2591, -781, 106, 3111, 2591, -781, 106, -781, -781, - -781, 106, -781, 2591, -781, -781, -781, 2591, -781, -781, - 220, -781, 495, 2591, -781, 747, 3209, 709, 721, -781, - -781, 189, -781, 1656, 2591, -781, -781, 734, 735, -781, - 2446, 2591, 2591, -781, -781, 357, -781, 741, 106, 376, - -781, 207, 401, -781, 711, -781, 89, 106, 106, 532, - 558, 224, -781, -781, 106, 89, 106, 224, -781, 106, - -781, 2305, 3167, 3091, 3185, 1487, 730, 1694, 1038, 3086, - 3172, 3120, 3202, 1545, 857, 1723, 1257, -781, -781, -781, - -781, -781, -781, -781, 1874, -781, -781, -781, -781, 3111, - 254, -781, 3111, 337, -781, 536, 2895, 495, 2591, -781, - -781, 2774, 1874, -781, -781, 1942, -781, 2049, -781, -781, - -781, 3225, -781, -781, -781, 724, -781, 729, -781, 545, - 3191, -781, 266, -781, -781, 400, -781, 400, 97, 180, - -781, 106, -781, 106, -781, -781, 106, 178, 178, -781, - -781, 97, 178, 737, -781, -781, -781, -781, -781, -781, - -781, 306, 2591, -781, 738, 2049, -781, -781, 2591, 732, - 744, -781, -781, -781, -781, -781, 746, 782, -781, -781, - 532, 558, 284, -781, -781, 1389, 106, 224, -781, 224, - -781, -781, -781, 2872, -781, -781, 724, -781, -781, -781, - 810, 2591, 743, -781, -781, 66, -781, -781, -781, -781, - -781, -781, -781, -781, -781, -781, 822, 823, -781, -781, - -781, -781, 2591, -781, 756, 495, 800, 757, -781, -781, - 698, 698, 93, -781, -781, -781, -781, -781, -781, -781, - 759, -781, -781, 761, 66, 66, 791, -781, -781, -781, - -781, -781, -781, -781, -781, 792, -781, 266, 825, -781, - 2591, 787, -781, -781, -781, 266, 560, 783, -781, 819, - 794, -781, -781, 799, -781, 2591, 266, -781, -781, 562, - -781, -781, -781 -}; - -/* YYPGOTO[NTERM-NUM]. */ -static const short int yypgoto[] = -{ - -781, -781, -781, -781, -781, 76, 885, -781, -781, -781, - -781, -781, -781, -781, -781, -28, -781, -71, 417, 232, - 468, -781, -781, -781, -105, 1189, -781, -781, -781, -781, - -781, -781, -781, -781, -781, -280, 579, -781, -781, 113, - 112, -301, -500, -2, 0, 138, 219, 2, 7, 31, - 141, -305, -304, 264, 267, -292, -286, 280, 291, -383, - -359, 583, 585, -781, -162, -781, -373, -209, 620, 1012, - 133, 470, -781, -504, -133, 451, -781, 612, -781, 41, - 693, -34, -781, 453, -781, 554, 282, -781, -616, -781, - 161, -781, -638, -781, -781, 250, 251, -781, -781, -781, - -781, -781, -781, -135, 362, 135, 150, -123, 16, -781, - -781, -781, -781, -781, -781, -781, -781, -781, -781, 479, - -118, -781, 595, -781, -781, 199, 204, 616, 502, -115, - -781, -781, -591, -274, -443, -487, -781, 531, -781, -781, - -781, -781, -781, -781, -246, -461, -781, -781, 681, -551, - -781, 437, -781, -781, -397, 662, -777, -742, -221, -207, - -733, -781, -200, 87, -633, -780, -781, -781, -781, -781, - -757, -781, -781, -781, -781, -781, -781, -781, -781, -781, - 269, -205, -781, -781, -781, -781, 88, -781, 95, -781, - -156, -19, -68, 490, -781, -576, -781, -781, -781, -781, - -781, -781, 439, -302, -781, -781, -781, -781, 28 -}; - -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -550 -static const short int yytable[] = -{ - 71, 192, 167, 599, 27, 27, 28, 28, 31, 31, - 248, 442, 443, 32, 32, 310, 234, 154, 401, 237, - 451, 318, 534, 454, 444, 686, 158, 160, 162, 324, - 445, 154, 154, 154, 61, 61, 530, 33, 33, 718, - 820, 242, 78, 452, 626, 770, 532, 598, 154, 455, - -115, 417, 605, 606, 607, 608, 609, 154, 641, 27, - 531, 28, 309, 31, -450, 638, 154, 435, 32, 250, - 251, -451, 211, 261, 212, 154, 420, 247, 342, 850, - 257, 595, -452, 62, 154, 68, 262, 882, 885, 61, - 421, -453, 33, 154, 871, 70, 745, 13, 747, 428, - 73, 705, 154, 223, 224, 301, 534, 155, 156, -2, - 513, 154, 19, 155, 156, 889, 217, 4, 699, 155, - 156, 19, 442, 443, 911, 651, 72, 263, 803, 817, - 424, 891, 875, 918, 73, 444, -3, 164, 19, 365, - 367, 445, -115, 904, 29, 29, 814, 34, 34, -540, - 372, -430, 373, 256, 706, 151, 152, 526, -431, -540, - 295, 530, 707, 224, 98, 103, 107, 112, 238, -432, - 509, 532, 134, 139, 143, 148, 924, 845, -433, 917, - 899, 73, 342, 73, 154, 531, 714, 714, 74, 490, - 776, 498, 501, 504, 507, 153, 75, 157, 163, 29, - 73, 229, 34, 159, 166, 499, 502, 505, 508, 161, - 838, 840, 213, 168, 296, 868, 349, 600, 241, 396, - 873, 356, 211, 243, 212, 30, 30, 461, 211, 463, - 212, 767, 302, 303, 246, 715, 222, 706, 333, -520, - 334, 741, 337, 716, 224, 707, 224, 338, 19, -520, - 737, 222, 245, 672, 230, 673, 19, 73, 229, 859, - 392, 655, 231, 397, 306, 480, 219, 407, 344, 317, - 220, 339, 319, 913, 738, 59, 59, 247, 155, 156, - 30, 223, 224, 398, 757, 468, 758, 223, 224, 223, - 224, 399, 224, 214, -520, 249, 442, 443, -520, 572, - 320, 599, 63, 64, 321, 483, 211, 530, 212, 444, - 599, 230, 759, 252, 438, 445, 439, 532, 440, 231, - 426, 253, 573, 441, 349, 257, 325, 224, 729, 730, - 59, 531, 616, 254, 302, 303, 98, 103, 107, 112, - 73, 733, 333, 255, 334, 598, 337, 734, 528, 793, - 224, 338, 750, 566, 598, 79, 753, 590, 714, 714, - 88, 592, 213, 324, 293, 453, 306, 308, 213, 13, - 327, 456, 344, 495, 220, 339, 858, 496, 335, 19, - 263, 340, 576, 489, 19, 621, 864, 462, 632, 263, - 84, 527, 633, 19, 74, 694, 211, 263, 212, 263, - 842, 311, 75, 93, -470, -470, -470, -470, -470, 281, - 282, 283, 284, 285, -470, -470, -470, 27, 330, 28, - 742, 31, 901, 901, 321, 438, 32, 439, 346, 440, - -470, 642, 528, 348, 441, 155, 156, 349, 743, 301, - 491, 356, 220, 214, 781, 353, 213, 544, 263, 214, - 33, 615, 368, 457, 458, 10, 11, 12, 102, 336, - 283, 284, 285, 784, 14, 15, 16, 321, 604, 370, - 98, 103, 107, 112, 577, 527, 155, 156, 10, 11, - 354, 355, 335, 897, 898, 340, -83, 701, 786, 833, - 702, 834, 220, -114, 406, 617, 324, 788, 155, 156, - 295, 99, 104, 108, 113, 828, 797, 829, 423, 135, - 140, 144, 149, 12, 97, 600, 263, 264, 429, 662, - 14, 15, 16, 433, 600, 497, 500, 214, 506, 9, - 442, 443, 12, 84, 602, 448, 213, -256, 19, 14, - 15, 16, 27, 444, 28, 695, 31, 325, 224, 445, - 459, 32, 223, 224, 471, 18, 464, 29, 562, 564, - 34, -389, -389, 336, 473, 669, 263, 369, 469, 470, - 493, 224, 544, 98, 103, 33, 465, 134, 139, 476, - 426, 83, 87, 92, 96, 101, 105, 110, 114, 119, - 123, 128, 132, 137, 141, 146, 150, 791, 224, 438, - 697, 439, 475, 440, 12, 106, 634, 635, 441, 663, - 664, 14, 15, 16, 652, 573, 477, 214, 656, 775, - 779, 658, 659, 793, 224, 660, 827, 488, 808, 19, - 478, 721, 481, 722, 482, 725, 263, 824, 30, 704, - 726, 484, 622, 623, 760, 711, 717, 80, 85, 89, - 94, 263, 922, 263, 931, 116, 121, 125, 130, 487, - 628, 628, 266, 268, 727, 831, 832, 9, 10, 11, - 12, 84, 488, 99, 104, 108, 113, 14, 15, 16, - 449, 450, 29, 902, 903, 34, 311, 811, 27, 510, - 28, 748, 31, 18, 561, 751, 563, 32, 570, 51, - 51, 580, 754, 581, 211, 584, 212, 65, 66, 67, - 587, -32, 479, 211, -33, 212, 611, 612, 544, 613, - 82, 33, 91, 618, 100, 624, 109, 627, 118, 810, - 127, 631, 136, 222, 145, 10, 11, 12, 102, 783, - 222, 653, 657, -520, 14, 15, 16, 846, 789, 790, - -252, 914, 795, -520, 51, 661, 665, 798, 799, 921, - 800, 690, 154, 30, 666, 51, 326, 51, 668, 577, - 930, 723, 685, 691, 728, 696, 223, 224, 286, 287, - 775, 698, 288, 289, 290, 291, 874, 12, 102, 740, - 804, 526, 763, 806, 14, 15, 16, 764, -520, 772, - 773, 775, -520, 360, 302, 303, 782, 99, 104, 108, - 113, 896, 765, 302, 303, 263, 822, 837, 839, 80, - 85, 89, 94, 405, 847, 841, 844, 855, 29, 870, - 872, 34, 306, 438, 306, 439, 848, 440, 854, 916, - 883, 884, 441, 892, 213, 894, 919, 893, 895, 801, - 802, 906, 724, 213, 929, 907, 910, 912, 98, 103, - 107, 112, 10, 11, 12, 138, 134, 139, 143, 148, - 915, 14, 15, 16, 899, 923, 331, 860, 861, 9, - 862, 51, 12, 13, 925, 926, 928, 5, 589, 14, - 15, 16, 82, 436, 91, 755, 100, 731, 109, 446, - 732, 447, 567, 927, 82, 18, 91, 19, 20, 30, - 99, 104, 932, 735, 135, 140, 425, 51, 10, 11, - 12, 97, 586, 51, 736, 214, 816, 14, 15, 16, - 746, 768, 769, 51, 214, 494, 836, 311, 830, 460, - -117, -117, -117, -117, -117, 19, 585, 51, 51, 805, - -117, -117, -117, 80, 85, 89, 94, 807, 51, 419, - 51, 9, 332, -381, 12, 79, -117, 583, 467, 900, - 625, 14, 15, 16, 434, 10, 11, 12, 106, 422, - 326, 326, 908, 603, 14, 15, 16, 18, 630, 19, - 909, 0, 83, 87, 101, 105, 119, 123, 137, 141, - -255, 51, 19, 0, 545, 0, 546, 9, 10, 11, - 12, 13, 0, 0, 0, 547, 0, 14, 15, 16, - 0, 405, 405, 360, 0, 0, 82, 0, 91, -117, - 100, 0, 109, 18, 0, 0, 0, 51, 0, 81, - 86, 90, 95, 10, 11, 12, 111, 117, 122, 126, - 131, 0, 14, 15, 16, 0, 0, -257, 80, 85, - 0, 0, 116, 121, 0, 0, 0, 0, 9, 10, - 11, 12, 93, 0, 419, 419, 503, 419, 14, 15, - 16, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 258, 51, 169, 9, 18, -549, 12, 13, 0, 170, - 171, 0, 172, 14, 15, 16, 0, 0, 0, 0, - 0, 0, 51, 0, 569, 0, 0, 571, 0, 18, - 173, 19, 20, 0, 174, 175, 176, 177, 178, 179, - 180, 82, 0, 100, 0, 118, 181, 136, 0, 182, - 0, 0, 0, 0, 183, 184, 185, 0, 0, 186, - 187, -254, 0, 0, 188, 12, 111, 0, 0, 0, - 405, 405, 14, 15, 16, 51, 0, 0, 0, 51, - 0, 0, 0, 9, 10, 11, 12, 79, 189, 190, - 0, 0, 259, 14, 15, 16, 0, 0, 0, 620, - 0, 0, 0, 0, 0, 99, 104, 108, 113, 18, - 0, 19, 0, 135, 140, 144, 149, 0, 0, 0, - 0, 81, 86, 90, 95, 331, 0, 0, 9, 0, - 322, 12, 13, -20, -20, -20, -20, -20, 14, 15, - 16, 0, 0, -20, -20, -20, 0, 51, 0, 0, - 792, 794, 0, 0, 18, 0, 19, 20, 222, -20, - 0, -520, 0, 0, 0, 0, -251, 0, 0, 0, - 0, -520, 10, 11, 12, 147, 0, 687, 688, 689, - 0, 14, 15, 16, 0, 83, 87, 92, 96, 101, - 105, 110, 114, 119, 123, 128, 132, 137, 141, 146, - 150, 0, 9, 0, 221, 12, 93, -28, -28, -28, - -28, -28, 14, 15, 16, 0, -520, -28, -28, -28, - -520, 0, -20, 0, 0, 0, 0, 0, 18, 405, - 405, 0, 222, -28, 364, -520, 51, 9, 405, 405, - 12, 13, 405, 405, 0, -520, 0, 14, 15, 16, - 0, 80, 85, 89, 94, 81, 86, 90, 95, 116, - 121, 125, 130, 18, 0, 19, 0, 0, 223, 224, - 0, 792, 794, 794, 0, 9, 10, 11, 12, 120, - 0, 0, 0, 0, 0, 14, 15, 16, 0, 0, - -520, 0, 0, 51, -520, 0, -28, 0, 0, 0, - 545, 18, 0, 9, 10, 11, 12, 13, 0, 51, - 0, 547, 0, 14, 15, 16, 0, 796, 51, 0, - 0, 0, 0, 0, 82, 0, 91, 0, 100, 18, - 109, 0, 118, 0, 127, 0, 136, 0, 145, 0, - 0, 0, 0, 0, 818, 818, 10, 11, 12, 111, - 823, 361, 363, 0, 0, 14, 15, 16, -260, 0, - 81, 86, 371, 0, 117, 122, 0, 0, 374, 375, - 0, 0, 0, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 390, 391, 0, 169, 0, 395, 0, - 0, -549, 0, 170, 171, 851, 172, 0, 0, 0, - 856, 857, 10, 11, 12, 97, 0, 0, 0, 432, - 0, 14, 15, 16, 173, 0, 20, 0, 174, 175, - 176, 177, 178, 179, 180, 0, 0, 0, -258, 19, - 181, 0, 0, 182, 0, 0, 0, 0, 183, 184, - 185, 503, 0, 186, 187, 0, 0, 0, 188, 0, - 0, 0, 0, 0, 503, 9, 10, 11, 12, 129, - 10, 11, 12, 133, 0, 14, 15, 16, 0, 14, - 15, 16, 189, 190, 0, 0, 479, 485, 486, 0, - 0, 18, 0, 503, 818, 0, 409, 19, -470, -470, - -470, -470, -470, -470, 0, -470, -470, 0, -470, -470, - -470, -470, -470, 0, -470, -470, -470, -470, -470, -470, - -470, -470, -470, -470, -470, -470, -470, -470, -470, 0, - -470, -470, -470, -470, -470, -470, -470, 556, 557, 0, - 0, 0, -470, 0, 0, -470, 0, 0, -262, 0, - -470, -470, -470, 0, 0, -470, -470, 0, 0, 0, - -470, 0, 0, 0, 9, 10, 11, 12, 88, 0, - 0, 0, 0, 582, 14, 15, 16, 671, 0, 169, - 395, 0, -470, 591, -470, -470, 170, 171, -470, 172, - 18, 0, 19, 596, 0, 0, 0, 597, 278, 279, - 280, 281, 282, 283, 284, 285, 0, 173, 0, 20, - 0, 174, 175, 176, 177, 178, 179, 180, -327, 10, - 11, 12, 106, 181, 0, 0, 182, 610, 14, 15, - 16, 183, 184, 185, 0, 0, 186, 187, 0, 0, - -327, 188, -327, 0, 0, 0, 19, -253, 10, 11, - 12, 142, 0, 81, 86, 90, 95, 14, 15, 16, - 0, 117, 122, 126, 131, 189, 190, 0, 0, 674, - 0, 0, 0, 0, 645, 19, 0, 0, 0, 0, - 0, 650, 0, 0, 0, 654, 0, 0, 0, 0, - 0, 0, 294, 0, -456, -456, -456, -456, -456, -456, - 0, -456, -456, 676, -456, -456, -456, -456, -456, 0, - -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, - -456, -456, -456, -456, -456, 295, -456, -456, -456, -456, - -456, -456, -456, 9, 10, 11, 12, 115, -456, 0, - 0, -456, 0, 14, 15, 16, -456, -456, -456, 0, - 0, -456, -456, 0, 0, 0, -456, 645, 0, 18, - 749, 19, 0, 9, 752, 0, 12, 88, 0, 0, - 0, 0, 395, 14, 15, 16, 756, 0, -456, 296, - -456, -456, 761, 0, -456, 0, 0, 0, 0, 18, - 0, 19, 676, 771, 0, 671, 0, 511, 156, 0, - 0, 780, 0, 0, 170, 171, 0, 172, 0, 0, - 0, 9, 10, 11, 12, 124, -259, 0, 0, 0, - 0, 14, 15, 16, 0, 173, 0, 20, 0, 174, - 175, 176, 177, 178, 179, 180, 0, 18, 0, 19, - 0, 181, 0, 0, 182, 0, 0, 0, 0, 183, - 184, 185, 0, 676, 186, 187, 0, 0, 672, 188, - 673, 0, 0, 671, 0, 511, 156, 0, 0, 0, - 0, 676, 170, 171, 676, 172, 676, 0, 0, 0, - 0, 0, -311, 189, 190, 0, 0, 674, 0, 0, - 0, 0, 0, 173, -261, 20, 0, 174, 175, 176, - 177, 178, 179, 180, 0, 10, 11, 12, 133, 181, - 0, 0, 182, 0, 14, 15, 16, 183, 184, 185, - 0, 843, 186, 187, 676, 0, 672, 188, 673, 643, - 0, 169, 19, 0, 0, 0, 0, 0, 170, 171, - 0, 172, 279, 280, 281, 282, 283, 284, 285, 0, - -378, 189, 190, 0, 0, 674, 0, 0, 0, 173, - 0, 20, 0, 174, 175, 176, 177, 178, 179, 180, - 671, 0, 169, 0, 0, 181, 0, 0, 182, 170, - 171, 0, 172, 183, 184, 185, 0, -263, 186, 187, - 0, 0, 0, 188, 0, 0, 0, 0, 0, 0, - 173, 0, 20, 0, 174, 175, 176, 177, 178, 179, - 180, 0, 0, 0, 0, 0, 181, 189, 190, 182, - 0, 644, 0, 0, 183, 184, 185, 0, 0, 186, - 187, 0, 328, 0, 188, -24, -24, -24, -24, -24, - 0, 10, 11, 12, 142, -24, -24, -24, 0, 0, - 14, 15, 16, 0, 0, 0, 0, 169, 189, 190, - 222, -24, 674, -520, 170, 171, 0, 172, 19, 0, - 0, 0, 0, -520, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 173, 0, 20, 0, 174, - 175, 176, 177, 178, 179, 180, 223, 224, 169, 0, - 0, 181, 0, 0, 182, 170, 171, 0, 172, 183, - 184, 430, 0, 0, 186, 187, 0, 0, -520, 188, - 0, 0, -520, -265, -24, 0, 173, 0, 20, 0, - 174, 175, 176, 177, 178, 179, 180, 0, 0, 0, - 0, 0, 181, 189, 190, 182, 0, 0, 431, 0, - 183, 184, 185, 0, 0, 186, 187, 0, 0, 0, - 188, 0, 0, 10, 11, 12, 138, 10, 11, 12, - 147, 0, 14, 15, 16, 0, 14, 15, 16, 0, - 0, 0, 0, 0, 189, 190, 0, 0, 0, 558, - 511, 512, 10, 11, 12, 13, 0, 170, 171, 0, - 172, 14, 15, 16, 513, 0, 514, 515, 516, 517, - 518, 519, 520, 521, 522, 523, 524, 18, 173, 19, - 20, 0, 174, 175, 176, 177, 178, 179, 180, 9, - 10, 11, 12, 79, 181, 0, 0, 182, 0, 14, - 15, 16, 183, 184, 185, -264, 0, 186, 187, -266, - 0, 0, 188, 0, 0, 18, 0, 19, 0, 0, - 0, 0, 0, 0, 0, 511, 156, 0, 0, 0, - 0, 0, 170, 171, 525, 172, 189, 190, 0, 513, - 526, 514, 515, 516, 517, 518, 519, 520, 521, 522, - 523, 524, 0, 173, 0, 20, 0, 174, 175, 176, - 177, 178, 179, 180, 362, 0, 169, 0, 0, 181, - 0, 0, 182, 170, 171, 0, 172, 183, 184, 185, - 0, 0, 186, 187, 0, 0, 0, 188, 0, 0, - 0, 0, 0, 0, 173, 0, 20, 0, 174, 175, - 176, 177, 178, 179, 180, 0, 0, 0, 0, 525, - 181, 189, 190, 182, 0, 526, 0, 0, 183, 184, - 185, 0, 0, 186, 187, 0, 0, 0, 188, 169, - 9, 10, 11, 12, 13, 0, 170, 171, 0, 172, - 14, 15, 16, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 189, 190, 0, 0, 18, 173, 19, 20, - 0, 174, 175, 176, 177, 178, 179, 180, 9, 10, - 11, 12, 13, 181, 0, 0, 182, 0, 14, 15, - 16, 183, 184, 185, 0, 0, 186, 187, 0, 0, - 0, 188, 169, 9, 18, 0, 12, 13, 0, 170, - 171, 0, 172, 14, 15, 16, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 189, 190, 0, 0, 18, - 173, 19, 20, 0, 174, 175, 176, 177, 178, 179, - 180, 0, 0, 169, 0, 0, 181, 0, 0, 182, - 170, 171, 0, 172, 183, 184, 185, 0, 0, 186, - 187, 0, 0, 0, 188, 0, 0, 0, 0, 0, - 0, 173, 0, 20, 0, 174, 175, 176, 177, 178, - 179, 180, 0, 0, 169, 0, 0, 181, 189, 190, - 182, 170, 171, 0, 172, 183, 184, 185, 0, 0, - 186, 187, 0, 0, 0, 188, 0, 0, 0, 0, - 0, 0, 173, 0, 20, 0, 174, 175, 176, 177, - 178, 179, 180, 0, 0, 169, 0, 614, 181, 189, - 190, 182, 170, 171, 0, 172, 183, 184, 185, 0, - 0, 186, 187, 0, 0, 0, 188, 0, 0, 0, - 0, 0, 0, 173, 0, 20, 0, 174, 175, 176, - 177, 178, 179, 180, 0, 0, 169, 0, 0, 181, - 189, 190, 182, 170, 171, 0, 172, 183, 184, 185, - 0, 0, 186, 187, 0, 0, 0, 265, 0, 0, - 0, 0, 0, 0, 173, 0, 20, 0, 174, 175, - 176, 177, 178, 179, 180, 0, 0, 588, 0, 0, - 181, 189, 190, 182, 170, 171, 0, 172, 183, 184, - 185, 0, 9, 186, 187, 12, 13, 0, 267, 0, - 0, 0, 14, 15, 16, 173, 0, 20, 0, 174, - 175, 176, 177, 178, 179, 180, 0, 0, 18, 0, - 19, 181, 189, 190, 182, 0, 0, 0, 0, 183, - 184, 185, 0, 0, 186, 187, 0, 0, 8, 188, - -126, 9, 10, 11, 12, 13, 812, 0, 0, 0, - 0, 14, 15, 16, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 189, 190, 0, 17, 18, 0, 19, - 20, 0, 0, 0, 0, 0, 269, 270, 271, 0, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, -126, 0, 0, 0, 0, 269, - 270, 271, -126, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 0, 0, 0, - 0, 0, 0, 0, 21, 269, 270, 271, 813, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 0, 0, 0, 0, 0, 269, 270, - 271, 559, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 270, 271, 636, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 0, 0, 0, 0, 0, 269, 270, 271, - 637, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 0, 0, 0, 0, 0, - 0, 0, 0, 269, 270, 271, 863, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 0, 0, 0, 269, 270, 271, 809, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 0, 0, 692, 0, 0, 0, 0, 269, - 270, 271, 472, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 0, 0, 0, - 0, 0, 0, 474, 269, 270, 271, 693, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 0, 366, 0, 0, 9, 0, 667, 12, - 13, 9, 10, 11, 12, 13, 14, 15, 16, 720, - 0, 14, 15, 16, 0, 0, 0, 0, 0, 0, - 0, 0, 18, 0, 19, 0, 0, 18, 0, 19, - 9, 10, 11, 12, 115, 9, 10, 11, 12, 88, - 14, 15, 16, 0, 0, 14, 15, 16, 0, 0, - 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, - 0, 18, 0, 19, 9, 10, 11, 12, 124, 0, - 0, 0, 0, 0, 14, 15, 16, 0, 0, 0, - 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, - 18, 0, 19, 269, 270, 271, 0, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 9, 10, 11, 12, 84, 9, 10, 11, 12, - 120, 14, 15, 16, 0, 0, 14, 15, 16, 9, - 10, 11, 12, 93, 0, 0, 0, 18, 0, 14, - 15, 16, 18, 0, 0, 0, 9, 10, 11, 12, - 129, 0, 0, 0, 0, 18, 14, 15, 16, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 0, 18, 269, 270, 271, 825, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 269, 270, 271, 0, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 271, - 0, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285 -}; - -static const short int yycheck[] = -{ - 19, 72, 70, 490, 6, 7, 6, 7, 6, 7, - 166, 316, 316, 6, 7, 224, 151, 51, 292, 152, - 321, 230, 419, 325, 316, 601, 54, 55, 56, 234, - 316, 65, 66, 67, 6, 7, 419, 6, 7, 630, - 773, 159, 26, 323, 544, 683, 419, 490, 82, 329, - 1, 297, 513, 514, 515, 516, 517, 91, 562, 61, - 419, 61, 224, 61, 1, 1, 100, 313, 61, 174, - 175, 1, 74, 188, 74, 109, 297, 11, 240, 821, - 185, 45, 1, 7, 118, 1, 191, 864, 868, 61, - 297, 1, 61, 127, 851, 1, 647, 8, 649, 308, - 3, 4, 136, 65, 66, 210, 503, 3, 4, 0, - 17, 145, 32, 3, 4, 872, 75, 0, 622, 3, - 4, 32, 427, 427, 901, 45, 65, 91, 744, 767, - 92, 873, 66, 913, 3, 427, 0, 61, 32, 254, - 255, 427, 93, 885, 6, 7, 762, 6, 7, 65, - 265, 88, 267, 181, 57, 43, 44, 93, 88, 65, - 34, 544, 65, 66, 31, 32, 33, 34, 152, 88, - 416, 544, 39, 40, 41, 42, 918, 815, 88, 912, - 87, 3, 344, 3, 218, 544, 629, 630, 57, 398, - 690, 412, 413, 414, 415, 87, 65, 93, 87, 61, - 3, 4, 61, 93, 65, 412, 413, 414, 415, 93, - 801, 802, 74, 65, 88, 848, 244, 491, 93, 290, - 853, 249, 224, 93, 224, 6, 7, 345, 230, 347, - 230, 42, 216, 217, 87, 57, 29, 57, 240, 32, - 240, 638, 240, 65, 66, 65, 66, 240, 32, 42, - 633, 29, 93, 64, 57, 66, 32, 3, 4, 835, - 288, 45, 65, 291, 223, 370, 87, 295, 240, 228, - 91, 240, 231, 906, 633, 6, 7, 11, 3, 4, - 61, 65, 66, 57, 64, 353, 66, 65, 66, 65, - 66, 65, 66, 74, 87, 65, 601, 601, 91, 45, - 87, 788, 87, 88, 91, 376, 308, 690, 308, 601, - 797, 57, 92, 65, 316, 601, 316, 690, 316, 65, - 304, 65, 457, 316, 352, 430, 65, 66, 633, 633, - 61, 690, 57, 65, 318, 319, 203, 204, 205, 206, - 3, 633, 344, 65, 344, 788, 344, 633, 419, 65, - 66, 344, 653, 92, 797, 8, 657, 472, 801, 802, - 8, 476, 224, 568, 92, 324, 325, 6, 230, 8, - 87, 330, 344, 87, 91, 344, 92, 91, 240, 32, - 91, 240, 45, 94, 32, 87, 847, 346, 87, 91, - 8, 419, 91, 32, 57, 87, 398, 91, 398, 91, - 94, 1, 65, 8, 4, 5, 6, 7, 8, 55, - 56, 57, 58, 59, 14, 15, 16, 419, 88, 419, - 87, 419, 883, 884, 91, 427, 419, 427, 88, 427, - 30, 564, 503, 1, 427, 3, 4, 465, 87, 544, - 399, 469, 91, 224, 87, 92, 308, 419, 91, 230, - 419, 522, 92, 341, 342, 5, 6, 7, 8, 240, - 57, 58, 59, 87, 14, 15, 16, 91, 496, 92, - 337, 338, 339, 340, 458, 503, 3, 4, 5, 6, - 7, 8, 344, 880, 881, 344, 45, 622, 87, 791, - 623, 793, 91, 93, 92, 523, 701, 706, 3, 4, - 34, 31, 32, 33, 34, 785, 715, 787, 92, 39, - 40, 41, 42, 7, 8, 789, 91, 92, 6, 587, - 14, 15, 16, 87, 798, 412, 413, 308, 415, 4, - 835, 835, 7, 8, 493, 42, 398, 87, 32, 14, - 15, 16, 544, 835, 544, 616, 544, 65, 66, 835, - 87, 544, 65, 66, 65, 30, 42, 419, 446, 447, - 419, 87, 88, 344, 92, 593, 91, 92, 91, 92, - 65, 66, 544, 440, 441, 544, 91, 444, 445, 91, - 564, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 65, 66, 601, - 619, 601, 92, 601, 7, 8, 91, 92, 601, 91, - 92, 14, 15, 16, 573, 750, 92, 398, 577, 690, - 691, 580, 581, 65, 66, 584, 782, 91, 92, 32, - 91, 633, 92, 633, 92, 633, 91, 92, 419, 623, - 633, 45, 530, 531, 672, 629, 630, 27, 28, 29, - 30, 91, 92, 91, 92, 35, 36, 37, 38, 92, - 548, 549, 194, 195, 633, 788, 789, 4, 5, 6, - 7, 8, 91, 203, 204, 205, 206, 14, 15, 16, - 318, 319, 544, 883, 884, 544, 1, 758, 690, 88, - 690, 650, 690, 30, 87, 654, 87, 690, 42, 6, - 7, 88, 661, 88, 706, 88, 706, 14, 15, 16, - 92, 45, 93, 715, 45, 715, 45, 87, 690, 87, - 27, 690, 29, 8, 31, 87, 33, 92, 35, 757, - 37, 92, 39, 29, 41, 5, 6, 7, 8, 698, - 29, 91, 91, 32, 14, 15, 16, 818, 707, 708, - 87, 907, 711, 42, 61, 88, 92, 716, 717, 915, - 719, 65, 796, 544, 92, 72, 235, 74, 92, 753, - 926, 633, 92, 65, 633, 87, 65, 66, 60, 61, - 851, 45, 64, 65, 66, 67, 854, 7, 8, 3, - 749, 93, 45, 752, 14, 15, 16, 88, 87, 65, - 65, 872, 91, 249, 788, 789, 65, 337, 338, 339, - 340, 879, 91, 797, 798, 91, 87, 801, 802, 199, - 200, 201, 202, 292, 92, 88, 88, 45, 690, 19, - 87, 690, 791, 835, 793, 835, 92, 835, 92, 910, - 18, 18, 835, 87, 706, 45, 914, 875, 91, 737, - 738, 92, 633, 715, 925, 94, 65, 65, 725, 726, - 727, 728, 5, 6, 7, 8, 733, 734, 735, 736, - 45, 14, 15, 16, 87, 92, 1, 836, 837, 4, - 839, 188, 7, 8, 65, 91, 87, 2, 471, 14, - 15, 16, 199, 314, 201, 663, 203, 633, 205, 316, - 633, 316, 451, 922, 211, 30, 213, 32, 33, 690, - 440, 441, 931, 633, 444, 445, 304, 224, 5, 6, - 7, 8, 469, 230, 633, 706, 765, 14, 15, 16, - 648, 681, 681, 240, 715, 404, 801, 1, 788, 344, - 4, 5, 6, 7, 8, 32, 467, 254, 255, 750, - 14, 15, 16, 333, 334, 335, 336, 753, 265, 297, - 267, 4, 87, 88, 7, 8, 30, 465, 352, 882, - 533, 14, 15, 16, 312, 5, 6, 7, 8, 298, - 449, 450, 894, 493, 14, 15, 16, 30, 549, 32, - 895, -1, 438, 439, 440, 441, 442, 443, 444, 445, - 87, 308, 32, -1, 1, -1, 3, 4, 5, 6, - 7, 8, -1, -1, -1, 12, -1, 14, 15, 16, - -1, 490, 491, 469, -1, -1, 333, -1, 335, 93, - 337, -1, 339, 30, -1, -1, -1, 344, -1, 27, - 28, 29, 30, 5, 6, 7, 8, 35, 36, 37, - 38, -1, 14, 15, 16, -1, -1, 87,