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