Thu Apr 28 2011 17:15:13

Asterisk developer's documentation


ael.tab.c

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