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