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