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