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