c79e45f32ac173b46bfa213a75b5af2ec537bf1f
[olsrd.git] / 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