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