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