1 /* A Bison parser, made by GNU Bison 3.0.4. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2015 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 "3.0.4" 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 11 "ntp_parser.y" /* yacc.c:339 */ 66 67 #ifdef HAVE_CONFIG_H 68 # include <config.h> 69 #endif 70 71 #include "ntp.h" 72 #include "ntpd.h" 73 #include "ntp_machine.h" 74 #include "ntp_stdlib.h" 75 #include "ntp_filegen.h" 76 #include "ntp_scanner.h" 77 #include "ntp_config.h" 78 #include "ntp_crypto.h" 79 #include "ntp_calendar.h" 80 81 #include "ntpsim.h" /* HMS: Do we really want this all the time? */ 82 /* SK: It might be a good idea to always 83 include the simulator code. That way 84 someone can use the same configuration file 85 for both the simulator and the daemon 86 */ 87 88 #define YYMALLOC emalloc 89 #define YYFREE free 90 #define YYERROR_VERBOSE 91 #define YYMAXDEPTH 1000 /* stop the madness sooner */ 92 void yyerror(const char *msg); 93 94 #ifdef SIM 95 # define ONLY_SIM(a) (a) 96 #else 97 # define ONLY_SIM(a) NULL 98 #endif 99 100 #line 101 "ntp_parser.c" /* yacc.c:339 */ 101 102 # ifndef YY_NULLPTR 103 # if defined __cplusplus && 201103L <= __cplusplus 104 # define YY_NULLPTR nullptr 105 # else 106 # define YY_NULLPTR 0 107 # endif 108 # endif 109 110 /* Enabling verbose error messages. */ 111 #ifdef YYERROR_VERBOSE 112 # undef YYERROR_VERBOSE 113 # define YYERROR_VERBOSE 1 114 #else 115 # define YYERROR_VERBOSE 0 116 #endif 117 118 /* In a future release of Bison, this section will be replaced 119 by #include "y.tab.h". */ 120 #ifndef YY_YY_NTP_PARSER_H_INCLUDED 121 # define YY_YY_NTP_PARSER_H_INCLUDED 122 /* Debug traces. */ 123 #ifndef YYDEBUG 124 # define YYDEBUG 1 125 #endif 126 #if YYDEBUG 127 extern int yydebug; 128 #endif 129 130 /* Token type. */ 131 #ifndef YYTOKENTYPE 132 # define YYTOKENTYPE 133 enum yytokentype 134 { 135 T_Abbrev = 258, 136 T_Age = 259, 137 T_All = 260, 138 T_Allan = 261, 139 T_Allpeers = 262, 140 T_Auth = 263, 141 T_Autokey = 264, 142 T_Automax = 265, 143 T_Average = 266, 144 T_Basedate = 267, 145 T_Bclient = 268, 146 T_Bcpollbstep = 269, 147 T_Beacon = 270, 148 T_Broadcast = 271, 149 T_Broadcastclient = 272, 150 T_Broadcastdelay = 273, 151 T_Burst = 274, 152 T_Calibrate = 275, 153 T_Ceiling = 276, 154 T_Clockstats = 277, 155 T_Cohort = 278, 156 T_ControlKey = 279, 157 T_Crypto = 280, 158 T_Cryptostats = 281, 159 T_Ctl = 282, 160 T_Day = 283, 161 T_Default = 284, 162 T_Digest = 285, 163 T_Disable = 286, 164 T_Discard = 287, 165 T_Dispersion = 288, 166 T_Double = 289, 167 T_Driftfile = 290, 168 T_Drop = 291, 169 T_Dscp = 292, 170 T_Ellipsis = 293, 171 T_Enable = 294, 172 T_End = 295, 173 T_Epeer = 296, 174 T_False = 297, 175 T_File = 298, 176 T_Filegen = 299, 177 T_Filenum = 300, 178 T_Flag1 = 301, 179 T_Flag2 = 302, 180 T_Flag3 = 303, 181 T_Flag4 = 304, 182 T_Flake = 305, 183 T_Floor = 306, 184 T_Freq = 307, 185 T_Fudge = 308, 186 T_Host = 309, 187 T_Huffpuff = 310, 188 T_Iburst = 311, 189 T_Ident = 312, 190 T_Ignore = 313, 191 T_Incalloc = 314, 192 T_Incmem = 315, 193 T_Initalloc = 316, 194 T_Initmem = 317, 195 T_Includefile = 318, 196 T_Integer = 319, 197 T_Interface = 320, 198 T_Intrange = 321, 199 T_Io = 322, 200 T_Ippeerlimit = 323, 201 T_Ipv4 = 324, 202 T_Ipv4_flag = 325, 203 T_Ipv6 = 326, 204 T_Ipv6_flag = 327, 205 T_Kernel = 328, 206 T_Key = 329, 207 T_Keys = 330, 208 T_Keysdir = 331, 209 T_Kod = 332, 210 T_Mssntp = 333, 211 T_Leapfile = 334, 212 T_Leapsmearinterval = 335, 213 T_Limited = 336, 214 T_Link = 337, 215 T_Listen = 338, 216 T_Logconfig = 339, 217 T_Logfile = 340, 218 T_Loopstats = 341, 219 T_Lowpriotrap = 342, 220 T_Manycastclient = 343, 221 T_Manycastserver = 344, 222 T_Mask = 345, 223 T_Maxage = 346, 224 T_Maxclock = 347, 225 T_Maxdepth = 348, 226 T_Maxdist = 349, 227 T_Maxmem = 350, 228 T_Maxpoll = 351, 229 T_Mdnstries = 352, 230 T_Mem = 353, 231 T_Memlock = 354, 232 T_Minclock = 355, 233 T_Mindepth = 356, 234 T_Mindist = 357, 235 T_Minimum = 358, 236 T_Minpoll = 359, 237 T_Minsane = 360, 238 T_Mode = 361, 239 T_Mode7 = 362, 240 T_Monitor = 363, 241 T_Month = 364, 242 T_Mru = 365, 243 T_Multicastclient = 366, 244 T_Nic = 367, 245 T_Nolink = 368, 246 T_Nomodify = 369, 247 T_Nomrulist = 370, 248 T_None = 371, 249 T_Nonvolatile = 372, 250 T_Noepeer = 373, 251 T_Nopeer = 374, 252 T_Noquery = 375, 253 T_Noselect = 376, 254 T_Noserve = 377, 255 T_Notrap = 378, 256 T_Notrust = 379, 257 T_Ntp = 380, 258 T_Ntpport = 381, 259 T_NtpSignDsocket = 382, 260 T_Orphan = 383, 261 T_Orphanwait = 384, 262 T_PCEdigest = 385, 263 T_Panic = 386, 264 T_Peer = 387, 265 T_Peerstats = 388, 266 T_Phone = 389, 267 T_Pid = 390, 268 T_Pidfile = 391, 269 T_Pool = 392, 270 T_Port = 393, 271 T_Preempt = 394, 272 T_Prefer = 395, 273 T_Protostats = 396, 274 T_Pw = 397, 275 T_Randfile = 398, 276 T_Rawstats = 399, 277 T_Refid = 400, 278 T_Requestkey = 401, 279 T_Reset = 402, 280 T_Restrict = 403, 281 T_Revoke = 404, 282 T_Rlimit = 405, 283 T_Saveconfigdir = 406, 284 T_Server = 407, 285 T_Setvar = 408, 286 T_Source = 409, 287 T_Stacksize = 410, 288 T_Statistics = 411, 289 T_Stats = 412, 290 T_Statsdir = 413, 291 T_Step = 414, 292 T_Stepback = 415, 293 T_Stepfwd = 416, 294 T_Stepout = 417, 295 T_Stratum = 418, 296 T_String = 419, 297 T_Sys = 420, 298 T_Sysstats = 421, 299 T_Tick = 422, 300 T_Time1 = 423, 301 T_Time2 = 424, 302 T_Timer = 425, 303 T_Timingstats = 426, 304 T_Tinker = 427, 305 T_Tos = 428, 306 T_Trap = 429, 307 T_True = 430, 308 T_Trustedkey = 431, 309 T_Ttl = 432, 310 T_Type = 433, 311 T_U_int = 434, 312 T_UEcrypto = 435, 313 T_UEcryptonak = 436, 314 T_UEdigest = 437, 315 T_Unconfig = 438, 316 T_Unpeer = 439, 317 T_Version = 440, 318 T_WanderThreshold = 441, 319 T_Week = 442, 320 T_Wildcard = 443, 321 T_Xleave = 444, 322 T_Year = 445, 323 T_Flag = 446, 324 T_EOC = 447, 325 T_Simulate = 448, 326 T_Beep_Delay = 449, 327 T_Sim_Duration = 450, 328 T_Server_Offset = 451, 329 T_Duration = 452, 330 T_Freq_Offset = 453, 331 T_Wander = 454, 332 T_Jitter = 455, 333 T_Prop_Delay = 456, 334 T_Proc_Delay = 457 335 }; 336 #endif 337 /* Tokens. */ 338 #define T_Abbrev 258 339 #define T_Age 259 340 #define T_All 260 341 #define T_Allan 261 342 #define T_Allpeers 262 343 #define T_Auth 263 344 #define T_Autokey 264 345 #define T_Automax 265 346 #define T_Average 266 347 #define T_Basedate 267 348 #define T_Bclient 268 349 #define T_Bcpollbstep 269 350 #define T_Beacon 270 351 #define T_Broadcast 271 352 #define T_Broadcastclient 272 353 #define T_Broadcastdelay 273 354 #define T_Burst 274 355 #define T_Calibrate 275 356 #define T_Ceiling 276 357 #define T_Clockstats 277 358 #define T_Cohort 278 359 #define T_ControlKey 279 360 #define T_Crypto 280 361 #define T_Cryptostats 281 362 #define T_Ctl 282 363 #define T_Day 283 364 #define T_Default 284 365 #define T_Digest 285 366 #define T_Disable 286 367 #define T_Discard 287 368 #define T_Dispersion 288 369 #define T_Double 289 370 #define T_Driftfile 290 371 #define T_Drop 291 372 #define T_Dscp 292 373 #define T_Ellipsis 293 374 #define T_Enable 294 375 #define T_End 295 376 #define T_Epeer 296 377 #define T_False 297 378 #define T_File 298 379 #define T_Filegen 299 380 #define T_Filenum 300 381 #define T_Flag1 301 382 #define T_Flag2 302 383 #define T_Flag3 303 384 #define T_Flag4 304 385 #define T_Flake 305 386 #define T_Floor 306 387 #define T_Freq 307 388 #define T_Fudge 308 389 #define T_Host 309 390 #define T_Huffpuff 310 391 #define T_Iburst 311 392 #define T_Ident 312 393 #define T_Ignore 313 394 #define T_Incalloc 314 395 #define T_Incmem 315 396 #define T_Initalloc 316 397 #define T_Initmem 317 398 #define T_Includefile 318 399 #define T_Integer 319 400 #define T_Interface 320 401 #define T_Intrange 321 402 #define T_Io 322 403 #define T_Ippeerlimit 323 404 #define T_Ipv4 324 405 #define T_Ipv4_flag 325 406 #define T_Ipv6 326 407 #define T_Ipv6_flag 327 408 #define T_Kernel 328 409 #define T_Key 329 410 #define T_Keys 330 411 #define T_Keysdir 331 412 #define T_Kod 332 413 #define T_Mssntp 333 414 #define T_Leapfile 334 415 #define T_Leapsmearinterval 335 416 #define T_Limited 336 417 #define T_Link 337 418 #define T_Listen 338 419 #define T_Logconfig 339 420 #define T_Logfile 340 421 #define T_Loopstats 341 422 #define T_Lowpriotrap 342 423 #define T_Manycastclient 343 424 #define T_Manycastserver 344 425 #define T_Mask 345 426 #define T_Maxage 346 427 #define T_Maxclock 347 428 #define T_Maxdepth 348 429 #define T_Maxdist 349 430 #define T_Maxmem 350 431 #define T_Maxpoll 351 432 #define T_Mdnstries 352 433 #define T_Mem 353 434 #define T_Memlock 354 435 #define T_Minclock 355 436 #define T_Mindepth 356 437 #define T_Mindist 357 438 #define T_Minimum 358 439 #define T_Minpoll 359 440 #define T_Minsane 360 441 #define T_Mode 361 442 #define T_Mode7 362 443 #define T_Monitor 363 444 #define T_Month 364 445 #define T_Mru 365 446 #define T_Multicastclient 366 447 #define T_Nic 367 448 #define T_Nolink 368 449 #define T_Nomodify 369 450 #define T_Nomrulist 370 451 #define T_None 371 452 #define T_Nonvolatile 372 453 #define T_Noepeer 373 454 #define T_Nopeer 374 455 #define T_Noquery 375 456 #define T_Noselect 376 457 #define T_Noserve 377 458 #define T_Notrap 378 459 #define T_Notrust 379 460 #define T_Ntp 380 461 #define T_Ntpport 381 462 #define T_NtpSignDsocket 382 463 #define T_Orphan 383 464 #define T_Orphanwait 384 465 #define T_PCEdigest 385 466 #define T_Panic 386 467 #define T_Peer 387 468 #define T_Peerstats 388 469 #define T_Phone 389 470 #define T_Pid 390 471 #define T_Pidfile 391 472 #define T_Pool 392 473 #define T_Port 393 474 #define T_Preempt 394 475 #define T_Prefer 395 476 #define T_Protostats 396 477 #define T_Pw 397 478 #define T_Randfile 398 479 #define T_Rawstats 399 480 #define T_Refid 400 481 #define T_Requestkey 401 482 #define T_Reset 402 483 #define T_Restrict 403 484 #define T_Revoke 404 485 #define T_Rlimit 405 486 #define T_Saveconfigdir 406 487 #define T_Server 407 488 #define T_Setvar 408 489 #define T_Source 409 490 #define T_Stacksize 410 491 #define T_Statistics 411 492 #define T_Stats 412 493 #define T_Statsdir 413 494 #define T_Step 414 495 #define T_Stepback 415 496 #define T_Stepfwd 416 497 #define T_Stepout 417 498 #define T_Stratum 418 499 #define T_String 419 500 #define T_Sys 420 501 #define T_Sysstats 421 502 #define T_Tick 422 503 #define T_Time1 423 504 #define T_Time2 424 505 #define T_Timer 425 506 #define T_Timingstats 426 507 #define T_Tinker 427 508 #define T_Tos 428 509 #define T_Trap 429 510 #define T_True 430 511 #define T_Trustedkey 431 512 #define T_Ttl 432 513 #define T_Type 433 514 #define T_U_int 434 515 #define T_UEcrypto 435 516 #define T_UEcryptonak 436 517 #define T_UEdigest 437 518 #define T_Unconfig 438 519 #define T_Unpeer 439 520 #define T_Version 440 521 #define T_WanderThreshold 441 522 #define T_Week 442 523 #define T_Wildcard 443 524 #define T_Xleave 444 525 #define T_Year 445 526 #define T_Flag 446 527 #define T_EOC 447 528 #define T_Simulate 448 529 #define T_Beep_Delay 449 530 #define T_Sim_Duration 450 531 #define T_Server_Offset 451 532 #define T_Duration 452 533 #define T_Freq_Offset 453 534 #define T_Wander 454 535 #define T_Jitter 455 536 #define T_Prop_Delay 456 537 #define T_Proc_Delay 457 538 539 /* Value type. */ 540 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 541 542 union YYSTYPE 543 { 544 #line 52 "ntp_parser.y" /* yacc.c:355 */ 545 546 char * String; 547 double Double; 548 int Integer; 549 unsigned U_int; 550 gen_fifo * Generic_fifo; 551 attr_val * Attr_val; 552 attr_val_fifo * Attr_val_fifo; 553 int_fifo * Int_fifo; 554 string_fifo * String_fifo; 555 address_node * Address_node; 556 address_fifo * Address_fifo; 557 setvar_node * Set_var; 558 server_info * Sim_server; 559 server_info_fifo * Sim_server_fifo; 560 script_info * Sim_script; 561 script_info_fifo * Sim_script_fifo; 562 563 #line 564 "ntp_parser.c" /* yacc.c:355 */ 564 }; 565 566 typedef union YYSTYPE YYSTYPE; 567 # define YYSTYPE_IS_TRIVIAL 1 568 # define YYSTYPE_IS_DECLARED 1 569 #endif 570 571 572 extern YYSTYPE yylval; 573 574 int yyparse (void); 575 576 #endif /* !YY_YY_NTP_PARSER_H_INCLUDED */ 577 578 /* Copy the second part of user declarations. */ 579 580 #line 581 "ntp_parser.c" /* yacc.c:358 */ 581 582 #ifdef short 583 # undef short 584 #endif 585 586 #ifdef YYTYPE_UINT8 587 typedef YYTYPE_UINT8 yytype_uint8; 588 #else 589 typedef unsigned char yytype_uint8; 590 #endif 591 592 #ifdef YYTYPE_INT8 593 typedef YYTYPE_INT8 yytype_int8; 594 #else 595 typedef signed char yytype_int8; 596 #endif 597 598 #ifdef YYTYPE_UINT16 599 typedef YYTYPE_UINT16 yytype_uint16; 600 #else 601 typedef unsigned short int yytype_uint16; 602 #endif 603 604 #ifdef YYTYPE_INT16 605 typedef YYTYPE_INT16 yytype_int16; 606 #else 607 typedef short int yytype_int16; 608 #endif 609 610 #ifndef YYSIZE_T 611 # ifdef __SIZE_TYPE__ 612 # define YYSIZE_T __SIZE_TYPE__ 613 # elif defined size_t 614 # define YYSIZE_T size_t 615 # elif ! defined YYSIZE_T 616 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 617 # define YYSIZE_T size_t 618 # else 619 # define YYSIZE_T unsigned int 620 # endif 621 #endif 622 623 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 624 625 #ifndef YY_ 626 # if defined YYENABLE_NLS && YYENABLE_NLS 627 # if ENABLE_NLS 628 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 629 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 630 # endif 631 # endif 632 # ifndef YY_ 633 # define YY_(Msgid) Msgid 634 # endif 635 #endif 636 637 #ifndef YY_ATTRIBUTE 638 # if (defined __GNUC__ \ 639 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ 640 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C 641 # define YY_ATTRIBUTE(Spec) __attribute__(Spec) 642 # else 643 # define YY_ATTRIBUTE(Spec) /* empty */ 644 # endif 645 #endif 646 647 #ifndef YY_ATTRIBUTE_PURE 648 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) 649 #endif 650 651 #ifndef YY_ATTRIBUTE_UNUSED 652 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) 653 #endif 654 655 #if !defined _Noreturn \ 656 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) 657 # if defined _MSC_VER && 1200 <= _MSC_VER 658 # define _Noreturn __declspec (noreturn) 659 # else 660 # define _Noreturn YY_ATTRIBUTE ((__noreturn__)) 661 # endif 662 #endif 663 664 /* Suppress unused-variable warnings by "using" E. */ 665 #if ! defined lint || defined __GNUC__ 666 # define YYUSE(E) ((void) (E)) 667 #else 668 # define YYUSE(E) /* empty */ 669 #endif 670 671 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ 672 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 673 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 674 _Pragma ("GCC diagnostic push") \ 675 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ 676 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 677 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 678 _Pragma ("GCC diagnostic pop") 679 #else 680 # define YY_INITIAL_VALUE(Value) Value 681 #endif 682 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 683 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 684 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 685 #endif 686 #ifndef YY_INITIAL_VALUE 687 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 688 #endif 689 690 691 #if ! defined yyoverflow || YYERROR_VERBOSE 692 693 /* The parser invokes alloca or malloc; define the necessary symbols. */ 694 695 # ifdef YYSTACK_USE_ALLOCA 696 # if YYSTACK_USE_ALLOCA 697 # ifdef __GNUC__ 698 # define YYSTACK_ALLOC __builtin_alloca 699 # elif defined __BUILTIN_VA_ARG_INCR 700 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 701 # elif defined _AIX 702 # define YYSTACK_ALLOC __alloca 703 # elif defined _MSC_VER 704 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 705 # define alloca _alloca 706 # else 707 # define YYSTACK_ALLOC alloca 708 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 709 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 710 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 711 # ifndef EXIT_SUCCESS 712 # define EXIT_SUCCESS 0 713 # endif 714 # endif 715 # endif 716 # endif 717 # endif 718 719 # ifdef YYSTACK_ALLOC 720 /* Pacify GCC's 'empty if-body' warning. */ 721 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 722 # ifndef YYSTACK_ALLOC_MAXIMUM 723 /* The OS might guarantee only one guard page at the bottom of the stack, 724 and a page size can be as small as 4096 bytes. So we cannot safely 725 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 726 to allow for a few compiler-allocated temporary stack slots. */ 727 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 728 # endif 729 # else 730 # define YYSTACK_ALLOC YYMALLOC 731 # define YYSTACK_FREE YYFREE 732 # ifndef YYSTACK_ALLOC_MAXIMUM 733 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 734 # endif 735 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 736 && ! ((defined YYMALLOC || defined malloc) \ 737 && (defined YYFREE || defined free))) 738 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 739 # ifndef EXIT_SUCCESS 740 # define EXIT_SUCCESS 0 741 # endif 742 # endif 743 # ifndef YYMALLOC 744 # define YYMALLOC malloc 745 # if ! defined malloc && ! defined EXIT_SUCCESS 746 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 747 # endif 748 # endif 749 # ifndef YYFREE 750 # define YYFREE free 751 # if ! defined free && ! defined EXIT_SUCCESS 752 void free (void *); /* INFRINGES ON USER NAME SPACE */ 753 # endif 754 # endif 755 # endif 756 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 757 758 759 #if (! defined yyoverflow \ 760 && (! defined __cplusplus \ 761 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 762 763 /* A type that is properly aligned for any stack member. */ 764 union yyalloc 765 { 766 yytype_int16 yyss_alloc; 767 YYSTYPE yyvs_alloc; 768 }; 769 770 /* The size of the maximum gap between one aligned stack and the next. */ 771 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 772 773 /* The size of an array large to enough to hold all stacks, each with 774 N elements. */ 775 # define YYSTACK_BYTES(N) \ 776 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 777 + YYSTACK_GAP_MAXIMUM) 778 779 # define YYCOPY_NEEDED 1 780 781 /* Relocate STACK from its old location to the new one. The 782 local variables YYSIZE and YYSTACKSIZE give the old and new number of 783 elements in the stack, and YYPTR gives the new location of the 784 stack. Advance YYPTR to a properly aligned location for the next 785 stack. */ 786 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 787 do \ 788 { \ 789 YYSIZE_T yynewbytes; \ 790 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 791 Stack = &yyptr->Stack_alloc; \ 792 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 793 yyptr += yynewbytes / sizeof (*yyptr); \ 794 } \ 795 while (0) 796 797 #endif 798 799 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 800 /* Copy COUNT objects from SRC to DST. The source and destination do 801 not overlap. */ 802 # ifndef YYCOPY 803 # if defined __GNUC__ && 1 < __GNUC__ 804 # define YYCOPY(Dst, Src, Count) \ 805 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) 806 # else 807 # define YYCOPY(Dst, Src, Count) \ 808 do \ 809 { \ 810 YYSIZE_T yyi; \ 811 for (yyi = 0; yyi < (Count); yyi++) \ 812 (Dst)[yyi] = (Src)[yyi]; \ 813 } \ 814 while (0) 815 # endif 816 # endif 817 #endif /* !YYCOPY_NEEDED */ 818 819 /* YYFINAL -- State number of the termination state. */ 820 #define YYFINAL 216 821 /* YYLAST -- Last index in YYTABLE. */ 822 #define YYLAST 662 823 824 /* YYNTOKENS -- Number of terminals. */ 825 #define YYNTOKENS 208 826 /* YYNNTS -- Number of nonterminals. */ 827 #define YYNNTS 107 828 /* YYNRULES -- Number of rules. */ 829 #define YYNRULES 324 830 /* YYNSTATES -- Number of states. */ 831 #define YYNSTATES 436 832 833 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned 834 by yylex, with out-of-bounds checking. */ 835 #define YYUNDEFTOK 2 836 #define YYMAXUTOK 457 837 838 #define YYTRANSLATE(YYX) \ 839 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 840 841 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 842 as returned by yylex, without out-of-bounds checking. */ 843 static const yytype_uint8 yytranslate[] = 844 { 845 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 846 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 847 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 848 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 849 204, 205, 2, 2, 2, 2, 2, 2, 2, 2, 850 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 851 2, 203, 2, 2, 2, 2, 2, 2, 2, 2, 852 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 853 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 854 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 855 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 856 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 857 2, 2, 2, 206, 2, 207, 2, 2, 2, 2, 858 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 859 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 860 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 861 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 862 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 863 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 864 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 865 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 866 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 867 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 868 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 869 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 870 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 871 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 872 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 873 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 874 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 875 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 876 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 877 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 878 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 879 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 880 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 881 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 882 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 883 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 884 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 885 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 886 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 887 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 888 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 889 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 890 195, 196, 197, 198, 199, 200, 201, 202 891 }; 892 893 #if YYDEBUG 894 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 895 static const yytype_uint16 yyrline[] = 896 { 897 0, 378, 378, 382, 383, 384, 399, 400, 401, 402, 898 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 899 420, 430, 431, 432, 433, 434, 438, 439, 444, 449, 900 451, 457, 458, 466, 467, 468, 472, 477, 478, 479, 901 480, 481, 482, 483, 484, 488, 490, 495, 496, 497, 902 498, 499, 500, 504, 509, 518, 528, 529, 539, 541, 903 543, 545, 556, 563, 565, 570, 572, 574, 576, 578, 904 588, 594, 595, 603, 605, 617, 618, 619, 620, 621, 905 630, 635, 640, 648, 650, 652, 654, 659, 660, 661, 906 662, 663, 664, 665, 666, 667, 671, 672, 681, 683, 907 692, 702, 707, 715, 716, 717, 718, 719, 720, 721, 908 722, 727, 728, 736, 746, 755, 770, 775, 776, 780, 909 781, 785, 786, 787, 788, 789, 790, 791, 800, 804, 910 808, 816, 824, 832, 847, 862, 875, 876, 896, 897, 911 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 912 915, 916, 917, 918, 919, 920, 921, 925, 930, 938, 913 943, 944, 945, 949, 954, 962, 967, 968, 969, 970, 914 971, 972, 973, 974, 982, 992, 997, 1005, 1007, 1009, 915 1018, 1020, 1025, 1026, 1030, 1031, 1032, 1033, 1041, 1046, 916 1051, 1059, 1064, 1065, 1066, 1075, 1077, 1082, 1087, 1095, 917 1097, 1114, 1115, 1116, 1117, 1118, 1119, 1123, 1124, 1125, 918 1126, 1127, 1128, 1136, 1141, 1146, 1154, 1159, 1160, 1161, 919 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1177, 1178, 1179, 920 1186, 1193, 1200, 1216, 1235, 1237, 1239, 1241, 1243, 1245, 921 1252, 1257, 1258, 1259, 1263, 1267, 1276, 1277, 1281, 1282, 922 1283, 1287, 1298, 1316, 1328, 1333, 1335, 1340, 1341, 1349, 923 1351, 1359, 1364, 1372, 1397, 1404, 1414, 1415, 1419, 1420, 924 1421, 1422, 1426, 1427, 1428, 1432, 1437, 1442, 1450, 1451, 925 1452, 1453, 1454, 1455, 1456, 1466, 1471, 1479, 1484, 1492, 926 1494, 1498, 1503, 1508, 1516, 1521, 1529, 1538, 1539, 1543, 927 1544, 1548, 1556, 1574, 1578, 1583, 1591, 1596, 1597, 1601, 928 1606, 1614, 1619, 1624, 1629, 1634, 1642, 1647, 1652, 1660, 929 1665, 1666, 1667, 1668, 1669 930 }; 931 #endif 932 933 #if YYDEBUG || YYERROR_VERBOSE || 1 934 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 935 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 936 static const char *const yytname[] = 937 { 938 "$end", "error", "$undefined", "T_Abbrev", "T_Age", "T_All", "T_Allan", 939 "T_Allpeers", "T_Auth", "T_Autokey", "T_Automax", "T_Average", 940 "T_Basedate", "T_Bclient", "T_Bcpollbstep", "T_Beacon", "T_Broadcast", 941 "T_Broadcastclient", "T_Broadcastdelay", "T_Burst", "T_Calibrate", 942 "T_Ceiling", "T_Clockstats", "T_Cohort", "T_ControlKey", "T_Crypto", 943 "T_Cryptostats", "T_Ctl", "T_Day", "T_Default", "T_Digest", "T_Disable", 944 "T_Discard", "T_Dispersion", "T_Double", "T_Driftfile", "T_Drop", 945 "T_Dscp", "T_Ellipsis", "T_Enable", "T_End", "T_Epeer", "T_False", 946 "T_File", "T_Filegen", "T_Filenum", "T_Flag1", "T_Flag2", "T_Flag3", 947 "T_Flag4", "T_Flake", "T_Floor", "T_Freq", "T_Fudge", "T_Host", 948 "T_Huffpuff", "T_Iburst", "T_Ident", "T_Ignore", "T_Incalloc", 949 "T_Incmem", "T_Initalloc", "T_Initmem", "T_Includefile", "T_Integer", 950 "T_Interface", "T_Intrange", "T_Io", "T_Ippeerlimit", "T_Ipv4", 951 "T_Ipv4_flag", "T_Ipv6", "T_Ipv6_flag", "T_Kernel", "T_Key", "T_Keys", 952 "T_Keysdir", "T_Kod", "T_Mssntp", "T_Leapfile", "T_Leapsmearinterval", 953 "T_Limited", "T_Link", "T_Listen", "T_Logconfig", "T_Logfile", 954 "T_Loopstats", "T_Lowpriotrap", "T_Manycastclient", "T_Manycastserver", 955 "T_Mask", "T_Maxage", "T_Maxclock", "T_Maxdepth", "T_Maxdist", 956 "T_Maxmem", "T_Maxpoll", "T_Mdnstries", "T_Mem", "T_Memlock", 957 "T_Minclock", "T_Mindepth", "T_Mindist", "T_Minimum", "T_Minpoll", 958 "T_Minsane", "T_Mode", "T_Mode7", "T_Monitor", "T_Month", "T_Mru", 959 "T_Multicastclient", "T_Nic", "T_Nolink", "T_Nomodify", "T_Nomrulist", 960 "T_None", "T_Nonvolatile", "T_Noepeer", "T_Nopeer", "T_Noquery", 961 "T_Noselect", "T_Noserve", "T_Notrap", "T_Notrust", "T_Ntp", "T_Ntpport", 962 "T_NtpSignDsocket", "T_Orphan", "T_Orphanwait", "T_PCEdigest", "T_Panic", 963 "T_Peer", "T_Peerstats", "T_Phone", "T_Pid", "T_Pidfile", "T_Pool", 964 "T_Port", "T_Preempt", "T_Prefer", "T_Protostats", "T_Pw", "T_Randfile", 965 "T_Rawstats", "T_Refid", "T_Requestkey", "T_Reset", "T_Restrict", 966 "T_Revoke", "T_Rlimit", "T_Saveconfigdir", "T_Server", "T_Setvar", 967 "T_Source", "T_Stacksize", "T_Statistics", "T_Stats", "T_Statsdir", 968 "T_Step", "T_Stepback", "T_Stepfwd", "T_Stepout", "T_Stratum", 969 "T_String", "T_Sys", "T_Sysstats", "T_Tick", "T_Time1", "T_Time2", 970 "T_Timer", "T_Timingstats", "T_Tinker", "T_Tos", "T_Trap", "T_True", 971 "T_Trustedkey", "T_Ttl", "T_Type", "T_U_int", "T_UEcrypto", 972 "T_UEcryptonak", "T_UEdigest", "T_Unconfig", "T_Unpeer", "T_Version", 973 "T_WanderThreshold", "T_Week", "T_Wildcard", "T_Xleave", "T_Year", 974 "T_Flag", "T_EOC", "T_Simulate", "T_Beep_Delay", "T_Sim_Duration", 975 "T_Server_Offset", "T_Duration", "T_Freq_Offset", "T_Wander", "T_Jitter", 976 "T_Prop_Delay", "T_Proc_Delay", "'='", "'('", "')'", "'{'", "'}'", 977 "$accept", "configuration", "command_list", "command", "server_command", 978 "client_type", "address", "ip_address", "address_fam", "option_list", 979 "option", "option_flag", "option_flag_keyword", "option_int", 980 "option_int_keyword", "option_str", "option_str_keyword", 981 "unpeer_command", "unpeer_keyword", "other_mode_command", 982 "authentication_command", "crypto_command_list", "crypto_command", 983 "crypto_str_keyword", "orphan_mode_command", "tos_option_list", 984 "tos_option", "tos_option_int_keyword", "tos_option_dbl_keyword", 985 "monitoring_command", "stats_list", "stat", "filegen_option_list", 986 "filegen_option", "link_nolink", "enable_disable", "filegen_type", 987 "access_control_command", "res_ippeerlimit", "ac_flag_list", 988 "access_control_flag", "discard_option_list", "discard_option", 989 "discard_option_keyword", "mru_option_list", "mru_option", 990 "mru_option_keyword", "fudge_command", "fudge_factor_list", 991 "fudge_factor", "fudge_factor_dbl_keyword", "fudge_factor_bool_keyword", 992 "rlimit_command", "rlimit_option_list", "rlimit_option", 993 "rlimit_option_keyword", "system_option_command", "system_option_list", 994 "system_option", "system_option_flag_keyword", 995 "system_option_local_flag_keyword", "tinker_command", 996 "tinker_option_list", "tinker_option", "tinker_option_keyword", 997 "miscellaneous_command", "misc_cmd_dbl_keyword", "misc_cmd_int_keyword", 998 "misc_cmd_str_keyword", "misc_cmd_str_lcl_keyword", "drift_parm", 999 "variable_assign", "t_default_or_zero", "trap_option_list", 1000 "trap_option", "log_config_list", "log_config_command", 1001 "interface_command", "interface_nic", "nic_rule_class", 1002 "nic_rule_action", "reset_command", "counter_set_list", 1003 "counter_set_keyword", "integer_list", "integer_list_range", 1004 "integer_list_range_elt", "integer_range", "string_list", "address_list", 1005 "boolean", "number", "basedate", "simulate_command", "sim_conf_start", 1006 "sim_init_statement_list", "sim_init_statement", "sim_init_keyword", 1007 "sim_server_list", "sim_server", "sim_server_offset", "sim_server_name", 1008 "sim_act_list", "sim_act", "sim_act_stmt_list", "sim_act_stmt", 1009 "sim_act_keyword", YY_NULLPTR 1010 }; 1011 #endif 1012 1013 # ifdef YYPRINT 1014 /* YYTOKNUM[NUM] -- (External) token number corresponding to the 1015 (internal) symbol number NUM (which must be that of a token). */ 1016 static const yytype_uint16 yytoknum[] = 1017 { 1018 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 1019 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 1020 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 1021 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 1022 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 1023 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 1024 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 1025 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 1026 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 1027 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 1028 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 1029 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 1030 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 1031 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 1032 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 1033 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 1034 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 1035 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 1036 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 1037 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 1038 455, 456, 457, 61, 40, 41, 123, 125 1039 }; 1040 # endif 1041 1042 #define YYPACT_NINF -215 1043 1044 #define yypact_value_is_default(Yystate) \ 1045 (!!((Yystate) == (-215))) 1046 1047 #define YYTABLE_NINF -7 1048 1049 #define yytable_value_is_error(Yytable_value) \ 1050 0 1051 1052 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1053 STATE-NUM. */ 1054 static const yytype_int16 yypact[] = 1055 { 1056 11, -175, 2, -215, -215, -215, 3, -215, 93, 9, 1057 -138, -215, 93, -215, 66, -40, -215, -93, -215, -87, 1058 -82, -215, -215, -81, -215, -215, -40, 20, 210, -40, 1059 -215, -215, -70, -215, -67, -215, -215, 34, 6, -13, 1060 47, -6, -215, -215, -48, 66, -45, -215, 412, 483, 1061 -39, -60, 62, -215, -215, -215, 127, 203, -63, -215, 1062 -40, -215, -40, -215, -215, -215, -215, -215, -215, -215, 1063 -215, -215, -215, -11, 75, -24, -22, -215, -18, -215, 1064 -215, -53, -215, -215, -215, 48, -215, -215, -215, -215, 1065 -215, -215, -215, -215, -215, -215, -215, -215, 93, -215, 1066 -215, -215, -215, -215, -215, 9, -215, 82, 120, -215, 1067 93, -215, -215, -215, -215, -215, -215, -215, -215, -215, 1068 -215, -215, -215, 86, -215, 4, 373, -215, -215, -215, 1069 -81, -215, -215, -40, -215, -215, -215, -215, -215, -215, 1070 -215, -215, -215, 210, -215, 106, -40, -215, -215, 15, 1071 -215, -215, -215, -215, -215, -215, -215, -215, 6, -215, 1072 105, 146, 151, 105, -30, -215, -215, -215, -215, -6, 1073 -215, 117, -21, -215, 66, -215, -215, -215, -215, -215, 1074 -215, -215, -215, -215, -215, -215, -215, 412, -215, -11, 1075 22, -215, -215, -215, -20, -215, -215, -215, -215, -215, 1076 -215, -215, -215, 483, -215, 128, -11, -215, -215, -215, 1077 129, -60, -215, -215, -215, 132, -215, 10, -215, -215, 1078 -215, -215, -215, -215, -215, -215, -215, -215, -215, -215, 1079 1, -133, -215, -215, -215, -215, -215, 134, -215, 41, 1080 -215, -215, -215, -215, -28, 42, -215, -215, -215, -215, 1081 45, 148, -215, -215, 86, -215, -11, -20, -215, -215, 1082 -215, -215, -215, -215, -215, -215, 150, -215, 105, 105, 1083 -215, -39, -215, -215, -215, 51, -215, -215, -215, -215, 1084 -215, -215, -215, -215, -215, -215, -215, -57, 178, -215, 1085 -215, -215, 288, -215, -215, -215, -215, -215, -215, -215, 1086 -215, -115, 25, 23, -215, -215, -215, -215, 61, -215, 1087 -215, 21, -215, -215, -215, -215, -215, -215, -215, -215, 1088 -215, -215, 477, -215, -215, 477, 105, 477, 201, -39, 1089 169, -215, 172, -215, -215, -215, -215, -215, -215, -215, 1090 -215, -215, -215, -215, -215, -215, -215, -215, -215, -215, 1091 -215, -215, -59, -215, 77, 36, 52, -100, -215, 39, 1092 -215, -11, -215, -215, -215, -215, -215, -215, -215, -215, 1093 -215, -215, -215, -215, -215, -215, -215, -215, -215, -215, 1094 -215, -215, -215, -215, -215, -215, -215, -215, -215, 477, 1095 477, -215, -215, -215, -215, -215, 43, -215, -215, -215, 1096 -40, -215, -215, -215, 55, -215, 477, -215, -215, 49, 1097 56, -11, 54, -166, -215, 67, -11, -215, -215, -215, 1098 70, 63, -215, -215, -215, -215, -215, 124, 85, 64, 1099 -215, 89, -215, -11, -215, -215 1100 }; 1101 1102 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 1103 Performed when YYTABLE does not specify something else to do. Zero 1104 means the default is an error. */ 1105 static const yytype_uint16 yydefact[] = 1106 { 1107 0, 0, 0, 24, 58, 241, 0, 71, 0, 0, 1108 253, 244, 0, 234, 0, 0, 246, 0, 266, 0, 1109 0, 247, 245, 0, 248, 25, 0, 0, 0, 0, 1110 267, 242, 0, 23, 0, 249, 22, 0, 0, 0, 1111 0, 0, 250, 21, 0, 0, 0, 243, 0, 0, 1112 0, 0, 0, 56, 57, 303, 0, 2, 0, 7, 1113 0, 8, 0, 9, 10, 13, 11, 12, 14, 15, 1114 16, 17, 18, 0, 0, 0, 0, 227, 0, 228, 1115 19, 0, 5, 62, 63, 64, 201, 202, 203, 204, 1116 207, 205, 206, 208, 209, 210, 211, 212, 196, 198, 1117 199, 200, 160, 161, 162, 128, 158, 0, 251, 235, 1118 195, 103, 104, 105, 106, 110, 107, 108, 109, 111, 1119 29, 30, 28, 0, 26, 0, 6, 65, 66, 263, 1120 236, 262, 295, 59, 61, 166, 167, 168, 169, 170, 1121 171, 172, 173, 129, 164, 0, 60, 70, 293, 237, 1122 67, 278, 279, 280, 281, 282, 283, 284, 275, 277, 1123 136, 29, 30, 136, 136, 68, 194, 192, 193, 188, 1124 190, 0, 0, 238, 98, 102, 99, 217, 218, 219, 1125 220, 221, 222, 223, 224, 225, 226, 213, 215, 0, 1126 0, 87, 88, 89, 0, 90, 91, 97, 92, 96, 1127 93, 94, 95, 80, 82, 0, 0, 86, 257, 289, 1128 0, 69, 288, 290, 286, 240, 1, 0, 4, 31, 1129 55, 300, 299, 229, 230, 231, 232, 274, 273, 272, 1130 0, 0, 79, 75, 76, 77, 78, 0, 72, 0, 1131 197, 157, 159, 252, 100, 0, 184, 185, 186, 187, 1132 0, 0, 182, 183, 174, 176, 0, 0, 27, 233, 1133 261, 294, 163, 165, 292, 276, 0, 138, 136, 136, 1134 138, 0, 138, 189, 191, 0, 101, 214, 216, 301, 1135 298, 296, 297, 85, 81, 83, 84, 239, 0, 287, 1136 285, 3, 20, 268, 269, 270, 265, 271, 264, 307, 1137 308, 0, 0, 0, 74, 73, 120, 119, 0, 117, 1138 118, 0, 112, 115, 116, 180, 181, 179, 175, 177, 1139 178, 137, 132, 138, 138, 135, 136, 130, 256, 0, 1140 0, 258, 0, 37, 38, 39, 54, 47, 49, 48, 1141 51, 40, 41, 42, 43, 50, 52, 44, 32, 33, 1142 36, 34, 0, 35, 0, 0, 0, 0, 310, 0, 1143 305, 0, 113, 127, 123, 125, 121, 122, 124, 126, 1144 114, 140, 141, 142, 143, 144, 145, 146, 148, 149, 1145 147, 150, 151, 152, 153, 154, 155, 156, 139, 133, 1146 134, 138, 255, 254, 260, 259, 0, 45, 46, 53, 1147 0, 304, 302, 309, 0, 306, 131, 291, 313, 0, 1148 0, 0, 0, 0, 315, 0, 0, 311, 314, 312, 1149 0, 0, 320, 321, 322, 323, 324, 0, 0, 0, 1150 316, 0, 318, 0, 317, 319 1151 }; 1152 1153 /* YYPGOTO[NTERM-NUM]. */ 1154 static const yytype_int16 yypgoto[] = 1155 { 1156 -215, -215, -215, -23, -215, -215, -15, -49, -215, -215, 1157 -215, -215, -215, -215, -215, -215, -215, -215, -215, -215, 1158 -215, -215, -215, -215, -215, -215, 81, -215, -215, -215, 1159 -215, -38, -215, -215, -215, -215, -215, -215, -154, -214, 1160 -215, -215, 153, -215, -215, 142, -215, -215, -215, 32, 1161 -215, -215, -215, -215, 121, -215, -215, 277, -35, -215, 1162 -215, -215, -215, 107, -215, -215, -215, -215, -215, -215, 1163 -215, -215, -215, -215, -215, -215, 163, -215, -215, -215, 1164 -215, -215, -215, 137, -215, -215, 87, -215, -215, 267, 1165 53, -187, -215, -215, -215, -215, -2, -215, -215, -55, 1166 -215, -215, -215, -109, -215, -121, -215 1167 }; 1168 1169 /* YYDEFGOTO[NTERM-NUM]. */ 1170 static const yytype_int16 yydefgoto[] = 1171 { 1172 -1, 56, 57, 58, 59, 60, 132, 124, 125, 292, 1173 348, 349, 350, 351, 352, 353, 354, 61, 62, 63, 1174 64, 85, 238, 239, 65, 203, 204, 205, 206, 66, 1175 174, 119, 244, 312, 313, 314, 370, 67, 267, 322, 1176 388, 105, 106, 107, 143, 144, 145, 68, 254, 255, 1177 256, 257, 69, 169, 170, 171, 70, 98, 99, 100, 1178 101, 71, 187, 188, 189, 72, 73, 74, 75, 76, 1179 109, 173, 393, 287, 331, 130, 131, 77, 78, 298, 1180 230, 79, 158, 159, 215, 211, 212, 213, 149, 133, 1181 283, 223, 207, 80, 81, 301, 302, 303, 357, 358, 1182 410, 359, 413, 414, 427, 428, 429 1183 }; 1184 1185 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 1186 positive, shift that token. If negative, reduce the rule whose 1187 number is the opposite. If YYTABLE_NINF, syntax error. */ 1188 static const yytype_int16 yytable[] = 1189 { 1190 123, 208, 278, 306, 209, 397, 293, 175, 329, 270, 1191 272, 307, 1, 151, 152, 308, 160, 82, 227, 286, 1192 102, 2, 280, 221, 164, 363, 108, 3, 4, 5, 1193 120, 412, 121, 153, 217, 6, 7, 355, 266, 166, 1194 228, 417, 8, 9, 281, 219, 10, 220, 11, 364, 1195 12, 13, 355, 222, 309, 14, 325, 161, 327, 162, 1196 271, 299, 300, 240, 15, 229, 83, 84, 16, 319, 1197 294, 126, 295, 154, 17, 240, 18, 127, 232, 299, 1198 300, 330, 128, 129, 134, 310, 19, 20, 111, 245, 1199 21, 22, 112, 167, 147, 23, 24, 148, 150, 25, 1200 26, 86, 233, 259, 155, 234, 87, 402, 27, 389, 1201 390, 165, 103, 88, 323, 324, 172, 104, 261, 176, 1202 398, 28, 29, 30, 122, 122, 214, 216, 31, 218, 1203 365, 261, 246, 247, 248, 249, 276, 366, 32, 224, 1204 225, 163, 226, 33, 210, 34, 242, 35, 36, 168, 1205 311, 122, 113, 231, 243, 282, 367, 37, 38, 39, 1206 40, 41, 42, 43, 44, 296, 89, 45, 258, 46, 1207 263, 156, 391, 266, 405, 268, 157, 406, 47, 264, 1208 269, 274, 275, 48, 49, 50, 279, 51, 52, 297, 1209 235, 236, 285, 288, 53, 54, 290, 237, 304, 114, 1210 90, 91, 291, -6, 55, 305, 315, 115, 368, 316, 1211 116, 369, 317, 2, 321, 328, 332, 360, 92, 3, 1212 4, 5, 326, 93, 415, 362, 361, 6, 7, 420, 1213 392, 250, 117, 395, 8, 9, 396, 118, 10, 400, 1214 11, 399, 12, 13, 401, 404, 435, 14, 407, 251, 1215 94, 409, 411, 412, 252, 253, 15, 416, 241, 419, 1216 16, 422, 423, 424, 425, 426, 17, 433, 18, 135, 1217 136, 137, 138, 95, 96, 97, 421, 432, 19, 20, 1218 394, 434, 21, 22, 284, 262, 318, 23, 24, 110, 1219 273, 25, 26, 260, 277, 265, 146, 333, 289, 356, 1220 27, 139, 403, 140, 418, 141, 431, 334, 0, 0, 1221 320, 142, 0, 28, 29, 30, 0, 0, 0, 0, 1222 31, 0, 422, 423, 424, 425, 426, 0, 0, 0, 1223 32, 430, 0, 0, 0, 33, 0, 34, 0, 35, 1224 36, 0, 0, 0, 335, 336, 0, 0, 0, 37, 1225 38, 39, 40, 41, 42, 43, 44, 0, 0, 45, 1226 0, 46, 337, 0, 0, 0, 0, 0, 0, 0, 1227 47, 0, 0, 0, 0, 48, 49, 50, 0, 51, 1228 52, 0, 0, 2, 338, 408, 53, 54, 0, 3, 1229 4, 5, 339, 0, 340, -6, 55, 6, 7, 0, 1230 0, 0, 0, 0, 8, 9, 0, 0, 10, 341, 1231 11, 0, 12, 13, 0, 0, 0, 14, 177, 0, 1232 0, 0, 0, 0, 0, 0, 15, 342, 343, 0, 1233 16, 0, 0, 0, 0, 0, 17, 0, 18, 0, 1234 0, 0, 0, 0, 0, 178, 0, 0, 19, 20, 1235 0, 0, 21, 22, 0, 0, 0, 23, 24, 0, 1236 0, 25, 26, 344, 179, 345, 0, 180, 0, 0, 1237 27, 0, 0, 346, 0, 0, 0, 347, 0, 0, 1238 0, 0, 0, 28, 29, 30, 0, 0, 0, 0, 1239 31, 0, 0, 0, 0, 190, 0, 191, 192, 0, 1240 32, 0, 0, 0, 193, 33, 194, 34, 0, 35, 1241 36, 0, 0, 0, 0, 0, 0, 0, 371, 37, 1242 38, 39, 40, 41, 42, 43, 44, 372, 0, 45, 1243 0, 46, 0, 0, 195, 373, 0, 0, 0, 0, 1244 47, 0, 0, 181, 0, 48, 49, 50, 0, 51, 1245 52, 0, 0, 0, 374, 375, 53, 54, 376, 0, 1246 0, 0, 0, 0, 377, 0, 55, 0, 0, 0, 1247 0, 182, 183, 184, 185, 196, 0, 197, 0, 186, 1248 0, 0, 0, 198, 0, 199, 0, 0, 200, 0, 1249 0, 378, 379, 0, 0, 380, 381, 382, 0, 383, 1250 384, 385, 0, 386, 0, 0, 0, 0, 0, 0, 1251 0, 201, 202, 0, 0, 0, 0, 0, 0, 0, 1252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1253 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1256 0, 0, 387 1257 }; 1258 1259 static const yytype_int16 yycheck[] = 1260 { 1261 15, 50, 189, 31, 64, 64, 5, 45, 65, 163, 1262 164, 39, 1, 7, 8, 43, 29, 192, 36, 206, 1263 11, 10, 42, 34, 39, 4, 164, 16, 17, 18, 1264 70, 197, 72, 27, 57, 24, 25, 152, 68, 45, 1265 58, 207, 31, 32, 64, 60, 35, 62, 37, 28, 1266 39, 40, 152, 64, 82, 44, 270, 70, 272, 72, 1267 90, 194, 195, 98, 53, 83, 64, 64, 57, 256, 1268 69, 164, 71, 67, 63, 110, 65, 164, 30, 194, 1269 195, 138, 164, 164, 64, 113, 75, 76, 22, 3, 1270 79, 80, 26, 99, 164, 84, 85, 164, 64, 88, 1271 89, 8, 54, 126, 98, 57, 13, 207, 97, 323, 1272 324, 64, 103, 20, 268, 269, 164, 108, 133, 164, 1273 179, 110, 111, 112, 164, 164, 64, 0, 117, 192, 1274 109, 146, 46, 47, 48, 49, 174, 116, 127, 64, 1275 164, 154, 164, 132, 204, 134, 64, 136, 137, 155, 1276 178, 164, 86, 206, 34, 175, 135, 146, 147, 148, 1277 149, 150, 151, 152, 153, 164, 73, 156, 164, 158, 1278 64, 165, 326, 68, 361, 29, 170, 391, 167, 164, 1279 29, 64, 203, 172, 173, 174, 164, 176, 177, 188, 1280 142, 143, 64, 64, 183, 184, 64, 149, 64, 133, 1281 107, 108, 192, 192, 193, 164, 164, 141, 187, 164, 1282 144, 190, 64, 10, 64, 164, 38, 192, 125, 16, 1283 17, 18, 271, 130, 411, 164, 203, 24, 25, 416, 1284 29, 145, 166, 64, 31, 32, 64, 171, 35, 203, 1285 37, 164, 39, 40, 192, 206, 433, 44, 205, 163, 1286 157, 196, 203, 197, 168, 169, 53, 203, 105, 192, 1287 57, 198, 199, 200, 201, 202, 63, 203, 65, 59, 1288 60, 61, 62, 180, 181, 182, 206, 192, 75, 76, 1289 329, 192, 79, 80, 203, 143, 254, 84, 85, 12, 1290 169, 88, 89, 130, 187, 158, 29, 9, 211, 301, 1291 97, 91, 357, 93, 413, 95, 427, 19, -1, -1, 1292 257, 101, -1, 110, 111, 112, -1, -1, -1, -1, 1293 117, -1, 198, 199, 200, 201, 202, -1, -1, -1, 1294 127, 207, -1, -1, -1, 132, -1, 134, -1, 136, 1295 137, -1, -1, -1, 56, 57, -1, -1, -1, 146, 1296 147, 148, 149, 150, 151, 152, 153, -1, -1, 156, 1297 -1, 158, 74, -1, -1, -1, -1, -1, -1, -1, 1298 167, -1, -1, -1, -1, 172, 173, 174, -1, 176, 1299 177, -1, -1, 10, 96, 400, 183, 184, -1, 16, 1300 17, 18, 104, -1, 106, 192, 193, 24, 25, -1, 1301 -1, -1, -1, -1, 31, 32, -1, -1, 35, 121, 1302 37, -1, 39, 40, -1, -1, -1, 44, 6, -1, 1303 -1, -1, -1, -1, -1, -1, 53, 139, 140, -1, 1304 57, -1, -1, -1, -1, -1, 63, -1, 65, -1, 1305 -1, -1, -1, -1, -1, 33, -1, -1, 75, 76, 1306 -1, -1, 79, 80, -1, -1, -1, 84, 85, -1, 1307 -1, 88, 89, 175, 52, 177, -1, 55, -1, -1, 1308 97, -1, -1, 185, -1, -1, -1, 189, -1, -1, 1309 -1, -1, -1, 110, 111, 112, -1, -1, -1, -1, 1310 117, -1, -1, -1, -1, 12, -1, 14, 15, -1, 1311 127, -1, -1, -1, 21, 132, 23, 134, -1, 136, 1312 137, -1, -1, -1, -1, -1, -1, -1, 41, 146, 1313 147, 148, 149, 150, 151, 152, 153, 50, -1, 156, 1314 -1, 158, -1, -1, 51, 58, -1, -1, -1, -1, 1315 167, -1, -1, 131, -1, 172, 173, 174, -1, 176, 1316 177, -1, -1, -1, 77, 78, 183, 184, 81, -1, 1317 -1, -1, -1, -1, 87, -1, 193, -1, -1, -1, 1318 -1, 159, 160, 161, 162, 92, -1, 94, -1, 167, 1319 -1, -1, -1, 100, -1, 102, -1, -1, 105, -1, 1320 -1, 114, 115, -1, -1, 118, 119, 120, -1, 122, 1321 123, 124, -1, 126, -1, -1, -1, -1, -1, -1, 1322 -1, 128, 129, -1, -1, -1, -1, -1, -1, -1, 1323 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1324 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1325 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1326 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1327 -1, -1, 185 1328 }; 1329 1330 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1331 symbol of state STATE-NUM. */ 1332 static const yytype_uint16 yystos[] = 1333 { 1334 0, 1, 10, 16, 17, 18, 24, 25, 31, 32, 1335 35, 37, 39, 40, 44, 53, 57, 63, 65, 75, 1336 76, 79, 80, 84, 85, 88, 89, 97, 110, 111, 1337 112, 117, 127, 132, 134, 136, 137, 146, 147, 148, 1338 149, 150, 151, 152, 153, 156, 158, 167, 172, 173, 1339 174, 176, 177, 183, 184, 193, 209, 210, 211, 212, 1340 213, 225, 226, 227, 228, 232, 237, 245, 255, 260, 1341 264, 269, 273, 274, 275, 276, 277, 285, 286, 289, 1342 301, 302, 192, 64, 64, 229, 8, 13, 20, 73, 1343 107, 108, 125, 130, 157, 180, 181, 182, 265, 266, 1344 267, 268, 11, 103, 108, 249, 250, 251, 164, 278, 1345 265, 22, 26, 86, 133, 141, 144, 166, 171, 239, 1346 70, 72, 164, 214, 215, 216, 164, 164, 164, 164, 1347 283, 284, 214, 297, 64, 59, 60, 61, 62, 91, 1348 93, 95, 101, 252, 253, 254, 297, 164, 164, 296, 1349 64, 7, 8, 27, 67, 98, 165, 170, 290, 291, 1350 29, 70, 72, 154, 214, 64, 45, 99, 155, 261, 1351 262, 263, 164, 279, 238, 239, 164, 6, 33, 52, 1352 55, 131, 159, 160, 161, 162, 167, 270, 271, 272, 1353 12, 14, 15, 21, 23, 51, 92, 94, 100, 102, 1354 105, 128, 129, 233, 234, 235, 236, 300, 215, 64, 1355 204, 293, 294, 295, 64, 292, 0, 211, 192, 214, 1356 214, 34, 64, 299, 64, 164, 164, 36, 58, 83, 1357 288, 206, 30, 54, 57, 142, 143, 149, 230, 231, 1358 266, 250, 64, 34, 240, 3, 46, 47, 48, 49, 1359 145, 163, 168, 169, 256, 257, 258, 259, 164, 211, 1360 284, 214, 253, 64, 164, 291, 68, 246, 29, 29, 1361 246, 90, 246, 262, 64, 203, 239, 271, 299, 164, 1362 42, 64, 175, 298, 234, 64, 299, 281, 64, 294, 1363 64, 192, 217, 5, 69, 71, 164, 188, 287, 194, 1364 195, 303, 304, 305, 64, 164, 31, 39, 43, 82, 1365 113, 178, 241, 242, 243, 164, 164, 64, 257, 299, 1366 298, 64, 247, 246, 246, 247, 215, 247, 164, 65, 1367 138, 282, 38, 9, 19, 56, 57, 74, 96, 104, 1368 106, 121, 139, 140, 175, 177, 185, 189, 218, 219, 1369 220, 221, 222, 223, 224, 152, 304, 306, 307, 309, 1370 192, 203, 164, 4, 28, 109, 116, 135, 187, 190, 1371 244, 41, 50, 58, 77, 78, 81, 87, 114, 115, 1372 118, 119, 120, 122, 123, 124, 126, 185, 248, 247, 1373 247, 246, 29, 280, 215, 64, 64, 64, 179, 164, 1374 203, 192, 207, 307, 206, 299, 247, 205, 214, 196, 1375 308, 203, 197, 310, 311, 299, 203, 207, 311, 192, 1376 299, 206, 198, 199, 200, 201, 202, 312, 313, 314, 1377 207, 313, 192, 203, 192, 299 1378 }; 1379 1380 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 1381 static const yytype_uint16 yyr1[] = 1382 { 1383 0, 208, 209, 210, 210, 210, 211, 211, 211, 211, 1384 211, 211, 211, 211, 211, 211, 211, 211, 211, 211, 1385 212, 213, 213, 213, 213, 213, 214, 214, 215, 216, 1386 216, 217, 217, 218, 218, 218, 219, 220, 220, 220, 1387 220, 220, 220, 220, 220, 221, 221, 222, 222, 222, 1388 222, 222, 222, 223, 224, 225, 226, 226, 227, 227, 1389 227, 227, 228, 228, 228, 228, 228, 228, 228, 228, 1390 228, 229, 229, 230, 230, 231, 231, 231, 231, 231, 1391 232, 233, 233, 234, 234, 234, 234, 235, 235, 235, 1392 235, 235, 235, 235, 235, 235, 236, 236, 237, 237, 1393 237, 238, 238, 239, 239, 239, 239, 239, 239, 239, 1394 239, 240, 240, 241, 241, 241, 241, 242, 242, 243, 1395 243, 244, 244, 244, 244, 244, 244, 244, 245, 245, 1396 245, 245, 245, 245, 245, 245, 246, 246, 247, 247, 1397 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 1398 248, 248, 248, 248, 248, 248, 248, 249, 249, 250, 1399 251, 251, 251, 252, 252, 253, 254, 254, 254, 254, 1400 254, 254, 254, 254, 255, 256, 256, 257, 257, 257, 1401 257, 257, 258, 258, 259, 259, 259, 259, 260, 261, 1402 261, 262, 263, 263, 263, 264, 264, 265, 265, 266, 1403 266, 267, 267, 267, 267, 267, 267, 268, 268, 268, 1404 268, 268, 268, 269, 270, 270, 271, 272, 272, 272, 1405 272, 272, 272, 272, 272, 272, 272, 273, 273, 273, 1406 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 1407 273, 274, 274, 274, 275, 275, 276, 276, 277, 277, 1408 277, 278, 278, 278, 279, 280, 280, 281, 281, 282, 1409 282, 283, 283, 284, 285, 285, 286, 286, 287, 287, 1410 287, 287, 288, 288, 288, 289, 290, 290, 291, 291, 1411 291, 291, 291, 291, 291, 292, 292, 293, 293, 294, 1412 294, 295, 296, 296, 297, 297, 298, 298, 298, 299, 1413 299, 300, 301, 302, 303, 303, 304, 305, 305, 306, 1414 306, 307, 308, 309, 310, 310, 311, 312, 312, 313, 1415 314, 314, 314, 314, 314 1416 }; 1417 1418 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ 1419 static const yytype_uint8 yyr2[] = 1420 { 1421 0, 2, 1, 3, 2, 2, 0, 1, 1, 1, 1422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1423 3, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1424 1, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1425 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1426 1, 1, 1, 2, 1, 2, 1, 1, 1, 2, 1427 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1428 2, 0, 2, 2, 2, 1, 1, 1, 1, 1, 1429 2, 2, 1, 2, 2, 2, 1, 1, 1, 1, 1430 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1431 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1432 1, 0, 2, 2, 2, 1, 1, 1, 1, 1, 1433 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1434 4, 6, 4, 5, 5, 4, 0, 2, 0, 2, 1435 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1436 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1437 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1438 1, 1, 1, 1, 3, 2, 1, 2, 2, 2, 1439 2, 2, 1, 1, 1, 1, 1, 1, 2, 2, 1440 1, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1441 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1442 1, 1, 1, 2, 2, 1, 2, 1, 1, 1, 1443 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1444 2, 2, 2, 3, 1, 2, 2, 2, 2, 3, 1445 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1446 1, 1, 2, 0, 4, 1, 0, 0, 2, 2, 1447 2, 2, 1, 1, 3, 3, 1, 1, 1, 1, 1448 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1449 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1450 1, 5, 2, 1, 2, 1, 1, 1, 1, 1, 1451 1, 2, 5, 1, 3, 2, 3, 1, 1, 2, 1452 1, 5, 4, 3, 2, 1, 6, 3, 2, 3, 1453 1, 1, 1, 1, 1 1454 }; 1455 1456 1457 #define yyerrok (yyerrstatus = 0) 1458 #define yyclearin (yychar = YYEMPTY) 1459 #define YYEMPTY (-2) 1460 #define YYEOF 0 1461 1462 #define YYACCEPT goto yyacceptlab 1463 #define YYABORT goto yyabortlab 1464 #define YYERROR goto yyerrorlab 1465 1466 1467 #define YYRECOVERING() (!!yyerrstatus) 1468 1469 #define YYBACKUP(Token, Value) \ 1470 do \ 1471 if (yychar == YYEMPTY) \ 1472 { \ 1473 yychar = (Token); \ 1474 yylval = (Value); \ 1475 YYPOPSTACK (yylen); \ 1476 yystate = *yyssp; \ 1477 goto yybackup; \ 1478 } \ 1479 else \ 1480 { \ 1481 yyerror (YY_("syntax error: cannot back up")); \ 1482 YYERROR; \ 1483 } \ 1484 while (0) 1485 1486 /* Error token number */ 1487 #define YYTERROR 1 1488 #define YYERRCODE 256 1489 1490 1491 1492 /* Enable debugging if requested. */ 1493 #if YYDEBUG 1494 1495 # ifndef YYFPRINTF 1496 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1497 # define YYFPRINTF fprintf 1498 # endif 1499 1500 # define YYDPRINTF(Args) \ 1501 do { \ 1502 if (yydebug) \ 1503 YYFPRINTF Args; \ 1504 } while (0) 1505 1506 /* This macro is provided for backward compatibility. */ 1507 #ifndef YY_LOCATION_PRINT 1508 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1509 #endif 1510 1511 1512 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1513 do { \ 1514 if (yydebug) \ 1515 { \ 1516 YYFPRINTF (stderr, "%s ", Title); \ 1517 yy_symbol_print (stderr, \ 1518 Type, Value); \ 1519 YYFPRINTF (stderr, "\n"); \ 1520 } \ 1521 } while (0) 1522 1523 1524 /*----------------------------------------. 1525 | Print this symbol's value on YYOUTPUT. | 1526 `----------------------------------------*/ 1527 1528 static void 1529 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1530 { 1531 FILE *yyo = yyoutput; 1532 YYUSE (yyo); 1533 if (!yyvaluep) 1534 return; 1535 # ifdef YYPRINT 1536 if (yytype < YYNTOKENS) 1537 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1538 # endif 1539 YYUSE (yytype); 1540 } 1541 1542 1543 /*--------------------------------. 1544 | Print this symbol on YYOUTPUT. | 1545 `--------------------------------*/ 1546 1547 static void 1548 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1549 { 1550 YYFPRINTF (yyoutput, "%s %s (", 1551 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); 1552 1553 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 1554 YYFPRINTF (yyoutput, ")"); 1555 } 1556 1557 /*------------------------------------------------------------------. 1558 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1559 | TOP (included). | 1560 `------------------------------------------------------------------*/ 1561 1562 static void 1563 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 1564 { 1565 YYFPRINTF (stderr, "Stack now"); 1566 for (; yybottom <= yytop; yybottom++) 1567 { 1568 int yybot = *yybottom; 1569 YYFPRINTF (stderr, " %d", yybot); 1570 } 1571 YYFPRINTF (stderr, "\n"); 1572 } 1573 1574 # define YY_STACK_PRINT(Bottom, Top) \ 1575 do { \ 1576 if (yydebug) \ 1577 yy_stack_print ((Bottom), (Top)); \ 1578 } while (0) 1579 1580 1581 /*------------------------------------------------. 1582 | Report that the YYRULE is going to be reduced. | 1583 `------------------------------------------------*/ 1584 1585 static void 1586 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule) 1587 { 1588 unsigned long int yylno = yyrline[yyrule]; 1589 int yynrhs = yyr2[yyrule]; 1590 int yyi; 1591 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1592 yyrule - 1, yylno); 1593 /* The symbols being reduced. */ 1594 for (yyi = 0; yyi < yynrhs; yyi++) 1595 { 1596 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1597 yy_symbol_print (stderr, 1598 yystos[yyssp[yyi + 1 - yynrhs]], 1599 &(yyvsp[(yyi + 1) - (yynrhs)]) 1600 ); 1601 YYFPRINTF (stderr, "\n"); 1602 } 1603 } 1604 1605 # define YY_REDUCE_PRINT(Rule) \ 1606 do { \ 1607 if (yydebug) \ 1608 yy_reduce_print (yyssp, yyvsp, Rule); \ 1609 } while (0) 1610 1611 /* Nonzero means print parse trace. It is left uninitialized so that 1612 multiple parsers can coexist. */ 1613 int yydebug; 1614 #else /* !YYDEBUG */ 1615 # define YYDPRINTF(Args) 1616 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1617 # define YY_STACK_PRINT(Bottom, Top) 1618 # define YY_REDUCE_PRINT(Rule) 1619 #endif /* !YYDEBUG */ 1620 1621 1622 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1623 #ifndef YYINITDEPTH 1624 # define YYINITDEPTH 200 1625 #endif 1626 1627 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1628 if the built-in stack extension method is used). 1629 1630 Do not make this value too large; the results are undefined if 1631 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1632 evaluated with infinite-precision integer arithmetic. */ 1633 1634 #ifndef YYMAXDEPTH 1635 # define YYMAXDEPTH 10000 1636 #endif 1637 1638 1639 #if YYERROR_VERBOSE 1640 1641 # ifndef yystrlen 1642 # if defined __GLIBC__ && defined _STRING_H 1643 # define yystrlen strlen 1644 # else 1645 /* Return the length of YYSTR. */ 1646 static YYSIZE_T 1647 yystrlen (const char *yystr) 1648 { 1649 YYSIZE_T yylen; 1650 for (yylen = 0; yystr[yylen]; yylen++) 1651 continue; 1652 return yylen; 1653 } 1654 # endif 1655 # endif 1656 1657 # ifndef yystpcpy 1658 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1659 # define yystpcpy stpcpy 1660 # else 1661 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1662 YYDEST. */ 1663 static char * 1664 yystpcpy (char *yydest, const char *yysrc) 1665 { 1666 char *yyd = yydest; 1667 const char *yys = yysrc; 1668 1669 while ((*yyd++ = *yys++) != '\0') 1670 continue; 1671 1672 return yyd - 1; 1673 } 1674 # endif 1675 # endif 1676 1677 # ifndef yytnamerr 1678 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1679 quotes and backslashes, so that it's suitable for yyerror. The 1680 heuristic is that double-quoting is unnecessary unless the string 1681 contains an apostrophe, a comma, or backslash (other than 1682 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1683 null, do not copy; instead, return the length of what the result 1684 would have been. */ 1685 static YYSIZE_T 1686 yytnamerr (char *yyres, const char *yystr) 1687 { 1688 if (*yystr == '"') 1689 { 1690 YYSIZE_T yyn = 0; 1691 char const *yyp = yystr; 1692 1693 for (;;) 1694 switch (*++yyp) 1695 { 1696 case '\'': 1697 case ',': 1698 goto do_not_strip_quotes; 1699 1700 case '\\': 1701 if (*++yyp != '\\') 1702 goto do_not_strip_quotes; 1703 /* Fall through. */ 1704 default: 1705 if (yyres) 1706 yyres[yyn] = *yyp; 1707 yyn++; 1708 break; 1709 1710 case '"': 1711 if (yyres) 1712 yyres[yyn] = '\0'; 1713 return yyn; 1714 } 1715 do_not_strip_quotes: ; 1716 } 1717 1718 if (! yyres) 1719 return yystrlen (yystr); 1720 1721 return yystpcpy (yyres, yystr) - yyres; 1722 } 1723 # endif 1724 1725 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1726 about the unexpected token YYTOKEN for the state stack whose top is 1727 YYSSP. 1728 1729 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1730 not large enough to hold the message. In that case, also set 1731 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1732 required number of bytes is too large to store. */ 1733 static int 1734 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1735 yytype_int16 *yyssp, int yytoken) 1736 { 1737 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); 1738 YYSIZE_T yysize = yysize0; 1739 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1740 /* Internationalized format string. */ 1741 const char *yyformat = YY_NULLPTR; 1742 /* Arguments of yyformat. */ 1743 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1744 /* Number of reported tokens (one for the "unexpected", one per 1745 "expected"). */ 1746 int yycount = 0; 1747 1748 /* There are many possibilities here to consider: 1749 - If this state is a consistent state with a default action, then 1750 the only way this function was invoked is if the default action 1751 is an error action. In that case, don't check for expected 1752 tokens because there are none. 1753 - The only way there can be no lookahead present (in yychar) is if 1754 this state is a consistent state with a default action. Thus, 1755 detecting the absence of a lookahead is sufficient to determine 1756 that there is no unexpected or expected token to report. In that 1757 case, just report a simple "syntax error". 1758 - Don't assume there isn't a lookahead just because this state is a 1759 consistent state with a default action. There might have been a 1760 previous inconsistent state, consistent state with a non-default 1761 action, or user semantic action that manipulated yychar. 1762 - Of course, the expected token list depends on states to have 1763 correct lookahead information, and it depends on the parser not 1764 to perform extra reductions after fetching a lookahead from the 1765 scanner and before detecting a syntax error. Thus, state merging 1766 (from LALR or IELR) and default reductions corrupt the expected 1767 token list. However, the list is correct for canonical LR with 1768 one exception: it will still contain any token that will not be 1769 accepted due to an error action in a later state. 1770 */ 1771 if (yytoken != YYEMPTY) 1772 { 1773 int yyn = yypact[*yyssp]; 1774 yyarg[yycount++] = yytname[yytoken]; 1775 if (!yypact_value_is_default (yyn)) 1776 { 1777 /* Start YYX at -YYN if negative to avoid negative indexes in 1778 YYCHECK. In other words, skip the first -YYN actions for 1779 this state because they are default actions. */ 1780 int yyxbegin = yyn < 0 ? -yyn : 0; 1781 /* Stay within bounds of both yycheck and yytname. */ 1782 int yychecklim = YYLAST - yyn + 1; 1783 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1784 int yyx; 1785 1786 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1787 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1788 && !yytable_value_is_error (yytable[yyx + yyn])) 1789 { 1790 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1791 { 1792 yycount = 1; 1793 yysize = yysize0; 1794 break; 1795 } 1796 yyarg[yycount++] = yytname[yyx]; 1797 { 1798 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); 1799 if (! (yysize <= yysize1 1800 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1801 return 2; 1802 yysize = yysize1; 1803 } 1804 } 1805 } 1806 } 1807 1808 switch (yycount) 1809 { 1810 # define YYCASE_(N, S) \ 1811 case N: \ 1812 yyformat = S; \ 1813 break 1814 YYCASE_(0, YY_("syntax error")); 1815 YYCASE_(1, YY_("syntax error, unexpected %s")); 1816 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1817 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1818 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1819 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1820 # undef YYCASE_ 1821 } 1822 1823 { 1824 YYSIZE_T yysize1 = yysize + yystrlen (yyformat); 1825 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1826 return 2; 1827 yysize = yysize1; 1828 } 1829 1830 if (*yymsg_alloc < yysize) 1831 { 1832 *yymsg_alloc = 2 * yysize; 1833 if (! (yysize <= *yymsg_alloc 1834 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1835 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1836 return 1; 1837 } 1838 1839 /* Avoid sprintf, as that infringes on the user's name space. 1840 Don't have undefined behavior even if the translation 1841 produced a string with the wrong number of "%s"s. */ 1842 { 1843 char *yyp = *yymsg; 1844 int yyi = 0; 1845 while ((*yyp = *yyformat) != '\0') 1846 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1847 { 1848 yyp += yytnamerr (yyp, yyarg[yyi++]); 1849 yyformat += 2; 1850 } 1851 else 1852 { 1853 yyp++; 1854 yyformat++; 1855 } 1856 } 1857 return 0; 1858 } 1859 #endif /* YYERROR_VERBOSE */ 1860 1861 /*-----------------------------------------------. 1862 | Release the memory associated to this symbol. | 1863 `-----------------------------------------------*/ 1864 1865 static void 1866 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1867 { 1868 YYUSE (yyvaluep); 1869 if (!yymsg) 1870 yymsg = "Deleting"; 1871 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1872 1873 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1874 YYUSE (yytype); 1875 YY_IGNORE_MAYBE_UNINITIALIZED_END 1876 } 1877 1878 1879 1880 1881 /* The lookahead symbol. */ 1882 int yychar; 1883 1884 /* The semantic value of the lookahead symbol. */ 1885 YYSTYPE yylval; 1886 /* Number of syntax errors so far. */ 1887 int yynerrs; 1888 1889 1890 /*----------. 1891 | yyparse. | 1892 `----------*/ 1893 1894 int 1895 yyparse (void) 1896 { 1897 int yystate; 1898 /* Number of tokens to shift before error messages enabled. */ 1899 int yyerrstatus; 1900 1901 /* The stacks and their tools: 1902 'yyss': related to states. 1903 'yyvs': related to semantic values. 1904 1905 Refer to the stacks through separate pointers, to allow yyoverflow 1906 to reallocate them elsewhere. */ 1907 1908 /* The state stack. */ 1909 yytype_int16 yyssa[YYINITDEPTH]; 1910 yytype_int16 *yyss; 1911 yytype_int16 *yyssp; 1912 1913 /* The semantic value stack. */ 1914 YYSTYPE yyvsa[YYINITDEPTH]; 1915 YYSTYPE *yyvs; 1916 YYSTYPE *yyvsp; 1917 1918 YYSIZE_T yystacksize; 1919 1920 int yyn; 1921 int yyresult; 1922 /* Lookahead token as an internal (translated) token number. */ 1923 int yytoken = 0; 1924 /* The variables used to return semantic value and location from the 1925 action routines. */ 1926 YYSTYPE yyval; 1927 1928 #if YYERROR_VERBOSE 1929 /* Buffer for error messages, and its allocated size. */ 1930 char yymsgbuf[128]; 1931 char *yymsg = yymsgbuf; 1932 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1933 #endif 1934 1935 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1936 1937 /* The number of symbols on the RHS of the reduced rule. 1938 Keep to zero when no symbol should be popped. */ 1939 int yylen = 0; 1940 1941 yyssp = yyss = yyssa; 1942 yyvsp = yyvs = yyvsa; 1943 yystacksize = YYINITDEPTH; 1944 1945 YYDPRINTF ((stderr, "Starting parse\n")); 1946 1947 yystate = 0; 1948 yyerrstatus = 0; 1949 yynerrs = 0; 1950 yychar = YYEMPTY; /* Cause a token to be read. */ 1951 goto yysetstate; 1952 1953 /*------------------------------------------------------------. 1954 | yynewstate -- Push a new state, which is found in yystate. | 1955 `------------------------------------------------------------*/ 1956 yynewstate: 1957 /* In all cases, when you get here, the value and location stacks 1958 have just been pushed. So pushing a state here evens the stacks. */ 1959 yyssp++; 1960 1961 yysetstate: 1962 *yyssp = yystate; 1963 1964 if (yyss + yystacksize - 1 <= yyssp) 1965 { 1966 /* Get the current used size of the three stacks, in elements. */ 1967 YYSIZE_T yysize = yyssp - yyss + 1; 1968 1969 #ifdef yyoverflow 1970 { 1971 /* Give user a chance to reallocate the stack. Use copies of 1972 these so that the &'s don't force the real ones into 1973 memory. */ 1974 YYSTYPE *yyvs1 = yyvs; 1975 yytype_int16 *yyss1 = yyss; 1976 1977 /* Each stack pointer address is followed by the size of the 1978 data in use in that stack, in bytes. This used to be a 1979 conditional around just the two extra args, but that might 1980 be undefined if yyoverflow is a macro. */ 1981 yyoverflow (YY_("memory exhausted"), 1982 &yyss1, yysize * sizeof (*yyssp), 1983 &yyvs1, yysize * sizeof (*yyvsp), 1984 &yystacksize); 1985 1986 yyss = yyss1; 1987 yyvs = yyvs1; 1988 } 1989 #else /* no yyoverflow */ 1990 # ifndef YYSTACK_RELOCATE 1991 goto yyexhaustedlab; 1992 # else 1993 /* Extend the stack our own way. */ 1994 if (YYMAXDEPTH <= yystacksize) 1995 goto yyexhaustedlab; 1996 yystacksize *= 2; 1997 if (YYMAXDEPTH < yystacksize) 1998 yystacksize = YYMAXDEPTH; 1999 2000 { 2001 yytype_int16 *yyss1 = yyss; 2002 union yyalloc *yyptr = 2003 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 2004 if (! yyptr) 2005 goto yyexhaustedlab; 2006 YYSTACK_RELOCATE (yyss_alloc, yyss); 2007 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 2008 # undef YYSTACK_RELOCATE 2009 if (yyss1 != yyssa) 2010 YYSTACK_FREE (yyss1); 2011 } 2012 # endif 2013 #endif /* no yyoverflow */ 2014 2015 yyssp = yyss + yysize - 1; 2016 yyvsp = yyvs + yysize - 1; 2017 2018 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 2019 (unsigned long int) yystacksize)); 2020 2021 if (yyss + yystacksize - 1 <= yyssp) 2022 YYABORT; 2023 } 2024 2025 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 2026 2027 if (yystate == YYFINAL) 2028 YYACCEPT; 2029 2030 goto yybackup; 2031 2032 /*-----------. 2033 | yybackup. | 2034 `-----------*/ 2035 yybackup: 2036 2037 /* Do appropriate processing given the current state. Read a 2038 lookahead token if we need one and don't already have one. */ 2039 2040 /* First try to decide what to do without reference to lookahead token. */ 2041 yyn = yypact[yystate]; 2042 if (yypact_value_is_default (yyn)) 2043 goto yydefault; 2044 2045 /* Not known => get a lookahead token if don't already have one. */ 2046 2047 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 2048 if (yychar == YYEMPTY) 2049 { 2050 YYDPRINTF ((stderr, "Reading a token: ")); 2051 yychar = yylex (); 2052 } 2053 2054 if (yychar <= YYEOF) 2055 { 2056 yychar = yytoken = YYEOF; 2057 YYDPRINTF ((stderr, "Now at end of input.\n")); 2058 } 2059 else 2060 { 2061 yytoken = YYTRANSLATE (yychar); 2062 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2063 } 2064 2065 /* If the proper action on seeing token YYTOKEN is to reduce or to 2066 detect an error, take that action. */ 2067 yyn += yytoken; 2068 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 2069 goto yydefault; 2070 yyn = yytable[yyn]; 2071 if (yyn <= 0) 2072 { 2073 if (yytable_value_is_error (yyn)) 2074 goto yyerrlab; 2075 yyn = -yyn; 2076 goto yyreduce; 2077 } 2078 2079 /* Count tokens shifted since error; after three, turn off error 2080 status. */ 2081 if (yyerrstatus) 2082 yyerrstatus--; 2083 2084 /* Shift the lookahead token. */ 2085 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2086 2087 /* Discard the shifted token. */ 2088 yychar = YYEMPTY; 2089 2090 yystate = yyn; 2091 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2092 *++yyvsp = yylval; 2093 YY_IGNORE_MAYBE_UNINITIALIZED_END 2094 2095 goto yynewstate; 2096 2097 2098 /*-----------------------------------------------------------. 2099 | yydefault -- do the default action for the current state. | 2100 `-----------------------------------------------------------*/ 2101 yydefault: 2102 yyn = yydefact[yystate]; 2103 if (yyn == 0) 2104 goto yyerrlab; 2105 goto yyreduce; 2106 2107 2108 /*-----------------------------. 2109 | yyreduce -- Do a reduction. | 2110 `-----------------------------*/ 2111 yyreduce: 2112 /* yyn is the number of a rule to reduce with. */ 2113 yylen = yyr2[yyn]; 2114 2115 /* If YYLEN is nonzero, implement the default value of the action: 2116 '$$ = $1'. 2117 2118 Otherwise, the following line sets YYVAL to garbage. 2119 This behavior is undocumented and Bison 2120 users should not rely upon it. Assigning to YYVAL 2121 unconditionally makes the parser a bit smaller, and it avoids a 2122 GCC warning that YYVAL may be used uninitialized. */ 2123 yyval = yyvsp[1-yylen]; 2124 2125 2126 YY_REDUCE_PRINT (yyn); 2127 switch (yyn) 2128 { 2129 case 5: 2130 #line 385 "ntp_parser.y" /* yacc.c:1646 */ 2131 { 2132 /* I will need to incorporate much more fine grained 2133 * error messages. The following should suffice for 2134 * the time being. 2135 */ 2136 struct FILE_INFO * ip_ctx = lex_current(); 2137 msyslog(LOG_ERR, 2138 "syntax error in %s line %d, column %d", 2139 ip_ctx->fname, 2140 ip_ctx->errpos.nline, 2141 ip_ctx->errpos.ncol); 2142 } 2143 #line 2144 "ntp_parser.c" /* yacc.c:1646 */ 2144 break; 2145 2146 case 20: 2147 #line 421 "ntp_parser.y" /* yacc.c:1646 */ 2148 { 2149 peer_node *my_node; 2150 2151 my_node = create_peer_node((yyvsp[-2].Integer), (yyvsp[-1].Address_node), (yyvsp[0].Attr_val_fifo)); 2152 APPEND_G_FIFO(cfgt.peers, my_node); 2153 } 2154 #line 2155 "ntp_parser.c" /* yacc.c:1646 */ 2155 break; 2156 2157 case 27: 2158 #line 440 "ntp_parser.y" /* yacc.c:1646 */ 2159 { (yyval.Address_node) = create_address_node((yyvsp[0].String), (yyvsp[-1].Integer)); } 2160 #line 2161 "ntp_parser.c" /* yacc.c:1646 */ 2161 break; 2162 2163 case 28: 2164 #line 445 "ntp_parser.y" /* yacc.c:1646 */ 2165 { (yyval.Address_node) = create_address_node((yyvsp[0].String), AF_UNSPEC); } 2166 #line 2167 "ntp_parser.c" /* yacc.c:1646 */ 2167 break; 2168 2169 case 29: 2170 #line 450 "ntp_parser.y" /* yacc.c:1646 */ 2171 { (yyval.Integer) = AF_INET; } 2172 #line 2173 "ntp_parser.c" /* yacc.c:1646 */ 2173 break; 2174 2175 case 30: 2176 #line 452 "ntp_parser.y" /* yacc.c:1646 */ 2177 { (yyval.Integer) = AF_INET6; } 2178 #line 2179 "ntp_parser.c" /* yacc.c:1646 */ 2179 break; 2180 2181 case 31: 2182 #line 457 "ntp_parser.y" /* yacc.c:1646 */ 2183 { (yyval.Attr_val_fifo) = NULL; } 2184 #line 2185 "ntp_parser.c" /* yacc.c:1646 */ 2185 break; 2186 2187 case 32: 2188 #line 459 "ntp_parser.y" /* yacc.c:1646 */ 2189 { 2190 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 2191 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2192 } 2193 #line 2194 "ntp_parser.c" /* yacc.c:1646 */ 2194 break; 2195 2196 case 36: 2197 #line 473 "ntp_parser.y" /* yacc.c:1646 */ 2198 { (yyval.Attr_val) = create_attr_ival(T_Flag, (yyvsp[0].Integer)); } 2199 #line 2200 "ntp_parser.c" /* yacc.c:1646 */ 2200 break; 2201 2202 case 45: 2203 #line 489 "ntp_parser.y" /* yacc.c:1646 */ 2204 { (yyval.Attr_val) = create_attr_ival((yyvsp[-1].Integer), (yyvsp[0].Integer)); } 2205 #line 2206 "ntp_parser.c" /* yacc.c:1646 */ 2206 break; 2207 2208 case 46: 2209 #line 491 "ntp_parser.y" /* yacc.c:1646 */ 2210 { (yyval.Attr_val) = create_attr_uval((yyvsp[-1].Integer), (yyvsp[0].Integer)); } 2211 #line 2212 "ntp_parser.c" /* yacc.c:1646 */ 2212 break; 2213 2214 case 53: 2215 #line 505 "ntp_parser.y" /* yacc.c:1646 */ 2216 { (yyval.Attr_val) = create_attr_sval((yyvsp[-1].Integer), (yyvsp[0].String)); } 2217 #line 2218 "ntp_parser.c" /* yacc.c:1646 */ 2218 break; 2219 2220 case 55: 2221 #line 519 "ntp_parser.y" /* yacc.c:1646 */ 2222 { 2223 unpeer_node *my_node; 2224 2225 my_node = create_unpeer_node((yyvsp[0].Address_node)); 2226 if (my_node) 2227 APPEND_G_FIFO(cfgt.unpeers, my_node); 2228 } 2229 #line 2230 "ntp_parser.c" /* yacc.c:1646 */ 2230 break; 2231 2232 case 58: 2233 #line 540 "ntp_parser.y" /* yacc.c:1646 */ 2234 { cfgt.broadcastclient = 1; } 2235 #line 2236 "ntp_parser.c" /* yacc.c:1646 */ 2236 break; 2237 2238 case 59: 2239 #line 542 "ntp_parser.y" /* yacc.c:1646 */ 2240 { CONCAT_G_FIFOS(cfgt.manycastserver, (yyvsp[0].Address_fifo)); } 2241 #line 2242 "ntp_parser.c" /* yacc.c:1646 */ 2242 break; 2243 2244 case 60: 2245 #line 544 "ntp_parser.y" /* yacc.c:1646 */ 2246 { CONCAT_G_FIFOS(cfgt.multicastclient, (yyvsp[0].Address_fifo)); } 2247 #line 2248 "ntp_parser.c" /* yacc.c:1646 */ 2248 break; 2249 2250 case 61: 2251 #line 546 "ntp_parser.y" /* yacc.c:1646 */ 2252 { cfgt.mdnstries = (yyvsp[0].Integer); } 2253 #line 2254 "ntp_parser.c" /* yacc.c:1646 */ 2254 break; 2255 2256 case 62: 2257 #line 557 "ntp_parser.y" /* yacc.c:1646 */ 2258 { 2259 attr_val *atrv; 2260 2261 atrv = create_attr_ival((yyvsp[-1].Integer), (yyvsp[0].Integer)); 2262 APPEND_G_FIFO(cfgt.vars, atrv); 2263 } 2264 #line 2265 "ntp_parser.c" /* yacc.c:1646 */ 2265 break; 2266 2267 case 63: 2268 #line 564 "ntp_parser.y" /* yacc.c:1646 */ 2269 { cfgt.auth.control_key = (yyvsp[0].Integer); } 2270 #line 2271 "ntp_parser.c" /* yacc.c:1646 */ 2271 break; 2272 2273 case 64: 2274 #line 566 "ntp_parser.y" /* yacc.c:1646 */ 2275 { 2276 cfgt.auth.cryptosw++; 2277 CONCAT_G_FIFOS(cfgt.auth.crypto_cmd_list, (yyvsp[0].Attr_val_fifo)); 2278 } 2279 #line 2280 "ntp_parser.c" /* yacc.c:1646 */ 2280 break; 2281 2282 case 65: 2283 #line 571 "ntp_parser.y" /* yacc.c:1646 */ 2284 { cfgt.auth.keys = (yyvsp[0].String); } 2285 #line 2286 "ntp_parser.c" /* yacc.c:1646 */ 2286 break; 2287 2288 case 66: 2289 #line 573 "ntp_parser.y" /* yacc.c:1646 */ 2290 { cfgt.auth.keysdir = (yyvsp[0].String); } 2291 #line 2292 "ntp_parser.c" /* yacc.c:1646 */ 2292 break; 2293 2294 case 67: 2295 #line 575 "ntp_parser.y" /* yacc.c:1646 */ 2296 { cfgt.auth.request_key = (yyvsp[0].Integer); } 2297 #line 2298 "ntp_parser.c" /* yacc.c:1646 */ 2298 break; 2299 2300 case 68: 2301 #line 577 "ntp_parser.y" /* yacc.c:1646 */ 2302 { cfgt.auth.revoke = (yyvsp[0].Integer); } 2303 #line 2304 "ntp_parser.c" /* yacc.c:1646 */ 2304 break; 2305 2306 case 69: 2307 #line 579 "ntp_parser.y" /* yacc.c:1646 */ 2308 { 2309 /* [Bug 948] leaves it open if appending or 2310 * replacing the trusted key list is the right 2311 * way. In any case, either alternative should 2312 * be coded correctly! 2313 */ 2314 DESTROY_G_FIFO(cfgt.auth.trusted_key_list, destroy_attr_val); /* remove for append */ 2315 CONCAT_G_FIFOS(cfgt.auth.trusted_key_list, (yyvsp[0].Attr_val_fifo)); 2316 } 2317 #line 2318 "ntp_parser.c" /* yacc.c:1646 */ 2318 break; 2319 2320 case 70: 2321 #line 589 "ntp_parser.y" /* yacc.c:1646 */ 2322 { cfgt.auth.ntp_signd_socket = (yyvsp[0].String); } 2323 #line 2324 "ntp_parser.c" /* yacc.c:1646 */ 2324 break; 2325 2326 case 71: 2327 #line 594 "ntp_parser.y" /* yacc.c:1646 */ 2328 { (yyval.Attr_val_fifo) = NULL; } 2329 #line 2330 "ntp_parser.c" /* yacc.c:1646 */ 2330 break; 2331 2332 case 72: 2333 #line 596 "ntp_parser.y" /* yacc.c:1646 */ 2334 { 2335 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 2336 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2337 } 2338 #line 2339 "ntp_parser.c" /* yacc.c:1646 */ 2339 break; 2340 2341 case 73: 2342 #line 604 "ntp_parser.y" /* yacc.c:1646 */ 2343 { (yyval.Attr_val) = create_attr_sval((yyvsp[-1].Integer), (yyvsp[0].String)); } 2344 #line 2345 "ntp_parser.c" /* yacc.c:1646 */ 2345 break; 2346 2347 case 74: 2348 #line 606 "ntp_parser.y" /* yacc.c:1646 */ 2349 { 2350 (yyval.Attr_val) = NULL; 2351 cfgt.auth.revoke = (yyvsp[0].Integer); 2352 msyslog(LOG_WARNING, 2353 "'crypto revoke %d' is deprecated, " 2354 "please use 'revoke %d' instead.", 2355 cfgt.auth.revoke, cfgt.auth.revoke); 2356 } 2357 #line 2358 "ntp_parser.c" /* yacc.c:1646 */ 2358 break; 2359 2360 case 80: 2361 #line 631 "ntp_parser.y" /* yacc.c:1646 */ 2362 { CONCAT_G_FIFOS(cfgt.orphan_cmds, (yyvsp[0].Attr_val_fifo)); } 2363 #line 2364 "ntp_parser.c" /* yacc.c:1646 */ 2364 break; 2365 2366 case 81: 2367 #line 636 "ntp_parser.y" /* yacc.c:1646 */ 2368 { 2369 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 2370 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2371 } 2372 #line 2373 "ntp_parser.c" /* yacc.c:1646 */ 2373 break; 2374 2375 case 82: 2376 #line 641 "ntp_parser.y" /* yacc.c:1646 */ 2377 { 2378 (yyval.Attr_val_fifo) = NULL; 2379 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2380 } 2381 #line 2382 "ntp_parser.c" /* yacc.c:1646 */ 2382 break; 2383 2384 case 83: 2385 #line 649 "ntp_parser.y" /* yacc.c:1646 */ 2386 { (yyval.Attr_val) = create_attr_dval((yyvsp[-1].Integer), (double)(yyvsp[0].Integer)); } 2387 #line 2388 "ntp_parser.c" /* yacc.c:1646 */ 2388 break; 2389 2390 case 84: 2391 #line 651 "ntp_parser.y" /* yacc.c:1646 */ 2392 { (yyval.Attr_val) = create_attr_dval((yyvsp[-1].Integer), (yyvsp[0].Double)); } 2393 #line 2394 "ntp_parser.c" /* yacc.c:1646 */ 2394 break; 2395 2396 case 85: 2397 #line 653 "ntp_parser.y" /* yacc.c:1646 */ 2398 { (yyval.Attr_val) = create_attr_dval((yyvsp[-1].Integer), (double)(yyvsp[0].Integer)); } 2399 #line 2400 "ntp_parser.c" /* yacc.c:1646 */ 2400 break; 2401 2402 case 86: 2403 #line 655 "ntp_parser.y" /* yacc.c:1646 */ 2404 { (yyval.Attr_val) = create_attr_ival(T_Basedate, (yyvsp[0].Integer)); } 2405 #line 2406 "ntp_parser.c" /* yacc.c:1646 */ 2406 break; 2407 2408 case 98: 2409 #line 682 "ntp_parser.y" /* yacc.c:1646 */ 2410 { CONCAT_G_FIFOS(cfgt.stats_list, (yyvsp[0].Int_fifo)); } 2411 #line 2412 "ntp_parser.c" /* yacc.c:1646 */ 2412 break; 2413 2414 case 99: 2415 #line 684 "ntp_parser.y" /* yacc.c:1646 */ 2416 { 2417 if (lex_from_file()) { 2418 cfgt.stats_dir = (yyvsp[0].String); 2419 } else { 2420 YYFREE((yyvsp[0].String)); 2421 yyerror("statsdir remote configuration ignored"); 2422 } 2423 } 2424 #line 2425 "ntp_parser.c" /* yacc.c:1646 */ 2425 break; 2426 2427 case 100: 2428 #line 693 "ntp_parser.y" /* yacc.c:1646 */ 2429 { 2430 filegen_node *fgn; 2431 2432 fgn = create_filegen_node((yyvsp[-1].Integer), (yyvsp[0].Attr_val_fifo)); 2433 APPEND_G_FIFO(cfgt.filegen_opts, fgn); 2434 } 2435 #line 2436 "ntp_parser.c" /* yacc.c:1646 */ 2436 break; 2437 2438 case 101: 2439 #line 703 "ntp_parser.y" /* yacc.c:1646 */ 2440 { 2441 (yyval.Int_fifo) = (yyvsp[-1].Int_fifo); 2442 APPEND_G_FIFO((yyval.Int_fifo), create_int_node((yyvsp[0].Integer))); 2443 } 2444 #line 2445 "ntp_parser.c" /* yacc.c:1646 */ 2445 break; 2446 2447 case 102: 2448 #line 708 "ntp_parser.y" /* yacc.c:1646 */ 2449 { 2450 (yyval.Int_fifo) = NULL; 2451 APPEND_G_FIFO((yyval.Int_fifo), create_int_node((yyvsp[0].Integer))); 2452 } 2453 #line 2454 "ntp_parser.c" /* yacc.c:1646 */ 2454 break; 2455 2456 case 111: 2457 #line 727 "ntp_parser.y" /* yacc.c:1646 */ 2458 { (yyval.Attr_val_fifo) = NULL; } 2459 #line 2460 "ntp_parser.c" /* yacc.c:1646 */ 2460 break; 2461 2462 case 112: 2463 #line 729 "ntp_parser.y" /* yacc.c:1646 */ 2464 { 2465 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 2466 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2467 } 2468 #line 2469 "ntp_parser.c" /* yacc.c:1646 */ 2469 break; 2470 2471 case 113: 2472 #line 737 "ntp_parser.y" /* yacc.c:1646 */ 2473 { 2474 if (lex_from_file()) { 2475 (yyval.Attr_val) = create_attr_sval((yyvsp[-1].Integer), (yyvsp[0].String)); 2476 } else { 2477 (yyval.Attr_val) = NULL; 2478 YYFREE((yyvsp[0].String)); 2479 yyerror("filegen file remote config ignored"); 2480 } 2481 } 2482 #line 2483 "ntp_parser.c" /* yacc.c:1646 */ 2483 break; 2484 2485 case 114: 2486 #line 747 "ntp_parser.y" /* yacc.c:1646 */ 2487 { 2488 if (lex_from_file()) { 2489 (yyval.Attr_val) = create_attr_ival((yyvsp[-1].Integer), (yyvsp[0].Integer)); 2490 } else { 2491 (yyval.Attr_val) = NULL; 2492 yyerror("filegen type remote config ignored"); 2493 } 2494 } 2495 #line 2496 "ntp_parser.c" /* yacc.c:1646 */ 2496 break; 2497 2498 case 115: 2499 #line 756 "ntp_parser.y" /* yacc.c:1646 */ 2500 { 2501 const char *err; 2502 2503 if (lex_from_file()) { 2504 (yyval.Attr_val) = create_attr_ival(T_Flag, (yyvsp[0].Integer)); 2505 } else { 2506 (yyval.Attr_val) = NULL; 2507 if (T_Link == (yyvsp[0].Integer)) 2508 err = "filegen link remote config ignored"; 2509 else 2510 err = "filegen nolink remote config ignored"; 2511 yyerror(err); 2512 } 2513 } 2514 #line 2515 "ntp_parser.c" /* yacc.c:1646 */ 2515 break; 2516 2517 case 116: 2518 #line 771 "ntp_parser.y" /* yacc.c:1646 */ 2519 { (yyval.Attr_val) = create_attr_ival(T_Flag, (yyvsp[0].Integer)); } 2520 #line 2521 "ntp_parser.c" /* yacc.c:1646 */ 2521 break; 2522 2523 case 128: 2524 #line 801 "ntp_parser.y" /* yacc.c:1646 */ 2525 { 2526 CONCAT_G_FIFOS(cfgt.discard_opts, (yyvsp[0].Attr_val_fifo)); 2527 } 2528 #line 2529 "ntp_parser.c" /* yacc.c:1646 */ 2529 break; 2530 2531 case 129: 2532 #line 805 "ntp_parser.y" /* yacc.c:1646 */ 2533 { 2534 CONCAT_G_FIFOS(cfgt.mru_opts, (yyvsp[0].Attr_val_fifo)); 2535 } 2536 #line 2537 "ntp_parser.c" /* yacc.c:1646 */ 2537 break; 2538 2539 case 130: 2540 #line 809 "ntp_parser.y" /* yacc.c:1646 */ 2541 { 2542 restrict_node *rn; 2543 2544 rn = create_restrict_node((yyvsp[-2].Address_node), NULL, (yyvsp[-1].Integer), (yyvsp[0].Int_fifo), 2545 lex_current()->curpos.nline); 2546 APPEND_G_FIFO(cfgt.restrict_opts, rn); 2547 } 2548 #line 2549 "ntp_parser.c" /* yacc.c:1646 */ 2549 break; 2550 2551 case 131: 2552 #line 817 "ntp_parser.y" /* yacc.c:1646 */ 2553 { 2554 restrict_node *rn; 2555 2556 rn = create_restrict_node((yyvsp[-4].Address_node), (yyvsp[-2].Address_node), (yyvsp[-1].Integer), (yyvsp[0].Int_fifo), 2557 lex_current()->curpos.nline); 2558 APPEND_G_FIFO(cfgt.restrict_opts, rn); 2559 } 2560 #line 2561 "ntp_parser.c" /* yacc.c:1646 */ 2561 break; 2562 2563 case 132: 2564 #line 825 "ntp_parser.y" /* yacc.c:1646 */ 2565 { 2566 restrict_node *rn; 2567 2568 rn = create_restrict_node(NULL, NULL, (yyvsp[-1].Integer), (yyvsp[0].Int_fifo), 2569 lex_current()->curpos.nline); 2570 APPEND_G_FIFO(cfgt.restrict_opts, rn); 2571 } 2572 #line 2573 "ntp_parser.c" /* yacc.c:1646 */ 2573 break; 2574 2575 case 133: 2576 #line 833 "ntp_parser.y" /* yacc.c:1646 */ 2577 { 2578 restrict_node *rn; 2579 2580 rn = create_restrict_node( 2581 create_address_node( 2582 estrdup("0.0.0.0"), 2583 AF_INET), 2584 create_address_node( 2585 estrdup("0.0.0.0"), 2586 AF_INET), 2587 (yyvsp[-1].Integer), (yyvsp[0].Int_fifo), 2588 lex_current()->curpos.nline); 2589 APPEND_G_FIFO(cfgt.restrict_opts, rn); 2590 } 2591 #line 2592 "ntp_parser.c" /* yacc.c:1646 */ 2592 break; 2593 2594 case 134: 2595 #line 848 "ntp_parser.y" /* yacc.c:1646 */ 2596 { 2597 restrict_node *rn; 2598 2599 rn = create_restrict_node( 2600 create_address_node( 2601 estrdup("::"), 2602 AF_INET6), 2603 create_address_node( 2604 estrdup("::"), 2605 AF_INET6), 2606 (yyvsp[-1].Integer), (yyvsp[0].Int_fifo), 2607 lex_current()->curpos.nline); 2608 APPEND_G_FIFO(cfgt.restrict_opts, rn); 2609 } 2610 #line 2611 "ntp_parser.c" /* yacc.c:1646 */ 2611 break; 2612 2613 case 135: 2614 #line 863 "ntp_parser.y" /* yacc.c:1646 */ 2615 { 2616 restrict_node * rn; 2617 2618 APPEND_G_FIFO((yyvsp[0].Int_fifo), create_int_node((yyvsp[-2].Integer))); 2619 rn = create_restrict_node( 2620 NULL, NULL, (yyvsp[-1].Integer), (yyvsp[0].Int_fifo), lex_current()->curpos.nline); 2621 APPEND_G_FIFO(cfgt.restrict_opts, rn); 2622 } 2623 #line 2624 "ntp_parser.c" /* yacc.c:1646 */ 2624 break; 2625 2626 case 136: 2627 #line 875 "ntp_parser.y" /* yacc.c:1646 */ 2628 { (yyval.Integer) = -1; } 2629 #line 2630 "ntp_parser.c" /* yacc.c:1646 */ 2630 break; 2631 2632 case 137: 2633 #line 877 "ntp_parser.y" /* yacc.c:1646 */ 2634 { 2635 if (((yyvsp[0].Integer) < -1) || ((yyvsp[0].Integer) > 100)) { 2636 struct FILE_INFO * ip_ctx; 2637 2638 ip_ctx = lex_current(); 2639 msyslog(LOG_ERR, 2640 "Unreasonable ippeerlimit value (%d) in %s line %d, column %d. Using 0.", 2641 (yyvsp[0].Integer), 2642 ip_ctx->fname, 2643 ip_ctx->errpos.nline, 2644 ip_ctx->errpos.ncol); 2645 (yyvsp[0].Integer) = 0; 2646 } 2647 (yyval.Integer) = (yyvsp[0].Integer); 2648 } 2649 #line 2650 "ntp_parser.c" /* yacc.c:1646 */ 2650 break; 2651 2652 case 138: 2653 #line 896 "ntp_parser.y" /* yacc.c:1646 */ 2654 { (yyval.Int_fifo) = NULL; } 2655 #line 2656 "ntp_parser.c" /* yacc.c:1646 */ 2656 break; 2657 2658 case 139: 2659 #line 898 "ntp_parser.y" /* yacc.c:1646 */ 2660 { 2661 (yyval.Int_fifo) = (yyvsp[-1].Int_fifo); 2662 APPEND_G_FIFO((yyval.Int_fifo), create_int_node((yyvsp[0].Integer))); 2663 } 2664 #line 2665 "ntp_parser.c" /* yacc.c:1646 */ 2665 break; 2666 2667 case 157: 2668 #line 926 "ntp_parser.y" /* yacc.c:1646 */ 2669 { 2670 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 2671 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2672 } 2673 #line 2674 "ntp_parser.c" /* yacc.c:1646 */ 2674 break; 2675 2676 case 158: 2677 #line 931 "ntp_parser.y" /* yacc.c:1646 */ 2678 { 2679 (yyval.Attr_val_fifo) = NULL; 2680 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2681 } 2682 #line 2683 "ntp_parser.c" /* yacc.c:1646 */ 2683 break; 2684 2685 case 159: 2686 #line 939 "ntp_parser.y" /* yacc.c:1646 */ 2687 { (yyval.Attr_val) = create_attr_ival((yyvsp[-1].Integer), (yyvsp[0].Integer)); } 2688 #line 2689 "ntp_parser.c" /* yacc.c:1646 */ 2689 break; 2690 2691 case 163: 2692 #line 950 "ntp_parser.y" /* yacc.c:1646 */ 2693 { 2694 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 2695 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2696 } 2697 #line 2698 "ntp_parser.c" /* yacc.c:1646 */ 2698 break; 2699 2700 case 164: 2701 #line 955 "ntp_parser.y" /* yacc.c:1646 */ 2702 { 2703 (yyval.Attr_val_fifo) = NULL; 2704 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2705 } 2706 #line 2707 "ntp_parser.c" /* yacc.c:1646 */ 2707 break; 2708 2709 case 165: 2710 #line 963 "ntp_parser.y" /* yacc.c:1646 */ 2711 { (yyval.Attr_val) = create_attr_ival((yyvsp[-1].Integer), (yyvsp[0].Integer)); } 2712 #line 2713 "ntp_parser.c" /* yacc.c:1646 */ 2713 break; 2714 2715 case 174: 2716 #line 983 "ntp_parser.y" /* yacc.c:1646 */ 2717 { 2718 addr_opts_node *aon; 2719 2720 aon = create_addr_opts_node((yyvsp[-1].Address_node), (yyvsp[0].Attr_val_fifo)); 2721 APPEND_G_FIFO(cfgt.fudge, aon); 2722 } 2723 #line 2724 "ntp_parser.c" /* yacc.c:1646 */ 2724 break; 2725 2726 case 175: 2727 #line 993 "ntp_parser.y" /* yacc.c:1646 */ 2728 { 2729 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 2730 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2731 } 2732 #line 2733 "ntp_parser.c" /* yacc.c:1646 */ 2733 break; 2734 2735 case 176: 2736 #line 998 "ntp_parser.y" /* yacc.c:1646 */ 2737 { 2738 (yyval.Attr_val_fifo) = NULL; 2739 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2740 } 2741 #line 2742 "ntp_parser.c" /* yacc.c:1646 */ 2742 break; 2743 2744 case 177: 2745 #line 1006 "ntp_parser.y" /* yacc.c:1646 */ 2746 { (yyval.Attr_val) = create_attr_dval((yyvsp[-1].Integer), (yyvsp[0].Double)); } 2747 #line 2748 "ntp_parser.c" /* yacc.c:1646 */ 2748 break; 2749 2750 case 178: 2751 #line 1008 "ntp_parser.y" /* yacc.c:1646 */ 2752 { (yyval.Attr_val) = create_attr_ival((yyvsp[-1].Integer), (yyvsp[0].Integer)); } 2753 #line 2754 "ntp_parser.c" /* yacc.c:1646 */ 2754 break; 2755 2756 case 179: 2757 #line 1010 "ntp_parser.y" /* yacc.c:1646 */ 2758 { 2759 if ((yyvsp[0].Integer) >= 0 && (yyvsp[0].Integer) <= 16) { 2760 (yyval.Attr_val) = create_attr_ival((yyvsp[-1].Integer), (yyvsp[0].Integer)); 2761 } else { 2762 (yyval.Attr_val) = NULL; 2763 yyerror("fudge factor: stratum value not in [0..16], ignored"); 2764 } 2765 } 2766 #line 2767 "ntp_parser.c" /* yacc.c:1646 */ 2767 break; 2768 2769 case 180: 2770 #line 1019 "ntp_parser.y" /* yacc.c:1646 */ 2771 { (yyval.Attr_val) = create_attr_sval((yyvsp[-1].Integer), (yyvsp[0].String)); } 2772 #line 2773 "ntp_parser.c" /* yacc.c:1646 */ 2773 break; 2774 2775 case 181: 2776 #line 1021 "ntp_parser.y" /* yacc.c:1646 */ 2777 { (yyval.Attr_val) = create_attr_sval((yyvsp[-1].Integer), (yyvsp[0].String)); } 2778 #line 2779 "ntp_parser.c" /* yacc.c:1646 */ 2779 break; 2780 2781 case 188: 2782 #line 1042 "ntp_parser.y" /* yacc.c:1646 */ 2783 { CONCAT_G_FIFOS(cfgt.rlimit, (yyvsp[0].Attr_val_fifo)); } 2784 #line 2785 "ntp_parser.c" /* yacc.c:1646 */ 2785 break; 2786 2787 case 189: 2788 #line 1047 "ntp_parser.y" /* yacc.c:1646 */ 2789 { 2790 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 2791 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2792 } 2793 #line 2794 "ntp_parser.c" /* yacc.c:1646 */ 2794 break; 2795 2796 case 190: 2797 #line 1052 "ntp_parser.y" /* yacc.c:1646 */ 2798 { 2799 (yyval.Attr_val_fifo) = NULL; 2800 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2801 } 2802 #line 2803 "ntp_parser.c" /* yacc.c:1646 */ 2803 break; 2804 2805 case 191: 2806 #line 1060 "ntp_parser.y" /* yacc.c:1646 */ 2807 { (yyval.Attr_val) = create_attr_ival((yyvsp[-1].Integer), (yyvsp[0].Integer)); } 2808 #line 2809 "ntp_parser.c" /* yacc.c:1646 */ 2809 break; 2810 2811 case 195: 2812 #line 1076 "ntp_parser.y" /* yacc.c:1646 */ 2813 { CONCAT_G_FIFOS(cfgt.enable_opts, (yyvsp[0].Attr_val_fifo)); } 2814 #line 2815 "ntp_parser.c" /* yacc.c:1646 */ 2815 break; 2816 2817 case 196: 2818 #line 1078 "ntp_parser.y" /* yacc.c:1646 */ 2819 { CONCAT_G_FIFOS(cfgt.disable_opts, (yyvsp[0].Attr_val_fifo)); } 2820 #line 2821 "ntp_parser.c" /* yacc.c:1646 */ 2821 break; 2822 2823 case 197: 2824 #line 1083 "ntp_parser.y" /* yacc.c:1646 */ 2825 { 2826 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 2827 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2828 } 2829 #line 2830 "ntp_parser.c" /* yacc.c:1646 */ 2830 break; 2831 2832 case 198: 2833 #line 1088 "ntp_parser.y" /* yacc.c:1646 */ 2834 { 2835 (yyval.Attr_val_fifo) = NULL; 2836 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2837 } 2838 #line 2839 "ntp_parser.c" /* yacc.c:1646 */ 2839 break; 2840 2841 case 199: 2842 #line 1096 "ntp_parser.y" /* yacc.c:1646 */ 2843 { (yyval.Attr_val) = create_attr_ival(T_Flag, (yyvsp[0].Integer)); } 2844 #line 2845 "ntp_parser.c" /* yacc.c:1646 */ 2845 break; 2846 2847 case 200: 2848 #line 1098 "ntp_parser.y" /* yacc.c:1646 */ 2849 { 2850 if (lex_from_file()) { 2851 (yyval.Attr_val) = create_attr_ival(T_Flag, (yyvsp[0].Integer)); 2852 } else { 2853 char err_str[128]; 2854 2855 (yyval.Attr_val) = NULL; 2856 snprintf(err_str, sizeof(err_str), 2857 "enable/disable %s remote configuration ignored", 2858 keyword((yyvsp[0].Integer))); 2859 yyerror(err_str); 2860 } 2861 } 2862 #line 2863 "ntp_parser.c" /* yacc.c:1646 */ 2863 break; 2864 2865 case 213: 2866 #line 1137 "ntp_parser.y" /* yacc.c:1646 */ 2867 { CONCAT_G_FIFOS(cfgt.tinker, (yyvsp[0].Attr_val_fifo)); } 2868 #line 2869 "ntp_parser.c" /* yacc.c:1646 */ 2869 break; 2870 2871 case 214: 2872 #line 1142 "ntp_parser.y" /* yacc.c:1646 */ 2873 { 2874 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 2875 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2876 } 2877 #line 2878 "ntp_parser.c" /* yacc.c:1646 */ 2878 break; 2879 2880 case 215: 2881 #line 1147 "ntp_parser.y" /* yacc.c:1646 */ 2882 { 2883 (yyval.Attr_val_fifo) = NULL; 2884 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 2885 } 2886 #line 2887 "ntp_parser.c" /* yacc.c:1646 */ 2887 break; 2888 2889 case 216: 2890 #line 1155 "ntp_parser.y" /* yacc.c:1646 */ 2891 { (yyval.Attr_val) = create_attr_dval((yyvsp[-1].Integer), (yyvsp[0].Double)); } 2892 #line 2893 "ntp_parser.c" /* yacc.c:1646 */ 2893 break; 2894 2895 case 229: 2896 #line 1180 "ntp_parser.y" /* yacc.c:1646 */ 2897 { 2898 attr_val *av; 2899 2900 av = create_attr_dval((yyvsp[-1].Integer), (yyvsp[0].Double)); 2901 APPEND_G_FIFO(cfgt.vars, av); 2902 } 2903 #line 2904 "ntp_parser.c" /* yacc.c:1646 */ 2904 break; 2905 2906 case 230: 2907 #line 1187 "ntp_parser.y" /* yacc.c:1646 */ 2908 { 2909 attr_val *av; 2910 2911 av = create_attr_ival((yyvsp[-1].Integer), (yyvsp[0].Integer)); 2912 APPEND_G_FIFO(cfgt.vars, av); 2913 } 2914 #line 2915 "ntp_parser.c" /* yacc.c:1646 */ 2915 break; 2916 2917 case 231: 2918 #line 1194 "ntp_parser.y" /* yacc.c:1646 */ 2919 { 2920 attr_val *av; 2921 2922 av = create_attr_sval((yyvsp[-1].Integer), (yyvsp[0].String)); 2923 APPEND_G_FIFO(cfgt.vars, av); 2924 } 2925 #line 2926 "ntp_parser.c" /* yacc.c:1646 */ 2926 break; 2927 2928 case 232: 2929 #line 1201 "ntp_parser.y" /* yacc.c:1646 */ 2930 { 2931 char error_text[64]; 2932 attr_val *av; 2933 2934 if (lex_from_file()) { 2935 av = create_attr_sval((yyvsp[-1].Integer), (yyvsp[0].String)); 2936 APPEND_G_FIFO(cfgt.vars, av); 2937 } else { 2938 YYFREE((yyvsp[0].String)); 2939 snprintf(error_text, sizeof(error_text), 2940 "%s remote config ignored", 2941 keyword((yyvsp[-1].Integer))); 2942 yyerror(error_text); 2943 } 2944 } 2945 #line 2946 "ntp_parser.c" /* yacc.c:1646 */ 2946 break; 2947 2948 case 233: 2949 #line 1217 "ntp_parser.y" /* yacc.c:1646 */ 2950 { 2951 if (!lex_from_file()) { 2952 YYFREE((yyvsp[-1].String)); /* avoid leak */ 2953 yyerror("remote includefile ignored"); 2954 break; 2955 } 2956 if (lex_level() > MAXINCLUDELEVEL) { 2957 fprintf(stderr, "getconfig: Maximum include file level exceeded.\n"); 2958 msyslog(LOG_ERR, "getconfig: Maximum include file level exceeded."); 2959 } else { 2960 const char * path = FindConfig((yyvsp[-1].String)); /* might return $2! */ 2961 if (!lex_push_file(path, "r")) { 2962 fprintf(stderr, "getconfig: Couldn't open <%s>\n", path); 2963 msyslog(LOG_ERR, "getconfig: Couldn't open <%s>", path); 2964 } 2965 } 2966 YYFREE((yyvsp[-1].String)); /* avoid leak */ 2967 } 2968 #line 2969 "ntp_parser.c" /* yacc.c:1646 */ 2969 break; 2970 2971 case 234: 2972 #line 1236 "ntp_parser.y" /* yacc.c:1646 */ 2973 { lex_flush_stack(); } 2974 #line 2975 "ntp_parser.c" /* yacc.c:1646 */ 2975 break; 2976 2977 case 235: 2978 #line 1238 "ntp_parser.y" /* yacc.c:1646 */ 2979 { /* see drift_parm below for actions */ } 2980 #line 2981 "ntp_parser.c" /* yacc.c:1646 */ 2981 break; 2982 2983 case 236: 2984 #line 1240 "ntp_parser.y" /* yacc.c:1646 */ 2985 { CONCAT_G_FIFOS(cfgt.logconfig, (yyvsp[0].Attr_val_fifo)); } 2986 #line 2987 "ntp_parser.c" /* yacc.c:1646 */ 2987 break; 2988 2989 case 237: 2990 #line 1242 "ntp_parser.y" /* yacc.c:1646 */ 2991 { CONCAT_G_FIFOS(cfgt.phone, (yyvsp[0].String_fifo)); } 2992 #line 2993 "ntp_parser.c" /* yacc.c:1646 */ 2993 break; 2994 2995 case 238: 2996 #line 1244 "ntp_parser.y" /* yacc.c:1646 */ 2997 { APPEND_G_FIFO(cfgt.setvar, (yyvsp[0].Set_var)); } 2998 #line 2999 "ntp_parser.c" /* yacc.c:1646 */ 2999 break; 3000 3001 case 239: 3002 #line 1246 "ntp_parser.y" /* yacc.c:1646 */ 3003 { 3004 addr_opts_node *aon; 3005 3006 aon = create_addr_opts_node((yyvsp[-1].Address_node), (yyvsp[0].Attr_val_fifo)); 3007 APPEND_G_FIFO(cfgt.trap, aon); 3008 } 3009 #line 3010 "ntp_parser.c" /* yacc.c:1646 */ 3010 break; 3011 3012 case 240: 3013 #line 1253 "ntp_parser.y" /* yacc.c:1646 */ 3014 { CONCAT_G_FIFOS(cfgt.ttl, (yyvsp[0].Attr_val_fifo)); } 3015 #line 3016 "ntp_parser.c" /* yacc.c:1646 */ 3016 break; 3017 3018 case 245: 3019 #line 1268 "ntp_parser.y" /* yacc.c:1646 */ 3020 { 3021 #ifndef LEAP_SMEAR 3022 yyerror("Built without LEAP_SMEAR support."); 3023 #endif 3024 } 3025 #line 3026 "ntp_parser.c" /* yacc.c:1646 */ 3026 break; 3027 3028 case 251: 3029 #line 1288 "ntp_parser.y" /* yacc.c:1646 */ 3030 { 3031 if (lex_from_file()) { 3032 attr_val *av; 3033 av = create_attr_sval(T_Driftfile, (yyvsp[0].String)); 3034 APPEND_G_FIFO(cfgt.vars, av); 3035 } else { 3036 YYFREE((yyvsp[0].String)); 3037 yyerror("driftfile remote configuration ignored"); 3038 } 3039 } 3040 #line 3041 "ntp_parser.c" /* yacc.c:1646 */ 3041 break; 3042 3043 case 252: 3044 #line 1299 "ntp_parser.y" /* yacc.c:1646 */ 3045 { 3046 if (lex_from_file()) { 3047 attr_val *av; 3048 av = create_attr_sval(T_Driftfile, (yyvsp[-1].String)); 3049 APPEND_G_FIFO(cfgt.vars, av); 3050 av = create_attr_dval(T_WanderThreshold, (yyvsp[0].Double)); 3051 APPEND_G_FIFO(cfgt.vars, av); 3052 msyslog(LOG_WARNING, 3053 "'driftfile FILENAME WanderValue' is deprecated, " 3054 "please use separate 'driftfile FILENAME' and " 3055 "'nonvolatile WanderValue' lines instead."); 3056 } else { 3057 YYFREE((yyvsp[-1].String)); 3058 yyerror("driftfile remote configuration ignored"); 3059 } 3060 } 3061 #line 3062 "ntp_parser.c" /* yacc.c:1646 */ 3062 break; 3063 3064 case 253: 3065 #line 1316 "ntp_parser.y" /* yacc.c:1646 */ 3066 { 3067 if (lex_from_file()) { 3068 attr_val *av; 3069 av = create_attr_sval(T_Driftfile, estrdup("")); 3070 APPEND_G_FIFO(cfgt.vars, av); 3071 } else { 3072 yyerror("driftfile remote configuration ignored"); 3073 } 3074 } 3075 #line 3076 "ntp_parser.c" /* yacc.c:1646 */ 3076 break; 3077 3078 case 254: 3079 #line 1329 "ntp_parser.y" /* yacc.c:1646 */ 3080 { (yyval.Set_var) = create_setvar_node((yyvsp[-3].String), (yyvsp[-1].String), (yyvsp[0].Integer)); } 3081 #line 3082 "ntp_parser.c" /* yacc.c:1646 */ 3082 break; 3083 3084 case 256: 3085 #line 1335 "ntp_parser.y" /* yacc.c:1646 */ 3086 { (yyval.Integer) = 0; } 3087 #line 3088 "ntp_parser.c" /* yacc.c:1646 */ 3088 break; 3089 3090 case 257: 3091 #line 1340 "ntp_parser.y" /* yacc.c:1646 */ 3092 { (yyval.Attr_val_fifo) = NULL; } 3093 #line 3094 "ntp_parser.c" /* yacc.c:1646 */ 3094 break; 3095 3096 case 258: 3097 #line 1342 "ntp_parser.y" /* yacc.c:1646 */ 3098 { 3099 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 3100 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 3101 } 3102 #line 3103 "ntp_parser.c" /* yacc.c:1646 */ 3103 break; 3104 3105 case 259: 3106 #line 1350 "ntp_parser.y" /* yacc.c:1646 */ 3107 { (yyval.Attr_val) = create_attr_ival((yyvsp[-1].Integer), (yyvsp[0].Integer)); } 3108 #line 3109 "ntp_parser.c" /* yacc.c:1646 */ 3109 break; 3110 3111 case 260: 3112 #line 1352 "ntp_parser.y" /* yacc.c:1646 */ 3113 { 3114 (yyval.Attr_val) = create_attr_sval((yyvsp[-1].Integer), estrdup((yyvsp[0].Address_node)->address)); 3115 destroy_address_node((yyvsp[0].Address_node)); 3116 } 3117 #line 3118 "ntp_parser.c" /* yacc.c:1646 */ 3118 break; 3119 3120 case 261: 3121 #line 1360 "ntp_parser.y" /* yacc.c:1646 */ 3122 { 3123 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 3124 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 3125 } 3126 #line 3127 "ntp_parser.c" /* yacc.c:1646 */ 3127 break; 3128 3129 case 262: 3130 #line 1365 "ntp_parser.y" /* yacc.c:1646 */ 3131 { 3132 (yyval.Attr_val_fifo) = NULL; 3133 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 3134 } 3135 #line 3136 "ntp_parser.c" /* yacc.c:1646 */ 3136 break; 3137 3138 case 263: 3139 #line 1373 "ntp_parser.y" /* yacc.c:1646 */ 3140 { 3141 char prefix; 3142 char * type; 3143 3144 switch ((yyvsp[0].String)[0]) { 3145 3146 case '+': 3147 case '-': 3148 case '=': 3149 prefix = (yyvsp[0].String)[0]; 3150 type = (yyvsp[0].String) + 1; 3151 break; 3152 3153 default: 3154 prefix = '='; 3155 type = (yyvsp[0].String); 3156 } 3157 3158 (yyval.Attr_val) = create_attr_sval(prefix, estrdup(type)); 3159 YYFREE((yyvsp[0].String)); 3160 } 3161 #line 3162 "ntp_parser.c" /* yacc.c:1646 */ 3162 break; 3163 3164 case 264: 3165 #line 1398 "ntp_parser.y" /* yacc.c:1646 */ 3166 { 3167 nic_rule_node *nrn; 3168 3169 nrn = create_nic_rule_node((yyvsp[0].Integer), NULL, (yyvsp[-1].Integer)); 3170 APPEND_G_FIFO(cfgt.nic_rules, nrn); 3171 } 3172 #line 3173 "ntp_parser.c" /* yacc.c:1646 */ 3173 break; 3174 3175 case 265: 3176 #line 1405 "ntp_parser.y" /* yacc.c:1646 */ 3177 { 3178 nic_rule_node *nrn; 3179 3180 nrn = create_nic_rule_node(0, (yyvsp[0].String), (yyvsp[-1].Integer)); 3181 APPEND_G_FIFO(cfgt.nic_rules, nrn); 3182 } 3183 #line 3184 "ntp_parser.c" /* yacc.c:1646 */ 3184 break; 3185 3186 case 275: 3187 #line 1433 "ntp_parser.y" /* yacc.c:1646 */ 3188 { CONCAT_G_FIFOS(cfgt.reset_counters, (yyvsp[0].Int_fifo)); } 3189 #line 3190 "ntp_parser.c" /* yacc.c:1646 */ 3190 break; 3191 3192 case 276: 3193 #line 1438 "ntp_parser.y" /* yacc.c:1646 */ 3194 { 3195 (yyval.Int_fifo) = (yyvsp[-1].Int_fifo); 3196 APPEND_G_FIFO((yyval.Int_fifo), create_int_node((yyvsp[0].Integer))); 3197 } 3198 #line 3199 "ntp_parser.c" /* yacc.c:1646 */ 3199 break; 3200 3201 case 277: 3202 #line 1443 "ntp_parser.y" /* yacc.c:1646 */ 3203 { 3204 (yyval.Int_fifo) = NULL; 3205 APPEND_G_FIFO((yyval.Int_fifo), create_int_node((yyvsp[0].Integer))); 3206 } 3207 #line 3208 "ntp_parser.c" /* yacc.c:1646 */ 3208 break; 3209 3210 case 285: 3211 #line 1467 "ntp_parser.y" /* yacc.c:1646 */ 3212 { 3213 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 3214 APPEND_G_FIFO((yyval.Attr_val_fifo), create_int_node((yyvsp[0].Integer))); 3215 } 3216 #line 3217 "ntp_parser.c" /* yacc.c:1646 */ 3217 break; 3218 3219 case 286: 3220 #line 1472 "ntp_parser.y" /* yacc.c:1646 */ 3221 { 3222 (yyval.Attr_val_fifo) = NULL; 3223 APPEND_G_FIFO((yyval.Attr_val_fifo), create_int_node((yyvsp[0].Integer))); 3224 } 3225 #line 3226 "ntp_parser.c" /* yacc.c:1646 */ 3226 break; 3227 3228 case 287: 3229 #line 1480 "ntp_parser.y" /* yacc.c:1646 */ 3230 { 3231 (yyval.Attr_val_fifo) = (yyvsp[-1].Attr_val_fifo); 3232 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 3233 } 3234 #line 3235 "ntp_parser.c" /* yacc.c:1646 */ 3235 break; 3236 3237 case 288: 3238 #line 1485 "ntp_parser.y" /* yacc.c:1646 */ 3239 { 3240 (yyval.Attr_val_fifo) = NULL; 3241 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[0].Attr_val)); 3242 } 3243 #line 3244 "ntp_parser.c" /* yacc.c:1646 */ 3244 break; 3245 3246 case 289: 3247 #line 1493 "ntp_parser.y" /* yacc.c:1646 */ 3248 { (yyval.Attr_val) = create_attr_ival('i', (yyvsp[0].Integer)); } 3249 #line 3250 "ntp_parser.c" /* yacc.c:1646 */ 3250 break; 3251 3252 case 291: 3253 #line 1499 "ntp_parser.y" /* yacc.c:1646 */ 3254 { (yyval.Attr_val) = create_attr_rangeval('-', (yyvsp[-3].Integer), (yyvsp[-1].Integer)); } 3255 #line 3256 "ntp_parser.c" /* yacc.c:1646 */ 3256 break; 3257 3258 case 292: 3259 #line 1504 "ntp_parser.y" /* yacc.c:1646 */ 3260 { 3261 (yyval.String_fifo) = (yyvsp[-1].String_fifo); 3262 APPEND_G_FIFO((yyval.String_fifo), create_string_node((yyvsp[0].String))); 3263 } 3264 #line 3265 "ntp_parser.c" /* yacc.c:1646 */ 3265 break; 3266 3267 case 293: 3268 #line 1509 "ntp_parser.y" /* yacc.c:1646 */ 3269 { 3270 (yyval.String_fifo) = NULL; 3271 APPEND_G_FIFO((yyval.String_fifo), create_string_node((yyvsp[0].String))); 3272 } 3273 #line 3274 "ntp_parser.c" /* yacc.c:1646 */ 3274 break; 3275 3276 case 294: 3277 #line 1517 "ntp_parser.y" /* yacc.c:1646 */ 3278 { 3279 (yyval.Address_fifo) = (yyvsp[-1].Address_fifo); 3280 APPEND_G_FIFO((yyval.Address_fifo), (yyvsp[0].Address_node)); 3281 } 3282 #line 3283 "ntp_parser.c" /* yacc.c:1646 */ 3283 break; 3284 3285 case 295: 3286 #line 1522 "ntp_parser.y" /* yacc.c:1646 */ 3287 { 3288 (yyval.Address_fifo) = NULL; 3289 APPEND_G_FIFO((yyval.Address_fifo), (yyvsp[0].Address_node)); 3290 } 3291 #line 3292 "ntp_parser.c" /* yacc.c:1646 */ 3292 break; 3293 3294 case 296: 3295 #line 1530 "ntp_parser.y" /* yacc.c:1646 */ 3296 { 3297 if ((yyvsp[0].Integer) != 0 && (yyvsp[0].Integer) != 1) { 3298 yyerror("Integer value is not boolean (0 or 1). Assuming 1"); 3299 (yyval.Integer) = 1; 3300 } else { 3301 (yyval.Integer) = (yyvsp[0].Integer); 3302 } 3303 } 3304 #line 3305 "ntp_parser.c" /* yacc.c:1646 */ 3305 break; 3306 3307 case 297: 3308 #line 1538 "ntp_parser.y" /* yacc.c:1646 */ 3309 { (yyval.Integer) = 1; } 3310 #line 3311 "ntp_parser.c" /* yacc.c:1646 */ 3311 break; 3312 3313 case 298: 3314 #line 1539 "ntp_parser.y" /* yacc.c:1646 */ 3315 { (yyval.Integer) = 0; } 3316 #line 3317 "ntp_parser.c" /* yacc.c:1646 */ 3317 break; 3318 3319 case 299: 3320 #line 1543 "ntp_parser.y" /* yacc.c:1646 */ 3321 { (yyval.Double) = (double)(yyvsp[0].Integer); } 3322 #line 3323 "ntp_parser.c" /* yacc.c:1646 */ 3323 break; 3324 3325 case 301: 3326 #line 1549 "ntp_parser.y" /* yacc.c:1646 */ 3327 { (yyval.Integer) = basedate_eval_string((yyvsp[0].String)); YYFREE((yyvsp[0].String)); } 3328 #line 3329 "ntp_parser.c" /* yacc.c:1646 */ 3329 break; 3330 3331 case 302: 3332 #line 1557 "ntp_parser.y" /* yacc.c:1646 */ 3333 { 3334 sim_node *sn; 3335 3336 sn = create_sim_node((yyvsp[-2].Attr_val_fifo), (yyvsp[-1].Sim_server_fifo)); 3337 APPEND_G_FIFO(cfgt.sim_details, sn); 3338 3339 /* Revert from ; to \n for end-of-command */ 3340 old_config_style = 1; 3341 } 3342 #line 3343 "ntp_parser.c" /* yacc.c:1646 */ 3343 break; 3344 3345 case 303: 3346 #line 1574 "ntp_parser.y" /* yacc.c:1646 */ 3347 { old_config_style = 0; } 3348 #line 3349 "ntp_parser.c" /* yacc.c:1646 */ 3349 break; 3350 3351 case 304: 3352 #line 1579 "ntp_parser.y" /* yacc.c:1646 */ 3353 { 3354 (yyval.Attr_val_fifo) = (yyvsp[-2].Attr_val_fifo); 3355 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[-1].Attr_val)); 3356 } 3357 #line 3358 "ntp_parser.c" /* yacc.c:1646 */ 3358 break; 3359 3360 case 305: 3361 #line 1584 "ntp_parser.y" /* yacc.c:1646 */ 3362 { 3363 (yyval.Attr_val_fifo) = NULL; 3364 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[-1].Attr_val)); 3365 } 3366 #line 3367 "ntp_parser.c" /* yacc.c:1646 */ 3367 break; 3368 3369 case 306: 3370 #line 1592 "ntp_parser.y" /* yacc.c:1646 */ 3371 { (yyval.Attr_val) = create_attr_dval((yyvsp[-2].Integer), (yyvsp[0].Double)); } 3372 #line 3373 "ntp_parser.c" /* yacc.c:1646 */ 3373 break; 3374 3375 case 309: 3376 #line 1602 "ntp_parser.y" /* yacc.c:1646 */ 3377 { 3378 (yyval.Sim_server_fifo) = (yyvsp[-1].Sim_server_fifo); 3379 APPEND_G_FIFO((yyval.Sim_server_fifo), (yyvsp[0].Sim_server)); 3380 } 3381 #line 3382 "ntp_parser.c" /* yacc.c:1646 */ 3382 break; 3383 3384 case 310: 3385 #line 1607 "ntp_parser.y" /* yacc.c:1646 */ 3386 { 3387 (yyval.Sim_server_fifo) = NULL; 3388 APPEND_G_FIFO((yyval.Sim_server_fifo), (yyvsp[0].Sim_server)); 3389 } 3390 #line 3391 "ntp_parser.c" /* yacc.c:1646 */ 3391 break; 3392 3393 case 311: 3394 #line 1615 "ntp_parser.y" /* yacc.c:1646 */ 3395 { (yyval.Sim_server) = ONLY_SIM(create_sim_server((yyvsp[-4].Address_node), (yyvsp[-2].Double), (yyvsp[-1].Sim_script_fifo))); } 3396 #line 3397 "ntp_parser.c" /* yacc.c:1646 */ 3397 break; 3398 3399 case 312: 3400 #line 1620 "ntp_parser.y" /* yacc.c:1646 */ 3401 { (yyval.Double) = (yyvsp[-1].Double); } 3402 #line 3403 "ntp_parser.c" /* yacc.c:1646 */ 3403 break; 3404 3405 case 313: 3406 #line 1625 "ntp_parser.y" /* yacc.c:1646 */ 3407 { (yyval.Address_node) = (yyvsp[0].Address_node); } 3408 #line 3409 "ntp_parser.c" /* yacc.c:1646 */ 3409 break; 3410 3411 case 314: 3412 #line 1630 "ntp_parser.y" /* yacc.c:1646 */ 3413 { 3414 (yyval.Sim_script_fifo) = (yyvsp[-1].Sim_script_fifo); 3415 APPEND_G_FIFO((yyval.Sim_script_fifo), (yyvsp[0].Sim_script)); 3416 } 3417 #line 3418 "ntp_parser.c" /* yacc.c:1646 */ 3418 break; 3419 3420 case 315: 3421 #line 1635 "ntp_parser.y" /* yacc.c:1646 */ 3422 { 3423 (yyval.Sim_script_fifo) = NULL; 3424 APPEND_G_FIFO((yyval.Sim_script_fifo), (yyvsp[0].Sim_script)); 3425 } 3426 #line 3427 "ntp_parser.c" /* yacc.c:1646 */ 3427 break; 3428 3429 case 316: 3430 #line 1643 "ntp_parser.y" /* yacc.c:1646 */ 3431 { (yyval.Sim_script) = ONLY_SIM(create_sim_script_info((yyvsp[-3].Double), (yyvsp[-1].Attr_val_fifo))); } 3432 #line 3433 "ntp_parser.c" /* yacc.c:1646 */ 3433 break; 3434 3435 case 317: 3436 #line 1648 "ntp_parser.y" /* yacc.c:1646 */ 3437 { 3438 (yyval.Attr_val_fifo) = (yyvsp[-2].Attr_val_fifo); 3439 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[-1].Attr_val)); 3440 } 3441 #line 3442 "ntp_parser.c" /* yacc.c:1646 */ 3442 break; 3443 3444 case 318: 3445 #line 1653 "ntp_parser.y" /* yacc.c:1646 */ 3446 { 3447 (yyval.Attr_val_fifo) = NULL; 3448 APPEND_G_FIFO((yyval.Attr_val_fifo), (yyvsp[-1].Attr_val)); 3449 } 3450 #line 3451 "ntp_parser.c" /* yacc.c:1646 */ 3451 break; 3452 3453 case 319: 3454 #line 1661 "ntp_parser.y" /* yacc.c:1646 */ 3455 { (yyval.Attr_val) = create_attr_dval((yyvsp[-2].Integer), (yyvsp[0].Double)); } 3456 #line 3457 "ntp_parser.c" /* yacc.c:1646 */ 3457 break; 3458 3459 3460 #line 3461 "ntp_parser.c" /* yacc.c:1646 */ 3461 default: break; 3462 } 3463 /* User semantic actions sometimes alter yychar, and that requires 3464 that yytoken be updated with the new translation. We take the 3465 approach of translating immediately before every use of yytoken. 3466 One alternative is translating here after every semantic action, 3467 but that translation would be missed if the semantic action invokes 3468 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 3469 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 3470 incorrect destructor might then be invoked immediately. In the 3471 case of YYERROR or YYBACKUP, subsequent parser actions might lead 3472 to an incorrect destructor call or verbose syntax error message 3473 before the lookahead is translated. */ 3474 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 3475 3476 YYPOPSTACK (yylen); 3477 yylen = 0; 3478 YY_STACK_PRINT (yyss, yyssp); 3479 3480 *++yyvsp = yyval; 3481 3482 /* Now 'shift' the result of the reduction. Determine what state 3483 that goes to, based on the state we popped back to and the rule 3484 number reduced by. */ 3485 3486 yyn = yyr1[yyn]; 3487 3488 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 3489 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 3490 yystate = yytable[yystate]; 3491 else 3492 yystate = yydefgoto[yyn - YYNTOKENS]; 3493 3494 goto yynewstate; 3495 3496 3497 /*--------------------------------------. 3498 | yyerrlab -- here on detecting error. | 3499 `--------------------------------------*/ 3500 yyerrlab: 3501 /* Make sure we have latest lookahead translation. See comments at 3502 user semantic actions for why this is necessary. */ 3503 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 3504 3505 /* If not already recovering from an error, report this error. */ 3506 if (!yyerrstatus) 3507 { 3508 ++yynerrs; 3509 #if ! YYERROR_VERBOSE 3510 yyerror (YY_("syntax error")); 3511 #else 3512 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 3513 yyssp, yytoken) 3514 { 3515 char const *yymsgp = YY_("syntax error"); 3516 int yysyntax_error_status; 3517 yysyntax_error_status = YYSYNTAX_ERROR; 3518 if (yysyntax_error_status == 0) 3519 yymsgp = yymsg; 3520 else if (yysyntax_error_status == 1) 3521 { 3522 if (yymsg != yymsgbuf) 3523 YYSTACK_FREE (yymsg); 3524 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 3525 if (!yymsg) 3526 { 3527 yymsg = yymsgbuf; 3528 yymsg_alloc = sizeof yymsgbuf; 3529 yysyntax_error_status = 2; 3530 } 3531 else 3532 { 3533 yysyntax_error_status = YYSYNTAX_ERROR; 3534 yymsgp = yymsg; 3535 } 3536 } 3537 yyerror (yymsgp); 3538 if (yysyntax_error_status == 2) 3539 goto yyexhaustedlab; 3540 } 3541 # undef YYSYNTAX_ERROR 3542 #endif 3543 } 3544 3545 3546 3547 if (yyerrstatus == 3) 3548 { 3549 /* If just tried and failed to reuse lookahead token after an 3550 error, discard it. */ 3551 3552 if (yychar <= YYEOF) 3553 { 3554 /* Return failure if at end of input. */ 3555 if (yychar == YYEOF) 3556 YYABORT; 3557 } 3558 else 3559 { 3560 yydestruct ("Error: discarding", 3561 yytoken, &yylval); 3562 yychar = YYEMPTY; 3563 } 3564 } 3565 3566 /* Else will try to reuse lookahead token after shifting the error 3567 token. */ 3568 goto yyerrlab1; 3569 3570 3571 /*---------------------------------------------------. 3572 | yyerrorlab -- error raised explicitly by YYERROR. | 3573 `---------------------------------------------------*/ 3574 yyerrorlab: 3575 3576 /* Pacify compilers like GCC when the user code never invokes 3577 YYERROR and the label yyerrorlab therefore never appears in user 3578 code. */ 3579 if (/*CONSTCOND*/ 0) 3580 goto yyerrorlab; 3581 3582 /* Do not reclaim the symbols of the rule whose action triggered 3583 this YYERROR. */ 3584 YYPOPSTACK (yylen); 3585 yylen = 0; 3586 YY_STACK_PRINT (yyss, yyssp); 3587 yystate = *yyssp; 3588 goto yyerrlab1; 3589 3590 3591 /*-------------------------------------------------------------. 3592 | yyerrlab1 -- common code for both syntax error and YYERROR. | 3593 `-------------------------------------------------------------*/ 3594 yyerrlab1: 3595 yyerrstatus = 3; /* Each real token shifted decrements this. */ 3596 3597 for (;;) 3598 { 3599 yyn = yypact[yystate]; 3600 if (!yypact_value_is_default (yyn)) 3601 { 3602 yyn += YYTERROR; 3603 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 3604 { 3605 yyn = yytable[yyn]; 3606 if (0 < yyn) 3607 break; 3608 } 3609 } 3610 3611 /* Pop the current state because it cannot handle the error token. */ 3612 if (yyssp == yyss) 3613 YYABORT; 3614 3615 3616 yydestruct ("Error: popping", 3617 yystos[yystate], yyvsp); 3618 YYPOPSTACK (1); 3619 yystate = *yyssp; 3620 YY_STACK_PRINT (yyss, yyssp); 3621 } 3622 3623 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3624 *++yyvsp = yylval; 3625 YY_IGNORE_MAYBE_UNINITIALIZED_END 3626 3627 3628 /* Shift the error token. */ 3629 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 3630 3631 yystate = yyn; 3632 goto yynewstate; 3633 3634 3635 /*-------------------------------------. 3636 | yyacceptlab -- YYACCEPT comes here. | 3637 `-------------------------------------*/ 3638 yyacceptlab: 3639 yyresult = 0; 3640 goto yyreturn; 3641 3642 /*-----------------------------------. 3643 | yyabortlab -- YYABORT comes here. | 3644 `-----------------------------------*/ 3645 yyabortlab: 3646 yyresult = 1; 3647 goto yyreturn; 3648 3649 #if !defined yyoverflow || YYERROR_VERBOSE 3650 /*-------------------------------------------------. 3651 | yyexhaustedlab -- memory exhaustion comes here. | 3652 `-------------------------------------------------*/ 3653 yyexhaustedlab: 3654 yyerror (YY_("memory exhausted")); 3655 yyresult = 2; 3656 /* Fall through. */ 3657 #endif 3658 3659 yyreturn: 3660 if (yychar != YYEMPTY) 3661 { 3662 /* Make sure we have latest lookahead translation. See comments at 3663 user semantic actions for why this is necessary. */ 3664 yytoken = YYTRANSLATE (yychar); 3665 yydestruct ("Cleanup: discarding lookahead", 3666 yytoken, &yylval); 3667 } 3668 /* Do not reclaim the symbols of the rule whose action triggered 3669 this YYABORT or YYACCEPT. */ 3670 YYPOPSTACK (yylen); 3671 YY_STACK_PRINT (yyss, yyssp); 3672 while (yyssp != yyss) 3673 { 3674 yydestruct ("Cleanup: popping", 3675 yystos[*yyssp], yyvsp); 3676 YYPOPSTACK (1); 3677 } 3678 #ifndef yyoverflow 3679 if (yyss != yyssa) 3680 YYSTACK_FREE (yyss); 3681 #endif 3682 #if YYERROR_VERBOSE 3683 if (yymsg != yymsgbuf) 3684 YYSTACK_FREE (yymsg); 3685 #endif 3686 return yyresult; 3687 } 3688 #line 1672 "ntp_parser.y" /* yacc.c:1906 */ 3689 3690 3691 void 3692 yyerror( 3693 const char *msg 3694 ) 3695 { 3696 int retval; 3697 struct FILE_INFO * ip_ctx; 3698 3699 ip_ctx = lex_current(); 3700 ip_ctx->errpos = ip_ctx->tokpos; 3701 3702 msyslog(LOG_ERR, "line %d column %d %s", 3703 ip_ctx->errpos.nline, ip_ctx->errpos.ncol, msg); 3704 if (!lex_from_file()) { 3705 /* Save the error message in the correct buffer */ 3706 retval = snprintf(remote_config.err_msg + remote_config.err_pos, 3707 MAXLINE - remote_config.err_pos, 3708 "column %d %s", 3709 ip_ctx->errpos.ncol, msg); 3710 3711 /* Increment the value of err_pos */ 3712 if (retval > 0) 3713 remote_config.err_pos += retval; 3714 3715 /* Increment the number of errors */ 3716 ++remote_config.no_errors; 3717 } 3718 } 3719 3720 3721 /* 3722 * token_name - convert T_ token integers to text 3723 * example: token_name(T_Server) returns "T_Server" 3724 */ 3725 const char * 3726 token_name( 3727 int token 3728 ) 3729 { 3730 return yytname[YYTRANSLATE(token)]; 3731 } 3732 3733 3734 /* Initial Testing function -- ignore */ 3735 #if 0 3736 int main(int argc, char *argv[]) 3737 { 3738 ip_file = FOPEN(argv[1], "r"); 3739 if (!ip_file) 3740 fprintf(stderr, "ERROR!! Could not open file: %s\n", argv[1]); 3741 yyparse(); 3742 return 0; 3743 } 3744 #endif 3745 3746