ael.tab.c

Go to the documentation of this file.
00001 /* A Bison parser, made by GNU Bison 2.5.  */
00002 
00003 /* Bison implementation for Yacc-like parsers in C
00004    
00005       Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
00006    
00007    This program is free software: you can redistribute it and/or modify
00008    it under the terms of the GNU General Public License as published by
00009    the Free Software Foundation, either version 3 of the License, or
00010    (at your option) any later version.
00011    
00012    This program is distributed in the hope that it will be useful,
00013    but WITHOUT ANY WARRANTY; without even the implied warranty of
00014    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015    GNU General Public License for more details.
00016    
00017    You should have received a copy of the GNU General Public License
00018    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
00019 
00020 /* As a special exception, you may create a larger work that contains
00021    part or all of the Bison parser skeleton and distribute that work
00022    under terms of your choice, so long as that work isn't itself a
00023    parser generator using the skeleton or a modified version thereof
00024    as a parser skeleton.  Alternatively, if you modify or redistribute
00025    the parser skeleton itself, you may (at your option) remove this
00026    special exception, which will cause the skeleton and the resulting
00027    Bison output files to be licensed under the GNU General Public
00028    License without this special exception.
00029    
00030    This special exception was added by the Free Software Foundation in
00031    version 2.2 of Bison.  */
00032 
00033 /* C LALR(1) parser skeleton written by Richard Stallman, by
00034    simplifying the original so-called "semantic" parser.  */
00035 
00036 /* All symbols defined below should begin with yy or YY, to avoid
00037    infringing on user name space.  This should be done even for local
00038    variables, as they might otherwise be expanded by user macros.
00039    There are some unavoidable exceptions within include files to
00040    define necessary library symbols; they are noted "INFRINGES ON
00041    USER NAME SPACE" below.  */
00042 
00043 /* Identify Bison output.  */
00044 #define YYBISON 1
00045 
00046 /* Bison version.  */
00047 #define YYBISON_VERSION "2.5"
00048 
00049 /* Skeleton name.  */
00050 #define YYSKELETON_NAME "yacc.c"
00051 
00052 /* Pure parsers.  */
00053 #define YYPURE 1
00054 
00055 /* Push parsers.  */
00056 #define YYPUSH 0
00057 
00058 /* Pull parsers.  */
00059 #define YYPULL 1
00060 
00061 /* Using locations.  */
00062 #define YYLSP_NEEDED 1
00063 
00064 /* Substitute the variable and function names.  */
00065 #define yyparse         ael_yyparse
00066 #define yylex           ael_yylex
00067 #define yyerror         ael_yyerror
00068 #define yylval          ael_yylval
00069 #define yychar          ael_yychar
00070 #define yydebug         ael_yydebug
00071 #define yynerrs         ael_yynerrs
00072 #define yylloc          ael_yylloc
00073 
00074 /* Copy the first part of user declarations.  */
00075 
00076 /* Line 268 of yacc.c  */
00077 #line 1 "ael.y"
00078 
00079 /*
00080  * Asterisk -- An open source telephony toolkit.
00081  *
00082  * Copyright (C) 2006, Digium, Inc.
00083  *
00084  * Steve Murphy <murf@parsetree.com>
00085  *
00086  * See http://www.asterisk.org for more information about
00087  * the Asterisk project. Please do not directly contact
00088  * any of the maintainers of this project for assistance;
00089  * the project provides a web site, mailing lists and IRC
00090  * channels for your use.
00091  *
00092  * This program is free software, distributed under the terms of
00093  * the GNU General Public License Version 2. See the LICENSE file
00094  * at the top of the source tree.
00095  */
00096 /*! \file
00097  *
00098  * \brief Bison Grammar description of AEL2.
00099  *
00100  */
00101 
00102 #define WRAP_LIBC_MALLOC
00103 #include "asterisk.h"
00104 
00105 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 423978 $")
00106 
00107 #include <stdio.h>
00108 #include <stdlib.h>
00109 #include <string.h>
00110 
00111 #include "asterisk/logger.h"
00112 #include "asterisk/lock.h"
00113 #include "asterisk/hashtab.h"
00114 #include "asterisk/ael_structs.h"
00115 #include "asterisk/utils.h"
00116 
00117 extern struct ast_flags ast_compat;
00118 
00119 pval * linku1(pval *head, pval *tail);
00120 static void set_dads(pval *dad, pval *child_list);
00121 void reset_parencount(yyscan_t yyscanner);
00122 void reset_semicount(yyscan_t yyscanner);
00123 void reset_argcount(yyscan_t yyscanner );
00124  
00125 #define YYLEX_PARAM ((struct parse_io *)parseio)->scanner
00126 #define YYERROR_VERBOSE 1
00127 
00128 extern char *my_file;
00129 #ifdef AAL_ARGCHECK
00130 int ael_is_funcname(char *name);
00131 #endif
00132 static char *ael_token_subst(const char *mess);
00133 
00134 
00135 
00136 /* Line 268 of yacc.c  */
00137 #line 137 "ael.tab.c"
00138 
00139 /* Enabling traces.  */
00140 #ifndef YYDEBUG
00141 # define YYDEBUG 0
00142 #endif
00143 
00144 /* Enabling verbose error messages.  */
00145 #ifdef YYERROR_VERBOSE
00146 # undef YYERROR_VERBOSE
00147 # define YYERROR_VERBOSE 1
00148 #else
00149 # define YYERROR_VERBOSE 1
00150 #endif
00151 
00152 /* Enabling the token table.  */
00153 #ifndef YYTOKEN_TABLE
00154 # define YYTOKEN_TABLE 0
00155 #endif
00156 
00157 
00158 /* Tokens.  */
00159 #ifndef YYTOKENTYPE
00160 # define YYTOKENTYPE
00161    /* Put the tokens into the symbol table, so that GDB and other debuggers
00162       know about them.  */
00163    enum yytokentype {
00164      KW_CONTEXT = 258,
00165      LC = 259,
00166      RC = 260,
00167      LP = 261,
00168      RP = 262,
00169      SEMI = 263,
00170      EQ = 264,
00171      COMMA = 265,
00172      COLON = 266,
00173      AMPER = 267,
00174      BAR = 268,
00175      AT = 269,
00176      KW_MACRO = 270,
00177      KW_GLOBALS = 271,
00178      KW_IGNOREPAT = 272,
00179      KW_SWITCH = 273,
00180      KW_IF = 274,
00181      KW_IFTIME = 275,
00182      KW_ELSE = 276,
00183      KW_RANDOM = 277,
00184      KW_ABSTRACT = 278,
00185      KW_EXTEND = 279,
00186      EXTENMARK = 280,
00187      KW_GOTO = 281,
00188      KW_JUMP = 282,
00189      KW_RETURN = 283,
00190      KW_BREAK = 284,
00191      KW_CONTINUE = 285,
00192      KW_REGEXTEN = 286,
00193      KW_HINT = 287,
00194      KW_FOR = 288,
00195      KW_WHILE = 289,
00196      KW_CASE = 290,
00197      KW_PATTERN = 291,
00198      KW_DEFAULT = 292,
00199      KW_CATCH = 293,
00200      KW_SWITCHES = 294,
00201      KW_ESWITCHES = 295,
00202      KW_INCLUDES = 296,
00203      KW_LOCAL = 297,
00204      word = 298
00205    };
00206 #endif
00207 
00208 
00209 
00210 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00211 typedef union YYSTYPE
00212 {
00213 
00214 /* Line 293 of yacc.c  */
00215 #line 59 "ael.y"
00216 
00217    int   intval;     /* integer value, typically flags */
00218    char  *str;    /* strings */
00219    struct pval *pval;   /* full objects */
00220 
00221 
00222 
00223 /* Line 293 of yacc.c  */
00224 #line 224 "ael.tab.c"
00225 } YYSTYPE;
00226 # define YYSTYPE_IS_TRIVIAL 1
00227 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00228 # define YYSTYPE_IS_DECLARED 1
00229 #endif
00230 
00231 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
00232 typedef struct YYLTYPE
00233 {
00234   int first_line;
00235   int first_column;
00236   int last_line;
00237   int last_column;
00238 } YYLTYPE;
00239 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
00240 # define YYLTYPE_IS_DECLARED 1
00241 # define YYLTYPE_IS_TRIVIAL 1
00242 #endif
00243 
00244 
00245 /* Copy the second part of user declarations.  */
00246 
00247 /* Line 343 of yacc.c  */
00248 #line 65 "ael.y"
00249 
00250    /* declaring these AFTER the union makes things a lot simpler! */
00251 void yyerror(YYLTYPE *locp, struct parse_io *parseio, char const *s);
00252 int ael_yylex (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , void * yyscanner);
00253 
00254 /* create a new object with start-end marker */
00255 pval *npval(pvaltype type, int first_line, int last_line,
00256    int first_column, int last_column);
00257 
00258 /* create a new object with start-end marker, simplified interface.
00259  * Must be declared here because YYLTYPE is not known before
00260  */
00261 static pval *npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last);
00262 
00263 /* another frontend for npval, this time for a string */
00264 static pval *nword(char *string, YYLTYPE *pos);
00265 
00266 /* update end position of an object, return the object */
00267 static pval *update_last(pval *, YYLTYPE *);
00268 
00269 
00270 /* Line 343 of yacc.c  */
00271 #line 271 "ael.tab.c"
00272 
00273 #ifdef short
00274 # undef short
00275 #endif
00276 
00277 #ifdef YYTYPE_UINT8
00278 typedef YYTYPE_UINT8 yytype_uint8;
00279 #else
00280 typedef unsigned char yytype_uint8;
00281 #endif
00282 
00283 #ifdef YYTYPE_INT8
00284 typedef YYTYPE_INT8 yytype_int8;
00285 #elif (defined __STDC__ || defined __C99__FUNC__ \
00286      || defined __cplusplus || defined _MSC_VER)
00287 typedef signed char yytype_int8;
00288 #else
00289 typedef short int yytype_int8;
00290 #endif
00291 
00292 #ifdef YYTYPE_UINT16
00293 typedef YYTYPE_UINT16 yytype_uint16;
00294 #else
00295 typedef unsigned short int yytype_uint16;
00296 #endif
00297 
00298 #ifdef YYTYPE_INT16
00299 typedef YYTYPE_INT16 yytype_int16;
00300 #else
00301 typedef short int yytype_int16;
00302 #endif
00303 
00304 #ifndef YYSIZE_T
00305 # ifdef __SIZE_TYPE__
00306 #  define YYSIZE_T __SIZE_TYPE__
00307 # elif defined size_t
00308 #  define YYSIZE_T size_t
00309 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00310      || defined __cplusplus || defined _MSC_VER)
00311 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00312 #  define YYSIZE_T size_t
00313 # else
00314 #  define YYSIZE_T unsigned int
00315 # endif
00316 #endif
00317 
00318 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00319 
00320 #ifndef YY_
00321 # if defined YYENABLE_NLS && YYENABLE_NLS
00322 #  if ENABLE_NLS
00323 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00324 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00325 #  endif
00326 # endif
00327 # ifndef YY_
00328 #  define YY_(msgid) msgid
00329 # endif
00330 #endif
00331 
00332 /* Suppress unused-variable warnings by "using" E.  */
00333 #if ! defined lint || defined __GNUC__
00334 # define YYUSE(e) ((void) (e))
00335 #else
00336 # define YYUSE(e) /* empty */
00337 #endif
00338 
00339 /* Identity function, used to suppress warnings about constant conditions.  */
00340 #ifndef lint
00341 # define YYID(n) (n)
00342 #else
00343 #if (defined __STDC__ || defined __C99__FUNC__ \
00344      || defined __cplusplus || defined _MSC_VER)
00345 static int
00346 YYID (int yyi)
00347 #else
00348 static int
00349 YYID (yyi)
00350     int yyi;
00351 #endif
00352 {
00353   return yyi;
00354 }
00355 #endif
00356 
00357 #if ! defined yyoverflow || YYERROR_VERBOSE
00358 
00359 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00360 
00361 # ifdef YYSTACK_USE_ALLOCA
00362 #  if YYSTACK_USE_ALLOCA
00363 #   ifdef __GNUC__
00364 #    define YYSTACK_ALLOC __builtin_alloca
00365 #   elif defined __BUILTIN_VA_ARG_INCR
00366 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
00367 #   elif defined _AIX
00368 #    define YYSTACK_ALLOC __alloca
00369 #   elif defined _MSC_VER
00370 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
00371 #    define alloca _alloca
00372 #   else
00373 #    define YYSTACK_ALLOC alloca
00374 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
00375      || defined __cplusplus || defined _MSC_VER)
00376 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00377 #     ifndef EXIT_SUCCESS
00378 #      define EXIT_SUCCESS 0
00379 #     endif
00380 #    endif
00381 #   endif
00382 #  endif
00383 # endif
00384 
00385 # ifdef YYSTACK_ALLOC
00386    /* Pacify GCC's `empty if-body' warning.  */
00387 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
00388 #  ifndef YYSTACK_ALLOC_MAXIMUM
00389     /* The OS might guarantee only one guard page at the bottom of the stack,
00390        and a page size can be as small as 4096 bytes.  So we cannot safely
00391        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
00392        to allow for a few compiler-allocated temporary stack slots.  */
00393 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
00394 #  endif
00395 # else
00396 #  define YYSTACK_ALLOC YYMALLOC
00397 #  define YYSTACK_FREE YYFREE
00398 #  ifndef YYSTACK_ALLOC_MAXIMUM
00399 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00400 #  endif
00401 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
00402        && ! ((defined YYMALLOC || defined malloc) \
00403         && (defined YYFREE || defined free)))
00404 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00405 #   ifndef EXIT_SUCCESS
00406 #    define EXIT_SUCCESS 0
00407 #   endif
00408 #  endif
00409 #  ifndef YYMALLOC
00410 #   define YYMALLOC malloc
00411 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
00412      || defined __cplusplus || defined _MSC_VER)
00413 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
00414 #   endif
00415 #  endif
00416 #  ifndef YYFREE
00417 #   define YYFREE free
00418 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
00419      || defined __cplusplus || defined _MSC_VER)
00420 void free (void *); /* INFRINGES ON USER NAME SPACE */
00421 #   endif
00422 #  endif
00423 # endif
00424 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
00425 
00426 
00427 #if (! defined yyoverflow \
00428      && (! defined __cplusplus \
00429     || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
00430         && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
00431 
00432 /* A type that is properly aligned for any stack member.  */
00433 union yyalloc
00434 {
00435   yytype_int16 yyss_alloc;
00436   YYSTYPE yyvs_alloc;
00437   YYLTYPE yyls_alloc;
00438 };
00439 
00440 /* The size of the maximum gap between one aligned stack and the next.  */
00441 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00442 
00443 /* The size of an array large to enough to hold all stacks, each with
00444    N elements.  */
00445 # define YYSTACK_BYTES(N) \
00446      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
00447       + 2 * YYSTACK_GAP_MAXIMUM)
00448 
00449 # define YYCOPY_NEEDED 1
00450 
00451 /* Relocate STACK from its old location to the new one.  The
00452    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00453    elements in the stack, and YYPTR gives the new location of the
00454    stack.  Advance YYPTR to a properly aligned location for the next
00455    stack.  */
00456 # define YYSTACK_RELOCATE(Stack_alloc, Stack)            \
00457     do                           \
00458       {                          \
00459    YYSIZE_T yynewbytes;                \
00460    YYCOPY (&yyptr->Stack_alloc, Stack, yysize);       \
00461    Stack = &yyptr->Stack_alloc;              \
00462    yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00463    yyptr += yynewbytes / sizeof (*yyptr);          \
00464       }                          \
00465     while (YYID (0))
00466 
00467 #endif
00468 
00469 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
00470 /* Copy COUNT objects from FROM to TO.  The source and destination do
00471    not overlap.  */
00472 # ifndef YYCOPY
00473 #  if defined __GNUC__ && 1 < __GNUC__
00474 #   define YYCOPY(To, From, Count) \
00475       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00476 #  else
00477 #   define YYCOPY(To, From, Count)     \
00478       do             \
00479    {              \
00480      YYSIZE_T yyi;            \
00481      for (yyi = 0; yyi < (Count); yyi++)  \
00482        (To)[yyi] = (From)[yyi];     \
00483    }              \
00484       while (YYID (0))
00485 #  endif
00486 # endif
00487 #endif /* !YYCOPY_NEEDED */
00488 
00489 /* YYFINAL -- State number of the termination state.  */
00490 #define YYFINAL  17
00491 /* YYLAST -- Last index in YYTABLE.  */
00492 #define YYLAST   371
00493 
00494 /* YYNTOKENS -- Number of terminals.  */
00495 #define YYNTOKENS  44
00496 /* YYNNTS -- Number of nonterminals.  */
00497 #define YYNNTS  56
00498 /* YYNRULES -- Number of rules.  */
00499 #define YYNRULES  143
00500 /* YYNRULES -- Number of states.  */
00501 #define YYNSTATES  283
00502 
00503 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00504 #define YYUNDEFTOK  2
00505 #define YYMAXUTOK   298
00506 
00507 #define YYTRANSLATE(YYX)                  \
00508   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00509 
00510 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00511 static const yytype_uint8 yytranslate[] =
00512 {
00513        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00514        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00515        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00516        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00517        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00518        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00519        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00520        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00521        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00522        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00523        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00524        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00525        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00526        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00527        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00528        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00529        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00530        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00531        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00532        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00533        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00534        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00535        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00536        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00537        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00538        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00539        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00540       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
00541       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
00542       35,    36,    37,    38,    39,    40,    41,    42,    43
00543 };
00544 
00545 #if YYDEBUG
00546 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00547    YYRHS.  */
00548 static const yytype_uint16 yyprhs[] =
00549 {
00550        0,     0,     3,     5,     7,    10,    13,    15,    17,    19,
00551       21,    23,    25,    32,    34,    35,    37,    40,    43,    52,
00552       57,    58,    61,    64,    65,    71,    72,    79,    80,    82,
00553       86,    89,    90,    93,    96,    98,   100,   102,   104,   106,
00554      108,   110,   113,   115,   120,   124,   130,   135,   143,   152,
00555      153,   156,   159,   165,   167,   175,   176,   181,   184,   187,
00556      192,   194,   197,   199,   202,   206,   210,   214,   216,   219,
00557      223,   225,   228,   232,   238,   242,   244,   246,   250,   254,
00558      257,   258,   259,   260,   273,   277,   279,   283,   286,   289,
00559      290,   296,   299,   302,   305,   309,   311,   314,   315,   317,
00560      321,   325,   331,   337,   343,   349,   350,   353,   356,   361,
00561      362,   368,   372,   373,   377,   381,   384,   386,   387,   389,
00562      390,   394,   395,   398,   403,   407,   412,   413,   416,   418,
00563      420,   426,   431,   436,   437,   441,   447,   450,   452,   456,
00564      459,   463,   466,   471
00565 };
00566 
00567 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
00568 static const yytype_int8 yyrhs[] =
00569 {
00570       45,     0,    -1,    46,    -1,    47,    -1,    46,    47,    -1,
00571       46,     1,    -1,    49,    -1,    51,    -1,    52,    -1,     8,
00572       -1,    43,    -1,    37,    -1,    50,     3,    48,     4,    59,
00573        5,    -1,    23,    -1,    -1,    24,    -1,    24,    23,    -1,
00574       23,    24,    -1,    15,    43,     6,    58,     7,     4,    92,
00575        5,    -1,    16,     4,    53,     5,    -1,    -1,    53,    54,
00576       -1,     1,    53,    -1,    -1,    43,     9,    55,    43,     8,
00577       -1,    -1,    42,    43,     9,    57,    43,     8,    -1,    -1,
00578       43,    -1,    58,    10,    43,    -1,    58,     1,    -1,    -1,
00579       59,    60,    -1,     1,    59,    -1,    62,    -1,    99,    -1,
00580       94,    -1,    95,    -1,    61,    -1,    54,    -1,    56,    -1,
00581       43,     1,    -1,     8,    -1,    17,    25,    43,     8,    -1,
00582       43,    25,    74,    -1,    43,    14,    43,    25,    74,    -1,
00583       31,    43,    25,    74,    -1,    32,     6,    70,     7,    43,
00584       25,    74,    -1,    31,    32,     6,    70,     7,    43,    25,
00585       74,    -1,    -1,    63,    74,    -1,     1,    63,    -1,    71,
00586       11,    71,    11,    71,    -1,    43,    -1,    64,    13,    71,
00587       13,    71,    13,    71,    -1,    -1,     6,    67,    69,     7,
00588       -1,    19,    66,    -1,    22,    66,    -1,    20,     6,    65,
00589        7,    -1,    43,    -1,    43,    43,    -1,    43,    -1,    70,
00590       43,    -1,    70,    11,    43,    -1,    70,    12,    43,    -1,
00591       70,    14,    43,    -1,    43,    -1,    43,    43,    -1,    43,
00592       43,    43,    -1,    43,    -1,    43,    43,    -1,    72,    11,
00593       43,    -1,    18,    66,     4,    90,     5,    -1,     4,    63,
00594        5,    -1,    54,    -1,    56,    -1,    26,    80,     8,    -1,
00595       27,    82,     8,    -1,    43,    11,    -1,    -1,    -1,    -1,
00596       33,     6,    75,    43,     8,    76,    43,     8,    77,    43,
00597        7,    74,    -1,    34,    66,    74,    -1,    73,    -1,    12,
00598       83,     8,    -1,    87,     8,    -1,    43,     8,    -1,    -1,
00599       87,     9,    78,    43,     8,    -1,    29,     8,    -1,    28,
00600        8,    -1,    30,     8,    -1,    68,    74,    79,    -1,     8,
00601       -1,    21,    74,    -1,    -1,    72,    -1,    72,    13,    72,
00602       -1,    72,    10,    72,    -1,    72,    13,    72,    13,    72,
00603       -1,    72,    10,    72,    10,    72,    -1,    37,    13,    72,
00604       13,    72,    -1,    37,    10,    72,    10,    72,    -1,    -1,
00605       10,    43,    -1,    72,    81,    -1,    72,    81,    14,    48,
00606       -1,    -1,    43,     6,    84,    89,     7,    -1,    43,     6,
00607        7,    -1,    -1,    43,     6,    86,    -1,    85,    89,     7,
00608       -1,    85,     7,    -1,    43,    -1,    -1,    69,    -1,    -1,
00609       89,    10,    88,    -1,    -1,    90,    91,    -1,    35,    43,
00610       11,    63,    -1,    37,    11,    63,    -1,    36,    43,    11,
00611       63,    -1,    -1,    92,    93,    -1,    74,    -1,    99,    -1,
00612       38,    43,     4,    63,     5,    -1,    39,     4,    96,     5,
00613       -1,    40,     4,    96,     5,    -1,    -1,    96,    43,     8,
00614       -1,    96,    43,    14,    43,     8,    -1,     1,    96,    -1,
00615       48,    -1,    48,    13,    65,    -1,    97,     8,    -1,    98,
00616       97,     8,    -1,    98,     1,    -1,    41,     4,    98,     5,
00617       -1,    41,     4,     5,    -1
00618 };
00619 
00620 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00621 static const yytype_uint16 yyrline[] =
00622 {
00623        0,   191,   191,   194,   195,   196,   199,   200,   201,   202,
00624      205,   206,   209,   218,   219,   220,   221,   222,   225,   231,
00625      237,   238,   239,   242,   242,   248,   248,   255,   256,   257,
00626      258,   261,   262,   263,   266,   267,   268,   269,   270,   271,
00627      272,   273,   274,   277,   282,   286,   294,   299,   304,   313,
00628      314,   315,   321,   331,   335,   343,   343,   347,   350,   353,
00629      364,   365,   377,   378,   387,   396,   405,   416,   417,   427,
00630      440,   441,   450,   461,   470,   473,   474,   475,   478,   481,
00631      484,   485,   486,   484,   492,   496,   497,   498,   499,   502,
00632      502,   535,   536,   537,   538,   542,   545,   546,   549,   550,
00633      553,   556,   560,   564,   568,   574,   575,   579,   582,   588,
00634      588,   593,   601,   601,   612,   619,   622,   623,   626,   627,
00635      630,   633,   634,   637,   641,   645,   651,   652,   655,   656,
00636      657,   663,   668,   673,   674,   675,   686,   689,   690,   697,
00637      698,   699,   702,   705
00638 };
00639 #endif
00640 
00641 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00642 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00643    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
00644 static const char *const yytname[] =
00645 {
00646   "$end", "error", "$undefined", "KW_CONTEXT", "LC", "RC", "LP", "RP",
00647   "SEMI", "EQ", "COMMA", "COLON", "AMPER", "BAR", "AT", "KW_MACRO",
00648   "KW_GLOBALS", "KW_IGNOREPAT", "KW_SWITCH", "KW_IF", "KW_IFTIME",
00649   "KW_ELSE", "KW_RANDOM", "KW_ABSTRACT", "KW_EXTEND", "EXTENMARK",
00650   "KW_GOTO", "KW_JUMP", "KW_RETURN", "KW_BREAK", "KW_CONTINUE",
00651   "KW_REGEXTEN", "KW_HINT", "KW_FOR", "KW_WHILE", "KW_CASE", "KW_PATTERN",
00652   "KW_DEFAULT", "KW_CATCH", "KW_SWITCHES", "KW_ESWITCHES", "KW_INCLUDES",
00653   "KW_LOCAL", "word", "$accept", "file", "objects", "object",
00654   "context_name", "context", "opt_abstract", "macro", "globals",
00655   "global_statements", "assignment", "$@1", "local_assignment", "$@2",
00656   "arglist", "elements", "element", "ignorepat", "extension", "statements",
00657   "timerange", "timespec", "test_expr", "$@3", "if_like_head", "word_list",
00658   "hint_word", "word3_list", "goto_word", "switch_statement", "statement",
00659   "$@4", "$@5", "$@6", "$@7", "opt_else", "target", "opt_pri",
00660   "jumptarget", "macro_call", "$@8", "application_call_head", "$@9",
00661   "application_call", "opt_word", "eval_arglist", "case_statements",
00662   "case_statement", "macro_statements", "macro_statement", "switches",
00663   "eswitches", "switchlist", "included_entry", "includeslist", "includes", 0
00664 };
00665 #endif
00666 
00667 # ifdef YYPRINT
00668 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00669    token YYLEX-NUM.  */
00670 static const yytype_uint16 yytoknum[] =
00671 {
00672        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00673      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
00674      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
00675      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
00676      295,   296,   297,   298
00677 };
00678 # endif
00679 
00680 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00681 static const yytype_uint8 yyr1[] =
00682 {
00683        0,    44,    45,    46,    46,    46,    47,    47,    47,    47,
00684       48,    48,    49,    50,    50,    50,    50,    50,    51,    52,
00685       53,    53,    53,    55,    54,    57,    56,    58,    58,    58,
00686       58,    59,    59,    59,    60,    60,    60,    60,    60,    60,
00687       60,    60,    60,    61,    62,    62,    62,    62,    62,    63,
00688       63,    63,    64,    64,    65,    67,    66,    68,    68,    68,
00689       69,    69,    70,    70,    70,    70,    70,    71,    71,    71,
00690       72,    72,    72,    73,    74,    74,    74,    74,    74,    74,
00691       75,    76,    77,    74,    74,    74,    74,    74,    74,    78,
00692       74,    74,    74,    74,    74,    74,    79,    79,    80,    80,
00693       80,    80,    80,    80,    80,    81,    81,    82,    82,    84,
00694       83,    83,    86,    85,    87,    87,    88,    88,    89,    89,
00695       89,    90,    90,    91,    91,    91,    92,    92,    93,    93,
00696       93,    94,    95,    96,    96,    96,    96,    97,    97,    98,
00697       98,    98,    99,    99
00698 };
00699 
00700 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00701 static const yytype_uint8 yyr2[] =
00702 {
00703        0,     2,     1,     1,     2,     2,     1,     1,     1,     1,
00704        1,     1,     6,     1,     0,     1,     2,     2,     8,     4,
00705        0,     2,     2,     0,     5,     0,     6,     0,     1,     3,
00706        2,     0,     2,     2,     1,     1,     1,     1,     1,     1,
00707        1,     2,     1,     4,     3,     5,     4,     7,     8,     0,
00708        2,     2,     5,     1,     7,     0,     4,     2,     2,     4,
00709        1,     2,     1,     2,     3,     3,     3,     1,     2,     3,
00710        1,     2,     3,     5,     3,     1,     1,     3,     3,     2,
00711        0,     0,     0,    12,     3,     1,     3,     2,     2,     0,
00712        5,     2,     2,     2,     3,     1,     2,     0,     1,     3,
00713        3,     5,     5,     5,     5,     0,     2,     2,     4,     0,
00714        5,     3,     0,     3,     3,     2,     1,     0,     1,     0,
00715        3,     0,     2,     4,     3,     4,     0,     2,     1,     1,
00716        5,     4,     4,     0,     3,     5,     2,     1,     3,     2,
00717        3,     2,     4,     3
00718 };
00719 
00720 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
00721    Performed when YYTABLE doesn't specify something else to do.  Zero
00722    means the default is an error.  */
00723 static const yytype_uint8 yydefact[] =
00724 {
00725       14,     9,     0,     0,    13,    15,     0,     0,     3,     6,
00726        0,     7,     8,     0,     0,    17,    16,     1,     5,     4,
00727        0,    27,     0,     0,    11,    10,     0,    28,     0,    22,
00728       19,     0,    21,     0,    30,     0,     0,    23,     0,     0,
00729      126,    29,     0,    33,    12,    42,     0,     0,     0,     0,
00730        0,     0,     0,     0,    39,    40,    32,    38,    34,    36,
00731       37,    35,     0,     0,     0,     0,     0,     0,     0,     0,
00732        0,     0,    41,     0,     0,     0,    18,    95,     0,     0,
00733        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00734        0,     0,    75,    76,     0,    85,   128,   119,     0,   127,
00735      129,    24,     0,     0,     0,    62,     0,     0,     0,     0,
00736      143,   137,     0,     0,    25,     0,    44,     0,     0,     0,
00737        0,    55,     0,    57,     0,    58,     0,    70,    98,     0,
00738      105,     0,    92,    91,    93,    80,     0,     0,   112,    88,
00739       79,    97,   115,    60,   118,     0,    87,    89,    43,     0,
00740       46,     0,     0,     0,     0,    63,   136,   131,     0,   132,
00741        0,   139,   141,   142,     0,     0,     0,    51,    74,    50,
00742      109,    86,     0,   121,    53,     0,     0,     0,     0,     0,
00743       71,     0,     0,     0,    77,     0,   107,    78,     0,    84,
00744        0,   113,     0,    94,    61,   114,   117,     0,     0,     0,
00745       64,    65,    66,   134,     0,   138,   140,     0,    45,   111,
00746      119,     0,     0,    68,     0,    59,     0,     0,     0,   100,
00747       72,    99,   106,     0,     0,     0,    96,   116,   120,     0,
00748        0,     0,     0,    26,     0,    56,    73,     0,     0,     0,
00749      122,    69,    67,     0,     0,     0,     0,     0,     0,   108,
00750       81,   130,    90,     0,    47,   135,   110,     0,     0,     0,
00751        0,     0,   104,   103,   102,   101,     0,    48,     0,     0,
00752      124,     0,    52,     0,   123,   125,     0,    82,    54,     0,
00753        0,     0,    83
00754 };
00755 
00756 /* YYDEFGOTO[NTERM-NUM].  */
00757 static const yytype_int16 yydefgoto[] =
00758 {
00759       -1,     6,     7,     8,   111,     9,    10,    11,    12,    23,
00760       92,    42,    93,   165,    28,    39,    56,    57,    58,   118,
00761      175,   176,   122,   172,    94,   144,   106,   177,   128,    95,
00762      169,   188,   266,   279,   197,   193,   129,   186,   131,   120,
00763      210,    97,   191,    98,   228,   145,   212,   240,    62,    99,
00764       59,    60,   108,   112,   113,    61
00765 };
00766 
00767 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00768    STATE-NUM.  */
00769 #define YYPACT_NINF -211
00770 static const yytype_int16 yypact[] =
00771 {
00772      166,  -211,   -32,    15,    12,    36,    40,   316,  -211,  -211,
00773       75,  -211,  -211,    82,    17,  -211,  -211,  -211,  -211,  -211,
00774      -28,    57,    17,     0,  -211,  -211,   127,  -211,     6,   109,
00775     -211,   152,  -211,   136,  -211,   169,   143,  -211,   136,   117,
00776     -211,  -211,   144,   272,  -211,  -211,   170,   -15,   191,   197,
00777      199,   201,   168,   137,  -211,  -211,  -211,  -211,  -211,  -211,
00778     -211,  -211,   180,   204,   172,   219,   202,   185,    25,    25,
00779       28,   217,  -211,   186,   266,    90,  -211,  -211,   190,   229,
00780      229,   230,   229,    21,   194,   240,   241,   242,   246,   229,
00781      210,   312,  -211,  -211,   266,  -211,  -211,     1,    61,  -211,
00782     -211,  -211,   248,   185,   266,  -211,    68,    25,    24,    29,
00783     -211,   247,   254,    20,  -211,   238,  -211,    19,   212,   258,
00784      263,  -211,   271,  -211,   233,  -211,   126,   234,   183,   275,
00785       95,   279,  -211,  -211,  -211,  -211,   266,   286,  -211,  -211,
00786     -211,   270,  -211,   236,  -211,   140,  -211,  -211,  -211,    78,
00787     -211,   255,   259,   262,   264,  -211,   267,  -211,    69,  -211,
00788      233,  -211,  -211,  -211,   289,   282,   266,   266,  -211,  -211,
00789      294,  -211,   283,  -211,    70,   293,   315,   317,   194,   194,
00790     -211,   194,   284,   194,  -211,   287,   319,  -211,   291,  -211,
00791       90,  -211,   266,  -211,  -211,  -211,   292,   295,   298,   304,
00792     -211,  -211,  -211,  -211,   299,  -211,  -211,   328,  -211,  -211,
00793      283,   330,   135,   300,   301,  -211,   301,   104,    73,   132,
00794     -211,   116,  -211,   -28,   337,   239,  -211,  -211,  -211,   338,
00795      322,   266,   340,  -211,   173,  -211,  -211,   306,   307,   341,
00796     -211,  -211,   308,   342,   343,   194,   194,   194,   194,  -211,
00797     -211,  -211,  -211,   266,  -211,  -211,  -211,   345,   346,    19,
00798      301,   301,   347,   347,   347,   347,   310,  -211,    19,    19,
00799      266,   348,  -211,   351,   266,   266,   301,  -211,  -211,   320,
00800      353,   266,  -211
00801 };
00802 
00803 /* YYPGOTO[NTERM-NUM].  */
00804 static const yytype_int16 yypgoto[] =
00805 {
00806     -211,  -211,  -211,   355,   -19,  -211,  -211,  -211,  -211,   344,
00807       64,  -211,   -29,  -211,  -211,   326,  -211,  -211,  -211,  -114,
00808     -211,   205,    46,  -211,  -211,   195,   265,  -210,   -82,  -211,
00809      -62,  -211,  -211,  -211,  -211,  -211,  -211,  -211,  -211,  -211,
00810     -211,  -211,  -211,  -211,  -211,   159,  -211,  -211,  -211,  -211,
00811     -211,  -211,   -34,   257,  -211,   309
00812 };
00813 
00814 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00815    positive, shift that token.  If negative, reduce the rule which
00816    number is the opposite.  If YYTABLE_NINF, syntax error.  */
00817 #define YYTABLE_NINF -134
00818 static const yytype_int16 yytable[] =
00819 {
00820       96,    26,   130,   167,   243,    30,   244,    34,   142,    24,
00821       55,    13,   116,    35,    55,    25,    36,    65,    22,    14,
00822      117,   162,   -20,   -49,   -49,   163,   107,   -49,    66,   157,
00823     -133,   -49,   141,   110,   159,   109,    15,   -49,   -49,   -49,
00824       17,   -49,   150,    31,   143,   -49,   -49,   -49,   -49,   -49,
00825      271,   272,   -49,   -49,   -49,   -49,   -49,    24,   126,    16,
00826      -20,   -49,   -49,    25,   127,    24,   278,   158,  -133,   146,
00827      147,    25,   158,   156,   189,   151,   225,   203,    20,   152,
00828      153,   -67,   154,   204,   182,   198,   246,    32,    21,   152,
00829      153,   117,   154,    32,   -49,   -49,   217,   218,   -49,   219,
00830       27,   221,   -49,    54,   208,   185,   182,    54,   -49,   -49,
00831      -49,   155,   -49,   213,   245,   182,   -49,   -49,   -49,   -49,
00832      -49,   155,    44,   -49,   -49,    45,   123,   182,   125,   248,
00833      226,    33,   -49,   -49,    46,   136,   178,    38,    72,   179,
00834      236,   -31,   247,   182,   -31,   270,    37,   195,    47,    48,
00835      196,    73,    31,   -31,   274,   275,    49,    50,    51,    52,
00836       53,    37,    74,   262,   263,   264,   265,   -31,   -31,   254,
00837      237,   238,   239,    40,     1,   -31,   -31,   -31,   -31,   -31,
00838      256,     2,     3,   196,    75,    76,    41,    63,    77,     4,
00839        5,   267,    78,   181,   182,    64,   183,    67,    79,    80,
00840       81,    68,    82,    69,   249,    70,    83,    84,    85,    86,
00841       87,    71,   101,    88,    89,   102,    75,   168,    90,   282,
00842       77,    51,    52,    91,    78,   103,   114,   104,   105,   115,
00843       79,    80,    81,   119,    82,   121,   124,   127,    83,    84,
00844       85,    86,    87,    75,   251,    88,    89,    77,   132,   133,
00845      134,    78,   135,   137,    52,    91,   148,    79,    80,    81,
00846      160,    82,   161,   166,   170,    83,    84,    85,    86,    87,
00847       75,   171,    88,    89,    77,   173,   174,   180,    78,   194,
00848       45,    52,    91,   184,    79,    80,    81,   187,    82,    46,
00849      190,   192,    83,    84,    85,    86,    87,   206,   199,    88,
00850       89,   209,   200,    47,    48,   201,   214,   202,    52,    91,
00851      158,    49,    50,    51,    52,    53,    -2,    18,   138,   -14,
00852      139,    37,   215,   140,     1,   207,   143,   220,   216,   231,
00853      222,     2,     3,   223,   224,   227,   233,   235,   229,     4,
00854        5,   230,   232,   241,   242,   250,   252,   253,   255,   257,
00855      258,   213,   259,   273,   261,   260,   268,   269,   182,   277,
00856      281,   276,    19,   280,    43,   205,    29,   211,   149,   234,
00857      164,   100
00858 };
00859 
00860 #define yypact_value_is_default(yystate) \
00861   ((yystate) == (-211))
00862 
00863 #define yytable_value_is_error(yytable_value) \
00864   YYID (0)
00865 
00866 static const yytype_uint16 yycheck[] =
00867 {
00868       62,    20,    84,   117,   214,     5,   216,     1,     7,    37,
00869       39,    43,    74,     7,    43,    43,    10,    32,     1,     4,
00870        1,     1,     5,     4,     5,     5,     1,     8,    43,     5,
00871        5,    12,    94,     5,     5,    69,    24,    18,    19,    20,
00872        0,    22,   104,    43,    43,    26,    27,    28,    29,    30,
00873      260,   261,    33,    34,    35,    36,    37,    37,    37,    23,
00874       43,    42,    43,    43,    43,    37,   276,    43,    43,     8,
00875        9,    43,    43,   107,   136,     7,   190,     8,     3,    11,
00876       12,    11,    14,    14,    11,     7,    13,    23,     6,    11,
00877       12,     1,    14,    29,     4,     5,   178,   179,     8,   181,
00878       43,   183,    12,    39,   166,    10,    11,    43,    18,    19,
00879       20,    43,    22,    43,    10,    11,    26,    27,    28,    29,
00880       30,    43,     5,    33,    34,     8,    80,    11,    82,    13,
00881      192,     4,    42,    43,    17,    89,    10,     1,     1,    13,
00882        5,     5,    10,    11,     8,   259,     9,     7,    31,    32,
00883       10,    14,    43,    17,   268,   269,    39,    40,    41,    42,
00884       43,     9,    25,   245,   246,   247,   248,    31,    32,   231,
00885       35,    36,    37,     4,     8,    39,    40,    41,    42,    43,
00886        7,    15,    16,    10,     4,     5,    43,    43,     8,    23,
00887       24,   253,    12,    10,    11,    25,    13,     6,    18,    19,
00888       20,     4,    22,     4,   223,     4,    26,    27,    28,    29,
00889       30,    43,     8,    33,    34,    43,     4,     5,    38,   281,
00890        8,    41,    42,    43,    12,     6,     9,    25,    43,    43,
00891       18,    19,    20,    43,    22,     6,     6,    43,    26,    27,
00892       28,    29,    30,     4,     5,    33,    34,     8,     8,     8,
00893        8,    12,     6,    43,    42,    43,     8,    18,    19,    20,
00894       13,    22,     8,    25,     6,    26,    27,    28,    29,    30,
00895        4,     8,    33,    34,     8,     4,    43,    43,    12,    43,
00896        8,    42,    43,     8,    18,    19,    20,     8,    22,    17,
00897        4,    21,    26,    27,    28,    29,    30,     8,    43,    33,
00898       34,     7,    43,    31,    32,    43,    13,    43,    42,    43,
00899       43,    39,    40,    41,    42,    43,     0,     1,     6,     3,
00900        8,     9,     7,    11,     8,    43,    43,    43,    11,    25,
00901       43,    15,    16,    14,    43,    43,     8,     7,    43,    23,
00902       24,    43,    43,    43,    43,     8,     8,    25,     8,    43,
00903       43,    43,    11,    43,    11,    13,    11,    11,    11,     8,
00904        7,    13,     7,    43,    38,   160,    22,   172,   103,   210,
00905      113,    62
00906 };
00907 
00908 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
00909    symbol of state STATE-NUM.  */
00910 static const yytype_uint8 yystos[] =
00911 {
00912        0,     8,    15,    16,    23,    24,    45,    46,    47,    49,
00913       50,    51,    52,    43,     4,    24,    23,     0,     1,    47,
00914        3,     6,     1,    53,    37,    43,    48,    43,    58,    53,
00915        5,    43,    54,     4,     1,     7,    10,     9,     1,    59,
00916        4,    43,    55,    59,     5,     8,    17,    31,    32,    39,
00917       40,    41,    42,    43,    54,    56,    60,    61,    62,    94,
00918       95,    99,    92,    43,    25,    32,    43,     6,     4,     4,
00919        4,    43,     1,    14,    25,     4,     5,     8,    12,    18,
00920       19,    20,    22,    26,    27,    28,    29,    30,    33,    34,
00921       38,    43,    54,    56,    68,    73,    74,    85,    87,    93,
00922       99,     8,    43,     6,    25,    43,    70,     1,    96,    96,
00923        5,    48,    97,    98,     9,    43,    74,     1,    63,    43,
00924       83,     6,    66,    66,     6,    66,    37,    43,    72,    80,
00925       72,    82,     8,     8,     8,     6,    66,    43,     6,     8,
00926       11,    74,     7,    43,    69,    89,     8,     9,     8,    70,
00927       74,     7,    11,    12,    14,    43,    96,     5,    43,     5,
00928       13,     8,     1,     5,    97,    57,    25,    63,     5,    74,
00929        6,     8,    67,     4,    43,    64,    65,    71,    10,    13,
00930       43,    10,    11,    13,     8,    10,    81,     8,    75,    74,
00931        4,    86,    21,    79,    43,     7,    10,    78,     7,    43,
00932       43,    43,    43,     8,    14,    65,     8,    43,    74,     7,
00933       84,    69,    90,    43,    13,     7,    11,    72,    72,    72,
00934       43,    72,    43,    14,    43,    63,    74,    43,    88,    43,
00935       43,    25,    43,     8,    89,     7,     5,    35,    36,    37,
00936       91,    43,    43,    71,    71,    10,    13,    10,    13,    48,
00937        8,     5,     8,    25,    74,     8,     7,    43,    43,    11,
00938       13,    11,    72,    72,    72,    72,    76,    74,    11,    11,
00939       63,    71,    71,    43,    63,    63,    13,     8,    71,    77,
00940       43,     7,    74
00941 };
00942 
00943 #define yyerrok      (yyerrstatus = 0)
00944 #define yyclearin (yychar = YYEMPTY)
00945 #define YYEMPTY      (-2)
00946 #define YYEOF     0
00947 
00948 #define YYACCEPT  goto yyacceptlab
00949 #define YYABORT      goto yyabortlab
00950 #define YYERROR      goto yyerrorlab
00951 
00952 
00953 /* Like YYERROR except do call yyerror.  This remains here temporarily
00954    to ease the transition to the new meaning of YYERROR, for GCC.
00955    Once GCC version 2 has supplanted version 1, this can go.  However,
00956    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
00957    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
00958    discussed.  */
00959 
00960 #define YYFAIL    goto yyerrlab
00961 #if defined YYFAIL
00962   /* This is here to suppress warnings from the GCC cpp's
00963      -Wunused-macros.  Normally we don't worry about that warning, but
00964      some users do, and we want to make it easy for users to remove
00965      YYFAIL uses, which will produce warnings from Bison 2.5.  */
00966 #endif
00967 
00968 #define YYRECOVERING()  (!!yyerrstatus)
00969 
00970 #define YYBACKUP(Token, Value)               \
00971 do                      \
00972   if (yychar == YYEMPTY && yylen == 1)          \
00973     {                      \
00974       yychar = (Token);                \
00975       yylval = (Value);                \
00976       YYPOPSTACK (1);                  \
00977       goto yybackup;                \
00978     }                      \
00979   else                        \
00980     {                      \
00981       yyerror (&yylloc, parseio, YY_("syntax error: cannot back up")); \
00982       YYERROR;                   \
00983     }                      \
00984 while (YYID (0))
00985 
00986 
00987 #define YYTERROR  1
00988 #define YYERRCODE 256
00989 
00990 
00991 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
00992    If N is 0, then set CURRENT to the empty location which ends
00993    the previous symbol: RHS[0] (always defined).  */
00994 
00995 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00996 #ifndef YYLLOC_DEFAULT
00997 # define YYLLOC_DEFAULT(Current, Rhs, N)           \
00998     do                           \
00999       if (YYID (N))                                                    \
01000    {                       \
01001      (Current).first_line   = YYRHSLOC (Rhs, 1).first_line; \
01002      (Current).first_column = YYRHSLOC (Rhs, 1).first_column;  \
01003      (Current).last_line    = YYRHSLOC (Rhs, N).last_line;     \
01004      (Current).last_column  = YYRHSLOC (Rhs, N).last_column;   \
01005    }                       \
01006       else                       \
01007    {                       \
01008      (Current).first_line   = (Current).last_line   =    \
01009        YYRHSLOC (Rhs, 0).last_line;          \
01010      (Current).first_column = (Current).last_column =    \
01011        YYRHSLOC (Rhs, 0).last_column;           \
01012    }                       \
01013     while (YYID (0))
01014 #endif
01015 
01016 
01017 /* YY_LOCATION_PRINT -- Print the location on the stream.
01018    This macro was not mandated originally: define only if we know
01019    we won't break user code: when these are the locations we know.  */
01020 
01021 #ifndef YY_LOCATION_PRINT
01022 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
01023 #  define YY_LOCATION_PRINT(File, Loc)       \
01024      fprintf (File, "%d.%d-%d.%d",        \
01025          (Loc).first_line, (Loc).first_column,  \
01026          (Loc).last_line,  (Loc).last_column)
01027 # else
01028 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
01029 # endif
01030 #endif
01031 
01032 
01033 /* YYLEX -- calling `yylex' with the right arguments.  */
01034 
01035 #ifdef YYLEX_PARAM
01036 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
01037 #else
01038 # define YYLEX yylex (&yylval, &yylloc)
01039 #endif
01040 
01041 /* Enable debugging if requested.  */
01042 #if YYDEBUG
01043 
01044 # ifndef YYFPRINTF
01045 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
01046 #  define YYFPRINTF fprintf
01047 # endif
01048 
01049 # define YYDPRINTF(Args)         \
01050 do {                 \
01051   if (yydebug)             \
01052     YYFPRINTF Args;           \
01053 } while (YYID (0))
01054 
01055 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)           \
01056 do {                            \
01057   if (yydebug)                        \
01058     {                           \
01059       YYFPRINTF (stderr, "%s ", Title);                 \
01060       yy_symbol_print (stderr,                    \
01061         Type, Value, Location, parseio); \
01062       YYFPRINTF (stderr, "\n");                   \
01063     }                           \
01064 } while (YYID (0))
01065 
01066 
01067 /*--------------------------------.
01068 | Print this symbol on YYOUTPUT.  |
01069 `--------------------------------*/
01070 
01071 /*ARGSUSED*/
01072 #if (defined __STDC__ || defined __C99__FUNC__ \
01073      || defined __cplusplus || defined _MSC_VER)
01074 static void
01075 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parse_io *parseio)
01076 #else
01077 static void
01078 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parseio)
01079     FILE *yyoutput;
01080     int yytype;
01081     YYSTYPE const * const yyvaluep;
01082     YYLTYPE const * const yylocationp;
01083     struct parse_io *parseio;
01084 #endif
01085 {
01086   if (!yyvaluep)
01087     return;
01088   YYUSE (yylocationp);
01089   YYUSE (parseio);
01090 # ifdef YYPRINT
01091   if (yytype < YYNTOKENS)
01092     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
01093 # else
01094   YYUSE (yyoutput);
01095 # endif
01096   switch (yytype)
01097     {
01098       default:
01099    break;
01100     }
01101 }
01102 
01103 
01104 /*--------------------------------.
01105 | Print this symbol on YYOUTPUT.  |
01106 `--------------------------------*/
01107 
01108 #if (defined __STDC__ || defined __C99__FUNC__ \
01109      || defined __cplusplus || defined _MSC_VER)
01110 static void
01111 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parse_io *parseio)
01112 #else
01113 static void
01114 yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, parseio)
01115     FILE *yyoutput;
01116     int yytype;
01117     YYSTYPE const * const yyvaluep;
01118     YYLTYPE const * const yylocationp;
01119     struct parse_io *parseio;
01120 #endif
01121 {
01122   if (yytype < YYNTOKENS)
01123     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
01124   else
01125     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
01126 
01127   YY_LOCATION_PRINT (yyoutput, *yylocationp);
01128   YYFPRINTF (yyoutput, ": ");
01129   yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parseio);
01130   YYFPRINTF (yyoutput, ")");
01131 }
01132 
01133 /*------------------------------------------------------------------.
01134 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
01135 | TOP (included).                                                   |
01136 `------------------------------------------------------------------*/
01137 
01138 #if (defined __STDC__ || defined __C99__FUNC__ \
01139      || defined __cplusplus || defined _MSC_VER)
01140 static void
01141 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
01142 #else
01143 static void
01144 yy_stack_print (yybottom, yytop)
01145     yytype_int16 *yybottom;
01146     yytype_int16 *yytop;
01147 #endif
01148 {
01149   YYFPRINTF (stderr, "Stack now");
01150   for (; yybottom <= yytop; yybottom++)
01151     {
01152       int yybot = *yybottom;
01153       YYFPRINTF (stderr, " %d", yybot);
01154     }
01155   YYFPRINTF (stderr, "\n");
01156 }
01157 
01158 # define YY_STACK_PRINT(Bottom, Top)            \
01159 do {                       \
01160   if (yydebug)                   \
01161     yy_stack_print ((Bottom), (Top));           \
01162 } while (YYID (0))
01163 
01164 
01165 /*------------------------------------------------.
01166 | Report that the YYRULE is going to be reduced.  |
01167 `------------------------------------------------*/
01168 
01169 #if (defined __STDC__ || defined __C99__FUNC__ \
01170      || defined __cplusplus || defined _MSC_VER)
01171 static void
01172 yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, struct parse_io *parseio)
01173 #else
01174 static void
01175 yy_reduce_print (yyvsp, yylsp, yyrule, parseio)
01176     YYSTYPE *yyvsp;
01177     YYLTYPE *yylsp;
01178     int yyrule;
01179     struct parse_io *parseio;
01180 #endif
01181 {
01182   int yynrhs = yyr2[yyrule];
01183   int yyi;
01184   unsigned long int yylno = yyrline[yyrule];
01185   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
01186         yyrule - 1, yylno);
01187   /* The symbols being reduced.  */
01188   for (yyi = 0; yyi < yynrhs; yyi++)
01189     {
01190       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
01191       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
01192              &(yyvsp[(yyi + 1) - (yynrhs)])
01193              , &(yylsp[(yyi + 1) - (yynrhs)])             , parseio);
01194       YYFPRINTF (stderr, "\n");
01195     }
01196 }
01197 
01198 # define YY_REDUCE_PRINT(Rule)      \
01199 do {              \
01200   if (yydebug)          \
01201     yy_reduce_print (yyvsp, yylsp, Rule, parseio); \
01202 } while (YYID (0))
01203 
01204 /* Nonzero means print parse trace.  It is left uninitialized so that
01205    multiple parsers can coexist.  */
01206 int yydebug;
01207 #else /* !YYDEBUG */
01208 # define YYDPRINTF(Args)
01209 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
01210 # define YY_STACK_PRINT(Bottom, Top)
01211 # define YY_REDUCE_PRINT(Rule)
01212 #endif /* !YYDEBUG */
01213 
01214 
01215 /* YYINITDEPTH -- initial size of the parser's stacks.  */
01216 #ifndef  YYINITDEPTH
01217 # define YYINITDEPTH 200
01218 #endif
01219 
01220 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
01221    if the built-in stack extension method is used).
01222 
01223    Do not make this value too large; the results are undefined if
01224    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
01225    evaluated with infinite-precision integer arithmetic.  */
01226 
01227 #ifndef YYMAXDEPTH
01228 # define YYMAXDEPTH 10000
01229 #endif
01230 
01231 
01232 #if YYERROR_VERBOSE
01233 
01234 # ifndef yystrlen
01235 #  if defined __GLIBC__ && defined _STRING_H
01236 #   define yystrlen strlen
01237 #  else
01238 /* Return the length of YYSTR.  */
01239 #if (defined __STDC__ || defined __C99__FUNC__ \
01240      || defined __cplusplus || defined _MSC_VER)
01241 static YYSIZE_T
01242 yystrlen (const char *yystr)
01243 #else
01244 static YYSIZE_T
01245 yystrlen (yystr)
01246     const char *yystr;
01247 #endif
01248 {
01249   YYSIZE_T yylen;
01250   for (yylen = 0; yystr[yylen]; yylen++)
01251     continue;
01252   return yylen;
01253 }
01254 #  endif
01255 # endif
01256 
01257 # ifndef yystpcpy
01258 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
01259 #   define yystpcpy stpcpy
01260 #  else
01261 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
01262    YYDEST.  */
01263 #if (defined __STDC__ || defined __C99__FUNC__ \
01264      || defined __cplusplus || defined _MSC_VER)
01265 static char *
01266 yystpcpy (char *yydest, const char *yysrc)
01267 #else
01268 static char *
01269 yystpcpy (yydest, yysrc)
01270     char *yydest;
01271     const char *yysrc;
01272 #endif
01273 {
01274   char *yyd = yydest;
01275   const char *yys = yysrc;
01276 
01277   while ((*yyd++ = *yys++) != '\0')
01278     continue;
01279 
01280   return yyd - 1;
01281 }
01282 #  endif
01283 # endif
01284 
01285 # ifndef yytnamerr
01286 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
01287    quotes and backslashes, so that it's suitable for yyerror.  The
01288    heuristic is that double-quoting is unnecessary unless the string
01289    contains an apostrophe, a comma, or backslash (other than
01290    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
01291    null, do not copy; instead, return the length of what the result
01292    would have been.  */
01293 static YYSIZE_T
01294 yytnamerr (char *yyres, const char *yystr)
01295 {
01296   if (*yystr == '"')
01297     {
01298       YYSIZE_T yyn = 0;
01299       char const *yyp = yystr;
01300 
01301       for (;;)
01302    switch (*++yyp)
01303      {
01304      case '\'':
01305      case ',':
01306        goto do_not_strip_quotes;
01307 
01308      case '\\':
01309        if (*++yyp != '\\')
01310          goto do_not_strip_quotes;
01311        /* Fall through.  */
01312      default:
01313        if (yyres)
01314          yyres[yyn] = *yyp;
01315        yyn++;
01316        break;
01317 
01318      case '"':
01319        if (yyres)
01320          yyres[yyn] = '\0';
01321        return yyn;
01322      }
01323     do_not_strip_quotes: ;
01324     }
01325 
01326   if (! yyres)
01327     return yystrlen (yystr);
01328 
01329   return yystpcpy (yyres, yystr) - yyres;
01330 }
01331 # endif
01332 
01333 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
01334    about the unexpected token YYTOKEN for the state stack whose top is
01335    YYSSP.
01336 
01337    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
01338    not large enough to hold the message.  In that case, also set
01339    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
01340    required number of bytes is too large to store.  */
01341 static int
01342 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
01343                 yytype_int16 *yyssp, int yytoken)
01344 {
01345   YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
01346   YYSIZE_T yysize = yysize0;
01347   YYSIZE_T yysize1;
01348   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
01349   /* Internationalized format string. */
01350   const char *yyformat = 0;
01351   /* Arguments of yyformat. */
01352   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
01353   /* Number of reported tokens (one for the "unexpected", one per
01354      "expected"). */
01355   int yycount = 0;
01356 
01357   /* There are many possibilities here to consider:
01358      - Assume YYFAIL is not used.  It's too flawed to consider.  See
01359        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
01360        for details.  YYERROR is fine as it does not invoke this
01361        function.
01362      - If this state is a consistent state with a default action, then
01363        the only way this function was invoked is if the default action
01364        is an error action.  In that case, don't check for expected
01365        tokens because there are none.
01366      - The only way there can be no lookahead present (in yychar) is if
01367        this state is a consistent state with a default action.  Thus,
01368        detecting the absence of a lookahead is sufficient to determine
01369        that there is no unexpected or expected token to report.  In that
01370        case, just report a simple "syntax error".
01371      - Don't assume there isn't a lookahead just because this state is a
01372        consistent state with a default action.  There might have been a
01373        previous inconsistent state, consistent state with a non-default
01374        action, or user semantic action that manipulated yychar.
01375      - Of course, the expected token list depends on states to have
01376        correct lookahead information, and it depends on the parser not
01377        to perform extra reductions after fetching a lookahead from the
01378        scanner and before detecting a syntax error.  Thus, state merging
01379        (from LALR or IELR) and default reductions corrupt the expected
01380        token list.  However, the list is correct for canonical LR with
01381        one exception: it will still contain any token that will not be
01382        accepted due to an error action in a later state.
01383   */
01384   if (yytoken != YYEMPTY)
01385     {
01386       int yyn = yypact[*yyssp];
01387       yyarg[yycount++] = yytname[yytoken];
01388       if (!yypact_value_is_default (yyn))
01389         {
01390           /* Start YYX at -YYN if negative to avoid negative indexes in
01391              YYCHECK.  In other words, skip the first -YYN actions for
01392              this state because they are default actions.  */
01393           int yyxbegin = yyn < 0 ? -yyn : 0;
01394           /* Stay within bounds of both yycheck and yytname.  */
01395           int yychecklim = YYLAST - yyn + 1;
01396           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
01397           int yyx;
01398 
01399           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01400             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
01401                 && !yytable_value_is_error (yytable[yyx + yyn]))
01402               {
01403                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
01404                   {
01405                     yycount = 1;
01406                     yysize = yysize0;
01407                     break;
01408                   }
01409                 yyarg[yycount++] = yytname[yyx];
01410                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
01411                 if (! (yysize <= yysize1
01412                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
01413                   return 2;
01414                 yysize = yysize1;
01415               }
01416         }
01417     }
01418 
01419   switch (yycount)
01420     {
01421 # define YYCASE_(N, S)                      \
01422       case N:                               \
01423         yyformat = S;                       \
01424       break
01425       YYCASE_(0, YY_("syntax error"));
01426       YYCASE_(1, YY_("syntax error, unexpected %s"));
01427       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
01428       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
01429       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
01430       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
01431 # undef YYCASE_
01432     }
01433 
01434   yysize1 = yysize + yystrlen (yyformat);
01435   if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
01436     return 2;
01437   yysize = yysize1;
01438 
01439   if (*yymsg_alloc < yysize)
01440     {
01441       *yymsg_alloc = 2 * yysize;
01442       if (! (yysize <= *yymsg_alloc
01443              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
01444         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
01445       return 1;
01446     }
01447 
01448   /* Avoid sprintf, as that infringes on the user's name space.
01449      Don't have undefined behavior even if the translation
01450      produced a string with the wrong number of "%s"s.  */
01451   {
01452     char *yyp = *yymsg;
01453     int yyi = 0;
01454     while ((*yyp = *yyformat) != '\0')
01455       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
01456         {
01457           yyp += yytnamerr (yyp, yyarg[yyi++]);
01458           yyformat += 2;
01459         }
01460       else
01461         {
01462           yyp++;
01463           yyformat++;
01464         }
01465   }
01466   return 0;
01467 }
01468 #endif /* YYERROR_VERBOSE */
01469 
01470 /*-----------------------------------------------.
01471 | Release the memory associated to this symbol.  |
01472 `-----------------------------------------------*/
01473 
01474 /*ARGSUSED*/
01475 #if (defined __STDC__ || defined __C99__FUNC__ \
01476      || defined __cplusplus || defined _MSC_VER)
01477 static void
01478 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct parse_io *parseio)
01479 #else
01480 static void
01481 yydestruct (yymsg, yytype, yyvaluep, yylocationp, parseio)
01482     const char *yymsg;
01483     int yytype;
01484     YYSTYPE *yyvaluep;
01485     YYLTYPE *yylocationp;
01486     struct parse_io *parseio;
01487 #endif
01488 {
01489   YYUSE (yyvaluep);
01490   YYUSE (yylocationp);
01491   YYUSE (parseio);
01492 
01493   if (!yymsg)
01494     yymsg = "Deleting";
01495   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
01496 
01497   switch (yytype)
01498     {
01499       case 43: /* "word" */
01500 
01501 /* Line 1391 of yacc.c  */
01502 #line 183 "ael.y"
01503    { free((yyvaluep->str));};
01504 
01505 /* Line 1391 of yacc.c  */
01506 #line 1506 "ael.tab.c"
01507    break;
01508       case 46: /* "objects" */
01509 
01510 /* Line 1391 of yacc.c  */
01511 #line 170 "ael.y"
01512    {
01513       destroy_pval((yyvaluep->pval));
01514       prev_word=0;
01515    };
01516 
01517 /* Line 1391 of yacc.c  */
01518 #line 1518 "ael.tab.c"
01519    break;
01520       case 47: /* "object" */
01521 
01522 /* Line 1391 of yacc.c  */
01523 #line 170 "ael.y"
01524    {
01525       destroy_pval((yyvaluep->pval));
01526       prev_word=0;
01527    };
01528 
01529 /* Line 1391 of yacc.c  */
01530 #line 1530 "ael.tab.c"
01531    break;
01532       case 48: /* "context_name" */
01533 
01534 /* Line 1391 of yacc.c  */
01535 #line 183 "ael.y"
01536    { free((yyvaluep->str));};
01537 
01538 /* Line 1391 of yacc.c  */
01539 #line 1539 "ael.tab.c"
01540    break;
01541       case 49: /* "context" */
01542 
01543 /* Line 1391 of yacc.c  */
01544 #line 170 "ael.y"
01545    {
01546       destroy_pval((yyvaluep->pval));
01547       prev_word=0;
01548    };
01549 
01550 /* Line 1391 of yacc.c  */
01551 #line 1551 "ael.tab.c"
01552    break;
01553       case 51: /* "macro" */
01554 
01555 /* Line 1391 of yacc.c  */
01556 #line 170 "ael.y"
01557    {
01558       destroy_pval((yyvaluep->pval));
01559       prev_word=0;
01560    };
01561 
01562 /* Line 1391 of yacc.c  */
01563 #line 1563 "ael.tab.c"
01564    break;
01565       case 52: /* "globals" */
01566 
01567 /* Line 1391 of yacc.c  */
01568 #line 170 "ael.y"
01569    {
01570       destroy_pval((yyvaluep->pval));
01571       prev_word=0;
01572    };
01573 
01574 /* Line 1391 of yacc.c  */
01575 #line 1575 "ael.tab.c"
01576    break;
01577       case 53: /* "global_statements" */
01578 
01579 /* Line 1391 of yacc.c  */
01580 #line 170 "ael.y"
01581    {
01582       destroy_pval((yyvaluep->pval));
01583       prev_word=0;
01584    };
01585 
01586 /* Line 1391 of yacc.c  */
01587 #line 1587 "ael.tab.c"
01588    break;
01589       case 54: /* "assignment" */
01590 
01591 /* Line 1391 of yacc.c  */
01592 #line 170 "ael.y"
01593    {
01594       destroy_pval((yyvaluep->pval));
01595       prev_word=0;
01596    };
01597 
01598 /* Line 1391 of yacc.c  */
01599 #line 1599 "ael.tab.c"
01600    break;
01601       case 56: /* "local_assignment" */
01602 
01603 /* Line 1391 of yacc.c  */
01604 #line 170 "ael.y"
01605    {
01606       destroy_pval((yyvaluep->pval));
01607       prev_word=0;
01608    };
01609 
01610 /* Line 1391 of yacc.c  */
01611 #line 1611 "ael.tab.c"
01612    break;
01613       case 58: /* "arglist" */
01614 
01615 /* Line 1391 of yacc.c  */
01616 #line 170 "ael.y"
01617    {
01618       destroy_pval((yyvaluep->pval));
01619       prev_word=0;
01620    };
01621 
01622 /* Line 1391 of yacc.c  */
01623 #line 1623 "ael.tab.c"
01624    break;
01625       case 59: /* "elements" */
01626 
01627 /* Line 1391 of yacc.c  */
01628 #line 170 "ael.y"
01629    {
01630       destroy_pval((yyvaluep->pval));
01631       prev_word=0;
01632    };
01633 
01634 /* Line 1391 of yacc.c  */
01635 #line 1635 "ael.tab.c"
01636    break;
01637       case 60: /* "element" */
01638 
01639 /* Line 1391 of yacc.c  */
01640 #line 170 "ael.y"
01641    {
01642       destroy_pval((yyvaluep->pval));
01643       prev_word=0;
01644    };
01645 
01646 /* Line 1391 of yacc.c  */
01647 #line 1647 "ael.tab.c"
01648    break;
01649       case 61: /* "ignorepat" */
01650 
01651 /* Line 1391 of yacc.c  */
01652 #line 170 "ael.y"
01653    {
01654       destroy_pval((yyvaluep->pval));
01655       prev_word=0;
01656    };
01657 
01658 /* Line 1391 of yacc.c  */
01659 #line 1659 "ael.tab.c"
01660    break;
01661       case 62: /* "extension" */
01662 
01663 /* Line 1391 of yacc.c  */
01664 #line 170 "ael.y"
01665    {
01666       destroy_pval((yyvaluep->pval));
01667       prev_word=0;
01668    };
01669 
01670 /* Line 1391 of yacc.c  */
01671 #line 1671 "ael.tab.c"
01672    break;
01673       case 63: /* "statements" */
01674 
01675 /* Line 1391 of yacc.c  */
01676 #line 170 "ael.y"
01677    {
01678       destroy_pval((yyvaluep->pval));
01679       prev_word=0;
01680    };
01681 
01682 /* Line 1391 of yacc.c  */
01683 #line 1683 "ael.tab.c"
01684    break;
01685       case 64: /* "timerange" */
01686 
01687 /* Line 1391 of yacc.c  */
01688 #line 183 "ael.y"
01689    { free((yyvaluep->str));};
01690 
01691 /* Line 1391 of yacc.c  */
01692 #line 1692 "ael.tab.c"
01693    break;
01694       case 65: /* "timespec" */
01695 
01696 /* Line 1391 of yacc.c  */
01697 #line 170 "ael.y"
01698    {
01699       destroy_pval((yyvaluep->pval));
01700       prev_word=0;
01701    };
01702 
01703 /* Line 1391 of yacc.c  */
01704 #line 1704 "ael.tab.c"
01705    break;
01706       case 66: /* "test_expr" */
01707 
01708 /* Line 1391 of yacc.c  */
01709 #line 183 "ael.y"
01710    { free((yyvaluep->str));};
01711 
01712 /* Line 1391 of yacc.c  */
01713 #line 1713 "ael.tab.c"
01714    break;
01715       case 68: /* "if_like_head" */
01716 
01717 /* Line 1391 of yacc.c  */
01718 #line 170 "ael.y"
01719    {
01720       destroy_pval((yyvaluep->pval));
01721       prev_word=0;
01722    };
01723 
01724 /* Line 1391 of yacc.c  */
01725 #line 1725 "ael.tab.c"
01726    break;
01727       case 69: /* "word_list" */
01728 
01729 /* Line 1391 of yacc.c  */
01730 #line 183 "ael.y"
01731    { free((yyvaluep->str));};
01732 
01733 /* Line 1391 of yacc.c  */
01734 #line 1734 "ael.tab.c"
01735    break;
01736       case 71: /* "word3_list" */
01737 
01738 /* Line 1391 of yacc.c  */
01739 #line 183 "ael.y"
01740    { free((yyvaluep->str));};
01741 
01742 /* Line 1391 of yacc.c  */
01743 #line 1743 "ael.tab.c"
01744    break;
01745       case 72: /* "goto_word" */
01746 
01747 /* Line 1391 of yacc.c  */
01748 #line 183 "ael.y"
01749    { free((yyvaluep->str));};
01750 
01751 /* Line 1391 of yacc.c  */
01752 #line 1752 "ael.tab.c"
01753    break;
01754       case 73: /* "switch_statement" */
01755 
01756 /* Line 1391 of yacc.c  */
01757 #line 170 "ael.y"
01758    {
01759       destroy_pval((yyvaluep->pval));
01760       prev_word=0;
01761    };
01762 
01763 /* Line 1391 of yacc.c  */
01764 #line 1764 "ael.tab.c"
01765    break;
01766       case 74: /* "statement" */
01767 
01768 /* Line 1391 of yacc.c  */
01769 #line 170 "ael.y"
01770    {
01771       destroy_pval((yyvaluep->pval));
01772       prev_word=0;
01773    };
01774 
01775 /* Line 1391 of yacc.c  */
01776 #line 1776 "ael.tab.c"
01777    break;
01778       case 79: /* "opt_else" */
01779 
01780 /* Line 1391 of yacc.c  */
01781 #line 170 "ael.y"
01782    {
01783       destroy_pval((yyvaluep->pval));
01784       prev_word=0;
01785    };
01786 
01787 /* Line 1391 of yacc.c  */
01788 #line 1788 "ael.tab.c"
01789    break;
01790       case 80: /* "target" */
01791 
01792 /* Line 1391 of yacc.c  */
01793 #line 170 "ael.y"
01794    {
01795       destroy_pval((yyvaluep->pval));
01796       prev_word=0;
01797    };
01798 
01799 /* Line 1391 of yacc.c  */
01800 #line 1800 "ael.tab.c"
01801    break;
01802       case 81: /* "opt_pri" */
01803 
01804 /* Line 1391 of yacc.c  */
01805 #line 183 "ael.y"
01806    { free((yyvaluep->str));};
01807 
01808 /* Line 1391 of yacc.c  */
01809 #line 1809 "ael.tab.c"
01810    break;
01811       case 82: /* "jumptarget" */
01812 
01813 /* Line 1391 of yacc.c  */
01814 #line 170 "ael.y"
01815    {
01816       destroy_pval((yyvaluep->pval));
01817       prev_word=0;
01818    };
01819 
01820 /* Line 1391 of yacc.c  */
01821 #line 1821 "ael.tab.c"
01822    break;
01823       case 83: /* "macro_call" */
01824 
01825 /* Line 1391 of yacc.c  */
01826 #line 170 "ael.y"
01827    {
01828       destroy_pval((yyvaluep->pval));
01829       prev_word=0;
01830    };
01831 
01832 /* Line 1391 of yacc.c  */
01833 #line 1833 "ael.tab.c"
01834    break;
01835       case 85: /* "application_call_head" */
01836 
01837 /* Line 1391 of yacc.c  */
01838 #line 170 "ael.y"
01839    {
01840       destroy_pval((yyvaluep->pval));
01841       prev_word=0;
01842    };
01843 
01844 /* Line 1391 of yacc.c  */
01845 #line 1845 "ael.tab.c"
01846    break;
01847       case 87: /* "application_call" */
01848 
01849 /* Line 1391 of yacc.c  */
01850 #line 170 "ael.y"
01851    {
01852       destroy_pval((yyvaluep->pval));
01853       prev_word=0;
01854    };
01855 
01856 /* Line 1391 of yacc.c  */
01857 #line 1857 "ael.tab.c"
01858    break;
01859       case 88: /* "opt_word" */
01860 
01861 /* Line 1391 of yacc.c  */
01862 #line 183 "ael.y"
01863    { free((yyvaluep->str));};
01864 
01865 /* Line 1391 of yacc.c  */
01866 #line 1866 "ael.tab.c"
01867    break;
01868       case 89: /* "eval_arglist" */
01869 
01870 /* Line 1391 of yacc.c  */
01871 #line 170 "ael.y"
01872    {
01873       destroy_pval((yyvaluep->pval));
01874       prev_word=0;
01875    };
01876 
01877 /* Line 1391 of yacc.c  */
01878 #line 1878 "ael.tab.c"
01879    break;
01880       case 90: /* "case_statements" */
01881 
01882 /* Line 1391 of yacc.c  */
01883 #line 170 "ael.y"
01884    {
01885       destroy_pval((yyvaluep->pval));
01886       prev_word=0;
01887    };
01888 
01889 /* Line 1391 of yacc.c  */
01890 #line 1890 "ael.tab.c"
01891    break;
01892       case 91: /* "case_statement" */
01893 
01894 /* Line 1391 of yacc.c  */
01895 #line 170 "ael.y"
01896    {
01897       destroy_pval((yyvaluep->pval));
01898       prev_word=0;
01899    };
01900 
01901 /* Line 1391 of yacc.c  */
01902 #line 1902 "ael.tab.c"
01903    break;
01904       case 92: /* "macro_statements" */
01905 
01906 /* Line 1391 of yacc.c  */
01907 #line 170 "ael.y"
01908    {
01909       destroy_pval((yyvaluep->pval));
01910       prev_word=0;
01911    };
01912 
01913 /* Line 1391 of yacc.c  */
01914 #line 1914 "ael.tab.c"
01915    break;
01916       case 93: /* "macro_statement" */
01917 
01918 /* Line 1391 of yacc.c  */
01919 #line 170 "ael.y"
01920    {
01921       destroy_pval((yyvaluep->pval));
01922       prev_word=0;
01923    };
01924 
01925 /* Line 1391 of yacc.c  */
01926 #line 1926 "ael.tab.c"
01927    break;
01928       case 94: /* "switches" */
01929 
01930 /* Line 1391 of yacc.c  */
01931 #line 170 "ael.y"
01932    {
01933       destroy_pval((yyvaluep->pval));
01934       prev_word=0;
01935    };
01936 
01937 /* Line 1391 of yacc.c  */
01938 #line 1938 "ael.tab.c"
01939    break;
01940       case 95: /* "eswitches" */
01941 
01942 /* Line 1391 of yacc.c  */
01943 #line 170 "ael.y"
01944    {
01945       destroy_pval((yyvaluep->pval));
01946       prev_word=0;
01947    };
01948 
01949 /* Line 1391 of yacc.c  */
01950 #line 1950 "ael.tab.c"
01951    break;
01952       case 96: /* "switchlist" */
01953 
01954 /* Line 1391 of yacc.c  */
01955 #line 170 "ael.y"
01956    {
01957       destroy_pval((yyvaluep->pval));
01958       prev_word=0;
01959    };
01960 
01961 /* Line 1391 of yacc.c  */
01962 #line 1962 "ael.tab.c"
01963    break;
01964       case 97: /* "included_entry" */
01965 
01966 /* Line 1391 of yacc.c  */
01967 #line 170 "ael.y"
01968    {
01969       destroy_pval((yyvaluep->pval));
01970       prev_word=0;
01971    };
01972 
01973 /* Line 1391 of yacc.c  */
01974 #line 1974 "ael.tab.c"
01975    break;
01976       case 98: /* "includeslist" */
01977 
01978 /* Line 1391 of yacc.c  */
01979 #line 170 "ael.y"
01980    {
01981       destroy_pval((yyvaluep->pval));
01982       prev_word=0;
01983    };
01984 
01985 /* Line 1391 of yacc.c  */
01986 #line 1986 "ael.tab.c"
01987    break;
01988       case 99: /* "includes" */
01989 
01990 /* Line 1391 of yacc.c  */
01991 #line 170 "ael.y"
01992    {
01993       destroy_pval((yyvaluep->pval));
01994       prev_word=0;
01995    };
01996 
01997 /* Line 1391 of yacc.c  */
01998 #line 1998 "ael.tab.c"
01999    break;
02000 
02001       default:
02002    break;
02003     }
02004 }
02005 
02006 
02007 /* Prevent warnings from -Wmissing-prototypes.  */
02008 #ifdef YYPARSE_PARAM
02009 #if defined __STDC__ || defined __cplusplus
02010 int yyparse (void *YYPARSE_PARAM);
02011 #else
02012 int yyparse ();
02013 #endif
02014 #else /* ! YYPARSE_PARAM */
02015 #if defined __STDC__ || defined __cplusplus
02016 int yyparse (struct parse_io *parseio);
02017 #else
02018 int yyparse ();
02019 #endif
02020 #endif /* ! YYPARSE_PARAM */
02021 
02022 
02023 /*----------.
02024 | yyparse.  |
02025 `----------*/
02026 
02027 #ifdef YYPARSE_PARAM
02028 #if (defined __STDC__ || defined __C99__FUNC__ \
02029      || defined __cplusplus || defined _MSC_VER)
02030 int
02031 yyparse (void *YYPARSE_PARAM)
02032 #else
02033 int
02034 yyparse (YYPARSE_PARAM)
02035     void *YYPARSE_PARAM;
02036 #endif
02037 #else /* ! YYPARSE_PARAM */
02038 #if (defined __STDC__ || defined __C99__FUNC__ \
02039      || defined __cplusplus || defined _MSC_VER)
02040 int
02041 yyparse (struct parse_io *parseio)
02042 #else
02043 int
02044 yyparse (parseio)
02045     struct parse_io *parseio;
02046 #endif
02047 #endif
02048 {
02049 /* The lookahead symbol.  */
02050 int yychar;
02051 
02052 /* The semantic value of the lookahead symbol.  */
02053 YYSTYPE yylval;
02054 
02055 /* Location data for the lookahead symbol.  */
02056 YYLTYPE yylloc;
02057 
02058     /* Number of syntax errors so far.  */
02059     int yynerrs;
02060 
02061     int yystate;
02062     /* Number of tokens to shift before error messages enabled.  */
02063     int yyerrstatus;
02064 
02065     /* The stacks and their tools:
02066        `yyss': related to states.
02067        `yyvs': related to semantic values.
02068        `yyls': related to locations.
02069 
02070        Refer to the stacks thru separate pointers, to allow yyoverflow
02071        to reallocate them elsewhere.  */
02072 
02073     /* The state stack.  */
02074     yytype_int16 yyssa[YYINITDEPTH];
02075     yytype_int16 *yyss;
02076     yytype_int16 *yyssp;
02077 
02078     /* The semantic value stack.  */
02079     YYSTYPE yyvsa[YYINITDEPTH];
02080     YYSTYPE *yyvs;
02081     YYSTYPE *yyvsp;
02082 
02083     /* The location stack.  */
02084     YYLTYPE yylsa[YYINITDEPTH];
02085     YYLTYPE *yyls;
02086     YYLTYPE *yylsp;
02087 
02088     /* The locations where the error started and ended.  */
02089     YYLTYPE yyerror_range[3];
02090 
02091     YYSIZE_T yystacksize;
02092 
02093   int yyn;
02094   int yyresult;
02095   /* Lookahead token as an internal (translated) token number.  */
02096   int yytoken;
02097   /* The variables used to return semantic value and location from the
02098      action routines.  */
02099   YYSTYPE yyval;
02100   YYLTYPE yyloc;
02101 
02102 #if YYERROR_VERBOSE
02103   /* Buffer for error messages, and its allocated size.  */
02104   char yymsgbuf[128];
02105   char *yymsg = yymsgbuf;
02106   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
02107 #endif
02108 
02109 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
02110 
02111   /* The number of symbols on the RHS of the reduced rule.
02112      Keep to zero when no symbol should be popped.  */
02113   int yylen = 0;
02114 
02115   yytoken = 0;
02116   yyss = yyssa;
02117   yyvs = yyvsa;
02118   yyls = yylsa;
02119   yystacksize = YYINITDEPTH;
02120 
02121   YYDPRINTF ((stderr, "Starting parse\n"));
02122 
02123   yystate = 0;
02124   yyerrstatus = 0;
02125   yynerrs = 0;
02126   yychar = YYEMPTY; /* Cause a token to be read.  */
02127 
02128   /* Initialize stack pointers.
02129      Waste one element of value and location stack
02130      so that they stay on the same level as the state stack.
02131      The wasted elements are never initialized.  */
02132   yyssp = yyss;
02133   yyvsp = yyvs;
02134   yylsp = yyls;
02135 
02136 #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
02137   /* Initialize the default location before parsing starts.  */
02138   yylloc.first_line   = yylloc.last_line   = 1;
02139   yylloc.first_column = yylloc.last_column = 1;
02140 #endif
02141 
02142   goto yysetstate;
02143 
02144 /*------------------------------------------------------------.
02145 | yynewstate -- Push a new state, which is found in yystate.  |
02146 `------------------------------------------------------------*/
02147  yynewstate:
02148   /* In all cases, when you get here, the value and location stacks
02149      have just been pushed.  So pushing a state here evens the stacks.  */
02150   yyssp++;
02151 
02152  yysetstate:
02153   *yyssp = yystate;
02154 
02155   if (yyss + yystacksize - 1 <= yyssp)
02156     {
02157       /* Get the current used size of the three stacks, in elements.  */
02158       YYSIZE_T yysize = yyssp - yyss + 1;
02159 
02160 #ifdef yyoverflow
02161       {
02162    /* Give user a chance to reallocate the stack.  Use copies of
02163       these so that the &'s don't force the real ones into
02164       memory.  */
02165    YYSTYPE *yyvs1 = yyvs;
02166    yytype_int16 *yyss1 = yyss;
02167    YYLTYPE *yyls1 = yyls;
02168 
02169    /* Each stack pointer address is followed by the size of the
02170       data in use in that stack, in bytes.  This used to be a
02171       conditional around just the two extra args, but that might
02172       be undefined if yyoverflow is a macro.  */
02173    yyoverflow (YY_("memory exhausted"),
02174           &yyss1, yysize * sizeof (*yyssp),
02175           &yyvs1, yysize * sizeof (*yyvsp),
02176           &yyls1, yysize * sizeof (*yylsp),
02177           &yystacksize);
02178 
02179    yyls = yyls1;
02180    yyss = yyss1;
02181    yyvs = yyvs1;
02182       }
02183 #else /* no yyoverflow */
02184 # ifndef YYSTACK_RELOCATE
02185       goto yyexhaustedlab;
02186 # else
02187       /* Extend the stack our own way.  */
02188       if (YYMAXDEPTH <= yystacksize)
02189    goto yyexhaustedlab;
02190       yystacksize *= 2;
02191       if (YYMAXDEPTH < yystacksize)
02192    yystacksize = YYMAXDEPTH;
02193 
02194       {
02195    yytype_int16 *yyss1 = yyss;
02196    union yyalloc *yyptr =
02197      (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
02198    if (! yyptr)
02199      goto yyexhaustedlab;
02200    YYSTACK_RELOCATE (yyss_alloc, yyss);
02201    YYSTACK_RELOCATE (yyvs_alloc, yyvs);
02202    YYSTACK_RELOCATE (yyls_alloc, yyls);
02203 #  undef YYSTACK_RELOCATE
02204    if (yyss1 != yyssa)
02205      YYSTACK_FREE (yyss1);
02206       }
02207 # endif
02208 #endif /* no yyoverflow */
02209 
02210       yyssp = yyss + yysize - 1;
02211       yyvsp = yyvs + yysize - 1;
02212       yylsp = yyls + yysize - 1;
02213 
02214       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
02215         (unsigned long int) yystacksize));
02216 
02217       if (yyss + yystacksize - 1 <= yyssp)
02218    YYABORT;
02219     }
02220 
02221   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
02222 
02223   if (yystate == YYFINAL)
02224     YYACCEPT;
02225 
02226   goto yybackup;
02227 
02228 /*-----------.
02229 | yybackup.  |
02230 `-----------*/
02231 yybackup:
02232 
02233   /* Do appropriate processing given the current state.  Read a
02234      lookahead token if we need one and don't already have one.  */
02235 
02236   /* First try to decide what to do without reference to lookahead token.  */
02237   yyn = yypact[yystate];
02238   if (yypact_value_is_default (yyn))
02239     goto yydefault;
02240 
02241   /* Not known => get a lookahead token if don't already have one.  */
02242 
02243   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
02244   if (yychar == YYEMPTY)
02245     {
02246       YYDPRINTF ((stderr, "Reading a token: "));
02247       yychar = YYLEX;
02248     }
02249 
02250   if (yychar <= YYEOF)
02251     {
02252       yychar = yytoken = YYEOF;
02253       YYDPRINTF ((stderr, "Now at end of input.\n"));
02254     }
02255   else
02256     {
02257       yytoken = YYTRANSLATE (yychar);
02258       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
02259     }
02260 
02261   /* If the proper action on seeing token YYTOKEN is to reduce or to
02262      detect an error, take that action.  */
02263   yyn += yytoken;
02264   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
02265     goto yydefault;
02266   yyn = yytable[yyn];
02267   if (yyn <= 0)
02268     {
02269       if (yytable_value_is_error (yyn))
02270         goto yyerrlab;
02271       yyn = -yyn;
02272       goto yyreduce;
02273     }
02274 
02275   /* Count tokens shifted since error; after three, turn off error
02276      status.  */
02277   if (yyerrstatus)
02278     yyerrstatus--;
02279 
02280   /* Shift the lookahead token.  */
02281   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
02282 
02283   /* Discard the shifted token.  */
02284   yychar = YYEMPTY;
02285 
02286   yystate = yyn;
02287   *++yyvsp = yylval;
02288   *++yylsp = yylloc;
02289   goto yynewstate;
02290 
02291 
02292 /*-----------------------------------------------------------.
02293 | yydefault -- do the default action for the current state.  |
02294 `-----------------------------------------------------------*/
02295 yydefault:
02296   yyn = yydefact[yystate];
02297   if (yyn == 0)
02298     goto yyerrlab;
02299   goto yyreduce;
02300 
02301 
02302 /*-----------------------------.
02303 | yyreduce -- Do a reduction.  |
02304 `-----------------------------*/
02305 yyreduce:
02306   /* yyn is the number of a rule to reduce with.  */
02307   yylen = yyr2[yyn];
02308 
02309   /* If YYLEN is nonzero, implement the default value of the action:
02310      `$$ = $1'.
02311 
02312      Otherwise, the following line sets YYVAL to garbage.
02313      This behavior is undocumented and Bison
02314      users should not rely upon it.  Assigning to YYVAL
02315      unconditionally makes the parser a bit smaller, and it avoids a
02316      GCC warning that YYVAL may be used uninitialized.  */
02317   yyval = yyvsp[1-yylen];
02318 
02319   /* Default location.  */
02320   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
02321   YY_REDUCE_PRINT (yyn);
02322   switch (yyn)
02323     {
02324         case 2:
02325 
02326 /* Line 1806 of yacc.c  */
02327 #line 191 "ael.y"
02328     { (yyval.pval) = parseio->pval = (yyvsp[(1) - (1)].pval); }
02329     break;
02330 
02331   case 3:
02332 
02333 /* Line 1806 of yacc.c  */
02334 #line 194 "ael.y"
02335     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02336     break;
02337 
02338   case 4:
02339 
02340 /* Line 1806 of yacc.c  */
02341 #line 195 "ael.y"
02342     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02343     break;
02344 
02345   case 5:
02346 
02347 /* Line 1806 of yacc.c  */
02348 #line 196 "ael.y"
02349     {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
02350     break;
02351 
02352   case 6:
02353 
02354 /* Line 1806 of yacc.c  */
02355 #line 199 "ael.y"
02356     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02357     break;
02358 
02359   case 7:
02360 
02361 /* Line 1806 of yacc.c  */
02362 #line 200 "ael.y"
02363     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02364     break;
02365 
02366   case 8:
02367 
02368 /* Line 1806 of yacc.c  */
02369 #line 201 "ael.y"
02370     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02371     break;
02372 
02373   case 9:
02374 
02375 /* Line 1806 of yacc.c  */
02376 #line 202 "ael.y"
02377     {(yyval.pval)=0;/* allow older docs to be read */}
02378     break;
02379 
02380   case 10:
02381 
02382 /* Line 1806 of yacc.c  */
02383 #line 205 "ael.y"
02384     { (yyval.str) = (yyvsp[(1) - (1)].str); }
02385     break;
02386 
02387   case 11:
02388 
02389 /* Line 1806 of yacc.c  */
02390 #line 206 "ael.y"
02391     { (yyval.str) = strdup("default"); }
02392     break;
02393 
02394   case 12:
02395 
02396 /* Line 1806 of yacc.c  */
02397 #line 209 "ael.y"
02398     {
02399       (yyval.pval) = npval2(PV_CONTEXT, &(yylsp[(1) - (6)]), &(yylsp[(6) - (6)]));
02400       (yyval.pval)->u1.str = (yyvsp[(3) - (6)].str);
02401       (yyval.pval)->u2.statements = (yyvsp[(5) - (6)].pval);
02402       set_dads((yyval.pval),(yyvsp[(5) - (6)].pval));
02403       (yyval.pval)->u3.abstract = (yyvsp[(1) - (6)].intval);}
02404     break;
02405 
02406   case 13:
02407 
02408 /* Line 1806 of yacc.c  */
02409 #line 218 "ael.y"
02410     { (yyval.intval) = 1; }
02411     break;
02412 
02413   case 14:
02414 
02415 /* Line 1806 of yacc.c  */
02416 #line 219 "ael.y"
02417     { (yyval.intval) = 0; }
02418     break;
02419 
02420   case 15:
02421 
02422 /* Line 1806 of yacc.c  */
02423 #line 220 "ael.y"
02424     { (yyval.intval) = 2; }
02425     break;
02426 
02427   case 16:
02428 
02429 /* Line 1806 of yacc.c  */
02430 #line 221 "ael.y"
02431     { (yyval.intval)=3; }
02432     break;
02433 
02434   case 17:
02435 
02436 /* Line 1806 of yacc.c  */
02437 #line 222 "ael.y"
02438     { (yyval.intval)=3; }
02439     break;
02440 
02441   case 18:
02442 
02443 /* Line 1806 of yacc.c  */
02444 #line 225 "ael.y"
02445     {
02446       (yyval.pval) = npval2(PV_MACRO, &(yylsp[(1) - (8)]), &(yylsp[(8) - (8)]));
02447       (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);
02448         set_dads((yyval.pval),(yyvsp[(7) - (8)].pval));}
02449     break;
02450 
02451   case 19:
02452 
02453 /* Line 1806 of yacc.c  */
02454 #line 231 "ael.y"
02455     {
02456       (yyval.pval) = npval2(PV_GLOBALS, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02457       (yyval.pval)->u1.statements = (yyvsp[(3) - (4)].pval);
02458         set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
02459     break;
02460 
02461   case 20:
02462 
02463 /* Line 1806 of yacc.c  */
02464 #line 237 "ael.y"
02465     { (yyval.pval) = NULL; }
02466     break;
02467 
02468   case 21:
02469 
02470 /* Line 1806 of yacc.c  */
02471 #line 238 "ael.y"
02472     {(yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02473     break;
02474 
02475   case 22:
02476 
02477 /* Line 1806 of yacc.c  */
02478 #line 239 "ael.y"
02479     {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
02480     break;
02481 
02482   case 23:
02483 
02484 /* Line 1806 of yacc.c  */
02485 #line 242 "ael.y"
02486     { reset_semicount(parseio->scanner); }
02487     break;
02488 
02489   case 24:
02490 
02491 /* Line 1806 of yacc.c  */
02492 #line 242 "ael.y"
02493     {
02494       (yyval.pval) = npval2(PV_VARDEC, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
02495       (yyval.pval)->u1.str = (yyvsp[(1) - (5)].str);
02496       (yyval.pval)->u2.val = (yyvsp[(4) - (5)].str); }
02497     break;
02498 
02499   case 25:
02500 
02501 /* Line 1806 of yacc.c  */
02502 #line 248 "ael.y"
02503     { reset_semicount(parseio->scanner); }
02504     break;
02505 
02506   case 26:
02507 
02508 /* Line 1806 of yacc.c  */
02509 #line 248 "ael.y"
02510     {
02511       (yyval.pval) = npval2(PV_LOCALVARDEC, &(yylsp[(1) - (6)]), &(yylsp[(6) - (6)]));
02512       (yyval.pval)->u1.str = (yyvsp[(2) - (6)].str);
02513       (yyval.pval)->u2.val = (yyvsp[(5) - (6)].str); }
02514     break;
02515 
02516   case 27:
02517 
02518 /* Line 1806 of yacc.c  */
02519 #line 255 "ael.y"
02520     { (yyval.pval) = NULL; }
02521     break;
02522 
02523   case 28:
02524 
02525 /* Line 1806 of yacc.c  */
02526 #line 256 "ael.y"
02527     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
02528     break;
02529 
02530   case 29:
02531 
02532 /* Line 1806 of yacc.c  */
02533 #line 257 "ael.y"
02534     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)]))); }
02535     break;
02536 
02537   case 30:
02538 
02539 /* Line 1806 of yacc.c  */
02540 #line 258 "ael.y"
02541     {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
02542     break;
02543 
02544   case 31:
02545 
02546 /* Line 1806 of yacc.c  */
02547 #line 261 "ael.y"
02548     {(yyval.pval)=0;}
02549     break;
02550 
02551   case 32:
02552 
02553 /* Line 1806 of yacc.c  */
02554 #line 262 "ael.y"
02555     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02556     break;
02557 
02558   case 33:
02559 
02560 /* Line 1806 of yacc.c  */
02561 #line 263 "ael.y"
02562     { (yyval.pval)=(yyvsp[(2) - (2)].pval);}
02563     break;
02564 
02565   case 34:
02566 
02567 /* Line 1806 of yacc.c  */
02568 #line 266 "ael.y"
02569     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02570     break;
02571 
02572   case 35:
02573 
02574 /* Line 1806 of yacc.c  */
02575 #line 267 "ael.y"
02576     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02577     break;
02578 
02579   case 36:
02580 
02581 /* Line 1806 of yacc.c  */
02582 #line 268 "ael.y"
02583     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02584     break;
02585 
02586   case 37:
02587 
02588 /* Line 1806 of yacc.c  */
02589 #line 269 "ael.y"
02590     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02591     break;
02592 
02593   case 38:
02594 
02595 /* Line 1806 of yacc.c  */
02596 #line 270 "ael.y"
02597     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02598     break;
02599 
02600   case 39:
02601 
02602 /* Line 1806 of yacc.c  */
02603 #line 271 "ael.y"
02604     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02605     break;
02606 
02607   case 40:
02608 
02609 /* Line 1806 of yacc.c  */
02610 #line 272 "ael.y"
02611     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02612     break;
02613 
02614   case 41:
02615 
02616 /* Line 1806 of yacc.c  */
02617 #line 273 "ael.y"
02618     {free((yyvsp[(1) - (2)].str)); (yyval.pval)=0;}
02619     break;
02620 
02621   case 42:
02622 
02623 /* Line 1806 of yacc.c  */
02624 #line 274 "ael.y"
02625     {(yyval.pval)=0;/* allow older docs to be read */}
02626     break;
02627 
02628   case 43:
02629 
02630 /* Line 1806 of yacc.c  */
02631 #line 277 "ael.y"
02632     {
02633       (yyval.pval) = npval2(PV_IGNOREPAT, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02634       (yyval.pval)->u1.str = (yyvsp[(3) - (4)].str);}
02635     break;
02636 
02637   case 44:
02638 
02639 /* Line 1806 of yacc.c  */
02640 #line 282 "ael.y"
02641     {
02642       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
02643       (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str);
02644       (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval); set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
02645     break;
02646 
02647   case 45:
02648 
02649 /* Line 1806 of yacc.c  */
02650 #line 286 "ael.y"
02651     {
02652       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (5)]), &(yylsp[(3) - (5)]));
02653       (yyval.pval)->u1.str = malloc(strlen((yyvsp[(1) - (5)].str))+strlen((yyvsp[(3) - (5)].str))+2);
02654       strcpy((yyval.pval)->u1.str,(yyvsp[(1) - (5)].str));
02655       strcat((yyval.pval)->u1.str,"@");
02656       strcat((yyval.pval)->u1.str,(yyvsp[(3) - (5)].str));
02657       free((yyvsp[(1) - (5)].str));
02658       (yyval.pval)->u2.statements = (yyvsp[(5) - (5)].pval); set_dads((yyval.pval),(yyvsp[(5) - (5)].pval));}
02659     break;
02660 
02661   case 46:
02662 
02663 /* Line 1806 of yacc.c  */
02664 #line 294 "ael.y"
02665     {
02666       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02667       (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
02668       (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval); set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));
02669       (yyval.pval)->u4.regexten=1;}
02670     break;
02671 
02672   case 47:
02673 
02674 /* Line 1806 of yacc.c  */
02675 #line 299 "ael.y"
02676     {
02677       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (7)]), &(yylsp[(7) - (7)]));
02678       (yyval.pval)->u1.str = (yyvsp[(5) - (7)].str);
02679       (yyval.pval)->u2.statements = (yyvsp[(7) - (7)].pval); set_dads((yyval.pval),(yyvsp[(7) - (7)].pval));
02680       (yyval.pval)->u3.hints = (yyvsp[(3) - (7)].str);}
02681     break;
02682 
02683   case 48:
02684 
02685 /* Line 1806 of yacc.c  */
02686 #line 304 "ael.y"
02687     {
02688       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (8)]), &(yylsp[(8) - (8)]));
02689       (yyval.pval)->u1.str = (yyvsp[(6) - (8)].str);
02690       (yyval.pval)->u2.statements = (yyvsp[(8) - (8)].pval); set_dads((yyval.pval),(yyvsp[(8) - (8)].pval));
02691       (yyval.pval)->u4.regexten=1;
02692       (yyval.pval)->u3.hints = (yyvsp[(4) - (8)].str);}
02693     break;
02694 
02695   case 49:
02696 
02697 /* Line 1806 of yacc.c  */
02698 #line 313 "ael.y"
02699     { (yyval.pval) = NULL; }
02700     break;
02701 
02702   case 50:
02703 
02704 /* Line 1806 of yacc.c  */
02705 #line 314 "ael.y"
02706     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02707     break;
02708 
02709   case 51:
02710 
02711 /* Line 1806 of yacc.c  */
02712 #line 315 "ael.y"
02713     {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
02714     break;
02715 
02716   case 52:
02717 
02718 /* Line 1806 of yacc.c  */
02719 #line 321 "ael.y"
02720     {
02721       if (asprintf(&(yyval.str), "%s:%s:%s", (yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (yyvsp[(5) - (5)].str)) < 0) {
02722          ast_log(LOG_WARNING, "asprintf() failed\n");
02723          (yyval.str) = NULL;
02724       } else {
02725          free((yyvsp[(1) - (5)].str));
02726          free((yyvsp[(3) - (5)].str));
02727          free((yyvsp[(5) - (5)].str));
02728       }
02729    }
02730     break;
02731 
02732   case 53:
02733 
02734 /* Line 1806 of yacc.c  */
02735 #line 331 "ael.y"
02736     { (yyval.str) = (yyvsp[(1) - (1)].str); }
02737     break;
02738 
02739   case 54:
02740 
02741 /* Line 1806 of yacc.c  */
02742 #line 335 "ael.y"
02743     {
02744       (yyval.pval) = nword((yyvsp[(1) - (7)].str), &(yylsp[(1) - (7)]));
02745       (yyval.pval)->next = nword((yyvsp[(3) - (7)].str), &(yylsp[(3) - (7)]));
02746       (yyval.pval)->next->next = nword((yyvsp[(5) - (7)].str), &(yylsp[(5) - (7)]));
02747       (yyval.pval)->next->next->next = nword((yyvsp[(7) - (7)].str), &(yylsp[(7) - (7)])); }
02748     break;
02749 
02750   case 55:
02751 
02752 /* Line 1806 of yacc.c  */
02753 #line 343 "ael.y"
02754     { reset_parencount(parseio->scanner); }
02755     break;
02756 
02757   case 56:
02758 
02759 /* Line 1806 of yacc.c  */
02760 #line 343 "ael.y"
02761     { (yyval.str) = (yyvsp[(3) - (4)].str); }
02762     break;
02763 
02764   case 57:
02765 
02766 /* Line 1806 of yacc.c  */
02767 #line 347 "ael.y"
02768     {
02769       (yyval.pval)= npval2(PV_IF, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
02770       (yyval.pval)->u1.str = (yyvsp[(2) - (2)].str); }
02771     break;
02772 
02773   case 58:
02774 
02775 /* Line 1806 of yacc.c  */
02776 #line 350 "ael.y"
02777     {
02778       (yyval.pval) = npval2(PV_RANDOM, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
02779       (yyval.pval)->u1.str=(yyvsp[(2) - (2)].str);}
02780     break;
02781 
02782   case 59:
02783 
02784 /* Line 1806 of yacc.c  */
02785 #line 353 "ael.y"
02786     {
02787       (yyval.pval) = npval2(PV_IFTIME, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02788       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval);
02789       prev_word = 0; }
02790     break;
02791 
02792   case 60:
02793 
02794 /* Line 1806 of yacc.c  */
02795 #line 364 "ael.y"
02796     { (yyval.str) = (yyvsp[(1) - (1)].str);}
02797     break;
02798 
02799   case 61:
02800 
02801 /* Line 1806 of yacc.c  */
02802 #line 365 "ael.y"
02803     {
02804       if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
02805          ast_log(LOG_WARNING, "asprintf() failed\n");
02806          (yyval.str) = NULL;
02807       } else {
02808          free((yyvsp[(1) - (2)].str));
02809          free((yyvsp[(2) - (2)].str));
02810          prev_word = (yyval.str);
02811       }
02812    }
02813     break;
02814 
02815   case 62:
02816 
02817 /* Line 1806 of yacc.c  */
02818 #line 377 "ael.y"
02819     { (yyval.str) = (yyvsp[(1) - (1)].str); }
02820     break;
02821 
02822   case 63:
02823 
02824 /* Line 1806 of yacc.c  */
02825 #line 378 "ael.y"
02826     {
02827       if (asprintf(&((yyval.str)), "%s %s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
02828          ast_log(LOG_WARNING, "asprintf() failed\n");
02829          (yyval.str) = NULL;
02830       } else {
02831          free((yyvsp[(1) - (2)].str));
02832          free((yyvsp[(2) - (2)].str));
02833       }
02834    }
02835     break;
02836 
02837   case 64:
02838 
02839 /* Line 1806 of yacc.c  */
02840 #line 387 "ael.y"
02841     {
02842       if (asprintf(&((yyval.str)), "%s:%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02843          ast_log(LOG_WARNING, "asprintf() failed\n");
02844          (yyval.str) = NULL;
02845       } else {
02846          free((yyvsp[(1) - (3)].str));
02847          free((yyvsp[(3) - (3)].str));
02848       }
02849    }
02850     break;
02851 
02852   case 65:
02853 
02854 /* Line 1806 of yacc.c  */
02855 #line 396 "ael.y"
02856     {  /* there are often '&' in hints */
02857       if (asprintf(&((yyval.str)), "%s&%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02858          ast_log(LOG_WARNING, "asprintf() failed\n");
02859          (yyval.str) = NULL;
02860       } else {
02861          free((yyvsp[(1) - (3)].str));
02862          free((yyvsp[(3) - (3)].str));
02863       }
02864    }
02865     break;
02866 
02867   case 66:
02868 
02869 /* Line 1806 of yacc.c  */
02870 #line 405 "ael.y"
02871     {
02872       if (asprintf(&((yyval.str)), "%s@%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02873          ast_log(LOG_WARNING, "asprintf() failed\n");
02874          (yyval.str) = NULL;
02875       } else {
02876          free((yyvsp[(1) - (3)].str));
02877          free((yyvsp[(3) - (3)].str));
02878       }
02879    }
02880     break;
02881 
02882   case 67:
02883 
02884 /* Line 1806 of yacc.c  */
02885 #line 416 "ael.y"
02886     { (yyval.str) = (yyvsp[(1) - (1)].str);}
02887     break;
02888 
02889   case 68:
02890 
02891 /* Line 1806 of yacc.c  */
02892 #line 417 "ael.y"
02893     {
02894       if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
02895          ast_log(LOG_WARNING, "asprintf() failed\n");
02896          (yyval.str) = NULL;
02897       } else {
02898          free((yyvsp[(1) - (2)].str));
02899          free((yyvsp[(2) - (2)].str));
02900          prev_word = (yyval.str);
02901       }        
02902    }
02903     break;
02904 
02905   case 69:
02906 
02907 /* Line 1806 of yacc.c  */
02908 #line 427 "ael.y"
02909     {
02910       if (asprintf(&((yyval.str)), "%s%s%s", (yyvsp[(1) - (3)].str), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02911          ast_log(LOG_WARNING, "asprintf() failed\n");
02912          (yyval.str) = NULL;
02913       } else {
02914          free((yyvsp[(1) - (3)].str));
02915          free((yyvsp[(2) - (3)].str));
02916          free((yyvsp[(3) - (3)].str));
02917          prev_word=(yyval.str);
02918       }
02919    }
02920     break;
02921 
02922   case 70:
02923 
02924 /* Line 1806 of yacc.c  */
02925 #line 440 "ael.y"
02926     { (yyval.str) = (yyvsp[(1) - (1)].str);}
02927     break;
02928 
02929   case 71:
02930 
02931 /* Line 1806 of yacc.c  */
02932 #line 441 "ael.y"
02933     {
02934       if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
02935          ast_log(LOG_WARNING, "asprintf() failed\n");
02936          (yyval.str) = NULL;
02937       } else {
02938          free((yyvsp[(1) - (2)].str));
02939          free((yyvsp[(2) - (2)].str));
02940       }
02941    }
02942     break;
02943 
02944   case 72:
02945 
02946 /* Line 1806 of yacc.c  */
02947 #line 450 "ael.y"
02948     {
02949       if (asprintf(&((yyval.str)), "%s:%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02950          ast_log(LOG_WARNING, "asprintf() failed\n");
02951          (yyval.str) = NULL;
02952       } else {
02953          free((yyvsp[(1) - (3)].str));
02954          free((yyvsp[(3) - (3)].str));
02955       }
02956    }
02957     break;
02958 
02959   case 73:
02960 
02961 /* Line 1806 of yacc.c  */
02962 #line 461 "ael.y"
02963     {
02964       (yyval.pval) = npval2(PV_SWITCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
02965       (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str);
02966       (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));}
02967     break;
02968 
02969   case 74:
02970 
02971 /* Line 1806 of yacc.c  */
02972 #line 470 "ael.y"
02973     {
02974       (yyval.pval) = npval2(PV_STATEMENTBLOCK, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
02975       (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval));}
02976     break;
02977 
02978   case 75:
02979 
02980 /* Line 1806 of yacc.c  */
02981 #line 473 "ael.y"
02982     { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
02983     break;
02984 
02985   case 76:
02986 
02987 /* Line 1806 of yacc.c  */
02988 #line 474 "ael.y"
02989     { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
02990     break;
02991 
02992   case 77:
02993 
02994 /* Line 1806 of yacc.c  */
02995 #line 475 "ael.y"
02996     {
02997       (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
02998       (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);}
02999     break;
03000 
03001   case 78:
03002 
03003 /* Line 1806 of yacc.c  */
03004 #line 478 "ael.y"
03005     {
03006       (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03007       (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);}
03008     break;
03009 
03010   case 79:
03011 
03012 /* Line 1806 of yacc.c  */
03013 #line 481 "ael.y"
03014     {
03015       (yyval.pval) = npval2(PV_LABEL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
03016       (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str); }
03017     break;
03018 
03019   case 80:
03020 
03021 /* Line 1806 of yacc.c  */
03022 #line 484 "ael.y"
03023     {reset_semicount(parseio->scanner);}
03024     break;
03025 
03026   case 81:
03027 
03028 /* Line 1806 of yacc.c  */
03029 #line 485 "ael.y"
03030     {reset_semicount(parseio->scanner);}
03031     break;
03032 
03033   case 82:
03034 
03035 /* Line 1806 of yacc.c  */
03036 #line 486 "ael.y"
03037     {reset_parencount(parseio->scanner);}
03038     break;
03039 
03040   case 83:
03041 
03042 /* Line 1806 of yacc.c  */
03043 #line 486 "ael.y"
03044     { /* XXX word_list maybe ? */
03045       (yyval.pval) = npval2(PV_FOR, &(yylsp[(1) - (12)]), &(yylsp[(12) - (12)]));
03046       (yyval.pval)->u1.for_init = (yyvsp[(4) - (12)].str);
03047       (yyval.pval)->u2.for_test=(yyvsp[(7) - (12)].str);
03048       (yyval.pval)->u3.for_inc = (yyvsp[(10) - (12)].str);
03049       (yyval.pval)->u4.for_statements = (yyvsp[(12) - (12)].pval); set_dads((yyval.pval),(yyvsp[(12) - (12)].pval));}
03050     break;
03051 
03052   case 84:
03053 
03054 /* Line 1806 of yacc.c  */
03055 #line 492 "ael.y"
03056     {
03057       (yyval.pval) = npval2(PV_WHILE, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03058       (yyval.pval)->u1.str = (yyvsp[(2) - (3)].str);
03059       (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval); set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
03060     break;
03061 
03062   case 85:
03063 
03064 /* Line 1806 of yacc.c  */
03065 #line 496 "ael.y"
03066     { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
03067     break;
03068 
03069   case 86:
03070 
03071 /* Line 1806 of yacc.c  */
03072 #line 497 "ael.y"
03073     { (yyval.pval) = update_last((yyvsp[(2) - (3)].pval), &(yylsp[(2) - (3)])); }
03074     break;
03075 
03076   case 87:
03077 
03078 /* Line 1806 of yacc.c  */
03079 #line 498 "ael.y"
03080     { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); }
03081     break;
03082 
03083   case 88:
03084 
03085 /* Line 1806 of yacc.c  */
03086 #line 499 "ael.y"
03087     {
03088       (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
03089       (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str);}
03090     break;
03091 
03092   case 89:
03093 
03094 /* Line 1806 of yacc.c  */
03095 #line 502 "ael.y"
03096     {reset_semicount(parseio->scanner);}
03097     break;
03098 
03099   case 90:
03100 
03101 /* Line 1806 of yacc.c  */
03102 #line 502 "ael.y"
03103     {
03104       char *bufx;
03105       int tot=0;
03106       pval *pptr;
03107       (yyval.pval) = npval2(PV_VARDEC, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
03108       (yyval.pval)->u2.val=(yyvsp[(4) - (5)].str);
03109       /* rebuild the original string-- this is not an app call, it's an unwrapped vardec, with a func call on the LHS */
03110       /* string to big to fit in the buffer? */
03111       tot+=strlen((yyvsp[(1) - (5)].pval)->u1.str);
03112       for(pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) {
03113          tot+=strlen(pptr->u1.str);
03114          tot++; /* for a sep like a comma */
03115       }
03116       tot+=4; /* for safety */
03117       bufx = calloc(1, tot);
03118       strcpy(bufx,(yyvsp[(1) - (5)].pval)->u1.str);
03119       strcat(bufx,"(");
03120       /* XXX need to advance the pointer or the loop is very inefficient */
03121       for (pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) {
03122          if ( pptr != (yyvsp[(1) - (5)].pval)->u2.arglist )
03123             strcat(bufx,",");
03124          strcat(bufx,pptr->u1.str);
03125       }
03126       strcat(bufx,")");
03127 #ifdef AAL_ARGCHECK
03128       if ( !ael_is_funcname((yyvsp[(1) - (5)].pval)->u1.str) )
03129          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",
03130             my_file, (yylsp[(1) - (5)]).first_line, (yylsp[(1) - (5)]).first_column, (yylsp[(1) - (5)]).last_column, (yyvsp[(1) - (5)].pval)->u1.str);
03131 #endif
03132       (yyval.pval)->u1.str = bufx;
03133       destroy_pval((yyvsp[(1) - (5)].pval)); /* the app call it is not, get rid of that chain */
03134       prev_word = 0;
03135    }
03136     break;
03137 
03138   case 91:
03139 
03140 /* Line 1806 of yacc.c  */
03141 #line 535 "ael.y"
03142     { (yyval.pval) = npval2(PV_BREAK, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
03143     break;
03144 
03145   case 92:
03146 
03147 /* Line 1806 of yacc.c  */
03148 #line 536 "ael.y"
03149     { (yyval.pval) = npval2(PV_RETURN, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
03150     break;
03151 
03152   case 93:
03153 
03154 /* Line 1806 of yacc.c  */
03155 #line 537 "ael.y"
03156     { (yyval.pval) = npval2(PV_CONTINUE, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
03157     break;
03158 
03159   case 94:
03160 
03161 /* Line 1806 of yacc.c  */
03162 #line 538 "ael.y"
03163     {
03164       (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(2) - (3)]));
03165       (yyval.pval)->u2.statements = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval));
03166       (yyval.pval)->u3.else_statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
03167     break;
03168 
03169   case 95:
03170 
03171 /* Line 1806 of yacc.c  */
03172 #line 542 "ael.y"
03173     { (yyval.pval)=0; }
03174     break;
03175 
03176   case 96:
03177 
03178 /* Line 1806 of yacc.c  */
03179 #line 545 "ael.y"
03180     { (yyval.pval) = (yyvsp[(2) - (2)].pval); }
03181     break;
03182 
03183   case 97:
03184 
03185 /* Line 1806 of yacc.c  */
03186 #line 546 "ael.y"
03187     { (yyval.pval) = NULL ; }
03188     break;
03189 
03190   case 98:
03191 
03192 /* Line 1806 of yacc.c  */
03193 #line 549 "ael.y"
03194     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
03195     break;
03196 
03197   case 99:
03198 
03199 /* Line 1806 of yacc.c  */
03200 #line 550 "ael.y"
03201     {
03202       (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
03203       (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); }
03204     break;
03205 
03206   case 100:
03207 
03208 /* Line 1806 of yacc.c  */
03209 #line 553 "ael.y"
03210     {
03211       (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
03212       (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); }
03213     break;
03214 
03215   case 101:
03216 
03217 /* Line 1806 of yacc.c  */
03218 #line 556 "ael.y"
03219     {
03220       (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)]));
03221       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03222       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03223     break;
03224 
03225   case 102:
03226 
03227 /* Line 1806 of yacc.c  */
03228 #line 560 "ael.y"
03229     {
03230       (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)]));
03231       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03232       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03233     break;
03234 
03235   case 103:
03236 
03237 /* Line 1806 of yacc.c  */
03238 #line 564 "ael.y"
03239     {
03240       (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)]));
03241       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03242       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03243     break;
03244 
03245   case 104:
03246 
03247 /* Line 1806 of yacc.c  */
03248 #line 568 "ael.y"
03249     {
03250       (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)]));
03251       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03252       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03253     break;
03254 
03255   case 105:
03256 
03257 /* Line 1806 of yacc.c  */
03258 #line 574 "ael.y"
03259     { (yyval.str) = strdup("1"); }
03260     break;
03261 
03262   case 106:
03263 
03264 /* Line 1806 of yacc.c  */
03265 #line 575 "ael.y"
03266     { (yyval.str) = (yyvsp[(2) - (2)].str); }
03267     break;
03268 
03269   case 107:
03270 
03271 /* Line 1806 of yacc.c  */
03272 #line 579 "ael.y"
03273     {       /* ext[, pri] default 1 */
03274       (yyval.pval) = nword((yyvsp[(1) - (2)].str), &(yylsp[(1) - (2)]));
03275       (yyval.pval)->next = nword((yyvsp[(2) - (2)].str), &(yylsp[(2) - (2)])); }
03276     break;
03277 
03278   case 108:
03279 
03280 /* Line 1806 of yacc.c  */
03281 #line 582 "ael.y"
03282     { /* context, ext, pri */
03283       (yyval.pval) = nword((yyvsp[(4) - (4)].str), &(yylsp[(4) - (4)]));
03284       (yyval.pval)->next = nword((yyvsp[(1) - (4)].str), &(yylsp[(1) - (4)]));
03285       (yyval.pval)->next->next = nword((yyvsp[(2) - (4)].str), &(yylsp[(2) - (4)])); }
03286     break;
03287 
03288   case 109:
03289 
03290 /* Line 1806 of yacc.c  */
03291 #line 588 "ael.y"
03292     {reset_argcount(parseio->scanner);}
03293     break;
03294 
03295   case 110:
03296 
03297 /* Line 1806 of yacc.c  */
03298 #line 588 "ael.y"
03299     {
03300       /* XXX original code had @2 but i think we need @5 */
03301       (yyval.pval) = npval2(PV_MACRO_CALL, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
03302       (yyval.pval)->u1.str = (yyvsp[(1) - (5)].str);
03303       (yyval.pval)->u2.arglist = (yyvsp[(4) - (5)].pval);}
03304     break;
03305 
03306   case 111:
03307 
03308 /* Line 1806 of yacc.c  */
03309 #line 593 "ael.y"
03310     {
03311       (yyval.pval)= npval2(PV_MACRO_CALL, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03312       (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str); }
03313     break;
03314 
03315   case 112:
03316 
03317 /* Line 1806 of yacc.c  */
03318 #line 601 "ael.y"
03319     {reset_argcount(parseio->scanner);}
03320     break;
03321 
03322   case 113:
03323 
03324 /* Line 1806 of yacc.c  */
03325 #line 601 "ael.y"
03326     {
03327       if (strcasecmp((yyvsp[(1) - (3)].str),"goto") == 0) {
03328          (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)]));
03329          free((yyvsp[(1) - (3)].str)); /* won't be using this */
03330          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 );
03331       } else {
03332          (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)]));
03333          (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str);
03334       } }
03335     break;
03336 
03337   case 114:
03338 
03339 /* Line 1806 of yacc.c  */
03340 #line 612 "ael.y"
03341     {
03342       (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(3) - (3)]));
03343       if( (yyval.pval)->type == PV_GOTO )
03344          (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);
03345       else
03346          (yyval.pval)->u2.arglist = (yyvsp[(2) - (3)].pval);
03347    }
03348     break;
03349 
03350   case 115:
03351 
03352 /* Line 1806 of yacc.c  */
03353 #line 619 "ael.y"
03354     { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); }
03355     break;
03356 
03357   case 116:
03358 
03359 /* Line 1806 of yacc.c  */
03360 #line 622 "ael.y"
03361     { (yyval.str) = (yyvsp[(1) - (1)].str) ;}
03362     break;
03363 
03364   case 117:
03365 
03366 /* Line 1806 of yacc.c  */
03367 #line 623 "ael.y"
03368     { (yyval.str) = strdup(""); }
03369     break;
03370 
03371   case 118:
03372 
03373 /* Line 1806 of yacc.c  */
03374 #line 626 "ael.y"
03375     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
03376     break;
03377 
03378   case 119:
03379 
03380 /* Line 1806 of yacc.c  */
03381 #line 627 "ael.y"
03382     {
03383       (yyval.pval)= npval(PV_WORD,0/*@1.first_line*/,0/*@1.last_line*/,0/* @1.first_column*/, 0/*@1.last_column*/);
03384       (yyval.pval)->u1.str = strdup(""); }
03385     break;
03386 
03387   case 120:
03388 
03389 /* Line 1806 of yacc.c  */
03390 #line 630 "ael.y"
03391     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)]))); }
03392     break;
03393 
03394   case 121:
03395 
03396 /* Line 1806 of yacc.c  */
03397 #line 633 "ael.y"
03398     { (yyval.pval) = NULL; }
03399     break;
03400 
03401   case 122:
03402 
03403 /* Line 1806 of yacc.c  */
03404 #line 634 "ael.y"
03405     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
03406     break;
03407 
03408   case 123:
03409 
03410 /* Line 1806 of yacc.c  */
03411 #line 637 "ael.y"
03412     {
03413       (yyval.pval) = npval2(PV_CASE, &(yylsp[(1) - (4)]), &(yylsp[(3) - (4)])); /* XXX 3 or 4 ? */
03414       (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
03415       (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval); set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));}
03416     break;
03417 
03418   case 124:
03419 
03420 /* Line 1806 of yacc.c  */
03421 #line 641 "ael.y"
03422     {
03423       (yyval.pval) = npval2(PV_DEFAULT, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03424       (yyval.pval)->u1.str = NULL;
03425       (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
03426     break;
03427 
03428   case 125:
03429 
03430 /* Line 1806 of yacc.c  */
03431 #line 645 "ael.y"
03432     {
03433       (yyval.pval) = npval2(PV_PATTERN, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)])); /* XXX@3 or @4 ? */
03434       (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
03435       (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval);set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));}
03436     break;
03437 
03438   case 126:
03439 
03440 /* Line 1806 of yacc.c  */
03441 #line 651 "ael.y"
03442     { (yyval.pval) = NULL; }
03443     break;
03444 
03445   case 127:
03446 
03447 /* Line 1806 of yacc.c  */
03448 #line 652 "ael.y"
03449     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
03450     break;
03451 
03452   case 128:
03453 
03454 /* Line 1806 of yacc.c  */
03455 #line 655 "ael.y"
03456     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
03457     break;
03458 
03459   case 129:
03460 
03461 /* Line 1806 of yacc.c  */
03462 #line 656 "ael.y"
03463     { (yyval.pval)=(yyvsp[(1) - (1)].pval);}
03464     break;
03465 
03466   case 130:
03467 
03468 /* Line 1806 of yacc.c  */
03469 #line 657 "ael.y"
03470     {
03471       (yyval.pval) = npval2(PV_CATCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
03472       (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str);
03473       (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));}
03474     break;
03475 
03476   case 131:
03477 
03478 /* Line 1806 of yacc.c  */
03479 #line 663 "ael.y"
03480     {
03481       (yyval.pval) = npval2(PV_SWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)]));
03482       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
03483     break;
03484 
03485   case 132:
03486 
03487 /* Line 1806 of yacc.c  */
03488 #line 668 "ael.y"
03489     {
03490       (yyval.pval) = npval2(PV_ESWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)]));
03491       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
03492     break;
03493 
03494   case 133:
03495 
03496 /* Line 1806 of yacc.c  */
03497 #line 673 "ael.y"
03498     { (yyval.pval) = NULL; }
03499     break;
03500 
03501   case 134:
03502 
03503 /* Line 1806 of yacc.c  */
03504 #line 674 "ael.y"
03505     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval),nword((yyvsp[(2) - (3)].str), &(yylsp[(2) - (3)]))); }
03506     break;
03507 
03508   case 135:
03509 
03510 /* Line 1806 of yacc.c  */
03511 #line 675 "ael.y"
03512     {
03513      char *x;
03514      if (asprintf(&x,"%s@%s", (yyvsp[(2) - (5)].str), (yyvsp[(4) - (5)].str)) < 0) {
03515       ast_log(LOG_WARNING, "asprintf() failed\n");
03516       (yyval.pval) = NULL;
03517      } else {
03518       free((yyvsp[(2) - (5)].str));
03519       free((yyvsp[(4) - (5)].str));
03520       (yyval.pval) = linku1((yyvsp[(1) - (5)].pval),nword(x, &(yylsp[(2) - (5)])));
03521      }
03522    }
03523     break;
03524 
03525   case 136:
03526 
03527 /* Line 1806 of yacc.c  */
03528 #line 686 "ael.y"
03529     {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
03530     break;
03531 
03532   case 137:
03533 
03534 /* Line 1806 of yacc.c  */
03535 #line 689 "ael.y"
03536     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
03537     break;
03538 
03539   case 138:
03540 
03541 /* Line 1806 of yacc.c  */
03542 #line 690 "ael.y"
03543     {
03544       (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
03545       (yyval.pval)->u2.arglist = (yyvsp[(3) - (3)].pval);
03546       prev_word=0; /* XXX sure ? */ }
03547     break;
03548 
03549   case 139:
03550 
03551 /* Line 1806 of yacc.c  */
03552 #line 697 "ael.y"
03553     { (yyval.pval) = (yyvsp[(1) - (2)].pval); }
03554     break;
03555 
03556   case 140:
03557 
03558 /* Line 1806 of yacc.c  */
03559 #line 698 "ael.y"
03560     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), (yyvsp[(2) - (3)].pval)); }
03561     break;
03562 
03563   case 141:
03564 
03565 /* Line 1806 of yacc.c  */
03566 #line 699 "ael.y"
03567     {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
03568     break;
03569 
03570   case 142:
03571 
03572 /* Line 1806 of yacc.c  */
03573 #line 702 "ael.y"
03574     {
03575       (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
03576       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval);set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
03577     break;
03578 
03579   case 143:
03580 
03581 /* Line 1806 of yacc.c  */
03582 #line 705 "ael.y"
03583     {
03584       (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));}
03585     break;
03586 
03587 
03588 
03589 /* Line 1806 of yacc.c  */
03590 #line 3590 "ael.tab.c"
03591       default: break;
03592     }
03593   /* User semantic actions sometimes alter yychar, and that requires
03594      that yytoken be updated with the new translation.  We take the
03595      approach of translating immediately before every use of yytoken.
03596      One alternative is translating here after every semantic action,
03597      but that translation would be missed if the semantic action invokes
03598      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
03599      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
03600      incorrect destructor might then be invoked immediately.  In the
03601      case of YYERROR or YYBACKUP, subsequent parser actions might lead
03602      to an incorrect destructor call or verbose syntax error message
03603      before the lookahead is translated.  */
03604   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
03605 
03606   YYPOPSTACK (yylen);
03607   yylen = 0;
03608   YY_STACK_PRINT (yyss, yyssp);
03609 
03610   *++yyvsp = yyval;
03611   *++yylsp = yyloc;
03612 
03613   /* Now `shift' the result of the reduction.  Determine what state
03614      that goes to, based on the state we popped back to and the rule
03615      number reduced by.  */
03616 
03617   yyn = yyr1[yyn];
03618 
03619   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
03620   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
03621     yystate = yytable[yystate];
03622   else
03623     yystate = yydefgoto[yyn - YYNTOKENS];
03624 
03625   goto yynewstate;
03626 
03627 
03628 /*------------------------------------.
03629 | yyerrlab -- here on detecting error |
03630 `------------------------------------*/
03631 yyerrlab:
03632   /* Make sure we have latest lookahead translation.  See comments at
03633      user semantic actions for why this is necessary.  */
03634   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
03635 
03636   /* If not already recovering from an error, report this error.  */
03637   if (!yyerrstatus)
03638     {
03639       ++yynerrs;
03640 #if ! YYERROR_VERBOSE
03641       yyerror (&yylloc, parseio, YY_("syntax error"));
03642 #else
03643 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
03644                                         yyssp, yytoken)
03645       {
03646         char const *yymsgp = YY_("syntax error");
03647         int yysyntax_error_status;
03648         yysyntax_error_status = YYSYNTAX_ERROR;
03649         if (yysyntax_error_status == 0)
03650           yymsgp = yymsg;
03651         else if (yysyntax_error_status == 1)
03652           {
03653             if (yymsg != yymsgbuf)
03654               YYSTACK_FREE (yymsg);
03655             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
03656             if (!yymsg)
03657               {
03658                 yymsg = yymsgbuf;
03659                 yymsg_alloc = sizeof yymsgbuf;
03660                 yysyntax_error_status = 2;
03661               }
03662             else
03663               {
03664                 yysyntax_error_status = YYSYNTAX_ERROR;
03665                 yymsgp = yymsg;
03666               }
03667           }
03668         yyerror (&yylloc, parseio, yymsgp);
03669         if (yysyntax_error_status == 2)
03670           goto yyexhaustedlab;
03671       }
03672 # undef YYSYNTAX_ERROR
03673 #endif
03674     }
03675 
03676   yyerror_range[1] = yylloc;
03677 
03678   if (yyerrstatus == 3)
03679     {
03680       /* If just tried and failed to reuse lookahead token after an
03681     error, discard it.  */
03682 
03683       if (yychar <= YYEOF)
03684    {
03685      /* Return failure if at end of input.  */
03686      if (yychar == YYEOF)
03687        YYABORT;
03688    }
03689       else
03690    {
03691      yydestruct ("Error: discarding",
03692             yytoken, &yylval, &yylloc, parseio);
03693      yychar = YYEMPTY;
03694    }
03695     }
03696 
03697   /* Else will try to reuse lookahead token after shifting the error
03698      token.  */
03699   goto yyerrlab1;
03700 
03701 
03702 /*---------------------------------------------------.
03703 | yyerrorlab -- error raised explicitly by YYERROR.  |
03704 `---------------------------------------------------*/
03705 yyerrorlab:
03706 
03707   /* Pacify compilers like GCC when the user code never invokes
03708      YYERROR and the label yyerrorlab therefore never appears in user
03709      code.  */
03710   if (/*CONSTCOND*/ 0)
03711      goto yyerrorlab;
03712 
03713   yyerror_range[1] = yylsp[1-yylen];
03714   /* Do not reclaim the symbols of the rule which action triggered
03715      this YYERROR.  */
03716   YYPOPSTACK (yylen);
03717   yylen = 0;
03718   YY_STACK_PRINT (yyss, yyssp);
03719   yystate = *yyssp;
03720   goto yyerrlab1;
03721 
03722 
03723 /*-------------------------------------------------------------.
03724 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
03725 `-------------------------------------------------------------*/
03726 yyerrlab1:
03727   yyerrstatus = 3;   /* Each real token shifted decrements this.  */
03728 
03729   for (;;)
03730     {
03731       yyn = yypact[yystate];
03732       if (!yypact_value_is_default (yyn))
03733    {
03734      yyn += YYTERROR;
03735      if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
03736        {
03737          yyn = yytable[yyn];
03738          if (0 < yyn)
03739       break;
03740        }
03741    }
03742 
03743       /* Pop the current state because it cannot handle the error token.  */
03744       if (yyssp == yyss)
03745    YYABORT;
03746 
03747       yyerror_range[1] = *yylsp;
03748       yydestruct ("Error: popping",
03749         yystos[yystate], yyvsp, yylsp, parseio);
03750       YYPOPSTACK (1);
03751       yystate = *yyssp;
03752       YY_STACK_PRINT (yyss, yyssp);
03753     }
03754 
03755   *++yyvsp = yylval;
03756 
03757   yyerror_range[2] = yylloc;
03758   /* Using YYLLOC is tempting, but would change the location of
03759      the lookahead.  YYLOC is available though.  */
03760   YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
03761   *++yylsp = yyloc;
03762 
03763   /* Shift the error token.  */
03764   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
03765 
03766   yystate = yyn;
03767   goto yynewstate;
03768 
03769 
03770 /*-------------------------------------.
03771 | yyacceptlab -- YYACCEPT comes here.  |
03772 `-------------------------------------*/
03773 yyacceptlab:
03774   yyresult = 0;
03775   goto yyreturn;
03776 
03777 /*-----------------------------------.
03778 | yyabortlab -- YYABORT comes here.  |
03779 `-----------------------------------*/
03780 yyabortlab:
03781   yyresult = 1;
03782   goto yyreturn;
03783 
03784 #if !defined(yyoverflow) || YYERROR_VERBOSE
03785 /*-------------------------------------------------.
03786 | yyexhaustedlab -- memory exhaustion comes here.  |
03787 `-------------------------------------------------*/
03788 yyexhaustedlab:
03789   yyerror (&yylloc, parseio, YY_("memory exhausted"));
03790   yyresult = 2;
03791   /* Fall through.  */
03792 #endif
03793 
03794 yyreturn:
03795   if (yychar != YYEMPTY)
03796     {
03797       /* Make sure we have latest lookahead translation.  See comments at
03798          user semantic actions for why this is necessary.  */
03799       yytoken = YYTRANSLATE (yychar);
03800       yydestruct ("Cleanup: discarding lookahead",
03801                   yytoken, &yylval, &yylloc, parseio);
03802     }
03803   /* Do not reclaim the symbols of the rule which action triggered
03804      this YYABORT or YYACCEPT.  */
03805   YYPOPSTACK (yylen);
03806   YY_STACK_PRINT (yyss, yyssp);
03807   while (yyssp != yyss)
03808     {
03809       yydestruct ("Cleanup: popping",
03810         yystos[*yyssp], yyvsp, yylsp, parseio);
03811       YYPOPSTACK (1);
03812     }
03813 #ifndef yyoverflow
03814   if (yyss != yyssa)
03815     YYSTACK_FREE (yyss);
03816 #endif
03817 #if YYERROR_VERBOSE
03818   if (yymsg != yymsgbuf)
03819     YYSTACK_FREE (yymsg);
03820 #endif
03821   /* Make sure YYID is used.  */
03822   return YYID (yyresult);
03823 }
03824 
03825 
03826 
03827 /* Line 2067 of yacc.c  */
03828 #line 710 "ael.y"
03829 
03830 
03831 static char *token_equivs1[] =
03832 {
03833    "AMPER",
03834    "AT",
03835    "BAR",
03836    "COLON",
03837    "COMMA",
03838    "EQ",
03839    "EXTENMARK",
03840    "KW_BREAK",
03841    "KW_CASE",
03842    "KW_CATCH",
03843    "KW_CONTEXT",
03844    "KW_CONTINUE",
03845    "KW_DEFAULT",
03846    "KW_ELSE",
03847    "KW_ESWITCHES",
03848    "KW_FOR",
03849    "KW_GLOBALS",
03850    "KW_GOTO",
03851    "KW_HINT",
03852    "KW_IFTIME",
03853    "KW_IF",
03854    "KW_IGNOREPAT",
03855    "KW_INCLUDES"
03856    "KW_JUMP",
03857    "KW_MACRO",
03858    "KW_PATTERN",
03859    "KW_REGEXTEN",
03860    "KW_RETURN",
03861    "KW_SWITCHES",
03862    "KW_SWITCH",
03863    "KW_WHILE",
03864    "LC",
03865    "LP",
03866    "RC",
03867    "RP",
03868    "SEMI",
03869 };
03870 
03871 static char *token_equivs2[] =
03872 {
03873    "&",
03874    "@",
03875    "|",
03876    ":",
03877    ",",
03878    "=",
03879    "=>",
03880    "break",
03881    "case",
03882    "catch",
03883    "context",
03884    "continue",
03885    "default",
03886    "else",
03887    "eswitches",
03888    "for",
03889    "globals",
03890    "goto",
03891    "hint",
03892    "ifTime",
03893    "if",
03894    "ignorepat",
03895    "includes"
03896    "jump",
03897    "macro",
03898    "pattern",
03899    "regexten",
03900    "return",
03901    "switches",
03902    "switch",
03903    "while",
03904    "{",
03905    "(",
03906    "}",
03907    ")",
03908    ";",
03909 };
03910 
03911 
03912 static char *ael_token_subst(const char *mess)
03913 {
03914    /* calc a length, malloc, fill, and return; yyerror had better free it! */
03915    int len=0,i;
03916    const char *p;
03917    char *res, *s,*t;
03918    int token_equivs_entries = sizeof(token_equivs1)/sizeof(char*);
03919 
03920    for (p=mess; *p; p++) {
03921       for (i=0; i<token_equivs_entries; i++) {
03922          if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 )
03923          {
03924             len+=strlen(token_equivs2[i])+2;
03925             p += strlen(token_equivs1[i])-1;
03926             break;
03927          }
03928       }
03929       len++;
03930    }
03931    res = calloc(1, len+1);
03932    res[0] = 0;
03933    s = res;
03934    for (p=mess; *p;) {
03935       int found = 0;
03936       for (i=0; i<token_equivs_entries; i++) {
03937          if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 ) {
03938             *s++ = '\'';
03939             for (t=token_equivs2[i]; *t;) {
03940                *s++ = *t++;
03941             }
03942             *s++ = '\'';
03943             p += strlen(token_equivs1[i]);
03944             found = 1;
03945             break;
03946          }
03947       }
03948       if( !found )
03949          *s++ = *p++;
03950    }
03951    *s++ = 0;
03952    return res;
03953 }
03954 
03955 void yyerror(YYLTYPE *locp, struct parse_io *parseio,  char const *s)
03956 {
03957    char *s2 = ael_token_subst((char *)s);
03958    if (locp->first_line == locp->last_line) {
03959       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);
03960    } else {
03961       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);
03962    }
03963    free(s2);
03964    parseio->syntax_error_count++;
03965 }
03966 
03967 struct pval *npval(pvaltype type, int first_line, int last_line,
03968    int first_column, int last_column)
03969 {
03970    pval *z = calloc(1, sizeof(struct pval));
03971    z->type = type;
03972    z->startline = first_line;
03973    z->endline = last_line;
03974    z->startcol = first_column;
03975    z->endcol = last_column;
03976    z->filename = strdup(S_OR(my_file, "<none>"));
03977    return z;
03978 }
03979 
03980 static struct pval *npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last)
03981 {
03982    return npval(type, first->first_line, last->last_line,
03983          first->first_column, last->last_column);
03984 }
03985 
03986 static struct pval *update_last(pval *obj, YYLTYPE *last)
03987 {
03988    obj->endline = last->last_line;
03989    obj->endcol = last->last_column;
03990    return obj;
03991 }
03992 
03993 /* frontend for npval to create a PV_WORD string from the given token */
03994 static pval *nword(char *string, YYLTYPE *pos)
03995 {
03996    pval *p = npval2(PV_WORD, pos, pos);
03997    if (p)
03998       p->u1.str = string;
03999    return p;
04000 }
04001 
04002 /* this routine adds a dad ptr to each element in the list */
04003 static void set_dads(struct pval *dad, struct pval *child_list)
04004 {
04005    struct pval *t;
04006    
04007    for(t=child_list;t;t=t->next)  /* simple stuff */
04008       t->dad = dad;
04009 }
04010 
04011 

Generated on Thu Apr 16 06:27:06 2015 for Asterisk - The Open Source Telephony Project by  doxygen 1.5.6