more simplifications in the bison sources,
[asterisk/asterisk.git] / pbx / ael / ael.tab.c
1 /* A Bison parser, made by GNU Bison 2.1.  */
2
3 /* Skeleton parser for Yacc-like parsing with Bison,
4    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 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., 51 Franklin Street, Fifth Floor,
19    Boston, MA 02110-1301, 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 /* Bison version.  */
40 #define YYBISON_VERSION "2.1"
41
42 /* Skeleton name.  */
43 #define YYSKELETON_NAME "yacc.c"
44
45 /* Pure parsers.  */
46 #define YYPURE 1
47
48 /* Using locations.  */
49 #define YYLSP_NEEDED 1
50
51 /* Substitute the variable and function names.  */
52 #define yyparse ael_yyparse
53 #define yylex   ael_yylex
54 #define yyerror ael_yyerror
55 #define yylval  ael_yylval
56 #define yychar  ael_yychar
57 #define yydebug ael_yydebug
58 #define yynerrs ael_yynerrs
59 #define yylloc ael_yylloc
60
61 /* Tokens.  */
62 #ifndef YYTOKENTYPE
63 # define YYTOKENTYPE
64    /* Put the tokens into the symbol table, so that GDB and other debuggers
65       know about them.  */
66    enum yytokentype {
67      KW_CONTEXT = 258,
68      LC = 259,
69      RC = 260,
70      LP = 261,
71      RP = 262,
72      SEMI = 263,
73      EQ = 264,
74      COMMA = 265,
75      COLON = 266,
76      AMPER = 267,
77      BAR = 268,
78      AT = 269,
79      KW_MACRO = 270,
80      KW_GLOBALS = 271,
81      KW_IGNOREPAT = 272,
82      KW_SWITCH = 273,
83      KW_IF = 274,
84      KW_IFTIME = 275,
85      KW_ELSE = 276,
86      KW_RANDOM = 277,
87      KW_ABSTRACT = 278,
88      EXTENMARK = 279,
89      KW_GOTO = 280,
90      KW_JUMP = 281,
91      KW_RETURN = 282,
92      KW_BREAK = 283,
93      KW_CONTINUE = 284,
94      KW_REGEXTEN = 285,
95      KW_HINT = 286,
96      KW_FOR = 287,
97      KW_WHILE = 288,
98      KW_CASE = 289,
99      KW_PATTERN = 290,
100      KW_DEFAULT = 291,
101      KW_CATCH = 292,
102      KW_SWITCHES = 293,
103      KW_ESWITCHES = 294,
104      KW_INCLUDES = 295,
105      word = 296
106    };
107 #endif
108 /* Tokens.  */
109 #define KW_CONTEXT 258
110 #define LC 259
111 #define RC 260
112 #define LP 261
113 #define RP 262
114 #define SEMI 263
115 #define EQ 264
116 #define COMMA 265
117 #define COLON 266
118 #define AMPER 267
119 #define BAR 268
120 #define AT 269
121 #define KW_MACRO 270
122 #define KW_GLOBALS 271
123 #define KW_IGNOREPAT 272
124 #define KW_SWITCH 273
125 #define KW_IF 274
126 #define KW_IFTIME 275
127 #define KW_ELSE 276
128 #define KW_RANDOM 277
129 #define KW_ABSTRACT 278
130 #define EXTENMARK 279
131 #define KW_GOTO 280
132 #define KW_JUMP 281
133 #define KW_RETURN 282
134 #define KW_BREAK 283
135 #define KW_CONTINUE 284
136 #define KW_REGEXTEN 285
137 #define KW_HINT 286
138 #define KW_FOR 287
139 #define KW_WHILE 288
140 #define KW_CASE 289
141 #define KW_PATTERN 290
142 #define KW_DEFAULT 291
143 #define KW_CATCH 292
144 #define KW_SWITCHES 293
145 #define KW_ESWITCHES 294
146 #define KW_INCLUDES 295
147 #define word 296
148
149
150
151
152 /* Copy the first part of user declarations.  */
153 #line 1 "ael.y"
154
155 /*
156  * Asterisk -- An open source telephony toolkit.
157  *
158  * Copyright (C) 2006, Digium, Inc.
159  *
160  * Steve Murphy <murf@parsetree.com>
161  *
162  * See http://www.asterisk.org for more information about
163  * the Asterisk project. Please do not directly contact
164  * any of the maintainers of this project for assistance;
165  * the project provides a web site, mailing lists and IRC
166  * channels for your use.
167  *
168  * This program is free software, distributed under the terms of
169  * the GNU General Public License Version 2. See the LICENSE file
170  * at the top of the source tree.
171  */
172 /*! \file
173  *
174  * \brief Bison Grammar description of AEL2.
175  *
176  */
177 #include <stdio.h>
178 #include <stdlib.h>
179 #include <string.h>
180 #include "asterisk/logger.h"
181 #include "asterisk/utils.h"             /* ast_calloc() */
182 #include "asterisk/ael_structs.h"
183
184 /* create a new object with start-end marker */
185 static pval *npval(pvaltype type, int first_line, int last_line,
186         int first_column, int last_column);
187
188 static pval * linku1(pval *head, pval *tail);
189
190 void reset_parencount(yyscan_t yyscanner);
191 void reset_semicount(yyscan_t yyscanner);
192 void reset_argcount(yyscan_t yyscanner );
193
194 #define YYLEX_PARAM ((struct parse_io *)parseio)->scanner
195 #define YYERROR_VERBOSE 1
196
197 extern char *my_file;
198 #ifdef AAL_ARGCHECK
199 int ael_is_funcname(char *name);
200 #endif
201 static char *ael_token_subst(char *mess);
202
203
204
205 /* Enabling traces.  */
206 #ifndef YYDEBUG
207 # define YYDEBUG 0
208 #endif
209
210 /* Enabling verbose error messages.  */
211 #ifdef YYERROR_VERBOSE
212 # undef YYERROR_VERBOSE
213 # define YYERROR_VERBOSE 1
214 #else
215 # define YYERROR_VERBOSE 1
216 #endif
217
218 /* Enabling the token table.  */
219 #ifndef YYTOKEN_TABLE
220 # define YYTOKEN_TABLE 0
221 #endif
222
223 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
224 #line 53 "ael.y"
225 typedef union YYSTYPE {
226         char *str;
227         struct pval *pval;
228 } YYSTYPE;
229 /* Line 196 of yacc.c.  */
230 #line 231 "ael.tab.c"
231 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
232 # define YYSTYPE_IS_DECLARED 1
233 # define YYSTYPE_IS_TRIVIAL 1
234 #endif
235
236 #if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
237 typedef struct YYLTYPE
238 {
239   int first_line;
240   int first_column;
241   int last_line;
242   int last_column;
243 } YYLTYPE;
244 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
245 # define YYLTYPE_IS_DECLARED 1
246 # define YYLTYPE_IS_TRIVIAL 1
247 #endif
248
249
250 /* Copy the second part of user declarations.  */
251 #line 58 "ael.y"
252
253         /* declaring these AFTER the union makes things a lot simpler! */
254 void yyerror(YYLTYPE *locp, struct parse_io *parseio, char const *s);
255 int ael_yylex (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , void * yyscanner);
256
257 /* create a new object with start-end marker, simplified interface.
258  * Must be declared here because YYLTYPE is not known before
259  */
260 static pval *npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last);
261
262
263 /* Line 219 of yacc.c.  */
264 #line 265 "ael.tab.c"
265
266 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
267 # define YYSIZE_T __SIZE_TYPE__
268 #endif
269 #if ! defined (YYSIZE_T) && defined (size_t)
270 # define YYSIZE_T size_t
271 #endif
272 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
273 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
274 # define YYSIZE_T size_t
275 #endif
276 #if ! defined (YYSIZE_T)
277 # define YYSIZE_T unsigned int
278 #endif
279
280 #ifndef YY_
281 # if YYENABLE_NLS
282 #  if ENABLE_NLS
283 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
284 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
285 #  endif
286 # endif
287 # ifndef YY_
288 #  define YY_(msgid) msgid
289 # endif
290 #endif
291
292 #if ! defined (yyoverflow) || YYERROR_VERBOSE
293
294 /* The parser invokes alloca or malloc; define the necessary symbols.  */
295
296 # ifdef YYSTACK_USE_ALLOCA
297 #  if YYSTACK_USE_ALLOCA
298 #   ifdef __GNUC__
299 #    define YYSTACK_ALLOC __builtin_alloca
300 #   else
301 #    define YYSTACK_ALLOC alloca
302 #    if defined (__STDC__) || defined (__cplusplus)
303 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
304 #     define YYINCLUDED_STDLIB_H
305 #    endif
306 #   endif
307 #  endif
308 # endif
309
310 # ifdef YYSTACK_ALLOC
311    /* Pacify GCC's `empty if-body' warning. */
312 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
313 #  ifndef YYSTACK_ALLOC_MAXIMUM
314     /* The OS might guarantee only one guard page at the bottom of the stack,
315        and a page size can be as small as 4096 bytes.  So we cannot safely
316        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
317        to allow for a few compiler-allocated temporary stack slots.  */
318 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
319 #  endif
320 # else
321 #  define YYSTACK_ALLOC YYMALLOC
322 #  define YYSTACK_FREE YYFREE
323 #  ifndef YYSTACK_ALLOC_MAXIMUM
324 #   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
325 #  endif
326 #  ifdef __cplusplus
327 extern "C" {
328 #  endif
329 #  ifndef YYMALLOC
330 #   define YYMALLOC malloc
331 #   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
332         && (defined (__STDC__) || defined (__cplusplus)))
333 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
334 #   endif
335 #  endif
336 #  ifndef YYFREE
337 #   define YYFREE free
338 #   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
339         && (defined (__STDC__) || defined (__cplusplus)))
340 void free (void *); /* INFRINGES ON USER NAME SPACE */
341 #   endif
342 #  endif
343 #  ifdef __cplusplus
344 }
345 #  endif
346 # endif
347 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
348
349
350 #if (! defined (yyoverflow) \
351      && (! defined (__cplusplus) \
352          || (defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
353              && defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
354
355 /* A type that is properly aligned for any stack member.  */
356 union yyalloc
357 {
358   short int yyss;
359   YYSTYPE yyvs;
360     YYLTYPE yyls;
361 };
362
363 /* The size of the maximum gap between one aligned stack and the next.  */
364 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
365
366 /* The size of an array large to enough to hold all stacks, each with
367    N elements.  */
368 # define YYSTACK_BYTES(N) \
369      ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE))  \
370       + 2 * YYSTACK_GAP_MAXIMUM)
371
372 /* Copy COUNT objects from FROM to TO.  The source and destination do
373    not overlap.  */
374 # ifndef YYCOPY
375 #  if defined (__GNUC__) && 1 < __GNUC__
376 #   define YYCOPY(To, From, Count) \
377       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
378 #  else
379 #   define YYCOPY(To, From, Count)              \
380       do                                        \
381         {                                       \
382           YYSIZE_T yyi;                         \
383           for (yyi = 0; yyi < (Count); yyi++)   \
384             (To)[yyi] = (From)[yyi];            \
385         }                                       \
386       while (0)
387 #  endif
388 # endif
389
390 /* Relocate STACK from its old location to the new one.  The
391    local variables YYSIZE and YYSTACKSIZE give the old and new number of
392    elements in the stack, and YYPTR gives the new location of the
393    stack.  Advance YYPTR to a properly aligned location for the next
394    stack.  */
395 # define YYSTACK_RELOCATE(Stack)                                        \
396     do                                                                  \
397       {                                                                 \
398         YYSIZE_T yynewbytes;                                            \
399         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
400         Stack = &yyptr->Stack;                                          \
401         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
402         yyptr += yynewbytes / sizeof (*yyptr);                          \
403       }                                                                 \
404     while (0)
405
406 #endif
407
408 #if defined (__STDC__) || defined (__cplusplus)
409    typedef signed char yysigned_char;
410 #else
411    typedef short int yysigned_char;
412 #endif
413
414 /* YYFINAL -- State number of the termination state. */
415 #define YYFINAL  18
416 /* YYLAST -- Last index in YYTABLE.  */
417 #define YYLAST   505
418
419 /* YYNTOKENS -- Number of terminals. */
420 #define YYNTOKENS  42
421 /* YYNNTS -- Number of nonterminals. */
422 #define YYNNTS  55
423 /* YYNRULES -- Number of rules. */
424 #define YYNRULES  149
425 /* YYNRULES -- Number of states. */
426 #define YYNSTATES  346
427
428 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
429 #define YYUNDEFTOK  2
430 #define YYMAXUTOK   296
431
432 #define YYTRANSLATE(YYX)                                                \
433   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
434
435 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
436 static const unsigned char yytranslate[] =
437 {
438        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
439        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
440        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
441        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
442        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
443        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
444        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
445        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
446        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
447        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
448        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
449        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
450        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
451        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
452        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
453        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
454        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
455        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
456        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
457        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
458        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
459        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
460        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
461        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
462        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
463        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
464        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
465       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
466       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
467       35,    36,    37,    38,    39,    40,    41
468 };
469
470 #if YYDEBUG
471 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
472    YYRHS.  */
473 static const unsigned short int yyprhs[] =
474 {
475        0,     0,     3,     5,     7,    10,    13,    15,    17,    19,
476       21,    23,    25,    31,    36,    43,    49,    58,    66,    74,
477       81,    86,    90,    92,    95,    98,    99,   105,   107,   111,
478      114,   116,   118,   121,   124,   126,   128,   130,   132,   134,
479      135,   141,   144,   146,   151,   155,   160,   168,   177,   179,
480      182,   185,   186,   192,   193,   199,   214,   225,   227,   230,
481      232,   235,   239,   241,   244,   248,   249,   256,   260,   261,
482      267,   271,   275,   278,   279,   280,   281,   294,   295,   302,
483      305,   309,   313,   316,   319,   320,   326,   329,   332,   335,
484      339,   343,   347,   349,   352,   353,   355,   359,   363,   369,
485      375,   381,   387,   389,   393,   399,   403,   409,   413,   414,
486      420,   424,   425,   429,   433,   436,   438,   439,   441,   442,
487      446,   448,   451,   456,   460,   465,   469,   472,   476,   478,
488      481,   483,   489,   494,   498,   503,   507,   510,   514,   517,
489      520,   535,   546,   550,   566,   578,   581,   583,   585,   590
490 };
491
492 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
493 static const yysigned_char yyrhs[] =
494 {
495       43,     0,    -1,    44,    -1,    45,    -1,    44,    45,    -1,
496       44,     1,    -1,    47,    -1,    48,    -1,    49,    -1,     8,
497       -1,    41,    -1,    36,    -1,     3,    46,     4,    54,     5,
498       -1,     3,    46,     4,     5,    -1,    23,     3,    46,     4,
499       54,     5,    -1,    23,     3,    46,     4,     5,    -1,    15,
500       41,     6,    53,     7,     4,    89,     5,    -1,    15,    41,
501        6,    53,     7,     4,     5,    -1,    15,    41,     6,     7,
502        4,    89,     5,    -1,    15,    41,     6,     7,     4,     5,
503       -1,    16,     4,    50,     5,    -1,    16,     4,     5,    -1,
504       51,    -1,    50,    51,    -1,    50,     1,    -1,    -1,    41,
505        9,    52,    41,     8,    -1,    41,    -1,    53,    10,    41,
506       -1,    53,     1,    -1,    55,    -1,     1,    -1,    54,    55,
507       -1,    54,     1,    -1,    58,    -1,    96,    -1,    91,    -1,
508       92,    -1,    57,    -1,    -1,    41,     9,    56,    41,     8,
509       -1,    41,     1,    -1,     8,    -1,    17,    24,    41,     8,
510       -1,    41,    24,    70,    -1,    30,    41,    24,    70,    -1,
511       31,     6,    66,     7,    41,    24,    70,    -1,    30,    31,
512        6,    66,     7,    41,    24,    70,    -1,    70,    -1,    59,
513       70,    -1,    59,     1,    -1,    -1,    19,     6,    61,    65,
514        7,    -1,    -1,    22,     6,    63,    65,     7,    -1,    20,
515        6,    66,    11,    66,    11,    66,    13,    66,    13,    66,
516       13,    66,     7,    -1,    20,     6,    41,    13,    66,    13,
517       66,    13,    66,     7,    -1,    41,    -1,    41,    41,    -1,
518       41,    -1,    41,    41,    -1,    41,    41,    41,    -1,    41,
519       -1,    41,    41,    -1,    41,    11,    41,    -1,    -1,    18,
520        6,    69,    41,     7,     4,    -1,     4,    59,     5,    -1,
521       -1,    41,     9,    71,    41,     8,    -1,    25,    78,     8,
522       -1,    26,    79,     8,    -1,    41,    11,    -1,    -1,    -1,
523       -1,    32,     6,    72,    41,     8,    73,    41,     8,    74,
524       41,     7,    70,    -1,    -1,    33,     6,    75,    41,     7,
525       70,    -1,    68,     5,    -1,    68,    87,     5,    -1,    12,
526       80,     8,    -1,    84,     8,    -1,    41,     8,    -1,    -1,
527       84,     9,    76,    41,     8,    -1,    28,     8,    -1,    27,
528        8,    -1,    29,     8,    -1,    62,    70,    77,    -1,    60,
529       70,    77,    -1,    64,    70,    77,    -1,     8,    -1,    21,
530       70,    -1,    -1,    67,    -1,    67,    13,    67,    -1,    67,
531       10,    67,    -1,    67,    13,    67,    13,    67,    -1,    67,
532       10,    67,    10,    67,    -1,    36,    13,    67,    13,    67,
533       -1,    36,    10,    67,    10,    67,    -1,    67,    -1,    67,
534       10,    67,    -1,    67,    10,    41,    14,    41,    -1,    67,
535       14,    67,    -1,    67,    10,    41,    14,    36,    -1,    67,
536       14,    36,    -1,    -1,    41,     6,    81,    86,     7,    -1,
537       41,     6,     7,    -1,    -1,    41,    83,     6,    -1,    82,
538       86,     7,    -1,    82,     7,    -1,    41,    -1,    -1,    65,
539       -1,    -1,    86,    10,    85,    -1,    88,    -1,    87,    88,
540       -1,    34,    41,    11,    59,    -1,    36,    11,    59,    -1,
541       35,    41,    11,    59,    -1,    34,    41,    11,    -1,    36,
542       11,    -1,    35,    41,    11,    -1,    90,    -1,    89,    90,
543       -1,    70,    -1,    37,    41,     4,    59,     5,    -1,    38,
544        4,    93,     5,    -1,    38,     4,     5,    -1,    39,     4,
545       93,     5,    -1,    39,     4,     5,    -1,    41,     8,    -1,
546       93,    41,     8,    -1,    93,     1,    -1,    95,     8,    -1,
547       95,    13,    66,    11,    66,    11,    66,    13,    66,    13,
548       66,    13,    66,     8,    -1,    95,    13,    41,    13,    66,
549       13,    66,    13,    66,     8,    -1,    94,    95,     8,    -1,
550       94,    95,    13,    66,    11,    66,    11,    66,    13,    66,
551       13,    66,    13,    66,     8,    -1,    94,    95,    13,    41,
552       13,    66,    13,    66,    13,    66,     8,    -1,    94,     1,
553       -1,    41,    -1,    36,    -1,    40,     4,    94,     5,    -1,
554       40,     4,     5,    -1
555 };
556
557 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
558 static const unsigned short int yyrline[] =
559 {
560        0,   165,   165,   168,   169,   180,   183,   184,   185,   186,
561      189,   190,   193,   197,   200,   205,   229,   232,   235,   239,
562      244,   247,   251,   252,   253,   256,   256,   262,   265,   269,
563      272,   273,   274,   277,   280,   281,   282,   283,   284,   285,
564      285,   289,   290,   293,   298,   302,   307,   312,   321,   322,
565      325,   328,   328,   333,   333,   338,   354,   374,   375,   382,
566      383,   388,   396,   397,   401,   407,   407,   415,   418,   418,
567      422,   425,   428,   431,   432,   433,   431,   439,   439,   443,
568      447,   452,   456,   460,   463,   463,   496,   497,   498,   499,
569      513,   527,   541,   544,   545,   550,   552,   557,   562,   569,
570      576,   583,   592,   597,   602,   609,   616,   623,   632,   632,
571      637,   642,   642,   652,   658,   661,   662,   665,   668,   671,
572      685,   686,   691,   695,   699,   703,   706,   709,   714,   715,
573      720,   721,   727,   730,   734,   737,   741,   744,   749,   752,
574      755,   772,   785,   790,   808,   823,   826,   827,   830,   833
575 };
576 #endif
577
578 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
579 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
580    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
581 static const char *const yytname[] =
582 {
583   "$end", "error", "$undefined", "KW_CONTEXT", "LC", "RC", "LP", "RP",
584   "SEMI", "EQ", "COMMA", "COLON", "AMPER", "BAR", "AT", "KW_MACRO",
585   "KW_GLOBALS", "KW_IGNOREPAT", "KW_SWITCH", "KW_IF", "KW_IFTIME",
586   "KW_ELSE", "KW_RANDOM", "KW_ABSTRACT", "EXTENMARK", "KW_GOTO", "KW_JUMP",
587   "KW_RETURN", "KW_BREAK", "KW_CONTINUE", "KW_REGEXTEN", "KW_HINT",
588   "KW_FOR", "KW_WHILE", "KW_CASE", "KW_PATTERN", "KW_DEFAULT", "KW_CATCH",
589   "KW_SWITCHES", "KW_ESWITCHES", "KW_INCLUDES", "word", "$accept", "file",
590   "objects", "object", "word_or_default", "context", "macro", "globals",
591   "global_statements", "global_statement", "@1", "arglist", "elements",
592   "element", "@2", "ignorepat", "extension", "statements", "if_head", "@3",
593   "random_head", "@4", "iftime_head", "word_list", "word3_list",
594   "goto_word", "switch_head", "@5", "statement", "@6", "@7", "@8", "@9",
595   "@10", "@11", "opt_else", "target", "jumptarget", "macro_call", "@12",
596   "application_call_head", "@13", "application_call", "opt_word",
597   "eval_arglist", "case_statements", "case_statement", "macro_statements",
598   "macro_statement", "switches", "eswitches", "switchlist", "includeslist",
599   "includedname", "includes", 0
600 };
601 #endif
602
603 # ifdef YYPRINT
604 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
605    token YYLEX-NUM.  */
606 static const unsigned short int yytoknum[] =
607 {
608        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
609      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
610      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
611      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
612      295,   296
613 };
614 # endif
615
616 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
617 static const unsigned char yyr1[] =
618 {
619        0,    42,    43,    44,    44,    44,    45,    45,    45,    45,
620       46,    46,    47,    47,    47,    47,    48,    48,    48,    48,
621       49,    49,    50,    50,    50,    52,    51,    53,    53,    53,
622       54,    54,    54,    54,    55,    55,    55,    55,    55,    56,
623       55,    55,    55,    57,    58,    58,    58,    58,    59,    59,
624       59,    61,    60,    63,    62,    64,    64,    65,    65,    66,
625       66,    66,    67,    67,    67,    69,    68,    70,    71,    70,
626       70,    70,    70,    72,    73,    74,    70,    75,    70,    70,
627       70,    70,    70,    70,    76,    70,    70,    70,    70,    70,
628       70,    70,    70,    77,    77,    78,    78,    78,    78,    78,
629       78,    78,    79,    79,    79,    79,    79,    79,    81,    80,
630       80,    83,    82,    84,    84,    85,    85,    86,    86,    86,
631       87,    87,    88,    88,    88,    88,    88,    88,    89,    89,
632       90,    90,    91,    91,    92,    92,    93,    93,    93,    94,
633       94,    94,    94,    94,    94,    94,    95,    95,    96,    96
634 };
635
636 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
637 static const unsigned char yyr2[] =
638 {
639        0,     2,     1,     1,     2,     2,     1,     1,     1,     1,
640        1,     1,     5,     4,     6,     5,     8,     7,     7,     6,
641        4,     3,     1,     2,     2,     0,     5,     1,     3,     2,
642        1,     1,     2,     2,     1,     1,     1,     1,     1,     0,
643        5,     2,     1,     4,     3,     4,     7,     8,     1,     2,
644        2,     0,     5,     0,     5,    14,    10,     1,     2,     1,
645        2,     3,     1,     2,     3,     0,     6,     3,     0,     5,
646        3,     3,     2,     0,     0,     0,    12,     0,     6,     2,
647        3,     3,     2,     2,     0,     5,     2,     2,     2,     3,
648        3,     3,     1,     2,     0,     1,     3,     3,     5,     5,
649        5,     5,     1,     3,     5,     3,     5,     3,     0,     5,
650        3,     0,     3,     3,     2,     1,     0,     1,     0,     3,
651        1,     2,     4,     3,     4,     3,     2,     3,     1,     2,
652        1,     5,     4,     3,     4,     3,     2,     3,     2,     2,
653       14,    10,     3,    15,    11,     2,     1,     1,     4,     3
654 };
655
656 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
657    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
658    means the default is an error.  */
659 static const unsigned char yydefact[] =
660 {
661        0,     0,     9,     0,     0,     0,     0,     0,     3,     6,
662        7,     8,    11,    10,     0,     0,     0,     0,     1,     5,
663        4,     0,     0,    21,     0,     0,    22,     0,    31,    13,
664       42,     0,     0,     0,     0,     0,     0,     0,     0,    30,
665       38,    34,    36,    37,    35,     0,    27,     0,    25,    24,
666       20,    23,     0,     0,     0,     0,     0,     0,     0,     0,
667       41,    39,     0,    33,    12,    32,     0,    29,     0,     0,
668        0,    15,     0,     0,     0,     0,    59,     0,   133,     0,
669        0,   135,     0,   149,   147,   146,     0,     0,     0,     0,
670       92,     0,     0,     0,     0,     0,     0,     0,     0,     0,
671        0,     0,     0,   111,     0,     0,     0,     0,    44,   118,
672        0,    19,     0,   130,     0,   128,     0,    28,     0,    14,
673       43,     0,    45,    60,     0,   136,   138,   132,     0,   134,
674      145,   148,     0,   139,     0,     0,     0,    48,     0,     0,
675       65,    51,     0,    53,     0,    62,    95,     0,   102,     0,
676       87,    86,    88,    73,    77,    83,    68,    72,     0,    94,
677       94,    94,    79,     0,     0,     0,     0,   120,   114,    57,
678      117,     0,    82,    84,     0,    18,   129,    17,     0,    26,
679        0,    61,     0,   137,   142,     0,    59,     0,    40,    50,
680       67,    49,   108,    81,     0,     0,    59,     0,     0,     0,
681        0,     0,    63,     0,     0,    70,     0,     0,    71,     0,
682        0,     0,   112,     0,    90,    89,    91,     0,     0,   126,
683       80,   121,    58,   113,   116,     0,     0,    16,     0,     0,
684       59,     0,     0,     0,   110,   118,     0,     0,     0,     0,
685        0,     0,     0,    64,    97,    96,    62,   103,   107,   105,
686        0,     0,     0,    93,   125,   127,     0,   115,   119,     0,
687        0,     0,    46,     0,     0,     0,     0,     0,     0,    52,
688        0,     0,    54,     0,     0,     0,     0,     0,    74,     0,
689       69,     0,     0,    85,   131,    47,     0,     0,     0,     0,
690      109,    66,     0,     0,   101,   100,    99,    98,   106,   104,
691        0,    78,     0,     0,     0,     0,     0,     0,     0,     0,
692        0,     0,     0,     0,     0,    75,     0,     0,     0,     0,
693        0,     0,     0,     0,     0,   141,     0,    56,     0,     0,
694      144,     0,     0,     0,     0,     0,     0,     0,    76,     0,
695        0,     0,     0,   140,    55,   143
696 };
697
698 /* YYDEFGOTO[NTERM-NUM]. */
699 static const short int yydefgoto[] =
700 {
701       -1,     6,     7,     8,    14,     9,    10,    11,    25,    26,
702       70,    47,    38,    39,    88,    40,    41,   136,   104,   195,
703      105,   198,   106,   170,    77,   146,   107,   194,   137,   211,
704      209,   300,   322,   210,   225,   214,   147,   149,   139,   235,
705      109,   158,   110,   258,   171,   166,   167,   114,   115,    42,
706       43,    80,    86,    87,    44
707 };
708
709 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
710    STATE-NUM.  */
711 #define YYPACT_NINF -193
712 static const short int yypact[] =
713 {
714      121,   117,  -193,   -38,    84,    17,    95,   343,  -193,  -193,
715     -193,  -193,  -193,  -193,    98,   122,     9,   117,  -193,  -193,
716     -193,   151,    53,  -193,   110,    14,  -193,   167,  -193,  -193,
717     -193,   102,    39,   182,   200,   214,   218,   184,   204,  -193,
718     -193,  -193,  -193,  -193,  -193,   219,  -193,   196,  -193,  -193,
719     -193,  -193,   280,   183,   221,   207,   187,    23,    44,    20,
720     -193,  -193,   461,  -193,  -193,  -193,   357,  -193,   228,   192,
721      195,  -193,   333,   229,   187,   461,   197,   234,  -193,   238,
722       16,  -193,    46,  -193,  -193,  -193,     5,   147,   206,   461,
723     -193,   211,   249,   250,   251,   252,   125,   220,   254,   256,
724      258,   253,   261,   104,   461,   461,   461,   129,  -193,    60,
725       50,  -193,   230,  -193,   383,  -193,   409,  -193,   262,  -193,
726     -193,   270,  -193,   239,   242,  -193,  -193,  -193,   276,  -193,
727     -193,  -193,   149,  -193,   246,   281,   274,  -193,   263,   282,
728     -193,  -193,   257,  -193,   173,     7,   201,   283,    63,   287,
729     -193,  -193,  -193,  -193,  -193,  -193,  -193,  -193,   298,   292,
730      292,   292,  -193,   273,   284,   306,   138,  -193,  -193,   286,
731     -193,   120,  -193,  -193,   324,  -193,  -193,  -193,   435,  -193,
732      294,  -193,   236,  -193,  -193,   299,    -6,   328,  -193,  -193,
733     -193,  -193,   335,  -193,   307,   308,    40,   336,   308,   220,
734      220,   311,  -193,   220,   220,  -193,   312,   166,  -193,   313,
735      314,   315,  -193,   461,  -193,  -193,  -193,   346,   349,   461,
736     -193,  -193,  -193,  -193,   326,   327,   461,  -193,   354,   461,
737       65,   359,   187,   187,  -193,   308,   373,   374,   187,   187,
738      385,   386,   380,  -193,   387,   391,   109,  -193,  -193,  -193,
739      392,   399,   410,  -193,   461,   461,     4,  -193,  -193,   411,
740      304,   461,  -193,   187,   187,   394,   388,   177,   418,  -193,
741      412,   415,  -193,   220,   220,   220,   220,   174,  -193,   461,
742     -193,    64,   113,  -193,  -193,  -193,   417,   421,   187,   187,
743     -193,  -193,   187,   187,  -193,  -193,  -193,  -193,  -193,  -193,
744      382,  -193,   187,   187,   420,   431,   432,   436,   440,   438,
745      439,   187,   187,   187,   187,  -193,   187,   187,   448,   445,
746      452,   453,   429,   463,   462,  -193,   187,  -193,   187,   467,
747     -193,   187,   464,   465,   461,   469,   187,   187,  -193,   187,
748      476,   478,   483,  -193,  -193,  -193
749 };
750
751 /* YYPGOTO[NTERM-NUM].  */
752 static const short int yypgoto[] =
753 {
754     -193,  -193,  -193,   485,   479,  -193,  -193,  -193,  -193,   470,
755     -193,  -193,   446,    37,  -193,  -193,  -193,  -192,  -193,  -193,
756     -193,  -193,  -193,    18,   -63,   -96,  -193,  -193,   -62,  -193,
757     -193,  -193,  -193,  -193,  -193,    35,  -193,  -193,  -193,  -193,
758     -193,  -193,  -193,  -193,   264,  -193,   331,   384,  -112,  -193,
759     -193,   443,  -193,   419,  -193
760 };
761
762 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
763    positive, shift that token.  If negative, reduce the rule which
764    number is the opposite.  If zero, do what YYDEFACT says.
765    If YYTABLE_NINF, syntax error.  */
766 #define YYTABLE_NINF -125
767 static const short int yytable[] =
768 {
769      108,   148,   176,    15,   113,   189,   130,   232,    89,  -123,
770      131,   121,    90,   122,    23,    49,    91,   126,   201,    50,
771       17,   127,    92,    93,    94,    83,    95,   256,    78,    96,
772       97,    98,    99,   100,   260,   123,   101,   102,  -123,  -123,
773     -123,    84,   159,   160,   161,   103,    85,   126,   202,    81,
774       24,   129,   113,   238,   113,    24,    84,   128,   172,   173,
775       45,    85,   281,   282,    79,   189,   176,   168,    89,  -122,
776       54,   187,    90,   206,   191,    65,    91,   207,   263,   197,
777       55,   123,    92,    93,    94,    79,    95,   128,    16,    96,
778       97,    98,    99,   100,    46,    18,   101,   102,  -122,  -122,
779     -122,   169,    21,   241,   242,   103,   123,   244,   245,    65,
780      247,   249,   155,   156,   189,   157,   113,    89,  -124,    48,
781      201,    90,   231,   277,     1,    91,    53,   223,    22,     2,
782      224,    92,    93,    94,   162,    95,     3,     4,    96,    97,
783       98,    99,   100,   220,     5,   101,   102,  -124,  -124,  -124,
784      202,   253,    28,    12,   103,   133,    29,   184,    13,    30,
785      134,   144,   185,   163,   164,   165,   145,   262,    31,   265,
786      266,    52,   163,   164,   165,   270,   271,   294,   295,   296,
787      297,    32,    33,   199,   290,    60,   200,   224,    56,    34,
788       35,    36,    37,    61,   191,   215,   216,    67,   191,   285,
789      286,   287,   248,    68,    57,    63,    69,   145,    62,    64,
790      298,   203,    30,   237,   204,   299,   240,   301,    58,   191,
791      191,    31,    59,    66,    73,   304,   305,    74,    76,   306,
792      307,    75,   116,   117,    32,    33,   118,   120,   123,   309,
793      310,   124,    34,    35,    36,    37,   125,   135,   318,   319,
794      320,   321,   138,   323,   324,   140,   141,   142,   143,   153,
795      229,   145,   150,   332,   151,   333,   152,   154,   335,   192,
796      179,   174,   338,   340,   341,   189,   342,   180,    89,   190,
797      181,    28,    90,   182,   183,    71,    91,   186,    30,   188,
798      193,   205,    92,    93,    94,   208,    95,    31,   196,    96,
799       97,    98,    99,   100,   212,   189,   101,   102,    89,   284,
800       32,    33,    90,   213,   217,   103,    91,   219,    34,    35,
801       36,    37,    92,    93,    94,   218,    95,   222,   226,    96,
802       97,    98,    99,   100,    63,   228,   101,   102,   119,   233,
803      230,    30,   234,    -2,    19,   103,     1,   239,   236,   169,
804       31,     2,   243,   246,   250,   251,   252,   254,     3,     4,
805      255,    89,   111,    32,    33,    90,     5,   257,   259,    91,
806      264,    34,    35,    36,    37,    92,    93,    94,   261,    95,
807      268,   269,    96,    97,    98,    99,   100,    89,   175,   101,
808      102,    90,   272,   274,   112,    91,   273,   275,   103,   289,
809      278,    92,    93,    94,   276,    95,   279,   288,    96,    97,
810       98,    99,   100,    89,   177,   101,   102,    90,   280,   283,
811      112,    91,   291,   308,   103,   292,   293,    92,    93,    94,
812      302,    95,   303,   311,    96,    97,    98,    99,   100,    89,
813      227,   101,   102,    90,   312,   313,   112,    91,   315,   314,
814      103,   316,   317,    92,    93,    94,   325,    95,   326,   327,
815       96,    97,    98,    99,   100,    89,   328,   101,   102,    90,
816      329,   330,   112,    91,   334,   331,   103,   336,   337,    92,
817       93,    94,   339,    95,   343,   344,    96,    97,    98,    99,
818      100,   345,    20,   101,   102,    51,    27,   221,    72,   267,
819      178,    82,   103,     0,     0,   132
820 };
821
822 static const short int yycheck[] =
823 {
824       62,    97,   114,    41,    66,     1,     1,    13,     4,     5,
825        5,    74,     8,    75,     5,     1,    12,     1,    11,     5,
826        3,     5,    18,    19,    20,     5,    22,   219,     5,    25,
827       26,    27,    28,    29,   226,    41,    32,    33,    34,    35,
828       36,    36,   104,   105,   106,    41,    41,     1,    41,     5,
829       41,     5,   114,    13,   116,    41,    36,    41,     8,     9,
830        7,    41,   254,   255,    41,     1,   178,     7,     4,     5,
831       31,   134,     8,    10,   136,    38,    12,    14,    13,   142,
832       41,    41,    18,    19,    20,    41,    22,    41,     4,    25,
833       26,    27,    28,    29,    41,     0,    32,    33,    34,    35,
834       36,    41,     4,   199,   200,    41,    41,   203,   204,    72,
835      206,   207,     8,     9,     1,    11,   178,     4,     5,     9,
836       11,     8,   185,    14,     3,    12,    24,     7,     6,     8,
837       10,    18,    19,    20,     5,    22,    15,    16,    25,    26,
838       27,    28,    29,     5,    23,    32,    33,    34,    35,    36,
839       41,   213,     1,    36,    41,     8,     5,     8,    41,     8,
840       13,    36,    13,    34,    35,    36,    41,   229,    17,   232,
841      233,     4,    34,    35,    36,   238,   239,   273,   274,   275,
842      276,    30,    31,    10,     7,     1,    13,    10,     6,    38,
843       39,    40,    41,     9,   256,   160,   161,     1,   260,   261,
844      263,   264,    36,     7,     4,     1,    10,    41,    24,     5,
845       36,    10,     8,   195,    13,    41,   198,   279,     4,   281,
846      282,    17,     4,     4,    41,   288,   289,     6,    41,   292,
847      293,    24,     4,    41,    30,    31,    41,     8,    41,   302,
848      303,     7,    38,    39,    40,    41,     8,    41,   311,   312,
849      313,   314,    41,   316,   317,     6,     6,     6,     6,     6,
850       24,    41,     8,   326,     8,   328,     8,     6,   331,     6,
851        8,    41,   334,   336,   337,     1,   339,     7,     4,     5,
852       41,     1,     8,    41,     8,     5,    12,    41,     8,     8,
853        8,     8,    18,    19,    20,     8,    22,    17,    41,    25,
854       26,    27,    28,    29,     6,     1,    32,    33,     4,     5,
855       30,    31,     8,    21,    41,    41,    12,    11,    38,    39,
856       40,    41,    18,    19,    20,    41,    22,    41,     4,    25,
857       26,    27,    28,    29,     1,    41,    32,    33,     5,    11,
858       41,     8,     7,     0,     1,    41,     3,    11,    41,    41,
859       17,     8,    41,    41,    41,    41,    41,    11,    15,    16,
860       11,     4,     5,    30,    31,     8,    23,    41,    41,    12,
861       11,    38,    39,    40,    41,    18,    19,    20,    24,    22,
862        7,     7,    25,    26,    27,    28,    29,     4,     5,    32,
863       33,     8,     7,    13,    37,    12,    10,    10,    41,    11,
864        8,    18,    19,    20,    13,    22,     7,    13,    25,    26,
865       27,    28,    29,     4,     5,    32,    33,     8,     8,     8,
866       37,    12,     4,    41,    41,    13,    11,    18,    19,    20,
867       13,    22,    11,    13,    25,    26,    27,    28,    29,     4,
868        5,    32,    33,     8,    13,    13,    37,    12,     8,    13,
869       41,    13,    13,    18,    19,    20,     8,    22,    13,     7,
870       25,    26,    27,    28,    29,     4,    13,    32,    33,     8,
871       41,     8,    37,    12,     7,    13,    41,    13,    13,    18,
872       19,    20,    13,    22,     8,     7,    25,    26,    27,    28,
873       29,     8,     7,    32,    33,    25,    17,   166,    52,   235,
874      116,    58,    41,    -1,    -1,    86
875 };
876
877 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
878    symbol of state STATE-NUM.  */
879 static const unsigned char yystos[] =
880 {
881        0,     3,     8,    15,    16,    23,    43,    44,    45,    47,
882       48,    49,    36,    41,    46,    41,     4,     3,     0,     1,
883       45,     4,     6,     5,    41,    50,    51,    46,     1,     5,
884        8,    17,    30,    31,    38,    39,    40,    41,    54,    55,
885       57,    58,    91,    92,    96,     7,    41,    53,     9,     1,
886        5,    51,     4,    24,    31,    41,     6,     4,     4,     4,
887        1,     9,    24,     1,     5,    55,     4,     1,     7,    10,
888       52,     5,    54,    41,     6,    24,    41,    66,     5,    41,
889       93,     5,    93,     5,    36,    41,    94,    95,    56,     4,
890        8,    12,    18,    19,    20,    22,    25,    26,    27,    28,
891       29,    32,    33,    41,    60,    62,    64,    68,    70,    82,
892       84,     5,    37,    70,    89,    90,     4,    41,    41,     5,
893        8,    66,    70,    41,     7,     8,     1,     5,    41,     5,
894        1,     5,    95,     8,    13,    41,    59,    70,    41,    80,
895        6,     6,     6,     6,    36,    41,    67,    78,    67,    79,
896        8,     8,     8,     6,     6,     8,     9,    11,    83,    70,
897       70,    70,     5,    34,    35,    36,    87,    88,     7,    41,
898       65,    86,     8,     9,    41,     5,    90,     5,    89,     8,
899        7,    41,    41,     8,     8,    13,    41,    66,     8,     1,
900        5,    70,     6,     8,    69,    61,    41,    66,    63,    10,
901       13,    11,    41,    10,    13,     8,    10,    14,     8,    72,
902       75,    71,     6,    21,    77,    77,    77,    41,    41,    11,
903        5,    88,    41,     7,    10,    76,     4,     5,    41,    24,
904       41,    66,    13,    11,     7,    81,    41,    65,    13,    11,
905       65,    67,    67,    41,    67,    67,    41,    67,    36,    67,
906       41,    41,    41,    70,    11,    11,    59,    41,    85,    41,
907       59,    24,    70,    13,    11,    66,    66,    86,     7,     7,
908       66,    66,     7,    10,    13,    10,    13,    14,     8,     7,
909        8,    59,    59,     8,     5,    70,    66,    66,    13,    11,
910        7,     4,    13,    11,    67,    67,    67,    67,    36,    41,
911       73,    70,    13,    11,    66,    66,    66,    66,    41,    66,
912       66,    13,    13,    13,    13,     8,    13,    13,    66,    66,
913       66,    66,    74,    66,    66,     8,    13,     7,    13,    41,
914        8,    13,    66,    66,     7,    66,    13,    13,    70,    13,
915       66,    66,    66,     8,     7,     8
916 };
917
918 #define yyerrok         (yyerrstatus = 0)
919 #define yyclearin       (yychar = YYEMPTY)
920 #define YYEMPTY         (-2)
921 #define YYEOF           0
922
923 #define YYACCEPT        goto yyacceptlab
924 #define YYABORT         goto yyabortlab
925 #define YYERROR         goto yyerrorlab
926
927
928 /* Like YYERROR except do call yyerror.  This remains here temporarily
929    to ease the transition to the new meaning of YYERROR, for GCC.
930    Once GCC version 2 has supplanted version 1, this can go.  */
931
932 #define YYFAIL          goto yyerrlab
933
934 #define YYRECOVERING()  (!!yyerrstatus)
935
936 #define YYBACKUP(Token, Value)                                  \
937 do                                                              \
938   if (yychar == YYEMPTY && yylen == 1)                          \
939     {                                                           \
940       yychar = (Token);                                         \
941       yylval = (Value);                                         \
942       yytoken = YYTRANSLATE (yychar);                           \
943       YYPOPSTACK;                                               \
944       goto yybackup;                                            \
945     }                                                           \
946   else                                                          \
947     {                                                           \
948       yyerror (&yylloc, parseio, YY_("syntax error: cannot back up")); \
949       YYERROR;                                                  \
950     }                                                           \
951 while (0)
952
953
954 #define YYTERROR        1
955 #define YYERRCODE       256
956
957
958 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
959    If N is 0, then set CURRENT to the empty location which ends
960    the previous symbol: RHS[0] (always defined).  */
961
962 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
963 #ifndef YYLLOC_DEFAULT
964 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
965     do                                                                  \
966       if (N)                                                            \
967         {                                                               \
968           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
969           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
970           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
971           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
972         }                                                               \
973       else                                                              \
974         {                                                               \
975           (Current).first_line   = (Current).last_line   =              \
976             YYRHSLOC (Rhs, 0).last_line;                                \
977           (Current).first_column = (Current).last_column =              \
978             YYRHSLOC (Rhs, 0).last_column;                              \
979         }                                                               \
980     while (0)
981 #endif
982
983
984 /* YY_LOCATION_PRINT -- Print the location on the stream.
985    This macro was not mandated originally: define only if we know
986    we won't break user code: when these are the locations we know.  */
987
988 #ifndef YY_LOCATION_PRINT
989 # if YYLTYPE_IS_TRIVIAL
990 #  define YY_LOCATION_PRINT(File, Loc)                  \
991      fprintf (File, "%d.%d-%d.%d",                      \
992               (Loc).first_line, (Loc).first_column,     \
993               (Loc).last_line,  (Loc).last_column)
994 # else
995 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
996 # endif
997 #endif
998
999
1000 /* YYLEX -- calling `yylex' with the right arguments.  */
1001
1002 #ifdef YYLEX_PARAM
1003 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
1004 #else
1005 # define YYLEX yylex (&yylval, &yylloc)
1006 #endif
1007
1008 /* Enable debugging if requested.  */
1009 #if YYDEBUG
1010
1011 # ifndef YYFPRINTF
1012 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1013 #  define YYFPRINTF fprintf
1014 # endif
1015
1016 # define YYDPRINTF(Args)                        \
1017 do {                                            \
1018   if (yydebug)                                  \
1019     YYFPRINTF Args;                             \
1020 } while (0)
1021
1022 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)          \
1023 do {                                                            \
1024   if (yydebug)                                                  \
1025     {                                                           \
1026       YYFPRINTF (stderr, "%s ", Title);                         \
1027       yysymprint (stderr,                                       \
1028                   Type, Value, Location);       \
1029       YYFPRINTF (stderr, "\n");                                 \
1030     }                                                           \
1031 } while (0)
1032
1033 /*------------------------------------------------------------------.
1034 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1035 | TOP (included).                                                   |
1036 `------------------------------------------------------------------*/
1037
1038 #if defined (__STDC__) || defined (__cplusplus)
1039 static void
1040 yy_stack_print (short int *bottom, short int *top)
1041 #else
1042 static void
1043 yy_stack_print (bottom, top)
1044     short int *bottom;
1045     short int *top;
1046 #endif
1047 {
1048   YYFPRINTF (stderr, "Stack now");
1049   for (/* Nothing. */; bottom <= top; ++bottom)
1050     YYFPRINTF (stderr, " %d", *bottom);
1051   YYFPRINTF (stderr, "\n");
1052 }
1053
1054 # define YY_STACK_PRINT(Bottom, Top)                            \
1055 do {                                                            \
1056   if (yydebug)                                                  \
1057     yy_stack_print ((Bottom), (Top));                           \
1058 } while (0)
1059
1060
1061 /*------------------------------------------------.
1062 | Report that the YYRULE is going to be reduced.  |
1063 `------------------------------------------------*/
1064
1065 #if defined (__STDC__) || defined (__cplusplus)
1066 static void
1067 yy_reduce_print (int yyrule)
1068 #else
1069 static void
1070 yy_reduce_print (yyrule)
1071     int yyrule;
1072 #endif
1073 {
1074   int yyi;
1075   unsigned long int yylno = yyrline[yyrule];
1076   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
1077              yyrule - 1, yylno);
1078   /* Print the symbols being reduced, and their result.  */
1079   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
1080     YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1081   YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
1082 }
1083
1084 # define YY_REDUCE_PRINT(Rule)          \
1085 do {                                    \
1086   if (yydebug)                          \
1087     yy_reduce_print (Rule);             \
1088 } while (0)
1089
1090 /* Nonzero means print parse trace.  It is left uninitialized so that
1091    multiple parsers can coexist.  */
1092 int yydebug;
1093 #else /* !YYDEBUG */
1094 # define YYDPRINTF(Args)
1095 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1096 # define YY_STACK_PRINT(Bottom, Top)
1097 # define YY_REDUCE_PRINT(Rule)
1098 #endif /* !YYDEBUG */
1099
1100
1101 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1102 #ifndef YYINITDEPTH
1103 # define YYINITDEPTH 200
1104 #endif
1105
1106 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1107    if the built-in stack extension method is used).
1108
1109    Do not make this value too large; the results are undefined if
1110    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1111    evaluated with infinite-precision integer arithmetic.  */
1112
1113 #ifndef YYMAXDEPTH
1114 # define YYMAXDEPTH 10000
1115 #endif
1116
1117 \f
1118
1119 #if YYERROR_VERBOSE
1120
1121 # ifndef yystrlen
1122 #  if defined (__GLIBC__) && defined (_STRING_H)
1123 #   define yystrlen strlen
1124 #  else
1125 /* Return the length of YYSTR.  */
1126 static YYSIZE_T
1127 #   if defined (__STDC__) || defined (__cplusplus)
1128 yystrlen (const char *yystr)
1129 #   else
1130 yystrlen (yystr)
1131      const char *yystr;
1132 #   endif
1133 {
1134   const char *yys = yystr;
1135
1136   while (*yys++ != '\0')
1137     continue;
1138
1139   return yys - yystr - 1;
1140 }
1141 #  endif
1142 # endif
1143
1144 # ifndef yystpcpy
1145 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1146 #   define yystpcpy stpcpy
1147 #  else
1148 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1149    YYDEST.  */
1150 static char *
1151 #   if defined (__STDC__) || defined (__cplusplus)
1152 yystpcpy (char *yydest, const char *yysrc)
1153 #   else
1154 yystpcpy (yydest, yysrc)
1155      char *yydest;
1156      const char *yysrc;
1157 #   endif
1158 {
1159   char *yyd = yydest;
1160   const char *yys = yysrc;
1161
1162   while ((*yyd++ = *yys++) != '\0')
1163     continue;
1164
1165   return yyd - 1;
1166 }
1167 #  endif
1168 # endif
1169
1170 # ifndef yytnamerr
1171 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1172    quotes and backslashes, so that it's suitable for yyerror.  The
1173    heuristic is that double-quoting is unnecessary unless the string
1174    contains an apostrophe, a comma, or backslash (other than
1175    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1176    null, do not copy; instead, return the length of what the result
1177    would have been.  */
1178 static YYSIZE_T
1179 yytnamerr (char *yyres, const char *yystr)
1180 {
1181   if (*yystr == '"')
1182     {
1183       size_t yyn = 0;
1184       char const *yyp = yystr;
1185
1186       for (;;)
1187         switch (*++yyp)
1188           {
1189           case '\'':
1190           case ',':
1191             goto do_not_strip_quotes;
1192
1193           case '\\':
1194             if (*++yyp != '\\')
1195               goto do_not_strip_quotes;
1196             /* Fall through.  */
1197           default:
1198             if (yyres)
1199               yyres[yyn] = *yyp;
1200             yyn++;
1201             break;
1202
1203           case '"':
1204             if (yyres)
1205               yyres[yyn] = '\0';
1206             return yyn;
1207           }
1208     do_not_strip_quotes: ;
1209     }
1210
1211   if (! yyres)
1212     return yystrlen (yystr);
1213
1214   return yystpcpy (yyres, yystr) - yyres;
1215 }
1216 # endif
1217
1218 #endif /* YYERROR_VERBOSE */
1219
1220 \f
1221
1222 #if YYDEBUG
1223 /*--------------------------------.
1224 | Print this symbol on YYOUTPUT.  |
1225 `--------------------------------*/
1226
1227 #if defined (__STDC__) || defined (__cplusplus)
1228 static void
1229 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1230 #else
1231 static void
1232 yysymprint (yyoutput, yytype, yyvaluep, yylocationp)
1233     FILE *yyoutput;
1234     int yytype;
1235     YYSTYPE *yyvaluep;
1236     YYLTYPE *yylocationp;
1237 #endif
1238 {
1239   /* Pacify ``unused variable'' warnings.  */
1240   (void) yyvaluep;
1241   (void) yylocationp;
1242
1243   if (yytype < YYNTOKENS)
1244     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1245   else
1246     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1247
1248   YY_LOCATION_PRINT (yyoutput, *yylocationp);
1249   YYFPRINTF (yyoutput, ": ");
1250
1251 # ifdef YYPRINT
1252   if (yytype < YYNTOKENS)
1253     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1254 # endif
1255   switch (yytype)
1256     {
1257       default:
1258         break;
1259     }
1260   YYFPRINTF (yyoutput, ")");
1261 }
1262
1263 #endif /* ! YYDEBUG */
1264 /*-----------------------------------------------.
1265 | Release the memory associated to this symbol.  |
1266 `-----------------------------------------------*/
1267
1268 #if defined (__STDC__) || defined (__cplusplus)
1269 static void
1270 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1271 #else
1272 static void
1273 yydestruct (yymsg, yytype, yyvaluep, yylocationp)
1274     const char *yymsg;
1275     int yytype;
1276     YYSTYPE *yyvaluep;
1277     YYLTYPE *yylocationp;
1278 #endif
1279 {
1280   /* Pacify ``unused variable'' warnings.  */
1281   (void) yyvaluep;
1282   (void) yylocationp;
1283
1284   if (!yymsg)
1285     yymsg = "Deleting";
1286   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1287
1288   switch (yytype)
1289     {
1290       case 41: /* "word" */
1291 #line 160 "ael.y"
1292         { free((yyvaluep->str));};
1293 #line 1294 "ael.tab.c"
1294         break;
1295       case 44: /* "objects" */
1296 #line 148 "ael.y"
1297         {
1298                 destroy_pval((yyvaluep->pval));
1299                 prev_word=0;
1300         };
1301 #line 1302 "ael.tab.c"
1302         break;
1303       case 45: /* "object" */
1304 #line 148 "ael.y"
1305         {
1306                 destroy_pval((yyvaluep->pval));
1307                 prev_word=0;
1308         };
1309 #line 1310 "ael.tab.c"
1310         break;
1311       case 46: /* "word_or_default" */
1312 #line 160 "ael.y"
1313         { free((yyvaluep->str));};
1314 #line 1315 "ael.tab.c"
1315         break;
1316       case 47: /* "context" */
1317 #line 148 "ael.y"
1318         {
1319                 destroy_pval((yyvaluep->pval));
1320                 prev_word=0;
1321         };
1322 #line 1323 "ael.tab.c"
1323         break;
1324       case 48: /* "macro" */
1325 #line 148 "ael.y"
1326         {
1327                 destroy_pval((yyvaluep->pval));
1328                 prev_word=0;
1329         };
1330 #line 1331 "ael.tab.c"
1331         break;
1332       case 49: /* "globals" */
1333 #line 148 "ael.y"
1334         {
1335                 destroy_pval((yyvaluep->pval));
1336                 prev_word=0;
1337         };
1338 #line 1339 "ael.tab.c"
1339         break;
1340       case 50: /* "global_statements" */
1341 #line 148 "ael.y"
1342         {
1343                 destroy_pval((yyvaluep->pval));
1344                 prev_word=0;
1345         };
1346 #line 1347 "ael.tab.c"
1347         break;
1348       case 51: /* "global_statement" */
1349 #line 148 "ael.y"
1350         {
1351                 destroy_pval((yyvaluep->pval));
1352                 prev_word=0;
1353         };
1354 #line 1355 "ael.tab.c"
1355         break;
1356       case 53: /* "arglist" */
1357 #line 148 "ael.y"
1358         {
1359                 destroy_pval((yyvaluep->pval));
1360                 prev_word=0;
1361         };
1362 #line 1363 "ael.tab.c"
1363         break;
1364       case 54: /* "elements" */
1365 #line 148 "ael.y"
1366         {
1367                 destroy_pval((yyvaluep->pval));
1368                 prev_word=0;
1369         };
1370 #line 1371 "ael.tab.c"
1371         break;
1372       case 55: /* "element" */
1373 #line 148 "ael.y"
1374         {
1375                 destroy_pval((yyvaluep->pval));
1376                 prev_word=0;
1377         };
1378 #line 1379 "ael.tab.c"
1379         break;
1380       case 57: /* "ignorepat" */
1381 #line 148 "ael.y"
1382         {
1383                 destroy_pval((yyvaluep->pval));
1384                 prev_word=0;
1385         };
1386 #line 1387 "ael.tab.c"
1387         break;
1388       case 58: /* "extension" */
1389 #line 148 "ael.y"
1390         {
1391                 destroy_pval((yyvaluep->pval));
1392                 prev_word=0;
1393         };
1394 #line 1395 "ael.tab.c"
1395         break;
1396       case 59: /* "statements" */
1397 #line 148 "ael.y"
1398         {
1399                 destroy_pval((yyvaluep->pval));
1400                 prev_word=0;
1401         };
1402 #line 1403 "ael.tab.c"
1403         break;
1404       case 60: /* "if_head" */
1405 #line 148 "ael.y"
1406         {
1407                 destroy_pval((yyvaluep->pval));
1408                 prev_word=0;
1409         };
1410 #line 1411 "ael.tab.c"
1411         break;
1412       case 62: /* "random_head" */
1413 #line 148 "ael.y"
1414         {
1415                 destroy_pval((yyvaluep->pval));
1416                 prev_word=0;
1417         };
1418 #line 1419 "ael.tab.c"
1419         break;
1420       case 64: /* "iftime_head" */
1421 #line 148 "ael.y"
1422         {
1423                 destroy_pval((yyvaluep->pval));
1424                 prev_word=0;
1425         };
1426 #line 1427 "ael.tab.c"
1427         break;
1428       case 65: /* "word_list" */
1429 #line 160 "ael.y"
1430         { free((yyvaluep->str));};
1431 #line 1432 "ael.tab.c"
1432         break;
1433       case 66: /* "word3_list" */
1434 #line 160 "ael.y"
1435         { free((yyvaluep->str));};
1436 #line 1437 "ael.tab.c"
1437         break;
1438       case 67: /* "goto_word" */
1439 #line 160 "ael.y"
1440         { free((yyvaluep->str));};
1441 #line 1442 "ael.tab.c"
1442         break;
1443       case 68: /* "switch_head" */
1444 #line 148 "ael.y"
1445         {
1446                 destroy_pval((yyvaluep->pval));
1447                 prev_word=0;
1448         };
1449 #line 1450 "ael.tab.c"
1450         break;
1451       case 70: /* "statement" */
1452 #line 148 "ael.y"
1453         {
1454                 destroy_pval((yyvaluep->pval));
1455                 prev_word=0;
1456         };
1457 #line 1458 "ael.tab.c"
1458         break;
1459       case 77: /* "opt_else" */
1460 #line 148 "ael.y"
1461         {
1462                 destroy_pval((yyvaluep->pval));
1463                 prev_word=0;
1464         };
1465 #line 1466 "ael.tab.c"
1466         break;
1467       case 78: /* "target" */
1468 #line 148 "ael.y"
1469         {
1470                 destroy_pval((yyvaluep->pval));
1471                 prev_word=0;
1472         };
1473 #line 1474 "ael.tab.c"
1474         break;
1475       case 79: /* "jumptarget" */
1476 #line 148 "ael.y"
1477         {
1478                 destroy_pval((yyvaluep->pval));
1479                 prev_word=0;
1480         };
1481 #line 1482 "ael.tab.c"
1482         break;
1483       case 80: /* "macro_call" */
1484 #line 148 "ael.y"
1485         {
1486                 destroy_pval((yyvaluep->pval));
1487                 prev_word=0;
1488         };
1489 #line 1490 "ael.tab.c"
1490         break;
1491       case 82: /* "application_call_head" */
1492 #line 148 "ael.y"
1493         {
1494                 destroy_pval((yyvaluep->pval));
1495                 prev_word=0;
1496         };
1497 #line 1498 "ael.tab.c"
1498         break;
1499       case 84: /* "application_call" */
1500 #line 148 "ael.y"
1501         {
1502                 destroy_pval((yyvaluep->pval));
1503                 prev_word=0;
1504         };
1505 #line 1506 "ael.tab.c"
1506         break;
1507       case 85: /* "opt_word" */
1508 #line 160 "ael.y"
1509         { free((yyvaluep->str));};
1510 #line 1511 "ael.tab.c"
1511         break;
1512       case 86: /* "eval_arglist" */
1513 #line 148 "ael.y"
1514         {
1515                 destroy_pval((yyvaluep->pval));
1516                 prev_word=0;
1517         };
1518 #line 1519 "ael.tab.c"
1519         break;
1520       case 87: /* "case_statements" */
1521 #line 148 "ael.y"
1522         {
1523                 destroy_pval((yyvaluep->pval));
1524                 prev_word=0;
1525         };
1526 #line 1527 "ael.tab.c"
1527         break;
1528       case 88: /* "case_statement" */
1529 #line 148 "ael.y"
1530         {
1531                 destroy_pval((yyvaluep->pval));
1532                 prev_word=0;
1533         };
1534 #line 1535 "ael.tab.c"
1535         break;
1536       case 89: /* "macro_statements" */
1537 #line 148 "ael.y"
1538         {
1539                 destroy_pval((yyvaluep->pval));
1540                 prev_word=0;
1541         };
1542 #line 1543 "ael.tab.c"
1543         break;
1544       case 90: /* "macro_statement" */
1545 #line 148 "ael.y"
1546         {
1547                 destroy_pval((yyvaluep->pval));
1548                 prev_word=0;
1549         };
1550 #line 1551 "ael.tab.c"
1551         break;
1552       case 91: /* "switches" */
1553 #line 148 "ael.y"
1554         {
1555                 destroy_pval((yyvaluep->pval));
1556                 prev_word=0;
1557         };
1558 #line 1559 "ael.tab.c"
1559         break;
1560       case 92: /* "eswitches" */
1561 #line 148 "ael.y"
1562         {
1563                 destroy_pval((yyvaluep->pval));
1564                 prev_word=0;
1565         };
1566 #line 1567 "ael.tab.c"
1567         break;
1568       case 93: /* "switchlist" */
1569 #line 148 "ael.y"
1570         {
1571                 destroy_pval((yyvaluep->pval));
1572                 prev_word=0;
1573         };
1574 #line 1575 "ael.tab.c"
1575         break;
1576       case 94: /* "includeslist" */
1577 #line 148 "ael.y"
1578         {
1579                 destroy_pval((yyvaluep->pval));
1580                 prev_word=0;
1581         };
1582 #line 1583 "ael.tab.c"
1583         break;
1584       case 95: /* "includedname" */
1585 #line 160 "ael.y"
1586         { free((yyvaluep->str));};
1587 #line 1588 "ael.tab.c"
1588         break;
1589       case 96: /* "includes" */
1590 #line 148 "ael.y"
1591         {
1592                 destroy_pval((yyvaluep->pval));
1593                 prev_word=0;
1594         };
1595 #line 1596 "ael.tab.c"
1596         break;
1597
1598       default:
1599         break;
1600     }
1601 }
1602 \f
1603
1604 /* Prevent warnings from -Wmissing-prototypes.  */
1605
1606 #ifdef YYPARSE_PARAM
1607 # if defined (__STDC__) || defined (__cplusplus)
1608 int yyparse (void *YYPARSE_PARAM);
1609 # else
1610 int yyparse ();
1611 # endif
1612 #else /* ! YYPARSE_PARAM */
1613 #if defined (__STDC__) || defined (__cplusplus)
1614 int yyparse (struct parse_io *parseio);
1615 #else
1616 int yyparse ();
1617 #endif
1618 #endif /* ! YYPARSE_PARAM */
1619
1620
1621
1622
1623
1624
1625 /*----------.
1626 | yyparse.  |
1627 `----------*/
1628
1629 #ifdef YYPARSE_PARAM
1630 # if defined (__STDC__) || defined (__cplusplus)
1631 int yyparse (void *YYPARSE_PARAM)
1632 # else
1633 int yyparse (YYPARSE_PARAM)
1634   void *YYPARSE_PARAM;
1635 # endif
1636 #else /* ! YYPARSE_PARAM */
1637 #if defined (__STDC__) || defined (__cplusplus)
1638 int
1639 yyparse (struct parse_io *parseio)
1640 #else
1641 int
1642 yyparse (parseio)
1643     struct parse_io *parseio;
1644 #endif
1645 #endif
1646 {
1647   /* The look-ahead symbol.  */
1648 int yychar;
1649
1650 /* The semantic value of the look-ahead symbol.  */
1651 YYSTYPE yylval;
1652
1653 /* Number of syntax errors so far.  */
1654 int yynerrs;
1655 /* Location data for the look-ahead symbol.  */
1656 YYLTYPE yylloc;
1657
1658   int yystate;
1659   int yyn;
1660   int yyresult;
1661   /* Number of tokens to shift before error messages enabled.  */
1662   int yyerrstatus;
1663   /* Look-ahead token as an internal (translated) token number.  */
1664   int yytoken = 0;
1665
1666   /* Three stacks and their tools:
1667      `yyss': related to states,
1668      `yyvs': related to semantic values,
1669      `yyls': related to locations.
1670
1671      Refer to the stacks thru separate pointers, to allow yyoverflow
1672      to reallocate them elsewhere.  */
1673
1674   /* The state stack.  */
1675   short int yyssa[YYINITDEPTH];
1676   short int *yyss = yyssa;
1677   short int *yyssp;
1678
1679   /* The semantic value stack.  */
1680   YYSTYPE yyvsa[YYINITDEPTH];
1681   YYSTYPE *yyvs = yyvsa;
1682   YYSTYPE *yyvsp;
1683
1684   /* The location stack.  */
1685   YYLTYPE yylsa[YYINITDEPTH];
1686   YYLTYPE *yyls = yylsa;
1687   YYLTYPE *yylsp;
1688   /* The locations where the error started and ended. */
1689   YYLTYPE yyerror_range[2];
1690
1691 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
1692
1693   YYSIZE_T yystacksize = YYINITDEPTH;
1694
1695   /* The variables used to return semantic value and location from the
1696      action routines.  */
1697   YYSTYPE yyval;
1698   YYLTYPE yyloc;
1699
1700   /* When reducing, the number of symbols on the RHS of the reduced
1701      rule.  */
1702   int yylen;
1703
1704   YYDPRINTF ((stderr, "Starting parse\n"));
1705
1706   yystate = 0;
1707   yyerrstatus = 0;
1708   yynerrs = 0;
1709   yychar = YYEMPTY;             /* Cause a token to be read.  */
1710
1711   /* Initialize stack pointers.
1712      Waste one element of value and location stack
1713      so that they stay on the same level as the state stack.
1714      The wasted elements are never initialized.  */
1715
1716   yyssp = yyss;
1717   yyvsp = yyvs;
1718   yylsp = yyls;
1719 #if YYLTYPE_IS_TRIVIAL
1720   /* Initialize the default location before parsing starts.  */
1721   yylloc.first_line   = yylloc.last_line   = 1;
1722   yylloc.first_column = yylloc.last_column = 0;
1723 #endif
1724
1725   goto yysetstate;
1726
1727 /*------------------------------------------------------------.
1728 | yynewstate -- Push a new state, which is found in yystate.  |
1729 `------------------------------------------------------------*/
1730  yynewstate:
1731   /* In all cases, when you get here, the value and location stacks
1732      have just been pushed. so pushing a state here evens the stacks.
1733      */
1734   yyssp++;
1735
1736  yysetstate:
1737   *yyssp = yystate;
1738
1739   if (yyss + yystacksize - 1 <= yyssp)
1740     {
1741       /* Get the current used size of the three stacks, in elements.  */
1742       YYSIZE_T yysize = yyssp - yyss + 1;
1743
1744 #ifdef yyoverflow
1745       {
1746         /* Give user a chance to reallocate the stack. Use copies of
1747            these so that the &'s don't force the real ones into
1748            memory.  */
1749         YYSTYPE *yyvs1 = yyvs;
1750         short int *yyss1 = yyss;
1751         YYLTYPE *yyls1 = yyls;
1752
1753         /* Each stack pointer address is followed by the size of the
1754            data in use in that stack, in bytes.  This used to be a
1755            conditional around just the two extra args, but that might
1756            be undefined if yyoverflow is a macro.  */
1757         yyoverflow (YY_("memory exhausted"),
1758                     &yyss1, yysize * sizeof (*yyssp),
1759                     &yyvs1, yysize * sizeof (*yyvsp),
1760                     &yyls1, yysize * sizeof (*yylsp),
1761                     &yystacksize);
1762         yyls = yyls1;
1763         yyss = yyss1;
1764         yyvs = yyvs1;
1765       }
1766 #else /* no yyoverflow */
1767 # ifndef YYSTACK_RELOCATE
1768       goto yyexhaustedlab;
1769 # else
1770       /* Extend the stack our own way.  */
1771       if (YYMAXDEPTH <= yystacksize)
1772         goto yyexhaustedlab;
1773       yystacksize *= 2;
1774       if (YYMAXDEPTH < yystacksize)
1775         yystacksize = YYMAXDEPTH;
1776
1777       {
1778         short int *yyss1 = yyss;
1779         union yyalloc *yyptr =
1780           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1781         if (! yyptr)
1782           goto yyexhaustedlab;
1783         YYSTACK_RELOCATE (yyss);
1784         YYSTACK_RELOCATE (yyvs);
1785         YYSTACK_RELOCATE (yyls);
1786 #  undef YYSTACK_RELOCATE
1787         if (yyss1 != yyssa)
1788           YYSTACK_FREE (yyss1);
1789       }
1790 # endif
1791 #endif /* no yyoverflow */
1792
1793       yyssp = yyss + yysize - 1;
1794       yyvsp = yyvs + yysize - 1;
1795       yylsp = yyls + yysize - 1;
1796
1797       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1798                   (unsigned long int) yystacksize));
1799
1800       if (yyss + yystacksize - 1 <= yyssp)
1801         YYABORT;
1802     }
1803
1804   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1805
1806   goto yybackup;
1807
1808 /*-----------.
1809 | yybackup.  |
1810 `-----------*/
1811 yybackup:
1812
1813 /* Do appropriate processing given the current state.  */
1814 /* Read a look-ahead token if we need one and don't already have one.  */
1815 /* yyresume: */
1816
1817   /* First try to decide what to do without reference to look-ahead token.  */
1818
1819   yyn = yypact[yystate];
1820   if (yyn == YYPACT_NINF)
1821     goto yydefault;
1822
1823   /* Not known => get a look-ahead token if don't already have one.  */
1824
1825   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1826   if (yychar == YYEMPTY)
1827     {
1828       YYDPRINTF ((stderr, "Reading a token: "));
1829       yychar = YYLEX;
1830     }
1831
1832   if (yychar <= YYEOF)
1833     {
1834       yychar = yytoken = YYEOF;
1835       YYDPRINTF ((stderr, "Now at end of input.\n"));
1836     }
1837   else
1838     {
1839       yytoken = YYTRANSLATE (yychar);
1840       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1841     }
1842
1843   /* If the proper action on seeing token YYTOKEN is to reduce or to
1844      detect an error, take that action.  */
1845   yyn += yytoken;
1846   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1847     goto yydefault;
1848   yyn = yytable[yyn];
1849   if (yyn <= 0)
1850     {
1851       if (yyn == 0 || yyn == YYTABLE_NINF)
1852         goto yyerrlab;
1853       yyn = -yyn;
1854       goto yyreduce;
1855     }
1856
1857   if (yyn == YYFINAL)
1858     YYACCEPT;
1859
1860   /* Shift the look-ahead token.  */
1861   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1862
1863   /* Discard the token being shifted unless it is eof.  */
1864   if (yychar != YYEOF)
1865     yychar = YYEMPTY;
1866
1867   *++yyvsp = yylval;
1868   *++yylsp = yylloc;
1869
1870   /* Count tokens shifted since error; after three, turn off error
1871      status.  */
1872   if (yyerrstatus)
1873     yyerrstatus--;
1874
1875   yystate = yyn;
1876   goto yynewstate;
1877
1878
1879 /*-----------------------------------------------------------.
1880 | yydefault -- do the default action for the current state.  |
1881 `-----------------------------------------------------------*/
1882 yydefault:
1883   yyn = yydefact[yystate];
1884   if (yyn == 0)
1885     goto yyerrlab;
1886   goto yyreduce;
1887
1888
1889 /*-----------------------------.
1890 | yyreduce -- Do a reduction.  |
1891 `-----------------------------*/
1892 yyreduce:
1893   /* yyn is the number of a rule to reduce with.  */
1894   yylen = yyr2[yyn];
1895
1896   /* If YYLEN is nonzero, implement the default value of the action:
1897      `$$ = $1'.
1898
1899      Otherwise, the following line sets YYVAL to garbage.
1900      This behavior is undocumented and Bison
1901      users should not rely upon it.  Assigning to YYVAL
1902      unconditionally makes the parser a bit smaller, and it avoids a
1903      GCC warning that YYVAL may be used uninitialized.  */
1904   yyval = yyvsp[1-yylen];
1905
1906   /* Default location. */
1907   YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);
1908   YY_REDUCE_PRINT (yyn);
1909   switch (yyn)
1910     {
1911         case 2:
1912 #line 165 "ael.y"
1913     { (yyval.pval) = parseio->pval = (yyvsp[0].pval); ;}
1914     break;
1915
1916   case 3:
1917 #line 168 "ael.y"
1918     {(yyval.pval)=(yyvsp[0].pval);;}
1919     break;
1920
1921   case 4:
1922 #line 170 "ael.y"
1923     {
1924                         if ( (yyvsp[-1].pval) && (yyvsp[0].pval) ) {
1925                                 (yyval.pval)=(yyvsp[-1].pval);
1926                                 linku1((yyval.pval),(yyvsp[0].pval));
1927                         } else if ( (yyvsp[-1].pval) ) {
1928                                 (yyval.pval)=(yyvsp[-1].pval);
1929                         } else if ( (yyvsp[0].pval) ) {
1930                                 (yyval.pval)=(yyvsp[0].pval);
1931                         }
1932                 ;}
1933     break;
1934
1935   case 5:
1936 #line 180 "ael.y"
1937     {(yyval.pval)=(yyvsp[-1].pval);;}
1938     break;
1939
1940   case 6:
1941 #line 183 "ael.y"
1942     {(yyval.pval)=(yyvsp[0].pval);;}
1943     break;
1944
1945   case 7:
1946 #line 184 "ael.y"
1947     {(yyval.pval)=(yyvsp[0].pval);;}
1948     break;
1949
1950   case 8:
1951 #line 185 "ael.y"
1952     {(yyval.pval)=(yyvsp[0].pval);;}
1953     break;
1954
1955   case 9:
1956 #line 186 "ael.y"
1957     {(yyval.pval)=0;/* allow older docs to be read */;}
1958     break;
1959
1960   case 10:
1961 #line 189 "ael.y"
1962     { (yyval.str) = (yyvsp[0].str); ;}
1963     break;
1964
1965   case 11:
1966 #line 190 "ael.y"
1967     { (yyval.str) = strdup("default"); ;}
1968     break;
1969
1970   case 12:
1971 #line 193 "ael.y"
1972     {
1973                 (yyval.pval) = npval2(PV_CONTEXT, &(yylsp[-4]), &(yylsp[0]));
1974                 (yyval.pval)->u1.str = (yyvsp[-3].str);
1975                 (yyval.pval)->u2.statements = (yyvsp[-1].pval); ;}
1976     break;
1977
1978   case 13:
1979 #line 197 "ael.y"
1980     {
1981                 (yyval.pval) = npval2(PV_CONTEXT, &(yylsp[-3]), &(yylsp[0]));
1982                 (yyval.pval)->u1.str = (yyvsp[-2].str); ;}
1983     break;
1984
1985   case 14:
1986 #line 200 "ael.y"
1987     {
1988                 (yyval.pval) = npval2(PV_CONTEXT, &(yylsp[-5]), &(yylsp[0]));
1989                 (yyval.pval)->u1.str = (yyvsp[-3].str);
1990                 (yyval.pval)->u2.statements = (yyvsp[-1].pval);
1991                 (yyval.pval)->u3.abstract = 1; ;}
1992     break;
1993
1994   case 15:
1995 #line 205 "ael.y"
1996     {
1997                 (yyval.pval) = npval2(PV_CONTEXT, &(yylsp[-4]), &(yylsp[0]));
1998                 (yyval.pval)->u1.str = (yyvsp[-2].str);
1999                 (yyval.pval)->u3.abstract = 1; ;}
2000     break;
2001
2002   case 16:
2003 #line 229 "ael.y"
2004     {
2005                 (yyval.pval) = npval2(PV_MACRO, &(yylsp[-7]), &(yylsp[0]));
2006                 (yyval.pval)->u1.str = (yyvsp[-6].str); (yyval.pval)->u2.arglist = (yyvsp[-4].pval); (yyval.pval)->u3.macro_statements = (yyvsp[-1].pval); ;}
2007     break;
2008
2009   case 17:
2010 #line 232 "ael.y"
2011     {
2012                 (yyval.pval) = npval2(PV_MACRO, &(yylsp[-6]), &(yylsp[0]));
2013                 (yyval.pval)->u1.str = (yyvsp[-5].str); (yyval.pval)->u2.arglist = (yyvsp[-3].pval); ;}
2014     break;
2015
2016   case 18:
2017 #line 235 "ael.y"
2018     {
2019                 (yyval.pval) = npval2(PV_MACRO, &(yylsp[-6]), &(yylsp[0]));
2020                 (yyval.pval)->u1.str = (yyvsp[-5].str);
2021                 (yyval.pval)->u3.macro_statements = (yyvsp[-1].pval); ;}
2022     break;
2023
2024   case 19:
2025 #line 239 "ael.y"
2026     {
2027                 (yyval.pval) = npval2(PV_MACRO, &(yylsp[-5]), &(yylsp[0]));
2028                 (yyval.pval)->u1.str = (yyvsp[-4].str); ;}
2029     break;
2030
2031   case 20:
2032 #line 244 "ael.y"
2033     {
2034                 (yyval.pval) = npval2(PV_GLOBALS, &(yylsp[-3]), &(yylsp[0]));
2035                 (yyval.pval)->u1.statements = (yyvsp[-1].pval);;}
2036     break;
2037
2038   case 21:
2039 #line 247 "ael.y"
2040     { /* empty globals is OK */
2041                 (yyval.pval) = npval2(PV_GLOBALS, &(yylsp[-2]), &(yylsp[0])); ;}
2042     break;
2043
2044   case 22:
2045 #line 251 "ael.y"
2046     {(yyval.pval)=(yyvsp[0].pval);;}
2047     break;
2048
2049   case 23:
2050 #line 252 "ael.y"
2051     {(yyval.pval)=(yyvsp[-1].pval); linku1((yyval.pval),(yyvsp[0].pval));;}
2052     break;
2053
2054   case 24:
2055 #line 253 "ael.y"
2056     {(yyval.pval)=(yyvsp[-1].pval);;}
2057     break;
2058
2059   case 25:
2060 #line 256 "ael.y"
2061     { reset_semicount(parseio->scanner); ;}
2062     break;
2063
2064   case 26:
2065 #line 256 "ael.y"
2066     {
2067                 (yyval.pval) = npval2(PV_VARDEC, &(yylsp[-4]), &(yylsp[0]));
2068                 (yyval.pval)->u1.str = (yyvsp[-4].str);
2069                 (yyval.pval)->u2.val = (yyvsp[-1].str); ;}
2070     break;
2071
2072   case 27:
2073 #line 262 "ael.y"
2074     {
2075                 (yyval.pval)= npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2076                 (yyval.pval)->u1.str = (yyvsp[0].str); ;}
2077     break;
2078
2079   case 28:
2080 #line 265 "ael.y"
2081     {
2082                 pval *z = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[0]));
2083                 z->u1.str = (yyvsp[0].str);
2084                 (yyval.pval) = linku1((yyvsp[-2].pval),z); ;}
2085     break;
2086
2087   case 29:
2088 #line 269 "ael.y"
2089     {(yyval.pval)=(yyvsp[-1].pval);;}
2090     break;
2091
2092   case 30:
2093 #line 272 "ael.y"
2094     { (yyval.pval)=(yyvsp[0].pval);;}
2095     break;
2096
2097   case 31:
2098 #line 273 "ael.y"
2099     {(yyval.pval)=0;;}
2100     break;
2101
2102   case 32:
2103 #line 274 "ael.y"
2104     { if ( (yyvsp[-1].pval) && (yyvsp[0].pval) ) {(yyval.pval)=(yyvsp[-1].pval); linku1((yyval.pval),(yyvsp[0].pval));}
2105                                 else if ( (yyvsp[-1].pval) ) {(yyval.pval)=(yyvsp[-1].pval);}
2106                                 else if ( (yyvsp[0].pval) ) {(yyval.pval)=(yyvsp[0].pval);} ;}
2107     break;
2108
2109   case 33:
2110 #line 277 "ael.y"
2111     { (yyval.pval)=(yyvsp[-1].pval);;}
2112     break;
2113
2114   case 34:
2115 #line 280 "ael.y"
2116     {(yyval.pval)=(yyvsp[0].pval);;}
2117     break;
2118
2119   case 35:
2120 #line 281 "ael.y"
2121     {(yyval.pval)=(yyvsp[0].pval);;}
2122     break;
2123
2124   case 36:
2125 #line 282 "ael.y"
2126     {(yyval.pval)=(yyvsp[0].pval);;}
2127     break;
2128
2129   case 37:
2130 #line 283 "ael.y"
2131     {(yyval.pval)=(yyvsp[0].pval);;}
2132     break;
2133
2134   case 38:
2135 #line 284 "ael.y"
2136     {(yyval.pval)=(yyvsp[0].pval);;}
2137     break;
2138
2139   case 39:
2140 #line 285 "ael.y"
2141     { reset_semicount(parseio->scanner); ;}
2142     break;
2143
2144   case 40:
2145 #line 285 "ael.y"
2146     {
2147                 (yyval.pval) = npval2(PV_VARDEC, &(yylsp[-4]), &(yylsp[0]));
2148                 (yyval.pval)->u1.str = (yyvsp[-4].str);
2149                 (yyval.pval)->u2.val = (yyvsp[-1].str); ;}
2150     break;
2151
2152   case 41:
2153 #line 289 "ael.y"
2154     {free((yyvsp[-1].str)); (yyval.pval)=0;;}
2155     break;
2156
2157   case 42:
2158 #line 290 "ael.y"
2159     {(yyval.pval)=0;/* allow older docs to be read */;}
2160     break;
2161
2162   case 43:
2163 #line 293 "ael.y"
2164     {
2165                 (yyval.pval) = npval2(PV_IGNOREPAT, &(yylsp[-3]), &(yylsp[0]));
2166                 (yyval.pval)->u1.str = (yyvsp[-1].str);;}
2167     break;
2168
2169   case 44:
2170 #line 298 "ael.y"
2171     {
2172                 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[-2]), &(yylsp[0]));
2173                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2174                 (yyval.pval)->u2.statements = (yyvsp[0].pval); ;}
2175     break;
2176
2177   case 45:
2178 #line 302 "ael.y"
2179     {
2180                 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[-3]), &(yylsp[0]));
2181                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2182                 (yyval.pval)->u2.statements = (yyvsp[0].pval);
2183                 (yyval.pval)->u4.regexten=1;;}
2184     break;
2185
2186   case 46:
2187 #line 307 "ael.y"
2188     {
2189                 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[-6]), &(yylsp[0]));
2190                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2191                 (yyval.pval)->u2.statements = (yyvsp[0].pval);
2192                 (yyval.pval)->u3.hints = (yyvsp[-4].str);;}
2193     break;
2194
2195   case 47:
2196 #line 312 "ael.y"
2197     {
2198                 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[-7]), &(yylsp[0]));
2199                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2200                 (yyval.pval)->u2.statements = (yyvsp[0].pval);
2201                 (yyval.pval)->u4.regexten=1;
2202                 (yyval.pval)->u3.hints = (yyvsp[-4].str);;}
2203     break;
2204
2205   case 48:
2206 #line 321 "ael.y"
2207     {(yyval.pval)=(yyvsp[0].pval);;}
2208     break;
2209
2210   case 49:
2211 #line 322 "ael.y"
2212     {if ( (yyvsp[-1].pval) && (yyvsp[0].pval) ) {(yyval.pval)=(yyvsp[-1].pval); linku1((yyval.pval),(yyvsp[0].pval));}
2213                                                  else if ( (yyvsp[-1].pval) ) {(yyval.pval)=(yyvsp[-1].pval);}
2214                                                  else if ( (yyvsp[0].pval) ) {(yyval.pval)=(yyvsp[0].pval);} ;}
2215     break;
2216
2217   case 50:
2218 #line 325 "ael.y"
2219     {(yyval.pval)=(yyvsp[-1].pval);;}
2220     break;
2221
2222   case 51:
2223 #line 328 "ael.y"
2224     { reset_parencount(parseio->scanner); ;}
2225     break;
2226
2227   case 52:
2228 #line 328 "ael.y"
2229     {
2230                 (yyval.pval)= npval2(PV_IF, &(yylsp[-4]), &(yylsp[0]));
2231                 (yyval.pval)->u1.str = (yyvsp[-1].str); ;}
2232     break;
2233
2234   case 53:
2235 #line 333 "ael.y"
2236     { reset_parencount(parseio->scanner); ;}
2237     break;
2238
2239   case 54:
2240 #line 333 "ael.y"
2241     {
2242                 (yyval.pval) = npval2(PV_RANDOM, &(yylsp[-4]), &(yylsp[0]));
2243                 (yyval.pval)->u1.str=(yyvsp[-1].str);;}
2244     break;
2245
2246   case 55:
2247 #line 339 "ael.y"
2248     {
2249                 (yyval.pval) = npval2(PV_IFTIME, &(yylsp[-13]), &(yylsp[-9])); /* XXX really @5 or more ? */
2250                 (yyval.pval)->u1.list = npval2(PV_WORD, &(yylsp[-11]), &(yylsp[-11]));
2251                 asprintf(&((yyval.pval)->u1.list->u1.str), "%s:%s:%s", (yyvsp[-11].str), (yyvsp[-9].str), (yyvsp[-7].str));
2252                 free((yyvsp[-11].str));
2253                 free((yyvsp[-9].str));
2254                 free((yyvsp[-7].str));
2255                 (yyval.pval)->u1.list->next = npval2(PV_WORD, &(yylsp[-5]), &(yylsp[-5]));
2256                 (yyval.pval)->u1.list->next->u1.str = (yyvsp[-5].str);
2257                 (yyval.pval)->u1.list->next->next = npval2(PV_WORD, &(yylsp[-3]), &(yylsp[-3]));
2258                 (yyval.pval)->u1.list->next->next->u1.str = (yyvsp[-3].str);
2259                 (yyval.pval)->u1.list->next->next->next = npval2(PV_WORD, &(yylsp[-1]), &(yylsp[-1]));
2260                 (yyval.pval)->u1.list->next->next->next->u1.str = (yyvsp[-1].str);
2261                 prev_word = 0;
2262         ;}
2263     break;
2264
2265   case 56:
2266 #line 354 "ael.y"
2267     {
2268                 (yyval.pval) = npval2(PV_IFTIME, &(yylsp[-9]), &(yylsp[-5])); /* XXX @5 or greater ? */
2269                 (yyval.pval)->u1.list = npval2(PV_WORD, &(yylsp[-7]), &(yylsp[-7]));
2270                 (yyval.pval)->u1.list->u1.str = (yyvsp[-7].str);
2271                 (yyval.pval)->u1.list->next = npval2(PV_WORD, &(yylsp[-5]), &(yylsp[-5]));
2272                 (yyval.pval)->u1.list->next->u1.str = (yyvsp[-5].str);
2273                 (yyval.pval)->u1.list->next->next = npval2(PV_WORD, &(yylsp[-3]), &(yylsp[-3]));
2274                 (yyval.pval)->u1.list->next->next->u1.str = (yyvsp[-3].str);
2275                 (yyval.pval)->u1.list->next->next->next = npval2(PV_WORD, &(yylsp[-1]), &(yylsp[-1]));
2276                 (yyval.pval)->u1.list->next->next->next->u1.str = (yyvsp[-1].str);
2277                 prev_word = 0;
2278         ;}
2279     break;
2280
2281   case 57:
2282 #line 374 "ael.y"
2283     { (yyval.str) = (yyvsp[0].str);;}
2284     break;
2285
2286   case 58:
2287 #line 375 "ael.y"
2288     {
2289                 asprintf(&((yyval.str)), "%s%s", (yyvsp[-1].str), (yyvsp[0].str));
2290                 free((yyvsp[-1].str));
2291                 free((yyvsp[0].str));
2292                 prev_word = (yyval.str);;}
2293     break;
2294
2295   case 59:
2296 #line 382 "ael.y"
2297     { (yyval.str) = (yyvsp[0].str);;}
2298     break;
2299
2300   case 60:
2301 #line 383 "ael.y"
2302     {
2303                 asprintf(&((yyval.str)), "%s%s", (yyvsp[-1].str), (yyvsp[0].str));
2304                 free((yyvsp[-1].str));
2305                 free((yyvsp[0].str));
2306                 prev_word = (yyval.str);;}
2307     break;
2308
2309   case 61:
2310 #line 388 "ael.y"
2311     {
2312                 asprintf(&((yyval.str)), "%s%s%s", (yyvsp[-2].str), (yyvsp[-1].str), (yyvsp[0].str));
2313                 free((yyvsp[-2].str));
2314                 free((yyvsp[-1].str));
2315                 free((yyvsp[0].str));
2316                 prev_word=(yyval.str);;}
2317     break;
2318
2319   case 62:
2320 #line 396 "ael.y"
2321     { (yyval.str) = (yyvsp[0].str);;}
2322     break;
2323
2324   case 63:
2325 #line 397 "ael.y"
2326     {
2327                 asprintf(&((yyval.str)), "%s%s", (yyvsp[-1].str), (yyvsp[0].str));
2328                 free((yyvsp[-1].str));
2329                 free((yyvsp[0].str));;}
2330     break;
2331
2332   case 64:
2333 #line 401 "ael.y"
2334     {
2335                 asprintf(&((yyval.str)), "%s:%s", (yyvsp[-2].str), (yyvsp[0].str));
2336                 free((yyvsp[-2].str));
2337                 free((yyvsp[0].str));;}
2338     break;
2339
2340   case 65:
2341 #line 407 "ael.y"
2342     { reset_parencount(parseio->scanner); ;}
2343     break;
2344
2345   case 66:
2346 #line 407 "ael.y"
2347     {
2348                 (yyval.pval) = npval2(PV_SWITCH, &(yylsp[-5]), &(yylsp[0]));
2349                 (yyval.pval)->u1.str = (yyvsp[-2].str); ;}
2350     break;
2351
2352   case 67:
2353 #line 415 "ael.y"
2354     {
2355                 (yyval.pval) = npval2(PV_STATEMENTBLOCK, &(yylsp[-2]), &(yylsp[0]));
2356                 (yyval.pval)->u1.list = (yyvsp[-1].pval); ;}
2357     break;
2358
2359   case 68:
2360 #line 418 "ael.y"
2361     {reset_semicount(parseio->scanner);;}
2362     break;
2363
2364   case 69:
2365 #line 418 "ael.y"
2366     {
2367                 (yyval.pval) = npval2(PV_VARDEC, &(yylsp[-4]), &(yylsp[0]));
2368                 (yyval.pval)->u1.str = (yyvsp[-4].str);
2369                 (yyval.pval)->u2.val = (yyvsp[-1].str); ;}
2370     break;
2371
2372   case 70:
2373 #line 422 "ael.y"
2374     {
2375                 (yyval.pval) = npval2(PV_GOTO, &(yylsp[-2]), &(yylsp[0]));
2376                 (yyval.pval)->u1.list = (yyvsp[-1].pval);;}
2377     break;
2378
2379   case 71:
2380 #line 425 "ael.y"
2381     {
2382                 (yyval.pval) = npval2(PV_GOTO, &(yylsp[-2]), &(yylsp[0]));
2383                 (yyval.pval)->u1.list = (yyvsp[-1].pval);;}
2384     break;
2385
2386   case 72:
2387 #line 428 "ael.y"
2388     {
2389                 (yyval.pval) = npval2(PV_LABEL, &(yylsp[-1]), &(yylsp[0]));
2390                 (yyval.pval)->u1.str = (yyvsp[-1].str); ;}
2391     break;
2392
2393   case 73:
2394 #line 431 "ael.y"
2395     {reset_semicount(parseio->scanner);;}
2396     break;
2397
2398   case 74:
2399 #line 432 "ael.y"
2400     {reset_semicount(parseio->scanner);;}
2401     break;
2402
2403   case 75:
2404 #line 433 "ael.y"
2405     {reset_parencount(parseio->scanner);;}
2406     break;
2407
2408   case 76:
2409 #line 433 "ael.y"
2410     {
2411                 (yyval.pval) = npval2(PV_FOR, &(yylsp[-11]), &(yylsp[0]));
2412                 (yyval.pval)->u1.for_init = (yyvsp[-8].str);
2413                 (yyval.pval)->u2.for_test=(yyvsp[-5].str);
2414                 (yyval.pval)->u3.for_inc = (yyvsp[-2].str);
2415                 (yyval.pval)->u4.for_statements = (yyvsp[0].pval);;}
2416     break;
2417
2418   case 77:
2419 #line 439 "ael.y"
2420     {reset_parencount(parseio->scanner);;}
2421     break;
2422
2423   case 78:
2424 #line 439 "ael.y"
2425     {
2426                 (yyval.pval) = npval2(PV_WHILE, &(yylsp[-5]), &(yylsp[0]));
2427                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2428                 (yyval.pval)->u2.statements = (yyvsp[0].pval); ;}
2429     break;
2430
2431   case 79:
2432 #line 443 "ael.y"
2433     {
2434                 (yyval.pval)=(yyvsp[-1].pval);
2435                 (yyval.pval)->endline = (yylsp[0]).last_line;
2436                 (yyval.pval)->endcol = (yylsp[0]).last_column;;}
2437     break;
2438
2439   case 80:
2440 #line 447 "ael.y"
2441     {
2442                 (yyval.pval)=(yyvsp[-2].pval);
2443                 (yyval.pval)->u2.statements = (yyvsp[-1].pval);
2444                 (yyval.pval)->endline = (yylsp[0]).last_line;
2445                 (yyval.pval)->endcol = (yylsp[0]).last_column;;}
2446     break;
2447
2448   case 81:
2449 #line 452 "ael.y"
2450     {
2451                 (yyval.pval) = (yyvsp[-1].pval);
2452                 (yyval.pval)->endline = (yylsp[-1]).last_line;
2453                 (yyval.pval)->endcol = (yylsp[-1]).last_column;;}
2454     break;
2455
2456   case 82:
2457 #line 456 "ael.y"
2458     {
2459                 (yyval.pval) = (yyvsp[-1].pval);
2460                 (yyval.pval)->endline = (yylsp[0]).last_line;
2461                 (yyval.pval)->endcol = (yylsp[0]).last_column;;}
2462     break;
2463
2464   case 83:
2465 #line 460 "ael.y"
2466     {
2467                 (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[-1]), &(yylsp[0]));
2468                 (yyval.pval)->u1.str = (yyvsp[-1].str);;}
2469     break;
2470
2471   case 84:
2472 #line 463 "ael.y"
2473     {reset_semicount(parseio->scanner);;}
2474     break;
2475
2476   case 85:
2477 #line 463 "ael.y"
2478     {
2479                 char *bufx;
2480                 int tot=0;
2481                 pval *pptr;
2482                 (yyval.pval) = npval2(PV_VARDEC, &(yylsp[-4]), &(yylsp[0]));
2483                 (yyval.pval)->u2.val=(yyvsp[-1].str);
2484                 /* rebuild the original string-- this is not an app call, it's an unwrapped vardec, with a func call on the LHS */
2485                 /* string to big to fit in the buffer? */
2486                 tot+=strlen((yyvsp[-4].pval)->u1.str);
2487                 for(pptr=(yyvsp[-4].pval)->u2.arglist;pptr;pptr=pptr->next) {
2488                         tot+=strlen(pptr->u1.str);
2489                         tot++; /* for a sep like a comma */
2490                 }
2491                 tot+=4; /* for safety */
2492                 bufx = ast_calloc(1, tot);
2493                 strcpy(bufx,(yyvsp[-4].pval)->u1.str);
2494                 strcat(bufx,"(");
2495                 /* XXX need to advance the pointer or the loop is very inefficient */
2496                 for (pptr=(yyvsp[-4].pval)->u2.arglist;pptr;pptr=pptr->next) {
2497                         if ( pptr != (yyvsp[-4].pval)->u2.arglist )
2498                                 strcat(bufx,",");
2499                         strcat(bufx,pptr->u1.str);
2500                 }
2501                 strcat(bufx,")");
2502 #ifdef AAL_ARGCHECK
2503                 if ( !ael_is_funcname((yyvsp[-4].pval)->u1.str) )
2504                         ast_log(LOG_WARNING, "==== File: %s, Line %d, Cols: %d-%d: Function call? The name %s is not in my internal list of function names\n",
2505                                 my_file, (yylsp[-4]).first_line, (yylsp[-4]).first_column, (yylsp[-4]).last_column, (yyvsp[-4].pval)->u1.str);
2506 #endif
2507                 (yyval.pval)->u1.str = bufx;
2508                 destroy_pval((yyvsp[-4].pval)); /* the app call it is not, get rid of that chain */
2509                 prev_word = 0;
2510         ;}
2511     break;
2512
2513   case 86:
2514 #line 496 "ael.y"
2515     { (yyval.pval) = npval2(PV_BREAK, &(yylsp[-1]), &(yylsp[0])); ;}
2516     break;
2517
2518   case 87:
2519 #line 497 "ael.y"
2520     { (yyval.pval) = npval2(PV_RETURN, &(yylsp[-1]), &(yylsp[0])); ;}
2521     break;
2522
2523   case 88:
2524 #line 498 "ael.y"
2525     { (yyval.pval) = npval2(PV_CONTINUE, &(yylsp[-1]), &(yylsp[0])); ;}
2526     break;
2527
2528   case 89:
2529 #line 499 "ael.y"
2530     {
2531                 (yyval.pval)=(yyvsp[-2].pval);
2532                 (yyval.pval)->u2.statements = (yyvsp[-1].pval);
2533                 (yyval.pval)->endline = (yylsp[-1]).last_line;
2534                 (yyval.pval)->u3.else_statements = (yyvsp[0].pval);
2535                 (yyval.pval)->endcol = (yylsp[-1]).last_column;;}
2536     break;
2537
2538   case 90:
2539 #line 513 "ael.y"
2540     {
2541                 (yyval.pval)=(yyvsp[-2].pval);
2542                 (yyval.pval)->u2.statements = (yyvsp[-1].pval);
2543                 (yyval.pval)->endline = (yylsp[-1]).last_line;
2544                 (yyval.pval)->u3.else_statements = (yyvsp[0].pval);
2545                 (yyval.pval)->endcol = (yylsp[-1]).last_column;;}
2546     break;
2547
2548   case 91:
2549 #line 527 "ael.y"
2550     {
2551                 (yyval.pval)=(yyvsp[-2].pval);
2552                 (yyval.pval)->u2.statements = (yyvsp[-1].pval);
2553                 (yyval.pval)->endline = (yylsp[-1]).last_line;
2554                 (yyval.pval)->u3.else_statements = (yyvsp[0].pval);
2555                 (yyval.pval)->endcol = (yylsp[-1]).last_column;;}
2556     break;
2557
2558   case 92:
2559 #line 541 "ael.y"
2560     { (yyval.pval)=0; ;}
2561     break;
2562
2563   case 93:
2564 #line 544 "ael.y"
2565     { (yyval.pval) = (yyvsp[0].pval); ;}
2566     break;
2567
2568   case 94:
2569 #line 545 "ael.y"
2570     { (yyval.pval) = NULL ; ;}
2571     break;
2572
2573   case 95:
2574 #line 550 "ael.y"
2575     { (yyval.pval) = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2576                 (yyval.pval)->u1.str = (yyvsp[0].str);;}
2577     break;
2578
2579   case 96:
2580 #line 552 "ael.y"
2581     {
2582                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[-2]));
2583                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2584                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2585                 (yyval.pval)->next->u1.str = (yyvsp[0].str);;}
2586     break;
2587
2588   case 97:
2589 #line 557 "ael.y"
2590     {
2591                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[-2]));
2592                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2593                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2594                 (yyval.pval)->next->u1.str = (yyvsp[0].str);;}
2595     break;
2596
2597   case 98:
2598 #line 562 "ael.y"
2599     {
2600                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-4]), &(yylsp[-4]));
2601                 (yyval.pval)->u1.str = (yyvsp[-4].str);
2602                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[-2]));
2603                 (yyval.pval)->next->u1.str = (yyvsp[-2].str);
2604                 (yyval.pval)->next->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2605                 (yyval.pval)->next->next->u1.str = (yyvsp[0].str); ;}
2606     break;
2607
2608   case 99:
2609 #line 569 "ael.y"
2610     {
2611                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-4]), &(yylsp[-4]));
2612                 (yyval.pval)->u1.str = (yyvsp[-4].str);
2613                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[-2]));
2614                 (yyval.pval)->next->u1.str = (yyvsp[-2].str);
2615                 (yyval.pval)->next->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2616                 (yyval.pval)->next->next->u1.str = (yyvsp[0].str); ;}
2617     break;
2618
2619   case 100:
2620 #line 576 "ael.y"
2621     {
2622                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-4]), &(yylsp[-4]));
2623                 (yyval.pval)->u1.str = strdup("default");
2624                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[-2]));
2625                 (yyval.pval)->next->u1.str = (yyvsp[-2].str);
2626                 (yyval.pval)->next->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2627                 (yyval.pval)->next->next->u1.str = (yyvsp[0].str); ;}
2628     break;
2629
2630   case 101:
2631 #line 583 "ael.y"
2632     {
2633                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-4]), &(yylsp[-4]));
2634                 (yyval.pval)->u1.str = strdup("default");
2635                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[-2]));
2636                 (yyval.pval)->next->u1.str = (yyvsp[-2].str);
2637                 (yyval.pval)->next->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2638                 (yyval.pval)->next->next->u1.str = (yyvsp[0].str); ;}
2639     break;
2640
2641   case 102:
2642 #line 592 "ael.y"
2643     {
2644                 (yyval.pval) = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2645                 (yyval.pval)->u1.str = (yyvsp[0].str);
2646                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0])); /* XXX not really @1 */
2647                 (yyval.pval)->next->u1.str = strdup("1");;}
2648     break;
2649
2650   case 103:
2651 #line 597 "ael.y"
2652     {
2653                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[-2]));
2654                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2655                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2656                 (yyval.pval)->next->u1.str = (yyvsp[0].str);;}
2657     break;
2658
2659   case 104:
2660 #line 602 "ael.y"
2661     {
2662                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-4]), &(yylsp[-4]));
2663                 (yyval.pval)->u1.str = (yyvsp[0].str);
2664                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[-2]));
2665                 (yyval.pval)->next->u1.str = (yyvsp[-4].str);
2666                 (yyval.pval)->next->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2667                 (yyval.pval)->next->next->u1.str = (yyvsp[-2].str); ;}
2668     break;
2669
2670   case 105:
2671 #line 609 "ael.y"
2672     {
2673                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[-2]));
2674                 (yyval.pval)->u1.str = (yyvsp[0].str);
2675                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2676                 (yyval.pval)->next->u1.str = (yyvsp[-2].str);
2677                 (yyval.pval)->next->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2678                 (yyval.pval)->next->next->u1.str = strdup("1"); ;}
2679     break;
2680
2681   case 106:
2682 #line 616 "ael.y"
2683     {
2684                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-4]), &(yylsp[-4]));
2685                 (yyval.pval)->u1.str = strdup("default");
2686                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[-2]));
2687                 (yyval.pval)->next->u1.str = (yyvsp[-4].str);
2688                 (yyval.pval)->next->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2689                 (yyval.pval)->next->next->u1.str = (yyvsp[-2].str); ;}
2690     break;
2691
2692   case 107:
2693 #line 623 "ael.y"
2694     {
2695                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-2]), &(yylsp[-2]));
2696                 (yyval.pval)->u1.str = strdup("default");
2697                 (yyval.pval)->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2698                 (yyval.pval)->next->u1.str = (yyvsp[-2].str);
2699                 (yyval.pval)->next->next = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2700                 (yyval.pval)->next->next->u1.str = strdup("1"); ;}
2701     break;
2702
2703   case 108:
2704 #line 632 "ael.y"
2705     {reset_argcount(parseio->scanner);;}
2706     break;
2707
2708   case 109:
2709 #line 632 "ael.y"
2710     {
2711                 /* XXX original code had @2 but i think we need @5 */
2712                 (yyval.pval) = npval2(PV_MACRO_CALL, &(yylsp[-4]), &(yylsp[0]));
2713                 (yyval.pval)->u1.str = (yyvsp[-4].str);
2714                 (yyval.pval)->u2.arglist = (yyvsp[-1].pval);;}
2715     break;
2716
2717   case 110:
2718 #line 637 "ael.y"
2719     {
2720                 (yyval.pval)= npval2(PV_MACRO_CALL, &(yylsp[-2]), &(yylsp[0]));
2721                 (yyval.pval)->u1.str = (yyvsp[-2].str); ;}
2722     break;
2723
2724   case 111:
2725 #line 642 "ael.y"
2726     {reset_argcount(parseio->scanner);;}
2727     break;
2728
2729   case 112:
2730 #line 642 "ael.y"
2731     {
2732                 if (strcasecmp((yyvsp[-2].str),"goto") == 0) {
2733                         (yyval.pval)= npval2(PV_GOTO, &(yylsp[-2]), &(yylsp[0]));
2734                         free((yyvsp[-2].str)); /* won't be using this */
2735                         ast_log(LOG_WARNING, "==== File: %s, Line %d, Cols: %d-%d: Suggestion: Use the goto statement instead of the Goto() application call in AEL.\n", my_file, (yylsp[-2]).first_line, (yylsp[-2]).first_column, (yylsp[-2]).last_column );
2736                 } else
2737                         (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[-2]), &(yylsp[0]));
2738                 (yyval.pval)->u1.str = (yyvsp[-2].str); ;}
2739     break;
2740
2741   case 113:
2742 #line 652 "ael.y"
2743     {(yyval.pval) = (yyvsp[-2].pval);
2744                 if( (yyval.pval)->type == PV_GOTO )
2745                         (yyval.pval)->u1.list = (yyvsp[-1].pval);
2746                 else
2747                         (yyval.pval)->u2.arglist = (yyvsp[-1].pval);
2748                 (yyval.pval)->endline = (yylsp[0]).last_line; (yyval.pval)->endcol = (yylsp[0]).last_column;;}
2749     break;
2750
2751   case 114:
2752 #line 658 "ael.y"
2753     {(yyval.pval)=(yyvsp[-1].pval);(yyval.pval)->endline = (yylsp[0]).last_line; (yyval.pval)->endcol = (yylsp[0]).last_column;;}
2754     break;
2755
2756   case 115:
2757 #line 661 "ael.y"
2758     { (yyval.str) = (yyvsp[0].str) ;}
2759     break;
2760
2761   case 116:
2762 #line 662 "ael.y"
2763     { (yyval.str) = strdup(""); ;}
2764     break;
2765
2766   case 117:
2767 #line 665 "ael.y"
2768     { 
2769                 (yyval.pval)= npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2770                 (yyval.pval)->u1.str = (yyvsp[0].str);;}
2771     break;
2772
2773   case 118:
2774 #line 668 "ael.y"
2775     {
2776                 (yyval.pval)= npval(PV_WORD,0/*@1.first_line*/,0/*@1.last_line*/,0/* @1.first_column*/, 0/*@1.last_column*/);
2777                 (yyval.pval)->u1.str = strdup(""); ;}
2778     break;
2779
2780   case 119:
2781 #line 671 "ael.y"
2782     {
2783                 pval *z = npval2(PV_WORD, &(yylsp[0]), &(yylsp[0]));
2784                 (yyval.pval) = (yyvsp[-2].pval);
2785                 linku1((yyvsp[-2].pval),z);
2786                 z->u1.str = (yyvsp[0].str);;}
2787     break;
2788
2789   case 120:
2790 #line 685 "ael.y"
2791     {(yyval.pval)=(yyvsp[0].pval);;}
2792     break;
2793
2794   case 121:
2795 #line 686 "ael.y"
2796     { if ( (yyvsp[-1].pval) && (yyvsp[0].pval) ) {(yyval.pval)=(yyvsp[-1].pval); linku1((yyval.pval),(yyvsp[0].pval));}
2797                                                  else if ( (yyvsp[-1].pval) ) {(yyval.pval)=(yyvsp[-1].pval);}
2798                                                  else if ( (yyvsp[0].pval) ) {(yyval.pval)=(yyvsp[0].pval);} ;}
2799     break;
2800
2801   case 122:
2802 #line 691 "ael.y"
2803     {
2804                 (yyval.pval) = npval2(PV_CASE, &(yylsp[-3]), &(yylsp[-1])); /* XXX 3 or 4 ? */
2805                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2806                 (yyval.pval)->u2.statements = (yyvsp[0].pval);;}
2807     break;
2808
2809   case 123:
2810 #line 695 "ael.y"
2811     {
2812                 (yyval.pval) = npval2(PV_DEFAULT, &(yylsp[-2]), &(yylsp[0]));
2813                 (yyval.pval)->u1.str = NULL;
2814                 (yyval.pval)->u2.statements = (yyvsp[0].pval);;}
2815     break;
2816
2817   case 124:
2818 #line 699 "ael.y"
2819     {
2820                 (yyval.pval) = npval2(PV_PATTERN, &(yylsp[-3]), &(yylsp[0])); /* XXX@3 or @4 ? */
2821                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2822                 (yyval.pval)->u2.statements = (yyvsp[0].pval);;}
2823     break;
2824
2825   case 125:
2826 #line 703 "ael.y"
2827     {
2828                 (yyval.pval) = npval2(PV_CASE, &(yylsp[-2]), &(yylsp[0]));
2829                 (yyval.pval)->u1.str = (yyvsp[-1].str);;}
2830     break;
2831
2832   case 126:
2833 #line 706 "ael.y"
2834     {
2835                 (yyval.pval) = npval2(PV_DEFAULT, &(yylsp[-1]), &(yylsp[0]));
2836                 (yyval.pval)->u1.str = NULL;;}
2837     break;
2838
2839   case 127:
2840 #line 709 "ael.y"
2841     {
2842                 (yyval.pval) = npval2(PV_PATTERN, &(yylsp[-2]), &(yylsp[0]));
2843                 (yyval.pval)->u1.str = (yyvsp[-1].str);;}
2844     break;
2845
2846   case 128:
2847 #line 714 "ael.y"
2848     {(yyval.pval) = (yyvsp[0].pval);;}
2849     break;
2850
2851   case 129:
2852 #line 715 "ael.y"
2853     { if ( (yyvsp[-1].pval) && (yyvsp[0].pval) ) {(yyval.pval)=(yyvsp[-1].pval); linku1((yyval.pval),(yyvsp[0].pval));}
2854                                                  else if ( (yyvsp[-1].pval) ) {(yyval.pval)=(yyvsp[-1].pval);}
2855                                                  else if ( (yyvsp[0].pval) ) {(yyval.pval)=(yyvsp[0].pval);} ;}
2856     break;
2857
2858   case 130:
2859 #line 720 "ael.y"
2860     {(yyval.pval)=(yyvsp[0].pval);;}
2861     break;
2862
2863   case 131:
2864 #line 721 "ael.y"
2865     {
2866                 (yyval.pval) = npval2(PV_CATCH, &(yylsp[-4]), &(yylsp[0]));
2867                 (yyval.pval)->u1.str = (yyvsp[-3].str);
2868                 (yyval.pval)->u2.statements = (yyvsp[-1].pval);;}
2869     break;
2870
2871   case 132:
2872 #line 727 "ael.y"
2873     {
2874                 (yyval.pval) = npval2(PV_SWITCHES, &(yylsp[-3]), &(yylsp[0]));
2875                 (yyval.pval)->u1.list = (yyvsp[-1].pval); ;}
2876     break;
2877
2878   case 133:
2879 #line 730 "ael.y"
2880     {
2881                 (yyval.pval) = npval2(PV_SWITCHES, &(yylsp[-2]), &(yylsp[0])); ;}
2882     break;
2883
2884   case 134:
2885 #line 734 "ael.y"
2886     {
2887                 (yyval.pval) = npval2(PV_ESWITCHES, &(yylsp[-3]), &(yylsp[0]));
2888                 (yyval.pval)->u1.list = (yyvsp[-1].pval); ;}
2889     break;
2890
2891   case 135:
2892 #line 737 "ael.y"
2893     { /* empty switch list OK */
2894                 (yyval.pval) = npval2(PV_ESWITCHES, &(yylsp[-2]), &(yylsp[0])); ;}
2895     break;
2896
2897   case 136:
2898 #line 741 "ael.y"
2899     {
2900                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-1]), &(yylsp[0]));
2901                 (yyval.pval)->u1.str = (yyvsp[-1].str);;}
2902     break;
2903
2904   case 137:
2905 #line 744 "ael.y"
2906     {
2907                 pval *z = npval2(PV_WORD, &(yylsp[-1]), &(yylsp[0]));
2908                 z->u1.str = (yyvsp[-1].str);
2909                 (yyval.pval)=(yyvsp[-2].pval);
2910                 linku1((yyval.pval),z); ;}
2911     break;
2912
2913   case 138:
2914 #line 749 "ael.y"
2915     {(yyval.pval)=(yyvsp[-1].pval);;}
2916     break;
2917
2918   case 139:
2919 #line 752 "ael.y"
2920     {
2921                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-1]), &(yylsp[0]));
2922                 (yyval.pval)->u1.str = (yyvsp[-1].str);;}
2923     break;
2924
2925   case 140:
2926 #line 756 "ael.y"
2927     {
2928                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-13]), &(yylsp[-12]));
2929                 (yyval.pval)->u1.str = (yyvsp[-13].str);
2930                 (yyval.pval)->u2.arglist = npval2(PV_WORD, &(yylsp[-11]), &(yylsp[-7]));
2931                 asprintf( &((yyval.pval)->u2.arglist->u1.str), "%s:%s:%s", (yyvsp[-11].str), (yyvsp[-9].str), (yyvsp[-7].str));
2932                 free((yyvsp[-11].str));
2933                 free((yyvsp[-9].str));
2934                 free((yyvsp[-7].str));
2935                 (yyval.pval)->u2.arglist->next = npval2(PV_WORD, &(yylsp[-5]), &(yylsp[-5]));
2936                 (yyval.pval)->u2.arglist->next->u1.str = (yyvsp[-5].str);
2937                 (yyval.pval)->u2.arglist->next->next = npval2(PV_WORD, &(yylsp[-3]), &(yylsp[-3]));
2938                 (yyval.pval)->u2.arglist->next->next->u1.str = (yyvsp[-3].str);
2939                 (yyval.pval)->u2.arglist->next->next->next = npval2(PV_WORD, &(yylsp[-1]), &(yylsp[-1]));
2940                 (yyval.pval)->u2.arglist->next->next->next->u1.str = (yyvsp[-1].str);
2941                 prev_word=0;
2942         ;}
2943     break;
2944
2945   case 141:
2946 #line 772 "ael.y"
2947     {
2948                 (yyval.pval) = npval2(PV_WORD, &(yylsp[-9]), &(yylsp[-8]));
2949                 (yyval.pval)->u1.str = (yyvsp[-9].str);
2950                 (yyval.pval)->u2.arglist = npval2(PV_WORD, &(yylsp[-7]), &(yylsp[-7]));
2951                 (yyval.pval)->u2.arglist->u1.str = (yyvsp[-7].str);
2952                 (yyval.pval)->u2.arglist->next = npval2(PV_WORD, &(yylsp[-5]), &(yylsp[-5]));
2953                 (yyval.pval)->u2.arglist->next->u1.str = (yyvsp[-5].str);
2954                 (yyval.pval)->u2.arglist->next->next = npval2(PV_WORD, &(yylsp[-3]), &(yylsp[-3]));
2955                 (yyval.pval)->u2.arglist->next->next->u1.str = (yyvsp[-3].str);
2956                 (yyval.pval)->u2.arglist->next->next->next = npval2(PV_WORD, &(yylsp[-1]), &(yylsp[-1]));
2957                 (yyval.pval)->u2.arglist->next->next->next->u1.str = (yyvsp[-1].str);
2958                 prev_word=0;
2959         ;}
2960     break;
2961
2962   case 142:
2963 #line 785 "ael.y"
2964     {
2965                 pval *z = npval2(PV_WORD, &(yylsp[-1]), &(yylsp[0])); /* XXX don't we need @1-@3 ?*/
2966                 (yyval.pval)=(yyvsp[-2].pval);
2967                 z->u1.str = (yyvsp[-1].str);
2968                 linku1((yyval.pval),z); ;}
2969     break;
2970
2971   case 143:
2972 #line 791 "ael.y"
2973     {
2974                 pval *z = npval2(PV_WORD, &(yylsp[-13]), &(yylsp[-12]));
2975                 (yyval.pval)=(yyvsp[-14].pval); z->u1.str = (yyvsp[-13].str);
2976                 linku1((yyval.pval),z);
2977                 z->u2.arglist = npval2(PV_WORD, &(yylsp[-11]), &(yylsp[-11]));
2978                 asprintf( &((yyval.pval)->u2.arglist->u1.str), "%s:%s:%s", (yyvsp[-11].str), (yyvsp[-9].str), (yyvsp[-7].str));
2979                 free((yyvsp[-11].str));
2980                 free((yyvsp[-9].str));
2981                 free((yyvsp[-7].str));
2982                 z->u2.arglist->next = npval2(PV_WORD, &(yylsp[-5]), &(yylsp[-5]));
2983                 z->u2.arglist->next->u1.str = (yyvsp[-5].str);
2984                 z->u2.arglist->next->next = npval2(PV_WORD, &(yylsp[-3]), &(yylsp[-3]));
2985                 z->u2.arglist->next->next->u1.str = (yyvsp[-3].str);
2986                 z->u2.arglist->next->next->next = npval2(PV_WORD, &(yylsp[-1]), &(yylsp[-1]));
2987                 z->u2.arglist->next->next->next->u1.str = (yyvsp[-1].str);
2988                 prev_word=0;
2989         ;}
2990     break;
2991
2992   case 144:
2993 #line 808 "ael.y"
2994     {
2995                 pval *z = npval2(PV_WORD, &(yylsp[-9]), &(yylsp[-8]));
2996                 (yyval.pval)=(yyvsp[-10].pval);
2997                 linku1((yyval.pval),z);
2998                 (yyval.pval)->u2.arglist->u1.str = (yyvsp[-7].str);
2999                 z->u1.str = (yyvsp[-9].str);
3000                 z->u2.arglist = npval2(PV_WORD, &(yylsp[-7]), &(yylsp[-7]));    /* XXX is this correct ? */
3001                 z->u2.arglist->next = npval2(PV_WORD, &(yylsp[-5]), &(yylsp[-5]));
3002                 z->u2.arglist->next->u1.str = (yyvsp[-5].str);
3003                 z->u2.arglist->next->next = npval2(PV_WORD, &(yylsp[-3]), &(yylsp[-3]));
3004                 z->u2.arglist->next->next->u1.str = (yyvsp[-3].str);
3005                 z->u2.arglist->next->next->next = npval2(PV_WORD, &(yylsp[-1]), &(yylsp[-1]));
3006                 z->u2.arglist->next->next->next->u1.str = (yyvsp[-1].str);
3007                 prev_word=0;
3008         ;}
3009     break;
3010
3011   case 145:
3012 #line 823 "ael.y"
3013     {(yyval.pval)=(yyvsp[-1].pval);;}
3014     break;
3015
3016   case 146:
3017 #line 826 "ael.y"
3018     { (yyval.str) = (yyvsp[0].str);;}
3019     break;
3020
3021   case 147:
3022 #line 827 "ael.y"
3023     {(yyval.str)=strdup("default");;}
3024     break;
3025
3026   case 148:
3027 #line 830 "ael.y"
3028     {
3029                 (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[-3]), &(yylsp[0]));
3030                 (yyval.pval)->u1.list = (yyvsp[-1].pval);;}
3031     break;
3032
3033   case 149:
3034 #line 833 "ael.y"
3035     {
3036                 (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[-2]), &(yylsp[0]));;}
3037     break;
3038
3039
3040       default: break;
3041     }
3042
3043 /* Line 1126 of yacc.c.  */
3044 #line 3045 "ael.tab.c"
3045 \f
3046   yyvsp -= yylen;
3047   yyssp -= yylen;
3048   yylsp -= yylen;
3049
3050   YY_STACK_PRINT (yyss, yyssp);
3051
3052   *++yyvsp = yyval;
3053   *++yylsp = yyloc;
3054
3055   /* Now `shift' the result of the reduction.  Determine what state
3056      that goes to, based on the state we popped back to and the rule
3057      number reduced by.  */
3058
3059   yyn = yyr1[yyn];
3060
3061   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3062   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3063     yystate = yytable[yystate];
3064   else
3065     yystate = yydefgoto[yyn - YYNTOKENS];
3066
3067   goto yynewstate;
3068
3069
3070 /*------------------------------------.
3071 | yyerrlab -- here on detecting error |
3072 `------------------------------------*/
3073 yyerrlab:
3074   /* If not already recovering from an error, report this error.  */
3075   if (!yyerrstatus)
3076     {
3077       ++yynerrs;
3078 #if YYERROR_VERBOSE
3079       yyn = yypact[yystate];
3080
3081       if (YYPACT_NINF < yyn && yyn < YYLAST)
3082         {
3083           int yytype = YYTRANSLATE (yychar);
3084           YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
3085           YYSIZE_T yysize = yysize0;
3086           YYSIZE_T yysize1;
3087           int yysize_overflow = 0;
3088           char *yymsg = 0;
3089 #         define YYERROR_VERBOSE_ARGS_MAXIMUM 5
3090           char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
3091           int yyx;
3092
3093 #if 0
3094           /* This is so xgettext sees the translatable formats that are
3095              constructed on the fly.  */
3096           YY_("syntax error, unexpected %s");
3097           YY_("syntax error, unexpected %s, expecting %s");
3098           YY_("syntax error, unexpected %s, expecting %s or %s");
3099           YY_("syntax error, unexpected %s, expecting %s or %s or %s");
3100           YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
3101 #endif
3102           char *yyfmt;
3103           char const *yyf;
3104           static char const yyunexpected[] = "syntax error, unexpected %s";
3105           static char const yyexpecting[] = ", expecting %s";
3106           static char const yyor[] = " or %s";
3107           char yyformat[sizeof yyunexpected
3108                         + sizeof yyexpecting - 1
3109                         + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
3110                            * (sizeof yyor - 1))];
3111           char const *yyprefix = yyexpecting;
3112
3113           /* Start YYX at -YYN if negative to avoid negative indexes in
3114              YYCHECK.  */
3115           int yyxbegin = yyn < 0 ? -yyn : 0;
3116
3117           /* Stay within bounds of both yycheck and yytname.  */
3118           int yychecklim = YYLAST - yyn;
3119           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3120           int yycount = 1;
3121
3122           yyarg[0] = yytname[yytype];
3123           yyfmt = yystpcpy (yyformat, yyunexpected);
3124
3125           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3126             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3127               {
3128                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3129                   {
3130                     yycount = 1;
3131                     yysize = yysize0;
3132                     yyformat[sizeof yyunexpected - 1] = '\0';
3133                     break;
3134                   }
3135                 yyarg[yycount++] = yytname[yyx];
3136                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
3137                 yysize_overflow |= yysize1 < yysize;
3138                 yysize = yysize1;
3139                 yyfmt = yystpcpy (yyfmt, yyprefix);
3140                 yyprefix = yyor;
3141               }
3142
3143           yyf = YY_(yyformat);
3144           yysize1 = yysize + yystrlen (yyf);
3145           yysize_overflow |= yysize1 < yysize;
3146           yysize = yysize1;
3147
3148           if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
3149             yymsg = (char *) YYSTACK_ALLOC (yysize);
3150           if (yymsg)
3151             {
3152               /* Avoid sprintf, as that infringes on the user's name space.
3153                  Don't have undefined behavior even if the translation
3154                  produced a string with the wrong number of "%s"s.  */
3155               char *yyp = yymsg;
3156               int yyi = 0;
3157               while ((*yyp = *yyf))
3158                 {
3159                   if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
3160                     {
3161                       yyp += yytnamerr (yyp, yyarg[yyi++]);
3162                       yyf += 2;
3163                     }
3164                   else
3165                     {
3166                       yyp++;
3167                       yyf++;
3168                     }
3169                 }
3170               yyerror (&yylloc, parseio, yymsg);
3171               YYSTACK_FREE (yymsg);
3172             }
3173           else
3174             {
3175               yyerror (&yylloc, parseio, YY_("syntax error"));
3176               goto yyexhaustedlab;
3177             }
3178         }
3179       else
3180 #endif /* YYERROR_VERBOSE */
3181         yyerror (&yylloc, parseio, YY_("syntax error"));
3182     }
3183
3184   yyerror_range[0] = yylloc;
3185
3186   if (yyerrstatus == 3)
3187     {
3188       /* If just tried and failed to reuse look-ahead token after an
3189          error, discard it.  */
3190
3191       if (yychar <= YYEOF)
3192         {
3193           /* Return failure if at end of input.  */
3194           if (yychar == YYEOF)
3195             YYABORT;
3196         }
3197       else
3198         {
3199           yydestruct ("Error: discarding", yytoken, &yylval, &yylloc);
3200           yychar = YYEMPTY;
3201         }
3202     }
3203
3204   /* Else will try to reuse look-ahead token after shifting the error
3205      token.  */
3206   goto yyerrlab1;
3207
3208
3209 /*---------------------------------------------------.
3210 | yyerrorlab -- error raised explicitly by YYERROR.  |
3211 `---------------------------------------------------*/
3212 yyerrorlab:
3213
3214   /* Pacify compilers like GCC when the user code never invokes
3215      YYERROR and the label yyerrorlab therefore never appears in user
3216      code.  */
3217   if (0)
3218      goto yyerrorlab;
3219
3220   yyerror_range[0] = yylsp[1-yylen];
3221   yylsp -= yylen;
3222   yyvsp -= yylen;
3223   yyssp -= yylen;
3224   yystate = *yyssp;
3225   goto yyerrlab1;
3226
3227
3228 /*-------------------------------------------------------------.
3229 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
3230 `-------------------------------------------------------------*/
3231 yyerrlab1:
3232   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
3233
3234   for (;;)
3235     {
3236       yyn = yypact[yystate];
3237       if (yyn != YYPACT_NINF)
3238         {
3239           yyn += YYTERROR;
3240           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3241             {
3242               yyn = yytable[yyn];
3243               if (0 < yyn)
3244                 break;
3245             }
3246         }
3247
3248       /* Pop the current state because it cannot handle the error token.  */
3249       if (yyssp == yyss)
3250         YYABORT;
3251
3252       yyerror_range[0] = *yylsp;
3253       yydestruct ("Error: popping", yystos[yystate], yyvsp, yylsp);
3254       YYPOPSTACK;
3255       yystate = *yyssp;
3256       YY_STACK_PRINT (yyss, yyssp);
3257     }
3258
3259   if (yyn == YYFINAL)
3260     YYACCEPT;
3261
3262   *++yyvsp = yylval;
3263
3264   yyerror_range[1] = yylloc;
3265   /* Using YYLLOC is tempting, but would change the location of
3266      the look-ahead.  YYLOC is available though. */
3267   YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
3268   *++yylsp = yyloc;
3269
3270   /* Shift the error token. */
3271   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3272
3273   yystate = yyn;
3274   goto yynewstate;
3275
3276
3277 /*-------------------------------------.
3278 | yyacceptlab -- YYACCEPT comes here.  |
3279 `-------------------------------------*/
3280 yyacceptlab:
3281   yyresult = 0;
3282   goto yyreturn;
3283
3284 /*-----------------------------------.
3285 | yyabortlab -- YYABORT comes here.  |
3286 `-----------------------------------*/
3287 yyabortlab:
3288   yyresult = 1;
3289   goto yyreturn;
3290
3291 #ifndef yyoverflow
3292 /*-------------------------------------------------.
3293 | yyexhaustedlab -- memory exhaustion comes here.  |
3294 `-------------------------------------------------*/
3295 yyexhaustedlab:
3296   yyerror (&yylloc, parseio, YY_("memory exhausted"));
3297   yyresult = 2;
3298   /* Fall through.  */
3299 #endif
3300
3301 yyreturn:
3302   if (yychar != YYEOF && yychar != YYEMPTY)
3303      yydestruct ("Cleanup: discarding lookahead",
3304                  yytoken, &yylval, &yylloc);
3305   while (yyssp != yyss)
3306     {
3307       yydestruct ("Cleanup: popping",
3308                   yystos[*yyssp], yyvsp, yylsp);
3309       YYPOPSTACK;
3310     }
3311 #ifndef yyoverflow
3312   if (yyss != yyssa)
3313     YYSTACK_FREE (yyss);