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