# line 30 "./c-exp.y" #include <stdio.h> #include <string.h> #include "defs.h" #include "symtab.h" #include "gdbtypes.h" #include "frame.h" #include "expression.h" #include "parser-defs.h" #include "value.h" #include "language.h" #include "bfd.h" #include "symfile.h" #include "objfiles.h" /* These MUST be included in any grammar file!!!! Please choose unique names! Note that this are a combined list of variables that can be produced by any one of bison, byacc, or yacc. */ #define yymaxdepth c_maxdepth #define yyparse c_parse #define yylex c_lex #define yyerror c_error #define yylval c_lval #define yychar c_char #define yydebug c_debug #define yypact c_pact #define yyr1 c_r1 #define yyr2 c_r2 #define yydef c_def #define yychk c_chk #define yypgo c_pgo #define yyact c_act #define yyexca c_exca #define yyerrflag c_errflag #define yynerrs c_nerrs #define yyps c_ps #define yypv c_pv #define yys c_s #define yy_yys c_yys #define yystate c_state #define yytmp c_tmp #define yyv c_v #define yy_yyv c_yyv #define yyval c_val #define yylloc c_lloc #define yyss c_yyss /* byacc */ #define yyssp c_yysp /* byacc */ #define yyvs c_yyvs /* byacc */ #define yyvsp c_yyvsp /* byacc */ int yyparse PARAMS ((void)); int yylex PARAMS ((void)); void yyerror PARAMS ((char *)); /* #define YYDEBUG 1 */ # line 97 "./c-exp.y" typedef union { LONGEST lval; unsigned LONGEST ulval; double dval; struct symbol *sym; struct type *tval; struct stoken sval; struct ttype tsym; struct symtoken ssym; int voidval; struct block *bval; enum exp_opcode opcode; struct internalvar *ivar; struct type **tvec; int *ivec; } YYSTYPE; # line 117 "./c-exp.y" /* YYSTYPE gets defined by %union */ static int parse_number PARAMS ((char *, int, int, YYSTYPE *)); # define INT 257 # define CHAR 258 # define UINT 259 # define FLOAT 260 # define STRING 261 # define NAME 262 # define TYPENAME 263 # define NAME_OR_INT 264 # define NAME_OR_UINT 265 # define STRUCT 266 # define CLASS 267 # define UNION 268 # define ENUM 269 # define SIZEOF 270 # define UNSIGNED 271 # define COLONCOLON 272 # define TEMPLATE 273 # define ERROR 274 # define SIGNED_KEYWORD 275 # define LONG 276 # define SHORT 277 # define INT_KEYWORD 278 # define CONST_KEYWORD 279 # define VOLATILE_KEYWORD 280 # define LAST 281 # define REGNAME 282 # define VARIABLE 283 # define ASSIGN_MODIFY 284 # define THIS 285 # define ABOVE_COMMA 286 # define OROR 287 # define ANDAND 288 # define EQUAL 289 # define NOTEQUAL 290 # define LEQ 291 # define GEQ 292 # define LSH 293 # define RSH 294 # define UNARY 295 # define INCREMENT 296 # define DECREMENT 297 # define ARROW 298 # define BLOCKNAME 299 # line 197 "./c-exp.y" /* Ensure that if the generated parser contains any calls to malloc/realloc, that they get mapped to xmalloc/xrealloc. We have to do this here rather than earlier in the file because this is the first point after the place where the SVR4 yacc includes <malloc.h>, and if we do it before that, then the remapped declarations in <malloc.h> will collide with the ones in "defs.h". */ #define malloc xmalloc #define realloc xrealloc #define yyclearin yychar = -1 #define yyerrok yyerrflag = 0 extern int yychar; extern int yyerrflag; #ifndef YYMAXDEPTH #define YYMAXDEPTH 150 #endif YYSTYPE yylval, yyval; # define YYERRCODE 256 # line 946 "./c-exp.y" /* Take care of parsing a number (anything that starts with a digit). Set yylval and return the token type; update lexptr. LEN is the number of characters in it. */ /*** Needs some error checking for the float case ***/ static int parse_number (p, len, parsed_float, putithere) register char *p; register int len; int parsed_float; YYSTYPE *putithere; { register LONGEST n = 0; register LONGEST prevn = 0; register int i; register int c; register int base = input_radix; int unsigned_p = 0; if (parsed_float) { /* It's a float since it contains a point or an exponent. */ putithere->dval = atof (p); return FLOAT; } /* Handle base-switching prefixes 0x, 0t, 0d, 0 */ if (p[0] == '0') switch (p[1]) { case 'x': case 'X': if (len >= 3) { p += 2; base = 16; len -= 2; } break; case 't': case 'T': case 'd': case 'D': if (len >= 3) { p += 2; base = 10; len -= 2; } break; default: base = 8; break; } while (len-- > 0) { c = *p++; if (c >= 'A' && c <= 'Z') c += 'a' - 'A'; if (c != 'l' && c != 'u') n *= base; if (c >= '0' && c <= '9') n += i = c - '0'; else { if (base > 10 && c >= 'a' && c <= 'f') n += i = c - 'a' + 10; else if (len == 0 && c == 'l') ; else if (len == 0 && c == 'u') unsigned_p = 1; else return ERROR; /* Char not a digit */ } if (i >= base) return ERROR; /* Invalid digit in this base */ /* Portably test for overflow (only works for nonzero values, so make a second check for zero). */ if((prevn >= n) && n != 0) unsigned_p=1; /* Try something unsigned */ /* If range checking enabled, portably test for unsigned overflow. */ if(RANGE_CHECK && n!=0) { if((unsigned_p && (unsigned)prevn >= (unsigned)n)) range_error("Overflow on numeric constant."); } prevn=n; } if (unsigned_p) { putithere->ulval = n; return UINT; } else { putithere->lval = n; return INT; } } struct token { char *operator; int token; enum exp_opcode opcode; }; const static struct token tokentab3[] = { {">>=", ASSIGN_MODIFY, BINOP_RSH}, {"<<=", ASSIGN_MODIFY, BINOP_LSH} }; const static struct token tokentab2[] = { {"+=", ASSIGN_MODIFY, BINOP_ADD}, {"-=", ASSIGN_MODIFY, BINOP_SUB}, {"*=", ASSIGN_MODIFY, BINOP_MUL}, {"/=", ASSIGN_MODIFY, BINOP_DIV}, {"%=", ASSIGN_MODIFY, BINOP_REM}, {"|=", ASSIGN_MODIFY, BINOP_LOGIOR}, {"&=", ASSIGN_MODIFY, BINOP_LOGAND}, {"^=", ASSIGN_MODIFY, BINOP_LOGXOR}, {"++", INCREMENT, BINOP_END}, {"--", DECREMENT, BINOP_END}, {"->", ARROW, BINOP_END}, {"&&", ANDAND, BINOP_END}, {"||", OROR, BINOP_END}, {"::", COLONCOLON, BINOP_END}, {"<<", LSH, BINOP_END}, {">>", RSH, BINOP_END}, {"==", EQUAL, BINOP_END}, {"!=", NOTEQUAL, BINOP_END}, {"<=", LEQ, BINOP_END}, {">=", GEQ, BINOP_END} }; /* Read one token, getting characters through lexptr. */ int yylex () { register int c; register int namelen; register unsigned i; register char *tokstart; retry: tokstart = lexptr; /* See if it is a special token of length 3. */ for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++) if (!strncmp (tokstart, tokentab3[i].operator, 3)) { lexptr += 3; yylval.opcode = tokentab3[i].opcode; return tokentab3[i].token; } /* See if it is a special token of length 2. */ for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++) if (!strncmp (tokstart, tokentab2[i].operator, 2)) { lexptr += 2; yylval.opcode = tokentab2[i].opcode; return tokentab2[i].token; } switch (c = *tokstart) { case 0: return 0; case ' ': case '\t': case '\n': lexptr++; goto retry; case '\'': /* We either have a character constant ('0' or '\177' for example) or we have a quoted symbol reference ('foo(int,int)' in C++ for example). */ lexptr++; c = *lexptr++; if (c == '\\') c = parse_escape (&lexptr); yylval.lval = c; c = *lexptr++; if (c != '\'') { namelen = skip_quoted (tokstart) - tokstart; if (namelen > 2) { lexptr = tokstart + namelen; namelen -= 2; tokstart++; goto tryname; } error ("Invalid character constant."); } return CHAR; case '(': paren_depth++; lexptr++; return c; case ')': if (paren_depth == 0) return 0; paren_depth--; lexptr++; return c; case ',': if (comma_terminates && paren_depth == 0) return 0; lexptr++; return c; case '.': /* Might be a floating point number. */ if (lexptr[1] < '0' || lexptr[1] > '9') goto symbol; /* Nope, must be a symbol. */ /* FALL THRU into number case. */ case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': { /* It's a number. */ int got_dot = 0, got_e = 0, toktype; register char *p = tokstart; int hex = input_radix > 10; if (c == '0' && (p[1] == 'x' || p[1] == 'X')) { p += 2; hex = 1; } else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D')) { p += 2; hex = 0; } for (;; ++p) { if (!hex && !got_e && (*p == 'e' || *p == 'E')) got_dot = got_e = 1; else if (!hex && !got_dot && *p == '.') got_dot = 1; else if (got_e && (p[-1] == 'e' || p[-1] == 'E') && (*p == '-' || *p == '+')) /* This is the sign of the exponent, not the end of the number. */ continue; /* We will take any letters or digits. parse_number will complain if past the radix, or if L or U are not final. */ else if ((*p < '0' || *p > '9') && ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z'))) break; } toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); if (toktype == ERROR) { char *err_copy = (char *) alloca (p - tokstart + 1); memcpy (err_copy, tokstart, p - tokstart); err_copy[p - tokstart] = 0; error ("Invalid number \"%s\".", err_copy); } lexptr = p; return toktype; } case '+': case '-': case '*': case '/': case '%': case '|': case '&': case '^': case '~': case '!': case '@': case '<': case '>': case '[': case ']': case '?': case ':': case '=': case '{': case '}': symbol: lexptr++; return c; case '"': for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++) if (c == '\\') { c = tokstart[++namelen]; if (c >= '0' && c <= '9') { c = tokstart[++namelen]; if (c >= '0' && c <= '9') c = tokstart[++namelen]; } } yylval.sval.ptr = tokstart + 1; yylval.sval.length = namelen - 1; lexptr += namelen + 1; return STRING; } if (!(c == '_' || c == '$' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) /* We must have come across a bad character (e.g. ';'). */ error ("Invalid character '%c' in expression.", c); /* It's a name. See how long it is. */ namelen = 0; for (c = tokstart[namelen]; (c == '_' || c == '$' || (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')); c = tokstart[++namelen]) ; /* The token "if" terminates the expression and is NOT removed from the input stream. */ if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') { return 0; } lexptr += namelen; /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1) and $$digits (equivalent to $<-digits> if you could type that). Make token type LAST, and put the number (the digits) in yylval. */ tryname: if (*tokstart == '$') { register int negate = 0; c = 1; /* Double dollar means negate the number and add -1 as well. Thus $$ alone means -1. */ if (namelen >= 2 && tokstart[1] == '$') { negate = 1; c = 2; } if (c == namelen) { /* Just dollars (one or two) */ yylval.lval = - negate; return LAST; } /* Is the rest of the token digits? */ for (; c < namelen; c++) if (!(tokstart[c] >= '0' && tokstart[c] <= '9')) break; if (c == namelen) { yylval.lval = atoi (tokstart + 1 + negate); if (negate) yylval.lval = - yylval.lval; return LAST; } } /* Handle tokens that refer to machine registers: $ followed by a register name. */ if (*tokstart == '$') { for (c = 0; c < NUM_REGS; c++) if (namelen - 1 == strlen (reg_names[c]) && !strncmp (tokstart + 1, reg_names[c], namelen - 1)) { yylval.lval = c; return REGNAME; } for (c = 0; c < num_std_regs; c++) if (namelen - 1 == strlen (std_regs[c].name) && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1)) { yylval.lval = std_regs[c].regnum; return REGNAME; } } /* Catch specific keywords. Should be done with a data structure. */ switch (namelen) { case 8: if (!strncmp (tokstart, "unsigned", 8)) return UNSIGNED; if (current_language->la_language == language_cplus && !strncmp (tokstart, "template", 8)) return TEMPLATE; if (!strncmp (tokstart, "volatile", 8)) return VOLATILE_KEYWORD; break; case 6: if (!strncmp (tokstart, "struct", 6)) return STRUCT; if (!strncmp (tokstart, "signed", 6)) return SIGNED_KEYWORD; if (!strncmp (tokstart, "sizeof", 6)) return SIZEOF; break; case 5: if (current_language->la_language == language_cplus && !strncmp (tokstart, "class", 5)) return CLASS; if (!strncmp (tokstart, "union", 5)) return UNION; if (!strncmp (tokstart, "short", 5)) return SHORT; if (!strncmp (tokstart, "const", 5)) return CONST_KEYWORD; break; case 4: if (!strncmp (tokstart, "enum", 4)) return ENUM; if (!strncmp (tokstart, "long", 4)) return LONG; if (current_language->la_language == language_cplus && !strncmp (tokstart, "this", 4)) { static const char this_name[] = { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' }; if (lookup_symbol (this_name, expression_context_block, VAR_NAMESPACE, 0, NULL)) return THIS; } break; case 3: if (!strncmp (tokstart, "int", 3)) return INT_KEYWORD; break; default: break; } yylval.sval.ptr = tokstart; yylval.sval.length = namelen; /* Any other names starting in $ are debugger internal variables. */ if (*tokstart == '$') { yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1); return VARIABLE; } /* Use token-type BLOCKNAME for symbols that happen to be defined as functions or symtabs. If this is not so, then ... Use token-type TYPENAME for symbols that happen to be defined currently as names of types; NAME for other symbols. The caller is not constrained to care about the distinction. */ { char *tmp = copy_name (yylval.sval); struct symbol *sym; int is_a_field_of_this = 0; int hextype; sym = lookup_symbol (tmp, expression_context_block, VAR_NAMESPACE, current_language->la_language == language_cplus ? &is_a_field_of_this : NULL, NULL); if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) || lookup_partial_symtab (tmp)) { yylval.ssym.sym = sym; yylval.ssym.is_a_field_of_this = is_a_field_of_this; return BLOCKNAME; } if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF) { yylval.tsym.type = SYMBOL_TYPE (sym); return TYPENAME; } if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0) return TYPENAME; /* Input names that aren't symbols but ARE valid hex numbers, when the input radix permits them, can be names or numbers depending on the parse. Note we support radixes > 16 here. */ if (!sym && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))) { YYSTYPE newlval; /* Its value is ignored. */ hextype = parse_number (tokstart, namelen, 0, &newlval); if (hextype == INT) { yylval.ssym.sym = sym; yylval.ssym.is_a_field_of_this = is_a_field_of_this; return NAME_OR_INT; } if (hextype == UINT) { yylval.ssym.sym = sym; yylval.ssym.is_a_field_of_this = is_a_field_of_this; return NAME_OR_UINT; } } /* Any other kind of symbol */ yylval.ssym.sym = sym; yylval.ssym.is_a_field_of_this = is_a_field_of_this; return NAME; } } void yyerror (msg) char *msg; { error (msg ? msg : "Invalid syntax in expression."); } /* Table mapping opcodes into strings for printing operators and precedences of the operators. */ const static struct op_print c_op_print_tab[] = { {",", BINOP_COMMA, PREC_COMMA, 0}, {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, {"||", BINOP_OR, PREC_OR, 0}, {"&&", BINOP_AND, PREC_AND, 0}, {"|", BINOP_LOGIOR, PREC_LOGIOR, 0}, {"&", BINOP_LOGAND, PREC_LOGAND, 0}, {"^", BINOP_LOGXOR, PREC_LOGXOR, 0}, {"==", BINOP_EQUAL, PREC_EQUAL, 0}, {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0}, {"<=", BINOP_LEQ, PREC_ORDER, 0}, {">=", BINOP_GEQ, PREC_ORDER, 0}, {">", BINOP_GTR, PREC_ORDER, 0}, {"<", BINOP_LESS, PREC_ORDER, 0}, {">>", BINOP_RSH, PREC_SHIFT, 0}, {"<<", BINOP_LSH, PREC_SHIFT, 0}, {"+", BINOP_ADD, PREC_ADD, 0}, {"-", BINOP_SUB, PREC_ADD, 0}, {"*", BINOP_MUL, PREC_MUL, 0}, {"/", BINOP_DIV, PREC_MUL, 0}, {"%", BINOP_REM, PREC_MUL, 0}, {"@", BINOP_REPEAT, PREC_REPEAT, 0}, {"-", UNOP_NEG, PREC_PREFIX, 0}, {"!", UNOP_ZEROP, PREC_PREFIX, 0}, {"~", UNOP_LOGNOT, PREC_PREFIX, 0}, {"*", UNOP_IND, PREC_PREFIX, 0}, {"&", UNOP_ADDR, PREC_PREFIX, 0}, {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0}, {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0}, {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0}, /* C++ */ {"::", BINOP_SCOPE, PREC_PREFIX, 0}, }; /* These variables point to the objects representing the predefined C data types. */ struct type *builtin_type_void; struct type *builtin_type_char; struct type *builtin_type_short; struct type *builtin_type_int; struct type *builtin_type_long; struct type *builtin_type_long_long; struct type *builtin_type_signed_char; struct type *builtin_type_unsigned_char; struct type *builtin_type_unsigned_short; struct type *builtin_type_unsigned_int; struct type *builtin_type_unsigned_long; struct type *builtin_type_unsigned_long_long; struct type *builtin_type_float; struct type *builtin_type_double; struct type *builtin_type_long_double; struct type *builtin_type_complex; struct type *builtin_type_double_complex; struct type ** const (c_builtin_types[]) = { &builtin_type_int, &builtin_type_long, &builtin_type_short, &builtin_type_char, &builtin_type_float, &builtin_type_double, &builtin_type_void, &builtin_type_long_long, &builtin_type_signed_char, &builtin_type_unsigned_char, &builtin_type_unsigned_short, &builtin_type_unsigned_int, &builtin_type_unsigned_long, &builtin_type_unsigned_long_long, &builtin_type_long_double, &builtin_type_complex, &builtin_type_double_complex, 0 }; const struct language_defn c_language_defn = { "c", /* Language name */ language_c, c_builtin_types, range_check_off, type_check_off, c_parse, c_error, &BUILTIN_TYPE_LONGEST, /* longest signed integral type */ &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */ &builtin_type_double, /* longest floating point type */ /*FIXME*/ "0x%x", "0x%", "x", /* Hex format, prefix, suffix */ "0%o", "0%", "o", /* Octal format, prefix, suffix */ c_op_print_tab, /* expression operators for printing */ LANG_MAGIC }; const struct language_defn cplus_language_defn = { "c++", /* Language name */ language_cplus, c_builtin_types, range_check_off, type_check_off, c_parse, c_error, &BUILTIN_TYPE_LONGEST, /* longest signed integral type */ &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */ &builtin_type_double, /* longest floating point type */ /*FIXME*/ "0x%x", "0x%", "x", /* Hex format, prefix, suffix */ "0%o", "0%", "o", /* Octal format, prefix, suffix */ c_op_print_tab, /* expression operators for printing */ LANG_MAGIC }; void _initialize_c_exp () { builtin_type_void = init_type (TYPE_CODE_VOID, 1, 0, "void", (struct objfile *) NULL); builtin_type_char = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 0, "char", (struct objfile *) NULL); builtin_type_signed_char = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, TYPE_FLAG_SIGNED, "signed char", (struct objfile *) NULL); builtin_type_unsigned_char = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, TYPE_FLAG_UNSIGNED, "unsigned char", (struct objfile *) NULL); builtin_type_short = init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT, 0, "short", (struct objfile *) NULL); builtin_type_unsigned_short = init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT, TYPE_FLAG_UNSIGNED, "unsigned short", (struct objfile *) NULL); builtin_type_int = init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT, 0, "int", (struct objfile *) NULL); builtin_type_unsigned_int = init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT, TYPE_FLAG_UNSIGNED, "unsigned int", (struct objfile *) NULL); builtin_type_long = init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT, 0, "long", (struct objfile *) NULL); builtin_type_unsigned_long = init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT, TYPE_FLAG_UNSIGNED, "unsigned long", (struct objfile *) NULL); builtin_type_long_long = init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, 0, "long long", (struct objfile *) NULL); builtin_type_unsigned_long_long = init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, TYPE_FLAG_UNSIGNED, "unsigned long long", (struct objfile *) NULL); builtin_type_float = init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT, 0, "float", (struct objfile *) NULL); builtin_type_double = init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, 0, "double", (struct objfile *) NULL); builtin_type_long_double = init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, 0, "long double", (struct objfile *) NULL); builtin_type_complex = init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT, 0, "complex", (struct objfile *) NULL); builtin_type_double_complex = init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT, 0, "double complex", (struct objfile *) NULL); add_language (&c_language_defn); add_language (&cplus_language_defn); } int yyexca[] ={ -1, 1, 0, -1, -2, 0, -1, 47, 272, 66, -2, 130, -1, 131, 272, 95, -2, 126, -1, 180, 272, 67, -2, 68, }; # define YYNPROD 131 # define YYLAST 1050 int yyact[]={ 9, 183, 167, 182, 110, 7, 109, 15, 115, 6, 201, 115, 8, 184, 181, 111, 104, 106, 107, 108, 178, 122, 123, 116, 112, 113, 116, 96, 96, 98, 98, 95, 95, 192, 160, 102, 78, 59, 94, 49, 55, 176, 57, 9, 99, 55, 53, 58, 7, 200, 88, 53, 6, 105, 34, 8, 173, 39, 40, 41, 42, 78, 38, 100, 44, 31, 43, 36, 37, 35, 45, 46, 96, 185, 98, 49, 95, 206, 168, 214, 101, 101, 199, 208, 78, 193, 203, 9, 188, 204, 14, 54, 198, 10, 15, 199, 54, 78, 164, 165, 92, 2, 49, 210, 114, 59, 70, 101, 55, 211, 57, 60, 197, 61, 53, 58, 78, 189, 129, 133, 136, 162, 168, 30, 33, 101, 191, 28, 68, 76, 69, 75, 56, 14, 169, 170, 10, 174, 104, 106, 107, 108, 171, 97, 59, 22, 1, 55, 121, 57, 60, 3, 61, 53, 58, 135, 0, 0, 0, 54, 0, 172, 71, 0, 59, 70, 0, 55, 0, 57, 60, 56, 61, 53, 58, 105, 0, 14, 0, 0, 10, 0, 0, 0, 179, 0, 0, 68, 76, 69, 75, 56, 72, 0, 0, 0, 0, 0, 54, 0, 0, 0, 59, 0, 0, 55, 167, 57, 60, 0, 61, 53, 58, 0, 0, 0, 0, 0, 54, 0, 0, 71, 0, 0, 16, 20, 18, 21, 26, 48, 34, 17, 19, 39, 40, 41, 42, 13, 38, 32, 44, 0, 43, 36, 37, 35, 45, 46, 23, 24, 25, 72, 27, 213, 0, 0, 54, 0, 0, 0, 0, 163, 93, 11, 12, 0, 47, 16, 20, 18, 21, 26, 48, 34, 17, 19, 39, 40, 41, 42, 13, 38, 32, 44, 0, 43, 36, 37, 35, 45, 46, 23, 24, 25, 0, 27, 50, 51, 52, 0, 0, 50, 51, 52, 0, 0, 11, 12, 0, 47, 0, 16, 20, 18, 21, 26, 48, 34, 17, 19, 39, 40, 41, 42, 13, 38, 32, 44, 134, 43, 36, 37, 35, 45, 46, 23, 24, 25, 0, 27, 0, 0, 104, 106, 107, 108, 0, 0, 0, 0, 11, 12, 77, 47, 0, 74, 73, 64, 65, 66, 67, 62, 63, 0, 50, 51, 52, 0, 0, 0, 0, 0, 59, 70, 0, 55, 0, 57, 60, 105, 61, 53, 58, 59, 70, 0, 55, 0, 57, 60, 0, 61, 53, 58, 0, 68, 0, 69, 75, 56, 62, 63, 0, 50, 51, 52, 68, 0, 69, 0, 56, 77, 0, 0, 74, 73, 64, 65, 66, 67, 62, 63, 0, 50, 51, 52, 54, 130, 0, 71, 0, 0, 0, 59, 70, 0, 55, 54, 57, 60, 71, 61, 53, 58, 59, 70, 0, 55, 0, 57, 60, 0, 61, 53, 58, 0, 68, 0, 69, 72, 56, 50, 51, 52, 0, 0, 0, 68, 0, 69, 72, 56, 59, 70, 0, 55, 0, 57, 60, 0, 61, 53, 58, 59, 212, 0, 55, 54, 57, 60, 71, 61, 53, 58, 0, 68, 0, 69, 54, 56, 0, 71, 0, 0, 0, 0, 68, 0, 69, 0, 56, 0, 0, 59, 0, 0, 55, 0, 57, 60, 72, 61, 53, 58, 175, 0, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 54, 69, 0, 56, 0, 0, 0, 0, 0, 0, 0, 104, 131, 107, 108, 39, 40, 41, 42, 0, 38, 0, 44, 0, 43, 36, 37, 35, 45, 46, 54, 96, 0, 98, 175, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 105, 0, 59, 0, 0, 55, 0, 57, 60, 0, 61, 53, 58, 0, 0, 0, 0, 177, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 89, 91, 0, 0, 101, 74, 73, 64, 65, 66, 67, 62, 63, 0, 50, 51, 52, 73, 64, 65, 66, 67, 62, 63, 54, 50, 51, 52, 0, 0, 104, 131, 107, 108, 39, 40, 41, 42, 0, 38, 0, 44, 0, 43, 36, 37, 35, 45, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 105, 64, 65, 66, 67, 62, 63, 161, 50, 51, 52, 0, 64, 65, 66, 67, 62, 63, 0, 50, 51, 52, 34, 0, 0, 39, 40, 41, 42, 0, 38, 0, 44, 0, 43, 36, 37, 35, 45, 46, 64, 65, 66, 67, 62, 63, 0, 50, 51, 52, 0, 64, 65, 66, 67, 62, 63, 0, 50, 51, 52, 0, 34, 0, 0, 39, 40, 41, 42, 0, 38, 0, 44, 0, 43, 36, 37, 35, 45, 46, 0, 0, 0, 66, 67, 62, 63, 0, 50, 51, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 202, 0, 0, 0, 0, 34, 0, 0, 39, 40, 41, 42, 0, 38, 207, 44, 4, 43, 36, 37, 35, 45, 46, 79, 81, 82, 83, 84, 85, 86, 87, 103, 0, 0, 0, 0, 0, 0, 117, 118, 119, 120, 0, 124, 0, 0, 0, 0, 0, 80, 29, 128, 132, 0, 0, 0, 0, 0, 50, 51, 52, 0, 0, 0, 90, 29, 127, 0, 0, 0, 0, 0, 0, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 125, 126, 0, 0, 0, 0, 180, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 159, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 186, 90, 0, 0, 187, 0, 190, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 196, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 194, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 205, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 209, 0, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 90 }; int yypact[]={ -33, -1000, 31, -1000, 127, 76, -33, -33, -33, -33, -33, -33, -33, 10, -209, -33, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -10, -237, -1000, -246, -1000, -1000, -1000, -272, -263, -252, -246, -246, -246, -246, -255, -246, -209, -209, -1000, -1000, -33, -1000, -1000, 385, 286, -33, -1000, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -209, 5, -238, 5, 5, 5, 5, 5, 5, 5, -33, -4, -11, 57, 58, 80, -1000, 34, 34, 16, 530, -1000, -1000, -73, -246, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -264, -1000, -275, -265, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 13, -1000, -1000, 127, -1000, -1000, -33, -1000, -1000, -1000, -33, -5, -33, 165, 5, 5, 5, 0, 0, 550, 550, 476, 476, 107, 107, 107, 107, 446, 435, 407, 396, 346, 68, 127, 127, -239, -124, 44, -33, 36, -33, -1000, -1000, -246, -1000, -1000, -1000, -1000, -1000, 483, 71, -1000, 51, 76, -1000, -44, -1000, -1000, -1000, -268, -1000, -209, 5, 5, -1000, 45, 127, -33, 35, 54, 5, 5, -1000, -1000, -1000, -209, -1000, -1000, 21, -1000, -33, 335, 62, 76, -1000, 127, 69, 443, -1000, 38, -1000 }; int yypgo[]={ 0, 804, 100, 151, 146, 145, 65, 602, 837, 41, 63, 143, 38, 127, 44, 786, 124, 104, 123, 120, 117 }; int yyr1[]={ 0, 4, 4, 3, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 19, 1, 20, 20, 20, 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, 18, 18, 5, 6, 6, 5, 5, 5, 13, 13, 12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 14, 14, 10, 10, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 17, 17, 17, 17, 9, 9, 15, 15, 15, 15, 15, 16, 16 }; int yyr2[]={ 0, 2, 2, 3, 2, 7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 7, 7, 9, 7, 7, 9, 9, 1, 11, 0, 3, 7, 9, 9, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 11, 7, 7, 3, 3, 3, 3, 3, 3, 2, 3, 3, 3, 9, 3, 3, 3, 7, 7, 7, 9, 2, 5, 3, 2, 5, 3, 5, 3, 5, 2, 7, 5, 3, 5, 3, 5, 7, 5, 7, 2, 7, 13, 17, 19, 3, 3, 3, 3, 5, 7, 5, 7, 7, 9, 5, 7, 5, 5, 5, 5, 5, 3, 5, 3, 11, 5, 5, 2, 3, 3, 3, 3, 7, 3, 3, 3, 3, 3, 2, 2 }; int yychk[]={ -1000, -4, -2, -3, -1, -7, 42, 38, 45, 33, 126, 296, 297, 270, 123, 40, 257, 264, 259, 265, 258, 260, -5, 281, 282, 283, 261, 285, -13, -8, -18, -6, 272, -16, 263, 278, 276, 277, 271, 266, 267, 268, 269, 275, 273, 279, 280, 299, 262, 44, 296, 297, 298, 46, 91, 40, 64, 42, 47, 37, 43, 45, 293, 294, 289, 290, 291, 292, 60, 62, 38, 94, 124, 288, 287, 63, 61, 284, 40, -1, -8, -1, -1, -1, -1, -1, -1, -1, 40, -7, -8, -7, -2, 272, -12, 42, 38, -11, 40, -14, -10, 91, 272, -15, 262, 299, 263, 264, 265, 278, 276, 278, 276, 277, -17, 263, 278, -15, -15, -15, -15, -17, 276, 277, -15, -8, -8, -1, -15, -6, 42, 263, -15, -6, 42, -2, -19, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -8, 272, -7, 125, 272, 41, 41, -15, 126, 42, -12, -12, -14, -10, 40, -12, 41, -9, -7, 93, 257, -15, 278, 278, 276, 278, 60, -1, -1, 93, -20, -1, 58, 272, 41, -1, -1, -15, 41, 41, 44, 93, 278, -7, 41, 44, -1, 42, -7, 62, -1, 41, 40, 41, -9, 41 }; int yydef[]={ 0, -2, 1, 2, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 64, 65, 90, 74, 0, 71, 0, 73, 95, 96, 97, 98, 112, 0, 0, 0, 0, 114, 0, 0, 0, -2, 129, 0, 13, 14, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 7, 8, 9, 10, 11, 12, 15, 0, 0, 74, 0, 0, 0, 75, 76, 78, 80, 0, 83, 85, 0, 0, 72, 124, 125, 126, 127, 128, 99, 101, 105, 120, 121, 111, 118, 119, 107, 108, 109, 110, 113, 120, 121, 0, 116, 117, 5, 16, 17, 0, -2, 19, 20, 0, 0, 25, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 0, 51, 52, 0, 0, 0, 0, 0, 0, 30, 69, 0, 91, 77, 79, 82, 84, 0, 0, 88, 0, 122, 86, 0, -2, 102, 100, 103, 106, 0, 18, 21, 22, 0, 26, 0, 0, 63, 28, 29, 70, 81, 89, 0, 87, 104, 0, 24, 0, 50, 0, 123, 115, 27, 92, 0, 93, 0, 94 }; typedef struct { char *t_name; int t_val; } yytoktype; #ifndef YYDEBUG # define YYDEBUG 0 /* don't allow debugging */ #endif #if YYDEBUG yytoktype yytoks[] = { "INT", 257, "CHAR", 258, "UINT", 259, "FLOAT", 260, "STRING", 261, "NAME", 262, "TYPENAME", 263, "NAME_OR_INT", 264, "NAME_OR_UINT", 265, "STRUCT", 266, "CLASS", 267, "UNION", 268, "ENUM", 269, "SIZEOF", 270, "UNSIGNED", 271, "COLONCOLON", 272, "TEMPLATE", 273, "ERROR", 274, "SIGNED_KEYWORD", 275, "LONG", 276, "SHORT", 277, "INT_KEYWORD", 278, "CONST_KEYWORD", 279, "VOLATILE_KEYWORD", 280, "LAST", 281, "REGNAME", 282, "VARIABLE", 283, "ASSIGN_MODIFY", 284, "THIS", 285, ",", 44, "ABOVE_COMMA", 286, "=", 61, "?", 63, "OROR", 287, "ANDAND", 288, "|", 124, "^", 94, "&", 38, "EQUAL", 289, "NOTEQUAL", 290, "<", 60, ">", 62, "LEQ", 291, "GEQ", 292, "LSH", 293, "RSH", 294, "@", 64, "+", 43, "-", 45, "*", 42, "/", 47, "%", 37, "UNARY", 295, "INCREMENT", 296, "DECREMENT", 297, "ARROW", 298, ".", 46, "[", 91, "(", 40, "BLOCKNAME", 299, "-unknown-", -1 /* ends search */ }; char * yyreds[] = { "-no such reduction-", "start : exp1", "start : type_exp", "type_exp : type", "exp1 : exp", "exp1 : exp1 ',' exp", "exp : '*' exp", "exp : '&' exp", "exp : '-' exp", "exp : '!' exp", "exp : '~' exp", "exp : INCREMENT exp", "exp : DECREMENT exp", "exp : exp INCREMENT", "exp : exp DECREMENT", "exp : SIZEOF exp", "exp : exp ARROW name", "exp : exp ARROW qualified_name", "exp : exp ARROW '*' exp", "exp : exp '.' name", "exp : exp '.' qualified_name", "exp : exp '.' '*' exp", "exp : exp '[' exp1 ']'", "exp : exp '('", "exp : exp '(' arglist ')'", "arglist : /* empty */", "arglist : exp", "arglist : arglist ',' exp", "exp : '{' type '}' exp", "exp : '(' type ')' exp", "exp : '(' exp1 ')'", "exp : exp '@' exp", "exp : exp '*' exp", "exp : exp '/' exp", "exp : exp '%' exp", "exp : exp '+' exp", "exp : exp '-' exp", "exp : exp LSH exp", "exp : exp RSH exp", "exp : exp EQUAL exp", "exp : exp NOTEQUAL exp", "exp : exp LEQ exp", "exp : exp GEQ exp", "exp : exp '<' exp", "exp : exp '>' exp", "exp : exp '&' exp", "exp : exp '^' exp", "exp : exp '|' exp", "exp : exp ANDAND exp", "exp : exp OROR exp", "exp : exp '?' exp ':' exp", "exp : exp '=' exp", "exp : exp ASSIGN_MODIFY exp", "exp : INT", "exp : NAME_OR_INT", "exp : UINT", "exp : NAME_OR_UINT", "exp : CHAR", "exp : FLOAT", "exp : variable", "exp : LAST", "exp : REGNAME", "exp : VARIABLE", "exp : SIZEOF '(' type ')'", "exp : STRING", "exp : THIS", "block : BLOCKNAME", "block : block COLONCOLON name", "variable : block COLONCOLON name", "qualified_name : typebase COLONCOLON name", "qualified_name : typebase COLONCOLON '~' name", "variable : qualified_name", "variable : COLONCOLON name", "variable : name_not_typename", "ptype : typebase", "ptype : typebase abs_decl", "abs_decl : '*'", "abs_decl : '*' abs_decl", "abs_decl : '&'", "abs_decl : '&' abs_decl", "abs_decl : direct_abs_decl", "direct_abs_decl : '(' abs_decl ')'", "direct_abs_decl : direct_abs_decl array_mod", "direct_abs_decl : array_mod", "direct_abs_decl : direct_abs_decl func_mod", "direct_abs_decl : func_mod", "array_mod : '[' ']'", "array_mod : '[' INT ']'", "func_mod : '(' ')'", "func_mod : '(' nonempty_typelist ')'", "type : ptype", "type : typebase COLONCOLON '*'", "type : type '(' typebase COLONCOLON '*' ')'", "type : type '(' typebase COLONCOLON '*' ')' '(' ')'", "type : type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'", "typebase : TYPENAME", "typebase : INT_KEYWORD", "typebase : LONG", "typebase : SHORT", "typebase : LONG INT_KEYWORD", "typebase : UNSIGNED LONG INT_KEYWORD", "typebase : LONG LONG", "typebase : LONG LONG INT_KEYWORD", "typebase : UNSIGNED LONG LONG", "typebase : UNSIGNED LONG LONG INT_KEYWORD", "typebase : SHORT INT_KEYWORD", "typebase : UNSIGNED SHORT INT_KEYWORD", "typebase : STRUCT name", "typebase : CLASS name", "typebase : UNION name", "typebase : ENUM name", "typebase : UNSIGNED typename", "typebase : UNSIGNED", "typebase : SIGNED_KEYWORD typename", "typebase : SIGNED_KEYWORD", "typebase : TEMPLATE name '<' type '>'", "typebase : CONST_KEYWORD typebase", "typebase : VOLATILE_KEYWORD typebase", "typename : TYPENAME", "typename : INT_KEYWORD", "typename : LONG", "typename : SHORT", "nonempty_typelist : type", "nonempty_typelist : nonempty_typelist ',' type", "name : NAME", "name : BLOCKNAME", "name : TYPENAME", "name : NAME_OR_INT", "name : NAME_OR_UINT", "name_not_typename : NAME", "name_not_typename : BLOCKNAME", }; #endif /* YYDEBUG */ #line 1 "/usr/lib/yaccpar" /* @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10 */ /* ** Skeleton parser driver for yacc output */ /* ** yacc user known macros and defines */ #define YYERROR goto yyerrlab #define YYACCEPT { free(yys); free(yyv); return(0); } #define YYABORT { free(yys); free(yyv); return(1); } #define YYBACKUP( newtoken, newvalue )\ {\ if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ {\ yyerror( "syntax error - cannot backup" );\ goto yyerrlab;\ }\ yychar = newtoken;\ yystate = *yyps;\ yylval = newvalue;\ goto yynewstate;\ } #define YYRECOVERING() (!!yyerrflag) #ifndef YYDEBUG # define YYDEBUG 1 /* make debugging available */ #endif /* ** user known globals */ int yydebug; /* set to 1 to get debugging */ /* ** driver internal defines */ #define YYFLAG (-1000) /* ** static variables used by the parser */ static YYSTYPE *yyv; /* value stack */ static int *yys; /* state stack */ static YYSTYPE *yypv; /* top of value stack */ static int *yyps; /* top of state stack */ static int yystate; /* current state */ static int yytmp; /* extra var (lasts between blocks) */ int yynerrs; /* number of errors */ int yyerrflag; /* error recovery flag */ int yychar; /* current input token number */ /* ** yyparse - return 0 if worked, 1 if syntax error not recovered from */ int yyparse() { register YYSTYPE *yypvt; /* top of value stack for $vars */ unsigned yymaxdepth = YYMAXDEPTH; /* ** Initialize externals - yyparse may be called more than once */ yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE)); yys = (int*)malloc(yymaxdepth*sizeof(int)); if (!yyv || !yys) { yyerror( "out of memory" ); return(1); } yypv = &yyv[-1]; yyps = &yys[-1]; yystate = 0; yytmp = 0; yynerrs = 0; yyerrflag = 0; yychar = -1; goto yystack; { register YYSTYPE *yy_pv; /* top of value stack */ register int *yy_ps; /* top of state stack */ register int yy_state; /* current state */ register int yy_n; /* internal state number info */ /* ** get globals into registers. ** branch to here only if YYBACKUP was called. */ yynewstate: yy_pv = yypv; yy_ps = yyps; yy_state = yystate; goto yy_newstate; /* ** get globals into registers. ** either we just started, or we just finished a reduction */ yystack: yy_pv = yypv; yy_ps = yyps; yy_state = yystate; /* ** top of for (;;) loop while no reductions done */ yy_stack: /* ** put a state and value onto the stacks */ #if YYDEBUG /* ** if debugging, look up token value in list of value vs. ** name pairs. 0 and negative (-1) are special values. ** Note: linear search is used since time is not a real ** consideration while debugging. */ if ( yydebug ) { register int yy_i; (void)printf( "State %d, token ", yy_state ); if ( yychar == 0 ) (void)printf( "end-of-file\n" ); else if ( yychar < 0 ) (void)printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } (void)printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */ { /* ** reallocate and recover. Note that pointers ** have to be reset, or bad things will happen */ int yyps_index = (yy_ps - yys); int yypv_index = (yy_pv - yyv); int yypvt_index = (yypvt - yyv); yymaxdepth += YYMAXDEPTH; yyv = (YYSTYPE*)realloc((char*)yyv, yymaxdepth * sizeof(YYSTYPE)); yys = (int*)realloc((char*)yys, yymaxdepth * sizeof(int)); if (!yyv || !yys) { yyerror( "yacc stack overflow" ); return(1); } yy_ps = yys + yyps_index; yy_pv = yyv + yypv_index; yypvt = yyv + yypvt_index; } *yy_ps = yy_state; *++yy_pv = yyval; /* ** we have a new state - find out what to do */ yy_newstate: if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) goto yydefault; /* simple state */ #if YYDEBUG /* ** if debugging, need to mark whether new token grabbed */ yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; (void)printf( "Received token " ); if ( yychar == 0 ) (void)printf( "end-of-file\n" ); else if ( yychar < 0 ) (void)printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } (void)printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) goto yydefault; if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ { yychar = -1; yyval = yylval; yy_state = yy_n; if ( yyerrflag > 0 ) yyerrflag--; goto yy_stack; } yydefault: if ( ( yy_n = yydef[ yy_state ] ) == -2 ) { #if YYDEBUG yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; (void)printf( "Received token " ); if ( yychar == 0 ) (void)printf( "end-of-file\n" ); else if ( yychar < 0 ) (void)printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } (void)printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ /* ** look through exception table */ { register int *yyxi = yyexca; while ( ( *yyxi != -1 ) || ( yyxi[1] != yy_state ) ) { yyxi += 2; } while ( ( *(yyxi += 2) >= 0 ) && ( *yyxi != yychar ) ) ; if ( ( yy_n = yyxi[1] ) < 0 ) YYACCEPT; } } /* ** check for syntax error */ if ( yy_n == 0 ) /* have an error */ { /* no worry about speed here! */ switch ( yyerrflag ) { case 0: /* new error */ yyerror( "syntax error" ); goto skip_init; yyerrlab: /* ** get globals into registers. ** we have a user generated syntax type error */ yy_pv = yypv; yy_ps = yyps; yy_state = yystate; yynerrs++; skip_init: case 1: case 2: /* incompletely recovered error */ /* try again... */ yyerrflag = 3; /* ** find state where "error" is a legal ** shift action */ while ( yy_ps >= yys ) { yy_n = yypact[ *yy_ps ] + YYERRCODE; if ( yy_n >= 0 && yy_n < YYLAST && yychk[yyact[yy_n]] == YYERRCODE) { /* ** simulate shift of "error" */ yy_state = yyact[ yy_n ]; goto yy_stack; } /* ** current state has no shift on ** "error", pop stack */ #if YYDEBUG # define _POP_ "Error recovery pops state %d, uncovers state %d\n" if ( yydebug ) (void)printf( _POP_, *yy_ps, yy_ps[-1] ); # undef _POP_ #endif yy_ps--; yy_pv--; } /* ** there is no state on stack with "error" as ** a valid shift. give up. */ YYABORT; case 3: /* no shift yet; eat a token */ #if YYDEBUG /* ** if debugging, look up token in list of ** pairs. 0 and negative shouldn't occur, ** but since timing doesn't matter when ** debugging, it doesn't hurt to leave the ** tests here. */ if ( yydebug ) { register int yy_i; (void)printf( "Error recovery discards " ); if ( yychar == 0 ) (void)printf( "token end-of-file\n" ); else if ( yychar < 0 ) (void)printf( "token -none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } (void)printf( "token %s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( yychar == 0 ) /* reached EOF. quit */ YYABORT; yychar = -1; goto yy_newstate; } }/* end if ( yy_n == 0 ) */ /* ** reduction by production yy_n ** put stack tops, etc. so things right after switch */ #if YYDEBUG /* ** if debugging, print the string that is the user's ** specification of the reduction which is just about ** to be done. */ if ( yydebug ) (void)printf( "Reduce by (%d) \"%s\"\n", yy_n, yyreds[ yy_n ] ); #endif yytmp = yy_n; /* value to switch over */ yypvt = yy_pv; /* $vars top of value stack */ /* ** Look in goto table for next state ** Sorry about using yy_state here as temporary ** register variable, but why not, if it works... ** If yyr2[ yy_n ] doesn't have the low order bit ** set, then there is no action to be done for ** this reduction. So, no saving & unsaving of ** registers done. The only difference between the ** code just after the if and the body of the if is ** the goto yy_stack in the body. This way the test ** can be made before the choice of what to do is needed. */ { /* length of production doubled with extra bit */ register int yy_len = yyr2[ yy_n ]; if ( !( yy_len & 01 ) ) { yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } goto yy_stack; } yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } } /* save until reenter driver code */ yystate = yy_state; yyps = yy_ps; yypv = yy_pv; } /* ** code supplied by user is placed in this switch */ switch( yytmp ) { case 3: # line 216 "./c-exp.y" { write_exp_elt_opcode(OP_TYPE); write_exp_elt_type(yypvt[-0].tval); write_exp_elt_opcode(OP_TYPE);} break; case 5: # line 224 "./c-exp.y" { write_exp_elt_opcode (BINOP_COMMA); } break; case 6: # line 229 "./c-exp.y" { write_exp_elt_opcode (UNOP_IND); } break; case 7: # line 232 "./c-exp.y" { write_exp_elt_opcode (UNOP_ADDR); } break; case 8: # line 235 "./c-exp.y" { write_exp_elt_opcode (UNOP_NEG); } break; case 9: # line 239 "./c-exp.y" { write_exp_elt_opcode (UNOP_ZEROP); } break; case 10: # line 243 "./c-exp.y" { write_exp_elt_opcode (UNOP_LOGNOT); } break; case 11: # line 247 "./c-exp.y" { write_exp_elt_opcode (UNOP_PREINCREMENT); } break; case 12: # line 251 "./c-exp.y" { write_exp_elt_opcode (UNOP_PREDECREMENT); } break; case 13: # line 255 "./c-exp.y" { write_exp_elt_opcode (UNOP_POSTINCREMENT); } break; case 14: # line 259 "./c-exp.y" { write_exp_elt_opcode (UNOP_POSTDECREMENT); } break; case 15: # line 263 "./c-exp.y" { write_exp_elt_opcode (UNOP_SIZEOF); } break; case 16: # line 267 "./c-exp.y" { write_exp_elt_opcode (STRUCTOP_PTR); write_exp_string (yypvt[-0].sval); write_exp_elt_opcode (STRUCTOP_PTR); } break; case 17: # line 273 "./c-exp.y" { /* exp->type::name becomes exp->*(&type::name) */ /* Note: this doesn't work if name is a static member! FIXME */ write_exp_elt_opcode (UNOP_ADDR); write_exp_elt_opcode (STRUCTOP_MPTR); } break; case 18: # line 280 "./c-exp.y" { write_exp_elt_opcode (STRUCTOP_MPTR); } break; case 19: # line 284 "./c-exp.y" { write_exp_elt_opcode (STRUCTOP_STRUCT); write_exp_string (yypvt[-0].sval); write_exp_elt_opcode (STRUCTOP_STRUCT); } break; case 20: # line 290 "./c-exp.y" { /* exp.type::name becomes exp.*(&type::name) */ /* Note: this doesn't work if name is a static member! FIXME */ write_exp_elt_opcode (UNOP_ADDR); write_exp_elt_opcode (STRUCTOP_MEMBER); } break; case 21: # line 298 "./c-exp.y" { write_exp_elt_opcode (STRUCTOP_MEMBER); } break; case 22: # line 302 "./c-exp.y" { write_exp_elt_opcode (BINOP_SUBSCRIPT); } break; case 23: # line 308 "./c-exp.y" { start_arglist (); } break; case 24: # line 310 "./c-exp.y" { write_exp_elt_opcode (OP_FUNCALL); write_exp_elt_longcst ((LONGEST) end_arglist ()); write_exp_elt_opcode (OP_FUNCALL); } break; case 26: # line 319 "./c-exp.y" { arglist_len = 1; } break; case 27: # line 323 "./c-exp.y" { arglist_len++; } break; case 28: # line 327 "./c-exp.y" { write_exp_elt_opcode (UNOP_MEMVAL); write_exp_elt_type (yypvt[-2].tval); write_exp_elt_opcode (UNOP_MEMVAL); } break; case 29: # line 333 "./c-exp.y" { write_exp_elt_opcode (UNOP_CAST); write_exp_elt_type (yypvt[-2].tval); write_exp_elt_opcode (UNOP_CAST); } break; case 30: # line 339 "./c-exp.y" { } break; case 31: # line 345 "./c-exp.y" { write_exp_elt_opcode (BINOP_REPEAT); } break; case 32: # line 349 "./c-exp.y" { write_exp_elt_opcode (BINOP_MUL); } break; case 33: # line 353 "./c-exp.y" { write_exp_elt_opcode (BINOP_DIV); } break; case 34: # line 357 "./c-exp.y" { write_exp_elt_opcode (BINOP_REM); } break; case 35: # line 361 "./c-exp.y" { write_exp_elt_opcode (BINOP_ADD); } break; case 36: # line 365 "./c-exp.y" { write_exp_elt_opcode (BINOP_SUB); } break; case 37: # line 369 "./c-exp.y" { write_exp_elt_opcode (BINOP_LSH); } break; case 38: # line 373 "./c-exp.y" { write_exp_elt_opcode (BINOP_RSH); } break; case 39: # line 377 "./c-exp.y" { write_exp_elt_opcode (BINOP_EQUAL); } break; case 40: # line 381 "./c-exp.y" { write_exp_elt_opcode (BINOP_NOTEQUAL); } break; case 41: # line 385 "./c-exp.y" { write_exp_elt_opcode (BINOP_LEQ); } break; case 42: # line 389 "./c-exp.y" { write_exp_elt_opcode (BINOP_GEQ); } break; case 43: # line 393 "./c-exp.y" { write_exp_elt_opcode (BINOP_LESS); } break; case 44: # line 397 "./c-exp.y" { write_exp_elt_opcode (BINOP_GTR); } break; case 45: # line 401 "./c-exp.y" { write_exp_elt_opcode (BINOP_LOGAND); } break; case 46: # line 405 "./c-exp.y" { write_exp_elt_opcode (BINOP_LOGXOR); } break; case 47: # line 409 "./c-exp.y" { write_exp_elt_opcode (BINOP_LOGIOR); } break; case 48: # line 413 "./c-exp.y" { write_exp_elt_opcode (BINOP_AND); } break; case 49: # line 417 "./c-exp.y" { write_exp_elt_opcode (BINOP_OR); } break; case 50: # line 421 "./c-exp.y" { write_exp_elt_opcode (TERNOP_COND); } break; case 51: # line 425 "./c-exp.y" { write_exp_elt_opcode (BINOP_ASSIGN); } break; case 52: # line 429 "./c-exp.y" { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); write_exp_elt_opcode (yypvt[-1].opcode); write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); } break; case 53: # line 435 "./c-exp.y" { write_exp_elt_opcode (OP_LONG); if (yypvt[-0].lval == (int) yypvt[-0].lval || yypvt[-0].lval == (unsigned int) yypvt[-0].lval) write_exp_elt_type (builtin_type_int); else write_exp_elt_type (BUILTIN_TYPE_LONGEST); write_exp_elt_longcst ((LONGEST) yypvt[-0].lval); write_exp_elt_opcode (OP_LONG); } break; case 54: # line 445 "./c-exp.y" { YYSTYPE val; parse_number (yypvt[-0].ssym.stoken.ptr, yypvt[-0].ssym.stoken.length, 0, &val); write_exp_elt_opcode (OP_LONG); if (val.lval == (int) val.lval || val.lval == (unsigned int) val.lval) write_exp_elt_type (builtin_type_int); else write_exp_elt_type (BUILTIN_TYPE_LONGEST); write_exp_elt_longcst (val.lval); write_exp_elt_opcode (OP_LONG); } break; case 55: # line 458 "./c-exp.y" { write_exp_elt_opcode (OP_LONG); if (yypvt[-0].ulval == (unsigned int) yypvt[-0].ulval) write_exp_elt_type (builtin_type_unsigned_int); else write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST); write_exp_elt_longcst ((LONGEST) yypvt[-0].ulval); write_exp_elt_opcode (OP_LONG); } break; case 56: # line 470 "./c-exp.y" { YYSTYPE val; parse_number (yypvt[-0].ssym.stoken.ptr, yypvt[-0].ssym.stoken.length, 0, &val); write_exp_elt_opcode (OP_LONG); if (val.ulval == (unsigned int) val.ulval) write_exp_elt_type (builtin_type_unsigned_int); else write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST); write_exp_elt_longcst ((LONGEST)val.ulval); write_exp_elt_opcode (OP_LONG); } break; case 57: # line 483 "./c-exp.y" { write_exp_elt_opcode (OP_LONG); write_exp_elt_type (builtin_type_char); write_exp_elt_longcst ((LONGEST) yypvt[-0].lval); write_exp_elt_opcode (OP_LONG); } break; case 58: # line 490 "./c-exp.y" { write_exp_elt_opcode (OP_DOUBLE); write_exp_elt_type (builtin_type_double); write_exp_elt_dblcst (yypvt[-0].dval); write_exp_elt_opcode (OP_DOUBLE); } break; case 60: # line 500 "./c-exp.y" { write_exp_elt_opcode (OP_LAST); write_exp_elt_longcst ((LONGEST) yypvt[-0].lval); write_exp_elt_opcode (OP_LAST); } break; case 61: # line 506 "./c-exp.y" { write_exp_elt_opcode (OP_REGISTER); write_exp_elt_longcst ((LONGEST) yypvt[-0].lval); write_exp_elt_opcode (OP_REGISTER); } break; case 62: # line 512 "./c-exp.y" { write_exp_elt_opcode (OP_INTERNALVAR); write_exp_elt_intern (yypvt[-0].ivar); write_exp_elt_opcode (OP_INTERNALVAR); } break; case 63: # line 518 "./c-exp.y" { write_exp_elt_opcode (OP_LONG); write_exp_elt_type (builtin_type_int); write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yypvt[-1].tval)); write_exp_elt_opcode (OP_LONG); } break; case 64: # line 525 "./c-exp.y" { write_exp_elt_opcode (OP_STRING); write_exp_string (yypvt[-0].sval); write_exp_elt_opcode (OP_STRING); } break; case 65: # line 532 "./c-exp.y" { write_exp_elt_opcode (OP_THIS); write_exp_elt_opcode (OP_THIS); } break; case 66: # line 539 "./c-exp.y" { if (yypvt[-0].ssym.sym != 0) yyval.bval = SYMBOL_BLOCK_VALUE (yypvt[-0].ssym.sym); else { struct symtab *tem = lookup_symtab (copy_name (yypvt[-0].ssym.stoken)); if (tem) yyval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK); else error ("No file or function \"%s\".", copy_name (yypvt[-0].ssym.stoken)); } } break; case 67: # line 557 "./c-exp.y" { struct symbol *tem = lookup_symbol (copy_name (yypvt[-0].sval), yypvt[-2].bval, VAR_NAMESPACE, 0, NULL); if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK) error ("No function \"%s\" in specified context.", copy_name (yypvt[-0].sval)); yyval.bval = SYMBOL_BLOCK_VALUE (tem); } break; case 68: # line 567 "./c-exp.y" { struct symbol *sym; sym = lookup_symbol (copy_name (yypvt[-0].sval), yypvt[-2].bval, VAR_NAMESPACE, 0, NULL); if (sym == 0) error ("No symbol \"%s\" in specified context.", copy_name (yypvt[-0].sval)); write_exp_elt_opcode (OP_VAR_VALUE); write_exp_elt_sym (sym); write_exp_elt_opcode (OP_VAR_VALUE); } break; case 69: # line 580 "./c-exp.y" { struct type *type = yypvt[-2].tval; if (TYPE_CODE (type) != TYPE_CODE_STRUCT && TYPE_CODE (type) != TYPE_CODE_UNION) error ("`%s' is not defined as an aggregate type.", TYPE_NAME (type)); write_exp_elt_opcode (OP_SCOPE); write_exp_elt_type (type); write_exp_string (yypvt[-0].sval); write_exp_elt_opcode (OP_SCOPE); } break; case 70: # line 593 "./c-exp.y" { struct type *type = yypvt[-3].tval; struct stoken tmp_token; if (TYPE_CODE (type) != TYPE_CODE_STRUCT && TYPE_CODE (type) != TYPE_CODE_UNION) error ("`%s' is not defined as an aggregate type.", TYPE_NAME (type)); if (strcmp (type_name_no_tag (type), yypvt[-0].sval.ptr)) error ("invalid destructor `%s::~%s'", type_name_no_tag (type), yypvt[-0].sval.ptr); tmp_token.ptr = (char*) alloca (yypvt[-0].sval.length + 2); tmp_token.length = yypvt[-0].sval.length + 1; tmp_token.ptr[0] = '~'; memcpy (tmp_token.ptr+1, yypvt[-0].sval.ptr, yypvt[-0].sval.length); tmp_token.ptr[tmp_token.length] = 0; write_exp_elt_opcode (OP_SCOPE); write_exp_elt_type (type); write_exp_string (tmp_token); write_exp_elt_opcode (OP_SCOPE); } break; case 72: # line 619 "./c-exp.y" { char *name = copy_name (yypvt[-0].sval); struct symbol *sym; struct minimal_symbol *msymbol; sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL); if (sym) { write_exp_elt_opcode (OP_VAR_VALUE); write_exp_elt_sym (sym); write_exp_elt_opcode (OP_VAR_VALUE); break; } msymbol = lookup_minimal_symbol (name, (struct objfile *) NULL); if (msymbol != NULL) { write_exp_elt_opcode (OP_LONG); write_exp_elt_type (builtin_type_int); write_exp_elt_longcst ((LONGEST) msymbol -> address); write_exp_elt_opcode (OP_LONG); write_exp_elt_opcode (UNOP_MEMVAL); if (msymbol -> type == mst_data || msymbol -> type == mst_bss) write_exp_elt_type (builtin_type_int); else if (msymbol -> type == mst_text) write_exp_elt_type (lookup_function_type (builtin_type_int)); else write_exp_elt_type (builtin_type_char); write_exp_elt_opcode (UNOP_MEMVAL); } else if (!have_full_symbols () && !have_partial_symbols ()) error ("No symbol table is loaded. Use the \"file\" command."); else error ("No symbol \"%s\" in current context.", name); } break; case 73: # line 661 "./c-exp.y" { struct symbol *sym = yypvt[-0].ssym.sym; if (sym) { switch (SYMBOL_CLASS (sym)) { case LOC_REGISTER: case LOC_ARG: case LOC_REF_ARG: case LOC_REGPARM: case LOC_LOCAL: case LOC_LOCAL_ARG: if (innermost_block == 0 || contained_in (block_found, innermost_block)) innermost_block = block_found; case LOC_UNDEF: case LOC_CONST: case LOC_STATIC: case LOC_TYPEDEF: case LOC_LABEL: case LOC_BLOCK: case LOC_CONST_BYTES: /* In this case the expression can be evaluated regardless of what frame we are in, so there is no need to check for the innermost_block. These cases are listed so that gcc -Wall will report types that may not have been considered. */ break; } write_exp_elt_opcode (OP_VAR_VALUE); write_exp_elt_sym (sym); write_exp_elt_opcode (OP_VAR_VALUE); } else if (yypvt[-0].ssym.is_a_field_of_this) { /* C++: it hangs off of `this'. Must not inadvertently convert from a method call to data ref. */ if (innermost_block == 0 || contained_in (block_found, innermost_block)) innermost_block = block_found; write_exp_elt_opcode (OP_THIS); write_exp_elt_opcode (OP_THIS); write_exp_elt_opcode (STRUCTOP_PTR); write_exp_string (yypvt[-0].ssym.stoken); write_exp_elt_opcode (STRUCTOP_PTR); } else { struct minimal_symbol *msymbol; register char *arg = copy_name (yypvt[-0].ssym.stoken); msymbol = lookup_minimal_symbol (arg, (struct objfile *) NULL); if (msymbol != NULL) { write_exp_elt_opcode (OP_LONG); write_exp_elt_type (builtin_type_int); write_exp_elt_longcst ((LONGEST) msymbol -> address); write_exp_elt_opcode (OP_LONG); write_exp_elt_opcode (UNOP_MEMVAL); if (msymbol -> type == mst_data || msymbol -> type == mst_bss) write_exp_elt_type (builtin_type_int); else if (msymbol -> type == mst_text) write_exp_elt_type (lookup_function_type (builtin_type_int)); else write_exp_elt_type (builtin_type_char); write_exp_elt_opcode (UNOP_MEMVAL); } else if (!have_full_symbols () && !have_partial_symbols ()) error ("No symbol table is loaded. Use the \"file\" command."); else error ("No symbol \"%s\" in current context.", copy_name (yypvt[-0].ssym.stoken)); } } break; case 75: # line 749 "./c-exp.y" { /* This is where the interesting stuff happens. */ int done = 0; int array_size; struct type *follow_type = yypvt[-1].tval; while (!done) switch (pop_type ()) { case tp_end: done = 1; break; case tp_pointer: follow_type = lookup_pointer_type (follow_type); break; case tp_reference: follow_type = lookup_reference_type (follow_type); break; case tp_array: array_size = pop_type_int (); if (array_size != -1) follow_type = create_array_type (follow_type, array_size); else follow_type = lookup_pointer_type (follow_type); break; case tp_function: follow_type = lookup_function_type (follow_type); break; } yyval.tval = follow_type; } break; case 76: # line 784 "./c-exp.y" { push_type (tp_pointer); yyval.voidval = 0; } break; case 77: # line 786 "./c-exp.y" { push_type (tp_pointer); yyval.voidval = yypvt[-0].voidval; } break; case 78: # line 788 "./c-exp.y" { push_type (tp_reference); yyval.voidval = 0; } break; case 79: # line 790 "./c-exp.y" { push_type (tp_reference); yyval.voidval = yypvt[-0].voidval; } break; case 81: # line 795 "./c-exp.y" { yyval.voidval = yypvt[-1].voidval; } break; case 82: # line 797 "./c-exp.y" { push_type_int (yypvt[-0].lval); push_type (tp_array); } break; case 83: # line 802 "./c-exp.y" { push_type_int (yypvt[-0].lval); push_type (tp_array); yyval.voidval = 0; } break; case 84: # line 808 "./c-exp.y" { push_type (tp_function); } break; case 85: # line 810 "./c-exp.y" { push_type (tp_function); } break; case 86: # line 814 "./c-exp.y" { yyval.lval = -1; } break; case 87: # line 816 "./c-exp.y" { yyval.lval = yypvt[-1].lval; } break; case 88: # line 820 "./c-exp.y" { yyval.voidval = 0; } break; case 89: # line 822 "./c-exp.y" { free ((PTR)yypvt[-1].tvec); yyval.voidval = 0; } break; case 91: # line 827 "./c-exp.y" { yyval.tval = lookup_member_type (builtin_type_int, yypvt[-2].tval); } break; case 92: # line 829 "./c-exp.y" { yyval.tval = lookup_member_type (yypvt[-5].tval, yypvt[-3].tval); } break; case 93: # line 831 "./c-exp.y" { yyval.tval = lookup_member_type (lookup_function_type (yypvt[-7].tval), yypvt[-5].tval); } break; case 94: # line 834 "./c-exp.y" { yyval.tval = lookup_member_type (lookup_function_type (yypvt[-8].tval), yypvt[-6].tval); free ((PTR)yypvt[-1].tvec); } break; case 95: # line 841 "./c-exp.y" { yyval.tval = yypvt[-0].tsym.type; } break; case 96: # line 843 "./c-exp.y" { yyval.tval = builtin_type_int; } break; case 97: # line 845 "./c-exp.y" { yyval.tval = builtin_type_long; } break; case 98: # line 847 "./c-exp.y" { yyval.tval = builtin_type_short; } break; case 99: # line 849 "./c-exp.y" { yyval.tval = builtin_type_long; } break; case 100: # line 851 "./c-exp.y" { yyval.tval = builtin_type_unsigned_long; } break; case 101: # line 853 "./c-exp.y" { yyval.tval = builtin_type_long_long; } break; case 102: # line 855 "./c-exp.y" { yyval.tval = builtin_type_long_long; } break; case 103: # line 857 "./c-exp.y" { yyval.tval = builtin_type_unsigned_long_long; } break; case 104: # line 859 "./c-exp.y" { yyval.tval = builtin_type_unsigned_long_long; } break; case 105: # line 861 "./c-exp.y" { yyval.tval = builtin_type_short; } break; case 106: # line 863 "./c-exp.y" { yyval.tval = builtin_type_unsigned_short; } break; case 107: # line 865 "./c-exp.y" { yyval.tval = lookup_struct (copy_name (yypvt[-0].sval), expression_context_block); } break; case 108: # line 868 "./c-exp.y" { yyval.tval = lookup_struct (copy_name (yypvt[-0].sval), expression_context_block); } break; case 109: # line 871 "./c-exp.y" { yyval.tval = lookup_union (copy_name (yypvt[-0].sval), expression_context_block); } break; case 110: # line 874 "./c-exp.y" { yyval.tval = lookup_enum (copy_name (yypvt[-0].sval), expression_context_block); } break; case 111: # line 877 "./c-exp.y" { yyval.tval = lookup_unsigned_typename (TYPE_NAME(yypvt[-0].tsym.type)); } break; case 112: # line 879 "./c-exp.y" { yyval.tval = builtin_type_unsigned_int; } break; case 113: # line 881 "./c-exp.y" { yyval.tval = lookup_signed_typename (TYPE_NAME(yypvt[-0].tsym.type)); } break; case 114: # line 883 "./c-exp.y" { yyval.tval = builtin_type_int; } break; case 115: # line 885 "./c-exp.y" { yyval.tval = lookup_template_type(copy_name(yypvt[-3].sval), yypvt[-1].tval, expression_context_block); } break; case 116: # line 889 "./c-exp.y" { yyval.tval = yypvt[-0].tval; } break; case 117: # line 890 "./c-exp.y" { yyval.tval = yypvt[-0].tval; } break; case 119: # line 895 "./c-exp.y" { yyval.tsym.stoken.ptr = "int"; yyval.tsym.stoken.length = 3; yyval.tsym.type = builtin_type_int; } break; case 120: # line 901 "./c-exp.y" { yyval.tsym.stoken.ptr = "long"; yyval.tsym.stoken.length = 4; yyval.tsym.type = builtin_type_long; } break; case 121: # line 907 "./c-exp.y" { yyval.tsym.stoken.ptr = "short"; yyval.tsym.stoken.length = 5; yyval.tsym.type = builtin_type_short; } break; case 122: # line 916 "./c-exp.y" { yyval.tvec = (struct type **) xmalloc (sizeof (struct type *) * 2); yyval.ivec[0] = 1; /* Number of types in vector */ yyval.tvec[1] = yypvt[-0].tval; } break; case 123: # line 921 "./c-exp.y" { int len = sizeof (struct type *) * (++(yypvt[-2].ivec[0]) + 1); yyval.tvec = (struct type **) xrealloc ((char *) yypvt[-2].tvec, len); yyval.tvec[yyval.ivec[0]] = yypvt[-0].tval; } break; case 124: # line 927 "./c-exp.y" { yyval.sval = yypvt[-0].ssym.stoken; } break; case 125: # line 928 "./c-exp.y" { yyval.sval = yypvt[-0].ssym.stoken; } break; case 126: # line 929 "./c-exp.y" { yyval.sval = yypvt[-0].tsym.stoken; } break; case 127: # line 930 "./c-exp.y" { yyval.sval = yypvt[-0].ssym.stoken; } break; case 128: # line 931 "./c-exp.y" { yyval.sval = yypvt[-0].ssym.stoken; } break; } goto yystack; /* reset registers in driver code */ }