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