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