1 2/* A Bison parser, made by GNU Bison 2.4.1. */ 3 4/* Skeleton implementation for Bison's Yacc-like parsers in C 5 6 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 7 Free Software Foundation, Inc. 8 9 This program is free software: you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation, either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22/* As a special exception, you may create a larger work that contains 23 part or all of the Bison parser skeleton and distribute that work 24 under terms of your choice, so long as that work isn't itself a 25 parser generator using the skeleton or a modified version thereof 26 as a parser skeleton. Alternatively, if you modify or redistribute 27 the parser skeleton itself, you may (at your option) remove this 28 special exception, which will cause the skeleton and the resulting 29 Bison output files to be licensed under the GNU General Public 30 License without this special exception. 31 32 This special exception was added by the Free Software Foundation in 33 version 2.2 of Bison. */ 34 35/* C LALR(1) parser skeleton written by Richard Stallman, by 36 simplifying the original so-called "semantic" parser. */ 37 38/* All symbols defined below should begin with yy or YY, to avoid 39 infringing on user name space. This should be done even for local 40 variables, as they might otherwise be expanded by user macros. 41 There are some unavoidable exceptions within include files to 42 define necessary library symbols; they are noted "INFRINGES ON 43 USER NAME SPACE" below. */ 44 45/* Identify Bison output. */ 46#define YYBISON 1 47 48/* Bison version. */ 49#define YYBISON_VERSION "2.4.1" 50 51/* Skeleton name. */ 52#define YYSKELETON_NAME "yacc.c" 53 54/* Pure parsers. */ 55#define YYPURE 0 56 57/* Push parsers. */ 58#define YYPUSH 0 59 60/* Pull parsers. */ 61#define YYPULL 1 62 63/* Using locations. */ 64#define YYLSP_NEEDED 0 65 66 67 68/* Copy the first part of user declarations. */ 69 70/* Line 189 of yacc.c */ 71#line 21 "dtc-parser.y" 72 73#include <stdio.h> 74 75#include "dtc.h" 76#include "srcpos.h" 77 78YYLTYPE yylloc; 79 80extern int yylex(void); 81extern void print_error(char const *fmt, ...); 82extern void yyerror(char const *s); 83 84extern struct boot_info *the_boot_info; 85extern int treesource_error; 86 87static unsigned long long eval_literal(const char *s, int base, int bits); 88 89 90/* Line 189 of yacc.c */ 91#line 92 "dtc-parser.tab.c" 92 93/* Enabling traces. */ 94#ifndef YYDEBUG 95# define YYDEBUG 0 96#endif 97 98/* Enabling verbose error messages. */ 99#ifdef YYERROR_VERBOSE 100# undef YYERROR_VERBOSE 101# define YYERROR_VERBOSE 1 102#else 103# define YYERROR_VERBOSE 0 104#endif 105 106/* Enabling the token table. */ 107#ifndef YYTOKEN_TABLE 108# define YYTOKEN_TABLE 0 109#endif 110 111 112/* Tokens. */ 113#ifndef YYTOKENTYPE 114# define YYTOKENTYPE 115 /* Put the tokens into the symbol table, so that GDB and other debuggers 116 know about them. */ 117 enum yytokentype { 118 DT_V1 = 258, 119 DT_MEMRESERVE = 259, 120 DT_PROPNODENAME = 260, 121 DT_LITERAL = 261, 122 DT_BASE = 262, 123 DT_BYTE = 263, 124 DT_STRING = 264, 125 DT_LABEL = 265, 126 DT_REF = 266, 127 DT_INCBIN = 267 128 }; 129#endif 130 131 132 133#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 134typedef union YYSTYPE 135{ 136 137/* Line 214 of yacc.c */ 138#line 39 "dtc-parser.y" 139 140 char *propnodename; 141 char *literal; 142 char *labelref; 143 unsigned int cbase; 144 uint8_t byte; 145 struct data data; 146 147 uint64_t addr; 148 cell_t cell; 149 struct property *prop; 150 struct property *proplist; 151 struct node *node; 152 struct node *nodelist; 153 struct reserve_info *re; 154 155 156 157/* Line 214 of yacc.c */ 158#line 159 "dtc-parser.tab.c" 159} YYSTYPE; 160# define YYSTYPE_IS_TRIVIAL 1 161# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 162# define YYSTYPE_IS_DECLARED 1 163#endif 164 165 166/* Copy the second part of user declarations. */ 167 168 169/* Line 264 of yacc.c */ 170#line 171 "dtc-parser.tab.c" 171 172#ifdef short 173# undef short 174#endif 175 176#ifdef YYTYPE_UINT8 177typedef YYTYPE_UINT8 yytype_uint8; 178#else 179typedef unsigned char yytype_uint8; 180#endif 181 182#ifdef YYTYPE_INT8 183typedef YYTYPE_INT8 yytype_int8; 184#elif (defined __STDC__ || defined __C99__FUNC__ \ 185 || defined __cplusplus || defined _MSC_VER) 186typedef signed char yytype_int8; 187#else 188typedef short int yytype_int8; 189#endif 190 191#ifdef YYTYPE_UINT16 192typedef YYTYPE_UINT16 yytype_uint16; 193#else 194typedef unsigned short int yytype_uint16; 195#endif 196 197#ifdef YYTYPE_INT16 198typedef YYTYPE_INT16 yytype_int16; 199#else 200typedef short int yytype_int16; 201#endif 202 203#ifndef YYSIZE_T 204# ifdef __SIZE_TYPE__ 205# define YYSIZE_T __SIZE_TYPE__ 206# elif defined size_t 207# define YYSIZE_T size_t 208# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 209 || defined __cplusplus || defined _MSC_VER) 210# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 211# define YYSIZE_T size_t 212# else 213# define YYSIZE_T unsigned int 214# endif 215#endif 216 217#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 218 219#ifndef YY_ 220# if YYENABLE_NLS 221# if ENABLE_NLS 222# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 223# define YY_(msgid) dgettext ("bison-runtime", msgid) 224# endif 225# endif 226# ifndef YY_ 227# define YY_(msgid) msgid 228# endif 229#endif 230 231/* Suppress unused-variable warnings by "using" E. */ 232#if ! defined lint || defined __GNUC__ 233# define YYUSE(e) ((void) (e)) 234#else 235# define YYUSE(e) /* empty */ 236#endif 237 238/* Identity function, used to suppress warnings about constant conditions. */ 239#ifndef lint 240# define YYID(n) (n) 241#else 242#if (defined __STDC__ || defined __C99__FUNC__ \ 243 || defined __cplusplus || defined _MSC_VER) 244static int 245YYID (int yyi) 246#else 247static int 248YYID (yyi) 249 int yyi; 250#endif 251{ 252 return yyi; 253} 254#endif 255 256#if ! defined yyoverflow || YYERROR_VERBOSE 257 258/* The parser invokes alloca or malloc; define the necessary symbols. */ 259 260# ifdef YYSTACK_USE_ALLOCA 261# if YYSTACK_USE_ALLOCA 262# ifdef __GNUC__ 263# define YYSTACK_ALLOC __builtin_alloca 264# elif defined __BUILTIN_VA_ARG_INCR 265# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 266# elif defined _AIX 267# define YYSTACK_ALLOC __alloca 268# elif defined _MSC_VER 269# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 270# define alloca _alloca 271# else 272# define YYSTACK_ALLOC alloca 273# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 274 || defined __cplusplus || defined _MSC_VER) 275# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 276# ifndef _STDLIB_H 277# define _STDLIB_H 1 278# endif 279# endif 280# endif 281# endif 282# endif 283 284# ifdef YYSTACK_ALLOC 285 /* Pacify GCC's `empty if-body' warning. */ 286# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 287# ifndef YYSTACK_ALLOC_MAXIMUM 288 /* The OS might guarantee only one guard page at the bottom of the stack, 289 and a page size can be as small as 4096 bytes. So we cannot safely 290 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 291 to allow for a few compiler-allocated temporary stack slots. */ 292# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 293# endif 294# else 295# define YYSTACK_ALLOC YYMALLOC 296# define YYSTACK_FREE YYFREE 297# ifndef YYSTACK_ALLOC_MAXIMUM 298# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 299# endif 300# if (defined __cplusplus && ! defined _STDLIB_H \ 301 && ! ((defined YYMALLOC || defined malloc) \ 302 && (defined YYFREE || defined free))) 303# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 304# ifndef _STDLIB_H 305# define _STDLIB_H 1 306# endif 307# endif 308# ifndef YYMALLOC 309# define YYMALLOC malloc 310# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 311 || defined __cplusplus || defined _MSC_VER) 312void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 313# endif 314# endif 315# ifndef YYFREE 316# define YYFREE free 317# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 318 || defined __cplusplus || defined _MSC_VER) 319void free (void *); /* INFRINGES ON USER NAME SPACE */ 320# endif 321# endif 322# endif 323#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 324 325 326#if (! defined yyoverflow \ 327 && (! defined __cplusplus \ 328 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 329 330/* A type that is properly aligned for any stack member. */ 331union yyalloc 332{ 333 yytype_int16 yyss_alloc; 334 YYSTYPE yyvs_alloc; 335}; 336 337/* The size of the maximum gap between one aligned stack and the next. */ 338# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 339 340/* The size of an array large to enough to hold all stacks, each with 341 N elements. */ 342# define YYSTACK_BYTES(N) \ 343 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 344 + YYSTACK_GAP_MAXIMUM) 345 346/* Copy COUNT objects from FROM to TO. The source and destination do 347 not overlap. */ 348# ifndef YYCOPY 349# if defined __GNUC__ && 1 < __GNUC__ 350# define YYCOPY(To, From, Count) \ 351 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 352# else 353# define YYCOPY(To, From, Count) \ 354 do \ 355 { \ 356 YYSIZE_T yyi; \ 357 for (yyi = 0; yyi < (Count); yyi++) \ 358 (To)[yyi] = (From)[yyi]; \ 359 } \ 360 while (YYID (0)) 361# endif 362# endif 363 364/* Relocate STACK from its old location to the new one. The 365 local variables YYSIZE and YYSTACKSIZE give the old and new number of 366 elements in the stack, and YYPTR gives the new location of the 367 stack. Advance YYPTR to a properly aligned location for the next 368 stack. */ 369# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 370 do \ 371 { \ 372 YYSIZE_T yynewbytes; \ 373 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 374 Stack = &yyptr->Stack_alloc; \ 375 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 376 yyptr += yynewbytes / sizeof (*yyptr); \ 377 } \ 378 while (YYID (0)) 379 380#endif 381 382/* YYFINAL -- State number of the termination state. */ 383#define YYFINAL 4 384/* YYLAST -- Last index in YYTABLE. */ 385#define YYLAST 56 386 387/* YYNTOKENS -- Number of terminals. */ 388#define YYNTOKENS 25 389/* YYNNTS -- Number of nonterminals. */ 390#define YYNNTS 16 391/* YYNRULES -- Number of rules. */ 392#define YYNRULES 39 393/* YYNRULES -- Number of states. */ 394#define YYNSTATES 67 395 396/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 397#define YYUNDEFTOK 2 398#define YYMAXUTOK 267 399 400#define YYTRANSLATE(YYX) \ 401 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 402 403/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 404static const yytype_uint8 yytranslate[] = 405{ 406 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 407 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 408 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 409 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 410 22, 24, 2, 2, 23, 2, 2, 14, 2, 2, 411 2, 2, 2, 2, 2, 2, 2, 2, 2, 13, 412 18, 17, 19, 2, 2, 2, 2, 2, 2, 2, 413 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 414 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 415 2, 20, 2, 21, 2, 2, 2, 2, 2, 2, 416 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 417 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 418 2, 2, 2, 15, 2, 16, 2, 2, 2, 2, 419 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 420 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 421 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 422 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 423 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 424 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 425 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 426 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 427 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 428 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 429 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 430 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 431 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 432 5, 6, 7, 8, 9, 10, 11, 12 433}; 434 435#if YYDEBUG 436/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 437 YYRHS. */ 438static const yytype_uint8 yyprhs[] = 439{ 440 0, 0, 3, 8, 9, 12, 17, 20, 22, 25, 441 29, 33, 39, 40, 43, 48, 51, 54, 57, 62, 442 67, 70, 80, 86, 89, 90, 93, 96, 97, 100, 443 103, 106, 108, 109, 112, 115, 116, 119, 122, 125 444}; 445 446/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 447static const yytype_int8 yyrhs[] = 448{ 449 26, 0, -1, 3, 13, 27, 30, -1, -1, 28, 450 27, -1, 4, 29, 29, 13, -1, 10, 28, -1, 451 6, -1, 14, 31, -1, 30, 14, 31, -1, 30, 452 11, 31, -1, 15, 32, 39, 16, 13, -1, -1, 453 32, 33, -1, 5, 17, 34, 13, -1, 5, 13, 454 -1, 10, 33, -1, 35, 9, -1, 35, 18, 36, 455 19, -1, 35, 20, 38, 21, -1, 35, 11, -1, 456 35, 12, 22, 9, 23, 29, 23, 29, 24, -1, 457 35, 12, 22, 9, 24, -1, 34, 10, -1, -1, 458 34, 23, -1, 35, 10, -1, -1, 36, 37, -1, 459 36, 11, -1, 36, 10, -1, 6, -1, -1, 38, 460 8, -1, 38, 10, -1, -1, 40, 39, -1, 40, 461 33, -1, 5, 31, -1, 10, 40, -1 462}; 463 464/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 465static const yytype_uint16 yyrline[] = 466{ 467 0, 86, 86, 95, 98, 105, 109, 117, 124, 128, 468 132, 145, 153, 156, 163, 167, 171, 179, 183, 187, 469 191, 195, 212, 222, 230, 233, 237, 245, 248, 252, 470 257, 264, 272, 275, 279, 287, 290, 294, 302, 306 471}; 472#endif 473 474#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 475/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 476 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 477static const char *const yytname[] = 478{ 479 "$end", "error", "$undefined", "DT_V1", "DT_MEMRESERVE", 480 "DT_PROPNODENAME", "DT_LITERAL", "DT_BASE", "DT_BYTE", "DT_STRING", 481 "DT_LABEL", "DT_REF", "DT_INCBIN", "';'", "'/'", "'{'", "'}'", "'='", 482 "'<'", "'>'", "'['", "']'", "'('", "','", "')'", "$accept", "sourcefile", 483 "memreserves", "memreserve", "addr", "devicetree", "nodedef", "proplist", 484 "propdef", "propdata", "propdataprefix", "celllist", "cellval", 485 "bytestring", "subnodes", "subnode", 0 486}; 487#endif 488 489# ifdef YYPRINT 490/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 491 token YYLEX-NUM. */ 492static const yytype_uint16 yytoknum[] = 493{ 494 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 495 265, 266, 267, 59, 47, 123, 125, 61, 60, 62, 496 91, 93, 40, 44, 41 497}; 498# endif 499 500/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 501static const yytype_uint8 yyr1[] = 502{ 503 0, 25, 26, 27, 27, 28, 28, 29, 30, 30, 504 30, 31, 32, 32, 33, 33, 33, 34, 34, 34, 505 34, 34, 34, 34, 35, 35, 35, 36, 36, 36, 506 36, 37, 38, 38, 38, 39, 39, 39, 40, 40 507}; 508 509/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 510static const yytype_uint8 yyr2[] = 511{ 512 0, 2, 4, 0, 2, 4, 2, 1, 2, 3, 513 3, 5, 0, 2, 4, 2, 2, 2, 4, 4, 514 2, 9, 5, 2, 0, 2, 2, 0, 2, 2, 515 2, 1, 0, 2, 2, 0, 2, 2, 2, 2 516}; 517 518/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 519 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 520 means the default is an error. */ 521static const yytype_uint8 yydefact[] = 522{ 523 0, 0, 0, 3, 1, 0, 0, 0, 3, 7, 524 0, 6, 0, 2, 4, 0, 12, 8, 0, 0, 525 5, 35, 10, 9, 0, 0, 13, 0, 35, 15, 526 24, 38, 16, 39, 0, 37, 36, 0, 0, 11, 527 23, 14, 25, 17, 26, 20, 0, 27, 32, 0, 528 0, 0, 0, 31, 30, 29, 18, 28, 33, 34, 529 19, 0, 22, 0, 0, 0, 21 530}; 531 532/* YYDEFGOTO[NTERM-NUM]. */ 533static const yytype_int8 yydefgoto[] = 534{ 535 -1, 2, 7, 8, 10, 13, 17, 21, 26, 37, 536 38, 50, 57, 51, 27, 28 537}; 538 539/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 540 STATE-NUM. */ 541#define YYPACT_NINF -12 542static const yytype_int8 yypact[] = 543{ 544 10, -11, 18, -1, -12, 22, -1, 15, -1, -12, 545 22, -12, 20, 1, -12, 17, -12, -12, 20, 20, 546 -12, 6, -12, -12, 21, 6, -12, 23, 6, -12, 547 -12, -12, -12, -12, 28, -12, -12, -6, 13, -12, 548 -12, -12, -12, -12, -12, -12, 24, -12, -12, 33, 549 -5, 0, -4, -12, -12, -12, -12, -12, -12, -12, 550 -12, 22, -12, 25, 22, 19, -12 551}; 552 553/* YYPGOTO[NTERM-NUM]. */ 554static const yytype_int8 yypgoto[] = 555{ 556 -12, -12, 36, 39, -10, -12, 8, -12, 12, -12, 557 -12, -12, -12, -12, 27, 31 558}; 559 560/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 561 positive, shift that token. If negative, reduce the rule which 562 number is the opposite. If zero, do what YYDEFACT says. 563 If YYTABLE_NINF, syntax error. */ 564#define YYTABLE_NINF -1 565static const yytype_uint8 yytable[] = 566{ 567 15, 53, 3, 5, 40, 54, 55, 41, 58, 6, 568 59, 24, 18, 1, 56, 19, 25, 42, 4, 61, 569 62, 60, 43, 44, 45, 46, 22, 23, 9, 12, 570 20, 47, 31, 48, 29, 16, 16, 32, 30, 34, 571 35, 39, 52, 66, 14, 11, 49, 0, 64, 0, 572 0, 63, 0, 0, 65, 36, 33 573}; 574 575static const yytype_int8 yycheck[] = 576{ 577 10, 6, 13, 4, 10, 10, 11, 13, 8, 10, 578 10, 5, 11, 3, 19, 14, 10, 23, 0, 23, 579 24, 21, 9, 10, 11, 12, 18, 19, 6, 14, 580 13, 18, 24, 20, 13, 15, 15, 25, 17, 16, 581 28, 13, 9, 24, 8, 6, 22, -1, 23, -1, 582 -1, 61, -1, -1, 64, 28, 25 583}; 584 585/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 586 symbol of state STATE-NUM. */ 587static const yytype_uint8 yystos[] = 588{ 589 0, 3, 26, 13, 0, 4, 10, 27, 28, 6, 590 29, 28, 14, 30, 27, 29, 15, 31, 11, 14, 591 13, 32, 31, 31, 5, 10, 33, 39, 40, 13, 592 17, 31, 33, 40, 16, 33, 39, 34, 35, 13, 593 10, 13, 23, 9, 10, 11, 12, 18, 20, 22, 594 36, 38, 9, 6, 10, 11, 19, 37, 8, 10, 595 21, 23, 24, 29, 23, 29, 24 596}; 597 598#define yyerrok (yyerrstatus = 0) 599#define yyclearin (yychar = YYEMPTY) 600#define YYEMPTY (-2) 601#define YYEOF 0 602 603#define YYACCEPT goto yyacceptlab 604#define YYABORT goto yyabortlab 605#define YYERROR goto yyerrorlab 606 607 608/* Like YYERROR except do call yyerror. This remains here temporarily 609 to ease the transition to the new meaning of YYERROR, for GCC. 610 Once GCC version 2 has supplanted version 1, this can go. */ 611 612#define YYFAIL goto yyerrlab 613 614#define YYRECOVERING() (!!yyerrstatus) 615 616#define YYBACKUP(Token, Value) \ 617do \ 618 if (yychar == YYEMPTY && yylen == 1) \ 619 { \ 620 yychar = (Token); \ 621 yylval = (Value); \ 622 yytoken = YYTRANSLATE (yychar); \ 623 YYPOPSTACK (1); \ 624 goto yybackup; \ 625 } \ 626 else \ 627 { \ 628 yyerror (YY_("syntax error: cannot back up")); \ 629 YYERROR; \ 630 } \ 631while (YYID (0)) 632 633 634#define YYTERROR 1 635#define YYERRCODE 256 636 637 638/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 639 If N is 0, then set CURRENT to the empty location which ends 640 the previous symbol: RHS[0] (always defined). */ 641 642#define YYRHSLOC(Rhs, K) ((Rhs)[K]) 643#ifndef YYLLOC_DEFAULT 644# define YYLLOC_DEFAULT(Current, Rhs, N) \ 645 do \ 646 if (YYID (N)) \ 647 { \ 648 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 649 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 650 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 651 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 652 } \ 653 else \ 654 { \ 655 (Current).first_line = (Current).last_line = \ 656 YYRHSLOC (Rhs, 0).last_line; \ 657 (Current).first_column = (Current).last_column = \ 658 YYRHSLOC (Rhs, 0).last_column; \ 659 } \ 660 while (YYID (0)) 661#endif 662 663 664/* YY_LOCATION_PRINT -- Print the location on the stream. 665 This macro was not mandated originally: define only if we know 666 we won't break user code: when these are the locations we know. */ 667 668#ifndef YY_LOCATION_PRINT 669# if YYLTYPE_IS_TRIVIAL 670# define YY_LOCATION_PRINT(File, Loc) \ 671 fprintf (File, "%d.%d-%d.%d", \ 672 (Loc).first_line, (Loc).first_column, \ 673 (Loc).last_line, (Loc).last_column) 674# else 675# define YY_LOCATION_PRINT(File, Loc) ((void) 0) 676# endif 677#endif 678 679 680/* YYLEX -- calling `yylex' with the right arguments. */ 681 682#ifdef YYLEX_PARAM 683# define YYLEX yylex (YYLEX_PARAM) 684#else 685# define YYLEX yylex () 686#endif 687 688/* Enable debugging if requested. */ 689#if YYDEBUG 690 691# ifndef YYFPRINTF 692# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 693# define YYFPRINTF fprintf 694# endif 695 696# define YYDPRINTF(Args) \ 697do { \ 698 if (yydebug) \ 699 YYFPRINTF Args; \ 700} while (YYID (0)) 701 702# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 703do { \ 704 if (yydebug) \ 705 { \ 706 YYFPRINTF (stderr, "%s ", Title); \ 707 yy_symbol_print (stderr, \ 708 Type, Value); \ 709 YYFPRINTF (stderr, "\n"); \ 710 } \ 711} while (YYID (0)) 712 713 714/*--------------------------------. 715| Print this symbol on YYOUTPUT. | 716`--------------------------------*/ 717 718/*ARGSUSED*/ 719#if (defined __STDC__ || defined __C99__FUNC__ \ 720 || defined __cplusplus || defined _MSC_VER) 721static void 722yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 723#else 724static void 725yy_symbol_value_print (yyoutput, yytype, yyvaluep) 726 FILE *yyoutput; 727 int yytype; 728 YYSTYPE const * const yyvaluep; 729#endif 730{ 731 if (!yyvaluep) 732 return; 733# ifdef YYPRINT 734 if (yytype < YYNTOKENS) 735 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 736# else 737 YYUSE (yyoutput); 738# endif 739 switch (yytype) 740 { 741 default: 742 break; 743 } 744} 745 746 747/*--------------------------------. 748| Print this symbol on YYOUTPUT. | 749`--------------------------------*/ 750 751#if (defined __STDC__ || defined __C99__FUNC__ \ 752 || defined __cplusplus || defined _MSC_VER) 753static void 754yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 755#else 756static void 757yy_symbol_print (yyoutput, yytype, yyvaluep) 758 FILE *yyoutput; 759 int yytype; 760 YYSTYPE const * const yyvaluep; 761#endif 762{ 763 if (yytype < YYNTOKENS) 764 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 765 else 766 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 767 768 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 769 YYFPRINTF (yyoutput, ")"); 770} 771 772/*------------------------------------------------------------------. 773| yy_stack_print -- Print the state stack from its BOTTOM up to its | 774| TOP (included). | 775`------------------------------------------------------------------*/ 776 777#if (defined __STDC__ || defined __C99__FUNC__ \ 778 || defined __cplusplus || defined _MSC_VER) 779static void 780yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 781#else 782static void 783yy_stack_print (yybottom, yytop) 784 yytype_int16 *yybottom; 785 yytype_int16 *yytop; 786#endif 787{ 788 YYFPRINTF (stderr, "Stack now"); 789 for (; yybottom <= yytop; yybottom++) 790 { 791 int yybot = *yybottom; 792 YYFPRINTF (stderr, " %d", yybot); 793 } 794 YYFPRINTF (stderr, "\n"); 795} 796 797# define YY_STACK_PRINT(Bottom, Top) \ 798do { \ 799 if (yydebug) \ 800 yy_stack_print ((Bottom), (Top)); \ 801} while (YYID (0)) 802 803 804/*------------------------------------------------. 805| Report that the YYRULE is going to be reduced. | 806`------------------------------------------------*/ 807 808#if (defined __STDC__ || defined __C99__FUNC__ \ 809 || defined __cplusplus || defined _MSC_VER) 810static void 811yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 812#else 813static void 814yy_reduce_print (yyvsp, yyrule) 815 YYSTYPE *yyvsp; 816 int yyrule; 817#endif 818{ 819 int yynrhs = yyr2[yyrule]; 820 int yyi; 821 unsigned long int yylno = yyrline[yyrule]; 822 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 823 yyrule - 1, yylno); 824 /* The symbols being reduced. */ 825 for (yyi = 0; yyi < yynrhs; yyi++) 826 { 827 YYFPRINTF (stderr, " $%d = ", yyi + 1); 828 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 829 &(yyvsp[(yyi + 1) - (yynrhs)]) 830 ); 831 YYFPRINTF (stderr, "\n"); 832 } 833} 834 835# define YY_REDUCE_PRINT(Rule) \ 836do { \ 837 if (yydebug) \ 838 yy_reduce_print (yyvsp, Rule); \ 839} while (YYID (0)) 840 841/* Nonzero means print parse trace. It is left uninitialized so that 842 multiple parsers can coexist. */ 843int yydebug; 844#else /* !YYDEBUG */ 845# define YYDPRINTF(Args) 846# define YY_SYMBOL_PRINT(Title, Type, Value, Location) 847# define YY_STACK_PRINT(Bottom, Top) 848# define YY_REDUCE_PRINT(Rule) 849#endif /* !YYDEBUG */ 850 851 852/* YYINITDEPTH -- initial size of the parser's stacks. */ 853#ifndef YYINITDEPTH 854# define YYINITDEPTH 200 855#endif 856 857/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 858 if the built-in stack extension method is used). 859 860 Do not make this value too large; the results are undefined if 861 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 862 evaluated with infinite-precision integer arithmetic. */ 863 864#ifndef YYMAXDEPTH 865# define YYMAXDEPTH 10000 866#endif 867 868 869 870#if YYERROR_VERBOSE 871 872# ifndef yystrlen 873# if defined __GLIBC__ && defined _STRING_H 874# define yystrlen strlen 875# else 876/* Return the length of YYSTR. */ 877#if (defined __STDC__ || defined __C99__FUNC__ \ 878 || defined __cplusplus || defined _MSC_VER) 879static YYSIZE_T 880yystrlen (const char *yystr) 881#else 882static YYSIZE_T 883yystrlen (yystr) 884 const char *yystr; 885#endif 886{ 887 YYSIZE_T yylen; 888 for (yylen = 0; yystr[yylen]; yylen++) 889 continue; 890 return yylen; 891} 892# endif 893# endif 894 895# ifndef yystpcpy 896# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 897# define yystpcpy stpcpy 898# else 899/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 900 YYDEST. */ 901#if (defined __STDC__ || defined __C99__FUNC__ \ 902 || defined __cplusplus || defined _MSC_VER) 903static char * 904yystpcpy (char *yydest, const char *yysrc) 905#else 906static char * 907yystpcpy (yydest, yysrc) 908 char *yydest; 909 const char *yysrc; 910#endif 911{ 912 char *yyd = yydest; 913 const char *yys = yysrc; 914 915 while ((*yyd++ = *yys++) != '\0') 916 continue; 917 918 return yyd - 1; 919} 920# endif 921# endif 922 923# ifndef yytnamerr 924/* Copy to YYRES the contents of YYSTR after stripping away unnecessary 925 quotes and backslashes, so that it's suitable for yyerror. The 926 heuristic is that double-quoting is unnecessary unless the string 927 contains an apostrophe, a comma, or backslash (other than 928 backslash-backslash). YYSTR is taken from yytname. If YYRES is 929 null, do not copy; instead, return the length of what the result 930 would have been. */ 931static YYSIZE_T 932yytnamerr (char *yyres, const char *yystr) 933{ 934 if (*yystr == '"') 935 { 936 YYSIZE_T yyn = 0; 937 char const *yyp = yystr; 938 939 for (;;) 940 switch (*++yyp) 941 { 942 case '\'': 943 case ',': 944 goto do_not_strip_quotes; 945 946 case '\\': 947 if (*++yyp != '\\') 948 goto do_not_strip_quotes; 949 /* Fall through. */ 950 default: 951 if (yyres) 952 yyres[yyn] = *yyp; 953 yyn++; 954 break; 955 956 case '"': 957 if (yyres) 958 yyres[yyn] = '\0'; 959 return yyn; 960 } 961 do_not_strip_quotes: ; 962 } 963 964 if (! yyres) 965 return yystrlen (yystr); 966 967 return yystpcpy (yyres, yystr) - yyres; 968} 969# endif 970 971/* Copy into YYRESULT an error message about the unexpected token 972 YYCHAR while in state YYSTATE. Return the number of bytes copied, 973 including the terminating null byte. If YYRESULT is null, do not 974 copy anything; just return the number of bytes that would be 975 copied. As a special case, return 0 if an ordinary "syntax error" 976 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 977 size calculation. */ 978static YYSIZE_T 979yysyntax_error (char *yyresult, int yystate, int yychar) 980{ 981 int yyn = yypact[yystate]; 982 983 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 984 return 0; 985 else 986 { 987 int yytype = YYTRANSLATE (yychar); 988 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 989 YYSIZE_T yysize = yysize0; 990 YYSIZE_T yysize1; 991 int yysize_overflow = 0; 992 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 993 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 994 int yyx; 995 996# if 0 997 /* This is so xgettext sees the translatable formats that are 998 constructed on the fly. */ 999 YY_("syntax error, unexpected %s"); 1000 YY_("syntax error, unexpected %s, expecting %s"); 1001 YY_("syntax error, unexpected %s, expecting %s or %s"); 1002 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 1003 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 1004# endif 1005 char *yyfmt; 1006 char const *yyf; 1007 static char const yyunexpected[] = "syntax error, unexpected %s"; 1008 static char const yyexpecting[] = ", expecting %s"; 1009 static char const yyor[] = " or %s"; 1010 char yyformat[sizeof yyunexpected 1011 + sizeof yyexpecting - 1 1012 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 1013 * (sizeof yyor - 1))]; 1014 char const *yyprefix = yyexpecting; 1015 1016 /* Start YYX at -YYN if negative to avoid negative indexes in 1017 YYCHECK. */ 1018 int yyxbegin = yyn < 0 ? -yyn : 0; 1019 1020 /* Stay within bounds of both yycheck and yytname. */ 1021 int yychecklim = YYLAST - yyn + 1; 1022 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1023 int yycount = 1; 1024 1025 yyarg[0] = yytname[yytype]; 1026 yyfmt = yystpcpy (yyformat, yyunexpected); 1027 1028 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1029 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1030 { 1031 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1032 { 1033 yycount = 1; 1034 yysize = yysize0; 1035 yyformat[sizeof yyunexpected - 1] = '\0'; 1036 break; 1037 } 1038 yyarg[yycount++] = yytname[yyx]; 1039 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1040 yysize_overflow |= (yysize1 < yysize); 1041 yysize = yysize1; 1042 yyfmt = yystpcpy (yyfmt, yyprefix); 1043 yyprefix = yyor; 1044 } 1045 1046 yyf = YY_(yyformat); 1047 yysize1 = yysize + yystrlen (yyf); 1048 yysize_overflow |= (yysize1 < yysize); 1049 yysize = yysize1; 1050 1051 if (yysize_overflow) 1052 return YYSIZE_MAXIMUM; 1053 1054 if (yyresult) 1055 { 1056 /* Avoid sprintf, as that infringes on the user's name space. 1057 Don't have undefined behavior even if the translation 1058 produced a string with the wrong number of "%s"s. */ 1059 char *yyp = yyresult; 1060 int yyi = 0; 1061 while ((*yyp = *yyf) != '\0') 1062 { 1063 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 1064 { 1065 yyp += yytnamerr (yyp, yyarg[yyi++]); 1066 yyf += 2; 1067 } 1068 else 1069 { 1070 yyp++; 1071 yyf++; 1072 } 1073 } 1074 } 1075 return yysize; 1076 } 1077} 1078#endif /* YYERROR_VERBOSE */ 1079 1080 1081/*-----------------------------------------------. 1082| Release the memory associated to this symbol. | 1083`-----------------------------------------------*/ 1084 1085/*ARGSUSED*/ 1086#if (defined __STDC__ || defined __C99__FUNC__ \ 1087 || defined __cplusplus || defined _MSC_VER) 1088static void 1089yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1090#else 1091static void 1092yydestruct (yymsg, yytype, yyvaluep) 1093 const char *yymsg; 1094 int yytype; 1095 YYSTYPE *yyvaluep; 1096#endif 1097{ 1098 YYUSE (yyvaluep); 1099 1100 if (!yymsg) 1101 yymsg = "Deleting"; 1102 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1103 1104 switch (yytype) 1105 { 1106 1107 default: 1108 break; 1109 } 1110} 1111 1112/* Prevent warnings from -Wmissing-prototypes. */ 1113#ifdef YYPARSE_PARAM 1114#if defined __STDC__ || defined __cplusplus 1115int yyparse (void *YYPARSE_PARAM); 1116#else 1117int yyparse (); 1118#endif 1119#else /* ! YYPARSE_PARAM */ 1120#if defined __STDC__ || defined __cplusplus 1121int yyparse (void); 1122#else 1123int yyparse (); 1124#endif 1125#endif /* ! YYPARSE_PARAM */ 1126 1127 1128/* The lookahead symbol. */ 1129int yychar; 1130 1131/* The semantic value of the lookahead symbol. */ 1132YYSTYPE yylval; 1133 1134/* Number of syntax errors so far. */ 1135int yynerrs; 1136 1137 1138 1139/*-------------------------. 1140| yyparse or yypush_parse. | 1141`-------------------------*/ 1142 1143#ifdef YYPARSE_PARAM 1144#if (defined __STDC__ || defined __C99__FUNC__ \ 1145 || defined __cplusplus || defined _MSC_VER) 1146int 1147yyparse (void *YYPARSE_PARAM) 1148#else 1149int 1150yyparse (YYPARSE_PARAM) 1151 void *YYPARSE_PARAM; 1152#endif 1153#else /* ! YYPARSE_PARAM */ 1154#if (defined __STDC__ || defined __C99__FUNC__ \ 1155 || defined __cplusplus || defined _MSC_VER) 1156int 1157yyparse (void) 1158#else 1159int 1160yyparse () 1161 1162#endif 1163#endif 1164{ 1165 1166 1167 int yystate; 1168 /* Number of tokens to shift before error messages enabled. */ 1169 int yyerrstatus; 1170 1171 /* The stacks and their tools: 1172 `yyss': related to states. 1173 `yyvs': related to semantic values. 1174 1175 Refer to the stacks thru separate pointers, to allow yyoverflow 1176 to reallocate them elsewhere. */ 1177 1178 /* The state stack. */ 1179 yytype_int16 yyssa[YYINITDEPTH]; 1180 yytype_int16 *yyss; 1181 yytype_int16 *yyssp; 1182 1183 /* The semantic value stack. */ 1184 YYSTYPE yyvsa[YYINITDEPTH]; 1185 YYSTYPE *yyvs; 1186 YYSTYPE *yyvsp; 1187 1188 YYSIZE_T yystacksize; 1189 1190 int yyn; 1191 int yyresult; 1192 /* Lookahead token as an internal (translated) token number. */ 1193 int yytoken; 1194 /* The variables used to return semantic value and location from the 1195 action routines. */ 1196 YYSTYPE yyval; 1197 1198#if YYERROR_VERBOSE 1199 /* Buffer for error messages, and its allocated size. */ 1200 char yymsgbuf[128]; 1201 char *yymsg = yymsgbuf; 1202 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1203#endif 1204 1205#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1206 1207 /* The number of symbols on the RHS of the reduced rule. 1208 Keep to zero when no symbol should be popped. */ 1209 int yylen = 0; 1210 1211 yytoken = 0; 1212 yyss = yyssa; 1213 yyvs = yyvsa; 1214 yystacksize = YYINITDEPTH; 1215 1216 YYDPRINTF ((stderr, "Starting parse\n")); 1217 1218 yystate = 0; 1219 yyerrstatus = 0; 1220 yynerrs = 0; 1221 yychar = YYEMPTY; /* Cause a token to be read. */ 1222 1223 /* Initialize stack pointers. 1224 Waste one element of value and location stack 1225 so that they stay on the same level as the state stack. 1226 The wasted elements are never initialized. */ 1227 yyssp = yyss; 1228 yyvsp = yyvs; 1229 1230 goto yysetstate; 1231 1232/*------------------------------------------------------------. 1233| yynewstate -- Push a new state, which is found in yystate. | 1234`------------------------------------------------------------*/ 1235 yynewstate: 1236 /* In all cases, when you get here, the value and location stacks 1237 have just been pushed. So pushing a state here evens the stacks. */ 1238 yyssp++; 1239 1240 yysetstate: 1241 *yyssp = yystate; 1242 1243 if (yyss + yystacksize - 1 <= yyssp) 1244 { 1245 /* Get the current used size of the three stacks, in elements. */ 1246 YYSIZE_T yysize = yyssp - yyss + 1; 1247 1248#ifdef yyoverflow 1249 { 1250 /* Give user a chance to reallocate the stack. Use copies of 1251 these so that the &'s don't force the real ones into 1252 memory. */ 1253 YYSTYPE *yyvs1 = yyvs; 1254 yytype_int16 *yyss1 = yyss; 1255 1256 /* Each stack pointer address is followed by the size of the 1257 data in use in that stack, in bytes. This used to be a 1258 conditional around just the two extra args, but that might 1259 be undefined if yyoverflow is a macro. */ 1260 yyoverflow (YY_("memory exhausted"), 1261 &yyss1, yysize * sizeof (*yyssp), 1262 &yyvs1, yysize * sizeof (*yyvsp), 1263 &yystacksize); 1264 1265 yyss = yyss1; 1266 yyvs = yyvs1; 1267 } 1268#else /* no yyoverflow */ 1269# ifndef YYSTACK_RELOCATE 1270 goto yyexhaustedlab; 1271# else 1272 /* Extend the stack our own way. */ 1273 if (YYMAXDEPTH <= yystacksize) 1274 goto yyexhaustedlab; 1275 yystacksize *= 2; 1276 if (YYMAXDEPTH < yystacksize) 1277 yystacksize = YYMAXDEPTH; 1278 1279 { 1280 yytype_int16 *yyss1 = yyss; 1281 union yyalloc *yyptr = 1282 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1283 if (! yyptr) 1284 goto yyexhaustedlab; 1285 YYSTACK_RELOCATE (yyss_alloc, yyss); 1286 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1287# undef YYSTACK_RELOCATE 1288 if (yyss1 != yyssa) 1289 YYSTACK_FREE (yyss1); 1290 } 1291# endif 1292#endif /* no yyoverflow */ 1293 1294 yyssp = yyss + yysize - 1; 1295 yyvsp = yyvs + yysize - 1; 1296 1297 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1298 (unsigned long int) yystacksize)); 1299 1300 if (yyss + yystacksize - 1 <= yyssp) 1301 YYABORT; 1302 } 1303 1304 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1305 1306 if (yystate == YYFINAL) 1307 YYACCEPT; 1308 1309 goto yybackup; 1310 1311/*-----------. 1312| yybackup. | 1313`-----------*/ 1314yybackup: 1315 1316 /* Do appropriate processing given the current state. Read a 1317 lookahead token if we need one and don't already have one. */ 1318 1319 /* First try to decide what to do without reference to lookahead token. */ 1320 yyn = yypact[yystate]; 1321 if (yyn == YYPACT_NINF) 1322 goto yydefault; 1323 1324 /* Not known => get a lookahead token if don't already have one. */ 1325 1326 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1327 if (yychar == YYEMPTY) 1328 { 1329 YYDPRINTF ((stderr, "Reading a token: ")); 1330 yychar = YYLEX; 1331 } 1332 1333 if (yychar <= YYEOF) 1334 { 1335 yychar = yytoken = YYEOF; 1336 YYDPRINTF ((stderr, "Now at end of input.\n")); 1337 } 1338 else 1339 { 1340 yytoken = YYTRANSLATE (yychar); 1341 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1342 } 1343 1344 /* If the proper action on seeing token YYTOKEN is to reduce or to 1345 detect an error, take that action. */ 1346 yyn += yytoken; 1347 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1348 goto yydefault; 1349 yyn = yytable[yyn]; 1350 if (yyn <= 0) 1351 { 1352 if (yyn == 0 || yyn == YYTABLE_NINF) 1353 goto yyerrlab; 1354 yyn = -yyn; 1355 goto yyreduce; 1356 } 1357 1358 /* Count tokens shifted since error; after three, turn off error 1359 status. */ 1360 if (yyerrstatus) 1361 yyerrstatus--; 1362 1363 /* Shift the lookahead token. */ 1364 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1365 1366 /* Discard the shifted token. */ 1367 yychar = YYEMPTY; 1368 1369 yystate = yyn; 1370 *++yyvsp = yylval; 1371 1372 goto yynewstate; 1373 1374 1375/*-----------------------------------------------------------. 1376| yydefault -- do the default action for the current state. | 1377`-----------------------------------------------------------*/ 1378yydefault: 1379 yyn = yydefact[yystate]; 1380 if (yyn == 0) 1381 goto yyerrlab; 1382 goto yyreduce; 1383 1384 1385/*-----------------------------. 1386| yyreduce -- Do a reduction. | 1387`-----------------------------*/ 1388yyreduce: 1389 /* yyn is the number of a rule to reduce with. */ 1390 yylen = yyr2[yyn]; 1391 1392 /* If YYLEN is nonzero, implement the default value of the action: 1393 `$$ = $1'. 1394 1395 Otherwise, the following line sets YYVAL to garbage. 1396 This behavior is undocumented and Bison 1397 users should not rely upon it. Assigning to YYVAL 1398 unconditionally makes the parser a bit smaller, and it avoids a 1399 GCC warning that YYVAL may be used uninitialized. */ 1400 yyval = yyvsp[1-yylen]; 1401 1402 1403 YY_REDUCE_PRINT (yyn); 1404 switch (yyn) 1405 { 1406 case 2: 1407 1408/* Line 1455 of yacc.c */ 1409#line 87 "dtc-parser.y" 1410 { 1411 the_boot_info = build_boot_info((yyvsp[(3) - (4)].re), (yyvsp[(4) - (4)].node), 1412 guess_boot_cpuid((yyvsp[(4) - (4)].node))); 1413 ;} 1414 break; 1415 1416 case 3: 1417 1418/* Line 1455 of yacc.c */ 1419#line 95 "dtc-parser.y" 1420 { 1421 (yyval.re) = NULL; 1422 ;} 1423 break; 1424 1425 case 4: 1426 1427/* Line 1455 of yacc.c */ 1428#line 99 "dtc-parser.y" 1429 { 1430 (yyval.re) = chain_reserve_entry((yyvsp[(1) - (2)].re), (yyvsp[(2) - (2)].re)); 1431 ;} 1432 break; 1433 1434 case 5: 1435 1436/* Line 1455 of yacc.c */ 1437#line 106 "dtc-parser.y" 1438 { 1439 (yyval.re) = build_reserve_entry((yyvsp[(2) - (4)].addr), (yyvsp[(3) - (4)].addr)); 1440 ;} 1441 break; 1442 1443 case 6: 1444 1445/* Line 1455 of yacc.c */ 1446#line 110 "dtc-parser.y" 1447 { 1448 add_label(&(yyvsp[(2) - (2)].re)->labels, (yyvsp[(1) - (2)].labelref)); 1449 (yyval.re) = (yyvsp[(2) - (2)].re); 1450 ;} 1451 break; 1452 1453 case 7: 1454 1455/* Line 1455 of yacc.c */ 1456#line 118 "dtc-parser.y" 1457 { 1458 (yyval.addr) = eval_literal((yyvsp[(1) - (1)].literal), 0, 64); 1459 ;} 1460 break; 1461 1462 case 8: 1463 1464/* Line 1455 of yacc.c */ 1465#line 125 "dtc-parser.y" 1466 { 1467 (yyval.node) = name_node((yyvsp[(2) - (2)].node), ""); 1468 ;} 1469 break; 1470 1471 case 9: 1472 1473/* Line 1455 of yacc.c */ 1474#line 129 "dtc-parser.y" 1475 { 1476 (yyval.node) = merge_nodes((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); 1477 ;} 1478 break; 1479 1480 case 10: 1481 1482/* Line 1455 of yacc.c */ 1483#line 133 "dtc-parser.y" 1484 { 1485 struct node *target = get_node_by_ref((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].labelref)); 1486 1487 if (target) 1488 merge_nodes(target, (yyvsp[(3) - (3)].node)); 1489 else 1490 print_error("label or path, '%s', not found", (yyvsp[(2) - (3)].labelref)); 1491 (yyval.node) = (yyvsp[(1) - (3)].node); 1492 ;} 1493 break; 1494 1495 case 11: 1496 1497/* Line 1455 of yacc.c */ 1498#line 146 "dtc-parser.y" 1499 { 1500 (yyval.node) = build_node((yyvsp[(2) - (5)].proplist), (yyvsp[(3) - (5)].nodelist)); 1501 ;} 1502 break; 1503 1504 case 12: 1505 1506/* Line 1455 of yacc.c */ 1507#line 153 "dtc-parser.y" 1508 { 1509 (yyval.proplist) = NULL; 1510 ;} 1511 break; 1512 1513 case 13: 1514 1515/* Line 1455 of yacc.c */ 1516#line 157 "dtc-parser.y" 1517 { 1518 (yyval.proplist) = chain_property((yyvsp[(2) - (2)].prop), (yyvsp[(1) - (2)].proplist)); 1519 ;} 1520 break; 1521 1522 case 14: 1523 1524/* Line 1455 of yacc.c */ 1525#line 164 "dtc-parser.y" 1526 { 1527 (yyval.prop) = build_property((yyvsp[(1) - (4)].propnodename), (yyvsp[(3) - (4)].data)); 1528 ;} 1529 break; 1530 1531 case 15: 1532 1533/* Line 1455 of yacc.c */ 1534#line 168 "dtc-parser.y" 1535 { 1536 (yyval.prop) = build_property((yyvsp[(1) - (2)].propnodename), empty_data); 1537 ;} 1538 break; 1539 1540 case 16: 1541 1542/* Line 1455 of yacc.c */ 1543#line 172 "dtc-parser.y" 1544 { 1545 add_label(&(yyvsp[(2) - (2)].prop)->labels, (yyvsp[(1) - (2)].labelref)); 1546 (yyval.prop) = (yyvsp[(2) - (2)].prop); 1547 ;} 1548 break; 1549 1550 case 17: 1551 1552/* Line 1455 of yacc.c */ 1553#line 180 "dtc-parser.y" 1554 { 1555 (yyval.data) = data_merge((yyvsp[(1) - (2)].data), (yyvsp[(2) - (2)].data)); 1556 ;} 1557 break; 1558 1559 case 18: 1560 1561/* Line 1455 of yacc.c */ 1562#line 184 "dtc-parser.y" 1563 { 1564 (yyval.data) = data_merge((yyvsp[(1) - (4)].data), (yyvsp[(3) - (4)].data)); 1565 ;} 1566 break; 1567 1568 case 19: 1569 1570/* Line 1455 of yacc.c */ 1571#line 188 "dtc-parser.y" 1572 { 1573 (yyval.data) = data_merge((yyvsp[(1) - (4)].data), (yyvsp[(3) - (4)].data)); 1574 ;} 1575 break; 1576 1577 case 20: 1578 1579/* Line 1455 of yacc.c */ 1580#line 192 "dtc-parser.y" 1581 { 1582 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), REF_PATH, (yyvsp[(2) - (2)].labelref)); 1583 ;} 1584 break; 1585 1586 case 21: 1587 1588/* Line 1455 of yacc.c */ 1589#line 196 "dtc-parser.y" 1590 { 1591 FILE *f = srcfile_relative_open((yyvsp[(4) - (9)].data).val, NULL); 1592 struct data d; 1593 1594 if ((yyvsp[(6) - (9)].addr) != 0) 1595 if (fseek(f, (yyvsp[(6) - (9)].addr), SEEK_SET) != 0) 1596 print_error("Couldn't seek to offset %llu in \"%s\": %s", 1597 (unsigned long long)(yyvsp[(6) - (9)].addr), 1598 (yyvsp[(4) - (9)].data).val, 1599 strerror(errno)); 1600 1601 d = data_copy_file(f, (yyvsp[(8) - (9)].addr)); 1602 1603 (yyval.data) = data_merge((yyvsp[(1) - (9)].data), d); 1604 fclose(f); 1605 ;} 1606 break; 1607 1608 case 22: 1609 1610/* Line 1455 of yacc.c */ 1611#line 213 "dtc-parser.y" 1612 { 1613 FILE *f = srcfile_relative_open((yyvsp[(4) - (5)].data).val, NULL); 1614 struct data d = empty_data; 1615 1616 d = data_copy_file(f, -1); 1617 1618 (yyval.data) = data_merge((yyvsp[(1) - (5)].data), d); 1619 fclose(f); 1620 ;} 1621 break; 1622 1623 case 23: 1624 1625/* Line 1455 of yacc.c */ 1626#line 223 "dtc-parser.y" 1627 { 1628 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref)); 1629 ;} 1630 break; 1631 1632 case 24: 1633 1634/* Line 1455 of yacc.c */ 1635#line 230 "dtc-parser.y" 1636 { 1637 (yyval.data) = empty_data; 1638 ;} 1639 break; 1640 1641 case 25: 1642 1643/* Line 1455 of yacc.c */ 1644#line 234 "dtc-parser.y" 1645 { 1646 (yyval.data) = (yyvsp[(1) - (2)].data); 1647 ;} 1648 break; 1649 1650 case 26: 1651 1652/* Line 1455 of yacc.c */ 1653#line 238 "dtc-parser.y" 1654 { 1655 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref)); 1656 ;} 1657 break; 1658 1659 case 27: 1660 1661/* Line 1455 of yacc.c */ 1662#line 245 "dtc-parser.y" 1663 { 1664 (yyval.data) = empty_data; 1665 ;} 1666 break; 1667 1668 case 28: 1669 1670/* Line 1455 of yacc.c */ 1671#line 249 "dtc-parser.y" 1672 { 1673 (yyval.data) = data_append_cell((yyvsp[(1) - (2)].data), (yyvsp[(2) - (2)].cell)); 1674 ;} 1675 break; 1676 1677 case 29: 1678 1679/* Line 1455 of yacc.c */ 1680#line 253 "dtc-parser.y" 1681 { 1682 (yyval.data) = data_append_cell(data_add_marker((yyvsp[(1) - (2)].data), REF_PHANDLE, 1683 (yyvsp[(2) - (2)].labelref)), -1); 1684 ;} 1685 break; 1686 1687 case 30: 1688 1689/* Line 1455 of yacc.c */ 1690#line 258 "dtc-parser.y" 1691 { 1692 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref)); 1693 ;} 1694 break; 1695 1696 case 31: 1697 1698/* Line 1455 of yacc.c */ 1699#line 265 "dtc-parser.y" 1700 { 1701 (yyval.cell) = eval_literal((yyvsp[(1) - (1)].literal), 0, 32); 1702 ;} 1703 break; 1704 1705 case 32: 1706 1707/* Line 1455 of yacc.c */ 1708#line 272 "dtc-parser.y" 1709 { 1710 (yyval.data) = empty_data; 1711 ;} 1712 break; 1713 1714 case 33: 1715 1716/* Line 1455 of yacc.c */ 1717#line 276 "dtc-parser.y" 1718 { 1719 (yyval.data) = data_append_byte((yyvsp[(1) - (2)].data), (yyvsp[(2) - (2)].byte)); 1720 ;} 1721 break; 1722 1723 case 34: 1724 1725/* Line 1455 of yacc.c */ 1726#line 280 "dtc-parser.y" 1727 { 1728 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref)); 1729 ;} 1730 break; 1731 1732 case 35: 1733 1734/* Line 1455 of yacc.c */ 1735#line 287 "dtc-parser.y" 1736 { 1737 (yyval.nodelist) = NULL; 1738 ;} 1739 break; 1740 1741 case 36: 1742 1743/* Line 1455 of yacc.c */ 1744#line 291 "dtc-parser.y" 1745 { 1746 (yyval.nodelist) = chain_node((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].nodelist)); 1747 ;} 1748 break; 1749 1750 case 37: 1751 1752/* Line 1455 of yacc.c */ 1753#line 295 "dtc-parser.y" 1754 { 1755 print_error("syntax error: properties must precede subnodes"); 1756 YYERROR; 1757 ;} 1758 break; 1759 1760 case 38: 1761 1762/* Line 1455 of yacc.c */ 1763#line 303 "dtc-parser.y" 1764 { 1765 (yyval.node) = name_node((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].propnodename)); 1766 ;} 1767 break; 1768 1769 case 39: 1770 1771/* Line 1455 of yacc.c */ 1772#line 307 "dtc-parser.y" 1773 { 1774 add_label(&(yyvsp[(2) - (2)].node)->labels, (yyvsp[(1) - (2)].labelref)); 1775 (yyval.node) = (yyvsp[(2) - (2)].node); 1776 ;} 1777 break; 1778 1779 1780 1781/* Line 1455 of yacc.c */ 1782#line 1783 "dtc-parser.tab.c" 1783 default: break; 1784 } 1785 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1786 1787 YYPOPSTACK (yylen); 1788 yylen = 0; 1789 YY_STACK_PRINT (yyss, yyssp); 1790 1791 *++yyvsp = yyval; 1792 1793 /* Now `shift' the result of the reduction. Determine what state 1794 that goes to, based on the state we popped back to and the rule 1795 number reduced by. */ 1796 1797 yyn = yyr1[yyn]; 1798 1799 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1800 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1801 yystate = yytable[yystate]; 1802 else 1803 yystate = yydefgoto[yyn - YYNTOKENS]; 1804 1805 goto yynewstate; 1806 1807 1808/*------------------------------------. 1809| yyerrlab -- here on detecting error | 1810`------------------------------------*/ 1811yyerrlab: 1812 /* If not already recovering from an error, report this error. */ 1813 if (!yyerrstatus) 1814 { 1815 ++yynerrs; 1816#if ! YYERROR_VERBOSE 1817 yyerror (YY_("syntax error")); 1818#else 1819 { 1820 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 1821 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 1822 { 1823 YYSIZE_T yyalloc = 2 * yysize; 1824 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 1825 yyalloc = YYSTACK_ALLOC_MAXIMUM; 1826 if (yymsg != yymsgbuf) 1827 YYSTACK_FREE (yymsg); 1828 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 1829 if (yymsg) 1830 yymsg_alloc = yyalloc; 1831 else 1832 { 1833 yymsg = yymsgbuf; 1834 yymsg_alloc = sizeof yymsgbuf; 1835 } 1836 } 1837 1838 if (0 < yysize && yysize <= yymsg_alloc) 1839 { 1840 (void) yysyntax_error (yymsg, yystate, yychar); 1841 yyerror (yymsg); 1842 } 1843 else 1844 { 1845 yyerror (YY_("syntax error")); 1846 if (yysize != 0) 1847 goto yyexhaustedlab; 1848 } 1849 } 1850#endif 1851 } 1852 1853 1854 1855 if (yyerrstatus == 3) 1856 { 1857 /* If just tried and failed to reuse lookahead token after an 1858 error, discard it. */ 1859 1860 if (yychar <= YYEOF) 1861 { 1862 /* Return failure if at end of input. */ 1863 if (yychar == YYEOF) 1864 YYABORT; 1865 } 1866 else 1867 { 1868 yydestruct ("Error: discarding", 1869 yytoken, &yylval); 1870 yychar = YYEMPTY; 1871 } 1872 } 1873 1874 /* Else will try to reuse lookahead token after shifting the error 1875 token. */ 1876 goto yyerrlab1; 1877 1878 1879/*---------------------------------------------------. 1880| yyerrorlab -- error raised explicitly by YYERROR. | 1881`---------------------------------------------------*/ 1882yyerrorlab: 1883 1884 /* Pacify compilers like GCC when the user code never invokes 1885 YYERROR and the label yyerrorlab therefore never appears in user 1886 code. */ 1887 if (/*CONSTCOND*/ 0) 1888 goto yyerrorlab; 1889 1890 /* Do not reclaim the symbols of the rule which action triggered 1891 this YYERROR. */ 1892 YYPOPSTACK (yylen); 1893 yylen = 0; 1894 YY_STACK_PRINT (yyss, yyssp); 1895 yystate = *yyssp; 1896 goto yyerrlab1; 1897 1898 1899/*-------------------------------------------------------------. 1900| yyerrlab1 -- common code for both syntax error and YYERROR. | 1901`-------------------------------------------------------------*/ 1902yyerrlab1: 1903 yyerrstatus = 3; /* Each real token shifted decrements this. */ 1904 1905 for (;;) 1906 { 1907 yyn = yypact[yystate]; 1908 if (yyn != YYPACT_NINF) 1909 { 1910 yyn += YYTERROR; 1911 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 1912 { 1913 yyn = yytable[yyn]; 1914 if (0 < yyn) 1915 break; 1916 } 1917 } 1918 1919 /* Pop the current state because it cannot handle the error token. */ 1920 if (yyssp == yyss) 1921 YYABORT; 1922 1923 1924 yydestruct ("Error: popping", 1925 yystos[yystate], yyvsp); 1926 YYPOPSTACK (1); 1927 yystate = *yyssp; 1928 YY_STACK_PRINT (yyss, yyssp); 1929 } 1930 1931 *++yyvsp = yylval; 1932 1933 1934 /* Shift the error token. */ 1935 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 1936 1937 yystate = yyn; 1938 goto yynewstate; 1939 1940 1941/*-------------------------------------. 1942| yyacceptlab -- YYACCEPT comes here. | 1943`-------------------------------------*/ 1944yyacceptlab: 1945 yyresult = 0; 1946 goto yyreturn; 1947 1948/*-----------------------------------. 1949| yyabortlab -- YYABORT comes here. | 1950`-----------------------------------*/ 1951yyabortlab: 1952 yyresult = 1; 1953 goto yyreturn; 1954 1955#if !defined(yyoverflow) || YYERROR_VERBOSE 1956/*-------------------------------------------------. 1957| yyexhaustedlab -- memory exhaustion comes here. | 1958`-------------------------------------------------*/ 1959yyexhaustedlab: 1960 yyerror (YY_("memory exhausted")); 1961 yyresult = 2; 1962 /* Fall through. */ 1963#endif 1964 1965yyreturn: 1966 if (yychar != YYEMPTY) 1967 yydestruct ("Cleanup: discarding lookahead", 1968 yytoken, &yylval); 1969 /* Do not reclaim the symbols of the rule which action triggered 1970 this YYABORT or YYACCEPT. */ 1971 YYPOPSTACK (yylen); 1972 YY_STACK_PRINT (yyss, yyssp); 1973 while (yyssp != yyss) 1974 { 1975 yydestruct ("Cleanup: popping", 1976 yystos[*yyssp], yyvsp); 1977 YYPOPSTACK (1); 1978 } 1979#ifndef yyoverflow 1980 if (yyss != yyssa) 1981 YYSTACK_FREE (yyss); 1982#endif 1983#if YYERROR_VERBOSE 1984 if (yymsg != yymsgbuf) 1985 YYSTACK_FREE (yymsg); 1986#endif 1987 /* Make sure YYID is used. */ 1988 return YYID (yyresult); 1989} 1990 1991 1992 1993/* Line 1675 of yacc.c */ 1994#line 313 "dtc-parser.y" 1995 1996 1997void print_error(char const *fmt, ...) 1998{ 1999 va_list va; 2000 2001 va_start(va, fmt); 2002 srcpos_verror(&yylloc, fmt, va); 2003 va_end(va); 2004 2005 treesource_error = 1; 2006} 2007 2008void yyerror(char const *s) { 2009 print_error("%s", s); 2010} 2011 2012static unsigned long long eval_literal(const char *s, int base, int bits) 2013{ 2014 unsigned long long val; 2015 char *e; 2016 2017 errno = 0; 2018 val = strtoull(s, &e, base); 2019 if (*e) 2020 print_error("bad characters in literal"); 2021 else if ((errno == ERANGE) 2022 || ((bits < 64) && (val >= (1ULL << bits)))) 2023 print_error("literal out of range"); 2024 else if (errno != 0) 2025 print_error("bad literal"); 2026 return val; 2027} 2028 2029