diff options
| author | Kaz Kylheku <kaz@kylheku.com> | 2020-09-24 19:56:07 -0700 |
|---|---|---|
| committer | Kaz Kylheku <kaz@kylheku.com> | 2020-09-24 19:56:07 -0700 |
| commit | b2c4389575185b5526370d3fb682c6ac06367b87 (patch) | |
| tree | 2db46427cbbc9595479b32dd7e20e710acfc83f4 /y.tab.c.shipped | |
| parent | 781cf1d35e83f75cf5278205cd34f63fb1284213 (diff) | |
| download | txr-b2c4389575185b5526370d3fb682c6ac06367b87.tar.gz txr-b2c4389575185b5526370d3fb682c6ac06367b87.tar.bz2 txr-b2c4389575185b5526370d3fb682c6ac06367b87.zip | |
parser: commit Bison-2.5-generated code.
* Makefile (BS_LIC_FROM, BS_LIC_TO): Variables removed.
(y.tab.c): Remove all filtering hacks. Don't remove the
license from y.tab.c. Don't remove yyparse declaration from
y.tab.h. Provide a pattern rule for producing any missing
file X from X.shipped. That's how y.tab.c and y.tab.h
get produced from y.tab.c.shipped and y.tab.h.shipped,
respectively, in user mode.
* y.tab.c.shipped, y.tab.h.shipped: New files, generated
using Bison 2.5.
Diffstat (limited to 'y.tab.c.shipped')
| -rw-r--r-- | y.tab.c.shipped | 7366 |
1 files changed, 7366 insertions, 0 deletions
diff --git a/y.tab.c.shipped b/y.tab.c.shipped new file mode 100644 index 00000000..2345cb9a --- /dev/null +++ b/y.tab.c.shipped @@ -0,0 +1,7366 @@ +/* A Bison parser, made by GNU Bison 2.5. */ + +/* Bison implementation for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "2.5" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 1 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + + + +/* Copy the first part of user declarations. */ + +/* Line 268 of yacc.c */ +#line 1 "parser.y" + + +/* Copyright 2009-2020 + * Kaz Kylheku <kaz@kylheku.com> + * Vancouver, Canada + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <stddef.h> +#include <stdio.h> +#include <assert.h> +#include <limits.h> +#include <stdlib.h> +#include <wchar.h> +#include <signal.h> +#include "config.h" +#include "alloca.h" +#include "lib.h" +#include "signal.h" +#include "unwind.h" +#include "regex.h" +#include "match.h" +#include "hash.h" +#include "struct.h" +#include "eval.h" +#include "tree.h" +#include "y.tab.h" +#include "debug.h" +#include "txr.h" +#include "itypes.h" +#include "buf.h" +#include "parser.h" + +static val sym_helper(parser_t *parser, wchar_t *lexeme, val meta_allowed); +static val repeat_rep_helper(val sym, val args, val main, val parts); +static void process_catch_exprs(val exprs); +static val define_transform(parser_t *parser, val define_form); +static val optimize_text(val text_form); +static val unquotes_occur(val quoted_form, int level); +static val rlrec(parser_t *, val form, val line); +static val rlcp_parser(parser_t *parser, val to, val from); +static wchar_t char_from_name(const wchar_t *name); +static val make_expr(parser_t *, val sym, val rest, val lineno); +static val check_parse_time_action(val spec_rev); +static val uref_helper(parser_t *, val expr); +static val uoref_helper(parser_t *, val expr); +static val qref_helper(parser_t *, val lexpr, val rexpr); +static val fname_helper(parser_t *, val name); + +#if YYBISON +union YYSTYPE; +int yylex(union YYSTYPE *, yyscan_t scanner); +int yyparse(scanner_t *, parser_t *); +#endif + +#define rl(form, line) rlrec(parser, form, line) +#define rlc(to, from) rlcp_parser(parser, to, from) +#define mkexp(sym, rest, lineno) make_expr(parser, sym, rest, lineno) +#define symhlpr(lexeme, meta_allowed) sym_helper(parser, lexeme, meta_allowed) +#define yyerr(msg) yyerror(scnr, parser, msg) +#define yybadtok(tok, context) yybadtoken(parser, tok, context) +#define ifnign(expr) (parser->ignore ? nil : (expr)) + +INLINE val expand_forms_ver(val forms, int ver) +{ + if (!opt_compat || opt_compat >= ver) + return expand_forms(forms, nil); + return forms; +} + +INLINE val expand_form_ver(val form, int ver) +{ + if (!opt_compat || opt_compat >= ver) + return expand(form, nil); + return form; +} + + + +/* Line 268 of yacc.c */ +#line 172 "y.tab.c" + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + SPACE = 258, + TEXT = 259, + SYMTOK = 260, + ALL = 261, + SOME = 262, + NONE = 263, + MAYBE = 264, + CASES = 265, + BLOCK = 266, + CHOOSE = 267, + GATHER = 268, + AND = 269, + OR = 270, + END = 271, + COLLECT = 272, + UNTIL = 273, + COLL = 274, + OUTPUT = 275, + REPEAT = 276, + REP = 277, + SINGLE = 278, + FIRST = 279, + LAST = 280, + EMPTY = 281, + MOD = 282, + MODLAST = 283, + DEFINE = 284, + TRY = 285, + CATCH = 286, + FINALLY = 287, + IF = 288, + ERRTOK = 289, + HASH_BACKSLASH = 290, + HASH_SLASH = 291, + DOTDOT = 292, + HASH_H = 293, + HASH_S = 294, + HASH_R = 295, + HASH_SEMI = 296, + HASH_B_QUOTE = 297, + HASH_N = 298, + HASH_T = 299, + WORDS = 300, + WSPLICE = 301, + QWORDS = 302, + QWSPLICE = 303, + SECRET_ESCAPE_R = 304, + SECRET_ESCAPE_E = 305, + SECRET_ESCAPE_I = 306, + OLD_DOTDOT = 307, + NUMBER = 308, + METANUM = 309, + HASH_N_EQUALS = 310, + HASH_N_HASH = 311, + REGCHAR = 312, + REGTOKEN = 313, + LITCHAR = 314, + SPLICE = 315, + CONSDOT = 316, + LAMBDOT = 317, + UREFDOT = 318, + OREFDOT = 319, + UOREFDOT = 320, + LOW = 321, + ELSE = 322, + ELIF = 323 + }; +#endif +/* Tokens. */ +#define SPACE 258 +#define TEXT 259 +#define SYMTOK 260 +#define ALL 261 +#define SOME 262 +#define NONE 263 +#define MAYBE 264 +#define CASES 265 +#define BLOCK 266 +#define CHOOSE 267 +#define GATHER 268 +#define AND 269 +#define OR 270 +#define END 271 +#define COLLECT 272 +#define UNTIL 273 +#define COLL 274 +#define OUTPUT 275 +#define REPEAT 276 +#define REP 277 +#define SINGLE 278 +#define FIRST 279 +#define LAST 280 +#define EMPTY 281 +#define MOD 282 +#define MODLAST 283 +#define DEFINE 284 +#define TRY 285 +#define CATCH 286 +#define FINALLY 287 +#define IF 288 +#define ERRTOK 289 +#define HASH_BACKSLASH 290 +#define HASH_SLASH 291 +#define DOTDOT 292 +#define HASH_H 293 +#define HASH_S 294 +#define HASH_R 295 +#define HASH_SEMI 296 +#define HASH_B_QUOTE 297 +#define HASH_N 298 +#define HASH_T 299 +#define WORDS 300 +#define WSPLICE 301 +#define QWORDS 302 +#define QWSPLICE 303 +#define SECRET_ESCAPE_R 304 +#define SECRET_ESCAPE_E 305 +#define SECRET_ESCAPE_I 306 +#define OLD_DOTDOT 307 +#define NUMBER 308 +#define METANUM 309 +#define HASH_N_EQUALS 310 +#define HASH_N_HASH 311 +#define REGCHAR 312 +#define REGTOKEN 313 +#define LITCHAR 314 +#define SPLICE 315 +#define CONSDOT 316 +#define LAMBDOT 317 +#define UREFDOT 318 +#define OREFDOT 319 +#define UOREFDOT 320 +#define LOW 321 +#define ELSE 322 +#define ELIF 323 + + + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +{ + +/* Line 293 of yacc.c */ +#line 106 "parser.y" + + wchar_t *lexeme; + union obj *val; + wchar_t chr; + cnum lineno; + + + +/* Line 293 of yacc.c */ +#line 353 "y.tab.c" +} YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +#endif + + +/* Copy the second part of user declarations. */ + + +/* Line 343 of yacc.c */ +#line 365 "y.tab.c" + +#ifdef short +# undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#elif (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +typedef signed char yytype_int8; +#else +typedef short int yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(e) ((void) (e)) +#else +# define YYUSE(e) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(n) (n) +#else +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID (int yyi) +#else +static int +YYID (yyi) + int yyi; +#endif +{ + return yyi; +} +#endif + +#if ! defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 198 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 4526 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 94 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 118 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 418 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 757 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 323 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 89, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 93, 2, 91, 90, 2, 87, 82, 78, + 66, 75, 84, 86, 77, 76, 88, 81, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 85, 68, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 67, 2, 74, 79, 2, 92, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 70, 80, 71, 83, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 69, 72, 73 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint16 yyprhs[] = +{ + 0, 0, 3, 5, 8, 9, 14, 15, 20, 22, + 24, 27, 28, 32, 33, 38, 39, 44, 46, 49, + 52, 53, 57, 58, 63, 64, 69, 71, 74, 77, + 79, 81, 82, 84, 87, 89, 90, 92, 94, 96, + 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, + 118, 122, 126, 132, 138, 142, 146, 150, 154, 158, + 162, 170, 176, 182, 188, 196, 209, 215, 218, 222, + 226, 227, 235, 248, 254, 256, 258, 260, 262, 265, + 268, 272, 276, 286, 292, 299, 300, 304, 305, 308, + 310, 311, 313, 316, 318, 320, 322, 324, 326, 329, + 331, 333, 335, 341, 351, 357, 367, 373, 376, 379, + 382, 385, 390, 393, 396, 399, 404, 410, 413, 415, + 418, 421, 429, 436, 439, 445, 450, 457, 461, 467, + 474, 478, 479, 484, 490, 494, 502, 508, 515, 523, + 532, 535, 541, 546, 553, 559, 561, 564, 566, 568, + 570, 579, 583, 588, 593, 600, 605, 612, 619, 620, + 630, 633, 639, 646, 647, 651, 652, 654, 655, 658, + 660, 661, 663, 666, 668, 671, 673, 675, 677, 679, + 681, 688, 691, 695, 699, 705, 709, 715, 721, 722, + 724, 728, 733, 736, 741, 747, 753, 756, 759, 761, + 763, 765, 767, 769, 771, 776, 779, 785, 789, 792, + 795, 798, 801, 804, 807, 810, 813, 816, 819, 822, + 825, 829, 834, 837, 842, 847, 850, 853, 856, 861, + 865, 868, 871, 873, 875, 877, 879, 881, 882, 884, + 888, 890, 891, 895, 896, 901, 904, 907, 911, 914, + 918, 920, 922, 924, 926, 928, 930, 932, 934, 936, + 938, 940, 942, 944, 946, 949, 952, 954, 957, 958, + 962, 963, 967, 968, 972, 973, 977, 979, 982, 984, + 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004, + 1006, 1008, 1010, 1012, 1015, 1018, 1020, 1023, 1024, 1028, + 1029, 1033, 1034, 1038, 1042, 1047, 1051, 1056, 1060, 1064, + 1067, 1070, 1071, 1075, 1077, 1079, 1080, 1083, 1086, 1088, + 1092, 1095, 1099, 1102, 1104, 1108, 1112, 1115, 1116, 1118, + 1121, 1125, 1128, 1131, 1134, 1138, 1142, 1145, 1148, 1150, + 1152, 1154, 1156, 1158, 1162, 1165, 1167, 1170, 1172, 1174, + 1176, 1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 1196, + 1198, 1200, 1202, 1204, 1206, 1208, 1211, 1214, 1218, 1221, + 1224, 1227, 1230, 1233, 1237, 1240, 1242, 1245, 1247, 1249, + 1251, 1253, 1256, 1258, 1261, 1263, 1266, 1268, 1271, 1274, + 1276, 1278, 1281, 1284, 1288, 1291, 1295, 1298, 1301, 1303, + 1306, 1309, 1311, 1313, 1315, 1317, 1319, 1321, 1323, 1325, + 1327, 1331, 1335, 1339, 1343, 1347, 1351, 1355, 1361 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int16 yyrhs[] = +{ + 95, 0, -1, 108, -1, 49, 190, -1, -1, 50, + 98, 96, 106, -1, -1, 51, 102, 97, 106, -1, + 50, -1, 51, -1, 1, 89, -1, -1, 41, 99, + 181, -1, -1, 41, 88, 100, 181, -1, -1, 41, + 64, 101, 181, -1, 181, -1, 88, 181, -1, 64, + 181, -1, -1, 41, 103, 175, -1, -1, 41, 88, + 104, 175, -1, -1, 41, 64, 105, 175, -1, 175, + -1, 88, 175, -1, 64, 175, -1, 181, -1, 41, + -1, -1, 109, -1, 107, 109, -1, 107, -1, -1, + 110, -1, 111, -1, 112, -1, 113, -1, 114, -1, + 115, -1, 116, -1, 120, -1, 117, -1, 136, -1, + 137, -1, 125, -1, 139, -1, 128, -1, 6, 198, + 123, -1, 6, 198, 1, -1, 7, 170, 75, 198, + 123, -1, 7, 170, 75, 198, 1, -1, 8, 198, + 123, -1, 8, 198, 1, -1, 9, 198, 123, -1, + 9, 198, 1, -1, 10, 198, 123, -1, 10, 198, + 1, -1, 11, 170, 75, 198, 108, 16, 198, -1, + 11, 170, 75, 198, 1, -1, 12, 170, 75, 198, + 123, -1, 12, 170, 75, 198, 1, -1, 13, 170, + 75, 198, 118, 16, 198, -1, 13, 170, 75, 198, + 118, 122, 170, 75, 198, 108, 16, 198, -1, 13, + 170, 75, 198, 1, -1, 108, 119, -1, 14, 198, + 118, -1, 15, 198, 118, -1, -1, 121, 170, 75, + 198, 108, 16, 198, -1, 121, 170, 75, 198, 108, + 122, 170, 75, 198, 108, 16, 198, -1, 121, 170, + 75, 198, 1, -1, 17, -1, 21, -1, 18, -1, + 25, -1, 108, 124, -1, 16, 198, -1, 14, 198, + 123, -1, 15, 198, 123, -1, 33, 186, 75, 198, + 108, 126, 127, 16, 198, -1, 33, 186, 75, 198, + 1, -1, 73, 186, 75, 198, 108, 126, -1, -1, + 72, 198, 108, -1, -1, 129, 89, -1, 130, -1, + -1, 133, -1, 133, 130, -1, 4, -1, 3, -1, + 188, -1, 26, -1, 131, -1, 131, 132, -1, 132, + -1, 154, -1, 165, -1, 19, 170, 75, 129, 16, + -1, 19, 170, 75, 129, 122, 170, 75, 129, 16, + -1, 22, 170, 75, 130, 16, -1, 22, 170, 75, + 130, 122, 170, 75, 130, 16, -1, 11, 170, 75, + 130, 16, -1, 19, 1, -1, 22, 1, -1, 11, + 1, -1, 6, 134, -1, 7, 170, 75, 134, -1, + 8, 134, -1, 9, 134, -1, 10, 134, -1, 12, + 170, 75, 134, -1, 29, 169, 75, 130, 16, -1, + 129, 135, -1, 16, -1, 14, 134, -1, 15, 134, + -1, 29, 169, 75, 198, 108, 16, 198, -1, 29, + 75, 198, 108, 16, 198, -1, 29, 1, -1, 29, + 169, 75, 198, 1, -1, 29, 75, 198, 1, -1, + 30, 198, 108, 138, 16, 198, -1, 30, 198, 1, + -1, 31, 75, 198, 108, 138, -1, 31, 169, 75, + 198, 108, 138, -1, 32, 198, 108, -1, -1, 31, + 75, 198, 1, -1, 31, 169, 75, 198, 1, -1, + 32, 198, 1, -1, 20, 75, 150, 89, 140, 16, + 198, -1, 20, 75, 198, 16, 198, -1, 20, 75, + 198, 140, 16, 198, -1, 20, 169, 75, 198, 140, + 16, 198, -1, 20, 169, 75, 150, 89, 140, 16, + 198, -1, 20, 1, -1, 20, 75, 150, 89, 1, + -1, 20, 75, 198, 1, -1, 20, 169, 75, 150, + 89, 1, -1, 20, 169, 75, 198, 1, -1, 141, + -1, 141, 140, -1, 142, -1, 144, -1, 148, -1, + 21, 186, 75, 198, 147, 143, 16, 198, -1, 21, + 198, 1, -1, 23, 198, 147, 143, -1, 24, 198, + 147, 143, -1, 25, 170, 75, 198, 147, 143, -1, + 26, 198, 147, 143, -1, 27, 170, 75, 198, 147, + 143, -1, 28, 170, 75, 198, 147, 143, -1, -1, + 33, 181, 75, 198, 147, 145, 146, 16, 198, -1, + 33, 75, -1, 33, 181, 75, 198, 1, -1, 73, + 186, 75, 198, 147, 145, -1, -1, 72, 198, 147, + -1, -1, 140, -1, -1, 149, 89, -1, 150, -1, + -1, 151, -1, 151, 150, -1, 211, -1, 211, 150, + -1, 4, -1, 3, -1, 157, -1, 168, -1, 152, + -1, 22, 186, 75, 149, 153, 16, -1, 22, 1, + -1, 23, 149, 153, -1, 24, 149, 153, -1, 25, + 170, 75, 149, 153, -1, 26, 149, 153, -1, 27, + 170, 75, 149, 153, -1, 28, 170, 75, 149, 153, + -1, -1, 5, -1, 70, 5, 71, -1, 70, 5, + 156, 71, -1, 155, 5, -1, 155, 70, 5, 71, + -1, 155, 70, 5, 188, 71, -1, 155, 70, 5, + 53, 71, -1, 5, 1, -1, 155, 1, -1, 84, + -1, 53, -1, 188, -1, 168, -1, 5, -1, 5, + -1, 70, 181, 186, 71, -1, 5, 1, -1, 68, + 70, 181, 186, 71, -1, 68, 70, 1, -1, 90, + 165, -1, 90, 1, -1, 38, 165, -1, 38, 1, + -1, 39, 165, -1, 39, 1, -1, 40, 165, -1, + 40, 1, -1, 43, 165, -1, 43, 1, -1, 44, + 165, -1, 44, 1, -1, 66, 171, 75, -1, 66, + 88, 171, 75, -1, 66, 75, -1, 66, 62, 181, + 75, -1, 66, 61, 181, 75, -1, 66, 1, -1, + 68, 181, -1, 68, 1, -1, 67, 88, 171, 74, + -1, 67, 171, 74, -1, 67, 74, -1, 67, 1, + -1, 165, -1, 167, -1, 166, -1, 171, -1, 169, + -1, -1, 172, -1, 172, 61, 181, -1, 181, -1, + -1, 41, 173, 181, -1, -1, 172, 41, 174, 181, + -1, 172, 181, -1, 46, 206, -1, 172, 46, 206, + -1, 48, 207, -1, 172, 48, 207, -1, 5, -1, + 54, -1, 53, -1, 168, -1, 159, -1, 160, -1, + 161, -1, 162, -1, 163, -1, 164, -1, 189, -1, + 200, -1, 199, -1, 201, -1, 45, 206, -1, 47, + 207, -1, 208, -1, 78, 180, -1, -1, 79, 176, + 180, -1, -1, 77, 177, 180, -1, -1, 60, 178, + 180, -1, -1, 55, 179, 180, -1, 56, -1, 88, + 175, -1, 175, -1, 5, -1, 54, -1, 53, -1, + 168, -1, 159, -1, 160, -1, 161, -1, 162, -1, + 163, -1, 164, -1, 189, -1, 200, -1, 199, -1, + 201, -1, 45, 206, -1, 47, 207, -1, 208, -1, + 78, 187, -1, -1, 79, 182, 187, -1, -1, 77, + 183, 187, -1, -1, 60, 184, 187, -1, 181, 37, + 181, -1, 181, 37, 88, 181, -1, 181, 52, 181, + -1, 181, 52, 88, 181, -1, 181, 88, 181, -1, + 181, 64, 181, -1, 63, 181, -1, 65, 181, -1, + -1, 55, 185, 187, -1, 56, -1, 171, -1, -1, + 88, 181, -1, 64, 181, -1, 181, -1, 81, 190, + 81, -1, 81, 1, -1, 36, 190, 81, -1, 36, + 1, -1, 191, -1, 190, 80, 190, -1, 190, 82, + 190, -1, 83, 190, -1, -1, 192, -1, 192, 191, + -1, 192, 83, 190, -1, 192, 84, -1, 192, 86, + -1, 192, 85, -1, 192, 87, 190, -1, 67, 193, + 74, -1, 67, 74, -1, 67, 1, -1, 88, -1, + 74, -1, 76, -1, 57, -1, 197, -1, 66, 190, + 75, -1, 66, 1, -1, 194, -1, 194, 193, -1, + 195, -1, 196, -1, 197, -1, 196, 76, 196, -1, + 85, -1, 88, -1, 84, -1, 86, -1, 66, -1, + 75, -1, 80, -1, 83, -1, 82, -1, 87, -1, + 81, -1, 57, -1, 58, -1, 89, -1, 1, 89, + -1, 91, 91, -1, 91, 204, 91, -1, 91, 1, + -1, 35, 5, -1, 35, 59, -1, 35, 1, -1, + 92, 92, -1, 92, 202, 92, -1, 92, 1, -1, + 203, -1, 203, 202, -1, 204, -1, 4, -1, 158, + -1, 54, -1, 68, 181, -1, 59, -1, 59, 205, + -1, 59, -1, 205, 59, -1, 91, -1, 93, 206, + -1, 204, 206, -1, 1, -1, 92, -1, 93, 207, + -1, 202, 92, -1, 202, 93, 207, -1, 42, 78, + -1, 42, 209, 78, -1, 42, 1, -1, 209, 210, + -1, 210, -1, 59, 59, -1, 59, 1, -1, 6, + -1, 7, -1, 8, -1, 9, -1, 10, -1, 14, + -1, 15, -1, 30, -1, 32, -1, 11, 170, 75, + -1, 12, 170, 75, -1, 17, 170, 75, -1, 19, + 170, 75, -1, 13, 170, 75, -1, 29, 170, 75, + -1, 31, 170, 75, -1, 33, 181, 181, 170, 75, + -1, 20, 170, 75, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint16 yyrline[] = +{ + 0, 173, 173, 174, 176, 175, 179, 178, 181, 188, + 195, 204, 204, 207, 207, 210, 210, 213, 214, 215, + 218, 218, 221, 221, 224, 224, 227, 228, 229, 234, + 235, 236, 239, 240, 243, 244, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 259, 260, 261, 262, + 265, 267, 271, 274, 280, 282, 286, 288, 292, 294, + 298, 309, 314, 317, 322, 331, 343, 348, 352, 353, + 354, 357, 363, 375, 380, 381, 384, 385, 388, 391, + 392, 393, 396, 419, 423, 436, 439, 444, 447, 450, + 451, 454, 456, 461, 462, 470, 472, 475, 476, 479, + 481, 483, 491, 494, 502, 505, 514, 517, 519, 521, + 523, 524, 526, 527, 528, 529, 532, 538, 541, 542, + 543, 546, 551, 555, 557, 559, 564, 572, 577, 582, + 588, 593, 594, 597, 600, 606, 610, 612, 615, 627, + 632, 634, 637, 640, 643, 648, 649, 652, 653, 654, + 657, 663, 668, 672, 676, 685, 689, 696, 703, 706, + 718, 721, 725, 736, 739, 742, 745, 746, 748, 751, + 753, 756, 757, 758, 759, 762, 764, 766, 767, 769, + 772, 775, 779, 782, 785, 793, 796, 802, 808, 815, + 816, 817, 818, 819, 820, 823, 827, 829, 833, 836, + 837, 839, 841, 844, 849, 858, 862, 865, 870, 875, + 879, 885, 889, 896, 900, 904, 908, 913, 917, 930, + 934, 935, 941, 942, 943, 944, 948, 953, 957, 961, + 962, 963, 967, 968, 969, 972, 975, 976, 979, 981, + 986, 989, 989, 993, 993, 996, 999, 1001, 1005, 1007, + 1013, 1014, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, + 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1033, 1033, + 1037, 1037, 1041, 1041, 1045, 1045, 1048, 1051, 1052, 1054, + 1055, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, + 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1074, 1074, 1078, + 1078, 1082, 1082, 1086, 1089, 1095, 1099, 1105, 1106, 1109, + 1110, 1111, 1111, 1114, 1117, 1118, 1121, 1122, 1123, 1126, + 1129, 1134, 1138, 1144, 1147, 1148, 1149, 1150, 1153, 1154, + 1155, 1158, 1159, 1160, 1161, 1162, 1169, 1170, 1172, 1173, + 1174, 1175, 1176, 1177, 1178, 1182, 1183, 1186, 1187, 1188, + 1191, 1193, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, + 1202, 1203, 1204, 1207, 1221, 1222, 1226, 1227, 1229, 1233, + 1246, 1248, 1253, 1254, 1257, 1261, 1263, 1267, 1268, 1269, + 1270, 1272, 1279, 1280, 1284, 1285, 1288, 1289, 1290, 1292, + 1296, 1297, 1298, 1300, 1306, 1308, 1311, 1316, 1318, 1322, + 1323, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, + 1339, 1341, 1343, 1345, 1347, 1349, 1351, 1353, 1358 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "SPACE", "TEXT", "SYMTOK", "ALL", "SOME", + "NONE", "MAYBE", "CASES", "BLOCK", "CHOOSE", "GATHER", "AND", "OR", + "END", "COLLECT", "UNTIL", "COLL", "OUTPUT", "REPEAT", "REP", "SINGLE", + "FIRST", "LAST", "EMPTY", "MOD", "MODLAST", "DEFINE", "TRY", "CATCH", + "FINALLY", "IF", "ERRTOK", "HASH_BACKSLASH", "HASH_SLASH", "DOTDOT", + "HASH_H", "HASH_S", "HASH_R", "HASH_SEMI", "HASH_B_QUOTE", "HASH_N", + "HASH_T", "WORDS", "WSPLICE", "QWORDS", "QWSPLICE", "SECRET_ESCAPE_R", + "SECRET_ESCAPE_E", "SECRET_ESCAPE_I", "OLD_DOTDOT", "NUMBER", "METANUM", + "HASH_N_EQUALS", "HASH_N_HASH", "REGCHAR", "REGTOKEN", "LITCHAR", + "SPLICE", "CONSDOT", "LAMBDOT", "UREFDOT", "OREFDOT", "UOREFDOT", "'('", + "'['", "'@'", "LOW", "'{'", "'}'", "ELSE", "ELIF", "']'", "')'", "'-'", + "','", "'\\''", "'^'", "'|'", "'/'", "'&'", "'~'", "'*'", "'?'", "'+'", + "'%'", "'.'", "'\\n'", "'#'", "'\"'", "'`'", "' '", "$accept", "spec", + "$@1", "$@2", "hash_semi_or_n_expr", "$@3", "$@4", "$@5", + "hash_semi_or_i_expr", "$@6", "$@7", "$@8", "byacc_fool", "clauses_rev", + "clauses_opt", "clause", "all_clause", "some_clause", "none_clause", + "maybe_clause", "cases_clause", "block_clause", "choose_clause", + "gather_clause", "gather_parts", "additional_gather_parts", + "collect_clause", "collect_repeat", "until_last", "clause_parts", + "additional_parts", "if_clause", "elif_clauses_opt", "else_clause_opt", + "line", "elems_opt", "elems", "text", "texts", "elem", "clause_parts_h", + "additional_parts_h", "define_clause", "try_clause", "catch_clauses_opt", + "output_clause", "out_clauses", "out_clause", "repeat_clause", + "repeat_parts_opt", "out_if_clause", "out_elif_clauses_opt", + "out_else_clause_opt", "out_clauses_opt", "o_line", "o_elems_opt", + "o_elems", "o_elem", "rep_elem", "rep_parts_opt", "var", "var_op", + "modifiers", "o_var", "q_var", "vector", "hash", "struct", "range", + "tnode", "tree", "list", "meta", "dwim", "compound", "exprs", + "exprs_opt", "n_exprs", "listacc", "$@9", "$@10", "i_expr", "$@11", + "$@12", "$@13", "$@14", "i_dot_expr", "n_expr", "$@15", "$@16", "$@17", + "$@18", "n_exprs_opt", "n_dot_expr", "regex", "lisp_regex", "regexpr", + "regbranch", "regterm", "regclass", "regclassterm", "regrange", + "regchar", "regtoken", "newl", "strlit", "chrlit", "quasilit", + "quasi_items", "quasi_item", "litchars", "restlitchar", "wordslit", + "wordsqlit", "buflit", "buflit_items", "buflit_item", "not_a_clause", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const yytype_uint16 yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 40, 91, 64, 321, + 123, 125, 322, 323, 93, 41, 45, 44, 39, 94, + 124, 47, 38, 126, 42, 63, 43, 37, 46, 10, + 35, 34, 96, 32 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint8 yyr1[] = +{ + 0, 94, 95, 95, 96, 95, 97, 95, 95, 95, + 95, 99, 98, 100, 98, 101, 98, 98, 98, 98, + 103, 102, 104, 102, 105, 102, 102, 102, 102, 106, + 106, 106, 107, 107, 108, 108, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 110, 110, 111, 111, 112, 112, 113, 113, 114, 114, + 115, 115, 116, 116, 117, 117, 117, 118, 119, 119, + 119, 120, 120, 120, 121, 121, 122, 122, 123, 124, + 124, 124, 125, 125, 126, 126, 127, 127, 128, 129, + 129, 130, 130, 131, 131, 131, 131, 132, 132, 133, + 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, + 133, 133, 133, 133, 133, 133, 133, 134, 135, 135, + 135, 136, 136, 136, 136, 136, 137, 137, 138, 138, + 138, 138, 138, 138, 138, 139, 139, 139, 139, 139, + 139, 139, 139, 139, 139, 140, 140, 141, 141, 141, + 142, 142, 143, 143, 143, 143, 143, 143, 143, 144, + 144, 144, 145, 145, 146, 146, 147, 147, 148, 149, + 149, 150, 150, 150, 150, 151, 151, 151, 151, 151, + 152, 152, 153, 153, 153, 153, 153, 153, 153, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 155, 156, + 156, 156, 156, 157, 157, 157, 158, 158, 159, 159, + 160, 160, 161, 161, 162, 162, 163, 163, 164, 164, + 165, 165, 165, 165, 165, 165, 166, 166, 167, 167, + 167, 167, 168, 168, 168, 169, 170, 170, 171, 171, + 172, 173, 172, 174, 172, 172, 172, 172, 172, 172, + 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, 176, 175, + 177, 175, 178, 175, 179, 175, 175, 180, 180, 181, + 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, + 181, 181, 181, 181, 181, 181, 181, 182, 181, 183, + 181, 184, 181, 181, 181, 181, 181, 181, 181, 181, + 181, 185, 181, 181, 186, 186, 187, 187, 187, 188, + 188, 189, 189, 190, 190, 190, 190, 190, 191, 191, + 191, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 193, 193, 194, 194, 194, + 195, 196, 196, 196, 196, 196, 196, 196, 196, 196, + 196, 196, 196, 197, 198, 198, 199, 199, 199, 200, + 200, 200, 201, 201, 201, 202, 202, 203, 203, 203, + 203, 203, 204, 204, 205, 205, 206, 206, 206, 206, + 207, 207, 207, 207, 208, 208, 208, 209, 209, 210, + 210, 211, 211, 211, 211, 211, 211, 211, 211, 211, + 211, 211, 211, 211, 211, 211, 211, 211, 211 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 1, 2, 0, 4, 0, 4, 1, 1, + 2, 0, 3, 0, 4, 0, 4, 1, 2, 2, + 0, 3, 0, 4, 0, 4, 1, 2, 2, 1, + 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 3, 3, 5, 5, 3, 3, 3, 3, 3, 3, + 7, 5, 5, 5, 7, 12, 5, 2, 3, 3, + 0, 7, 12, 5, 1, 1, 1, 1, 2, 2, + 3, 3, 9, 5, 6, 0, 3, 0, 2, 1, + 0, 1, 2, 1, 1, 1, 1, 1, 2, 1, + 1, 1, 5, 9, 5, 9, 5, 2, 2, 2, + 2, 4, 2, 2, 2, 4, 5, 2, 1, 2, + 2, 7, 6, 2, 5, 4, 6, 3, 5, 6, + 3, 0, 4, 5, 3, 7, 5, 6, 7, 8, + 2, 5, 4, 6, 5, 1, 2, 1, 1, 1, + 8, 3, 4, 4, 6, 4, 6, 6, 0, 9, + 2, 5, 6, 0, 3, 0, 1, 0, 2, 1, + 0, 1, 2, 1, 2, 1, 1, 1, 1, 1, + 6, 2, 3, 3, 5, 3, 5, 5, 0, 1, + 3, 4, 2, 4, 5, 5, 2, 2, 1, 1, + 1, 1, 1, 1, 4, 2, 5, 3, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 3, 4, 2, 4, 4, 2, 2, 2, 4, 3, + 2, 2, 1, 1, 1, 1, 1, 0, 1, 3, + 1, 0, 3, 0, 4, 2, 2, 3, 2, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 2, 2, 1, 2, 0, 3, + 0, 3, 0, 3, 0, 3, 1, 2, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 2, 2, 1, 2, 0, 3, 0, + 3, 0, 3, 3, 4, 3, 4, 3, 3, 2, + 2, 0, 3, 1, 1, 0, 2, 2, 1, 3, + 2, 3, 2, 1, 3, 3, 2, 0, 1, 2, + 3, 2, 2, 2, 3, 3, 2, 2, 1, 1, + 1, 1, 1, 3, 2, 1, 2, 1, 1, 1, + 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 2, 2, 3, 2, 2, + 2, 2, 2, 3, 2, 1, 2, 1, 1, 1, + 1, 2, 1, 2, 1, 2, 1, 2, 2, 1, + 1, 2, 2, 3, 2, 3, 2, 2, 1, 2, + 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 3, 3, 3, 3, 3, 3, 3, 5, 3 +}; + +/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const yytype_uint16 yydefact[] = +{ + 0, 0, 94, 93, 0, 0, 237, 0, 0, 0, + 0, 237, 237, 74, 0, 0, 75, 0, 96, 0, + 0, 315, 327, 8, 9, 0, 0, 0, 198, 0, + 34, 2, 32, 36, 37, 38, 39, 40, 41, 42, + 44, 43, 237, 47, 49, 0, 89, 97, 99, 91, + 45, 46, 48, 100, 0, 101, 95, 10, 196, 0, + 90, 237, 90, 90, 90, 0, 237, 0, 364, 0, + 110, 0, 279, 0, 0, 0, 0, 0, 241, 0, + 0, 0, 0, 0, 0, 0, 281, 280, 311, 313, + 301, 0, 0, 0, 0, 299, 0, 297, 0, 0, + 0, 283, 284, 285, 286, 287, 288, 232, 234, 233, + 282, 236, 0, 235, 238, 240, 289, 291, 290, 292, + 295, 112, 0, 113, 0, 114, 0, 109, 0, 0, + 0, 107, 0, 140, 0, 0, 108, 0, 123, 0, + 0, 0, 314, 0, 341, 363, 0, 0, 339, 340, + 327, 338, 3, 323, 328, 342, 11, 0, 0, 4, + 17, 250, 20, 0, 0, 252, 251, 274, 276, 272, + 0, 270, 0, 268, 0, 6, 254, 255, 256, 257, + 258, 259, 253, 26, 260, 262, 261, 263, 266, 225, + 0, 0, 222, 0, 0, 0, 320, 0, 1, 33, + 0, 88, 98, 92, 197, 192, 0, 365, 0, 0, + 0, 0, 90, 90, 118, 117, 51, 0, 50, 371, + 369, 370, 322, 0, 211, 210, 213, 212, 215, 214, + 0, 396, 0, 394, 0, 398, 217, 216, 219, 218, + 389, 382, 386, 0, 0, 293, 246, 378, 380, 0, + 390, 0, 379, 0, 375, 377, 294, 248, 0, 0, + 309, 310, 231, 230, 0, 0, 227, 226, 0, 0, + 0, 318, 296, 0, 209, 208, 368, 366, 0, 374, + 372, 0, 0, 243, 0, 0, 0, 245, 0, 0, + 0, 0, 55, 54, 57, 56, 59, 58, 0, 0, + 0, 90, 176, 175, 0, 401, 402, 403, 404, 405, + 237, 237, 237, 406, 407, 237, 237, 237, 0, 237, + 408, 237, 409, 0, 0, 0, 171, 179, 177, 178, + 0, 173, 0, 0, 0, 0, 127, 131, 0, 344, + 0, 337, 362, 355, 336, 356, 357, 361, 359, 358, + 353, 351, 354, 360, 352, 0, 345, 347, 348, 349, + 326, 327, 327, 327, 331, 333, 332, 327, 329, 15, + 13, 0, 19, 18, 31, 24, 22, 0, 264, 265, + 0, 0, 28, 0, 0, 278, 267, 0, 27, 31, + 0, 0, 0, 220, 202, 199, 190, 0, 201, 200, + 319, 0, 0, 90, 0, 90, 0, 119, 120, 0, + 0, 0, 78, 321, 242, 400, 399, 395, 397, 384, + 383, 387, 388, 0, 381, 391, 392, 0, 376, 312, + 302, 0, 229, 300, 317, 316, 298, 367, 373, 111, + 0, 0, 247, 249, 239, 0, 303, 0, 305, 308, + 307, 0, 0, 115, 0, 0, 0, 205, 0, 0, + 0, 0, 0, 0, 181, 0, 0, 0, 0, 315, + 0, 172, 142, 0, 0, 0, 0, 145, 147, 148, + 149, 0, 169, 174, 0, 0, 0, 125, 0, 0, + 0, 0, 0, 0, 0, 343, 335, 346, 0, 324, + 325, 330, 334, 0, 0, 12, 30, 5, 29, 0, + 0, 21, 275, 273, 271, 277, 269, 7, 224, 223, + 221, 191, 0, 0, 193, 0, 35, 35, 79, 385, + 207, 315, 393, 228, 53, 52, 244, 304, 306, 106, + 61, 0, 63, 62, 66, 70, 0, 102, 76, 77, + 237, 410, 411, 414, 412, 413, 418, 170, 415, 416, + 237, 0, 141, 0, 136, 0, 0, 160, 0, 0, + 146, 168, 0, 144, 0, 104, 237, 0, 116, 124, + 0, 0, 0, 0, 0, 83, 85, 350, 16, 14, + 25, 23, 73, 0, 195, 194, 80, 81, 0, 0, + 0, 0, 67, 0, 237, 0, 188, 0, 204, 0, + 0, 151, 0, 137, 143, 0, 0, 0, 122, 0, + 0, 0, 134, 130, 126, 315, 87, 0, 237, 206, + 60, 35, 35, 64, 0, 90, 170, 170, 237, 170, + 237, 237, 0, 417, 135, 167, 0, 0, 138, 0, + 121, 132, 131, 0, 0, 0, 0, 71, 0, 68, + 69, 0, 0, 188, 188, 0, 188, 0, 0, 180, + 166, 158, 161, 163, 139, 0, 128, 133, 131, 0, + 35, 0, 0, 35, 103, 182, 183, 170, 185, 170, + 170, 0, 0, 237, 0, 237, 237, 0, 315, 165, + 105, 129, 35, 86, 82, 35, 0, 188, 188, 188, + 167, 167, 0, 167, 0, 0, 0, 0, 0, 0, + 85, 0, 0, 184, 186, 187, 158, 158, 0, 158, + 0, 0, 150, 0, 167, 0, 84, 0, 65, 152, + 153, 167, 155, 167, 167, 167, 164, 159, 72, 158, + 158, 158, 163, 154, 156, 157, 162 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int16 yydefgoto[] = +{ + -1, 29, 374, 389, 159, 371, 504, 503, 175, 377, + 510, 509, 507, 30, 217, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 546, 602, 41, 42, 550, 218, + 412, 43, 626, 656, 44, 45, 46, 47, 48, 49, + 70, 215, 50, 51, 493, 52, 670, 477, 478, 697, + 479, 699, 719, 671, 480, 481, 482, 326, 327, 642, + 53, 54, 397, 328, 252, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 230, + 441, 385, 387, 383, 381, 380, 386, 115, 273, 268, + 259, 258, 143, 272, 56, 116, 152, 153, 154, 355, + 356, 357, 358, 155, 71, 117, 118, 119, 253, 254, + 255, 420, 245, 256, 120, 234, 235, 331 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -608 +static const yytype_int16 yypact[] = +{ + 1827, -32, -608, -608, 3244, 3271, 3636, 3271, 3271, 3271, + 1326, 3636, 3636, -608, 1394, 1462, -608, 1530, -608, 1598, + 10, 3636, 700, 3695, 3823, 1110, 59, 207, -608, 68, + 4414, -608, -608, -608, -608, -608, -608, -608, -608, -608, + -608, -608, 3636, -608, -608, 13, -608, 27, -608, 832, + -608, -608, -608, -608, 36, -608, -608, -608, -608, 54, + 832, 3636, 832, 832, 832, 1326, 3636, 3636, -608, 287, + -608, 2145, -608, 91, 1139, 11, 17, 31, -608, 22, + 37, 38, 25, 25, 175, 175, -608, -608, -608, -608, + -608, 4176, 4176, 1190, 1015, -608, 3759, -608, 39, 35, + 65, -608, -608, -608, -608, -608, -608, -608, -608, -608, + -608, -608, 4, -608, 3454, 43, -608, -608, -608, -608, + -608, -608, 2176, -608, 2263, -608, 2294, -608, 72, 74, + 83, -608, 87, -608, 2937, 99, -608, 112, -608, 10, + 113, 2381, -608, 115, -608, -608, 935, 874, -608, -608, + 700, -608, -19, -608, 1785, -608, -21, 4176, 4176, -608, + 43, -608, 34, 25, 175, -608, -608, -608, -608, -608, + 4293, -608, 4235, -608, 4293, -608, -608, -608, -608, -608, + -608, -608, -608, -608, -608, -608, -608, -608, -608, -608, + 4176, 4176, -608, 3636, 127, 178, -608, 268, -608, -608, + 136, -608, -608, -608, -608, -608, 135, -608, 165, 167, + 177, 181, 832, 832, -608, -608, -608, 377, -608, -608, + -608, -608, -608, 326, -608, -608, -608, -608, -608, -608, + 4176, -608, 51, -608, -31, -608, -608, -608, -608, -608, + -608, 191, -608, 25, 25, -608, -608, -608, -608, 3881, + -608, 175, -608, -43, 144, -608, -608, -608, 3759, 3759, + -10, -10, -608, -608, 3636, 183, -608, 43, 3759, 4176, + 4176, 43, -608, 3759, -608, -608, -608, -608, 169, -608, + -608, 174, 3271, -608, 25, 175, 4176, 43, 3940, 3999, + 4176, 4176, -608, -608, -608, -608, -608, -608, 796, 3271, + 10, 832, -608, -608, 1914, -608, -608, -608, -608, -608, + 3636, 3636, 3636, -608, -608, 3636, 3636, 3636, 1666, 3636, + -608, 3636, -608, 4176, 4176, 180, 4456, -608, -608, -608, + 2074, 4456, 2937, 832, 3008, 796, -608, 80, 10, -608, + 254, -608, -608, -608, -608, -608, -608, -608, -608, -608, + -608, -608, -608, -608, -608, 210, 956, -608, 209, -608, + -608, 700, 700, 700, -608, -608, -608, 700, -608, -608, + -608, 4176, 43, 43, 4058, -608, -608, 4293, -608, -608, + 4235, 4235, -608, 4235, 4293, -608, -608, 4235, -608, 4058, + 245, 263, 224, -608, -608, -608, -608, 233, -608, -608, + -608, 10, 75, 832, 832, 832, 832, -608, -608, 10, + 10, 10, -608, -608, 43, -608, -608, -608, -608, -608, + 257, -608, -608, 1734, 43, -608, -608, 175, -608, -608, + -608, 244, -608, -608, -10, -10, -608, -608, -608, -608, + 2415, 4176, -608, -608, 43, 4176, 43, 4176, 267, -10, + -10, 308, 3039, -608, 2502, 2043, 223, -608, 255, 264, + 265, 271, 277, 278, -608, 291, 295, 298, 3513, 3326, + 2533, -608, -608, 10, 1258, 4117, 365, 4383, -608, -608, + -608, 293, -608, -608, 296, 2604, 261, -608, 372, 373, + 3126, 3577, 10, 379, 2647, -608, -608, -608, 1204, 314, + -608, -608, -608, 4176, 4176, 43, -608, -608, 43, 4293, + 4293, -608, -608, -608, -608, -608, -608, -608, -608, -608, + -608, -608, 2678, 328, -608, 330, 4414, 4414, -608, -608, + -608, 3326, -608, -608, -608, -608, 43, -10, -10, -608, + -608, 393, -608, -608, -608, 154, 280, -608, -608, -608, + 3636, -608, -608, -608, -608, -608, -608, 4456, -608, -608, + 3326, 339, -608, 396, -608, 338, 413, -608, 3390, 10, + -608, -608, 2765, -608, 400, -608, 3636, 10, -608, -608, + 402, 10, 348, 3157, 10, -608, 351, -608, 43, 43, + -608, -608, -608, 319, -608, -608, -608, -608, 354, 10, + 10, 10, -608, 10, 3636, 356, 479, 357, -608, 10, + 10, -608, 10, -608, -608, 418, 10, 361, -608, 10, + 2808, 10, -608, -608, -608, 3636, 380, 10, 3636, -608, + -608, 4414, 4414, -608, 362, 832, 4456, 4456, 3636, 4456, + 3636, 3636, 435, -608, -608, 4383, 1956, 10, -608, 832, + -608, -608, 80, 2895, 381, 10, 438, -608, 383, -608, + -608, 10, 443, 479, 479, 385, 479, 390, 397, -608, + -608, 518, -608, 401, -608, 457, -608, -608, 80, 10, + 4414, 10, 10, 4414, -608, -608, -608, 4456, -608, 4456, + 4456, 10, 10, 3636, 10, 3636, 3636, 462, 3636, 408, + -608, -608, 4414, -608, -608, 4414, 465, 479, 479, 479, + 4383, 4383, 409, 4383, 416, 417, 10, 419, 10, 481, + 351, 482, 10, -608, -608, -608, 518, 518, 10, 518, + 10, 10, -608, 10, 4383, 10, -608, 10, -608, -608, + -608, 4383, -608, 4383, 4383, 4383, -608, -608, -608, 518, + 518, 518, 401, -608, -608, -608, -608 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = +{ + -608, -608, -608, -608, -608, -608, -608, -608, -608, -608, + -608, -608, 40, -608, 85, 458, -608, -608, -608, -608, + -608, -608, -608, -608, -460, -608, -608, -608, -476, -78, + -608, -608, -225, -608, -608, 12, -27, -608, 452, -608, + 764, -608, -608, -608, -607, -608, -325, -608, -608, -329, + -608, -244, -608, -590, -608, -548, -110, -608, -608, -446, + -608, -608, -608, -608, -608, 3, 58, 63, 106, 140, + 173, 129, -608, -608, -9, -12, 48, 8, -608, -608, + -608, 49, -608, -608, -608, -608, -26, 656, -608, -608, + -608, -608, -293, -74, -187, 283, 108, 355, -608, 158, + -608, -608, 18, -143, -7, 472, 487, 523, -84, -608, + -48, -608, -77, -71, 607, -608, 276, -608 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -328 +static const yytype_int16 yytable[] = +{ + 122, 124, 126, 135, 359, 476, 246, 140, 399, 606, + 576, 59, 224, 141, 257, 182, 281, 69, 226, 69, + 69, 69, 203, 231, 325, 465, 240, 176, 232, 142, + 2, 3, 228, 194, 244, 244, 276, 204, 236, 238, + 274, 205, 289, 369, 293, 676, 295, 417, 297, 426, + 427, 278, 415, 18, 290, 211, 673, 57, 128, 129, + 130, 361, 132, 362, 195, 137, 279, 370, 198, 247, + 604, 701, 69, 183, 69, 69, 69, 25, 291, 282, + 288, 232, 177, 25, 241, 31, 378, 178, 663, 664, + 200, 666, 219, 379, 241, 289, 220, 25, 375, 68, + 233, 265, 201, 25, 25, 25, 206, 290, 27, 208, + 416, 491, 492, 209, 210, 244, 242, 628, 243, 248, + 726, 727, 376, 729, 241, 329, 277, 330, 523, 55, + 179, 291, 334, 249, 55, 197, 55, 55, 55, 707, + 402, 708, 709, 207, 746, 563, 524, 298, 247, 299, + 221, 749, 570, 750, 751, 752, 27, 280, 300, 55, + 574, 182, 301, 182, 180, 182, 421, 422, 600, 601, + 428, 659, 660, 176, 332, 176, 561, 176, 55, 247, + 425, 565, 223, 394, 429, 430, 398, 333, 335, 55, + 338, 55, 55, 55, 433, 244, 244, 181, 248, 436, + 55, 392, 393, 241, 225, 227, 229, 442, 196, 237, + 239, 401, 249, 359, 443, 525, 471, 685, 686, 382, + 688, 483, 484, 388, 69, 69, 337, 275, 177, 248, + 177, 395, 177, 178, 241, 178, 244, 178, 598, 547, + 403, 548, 404, 249, 25, 93, 94, 615, 549, 396, + 419, 55, 405, 55, 340, 55, 406, 432, 360, 27, + 437, 723, 724, 725, 144, 145, 438, 250, 251, 470, + 55, 451, 431, 146, 147, 440, 179, 575, 179, 548, + 179, 148, 288, 149, 496, 498, 549, -327, -327, -327, + 150, 452, 454, 455, 69, 151, 603, 289, 548, 520, + 288, 212, 213, 214, 521, 549, 486, 184, 489, 290, + 180, 69, 180, 456, 180, 289, 529, 329, 533, 289, + 518, 329, 329, 329, 539, 485, 142, 290, 490, 495, + 551, 494, 654, 291, 361, 627, 362, 548, 519, 552, + 553, 55, 55, 181, 549, 181, 554, 181, 361, 400, + 362, 291, 555, 556, 512, 513, 532, 514, 458, 459, + 460, 516, 535, 461, 462, 463, 557, 466, 182, 467, + 558, 182, 182, 559, 182, 182, 543, 451, 182, 489, + 176, 569, 571, 176, 176, 572, 176, 176, 577, 578, + 176, 409, 410, 411, 522, 584, 362, 739, 740, 594, + 742, 595, 526, 527, 528, 717, 361, 413, 362, 599, + 608, 55, 609, 610, 611, 69, 616, 69, 619, 488, + 753, 754, 755, 621, 625, 629, 511, 55, 55, 517, + 55, 635, 643, 515, 647, 177, 649, 661, 177, 177, + 178, 177, 177, 178, 178, 177, 178, 178, 596, 597, + 178, 669, 655, 184, 681, 184, 679, 184, 682, 684, + 687, 329, 55, 55, 55, 689, 564, 566, 329, 499, + 500, 501, 690, 700, 698, 502, 329, 142, 716, 582, + 718, 722, 142, 179, 728, 583, 179, 179, 199, 179, + 179, 730, 731, 179, 733, 736, 185, 735, 737, 202, + 182, 182, 636, 637, 638, 639, 640, 641, 756, 368, + 418, 186, 176, 176, 497, 0, 587, 180, 0, 0, + 180, 180, 0, 180, 180, 0, 0, 180, 0, 0, + 0, 0, 55, 55, 55, 55, 0, 541, 0, 142, + 545, 691, 692, 693, 694, 695, 696, 187, 329, 0, + 181, 0, 0, 181, 181, 0, 181, 181, 590, 591, + 181, 0, 613, 329, 0, 0, 0, 177, 177, 55, + 618, 0, 178, 178, 620, 580, 0, 624, 0, 586, + 0, 55, 0, 55, 55, 0, 0, 0, 0, 0, + 0, 0, 630, 631, 632, 0, 633, 0, 605, 0, + 0, 0, 644, 645, 0, 646, 0, 593, 607, 648, + 0, 0, 650, 0, 653, 179, 179, 0, 0, 55, + 657, 0, 675, 55, 617, 0, 0, 329, 329, 0, + 329, 188, 0, 142, 0, 0, 329, 329, 0, 0, + 674, 0, 185, 0, 185, 0, 185, 662, 680, 180, + 180, 55, 634, 0, 683, 55, 55, 186, 0, 186, + 184, 186, 0, 184, 184, 0, 184, 184, 623, 0, + 184, 0, 702, 0, 704, 705, 658, 0, 329, 160, + 329, 329, 181, 181, 710, 711, 665, 713, 667, 668, + 0, 0, 0, 187, 0, 187, 0, 187, 0, 0, + 0, 329, 329, 0, 329, 652, 142, 0, 0, 732, + 0, 734, 55, 0, 0, 738, 545, 545, 0, 0, + 0, 741, 0, 743, 744, 329, 745, 0, 747, 0, + 748, 0, 329, 0, 329, 329, 329, 0, 678, 0, + 0, 712, 0, 714, 715, 0, 0, 260, 261, 55, + 267, 0, 271, 0, 0, 0, 0, 144, 145, 0, + 55, 55, 0, 0, 55, 703, 146, 147, 706, 0, + 287, 121, 123, 125, 148, 0, 149, 188, 55, 188, + 0, 188, 55, 150, 0, 0, 0, 720, 151, 0, + 721, 0, 184, 184, 0, 0, 0, 59, 0, 2, + 3, 4, 60, 61, 62, 63, 64, 65, 66, 55, + 0, 0, 55, 372, 373, 14, 0, 0, 17, 0, + 0, 0, 18, 0, 0, 67, 121, 123, 125, 0, + 0, 55, 0, 0, 55, 2, 3, 4, 60, 61, + 62, 63, 64, 65, 66, 0, 390, 391, 0, 185, + 0, 14, 185, 185, 17, 185, 185, 0, 18, 185, + 0, 67, 25, 0, 186, 0, 26, 186, 186, 0, + 186, 186, 0, 0, 186, 341, 0, 27, 0, 0, + 28, 0, 0, 0, 0, 68, 414, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, + 187, 0, 26, 187, 187, 424, 187, 187, 0, 0, + 187, 0, 0, 27, 271, 271, 28, 0, 0, 0, + 0, 0, 0, 0, 271, 434, 435, 0, 0, 271, + 0, 342, 145, 0, 0, 0, 339, 0, 0, 0, + 343, 0, 444, 0, 446, 448, 449, 450, 344, 345, + 0, 0, 0, 0, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 407, 408, 0, 468, + 469, 185, 185, 0, 188, 0, 0, 188, 188, 0, + 188, 188, 144, 145, 188, 0, 186, 186, 0, 0, + 0, 146, 147, 0, 0, 0, 0, 0, 0, 148, + -327, 149, 0, 342, 145, -327, 266, -327, 150, 0, + 72, 0, 343, 151, 0, 0, 0, 505, 0, 0, + 508, 345, 187, 187, 0, 0, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 508, 439, 0, 0, 0, + 73, 74, 0, 75, 76, 77, 0, 79, 80, 81, + 82, 0, 84, 453, 0, 0, 0, 0, 86, 87, + 88, 89, 0, 0, 0, 90, 0, 0, 91, 531, + 92, 25, 93, 94, 0, 0, 0, 0, 0, 0, + 0, 0, 95, 96, 97, 0, 0, 536, 0, 0, + 0, 537, 0, 538, 0, 98, 99, 100, 0, 0, + 0, 189, 0, 0, 0, 72, 188, 188, 0, 0, + 0, 0, 0, 0, 560, 0, 0, 0, 0, 0, + 0, 568, 0, 0, 0, 0, 0, 0, 0, 0, + 222, 0, 0, 0, 0, 73, 74, 0, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 588, + 589, 0, 0, 86, 87, 88, 89, 439, 0, 453, + 90, 190, 191, 91, 0, 92, 25, 93, 94, 0, + 0, 0, 0, 0, 0, 192, 0, 95, 96, 97, + 0, 262, 0, 0, 0, 72, 144, 145, 193, 0, + 98, 99, 100, 0, 0, 146, 147, 0, 0, 0, + 0, 0, 0, 148, 0, 149, 0, 0, 0, -327, + -327, -327, 150, 0, 560, 73, 74, 151, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 0, + 0, 0, 0, 86, 87, 88, 89, 0, 0, 0, + 90, 0, 0, 91, 0, 92, 25, 93, 94, 59, + 0, 342, 0, 72, 263, 0, 0, 95, 96, 97, + 343, 0, 0, 0, 0, 0, 0, 0, 264, 345, + 98, 99, 100, 0, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 73, 74, 0, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 0, 0, 0, + 0, 86, 87, 88, 89, 0, 0, 0, 90, 0, + 0, 91, 0, 92, 25, 93, 94, 127, 0, 0, + 0, 72, 0, -315, 0, 95, 96, 97, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 68, 98, 99, + 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 73, 74, 0, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 0, 0, 0, 0, 86, + 87, 88, 89, 0, 0, 0, 90, 0, 0, 91, + 0, 92, 25, 93, 94, 131, 0, 0, 0, 72, + 0, -237, 0, 95, 96, 97, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 98, 99, 100, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 73, + 74, 0, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 0, 0, 0, 0, 86, 87, 88, + 89, 0, 0, 0, 90, 0, 0, 91, 0, 92, + 25, 93, 94, 133, 0, 0, 0, 72, 0, -237, + 0, 95, 96, 97, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 98, 99, 100, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 73, 74, 0, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 0, 0, 0, 0, 86, 87, 88, 89, 0, + 0, 0, 90, 0, 0, 91, 0, 92, 25, 93, + 94, 136, 0, 0, 0, 72, 0, 134, 0, 95, + 96, 97, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 98, 99, 100, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 73, 74, 0, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 0, + 0, 0, 0, 86, 87, 88, 89, 0, 0, 0, + 90, 0, 0, 91, 0, 92, 25, 93, 94, 138, + 0, 0, 0, 72, 0, -237, 0, 95, 96, 97, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 98, 99, 100, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 73, 74, 0, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 0, 0, 0, + 0, 86, 87, 88, 89, 0, 0, 0, 90, 0, + 0, 91, 0, 92, 25, 93, 94, 464, 0, 0, + 0, 72, 0, 139, 0, 95, 96, 97, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 98, 99, + 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 73, 74, 0, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 0, 0, 0, 0, 86, + 87, 88, 89, 0, 0, 0, 90, 0, 0, 91, + 0, 92, 25, 93, 94, 530, 0, 0, 0, 72, + 0, -315, 0, 95, 96, 97, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 98, 99, 100, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 73, + 74, 0, 75, 76, 77, 0, 79, 80, 81, 82, + 0, 84, 0, 0, 0, 0, 0, 86, 87, 88, + 89, 0, 0, 0, 90, 0, 0, 91, 0, 92, + 25, 93, 94, 0, 0, 0, 0, 0, 0, 0, + 0, 95, 96, 97, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 98, 99, 100, -35, 1, 0, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 0, 144, 145, 13, 0, 14, 15, 16, 17, + 0, 146, 147, 18, 0, 0, 19, 20, 0, 148, + 21, 149, 0, 0, 0, 0, 0, 0, 363, 364, + 365, 366, 367, 151, 0, 0, 22, 23, 24, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 25, 0, 0, 0, 26, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, + 0, 28, 0, 0, 0, 457, -90, -203, -203, -203, + -203, -203, -203, -203, -203, -203, -203, -203, -203, -203, + -203, -203, 0, -203, -203, 0, -203, -203, -203, -203, + -203, -203, -203, -203, -203, -203, -203, -203, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 672, 0, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, -167, 315, 0, 316, 317, 474, 318, 0, + -203, -203, -203, 0, -203, 319, 320, 321, 322, 475, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, -203, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 25, 93, 94, 0, 324, 0, -167, -167, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 544, -170, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, -35, -35, -35, + 13, -35, 14, 15, 16, 17, 0, 0, -35, 18, + 0, 0, 19, 20, 0, 472, 21, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 473, 315, 0, 316, 317, 474, 318, 0, 0, 0, + 0, 0, 0, 319, 320, 321, 322, 475, 0, 25, + 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 27, 0, 0, 28, 0, 0, + 0, 0, -90, 0, 0, 0, 0, 0, 0, 0, + 25, 93, 94, 0, 324, 0, 216, 0, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, -35, + -35, -35, 13, -170, 14, 15, 16, 17, 0, 0, + 0, 18, 0, 0, 19, 20, 0, 292, 21, 2, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + -35, -35, -35, 13, 0, 14, 15, 16, 17, 0, + 0, 0, 18, 0, 0, 19, 20, 0, 0, 21, + 0, 25, 0, 0, 0, 26, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 27, 0, 0, 28, + 0, 0, 0, 0, -90, 0, 0, 0, 0, 0, + 0, 0, 25, 0, 0, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, + 28, 0, 0, 0, 294, -90, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, -35, -35, -35, + 13, 0, 14, 15, 16, 17, 0, 0, 0, 18, + 0, 0, 19, 20, 0, 296, 21, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, -35, -35, + -35, 13, 0, 14, 15, 16, 17, 0, 0, 0, + 18, 0, 0, 19, 20, 0, 0, 21, 0, 25, + 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 27, 0, 0, 28, 0, 0, + 0, 0, -90, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 26, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 27, 0, 0, 28, 0, + 0, 0, 336, -90, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 0, 0, -35, 13, 0, + 14, 15, 16, 17, 0, 0, 0, 18, 0, 0, + 19, 20, -35, -35, 21, 0, 534, 0, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, -35, + -35, -35, 13, 0, 14, 15, 16, 17, 0, 0, + 0, 18, 0, 0, 19, 20, 0, 25, 21, 0, + 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 27, 0, 0, 28, 0, 0, 0, 0, + -90, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 25, 0, 0, 0, 26, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 27, 0, 0, 28, + 0, 0, 0, 542, -90, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, -35, -35, -35, 13, + 0, 14, 15, 16, 17, 0, 0, 0, 18, 0, + 0, 19, 20, 0, 562, 21, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 0, + 315, 0, 316, 317, 474, 318, 0, 0, 0, 0, + 0, 0, 319, 320, 321, 322, 475, 0, 25, 0, + 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 27, 0, 0, 28, 0, 0, 0, + 0, -90, 0, 0, 0, 0, 0, 0, 0, 25, + 93, 94, 0, 324, 0, 573, 0, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 0, 315, -170, 316, 317, 474, 318, 0, 0, 0, + 0, 0, 0, 319, 320, 321, 322, 475, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 585, 0, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 0, 0, -35, 13, 0, 14, 15, 16, 17, + 25, 93, 94, 18, 324, 0, 19, 20, 0, 592, + 21, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 0, -170, -35, 13, -35, 14, 15, 16, + 17, 0, 0, -35, 18, 0, 0, 19, 20, 0, + 0, 21, 0, 25, 0, 0, 0, 26, 0, -35, + -35, 0, 0, 0, 0, 0, 0, 0, 27, 0, + 0, 28, 0, 0, 0, 0, -90, 0, 0, 0, + 0, 0, 0, 0, 25, 0, 0, 0, 26, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, + 0, 0, 28, 0, 0, 0, 614, -90, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 0, 315, 0, 316, 317, 474, 318, 0, 0, + 0, 0, 0, 0, 319, 320, 321, 322, 475, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 651, + 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 0, 0, -35, 13, 0, 14, 15, 16, + 17, 25, 93, 94, 18, 324, 0, 19, 20, -35, + -35, 21, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -170, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 25, 0, 0, 0, 26, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, + 0, 0, 28, 0, 0, 0, 677, -90, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 0, + 0, -35, 13, 0, 14, 15, 16, 17, 0, 0, + 0, 18, 0, 0, 19, 20, -35, -35, 21, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 59, 0, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 0, 315, 0, 316, 317, 0, 318, + 0, 25, 0, 0, 0, 26, 319, 320, 321, 322, + 323, 0, 0, 0, 0, 0, 27, 0, 0, 28, + 0, 0, 0, 0, -90, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 25, 93, 94, 0, 324, 0, 487, + 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 0, 0, -35, 13, 68, 14, 15, 16, + 17, 0, 0, 0, 18, 0, 0, 19, 20, 0, + 540, 21, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 0, 0, -35, 13, 0, 14, 15, + 16, 17, 0, 0, 0, 18, 0, 0, 19, 20, + 0, 0, 21, 0, 25, 0, 0, 0, 26, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, + 0, 0, 28, 0, 0, 0, 0, -90, 0, 0, + 0, 0, 0, 0, 0, 25, 0, 0, 0, 26, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 27, 0, 0, 28, 0, 0, 0, 579, -90, 2, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 0, 0, -35, 13, 0, 14, 15, 16, 17, 0, + 0, 0, 18, 0, 0, 19, 20, 0, 622, 21, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 0, 0, -35, 13, 0, 14, 15, 16, 17, + 0, 0, 0, 18, 0, 0, 19, 20, 0, 0, + 21, 0, 25, 0, 0, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, + 28, 0, 0, 0, 0, -90, 0, 0, 0, 0, + 0, 0, 0, 25, 0, 0, 0, 26, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, + 0, 28, 0, 0, 0, 58, -90, -189, -189, -189, + -189, -189, -189, -189, -189, -189, -189, 0, -189, -189, + -189, 0, -189, -189, 0, 0, -189, 0, 0, -189, + -189, 0, 59, -189, 2, 3, 4, 60, 61, 62, + 63, 64, 65, 66, 0, -90, -90, -90, 0, 0, + 14, 0, 0, 17, 0, 0, 0, 18, 0, 0, + 67, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -189, 0, 0, 0, -189, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -189, 0, 0, -189, 0, + 0, 72, 0, -189, 0, 0, 0, 25, 0, 0, + 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 27, 0, 0, 28, 0, 0, 0, 0, + 68, 73, 74, 288, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 0, 0, 0, 289, 86, + 87, 88, 89, 0, 0, 0, 90, 0, 0, 91, + 290, 92, 25, 93, 94, 72, 0, 0, 0, 0, + 0, 0, 0, 95, 96, 97, 0, 0, 0, 0, + 0, 0, 0, 0, 291, 0, 98, 99, 100, 0, + 0, 0, 0, 0, 0, 73, 74, 288, 75, 76, + 77, 0, 79, 80, 81, 82, 0, 84, 0, 0, + 0, 0, 289, 86, 87, 88, 89, 0, 0, 0, + 90, 0, 0, 91, 290, 92, 25, 93, 94, 72, + 0, 0, 0, 0, 0, 612, 0, 95, 96, 97, + 0, 0, 0, 0, 0, 0, 0, 0, 291, 0, + 98, 99, 100, 0, 0, 0, 0, 0, 0, 73, + 74, 0, 75, 76, 77, 283, 79, 80, 81, 82, + 284, 84, 285, 0, 0, 0, 0, 86, 87, 88, + 89, 0, 0, 0, 90, 286, 0, 91, 72, 92, + 25, 93, 94, 0, 0, 0, 0, 0, 0, 0, + 0, 95, 96, 97, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 98, 99, 100, 0, 73, 74, + 288, 75, 76, 77, 0, 79, 80, 81, 82, 0, + 84, 0, 0, 0, 0, 289, 86, 87, 88, 89, + 0, 0, 0, 90, 0, 0, 91, 290, 92, 25, + 93, 94, 72, 0, 0, 0, 0, 0, 0, 0, + 95, 96, 97, 0, 0, 0, 0, 0, 0, 0, + 0, 291, 0, 98, 99, 100, 0, 0, 0, 0, + 0, 0, 73, 74, 0, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 0, 0, 0, 0, + 86, 87, 88, 89, 0, 0, 0, 90, 0, 0, + 91, 72, 92, 25, 93, 94, 0, 0, 0, 0, + 0, 0, 581, 0, 95, 96, 97, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 98, 99, 100, + 0, 73, 74, 0, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 0, 0, 0, 0, 86, + 87, 88, 89, 0, 0, 0, 90, 0, 0, 91, + 72, 92, 25, 93, 94, 0, 0, 0, 0, 0, + 0, 0, 0, 95, 96, 97, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 98, 99, 100, 0, + 73, 74, 0, 75, 76, 77, 156, 79, 80, 81, + 82, 0, 84, 0, 0, 0, 0, 0, 86, 87, + 88, 89, 0, 0, 0, 90, 0, 0, 91, 157, + 92, 25, 93, 94, 72, 0, 0, 0, 0, 0, + 0, 0, 95, 96, 97, 0, 0, 0, 0, 0, + 0, 0, 0, 158, 0, 98, 99, 100, 0, 0, + 0, 0, 0, 0, 73, 74, 0, 75, 76, 77, + 0, 79, 80, 81, 82, 0, 84, 0, 0, 0, + 0, 0, 86, 87, 88, 89, 0, 0, 0, 90, + 0, 0, 91, 269, 92, 25, 93, 94, 161, 0, + 0, 0, 0, 0, 0, 0, 95, 96, 97, 0, + 0, 0, 0, 0, 0, 0, 0, 270, 0, 98, + 99, 100, 0, 0, 0, 0, 0, 0, 73, 74, + 0, 75, 76, 77, 162, 79, 80, 81, 163, 0, + 164, 0, 0, 0, 0, 0, 165, 166, 167, 168, + 0, 0, 0, 169, 0, 0, 72, 170, 0, 25, + 93, 94, 0, 0, 0, 0, 0, 0, 0, 0, + 171, 172, 173, 0, 0, 0, 0, 0, 0, 0, + 0, 174, 0, 98, 99, 100, 73, 74, 0, 75, + 76, 77, 0, 79, 80, 81, 82, 0, 84, 0, + 0, 0, 0, 0, 86, 87, 88, 89, 0, 0, + 0, 90, 0, 0, 91, 72, 92, 25, 93, 94, + 0, 423, 0, 0, 0, 0, 0, 0, 95, 96, + 97, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 98, 99, 100, 0, 73, 74, 0, 75, 76, + 77, 0, 79, 80, 81, 82, 0, 84, 0, 0, + 0, 0, 0, 86, 87, 88, 89, 0, 0, 0, + 90, 0, 0, 91, 72, 92, 25, 93, 94, 0, + 0, 0, 0, 0, 0, 0, 0, 95, 96, 97, + 0, 0, 0, 0, 0, 0, 0, 0, 445, 0, + 98, 99, 100, 0, 73, 74, 0, 75, 76, 77, + 0, 79, 80, 81, 82, 0, 84, 0, 0, 0, + 0, 0, 86, 87, 88, 89, 0, 0, 0, 90, + 0, 0, 91, 72, 92, 25, 93, 94, 0, 0, + 0, 0, 0, 0, 0, 0, 95, 96, 97, 0, + 0, 0, 0, 0, 0, 0, 0, 447, 0, 98, + 99, 100, 0, 73, 74, 0, 75, 76, 77, 506, + 79, 80, 81, 82, 0, 84, 0, 0, 0, 0, + 0, 86, 87, 88, 89, 0, 0, 0, 90, 0, + 0, 91, 72, 92, 25, 93, 94, 0, 0, 0, + 0, 0, 0, 0, 0, 95, 96, 97, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 98, 99, + 100, 0, 73, 74, 0, 75, 76, 77, 0, 79, + 80, 81, 82, 0, 84, 0, 0, 0, 0, 0, + 86, 87, 88, 89, 0, 0, 0, 90, 0, 0, + 91, 72, 92, 25, 93, 94, 0, 0, 0, 0, + 0, 0, 567, 0, 95, 96, 97, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 98, 99, 100, + 0, 73, 74, 0, 75, 76, 77, 0, 79, 80, + 81, 82, 0, 84, 0, 0, 0, 0, 0, 86, + 87, 88, 89, 0, 0, 0, 90, 0, 0, 91, + 161, 92, 25, 93, 94, 0, 0, 0, 0, 0, + 0, 0, 0, 95, 96, 97, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 98, 99, 100, 0, + 73, 74, 0, 75, 76, 77, 0, 79, 80, 81, + 163, 0, 164, 0, 0, 0, 0, 0, 165, 166, + 167, 168, 0, 0, 0, 169, 0, 0, 161, 0, + 0, 25, 93, 94, 0, 0, 0, 0, 0, 0, + 0, 0, 171, 172, 173, 0, 0, 0, 0, 0, + 0, 0, 0, 384, 0, 98, 99, 100, 73, 74, + 0, 75, 76, 77, 0, 79, 80, 81, 163, 0, + 164, 0, 0, 0, 0, 0, 165, 166, 167, 168, + 0, 0, 0, 169, 0, 0, 0, 0, 0, 25, + 93, 94, 0, 0, 0, 0, 0, 0, 0, 0, + 171, 172, 173, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 98, 99, 100, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 0, + 315, 0, 316, 317, 474, 318, 0, 0, 0, 0, + 0, 0, 319, 320, 321, 322, 475, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 0, 0, + 0, 13, 0, 14, 15, 16, 17, 0, 0, 0, + 18, 0, 0, 19, 20, 0, 0, 21, 0, 25, + 93, 94, 0, 324, 0, 0, 0, 0, 0, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, -170, 315, 0, 316, 317, 0, 318, 0, + 25, 0, 0, 0, 26, 319, 320, 321, 322, 323, + 0, 0, 0, 0, 0, 27, 0, 0, 28, 0, + 0, 0, 0, -90, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 25, 93, 94, 0, 324 +}; + +#define yypact_value_is_default(yystate) \ + ((yystate) == (-608)) + +#define yytable_value_is_error(yytable_value) \ + YYID (0) + +static const yytype_int16 yycheck[] = +{ + 7, 8, 9, 15, 147, 330, 83, 19, 195, 557, + 486, 1, 1, 20, 85, 24, 100, 5, 1, 7, + 8, 9, 49, 1, 134, 318, 1, 24, 59, 21, + 3, 4, 1, 25, 82, 83, 1, 1, 1, 1, + 1, 5, 52, 64, 122, 652, 124, 78, 126, 92, + 93, 99, 1, 26, 64, 67, 646, 89, 10, 11, + 12, 80, 14, 82, 5, 17, 1, 88, 0, 4, + 546, 678, 60, 24, 62, 63, 64, 66, 88, 75, + 37, 59, 24, 66, 59, 0, 163, 24, 636, 637, + 42, 639, 1, 164, 59, 52, 5, 66, 64, 89, + 78, 93, 89, 66, 66, 66, 70, 64, 81, 61, + 59, 31, 32, 65, 66, 163, 91, 593, 93, 54, + 710, 711, 88, 713, 59, 134, 91, 134, 53, 0, + 24, 88, 139, 68, 5, 27, 7, 8, 9, 687, + 5, 689, 690, 89, 734, 470, 71, 75, 4, 75, + 59, 741, 477, 743, 744, 745, 81, 92, 75, 30, + 485, 170, 75, 172, 24, 174, 243, 244, 14, 15, + 254, 631, 632, 170, 75, 172, 469, 174, 49, 4, + 251, 474, 74, 5, 258, 259, 195, 75, 75, 60, + 75, 62, 63, 64, 268, 243, 244, 24, 54, 273, + 71, 193, 75, 59, 75, 76, 77, 284, 1, 80, + 81, 75, 68, 356, 285, 402, 326, 663, 664, 170, + 666, 331, 332, 174, 212, 213, 141, 98, 170, 54, + 172, 53, 174, 170, 59, 172, 284, 174, 531, 16, + 75, 18, 75, 68, 66, 67, 68, 572, 25, 71, + 59, 122, 75, 124, 146, 126, 75, 74, 150, 81, + 91, 707, 708, 709, 57, 58, 92, 92, 93, 89, + 141, 298, 264, 66, 67, 282, 170, 16, 172, 18, + 174, 74, 37, 76, 74, 76, 25, 80, 81, 82, + 83, 298, 299, 300, 282, 88, 16, 52, 18, 75, + 37, 14, 15, 16, 71, 25, 333, 24, 335, 64, + 170, 299, 172, 301, 174, 52, 59, 326, 74, 52, + 75, 330, 331, 332, 16, 332, 318, 64, 335, 75, + 75, 338, 625, 88, 80, 16, 82, 18, 75, 75, + 75, 212, 213, 170, 25, 172, 75, 174, 80, 81, + 82, 88, 75, 75, 380, 381, 427, 383, 310, 311, + 312, 387, 440, 315, 316, 317, 75, 319, 377, 321, + 75, 380, 381, 75, 383, 384, 454, 404, 387, 406, + 377, 16, 89, 380, 381, 89, 383, 384, 16, 16, + 387, 14, 15, 16, 401, 16, 82, 726, 727, 71, + 729, 71, 409, 410, 411, 698, 80, 81, 82, 16, + 71, 282, 16, 75, 1, 403, 16, 405, 16, 334, + 749, 750, 751, 75, 73, 71, 377, 298, 299, 389, + 301, 75, 75, 384, 16, 377, 75, 75, 380, 381, + 377, 383, 384, 380, 381, 387, 383, 384, 526, 527, + 387, 16, 72, 170, 16, 172, 75, 174, 75, 16, + 75, 470, 333, 334, 335, 75, 473, 474, 477, 361, + 362, 363, 75, 16, 73, 367, 485, 469, 16, 491, + 72, 16, 474, 377, 75, 492, 380, 381, 30, 383, + 384, 75, 75, 387, 75, 720, 24, 16, 16, 47, + 509, 510, 23, 24, 25, 26, 27, 28, 752, 154, + 234, 24, 509, 510, 356, -1, 498, 377, -1, -1, + 380, 381, -1, 383, 384, -1, -1, 387, -1, -1, + -1, -1, 403, 404, 405, 406, -1, 452, -1, 531, + 455, 23, 24, 25, 26, 27, 28, 24, 557, -1, + 377, -1, -1, 380, 381, -1, 383, 384, 509, 510, + 387, -1, 569, 572, -1, -1, -1, 509, 510, 440, + 577, -1, 509, 510, 581, 490, -1, 584, -1, 494, + -1, 452, -1, 454, 455, -1, -1, -1, -1, -1, + -1, -1, 599, 600, 601, -1, 603, -1, 550, -1, + -1, -1, 609, 610, -1, 612, -1, 522, 560, 616, + -1, -1, 619, -1, 621, 509, 510, -1, -1, 490, + 627, -1, 649, 494, 576, -1, -1, 636, 637, -1, + 639, 24, -1, 625, -1, -1, 645, 646, -1, -1, + 647, -1, 170, -1, 172, -1, 174, 635, 655, 509, + 510, 522, 604, -1, 661, 526, 527, 170, -1, 172, + 377, 174, -1, 380, 381, -1, 383, 384, 583, -1, + 387, -1, 679, -1, 681, 682, 628, -1, 687, 23, + 689, 690, 509, 510, 691, 692, 638, 694, 640, 641, + -1, -1, -1, 170, -1, 172, -1, 174, -1, -1, + -1, 710, 711, -1, 713, 620, 698, -1, -1, 716, + -1, 718, 583, -1, -1, 722, 631, 632, -1, -1, + -1, 728, -1, 730, 731, 734, 733, -1, 735, -1, + 737, -1, 741, -1, 743, 744, 745, -1, 653, -1, + -1, 693, -1, 695, 696, -1, -1, 91, 92, 620, + 94, -1, 96, -1, -1, -1, -1, 57, 58, -1, + 631, 632, -1, -1, 635, 680, 66, 67, 683, -1, + 114, 7, 8, 9, 74, -1, 76, 170, 649, 172, + -1, 174, 653, 83, -1, -1, -1, 702, 88, -1, + 705, -1, 509, 510, -1, -1, -1, 1, -1, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 680, + -1, -1, 683, 157, 158, 19, -1, -1, 22, -1, + -1, -1, 26, -1, -1, 29, 62, 63, 64, -1, + -1, 702, -1, -1, 705, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, -1, 190, 191, -1, 377, + -1, 19, 380, 381, 22, 383, 384, -1, 26, 387, + -1, 29, 66, -1, 377, -1, 70, 380, 381, -1, + 383, 384, -1, -1, 387, 1, -1, 81, -1, -1, + 84, -1, -1, -1, -1, 89, 230, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 66, -1, + 377, -1, 70, 380, 381, 249, 383, 384, -1, -1, + 387, -1, -1, 81, 258, 259, 84, -1, -1, -1, + -1, -1, -1, -1, 268, 269, 270, -1, -1, 273, + -1, 57, 58, -1, -1, -1, 1, -1, -1, -1, + 66, -1, 286, -1, 288, 289, 290, 291, 74, 75, + -1, -1, -1, -1, 80, 81, 82, 83, 84, 85, + 86, 87, 88, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 212, 213, -1, 323, + 324, 509, 510, -1, 377, -1, -1, 380, 381, -1, + 383, 384, 57, 58, 387, -1, 509, 510, -1, -1, + -1, 66, 67, -1, -1, -1, -1, -1, -1, 74, + 75, 76, -1, 57, 58, 80, 1, 82, 83, -1, + 5, -1, 66, 88, -1, -1, -1, 371, -1, -1, + 374, 75, 509, 510, -1, -1, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 389, 282, -1, -1, -1, + 35, 36, -1, 38, 39, 40, -1, 42, 43, 44, + 45, -1, 47, 299, -1, -1, -1, -1, 53, 54, + 55, 56, -1, -1, -1, 60, -1, -1, 63, 423, + 65, 66, 67, 68, -1, -1, -1, -1, -1, -1, + -1, -1, 77, 78, 79, -1, -1, 441, -1, -1, + -1, 445, -1, 447, -1, 90, 91, 92, -1, -1, + -1, 1, -1, -1, -1, 5, 509, 510, -1, -1, + -1, -1, -1, -1, 468, -1, -1, -1, -1, -1, + -1, 475, -1, -1, -1, -1, -1, -1, -1, -1, + 1, -1, -1, -1, -1, 35, 36, -1, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 503, + 504, -1, -1, 53, 54, 55, 56, 403, -1, 405, + 60, 61, 62, 63, -1, 65, 66, 67, 68, -1, + -1, -1, -1, -1, -1, 75, -1, 77, 78, 79, + -1, 1, -1, -1, -1, 5, 57, 58, 88, -1, + 90, 91, 92, -1, -1, 66, 67, -1, -1, -1, + -1, -1, -1, 74, -1, 76, -1, -1, -1, 80, + 81, 82, 83, -1, 568, 35, 36, 88, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, -1, + -1, -1, -1, 53, 54, 55, 56, -1, -1, -1, + 60, -1, -1, 63, -1, 65, 66, 67, 68, 1, + -1, 57, -1, 5, 74, -1, -1, 77, 78, 79, + 66, -1, -1, -1, -1, -1, -1, -1, 88, 75, + 90, 91, 92, -1, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 35, 36, -1, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, -1, -1, -1, + -1, 53, 54, 55, 56, -1, -1, -1, 60, -1, + -1, 63, -1, 65, 66, 67, 68, 1, -1, -1, + -1, 5, -1, 75, -1, 77, 78, 79, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 89, 90, 91, + 92, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 35, 36, -1, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, -1, -1, -1, -1, 53, + 54, 55, 56, -1, -1, -1, 60, -1, -1, 63, + -1, 65, 66, 67, 68, 1, -1, -1, -1, 5, + -1, 75, -1, 77, 78, 79, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 90, 91, 92, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 35, + 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, -1, -1, -1, -1, 53, 54, 55, + 56, -1, -1, -1, 60, -1, -1, 63, -1, 65, + 66, 67, 68, 1, -1, -1, -1, 5, -1, 75, + -1, 77, 78, 79, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 90, 91, 92, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 35, 36, -1, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, -1, -1, -1, -1, 53, 54, 55, 56, -1, + -1, -1, 60, -1, -1, 63, -1, 65, 66, 67, + 68, 1, -1, -1, -1, 5, -1, 75, -1, 77, + 78, 79, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 90, 91, 92, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 35, 36, -1, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, -1, + -1, -1, -1, 53, 54, 55, 56, -1, -1, -1, + 60, -1, -1, 63, -1, 65, 66, 67, 68, 1, + -1, -1, -1, 5, -1, 75, -1, 77, 78, 79, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 90, 91, 92, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 35, 36, -1, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, -1, -1, -1, + -1, 53, 54, 55, 56, -1, -1, -1, 60, -1, + -1, 63, -1, 65, 66, 67, 68, 1, -1, -1, + -1, 5, -1, 75, -1, 77, 78, 79, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 90, 91, + 92, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 35, 36, -1, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, -1, -1, -1, -1, 53, + 54, 55, 56, -1, -1, -1, 60, -1, -1, 63, + -1, 65, 66, 67, 68, 1, -1, -1, -1, 5, + -1, 75, -1, 77, 78, 79, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 90, 91, 92, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 35, + 36, -1, 38, 39, 40, -1, 42, 43, 44, 45, + -1, 47, -1, -1, -1, -1, -1, 53, 54, 55, + 56, -1, -1, -1, 60, -1, -1, 63, -1, 65, + 66, 67, 68, -1, -1, -1, -1, -1, -1, -1, + -1, 77, 78, 79, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 90, 91, 92, 0, 1, -1, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, -1, 57, 58, 17, -1, 19, 20, 21, 22, + -1, 66, 67, 26, -1, -1, 29, 30, -1, 74, + 33, 76, -1, -1, -1, -1, -1, -1, 83, 84, + 85, 86, 87, 88, -1, -1, 49, 50, 51, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 66, -1, -1, -1, 70, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 81, -1, + -1, 84, -1, -1, -1, 1, 89, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, -1, 19, 20, -1, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1, -1, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, -1, 19, 20, 21, 22, -1, + 66, 67, 68, -1, 70, 29, 30, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 89, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 66, 67, 68, -1, 70, -1, 72, 73, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1, 89, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, -1, -1, 25, 26, + -1, -1, 29, 30, -1, 1, 33, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, -1, 19, 20, 21, 22, -1, -1, -1, + -1, -1, -1, 29, 30, 31, 32, 33, -1, 66, + -1, -1, -1, 70, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 81, -1, -1, 84, -1, -1, + -1, -1, 89, -1, -1, -1, -1, -1, -1, -1, + 66, 67, 68, -1, 70, -1, 1, -1, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 89, 19, 20, 21, 22, -1, -1, + -1, 26, -1, -1, 29, 30, -1, 1, 33, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, -1, 19, 20, 21, 22, -1, + -1, -1, 26, -1, -1, 29, 30, -1, -1, 33, + -1, 66, -1, -1, -1, 70, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 81, -1, -1, 84, + -1, -1, -1, -1, 89, -1, -1, -1, -1, -1, + -1, -1, 66, -1, -1, -1, 70, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 81, -1, -1, + 84, -1, -1, -1, 1, 89, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, -1, 19, 20, 21, 22, -1, -1, -1, 26, + -1, -1, 29, 30, -1, 1, 33, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, -1, 19, 20, 21, 22, -1, -1, -1, + 26, -1, -1, 29, 30, -1, -1, 33, -1, 66, + -1, -1, -1, 70, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 81, -1, -1, 84, -1, -1, + -1, -1, 89, -1, -1, -1, -1, -1, -1, -1, + 66, -1, -1, -1, 70, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 81, -1, -1, 84, -1, + -1, -1, 1, 89, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, -1, -1, 16, 17, -1, + 19, 20, 21, 22, -1, -1, -1, 26, -1, -1, + 29, 30, 31, 32, 33, -1, 1, -1, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, -1, 19, 20, 21, 22, -1, -1, + -1, 26, -1, -1, 29, 30, -1, 66, 33, -1, + -1, 70, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 81, -1, -1, 84, -1, -1, -1, -1, + 89, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 66, -1, -1, -1, 70, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 81, -1, -1, 84, + -1, -1, -1, 1, 89, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + -1, 19, 20, 21, 22, -1, -1, -1, 26, -1, + -1, 29, 30, -1, 1, 33, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, -1, + 17, -1, 19, 20, 21, 22, -1, -1, -1, -1, + -1, -1, 29, 30, 31, 32, 33, -1, 66, -1, + -1, -1, 70, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 81, -1, -1, 84, -1, -1, -1, + -1, 89, -1, -1, -1, -1, -1, -1, -1, 66, + 67, 68, -1, 70, -1, 1, -1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + -1, 17, 89, 19, 20, 21, 22, -1, -1, -1, + -1, -1, -1, 29, 30, 31, 32, 33, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, -1, -1, 16, 17, -1, 19, 20, 21, 22, + 66, 67, 68, 26, 70, -1, 29, 30, -1, 1, + 33, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, -1, 89, 16, 17, 18, 19, 20, 21, + 22, -1, -1, 25, 26, -1, -1, 29, 30, -1, + -1, 33, -1, 66, -1, -1, -1, 70, -1, 72, + 73, -1, -1, -1, -1, -1, -1, -1, 81, -1, + -1, 84, -1, -1, -1, -1, 89, -1, -1, -1, + -1, -1, -1, -1, 66, -1, -1, -1, 70, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 81, + -1, -1, 84, -1, -1, -1, 1, 89, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, -1, 17, -1, 19, 20, 21, 22, -1, -1, + -1, -1, -1, -1, 29, 30, 31, 32, 33, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, + -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, -1, -1, 16, 17, -1, 19, 20, 21, + 22, 66, 67, 68, 26, 70, -1, 29, 30, 31, + 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 89, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 66, -1, -1, -1, 70, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 81, + -1, -1, 84, -1, -1, -1, 1, 89, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, -1, + -1, 16, 17, -1, 19, 20, 21, 22, -1, -1, + -1, 26, -1, -1, 29, 30, 31, 32, 33, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, -1, 17, -1, 19, 20, -1, 22, + -1, 66, -1, -1, -1, 70, 29, 30, 31, 32, + 33, -1, -1, -1, -1, -1, 81, -1, -1, 84, + -1, -1, -1, -1, 89, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 66, 67, 68, -1, 70, -1, 1, + -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, -1, -1, 16, 17, 89, 19, 20, 21, + 22, -1, -1, -1, 26, -1, -1, 29, 30, -1, + 1, 33, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, -1, -1, 16, 17, -1, 19, 20, + 21, 22, -1, -1, -1, 26, -1, -1, 29, 30, + -1, -1, 33, -1, 66, -1, -1, -1, 70, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 81, + -1, -1, 84, -1, -1, -1, -1, 89, -1, -1, + -1, -1, -1, -1, -1, 66, -1, -1, -1, 70, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 81, -1, -1, 84, -1, -1, -1, 1, 89, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + -1, -1, 16, 17, -1, 19, 20, 21, 22, -1, + -1, -1, 26, -1, -1, 29, 30, -1, 1, 33, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, -1, -1, 16, 17, -1, 19, 20, 21, 22, + -1, -1, -1, 26, -1, -1, 29, 30, -1, -1, + 33, -1, 66, -1, -1, -1, 70, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 81, -1, -1, + 84, -1, -1, -1, -1, 89, -1, -1, -1, -1, + -1, -1, -1, 66, -1, -1, -1, 70, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 81, -1, + -1, 84, -1, -1, -1, 1, 89, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, -1, 14, 15, + 16, -1, 18, 19, -1, -1, 22, -1, -1, 25, + 26, -1, 1, 29, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, -1, 14, 15, 16, -1, -1, + 19, -1, -1, 22, -1, -1, -1, 26, -1, -1, + 29, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 66, -1, -1, -1, 70, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 81, -1, -1, 84, -1, + -1, 5, -1, 89, -1, -1, -1, 66, -1, -1, + -1, 70, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 81, -1, -1, 84, -1, -1, -1, -1, + 89, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, -1, -1, -1, 52, 53, + 54, 55, 56, -1, -1, -1, 60, -1, -1, 63, + 64, 65, 66, 67, 68, 5, -1, -1, -1, -1, + -1, -1, -1, 77, 78, 79, -1, -1, -1, -1, + -1, -1, -1, -1, 88, -1, 90, 91, 92, -1, + -1, -1, -1, -1, -1, 35, 36, 37, 38, 39, + 40, -1, 42, 43, 44, 45, -1, 47, -1, -1, + -1, -1, 52, 53, 54, 55, 56, -1, -1, -1, + 60, -1, -1, 63, 64, 65, 66, 67, 68, 5, + -1, -1, -1, -1, -1, 75, -1, 77, 78, 79, + -1, -1, -1, -1, -1, -1, -1, -1, 88, -1, + 90, 91, 92, -1, -1, -1, -1, -1, -1, 35, + 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, -1, -1, -1, -1, 53, 54, 55, + 56, -1, -1, -1, 60, 61, -1, 63, 5, 65, + 66, 67, 68, -1, -1, -1, -1, -1, -1, -1, + -1, 77, 78, 79, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 90, 91, 92, -1, 35, 36, + 37, 38, 39, 40, -1, 42, 43, 44, 45, -1, + 47, -1, -1, -1, -1, 52, 53, 54, 55, 56, + -1, -1, -1, 60, -1, -1, 63, 64, 65, 66, + 67, 68, 5, -1, -1, -1, -1, -1, -1, -1, + 77, 78, 79, -1, -1, -1, -1, -1, -1, -1, + -1, 88, -1, 90, 91, 92, -1, -1, -1, -1, + -1, -1, 35, 36, -1, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, -1, -1, -1, -1, + 53, 54, 55, 56, -1, -1, -1, 60, -1, -1, + 63, 5, 65, 66, 67, 68, -1, -1, -1, -1, + -1, -1, 75, -1, 77, 78, 79, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 90, 91, 92, + -1, 35, 36, -1, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, -1, -1, -1, -1, 53, + 54, 55, 56, -1, -1, -1, 60, -1, -1, 63, + 5, 65, 66, 67, 68, -1, -1, -1, -1, -1, + -1, -1, -1, 77, 78, 79, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 90, 91, 92, -1, + 35, 36, -1, 38, 39, 40, 41, 42, 43, 44, + 45, -1, 47, -1, -1, -1, -1, -1, 53, 54, + 55, 56, -1, -1, -1, 60, -1, -1, 63, 64, + 65, 66, 67, 68, 5, -1, -1, -1, -1, -1, + -1, -1, 77, 78, 79, -1, -1, -1, -1, -1, + -1, -1, -1, 88, -1, 90, 91, 92, -1, -1, + -1, -1, -1, -1, 35, 36, -1, 38, 39, 40, + -1, 42, 43, 44, 45, -1, 47, -1, -1, -1, + -1, -1, 53, 54, 55, 56, -1, -1, -1, 60, + -1, -1, 63, 64, 65, 66, 67, 68, 5, -1, + -1, -1, -1, -1, -1, -1, 77, 78, 79, -1, + -1, -1, -1, -1, -1, -1, -1, 88, -1, 90, + 91, 92, -1, -1, -1, -1, -1, -1, 35, 36, + -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, + 47, -1, -1, -1, -1, -1, 53, 54, 55, 56, + -1, -1, -1, 60, -1, -1, 5, 64, -1, 66, + 67, 68, -1, -1, -1, -1, -1, -1, -1, -1, + 77, 78, 79, -1, -1, -1, -1, -1, -1, -1, + -1, 88, -1, 90, 91, 92, 35, 36, -1, 38, + 39, 40, -1, 42, 43, 44, 45, -1, 47, -1, + -1, -1, -1, -1, 53, 54, 55, 56, -1, -1, + -1, 60, -1, -1, 63, 5, 65, 66, 67, 68, + -1, 70, -1, -1, -1, -1, -1, -1, 77, 78, + 79, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 90, 91, 92, -1, 35, 36, -1, 38, 39, + 40, -1, 42, 43, 44, 45, -1, 47, -1, -1, + -1, -1, -1, 53, 54, 55, 56, -1, -1, -1, + 60, -1, -1, 63, 5, 65, 66, 67, 68, -1, + -1, -1, -1, -1, -1, -1, -1, 77, 78, 79, + -1, -1, -1, -1, -1, -1, -1, -1, 88, -1, + 90, 91, 92, -1, 35, 36, -1, 38, 39, 40, + -1, 42, 43, 44, 45, -1, 47, -1, -1, -1, + -1, -1, 53, 54, 55, 56, -1, -1, -1, 60, + -1, -1, 63, 5, 65, 66, 67, 68, -1, -1, + -1, -1, -1, -1, -1, -1, 77, 78, 79, -1, + -1, -1, -1, -1, -1, -1, -1, 88, -1, 90, + 91, 92, -1, 35, 36, -1, 38, 39, 40, 41, + 42, 43, 44, 45, -1, 47, -1, -1, -1, -1, + -1, 53, 54, 55, 56, -1, -1, -1, 60, -1, + -1, 63, 5, 65, 66, 67, 68, -1, -1, -1, + -1, -1, -1, -1, -1, 77, 78, 79, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 90, 91, + 92, -1, 35, 36, -1, 38, 39, 40, -1, 42, + 43, 44, 45, -1, 47, -1, -1, -1, -1, -1, + 53, 54, 55, 56, -1, -1, -1, 60, -1, -1, + 63, 5, 65, 66, 67, 68, -1, -1, -1, -1, + -1, -1, 75, -1, 77, 78, 79, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 90, 91, 92, + -1, 35, 36, -1, 38, 39, 40, -1, 42, 43, + 44, 45, -1, 47, -1, -1, -1, -1, -1, 53, + 54, 55, 56, -1, -1, -1, 60, -1, -1, 63, + 5, 65, 66, 67, 68, -1, -1, -1, -1, -1, + -1, -1, -1, 77, 78, 79, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 90, 91, 92, -1, + 35, 36, -1, 38, 39, 40, -1, 42, 43, 44, + 45, -1, 47, -1, -1, -1, -1, -1, 53, 54, + 55, 56, -1, -1, -1, 60, -1, -1, 5, -1, + -1, 66, 67, 68, -1, -1, -1, -1, -1, -1, + -1, -1, 77, 78, 79, -1, -1, -1, -1, -1, + -1, -1, -1, 88, -1, 90, 91, 92, 35, 36, + -1, 38, 39, 40, -1, 42, 43, 44, 45, -1, + 47, -1, -1, -1, -1, -1, 53, 54, 55, 56, + -1, -1, -1, 60, -1, -1, -1, -1, -1, 66, + 67, 68, -1, -1, -1, -1, -1, -1, -1, -1, + 77, 78, 79, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 90, 91, 92, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, -1, + 17, -1, 19, 20, 21, 22, -1, -1, -1, -1, + -1, -1, 29, 30, 31, 32, 33, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, -1, -1, + -1, 17, -1, 19, 20, 21, 22, -1, -1, -1, + 26, -1, -1, 29, 30, -1, -1, 33, -1, 66, + 67, 68, -1, 70, -1, -1, -1, -1, -1, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 89, 17, -1, 19, 20, -1, 22, -1, + 66, -1, -1, -1, 70, 29, 30, 31, 32, 33, + -1, -1, -1, -1, -1, 81, -1, -1, 84, -1, + -1, -1, -1, 89, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 66, 67, 68, -1, 70 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint8 yystos[] = +{ + 0, 1, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 17, 19, 20, 21, 22, 26, 29, + 30, 33, 49, 50, 51, 66, 70, 81, 84, 95, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 120, 121, 125, 128, 129, 130, 131, 132, 133, + 136, 137, 139, 154, 155, 165, 188, 89, 1, 1, + 6, 7, 8, 9, 10, 11, 12, 29, 89, 129, + 134, 198, 5, 35, 36, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 53, 54, 55, 56, + 60, 63, 65, 67, 68, 77, 78, 79, 90, 91, + 92, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 181, 189, 199, 200, 201, + 208, 134, 198, 134, 198, 134, 198, 1, 170, 170, + 170, 1, 170, 1, 75, 169, 1, 170, 1, 75, + 169, 198, 171, 186, 57, 58, 66, 67, 74, 76, + 83, 88, 190, 191, 192, 197, 41, 64, 88, 98, + 181, 5, 41, 45, 47, 53, 54, 55, 56, 60, + 64, 77, 78, 79, 88, 102, 159, 160, 161, 162, + 163, 164, 168, 175, 189, 199, 200, 201, 208, 1, + 61, 62, 75, 88, 171, 5, 1, 190, 0, 109, + 170, 89, 132, 130, 1, 5, 70, 89, 170, 170, + 170, 169, 14, 15, 16, 135, 1, 108, 123, 1, + 5, 59, 1, 190, 1, 165, 1, 165, 1, 165, + 173, 1, 59, 78, 209, 210, 1, 165, 1, 165, + 1, 59, 91, 93, 204, 206, 206, 4, 54, 68, + 92, 93, 158, 202, 203, 204, 207, 207, 185, 184, + 181, 181, 1, 74, 88, 171, 1, 181, 183, 64, + 88, 181, 187, 182, 1, 165, 1, 91, 204, 1, + 92, 202, 75, 41, 46, 48, 61, 181, 37, 52, + 64, 88, 1, 123, 1, 123, 1, 123, 75, 75, + 75, 75, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 17, 19, 20, 22, 29, + 30, 31, 32, 33, 70, 150, 151, 152, 157, 168, + 198, 211, 75, 75, 198, 75, 1, 108, 75, 1, + 190, 1, 57, 66, 74, 75, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 193, 194, 195, 196, 197, + 190, 80, 82, 83, 84, 85, 86, 87, 191, 64, + 88, 99, 181, 181, 96, 64, 88, 103, 206, 207, + 179, 178, 175, 177, 88, 175, 180, 176, 175, 97, + 181, 181, 171, 75, 5, 53, 71, 156, 168, 188, + 81, 75, 5, 75, 75, 75, 75, 134, 134, 14, + 15, 16, 124, 81, 181, 1, 59, 78, 210, 59, + 205, 206, 206, 70, 181, 207, 92, 93, 202, 187, + 187, 171, 74, 187, 181, 181, 187, 91, 92, 134, + 198, 174, 206, 207, 181, 88, 181, 88, 181, 181, + 181, 130, 198, 134, 198, 198, 129, 1, 170, 170, + 170, 170, 170, 170, 1, 186, 170, 170, 181, 181, + 89, 150, 1, 16, 21, 33, 140, 141, 142, 144, + 148, 149, 150, 150, 150, 198, 130, 1, 108, 130, + 198, 31, 32, 138, 198, 75, 74, 193, 76, 190, + 190, 190, 190, 101, 100, 181, 41, 106, 181, 105, + 104, 175, 180, 180, 180, 175, 180, 106, 75, 75, + 75, 71, 198, 53, 71, 188, 198, 198, 198, 59, + 1, 181, 207, 74, 1, 123, 181, 181, 181, 16, + 1, 108, 1, 123, 1, 108, 118, 16, 18, 25, + 122, 75, 75, 75, 75, 75, 75, 75, 75, 75, + 181, 186, 1, 140, 198, 186, 198, 75, 181, 16, + 140, 89, 89, 1, 140, 16, 122, 16, 16, 1, + 108, 75, 169, 198, 16, 1, 108, 196, 181, 181, + 175, 175, 1, 108, 71, 71, 123, 123, 186, 16, + 14, 15, 119, 16, 122, 170, 149, 170, 71, 16, + 75, 1, 75, 198, 1, 140, 16, 170, 198, 16, + 198, 75, 1, 108, 198, 73, 126, 16, 122, 71, + 198, 198, 198, 198, 170, 75, 23, 24, 25, 26, + 27, 28, 153, 75, 198, 198, 198, 16, 198, 75, + 198, 1, 108, 198, 186, 72, 127, 198, 170, 118, + 118, 75, 129, 149, 149, 170, 149, 170, 170, 16, + 140, 147, 1, 147, 198, 130, 138, 1, 108, 75, + 198, 16, 75, 198, 16, 153, 153, 75, 153, 75, + 75, 23, 24, 25, 26, 27, 28, 143, 73, 145, + 16, 138, 198, 108, 198, 198, 108, 149, 149, 149, + 198, 198, 170, 198, 170, 170, 16, 186, 72, 146, + 108, 108, 16, 153, 153, 153, 147, 147, 75, 147, + 75, 75, 198, 75, 198, 16, 126, 16, 198, 143, + 143, 198, 143, 198, 198, 198, 147, 198, 198, 147, + 147, 147, 147, 143, 143, 143, 145 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. However, + YYFAIL appears to be in use. Nevertheless, it is formally deprecated + in Bison 2.4.2's NEWS entry, where a plan to phase it out is + discussed. */ + +#define YYFAIL goto yyerrlab +#if defined YYFAIL + /* This is here to suppress warnings from the GCC cpp's + -Wunused-macros. Normally we don't worry about that warning, but + some users do, and we want to make it easy for users to remove + YYFAIL uses, which will produce warnings from Bison 2.5. */ +#endif + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (1); \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (scnr, parser, YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) + + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (YYID (N)) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (YYID (0)) +#endif + + +/* This macro is provided for backward compatibility. */ + +#ifndef YY_LOCATION_PRINT +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, YYLEX_PARAM) +#else +# define YYLEX yylex (&yylval, scnr) +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value, scnr, parser); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, scanner_t *scnr, parser_t *parser) +#else +static void +yy_symbol_value_print (yyoutput, yytype, yyvaluep, scnr, parser) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; + scanner_t *scnr; + parser_t *parser; +#endif +{ + if (!yyvaluep) + return; + YYUSE (scnr); + YYUSE (parser); +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { + default: + break; + } +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, scanner_t *scnr, parser_t *parser) +#else +static void +yy_symbol_print (yyoutput, yytype, yyvaluep, scnr, parser) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; + scanner_t *scnr; + parser_t *parser; +#endif +{ + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + yy_symbol_value_print (yyoutput, yytype, yyvaluep, scnr, parser); + YYFPRINTF (yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +#else +static void +yy_stack_print (yybottom, yytop) + yytype_int16 *yybottom; + yytype_int16 *yytop; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_reduce_print (YYSTYPE *yyvsp, int yyrule, scanner_t *scnr, parser_t *parser) +#else +static void +yy_reduce_print (yyvsp, yyrule, scnr, parser) + YYSTYPE *yyvsp; + int yyrule; + scanner_t *scnr; + parser_t *parser; +#endif +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)]) + , scnr, parser); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, Rule, scnr, parser); \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen (const char *yystr) +#else +static YYSIZE_T +yystrlen (yystr) + const char *yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char * +yystpcpy (char *yydest, const char *yysrc) +#else +static char * +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +#endif +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP. + + Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return 2 if the + required number of bytes is too large to store. */ +static int +yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, + yytype_int16 *yyssp, int yytoken) +{ + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = 0; + /* Arguments of yyformat. */ + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + + /* There are many possibilities here to consider: + - Assume YYFAIL is not used. It's too flawed to consider. See + <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> + for details. YYERROR is fine as it does not invoke this + function. + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yytoken != YYEMPTY) + { + int yyn = yypact[*yyssp]; + yyarg[yycount++] = yytname[yytoken]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr (0, yytname[yyx]); + if (! (yysize <= yysize1 + && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + } + } + } + + switch (yycount) + { +# define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +# undef YYCASE_ + } + + yysize1 = yysize + yystrlen (yyformat); + if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + return 2; + yysize = yysize1; + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return 1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + return 0; +} +#endif /* YYERROR_VERBOSE */ + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, scanner_t *scnr, parser_t *parser) +#else +static void +yydestruct (yymsg, yytype, yyvaluep, scnr, parser) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; + scanner_t *scnr; + parser_t *parser; +#endif +{ + YYUSE (yyvaluep); + YYUSE (scnr); + YYUSE (parser); + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (scanner_t *scnr, parser_t *parser); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void *YYPARSE_PARAM) +#else +int +yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (scanner_t *scnr, parser_t *parser) +#else +int +yyparse (scnr, parser) + scanner_t *scnr; + parser_t *parser; +#endif +#endif +{ +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + + /* Number of syntax errors so far. */ + int yynerrs; + + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + `yyss': related to states. + `yyvs': related to semantic values. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp; + + YYSIZE_T yystacksize; + + int yyn; + int yyresult; + /* Lookahead token as an internal (translated) token number. */ + int yytoken; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + yytoken = 0; + yyss = yyssa; + yyvs = yyvsa; + yystacksize = YYINITDEPTH; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token. */ + yychar = YYEMPTY; + + yystate = yyn; + *++yyvsp = yylval; + + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: + +/* Line 1806 of yacc.c */ +#line 173 "parser.y" + { parser->syntax_tree = (yyvsp[(1) - (1)].val); } + break; + + case 3: + +/* Line 1806 of yacc.c */ +#line 174 "parser.y" + { parser->syntax_tree = (yyvsp[(2) - (2)].val); end_of_regex(scnr); } + break; + + case 4: + +/* Line 1806 of yacc.c */ +#line 176 "parser.y" + { parser->syntax_tree = (yyvsp[(2) - (2)].val); YYACCEPT; } + break; + + case 5: + +/* Line 1806 of yacc.c */ +#line 177 "parser.y" + { internal_error("notreached"); } + break; + + case 6: + +/* Line 1806 of yacc.c */ +#line 179 "parser.y" + { parser->syntax_tree = (yyvsp[(2) - (2)].val); YYACCEPT; } + break; + + case 7: + +/* Line 1806 of yacc.c */ +#line 180 "parser.y" + { internal_error("notreached"); } + break; + + case 8: + +/* Line 1806 of yacc.c */ +#line 181 "parser.y" + { if (yychar == YYEOF) { + parser->syntax_tree = nao; + YYACCEPT; + } else { + yybadtok(yychar, nil); + parser->syntax_tree = nil; + } } + break; + + case 9: + +/* Line 1806 of yacc.c */ +#line 188 "parser.y" + { if (yychar == YYEOF) { + parser->syntax_tree = nao; + YYACCEPT; + } else { + yybadtok(yychar, nil); + parser->syntax_tree = nil; + } } + break; + + case 10: + +/* Line 1806 of yacc.c */ +#line 195 "parser.y" + { parser->syntax_tree = nil; + if (parser->errors >= 8) + YYABORT; + yyerrok; + yybadtok(yychar, nil); } + break; + + case 11: + +/* Line 1806 of yacc.c */ +#line 204 "parser.y" + { parser->ignore = 1; } + break; + + case 12: + +/* Line 1806 of yacc.c */ +#line 205 "parser.y" + { parser->ignore = 0; + (yyval.val) = nao; } + break; + + case 13: + +/* Line 1806 of yacc.c */ +#line 207 "parser.y" + { parser->ignore = 1; } + break; + + case 14: + +/* Line 1806 of yacc.c */ +#line 208 "parser.y" + { parser->ignore = 0; + (yyval.val) = nao; } + break; + + case 15: + +/* Line 1806 of yacc.c */ +#line 210 "parser.y" + { parser->ignore = 1; } + break; + + case 16: + +/* Line 1806 of yacc.c */ +#line 211 "parser.y" + { parser->ignore = 0; + (yyval.val) = nao; } + break; + + case 17: + +/* Line 1806 of yacc.c */ +#line 213 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 18: + +/* Line 1806 of yacc.c */ +#line 214 "parser.y" + { (yyval.val) = uref_helper(parser, (yyvsp[(2) - (2)].val)); } + break; + + case 19: + +/* Line 1806 of yacc.c */ +#line 215 "parser.y" + { (yyval.val) = uoref_helper(parser, (yyvsp[(2) - (2)].val)); } + break; + + case 20: + +/* Line 1806 of yacc.c */ +#line 218 "parser.y" + { parser->ignore = 1; } + break; + + case 21: + +/* Line 1806 of yacc.c */ +#line 219 "parser.y" + { parser->ignore = 0; + (yyval.val) = nao; } + break; + + case 22: + +/* Line 1806 of yacc.c */ +#line 221 "parser.y" + { parser->ignore = 1; } + break; + + case 23: + +/* Line 1806 of yacc.c */ +#line 222 "parser.y" + { parser->ignore = 0; + (yyval.val) = nao; } + break; + + case 24: + +/* Line 1806 of yacc.c */ +#line 224 "parser.y" + { parser->ignore = 1; } + break; + + case 25: + +/* Line 1806 of yacc.c */ +#line 225 "parser.y" + { parser->ignore = 0; + (yyval.val) = nao; } + break; + + case 26: + +/* Line 1806 of yacc.c */ +#line 227 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 27: + +/* Line 1806 of yacc.c */ +#line 228 "parser.y" + { (yyval.val) = uref_helper(parser, (yyvsp[(2) - (2)].val)); } + break; + + case 28: + +/* Line 1806 of yacc.c */ +#line 229 "parser.y" + { (yyval.val) = uoref_helper(parser, (yyvsp[(2) - (2)].val)); } + break; + + case 29: + +/* Line 1806 of yacc.c */ +#line 234 "parser.y" + { internal_error("notreached"); } + break; + + case 30: + +/* Line 1806 of yacc.c */ +#line 235 "parser.y" + { internal_error("notreached"); } + break; + + case 31: + +/* Line 1806 of yacc.c */ +#line 236 "parser.y" + { internal_error("notreached"); } + break; + + case 32: + +/* Line 1806 of yacc.c */ +#line 239 "parser.y" + { (yyval.val) = check_parse_time_action(cons((yyvsp[(1) - (1)].val), nil)); } + break; + + case 33: + +/* Line 1806 of yacc.c */ +#line 240 "parser.y" + { (yyval.val) = check_parse_time_action(cons((yyvsp[(2) - (2)].val), (yyvsp[(1) - (2)].val))); } + break; + + case 34: + +/* Line 1806 of yacc.c */ +#line 243 "parser.y" + { (yyval.val) = us_nreverse((yyvsp[(1) - (1)].val)); } + break; + + case 35: + +/* Line 1806 of yacc.c */ +#line 244 "parser.y" + { (yyval.val) = nil; } + break; + + case 36: + +/* Line 1806 of yacc.c */ +#line 247 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 37: + +/* Line 1806 of yacc.c */ +#line 248 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 38: + +/* Line 1806 of yacc.c */ +#line 249 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 39: + +/* Line 1806 of yacc.c */ +#line 250 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 40: + +/* Line 1806 of yacc.c */ +#line 251 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 41: + +/* Line 1806 of yacc.c */ +#line 252 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 42: + +/* Line 1806 of yacc.c */ +#line 253 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 43: + +/* Line 1806 of yacc.c */ +#line 254 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 44: + +/* Line 1806 of yacc.c */ +#line 255 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 45: + +/* Line 1806 of yacc.c */ +#line 256 "parser.y" + { (yyval.val) = list(define_transform(parser, (yyvsp[(1) - (1)].val)), nao); + rlc(car((yyval.val)), (yyvsp[(1) - (1)].val)); + rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 46: + +/* Line 1806 of yacc.c */ +#line 259 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 47: + +/* Line 1806 of yacc.c */ +#line 260 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 48: + +/* Line 1806 of yacc.c */ +#line 261 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 49: + +/* Line 1806 of yacc.c */ +#line 262 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 50: + +/* Line 1806 of yacc.c */ +#line 265 "parser.y" + { (yyval.val) = list(all_s, (yyvsp[(3) - (3)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (3)].lineno))); } + break; + + case 51: + +/* Line 1806 of yacc.c */ +#line 267 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("all clause")); } + break; + + case 52: + +/* Line 1806 of yacc.c */ +#line 272 "parser.y" + { (yyval.val) = list(some_s, (yyvsp[(5) - (5)].val), (yyvsp[(2) - (5)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (5)].lineno))); } + break; + + case 53: + +/* Line 1806 of yacc.c */ +#line 276 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("some clause")); } + break; + + case 54: + +/* Line 1806 of yacc.c */ +#line 280 "parser.y" + { (yyval.val) = list(none_s, (yyvsp[(3) - (3)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (3)].lineno))); } + break; + + case 55: + +/* Line 1806 of yacc.c */ +#line 282 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("none clause")); } + break; + + case 56: + +/* Line 1806 of yacc.c */ +#line 286 "parser.y" + { (yyval.val) = list(maybe_s, (yyvsp[(3) - (3)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (3)].lineno))); } + break; + + case 57: + +/* Line 1806 of yacc.c */ +#line 288 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("maybe clause")); } + break; + + case 58: + +/* Line 1806 of yacc.c */ +#line 292 "parser.y" + { (yyval.val) = list(cases_s, (yyvsp[(3) - (3)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (3)].lineno))); } + break; + + case 59: + +/* Line 1806 of yacc.c */ +#line 294 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("cases clause")); } + break; + + case 60: + +/* Line 1806 of yacc.c */ +#line 300 "parser.y" + { val name = first((yyvsp[(2) - (7)].val)); + if (gt(length((yyvsp[(2) - (7)].val)), one)) + yyerr("block: takes zero or no arguments"); + if (name && !bindable(name)) + yyerrorf(scnr, + lit("block: ~s is not a bindable symbol"), + name, nao); + (yyval.val) = list(block_s, name, (yyvsp[(5) - (7)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (7)].lineno))); } + break; + + case 61: + +/* Line 1806 of yacc.c */ +#line 310 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("block clause")); } + break; + + case 62: + +/* Line 1806 of yacc.c */ +#line 315 "parser.y" + { (yyval.val) = list(choose_s, (yyvsp[(5) - (5)].val), (yyvsp[(2) - (5)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (5)].lineno))); } + break; + + case 63: + +/* Line 1806 of yacc.c */ +#line 318 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("choose clause")); } + break; + + case 64: + +/* Line 1806 of yacc.c */ +#line 324 "parser.y" + { val args = match_expand_keyword_args((yyvsp[(2) - (7)].val)); + (yyval.val) = list(gather_s, + append2(mapcar(pa_12_1(func_n2(cons), nil), + first((yyvsp[(5) - (7)].val))), rest((yyvsp[(5) - (7)].val))), + args, nao); + rl((yyval.val), num((yyvsp[(1) - (7)].lineno))); } + break; + + case 65: + +/* Line 1806 of yacc.c */ +#line 335 "parser.y" + { val args = match_expand_keyword_args((yyvsp[(2) - (12)].val)); + (yyval.val) = list(gather_s, + append2(mapcar(pa_12_1(func_n2(cons), nil), + first((yyvsp[(5) - (12)].val))), rest((yyvsp[(5) - (12)].val))), + args, cons(cdr((yyvsp[(6) - (12)].val)), + cons((yyvsp[(7) - (12)].val), (yyvsp[(10) - (12)].val))), nao); + rl((yyval.val), num((yyvsp[(1) - (12)].lineno))); } + break; + + case 66: + +/* Line 1806 of yacc.c */ +#line 344 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("gather clause")); } + break; + + case 67: + +/* Line 1806 of yacc.c */ +#line 349 "parser.y" + { (yyval.val) = if2((yyvsp[(1) - (2)].val), cons((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val))); } + break; + + case 68: + +/* Line 1806 of yacc.c */ +#line 352 "parser.y" + { (yyval.val) = (yyvsp[(3) - (3)].val); } + break; + + case 69: + +/* Line 1806 of yacc.c */ +#line 353 "parser.y" + { (yyval.val) = (yyvsp[(3) - (3)].val); } + break; + + case 70: + +/* Line 1806 of yacc.c */ +#line 354 "parser.y" + { (yyval.val) = nil; } + break; + + case 71: + +/* Line 1806 of yacc.c */ +#line 358 "parser.y" + { val args = match_expand_keyword_args((yyvsp[(2) - (7)].val)); + (yyval.val) = list(car((yyvsp[(1) - (7)].val)), + (yyvsp[(5) - (7)].val), nil, args, + nao); + rl((yyval.val), cdr((yyvsp[(1) - (7)].val))); } + break; + + case 72: + +/* Line 1806 of yacc.c */ +#line 366 "parser.y" + { val args = match_expand_keyword_args((yyvsp[(2) - (12)].val)); + if (nilp((yyvsp[(10) - (12)].val))) + yyerr("empty until/last in collect"); + (yyval.val) = list(car((yyvsp[(1) - (12)].val)), (yyvsp[(5) - (12)].val), + cons(cdr((yyvsp[(6) - (12)].val)), + cons((yyvsp[(7) - (12)].val), (yyvsp[(10) - (12)].val))), + args, nao); + rl((yyval.val), cdr((yyvsp[(1) - (12)].val))); + rl((yyvsp[(10) - (12)].val), car((yyvsp[(6) - (12)].val))); } + break; + + case 73: + +/* Line 1806 of yacc.c */ +#line 376 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("collect clause")); } + break; + + case 74: + +/* Line 1806 of yacc.c */ +#line 380 "parser.y" + { (yyval.val) = cons(collect_s, num((yyvsp[(1) - (1)].lineno))); } + break; + + case 75: + +/* Line 1806 of yacc.c */ +#line 381 "parser.y" + { (yyval.val) = cons(repeat_s, num((yyvsp[(1) - (1)].lineno))); } + break; + + case 76: + +/* Line 1806 of yacc.c */ +#line 384 "parser.y" + { (yyval.val) = cons(num((yyvsp[(1) - (1)].lineno)), until_s); } + break; + + case 77: + +/* Line 1806 of yacc.c */ +#line 385 "parser.y" + { (yyval.val) = cons(num((yyvsp[(1) - (1)].lineno)), last_s); } + break; + + case 78: + +/* Line 1806 of yacc.c */ +#line 388 "parser.y" + { (yyval.val) = if2((yyvsp[(1) - (2)].val), cons((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val))); } + break; + + case 79: + +/* Line 1806 of yacc.c */ +#line 391 "parser.y" + { (yyval.val) = nil; } + break; + + case 80: + +/* Line 1806 of yacc.c */ +#line 392 "parser.y" + { (yyval.val) = (yyvsp[(3) - (3)].val); } + break; + + case 81: + +/* Line 1806 of yacc.c */ +#line 393 "parser.y" + { (yyval.val) = (yyvsp[(3) - (3)].val); } + break; + + case 82: + +/* Line 1806 of yacc.c */ +#line 400 "parser.y" + { if (opt_compat && opt_compat <= 136) + { val xexp = expand_meta((yyvsp[(2) - (9)].val), nil); + val req = rlc(cons(require_s, xexp), (yyvsp[(2) - (9)].val)); + val iff = rlc(cons(cons(cons(req, nil), (yyvsp[(5) - (9)].val)), nil), (yyvsp[(2) - (9)].val)); + val elifs = (yyvsp[(6) - (9)].val); + val els = cons((yyvsp[(7) - (9)].val), nil); + val cases = nappend2(nappend2(iff, elifs), els); + (yyval.val) = list(cases_s, cases, nao); } + else + { val expr = expand(car((yyvsp[(2) - (9)].val)), nil); + val ifs = (yyvsp[(5) - (9)].val); + val branch = cons(cons(expr, ifs), nil); + val elifs = (yyvsp[(6) - (9)].val); + val els = (yyvsp[(7) - (9)].val); + if (cdr((yyvsp[(2) - (9)].val))) + yyerr("extra expression in if"); + (yyval.val) = cons(if_s, + nappend2(branch, nappend2(elifs, els))); + rl((yyval.val), num((yyvsp[(1) - (9)].lineno))); } } + break; + + case 83: + +/* Line 1806 of yacc.c */ +#line 420 "parser.y" + { (yyval.val) = nil; yybadtok(yychar, lit("if clause")); } + break; + + case 84: + +/* Line 1806 of yacc.c */ +#line 425 "parser.y" + { if (opt_compat && opt_compat <= 136) + { val xexp = expand_meta((yyvsp[(2) - (6)].val), nil); + val req = rlc(cons(require_s, xexp), (yyvsp[(2) - (6)].val)); + (yyval.val) = cons(cons(cons(req, nil), (yyvsp[(5) - (6)].val)), (yyvsp[(6) - (6)].val)); } + else + { val expr = expand(car((yyvsp[(2) - (6)].val)), nil); + val elifs = (yyvsp[(5) - (6)].val); + val branch = cons(cons(expr, elifs), nil); + if (cdr((yyvsp[(2) - (6)].val))) + yyerr("extra expression in elif"); + (yyval.val) = nappend2(branch, (yyvsp[(6) - (6)].val)); } } + break; + + case 85: + +/* Line 1806 of yacc.c */ +#line 436 "parser.y" + { (yyval.val) = nil; } + break; + + case 86: + +/* Line 1806 of yacc.c */ +#line 440 "parser.y" + { if (opt_compat && opt_compat <= 136) + { (yyval.val) = (yyvsp[(3) - (3)].val); } + else + { (yyval.val) = cons(cons(t, (yyvsp[(3) - (3)].val)), nil); } } + break; + + case 87: + +/* Line 1806 of yacc.c */ +#line 444 "parser.y" + { (yyval.val) = nil; } + break; + + case 88: + +/* Line 1806 of yacc.c */ +#line 447 "parser.y" + { (yyval.val) = (yyvsp[(1) - (2)].val); } + break; + + case 89: + +/* Line 1806 of yacc.c */ +#line 450 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 90: + +/* Line 1806 of yacc.c */ +#line 451 "parser.y" + { (yyval.val) = nil; } + break; + + case 91: + +/* Line 1806 of yacc.c */ +#line 454 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); + rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 92: + +/* Line 1806 of yacc.c */ +#line 456 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); + rlc((yyval.val), (yyvsp[(1) - (2)].val)); } + break; + + case 93: + +/* Line 1806 of yacc.c */ +#line 461 "parser.y" + { (yyval.val) = rl(string_own((yyvsp[(1) - (1)].lexeme)), num(parser->lineno)); } + break; + + case 94: + +/* Line 1806 of yacc.c */ +#line 462 "parser.y" + { if ((yyvsp[(1) - (1)].lexeme)[0] == ' ' && (yyvsp[(1) - (1)].lexeme)[1] == 0) + { val spaces = list(oneplus_s, + chr(' '), nao); + free((yyvsp[(1) - (1)].lexeme)); + (yyval.val) = regex_compile(spaces, nil); + rl((yyval.val), num(parser->lineno)); } + else + { (yyval.val) = rl(string_own((yyvsp[(1) - (1)].lexeme)), num(parser->lineno)); }} + break; + + case 95: + +/* Line 1806 of yacc.c */ +#line 470 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); + rl((yyval.val), num(parser->lineno)); } + break; + + case 96: + +/* Line 1806 of yacc.c */ +#line 472 "parser.y" + { (yyval.val) = null_string; } + break; + + case 97: + +/* Line 1806 of yacc.c */ +#line 475 "parser.y" + { (yyval.val) = rlc(cons((yyvsp[(1) - (1)].val), nil), (yyvsp[(1) - (1)].val)); } + break; + + case 98: + +/* Line 1806 of yacc.c */ +#line 476 "parser.y" + { (yyval.val) = rlc(cons((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)), (yyvsp[(2) - (2)].val)); } + break; + + case 99: + +/* Line 1806 of yacc.c */ +#line 479 "parser.y" + { (yyval.val) = rlc(cons(text_s, (yyvsp[(1) - (1)].val)), (yyvsp[(1) - (1)].val)); + (yyval.val) = rlc(optimize_text((yyval.val)), (yyval.val)); } + break; + + case 100: + +/* Line 1806 of yacc.c */ +#line 481 "parser.y" + { (yyval.val) = rl((yyvsp[(1) - (1)].val), num(parser->lineno)); + match_reg_elem((yyval.val)); } + break; + + case 101: + +/* Line 1806 of yacc.c */ +#line 483 "parser.y" + { val sym = first((yyvsp[(1) - (1)].val)); + if (sym == do_s || sym == require_s) + (yyval.val) = rlc(cons(sym, + expand_forms(rest((yyvsp[(1) - (1)].val)), nil)), + (yyvsp[(1) - (1)].val)); + else + { (yyval.val) = match_expand_elem((yyvsp[(1) - (1)].val)); + match_reg_elem((yyval.val)); } } + break; + + case 102: + +/* Line 1806 of yacc.c */ +#line 491 "parser.y" + { val args = match_expand_keyword_args((yyvsp[(2) - (5)].val)); + (yyval.val) = list(coll_s, (yyvsp[(4) - (5)].val), nil, args, nao); + rl((yyval.val), num((yyvsp[(1) - (5)].lineno))); } + break; + + case 103: + +/* Line 1806 of yacc.c */ +#line 496 "parser.y" + { val args = match_expand_keyword_args((yyvsp[(2) - (9)].val)); + (yyval.val) = list(coll_s, (yyvsp[(4) - (9)].val), cons(cdr((yyvsp[(5) - (9)].val)), + cons((yyvsp[(6) - (9)].val), (yyvsp[(8) - (9)].val))), + args, nao); + rl((yyval.val), num((yyvsp[(1) - (9)].lineno))); + rl((yyvsp[(6) - (9)].val), car((yyvsp[(5) - (9)].val))); } + break; + + case 104: + +/* Line 1806 of yacc.c */ +#line 502 "parser.y" + { val args = match_expand_keyword_args((yyvsp[(2) - (5)].val)); + (yyval.val) = list(rep_s, (yyvsp[(4) - (5)].val), nil, args, nao); + rl((yyval.val), num((yyvsp[(1) - (5)].lineno))); } + break; + + case 105: + +/* Line 1806 of yacc.c */ +#line 508 "parser.y" + { val args = match_expand_keyword_args((yyvsp[(2) - (9)].val)); + (yyval.val) = list(rep_s, (yyvsp[(4) - (9)].val), cons(cdr((yyvsp[(5) - (9)].val)), + cons((yyvsp[(6) - (9)].val), (yyvsp[(8) - (9)].val))), + args, nao); + rl((yyval.val), num((yyvsp[(1) - (9)].lineno))); + rl((yyvsp[(6) - (9)].val), car((yyvsp[(5) - (9)].val))); } + break; + + case 106: + +/* Line 1806 of yacc.c */ +#line 514 "parser.y" + { (yyval.val) = list(block_s, car((yyvsp[(2) - (5)].val)), + cons((yyvsp[(4) - (5)].val), nil), nao); + rl((yyval.val), num((yyvsp[(1) - (5)].lineno))); } + break; + + case 107: + +/* Line 1806 of yacc.c */ +#line 517 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("coll clause")); } + break; + + case 108: + +/* Line 1806 of yacc.c */ +#line 519 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("rep clause")); } + break; + + case 109: + +/* Line 1806 of yacc.c */ +#line 521 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("rep clause")); } + break; + + case 110: + +/* Line 1806 of yacc.c */ +#line 523 "parser.y" + { (yyval.val) = rl(list(all_s, t, (yyvsp[(2) - (2)].val), nao), num((yyvsp[(1) - (2)].lineno))); } + break; + + case 111: + +/* Line 1806 of yacc.c */ +#line 525 "parser.y" + { (yyval.val) = rl(list(some_s, t, (yyvsp[(4) - (4)].val), (yyvsp[(2) - (4)].val), nao), num((yyvsp[(1) - (4)].lineno))); } + break; + + case 112: + +/* Line 1806 of yacc.c */ +#line 526 "parser.y" + { (yyval.val) = rl(list(none_s, t, (yyvsp[(2) - (2)].val), nao), num((yyvsp[(1) - (2)].lineno))); } + break; + + case 113: + +/* Line 1806 of yacc.c */ +#line 527 "parser.y" + { (yyval.val) = rl(list(maybe_s, t, (yyvsp[(2) - (2)].val), nao), num((yyvsp[(1) - (2)].lineno))); } + break; + + case 114: + +/* Line 1806 of yacc.c */ +#line 528 "parser.y" + { (yyval.val) = rl(list(cases_s, t, (yyvsp[(2) - (2)].val), nao), num((yyvsp[(1) - (2)].lineno))); } + break; + + case 115: + +/* Line 1806 of yacc.c */ +#line 530 "parser.y" + { (yyval.val) = list(choose_s, t, (yyvsp[(4) - (4)].val), (yyvsp[(2) - (4)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (4)].lineno))); } + break; + + case 116: + +/* Line 1806 of yacc.c */ +#line 533 "parser.y" + { (yyval.val) = list(define_s, t, (yyvsp[(4) - (5)].val), (yyvsp[(2) - (5)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (5)].lineno))); + match_reg_params(second((yyvsp[(2) - (5)].val))); } + break; + + case 117: + +/* Line 1806 of yacc.c */ +#line 538 "parser.y" + { (yyval.val) = if2((yyvsp[(1) - (2)].val), cons((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val))); } + break; + + case 118: + +/* Line 1806 of yacc.c */ +#line 541 "parser.y" + { (yyval.val) = nil; } + break; + + case 119: + +/* Line 1806 of yacc.c */ +#line 542 "parser.y" + { (yyval.val) = (yyvsp[(2) - (2)].val); } + break; + + case 120: + +/* Line 1806 of yacc.c */ +#line 543 "parser.y" + { (yyval.val) = (yyvsp[(2) - (2)].val); } + break; + + case 121: + +/* Line 1806 of yacc.c */ +#line 548 "parser.y" + { (yyval.val) = list(define_s, (yyvsp[(2) - (7)].val), (yyvsp[(5) - (7)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (7)].lineno))); + match_reg_params(second((yyvsp[(2) - (7)].val))); } + break; + + case 122: + +/* Line 1806 of yacc.c */ +#line 553 "parser.y" + { (yyval.val) = list(define_s, nil, (yyvsp[(4) - (6)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (6)].lineno))); } + break; + + case 123: + +/* Line 1806 of yacc.c */ +#line 555 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("define directive")); } + break; + + case 124: + +/* Line 1806 of yacc.c */ +#line 558 "parser.y" + { (yyval.val) = nil; yybadtok(yychar, lit("define")); } + break; + + case 125: + +/* Line 1806 of yacc.c */ +#line 560 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("define")); } + break; + + case 126: + +/* Line 1806 of yacc.c */ +#line 567 "parser.y" + { (yyval.val) = list(try_s, + flatten(mapcar(func_n1(second), + (yyvsp[(4) - (6)].val))), + (yyvsp[(3) - (6)].val), (yyvsp[(4) - (6)].val), nao); + rl((yyval.val), num((yyvsp[(1) - (6)].lineno))); } + break; + + case 127: + +/* Line 1806 of yacc.c */ +#line 573 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("try clause")); } + break; + + case 128: + +/* Line 1806 of yacc.c */ +#line 579 "parser.y" + { (yyval.val) = cons(list(catch_s, cons(t, nil), + (yyvsp[(4) - (5)].val), nao), (yyvsp[(5) - (5)].val)); + rl((yyval.val), num((yyvsp[(1) - (5)].lineno))); } + break; + + case 129: + +/* Line 1806 of yacc.c */ +#line 584 "parser.y" + { (yyval.val) = cons(list(catch_s, (yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), nao), + (yyvsp[(6) - (6)].val)); + process_catch_exprs((yyvsp[(2) - (6)].val)); + rl((yyval.val), num((yyvsp[(1) - (6)].lineno))); } + break; + + case 130: + +/* Line 1806 of yacc.c */ +#line 589 "parser.y" + { (yyval.val) = cons(list(finally_s, nil, + (yyvsp[(3) - (3)].val), nao), + nil); + rl((yyval.val), num((yyvsp[(1) - (3)].lineno))); } + break; + + case 131: + +/* Line 1806 of yacc.c */ +#line 593 "parser.y" + { (yyval.val) = nil; } + break; + + case 132: + +/* Line 1806 of yacc.c */ +#line 595 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("catch clause")); } + break; + + case 133: + +/* Line 1806 of yacc.c */ +#line 598 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("catch clause")); } + break; + + case 134: + +/* Line 1806 of yacc.c */ +#line 601 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("finally clause")); } + break; + + case 135: + +/* Line 1806 of yacc.c */ +#line 608 "parser.y" + { (yyval.val) = nil; + yyerr("obsolete output syntax: trailing material"); } + break; + + case 136: + +/* Line 1806 of yacc.c */ +#line 611 "parser.y" + { (yyval.val) = rl(list(output_s, nao), num((yyvsp[(1) - (5)].lineno))); } + break; + + case 137: + +/* Line 1806 of yacc.c */ +#line 614 "parser.y" + { (yyval.val) = rl(list(output_s, (yyvsp[(4) - (6)].val), nao), num((yyvsp[(1) - (6)].lineno))); } + break; + + case 138: + +/* Line 1806 of yacc.c */ +#line 617 "parser.y" + { cons_bind (dest, rest, (yyvsp[(2) - (7)].val)); + val dest_ex = expand_form_ver(dest, 166); + val args = if3(dest_ex == dest, + (yyvsp[(2) - (7)].val), cons(dest_ex, rest)); + (yyval.val) = list(output_s, (yyvsp[(5) - (7)].val), args, nao); + rl((yyval.val), num((yyvsp[(1) - (7)].lineno))); + { val into_var = second(memql(into_k, args)); + val named_var = second(memql(named_k, args)); + match_reg_var(into_var); + match_reg_var(named_var); } } + break; + + case 139: + +/* Line 1806 of yacc.c */ +#line 629 "parser.y" + { (yyval.val) = nil; + yyerr("invalid combination of old and " + "new syntax in output directive"); } + break; + + case 140: + +/* Line 1806 of yacc.c */ +#line 632 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("output directive")); } + break; + + case 141: + +/* Line 1806 of yacc.c */ +#line 635 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("output clause")); } + break; + + case 142: + +/* Line 1806 of yacc.c */ +#line 638 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("output clause")); } + break; + + case 143: + +/* Line 1806 of yacc.c */ +#line 641 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("output clause")); } + break; + + case 144: + +/* Line 1806 of yacc.c */ +#line 644 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("output clause")); } + break; + + case 145: + +/* Line 1806 of yacc.c */ +#line 648 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); } + break; + + case 146: + +/* Line 1806 of yacc.c */ +#line 649 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); } + break; + + case 147: + +/* Line 1806 of yacc.c */ +#line 652 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); } + break; + + case 148: + +/* Line 1806 of yacc.c */ +#line 653 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); } + break; + + case 149: + +/* Line 1806 of yacc.c */ +#line 654 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 150: + +/* Line 1806 of yacc.c */ +#line 660 "parser.y" + { (yyval.val) = repeat_rep_helper(repeat_s, + (yyvsp[(2) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(6) - (8)].val)); + rl((yyval.val), num((yyvsp[(1) - (8)].lineno))); } + break; + + case 151: + +/* Line 1806 of yacc.c */ +#line 664 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("repeat clause")); } + break; + + case 152: + +/* Line 1806 of yacc.c */ +#line 670 "parser.y" + { (yyval.val) = cons(cons(single_s, (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val)); + rl((yyval.val), num((yyvsp[(1) - (4)].lineno))); } + break; + + case 153: + +/* Line 1806 of yacc.c */ +#line 674 "parser.y" + { (yyval.val) = cons(cons(first_s, (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val)); + rl((yyval.val), num((yyvsp[(1) - (4)].lineno))); } + break; + + case 154: + +/* Line 1806 of yacc.c */ +#line 678 "parser.y" + { if ((yyvsp[(2) - (6)].val)) + yyerrorf(scnr, + lit("last: in output, " + "takes no arguments"), + nao); + (yyval.val) = cons(cons(last_s, (yyvsp[(5) - (6)].val)), (yyvsp[(6) - (6)].val)); + rl((yyval.val), num((yyvsp[(1) - (6)].lineno))); } + break; + + case 155: + +/* Line 1806 of yacc.c */ +#line 687 "parser.y" + { (yyval.val) = cons(cons(empty_s, (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val)); + rl((yyval.val), num((yyvsp[(1) - (4)].lineno))); } + break; + + case 156: + +/* Line 1806 of yacc.c */ +#line 692 "parser.y" + { (yyval.val) = cons(cons(mod_s, + cons(expand_forms_ver((yyvsp[(2) - (6)].val), 166), + (yyvsp[(5) - (6)].val))), (yyvsp[(6) - (6)].val)); + rl((yyval.val), num((yyvsp[(1) - (6)].lineno))); } + break; + + case 157: + +/* Line 1806 of yacc.c */ +#line 699 "parser.y" + { (yyval.val) = cons(cons(modlast_s, + cons(expand_forms_ver((yyvsp[(2) - (6)].val), 166), + (yyvsp[(5) - (6)].val))), (yyvsp[(6) - (6)].val)); + rl((yyval.val), num((yyvsp[(1) - (6)].lineno))); } + break; + + case 158: + +/* Line 1806 of yacc.c */ +#line 703 "parser.y" + { (yyval.val) = nil; } + break; + + case 159: + +/* Line 1806 of yacc.c */ +#line 710 "parser.y" + { val expr = expand((yyvsp[(2) - (9)].val), nil); + val ifs = (yyvsp[(5) - (9)].val); + val branch = cons(cons(expr, ifs), nil); + val elifs = (yyvsp[(6) - (9)].val); + val els = (yyvsp[(7) - (9)].val); + (yyval.val) = cons(if_s, + nappend2(branch, nappend2(elifs, els))); + rl((yyval.val), num((yyvsp[(1) - (9)].lineno))); } + break; + + case 160: + +/* Line 1806 of yacc.c */ +#line 719 "parser.y" + { (yyval.val) = nil; + yyerr("if requires expression"); } + break; + + case 161: + +/* Line 1806 of yacc.c */ +#line 722 "parser.y" + { (yyval.val) = nil; yybadtok(yychar, lit("if clause")); } + break; + + case 162: + +/* Line 1806 of yacc.c */ +#line 728 "parser.y" + { val expr = expand(car((yyvsp[(2) - (6)].val)), nil); + val elifs = (yyvsp[(5) - (6)].val); + val branch = cons(cons(expr, elifs), nil); + if (null((yyvsp[(2) - (6)].val))) + yyerr("elif requires expression"); + else if (cdr((yyvsp[(2) - (6)].val))) + yyerr("extra expression in elif"); + (yyval.val) = nappend2(branch, (yyvsp[(6) - (6)].val)); } + break; + + case 163: + +/* Line 1806 of yacc.c */ +#line 736 "parser.y" + { (yyval.val) = nil; } + break; + + case 164: + +/* Line 1806 of yacc.c */ +#line 741 "parser.y" + { (yyval.val) = cons(cons(t, (yyvsp[(3) - (3)].val)), nil); } + break; + + case 165: + +/* Line 1806 of yacc.c */ +#line 742 "parser.y" + { (yyval.val) = nil; } + break; + + case 166: + +/* Line 1806 of yacc.c */ +#line 745 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 167: + +/* Line 1806 of yacc.c */ +#line 746 "parser.y" + { (yyval.val) = nil; } + break; + + case 168: + +/* Line 1806 of yacc.c */ +#line 748 "parser.y" + { (yyval.val) = (yyvsp[(1) - (2)].val); } + break; + + case 169: + +/* Line 1806 of yacc.c */ +#line 751 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); + rl((yyval.val), num(parser->lineno)); } + break; + + case 170: + +/* Line 1806 of yacc.c */ +#line 753 "parser.y" + { (yyval.val) = nil; } + break; + + case 171: + +/* Line 1806 of yacc.c */ +#line 756 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); } + break; + + case 172: + +/* Line 1806 of yacc.c */ +#line 757 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); } + break; + + case 173: + +/* Line 1806 of yacc.c */ +#line 758 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); } + break; + + case 174: + +/* Line 1806 of yacc.c */ +#line 759 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); } + break; + + case 175: + +/* Line 1806 of yacc.c */ +#line 762 "parser.y" + { (yyval.val) = string_own((yyvsp[(1) - (1)].lexeme)); + rl((yyval.val), num(parser->lineno)); } + break; + + case 176: + +/* Line 1806 of yacc.c */ +#line 764 "parser.y" + { (yyval.val) = string_own((yyvsp[(1) - (1)].lexeme)); + rl((yyval.val), num(parser->lineno)); } + break; + + case 177: + +/* Line 1806 of yacc.c */ +#line 766 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 178: + +/* Line 1806 of yacc.c */ +#line 767 "parser.y" + { (yyval.val) = rlc(list(expr_s, + expand((yyvsp[(1) - (1)].val), nil), nao), (yyvsp[(1) - (1)].val)); } + break; + + case 179: + +/* Line 1806 of yacc.c */ +#line 769 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 180: + +/* Line 1806 of yacc.c */ +#line 773 "parser.y" + { (yyval.val) = repeat_rep_helper(rep_s, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val)); + rl((yyval.val), num((yyvsp[(1) - (6)].lineno))); } + break; + + case 181: + +/* Line 1806 of yacc.c */ +#line 775 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("rep clause")); } + break; + + case 182: + +/* Line 1806 of yacc.c */ +#line 780 "parser.y" + { (yyval.val) = cons(cons(single_s, (yyvsp[(2) - (3)].val)), (yyvsp[(3) - (3)].val)); + rl((yyval.val), num((yyvsp[(1) - (3)].lineno))); } + break; + + case 183: + +/* Line 1806 of yacc.c */ +#line 783 "parser.y" + { (yyval.val) = cons(cons(first_s, (yyvsp[(2) - (3)].val)), (yyvsp[(3) - (3)].val)); + rl((yyval.val), num((yyvsp[(1) - (3)].lineno))); } + break; + + case 184: + +/* Line 1806 of yacc.c */ +#line 786 "parser.y" + { if ((yyvsp[(2) - (5)].val)) + yyerrorf(scnr, + lit("last: in output, " + "takes no arguments"), + nao); + (yyval.val) = cons(cons(last_s, (yyvsp[(4) - (5)].val)), (yyvsp[(5) - (5)].val)); + rl((yyval.val), num((yyvsp[(1) - (5)].lineno))); } + break; + + case 185: + +/* Line 1806 of yacc.c */ +#line 794 "parser.y" + { (yyval.val) = cons(cons(empty_s, (yyvsp[(2) - (3)].val)), (yyvsp[(3) - (3)].val)); + rl((yyval.val), num((yyvsp[(1) - (3)].lineno))); } + break; + + case 186: + +/* Line 1806 of yacc.c */ +#line 798 "parser.y" + { (yyval.val) = cons(cons(mod_s, + cons(expand_forms_ver((yyvsp[(2) - (5)].val), 166), + (yyvsp[(4) - (5)].val))), (yyvsp[(5) - (5)].val)); + rl((yyval.val), num((yyvsp[(1) - (5)].lineno))); } + break; + + case 187: + +/* Line 1806 of yacc.c */ +#line 804 "parser.y" + { (yyval.val) = cons(cons(modlast_s, + cons(expand_forms_ver((yyvsp[(2) - (5)].val), 166), + (yyvsp[(4) - (5)].val))), (yyvsp[(5) - (5)].val)); + rl((yyval.val), num((yyvsp[(1) - (5)].lineno))); } + break; + + case 188: + +/* Line 1806 of yacc.c */ +#line 808 "parser.y" + { (yyval.val) = nil; } + break; + + case 189: + +/* Line 1806 of yacc.c */ +#line 815 "parser.y" + { (yyval.val) = list(var_s, symhlpr((yyvsp[(1) - (1)].lexeme), nil), nao); } + break; + + case 190: + +/* Line 1806 of yacc.c */ +#line 816 "parser.y" + { (yyval.val) = list(var_s, symhlpr((yyvsp[(2) - (3)].lexeme), nil), nao); } + break; + + case 191: + +/* Line 1806 of yacc.c */ +#line 817 "parser.y" + { (yyval.val) = list(var_s, symhlpr((yyvsp[(2) - (4)].lexeme), nil), (yyvsp[(3) - (4)].val), nao); } + break; + + case 192: + +/* Line 1806 of yacc.c */ +#line 818 "parser.y" + { (yyval.val) = list(var_s, symhlpr((yyvsp[(2) - (2)].lexeme), nil), (yyvsp[(1) - (2)].val), nao); } + break; + + case 193: + +/* Line 1806 of yacc.c */ +#line 819 "parser.y" + { (yyval.val) = list(var_s, symhlpr((yyvsp[(3) - (4)].lexeme), nil), (yyvsp[(1) - (4)].val), nao); } + break; + + case 194: + +/* Line 1806 of yacc.c */ +#line 820 "parser.y" + { (yyval.val) = nil; + yyerr("longest match " + "not useable with regex"); } + break; + + case 195: + +/* Line 1806 of yacc.c */ +#line 823 "parser.y" + { (yyval.val) = nil; + yyerr("longest match " + "not useable with " + "fixed width match"); } + break; + + case 196: + +/* Line 1806 of yacc.c */ +#line 827 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("variable spec")); } + break; + + case 197: + +/* Line 1806 of yacc.c */ +#line 829 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("variable spec")); } + break; + + case 198: + +/* Line 1806 of yacc.c */ +#line 833 "parser.y" + { (yyval.val) = list(t, nao); } + break; + + case 199: + +/* Line 1806 of yacc.c */ +#line 836 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); } + break; + + case 200: + +/* Line 1806 of yacc.c */ +#line 837 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); + rlc((yyval.val), (yyvsp[(1) - (1)].val)); } + break; + + case 201: + +/* Line 1806 of yacc.c */ +#line 839 "parser.y" + { (yyval.val) = rlc(cons(expand_meta((yyvsp[(1) - (1)].val), nil), + nil), (yyvsp[(1) - (1)].val)); } + break; + + case 202: + +/* Line 1806 of yacc.c */ +#line 841 "parser.y" + { (yyval.val) = cons(symhlpr((yyvsp[(1) - (1)].lexeme), nil), nil); } + break; + + case 203: + +/* Line 1806 of yacc.c */ +#line 844 "parser.y" + { val expr = symhlpr((yyvsp[(1) - (1)].lexeme), nil); + if (!opt_compat || opt_compat > 128) + expr = expand(expr, nil); + (yyval.val) = list(var_s, expr, nao); + rl((yyval.val), num(parser->lineno)); } + break; + + case 204: + +/* Line 1806 of yacc.c */ +#line 850 "parser.y" + { if (opt_compat && opt_compat <= 128) + { (yyval.val) = list(var_s, + expand_meta((yyvsp[(2) - (4)].val), nil), + expand_meta((yyvsp[(3) - (4)].val), nil), nao); } + else + { val quasi_var = list(var_s, (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val), nao); + val quasi_items = cons(quasi_var, nil); + (yyval.val) = car(expand_quasi(quasi_items, nil)); } } + break; + + case 205: + +/* Line 1806 of yacc.c */ +#line 858 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("variable spec")); } + break; + + case 206: + +/* Line 1806 of yacc.c */ +#line 863 "parser.y" + { (yyval.val) = list(var_s, (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), nao); + rl((yyval.val), num(parser->lineno)); } + break; + + case 207: + +/* Line 1806 of yacc.c */ +#line 865 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("variable spec")); } + break; + + case 208: + +/* Line 1806 of yacc.c */ +#line 870 "parser.y" + { if (parser->quasi_level > 0 && unquotes_occur((yyvsp[(2) - (2)].val), 0)) + (yyval.val) = rlc(cons(vector_lit_s, + cons((yyvsp[(2) - (2)].val), nil)), (yyvsp[(2) - (2)].val)); + else + (yyval.val) = rlc(vec_list((yyvsp[(2) - (2)].val)), (yyvsp[(2) - (2)].val)); } + break; + + case 209: + +/* Line 1806 of yacc.c */ +#line 875 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("unassigned/reserved # notation")); } + break; + + case 210: + +/* Line 1806 of yacc.c */ +#line 879 "parser.y" + { if (parser->quasi_level > 0 && unquotes_occur((yyvsp[(2) - (2)].val), 0)) + (yyval.val) = rl(cons(hash_lit_s, (yyvsp[(2) - (2)].val)), num((yyvsp[(1) - (2)].lineno))); + else + (yyval.val) = rl(hash_construct(first((yyvsp[(2) - (2)].val)), + rest((yyvsp[(2) - (2)].val))), + num((yyvsp[(1) - (2)].lineno))); } + break; + + case 211: + +/* Line 1806 of yacc.c */ +#line 885 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("hash literal")); } + break; + + case 212: + +/* Line 1806 of yacc.c */ +#line 889 "parser.y" + { if (parser->quasi_level > 0 && unquotes_occur((yyvsp[(2) - (2)].val), 0)) + (yyval.val) = rl(cons(struct_lit_s, (yyvsp[(2) - (2)].val)), + num((yyvsp[(1) - (2)].lineno))); + else + { val strct = make_struct_lit(first((yyvsp[(2) - (2)].val)), + rest((yyvsp[(2) - (2)].val))); + (yyval.val) = rl(strct, num((yyvsp[(1) - (2)].lineno))); } } + break; + + case 213: + +/* Line 1806 of yacc.c */ +#line 896 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("struct literal")); } + break; + + case 214: + +/* Line 1806 of yacc.c */ +#line 900 "parser.y" + { if (length((yyvsp[(2) - (2)].val)) != two) + yyerr("range literal needs two elements"); + { val range = rcons(first((yyvsp[(2) - (2)].val)), second((yyvsp[(2) - (2)].val))); + (yyval.val) = rl(range, num((yyvsp[(1) - (2)].lineno))); } } + break; + + case 215: + +/* Line 1806 of yacc.c */ +#line 904 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("range literal")); } + break; + + case 216: + +/* Line 1806 of yacc.c */ +#line 908 "parser.y" + { if (gt(length((yyvsp[(2) - (2)].val)), three)) + yyerr("excess elements in tree node"); + { val tn = tnode(first((yyvsp[(2) - (2)].val)), second((yyvsp[(2) - (2)].val)), + third((yyvsp[(2) - (2)].val))); + (yyval.val) = rl(tn, num((yyvsp[(1) - (2)].lineno))); } } + break; + + case 217: + +/* Line 1806 of yacc.c */ +#line 913 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("tree node literal")); } + break; + + case 218: + +/* Line 1806 of yacc.c */ +#line 917 "parser.y" + { if (parser->quasi_level > 0 && unquotes_occur((yyvsp[(2) - (2)].val), 0)) + (yyval.val) = rl(cons(tree_lit_s, (yyvsp[(2) - (2)].val)), num((yyvsp[(1) - (2)].lineno))); + else + { val opts = first((yyvsp[(2) - (2)].val)); + val key_fn_name = pop(&opts); + val less_fn_name = pop(&opts); + val equal_fn_name = pop(&opts); + val key_fn = fname_helper(parser, key_fn_name); + val less_fn = fname_helper(parser, less_fn_name); + val equal_fn = fname_helper(parser, equal_fn_name); + val tr = tree(rest((yyvsp[(2) - (2)].val)), key_fn, + less_fn, equal_fn); + (yyval.val) = rl(tr, num((yyvsp[(1) - (2)].lineno))); } } + break; + + case 219: + +/* Line 1806 of yacc.c */ +#line 930 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("tree node literal")); } + break; + + case 220: + +/* Line 1806 of yacc.c */ +#line 934 "parser.y" + { (yyval.val) = rl((yyvsp[(2) - (3)].val), num((yyvsp[(1) - (3)].lineno))); } + break; + + case 221: + +/* Line 1806 of yacc.c */ +#line 935 "parser.y" + { val a = car((yyvsp[(3) - (4)].val)); + val ur = uref_helper(parser, a); + if (ur == a) + (yyval.val) = (yyvsp[(3) - (4)].val); + else + (yyval.val) = rlc(cons(ur, cdr((yyvsp[(3) - (4)].val))), ur); } + break; + + case 222: + +/* Line 1806 of yacc.c */ +#line 941 "parser.y" + { (yyval.val) = nil; } + break; + + case 223: + +/* Line 1806 of yacc.c */ +#line 942 "parser.y" + { (yyval.val) = (yyvsp[(3) - (4)].val); } + break; + + case 224: + +/* Line 1806 of yacc.c */ +#line 943 "parser.y" + { (yyval.val) = (yyvsp[(3) - (4)].val); } + break; + + case 225: + +/* Line 1806 of yacc.c */ +#line 944 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("expression")); } + break; + + case 226: + +/* Line 1806 of yacc.c */ +#line 948 "parser.y" + { if (consp((yyvsp[(2) - (2)].val))) + (yyval.val) = rl(cons(expr_s, cons((yyvsp[(2) - (2)].val), nil)), num((yyvsp[(1) - (2)].lineno))); + else + (yyval.val) = rl(cons(var_s, cons((yyvsp[(2) - (2)].val), nil)), + num((yyvsp[(1) - (2)].lineno))); } + break; + + case 227: + +/* Line 1806 of yacc.c */ +#line 953 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("meta expression")); } + break; + + case 228: + +/* Line 1806 of yacc.c */ +#line 957 "parser.y" + { val a = car((yyvsp[(3) - (4)].val)); + val ur = uref_helper(parser, a); + (yyval.val) = rlcp_tree(cons(dwim_s, + cons(ur, cdr((yyvsp[(3) - (4)].val)))), ur); } + break; + + case 229: + +/* Line 1806 of yacc.c */ +#line 961 "parser.y" + { (yyval.val) = rl(cons(dwim_s, (yyvsp[(2) - (3)].val)), num((yyvsp[(1) - (3)].lineno))); } + break; + + case 230: + +/* Line 1806 of yacc.c */ +#line 962 "parser.y" + { (yyval.val) = rl(cons(dwim_s, nil), num((yyvsp[(1) - (2)].lineno))); } + break; + + case 231: + +/* Line 1806 of yacc.c */ +#line 963 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("DWIM expression")); } + break; + + case 235: + +/* Line 1806 of yacc.c */ +#line 972 "parser.y" + { (yyval.val) = rlc(expand_meta((yyvsp[(1) - (1)].val), nil), (yyvsp[(1) - (1)].val)); } + break; + + case 236: + +/* Line 1806 of yacc.c */ +#line 975 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 237: + +/* Line 1806 of yacc.c */ +#line 976 "parser.y" + { (yyval.val) = nil; } + break; + + case 238: + +/* Line 1806 of yacc.c */ +#line 979 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val)->c.cdr; + (yyvsp[(1) - (1)].val)->c.cdr = nil; } + break; + + case 239: + +/* Line 1806 of yacc.c */ +#line 982 "parser.y" + { (yyval.val) = (yyvsp[(1) - (3)].val)->c.cdr; + (yyvsp[(1) - (3)].val)->c.cdr = (yyvsp[(3) - (3)].val); } + break; + + case 240: + +/* Line 1806 of yacc.c */ +#line 986 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); + rlc((yyval.val), (yyvsp[(1) - (1)].val)); + (yyval.val)->c.cdr = (yyval.val); } + break; + + case 241: + +/* Line 1806 of yacc.c */ +#line 989 "parser.y" + { parser->ignore = 1; } + break; + + case 242: + +/* Line 1806 of yacc.c */ +#line 990 "parser.y" + { parser->ignore = 0; + (yyval.val) = cons(nil, nil); + (yyval.val)->c.cdr = (yyval.val); } + break; + + case 243: + +/* Line 1806 of yacc.c */ +#line 993 "parser.y" + { parser->ignore = 1; } + break; + + case 244: + +/* Line 1806 of yacc.c */ +#line 994 "parser.y" + { parser->ignore = 0; + (yyval.val) = (yyvsp[(1) - (4)].val); } + break; + + case 245: + +/* Line 1806 of yacc.c */ +#line 996 "parser.y" + { uses_or2; + (yyval.val) = rlc(cons((yyvsp[(2) - (2)].val), (yyvsp[(1) - (2)].val)->c.cdr), or2((yyvsp[(2) - (2)].val), (yyvsp[(1) - (2)].val)->c.cdr)); + (yyvsp[(1) - (2)].val)->c.cdr = (yyval.val); } + break; + + case 246: + +/* Line 1806 of yacc.c */ +#line 999 "parser.y" + { (yyval.val) = lastcons(rl((yyvsp[(2) - (2)].val), num((yyvsp[(1) - (2)].lineno)))); + (yyval.val)->c.cdr = (yyvsp[(2) - (2)].val); } + break; + + case 247: + +/* Line 1806 of yacc.c */ +#line 1002 "parser.y" + { (yyval.val) = lastcons(rl((yyvsp[(3) - (3)].val), num((yyvsp[(2) - (3)].lineno)))); + (yyval.val)->c.cdr = (yyvsp[(1) - (3)].val)->c.cdr; + (yyvsp[(1) - (3)].val)->c.cdr = (yyvsp[(3) - (3)].val); } + break; + + case 248: + +/* Line 1806 of yacc.c */ +#line 1005 "parser.y" + { (yyval.val) = lastcons(rl((yyvsp[(2) - (2)].val), num((yyvsp[(1) - (2)].lineno)))); + (yyval.val)->c.cdr = (yyvsp[(2) - (2)].val); } + break; + + case 249: + +/* Line 1806 of yacc.c */ +#line 1008 "parser.y" + { (yyval.val) = lastcons(rl((yyvsp[(3) - (3)].val), num((yyvsp[(2) - (3)].lineno)))); + (yyval.val)->c.cdr = (yyvsp[(1) - (3)].val)->c.cdr; + (yyvsp[(1) - (3)].val)->c.cdr = (yyvsp[(3) - (3)].val); } + break; + + case 250: + +/* Line 1806 of yacc.c */ +#line 1013 "parser.y" + { (yyval.val) = ifnign(symhlpr((yyvsp[(1) - (1)].lexeme), t)); } + break; + + case 251: + +/* Line 1806 of yacc.c */ +#line 1014 "parser.y" + { (yyval.val) = cons(var_s, cons((yyvsp[(1) - (1)].val), nil)); + rl((yyval.val), num(parser->lineno)); } + break; + + case 252: + +/* Line 1806 of yacc.c */ +#line 1016 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 253: + +/* Line 1806 of yacc.c */ +#line 1017 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 254: + +/* Line 1806 of yacc.c */ +#line 1018 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 255: + +/* Line 1806 of yacc.c */ +#line 1019 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 256: + +/* Line 1806 of yacc.c */ +#line 1020 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 257: + +/* Line 1806 of yacc.c */ +#line 1021 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 258: + +/* Line 1806 of yacc.c */ +#line 1022 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 259: + +/* Line 1806 of yacc.c */ +#line 1023 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 260: + +/* Line 1806 of yacc.c */ +#line 1024 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 261: + +/* Line 1806 of yacc.c */ +#line 1025 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 262: + +/* Line 1806 of yacc.c */ +#line 1026 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 263: + +/* Line 1806 of yacc.c */ +#line 1027 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 264: + +/* Line 1806 of yacc.c */ +#line 1028 "parser.y" + { (yyval.val) = rl((yyvsp[(2) - (2)].val), num((yyvsp[(1) - (2)].lineno))); } + break; + + case 265: + +/* Line 1806 of yacc.c */ +#line 1029 "parser.y" + { (yyval.val) = rl(cons(quasilist_s, (yyvsp[(2) - (2)].val)), num((yyvsp[(1) - (2)].lineno))); } + break; + + case 266: + +/* Line 1806 of yacc.c */ +#line 1030 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 267: + +/* Line 1806 of yacc.c */ +#line 1031 "parser.y" + { (yyval.val) = rl(rlc(list(quote_s, (yyvsp[(2) - (2)].val), nao), (yyvsp[(2) - (2)].val)), + num(parser->lineno)); } + break; + + case 268: + +/* Line 1806 of yacc.c */ +#line 1033 "parser.y" + { parser->quasi_level++; } + break; + + case 269: + +/* Line 1806 of yacc.c */ +#line 1034 "parser.y" + { parser->quasi_level--; + (yyval.val) = rl(rlc(list(sys_qquote_s, (yyvsp[(3) - (3)].val), nao), (yyvsp[(3) - (3)].val)), + num(parser->lineno)); } + break; + + case 270: + +/* Line 1806 of yacc.c */ +#line 1037 "parser.y" + { parser->quasi_level--; } + break; + + case 271: + +/* Line 1806 of yacc.c */ +#line 1038 "parser.y" + { parser->quasi_level++; + (yyval.val) = rl(rlc(list(sys_unquote_s, (yyvsp[(3) - (3)].val), nao), (yyvsp[(3) - (3)].val)), + num(parser->lineno)); } + break; + + case 272: + +/* Line 1806 of yacc.c */ +#line 1041 "parser.y" + { parser->quasi_level--; } + break; + + case 273: + +/* Line 1806 of yacc.c */ +#line 1042 "parser.y" + { parser->quasi_level++; + (yyval.val) = rl(rlc(list(sys_splice_s, (yyvsp[(3) - (3)].val), nao), (yyvsp[(3) - (3)].val)), + num(parser->lineno)); } + break; + + case 274: + +/* Line 1806 of yacc.c */ +#line 1045 "parser.y" + { parser_circ_def(parser, (yyvsp[(1) - (1)].val), unique_s); } + break; + + case 275: + +/* Line 1806 of yacc.c */ +#line 1046 "parser.y" + { parser_circ_def(parser, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); + (yyval.val) = (yyvsp[(3) - (3)].val); } + break; + + case 276: + +/* Line 1806 of yacc.c */ +#line 1048 "parser.y" + { (yyval.val) = parser_circ_ref(parser, (yyvsp[(1) - (1)].val)); } + break; + + case 277: + +/* Line 1806 of yacc.c */ +#line 1051 "parser.y" + { (yyval.val) = uref_helper(parser, (yyvsp[(2) - (2)].val)); } + break; + + case 278: + +/* Line 1806 of yacc.c */ +#line 1052 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 279: + +/* Line 1806 of yacc.c */ +#line 1054 "parser.y" + { (yyval.val) = ifnign(symhlpr((yyvsp[(1) - (1)].lexeme), t)); } + break; + + case 280: + +/* Line 1806 of yacc.c */ +#line 1055 "parser.y" + { (yyval.val) = cons(var_s, cons((yyvsp[(1) - (1)].val), nil)); + rl((yyval.val), num(parser->lineno)); } + break; + + case 281: + +/* Line 1806 of yacc.c */ +#line 1057 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 282: + +/* Line 1806 of yacc.c */ +#line 1058 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 283: + +/* Line 1806 of yacc.c */ +#line 1059 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 284: + +/* Line 1806 of yacc.c */ +#line 1060 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 285: + +/* Line 1806 of yacc.c */ +#line 1061 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 286: + +/* Line 1806 of yacc.c */ +#line 1062 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 287: + +/* Line 1806 of yacc.c */ +#line 1063 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 288: + +/* Line 1806 of yacc.c */ +#line 1064 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 289: + +/* Line 1806 of yacc.c */ +#line 1065 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 290: + +/* Line 1806 of yacc.c */ +#line 1066 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 291: + +/* Line 1806 of yacc.c */ +#line 1067 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 292: + +/* Line 1806 of yacc.c */ +#line 1068 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 293: + +/* Line 1806 of yacc.c */ +#line 1069 "parser.y" + { (yyval.val) = rl((yyvsp[(2) - (2)].val), num((yyvsp[(1) - (2)].lineno))); } + break; + + case 294: + +/* Line 1806 of yacc.c */ +#line 1070 "parser.y" + { (yyval.val) = rl(cons(quasilist_s, (yyvsp[(2) - (2)].val)), num((yyvsp[(1) - (2)].lineno))); } + break; + + case 295: + +/* Line 1806 of yacc.c */ +#line 1071 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 296: + +/* Line 1806 of yacc.c */ +#line 1072 "parser.y" + { (yyval.val) = rl(rlc(list(quote_s, (yyvsp[(2) - (2)].val), nao), (yyvsp[(2) - (2)].val)), + num(parser->lineno)); } + break; + + case 297: + +/* Line 1806 of yacc.c */ +#line 1074 "parser.y" + { parser->quasi_level++; } + break; + + case 298: + +/* Line 1806 of yacc.c */ +#line 1075 "parser.y" + { parser->quasi_level--; + (yyval.val) = rl(rlc(list(sys_qquote_s, (yyvsp[(3) - (3)].val), nao), (yyvsp[(3) - (3)].val)), + num(parser->lineno)); } + break; + + case 299: + +/* Line 1806 of yacc.c */ +#line 1078 "parser.y" + { parser->quasi_level--; } + break; + + case 300: + +/* Line 1806 of yacc.c */ +#line 1079 "parser.y" + { parser->quasi_level++; + (yyval.val) = rl(rlc(list(sys_unquote_s, (yyvsp[(3) - (3)].val), nao), (yyvsp[(3) - (3)].val)), + num(parser->lineno)); } + break; + + case 301: + +/* Line 1806 of yacc.c */ +#line 1082 "parser.y" + { parser->quasi_level--; } + break; + + case 302: + +/* Line 1806 of yacc.c */ +#line 1083 "parser.y" + { parser->quasi_level++; + (yyval.val) = rl(rlc(list(sys_splice_s, (yyvsp[(3) - (3)].val), nao), (yyvsp[(3) - (3)].val)), + num(parser->lineno)); } + break; + + case 303: + +/* Line 1806 of yacc.c */ +#line 1086 "parser.y" + { uses_or2; + (yyval.val) = rlc(list(rcons_s, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), nao), + or2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val))); } + break; + + case 304: + +/* Line 1806 of yacc.c */ +#line 1090 "parser.y" + { uses_or2; + (yyval.val) = rlc(list(rcons_s, (yyvsp[(1) - (4)].val), + uref_helper(parser, (yyvsp[(4) - (4)].val)), + nao), + or2((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val))); } + break; + + case 305: + +/* Line 1806 of yacc.c */ +#line 1096 "parser.y" + { uses_or2; + (yyval.val) = rlc(list(rcons_s, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), nao), + or2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val))); } + break; + + case 306: + +/* Line 1806 of yacc.c */ +#line 1100 "parser.y" + { uses_or2; + (yyval.val) = rlc(list(rcons_s, (yyvsp[(1) - (4)].val), + uref_helper(parser, (yyvsp[(4) - (4)].val)), + nao), + or2((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val))); } + break; + + case 307: + +/* Line 1806 of yacc.c */ +#line 1105 "parser.y" + { (yyval.val) = qref_helper(parser, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); } + break; + + case 308: + +/* Line 1806 of yacc.c */ +#line 1106 "parser.y" + { (yyval.val) = qref_helper(parser, + cons(t, cons((yyvsp[(1) - (3)].val), nil)), + (yyvsp[(3) - (3)].val)); } + break; + + case 309: + +/* Line 1806 of yacc.c */ +#line 1109 "parser.y" + { (yyval.val) = uref_helper(parser, (yyvsp[(2) - (2)].val)); } + break; + + case 310: + +/* Line 1806 of yacc.c */ +#line 1110 "parser.y" + { (yyval.val) = uoref_helper(parser, (yyvsp[(2) - (2)].val)); } + break; + + case 311: + +/* Line 1806 of yacc.c */ +#line 1111 "parser.y" + { parser_circ_def(parser, (yyvsp[(1) - (1)].val), unique_s); } + break; + + case 312: + +/* Line 1806 of yacc.c */ +#line 1112 "parser.y" + { parser_circ_def(parser, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)); + (yyval.val) = (yyvsp[(3) - (3)].val); } + break; + + case 313: + +/* Line 1806 of yacc.c */ +#line 1114 "parser.y" + { (yyval.val) = parser_circ_ref(parser, (yyvsp[(1) - (1)].val)); } + break; + + case 314: + +/* Line 1806 of yacc.c */ +#line 1117 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 315: + +/* Line 1806 of yacc.c */ +#line 1118 "parser.y" + { (yyval.val) = nil; } + break; + + case 316: + +/* Line 1806 of yacc.c */ +#line 1121 "parser.y" + { (yyval.val) = uref_helper(parser, (yyvsp[(2) - (2)].val)); } + break; + + case 317: + +/* Line 1806 of yacc.c */ +#line 1122 "parser.y" + { (yyval.val) = uoref_helper(parser, (yyvsp[(2) - (2)].val)); } + break; + + case 318: + +/* Line 1806 of yacc.c */ +#line 1123 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 319: + +/* Line 1806 of yacc.c */ +#line 1126 "parser.y" + { (yyval.val) = regex_compile((yyvsp[(2) - (3)].val), nil); + end_of_regex(scnr); + rl((yyval.val), num(parser->lineno)); } + break; + + case 320: + +/* Line 1806 of yacc.c */ +#line 1129 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("regex")); + end_of_regex(scnr); } + break; + + case 321: + +/* Line 1806 of yacc.c */ +#line 1135 "parser.y" + { (yyval.val) = regex_compile((yyvsp[(2) - (3)].val), nil); + end_of_regex(scnr); + rl((yyval.val), num(parser->lineno)); } + break; + + case 322: + +/* Line 1806 of yacc.c */ +#line 1139 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("regex")); + end_of_regex(scnr); } + break; + + case 323: + +/* Line 1806 of yacc.c */ +#line 1144 "parser.y" + { (yyval.val) = if3(cdr((yyvsp[(1) - (1)].val)), + cons(compound_s, (yyvsp[(1) - (1)].val)), + car((yyvsp[(1) - (1)].val))); } + break; + + case 324: + +/* Line 1806 of yacc.c */ +#line 1147 "parser.y" + { (yyval.val) = list(or_s, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), nao); } + break; + + case 325: + +/* Line 1806 of yacc.c */ +#line 1148 "parser.y" + { (yyval.val) = list(and_s, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), nao); } + break; + + case 326: + +/* Line 1806 of yacc.c */ +#line 1149 "parser.y" + { (yyval.val) = list(compl_s, (yyvsp[(2) - (2)].val), nao); } + break; + + case 327: + +/* Line 1806 of yacc.c */ +#line 1150 "parser.y" + { (yyval.val) = nil; } + break; + + case 328: + +/* Line 1806 of yacc.c */ +#line 1153 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); } + break; + + case 329: + +/* Line 1806 of yacc.c */ +#line 1154 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); } + break; + + case 330: + +/* Line 1806 of yacc.c */ +#line 1155 "parser.y" + { (yyval.val) = list((yyvsp[(1) - (3)].val), list(compl_s, (yyvsp[(3) - (3)].val), nao), nao); } + break; + + case 331: + +/* Line 1806 of yacc.c */ +#line 1158 "parser.y" + { (yyval.val) = list(zeroplus_s, (yyvsp[(1) - (2)].val), nao); } + break; + + case 332: + +/* Line 1806 of yacc.c */ +#line 1159 "parser.y" + { (yyval.val) = list(oneplus_s, (yyvsp[(1) - (2)].val), nao); } + break; + + case 333: + +/* Line 1806 of yacc.c */ +#line 1160 "parser.y" + { (yyval.val) = list(optional_s, (yyvsp[(1) - (2)].val), nao); } + break; + + case 334: + +/* Line 1806 of yacc.c */ +#line 1161 "parser.y" + { (yyval.val) = list(nongreedy_s, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), nao); } + break; + + case 335: + +/* Line 1806 of yacc.c */ +#line 1162 "parser.y" + { if (first((yyvsp[(2) - (3)].val)) == chr('^')) + { if (rest((yyvsp[(2) - (3)].val))) + (yyval.val) = cons(cset_s, rest((yyvsp[(2) - (3)].val))); + else + (yyval.val) = wild_s; } + else + (yyval.val) = cons(set_s, (yyvsp[(2) - (3)].val)); } + break; + + case 336: + +/* Line 1806 of yacc.c */ +#line 1169 "parser.y" + { (yyval.val) = cons(set_s, nil); } + break; + + case 337: + +/* Line 1806 of yacc.c */ +#line 1170 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("regex character class")); } + break; + + case 338: + +/* Line 1806 of yacc.c */ +#line 1172 "parser.y" + { (yyval.val) = wild_s; } + break; + + case 339: + +/* Line 1806 of yacc.c */ +#line 1173 "parser.y" + { (yyval.val) = chr(']'); } + break; + + case 340: + +/* Line 1806 of yacc.c */ +#line 1174 "parser.y" + { (yyval.val) = chr('-'); } + break; + + case 341: + +/* Line 1806 of yacc.c */ +#line 1175 "parser.y" + { (yyval.val) = chr((yyvsp[(1) - (1)].chr)); } + break; + + case 342: + +/* Line 1806 of yacc.c */ +#line 1176 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 343: + +/* Line 1806 of yacc.c */ +#line 1177 "parser.y" + { (yyval.val) = (yyvsp[(2) - (3)].val); } + break; + + case 344: + +/* Line 1806 of yacc.c */ +#line 1178 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("regex subexpression")); } + break; + + case 345: + +/* Line 1806 of yacc.c */ +#line 1182 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); } + break; + + case 346: + +/* Line 1806 of yacc.c */ +#line 1183 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); } + break; + + case 347: + +/* Line 1806 of yacc.c */ +#line 1186 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 348: + +/* Line 1806 of yacc.c */ +#line 1187 "parser.y" + { (yyval.val) = chr((yyvsp[(1) - (1)].chr)); } + break; + + case 349: + +/* Line 1806 of yacc.c */ +#line 1188 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 350: + +/* Line 1806 of yacc.c */ +#line 1191 "parser.y" + { (yyval.val) = cons(chr((yyvsp[(1) - (3)].chr)), chr((yyvsp[(3) - (3)].chr))); } + break; + + case 351: + +/* Line 1806 of yacc.c */ +#line 1193 "parser.y" + { (yyval.chr) = '?'; } + break; + + case 352: + +/* Line 1806 of yacc.c */ +#line 1194 "parser.y" + { (yyval.chr) = '.'; } + break; + + case 353: + +/* Line 1806 of yacc.c */ +#line 1195 "parser.y" + { (yyval.chr) = '*'; } + break; + + case 354: + +/* Line 1806 of yacc.c */ +#line 1196 "parser.y" + { (yyval.chr) = '+'; } + break; + + case 355: + +/* Line 1806 of yacc.c */ +#line 1197 "parser.y" + { (yyval.chr) = '('; } + break; + + case 356: + +/* Line 1806 of yacc.c */ +#line 1198 "parser.y" + { (yyval.chr) = ')'; } + break; + + case 357: + +/* Line 1806 of yacc.c */ +#line 1199 "parser.y" + { (yyval.chr) = '|'; } + break; + + case 358: + +/* Line 1806 of yacc.c */ +#line 1200 "parser.y" + { (yyval.chr) = '~'; } + break; + + case 359: + +/* Line 1806 of yacc.c */ +#line 1201 "parser.y" + { (yyval.chr) = '&'; } + break; + + case 360: + +/* Line 1806 of yacc.c */ +#line 1202 "parser.y" + { (yyval.chr) = '%'; } + break; + + case 361: + +/* Line 1806 of yacc.c */ +#line 1203 "parser.y" + { (yyval.chr) = '/'; } + break; + + case 362: + +/* Line 1806 of yacc.c */ +#line 1204 "parser.y" + { (yyval.chr) = (yyvsp[(1) - (1)].chr); } + break; + + case 363: + +/* Line 1806 of yacc.c */ +#line 1207 "parser.y" + { switch ((yyvsp[(1) - (1)].chr)) + { case 's': + (yyval.val) = space_k; break; + case 'S': + (yyval.val) = cspace_k; break; + case 'd': + (yyval.val) = digit_k; break; + case 'D': + (yyval.val) = cdigit_k; break; + case 'w': + (yyval.val) = word_char_k; break; + case 'W': + (yyval.val) = cword_char_k; break; }} + break; + + case 365: + +/* Line 1806 of yacc.c */ +#line 1222 "parser.y" + { yyerr("newline expected after directive"); + yyerrok; } + break; + + case 366: + +/* Line 1806 of yacc.c */ +#line 1226 "parser.y" + { (yyval.val) = null_string; } + break; + + case 367: + +/* Line 1806 of yacc.c */ +#line 1227 "parser.y" + { (yyval.val) = (yyvsp[(2) - (3)].val); + rl((yyval.val), num(parser->lineno)); } + break; + + case 368: + +/* Line 1806 of yacc.c */ +#line 1229 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("string literal")); } + break; + + case 369: + +/* Line 1806 of yacc.c */ +#line 1233 "parser.y" + { wchar_t ch; + val str = string_own((yyvsp[(2) - (2)].lexeme)); + const wchar_t *cstr = c_str(str); + + if (cstr[1] == 0) + { ch = cstr[0]; } + else + { ch = char_from_name(cstr); + if (ch == L'!') + { yyerrorf(scnr, lit("unknown character name: ~a"), + str, nao); }} + end_of_char(scnr); + (yyval.val) = chr(ch); } + break; + + case 370: + +/* Line 1806 of yacc.c */ +#line 1246 "parser.y" + { (yyval.val) = chr((yyvsp[(2) - (2)].chr)); + end_of_char(scnr); } + break; + + case 371: + +/* Line 1806 of yacc.c */ +#line 1248 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, + lit("character literal")); } + break; + + case 372: + +/* Line 1806 of yacc.c */ +#line 1253 "parser.y" + { (yyval.val) = null_string; } + break; + + case 373: + +/* Line 1806 of yacc.c */ +#line 1254 "parser.y" + { (yyval.val) = cons(quasi_s, (yyvsp[(2) - (3)].val)); + rlc((yyval.val), (yyvsp[(2) - (3)].val)); + rl((yyval.val), num(parser->lineno)); } + break; + + case 374: + +/* Line 1806 of yacc.c */ +#line 1257 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("quasistring")); } + break; + + case 375: + +/* Line 1806 of yacc.c */ +#line 1261 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (1)].val), nil); + rl((yyval.val), num(parser->lineno)); } + break; + + case 376: + +/* Line 1806 of yacc.c */ +#line 1263 "parser.y" + { (yyval.val) = cons((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val)); + rl((yyval.val), num(parser->lineno)); } + break; + + case 377: + +/* Line 1806 of yacc.c */ +#line 1267 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 378: + +/* Line 1806 of yacc.c */ +#line 1268 "parser.y" + { (yyval.val) = string_own((yyvsp[(1) - (1)].lexeme)); } + break; + + case 379: + +/* Line 1806 of yacc.c */ +#line 1269 "parser.y" + { (yyval.val) = (yyvsp[(1) - (1)].val); } + break; + + case 380: + +/* Line 1806 of yacc.c */ +#line 1270 "parser.y" + { (yyval.val) = cons(var_s, cons((yyvsp[(1) - (1)].val), nil)); + rl((yyval.val), num(parser->lineno)); } + break; + + case 381: + +/* Line 1806 of yacc.c */ +#line 1272 "parser.y" + { if (integerp((yyvsp[(2) - (2)].val)) || symbolp((yyvsp[(2) - (2)].val))) + (yyval.val) = rlcp_tree(cons(var_s, cons((yyvsp[(2) - (2)].val), nil)), + (yyvsp[(2) - (2)].val)); + else + (yyval.val) = (yyvsp[(2) - (2)].val); } + break; + + case 382: + +/* Line 1806 of yacc.c */ +#line 1279 "parser.y" + { (yyval.val) = mkstring(one, chr((yyvsp[(1) - (1)].chr))); } + break; + + case 383: + +/* Line 1806 of yacc.c */ +#line 1280 "parser.y" + { val ch = mkstring(one, chr((yyvsp[(1) - (2)].chr))); + (yyval.val) = string_extend(ch, (yyvsp[(2) - (2)].val)); } + break; + + case 384: + +/* Line 1806 of yacc.c */ +#line 1284 "parser.y" + { (yyval.val) = mkstring(one, chr((yyvsp[(1) - (1)].chr))); } + break; + + case 385: + +/* Line 1806 of yacc.c */ +#line 1285 "parser.y" + { (yyval.val) = string_extend((yyvsp[(1) - (2)].val), chr((yyvsp[(2) - (2)].chr))); } + break; + + case 386: + +/* Line 1806 of yacc.c */ +#line 1288 "parser.y" + { (yyval.val) = nil; } + break; + + case 387: + +/* Line 1806 of yacc.c */ +#line 1289 "parser.y" + { (yyval.val) = (yyvsp[(2) - (2)].val); } + break; + + case 388: + +/* Line 1806 of yacc.c */ +#line 1290 "parser.y" + { val word = (yyvsp[(1) - (2)].val); + (yyval.val) = rlc(cons(word, (yyvsp[(2) - (2)].val)), (yyvsp[(1) - (2)].val)); } + break; + + case 389: + +/* Line 1806 of yacc.c */ +#line 1292 "parser.y" + { (yyval.val) = nil; + yybadtok(yychar, lit("word list")); } + break; + + case 390: + +/* Line 1806 of yacc.c */ +#line 1296 "parser.y" + { (yyval.val) = nil; } + break; + + case 391: + +/* Line 1806 of yacc.c */ +#line 1297 "parser.y" + { (yyval.val) = (yyvsp[(2) - (2)].val); } + break; + + case 392: + +/* Line 1806 of yacc.c */ +#line 1298 "parser.y" + { val qword = cons(quasi_s, (yyvsp[(1) - (2)].val)); + (yyval.val) = rlc(cons(qword, nil), (yyvsp[(1) - (2)].val)); } + break; + + case 393: + +/* Line 1806 of yacc.c */ +#line 1302 "parser.y" + { val qword = cons(quasi_s, (yyvsp[(1) - (3)].val)); + (yyval.val) = rlc(cons(qword, (yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)); } + break; + + case 394: + +/* Line 1806 of yacc.c */ +#line 1306 "parser.y" + { (yyval.val) = make_buf(zero, nil, nil); + end_of_buflit(scnr); } + break; + + case 395: + +/* Line 1806 of yacc.c */ +#line 1308 "parser.y" + { end_of_buflit(scnr); + buf_trim((yyvsp[(2) - (3)].val)); + (yyval.val) = (yyvsp[(2) - (3)].val); } + break; + + case 396: + +/* Line 1806 of yacc.c */ +#line 1311 "parser.y" + { yyerr("unterminated buffer literal"); + end_of_buflit(scnr); + yyerrok; } + break; + + case 397: + +/* Line 1806 of yacc.c */ +#line 1316 "parser.y" + { buf_put_u8((yyvsp[(1) - (2)].val), length_buf((yyval.val)), (yyvsp[(2) - (2)].val)); + (yyval.val) = (yyvsp[(1) - (2)].val); } + break; + + case 398: + +/* Line 1806 of yacc.c */ +#line 1318 "parser.y" + { (yyval.val) = make_buf(zero, nil, num_fast(512)); + buf_put_u8((yyval.val), zero, (yyvsp[(1) - (1)].val)); } + break; + + case 399: + +/* Line 1806 of yacc.c */ +#line 1322 "parser.y" + { (yyval.val) = num((yyvsp[(1) - (2)].chr) << 4 | (yyvsp[(2) - (2)].chr)); } + break; + + case 400: + +/* Line 1806 of yacc.c */ +#line 1323 "parser.y" + { (yyval.val) = zero; + yyerr("unpaired digit in buffer literal"); + yyerrok; } + break; + + case 401: + +/* Line 1806 of yacc.c */ +#line 1330 "parser.y" + { (yyval.val) = mkexp(all_s, nil, num(parser->lineno)); } + break; + + case 402: + +/* Line 1806 of yacc.c */ +#line 1331 "parser.y" + { (yyval.val) = mkexp(some_s, nil, num(parser->lineno)); } + break; + + case 403: + +/* Line 1806 of yacc.c */ +#line 1332 "parser.y" + { (yyval.val) = mkexp(none_s, nil, num(parser->lineno)); } + break; + + case 404: + +/* Line 1806 of yacc.c */ +#line 1333 "parser.y" + { (yyval.val) = mkexp(maybe_s, nil, num(parser->lineno)); } + break; + + case 405: + +/* Line 1806 of yacc.c */ +#line 1334 "parser.y" + { (yyval.val) = mkexp(cases_s, nil, num(parser->lineno)); } + break; + + case 406: + +/* Line 1806 of yacc.c */ +#line 1335 "parser.y" + { (yyval.val) = mkexp(and_s, nil, num(parser->lineno)); } + break; + + case 407: + +/* Line 1806 of yacc.c */ +#line 1336 "parser.y" + { (yyval.val) = mkexp(or_s, nil, num(parser->lineno)); } + break; + + case 408: + +/* Line 1806 of yacc.c */ +#line 1337 "parser.y" + { (yyval.val) = mkexp(try_s, nil, num(parser->lineno)); } + break; + + case 409: + +/* Line 1806 of yacc.c */ +#line 1338 "parser.y" + { (yyval.val) = mkexp(finally_s, nil, num(parser->lineno)); } + break; + + case 410: + +/* Line 1806 of yacc.c */ +#line 1340 "parser.y" + { (yyval.val) = mkexp(block_s, (yyvsp[(2) - (3)].val), nil); } + break; + + case 411: + +/* Line 1806 of yacc.c */ +#line 1342 "parser.y" + { (yyval.val) = mkexp(choose_s, (yyvsp[(2) - (3)].val), nil); } + break; + + case 412: + +/* Line 1806 of yacc.c */ +#line 1344 "parser.y" + { (yyval.val) = mkexp(collect_s, (yyvsp[(2) - (3)].val), nil); } + break; + + case 413: + +/* Line 1806 of yacc.c */ +#line 1346 "parser.y" + { (yyval.val) = mkexp(coll_s, (yyvsp[(2) - (3)].val), nil); } + break; + + case 414: + +/* Line 1806 of yacc.c */ +#line 1348 "parser.y" + { (yyval.val) = mkexp(gather_s, (yyvsp[(2) - (3)].val), nil); } + break; + + case 415: + +/* Line 1806 of yacc.c */ +#line 1350 "parser.y" + { (yyval.val) = mkexp(define_s, (yyvsp[(2) - (3)].val), nil); } + break; + + case 416: + +/* Line 1806 of yacc.c */ +#line 1352 "parser.y" + { (yyval.val) = mkexp(catch_s, (yyvsp[(2) - (3)].val), nil); } + break; + + case 417: + +/* Line 1806 of yacc.c */ +#line 1354 "parser.y" + { (yyval.val) = mkexp(if_s, + cons((yyvsp[(2) - (5)].val), + cons((yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val))), + nil); } + break; + + case 418: + +/* Line 1806 of yacc.c */ +#line 1359 "parser.y" + { yyerr("@(output) doesn't nest"); } + break; + + + +/* Line 1806 of yacc.c */ +#line 6411 "y.tab.c" + default: break; + } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); + + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (scnr, parser, YY_("syntax error")); +#else +# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ + yyssp, yytoken) + { + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status; + yysyntax_error_status = YYSYNTAX_ERROR; + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == 1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + if (!yymsg) + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = 2; + } + else + { + yysyntax_error_status = YYSYNTAX_ERROR; + yymsgp = yymsg; + } + } + yyerror (scnr, parser, yymsgp); + if (yysyntax_error_status == 2) + goto yyexhaustedlab; + } +# undef YYSYNTAX_ERROR +#endif + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval, scnr, parser); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + yystos[yystate], yyvsp, scnr, parser); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + *++yyvsp = yylval; + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#if !defined(yyoverflow) || YYERROR_VERBOSE +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (scnr, parser, YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval, scnr, parser); + } + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp, scnr, parser); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + /* Make sure YYID is used. */ + return YYID (yyresult); +} + + + +/* Line 2067 of yacc.c */ +#line 1363 "parser.y" + + +const int have_yydebug = YYDEBUG; + +int yylex(YYSTYPE *, yyscan_t scanner); + +void yydebug_onoff(int val) +{ +#if YYDEBUG + yydebug = val; +#else + (void) val; +#endif +} + +static val sym_helper(parser_t *parser, wchar_t *lexeme, val meta_allowed) +{ + scanner_t *scnr = parser->scanner; + int leading_at = *lexeme == L'@'; + wchar_t *tokfree = lexeme; + wchar_t *colon = wcschr(lexeme, L':'); + val sym; + + if (leading_at) { + if (!meta_allowed) { + val tok = string_own(lexeme); + yyerrorf(scnr, lit("~a: meta variable not allowed in this context"), tok, nao); + return nil; + } + lexeme++; + } + + if (colon != 0) + *colon = 0; + + if (colon == lexeme) { + val sym_name = string(colon + 1); + scrub_scanner(parser->scanner, SYMTOK, tokfree); + free(tokfree); + sym = intern(sym_name, keyword_package); + } else if (colon != 0) { + val pkg_name = string(lexeme); + val sym_name = string(colon + 1); + scrub_scanner(parser->scanner, SYMTOK, tokfree); + free(tokfree); + if (equal(pkg_name, lit("#"))) { + sym = make_sym(sym_name); + } else { + val package = find_package(pkg_name); + if (!package) { + yyerrorf(scnr, lit("~a:~a: package ~a not found"), + pkg_name, sym_name, pkg_name, nao); + return nil; + } + sym = intern(sym_name, package); + } + } else { + val sym_name = string(lexeme); + scrub_scanner(parser->scanner, SYMTOK, tokfree); + free(tokfree); + sym = intern_fallback(sym_name, cur_package); + } + + return leading_at ? rl(list(var_s, sym, nao), num(parser->lineno)) : sym; +} + +static val expand_repeat_rep_args(val args) +{ + list_collect_decl (out, ptail); + val exp_pair = nil, exp_pairs = nil; + + for (; args; args = cdr(args)) { + val arg = car(args); + + if (consp(arg)) { + if (exp_pairs) { + list_collect_decl (iout, iptail); + for (; arg; arg = cdr(arg)) { + val iarg = car(arg); + if (consp(iarg)) { + val sym = first(iarg); + iptail = list_collect(iptail, list(sym, + expand(second(iarg), nil), + nao)); + match_reg_var(sym); + } else { + iptail = list_collect(iptail, iarg); + match_reg_var(iarg); + } + } + ptail = list_collect(ptail, iout); + } else if (exp_pair) { + val sym = first(arg); + ptail = list_collect(ptail, list(sym, + expand(second(arg), nil), + nao)); + match_reg_var(sym); + } else { + ptail = list_collect(ptail, arg); + } + } else if (!exp_pair && !exp_pairs) { + if (arg == counter_k) { + exp_pair = t; + ptail = list_collect(ptail, arg); + continue; + } else if (arg == vars_k) { + exp_pairs = t; + ptail = list_collect(ptail, arg); + continue; + } + } else if (exp_pair) { + match_reg_var(arg); + } + + exp_pair = exp_pairs = nil; + ptail = list_collect(ptail, arg); + } + + return out; +} + +static val extract_vars(val output_spec) +{ + list_collect_decl (vars, tai); + + if (consp(output_spec)) { + val sym = first(output_spec); + if (sym == var_s) { + val name = second(output_spec); + val modifiers = third(output_spec); + + if (bindable(name)) + tai = list_collect(tai, name); + else + tai = list_collect_nconc(tai, extract_vars(name)); + + for (; modifiers; modifiers = cdr(modifiers)) { + val mod = car(modifiers); + if (bindable(mod)) { + tai = list_collect(tai, mod); + } else if (consp(mod)) { + val msym = car(mod); + + if (msym == dwim_s) { + val arg = second(mod); + + if (bindable(arg)) { + tai = list_collect(tai, arg); + } else if (consp(arg) && car(arg) == rcons_s) { + val f = second(arg); + val t = third(arg); + if (bindable(f)) + tai = list_collect(tai, f); + if (bindable(t)) + tai = list_collect(tai, t); + } + } + } + } + } else if (sym == expr_s) { + val expr = second(output_spec); + val frefs = expand_with_free_refs(expr, nil, nil); + tai = list_collect_nconc(tai, second(frefs)); + } else { + for (; output_spec; output_spec = cdr(output_spec)) + tai = list_collect_nconc(tai, extract_vars(car(output_spec))); + } + } + + return vars; +} + +static val repeat_rep_helper(val sym, val args, val main, val parts) +{ + uses_or2; + val exp_args = expand_repeat_rep_args(args); + val single_parts = nil, single_parts_p = nil; + val first_parts = nil, first_parts_p = nil; + val last_parts = nil, last_parts_p = nil; + val empty_parts = nil, empty_parts_p = nil; + val mod_parts = nil, mod_parts_p = nil; + val modlast_parts = nil, modlast_parts_p = nil; + val occur_vars = nil; + val iter; + + for (iter = parts; iter != nil; iter = cdr(iter)) { + val part = car(iter); + val sym = car(part); + val clauses = copy_list(cdr(part)); + + if (sym == single_s) { + single_parts = nappend2(single_parts, clauses); + single_parts_p = t; + } else if (sym == first_s) { + first_parts = nappend2(first_parts, clauses); + first_parts_p = t; + } else if (sym == last_s) { + last_parts = nappend2(last_parts, clauses); + last_parts_p = t; + } else if (sym == empty_s) { + empty_parts = nappend2(empty_parts, clauses); + empty_parts_p = t; + } else if (sym == mod_s) { + mod_parts = cons(clauses, mod_parts); + mod_parts_p = t; + } else if (sym == modlast_s) { + modlast_parts = cons(clauses, modlast_parts); + modlast_parts_p = t; + } else { + abort(); + } + } + + single_parts = or2(single_parts, single_parts_p); + first_parts = or2(first_parts, first_parts_p); + last_parts = or2(last_parts, last_parts_p); + empty_parts = or2(empty_parts, empty_parts_p); + mod_parts = or2(nreverse(mod_parts), mod_parts_p); + modlast_parts = or2(nreverse(modlast_parts), modlast_parts_p); + + occur_vars = extract_vars(main); + occur_vars = nappend2(occur_vars, extract_vars(single_parts)); + occur_vars = nappend2(occur_vars, extract_vars(first_parts)); + occur_vars = nappend2(occur_vars, extract_vars(last_parts)); + occur_vars = nappend2(occur_vars, extract_vars(empty_parts)); + occur_vars = nappend2(occur_vars, extract_vars(mod_parts)); + occur_vars = uniq(occur_vars); + + return list(sym, exp_args, main, single_parts, first_parts, + last_parts, empty_parts, nreverse(mod_parts), + nreverse(modlast_parts), occur_vars, nao); +} + +static void process_catch_exprs(val exprs) +{ + val params = second(exprs); + for (; params; params = cdr(params)) { + val param = first(params); + if (consp(param)) + match_reg_var(car(param)); + else + match_reg_var(param); + } +} + +static val define_transform(parser_t *parser, val define_form) +{ + scanner_t *scnr = parser->scanner; + val sym = first(define_form); + val args = second(define_form); + + if (define_form == nil) + return nil; + + assert (sym == define_s); + + if (args == nil) { + yyerr("define requires arguments"); + return define_form; + } + + if (!consp(args) || !listp(cdr(args))) { + yyerr("bad define argument syntax"); + return define_form; + } else { + val name = first(args); + val params = second(args); + + if (!symbolp(name)) { + yyerr("function name must be a symbol"); + return define_form; + } + + if (!proper_list_p(params)) { + yyerr("invalid function parameter list"); + return define_form; + } + + if (!all_satisfy(params, func_n1(symbolp), nil)) + yyerr("function parameters must be symbols"); + } + + return define_form; +} + +static val optimize_text(val text_form) +{ + if (all_satisfy(rest(text_form), func_n1(stringp), nil)) + return cat_str(rest(text_form), lit("")); + return text_form; +} + +static val unquotes_occur(val quoted_form, int level) +{ + uses_or2; + + if (atom(quoted_form)) { + return nil; + } else { + val sym = car(quoted_form); + if (sym == sys_unquote_s || sym == sys_splice_s) + return (level == 0) ? t : unquotes_occur(cdr(quoted_form), level - 1); + if (sym == sys_qquote_s) + return unquotes_occur(cdr(quoted_form), level + 1); + return or2(unquotes_occur(sym, level), + unquotes_occur(cdr(quoted_form), level)); + } +} + +val expand_meta(val form, val menv) +{ + val sym; + + if (atom(form)) + return form; + + menv = default_arg(menv, make_env(nil, nil, nil)); + + if ((sym = car(form)) == quasi_s) { + if (opt_compat && opt_compat <= 128) { + list_collect_decl (out, ptail); + + for (; consp(form); form = cdr(form)) { + val subform = car(form); + if (consp(subform) && car(subform) == expr_s) + ptail = list_collect(ptail, expand_meta(subform, menv)); + else + ptail = list_collect(ptail, subform); + } + + ptail = list_collect_nconc(ptail, form); + + return rlcp(out, form); + } + + return expand(form, nil); + } + + if ((sym = car(form)) == expr_s) { + val exp_x = expand(second(form), menv); + if (!bindable(exp_x)) + return rlcp(cons(sym, cons(exp_x, nil)), form); + return rlcp(cons(var_s, cons(exp_x, nil)), form); + } + + if (sym == var_s) { + val var_x = expand(second(form), menv); + if (!bindable(var_x)) + return rlcp(cons(expr_s, cons(var_x, nil)), form); + return rlcp(cons(var_s, cons(var_x, nil)), form); + } + + { + list_collect_decl (out, ptail); + + for (; consp(form); form = cdr(form)) { + loc nptail = list_collect(ptail, expand_meta(car(form), menv)); + rlcp(deref(ptail), form); + ptail = nptail; + } + + ptail = list_collect_nconc(ptail, form); + + return out; + } +} + +static val rlviable(val form) +{ + switch (type(form)) { + case NIL: + case LIT: + case CHR: + case NUM: + case SYM: + case BGNUM: + case FLNUM: + return nil; + default: + return t; + } +} + +val rlset(val form, val info) +{ + if (rlviable(form)) { + loc place = gethash_l(lit("rlcp"), form_to_ln_hash, form, nulloc); + if (nilp(deref(place))) + set(place, info); + } + return form; +} + +val rlrec(parser_t *parser, val form, val line) +{ + if (parser->rec_source_loc) + rlset(form, cons(line, parser->name)); + return form; +} + +val rlcp_parser(parser_t *parser, val to, val from) +{ + if (parser->rec_source_loc) + rlset(to, source_loc(from)); + return to; +} + +static val rlcp_tree_rec(val to, val from, struct circ_stack *up) +{ + val ret = to; + + while (consp(to)) { + val a = car(to); + struct circ_stack rlcs = { up, a }; + rlcp(to, from); + if (!parser_callgraph_circ_check(up, a)) + break; + rlcp_tree_rec(a, from, &rlcs); + to = cdr(to); + if (!parser_callgraph_circ_check(up, to)) + break; + } + return ret; +} + + +val rlcp_tree(val to, val from) +{ + return rlcp_tree_rec(to, from, 0); +} + +static wchar_t char_from_name(const wchar_t *name) +{ + static struct { + const wchar_t *name; + const wchar_t ch; + } map[] = { + { L"nul", 0 }, + { L"alarm", L'\a' }, + { L"backspace", L'\b' }, + { L"tab", L'\t' }, + { L"linefeed", L'\n' }, + { L"newline", L'\n' }, + { L"vtab", L'\v' }, + { L"page", L'\f' }, + { L"return", L'\r' }, + { L"esc", 27 }, + { L"space", L' ' }, + { L"pnul", 0xDC00 }, + { 0, 0 }, + }; + int i; + + for (i = 0; map[i].name; i++) { + if (wcscmp(map[i].name, name) == 0) + return map[i].ch; + } + + return L'!'; /* code meaning not found */ +} + +static val make_expr(parser_t *parser, val sym, val rest, val lineno) +{ + val expr = cons(sym, rest); + val ret = cons(expr_s, cons(expand(expr, nil), nil)); + + if (rest) { + rlc(expr, rest); + rlc(ret, rest); + } else { + rl(expr, lineno); + rl(ret, lineno); + } + + return ret; +} + +static val check_parse_time_action(val spec_rev) +{ + val line = first(spec_rev); + + if (consp(line)) { + val elem = first(line); + if (consp(elem)) { + val sym = car(elem); + if (sym == include_s) { + return nappend2(nreverse(include(line)), rest(spec_rev)); + } + if (sym == mdo_s) { + eval_intrinsic(cons(progn_s, cdr(elem)), nil); + return nil; + } + if (sym == in_package_s) { + eval_intrinsic(elem, nil); + return nil; + } + } + } + return spec_rev; +} + +static val uref_helper(parser_t *parser, val expr) +{ + if (consp(expr) && car(expr) == qref_s) { + return rplaca(expr, uref_s); + } else { + return rl(rlc(list(uref_s, expr, nao), expr), num(parser->lineno)); + } +} + +static val uoref_helper(parser_t *parser, val expr) +{ + val uref = uref_helper(parser, expr); + rplacd(uref, cons(t, cdr(uref))); + return uref; +} + +static val qref_helper(parser_t *parser, val lexpr, val rexpr) +{ + uses_or2; + + if (consp(rexpr) && car(rexpr) == qref_s) { + rplacd(rexpr, rlc(cons(lexpr, cdr(rexpr)), lexpr)); + return rl(rexpr, num(parser->lineno)); + } else { + return rl(rlc(list(qref_s, lexpr, rexpr, nao), + or2(lexpr, rexpr)), + num(parser->lineno)); + } +} + +static val fname_helper(parser_t *parser, val name) +{ + if (!name) { + return nil; + } else if (!bindable(name)) { + yyerrorf(parser->scanner, lit("#T: ~s isn't a function name"), + name, nao); + } else if (!memq(name, tree_fun_whitelist)) { + yyerrorf(parser->scanner, lit("#T: ~s not in *tree-fun-whitelist*"), + name, nao); + } else { + val fbinding = lookup_fun(nil, name); + if (fbinding) + return cdr(fbinding); + yyerrorf(parser->scanner, lit("#T: function named ~s doesn't exist"), + name, nao); + } + + return nil; +} + +#ifndef YYEOF +#define YYEOF 0 +#endif + +void yybadtoken(parser_t *parser, int tok, val context) +{ + val problem = nil; + scanner_t *scnr = parser->scanner; + + switch (tok) { + case ERRTOK: + return; + case SPACE: problem = lit("space"); break; + case TEXT: problem = lit("text"); break; + case SYMTOK: problem = lit("symbol-token"); break; + case METANUM: problem = lit("metanum"); break; + case ALL: problem = lit("\"all\""); break; + case SOME: problem = lit("\"some\""); break; + case NONE: problem = lit("\"none\""); break; + case MAYBE: problem = lit("\"maybe\""); break; + case CASES: problem = lit("\"cases\""); break; + case BLOCK: problem = lit("\"block\""); break; + case CHOOSE: problem = lit("\"choose\""); break; + case GATHER: problem = lit("\"gather\""); break; + case AND: problem = lit("\"and\""); break; + case OR: problem = lit("\"or\""); break; + case END: problem = lit("\"end\""); break; + case COLLECT: problem = lit("\"collect\""); break; + case UNTIL: problem = lit("\"until\""); break; + case COLL: problem = lit("\"coll\""); break; + case OUTPUT: problem = lit("\"output\""); break; + case REPEAT: problem = lit("\"repeat\""); break; + case REP: problem = lit("\"rep\""); break; + case SINGLE: problem = lit("\"single\""); break; + case FIRST: problem = lit("\"first\""); break; + case LAST: problem = lit("\"last\""); break; + case EMPTY: problem = lit("\"empty\""); break; + case MOD: problem = lit("\"mod\""); break; + case MODLAST: problem = lit("\"modlast\""); break; + case DEFINE: problem = lit("\"define\""); break; + case TRY: problem = lit("\"try\""); break; + case CATCH: problem = lit("\"catch\""); break; + case FINALLY: problem = lit("\"finally\""); break; + case IF: problem = lit("\"if\""); break; + case ELIF: problem = lit("\"elif\""); break; + case ELSE: problem = lit("\"else\""); break; + case NUMBER: problem = lit("number"); break; + case REGCHAR: problem = lit("regular expression character"); break; + case REGTOKEN: problem = lit("regular expression token"); break; + case LITCHAR: problem = lit("string literal character"); break; + case SPLICE: problem = lit("*"); break; + case CONSDOT: + case LAMBDOT: problem = lit("consing dot"); break; + case DOTDOT: problem = lit(".."); break; + case OLD_DOTDOT: problem = lit(".."); break; + case UREFDOT: problem = lit("referencing dot"); break; + case OREFDOT: + case UOREFDOT: problem = lit("referencing .?"); break; + case HASH_BACKSLASH: problem = lit("#\\"); break; + case HASH_SLASH: problem = lit("#/"); break; + case HASH_H: problem = lit("#H"); break; + case HASH_S: problem = lit("#S"); break; + case HASH_R: problem = lit("#R"); break; + case HASH_N: problem = lit("#N"); break; + case HASH_T: problem = lit("#T"); break; + case HASH_SEMI: problem = lit("#;"); break; + case HASH_N_EQUALS: problem = lit("#<n>="); break; + case HASH_N_HASH: problem = lit("#<n>#"); break; + case HASH_B_QUOTE: problem = lit("#b'"); break; + case WORDS: problem = lit("#\""); break; + case WSPLICE: problem = lit("#*\""); break; + case QWORDS: problem = lit("#`"); break; + case QWSPLICE: problem = lit("#*`"); break; + } + + if (problem != 0) + if (context) + yyerrorf(scnr, lit("misplaced ~a in ~a"), problem, context, nao); + else + yyerrorf(scnr, lit("unexpected ~a"), problem, nao); + else + if (context) /* Byacc sets yychar to 0 */ + if (tok == YYEOF || tok == YYEMPTY) + yyerrorf(scnr, lit("unterminated ~a"), context, nao); + else if (tok == '\n') + yyerrorf(scnr, lit("newline in ~a"), context, nao); + else + yyerrorf(scnr, lit("misplaced character ~a in ~a"), chr(tok), context, nao); + else + if (tok == YYEOF) + yyerrorf(scnr, lit("unexpected end of input"), nao); + else if (tok == YYEMPTY) + return; + else + yyerrorf(scnr, lit("unexpected character ~a"), chr(tok), nao); +} + +int parse_once(val self, val stream, val name) +{ + int res = 0; +#if CONFIG_DEBUG_SUPPORT + unsigned dbg_state = debug_clear(opt_dbg_expansion ? 0 : DBG_ENABLE); +#endif + val parser_obj = ensure_parser(stream, name); + parser_t *parser = parser_get_impl(self, parser_obj); + parser->rec_source_loc = 1; + + uw_catch_begin(cons(error_s, nil), esym, eobj); + + + res = yyparse(parser->scanner, parser); + + parser_resolve_circ(parser); + + uw_catch(esym, eobj) { + yyerrorf(parser->scanner, lit("error exception during parse"), nao); + uw_throw(esym, eobj); + } + + uw_unwind { +#if CONFIG_DEBUG_SUPPORT + debug_set(dbg_state); +#endif + } + + uw_catch_end; + + return res; +} + +int parse(parser_t *parser, val name, enum prime_parser prim) +{ + int res = 0; + cnum start_line = parser->lineno; + + parser->errors = 0; + parser->eof = 0; + parser->ignore = 0; + parser->prepared_msg = nil; + parser->circ_ref_hash = nil; + parser->circ_count = 0; + parser->syntax_tree = nil; + parser->quasi_level = 0; + + prime_parser(parser, name, prim); + + uw_catch_begin(cons(error_s, nil), esym, eobj); + + res = yyparse(parser->scanner, parser); + + prime_parser_post(parser, prim); + + parser_resolve_circ(parser); + + uw_catch(esym, eobj) { + yyerrorf(parser->scanner, lit("error exception during parse"), nao); + uw_throw(esym, eobj); + } + + uw_unwind; + + uw_catch_end; + + if (parser->errors && parser->syntax_tree == nil && + parser->lineno != start_line) + { + yyerrorf(parser->scanner, lit("while parsing form starting at line ~a"), + num(start_line), nao); + } + + return res; +} + |