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