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