Go to:
Gentoo Home
Documentation
Forums
Lists
Bugs
Planet
Store
Wiki
Get Gentoo!
Gentoo's Bugzilla – Attachment 160268 Details for
Bug 231695
=gnome-extra/gcalctool-5.22.3 fails with sys-devel/flex-2.5.33* (2.5.35 fixes the bug)
Home
|
New
–
[Ex]
|
Browse
|
Search
|
Privacy Policy
|
[?]
|
Reports
|
Requests
|
Help
|
New Account
|
Log In
[x]
|
Forgot Password
Login:
[x]
The file that causes the failure
lr_parser.tab.c (text/plain), 54.97 KB, created by
Serkan Kaba (RETIRED)
on 2008-07-13 15:38:55 UTC
(
hide
)
Description:
The file that causes the failure
Filename:
MIME Type:
Creator:
Serkan Kaba (RETIRED)
Created:
2008-07-13 15:38:55 UTC
Size:
54.97 KB
patch
obsolete
>/* A Bison parser, made by GNU Bison 2.3. */ > >/* Skeleton implementation for Bison's Yacc-like parsers in C > > Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 > 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., 51 Franklin Street, Fifth Floor, > Boston, MA 02110-1301, USA. */ > >/* As a special exception, you may create a larger work that contains > part or all of the Bison parser skeleton and distribute that work > under terms of your choice, so long as that work isn't itself a > parser generator using the skeleton or a modified version thereof > as a parser skeleton. Alternatively, if you modify or redistribute > the parser skeleton itself, you may (at your option) remove this > special exception, which will cause the skeleton and the resulting > Bison output files to be licensed under the GNU General Public > License without this special exception. > > This special exception was added by the Free Software Foundation in > version 2.2 of Bison. */ > >/* C LALR(1) parser skeleton 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 > >/* Bison version. */ >#define YYBISON_VERSION "2.3" > >/* Skeleton name. */ >#define YYSKELETON_NAME "yacc.c" > >/* Pure parsers. */ >#define YYPURE 0 > >/* Using locations. */ >#define YYLSP_NEEDED 0 > >/* Substitute the variable and function names. */ >#define yyparse lrparse >#define yylex lrlex >#define yyerror lrerror >#define yylval lrlval >#define yychar lrchar >#define yydebug lrdebug >#define yynerrs lrnerrs > > >/* Tokens. */ >#ifndef YYTOKENTYPE ># define YYTOKENTYPE > /* Put the tokens into the symbol table, so that GDB and other debuggers > know about them. */ > enum yytokentype { > NEG = 258, > tABS = 259, > tACOS = 260, > tACOSH = 261, > tAND = 262, > tANS = 263, > tASIN = 264, > tASINH = 265, > tATAN = 266, > tATANH = 267, > tCBRT = 268, > tCHS = 269, > tCOS = 270, > tCOSH = 271, > tDDB = 272, > tEXP = 273, > tFRAC = 274, > tFV = 275, > tINT = 276, > tLN = 277, > tLOG10 = 278, > tLOG2 = 279, > tNOT = 280, > tOR = 281, > tPI = 282, > tPMT = 283, > tPV = 284, > tRAND = 285, > tRATE = 286, > tSIN = 287, > tSINH = 288, > tSLN = 289, > tSQRT = 290, > tSYD = 291, > tTAN = 292, > tTANH = 293, > tTERM = 294, > tU16 = 295, > tU32 = 296, > tXNOR = 297, > tXOR = 298, > tRCL = 299, > tSTO = 300, > tCLR = 301, > tINUMBER = 302, > tDNUMBER = 303, > POS = 304 > }; >#endif >/* Tokens. */ >#define NEG 258 >#define tABS 259 >#define tACOS 260 >#define tACOSH 261 >#define tAND 262 >#define tANS 263 >#define tASIN 264 >#define tASINH 265 >#define tATAN 266 >#define tATANH 267 >#define tCBRT 268 >#define tCHS 269 >#define tCOS 270 >#define tCOSH 271 >#define tDDB 272 >#define tEXP 273 >#define tFRAC 274 >#define tFV 275 >#define tINT 276 >#define tLN 277 >#define tLOG10 278 >#define tLOG2 279 >#define tNOT 280 >#define tOR 281 >#define tPI 282 >#define tPMT 283 >#define tPV 284 >#define tRAND 285 >#define tRATE 286 >#define tSIN 287 >#define tSINH 288 >#define tSLN 289 >#define tSQRT 290 >#define tSYD 291 >#define tTAN 292 >#define tTANH 293 >#define tTERM 294 >#define tU16 295 >#define tU32 296 >#define tXNOR 297 >#define tXOR 298 >#define tRCL 299 >#define tSTO 300 >#define tCLR 301 >#define tINUMBER 302 >#define tDNUMBER 303 >#define POS 304 > > > > >/* Copy the first part of user declarations. */ >#line 1 "./lr_parser.y" > > >/* $Header: /cvs/gnome/gcalctool/gcalctool/lr_parser.y,v 1.9 2006/09/13 17:41:46 sampie Exp $ > * > * Copyright (C) 2004-2008 Sami Pietila > * > * 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. > */ > >#include <stdio.h> >#include <stdlib.h> >#include <math.h> >#include <errno.h> >#include "calctool.h" >#include "functions.h" >#include "display.h" >#include "mpmath.h" > >#include "parser.h" >#include "parser_mac.h" >#include "lr_parser.h" > >extern struct parser_state parser_state; > > > >/* 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 > >/* Enabling the token table. */ >#ifndef YYTOKEN_TABLE ># define YYTOKEN_TABLE 0 >#endif > >#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED >typedef union YYSTYPE >#line 40 "./lr_parser.y" >{ > int int_t[MP_SIZE]; >} >/* Line 187 of yacc.c. */ >#line 245 "lr_parser.tab.c" > YYSTYPE; ># 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 216 of yacc.c. */ >#line 258 "lr_parser.tab.c" > >#ifdef short ># undef short >#endif > >#ifdef YYTYPE_UINT8 >typedef YYTYPE_UINT8 yytype_uint8; >#else >typedef unsigned char yytype_uint8; >#endif > >#ifdef YYTYPE_INT8 >typedef YYTYPE_INT8 yytype_int8; >#elif (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >typedef signed char yytype_int8; >#else >typedef short int yytype_int8; >#endif > >#ifdef YYTYPE_UINT16 >typedef YYTYPE_UINT16 yytype_uint16; >#else >typedef unsigned short int yytype_uint16; >#endif > >#ifdef YYTYPE_INT16 >typedef YYTYPE_INT16 yytype_int16; >#else >typedef short int yytype_int16; >#endif > >#ifndef YYSIZE_T ># ifdef __SIZE_TYPE__ ># define YYSIZE_T __SIZE_TYPE__ ># elif defined size_t ># define YYSIZE_T size_t ># elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) ># include <stddef.h> /* INFRINGES ON USER NAME SPACE */ ># define YYSIZE_T size_t ># else ># define YYSIZE_T unsigned int ># endif >#endif > >#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) > >#ifndef YY_ ># if YYENABLE_NLS ># if ENABLE_NLS ># include <libintl.h> /* INFRINGES ON USER NAME SPACE */ ># define YY_(msgid) dgettext ("bison-runtime", msgid) ># endif ># endif ># ifndef YY_ ># define YY_(msgid) msgid ># endif >#endif > >/* Suppress unused-variable warnings by "using" E. */ >#if ! defined lint || defined __GNUC__ ># define YYUSE(e) ((void) (e)) >#else ># define YYUSE(e) /* empty */ >#endif > >/* Identity function, used to suppress warnings about constant conditions. */ >#ifndef lint ># define YYID(n) (n) >#else >#if (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >static int >YYID (int i) >#else >static int >YYID (i) > int i; >#endif >{ > return i; >} >#endif > >#if ! defined yyoverflow || YYERROR_VERBOSE > >/* 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 ># elif defined __BUILTIN_VA_ARG_INCR ># include <alloca.h> /* INFRINGES ON USER NAME SPACE */ ># elif defined _AIX ># define YYSTACK_ALLOC __alloca ># elif defined _MSC_VER ># include <malloc.h> /* INFRINGES ON USER NAME SPACE */ ># define alloca _alloca ># else ># define YYSTACK_ALLOC alloca ># if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) ># include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ ># ifndef _STDLIB_H ># define _STDLIB_H 1 ># endif ># endif ># endif ># endif ># endif > ># ifdef YYSTACK_ALLOC > /* Pacify GCC's `empty if-body' warning. */ ># define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) ># ifndef YYSTACK_ALLOC_MAXIMUM > /* The OS might guarantee only one guard page at the bottom of the stack, > and a page size can be as small as 4096 bytes. So we cannot safely > invoke alloca (N) if N exceeds 4096. Use a slightly smaller number > to allow for a few compiler-allocated temporary stack slots. */ ># define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ ># endif ># else ># define YYSTACK_ALLOC YYMALLOC ># define YYSTACK_FREE YYFREE ># ifndef YYSTACK_ALLOC_MAXIMUM ># define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM ># endif ># if (defined __cplusplus && ! defined _STDLIB_H \ > && ! ((defined YYMALLOC || defined malloc) \ > && (defined YYFREE || defined free))) ># include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ ># ifndef _STDLIB_H ># define _STDLIB_H 1 ># endif ># endif ># ifndef YYMALLOC ># define YYMALLOC malloc ># if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ ># endif ># endif ># ifndef YYFREE ># define YYFREE free ># if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >void free (void *); /* INFRINGES ON USER NAME SPACE */ ># endif ># endif ># 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 >{ > yytype_int16 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 (yytype_int16) + 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 \ > { \ > YYSIZE_T yyi; \ > for (yyi = 0; yyi < (Count); yyi++) \ > (To)[yyi] = (From)[yyi]; \ > } \ > while (YYID (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 (YYID (0)) > >#endif > >/* YYFINAL -- State number of the termination state. */ >#define YYFINAL 43 >/* YYLAST -- Last index in YYTABLE. */ >#define YYLAST 191 > >/* YYNTOKENS -- Number of terminals. */ >#define YYNTOKENS 65 >/* YYNNTS -- Number of nonterminals. */ >#define YYNNTS 11 >/* YYNRULES -- Number of rules. */ >#define YYNRULES 50 >/* YYNRULES -- Number of states. */ >#define YYNSTATES 82 > >/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ >#define YYUNDEFTOK 2 >#define YYMAXUTOK 304 > >#define YYTRANSLATE(YYX) \ > ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) > >/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ >static const yytype_uint8 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, 63, 2, 2, 2, 64, 53, 2, > 61, 62, 51, 49, 2, 50, 2, 52, 2, 2, > 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, > 2, 60, 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, 57, 2, 2, 2, 2, 2, > 2, 58, 2, 2, 2, 2, 2, 2, 2, 2, > 55, 2, 2, 2, 2, 2, 2, 2, 2, 2, > 56, 2, 2, 2, 54, 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, 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, 42, 43, 44, > 45, 46, 47, 48, 59 >}; > >#if YYDEBUG >/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in > YYRHS. */ >static const yytype_uint8 yyprhs[] = >{ > 0, 0, 3, 5, 7, 9, 11, 14, 17, 24, > 30, 32, 34, 36, 40, 44, 48, 52, 56, 60, > 63, 66, 68, 71, 74, 77, 80, 83, 86, 89, > 92, 95, 98, 101, 104, 107, 110, 113, 116, 119, > 122, 125, 128, 132, 134, 136, 138, 141, 144, 149, > 151 >}; > >/* YYRHS -- A `-1'-separated list of the rules' RHS. */ >static const yytype_int8 yyrhs[] = >{ > 66, 0, -1, 67, -1, 69, -1, 1, -1, 68, > -1, 67, 68, -1, 69, 60, -1, 69, 60, 45, > 61, 47, 62, -1, 69, 45, 61, 47, 62, -1, > 46, -1, 70, -1, 73, -1, 70, 49, 70, -1, > 70, 50, 70, -1, 70, 51, 70, -1, 70, 52, > 70, -1, 70, 57, 70, -1, 70, 58, 70, -1, > 70, 63, -1, 70, 64, -1, 71, -1, 23, 72, > -1, 73, 23, -1, 24, 72, -1, 73, 24, -1, > 35, 72, -1, 73, 35, -1, 22, 72, -1, 73, > 22, -1, 4, 72, -1, 73, 4, -1, 19, 72, > -1, 73, 19, -1, 21, 72, -1, 73, 21, -1, > 32, 72, -1, 73, 32, -1, 15, 72, -1, 73, > 15, -1, 37, 72, -1, 73, 37, -1, 61, 70, > 62, -1, 75, -1, 74, -1, 72, -1, 50, 73, > -1, 49, 73, -1, 44, 61, 47, 62, -1, 47, > -1, 48, -1 >}; > >/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ >static const yytype_uint8 yyrline[] = >{ > 0, 104, 104, 105, 106, 115, 116, 120, 124, 129, > 134, 141, 145, 146, 147, 148, 149, 150, 151, 152, > 153, 155, 159, 160, 161, 162, 163, 164, 165, 166, > 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, > 177, 178, 182, 186, 187, 188, 189, 190, 194, 202, > 203 >}; >#endif > >#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE >/* YYTNAME[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", "NEG", "tABS", "tACOS", "tACOSH", "tAND", > "tANS", "tASIN", "tASINH", "tATAN", "tATANH", "tCBRT", "tCHS", "tCOS", > "tCOSH", "tDDB", "tEXP", "tFRAC", "tFV", "tINT", "tLN", "tLOG10", > "tLOG2", "tNOT", "tOR", "tPI", "tPMT", "tPV", "tRAND", "tRATE", "tSIN", > "tSINH", "tSLN", "tSQRT", "tSYD", "tTAN", "tTANH", "tTERM", "tU16", > "tU32", "tXNOR", "tXOR", "tRCL", "tSTO", "tCLR", "tINUMBER", "tDNUMBER", > "'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'n'", "'x'", "'^'", "'e'", > "POS", "'='", "'('", "')'", "'!'", "'%'", "$accept", "statement", "seq", > "udf", "value", "exp", "func", "parenthesis", "term", "rcl", "number", 0 >}; >#endif > ># ifdef YYPRINT >/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to > token YYLEX-NUM. */ >static const yytype_uint16 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, 297, 298, 299, 300, 301, 302, 303, 43, > 45, 42, 47, 38, 124, 110, 120, 94, 101, 304, > 61, 40, 41, 33, 37 >}; ># endif > >/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ >static const yytype_uint8 yyr1[] = >{ > 0, 65, 66, 66, 66, 67, 67, 68, 68, 68, > 68, 69, 70, 70, 70, 70, 70, 70, 70, 70, > 70, 70, 71, 71, 71, 71, 71, 71, 71, 71, > 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, > 71, 71, 72, 73, 73, 73, 73, 73, 74, 75, > 75 >}; > >/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ >static const yytype_uint8 yyr2[] = >{ > 0, 2, 1, 1, 1, 1, 2, 2, 6, 5, > 1, 1, 1, 3, 3, 3, 3, 3, 3, 2, > 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, > 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, > 2, 2, 3, 1, 1, 1, 2, 2, 4, 1, > 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 yytype_uint8 yydefact[] = >{ > 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, > 0, 0, 0, 10, 49, 50, 0, 0, 0, 0, > 2, 5, 3, 11, 21, 45, 12, 44, 43, 30, > 38, 32, 34, 28, 22, 24, 36, 26, 40, 0, > 47, 46, 0, 1, 6, 0, 0, 7, 0, 0, > 0, 0, 0, 0, 19, 20, 31, 39, 33, 35, > 29, 23, 25, 37, 27, 41, 0, 42, 0, 0, > 13, 14, 15, 16, 17, 18, 48, 0, 0, 9, > 0, 8 >}; > >/* YYDEFGOTO[NTERM-NUM]. */ >static const yytype_int8 yydefgoto[] = >{ > -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, > 28 >}; > >/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing > STATE-NUM. */ >#define YYPACT_NINF -58 >static const yytype_int8 yypact[] = >{ > -1, -58, -57, -57, -57, -57, -57, -57, -57, -57, > -57, -57, -48, -58, -58, -58, -42, -42, 71, 15, > 35, -58, -44, 117, -58, -58, 125, -58, -58, -58, > -58, -58, -58, -58, -58, -58, -58, -58, -58, -30, > -58, -58, 101, -58, -58, -44, -37, -20, 71, 71, > 71, 71, 71, 71, -58, -58, -58, -58, -58, -58, > -58, -58, -58, -58, -58, -58, -36, -58, -19, -34, > -54, -54, -54, -54, -54, -54, -58, -33, -17, -58, > -29, -58 >}; > >/* YYPGOTO[NTERM-NUM]. */ >static const yytype_int16 yypgoto[] = >{ > -58, -58, -58, 12, 17, 86, -58, 180, -5, -58, > -58 >}; > >/* 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 -1 >static const yytype_uint8 yytable[] = >{ > 1, 46, 12, 2, 18, 14, 15, 16, 17, 54, > 55, 40, 41, 39, 3, 43, 47, 66, 4, 18, > 5, 6, 7, 8, 68, 69, 76, 78, 77, 79, > 80, 9, 44, 81, 10, 0, 11, 45, 0, 2, > 0, 0, 0, 12, 0, 13, 14, 15, 16, 17, > 3, 0, 0, 0, 4, 0, 5, 6, 7, 8, > 18, 0, 0, 0, 0, 0, 0, 9, 0, 0, > 10, 0, 11, 0, 0, 2, 0, 0, 0, 12, > 0, 13, 14, 15, 16, 17, 3, 0, 0, 0, > 4, 0, 5, 6, 7, 8, 18, 0, 0, 0, > 0, 0, 0, 9, 42, 0, 10, 0, 11, 0, > 0, 0, 0, 0, 0, 12, 0, 0, 14, 15, > 16, 17, 0, 0, 0, 0, 0, 0, 0, 56, > 0, 0, 18, 0, 70, 71, 72, 73, 74, 75, > 57, 0, 0, 0, 58, 0, 59, 60, 61, 62, > 48, 49, 50, 51, 0, 0, 0, 63, 52, 53, > 64, 0, 65, 67, 54, 55, 48, 49, 50, 51, > 0, 0, 0, 0, 52, 53, 0, 0, 0, 0, > 54, 55, 29, 30, 31, 32, 33, 34, 35, 36, > 37, 38 >}; > >static const yytype_int8 yycheck[] = >{ > 1, 45, 44, 4, 61, 47, 48, 49, 50, 63, > 64, 16, 17, 61, 15, 0, 60, 47, 19, 61, > 21, 22, 23, 24, 61, 45, 62, 61, 47, 62, > 47, 32, 20, 62, 35, -1, 37, 20, -1, 4, > -1, -1, -1, 44, -1, 46, 47, 48, 49, 50, > 15, -1, -1, -1, 19, -1, 21, 22, 23, 24, > 61, -1, -1, -1, -1, -1, -1, 32, -1, -1, > 35, -1, 37, -1, -1, 4, -1, -1, -1, 44, > -1, 46, 47, 48, 49, 50, 15, -1, -1, -1, > 19, -1, 21, 22, 23, 24, 61, -1, -1, -1, > -1, -1, -1, 32, 18, -1, 35, -1, 37, -1, > -1, -1, -1, -1, -1, 44, -1, -1, 47, 48, > 49, 50, -1, -1, -1, -1, -1, -1, -1, 4, > -1, -1, 61, -1, 48, 49, 50, 51, 52, 53, > 15, -1, -1, -1, 19, -1, 21, 22, 23, 24, > 49, 50, 51, 52, -1, -1, -1, 32, 57, 58, > 35, -1, 37, 62, 63, 64, 49, 50, 51, 52, > -1, -1, -1, -1, 57, 58, -1, -1, -1, -1, > 63, 64, 2, 3, 4, 5, 6, 7, 8, 9, > 10, 11 >}; > >/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing > symbol of state STATE-NUM. */ >static const yytype_uint8 yystos[] = >{ > 0, 1, 4, 15, 19, 21, 22, 23, 24, 32, > 35, 37, 44, 46, 47, 48, 49, 50, 61, 66, > 67, 68, 69, 70, 71, 72, 73, 74, 75, 72, > 72, 72, 72, 72, 72, 72, 72, 72, 72, 61, > 73, 73, 70, 0, 68, 69, 45, 60, 49, 50, > 51, 52, 57, 58, 63, 64, 4, 15, 19, 21, > 22, 23, 24, 32, 35, 37, 47, 62, 61, 45, > 70, 70, 70, 70, 70, 70, 62, 47, 61, 62, > 47, 62 >}; > >#define yyerrok (yyerrstatus = 0) >#define yyclearin (yychar = YYEMPTY) >#define YYEMPTY (-2) >#define YYEOF 0 > >#define YYACCEPT goto yyacceptlab >#define YYABORT goto yyabortlab >#define YYERROR goto yyerrorlab > > >/* Like YYERROR except do call yyerror. This remains here temporarily > to ease the transition to the new meaning of YYERROR, for GCC. > Once GCC version 2 has supplanted version 1, this can go. */ > >#define YYFAIL goto yyerrlab > >#define YYRECOVERING() (!!yyerrstatus) > >#define YYBACKUP(Token, Value) \ >do \ > if (yychar == YYEMPTY && yylen == 1) \ > { \ > yychar = (Token); \ > yylval = (Value); \ > yytoken = YYTRANSLATE (yychar); \ > YYPOPSTACK (1); \ > goto yybackup; \ > } \ > else \ > { \ > yyerror (YY_("syntax error: cannot back up")); \ > YYERROR; \ > } \ >while (YYID (0)) > > >#define YYTERROR 1 >#define YYERRCODE 256 > > >/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. > If N is 0, then set CURRENT to the empty location which ends > the previous symbol: RHS[0] (always defined). */ > >#define YYRHSLOC(Rhs, K) ((Rhs)[K]) >#ifndef YYLLOC_DEFAULT ># define YYLLOC_DEFAULT(Current, Rhs, N) \ > do \ > if (YYID (N)) \ > { \ > (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ > (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ > (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ > (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ > } \ > else \ > { \ > (Current).first_line = (Current).last_line = \ > YYRHSLOC (Rhs, 0).last_line; \ > (Current).first_column = (Current).last_column = \ > YYRHSLOC (Rhs, 0).last_column; \ > } \ > while (YYID (0)) >#endif > > >/* YY_LOCATION_PRINT -- Print the location on the stream. > This macro was not mandated originally: define only if we know > we won't break user code: when these are the locations we know. */ > >#ifndef YY_LOCATION_PRINT ># if YYLTYPE_IS_TRIVIAL ># define YY_LOCATION_PRINT(File, Loc) \ > fprintf (File, "%d.%d-%d.%d", \ > (Loc).first_line, (Loc).first_column, \ > (Loc).last_line, (Loc).last_column) ># else ># define YY_LOCATION_PRINT(File, Loc) ((void) 0) ># endif >#endif > > >/* YYLEX -- calling `yylex' with the right arguments. */ > >#ifdef YYLEX_PARAM ># define YYLEX yylex (YYLEX_PARAM) >#else ># define YYLEX yylex () >#endif > >/* Enable debugging if requested. */ >#if YYDEBUG > ># ifndef YYFPRINTF ># include <stdio.h> /* INFRINGES ON USER NAME SPACE */ ># define YYFPRINTF fprintf ># endif > ># define YYDPRINTF(Args) \ >do { \ > if (yydebug) \ > YYFPRINTF Args; \ >} while (YYID (0)) > ># define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ >do { \ > if (yydebug) \ > { \ > YYFPRINTF (stderr, "%s ", Title); \ > yy_symbol_print (stderr, \ > Type, Value); \ > YYFPRINTF (stderr, "\n"); \ > } \ >} while (YYID (0)) > > >/*--------------------------------. >| Print this symbol on YYOUTPUT. | >`--------------------------------*/ > >/*ARGSUSED*/ >#if (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >static void >yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) >#else >static void >yy_symbol_value_print (yyoutput, yytype, yyvaluep) > FILE *yyoutput; > int yytype; > YYSTYPE const * const yyvaluep; >#endif >{ > if (!yyvaluep) > return; ># ifdef YYPRINT > if (yytype < YYNTOKENS) > YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); ># else > YYUSE (yyoutput); ># endif > switch (yytype) > { > default: > break; > } >} > > >/*--------------------------------. >| Print this symbol on YYOUTPUT. | >`--------------------------------*/ > >#if (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >static void >yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) >#else >static void >yy_symbol_print (yyoutput, yytype, yyvaluep) > FILE *yyoutput; > int yytype; > YYSTYPE const * const yyvaluep; >#endif >{ > if (yytype < YYNTOKENS) > YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); > else > YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); > > yy_symbol_value_print (yyoutput, yytype, yyvaluep); > YYFPRINTF (yyoutput, ")"); >} > >/*------------------------------------------------------------------. >| yy_stack_print -- Print the state stack from its BOTTOM up to its | >| TOP (included). | >`------------------------------------------------------------------*/ > >#if (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >static void >yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) >#else >static void >yy_stack_print (bottom, top) > yytype_int16 *bottom; > yytype_int16 *top; >#endif >{ > YYFPRINTF (stderr, "Stack now"); > for (; bottom <= top; ++bottom) > YYFPRINTF (stderr, " %d", *bottom); > YYFPRINTF (stderr, "\n"); >} > ># define YY_STACK_PRINT(Bottom, Top) \ >do { \ > if (yydebug) \ > yy_stack_print ((Bottom), (Top)); \ >} while (YYID (0)) > > >/*------------------------------------------------. >| Report that the YYRULE is going to be reduced. | >`------------------------------------------------*/ > >#if (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >static void >yy_reduce_print (YYSTYPE *yyvsp, int yyrule) >#else >static void >yy_reduce_print (yyvsp, yyrule) > YYSTYPE *yyvsp; > int yyrule; >#endif >{ > int yynrhs = yyr2[yyrule]; > int yyi; > unsigned long int yylno = yyrline[yyrule]; > YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", > yyrule - 1, yylno); > /* The symbols being reduced. */ > for (yyi = 0; yyi < yynrhs; yyi++) > { > fprintf (stderr, " $%d = ", yyi + 1); > yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], > &(yyvsp[(yyi + 1) - (yynrhs)]) > ); > fprintf (stderr, "\n"); > } >} > ># define YY_REDUCE_PRINT(Rule) \ >do { \ > if (yydebug) \ > yy_reduce_print (yyvsp, Rule); \ >} while (YYID (0)) > >/* Nonzero means print parse trace. It is left uninitialized so that > multiple parsers can coexist. */ >int yydebug; >#else /* !YYDEBUG */ ># define YYDPRINTF(Args) ># define YY_SYMBOL_PRINT(Title, Type, Value, Location) ># define YY_STACK_PRINT(Bottom, Top) ># define YY_REDUCE_PRINT(Rule) >#endif /* !YYDEBUG */ > > >/* YYINITDEPTH -- initial size of the parser's stacks. */ >#ifndef YYINITDEPTH ># define YYINITDEPTH 200 >#endif > >/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only > if the built-in stack extension method is used). > > Do not make this value too large; the results are undefined if > YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) > evaluated with infinite-precision integer arithmetic. */ > >#ifndef YYMAXDEPTH ># define YYMAXDEPTH 10000 >#endif > > > >#if YYERROR_VERBOSE > ># ifndef yystrlen ># if defined __GLIBC__ && defined _STRING_H ># define yystrlen strlen ># else >/* Return the length of YYSTR. */ >#if (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >static YYSIZE_T >yystrlen (const char *yystr) >#else >static YYSIZE_T >yystrlen (yystr) > const char *yystr; >#endif >{ > YYSIZE_T yylen; > for (yylen = 0; yystr[yylen]; yylen++) > continue; > return yylen; >} ># endif ># endif > ># ifndef yystpcpy ># if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE ># define yystpcpy stpcpy ># else >/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in > YYDEST. */ >#if (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >static char * >yystpcpy (char *yydest, const char *yysrc) >#else >static char * >yystpcpy (yydest, yysrc) > char *yydest; > const char *yysrc; >#endif >{ > char *yyd = yydest; > const char *yys = yysrc; > > while ((*yyd++ = *yys++) != '\0') > continue; > > return yyd - 1; >} ># endif ># endif > ># ifndef yytnamerr >/* Copy to YYRES the contents of YYSTR after stripping away unnecessary > quotes and backslashes, so that it's suitable for yyerror. The > heuristic is that double-quoting is unnecessary unless the string > contains an apostrophe, a comma, or backslash (other than > backslash-backslash). YYSTR is taken from yytname. If YYRES is > null, do not copy; instead, return the length of what the result > would have been. */ >static YYSIZE_T >yytnamerr (char *yyres, const char *yystr) >{ > if (*yystr == '"') > { > YYSIZE_T yyn = 0; > char const *yyp = yystr; > > for (;;) > switch (*++yyp) > { > case '\'': > case ',': > goto do_not_strip_quotes; > > case '\\': > if (*++yyp != '\\') > goto do_not_strip_quotes; > /* Fall through. */ > default: > if (yyres) > yyres[yyn] = *yyp; > yyn++; > break; > > case '"': > if (yyres) > yyres[yyn] = '\0'; > return yyn; > } > do_not_strip_quotes: ; > } > > if (! yyres) > return yystrlen (yystr); > > return yystpcpy (yyres, yystr) - yyres; >} ># endif > >/* Copy into YYRESULT an error message about the unexpected token > YYCHAR while in state YYSTATE. Return the number of bytes copied, > including the terminating null byte. If YYRESULT is null, do not > copy anything; just return the number of bytes that would be > copied. As a special case, return 0 if an ordinary "syntax error" > message will do. Return YYSIZE_MAXIMUM if overflow occurs during > size calculation. */ >static YYSIZE_T >yysyntax_error (char *yyresult, int yystate, int yychar) >{ > int yyn = yypact[yystate]; > > if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) > return 0; > else > { > int yytype = YYTRANSLATE (yychar); > YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); > YYSIZE_T yysize = yysize0; > YYSIZE_T yysize1; > int yysize_overflow = 0; > enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; > char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; > int yyx; > ># if 0 > /* This is so xgettext sees the translatable formats that are > constructed on the fly. */ > YY_("syntax error, unexpected %s"); > YY_("syntax error, unexpected %s, expecting %s"); > YY_("syntax error, unexpected %s, expecting %s or %s"); > YY_("syntax error, unexpected %s, expecting %s or %s or %s"); > YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); ># endif > char *yyfmt; > char const *yyf; > static char const yyunexpected[] = "syntax error, unexpected %s"; > static char const yyexpecting[] = ", expecting %s"; > static char const yyor[] = " or %s"; > char yyformat[sizeof yyunexpected > + sizeof yyexpecting - 1 > + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) > * (sizeof yyor - 1))]; > char const *yyprefix = yyexpecting; > > /* Start YYX at -YYN if negative to avoid negative indexes in > YYCHECK. */ > int yyxbegin = yyn < 0 ? -yyn : 0; > > /* Stay within bounds of both yycheck and yytname. */ > int yychecklim = YYLAST - yyn + 1; > int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; > int yycount = 1; > > yyarg[0] = yytname[yytype]; > yyfmt = yystpcpy (yyformat, yyunexpected); > > for (yyx = yyxbegin; yyx < yyxend; ++yyx) > if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) > { > if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) > { > yycount = 1; > yysize = yysize0; > yyformat[sizeof yyunexpected - 1] = '\0'; > break; > } > yyarg[yycount++] = yytname[yyx]; > yysize1 = yysize + yytnamerr (0, yytname[yyx]); > yysize_overflow |= (yysize1 < yysize); > yysize = yysize1; > yyfmt = yystpcpy (yyfmt, yyprefix); > yyprefix = yyor; > } > > yyf = YY_(yyformat); > yysize1 = yysize + yystrlen (yyf); > yysize_overflow |= (yysize1 < yysize); > yysize = yysize1; > > if (yysize_overflow) > return YYSIZE_MAXIMUM; > > if (yyresult) > { > /* Avoid sprintf, as that infringes on the user's name space. > Don't have undefined behavior even if the translation > produced a string with the wrong number of "%s"s. */ > char *yyp = yyresult; > int yyi = 0; > while ((*yyp = *yyf) != '\0') > { > if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) > { > yyp += yytnamerr (yyp, yyarg[yyi++]); > yyf += 2; > } > else > { > yyp++; > yyf++; > } > } > } > return yysize; > } >} >#endif /* YYERROR_VERBOSE */ > > >/*-----------------------------------------------. >| Release the memory associated to this symbol. | >`-----------------------------------------------*/ > >/*ARGSUSED*/ >#if (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >static void >yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) >#else >static void >yydestruct (yymsg, yytype, yyvaluep) > const char *yymsg; > int yytype; > YYSTYPE *yyvaluep; >#endif >{ > YYUSE (yyvaluep); > > if (!yymsg) > yymsg = "Deleting"; > YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); > > switch (yytype) > { > > default: > break; > } >} > > >/* Prevent warnings from -Wmissing-prototypes. */ > >#ifdef YYPARSE_PARAM >#if defined __STDC__ || defined __cplusplus >int yyparse (void *YYPARSE_PARAM); >#else >int yyparse (); >#endif >#else /* ! YYPARSE_PARAM */ >#if defined __STDC__ || defined __cplusplus >int yyparse (void); >#else >int yyparse (); >#endif >#endif /* ! YYPARSE_PARAM */ > > > >/* The look-ahead symbol. */ >int yychar; > >/* The semantic value of the look-ahead symbol. */ >YYSTYPE yylval; > >/* Number of syntax errors so far. */ >int yynerrs; > > > >/*----------. >| yyparse. | >`----------*/ > >#ifdef YYPARSE_PARAM >#if (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >int >yyparse (void *YYPARSE_PARAM) >#else >int >yyparse (YYPARSE_PARAM) > void *YYPARSE_PARAM; >#endif >#else /* ! YYPARSE_PARAM */ >#if (defined __STDC__ || defined __C99__FUNC__ \ > || defined __cplusplus || defined _MSC_VER) >int >yyparse (void) >#else >int >yyparse () > >#endif >#endif >{ > > int yystate; > int yyn; > int yyresult; > /* Number of tokens to shift before error messages enabled. */ > int yyerrstatus; > /* Look-ahead token as an internal (translated) token number. */ > int yytoken = 0; >#if YYERROR_VERBOSE > /* Buffer for error messages, and its allocated size. */ > char yymsgbuf[128]; > char *yymsg = yymsgbuf; > YYSIZE_T yymsg_alloc = sizeof yymsgbuf; >#endif > > /* Three stacks and their tools: > `yyss': related to states, > `yyvs': related to semantic values, > `yyls': related to locations. > > Refer to the stacks thru separate pointers, to allow yyoverflow > to reallocate them elsewhere. */ > > /* The state stack. */ > yytype_int16 yyssa[YYINITDEPTH]; > yytype_int16 *yyss = yyssa; > yytype_int16 *yyssp; > > /* The semantic value stack. */ > YYSTYPE yyvsa[YYINITDEPTH]; > YYSTYPE *yyvs = yyvsa; > YYSTYPE *yyvsp; > > > >#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) > > YYSIZE_T yystacksize = YYINITDEPTH; > > /* The variables used to return semantic value and location from the > action routines. */ > YYSTYPE yyval; > > > /* The number of symbols on the RHS of the reduced rule. > Keep to zero when no symbol should be popped. */ > int yylen = 0; > > YYDPRINTF ((stderr, "Starting parse\n")); > > yystate = 0; > yyerrstatus = 0; > yynerrs = 0; > yychar = YYEMPTY; /* Cause a token to be read. */ > > /* Initialize stack pointers. > Waste one element of value and location stack > so that they stay on the same level as the state stack. > The wasted elements are never initialized. */ > > yyssp = yyss; > yyvsp = yyvs; > > goto yysetstate; > >/*------------------------------------------------------------. >| yynewstate -- Push a new state, which is found in yystate. | >`------------------------------------------------------------*/ > yynewstate: > /* In all cases, when you get here, the value and location stacks > have just been pushed. So pushing a state here evens the stacks. */ > yyssp++; > > yysetstate: > *yyssp = yystate; > > if (yyss + yystacksize - 1 <= yyssp) > { > /* Get the current used size of the three stacks, in elements. */ > YYSIZE_T yysize = yyssp - yyss + 1; > >#ifdef yyoverflow > { > /* Give user a chance to reallocate the stack. Use copies of > these so that the &'s don't force the real ones into > memory. */ > YYSTYPE *yyvs1 = yyvs; > yytype_int16 *yyss1 = yyss; > > > /* Each stack pointer address is followed by the size of the > data in use in that stack, in bytes. This used to be a > conditional around just the two extra args, but that might > be undefined if yyoverflow is a macro. */ > yyoverflow (YY_("memory exhausted"), > &yyss1, yysize * sizeof (*yyssp), > &yyvs1, yysize * sizeof (*yyvsp), > > &yystacksize); > > yyss = yyss1; > yyvs = yyvs1; > } >#else /* no yyoverflow */ ># ifndef YYSTACK_RELOCATE > goto yyexhaustedlab; ># else > /* Extend the stack our own way. */ > if (YYMAXDEPTH <= yystacksize) > goto yyexhaustedlab; > yystacksize *= 2; > if (YYMAXDEPTH < yystacksize) > yystacksize = YYMAXDEPTH; > > { > yytype_int16 *yyss1 = yyss; > union yyalloc *yyptr = > (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); > if (! yyptr) > goto yyexhaustedlab; > YYSTACK_RELOCATE (yyss); > YYSTACK_RELOCATE (yyvs); > ># undef YYSTACK_RELOCATE > if (yyss1 != yyssa) > YYSTACK_FREE (yyss1); > } ># endif >#endif /* no yyoverflow */ > > yyssp = yyss + yysize - 1; > yyvsp = yyvs + yysize - 1; > > > YYDPRINTF ((stderr, "Stack size increased to %lu\n", > (unsigned long int) yystacksize)); > > if (yyss + yystacksize - 1 <= yyssp) > YYABORT; > } > > YYDPRINTF ((stderr, "Entering state %d\n", yystate)); > > goto yybackup; > >/*-----------. >| yybackup. | >`-----------*/ >yybackup: > > /* Do appropriate processing given the current state. Read a > look-ahead token if we need one and don't already have one. */ > > /* First try to decide what to do without reference to look-ahead token. */ > yyn = yypact[yystate]; > if (yyn == YYPACT_NINF) > goto yydefault; > > /* Not known => get a look-ahead token if don't already have one. */ > > /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ > if (yychar == YYEMPTY) > { > YYDPRINTF ((stderr, "Reading a token: ")); > yychar = YYLEX; > } > > if (yychar <= YYEOF) > { > yychar = yytoken = YYEOF; > YYDPRINTF ((stderr, "Now at end of input.\n")); > } > else > { > yytoken = YYTRANSLATE (yychar); > YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); > } > > /* If the proper action on seeing token YYTOKEN is to reduce or to > detect an error, take that action. */ > yyn += yytoken; > if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) > goto yydefault; > yyn = yytable[yyn]; > if (yyn <= 0) > { > if (yyn == 0 || yyn == YYTABLE_NINF) > goto yyerrlab; > yyn = -yyn; > goto yyreduce; > } > > if (yyn == YYFINAL) > YYACCEPT; > > /* Count tokens shifted since error; after three, turn off error > status. */ > if (yyerrstatus) > yyerrstatus--; > > /* Shift the look-ahead token. */ > YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); > > /* Discard the shifted token unless it is eof. */ > if (yychar != YYEOF) > yychar = YYEMPTY; > > yystate = yyn; > *++yyvsp = yylval; > > goto yynewstate; > > >/*-----------------------------------------------------------. >| yydefault -- do the default action for the current state. | >`-----------------------------------------------------------*/ >yydefault: > yyn = yydefact[yystate]; > if (yyn == 0) > goto yyerrlab; > goto yyreduce; > > >/*-----------------------------. >| yyreduce -- Do a reduction. | >`-----------------------------*/ >yyreduce: > /* yyn is the number of a rule to reduce with. */ > yylen = yyr2[yyn]; > > /* If YYLEN is nonzero, implement the default value of the action: > `$$ = $1'. > > Otherwise, the following line sets YYVAL to garbage. > This behavior is undocumented and Bison > users should not rely upon it. Assigning to YYVAL > unconditionally makes the parser a bit smaller, and it avoids a > GCC warning that YYVAL may be used uninitialized. */ > yyval = yyvsp[1-yylen]; > > > YY_REDUCE_PRINT (yyn); > switch (yyn) > { > case 3: >#line 105 "./lr_parser.y" > {ret((yyvsp[(1) - (1)].int_t));;} > break; > > case 4: >#line 106 "./lr_parser.y" > { > yyclearin; > reset_lr_tokeniser(); > parser_state.error = EINVAL; > YYABORT; >;} > break; > > case 7: >#line 120 "./lr_parser.y" > { > cp((yyvsp[(1) - (2)].int_t), v->MPdisp_val); > show_display(v->MPdisp_val); > ;} > break; > > case 8: >#line 124 "./lr_parser.y" > { > int val; > mpcmi((yyvsp[(5) - (6)].int_t), &val); > do_sto_reg(val, (yyvsp[(1) - (6)].int_t)); >;} > break; > > case 9: >#line 129 "./lr_parser.y" > { > int val; > mpcmi((yyvsp[(4) - (5)].int_t), &val); > do_sto_reg(val, (yyvsp[(1) - (5)].int_t)); >;} > break; > > case 10: >#line 134 "./lr_parser.y" > { > initialise(); > show_display(v->MPdisp_val); >;} > break; > > case 11: >#line 141 "./lr_parser.y" > {cp((yyvsp[(1) - (1)].int_t), (yyval.int_t));;} > break; > > case 12: >#line 145 "./lr_parser.y" > {cp((yyvsp[(1) - (1)].int_t), (yyval.int_t));;} > break; > > case 13: >#line 146 "./lr_parser.y" > {mpadd((yyvsp[(1) - (3)].int_t), (yyvsp[(3) - (3)].int_t), (yyval.int_t));;} > break; > > case 14: >#line 147 "./lr_parser.y" > {mpsub((yyvsp[(1) - (3)].int_t), (yyvsp[(3) - (3)].int_t), (yyval.int_t));;} > break; > > case 15: >#line 148 "./lr_parser.y" > {mpmul((yyvsp[(1) - (3)].int_t), (yyvsp[(3) - (3)].int_t), (yyval.int_t));;} > break; > > case 16: >#line 149 "./lr_parser.y" > {mpdiv((yyvsp[(1) - (3)].int_t), (yyvsp[(3) - (3)].int_t), (yyval.int_t));;} > break; > > case 17: >#line 150 "./lr_parser.y" > {calc_xpowy((yyvsp[(1) - (3)].int_t), (yyvsp[(3) - (3)].int_t), (yyval.int_t));;} > break; > > case 18: >#line 151 "./lr_parser.y" > {calc_xtimestenpowx((yyvsp[(1) - (3)].int_t), (yyvsp[(3) - (3)].int_t), (yyval.int_t));;} > break; > > case 19: >#line 152 "./lr_parser.y" > {do_factorial((yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 20: >#line 153 "./lr_parser.y" > {calc_percent((yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 21: >#line 155 "./lr_parser.y" > {cp((yyvsp[(1) - (1)].int_t), (yyval.int_t));;} > break; > > case 22: >#line 159 "./lr_parser.y" > {mplogn(10, (yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 23: >#line 160 "./lr_parser.y" > {mplogn(10, (yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 24: >#line 161 "./lr_parser.y" > {mplogn(2, (yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 25: >#line 162 "./lr_parser.y" > {mplogn(2, (yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 26: >#line 163 "./lr_parser.y" > {mpsqrt((yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 27: >#line 164 "./lr_parser.y" > {mpsqrt((yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 28: >#line 165 "./lr_parser.y" > {mpln((yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 29: >#line 166 "./lr_parser.y" > {mpln((yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 30: >#line 167 "./lr_parser.y" > {mpabs((yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 31: >#line 168 "./lr_parser.y" > {mpabs((yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 32: >#line 169 "./lr_parser.y" > {mpcmf((yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 33: >#line 170 "./lr_parser.y" > {mpcmf((yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 34: >#line 171 "./lr_parser.y" > {mpcmim((yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 35: >#line 172 "./lr_parser.y" > {mpcmim((yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 36: >#line 173 "./lr_parser.y" > {calc_trigfunc(sin_t, (yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 37: >#line 174 "./lr_parser.y" > {calc_trigfunc(sin_t, (yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 38: >#line 175 "./lr_parser.y" > {calc_trigfunc(cos_t, (yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 39: >#line 176 "./lr_parser.y" > {calc_trigfunc(cos_t, (yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 40: >#line 177 "./lr_parser.y" > {calc_trigfunc(tan_t, (yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 41: >#line 178 "./lr_parser.y" > {calc_trigfunc(tan_t, (yyvsp[(1) - (2)].int_t), (yyval.int_t));;} > break; > > case 42: >#line 182 "./lr_parser.y" > {cp((yyvsp[(2) - (3)].int_t), (yyval.int_t));;} > break; > > case 43: >#line 186 "./lr_parser.y" > {cp((yyvsp[(1) - (1)].int_t), (yyval.int_t));;} > break; > > case 44: >#line 187 "./lr_parser.y" > {cp((yyvsp[(1) - (1)].int_t), (yyval.int_t));;} > break; > > case 45: >#line 188 "./lr_parser.y" > {cp((yyvsp[(1) - (1)].int_t), (yyval.int_t));;} > break; > > case 46: >#line 189 "./lr_parser.y" > {mpneg((yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 47: >#line 190 "./lr_parser.y" > {cp((yyvsp[(2) - (2)].int_t), (yyval.int_t));;} > break; > > case 48: >#line 194 "./lr_parser.y" > { > int val; > mpcmi((yyvsp[(3) - (4)].int_t), &val); > do_rcl_reg(val, (yyval.int_t)); > ;} > break; > > case 49: >#line 202 "./lr_parser.y" > {cp((yyvsp[(1) - (1)].int_t), (yyval.int_t));;} > break; > > case 50: >#line 203 "./lr_parser.y" > {cp((yyvsp[(1) - (1)].int_t), (yyval.int_t));;} > break; > > >/* Line 1267 of yacc.c. */ >#line 1807 "lr_parser.tab.c" > default: break; > } > YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); > > YYPOPSTACK (yylen); > yylen = 0; > YY_STACK_PRINT (yyss, yyssp); > > *++yyvsp = yyval; > > > /* Now `shift' the result of the reduction. Determine what state > that goes to, based on the state we popped back to and the rule > number reduced by. */ > > yyn = yyr1[yyn]; > > yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; > if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) > yystate = yytable[yystate]; > else > yystate = yydefgoto[yyn - YYNTOKENS]; > > goto yynewstate; > > >/*------------------------------------. >| yyerrlab -- here on detecting error | >`------------------------------------*/ >yyerrlab: > /* If not already recovering from an error, report this error. */ > if (!yyerrstatus) > { > ++yynerrs; >#if ! YYERROR_VERBOSE > yyerror (YY_("syntax error")); >#else > { > YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); > if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) > { > YYSIZE_T yyalloc = 2 * yysize; > if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) > yyalloc = YYSTACK_ALLOC_MAXIMUM; > if (yymsg != yymsgbuf) > YYSTACK_FREE (yymsg); > yymsg = (char *) YYSTACK_ALLOC (yyalloc); > if (yymsg) > yymsg_alloc = yyalloc; > else > { > yymsg = yymsgbuf; > yymsg_alloc = sizeof yymsgbuf; > } > } > > if (0 < yysize && yysize <= yymsg_alloc) > { > (void) yysyntax_error (yymsg, yystate, yychar); > yyerror (yymsg); > } > else > { > yyerror (YY_("syntax error")); > if (yysize != 0) > goto yyexhaustedlab; > } > } >#endif > } > > > > if (yyerrstatus == 3) > { > /* If just tried and failed to reuse look-ahead token after an > error, discard it. */ > > if (yychar <= YYEOF) > { > /* Return failure if at end of input. */ > if (yychar == YYEOF) > YYABORT; > } > else > { > yydestruct ("Error: discarding", > yytoken, &yylval); > yychar = YYEMPTY; > } > } > > /* Else will try to reuse look-ahead token after shifting the error > token. */ > goto yyerrlab1; > > >/*---------------------------------------------------. >| yyerrorlab -- error raised explicitly by YYERROR. | >`---------------------------------------------------*/ >yyerrorlab: > > /* Pacify compilers like GCC when the user code never invokes > YYERROR and the label yyerrorlab therefore never appears in user > code. */ > if (/*CONSTCOND*/ 0) > goto yyerrorlab; > > /* Do not reclaim the symbols of the rule which action triggered > this YYERROR. */ > YYPOPSTACK (yylen); > yylen = 0; > YY_STACK_PRINT (yyss, yyssp); > yystate = *yyssp; > goto yyerrlab1; > > >/*-------------------------------------------------------------. >| yyerrlab1 -- common code for both syntax error and YYERROR. | >`-------------------------------------------------------------*/ >yyerrlab1: > yyerrstatus = 3; /* Each real token shifted decrements this. */ > > for (;;) > { > yyn = yypact[yystate]; > if (yyn != YYPACT_NINF) > { > yyn += YYTERROR; > if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) > { > yyn = yytable[yyn]; > if (0 < yyn) > break; > } > } > > /* Pop the current state because it cannot handle the error token. */ > if (yyssp == yyss) > YYABORT; > > > yydestruct ("Error: popping", > yystos[yystate], yyvsp); > YYPOPSTACK (1); > yystate = *yyssp; > YY_STACK_PRINT (yyss, yyssp); > } > > if (yyn == YYFINAL) > YYACCEPT; > > *++yyvsp = yylval; > > > /* Shift the error token. */ > YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); > > yystate = yyn; > goto yynewstate; > > >/*-------------------------------------. >| yyacceptlab -- YYACCEPT comes here. | >`-------------------------------------*/ >yyacceptlab: > yyresult = 0; > goto yyreturn; > >/*-----------------------------------. >| yyabortlab -- YYABORT comes here. | >`-----------------------------------*/ >yyabortlab: > yyresult = 1; > goto yyreturn; > >#ifndef yyoverflow >/*-------------------------------------------------. >| yyexhaustedlab -- memory exhaustion comes here. | >`-------------------------------------------------*/ >yyexhaustedlab: > yyerror (YY_("memory exhausted")); > yyresult = 2; > /* Fall through. */ >#endif > >yyreturn: > if (yychar != YYEOF && yychar != YYEMPTY) > yydestruct ("Cleanup: discarding lookahead", > yytoken, &yylval); > /* Do not reclaim the symbols of the rule which action triggered > this YYABORT or YYACCEPT. */ > YYPOPSTACK (yylen); > YY_STACK_PRINT (yyss, yyssp); > while (yyssp != yyss) > { > yydestruct ("Cleanup: popping", > yystos[*yyssp], yyvsp); > YYPOPSTACK (1); > } >#ifndef yyoverflow > if (yyss != yyssa) > YYSTACK_FREE (yyss); >#endif >#if YYERROR_VERBOSE > if (yymsg != yymsgbuf) > YYSTACK_FREE (yymsg); >#endif > /* Make sure YYID is used. */ > return YYID (yyresult); >} > > >#line 206 "./lr_parser.y" > > >int lrerror(char *s) {return 0;} > > >#if 0 > >#endif >
You cannot view the attachment while viewing its details because your browser does not support IFRAMEs.
View the attachment on a separate page
.
View Attachment As Raw
Actions:
View
Attachments on
bug 231695
:
160267
| 160268