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