contrib/ntp/ntpd/ntp_parser.c

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