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