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.2 2004/10/17 11:52:41 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  88
 375 /* YYNRULES -- Number of states. */
 376 #define YYNSTATES  131
 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,   129,   132,   135,
 432      138,   141,   144,   147,   150,   153,   156,   159,   162,   165,
 433      168,   171,   174,   177,   180,   183,   186,   189,   192,   195,
 434      198,   201,   204,   207,   210,   213,   216,   219,   223
 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,    15,    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,    92,    -1,    93,    -1,    94,    -1,    17,
 453        6,    -1,    31,    43,    -1,    32,    10,    -1,    33,    44,
 454       -1,    34,    44,    -1,    35,     8,    -1,    36,     8,    -1,
 455       37,     8,    -1,    38,     8,    -1,    39,     8,    -1,    40,
 456        8,    -1,    41,     8,    -1,    42,     8,    -1,    11,     7,
 457       -1,    12,     7,    -1,    43,    43,    -1,    44,     7,    -1,
 458        6,     6,    -1,    18,     9,    -1,    19,     7,    -1,    20,
 459        7,    -1,    21,     9,    -1,    22,     9,    -1,    23,     8,
 460       -1,    24,     8,    -1,    25,     8,    -1,    26,     8,    -1,
 461       27,     7,    -1,    28,     7,    -1,    29,     6,    -1,    30,
 462        6,     6,    -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,   224,   230,   253,   272,
 474      280,   300,   318,   325,   332,   339,   346,   353,   360,   367,
 475      376,   394,   408,   444,   481,   505,   512,   527,   542,   558,
 476      574,   583,   592,   600,   610,   626,   642,   664,   676
 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", "plname", "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,    62,    63,    64,    65,
 530       66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
 531       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
 532       86,    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,     1,     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,     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,    88,     4,     3,     0,     5,     6,     7,     8,     9,
 557       10,    11,    12,    13,    14,    15,    16,    17,    18,    70,
 558       71,    25,    19,    28,    20,    52,    22,    31,    21,    57,
 559       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
 560       85,    36,    23,     0,     0,     0,     0,     0,    24,     0,
 561       26,    27,     0,    29,    51,     0,     0,    53,    54,    55,
 562       56,    30,     0,    32,    33,    34,    35,     0,     0,     0,
 563        0,     0,     0,     0,     0,     0,     0,     0,     0,    37,
 564       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
 565       49,    50,    38,    72,    73,    86,     0,    74,    58,    59,
 566       60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
 567       87
 568 };
 569
 570 /* YYDEFGOTO[NTERM-NUM]. */
 571 static const yysigned_char yydefgoto[] =
 572 {
 573       -1,     1,    22,    23,    42,    63,    44,    64,    48,    66,
 574       83,    62,    67,    99,    46,    65,    77,    24,   100,   101,
 575      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
 576       25,    26,    70,    73,    84,    27,    28,    29,    30,    31,
 577       32,    33,    34,    35,    36,    37,    78,    79,    38
 578 };
 579
 580 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 581    STATE-NUM.  */
 582 #define YYPACT_NINF -59
 583 static const yysigned_char yypact[] =
 584 {
 585      -59,     0,   -59,     3,    40,    45,    46,    47,    48,    49,
 586       -5,    50,    51,    43,    44,    52,    53,    54,    55,    57,
 587       58,   -59,   -59,   -59,    56,   -59,   -59,   -59,   -59,   -59,
 588      -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,
 589      -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,
 590      -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,
 591      -59,   -59,   -59,     1,     2,    37,    -3,    -2,   -59,    11,
 592      -59,   -59,    61,   -59,   -59,    63,    64,   -59,   -59,   -59,
 593      -59,   -59,    65,   -59,   -59,   -59,   -59,    13,    62,    29,
 594       30,    67,    68,    69,    70,    71,    72,    73,    75,   -59,
 595      -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,
 596      -59,   -59,   -59,   -59,   -59,   -59,    78,   -59,   -59,   -59,
 597      -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,
 598      -59
 599 };
 600
 601 /* YYPGOTO[NTERM-NUM].  */
 602 static const yysigned_char yypgoto[] =
 603 {
 604      -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,
 605      -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,
 606      -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,
 607      -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,
 608      -59,   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -58
 609 };
 610
 611 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 612    positive, shift that token.  If negative, reduce the rule which
 613    number is the opposite.  If zero, do what YYDEFACT says.
 614    If YYTABLE_NINF, syntax error.  */
 615 #define YYTABLE_NINF -1
 616 static const unsigned char yytable[] =
 617 {
 618        2,    81,    86,    82,    50,    68,    71,    80,    85,   112,
 619       39,     3,     4,     5,     6,     7,     8,     9,    10,    11,
 620       12,    13,    14,    15,    16,    17,    18,    19,    20,    87,
 621       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
 622       98,    74,    21,    21,    69,    21,    72,    40,    41,    43,
 623       45,    47,    53,    54,   113,    49,   118,    51,    52,    61,
 624       55,    56,    57,    58,    59,    60,    75,    76,   114,   115,
 625      116,   117,   119,   120,   121,   122,   123,   124,   125,   126,
 626      127,   128,    21,   129,   130
 627 };
 628
 629 static const unsigned char yycheck[] =
 630 {
 631        0,     4,     4,     6,     9,     4,     4,    65,    66,    67,
 632        7,    11,    12,    13,    14,    15,    16,    17,    18,    19,
 633       20,    21,    22,    23,    24,    25,    26,    27,    28,    31,
 634       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
 635       42,     4,    45,    45,    43,    45,    44,     7,     3,     3,
 636        3,     3,     9,     9,    43,     6,    43,     7,     7,     3,
 637        8,     8,     8,     8,     7,     7,    29,    30,     7,     6,
 638        6,     6,    10,    44,    44,     8,     8,     8,     8,     8,
 639        8,     8,    45,     8,     6
 640 };
 641
 642 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 643    symbol of state STATE-NUM.  */
 644 static const unsigned char yystos[] =
 645 {
 646        0,    47,     0,    11,    12,    13,    14,    15,    16,    17,
 647       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
 648       28,    45,    48,    49,    63,    76,    77,    81,    82,    83,
 649       84,    85,    86,    87,    88,    89,    90,    91,    94,     7,
 650        7,     3,    50,     3,    52,     3,    60,     3,    54,     6,
 651        9,     7,     7,     9,     9,     8,     8,     8,     8,     7,
 652        7,     3,    57,    51,    53,    61,    55,    58,     4,    43,
 653       78,     4,    44,    79,     4,    29,    30,    62,    92,    93,
 654       94,     4,     6,    56,    80,    94,     4,    31,    32,    33,
 655       34,    35,    36,    37,    38,    39,    40,    41,    42,    59,
 656       64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
 657       74,    75,    94,    43,     7,     6,     6,     6,    43,    10,
 658       44,    44,     8,     8,     8,     8,     8,     8,     8,     8,
 659        6
 660 };
 661
 662 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 663 # define YYSIZE_T __SIZE_TYPE__
 664 #endif
 665 #if ! defined (YYSIZE_T) && defined (size_t)
 666 # define YYSIZE_T size_t
 667 #endif
 668 #if ! defined (YYSIZE_T)
 669 # if defined (__STDC__) || defined (__cplusplus)
 670 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 671 #  define YYSIZE_T size_t
 672 # endif
 673 #endif
 674 #if ! defined (YYSIZE_T)
 675 # define YYSIZE_T unsigned int
 676 #endif
 677
 678 #define yyerrok         (yyerrstatus = 0)
 679 #define yyclearin       (yychar = YYEMPTY)
 680 #define YYEMPTY         (-2)
 681 #define YYEOF           0
 682
 683 #define YYACCEPT        goto yyacceptlab
 684 #define YYABORT         goto yyabortlab
 685 #define YYERROR         goto yyerrlab1
 686
 687
 688 /* Like YYERROR except do call yyerror.  This remains here temporarily
 689    to ease the transition to the new meaning of YYERROR, for GCC.
 690    Once GCC version 2 has supplanted version 1, this can go.  */
 691
 692 #define YYFAIL          goto yyerrlab
 693
 694 #define YYRECOVERING()  (!!yyerrstatus)
 695
 696 #define YYBACKUP(Token, Value)                                  \
 697 do                                                              \
 698   if (yychar == YYEMPTY && yylen == 1)                          \
 699     {                                                           \
 700       yychar = (Token);                                         \
 701       yylval = (Value);                                         \
 702       yytoken = YYTRANSLATE (yychar);                           \
 703       YYPOPSTACK;                                               \
 704       goto yybackup;                                            \
 705     }                                                           \
 706   else                                                          \
 707     {                                                           \
 708       yyerror ("syntax error: cannot back up");\
 709       YYERROR;                                                  \
 710     }                                                           \
 711 while (0)
 712
 713 #define YYTERROR        1
 714 #define YYERRCODE       256
 715
 716 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
 717    are run).  */
 718
 719 #ifndef YYLLOC_DEFAULT
 720 # define YYLLOC_DEFAULT(Current, Rhs, N)         \
 721   Current.first_line   = Rhs[1].first_line;      \
 722   Current.first_column = Rhs[1].first_column;    \
 723   Current.last_line    = Rhs[N].last_line;       \
 724   Current.last_column  = Rhs[N].last_column;
 725 #endif
 726
 727 /* YYLEX -- calling `yylex' with the right arguments.  */
 728
 729 #ifdef YYLEX_PARAM
 730 # define YYLEX yylex (YYLEX_PARAM)
 731 #else
 732 # define YYLEX yylex ()
 733 #endif
 734
 735 /* Enable debugging if requested.  */
 736 #if YYDEBUG
 737
 738 # ifndef YYFPRINTF
 739 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 740 #  define YYFPRINTF fprintf
 741 # endif
 742
 743 # define YYDPRINTF(Args)                        \
 744 do {                                            \
 745   if (yydebug)                                  \
 746     YYFPRINTF Args;                             \
 747 } while (0)
 748
 749 # define YYDSYMPRINT(Args)                      \
 750 do {                                            \
 751   if (yydebug)                                  \
 752     yysymprint Args;                            \
 753 } while (0)
 754
 755 # define YYDSYMPRINTF(Title, Token, Value, Location)            \
 756 do {                                                            \
 757   if (yydebug)                                                  \
 758     {                                                           \
 759       YYFPRINTF (stderr, "%s ", Title);                         \
 760       yysymprint (stderr,                                       \
 761                   Token, Value);        \
 762       YYFPRINTF (stderr, "\n");                                 \
 763     }                                                           \
 764 } while (0)
 765
 766 /*------------------------------------------------------------------.
 767 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 768 | TOP (cinluded).                                                   |
 769 `------------------------------------------------------------------*/
 770
 771 #if defined (__STDC__) || defined (__cplusplus)
 772 static void
 773 yy_stack_print (short *bottom, short *top)
 774 #else
 775 static void
 776 yy_stack_print (bottom, top)
 777     short *bottom;
 778     short *top;
 779 #endif
 780 {
 781   YYFPRINTF (stderr, "Stack now");
 782   for (/* Nothing. */; bottom <= top; ++bottom)
 783     YYFPRINTF (stderr, " %d", *bottom);
 784   YYFPRINTF (stderr, "\n");
 785 }
 786
 787 # define YY_STACK_PRINT(Bottom, Top)                            \
 788 do {                                                            \
 789   if (yydebug)                                                  \
 790     yy_stack_print ((Bottom), (Top));                           \
 791 } while (0)
 792
 793
 794 /*------------------------------------------------.
 795 | Report that the YYRULE is going to be reduced.  |
 796 `------------------------------------------------*/
 797
 798 #if defined (__STDC__) || defined (__cplusplus)
 799 static void
 800 yy_reduce_print (int yyrule)
 801 #else
 802 static void
 803 yy_reduce_print (yyrule)
 804     int yyrule;
 805 #endif
 806 {
 807   int yyi;
 808   unsigned int yylineno = yyrline[yyrule];
 809   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
 810              yyrule - 1, yylineno);
 811   /* Print the symbols being reduced, and their result.  */
 812   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
 813     YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
 814   YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
 815 }
 816
 817 # define YY_REDUCE_PRINT(Rule)          \
 818 do {                                    \
 819   if (yydebug)                          \
 820     yy_reduce_print (Rule);             \
 821 } while (0)
 822
 823 /* Nonzero means print parse trace.  It is left uninitialized so that
 824    multiple parsers can coexist.  */
 825 int yydebug;
 826 #else /* !YYDEBUG */
 827 # define YYDPRINTF(Args)
 828 # define YYDSYMPRINT(Args)
 829 # define YYDSYMPRINTF(Title, Token, Value, Location)
 830 # define YY_STACK_PRINT(Bottom, Top)
 831 # define YY_REDUCE_PRINT(Rule)
 832 #endif /* !YYDEBUG */
 833
 834
 835 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 836 #ifndef YYINITDEPTH
 837 # define YYINITDEPTH 200
 838 #endif
 839
 840 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 841    if the built-in stack extension method is used).
 842
 843    Do not make this value too large; the results are undefined if
 844    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 845    evaluated with infinite-precision integer arithmetic.  */
 846
 847 #if YYMAXDEPTH == 0
 848 # undef YYMAXDEPTH
 849 #endif
 850
 851 #ifndef YYMAXDEPTH
 852 # define YYMAXDEPTH 10000
 853 #endif
 854
 855 \f
 856
 857 #if YYERROR_VERBOSE
 858
 859 # ifndef yystrlen
 860 #  if defined (__GLIBC__) && defined (_STRING_H)
 861 #   define yystrlen strlen
 862 #  else
 863 /* Return the length of YYSTR.  */
 864 static YYSIZE_T
 865 #   if defined (__STDC__) || defined (__cplusplus)
 866 yystrlen (const char *yystr)
 867 #   else
 868 yystrlen (yystr)
 869      const char *yystr;
 870 #   endif
 871 {
 872   register const char *yys = yystr;
 873
 874   while (*yys++ != '\0')
 875     continue;
 876
 877   return yys - yystr - 1;
 878 }
 879 #  endif
 880 # endif
 881
 882 # ifndef yystpcpy
 883 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 884 #   define yystpcpy stpcpy
 885 #  else
 886 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 887    YYDEST.  */
 888 static char *
 889 #   if defined (__STDC__) || defined (__cplusplus)
 890 yystpcpy (char *yydest, const char *yysrc)
 891 #   else
 892 yystpcpy (yydest, yysrc)
 893      char *yydest;
 894      const char *yysrc;
 895 #   endif
 896 {
 897   register char *yyd = yydest;
 898   register const char *yys = yysrc;
 899
 900   while ((*yyd++ = *yys++) != '\0')
 901     continue;
 902
 903   return yyd - 1;
 904 }
 905 #  endif
 906 # endif
 907
 908 #endif /* !YYERROR_VERBOSE */
 909
 910 \f
 911
 912 #if YYDEBUG
 913 /*--------------------------------.
 914 | Print this symbol on YYOUTPUT.  |
 915 `--------------------------------*/
 916
 917 #if defined (__STDC__) || defined (__cplusplus)
 918 static void
 919 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
 920 #else
 921 static void
 922 yysymprint (yyoutput, yytype, yyvaluep)
 923     FILE *yyoutput;
 924     int yytype;
 925     YYSTYPE *yyvaluep;
 926 #endif
 927 {
 928   /* Pacify ``unused variable'' warnings.  */
 929   (void) yyvaluep;
 930
 931   if (yytype < YYNTOKENS)
 932     {
 933       YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 934 # ifdef YYPRINT
 935       YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 936 # endif
 937     }
 938   else
 939     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 940
 941   switch (yytype)
 942     {
 943       default:
 944         break;
 945     }
 946   YYFPRINTF (yyoutput, ")");
 947 }
 948
 949 #endif /* ! YYDEBUG */
 950 /*-----------------------------------------------.
 951 | Release the memory associated to this symbol.  |
 952 `-----------------------------------------------*/
 953
 954 #if defined (__STDC__) || defined (__cplusplus)
 955 static void
 956 yydestruct (int yytype, YYSTYPE *yyvaluep)
 957 #else
 958 static void
 959 yydestruct (yytype, yyvaluep)
 960     int yytype;
 961     YYSTYPE *yyvaluep;
 962 #endif
 963 {
 964   /* Pacify ``unused variable'' warnings.  */
 965   (void) yyvaluep;
 966
 967   switch (yytype)
 968     {
 969
 970       default:
 971         break;
 972     }
 973 }
 974 \f
 975
 976 /* Prevent warnings from -Wmissing-prototypes.  */
 977
 978 #ifdef YYPARSE_PARAM
 979 # if defined (__STDC__) || defined (__cplusplus)
 980 int yyparse (void *YYPARSE_PARAM);
 981 # else
 982 int yyparse ();
 983 # endif
 984 #else /* ! YYPARSE_PARAM */
 985 #if defined (__STDC__) || defined (__cplusplus)
 986 int yyparse (void);
 987 #else
 988 int yyparse ();
 989 #endif
 990 #endif /* ! YYPARSE_PARAM */
 991
 992
 993
 994 /* The lookahead symbol.  */
 995 int yychar;
 996
 997 /* The semantic value of the lookahead symbol.  */
 998 YYSTYPE yylval;
 999
1000 /* Number of syntax errors so far.  */
1001 int yynerrs;
1002
1003
1004
1005 /*----------.
1006 | yyparse.  |
1007 `----------*/
1008
1009 #ifdef YYPARSE_PARAM
1010 # if defined (__STDC__) || defined (__cplusplus)
1011 int yyparse (void *YYPARSE_PARAM)
1012 # else
1013 int yyparse (YYPARSE_PARAM)
1014   void *YYPARSE_PARAM;
1015 # endif
1016 #else /* ! YYPARSE_PARAM */
1017 #if defined (__STDC__) || defined (__cplusplus)
1018 int
1019 yyparse (void)
1020 #else
1021 int
1022 yyparse ()
1023
1024 #endif
1025 #endif
1026 {
1027
1028   register int yystate;
1029   register int yyn;
1030   int yyresult;
1031   /* Number of tokens to shift before error messages enabled.  */
1032   int yyerrstatus;
1033   /* Lookahead token as an internal (translated) token number.  */
1034   int yytoken = 0;
1035
1036   /* Three stacks and their tools:
1037      `yyss': related to states,
1038      `yyvs': related to semantic values,
1039      `yyls': related to locations.
1040
1041      Refer to the stacks thru separate pointers, to allow yyoverflow
1042      to reallocate them elsewhere.  */
1043
1044   /* The state stack.  */
1045   short yyssa[YYINITDEPTH];
1046   short *yyss = yyssa;
1047   register short *yyssp;
1048
1049   /* The semantic value stack.  */
1050   YYSTYPE yyvsa[YYINITDEPTH];
1051   YYSTYPE *yyvs = yyvsa;
1052   register YYSTYPE *yyvsp;
1053
1054
1055
1056 #define YYPOPSTACK   (yyvsp--, yyssp--)
1057
1058   YYSIZE_T yystacksize = YYINITDEPTH;
1059
1060   /* The variables used to return semantic value and location from the
1061      action routines.  */
1062   YYSTYPE yyval;
1063
1064
1065   /* When reducing, the number of symbols on the RHS of the reduced
1066      rule.  */
1067   int yylen;
1068
1069   YYDPRINTF ((stderr, "Starting parse\n"));
1070
1071   yystate = 0;
1072   yyerrstatus = 0;
1073   yynerrs = 0;
1074   yychar = YYEMPTY;             /* Cause a token to be read.  */
1075
1076   /* Initialize stack pointers.
1077      Waste one element of value and location stack
1078      so that they stay on the same level as the state stack.
1079      The wasted elements are never initialized.  */
1080
1081   yyssp = yyss;
1082   yyvsp = yyvs;
1083
1084   goto yysetstate;
1085
1086 /*------------------------------------------------------------.
1087 | yynewstate -- Push a new state, which is found in yystate.  |
1088 `------------------------------------------------------------*/
1089  yynewstate:
1090   /* In all cases, when you get here, the value and location stacks
1091      have just been pushed. so pushing a state here evens the stacks.
1092      */
1093   yyssp++;
1094
1095  yysetstate:
1096   *yyssp = yystate;
1097
1098   if (yyss + yystacksize - 1 <= yyssp)
1099     {
1100       /* Get the current used size of the three stacks, in elements.  */
1101       YYSIZE_T yysize = yyssp - yyss + 1;
1102
1103 #ifdef yyoverflow
1104       {
1105         /* Give user a chance to reallocate the stack. Use copies of
1106            these so that the &'s don't force the real ones into
1107            memory.  */
1108         YYSTYPE *yyvs1 = yyvs;
1109         short *yyss1 = yyss;
1110
1111
1112         /* Each stack pointer address is followed by the size of the
1113            data in use in that stack, in bytes.  This used to be a
1114            conditional around just the two extra args, but that might
1115            be undefined if yyoverflow is a macro.  */
1116         yyoverflow ("parser stack overflow",
1117                     &yyss1, yysize * sizeof (*yyssp),
1118                     &yyvs1, yysize * sizeof (*yyvsp),
1119
1120                     &yystacksize);
1121
1122         yyss = yyss1;
1123         yyvs = yyvs1;
1124       }
1125 #else /* no yyoverflow */
1126 # ifndef YYSTACK_RELOCATE
1127       goto yyoverflowlab;
1128 # else
1129       /* Extend the stack our own way.  */
1130       if (YYMAXDEPTH <= yystacksize)
1131         goto yyoverflowlab;
1132       yystacksize *= 2;
1133       if (YYMAXDEPTH < yystacksize)
1134         yystacksize = YYMAXDEPTH;
1135
1136       {
1137         short *yyss1 = yyss;
1138         union yyalloc *yyptr =
1139           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1140         if (! yyptr)
1141           goto yyoverflowlab;
1142         YYSTACK_RELOCATE (yyss);
1143         YYSTACK_RELOCATE (yyvs);
1144
1145 #  undef YYSTACK_RELOCATE
1146         if (yyss1 != yyssa)
1147           YYSTACK_FREE (yyss1);
1148       }
1149 # endif
1150 #endif /* no yyoverflow */
1151
1152       yyssp = yyss + yysize - 1;
1153       yyvsp = yyvs + yysize - 1;
1154
1155
1156       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1157                   (unsigned long int) yystacksize));
1158
1159       if (yyss + yystacksize - 1 <= yyssp)
1160         YYABORT;
1161     }
1162
1163   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1164
1165   goto yybackup;
1166
1167 /*-----------.
1168 | yybackup.  |
1169 `-----------*/
1170 yybackup:
1171
1172 /* Do appropriate processing given the current state.  */
1173 /* Read a lookahead token if we need one and don't already have one.  */
1174 /* yyresume: */
1175
1176   /* First try to decide what to do without reference to lookahead token.  */
1177
1178   yyn = yypact[yystate];
1179   if (yyn == YYPACT_NINF)
1180     goto yydefault;
1181
1182   /* Not known => get a lookahead token if don't already have one.  */
1183
1184   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1185   if (yychar == YYEMPTY)
1186     {
1187       YYDPRINTF ((stderr, "Reading a token: "));
1188       yychar = YYLEX;
1189     }
1190
1191   if (yychar <= YYEOF)
1192     {
1193       yychar = yytoken = YYEOF;
1194       YYDPRINTF ((stderr, "Now at end of input.\n"));
1195     }
1196   else
1197     {
1198       yytoken = YYTRANSLATE (yychar);
1199       YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
1200     }
1201
1202   /* If the proper action on seeing token YYTOKEN is to reduce or to
1203      detect an error, take that action.  */
1204   yyn += yytoken;
1205   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1206     goto yydefault;
1207   yyn = yytable[yyn];
1208   if (yyn <= 0)
1209     {
1210       if (yyn == 0 || yyn == YYTABLE_NINF)
1211         goto yyerrlab;
1212       yyn = -yyn;
1213       goto yyreduce;
1214     }
1215
1216   if (yyn == YYFINAL)
1217     YYACCEPT;
1218
1219   /* Shift the lookahead token.  */
1220   YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
1221
1222   /* Discard the token being shifted unless it is eof.  */
1223   if (yychar != YYEOF)
1224     yychar = YYEMPTY;
1225
1226   *++yyvsp = yylval;
1227
1228
1229   /* Count tokens shifted since error; after three, turn off error
1230      status.  */
1231   if (yyerrstatus)
1232     yyerrstatus--;
1233
1234   yystate = yyn;
1235   goto yynewstate;
1236
1237
1238 /*-----------------------------------------------------------.
1239 | yydefault -- do the default action for the current state.  |
1240 `-----------------------------------------------------------*/
1241 yydefault:
1242   yyn = yydefact[yystate];
1243   if (yyn == 0)
1244     goto yyerrlab;
1245   goto yyreduce;
1246
1247
1248 /*-----------------------------.
1249 | yyreduce -- Do a reduction.  |
1250 `-----------------------------*/
1251 yyreduce:
1252   /* yyn is the number of a rule to reduce with.  */
1253   yylen = yyr2[yyn];
1254
1255   /* If YYLEN is nonzero, implement the default value of the action:
1256      `$$ = $1'.
1257
1258      Otherwise, the following line sets YYVAL to garbage.
1259      This behavior is undocumented and Bison
1260      users should not rely upon it.  Assigning to YYVAL
1261      unconditionally makes the parser a bit smaller, and it avoids a
1262      GCC warning that YYVAL may be used uninitialized.  */
1263   yyval = yyvsp[1-yylen];
1264
1265
1266   YY_REDUCE_PRINT (yyn);
1267   switch (yyn)
1268     {
1269         case 57:
1270 #line 231 "src/cfgparser/oparse.y"
1271     {
1272   struct if_config_options *io = get_default_if_config();
1273   if(io == NULL)
1274     {
1275       fprintf(stderr, "Out of memory(ADD IFRULE)\n");
1276       YYABORT;
1277     }
1278
1279   if(PARSER_DEBUG) printf("Interface setup: \"%s\"\n", yyvsp[0]->string);
1280
1281   io->name = yyvsp[0]->string;
1282
1283
1284   /* Queue */
1285   io->next = cnf->if_options;
1286   cnf->if_options = io;
1287
1288   free(yyvsp[0]);
1289 }
1290     break;
1291
1292   case 58:
1293 #line 254 "src/cfgparser/oparse.y"
1294     {
1295   struct in_addr in;
1296
1297   if(PARSER_DEBUG) printf("\tIPv4 broadcast: %s\n", yyvsp[0]->string);
1298
1299   if(inet_aton(yyvsp[0]->string, &in) == 0)
1300     {
1301       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[-1]->string);
1302       exit(EXIT_FAILURE);
1303     }
1304
1305   cnf->if_options->ipv4_broadcast.v4 = in.s_addr;
1306
1307   free(yyvsp[0]->string);
1308   free(yyvsp[0]);
1309 }
1310     break;
1311
1312   case 59:
1313 #line 273 "src/cfgparser/oparse.y"
1314     {
1315   cnf->if_options->ipv6_addrtype = yyvsp[0]->boolean;
1316
1317   free(yyvsp[0]);
1318 }
1319     break;
1320
1321   case 60:
1322 #line 281 "src/cfgparser/oparse.y"
1323     {
1324   struct in6_addr in6;
1325
1326   if(PARSER_DEBUG) printf("\tIPv6 site-local multicast: %s\n", yyvsp[0]->string);
1327
1328   if(inet_pton(AF_INET6, yyvsp[0]->string, &in6) < 0)
1329     {
1330       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[0]->string);
1331       exit(EXIT_FAILURE);
1332     }
1333   memcpy(&cnf->if_options->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
1334
1335
1336   free(yyvsp[0]->string);
1337   free(yyvsp[0]);
1338 }
1339     break;
1340
1341   case 61:
1342 #line 301 "src/cfgparser/oparse.y"
1343     {
1344   struct in6_addr in6;
1345
1346   if(PARSER_DEBUG) printf("\tIPv6 global multicast: %s\n", yyvsp[0]->string);
1347
1348   if(inet_pton(AF_INET6, yyvsp[0]->string, &in6) < 0)
1349     {
1350       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[0]->string);
1351       exit(EXIT_FAILURE);
1352     }
1353   memcpy(&cnf->if_options->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
1354
1355
1356   free(yyvsp[0]->string);
1357   free(yyvsp[0]);
1358 }
1359     break;
1360
1361   case 62:
1362 #line 319 "src/cfgparser/oparse.y"
1363     {
1364     if(PARSER_DEBUG) printf("\tHELLO interval: %0.2f\n", yyvsp[0]->floating);
1365     cnf->if_options->hello_params.emission_interval = yyvsp[0]->floating;
1366     free(yyvsp[0]);
1367 }
1368     break;
1369
1370   case 63:
1371 #line 326 "src/cfgparser/oparse.y"
1372     {
1373     if(PARSER_DEBUG) printf("\tHELLO validity: %0.2f\n", yyvsp[0]->floating);
1374     cnf->if_options->hello_params.validity_time = yyvsp[0]->floating;
1375     free(yyvsp[0]);
1376 }
1377     break;
1378
1379   case 64:
1380 #line 333 "src/cfgparser/oparse.y"
1381     {
1382     if(PARSER_DEBUG) printf("\tTC interval: %0.2f\n", yyvsp[0]->floating);
1383     cnf->if_options->tc_params.emission_interval = yyvsp[0]->floating;
1384     free(yyvsp[0]);
1385 }
1386     break;
1387
1388   case 65:
1389 #line 340 "src/cfgparser/oparse.y"
1390     {
1391     if(PARSER_DEBUG) printf("\tTC validity: %0.2f\n", yyvsp[0]->floating);
1392     cnf->if_options->tc_params.validity_time = yyvsp[0]->floating;
1393     free(yyvsp[0]);
1394 }
1395     break;
1396
1397   case 66:
1398 #line 347 "src/cfgparser/oparse.y"
1399     {
1400     if(PARSER_DEBUG) printf("\tMID interval: %0.2f\n", yyvsp[0]->floating);
1401     cnf->if_options->mid_params.emission_interval = yyvsp[0]->floating;
1402     free(yyvsp[0]);
1403 }
1404     break;
1405
1406   case 67:
1407 #line 354 "src/cfgparser/oparse.y"
1408     {
1409     if(PARSER_DEBUG) printf("\tMID validity: %0.2f\n", yyvsp[0]->floating);
1410     cnf->if_options->mid_params.validity_time = yyvsp[0]->floating;
1411     free(yyvsp[0]);
1412 }
1413     break;
1414
1415   case 68:
1416 #line 361 "src/cfgparser/oparse.y"
1417     {
1418     if(PARSER_DEBUG) printf("\tHNA interval: %0.2f\n", yyvsp[0]->floating);
1419     cnf->if_options->hna_params.emission_interval = yyvsp[0]->floating;
1420     free(yyvsp[0]);
1421 }
1422     break;
1423
1424   case 69:
1425 #line 368 "src/cfgparser/oparse.y"
1426     {
1427     if(PARSER_DEBUG) printf("\tHNA validity: %0.2f\n", yyvsp[0]->floating);
1428     cnf->if_options->hna_params.validity_time = yyvsp[0]->floating;
1429     free(yyvsp[0]);
1430 }
1431     break;
1432
1433   case 70:
1434 #line 377 "src/cfgparser/oparse.y"
1435     {
1436
1437   if(yyvsp[0]->boolean == 1)
1438     {
1439       if(PARSER_DEBUG) printf("Debug levl AUTO\n");
1440     }
1441   else
1442     {
1443       cnf->debug_level = yyvsp[0]->integer;
1444       if(PARSER_DEBUG) printf("Debug level: %d\n", cnf->debug_level);
1445     }
1446
1447   free(yyvsp[0]);
1448 }
1449     break;
1450
1451   case 71:
1452 #line 395 "src/cfgparser/oparse.y"
1453     {
1454   if((yyvsp[0]->integer != 4) && (yyvsp[0]->integer != 6))
1455     {
1456       fprintf(stderr, "IPversion must be 4 or 6!\n");
1457       YYABORT;
1458     }
1459   cnf->ip_version = yyvsp[0]->integer;
1460   if(PARSER_DEBUG) printf("IpVersion: %d\n", cnf->ip_version);
1461   free(yyvsp[0]);
1462 }
1463     break;
1464
1465   case 72:
1466 #line 409 "src/cfgparser/oparse.y"
1467     {
1468   struct hna4_entry *h = malloc(sizeof(struct hna4_entry));
1469   struct in_addr in;
1470
1471   if(PARSER_DEBUG) printf("HNA IPv4 entry: %s/%s\n", yyvsp[-1]->string, yyvsp[0]->string);
1472
1473   if(h == NULL)
1474     {
1475       fprintf(stderr, "Out of memory(HNA4)\n");
1476       YYABORT;
1477     }
1478
1479   if(inet_aton(yyvsp[-1]->string, &in) == 0)
1480     {
1481       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[-1]->string);
1482       exit(EXIT_FAILURE);
1483     }
1484   h->net = in.s_addr;
1485   if(inet_aton(yyvsp[0]->string, &in) == 0)
1486     {
1487       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[-1]->string);
1488       exit(EXIT_FAILURE);
1489     }
1490   h->netmask = in.s_addr;
1491   /* Queue */
1492   h->next = cnf->hna4_entries;
1493   cnf->hna4_entries = h;
1494
1495   free(yyvsp[-1]->string);
1496   free(yyvsp[-1]);
1497   free(yyvsp[0]->string);
1498   free(yyvsp[0]);
1499
1500 }
1501     break;
1502
1503   case 73:
1504 #line 445 "src/cfgparser/oparse.y"
1505     {
1506   struct hna6_entry *h = malloc(sizeof(struct hna6_entry));
1507   struct in6_addr in6;
1508
1509   if(PARSER_DEBUG) printf("HNA IPv6 entry: %s/%d\n", yyvsp[-1]->string, yyvsp[0]->integer);
1510
1511   if(h == NULL)
1512     {
1513       fprintf(stderr, "Out of memory(HNA6)\n");
1514       YYABORT;
1515     }
1516
1517   if(inet_pton(AF_INET6, yyvsp[-1]->string, &in6) < 0)
1518     {
1519       fprintf(stderr, "Failed converting IP address %s\n", yyvsp[-1]->string);
1520       exit(EXIT_FAILURE);
1521     }
1522   memcpy(&h->net, &in6, sizeof(struct in6_addr));
1523
1524   if((yyvsp[0]->integer < 0) || (yyvsp[0]->integer > 128))
1525     {
1526       fprintf(stderr, "Illegal IPv6 prefix length %d\n", yyvsp[0]->integer);
1527       exit(EXIT_FAILURE);
1528     }
1529
1530   h->prefix_len = yyvsp[0]->integer;
1531   /* Queue */
1532   h->next = cnf->hna6_entries;
1533   cnf->hna6_entries = h;
1534
1535   free(yyvsp[-1]->string);
1536   free(yyvsp[-1]);
1537   free(yyvsp[0]);
1538
1539 }
1540     break;
1541
1542   case 74:
1543 #line 482 "src/cfgparser/oparse.y"
1544     {
1545   struct olsr_if *in = malloc(sizeof(struct olsr_if));
1546
1547   if(in == NULL)
1548     {
1549       fprintf(stderr, "Out of memory(ADD IF)\n");
1550       YYABORT;
1551     }
1552
1553   in->name = yyvsp[-1]->string;
1554   in->config = yyvsp[0]->string;
1555
1556   if(PARSER_DEBUG) printf("Interface: %s Ruleset: %s\n", yyvsp[-1]->string, yyvsp[0]->string);
1557
1558   /* Queue */
1559   in->next = cnf->interfaces;
1560   cnf->interfaces = in;
1561
1562   free(yyvsp[-1]);
1563   free(yyvsp[0]);
1564 }
1565     break;
1566
1567   case 75:
1568 #line 506 "src/cfgparser/oparse.y"
1569     {
1570   if(PARSER_DEBUG) printf("Noint set to %d\n", yyvsp[0]->boolean);
1571   free(yyvsp[0]);
1572 }
1573     break;
1574
1575   case 76:
1576 #line 513 "src/cfgparser/oparse.y"
1577     {
1578   if(yyvsp[0]->boolean == 1)
1579     {
1580       if(PARSER_DEBUG) printf("Tos AUTO\n");
1581     }
1582   else
1583     {
1584       if(PARSER_DEBUG) printf("TOS: %d\n", yyvsp[0]->integer);
1585     }
1586   free(yyvsp[0]);
1587
1588 }
1589     break;
1590
1591   case 77:
1592 #line 528 "src/cfgparser/oparse.y"
1593     {
1594   if(yyvsp[0]->boolean == 1)
1595     {
1596       if(PARSER_DEBUG) printf("Willingness AUTO\n");
1597     }
1598   else
1599     {
1600       if(PARSER_DEBUG) printf("Willingness: %d\n", yyvsp[0]->integer);
1601     }
1602   free(yyvsp[0]);
1603
1604 }
1605     break;
1606
1607   case 78:
1608 #line 543 "src/cfgparser/oparse.y"
1609     {
1610   if(yyvsp[0]->boolean == 1)
1611     {
1612       if(PARSER_DEBUG) printf("IPC allowed\n");
1613     }
1614   else
1615     {
1616       if(PARSER_DEBUG) printf("IPC blocked\n");
1617     }
1618   free(yyvsp[0]);
1619
1620 }
1621     break;
1622
1623   case 79:
1624 #line 559 "src/cfgparser/oparse.y"
1625     {
1626   if(yyvsp[0]->boolean == 1)
1627     {
1628       if(PARSER_DEBUG) printf("Hysteresis enabled\n");
1629     }
1630   else
1631     {
1632       if(PARSER_DEBUG) printf("Hysteresis disabled\n");
1633     }
1634   free(yyvsp[0]);
1635
1636 }
1637     break;
1638
1639   case 80:
1640 #line 575 "src/cfgparser/oparse.y"
1641     {
1642   cnf->hysteresis_param.scaling = yyvsp[0]->floating;
1643   if(PARSER_DEBUG) printf("Hysteresis Scaling: %0.2f\n", yyvsp[0]->floating);
1644   free(yyvsp[0]);
1645 }
1646     break;
1647
1648   case 81:
1649 #line 584 "src/cfgparser/oparse.y"
1650     {
1651   cnf->hysteresis_param.thr_high = yyvsp[0]->floating;
1652   if(PARSER_DEBUG) printf("Hysteresis UpperThr: %0.2f\n", yyvsp[0]->floating);
1653   free(yyvsp[0]);
1654 }
1655     break;
1656
1657   case 82:
1658 #line 593 "src/cfgparser/oparse.y"
1659     {
1660   cnf->hysteresis_param.thr_low = yyvsp[0]->floating;
1661   if(PARSER_DEBUG) printf("Hysteresis LowerThr: %0.2f\n", yyvsp[0]->floating);
1662   free(yyvsp[0]);
1663 }
1664     break;
1665
1666   case 83:
1667 #line 601 "src/cfgparser/oparse.y"
1668     {
1669   if(PARSER_DEBUG) printf("Pollrate %0.2f\n", yyvsp[0]->floating);
1670   cnf->pollrate = yyvsp[0]->floating;
1671
1672   free(yyvsp[0]);
1673 }
1674     break;
1675
1676   case 84:
1677 #line 611 "src/cfgparser/oparse.y"
1678     {
1679   if(yyvsp[0]->boolean == 1)
1680     {
1681       if(PARSER_DEBUG) printf("TC redundancy AUTO\n");
1682     }
1683   else
1684     {
1685       if(PARSER_DEBUG) printf("TC redundancy %d\n", yyvsp[0]->integer);
1686       cnf->tc_redundancy = yyvsp[0]->integer;
1687     }
1688   free(yyvsp[0]);
1689
1690 }
1691     break;
1692
1693   case 85:
1694 #line 627 "src/cfgparser/oparse.y"
1695     {
1696   if(yyvsp[0]->boolean == 1)
1697     {
1698       if(PARSER_DEBUG) printf("MPR coverage AUTO\n");
1699     }
1700   else
1701     {
1702       if(PARSER_DEBUG) printf("MPR coverage %d\n", yyvsp[0]->integer);
1703       cnf->mpr_coverage = yyvsp[0]->integer;
1704     }
1705   free(yyvsp[0]);
1706 }
1707     break;
1708
1709   case 86:
1710 #line 643 "src/cfgparser/oparse.y"
1711     {
1712   struct plugin_entry *pe = malloc(sizeof(struct plugin_entry));
1713
1714   if(pe == NULL)
1715     {
1716       fprintf(stderr, "Out of memory(ADD PL)\n");
1717       YYABORT;
1718     }
1719
1720   pe->name = yyvsp[0]->string;
1721
1722   if(PARSER_DEBUG) printf("Plugin: %s\n", yyvsp[0]->string);
1723
1724   /* Queue */
1725   pe->next = cnf->plugins;
1726   cnf->plugins = pe;
1727
1728   free(yyvsp[0]);
1729 }
1730     break;
1731
1732   case 87:
1733 #line 665 "src/cfgparser/oparse.y"
1734     {
1735
1736     if(PARSER_DEBUG) printf("Plugin param key:\"%s\" val: \"%s\"\n", yyvsp[-1]->string, yyvsp[0]->string);
1737
1738     free(yyvsp[-1]->string);
1739     free(yyvsp[-1]);
1740     free(yyvsp[0]->string);
1741     free(yyvsp[0]);
1742 }
1743     break;
1744
1745   case 88:
1746 #line 677 "src/cfgparser/oparse.y"
1747     {
1748     //if(PARSER_DEBUG) printf("Comment\n");
1749 }
1750     break;
1751
1752
1753     }
1754
1755 /* Line 999 of yacc.c.  */
1756 #line 1757 "y.tab.c"
1757 \f
1758   yyvsp -= yylen;
1759   yyssp -= yylen;
1760
1761
1762   YY_STACK_PRINT (yyss, yyssp);
1763
1764   *++yyvsp = yyval;
1765
1766
1767   /* Now `shift' the result of the reduction.  Determine what state
1768      that goes to, based on the state we popped back to and the rule
1769      number reduced by.  */
1770
1771   yyn = yyr1[yyn];
1772
1773   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1774   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1775     yystate = yytable[yystate];
1776   else
1777     yystate = yydefgoto[yyn - YYNTOKENS];
1778
1779   goto yynewstate;
1780
1781
1782 /*------------------------------------.
1783 | yyerrlab -- here on detecting error |
1784 `------------------------------------*/
1785 yyerrlab:
1786   /* If not already recovering from an error, report this error.  */
1787   if (!yyerrstatus)
1788     {
1789       ++yynerrs;
1790 #if YYERROR_VERBOSE
1791       yyn = yypact[yystate];
1792
1793       if (YYPACT_NINF < yyn && yyn < YYLAST)
1794         {
1795           YYSIZE_T yysize = 0;
1796           int yytype = YYTRANSLATE (yychar);
1797           char *yymsg;
1798           int yyx, yycount;
1799
1800           yycount = 0;
1801           /* Start YYX at -YYN if negative to avoid negative indexes in
1802              YYCHECK.  */
1803           for (yyx = yyn < 0 ? -yyn : 0;
1804                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1805             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1806               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1807           yysize += yystrlen ("syntax error, unexpected ") + 1;
1808           yysize += yystrlen (yytname[yytype]);
1809           yymsg = (char *) YYSTACK_ALLOC (yysize);
1810           if (yymsg != 0)
1811             {
1812               char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
1813               yyp = yystpcpy (yyp, yytname[yytype]);
1814
1815               if (yycount < 5)
1816                 {
1817                   yycount = 0;
1818                   for (yyx = yyn < 0 ? -yyn : 0;
1819                        yyx < (int) (sizeof (yytname) / sizeof (char *));
1820                        yyx++)
1821                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1822                       {
1823                         const char *yyq = ! yycount ? ", expecting " : " or ";
1824                         yyp = yystpcpy (yyp, yyq);
1825                         yyp = yystpcpy (yyp, yytname[yyx]);
1826                         yycount++;
1827                       }
1828                 }
1829               yyerror (yymsg);
1830               YYSTACK_FREE (yymsg);
1831             }
1832           else
1833             yyerror ("syntax error; also virtual memory exhausted");
1834         }
1835       else
1836 #endif /* YYERROR_VERBOSE */
1837         yyerror ("syntax error");
1838     }
1839
1840
1841
1842   if (yyerrstatus == 3)
1843     {
1844       /* If just tried and failed to reuse lookahead token after an
1845          error, discard it.  */
1846
1847       /* Return failure if at end of input.  */
1848       if (yychar == YYEOF)
1849         {
1850           /* Pop the error token.  */
1851           YYPOPSTACK;
1852           /* Pop the rest of the stack.  */
1853           while (yyss < yyssp)
1854             {
1855               YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1856               yydestruct (yystos[*yyssp], yyvsp);
1857               YYPOPSTACK;
1858             }
1859           YYABORT;
1860         }
1861
1862       YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
1863       yydestruct (yytoken, &yylval);
1864       yychar = YYEMPTY;
1865
1866     }
1867
1868   /* Else will try to reuse lookahead token after shifting the error
1869      token.  */
1870   goto yyerrlab1;
1871
1872
1873 /*----------------------------------------------------.
1874 | yyerrlab1 -- error raised explicitly by an action.  |
1875 `----------------------------------------------------*/
1876 yyerrlab1:
1877   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1878
1879   for (;;)
1880     {
1881       yyn = yypact[yystate];
1882       if (yyn != YYPACT_NINF)
1883         {
1884           yyn += YYTERROR;
1885           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1886             {
1887               yyn = yytable[yyn];
1888               if (0 < yyn)
1889                 break;
1890             }
1891         }
1892
1893       /* Pop the current state because it cannot handle the error token.  */
1894       if (yyssp == yyss)
1895         YYABORT;
1896
1897       YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1898       yydestruct (yystos[yystate], yyvsp);
1899       yyvsp--;
1900       yystate = *--yyssp;
1901
1902       YY_STACK_PRINT (yyss, yyssp);
1903     }
1904
1905   if (yyn == YYFINAL)
1906     YYACCEPT;
1907
1908   YYDPRINTF ((stderr, "Shifting error token, "));
1909
1910   *++yyvsp = yylval;
1911
1912
1913   yystate = yyn;
1914   goto yynewstate;
1915
1916
1917 /*-------------------------------------.
1918 | yyacceptlab -- YYACCEPT comes here.  |
1919 `-------------------------------------*/
1920 yyacceptlab:
1921   yyresult = 0;
1922   goto yyreturn;
1923
1924 /*-----------------------------------.
1925 | yyabortlab -- YYABORT comes here.  |
1926 `-----------------------------------*/
1927 yyabortlab:
1928   yyresult = 1;
1929   goto yyreturn;
1930
1931 #ifndef yyoverflow
1932 /*----------------------------------------------.
1933 | yyoverflowlab -- parser overflow comes here.  |
1934 `----------------------------------------------*/
1935 yyoverflowlab:
1936   yyerror ("parser stack overflow");
1937   yyresult = 2;
1938   /* Fall through.  */
1939 #endif
1940
1941 yyreturn:
1942 #ifndef yyoverflow
1943   if (yyss != yyssa)
1944     YYSTACK_FREE (yyss);
1945 #endif
1946   return yyresult;
1947 }
1948
1949
1950 #line 684 "src/cfgparser/oparse.y"
1951
1952
1953 void yyerror (char *string)
1954 {
1955   fprintf(stderr, "Config line %d: %s\n", current_line, string);
1956 }
1957
1958