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