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