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