Wed Jan 8 2020 09:49:39

Asterisk developer's documentation


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