1/* A Bison parser, made by GNU Bison 1.875c. */ 2 3/* Skeleton parser for Yacc-like parsing with Bison, 4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2, or (at your option) 9 any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place - Suite 330, 19 Boston, MA 02111-1307, USA. */ 20 21/* As a special exception, when this file is copied by Bison into a 22 Bison output file, you may use that output file without restriction. 23 This special exception was added by the Free Software Foundation 24 in version 1.24 of Bison. */ 25 26/* Written by Richard Stallman by simplifying the original so called 27 ``semantic'' parser. */ 28 29/* All symbols defined below should begin with yy or YY, to avoid 30 infringing on user name space. This should be done even for local 31 variables, as they might otherwise be expanded by user macros. 32 There are some unavoidable exceptions within include files to 33 define necessary library symbols; they are noted "INFRINGES ON 34 USER NAME SPACE" below. */ 35 36/* Identify Bison output. */ 37#define YYBISON 1 38 39/* Skeleton name. */ 40#define YYSKELETON_NAME "yacc.c" 41 42/* Pure parsers. */ 43#define YYPURE 0 44 45/* Using locations. */ 46#define YYLSP_NEEDED 0 47 48 49 50/* Tokens. */ 51#ifndef YYTOKENTYPE 52# define YYTOKENTYPE 53 /* Put the tokens into the symbol table, so that GDB and other debuggers 54 know about them. */ 55 enum yytokentype { 56 COND = 258, 57 REPEAT = 259, 58 TYPE = 260, 59 NAME = 261, 60 NUMBER = 262, 61 UNIT = 263 62 }; 63#endif 64#define COND 258 65#define REPEAT 259 66#define TYPE 260 67#define NAME 261 68#define NUMBER 262 69#define UNIT 263 70 71 72 73 74/* Copy the first part of user declarations. */ 75#line 20 "sysinfo.y" 76 77#include <stdio.h> 78#include <stdlib.h> 79 80static char writecode; 81static char *it; 82static int code; 83static char * repeat; 84static char *oldrepeat; 85static char *name; 86static int rdepth; 87static char *names[] = {" ","[n]","[n][m]"}; 88static char *pnames[]= {"","*","**"}; 89 90static int yyerror (char *s); 91extern int yylex (void); 92 93 94/* Enabling traces. */ 95#ifndef YYDEBUG 96# define YYDEBUG 0 97#endif 98 99/* Enabling verbose error messages. */ 100#ifdef YYERROR_VERBOSE 101# undef YYERROR_VERBOSE 102# define YYERROR_VERBOSE 1 103#else 104# define YYERROR_VERBOSE 0 105#endif 106 107#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) 108#line 39 "sysinfo.y" 109typedef union YYSTYPE { 110 int i; 111 char *s; 112} YYSTYPE; 113/* Line 191 of yacc.c. */ 114#line 115 "sysinfo.c" 115# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 116# define YYSTYPE_IS_DECLARED 1 117# define YYSTYPE_IS_TRIVIAL 1 118#endif 119 120 121 122/* Copy the second part of user declarations. */ 123 124 125/* Line 214 of yacc.c. */ 126#line 127 "sysinfo.c" 127 128#if ! defined (yyoverflow) || YYERROR_VERBOSE 129 130# ifndef YYFREE 131# define YYFREE free 132# endif 133# ifndef YYMALLOC 134# define YYMALLOC malloc 135# endif 136 137/* The parser invokes alloca or malloc; define the necessary symbols. */ 138 139# ifdef YYSTACK_USE_ALLOCA 140# if YYSTACK_USE_ALLOCA 141# define YYSTACK_ALLOC alloca 142# endif 143# else 144# if defined (alloca) || defined (_ALLOCA_H) 145# define YYSTACK_ALLOC alloca 146# else 147# ifdef __GNUC__ 148# define YYSTACK_ALLOC __builtin_alloca 149# endif 150# endif 151# endif 152 153# ifdef YYSTACK_ALLOC 154 /* Pacify GCC's `empty if-body' warning. */ 155# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 156# else 157# if defined (__STDC__) || defined (__cplusplus) 158# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 159# define YYSIZE_T size_t 160# endif 161# define YYSTACK_ALLOC YYMALLOC 162# define YYSTACK_FREE YYFREE 163# endif 164#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ 165 166 167#if (! defined (yyoverflow) \ 168 && (! defined (__cplusplus) \ 169 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) 170 171/* A type that is properly aligned for any stack member. */ 172union yyalloc 173{ 174 short yyss; 175 YYSTYPE yyvs; 176 }; 177 178/* The size of the maximum gap between one aligned stack and the next. */ 179# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 180 181/* The size of an array large to enough to hold all stacks, each with 182 N elements. */ 183# define YYSTACK_BYTES(N) \ 184 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ 185 + YYSTACK_GAP_MAXIMUM) 186 187/* Copy COUNT objects from FROM to TO. The source and destination do 188 not overlap. */ 189# ifndef YYCOPY 190# if defined (__GNUC__) && 1 < __GNUC__ 191# define YYCOPY(To, From, Count) \ 192 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 193# else 194# define YYCOPY(To, From, Count) \ 195 do \ 196 { \ 197 register YYSIZE_T yyi; \ 198 for (yyi = 0; yyi < (Count); yyi++) \ 199 (To)[yyi] = (From)[yyi]; \ 200 } \ 201 while (0) 202# endif 203# endif 204 205/* Relocate STACK from its old location to the new one. The 206 local variables YYSIZE and YYSTACKSIZE give the old and new number of 207 elements in the stack, and YYPTR gives the new location of the 208 stack. Advance YYPTR to a properly aligned location for the next 209 stack. */ 210# define YYSTACK_RELOCATE(Stack) \ 211 do \ 212 { \ 213 YYSIZE_T yynewbytes; \ 214 YYCOPY (&yyptr->Stack, Stack, yysize); \ 215 Stack = &yyptr->Stack; \ 216 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 217 yyptr += yynewbytes / sizeof (*yyptr); \ 218 } \ 219 while (0) 220 221#endif 222 223#if defined (__STDC__) || defined (__cplusplus) 224 typedef signed char yysigned_char; 225#else 226 typedef short yysigned_char; 227#endif 228 229/* YYFINAL -- State number of the termination state. */ 230#define YYFINAL 3 231/* YYLAST -- Last index in YYTABLE. */ 232#define YYLAST 38 233 234/* YYNTOKENS -- Number of terminals. */ 235#define YYNTOKENS 11 236/* YYNNTS -- Number of nonterminals. */ 237#define YYNNTS 19 238/* YYNRULES -- Number of rules. */ 239#define YYNRULES 27 240/* YYNRULES -- Number of states. */ 241#define YYNSTATES 55 242 243/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 244#define YYUNDEFTOK 2 245#define YYMAXUTOK 263 246 247#define YYTRANSLATE(YYX) \ 248 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 249 250/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 251static const unsigned char yytranslate[] = 252{ 253 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 254 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 255 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 256 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 257 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 258 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 259 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 260 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 261 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 262 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 263 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 264 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 265 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 266 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 267 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 268 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 269 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 270 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 271 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 272 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 273 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 274 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 275 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 276 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 277 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 278 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 279 7, 8, 9, 10 280}; 281 282#if YYDEBUG 283/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 284 YYRHS. */ 285static const unsigned char yyprhs[] = 286{ 287 0, 0, 3, 4, 7, 10, 11, 12, 19, 22, 288 25, 28, 29, 30, 37, 38, 45, 46, 57, 59, 289 60, 64, 67, 71, 72, 73, 77, 78 290}; 291 292/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 293static const yysigned_char yyrhs[] = 294{ 295 12, 0, -1, -1, 13, 14, -1, 15, 14, -1, 296 -1, -1, 5, 8, 9, 16, 17, 6, -1, 22, 297 17, -1, 20, 17, -1, 18, 17, -1, -1, -1, 298 5, 4, 8, 19, 17, 6, -1, -1, 5, 3, 299 8, 21, 17, 6, -1, -1, 5, 25, 5, 24, 300 26, 6, 27, 23, 28, 6, -1, 7, -1, -1, 301 5, 8, 6, -1, 9, 10, -1, 5, 8, 6, 302 -1, -1, -1, 5, 29, 6, -1, -1, 29, 5, 303 8, 8, 6, -1 304}; 305 306/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 307static const unsigned short yyrline[] = 308{ 309 0, 53, 53, 53, 91, 92, 97, 96, 174, 175, 310 176, 177, 181, 180, 228, 227, 255, 254, 362, 363, 311 367, 372, 378, 379, 382, 383, 385, 387 312}; 313#endif 314 315#if YYDEBUG || YYERROR_VERBOSE 316/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 317 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 318static const char *const yytname[] = 319{ 320 "$end", "error", "$undefined", "COND", "REPEAT", "'('", "')'", "TYPE", 321 "NAME", "NUMBER", "UNIT", "$accept", "top", "@1", "it_list", "it", "@2", 322 "it_field_list", "repeat_it_field", "@3", "cond_it_field", "@4", 323 "it_field", "@5", "attr_type", "attr_desc", "attr_size", "attr_id", 324 "enums", "enum_list", 0 325}; 326#endif 327 328# ifdef YYPRINT 329/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 330 token YYLEX-NUM. */ 331static const unsigned short yytoknum[] = 332{ 333 0, 256, 257, 258, 259, 40, 41, 260, 261, 262, 334 263 335}; 336# endif 337 338/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 339static const unsigned char yyr1[] = 340{ 341 0, 11, 13, 12, 14, 14, 16, 15, 17, 17, 342 17, 17, 19, 18, 21, 20, 23, 22, 24, 24, 343 25, 26, 27, 27, 28, 28, 29, 29 344}; 345 346/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 347static const unsigned char yyr2[] = 348{ 349 0, 2, 0, 2, 2, 0, 0, 6, 2, 2, 350 2, 0, 0, 6, 0, 6, 0, 10, 1, 0, 351 3, 2, 3, 0, 0, 3, 0, 5 352}; 353 354/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 355 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 356 means the default is an error. */ 357static const unsigned char yydefact[] = 358{ 359 2, 0, 5, 1, 0, 3, 5, 0, 4, 6, 360 11, 0, 0, 11, 11, 11, 0, 0, 0, 0, 361 7, 10, 9, 8, 14, 12, 0, 19, 11, 11, 362 20, 18, 0, 0, 0, 0, 0, 15, 13, 21, 363 23, 0, 16, 0, 24, 22, 26, 0, 0, 17, 364 0, 25, 0, 0, 27 365}; 366 367/* YYDEFGOTO[NTERM-NUM]. */ 368static const yysigned_char yydefgoto[] = 369{ 370 -1, 1, 2, 5, 6, 10, 12, 13, 29, 14, 371 28, 15, 44, 32, 19, 36, 42, 47, 48 372}; 373 374/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 375 STATE-NUM. */ 376#define YYPACT_NINF -14 377static const yysigned_char yypact[] = 378{ 379 -14, 8, 4, -14, 2, -14, 4, 3, -14, -14, 380 6, 0, 7, 6, 6, 6, 9, 10, 11, 15, 381 -14, -14, -14, -14, -14, -14, 16, 14, 6, 6, 382 -14, -14, 5, 17, 18, 19, 20, -14, -14, -14, 383 22, 23, -14, 24, 27, -14, -14, 28, 1, -14, 384 25, -14, 29, 30, -14 385}; 386 387/* YYPGOTO[NTERM-NUM]. */ 388static const yysigned_char yypgoto[] = 389{ 390 -14, -14, -14, 32, -14, -14, -13, -14, -14, -14, 391 -14, -14, -14, -14, -14, -14, -14, -14, -14 392}; 393 394/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 395 positive, shift that token. If negative, reduce the rule which 396 number is the opposite. If zero, do what YYDEFACT says. 397 If YYTABLE_NINF, syntax error. */ 398#define YYTABLE_NINF -1 399static const unsigned char yytable[] = 400{ 401 21, 22, 23, 16, 17, 18, 50, 51, 3, 4, 402 7, 11, 9, 20, 35, 33, 34, 24, 25, 26, 403 27, 31, 30, 37, 38, 0, 40, 41, 0, 39, 404 45, 43, 46, 52, 49, 0, 54, 53, 8 405}; 406 407static const yysigned_char yycheck[] = 408{ 409 13, 14, 15, 3, 4, 5, 5, 6, 0, 5, 410 8, 5, 9, 6, 9, 28, 29, 8, 8, 8, 411 5, 7, 6, 6, 6, -1, 6, 5, -1, 10, 412 6, 8, 5, 8, 6, -1, 6, 8, 6 413}; 414 415/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 416 symbol of state STATE-NUM. */ 417static const unsigned char yystos[] = 418{ 419 0, 12, 13, 0, 5, 14, 15, 8, 14, 9, 420 16, 5, 17, 18, 20, 22, 3, 4, 5, 25, 421 6, 17, 17, 17, 8, 8, 8, 5, 21, 19, 422 6, 7, 24, 17, 17, 9, 26, 6, 6, 10, 423 6, 5, 27, 8, 23, 6, 5, 28, 29, 6, 424 5, 6, 8, 8, 6 425}; 426 427#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) 428# define YYSIZE_T __SIZE_TYPE__ 429#endif 430#if ! defined (YYSIZE_T) && defined (size_t) 431# define YYSIZE_T size_t 432#endif 433#if ! defined (YYSIZE_T) 434# if defined (__STDC__) || defined (__cplusplus) 435# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 436# define YYSIZE_T size_t 437# endif 438#endif 439#if ! defined (YYSIZE_T) 440# define YYSIZE_T unsigned int 441#endif 442 443#define yyerrok (yyerrstatus = 0) 444#define yyclearin (yychar = YYEMPTY) 445#define YYEMPTY (-2) 446#define YYEOF 0 447 448#define YYACCEPT goto yyacceptlab 449#define YYABORT goto yyabortlab 450#define YYERROR goto yyerrorlab 451 452 453/* Like YYERROR except do call yyerror. This remains here temporarily 454 to ease the transition to the new meaning of YYERROR, for GCC. 455 Once GCC version 2 has supplanted version 1, this can go. */ 456 457#define YYFAIL goto yyerrlab 458 459#define YYRECOVERING() (!!yyerrstatus) 460 461#define YYBACKUP(Token, Value) \ 462do \ 463 if (yychar == YYEMPTY && yylen == 1) \ 464 { \ 465 yychar = (Token); \ 466 yylval = (Value); \ 467 yytoken = YYTRANSLATE (yychar); \ 468 YYPOPSTACK; \ 469 goto yybackup; \ 470 } \ 471 else \ 472 { \ 473 yyerror ("syntax error: cannot back up");\ 474 YYERROR; \ 475 } \ 476while (0) 477 478#define YYTERROR 1 479#define YYERRCODE 256 480 481/* YYLLOC_DEFAULT -- Compute the default location (before the actions 482 are run). */ 483 484#ifndef YYLLOC_DEFAULT 485# define YYLLOC_DEFAULT(Current, Rhs, N) \ 486 ((Current).first_line = (Rhs)[1].first_line, \ 487 (Current).first_column = (Rhs)[1].first_column, \ 488 (Current).last_line = (Rhs)[N].last_line, \ 489 (Current).last_column = (Rhs)[N].last_column) 490#endif 491 492/* YYLEX -- calling `yylex' with the right arguments. */ 493 494#ifdef YYLEX_PARAM 495# define YYLEX yylex (YYLEX_PARAM) 496#else 497# define YYLEX yylex () 498#endif 499 500/* Enable debugging if requested. */ 501#if YYDEBUG 502 503# ifndef YYFPRINTF 504# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 505# define YYFPRINTF fprintf 506# endif 507 508# define YYDPRINTF(Args) \ 509do { \ 510 if (yydebug) \ 511 YYFPRINTF Args; \ 512} while (0) 513 514# define YYDSYMPRINT(Args) \ 515do { \ 516 if (yydebug) \ 517 yysymprint Args; \ 518} while (0) 519 520# define YYDSYMPRINTF(Title, Token, Value, Location) \ 521do { \ 522 if (yydebug) \ 523 { \ 524 YYFPRINTF (stderr, "%s ", Title); \ 525 yysymprint (stderr, \ 526 Token, Value); \ 527 YYFPRINTF (stderr, "\n"); \ 528 } \ 529} while (0) 530 531/*------------------------------------------------------------------. 532| yy_stack_print -- Print the state stack from its BOTTOM up to its | 533| TOP (included). | 534`------------------------------------------------------------------*/ 535 536#if defined (__STDC__) || defined (__cplusplus) 537static void 538yy_stack_print (short *bottom, short *top) 539#else 540static void 541yy_stack_print (bottom, top) 542 short *bottom; 543 short *top; 544#endif 545{ 546 YYFPRINTF (stderr, "Stack now"); 547 for (/* Nothing. */; bottom <= top; ++bottom) 548 YYFPRINTF (stderr, " %d", *bottom); 549 YYFPRINTF (stderr, "\n"); 550} 551 552# define YY_STACK_PRINT(Bottom, Top) \ 553do { \ 554 if (yydebug) \ 555 yy_stack_print ((Bottom), (Top)); \ 556} while (0) 557 558 559/*------------------------------------------------. 560| Report that the YYRULE is going to be reduced. | 561`------------------------------------------------*/ 562 563#if defined (__STDC__) || defined (__cplusplus) 564static void 565yy_reduce_print (int yyrule) 566#else 567static void 568yy_reduce_print (yyrule) 569 int yyrule; 570#endif 571{ 572 int yyi; 573 unsigned int yylno = yyrline[yyrule]; 574 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", 575 yyrule - 1, yylno); 576 /* Print the symbols being reduced, and their result. */ 577 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) 578 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); 579 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); 580} 581 582# define YY_REDUCE_PRINT(Rule) \ 583do { \ 584 if (yydebug) \ 585 yy_reduce_print (Rule); \ 586} while (0) 587 588/* Nonzero means print parse trace. It is left uninitialized so that 589 multiple parsers can coexist. */ 590int yydebug; 591#else /* !YYDEBUG */ 592# define YYDPRINTF(Args) 593# define YYDSYMPRINT(Args) 594# define YYDSYMPRINTF(Title, Token, Value, Location) 595# define YY_STACK_PRINT(Bottom, Top) 596# define YY_REDUCE_PRINT(Rule) 597#endif /* !YYDEBUG */ 598 599 600/* YYINITDEPTH -- initial size of the parser's stacks. */ 601#ifndef YYINITDEPTH 602# define YYINITDEPTH 200 603#endif 604 605/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 606 if the built-in stack extension method is used). 607 608 Do not make this value too large; the results are undefined if 609 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) 610 evaluated with infinite-precision integer arithmetic. */ 611 612#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 613# undef YYMAXDEPTH 614#endif 615 616#ifndef YYMAXDEPTH 617# define YYMAXDEPTH 10000 618#endif 619 620 621 622#if YYERROR_VERBOSE 623 624# ifndef yystrlen 625# if defined (__GLIBC__) && defined (_STRING_H) 626# define yystrlen strlen 627# else 628/* Return the length of YYSTR. */ 629static YYSIZE_T 630# if defined (__STDC__) || defined (__cplusplus) 631yystrlen (const char *yystr) 632# else 633yystrlen (yystr) 634 const char *yystr; 635# endif 636{ 637 register const char *yys = yystr; 638 639 while (*yys++ != '\0') 640 continue; 641 642 return yys - yystr - 1; 643} 644# endif 645# endif 646 647# ifndef yystpcpy 648# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) 649# define yystpcpy stpcpy 650# else 651/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 652 YYDEST. */ 653static char * 654# if defined (__STDC__) || defined (__cplusplus) 655yystpcpy (char *yydest, const char *yysrc) 656# else 657yystpcpy (yydest, yysrc) 658 char *yydest; 659 const char *yysrc; 660# endif 661{ 662 register char *yyd = yydest; 663 register const char *yys = yysrc; 664 665 while ((*yyd++ = *yys++) != '\0') 666 continue; 667 668 return yyd - 1; 669} 670# endif 671# endif 672 673#endif /* !YYERROR_VERBOSE */ 674 675 676 677#if YYDEBUG 678/*--------------------------------. 679| Print this symbol on YYOUTPUT. | 680`--------------------------------*/ 681 682#if defined (__STDC__) || defined (__cplusplus) 683static void 684yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) 685#else 686static void 687yysymprint (yyoutput, yytype, yyvaluep) 688 FILE *yyoutput; 689 int yytype; 690 YYSTYPE *yyvaluep; 691#endif 692{ 693 /* Pacify ``unused variable'' warnings. */ 694 (void) yyvaluep; 695 696 if (yytype < YYNTOKENS) 697 { 698 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 699# ifdef YYPRINT 700 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 701# endif 702 } 703 else 704 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 705 706 switch (yytype) 707 { 708 default: 709 break; 710 } 711 YYFPRINTF (yyoutput, ")"); 712} 713 714#endif /* ! YYDEBUG */ 715/*-----------------------------------------------. 716| Release the memory associated to this symbol. | 717`-----------------------------------------------*/ 718 719#if defined (__STDC__) || defined (__cplusplus) 720static void 721yydestruct (int yytype, YYSTYPE *yyvaluep) 722#else 723static void 724yydestruct (yytype, yyvaluep) 725 int yytype; 726 YYSTYPE *yyvaluep; 727#endif 728{ 729 /* Pacify ``unused variable'' warnings. */ 730 (void) yyvaluep; 731 732 switch (yytype) 733 { 734 735 default: 736 break; 737 } 738} 739 740 741/* Prevent warnings from -Wmissing-prototypes. */ 742 743#ifdef YYPARSE_PARAM 744# if defined (__STDC__) || defined (__cplusplus) 745int yyparse (void *YYPARSE_PARAM); 746# else 747int yyparse (); 748# endif 749#else /* ! YYPARSE_PARAM */ 750#if defined (__STDC__) || defined (__cplusplus) 751int yyparse (void); 752#else 753int yyparse (); 754#endif 755#endif /* ! YYPARSE_PARAM */ 756 757 758 759/* The lookahead symbol. */ 760int yychar; 761 762/* The semantic value of the lookahead symbol. */ 763YYSTYPE yylval; 764 765/* Number of syntax errors so far. */ 766int yynerrs; 767 768 769 770/*----------. 771| yyparse. | 772`----------*/ 773 774#ifdef YYPARSE_PARAM 775# if defined (__STDC__) || defined (__cplusplus) 776int yyparse (void *YYPARSE_PARAM) 777# else 778int yyparse (YYPARSE_PARAM) 779 void *YYPARSE_PARAM; 780# endif 781#else /* ! YYPARSE_PARAM */ 782#if defined (__STDC__) || defined (__cplusplus) 783int 784yyparse (void) 785#else 786int 787yyparse () 788 789#endif 790#endif 791{ 792 793 register int yystate; 794 register int yyn; 795 int yyresult; 796 /* Number of tokens to shift before error messages enabled. */ 797 int yyerrstatus; 798 /* Lookahead token as an internal (translated) token number. */ 799 int yytoken = 0; 800 801 /* Three stacks and their tools: 802 `yyss': related to states, 803 `yyvs': related to semantic values, 804 `yyls': related to locations. 805 806 Refer to the stacks thru separate pointers, to allow yyoverflow 807 to reallocate them elsewhere. */ 808 809 /* The state stack. */ 810 short yyssa[YYINITDEPTH]; 811 short *yyss = yyssa; 812 register short *yyssp; 813 814 /* The semantic value stack. */ 815 YYSTYPE yyvsa[YYINITDEPTH]; 816 YYSTYPE *yyvs = yyvsa; 817 register YYSTYPE *yyvsp; 818 819 820 821#define YYPOPSTACK (yyvsp--, yyssp--) 822 823 YYSIZE_T yystacksize = YYINITDEPTH; 824 825 /* The variables used to return semantic value and location from the 826 action routines. */ 827 YYSTYPE yyval; 828 829 830 /* When reducing, the number of symbols on the RHS of the reduced 831 rule. */ 832 int yylen; 833 834 YYDPRINTF ((stderr, "Starting parse\n")); 835 836 yystate = 0; 837 yyerrstatus = 0; 838 yynerrs = 0; 839 yychar = YYEMPTY; /* Cause a token to be read. */ 840 841 /* Initialize stack pointers. 842 Waste one element of value and location stack 843 so that they stay on the same level as the state stack. 844 The wasted elements are never initialized. */ 845 846 yyssp = yyss; 847 yyvsp = yyvs; 848 849 goto yysetstate; 850 851/*------------------------------------------------------------. 852| yynewstate -- Push a new state, which is found in yystate. | 853`------------------------------------------------------------*/ 854 yynewstate: 855 /* In all cases, when you get here, the value and location stacks 856 have just been pushed. so pushing a state here evens the stacks. 857 */ 858 yyssp++; 859 860 yysetstate: 861 *yyssp = yystate; 862 863 if (yyss + yystacksize - 1 <= yyssp) 864 { 865 /* Get the current used size of the three stacks, in elements. */ 866 YYSIZE_T yysize = yyssp - yyss + 1; 867 868#ifdef yyoverflow 869 { 870 /* Give user a chance to reallocate the stack. Use copies of 871 these so that the &'s don't force the real ones into 872 memory. */ 873 YYSTYPE *yyvs1 = yyvs; 874 short *yyss1 = yyss; 875 876 877 /* Each stack pointer address is followed by the size of the 878 data in use in that stack, in bytes. This used to be a 879 conditional around just the two extra args, but that might 880 be undefined if yyoverflow is a macro. */ 881 yyoverflow ("parser stack overflow", 882 &yyss1, yysize * sizeof (*yyssp), 883 &yyvs1, yysize * sizeof (*yyvsp), 884 885 &yystacksize); 886 887 yyss = yyss1; 888 yyvs = yyvs1; 889 } 890#else /* no yyoverflow */ 891# ifndef YYSTACK_RELOCATE 892 goto yyoverflowlab; 893# else 894 /* Extend the stack our own way. */ 895 if (YYMAXDEPTH <= yystacksize) 896 goto yyoverflowlab; 897 yystacksize *= 2; 898 if (YYMAXDEPTH < yystacksize) 899 yystacksize = YYMAXDEPTH; 900 901 { 902 short *yyss1 = yyss; 903 union yyalloc *yyptr = 904 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 905 if (! yyptr) 906 goto yyoverflowlab; 907 YYSTACK_RELOCATE (yyss); 908 YYSTACK_RELOCATE (yyvs); 909 910# undef YYSTACK_RELOCATE 911 if (yyss1 != yyssa) 912 YYSTACK_FREE (yyss1); 913 } 914# endif 915#endif /* no yyoverflow */ 916 917 yyssp = yyss + yysize - 1; 918 yyvsp = yyvs + yysize - 1; 919 920 921 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 922 (unsigned long int) yystacksize)); 923 924 if (yyss + yystacksize - 1 <= yyssp) 925 YYABORT; 926 } 927 928 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 929 930 goto yybackup; 931 932/*-----------. 933| yybackup. | 934`-----------*/ 935yybackup: 936 937/* Do appropriate processing given the current state. */ 938/* Read a lookahead token if we need one and don't already have one. */ 939/* yyresume: */ 940 941 /* First try to decide what to do without reference to lookahead token. */ 942 943 yyn = yypact[yystate]; 944 if (yyn == YYPACT_NINF) 945 goto yydefault; 946 947 /* Not known => get a lookahead token if don't already have one. */ 948 949 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 950 if (yychar == YYEMPTY) 951 { 952 YYDPRINTF ((stderr, "Reading a token: ")); 953 yychar = YYLEX; 954 } 955 956 if (yychar <= YYEOF) 957 { 958 yychar = yytoken = YYEOF; 959 YYDPRINTF ((stderr, "Now at end of input.\n")); 960 } 961 else 962 { 963 yytoken = YYTRANSLATE (yychar); 964 YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); 965 } 966 967 /* If the proper action on seeing token YYTOKEN is to reduce or to 968 detect an error, take that action. */ 969 yyn += yytoken; 970 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 971 goto yydefault; 972 yyn = yytable[yyn]; 973 if (yyn <= 0) 974 { 975 if (yyn == 0 || yyn == YYTABLE_NINF) 976 goto yyerrlab; 977 yyn = -yyn; 978 goto yyreduce; 979 } 980 981 if (yyn == YYFINAL) 982 YYACCEPT; 983 984 /* Shift the lookahead token. */ 985 YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); 986 987 /* Discard the token being shifted unless it is eof. */ 988 if (yychar != YYEOF) 989 yychar = YYEMPTY; 990 991 *++yyvsp = yylval; 992 993 994 /* Count tokens shifted since error; after three, turn off error 995 status. */ 996 if (yyerrstatus) 997 yyerrstatus--; 998 999 yystate = yyn; 1000 goto yynewstate; 1001 1002 1003/*-----------------------------------------------------------. 1004| yydefault -- do the default action for the current state. | 1005`-----------------------------------------------------------*/ 1006yydefault: 1007 yyn = yydefact[yystate]; 1008 if (yyn == 0) 1009 goto yyerrlab; 1010 goto yyreduce; 1011 1012 1013/*-----------------------------. 1014| yyreduce -- Do a reduction. | 1015`-----------------------------*/ 1016yyreduce: 1017 /* yyn is the number of a rule to reduce with. */ 1018 yylen = yyr2[yyn]; 1019 1020 /* If YYLEN is nonzero, implement the default value of the action: 1021 `$$ = $1'. 1022 1023 Otherwise, the following line sets YYVAL to garbage. 1024 This behavior is undocumented and Bison 1025 users should not rely upon it. Assigning to YYVAL 1026 unconditionally makes the parser a bit smaller, and it avoids a 1027 GCC warning that YYVAL may be used uninitialized. */ 1028 yyval = yyvsp[1-yylen]; 1029 1030 1031 YY_REDUCE_PRINT (yyn); 1032 switch (yyn) 1033 { 1034 case 2: 1035#line 53 "sysinfo.y" 1036 { 1037 switch (writecode) 1038 { 1039 case 'i': 1040 printf("#ifdef SYSROFF_SWAP_IN\n"); 1041 break; 1042 case 'p': 1043 printf("#ifdef SYSROFF_p\n"); 1044 break; 1045 case 'd': 1046 break; 1047 case 'g': 1048 printf("#ifdef SYSROFF_SWAP_OUT\n"); 1049 break; 1050 case 'c': 1051 printf("#ifdef SYSROFF_PRINT\n"); 1052 printf("#include <stdio.h>\n"); 1053 printf("#include <stdlib.h>\n"); 1054 printf("#include <ansidecl.h>\n"); 1055 break; 1056 } 1057 } 1058 break; 1059 1060 case 3: 1061#line 75 "sysinfo.y" 1062 { 1063 switch (writecode) { 1064 case 'i': 1065 case 'p': 1066 case 'g': 1067 case 'c': 1068 printf("#endif\n"); 1069 break; 1070 case 'd': 1071 break; 1072 } 1073} 1074 break; 1075 1076 case 6: 1077#line 97 "sysinfo.y" 1078 { 1079 it = yyvsp[-1].s; code = yyvsp[0].i; 1080 switch (writecode) 1081 { 1082 case 'd': 1083 printf("\n\n\n#define IT_%s_CODE 0x%x\n", it,code); 1084 printf("struct IT_%s;\n", it); 1085 printf("extern void sysroff_swap_%s_in PARAMS ((struct IT_%s *));\n", 1086 yyvsp[-1].s, it); 1087 printf("extern void sysroff_swap_%s_out PARAMS ((FILE *, struct IT_%s *));\n", 1088 yyvsp[-1].s, it); 1089 printf("extern void sysroff_print_%s_out PARAMS ((struct IT_%s *));\n", 1090 yyvsp[-1].s, it); 1091 printf("struct IT_%s { \n", it); 1092 break; 1093 case 'i': 1094 printf("void sysroff_swap_%s_in(ptr)\n",yyvsp[-1].s); 1095 printf("struct IT_%s *ptr;\n", it); 1096 printf("{\n"); 1097 printf("unsigned char raw[255];\n"); 1098 printf("\tint idx = 0 ;\n"); 1099 printf("\tint size;\n"); 1100 printf("memset(raw,0,255);\n"); 1101 printf("memset(ptr,0,sizeof(*ptr));\n"); 1102 printf("size = fillup(raw);\n"); 1103 break; 1104 case 'g': 1105 printf("void sysroff_swap_%s_out(file,ptr)\n",yyvsp[-1].s); 1106 printf("FILE * file;\n"); 1107 printf("struct IT_%s *ptr;\n", it); 1108 printf("{\n"); 1109 printf("\tunsigned char raw[255];\n"); 1110 printf("\tint idx = 16 ;\n"); 1111 printf("\tmemset (raw, 0, 255);\n"); 1112 printf("\tcode = IT_%s_CODE;\n", it); 1113 break; 1114 case 'o': 1115 printf("void sysroff_swap_%s_out(abfd,ptr)\n",yyvsp[-1].s); 1116 printf("bfd * abfd;\n"); 1117 printf("struct IT_%s *ptr;\n",it); 1118 printf("{\n"); 1119 printf("int idx = 0 ;\n"); 1120 break; 1121 case 'c': 1122 printf("void sysroff_print_%s_out(ptr)\n",yyvsp[-1].s); 1123 printf("struct IT_%s *ptr;\n", it); 1124 printf("{\n"); 1125 printf("itheader(\"%s\", IT_%s_CODE);\n",yyvsp[-1].s,yyvsp[-1].s); 1126 break; 1127 1128 case 't': 1129 break; 1130 } 1131 1132 } 1133 break; 1134 1135 case 7: 1136#line 154 "sysinfo.y" 1137 { 1138 switch (writecode) { 1139 case 'd': 1140 printf("};\n"); 1141 break; 1142 case 'g': 1143 printf("\tchecksum(file,raw, idx, IT_%s_CODE);\n", it); 1144 1145 case 'i': 1146 1147 case 'o': 1148 case 'c': 1149 printf("}\n"); 1150 } 1151} 1152 break; 1153 1154 case 12: 1155#line 181 "sysinfo.y" 1156 { 1157 rdepth++; 1158 switch (writecode) 1159 { 1160 case 'c': 1161 if (rdepth==1) 1162 printf("\tprintf(\"repeat %%d\\n\", %s);\n",yyvsp[0].s); 1163 if (rdepth==2) 1164 printf("\tprintf(\"repeat %%d\\n\", %s[n]);\n",yyvsp[0].s); 1165 case 'i': 1166 case 'g': 1167 case 'o': 1168 1169 if (rdepth==1) 1170 { 1171 printf("\t{ int n; for (n = 0; n < %s; n++) {\n", yyvsp[0].s); 1172 } 1173 if (rdepth == 2) { 1174 printf("\t{ int m; for (m = 0; m < %s[n]; m++) {\n", yyvsp[0].s); 1175 } 1176 1177 break; 1178 } 1179 1180 oldrepeat = repeat; 1181 repeat = yyvsp[0].s; 1182 } 1183 break; 1184 1185 case 13: 1186#line 211 "sysinfo.y" 1187 { 1188 repeat = oldrepeat; 1189 oldrepeat =0; 1190 rdepth--; 1191 switch (writecode) 1192 { 1193 case 'i': 1194 case 'g': 1195 case 'o': 1196 case 'c': 1197 printf("\t}}\n"); 1198 } 1199 } 1200 break; 1201 1202 case 14: 1203#line 228 "sysinfo.y" 1204 { 1205 switch (writecode) 1206 { 1207 case 'i': 1208 case 'g': 1209 case 'o': 1210 case 'c': 1211 printf("\tif (%s) {\n", yyvsp[0].s); 1212 break; 1213 } 1214 } 1215 break; 1216 1217 case 15: 1218#line 241 "sysinfo.y" 1219 { 1220 switch (writecode) 1221 { 1222 case 'i': 1223 case 'g': 1224 case 'o': 1225 case 'c': 1226 printf("\t}\n"); 1227 } 1228 } 1229 break; 1230 1231 case 16: 1232#line 255 "sysinfo.y" 1233 {name = yyvsp[0].s; } 1234 break; 1235 1236 case 17: 1237#line 257 "sysinfo.y" 1238 { 1239 char *desc = yyvsp[-8].s; 1240 char *type = yyvsp[-6].s; 1241 int size = yyvsp[-5].i; 1242 char *id = yyvsp[-3].s; 1243char *p = names[rdepth]; 1244char *ptr = pnames[rdepth]; 1245 switch (writecode) 1246 { 1247 case 'g': 1248 if (size % 8) 1249 { 1250 1251 printf("\twriteBITS(ptr->%s%s,raw,&idx,%d);\n", 1252 id, 1253 names[rdepth], size); 1254 1255 } 1256 else { 1257 printf("\twrite%s(ptr->%s%s,raw,&idx,%d,file);\n", 1258 type, 1259 id, 1260 names[rdepth],size/8); 1261 } 1262 break; 1263 case 'i': 1264 { 1265 1266 if (rdepth >= 1) 1267 1268 { 1269 printf("if (!ptr->%s) ptr->%s = (%s*)xcalloc(%s, sizeof(ptr->%s[0]));\n", 1270 id, 1271 id, 1272 type, 1273 repeat, 1274 id); 1275 } 1276 1277 if (rdepth == 2) 1278 { 1279 printf("if (!ptr->%s[n]) ptr->%s[n] = (%s**)xcalloc(%s[n], sizeof(ptr->%s[n][0]));\n", 1280 id, 1281 id, 1282 type, 1283 repeat, 1284 id); 1285 } 1286 1287 } 1288 1289 if (size % 8) 1290 { 1291 printf("\tptr->%s%s = getBITS(raw,&idx, %d,size);\n", 1292 id, 1293 names[rdepth], 1294 size); 1295 } 1296 else { 1297 printf("\tptr->%s%s = get%s(raw,&idx, %d,size);\n", 1298 id, 1299 names[rdepth], 1300 type, 1301 size/8); 1302 } 1303 break; 1304 case 'o': 1305 printf("\tput%s(raw,%d,%d,&idx,ptr->%s%s);\n", type,size/8,size%8,id,names[rdepth]); 1306 break; 1307 case 'd': 1308 if (repeat) 1309 printf("\t/* repeat %s */\n", repeat); 1310 1311 if (type[0] == 'I') { 1312 printf("\tint %s%s; \t/* %s */\n",ptr,id, desc); 1313 } 1314 else if (type[0] =='C') { 1315 printf("\tchar %s*%s;\t /* %s */\n",ptr,id, desc); 1316 } 1317 else { 1318 printf("\tbarray %s%s;\t /* %s */\n",ptr,id, desc); 1319 } 1320 break; 1321 case 'c': 1322 printf("tabout();\n"); 1323 printf("\tprintf(\"/*%-30s*/ ptr->%s = \");\n", desc, id); 1324 1325 if (type[0] == 'I') 1326 printf("\tprintf(\"%%d\\n\",ptr->%s%s);\n", id,p); 1327 else if (type[0] == 'C') 1328 printf("\tprintf(\"%%s\\n\",ptr->%s%s);\n", id,p); 1329 1330 else if (type[0] == 'B') 1331 { 1332 printf("\tpbarray(&ptr->%s%s);\n", id,p); 1333 } 1334 else abort(); 1335 break; 1336 } 1337 } 1338 break; 1339 1340 case 18: 1341#line 362 "sysinfo.y" 1342 { yyval.s = yyvsp[0].s; } 1343 break; 1344 1345 case 19: 1346#line 363 "sysinfo.y" 1347 { yyval.s = "INT";} 1348 break; 1349 1350 case 20: 1351#line 368 "sysinfo.y" 1352 { yyval.s = yyvsp[-1].s; } 1353 break; 1354 1355 case 21: 1356#line 373 "sysinfo.y" 1357 { yyval.i = yyvsp[-1].i * yyvsp[0].i; } 1358 break; 1359 1360 case 22: 1361#line 378 "sysinfo.y" 1362 { yyval.s = yyvsp[-1].s; } 1363 break; 1364 1365 case 23: 1366#line 379 "sysinfo.y" 1367 { yyval.s = "dummy";} 1368 break; 1369 1370 case 27: 1371#line 387 "sysinfo.y" 1372 { 1373 switch (writecode) 1374 { 1375 case 'd': 1376 printf("#define %s %s\n", yyvsp[-2].s,yyvsp[-1].s); 1377 break; 1378 case 'c': 1379 printf("if (ptr->%s%s == %s) { tabout(); printf(\"%s\\n\");}\n", name, names[rdepth],yyvsp[-1].s,yyvsp[-2].s); 1380 } 1381 } 1382 break; 1383 1384 1385 } 1386 1387/* Line 1000 of yacc.c. */ 1388#line 1389 "sysinfo.c" 1389 1390 yyvsp -= yylen; 1391 yyssp -= yylen; 1392 1393 1394 YY_STACK_PRINT (yyss, yyssp); 1395 1396 *++yyvsp = yyval; 1397 1398 1399 /* Now `shift' the result of the reduction. Determine what state 1400 that goes to, based on the state we popped back to and the rule 1401 number reduced by. */ 1402 1403 yyn = yyr1[yyn]; 1404 1405 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1406 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1407 yystate = yytable[yystate]; 1408 else 1409 yystate = yydefgoto[yyn - YYNTOKENS]; 1410 1411 goto yynewstate; 1412 1413 1414/*------------------------------------. 1415| yyerrlab -- here on detecting error | 1416`------------------------------------*/ 1417yyerrlab: 1418 /* If not already recovering from an error, report this error. */ 1419 if (!yyerrstatus) 1420 { 1421 ++yynerrs; 1422#if YYERROR_VERBOSE 1423 yyn = yypact[yystate]; 1424 1425 if (YYPACT_NINF < yyn && yyn < YYLAST) 1426 { 1427 YYSIZE_T yysize = 0; 1428 int yytype = YYTRANSLATE (yychar); 1429 const char* yyprefix; 1430 char *yymsg; 1431 int yyx; 1432 1433 /* Start YYX at -YYN if negative to avoid negative indexes in 1434 YYCHECK. */ 1435 int yyxbegin = yyn < 0 ? -yyn : 0; 1436 1437 /* Stay within bounds of both yycheck and yytname. */ 1438 int yychecklim = YYLAST - yyn; 1439 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1440 int yycount = 0; 1441 1442 yyprefix = ", expecting "; 1443 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1444 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1445 { 1446 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); 1447 yycount += 1; 1448 if (yycount == 5) 1449 { 1450 yysize = 0; 1451 break; 1452 } 1453 } 1454 yysize += (sizeof ("syntax error, unexpected ") 1455 + yystrlen (yytname[yytype])); 1456 yymsg = (char *) YYSTACK_ALLOC (yysize); 1457 if (yymsg != 0) 1458 { 1459 char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); 1460 yyp = yystpcpy (yyp, yytname[yytype]); 1461 1462 if (yycount < 5) 1463 { 1464 yyprefix = ", expecting "; 1465 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1466 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1467 { 1468 yyp = yystpcpy (yyp, yyprefix); 1469 yyp = yystpcpy (yyp, yytname[yyx]); 1470 yyprefix = " or "; 1471 } 1472 } 1473 yyerror (yymsg); 1474 YYSTACK_FREE (yymsg); 1475 } 1476 else 1477 yyerror ("syntax error; also virtual memory exhausted"); 1478 } 1479 else 1480#endif /* YYERROR_VERBOSE */ 1481 yyerror ("syntax error"); 1482 } 1483 1484 1485 1486 if (yyerrstatus == 3) 1487 { 1488 /* If just tried and failed to reuse lookahead token after an 1489 error, discard it. */ 1490 1491 if (yychar <= YYEOF) 1492 { 1493 /* If at end of input, pop the error token, 1494 then the rest of the stack, then return failure. */ 1495 if (yychar == YYEOF) 1496 for (;;) 1497 { 1498 YYPOPSTACK; 1499 if (yyssp == yyss) 1500 YYABORT; 1501 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); 1502 yydestruct (yystos[*yyssp], yyvsp); 1503 } 1504 } 1505 else 1506 { 1507 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); 1508 yydestruct (yytoken, &yylval); 1509 yychar = YYEMPTY; 1510 1511 } 1512 } 1513 1514 /* Else will try to reuse lookahead token after shifting the error 1515 token. */ 1516 goto yyerrlab1; 1517 1518 1519/*---------------------------------------------------. 1520| yyerrorlab -- error raised explicitly by YYERROR. | 1521`---------------------------------------------------*/ 1522yyerrorlab: 1523 1524#ifdef __GNUC__ 1525 /* Pacify GCC when the user code never invokes YYERROR and the label 1526 yyerrorlab therefore never appears in user code. */ 1527 if (0) 1528 goto yyerrorlab; 1529#endif 1530 1531 yyvsp -= yylen; 1532 yyssp -= yylen; 1533 yystate = *yyssp; 1534 goto yyerrlab1; 1535 1536 1537/*-------------------------------------------------------------. 1538| yyerrlab1 -- common code for both syntax error and YYERROR. | 1539`-------------------------------------------------------------*/ 1540yyerrlab1: 1541 yyerrstatus = 3; /* Each real token shifted decrements this. */ 1542 1543 for (;;) 1544 { 1545 yyn = yypact[yystate]; 1546 if (yyn != YYPACT_NINF) 1547 { 1548 yyn += YYTERROR; 1549 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 1550 { 1551 yyn = yytable[yyn]; 1552 if (0 < yyn) 1553 break; 1554 } 1555 } 1556 1557 /* Pop the current state because it cannot handle the error token. */ 1558 if (yyssp == yyss) 1559 YYABORT; 1560 1561 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); 1562 yydestruct (yystos[yystate], yyvsp); 1563 YYPOPSTACK; 1564 yystate = *yyssp; 1565 YY_STACK_PRINT (yyss, yyssp); 1566 } 1567 1568 if (yyn == YYFINAL) 1569 YYACCEPT; 1570 1571 YYDPRINTF ((stderr, "Shifting error token, ")); 1572 1573 *++yyvsp = yylval; 1574 1575 1576 yystate = yyn; 1577 goto yynewstate; 1578 1579 1580/*-------------------------------------. 1581| yyacceptlab -- YYACCEPT comes here. | 1582`-------------------------------------*/ 1583yyacceptlab: 1584 yyresult = 0; 1585 goto yyreturn; 1586 1587/*-----------------------------------. 1588| yyabortlab -- YYABORT comes here. | 1589`-----------------------------------*/ 1590yyabortlab: 1591 yyresult = 1; 1592 goto yyreturn; 1593 1594#ifndef yyoverflow 1595/*----------------------------------------------. 1596| yyoverflowlab -- parser overflow comes here. | 1597`----------------------------------------------*/ 1598yyoverflowlab: 1599 yyerror ("parser stack overflow"); 1600 yyresult = 2; 1601 /* Fall through. */ 1602#endif 1603 1604yyreturn: 1605#ifndef yyoverflow 1606 if (yyss != yyssa) 1607 YYSTACK_FREE (yyss); 1608#endif 1609 return yyresult; 1610} 1611 1612 1613#line 402 "sysinfo.y" 1614 1615/* four modes 1616 1617 -d write structure definitions for sysroff in host format 1618 -i write functions to swap into sysroff format in 1619 -o write functions to swap into sysroff format out 1620 -c write code to print info in human form */ 1621 1622int yydebug; 1623 1624int 1625main (int ac, char **av) 1626{ 1627 yydebug=0; 1628 if (ac > 1) 1629 writecode = av[1][1]; 1630if (writecode == 'd') 1631 { 1632 printf("typedef struct { unsigned char *data; int len; } barray; \n"); 1633 printf("typedef int INT;\n"); 1634 printf("typedef char * CHARS;\n"); 1635 1636 } 1637 yyparse(); 1638return 0; 1639} 1640 1641static int 1642yyerror (char *s) 1643{ 1644 fprintf(stderr, "%s\n" , s); 1645 return 0; 1646} 1647 1648