cbe9d8c337a471cf3b2af49407e866bf4f6a167f
[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   371
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  143
522 /* YYNRULES -- Number of states.  */
523 #define YYNSTATES  283
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,   214,   216,   219,
579      223,   225,   228,   232,   238,   242,   244,   246,   250,   254,
580      257,   258,   259,   260,   273,   277,   279,   283,   286,   289,
581      290,   296,   299,   302,   305,   309,   311,   314,   315,   317,
582      321,   325,   331,   337,   343,   349,   350,   353,   356,   361,
583      362,   368,   372,   373,   377,   381,   384,   386,   387,   389,
584      390,   394,   395,   398,   403,   407,   412,   413,   416,   418,
585      420,   426,   431,   436,   437,   441,   447,   450,   452,   456,
586      459,   463,   466,   471
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       70,    14,    43,    -1,    43,    -1,    43,    43,    -1,    43,
614       43,    43,    -1,    43,    -1,    43,    43,    -1,    72,    11,
615       43,    -1,    18,    66,     4,    90,     5,    -1,     4,    63,
616        5,    -1,    54,    -1,    56,    -1,    26,    80,     8,    -1,
617       27,    82,     8,    -1,    43,    11,    -1,    -1,    -1,    -1,
618       33,     6,    75,    43,     8,    76,    43,     8,    77,    43,
619        7,    74,    -1,    34,    66,    74,    -1,    73,    -1,    12,
620       83,     8,    -1,    87,     8,    -1,    43,     8,    -1,    -1,
621       87,     9,    78,    43,     8,    -1,    29,     8,    -1,    28,
622        8,    -1,    30,     8,    -1,    68,    74,    79,    -1,     8,
623       -1,    21,    74,    -1,    -1,    72,    -1,    72,    13,    72,
624       -1,    72,    10,    72,    -1,    72,    13,    72,    13,    72,
625       -1,    72,    10,    72,    10,    72,    -1,    37,    13,    72,
626       13,    72,    -1,    37,    10,    72,    10,    72,    -1,    -1,
627       10,    43,    -1,    72,    81,    -1,    72,    81,    14,    48,
628       -1,    -1,    43,     6,    84,    89,     7,    -1,    43,     6,
629        7,    -1,    -1,    43,     6,    86,    -1,    85,    89,     7,
630       -1,    85,     7,    -1,    43,    -1,    -1,    69,    -1,    -1,
631       89,    10,    88,    -1,    -1,    90,    91,    -1,    35,    43,
632       11,    63,    -1,    37,    11,    63,    -1,    36,    43,    11,
633       63,    -1,    -1,    92,    93,    -1,    74,    -1,    99,    -1,
634       38,    43,     4,    63,     5,    -1,    39,     4,    96,     5,
635       -1,    40,     4,    96,     5,    -1,    -1,    96,    43,     8,
636       -1,    96,    43,    14,    43,     8,    -1,     1,    96,    -1,
637       48,    -1,    48,    13,    65,    -1,    97,     8,    -1,    98,
638       97,     8,    -1,    98,     1,    -1,    41,     4,    98,     5,
639       -1,    41,     4,     5,    -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,   405,   416,   417,   427,
652      440,   441,   450,   461,   470,   473,   474,   475,   478,   481,
653      484,   485,   486,   484,   492,   496,   497,   498,   499,   502,
654      502,   535,   536,   537,   538,   542,   545,   546,   549,   550,
655      553,   556,   560,   564,   568,   574,   575,   579,   582,   588,
656      588,   593,   601,   601,   612,   619,   622,   623,   626,   627,
657      630,   633,   634,   637,   641,   645,   651,   652,   655,   656,
658      657,   663,   668,   673,   674,   675,   686,   689,   690,   697,
659      698,   699,   702,   705
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,    70,    71,    71,    71,
712       72,    72,    72,    73,    74,    74,    74,    74,    74,    74,
713       75,    76,    77,    74,    74,    74,    74,    74,    74,    78,
714       74,    74,    74,    74,    74,    74,    79,    79,    80,    80,
715       80,    80,    80,    80,    80,    81,    81,    82,    82,    84,
716       83,    83,    86,    85,    87,    87,    88,    88,    89,    89,
717       89,    90,    90,    91,    91,    91,    92,    92,    93,    93,
718       93,    94,    95,    96,    96,    96,    96,    97,    97,    98,
719       98,    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,     3,     1,     2,     3,
732        1,     2,     3,     5,     3,     1,     1,     3,     3,     2,
733        0,     0,     0,    12,     3,     1,     3,     2,     2,     0,
734        5,     2,     2,     2,     3,     1,     2,     0,     1,     3,
735        3,     5,     5,     5,     5,     0,     2,     2,     4,     0,
736        5,     3,     0,     3,     3,     2,     1,     0,     1,     0,
737        3,     0,     2,     4,     3,     4,     0,     2,     1,     1,
738        5,     4,     4,     0,     3,     5,     2,     1,     3,     2,
739        3,     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      126,    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,    95,     0,     0,
755        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
756        0,     0,    75,    76,     0,    85,   128,   119,     0,   127,
757      129,    24,     0,     0,     0,    62,     0,     0,     0,     0,
758      143,   137,     0,     0,    25,     0,    44,     0,     0,     0,
759        0,    55,     0,    57,     0,    58,     0,    70,    98,     0,
760      105,     0,    92,    91,    93,    80,     0,     0,   112,    88,
761       79,    97,   115,    60,   118,     0,    87,    89,    43,     0,
762       46,     0,     0,     0,     0,    63,   136,   131,     0,   132,
763        0,   139,   141,   142,     0,     0,     0,    51,    74,    50,
764      109,    86,     0,   121,    53,     0,     0,     0,     0,     0,
765       71,     0,     0,     0,    77,     0,   107,    78,     0,    84,
766        0,   113,     0,    94,    61,   114,   117,     0,     0,     0,
767       64,    65,    66,   134,     0,   138,   140,     0,    45,   111,
768      119,     0,     0,    68,     0,    59,     0,     0,     0,   100,
769       72,    99,   106,     0,     0,     0,    96,   116,   120,     0,
770        0,     0,     0,    26,     0,    56,    73,     0,     0,     0,
771      122,    69,    67,     0,     0,     0,     0,     0,     0,   108,
772       81,   130,    90,     0,    47,   135,   110,     0,     0,     0,
773        0,     0,   104,   103,   102,   101,     0,    48,     0,     0,
774      124,     0,    52,     0,   123,   125,     0,    82,    54,     0,
775        0,     0,    83
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,   165,    28,    39,    56,    57,    58,   118,
783      175,   176,   122,   172,    94,   144,   106,   177,   128,    95,
784      169,   188,   266,   279,   197,   193,   129,   186,   131,   120,
785      210,    97,   191,    98,   228,   145,   212,   240,    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 -211
792 static const yytype_int16 yypact[] =
793 {
794      166,  -211,   -32,    15,    12,    36,    40,   316,  -211,  -211,
795       75,  -211,  -211,    82,    17,  -211,  -211,  -211,  -211,  -211,
796      -28,    57,    17,     0,  -211,  -211,   127,  -211,     6,   109,
797     -211,   152,  -211,   136,  -211,   169,   143,  -211,   136,   117,
798     -211,  -211,   144,   272,  -211,  -211,   170,   -15,   191,   197,
799      199,   201,   168,   137,  -211,  -211,  -211,  -211,  -211,  -211,
800     -211,  -211,   180,   204,   172,   219,   202,   185,    25,    25,
801       28,   217,  -211,   186,   266,    90,  -211,  -211,   190,   229,
802      229,   230,   229,    21,   194,   240,   241,   242,   246,   229,
803      210,   312,  -211,  -211,   266,  -211,  -211,     1,    61,  -211,
804     -211,  -211,   248,   185,   266,  -211,    68,    25,    24,    29,
805     -211,   247,   254,    20,  -211,   238,  -211,    19,   212,   258,
806      263,  -211,   271,  -211,   233,  -211,   126,   234,   183,   275,
807       95,   279,  -211,  -211,  -211,  -211,   266,   286,  -211,  -211,
808     -211,   270,  -211,   236,  -211,   140,  -211,  -211,  -211,    78,
809     -211,   255,   259,   262,   264,  -211,   267,  -211,    69,  -211,
810      233,  -211,  -211,  -211,   289,   282,   266,   266,  -211,  -211,
811      294,  -211,   283,  -211,    70,   293,   315,   317,   194,   194,
812     -211,   194,   284,   194,  -211,   287,   319,  -211,   291,  -211,
813       90,  -211,   266,  -211,  -211,  -211,   292,   295,   298,   304,
814     -211,  -211,  -211,  -211,   299,  -211,  -211,   328,  -211,  -211,
815      283,   330,   135,   300,   301,  -211,   301,   104,    73,   132,
816     -211,   116,  -211,   -28,   337,   239,  -211,  -211,  -211,   338,
817      322,   266,   340,  -211,   173,  -211,  -211,   306,   307,   341,
818     -211,  -211,   308,   342,   343,   194,   194,   194,   194,  -211,
819     -211,  -211,  -211,   266,  -211,  -211,  -211,   345,   346,    19,
820      301,   301,   347,   347,   347,   347,   310,  -211,    19,    19,
821      266,   348,  -211,   351,   266,   266,   301,  -211,  -211,   320,
822      353,   266,  -211
823 };
824
825 /* YYPGOTO[NTERM-NUM].  */
826 static const yytype_int16 yypgoto[] =
827 {
828     -211,  -211,  -211,   355,   -19,  -211,  -211,  -211,  -211,   344,
829       64,  -211,   -29,  -211,  -211,   326,  -211,  -211,  -211,  -114,
830     -211,   205,    46,  -211,  -211,   195,   265,  -210,   -82,  -211,
831      -62,  -211,  -211,  -211,  -211,  -211,  -211,  -211,  -211,  -211,
832     -211,  -211,  -211,  -211,  -211,   159,  -211,  -211,  -211,  -211,
833     -211,  -211,   -34,   257,  -211,   309
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 -134
841 static const yytype_int16 yytable[] =
842 {
843       96,    26,   130,   167,   243,    30,   244,    34,   142,    24,
844       55,    13,   116,    35,    55,    25,    36,    65,    22,    14,
845      117,   162,   -20,   -49,   -49,   163,   107,   -49,    66,   157,
846     -133,   -49,   141,   110,   159,   109,    15,   -49,   -49,   -49,
847       17,   -49,   150,    31,   143,   -49,   -49,   -49,   -49,   -49,
848      271,   272,   -49,   -49,   -49,   -49,   -49,    24,   126,    16,
849      -20,   -49,   -49,    25,   127,    24,   278,   158,  -133,   146,
850      147,    25,   158,   156,   189,   151,   225,   203,    20,   152,
851      153,   -67,   154,   204,   182,   198,   246,    32,    21,   152,
852      153,   117,   154,    32,   -49,   -49,   217,   218,   -49,   219,
853       27,   221,   -49,    54,   208,   185,   182,    54,   -49,   -49,
854      -49,   155,   -49,   213,   245,   182,   -49,   -49,   -49,   -49,
855      -49,   155,    44,   -49,   -49,    45,   123,   182,   125,   248,
856      226,    33,   -49,   -49,    46,   136,   178,    38,    72,   179,
857      236,   -31,   247,   182,   -31,   270,    37,   195,    47,    48,
858      196,    73,    31,   -31,   274,   275,    49,    50,    51,    52,
859       53,    37,    74,   262,   263,   264,   265,   -31,   -31,   254,
860      237,   238,   239,    40,     1,   -31,   -31,   -31,   -31,   -31,
861      256,     2,     3,   196,    75,    76,    41,    63,    77,     4,
862        5,   267,    78,   181,   182,    64,   183,    67,    79,    80,
863       81,    68,    82,    69,   249,    70,    83,    84,    85,    86,
864       87,    71,   101,    88,    89,   102,    75,   168,    90,   282,
865       77,    51,    52,    91,    78,   103,   114,   104,   105,   115,
866       79,    80,    81,   119,    82,   121,   124,   127,    83,    84,
867       85,    86,    87,    75,   251,    88,    89,    77,   132,   133,
868      134,    78,   135,   137,    52,    91,   148,    79,    80,    81,
869      160,    82,   161,   166,   170,    83,    84,    85,    86,    87,
870       75,   171,    88,    89,    77,   173,   174,   180,    78,   194,
871       45,    52,    91,   184,    79,    80,    81,   187,    82,    46,
872      190,   192,    83,    84,    85,    86,    87,   206,   199,    88,
873       89,   209,   200,    47,    48,   201,   214,   202,    52,    91,
874      158,    49,    50,    51,    52,    53,    -2,    18,   138,   -14,
875      139,    37,   215,   140,     1,   207,   143,   220,   216,   231,
876      222,     2,     3,   223,   224,   227,   233,   235,   229,     4,
877        5,   230,   232,   241,   242,   250,   252,   253,   255,   257,
878      258,   213,   259,   273,   261,   260,   268,   269,   182,   277,
879      281,   276,    19,   280,    43,   205,    29,   211,   149,   234,
880      164,   100
881 };
882
883 static const yytype_uint16 yycheck[] =
884 {
885       62,    20,    84,   117,   214,     5,   216,     1,     7,    37,
886       39,    43,    74,     7,    43,    43,    10,    32,     1,     4,
887        1,     1,     5,     4,     5,     5,     1,     8,    43,     5,
888        5,    12,    94,     5,     5,    69,    24,    18,    19,    20,
889        0,    22,   104,    43,    43,    26,    27,    28,    29,    30,
890      260,   261,    33,    34,    35,    36,    37,    37,    37,    23,
891       43,    42,    43,    43,    43,    37,   276,    43,    43,     8,
892        9,    43,    43,   107,   136,     7,   190,     8,     3,    11,
893       12,    11,    14,    14,    11,     7,    13,    23,     6,    11,
894       12,     1,    14,    29,     4,     5,   178,   179,     8,   181,
895       43,   183,    12,    39,   166,    10,    11,    43,    18,    19,
896       20,    43,    22,    43,    10,    11,    26,    27,    28,    29,
897       30,    43,     5,    33,    34,     8,    80,    11,    82,    13,
898      192,     4,    42,    43,    17,    89,    10,     1,     1,    13,
899        5,     5,    10,    11,     8,   259,     9,     7,    31,    32,
900       10,    14,    43,    17,   268,   269,    39,    40,    41,    42,
901       43,     9,    25,   245,   246,   247,   248,    31,    32,   231,
902       35,    36,    37,     4,     8,    39,    40,    41,    42,    43,
903        7,    15,    16,    10,     4,     5,    43,    43,     8,    23,
904       24,   253,    12,    10,    11,    25,    13,     6,    18,    19,
905       20,     4,    22,     4,   223,     4,    26,    27,    28,    29,
906       30,    43,     8,    33,    34,    43,     4,     5,    38,   281,
907        8,    41,    42,    43,    12,     6,     9,    25,    43,    43,
908       18,    19,    20,    43,    22,     6,     6,    43,    26,    27,
909       28,    29,    30,     4,     5,    33,    34,     8,     8,     8,
910        8,    12,     6,    43,    42,    43,     8,    18,    19,    20,
911       13,    22,     8,    25,     6,    26,    27,    28,    29,    30,
912        4,     8,    33,    34,     8,     4,    43,    43,    12,    43,
913        8,    42,    43,     8,    18,    19,    20,     8,    22,    17,
914        4,    21,    26,    27,    28,    29,    30,     8,    43,    33,
915       34,     7,    43,    31,    32,    43,    13,    43,    42,    43,
916       43,    39,    40,    41,    42,    43,     0,     1,     6,     3,
917        8,     9,     7,    11,     8,    43,    43,    43,    11,    25,
918       43,    15,    16,    14,    43,    43,     8,     7,    43,    23,
919       24,    43,    43,    43,    43,     8,     8,    25,     8,    43,
920       43,    43,    11,    43,    11,    13,    11,    11,    11,     8,
921        7,    13,     7,    43,    38,   160,    22,   172,   103,   210,
922      113,    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,    14,    43,    96,     5,    43,     5,
945       13,     8,     1,     5,    97,    57,    25,    63,     5,    74,
946        6,     8,    67,     4,    43,    64,    65,    71,    10,    13,
947       43,    10,    11,    13,     8,    10,    81,     8,    75,    74,
948        4,    86,    21,    79,    43,     7,    10,    78,     7,    43,
949       43,    43,    43,     8,    14,    65,     8,    43,    74,     7,
950       84,    69,    90,    43,    13,     7,    11,    72,    72,    72,
951       43,    72,    43,    14,    43,    63,    74,    43,    88,    43,
952       43,    25,    43,     8,    89,     7,     5,    35,    36,    37,
953       91,    43,    43,    71,    71,    10,    13,    10,    13,    48,
954        8,     5,     8,    25,    74,     8,     7,    43,    43,    11,
955       13,    11,    72,    72,    72,    72,    76,    74,    11,    11,
956       63,    71,    71,    43,    63,    63,    13,     8,    71,    77,
957       43,     7,    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 405 "ael.y"
2541     {
2542                 if (asprintf(&((yyval.str)), "%s@%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
2543                         ast_log(LOG_WARNING, "asprintf() failed\n");
2544                         (yyval.str) = NULL;
2545                 } else {
2546                         free((yyvsp[(1) - (3)].str));
2547                         free((yyvsp[(3) - (3)].str));
2548                 }
2549         ;}
2550     break;
2551
2552   case 67:
2553 #line 416 "ael.y"
2554     { (yyval.str) = (yyvsp[(1) - (1)].str);;}
2555     break;
2556
2557   case 68:
2558 #line 417 "ael.y"
2559     {
2560                 if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
2561                         ast_log(LOG_WARNING, "asprintf() failed\n");
2562                         (yyval.str) = NULL;
2563                 } else {
2564                         free((yyvsp[(1) - (2)].str));
2565                         free((yyvsp[(2) - (2)].str));
2566                         prev_word = (yyval.str);
2567                 }                       
2568         ;}
2569     break;
2570
2571   case 69:
2572 #line 427 "ael.y"
2573     {
2574                 if (asprintf(&((yyval.str)), "%s%s%s", (yyvsp[(1) - (3)].str), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
2575                         ast_log(LOG_WARNING, "asprintf() failed\n");
2576                         (yyval.str) = NULL;
2577                 } else {
2578                         free((yyvsp[(1) - (3)].str));
2579                         free((yyvsp[(2) - (3)].str));
2580                         free((yyvsp[(3) - (3)].str));
2581                         prev_word=(yyval.str);
2582                 }
2583         ;}
2584     break;
2585
2586   case 70:
2587 #line 440 "ael.y"
2588     { (yyval.str) = (yyvsp[(1) - (1)].str);;}
2589     break;
2590
2591   case 71:
2592 #line 441 "ael.y"
2593     {
2594                 if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
2595                         ast_log(LOG_WARNING, "asprintf() failed\n");
2596                         (yyval.str) = NULL;
2597                 } else {
2598                         free((yyvsp[(1) - (2)].str));
2599                         free((yyvsp[(2) - (2)].str));
2600                 }
2601         ;}
2602     break;
2603
2604   case 72:
2605 #line 450 "ael.y"
2606     {
2607                 if (asprintf(&((yyval.str)), "%s:%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
2608                         ast_log(LOG_WARNING, "asprintf() failed\n");
2609                         (yyval.str) = NULL;
2610                 } else {
2611                         free((yyvsp[(1) - (3)].str));
2612                         free((yyvsp[(3) - (3)].str));
2613                 }
2614         ;}
2615     break;
2616
2617   case 73:
2618 #line 461 "ael.y"
2619     {
2620                 (yyval.pval) = npval2(PV_SWITCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
2621                 (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str);
2622                 (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));;}
2623     break;
2624
2625   case 74:
2626 #line 470 "ael.y"
2627     {
2628                 (yyval.pval) = npval2(PV_STATEMENTBLOCK, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
2629                 (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval));;}
2630     break;
2631
2632   case 75:
2633 #line 473 "ael.y"
2634     { (yyval.pval) = (yyvsp[(1) - (1)].pval); ;}
2635     break;
2636
2637   case 76:
2638 #line 474 "ael.y"
2639     { (yyval.pval) = (yyvsp[(1) - (1)].pval); ;}
2640     break;
2641
2642   case 77:
2643 #line 475 "ael.y"
2644     {
2645                 (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
2646                 (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);;}
2647     break;
2648
2649   case 78:
2650 #line 478 "ael.y"
2651     {
2652                 (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
2653                 (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);;}
2654     break;
2655
2656   case 79:
2657 #line 481 "ael.y"
2658     {
2659                 (yyval.pval) = npval2(PV_LABEL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
2660                 (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str); ;}
2661     break;
2662
2663   case 80:
2664 #line 484 "ael.y"
2665     {reset_semicount(parseio->scanner);;}
2666     break;
2667
2668   case 81:
2669 #line 485 "ael.y"
2670     {reset_semicount(parseio->scanner);;}
2671     break;
2672
2673   case 82:
2674 #line 486 "ael.y"
2675     {reset_parencount(parseio->scanner);;}
2676     break;
2677
2678   case 83:
2679 #line 486 "ael.y"
2680     { /* XXX word_list maybe ? */
2681                 (yyval.pval) = npval2(PV_FOR, &(yylsp[(1) - (12)]), &(yylsp[(12) - (12)]));
2682                 (yyval.pval)->u1.for_init = (yyvsp[(4) - (12)].str);
2683                 (yyval.pval)->u2.for_test=(yyvsp[(7) - (12)].str);
2684                 (yyval.pval)->u3.for_inc = (yyvsp[(10) - (12)].str);
2685                 (yyval.pval)->u4.for_statements = (yyvsp[(12) - (12)].pval); set_dads((yyval.pval),(yyvsp[(12) - (12)].pval));;}
2686     break;
2687
2688   case 84:
2689 #line 492 "ael.y"
2690     {
2691                 (yyval.pval) = npval2(PV_WHILE, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
2692                 (yyval.pval)->u1.str = (yyvsp[(2) - (3)].str);
2693                 (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval); set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));;}
2694     break;
2695
2696   case 85:
2697 #line 496 "ael.y"
2698     { (yyval.pval) = (yyvsp[(1) - (1)].pval); ;}
2699     break;
2700
2701   case 86:
2702 #line 497 "ael.y"
2703     { (yyval.pval) = update_last((yyvsp[(2) - (3)].pval), &(yylsp[(2) - (3)])); ;}
2704     break;
2705
2706   case 87:
2707 #line 498 "ael.y"
2708     { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); ;}
2709     break;
2710
2711   case 88:
2712 #line 499 "ael.y"
2713     {
2714                 (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
2715                 (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str);;}
2716     break;
2717
2718   case 89:
2719 #line 502 "ael.y"
2720     {reset_semicount(parseio->scanner);;}
2721     break;
2722
2723   case 90:
2724 #line 502 "ael.y"
2725     {
2726                 char *bufx;
2727                 int tot=0;
2728                 pval *pptr;
2729                 (yyval.pval) = npval2(PV_VARDEC, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
2730                 (yyval.pval)->u2.val=(yyvsp[(4) - (5)].str);
2731                 /* rebuild the original string-- this is not an app call, it's an unwrapped vardec, with a func call on the LHS */
2732                 /* string to big to fit in the buffer? */
2733                 tot+=strlen((yyvsp[(1) - (5)].pval)->u1.str);
2734                 for(pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) {
2735                         tot+=strlen(pptr->u1.str);
2736                         tot++; /* for a sep like a comma */
2737                 }
2738                 tot+=4; /* for safety */
2739                 bufx = calloc(1, tot);
2740                 strcpy(bufx,(yyvsp[(1) - (5)].pval)->u1.str);
2741                 strcat(bufx,"(");
2742                 /* XXX need to advance the pointer or the loop is very inefficient */
2743                 for (pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) {
2744                         if ( pptr != (yyvsp[(1) - (5)].pval)->u2.arglist )
2745                                 strcat(bufx,",");
2746                         strcat(bufx,pptr->u1.str);
2747                 }
2748                 strcat(bufx,")");
2749 #ifdef AAL_ARGCHECK
2750                 if ( !ael_is_funcname((yyvsp[(1) - (5)].pval)->u1.str) )
2751                         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",
2752                                 my_file, (yylsp[(1) - (5)]).first_line, (yylsp[(1) - (5)]).first_column, (yylsp[(1) - (5)]).last_column, (yyvsp[(1) - (5)].pval)->u1.str);
2753 #endif
2754                 (yyval.pval)->u1.str = bufx;
2755                 destroy_pval((yyvsp[(1) - (5)].pval)); /* the app call it is not, get rid of that chain */
2756                 prev_word = 0;
2757         ;}
2758     break;
2759
2760   case 91:
2761 #line 535 "ael.y"
2762     { (yyval.pval) = npval2(PV_BREAK, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); ;}
2763     break;
2764
2765   case 92:
2766 #line 536 "ael.y"
2767     { (yyval.pval) = npval2(PV_RETURN, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); ;}
2768     break;
2769
2770   case 93:
2771 #line 537 "ael.y"
2772     { (yyval.pval) = npval2(PV_CONTINUE, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); ;}
2773     break;
2774
2775   case 94:
2776 #line 538 "ael.y"
2777     {
2778                 (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(2) - (3)]));
2779                 (yyval.pval)->u2.statements = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval));
2780                 (yyval.pval)->u3.else_statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));;}
2781     break;
2782
2783   case 95:
2784 #line 542 "ael.y"
2785     { (yyval.pval)=0; ;}
2786     break;
2787
2788   case 96:
2789 #line 545 "ael.y"
2790     { (yyval.pval) = (yyvsp[(2) - (2)].pval); ;}
2791     break;
2792
2793   case 97:
2794 #line 546 "ael.y"
2795     { (yyval.pval) = NULL ; ;}
2796     break;
2797
2798   case 98:
2799 #line 549 "ael.y"
2800     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); ;}
2801     break;
2802
2803   case 99:
2804 #line 550 "ael.y"
2805     {
2806                 (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
2807                 (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); ;}
2808     break;
2809
2810   case 100:
2811 #line 553 "ael.y"
2812     {
2813                 (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
2814                 (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); ;}
2815     break;
2816
2817   case 101:
2818 #line 556 "ael.y"
2819     {
2820                 (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)]));
2821                 (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
2822                 (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); ;}
2823     break;
2824
2825   case 102:
2826 #line 560 "ael.y"
2827     {
2828                 (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)]));
2829                 (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
2830                 (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); ;}
2831     break;
2832
2833   case 103:
2834 #line 564 "ael.y"
2835     {
2836                 (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)]));
2837                 (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
2838                 (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); ;}
2839     break;
2840
2841   case 104:
2842 #line 568 "ael.y"
2843     {
2844                 (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)]));
2845                 (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
2846                 (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); ;}
2847     break;
2848
2849   case 105:
2850 #line 574 "ael.y"
2851     { (yyval.str) = strdup("1"); ;}
2852     break;
2853
2854   case 106:
2855 #line 575 "ael.y"
2856     { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
2857     break;
2858
2859   case 107:
2860 #line 579 "ael.y"
2861     {                   /* ext[, pri] default 1 */
2862                 (yyval.pval) = nword((yyvsp[(1) - (2)].str), &(yylsp[(1) - (2)]));
2863                 (yyval.pval)->next = nword((yyvsp[(2) - (2)].str), &(yylsp[(2) - (2)])); ;}
2864     break;
2865
2866   case 108:
2867 #line 582 "ael.y"
2868     {   /* context, ext, pri */
2869                 (yyval.pval) = nword((yyvsp[(4) - (4)].str), &(yylsp[(4) - (4)]));
2870                 (yyval.pval)->next = nword((yyvsp[(1) - (4)].str), &(yylsp[(1) - (4)]));
2871                 (yyval.pval)->next->next = nword((yyvsp[(2) - (4)].str), &(yylsp[(2) - (4)])); ;}
2872     break;
2873
2874   case 109:
2875 #line 588 "ael.y"
2876     {reset_argcount(parseio->scanner);;}
2877     break;
2878
2879   case 110:
2880 #line 588 "ael.y"
2881     {
2882                 /* XXX original code had @2 but i think we need @5 */
2883                 (yyval.pval) = npval2(PV_MACRO_CALL, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
2884                 (yyval.pval)->u1.str = (yyvsp[(1) - (5)].str);
2885                 (yyval.pval)->u2.arglist = (yyvsp[(4) - (5)].pval);;}
2886     break;
2887
2888   case 111:
2889 #line 593 "ael.y"
2890     {
2891                 (yyval.pval)= npval2(PV_MACRO_CALL, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
2892                 (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str); ;}
2893     break;
2894
2895   case 112:
2896 #line 601 "ael.y"
2897     {reset_argcount(parseio->scanner);;}
2898     break;
2899
2900   case 113:
2901 #line 601 "ael.y"
2902     {
2903                 if (strcasecmp((yyvsp[(1) - (3)].str),"goto") == 0) {
2904                         (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)]));
2905                         free((yyvsp[(1) - (3)].str)); /* won't be using this */
2906                         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 );
2907                 } else {
2908                         (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)]));
2909                         (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str);
2910                 } ;}
2911     break;
2912
2913   case 114:
2914 #line 612 "ael.y"
2915     {
2916                 (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(3) - (3)]));
2917                 if( (yyval.pval)->type == PV_GOTO )
2918                         (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);
2919                 else
2920                         (yyval.pval)->u2.arglist = (yyvsp[(2) - (3)].pval);
2921         ;}
2922     break;
2923
2924   case 115:
2925 #line 619 "ael.y"
2926     { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); ;}
2927     break;
2928
2929   case 116:
2930 #line 622 "ael.y"
2931     { (yyval.str) = (yyvsp[(1) - (1)].str) ;}
2932     break;
2933
2934   case 117:
2935 #line 623 "ael.y"
2936     { (yyval.str) = strdup(""); ;}
2937     break;
2938
2939   case 118:
2940 #line 626 "ael.y"
2941     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); ;}
2942     break;
2943
2944   case 119:
2945 #line 627 "ael.y"
2946     {
2947                 (yyval.pval)= npval(PV_WORD,0/*@1.first_line*/,0/*@1.last_line*/,0/* @1.first_column*/, 0/*@1.last_column*/);
2948                 (yyval.pval)->u1.str = strdup(""); ;}
2949     break;
2950
2951   case 120:
2952 #line 630 "ael.y"
2953     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)]))); ;}
2954     break;
2955
2956   case 121:
2957 #line 633 "ael.y"
2958     { (yyval.pval) = NULL; ;}
2959     break;
2960
2961   case 122:
2962 #line 634 "ael.y"
2963     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); ;}
2964     break;
2965
2966   case 123:
2967 #line 637 "ael.y"
2968     {
2969                 (yyval.pval) = npval2(PV_CASE, &(yylsp[(1) - (4)]), &(yylsp[(3) - (4)])); /* XXX 3 or 4 ? */
2970                 (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
2971                 (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval); set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));;}
2972     break;
2973
2974   case 124:
2975 #line 641 "ael.y"
2976     {
2977                 (yyval.pval) = npval2(PV_DEFAULT, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
2978                 (yyval.pval)->u1.str = NULL;
2979                 (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));;}
2980     break;
2981
2982   case 125:
2983 #line 645 "ael.y"
2984     {
2985                 (yyval.pval) = npval2(PV_PATTERN, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)])); /* XXX@3 or @4 ? */
2986                 (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
2987                 (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval);set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));;}
2988     break;
2989
2990   case 126:
2991 #line 651 "ael.y"
2992     { (yyval.pval) = NULL; ;}
2993     break;
2994
2995   case 127:
2996 #line 652 "ael.y"
2997     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); ;}
2998     break;
2999
3000   case 128:
3001 #line 655 "ael.y"
3002     {(yyval.pval)=(yyvsp[(1) - (1)].pval);;}
3003     break;
3004
3005   case 129:
3006 #line 656 "ael.y"
3007     { (yyval.pval)=(yyvsp[(1) - (1)].pval);;}
3008     break;
3009
3010   case 130:
3011 #line 657 "ael.y"
3012     {
3013                 (yyval.pval) = npval2(PV_CATCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
3014                 (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str);
3015                 (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));;}
3016     break;
3017
3018   case 131:
3019 #line 663 "ael.y"
3020     {
3021                 (yyval.pval) = npval2(PV_SWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)]));
3022                 (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));;}
3023     break;
3024
3025   case 132:
3026 #line 668 "ael.y"
3027     {
3028                 (yyval.pval) = npval2(PV_ESWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)]));
3029                 (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));;}
3030     break;
3031
3032   case 133:
3033 #line 673 "ael.y"
3034     { (yyval.pval) = NULL; ;}
3035     break;
3036
3037   case 134:
3038 #line 674 "ael.y"
3039     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval),nword((yyvsp[(2) - (3)].str), &(yylsp[(2) - (3)]))); ;}
3040     break;
3041
3042   case 135:
3043 #line 675 "ael.y"
3044     {
3045           char *x;
3046           if (asprintf(&x,"%s@%s", (yyvsp[(2) - (5)].str), (yyvsp[(4) - (5)].str)) < 0) {
3047                 ast_log(LOG_WARNING, "asprintf() failed\n");
3048                 (yyval.pval) = NULL;
3049           } else {
3050                 free((yyvsp[(2) - (5)].str));
3051                 free((yyvsp[(4) - (5)].str));
3052                 (yyval.pval) = linku1((yyvsp[(1) - (5)].pval),nword(x, &(yylsp[(2) - (5)])));
3053           }
3054         ;}
3055     break;
3056
3057   case 136:
3058 #line 686 "ael.y"
3059     {(yyval.pval)=(yyvsp[(2) - (2)].pval);;}
3060     break;
3061
3062   case 137:
3063 #line 689 "ael.y"
3064     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); ;}
3065     break;
3066
3067   case 138:
3068 #line 690 "ael.y"
3069     {
3070                 (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
3071                 (yyval.pval)->u2.arglist = (yyvsp[(3) - (3)].pval);
3072                 prev_word=0; /* XXX sure ? */ ;}
3073     break;
3074
3075   case 139:
3076 #line 697 "ael.y"
3077     { (yyval.pval) = (yyvsp[(1) - (2)].pval); ;}
3078     break;
3079
3080   case 140:
3081 #line 698 "ael.y"
3082     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), (yyvsp[(2) - (3)].pval)); ;}
3083     break;
3084
3085   case 141:
3086 #line 699 "ael.y"
3087     {(yyval.pval)=(yyvsp[(1) - (2)].pval);;}
3088     break;
3089
3090   case 142:
3091 #line 702 "ael.y"
3092     {
3093                 (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
3094                 (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval);set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));;}
3095     break;
3096
3097   case 143:
3098 #line 705 "ael.y"
3099     {
3100                 (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));;}
3101     break;
3102
3103
3104 /* Line 1267 of yacc.c.  */
3105 #line 3106 "ael.tab.c"
3106       default: break;
3107     }
3108   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3109
3110   YYPOPSTACK (yylen);
3111   yylen = 0;
3112   YY_STACK_PRINT (yyss, yyssp);
3113
3114   *++yyvsp = yyval;
3115   *++yylsp = yyloc;
3116
3117   /* Now `shift' the result of the reduction.  Determine what state
3118      that goes to, based on the state we popped back to and the rule
3119      number reduced by.  */
3120
3121   yyn = yyr1[yyn];
3122
3123   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3124   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3125     yystate = yytable[yystate];
3126   else
3127     yystate = yydefgoto[yyn - YYNTOKENS];
3128
3129   goto yynewstate;
3130
3131
3132 /*------------------------------------.
3133 | yyerrlab -- here on detecting error |
3134 `------------------------------------*/
3135 yyerrlab:
3136   /* If not already recovering from an error, report this error.  */
3137   if (!yyerrstatus)
3138     {
3139       ++yynerrs;
3140 #if ! YYERROR_VERBOSE
3141       yyerror (&yylloc, parseio, YY_("syntax error"));
3142 #else
3143       {
3144         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
3145         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
3146           {
3147             YYSIZE_T yyalloc = 2 * yysize;
3148             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
3149               yyalloc = YYSTACK_ALLOC_MAXIMUM;
3150             if (yymsg != yymsgbuf)
3151               YYSTACK_FREE (yymsg);
3152             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
3153             if (yymsg)
3154               yymsg_alloc = yyalloc;
3155             else
3156               {
3157                 yymsg = yymsgbuf;
3158                 yymsg_alloc = sizeof yymsgbuf;
3159               }
3160           }
3161
3162         if (0 < yysize && yysize <= yymsg_alloc)
3163           {
3164             (void) yysyntax_error (yymsg, yystate, yychar);
3165             yyerror (&yylloc, parseio, yymsg);
3166           }
3167         else
3168           {
3169             yyerror (&yylloc, parseio, YY_("syntax error"));
3170             if (yysize != 0)
3171               goto yyexhaustedlab;
3172           }
3173       }
3174 #endif
3175     }
3176
3177   yyerror_range[0] = yylloc;
3178
3179   if (yyerrstatus == 3)
3180     {
3181       /* If just tried and failed to reuse look-ahead token after an
3182          error, discard it.  */
3183
3184       if (yychar <= YYEOF)
3185         {
3186           /* Return failure if at end of input.  */
3187           if (yychar == YYEOF)
3188             YYABORT;
3189         }
3190       else
3191         {
3192           yydestruct ("Error: discarding",
3193                       yytoken, &yylval, &yylloc, parseio);
3194           yychar = YYEMPTY;
3195         }
3196     }
3197
3198   /* Else will try to reuse look-ahead token after shifting the error
3199      token.  */
3200   goto yyerrlab1;
3201
3202
3203 /*---------------------------------------------------.
3204 | yyerrorlab -- error raised explicitly by YYERROR.  |
3205 `---------------------------------------------------*/
3206 yyerrorlab:
3207
3208   /* Pacify compilers like GCC when the user code never invokes
3209      YYERROR and the label yyerrorlab therefore never appears in user
3210      code.  */
3211   if (/*CONSTCOND*/ 0)
3212      goto yyerrorlab;
3213
3214   yyerror_range[0] = yylsp[1-yylen];
3215   /* Do not reclaim the symbols of the rule which action triggered
3216      this YYERROR.  */
3217   YYPOPSTACK (yylen);
3218   yylen = 0;
3219   YY_STACK_PRINT (yyss, yyssp);
3220   yystate = *yyssp;
3221   goto yyerrlab1;
3222
3223
3224 /*-------------------------------------------------------------.
3225 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
3226 `-------------------------------------------------------------*/
3227 yyerrlab1:
3228   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
3229
3230   for (;;)
3231     {
3232       yyn = yypact[yystate];
3233       if (yyn != YYPACT_NINF)
3234         {
3235           yyn += YYTERROR;
3236           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3237             {
3238               yyn = yytable[yyn];
3239               if (0 < yyn)
3240                 break;
3241             }
3242         }
3243
3244       /* Pop the current state because it cannot handle the error token.  */
3245       if (yyssp == yyss)
3246         YYABORT;
3247
3248       yyerror_range[0] = *yylsp;
3249       yydestruct ("Error: popping",
3250                   yystos[yystate], yyvsp, yylsp, parseio);
3251       YYPOPSTACK (1);
3252       yystate = *yyssp;
3253       YY_STACK_PRINT (yyss, yyssp);
3254     }
3255
3256   if (yyn == YYFINAL)
3257     YYACCEPT;
3258
3259   *++yyvsp = yylval;
3260
3261   yyerror_range[1] = yylloc;
3262   /* Using YYLLOC is tempting, but would change the location of
3263      the look-ahead.  YYLOC is available though.  */
3264   YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
3265   *++yylsp = yyloc;
3266
3267   /* Shift the error token.  */
3268   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3269
3270   yystate = yyn;
3271   goto yynewstate;
3272
3273
3274 /*-------------------------------------.
3275 | yyacceptlab -- YYACCEPT comes here.  |
3276 `-------------------------------------*/
3277 yyacceptlab:
3278   yyresult = 0;
3279   goto yyreturn;
3280
3281 /*-----------------------------------.
3282 | yyabortlab -- YYABORT comes here.  |
3283 `-----------------------------------*/
3284 yyabortlab:
3285   yyresult = 1;
3286   goto yyreturn;
3287
3288 #ifndef yyoverflow
3289 /*-------------------------------------------------.
3290 | yyexhaustedlab -- memory exhaustion comes here.  |
3291 `-------------------------------------------------*/
3292 yyexhaustedlab:
3293   yyerror (&yylloc, parseio, YY_("memory exhausted"));
3294   yyresult = 2;
3295   /* Fall through.  */
3296 #endif
3297
3298 yyreturn:
3299   if (yychar != YYEOF && yychar != YYEMPTY)
3300      yydestruct ("Cleanup: discarding lookahead",
3301                  yytoken, &yylval, &yylloc, parseio);
3302   /* Do not reclaim the symbols of the rule which action triggered
3303      this YYABORT or YYACCEPT.  */
3304   YYPOPSTACK (yylen);
3305   YY_STACK_PRINT (yyss, yyssp);
3306   while (yyssp != yyss)
3307     {
3308       yydestruct ("Cleanup: popping",
3309                   yystos[*yyssp], yyvsp, yylsp, parseio);
3310       YYPOPSTACK (1);
3311     }
3312 #ifndef yyoverflow
3313   if (yyss != yyssa)
3314     YYSTACK_FREE (yyss);
3315 #endif
3316 #if YYERROR_VERBOSE
3317   if (yymsg != yymsgbuf)
3318     YYSTACK_FREE (yymsg);
3319 #endif
3320   /* Make sure YYID is used.  */
3321   return YYID (yyresult);
3322 }
3323
3324
3325 #line 710 "ael.y"
3326
3327
3328 static char *token_equivs1[] =
3329 {
3330         "AMPER",
3331         "AT",
3332         "BAR",
3333         "COLON",
3334         "COMMA",
3335         "EQ",
3336         "EXTENMARK",
3337         "KW_BREAK",
3338         "KW_CASE",
3339         "KW_CATCH",
3340         "KW_CONTEXT",
3341         "KW_CONTINUE",
3342         "KW_DEFAULT",
3343         "KW_ELSE",
3344         "KW_ESWITCHES",
3345         "KW_FOR",
3346         "KW_GLOBALS",
3347         "KW_GOTO",
3348         "KW_HINT",
3349         "KW_IFTIME",
3350         "KW_IF",
3351         "KW_IGNOREPAT",
3352         "KW_INCLUDES"
3353         "KW_JUMP",
3354         "KW_MACRO",
3355         "KW_PATTERN",
3356         "KW_REGEXTEN",
3357         "KW_RETURN",
3358         "KW_SWITCHES",
3359         "KW_SWITCH",
3360         "KW_WHILE",
3361         "LC",
3362         "LP",
3363         "RC",
3364         "RP",
3365         "SEMI",
3366 };
3367
3368 static char *token_equivs2[] =
3369 {
3370         "&",
3371         "@",
3372         "|",
3373         ":",
3374         ",",
3375         "=",
3376         "=>",
3377         "break",
3378         "case",
3379         "catch",
3380         "context",
3381         "continue",
3382         "default",
3383         "else",
3384         "eswitches",
3385         "for",
3386         "globals",
3387         "goto",
3388         "hint",
3389         "ifTime",
3390         "if",
3391         "ignorepat",
3392         "includes"
3393         "jump",
3394         "macro",
3395         "pattern",
3396         "regexten",
3397         "return",
3398         "switches",
3399         "switch",
3400         "while",
3401         "{",
3402         "(",
3403         "}",
3404         ")",
3405         ";",
3406 };
3407
3408
3409 static char *ael_token_subst(const char *mess)
3410 {
3411         /* calc a length, malloc, fill, and return; yyerror had better free it! */
3412         int len=0,i;
3413         const char *p;
3414         char *res, *s,*t;
3415         int token_equivs_entries = sizeof(token_equivs1)/sizeof(char*);
3416
3417         for (p=mess; *p; p++) {
3418                 for (i=0; i<token_equivs_entries; i++) {
3419                         if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 )
3420                         {
3421                                 len+=strlen(token_equivs2[i])+2;
3422                                 p += strlen(token_equivs1[i])-1;
3423                                 break;
3424                         }
3425                 }
3426                 len++;
3427         }
3428         res = calloc(1, len+1);
3429         res[0] = 0;
3430         s = res;
3431         for (p=mess; *p;) {
3432                 int found = 0;
3433                 for (i=0; i<token_equivs_entries; i++) {
3434                         if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 ) {
3435                                 *s++ = '\'';
3436                                 for (t=token_equivs2[i]; *t;) {
3437                                         *s++ = *t++;
3438                                 }
3439                                 *s++ = '\'';
3440                                 p += strlen(token_equivs1[i]);
3441                                 found = 1;
3442                                 break;
3443                         }
3444                 }
3445                 if( !found )
3446                         *s++ = *p++;
3447         }
3448         *s++ = 0;
3449         return res;
3450 }
3451
3452 void yyerror(YYLTYPE *locp, struct parse_io *parseio,  char const *s)
3453 {
3454         char *s2 = ael_token_subst((char *)s);
3455         if (locp->first_line == locp->last_line) {
3456                 ast_log(LOG_ERROR, "==== File: %s, Line %d, Cols: %d-%d: Error: %s\n", my_file, locp->first_line, locp->first_column, locp->last_column, s2);
3457         } else {
3458                 ast_log(LOG_ERROR, "==== File: %s, Line %d Col %d  to Line %d Col %d: Error: %s\n", my_file, locp->first_line, locp->first_column, locp->last_line, locp->last_column, s2);
3459         }
3460         free(s2);
3461         parseio->syntax_error_count++;
3462 }
3463
3464 struct pval *npval(pvaltype type, int first_line, int last_line,
3465         int first_column, int last_column)
3466 {
3467         pval *z = calloc(1, sizeof(struct pval));
3468         z->type = type;
3469         z->startline = first_line;
3470         z->endline = last_line;
3471         z->startcol = first_column;
3472         z->endcol = last_column;
3473         z->filename = strdup(my_file);
3474         return z;
3475 }
3476
3477 static struct pval *npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last)
3478 {
3479         return npval(type, first->first_line, last->last_line,
3480                         first->first_column, last->last_column);
3481 }
3482
3483 static struct pval *update_last(pval *obj, YYLTYPE *last)
3484 {
3485         obj->endline = last->last_line;
3486         obj->endcol = last->last_column;
3487         return obj;
3488 }
3489
3490 /* frontend for npval to create a PV_WORD string from the given token */
3491 static pval *nword(char *string, YYLTYPE *pos)
3492 {
3493         pval *p = npval2(PV_WORD, pos, pos);
3494         if (p)
3495                 p->u1.str = string;
3496         return p;
3497 }
3498
3499 /* this routine adds a dad ptr to each element in the list */
3500 static void set_dads(struct pval *dad, struct pval *child_list)
3501 {
3502         struct pval *t;
3503         
3504         for(t=child_list;t;t=t->next)  /* simple stuff */
3505                 t->dad = dad;
3506 }
3507
3508