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