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