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