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