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