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