1 /* A Bison parser, made by GNU Bison 2.6.1. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc. 6 7 This program is free software: you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation, either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 /* As a special exception, you may create a larger work that contains 21 part or all of the Bison parser skeleton and distribute that work 22 under terms of your choice, so long as that work isn't itself a 23 parser generator using the skeleton or a modified version thereof 24 as a parser skeleton. Alternatively, if you modify or redistribute 25 the parser skeleton itself, you may (at your option) remove this 26 special exception, which will cause the skeleton and the resulting 27 Bison output files to be licensed under the GNU General Public 28 License without this special exception. 29 30 This special exception was added by the Free Software Foundation in 31 version 2.2 of Bison. */ 32 33 /* C LALR(1) parser skeleton written by Richard Stallman, by 34 simplifying the original so-called "semantic" parser. */ 35 36 /* All symbols defined below should begin with yy or YY, to avoid 37 infringing on user name space. This should be done even for local 38 variables, as they might otherwise be expanded by user macros. 39 There are some unavoidable exceptions within include files to 40 define necessary library symbols; they are noted "INFRINGES ON 41 USER NAME SPACE" below. */ 42 43 /* Identify Bison output. */ 44 #define YYBISON 1 45 46 /* Bison version. */ 47 #define YYBISON_VERSION "2.6.1" 48 49 /* Skeleton name. */ 50 #define YYSKELETON_NAME "yacc.c" 51 52 /* Pure parsers. */ 53 #define YYPURE 0 54 55 /* Push parsers. */ 56 #define YYPUSH 0 57 58 /* Pull parsers. */ 59 #define YYPULL 1 60 61 62 63 64 /* Copy the first part of user declarations. */ 65 /* Line 336 of yacc.c */ 66 #line 38 "util/configparser.y" 67 68 #include "config.h" 69 70 #include <stdarg.h> 71 #include <stdio.h> 72 #include <string.h> 73 #include <stdlib.h> 74 #include <assert.h> 75 76 #include "util/configyyrename.h" 77 #include "util/config_file.h" 78 #include "util/net_help.h" 79 80 int ub_c_lex(void); 81 void ub_c_error(const char *message); 82 83 /* these need to be global, otherwise they cannot be used inside yacc */ 84 extern struct config_parser_state* cfg_parser; 85 86 #if 0 87 #define OUTYY(s) printf s /* used ONLY when debugging */ 88 #else 89 #define OUTYY(s) 90 #endif 91 92 93 /* Line 336 of yacc.c */ 94 #line 95 "util/configparser.c" 95 96 # ifndef YY_NULL 97 # if defined __cplusplus && 201103L <= __cplusplus 98 # define YY_NULL nullptr 99 # else 100 # define YY_NULL 0 101 # endif 102 # endif 103 104 /* Enabling verbose error messages. */ 105 #ifdef YYERROR_VERBOSE 106 # undef YYERROR_VERBOSE 107 # define YYERROR_VERBOSE 1 108 #else 109 # define YYERROR_VERBOSE 0 110 #endif 111 112 /* In a future release of Bison, this section will be replaced 113 by #include "configparser.h". */ 114 #ifndef YY_UTIL_CONFIGPARSER_H 115 # define YY_UTIL_CONFIGPARSER_H 116 /* Enabling traces. */ 117 #ifndef YYDEBUG 118 # define YYDEBUG 0 119 #endif 120 #if YYDEBUG 121 extern int yydebug; 122 #endif 123 124 /* Tokens. */ 125 #ifndef YYTOKENTYPE 126 # define YYTOKENTYPE 127 /* Put the tokens into the symbol table, so that GDB and other debuggers 128 know about them. */ 129 enum yytokentype { 130 SPACE = 258, 131 LETTER = 259, 132 NEWLINE = 260, 133 COMMENT = 261, 134 COLON = 262, 135 ANY = 263, 136 ZONESTR = 264, 137 STRING_ARG = 265, 138 VAR_SERVER = 266, 139 VAR_VERBOSITY = 267, 140 VAR_NUM_THREADS = 268, 141 VAR_PORT = 269, 142 VAR_OUTGOING_RANGE = 270, 143 VAR_INTERFACE = 271, 144 VAR_DO_IP4 = 272, 145 VAR_DO_IP6 = 273, 146 VAR_DO_UDP = 274, 147 VAR_DO_TCP = 275, 148 VAR_CHROOT = 276, 149 VAR_USERNAME = 277, 150 VAR_DIRECTORY = 278, 151 VAR_LOGFILE = 279, 152 VAR_PIDFILE = 280, 153 VAR_MSG_CACHE_SIZE = 281, 154 VAR_MSG_CACHE_SLABS = 282, 155 VAR_NUM_QUERIES_PER_THREAD = 283, 156 VAR_RRSET_CACHE_SIZE = 284, 157 VAR_RRSET_CACHE_SLABS = 285, 158 VAR_OUTGOING_NUM_TCP = 286, 159 VAR_INFRA_HOST_TTL = 287, 160 VAR_INFRA_LAME_TTL = 288, 161 VAR_INFRA_CACHE_SLABS = 289, 162 VAR_INFRA_CACHE_NUMHOSTS = 290, 163 VAR_INFRA_CACHE_LAME_SIZE = 291, 164 VAR_NAME = 292, 165 VAR_STUB_ZONE = 293, 166 VAR_STUB_HOST = 294, 167 VAR_STUB_ADDR = 295, 168 VAR_TARGET_FETCH_POLICY = 296, 169 VAR_HARDEN_SHORT_BUFSIZE = 297, 170 VAR_HARDEN_LARGE_QUERIES = 298, 171 VAR_FORWARD_ZONE = 299, 172 VAR_FORWARD_HOST = 300, 173 VAR_FORWARD_ADDR = 301, 174 VAR_DO_NOT_QUERY_ADDRESS = 302, 175 VAR_HIDE_IDENTITY = 303, 176 VAR_HIDE_VERSION = 304, 177 VAR_IDENTITY = 305, 178 VAR_VERSION = 306, 179 VAR_HARDEN_GLUE = 307, 180 VAR_MODULE_CONF = 308, 181 VAR_TRUST_ANCHOR_FILE = 309, 182 VAR_TRUST_ANCHOR = 310, 183 VAR_VAL_OVERRIDE_DATE = 311, 184 VAR_BOGUS_TTL = 312, 185 VAR_VAL_CLEAN_ADDITIONAL = 313, 186 VAR_VAL_PERMISSIVE_MODE = 314, 187 VAR_INCOMING_NUM_TCP = 315, 188 VAR_MSG_BUFFER_SIZE = 316, 189 VAR_KEY_CACHE_SIZE = 317, 190 VAR_KEY_CACHE_SLABS = 318, 191 VAR_TRUSTED_KEYS_FILE = 319, 192 VAR_VAL_NSEC3_KEYSIZE_ITERATIONS = 320, 193 VAR_USE_SYSLOG = 321, 194 VAR_OUTGOING_INTERFACE = 322, 195 VAR_ROOT_HINTS = 323, 196 VAR_DO_NOT_QUERY_LOCALHOST = 324, 197 VAR_CACHE_MAX_TTL = 325, 198 VAR_HARDEN_DNSSEC_STRIPPED = 326, 199 VAR_ACCESS_CONTROL = 327, 200 VAR_LOCAL_ZONE = 328, 201 VAR_LOCAL_DATA = 329, 202 VAR_INTERFACE_AUTOMATIC = 330, 203 VAR_STATISTICS_INTERVAL = 331, 204 VAR_DO_DAEMONIZE = 332, 205 VAR_USE_CAPS_FOR_ID = 333, 206 VAR_STATISTICS_CUMULATIVE = 334, 207 VAR_OUTGOING_PORT_PERMIT = 335, 208 VAR_OUTGOING_PORT_AVOID = 336, 209 VAR_DLV_ANCHOR_FILE = 337, 210 VAR_DLV_ANCHOR = 338, 211 VAR_NEG_CACHE_SIZE = 339, 212 VAR_HARDEN_REFERRAL_PATH = 340, 213 VAR_PRIVATE_ADDRESS = 341, 214 VAR_PRIVATE_DOMAIN = 342, 215 VAR_REMOTE_CONTROL = 343, 216 VAR_CONTROL_ENABLE = 344, 217 VAR_CONTROL_INTERFACE = 345, 218 VAR_CONTROL_PORT = 346, 219 VAR_SERVER_KEY_FILE = 347, 220 VAR_SERVER_CERT_FILE = 348, 221 VAR_CONTROL_KEY_FILE = 349, 222 VAR_CONTROL_CERT_FILE = 350, 223 VAR_EXTENDED_STATISTICS = 351, 224 VAR_LOCAL_DATA_PTR = 352, 225 VAR_JOSTLE_TIMEOUT = 353, 226 VAR_STUB_PRIME = 354, 227 VAR_UNWANTED_REPLY_THRESHOLD = 355, 228 VAR_LOG_TIME_ASCII = 356, 229 VAR_DOMAIN_INSECURE = 357, 230 VAR_PYTHON = 358, 231 VAR_PYTHON_SCRIPT = 359, 232 VAR_VAL_SIG_SKEW_MIN = 360, 233 VAR_VAL_SIG_SKEW_MAX = 361, 234 VAR_CACHE_MIN_TTL = 362, 235 VAR_VAL_LOG_LEVEL = 363, 236 VAR_AUTO_TRUST_ANCHOR_FILE = 364, 237 VAR_KEEP_MISSING = 365, 238 VAR_ADD_HOLDDOWN = 366, 239 VAR_DEL_HOLDDOWN = 367, 240 VAR_SO_RCVBUF = 368, 241 VAR_EDNS_BUFFER_SIZE = 369, 242 VAR_PREFETCH = 370, 243 VAR_PREFETCH_KEY = 371, 244 VAR_SO_SNDBUF = 372, 245 VAR_HARDEN_BELOW_NXDOMAIN = 373, 246 VAR_IGNORE_CD_FLAG = 374, 247 VAR_LOG_QUERIES = 375, 248 VAR_TCP_UPSTREAM = 376, 249 VAR_SSL_UPSTREAM = 377, 250 VAR_SSL_SERVICE_KEY = 378, 251 VAR_SSL_SERVICE_PEM = 379, 252 VAR_SSL_PORT = 380, 253 VAR_FORWARD_FIRST = 381, 254 VAR_STUB_FIRST = 382, 255 VAR_MINIMAL_RESPONSES = 383, 256 VAR_RRSET_ROUNDROBIN = 384 257 }; 258 #endif 259 /* Tokens. */ 260 #define SPACE 258 261 #define LETTER 259 262 #define NEWLINE 260 263 #define COMMENT 261 264 #define COLON 262 265 #define ANY 263 266 #define ZONESTR 264 267 #define STRING_ARG 265 268 #define VAR_SERVER 266 269 #define VAR_VERBOSITY 267 270 #define VAR_NUM_THREADS 268 271 #define VAR_PORT 269 272 #define VAR_OUTGOING_RANGE 270 273 #define VAR_INTERFACE 271 274 #define VAR_DO_IP4 272 275 #define VAR_DO_IP6 273 276 #define VAR_DO_UDP 274 277 #define VAR_DO_TCP 275 278 #define VAR_CHROOT 276 279 #define VAR_USERNAME 277 280 #define VAR_DIRECTORY 278 281 #define VAR_LOGFILE 279 282 #define VAR_PIDFILE 280 283 #define VAR_MSG_CACHE_SIZE 281 284 #define VAR_MSG_CACHE_SLABS 282 285 #define VAR_NUM_QUERIES_PER_THREAD 283 286 #define VAR_RRSET_CACHE_SIZE 284 287 #define VAR_RRSET_CACHE_SLABS 285 288 #define VAR_OUTGOING_NUM_TCP 286 289 #define VAR_INFRA_HOST_TTL 287 290 #define VAR_INFRA_LAME_TTL 288 291 #define VAR_INFRA_CACHE_SLABS 289 292 #define VAR_INFRA_CACHE_NUMHOSTS 290 293 #define VAR_INFRA_CACHE_LAME_SIZE 291 294 #define VAR_NAME 292 295 #define VAR_STUB_ZONE 293 296 #define VAR_STUB_HOST 294 297 #define VAR_STUB_ADDR 295 298 #define VAR_TARGET_FETCH_POLICY 296 299 #define VAR_HARDEN_SHORT_BUFSIZE 297 300 #define VAR_HARDEN_LARGE_QUERIES 298 301 #define VAR_FORWARD_ZONE 299 302 #define VAR_FORWARD_HOST 300 303 #define VAR_FORWARD_ADDR 301 304 #define VAR_DO_NOT_QUERY_ADDRESS 302 305 #define VAR_HIDE_IDENTITY 303 306 #define VAR_HIDE_VERSION 304 307 #define VAR_IDENTITY 305 308 #define VAR_VERSION 306 309 #define VAR_HARDEN_GLUE 307 310 #define VAR_MODULE_CONF 308 311 #define VAR_TRUST_ANCHOR_FILE 309 312 #define VAR_TRUST_ANCHOR 310 313 #define VAR_VAL_OVERRIDE_DATE 311 314 #define VAR_BOGUS_TTL 312 315 #define VAR_VAL_CLEAN_ADDITIONAL 313 316 #define VAR_VAL_PERMISSIVE_MODE 314 317 #define VAR_INCOMING_NUM_TCP 315 318 #define VAR_MSG_BUFFER_SIZE 316 319 #define VAR_KEY_CACHE_SIZE 317 320 #define VAR_KEY_CACHE_SLABS 318 321 #define VAR_TRUSTED_KEYS_FILE 319 322 #define VAR_VAL_NSEC3_KEYSIZE_ITERATIONS 320 323 #define VAR_USE_SYSLOG 321 324 #define VAR_OUTGOING_INTERFACE 322 325 #define VAR_ROOT_HINTS 323 326 #define VAR_DO_NOT_QUERY_LOCALHOST 324 327 #define VAR_CACHE_MAX_TTL 325 328 #define VAR_HARDEN_DNSSEC_STRIPPED 326 329 #define VAR_ACCESS_CONTROL 327 330 #define VAR_LOCAL_ZONE 328 331 #define VAR_LOCAL_DATA 329 332 #define VAR_INTERFACE_AUTOMATIC 330 333 #define VAR_STATISTICS_INTERVAL 331 334 #define VAR_DO_DAEMONIZE 332 335 #define VAR_USE_CAPS_FOR_ID 333 336 #define VAR_STATISTICS_CUMULATIVE 334 337 #define VAR_OUTGOING_PORT_PERMIT 335 338 #define VAR_OUTGOING_PORT_AVOID 336 339 #define VAR_DLV_ANCHOR_FILE 337 340 #define VAR_DLV_ANCHOR 338 341 #define VAR_NEG_CACHE_SIZE 339 342 #define VAR_HARDEN_REFERRAL_PATH 340 343 #define VAR_PRIVATE_ADDRESS 341 344 #define VAR_PRIVATE_DOMAIN 342 345 #define VAR_REMOTE_CONTROL 343 346 #define VAR_CONTROL_ENABLE 344 347 #define VAR_CONTROL_INTERFACE 345 348 #define VAR_CONTROL_PORT 346 349 #define VAR_SERVER_KEY_FILE 347 350 #define VAR_SERVER_CERT_FILE 348 351 #define VAR_CONTROL_KEY_FILE 349 352 #define VAR_CONTROL_CERT_FILE 350 353 #define VAR_EXTENDED_STATISTICS 351 354 #define VAR_LOCAL_DATA_PTR 352 355 #define VAR_JOSTLE_TIMEOUT 353 356 #define VAR_STUB_PRIME 354 357 #define VAR_UNWANTED_REPLY_THRESHOLD 355 358 #define VAR_LOG_TIME_ASCII 356 359 #define VAR_DOMAIN_INSECURE 357 360 #define VAR_PYTHON 358 361 #define VAR_PYTHON_SCRIPT 359 362 #define VAR_VAL_SIG_SKEW_MIN 360 363 #define VAR_VAL_SIG_SKEW_MAX 361 364 #define VAR_CACHE_MIN_TTL 362 365 #define VAR_VAL_LOG_LEVEL 363 366 #define VAR_AUTO_TRUST_ANCHOR_FILE 364 367 #define VAR_KEEP_MISSING 365 368 #define VAR_ADD_HOLDDOWN 366 369 #define VAR_DEL_HOLDDOWN 367 370 #define VAR_SO_RCVBUF 368 371 #define VAR_EDNS_BUFFER_SIZE 369 372 #define VAR_PREFETCH 370 373 #define VAR_PREFETCH_KEY 371 374 #define VAR_SO_SNDBUF 372 375 #define VAR_HARDEN_BELOW_NXDOMAIN 373 376 #define VAR_IGNORE_CD_FLAG 374 377 #define VAR_LOG_QUERIES 375 378 #define VAR_TCP_UPSTREAM 376 379 #define VAR_SSL_UPSTREAM 377 380 #define VAR_SSL_SERVICE_KEY 378 381 #define VAR_SSL_SERVICE_PEM 379 382 #define VAR_SSL_PORT 380 383 #define VAR_FORWARD_FIRST 381 384 #define VAR_STUB_FIRST 382 385 #define VAR_MINIMAL_RESPONSES 383 386 #define VAR_RRSET_ROUNDROBIN 384 387 388 389 390 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 391 typedef union YYSTYPE 392 { 393 /* Line 350 of yacc.c */ 394 #line 64 "util/configparser.y" 395 396 char* str; 397 398 399 /* Line 350 of yacc.c */ 400 #line 401 "util/configparser.c" 401 } YYSTYPE; 402 # define YYSTYPE_IS_TRIVIAL 1 403 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 404 # define YYSTYPE_IS_DECLARED 1 405 #endif 406 407 extern YYSTYPE yylval; 408 409 #ifdef YYPARSE_PARAM 410 #if defined __STDC__ || defined __cplusplus 411 int yyparse (void *YYPARSE_PARAM); 412 #else 413 int yyparse (); 414 #endif 415 #else /* ! YYPARSE_PARAM */ 416 #if defined __STDC__ || defined __cplusplus 417 int yyparse (void); 418 #else 419 int yyparse (); 420 #endif 421 #endif /* ! YYPARSE_PARAM */ 422 423 #endif /* !YY_UTIL_CONFIGPARSER_H */ 424 425 /* Copy the second part of user declarations. */ 426 427 /* Line 353 of yacc.c */ 428 #line 429 "util/configparser.c" 429 430 #ifdef short 431 # undef short 432 #endif 433 434 #ifdef YYTYPE_UINT8 435 typedef YYTYPE_UINT8 yytype_uint8; 436 #else 437 typedef unsigned char yytype_uint8; 438 #endif 439 440 #ifdef YYTYPE_INT8 441 typedef YYTYPE_INT8 yytype_int8; 442 #elif (defined __STDC__ || defined __C99__FUNC__ \ 443 || defined __cplusplus || defined _MSC_VER) 444 typedef signed char yytype_int8; 445 #else 446 typedef short int yytype_int8; 447 #endif 448 449 #ifdef YYTYPE_UINT16 450 typedef YYTYPE_UINT16 yytype_uint16; 451 #else 452 typedef unsigned short int yytype_uint16; 453 #endif 454 455 #ifdef YYTYPE_INT16 456 typedef YYTYPE_INT16 yytype_int16; 457 #else 458 typedef short int yytype_int16; 459 #endif 460 461 #ifndef YYSIZE_T 462 # ifdef __SIZE_TYPE__ 463 # define YYSIZE_T __SIZE_TYPE__ 464 # elif defined size_t 465 # define YYSIZE_T size_t 466 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 467 || defined __cplusplus || defined _MSC_VER) 468 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 469 # define YYSIZE_T size_t 470 # else 471 # define YYSIZE_T unsigned int 472 # endif 473 #endif 474 475 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 476 477 #ifndef YY_ 478 # if defined YYENABLE_NLS && YYENABLE_NLS 479 # if ENABLE_NLS 480 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 481 # define YY_(msgid) dgettext ("bison-runtime", msgid) 482 # endif 483 # endif 484 # ifndef YY_ 485 # define YY_(msgid) msgid 486 # endif 487 #endif 488 489 /* Suppress unused-variable warnings by "using" E. */ 490 #if ! defined lint || defined __GNUC__ 491 # define YYUSE(e) ((void) (e)) 492 #else 493 # define YYUSE(e) /* empty */ 494 #endif 495 496 /* Identity function, used to suppress warnings about constant conditions. */ 497 #ifndef lint 498 # define YYID(n) (n) 499 #else 500 #if (defined __STDC__ || defined __C99__FUNC__ \ 501 || defined __cplusplus || defined _MSC_VER) 502 static int 503 YYID (int yyi) 504 #else 505 static int 506 YYID (yyi) 507 int yyi; 508 #endif 509 { 510 return yyi; 511 } 512 #endif 513 514 #if ! defined yyoverflow || YYERROR_VERBOSE 515 516 /* The parser invokes alloca or malloc; define the necessary symbols. */ 517 518 # ifdef YYSTACK_USE_ALLOCA 519 # if YYSTACK_USE_ALLOCA 520 # ifdef __GNUC__ 521 # define YYSTACK_ALLOC __builtin_alloca 522 # elif defined __BUILTIN_VA_ARG_INCR 523 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 524 # elif defined _AIX 525 # define YYSTACK_ALLOC __alloca 526 # elif defined _MSC_VER 527 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 528 # define alloca _alloca 529 # else 530 # define YYSTACK_ALLOC alloca 531 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 532 || defined __cplusplus || defined _MSC_VER) 533 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 534 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 535 # ifndef EXIT_SUCCESS 536 # define EXIT_SUCCESS 0 537 # endif 538 # endif 539 # endif 540 # endif 541 # endif 542 543 # ifdef YYSTACK_ALLOC 544 /* Pacify GCC's `empty if-body' warning. */ 545 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 546 # ifndef YYSTACK_ALLOC_MAXIMUM 547 /* The OS might guarantee only one guard page at the bottom of the stack, 548 and a page size can be as small as 4096 bytes. So we cannot safely 549 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 550 to allow for a few compiler-allocated temporary stack slots. */ 551 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 552 # endif 553 # else 554 # define YYSTACK_ALLOC YYMALLOC 555 # define YYSTACK_FREE YYFREE 556 # ifndef YYSTACK_ALLOC_MAXIMUM 557 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 558 # endif 559 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 560 && ! ((defined YYMALLOC || defined malloc) \ 561 && (defined YYFREE || defined free))) 562 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 563 # ifndef EXIT_SUCCESS 564 # define EXIT_SUCCESS 0 565 # endif 566 # endif 567 # ifndef YYMALLOC 568 # define YYMALLOC malloc 569 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 570 || defined __cplusplus || defined _MSC_VER) 571 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 572 # endif 573 # endif 574 # ifndef YYFREE 575 # define YYFREE free 576 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 577 || defined __cplusplus || defined _MSC_VER) 578 void free (void *); /* INFRINGES ON USER NAME SPACE */ 579 # endif 580 # endif 581 # endif 582 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 583 584 585 #if (! defined yyoverflow \ 586 && (! defined __cplusplus \ 587 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 588 589 /* A type that is properly aligned for any stack member. */ 590 union yyalloc 591 { 592 yytype_int16 yyss_alloc; 593 YYSTYPE yyvs_alloc; 594 }; 595 596 /* The size of the maximum gap between one aligned stack and the next. */ 597 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 598 599 /* The size of an array large to enough to hold all stacks, each with 600 N elements. */ 601 # define YYSTACK_BYTES(N) \ 602 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 603 + YYSTACK_GAP_MAXIMUM) 604 605 # define YYCOPY_NEEDED 1 606 607 /* Relocate STACK from its old location to the new one. The 608 local variables YYSIZE and YYSTACKSIZE give the old and new number of 609 elements in the stack, and YYPTR gives the new location of the 610 stack. Advance YYPTR to a properly aligned location for the next 611 stack. */ 612 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 613 do \ 614 { \ 615 YYSIZE_T yynewbytes; \ 616 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 617 Stack = &yyptr->Stack_alloc; \ 618 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 619 yyptr += yynewbytes / sizeof (*yyptr); \ 620 } \ 621 while (YYID (0)) 622 623 #endif 624 625 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 626 /* Copy COUNT objects from SRC to DST. The source and destination do 627 not overlap. */ 628 # ifndef YYCOPY 629 # if defined __GNUC__ && 1 < __GNUC__ 630 # define YYCOPY(Dst, Src, Count) \ 631 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) 632 # else 633 # define YYCOPY(Dst, Src, Count) \ 634 do \ 635 { \ 636 YYSIZE_T yyi; \ 637 for (yyi = 0; yyi < (Count); yyi++) \ 638 (Dst)[yyi] = (Src)[yyi]; \ 639 } \ 640 while (YYID (0)) 641 # endif 642 # endif 643 #endif /* !YYCOPY_NEEDED */ 644 645 /* YYFINAL -- State number of the termination state. */ 646 #define YYFINAL 2 647 /* YYLAST -- Last index in YYTABLE. */ 648 #define YYLAST 237 649 650 /* YYNTOKENS -- Number of terminals. */ 651 #define YYNTOKENS 130 652 /* YYNNTS -- Number of nonterminals. */ 653 #define YYNNTS 133 654 /* YYNRULES -- Number of rules. */ 655 #define YYNRULES 253 656 /* YYNRULES -- Number of states. */ 657 #define YYNSTATES 371 658 659 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 660 #define YYUNDEFTOK 2 661 #define YYMAXUTOK 384 662 663 #define YYTRANSLATE(YYX) \ 664 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 665 666 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 667 static const yytype_uint8 yytranslate[] = 668 { 669 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 670 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 671 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 672 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 673 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 674 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 675 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 676 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 677 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 678 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 679 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 680 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 681 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 682 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 683 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 684 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 685 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 686 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 687 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 688 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 689 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 690 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 691 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 692 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 693 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 694 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 695 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 696 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 697 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 698 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 699 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 700 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 701 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 702 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 703 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 704 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 705 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 706 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 707 125, 126, 127, 128, 129 708 }; 709 710 #if YYDEBUG 711 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 712 YYRHS. */ 713 static const yytype_uint16 yyprhs[] = 714 { 715 0, 0, 3, 4, 7, 10, 13, 16, 19, 22, 716 24, 27, 28, 30, 32, 34, 36, 38, 40, 42, 717 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 718 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 719 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 720 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 721 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 722 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 723 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 724 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 725 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 726 224, 226, 229, 230, 232, 234, 236, 238, 240, 242, 727 245, 246, 248, 250, 252, 254, 257, 260, 263, 266, 728 269, 272, 275, 278, 281, 284, 287, 290, 293, 296, 729 299, 302, 305, 308, 311, 314, 317, 320, 323, 326, 730 329, 332, 335, 338, 341, 344, 347, 350, 353, 356, 731 359, 362, 365, 368, 371, 374, 377, 380, 383, 386, 732 389, 392, 395, 398, 401, 404, 407, 410, 413, 416, 733 419, 422, 425, 428, 431, 434, 437, 440, 443, 446, 734 449, 452, 455, 458, 461, 464, 467, 470, 473, 476, 735 480, 483, 486, 489, 492, 495, 498, 501, 504, 507, 736 510, 513, 516, 519, 522, 525, 528, 531, 534, 538, 737 541, 544, 547, 550, 553, 556, 559, 562, 565, 568, 738 571, 574, 577, 579, 582, 583, 585, 587, 589, 591, 739 593, 595, 597, 600, 603, 606, 609, 612, 615, 618, 740 620, 623, 624, 626 741 }; 742 743 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 744 static const yytype_int16 yyrhs[] = 745 { 746 131, 0, -1, -1, 131, 132, -1, 133, 134, -1, 747 136, 137, -1, 139, 140, -1, 259, 260, -1, 249, 748 250, -1, 11, -1, 134, 135, -1, -1, 142, -1, 749 143, -1, 147, -1, 150, -1, 156, -1, 157, -1, 750 158, -1, 159, -1, 148, -1, 169, -1, 170, -1, 751 171, -1, 172, -1, 173, -1, 190, -1, 191, -1, 752 192, -1, 194, -1, 195, -1, 153, -1, 196, -1, 753 197, -1, 200, -1, 198, -1, 199, -1, 201, -1, 754 202, -1, 203, -1, 214, -1, 182, -1, 183, -1, 755 184, -1, 185, -1, 204, -1, 217, -1, 178, -1, 756 180, -1, 218, -1, 223, -1, 224, -1, 225, -1, 757 154, -1, 189, -1, 232, -1, 233, -1, 179, -1, 758 228, -1, 166, -1, 149, -1, 174, -1, 215, -1, 759 221, -1, 205, -1, 216, -1, 235, -1, 236, -1, 760 155, -1, 144, -1, 165, -1, 208, -1, 145, -1, 761 151, -1, 152, -1, 175, -1, 176, -1, 234, -1, 762 207, -1, 209, -1, 210, -1, 146, -1, 237, -1, 763 193, -1, 213, -1, 167, -1, 181, -1, 219, -1, 764 220, -1, 222, -1, 227, -1, 177, -1, 229, -1, 765 230, -1, 231, -1, 186, -1, 188, -1, 211, -1, 766 212, -1, 187, -1, 206, -1, 226, -1, 168, -1, 767 160, -1, 161, -1, 162, -1, 163, -1, 164, -1, 768 238, -1, 239, -1, 38, -1, 137, 138, -1, -1, 769 240, -1, 241, -1, 242, -1, 244, -1, 243, -1, 770 44, -1, 140, 141, -1, -1, 245, -1, 246, -1, 771 247, -1, 248, -1, 13, 10, -1, 12, 10, -1, 772 76, 10, -1, 79, 10, -1, 96, 10, -1, 14, 773 10, -1, 16, 10, -1, 67, 10, -1, 15, 10, 774 -1, 80, 10, -1, 81, 10, -1, 31, 10, -1, 775 60, 10, -1, 75, 10, -1, 17, 10, -1, 18, 776 10, -1, 19, 10, -1, 20, 10, -1, 121, 10, 777 -1, 122, 10, -1, 123, 10, -1, 124, 10, -1, 778 125, 10, -1, 77, 10, -1, 66, 10, -1, 101, 779 10, -1, 120, 10, -1, 21, 10, -1, 22, 10, 780 -1, 23, 10, -1, 24, 10, -1, 25, 10, -1, 781 68, 10, -1, 82, 10, -1, 83, 10, -1, 109, 782 10, -1, 54, 10, -1, 64, 10, -1, 55, 10, 783 -1, 102, 10, -1, 48, 10, -1, 49, 10, -1, 784 50, 10, -1, 51, 10, -1, 113, 10, -1, 117, 785 10, -1, 114, 10, -1, 61, 10, -1, 26, 10, 786 -1, 27, 10, -1, 28, 10, -1, 98, 10, -1, 787 29, 10, -1, 30, 10, -1, 32, 10, -1, 33, 788 10, -1, 35, 10, -1, 36, 10, -1, 34, 10, 789 -1, 41, 10, -1, 42, 10, -1, 43, 10, -1, 790 52, 10, -1, 71, 10, -1, 118, 10, -1, 85, 791 10, -1, 78, 10, -1, 86, 10, -1, 87, 10, 792 -1, 115, 10, -1, 116, 10, -1, 100, 10, -1, 793 47, 10, -1, 69, 10, -1, 72, 10, 10, -1, 794 53, 10, -1, 56, 10, -1, 105, 10, -1, 106, 795 10, -1, 70, 10, -1, 107, 10, -1, 57, 10, 796 -1, 58, 10, -1, 59, 10, -1, 119, 10, -1, 797 108, 10, -1, 65, 10, -1, 111, 10, -1, 112, 798 10, -1, 110, 10, -1, 62, 10, -1, 63, 10, 799 -1, 84, 10, -1, 73, 10, 10, -1, 74, 10, 800 -1, 97, 10, -1, 128, 10, -1, 129, 10, -1, 801 37, 10, -1, 39, 10, -1, 40, 10, -1, 127, 802 10, -1, 99, 10, -1, 37, 10, -1, 45, 10, 803 -1, 46, 10, -1, 126, 10, -1, 88, -1, 250, 804 251, -1, -1, 252, -1, 254, -1, 253, -1, 255, 805 -1, 256, -1, 257, -1, 258, -1, 89, 10, -1, 806 91, 10, -1, 90, 10, -1, 92, 10, -1, 93, 807 10, -1, 94, 10, -1, 95, 10, -1, 103, -1, 808 260, 261, -1, -1, 262, -1, 104, 10, -1 809 }; 810 811 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 812 static const yytype_uint16 yyrline[] = 813 { 814 0, 110, 110, 110, 111, 111, 112, 112, 113, 117, 815 122, 123, 124, 124, 124, 125, 125, 126, 126, 126, 816 127, 127, 127, 128, 128, 128, 129, 129, 130, 130, 817 131, 131, 132, 132, 133, 133, 134, 134, 135, 135, 818 136, 136, 137, 137, 137, 138, 138, 138, 139, 139, 819 139, 140, 140, 141, 141, 142, 142, 143, 143, 144, 820 144, 144, 145, 145, 146, 146, 147, 147, 147, 148, 821 148, 149, 149, 150, 150, 151, 151, 151, 152, 152, 822 153, 153, 154, 154, 155, 155, 156, 156, 157, 157, 823 157, 158, 158, 159, 159, 159, 160, 160, 160, 161, 824 161, 161, 162, 162, 162, 163, 163, 163, 164, 164, 825 166, 178, 179, 180, 180, 180, 180, 180, 182, 194, 826 195, 196, 196, 196, 196, 198, 207, 216, 227, 236, 827 245, 254, 267, 282, 291, 300, 309, 318, 327, 336, 828 345, 354, 363, 372, 381, 390, 397, 404, 413, 422, 829 436, 445, 454, 461, 468, 475, 483, 490, 497, 504, 830 511, 519, 527, 535, 542, 549, 558, 567, 574, 581, 831 589, 597, 610, 621, 629, 642, 651, 660, 668, 681, 832 690, 698, 707, 715, 728, 735, 745, 755, 765, 775, 833 785, 795, 805, 812, 819, 828, 837, 846, 853, 863, 834 877, 884, 902, 915, 928, 937, 946, 955, 965, 975, 835 984, 993, 1000, 1009, 1018, 1027, 1035, 1048, 1056, 1078, 836 1085, 1100, 1110, 1120, 1130, 1137, 1144, 1153, 1163, 1173, 837 1180, 1187, 1196, 1201, 1202, 1203, 1203, 1203, 1204, 1204, 838 1204, 1205, 1207, 1217, 1226, 1233, 1240, 1247, 1254, 1261, 839 1266, 1267, 1268, 1270 840 }; 841 #endif 842 843 #if YYDEBUG || YYERROR_VERBOSE || 0 844 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 845 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 846 static const char *const yytname[] = 847 { 848 "$end", "error", "$undefined", "SPACE", "LETTER", "NEWLINE", "COMMENT", 849 "COLON", "ANY", "ZONESTR", "STRING_ARG", "VAR_SERVER", "VAR_VERBOSITY", 850 "VAR_NUM_THREADS", "VAR_PORT", "VAR_OUTGOING_RANGE", "VAR_INTERFACE", 851 "VAR_DO_IP4", "VAR_DO_IP6", "VAR_DO_UDP", "VAR_DO_TCP", "VAR_CHROOT", 852 "VAR_USERNAME", "VAR_DIRECTORY", "VAR_LOGFILE", "VAR_PIDFILE", 853 "VAR_MSG_CACHE_SIZE", "VAR_MSG_CACHE_SLABS", 854 "VAR_NUM_QUERIES_PER_THREAD", "VAR_RRSET_CACHE_SIZE", 855 "VAR_RRSET_CACHE_SLABS", "VAR_OUTGOING_NUM_TCP", "VAR_INFRA_HOST_TTL", 856 "VAR_INFRA_LAME_TTL", "VAR_INFRA_CACHE_SLABS", 857 "VAR_INFRA_CACHE_NUMHOSTS", "VAR_INFRA_CACHE_LAME_SIZE", "VAR_NAME", 858 "VAR_STUB_ZONE", "VAR_STUB_HOST", "VAR_STUB_ADDR", 859 "VAR_TARGET_FETCH_POLICY", "VAR_HARDEN_SHORT_BUFSIZE", 860 "VAR_HARDEN_LARGE_QUERIES", "VAR_FORWARD_ZONE", "VAR_FORWARD_HOST", 861 "VAR_FORWARD_ADDR", "VAR_DO_NOT_QUERY_ADDRESS", "VAR_HIDE_IDENTITY", 862 "VAR_HIDE_VERSION", "VAR_IDENTITY", "VAR_VERSION", "VAR_HARDEN_GLUE", 863 "VAR_MODULE_CONF", "VAR_TRUST_ANCHOR_FILE", "VAR_TRUST_ANCHOR", 864 "VAR_VAL_OVERRIDE_DATE", "VAR_BOGUS_TTL", "VAR_VAL_CLEAN_ADDITIONAL", 865 "VAR_VAL_PERMISSIVE_MODE", "VAR_INCOMING_NUM_TCP", "VAR_MSG_BUFFER_SIZE", 866 "VAR_KEY_CACHE_SIZE", "VAR_KEY_CACHE_SLABS", "VAR_TRUSTED_KEYS_FILE", 867 "VAR_VAL_NSEC3_KEYSIZE_ITERATIONS", "VAR_USE_SYSLOG", 868 "VAR_OUTGOING_INTERFACE", "VAR_ROOT_HINTS", "VAR_DO_NOT_QUERY_LOCALHOST", 869 "VAR_CACHE_MAX_TTL", "VAR_HARDEN_DNSSEC_STRIPPED", "VAR_ACCESS_CONTROL", 870 "VAR_LOCAL_ZONE", "VAR_LOCAL_DATA", "VAR_INTERFACE_AUTOMATIC", 871 "VAR_STATISTICS_INTERVAL", "VAR_DO_DAEMONIZE", "VAR_USE_CAPS_FOR_ID", 872 "VAR_STATISTICS_CUMULATIVE", "VAR_OUTGOING_PORT_PERMIT", 873 "VAR_OUTGOING_PORT_AVOID", "VAR_DLV_ANCHOR_FILE", "VAR_DLV_ANCHOR", 874 "VAR_NEG_CACHE_SIZE", "VAR_HARDEN_REFERRAL_PATH", "VAR_PRIVATE_ADDRESS", 875 "VAR_PRIVATE_DOMAIN", "VAR_REMOTE_CONTROL", "VAR_CONTROL_ENABLE", 876 "VAR_CONTROL_INTERFACE", "VAR_CONTROL_PORT", "VAR_SERVER_KEY_FILE", 877 "VAR_SERVER_CERT_FILE", "VAR_CONTROL_KEY_FILE", "VAR_CONTROL_CERT_FILE", 878 "VAR_EXTENDED_STATISTICS", "VAR_LOCAL_DATA_PTR", "VAR_JOSTLE_TIMEOUT", 879 "VAR_STUB_PRIME", "VAR_UNWANTED_REPLY_THRESHOLD", "VAR_LOG_TIME_ASCII", 880 "VAR_DOMAIN_INSECURE", "VAR_PYTHON", "VAR_PYTHON_SCRIPT", 881 "VAR_VAL_SIG_SKEW_MIN", "VAR_VAL_SIG_SKEW_MAX", "VAR_CACHE_MIN_TTL", 882 "VAR_VAL_LOG_LEVEL", "VAR_AUTO_TRUST_ANCHOR_FILE", "VAR_KEEP_MISSING", 883 "VAR_ADD_HOLDDOWN", "VAR_DEL_HOLDDOWN", "VAR_SO_RCVBUF", 884 "VAR_EDNS_BUFFER_SIZE", "VAR_PREFETCH", "VAR_PREFETCH_KEY", 885 "VAR_SO_SNDBUF", "VAR_HARDEN_BELOW_NXDOMAIN", "VAR_IGNORE_CD_FLAG", 886 "VAR_LOG_QUERIES", "VAR_TCP_UPSTREAM", "VAR_SSL_UPSTREAM", 887 "VAR_SSL_SERVICE_KEY", "VAR_SSL_SERVICE_PEM", "VAR_SSL_PORT", 888 "VAR_FORWARD_FIRST", "VAR_STUB_FIRST", "VAR_MINIMAL_RESPONSES", 889 "VAR_RRSET_ROUNDROBIN", "$accept", "toplevelvars", "toplevelvar", 890 "serverstart", "contents_server", "content_server", "stubstart", 891 "contents_stub", "content_stub", "forwardstart", "contents_forward", 892 "content_forward", "server_num_threads", "server_verbosity", 893 "server_statistics_interval", "server_statistics_cumulative", 894 "server_extended_statistics", "server_port", "server_interface", 895 "server_outgoing_interface", "server_outgoing_range", 896 "server_outgoing_port_permit", "server_outgoing_port_avoid", 897 "server_outgoing_num_tcp", "server_incoming_num_tcp", 898 "server_interface_automatic", "server_do_ip4", "server_do_ip6", 899 "server_do_udp", "server_do_tcp", "server_tcp_upstream", 900 "server_ssl_upstream", "server_ssl_service_key", 901 "server_ssl_service_pem", "server_ssl_port", "server_do_daemonize", 902 "server_use_syslog", "server_log_time_ascii", "server_log_queries", 903 "server_chroot", "server_username", "server_directory", "server_logfile", 904 "server_pidfile", "server_root_hints", "server_dlv_anchor_file", 905 "server_dlv_anchor", "server_auto_trust_anchor_file", 906 "server_trust_anchor_file", "server_trusted_keys_file", 907 "server_trust_anchor", "server_domain_insecure", "server_hide_identity", 908 "server_hide_version", "server_identity", "server_version", 909 "server_so_rcvbuf", "server_so_sndbuf", "server_edns_buffer_size", 910 "server_msg_buffer_size", "server_msg_cache_size", 911 "server_msg_cache_slabs", "server_num_queries_per_thread", 912 "server_jostle_timeout", "server_rrset_cache_size", 913 "server_rrset_cache_slabs", "server_infra_host_ttl", 914 "server_infra_lame_ttl", "server_infra_cache_numhosts", 915 "server_infra_cache_lame_size", "server_infra_cache_slabs", 916 "server_target_fetch_policy", "server_harden_short_bufsize", 917 "server_harden_large_queries", "server_harden_glue", 918 "server_harden_dnssec_stripped", "server_harden_below_nxdomain", 919 "server_harden_referral_path", "server_use_caps_for_id", 920 "server_private_address", "server_private_domain", "server_prefetch", 921 "server_prefetch_key", "server_unwanted_reply_threshold", 922 "server_do_not_query_address", "server_do_not_query_localhost", 923 "server_access_control", "server_module_conf", 924 "server_val_override_date", "server_val_sig_skew_min", 925 "server_val_sig_skew_max", "server_cache_max_ttl", 926 "server_cache_min_ttl", "server_bogus_ttl", 927 "server_val_clean_additional", "server_val_permissive_mode", 928 "server_ignore_cd_flag", "server_val_log_level", 929 "server_val_nsec3_keysize_iterations", "server_add_holddown", 930 "server_del_holddown", "server_keep_missing", "server_key_cache_size", 931 "server_key_cache_slabs", "server_neg_cache_size", "server_local_zone", 932 "server_local_data", "server_local_data_ptr", "server_minimal_responses", 933 "server_rrset_roundrobin", "stub_name", "stub_host", "stub_addr", 934 "stub_first", "stub_prime", "forward_name", "forward_host", 935 "forward_addr", "forward_first", "rcstart", "contents_rc", "content_rc", 936 "rc_control_enable", "rc_control_port", "rc_control_interface", 937 "rc_server_key_file", "rc_server_cert_file", "rc_control_key_file", 938 "rc_control_cert_file", "pythonstart", "contents_py", "content_py", 939 "py_script", YY_NULL 940 }; 941 #endif 942 943 # ifdef YYPRINT 944 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 945 token YYLEX-NUM. */ 946 static const yytype_uint16 yytoknum[] = 947 { 948 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 949 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 950 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 951 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 952 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 953 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 954 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 955 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 956 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 957 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 958 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 959 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 960 375, 376, 377, 378, 379, 380, 381, 382, 383, 384 961 }; 962 # endif 963 964 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 965 static const yytype_uint16 yyr1[] = 966 { 967 0, 130, 131, 131, 132, 132, 132, 132, 132, 133, 968 134, 134, 135, 135, 135, 135, 135, 135, 135, 135, 969 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 970 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 971 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 972 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 973 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 974 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 975 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 976 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 977 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 978 136, 137, 137, 138, 138, 138, 138, 138, 139, 140, 979 140, 141, 141, 141, 141, 142, 143, 144, 145, 146, 980 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 981 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 982 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 983 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 984 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 985 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 986 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 987 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 988 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 989 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 990 247, 248, 249, 250, 250, 251, 251, 251, 251, 251, 991 251, 251, 252, 253, 254, 255, 256, 257, 258, 259, 992 260, 260, 261, 262 993 }; 994 995 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 996 static const yytype_uint8 yyr2[] = 997 { 998 0, 2, 0, 2, 2, 2, 2, 2, 2, 1, 999 2, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1000 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1001 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1002 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1003 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1004 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1005 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1006 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1007 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1008 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1009 1, 2, 0, 1, 1, 1, 1, 1, 1, 2, 1010 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 1011 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1012 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1013 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1014 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1015 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1016 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1017 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1018 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1019 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1020 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1021 2, 2, 1, 2, 0, 1, 1, 1, 1, 1, 1022 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1023 2, 0, 1, 2 1024 }; 1025 1026 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 1027 Performed when YYTABLE doesn't specify something else to do. Zero 1028 means the default is an error. */ 1029 static const yytype_uint8 yydefact[] = 1030 { 1031 2, 0, 1, 9, 110, 118, 232, 249, 3, 11, 1032 112, 120, 234, 251, 4, 5, 6, 8, 7, 0, 1033 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1034 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1035 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1036 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1037 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1038 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1039 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1040 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1041 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1042 0, 0, 0, 0, 0, 0, 0, 10, 12, 13, 1043 69, 72, 81, 14, 20, 60, 15, 73, 74, 31, 1044 53, 68, 16, 17, 18, 19, 103, 104, 105, 106, 1045 107, 70, 59, 85, 102, 21, 22, 23, 24, 25, 1046 61, 75, 76, 91, 47, 57, 48, 86, 41, 42, 1047 43, 44, 95, 99, 96, 54, 26, 27, 28, 83, 1048 29, 30, 32, 33, 35, 36, 34, 37, 38, 39, 1049 45, 64, 100, 78, 71, 79, 80, 97, 98, 84, 1050 40, 62, 65, 46, 49, 87, 88, 63, 89, 50, 1051 51, 52, 101, 90, 58, 92, 93, 94, 55, 56, 1052 77, 66, 67, 82, 108, 109, 0, 0, 0, 0, 1053 0, 111, 113, 114, 115, 117, 116, 0, 0, 0, 1054 0, 119, 121, 122, 123, 124, 0, 0, 0, 0, 1055 0, 0, 0, 233, 235, 237, 236, 238, 239, 240, 1056 241, 0, 250, 252, 126, 125, 130, 133, 131, 139, 1057 140, 141, 142, 152, 153, 154, 155, 156, 173, 174, 1058 175, 177, 178, 136, 179, 180, 183, 181, 182, 184, 1059 185, 186, 197, 165, 166, 167, 168, 187, 200, 161, 1060 163, 201, 206, 207, 208, 137, 172, 215, 216, 162, 1061 211, 149, 132, 157, 198, 204, 188, 0, 0, 219, 1062 138, 127, 148, 191, 128, 134, 135, 158, 159, 217, 1063 190, 192, 193, 129, 220, 176, 196, 150, 164, 202, 1064 203, 205, 210, 160, 214, 212, 213, 169, 171, 194, 1065 195, 170, 189, 209, 151, 143, 144, 145, 146, 147, 1066 221, 222, 223, 224, 225, 227, 226, 228, 229, 230, 1067 231, 242, 244, 243, 245, 246, 247, 248, 253, 199, 1068 218 1069 }; 1070 1071 /* YYDEFGOTO[NTERM-NUM]. */ 1072 static const yytype_int16 yydefgoto[] = 1073 { 1074 -1, 1, 8, 9, 14, 117, 10, 15, 221, 11, 1075 16, 231, 118, 119, 120, 121, 122, 123, 124, 125, 1076 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 1077 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 1078 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 1079 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 1080 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 1081 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1082 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 1083 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 1084 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 1085 222, 223, 224, 225, 226, 232, 233, 234, 235, 12, 1086 17, 243, 244, 245, 246, 247, 248, 249, 250, 13, 1087 18, 252, 253 1088 }; 1089 1090 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1091 STATE-NUM. */ 1092 #define YYPACT_NINF -80 1093 static const yytype_int16 yypact[] = 1094 { 1095 -80, 76, -80, -80, -80, -80, -80, -80, -80, -80, 1096 -80, -80, -80, -80, -12, 40, 46, 32, -79, 16, 1097 17, 18, 22, 23, 24, 68, 71, 72, 105, 108, 1098 109, 118, 119, 120, 121, 122, 123, 124, 125, 126, 1099 127, 128, 130, 131, 132, 133, 134, 135, 136, 137, 1100 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 1101 148, 149, 150, 151, 152, 153, 155, 156, 158, 159, 1102 160, 161, 163, 164, 165, 166, 167, 168, 170, 171, 1103 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 1104 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 1105 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 1106 202, 203, 204, 205, 206, 207, 208, -80, -80, -80, 1107 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1108 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1109 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1110 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1111 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1112 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1113 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1114 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1115 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1116 -80, -80, -80, -80, -80, -80, 209, 210, 211, 212, 1117 213, -80, -80, -80, -80, -80, -80, 214, 215, 216, 1118 217, -80, -80, -80, -80, -80, 218, 219, 220, 221, 1119 222, 223, 224, -80, -80, -80, -80, -80, -80, -80, 1120 -80, 225, -80, -80, -80, -80, -80, -80, -80, -80, 1121 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1122 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1123 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1124 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1125 -80, -80, -80, -80, -80, -80, -80, 226, 227, -80, 1126 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1127 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1128 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1129 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1130 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1131 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1132 -80 1133 }; 1134 1135 /* YYPGOTO[NTERM-NUM]. */ 1136 static const yytype_int8 yypgoto[] = 1137 { 1138 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1139 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1140 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1141 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1142 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1143 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1144 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1145 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1146 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1147 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1148 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1149 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1150 -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 1151 -80, -80, -80 1152 }; 1153 1154 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 1155 positive, shift that token. If negative, reduce the rule which 1156 number is the opposite. If YYTABLE_NINF, syntax error. */ 1157 #define YYTABLE_NINF -1 1158 static const yytype_uint16 yytable[] = 1159 { 1160 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 1161 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 1162 39, 40, 41, 42, 43, 251, 254, 255, 256, 44, 1163 45, 46, 257, 258, 259, 47, 48, 49, 50, 51, 1164 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 1165 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 1166 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 1167 82, 83, 84, 85, 86, 87, 2, 216, 260, 217, 1168 218, 261, 262, 227, 88, 89, 90, 3, 91, 92, 1169 93, 228, 229, 94, 95, 96, 97, 98, 99, 100, 1170 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 1171 111, 112, 113, 114, 4, 263, 115, 116, 264, 265, 1172 5, 236, 237, 238, 239, 240, 241, 242, 266, 267, 1173 268, 269, 270, 271, 272, 273, 274, 275, 276, 219, 1174 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 1175 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 1176 297, 298, 299, 300, 6, 301, 302, 220, 303, 304, 1177 305, 306, 230, 307, 308, 309, 310, 311, 312, 7, 1178 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 1179 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 1180 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 1181 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 1182 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 1183 363, 364, 365, 366, 367, 368, 369, 370 1184 }; 1185 1186 #define yypact_value_is_default(yystate) \ 1187 ((yystate) == (-80)) 1188 1189 #define yytable_value_is_error(yytable_value) \ 1190 YYID (0) 1191 1192 static const yytype_uint8 yycheck[] = 1193 { 1194 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 1195 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1196 32, 33, 34, 35, 36, 104, 10, 10, 10, 41, 1197 42, 43, 10, 10, 10, 47, 48, 49, 50, 51, 1198 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 1199 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 1200 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 1201 82, 83, 84, 85, 86, 87, 0, 37, 10, 39, 1202 40, 10, 10, 37, 96, 97, 98, 11, 100, 101, 1203 102, 45, 46, 105, 106, 107, 108, 109, 110, 111, 1204 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 1205 122, 123, 124, 125, 38, 10, 128, 129, 10, 10, 1206 44, 89, 90, 91, 92, 93, 94, 95, 10, 10, 1207 10, 10, 10, 10, 10, 10, 10, 10, 10, 99, 1208 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1209 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1210 10, 10, 10, 10, 88, 10, 10, 127, 10, 10, 1211 10, 10, 126, 10, 10, 10, 10, 10, 10, 103, 1212 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1213 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1214 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1215 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1216 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1217 10, 10, 10, 10, 10, 10, 10, 10 1218 }; 1219 1220 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1221 symbol of state STATE-NUM. */ 1222 static const yytype_uint16 yystos[] = 1223 { 1224 0, 131, 0, 11, 38, 44, 88, 103, 132, 133, 1225 136, 139, 249, 259, 134, 137, 140, 250, 260, 12, 1226 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 1227 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 1228 33, 34, 35, 36, 41, 42, 43, 47, 48, 49, 1229 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 1230 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 1231 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 1232 80, 81, 82, 83, 84, 85, 86, 87, 96, 97, 1233 98, 100, 101, 102, 105, 106, 107, 108, 109, 110, 1234 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 1235 121, 122, 123, 124, 125, 128, 129, 135, 142, 143, 1236 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 1237 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 1238 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 1239 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 1240 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 1241 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 1242 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 1243 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 1244 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 1245 234, 235, 236, 237, 238, 239, 37, 39, 40, 99, 1246 127, 138, 240, 241, 242, 243, 244, 37, 45, 46, 1247 126, 141, 245, 246, 247, 248, 89, 90, 91, 92, 1248 93, 94, 95, 251, 252, 253, 254, 255, 256, 257, 1249 258, 104, 261, 262, 10, 10, 10, 10, 10, 10, 1250 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1251 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1252 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1253 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1254 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1255 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1256 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1257 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1258 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1259 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1260 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1261 10 1262 }; 1263 1264 #define yyerrok (yyerrstatus = 0) 1265 #define yyclearin (yychar = YYEMPTY) 1266 #define YYEMPTY (-2) 1267 #define YYEOF 0 1268 1269 #define YYACCEPT goto yyacceptlab 1270 #define YYABORT goto yyabortlab 1271 #define YYERROR goto yyerrorlab 1272 1273 1274 /* Like YYERROR except do call yyerror. This remains here temporarily 1275 to ease the transition to the new meaning of YYERROR, for GCC. 1276 Once GCC version 2 has supplanted version 1, this can go. However, 1277 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 1278 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 1279 discussed. */ 1280 1281 #define YYFAIL goto yyerrlab 1282 #if defined YYFAIL 1283 /* This is here to suppress warnings from the GCC cpp's 1284 -Wunused-macros. Normally we don't worry about that warning, but 1285 some users do, and we want to make it easy for users to remove 1286 YYFAIL uses, which will produce warnings from Bison 2.5. */ 1287 #endif 1288 1289 #define YYRECOVERING() (!!yyerrstatus) 1290 1291 #define YYBACKUP(Token, Value) \ 1292 do \ 1293 if (yychar == YYEMPTY) \ 1294 { \ 1295 yychar = (Token); \ 1296 yylval = (Value); \ 1297 YYPOPSTACK (yylen); \ 1298 yystate = *yyssp; \ 1299 goto yybackup; \ 1300 } \ 1301 else \ 1302 { \ 1303 yyerror (YY_("syntax error: cannot back up")); \ 1304 YYERROR; \ 1305 } \ 1306 while (YYID (0)) 1307 1308 1309 #define YYTERROR 1 1310 #define YYERRCODE 256 1311 1312 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1313 If N is 0, then set CURRENT to the empty location which ends 1314 the previous symbol: RHS[0] (always defined). */ 1315 1316 #ifndef YYLLOC_DEFAULT 1317 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 1318 do \ 1319 if (YYID (N)) \ 1320 { \ 1321 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1322 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1323 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1324 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1325 } \ 1326 else \ 1327 { \ 1328 (Current).first_line = (Current).last_line = \ 1329 YYRHSLOC (Rhs, 0).last_line; \ 1330 (Current).first_column = (Current).last_column = \ 1331 YYRHSLOC (Rhs, 0).last_column; \ 1332 } \ 1333 while (YYID (0)) 1334 #endif 1335 1336 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1337 1338 1339 1340 /* This macro is provided for backward compatibility. */ 1341 1342 #ifndef YY_LOCATION_PRINT 1343 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1344 #endif 1345 1346 1347 /* YYLEX -- calling `yylex' with the right arguments. */ 1348 1349 #ifdef YYLEX_PARAM 1350 # define YYLEX yylex (YYLEX_PARAM) 1351 #else 1352 # define YYLEX yylex () 1353 #endif 1354 1355 /* Enable debugging if requested. */ 1356 #if YYDEBUG 1357 1358 # ifndef YYFPRINTF 1359 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1360 # define YYFPRINTF fprintf 1361 # endif 1362 1363 # define YYDPRINTF(Args) \ 1364 do { \ 1365 if (yydebug) \ 1366 YYFPRINTF Args; \ 1367 } while (YYID (0)) 1368 1369 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1370 do { \ 1371 if (yydebug) \ 1372 { \ 1373 YYFPRINTF (stderr, "%s ", Title); \ 1374 yy_symbol_print (stderr, \ 1375 Type, Value); \ 1376 YYFPRINTF (stderr, "\n"); \ 1377 } \ 1378 } while (YYID (0)) 1379 1380 1381 /*--------------------------------. 1382 | Print this symbol on YYOUTPUT. | 1383 `--------------------------------*/ 1384 1385 /*ARGSUSED*/ 1386 #if (defined __STDC__ || defined __C99__FUNC__ \ 1387 || defined __cplusplus || defined _MSC_VER) 1388 static void 1389 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1390 #else 1391 static void 1392 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 1393 FILE *yyoutput; 1394 int yytype; 1395 YYSTYPE const * const yyvaluep; 1396 #endif 1397 { 1398 FILE *yyo = yyoutput; 1399 YYUSE (yyo); 1400 if (!yyvaluep) 1401 return; 1402 # ifdef YYPRINT 1403 if (yytype < YYNTOKENS) 1404 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1405 # else 1406 YYUSE (yyoutput); 1407 # endif 1408 switch (yytype) 1409 { 1410 default: 1411 break; 1412 } 1413 } 1414 1415 1416 /*--------------------------------. 1417 | Print this symbol on YYOUTPUT. | 1418 `--------------------------------*/ 1419 1420 #if (defined __STDC__ || defined __C99__FUNC__ \ 1421 || defined __cplusplus || defined _MSC_VER) 1422 static void 1423 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1424 #else 1425 static void 1426 yy_symbol_print (yyoutput, yytype, yyvaluep) 1427 FILE *yyoutput; 1428 int yytype; 1429 YYSTYPE const * const yyvaluep; 1430 #endif 1431 { 1432 if (yytype < YYNTOKENS) 1433 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1434 else 1435 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1436 1437 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 1438 YYFPRINTF (yyoutput, ")"); 1439 } 1440 1441 /*------------------------------------------------------------------. 1442 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1443 | TOP (included). | 1444 `------------------------------------------------------------------*/ 1445 1446 #if (defined __STDC__ || defined __C99__FUNC__ \ 1447 || defined __cplusplus || defined _MSC_VER) 1448 static void 1449 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 1450 #else 1451 static void 1452 yy_stack_print (yybottom, yytop) 1453 yytype_int16 *yybottom; 1454 yytype_int16 *yytop; 1455 #endif 1456 { 1457 YYFPRINTF (stderr, "Stack now"); 1458 for (; yybottom <= yytop; yybottom++) 1459 { 1460 int yybot = *yybottom; 1461 YYFPRINTF (stderr, " %d", yybot); 1462 } 1463 YYFPRINTF (stderr, "\n"); 1464 } 1465 1466 # define YY_STACK_PRINT(Bottom, Top) \ 1467 do { \ 1468 if (yydebug) \ 1469 yy_stack_print ((Bottom), (Top)); \ 1470 } while (YYID (0)) 1471 1472 1473 /*------------------------------------------------. 1474 | Report that the YYRULE is going to be reduced. | 1475 `------------------------------------------------*/ 1476 1477 #if (defined __STDC__ || defined __C99__FUNC__ \ 1478 || defined __cplusplus || defined _MSC_VER) 1479 static void 1480 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1481 #else 1482 static void 1483 yy_reduce_print (yyvsp, yyrule) 1484 YYSTYPE *yyvsp; 1485 int yyrule; 1486 #endif 1487 { 1488 int yynrhs = yyr2[yyrule]; 1489 int yyi; 1490 unsigned long int yylno = yyrline[yyrule]; 1491 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1492 yyrule - 1, yylno); 1493 /* The symbols being reduced. */ 1494 for (yyi = 0; yyi < yynrhs; yyi++) 1495 { 1496 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1497 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1498 &(yyvsp[(yyi + 1) - (yynrhs)]) 1499 ); 1500 YYFPRINTF (stderr, "\n"); 1501 } 1502 } 1503 1504 # define YY_REDUCE_PRINT(Rule) \ 1505 do { \ 1506 if (yydebug) \ 1507 yy_reduce_print (yyvsp, Rule); \ 1508 } while (YYID (0)) 1509 1510 /* Nonzero means print parse trace. It is left uninitialized so that 1511 multiple parsers can coexist. */ 1512 int yydebug; 1513 #else /* !YYDEBUG */ 1514 # define YYDPRINTF(Args) 1515 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1516 # define YY_STACK_PRINT(Bottom, Top) 1517 # define YY_REDUCE_PRINT(Rule) 1518 #endif /* !YYDEBUG */ 1519 1520 1521 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1522 #ifndef YYINITDEPTH 1523 # define YYINITDEPTH 200 1524 #endif 1525 1526 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1527 if the built-in stack extension method is used). 1528 1529 Do not make this value too large; the results are undefined if 1530 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1531 evaluated with infinite-precision integer arithmetic. */ 1532 1533 #ifndef YYMAXDEPTH 1534 # define YYMAXDEPTH 10000 1535 #endif 1536 1537 1538 #if YYERROR_VERBOSE 1539 1540 # ifndef yystrlen 1541 # if defined __GLIBC__ && defined _STRING_H 1542 # define yystrlen strlen 1543 # else 1544 /* Return the length of YYSTR. */ 1545 #if (defined __STDC__ || defined __C99__FUNC__ \ 1546 || defined __cplusplus || defined _MSC_VER) 1547 static YYSIZE_T 1548 yystrlen (const char *yystr) 1549 #else 1550 static YYSIZE_T 1551 yystrlen (yystr) 1552 const char *yystr; 1553 #endif 1554 { 1555 YYSIZE_T yylen; 1556 for (yylen = 0; yystr[yylen]; yylen++) 1557 continue; 1558 return yylen; 1559 } 1560 # endif 1561 # endif 1562 1563 # ifndef yystpcpy 1564 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1565 # define yystpcpy stpcpy 1566 # else 1567 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1568 YYDEST. */ 1569 #if (defined __STDC__ || defined __C99__FUNC__ \ 1570 || defined __cplusplus || defined _MSC_VER) 1571 static char * 1572 yystpcpy (char *yydest, const char *yysrc) 1573 #else 1574 static char * 1575 yystpcpy (yydest, yysrc) 1576 char *yydest; 1577 const char *yysrc; 1578 #endif 1579 { 1580 char *yyd = yydest; 1581 const char *yys = yysrc; 1582 1583 while ((*yyd++ = *yys++) != '\0') 1584 continue; 1585 1586 return yyd - 1; 1587 } 1588 # endif 1589 # endif 1590 1591 # ifndef yytnamerr 1592 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1593 quotes and backslashes, so that it's suitable for yyerror. The 1594 heuristic is that double-quoting is unnecessary unless the string 1595 contains an apostrophe, a comma, or backslash (other than 1596 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1597 null, do not copy; instead, return the length of what the result 1598 would have been. */ 1599 static YYSIZE_T 1600 yytnamerr (char *yyres, const char *yystr) 1601 { 1602 if (*yystr == '"') 1603 { 1604 YYSIZE_T yyn = 0; 1605 char const *yyp = yystr; 1606 1607 for (;;) 1608 switch (*++yyp) 1609 { 1610 case '\'': 1611 case ',': 1612 goto do_not_strip_quotes; 1613 1614 case '\\': 1615 if (*++yyp != '\\') 1616 goto do_not_strip_quotes; 1617 /* Fall through. */ 1618 default: 1619 if (yyres) 1620 yyres[yyn] = *yyp; 1621 yyn++; 1622 break; 1623 1624 case '"': 1625 if (yyres) 1626 yyres[yyn] = '\0'; 1627 return yyn; 1628 } 1629 do_not_strip_quotes: ; 1630 } 1631 1632 if (! yyres) 1633 return yystrlen (yystr); 1634 1635 return yystpcpy (yyres, yystr) - yyres; 1636 } 1637 # endif 1638 1639 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1640 about the unexpected token YYTOKEN for the state stack whose top is 1641 YYSSP. 1642 1643 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1644 not large enough to hold the message. In that case, also set 1645 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1646 required number of bytes is too large to store. */ 1647 static int 1648 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1649 yytype_int16 *yyssp, int yytoken) 1650 { 1651 YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]); 1652 YYSIZE_T yysize = yysize0; 1653 YYSIZE_T yysize1; 1654 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1655 /* Internationalized format string. */ 1656 const char *yyformat = YY_NULL; 1657 /* Arguments of yyformat. */ 1658 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1659 /* Number of reported tokens (one for the "unexpected", one per 1660 "expected"). */ 1661 int yycount = 0; 1662 1663 /* There are many possibilities here to consider: 1664 - Assume YYFAIL is not used. It's too flawed to consider. See 1665 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 1666 for details. YYERROR is fine as it does not invoke this 1667 function. 1668 - If this state is a consistent state with a default action, then 1669 the only way this function was invoked is if the default action 1670 is an error action. In that case, don't check for expected 1671 tokens because there are none. 1672 - The only way there can be no lookahead present (in yychar) is if 1673 this state is a consistent state with a default action. Thus, 1674 detecting the absence of a lookahead is sufficient to determine 1675 that there is no unexpected or expected token to report. In that 1676 case, just report a simple "syntax error". 1677 - Don't assume there isn't a lookahead just because this state is a 1678 consistent state with a default action. There might have been a 1679 previous inconsistent state, consistent state with a non-default 1680 action, or user semantic action that manipulated yychar. 1681 - Of course, the expected token list depends on states to have 1682 correct lookahead information, and it depends on the parser not 1683 to perform extra reductions after fetching a lookahead from the 1684 scanner and before detecting a syntax error. Thus, state merging 1685 (from LALR or IELR) and default reductions corrupt the expected 1686 token list. However, the list is correct for canonical LR with 1687 one exception: it will still contain any token that will not be 1688 accepted due to an error action in a later state. 1689 */ 1690 if (yytoken != YYEMPTY) 1691 { 1692 int yyn = yypact[*yyssp]; 1693 yyarg[yycount++] = yytname[yytoken]; 1694 if (!yypact_value_is_default (yyn)) 1695 { 1696 /* Start YYX at -YYN if negative to avoid negative indexes in 1697 YYCHECK. In other words, skip the first -YYN actions for 1698 this state because they are default actions. */ 1699 int yyxbegin = yyn < 0 ? -yyn : 0; 1700 /* Stay within bounds of both yycheck and yytname. */ 1701 int yychecklim = YYLAST - yyn + 1; 1702 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1703 int yyx; 1704 1705 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1706 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1707 && !yytable_value_is_error (yytable[yyx + yyn])) 1708 { 1709 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1710 { 1711 yycount = 1; 1712 yysize = yysize0; 1713 break; 1714 } 1715 yyarg[yycount++] = yytname[yyx]; 1716 yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]); 1717 if (! (yysize <= yysize1 1718 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1719 return 2; 1720 yysize = yysize1; 1721 } 1722 } 1723 } 1724 1725 switch (yycount) 1726 { 1727 # define YYCASE_(N, S) \ 1728 case N: \ 1729 yyformat = S; \ 1730 break 1731 YYCASE_(0, YY_("syntax error")); 1732 YYCASE_(1, YY_("syntax error, unexpected %s")); 1733 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1734 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1735 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1736 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1737 # undef YYCASE_ 1738 } 1739 1740 yysize1 = yysize + yystrlen (yyformat); 1741 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1742 return 2; 1743 yysize = yysize1; 1744 1745 if (*yymsg_alloc < yysize) 1746 { 1747 *yymsg_alloc = 2 * yysize; 1748 if (! (yysize <= *yymsg_alloc 1749 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1750 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1751 return 1; 1752 } 1753 1754 /* Avoid sprintf, as that infringes on the user's name space. 1755 Don't have undefined behavior even if the translation 1756 produced a string with the wrong number of "%s"s. */ 1757 { 1758 char *yyp = *yymsg; 1759 int yyi = 0; 1760 while ((*yyp = *yyformat) != '\0') 1761 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1762 { 1763 yyp += yytnamerr (yyp, yyarg[yyi++]); 1764 yyformat += 2; 1765 } 1766 else 1767 { 1768 yyp++; 1769 yyformat++; 1770 } 1771 } 1772 return 0; 1773 } 1774 #endif /* YYERROR_VERBOSE */ 1775 1776 /*-----------------------------------------------. 1777 | Release the memory associated to this symbol. | 1778 `-----------------------------------------------*/ 1779 1780 /*ARGSUSED*/ 1781 #if (defined __STDC__ || defined __C99__FUNC__ \ 1782 || defined __cplusplus || defined _MSC_VER) 1783 static void 1784 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1785 #else 1786 static void 1787 yydestruct (yymsg, yytype, yyvaluep) 1788 const char *yymsg; 1789 int yytype; 1790 YYSTYPE *yyvaluep; 1791 #endif 1792 { 1793 YYUSE (yyvaluep); 1794 1795 if (!yymsg) 1796 yymsg = "Deleting"; 1797 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1798 1799 switch (yytype) 1800 { 1801 1802 default: 1803 break; 1804 } 1805 } 1806 1807 1808 1809 1810 /* The lookahead symbol. */ 1811 int yychar; 1812 1813 /* The semantic value of the lookahead symbol. */ 1814 YYSTYPE yylval; 1815 1816 /* Number of syntax errors so far. */ 1817 int yynerrs; 1818 1819 1820 /*----------. 1821 | yyparse. | 1822 `----------*/ 1823 1824 #ifdef YYPARSE_PARAM 1825 #if (defined __STDC__ || defined __C99__FUNC__ \ 1826 || defined __cplusplus || defined _MSC_VER) 1827 int 1828 yyparse (void *YYPARSE_PARAM) 1829 #else 1830 int 1831 yyparse (YYPARSE_PARAM) 1832 void *YYPARSE_PARAM; 1833 #endif 1834 #else /* ! YYPARSE_PARAM */ 1835 #if (defined __STDC__ || defined __C99__FUNC__ \ 1836 || defined __cplusplus || defined _MSC_VER) 1837 int 1838 yyparse (void) 1839 #else 1840 int 1841 yyparse () 1842 1843 #endif 1844 #endif 1845 { 1846 int yystate; 1847 /* Number of tokens to shift before error messages enabled. */ 1848 int yyerrstatus; 1849 1850 /* The stacks and their tools: 1851 `yyss': related to states. 1852 `yyvs': related to semantic values. 1853 1854 Refer to the stacks through separate pointers, to allow yyoverflow 1855 to reallocate them elsewhere. */ 1856 1857 /* The state stack. */ 1858 yytype_int16 yyssa[YYINITDEPTH]; 1859 yytype_int16 *yyss; 1860 yytype_int16 *yyssp; 1861 1862 /* The semantic value stack. */ 1863 YYSTYPE yyvsa[YYINITDEPTH]; 1864 YYSTYPE *yyvs; 1865 YYSTYPE *yyvsp; 1866 1867 YYSIZE_T yystacksize; 1868 1869 int yyn; 1870 int yyresult; 1871 /* Lookahead token as an internal (translated) token number. */ 1872 int yytoken; 1873 /* The variables used to return semantic value and location from the 1874 action routines. */ 1875 YYSTYPE yyval; 1876 1877 #if YYERROR_VERBOSE 1878 /* Buffer for error messages, and its allocated size. */ 1879 char yymsgbuf[128]; 1880 char *yymsg = yymsgbuf; 1881 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1882 #endif 1883 1884 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1885 1886 /* The number of symbols on the RHS of the reduced rule. 1887 Keep to zero when no symbol should be popped. */ 1888 int yylen = 0; 1889 1890 yytoken = 0; 1891 yyss = yyssa; 1892 yyvs = yyvsa; 1893 yystacksize = YYINITDEPTH; 1894 1895 YYDPRINTF ((stderr, "Starting parse\n")); 1896 1897 yystate = 0; 1898 yyerrstatus = 0; 1899 yynerrs = 0; 1900 yychar = YYEMPTY; /* Cause a token to be read. */ 1901 1902 /* Initialize stack pointers. 1903 Waste one element of value and location stack 1904 so that they stay on the same level as the state stack. 1905 The wasted elements are never initialized. */ 1906 yyssp = yyss; 1907 yyvsp = yyvs; 1908 goto yysetstate; 1909 1910 /*------------------------------------------------------------. 1911 | yynewstate -- Push a new state, which is found in yystate. | 1912 `------------------------------------------------------------*/ 1913 yynewstate: 1914 /* In all cases, when you get here, the value and location stacks 1915 have just been pushed. So pushing a state here evens the stacks. */ 1916 yyssp++; 1917 1918 yysetstate: 1919 *yyssp = yystate; 1920 1921 if (yyss + yystacksize - 1 <= yyssp) 1922 { 1923 /* Get the current used size of the three stacks, in elements. */ 1924 YYSIZE_T yysize = yyssp - yyss + 1; 1925 1926 #ifdef yyoverflow 1927 { 1928 /* Give user a chance to reallocate the stack. Use copies of 1929 these so that the &'s don't force the real ones into 1930 memory. */ 1931 YYSTYPE *yyvs1 = yyvs; 1932 yytype_int16 *yyss1 = yyss; 1933 1934 /* Each stack pointer address is followed by the size of the 1935 data in use in that stack, in bytes. This used to be a 1936 conditional around just the two extra args, but that might 1937 be undefined if yyoverflow is a macro. */ 1938 yyoverflow (YY_("memory exhausted"), 1939 &yyss1, yysize * sizeof (*yyssp), 1940 &yyvs1, yysize * sizeof (*yyvsp), 1941 &yystacksize); 1942 1943 yyss = yyss1; 1944 yyvs = yyvs1; 1945 } 1946 #else /* no yyoverflow */ 1947 # ifndef YYSTACK_RELOCATE 1948 goto yyexhaustedlab; 1949 # else 1950 /* Extend the stack our own way. */ 1951 if (YYMAXDEPTH <= yystacksize) 1952 goto yyexhaustedlab; 1953 yystacksize *= 2; 1954 if (YYMAXDEPTH < yystacksize) 1955 yystacksize = YYMAXDEPTH; 1956 1957 { 1958 yytype_int16 *yyss1 = yyss; 1959 union yyalloc *yyptr = 1960 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1961 if (! yyptr) 1962 goto yyexhaustedlab; 1963 YYSTACK_RELOCATE (yyss_alloc, yyss); 1964 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1965 # undef YYSTACK_RELOCATE 1966 if (yyss1 != yyssa) 1967 YYSTACK_FREE (yyss1); 1968 } 1969 # endif 1970 #endif /* no yyoverflow */ 1971 1972 yyssp = yyss + yysize - 1; 1973 yyvsp = yyvs + yysize - 1; 1974 1975 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1976 (unsigned long int) yystacksize)); 1977 1978 if (yyss + yystacksize - 1 <= yyssp) 1979 YYABORT; 1980 } 1981 1982 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1983 1984 if (yystate == YYFINAL) 1985 YYACCEPT; 1986 1987 goto yybackup; 1988 1989 /*-----------. 1990 | yybackup. | 1991 `-----------*/ 1992 yybackup: 1993 1994 /* Do appropriate processing given the current state. Read a 1995 lookahead token if we need one and don't already have one. */ 1996 1997 /* First try to decide what to do without reference to lookahead token. */ 1998 yyn = yypact[yystate]; 1999 if (yypact_value_is_default (yyn)) 2000 goto yydefault; 2001 2002 /* Not known => get a lookahead token if don't already have one. */ 2003 2004 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 2005 if (yychar == YYEMPTY) 2006 { 2007 YYDPRINTF ((stderr, "Reading a token: ")); 2008 yychar = YYLEX; 2009 } 2010 2011 if (yychar <= YYEOF) 2012 { 2013 yychar = yytoken = YYEOF; 2014 YYDPRINTF ((stderr, "Now at end of input.\n")); 2015 } 2016 else 2017 { 2018 yytoken = YYTRANSLATE (yychar); 2019 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2020 } 2021 2022 /* If the proper action on seeing token YYTOKEN is to reduce or to 2023 detect an error, take that action. */ 2024 yyn += yytoken; 2025 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 2026 goto yydefault; 2027 yyn = yytable[yyn]; 2028 if (yyn <= 0) 2029 { 2030 if (yytable_value_is_error (yyn)) 2031 goto yyerrlab; 2032 yyn = -yyn; 2033 goto yyreduce; 2034 } 2035 2036 /* Count tokens shifted since error; after three, turn off error 2037 status. */ 2038 if (yyerrstatus) 2039 yyerrstatus--; 2040 2041 /* Shift the lookahead token. */ 2042 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2043 2044 /* Discard the shifted token. */ 2045 yychar = YYEMPTY; 2046 2047 yystate = yyn; 2048 *++yyvsp = yylval; 2049 2050 goto yynewstate; 2051 2052 2053 /*-----------------------------------------------------------. 2054 | yydefault -- do the default action for the current state. | 2055 `-----------------------------------------------------------*/ 2056 yydefault: 2057 yyn = yydefact[yystate]; 2058 if (yyn == 0) 2059 goto yyerrlab; 2060 goto yyreduce; 2061 2062 2063 /*-----------------------------. 2064 | yyreduce -- Do a reduction. | 2065 `-----------------------------*/ 2066 yyreduce: 2067 /* yyn is the number of a rule to reduce with. */ 2068 yylen = yyr2[yyn]; 2069 2070 /* If YYLEN is nonzero, implement the default value of the action: 2071 `$$ = $1'. 2072 2073 Otherwise, the following line sets YYVAL to garbage. 2074 This behavior is undocumented and Bison 2075 users should not rely upon it. Assigning to YYVAL 2076 unconditionally makes the parser a bit smaller, and it avoids a 2077 GCC warning that YYVAL may be used uninitialized. */ 2078 yyval = yyvsp[1-yylen]; 2079 2080 2081 YY_REDUCE_PRINT (yyn); 2082 switch (yyn) 2083 { 2084 case 9: 2085 /* Line 1787 of yacc.c */ 2086 #line 118 "util/configparser.y" 2087 { 2088 OUTYY(("\nP(server:)\n")); 2089 } 2090 break; 2091 2092 case 110: 2093 /* Line 1787 of yacc.c */ 2094 #line 167 "util/configparser.y" 2095 { 2096 struct config_stub* s; 2097 OUTYY(("\nP(stub_zone:)\n")); 2098 s = (struct config_stub*)calloc(1, sizeof(struct config_stub)); 2099 if(s) { 2100 s->next = cfg_parser->cfg->stubs; 2101 cfg_parser->cfg->stubs = s; 2102 } else 2103 yyerror("out of memory"); 2104 } 2105 break; 2106 2107 case 118: 2108 /* Line 1787 of yacc.c */ 2109 #line 183 "util/configparser.y" 2110 { 2111 struct config_stub* s; 2112 OUTYY(("\nP(forward_zone:)\n")); 2113 s = (struct config_stub*)calloc(1, sizeof(struct config_stub)); 2114 if(s) { 2115 s->next = cfg_parser->cfg->forwards; 2116 cfg_parser->cfg->forwards = s; 2117 } else 2118 yyerror("out of memory"); 2119 } 2120 break; 2121 2122 case 125: 2123 /* Line 1787 of yacc.c */ 2124 #line 199 "util/configparser.y" 2125 { 2126 OUTYY(("P(server_num_threads:%s)\n", (yyvsp[(2) - (2)].str))); 2127 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 2128 yyerror("number expected"); 2129 else cfg_parser->cfg->num_threads = atoi((yyvsp[(2) - (2)].str)); 2130 free((yyvsp[(2) - (2)].str)); 2131 } 2132 break; 2133 2134 case 126: 2135 /* Line 1787 of yacc.c */ 2136 #line 208 "util/configparser.y" 2137 { 2138 OUTYY(("P(server_verbosity:%s)\n", (yyvsp[(2) - (2)].str))); 2139 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 2140 yyerror("number expected"); 2141 else cfg_parser->cfg->verbosity = atoi((yyvsp[(2) - (2)].str)); 2142 free((yyvsp[(2) - (2)].str)); 2143 } 2144 break; 2145 2146 case 127: 2147 /* Line 1787 of yacc.c */ 2148 #line 217 "util/configparser.y" 2149 { 2150 OUTYY(("P(server_statistics_interval:%s)\n", (yyvsp[(2) - (2)].str))); 2151 if(strcmp((yyvsp[(2) - (2)].str), "") == 0 || strcmp((yyvsp[(2) - (2)].str), "0") == 0) 2152 cfg_parser->cfg->stat_interval = 0; 2153 else if(atoi((yyvsp[(2) - (2)].str)) == 0) 2154 yyerror("number expected"); 2155 else cfg_parser->cfg->stat_interval = atoi((yyvsp[(2) - (2)].str)); 2156 free((yyvsp[(2) - (2)].str)); 2157 } 2158 break; 2159 2160 case 128: 2161 /* Line 1787 of yacc.c */ 2162 #line 228 "util/configparser.y" 2163 { 2164 OUTYY(("P(server_statistics_cumulative:%s)\n", (yyvsp[(2) - (2)].str))); 2165 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2166 yyerror("expected yes or no."); 2167 else cfg_parser->cfg->stat_cumulative = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2168 free((yyvsp[(2) - (2)].str)); 2169 } 2170 break; 2171 2172 case 129: 2173 /* Line 1787 of yacc.c */ 2174 #line 237 "util/configparser.y" 2175 { 2176 OUTYY(("P(server_extended_statistics:%s)\n", (yyvsp[(2) - (2)].str))); 2177 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2178 yyerror("expected yes or no."); 2179 else cfg_parser->cfg->stat_extended = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2180 free((yyvsp[(2) - (2)].str)); 2181 } 2182 break; 2183 2184 case 130: 2185 /* Line 1787 of yacc.c */ 2186 #line 246 "util/configparser.y" 2187 { 2188 OUTYY(("P(server_port:%s)\n", (yyvsp[(2) - (2)].str))); 2189 if(atoi((yyvsp[(2) - (2)].str)) == 0) 2190 yyerror("port number expected"); 2191 else cfg_parser->cfg->port = atoi((yyvsp[(2) - (2)].str)); 2192 free((yyvsp[(2) - (2)].str)); 2193 } 2194 break; 2195 2196 case 131: 2197 /* Line 1787 of yacc.c */ 2198 #line 255 "util/configparser.y" 2199 { 2200 OUTYY(("P(server_interface:%s)\n", (yyvsp[(2) - (2)].str))); 2201 if(cfg_parser->cfg->num_ifs == 0) 2202 cfg_parser->cfg->ifs = calloc(1, sizeof(char*)); 2203 else cfg_parser->cfg->ifs = realloc(cfg_parser->cfg->ifs, 2204 (cfg_parser->cfg->num_ifs+1)*sizeof(char*)); 2205 if(!cfg_parser->cfg->ifs) 2206 yyerror("out of memory"); 2207 else 2208 cfg_parser->cfg->ifs[cfg_parser->cfg->num_ifs++] = (yyvsp[(2) - (2)].str); 2209 } 2210 break; 2211 2212 case 132: 2213 /* Line 1787 of yacc.c */ 2214 #line 268 "util/configparser.y" 2215 { 2216 OUTYY(("P(server_outgoing_interface:%s)\n", (yyvsp[(2) - (2)].str))); 2217 if(cfg_parser->cfg->num_out_ifs == 0) 2218 cfg_parser->cfg->out_ifs = calloc(1, sizeof(char*)); 2219 else cfg_parser->cfg->out_ifs = realloc( 2220 cfg_parser->cfg->out_ifs, 2221 (cfg_parser->cfg->num_out_ifs+1)*sizeof(char*)); 2222 if(!cfg_parser->cfg->out_ifs) 2223 yyerror("out of memory"); 2224 else 2225 cfg_parser->cfg->out_ifs[ 2226 cfg_parser->cfg->num_out_ifs++] = (yyvsp[(2) - (2)].str); 2227 } 2228 break; 2229 2230 case 133: 2231 /* Line 1787 of yacc.c */ 2232 #line 283 "util/configparser.y" 2233 { 2234 OUTYY(("P(server_outgoing_range:%s)\n", (yyvsp[(2) - (2)].str))); 2235 if(atoi((yyvsp[(2) - (2)].str)) == 0) 2236 yyerror("number expected"); 2237 else cfg_parser->cfg->outgoing_num_ports = atoi((yyvsp[(2) - (2)].str)); 2238 free((yyvsp[(2) - (2)].str)); 2239 } 2240 break; 2241 2242 case 134: 2243 /* Line 1787 of yacc.c */ 2244 #line 292 "util/configparser.y" 2245 { 2246 OUTYY(("P(server_outgoing_port_permit:%s)\n", (yyvsp[(2) - (2)].str))); 2247 if(!cfg_mark_ports((yyvsp[(2) - (2)].str), 1, 2248 cfg_parser->cfg->outgoing_avail_ports, 65536)) 2249 yyerror("port number or range (\"low-high\") expected"); 2250 free((yyvsp[(2) - (2)].str)); 2251 } 2252 break; 2253 2254 case 135: 2255 /* Line 1787 of yacc.c */ 2256 #line 301 "util/configparser.y" 2257 { 2258 OUTYY(("P(server_outgoing_port_avoid:%s)\n", (yyvsp[(2) - (2)].str))); 2259 if(!cfg_mark_ports((yyvsp[(2) - (2)].str), 0, 2260 cfg_parser->cfg->outgoing_avail_ports, 65536)) 2261 yyerror("port number or range (\"low-high\") expected"); 2262 free((yyvsp[(2) - (2)].str)); 2263 } 2264 break; 2265 2266 case 136: 2267 /* Line 1787 of yacc.c */ 2268 #line 310 "util/configparser.y" 2269 { 2270 OUTYY(("P(server_outgoing_num_tcp:%s)\n", (yyvsp[(2) - (2)].str))); 2271 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 2272 yyerror("number expected"); 2273 else cfg_parser->cfg->outgoing_num_tcp = atoi((yyvsp[(2) - (2)].str)); 2274 free((yyvsp[(2) - (2)].str)); 2275 } 2276 break; 2277 2278 case 137: 2279 /* Line 1787 of yacc.c */ 2280 #line 319 "util/configparser.y" 2281 { 2282 OUTYY(("P(server_incoming_num_tcp:%s)\n", (yyvsp[(2) - (2)].str))); 2283 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 2284 yyerror("number expected"); 2285 else cfg_parser->cfg->incoming_num_tcp = atoi((yyvsp[(2) - (2)].str)); 2286 free((yyvsp[(2) - (2)].str)); 2287 } 2288 break; 2289 2290 case 138: 2291 /* Line 1787 of yacc.c */ 2292 #line 328 "util/configparser.y" 2293 { 2294 OUTYY(("P(server_interface_automatic:%s)\n", (yyvsp[(2) - (2)].str))); 2295 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2296 yyerror("expected yes or no."); 2297 else cfg_parser->cfg->if_automatic = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2298 free((yyvsp[(2) - (2)].str)); 2299 } 2300 break; 2301 2302 case 139: 2303 /* Line 1787 of yacc.c */ 2304 #line 337 "util/configparser.y" 2305 { 2306 OUTYY(("P(server_do_ip4:%s)\n", (yyvsp[(2) - (2)].str))); 2307 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2308 yyerror("expected yes or no."); 2309 else cfg_parser->cfg->do_ip4 = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2310 free((yyvsp[(2) - (2)].str)); 2311 } 2312 break; 2313 2314 case 140: 2315 /* Line 1787 of yacc.c */ 2316 #line 346 "util/configparser.y" 2317 { 2318 OUTYY(("P(server_do_ip6:%s)\n", (yyvsp[(2) - (2)].str))); 2319 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2320 yyerror("expected yes or no."); 2321 else cfg_parser->cfg->do_ip6 = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2322 free((yyvsp[(2) - (2)].str)); 2323 } 2324 break; 2325 2326 case 141: 2327 /* Line 1787 of yacc.c */ 2328 #line 355 "util/configparser.y" 2329 { 2330 OUTYY(("P(server_do_udp:%s)\n", (yyvsp[(2) - (2)].str))); 2331 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2332 yyerror("expected yes or no."); 2333 else cfg_parser->cfg->do_udp = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2334 free((yyvsp[(2) - (2)].str)); 2335 } 2336 break; 2337 2338 case 142: 2339 /* Line 1787 of yacc.c */ 2340 #line 364 "util/configparser.y" 2341 { 2342 OUTYY(("P(server_do_tcp:%s)\n", (yyvsp[(2) - (2)].str))); 2343 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2344 yyerror("expected yes or no."); 2345 else cfg_parser->cfg->do_tcp = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2346 free((yyvsp[(2) - (2)].str)); 2347 } 2348 break; 2349 2350 case 143: 2351 /* Line 1787 of yacc.c */ 2352 #line 373 "util/configparser.y" 2353 { 2354 OUTYY(("P(server_tcp_upstream:%s)\n", (yyvsp[(2) - (2)].str))); 2355 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2356 yyerror("expected yes or no."); 2357 else cfg_parser->cfg->tcp_upstream = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2358 free((yyvsp[(2) - (2)].str)); 2359 } 2360 break; 2361 2362 case 144: 2363 /* Line 1787 of yacc.c */ 2364 #line 382 "util/configparser.y" 2365 { 2366 OUTYY(("P(server_ssl_upstream:%s)\n", (yyvsp[(2) - (2)].str))); 2367 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2368 yyerror("expected yes or no."); 2369 else cfg_parser->cfg->ssl_upstream = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2370 free((yyvsp[(2) - (2)].str)); 2371 } 2372 break; 2373 2374 case 145: 2375 /* Line 1787 of yacc.c */ 2376 #line 391 "util/configparser.y" 2377 { 2378 OUTYY(("P(server_ssl_service_key:%s)\n", (yyvsp[(2) - (2)].str))); 2379 free(cfg_parser->cfg->ssl_service_key); 2380 cfg_parser->cfg->ssl_service_key = (yyvsp[(2) - (2)].str); 2381 } 2382 break; 2383 2384 case 146: 2385 /* Line 1787 of yacc.c */ 2386 #line 398 "util/configparser.y" 2387 { 2388 OUTYY(("P(server_ssl_service_pem:%s)\n", (yyvsp[(2) - (2)].str))); 2389 free(cfg_parser->cfg->ssl_service_pem); 2390 cfg_parser->cfg->ssl_service_pem = (yyvsp[(2) - (2)].str); 2391 } 2392 break; 2393 2394 case 147: 2395 /* Line 1787 of yacc.c */ 2396 #line 405 "util/configparser.y" 2397 { 2398 OUTYY(("P(server_ssl_port:%s)\n", (yyvsp[(2) - (2)].str))); 2399 if(atoi((yyvsp[(2) - (2)].str)) == 0) 2400 yyerror("port number expected"); 2401 else cfg_parser->cfg->ssl_port = atoi((yyvsp[(2) - (2)].str)); 2402 free((yyvsp[(2) - (2)].str)); 2403 } 2404 break; 2405 2406 case 148: 2407 /* Line 1787 of yacc.c */ 2408 #line 414 "util/configparser.y" 2409 { 2410 OUTYY(("P(server_do_daemonize:%s)\n", (yyvsp[(2) - (2)].str))); 2411 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2412 yyerror("expected yes or no."); 2413 else cfg_parser->cfg->do_daemonize = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2414 free((yyvsp[(2) - (2)].str)); 2415 } 2416 break; 2417 2418 case 149: 2419 /* Line 1787 of yacc.c */ 2420 #line 423 "util/configparser.y" 2421 { 2422 OUTYY(("P(server_use_syslog:%s)\n", (yyvsp[(2) - (2)].str))); 2423 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2424 yyerror("expected yes or no."); 2425 else cfg_parser->cfg->use_syslog = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2426 #if !defined(HAVE_SYSLOG_H) && !defined(UB_ON_WINDOWS) 2427 if(strcmp((yyvsp[(2) - (2)].str), "yes") == 0) 2428 yyerror("no syslog services are available. " 2429 "(reconfigure and compile to add)"); 2430 #endif 2431 free((yyvsp[(2) - (2)].str)); 2432 } 2433 break; 2434 2435 case 150: 2436 /* Line 1787 of yacc.c */ 2437 #line 437 "util/configparser.y" 2438 { 2439 OUTYY(("P(server_log_time_ascii:%s)\n", (yyvsp[(2) - (2)].str))); 2440 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2441 yyerror("expected yes or no."); 2442 else cfg_parser->cfg->log_time_ascii = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2443 free((yyvsp[(2) - (2)].str)); 2444 } 2445 break; 2446 2447 case 151: 2448 /* Line 1787 of yacc.c */ 2449 #line 446 "util/configparser.y" 2450 { 2451 OUTYY(("P(server_log_queries:%s)\n", (yyvsp[(2) - (2)].str))); 2452 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2453 yyerror("expected yes or no."); 2454 else cfg_parser->cfg->log_queries = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2455 free((yyvsp[(2) - (2)].str)); 2456 } 2457 break; 2458 2459 case 152: 2460 /* Line 1787 of yacc.c */ 2461 #line 455 "util/configparser.y" 2462 { 2463 OUTYY(("P(server_chroot:%s)\n", (yyvsp[(2) - (2)].str))); 2464 free(cfg_parser->cfg->chrootdir); 2465 cfg_parser->cfg->chrootdir = (yyvsp[(2) - (2)].str); 2466 } 2467 break; 2468 2469 case 153: 2470 /* Line 1787 of yacc.c */ 2471 #line 462 "util/configparser.y" 2472 { 2473 OUTYY(("P(server_username:%s)\n", (yyvsp[(2) - (2)].str))); 2474 free(cfg_parser->cfg->username); 2475 cfg_parser->cfg->username = (yyvsp[(2) - (2)].str); 2476 } 2477 break; 2478 2479 case 154: 2480 /* Line 1787 of yacc.c */ 2481 #line 469 "util/configparser.y" 2482 { 2483 OUTYY(("P(server_directory:%s)\n", (yyvsp[(2) - (2)].str))); 2484 free(cfg_parser->cfg->directory); 2485 cfg_parser->cfg->directory = (yyvsp[(2) - (2)].str); 2486 } 2487 break; 2488 2489 case 155: 2490 /* Line 1787 of yacc.c */ 2491 #line 476 "util/configparser.y" 2492 { 2493 OUTYY(("P(server_logfile:%s)\n", (yyvsp[(2) - (2)].str))); 2494 free(cfg_parser->cfg->logfile); 2495 cfg_parser->cfg->logfile = (yyvsp[(2) - (2)].str); 2496 cfg_parser->cfg->use_syslog = 0; 2497 } 2498 break; 2499 2500 case 156: 2501 /* Line 1787 of yacc.c */ 2502 #line 484 "util/configparser.y" 2503 { 2504 OUTYY(("P(server_pidfile:%s)\n", (yyvsp[(2) - (2)].str))); 2505 free(cfg_parser->cfg->pidfile); 2506 cfg_parser->cfg->pidfile = (yyvsp[(2) - (2)].str); 2507 } 2508 break; 2509 2510 case 157: 2511 /* Line 1787 of yacc.c */ 2512 #line 491 "util/configparser.y" 2513 { 2514 OUTYY(("P(server_root_hints:%s)\n", (yyvsp[(2) - (2)].str))); 2515 if(!cfg_strlist_insert(&cfg_parser->cfg->root_hints, (yyvsp[(2) - (2)].str))) 2516 yyerror("out of memory"); 2517 } 2518 break; 2519 2520 case 158: 2521 /* Line 1787 of yacc.c */ 2522 #line 498 "util/configparser.y" 2523 { 2524 OUTYY(("P(server_dlv_anchor_file:%s)\n", (yyvsp[(2) - (2)].str))); 2525 free(cfg_parser->cfg->dlv_anchor_file); 2526 cfg_parser->cfg->dlv_anchor_file = (yyvsp[(2) - (2)].str); 2527 } 2528 break; 2529 2530 case 159: 2531 /* Line 1787 of yacc.c */ 2532 #line 505 "util/configparser.y" 2533 { 2534 OUTYY(("P(server_dlv_anchor:%s)\n", (yyvsp[(2) - (2)].str))); 2535 if(!cfg_strlist_insert(&cfg_parser->cfg->dlv_anchor_list, (yyvsp[(2) - (2)].str))) 2536 yyerror("out of memory"); 2537 } 2538 break; 2539 2540 case 160: 2541 /* Line 1787 of yacc.c */ 2542 #line 512 "util/configparser.y" 2543 { 2544 OUTYY(("P(server_auto_trust_anchor_file:%s)\n", (yyvsp[(2) - (2)].str))); 2545 if(!cfg_strlist_insert(&cfg_parser->cfg-> 2546 auto_trust_anchor_file_list, (yyvsp[(2) - (2)].str))) 2547 yyerror("out of memory"); 2548 } 2549 break; 2550 2551 case 161: 2552 /* Line 1787 of yacc.c */ 2553 #line 520 "util/configparser.y" 2554 { 2555 OUTYY(("P(server_trust_anchor_file:%s)\n", (yyvsp[(2) - (2)].str))); 2556 if(!cfg_strlist_insert(&cfg_parser->cfg-> 2557 trust_anchor_file_list, (yyvsp[(2) - (2)].str))) 2558 yyerror("out of memory"); 2559 } 2560 break; 2561 2562 case 162: 2563 /* Line 1787 of yacc.c */ 2564 #line 528 "util/configparser.y" 2565 { 2566 OUTYY(("P(server_trusted_keys_file:%s)\n", (yyvsp[(2) - (2)].str))); 2567 if(!cfg_strlist_insert(&cfg_parser->cfg-> 2568 trusted_keys_file_list, (yyvsp[(2) - (2)].str))) 2569 yyerror("out of memory"); 2570 } 2571 break; 2572 2573 case 163: 2574 /* Line 1787 of yacc.c */ 2575 #line 536 "util/configparser.y" 2576 { 2577 OUTYY(("P(server_trust_anchor:%s)\n", (yyvsp[(2) - (2)].str))); 2578 if(!cfg_strlist_insert(&cfg_parser->cfg->trust_anchor_list, (yyvsp[(2) - (2)].str))) 2579 yyerror("out of memory"); 2580 } 2581 break; 2582 2583 case 164: 2584 /* Line 1787 of yacc.c */ 2585 #line 543 "util/configparser.y" 2586 { 2587 OUTYY(("P(server_domain_insecure:%s)\n", (yyvsp[(2) - (2)].str))); 2588 if(!cfg_strlist_insert(&cfg_parser->cfg->domain_insecure, (yyvsp[(2) - (2)].str))) 2589 yyerror("out of memory"); 2590 } 2591 break; 2592 2593 case 165: 2594 /* Line 1787 of yacc.c */ 2595 #line 550 "util/configparser.y" 2596 { 2597 OUTYY(("P(server_hide_identity:%s)\n", (yyvsp[(2) - (2)].str))); 2598 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2599 yyerror("expected yes or no."); 2600 else cfg_parser->cfg->hide_identity = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2601 free((yyvsp[(2) - (2)].str)); 2602 } 2603 break; 2604 2605 case 166: 2606 /* Line 1787 of yacc.c */ 2607 #line 559 "util/configparser.y" 2608 { 2609 OUTYY(("P(server_hide_version:%s)\n", (yyvsp[(2) - (2)].str))); 2610 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2611 yyerror("expected yes or no."); 2612 else cfg_parser->cfg->hide_version = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2613 free((yyvsp[(2) - (2)].str)); 2614 } 2615 break; 2616 2617 case 167: 2618 /* Line 1787 of yacc.c */ 2619 #line 568 "util/configparser.y" 2620 { 2621 OUTYY(("P(server_identity:%s)\n", (yyvsp[(2) - (2)].str))); 2622 free(cfg_parser->cfg->identity); 2623 cfg_parser->cfg->identity = (yyvsp[(2) - (2)].str); 2624 } 2625 break; 2626 2627 case 168: 2628 /* Line 1787 of yacc.c */ 2629 #line 575 "util/configparser.y" 2630 { 2631 OUTYY(("P(server_version:%s)\n", (yyvsp[(2) - (2)].str))); 2632 free(cfg_parser->cfg->version); 2633 cfg_parser->cfg->version = (yyvsp[(2) - (2)].str); 2634 } 2635 break; 2636 2637 case 169: 2638 /* Line 1787 of yacc.c */ 2639 #line 582 "util/configparser.y" 2640 { 2641 OUTYY(("P(server_so_rcvbuf:%s)\n", (yyvsp[(2) - (2)].str))); 2642 if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->so_rcvbuf)) 2643 yyerror("buffer size expected"); 2644 free((yyvsp[(2) - (2)].str)); 2645 } 2646 break; 2647 2648 case 170: 2649 /* Line 1787 of yacc.c */ 2650 #line 590 "util/configparser.y" 2651 { 2652 OUTYY(("P(server_so_sndbuf:%s)\n", (yyvsp[(2) - (2)].str))); 2653 if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->so_sndbuf)) 2654 yyerror("buffer size expected"); 2655 free((yyvsp[(2) - (2)].str)); 2656 } 2657 break; 2658 2659 case 171: 2660 /* Line 1787 of yacc.c */ 2661 #line 598 "util/configparser.y" 2662 { 2663 OUTYY(("P(server_edns_buffer_size:%s)\n", (yyvsp[(2) - (2)].str))); 2664 if(atoi((yyvsp[(2) - (2)].str)) == 0) 2665 yyerror("number expected"); 2666 else if (atoi((yyvsp[(2) - (2)].str)) < 12) 2667 yyerror("edns buffer size too small"); 2668 else if (atoi((yyvsp[(2) - (2)].str)) > 65535) 2669 cfg_parser->cfg->edns_buffer_size = 65535; 2670 else cfg_parser->cfg->edns_buffer_size = atoi((yyvsp[(2) - (2)].str)); 2671 free((yyvsp[(2) - (2)].str)); 2672 } 2673 break; 2674 2675 case 172: 2676 /* Line 1787 of yacc.c */ 2677 #line 611 "util/configparser.y" 2678 { 2679 OUTYY(("P(server_msg_buffer_size:%s)\n", (yyvsp[(2) - (2)].str))); 2680 if(atoi((yyvsp[(2) - (2)].str)) == 0) 2681 yyerror("number expected"); 2682 else if (atoi((yyvsp[(2) - (2)].str)) < 4096) 2683 yyerror("message buffer size too small (use 4096)"); 2684 else cfg_parser->cfg->msg_buffer_size = atoi((yyvsp[(2) - (2)].str)); 2685 free((yyvsp[(2) - (2)].str)); 2686 } 2687 break; 2688 2689 case 173: 2690 /* Line 1787 of yacc.c */ 2691 #line 622 "util/configparser.y" 2692 { 2693 OUTYY(("P(server_msg_cache_size:%s)\n", (yyvsp[(2) - (2)].str))); 2694 if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->msg_cache_size)) 2695 yyerror("memory size expected"); 2696 free((yyvsp[(2) - (2)].str)); 2697 } 2698 break; 2699 2700 case 174: 2701 /* Line 1787 of yacc.c */ 2702 #line 630 "util/configparser.y" 2703 { 2704 OUTYY(("P(server_msg_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str))); 2705 if(atoi((yyvsp[(2) - (2)].str)) == 0) 2706 yyerror("number expected"); 2707 else { 2708 cfg_parser->cfg->msg_cache_slabs = atoi((yyvsp[(2) - (2)].str)); 2709 if(!is_pow2(cfg_parser->cfg->msg_cache_slabs)) 2710 yyerror("must be a power of 2"); 2711 } 2712 free((yyvsp[(2) - (2)].str)); 2713 } 2714 break; 2715 2716 case 175: 2717 /* Line 1787 of yacc.c */ 2718 #line 643 "util/configparser.y" 2719 { 2720 OUTYY(("P(server_num_queries_per_thread:%s)\n", (yyvsp[(2) - (2)].str))); 2721 if(atoi((yyvsp[(2) - (2)].str)) == 0) 2722 yyerror("number expected"); 2723 else cfg_parser->cfg->num_queries_per_thread = atoi((yyvsp[(2) - (2)].str)); 2724 free((yyvsp[(2) - (2)].str)); 2725 } 2726 break; 2727 2728 case 176: 2729 /* Line 1787 of yacc.c */ 2730 #line 652 "util/configparser.y" 2731 { 2732 OUTYY(("P(server_jostle_timeout:%s)\n", (yyvsp[(2) - (2)].str))); 2733 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 2734 yyerror("number expected"); 2735 else cfg_parser->cfg->jostle_time = atoi((yyvsp[(2) - (2)].str)); 2736 free((yyvsp[(2) - (2)].str)); 2737 } 2738 break; 2739 2740 case 177: 2741 /* Line 1787 of yacc.c */ 2742 #line 661 "util/configparser.y" 2743 { 2744 OUTYY(("P(server_rrset_cache_size:%s)\n", (yyvsp[(2) - (2)].str))); 2745 if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->rrset_cache_size)) 2746 yyerror("memory size expected"); 2747 free((yyvsp[(2) - (2)].str)); 2748 } 2749 break; 2750 2751 case 178: 2752 /* Line 1787 of yacc.c */ 2753 #line 669 "util/configparser.y" 2754 { 2755 OUTYY(("P(server_rrset_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str))); 2756 if(atoi((yyvsp[(2) - (2)].str)) == 0) 2757 yyerror("number expected"); 2758 else { 2759 cfg_parser->cfg->rrset_cache_slabs = atoi((yyvsp[(2) - (2)].str)); 2760 if(!is_pow2(cfg_parser->cfg->rrset_cache_slabs)) 2761 yyerror("must be a power of 2"); 2762 } 2763 free((yyvsp[(2) - (2)].str)); 2764 } 2765 break; 2766 2767 case 179: 2768 /* Line 1787 of yacc.c */ 2769 #line 682 "util/configparser.y" 2770 { 2771 OUTYY(("P(server_infra_host_ttl:%s)\n", (yyvsp[(2) - (2)].str))); 2772 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 2773 yyerror("number expected"); 2774 else cfg_parser->cfg->host_ttl = atoi((yyvsp[(2) - (2)].str)); 2775 free((yyvsp[(2) - (2)].str)); 2776 } 2777 break; 2778 2779 case 180: 2780 /* Line 1787 of yacc.c */ 2781 #line 691 "util/configparser.y" 2782 { 2783 OUTYY(("P(server_infra_lame_ttl:%s)\n", (yyvsp[(2) - (2)].str))); 2784 verbose(VERB_DETAIL, "ignored infra-lame-ttl: %s (option " 2785 "removed, use infra-host-ttl)", (yyvsp[(2) - (2)].str)); 2786 free((yyvsp[(2) - (2)].str)); 2787 } 2788 break; 2789 2790 case 181: 2791 /* Line 1787 of yacc.c */ 2792 #line 699 "util/configparser.y" 2793 { 2794 OUTYY(("P(server_infra_cache_numhosts:%s)\n", (yyvsp[(2) - (2)].str))); 2795 if(atoi((yyvsp[(2) - (2)].str)) == 0) 2796 yyerror("number expected"); 2797 else cfg_parser->cfg->infra_cache_numhosts = atoi((yyvsp[(2) - (2)].str)); 2798 free((yyvsp[(2) - (2)].str)); 2799 } 2800 break; 2801 2802 case 182: 2803 /* Line 1787 of yacc.c */ 2804 #line 708 "util/configparser.y" 2805 { 2806 OUTYY(("P(server_infra_cache_lame_size:%s)\n", (yyvsp[(2) - (2)].str))); 2807 verbose(VERB_DETAIL, "ignored infra-cache-lame-size: %s " 2808 "(option removed, use infra-cache-numhosts)", (yyvsp[(2) - (2)].str)); 2809 free((yyvsp[(2) - (2)].str)); 2810 } 2811 break; 2812 2813 case 183: 2814 /* Line 1787 of yacc.c */ 2815 #line 716 "util/configparser.y" 2816 { 2817 OUTYY(("P(server_infra_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str))); 2818 if(atoi((yyvsp[(2) - (2)].str)) == 0) 2819 yyerror("number expected"); 2820 else { 2821 cfg_parser->cfg->infra_cache_slabs = atoi((yyvsp[(2) - (2)].str)); 2822 if(!is_pow2(cfg_parser->cfg->infra_cache_slabs)) 2823 yyerror("must be a power of 2"); 2824 } 2825 free((yyvsp[(2) - (2)].str)); 2826 } 2827 break; 2828 2829 case 184: 2830 /* Line 1787 of yacc.c */ 2831 #line 729 "util/configparser.y" 2832 { 2833 OUTYY(("P(server_target_fetch_policy:%s)\n", (yyvsp[(2) - (2)].str))); 2834 free(cfg_parser->cfg->target_fetch_policy); 2835 cfg_parser->cfg->target_fetch_policy = (yyvsp[(2) - (2)].str); 2836 } 2837 break; 2838 2839 case 185: 2840 /* Line 1787 of yacc.c */ 2841 #line 736 "util/configparser.y" 2842 { 2843 OUTYY(("P(server_harden_short_bufsize:%s)\n", (yyvsp[(2) - (2)].str))); 2844 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2845 yyerror("expected yes or no."); 2846 else cfg_parser->cfg->harden_short_bufsize = 2847 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2848 free((yyvsp[(2) - (2)].str)); 2849 } 2850 break; 2851 2852 case 186: 2853 /* Line 1787 of yacc.c */ 2854 #line 746 "util/configparser.y" 2855 { 2856 OUTYY(("P(server_harden_large_queries:%s)\n", (yyvsp[(2) - (2)].str))); 2857 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2858 yyerror("expected yes or no."); 2859 else cfg_parser->cfg->harden_large_queries = 2860 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2861 free((yyvsp[(2) - (2)].str)); 2862 } 2863 break; 2864 2865 case 187: 2866 /* Line 1787 of yacc.c */ 2867 #line 756 "util/configparser.y" 2868 { 2869 OUTYY(("P(server_harden_glue:%s)\n", (yyvsp[(2) - (2)].str))); 2870 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2871 yyerror("expected yes or no."); 2872 else cfg_parser->cfg->harden_glue = 2873 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2874 free((yyvsp[(2) - (2)].str)); 2875 } 2876 break; 2877 2878 case 188: 2879 /* Line 1787 of yacc.c */ 2880 #line 766 "util/configparser.y" 2881 { 2882 OUTYY(("P(server_harden_dnssec_stripped:%s)\n", (yyvsp[(2) - (2)].str))); 2883 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2884 yyerror("expected yes or no."); 2885 else cfg_parser->cfg->harden_dnssec_stripped = 2886 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2887 free((yyvsp[(2) - (2)].str)); 2888 } 2889 break; 2890 2891 case 189: 2892 /* Line 1787 of yacc.c */ 2893 #line 776 "util/configparser.y" 2894 { 2895 OUTYY(("P(server_harden_below_nxdomain:%s)\n", (yyvsp[(2) - (2)].str))); 2896 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2897 yyerror("expected yes or no."); 2898 else cfg_parser->cfg->harden_below_nxdomain = 2899 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2900 free((yyvsp[(2) - (2)].str)); 2901 } 2902 break; 2903 2904 case 190: 2905 /* Line 1787 of yacc.c */ 2906 #line 786 "util/configparser.y" 2907 { 2908 OUTYY(("P(server_harden_referral_path:%s)\n", (yyvsp[(2) - (2)].str))); 2909 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2910 yyerror("expected yes or no."); 2911 else cfg_parser->cfg->harden_referral_path = 2912 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2913 free((yyvsp[(2) - (2)].str)); 2914 } 2915 break; 2916 2917 case 191: 2918 /* Line 1787 of yacc.c */ 2919 #line 796 "util/configparser.y" 2920 { 2921 OUTYY(("P(server_use_caps_for_id:%s)\n", (yyvsp[(2) - (2)].str))); 2922 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2923 yyerror("expected yes or no."); 2924 else cfg_parser->cfg->use_caps_bits_for_id = 2925 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2926 free((yyvsp[(2) - (2)].str)); 2927 } 2928 break; 2929 2930 case 192: 2931 /* Line 1787 of yacc.c */ 2932 #line 806 "util/configparser.y" 2933 { 2934 OUTYY(("P(server_private_address:%s)\n", (yyvsp[(2) - (2)].str))); 2935 if(!cfg_strlist_insert(&cfg_parser->cfg->private_address, (yyvsp[(2) - (2)].str))) 2936 yyerror("out of memory"); 2937 } 2938 break; 2939 2940 case 193: 2941 /* Line 1787 of yacc.c */ 2942 #line 813 "util/configparser.y" 2943 { 2944 OUTYY(("P(server_private_domain:%s)\n", (yyvsp[(2) - (2)].str))); 2945 if(!cfg_strlist_insert(&cfg_parser->cfg->private_domain, (yyvsp[(2) - (2)].str))) 2946 yyerror("out of memory"); 2947 } 2948 break; 2949 2950 case 194: 2951 /* Line 1787 of yacc.c */ 2952 #line 820 "util/configparser.y" 2953 { 2954 OUTYY(("P(server_prefetch:%s)\n", (yyvsp[(2) - (2)].str))); 2955 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2956 yyerror("expected yes or no."); 2957 else cfg_parser->cfg->prefetch = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2958 free((yyvsp[(2) - (2)].str)); 2959 } 2960 break; 2961 2962 case 195: 2963 /* Line 1787 of yacc.c */ 2964 #line 829 "util/configparser.y" 2965 { 2966 OUTYY(("P(server_prefetch_key:%s)\n", (yyvsp[(2) - (2)].str))); 2967 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 2968 yyerror("expected yes or no."); 2969 else cfg_parser->cfg->prefetch_key = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 2970 free((yyvsp[(2) - (2)].str)); 2971 } 2972 break; 2973 2974 case 196: 2975 /* Line 1787 of yacc.c */ 2976 #line 838 "util/configparser.y" 2977 { 2978 OUTYY(("P(server_unwanted_reply_threshold:%s)\n", (yyvsp[(2) - (2)].str))); 2979 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 2980 yyerror("number expected"); 2981 else cfg_parser->cfg->unwanted_threshold = atoi((yyvsp[(2) - (2)].str)); 2982 free((yyvsp[(2) - (2)].str)); 2983 } 2984 break; 2985 2986 case 197: 2987 /* Line 1787 of yacc.c */ 2988 #line 847 "util/configparser.y" 2989 { 2990 OUTYY(("P(server_do_not_query_address:%s)\n", (yyvsp[(2) - (2)].str))); 2991 if(!cfg_strlist_insert(&cfg_parser->cfg->donotqueryaddrs, (yyvsp[(2) - (2)].str))) 2992 yyerror("out of memory"); 2993 } 2994 break; 2995 2996 case 198: 2997 /* Line 1787 of yacc.c */ 2998 #line 854 "util/configparser.y" 2999 { 3000 OUTYY(("P(server_do_not_query_localhost:%s)\n", (yyvsp[(2) - (2)].str))); 3001 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 3002 yyerror("expected yes or no."); 3003 else cfg_parser->cfg->donotquery_localhost = 3004 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 3005 free((yyvsp[(2) - (2)].str)); 3006 } 3007 break; 3008 3009 case 199: 3010 /* Line 1787 of yacc.c */ 3011 #line 864 "util/configparser.y" 3012 { 3013 OUTYY(("P(server_access_control:%s %s)\n", (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str))); 3014 if(strcmp((yyvsp[(3) - (3)].str), "deny")!=0 && strcmp((yyvsp[(3) - (3)].str), "refuse")!=0 && 3015 strcmp((yyvsp[(3) - (3)].str), "allow")!=0 && 3016 strcmp((yyvsp[(3) - (3)].str), "allow_snoop")!=0) { 3017 yyerror("expected deny, refuse, allow or allow_snoop " 3018 "in access control action"); 3019 } else { 3020 if(!cfg_str2list_insert(&cfg_parser->cfg->acls, (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str))) 3021 fatal_exit("out of memory adding acl"); 3022 } 3023 } 3024 break; 3025 3026 case 200: 3027 /* Line 1787 of yacc.c */ 3028 #line 878 "util/configparser.y" 3029 { 3030 OUTYY(("P(server_module_conf:%s)\n", (yyvsp[(2) - (2)].str))); 3031 free(cfg_parser->cfg->module_conf); 3032 cfg_parser->cfg->module_conf = (yyvsp[(2) - (2)].str); 3033 } 3034 break; 3035 3036 case 201: 3037 /* Line 1787 of yacc.c */ 3038 #line 885 "util/configparser.y" 3039 { 3040 OUTYY(("P(server_val_override_date:%s)\n", (yyvsp[(2) - (2)].str))); 3041 if(strlen((yyvsp[(2) - (2)].str)) == 0 || strcmp((yyvsp[(2) - (2)].str), "0") == 0) { 3042 cfg_parser->cfg->val_date_override = 0; 3043 } else if(strlen((yyvsp[(2) - (2)].str)) == 14) { 3044 cfg_parser->cfg->val_date_override = 3045 cfg_convert_timeval((yyvsp[(2) - (2)].str)); 3046 if(!cfg_parser->cfg->val_date_override) 3047 yyerror("bad date/time specification"); 3048 } else { 3049 if(atoi((yyvsp[(2) - (2)].str)) == 0) 3050 yyerror("number expected"); 3051 cfg_parser->cfg->val_date_override = atoi((yyvsp[(2) - (2)].str)); 3052 } 3053 free((yyvsp[(2) - (2)].str)); 3054 } 3055 break; 3056 3057 case 202: 3058 /* Line 1787 of yacc.c */ 3059 #line 903 "util/configparser.y" 3060 { 3061 OUTYY(("P(server_val_sig_skew_min:%s)\n", (yyvsp[(2) - (2)].str))); 3062 if(strlen((yyvsp[(2) - (2)].str)) == 0 || strcmp((yyvsp[(2) - (2)].str), "0") == 0) { 3063 cfg_parser->cfg->val_sig_skew_min = 0; 3064 } else { 3065 cfg_parser->cfg->val_sig_skew_min = atoi((yyvsp[(2) - (2)].str)); 3066 if(!cfg_parser->cfg->val_sig_skew_min) 3067 yyerror("number expected"); 3068 } 3069 free((yyvsp[(2) - (2)].str)); 3070 } 3071 break; 3072 3073 case 203: 3074 /* Line 1787 of yacc.c */ 3075 #line 916 "util/configparser.y" 3076 { 3077 OUTYY(("P(server_val_sig_skew_max:%s)\n", (yyvsp[(2) - (2)].str))); 3078 if(strlen((yyvsp[(2) - (2)].str)) == 0 || strcmp((yyvsp[(2) - (2)].str), "0") == 0) { 3079 cfg_parser->cfg->val_sig_skew_max = 0; 3080 } else { 3081 cfg_parser->cfg->val_sig_skew_max = atoi((yyvsp[(2) - (2)].str)); 3082 if(!cfg_parser->cfg->val_sig_skew_max) 3083 yyerror("number expected"); 3084 } 3085 free((yyvsp[(2) - (2)].str)); 3086 } 3087 break; 3088 3089 case 204: 3090 /* Line 1787 of yacc.c */ 3091 #line 929 "util/configparser.y" 3092 { 3093 OUTYY(("P(server_cache_max_ttl:%s)\n", (yyvsp[(2) - (2)].str))); 3094 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 3095 yyerror("number expected"); 3096 else cfg_parser->cfg->max_ttl = atoi((yyvsp[(2) - (2)].str)); 3097 free((yyvsp[(2) - (2)].str)); 3098 } 3099 break; 3100 3101 case 205: 3102 /* Line 1787 of yacc.c */ 3103 #line 938 "util/configparser.y" 3104 { 3105 OUTYY(("P(server_cache_min_ttl:%s)\n", (yyvsp[(2) - (2)].str))); 3106 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 3107 yyerror("number expected"); 3108 else cfg_parser->cfg->min_ttl = atoi((yyvsp[(2) - (2)].str)); 3109 free((yyvsp[(2) - (2)].str)); 3110 } 3111 break; 3112 3113 case 206: 3114 /* Line 1787 of yacc.c */ 3115 #line 947 "util/configparser.y" 3116 { 3117 OUTYY(("P(server_bogus_ttl:%s)\n", (yyvsp[(2) - (2)].str))); 3118 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 3119 yyerror("number expected"); 3120 else cfg_parser->cfg->bogus_ttl = atoi((yyvsp[(2) - (2)].str)); 3121 free((yyvsp[(2) - (2)].str)); 3122 } 3123 break; 3124 3125 case 207: 3126 /* Line 1787 of yacc.c */ 3127 #line 956 "util/configparser.y" 3128 { 3129 OUTYY(("P(server_val_clean_additional:%s)\n", (yyvsp[(2) - (2)].str))); 3130 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 3131 yyerror("expected yes or no."); 3132 else cfg_parser->cfg->val_clean_additional = 3133 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 3134 free((yyvsp[(2) - (2)].str)); 3135 } 3136 break; 3137 3138 case 208: 3139 /* Line 1787 of yacc.c */ 3140 #line 966 "util/configparser.y" 3141 { 3142 OUTYY(("P(server_val_permissive_mode:%s)\n", (yyvsp[(2) - (2)].str))); 3143 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 3144 yyerror("expected yes or no."); 3145 else cfg_parser->cfg->val_permissive_mode = 3146 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 3147 free((yyvsp[(2) - (2)].str)); 3148 } 3149 break; 3150 3151 case 209: 3152 /* Line 1787 of yacc.c */ 3153 #line 976 "util/configparser.y" 3154 { 3155 OUTYY(("P(server_ignore_cd_flag:%s)\n", (yyvsp[(2) - (2)].str))); 3156 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 3157 yyerror("expected yes or no."); 3158 else cfg_parser->cfg->ignore_cd = (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 3159 free((yyvsp[(2) - (2)].str)); 3160 } 3161 break; 3162 3163 case 210: 3164 /* Line 1787 of yacc.c */ 3165 #line 985 "util/configparser.y" 3166 { 3167 OUTYY(("P(server_val_log_level:%s)\n", (yyvsp[(2) - (2)].str))); 3168 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 3169 yyerror("number expected"); 3170 else cfg_parser->cfg->val_log_level = atoi((yyvsp[(2) - (2)].str)); 3171 free((yyvsp[(2) - (2)].str)); 3172 } 3173 break; 3174 3175 case 211: 3176 /* Line 1787 of yacc.c */ 3177 #line 994 "util/configparser.y" 3178 { 3179 OUTYY(("P(server_val_nsec3_keysize_iterations:%s)\n", (yyvsp[(2) - (2)].str))); 3180 free(cfg_parser->cfg->val_nsec3_key_iterations); 3181 cfg_parser->cfg->val_nsec3_key_iterations = (yyvsp[(2) - (2)].str); 3182 } 3183 break; 3184 3185 case 212: 3186 /* Line 1787 of yacc.c */ 3187 #line 1001 "util/configparser.y" 3188 { 3189 OUTYY(("P(server_add_holddown:%s)\n", (yyvsp[(2) - (2)].str))); 3190 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 3191 yyerror("number expected"); 3192 else cfg_parser->cfg->add_holddown = atoi((yyvsp[(2) - (2)].str)); 3193 free((yyvsp[(2) - (2)].str)); 3194 } 3195 break; 3196 3197 case 213: 3198 /* Line 1787 of yacc.c */ 3199 #line 1010 "util/configparser.y" 3200 { 3201 OUTYY(("P(server_del_holddown:%s)\n", (yyvsp[(2) - (2)].str))); 3202 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 3203 yyerror("number expected"); 3204 else cfg_parser->cfg->del_holddown = atoi((yyvsp[(2) - (2)].str)); 3205 free((yyvsp[(2) - (2)].str)); 3206 } 3207 break; 3208 3209 case 214: 3210 /* Line 1787 of yacc.c */ 3211 #line 1019 "util/configparser.y" 3212 { 3213 OUTYY(("P(server_keep_missing:%s)\n", (yyvsp[(2) - (2)].str))); 3214 if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0) 3215 yyerror("number expected"); 3216 else cfg_parser->cfg->keep_missing = atoi((yyvsp[(2) - (2)].str)); 3217 free((yyvsp[(2) - (2)].str)); 3218 } 3219 break; 3220 3221 case 215: 3222 /* Line 1787 of yacc.c */ 3223 #line 1028 "util/configparser.y" 3224 { 3225 OUTYY(("P(server_key_cache_size:%s)\n", (yyvsp[(2) - (2)].str))); 3226 if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->key_cache_size)) 3227 yyerror("memory size expected"); 3228 free((yyvsp[(2) - (2)].str)); 3229 } 3230 break; 3231 3232 case 216: 3233 /* Line 1787 of yacc.c */ 3234 #line 1036 "util/configparser.y" 3235 { 3236 OUTYY(("P(server_key_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str))); 3237 if(atoi((yyvsp[(2) - (2)].str)) == 0) 3238 yyerror("number expected"); 3239 else { 3240 cfg_parser->cfg->key_cache_slabs = atoi((yyvsp[(2) - (2)].str)); 3241 if(!is_pow2(cfg_parser->cfg->key_cache_slabs)) 3242 yyerror("must be a power of 2"); 3243 } 3244 free((yyvsp[(2) - (2)].str)); 3245 } 3246 break; 3247 3248 case 217: 3249 /* Line 1787 of yacc.c */ 3250 #line 1049 "util/configparser.y" 3251 { 3252 OUTYY(("P(server_neg_cache_size:%s)\n", (yyvsp[(2) - (2)].str))); 3253 if(!cfg_parse_memsize((yyvsp[(2) - (2)].str), &cfg_parser->cfg->neg_cache_size)) 3254 yyerror("memory size expected"); 3255 free((yyvsp[(2) - (2)].str)); 3256 } 3257 break; 3258 3259 case 218: 3260 /* Line 1787 of yacc.c */ 3261 #line 1057 "util/configparser.y" 3262 { 3263 OUTYY(("P(server_local_zone:%s %s)\n", (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str))); 3264 if(strcmp((yyvsp[(3) - (3)].str), "static")!=0 && strcmp((yyvsp[(3) - (3)].str), "deny")!=0 && 3265 strcmp((yyvsp[(3) - (3)].str), "refuse")!=0 && strcmp((yyvsp[(3) - (3)].str), "redirect")!=0 && 3266 strcmp((yyvsp[(3) - (3)].str), "transparent")!=0 && strcmp((yyvsp[(3) - (3)].str), "nodefault")!=0 3267 && strcmp((yyvsp[(3) - (3)].str), "typetransparent")!=0) 3268 yyerror("local-zone type: expected static, deny, " 3269 "refuse, redirect, transparent, " 3270 "typetransparent or nodefault"); 3271 else if(strcmp((yyvsp[(3) - (3)].str), "nodefault")==0) { 3272 if(!cfg_strlist_insert(&cfg_parser->cfg-> 3273 local_zones_nodefault, (yyvsp[(2) - (3)].str))) 3274 fatal_exit("out of memory adding local-zone"); 3275 free((yyvsp[(3) - (3)].str)); 3276 } else { 3277 if(!cfg_str2list_insert(&cfg_parser->cfg->local_zones, 3278 (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str))) 3279 fatal_exit("out of memory adding local-zone"); 3280 } 3281 } 3282 break; 3283 3284 case 219: 3285 /* Line 1787 of yacc.c */ 3286 #line 1079 "util/configparser.y" 3287 { 3288 OUTYY(("P(server_local_data:%s)\n", (yyvsp[(2) - (2)].str))); 3289 if(!cfg_strlist_insert(&cfg_parser->cfg->local_data, (yyvsp[(2) - (2)].str))) 3290 fatal_exit("out of memory adding local-data"); 3291 } 3292 break; 3293 3294 case 220: 3295 /* Line 1787 of yacc.c */ 3296 #line 1086 "util/configparser.y" 3297 { 3298 char* ptr; 3299 OUTYY(("P(server_local_data_ptr:%s)\n", (yyvsp[(2) - (2)].str))); 3300 ptr = cfg_ptr_reverse((yyvsp[(2) - (2)].str)); 3301 free((yyvsp[(2) - (2)].str)); 3302 if(ptr) { 3303 if(!cfg_strlist_insert(&cfg_parser->cfg-> 3304 local_data, ptr)) 3305 fatal_exit("out of memory adding local-data"); 3306 } else { 3307 yyerror("local-data-ptr could not be reversed"); 3308 } 3309 } 3310 break; 3311 3312 case 221: 3313 /* Line 1787 of yacc.c */ 3314 #line 1101 "util/configparser.y" 3315 { 3316 OUTYY(("P(server_minimal_responses:%s)\n", (yyvsp[(2) - (2)].str))); 3317 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 3318 yyerror("expected yes or no."); 3319 else cfg_parser->cfg->minimal_responses = 3320 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 3321 free((yyvsp[(2) - (2)].str)); 3322 } 3323 break; 3324 3325 case 222: 3326 /* Line 1787 of yacc.c */ 3327 #line 1111 "util/configparser.y" 3328 { 3329 OUTYY(("P(server_rrset_roundrobin:%s)\n", (yyvsp[(2) - (2)].str))); 3330 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 3331 yyerror("expected yes or no."); 3332 else cfg_parser->cfg->rrset_roundrobin = 3333 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 3334 free((yyvsp[(2) - (2)].str)); 3335 } 3336 break; 3337 3338 case 223: 3339 /* Line 1787 of yacc.c */ 3340 #line 1121 "util/configparser.y" 3341 { 3342 OUTYY(("P(name:%s)\n", (yyvsp[(2) - (2)].str))); 3343 if(cfg_parser->cfg->stubs->name) 3344 yyerror("stub name override, there must be one name " 3345 "for one stub-zone"); 3346 free(cfg_parser->cfg->stubs->name); 3347 cfg_parser->cfg->stubs->name = (yyvsp[(2) - (2)].str); 3348 } 3349 break; 3350 3351 case 224: 3352 /* Line 1787 of yacc.c */ 3353 #line 1131 "util/configparser.y" 3354 { 3355 OUTYY(("P(stub-host:%s)\n", (yyvsp[(2) - (2)].str))); 3356 if(!cfg_strlist_insert(&cfg_parser->cfg->stubs->hosts, (yyvsp[(2) - (2)].str))) 3357 yyerror("out of memory"); 3358 } 3359 break; 3360 3361 case 225: 3362 /* Line 1787 of yacc.c */ 3363 #line 1138 "util/configparser.y" 3364 { 3365 OUTYY(("P(stub-addr:%s)\n", (yyvsp[(2) - (2)].str))); 3366 if(!cfg_strlist_insert(&cfg_parser->cfg->stubs->addrs, (yyvsp[(2) - (2)].str))) 3367 yyerror("out of memory"); 3368 } 3369 break; 3370 3371 case 226: 3372 /* Line 1787 of yacc.c */ 3373 #line 1145 "util/configparser.y" 3374 { 3375 OUTYY(("P(stub-first:%s)\n", (yyvsp[(2) - (2)].str))); 3376 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 3377 yyerror("expected yes or no."); 3378 else cfg_parser->cfg->stubs->isfirst=(strcmp((yyvsp[(2) - (2)].str), "yes")==0); 3379 free((yyvsp[(2) - (2)].str)); 3380 } 3381 break; 3382 3383 case 227: 3384 /* Line 1787 of yacc.c */ 3385 #line 1154 "util/configparser.y" 3386 { 3387 OUTYY(("P(stub-prime:%s)\n", (yyvsp[(2) - (2)].str))); 3388 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 3389 yyerror("expected yes or no."); 3390 else cfg_parser->cfg->stubs->isprime = 3391 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 3392 free((yyvsp[(2) - (2)].str)); 3393 } 3394 break; 3395 3396 case 228: 3397 /* Line 1787 of yacc.c */ 3398 #line 1164 "util/configparser.y" 3399 { 3400 OUTYY(("P(name:%s)\n", (yyvsp[(2) - (2)].str))); 3401 if(cfg_parser->cfg->forwards->name) 3402 yyerror("forward name override, there must be one " 3403 "name for one forward-zone"); 3404 free(cfg_parser->cfg->forwards->name); 3405 cfg_parser->cfg->forwards->name = (yyvsp[(2) - (2)].str); 3406 } 3407 break; 3408 3409 case 229: 3410 /* Line 1787 of yacc.c */ 3411 #line 1174 "util/configparser.y" 3412 { 3413 OUTYY(("P(forward-host:%s)\n", (yyvsp[(2) - (2)].str))); 3414 if(!cfg_strlist_insert(&cfg_parser->cfg->forwards->hosts, (yyvsp[(2) - (2)].str))) 3415 yyerror("out of memory"); 3416 } 3417 break; 3418 3419 case 230: 3420 /* Line 1787 of yacc.c */ 3421 #line 1181 "util/configparser.y" 3422 { 3423 OUTYY(("P(forward-addr:%s)\n", (yyvsp[(2) - (2)].str))); 3424 if(!cfg_strlist_insert(&cfg_parser->cfg->forwards->addrs, (yyvsp[(2) - (2)].str))) 3425 yyerror("out of memory"); 3426 } 3427 break; 3428 3429 case 231: 3430 /* Line 1787 of yacc.c */ 3431 #line 1188 "util/configparser.y" 3432 { 3433 OUTYY(("P(forward-first:%s)\n", (yyvsp[(2) - (2)].str))); 3434 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 3435 yyerror("expected yes or no."); 3436 else cfg_parser->cfg->forwards->isfirst=(strcmp((yyvsp[(2) - (2)].str), "yes")==0); 3437 free((yyvsp[(2) - (2)].str)); 3438 } 3439 break; 3440 3441 case 232: 3442 /* Line 1787 of yacc.c */ 3443 #line 1197 "util/configparser.y" 3444 { 3445 OUTYY(("\nP(remote-control:)\n")); 3446 } 3447 break; 3448 3449 case 242: 3450 /* Line 1787 of yacc.c */ 3451 #line 1208 "util/configparser.y" 3452 { 3453 OUTYY(("P(control_enable:%s)\n", (yyvsp[(2) - (2)].str))); 3454 if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0) 3455 yyerror("expected yes or no."); 3456 else cfg_parser->cfg->remote_control_enable = 3457 (strcmp((yyvsp[(2) - (2)].str), "yes")==0); 3458 free((yyvsp[(2) - (2)].str)); 3459 } 3460 break; 3461 3462 case 243: 3463 /* Line 1787 of yacc.c */ 3464 #line 1218 "util/configparser.y" 3465 { 3466 OUTYY(("P(control_port:%s)\n", (yyvsp[(2) - (2)].str))); 3467 if(atoi((yyvsp[(2) - (2)].str)) == 0) 3468 yyerror("control port number expected"); 3469 else cfg_parser->cfg->control_port = atoi((yyvsp[(2) - (2)].str)); 3470 free((yyvsp[(2) - (2)].str)); 3471 } 3472 break; 3473 3474 case 244: 3475 /* Line 1787 of yacc.c */ 3476 #line 1227 "util/configparser.y" 3477 { 3478 OUTYY(("P(control_interface:%s)\n", (yyvsp[(2) - (2)].str))); 3479 if(!cfg_strlist_insert(&cfg_parser->cfg->control_ifs, (yyvsp[(2) - (2)].str))) 3480 yyerror("out of memory"); 3481 } 3482 break; 3483 3484 case 245: 3485 /* Line 1787 of yacc.c */ 3486 #line 1234 "util/configparser.y" 3487 { 3488 OUTYY(("P(rc_server_key_file:%s)\n", (yyvsp[(2) - (2)].str))); 3489 free(cfg_parser->cfg->server_key_file); 3490 cfg_parser->cfg->server_key_file = (yyvsp[(2) - (2)].str); 3491 } 3492 break; 3493 3494 case 246: 3495 /* Line 1787 of yacc.c */ 3496 #line 1241 "util/configparser.y" 3497 { 3498 OUTYY(("P(rc_server_cert_file:%s)\n", (yyvsp[(2) - (2)].str))); 3499 free(cfg_parser->cfg->server_cert_file); 3500 cfg_parser->cfg->server_cert_file = (yyvsp[(2) - (2)].str); 3501 } 3502 break; 3503 3504 case 247: 3505 /* Line 1787 of yacc.c */ 3506 #line 1248 "util/configparser.y" 3507 { 3508 OUTYY(("P(rc_control_key_file:%s)\n", (yyvsp[(2) - (2)].str))); 3509 free(cfg_parser->cfg->control_key_file); 3510 cfg_parser->cfg->control_key_file = (yyvsp[(2) - (2)].str); 3511 } 3512 break; 3513 3514 case 248: 3515 /* Line 1787 of yacc.c */ 3516 #line 1255 "util/configparser.y" 3517 { 3518 OUTYY(("P(rc_control_cert_file:%s)\n", (yyvsp[(2) - (2)].str))); 3519 free(cfg_parser->cfg->control_cert_file); 3520 cfg_parser->cfg->control_cert_file = (yyvsp[(2) - (2)].str); 3521 } 3522 break; 3523 3524 case 249: 3525 /* Line 1787 of yacc.c */ 3526 #line 1262 "util/configparser.y" 3527 { 3528 OUTYY(("\nP(python:)\n")); 3529 } 3530 break; 3531 3532 case 253: 3533 /* Line 1787 of yacc.c */ 3534 #line 1271 "util/configparser.y" 3535 { 3536 OUTYY(("P(python-script:%s)\n", (yyvsp[(2) - (2)].str))); 3537 free(cfg_parser->cfg->python_script); 3538 cfg_parser->cfg->python_script = (yyvsp[(2) - (2)].str); 3539 } 3540 break; 3541 3542 3543 /* Line 1787 of yacc.c */ 3544 #line 3545 "util/configparser.c" 3545 default: break; 3546 } 3547 /* User semantic actions sometimes alter yychar, and that requires 3548 that yytoken be updated with the new translation. We take the 3549 approach of translating immediately before every use of yytoken. 3550 One alternative is translating here after every semantic action, 3551 but that translation would be missed if the semantic action invokes 3552 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 3553 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 3554 incorrect destructor might then be invoked immediately. In the 3555 case of YYERROR or YYBACKUP, subsequent parser actions might lead 3556 to an incorrect destructor call or verbose syntax error message 3557 before the lookahead is translated. */ 3558 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 3559 3560 YYPOPSTACK (yylen); 3561 yylen = 0; 3562 YY_STACK_PRINT (yyss, yyssp); 3563 3564 *++yyvsp = yyval; 3565 3566 /* Now `shift' the result of the reduction. Determine what state 3567 that goes to, based on the state we popped back to and the rule 3568 number reduced by. */ 3569 3570 yyn = yyr1[yyn]; 3571 3572 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 3573 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 3574 yystate = yytable[yystate]; 3575 else 3576 yystate = yydefgoto[yyn - YYNTOKENS]; 3577 3578 goto yynewstate; 3579 3580 3581 /*------------------------------------. 3582 | yyerrlab -- here on detecting error | 3583 `------------------------------------*/ 3584 yyerrlab: 3585 /* Make sure we have latest lookahead translation. See comments at 3586 user semantic actions for why this is necessary. */ 3587 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 3588 3589 /* If not already recovering from an error, report this error. */ 3590 if (!yyerrstatus) 3591 { 3592 ++yynerrs; 3593 #if ! YYERROR_VERBOSE 3594 yyerror (YY_("syntax error")); 3595 #else 3596 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 3597 yyssp, yytoken) 3598 { 3599 char const *yymsgp = YY_("syntax error"); 3600 int yysyntax_error_status; 3601 yysyntax_error_status = YYSYNTAX_ERROR; 3602 if (yysyntax_error_status == 0) 3603 yymsgp = yymsg; 3604 else if (yysyntax_error_status == 1) 3605 { 3606 if (yymsg != yymsgbuf) 3607 YYSTACK_FREE (yymsg); 3608 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 3609 if (!yymsg) 3610 { 3611 yymsg = yymsgbuf; 3612 yymsg_alloc = sizeof yymsgbuf; 3613 yysyntax_error_status = 2; 3614 } 3615 else 3616 { 3617 yysyntax_error_status = YYSYNTAX_ERROR; 3618 yymsgp = yymsg; 3619 } 3620 } 3621 yyerror (yymsgp); 3622 if (yysyntax_error_status == 2) 3623 goto yyexhaustedlab; 3624 } 3625 # undef YYSYNTAX_ERROR 3626 #endif 3627 } 3628 3629 3630 3631 if (yyerrstatus == 3) 3632 { 3633 /* If just tried and failed to reuse lookahead token after an 3634 error, discard it. */ 3635 3636 if (yychar <= YYEOF) 3637 { 3638 /* Return failure if at end of input. */ 3639 if (yychar == YYEOF) 3640 YYABORT; 3641 } 3642 else 3643 { 3644 yydestruct ("Error: discarding", 3645 yytoken, &yylval); 3646 yychar = YYEMPTY; 3647 } 3648 } 3649 3650 /* Else will try to reuse lookahead token after shifting the error 3651 token. */ 3652 goto yyerrlab1; 3653 3654 3655 /*---------------------------------------------------. 3656 | yyerrorlab -- error raised explicitly by YYERROR. | 3657 `---------------------------------------------------*/ 3658 yyerrorlab: 3659 3660 /* Pacify compilers like GCC when the user code never invokes 3661 YYERROR and the label yyerrorlab therefore never appears in user 3662 code. */ 3663 if (/*CONSTCOND*/ 0) 3664 goto yyerrorlab; 3665 3666 /* Do not reclaim the symbols of the rule which action triggered 3667 this YYERROR. */ 3668 YYPOPSTACK (yylen); 3669 yylen = 0; 3670 YY_STACK_PRINT (yyss, yyssp); 3671 yystate = *yyssp; 3672 goto yyerrlab1; 3673 3674 3675 /*-------------------------------------------------------------. 3676 | yyerrlab1 -- common code for both syntax error and YYERROR. | 3677 `-------------------------------------------------------------*/ 3678 yyerrlab1: 3679 yyerrstatus = 3; /* Each real token shifted decrements this. */ 3680 3681 for (;;) 3682 { 3683 yyn = yypact[yystate]; 3684 if (!yypact_value_is_default (yyn)) 3685 { 3686 yyn += YYTERROR; 3687 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 3688 { 3689 yyn = yytable[yyn]; 3690 if (0 < yyn) 3691 break; 3692 } 3693 } 3694 3695 /* Pop the current state because it cannot handle the error token. */ 3696 if (yyssp == yyss) 3697 YYABORT; 3698 3699 3700 yydestruct ("Error: popping", 3701 yystos[yystate], yyvsp); 3702 YYPOPSTACK (1); 3703 yystate = *yyssp; 3704 YY_STACK_PRINT (yyss, yyssp); 3705 } 3706 3707 *++yyvsp = yylval; 3708 3709 3710 /* Shift the error token. */ 3711 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 3712 3713 yystate = yyn; 3714 goto yynewstate; 3715 3716 3717 /*-------------------------------------. 3718 | yyacceptlab -- YYACCEPT comes here. | 3719 `-------------------------------------*/ 3720 yyacceptlab: 3721 yyresult = 0; 3722 goto yyreturn; 3723 3724 /*-----------------------------------. 3725 | yyabortlab -- YYABORT comes here. | 3726 `-----------------------------------*/ 3727 yyabortlab: 3728 yyresult = 1; 3729 goto yyreturn; 3730 3731 #if !defined yyoverflow || YYERROR_VERBOSE 3732 /*-------------------------------------------------. 3733 | yyexhaustedlab -- memory exhaustion comes here. | 3734 `-------------------------------------------------*/ 3735 yyexhaustedlab: 3736 yyerror (YY_("memory exhausted")); 3737 yyresult = 2; 3738 /* Fall through. */ 3739 #endif 3740 3741 yyreturn: 3742 if (yychar != YYEMPTY) 3743 { 3744 /* Make sure we have latest lookahead translation. See comments at 3745 user semantic actions for why this is necessary. */ 3746 yytoken = YYTRANSLATE (yychar); 3747 yydestruct ("Cleanup: discarding lookahead", 3748 yytoken, &yylval); 3749 } 3750 /* Do not reclaim the symbols of the rule which action triggered 3751 this YYABORT or YYACCEPT. */ 3752 YYPOPSTACK (yylen); 3753 YY_STACK_PRINT (yyss, yyssp); 3754 while (yyssp != yyss) 3755 { 3756 yydestruct ("Cleanup: popping", 3757 yystos[*yyssp], yyvsp); 3758 YYPOPSTACK (1); 3759 } 3760 #ifndef yyoverflow 3761 if (yyss != yyssa) 3762 YYSTACK_FREE (yyss); 3763 #endif 3764 #if YYERROR_VERBOSE 3765 if (yymsg != yymsgbuf) 3766 YYSTACK_FREE (yymsg); 3767 #endif 3768 /* Make sure YYID is used. */ 3769 return YYID (yyresult); 3770 } 3771 3772 3773 /* Line 2048 of yacc.c */ 3774 #line 1276 "util/configparser.y" 3775 3776 3777 /* parse helper routines could be here */ 3778 3779