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