1/* A Bison parser, made by GNU Bison 3.8.2. */ 2 3/* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, 6 Inc. 7 8 This program is free software: you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation, either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <https://www.gnu.org/licenses/>. */ 20 21/* As a special exception, you may create a larger work that contains 22 part or all of the Bison parser skeleton and distribute that work 23 under terms of your choice, so long as that work isn't itself a 24 parser generator using the skeleton or a modified version thereof 25 as a parser skeleton. Alternatively, if you modify or redistribute 26 the parser skeleton itself, you may (at your option) remove this 27 special exception, which will cause the skeleton and the resulting 28 Bison output files to be licensed under the GNU General Public 29 License without this special exception. 30 31 This special exception was added by the Free Software Foundation in 32 version 2.2 of Bison. */ 33 34/* C LALR(1) parser skeleton written by Richard Stallman, by 35 simplifying the original so-called "semantic" parser. */ 36 37/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, 38 especially those whose name start with YY_ or yy_. They are 39 private implementation details that can be changed or removed. */ 40 41/* All symbols defined below should begin with yy or YY, to avoid 42 infringing on user name space. This should be done even for local 43 variables, as they might otherwise be expanded by user macros. 44 There are some unavoidable exceptions within include files to 45 define necessary library symbols; they are noted "INFRINGES ON 46 USER NAME SPACE" below. */ 47 48/* Identify Bison output, and Bison version. */ 49#define YYBISON 30802 50 51/* Bison version string. */ 52#define YYBISON_VERSION "3.8.2" 53 54/* Skeleton name. */ 55#define YYSKELETON_NAME "yacc.c" 56 57/* Pure parsers. */ 58#define YYPURE 0 59 60/* Push parsers. */ 61#define YYPUSH 0 62 63/* Pull parsers. */ 64#define YYPULL 1 65 66 67 68 69/* First part of user prologue. */ 70#line 21 "sysinfo.y" 71 72#include <stdio.h> 73#include <stdlib.h> 74#include <string.h> 75 76static char writecode; 77static char *it; 78static int code; 79static char * repeat; 80static char *oldrepeat; 81static char *name; 82static int rdepth; 83static char *names[] = {" ","[n]","[n][m]"}; 84static char *pnames[]= {"","*","**"}; 85 86static void yyerror (const char *s); 87extern int yylex (void); 88 89#line 90 "sysinfo.c" 90 91# ifndef YY_CAST 92# ifdef __cplusplus 93# define YY_CAST(Type, Val) static_cast<Type> (Val) 94# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) 95# else 96# define YY_CAST(Type, Val) ((Type) (Val)) 97# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) 98# endif 99# endif 100# ifndef YY_NULLPTR 101# if defined __cplusplus 102# if 201103L <= __cplusplus 103# define YY_NULLPTR nullptr 104# else 105# define YY_NULLPTR 0 106# endif 107# else 108# define YY_NULLPTR ((void*)0) 109# endif 110# endif 111 112/* Use api.header.include to #include this header 113 instead of duplicating it here. */ 114#ifndef YY_YY_SYSINFO_H_INCLUDED 115# define YY_YY_SYSINFO_H_INCLUDED 116/* Debug traces. */ 117#ifndef YYDEBUG 118# define YYDEBUG 0 119#endif 120#if YYDEBUG 121extern int yydebug; 122#endif 123 124/* Token kinds. */ 125#ifndef YYTOKENTYPE 126# define YYTOKENTYPE 127 enum yytokentype 128 { 129 YYEMPTY = -2, 130 YYEOF = 0, /* "end of file" */ 131 YYerror = 256, /* error */ 132 YYUNDEF = 257, /* "invalid token" */ 133 COND = 258, /* COND */ 134 REPEAT = 259, /* REPEAT */ 135 TYPE = 260, /* TYPE */ 136 NAME = 261, /* NAME */ 137 NUMBER = 262, /* NUMBER */ 138 UNIT = 263 /* UNIT */ 139 }; 140 typedef enum yytokentype yytoken_kind_t; 141#endif 142/* Token kinds. */ 143#define YYEMPTY -2 144#define YYEOF 0 145#define YYerror 256 146#define YYUNDEF 257 147#define COND 258 148#define REPEAT 259 149#define TYPE 260 150#define NAME 261 151#define NUMBER 262 152#define UNIT 263 153 154/* Value type. */ 155#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 156union YYSTYPE 157{ 158#line 41 "sysinfo.y" 159 160 int i; 161 char *s; 162 163#line 164 "sysinfo.c" 164 165}; 166typedef union YYSTYPE YYSTYPE; 167# define YYSTYPE_IS_TRIVIAL 1 168# define YYSTYPE_IS_DECLARED 1 169#endif 170 171 172extern YYSTYPE yylval; 173 174 175int yyparse (void); 176 177 178#endif /* !YY_YY_SYSINFO_H_INCLUDED */ 179/* Symbol kind. */ 180enum yysymbol_kind_t 181{ 182 YYSYMBOL_YYEMPTY = -2, 183 YYSYMBOL_YYEOF = 0, /* "end of file" */ 184 YYSYMBOL_YYerror = 1, /* error */ 185 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ 186 YYSYMBOL_COND = 3, /* COND */ 187 YYSYMBOL_REPEAT = 4, /* REPEAT */ 188 YYSYMBOL_5_ = 5, /* '(' */ 189 YYSYMBOL_6_ = 6, /* ')' */ 190 YYSYMBOL_TYPE = 7, /* TYPE */ 191 YYSYMBOL_NAME = 8, /* NAME */ 192 YYSYMBOL_NUMBER = 9, /* NUMBER */ 193 YYSYMBOL_UNIT = 10, /* UNIT */ 194 YYSYMBOL_YYACCEPT = 11, /* $accept */ 195 YYSYMBOL_top = 12, /* top */ 196 YYSYMBOL_13_1 = 13, /* $@1 */ 197 YYSYMBOL_it_list = 14, /* it_list */ 198 YYSYMBOL_it = 15, /* it */ 199 YYSYMBOL_16_2 = 16, /* $@2 */ 200 YYSYMBOL_it_field_list = 17, /* it_field_list */ 201 YYSYMBOL_repeat_it_field = 18, /* repeat_it_field */ 202 YYSYMBOL_19_3 = 19, /* $@3 */ 203 YYSYMBOL_cond_it_field = 20, /* cond_it_field */ 204 YYSYMBOL_21_4 = 21, /* $@4 */ 205 YYSYMBOL_it_field = 22, /* it_field */ 206 YYSYMBOL_23_5 = 23, /* $@5 */ 207 YYSYMBOL_attr_type = 24, /* attr_type */ 208 YYSYMBOL_attr_desc = 25, /* attr_desc */ 209 YYSYMBOL_attr_size = 26, /* attr_size */ 210 YYSYMBOL_attr_id = 27, /* attr_id */ 211 YYSYMBOL_enums = 28, /* enums */ 212 YYSYMBOL_enum_list = 29 /* enum_list */ 213}; 214typedef enum yysymbol_kind_t yysymbol_kind_t; 215 216 217 218 219#ifdef short 220# undef short 221#endif 222 223/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure 224 <limits.h> and (if available) <stdint.h> are included 225 so that the code can choose integer types of a good width. */ 226 227#ifndef __PTRDIFF_MAX__ 228# include <limits.h> /* INFRINGES ON USER NAME SPACE */ 229# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 230# include <stdint.h> /* INFRINGES ON USER NAME SPACE */ 231# define YY_STDINT_H 232# endif 233#endif 234 235/* Narrow types that promote to a signed type and that can represent a 236 signed or unsigned integer of at least N bits. In tables they can 237 save space and decrease cache pressure. Promoting to a signed type 238 helps avoid bugs in integer arithmetic. */ 239 240#ifdef __INT_LEAST8_MAX__ 241typedef __INT_LEAST8_TYPE__ yytype_int8; 242#elif defined YY_STDINT_H 243typedef int_least8_t yytype_int8; 244#else 245typedef signed char yytype_int8; 246#endif 247 248#ifdef __INT_LEAST16_MAX__ 249typedef __INT_LEAST16_TYPE__ yytype_int16; 250#elif defined YY_STDINT_H 251typedef int_least16_t yytype_int16; 252#else 253typedef short yytype_int16; 254#endif 255 256/* Work around bug in HP-UX 11.23, which defines these macros 257 incorrectly for preprocessor constants. This workaround can likely 258 be removed in 2023, as HPE has promised support for HP-UX 11.23 259 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of 260 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */ 261#ifdef __hpux 262# undef UINT_LEAST8_MAX 263# undef UINT_LEAST16_MAX 264# define UINT_LEAST8_MAX 255 265# define UINT_LEAST16_MAX 65535 266#endif 267 268#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ 269typedef __UINT_LEAST8_TYPE__ yytype_uint8; 270#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ 271 && UINT_LEAST8_MAX <= INT_MAX) 272typedef uint_least8_t yytype_uint8; 273#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX 274typedef unsigned char yytype_uint8; 275#else 276typedef short yytype_uint8; 277#endif 278 279#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ 280typedef __UINT_LEAST16_TYPE__ yytype_uint16; 281#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ 282 && UINT_LEAST16_MAX <= INT_MAX) 283typedef uint_least16_t yytype_uint16; 284#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX 285typedef unsigned short yytype_uint16; 286#else 287typedef int yytype_uint16; 288#endif 289 290#ifndef YYPTRDIFF_T 291# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ 292# define YYPTRDIFF_T __PTRDIFF_TYPE__ 293# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ 294# elif defined PTRDIFF_MAX 295# ifndef ptrdiff_t 296# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 297# endif 298# define YYPTRDIFF_T ptrdiff_t 299# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX 300# else 301# define YYPTRDIFF_T long 302# define YYPTRDIFF_MAXIMUM LONG_MAX 303# endif 304#endif 305 306#ifndef YYSIZE_T 307# ifdef __SIZE_TYPE__ 308# define YYSIZE_T __SIZE_TYPE__ 309# elif defined size_t 310# define YYSIZE_T size_t 311# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 312# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 313# define YYSIZE_T size_t 314# else 315# define YYSIZE_T unsigned 316# endif 317#endif 318 319#define YYSIZE_MAXIMUM \ 320 YY_CAST (YYPTRDIFF_T, \ 321 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ 322 ? YYPTRDIFF_MAXIMUM \ 323 : YY_CAST (YYSIZE_T, -1))) 324 325#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) 326 327 328/* Stored state numbers (used for stacks). */ 329typedef yytype_int8 yy_state_t; 330 331/* State numbers in computations. */ 332typedef int yy_state_fast_t; 333 334#ifndef YY_ 335# if defined YYENABLE_NLS && YYENABLE_NLS 336# if ENABLE_NLS 337# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 338# define YY_(Msgid) dgettext ("bison-runtime", Msgid) 339# endif 340# endif 341# ifndef YY_ 342# define YY_(Msgid) Msgid 343# endif 344#endif 345 346 347#ifndef YY_ATTRIBUTE_PURE 348# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) 349# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) 350# else 351# define YY_ATTRIBUTE_PURE 352# endif 353#endif 354 355#ifndef YY_ATTRIBUTE_UNUSED 356# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) 357# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 358# else 359# define YY_ATTRIBUTE_UNUSED 360# endif 361#endif 362 363/* Suppress unused-variable warnings by "using" E. */ 364#if ! defined lint || defined __GNUC__ 365# define YY_USE(E) ((void) (E)) 366#else 367# define YY_USE(E) /* empty */ 368#endif 369 370/* Suppress an incorrect diagnostic about yylval being uninitialized. */ 371#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ 372# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 373# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 374 _Pragma ("GCC diagnostic push") \ 375 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") 376# else 377# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 378 _Pragma ("GCC diagnostic push") \ 379 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ 380 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 381# endif 382# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 383 _Pragma ("GCC diagnostic pop") 384#else 385# define YY_INITIAL_VALUE(Value) Value 386#endif 387#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 388# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 389# define YY_IGNORE_MAYBE_UNINITIALIZED_END 390#endif 391#ifndef YY_INITIAL_VALUE 392# define YY_INITIAL_VALUE(Value) /* Nothing. */ 393#endif 394 395#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ 396# define YY_IGNORE_USELESS_CAST_BEGIN \ 397 _Pragma ("GCC diagnostic push") \ 398 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") 399# define YY_IGNORE_USELESS_CAST_END \ 400 _Pragma ("GCC diagnostic pop") 401#endif 402#ifndef YY_IGNORE_USELESS_CAST_BEGIN 403# define YY_IGNORE_USELESS_CAST_BEGIN 404# define YY_IGNORE_USELESS_CAST_END 405#endif 406 407 408#define YY_ASSERT(E) ((void) (0 && (E))) 409 410#if !defined yyoverflow 411 412/* The parser invokes alloca or malloc; define the necessary symbols. */ 413 414# ifdef YYSTACK_USE_ALLOCA 415# if YYSTACK_USE_ALLOCA 416# ifdef __GNUC__ 417# define YYSTACK_ALLOC __builtin_alloca 418# elif defined __BUILTIN_VA_ARG_INCR 419# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 420# elif defined _AIX 421# define YYSTACK_ALLOC __alloca 422# elif defined _MSC_VER 423# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 424# define alloca _alloca 425# else 426# define YYSTACK_ALLOC alloca 427# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 428# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 429 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 430# ifndef EXIT_SUCCESS 431# define EXIT_SUCCESS 0 432# endif 433# endif 434# endif 435# endif 436# endif 437 438# ifdef YYSTACK_ALLOC 439 /* Pacify GCC's 'empty if-body' warning. */ 440# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 441# ifndef YYSTACK_ALLOC_MAXIMUM 442 /* The OS might guarantee only one guard page at the bottom of the stack, 443 and a page size can be as small as 4096 bytes. So we cannot safely 444 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 445 to allow for a few compiler-allocated temporary stack slots. */ 446# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 447# endif 448# else 449# define YYSTACK_ALLOC YYMALLOC 450# define YYSTACK_FREE YYFREE 451# ifndef YYSTACK_ALLOC_MAXIMUM 452# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 453# endif 454# if (defined __cplusplus && ! defined EXIT_SUCCESS \ 455 && ! ((defined YYMALLOC || defined malloc) \ 456 && (defined YYFREE || defined free))) 457# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 458# ifndef EXIT_SUCCESS 459# define EXIT_SUCCESS 0 460# endif 461# endif 462# ifndef YYMALLOC 463# define YYMALLOC malloc 464# if ! defined malloc && ! defined EXIT_SUCCESS 465void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 466# endif 467# endif 468# ifndef YYFREE 469# define YYFREE free 470# if ! defined free && ! defined EXIT_SUCCESS 471void free (void *); /* INFRINGES ON USER NAME SPACE */ 472# endif 473# endif 474# endif 475#endif /* !defined yyoverflow */ 476 477#if (! defined yyoverflow \ 478 && (! defined __cplusplus \ 479 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 480 481/* A type that is properly aligned for any stack member. */ 482union yyalloc 483{ 484 yy_state_t yyss_alloc; 485 YYSTYPE yyvs_alloc; 486}; 487 488/* The size of the maximum gap between one aligned stack and the next. */ 489# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) 490 491/* The size of an array large to enough to hold all stacks, each with 492 N elements. */ 493# define YYSTACK_BYTES(N) \ 494 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ 495 + YYSTACK_GAP_MAXIMUM) 496 497# define YYCOPY_NEEDED 1 498 499/* Relocate STACK from its old location to the new one. The 500 local variables YYSIZE and YYSTACKSIZE give the old and new number of 501 elements in the stack, and YYPTR gives the new location of the 502 stack. Advance YYPTR to a properly aligned location for the next 503 stack. */ 504# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 505 do \ 506 { \ 507 YYPTRDIFF_T yynewbytes; \ 508 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 509 Stack = &yyptr->Stack_alloc; \ 510 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ 511 yyptr += yynewbytes / YYSIZEOF (*yyptr); \ 512 } \ 513 while (0) 514 515#endif 516 517#if defined YYCOPY_NEEDED && YYCOPY_NEEDED 518/* Copy COUNT objects from SRC to DST. The source and destination do 519 not overlap. */ 520# ifndef YYCOPY 521# if defined __GNUC__ && 1 < __GNUC__ 522# define YYCOPY(Dst, Src, Count) \ 523 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) 524# else 525# define YYCOPY(Dst, Src, Count) \ 526 do \ 527 { \ 528 YYPTRDIFF_T yyi; \ 529 for (yyi = 0; yyi < (Count); yyi++) \ 530 (Dst)[yyi] = (Src)[yyi]; \ 531 } \ 532 while (0) 533# endif 534# endif 535#endif /* !YYCOPY_NEEDED */ 536 537/* YYFINAL -- State number of the termination state. */ 538#define YYFINAL 3 539/* YYLAST -- Last index in YYTABLE. */ 540#define YYLAST 38 541 542/* YYNTOKENS -- Number of terminals. */ 543#define YYNTOKENS 11 544/* YYNNTS -- Number of nonterminals. */ 545#define YYNNTS 19 546/* YYNRULES -- Number of rules. */ 547#define YYNRULES 27 548/* YYNSTATES -- Number of states. */ 549#define YYNSTATES 55 550 551/* YYMAXUTOK -- Last valid token kind. */ 552#define YYMAXUTOK 263 553 554 555/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM 556 as returned by yylex, with out-of-bounds checking. */ 557#define YYTRANSLATE(YYX) \ 558 (0 <= (YYX) && (YYX) <= YYMAXUTOK \ 559 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ 560 : YYSYMBOL_YYUNDEF) 561 562/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 563 as returned by yylex. */ 564static const yytype_int8 yytranslate[] = 565{ 566 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 567 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 568 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 569 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 570 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 571 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 572 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 573 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 574 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 575 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 576 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 577 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 578 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 579 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 580 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 581 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 582 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 583 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 584 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 585 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 586 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 587 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 588 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 589 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 590 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 591 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 592 7, 8, 9, 10 593}; 594 595#if YYDEBUG 596/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 597static const yytype_int16 yyrline[] = 598{ 599 0, 55, 55, 55, 93, 94, 99, 98, 171, 172, 600 173, 174, 178, 177, 228, 227, 257, 256, 367, 368, 601 372, 377, 383, 384, 387, 388, 390, 392 602}; 603#endif 604 605/** Accessing symbol of state STATE. */ 606#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) 607 608#if YYDEBUG || 0 609/* The user-facing name of the symbol whose (internal) number is 610 YYSYMBOL. No bounds checking. */ 611static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; 612 613/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 614 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 615static const char *const yytname[] = 616{ 617 "\"end of file\"", "error", "\"invalid token\"", "COND", "REPEAT", 618 "'('", "')'", "TYPE", "NAME", "NUMBER", "UNIT", "$accept", "top", "$@1", 619 "it_list", "it", "$@2", "it_field_list", "repeat_it_field", "$@3", 620 "cond_it_field", "$@4", "it_field", "$@5", "attr_type", "attr_desc", 621 "attr_size", "attr_id", "enums", "enum_list", YY_NULLPTR 622}; 623 624static const char * 625yysymbol_name (yysymbol_kind_t yysymbol) 626{ 627 return yytname[yysymbol]; 628} 629#endif 630 631#define YYPACT_NINF (-14) 632 633#define yypact_value_is_default(Yyn) \ 634 ((Yyn) == YYPACT_NINF) 635 636#define YYTABLE_NINF (-1) 637 638#define yytable_value_is_error(Yyn) \ 639 0 640 641/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 642 STATE-NUM. */ 643static const yytype_int8 yypact[] = 644{ 645 -14, 8, 4, -14, 2, -14, 4, 3, -14, -14, 646 6, 0, 7, 6, 6, 6, 9, 10, 11, 15, 647 -14, -14, -14, -14, -14, -14, 16, 14, 6, 6, 648 -14, -14, 5, 17, 18, 19, 20, -14, -14, -14, 649 22, 23, -14, 24, 27, -14, -14, 28, 1, -14, 650 25, -14, 29, 30, -14 651}; 652 653/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 654 Performed when YYTABLE does not specify something else to do. Zero 655 means the default is an error. */ 656static const yytype_int8 yydefact[] = 657{ 658 2, 0, 5, 1, 0, 3, 5, 0, 4, 6, 659 11, 0, 0, 11, 11, 11, 0, 0, 0, 0, 660 7, 10, 9, 8, 14, 12, 0, 19, 11, 11, 661 20, 18, 0, 0, 0, 0, 0, 15, 13, 21, 662 23, 0, 16, 0, 24, 22, 26, 0, 0, 17, 663 0, 25, 0, 0, 27 664}; 665 666/* YYPGOTO[NTERM-NUM]. */ 667static const yytype_int8 yypgoto[] = 668{ 669 -14, -14, -14, 32, -14, -14, -13, -14, -14, -14, 670 -14, -14, -14, -14, -14, -14, -14, -14, -14 671}; 672 673/* YYDEFGOTO[NTERM-NUM]. */ 674static const yytype_int8 yydefgoto[] = 675{ 676 0, 1, 2, 5, 6, 10, 12, 13, 29, 14, 677 28, 15, 44, 32, 19, 36, 42, 47, 48 678}; 679 680/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 681 positive, shift that token. If negative, reduce the rule whose 682 number is the opposite. If YYTABLE_NINF, syntax error. */ 683static const yytype_int8 yytable[] = 684{ 685 21, 22, 23, 16, 17, 18, 50, 51, 3, 4, 686 7, 11, 9, 20, 35, 33, 34, 24, 25, 26, 687 27, 31, 30, 37, 38, 0, 40, 41, 0, 39, 688 45, 43, 46, 52, 49, 0, 54, 53, 8 689}; 690 691static const yytype_int8 yycheck[] = 692{ 693 13, 14, 15, 3, 4, 5, 5, 6, 0, 5, 694 8, 5, 9, 6, 9, 28, 29, 8, 8, 8, 695 5, 7, 6, 6, 6, -1, 6, 5, -1, 10, 696 6, 8, 5, 8, 6, -1, 6, 8, 6 697}; 698 699/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of 700 state STATE-NUM. */ 701static const yytype_int8 yystos[] = 702{ 703 0, 12, 13, 0, 5, 14, 15, 8, 14, 9, 704 16, 5, 17, 18, 20, 22, 3, 4, 5, 25, 705 6, 17, 17, 17, 8, 8, 8, 5, 21, 19, 706 6, 7, 24, 17, 17, 9, 26, 6, 6, 10, 707 6, 5, 27, 8, 23, 6, 5, 28, 29, 6, 708 5, 6, 8, 8, 6 709}; 710 711/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ 712static const yytype_int8 yyr1[] = 713{ 714 0, 11, 13, 12, 14, 14, 16, 15, 17, 17, 715 17, 17, 19, 18, 21, 20, 23, 22, 24, 24, 716 25, 26, 27, 27, 28, 28, 29, 29 717}; 718 719/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ 720static const yytype_int8 yyr2[] = 721{ 722 0, 2, 0, 2, 2, 0, 0, 6, 2, 2, 723 2, 0, 0, 6, 0, 6, 0, 10, 1, 0, 724 3, 2, 3, 0, 0, 3, 0, 5 725}; 726 727 728enum { YYENOMEM = -2 }; 729 730#define yyerrok (yyerrstatus = 0) 731#define yyclearin (yychar = YYEMPTY) 732 733#define YYACCEPT goto yyacceptlab 734#define YYABORT goto yyabortlab 735#define YYERROR goto yyerrorlab 736#define YYNOMEM goto yyexhaustedlab 737 738 739#define YYRECOVERING() (!!yyerrstatus) 740 741#define YYBACKUP(Token, Value) \ 742 do \ 743 if (yychar == YYEMPTY) \ 744 { \ 745 yychar = (Token); \ 746 yylval = (Value); \ 747 YYPOPSTACK (yylen); \ 748 yystate = *yyssp; \ 749 goto yybackup; \ 750 } \ 751 else \ 752 { \ 753 yyerror (YY_("syntax error: cannot back up")); \ 754 YYERROR; \ 755 } \ 756 while (0) 757 758/* Backward compatibility with an undocumented macro. 759 Use YYerror or YYUNDEF. */ 760#define YYERRCODE YYUNDEF 761 762 763/* Enable debugging if requested. */ 764#if YYDEBUG 765 766# ifndef YYFPRINTF 767# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 768# define YYFPRINTF fprintf 769# endif 770 771# define YYDPRINTF(Args) \ 772do { \ 773 if (yydebug) \ 774 YYFPRINTF Args; \ 775} while (0) 776 777 778 779 780# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ 781do { \ 782 if (yydebug) \ 783 { \ 784 YYFPRINTF (stderr, "%s ", Title); \ 785 yy_symbol_print (stderr, \ 786 Kind, Value); \ 787 YYFPRINTF (stderr, "\n"); \ 788 } \ 789} while (0) 790 791 792/*-----------------------------------. 793| Print this symbol's value on YYO. | 794`-----------------------------------*/ 795 796static void 797yy_symbol_value_print (FILE *yyo, 798 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 799{ 800 FILE *yyoutput = yyo; 801 YY_USE (yyoutput); 802 if (!yyvaluep) 803 return; 804 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 805 YY_USE (yykind); 806 YY_IGNORE_MAYBE_UNINITIALIZED_END 807} 808 809 810/*---------------------------. 811| Print this symbol on YYO. | 812`---------------------------*/ 813 814static void 815yy_symbol_print (FILE *yyo, 816 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 817{ 818 YYFPRINTF (yyo, "%s %s (", 819 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); 820 821 yy_symbol_value_print (yyo, yykind, yyvaluep); 822 YYFPRINTF (yyo, ")"); 823} 824 825/*------------------------------------------------------------------. 826| yy_stack_print -- Print the state stack from its BOTTOM up to its | 827| TOP (included). | 828`------------------------------------------------------------------*/ 829 830static void 831yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) 832{ 833 YYFPRINTF (stderr, "Stack now"); 834 for (; yybottom <= yytop; yybottom++) 835 { 836 int yybot = *yybottom; 837 YYFPRINTF (stderr, " %d", yybot); 838 } 839 YYFPRINTF (stderr, "\n"); 840} 841 842# define YY_STACK_PRINT(Bottom, Top) \ 843do { \ 844 if (yydebug) \ 845 yy_stack_print ((Bottom), (Top)); \ 846} while (0) 847 848 849/*------------------------------------------------. 850| Report that the YYRULE is going to be reduced. | 851`------------------------------------------------*/ 852 853static void 854yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, 855 int yyrule) 856{ 857 int yylno = yyrline[yyrule]; 858 int yynrhs = yyr2[yyrule]; 859 int yyi; 860 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", 861 yyrule - 1, yylno); 862 /* The symbols being reduced. */ 863 for (yyi = 0; yyi < yynrhs; yyi++) 864 { 865 YYFPRINTF (stderr, " $%d = ", yyi + 1); 866 yy_symbol_print (stderr, 867 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), 868 &yyvsp[(yyi + 1) - (yynrhs)]); 869 YYFPRINTF (stderr, "\n"); 870 } 871} 872 873# define YY_REDUCE_PRINT(Rule) \ 874do { \ 875 if (yydebug) \ 876 yy_reduce_print (yyssp, yyvsp, Rule); \ 877} while (0) 878 879/* Nonzero means print parse trace. It is left uninitialized so that 880 multiple parsers can coexist. */ 881int yydebug; 882#else /* !YYDEBUG */ 883# define YYDPRINTF(Args) ((void) 0) 884# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) 885# define YY_STACK_PRINT(Bottom, Top) 886# define YY_REDUCE_PRINT(Rule) 887#endif /* !YYDEBUG */ 888 889 890/* YYINITDEPTH -- initial size of the parser's stacks. */ 891#ifndef YYINITDEPTH 892# define YYINITDEPTH 200 893#endif 894 895/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 896 if the built-in stack extension method is used). 897 898 Do not make this value too large; the results are undefined if 899 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 900 evaluated with infinite-precision integer arithmetic. */ 901 902#ifndef YYMAXDEPTH 903# define YYMAXDEPTH 10000 904#endif 905 906 907 908 909 910 911/*-----------------------------------------------. 912| Release the memory associated to this symbol. | 913`-----------------------------------------------*/ 914 915static void 916yydestruct (const char *yymsg, 917 yysymbol_kind_t yykind, YYSTYPE *yyvaluep) 918{ 919 YY_USE (yyvaluep); 920 if (!yymsg) 921 yymsg = "Deleting"; 922 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 923 924 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 925 YY_USE (yykind); 926 YY_IGNORE_MAYBE_UNINITIALIZED_END 927} 928 929 930/* Lookahead token kind. */ 931int yychar; 932 933/* The semantic value of the lookahead symbol. */ 934YYSTYPE yylval; 935/* Number of syntax errors so far. */ 936int yynerrs; 937 938 939 940 941/*----------. 942| yyparse. | 943`----------*/ 944 945int 946yyparse (void) 947{ 948 yy_state_fast_t yystate = 0; 949 /* Number of tokens to shift before error messages enabled. */ 950 int yyerrstatus = 0; 951 952 /* Refer to the stacks through separate pointers, to allow yyoverflow 953 to reallocate them elsewhere. */ 954 955 /* Their size. */ 956 YYPTRDIFF_T yystacksize = YYINITDEPTH; 957 958 /* The state stack: array, bottom, top. */ 959 yy_state_t yyssa[YYINITDEPTH]; 960 yy_state_t *yyss = yyssa; 961 yy_state_t *yyssp = yyss; 962 963 /* The semantic value stack: array, bottom, top. */ 964 YYSTYPE yyvsa[YYINITDEPTH]; 965 YYSTYPE *yyvs = yyvsa; 966 YYSTYPE *yyvsp = yyvs; 967 968 int yyn; 969 /* The return value of yyparse. */ 970 int yyresult; 971 /* Lookahead symbol kind. */ 972 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 973 /* The variables used to return semantic value and location from the 974 action routines. */ 975 YYSTYPE yyval; 976 977 978 979#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 980 981 /* The number of symbols on the RHS of the reduced rule. 982 Keep to zero when no symbol should be popped. */ 983 int yylen = 0; 984 985 YYDPRINTF ((stderr, "Starting parse\n")); 986 987 yychar = YYEMPTY; /* Cause a token to be read. */ 988 989 goto yysetstate; 990 991 992/*------------------------------------------------------------. 993| yynewstate -- push a new state, which is found in yystate. | 994`------------------------------------------------------------*/ 995yynewstate: 996 /* In all cases, when you get here, the value and location stacks 997 have just been pushed. So pushing a state here evens the stacks. */ 998 yyssp++; 999 1000 1001/*--------------------------------------------------------------------. 1002| yysetstate -- set current state (the top of the stack) to yystate. | 1003`--------------------------------------------------------------------*/ 1004yysetstate: 1005 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1006 YY_ASSERT (0 <= yystate && yystate < YYNSTATES); 1007 YY_IGNORE_USELESS_CAST_BEGIN 1008 *yyssp = YY_CAST (yy_state_t, yystate); 1009 YY_IGNORE_USELESS_CAST_END 1010 YY_STACK_PRINT (yyss, yyssp); 1011 1012 if (yyss + yystacksize - 1 <= yyssp) 1013#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1014 YYNOMEM; 1015#else 1016 { 1017 /* Get the current used size of the three stacks, in elements. */ 1018 YYPTRDIFF_T yysize = yyssp - yyss + 1; 1019 1020# if defined yyoverflow 1021 { 1022 /* Give user a chance to reallocate the stack. Use copies of 1023 these so that the &'s don't force the real ones into 1024 memory. */ 1025 yy_state_t *yyss1 = yyss; 1026 YYSTYPE *yyvs1 = yyvs; 1027 1028 /* Each stack pointer address is followed by the size of the 1029 data in use in that stack, in bytes. This used to be a 1030 conditional around just the two extra args, but that might 1031 be undefined if yyoverflow is a macro. */ 1032 yyoverflow (YY_("memory exhausted"), 1033 &yyss1, yysize * YYSIZEOF (*yyssp), 1034 &yyvs1, yysize * YYSIZEOF (*yyvsp), 1035 &yystacksize); 1036 yyss = yyss1; 1037 yyvs = yyvs1; 1038 } 1039# else /* defined YYSTACK_RELOCATE */ 1040 /* Extend the stack our own way. */ 1041 if (YYMAXDEPTH <= yystacksize) 1042 YYNOMEM; 1043 yystacksize *= 2; 1044 if (YYMAXDEPTH < yystacksize) 1045 yystacksize = YYMAXDEPTH; 1046 1047 { 1048 yy_state_t *yyss1 = yyss; 1049 union yyalloc *yyptr = 1050 YY_CAST (union yyalloc *, 1051 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1052 if (! yyptr) 1053 YYNOMEM; 1054 YYSTACK_RELOCATE (yyss_alloc, yyss); 1055 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1056# undef YYSTACK_RELOCATE 1057 if (yyss1 != yyssa) 1058 YYSTACK_FREE (yyss1); 1059 } 1060# endif 1061 1062 yyssp = yyss + yysize - 1; 1063 yyvsp = yyvs + yysize - 1; 1064 1065 YY_IGNORE_USELESS_CAST_BEGIN 1066 YYDPRINTF ((stderr, "Stack size increased to %ld\n", 1067 YY_CAST (long, yystacksize))); 1068 YY_IGNORE_USELESS_CAST_END 1069 1070 if (yyss + yystacksize - 1 <= yyssp) 1071 YYABORT; 1072 } 1073#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1074 1075 1076 if (yystate == YYFINAL) 1077 YYACCEPT; 1078 1079 goto yybackup; 1080 1081 1082/*-----------. 1083| yybackup. | 1084`-----------*/ 1085yybackup: 1086 /* Do appropriate processing given the current state. Read a 1087 lookahead token if we need one and don't already have one. */ 1088 1089 /* First try to decide what to do without reference to lookahead token. */ 1090 yyn = yypact[yystate]; 1091 if (yypact_value_is_default (yyn)) 1092 goto yydefault; 1093 1094 /* Not known => get a lookahead token if don't already have one. */ 1095 1096 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 1097 if (yychar == YYEMPTY) 1098 { 1099 YYDPRINTF ((stderr, "Reading a token\n")); 1100 yychar = yylex (); 1101 } 1102 1103 if (yychar <= YYEOF) 1104 { 1105 yychar = YYEOF; 1106 yytoken = YYSYMBOL_YYEOF; 1107 YYDPRINTF ((stderr, "Now at end of input.\n")); 1108 } 1109 else if (yychar == YYerror) 1110 { 1111 /* The scanner already issued an error message, process directly 1112 to error recovery. But do not keep the error token as 1113 lookahead, it is too special and may lead us to an endless 1114 loop in error recovery. */ 1115 yychar = YYUNDEF; 1116 yytoken = YYSYMBOL_YYerror; 1117 goto yyerrlab1; 1118 } 1119 else 1120 { 1121 yytoken = YYTRANSLATE (yychar); 1122 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1123 } 1124 1125 /* If the proper action on seeing token YYTOKEN is to reduce or to 1126 detect an error, take that action. */ 1127 yyn += yytoken; 1128 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1129 goto yydefault; 1130 yyn = yytable[yyn]; 1131 if (yyn <= 0) 1132 { 1133 if (yytable_value_is_error (yyn)) 1134 goto yyerrlab; 1135 yyn = -yyn; 1136 goto yyreduce; 1137 } 1138 1139 /* Count tokens shifted since error; after three, turn off error 1140 status. */ 1141 if (yyerrstatus) 1142 yyerrstatus--; 1143 1144 /* Shift the lookahead token. */ 1145 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1146 yystate = yyn; 1147 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1148 *++yyvsp = yylval; 1149 YY_IGNORE_MAYBE_UNINITIALIZED_END 1150 1151 /* Discard the shifted token. */ 1152 yychar = YYEMPTY; 1153 goto yynewstate; 1154 1155 1156/*-----------------------------------------------------------. 1157| yydefault -- do the default action for the current state. | 1158`-----------------------------------------------------------*/ 1159yydefault: 1160 yyn = yydefact[yystate]; 1161 if (yyn == 0) 1162 goto yyerrlab; 1163 goto yyreduce; 1164 1165 1166/*-----------------------------. 1167| yyreduce -- do a reduction. | 1168`-----------------------------*/ 1169yyreduce: 1170 /* yyn is the number of a rule to reduce with. */ 1171 yylen = yyr2[yyn]; 1172 1173 /* If YYLEN is nonzero, implement the default value of the action: 1174 '$$ = $1'. 1175 1176 Otherwise, the following line sets YYVAL to garbage. 1177 This behavior is undocumented and Bison 1178 users should not rely upon it. Assigning to YYVAL 1179 unconditionally makes the parser a bit smaller, and it avoids a 1180 GCC warning that YYVAL may be used uninitialized. */ 1181 yyval = yyvsp[1-yylen]; 1182 1183 1184 YY_REDUCE_PRINT (yyn); 1185 switch (yyn) 1186 { 1187 case 2: /* $@1: %empty */ 1188#line 55 "sysinfo.y" 1189 { 1190 switch (writecode) 1191 { 1192 case 'i': 1193 printf("#ifdef SYSROFF_SWAP_IN\n"); 1194 break; 1195 case 'p': 1196 printf("#ifdef SYSROFF_p\n"); 1197 break; 1198 case 'd': 1199 break; 1200 case 'g': 1201 printf("#ifdef SYSROFF_SWAP_OUT\n"); 1202 break; 1203 case 'c': 1204 printf("#ifdef SYSROFF_PRINT\n"); 1205 printf("#include <stdio.h>\n"); 1206 printf("#include <stdlib.h>\n"); 1207 printf("#include <ansidecl.h>\n"); 1208 break; 1209 } 1210 } 1211#line 1212 "sysinfo.c" 1212 break; 1213 1214 case 3: /* top: $@1 it_list */ 1215#line 77 "sysinfo.y" 1216 { 1217 switch (writecode) { 1218 case 'i': 1219 case 'p': 1220 case 'g': 1221 case 'c': 1222 printf("#endif\n"); 1223 break; 1224 case 'd': 1225 break; 1226 } 1227} 1228#line 1229 "sysinfo.c" 1229 break; 1230 1231 case 6: /* $@2: %empty */ 1232#line 99 "sysinfo.y" 1233 { 1234 it = (yyvsp[-1].s); code = (yyvsp[0].i); 1235 switch (writecode) 1236 { 1237 case 'd': 1238 printf("\n\n\n#define IT_%s_CODE 0x%x\n", it,code); 1239 printf("struct IT_%s;\n", it); 1240 printf("extern void sysroff_swap_%s_in (struct IT_%s *);\n", 1241 (yyvsp[-1].s), it); 1242 printf("extern void sysroff_swap_%s_out (FILE *, struct IT_%s *);\n", 1243 (yyvsp[-1].s), it); 1244 printf("extern void sysroff_print_%s_out (struct IT_%s *);\n", 1245 (yyvsp[-1].s), it); 1246 printf("struct IT_%s { \n", it); 1247 break; 1248 case 'i': 1249 printf("void sysroff_swap_%s_in (struct IT_%s * ptr)\n",(yyvsp[-1].s),it); 1250 printf("{\n"); 1251 printf("\tunsigned char raw[255];\n"); 1252 printf("\tint idx = 0;\n"); 1253 printf("\tint size;\n"); 1254 printf("\tmemset(raw,0,255);\n"); 1255 printf("\tmemset(ptr,0,sizeof(*ptr));\n"); 1256 printf("\tsize = fillup(raw);\n"); 1257 break; 1258 case 'g': 1259 printf("void sysroff_swap_%s_out (FILE * ffile, struct IT_%s * ptr)\n",(yyvsp[-1].s),it); 1260 printf("{\n"); 1261 printf("\tunsigned char raw[255];\n"); 1262 printf("\tint idx = 16;\n"); 1263 printf("\tmemset (raw, 0, 255);\n"); 1264 printf("\tcode = IT_%s_CODE;\n", it); 1265 break; 1266 case 'o': 1267 printf("void sysroff_swap_%s_out (bfd * abfd, struct IT_%s * ptr)\n",(yyvsp[-1].s), it); 1268 printf("{\n"); 1269 printf("\tint idx = 0;\n"); 1270 break; 1271 case 'c': 1272 printf("void sysroff_print_%s_out (struct IT_%s *ptr)\n",(yyvsp[-1].s),it); 1273 printf("{\n"); 1274 printf("itheader(\"%s\", IT_%s_CODE);\n",(yyvsp[-1].s),(yyvsp[-1].s)); 1275 break; 1276 1277 case 't': 1278 break; 1279 } 1280 1281 } 1282#line 1283 "sysinfo.c" 1283 break; 1284 1285 case 7: /* it: '(' NAME NUMBER $@2 it_field_list ')' */ 1286#line 150 "sysinfo.y" 1287{ 1288 switch (writecode) { 1289 case 'd': 1290 printf("};\n"); 1291 break; 1292 case 'g': 1293 printf("\tchecksum(ffile,raw, idx, IT_%s_CODE);\n", it); 1294 /* Fall through. */ 1295 case 'i': 1296 case 'o': 1297 case 'c': 1298 printf("}\n"); 1299 } 1300 1301 free (it); 1302} 1303#line 1304 "sysinfo.c" 1304 break; 1305 1306 case 12: /* $@3: %empty */ 1307#line 178 "sysinfo.y" 1308 { 1309 rdepth++; 1310 switch (writecode) 1311 { 1312 case 'c': 1313 if (rdepth==1) 1314 printf("\tprintf(\"repeat %%d\\n\", %s);\n",(yyvsp[0].s)); 1315 if (rdepth==2) 1316 printf("\tprintf(\"repeat %%d\\n\", %s[n]);\n",(yyvsp[0].s)); 1317 /* Fall through. */ 1318 case 'i': 1319 case 'g': 1320 case 'o': 1321 1322 if (rdepth==1) 1323 { 1324 printf("\t{ int n; for (n = 0; n < %s; n++) {\n", (yyvsp[0].s)); 1325 } 1326 if (rdepth == 2) { 1327 printf("\t{ int m; for (m = 0; m < %s[n]; m++) {\n", (yyvsp[0].s)); 1328 } 1329 1330 break; 1331 } 1332 1333 oldrepeat = repeat; 1334 repeat = (yyvsp[0].s); 1335 } 1336#line 1337 "sysinfo.c" 1337 break; 1338 1339 case 13: /* repeat_it_field: '(' REPEAT NAME $@3 it_field_list ')' */ 1340#line 209 "sysinfo.y" 1341 { 1342 free (repeat); 1343 1344 repeat = oldrepeat; 1345 oldrepeat =0; 1346 rdepth--; 1347 switch (writecode) 1348 { 1349 case 'i': 1350 case 'g': 1351 case 'o': 1352 case 'c': 1353 printf("\t}}\n"); 1354 } 1355 } 1356#line 1357 "sysinfo.c" 1357 break; 1358 1359 case 14: /* $@4: %empty */ 1360#line 228 "sysinfo.y" 1361 { 1362 switch (writecode) 1363 { 1364 case 'i': 1365 case 'g': 1366 case 'o': 1367 case 'c': 1368 printf("\tif (%s) {\n", (yyvsp[0].s)); 1369 break; 1370 } 1371 1372 free ((yyvsp[0].s)); 1373 } 1374#line 1375 "sysinfo.c" 1375 break; 1376 1377 case 15: /* cond_it_field: '(' COND NAME $@4 it_field_list ')' */ 1378#line 243 "sysinfo.y" 1379 { 1380 switch (writecode) 1381 { 1382 case 'i': 1383 case 'g': 1384 case 'o': 1385 case 'c': 1386 printf("\t}\n"); 1387 } 1388 } 1389#line 1390 "sysinfo.c" 1390 break; 1391 1392 case 16: /* $@5: %empty */ 1393#line 257 "sysinfo.y" 1394 {name = (yyvsp[0].s); } 1395#line 1396 "sysinfo.c" 1396 break; 1397 1398 case 17: /* it_field: '(' attr_desc '(' attr_type attr_size ')' attr_id $@5 enums ')' */ 1399#line 259 "sysinfo.y" 1400 { 1401 char *desc = (yyvsp[-8].s); 1402 char *type = (yyvsp[-6].s); 1403 int size = (yyvsp[-5].i); 1404 char *id = (yyvsp[-3].s); 1405char *p = names[rdepth]; 1406char *ptr = pnames[rdepth]; 1407 switch (writecode) 1408 { 1409 case 'g': 1410 if (size % 8) 1411 { 1412 1413 printf("\twriteBITS(ptr->%s%s,raw,&idx,%d);\n", 1414 id, 1415 names[rdepth], size); 1416 1417 } 1418 else { 1419 printf("\twrite%s(ptr->%s%s,raw,&idx,%d,ffile);\n", 1420 type, 1421 id, 1422 names[rdepth],size/8); 1423 } 1424 break; 1425 case 'i': 1426 { 1427 1428 if (rdepth >= 1) 1429 1430 { 1431 printf("if (!ptr->%s) ptr->%s = (%s*)xcalloc(%s, sizeof(ptr->%s[0]));\n", 1432 id, 1433 id, 1434 type, 1435 repeat, 1436 id); 1437 } 1438 1439 if (rdepth == 2) 1440 { 1441 printf("if (!ptr->%s[n]) ptr->%s[n] = (%s**)xcalloc(%s[n], sizeof(ptr->%s[n][0]));\n", 1442 id, 1443 id, 1444 type, 1445 repeat, 1446 id); 1447 } 1448 1449 } 1450 1451 if (size % 8) 1452 { 1453 printf("\tptr->%s%s = getBITS(raw,&idx, %d,size);\n", 1454 id, 1455 names[rdepth], 1456 size); 1457 } 1458 else { 1459 printf("\tptr->%s%s = get%s(raw,&idx, %d,size);\n", 1460 id, 1461 names[rdepth], 1462 type, 1463 size/8); 1464 } 1465 break; 1466 case 'o': 1467 printf("\tput%s(raw,%d,%d,&idx,ptr->%s%s);\n", type,size/8,size%8,id,names[rdepth]); 1468 break; 1469 case 'd': 1470 if (repeat) 1471 printf("\t/* repeat %s */\n", repeat); 1472 1473 if (type[0] == 'I') { 1474 printf("\tint %s%s; \t/* %s */\n",ptr,id, desc); 1475 } 1476 else if (type[0] =='C') { 1477 printf("\tchar %s*%s;\t /* %s */\n",ptr,id, desc); 1478 } 1479 else { 1480 printf("\tbarray %s%s;\t /* %s */\n",ptr,id, desc); 1481 } 1482 break; 1483 case 'c': 1484 printf("tabout();\n"); 1485 printf("\tprintf(\"/*%-30s*/ ptr->%s = \");\n", desc, id); 1486 1487 if (type[0] == 'I') 1488 printf("\tprintf(\"%%d\\n\",ptr->%s%s);\n", id,p); 1489 else if (type[0] == 'C') 1490 printf("\tprintf(\"%%s\\n\",ptr->%s%s);\n", id,p); 1491 1492 else if (type[0] == 'B') 1493 { 1494 printf("\tpbarray(&ptr->%s%s);\n", id,p); 1495 } 1496 else abort(); 1497 break; 1498 } 1499 1500 free (desc); 1501 free (id); 1502 } 1503#line 1504 "sysinfo.c" 1504 break; 1505 1506 case 18: /* attr_type: TYPE */ 1507#line 367 "sysinfo.y" 1508 { (yyval.s) = (yyvsp[0].s); } 1509#line 1510 "sysinfo.c" 1510 break; 1511 1512 case 19: /* attr_type: %empty */ 1513#line 368 "sysinfo.y" 1514 { (yyval.s) = "INT";} 1515#line 1516 "sysinfo.c" 1516 break; 1517 1518 case 20: /* attr_desc: '(' NAME ')' */ 1519#line 373 "sysinfo.y" 1520 { (yyval.s) = (yyvsp[-1].s); } 1521#line 1522 "sysinfo.c" 1522 break; 1523 1524 case 21: /* attr_size: NUMBER UNIT */ 1525#line 378 "sysinfo.y" 1526 { (yyval.i) = (yyvsp[-1].i) * (yyvsp[0].i); } 1527#line 1528 "sysinfo.c" 1528 break; 1529 1530 case 22: /* attr_id: '(' NAME ')' */ 1531#line 383 "sysinfo.y" 1532 { (yyval.s) = (yyvsp[-1].s); } 1533#line 1534 "sysinfo.c" 1534 break; 1535 1536 case 23: /* attr_id: %empty */ 1537#line 384 "sysinfo.y" 1538 { (yyval.s) = strdup ("dummy");} 1539#line 1540 "sysinfo.c" 1540 break; 1541 1542 case 27: /* enum_list: enum_list '(' NAME NAME ')' */ 1543#line 392 "sysinfo.y" 1544 { 1545 switch (writecode) 1546 { 1547 case 'd': 1548 printf("#define %s %s\n", (yyvsp[-2].s),(yyvsp[-1].s)); 1549 break; 1550 case 'c': 1551 printf("if (ptr->%s%s == %s) { tabout(); printf(\"%s\\n\");}\n", name, names[rdepth],(yyvsp[-1].s),(yyvsp[-2].s)); 1552 } 1553 1554 free ((yyvsp[-2].s)); 1555 free ((yyvsp[-1].s)); 1556 } 1557#line 1558 "sysinfo.c" 1558 break; 1559 1560 1561#line 1562 "sysinfo.c" 1562 1563 default: break; 1564 } 1565 /* User semantic actions sometimes alter yychar, and that requires 1566 that yytoken be updated with the new translation. We take the 1567 approach of translating immediately before every use of yytoken. 1568 One alternative is translating here after every semantic action, 1569 but that translation would be missed if the semantic action invokes 1570 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1571 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1572 incorrect destructor might then be invoked immediately. In the 1573 case of YYERROR or YYBACKUP, subsequent parser actions might lead 1574 to an incorrect destructor call or verbose syntax error message 1575 before the lookahead is translated. */ 1576 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 1577 1578 YYPOPSTACK (yylen); 1579 yylen = 0; 1580 1581 *++yyvsp = yyval; 1582 1583 /* Now 'shift' the result of the reduction. Determine what state 1584 that goes to, based on the state we popped back to and the rule 1585 number reduced by. */ 1586 { 1587 const int yylhs = yyr1[yyn] - YYNTOKENS; 1588 const int yyi = yypgoto[yylhs] + *yyssp; 1589 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp 1590 ? yytable[yyi] 1591 : yydefgoto[yylhs]); 1592 } 1593 1594 goto yynewstate; 1595 1596 1597/*--------------------------------------. 1598| yyerrlab -- here on detecting error. | 1599`--------------------------------------*/ 1600yyerrlab: 1601 /* Make sure we have latest lookahead translation. See comments at 1602 user semantic actions for why this is necessary. */ 1603 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); 1604 /* If not already recovering from an error, report this error. */ 1605 if (!yyerrstatus) 1606 { 1607 ++yynerrs; 1608 yyerror (YY_("syntax error")); 1609 } 1610 1611 if (yyerrstatus == 3) 1612 { 1613 /* If just tried and failed to reuse lookahead token after an 1614 error, discard it. */ 1615 1616 if (yychar <= YYEOF) 1617 { 1618 /* Return failure if at end of input. */ 1619 if (yychar == YYEOF) 1620 YYABORT; 1621 } 1622 else 1623 { 1624 yydestruct ("Error: discarding", 1625 yytoken, &yylval); 1626 yychar = YYEMPTY; 1627 } 1628 } 1629 1630 /* Else will try to reuse lookahead token after shifting the error 1631 token. */ 1632 goto yyerrlab1; 1633 1634 1635/*---------------------------------------------------. 1636| yyerrorlab -- error raised explicitly by YYERROR. | 1637`---------------------------------------------------*/ 1638yyerrorlab: 1639 /* Pacify compilers when the user code never invokes YYERROR and the 1640 label yyerrorlab therefore never appears in user code. */ 1641 if (0) 1642 YYERROR; 1643 ++yynerrs; 1644 1645 /* Do not reclaim the symbols of the rule whose action triggered 1646 this YYERROR. */ 1647 YYPOPSTACK (yylen); 1648 yylen = 0; 1649 YY_STACK_PRINT (yyss, yyssp); 1650 yystate = *yyssp; 1651 goto yyerrlab1; 1652 1653 1654/*-------------------------------------------------------------. 1655| yyerrlab1 -- common code for both syntax error and YYERROR. | 1656`-------------------------------------------------------------*/ 1657yyerrlab1: 1658 yyerrstatus = 3; /* Each real token shifted decrements this. */ 1659 1660 /* Pop stack until we find a state that shifts the error token. */ 1661 for (;;) 1662 { 1663 yyn = yypact[yystate]; 1664 if (!yypact_value_is_default (yyn)) 1665 { 1666 yyn += YYSYMBOL_YYerror; 1667 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) 1668 { 1669 yyn = yytable[yyn]; 1670 if (0 < yyn) 1671 break; 1672 } 1673 } 1674 1675 /* Pop the current state because it cannot handle the error token. */ 1676 if (yyssp == yyss) 1677 YYABORT; 1678 1679 1680 yydestruct ("Error: popping", 1681 YY_ACCESSING_SYMBOL (yystate), yyvsp); 1682 YYPOPSTACK (1); 1683 yystate = *yyssp; 1684 YY_STACK_PRINT (yyss, yyssp); 1685 } 1686 1687 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1688 *++yyvsp = yylval; 1689 YY_IGNORE_MAYBE_UNINITIALIZED_END 1690 1691 1692 /* Shift the error token. */ 1693 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 1694 1695 yystate = yyn; 1696 goto yynewstate; 1697 1698 1699/*-------------------------------------. 1700| yyacceptlab -- YYACCEPT comes here. | 1701`-------------------------------------*/ 1702yyacceptlab: 1703 yyresult = 0; 1704 goto yyreturnlab; 1705 1706 1707/*-----------------------------------. 1708| yyabortlab -- YYABORT comes here. | 1709`-----------------------------------*/ 1710yyabortlab: 1711 yyresult = 1; 1712 goto yyreturnlab; 1713 1714 1715/*-----------------------------------------------------------. 1716| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 1717`-----------------------------------------------------------*/ 1718yyexhaustedlab: 1719 yyerror (YY_("memory exhausted")); 1720 yyresult = 2; 1721 goto yyreturnlab; 1722 1723 1724/*----------------------------------------------------------. 1725| yyreturnlab -- parsing is finished, clean up and return. | 1726`----------------------------------------------------------*/ 1727yyreturnlab: 1728 if (yychar != YYEMPTY) 1729 { 1730 /* Make sure we have latest lookahead translation. See comments at 1731 user semantic actions for why this is necessary. */ 1732 yytoken = YYTRANSLATE (yychar); 1733 yydestruct ("Cleanup: discarding lookahead", 1734 yytoken, &yylval); 1735 } 1736 /* Do not reclaim the symbols of the rule whose action triggered 1737 this YYABORT or YYACCEPT. */ 1738 YYPOPSTACK (yylen); 1739 YY_STACK_PRINT (yyss, yyssp); 1740 while (yyssp != yyss) 1741 { 1742 yydestruct ("Cleanup: popping", 1743 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); 1744 YYPOPSTACK (1); 1745 } 1746#ifndef yyoverflow 1747 if (yyss != yyssa) 1748 YYSTACK_FREE (yyss); 1749#endif 1750 1751 return yyresult; 1752} 1753 1754#line 410 "sysinfo.y" 1755 1756/* four modes 1757 1758 -d write structure definitions for sysroff in host format 1759 -i write functions to swap into sysroff format in 1760 -o write functions to swap into sysroff format out 1761 -c write code to print info in human form */ 1762 1763int yydebug; 1764 1765int 1766main (int ac, char **av) 1767{ 1768 yydebug=0; 1769 if (ac > 1) 1770 writecode = av[1][1]; 1771if (writecode == 'd') 1772 { 1773 printf("typedef struct { unsigned char *data; int len; } barray; \n"); 1774 printf("typedef int INT;\n"); 1775 printf("typedef char * CHARS;\n"); 1776 1777 } 1778 yyparse(); 1779return 0; 1780} 1781 1782static void 1783yyerror (const char *s) 1784{ 1785 fprintf(stderr, "%s\n" , s); 1786} 1787