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