src/cfgparser/oparse.c

   1 /* A Bison parser, made by GNU Bison 1.875a.  */
   2
   3 /* Skeleton parser for Yacc-like parsing with Bison,
   4    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 /* As a special exception, when this file is copied by Bison into a
  22    Bison output file, you may use that output file without restriction.
  23    This special exception was added by the Free Software Foundation
  24    in version 1.24 of Bison.  */
  25
  26 /* Written by Richard Stallman by simplifying the original so called
  27    ``semantic'' parser.  */
  28
  29 /* All symbols defined below should begin with yy or YY, to avoid
  30    infringing on user name space.  This should be done even for local
  31    variables, as they might otherwise be expanded by user macros.
  32    There are some unavoidable exceptions within include files to
  33    define necessary library symbols; they are noted "INFRINGES ON
  34    USER NAME SPACE" below.  */
  35
  36 /* Identify Bison output.  */
  37 #define YYBISON 1
  38
  39 /* Skeleton name.  */
  40 #define YYSKELETON_NAME "yacc.c"
  41
  42 /* Pure parsers.  */
  43 #define YYPURE 0
  44
  45 /* Using locations.  */
  46 #define YYLSP_NEEDED 0
  47
  48
  49
  50 /* Tokens.  */
  51 #ifndef YYTOKENTYPE
  52 # define YYTOKENTYPE
  53    /* Put the tokens into the symbol table, so that GDB and other debuggers
  54       know about them.  */
  55    enum yytokentype {
  56      TOK_OPEN = 258,
  57      TOK_CLOSE = 259,
  58      TOK_SEMI = 260,
  59      TOK_STRING = 261,
  60      TOK_INTEGER = 262,
  61      TOK_FLOAT = 263,
  62      TOK_BOOLEAN = 264,
  63      TOK_IP6TYPE = 265,
  64      TOK_DEBUGLEVEL = 266,
  65      TOK_IPVERSION = 267,
  66      TOK_HNA4 = 268,
  67      TOK_HNA6 = 269,
  68      TOK_PLUGIN = 270,
  69      TOK_INTERFACES = 271,
  70      TOK_IFSETUP = 272,
  71      TOK_NOINT = 273,
  72      TOK_TOS = 274,
  73      TOK_WILLINGNESS = 275,
  74      TOK_IPCCON = 276,
  75      TOK_USEHYST = 277,
  76      TOK_HYSTSCALE = 278,
  77      TOK_HYSTUPPER = 279,
  78      TOK_HYSTLOWER = 280,
  79      TOK_POLLRATE = 281,
  80      TOK_TCREDUNDANCY = 282,
  81      TOK_MPRCOVERAGE = 283,
  82      TOK_PLNAME = 284,
  83      TOK_PLPARAM = 285,
  84      TOK_IP4BROADCAST = 286,
  85      TOK_IP6ADDRTYPE = 287,
  86      TOK_IP6MULTISITE = 288,
  87      TOK_IP6MULTIGLOBAL = 289,
  88      TOK_HELLOINT = 290,
  89      TOK_HELLOVAL = 291,
  90      TOK_TCINT = 292,
  91      TOK_TCVAL = 293,
  92      TOK_MIDINT = 294,
  93      TOK_MIDVAL = 295,
  94      TOK_HNAINT = 296,
  95      TOK_HNAVAL = 297,
  96      TOK_IP4_ADDR = 298,
  97      TOK_IP6_ADDR = 299,
  98      TOK_COMMENT = 300
  99    };
 100 #endif
 101 #define TOK_OPEN 258
 102 #define TOK_CLOSE 259
 103 #define TOK_SEMI 260
 104 #define TOK_STRING 261
 105 #define TOK_INTEGER 262
 106 #define TOK_FLOAT 263
 107 #define TOK_BOOLEAN 264
 108 #define TOK_IP6TYPE 265
 109 #define TOK_DEBUGLEVEL 266
 110 #define TOK_IPVERSION 267
 111 #define TOK_HNA4 268
 112 #define TOK_HNA6 269
 113 #define TOK_PLUGIN 270
 114 #define TOK_INTERFACES 271
 115 #define TOK_IFSETUP 272
 116 #define TOK_NOINT 273
 117 #define TOK_TOS 274
 118 #define TOK_WILLINGNESS 275
 119 #define TOK_IPCCON 276
 120 #define TOK_USEHYST 277
 121 #define TOK_HYSTSCALE 278
 122 #define TOK_HYSTUPPER 279
 123 #define TOK_HYSTLOWER 280
 124 #define TOK_POLLRATE 281
 125 #define TOK_TCREDUNDANCY 282
 126 #define TOK_MPRCOVERAGE 283
 127 #define TOK_PLNAME 284
 128 #define TOK_PLPARAM 285
 129 #define TOK_IP4BROADCAST 286
 130 #define TOK_IP6ADDRTYPE 287
 131 #define TOK_IP6MULTISITE 288
 132 #define TOK_IP6MULTIGLOBAL 289
 133 #define TOK_HELLOINT 290
 134 #define TOK_HELLOVAL 291
 135 #define TOK_TCINT 292
 136 #define TOK_TCVAL 293
 137 #define TOK_MIDINT 294
 138 #define TOK_MIDVAL 295
 139 #define TOK_HNAINT 296
 140 #define TOK_HNAVAL 297
 141 #define TOK_IP4_ADDR 298
 142 #define TOK_IP6_ADDR 299
 143 #define TOK_COMMENT 300
 144
 145
 146
 147
 148 /* Copy the first part of user declarations.  */
 149 #line 1 "src/cfgparser/oparse.y"
 150
 151
 152 /*
 153  * OLSR ad-hoc routing table management protocol config parser
 154  * Copyright (C) 2004 Andreas Tønnesen (andreto@olsr.org)
 155  *
 156  * This file is part of the olsr.org OLSR daemon.
 157  *
 158  * olsr.org is free software; you can redistribute it and/or modify
 159  * it under the terms of the GNU General Public License as published by
 160  * the Free Software Foundation; either version 2 of the License, or
 161  * (at your option) any later version.
 162  *
 163  * olsr.org is distributed in the hope that it will be useful,
 164  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 165  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 166  * GNU General Public License for more details.
 167  *
 168  * You should have received a copy of the GNU General Public License
 169  * along with olsr.org; if not, write to the Free Software
 170  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 171  *
 172  *
 173  * $Id: oparse.c,v 1.3 2004/10/17 12:28:02 kattemat Exp $
 174  *
 175  */
 176
 177
 178 #include <stddef.h>
 179 #include <stdio.h>
 180 #include <stdlib.h>
 181 #include <sys/socket.h>
 182 #include <netinet/in.h>
 183 #include <arpa/inet.h>
 184 #include <string.h>
 185
 186 #include "olsrd_conf.h"
 187
 188 #define PARSER_DEBUG 0
 189
 190 #define YYSTYPE struct conf_token *
 191
 192 void yyerror(char *);
 193 int yylex(void);
 194
 195 struct if_config_options *
 196 get_default_if_config(void);
 197
 198
 199 struct if_config_options *
 200 get_default_if_config()
 201 {
 202   struct if_config_options *io = malloc(sizeof(struct if_config_options));
 203   struct in6_addr in6;
 204
 205   memset(io, 0, sizeof(struct if_config_options));
 206
 207   io->ipv6_addrtype = 1;
 208
 209   if(inet_pton(AF_INET6, OLSR_IPV6_MCAST_SITE_LOCAL, &in6) < 0)
 210     {
 211       fprintf(stderr, "Failed converting IP address %s\n", OLSR_IPV6_MCAST_SITE_LOCAL);
 212       exit(EXIT_FAILURE);
 213     }
 214   memcpy(&io->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
 215
 216   if(inet_pton(AF_INET6, OLSR_IPV6_MCAST_GLOBAL, &in6) < 0)
 217     {
 218       fprintf(stderr, "Failed converting IP address %s\n", OLSR_IPV6_MCAST_GLOBAL);
 219       exit(EXIT_FAILURE);
 220     }
 221   memcpy(&io->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
 222
 223
 224   io->hello_params.emission_interval = HELLO_INTERVAL;
 225   io->hello_params.validity_time = NEIGHB_HOLD_TIME;
 226   io->tc_params.emission_interval = TC_INTERVAL;
 227   io->tc_params.validity_time = TOP_HOLD_TIME;
 228   io->mid_params.emission_interval = MID_INTERVAL;
 229   io->mid_params.validity_time = MID_HOLD_TIME;
 230   io->hna_params.emission_interval = HNA_INTERVAL;
 231   io->hna_params.validity_time = HNA_HOLD_TIME;
 232
 233   return io;
 234
 235 }
 236
 237
 238
 239
 240
 241
 242 /* Enabling traces.  */
 243 #ifndef YYDEBUG
 244 # define YYDEBUG 0
 245 #endif
 246
 247 /* Enabling verbose error messages.  */
 248 #ifdef YYERROR_VERBOSE
 249 # undef YYERROR_VERBOSE
 250 # define YYERROR_VERBOSE 1
 251 #else
 252 # define YYERROR_VERBOSE 0
 253 #endif
 254
 255 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
 256 typedef int YYSTYPE;
 257 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 258 # define YYSTYPE_IS_DECLARED 1
 259 # define YYSTYPE_IS_TRIVIAL 1
 260 #endif
 261
 262
 263
 264 /* Copy the second part of user declarations.  */
 265
 266
 267 /* Line 214 of yacc.c.  */
 268 #line 269 "y.tab.c"
 269
 270 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 271
 272 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 273
 274 # if YYSTACK_USE_ALLOCA
 275 #  define YYSTACK_ALLOC alloca
 276 # else
 277 #  ifndef YYSTACK_USE_ALLOCA
 278 #   if defined (alloca) || defined (_ALLOCA_H)
 279 #    define YYSTACK_ALLOC alloca
 280 #   else
 281 #    ifdef __GNUC__
 282 #     define YYSTACK_ALLOC __builtin_alloca
 283 #    endif
 284 #   endif
 285 #  endif
 286 # endif
 287
 288 # ifdef YYSTACK_ALLOC
 289    /* Pacify GCC's `empty if-body' warning. */
 290 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 291 # else
 292 #  if defined (__STDC__) || defined (__cplusplus)
 293 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 294 #   define YYSIZE_T size_t
 295 #  endif
 296 #  define YYSTACK_ALLOC malloc
 297 #  define YYSTACK_FREE free
 298 # endif
 299 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
 300
 301
 302 #if (! defined (yyoverflow) \
 303      && (! defined (__cplusplus) \
 304          || (YYSTYPE_IS_TRIVIAL)))
 305
 306 /* A type that is properly aligned for any stack member.  */
 307 union yyalloc
 308 {
 309   short yyss;
 310   YYSTYPE yyvs;
 311   };
 312
 313 /* The size of the maximum gap between one aligned stack and the next.  */
 314 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 315
 316 /* The size of an array large to enough to hold all stacks, each with
 317    N elements.  */
 318 # define YYSTACK_BYTES(N) \
 319      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
 320       + YYSTACK_GAP_MAXIMUM)
 321
 322 /* Copy COUNT objects from FROM to TO.  The source and destination do
 323    not overlap.  */
 324 # ifndef YYCOPY
 325 #  if 1 < __GNUC__
 326 #   define YYCOPY(To, From, Count) \
 327       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 328 #  else
 329 #   define YYCOPY(To, From, Count)              \
 330       do                                        \
 331         {                                       \
 332           register YYSIZE_T yyi;                \
 333           for (yyi = 0; yyi < (Count); yyi++)   \
 334             (To)[yyi] = (From)[yyi];            \
 335         }                                       \
 336       while (0)
 337 #  endif
 338 # endif
 339
 340 /* Relocate STACK from its old location to the new one.  The
 341    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 342    elements in the stack, and YYPTR gives the new location of the
 343    stack.  Advance YYPTR to a properly aligned location for the next
 344    stack.  */
 345 # define YYSTACK_RELOCATE(Stack)                                        \
 346     do                                                                  \
 347       {                                                                 \
 348         YYSIZE_T yynewbytes;                                            \
 349         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 350         Stack = &yyptr->Stack;                                          \
 351         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 352         yyptr += yynewbytes / sizeof (*yyptr);                          \
 353       }                                                                 \
 354     while (0)
 355
 356 #endif
 357
 358 #if defined (__STDC__) || defined (__cplusplus)
 359    typedef signed char yysigned_char;
 360 #else
 361    typedef short yysigned_char;
 362 #endif
 363
 364 /* YYFINAL -- State number of the termination state. */
 365 #define YYFINAL  2
 366 /* YYLAST -- Last index in YYTABLE.  */
 367 #define YYLAST   84
 368
 369 /* YYNTOKENS -- Number of terminals. */
 370 #define YYNTOKENS  46
 371 /* YYNNTS -- Number of nonterminals. */
 372 #define YYNNTS  49
 373 /* YYNRULES -- Number of rules. */
 374 #define YYNRULES  87
 375 /* YYNRULES -- Number of states. */
 376 #define YYNSTATES  130
 377
 378 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 379 #define YYUNDEFTOK  2
 380 #define YYMAXUTOK   300
 381
 382 #define YYTRANSLATE(YYX)                                                \
 383   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 384
 385 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 386 static const unsigned char yytranslate[] =
 387 {
 388        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 389        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 390        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 391        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 392        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 393        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 394        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 395        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 396        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 397        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 398        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 399        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 400        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 401        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 402        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 403        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 404        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 405        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 406        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 407        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 408        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 409        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 410        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 411        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 412        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 413        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 414        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 415       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 416       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
 417       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
 418       45
 419 };
 420
 421 #if YYDEBUG
 422 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 423    YYRHS.  */
 424 static const unsigned char yyprhs[] =
 425 {
 426        0,     0,     3,     4,     7,    10,    12,    14,    16,    18,
 427       20,    22,    24,    26,    28,    30,    32,    34,    36,    38,
 428       41,    44,    47,    50,    53,    57,    58,    61,    65,    66,
 429       69,    73,    74,    77,    79,    81,    85,    86,    89,    91,
 430       93,    95,    97,    99,   101,   103,   105,   107,   109,   111,
 431      113,   115,   119,   120,   123,   125,   127,   130,   133,   136,
 432      139,   142,   145,   148,   151,   154,   157,   160,   163,   166,
 433      169,   172,   175,   178,   181,   184,   187,   190,   193,   196,
 434      199,   202,   205,   208,   211,   214,   217,   221
 435 };
 436
 437 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 438 static const yysigned_char yyrhs[] =
 439 {
 440       47,     0,    -1,    -1,    47,    49,    -1,    47,    48,    -1,
 441       76,    -1,    77,    -1,    81,    -1,    82,    -1,    83,    -1,
 442       84,    -1,    85,    -1,    86,    -1,    87,    -1,    88,    -1,
 443       89,    -1,    90,    -1,    91,    -1,    94,    -1,    13,    50,
 444       -1,    14,    52,    -1,    16,    54,    -1,    92,    60,    -1,
 445       63,    57,    -1,     3,    51,     4,    -1,    -1,    51,    78,
 446       -1,     3,    53,     4,    -1,    -1,    53,    79,    -1,     3,
 447       55,     4,    -1,    -1,    55,    56,    -1,    80,    -1,    94,
 448       -1,     3,    58,     4,    -1,    -1,    58,    59,    -1,    94,
 449       -1,    64,    -1,    65,    -1,    66,    -1,    67,    -1,    68,
 450       -1,    69,    -1,    70,    -1,    71,    -1,    72,    -1,    73,
 451       -1,    74,    -1,    75,    -1,     3,    61,     4,    -1,    -1,
 452       61,    62,    -1,    93,    -1,    94,    -1,    17,     6,    -1,
 453       31,    43,    -1,    32,    10,    -1,    33,    44,    -1,    34,
 454       44,    -1,    35,     8,    -1,    36,     8,    -1,    37,     8,
 455       -1,    38,     8,    -1,    39,     8,    -1,    40,     8,    -1,
 456       41,     8,    -1,    42,     8,    -1,    11,     7,    -1,    12,
 457        7,    -1,    43,    43,    -1,    44,     7,    -1,     6,     6,
 458       -1,    18,     9,    -1,    19,     7,    -1,    20,     7,    -1,
 459       21,     9,    -1,    22,     9,    -1,    23,     8,    -1,    24,
 460        8,    -1,    25,     8,    -1,    26,     8,    -1,    27,     7,
 461       -1,    28,     7,    -1,    15,     6,    -1,    30,     6,     6,
 462       -1,    45,    -1
 463 };
 464
 465 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 466 static const unsigned short yyrline[] =
 467 {
 468        0,   145,   145,   146,   147,   150,   151,   152,   153,   154,
 469      155,   156,   157,   158,   159,   160,   161,   162,   163,   166,
 470      167,   168,   169,   170,   173,   176,   176,   179,   182,   182,
 471      185,   188,   188,   191,   192,   195,   198,   198,   201,   202,
 472      203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
 473      213,   216,   219,   219,   222,   223,   229,   252,   271,   279,
 474      299,   317,   324,   331,   338,   345,   352,   359,   366,   375,
 475      393,   407,   443,   480,   504,   511,   526,   541,   557,   573,
 476      582,   591,   599,   609,   625,   641,   663,   675
 477 };
 478 #endif
 479
 480 #if YYDEBUG || YYERROR_VERBOSE
 481 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 482    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 483 static const char *const yytname[] =
 484 {
 485   "$end", "error", "$undefined", "TOK_OPEN", "TOK_CLOSE", "TOK_SEMI",
 486   "TOK_STRING", "TOK_INTEGER", "TOK_FLOAT", "TOK_BOOLEAN", "TOK_IP6TYPE",
 487   "TOK_DEBUGLEVEL", "TOK_IPVERSION", "TOK_HNA4", "TOK_HNA6", "TOK_PLUGIN",
 488   "TOK_INTERFACES", "TOK_IFSETUP", "TOK_NOINT", "TOK_TOS",
 489   "TOK_WILLINGNESS", "TOK_IPCCON", "TOK_USEHYST", "TOK_HYSTSCALE",
 490   "TOK_HYSTUPPER", "TOK_HYSTLOWER", "TOK_POLLRATE", "TOK_TCREDUNDANCY",
 491   "TOK_MPRCOVERAGE", "TOK_PLNAME", "TOK_PLPARAM", "TOK_IP4BROADCAST",
 492   "TOK_IP6ADDRTYPE", "TOK_IP6MULTISITE", "TOK_IP6MULTIGLOBAL",
 493   "TOK_HELLOINT", "TOK_HELLOVAL", "TOK_TCINT", "TOK_TCVAL", "TOK_MIDINT",
 494   "TOK_MIDVAL", "TOK_HNAINT", "TOK_HNAVAL", "TOK_IP4_ADDR",
 495   "TOK_IP6_ADDR", "TOK_COMMENT", "$accept", "conf", "stmt", "block",
 496   "hna4body", "hna4stmts", "hna6body", "hna6stmts", "ifbody", "ifstmts",
 497   "ifstmt", "isetbody", "isetstmts", "isetstmt", "plbody", "plstmts",
 498   "plstmt", "isetblock", "isetip4br", "isetip6addrt", "isetip6mults",
 499   "isetip6multg", "isethelloint", "isethelloval", "isettcint",
 500   "isettcval", "isetmidint", "isetmidval", "isethnaint", "isethnaval",
 501   "idebug", "iipversion", "ihna4entry", "ihna6entry", "ifentry", "bnoint",
 502   "atos", "awillingness", "bipccon", "busehyst", "fhystscale",
 503   "fhystupper", "fhystlower", "fpollrate", "atcredundancy",
 504   "amprcoverage", "plblock", "plparam", "vcomment", 0
 505 };
 506 #endif
 507
 508 # ifdef YYPRINT
 509 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 510    token YYLEX-NUM.  */
 511 static const unsigned short yytoknum[] =
 512 {
 513        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 514      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
 515      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
 516      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
 517      295,   296,   297,   298,   299,   300
 518 };
 519 # endif
 520
 521 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 522 static const unsigned char yyr1[] =
 523 {
 524        0,    46,    47,    47,    47,    48,    48,    48,    48,    48,
 525       48,    48,    48,    48,    48,    48,    48,    48,    48,    49,
 526       49,    49,    49,    49,    50,    51,    51,    52,    53,    53,
 527       54,    55,    55,    56,    56,    57,    58,    58,    59,    59,
 528       59,    59,    59,    59,    59,    59,    59,    59,    59,    59,
 529       59,    60,    61,    61,    62,    62,    63,    64,    65,    66,
 530       67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
 531       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
 532       87,    88,    89,    90,    91,    92,    93,    94
 533 };
 534
 535 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 536 static const unsigned char yyr2[] =
 537 {
 538        0,     2,     0,     2,     2,     1,     1,     1,     1,     1,
 539        1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
 540        2,     2,     2,     2,     3,     0,     2,     3,     0,     2,
 541        3,     0,     2,     1,     1,     3,     0,     2,     1,     1,
 542        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
 543        1,     3,     0,     2,     1,     1,     2,     2,     2,     2,
 544        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 545        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 546        2,     2,     2,     2,     2,     2,     3,     1
 547 };
 548
 549 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 550    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 551    means the default is an error.  */
 552 static const unsigned char yydefact[] =
 553 {
 554        2,     0,     1,     0,     0,     0,     0,     0,     0,     0,
 555        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 556        0,    87,     4,     3,     0,     5,     6,     7,     8,     9,
 557       10,    11,    12,    13,    14,    15,    16,    17,     0,    18,
 558       69,    70,    25,    19,    28,    20,    85,    31,    21,    56,
 559       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
 560       84,    36,    23,    52,    22,     0,     0,     0,     0,     0,
 561       24,     0,    26,    27,     0,    29,    30,     0,    32,    33,
 562       34,    35,     0,     0,     0,     0,     0,     0,     0,     0,
 563        0,     0,     0,     0,    37,    39,    40,    41,    42,    43,
 564       44,    45,    46,    47,    48,    49,    50,    38,    51,     0,
 565       53,    54,    55,    71,    72,    73,    57,    58,    59,    60,
 566       61,    62,    63,    64,    65,    66,    67,    68,     0,    86
 567 };
 568
 569 /* YYDEFGOTO[NTERM-NUM]. */
 570 static const yysigned_char yydefgoto[] =
 571 {
 572       -1,     1,    22,    23,    43,    65,    45,    66,    48,    67,
 573       78,    62,    68,    94,    64,    69,   110,    24,    95,    96,
 574       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
 575       25,    26,    72,    75,    79,    27,    28,    29,    30,    31,
 576       32,    33,    34,    35,    36,    37,    38,   111,    39
 577 };
 578
 579 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 580    STATE-NUM.  */
 581 #define YYPACT_NINF -61
 582 static const yysigned_char yypact[] =
 583 {
 584      -61,     0,   -61,     3,    40,    45,    46,    44,    48,    47,
 585       -5,    49,    50,    43,    51,    53,    54,    55,    56,    52,
 586       58,   -61,   -61,   -61,    63,   -61,   -61,   -61,   -61,   -61,
 587      -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,    65,   -61,
 588      -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,
 589      -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,
 590      -61,   -61,   -61,   -61,   -61,     1,     2,    -3,    -2,    37,
 591      -61,    11,   -61,   -61,    62,   -61,   -61,    64,   -61,   -61,
 592      -61,   -61,    12,    61,    14,    28,    66,    67,    68,    69,
 593       70,    71,    72,    73,   -61,   -61,   -61,   -61,   -61,   -61,
 594      -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,    77,
 595      -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,
 596      -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,    78,   -61
 597 };
 598
 599 /* YYPGOTO[NTERM-NUM].  */
 600 static const yysigned_char yypgoto[] =
 601 {
 602      -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,
 603      -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,
 604      -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,
 605      -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,
 606      -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -60
 607 };
 608
 609 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 610    positive, shift that token.  If negative, reduce the rule which
 611    number is the opposite.  If zero, do what YYDEFACT says.
 612    If YYTABLE_NINF, syntax error.  */
 613 #define YYTABLE_NINF -1
 614 static const unsigned char yytable[] =
 615 {
 616        2,    76,    81,    77,    50,    70,    73,    80,   107,   112,
 617       40,     3,     4,     5,     6,     7,     8,     9,    10,    11,
 618       12,    13,    14,    15,    16,    17,    18,    19,    20,    82,
 619       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
 620       93,   108,    21,    21,    71,    21,    74,    41,    42,    44,
 621       46,    47,    53,    49,   113,   116,    51,    52,   118,    59,
 622       54,    55,    56,    57,    58,    60,    61,   109,    63,   114,
 623      115,   117,   119,     0,   120,   121,   122,   123,   124,   125,
 624      126,   127,    21,   128,   129
 625 };
 626
 627 static const yysigned_char yycheck[] =
 628 {
 629        0,     4,     4,     6,     9,     4,     4,    67,    68,    69,
 630        7,    11,    12,    13,    14,    15,    16,    17,    18,    19,
 631       20,    21,    22,    23,    24,    25,    26,    27,    28,    31,
 632       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
 633       42,     4,    45,    45,    43,    45,    44,     7,     3,     3,
 634        6,     3,     9,     6,    43,    43,     7,     7,    44,     7,
 635        9,     8,     8,     8,     8,     7,     3,    30,     3,     7,
 636        6,    10,    44,    -1,     8,     8,     8,     8,     8,     8,
 637        8,     8,    45,     6,     6
 638 };
 639
 640 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 641    symbol of state STATE-NUM.  */
 642 static const unsigned char yystos[] =
 643 {
 644        0,    47,     0,    11,    12,    13,    14,    15,    16,    17,
 645       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
 646       28,    45,    48,    49,    63,    76,    77,    81,    82,    83,
 647       84,    85,    86,    87,    88,    89,    90,    91,    92,    94,
 648        7,     7,     3,    50,     3,    52,     6,     3,    54,     6,
 649        9,     7,     7,     9,     9,     8,     8,     8,     8,     7,
 650        7,     3,    57,     3,    60,    51,    53,    55,    58,    61,
 651        4,    43,    78,     4,    44,    79,     4,     6,    56,    80,
 652       94,     4,    31,    32,    33,    34,    35,    36,    37,    38,
 653       39,    40,    41,    42,    59,    64,    65,    66,    67,    68,
 654       69,    70,    71,    72,    73,    74,    75,    94,     4,    30,
 655       62,    93,    94,    43,     7,     6,    43,    10,    44,    44,
 656        8,     8,     8,     8,     8,     8,     8,     8,     6,     6
 657 };
 658
 659 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 660 # define YYSIZE_T __SIZE_TYPE__
 661 #endif
 662 #if ! defined (YYSIZE_T) && defined (size_t)
 663 # define YYSIZE_T size_t
 664 #endif
 665 #if ! defined (YYSIZE_T)
 666 # if defined (__STDC__) || defined (__cplusplus)
 667 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 668 #  define YYSIZE_T size_t
 669 # endif
 670 #endif
 671 #if ! defined (YYSIZE_T)
 672 # define YYSIZE_T unsigned int
 673 #endif
 674
 675 #define yyerrok         (yyerrstatus = 0)
 676 #define yyclearin       (yychar = YYEMPTY)
 677 #define YYEMPTY         (-2)
 678 #define YYEOF           0
 679
 680 #define YYACCEPT        goto yyacceptlab
 681 #define YYABORT         goto yyabortlab
 682 #define YYERROR         goto yyerrlab1
 683
 684
 685 /* Like YYERROR except do call yyerror.  This remains here temporarily
 686    to ease the transition to the new meaning of YYERROR, for GCC.
 687    Once GCC version 2 has supplanted version 1, this can go.  */
 688
 689 #define YYFAIL          goto yyerrlab
 690
 691 #define YYRECOVERING()  (!!yyerrstatus)
 692
 693 #define YYBACKUP(Token, Value)                                  \
 694 do                                                              \
 695   if (yychar == YYEMPTY && yylen == 1)                          \
 696     {                                                           \
 697       yychar = (Token);                                         \
 698       yylval = (Value);                                         \
 699       yytoken = YYTRANSLATE (yychar);                           \
 700       YYPOPSTACK;                                               \
 701       goto yybackup;                                            \
 702     }                                                           \
 703   else                                                          \
 704     {                                                           \
 705       yyerror ("syntax error: cannot back up");\
 706       YYERROR;                                                  \
 707     }                                                           \
 708 while (0)
 709
 710 #define YYTERROR        1
 711 #define YYERRCODE       256
 712
 713 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
 714    are run).  */
 715
 716 #ifndef YYLLOC_DEFAULT
 717 # define YYLLOC_DEFAULT(Current, Rhs, N)         \
 718   Current.first_line   = Rhs[1].first_line;      \
 719   Current.first_column = Rhs[1].first_column;    \
 720   Current.last_line    = Rhs[N].last_line;       \
 721   Current.last_column  = Rhs[N].last_column;
 722 #endif
 723
 724 /* YYLEX -- calling `yylex' with the right arguments.  */
 725
 726 #ifdef YYLEX_PARAM
 727 # define YYLEX yylex (YYLEX_PARAM)
 728 #else
 729 # define YYLEX yylex ()
 730 #endif
 731
 732 /* Enable debugging if requested.  */
 733 #if YYDEBUG
 734
 735 # ifndef YYFPRINTF
 736 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 737 #  define YYFPRINTF fprintf
 738 # endif
 739
 740 # define YYDPRINTF(Args)                        \
 741 do {                                            \
 742   if (yydebug)                                  \
 743     YYFPRINTF Args;                             \
 744 } while (0)
 745
 746 # define YYDSYMPRINT(Args)                      \
 747 do {                                            \
 748   if (yydebug)                                  \
 749     yysymprint Args;                            \
 750 } while (0)
 751
 752 # define YYDSYMPRINTF(Title, Token, Value, Location)            \
 753 do {                                                            \
 754   if (yydebug)                                                  \
 755     {                                                           \
 756       YYFPRINTF (stderr, "%s ", Title);                         \
 757       yysymprint (stderr,                                       \
 758                   Token, Value);        \
 759       YYFPRINTF (stderr, "\n");                                 \
 760     }                                                           \
 761 } while (0)
 762
 763 /*------------------------------------------------------------------.
 764 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 765 | TOP (cinluded).                                                   |
 766 `------------------------------------------------------------------*/
 767
 768 #if defined (__STDC__) || defined (__cplusplus)
 769 static void
 770 yy_stack_print (short *bottom, short *top)
 771 #else
 772 static void
 773 yy_stack_print (bottom, top)
 774     short *bottom;
 775     short *top;
 776 #endif
 777 {
 778   YYFPRINTF (stderr, "Stack now");
 779   for (/* Nothing. */; bottom <= top; ++bottom)
 780     YYFPRINTF (stderr, " %d", *bottom);
 781   YYFPRINTF (stderr, "\n");
 782 }
 783
 784 # define YY_STACK_PRINT(Bottom, Top)                            \
 785 do {                                                            \
 786   if (yydebug)                                                  \
 787     yy_stack_print ((Bottom), (Top));                           \
 788 } while (0)
 789
 790
 791 /*------------------------------------------------.
 792 | Report that the YYRULE is going to be reduced.  |
 793 `------------------------------------------------*/
 794
 795 #if defined (__STDC__) || defined (__cplusplus)
 796 static void
 797 yy_reduce_print (int yyrule)
 798 #else
 799 static void
 800 yy_reduce_print (yyrule)
 801     int yyrule;
 802 #endif
 803 {
 804   int yyi;
 805   unsigned int yylineno = yyrline[yyrule];
 806   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
 807              yyrule - 1, yylineno);
 808   /* Print the symbols being reduced, and their result.  */
 809   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
 810     YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
 811   YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
 812 }
 813
 814 # define YY_REDUCE_PRINT(Rule)          \
 815 do {                                    \
 816   if (yydebug)                          \
 817     yy_reduce_print (Rule);             \
 818 } while (0)
 819
 820 /* Nonzero means print parse trace.  It is left uninitialized so that
 821    multiple parsers can coexist.  */
 822 int yydebug;
 823 #else /* !YYDEBUG */
 824 # define YYDPRINTF(Args)
 825 # define YYDSYMPRINT(Args)
 826 # define YYDSYMPRINTF(Title, Token, Value, Location)
 827 # define YY_STACK_PRINT(Bottom, Top)
 828 # define YY_REDUCE_PRINT(Rule)
 829 #endif /* !YYDEBUG */
 830
 831
 832 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 833 #ifndef YYINITDEPTH
 834 # define YYINITDEPTH 200
 835 #endif
 836
 837 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 838    if the built-in stack extension method is used).
 839
 840    Do not make this value too large; the results are undefined if
 841    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 842    evaluated with infinite-precision integer arithmetic.  */
 843
 844 #if YYMAXDEPTH == 0
 845 # undef YYMAXDEPTH
 846 #endif
 847
 848 #ifndef YYMAXDEPTH
 849 # define YYMAXDEPTH 10000
 850 #endif
 851
 852 \f
 853
 854 #if YYERROR_VERBOSE
 855
 856 # ifndef yystrlen
 857 #  if defined (__GLIBC__) && defined (_STRING_H)
 858 #   define yystrlen strlen
 859 #  else
 860 /* Return the length of YYSTR.  */
 861 static YYSIZE_T
 862 #   if defined (__STDC__) || defined (__cplusplus)
 863 yystrlen (const char *yystr)
 864 #   else
 865 yystrlen (yystr)
 866      const char *yystr;
 867 #   endif
 868 {
 869   register const char *yys = yystr;
 870
 871   while (*yys++ != '\0')
 872     continue;
 873
 874   return yys - yystr - 1;
 875 }
 876 #  endif
 877 # endif
 878
 879 # ifndef yystpcpy
 880 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 881 #   define yystpcpy stpcpy
 882 #  else
 883 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 884    YYDEST.  */
 885 static char *
 886 #   if defined (__STDC__) || defined (__cplusplus)
 887 yystpcpy (char *yydest, const char *yysrc)
 888 #   else
 889 yystpcpy (yydest, yysrc)
 890      char *yydest;
 891      const char *yysrc;
 892 #   endif
 893 {
 894   register char *yyd = yydest;
 895   register const char *yys = yysrc;
 896
 897   while ((*yyd++ = *yys++) != '\0')
 898     continue;
 899
 900   return yyd - 1;
 901 }
 902 #  endif
 903 # endif
 904
 905 #endif /* !YYERROR_VERBOSE */
 906
 907 \f
 908
 909 #if YYDEBUG
 910 /*--------------------------------.
 911 | Print this symbol on YYOUTPUT.  |
 912 `--------------------------------*/
 913
 914 #if defined (__STDC__) || defined (__cplusplus)
 915 static void
 916 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
 917 #else
 918 static void
 919 yysymprint (yyoutput, yytype, yyvaluep)
 920     FILE *yyoutput;
 921     int yytype;
 922     YYSTYPE *yyvaluep;
 923 #endif
 924 {
 925   /* Pacify ``unused variable'' warnings.  */
 926   (void) yyvaluep;
 927
 928   if (yytype < YYNTOKENS)
 929     {
 930       YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 931 # ifdef YYPRINT
 932       YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 933 # endif
 934     }
 935   else
 936     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 937
 938   switch (yytype)
 939     {
 940       default:
 941         break;
 942     }
 943   YYFPRINTF (yyoutput, ")");
 944 }
 945
 946 #endif /* ! YYDEBUG */
 947 /*-----------------------------------------------.
 948 | Release the memory associated to this symbol.  |
 949 `-----------------------------------------------*/
 950
 951 #if defined (__STDC__) || defined (__cplusplus)
 952 static void
 953 yydestruct (int yytype, YYSTYPE *yyvaluep)
 954 #else
 955 static void
 956 yydestruct (yytype, yyvaluep)
 957     int yytype;
 958     YYSTYPE *yyvaluep;
 959 #endif
 960 {
 961   /* Pacify ``unused variable'' warnings.  */
 962   (void) yyvaluep;
 963
 964   switch (yytype)
 965     {
 966
 967       default:
 968         break;
 969     }
 970 }
 971 \f
 972
 973 /* Prevent warnings from -Wmissing-prototypes.  */
 974
 975 #ifdef YYPARSE_PARAM
 976 # if defined (__STDC__) || defined (__cplusplus)
 977 int yyparse (void *YYPARSE_PARAM);
 978 # else
 979 int yyparse ();
 980 # endif
 981 #else /* ! YYPARSE_PARAM */
 982 #if defined (__STDC__) || defined (__cplusplus)
 983 int yyparse (void);
 984 #else
 985 int yyparse ();
 986 #endif
 987 #endif /* ! YYPARSE_PARAM */
 988
 989
 990
 991 /* The lookahead symbol.  */
 992 int yychar;
 993
 994 /* The semantic value of the lookahead symbol.  */
 995 YYSTYPE yylval;
 996
 997 /* Number of syntax errors so far.  */
 998 int yynerrs;
 999
1000
1001
1002 /*----------.
1003 | yyparse.  |
1004 `----------*/
1005
1006 #ifdef YYPARSE_PARAM
1007 # if defined (__STDC__) || defined (__cplusplus)
1008 int yyparse (void *YYPARSE_PARAM)
1009 # else
1010 int yyparse (YYPARSE_PARAM)
1011   void *YYPARSE_PARAM;
1012 # endif
1013 #else /* ! YYPARSE_PARAM */
1014 #if defined (__STDC__) || defined (__cplusplus)
1015 int
1016 yyparse (void)
1017 #else
1018 int
1019 yyparse ()
1020
1021 #endif
1022 #endif
1023 {
1024
1025   register int yystate;
1026   register int yyn;
1027   int yyresult;
1028   /* Number of tokens to shift before error messages enabled.  */
1029   int yyerrstatus;
1030   /* Lookahead token as an internal (translated) token number.  */
1031   int yytoken = 0;
1032
1033   /* Three stacks and their tools:
1034      `yyss': related to states,
1035      `yyvs': related to semantic values,
1036      `yyls': related to locations.
1037
1038      Refer to the stacks thru separate pointers, to allow yyoverflow
1039      to reallocate them elsewhere.  */
1040
1041   /* The state stack.  */
1042   short yyssa[YYINITDEPTH];
1043   short *yyss = yyssa;
1044   register short *yyssp;
1045
1046   /* The semantic value stack.  */
1047   YYSTYPE yyvsa[YYINITDEPTH];
1048   YYSTYPE *yyvs = yyvsa;
1049   register YYSTYPE *yyvsp;
1050
1051
1052
1053 #define YYPOPSTACK   (yyvsp--, yyssp--)
1054
1055   YYSIZE_T yystacksize = YYINITDEPTH;
1056
1057   /* The variables used to return semantic value and location from the
1058      action routines.  */
1059   YYSTYPE yyval;
1060
1061
1062   /* When reducing, the number of symbols on the RHS of the reduced
1063      rule.  */
1064   int yylen;
1065
1066   YYDPRINTF ((stderr, "Starting parse\n"));
1067
1068   yystate = 0;
1069   yyerrstatus = 0;
1070   yynerrs = 0;
1071   yychar = YYEMPTY;             /* Cause a token to be read.  */
1072
1073   /* Initialize stack pointers.
1074      Waste one element of value and location stack
1075      so that they stay on the same level as the state stack.
1076      The wasted elements are never initialized.  */
1077
1078   yyssp = yyss;
1079   yyvsp = yyvs;
1080
1081   goto yysetstate;
1082
1083 /*------------------------------------------------------------.
1084 | yynewstate -- Push a new state, which is found in yystate.  |
1085 `------------------------------------------------------------*/
1086  yynewstate:
1087   /* In all cases, when you get here, the value and location stacks
1088      have just been pushed. so pushing a state here evens the stacks.
1089      */
1090   yyssp++;
1091
1092  yysetstate:
1093   *yyssp = yystate;
1094
1095   if (yyss + yystacksize - 1 <= yyssp)
1096     {
1097       /* Get the current used size of the three stacks, in elements.  */
1098       YYSIZE_T yysize = yyssp - yyss + 1;
1099
1100 #ifdef yyoverflow
1101       {
1102         /* Give user a chance to reallocate the stack. Use copies of
1103            these so that the &'s don't force the real ones into
1104            memory.  */
1105         YYSTYPE *yyvs1 = yyvs;
1106         short *yyss1 = yyss;
1107
1108
1109         /* Each stack pointer address is followed by the size of the
1110            data in use in that stack, in bytes.  This used to be a
1111            conditional around just the two extra args, but that might
1112            be undefined if yyoverflow is a macro.  */
1113         yyoverflow ("parser stack overflow",
1114                     &yyss1, yysize * sizeof (*yyssp),
1115                     &yyvs1, yysize * sizeof (*yyvsp),
1116
1117                     &yystacksize);
1118
1119         yyss = yyss1;
1120         yyvs = yyvs1;
1121       }
1122 #else /* no yyoverflow */
1123 # ifndef YYSTACK_RELOCATE
1124       goto yyoverflowlab;
1125 # else
1126       /* Extend the stack our own way.  */
1127       if (YYMAXDEPTH <= yystacksize)
1128         goto yyoverflowlab;
1129       yystacksize *= 2;
1130       if (YYMAXDEPTH < yystacksize)
1131         yystacksize = YYMAXDEPTH;
1132
1133       {
1134         short *yyss1 = yyss;
1135         union yyalloc *yyptr =
1136           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1137         if (! yyptr)
1138           goto yyoverflowlab;
1139         YYSTACK_RELOCATE (yyss);
1140         YYSTACK_RELOCATE (yyvs);
1141
1142 #  undef YYSTACK_RELOCATE
1143         if (yyss1 != yyssa)
1144           YYSTACK_FREE (yyss1);
1145       }
1146 # endif
1147 #endif /* no yyoverflow */
1148
1149       yyssp = yyss + yysize - 1;
1150       yyvsp = yyvs + yysize - 1;
1151
1152
1153       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1154                   (unsigned long int) yystacksize));
1155
1156       if (yyss + yystacksize - 1 <= yyssp)
1157         YYABORT;
1158     }
1159
1160   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1161
1162   goto yybackup;
1163
1164 /*-----------.
1165 | yybackup.  |
1166 `-----------*/
1167 yybackup:
1168
1169 /* Do appropriate processing given the current state.  */
1170 /* Read a lookahead token if we need one and don't already have one.  */
1171 /* yyresume: */
1172
1173   /* First try to decide what to do without reference to lookahead token.  */
1174
1175   yyn = yypact[yystate];
1176   if (yyn == YYPACT_NINF)
1177     goto yydefault;
1178
1179   /* Not known => get a lookahead token if don't already have one.  */
1180
1181   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1182   if (yychar == YYEMPTY)
1183     {
1184       YYDPRINTF ((stderr, "Reading a token: "));
1185       yychar = YYLEX;
1186     }
1187
1188   if (yychar <= YYEOF)
1189     {
1190       yychar = yytoken = YYEOF;
1191       YYDPRINTF ((stderr, "Now at end of input.\n"));
1192     }
1193   else
1194     {
1195       yytoken = YYTRANSLATE (yychar);
1196       YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
1197     }
1198
1199   /* If the proper action on seeing token YYTOKEN is to reduce or to
1200      detect an error, take that action.  */
1201   yyn += yytoken;
1202   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1203     goto yydefault;
1204   yyn = yytable[yyn];
1205   if (yyn <= 0)
1206     {
1207       if (yyn == 0 || yyn == YYTABLE_NINF)
1208         goto yyerrlab;
1209       yyn = -yyn;
1210       goto yyreduce;
1211     }
1212
1213   if (yyn == YYFINAL)
1214     YYACCEPT;
1215
1216   /* Shift the lookahead token.  */
1217   YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
1218
1219   /* Discard the token being shifted unless it is eof.  */
1220   if (yychar != YYEOF)
1221     yychar = YYEMPTY;
1222
1223   *++yyvsp = yylval;
1224
1225
1226   /* Count tokens shifted since error; after three, turn off error
1227      status.  */
1228   if (yyerrstatus)
1229     yyerrstatus--;
1230
1231   yystate = yyn;
1232   goto yynewstate;
1233
1234
1235 /*-----------------------------------------------------------.
1236 | yydefault -- do the default action for the current state.  |
1237 `-----------------------------------------------------------*/
1238 yydefault:
1239   yyn = yydefact[yystate];
1240   if (yyn == 0)
1241     goto yyerrlab;
1242   goto yyreduce;
1243
1244
1245 /*-----------------------------.
1246 | yyreduce -- Do a reduction.  |
1247 `-----------------------------*/
1248 yyreduce:
1249   /* yyn is the number of a rule to reduce with.  */
1250   yylen = yyr2[yyn];
1251
1252   /* If YYLEN is nonzero, implement the default value of the action:
1253      `$$ = $1'.
1254
1255      Otherwise, the following line sets YYVAL to garbage.
1256      This behavior is undocumented and Bison
1257      users should not rely upon it.  Assigning to YYVAL
1258      unconditionally makes the parser a bit smaller, and it avoids a
1259      GCC warning that YYVAL may be used uninitialized.  */
1260   yyval = yyvsp[1-yylen];
1261
1262
1263   YY_REDUCE_PRINT (yyn);
1264   switch (yyn)
1265     {
1266         case 56:
1267 #line 230 "src/cfgparser/oparse.y"
1268     {
1269   struct if_config_options *io = get_default_if_config();
1270   if(io == NULL)
1271     {
1272       fprintf(stderr, "Out of memory(ADD IFRULE)\n");
1273       YYABORT;
1274     }
1275
1276   if(PARSER_DEBUG) printf("Interface setup: \"%s\"\n", yyvsp[0]->string);
1277
1278   io->name = yyvsp[0]->string;
1279
1280
1281   /* Queue */
1282   io->next = cnf->if_options;
1283   cnf->if_options = io;
1284
1285   free(yyvsp[0]);
1286 }
1287     break;
1288
1289   case 57:
1290 #line 253 "src/cfgparser/oparse.y"
1291     {
1292   struct in_addr in;
1293
1294   if(PARSER_DEBUG) printf("\tIPv4 broadcast: %s\n", yyvsp[0]->string);
1295
1296   if(inet_aton(yyvsp[0]->string, &in) == 0)
1297     {
1298       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[-1]->string);
1299       exit(EXIT_FAILURE);
1300     }
1301
1302   cnf->if_options->ipv4_broadcast.v4 = in.s_addr;
1303
1304   free(yyvsp[0]->string);
1305   free(yyvsp[0]);
1306 }
1307     break;
1308
1309   case 58:
1310 #line 272 "src/cfgparser/oparse.y"
1311     {
1312   cnf->if_options->ipv6_addrtype = yyvsp[0]->boolean;
1313
1314   free(yyvsp[0]);
1315 }
1316     break;
1317
1318   case 59:
1319 #line 280 "src/cfgparser/oparse.y"
1320     {
1321   struct in6_addr in6;
1322
1323   if(PARSER_DEBUG) printf("\tIPv6 site-local multicast: %s\n", yyvsp[0]->string);
1324
1325   if(inet_pton(AF_INET6, yyvsp[0]->string, &in6) < 0)
1326     {
1327       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[0]->string);
1328       exit(EXIT_FAILURE);
1329     }
1330   memcpy(&cnf->if_options->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
1331
1332
1333   free(yyvsp[0]->string);
1334   free(yyvsp[0]);
1335 }
1336     break;
1337
1338   case 60:
1339 #line 300 "src/cfgparser/oparse.y"
1340     {
1341   struct in6_addr in6;
1342
1343   if(PARSER_DEBUG) printf("\tIPv6 global multicast: %s\n", yyvsp[0]->string);
1344
1345   if(inet_pton(AF_INET6, yyvsp[0]->string, &in6) < 0)
1346     {
1347       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[0]->string);
1348       exit(EXIT_FAILURE);
1349     }
1350   memcpy(&cnf->if_options->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
1351
1352
1353   free(yyvsp[0]->string);
1354   free(yyvsp[0]);
1355 }
1356     break;
1357
1358   case 61:
1359 #line 318 "src/cfgparser/oparse.y"
1360     {
1361     if(PARSER_DEBUG) printf("\tHELLO interval: %0.2f\n", yyvsp[0]->floating);
1362     cnf->if_options->hello_params.emission_interval = yyvsp[0]->floating;
1363     free(yyvsp[0]);
1364 }
1365     break;
1366
1367   case 62:
1368 #line 325 "src/cfgparser/oparse.y"
1369     {
1370     if(PARSER_DEBUG) printf("\tHELLO validity: %0.2f\n", yyvsp[0]->floating);
1371     cnf->if_options->hello_params.validity_time = yyvsp[0]->floating;
1372     free(yyvsp[0]);
1373 }
1374     break;
1375
1376   case 63:
1377 #line 332 "src/cfgparser/oparse.y"
1378     {
1379     if(PARSER_DEBUG) printf("\tTC interval: %0.2f\n", yyvsp[0]->floating);
1380     cnf->if_options->tc_params.emission_interval = yyvsp[0]->floating;
1381     free(yyvsp[0]);
1382 }
1383     break;
1384
1385   case 64:
1386 #line 339 "src/cfgparser/oparse.y"
1387     {
1388     if(PARSER_DEBUG) printf("\tTC validity: %0.2f\n", yyvsp[0]->floating);
1389     cnf->if_options->tc_params.validity_time = yyvsp[0]->floating;
1390     free(yyvsp[0]);
1391 }
1392     break;
1393
1394   case 65:
1395 #line 346 "src/cfgparser/oparse.y"
1396     {
1397     if(PARSER_DEBUG) printf("\tMID interval: %0.2f\n", yyvsp[0]->floating);
1398     cnf->if_options->mid_params.emission_interval = yyvsp[0]->floating;
1399     free(yyvsp[0]);
1400 }
1401     break;
1402
1403   case 66:
1404 #line 353 "src/cfgparser/oparse.y"
1405     {
1406     if(PARSER_DEBUG) printf("\tMID validity: %0.2f\n", yyvsp[0]->floating);
1407     cnf->if_options->mid_params.validity_time = yyvsp[0]->floating;
1408     free(yyvsp[0]);
1409 }
1410     break;
1411
1412   case 67:
1413 #line 360 "src/cfgparser/oparse.y"
1414     {
1415     if(PARSER_DEBUG) printf("\tHNA interval: %0.2f\n", yyvsp[0]->floating);
1416     cnf->if_options->hna_params.emission_interval = yyvsp[0]->floating;
1417     free(yyvsp[0]);
1418 }
1419     break;
1420
1421   case 68:
1422 #line 367 "src/cfgparser/oparse.y"
1423     {
1424     if(PARSER_DEBUG) printf("\tHNA validity: %0.2f\n", yyvsp[0]->floating);
1425     cnf->if_options->hna_params.validity_time = yyvsp[0]->floating;
1426     free(yyvsp[0]);
1427 }
1428     break;
1429
1430   case 69:
1431 #line 376 "src/cfgparser/oparse.y"
1432     {
1433
1434   if(yyvsp[0]->boolean == 1)
1435     {
1436       if(PARSER_DEBUG) printf("Debug levl AUTO\n");
1437     }
1438   else
1439     {
1440       cnf->debug_level = yyvsp[0]->integer;
1441       if(PARSER_DEBUG) printf("Debug level: %d\n", cnf->debug_level);
1442     }
1443
1444   free(yyvsp[0]);
1445 }
1446     break;
1447
1448   case 70:
1449 #line 394 "src/cfgparser/oparse.y"
1450     {
1451   if((yyvsp[0]->integer != 4) && (yyvsp[0]->integer != 6))
1452     {
1453       fprintf(stderr, "IPversion must be 4 or 6!\n");
1454       YYABORT;
1455     }
1456   cnf->ip_version = yyvsp[0]->integer;
1457   if(PARSER_DEBUG) printf("IpVersion: %d\n", cnf->ip_version);
1458   free(yyvsp[0]);
1459 }
1460     break;
1461
1462   case 71:
1463 #line 408 "src/cfgparser/oparse.y"
1464     {
1465   struct hna4_entry *h = malloc(sizeof(struct hna4_entry));
1466   struct in_addr in;
1467
1468   if(PARSER_DEBUG) printf("HNA IPv4 entry: %s/%s\n", yyvsp[-1]->string, yyvsp[0]->string);
1469
1470   if(h == NULL)
1471     {
1472       fprintf(stderr, "Out of memory(HNA4)\n");
1473       YYABORT;
1474     }
1475
1476   if(inet_aton(yyvsp[-1]->string, &in) == 0)
1477     {
1478       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[-1]->string);
1479       exit(EXIT_FAILURE);
1480     }
1481   h->net = in.s_addr;
1482   if(inet_aton(yyvsp[0]->string, &in) == 0)
1483     {
1484       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[-1]->string);
1485       exit(EXIT_FAILURE);
1486     }
1487   h->netmask = in.s_addr;
1488   /* Queue */
1489   h->next = cnf->hna4_entries;
1490   cnf->hna4_entries = h;
1491
1492   free(yyvsp[-1]->string);
1493   free(yyvsp[-1]);
1494   free(yyvsp[0]->string);
1495   free(yyvsp[0]);
1496
1497 }
1498     break;
1499
1500   case 72:
1501 #line 444 "src/cfgparser/oparse.y"
1502     {
1503   struct hna6_entry *h = malloc(sizeof(struct hna6_entry));
1504   struct in6_addr in6;
1505
1506   if(PARSER_DEBUG) printf("HNA IPv6 entry: %s/%d\n", yyvsp[-1]->string, yyvsp[0]->integer);
1507
1508   if(h == NULL)
1509     {
1510       fprintf(stderr, "Out of memory(HNA6)\n");
1511       YYABORT;
1512     }
1513
1514   if(inet_pton(AF_INET6, yyvsp[-1]->string, &in6) < 0)
1515     {
1516       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[-1]->string);
1517       exit(EXIT_FAILURE);
1518     }
1519   memcpy(&h->net, &in6, sizeof(struct in6_addr));
1520
1521   if((yyvsp[0]->integer < 0) || (yyvsp[0]->integer > 128))
1522     {
1523       fprintf(stderr, "Illegal IPv6 prefix length %d\n", yyvsp[0]->integer);
1524       exit(EXIT_FAILURE);
1525     }
1526
1527   h->prefix_len = yyvsp[0]->integer;
1528   /* Queue */
1529   h->next = cnf->hna6_entries;
1530   cnf->hna6_entries = h;
1531
1532   free(yyvsp[-1]->string);
1533   free(yyvsp[-1]);
1534   free(yyvsp[0]);
1535
1536 }
1537     break;
1538
1539   case 73:
1540 #line 481 "src/cfgparser/oparse.y"
1541     {
1542   struct olsr_if *in = malloc(sizeof(struct olsr_if));
1543
1544   if(in == NULL)
1545     {
1546       fprintf(stderr, "Out of memory(ADD IF)\n");
1547       YYABORT;
1548     }
1549
1550   in->name = yyvsp[-1]->string;
1551   in->config = yyvsp[0]->string;
1552
1553   if(PARSER_DEBUG) printf("Interface: %s Ruleset: %s\n", yyvsp[-1]->string, yyvsp[0]->string);
1554
1555   /* Queue */
1556   in->next = cnf->interfaces;
1557   cnf->interfaces = in;
1558
1559   free(yyvsp[-1]);
1560   free(yyvsp[0]);
1561 }
1562     break;
1563
1564   case 74:
1565 #line 505 "src/cfgparser/oparse.y"
1566     {
1567   if(PARSER_DEBUG) printf("Noint set to %d\n", yyvsp[0]->boolean);
1568   free(yyvsp[0]);
1569 }
1570     break;
1571
1572   case 75:
1573 #line 512 "src/cfgparser/oparse.y"
1574     {
1575   if(yyvsp[0]->boolean == 1)
1576     {
1577       if(PARSER_DEBUG) printf("Tos AUTO\n");
1578     }
1579   else
1580     {
1581       if(PARSER_DEBUG) printf("TOS: %d\n", yyvsp[0]->integer);
1582     }
1583   free(yyvsp[0]);
1584
1585 }
1586     break;
1587
1588   case 76:
1589 #line 527 "src/cfgparser/oparse.y"
1590     {
1591   if(yyvsp[0]->boolean == 1)
1592     {
1593       if(PARSER_DEBUG) printf("Willingness AUTO\n");
1594     }
1595   else
1596     {
1597       if(PARSER_DEBUG) printf("Willingness: %d\n", yyvsp[0]->integer);
1598     }
1599   free(yyvsp[0]);
1600
1601 }
1602     break;
1603
1604   case 77:
1605 #line 542 "src/cfgparser/oparse.y"
1606     {
1607   if(yyvsp[0]->boolean == 1)
1608     {
1609       if(PARSER_DEBUG) printf("IPC allowed\n");
1610     }
1611   else
1612     {
1613       if(PARSER_DEBUG) printf("IPC blocked\n");
1614     }
1615   free(yyvsp[0]);
1616
1617 }
1618     break;
1619
1620   case 78:
1621 #line 558 "src/cfgparser/oparse.y"
1622     {
1623   if(yyvsp[0]->boolean == 1)
1624     {
1625       if(PARSER_DEBUG) printf("Hysteresis enabled\n");
1626     }
1627   else
1628     {
1629       if(PARSER_DEBUG) printf("Hysteresis disabled\n");
1630     }
1631   free(yyvsp[0]);
1632
1633 }
1634     break;
1635
1636   case 79:
1637 #line 574 "src/cfgparser/oparse.y"
1638     {
1639   cnf->hysteresis_param.scaling = yyvsp[0]->floating;
1640   if(PARSER_DEBUG) printf("Hysteresis Scaling: %0.2f\n", yyvsp[0]->floating);
1641   free(yyvsp[0]);
1642 }
1643     break;
1644
1645   case 80:
1646 #line 583 "src/cfgparser/oparse.y"
1647     {
1648   cnf->hysteresis_param.thr_high = yyvsp[0]->floating;
1649   if(PARSER_DEBUG) printf("Hysteresis UpperThr: %0.2f\n", yyvsp[0]->floating);
1650   free(yyvsp[0]);
1651 }
1652     break;
1653
1654   case 81:
1655 #line 592 "src/cfgparser/oparse.y"
1656     {
1657   cnf->hysteresis_param.thr_low = yyvsp[0]->floating;
1658   if(PARSER_DEBUG) printf("Hysteresis LowerThr: %0.2f\n", yyvsp[0]->floating);
1659   free(yyvsp[0]);
1660 }
1661     break;
1662
1663   case 82:
1664 #line 600 "src/cfgparser/oparse.y"
1665     {
1666   if(PARSER_DEBUG) printf("Pollrate %0.2f\n", yyvsp[0]->floating);
1667   cnf->pollrate = yyvsp[0]->floating;
1668
1669   free(yyvsp[0]);
1670 }
1671     break;
1672
1673   case 83:
1674 #line 610 "src/cfgparser/oparse.y"
1675     {
1676   if(yyvsp[0]->boolean == 1)
1677     {
1678       if(PARSER_DEBUG) printf("TC redundancy AUTO\n");
1679     }
1680   else
1681     {
1682       if(PARSER_DEBUG) printf("TC redundancy %d\n", yyvsp[0]->integer);
1683       cnf->tc_redundancy = yyvsp[0]->integer;
1684     }
1685   free(yyvsp[0]);
1686
1687 }
1688     break;
1689
1690   case 84:
1691 #line 626 "src/cfgparser/oparse.y"
1692     {
1693   if(yyvsp[0]->boolean == 1)
1694     {
1695       if(PARSER_DEBUG) printf("MPR coverage AUTO\n");
1696     }
1697   else
1698     {
1699       if(PARSER_DEBUG) printf("MPR coverage %d\n", yyvsp[0]->integer);
1700       cnf->mpr_coverage = yyvsp[0]->integer;
1701     }
1702   free(yyvsp[0]);
1703 }
1704     break;
1705
1706   case 85:
1707 #line 642 "src/cfgparser/oparse.y"
1708     {
1709   struct plugin_entry *pe = malloc(sizeof(struct plugin_entry));
1710
1711   if(pe == NULL)
1712     {
1713       fprintf(stderr, "Out of memory(ADD PL)\n");
1714       YYABORT;
1715     }
1716
1717   pe->name = yyvsp[0]->string;
1718
1719   if(PARSER_DEBUG) printf("Plugin: %s\n", yyvsp[0]->string);
1720
1721   /* Queue */
1722   pe->next = cnf->plugins;
1723   cnf->plugins = pe;
1724
1725   free(yyvsp[0]);
1726 }
1727     break;
1728
1729   case 86:
1730 #line 664 "src/cfgparser/oparse.y"
1731     {
1732
1733     if(PARSER_DEBUG) printf("Plugin param key:\"%s\" val: \"%s\"\n", yyvsp[-1]->string, yyvsp[0]->string);
1734
1735     free(yyvsp[-1]->string);
1736     free(yyvsp[-1]);
1737     free(yyvsp[0]->string);
1738     free(yyvsp[0]);
1739 }
1740     break;
1741
1742   case 87:
1743 #line 676 "src/cfgparser/oparse.y"
1744     {
1745     //if(PARSER_DEBUG) printf("Comment\n");
1746 }
1747     break;
1748
1749
1750     }
1751
1752 /* Line 999 of yacc.c.  */
1753 #line 1754 "y.tab.c"
1754 \f
1755   yyvsp -= yylen;
1756   yyssp -= yylen;
1757
1758
1759   YY_STACK_PRINT (yyss, yyssp);
1760
1761   *++yyvsp = yyval;
1762
1763
1764   /* Now `shift' the result of the reduction.  Determine what state
1765      that goes to, based on the state we popped back to and the rule
1766      number reduced by.  */
1767
1768   yyn = yyr1[yyn];
1769
1770   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1771   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1772     yystate = yytable[yystate];
1773   else
1774     yystate = yydefgoto[yyn - YYNTOKENS];
1775
1776   goto yynewstate;
1777
1778
1779 /*------------------------------------.
1780 | yyerrlab -- here on detecting error |
1781 `------------------------------------*/
1782 yyerrlab:
1783   /* If not already recovering from an error, report this error.  */
1784   if (!yyerrstatus)
1785     {
1786       ++yynerrs;
1787 #if YYERROR_VERBOSE
1788       yyn = yypact[yystate];
1789
1790       if (YYPACT_NINF < yyn && yyn < YYLAST)
1791         {
1792           YYSIZE_T yysize = 0;
1793           int yytype = YYTRANSLATE (yychar);
1794           char *yymsg;
1795           int yyx, yycount;
1796
1797           yycount = 0;
1798           /* Start YYX at -YYN if negative to avoid negative indexes in
1799              YYCHECK.  */
1800           for (yyx = yyn < 0 ? -yyn : 0;
1801                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1802             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1803               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1804           yysize += yystrlen ("syntax error, unexpected ") + 1;
1805           yysize += yystrlen (yytname[yytype]);
1806           yymsg = (char *) YYSTACK_ALLOC (yysize);
1807           if (yymsg != 0)
1808             {
1809               char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
1810               yyp = yystpcpy (yyp, yytname[yytype]);
1811
1812               if (yycount < 5)
1813                 {
1814                   yycount = 0;
1815                   for (yyx = yyn < 0 ? -yyn : 0;
1816                        yyx < (int) (sizeof (yytname) / sizeof (char *));
1817                        yyx++)
1818                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1819                       {
1820                         const char *yyq = ! yycount ? ", expecting " : " or ";
1821                         yyp = yystpcpy (yyp, yyq);
1822                         yyp = yystpcpy (yyp, yytname[yyx]);
1823                         yycount++;
1824                       }
1825                 }
1826               yyerror (yymsg);
1827               YYSTACK_FREE (yymsg);
1828             }
1829           else
1830             yyerror ("syntax error; also virtual memory exhausted");
1831         }
1832       else
1833 #endif /* YYERROR_VERBOSE */
1834         yyerror ("syntax error");
1835     }
1836
1837
1838
1839   if (yyerrstatus == 3)
1840     {
1841       /* If just tried and failed to reuse lookahead token after an
1842          error, discard it.  */
1843
1844       /* Return failure if at end of input.  */
1845       if (yychar == YYEOF)
1846         {
1847           /* Pop the error token.  */
1848           YYPOPSTACK;
1849           /* Pop the rest of the stack.  */
1850           while (yyss < yyssp)
1851             {
1852               YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1853               yydestruct (yystos[*yyssp], yyvsp);
1854               YYPOPSTACK;
1855             }
1856           YYABORT;
1857         }
1858
1859       YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
1860       yydestruct (yytoken, &yylval);
1861       yychar = YYEMPTY;
1862
1863     }
1864
1865   /* Else will try to reuse lookahead token after shifting the error
1866      token.  */
1867   goto yyerrlab1;
1868
1869
1870 /*----------------------------------------------------.
1871 | yyerrlab1 -- error raised explicitly by an action.  |
1872 `----------------------------------------------------*/
1873 yyerrlab1:
1874   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1875
1876   for (;;)
1877     {
1878       yyn = yypact[yystate];
1879       if (yyn != YYPACT_NINF)
1880         {
1881           yyn += YYTERROR;
1882           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1883             {
1884               yyn = yytable[yyn];
1885               if (0 < yyn)
1886                 break;
1887             }
1888         }
1889
1890       /* Pop the current state because it cannot handle the error token.  */
1891       if (yyssp == yyss)
1892         YYABORT;
1893
1894       YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1895       yydestruct (yystos[yystate], yyvsp);
1896       yyvsp--;
1897       yystate = *--yyssp;
1898
1899       YY_STACK_PRINT (yyss, yyssp);
1900     }
1901
1902   if (yyn == YYFINAL)
1903     YYACCEPT;
1904
1905   YYDPRINTF ((stderr, "Shifting error token, "));
1906
1907   *++yyvsp = yylval;
1908
1909
1910   yystate = yyn;
1911   goto yynewstate;
1912
1913
1914 /*-------------------------------------.
1915 | yyacceptlab -- YYACCEPT comes here.  |
1916 `-------------------------------------*/
1917 yyacceptlab:
1918   yyresult = 0;
1919   goto yyreturn;
1920
1921 /*-----------------------------------.
1922 | yyabortlab -- YYABORT comes here.  |
1923 `-----------------------------------*/
1924 yyabortlab:
1925   yyresult = 1;
1926   goto yyreturn;
1927
1928 #ifndef yyoverflow
1929 /*----------------------------------------------.
1930 | yyoverflowlab -- parser overflow comes here.  |
1931 `----------------------------------------------*/
1932 yyoverflowlab:
1933   yyerror ("parser stack overflow");
1934   yyresult = 2;
1935   /* Fall through.  */
1936 #endif
1937
1938 yyreturn:
1939 #ifndef yyoverflow
1940   if (yyss != yyssa)
1941     YYSTACK_FREE (yyss);
1942 #endif
1943   return yyresult;
1944 }
1945
1946
1947 #line 683 "src/cfgparser/oparse.y"
1948
1949
1950 void yyerror (char *string)
1951 {
1952   fprintf(stderr, "Config line %d: %s\n", current_line, string);
1953 }
1954
1955