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