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