contrib/ntp/ntpd/ntp_parser.c

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