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