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