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