mirror of
https://github.com/mruby/mruby
synced 2026-06-08 16:11:16 +00:00
Yukihiro "Matz" Matsumoto
3fd59d336e
Convert NODE_LVAR and NODE_ARG from cons-list to variable-sized nodes. Remove new_lvar wrapper and use new_xvar directly. Update parser semantic functions and cleanup gen_assignment. Rename codegen_lvar to gen_lvar for consistency. Co-authored-by: Claude <noreply@anthropic.com>
15609 lines
604 KiB
C
15609 lines
604 KiB
C
/* A Bison parser, made by Lrama 0.7.0. */
|
|
|
|
/* Bison implementation for Yacc-like parsers in C
|
|
|
|
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 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 <https://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. */
|
|
|
|
/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
|
|
especially those whose name start with YY_ or yy_. They are
|
|
private implementation details that can be changed or removed. */
|
|
|
|
/* 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, and Bison version. */
|
|
#define YYBISON 30802
|
|
|
|
/* Bison version string. */
|
|
#define YYBISON_VERSION "3.8.2"
|
|
|
|
/* Skeleton name. */
|
|
#define YYSKELETON_NAME "yacc.c"
|
|
|
|
/* Pure parsers. */
|
|
#define YYPURE 1
|
|
|
|
/* Push parsers. */
|
|
#define YYPUSH 0
|
|
|
|
/* Pull parsers. */
|
|
#define YYPULL 1
|
|
|
|
|
|
/* First part of user prologue. */
|
|
#line 7 "mrbgems/mruby-compiler/core/parse.y"
|
|
|
|
#undef PARSER_DEBUG
|
|
#ifdef PARSER_DEBUG
|
|
# define YYDEBUG 1
|
|
#endif
|
|
#define YYSTACK_USE_ALLOCA 1
|
|
|
|
#include <ctype.h>
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <mruby.h>
|
|
#include <mruby/compile.h>
|
|
#include <mruby/proc.h>
|
|
#include <mruby/error.h>
|
|
#include <mruby/throw.h>
|
|
#include <mruby/string.h>
|
|
#include <mruby/dump.h>
|
|
#include <mruby/internal.h>
|
|
#include <mruby/presym.h>
|
|
#include "node.h"
|
|
|
|
#define YYLEX_PARAM p
|
|
|
|
#define mrbc_malloc(s) mrb_basic_alloc_func(NULL,(s))
|
|
#define mrbc_realloc(p,s) mrb_basic_alloc_func((p),(s))
|
|
#define mrbc_free(p) mrb_basic_alloc_func((p),0)
|
|
|
|
typedef mrb_ast_node node;
|
|
typedef struct mrb_parser_state parser_state;
|
|
typedef struct mrb_parser_heredoc_info parser_heredoc_info;
|
|
|
|
static int yyparse(parser_state *p);
|
|
static int yylex(void *lval, void *lp, parser_state *p);
|
|
static void yyerror(void *lp, parser_state *p, const char *s);
|
|
static void yywarning(parser_state *p, const char *s);
|
|
static void backref_error(parser_state *p, node *n);
|
|
static void void_expr_error(parser_state *p, node *n);
|
|
static void tokadd(parser_state *p, int32_t c);
|
|
static const char* tok(parser_state *p);
|
|
static int toklen(parser_state *p);
|
|
|
|
/* Forward declarations for variable-sized simple node functions */
|
|
|
|
/* Forward declarations for variable-sized advanced node functions */
|
|
|
|
/* Helper function to check node type for both traditional and variable-sized nodes */
|
|
static mrb_bool node_type_p(node *n, enum node_type type);
|
|
|
|
#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
|
|
|
|
typedef unsigned int stack_type;
|
|
|
|
#define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
|
|
#define BITSTACK_POP(stack) ((stack) = (stack) >> 1)
|
|
#define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
|
|
#define BITSTACK_SET_P(stack) ((stack)&1)
|
|
|
|
#define COND_PUSH(n) BITSTACK_PUSH(p->cond_stack, (n))
|
|
#define COND_POP() BITSTACK_POP(p->cond_stack)
|
|
#define COND_LEXPOP() BITSTACK_LEXPOP(p->cond_stack)
|
|
#define COND_P() BITSTACK_SET_P(p->cond_stack)
|
|
|
|
#define CMDARG_PUSH(n) BITSTACK_PUSH(p->cmdarg_stack, (n))
|
|
#define CMDARG_POP() BITSTACK_POP(p->cmdarg_stack)
|
|
#define CMDARG_LEXPOP() BITSTACK_LEXPOP(p->cmdarg_stack)
|
|
#define CMDARG_P() BITSTACK_SET_P(p->cmdarg_stack)
|
|
|
|
#define SET_LINENO(c,n) (head(c)->lineno = (n))
|
|
|
|
#define NUM_SUFFIX_R (1<<0)
|
|
#define NUM_SUFFIX_I (1<<1)
|
|
|
|
static inline mrb_sym
|
|
intern_cstr_gen(parser_state *p, const char *s)
|
|
{
|
|
return mrb_intern_cstr(p->mrb, s);
|
|
}
|
|
#define intern_cstr(s) intern_cstr_gen(p,(s))
|
|
|
|
static inline mrb_sym
|
|
intern_gen(parser_state *p, const char *s, size_t len)
|
|
{
|
|
return mrb_intern(p->mrb, s, len);
|
|
}
|
|
#define intern(s,len) intern_gen(p,(s),(len))
|
|
|
|
#define intern_op(op) MRB_OPSYM_2(p->mrb, op)
|
|
|
|
static mrb_sym
|
|
intern_numparam_gen(parser_state *p, int num)
|
|
{
|
|
char buf[3];
|
|
buf[0] = '_'; buf[1] = '0'+num; buf[2] = '\0';
|
|
return intern(buf, 2);
|
|
}
|
|
#define intern_numparam(n) intern_numparam_gen(p,(n))
|
|
|
|
static void
|
|
cons_free_gen(parser_state *p, node *cons)
|
|
{
|
|
cons->cdr = p->cells;
|
|
p->cells = cons;
|
|
}
|
|
#define cons_free(c) cons_free_gen(p, (c))
|
|
|
|
static void*
|
|
parser_palloc(parser_state *p, size_t size)
|
|
{
|
|
void *m = mempool_alloc(p->pool, size);
|
|
|
|
if (!m) {
|
|
MRB_THROW(p->mrb->jmp);
|
|
}
|
|
return m;
|
|
}
|
|
|
|
#define parser_pfree(ptr) do { if (sizeof(node) <= sizeof(*(ptr))) cons_free((node*)ptr);} while (0)
|
|
|
|
static node*
|
|
cons_gen(parser_state *p, node *car, node *cdr)
|
|
{
|
|
struct mrb_ast_node *c;
|
|
|
|
/* Try to reuse from free list first - only for 16-byte nodes */
|
|
if (p->cells) {
|
|
c = (struct mrb_ast_node*)p->cells;
|
|
p->cells = p->cells->cdr;
|
|
}
|
|
else {
|
|
c = (struct mrb_ast_node*)parser_palloc(p, sizeof(struct mrb_ast_node));
|
|
}
|
|
c->car = car;
|
|
c->cdr = cdr;
|
|
/* Don't initialize location fields for structure nodes - saves CPU */
|
|
return (node*)c;
|
|
}
|
|
|
|
static node*
|
|
cons_head_gen(parser_state *p, node *car, node *cdr)
|
|
{
|
|
struct mrb_ast_head_node *c;
|
|
|
|
/* Always allocate new nodes for head nodes - they're 24 bytes */
|
|
c = (struct mrb_ast_head_node*)parser_palloc(p, sizeof(struct mrb_ast_head_node));
|
|
|
|
c->car = car;
|
|
c->cdr = cdr;
|
|
c->lineno = p->lineno;
|
|
c->filename_index = p->current_filename_index;
|
|
/* beginning of next partial file; need to point the previous file */
|
|
if (p->lineno == 0 && p->current_filename_index > 0) {
|
|
c->filename_index--;
|
|
}
|
|
return (node*)c;
|
|
}
|
|
/* Head-only location optimization: separate functions for head vs structure nodes */
|
|
#define cons(a,b) cons_gen(p,(a),(b)) /* Structure nodes - no location */
|
|
#define cons_head(a,b) cons_head_gen(p,(a),(b)) /* Head nodes - with location */
|
|
|
|
/* Variable-sized node infrastructure - Phase 1 */
|
|
|
|
/* Calculate size class for given byte size */
|
|
static inline enum mrb_ast_size_class
|
|
size_to_class(size_t size)
|
|
{
|
|
static const size_t limits[] = SIZE_CLASS_LIMITS;
|
|
for (int i = 0; i < SIZE_CLASS_COUNT; i++) {
|
|
if (size <= limits[i]) return (enum mrb_ast_size_class)i;
|
|
}
|
|
return SIZE_CLASS_XLARGE;
|
|
}
|
|
|
|
/* Get maximum size for a size class */
|
|
static inline size_t
|
|
size_class_limit(enum mrb_ast_size_class class)
|
|
{
|
|
static const size_t limits[] = SIZE_CLASS_LIMITS;
|
|
return (class < SIZE_CLASS_COUNT) ? limits[class] : 512;
|
|
}
|
|
|
|
/* Allocate variable-sized node with size class management */
|
|
static void*
|
|
parser_alloc_var(parser_state *p, size_t size, enum mrb_ast_size_class class)
|
|
{
|
|
/* Try to reuse from appropriate size class free list */
|
|
if (p->var_free_lists[class] && size <= size_class_limit(class)) {
|
|
struct mrb_ast_node *ptr = p->var_free_lists[class];
|
|
p->var_free_lists[class] = ptr->cdr;
|
|
p->var_alloc_counts[class]++;
|
|
return ptr;
|
|
}
|
|
|
|
/* Allocate new memory */
|
|
void *ptr = parser_palloc(p, size);
|
|
p->var_total_allocated += size;
|
|
p->var_alloc_counts[class]++;
|
|
return ptr;
|
|
}
|
|
|
|
/* Free variable-sized node to appropriate size class list */
|
|
/*
|
|
static void
|
|
parser_free_var(parser_state *p, void *ptr, enum mrb_ast_size_class class)
|
|
{
|
|
if (!ptr) return;
|
|
|
|
struct mrb_ast_node *node = (struct mrb_ast_node*)ptr;
|
|
node->cdr = p->var_free_lists[class];
|
|
p->var_free_lists[class] = node;
|
|
}
|
|
*/
|
|
|
|
/* Initialize variable node header */
|
|
static void
|
|
init_var_header(struct mrb_ast_var_header *header, parser_state *p,
|
|
enum node_type type, enum mrb_ast_size_class class)
|
|
{
|
|
header->lineno = p->lineno;
|
|
header->filename_index = p->current_filename_index;
|
|
header->node_type = (uint8_t)type;
|
|
header->size_class = (uint8_t)class;
|
|
header->flags = 0;
|
|
|
|
/* Handle file boundary edge case */
|
|
if (p->lineno == 0 && p->current_filename_index > 0) {
|
|
header->filename_index--;
|
|
}
|
|
}
|
|
|
|
static node*
|
|
list1_gen(parser_state *p, node *a)
|
|
{
|
|
return cons_head(a, 0);
|
|
}
|
|
#define list1(a) list1_gen(p, (a))
|
|
|
|
static node*
|
|
list2_gen(parser_state *p, node *a, node *b)
|
|
{
|
|
return cons_head(a, cons(b, 0));
|
|
}
|
|
#define list2(a,b) list2_gen(p, (a),(b))
|
|
|
|
static node*
|
|
list3_gen(parser_state *p, node *a, node *b, node *c)
|
|
{
|
|
return cons_head(a, cons(b, cons(c, 0)));
|
|
}
|
|
#define list3(a,b,c) list3_gen(p, (a),(b),(c))
|
|
|
|
static node*
|
|
list4_gen(parser_state *p, node *a, node *b, node *c, node *d)
|
|
{
|
|
return cons_head(a, cons(b, cons(c, cons(d, 0))));
|
|
}
|
|
#define list4(a,b,c,d) list4_gen(p, (a),(b),(c),(d))
|
|
|
|
static node*
|
|
list5_gen(parser_state *p, node *a, node *b, node *c, node *d, node *e)
|
|
{
|
|
return cons_head(a, cons(b, cons(c, cons(d, cons(e, 0)))));
|
|
}
|
|
#define list5(a,b,c,d,e) list5_gen(p, (a),(b),(c),(d),(e))
|
|
|
|
static node*
|
|
list6_gen(parser_state *p, node *a, node *b, node *c, node *d, node *e, node *f)
|
|
{
|
|
return cons_head(a, cons(b, cons(c, cons(d, cons(e, cons(f, 0))))));
|
|
}
|
|
#define list6(a,b,c,d,e,f) list6_gen(p, (a),(b),(c),(d),(e),(f))
|
|
|
|
static node*
|
|
append_gen(parser_state *p, node *a, node *b)
|
|
{
|
|
node *c = a;
|
|
|
|
if (!a) return b;
|
|
if (!b) return a;
|
|
while (c->cdr) {
|
|
c = c->cdr;
|
|
}
|
|
c->cdr = b;
|
|
return a;
|
|
}
|
|
#define append(a,b) append_gen(p,(a),(b))
|
|
#define push(a,b) append_gen(p,(a),list1(b))
|
|
|
|
static char*
|
|
parser_strndup(parser_state *p, const char *s, size_t len)
|
|
{
|
|
char *b = (char*)parser_palloc(p, len+1);
|
|
|
|
memcpy(b, s, len);
|
|
b[len] = '\0';
|
|
return b;
|
|
}
|
|
#undef strndup
|
|
#define strndup(s,len) parser_strndup(p, s, len)
|
|
|
|
static char*
|
|
parser_strdup(parser_state *p, const char *s)
|
|
{
|
|
return parser_strndup(p, s, strlen(s));
|
|
}
|
|
#undef strdup
|
|
#define strdup(s) parser_strdup(p, s)
|
|
|
|
static void
|
|
dump_int(uint16_t i, char *s)
|
|
{
|
|
char *p = s;
|
|
char *t = s;
|
|
|
|
while (i > 0) {
|
|
*p++ = (i % 10)+'0';
|
|
i /= 10;
|
|
}
|
|
if (p == s) *p++ = '0';
|
|
*p = 0;
|
|
p--; /* point the last char */
|
|
while (t < p) {
|
|
char c = *t;
|
|
*t++ = *p;
|
|
*p-- = c;
|
|
}
|
|
}
|
|
|
|
/* xxx ----------------------------- */
|
|
|
|
static node*
|
|
local_switch(parser_state *p)
|
|
{
|
|
node *prev = p->locals;
|
|
|
|
p->locals = cons(0, 0);
|
|
return prev;
|
|
}
|
|
|
|
static void
|
|
local_resume(parser_state *p, node *prev)
|
|
{
|
|
p->locals = prev;
|
|
}
|
|
|
|
static void
|
|
local_nest(parser_state *p)
|
|
{
|
|
p->locals = cons(0, p->locals);
|
|
}
|
|
|
|
static void
|
|
local_unnest(parser_state *p)
|
|
{
|
|
if (p->locals) {
|
|
p->locals = p->locals->cdr;
|
|
}
|
|
}
|
|
|
|
static mrb_bool
|
|
local_var_p(parser_state *p, mrb_sym sym)
|
|
{
|
|
const struct RProc *u;
|
|
node *l = p->locals;
|
|
|
|
while (l) {
|
|
node *n = l->car;
|
|
while (n) {
|
|
if (node_to_sym(n->car) == sym) return TRUE;
|
|
n = n->cdr;
|
|
}
|
|
l = l->cdr;
|
|
}
|
|
|
|
u = p->upper;
|
|
while (u && !MRB_PROC_CFUNC_P(u)) {
|
|
const struct mrb_irep *ir = u->body.irep;
|
|
const mrb_sym *v = ir->lv;
|
|
int i;
|
|
|
|
if (v) {
|
|
for (i=0; i+1 < ir->nlocals; i++) {
|
|
if (v[i] == sym) return TRUE;
|
|
}
|
|
}
|
|
if (MRB_PROC_SCOPE_P(u)) break;
|
|
u = u->upper;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
local_add_f(parser_state *p, mrb_sym sym)
|
|
{
|
|
if (p->locals) {
|
|
node *n = p->locals->car;
|
|
while (n) {
|
|
if (node_to_sym(n->car) == sym) {
|
|
mrb_int len;
|
|
const char* name = mrb_sym_name_len(p->mrb, sym, &len);
|
|
if (len > 0 && name[0] != '_') {
|
|
yyerror(NULL, p, "duplicated argument name");
|
|
return;
|
|
}
|
|
}
|
|
n = n->cdr;
|
|
}
|
|
p->locals->car = push(p->locals->car, sym_to_node(sym));
|
|
}
|
|
}
|
|
|
|
static void
|
|
local_add(parser_state *p, mrb_sym sym)
|
|
{
|
|
if (!local_var_p(p, sym)) {
|
|
local_add_f(p, sym);
|
|
}
|
|
}
|
|
|
|
/* allocate register for block */
|
|
#define local_add_blk(p) local_add_f(p, 0)
|
|
|
|
static void
|
|
local_add_kw(parser_state *p, mrb_sym kwd)
|
|
{
|
|
/* allocate register for keywords hash */
|
|
local_add_f(p, kwd ? kwd : intern_op(pow));
|
|
}
|
|
|
|
static node*
|
|
locals_node(parser_state *p)
|
|
{
|
|
return p->locals ? p->locals->car : NULL;
|
|
}
|
|
|
|
/* Helper function to check node type for both traditional and variable-sized nodes */
|
|
static mrb_bool
|
|
node_type_p(node *n, enum node_type type)
|
|
{
|
|
if (!n) return FALSE;
|
|
|
|
/* Check traditional cons-list nodes */
|
|
if (node_to_int(n->car) == type) return TRUE;
|
|
|
|
/* Check variable-sized nodes */
|
|
if (n->car == (node*)NODE_VARIABLE && VAR_NODE_TYPE(n->cdr) == type) return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
nvars_nest(parser_state *p)
|
|
{
|
|
p->nvars = cons(int_to_node(0), p->nvars);
|
|
}
|
|
|
|
static void
|
|
nvars_block(parser_state *p)
|
|
{
|
|
p->nvars = cons(int_to_node(-2), p->nvars);
|
|
}
|
|
|
|
static void
|
|
nvars_unnest(parser_state *p)
|
|
{
|
|
p->nvars = p->nvars->cdr;
|
|
}
|
|
|
|
/* (:scope (vars..) (prog...)) */
|
|
static node*
|
|
new_scope(parser_state *p, node *body)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_scope_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_scope_node *scope_node = (struct mrb_ast_scope_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&scope_node->hdr, p, NODE_SCOPE, class);
|
|
scope_node->locals = locals_node(p);
|
|
scope_node->body = body;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)scope_node);
|
|
}
|
|
|
|
/* (:begin prog...) */
|
|
static node*
|
|
new_stmts(parser_state *p, node *body)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_stmts_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_stmts_node *n = (struct mrb_ast_stmts_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_STMTS, class);
|
|
n->stmts = body ? list1(body) : 0; /* Wrap single statement in cons-list */
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:begin body) - Always use variable-sized nodes */
|
|
static node*
|
|
new_begin(parser_state *p, node *body)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_begin_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_begin_node *begin_node = (struct mrb_ast_begin_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&begin_node->hdr, p, NODE_BEGIN, class);
|
|
begin_node->body = body;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)begin_node);
|
|
}
|
|
|
|
#define newline_node(n) (n)
|
|
|
|
/* (:rescue body rescue else) - Always use variable-sized nodes */
|
|
static node*
|
|
new_rescue(parser_state *p, node *body, node *resq, node *els)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_rescue_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_rescue_node *n = (struct mrb_ast_rescue_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_RESCUE, class);
|
|
n->body = body;
|
|
n->rescue_clauses = resq;
|
|
n->else_clause = els;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
static node*
|
|
new_mod_rescue(parser_state *p, node *body, node *resq)
|
|
{
|
|
return new_rescue(p, body, list1(list3(0, 0, resq)), 0);
|
|
}
|
|
|
|
/* (:ensure body ensure) - Always use variable-sized nodes */
|
|
static node*
|
|
new_ensure(parser_state *p, node *a, node *b)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_ensure_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_ensure_node *ensure_node = (struct mrb_ast_ensure_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&ensure_node->hdr, p, NODE_ENSURE, class);
|
|
ensure_node->body = a;
|
|
ensure_node->ensure_clause = b;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)ensure_node);
|
|
}
|
|
|
|
/* (:nil) */
|
|
static node*
|
|
new_nil(parser_state *p)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_nil_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_nil_node *n = (struct mrb_ast_nil_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_NIL, class);
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:true) */
|
|
static node*
|
|
new_true(parser_state *p)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_true_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_true_node *n = (struct mrb_ast_true_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_TRUE, class);
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:false) */
|
|
static node*
|
|
new_false(parser_state *p)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_false_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_false_node *n = (struct mrb_ast_false_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_FALSE, class);
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:alias new old) */
|
|
static node*
|
|
new_alias(parser_state *p, mrb_sym a, mrb_sym b)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_alias_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_alias_node *alias_node = (struct mrb_ast_alias_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&alias_node->hdr, p, NODE_ALIAS, class);
|
|
alias_node->new_name = a;
|
|
alias_node->old_name = b;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)alias_node);
|
|
}
|
|
|
|
/* Forward declarations for variable-sized AST node creation functions */
|
|
static node* new_def_var(parser_state *p, mrb_sym name, node *args, node *body);
|
|
|
|
/* (:if cond then else) */
|
|
static node*
|
|
new_if(parser_state *p, node *condition, node *then_body, node *else_body)
|
|
{
|
|
void_expr_error(p, condition);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_if_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_if_node *n;
|
|
|
|
n = (struct mrb_ast_if_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->header, p, NODE_IF, class);
|
|
n->condition = condition;
|
|
n->then_body = then_body;
|
|
n->else_body = else_body;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:while cond body) */
|
|
static node*
|
|
new_while(parser_state *p, node *condition, node *body)
|
|
{
|
|
void_expr_error(p, condition);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_while_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_while_node *n;
|
|
|
|
n = (struct mrb_ast_while_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->header, p, NODE_WHILE, class);
|
|
n->condition = condition;
|
|
n->body = body;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:until cond body) */
|
|
static node*
|
|
new_until(parser_state *p, node *condition, node *body)
|
|
{
|
|
void_expr_error(p, condition);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_until_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_until_node *n;
|
|
|
|
n = (struct mrb_ast_until_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->header, p, NODE_UNTIL, class);
|
|
n->condition = condition;
|
|
n->body = body;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:while_mod cond body) */
|
|
static node*
|
|
new_while_mod(parser_state *p, node *condition, node *body)
|
|
{
|
|
node *while_node = new_while(p, condition, body);
|
|
struct mrb_ast_while_node *n = (struct mrb_ast_while_node*)NODE_VAR_NODE_PTR(while_node);
|
|
n->header.node_type = NODE_WHILE_MOD;
|
|
return while_node;
|
|
}
|
|
|
|
/* (:until_mod cond body) */
|
|
static node*
|
|
new_until_mod(parser_state *p, node *a, node *b)
|
|
{
|
|
node *until_node = new_until(p, a, b);
|
|
struct mrb_ast_until_node *n = (struct mrb_ast_until_node*)NODE_VAR_NODE_PTR(until_node);
|
|
n->header.node_type = NODE_UNTIL_MOD;
|
|
return until_node;
|
|
}
|
|
|
|
/* (:for var obj body) */
|
|
static node*
|
|
new_for(parser_state *p, node *v, node *o, node *b)
|
|
{
|
|
void_expr_error(p, o);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_for_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_for_node *n = (struct mrb_ast_for_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_FOR, class);
|
|
n->var = v;
|
|
n->iterable = o;
|
|
n->body = b;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:case a ((when ...) body) ((when...) body)) */
|
|
static node*
|
|
new_case(parser_state *p, node *a, node *b)
|
|
{
|
|
uint16_t when_count = 0;
|
|
node *else_body = NULL;
|
|
node *current_when = b;
|
|
|
|
void_expr_error(p, a);
|
|
|
|
// First pass: count when clauses and identify else_body
|
|
// The when_list is a linked list where each element's car is a (condition . body) cons node.
|
|
// The last element's car might be 0, and its cdr is the else_body.
|
|
while (current_when) {
|
|
node *clause = current_when->car;
|
|
if (clause && node_to_int(clause->car) == 0) { // This is the else clause
|
|
else_body = clause->cdr;
|
|
break; // Else body is always the last
|
|
}
|
|
when_count++;
|
|
current_when = current_when->cdr;
|
|
}
|
|
|
|
size_t base_size = sizeof(struct mrb_ast_case_node);
|
|
size_t when_clauses_size = when_count * sizeof(struct mrb_ast_node*);
|
|
size_t total_size = base_size + when_clauses_size;
|
|
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_case_node *n = (struct mrb_ast_case_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_CASE, class);
|
|
n->value = a;
|
|
n->when_count = when_count;
|
|
n->else_body = else_body;
|
|
|
|
// Second pass: copy when clauses into flexible array
|
|
current_when = b;
|
|
for (int i = 0; i < when_count; i++) {
|
|
n->when_clauses[i] = current_when->car; // Each car is a (condition . body) cons node
|
|
current_when = current_when->cdr;
|
|
}
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:postexe a) */
|
|
static node*
|
|
new_postexe(parser_state *p, node *a)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_postexe_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_postexe_node *postexe_node = (struct mrb_ast_postexe_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&postexe_node->hdr, p, NODE_POSTEXE, class);
|
|
postexe_node->body = a;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)postexe_node);
|
|
}
|
|
|
|
/* (:self) */
|
|
static node*
|
|
new_self(parser_state *p)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_self_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_self_node *n = (struct mrb_ast_self_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_SELF, class);
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:call a b c) */
|
|
static node*
|
|
new_call(parser_state *p, node *a, mrb_sym b, node *c, int pass)
|
|
{
|
|
node *n = list4(int_to_node(pass?NODE_CALL:NODE_SCALL), a, sym_to_node(b), c);
|
|
void_expr_error(p, a);
|
|
return n;
|
|
}
|
|
|
|
#if 0
|
|
/* Variable-sized call node creation */
|
|
static node*
|
|
new_call_var(parser_state *p, node *receiver, mrb_sym method, node *args, int pass)
|
|
{
|
|
/* Analyze the arguments to determine size needed */
|
|
uint8_t argc = 0;
|
|
uint8_t has_kwargs = 0;
|
|
uint8_t has_block = 0;
|
|
node *regular_args = NULL, *kwargs = NULL, *block = NULL;
|
|
|
|
if (args) {
|
|
regular_args = args->car;
|
|
if (args->cdr) {
|
|
kwargs = args->cdr->car;
|
|
has_kwargs = (kwargs != NULL);
|
|
if (args->cdr->cdr) {
|
|
block = args->cdr->cdr;
|
|
has_block = (block != NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Count regular arguments */
|
|
node *arg_iter = regular_args;
|
|
while (arg_iter) {
|
|
argc++;
|
|
arg_iter = arg_iter->cdr;
|
|
}
|
|
|
|
/* Calculate total size needed */
|
|
size_t base_size = sizeof(struct mrb_ast_call_node);
|
|
size_t args_size = argc * sizeof(struct mrb_ast_node*);
|
|
size_t kwargs_size = has_kwargs ? sizeof(struct mrb_ast_node*) : 0;
|
|
size_t block_size = has_block ? sizeof(struct mrb_ast_node*) : 0;
|
|
size_t total_size = base_size + args_size + kwargs_size + block_size;
|
|
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_call_node *n = (struct mrb_ast_call_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, pass ? NODE_CALL : NODE_SCALL, class);
|
|
n->receiver = receiver;
|
|
n->method_name = method;
|
|
n->argc = argc;
|
|
n->has_kwargs = has_kwargs;
|
|
n->has_block = has_block;
|
|
n->safe_call = (pass == 2); /* Assuming pass == 2 means safe call (&.) */
|
|
n->reserved = 0;
|
|
|
|
/* Copy regular arguments into flexible array */
|
|
arg_iter = regular_args;
|
|
for (int i = 0; i < argc; i++) {
|
|
n->args[i] = arg_iter->car;
|
|
arg_iter = arg_iter->cdr;
|
|
}
|
|
|
|
/* Add kwargs and block after regular arguments */
|
|
if (has_kwargs) {
|
|
n->args[argc] = kwargs;
|
|
}
|
|
if (has_block) {
|
|
n->args[argc + (has_kwargs ? 1 : 0)] = block;
|
|
}
|
|
|
|
void_expr_error(p, receiver);
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
#endif
|
|
|
|
/* Variable-sized method definition node creation */
|
|
static node*
|
|
new_def_var(parser_state *p, mrb_sym name, node *args, node *body)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_def_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_def_node *n = (struct mrb_ast_def_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_DEF, class);
|
|
n->name = name;
|
|
n->args = args;
|
|
n->body = body;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* Variable-sized simple node creation functions */
|
|
|
|
/* (:fcall self mid args) */
|
|
static node*
|
|
new_fcall(parser_state *p, mrb_sym b, node *c)
|
|
{
|
|
if (!p->var_nodes_enabled) {
|
|
node *n = list4((node*)NODE_FCALL, 0, sym_to_node(b), c);
|
|
return n;
|
|
}
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_fcall_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_fcall_node *fcall_node = (struct mrb_ast_fcall_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&fcall_node->hdr, p, NODE_FCALL, class);
|
|
fcall_node->method_name = b;
|
|
fcall_node->args = c;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)fcall_node);
|
|
}
|
|
|
|
/* (a b . c) */
|
|
static node*
|
|
new_callargs(parser_state *p, node *a, node *b, node *c)
|
|
{
|
|
return cons_head(a, cons(b, c));
|
|
}
|
|
|
|
/* (:super . c) */
|
|
static node*
|
|
new_super(parser_state *p, node *c)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_super_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_SUPER, class);
|
|
n->args = c;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:zsuper) */
|
|
static node*
|
|
new_zsuper(parser_state *p)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_super_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->header, p, NODE_ZSUPER, class);
|
|
n->args = NULL; /* zsuper initially has no args, but may be added by call_with_block */
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:yield . c) */
|
|
static node*
|
|
new_yield(parser_state *p, node *c)
|
|
{
|
|
if (c && c->cdr && c->cdr->cdr) {
|
|
yyerror(NULL, p, "both block arg and actual block given");
|
|
}
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_yield_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_yield_node *n = (struct mrb_ast_yield_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_YIELD, class);
|
|
n->args = c;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:return . c) */
|
|
static node*
|
|
new_return(parser_state *p, node *c)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_return_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_return_node *n = (struct mrb_ast_return_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_RETURN, class);
|
|
n->args = c;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:break . c) */
|
|
static node*
|
|
new_break(parser_state *p, node *c)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_break_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_break_node *n = (struct mrb_ast_break_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->hdr, p, NODE_BREAK, class);
|
|
n->value = c;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:next . c) */
|
|
static node*
|
|
new_next(parser_state *p, node *c)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_next_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_next_node *n = (struct mrb_ast_next_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->hdr, p, NODE_NEXT, class);
|
|
n->value = c;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:redo) */
|
|
static node*
|
|
new_redo(parser_state *p)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_redo_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_redo_node *n = (struct mrb_ast_redo_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->hdr, p, NODE_REDO, class);
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:retry) */
|
|
static node*
|
|
new_retry(parser_state *p)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_retry_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_retry_node *n = (struct mrb_ast_retry_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->hdr, p, NODE_RETRY, class);
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:dot2 a b) */
|
|
static node*
|
|
new_dot2(parser_state *p, node *a, node *b)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_dot2_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_dot2_node *n = (struct mrb_ast_dot2_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_DOT2, class);
|
|
n->left = a;
|
|
n->right = b;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:dot3 a b) */
|
|
static node*
|
|
new_dot3(parser_state *p, node *a, node *b)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_dot3_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_dot3_node *n = (struct mrb_ast_dot3_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_DOT3, class);
|
|
n->left = a;
|
|
n->right = b;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:colon2 b c) */
|
|
static node*
|
|
new_colon2(parser_state *p, node *b, mrb_sym c)
|
|
{
|
|
void_expr_error(p, b);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_colon2_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_colon2_node *colon2_node = (struct mrb_ast_colon2_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&colon2_node->hdr, p, NODE_COLON2, class);
|
|
colon2_node->base = b;
|
|
colon2_node->name = c;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)colon2_node);
|
|
}
|
|
|
|
/* (:colon3 . c) */
|
|
static node*
|
|
new_colon3(parser_state *p, mrb_sym c)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_colon3_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_colon3_node *colon3_node = (struct mrb_ast_colon3_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&colon3_node->hdr, p, NODE_COLON3, class);
|
|
colon3_node->name = c;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)colon3_node);
|
|
}
|
|
|
|
/* (:and a b) */
|
|
static node*
|
|
new_and(parser_state *p, node *a, node *b)
|
|
{
|
|
void_expr_error(p, a);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_and_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_and_node *n = (struct mrb_ast_and_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_AND, class);
|
|
n->left = a;
|
|
n->right = b;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:or a b) */
|
|
static node*
|
|
new_or(parser_state *p, node *a, node *b)
|
|
{
|
|
void_expr_error(p, a);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_or_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_or_node *n = (struct mrb_ast_or_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_OR, class);
|
|
n->left = a;
|
|
n->right = b;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:array a...) */
|
|
static node*
|
|
new_array(parser_state *p, node *a)
|
|
{
|
|
/* Count array elements */
|
|
uint16_t len = 0;
|
|
node *elem_iter = a;
|
|
while (elem_iter) {
|
|
len++;
|
|
elem_iter = elem_iter->cdr;
|
|
}
|
|
|
|
/* Calculate total size needed */
|
|
size_t base_size = sizeof(struct mrb_ast_array_node);
|
|
size_t elems_size = len * sizeof(struct mrb_ast_node*);
|
|
size_t total_size = base_size + elems_size;
|
|
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_array_node *n = (struct mrb_ast_array_node*)
|
|
parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_ARRAY, class);
|
|
n->len = len;
|
|
n->flags = 0;
|
|
|
|
/* Copy elements into flexible array */
|
|
elem_iter = a;
|
|
for (int i = 0; i < len; i++) {
|
|
n->elements[i] = elem_iter->car;
|
|
elem_iter = elem_iter->cdr;
|
|
}
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:splat . a) */
|
|
static node*
|
|
new_splat(parser_state *p, node *a)
|
|
{
|
|
void_expr_error(p, a);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_splat_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_splat_node *splat_node = (struct mrb_ast_splat_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&splat_node->hdr, p, NODE_SPLAT, class);
|
|
splat_node->value = a;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)splat_node);
|
|
}
|
|
|
|
/* (:hash (k . v) (k . v)...) */
|
|
static node*
|
|
new_hash(parser_state *p, node *a)
|
|
{
|
|
/* Count hash key-value pairs */
|
|
uint16_t len = 0;
|
|
node *pair_iter = a;
|
|
while (pair_iter) {
|
|
len++;
|
|
pair_iter = pair_iter->cdr;
|
|
}
|
|
|
|
/* Calculate total size needed */
|
|
size_t base_size = sizeof(struct mrb_ast_hash_node);
|
|
size_t pairs_size = len * 2 * sizeof(struct mrb_ast_node*); /* key and value for each pair */
|
|
size_t total_size = base_size + pairs_size;
|
|
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_hash_node *n = (struct mrb_ast_hash_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_HASH, class);
|
|
n->len = len;
|
|
n->flags = 0;
|
|
|
|
/* Copy key-value pairs into flexible array */
|
|
pair_iter = a;
|
|
for (int i = 0; i < len; i++) {
|
|
if (pair_iter && pair_iter->car) {
|
|
/* Each pair is a cons (key . value) */
|
|
node *pair = pair_iter->car;
|
|
n->pairs[i * 2] = pair->car; /* key */
|
|
n->pairs[i * 2 + 1] = pair->cdr; /* value */
|
|
}
|
|
pair_iter = pair_iter->cdr;
|
|
}
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:kw_hash (k . v) (k . v)...) */
|
|
static node*
|
|
new_kw_hash(parser_state *p, node *a)
|
|
{
|
|
if (!p->var_nodes_enabled) {
|
|
return cons_head((node*)NODE_KW_HASH, a);
|
|
}
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_kw_hash_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_kw_hash_node *kw_hash_node = (struct mrb_ast_kw_hash_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&kw_hash_node->hdr, p, NODE_KW_HASH, class);
|
|
kw_hash_node->args = a;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)kw_hash_node);
|
|
}
|
|
|
|
/* (:sym . a) */
|
|
/* Symbol node creation - supports both variable and legacy modes */
|
|
static node*
|
|
new_sym(parser_state *p, mrb_sym sym)
|
|
{
|
|
size_t size = sizeof(struct mrb_ast_sym_node);
|
|
enum mrb_ast_size_class class = size_to_class(size);
|
|
|
|
struct mrb_ast_sym_node *n = (struct mrb_ast_sym_node*)parser_alloc_var(p, size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_SYM, class);
|
|
n->symbol = sym;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
static node*
|
|
new_xvar(parser_state *p, mrb_sym sym, enum node_type type)
|
|
{
|
|
size_t size = sizeof(struct mrb_ast_var_node);
|
|
enum mrb_ast_size_class class = size_to_class(size);
|
|
|
|
struct mrb_ast_var_node *n = (struct mrb_ast_var_node*)parser_alloc_var(p, size, class);
|
|
|
|
init_var_header(&n->header, p, type, class);
|
|
n->symbol = sym;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
static mrb_sym
|
|
new_strsym(parser_state *p, node* str)
|
|
{
|
|
size_t len = (size_t)str->car;
|
|
const char *s = (const char*)str->cdr;
|
|
|
|
return mrb_intern(p->mrb, s, len);
|
|
}
|
|
|
|
/* (:nvar . a) */
|
|
static node*
|
|
new_nvar(parser_state *p, int num)
|
|
{
|
|
int nvar;
|
|
node *nvars = p->nvars->cdr;
|
|
while (nvars) {
|
|
nvar = node_to_int(nvars->car);
|
|
if (nvar == -2) break; /* top of the scope */
|
|
if (nvar > 0) {
|
|
yyerror(NULL, p, "numbered parameter used in outer block");
|
|
break;
|
|
}
|
|
nvars->car = int_to_node(-1);
|
|
nvars = nvars->cdr;
|
|
}
|
|
nvar = node_to_int(p->nvars->car);
|
|
if (nvar == -1) {
|
|
yyerror(NULL, p, "numbered parameter used in inner block");
|
|
}
|
|
else {
|
|
p->nvars->car = int_to_node(nvar > num ? nvar : num);
|
|
}
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_nvar_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_nvar_node *n = (struct mrb_ast_nvar_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->hdr, p, NODE_NVAR, class);
|
|
n->num = num;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:const . a) */
|
|
static node*
|
|
new_const(parser_state *p, mrb_sym sym)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_const_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_const_node *n = (struct mrb_ast_const_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_CONST, class);
|
|
n->symbol = sym;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:undef a...) */
|
|
static node*
|
|
new_undef(parser_state *p, node *syms)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_undef_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_undef_node *undef_node = (struct mrb_ast_undef_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&undef_node->hdr, p, NODE_UNDEF, class);
|
|
undef_node->syms = syms;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)undef_node);
|
|
}
|
|
|
|
/* (:class class super body) */
|
|
static node*
|
|
new_class(parser_state *p, node *c, node *s, node *b)
|
|
{
|
|
void_expr_error(p, s);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_class_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_class_node *n = (struct mrb_ast_class_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_CLASS, class);
|
|
n->name = c;
|
|
n->superclass = s;
|
|
n->body = cons(locals_node(p), b);
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:sclass obj body) */
|
|
static node*
|
|
new_sclass(parser_state *p, node *o, node *b)
|
|
{
|
|
void_expr_error(p, o);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_sclass_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_sclass_node *n = (struct mrb_ast_sclass_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_SCLASS, class);
|
|
n->obj = o;
|
|
n->body = cons(locals_node(p), b);
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:module module body) */
|
|
static node*
|
|
new_module(parser_state *p, node *m, node *b)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_module_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_module_node *n = (struct mrb_ast_module_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_MODULE, class);
|
|
n->name = m;
|
|
n->body = cons(locals_node(p), b);
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:def m lv (arg . body)) */
|
|
static node*
|
|
new_def(parser_state *p, mrb_sym m, node *a, node *b)
|
|
{
|
|
if (p->var_nodes_enabled) {
|
|
return new_def_var(p, m, a, b);
|
|
}
|
|
return list5((node*)NODE_DEF, sym_to_node(m), 0, a, b);
|
|
}
|
|
|
|
static void
|
|
defn_setup(parser_state *p, node *d, node *a, node *b)
|
|
{
|
|
node *n = d->cdr->cdr;
|
|
|
|
n->car = locals_node(p);
|
|
p->cmdarg_stack = node_to_int(n->cdr->car);
|
|
n->cdr->car = a;
|
|
local_resume(p, n->cdr->cdr->car);
|
|
n->cdr->cdr->car = b;
|
|
}
|
|
|
|
/* (:sdef obj m lv (arg . body)) */
|
|
static node*
|
|
new_sdef(parser_state *p, node *o, mrb_sym m, node *a, node *b)
|
|
{
|
|
void_expr_error(p, o);
|
|
if (!p->var_nodes_enabled) {
|
|
return list6((node*)NODE_SDEF, o, sym_to_node(m), 0, a, b);
|
|
}
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_sdef_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_sdef_node *sdef_node = (struct mrb_ast_sdef_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&sdef_node->hdr, p, NODE_SDEF, class);
|
|
sdef_node->obj = o;
|
|
sdef_node->name = m;
|
|
sdef_node->args = a;
|
|
sdef_node->body = b;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)sdef_node);
|
|
}
|
|
|
|
static void
|
|
defs_setup(parser_state *p, node *d, node *a, node *b)
|
|
{
|
|
node *n = d->cdr->cdr->cdr;
|
|
|
|
n->car = locals_node(p);
|
|
p->cmdarg_stack = node_to_int(n->cdr->car);
|
|
n->cdr->car = a;
|
|
local_resume(p, n->cdr->cdr->car);
|
|
n->cdr->cdr->car = b;
|
|
}
|
|
|
|
/* (:arg . sym) */
|
|
static node*
|
|
new_arg(parser_state *p, mrb_sym sym)
|
|
{
|
|
return new_xvar(p, sym, NODE_ARG);
|
|
}
|
|
|
|
static void
|
|
local_add_margs(parser_state *p, node *n)
|
|
{
|
|
while (n) {
|
|
if (node_to_type(n->car->car) == NODE_VARIABLE) {
|
|
if (VAR_NODE_TYPE(n->car->cdr) == NODE_MASGN) {
|
|
struct mrb_ast_masgn_node *masgn_n = (struct mrb_ast_masgn_node*)n->car->cdr;
|
|
node *lhs = masgn_n->lhs;
|
|
node *rhs = masgn_n->rhs;
|
|
|
|
/* For parameter destructuring, rhs contains the locals */
|
|
if (rhs) {
|
|
node *t = rhs;
|
|
while (t) {
|
|
local_add_f(p, node_to_sym(t->car));
|
|
t = t->cdr;
|
|
}
|
|
}
|
|
|
|
/* Process nested destructuring in lhs */
|
|
if (lhs && lhs->car) {
|
|
local_add_margs(p, lhs->car);
|
|
}
|
|
if (lhs && lhs->cdr && lhs->cdr->cdr && lhs->cdr->cdr->car) {
|
|
local_add_margs(p, lhs->cdr->cdr->car);
|
|
}
|
|
}
|
|
}
|
|
n = n->cdr;
|
|
}
|
|
}
|
|
|
|
static void
|
|
local_add_lv(parser_state *p, node *lv)
|
|
{
|
|
while (lv) {
|
|
local_add_f(p, node_to_sym(lv->car));
|
|
lv = lv->cdr;
|
|
}
|
|
}
|
|
|
|
/* (m o r m2 tail) */
|
|
/* m: (a b c) */
|
|
/* o: ((a . e1) (b . e2)) */
|
|
/* r: a */
|
|
/* m2: (a b c) */
|
|
/* b: a */
|
|
static node*
|
|
new_args(parser_state *p, node *m, node *opt, mrb_sym rest, node *m2, node *tail)
|
|
{
|
|
node *n;
|
|
|
|
local_add_margs(p, m);
|
|
local_add_margs(p, m2);
|
|
|
|
n = cons(m2, tail);
|
|
n = cons(sym_to_node(rest), n);
|
|
n = cons(opt, n);
|
|
while (opt) {
|
|
/* opt: (sym . (opt . lv)) -> (sym . opt) */
|
|
local_add_lv(p, opt->car->cdr->cdr);
|
|
opt->car->cdr = opt->car->cdr->car;
|
|
opt = opt->cdr;
|
|
}
|
|
return cons(m, n);
|
|
}
|
|
|
|
/* (:args_tail keywords rest_keywords_sym block_sym) */
|
|
static node*
|
|
new_args_tail(parser_state *p, node *kws, node *kwrest, mrb_sym blk)
|
|
{
|
|
node *k;
|
|
|
|
if (kws || kwrest) {
|
|
local_add_kw(p, (kwrest && kwrest->cdr)? node_to_sym(kwrest->cdr) : 0);
|
|
}
|
|
|
|
local_add_blk(p);
|
|
if (blk) local_add_f(p, blk);
|
|
|
|
/* allocate register for keywords arguments */
|
|
/* order is for Proc#parameters */
|
|
for (k = kws; k; k = k->cdr) {
|
|
if (!k->car->cdr->cdr->car) { /* allocate required keywords */
|
|
local_add_f(p, node_to_sym(k->car->cdr->car));
|
|
}
|
|
}
|
|
for (k = kws; k; k = k->cdr) {
|
|
if (k->car->cdr->cdr->car) { /* allocate keywords with default */
|
|
local_add_lv(p, k->car->cdr->cdr->car->cdr);
|
|
k->car->cdr->cdr->car = k->car->cdr->cdr->car->car;
|
|
local_add_f(p, node_to_sym(k->car->cdr->car));
|
|
}
|
|
}
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_args_tail_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_args_tail_node *n = (struct mrb_ast_args_tail_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_ARGS_TAIL, class);
|
|
n->keywords = kws;
|
|
n->kwrest = kwrest;
|
|
n->block = blk;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:kw_arg kw_sym def_arg) */
|
|
static node*
|
|
new_kw_arg(parser_state *p, mrb_sym kw, node *def_arg)
|
|
{
|
|
mrb_assert(kw);
|
|
return list3((node*)NODE_KW_ARG, sym_to_node(kw), def_arg);
|
|
}
|
|
|
|
/* (:kw_rest_args . a) */
|
|
static node*
|
|
new_kw_rest_args(parser_state *p, mrb_sym sym)
|
|
{
|
|
return cons_head((node*)NODE_KW_REST_ARGS, sym_to_node(sym));
|
|
}
|
|
|
|
static node*
|
|
new_args_dots(parser_state *p, node *m)
|
|
{
|
|
mrb_sym r = intern_op(mul);
|
|
mrb_sym k = intern_op(pow);
|
|
mrb_sym b = intern_op(and);
|
|
local_add_f(p, r);
|
|
return new_args(p, m, 0, r, 0,
|
|
new_args_tail(p, 0, new_kw_rest_args(p, k), b));
|
|
}
|
|
|
|
/* (:block_arg . a) */
|
|
static node*
|
|
new_block_arg(parser_state *p, node *a)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_block_arg_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_block_arg_node *block_arg_node = (struct mrb_ast_block_arg_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&block_arg_node->hdr, p, NODE_BLOCK_ARG, class);
|
|
block_arg_node->value = a;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)block_arg_node);
|
|
}
|
|
|
|
static node*
|
|
setup_numparams(parser_state *p, node *a)
|
|
{
|
|
int nvars = node_to_int(p->nvars->car);
|
|
if (nvars > 0) {
|
|
int i;
|
|
mrb_sym sym;
|
|
// m || opt || rest || tail
|
|
if (a && (a->car || (a->cdr && a->cdr->car) || (a->cdr->cdr && a->cdr->cdr->car) || (a->cdr->cdr->cdr->cdr && a->cdr->cdr->cdr->cdr->car))) {
|
|
yyerror(NULL, p, "ordinary parameter is defined");
|
|
}
|
|
else if (p->locals) {
|
|
/* p->locals should not be NULL unless error happens before the point */
|
|
node* args = 0;
|
|
for (i = nvars; i > 0; i--) {
|
|
char buf[3];
|
|
|
|
buf[0] = '_';
|
|
buf[1] = i+'0';
|
|
buf[2] = '\0';
|
|
sym = intern_cstr(buf);
|
|
args = cons(new_arg(p, sym), args);
|
|
p->locals->car = cons(sym_to_node(sym), p->locals->car);
|
|
}
|
|
a = new_args(p, args, 0, 0, 0, 0);
|
|
}
|
|
}
|
|
return a;
|
|
}
|
|
|
|
/* (:block arg body) */
|
|
static node*
|
|
new_block(parser_state *p, node *a, node *b)
|
|
{
|
|
a = setup_numparams(p, a);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_block_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_block_node *n = (struct mrb_ast_block_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_BLOCK, class);
|
|
n->locals = locals_node(p);
|
|
n->args = a;
|
|
n->body = b;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:lambda arg body) */
|
|
static node*
|
|
new_lambda(parser_state *p, node *a, node *b)
|
|
{
|
|
a = setup_numparams(p, a);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_lambda_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_lambda_node *lambda_node = (struct mrb_ast_lambda_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&lambda_node->hdr, p, NODE_LAMBDA, class);
|
|
lambda_node->locals = locals_node(p);
|
|
lambda_node->args = a;
|
|
lambda_node->body = b;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)lambda_node);
|
|
}
|
|
|
|
/* (:asgn lhs rhs) */
|
|
static node*
|
|
new_asgn(parser_state *p, node *a, node *b)
|
|
{
|
|
void_expr_error(p, b);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_asgn_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_asgn_node *n = (struct mrb_ast_asgn_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_ASGN, class);
|
|
n->lhs = a;
|
|
n->rhs = b;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:masgn mlhs=(pre rest post) mrhs) */
|
|
static node*
|
|
new_masgn(parser_state *p, node *a, node *b)
|
|
{
|
|
void_expr_error(p, b);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_masgn_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_masgn_node *n = (struct mrb_ast_masgn_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_MASGN, class);
|
|
n->lhs = a;
|
|
n->rhs = b;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:masgn mlhs mrhs) no check */
|
|
static node*
|
|
new_masgn_param(parser_state *p, node *a, node *b)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_masgn_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_masgn_node *n = (struct mrb_ast_masgn_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_MASGN, class);
|
|
n->lhs = a;
|
|
n->rhs = b;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:asgn lhs rhs) */
|
|
static node*
|
|
new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)
|
|
{
|
|
void_expr_error(p, b);
|
|
|
|
size_t total_size = sizeof(struct mrb_ast_op_asgn_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_op_asgn_node *n = (struct mrb_ast_op_asgn_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->header, p, NODE_OP_ASGN, class);
|
|
n->lhs = a;
|
|
n->operator = op;
|
|
n->rhs = b;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
static node*
|
|
new_int_n(parser_state *p, int32_t val)
|
|
{
|
|
size_t size = sizeof(struct mrb_ast_int_node);
|
|
enum mrb_ast_size_class class = size_to_class(size);
|
|
struct mrb_ast_int_node *n = (struct mrb_ast_int_node*)parser_alloc_var(p, size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_INT, class);
|
|
n->value = val;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
static node*
|
|
new_imaginary(parser_state *p, node *imaginary)
|
|
{
|
|
return new_fcall(p, MRB_SYM_2(p->mrb, Complex),
|
|
new_callargs(p, list2(new_int_n(p, 0), imaginary), 0, 0));
|
|
}
|
|
|
|
static node*
|
|
new_rational(parser_state *p, node *rational)
|
|
{
|
|
return new_fcall(p, MRB_SYM_2(p->mrb, Rational), new_callargs(p, list1(rational), 0, 0));
|
|
}
|
|
|
|
/* Read integer into int32_t with overflow detection */
|
|
static mrb_bool
|
|
read_int32(const char *p, int base, int32_t *result)
|
|
{
|
|
const char *e = p + strlen(p);
|
|
int32_t value = 0;
|
|
mrb_bool neg = FALSE;
|
|
|
|
if (base < 2 || base > 16) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (*p == '+') {
|
|
p++;
|
|
}
|
|
else if (*p == '-') {
|
|
neg = TRUE;
|
|
p++;
|
|
}
|
|
|
|
while (p < e) {
|
|
int n;
|
|
char c = *p;
|
|
|
|
/* Skip underscores */
|
|
if (c == '_') {
|
|
p++;
|
|
continue;
|
|
}
|
|
|
|
/* Parse digit */
|
|
if (c >= '0' && c <= '9') {
|
|
n = c - '0';
|
|
}
|
|
else if (c >= 'a' && c <= 'f') {
|
|
n = c - 'a' + 10;
|
|
}
|
|
else if (c >= 'A' && c <= 'F') {
|
|
n = c - 'A' + 10;
|
|
}
|
|
else {
|
|
/* Invalid character */
|
|
return FALSE;
|
|
}
|
|
|
|
if (n >= base) {
|
|
/* Digit not valid for this base */
|
|
return FALSE;
|
|
}
|
|
|
|
/* Check for multiplication overflow */
|
|
if (value > INT32_MAX / base) {
|
|
return FALSE;
|
|
}
|
|
|
|
value *= base;
|
|
|
|
/* Check for addition overflow */
|
|
if (value > INT32_MAX - n) {
|
|
/* Special case: -INT32_MIN is valid */
|
|
if (neg && value == (INT32_MAX - n + 1) && p + 1 == e) {
|
|
*result = INT32_MIN;
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
value += n;
|
|
p++;
|
|
}
|
|
|
|
*result = neg ? -value : value;
|
|
return TRUE;
|
|
}
|
|
|
|
static node*
|
|
new_int(parser_state *p, const char *s, int base, int suffix)
|
|
{
|
|
int32_t val;
|
|
node* result;
|
|
|
|
/* Try to parse as int32_t first */
|
|
if (read_int32(s, base, &val)) {
|
|
result = new_int_n(p, val);
|
|
}
|
|
else {
|
|
/* Big integer - create NODE_BIGINT */
|
|
size_t size = sizeof(struct mrb_ast_bigint_node);
|
|
enum mrb_ast_size_class class = size_to_class(size);
|
|
struct mrb_ast_bigint_node *n = (struct mrb_ast_bigint_node*)parser_alloc_var(p, size, class);
|
|
|
|
init_var_header(&n->header, p, NODE_BIGINT, class);
|
|
n->string = strdup(s);
|
|
n->base = base;
|
|
|
|
result = cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* Handle suffix modifiers */
|
|
if (suffix & NUM_SUFFIX_R) {
|
|
result = new_rational(p, result);
|
|
}
|
|
if (suffix & NUM_SUFFIX_I) {
|
|
result = new_imaginary(p, result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#ifndef MRB_NO_FLOAT
|
|
/* (:float . i) */
|
|
static node*
|
|
new_float(parser_state *p, const char *s, int suffix)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_float_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_float_node *n = (struct mrb_ast_float_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_FLOAT, class);
|
|
n->value = strdup(s);
|
|
|
|
node* result = cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
|
|
if (suffix & NUM_SUFFIX_R) {
|
|
result = new_rational(p, result);
|
|
}
|
|
if (suffix & NUM_SUFFIX_I) {
|
|
result = new_imaginary(p, result);
|
|
}
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
/* Create string node from cons list */
|
|
/* (:str . a) */
|
|
static node*
|
|
new_str(parser_state *p, node *a)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_str_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
|
|
struct mrb_ast_str_node *n = (struct mrb_ast_str_node*)parser_alloc_var(p, total_size, class);
|
|
|
|
init_var_header(&n->hdr, p, NODE_STR, class);
|
|
n->list = a;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:xstr . a) */
|
|
static node*
|
|
new_xstr(parser_state *p, node *a)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_xstr_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_xstr_node *n = (struct mrb_ast_xstr_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->hdr, p, NODE_XSTR, class);
|
|
n->list = a;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:dsym . a) */
|
|
static node*
|
|
new_dsym(parser_state *p, node *a)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_dsym_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_dsym_node *n = (struct mrb_ast_dsym_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->hdr, p, NODE_DSYM, class);
|
|
n->list = a;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:dregx . (list . (flags . encoding))) */
|
|
static node*
|
|
new_dregx(parser_state *p, node *list, const char *flags, const char *encoding)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_dregx_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_dregx_node *n = (struct mrb_ast_dregx_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->hdr, p, NODE_DREGX, class);
|
|
n->list = list;
|
|
n->flags = flags;
|
|
n->encoding = encoding;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
/* (:backref . n) */
|
|
static node*
|
|
new_back_ref(parser_state *p, int n)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_back_ref_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_back_ref_node *backref_node = (struct mrb_ast_back_ref_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&backref_node->hdr, p, NODE_BACK_REF, class);
|
|
backref_node->type = n;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)backref_node);
|
|
}
|
|
|
|
/* (:nthref . n) */
|
|
static node*
|
|
new_nth_ref(parser_state *p, int n)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_nth_ref_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_nth_ref_node *nthref_node = (struct mrb_ast_nth_ref_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&nthref_node->hdr, p, NODE_NTH_REF, class);
|
|
nthref_node->nth = n;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)nthref_node);
|
|
}
|
|
|
|
/* (:heredoc . a) */
|
|
static node*
|
|
new_heredoc(parser_state *p, struct mrb_parser_heredoc_info **infop)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_heredoc_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_heredoc_node *n = (struct mrb_ast_heredoc_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&n->hdr, p, NODE_HEREDOC, class);
|
|
|
|
/* Initialize embedded heredoc info struct */
|
|
n->info.allow_indent = FALSE;
|
|
n->info.remove_indent = FALSE;
|
|
n->info.line_head = FALSE;
|
|
n->info.indent = 0;
|
|
n->info.indented = NULL;
|
|
n->info.type = str_not_parsing; // Will be set by heredoc processing
|
|
n->info.term = NULL; // Will be set by heredoc processing
|
|
n->info.term_len = 0;
|
|
n->info.doc = NULL;
|
|
|
|
/* Return pointer to embedded info if requested */
|
|
*infop = &n->info;
|
|
|
|
return cons_head((node*)NODE_VARIABLE, (node*)n);
|
|
}
|
|
|
|
static void
|
|
new_bv(parser_state *p, mrb_sym id)
|
|
{
|
|
}
|
|
|
|
static node*
|
|
new_literal_delim(parser_state *p)
|
|
{
|
|
return cons((node*)0, (node*)0);
|
|
}
|
|
|
|
/* Helper for creating string representation cons (length . string_ptr) */
|
|
static node*
|
|
new_str_rep(parser_state *p, const char *str, int len)
|
|
{
|
|
return cons(int_to_node(len), (node*)strndup(str, len));
|
|
}
|
|
|
|
/* Helper for creating string representation from current token */
|
|
static node*
|
|
new_str_tok(parser_state *p)
|
|
{
|
|
return new_str_rep(p, tok(p), toklen(p));
|
|
}
|
|
|
|
/* Helper for creating empty string representation */
|
|
static node*
|
|
new_str_empty(parser_state *p)
|
|
{
|
|
return new_str_rep(p, "", 0);
|
|
}
|
|
|
|
/* (:words . a) */
|
|
static node*
|
|
new_words(parser_state *p, node *a)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_words_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_words_node *words_node = (struct mrb_ast_words_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&words_node->hdr, p, NODE_WORDS, class);
|
|
words_node->args = a;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)words_node);
|
|
}
|
|
|
|
/* (:symbols . a) */
|
|
static node*
|
|
new_symbols(parser_state *p, node *a)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_symbols_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_symbols_node *symbols_node = (struct mrb_ast_symbols_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&symbols_node->hdr, p, NODE_SYMBOLS, class);
|
|
symbols_node->args = a;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)symbols_node);
|
|
}
|
|
|
|
/* xxx ----------------------------- */
|
|
|
|
/* (:call a op) */
|
|
static node*
|
|
call_uni_op(parser_state *p, node *recv, const char *m)
|
|
{
|
|
void_expr_error(p, recv);
|
|
return new_call(p, recv, intern_cstr(m), 0, '.');
|
|
}
|
|
|
|
/* (:call a op b) */
|
|
static node*
|
|
call_bin_op(parser_state *p, node *recv, const char *m, node *arg1)
|
|
{
|
|
return new_call(p, recv, intern_cstr(m), new_callargs(p, list1(arg1), 0, 0), '.');
|
|
}
|
|
|
|
static void
|
|
args_with_block(parser_state *p, node *a, node *b)
|
|
{
|
|
if (b) {
|
|
if (a->cdr && a->cdr->cdr) {
|
|
yyerror(NULL, p, "both block arg and actual block given");
|
|
}
|
|
a->cdr->cdr = b;
|
|
}
|
|
}
|
|
|
|
static void
|
|
endless_method_name(parser_state *p, node *defn)
|
|
{
|
|
mrb_sym sym = node_to_sym(defn->cdr->car);
|
|
mrb_int len;
|
|
const char *name = mrb_sym_name_len(p->mrb, sym, &len);
|
|
|
|
if (len > 1 && name[len-1] == '=') {
|
|
for (int i=0; i<len-1; i++) {
|
|
if (!identchar(name[i])) return;
|
|
}
|
|
yyerror(NULL, p, "setter method cannot be defined by endless method definition");
|
|
}
|
|
}
|
|
|
|
static void
|
|
call_with_block(parser_state *p, node *a, node *b)
|
|
{
|
|
node *n;
|
|
|
|
switch (node_to_type(a->car)) {
|
|
case NODE_VARIABLE:
|
|
/* Handle variable-sized nodes wrapped in NODE_VARIABLE */
|
|
{
|
|
enum node_type var_type = VAR_NODE_TYPE(a->cdr);
|
|
if (var_type == NODE_SUPER || var_type == NODE_ZSUPER) {
|
|
/* For variable-sized super/zsuper nodes, we need to update the args field directly */
|
|
struct mrb_ast_super_node *super_n = super_node(a->cdr);
|
|
if (!super_n->args) {
|
|
super_n->args = new_callargs(p, 0, 0, b);
|
|
}
|
|
else {
|
|
args_with_block(p, super_n->args, b);
|
|
}
|
|
return;
|
|
}
|
|
else if (var_type == NODE_YIELD) {
|
|
/* Variable-sized yield nodes should generate an error when given a block */
|
|
yyerror(NULL, p, "block given to yield");
|
|
return;
|
|
}
|
|
else if (var_type == NODE_RETURN) {
|
|
/* Variable-sized return nodes - recursively call with args */
|
|
struct mrb_ast_return_node *return_n = return_node(a->cdr);
|
|
if (return_n->args == NULL) return;
|
|
call_with_block(p, return_n->args, b);
|
|
return;
|
|
}
|
|
else if (var_type == NODE_BREAK) {
|
|
/* Variable-sized break nodes - recursively call with value */
|
|
struct mrb_ast_break_node *break_n = (struct mrb_ast_break_node*)a->cdr;
|
|
if (break_n->value == NULL) return;
|
|
call_with_block(p, break_n->value, b);
|
|
return;
|
|
}
|
|
else if (var_type == NODE_NEXT) {
|
|
/* Variable-sized next nodes - recursively call with value */
|
|
struct mrb_ast_next_node *next_n = (struct mrb_ast_next_node*)a->cdr;
|
|
if (next_n->value == NULL) return;
|
|
call_with_block(p, next_n->value, b);
|
|
return;
|
|
}
|
|
}
|
|
/* For other variable-sized nodes, fall through to default */
|
|
break;
|
|
case NODE_CALL:
|
|
case NODE_FCALL:
|
|
case NODE_SCALL:
|
|
/* (NODE_CALL recv mid (args kw . blk)) */
|
|
n = a->cdr->cdr->cdr; /* (args kw . blk) */
|
|
if (!n->car) n->car = new_callargs(p, 0, 0, b);
|
|
else args_with_block(p, n->car, b);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static node*
|
|
new_negate(parser_state *p, node *n)
|
|
{
|
|
size_t total_size = sizeof(struct mrb_ast_negate_node);
|
|
enum mrb_ast_size_class class = size_to_class(total_size);
|
|
struct mrb_ast_negate_node *negate_node = (struct mrb_ast_negate_node*)parser_alloc_var(p, total_size, class);
|
|
init_var_header(&negate_node->hdr, p, NODE_NEGATE, class);
|
|
negate_node->operand = n;
|
|
return cons_head((node*)NODE_VARIABLE, (node*)negate_node);
|
|
}
|
|
|
|
static node*
|
|
cond(node *n)
|
|
{
|
|
return n;
|
|
}
|
|
|
|
static node*
|
|
ret_args(parser_state *p, node *n)
|
|
{
|
|
if (n->cdr->cdr) {
|
|
yyerror(NULL, p, "block argument should not be given");
|
|
return NULL;
|
|
}
|
|
if (!n->car) return NULL;
|
|
if (!n->car->cdr) return n->car->car;
|
|
return new_array(p, n->car);
|
|
}
|
|
|
|
static void
|
|
assignable(parser_state *p, node *lhs)
|
|
{
|
|
if (node_to_int(lhs->car) == NODE_VARIABLE) {
|
|
node *var_node = lhs->cdr;
|
|
switch (VAR_NODE_TYPE(var_node)) {
|
|
case NODE_LVAR:
|
|
local_add(p, VAR_NODE_SYMBOL(var_node));
|
|
break;
|
|
case NODE_CONST:
|
|
if (p->in_def)
|
|
yyerror(NULL, p, "dynamic constant assignment");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static node*
|
|
var_reference(parser_state *p, node *lhs)
|
|
{
|
|
if (node_to_int(lhs->car) == NODE_VARIABLE) {
|
|
node *var_node = lhs->cdr;
|
|
if (VAR_NODE_TYPE(var_node) == NODE_LVAR) {
|
|
mrb_sym sym = VAR_NODE_SYMBOL(var_node);
|
|
if (!local_var_p(p, sym)) {
|
|
node *n = new_fcall(p, sym, 0);
|
|
/* Don't free variable-sized nodes - they're managed by the parser allocator */
|
|
return n;
|
|
}
|
|
}
|
|
}
|
|
return lhs;
|
|
}
|
|
|
|
static node*
|
|
label_reference(parser_state *p, mrb_sym sym)
|
|
{
|
|
const char *name = mrb_sym_name(p->mrb, sym);
|
|
|
|
if (local_var_p(p, sym)) {
|
|
return new_xvar(p, sym, NODE_LVAR);
|
|
}
|
|
else if (ISUPPER(name[0])) {
|
|
return new_const(p, sym);
|
|
}
|
|
else {
|
|
return new_fcall(p, sym, 0);
|
|
}
|
|
}
|
|
|
|
typedef enum mrb_string_type string_type;
|
|
|
|
typedef struct parser_lex_strterm {
|
|
int type;
|
|
int level;
|
|
int term;
|
|
int paren;
|
|
struct parser_lex_strterm *prev;
|
|
} parser_lex_strterm;
|
|
|
|
static parser_lex_strterm*
|
|
new_strterm(parser_state *p, string_type type, int term, int paren)
|
|
{
|
|
parser_lex_strterm *lex = (parser_lex_strterm*)parser_palloc(p, sizeof(parser_lex_strterm));
|
|
lex->type = type;
|
|
lex->level = 0;
|
|
lex->term = term;
|
|
lex->paren = paren;
|
|
lex->prev = p->lex_strterm;
|
|
return lex;
|
|
}
|
|
|
|
static void
|
|
end_strterm(parser_state *p)
|
|
{
|
|
parser_lex_strterm *term = p->lex_strterm->prev;
|
|
parser_pfree(p->lex_strterm);
|
|
p->lex_strterm = term;
|
|
}
|
|
|
|
static node*
|
|
push_strterm(parser_state *p)
|
|
{
|
|
node *n = cons((node*)p->lex_strterm, p->parsing_heredoc);
|
|
p->lex_strterm = NULL;
|
|
return n;
|
|
}
|
|
|
|
static void
|
|
pop_strterm(parser_state *p, node *n)
|
|
{
|
|
p->lex_strterm = (parser_lex_strterm*)n->car;
|
|
p->parsing_heredoc = n->cdr;
|
|
cons_free(n);
|
|
}
|
|
|
|
static parser_heredoc_info *
|
|
parsing_heredoc_info(parser_state *p)
|
|
{
|
|
node *nd = p->parsing_heredoc;
|
|
if (nd == NULL) return NULL;
|
|
/* mrb_assert(nd->car->car == NODE_HEREDOC); */
|
|
if (nd->car->car == (node*)NODE_VARIABLE) {
|
|
/* Variable-sized heredoc node - return address of embedded info struct */
|
|
struct mrb_ast_heredoc_node *heredoc = heredoc_node(NODE_VAR_NODE_PTR(nd->car));
|
|
return &heredoc->info;
|
|
}
|
|
return (parser_heredoc_info*)nd->car->cdr;
|
|
}
|
|
|
|
static void
|
|
heredoc_treat_nextline(parser_state *p)
|
|
{
|
|
if (p->heredocs_from_nextline == NULL) return;
|
|
if (p->parsing_heredoc && p->lex_strterm) {
|
|
append(p->heredocs_from_nextline, p->parsing_heredoc);
|
|
}
|
|
p->parsing_heredoc = p->heredocs_from_nextline;
|
|
p->lex_strterm = new_strterm(p, parsing_heredoc_info(p)->type, 0, 0);
|
|
p->heredocs_from_nextline = NULL;
|
|
}
|
|
|
|
static void
|
|
heredoc_end(parser_state *p)
|
|
{
|
|
p->parsing_heredoc = p->parsing_heredoc->cdr;
|
|
if (p->parsing_heredoc == NULL) {
|
|
p->lstate = EXPR_BEG;
|
|
end_strterm(p);
|
|
}
|
|
else {
|
|
/* next heredoc */
|
|
p->lex_strterm->type = parsing_heredoc_info(p)->type;
|
|
}
|
|
}
|
|
#define is_strterm_type(p,str_func) ((p)->lex_strterm->type & (str_func))
|
|
|
|
static void
|
|
prohibit_literals(parser_state *p, node *n)
|
|
{
|
|
if (n == 0) {
|
|
yyerror(NULL, p, "can't define singleton method for ().");
|
|
}
|
|
else {
|
|
switch (node_to_type(n->car)) {
|
|
case NODE_INT:
|
|
case NODE_STR:
|
|
case NODE_XSTR:
|
|
case NODE_DREGX:
|
|
case NODE_MATCH:
|
|
case NODE_FLOAT:
|
|
case NODE_ARRAY:
|
|
case NODE_HEREDOC:
|
|
yyerror(NULL, p, "can't define singleton method for literals");
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* xxx ----------------------------- */
|
|
|
|
|
|
#line 2379 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
|
|
# ifndef YY_CAST
|
|
# ifdef __cplusplus
|
|
# define YY_CAST(Type, Val) static_cast<Type> (Val)
|
|
# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
|
|
# else
|
|
# define YY_CAST(Type, Val) ((Type) (Val))
|
|
# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
|
|
# endif
|
|
# endif
|
|
# ifndef YY_NULLPTR
|
|
# if defined __cplusplus
|
|
# if 201103L <= __cplusplus
|
|
# define YY_NULLPTR nullptr
|
|
# else
|
|
# define YY_NULLPTR 0
|
|
# endif
|
|
# else
|
|
# define YY_NULLPTR ((void*)0)
|
|
# endif
|
|
# endif
|
|
|
|
/* Use api.header.include to #include this header
|
|
instead of duplicating it here. */
|
|
/* Debug traces. */
|
|
#ifndef YYDEBUG
|
|
# define YYDEBUG 0
|
|
#endif
|
|
#if YYDEBUG && !defined(yydebug)
|
|
extern int yydebug;
|
|
#endif
|
|
|
|
|
|
/* Token kinds. */
|
|
#ifndef YYTOKENTYPE
|
|
# define YYTOKENTYPE
|
|
enum yytokentype
|
|
{
|
|
YYEMPTY = -2,
|
|
YYEOF = 0, /* "end of file" */
|
|
YYerror = 256, /* error */
|
|
YYUNDEF = 257, /* "invalid token" */
|
|
keyword_class = 258, /* "'class'" */
|
|
keyword_module = 259, /* "'module'" */
|
|
keyword_def = 260, /* "'def'" */
|
|
keyword_begin = 261, /* "'begin'" */
|
|
keyword_if = 262, /* "'if'" */
|
|
keyword_unless = 263, /* "'unless'" */
|
|
keyword_while = 264, /* "'while'" */
|
|
keyword_until = 265, /* "'until'" */
|
|
keyword_for = 266, /* "'for'" */
|
|
keyword_undef = 267, /* "'undef'" */
|
|
keyword_rescue = 268, /* "'rescue'" */
|
|
keyword_ensure = 269, /* "'ensure'" */
|
|
keyword_end = 270, /* "'end'" */
|
|
keyword_then = 271, /* "'then'" */
|
|
keyword_elsif = 272, /* "'elsif'" */
|
|
keyword_else = 273, /* "'else'" */
|
|
keyword_case = 274, /* "'case'" */
|
|
keyword_when = 275, /* "'when'" */
|
|
keyword_break = 276, /* "'break'" */
|
|
keyword_next = 277, /* "'next'" */
|
|
keyword_redo = 278, /* "'redo'" */
|
|
keyword_retry = 279, /* "'retry'" */
|
|
keyword_in = 280, /* "'in'" */
|
|
keyword_do = 281, /* "'do'" */
|
|
keyword_do_cond = 282, /* "'do' for condition" */
|
|
keyword_do_block = 283, /* "'do' for block" */
|
|
keyword_do_LAMBDA = 284, /* "'do' for lambda" */
|
|
keyword_return = 285, /* "'return'" */
|
|
keyword_yield = 286, /* "'yield'" */
|
|
keyword_super = 287, /* "'super'" */
|
|
keyword_self = 288, /* "'self'" */
|
|
keyword_nil = 289, /* "'nil'" */
|
|
keyword_true = 290, /* "'true'" */
|
|
keyword_false = 291, /* "'false'" */
|
|
keyword_and = 292, /* "'and'" */
|
|
keyword_or = 293, /* "'or'" */
|
|
keyword_not = 294, /* "'not'" */
|
|
modifier_if = 295, /* "'if' modifier" */
|
|
modifier_unless = 296, /* "'unless' modifier" */
|
|
modifier_while = 297, /* "'while' modifier" */
|
|
modifier_until = 298, /* "'until' modifier" */
|
|
modifier_rescue = 299, /* "'rescue' modifier" */
|
|
keyword_alias = 300, /* "'alias'" */
|
|
keyword_BEGIN = 301, /* "'BEGIN'" */
|
|
keyword_END = 302, /* "'END'" */
|
|
keyword__LINE__ = 303, /* "'__LINE__'" */
|
|
keyword__FILE__ = 304, /* "'__FILE__'" */
|
|
keyword__ENCODING__ = 305, /* "'__ENCODING__'" */
|
|
tIDENTIFIER = 306, /* "local variable or method" */
|
|
tFID = 307, /* "method" */
|
|
tGVAR = 308, /* "global variable" */
|
|
tIVAR = 309, /* "instance variable" */
|
|
tCONSTANT = 310, /* "constant" */
|
|
tCVAR = 311, /* "class variable" */
|
|
tLABEL_TAG = 312, /* "label" */
|
|
tINTEGER = 313, /* "integer literal" */
|
|
tFLOAT = 314, /* "float literal" */
|
|
tCHAR = 315, /* "character literal" */
|
|
tXSTRING = 316, /* tXSTRING */
|
|
tREGEXP = 317, /* tREGEXP */
|
|
tSTRING = 318, /* tSTRING */
|
|
tSTRING_PART = 319, /* tSTRING_PART */
|
|
tSTRING_MID = 320, /* tSTRING_MID */
|
|
tNTH_REF = 321, /* tNTH_REF */
|
|
tBACK_REF = 322, /* tBACK_REF */
|
|
tREGEXP_END = 323, /* tREGEXP_END */
|
|
tNUMPARAM = 324, /* "numbered parameter" */
|
|
tUPLUS = 325, /* "unary plus" */
|
|
tUMINUS = 326, /* "unary minus" */
|
|
tCMP = 327, /* "<=>" */
|
|
tEQ = 328, /* "==" */
|
|
tEQQ = 329, /* "===" */
|
|
tNEQ = 330, /* "!=" */
|
|
tGEQ = 331, /* ">=" */
|
|
tLEQ = 332, /* "<=" */
|
|
tANDOP = 333, /* "&&" */
|
|
tOROP = 334, /* "||" */
|
|
tMATCH = 335, /* "=~" */
|
|
tNMATCH = 336, /* "!~" */
|
|
tDOT2 = 337, /* ".." */
|
|
tDOT3 = 338, /* "..." */
|
|
tBDOT2 = 339, /* tBDOT2 */
|
|
tBDOT3 = 340, /* tBDOT3 */
|
|
tAREF = 341, /* tAREF */
|
|
tASET = 342, /* tASET */
|
|
tLSHFT = 343, /* "<<" */
|
|
tRSHFT = 344, /* ">>" */
|
|
tCOLON2 = 345, /* "::" */
|
|
tCOLON3 = 346, /* tCOLON3 */
|
|
tOP_ASGN = 347, /* tOP_ASGN */
|
|
tASSOC = 348, /* "=>" */
|
|
tLPAREN = 349, /* tLPAREN */
|
|
tLPAREN_ARG = 350, /* "(" */
|
|
tRPAREN = 351, /* ")" */
|
|
tLBRACK = 352, /* "[" */
|
|
tLBRACE = 353, /* tLBRACE */
|
|
tLBRACE_ARG = 354, /* "{" */
|
|
tSTAR = 355, /* "*" */
|
|
tPOW = 356, /* tPOW */
|
|
tDSTAR = 357, /* "**" */
|
|
tAMPER = 358, /* "&" */
|
|
tLAMBDA = 359, /* "->" */
|
|
tANDDOT = 360, /* "&." */
|
|
tSYMBEG = 361, /* "symbol" */
|
|
tSTRING_BEG = 362, /* "string literal" */
|
|
tXSTRING_BEG = 363, /* tXSTRING_BEG */
|
|
tSTRING_DVAR = 364, /* tSTRING_DVAR */
|
|
tREGEXP_BEG = 365, /* tREGEXP_BEG */
|
|
tWORDS_BEG = 366, /* tWORDS_BEG */
|
|
tSYMBOLS_BEG = 367, /* tSYMBOLS_BEG */
|
|
tLAMBEG = 368, /* tLAMBEG */
|
|
tHEREDOC_BEG = 369, /* "here document" */
|
|
tHEREDOC_END = 370, /* tHEREDOC_END */
|
|
tLITERAL_DELIM = 371, /* tLITERAL_DELIM */
|
|
tHD_LITERAL_DELIM = 372, /* tHD_LITERAL_DELIM */
|
|
tHD_STRING_PART = 373, /* tHD_STRING_PART */
|
|
tHD_STRING_MID = 374, /* tHD_STRING_MID */
|
|
tLOWEST = 375, /* tLOWEST */
|
|
tUMINUS_NUM = 376, /* tUMINUS_NUM */
|
|
tLAST_TOKEN = 377 /* tLAST_TOKEN */
|
|
};
|
|
typedef enum yytokentype yytoken_kind_t;
|
|
#endif
|
|
|
|
/* Value type. */
|
|
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
|
|
union YYSTYPE
|
|
{
|
|
#line 2322 "mrbgems/mruby-compiler/core/parse.y"
|
|
|
|
node *nd;
|
|
mrb_sym id;
|
|
int num;
|
|
stack_type stack;
|
|
const struct vtable *vars;
|
|
|
|
#line 2558 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
|
|
};
|
|
typedef union YYSTYPE YYSTYPE;
|
|
# define YYSTYPE_IS_TRIVIAL 1
|
|
# define YYSTYPE_IS_DECLARED 1
|
|
#endif
|
|
|
|
/* Location type. */
|
|
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
|
|
typedef struct YYLTYPE YYLTYPE;
|
|
struct YYLTYPE
|
|
{
|
|
int first_line;
|
|
int first_column;
|
|
int last_line;
|
|
int last_column;
|
|
};
|
|
# define YYLTYPE_IS_DECLARED 1
|
|
# define YYLTYPE_IS_TRIVIAL 1
|
|
#endif
|
|
|
|
|
|
|
|
|
|
int yyparse (parser_state *p);
|
|
|
|
|
|
|
|
|
|
/* Symbol kind. */
|
|
enum yysymbol_kind_t
|
|
{
|
|
YYSYMBOL_YYEMPTY = -2,
|
|
YYSYMBOL_YYEOF = 0, /* "end of file" */
|
|
YYSYMBOL_YYerror = 1, /* error */
|
|
YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
|
|
YYSYMBOL_keyword_class = 3, /* "'class'" */
|
|
YYSYMBOL_keyword_module = 4, /* "'module'" */
|
|
YYSYMBOL_keyword_def = 5, /* "'def'" */
|
|
YYSYMBOL_keyword_begin = 6, /* "'begin'" */
|
|
YYSYMBOL_keyword_if = 7, /* "'if'" */
|
|
YYSYMBOL_keyword_unless = 8, /* "'unless'" */
|
|
YYSYMBOL_keyword_while = 9, /* "'while'" */
|
|
YYSYMBOL_keyword_until = 10, /* "'until'" */
|
|
YYSYMBOL_keyword_for = 11, /* "'for'" */
|
|
YYSYMBOL_keyword_undef = 12, /* "'undef'" */
|
|
YYSYMBOL_keyword_rescue = 13, /* "'rescue'" */
|
|
YYSYMBOL_keyword_ensure = 14, /* "'ensure'" */
|
|
YYSYMBOL_keyword_end = 15, /* "'end'" */
|
|
YYSYMBOL_keyword_then = 16, /* "'then'" */
|
|
YYSYMBOL_keyword_elsif = 17, /* "'elsif'" */
|
|
YYSYMBOL_keyword_else = 18, /* "'else'" */
|
|
YYSYMBOL_keyword_case = 19, /* "'case'" */
|
|
YYSYMBOL_keyword_when = 20, /* "'when'" */
|
|
YYSYMBOL_keyword_break = 21, /* "'break'" */
|
|
YYSYMBOL_keyword_next = 22, /* "'next'" */
|
|
YYSYMBOL_keyword_redo = 23, /* "'redo'" */
|
|
YYSYMBOL_keyword_retry = 24, /* "'retry'" */
|
|
YYSYMBOL_keyword_in = 25, /* "'in'" */
|
|
YYSYMBOL_keyword_do = 26, /* "'do'" */
|
|
YYSYMBOL_keyword_do_cond = 27, /* "'do' for condition" */
|
|
YYSYMBOL_keyword_do_block = 28, /* "'do' for block" */
|
|
YYSYMBOL_keyword_do_LAMBDA = 29, /* "'do' for lambda" */
|
|
YYSYMBOL_keyword_return = 30, /* "'return'" */
|
|
YYSYMBOL_keyword_yield = 31, /* "'yield'" */
|
|
YYSYMBOL_keyword_super = 32, /* "'super'" */
|
|
YYSYMBOL_keyword_self = 33, /* "'self'" */
|
|
YYSYMBOL_keyword_nil = 34, /* "'nil'" */
|
|
YYSYMBOL_keyword_true = 35, /* "'true'" */
|
|
YYSYMBOL_keyword_false = 36, /* "'false'" */
|
|
YYSYMBOL_keyword_and = 37, /* "'and'" */
|
|
YYSYMBOL_keyword_or = 38, /* "'or'" */
|
|
YYSYMBOL_keyword_not = 39, /* "'not'" */
|
|
YYSYMBOL_modifier_if = 40, /* "'if' modifier" */
|
|
YYSYMBOL_modifier_unless = 41, /* "'unless' modifier" */
|
|
YYSYMBOL_modifier_while = 42, /* "'while' modifier" */
|
|
YYSYMBOL_modifier_until = 43, /* "'until' modifier" */
|
|
YYSYMBOL_modifier_rescue = 44, /* "'rescue' modifier" */
|
|
YYSYMBOL_keyword_alias = 45, /* "'alias'" */
|
|
YYSYMBOL_keyword_BEGIN = 46, /* "'BEGIN'" */
|
|
YYSYMBOL_keyword_END = 47, /* "'END'" */
|
|
YYSYMBOL_keyword__LINE__ = 48, /* "'__LINE__'" */
|
|
YYSYMBOL_keyword__FILE__ = 49, /* "'__FILE__'" */
|
|
YYSYMBOL_keyword__ENCODING__ = 50, /* "'__ENCODING__'" */
|
|
YYSYMBOL_tIDENTIFIER = 51, /* "local variable or method" */
|
|
YYSYMBOL_tFID = 52, /* "method" */
|
|
YYSYMBOL_tGVAR = 53, /* "global variable" */
|
|
YYSYMBOL_tIVAR = 54, /* "instance variable" */
|
|
YYSYMBOL_tCONSTANT = 55, /* "constant" */
|
|
YYSYMBOL_tCVAR = 56, /* "class variable" */
|
|
YYSYMBOL_tLABEL_TAG = 57, /* "label" */
|
|
YYSYMBOL_tINTEGER = 58, /* "integer literal" */
|
|
YYSYMBOL_tFLOAT = 59, /* "float literal" */
|
|
YYSYMBOL_tCHAR = 60, /* "character literal" */
|
|
YYSYMBOL_tXSTRING = 61, /* tXSTRING */
|
|
YYSYMBOL_tREGEXP = 62, /* tREGEXP */
|
|
YYSYMBOL_tSTRING = 63, /* tSTRING */
|
|
YYSYMBOL_tSTRING_PART = 64, /* tSTRING_PART */
|
|
YYSYMBOL_tSTRING_MID = 65, /* tSTRING_MID */
|
|
YYSYMBOL_tNTH_REF = 66, /* tNTH_REF */
|
|
YYSYMBOL_tBACK_REF = 67, /* tBACK_REF */
|
|
YYSYMBOL_tREGEXP_END = 68, /* tREGEXP_END */
|
|
YYSYMBOL_tNUMPARAM = 69, /* "numbered parameter" */
|
|
YYSYMBOL_tUPLUS = 70, /* "unary plus" */
|
|
YYSYMBOL_tUMINUS = 71, /* "unary minus" */
|
|
YYSYMBOL_tCMP = 72, /* "<=>" */
|
|
YYSYMBOL_tEQ = 73, /* "==" */
|
|
YYSYMBOL_tEQQ = 74, /* "===" */
|
|
YYSYMBOL_tNEQ = 75, /* "!=" */
|
|
YYSYMBOL_tGEQ = 76, /* ">=" */
|
|
YYSYMBOL_tLEQ = 77, /* "<=" */
|
|
YYSYMBOL_tANDOP = 78, /* "&&" */
|
|
YYSYMBOL_tOROP = 79, /* "||" */
|
|
YYSYMBOL_tMATCH = 80, /* "=~" */
|
|
YYSYMBOL_tNMATCH = 81, /* "!~" */
|
|
YYSYMBOL_tDOT2 = 82, /* ".." */
|
|
YYSYMBOL_tDOT3 = 83, /* "..." */
|
|
YYSYMBOL_tBDOT2 = 84, /* tBDOT2 */
|
|
YYSYMBOL_tBDOT3 = 85, /* tBDOT3 */
|
|
YYSYMBOL_tAREF = 86, /* tAREF */
|
|
YYSYMBOL_tASET = 87, /* tASET */
|
|
YYSYMBOL_tLSHFT = 88, /* "<<" */
|
|
YYSYMBOL_tRSHFT = 89, /* ">>" */
|
|
YYSYMBOL_tCOLON2 = 90, /* "::" */
|
|
YYSYMBOL_tCOLON3 = 91, /* tCOLON3 */
|
|
YYSYMBOL_tOP_ASGN = 92, /* tOP_ASGN */
|
|
YYSYMBOL_tASSOC = 93, /* "=>" */
|
|
YYSYMBOL_tLPAREN = 94, /* tLPAREN */
|
|
YYSYMBOL_tLPAREN_ARG = 95, /* "(" */
|
|
YYSYMBOL_tRPAREN = 96, /* ")" */
|
|
YYSYMBOL_tLBRACK = 97, /* "[" */
|
|
YYSYMBOL_tLBRACE = 98, /* tLBRACE */
|
|
YYSYMBOL_tLBRACE_ARG = 99, /* "{" */
|
|
YYSYMBOL_tSTAR = 100, /* "*" */
|
|
YYSYMBOL_tPOW = 101, /* tPOW */
|
|
YYSYMBOL_tDSTAR = 102, /* "**" */
|
|
YYSYMBOL_tAMPER = 103, /* "&" */
|
|
YYSYMBOL_tLAMBDA = 104, /* "->" */
|
|
YYSYMBOL_tANDDOT = 105, /* "&." */
|
|
YYSYMBOL_tSYMBEG = 106, /* "symbol" */
|
|
YYSYMBOL_tSTRING_BEG = 107, /* "string literal" */
|
|
YYSYMBOL_tXSTRING_BEG = 108, /* tXSTRING_BEG */
|
|
YYSYMBOL_tSTRING_DVAR = 109, /* tSTRING_DVAR */
|
|
YYSYMBOL_tREGEXP_BEG = 110, /* tREGEXP_BEG */
|
|
YYSYMBOL_tWORDS_BEG = 111, /* tWORDS_BEG */
|
|
YYSYMBOL_tSYMBOLS_BEG = 112, /* tSYMBOLS_BEG */
|
|
YYSYMBOL_tLAMBEG = 113, /* tLAMBEG */
|
|
YYSYMBOL_tHEREDOC_BEG = 114, /* "here document" */
|
|
YYSYMBOL_tHEREDOC_END = 115, /* tHEREDOC_END */
|
|
YYSYMBOL_tLITERAL_DELIM = 116, /* tLITERAL_DELIM */
|
|
YYSYMBOL_tHD_LITERAL_DELIM = 117, /* tHD_LITERAL_DELIM */
|
|
YYSYMBOL_tHD_STRING_PART = 118, /* tHD_STRING_PART */
|
|
YYSYMBOL_tHD_STRING_MID = 119, /* tHD_STRING_MID */
|
|
YYSYMBOL_tLOWEST = 120, /* tLOWEST */
|
|
YYSYMBOL_121_ = 121, /* '=' */
|
|
YYSYMBOL_122_ = 122, /* '?' */
|
|
YYSYMBOL_123_ = 123, /* ':' */
|
|
YYSYMBOL_124_ = 124, /* '>' */
|
|
YYSYMBOL_125_ = 125, /* '<' */
|
|
YYSYMBOL_126_ = 126, /* '|' */
|
|
YYSYMBOL_127_ = 127, /* '^' */
|
|
YYSYMBOL_128_ = 128, /* '&' */
|
|
YYSYMBOL_129_ = 129, /* '+' */
|
|
YYSYMBOL_130_ = 130, /* '-' */
|
|
YYSYMBOL_131_ = 131, /* '*' */
|
|
YYSYMBOL_132_ = 132, /* '/' */
|
|
YYSYMBOL_133_ = 133, /* '%' */
|
|
YYSYMBOL_tUMINUS_NUM = 134, /* tUMINUS_NUM */
|
|
YYSYMBOL_135_ = 135, /* '!' */
|
|
YYSYMBOL_136_ = 136, /* '~' */
|
|
YYSYMBOL_tLAST_TOKEN = 137, /* tLAST_TOKEN */
|
|
YYSYMBOL_138_ = 138, /* '{' */
|
|
YYSYMBOL_139_ = 139, /* '}' */
|
|
YYSYMBOL_140_ = 140, /* '[' */
|
|
YYSYMBOL_141_ = 141, /* ']' */
|
|
YYSYMBOL_142_ = 142, /* ',' */
|
|
YYSYMBOL_143_ = 143, /* '`' */
|
|
YYSYMBOL_144_ = 144, /* '(' */
|
|
YYSYMBOL_145_ = 145, /* ')' */
|
|
YYSYMBOL_146_ = 146, /* ';' */
|
|
YYSYMBOL_147_ = 147, /* '.' */
|
|
YYSYMBOL_148_n_ = 148, /* '\n' */
|
|
YYSYMBOL_YYACCEPT = 149, /* $accept */
|
|
YYSYMBOL_150_1 = 150, /* $@1 */
|
|
YYSYMBOL_program = 151, /* program */
|
|
YYSYMBOL_top_compstmt = 152, /* top_compstmt */
|
|
YYSYMBOL_top_stmts = 153, /* top_stmts */
|
|
YYSYMBOL_top_stmt = 154, /* top_stmt */
|
|
YYSYMBOL_155_2 = 155, /* @2 */
|
|
YYSYMBOL_bodystmt = 156, /* bodystmt */
|
|
YYSYMBOL_compstmt = 157, /* compstmt */
|
|
YYSYMBOL_stmts = 158, /* stmts */
|
|
YYSYMBOL_159_3 = 159, /* $@3 */
|
|
YYSYMBOL_stmt = 160, /* stmt */
|
|
YYSYMBOL_command_asgn = 161, /* command_asgn */
|
|
YYSYMBOL_command_rhs = 162, /* command_rhs */
|
|
YYSYMBOL_expr = 163, /* expr */
|
|
YYSYMBOL_defn_head = 164, /* defn_head */
|
|
YYSYMBOL_165_4 = 165, /* $@4 */
|
|
YYSYMBOL_defs_head = 166, /* defs_head */
|
|
YYSYMBOL_expr_value = 167, /* expr_value */
|
|
YYSYMBOL_command_call = 168, /* command_call */
|
|
YYSYMBOL_block_command = 169, /* block_command */
|
|
YYSYMBOL_170_5 = 170, /* $@5 */
|
|
YYSYMBOL_cmd_brace_block = 171, /* cmd_brace_block */
|
|
YYSYMBOL_command = 172, /* command */
|
|
YYSYMBOL_mlhs = 173, /* mlhs */
|
|
YYSYMBOL_mlhs_inner = 174, /* mlhs_inner */
|
|
YYSYMBOL_mlhs_basic = 175, /* mlhs_basic */
|
|
YYSYMBOL_mlhs_item = 176, /* mlhs_item */
|
|
YYSYMBOL_mlhs_list = 177, /* mlhs_list */
|
|
YYSYMBOL_mlhs_post = 178, /* mlhs_post */
|
|
YYSYMBOL_mlhs_node = 179, /* mlhs_node */
|
|
YYSYMBOL_lhs = 180, /* lhs */
|
|
YYSYMBOL_cname = 181, /* cname */
|
|
YYSYMBOL_cpath = 182, /* cpath */
|
|
YYSYMBOL_fname = 183, /* fname */
|
|
YYSYMBOL_fsym = 184, /* fsym */
|
|
YYSYMBOL_undef_list = 185, /* undef_list */
|
|
YYSYMBOL_186_6 = 186, /* $@6 */
|
|
YYSYMBOL_op = 187, /* op */
|
|
YYSYMBOL_reswords = 188, /* reswords */
|
|
YYSYMBOL_arg = 189, /* arg */
|
|
YYSYMBOL_aref_args = 190, /* aref_args */
|
|
YYSYMBOL_arg_rhs = 191, /* arg_rhs */
|
|
YYSYMBOL_paren_args = 192, /* paren_args */
|
|
YYSYMBOL_opt_paren_args = 193, /* opt_paren_args */
|
|
YYSYMBOL_opt_call_args = 194, /* opt_call_args */
|
|
YYSYMBOL_call_args = 195, /* call_args */
|
|
YYSYMBOL_196_7 = 196, /* @7 */
|
|
YYSYMBOL_command_args = 197, /* command_args */
|
|
YYSYMBOL_block_arg = 198, /* block_arg */
|
|
YYSYMBOL_opt_block_arg = 199, /* opt_block_arg */
|
|
YYSYMBOL_comma = 200, /* comma */
|
|
YYSYMBOL_args = 201, /* args */
|
|
YYSYMBOL_mrhs = 202, /* mrhs */
|
|
YYSYMBOL_primary = 203, /* primary */
|
|
YYSYMBOL_204_8 = 204, /* @8 */
|
|
YYSYMBOL_205_9 = 205, /* @9 */
|
|
YYSYMBOL_206_10 = 206, /* $@10 */
|
|
YYSYMBOL_207_11 = 207, /* $@11 */
|
|
YYSYMBOL_208_12 = 208, /* @12 */
|
|
YYSYMBOL_209_13 = 209, /* @13 */
|
|
YYSYMBOL_210_14 = 210, /* $@14 */
|
|
YYSYMBOL_211_15 = 211, /* $@15 */
|
|
YYSYMBOL_212_16 = 212, /* $@16 */
|
|
YYSYMBOL_213_17 = 213, /* $@17 */
|
|
YYSYMBOL_214_18 = 214, /* $@18 */
|
|
YYSYMBOL_215_19 = 215, /* $@19 */
|
|
YYSYMBOL_216_20 = 216, /* @20 */
|
|
YYSYMBOL_217_21 = 217, /* @21 */
|
|
YYSYMBOL_218_22 = 218, /* @22 */
|
|
YYSYMBOL_219_23 = 219, /* @23 */
|
|
YYSYMBOL_primary_value = 220, /* primary_value */
|
|
YYSYMBOL_then = 221, /* then */
|
|
YYSYMBOL_do = 222, /* do */
|
|
YYSYMBOL_if_tail = 223, /* if_tail */
|
|
YYSYMBOL_opt_else = 224, /* opt_else */
|
|
YYSYMBOL_for_var = 225, /* for_var */
|
|
YYSYMBOL_f_margs = 226, /* f_margs */
|
|
YYSYMBOL_227_24 = 227, /* $@24 */
|
|
YYSYMBOL_block_args_tail = 228, /* block_args_tail */
|
|
YYSYMBOL_opt_block_args_tail = 229, /* opt_block_args_tail */
|
|
YYSYMBOL_block_param = 230, /* block_param */
|
|
YYSYMBOL_opt_block_param = 231, /* opt_block_param */
|
|
YYSYMBOL_232_25 = 232, /* $@25 */
|
|
YYSYMBOL_block_param_def = 233, /* block_param_def */
|
|
YYSYMBOL_opt_bv_decl = 234, /* opt_bv_decl */
|
|
YYSYMBOL_bv_decls = 235, /* bv_decls */
|
|
YYSYMBOL_bvar = 236, /* bvar */
|
|
YYSYMBOL_f_larglist = 237, /* f_larglist */
|
|
YYSYMBOL_lambda_body = 238, /* lambda_body */
|
|
YYSYMBOL_239_26 = 239, /* @26 */
|
|
YYSYMBOL_do_block = 240, /* do_block */
|
|
YYSYMBOL_block_call = 241, /* block_call */
|
|
YYSYMBOL_method_call = 242, /* method_call */
|
|
YYSYMBOL_243_27 = 243, /* @27 */
|
|
YYSYMBOL_brace_block = 244, /* brace_block */
|
|
YYSYMBOL_245_28 = 245, /* @28 */
|
|
YYSYMBOL_case_body = 246, /* case_body */
|
|
YYSYMBOL_cases = 247, /* cases */
|
|
YYSYMBOL_opt_rescue = 248, /* opt_rescue */
|
|
YYSYMBOL_exc_list = 249, /* exc_list */
|
|
YYSYMBOL_exc_var = 250, /* exc_var */
|
|
YYSYMBOL_opt_ensure = 251, /* opt_ensure */
|
|
YYSYMBOL_literal = 252, /* literal */
|
|
YYSYMBOL_string = 253, /* string */
|
|
YYSYMBOL_string_fragment = 254, /* string_fragment */
|
|
YYSYMBOL_string_rep = 255, /* string_rep */
|
|
YYSYMBOL_string_interp = 256, /* string_interp */
|
|
YYSYMBOL_257_29 = 257, /* @29 */
|
|
YYSYMBOL_xstring = 258, /* xstring */
|
|
YYSYMBOL_regexp = 259, /* regexp */
|
|
YYSYMBOL_heredoc = 260, /* heredoc */
|
|
YYSYMBOL_heredoc_bodies = 261, /* heredoc_bodies */
|
|
YYSYMBOL_heredoc_body = 262, /* heredoc_body */
|
|
YYSYMBOL_heredoc_string_rep = 263, /* heredoc_string_rep */
|
|
YYSYMBOL_heredoc_string_interp = 264, /* heredoc_string_interp */
|
|
YYSYMBOL_265_30 = 265, /* @30 */
|
|
YYSYMBOL_words = 266, /* words */
|
|
YYSYMBOL_symbol = 267, /* symbol */
|
|
YYSYMBOL_basic_symbol = 268, /* basic_symbol */
|
|
YYSYMBOL_sym = 269, /* sym */
|
|
YYSYMBOL_symbols = 270, /* symbols */
|
|
YYSYMBOL_numeric = 271, /* numeric */
|
|
YYSYMBOL_variable = 272, /* variable */
|
|
YYSYMBOL_var_lhs = 273, /* var_lhs */
|
|
YYSYMBOL_var_ref = 274, /* var_ref */
|
|
YYSYMBOL_backref = 275, /* backref */
|
|
YYSYMBOL_superclass = 276, /* superclass */
|
|
YYSYMBOL_277_31 = 277, /* $@31 */
|
|
YYSYMBOL_f_opt_arglist_paren = 278, /* f_opt_arglist_paren */
|
|
YYSYMBOL_f_arglist_paren = 279, /* f_arglist_paren */
|
|
YYSYMBOL_f_arglist = 280, /* f_arglist */
|
|
YYSYMBOL_f_label = 281, /* f_label */
|
|
YYSYMBOL_f_kw = 282, /* f_kw */
|
|
YYSYMBOL_f_block_kw = 283, /* f_block_kw */
|
|
YYSYMBOL_f_block_kwarg = 284, /* f_block_kwarg */
|
|
YYSYMBOL_f_kwarg = 285, /* f_kwarg */
|
|
YYSYMBOL_kwrest_mark = 286, /* kwrest_mark */
|
|
YYSYMBOL_f_kwrest = 287, /* f_kwrest */
|
|
YYSYMBOL_args_tail = 288, /* args_tail */
|
|
YYSYMBOL_opt_args_tail = 289, /* opt_args_tail */
|
|
YYSYMBOL_f_args = 290, /* f_args */
|
|
YYSYMBOL_f_bad_arg = 291, /* f_bad_arg */
|
|
YYSYMBOL_f_norm_arg = 292, /* f_norm_arg */
|
|
YYSYMBOL_f_arg_item = 293, /* f_arg_item */
|
|
YYSYMBOL_294_32 = 294, /* @32 */
|
|
YYSYMBOL_f_arg = 295, /* f_arg */
|
|
YYSYMBOL_f_opt_asgn = 296, /* f_opt_asgn */
|
|
YYSYMBOL_f_opt = 297, /* f_opt */
|
|
YYSYMBOL_f_block_opt = 298, /* f_block_opt */
|
|
YYSYMBOL_f_block_optarg = 299, /* f_block_optarg */
|
|
YYSYMBOL_f_optarg = 300, /* f_optarg */
|
|
YYSYMBOL_restarg_mark = 301, /* restarg_mark */
|
|
YYSYMBOL_f_rest_arg = 302, /* f_rest_arg */
|
|
YYSYMBOL_blkarg_mark = 303, /* blkarg_mark */
|
|
YYSYMBOL_f_block_arg = 304, /* f_block_arg */
|
|
YYSYMBOL_opt_f_block_arg = 305, /* opt_f_block_arg */
|
|
YYSYMBOL_singleton = 306, /* singleton */
|
|
YYSYMBOL_307_33 = 307, /* $@33 */
|
|
YYSYMBOL_assoc_list = 308, /* assoc_list */
|
|
YYSYMBOL_assocs = 309, /* assocs */
|
|
YYSYMBOL_assoc = 310, /* assoc */
|
|
YYSYMBOL_operation = 311, /* operation */
|
|
YYSYMBOL_operation2 = 312, /* operation2 */
|
|
YYSYMBOL_operation3 = 313, /* operation3 */
|
|
YYSYMBOL_dot_or_colon = 314, /* dot_or_colon */
|
|
YYSYMBOL_call_op = 315, /* call_op */
|
|
YYSYMBOL_call_op2 = 316, /* call_op2 */
|
|
YYSYMBOL_opt_terms = 317, /* opt_terms */
|
|
YYSYMBOL_opt_nl = 318, /* opt_nl */
|
|
YYSYMBOL_rparen = 319, /* rparen */
|
|
YYSYMBOL_trailer = 320, /* trailer */
|
|
YYSYMBOL_term = 321, /* term */
|
|
YYSYMBOL_nl = 322, /* nl */
|
|
YYSYMBOL_terms = 323, /* terms */
|
|
YYSYMBOL_none = 324 /* none */
|
|
};
|
|
typedef enum yysymbol_kind_t yysymbol_kind_t;
|
|
|
|
|
|
|
|
|
|
#ifdef short
|
|
# undef short
|
|
#endif
|
|
|
|
/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
|
|
<limits.h> and (if available) <stdint.h> are included
|
|
so that the code can choose integer types of a good width. */
|
|
|
|
#ifndef __PTRDIFF_MAX__
|
|
# include <limits.h> /* INFRINGES ON USER NAME SPACE */
|
|
# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
|
|
# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
|
|
# define YY_STDINT_H
|
|
# endif
|
|
#endif
|
|
|
|
/* Narrow types that promote to a signed type and that can represent a
|
|
signed or unsigned integer of at least N bits. In tables they can
|
|
save space and decrease cache pressure. Promoting to a signed type
|
|
helps avoid bugs in integer arithmetic. */
|
|
|
|
#ifdef __INT_LEAST8_MAX__
|
|
typedef __INT_LEAST8_TYPE__ yytype_int8;
|
|
#elif defined YY_STDINT_H
|
|
typedef int_least8_t yytype_int8;
|
|
#else
|
|
typedef signed char yytype_int8;
|
|
#endif
|
|
|
|
#ifdef __INT_LEAST16_MAX__
|
|
typedef __INT_LEAST16_TYPE__ yytype_int16;
|
|
#elif defined YY_STDINT_H
|
|
typedef int_least16_t yytype_int16;
|
|
#else
|
|
typedef short yytype_int16;
|
|
#endif
|
|
|
|
/* Work around bug in HP-UX 11.23, which defines these macros
|
|
incorrectly for preprocessor constants. This workaround can likely
|
|
be removed in 2023, as HPE has promised support for HP-UX 11.23
|
|
(aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
|
|
<https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
|
|
#ifdef __hpux
|
|
# undef UINT_LEAST8_MAX
|
|
# undef UINT_LEAST16_MAX
|
|
# define UINT_LEAST8_MAX 255
|
|
# define UINT_LEAST16_MAX 65535
|
|
#endif
|
|
|
|
#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
|
|
typedef __UINT_LEAST8_TYPE__ yytype_uint8;
|
|
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
|
|
&& UINT_LEAST8_MAX <= INT_MAX)
|
|
typedef uint_least8_t yytype_uint8;
|
|
#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
|
|
typedef unsigned char yytype_uint8;
|
|
#else
|
|
typedef short yytype_uint8;
|
|
#endif
|
|
|
|
#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
|
|
typedef __UINT_LEAST16_TYPE__ yytype_uint16;
|
|
#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
|
|
&& UINT_LEAST16_MAX <= INT_MAX)
|
|
typedef uint_least16_t yytype_uint16;
|
|
#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
|
|
typedef unsigned short yytype_uint16;
|
|
#else
|
|
typedef int yytype_uint16;
|
|
#endif
|
|
|
|
#ifndef YYPTRDIFF_T
|
|
# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
|
|
# define YYPTRDIFF_T __PTRDIFF_TYPE__
|
|
# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
|
|
# elif defined PTRDIFF_MAX
|
|
# ifndef ptrdiff_t
|
|
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
|
|
# endif
|
|
# define YYPTRDIFF_T ptrdiff_t
|
|
# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
|
|
# else
|
|
# define YYPTRDIFF_T long
|
|
# define YYPTRDIFF_MAXIMUM LONG_MAX
|
|
# endif
|
|
#endif
|
|
|
|
#ifndef YYSIZE_T
|
|
# ifdef __SIZE_TYPE__
|
|
# define YYSIZE_T __SIZE_TYPE__
|
|
# elif defined size_t
|
|
# define YYSIZE_T size_t
|
|
# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
|
|
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
|
|
# define YYSIZE_T size_t
|
|
# else
|
|
# define YYSIZE_T unsigned
|
|
# endif
|
|
#endif
|
|
|
|
#define YYSIZE_MAXIMUM \
|
|
YY_CAST (YYPTRDIFF_T, \
|
|
(YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
|
|
? YYPTRDIFF_MAXIMUM \
|
|
: YY_CAST (YYSIZE_T, -1)))
|
|
|
|
#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
|
|
|
|
|
|
/* Stored state numbers (used for stacks). */
|
|
typedef yytype_int16 yy_state_t;
|
|
|
|
/* State numbers in computations. */
|
|
typedef int yy_state_fast_t;
|
|
|
|
#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
|
|
|
|
|
|
#ifndef YY_ATTRIBUTE_PURE
|
|
# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
|
|
# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
|
|
# else
|
|
# define YY_ATTRIBUTE_PURE
|
|
# endif
|
|
#endif
|
|
|
|
#ifndef YY_ATTRIBUTE_UNUSED
|
|
# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
|
|
# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
|
|
# else
|
|
# define YY_ATTRIBUTE_UNUSED
|
|
# endif
|
|
#endif
|
|
|
|
/* Suppress unused-variable warnings by "using" E. */
|
|
#if ! defined lint || defined __GNUC__
|
|
# define YY_USE(E) ((void) (E))
|
|
#else
|
|
# define YY_USE(E) /* empty */
|
|
#endif
|
|
|
|
/* Suppress an incorrect diagnostic about yylval being uninitialized. */
|
|
#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
|
|
# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
|
|
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
|
|
_Pragma ("GCC diagnostic push") \
|
|
_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
|
|
# else
|
|
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
|
|
_Pragma ("GCC diagnostic push") \
|
|
_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
|
|
_Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
|
|
# endif
|
|
# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
|
|
_Pragma ("GCC diagnostic pop")
|
|
#else
|
|
# define YY_INITIAL_VALUE(Value) Value
|
|
#endif
|
|
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
|
|
#endif
|
|
#ifndef YY_INITIAL_VALUE
|
|
# define YY_INITIAL_VALUE(Value) /* Nothing. */
|
|
#endif
|
|
|
|
#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
|
|
# define YY_IGNORE_USELESS_CAST_BEGIN \
|
|
_Pragma ("GCC diagnostic push") \
|
|
_Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
|
|
# define YY_IGNORE_USELESS_CAST_END \
|
|
_Pragma ("GCC diagnostic pop")
|
|
#endif
|
|
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
|
|
# define YY_IGNORE_USELESS_CAST_BEGIN
|
|
# define YY_IGNORE_USELESS_CAST_END
|
|
#endif
|
|
|
|
|
|
#define YY_ASSERT(E) ((void) (0 && (E)))
|
|
|
|
#if 1
|
|
|
|
/* 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
|
|
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
|
|
/* Use EXIT_SUCCESS as a witness for stdlib.h. */
|
|
# 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 (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
|
|
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
|
|
# endif
|
|
# endif
|
|
# ifndef YYFREE
|
|
# define YYFREE free
|
|
# if ! defined free && ! defined EXIT_SUCCESS
|
|
void free (void *); /* INFRINGES ON USER NAME SPACE */
|
|
# endif
|
|
# endif
|
|
# endif
|
|
#endif /* 1 */
|
|
|
|
#if (! defined yyoverflow \
|
|
&& (! defined __cplusplus \
|
|
|| (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
|
|
&& defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
|
|
|
|
/* A type that is properly aligned for any stack member. */
|
|
union yyalloc
|
|
{
|
|
yy_state_t yyss_alloc;
|
|
YYSTYPE yyvs_alloc;
|
|
YYLTYPE yyls_alloc;
|
|
};
|
|
|
|
/* The size of the maximum gap between one aligned stack and the next. */
|
|
# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
|
|
|
|
/* The size of an array large to enough to hold all stacks, each with
|
|
N elements. */
|
|
# define YYSTACK_BYTES(N) \
|
|
((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
|
|
+ YYSIZEOF (YYLTYPE)) \
|
|
+ 2 * 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 \
|
|
{ \
|
|
YYPTRDIFF_T yynewbytes; \
|
|
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
|
|
Stack = &yyptr->Stack_alloc; \
|
|
yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
|
|
yyptr += yynewbytes / YYSIZEOF (*yyptr); \
|
|
} \
|
|
while (0)
|
|
|
|
#endif
|
|
|
|
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
|
|
/* Copy COUNT objects from SRC to DST. The source and destination do
|
|
not overlap. */
|
|
# ifndef YYCOPY
|
|
# if defined __GNUC__ && 1 < __GNUC__
|
|
# define YYCOPY(Dst, Src, Count) \
|
|
__builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
|
|
# else
|
|
# define YYCOPY(Dst, Src, Count) \
|
|
do \
|
|
{ \
|
|
YYPTRDIFF_T yyi; \
|
|
for (yyi = 0; yyi < (Count); yyi++) \
|
|
(Dst)[yyi] = (Src)[yyi]; \
|
|
} \
|
|
while (0)
|
|
# endif
|
|
# endif
|
|
#endif /* !YYCOPY_NEEDED */
|
|
|
|
/* YYFINAL -- State number of the termination state. */
|
|
#define YYFINAL 106
|
|
/* YYLAST -- Last index in YYTABLE. */
|
|
#define YYLAST 13386
|
|
|
|
/* YYNTOKENS -- Number of terminals. */
|
|
#define YYNTOKENS 149
|
|
/* YYNNTS -- Number of nonterminals. */
|
|
#define YYNNTS 176
|
|
/* YYNRULES -- Number of rules. */
|
|
#define YYNRULES 620
|
|
/* YYNSTATES -- Number of states. */
|
|
#define YYNSTATES 1085
|
|
|
|
/* YYMAXUTOK -- Last valid token kind. */
|
|
#define YYMAXUTOK 377
|
|
|
|
|
|
/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
|
|
as returned by yylex, with out-of-bounds checking. */
|
|
#define YYTRANSLATE(YYX) \
|
|
(0 <= (YYX) && (YYX) <= YYMAXUTOK \
|
|
? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
|
|
: YYSYMBOL_YYUNDEF)
|
|
|
|
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
|
|
as returned by yylex. */
|
|
static const yytype_uint8 yytranslate[] =
|
|
{
|
|
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
148, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
2, 2, 2, 135, 2, 2, 2, 133, 128, 2,
|
|
144, 145, 131, 129, 142, 130, 147, 132, 2, 2,
|
|
2, 2, 2, 2, 2, 2, 2, 2, 123, 146,
|
|
125, 121, 124, 122, 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, 140, 2, 141, 127, 2, 143, 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, 138, 126, 139, 136, 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, 66, 67, 68, 69, 70, 71, 72, 73, 74,
|
|
75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
|
|
85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
|
|
95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
|
|
105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
|
|
115, 116, 117, 118, 119, 120, 134, 137
|
|
};
|
|
|
|
#if YYDEBUG
|
|
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
|
|
static const yytype_int16 yyrline[] =
|
|
{
|
|
0, 2493, 2493, 2493, 2503, 2509, 2513, 2517, 2521, 2527,
|
|
2529, 2528, 2542, 2568, 2574, 2578, 2582, 2588, 2594, 2594,
|
|
2598, 2602, 2606, 2610, 2619, 2628, 2632, 2637, 2638, 2642,
|
|
2646, 2650, 2654, 2660, 2663, 2667, 2671, 2675, 2679, 2683,
|
|
2688, 2692, 2701, 2710, 2719, 2728, 2735, 2736, 2740, 2743,
|
|
2744, 2748, 2752, 2756, 2760, 2763, 2773, 2772, 2787, 2796,
|
|
2797, 2800, 2801, 2808, 2807, 2822, 2826, 2831, 2835, 2840,
|
|
2844, 2849, 2853, 2857, 2861, 2865, 2871, 2875, 2881, 2882,
|
|
2888, 2892, 2896, 2900, 2904, 2908, 2912, 2916, 2920, 2924,
|
|
2930, 2931, 2937, 2941, 2947, 2951, 2957, 2961, 2965, 2969,
|
|
2973, 2977, 2983, 2989, 2996, 3000, 3004, 3008, 3012, 3016,
|
|
3022, 3028, 3033, 3039, 3043, 3046, 3050, 3054, 3061, 3062,
|
|
3063, 3064, 3069, 3076, 3077, 3080, 3084, 3084, 3090, 3091,
|
|
3092, 3093, 3094, 3095, 3096, 3097, 3098, 3099, 3100, 3101,
|
|
3102, 3103, 3104, 3105, 3106, 3107, 3108, 3109, 3110, 3111,
|
|
3112, 3113, 3114, 3115, 3116, 3117, 3118, 3119, 3122, 3122,
|
|
3122, 3123, 3123, 3124, 3124, 3124, 3125, 3125, 3125, 3125,
|
|
3126, 3126, 3126, 3127, 3127, 3127, 3128, 3128, 3128, 3128,
|
|
3129, 3129, 3129, 3129, 3130, 3130, 3130, 3130, 3131, 3131,
|
|
3131, 3131, 3132, 3132, 3132, 3132, 3133, 3133, 3136, 3140,
|
|
3144, 3148, 3152, 3156, 3160, 3165, 3170, 3175, 3179, 3183,
|
|
3187, 3191, 3195, 3199, 3203, 3207, 3211, 3215, 3219, 3223,
|
|
3227, 3231, 3235, 3239, 3243, 3247, 3251, 3255, 3259, 3263,
|
|
3267, 3271, 3275, 3279, 3283, 3287, 3291, 3295, 3299, 3303,
|
|
3307, 3311, 3315, 3319, 3323, 3332, 3341, 3350, 3359, 3365,
|
|
3366, 3370, 3374, 3380, 3384, 3391, 3395, 3404, 3421, 3422,
|
|
3425, 3426, 3427, 3431, 3435, 3441, 3446, 3450, 3454, 3458,
|
|
3464, 3464, 3475, 3479, 3485, 3489, 3495, 3498, 3503, 3507,
|
|
3511, 3516, 3520, 3526, 3531, 3535, 3541, 3542, 3546, 3550,
|
|
3551, 3552, 3553, 3554, 3559, 3558, 3570, 3574, 3569, 3579,
|
|
3579, 3583, 3587, 3591, 3595, 3599, 3603, 3607, 3611, 3615,
|
|
3619, 3623, 3624, 3630, 3637, 3629, 3650, 3658, 3666, 3666,
|
|
3666, 3673, 3673, 3673, 3680, 3686, 3691, 3693, 3690, 3702,
|
|
3700, 3718, 3723, 3716, 3740, 3738, 3754, 3764, 3775, 3779,
|
|
3783, 3787, 3793, 3800, 3801, 3802, 3805, 3806, 3809, 3810,
|
|
3818, 3819, 3825, 3829, 3832, 3836, 3840, 3844, 3849, 3853,
|
|
3857, 3861, 3867, 3866, 3876, 3880, 3884, 3888, 3894, 3899,
|
|
3904, 3908, 3912, 3916, 3920, 3924, 3928, 3932, 3936, 3940,
|
|
3944, 3948, 3952, 3956, 3960, 3966, 3971, 3978, 3978, 3982,
|
|
3987, 3993, 3997, 4003, 4004, 4007, 4012, 4015, 4019, 4025,
|
|
4029, 4036, 4035, 4052, 4057, 4061, 4066, 4073, 4077, 4081,
|
|
4085, 4089, 4093, 4097, 4101, 4105, 4112, 4111, 4126, 4125,
|
|
4141, 4149, 4158, 4161, 4168, 4171, 4175, 4176, 4179, 4183,
|
|
4186, 4190, 4193, 4194, 4195, 4196, 4199, 4200, 4206, 4211,
|
|
4216, 4221, 4227, 4228, 4234, 4240, 4239, 4251, 4255, 4261,
|
|
4265, 4271, 4280, 4291, 4294, 4295, 4298, 4304, 4310, 4311,
|
|
4314, 4321, 4320, 4335, 4339, 4347, 4351, 4363, 4370, 4377,
|
|
4378, 4379, 4380, 4381, 4385, 4391, 4395, 4403, 4404, 4405,
|
|
4409, 4415, 4419, 4423, 4427, 4431, 4437, 4441, 4447, 4451,
|
|
4455, 4459, 4463, 4467, 4471, 4479, 4486, 4492, 4493, 4497,
|
|
4501, 4500, 4517, 4518, 4521, 4527, 4531, 4537, 4538, 4542,
|
|
4546, 4552, 4556, 4562, 4568, 4575, 4581, 4588, 4592, 4598,
|
|
4602, 4608, 4609, 4612, 4616, 4622, 4626, 4630, 4634, 4640,
|
|
4645, 4650, 4654, 4658, 4662, 4666, 4670, 4674, 4678, 4682,
|
|
4686, 4690, 4694, 4698, 4702, 4707, 4713, 4718, 4723, 4728,
|
|
4733, 4740, 4744, 4751, 4756, 4755, 4767, 4771, 4777, 4785,
|
|
4793, 4801, 4805, 4811, 4815, 4821, 4822, 4825, 4830, 4837,
|
|
4838, 4841, 4845, 4851, 4855, 4861, 4867, 4867, 4874, 4875,
|
|
4881, 4885, 4891, 4897, 4902, 4906, 4911, 4916, 4932, 4937,
|
|
4943, 4944, 4945, 4948, 4949, 4950, 4951, 4954, 4955, 4956,
|
|
4959, 4960, 4963, 4967, 4973, 4974, 4980, 4981, 4984, 4985,
|
|
4988, 4991, 4992, 4993, 4996, 4997, 5000, 5005, 5008, 5009,
|
|
5013
|
|
};
|
|
#endif
|
|
|
|
/** Accessing symbol of state STATE. */
|
|
#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
|
|
|
|
#if 1
|
|
/* The user-facing name of the symbol whose (internal) number is
|
|
YYSYMBOL. No bounds checking. */
|
|
static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
|
|
|
|
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
|
|
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
|
|
static const char *const yytname[] =
|
|
{
|
|
"\"end of file\"", "error", "\"invalid token\"", "\"'class'\"",
|
|
"\"'module'\"", "\"'def'\"", "\"'begin'\"", "\"'if'\"", "\"'unless'\"",
|
|
"\"'while'\"", "\"'until'\"", "\"'for'\"", "\"'undef'\"", "\"'rescue'\"",
|
|
"\"'ensure'\"", "\"'end'\"", "\"'then'\"", "\"'elsif'\"", "\"'else'\"",
|
|
"\"'case'\"", "\"'when'\"", "\"'break'\"", "\"'next'\"", "\"'redo'\"",
|
|
"\"'retry'\"", "\"'in'\"", "\"'do'\"", "\"'do' for condition\"",
|
|
"\"'do' for block\"", "\"'do' for lambda\"", "\"'return'\"",
|
|
"\"'yield'\"", "\"'super'\"", "\"'self'\"", "\"'nil'\"", "\"'true'\"",
|
|
"\"'false'\"", "\"'and'\"", "\"'or'\"", "\"'not'\"", "\"'if' modifier\"",
|
|
"\"'unless' modifier\"", "\"'while' modifier\"", "\"'until' modifier\"",
|
|
"\"'rescue' modifier\"", "\"'alias'\"", "\"'BEGIN'\"", "\"'END'\"",
|
|
"\"'__LINE__'\"", "\"'__FILE__'\"", "\"'__ENCODING__'\"",
|
|
"\"local variable or method\"", "\"method\"", "\"global variable\"",
|
|
"\"instance variable\"", "\"constant\"", "\"class variable\"",
|
|
"\"label\"", "\"integer literal\"", "\"float literal\"",
|
|
"\"character literal\"", "tXSTRING", "tREGEXP", "tSTRING",
|
|
"tSTRING_PART", "tSTRING_MID", "tNTH_REF", "tBACK_REF", "tREGEXP_END",
|
|
"\"numbered parameter\"", "\"unary plus\"", "\"unary minus\"", "\"<=>\"",
|
|
"\"==\"", "\"===\"", "\"!=\"", "\">=\"", "\"<=\"", "\"&&\"", "\"||\"",
|
|
"\"=~\"", "\"!~\"", "\"..\"", "\"...\"", "tBDOT2", "tBDOT3", "tAREF",
|
|
"tASET", "\"<<\"", "\">>\"", "\"::\"", "tCOLON3", "tOP_ASGN", "\"=>\"",
|
|
"tLPAREN", "\"(\"", "\")\"", "\"[\"", "tLBRACE", "\"{\"", "\"*\"",
|
|
"tPOW", "\"**\"", "\"&\"", "\"->\"", "\"&.\"", "\"symbol\"",
|
|
"\"string literal\"", "tXSTRING_BEG", "tSTRING_DVAR", "tREGEXP_BEG",
|
|
"tWORDS_BEG", "tSYMBOLS_BEG", "tLAMBEG", "\"here document\"",
|
|
"tHEREDOC_END", "tLITERAL_DELIM", "tHD_LITERAL_DELIM", "tHD_STRING_PART",
|
|
"tHD_STRING_MID", "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'",
|
|
"'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'",
|
|
"'~'", "tLAST_TOKEN", "'{'", "'}'", "'['", "']'", "','", "'`'", "'('",
|
|
"')'", "';'", "'.'", "'\\n'", "$accept", "$@1", "program",
|
|
"top_compstmt", "top_stmts", "top_stmt", "@2", "bodystmt", "compstmt",
|
|
"stmts", "$@3", "stmt", "command_asgn", "command_rhs", "expr",
|
|
"defn_head", "$@4", "defs_head", "expr_value", "command_call",
|
|
"block_command", "$@5", "cmd_brace_block", "command", "mlhs",
|
|
"mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_list", "mlhs_post",
|
|
"mlhs_node", "lhs", "cname", "cpath", "fname", "fsym", "undef_list",
|
|
"$@6", "op", "reswords", "arg", "aref_args", "arg_rhs", "paren_args",
|
|
"opt_paren_args", "opt_call_args", "call_args", "@7", "command_args",
|
|
"block_arg", "opt_block_arg", "comma", "args", "mrhs", "primary", "@8",
|
|
"@9", "$@10", "$@11", "@12", "@13", "$@14", "$@15", "$@16", "$@17",
|
|
"$@18", "$@19", "@20", "@21", "@22", "@23", "primary_value", "then",
|
|
"do", "if_tail", "opt_else", "for_var", "f_margs", "$@24",
|
|
"block_args_tail", "opt_block_args_tail", "block_param",
|
|
"opt_block_param", "$@25", "block_param_def", "opt_bv_decl", "bv_decls",
|
|
"bvar", "f_larglist", "lambda_body", "@26", "do_block", "block_call",
|
|
"method_call", "@27", "brace_block", "@28", "case_body", "cases",
|
|
"opt_rescue", "exc_list", "exc_var", "opt_ensure", "literal", "string",
|
|
"string_fragment", "string_rep", "string_interp", "@29", "xstring",
|
|
"regexp", "heredoc", "heredoc_bodies", "heredoc_body",
|
|
"heredoc_string_rep", "heredoc_string_interp", "@30", "words", "symbol",
|
|
"basic_symbol", "sym", "symbols", "numeric", "variable", "var_lhs",
|
|
"var_ref", "backref", "superclass", "$@31", "f_opt_arglist_paren",
|
|
"f_arglist_paren", "f_arglist", "f_label", "f_kw", "f_block_kw",
|
|
"f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest", "args_tail",
|
|
"opt_args_tail", "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item",
|
|
"@32", "f_arg", "f_opt_asgn", "f_opt", "f_block_opt", "f_block_optarg",
|
|
"f_optarg", "restarg_mark", "f_rest_arg", "blkarg_mark", "f_block_arg",
|
|
"opt_f_block_arg", "singleton", "$@33", "assoc_list", "assocs", "assoc",
|
|
"operation", "operation2", "operation3", "dot_or_colon", "call_op",
|
|
"call_op2", "opt_terms", "opt_nl", "rparen", "trailer", "term", "nl",
|
|
"terms", "none", YY_NULLPTR
|
|
};
|
|
|
|
static const char *
|
|
yysymbol_name (yysymbol_kind_t yysymbol)
|
|
{
|
|
return yytname[yysymbol];
|
|
}
|
|
#endif
|
|
|
|
#define YYPACT_NINF (-870)
|
|
|
|
#define yypact_value_is_default(Yyn) \
|
|
((Yyn) == YYPACT_NINF)
|
|
|
|
#define YYTABLE_NINF (-621)
|
|
|
|
#define yytable_value_is_error(Yyn) \
|
|
((Yyn) == YYTABLE_NINF)
|
|
|
|
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
|
|
STATE-NUM. */
|
|
static const yytype_int16 yypact[] =
|
|
{
|
|
-870, 3957, 130, 8673, 10797, 11139, 6981, -870, 10443, 10443,
|
|
-870, -870, 10911, 8163, 6597, 8909, 8909, -870, -870, 8909,
|
|
4478, 1831, -870, -870, -870, -870, 19, 8163, -870, 36,
|
|
-870, -870, -870, 7123, 4070, -870, -870, 7265, -870, -870,
|
|
-870, -870, -870, -870, -870, 89, 10561, 10561, 10561, 10561,
|
|
152, 5856, 1426, 9381, 9735, 8445, -870, 7881, 422, 515,
|
|
1221, 920, 1245, -870, 90, 10679, 10561, -870, 1443, -870,
|
|
988, -870, 306, 1273, 1273, -870, -870, 138, 69, -870,
|
|
74, 11025, -870, 107, 2381, 735, 769, 47, 53, -870,
|
|
399, -870, -870, -870, -870, -870, -870, -870, -870, -870,
|
|
319, 119, -870, 347, 98, -870, -870, -870, -870, -870,
|
|
-870, 124, 124, 19, 743, 773, -870, 10443, 120, 5975,
|
|
292, 1295, 1295, -870, 147, -870, 775, -870, -870, 98,
|
|
-870, -870, -870, -870, -870, -870, -870, -870, -870, -870,
|
|
-870, -870, -870, -870, -870, -870, -870, -870, -870, -870,
|
|
-870, -870, -870, -870, -870, -870, -870, -870, 23, 51,
|
|
54, 87, -870, -870, -870, -870, -870, -870, 93, 102,
|
|
112, 145, -870, 193, -870, -870, -870, -870, -870, -870,
|
|
-870, -870, -870, -870, -870, -870, -870, -870, -870, -870,
|
|
-870, -870, -870, -870, -870, -870, -870, -870, -870, -870,
|
|
-870, -870, -870, -870, -870, -870, -870, -870, -870, 200,
|
|
5034, 222, 306, 1273, 1273, 188, 134, 13191, 831, 218,
|
|
199, 224, 188, 10443, 10443, 852, 243, -870, -870, 960,
|
|
275, 79, 104, -870, -870, -870, -870, -870, -870, -870,
|
|
-870, -870, 8022, -870, -870, 167, -870, -870, -870, -870,
|
|
-870, -870, 1443, -870, 620, -870, 310, -870, -870, 1443,
|
|
4206, 122, 10561, 10561, 10561, 10561, -870, 13129, -870, -870,
|
|
195, 320, 195, -870, -870, -870, 9027, -870, -870, 8909,
|
|
-870, -870, -870, -870, 6597, 6835, -870, 250, 6094, -870,
|
|
987, 296, 13253, 13253, 425, 8791, 5856, 263, 1443, 988,
|
|
1443, 317, -870, 8791, 1443, 281, 1129, 1129, -870, 13129,
|
|
302, 1129, -870, 389, 11253, 316, 1004, 1007, 1068, 1402,
|
|
-870, -870, -870, -870, -870, 1252, -870, -870, -870, -870,
|
|
-870, -870, 666, 1255, -870, -870, 1021, -870, 1242, -870,
|
|
1317, -870, 1320, 374, 378, -870, -870, -870, -870, 6359,
|
|
10443, 10443, 10443, 10443, 8791, 10443, 10443, 68, -870, -870,
|
|
-870, -870, 424, 1443, -870, -870, -870, -870, -870, -870,
|
|
-870, 1589, 369, 381, 5034, 10561, -870, 367, 465, 380,
|
|
-870, 1443, -870, -870, -870, 392, 10561, -870, 410, 509,
|
|
423, 518, -870, -870, 462, 5034, -870, -870, 9853, -870,
|
|
5856, 8559, 444, 9853, 10561, 10561, 10561, 10561, 10561, 10561,
|
|
10561, 10561, 10561, 10561, 10561, 10561, 10561, 10561, 539, 10561,
|
|
10561, 10561, 10561, 10561, 10561, 10561, 10561, 10561, 10561, 10561,
|
|
10561, 3007, -870, 8909, -870, 3752, -870, -870, 12649, -870,
|
|
-870, -870, -870, 10679, 10679, -870, 503, -870, 306, -870,
|
|
1093, -870, -870, -870, -870, -870, -870, 11531, 8909, 11617,
|
|
5034, 10443, -870, -870, -870, 595, 604, 225, 501, 505,
|
|
-870, 5180, 608, 10561, 11703, 8909, 11789, 10561, 10561, 5472,
|
|
308, 308, 106, 11875, 8909, 11961, -870, 566, -870, 6094,
|
|
310, -870, -870, 9971, 621, -870, 10561, 10561, 13191, 13191,
|
|
13191, 10561, -870, -870, 9145, -870, 10561, -870, 9499, 6716,
|
|
493, 1443, 195, 195, -870, -870, 318, 499, -870, -870,
|
|
-870, 8163, 5591, 506, 11703, 11789, 10561, 988, 1443, -870,
|
|
-870, 6478, 504, 988, -870, -870, 9617, -870, 1443, 9735,
|
|
-870, -870, -870, 1093, 74, 11253, -870, 11253, 12047, 8909,
|
|
12133, 2010, -870, -870, 507, -870, 1345, 6094, 666, -870,
|
|
-870, -870, -870, -870, -870, -870, 10561, 10561, -870, -870,
|
|
-870, -870, -870, -870, -870, -870, -870, -870, -870, -870,
|
|
1431, 1443, 1443, 513, 10679, 642, 13191, 605, -870, -870,
|
|
-870, 37, -870, -870, 1691, -870, 13191, 2010, -870, -870,
|
|
1712, -870, -870, 10679, 644, 83, 10561, -870, 12845, 195,
|
|
-870, 1443, 11253, 521, -870, -870, -870, 616, 549, 3375,
|
|
-870, -870, 1116, 307, 2135, 2135, 2135, 2135, 2029, 2029,
|
|
3438, 2505, 2135, 2135, 13253, 13253, 1521, 1521, -870, 296,
|
|
13191, 2029, 2029, 1668, 1668, 1694, 237, 237, 296, 296,
|
|
296, 3634, 7621, 4750, 7739, -870, 124, -870, 530, 195,
|
|
432, -870, 450, -870, -870, 4342, -870, -870, 2280, 83,
|
|
83, -870, 2882, -870, -870, -870, -870, -870, 1443, 10443,
|
|
5034, 874, 654, -870, 124, 536, 124, 671, 318, 8304,
|
|
-870, 10089, 674, -870, 10561, 10561, 278, -870, 7383, 7502,
|
|
556, 309, 327, 674, -870, -870, -870, -870, 64, 73,
|
|
558, 111, 121, 10443, 8163, 572, 690, 13191, 81, -870,
|
|
13191, 13191, 13191, 287, 10561, 13129, -870, 195, 13191, -870,
|
|
-870, -870, -870, 9263, 9499, -870, -870, -870, 576, -870,
|
|
-870, 22, 988, 1443, 1129, 444, -870, 874, 654, 575,
|
|
1031, 1156, -870, 113, 2010, -870, 579, -870, 296, 296,
|
|
-870, -870, 912, 1443, 578, -870, -870, 1929, 681, 12721,
|
|
-870, 679, 424, -870, 380, -870, 1443, -870, -870, 586,
|
|
589, 606, -870, 607, 679, 606, 710, 12783, -870, -870,
|
|
2010, 5034, -870, -870, 12916, 10207, -870, -870, 11253, 8791,
|
|
10679, 10561, 12219, 8909, 12305, 561, 10679, 10679, -870, 503,
|
|
551, 9145, 10679, 10679, -870, 503, 53, 138, 5034, 6094,
|
|
83, -870, 1443, 740, -870, -870, -870, -870, 12845, -870,
|
|
665, -870, 5737, 746, -870, 10443, 749, -870, 10561, 10561,
|
|
379, 10561, 10561, 753, 6240, 6240, 128, 308, -870, -870,
|
|
-870, 10325, 5326, 13191, -870, 6716, 195, -870, -870, -870,
|
|
161, 625, 1449, 5034, 6094, -870, -870, -870, 619, -870,
|
|
1484, 1443, 10561, 10561, -870, -870, 2010, -870, 1712, -870,
|
|
1712, -870, 1712, -870, -870, 10561, 10561, -870, -870, -870,
|
|
11367, -870, 632, 380, 637, 11367, -870, 640, 645, -870,
|
|
774, 10561, 12987, -870, -870, 13191, 4614, 4886, 647, 407,
|
|
463, 10561, 10561, -870, -870, -870, -870, -870, 10679, -870,
|
|
-870, -870, -870, -870, -870, -870, 778, 656, 6094, 5034,
|
|
-870, -870, 11481, 188, -870, -870, 6240, -870, -870, 188,
|
|
-870, 10561, -870, 782, 790, -870, 13191, 168, -870, 9499,
|
|
-870, 1615, 791, 672, 1457, 1457, 1063, -870, 13191, 13191,
|
|
606, 675, 606, 606, 13191, 13191, 687, 688, 763, 1119,
|
|
605, -870, -870, 1421, -870, 1119, 2010, -870, 1712, -870,
|
|
-870, 13058, 478, 13191, 13191, -870, -870, -870, -870, 691,
|
|
805, 776, -870, 1127, 1007, 1068, 5034, -870, 5180, -870,
|
|
-870, 6240, -870, -870, -870, -870, 693, -870, -870, -870,
|
|
-870, 696, 696, 1457, 697, -870, 1712, -870, -870, -870,
|
|
-870, -870, -870, 12391, -870, 380, 605, -870, -870, 701,
|
|
705, 708, -870, 720, 708, -870, -870, 1093, 12477, 8909,
|
|
12563, 604, 278, 851, 1615, 287, 1457, 696, 1457, 606,
|
|
723, 733, -870, 2010, -870, 1712, -870, 1712, -870, 1712,
|
|
-870, -870, 874, 654, 745, 299, 535, -870, -870, -870,
|
|
-870, 696, -870, 708, 751, 708, 708, 161, -870, 1712,
|
|
-870, -870, -870, 708, -870
|
|
};
|
|
|
|
/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
|
|
Performed when YYTABLE does not specify something else to do. Zero
|
|
means the default is an error. */
|
|
static const yytype_int16 yydefact[] =
|
|
{
|
|
2, 0, 0, 0, 0, 0, 0, 294, 0, 0,
|
|
318, 321, 0, 0, 606, 338, 339, 340, 341, 306,
|
|
270, 270, 491, 490, 492, 493, 608, 0, 10, 0,
|
|
495, 494, 496, 481, 592, 483, 482, 485, 484, 477,
|
|
478, 438, 439, 497, 498, 489, 0, 0, 0, 0,
|
|
0, 0, 296, 620, 620, 88, 313, 0, 0, 0,
|
|
0, 0, 0, 453, 0, 0, 0, 3, 606, 6,
|
|
9, 27, 33, 545, 545, 49, 60, 59, 0, 76,
|
|
0, 80, 90, 0, 54, 248, 0, 61, 311, 286,
|
|
287, 436, 288, 289, 290, 434, 433, 465, 435, 432,
|
|
488, 0, 291, 292, 270, 5, 1, 8, 338, 339,
|
|
306, 620, 414, 0, 113, 114, 489, 0, 0, 0,
|
|
0, 545, 545, 116, 499, 342, 0, 488, 292, 0,
|
|
334, 168, 178, 169, 165, 194, 195, 196, 197, 176,
|
|
191, 184, 174, 173, 189, 172, 171, 167, 192, 166,
|
|
179, 183, 185, 177, 170, 186, 193, 188, 187, 180,
|
|
190, 175, 164, 182, 181, 163, 161, 162, 158, 159,
|
|
160, 118, 120, 119, 153, 154, 131, 132, 133, 140,
|
|
137, 139, 134, 135, 155, 156, 141, 142, 146, 149,
|
|
150, 136, 138, 128, 129, 130, 143, 144, 145, 147,
|
|
148, 151, 152, 157, 576, 55, 121, 122, 575, 0,
|
|
0, 0, 58, 545, 545, 0, 0, 54, 0, 488,
|
|
0, 292, 0, 0, 0, 112, 0, 353, 352, 0,
|
|
0, 488, 292, 187, 180, 190, 175, 158, 159, 160,
|
|
118, 119, 0, 123, 125, 20, 124, 456, 461, 460,
|
|
614, 616, 606, 617, 0, 458, 0, 618, 615, 607,
|
|
590, 489, 278, 589, 273, 0, 265, 277, 74, 269,
|
|
620, 436, 620, 580, 75, 73, 620, 259, 307, 0,
|
|
72, 258, 413, 71, 606, 0, 18, 0, 0, 221,
|
|
0, 222, 209, 212, 303, 0, 0, 0, 606, 15,
|
|
606, 78, 14, 0, 606, 0, 611, 611, 249, 0,
|
|
0, 611, 578, 0, 0, 86, 0, 96, 103, 545,
|
|
471, 470, 472, 473, 467, 0, 469, 468, 440, 445,
|
|
444, 447, 0, 0, 442, 449, 0, 451, 0, 463,
|
|
0, 475, 0, 479, 480, 53, 236, 237, 4, 607,
|
|
0, 0, 0, 0, 0, 0, 0, 552, 548, 547,
|
|
546, 549, 550, 0, 554, 566, 521, 522, 570, 569,
|
|
565, 545, 0, 507, 0, 514, 519, 620, 524, 620,
|
|
544, 0, 551, 553, 556, 530, 0, 563, 530, 568,
|
|
530, 572, 528, 503, 0, 0, 401, 403, 0, 92,
|
|
0, 84, 81, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 208, 211, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 603, 620, 602, 0, 605, 604, 0, 418,
|
|
416, 312, 437, 0, 0, 407, 65, 310, 331, 113,
|
|
114, 115, 479, 480, 507, 500, 329, 0, 620, 0,
|
|
0, 0, 601, 600, 56, 0, 620, 303, 0, 0,
|
|
344, 0, 343, 0, 0, 620, 0, 0, 0, 0,
|
|
0, 0, 303, 0, 620, 0, 326, 0, 126, 0,
|
|
0, 457, 459, 0, 0, 619, 584, 585, 279, 588,
|
|
272, 0, 608, 266, 0, 275, 0, 267, 0, 606,
|
|
0, 606, 620, 620, 260, 271, 606, 0, 309, 52,
|
|
609, 0, 0, 0, 0, 0, 0, 17, 606, 301,
|
|
13, 607, 77, 297, 300, 304, 613, 250, 612, 613,
|
|
252, 305, 579, 102, 94, 0, 89, 0, 0, 620,
|
|
0, 545, 314, 398, 530, 474, 0, 0, 448, 454,
|
|
441, 443, 450, 452, 464, 476, 0, 0, 7, 21,
|
|
22, 23, 24, 25, 50, 51, 511, 558, 512, 510,
|
|
0, 606, 606, 530, 0, 0, 513, 0, 526, 574,
|
|
523, 0, 527, 508, 0, 537, 559, 0, 540, 567,
|
|
0, 542, 571, 0, 0, 620, 278, 28, 30, 0,
|
|
31, 606, 0, 82, 93, 48, 34, 46, 0, 253,
|
|
198, 29, 0, 292, 226, 231, 232, 233, 228, 230,
|
|
240, 241, 234, 235, 207, 210, 238, 239, 32, 218,
|
|
608, 227, 229, 223, 224, 225, 213, 214, 215, 216,
|
|
217, 593, 598, 594, 599, 412, 270, 410, 0, 620,
|
|
593, 595, 594, 596, 411, 270, 593, 594, 270, 620,
|
|
620, 35, 253, 199, 45, 206, 63, 66, 0, 0,
|
|
0, 113, 114, 117, 0, 0, 620, 0, 606, 0,
|
|
295, 620, 620, 424, 0, 0, 620, 345, 597, 302,
|
|
0, 593, 594, 620, 347, 319, 346, 322, 597, 302,
|
|
0, 593, 594, 0, 0, 0, 0, 277, 0, 325,
|
|
583, 586, 582, 276, 281, 280, 274, 620, 587, 581,
|
|
257, 255, 261, 262, 264, 308, 610, 19, 0, 26,
|
|
205, 79, 16, 606, 611, 95, 87, 99, 101, 0,
|
|
98, 100, 608, 0, 0, 466, 0, 455, 219, 220,
|
|
552, 550, 361, 606, 354, 506, 504, 0, 41, 244,
|
|
336, 0, 0, 520, 620, 573, 0, 529, 557, 530,
|
|
530, 530, 564, 530, 552, 530, 43, 246, 337, 389,
|
|
387, 0, 386, 385, 285, 0, 91, 85, 0, 0,
|
|
0, 0, 0, 620, 0, 0, 0, 0, 409, 69,
|
|
415, 262, 0, 0, 408, 67, 404, 62, 0, 0,
|
|
620, 332, 0, 0, 415, 335, 577, 57, 425, 426,
|
|
620, 427, 0, 620, 350, 0, 0, 348, 0, 0,
|
|
415, 0, 0, 0, 0, 0, 415, 0, 127, 462,
|
|
324, 0, 0, 282, 268, 606, 620, 11, 298, 251,
|
|
97, 0, 391, 0, 0, 315, 446, 362, 359, 555,
|
|
0, 606, 0, 0, 525, 509, 0, 533, 0, 535,
|
|
0, 541, 0, 538, 543, 0, 0, 384, 608, 608,
|
|
516, 517, 620, 620, 369, 0, 561, 369, 369, 367,
|
|
0, 281, 283, 83, 47, 254, 593, 594, 0, 593,
|
|
594, 0, 0, 40, 203, 39, 204, 70, 0, 37,
|
|
201, 38, 202, 68, 405, 406, 0, 0, 0, 0,
|
|
501, 330, 0, 0, 429, 351, 0, 12, 431, 0,
|
|
316, 0, 317, 0, 0, 327, 280, 620, 256, 263,
|
|
397, 0, 0, 0, 0, 0, 357, 505, 42, 245,
|
|
530, 530, 530, 530, 44, 247, 0, 0, 0, 515,
|
|
0, 365, 366, 369, 377, 560, 0, 380, 0, 382,
|
|
402, 284, 415, 243, 242, 36, 200, 419, 417, 0,
|
|
0, 0, 428, 0, 104, 111, 0, 430, 0, 320,
|
|
323, 0, 421, 422, 420, 395, 608, 393, 396, 400,
|
|
399, 363, 360, 0, 355, 534, 0, 531, 536, 539,
|
|
390, 388, 303, 0, 518, 620, 0, 368, 375, 369,
|
|
369, 369, 562, 369, 369, 64, 333, 110, 0, 620,
|
|
0, 620, 620, 0, 0, 392, 0, 358, 0, 530,
|
|
597, 302, 364, 0, 372, 0, 374, 0, 381, 0,
|
|
378, 383, 107, 109, 0, 593, 594, 423, 349, 328,
|
|
394, 356, 532, 369, 369, 369, 369, 105, 373, 0,
|
|
370, 376, 379, 369, 371
|
|
};
|
|
|
|
/* YYPGOTO[NTERM-NUM]. */
|
|
static const yytype_int16 yypgoto[] =
|
|
{
|
|
-870, -870, -870, 372, -870, 43, -870, -299, 301, -870,
|
|
-870, 46, -165, -305, 34, 1724, -870, 1884, 21, -50,
|
|
-870, -870, -483, -12, 885, -205, 15, -27, -285, -477,
|
|
-47, 2818, -59, 893, 5, -18, -870, -870, 38, -870,
|
|
1204, -870, 184, 56, -252, -325, 96, -870, 10, -420,
|
|
-231, 14, 52, -358, 28, -870, -870, -870, -870, -870,
|
|
-870, -870, -870, -870, -870, -870, -870, -870, -870, -870,
|
|
-870, 9, -188, -444, -141, -623, -870, -870, -870, 115,
|
|
258, -870, -583, -870, -870, -464, -870, -142, -870, -870,
|
|
-870, 91, -870, -870, -870, -87, -870, -470, -870, -131,
|
|
-870, -870, -870, -870, -870, 103, 41, -160, -870, -870,
|
|
-870, -870, -870, -277, -870, 670, -870, -870, -870, -11,
|
|
-870, -870, -870, 2545, 2999, 913, 2385, -870, -870, 60,
|
|
512, 25, 135, 341, -40, -870, -870, -870, 117, 730,
|
|
-185, -226, -824, -706, -513, -870, 186, -751, -547, -869,
|
|
-42, -536, -870, 252, -870, -44, -343, -870, -870, -870,
|
|
101, -445, 600, -353, -870, -870, -60, -870, 24, -20,
|
|
492, -250, 508, -280, -46, -1
|
|
};
|
|
|
|
/* YYDEFGOTO[NTERM-NUM]. */
|
|
static const yytype_int16 yydefgoto[] =
|
|
{
|
|
0, 1, 2, 67, 68, 69, 287, 465, 466, 298,
|
|
521, 299, 71, 616, 72, 213, 689, 214, 215, 75,
|
|
76, 820, 677, 77, 78, 300, 79, 80, 81, 546,
|
|
82, 216, 123, 124, 243, 244, 245, 714, 654, 207,
|
|
84, 305, 620, 655, 278, 510, 511, 279, 280, 269,
|
|
503, 539, 659, 610, 85, 210, 303, 743, 304, 319,
|
|
753, 223, 844, 224, 845, 713, 1001, 680, 678, 929,
|
|
460, 290, 471, 705, 836, 837, 230, 763, 954, 1027,
|
|
974, 888, 791, 889, 792, 861, 1006, 1007, 552, 865,
|
|
605, 397, 87, 88, 670, 447, 669, 494, 1004, 692,
|
|
830, 933, 937, 89, 90, 91, 333, 334, 557, 92,
|
|
93, 94, 558, 253, 254, 255, 489, 95, 96, 97,
|
|
327, 98, 99, 219, 220, 102, 221, 456, 679, 372,
|
|
373, 374, 375, 376, 891, 892, 377, 378, 379, 777,
|
|
595, 381, 382, 383, 384, 580, 385, 386, 387, 896,
|
|
897, 388, 389, 390, 391, 392, 588, 209, 461, 310,
|
|
513, 273, 129, 684, 657, 464, 459, 438, 517, 862,
|
|
518, 537, 257, 258, 259, 302
|
|
};
|
|
|
|
/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
|
|
positive, shift that token. If negative, reduce the rule whose
|
|
number is the opposite. If YYTABLE_NINF, syntax error. */
|
|
static const yytype_int16 yytable[] =
|
|
{
|
|
105, 441, 246, 266, 266, 520, 285, 266, 315, 286,
|
|
86, 205, 86, 126, 126, 345, 246, 218, 218, 281,
|
|
716, 229, 349, 218, 218, 218, 435, 437, 218, 545,
|
|
222, 283, 125, 125, 479, 252, 592, 707, 256, 895,
|
|
125, 507, 212, 212, 206, 621, 107, 70, 212, 70,
|
|
782, 206, 308, 312, 402, 559, 868, 540, 779, 451,
|
|
86, 542, 326, 729, 316, 206, 301, 270, 270, 833,
|
|
746, 270, 393, 393, 218, 585, 277, 282, 656, 439,
|
|
843, 778, 665, 125, 726, 668, 818, 819, 726, -107,
|
|
316, 528, 348, 553, 729, 206, 604, 470, -109, 395,
|
|
336, 338, 340, 342, -104, 306, 686, 1032, 658, 125,
|
|
281, 268, 274, -491, 446, 275, 272, 272, 271, 271,
|
|
272, 656, 271, 665, 439, 576, 218, 1008, 86, -111,
|
|
106, -110, 686, 685, 394, 797, -106, 436, 671, 674,
|
|
368, -490, 863, -77, -492, 582, -108, 395, 343, 344,
|
|
700, 448, 432, -105, 307, 311, 271, 271, 476, 710,
|
|
445, 687, 789, 284, -91, 369, 396, 277, 282, 485,
|
|
-491, 449, 686, 561, 288, 450, 561, -493, 561, 497,
|
|
561, -487, 561, -495, 1032, 445, 832, -415, 493, 577,
|
|
398, 440, -494, 442, 434, 611, 247, 686, -490, 248,
|
|
249, -492, -496, 598, 470, 601, -99, 294, -593, 790,
|
|
-112, 443, 393, 393, -487, -101, 399, -594, 779, 86,
|
|
1008, -96, 895, 502, 749, 895, 864, 250, 403, 251,
|
|
525, 779, 218, 218, -493, -481, 440, 928, 615, 395,
|
|
-495, 778, 276, -112, 480, 481, -103, 326, -102, -494,
|
|
1014, -415, 531, -98, 778, 473, 550, 212, 212, -496,
|
|
538, 538, 545, -100, 266, 538, -415, 266, 276, 505,
|
|
-97, 505, 455, 468, 469, 514, 490, 467, 615, 615,
|
|
206, 757, 507, -485, 504, 218, 508, 544, 218, 729,
|
|
462, 477, -481, 218, 218, 835, 832, 86, 482, -415,
|
|
486, -415, 895, 247, 86, 86, 248, 249, -415, 488,
|
|
-486, 301, 86, 726, 726, -106, 478, 526, 516, 519,
|
|
536, 903, 530, 316, 1002, 752, 917, 545, 512, 782,
|
|
493, 270, 923, 829, 250, 704, 251, 502, 419, -104,
|
|
-485, 527, 125, 355, 356, -111, -110, 463, 607, 533,
|
|
452, 453, 297, 617, 613, 355, 356, 778, 86, 218,
|
|
218, 218, 218, 86, 218, 218, 556, 778, 428, 429,
|
|
430, 569, 570, 571, 572, 515, 589, 506, 589, 271,
|
|
272, 823, 271, 86, 212, 212, 212, 212, 522, 574,
|
|
575, 726, 568, 617, 617, 70, 561, 419, 683, 444,
|
|
573, 841, 247, 945, 86, 248, 249, 218, 529, 86,
|
|
316, -486, 622, 814, -106, 301, 816, -106, -106, 842,
|
|
297, 266, 535, 247, 966, 967, 248, 249, -111, 125,
|
|
-106, 874, 514, 247, 814, 251, 248, 249, -76, 444,
|
|
-104, 541, 218, 520, 543, -106, 266, -106, -108, 656,
|
|
609, 665, 622, 622, 250, 609, 251, 514, 547, 41,
|
|
778, -96, 42, 266, 250, 693, 251, 218, -111, 86,
|
|
218, 941, 266, 663, 514, 566, 663, 1003, 908, 567,
|
|
86, 578, 723, 514, 218, 328, 329, 330, 86, -103,
|
|
584, 664, 900, 218, 859, 688, 854, 663, 86, 812,
|
|
-105, 913, -502, 737, 729, 554, 58, 919, 921, 587,
|
|
246, 505, 505, 545, 663, 664, 590, 526, 745, 926,
|
|
544, 105, 591, 663, 812, 520, 733, 734, -106, 726,
|
|
852, 86, 664, 778, 594, 732, 271, 266, 331, 332,
|
|
86, 664, 813, 775, 778, 718, -110, 775, 514, 971,
|
|
972, -108, 597, -106, 316, 813, 316, 583, 218, 206,
|
|
599, 271, 804, 663, 952, 600, 86, -102, 70, 602,
|
|
918, -108, 768, 125, -98, 125, 335, 742, 271, 329,
|
|
330, 664, 520, 603, -108, 544, 614, 271, 663, 523,
|
|
638, 786, -100, 218, 877, 879, 881, 297, 883, -105,
|
|
884, 104, 676, 104, 793, 727, 664, 271, 104, 104,
|
|
690, 271, 218, 985, 104, 104, 104, 691, 911, 104,
|
|
805, 316, 694, 795, 697, 854, 695, 673, 675, 555,
|
|
990, 331, 332, 454, 454, 615, 719, 744, 731, 271,
|
|
125, 615, 271, 918, 736, 739, -91, 615, 615, 754,
|
|
-108, 104, 271, -108, -108, 767, 771, 770, 505, 788,
|
|
799, 673, 675, 798, 281, 104, 809, 281, 793, 793,
|
|
800, 810, -105, 811, 772, 815, 247, 824, 817, 248,
|
|
249, -108, 1052, -108, 912, 281, 825, 686, 218, 86,
|
|
831, 834, 832, -97, 827, 834, 848, 840, 538, 846,
|
|
822, 297, 834, 246, 774, 850, 366, 367, 368, 251,
|
|
740, 849, 808, 212, 1064, 857, 860, 104, 866, 104,
|
|
870, 277, 218, 472, 277, 872, 505, 206, 876, 924,
|
|
472, 878, 851, 369, 847, 491, 576, 554, 248, 249,
|
|
808, 508, 277, 609, -302, 996, 899, 212, 880, 882,
|
|
617, 998, 206, 615, 885, 931, 617, 915, 932, -302,
|
|
936, 955, 617, 617, 940, 520, 764, 495, 942, -590,
|
|
950, 544, 696, 589, 970, 1015, 1017, 1018, 1019, 973,
|
|
703, 247, 976, 781, 248, 249, 785, 978, 982, 980,
|
|
715, 266, 532, 987, -302, 988, 534, 999, -594, -591,
|
|
86, -302, 514, 380, 380, 1000, 1009, 316, 86, 622,
|
|
104, 1010, 218, 1020, 1021, 622, 218, 1016, 1022, 793,
|
|
1036, 622, 622, 104, 104, -342, 125, 86, 86, 934,
|
|
1035, 1037, 938, -481, 856, 1044, 271, 271, 1046, 1048,
|
|
-342, 86, 663, 1053, 218, 904, 780, 1055, -481, 783,
|
|
1057, 380, 380, 86, 86, 505, 939, 495, 756, 431,
|
|
664, 86, 1059, -485, 1072, 457, 1069, -593, 617, 212,
|
|
949, 579, 86, 86, 432, -342, 104, -594, -485, 104,
|
|
432, -590, -342, -481, 104, 104, 1077, -590, 104, 593,
|
|
-481, 589, 589, 1079, 738, 104, 104, 227, 130, 969,
|
|
-597, 1068, 1070, 104, 975, 887, 271, 893, 925, 433,
|
|
1067, -591, 856, -485, 271, 458, 434, -591, 125, 208,
|
|
-485, 474, 434, 125, 492, 890, 775, 622, 773, 899,
|
|
1024, 1029, 899, 1040, 899, 0, 432, 86, 86, 0,
|
|
0, 993, -489, 380, 380, 86, 834, 0, 0, 104,
|
|
104, 104, 104, 104, 104, 104, 104, -489, 0, 0,
|
|
125, 0, 0, 760, -597, 358, 359, 360, 361, 0,
|
|
0, 475, 0, 0, 104, 0, 894, 0, 434, -597,
|
|
0, 761, 899, 339, 329, 330, 1045, 0, 706, 706,
|
|
914, 916, -489, 0, 0, 104, 920, 922, 104, -489,
|
|
104, 730, 0, 104, 0, 86, 780, 86, 735, 899,
|
|
86, 899, -597, 899, -597, 899, 0, 0, -593, 780,
|
|
741, -597, 914, 916, 589, 920, 922, 266, 350, 351,
|
|
352, 353, 354, 104, 0, 899, 331, 332, 514, 495,
|
|
693, 834, 898, 104, 104, 0, 495, 0, 218, 380,
|
|
483, 0, 271, 0, 867, 0, 0, -593, 104, 0,
|
|
104, 104, 960, 0, 962, 432, 0, 0, 963, 0,
|
|
0, 104, 0, 765, 766, 104, 0, 524, 663, 104,
|
|
0, 0, 562, 0, 104, 329, 330, 1025, 0, 104,
|
|
893, 0, 432, 893, 548, 893, 664, -488, 0, 0,
|
|
484, 380, 986, 796, 0, 890, 0, 434, 890, 432,
|
|
0, 890, -488, 890, 760, 0, 358, 359, 360, 361,
|
|
927, -593, 104, 0, 0, 986, 0, 475, 961, 0,
|
|
0, 104, 761, 935, 434, 0, -593, 331, 332, 0,
|
|
1011, 1012, 271, 893, 549, 943, 944, -488, 0, 104,
|
|
0, 434, 0, 947, -488, 977, 979, 104, -292, 0,
|
|
0, 890, 1031, 0, 1034, 953, 0, 0, 0, -593,
|
|
893, -593, 893, -292, 893, -593, 893, 0, -593, 0,
|
|
826, 0, -594, -303, 104, 0, 821, 0, 890, 0,
|
|
890, 0, 890, 0, 890, 0, 893, 0, -303, 1047,
|
|
0, 0, 1049, 104, 0, 1013, 802, 0, -292, 1023,
|
|
0, 0, 217, 217, 890, -292, 0, 1038, 217, 267,
|
|
267, 432, 0, 267, 432, 1030, 472, 0, 1033, 989,
|
|
0, 1028, 432, -303, 1071, 858, 0, 997, 0, 1073,
|
|
-303, 1075, 0, 0, 247, 1076, -594, 248, 249, 0,
|
|
289, 291, 292, 293, 0, 869, 803, 267, 309, 458,
|
|
0, -594, 0, 434, 0, 1083, 434, 1039, 0, 346,
|
|
347, 502, 0, 0, 434, 250, 0, 251, 0, 104,
|
|
104, 380, 0, 337, 875, 329, 330, 1054, 1056, 1058,
|
|
0, 1060, 1061, 0, -594, 0, -594, 1041, 0, 1042,
|
|
-594, 0, 1043, -594, 563, 1074, 329, 330, 341, 329,
|
|
330, 0, 0, 104, 0, 555, 329, 330, 560, 329,
|
|
330, 217, 0, 0, 357, 0, 358, 359, 360, 361,
|
|
930, 1078, 1080, 1081, 1082, 0, 0, 331, 332, 0,
|
|
0, 1084, 362, 0, 0, 0, 357, 948, 358, 359,
|
|
360, 361, 0, 0, 0, 706, 363, 0, 331, 332,
|
|
0, 331, 332, 957, 362, 0, 0, 364, 331, 332,
|
|
0, 331, 332, 365, 366, 367, 368, 0, 363, 0,
|
|
564, 329, 330, 565, 329, 330, 0, 0, 0, 364,
|
|
0, 104, 0, 0, -620, 365, 366, 367, 368, 104,
|
|
104, 369, 0, 104, 370, 0, 104, 104, 755, 329,
|
|
330, 0, 104, 104, 0, 0, 0, 371, 104, 104,
|
|
0, 0, 0, 369, 0, 0, 370, 217, 217, 0,
|
|
0, 0, 104, 331, 332, 104, 331, 332, 0, 371,
|
|
0, 472, 0, 0, 104, 104, 0, 472, 0, 0,
|
|
0, 0, 104, 357, 0, 358, 359, 360, 361, 0,
|
|
0, 331, 332, 104, 104, 0, 498, 499, 500, 346,
|
|
0, 362, 357, 0, 358, 359, 360, 361, 0, 0,
|
|
267, 0, 760, 267, 358, 359, 360, 361, 217, 217,
|
|
362, 0, 0, 0, 0, 0, 364, 0, 0, 0,
|
|
761, 0, 365, 366, 367, 368, 0, 0, 760, 0,
|
|
358, 359, 360, 361, 0, 364, 0, 0, 104, 0,
|
|
0, 365, 366, 367, 368, 364, 761, 0, 104, 104,
|
|
369, 762, 0, 370, 0, 760, 104, 358, 359, 360,
|
|
361, -299, 0, 0, -299, -299, 551, 0, 0, 369,
|
|
0, 364, 370, 761, 217, 217, 217, 217, 247, 217,
|
|
217, 248, 249, 1026, 247, 0, 0, 248, 249, 0,
|
|
0, -299, -299, 0, -299, 0, 0, 0, 364, 586,
|
|
0, 0, 0, 0, 956, 0, 0, 0, 0, 250,
|
|
596, 251, 0, 0, 0, 951, 104, 251, 104, 0,
|
|
0, 104, 608, 0, 0, 0, 0, 619, 624, 625,
|
|
626, 627, 628, 629, 630, 631, 632, 633, 634, 635,
|
|
636, 637, 419, 639, 640, 641, 642, 643, 644, 645,
|
|
646, 647, 648, 649, 650, 0, 0, 267, 0, 104,
|
|
357, 0, 358, 359, 360, 361, 0, 672, 672, 0,
|
|
426, 427, 428, 429, 430, 0, 0, 0, 362, 0,
|
|
0, 0, 267, 0, 0, 217, 1005, 0, 358, 359,
|
|
360, 361, 0, 0, 581, 0, 0, 672, 0, 267,
|
|
0, 672, 672, 364, 761, 0, 0, 0, 267, 365,
|
|
366, 367, 368, 0, 0, 0, 0, 717, 0, 0,
|
|
720, 721, 0, 0, 0, 722, 0, 0, 725, 0,
|
|
728, 0, 309, 293, 0, 0, 0, 369, 0, 0,
|
|
370, 0, 0, 0, 0, 73, 0, 73, 121, 121,
|
|
672, 0, 0, 0, 0, 0, 121, 0, 0, 0,
|
|
725, 0, 357, 309, 358, 359, 360, 361, 0, 0,
|
|
0, 0, 0, 267, 0, 0, 416, 417, 0, 0,
|
|
362, 0, 0, 784, 0, 358, 359, 360, 361, 419,
|
|
758, 759, 0, 0, 0, 73, 776, 0, 0, 121,
|
|
0, 362, 416, 417, 0, 364, 0, 0, 769, 0,
|
|
0, 365, 366, 367, 368, 419, 425, 426, 427, 428,
|
|
429, 430, 0, 0, 0, 121, 364, 787, 0, 0,
|
|
794, 0, 0, 366, 367, 368, 0, 0, 0, 369,
|
|
0, 0, 370, 426, 427, 428, 429, 430, 0, 0,
|
|
0, -414, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
369, 0, 0, 73, -414, -414, -414, -414, -414, -414,
|
|
0, -414, 0, 0, 0, 0, 0, -414, -414, -414,
|
|
0, 0, 0, 0, 0, 0, 0, 0, -414, -414,
|
|
0, -414, -414, -414, -414, -414, 0, 0, 0, 0,
|
|
0, 0, 0, 217, 0, 74, 0, 74, 122, 122,
|
|
0, 0, 0, 0, 0, 828, 122, 0, 769, 787,
|
|
0, 0, 0, -414, -414, -414, -414, -414, -414, -414,
|
|
-414, -414, -414, -414, -414, 0, 0, 217, 0, -414,
|
|
-414, -414, 0, 0, -414, 0, 0, 0, 853, 0,
|
|
-414, 0, -414, 0, 73, 74, -414, 725, 309, 122,
|
|
0, 0, 0, 0, 0, 0, -414, 0, 0, -414,
|
|
-414, 0, 0, -414, 0, -414, -414, -414, -414, -414,
|
|
-414, -414, -414, -414, -414, 122, 0, 0, 0, -414,
|
|
-414, -414, -414, -414, 0, 276, -414, -414, -414, -414,
|
|
357, 0, 358, 359, 360, 361, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 362, 902,
|
|
0, 0, 0, 74, 672, 905, 0, 267, 0, 0,
|
|
672, 672, 73, 0, 871, 725, 672, 672, 0, 73,
|
|
73, 0, 0, 364, 0, 0, 0, 73, 0, 365,
|
|
366, 367, 368, 0, 0, 0, 0, 0, 121, 217,
|
|
0, 0, 672, 672, 0, 672, 672, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 946, 0, 369, 0, 293,
|
|
370, 357, 0, 358, 359, 360, 361, 0, 0, 0,
|
|
0, 0, 0, 73, 0, 0, 958, 959, 73, 362,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 964,
|
|
965, 0, 0, 0, 74, 0, 0, 0, 73, 0,
|
|
0, 0, 0, 0, 364, 981, 0, 0, 0, 0,
|
|
365, 366, 367, 368, 0, 983, 984, 416, 417, 73,
|
|
0, 0, 672, 0, 73, 121, 0, 73, 0, 0,
|
|
419, 0, 0, 0, 0, 0, 0, 0, 369, 0,
|
|
0, 370, 0, 0, 0, 672, 0, 0, 0, 0,
|
|
0, 0, 0, 309, 0, 423, 424, 425, 426, 427,
|
|
428, 429, 430, 0, 0, 0, 0, 73, 73, 0,
|
|
0, 0, 74, 0, 0, 0, 0, 0, 0, 74,
|
|
74, 0, 0, 0, 73, 0, 0, 74, 0, 0,
|
|
0, 0, 0, 0, 0, 73, 0, 0, 122, 0,
|
|
0, 0, 0, 73, 0, 0, 0, -621, -621, -621,
|
|
-621, 408, 409, 73, 0, -621, -621, 0, 0, 0,
|
|
0, 0, 0, 416, 417, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 74, 0, 0, 419, 0, 74, 0,
|
|
0, 0, 0, 267, 0, 0, 73, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 73, 0, 0, 74, 421,
|
|
422, 423, 424, 425, 426, 427, 428, 429, 430, 121,
|
|
0, 121, 0, 0, 0, 0, 0, 0, 0, 74,
|
|
-620, 73, 0, 0, 74, 122, 0, 74, 0, 0,
|
|
0, 0, 0, -620, -620, -620, -620, -620, -620, 0,
|
|
-620, 0, 0, 0, 0, 0, -620, -620, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, -620, -620, 0,
|
|
-620, -620, -620, -620, -620, 0, 0, 74, 74, 0,
|
|
0, 0, 0, 0, 0, 0, 121, 0, 0, 0,
|
|
0, 0, 0, 0, 74, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 74, 0, 0, 0, 0,
|
|
0, 0, 0, 74, 0, 0, 0, 0, 0, 0,
|
|
-620, 0, 0, 74, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, -620, 103, 0, 103, 128,
|
|
128, 0, 0, 0, 0, -620, 0, 232, -620, -620,
|
|
0, 0, 0, 0, 73, 0, 74, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 74, 0, 0, -620, -620,
|
|
0, 0, 0, 0, 276, -620, -620, -620, -620, 122,
|
|
0, 122, 0, 0, 0, 0, 103, 0, 0, 0,
|
|
318, 74, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 404, 405, 406, 407, 408, 409, 410,
|
|
411, 412, 413, 414, 415, 0, 318, 0, 0, 416,
|
|
417, 0, 0, 0, 418, 0, 0, 0, 0, 0,
|
|
0, 0, 419, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 122, 0, 0, 0,
|
|
0, 0, 0, 420, 103, 421, 422, 423, 424, 425,
|
|
426, 427, 428, 429, 430, 73, 0, 0, 0, 0,
|
|
0, 0, 121, 73, 73, 0, 0, 0, 0, 0,
|
|
73, 0, 0, 0, 0, 0, 73, 73, 0, 0,
|
|
0, 0, 73, 73, 0, 0, 100, 0, 100, 127,
|
|
127, 127, 0, 0, 0, 0, 73, 231, 0, 0,
|
|
0, 0, 0, 0, 74, 0, 0, 0, 73, 73,
|
|
0, 0, 0, 0, 0, 0, 73, 404, 405, 406,
|
|
407, 408, 409, 410, 0, 412, 413, 73, 73, 0,
|
|
0, 0, 0, 416, 417, 103, 100, 0, 0, 0,
|
|
317, 0, 0, 0, 0, 0, 419, 0, 0, 0,
|
|
0, 0, 0, 0, 121, 0, 0, 0, 0, 121,
|
|
0, 0, 0, 0, 0, 0, 317, 0, 0, 421,
|
|
422, 423, 424, 425, 426, 427, 428, 429, 430, 0,
|
|
0, 0, 73, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 73, 73, 0, 0, 121, 0, 0, 0,
|
|
73, 0, 0, 0, 100, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 103, 0, 74, 0, 0, 0, 0,
|
|
103, 103, 122, 74, 74, 0, 0, 0, 103, 0,
|
|
74, 0, 0, 0, 0, 0, 74, 74, 0, 318,
|
|
0, 0, 74, 74, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 74, 0, 0, 0,
|
|
73, 0, 73, 0, 0, 73, 0, 0, 74, 74,
|
|
0, 0, 0, 0, 103, 0, 74, 0, 0, 103,
|
|
0, 0, 0, 0, 0, 0, 0, 74, 74, 0,
|
|
0, 0, 0, 0, 0, 100, 0, 0, 0, 103,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 122, 0, 0, 0, 0, 122,
|
|
103, 0, 0, 0, 0, 103, 318, 0, 623, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 74, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 74, 74, 0, 0, 122, 0, 0, 83,
|
|
74, 83, 0, 0, 0, 0, 0, 0, 623, 623,
|
|
228, 0, 0, 100, 0, 0, 0, 0, 0, 0,
|
|
100, 100, 0, 0, 0, 103, 0, 0, 100, 0,
|
|
0, 0, 0, 0, 0, 0, 103, 0, 0, 317,
|
|
0, 0, 0, 0, 103, 0, 0, 0, 0, 83,
|
|
0, 0, 0, 0, 103, 0, 0, 0, 0, 0,
|
|
74, 0, 74, 0, 0, 74, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 100, 0, 0, 0, 0, 100,
|
|
0, 0, 0, 0, 0, 0, 0, 103, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 103, 0, 0, 100,
|
|
0, 0, 0, 0, 0, 0, 801, 0, 0, 0,
|
|
318, 0, 318, 0, 0, 0, 0, 83, 0, 0,
|
|
100, 0, 103, 0, 0, 100, 317, 0, 0, 0,
|
|
0, 0, 0, 0, 404, 405, 406, 407, 408, 409,
|
|
410, 411, 412, 413, 414, 415, 0, 0, 0, 0,
|
|
416, 417, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 419, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 318, 0, 0,
|
|
101, 0, 101, 0, 420, 100, 421, 422, 423, 424,
|
|
425, 426, 427, 428, 429, 430, 100, 0, 0, 0,
|
|
0, 0, 0, 0, 100, 0, 0, 0, 83, 0,
|
|
0, 0, 0, 0, 100, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
101, 0, 0, 0, 0, 0, 0, 0, 651, 652,
|
|
0, 0, 653, 0, 0, 103, 0, 100, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 100, 174, 175, 176,
|
|
177, 178, 179, 180, 181, 0, 0, 182, 183, 0,
|
|
317, 0, 317, 184, 185, 186, 187, 0, 0, 0,
|
|
0, 0, 100, 0, 0, 0, 83, 188, 189, 190,
|
|
0, 0, 0, 83, 83, 0, 0, 0, 101, 0,
|
|
0, 83, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 191, 192, 193, 194, 195, 196, 197, 198, 199,
|
|
200, 0, 201, 202, 0, 0, 0, 0, 0, 0,
|
|
203, 276, 0, 0, 0, 0, 0, 317, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 83, 0, 0,
|
|
0, 0, 83, 0, 0, 0, 103, 0, 0, 0,
|
|
0, 0, 0, 318, 103, 623, 0, 0, 0, 0,
|
|
0, 623, 83, 0, 0, 0, 0, 623, 623, 0,
|
|
0, 0, 0, 103, 103, 0, 0, 0, 0, 101,
|
|
0, 0, 0, 83, 0, 0, 0, 103, 83, 0,
|
|
0, 618, 0, 0, 0, 100, 0, 0, 0, 103,
|
|
103, 0, 0, 0, 0, 0, 0, 103, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 103, 103,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 618, 618, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 128, 0, 0, 83, 0,
|
|
128, 0, 0, 0, 0, 0, 0, 101, 0, 83,
|
|
0, 0, 0, 0, 101, 101, 0, 83, 0, 0,
|
|
0, 0, 101, 623, 0, 0, 0, 83, 0, 0,
|
|
0, 0, 0, 103, 103, 0, 0, 995, 0, 0,
|
|
0, 103, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 100, 0, 0, 0,
|
|
83, 0, 0, 317, 100, 0, 0, 0, 101, 83,
|
|
0, 0, 0, 101, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 100, 100, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 101, 0, 83, 0, 100, 0, 0,
|
|
0, 103, 0, 103, 0, 0, 103, 0, 0, 100,
|
|
100, 0, 0, 0, 101, 0, 0, 100, 0, 101,
|
|
0, 0, 101, 0, 0, 0, 0, 0, 100, 100,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 801,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 127, 0, 0, 0, 0,
|
|
127, 0, 101, 101, 0, 0, 0, 404, 405, 406,
|
|
407, 408, 409, 410, 411, 412, 413, 414, 415, 101,
|
|
0, 0, 0, 416, 417, 0, 0, 0, 0, 0,
|
|
101, 0, 0, 100, 100, 0, 419, 994, 101, 0,
|
|
0, 100, 0, 0, 0, 0, 0, 0, 101, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 420, 83, 421,
|
|
422, 423, 424, 425, 426, 427, 428, 429, 430, 0,
|
|
404, 405, 406, 407, 408, 409, 0, -277, 412, 413,
|
|
0, 101, 0, 0, 0, 0, 416, 417, 0, 0,
|
|
101, 0, 0, 0, 0, 0, 0, 0, 0, 419,
|
|
0, 100, 0, 100, 0, 0, 100, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 101, 0, 0, 0,
|
|
0, 0, 421, 422, 423, 424, 425, 426, 427, 428,
|
|
429, 430, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 83,
|
|
0, 0, 0, 0, 0, 0, 0, 83, 618, 0,
|
|
0, 0, 0, 0, 618, 0, 0, 0, 0, 0,
|
|
618, 618, 0, 0, -597, 0, 83, 83, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, -597, -597, -597,
|
|
83, -597, -597, 0, -597, 0, 0, 0, 0, 0,
|
|
-597, 0, 83, 83, 0, 0, 0, 0, 0, 0,
|
|
83, -597, -597, 0, -597, -597, -597, -597, -597, 101,
|
|
0, 83, 83, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, -597, -597, -597, -597,
|
|
-597, -597, -597, -597, -597, -597, -597, -597, 0, 0,
|
|
0, 0, -597, -597, -597, 0, 806, -597, 0, 0,
|
|
0, 0, 0, 0, 0, -597, 618, 0, 0, -597,
|
|
0, 0, 0, 0, 0, 0, 83, 83, 0, -597,
|
|
992, 0, -597, -597, 83, -107, -597, 0, -597, -597,
|
|
-597, -597, -597, -597, -597, -597, -597, -597, 0, 0,
|
|
0, 0, -597, -597, -597, 0, -99, 0, 0, -597,
|
|
-597, -597, -597, 0, 0, 0, 0, 0, 0, 0,
|
|
101, 0, 0, 0, 0, 0, 0, 0, 101, 101,
|
|
0, 0, 0, 660, 661, 101, 0, 662, 0, 0,
|
|
0, 101, 101, 0, 83, 0, 83, 101, 101, 83,
|
|
0, 0, 174, 175, 176, 177, 178, 179, 180, 181,
|
|
0, 101, 182, 183, 0, 0, 0, 0, 184, 185,
|
|
186, 187, 0, 101, 101, 0, 0, 0, 0, 0,
|
|
0, 101, 188, 189, 190, 0, 0, 0, 0, 0,
|
|
0, 0, 101, 101, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 191, 192, 193, 194,
|
|
195, 196, 197, 198, 199, 200, 0, 201, 202, 0,
|
|
0, 0, 0, 0, 0, 203, 276, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 101, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 101, 101, 0,
|
|
0, 0, 0, 0, 0, 101, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, -620, 3, 0,
|
|
4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
|
|
0, 0, 0, 0, 0, 0, 14, 0, 15, 16,
|
|
17, 18, 0, 0, 0, 0, 0, 19, 20, 21,
|
|
22, 23, 24, 25, 0, 101, 26, 101, 0, 0,
|
|
101, 0, 27, 28, 29, 30, 31, 32, 33, 34,
|
|
35, 36, 37, 38, 0, 39, 40, 41, 0, 0,
|
|
42, 0, 0, 43, 44, 0, 45, 46, 47, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 48, 49, 0, 0, 0, 0, 0, 50, 0,
|
|
0, 51, 52, 0, 53, 54, 0, 55, 0, 0,
|
|
0, 56, 0, 57, 58, 59, 0, 60, 61, 62,
|
|
-293, 63, -620, 0, 0, -620, -620, 0, 0, 0,
|
|
0, 0, 0, -293, -293, -293, -293, -293, -293, 0,
|
|
-293, 64, 65, 66, 0, 0, 0, -293, -293, -293,
|
|
0, 0, 0, -620, 0, -620, 0, -293, -293, 0,
|
|
-293, -293, -293, -293, -293, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, -293, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, -293, -293, -293, -293, -293, -293, -293, -293,
|
|
-293, -293, -293, -293, 0, 0, 0, 0, -293, -293,
|
|
-293, 0, 0, -293, 0, 0, 0, 0, 0, -293,
|
|
0, -293, 0, 0, 0, -293, 0, 0, 0, 0,
|
|
0, 0, 0, -293, 0, -293, 0, 0, -293, -293,
|
|
0, 0, -293, -293, -293, -293, -293, -293, -293, -293,
|
|
-293, -293, -293, -293, 0, 0, -481, 0, 0, -293,
|
|
-293, -293, -293, 0, 0, -293, -293, -293, -293, -481,
|
|
-481, -481, -481, -481, -481, 0, -481, 0, 0, 0,
|
|
0, 0, 0, -481, -481, 0, 0, 0, 0, 0,
|
|
0, 0, 0, -481, -481, 0, -481, -481, -481, -481,
|
|
-481, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 496, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, -481, -481,
|
|
-481, -481, -481, -481, -481, -481, -481, -481, -481, -481,
|
|
0, 0, 0, 0, -481, -481, -481, 0, -481, -481,
|
|
0, 0, 0, 0, 0, -481, 0, -481, 0, 0,
|
|
0, -481, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, -481, 0, 0, -481, -481, 0, -481, -481, 0,
|
|
-481, -481, -481, -481, -481, -481, -481, -481, -481, -481,
|
|
0, 0, -620, 0, 0, -481, -481, -481, -481, 0,
|
|
0, -481, -481, -481, -481, -620, -620, -620, -620, -620,
|
|
-620, 0, -620, 0, 0, 0, 0, 0, -620, -620,
|
|
-620, 0, 0, 0, 0, 0, 0, 0, 0, -620,
|
|
-620, 0, -620, -620, -620, -620, -620, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, -620, -620, -620, -620, -620, -620,
|
|
-620, -620, -620, -620, -620, -620, 0, 0, 0, 0,
|
|
-620, -620, -620, 0, 0, -620, 0, 0, 0, 0,
|
|
0, -620, 0, -620, 0, 0, 0, -620, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, -620, 0, 0,
|
|
-620, -620, 0, 0, -620, 0, -620, -620, -620, -620,
|
|
-620, -620, -620, -620, -620, -620, 0, 0, -620, 0,
|
|
-620, -620, -620, -620, -620, 0, 276, -620, -620, -620,
|
|
-620, -620, -620, -620, -620, -620, -620, 0, -620, 0,
|
|
0, 0, 0, 0, 0, -620, -620, 0, 0, 0,
|
|
0, 0, 0, 0, 0, -620, -620, 0, -620, -620,
|
|
-620, -620, -620, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
-620, -620, -620, -620, -620, -620, -620, -620, -620, -620,
|
|
-620, -620, 0, 0, 0, 0, -620, -620, -620, 0,
|
|
0, -620, 0, 0, 0, 0, 0, -620, 0, -620,
|
|
0, 0, 0, -620, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, -620, 0, 0, -620, -620, 0, 0,
|
|
-620, 0, -620, -620, -620, -620, -620, -620, -620, -620,
|
|
-620, -620, 0, 0, -597, 0, 0, -620, -620, -620,
|
|
-620, 0, 276, -620, -620, -620, -620, -597, -597, -597,
|
|
0, -597, -597, 0, -597, 0, 0, 0, 0, 0,
|
|
-597, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, -597, -597, 0, -597, -597, -597, -597, -597, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, -597, -597, -597, -597,
|
|
-597, -597, -597, -597, -597, -597, -597, -597, 0, 0,
|
|
0, 0, -597, -597, -597, 0, 806, -597, 0, 0,
|
|
0, 0, 0, 0, 0, -597, 0, 0, 0, -597,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, -597,
|
|
0, 0, -597, -597, 0, -107, -597, 0, -597, -597,
|
|
-597, -597, -597, -597, -597, -597, -597, -597, 0, 0,
|
|
-302, 0, -597, -597, -597, 0, -597, 0, 0, -597,
|
|
-597, -597, -597, -302, -302, -302, 0, -302, -302, 0,
|
|
-302, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, -302, -302, 0,
|
|
-302, -302, -302, -302, -302, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, -302, -302, -302, -302, -302, -302, -302, -302,
|
|
-302, -302, -302, -302, 0, 0, 0, 0, -302, -302,
|
|
-302, 0, 807, -302, 0, 0, 0, 0, 0, 0,
|
|
0, -302, 0, 0, 0, -302, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, -302, 0, 0, -302, -302,
|
|
0, -109, -302, 0, -302, -302, -302, -302, -302, -302,
|
|
-302, -302, -302, -302, 0, 0, -302, 0, 0, -302,
|
|
-302, 0, -101, 0, 0, -302, -302, -302, -302, -302,
|
|
-302, -302, 0, -302, -302, 0, -302, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, -302, -302, 0, -302, -302, -302, -302,
|
|
-302, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, -302, -302,
|
|
-302, -302, -302, -302, -302, -302, -302, -302, -302, -302,
|
|
0, 0, 0, 0, -302, -302, -302, 0, 807, -302,
|
|
0, 0, 0, 0, 0, 0, 0, -302, 0, 0,
|
|
0, -302, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, -302, 0, 0, -302, -302, 0, -109, -302, 0,
|
|
-302, -302, -302, -302, -302, -302, -302, -302, -302, -302,
|
|
0, 0, 0, 0, 0, -302, -302, 0, -302, 0,
|
|
0, -302, -302, -302, -302, 295, 0, 4, 5, 6,
|
|
7, 8, 9, 10, 11, 12, 13, -620, -620, -620,
|
|
0, 0, -620, 14, 0, 15, 16, 17, 18, 0,
|
|
0, 0, 0, 0, 19, 20, 21, 22, 23, 24,
|
|
25, 0, 0, 26, 0, 0, 0, 0, 0, 27,
|
|
0, 29, 30, 31, 32, 33, 34, 35, 36, 37,
|
|
38, 0, 39, 40, 41, 0, 0, 42, 0, 0,
|
|
43, 44, 0, 45, 46, 47, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 48, 49,
|
|
0, 0, 0, 0, 0, 50, 0, 0, 51, 52,
|
|
0, 53, 54, 0, 55, 0, 0, 0, 56, 0,
|
|
57, 58, 59, 0, 60, 61, 62, 0, 63, -620,
|
|
0, 0, -620, -620, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 64, 65,
|
|
66, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
-620, 295, -620, 4, 5, 6, 7, 8, 9, 10,
|
|
11, 12, 13, 0, 0, -620, 0, -620, -620, 14,
|
|
0, 15, 16, 17, 18, 0, 0, 0, 0, 0,
|
|
19, 20, 21, 22, 23, 24, 25, 0, 0, 26,
|
|
0, 0, 0, 0, 0, 27, 0, 29, 30, 31,
|
|
32, 33, 34, 35, 36, 37, 38, 0, 39, 40,
|
|
41, 0, 0, 42, 0, 0, 43, 44, 0, 45,
|
|
46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 48, 49, 0, 0, 0, 0,
|
|
0, 50, 0, 0, 51, 52, 0, 53, 54, 0,
|
|
55, 0, 0, 0, 56, 0, 57, 58, 59, 0,
|
|
60, 61, 62, 0, 63, -620, 0, 0, -620, -620,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 64, 65, 66, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, -620, 295, -620, 4,
|
|
5, 6, 7, 8, 9, 10, 11, 12, 13, 0,
|
|
0, -620, 0, 0, -620, 14, -620, 15, 16, 17,
|
|
18, 0, 0, 0, 0, 0, 19, 20, 21, 22,
|
|
23, 24, 25, 0, 0, 26, 0, 0, 0, 0,
|
|
0, 27, 0, 29, 30, 31, 32, 33, 34, 35,
|
|
36, 37, 38, 0, 39, 40, 41, 0, 0, 42,
|
|
0, 0, 43, 44, 0, 45, 46, 47, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
48, 49, 0, 0, 0, 0, 0, 50, 0, 0,
|
|
51, 52, 0, 53, 54, 0, 55, 0, 0, 0,
|
|
56, 0, 57, 58, 59, 0, 60, 61, 62, 0,
|
|
63, -620, 0, 0, -620, -620, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
64, 65, 66, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, -620, 295, -620, 4, 5, 6, 7, 8,
|
|
9, 10, 11, 12, 13, 0, 0, -620, 0, 0,
|
|
-620, 14, 0, 15, 16, 17, 18, 0, 0, 0,
|
|
0, 0, 19, 20, 21, 22, 23, 24, 25, 0,
|
|
0, 26, 0, 0, 0, 0, 0, 27, 0, 29,
|
|
30, 31, 32, 33, 34, 35, 36, 37, 38, 0,
|
|
39, 40, 41, 0, 0, 42, 0, 0, 43, 44,
|
|
0, 45, 46, 47, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 48, 49, 0, 0,
|
|
0, 0, 0, 50, 0, 0, 51, 52, 0, 53,
|
|
54, 0, 55, 0, 0, 0, 56, 0, 57, 58,
|
|
59, 0, 60, 61, 62, 0, 63, -620, 0, 0,
|
|
-620, -620, 3, 0, 4, 5, 6, 7, 8, 9,
|
|
10, 11, 12, 13, 0, 0, 64, 65, 66, 0,
|
|
14, 0, 15, 16, 17, 18, 0, 0, -620, 0,
|
|
-620, 19, 20, 21, 22, 23, 24, 25, 0, 0,
|
|
26, 0, 0, 0, 0, 0, 27, 28, 29, 30,
|
|
31, 32, 33, 34, 35, 36, 37, 38, 0, 39,
|
|
40, 41, 0, 0, 42, 0, 0, 43, 44, 0,
|
|
45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
|
|
0, 0, 50, 0, 0, 51, 52, 0, 53, 54,
|
|
0, 55, 0, 0, 0, 56, 0, 57, 58, 59,
|
|
0, 60, 61, 62, 0, 63, -620, 0, 0, -620,
|
|
-620, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 64, 65, 66, 0, 0,
|
|
-620, 0, 0, 0, 0, 0, 0, -620, 295, -620,
|
|
4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
|
|
0, -620, -620, 0, 0, 0, 14, 0, 15, 16,
|
|
17, 18, 0, 0, 0, 0, 0, 19, 20, 21,
|
|
22, 23, 24, 25, 0, 0, 26, 0, 0, 0,
|
|
0, 0, 27, 0, 29, 30, 31, 32, 33, 34,
|
|
35, 36, 37, 38, 0, 39, 40, 41, 0, 0,
|
|
42, 0, 0, 43, 44, 0, 45, 46, 47, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 48, 49, 0, 0, 0, 0, 0, 50, 0,
|
|
0, 51, 52, 0, 53, 54, 0, 55, 0, 0,
|
|
0, 56, 0, 57, 58, 59, 0, 60, 61, 62,
|
|
0, 63, -620, 0, 0, -620, -620, 295, 0, 4,
|
|
5, 6, 7, 8, 9, 10, 11, 12, 13, 0,
|
|
0, 64, 65, 66, 0, 14, 0, 15, 16, 17,
|
|
18, 0, 0, -620, 0, -620, 19, 20, 21, 22,
|
|
23, 24, 25, 0, 0, 26, 0, 0, 0, 0,
|
|
0, 27, 0, 29, 30, 31, 32, 33, 34, 35,
|
|
36, 37, 38, 0, 39, 40, 41, 0, 0, 42,
|
|
0, 0, 43, 44, 0, 45, 46, 47, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
48, 49, 0, 0, 0, 0, 0, 50, 0, 0,
|
|
296, 52, 0, 53, 54, 0, 55, 0, 0, 0,
|
|
56, 0, 57, 58, 59, 0, 60, 61, 62, 0,
|
|
63, -620, 0, 0, -620, -620, 295, 0, 4, 5,
|
|
6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
|
|
64, 65, 66, 0, 14, 0, 15, 16, 17, 18,
|
|
0, -620, -620, 0, -620, 19, 20, 21, 22, 23,
|
|
24, 25, 0, 0, 26, 0, 0, 0, 0, 0,
|
|
27, 0, 29, 30, 31, 32, 33, 34, 35, 36,
|
|
37, 38, 0, 39, 40, 41, 0, 0, 42, 0,
|
|
0, 43, 44, 0, 45, 46, 47, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
|
|
49, 0, 0, 0, 0, 0, 50, 0, 0, 51,
|
|
52, 0, 53, 54, 0, 55, 0, 0, 0, 56,
|
|
0, 57, 58, 59, 0, 60, 61, 62, 0, 63,
|
|
-620, 0, 0, -620, -620, 295, 0, 4, 5, 6,
|
|
7, 8, 9, 10, 11, 12, 13, 0, 0, 64,
|
|
65, 66, 0, 14, 0, 15, 16, 17, 18, 0,
|
|
-620, -620, 0, -620, 19, 20, 21, 22, 23, 24,
|
|
25, 0, 0, 26, 0, 0, 0, 0, 0, 27,
|
|
0, 29, 30, 31, 32, 33, 34, 35, 36, 37,
|
|
38, 0, 39, 40, 41, 0, 0, 42, 0, 0,
|
|
43, 44, 0, 45, 46, 47, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 48, 49,
|
|
0, 0, 0, 0, 0, 50, 0, 0, 51, 52,
|
|
0, 53, 54, 0, 55, 0, 0, 0, 56, 0,
|
|
57, 58, 59, 0, 60, 61, 62, 0, 63, -620,
|
|
0, 0, -620, -620, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 64, 65,
|
|
66, 0, 0, -620, 0, 0, 0, 0, 0, 0,
|
|
-620, 295, -620, 4, 5, 6, 7, 8, 9, 10,
|
|
11, 12, 13, 0, 0, -620, 0, 0, 0, 14,
|
|
0, 15, 16, 17, 18, 0, 0, 0, 0, 0,
|
|
19, 20, 21, 22, 23, 24, 25, 0, 0, 26,
|
|
0, 0, 0, 0, 0, 27, 0, 29, 30, 31,
|
|
32, 33, 34, 35, 36, 37, 38, 0, 39, 40,
|
|
41, 0, 0, 42, 0, 0, 43, 44, 0, 45,
|
|
46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 48, 49, 0, 0, 0, 0,
|
|
0, 50, 0, 0, 51, 52, 0, 53, 54, 0,
|
|
55, 0, 0, 0, 56, 0, 57, 58, 59, 0,
|
|
60, 61, 62, 0, 63, -620, 0, 0, -620, -620,
|
|
0, 0, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, 13, 0, 0, 64, 65, 66, 0, 14, 0,
|
|
15, 16, 17, 18, 0, 0, -620, 0, -620, 19,
|
|
20, 21, 22, 23, 24, 25, 0, 0, 26, 0,
|
|
0, 0, 0, 0, 27, 28, 29, 30, 31, 32,
|
|
33, 34, 35, 36, 37, 38, 0, 39, 40, 41,
|
|
0, 0, 42, 0, 0, 43, 44, 0, 45, 46,
|
|
47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
|
|
50, 0, 0, 51, 52, 0, 53, 54, 0, 55,
|
|
0, 0, 0, 56, 0, 57, 58, 59, 0, 60,
|
|
61, 62, 0, 63, 247, 0, 0, 248, 249, 0,
|
|
0, 4, 5, 6, 7, 8, 9, 10, 11, 12,
|
|
13, 0, 0, 64, 65, 66, 0, 14, 0, 15,
|
|
16, 17, 18, 0, 0, 250, 0, 251, 19, 20,
|
|
21, 22, 23, 24, 25, 0, 0, 26, 0, 0,
|
|
0, 0, 0, 27, 0, 29, 30, 31, 32, 33,
|
|
34, 35, 36, 37, 38, 0, 39, 40, 41, 0,
|
|
0, 42, 0, 0, 43, 44, 0, 45, 46, 47,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 48, 49, 0, 0, 0, 0, 0, 50,
|
|
0, 0, 51, 52, 0, 53, 54, 0, 55, 0,
|
|
0, 0, 56, 0, 57, 58, 59, 0, 60, 61,
|
|
62, 0, 63, 247, 0, 0, 248, 249, 0, 0,
|
|
4, 5, 6, 7, 8, 9, 10, 11, 12, 0,
|
|
0, 0, 64, 65, 66, 0, 14, 0, 15, 16,
|
|
17, 18, 0, 0, 250, 0, 251, 19, 20, 21,
|
|
22, 23, 24, 25, 0, 0, 26, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 30, 31, 32, 33, 34,
|
|
35, 36, 37, 38, 0, 39, 40, 41, 0, 0,
|
|
42, 0, 0, 43, 44, 0, 45, 46, 47, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 48, 49, 0, 0, 0, 0, 0, 211, 0,
|
|
0, 119, 52, 0, 53, 54, 0, 0, 0, 0,
|
|
0, 56, 0, 57, 58, 59, 0, 60, 61, 62,
|
|
0, 63, 247, 0, 0, 248, 249, 0, 0, 4,
|
|
5, 6, 7, 8, 9, 10, 11, 12, 0, 0,
|
|
0, 64, 65, 66, 0, 14, 0, 108, 109, 17,
|
|
18, 0, 0, 250, 0, 251, 110, 111, 112, 22,
|
|
23, 24, 25, 0, 0, 113, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 30, 31, 32, 33, 34, 35,
|
|
36, 37, 38, 0, 39, 40, 41, 0, 0, 42,
|
|
0, 0, 43, 44, 0, 45, 46, 47, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
48, 49, 0, 0, 0, 0, 0, 211, 0, 0,
|
|
119, 52, 0, 53, 54, 0, 0, 0, 0, 0,
|
|
56, 0, 57, 58, 59, 0, 60, 61, 62, 0,
|
|
63, 247, 0, 0, 248, 249, 0, 0, 4, 5,
|
|
6, 7, 8, 9, 10, 11, 12, 0, 0, 0,
|
|
64, 265, 66, 0, 14, 0, 15, 16, 17, 18,
|
|
0, 0, 250, 0, 251, 19, 20, 21, 22, 23,
|
|
24, 25, 0, 0, 26, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 30, 31, 32, 33, 34, 35, 36,
|
|
37, 38, 0, 39, 40, 41, 0, 0, 42, 0,
|
|
0, 43, 44, 0, 45, 46, 47, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
|
|
49, 0, 0, 0, 0, 0, 211, 0, 0, 119,
|
|
52, 0, 53, 54, 0, 0, 0, 0, 0, 56,
|
|
0, 57, 58, 59, 0, 60, 61, 62, 0, 63,
|
|
247, 0, 0, 248, 249, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 64,
|
|
65, 66, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 251, 131, 132, 133, 134, 135, 136,
|
|
137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
|
|
147, 148, 149, 150, 151, 152, 153, 154, 0, 0,
|
|
0, 155, 156, 157, 158, 159, 160, 161, 162, 163,
|
|
164, 0, 0, 0, 0, 0, 165, 166, 167, 168,
|
|
169, 170, 171, 172, 35, 36, 173, 38, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
116, 174, 175, 176, 177, 178, 179, 180, 181, 0,
|
|
0, 182, 183, 0, 0, 0, 0, 184, 185, 186,
|
|
187, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 188, 189, 190, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 191, 192, 193, 194, 195,
|
|
196, 197, 198, 199, 200, 0, 201, 202, 0, 0,
|
|
0, 0, 0, 0, 203, 204, -590, -590, -590, -590,
|
|
-590, -590, -590, -590, -590, 0, 0, 0, 0, 0,
|
|
0, 0, -590, 0, -590, -590, -590, -590, 0, -590,
|
|
0, 0, 0, -590, -590, -590, -590, -590, -590, -590,
|
|
0, 0, -590, 0, 0, 0, 0, 0, 0, 0,
|
|
0, -590, -590, -590, -590, -590, -590, -590, -590, -590,
|
|
0, -590, -590, -590, 0, 0, -590, 0, 0, -590,
|
|
-590, 0, -590, -590, -590, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, -590, -590, 0,
|
|
0, 0, 0, 0, -590, 0, 0, -590, -590, 0,
|
|
-590, -590, 0, -590, 0, -590, -590, -590, 0, -590,
|
|
-590, -590, 0, -590, -590, -590, 0, -590, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, -590, -590, -590,
|
|
0, -590, 0, 0, 0, 0, 0, -590, -591, -591,
|
|
-591, -591, -591, -591, -591, -591, -591, 0, 0, 0,
|
|
0, 0, 0, 0, -591, 0, -591, -591, -591, -591,
|
|
0, -591, 0, 0, 0, -591, -591, -591, -591, -591,
|
|
-591, -591, 0, 0, -591, 0, 0, 0, 0, 0,
|
|
0, 0, 0, -591, -591, -591, -591, -591, -591, -591,
|
|
-591, -591, 0, -591, -591, -591, 0, 0, -591, 0,
|
|
0, -591, -591, 0, -591, -591, -591, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, -591,
|
|
-591, 0, 0, 0, 0, 0, -591, 0, 0, -591,
|
|
-591, 0, -591, -591, 0, -591, 0, -591, -591, -591,
|
|
0, -591, -591, -591, 0, -591, -591, -591, 0, -591,
|
|
0, 0, 0, 0, 0, 0, -593, -593, -593, -593,
|
|
-593, -593, -593, -593, -593, 0, 0, 0, 0, -591,
|
|
-591, -591, -593, -591, -593, -593, -593, -593, 0, -591,
|
|
0, 0, 0, -593, -593, -593, -593, -593, -593, -593,
|
|
0, 0, -593, 0, 0, 0, 0, 0, 0, 0,
|
|
0, -593, -593, -593, -593, -593, -593, -593, -593, -593,
|
|
0, -593, -593, -593, 0, 0, -593, 0, 0, -593,
|
|
-593, 0, -593, -593, -593, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, -593, -593, 0,
|
|
0, 0, 0, 0, -593, 838, 0, -593, -593, 0,
|
|
-593, -593, 0, -593, 0, -593, -593, -593, 0, -593,
|
|
-593, -593, 0, -593, -593, -593, 0, -593, 0, 0,
|
|
0, 0, 0, 0, -107, -594, -594, -594, -594, -594,
|
|
-594, -594, -594, -594, 0, 0, 0, -593, -593, -593,
|
|
0, -594, 0, -594, -594, -594, -594, -593, 0, 0,
|
|
0, 0, -594, -594, -594, -594, -594, -594, -594, 0,
|
|
0, -594, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
-594, -594, -594, -594, -594, -594, -594, -594, -594, 0,
|
|
-594, -594, -594, 0, 0, -594, 0, 0, -594, -594,
|
|
0, -594, -594, -594, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, -594, -594, 0, 0,
|
|
0, 0, 0, -594, 839, 0, -594, -594, 0, -594,
|
|
-594, 0, -594, 0, -594, -594, -594, 0, -594, -594,
|
|
-594, 0, -594, -594, -594, 0, -594, 0, 0, 0,
|
|
0, 0, 0, -109, -595, -595, -595, -595, -595, -595,
|
|
-595, -595, -595, 0, 0, 0, -594, -594, -594, 0,
|
|
-595, 0, -595, -595, -595, -595, -594, 0, 0, 0,
|
|
0, -595, -595, -595, -595, -595, -595, -595, 0, 0,
|
|
-595, 0, 0, 0, 0, 0, 0, 0, 0, -595,
|
|
-595, -595, -595, -595, -595, -595, -595, -595, 0, -595,
|
|
-595, -595, 0, 0, -595, 0, 0, -595, -595, 0,
|
|
-595, -595, -595, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, -595, -595, 0, 0, 0,
|
|
0, 0, -595, 0, 0, -595, -595, 0, -595, -595,
|
|
0, -595, 0, -595, -595, -595, 0, -595, -595, -595,
|
|
0, -595, -595, -595, 0, -595, 0, 0, 0, 0,
|
|
0, 0, -596, -596, -596, -596, -596, -596, -596, -596,
|
|
-596, 0, 0, 0, 0, -595, -595, -595, -596, 0,
|
|
-596, -596, -596, -596, 0, -595, 0, 0, 0, -596,
|
|
-596, -596, -596, -596, -596, -596, 0, 0, -596, 0,
|
|
0, 0, 0, 0, 0, 0, 0, -596, -596, -596,
|
|
-596, -596, -596, -596, -596, -596, 0, -596, -596, -596,
|
|
0, 0, -596, 0, 0, -596, -596, 0, -596, -596,
|
|
-596, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, -596, -596, 0, 0, 0, 0, 0,
|
|
-596, 0, 0, -596, -596, 0, -596, -596, 0, -596,
|
|
0, -596, -596, -596, 0, -596, -596, -596, 0, -596,
|
|
-596, -596, 0, -596, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, -596, -596, -596, 0, 0, 0, 0,
|
|
0, 0, 0, -596, 131, 132, 133, 134, 135, 136,
|
|
137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
|
|
147, 148, 149, 150, 151, 152, 153, 154, 0, 0,
|
|
0, 155, 156, 157, 233, 234, 235, 236, 162, 163,
|
|
164, 0, 0, 0, 0, 0, 165, 166, 167, 237,
|
|
238, 239, 240, 172, 320, 321, 241, 322, 0, 0,
|
|
0, 0, 0, 0, 323, 0, 0, 0, 0, 0,
|
|
324, 174, 175, 176, 177, 178, 179, 180, 181, 0,
|
|
0, 182, 183, 0, 0, 0, 0, 184, 185, 186,
|
|
187, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 188, 189, 190, 0, 0, 0, 0, 325, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 191, 192, 193, 194, 195,
|
|
196, 197, 198, 199, 200, 0, 201, 202, 0, 0,
|
|
0, 0, 0, 0, 203, 131, 132, 133, 134, 135,
|
|
136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
|
|
146, 147, 148, 149, 150, 151, 152, 153, 154, 0,
|
|
0, 0, 155, 156, 157, 233, 234, 235, 236, 162,
|
|
163, 164, 0, 0, 0, 0, 0, 165, 166, 167,
|
|
237, 238, 239, 240, 172, 320, 321, 241, 322, 0,
|
|
0, 0, 0, 0, 0, 323, 0, 0, 0, 0,
|
|
0, 0, 174, 175, 176, 177, 178, 179, 180, 181,
|
|
0, 0, 182, 183, 0, 0, 0, 0, 184, 185,
|
|
186, 187, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 188, 189, 190, 0, 0, 0, 0, 487,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 191, 192, 193, 194,
|
|
195, 196, 197, 198, 199, 200, 0, 201, 202, 0,
|
|
0, 0, 0, 0, 0, 203, 131, 132, 133, 134,
|
|
135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
|
|
145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
|
|
0, 0, 0, 155, 156, 157, 233, 234, 235, 236,
|
|
162, 163, 164, 0, 0, 0, 0, 0, 165, 166,
|
|
167, 237, 238, 239, 240, 172, 0, 0, 241, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 174, 175, 176, 177, 178, 179, 180,
|
|
181, 0, 0, 182, 183, 0, 0, 0, 0, 184,
|
|
185, 186, 187, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 188, 189, 190, 0, 0, 0, 242,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 191, 192, 193,
|
|
194, 195, 196, 197, 198, 199, 200, 0, 201, 202,
|
|
0, 0, 0, 0, 0, 0, 203, 131, 132, 133,
|
|
134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
|
|
144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
|
|
154, 0, 0, 0, 155, 156, 157, 233, 234, 235,
|
|
236, 162, 163, 164, 0, 0, 0, 0, 0, 165,
|
|
166, 167, 237, 238, 239, 240, 172, 0, 0, 241,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 174, 175, 176, 177, 178, 179,
|
|
180, 181, 0, 0, 182, 183, 0, 0, 0, 0,
|
|
184, 185, 186, 187, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 188, 189, 190, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 191, 192,
|
|
193, 194, 195, 196, 197, 198, 199, 200, 0, 201,
|
|
202, 0, 0, 0, 0, 0, 0, 203, 4, 5,
|
|
6, 7, 8, 9, 10, 11, 12, 0, 0, 0,
|
|
0, 0, 0, 0, 14, 0, 108, 109, 17, 18,
|
|
0, 0, 0, 0, 0, 110, 111, 112, 22, 23,
|
|
24, 25, 0, 0, 113, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 30, 31, 32, 33, 34, 35, 36,
|
|
37, 38, 0, 39, 40, 41, 0, 0, 42, 0,
|
|
0, 43, 44, 0, 116, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 313, 0, 0, 119,
|
|
52, 0, 53, 54, 0, 0, 0, 0, 0, 56,
|
|
0, 57, 58, 59, 0, 60, 61, 62, 0, 63,
|
|
0, 0, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, 0, 0, 0, 0, 0, 0, 0, 14, 120,
|
|
108, 109, 17, 18, 0, 0, 0, 314, 0, 110,
|
|
111, 112, 22, 23, 24, 25, 0, 0, 113, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 30, 31, 32,
|
|
33, 34, 35, 36, 37, 38, 0, 39, 40, 41,
|
|
0, 0, 42, 0, 0, 43, 44, 0, 116, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
313, 0, 0, 119, 52, 0, 53, 54, 0, 0,
|
|
0, 0, 0, 56, 0, 57, 58, 59, 0, 60,
|
|
61, 62, 0, 63, 0, 0, 4, 5, 6, 7,
|
|
8, 9, 10, 11, 12, 13, 0, 0, 0, 0,
|
|
0, 0, 14, 120, 15, 16, 17, 18, 0, 0,
|
|
0, 612, 0, 19, 20, 21, 22, 23, 24, 25,
|
|
0, 0, 26, 0, 0, 0, 0, 0, 27, 28,
|
|
29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
|
|
0, 39, 40, 41, 0, 0, 42, 0, 0, 43,
|
|
44, 0, 45, 46, 47, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
|
|
0, 0, 0, 0, 50, 0, 0, 51, 52, 0,
|
|
53, 54, 0, 55, 0, 0, 0, 56, 0, 57,
|
|
58, 59, 0, 60, 61, 62, 0, 63, 0, 0,
|
|
0, 0, 0, 0, 4, 5, 6, 7, 8, 9,
|
|
10, 11, 12, 13, 0, 0, 0, 64, 65, 66,
|
|
14, 0, 15, 16, 17, 18, 0, 0, 0, 0,
|
|
0, 19, 20, 21, 22, 23, 24, 25, 0, 0,
|
|
26, 0, 0, 0, 0, 0, 27, 0, 29, 30,
|
|
31, 32, 33, 34, 35, 36, 37, 38, 0, 39,
|
|
40, 41, 0, 0, 42, 0, 0, 43, 44, 0,
|
|
45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
|
|
0, 0, 50, 0, 0, 51, 52, 0, 53, 54,
|
|
0, 55, 0, 0, 0, 56, 0, 57, 58, 59,
|
|
0, 60, 61, 62, 0, 63, 0, 0, 0, 0,
|
|
0, 0, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, 0, 0, 0, 0, 64, 65, 66, 14, 0,
|
|
15, 16, 17, 18, 0, 0, 0, 0, 0, 19,
|
|
20, 21, 22, 23, 24, 25, 0, 0, 113, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 30, 31, 32,
|
|
260, 34, 35, 36, 37, 38, 0, 39, 40, 41,
|
|
0, 0, 42, 0, 0, 43, 44, 0, 261, 46,
|
|
47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
|
|
211, 0, 0, 119, 52, 0, 53, 54, 0, 262,
|
|
0, 263, 264, 56, 0, 57, 58, 59, 0, 60,
|
|
61, 62, 0, 63, 0, 0, 0, 0, 0, 0,
|
|
4, 5, 6, 7, 8, 9, 10, 11, 12, 0,
|
|
0, 0, 0, 64, 265, 66, 14, 0, 15, 16,
|
|
17, 18, 0, 0, 0, 0, 0, 19, 20, 21,
|
|
22, 23, 24, 25, 0, 0, 113, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 30, 31, 32, 260, 34,
|
|
35, 36, 37, 38, 0, 39, 40, 41, 0, 0,
|
|
42, 0, 0, 43, 44, 0, 261, 46, 47, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 48, 509, 0, 0, 0, 0, 0, 211, 0,
|
|
0, 119, 52, 0, 53, 54, 0, 262, 0, 263,
|
|
264, 56, 0, 57, 58, 59, 0, 60, 61, 62,
|
|
0, 63, 0, 0, 0, 0, 0, 0, 4, 5,
|
|
6, 7, 8, 9, 10, 11, 12, 0, 0, 0,
|
|
0, 64, 265, 66, 14, 0, 108, 109, 17, 18,
|
|
0, 0, 0, 0, 0, 110, 111, 112, 22, 23,
|
|
24, 25, 0, 0, 113, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 30, 31, 32, 260, 34, 35, 36,
|
|
37, 38, 0, 39, 40, 41, 0, 0, 42, 0,
|
|
0, 43, 44, 0, 261, 46, 47, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
|
|
49, 0, 0, 0, 0, 0, 211, 0, 0, 119,
|
|
52, 0, 53, 54, 0, 724, 0, 263, 264, 56,
|
|
0, 57, 58, 59, 0, 60, 61, 62, 0, 63,
|
|
0, 0, 0, 0, 0, 0, 4, 5, 6, 7,
|
|
8, 9, 10, 11, 12, 0, 0, 0, 0, 64,
|
|
265, 66, 14, 0, 108, 109, 17, 18, 0, 0,
|
|
0, 0, 0, 110, 111, 112, 22, 23, 24, 25,
|
|
0, 0, 113, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 30, 31, 32, 260, 34, 35, 36, 37, 38,
|
|
0, 39, 40, 41, 0, 0, 42, 0, 0, 43,
|
|
44, 0, 261, 46, 47, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 48, 855, 0,
|
|
0, 0, 0, 0, 211, 0, 0, 119, 52, 0,
|
|
53, 54, 0, 724, 0, 263, 264, 56, 0, 57,
|
|
58, 59, 0, 60, 61, 62, 0, 63, 0, 0,
|
|
0, 0, 0, 0, 4, 5, 6, 7, 8, 9,
|
|
10, 11, 12, 0, 0, 0, 0, 64, 265, 66,
|
|
14, 0, 108, 109, 17, 18, 0, 0, 0, 0,
|
|
0, 110, 111, 112, 22, 23, 24, 25, 0, 0,
|
|
113, 0, 0, 0, 0, 0, 0, 0, 0, 30,
|
|
31, 32, 260, 34, 35, 36, 37, 38, 0, 39,
|
|
40, 41, 0, 0, 42, 0, 0, 43, 44, 0,
|
|
261, 46, 47, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
|
|
0, 0, 211, 0, 0, 119, 52, 0, 53, 54,
|
|
0, 262, 0, 263, 0, 56, 0, 57, 58, 59,
|
|
0, 60, 61, 62, 0, 63, 0, 0, 0, 0,
|
|
0, 0, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, 0, 0, 0, 0, 64, 265, 66, 14, 0,
|
|
108, 109, 17, 18, 0, 0, 0, 0, 0, 110,
|
|
111, 112, 22, 23, 24, 25, 0, 0, 113, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 30, 31, 32,
|
|
260, 34, 35, 36, 37, 38, 0, 39, 40, 41,
|
|
0, 0, 42, 0, 0, 43, 44, 0, 261, 46,
|
|
47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
|
|
211, 0, 0, 119, 52, 0, 53, 54, 0, 0,
|
|
0, 263, 264, 56, 0, 57, 58, 59, 0, 60,
|
|
61, 62, 0, 63, 0, 0, 0, 0, 0, 0,
|
|
4, 5, 6, 7, 8, 9, 10, 11, 12, 0,
|
|
0, 0, 0, 64, 265, 66, 14, 0, 108, 109,
|
|
17, 18, 0, 0, 0, 0, 0, 110, 111, 112,
|
|
22, 23, 24, 25, 0, 0, 113, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 30, 31, 32, 260, 34,
|
|
35, 36, 37, 38, 0, 39, 40, 41, 0, 0,
|
|
42, 0, 0, 43, 44, 0, 261, 46, 47, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 48, 49, 0, 0, 0, 0, 0, 211, 0,
|
|
0, 119, 52, 0, 53, 54, 0, 724, 0, 263,
|
|
0, 56, 0, 57, 58, 59, 0, 60, 61, 62,
|
|
0, 63, 0, 0, 0, 0, 0, 0, 4, 5,
|
|
6, 7, 8, 9, 10, 11, 12, 0, 0, 0,
|
|
0, 64, 265, 66, 14, 0, 108, 109, 17, 18,
|
|
0, 0, 0, 0, 0, 110, 111, 112, 22, 23,
|
|
24, 25, 0, 0, 113, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 30, 31, 32, 260, 34, 35, 36,
|
|
37, 38, 0, 39, 40, 41, 0, 0, 42, 0,
|
|
0, 43, 44, 0, 261, 46, 47, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
|
|
49, 0, 0, 0, 0, 0, 211, 0, 0, 119,
|
|
52, 0, 53, 54, 0, 0, 0, 263, 0, 56,
|
|
0, 57, 58, 59, 0, 60, 61, 62, 0, 63,
|
|
0, 0, 0, 0, 0, 0, 4, 5, 6, 7,
|
|
8, 9, 10, 11, 12, 0, 0, 0, 0, 64,
|
|
265, 66, 14, 0, 15, 16, 17, 18, 0, 0,
|
|
0, 0, 0, 19, 20, 21, 22, 23, 24, 25,
|
|
0, 0, 113, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 30, 31, 32, 33, 34, 35, 36, 37, 38,
|
|
0, 39, 40, 41, 0, 0, 42, 0, 0, 43,
|
|
44, 0, 45, 46, 47, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
|
|
0, 0, 0, 0, 211, 0, 0, 119, 52, 0,
|
|
53, 54, 0, 606, 0, 0, 0, 56, 0, 57,
|
|
58, 59, 0, 60, 61, 62, 0, 63, 0, 0,
|
|
0, 0, 0, 0, 4, 5, 6, 7, 8, 9,
|
|
10, 11, 12, 0, 0, 0, 0, 64, 265, 66,
|
|
14, 0, 108, 109, 17, 18, 0, 0, 0, 0,
|
|
0, 110, 111, 112, 22, 23, 24, 25, 0, 0,
|
|
113, 0, 0, 0, 0, 0, 0, 0, 0, 30,
|
|
31, 32, 33, 34, 35, 36, 37, 38, 0, 39,
|
|
40, 41, 0, 0, 42, 0, 0, 43, 44, 0,
|
|
45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
|
|
0, 0, 211, 0, 0, 119, 52, 0, 53, 54,
|
|
0, 262, 0, 0, 0, 56, 0, 57, 58, 59,
|
|
0, 60, 61, 62, 0, 63, 0, 0, 0, 0,
|
|
0, 0, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, 0, 0, 0, 0, 64, 265, 66, 14, 0,
|
|
108, 109, 17, 18, 0, 0, 0, 0, 0, 110,
|
|
111, 112, 22, 23, 24, 25, 0, 0, 113, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 30, 31, 32,
|
|
33, 34, 35, 36, 37, 38, 0, 39, 40, 41,
|
|
0, 0, 42, 0, 0, 43, 44, 0, 45, 46,
|
|
47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
|
|
211, 0, 0, 119, 52, 0, 53, 54, 0, 606,
|
|
0, 0, 0, 56, 0, 57, 58, 59, 0, 60,
|
|
61, 62, 0, 63, 0, 0, 0, 0, 0, 0,
|
|
4, 5, 6, 7, 8, 9, 10, 11, 12, 0,
|
|
0, 0, 0, 64, 265, 66, 14, 0, 108, 109,
|
|
17, 18, 0, 0, 0, 0, 0, 110, 111, 112,
|
|
22, 23, 24, 25, 0, 0, 113, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 30, 31, 32, 33, 34,
|
|
35, 36, 37, 38, 0, 39, 40, 41, 0, 0,
|
|
42, 0, 0, 43, 44, 0, 45, 46, 47, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 48, 49, 0, 0, 0, 0, 0, 211, 0,
|
|
0, 119, 52, 0, 53, 54, 0, 901, 0, 0,
|
|
0, 56, 0, 57, 58, 59, 0, 60, 61, 62,
|
|
0, 63, 0, 0, 0, 0, 0, 0, 4, 5,
|
|
6, 7, 8, 9, 10, 11, 12, 0, 0, 0,
|
|
0, 64, 265, 66, 14, 0, 108, 109, 17, 18,
|
|
0, 0, 0, 0, 0, 110, 111, 112, 22, 23,
|
|
24, 25, 0, 0, 113, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 30, 31, 32, 33, 34, 35, 36,
|
|
37, 38, 0, 39, 40, 41, 0, 0, 42, 0,
|
|
0, 43, 44, 0, 45, 46, 47, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
|
|
49, 0, 0, 0, 0, 0, 211, 0, 0, 119,
|
|
52, 0, 53, 54, 0, 724, 0, 0, 0, 56,
|
|
0, 57, 58, 59, 0, 60, 61, 62, 0, 63,
|
|
0, 0, 0, 0, 0, 0, 4, 5, 6, 7,
|
|
8, 9, 10, 11, 12, 0, 0, 0, 0, 64,
|
|
265, 66, 14, 0, 15, 16, 17, 18, 0, 0,
|
|
0, 0, 0, 19, 20, 21, 22, 23, 24, 25,
|
|
0, 0, 26, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 30, 31, 32, 33, 34, 35, 36, 37, 38,
|
|
0, 39, 40, 41, 0, 0, 42, 0, 0, 43,
|
|
44, 0, 45, 46, 47, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
|
|
0, 0, 0, 0, 211, 0, 0, 119, 52, 0,
|
|
53, 54, 0, 0, 0, 0, 0, 56, 0, 57,
|
|
58, 59, 0, 60, 61, 62, 0, 63, 0, 0,
|
|
0, 0, 0, 0, 4, 5, 6, 7, 8, 9,
|
|
10, 11, 12, 0, 0, 0, 0, 64, 65, 66,
|
|
14, 0, 108, 109, 17, 18, 0, 0, 0, 0,
|
|
0, 110, 111, 112, 22, 23, 24, 25, 0, 0,
|
|
113, 0, 0, 0, 0, 0, 0, 0, 0, 30,
|
|
31, 32, 33, 34, 35, 36, 37, 38, 0, 39,
|
|
40, 41, 0, 0, 42, 0, 0, 43, 44, 0,
|
|
45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
|
|
0, 0, 211, 0, 0, 119, 52, 0, 53, 54,
|
|
0, 0, 0, 0, 0, 56, 0, 57, 58, 59,
|
|
0, 60, 61, 62, 0, 63, 0, 0, 0, 0,
|
|
0, 0, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, 0, 0, 0, 0, 64, 265, 66, 14, 0,
|
|
15, 16, 17, 18, 0, 0, 0, 0, 0, 19,
|
|
20, 21, 22, 23, 24, 25, 0, 0, 113, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 30, 31, 32,
|
|
33, 34, 35, 36, 37, 38, 0, 39, 40, 41,
|
|
0, 0, 42, 0, 0, 43, 44, 0, 45, 46,
|
|
47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
|
|
211, 0, 0, 119, 52, 0, 53, 54, 0, 0,
|
|
0, 0, 0, 56, 0, 57, 58, 59, 0, 60,
|
|
61, 62, 0, 63, 0, 0, 0, 0, 0, 0,
|
|
4, 5, 6, 7, 8, 9, 10, 11, 12, 0,
|
|
0, 0, 0, 64, 265, 66, 14, 0, 108, 109,
|
|
17, 18, 0, 0, 0, 0, 0, 110, 111, 112,
|
|
22, 23, 24, 25, 0, 0, 113, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 30, 31, 32, 114, 34,
|
|
35, 36, 115, 38, 0, 39, 40, 41, 0, 0,
|
|
42, 0, 0, 43, 44, 0, 116, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 117, 0, 0, 118, 0,
|
|
0, 119, 52, 0, 53, 54, 0, 0, 0, 0,
|
|
0, 56, 0, 57, 58, 59, 0, 60, 61, 62,
|
|
0, 63, 0, 0, 4, 5, 6, 7, 8, 9,
|
|
10, 11, 12, 0, 0, 0, 0, 0, 0, 0,
|
|
14, 120, 108, 109, 17, 18, 0, 0, 0, 0,
|
|
0, 110, 111, 112, 22, 23, 24, 25, 0, 0,
|
|
113, 0, 0, 0, 0, 0, 0, 0, 0, 30,
|
|
31, 32, 33, 34, 35, 36, 37, 38, 0, 39,
|
|
40, 41, 0, 0, 42, 0, 0, 43, 44, 0,
|
|
225, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 226, 0, 0, 51, 52, 0, 53, 54,
|
|
0, 55, 0, 0, 0, 56, 0, 57, 58, 59,
|
|
0, 60, 61, 62, 0, 63, 0, 0, 4, 5,
|
|
6, 7, 8, 9, 10, 11, 12, 0, 0, 0,
|
|
0, 0, 0, 0, 14, 120, 108, 109, 17, 18,
|
|
0, 0, 0, 0, 0, 110, 111, 112, 22, 23,
|
|
24, 25, 0, 0, 113, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 30, 31, 32, 33, 34, 35, 36,
|
|
37, 38, 0, 39, 40, 41, 0, 0, 42, 0,
|
|
0, 43, 44, 0, 116, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 313, 0, 0, 400,
|
|
52, 0, 53, 54, 0, 401, 0, 0, 0, 56,
|
|
0, 57, 58, 59, 0, 60, 61, 62, 0, 63,
|
|
0, 0, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, 0, 0, 0, 0, 0, 0, 0, 14, 120,
|
|
108, 109, 17, 18, 0, 0, 0, 0, 0, 110,
|
|
111, 112, 22, 23, 24, 25, 0, 0, 113, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 30, 31, 32,
|
|
114, 34, 35, 36, 115, 38, 0, 39, 40, 41,
|
|
0, 0, 42, 0, 0, 43, 44, 0, 116, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
118, 0, 0, 119, 52, 0, 53, 54, 0, 0,
|
|
0, 0, 0, 56, 0, 57, 58, 59, 0, 60,
|
|
61, 62, 0, 63, 0, 0, 4, 5, 6, 7,
|
|
8, 9, 10, 11, 12, 0, 0, 0, 0, 0,
|
|
0, 0, 14, 120, 108, 109, 17, 18, 0, 0,
|
|
0, 0, 0, 110, 111, 112, 22, 23, 24, 25,
|
|
0, 0, 113, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 30, 31, 32, 33, 34, 35, 36, 37, 38,
|
|
0, 39, 40, 41, 0, 0, 42, 0, 0, 43,
|
|
44, 0, 116, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 313, 0, 0, 400, 52, 0,
|
|
53, 54, 0, 0, 0, 0, 0, 56, 0, 57,
|
|
58, 59, 0, 60, 61, 62, 0, 63, 0, 0,
|
|
4, 5, 6, 7, 8, 9, 10, 11, 12, 0,
|
|
0, 0, 0, 0, 0, 0, 14, 120, 108, 109,
|
|
17, 18, 0, 0, 0, 0, 0, 110, 111, 112,
|
|
22, 23, 24, 25, 0, 0, 113, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 30, 31, 32, 33, 34,
|
|
35, 36, 37, 38, 0, 39, 40, 41, 0, 0,
|
|
42, 0, 0, 43, 44, 0, 116, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 968, 0,
|
|
0, 119, 52, 0, 53, 54, 0, 0, 0, 0,
|
|
0, 56, 0, 57, 58, 59, 0, 60, 61, 62,
|
|
0, 63, 0, 0, 4, 5, 6, 7, 8, 9,
|
|
10, 11, 12, 0, 0, 0, 0, 0, 0, 0,
|
|
14, 120, 108, 109, 17, 18, 0, 0, 0, 0,
|
|
0, 110, 111, 112, 22, 23, 24, 25, 0, 0,
|
|
113, 0, 0, 0, 0, 0, 0, 0, 0, 30,
|
|
31, 32, 33, 34, 35, 36, 37, 38, 0, 39,
|
|
40, 41, 0, 0, 42, 0, 0, 43, 44, 0,
|
|
225, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 991, 0, 0, 119, 52, 0, 53, 54,
|
|
0, 0, 681, 652, 0, 56, 682, 57, 58, 59,
|
|
0, 60, 61, 62, 0, 63, 0, 0, 0, 0,
|
|
0, 174, 175, 176, 177, 178, 179, 180, 181, 0,
|
|
0, 182, 183, 0, 0, 120, 0, 184, 185, 186,
|
|
187, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 188, 189, 190, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 191, 192, 193, 194, 195,
|
|
196, 197, 198, 199, 200, 0, 201, 202, 666, 661,
|
|
0, 0, 667, 0, 203, 276, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 174, 175, 176,
|
|
177, 178, 179, 180, 181, 0, 0, 182, 183, 0,
|
|
0, 0, 0, 184, 185, 186, 187, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 188, 189, 190,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 191, 192, 193, 194, 195, 196, 197, 198, 199,
|
|
200, 0, 201, 202, 698, 652, 0, 0, 699, 0,
|
|
203, 276, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 174, 175, 176, 177, 178, 179, 180,
|
|
181, 0, 0, 182, 183, 0, 0, 0, 0, 184,
|
|
185, 186, 187, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 188, 189, 190, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 191, 192, 193,
|
|
194, 195, 196, 197, 198, 199, 200, 0, 201, 202,
|
|
701, 661, 0, 0, 702, 0, 203, 276, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 174,
|
|
175, 176, 177, 178, 179, 180, 181, 0, 0, 182,
|
|
183, 0, 0, 0, 0, 184, 185, 186, 187, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 188,
|
|
189, 190, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 191, 192, 193, 194, 195, 196, 197,
|
|
198, 199, 200, 0, 201, 202, 708, 652, 0, 0,
|
|
709, 0, 203, 276, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 174, 175, 176, 177, 178,
|
|
179, 180, 181, 0, 0, 182, 183, 0, 0, 0,
|
|
0, 184, 185, 186, 187, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 188, 189, 190, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 191,
|
|
192, 193, 194, 195, 196, 197, 198, 199, 200, 0,
|
|
201, 202, 711, 661, 0, 0, 712, 0, 203, 276,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 174, 175, 176, 177, 178, 179, 180, 181, 0,
|
|
0, 182, 183, 0, 0, 0, 0, 184, 185, 186,
|
|
187, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 188, 189, 190, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 191, 192, 193, 194, 195,
|
|
196, 197, 198, 199, 200, 0, 201, 202, 747, 652,
|
|
0, 0, 748, 0, 203, 276, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 174, 175, 176,
|
|
177, 178, 179, 180, 181, 0, 0, 182, 183, 0,
|
|
0, 0, 0, 184, 185, 186, 187, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 188, 189, 190,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 191, 192, 193, 194, 195, 196, 197, 198, 199,
|
|
200, 0, 201, 202, 750, 661, 0, 0, 751, 0,
|
|
203, 276, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 174, 175, 176, 177, 178, 179, 180,
|
|
181, 0, 0, 182, 183, 0, 0, 0, 0, 184,
|
|
185, 186, 187, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 188, 189, 190, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 191, 192, 193,
|
|
194, 195, 196, 197, 198, 199, 200, 0, 201, 202,
|
|
906, 652, 0, 0, 907, 0, 203, 276, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 174,
|
|
175, 176, 177, 178, 179, 180, 181, 0, 0, 182,
|
|
183, 0, 0, 0, 0, 184, 185, 186, 187, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 188,
|
|
189, 190, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 191, 192, 193, 194, 195, 196, 197,
|
|
198, 199, 200, 0, 201, 202, 909, 661, 0, 0,
|
|
910, 0, 203, 276, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 174, 175, 176, 177, 178,
|
|
179, 180, 181, 0, 0, 182, 183, 0, 0, 0,
|
|
0, 184, 185, 186, 187, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 188, 189, 190, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 191,
|
|
192, 193, 194, 195, 196, 197, 198, 199, 200, 0,
|
|
201, 202, 1050, 652, 0, 0, 1051, 0, 203, 276,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 174, 175, 176, 177, 178, 179, 180, 181, 0,
|
|
0, 182, 183, 0, 0, 0, 0, 184, 185, 186,
|
|
187, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 188, 189, 190, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 191, 192, 193, 194, 195,
|
|
196, 197, 198, 199, 200, 0, 201, 202, 1062, 652,
|
|
0, 0, 1063, 0, 203, 276, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 174, 175, 176,
|
|
177, 178, 179, 180, 181, 0, 0, 182, 183, 0,
|
|
0, 0, 0, 184, 185, 186, 187, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 188, 189, 190,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 191, 192, 193, 194, 195, 196, 197, 198, 199,
|
|
200, 0, 201, 202, 1065, 661, 0, 0, 1066, 0,
|
|
203, 276, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 174, 175, 176, 177, 178, 179, 180,
|
|
181, 0, 0, 182, 183, 0, 0, 0, 0, 184,
|
|
185, 186, 187, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 188, 189, 190, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 191, 192, 193,
|
|
194, 195, 196, 197, 198, 199, 200, 0, 201, 202,
|
|
666, 661, 0, 0, 667, 0, 203, 276, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 174,
|
|
175, 176, 177, 178, 179, 180, 181, 0, 0, 182,
|
|
183, 0, 0, 0, 0, 184, 185, 186, 187, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 188,
|
|
189, 190, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 873, 0, 0, 0, 0,
|
|
0, 0, 0, 191, 192, 193, 194, 195, 196, 197,
|
|
198, 199, 200, 0, 201, 202, 0, 0, 0, 0,
|
|
0, 0, 203, 404, 405, 406, 407, 408, 409, 410,
|
|
411, 412, 413, 414, 415, 0, 0, 0, 0, 416,
|
|
417, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 419, 0, 0, 0, 0, 886, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 420, 0, 421, 422, 423, 424, 425,
|
|
426, 427, 428, 429, 430, 404, 405, 406, 407, 408,
|
|
409, 410, 411, 412, 413, 414, 415, 0, 0, 0,
|
|
0, 416, 417, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 419, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 420, 0, 421, 422, 423,
|
|
424, 425, 426, 427, 428, 429, 430, 404, 405, 406,
|
|
407, 408, 409, 410, 411, 412, 413, 414, 415, 0,
|
|
0, 0, 0, 416, 417, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 419, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 420, 0, 421,
|
|
422, 423, 424, 425, 426, 427, 428, 429, 430, 0,
|
|
0, 0, 0, 0, 0, 0, 0, -277, 404, 405,
|
|
406, 407, 408, 409, 410, 411, 412, 413, 414, 415,
|
|
0, 0, 0, 0, 416, 417, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 419, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 420, 0,
|
|
421, 422, 423, 424, 425, 426, 427, 428, 429, 430,
|
|
0, 0, 0, 0, 0, 0, 0, 0, -279, 404,
|
|
405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
|
|
415, 0, 0, 0, 0, 416, 417, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 419, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 420,
|
|
0, 421, 422, 423, 424, 425, 426, 427, 428, 429,
|
|
430, 0, 0, 0, 0, 0, 0, 0, 0, -280,
|
|
404, 405, 406, 407, 408, 409, 410, 411, 412, 413,
|
|
414, 415, 0, 0, 0, 0, 416, 417, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 419,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
420, 0, 421, 422, 423, 424, 425, 426, 427, 428,
|
|
429, 430, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
-282, 404, 405, 406, 407, 408, 409, 410, 411, 412,
|
|
413, 414, 415, 0, 0, 0, 0, 416, 417, 0,
|
|
0, 0, 501, 0, 0, 0, 0, 0, 0, 0,
|
|
419, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 420, 0, 421, 422, 423, 424, 425, 426, 427,
|
|
428, 429, 430, 404, 405, 406, 407, 408, 409, 410,
|
|
411, 412, 413, 414, 415, 0, 0, 0, 0, 416,
|
|
417, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 419, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 420, 0, 421, 422, 423, 424, 425,
|
|
426, 427, 428, 429, 430, 404, 405, 406, 407, 408,
|
|
409, 410, 411, 412, 413, -621, -621, 0, 0, 0,
|
|
0, 416, 417, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 419, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 421, 422, 423,
|
|
424, 425, 426, 427, 428, 429, 430
|
|
};
|
|
|
|
static const yytype_int16 yycheck[] =
|
|
{
|
|
1, 88, 13, 15, 16, 285, 26, 19, 55, 27,
|
|
1, 6, 3, 4, 5, 65, 27, 8, 9, 20,
|
|
490, 12, 68, 14, 15, 16, 86, 87, 19, 314,
|
|
9, 21, 4, 5, 222, 14, 379, 481, 14, 790,
|
|
12, 272, 8, 9, 6, 403, 3, 1, 14, 3,
|
|
597, 13, 53, 54, 81, 332, 762, 307, 594, 118,
|
|
51, 311, 57, 508, 55, 27, 51, 15, 16, 692,
|
|
547, 19, 73, 74, 65, 374, 20, 21, 431, 26,
|
|
703, 594, 435, 55, 504, 438, 669, 670, 508, 25,
|
|
81, 296, 68, 319, 539, 57, 395, 16, 25, 74,
|
|
59, 60, 61, 62, 25, 53, 459, 976, 433, 81,
|
|
111, 15, 16, 90, 104, 19, 15, 16, 15, 16,
|
|
19, 474, 19, 476, 26, 57, 117, 951, 119, 25,
|
|
0, 25, 485, 458, 74, 612, 25, 90, 443, 444,
|
|
103, 90, 29, 121, 90, 371, 25, 122, 58, 59,
|
|
475, 117, 105, 25, 53, 54, 53, 54, 218, 484,
|
|
104, 460, 79, 144, 142, 128, 28, 111, 112, 229,
|
|
147, 51, 525, 333, 138, 55, 336, 90, 338, 57,
|
|
340, 92, 342, 90, 1053, 129, 18, 26, 20, 121,
|
|
121, 138, 90, 90, 147, 400, 115, 550, 147, 118,
|
|
119, 147, 90, 388, 16, 390, 142, 55, 144, 126,
|
|
121, 92, 213, 214, 92, 142, 142, 144, 754, 210,
|
|
1044, 142, 973, 142, 549, 976, 113, 146, 121, 148,
|
|
290, 767, 223, 224, 147, 90, 138, 820, 403, 214,
|
|
147, 754, 144, 121, 223, 224, 142, 242, 142, 147,
|
|
956, 90, 298, 142, 767, 121, 316, 223, 224, 147,
|
|
306, 307, 547, 142, 276, 311, 105, 279, 144, 270,
|
|
142, 272, 125, 213, 214, 276, 252, 55, 443, 444,
|
|
242, 558, 513, 90, 270, 276, 272, 314, 279, 734,
|
|
90, 92, 147, 284, 285, 17, 18, 288, 55, 138,
|
|
25, 140, 1053, 115, 295, 296, 118, 119, 147, 142,
|
|
92, 296, 303, 733, 734, 16, 92, 92, 284, 285,
|
|
306, 798, 298, 314, 947, 551, 809, 612, 276, 876,
|
|
20, 279, 815, 691, 146, 27, 148, 142, 101, 121,
|
|
147, 295, 314, 37, 38, 121, 121, 147, 398, 303,
|
|
58, 59, 51, 403, 401, 37, 38, 870, 349, 350,
|
|
351, 352, 353, 354, 355, 356, 325, 880, 131, 132,
|
|
133, 350, 351, 352, 353, 279, 377, 57, 379, 276,
|
|
279, 680, 279, 374, 350, 351, 352, 353, 138, 355,
|
|
356, 811, 349, 443, 444, 349, 556, 101, 457, 92,
|
|
354, 92, 115, 847, 395, 118, 119, 398, 145, 400,
|
|
401, 92, 403, 665, 115, 400, 668, 118, 119, 92,
|
|
119, 433, 141, 115, 888, 889, 118, 119, 121, 401,
|
|
121, 774, 433, 115, 686, 148, 118, 119, 121, 92,
|
|
121, 139, 433, 723, 55, 146, 458, 148, 121, 802,
|
|
398, 804, 443, 444, 146, 403, 148, 458, 142, 60,
|
|
973, 142, 63, 475, 146, 466, 148, 458, 121, 460,
|
|
461, 92, 484, 435, 475, 101, 438, 947, 803, 101,
|
|
471, 57, 502, 484, 475, 63, 64, 65, 479, 142,
|
|
121, 435, 791, 484, 744, 461, 727, 459, 489, 92,
|
|
121, 806, 121, 521, 949, 319, 107, 812, 813, 142,
|
|
521, 512, 513, 798, 476, 459, 51, 92, 545, 818,
|
|
547, 522, 142, 485, 92, 805, 512, 513, 121, 949,
|
|
718, 522, 476, 1046, 142, 511, 433, 549, 116, 117,
|
|
531, 485, 92, 587, 1057, 493, 121, 591, 549, 892,
|
|
893, 16, 142, 121, 545, 92, 547, 371, 549, 521,
|
|
51, 458, 622, 525, 863, 142, 557, 142, 522, 51,
|
|
92, 121, 584, 545, 142, 547, 61, 531, 475, 64,
|
|
65, 525, 862, 121, 121, 612, 142, 484, 550, 288,
|
|
51, 603, 142, 584, 779, 780, 781, 296, 783, 121,
|
|
785, 1, 99, 3, 605, 504, 550, 504, 8, 9,
|
|
15, 508, 603, 918, 14, 15, 16, 13, 57, 19,
|
|
640, 612, 121, 609, 16, 856, 121, 443, 444, 63,
|
|
929, 116, 117, 121, 122, 800, 15, 536, 145, 536,
|
|
612, 806, 539, 92, 145, 139, 142, 812, 813, 142,
|
|
115, 51, 549, 118, 119, 142, 51, 15, 659, 15,
|
|
44, 477, 478, 142, 665, 65, 656, 668, 669, 670,
|
|
121, 141, 121, 659, 69, 665, 115, 141, 668, 118,
|
|
119, 146, 1025, 148, 123, 686, 15, 1040, 679, 680,
|
|
691, 692, 18, 142, 689, 696, 714, 141, 744, 141,
|
|
679, 400, 703, 714, 587, 15, 101, 102, 103, 148,
|
|
526, 139, 656, 679, 1039, 139, 141, 117, 139, 119,
|
|
142, 665, 713, 215, 668, 44, 727, 689, 142, 816,
|
|
222, 142, 718, 128, 713, 115, 57, 551, 118, 119,
|
|
684, 727, 686, 691, 90, 933, 790, 713, 142, 142,
|
|
800, 939, 714, 918, 44, 15, 806, 807, 93, 105,
|
|
14, 142, 812, 813, 15, 1045, 580, 259, 15, 26,
|
|
145, 798, 471, 774, 142, 960, 961, 962, 963, 142,
|
|
479, 115, 142, 597, 118, 119, 600, 142, 141, 15,
|
|
489, 803, 300, 15, 140, 139, 304, 15, 144, 26,
|
|
791, 147, 803, 73, 74, 15, 15, 798, 799, 800,
|
|
210, 139, 803, 126, 126, 806, 807, 142, 55, 820,
|
|
15, 812, 813, 223, 224, 90, 798, 818, 819, 830,
|
|
139, 55, 833, 90, 733, 142, 733, 734, 142, 142,
|
|
105, 832, 804, 142, 835, 799, 594, 142, 105, 597,
|
|
142, 121, 122, 844, 845, 856, 835, 349, 557, 90,
|
|
804, 852, 142, 90, 1049, 90, 15, 144, 918, 835,
|
|
856, 363, 863, 864, 105, 140, 276, 144, 105, 279,
|
|
105, 138, 147, 140, 284, 285, 141, 144, 288, 381,
|
|
147, 892, 893, 142, 522, 295, 296, 12, 5, 890,
|
|
26, 1042, 1044, 303, 895, 790, 803, 790, 817, 140,
|
|
1041, 138, 811, 140, 811, 140, 147, 144, 890, 6,
|
|
147, 90, 147, 895, 254, 790, 970, 918, 587, 973,
|
|
970, 973, 976, 993, 978, -1, 105, 928, 929, -1,
|
|
-1, 932, 90, 213, 214, 936, 947, -1, -1, 349,
|
|
350, 351, 352, 353, 354, 355, 356, 105, -1, -1,
|
|
932, -1, -1, 51, 90, 53, 54, 55, 56, -1,
|
|
-1, 140, -1, -1, 374, -1, 790, -1, 147, 105,
|
|
-1, 69, 1026, 63, 64, 65, 1006, -1, 480, 481,
|
|
806, 807, 140, -1, -1, 395, 812, 813, 398, 147,
|
|
400, 509, -1, 403, -1, 996, 754, 998, 516, 1053,
|
|
1001, 1055, 138, 1057, 140, 1059, -1, -1, 144, 767,
|
|
528, 147, 838, 839, 1025, 841, 842, 1039, 40, 41,
|
|
42, 43, 44, 433, -1, 1079, 116, 117, 1039, 531,
|
|
1041, 1042, 790, 443, 444, -1, 538, -1, 1039, 319,
|
|
90, -1, 949, -1, 142, -1, -1, 26, 458, -1,
|
|
460, 461, 876, -1, 878, 105, -1, -1, 882, -1,
|
|
-1, 471, -1, 581, 582, 475, -1, 90, 1040, 479,
|
|
-1, -1, 61, -1, 484, 64, 65, 970, -1, 489,
|
|
973, -1, 105, 976, 90, 978, 1040, 90, -1, -1,
|
|
140, 371, 918, 611, -1, 970, -1, 147, 973, 105,
|
|
-1, 976, 105, 978, 51, -1, 53, 54, 55, 56,
|
|
819, 90, 522, -1, -1, 941, -1, 140, 876, -1,
|
|
-1, 531, 69, 832, 147, -1, 105, 116, 117, -1,
|
|
954, 955, 1039, 1026, 140, 844, 845, 140, -1, 549,
|
|
-1, 147, -1, 852, 147, 897, 898, 557, 90, -1,
|
|
-1, 1026, 976, -1, 978, 864, -1, -1, -1, 138,
|
|
1053, 140, 1055, 105, 1057, 144, 1059, -1, 147, -1,
|
|
688, -1, 26, 90, 584, -1, 678, -1, 1053, -1,
|
|
1055, -1, 1057, -1, 1059, -1, 1079, -1, 105, 1013,
|
|
-1, -1, 1016, 603, -1, 142, 90, -1, 140, 90,
|
|
-1, -1, 8, 9, 1079, 147, -1, 90, 14, 15,
|
|
16, 105, -1, 19, 105, 973, 718, -1, 976, 928,
|
|
-1, 973, 105, 140, 1048, 743, -1, 936, -1, 1053,
|
|
147, 1055, -1, -1, 115, 1059, 90, 118, 119, -1,
|
|
46, 47, 48, 49, -1, 763, 140, 53, 54, 140,
|
|
-1, 105, -1, 147, -1, 1079, 147, 140, -1, 65,
|
|
66, 142, -1, -1, 147, 146, -1, 148, -1, 679,
|
|
680, 551, -1, 62, 776, 64, 65, 1029, 1030, 1031,
|
|
-1, 1033, 1034, -1, 138, -1, 140, 996, -1, 998,
|
|
144, -1, 1001, 147, 62, 1053, 64, 65, 63, 64,
|
|
65, -1, -1, 713, -1, 63, 64, 65, 63, 64,
|
|
65, 117, -1, -1, 51, -1, 53, 54, 55, 56,
|
|
822, 1073, 1074, 1075, 1076, -1, -1, 116, 117, -1,
|
|
-1, 1083, 69, -1, -1, -1, 51, 855, 53, 54,
|
|
55, 56, -1, -1, -1, 847, 83, -1, 116, 117,
|
|
-1, 116, 117, 871, 69, -1, -1, 94, 116, 117,
|
|
-1, 116, 117, 100, 101, 102, 103, -1, 83, -1,
|
|
63, 64, 65, 63, 64, 65, -1, -1, -1, 94,
|
|
-1, 791, -1, -1, 121, 100, 101, 102, 103, 799,
|
|
800, 128, -1, 803, 131, -1, 806, 807, 63, 64,
|
|
65, -1, 812, 813, -1, -1, -1, 144, 818, 819,
|
|
-1, -1, -1, 128, -1, -1, 131, 223, 224, -1,
|
|
-1, -1, 832, 116, 117, 835, 116, 117, -1, 144,
|
|
-1, 933, -1, -1, 844, 845, -1, 939, -1, -1,
|
|
-1, -1, 852, 51, -1, 53, 54, 55, 56, -1,
|
|
-1, 116, 117, 863, 864, -1, 262, 263, 264, 265,
|
|
-1, 69, 51, -1, 53, 54, 55, 56, -1, -1,
|
|
276, -1, 51, 279, 53, 54, 55, 56, 284, 285,
|
|
69, -1, -1, -1, -1, -1, 94, -1, -1, -1,
|
|
69, -1, 100, 101, 102, 103, -1, -1, 51, -1,
|
|
53, 54, 55, 56, -1, 94, -1, -1, 918, -1,
|
|
-1, 100, 101, 102, 103, 94, 69, -1, 928, 929,
|
|
128, 100, -1, 131, -1, 51, 936, 53, 54, 55,
|
|
56, 115, -1, -1, 118, 119, 144, -1, -1, 128,
|
|
-1, 94, 131, 69, 350, 351, 352, 353, 115, 355,
|
|
356, 118, 119, 142, 115, -1, -1, 118, 119, -1,
|
|
-1, 145, 146, -1, 148, -1, -1, -1, 94, 375,
|
|
-1, -1, -1, -1, 100, -1, -1, -1, -1, 146,
|
|
386, 148, -1, -1, -1, 146, 996, 148, 998, -1,
|
|
-1, 1001, 398, -1, -1, -1, -1, 403, 404, 405,
|
|
406, 407, 408, 409, 410, 411, 412, 413, 414, 415,
|
|
416, 417, 101, 419, 420, 421, 422, 423, 424, 425,
|
|
426, 427, 428, 429, 430, -1, -1, 433, -1, 1039,
|
|
51, -1, 53, 54, 55, 56, -1, 443, 444, -1,
|
|
129, 130, 131, 132, 133, -1, -1, -1, 69, -1,
|
|
-1, -1, 458, -1, -1, 461, 51, -1, 53, 54,
|
|
55, 56, -1, -1, 85, -1, -1, 473, -1, 475,
|
|
-1, 477, 478, 94, 69, -1, -1, -1, 484, 100,
|
|
101, 102, 103, -1, -1, -1, -1, 493, -1, -1,
|
|
496, 497, -1, -1, -1, 501, -1, -1, 504, -1,
|
|
506, -1, 508, 509, -1, -1, -1, 128, -1, -1,
|
|
131, -1, -1, -1, -1, 1, -1, 3, 4, 5,
|
|
526, -1, -1, -1, -1, -1, 12, -1, -1, -1,
|
|
536, -1, 51, 539, 53, 54, 55, 56, -1, -1,
|
|
-1, -1, -1, 549, -1, -1, 88, 89, -1, -1,
|
|
69, -1, -1, 51, -1, 53, 54, 55, 56, 101,
|
|
566, 567, -1, -1, -1, 51, 85, -1, -1, 55,
|
|
-1, 69, 88, 89, -1, 94, -1, -1, 584, -1,
|
|
-1, 100, 101, 102, 103, 101, 128, 129, 130, 131,
|
|
132, 133, -1, -1, -1, 81, 94, 603, -1, -1,
|
|
606, -1, -1, 101, 102, 103, -1, -1, -1, 128,
|
|
-1, -1, 131, 129, 130, 131, 132, 133, -1, -1,
|
|
-1, 0, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
128, -1, -1, 119, 13, 14, 15, 16, 17, 18,
|
|
-1, 20, -1, -1, -1, -1, -1, 26, 27, 28,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 37, 38,
|
|
-1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
|
|
-1, -1, -1, 679, -1, 1, -1, 3, 4, 5,
|
|
-1, -1, -1, -1, -1, 691, 12, -1, 694, 695,
|
|
-1, -1, -1, 72, 73, 74, 75, 76, 77, 78,
|
|
79, 80, 81, 82, 83, -1, -1, 713, -1, 88,
|
|
89, 90, -1, -1, 93, -1, -1, -1, 724, -1,
|
|
99, -1, 101, -1, 210, 51, 105, 733, 734, 55,
|
|
-1, -1, -1, -1, -1, -1, 115, -1, -1, 118,
|
|
119, -1, -1, 122, -1, 124, 125, 126, 127, 128,
|
|
129, 130, 131, 132, 133, 81, -1, -1, -1, 138,
|
|
139, 140, 141, 142, -1, 144, 145, 146, 147, 148,
|
|
51, -1, 53, 54, 55, 56, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 69, 795,
|
|
-1, -1, -1, 119, 800, 801, -1, 803, -1, -1,
|
|
806, 807, 288, -1, 85, 811, 812, 813, -1, 295,
|
|
296, -1, -1, 94, -1, -1, -1, 303, -1, 100,
|
|
101, 102, 103, -1, -1, -1, -1, -1, 314, 835,
|
|
-1, -1, 838, 839, -1, 841, 842, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 851, -1, 128, -1, 855,
|
|
131, 51, -1, 53, 54, 55, 56, -1, -1, -1,
|
|
-1, -1, -1, 349, -1, -1, 872, 873, 354, 69,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 885,
|
|
886, -1, -1, -1, 210, -1, -1, -1, 374, -1,
|
|
-1, -1, -1, -1, 94, 901, -1, -1, -1, -1,
|
|
100, 101, 102, 103, -1, 911, 912, 88, 89, 395,
|
|
-1, -1, 918, -1, 400, 401, -1, 403, -1, -1,
|
|
101, -1, -1, -1, -1, -1, -1, -1, 128, -1,
|
|
-1, 131, -1, -1, -1, 941, -1, -1, -1, -1,
|
|
-1, -1, -1, 949, -1, 126, 127, 128, 129, 130,
|
|
131, 132, 133, -1, -1, -1, -1, 443, 444, -1,
|
|
-1, -1, 288, -1, -1, -1, -1, -1, -1, 295,
|
|
296, -1, -1, -1, 460, -1, -1, 303, -1, -1,
|
|
-1, -1, -1, -1, -1, 471, -1, -1, 314, -1,
|
|
-1, -1, -1, 479, -1, -1, -1, 72, 73, 74,
|
|
75, 76, 77, 489, -1, 80, 81, -1, -1, -1,
|
|
-1, -1, -1, 88, 89, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 349, -1, -1, 101, -1, 354, -1,
|
|
-1, -1, -1, 1039, -1, -1, 522, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 531, -1, -1, 374, 124,
|
|
125, 126, 127, 128, 129, 130, 131, 132, 133, 545,
|
|
-1, 547, -1, -1, -1, -1, -1, -1, -1, 395,
|
|
0, 557, -1, -1, 400, 401, -1, 403, -1, -1,
|
|
-1, -1, -1, 13, 14, 15, 16, 17, 18, -1,
|
|
20, -1, -1, -1, -1, -1, 26, 27, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
|
|
40, 41, 42, 43, 44, -1, -1, 443, 444, -1,
|
|
-1, -1, -1, -1, -1, -1, 612, -1, -1, -1,
|
|
-1, -1, -1, -1, 460, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 471, -1, -1, -1, -1,
|
|
-1, -1, -1, 479, -1, -1, -1, -1, -1, -1,
|
|
90, -1, -1, 489, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 105, 1, -1, 3, 4,
|
|
5, -1, -1, -1, -1, 115, -1, 12, 118, 119,
|
|
-1, -1, -1, -1, 680, -1, 522, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 531, -1, -1, 138, 139,
|
|
-1, -1, -1, -1, 144, 145, 146, 147, 148, 545,
|
|
-1, 547, -1, -1, -1, -1, 51, -1, -1, -1,
|
|
55, 557, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 72, 73, 74, 75, 76, 77, 78,
|
|
79, 80, 81, 82, 83, -1, 81, -1, -1, 88,
|
|
89, -1, -1, -1, 93, -1, -1, -1, -1, -1,
|
|
-1, -1, 101, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 612, -1, -1, -1,
|
|
-1, -1, -1, 122, 119, 124, 125, 126, 127, 128,
|
|
129, 130, 131, 132, 133, 791, -1, -1, -1, -1,
|
|
-1, -1, 798, 799, 800, -1, -1, -1, -1, -1,
|
|
806, -1, -1, -1, -1, -1, 812, 813, -1, -1,
|
|
-1, -1, 818, 819, -1, -1, 1, -1, 3, 4,
|
|
5, 6, -1, -1, -1, -1, 832, 12, -1, -1,
|
|
-1, -1, -1, -1, 680, -1, -1, -1, 844, 845,
|
|
-1, -1, -1, -1, -1, -1, 852, 72, 73, 74,
|
|
75, 76, 77, 78, -1, 80, 81, 863, 864, -1,
|
|
-1, -1, -1, 88, 89, 210, 51, -1, -1, -1,
|
|
55, -1, -1, -1, -1, -1, 101, -1, -1, -1,
|
|
-1, -1, -1, -1, 890, -1, -1, -1, -1, 895,
|
|
-1, -1, -1, -1, -1, -1, 81, -1, -1, 124,
|
|
125, 126, 127, 128, 129, 130, 131, 132, 133, -1,
|
|
-1, -1, 918, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 928, 929, -1, -1, 932, -1, -1, -1,
|
|
936, -1, -1, -1, 119, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 288, -1, 791, -1, -1, -1, -1,
|
|
295, 296, 798, 799, 800, -1, -1, -1, 303, -1,
|
|
806, -1, -1, -1, -1, -1, 812, 813, -1, 314,
|
|
-1, -1, 818, 819, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 832, -1, -1, -1,
|
|
996, -1, 998, -1, -1, 1001, -1, -1, 844, 845,
|
|
-1, -1, -1, -1, 349, -1, 852, -1, -1, 354,
|
|
-1, -1, -1, -1, -1, -1, -1, 863, 864, -1,
|
|
-1, -1, -1, -1, -1, 210, -1, -1, -1, 374,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 890, -1, -1, -1, -1, 895,
|
|
395, -1, -1, -1, -1, 400, 401, -1, 403, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 918, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 928, 929, -1, -1, 932, -1, -1, 1,
|
|
936, 3, -1, -1, -1, -1, -1, -1, 443, 444,
|
|
12, -1, -1, 288, -1, -1, -1, -1, -1, -1,
|
|
295, 296, -1, -1, -1, 460, -1, -1, 303, -1,
|
|
-1, -1, -1, -1, -1, -1, 471, -1, -1, 314,
|
|
-1, -1, -1, -1, 479, -1, -1, -1, -1, 51,
|
|
-1, -1, -1, -1, 489, -1, -1, -1, -1, -1,
|
|
996, -1, 998, -1, -1, 1001, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 349, -1, -1, -1, -1, 354,
|
|
-1, -1, -1, -1, -1, -1, -1, 522, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 531, -1, -1, 374,
|
|
-1, -1, -1, -1, -1, -1, 44, -1, -1, -1,
|
|
545, -1, 547, -1, -1, -1, -1, 119, -1, -1,
|
|
395, -1, 557, -1, -1, 400, 401, -1, -1, -1,
|
|
-1, -1, -1, -1, 72, 73, 74, 75, 76, 77,
|
|
78, 79, 80, 81, 82, 83, -1, -1, -1, -1,
|
|
88, 89, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 101, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 612, -1, -1,
|
|
1, -1, 3, -1, 122, 460, 124, 125, 126, 127,
|
|
128, 129, 130, 131, 132, 133, 471, -1, -1, -1,
|
|
-1, -1, -1, -1, 479, -1, -1, -1, 210, -1,
|
|
-1, -1, -1, -1, 489, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
51, -1, -1, -1, -1, -1, -1, -1, 51, 52,
|
|
-1, -1, 55, -1, -1, 680, -1, 522, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 531, 70, 71, 72,
|
|
73, 74, 75, 76, 77, -1, -1, 80, 81, -1,
|
|
545, -1, 547, 86, 87, 88, 89, -1, -1, -1,
|
|
-1, -1, 557, -1, -1, -1, 288, 100, 101, 102,
|
|
-1, -1, -1, 295, 296, -1, -1, -1, 119, -1,
|
|
-1, 303, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 124, 125, 126, 127, 128, 129, 130, 131, 132,
|
|
133, -1, 135, 136, -1, -1, -1, -1, -1, -1,
|
|
143, 144, -1, -1, -1, -1, -1, 612, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 349, -1, -1,
|
|
-1, -1, 354, -1, -1, -1, 791, -1, -1, -1,
|
|
-1, -1, -1, 798, 799, 800, -1, -1, -1, -1,
|
|
-1, 806, 374, -1, -1, -1, -1, 812, 813, -1,
|
|
-1, -1, -1, 818, 819, -1, -1, -1, -1, 210,
|
|
-1, -1, -1, 395, -1, -1, -1, 832, 400, -1,
|
|
-1, 403, -1, -1, -1, 680, -1, -1, -1, 844,
|
|
845, -1, -1, -1, -1, -1, -1, 852, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 863, 864,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 443, 444, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 890, -1, -1, 460, -1,
|
|
895, -1, -1, -1, -1, -1, -1, 288, -1, 471,
|
|
-1, -1, -1, -1, 295, 296, -1, 479, -1, -1,
|
|
-1, -1, 303, 918, -1, -1, -1, 489, -1, -1,
|
|
-1, -1, -1, 928, 929, -1, -1, 932, -1, -1,
|
|
-1, 936, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 791, -1, -1, -1,
|
|
522, -1, -1, 798, 799, -1, -1, -1, 349, 531,
|
|
-1, -1, -1, 354, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 818, 819, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 374, -1, 557, -1, 832, -1, -1,
|
|
-1, 996, -1, 998, -1, -1, 1001, -1, -1, 844,
|
|
845, -1, -1, -1, 395, -1, -1, 852, -1, 400,
|
|
-1, -1, 403, -1, -1, -1, -1, -1, 863, 864,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 44,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 890, -1, -1, -1, -1,
|
|
895, -1, 443, 444, -1, -1, -1, 72, 73, 74,
|
|
75, 76, 77, 78, 79, 80, 81, 82, 83, 460,
|
|
-1, -1, -1, 88, 89, -1, -1, -1, -1, -1,
|
|
471, -1, -1, 928, 929, -1, 101, 932, 479, -1,
|
|
-1, 936, -1, -1, -1, -1, -1, -1, 489, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 122, 680, 124,
|
|
125, 126, 127, 128, 129, 130, 131, 132, 133, -1,
|
|
72, 73, 74, 75, 76, 77, -1, 142, 80, 81,
|
|
-1, 522, -1, -1, -1, -1, 88, 89, -1, -1,
|
|
531, -1, -1, -1, -1, -1, -1, -1, -1, 101,
|
|
-1, 996, -1, 998, -1, -1, 1001, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 557, -1, -1, -1,
|
|
-1, -1, 124, 125, 126, 127, 128, 129, 130, 131,
|
|
132, 133, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 791,
|
|
-1, -1, -1, -1, -1, -1, -1, 799, 800, -1,
|
|
-1, -1, -1, -1, 806, -1, -1, -1, -1, -1,
|
|
812, 813, -1, -1, 0, -1, 818, 819, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 13, 14, 15,
|
|
832, 17, 18, -1, 20, -1, -1, -1, -1, -1,
|
|
26, -1, 844, 845, -1, -1, -1, -1, -1, -1,
|
|
852, 37, 38, -1, 40, 41, 42, 43, 44, 680,
|
|
-1, 863, 864, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 72, 73, 74, 75,
|
|
76, 77, 78, 79, 80, 81, 82, 83, -1, -1,
|
|
-1, -1, 88, 89, 90, -1, 92, 93, -1, -1,
|
|
-1, -1, -1, -1, -1, 101, 918, -1, -1, 105,
|
|
-1, -1, -1, -1, -1, -1, 928, 929, -1, 115,
|
|
932, -1, 118, 119, 936, 121, 122, -1, 124, 125,
|
|
126, 127, 128, 129, 130, 131, 132, 133, -1, -1,
|
|
-1, -1, 138, 139, 140, -1, 142, -1, -1, 145,
|
|
146, 147, 148, -1, -1, -1, -1, -1, -1, -1,
|
|
791, -1, -1, -1, -1, -1, -1, -1, 799, 800,
|
|
-1, -1, -1, 51, 52, 806, -1, 55, -1, -1,
|
|
-1, 812, 813, -1, 996, -1, 998, 818, 819, 1001,
|
|
-1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
|
|
-1, 832, 80, 81, -1, -1, -1, -1, 86, 87,
|
|
88, 89, -1, 844, 845, -1, -1, -1, -1, -1,
|
|
-1, 852, 100, 101, 102, -1, -1, -1, -1, -1,
|
|
-1, -1, 863, 864, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 124, 125, 126, 127,
|
|
128, 129, 130, 131, 132, 133, -1, 135, 136, -1,
|
|
-1, -1, -1, -1, -1, 143, 144, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 918, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 928, 929, -1,
|
|
-1, -1, -1, -1, -1, 936, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 0, 1, -1,
|
|
3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
|
|
-1, -1, -1, -1, -1, -1, 19, -1, 21, 22,
|
|
23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
|
|
33, 34, 35, 36, -1, 996, 39, 998, -1, -1,
|
|
1001, -1, 45, 46, 47, 48, 49, 50, 51, 52,
|
|
53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
|
|
63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 84, 85, -1, -1, -1, -1, -1, 91, -1,
|
|
-1, 94, 95, -1, 97, 98, -1, 100, -1, -1,
|
|
-1, 104, -1, 106, 107, 108, -1, 110, 111, 112,
|
|
0, 114, 115, -1, -1, 118, 119, -1, -1, -1,
|
|
-1, -1, -1, 13, 14, 15, 16, 17, 18, -1,
|
|
20, 134, 135, 136, -1, -1, -1, 27, 28, 29,
|
|
-1, -1, -1, 146, -1, 148, -1, 37, 38, -1,
|
|
40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 57, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 72, 73, 74, 75, 76, 77, 78, 79,
|
|
80, 81, 82, 83, -1, -1, -1, -1, 88, 89,
|
|
90, -1, -1, 93, -1, -1, -1, -1, -1, 99,
|
|
-1, 101, -1, -1, -1, 105, -1, -1, -1, -1,
|
|
-1, -1, -1, 113, -1, 115, -1, -1, 118, 119,
|
|
-1, -1, 122, 123, 124, 125, 126, 127, 128, 129,
|
|
130, 131, 132, 133, -1, -1, 0, -1, -1, 139,
|
|
140, 141, 142, -1, -1, 145, 146, 147, 148, 13,
|
|
14, 15, 16, 17, 18, -1, 20, -1, -1, -1,
|
|
-1, -1, -1, 27, 28, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
|
|
44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 57, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 72, 73,
|
|
74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
|
|
-1, -1, -1, -1, 88, 89, 90, -1, 92, 93,
|
|
-1, -1, -1, -1, -1, 99, -1, 101, -1, -1,
|
|
-1, 105, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 115, -1, -1, 118, 119, -1, 121, 122, -1,
|
|
124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
|
|
-1, -1, 0, -1, -1, 139, 140, 141, 142, -1,
|
|
-1, 145, 146, 147, 148, 13, 14, 15, 16, 17,
|
|
18, -1, 20, -1, -1, -1, -1, -1, 26, 27,
|
|
28, -1, -1, -1, -1, -1, -1, -1, -1, 37,
|
|
38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 72, 73, 74, 75, 76, 77,
|
|
78, 79, 80, 81, 82, 83, -1, -1, -1, -1,
|
|
88, 89, 90, -1, -1, 93, -1, -1, -1, -1,
|
|
-1, 99, -1, 101, -1, -1, -1, 105, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 115, -1, -1,
|
|
118, 119, -1, -1, 122, -1, 124, 125, 126, 127,
|
|
128, 129, 130, 131, 132, 133, -1, -1, 0, -1,
|
|
138, 139, 140, 141, 142, -1, 144, 145, 146, 147,
|
|
148, 13, 14, 15, 16, 17, 18, -1, 20, -1,
|
|
-1, -1, -1, -1, -1, 27, 28, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
|
|
42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
|
|
82, 83, -1, -1, -1, -1, 88, 89, 90, -1,
|
|
-1, 93, -1, -1, -1, -1, -1, 99, -1, 101,
|
|
-1, -1, -1, 105, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 115, -1, -1, 118, 119, -1, -1,
|
|
122, -1, 124, 125, 126, 127, 128, 129, 130, 131,
|
|
132, 133, -1, -1, 0, -1, -1, 139, 140, 141,
|
|
142, -1, 144, 145, 146, 147, 148, 13, 14, 15,
|
|
-1, 17, 18, -1, 20, -1, -1, -1, -1, -1,
|
|
26, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 72, 73, 74, 75,
|
|
76, 77, 78, 79, 80, 81, 82, 83, -1, -1,
|
|
-1, -1, 88, 89, 90, -1, 92, 93, -1, -1,
|
|
-1, -1, -1, -1, -1, 101, -1, -1, -1, 105,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 115,
|
|
-1, -1, 118, 119, -1, 121, 122, -1, 124, 125,
|
|
126, 127, 128, 129, 130, 131, 132, 133, -1, -1,
|
|
0, -1, 138, 139, 140, -1, 142, -1, -1, 145,
|
|
146, 147, 148, 13, 14, 15, -1, 17, 18, -1,
|
|
20, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
|
|
40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 72, 73, 74, 75, 76, 77, 78, 79,
|
|
80, 81, 82, 83, -1, -1, -1, -1, 88, 89,
|
|
90, -1, 92, 93, -1, -1, -1, -1, -1, -1,
|
|
-1, 101, -1, -1, -1, 105, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 115, -1, -1, 118, 119,
|
|
-1, 121, 122, -1, 124, 125, 126, 127, 128, 129,
|
|
130, 131, 132, 133, -1, -1, 0, -1, -1, 139,
|
|
140, -1, 142, -1, -1, 145, 146, 147, 148, 13,
|
|
14, 15, -1, 17, 18, -1, 20, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
|
|
44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 72, 73,
|
|
74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
|
|
-1, -1, -1, -1, 88, 89, 90, -1, 92, 93,
|
|
-1, -1, -1, -1, -1, -1, -1, 101, -1, -1,
|
|
-1, 105, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 115, -1, -1, 118, 119, -1, 121, 122, -1,
|
|
124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
|
|
-1, -1, -1, -1, -1, 139, 140, -1, 142, -1,
|
|
-1, 145, 146, 147, 148, 1, -1, 3, 4, 5,
|
|
6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
|
-1, -1, 18, 19, -1, 21, 22, 23, 24, -1,
|
|
-1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
|
|
36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
|
|
-1, 47, 48, 49, 50, 51, 52, 53, 54, 55,
|
|
56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
|
|
66, 67, -1, 69, 70, 71, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 84, 85,
|
|
-1, -1, -1, -1, -1, 91, -1, -1, 94, 95,
|
|
-1, 97, 98, -1, 100, -1, -1, -1, 104, -1,
|
|
106, 107, 108, -1, 110, 111, 112, -1, 114, 115,
|
|
-1, -1, 118, 119, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 134, 135,
|
|
136, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
146, 1, 148, 3, 4, 5, 6, 7, 8, 9,
|
|
10, 11, 12, -1, -1, 15, -1, 17, 18, 19,
|
|
-1, 21, 22, 23, 24, -1, -1, -1, -1, -1,
|
|
30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
|
|
-1, -1, -1, -1, -1, 45, -1, 47, 48, 49,
|
|
50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
|
|
60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
|
|
70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 84, 85, -1, -1, -1, -1,
|
|
-1, 91, -1, -1, 94, 95, -1, 97, 98, -1,
|
|
100, -1, -1, -1, 104, -1, 106, 107, 108, -1,
|
|
110, 111, 112, -1, 114, 115, -1, -1, 118, 119,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 134, 135, 136, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 146, 1, 148, 3,
|
|
4, 5, 6, 7, 8, 9, 10, 11, 12, -1,
|
|
-1, 15, -1, -1, 18, 19, 20, 21, 22, 23,
|
|
24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
|
|
34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
|
|
-1, 45, -1, 47, 48, 49, 50, 51, 52, 53,
|
|
54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
|
|
-1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
84, 85, -1, -1, -1, -1, -1, 91, -1, -1,
|
|
94, 95, -1, 97, 98, -1, 100, -1, -1, -1,
|
|
104, -1, 106, 107, 108, -1, 110, 111, 112, -1,
|
|
114, 115, -1, -1, 118, 119, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
134, 135, 136, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 146, 1, 148, 3, 4, 5, 6, 7,
|
|
8, 9, 10, 11, 12, -1, -1, 15, -1, -1,
|
|
18, 19, -1, 21, 22, 23, 24, -1, -1, -1,
|
|
-1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
|
|
-1, 39, -1, -1, -1, -1, -1, 45, -1, 47,
|
|
48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
|
|
58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
|
|
-1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 84, 85, -1, -1,
|
|
-1, -1, -1, 91, -1, -1, 94, 95, -1, 97,
|
|
98, -1, 100, -1, -1, -1, 104, -1, 106, 107,
|
|
108, -1, 110, 111, 112, -1, 114, 115, -1, -1,
|
|
118, 119, 1, -1, 3, 4, 5, 6, 7, 8,
|
|
9, 10, 11, 12, -1, -1, 134, 135, 136, -1,
|
|
19, -1, 21, 22, 23, 24, -1, -1, 146, -1,
|
|
148, 30, 31, 32, 33, 34, 35, 36, -1, -1,
|
|
39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
|
|
49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
|
|
59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
|
|
69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 84, 85, -1, -1, -1,
|
|
-1, -1, 91, -1, -1, 94, 95, -1, 97, 98,
|
|
-1, 100, -1, -1, -1, 104, -1, 106, 107, 108,
|
|
-1, 110, 111, 112, -1, 114, 115, -1, -1, 118,
|
|
119, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 134, 135, 136, -1, -1,
|
|
139, -1, -1, -1, -1, -1, -1, 146, 1, 148,
|
|
3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
|
|
-1, 14, 15, -1, -1, -1, 19, -1, 21, 22,
|
|
23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
|
|
33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
|
|
-1, -1, 45, -1, 47, 48, 49, 50, 51, 52,
|
|
53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
|
|
63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 84, 85, -1, -1, -1, -1, -1, 91, -1,
|
|
-1, 94, 95, -1, 97, 98, -1, 100, -1, -1,
|
|
-1, 104, -1, 106, 107, 108, -1, 110, 111, 112,
|
|
-1, 114, 115, -1, -1, 118, 119, 1, -1, 3,
|
|
4, 5, 6, 7, 8, 9, 10, 11, 12, -1,
|
|
-1, 134, 135, 136, -1, 19, -1, 21, 22, 23,
|
|
24, -1, -1, 146, -1, 148, 30, 31, 32, 33,
|
|
34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
|
|
-1, 45, -1, 47, 48, 49, 50, 51, 52, 53,
|
|
54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
|
|
-1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
84, 85, -1, -1, -1, -1, -1, 91, -1, -1,
|
|
94, 95, -1, 97, 98, -1, 100, -1, -1, -1,
|
|
104, -1, 106, 107, 108, -1, 110, 111, 112, -1,
|
|
114, 115, -1, -1, 118, 119, 1, -1, 3, 4,
|
|
5, 6, 7, 8, 9, 10, 11, 12, -1, -1,
|
|
134, 135, 136, -1, 19, -1, 21, 22, 23, 24,
|
|
-1, 145, 146, -1, 148, 30, 31, 32, 33, 34,
|
|
35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
|
|
45, -1, 47, 48, 49, 50, 51, 52, 53, 54,
|
|
55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
|
|
-1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 84,
|
|
85, -1, -1, -1, -1, -1, 91, -1, -1, 94,
|
|
95, -1, 97, 98, -1, 100, -1, -1, -1, 104,
|
|
-1, 106, 107, 108, -1, 110, 111, 112, -1, 114,
|
|
115, -1, -1, 118, 119, 1, -1, 3, 4, 5,
|
|
6, 7, 8, 9, 10, 11, 12, -1, -1, 134,
|
|
135, 136, -1, 19, -1, 21, 22, 23, 24, -1,
|
|
145, 146, -1, 148, 30, 31, 32, 33, 34, 35,
|
|
36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
|
|
-1, 47, 48, 49, 50, 51, 52, 53, 54, 55,
|
|
56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
|
|
66, 67, -1, 69, 70, 71, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 84, 85,
|
|
-1, -1, -1, -1, -1, 91, -1, -1, 94, 95,
|
|
-1, 97, 98, -1, 100, -1, -1, -1, 104, -1,
|
|
106, 107, 108, -1, 110, 111, 112, -1, 114, 115,
|
|
-1, -1, 118, 119, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 134, 135,
|
|
136, -1, -1, 139, -1, -1, -1, -1, -1, -1,
|
|
146, 1, 148, 3, 4, 5, 6, 7, 8, 9,
|
|
10, 11, 12, -1, -1, 15, -1, -1, -1, 19,
|
|
-1, 21, 22, 23, 24, -1, -1, -1, -1, -1,
|
|
30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
|
|
-1, -1, -1, -1, -1, 45, -1, 47, 48, 49,
|
|
50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
|
|
60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
|
|
70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 84, 85, -1, -1, -1, -1,
|
|
-1, 91, -1, -1, 94, 95, -1, 97, 98, -1,
|
|
100, -1, -1, -1, 104, -1, 106, 107, 108, -1,
|
|
110, 111, 112, -1, 114, 115, -1, -1, 118, 119,
|
|
-1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
|
|
11, 12, -1, -1, 134, 135, 136, -1, 19, -1,
|
|
21, 22, 23, 24, -1, -1, 146, -1, 148, 30,
|
|
31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
|
|
-1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
|
|
51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
|
|
-1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
|
|
71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 84, 85, -1, -1, -1, -1, -1,
|
|
91, -1, -1, 94, 95, -1, 97, 98, -1, 100,
|
|
-1, -1, -1, 104, -1, 106, 107, 108, -1, 110,
|
|
111, 112, -1, 114, 115, -1, -1, 118, 119, -1,
|
|
-1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, -1, -1, 134, 135, 136, -1, 19, -1, 21,
|
|
22, 23, 24, -1, -1, 146, -1, 148, 30, 31,
|
|
32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
|
|
-1, -1, -1, 45, -1, 47, 48, 49, 50, 51,
|
|
52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
|
|
-1, 63, -1, -1, 66, 67, -1, 69, 70, 71,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 84, 85, -1, -1, -1, -1, -1, 91,
|
|
-1, -1, 94, 95, -1, 97, 98, -1, 100, -1,
|
|
-1, -1, 104, -1, 106, 107, 108, -1, 110, 111,
|
|
112, -1, 114, 115, -1, -1, 118, 119, -1, -1,
|
|
3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
|
|
-1, -1, 134, 135, 136, -1, 19, -1, 21, 22,
|
|
23, 24, -1, -1, 146, -1, 148, 30, 31, 32,
|
|
33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
|
|
53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
|
|
63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 84, 85, -1, -1, -1, -1, -1, 91, -1,
|
|
-1, 94, 95, -1, 97, 98, -1, -1, -1, -1,
|
|
-1, 104, -1, 106, 107, 108, -1, 110, 111, 112,
|
|
-1, 114, 115, -1, -1, 118, 119, -1, -1, 3,
|
|
4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
|
|
-1, 134, 135, 136, -1, 19, -1, 21, 22, 23,
|
|
24, -1, -1, 146, -1, 148, 30, 31, 32, 33,
|
|
34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
|
|
54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
|
|
-1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
84, 85, -1, -1, -1, -1, -1, 91, -1, -1,
|
|
94, 95, -1, 97, 98, -1, -1, -1, -1, -1,
|
|
104, -1, 106, 107, 108, -1, 110, 111, 112, -1,
|
|
114, 115, -1, -1, 118, 119, -1, -1, 3, 4,
|
|
5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
|
|
134, 135, 136, -1, 19, -1, 21, 22, 23, 24,
|
|
-1, -1, 146, -1, 148, 30, 31, 32, 33, 34,
|
|
35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
|
|
55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
|
|
-1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 84,
|
|
85, -1, -1, -1, -1, -1, 91, -1, -1, 94,
|
|
95, -1, 97, 98, -1, -1, -1, -1, -1, 104,
|
|
-1, 106, 107, 108, -1, 110, 111, 112, -1, 114,
|
|
115, -1, -1, 118, 119, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 134,
|
|
135, 136, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 148, 3, 4, 5, 6, 7, 8,
|
|
9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
|
|
19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
|
|
-1, 30, 31, 32, 33, 34, 35, 36, 37, 38,
|
|
39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
|
|
49, 50, 51, 52, 53, 54, 55, 56, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
69, 70, 71, 72, 73, 74, 75, 76, 77, -1,
|
|
-1, 80, 81, -1, -1, -1, -1, 86, 87, 88,
|
|
89, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 100, 101, 102, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 124, 125, 126, 127, 128,
|
|
129, 130, 131, 132, 133, -1, 135, 136, -1, -1,
|
|
-1, -1, -1, -1, 143, 144, 3, 4, 5, 6,
|
|
7, 8, 9, 10, 11, -1, -1, -1, -1, -1,
|
|
-1, -1, 19, -1, 21, 22, 23, 24, -1, 26,
|
|
-1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
|
|
-1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
|
|
-1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
|
|
67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 84, 85, -1,
|
|
-1, -1, -1, -1, 91, -1, -1, 94, 95, -1,
|
|
97, 98, -1, 100, -1, 102, 103, 104, -1, 106,
|
|
107, 108, -1, 110, 111, 112, -1, 114, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 134, 135, 136,
|
|
-1, 138, -1, -1, -1, -1, -1, 144, 3, 4,
|
|
5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
|
|
-1, -1, -1, -1, 19, -1, 21, 22, 23, 24,
|
|
-1, 26, -1, -1, -1, 30, 31, 32, 33, 34,
|
|
35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
|
|
55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
|
|
-1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 84,
|
|
85, -1, -1, -1, -1, -1, 91, -1, -1, 94,
|
|
95, -1, 97, 98, -1, 100, -1, 102, 103, 104,
|
|
-1, 106, 107, 108, -1, 110, 111, 112, -1, 114,
|
|
-1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
|
|
7, 8, 9, 10, 11, -1, -1, -1, -1, 134,
|
|
135, 136, 19, 138, 21, 22, 23, 24, -1, 144,
|
|
-1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
|
|
-1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
|
|
-1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
|
|
67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 84, 85, -1,
|
|
-1, -1, -1, -1, 91, 92, -1, 94, 95, -1,
|
|
97, 98, -1, 100, -1, 102, 103, 104, -1, 106,
|
|
107, 108, -1, 110, 111, 112, -1, 114, -1, -1,
|
|
-1, -1, -1, -1, 121, 3, 4, 5, 6, 7,
|
|
8, 9, 10, 11, -1, -1, -1, 134, 135, 136,
|
|
-1, 19, -1, 21, 22, 23, 24, 144, -1, -1,
|
|
-1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
|
|
-1, 39, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
|
|
58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
|
|
-1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 84, 85, -1, -1,
|
|
-1, -1, -1, 91, 92, -1, 94, 95, -1, 97,
|
|
98, -1, 100, -1, 102, 103, 104, -1, 106, 107,
|
|
108, -1, 110, 111, 112, -1, 114, -1, -1, -1,
|
|
-1, -1, -1, 121, 3, 4, 5, 6, 7, 8,
|
|
9, 10, 11, -1, -1, -1, 134, 135, 136, -1,
|
|
19, -1, 21, 22, 23, 24, 144, -1, -1, -1,
|
|
-1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
|
|
39, -1, -1, -1, -1, -1, -1, -1, -1, 48,
|
|
49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
|
|
59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
|
|
69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 84, 85, -1, -1, -1,
|
|
-1, -1, 91, -1, -1, 94, 95, -1, 97, 98,
|
|
-1, 100, -1, 102, 103, 104, -1, 106, 107, 108,
|
|
-1, 110, 111, 112, -1, 114, -1, -1, -1, -1,
|
|
-1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
|
|
11, -1, -1, -1, -1, 134, 135, 136, 19, -1,
|
|
21, 22, 23, 24, -1, 144, -1, -1, -1, 30,
|
|
31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
|
|
51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
|
|
-1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
|
|
71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 84, 85, -1, -1, -1, -1, -1,
|
|
91, -1, -1, 94, 95, -1, 97, 98, -1, 100,
|
|
-1, 102, 103, 104, -1, 106, 107, 108, -1, 110,
|
|
111, 112, -1, 114, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 134, 135, 136, -1, -1, -1, -1,
|
|
-1, -1, -1, 144, 3, 4, 5, 6, 7, 8,
|
|
9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
|
|
19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
|
|
-1, 30, 31, 32, 33, 34, 35, 36, 37, 38,
|
|
39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
|
|
49, 50, 51, 52, 53, 54, 55, 56, -1, -1,
|
|
-1, -1, -1, -1, 63, -1, -1, -1, -1, -1,
|
|
69, 70, 71, 72, 73, 74, 75, 76, 77, -1,
|
|
-1, 80, 81, -1, -1, -1, -1, 86, 87, 88,
|
|
89, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 100, 101, 102, -1, -1, -1, -1, 107, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 124, 125, 126, 127, 128,
|
|
129, 130, 131, 132, 133, -1, 135, 136, -1, -1,
|
|
-1, -1, -1, -1, 143, 3, 4, 5, 6, 7,
|
|
8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
|
|
18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
|
|
-1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
|
|
38, 39, -1, -1, -1, -1, -1, 45, 46, 47,
|
|
48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
|
|
-1, -1, -1, -1, -1, 63, -1, -1, -1, -1,
|
|
-1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
|
|
-1, -1, 80, 81, -1, -1, -1, -1, 86, 87,
|
|
88, 89, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 100, 101, 102, -1, -1, -1, -1, 107,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 124, 125, 126, 127,
|
|
128, 129, 130, 131, 132, 133, -1, 135, 136, -1,
|
|
-1, -1, -1, -1, -1, 143, 3, 4, 5, 6,
|
|
7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
|
|
17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
|
|
-1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
|
|
37, 38, 39, -1, -1, -1, -1, -1, 45, 46,
|
|
47, 48, 49, 50, 51, 52, -1, -1, 55, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
|
|
77, -1, -1, 80, 81, -1, -1, -1, -1, 86,
|
|
87, 88, 89, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 100, 101, 102, -1, -1, -1, 106,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 124, 125, 126,
|
|
127, 128, 129, 130, 131, 132, 133, -1, 135, 136,
|
|
-1, -1, -1, -1, -1, -1, 143, 3, 4, 5,
|
|
6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
|
16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
|
|
26, -1, -1, -1, 30, 31, 32, 33, 34, 35,
|
|
36, 37, 38, 39, -1, -1, -1, -1, -1, 45,
|
|
46, 47, 48, 49, 50, 51, 52, -1, -1, 55,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
|
|
76, 77, -1, -1, 80, 81, -1, -1, -1, -1,
|
|
86, 87, 88, 89, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 100, 101, 102, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 124, 125,
|
|
126, 127, 128, 129, 130, 131, 132, 133, -1, 135,
|
|
136, -1, -1, -1, -1, -1, -1, 143, 3, 4,
|
|
5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
|
|
-1, -1, -1, -1, 19, -1, 21, 22, 23, 24,
|
|
-1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
|
|
35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
|
|
55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
|
|
-1, 66, 67, -1, 69, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 91, -1, -1, 94,
|
|
95, -1, 97, 98, -1, -1, -1, -1, -1, 104,
|
|
-1, 106, 107, 108, -1, 110, 111, 112, -1, 114,
|
|
-1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
|
|
11, -1, -1, -1, -1, -1, -1, -1, 19, 134,
|
|
21, 22, 23, 24, -1, -1, -1, 142, -1, 30,
|
|
31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
|
|
51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
|
|
-1, -1, 63, -1, -1, 66, 67, -1, 69, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
91, -1, -1, 94, 95, -1, 97, 98, -1, -1,
|
|
-1, -1, -1, 104, -1, 106, 107, 108, -1, 110,
|
|
111, 112, -1, 114, -1, -1, 3, 4, 5, 6,
|
|
7, 8, 9, 10, 11, 12, -1, -1, -1, -1,
|
|
-1, -1, 19, 134, 21, 22, 23, 24, -1, -1,
|
|
-1, 142, -1, 30, 31, 32, 33, 34, 35, 36,
|
|
-1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
|
|
47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
|
|
-1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
|
|
67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 84, 85, -1,
|
|
-1, -1, -1, -1, 91, -1, -1, 94, 95, -1,
|
|
97, 98, -1, 100, -1, -1, -1, 104, -1, 106,
|
|
107, 108, -1, 110, 111, 112, -1, 114, -1, -1,
|
|
-1, -1, -1, -1, 3, 4, 5, 6, 7, 8,
|
|
9, 10, 11, 12, -1, -1, -1, 134, 135, 136,
|
|
19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
|
|
-1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
|
|
39, -1, -1, -1, -1, -1, 45, -1, 47, 48,
|
|
49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
|
|
59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
|
|
69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 84, 85, -1, -1, -1,
|
|
-1, -1, 91, -1, -1, 94, 95, -1, 97, 98,
|
|
-1, 100, -1, -1, -1, 104, -1, 106, 107, 108,
|
|
-1, 110, 111, 112, -1, 114, -1, -1, -1, -1,
|
|
-1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
|
|
11, -1, -1, -1, -1, 134, 135, 136, 19, -1,
|
|
21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
|
|
31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
|
|
51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
|
|
-1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
|
|
71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 84, 85, -1, -1, -1, -1, -1,
|
|
91, -1, -1, 94, 95, -1, 97, 98, -1, 100,
|
|
-1, 102, 103, 104, -1, 106, 107, 108, -1, 110,
|
|
111, 112, -1, 114, -1, -1, -1, -1, -1, -1,
|
|
3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
|
|
-1, -1, -1, 134, 135, 136, 19, -1, 21, 22,
|
|
23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
|
|
33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
|
|
53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
|
|
63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 84, 85, -1, -1, -1, -1, -1, 91, -1,
|
|
-1, 94, 95, -1, 97, 98, -1, 100, -1, 102,
|
|
103, 104, -1, 106, 107, 108, -1, 110, 111, 112,
|
|
-1, 114, -1, -1, -1, -1, -1, -1, 3, 4,
|
|
5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
|
|
-1, 134, 135, 136, 19, -1, 21, 22, 23, 24,
|
|
-1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
|
|
35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
|
|
55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
|
|
-1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 84,
|
|
85, -1, -1, -1, -1, -1, 91, -1, -1, 94,
|
|
95, -1, 97, 98, -1, 100, -1, 102, 103, 104,
|
|
-1, 106, 107, 108, -1, 110, 111, 112, -1, 114,
|
|
-1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
|
|
7, 8, 9, 10, 11, -1, -1, -1, -1, 134,
|
|
135, 136, 19, -1, 21, 22, 23, 24, -1, -1,
|
|
-1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
|
|
-1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
|
|
-1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
|
|
67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 84, 85, -1,
|
|
-1, -1, -1, -1, 91, -1, -1, 94, 95, -1,
|
|
97, 98, -1, 100, -1, 102, 103, 104, -1, 106,
|
|
107, 108, -1, 110, 111, 112, -1, 114, -1, -1,
|
|
-1, -1, -1, -1, 3, 4, 5, 6, 7, 8,
|
|
9, 10, 11, -1, -1, -1, -1, 134, 135, 136,
|
|
19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
|
|
-1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
|
|
39, -1, -1, -1, -1, -1, -1, -1, -1, 48,
|
|
49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
|
|
59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
|
|
69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 84, 85, -1, -1, -1,
|
|
-1, -1, 91, -1, -1, 94, 95, -1, 97, 98,
|
|
-1, 100, -1, 102, -1, 104, -1, 106, 107, 108,
|
|
-1, 110, 111, 112, -1, 114, -1, -1, -1, -1,
|
|
-1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
|
|
11, -1, -1, -1, -1, 134, 135, 136, 19, -1,
|
|
21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
|
|
31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
|
|
51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
|
|
-1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
|
|
71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 84, 85, -1, -1, -1, -1, -1,
|
|
91, -1, -1, 94, 95, -1, 97, 98, -1, -1,
|
|
-1, 102, 103, 104, -1, 106, 107, 108, -1, 110,
|
|
111, 112, -1, 114, -1, -1, -1, -1, -1, -1,
|
|
3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
|
|
-1, -1, -1, 134, 135, 136, 19, -1, 21, 22,
|
|
23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
|
|
33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
|
|
53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
|
|
63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 84, 85, -1, -1, -1, -1, -1, 91, -1,
|
|
-1, 94, 95, -1, 97, 98, -1, 100, -1, 102,
|
|
-1, 104, -1, 106, 107, 108, -1, 110, 111, 112,
|
|
-1, 114, -1, -1, -1, -1, -1, -1, 3, 4,
|
|
5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
|
|
-1, 134, 135, 136, 19, -1, 21, 22, 23, 24,
|
|
-1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
|
|
35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
|
|
55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
|
|
-1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 84,
|
|
85, -1, -1, -1, -1, -1, 91, -1, -1, 94,
|
|
95, -1, 97, 98, -1, -1, -1, 102, -1, 104,
|
|
-1, 106, 107, 108, -1, 110, 111, 112, -1, 114,
|
|
-1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
|
|
7, 8, 9, 10, 11, -1, -1, -1, -1, 134,
|
|
135, 136, 19, -1, 21, 22, 23, 24, -1, -1,
|
|
-1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
|
|
-1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
|
|
-1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
|
|
67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 84, 85, -1,
|
|
-1, -1, -1, -1, 91, -1, -1, 94, 95, -1,
|
|
97, 98, -1, 100, -1, -1, -1, 104, -1, 106,
|
|
107, 108, -1, 110, 111, 112, -1, 114, -1, -1,
|
|
-1, -1, -1, -1, 3, 4, 5, 6, 7, 8,
|
|
9, 10, 11, -1, -1, -1, -1, 134, 135, 136,
|
|
19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
|
|
-1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
|
|
39, -1, -1, -1, -1, -1, -1, -1, -1, 48,
|
|
49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
|
|
59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
|
|
69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 84, 85, -1, -1, -1,
|
|
-1, -1, 91, -1, -1, 94, 95, -1, 97, 98,
|
|
-1, 100, -1, -1, -1, 104, -1, 106, 107, 108,
|
|
-1, 110, 111, 112, -1, 114, -1, -1, -1, -1,
|
|
-1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
|
|
11, -1, -1, -1, -1, 134, 135, 136, 19, -1,
|
|
21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
|
|
31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
|
|
51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
|
|
-1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
|
|
71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 84, 85, -1, -1, -1, -1, -1,
|
|
91, -1, -1, 94, 95, -1, 97, 98, -1, 100,
|
|
-1, -1, -1, 104, -1, 106, 107, 108, -1, 110,
|
|
111, 112, -1, 114, -1, -1, -1, -1, -1, -1,
|
|
3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
|
|
-1, -1, -1, 134, 135, 136, 19, -1, 21, 22,
|
|
23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
|
|
33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
|
|
53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
|
|
63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 84, 85, -1, -1, -1, -1, -1, 91, -1,
|
|
-1, 94, 95, -1, 97, 98, -1, 100, -1, -1,
|
|
-1, 104, -1, 106, 107, 108, -1, 110, 111, 112,
|
|
-1, 114, -1, -1, -1, -1, -1, -1, 3, 4,
|
|
5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
|
|
-1, 134, 135, 136, 19, -1, 21, 22, 23, 24,
|
|
-1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
|
|
35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
|
|
55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
|
|
-1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 84,
|
|
85, -1, -1, -1, -1, -1, 91, -1, -1, 94,
|
|
95, -1, 97, 98, -1, 100, -1, -1, -1, 104,
|
|
-1, 106, 107, 108, -1, 110, 111, 112, -1, 114,
|
|
-1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
|
|
7, 8, 9, 10, 11, -1, -1, -1, -1, 134,
|
|
135, 136, 19, -1, 21, 22, 23, 24, -1, -1,
|
|
-1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
|
|
-1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
|
|
-1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
|
|
67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 84, 85, -1,
|
|
-1, -1, -1, -1, 91, -1, -1, 94, 95, -1,
|
|
97, 98, -1, -1, -1, -1, -1, 104, -1, 106,
|
|
107, 108, -1, 110, 111, 112, -1, 114, -1, -1,
|
|
-1, -1, -1, -1, 3, 4, 5, 6, 7, 8,
|
|
9, 10, 11, -1, -1, -1, -1, 134, 135, 136,
|
|
19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
|
|
-1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
|
|
39, -1, -1, -1, -1, -1, -1, -1, -1, 48,
|
|
49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
|
|
59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
|
|
69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 84, 85, -1, -1, -1,
|
|
-1, -1, 91, -1, -1, 94, 95, -1, 97, 98,
|
|
-1, -1, -1, -1, -1, 104, -1, 106, 107, 108,
|
|
-1, 110, 111, 112, -1, 114, -1, -1, -1, -1,
|
|
-1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
|
|
11, -1, -1, -1, -1, 134, 135, 136, 19, -1,
|
|
21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
|
|
31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
|
|
51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
|
|
-1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
|
|
71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 84, 85, -1, -1, -1, -1, -1,
|
|
91, -1, -1, 94, 95, -1, 97, 98, -1, -1,
|
|
-1, -1, -1, 104, -1, 106, 107, 108, -1, 110,
|
|
111, 112, -1, 114, -1, -1, -1, -1, -1, -1,
|
|
3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
|
|
-1, -1, -1, 134, 135, 136, 19, -1, 21, 22,
|
|
23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
|
|
33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
|
|
53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
|
|
63, -1, -1, 66, 67, -1, 69, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 88, -1, -1, 91, -1,
|
|
-1, 94, 95, -1, 97, 98, -1, -1, -1, -1,
|
|
-1, 104, -1, 106, 107, 108, -1, 110, 111, 112,
|
|
-1, 114, -1, -1, 3, 4, 5, 6, 7, 8,
|
|
9, 10, 11, -1, -1, -1, -1, -1, -1, -1,
|
|
19, 134, 21, 22, 23, 24, -1, -1, -1, -1,
|
|
-1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
|
|
39, -1, -1, -1, -1, -1, -1, -1, -1, 48,
|
|
49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
|
|
59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
|
|
69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 91, -1, -1, 94, 95, -1, 97, 98,
|
|
-1, 100, -1, -1, -1, 104, -1, 106, 107, 108,
|
|
-1, 110, 111, 112, -1, 114, -1, -1, 3, 4,
|
|
5, 6, 7, 8, 9, 10, 11, -1, -1, -1,
|
|
-1, -1, -1, -1, 19, 134, 21, 22, 23, 24,
|
|
-1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
|
|
35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 48, 49, 50, 51, 52, 53, 54,
|
|
55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
|
|
-1, 66, 67, -1, 69, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 91, -1, -1, 94,
|
|
95, -1, 97, 98, -1, 100, -1, -1, -1, 104,
|
|
-1, 106, 107, 108, -1, 110, 111, 112, -1, 114,
|
|
-1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
|
|
11, -1, -1, -1, -1, -1, -1, -1, 19, 134,
|
|
21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
|
|
31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 48, 49, 50,
|
|
51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
|
|
-1, -1, 63, -1, -1, 66, 67, -1, 69, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
91, -1, -1, 94, 95, -1, 97, 98, -1, -1,
|
|
-1, -1, -1, 104, -1, 106, 107, 108, -1, 110,
|
|
111, 112, -1, 114, -1, -1, 3, 4, 5, 6,
|
|
7, 8, 9, 10, 11, -1, -1, -1, -1, -1,
|
|
-1, -1, 19, 134, 21, 22, 23, 24, -1, -1,
|
|
-1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
|
|
-1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
|
|
-1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
|
|
67, -1, 69, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 91, -1, -1, 94, 95, -1,
|
|
97, 98, -1, -1, -1, -1, -1, 104, -1, 106,
|
|
107, 108, -1, 110, 111, 112, -1, 114, -1, -1,
|
|
3, 4, 5, 6, 7, 8, 9, 10, 11, -1,
|
|
-1, -1, -1, -1, -1, -1, 19, 134, 21, 22,
|
|
23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
|
|
33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 48, 49, 50, 51, 52,
|
|
53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
|
|
63, -1, -1, 66, 67, -1, 69, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 91, -1,
|
|
-1, 94, 95, -1, 97, 98, -1, -1, -1, -1,
|
|
-1, 104, -1, 106, 107, 108, -1, 110, 111, 112,
|
|
-1, 114, -1, -1, 3, 4, 5, 6, 7, 8,
|
|
9, 10, 11, -1, -1, -1, -1, -1, -1, -1,
|
|
19, 134, 21, 22, 23, 24, -1, -1, -1, -1,
|
|
-1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
|
|
39, -1, -1, -1, -1, -1, -1, -1, -1, 48,
|
|
49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
|
|
59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
|
|
69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 91, -1, -1, 94, 95, -1, 97, 98,
|
|
-1, -1, 51, 52, -1, 104, 55, 106, 107, 108,
|
|
-1, 110, 111, 112, -1, 114, -1, -1, -1, -1,
|
|
-1, 70, 71, 72, 73, 74, 75, 76, 77, -1,
|
|
-1, 80, 81, -1, -1, 134, -1, 86, 87, 88,
|
|
89, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 100, 101, 102, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 124, 125, 126, 127, 128,
|
|
129, 130, 131, 132, 133, -1, 135, 136, 51, 52,
|
|
-1, -1, 55, -1, 143, 144, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
|
|
73, 74, 75, 76, 77, -1, -1, 80, 81, -1,
|
|
-1, -1, -1, 86, 87, 88, 89, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 100, 101, 102,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 124, 125, 126, 127, 128, 129, 130, 131, 132,
|
|
133, -1, 135, 136, 51, 52, -1, -1, 55, -1,
|
|
143, 144, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
|
|
77, -1, -1, 80, 81, -1, -1, -1, -1, 86,
|
|
87, 88, 89, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 100, 101, 102, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 124, 125, 126,
|
|
127, 128, 129, 130, 131, 132, 133, -1, 135, 136,
|
|
51, 52, -1, -1, 55, -1, 143, 144, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
|
|
71, 72, 73, 74, 75, 76, 77, -1, -1, 80,
|
|
81, -1, -1, -1, -1, 86, 87, 88, 89, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 100,
|
|
101, 102, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 124, 125, 126, 127, 128, 129, 130,
|
|
131, 132, 133, -1, 135, 136, 51, 52, -1, -1,
|
|
55, -1, 143, 144, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 70, 71, 72, 73, 74,
|
|
75, 76, 77, -1, -1, 80, 81, -1, -1, -1,
|
|
-1, 86, 87, 88, 89, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 100, 101, 102, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 124,
|
|
125, 126, 127, 128, 129, 130, 131, 132, 133, -1,
|
|
135, 136, 51, 52, -1, -1, 55, -1, 143, 144,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 70, 71, 72, 73, 74, 75, 76, 77, -1,
|
|
-1, 80, 81, -1, -1, -1, -1, 86, 87, 88,
|
|
89, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 100, 101, 102, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 124, 125, 126, 127, 128,
|
|
129, 130, 131, 132, 133, -1, 135, 136, 51, 52,
|
|
-1, -1, 55, -1, 143, 144, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
|
|
73, 74, 75, 76, 77, -1, -1, 80, 81, -1,
|
|
-1, -1, -1, 86, 87, 88, 89, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 100, 101, 102,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 124, 125, 126, 127, 128, 129, 130, 131, 132,
|
|
133, -1, 135, 136, 51, 52, -1, -1, 55, -1,
|
|
143, 144, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
|
|
77, -1, -1, 80, 81, -1, -1, -1, -1, 86,
|
|
87, 88, 89, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 100, 101, 102, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 124, 125, 126,
|
|
127, 128, 129, 130, 131, 132, 133, -1, 135, 136,
|
|
51, 52, -1, -1, 55, -1, 143, 144, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
|
|
71, 72, 73, 74, 75, 76, 77, -1, -1, 80,
|
|
81, -1, -1, -1, -1, 86, 87, 88, 89, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 100,
|
|
101, 102, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 124, 125, 126, 127, 128, 129, 130,
|
|
131, 132, 133, -1, 135, 136, 51, 52, -1, -1,
|
|
55, -1, 143, 144, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 70, 71, 72, 73, 74,
|
|
75, 76, 77, -1, -1, 80, 81, -1, -1, -1,
|
|
-1, 86, 87, 88, 89, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 100, 101, 102, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 124,
|
|
125, 126, 127, 128, 129, 130, 131, 132, 133, -1,
|
|
135, 136, 51, 52, -1, -1, 55, -1, 143, 144,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 70, 71, 72, 73, 74, 75, 76, 77, -1,
|
|
-1, 80, 81, -1, -1, -1, -1, 86, 87, 88,
|
|
89, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 100, 101, 102, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 124, 125, 126, 127, 128,
|
|
129, 130, 131, 132, 133, -1, 135, 136, 51, 52,
|
|
-1, -1, 55, -1, 143, 144, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
|
|
73, 74, 75, 76, 77, -1, -1, 80, 81, -1,
|
|
-1, -1, -1, 86, 87, 88, 89, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 100, 101, 102,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 124, 125, 126, 127, 128, 129, 130, 131, 132,
|
|
133, -1, 135, 136, 51, 52, -1, -1, 55, -1,
|
|
143, 144, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
|
|
77, -1, -1, 80, 81, -1, -1, -1, -1, 86,
|
|
87, 88, 89, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 100, 101, 102, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 124, 125, 126,
|
|
127, 128, 129, 130, 131, 132, 133, -1, 135, 136,
|
|
51, 52, -1, -1, 55, -1, 143, 144, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
|
|
71, 72, 73, 74, 75, 76, 77, -1, -1, 80,
|
|
81, -1, -1, -1, -1, 86, 87, 88, 89, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 100,
|
|
101, 102, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 44, -1, -1, -1, -1,
|
|
-1, -1, -1, 124, 125, 126, 127, 128, 129, 130,
|
|
131, 132, 133, -1, 135, 136, -1, -1, -1, -1,
|
|
-1, -1, 143, 72, 73, 74, 75, 76, 77, 78,
|
|
79, 80, 81, 82, 83, -1, -1, -1, -1, 88,
|
|
89, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 101, -1, -1, -1, -1, 44, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 122, -1, 124, 125, 126, 127, 128,
|
|
129, 130, 131, 132, 133, 72, 73, 74, 75, 76,
|
|
77, 78, 79, 80, 81, 82, 83, -1, -1, -1,
|
|
-1, 88, 89, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 101, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 122, -1, 124, 125, 126,
|
|
127, 128, 129, 130, 131, 132, 133, 72, 73, 74,
|
|
75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
|
|
-1, -1, -1, 88, 89, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 101, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 122, -1, 124,
|
|
125, 126, 127, 128, 129, 130, 131, 132, 133, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 142, 72, 73,
|
|
74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
|
|
-1, -1, -1, -1, 88, 89, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 101, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 122, -1,
|
|
124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 142, 72,
|
|
73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
|
|
83, -1, -1, -1, -1, 88, 89, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 101, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
|
|
-1, 124, 125, 126, 127, 128, 129, 130, 131, 132,
|
|
133, -1, -1, -1, -1, -1, -1, -1, -1, 142,
|
|
72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
|
|
82, 83, -1, -1, -1, -1, 88, 89, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 101,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
122, -1, 124, 125, 126, 127, 128, 129, 130, 131,
|
|
132, 133, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
142, 72, 73, 74, 75, 76, 77, 78, 79, 80,
|
|
81, 82, 83, -1, -1, -1, -1, 88, 89, -1,
|
|
-1, -1, 93, -1, -1, -1, -1, -1, -1, -1,
|
|
101, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 122, -1, 124, 125, 126, 127, 128, 129, 130,
|
|
131, 132, 133, 72, 73, 74, 75, 76, 77, 78,
|
|
79, 80, 81, 82, 83, -1, -1, -1, -1, 88,
|
|
89, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 101, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 122, -1, 124, 125, 126, 127, 128,
|
|
129, 130, 131, 132, 133, 72, 73, 74, 75, 76,
|
|
77, 78, 79, 80, 81, 82, 83, -1, -1, -1,
|
|
-1, 88, 89, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 101, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 124, 125, 126,
|
|
127, 128, 129, 130, 131, 132, 133
|
|
};
|
|
|
|
/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
|
|
state STATE-NUM. */
|
|
static const yytype_int16 yystos[] =
|
|
{
|
|
0, 150, 151, 1, 3, 4, 5, 6, 7, 8,
|
|
9, 10, 11, 12, 19, 21, 22, 23, 24, 30,
|
|
31, 32, 33, 34, 35, 36, 39, 45, 46, 47,
|
|
48, 49, 50, 51, 52, 53, 54, 55, 56, 58,
|
|
59, 60, 63, 66, 67, 69, 70, 71, 84, 85,
|
|
91, 94, 95, 97, 98, 100, 104, 106, 107, 108,
|
|
110, 111, 112, 114, 134, 135, 136, 152, 153, 154,
|
|
160, 161, 163, 164, 166, 168, 169, 172, 173, 175,
|
|
176, 177, 179, 180, 189, 203, 220, 241, 242, 252,
|
|
253, 254, 258, 259, 260, 266, 267, 268, 270, 271,
|
|
272, 273, 274, 275, 311, 324, 0, 154, 21, 22,
|
|
30, 31, 32, 39, 51, 55, 69, 88, 91, 94,
|
|
134, 164, 166, 181, 182, 203, 220, 272, 275, 311,
|
|
182, 3, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
|
|
22, 23, 24, 25, 26, 30, 31, 32, 33, 34,
|
|
35, 36, 37, 38, 39, 45, 46, 47, 48, 49,
|
|
50, 51, 52, 55, 70, 71, 72, 73, 74, 75,
|
|
76, 77, 80, 81, 86, 87, 88, 89, 100, 101,
|
|
102, 124, 125, 126, 127, 128, 129, 130, 131, 132,
|
|
133, 135, 136, 143, 144, 183, 187, 188, 274, 306,
|
|
204, 91, 163, 164, 166, 167, 180, 189, 220, 272,
|
|
273, 275, 167, 210, 212, 69, 91, 173, 180, 220,
|
|
225, 272, 275, 33, 34, 35, 36, 48, 49, 50,
|
|
51, 55, 106, 183, 184, 185, 268, 115, 118, 119,
|
|
146, 148, 167, 262, 263, 264, 317, 321, 322, 323,
|
|
51, 69, 100, 102, 103, 135, 172, 189, 195, 198,
|
|
201, 254, 309, 310, 195, 195, 144, 192, 193, 196,
|
|
197, 324, 192, 197, 144, 318, 184, 155, 138, 189,
|
|
220, 189, 189, 189, 55, 1, 94, 157, 158, 160,
|
|
174, 175, 324, 205, 207, 190, 201, 309, 324, 189,
|
|
308, 309, 324, 91, 142, 179, 220, 272, 275, 208,
|
|
53, 54, 56, 63, 69, 107, 183, 269, 63, 64,
|
|
65, 116, 117, 255, 256, 61, 255, 62, 255, 63,
|
|
255, 63, 255, 58, 59, 168, 189, 189, 317, 323,
|
|
40, 41, 42, 43, 44, 37, 38, 51, 53, 54,
|
|
55, 56, 69, 83, 94, 100, 101, 102, 103, 128,
|
|
131, 144, 278, 279, 280, 281, 282, 285, 286, 287,
|
|
288, 290, 291, 292, 293, 295, 296, 297, 300, 301,
|
|
302, 303, 304, 324, 278, 280, 28, 240, 121, 142,
|
|
94, 100, 176, 121, 72, 73, 74, 75, 76, 77,
|
|
78, 79, 80, 81, 82, 83, 88, 89, 93, 101,
|
|
122, 124, 125, 126, 127, 128, 129, 130, 131, 132,
|
|
133, 90, 105, 140, 147, 315, 90, 315, 316, 26,
|
|
138, 244, 254, 92, 92, 192, 197, 244, 163, 51,
|
|
55, 181, 58, 59, 279, 125, 276, 90, 140, 315,
|
|
219, 307, 90, 147, 314, 156, 157, 55, 278, 278,
|
|
16, 221, 321, 121, 90, 140, 315, 92, 92, 221,
|
|
167, 167, 55, 90, 140, 315, 25, 107, 142, 265,
|
|
317, 115, 264, 20, 246, 321, 57, 57, 189, 189,
|
|
189, 93, 142, 199, 200, 324, 57, 199, 200, 85,
|
|
194, 195, 201, 309, 324, 195, 163, 317, 319, 163,
|
|
322, 159, 138, 157, 90, 315, 92, 160, 174, 145,
|
|
317, 323, 319, 160, 319, 141, 200, 320, 323, 200,
|
|
320, 139, 320, 55, 176, 177, 178, 142, 90, 140,
|
|
315, 144, 237, 290, 295, 63, 255, 257, 261, 262,
|
|
63, 256, 61, 62, 63, 63, 101, 101, 154, 167,
|
|
167, 167, 167, 160, 163, 163, 57, 121, 57, 321,
|
|
294, 85, 290, 295, 121, 156, 189, 142, 305, 324,
|
|
51, 142, 305, 321, 142, 289, 189, 142, 289, 51,
|
|
142, 289, 51, 121, 156, 239, 100, 168, 189, 201,
|
|
202, 174, 142, 179, 142, 161, 162, 168, 180, 189,
|
|
191, 202, 220, 275, 189, 189, 189, 189, 189, 189,
|
|
189, 189, 189, 189, 189, 189, 189, 189, 51, 189,
|
|
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
|
|
189, 51, 52, 55, 187, 192, 312, 313, 194, 201,
|
|
51, 52, 55, 187, 192, 312, 51, 55, 312, 245,
|
|
243, 162, 189, 191, 162, 191, 99, 171, 217, 277,
|
|
216, 51, 55, 181, 312, 194, 312, 156, 163, 165,
|
|
15, 13, 248, 324, 121, 121, 157, 16, 51, 55,
|
|
194, 51, 55, 157, 27, 222, 321, 222, 51, 55,
|
|
194, 51, 55, 214, 186, 157, 246, 189, 201, 15,
|
|
189, 189, 189, 318, 100, 189, 198, 309, 189, 310,
|
|
319, 145, 317, 200, 200, 319, 145, 184, 152, 139,
|
|
191, 319, 160, 206, 309, 176, 178, 51, 55, 194,
|
|
51, 55, 290, 209, 142, 63, 157, 262, 189, 189,
|
|
51, 69, 100, 226, 295, 319, 319, 142, 172, 189,
|
|
15, 51, 69, 282, 287, 304, 85, 288, 293, 300,
|
|
302, 295, 297, 302, 51, 295, 172, 189, 15, 79,
|
|
126, 231, 233, 324, 189, 200, 319, 178, 142, 44,
|
|
121, 44, 90, 140, 315, 318, 92, 92, 192, 197,
|
|
141, 200, 92, 92, 193, 197, 193, 197, 231, 231,
|
|
170, 321, 167, 156, 141, 15, 319, 183, 189, 202,
|
|
249, 324, 18, 224, 324, 17, 223, 224, 92, 92,
|
|
141, 92, 92, 224, 211, 213, 141, 167, 184, 139,
|
|
15, 200, 221, 189, 199, 85, 309, 139, 319, 320,
|
|
141, 234, 318, 29, 113, 238, 139, 142, 292, 319,
|
|
142, 85, 44, 44, 305, 321, 142, 289, 142, 289,
|
|
142, 289, 142, 289, 289, 44, 44, 228, 230, 232,
|
|
281, 283, 284, 287, 295, 296, 298, 299, 302, 304,
|
|
156, 100, 189, 178, 160, 189, 51, 55, 194, 51,
|
|
55, 57, 123, 162, 191, 168, 191, 171, 92, 162,
|
|
191, 162, 191, 171, 244, 240, 156, 157, 231, 218,
|
|
321, 15, 93, 250, 324, 157, 14, 251, 324, 167,
|
|
15, 92, 15, 157, 157, 222, 189, 157, 319, 200,
|
|
145, 146, 156, 157, 227, 142, 100, 319, 189, 189,
|
|
295, 302, 295, 295, 189, 189, 234, 234, 91, 220,
|
|
142, 305, 305, 142, 229, 220, 142, 229, 142, 229,
|
|
15, 189, 141, 189, 189, 162, 191, 15, 139, 157,
|
|
156, 91, 180, 220, 272, 275, 221, 157, 221, 15,
|
|
15, 215, 224, 246, 247, 51, 235, 236, 291, 15,
|
|
139, 295, 295, 142, 292, 289, 142, 289, 289, 289,
|
|
126, 126, 55, 90, 283, 287, 142, 228, 229, 299,
|
|
302, 295, 298, 302, 295, 139, 15, 55, 90, 140,
|
|
315, 157, 157, 157, 142, 318, 142, 295, 142, 295,
|
|
51, 55, 305, 142, 229, 142, 229, 142, 229, 142,
|
|
229, 229, 51, 55, 194, 51, 55, 248, 223, 15,
|
|
236, 295, 289, 295, 302, 295, 295, 141, 229, 142,
|
|
229, 229, 229, 295, 229
|
|
};
|
|
|
|
/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */
|
|
static const yytype_int16 yyr1[] =
|
|
{
|
|
0, 149, 150, 151, 152, 153, 153, 153, 153, 154,
|
|
155, 154, 156, 157, 158, 158, 158, 158, 159, 160,
|
|
160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
|
|
160, 160, 160, 160, 161, 161, 161, 161, 161, 161,
|
|
161, 161, 161, 161, 161, 161, 162, 162, 162, 163,
|
|
163, 163, 163, 163, 163, 164, 165, 166, 167, 168,
|
|
168, 169, 169, 170, 171, 172, 172, 172, 172, 172,
|
|
172, 172, 172, 172, 172, 172, 173, 173, 174, 174,
|
|
175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
|
|
176, 176, 177, 177, 178, 178, 179, 179, 179, 179,
|
|
179, 179, 179, 179, 180, 180, 180, 180, 180, 180,
|
|
180, 180, 180, 181, 181, 182, 182, 182, 183, 183,
|
|
183, 183, 183, 184, 184, 185, 186, 185, 187, 187,
|
|
187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
|
|
187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
|
|
187, 187, 187, 187, 187, 187, 187, 187, 188, 188,
|
|
188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
|
|
188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
|
|
188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
|
|
188, 188, 188, 188, 188, 188, 188, 188, 189, 189,
|
|
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
|
|
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
|
|
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
|
|
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
|
|
189, 189, 189, 189, 189, 189, 189, 189, 189, 190,
|
|
190, 190, 190, 191, 191, 192, 192, 192, 193, 193,
|
|
194, 194, 194, 194, 194, 195, 195, 195, 195, 195,
|
|
196, 197, 198, 198, 199, 199, 200, 201, 201, 201,
|
|
201, 201, 201, 202, 202, 202, 203, 203, 203, 203,
|
|
203, 203, 203, 203, 204, 203, 205, 206, 203, 207,
|
|
203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
|
|
203, 203, 203, 208, 209, 203, 203, 203, 210, 211,
|
|
203, 212, 213, 203, 203, 203, 214, 215, 203, 216,
|
|
203, 217, 218, 203, 219, 203, 203, 203, 203, 203,
|
|
203, 203, 220, 221, 221, 221, 222, 222, 223, 223,
|
|
224, 224, 225, 225, 226, 226, 226, 226, 226, 226,
|
|
226, 226, 227, 226, 228, 228, 228, 228, 229, 229,
|
|
230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
|
|
230, 230, 230, 230, 230, 231, 231, 232, 233, 233,
|
|
233, 234, 234, 235, 235, 236, 236, 237, 237, 238,
|
|
238, 239, 240, 241, 241, 241, 241, 242, 242, 242,
|
|
242, 242, 242, 242, 242, 242, 243, 244, 245, 244,
|
|
246, 247, 247, 248, 248, 249, 249, 249, 250, 250,
|
|
251, 251, 252, 252, 252, 252, 253, 253, 254, 254,
|
|
254, 254, 255, 255, 256, 257, 256, 256, 256, 258,
|
|
258, 259, 259, 260, 261, 261, 262, 262, 263, 263,
|
|
264, 265, 264, 266, 266, 267, 267, 267, 268, 269,
|
|
269, 269, 269, 269, 269, 270, 270, 271, 271, 271,
|
|
271, 272, 272, 272, 272, 272, 273, 273, 274, 274,
|
|
274, 274, 274, 274, 274, 274, 274, 275, 275, 276,
|
|
277, 276, 278, 278, 279, 279, 279, 280, 280, 280,
|
|
280, 281, 281, 282, 282, 283, 283, 284, 284, 285,
|
|
285, 286, 286, 287, 287, 288, 288, 288, 288, 289,
|
|
289, 290, 290, 290, 290, 290, 290, 290, 290, 290,
|
|
290, 290, 290, 290, 290, 290, 291, 291, 291, 291,
|
|
291, 292, 292, 293, 294, 293, 295, 295, 296, 297,
|
|
298, 299, 299, 300, 300, 301, 301, 302, 302, 303,
|
|
303, 304, 304, 305, 305, 306, 307, 306, 308, 308,
|
|
309, 309, 310, 310, 310, 310, 310, 310, 310, 310,
|
|
311, 311, 311, 312, 312, 312, 312, 313, 313, 313,
|
|
314, 314, 315, 315, 316, 316, 317, 317, 318, 318,
|
|
319, 320, 320, 320, 321, 321, 322, 322, 323, 323,
|
|
324
|
|
};
|
|
|
|
/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */
|
|
static const yytype_int8 yyr2[] =
|
|
{
|
|
0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
|
|
0, 5, 4, 2, 1, 1, 3, 2, 0, 4,
|
|
2, 3, 3, 3, 3, 3, 4, 1, 3, 3,
|
|
3, 3, 3, 1, 3, 3, 6, 5, 5, 5,
|
|
5, 4, 6, 4, 6, 3, 1, 3, 1, 1,
|
|
3, 3, 3, 2, 1, 2, 0, 5, 1, 1,
|
|
1, 1, 4, 0, 5, 2, 3, 4, 5, 4,
|
|
5, 2, 2, 2, 2, 2, 1, 3, 1, 3,
|
|
1, 2, 3, 5, 2, 4, 2, 4, 1, 3,
|
|
1, 3, 2, 3, 1, 2, 1, 4, 3, 3,
|
|
3, 3, 2, 1, 1, 4, 3, 3, 3, 3,
|
|
2, 1, 1, 1, 1, 2, 1, 3, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 0, 4, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 3, 3,
|
|
6, 5, 5, 5, 5, 4, 3, 3, 2, 2,
|
|
3, 2, 2, 3, 3, 3, 3, 3, 3, 4,
|
|
4, 2, 2, 3, 3, 3, 3, 3, 3, 3,
|
|
3, 3, 3, 3, 3, 3, 2, 2, 3, 3,
|
|
3, 3, 6, 6, 4, 6, 4, 6, 1, 1,
|
|
2, 4, 2, 1, 3, 3, 5, 3, 1, 1,
|
|
1, 2, 2, 4, 2, 1, 2, 2, 4, 1,
|
|
0, 2, 2, 1, 2, 1, 2, 1, 1, 2,
|
|
3, 3, 4, 3, 4, 2, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 0, 4, 0, 0, 5, 0,
|
|
3, 3, 3, 2, 3, 3, 1, 2, 4, 3,
|
|
2, 1, 2, 0, 0, 5, 6, 6, 0, 0,
|
|
7, 0, 0, 7, 5, 4, 0, 0, 9, 0,
|
|
6, 0, 0, 8, 0, 5, 4, 4, 1, 1,
|
|
1, 1, 1, 1, 1, 2, 1, 1, 1, 5,
|
|
1, 2, 1, 1, 1, 4, 6, 3, 5, 2,
|
|
4, 1, 0, 4, 4, 2, 2, 1, 2, 0,
|
|
6, 8, 4, 6, 4, 3, 6, 2, 4, 6,
|
|
2, 4, 2, 4, 1, 1, 1, 0, 4, 1,
|
|
4, 1, 4, 1, 3, 1, 1, 4, 1, 3,
|
|
3, 0, 5, 2, 4, 5, 5, 2, 4, 4,
|
|
3, 3, 3, 2, 1, 4, 0, 5, 0, 5,
|
|
5, 1, 1, 6, 1, 1, 1, 1, 2, 1,
|
|
2, 1, 1, 1, 1, 1, 1, 2, 1, 1,
|
|
2, 3, 1, 2, 1, 0, 4, 1, 2, 2,
|
|
3, 2, 3, 1, 1, 2, 1, 2, 1, 2,
|
|
1, 0, 4, 2, 3, 1, 4, 2, 2, 1,
|
|
1, 1, 1, 1, 2, 2, 3, 1, 1, 2,
|
|
2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
|
|
0, 4, 1, 1, 3, 5, 3, 1, 2, 4,
|
|
2, 2, 2, 2, 1, 2, 1, 1, 3, 1,
|
|
3, 1, 1, 2, 1, 4, 2, 2, 1, 2,
|
|
0, 6, 8, 4, 6, 4, 6, 2, 4, 6,
|
|
2, 4, 2, 4, 1, 0, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 0, 4, 1, 3, 2, 2,
|
|
2, 1, 3, 1, 3, 1, 1, 2, 1, 1,
|
|
1, 2, 1, 2, 1, 1, 0, 4, 1, 2,
|
|
1, 3, 3, 3, 2, 2, 3, 3, 2, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 0, 1, 0, 2,
|
|
2, 0, 1, 1, 1, 1, 1, 1, 1, 2,
|
|
0
|
|
};
|
|
|
|
|
|
enum { YYENOMEM = -2 };
|
|
|
|
#define yyerrok (yyerrstatus = 0)
|
|
#define yyclearin (yychar = YYEMPTY)
|
|
|
|
#define YYACCEPT goto yyacceptlab
|
|
#define YYABORT goto yyabortlab
|
|
#define YYERROR goto yyerrorlab
|
|
#define YYNOMEM goto yyexhaustedlab
|
|
|
|
|
|
#define YYRECOVERING() (!!yyerrstatus)
|
|
|
|
#define YYBACKUP(Token, Value) \
|
|
do \
|
|
if (yychar == YYEMPTY) \
|
|
{ \
|
|
yychar = (Token); \
|
|
yylval = (Value); \
|
|
YYPOPSTACK (yylen); \
|
|
yystate = *yyssp; \
|
|
goto yybackup; \
|
|
} \
|
|
else \
|
|
{ \
|
|
yyerror (&yylloc, p, YY_("syntax error: cannot back up")); \
|
|
YYERROR; \
|
|
} \
|
|
while (0)
|
|
|
|
/* Backward compatibility with an undocumented macro.
|
|
Use YYerror or YYUNDEF. */
|
|
#define YYERRCODE YYUNDEF
|
|
|
|
/* 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). */
|
|
|
|
#ifndef YYLLOC_DEFAULT
|
|
# define YYLLOC_DEFAULT(Current, Rhs, N) \
|
|
do \
|
|
if (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 (0)
|
|
#endif
|
|
|
|
#define YYRHSLOC(Rhs, K) ((Rhs)[K])
|
|
|
|
|
|
/* 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 (0)
|
|
|
|
|
|
/* YYLOCATION_PRINT -- Print the location on the stream.
|
|
This macro was not mandated originally: define only if we know
|
|
we won't break user code: when these are the locations we know. */
|
|
|
|
# ifndef YYLOCATION_PRINT
|
|
|
|
# if defined YY_LOCATION_PRINT
|
|
|
|
/* Temporary convenience wrapper in case some people defined the
|
|
undocumented and private YY_LOCATION_PRINT macros. */
|
|
# define YYLOCATION_PRINT(File, Loc, p) YY_LOCATION_PRINT(File, *(Loc), p)
|
|
|
|
# elif defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
|
|
|
|
/* Print *YYLOCP on YYO. Private, do not rely on its existence. */
|
|
|
|
YY_ATTRIBUTE_UNUSED
|
|
static int
|
|
yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
|
|
{
|
|
int res = 0;
|
|
int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
|
|
if (0 <= yylocp->first_line)
|
|
{
|
|
res += YYFPRINTF (yyo, "%d", yylocp->first_line);
|
|
if (0 <= yylocp->first_column)
|
|
res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
|
|
}
|
|
if (0 <= yylocp->last_line)
|
|
{
|
|
if (yylocp->first_line < yylocp->last_line)
|
|
{
|
|
res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
|
|
if (0 <= end_col)
|
|
res += YYFPRINTF (yyo, ".%d", end_col);
|
|
}
|
|
else if (0 <= end_col && yylocp->first_column < end_col)
|
|
res += YYFPRINTF (yyo, "-%d", end_col);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
# define YYLOCATION_PRINT yy_location_print_
|
|
|
|
/* Temporary convenience wrapper in case some people defined the
|
|
undocumented and private YY_LOCATION_PRINT macros. */
|
|
# define YY_LOCATION_PRINT(File, Loc, p) YYLOCATION_PRINT(File, &(Loc), p)
|
|
|
|
# else
|
|
|
|
# define YYLOCATION_PRINT(File, Loc, p) ((void) 0)
|
|
/* Temporary convenience wrapper in case some people defined the
|
|
undocumented and private YY_LOCATION_PRINT macros. */
|
|
# define YY_LOCATION_PRINT YYLOCATION_PRINT
|
|
|
|
# endif
|
|
# endif /* !defined YYLOCATION_PRINT */
|
|
|
|
|
|
# define YY_SYMBOL_PRINT(Title, Kind, Value, Location, p) \
|
|
do { \
|
|
if (yydebug) \
|
|
{ \
|
|
YYFPRINTF (stderr, "%s ", Title); \
|
|
yy_symbol_print (stderr, \
|
|
Kind, Value, Location, p); \
|
|
YYFPRINTF (stderr, "\n"); \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
/*-----------------------------------.
|
|
| Print this symbol's value on YYO. |
|
|
`-----------------------------------*/
|
|
|
|
static void
|
|
yy_symbol_value_print (FILE *yyo,
|
|
yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, parser_state *p)
|
|
{
|
|
FILE *yyoutput = yyo;
|
|
YY_USE (yyoutput);
|
|
YY_USE (yylocationp);
|
|
YY_USE (p);
|
|
if (!yyvaluep)
|
|
return;
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
switch (yykind)
|
|
{
|
|
default:
|
|
break;
|
|
}
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_END
|
|
}
|
|
|
|
|
|
/*---------------------------.
|
|
| Print this symbol on YYO. |
|
|
`---------------------------*/
|
|
|
|
static void
|
|
yy_symbol_print (FILE *yyo,
|
|
yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, parser_state *p)
|
|
{
|
|
YYFPRINTF (yyo, "%s %s (",
|
|
yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
|
|
|
|
YYLOCATION_PRINT (yyo, yylocationp, p);
|
|
YYFPRINTF (yyo, ": ");
|
|
yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp, p);
|
|
YYFPRINTF (yyo, ")");
|
|
}
|
|
|
|
/*------------------------------------------------------------------.
|
|
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
|
|
| TOP (included). |
|
|
`------------------------------------------------------------------*/
|
|
|
|
static void
|
|
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop, parser_state *p)
|
|
{
|
|
YYFPRINTF (stderr, "Stack now");
|
|
for (; yybottom <= yytop; yybottom++)
|
|
{
|
|
int yybot = *yybottom;
|
|
YYFPRINTF (stderr, " %d", yybot);
|
|
}
|
|
YYFPRINTF (stderr, "\n");
|
|
}
|
|
|
|
# define YY_STACK_PRINT(Bottom, Top, p) \
|
|
do { \
|
|
if (yydebug) \
|
|
yy_stack_print ((Bottom), (Top), p); \
|
|
} while (0)
|
|
|
|
|
|
/*------------------------------------------------.
|
|
| Report that the YYRULE is going to be reduced. |
|
|
`------------------------------------------------*/
|
|
|
|
static void
|
|
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp,
|
|
int yyrule, parser_state *p)
|
|
{
|
|
int yylno = yyrline[yyrule];
|
|
int yynrhs = yyr2[yyrule];
|
|
int yyi;
|
|
YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
|
|
yyrule - 1, yylno);
|
|
/* The symbols being reduced. */
|
|
for (yyi = 0; yyi < yynrhs; yyi++)
|
|
{
|
|
YYFPRINTF (stderr, " $%d = ", yyi + 1);
|
|
yy_symbol_print (stderr,
|
|
YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
|
|
&yyvsp[(yyi + 1) - (yynrhs)],
|
|
&(yylsp[(yyi + 1) - (yynrhs)]), p);
|
|
YYFPRINTF (stderr, "\n");
|
|
}
|
|
}
|
|
|
|
# define YY_REDUCE_PRINT(Rule, p) \
|
|
do { \
|
|
if (yydebug) \
|
|
yy_reduce_print (yyssp, yyvsp, yylsp, Rule, p); \
|
|
} while (0)
|
|
|
|
/* Nonzero means print parse trace. It is left uninitialized so that
|
|
multiple parsers can coexist. */
|
|
#ifndef yydebug
|
|
int yydebug;
|
|
#endif
|
|
#else /* !YYDEBUG */
|
|
# define YYDPRINTF(Args) ((void) 0)
|
|
# define YY_SYMBOL_PRINT(Title, Kind, Value, Location, p)
|
|
# define YY_STACK_PRINT(Bottom, Top, p)
|
|
# define YY_REDUCE_PRINT(Rule, p)
|
|
#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
|
|
|
|
|
|
/* Context of a parse error. */
|
|
typedef struct
|
|
{
|
|
yy_state_t *yyssp;
|
|
yysymbol_kind_t yytoken;
|
|
YYLTYPE *yylloc;
|
|
} yypcontext_t;
|
|
|
|
/* Put in YYARG at most YYARGN of the expected tokens given the
|
|
current YYCTX, and return the number of tokens stored in YYARG. If
|
|
YYARG is null, return the number of expected tokens (guaranteed to
|
|
be less than YYNTOKENS). Return YYENOMEM on memory exhaustion.
|
|
Return 0 if there are more than YYARGN expected tokens, yet fill
|
|
YYARG up to YYARGN. */
|
|
static int
|
|
yypcontext_expected_tokens (const yypcontext_t *yyctx,
|
|
yysymbol_kind_t yyarg[], int yyargn)
|
|
{
|
|
/* Actual size of YYARG. */
|
|
int yycount = 0;
|
|
int yyn = yypact[+*yyctx->yyssp];
|
|
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 != YYSYMBOL_YYerror
|
|
&& !yytable_value_is_error (yytable[yyx + yyn]))
|
|
{
|
|
if (!yyarg)
|
|
++yycount;
|
|
else if (yycount == yyargn)
|
|
return 0;
|
|
else
|
|
yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx);
|
|
}
|
|
}
|
|
if (yyarg && yycount == 0 && 0 < yyargn)
|
|
yyarg[0] = YYSYMBOL_YYEMPTY;
|
|
return yycount;
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifndef yystrlen
|
|
# if defined __GLIBC__ && defined _STRING_H
|
|
# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
|
|
# else
|
|
/* Return the length of YYSTR. */
|
|
static YYPTRDIFF_T
|
|
yystrlen (const char *yystr)
|
|
{
|
|
YYPTRDIFF_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. */
|
|
static char *
|
|
yystpcpy (char *yydest, const char *yysrc)
|
|
{
|
|
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 YYPTRDIFF_T
|
|
yytnamerr (char *yyres, const char *yystr)
|
|
{
|
|
if (*yystr == '"')
|
|
{
|
|
YYPTRDIFF_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;
|
|
else
|
|
goto append;
|
|
|
|
append:
|
|
default:
|
|
if (yyres)
|
|
yyres[yyn] = *yyp;
|
|
yyn++;
|
|
break;
|
|
|
|
case '"':
|
|
if (yyres)
|
|
yyres[yyn] = '\0';
|
|
return yyn;
|
|
}
|
|
do_not_strip_quotes: ;
|
|
}
|
|
|
|
if (yyres)
|
|
return yystpcpy (yyres, yystr) - yyres;
|
|
else
|
|
return yystrlen (yystr);
|
|
}
|
|
#endif
|
|
|
|
|
|
static int
|
|
yy_syntax_error_arguments (const yypcontext_t *yyctx,
|
|
yysymbol_kind_t yyarg[], int yyargn)
|
|
{
|
|
/* Actual size of YYARG. */
|
|
int yycount = 0;
|
|
/* There are many possibilities here to consider:
|
|
- 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 (yyctx->yytoken != YYSYMBOL_YYEMPTY)
|
|
{
|
|
int yyn;
|
|
if (yyarg)
|
|
yyarg[yycount] = yyctx->yytoken;
|
|
++yycount;
|
|
yyn = yypcontext_expected_tokens (yyctx,
|
|
yyarg ? yyarg + 1 : yyarg, yyargn - 1);
|
|
if (yyn == YYENOMEM)
|
|
return YYENOMEM;
|
|
else
|
|
yycount += yyn;
|
|
}
|
|
return yycount;
|
|
}
|
|
|
|
/* 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 YYENOMEM if the
|
|
required number of bytes is too large to store. */
|
|
static int
|
|
yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
|
|
const yypcontext_t *yyctx, parser_state *p)
|
|
{
|
|
enum { YYARGS_MAX = 5 };
|
|
/* Internationalized format string. */
|
|
const char *yyformat = YY_NULLPTR;
|
|
/* Arguments of yyformat: reported tokens (one for the "unexpected",
|
|
one per "expected"). */
|
|
yysymbol_kind_t yyarg[YYARGS_MAX];
|
|
/* Cumulated lengths of YYARG. */
|
|
YYPTRDIFF_T yysize = 0;
|
|
|
|
/* Actual size of YYARG. */
|
|
int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX);
|
|
if (yycount == YYENOMEM)
|
|
return YYENOMEM;
|
|
|
|
switch (yycount)
|
|
{
|
|
#define YYCASE_(N, S) \
|
|
case N: \
|
|
yyformat = S; \
|
|
break
|
|
default: /* Avoid compiler warnings. */
|
|
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_
|
|
}
|
|
|
|
/* Compute error message size. Don't count the "%s"s, but reserve
|
|
room for the terminator. */
|
|
yysize = yystrlen (yyformat) - 2 * yycount + 1;
|
|
{
|
|
int yyi;
|
|
for (yyi = 0; yyi < yycount; ++yyi)
|
|
{
|
|
YYPTRDIFF_T yysize1
|
|
= yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]);
|
|
if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
|
|
yysize = yysize1;
|
|
else
|
|
return YYENOMEM;
|
|
}
|
|
}
|
|
|
|
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, yytname[yyarg[yyi++]]);
|
|
yyformat += 2;
|
|
}
|
|
else
|
|
{
|
|
++yyp;
|
|
++yyformat;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*-----------------------------------------------.
|
|
| Release the memory associated to this symbol. |
|
|
`-----------------------------------------------*/
|
|
|
|
static void
|
|
yydestruct (const char *yymsg,
|
|
yysymbol_kind_t yykind, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, parser_state *p)
|
|
{
|
|
YY_USE (yyvaluep);
|
|
YY_USE (yylocationp);
|
|
YY_USE (p);
|
|
if (!yymsg)
|
|
yymsg = "Deleting";
|
|
YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp, p);
|
|
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
switch (yykind)
|
|
{
|
|
default:
|
|
break;
|
|
}
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_END
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*----------.
|
|
| yyparse. |
|
|
`----------*/
|
|
|
|
int
|
|
yyparse (parser_state *p)
|
|
{
|
|
/* Lookahead token kind. */
|
|
int yychar;
|
|
|
|
|
|
/* The semantic value of the lookahead symbol. */
|
|
/* Default value used for initialization, for pacifying older GCCs
|
|
or non-GCC compilers. */
|
|
#ifdef __cplusplus
|
|
static const YYSTYPE yyval_default = {};
|
|
(void) yyval_default;
|
|
#else
|
|
YY_INITIAL_VALUE (static const YYSTYPE yyval_default;)
|
|
#endif
|
|
YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
|
|
|
|
/* Location data for the lookahead symbol. */
|
|
static const YYLTYPE yyloc_default
|
|
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
|
|
= { 1, 1, 1, 1 }
|
|
# endif
|
|
;
|
|
YYLTYPE yylloc = yyloc_default;
|
|
|
|
/* Number of syntax errors so far. */
|
|
int yynerrs = 0;
|
|
YY_USE (yynerrs); /* Silence compiler warning. */
|
|
|
|
yy_state_fast_t yystate = 0;
|
|
/* Number of tokens to shift before error messages enabled. */
|
|
int yyerrstatus = 0;
|
|
|
|
/* Refer to the stacks through separate pointers, to allow yyoverflow
|
|
to reallocate them elsewhere. */
|
|
|
|
/* Their size. */
|
|
YYPTRDIFF_T yystacksize = YYINITDEPTH;
|
|
|
|
/* The state stack: array, bottom, top. */
|
|
yy_state_t yyssa[YYINITDEPTH];
|
|
yy_state_t *yyss = yyssa;
|
|
yy_state_t *yyssp = yyss;
|
|
|
|
/* The semantic value stack: array, bottom, top. */
|
|
YYSTYPE yyvsa[YYINITDEPTH];
|
|
YYSTYPE *yyvs = yyvsa;
|
|
YYSTYPE *yyvsp = yyvs;
|
|
|
|
/* The location stack: array, bottom, top. */
|
|
YYLTYPE yylsa[YYINITDEPTH];
|
|
YYLTYPE *yyls = yylsa;
|
|
YYLTYPE *yylsp = yyls;
|
|
|
|
int yyn;
|
|
/* The return value of yyparse. */
|
|
int yyresult;
|
|
/* Lookahead symbol kind. */
|
|
yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
|
|
/* The variables used to return semantic value and location from the
|
|
action routines. */
|
|
YYSTYPE yyval;
|
|
YYLTYPE yyloc;
|
|
|
|
/* The locations where the error started and ended. */
|
|
YYLTYPE yyerror_range[3];
|
|
|
|
/* Buffer for error messages, and its allocated size. */
|
|
char yymsgbuf[128];
|
|
char *yymsg = yymsgbuf;
|
|
YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
|
|
|
|
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
|
|
|
|
/* The number of symbols on the RHS of the reduced rule.
|
|
Keep to zero when no symbol should be popped. */
|
|
int yylen = 0;
|
|
|
|
YYDPRINTF ((stderr, "Starting parse\n"));
|
|
|
|
yychar = YYEMPTY; /* Cause a token to be read. */
|
|
|
|
|
|
|
|
#line 7356 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
|
|
yylsp[0] = yylloc;
|
|
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 -- set current state (the top of the stack) to yystate. |
|
|
`--------------------------------------------------------------------*/
|
|
yysetstate:
|
|
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
|
|
YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
|
|
YY_IGNORE_USELESS_CAST_BEGIN
|
|
*yyssp = YY_CAST (yy_state_t, yystate);
|
|
YY_IGNORE_USELESS_CAST_END
|
|
YY_STACK_PRINT (yyss, yyssp, p);
|
|
|
|
if (yyss + yystacksize - 1 <= yyssp)
|
|
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
|
|
YYNOMEM;
|
|
#else
|
|
{
|
|
/* Get the current used size of the three stacks, in elements. */
|
|
YYPTRDIFF_T yysize = yyssp - yyss + 1;
|
|
|
|
# if defined 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. */
|
|
yy_state_t *yyss1 = yyss;
|
|
YYSTYPE *yyvs1 = yyvs;
|
|
YYLTYPE *yyls1 = yyls;
|
|
|
|
/* 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 * YYSIZEOF (*yyssp),
|
|
&yyvs1, yysize * YYSIZEOF (*yyvsp),
|
|
&yyls1, yysize * YYSIZEOF (*yylsp),
|
|
&yystacksize);
|
|
yyss = yyss1;
|
|
yyvs = yyvs1;
|
|
yyls = yyls1;
|
|
}
|
|
# else /* defined YYSTACK_RELOCATE */
|
|
/* Extend the stack our own way. */
|
|
if (YYMAXDEPTH <= yystacksize)
|
|
YYNOMEM;
|
|
yystacksize *= 2;
|
|
if (YYMAXDEPTH < yystacksize)
|
|
yystacksize = YYMAXDEPTH;
|
|
|
|
{
|
|
yy_state_t *yyss1 = yyss;
|
|
union yyalloc *yyptr =
|
|
YY_CAST (union yyalloc *,
|
|
YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
|
|
if (! yyptr)
|
|
YYNOMEM;
|
|
YYSTACK_RELOCATE (yyss_alloc, yyss);
|
|
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
|
|
YYSTACK_RELOCATE (yyls_alloc, yyls);
|
|
# undef YYSTACK_RELOCATE
|
|
if (yyss1 != yyssa)
|
|
YYSTACK_FREE (yyss1);
|
|
}
|
|
# endif
|
|
|
|
yyssp = yyss + yysize - 1;
|
|
yyvsp = yyvs + yysize - 1;
|
|
yylsp = yyls + yysize - 1;
|
|
|
|
YY_IGNORE_USELESS_CAST_BEGIN
|
|
YYDPRINTF ((stderr, "Stack size increased to %ld\n",
|
|
YY_CAST (long, yystacksize)));
|
|
YY_IGNORE_USELESS_CAST_END
|
|
|
|
if (yyss + yystacksize - 1 <= yyssp)
|
|
YYABORT;
|
|
}
|
|
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
|
|
|
|
|
|
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 empty, or end-of-input, or a valid lookahead. */
|
|
if (yychar == YYEMPTY)
|
|
{
|
|
YYDPRINTF ((stderr, "Reading a token\n"));
|
|
yychar = yylex (&yylval, &yylloc, p);
|
|
}
|
|
|
|
if (yychar <= YYEOF)
|
|
{
|
|
yychar = YYEOF;
|
|
yytoken = YYSYMBOL_YYEOF;
|
|
YYDPRINTF ((stderr, "Now at end of input.\n"));
|
|
}
|
|
else if (yychar == YYerror)
|
|
{
|
|
/* The scanner already issued an error message, process directly
|
|
to error recovery. But do not keep the error token as
|
|
lookahead, it is too special and may lead us to an endless
|
|
loop in error recovery. */
|
|
yychar = YYUNDEF;
|
|
yytoken = YYSYMBOL_YYerror;
|
|
yyerror_range[1] = yylloc;
|
|
goto yyerrlab1;
|
|
}
|
|
else
|
|
{
|
|
yytoken = YYTRANSLATE (yychar);
|
|
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc, p);
|
|
}
|
|
|
|
/* 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, p);
|
|
yystate = yyn;
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
*++yyvsp = yylval;
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_END
|
|
*++yylsp = yylloc;
|
|
|
|
|
|
/* Discard the shifted token. */
|
|
yychar = YYEMPTY;
|
|
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];
|
|
|
|
|
|
/* Default location. */
|
|
YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
|
|
yyerror_range[1] = yyloc;
|
|
YY_REDUCE_PRINT (yyn, p);
|
|
switch (yyn)
|
|
{
|
|
case 2: /* $@1: %empty */
|
|
#line 2493 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->lstate = EXPR_BEG;
|
|
if (!p->locals) p->locals = cons(0,0);
|
|
}
|
|
#line 7574 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 3: /* program: $@1 top_compstmt */
|
|
#line 2498 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->tree = new_scope(p, (yyvsp[0].nd));
|
|
}
|
|
#line 7582 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 4: /* top_compstmt: top_stmts opt_terms */
|
|
#line 2504 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 7590 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 5: /* top_stmts: none */
|
|
#line 2510 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_stmts(p, 0);
|
|
}
|
|
#line 7598 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 6: /* top_stmts: top_stmt */
|
|
#line 2514 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_stmts(p, (yyvsp[0].nd));
|
|
}
|
|
#line 7606 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 7: /* top_stmts: top_stmts terms top_stmt */
|
|
#line 2518 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd)));
|
|
}
|
|
#line 7614 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 8: /* top_stmts: error top_stmt */
|
|
#line 2522 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_stmts(p, 0);
|
|
}
|
|
#line 7622 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 10: /* @2: %empty */
|
|
#line 2529 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = local_switch(p);
|
|
nvars_block(p);
|
|
}
|
|
#line 7631 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 11: /* top_stmt: "'BEGIN'" @2 '{' top_compstmt '}' */
|
|
#line 2534 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[-4]), p, "BEGIN not supported");
|
|
local_resume(p, (yyvsp[-3].nd));
|
|
nvars_unnest(p);
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 7642 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 12: /* bodystmt: compstmt opt_rescue opt_else opt_ensure */
|
|
#line 2546 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
if ((yyvsp[-2].nd)) {
|
|
(yyval.nd) = new_rescue(p, (yyvsp[-3].nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
|
|
}
|
|
else if ((yyvsp[-1].nd)) {
|
|
yywarning(p, "else without rescue is useless");
|
|
(yyval.nd) = push((yyvsp[-3].nd), (yyvsp[-1].nd));
|
|
}
|
|
else {
|
|
(yyval.nd) = (yyvsp[-3].nd);
|
|
}
|
|
if ((yyvsp[0].nd)) {
|
|
if ((yyval.nd)) {
|
|
(yyval.nd) = new_ensure(p, (yyval.nd), (yyvsp[0].nd));
|
|
}
|
|
else {
|
|
(yyval.nd) = push((yyvsp[0].nd), new_nil(p));
|
|
}
|
|
}
|
|
}
|
|
#line 7667 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 13: /* compstmt: stmts opt_terms */
|
|
#line 2569 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 7675 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 14: /* stmts: none */
|
|
#line 2575 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_stmts(p, 0);
|
|
}
|
|
#line 7683 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 15: /* stmts: stmt */
|
|
#line 2579 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_stmts(p, (yyvsp[0].nd));
|
|
}
|
|
#line 7691 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 16: /* stmts: stmts terms stmt */
|
|
#line 2583 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
/* Update the cons-list inside the existing variable-sized node */
|
|
STMTS_NODE_STMTS((yyvsp[-2].nd)->cdr) = push(STMTS_NODE_STMTS((yyvsp[-2].nd)->cdr), newline_node((yyvsp[0].nd)));
|
|
(yyval.nd) = (yyvsp[-2].nd);
|
|
}
|
|
#line 7701 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 17: /* stmts: error stmt */
|
|
#line 2589 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_stmts(p, (yyvsp[0].nd));
|
|
}
|
|
#line 7709 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 18: /* $@3: %empty */
|
|
#line 2594 "mrbgems/mruby-compiler/core/parse.y"
|
|
{p->lstate = EXPR_FNAME;}
|
|
#line 7715 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 19: /* stmt: "'alias'" fsym $@3 fsym */
|
|
#line 2595 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_alias(p, (yyvsp[-2].id), (yyvsp[0].id));
|
|
}
|
|
#line 7723 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 20: /* stmt: "'undef'" undef_list */
|
|
#line 2599 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_undef(p, (yyvsp[0].nd));
|
|
}
|
|
#line 7731 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 21: /* stmt: stmt "'if' modifier" expr_value */
|
|
#line 2603 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_if(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0);
|
|
}
|
|
#line 7739 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 22: /* stmt: stmt "'unless' modifier" expr_value */
|
|
#line 2607 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_if(p, cond((yyvsp[0].nd)), 0, (yyvsp[-2].nd));
|
|
}
|
|
#line 7747 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 23: /* stmt: stmt "'while' modifier" expr_value */
|
|
#line 2611 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
if ((yyvsp[-2].nd) && node_type_p((yyvsp[-2].nd), NODE_BEGIN)) {
|
|
(yyval.nd) = new_while_mod(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
|
|
}
|
|
else {
|
|
(yyval.nd) = new_while(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
|
|
}
|
|
}
|
|
#line 7760 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 24: /* stmt: stmt "'until' modifier" expr_value */
|
|
#line 2620 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
if ((yyvsp[-2].nd) && node_type_p((yyvsp[-2].nd), NODE_BEGIN)) {
|
|
(yyval.nd) = new_until_mod(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
|
|
}
|
|
else {
|
|
(yyval.nd) = new_until(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
|
|
}
|
|
}
|
|
#line 7773 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 25: /* stmt: stmt "'rescue' modifier" stmt */
|
|
#line 2629 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 7781 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 26: /* stmt: "'END'" '{' compstmt '}' */
|
|
#line 2633 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[-3]), p, "END not supported");
|
|
(yyval.nd) = new_postexe(p, (yyvsp[-1].nd));
|
|
}
|
|
#line 7790 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 28: /* stmt: mlhs '=' command_call */
|
|
#line 2639 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 7798 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 29: /* stmt: lhs '=' mrhs */
|
|
#line 2643 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_asgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd)));
|
|
}
|
|
#line 7806 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 30: /* stmt: mlhs '=' arg */
|
|
#line 2647 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 7814 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 31: /* stmt: mlhs '=' mrhs */
|
|
#line 2651 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_masgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd)));
|
|
}
|
|
#line 7822 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 32: /* stmt: arg "=>" "local variable or method" */
|
|
#line 2655 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
node *lhs = new_xvar(p, (yyvsp[0].id), NODE_LVAR);
|
|
assignable(p, lhs);
|
|
(yyval.nd) = new_asgn(p, lhs, (yyvsp[-2].nd));
|
|
}
|
|
#line 7832 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 34: /* command_asgn: lhs '=' command_rhs */
|
|
#line 2664 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 7840 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 35: /* command_asgn: var_lhs tOP_ASGN command_rhs */
|
|
#line 2668 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 7848 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 36: /* command_asgn: primary_value '[' opt_call_args ']' tOP_ASGN command_rhs */
|
|
#line 2672 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_op(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 7856 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 37: /* command_asgn: primary_value call_op "local variable or method" tOP_ASGN command_rhs */
|
|
#line 2676 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 7864 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 38: /* command_asgn: primary_value call_op "constant" tOP_ASGN command_rhs */
|
|
#line 2680 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 7872 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 39: /* command_asgn: primary_value "::" "constant" tOP_ASGN command_call */
|
|
#line 2684 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[-4]), p, "constant re-assignment");
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 7881 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 40: /* command_asgn: primary_value "::" "local variable or method" tOP_ASGN command_rhs */
|
|
#line 2689 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, tCOLON2), (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 7889 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 41: /* command_asgn: defn_head f_opt_arglist_paren '=' command */
|
|
#line 2693 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-3].nd);
|
|
endless_method_name(p, (yyvsp[-3].nd));
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
nvars_unnest(p);
|
|
p->in_def--;
|
|
}
|
|
#line 7902 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 42: /* command_asgn: defn_head f_opt_arglist_paren '=' command "'rescue' modifier" arg */
|
|
#line 2702 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-5].nd);
|
|
endless_method_name(p, (yyvsp[-5].nd));
|
|
void_expr_error(p, (yyvsp[-2].nd));
|
|
defn_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
|
|
nvars_unnest(p);
|
|
p->in_def--;
|
|
}
|
|
#line 7915 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 43: /* command_asgn: defs_head f_opt_arglist_paren '=' command */
|
|
#line 2711 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-3].nd);
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
nvars_unnest(p);
|
|
p->in_def--;
|
|
p->in_single--;
|
|
}
|
|
#line 7928 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 44: /* command_asgn: defs_head f_opt_arglist_paren '=' command "'rescue' modifier" arg */
|
|
#line 2720 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-5].nd);
|
|
void_expr_error(p, (yyvsp[-2].nd));
|
|
defs_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
|
|
nvars_unnest(p);
|
|
p->in_def--;
|
|
p->in_single--;
|
|
}
|
|
#line 7941 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 45: /* command_asgn: backref tOP_ASGN command_rhs */
|
|
#line 2729 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
backref_error(p, (yyvsp[-2].nd));
|
|
(yyval.nd) = new_stmts(p, 0);
|
|
}
|
|
#line 7950 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 47: /* command_rhs: command_call "'rescue' modifier" stmt */
|
|
#line 2737 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 7958 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 50: /* expr: expr "'and'" expr */
|
|
#line 2745 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 7966 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 51: /* expr: expr "'or'" expr */
|
|
#line 2749 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 7974 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 52: /* expr: "'not'" opt_nl expr */
|
|
#line 2753 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
|
|
}
|
|
#line 7982 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 53: /* expr: '!' command_call */
|
|
#line 2757 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
|
|
}
|
|
#line 7990 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 55: /* defn_head: "'def'" fname */
|
|
#line 2764 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_def(p, (yyvsp[0].id), int_to_node(p->cmdarg_stack), local_switch(p));
|
|
p->cmdarg_stack = 0;
|
|
p->in_def++;
|
|
nvars_block(p);
|
|
}
|
|
#line 8001 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 56: /* $@4: %empty */
|
|
#line 2773 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->lstate = EXPR_FNAME;
|
|
}
|
|
#line 8009 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 57: /* defs_head: "'def'" singleton dot_or_colon $@4 fname */
|
|
#line 2777 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_sdef(p, (yyvsp[-3].nd), (yyvsp[0].id), int_to_node(p->cmdarg_stack), local_switch(p));
|
|
p->cmdarg_stack = 0;
|
|
p->in_def++;
|
|
p->in_single++;
|
|
nvars_block(p);
|
|
p->lstate = EXPR_ENDFN; /* force for args */
|
|
}
|
|
#line 8022 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 58: /* expr_value: expr */
|
|
#line 2788 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
if (!(yyvsp[0].nd)) (yyval.nd) = new_nil(p);
|
|
else {
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
}
|
|
#line 8033 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 62: /* block_command: block_call call_op2 operation2 command_args */
|
|
#line 2802 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
|
|
}
|
|
#line 8041 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 63: /* $@5: %empty */
|
|
#line 2808 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_nest(p);
|
|
nvars_nest(p);
|
|
}
|
|
#line 8050 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 64: /* cmd_brace_block: "{" $@5 opt_block_param compstmt '}' */
|
|
#line 2815 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_block(p, (yyvsp[-2].nd), (yyvsp[-1].nd));
|
|
local_unnest(p);
|
|
nvars_unnest(p);
|
|
}
|
|
#line 8060 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 65: /* command: operation command_args */
|
|
#line 2823 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 8068 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 66: /* command: operation command_args cmd_brace_block */
|
|
#line 2827 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
(yyval.nd) = new_fcall(p, (yyvsp[-2].id), (yyvsp[-1].nd));
|
|
}
|
|
#line 8077 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 67: /* command: primary_value call_op operation2 command_args */
|
|
#line 2832 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
|
|
}
|
|
#line 8085 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 68: /* command: primary_value call_op operation2 command_args cmd_brace_block */
|
|
#line 2836 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
(yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
|
|
}
|
|
#line 8094 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 69: /* command: primary_value "::" operation2 command_args */
|
|
#line 2841 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2);
|
|
}
|
|
#line 8102 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 70: /* command: primary_value "::" operation2 command_args cmd_brace_block */
|
|
#line 2845 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
(yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), tCOLON2);
|
|
}
|
|
#line 8111 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 71: /* command: "'super'" command_args */
|
|
#line 2850 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_super(p, (yyvsp[0].nd));
|
|
}
|
|
#line 8119 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 72: /* command: "'yield'" command_args */
|
|
#line 2854 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_yield(p, (yyvsp[0].nd));
|
|
}
|
|
#line 8127 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 73: /* command: "'return'" call_args */
|
|
#line 2858 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_return(p, ret_args(p, (yyvsp[0].nd)));
|
|
}
|
|
#line 8135 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 74: /* command: "'break'" call_args */
|
|
#line 2862 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_break(p, ret_args(p, (yyvsp[0].nd)));
|
|
}
|
|
#line 8143 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 75: /* command: "'next'" call_args */
|
|
#line 2866 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_next(p, ret_args(p, (yyvsp[0].nd)));
|
|
}
|
|
#line 8151 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 76: /* mlhs: mlhs_basic */
|
|
#line 2872 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 8159 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 77: /* mlhs: tLPAREN mlhs_inner rparen */
|
|
#line 2876 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 8167 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 79: /* mlhs_inner: tLPAREN mlhs_inner rparen */
|
|
#line 2883 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 8175 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 80: /* mlhs_basic: mlhs_list */
|
|
#line 2889 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 8183 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 81: /* mlhs_basic: mlhs_list mlhs_item */
|
|
#line 2893 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1(push((yyvsp[-1].nd),(yyvsp[0].nd)));
|
|
}
|
|
#line 8191 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 82: /* mlhs_basic: mlhs_list "*" mlhs_node */
|
|
#line 2897 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list2((yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 8199 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 83: /* mlhs_basic: mlhs_list "*" mlhs_node ',' mlhs_post */
|
|
#line 2901 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list3((yyvsp[-4].nd), (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 8207 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 84: /* mlhs_basic: mlhs_list "*" */
|
|
#line 2905 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list2((yyvsp[-1].nd), new_nil(p));
|
|
}
|
|
#line 8215 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 85: /* mlhs_basic: mlhs_list "*" ',' mlhs_post */
|
|
#line 2909 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list3((yyvsp[-3].nd), new_nil(p), (yyvsp[0].nd));
|
|
}
|
|
#line 8223 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 86: /* mlhs_basic: "*" mlhs_node */
|
|
#line 2913 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list2(0, (yyvsp[0].nd));
|
|
}
|
|
#line 8231 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 87: /* mlhs_basic: "*" mlhs_node ',' mlhs_post */
|
|
#line 2917 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list3(0, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 8239 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 88: /* mlhs_basic: "*" */
|
|
#line 2921 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list2(0, new_nil(p));
|
|
}
|
|
#line 8247 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 89: /* mlhs_basic: "*" ',' mlhs_post */
|
|
#line 2925 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list3(0, new_nil(p), (yyvsp[0].nd));
|
|
}
|
|
#line 8255 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 91: /* mlhs_item: tLPAREN mlhs_inner rparen */
|
|
#line 2932 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_masgn(p, (yyvsp[-1].nd), NULL);
|
|
}
|
|
#line 8263 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 92: /* mlhs_list: mlhs_item ',' */
|
|
#line 2938 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1((yyvsp[-1].nd));
|
|
}
|
|
#line 8271 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 93: /* mlhs_list: mlhs_list mlhs_item ',' */
|
|
#line 2942 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[-1].nd));
|
|
}
|
|
#line 8279 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 94: /* mlhs_post: mlhs_item */
|
|
#line 2948 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 8287 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 95: /* mlhs_post: mlhs_list mlhs_item */
|
|
#line 2952 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 8295 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 96: /* mlhs_node: variable */
|
|
#line 2958 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
assignable(p, (yyvsp[0].nd));
|
|
}
|
|
#line 8303 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 97: /* mlhs_node: primary_value '[' opt_call_args ']' */
|
|
#line 2962 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.');
|
|
}
|
|
#line 8311 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 98: /* mlhs_node: primary_value call_op "local variable or method" */
|
|
#line 2966 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
|
|
}
|
|
#line 8319 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 99: /* mlhs_node: primary_value "::" "local variable or method" */
|
|
#line 2970 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
|
|
}
|
|
#line 8327 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 100: /* mlhs_node: primary_value call_op "constant" */
|
|
#line 2974 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
|
|
}
|
|
#line 8335 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 101: /* mlhs_node: primary_value "::" "constant" */
|
|
#line 2978 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
if (p->in_def || p->in_single)
|
|
yyerror(&(yylsp[-2]), p, "dynamic constant assignment");
|
|
(yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
|
|
}
|
|
#line 8345 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 102: /* mlhs_node: tCOLON3 "constant" */
|
|
#line 2984 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
if (p->in_def || p->in_single)
|
|
yyerror(&(yylsp[-1]), p, "dynamic constant assignment");
|
|
(yyval.nd) = new_colon3(p, (yyvsp[0].id));
|
|
}
|
|
#line 8355 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 103: /* mlhs_node: backref */
|
|
#line 2990 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
backref_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 8364 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 104: /* lhs: variable */
|
|
#line 2997 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
assignable(p, (yyvsp[0].nd));
|
|
}
|
|
#line 8372 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 105: /* lhs: primary_value '[' opt_call_args ']' */
|
|
#line 3001 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.');
|
|
}
|
|
#line 8380 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 106: /* lhs: primary_value call_op "local variable or method" */
|
|
#line 3005 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
|
|
}
|
|
#line 8388 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 107: /* lhs: primary_value "::" "local variable or method" */
|
|
#line 3009 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
|
|
}
|
|
#line 8396 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 108: /* lhs: primary_value call_op "constant" */
|
|
#line 3013 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
|
|
}
|
|
#line 8404 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 109: /* lhs: primary_value "::" "constant" */
|
|
#line 3017 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
if (p->in_def || p->in_single)
|
|
yyerror(&(yylsp[-2]), p, "dynamic constant assignment");
|
|
(yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
|
|
}
|
|
#line 8414 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 110: /* lhs: tCOLON3 "constant" */
|
|
#line 3023 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
if (p->in_def || p->in_single)
|
|
yyerror(&(yylsp[-1]), p, "dynamic constant assignment");
|
|
(yyval.nd) = new_colon3(p, (yyvsp[0].id));
|
|
}
|
|
#line 8424 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 111: /* lhs: backref */
|
|
#line 3029 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
backref_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 8433 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 112: /* lhs: "numbered parameter" */
|
|
#line 3034 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[0]), p, "can't assign to numbered parameter");
|
|
}
|
|
#line 8441 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 113: /* cname: "local variable or method" */
|
|
#line 3040 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[0]), p, "class/module name must be CONSTANT");
|
|
}
|
|
#line 8449 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 115: /* cpath: tCOLON3 cname */
|
|
#line 3047 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = cons(int_to_node(1), sym_to_node((yyvsp[0].id)));
|
|
}
|
|
#line 8457 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 116: /* cpath: cname */
|
|
#line 3051 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = cons(int_to_node(0), sym_to_node((yyvsp[0].id)));
|
|
}
|
|
#line 8465 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 117: /* cpath: primary_value "::" cname */
|
|
#line 3055 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[-2].nd));
|
|
(yyval.nd) = cons((yyvsp[-2].nd), sym_to_node((yyvsp[0].id)));
|
|
}
|
|
#line 8474 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 121: /* fname: op */
|
|
#line 3065 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->lstate = EXPR_ENDFN;
|
|
(yyval.id) = (yyvsp[0].id);
|
|
}
|
|
#line 8483 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 122: /* fname: reswords */
|
|
#line 3070 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->lstate = EXPR_ENDFN;
|
|
(yyval.id) = (yyvsp[0].id);
|
|
}
|
|
#line 8492 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 125: /* undef_list: fsym */
|
|
#line 3081 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = cons(sym_to_node((yyvsp[0].id)), 0);
|
|
}
|
|
#line 8500 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 126: /* $@6: %empty */
|
|
#line 3084 "mrbgems/mruby-compiler/core/parse.y"
|
|
{p->lstate = EXPR_FNAME;}
|
|
#line 8506 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 127: /* undef_list: undef_list ',' $@6 fsym */
|
|
#line 3085 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-3].nd), sym_to_node((yyvsp[0].id)));
|
|
}
|
|
#line 8514 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 128: /* op: '|' */
|
|
#line 3090 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(or); }
|
|
#line 8520 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 129: /* op: '^' */
|
|
#line 3091 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(xor); }
|
|
#line 8526 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 130: /* op: '&' */
|
|
#line 3092 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(and); }
|
|
#line 8532 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 131: /* op: "<=>" */
|
|
#line 3093 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(cmp); }
|
|
#line 8538 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 132: /* op: "==" */
|
|
#line 3094 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(eq); }
|
|
#line 8544 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 133: /* op: "===" */
|
|
#line 3095 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(eqq); }
|
|
#line 8550 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 134: /* op: "=~" */
|
|
#line 3096 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(match); }
|
|
#line 8556 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 135: /* op: "!~" */
|
|
#line 3097 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(nmatch); }
|
|
#line 8562 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 136: /* op: '>' */
|
|
#line 3098 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(gt); }
|
|
#line 8568 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 137: /* op: ">=" */
|
|
#line 3099 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(ge); }
|
|
#line 8574 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 138: /* op: '<' */
|
|
#line 3100 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(lt); }
|
|
#line 8580 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 139: /* op: "<=" */
|
|
#line 3101 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(le); }
|
|
#line 8586 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 140: /* op: "!=" */
|
|
#line 3102 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(neq); }
|
|
#line 8592 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 141: /* op: "<<" */
|
|
#line 3103 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(lshift); }
|
|
#line 8598 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 142: /* op: ">>" */
|
|
#line 3104 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(rshift); }
|
|
#line 8604 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 143: /* op: '+' */
|
|
#line 3105 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(add); }
|
|
#line 8610 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 144: /* op: '-' */
|
|
#line 3106 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(sub); }
|
|
#line 8616 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 145: /* op: '*' */
|
|
#line 3107 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(mul); }
|
|
#line 8622 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 146: /* op: "*" */
|
|
#line 3108 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(mul); }
|
|
#line 8628 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 147: /* op: '/' */
|
|
#line 3109 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(div); }
|
|
#line 8634 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 148: /* op: '%' */
|
|
#line 3110 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(mod); }
|
|
#line 8640 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 149: /* op: tPOW */
|
|
#line 3111 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(pow); }
|
|
#line 8646 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 150: /* op: "**" */
|
|
#line 3112 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(pow); }
|
|
#line 8652 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 151: /* op: '!' */
|
|
#line 3113 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(not); }
|
|
#line 8658 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 152: /* op: '~' */
|
|
#line 3114 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(neg); }
|
|
#line 8664 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 153: /* op: "unary plus" */
|
|
#line 3115 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(plus); }
|
|
#line 8670 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 154: /* op: "unary minus" */
|
|
#line 3116 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(minus); }
|
|
#line 8676 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 155: /* op: tAREF */
|
|
#line 3117 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(aref); }
|
|
#line 8682 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 156: /* op: tASET */
|
|
#line 3118 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(aset); }
|
|
#line 8688 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 157: /* op: '`' */
|
|
#line 3119 "mrbgems/mruby-compiler/core/parse.y"
|
|
{ (yyval.id) = intern_op(tick); }
|
|
#line 8694 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 198: /* arg: lhs '=' arg_rhs */
|
|
#line 3137 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 8702 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 199: /* arg: var_lhs tOP_ASGN arg_rhs */
|
|
#line 3141 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 8710 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 200: /* arg: primary_value '[' opt_call_args ']' tOP_ASGN arg_rhs */
|
|
#line 3145 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_op(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 8718 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 201: /* arg: primary_value call_op "local variable or method" tOP_ASGN arg_rhs */
|
|
#line 3149 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 8726 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 202: /* arg: primary_value call_op "constant" tOP_ASGN arg_rhs */
|
|
#line 3153 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 8734 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 203: /* arg: primary_value "::" "local variable or method" tOP_ASGN arg_rhs */
|
|
#line 3157 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, tCOLON2), (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 8742 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 204: /* arg: primary_value "::" "constant" tOP_ASGN arg_rhs */
|
|
#line 3161 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[-4]), p, "constant re-assignment");
|
|
(yyval.nd) = new_stmts(p, 0);
|
|
}
|
|
#line 8751 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 205: /* arg: tCOLON3 "constant" tOP_ASGN arg_rhs */
|
|
#line 3166 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[-3]), p, "constant re-assignment");
|
|
(yyval.nd) = new_stmts(p, 0);
|
|
}
|
|
#line 8760 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 206: /* arg: backref tOP_ASGN arg_rhs */
|
|
#line 3171 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
backref_error(p, (yyvsp[-2].nd));
|
|
(yyval.nd) = new_stmts(p, 0);
|
|
}
|
|
#line 8769 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 207: /* arg: arg ".." arg */
|
|
#line 3176 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_dot2(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 8777 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 208: /* arg: arg ".." */
|
|
#line 3180 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_dot2(p, (yyvsp[-1].nd), new_nil(p));
|
|
}
|
|
#line 8785 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 209: /* arg: tBDOT2 arg */
|
|
#line 3184 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_dot2(p, new_nil(p), (yyvsp[0].nd));
|
|
}
|
|
#line 8793 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 210: /* arg: arg "..." arg */
|
|
#line 3188 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_dot3(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 8801 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 211: /* arg: arg "..." */
|
|
#line 3192 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_dot3(p, (yyvsp[-1].nd), new_nil(p));
|
|
}
|
|
#line 8809 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 212: /* arg: tBDOT3 arg */
|
|
#line 3196 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_dot3(p, new_nil(p), (yyvsp[0].nd));
|
|
}
|
|
#line 8817 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 213: /* arg: arg '+' arg */
|
|
#line 3200 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "+", (yyvsp[0].nd));
|
|
}
|
|
#line 8825 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 214: /* arg: arg '-' arg */
|
|
#line 3204 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "-", (yyvsp[0].nd));
|
|
}
|
|
#line 8833 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 215: /* arg: arg '*' arg */
|
|
#line 3208 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "*", (yyvsp[0].nd));
|
|
}
|
|
#line 8841 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 216: /* arg: arg '/' arg */
|
|
#line 3212 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "/", (yyvsp[0].nd));
|
|
}
|
|
#line 8849 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 217: /* arg: arg '%' arg */
|
|
#line 3216 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "%", (yyvsp[0].nd));
|
|
}
|
|
#line 8857 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 218: /* arg: arg tPOW arg */
|
|
#line 3220 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd));
|
|
}
|
|
#line 8865 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 219: /* arg: tUMINUS_NUM "integer literal" tPOW arg */
|
|
#line 3224 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_negate(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)));
|
|
}
|
|
#line 8873 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 220: /* arg: tUMINUS_NUM "float literal" tPOW arg */
|
|
#line 3228 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_negate(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)));
|
|
}
|
|
#line 8881 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 221: /* arg: "unary plus" arg */
|
|
#line 3232 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_uni_op(p, (yyvsp[0].nd), "+@");
|
|
}
|
|
#line 8889 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 222: /* arg: "unary minus" arg */
|
|
#line 3236 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_negate(p, (yyvsp[0].nd));
|
|
}
|
|
#line 8897 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 223: /* arg: arg '|' arg */
|
|
#line 3240 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "|", (yyvsp[0].nd));
|
|
}
|
|
#line 8905 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 224: /* arg: arg '^' arg */
|
|
#line 3244 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "^", (yyvsp[0].nd));
|
|
}
|
|
#line 8913 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 225: /* arg: arg '&' arg */
|
|
#line 3248 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "&", (yyvsp[0].nd));
|
|
}
|
|
#line 8921 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 226: /* arg: arg "<=>" arg */
|
|
#line 3252 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=>", (yyvsp[0].nd));
|
|
}
|
|
#line 8929 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 227: /* arg: arg '>' arg */
|
|
#line 3256 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">", (yyvsp[0].nd));
|
|
}
|
|
#line 8937 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 228: /* arg: arg ">=" arg */
|
|
#line 3260 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">=", (yyvsp[0].nd));
|
|
}
|
|
#line 8945 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 229: /* arg: arg '<' arg */
|
|
#line 3264 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<", (yyvsp[0].nd));
|
|
}
|
|
#line 8953 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 230: /* arg: arg "<=" arg */
|
|
#line 3268 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=", (yyvsp[0].nd));
|
|
}
|
|
#line 8961 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 231: /* arg: arg "==" arg */
|
|
#line 3272 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "==", (yyvsp[0].nd));
|
|
}
|
|
#line 8969 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 232: /* arg: arg "===" arg */
|
|
#line 3276 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "===", (yyvsp[0].nd));
|
|
}
|
|
#line 8977 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 233: /* arg: arg "!=" arg */
|
|
#line 3280 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!=", (yyvsp[0].nd));
|
|
}
|
|
#line 8985 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 234: /* arg: arg "=~" arg */
|
|
#line 3284 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "=~", (yyvsp[0].nd));
|
|
}
|
|
#line 8993 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 235: /* arg: arg "!~" arg */
|
|
#line 3288 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!~", (yyvsp[0].nd));
|
|
}
|
|
#line 9001 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 236: /* arg: '!' arg */
|
|
#line 3292 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
|
|
}
|
|
#line 9009 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 237: /* arg: '~' arg */
|
|
#line 3296 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "~");
|
|
}
|
|
#line 9017 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 238: /* arg: arg "<<" arg */
|
|
#line 3300 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<<", (yyvsp[0].nd));
|
|
}
|
|
#line 9025 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 239: /* arg: arg ">>" arg */
|
|
#line 3304 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">>", (yyvsp[0].nd));
|
|
}
|
|
#line 9033 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 240: /* arg: arg "&&" arg */
|
|
#line 3308 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 9041 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 241: /* arg: arg "||" arg */
|
|
#line 3312 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 9049 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 242: /* arg: arg '?' arg opt_nl ':' arg */
|
|
#line 3316 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 9057 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 243: /* arg: arg '?' arg opt_nl "label" arg */
|
|
#line 3320 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 9065 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 244: /* arg: defn_head f_opt_arglist_paren '=' arg */
|
|
#line 3324 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-3].nd);
|
|
endless_method_name(p, (yyvsp[-3].nd));
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
nvars_unnest(p);
|
|
p->in_def--;
|
|
}
|
|
#line 9078 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 245: /* arg: defn_head f_opt_arglist_paren '=' arg "'rescue' modifier" arg */
|
|
#line 3333 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-5].nd);
|
|
endless_method_name(p, (yyvsp[-5].nd));
|
|
void_expr_error(p, (yyvsp[-2].nd));
|
|
defn_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
|
|
nvars_unnest(p);
|
|
p->in_def--;
|
|
}
|
|
#line 9091 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 246: /* arg: defs_head f_opt_arglist_paren '=' arg */
|
|
#line 3342 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-3].nd);
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
nvars_unnest(p);
|
|
p->in_def--;
|
|
p->in_single--;
|
|
}
|
|
#line 9104 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 247: /* arg: defs_head f_opt_arglist_paren '=' arg "'rescue' modifier" arg */
|
|
#line 3351 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-5].nd);
|
|
void_expr_error(p, (yyvsp[-2].nd));
|
|
defs_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
|
|
nvars_unnest(p);
|
|
p->in_def--;
|
|
p->in_single--;
|
|
}
|
|
#line 9117 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 248: /* arg: primary */
|
|
#line 3360 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 9125 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 250: /* aref_args: args trailer */
|
|
#line 3367 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 9133 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 251: /* aref_args: args comma assocs trailer */
|
|
#line 3371 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-3].nd), new_hash(p, (yyvsp[-1].nd)));
|
|
}
|
|
#line 9141 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 252: /* aref_args: assocs trailer */
|
|
#line 3375 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = cons(new_kw_hash(p, (yyvsp[-1].nd)), 0);
|
|
}
|
|
#line 9149 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 253: /* arg_rhs: arg */
|
|
#line 3381 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 9157 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 254: /* arg_rhs: arg "'rescue' modifier" arg */
|
|
#line 3385 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[-2].nd));
|
|
(yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 9166 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 255: /* paren_args: '(' opt_call_args ')' */
|
|
#line 3392 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 9174 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 256: /* paren_args: '(' args comma tBDOT3 rparen */
|
|
#line 3396 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
mrb_sym r = intern_op(mul);
|
|
mrb_sym k = intern_op(pow);
|
|
mrb_sym b = intern_op(and);
|
|
(yyval.nd) = new_callargs(p, push((yyvsp[-3].nd), new_splat(p, new_xvar(p, r, NODE_LVAR))),
|
|
new_kw_hash(p, list1(cons(new_kw_rest_args(p, 0), new_xvar(p, k, NODE_LVAR)))),
|
|
new_block_arg(p, new_xvar(p, b, NODE_LVAR)));
|
|
}
|
|
#line 9187 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 257: /* paren_args: '(' tBDOT3 rparen */
|
|
#line 3405 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
mrb_sym r = intern_op(mul);
|
|
mrb_sym k = intern_op(pow);
|
|
mrb_sym b = intern_op(and);
|
|
if (local_var_p(p, r) && local_var_p(p, k) && local_var_p(p, b)) {
|
|
(yyval.nd) = new_callargs(p, list1(new_splat(p, new_xvar(p, r, NODE_LVAR))),
|
|
new_kw_hash(p, list1(cons(new_kw_rest_args(p, 0), new_xvar(p, k, NODE_LVAR)))),
|
|
new_block_arg(p, new_xvar(p, b, NODE_LVAR)));
|
|
}
|
|
else {
|
|
yyerror(&(yylsp[-2]), p, "unexpected argument forwarding ...");
|
|
(yyval.nd) = 0;
|
|
}
|
|
}
|
|
#line 9206 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 262: /* opt_call_args: args comma */
|
|
#line 3428 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_callargs(p,(yyvsp[-1].nd),0,0);
|
|
}
|
|
#line 9214 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 263: /* opt_call_args: args comma assocs comma */
|
|
#line 3432 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_callargs(p,(yyvsp[-3].nd),new_kw_hash(p,(yyvsp[-1].nd)),0);
|
|
}
|
|
#line 9222 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 264: /* opt_call_args: assocs comma */
|
|
#line 3436 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_callargs(p,0,new_kw_hash(p,(yyvsp[-1].nd)),0);
|
|
}
|
|
#line 9230 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 265: /* call_args: command */
|
|
#line 3442 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = new_callargs(p, list1((yyvsp[0].nd)), 0, 0);
|
|
}
|
|
#line 9239 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 266: /* call_args: args opt_block_arg */
|
|
#line 3447 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_callargs(p, (yyvsp[-1].nd), 0, (yyvsp[0].nd));
|
|
}
|
|
#line 9247 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 267: /* call_args: assocs opt_block_arg */
|
|
#line 3451 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_callargs(p, 0, new_kw_hash(p, (yyvsp[-1].nd)), (yyvsp[0].nd));
|
|
}
|
|
#line 9255 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 268: /* call_args: args comma assocs opt_block_arg */
|
|
#line 3455 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_callargs(p, (yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd)), (yyvsp[0].nd));
|
|
}
|
|
#line 9263 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 269: /* call_args: block_arg */
|
|
#line 3459 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_callargs(p, 0, 0, (yyvsp[0].nd));
|
|
}
|
|
#line 9271 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 270: /* @7: %empty */
|
|
#line 3464 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.stack) = p->cmdarg_stack;
|
|
CMDARG_PUSH(1);
|
|
}
|
|
#line 9280 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 271: /* command_args: @7 call_args */
|
|
#line 3469 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->cmdarg_stack = (yyvsp[-1].stack);
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 9289 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 272: /* block_arg: "&" arg */
|
|
#line 3476 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_block_arg(p, (yyvsp[0].nd));
|
|
}
|
|
#line 9297 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 273: /* block_arg: "&" */
|
|
#line 3480 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_block_arg(p, 0);
|
|
}
|
|
#line 9305 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 274: /* opt_block_arg: comma block_arg */
|
|
#line 3486 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 9313 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 275: /* opt_block_arg: none */
|
|
#line 3490 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 9321 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 277: /* args: arg */
|
|
#line 3499 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 9330 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 278: /* args: "*" */
|
|
#line 3504 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1(new_splat(p, new_xvar(p, intern_op(mul), NODE_LVAR)));
|
|
}
|
|
#line 9338 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 279: /* args: "*" arg */
|
|
#line 3508 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1(new_splat(p, (yyvsp[0].nd)));
|
|
}
|
|
#line 9346 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 280: /* args: args comma arg */
|
|
#line 3512 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 9355 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 281: /* args: args comma "*" */
|
|
#line 3517 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-2].nd), new_splat(p, new_xvar(p, intern_op(mul), NODE_LVAR)));
|
|
}
|
|
#line 9363 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 282: /* args: args comma "*" arg */
|
|
#line 3521 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd)));
|
|
}
|
|
#line 9371 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 283: /* mrhs: args comma arg */
|
|
#line 3527 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 9380 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 284: /* mrhs: args comma "*" arg */
|
|
#line 3532 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd)));
|
|
}
|
|
#line 9388 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 285: /* mrhs: "*" arg */
|
|
#line 3536 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1(new_splat(p, (yyvsp[0].nd)));
|
|
}
|
|
#line 9396 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 287: /* primary: string */
|
|
#line 3543 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_str(p, (yyvsp[0].nd));
|
|
}
|
|
#line 9404 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 288: /* primary: xstring */
|
|
#line 3547 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_xstr(p, (yyvsp[0].nd));
|
|
}
|
|
#line 9412 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 293: /* primary: "method" */
|
|
#line 3555 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_fcall(p, (yyvsp[0].id), 0);
|
|
}
|
|
#line 9420 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 294: /* @8: %empty */
|
|
#line 3559 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.stack) = p->cmdarg_stack;
|
|
p->cmdarg_stack = 0;
|
|
}
|
|
#line 9429 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 295: /* primary: "'begin'" @8 bodystmt "'end'" */
|
|
#line 3565 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->cmdarg_stack = (yyvsp[-2].stack);
|
|
(yyval.nd) = new_begin(p, (yyvsp[-1].nd));
|
|
}
|
|
#line 9438 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 296: /* @9: %empty */
|
|
#line 3570 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.stack) = p->cmdarg_stack;
|
|
p->cmdarg_stack = 0;
|
|
}
|
|
#line 9447 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 297: /* $@10: %empty */
|
|
#line 3574 "mrbgems/mruby-compiler/core/parse.y"
|
|
{p->lstate = EXPR_ENDARG;}
|
|
#line 9453 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 298: /* primary: "(" @9 stmt $@10 rparen */
|
|
#line 3575 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->cmdarg_stack = (yyvsp[-3].stack);
|
|
(yyval.nd) = (yyvsp[-2].nd);
|
|
}
|
|
#line 9462 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 299: /* $@11: %empty */
|
|
#line 3579 "mrbgems/mruby-compiler/core/parse.y"
|
|
{p->lstate = EXPR_ENDARG;}
|
|
#line 9468 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 300: /* primary: "(" $@11 rparen */
|
|
#line 3580 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_nil(p);
|
|
}
|
|
#line 9476 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 301: /* primary: tLPAREN compstmt ')' */
|
|
#line 3584 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 9484 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 302: /* primary: primary_value "::" "constant" */
|
|
#line 3588 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
|
|
}
|
|
#line 9492 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 303: /* primary: tCOLON3 "constant" */
|
|
#line 3592 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_colon3(p, (yyvsp[0].id));
|
|
}
|
|
#line 9500 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 304: /* primary: "[" aref_args ']' */
|
|
#line 3596 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_array(p, (yyvsp[-1].nd));
|
|
}
|
|
#line 9508 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 305: /* primary: tLBRACE assoc_list '}' */
|
|
#line 3600 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_hash(p, (yyvsp[-1].nd));
|
|
}
|
|
#line 9516 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 306: /* primary: "'return'" */
|
|
#line 3604 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_return(p, 0);
|
|
}
|
|
#line 9524 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 307: /* primary: "'yield'" opt_paren_args */
|
|
#line 3608 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_yield(p, (yyvsp[0].nd));
|
|
}
|
|
#line 9532 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 308: /* primary: "'not'" '(' expr rparen */
|
|
#line 3612 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_uni_op(p, cond((yyvsp[-1].nd)), "!");
|
|
}
|
|
#line 9540 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 309: /* primary: "'not'" '(' rparen */
|
|
#line 3616 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = call_uni_op(p, new_nil(p), "!");
|
|
}
|
|
#line 9548 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 310: /* primary: operation brace_block */
|
|
#line 3620 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_fcall(p, (yyvsp[-1].id), new_callargs(p, 0, 0, (yyvsp[0].nd)));
|
|
}
|
|
#line 9556 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 312: /* primary: method_call brace_block */
|
|
#line 3625 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
call_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 9565 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 313: /* @12: %empty */
|
|
#line 3630 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_nest(p);
|
|
nvars_nest(p);
|
|
(yyval.num) = p->lpar_beg;
|
|
p->lpar_beg = ++p->paren_nest;
|
|
}
|
|
#line 9576 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 314: /* @13: %empty */
|
|
#line 3637 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.stack) = p->cmdarg_stack;
|
|
p->cmdarg_stack = 0;
|
|
}
|
|
#line 9585 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 315: /* primary: "->" @12 f_larglist @13 lambda_body */
|
|
#line 3642 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->lpar_beg = (yyvsp[-3].num);
|
|
(yyval.nd) = new_lambda(p, (yyvsp[-2].nd), (yyvsp[0].nd));
|
|
local_unnest(p);
|
|
nvars_unnest(p);
|
|
p->cmdarg_stack = (yyvsp[-1].stack);
|
|
CMDARG_LEXPOP();
|
|
}
|
|
#line 9598 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 316: /* primary: "'if'" expr_value then compstmt if_tail "'end'" */
|
|
#line 3654 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_if(p, cond((yyvsp[-4].nd)), (yyvsp[-2].nd), (yyvsp[-1].nd));
|
|
SET_LINENO((yyval.nd), (yyvsp[-5].num));
|
|
}
|
|
#line 9607 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 317: /* primary: "'unless'" expr_value then compstmt opt_else "'end'" */
|
|
#line 3662 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_if(p, cond((yyvsp[-4].nd)), (yyvsp[-1].nd), (yyvsp[-2].nd));
|
|
SET_LINENO((yyval.nd), (yyvsp[-5].num));
|
|
}
|
|
#line 9616 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 318: /* $@14: %empty */
|
|
#line 3666 "mrbgems/mruby-compiler/core/parse.y"
|
|
{COND_PUSH(1);}
|
|
#line 9622 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 319: /* $@15: %empty */
|
|
#line 3666 "mrbgems/mruby-compiler/core/parse.y"
|
|
{COND_POP();}
|
|
#line 9628 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 320: /* primary: "'while'" $@14 expr_value do $@15 compstmt "'end'" */
|
|
#line 3669 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_while(p, cond((yyvsp[-4].nd)), (yyvsp[-1].nd));
|
|
SET_LINENO((yyval.nd), (yyvsp[-6].num));
|
|
}
|
|
#line 9637 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 321: /* $@16: %empty */
|
|
#line 3673 "mrbgems/mruby-compiler/core/parse.y"
|
|
{COND_PUSH(1);}
|
|
#line 9643 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 322: /* $@17: %empty */
|
|
#line 3673 "mrbgems/mruby-compiler/core/parse.y"
|
|
{COND_POP();}
|
|
#line 9649 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 323: /* primary: "'until'" $@16 expr_value do $@17 compstmt "'end'" */
|
|
#line 3676 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_until(p, cond((yyvsp[-4].nd)), (yyvsp[-1].nd));
|
|
SET_LINENO((yyval.nd), (yyvsp[-6].num));
|
|
}
|
|
#line 9658 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 324: /* primary: "'case'" expr_value opt_terms case_body "'end'" */
|
|
#line 3683 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_case(p, (yyvsp[-3].nd), (yyvsp[-1].nd));
|
|
}
|
|
#line 9666 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 325: /* primary: "'case'" opt_terms case_body "'end'" */
|
|
#line 3687 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_case(p, 0, (yyvsp[-1].nd));
|
|
}
|
|
#line 9674 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 326: /* $@18: %empty */
|
|
#line 3691 "mrbgems/mruby-compiler/core/parse.y"
|
|
{COND_PUSH(1);}
|
|
#line 9680 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 327: /* $@19: %empty */
|
|
#line 3693 "mrbgems/mruby-compiler/core/parse.y"
|
|
{COND_POP();}
|
|
#line 9686 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 328: /* primary: "'for'" for_var "'in'" $@18 expr_value do $@19 compstmt "'end'" */
|
|
#line 3696 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_for(p, (yyvsp[-7].nd), (yyvsp[-4].nd), (yyvsp[-1].nd));
|
|
SET_LINENO((yyval.nd), (yyvsp[-8].num));
|
|
}
|
|
#line 9695 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 329: /* @20: %empty */
|
|
#line 3702 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
if (p->in_def || p->in_single)
|
|
yyerror(&(yylsp[-2]), p, "class definition in method body");
|
|
(yyval.nd) = local_switch(p);
|
|
nvars_block(p);
|
|
}
|
|
#line 9706 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 330: /* primary: "'class'" cpath superclass @20 bodystmt "'end'" */
|
|
#line 3710 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_class(p, (yyvsp[-4].nd), (yyvsp[-3].nd), (yyvsp[-1].nd));
|
|
SET_LINENO((yyval.nd), (yyvsp[-5].num));
|
|
local_resume(p, (yyvsp[-2].nd));
|
|
nvars_unnest(p);
|
|
}
|
|
#line 9717 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 331: /* @21: %empty */
|
|
#line 3718 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.num) = p->in_def;
|
|
p->in_def = 0;
|
|
}
|
|
#line 9726 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 332: /* @22: %empty */
|
|
#line 3723 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = cons(local_switch(p), int_to_node(p->in_single));
|
|
nvars_block(p);
|
|
p->in_single = 0;
|
|
}
|
|
#line 9736 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 333: /* primary: "'class'" "<<" expr @21 term @22 bodystmt "'end'" */
|
|
#line 3730 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_sclass(p, (yyvsp[-5].nd), (yyvsp[-1].nd));
|
|
SET_LINENO((yyval.nd), (yyvsp[-7].num));
|
|
local_resume(p, (yyvsp[-2].nd)->car);
|
|
nvars_unnest(p);
|
|
p->in_def = (yyvsp[-4].num);
|
|
p->in_single = node_to_int((yyvsp[-2].nd)->cdr);
|
|
}
|
|
#line 9749 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 334: /* @23: %empty */
|
|
#line 3740 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
if (p->in_def || p->in_single)
|
|
yyerror(&(yylsp[-1]), p, "module definition in method body");
|
|
(yyval.nd) = local_switch(p);
|
|
nvars_block(p);
|
|
}
|
|
#line 9760 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 335: /* primary: "'module'" cpath @23 bodystmt "'end'" */
|
|
#line 3748 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_module(p, (yyvsp[-3].nd), (yyvsp[-1].nd));
|
|
SET_LINENO((yyval.nd), (yyvsp[-4].num));
|
|
local_resume(p, (yyvsp[-2].nd));
|
|
nvars_unnest(p);
|
|
}
|
|
#line 9771 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 336: /* primary: defn_head f_arglist bodystmt "'end'" */
|
|
#line 3758 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-3].nd);
|
|
defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
|
|
nvars_unnest(p);
|
|
p->in_def--;
|
|
}
|
|
#line 9782 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 337: /* primary: defs_head f_arglist bodystmt "'end'" */
|
|
#line 3768 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-3].nd);
|
|
defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
|
|
nvars_unnest(p);
|
|
p->in_def--;
|
|
p->in_single--;
|
|
}
|
|
#line 9794 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 338: /* primary: "'break'" */
|
|
#line 3776 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_break(p, 0);
|
|
}
|
|
#line 9802 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 339: /* primary: "'next'" */
|
|
#line 3780 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_next(p, 0);
|
|
}
|
|
#line 9810 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 340: /* primary: "'redo'" */
|
|
#line 3784 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_redo(p);
|
|
}
|
|
#line 9818 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 341: /* primary: "'retry'" */
|
|
#line 3788 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_retry(p);
|
|
}
|
|
#line 9826 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 342: /* primary_value: primary */
|
|
#line 3794 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
if (!(yyval.nd)) (yyval.nd) = new_nil(p);
|
|
}
|
|
#line 9835 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 349: /* if_tail: "'elsif'" expr_value then compstmt if_tail */
|
|
#line 3813 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_if(p, cond((yyvsp[-3].nd)), (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 9843 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 351: /* opt_else: "'else'" compstmt */
|
|
#line 3820 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 9851 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 352: /* for_var: lhs */
|
|
#line 3826 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1(list1((yyvsp[0].nd)));
|
|
}
|
|
#line 9859 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 354: /* f_margs: f_arg */
|
|
#line 3833 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list3((yyvsp[0].nd),0,0);
|
|
}
|
|
#line 9867 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 355: /* f_margs: f_arg ',' "*" f_norm_arg */
|
|
#line 3837 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list3((yyvsp[-3].nd), new_arg(p, (yyvsp[0].id)), 0);
|
|
}
|
|
#line 9875 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 356: /* f_margs: f_arg ',' "*" f_norm_arg ',' f_arg */
|
|
#line 3841 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list3((yyvsp[-5].nd), new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd));
|
|
}
|
|
#line 9883 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 357: /* f_margs: f_arg ',' "*" */
|
|
#line 3845 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_add_f(p, intern_op(mul));
|
|
(yyval.nd) = list3((yyvsp[-2].nd), int_to_node(-1), 0);
|
|
}
|
|
#line 9892 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 358: /* f_margs: f_arg ',' "*" ',' f_arg */
|
|
#line 3850 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list3((yyvsp[-4].nd), int_to_node(-1), (yyvsp[0].nd));
|
|
}
|
|
#line 9900 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 359: /* f_margs: "*" f_norm_arg */
|
|
#line 3854 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list3(0, new_arg(p, (yyvsp[0].id)), 0);
|
|
}
|
|
#line 9908 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 360: /* f_margs: "*" f_norm_arg ',' f_arg */
|
|
#line 3858 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list3(0, new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd));
|
|
}
|
|
#line 9916 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 361: /* f_margs: "*" */
|
|
#line 3862 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_add_f(p, intern_op(mul));
|
|
(yyval.nd) = list3(0, int_to_node(-1), 0);
|
|
}
|
|
#line 9925 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 362: /* $@24: %empty */
|
|
#line 3867 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_add_f(p, intern_op(mul));
|
|
}
|
|
#line 9933 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 363: /* f_margs: "*" ',' $@24 f_arg */
|
|
#line 3871 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list3(0, int_to_node(-1), (yyvsp[0].nd));
|
|
}
|
|
#line 9941 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 364: /* block_args_tail: f_block_kwarg ',' f_kwrest opt_f_block_arg */
|
|
#line 3877 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id));
|
|
}
|
|
#line 9949 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 365: /* block_args_tail: f_block_kwarg opt_f_block_arg */
|
|
#line 3881 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id));
|
|
}
|
|
#line 9957 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 366: /* block_args_tail: f_kwrest opt_f_block_arg */
|
|
#line 3885 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id));
|
|
}
|
|
#line 9965 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 367: /* block_args_tail: f_block_arg */
|
|
#line 3889 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id));
|
|
}
|
|
#line 9973 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 368: /* opt_block_args_tail: ',' block_args_tail */
|
|
#line 3895 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 9981 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 369: /* opt_block_args_tail: %empty */
|
|
#line 3899 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_tail(p, 0, 0, 0);
|
|
}
|
|
#line 9989 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 370: /* block_param: f_arg ',' f_block_optarg ',' f_rest_arg opt_block_args_tail */
|
|
#line 3905 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
|
|
}
|
|
#line 9997 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 371: /* block_param: f_arg ',' f_block_optarg ',' f_rest_arg ',' f_arg opt_block_args_tail */
|
|
#line 3909 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10005 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 372: /* block_param: f_arg ',' f_block_optarg opt_block_args_tail */
|
|
#line 3913 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
|
|
}
|
|
#line 10013 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 373: /* block_param: f_arg ',' f_block_optarg ',' f_arg opt_block_args_tail */
|
|
#line 3917 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10021 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 374: /* block_param: f_arg ',' f_rest_arg opt_block_args_tail */
|
|
#line 3921 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
|
|
}
|
|
#line 10029 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 375: /* block_param: f_arg ',' opt_block_args_tail */
|
|
#line 3925 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-2].nd), 0, 0, 0, (yyvsp[0].nd));
|
|
}
|
|
#line 10037 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 376: /* block_param: f_arg ',' f_rest_arg ',' f_arg opt_block_args_tail */
|
|
#line 3929 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10045 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 377: /* block_param: f_arg opt_block_args_tail */
|
|
#line 3933 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd));
|
|
}
|
|
#line 10053 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 378: /* block_param: f_block_optarg ',' f_rest_arg opt_block_args_tail */
|
|
#line 3937 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
|
|
}
|
|
#line 10061 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 379: /* block_param: f_block_optarg ',' f_rest_arg ',' f_arg opt_block_args_tail */
|
|
#line 3941 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10069 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 380: /* block_param: f_block_optarg opt_block_args_tail */
|
|
#line 3945 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
|
|
}
|
|
#line 10077 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 381: /* block_param: f_block_optarg ',' f_arg opt_block_args_tail */
|
|
#line 3949 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10085 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 382: /* block_param: f_rest_arg opt_block_args_tail */
|
|
#line 3953 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
|
|
}
|
|
#line 10093 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 383: /* block_param: f_rest_arg ',' f_arg opt_block_args_tail */
|
|
#line 3957 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10101 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 384: /* block_param: block_args_tail */
|
|
#line 3961 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd));
|
|
}
|
|
#line 10109 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 385: /* opt_block_param: none */
|
|
#line 3967 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_add_blk(p);
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 10118 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 386: /* opt_block_param: block_param_def */
|
|
#line 3972 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->cmd_start = TRUE;
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 10127 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 387: /* $@25: %empty */
|
|
#line 3978 "mrbgems/mruby-compiler/core/parse.y"
|
|
{local_add_blk(p);}
|
|
#line 10133 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 388: /* block_param_def: '|' $@25 opt_bv_decl '|' */
|
|
#line 3979 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 10141 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 389: /* block_param_def: "||" */
|
|
#line 3983 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_add_blk(p);
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 10150 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 390: /* block_param_def: '|' block_param opt_bv_decl '|' */
|
|
#line 3988 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-2].nd);
|
|
}
|
|
#line 10158 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 391: /* opt_bv_decl: opt_nl */
|
|
#line 3994 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 10166 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 392: /* opt_bv_decl: opt_nl ';' bv_decls opt_nl */
|
|
#line 3998 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 10174 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 395: /* bvar: "local variable or method" */
|
|
#line 4008 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_add_f(p, (yyvsp[0].id));
|
|
new_bv(p, (yyvsp[0].id));
|
|
}
|
|
#line 10183 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 397: /* f_larglist: '(' f_args opt_bv_decl ')' */
|
|
#line 4016 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-2].nd);
|
|
}
|
|
#line 10191 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 398: /* f_larglist: f_args */
|
|
#line 4020 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 10199 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 399: /* lambda_body: tLAMBEG compstmt '}' */
|
|
#line 4026 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 10207 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 400: /* lambda_body: "'do' for lambda" bodystmt "'end'" */
|
|
#line 4030 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 10215 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 401: /* @26: %empty */
|
|
#line 4036 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_nest(p);
|
|
nvars_nest(p);
|
|
(yyval.num) = p->lineno;
|
|
}
|
|
#line 10225 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 402: /* do_block: "'do' for block" @26 opt_block_param bodystmt "'end'" */
|
|
#line 4044 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
|
|
SET_LINENO((yyval.nd), (yyvsp[-3].num));
|
|
local_unnest(p);
|
|
nvars_unnest(p);
|
|
}
|
|
#line 10236 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 403: /* block_call: command do_block */
|
|
#line 4053 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
call_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 10245 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 404: /* block_call: block_call call_op2 operation2 opt_paren_args */
|
|
#line 4058 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
|
|
}
|
|
#line 10253 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 405: /* block_call: block_call call_op2 operation2 opt_paren_args brace_block */
|
|
#line 4062 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
|
|
call_with_block(p, (yyval.nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10262 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 406: /* block_call: block_call call_op2 operation2 command_args do_block */
|
|
#line 4067 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
|
|
call_with_block(p, (yyval.nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10271 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 407: /* method_call: operation paren_args */
|
|
#line 4074 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd));
|
|
}
|
|
#line 10279 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 408: /* method_call: primary_value call_op operation2 opt_paren_args */
|
|
#line 4078 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
|
|
}
|
|
#line 10287 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 409: /* method_call: primary_value "::" operation2 paren_args */
|
|
#line 4082 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2);
|
|
}
|
|
#line 10295 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 410: /* method_call: primary_value "::" operation3 */
|
|
#line 4086 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
|
|
}
|
|
#line 10303 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 411: /* method_call: primary_value call_op paren_args */
|
|
#line 4090 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), (yyvsp[-1].num));
|
|
}
|
|
#line 10311 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 412: /* method_call: primary_value "::" paren_args */
|
|
#line 4094 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM_2(p->mrb, call), (yyvsp[0].nd), tCOLON2);
|
|
}
|
|
#line 10319 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 413: /* method_call: "'super'" paren_args */
|
|
#line 4098 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_super(p, (yyvsp[0].nd));
|
|
}
|
|
#line 10327 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 414: /* method_call: "'super'" */
|
|
#line 4102 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_zsuper(p);
|
|
}
|
|
#line 10335 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 415: /* method_call: primary_value '[' opt_call_args ']' */
|
|
#line 4106 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_op(aref), (yyvsp[-1].nd), '.');
|
|
}
|
|
#line 10343 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 416: /* @27: %empty */
|
|
#line 4112 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_nest(p);
|
|
nvars_nest(p);
|
|
(yyval.num) = p->lineno;
|
|
}
|
|
#line 10353 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 417: /* brace_block: '{' @27 opt_block_param compstmt '}' */
|
|
#line 4119 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
|
|
SET_LINENO((yyval.nd), (yyvsp[-3].num));
|
|
local_unnest(p);
|
|
nvars_unnest(p);
|
|
}
|
|
#line 10364 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 418: /* @28: %empty */
|
|
#line 4126 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_nest(p);
|
|
nvars_nest(p);
|
|
(yyval.num) = p->lineno;
|
|
}
|
|
#line 10374 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 419: /* brace_block: "'do'" @28 opt_block_param bodystmt "'end'" */
|
|
#line 4133 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
|
|
SET_LINENO((yyval.nd), (yyvsp[-3].num));
|
|
local_unnest(p);
|
|
nvars_unnest(p);
|
|
}
|
|
#line 10385 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 420: /* case_body: "'when'" args then compstmt cases */
|
|
#line 4144 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = cons(cons((yyvsp[-3].nd), (yyvsp[-1].nd)), (yyvsp[0].nd));
|
|
}
|
|
#line 10393 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 421: /* cases: opt_else */
|
|
#line 4150 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
if ((yyvsp[0].nd)) {
|
|
(yyval.nd) = cons(cons(0, (yyvsp[0].nd)), 0);
|
|
}
|
|
else {
|
|
(yyval.nd) = 0;
|
|
}
|
|
}
|
|
#line 10406 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 423: /* opt_rescue: "'rescue'" exc_list exc_var then compstmt opt_rescue */
|
|
#line 4164 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1(list3((yyvsp[-4].nd), (yyvsp[-3].nd), (yyvsp[-1].nd)));
|
|
if ((yyvsp[0].nd)) (yyval.nd) = append((yyval.nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10415 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 425: /* exc_list: arg */
|
|
#line 4172 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 10423 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 428: /* exc_var: "=>" lhs */
|
|
#line 4180 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 10431 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 430: /* opt_ensure: "'ensure'" compstmt */
|
|
#line 4187 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 10439 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 437: /* string: string string_fragment */
|
|
#line 4201 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = append((yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10447 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 438: /* string_fragment: "character literal" */
|
|
#line 4207 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
/* tCHAR is (len . str), wrap as cons list */
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 10456 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 439: /* string_fragment: tSTRING */
|
|
#line 4212 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
/* tSTRING is (len . str), wrap as cons list */
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 10465 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 440: /* string_fragment: "string literal" tSTRING */
|
|
#line 4217 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
/* $2 is (len . str), wrap as cons list */
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 10474 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 441: /* string_fragment: "string literal" string_rep tSTRING */
|
|
#line 4222 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10482 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 443: /* string_rep: string_rep string_interp */
|
|
#line 4229 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = append((yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10490 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 444: /* string_interp: tSTRING_MID */
|
|
#line 4235 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
/* $1 is already in (len . str) format */
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 10499 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 445: /* @29: %empty */
|
|
#line 4240 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push_strterm(p);
|
|
}
|
|
#line 10507 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 446: /* string_interp: tSTRING_PART @29 compstmt '}' */
|
|
#line 4245 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
pop_strterm(p,(yyvsp[-2].nd));
|
|
/* $1 is already in (len . str) format, create (-1 . node) for expression */
|
|
node *expr_elem = cons(int_to_node(-1), (yyvsp[-1].nd));
|
|
(yyval.nd) = list2((yyvsp[-3].nd), expr_elem);
|
|
}
|
|
#line 10518 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 447: /* string_interp: tLITERAL_DELIM */
|
|
#line 4252 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1(new_literal_delim(p));
|
|
}
|
|
#line 10526 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 448: /* string_interp: tHD_LITERAL_DELIM heredoc_bodies */
|
|
#line 4256 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1(new_literal_delim(p));
|
|
}
|
|
#line 10534 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 449: /* xstring: tXSTRING_BEG tXSTRING */
|
|
#line 4262 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = cons((yyvsp[0].nd), (node*)NULL);
|
|
}
|
|
#line 10542 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 450: /* xstring: tXSTRING_BEG string_rep tXSTRING */
|
|
#line 4266 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 10550 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 451: /* regexp: tREGEXP_BEG tREGEXP */
|
|
#line 4272 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
node *data = (yyvsp[0].nd); /* ((len . pattern) . (flags . encoding)) */
|
|
const char *flags = (const char*)data->cdr->car;
|
|
const char *encoding = (const char*)data->cdr->cdr;
|
|
/* Use data->car directly as pattern_list: (len . pattern) */
|
|
node *pattern_list = cons(data->car, (node*)NULL);
|
|
(yyval.nd) = new_dregx(p, pattern_list, flags, encoding);
|
|
}
|
|
#line 10563 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 452: /* regexp: tREGEXP_BEG string_rep tREGEXP */
|
|
#line 4281 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
node *data = (yyvsp[0].nd); /* ((len . pattern) . (flags . encoding)) */
|
|
const char *flags = (const char*)data->cdr->car;
|
|
const char *encoding = (const char*)data->cdr->cdr;
|
|
/* Append the pattern from $3->car to the string list $2 */
|
|
node *complete_list = push((yyvsp[-1].nd), data->car);
|
|
(yyval.nd) = new_dregx(p, complete_list, flags, encoding);
|
|
}
|
|
#line 10576 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 456: /* heredoc_body: tHEREDOC_END */
|
|
#line 4299 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
parser_heredoc_info *info = parsing_heredoc_info(p);
|
|
info->doc = push(info->doc, new_str_empty(p));
|
|
heredoc_end(p);
|
|
}
|
|
#line 10586 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 457: /* heredoc_body: heredoc_string_rep tHEREDOC_END */
|
|
#line 4305 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
heredoc_end(p);
|
|
}
|
|
#line 10594 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 460: /* heredoc_string_interp: tHD_STRING_MID */
|
|
#line 4315 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
parser_heredoc_info *info = parsing_heredoc_info(p);
|
|
info->doc = push(info->doc, (yyvsp[0].nd));
|
|
heredoc_treat_nextline(p);
|
|
}
|
|
#line 10604 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 461: /* @30: %empty */
|
|
#line 4321 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push_strterm(p);
|
|
}
|
|
#line 10612 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 462: /* heredoc_string_interp: tHD_STRING_PART @30 compstmt '}' */
|
|
#line 4326 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
pop_strterm(p, (yyvsp[-2].nd));
|
|
parser_heredoc_info *info = parsing_heredoc_info(p);
|
|
/* $1 is already in (len . str) format, create (-1 . node) for expression */
|
|
node *expr_elem = cons(int_to_node(-1), (yyvsp[-1].nd));
|
|
info->doc = push(push(info->doc, (yyvsp[-3].nd)), expr_elem);
|
|
}
|
|
#line 10624 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 463: /* words: tWORDS_BEG tSTRING */
|
|
#line 4336 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_words(p, list1((yyvsp[0].nd)));
|
|
}
|
|
#line 10632 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 464: /* words: tWORDS_BEG string_rep tSTRING */
|
|
#line 4340 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
node *n = (yyvsp[-1].nd);
|
|
n = push(n, (yyvsp[0].nd));
|
|
(yyval.nd) = new_words(p, n);
|
|
}
|
|
#line 10642 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 465: /* symbol: basic_symbol */
|
|
#line 4348 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_sym(p, (yyvsp[0].id));
|
|
}
|
|
#line 10650 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 466: /* symbol: "symbol" "string literal" string_rep tSTRING */
|
|
#line 4352 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
node *n = (yyvsp[-1].nd);
|
|
p->lstate = EXPR_ENDARG;
|
|
if (node_to_int((yyvsp[0].nd)->car) > 0) {
|
|
n = push(n, (yyvsp[0].nd));
|
|
}
|
|
else {
|
|
cons_free((yyvsp[0].nd));
|
|
}
|
|
(yyval.nd) = new_dsym(p, new_str(p, n));
|
|
}
|
|
#line 10666 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 467: /* symbol: "symbol" "numbered parameter" */
|
|
#line 4364 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
mrb_sym sym = intern_numparam((yyvsp[0].num));
|
|
(yyval.nd) = new_sym(p, sym);
|
|
}
|
|
#line 10675 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 468: /* basic_symbol: "symbol" sym */
|
|
#line 4371 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->lstate = EXPR_END;
|
|
(yyval.id) = (yyvsp[0].id);
|
|
}
|
|
#line 10684 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 473: /* sym: tSTRING */
|
|
#line 4382 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.id) = new_strsym(p, (yyvsp[0].nd));
|
|
}
|
|
#line 10692 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 474: /* sym: "string literal" tSTRING */
|
|
#line 4386 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.id) = new_strsym(p, (yyvsp[0].nd));
|
|
}
|
|
#line 10700 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 475: /* symbols: tSYMBOLS_BEG tSTRING */
|
|
#line 4392 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_symbols(p, list1((yyvsp[0].nd)));
|
|
}
|
|
#line 10708 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 476: /* symbols: tSYMBOLS_BEG string_rep tSTRING */
|
|
#line 4396 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
node *n = (yyvsp[-1].nd);
|
|
n = push(n, (yyvsp[0].nd));
|
|
(yyval.nd) = new_symbols(p, n);
|
|
}
|
|
#line 10718 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 479: /* numeric: tUMINUS_NUM "integer literal" */
|
|
#line 4406 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_negate(p, (yyvsp[0].nd));
|
|
}
|
|
#line 10726 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 480: /* numeric: tUMINUS_NUM "float literal" */
|
|
#line 4410 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_negate(p, (yyvsp[0].nd));
|
|
}
|
|
#line 10734 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 481: /* variable: "local variable or method" */
|
|
#line 4416 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_xvar(p, (yyvsp[0].id), NODE_LVAR);
|
|
}
|
|
#line 10742 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 482: /* variable: "instance variable" */
|
|
#line 4420 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_xvar(p, (yyvsp[0].id), NODE_IVAR);
|
|
}
|
|
#line 10750 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 483: /* variable: "global variable" */
|
|
#line 4424 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_xvar(p, (yyvsp[0].id), NODE_GVAR);
|
|
}
|
|
#line 10758 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 484: /* variable: "class variable" */
|
|
#line 4428 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_xvar(p, (yyvsp[0].id), NODE_CVAR);
|
|
}
|
|
#line 10766 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 485: /* variable: "constant" */
|
|
#line 4432 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_const(p, (yyvsp[0].id));
|
|
}
|
|
#line 10774 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 486: /* var_lhs: variable */
|
|
#line 4438 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
assignable(p, (yyvsp[0].nd));
|
|
}
|
|
#line 10782 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 487: /* var_lhs: "numbered parameter" */
|
|
#line 4442 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[0]), p, "can't assign to numbered parameter");
|
|
}
|
|
#line 10790 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 488: /* var_ref: variable */
|
|
#line 4448 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = var_reference(p, (yyvsp[0].nd));
|
|
}
|
|
#line 10798 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 489: /* var_ref: "numbered parameter" */
|
|
#line 4452 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_nvar(p, (yyvsp[0].num));
|
|
}
|
|
#line 10806 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 490: /* var_ref: "'nil'" */
|
|
#line 4456 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_nil(p);
|
|
}
|
|
#line 10814 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 491: /* var_ref: "'self'" */
|
|
#line 4460 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_self(p);
|
|
}
|
|
#line 10822 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 492: /* var_ref: "'true'" */
|
|
#line 4464 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_true(p);
|
|
}
|
|
#line 10830 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 493: /* var_ref: "'false'" */
|
|
#line 4468 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_false(p);
|
|
}
|
|
#line 10838 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 494: /* var_ref: "'__FILE__'" */
|
|
#line 4472 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
const char *fn = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
|
|
if (!fn) {
|
|
fn = "(null)";
|
|
}
|
|
(yyval.nd) = new_str(p, cons(cons(int_to_node(strlen(fn)), (node*)fn), (node*)NULL));
|
|
}
|
|
#line 10850 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 495: /* var_ref: "'__LINE__'" */
|
|
#line 4480 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
char buf[16];
|
|
|
|
dump_int(p->lineno, buf);
|
|
(yyval.nd) = new_int(p, buf, 10, 0);
|
|
}
|
|
#line 10861 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 496: /* var_ref: "'__ENCODING__'" */
|
|
#line 4487 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_fcall(p, MRB_SYM_2(p->mrb, __ENCODING__), 0);
|
|
}
|
|
#line 10869 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 499: /* superclass: %empty */
|
|
#line 4497 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 10877 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 500: /* $@31: %empty */
|
|
#line 4501 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->lstate = EXPR_BEG;
|
|
p->cmd_start = TRUE;
|
|
}
|
|
#line 10886 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 501: /* superclass: '<' $@31 expr_value term */
|
|
#line 4506 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 10894 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 504: /* f_arglist_paren: '(' f_args rparen */
|
|
#line 4522 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
p->lstate = EXPR_BEG;
|
|
p->cmd_start = TRUE;
|
|
}
|
|
#line 10904 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 505: /* f_arglist_paren: '(' f_arg ',' tBDOT3 rparen */
|
|
#line 4528 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_dots(p, (yyvsp[-3].nd));
|
|
}
|
|
#line 10912 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 506: /* f_arglist_paren: '(' tBDOT3 rparen */
|
|
#line 4532 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_dots(p, 0);
|
|
}
|
|
#line 10920 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 508: /* f_arglist: f_args term */
|
|
#line 4539 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 10928 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 509: /* f_arglist: f_arg ',' tBDOT3 term */
|
|
#line 4543 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_dots(p, (yyvsp[-3].nd));
|
|
}
|
|
#line 10936 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 510: /* f_arglist: "..." term */
|
|
#line 4547 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_dots(p, 0);
|
|
}
|
|
#line 10944 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 511: /* f_label: "local variable or method" "label" */
|
|
#line 4553 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_nest(p);
|
|
}
|
|
#line 10952 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 512: /* f_label: "numbered parameter" "label" */
|
|
#line 4557 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_nest(p);
|
|
}
|
|
#line 10960 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 513: /* f_kw: f_label arg */
|
|
#line 4563 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p)));
|
|
local_unnest(p);
|
|
}
|
|
#line 10970 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 514: /* f_kw: f_label */
|
|
#line 4569 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0);
|
|
local_unnest(p);
|
|
}
|
|
#line 10979 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 515: /* f_block_kw: f_label primary_value */
|
|
#line 4576 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p)));
|
|
local_unnest(p);
|
|
}
|
|
#line 10989 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 516: /* f_block_kw: f_label */
|
|
#line 4582 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0);
|
|
local_unnest(p);
|
|
}
|
|
#line 10998 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 517: /* f_block_kwarg: f_block_kw */
|
|
#line 4589 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 11006 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 518: /* f_block_kwarg: f_block_kwarg ',' f_block_kw */
|
|
#line 4593 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11014 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 519: /* f_kwarg: f_kw */
|
|
#line 4599 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 11022 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 520: /* f_kwarg: f_kwarg ',' f_kw */
|
|
#line 4603 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11030 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 523: /* f_kwrest: kwrest_mark "local variable or method" */
|
|
#line 4613 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_kw_rest_args(p, (yyvsp[0].id));
|
|
}
|
|
#line 11038 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 524: /* f_kwrest: kwrest_mark */
|
|
#line 4617 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_kw_rest_args(p, 0);
|
|
}
|
|
#line 11046 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 525: /* args_tail: f_kwarg ',' f_kwrest opt_f_block_arg */
|
|
#line 4623 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id));
|
|
}
|
|
#line 11054 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 526: /* args_tail: f_kwarg opt_f_block_arg */
|
|
#line 4627 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id));
|
|
}
|
|
#line 11062 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 527: /* args_tail: f_kwrest opt_f_block_arg */
|
|
#line 4631 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id));
|
|
}
|
|
#line 11070 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 528: /* args_tail: f_block_arg */
|
|
#line 4635 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id));
|
|
}
|
|
#line 11078 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 529: /* opt_args_tail: ',' args_tail */
|
|
#line 4641 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
}
|
|
#line 11086 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 530: /* opt_args_tail: %empty */
|
|
#line 4645 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args_tail(p, 0, 0, 0);
|
|
}
|
|
#line 11094 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 531: /* f_args: f_arg ',' f_optarg ',' f_rest_arg opt_args_tail */
|
|
#line 4651 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
|
|
}
|
|
#line 11102 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 532: /* f_args: f_arg ',' f_optarg ',' f_rest_arg ',' f_arg opt_args_tail */
|
|
#line 4655 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11110 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 533: /* f_args: f_arg ',' f_optarg opt_args_tail */
|
|
#line 4659 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
|
|
}
|
|
#line 11118 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 534: /* f_args: f_arg ',' f_optarg ',' f_arg opt_args_tail */
|
|
#line 4663 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11126 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 535: /* f_args: f_arg ',' f_rest_arg opt_args_tail */
|
|
#line 4667 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
|
|
}
|
|
#line 11134 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 536: /* f_args: f_arg ',' f_rest_arg ',' f_arg opt_args_tail */
|
|
#line 4671 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11142 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 537: /* f_args: f_arg opt_args_tail */
|
|
#line 4675 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd));
|
|
}
|
|
#line 11150 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 538: /* f_args: f_optarg ',' f_rest_arg opt_args_tail */
|
|
#line 4679 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
|
|
}
|
|
#line 11158 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 539: /* f_args: f_optarg ',' f_rest_arg ',' f_arg opt_args_tail */
|
|
#line 4683 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11166 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 540: /* f_args: f_optarg opt_args_tail */
|
|
#line 4687 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
|
|
}
|
|
#line 11174 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 541: /* f_args: f_optarg ',' f_arg opt_args_tail */
|
|
#line 4691 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11182 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 542: /* f_args: f_rest_arg opt_args_tail */
|
|
#line 4695 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
|
|
}
|
|
#line 11190 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 543: /* f_args: f_rest_arg ',' f_arg opt_args_tail */
|
|
#line 4699 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11198 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 544: /* f_args: args_tail */
|
|
#line 4703 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd));
|
|
}
|
|
#line 11206 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 545: /* f_args: %empty */
|
|
#line 4707 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_add_f(p, 0);
|
|
(yyval.nd) = new_args(p, 0, 0, 0, 0, 0);
|
|
}
|
|
#line 11215 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 546: /* f_bad_arg: "constant" */
|
|
#line 4714 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[0]), p, "formal argument cannot be a constant");
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 11224 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 547: /* f_bad_arg: "instance variable" */
|
|
#line 4719 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[0]), p, "formal argument cannot be an instance variable");
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 11233 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 548: /* f_bad_arg: "global variable" */
|
|
#line 4724 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[0]), p, "formal argument cannot be a global variable");
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 11242 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 549: /* f_bad_arg: "class variable" */
|
|
#line 4729 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[0]), p, "formal argument cannot be a class variable");
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 11251 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 550: /* f_bad_arg: "numbered parameter" */
|
|
#line 4734 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
yyerror(&(yylsp[0]), p, "formal argument cannot be a numbered parameter");
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 11260 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 551: /* f_norm_arg: f_bad_arg */
|
|
#line 4741 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.id) = 0;
|
|
}
|
|
#line 11268 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 552: /* f_norm_arg: "local variable or method" */
|
|
#line 4745 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_add_f(p, (yyvsp[0].id));
|
|
(yyval.id) = (yyvsp[0].id);
|
|
}
|
|
#line 11277 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 553: /* f_arg_item: f_norm_arg */
|
|
#line 4752 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_arg(p, (yyvsp[0].id));
|
|
}
|
|
#line 11285 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 554: /* @32: %empty */
|
|
#line 4756 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = local_switch(p);
|
|
}
|
|
#line 11293 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 555: /* f_arg_item: tLPAREN @32 f_margs rparen */
|
|
#line 4760 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = new_masgn_param(p, (yyvsp[-1].nd), p->locals->car);
|
|
local_resume(p, (yyvsp[-2].nd));
|
|
local_add_f(p, 0);
|
|
}
|
|
#line 11303 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 556: /* f_arg: f_arg_item */
|
|
#line 4768 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 11311 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 557: /* f_arg: f_arg ',' f_arg_item */
|
|
#line 4772 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11319 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 558: /* f_opt_asgn: "local variable or method" '=' */
|
|
#line 4778 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_add_f(p, (yyvsp[-1].id));
|
|
local_nest(p);
|
|
(yyval.id) = (yyvsp[-1].id);
|
|
}
|
|
#line 11329 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 559: /* f_opt: f_opt_asgn arg */
|
|
#line 4786 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = cons(sym_to_node((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p)));
|
|
local_unnest(p);
|
|
}
|
|
#line 11339 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 560: /* f_block_opt: f_opt_asgn primary_value */
|
|
#line 4794 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = cons(sym_to_node((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p)));
|
|
local_unnest(p);
|
|
}
|
|
#line 11349 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 561: /* f_block_optarg: f_block_opt */
|
|
#line 4802 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 11357 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 562: /* f_block_optarg: f_block_optarg ',' f_block_opt */
|
|
#line 4806 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11365 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 563: /* f_optarg: f_opt */
|
|
#line 4812 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 11373 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 564: /* f_optarg: f_optarg ',' f_opt */
|
|
#line 4816 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11381 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 567: /* f_rest_arg: restarg_mark "local variable or method" */
|
|
#line 4826 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
local_add_f(p, (yyvsp[0].id));
|
|
(yyval.id) = (yyvsp[0].id);
|
|
}
|
|
#line 11390 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 568: /* f_rest_arg: restarg_mark */
|
|
#line 4831 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.id) = intern_op(mul);
|
|
local_add_f(p, (yyval.id));
|
|
}
|
|
#line 11399 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 571: /* f_block_arg: blkarg_mark "local variable or method" */
|
|
#line 4842 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.id) = (yyvsp[0].id);
|
|
}
|
|
#line 11407 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 572: /* f_block_arg: blkarg_mark */
|
|
#line 4846 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.id) = intern_op(and);
|
|
}
|
|
#line 11415 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 573: /* opt_f_block_arg: ',' f_block_arg */
|
|
#line 4852 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.id) = (yyvsp[0].id);
|
|
}
|
|
#line 11423 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 574: /* opt_f_block_arg: none */
|
|
#line 4856 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.id) = 0;
|
|
}
|
|
#line 11431 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 575: /* singleton: var_ref */
|
|
#line 4862 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
prohibit_literals(p, (yyvsp[0].nd));
|
|
(yyval.nd) = (yyvsp[0].nd);
|
|
if (!(yyval.nd)) (yyval.nd) = new_nil(p);
|
|
}
|
|
#line 11441 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 576: /* $@33: %empty */
|
|
#line 4867 "mrbgems/mruby-compiler/core/parse.y"
|
|
{p->lstate = EXPR_BEG;}
|
|
#line 11447 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 577: /* singleton: '(' $@33 expr rparen */
|
|
#line 4868 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
prohibit_literals(p, (yyvsp[-1].nd));
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 11456 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 579: /* assoc_list: assocs trailer */
|
|
#line 4876 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = (yyvsp[-1].nd);
|
|
}
|
|
#line 11464 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 580: /* assocs: assoc */
|
|
#line 4882 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = list1((yyvsp[0].nd));
|
|
}
|
|
#line 11472 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 581: /* assocs: assocs comma assoc */
|
|
#line 4886 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11480 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 582: /* assoc: arg "=>" arg */
|
|
#line 4892 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[-2].nd));
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = cons((yyvsp[-2].nd), (yyvsp[0].nd));
|
|
}
|
|
#line 11490 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 583: /* assoc: "local variable or method" "label" arg */
|
|
#line 4898 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = cons(new_sym(p, (yyvsp[-2].id)), (yyvsp[0].nd));
|
|
}
|
|
#line 11499 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 584: /* assoc: "local variable or method" "label" */
|
|
#line 4903 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = cons(new_sym(p, (yyvsp[-1].id)), label_reference(p, (yyvsp[-1].id)));
|
|
}
|
|
#line 11507 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 585: /* assoc: "numbered parameter" "label" */
|
|
#line 4907 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
mrb_sym sym = intern_numparam((yyvsp[-1].num));
|
|
(yyval.nd) = cons(new_sym(p, sym), label_reference(p, sym));
|
|
}
|
|
#line 11516 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 586: /* assoc: "numbered parameter" "label" arg */
|
|
#line 4912 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = cons(new_sym(p, intern_numparam((yyvsp[-2].num))), (yyvsp[0].nd));
|
|
}
|
|
#line 11525 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 587: /* assoc: string_fragment "label" arg */
|
|
#line 4917 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
if ((yyvsp[-2].nd)->cdr) {
|
|
/* Multiple fragments - create dynamic symbol */
|
|
(yyval.nd) = cons(new_dsym(p, (yyvsp[-2].nd)), (yyvsp[0].nd));
|
|
}
|
|
else if (node_to_int((yyvsp[-2].nd)->car->car) < 0) {
|
|
/* Single fragment but it's an expression (-1 . node) - create dynamic symbol */
|
|
(yyval.nd) = cons(new_dsym(p, (yyvsp[-2].nd)), (yyvsp[0].nd));
|
|
}
|
|
else {
|
|
/* Single string fragment - create simple symbol */
|
|
(yyval.nd) = cons(new_sym(p, new_strsym(p, (yyvsp[-2].nd)->car)), (yyvsp[0].nd));
|
|
}
|
|
}
|
|
#line 11545 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 588: /* assoc: "**" arg */
|
|
#line 4933 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
void_expr_error(p, (yyvsp[0].nd));
|
|
(yyval.nd) = cons(new_kw_rest_args(p, 0), (yyvsp[0].nd));
|
|
}
|
|
#line 11554 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 589: /* assoc: "**" */
|
|
#line 4938 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = cons(new_kw_rest_args(p, 0), new_xvar(p, intern_op(pow), NODE_LVAR));
|
|
}
|
|
#line 11562 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 602: /* call_op: '.' */
|
|
#line 4964 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.num) = '.';
|
|
}
|
|
#line 11570 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 603: /* call_op: "&." */
|
|
#line 4968 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.num) = 0;
|
|
}
|
|
#line 11578 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 605: /* call_op2: "::" */
|
|
#line 4975 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.num) = tCOLON2;
|
|
}
|
|
#line 11586 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 614: /* term: ';' */
|
|
#line 4996 "mrbgems/mruby-compiler/core/parse.y"
|
|
{yyerrok;}
|
|
#line 11592 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 616: /* nl: '\n' */
|
|
#line 5001 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
p->lineno += (yyvsp[0].num);
|
|
p->column = 0;
|
|
}
|
|
#line 11601 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
case 620: /* none: %empty */
|
|
#line 5013 "mrbgems/mruby-compiler/core/parse.y"
|
|
{
|
|
(yyval.nd) = 0;
|
|
}
|
|
#line 11609 "mrbgems/mruby-compiler/core/y.tab.c"
|
|
break;
|
|
|
|
|
|
#line 11613 "mrbgems/mruby-compiler/core/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 ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc, p);
|
|
|
|
YYPOPSTACK (yylen);
|
|
|
|
yylen = 0;
|
|
|
|
*++yyvsp = yyval;
|
|
*++yylsp = yyloc;
|
|
|
|
/* 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. */
|
|
{
|
|
const int yylhs = yyr1[yyn] - YYNTOKENS;
|
|
const int yyi = yypgoto[yylhs] + *yyssp;
|
|
yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
|
|
? yytable[yyi]
|
|
: yydefgoto[yylhs]);
|
|
}
|
|
|
|
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 ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
|
|
/* If not already recovering from an error, report this error. */
|
|
if (!yyerrstatus)
|
|
{
|
|
++yynerrs;
|
|
{
|
|
yypcontext_t yyctx
|
|
= {yyssp, yytoken, &yylloc};
|
|
char const *yymsgp = YY_("syntax error");
|
|
int yysyntax_error_status;
|
|
yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx, p);
|
|
if (yysyntax_error_status == 0)
|
|
yymsgp = yymsg;
|
|
else if (yysyntax_error_status == -1)
|
|
{
|
|
if (yymsg != yymsgbuf)
|
|
YYSTACK_FREE (yymsg);
|
|
yymsg = YY_CAST (char *,
|
|
YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
|
|
if (yymsg)
|
|
{
|
|
yysyntax_error_status
|
|
= yysyntax_error (&yymsg_alloc, &yymsg, &yyctx, p);
|
|
yymsgp = yymsg;
|
|
}
|
|
else
|
|
{
|
|
yymsg = yymsgbuf;
|
|
yymsg_alloc = sizeof yymsgbuf;
|
|
yysyntax_error_status = YYENOMEM;
|
|
}
|
|
}
|
|
yyerror (&yylloc, p, yymsgp);
|
|
if (yysyntax_error_status == YYENOMEM)
|
|
YYNOMEM;
|
|
}
|
|
}
|
|
|
|
yyerror_range[1] = yylloc;
|
|
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, &yylloc, p);
|
|
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 when the user code never invokes YYERROR and the
|
|
label yyerrorlab therefore never appears in user code. */
|
|
if (0)
|
|
YYERROR;
|
|
++yynerrs;
|
|
|
|
/* Do not reclaim the symbols of the rule whose action triggered
|
|
this YYERROR. */
|
|
YYPOPSTACK (yylen);
|
|
|
|
yylen = 0;
|
|
YY_STACK_PRINT (yyss, yyssp, p);
|
|
yystate = *yyssp;
|
|
goto yyerrlab1;
|
|
|
|
|
|
/*-------------------------------------------------------------.
|
|
| yyerrlab1 -- common code for both syntax error and YYERROR. |
|
|
`-------------------------------------------------------------*/
|
|
yyerrlab1:
|
|
yyerrstatus = 3; /* Each real token shifted decrements this. */
|
|
|
|
/* Pop stack until we find a state that shifts the error token. */
|
|
for (;;)
|
|
{
|
|
yyn = yypact[yystate];
|
|
if (!yypact_value_is_default (yyn))
|
|
{
|
|
yyn += YYSYMBOL_YYerror;
|
|
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
|
|
{
|
|
yyn = yytable[yyn];
|
|
if (0 < yyn)
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Pop the current state because it cannot handle the error token. */
|
|
if (yyssp == yyss)
|
|
YYABORT;
|
|
|
|
yyerror_range[1] = *yylsp;
|
|
yydestruct ("Error: popping",
|
|
YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, p);
|
|
YYPOPSTACK (1);
|
|
|
|
yystate = *yyssp;
|
|
YY_STACK_PRINT (yyss, yyssp, p);
|
|
}
|
|
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
*++yyvsp = yylval;
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_END
|
|
|
|
yyerror_range[2] = yylloc;
|
|
++yylsp;
|
|
YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);
|
|
|
|
/* Shift the error token. */
|
|
YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp, p);
|
|
|
|
|
|
yystate = yyn;
|
|
goto yynewstate;
|
|
|
|
|
|
/*-------------------------------------.
|
|
| yyacceptlab -- YYACCEPT comes here. |
|
|
`-------------------------------------*/
|
|
yyacceptlab:
|
|
yyresult = 0;
|
|
goto yyreturnlab;
|
|
|
|
|
|
/*-----------------------------------.
|
|
| yyabortlab -- YYABORT comes here. |
|
|
`-----------------------------------*/
|
|
yyabortlab:
|
|
yyresult = 1;
|
|
goto yyreturnlab;
|
|
|
|
|
|
/*-----------------------------------------------------------.
|
|
| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. |
|
|
`-----------------------------------------------------------*/
|
|
yyexhaustedlab:
|
|
yyerror (&yylloc, p, YY_("memory exhausted"));
|
|
yyresult = 2;
|
|
goto yyreturnlab;
|
|
|
|
|
|
/*----------------------------------------------------------.
|
|
| yyreturnlab -- parsing is finished, clean up and return. |
|
|
`----------------------------------------------------------*/
|
|
yyreturnlab:
|
|
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, &yylloc, p);
|
|
}
|
|
/* Do not reclaim the symbols of the rule whose action triggered
|
|
this YYABORT or YYACCEPT. */
|
|
YYPOPSTACK (yylen);
|
|
YY_STACK_PRINT (yyss, yyssp, p);
|
|
while (yyssp != yyss)
|
|
{
|
|
yydestruct ("Cleanup: popping",
|
|
YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, p);
|
|
YYPOPSTACK (1);
|
|
}
|
|
#ifndef yyoverflow
|
|
if (yyss != yyssa)
|
|
YYSTACK_FREE (yyss);
|
|
#endif
|
|
if (yymsg != yymsgbuf)
|
|
YYSTACK_FREE (yymsg);
|
|
return yyresult;
|
|
}
|
|
|
|
#line 5017 "mrbgems/mruby-compiler/core/parse.y"
|
|
|
|
#define pylval (*((YYSTYPE*)(p->ylval)))
|
|
|
|
static void
|
|
yyerror(void *lp, parser_state *p, const char *s)
|
|
{
|
|
char* c;
|
|
size_t n;
|
|
|
|
if (! p->capture_errors) {
|
|
#ifndef MRB_NO_STDIO
|
|
if (p->filename_sym) {
|
|
const char *filename = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
|
|
fprintf(stderr, "%s:%d:%d: %s\n", filename, p->lineno, p->column, s);
|
|
}
|
|
else {
|
|
fprintf(stderr, "line %d:%d: %s\n", p->lineno, p->column, s);
|
|
}
|
|
#endif
|
|
}
|
|
else if (p->nerr < sizeof(p->error_buffer) / sizeof(p->error_buffer[0])) {
|
|
n = strlen(s);
|
|
c = (char*)parser_palloc(p, n + 1);
|
|
memcpy(c, s, n + 1);
|
|
p->error_buffer[p->nerr].message = c;
|
|
p->error_buffer[p->nerr].lineno = p->lineno;
|
|
p->error_buffer[p->nerr].column = p->column;
|
|
}
|
|
p->nerr++;
|
|
}
|
|
|
|
static void
|
|
yyerror_c(parser_state *p, const char *msg, char c)
|
|
{
|
|
char buf[256];
|
|
|
|
strncpy(buf, msg, sizeof(buf) - 2);
|
|
buf[sizeof(buf) - 2] = '\0';
|
|
strncat(buf, &c, 1);
|
|
yyerror(NULL, p, buf);
|
|
}
|
|
|
|
static void
|
|
yywarning(parser_state *p, const char *s)
|
|
{
|
|
char* c;
|
|
size_t n;
|
|
|
|
if (! p->capture_errors) {
|
|
#ifndef MRB_NO_STDIO
|
|
if (p->filename_sym) {
|
|
const char *filename = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
|
|
fprintf(stderr, "%s:%d:%d: warning: %s\n", filename, p->lineno, p->column, s);
|
|
}
|
|
else {
|
|
fprintf(stderr, "line %d:%d: warning: %s\n", p->lineno, p->column, s);
|
|
}
|
|
#endif
|
|
}
|
|
else if (p->nwarn < sizeof(p->warn_buffer) / sizeof(p->warn_buffer[0])) {
|
|
n = strlen(s);
|
|
c = (char*)parser_palloc(p, n + 1);
|
|
memcpy(c, s, n + 1);
|
|
p->warn_buffer[p->nwarn].message = c;
|
|
p->warn_buffer[p->nwarn].lineno = p->lineno;
|
|
p->warn_buffer[p->nwarn].column = p->column;
|
|
}
|
|
p->nwarn++;
|
|
}
|
|
|
|
static void
|
|
yywarning_s(parser_state *p, const char *msg, const char *s)
|
|
{
|
|
char buf[256];
|
|
|
|
strncpy(buf, msg, sizeof(buf) - 1);
|
|
buf[sizeof(buf) - 1] = '\0';
|
|
strncat(buf, ": ", sizeof(buf) - strlen(buf) - 1);
|
|
strncat(buf, s, sizeof(buf) - strlen(buf) - 1);
|
|
yywarning(p, buf);
|
|
}
|
|
|
|
static void
|
|
backref_error(parser_state *p, node *n)
|
|
{
|
|
int c;
|
|
|
|
c = node_to_int(n->car);
|
|
|
|
if (c == NODE_NTH_REF) {
|
|
yyerror_c(p, "can't set variable $", (char)node_to_int(n->cdr)+'0');
|
|
}
|
|
else if (c == NODE_BACK_REF) {
|
|
yyerror_c(p, "can't set variable $", (char)node_to_int(n->cdr));
|
|
}
|
|
else {
|
|
yyerror(NULL, p, "Internal error in backref_error()");
|
|
}
|
|
}
|
|
|
|
static void
|
|
void_expr_error(parser_state *p, node *n)
|
|
{
|
|
int c;
|
|
|
|
if (n == NULL) return;
|
|
c = node_to_int(n->car);
|
|
switch (c) {
|
|
case NODE_VARIABLE:
|
|
/* Handle variable-sized nodes */
|
|
switch (VAR_NODE_TYPE(n->cdr)) {
|
|
case NODE_BREAK:
|
|
case NODE_RETURN:
|
|
case NODE_NEXT:
|
|
case NODE_REDO:
|
|
case NODE_RETRY:
|
|
yyerror(NULL, p, "void value expression");
|
|
break;
|
|
case NODE_AND:
|
|
case NODE_OR:
|
|
{
|
|
struct mrb_ast_and_node *and_n = (struct mrb_ast_and_node*)n->cdr;
|
|
void_expr_error(p, (node*)and_n->left);
|
|
void_expr_error(p, (node*)and_n->right);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case NODE_STMTS:
|
|
case NODE_BEGIN:
|
|
if (n->cdr) {
|
|
while (n->cdr) {
|
|
n = n->cdr;
|
|
}
|
|
void_expr_error(p, n->car);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void pushback(parser_state *p, int c);
|
|
static mrb_bool peeks(parser_state *p, const char *s);
|
|
static mrb_bool skips(parser_state *p, const char *s);
|
|
|
|
static inline int
|
|
nextc0(parser_state *p)
|
|
{
|
|
if (p->s && p->s < p->send) {
|
|
return (unsigned char)*p->s++;
|
|
}
|
|
else {
|
|
#ifndef MRB_NO_STDIO
|
|
int c;
|
|
|
|
if (p->f) {
|
|
c = fgetc(p->f);
|
|
if (!feof(p->f)) return c;
|
|
}
|
|
#endif
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
static inline int
|
|
nextc(parser_state *p)
|
|
{
|
|
int c;
|
|
|
|
if (p->pb) {
|
|
node *tmp;
|
|
|
|
c = node_to_int(p->pb->car);
|
|
tmp = p->pb;
|
|
p->pb = p->pb->cdr;
|
|
cons_free(tmp);
|
|
}
|
|
else {
|
|
c = nextc0(p);
|
|
if (c < 0) goto eof;
|
|
}
|
|
if (c >= 0) {
|
|
p->column++;
|
|
}
|
|
if (c == '\r') {
|
|
const int lf = nextc0(p);
|
|
if (lf == '\n') {
|
|
return '\n';
|
|
}
|
|
if (lf > 0) pushback(p, lf);
|
|
}
|
|
return c;
|
|
|
|
eof:
|
|
if (!p->cxt) return -1;
|
|
else {
|
|
if (p->cxt->partial_hook(p) < 0)
|
|
return -1; /* end of program(s) */
|
|
return -2; /* end of a file in the program files */
|
|
}
|
|
}
|
|
|
|
static void
|
|
pushback(parser_state *p, int c)
|
|
{
|
|
if (c >= 0) {
|
|
p->column--;
|
|
}
|
|
p->pb = cons(int_to_node(c), p->pb);
|
|
}
|
|
|
|
static void
|
|
skip(parser_state *p, char term)
|
|
{
|
|
int c;
|
|
|
|
for (;;) {
|
|
c = nextc(p);
|
|
if (c < 0) break;
|
|
if (c == term) break;
|
|
}
|
|
}
|
|
|
|
static int
|
|
peekc_n(parser_state *p, int n)
|
|
{
|
|
node *list = 0;
|
|
int c0;
|
|
|
|
do {
|
|
c0 = nextc(p);
|
|
if (c0 == -1) return c0; /* do not skip partial EOF */
|
|
if (c0 >= 0) --p->column;
|
|
list = push(list, int_to_node(c0));
|
|
} while(n--);
|
|
if (p->pb) {
|
|
p->pb = append(list, p->pb);
|
|
}
|
|
else {
|
|
p->pb = list;
|
|
}
|
|
return c0;
|
|
}
|
|
|
|
static mrb_bool
|
|
peek_n(parser_state *p, int c, int n)
|
|
{
|
|
return peekc_n(p, n) == c && c >= 0;
|
|
}
|
|
#define peek(p,c) peek_n((p), (c), 0)
|
|
|
|
static mrb_bool
|
|
peeks(parser_state *p, const char *s)
|
|
{
|
|
size_t len = strlen(s);
|
|
|
|
#ifndef MRB_NO_STDIO
|
|
if (p->f) {
|
|
int n = 0;
|
|
while (*s) {
|
|
if (!peek_n(p, *s++, n++)) return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
else
|
|
#endif
|
|
if (p->s && p->s + len <= p->send) {
|
|
if (memcmp(p->s, s, len) == 0) return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static mrb_bool
|
|
skips(parser_state *p, const char *s)
|
|
{
|
|
int c;
|
|
|
|
for (;;) {
|
|
/* skip until first char */
|
|
for (;;) {
|
|
c = nextc(p);
|
|
if (c < 0) return FALSE;
|
|
if (c == '\n') {
|
|
p->lineno++;
|
|
p->column = 0;
|
|
}
|
|
if (c == *s) break;
|
|
}
|
|
s++;
|
|
if (peeks(p, s)) {
|
|
size_t len = strlen(s);
|
|
|
|
while (len--) {
|
|
if (nextc(p) == '\n') {
|
|
p->lineno++;
|
|
p->column = 0;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
else{
|
|
s--;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static int
|
|
newtok(parser_state *p)
|
|
{
|
|
if (p->tokbuf != p->buf) {
|
|
mrbc_free(p->tokbuf);
|
|
p->tokbuf = p->buf;
|
|
p->tsiz = MRB_PARSER_TOKBUF_SIZE;
|
|
}
|
|
p->tidx = 0;
|
|
return p->column - 1;
|
|
}
|
|
|
|
static void
|
|
tokadd(parser_state *p, int32_t c)
|
|
{
|
|
char utf8[4];
|
|
int i, len;
|
|
|
|
/* mrb_assert(-0x10FFFF <= c && c <= 0xFF); */
|
|
if (c >= 0) {
|
|
/* Single byte from source or non-Unicode escape */
|
|
utf8[0] = (char)c;
|
|
len = 1;
|
|
}
|
|
else {
|
|
/* Unicode character */
|
|
c = -c;
|
|
if (c < 0x80) {
|
|
utf8[0] = (char)c;
|
|
len = 1;
|
|
}
|
|
else if (c < 0x800) {
|
|
utf8[0] = (char)(0xC0 | (c >> 6));
|
|
utf8[1] = (char)(0x80 | (c & 0x3F));
|
|
len = 2;
|
|
}
|
|
else if (c < 0x10000) {
|
|
utf8[0] = (char)(0xE0 | (c >> 12) );
|
|
utf8[1] = (char)(0x80 | ((c >> 6) & 0x3F));
|
|
utf8[2] = (char)(0x80 | ( c & 0x3F));
|
|
len = 3;
|
|
}
|
|
else {
|
|
utf8[0] = (char)(0xF0 | (c >> 18) );
|
|
utf8[1] = (char)(0x80 | ((c >> 12) & 0x3F));
|
|
utf8[2] = (char)(0x80 | ((c >> 6) & 0x3F));
|
|
utf8[3] = (char)(0x80 | ( c & 0x3F));
|
|
len = 4;
|
|
}
|
|
}
|
|
if (p->tidx+len >= p->tsiz) {
|
|
if (p->tsiz >= MRB_PARSER_TOKBUF_MAX) {
|
|
p->tidx += len;
|
|
return;
|
|
}
|
|
p->tsiz *= 2;
|
|
if (p->tokbuf == p->buf) {
|
|
p->tokbuf = (char*)mrbc_malloc(p->tsiz);
|
|
memcpy(p->tokbuf, p->buf, MRB_PARSER_TOKBUF_SIZE);
|
|
}
|
|
else {
|
|
p->tokbuf = (char*)mrbc_realloc(p->tokbuf, p->tsiz);
|
|
}
|
|
}
|
|
for (i = 0; i < len; i++) {
|
|
p->tokbuf[p->tidx++] = utf8[i];
|
|
}
|
|
}
|
|
|
|
static int
|
|
toklast(parser_state *p)
|
|
{
|
|
return p->tokbuf[p->tidx-1];
|
|
}
|
|
|
|
static void
|
|
tokfix(parser_state *p)
|
|
{
|
|
if (p->tidx >= MRB_PARSER_TOKBUF_MAX) {
|
|
p->tidx = MRB_PARSER_TOKBUF_MAX-1;
|
|
yyerror(NULL, p, "string too long (truncated)");
|
|
}
|
|
p->tokbuf[p->tidx] = '\0';
|
|
}
|
|
|
|
static const char*
|
|
tok(parser_state *p)
|
|
{
|
|
return p->tokbuf;
|
|
}
|
|
|
|
static int
|
|
toklen(parser_state *p)
|
|
{
|
|
return p->tidx;
|
|
}
|
|
|
|
#define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
|
|
#define IS_END() (p->lstate == EXPR_END || p->lstate == EXPR_ENDARG || p->lstate == EXPR_ENDFN)
|
|
#define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
|
|
#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
|
|
#define IS_LABEL_POSSIBLE() ((p->lstate == EXPR_BEG && !cmd_state) || IS_ARG())
|
|
#define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1))
|
|
|
|
static int32_t
|
|
scan_oct(const int *start, int len, int *retlen)
|
|
{
|
|
const int *s = start;
|
|
int32_t retval = 0;
|
|
|
|
/* mrb_assert(len <= 3) */
|
|
while (len-- && *s >= '0' && *s <= '7') {
|
|
retval <<= 3;
|
|
retval |= *s++ - '0';
|
|
}
|
|
*retlen = (int)(s - start);
|
|
|
|
return retval;
|
|
}
|
|
|
|
static int32_t
|
|
scan_hex(parser_state *p, const int *start, int len, int *retlen)
|
|
{
|
|
static const char hexdigit[] = "0123456789abcdef0123456789ABCDEF";
|
|
const int *s = start;
|
|
uint32_t retval = 0;
|
|
char *tmp;
|
|
|
|
/* mrb_assert(len <= 8) */
|
|
while (len-- && *s && (tmp = (char*)strchr(hexdigit, *s))) {
|
|
retval <<= 4;
|
|
retval |= (tmp - hexdigit) & 15;
|
|
s++;
|
|
}
|
|
*retlen = (int)(s - start);
|
|
|
|
return (int32_t)retval;
|
|
}
|
|
|
|
static int32_t
|
|
read_escape_unicode(parser_state *p, int limit)
|
|
{
|
|
int buf[9];
|
|
int i;
|
|
int32_t hex;
|
|
|
|
/* Look for opening brace */
|
|
i = 0;
|
|
buf[0] = nextc(p);
|
|
if (buf[0] < 0) {
|
|
eof:
|
|
yyerror(NULL, p, "invalid escape character syntax");
|
|
return -1;
|
|
}
|
|
if (ISXDIGIT(buf[0])) {
|
|
/* \uxxxx form */
|
|
for (i=1; i<limit; i++) {
|
|
buf[i] = nextc(p);
|
|
if (buf[i] < 0) goto eof;
|
|
if (!ISXDIGIT(buf[i])) {
|
|
pushback(p, buf[i]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
pushback(p, buf[0]);
|
|
}
|
|
hex = scan_hex(p, buf, i, &i);
|
|
if (i == 0 || hex > 0x10FFFF || (hex & 0xFFFFF800) == 0xD800) {
|
|
yyerror(NULL, p, "invalid Unicode code point");
|
|
return -1;
|
|
}
|
|
return hex;
|
|
}
|
|
|
|
/* Return negative to indicate Unicode code point */
|
|
static int32_t
|
|
read_escape(parser_state *p)
|
|
{
|
|
int32_t c;
|
|
|
|
switch (c = nextc(p)) {
|
|
case '\\':/* Backslash */
|
|
return c;
|
|
|
|
case 'n':/* newline */
|
|
return '\n';
|
|
|
|
case 't':/* horizontal tab */
|
|
return '\t';
|
|
|
|
case 'r':/* carriage-return */
|
|
return '\r';
|
|
|
|
case 'f':/* form-feed */
|
|
return '\f';
|
|
|
|
case 'v':/* vertical tab */
|
|
return '\13';
|
|
|
|
case 'a':/* alarm(bell) */
|
|
return '\007';
|
|
|
|
case 'e':/* escape */
|
|
return 033;
|
|
|
|
case '0': case '1': case '2': case '3': /* octal constant */
|
|
case '4': case '5': case '6': case '7':
|
|
{
|
|
int buf[3];
|
|
int i;
|
|
|
|
buf[0] = c;
|
|
for (i=1; i<3; i++) {
|
|
buf[i] = nextc(p);
|
|
if (buf[i] < 0) goto eof;
|
|
if (buf[i] < '0' || '7' < buf[i]) {
|
|
pushback(p, buf[i]);
|
|
break;
|
|
}
|
|
}
|
|
c = scan_oct(buf, i, &i);
|
|
}
|
|
return c;
|
|
|
|
case 'x': /* hex constant */
|
|
{
|
|
int buf[2];
|
|
int i;
|
|
|
|
for (i=0; i<2; i++) {
|
|
buf[i] = nextc(p);
|
|
if (buf[i] < 0) goto eof;
|
|
if (!ISXDIGIT(buf[i])) {
|
|
pushback(p, buf[i]);
|
|
break;
|
|
}
|
|
}
|
|
if (i == 0) {
|
|
yyerror(NULL, p, "invalid hex escape");
|
|
return -1;
|
|
}
|
|
return scan_hex(p, buf, i, &i);
|
|
}
|
|
|
|
case 'u': /* Unicode */
|
|
if (peek(p, '{')) {
|
|
/* \u{xxxxxxxx} form */
|
|
nextc(p);
|
|
c = read_escape_unicode(p, 8);
|
|
if (c < 0) return 0;
|
|
if (nextc(p) != '}') goto eof;
|
|
}
|
|
else {
|
|
c = read_escape_unicode(p, 4);
|
|
if (c < 0) return 0;
|
|
}
|
|
return -c;
|
|
|
|
case 'b':/* backspace */
|
|
return '\010';
|
|
|
|
case 's':/* space */
|
|
return ' ';
|
|
|
|
case 'M':
|
|
if ((c = nextc(p)) != '-') {
|
|
yyerror(NULL, p, "Invalid escape character syntax");
|
|
pushback(p, c);
|
|
return '\0';
|
|
}
|
|
if ((c = nextc(p)) == '\\') {
|
|
return read_escape(p) | 0x80;
|
|
}
|
|
else if (c < 0) goto eof;
|
|
else {
|
|
return ((c & 0xff) | 0x80);
|
|
}
|
|
|
|
case 'C':
|
|
if ((c = nextc(p)) != '-') {
|
|
yyerror(NULL, p, "Invalid escape character syntax");
|
|
pushback(p, c);
|
|
return '\0';
|
|
}
|
|
case 'c':
|
|
if ((c = nextc(p))== '\\') {
|
|
c = read_escape(p);
|
|
}
|
|
else if (c == '?')
|
|
return 0177;
|
|
else if (c < 0) goto eof;
|
|
return c & 0x9f;
|
|
|
|
eof:
|
|
case -1:
|
|
case -2: /* end of a file */
|
|
yyerror(NULL, p, "Invalid escape character syntax");
|
|
return '\0';
|
|
|
|
default:
|
|
return c;
|
|
}
|
|
}
|
|
|
|
static void
|
|
heredoc_count_indent(parser_heredoc_info *hinfo, const char *str, size_t len, size_t spaces, size_t *offset)
|
|
{
|
|
size_t indent = 0;
|
|
*offset = 0;
|
|
for (size_t i = 0; i < len; i++) {
|
|
size_t size;
|
|
if (str[i] == '\n')
|
|
break;
|
|
else if (str[i] == '\t')
|
|
size = 8;
|
|
else if (ISSPACE(str[i]))
|
|
size = 1;
|
|
else
|
|
break;
|
|
size_t nindent = indent + size;
|
|
if (nindent > spaces || nindent > hinfo->indent)
|
|
break;
|
|
indent = nindent;
|
|
*offset += 1;
|
|
}
|
|
}
|
|
|
|
static void
|
|
heredoc_remove_indent(parser_state *p, parser_heredoc_info *hinfo)
|
|
{
|
|
if (!hinfo->remove_indent || hinfo->indent == 0)
|
|
return;
|
|
node *indented, *n, *pair, *escaped, *nspaces;
|
|
const char *str;
|
|
size_t len, spaces, offset, start, end;
|
|
indented = hinfo->indented;
|
|
while (indented) {
|
|
n = indented->car;
|
|
pair = n->car;
|
|
len = (size_t)pair->car;
|
|
str = (char*)pair->cdr;
|
|
escaped = n->cdr->car;
|
|
nspaces = n->cdr->cdr;
|
|
if (escaped) {
|
|
char *newstr = strndup(str, len);
|
|
size_t newlen = 0;
|
|
start = 0;
|
|
while (start < len) {
|
|
end = escaped ? (size_t)escaped->car : len;
|
|
if (end > len) end = len;
|
|
spaces = (size_t)nspaces->car;
|
|
size_t esclen = end - start;
|
|
heredoc_count_indent(hinfo, str + start, esclen, spaces, &offset);
|
|
esclen -= offset;
|
|
memcpy(newstr + newlen, str + start + offset, esclen);
|
|
newlen += esclen;
|
|
start = end;
|
|
if (escaped)
|
|
escaped = escaped->cdr;
|
|
nspaces = nspaces->cdr;
|
|
}
|
|
if (newlen < len)
|
|
newstr[newlen] = '\0';
|
|
pair->car = (node*)newlen;
|
|
pair->cdr = (node*)newstr;
|
|
}
|
|
else {
|
|
spaces = (size_t)nspaces->car;
|
|
heredoc_count_indent(hinfo, str, len, spaces, &offset);
|
|
pair->car = (node*)(len - offset);
|
|
pair->cdr = (node*)(str + offset);
|
|
}
|
|
indented = indented->cdr;
|
|
}
|
|
}
|
|
|
|
static void
|
|
heredoc_push_indented(parser_state *p, parser_heredoc_info *hinfo, node *pair, node *escaped, node *nspaces, mrb_bool empty_line)
|
|
{
|
|
hinfo->indented = push(hinfo->indented, cons(pair, cons(escaped, nspaces)));
|
|
while (nspaces) {
|
|
size_t tspaces = (size_t)nspaces->car;
|
|
if ((hinfo->indent == ~0U || tspaces < hinfo->indent) && !empty_line)
|
|
hinfo->indent = tspaces;
|
|
nspaces = nspaces->cdr;
|
|
}
|
|
}
|
|
|
|
static int
|
|
parse_string(parser_state *p)
|
|
{
|
|
int c;
|
|
string_type type = (string_type)p->lex_strterm->type;
|
|
int nest_level = p->lex_strterm->level;
|
|
int beg = p->lex_strterm->paren;
|
|
int end = p->lex_strterm->term;
|
|
parser_heredoc_info *hinfo = (type & STR_FUNC_HEREDOC) ? parsing_heredoc_info(p) : NULL;
|
|
|
|
mrb_bool unindent = hinfo && hinfo->remove_indent;
|
|
mrb_bool head = hinfo && hinfo->line_head;
|
|
mrb_bool empty = TRUE;
|
|
size_t spaces = 0;
|
|
size_t pos = -1;
|
|
node *escaped = NULL;
|
|
node *nspaces = NULL;
|
|
|
|
if (beg == 0) beg = -3; /* should never happen */
|
|
if (end == 0) end = -3;
|
|
newtok(p);
|
|
while ((c = nextc(p)) != end || nest_level != 0) {
|
|
pos++;
|
|
if (hinfo && (c == '\n' || c < 0)) {
|
|
mrb_bool line_head;
|
|
tokadd(p, '\n');
|
|
tokfix(p);
|
|
p->lineno++;
|
|
p->column = 0;
|
|
line_head = hinfo->line_head;
|
|
hinfo->line_head = TRUE;
|
|
if (line_head) {
|
|
/* check whether end of heredoc */
|
|
const char *s = tok(p);
|
|
int len = toklen(p);
|
|
if (hinfo->allow_indent) {
|
|
while (ISSPACE(*s) && len > 0) {
|
|
s++;
|
|
len--;
|
|
}
|
|
}
|
|
if (hinfo->term_len > 0 && len-1 == hinfo->term_len && strncmp(s, hinfo->term, len-1) == 0) {
|
|
heredoc_remove_indent(p, hinfo);
|
|
return tHEREDOC_END;
|
|
}
|
|
}
|
|
if (c < 0) {
|
|
char buf[256];
|
|
const char s1[] = "can't find heredoc delimiter \"";
|
|
const char s2[] = "\" anywhere before EOF";
|
|
|
|
if (sizeof(s1)+sizeof(s2)+strlen(hinfo->term)+1 >= sizeof(buf)) {
|
|
yyerror(NULL, p, "can't find heredoc delimiter anywhere before EOF");
|
|
}
|
|
else {
|
|
strcpy(buf, s1);
|
|
strcat(buf, hinfo->term);
|
|
strcat(buf, s2);
|
|
yyerror(NULL, p, buf);
|
|
}
|
|
return 0;
|
|
}
|
|
pylval.nd = new_str_tok(p);
|
|
if (unindent && head) {
|
|
nspaces = push(nspaces, int_to_node(spaces));
|
|
heredoc_push_indented(p, hinfo, pylval.nd, escaped, nspaces, empty && line_head);
|
|
}
|
|
return tHD_STRING_MID;
|
|
}
|
|
if (unindent && empty) {
|
|
if (c == '\t')
|
|
spaces += 8;
|
|
else if (ISSPACE(c))
|
|
spaces++;
|
|
else
|
|
empty = FALSE;
|
|
}
|
|
if (c < 0) {
|
|
yyerror(NULL, p, "unterminated string meets end of file");
|
|
return 0;
|
|
}
|
|
else if (c == beg) {
|
|
nest_level++;
|
|
p->lex_strterm->level = nest_level;
|
|
}
|
|
else if (c == end) {
|
|
nest_level--;
|
|
p->lex_strterm->level = nest_level;
|
|
}
|
|
else if (c == '\\') {
|
|
c = nextc(p);
|
|
if (type & STR_FUNC_EXPAND) {
|
|
if (c == end || c == beg) {
|
|
tokadd(p, c);
|
|
}
|
|
else if (c == '\n') {
|
|
p->lineno++;
|
|
p->column = 0;
|
|
if (unindent) {
|
|
nspaces = push(nspaces, int_to_node(spaces));
|
|
escaped = push(escaped, int_to_node(pos));
|
|
pos--;
|
|
empty = TRUE;
|
|
spaces = 0;
|
|
}
|
|
if (type & STR_FUNC_ARRAY) {
|
|
tokadd(p, '\n');
|
|
}
|
|
}
|
|
else if (type & STR_FUNC_REGEXP) {
|
|
tokadd(p, '\\');
|
|
tokadd(p, c);
|
|
}
|
|
else if (c == 'u' && peek(p, '{')) {
|
|
/* \u{xxxx xxxx xxxx} form */
|
|
nextc(p);
|
|
while (1) {
|
|
do c = nextc(p); while (ISSPACE(c));
|
|
if (c == '}') break;
|
|
pushback(p, c);
|
|
c = read_escape_unicode(p, 8);
|
|
if (c < 0) break;
|
|
tokadd(p, -c);
|
|
}
|
|
if (hinfo)
|
|
hinfo->line_head = FALSE;
|
|
}
|
|
else {
|
|
pushback(p, c);
|
|
tokadd(p, read_escape(p));
|
|
if (hinfo)
|
|
hinfo->line_head = FALSE;
|
|
}
|
|
}
|
|
else {
|
|
if (c != beg && c != end) {
|
|
if (c == '\n') {
|
|
p->lineno++;
|
|
p->column = 0;
|
|
}
|
|
if (!(c == '\\' || ((type & STR_FUNC_ARRAY) && ISSPACE(c)))) {
|
|
tokadd(p, '\\');
|
|
}
|
|
}
|
|
tokadd(p, c);
|
|
}
|
|
continue;
|
|
}
|
|
else if ((c == '#') && (type & STR_FUNC_EXPAND)) {
|
|
c = nextc(p);
|
|
if (c == '{') {
|
|
tokfix(p);
|
|
p->lstate = EXPR_BEG;
|
|
p->cmd_start = TRUE;
|
|
pylval.nd = new_str_tok(p);
|
|
if (hinfo) {
|
|
if (unindent && head) {
|
|
nspaces = push(nspaces, int_to_node(spaces));
|
|
heredoc_push_indented(p, hinfo, pylval.nd, escaped, nspaces, FALSE);
|
|
}
|
|
hinfo->line_head = FALSE;
|
|
return tHD_STRING_PART;
|
|
}
|
|
return tSTRING_PART;
|
|
}
|
|
tokadd(p, '#');
|
|
pushback(p, c);
|
|
continue;
|
|
}
|
|
if ((type & STR_FUNC_ARRAY) && ISSPACE(c)) {
|
|
if (toklen(p) == 0) {
|
|
do {
|
|
if (c == '\n') {
|
|
p->lineno++;
|
|
p->column = 0;
|
|
heredoc_treat_nextline(p);
|
|
if (p->parsing_heredoc != NULL) {
|
|
return tHD_LITERAL_DELIM;
|
|
}
|
|
}
|
|
c = nextc(p);
|
|
} while (ISSPACE(c));
|
|
pushback(p, c);
|
|
return tLITERAL_DELIM;
|
|
}
|
|
else {
|
|
pushback(p, c);
|
|
tokfix(p);
|
|
pylval.nd = new_str_tok(p);
|
|
return tSTRING_MID;
|
|
}
|
|
}
|
|
if (c == '\n') {
|
|
p->lineno++;
|
|
p->column = 0;
|
|
}
|
|
tokadd(p, c);
|
|
}
|
|
|
|
tokfix(p);
|
|
p->lstate = EXPR_END;
|
|
end_strterm(p);
|
|
|
|
if (type & STR_FUNC_XQUOTE) {
|
|
pylval.nd = new_str_tok(p);
|
|
return tXSTRING;
|
|
}
|
|
|
|
if (type & STR_FUNC_REGEXP) {
|
|
int f = 0;
|
|
int re_opt;
|
|
int pattern_len = toklen(p);
|
|
char *s = strndup(tok(p), pattern_len);
|
|
char flags[3];
|
|
char *flag = flags;
|
|
char enc = '\0';
|
|
char *encp;
|
|
char *dup;
|
|
|
|
newtok(p);
|
|
while (re_opt = nextc(p), re_opt >= 0 && ISALPHA(re_opt)) {
|
|
switch (re_opt) {
|
|
case 'i': f |= 1; break;
|
|
case 'x': f |= 2; break;
|
|
case 'm': f |= 4; break;
|
|
case 'u': f |= 16; break;
|
|
case 'n': f |= 32; break;
|
|
case 'o': break;
|
|
default: tokadd(p, re_opt); break;
|
|
}
|
|
}
|
|
pushback(p, re_opt);
|
|
if (toklen(p)) {
|
|
char msg[128];
|
|
|
|
strcpy(msg, "unknown regexp option");
|
|
tokfix(p);
|
|
if (toklen(p) > 1) {
|
|
strcat(msg, "s");
|
|
}
|
|
strcat(msg, " - ");
|
|
strncat(msg, tok(p), sizeof(msg) - strlen(msg) - 1);
|
|
yyerror(NULL, p, msg);
|
|
}
|
|
if (f != 0) {
|
|
if (f & 1) *flag++ = 'i';
|
|
if (f & 2) *flag++ = 'x';
|
|
if (f & 4) *flag++ = 'm';
|
|
if (f & 16) enc = 'u';
|
|
if (f & 32) enc = 'n';
|
|
}
|
|
if (flag > flags) {
|
|
dup = strndup(flags, (size_t)(flag - flags));
|
|
}
|
|
else {
|
|
dup = NULL;
|
|
}
|
|
if (enc) {
|
|
encp = strndup(&enc, 1);
|
|
}
|
|
else {
|
|
encp = NULL;
|
|
}
|
|
pylval.nd = cons(cons(int_to_node(pattern_len), (node*)s), cons((node*)dup, (node*)encp));
|
|
|
|
return tREGEXP;
|
|
}
|
|
pylval.nd = new_str_tok(p);
|
|
|
|
return tSTRING;
|
|
}
|
|
|
|
static int
|
|
number_literal_suffix(parser_state *p)
|
|
{
|
|
int c, result = 0;
|
|
node *list = 0;
|
|
int column = p->column;
|
|
int mask = NUM_SUFFIX_R|NUM_SUFFIX_I;
|
|
|
|
while ((c = nextc(p)) != -1) {
|
|
list = push(list, int_to_node(c));
|
|
|
|
if ((mask & NUM_SUFFIX_I) && c == 'i') {
|
|
result |= (mask & NUM_SUFFIX_I);
|
|
mask &= ~NUM_SUFFIX_I;
|
|
/* r after i, rational of complex is disallowed */
|
|
mask &= ~NUM_SUFFIX_R;
|
|
continue;
|
|
}
|
|
if ((mask & NUM_SUFFIX_R) && c == 'r') {
|
|
result |= (mask & NUM_SUFFIX_R);
|
|
mask &= ~NUM_SUFFIX_R;
|
|
continue;
|
|
}
|
|
if (!ISASCII(c) || ISALPHA(c) || c == '_') {
|
|
p->column = column;
|
|
if (p->pb) {
|
|
p->pb = append(list, p->pb);
|
|
}
|
|
else {
|
|
p->pb = list;
|
|
}
|
|
return 0;
|
|
}
|
|
pushback(p, c);
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static int
|
|
heredoc_identifier(parser_state *p)
|
|
{
|
|
int c;
|
|
int type = str_heredoc;
|
|
mrb_bool indent = FALSE;
|
|
mrb_bool squiggly = FALSE;
|
|
mrb_bool quote = FALSE;
|
|
node *newnode;
|
|
parser_heredoc_info *info;
|
|
|
|
c = nextc(p);
|
|
if (ISSPACE(c) || c == '=') {
|
|
pushback(p, c);
|
|
return 0;
|
|
}
|
|
if (c == '-' || c == '~') {
|
|
if (c == '-')
|
|
indent = TRUE;
|
|
if (c == '~')
|
|
squiggly = TRUE;
|
|
c = nextc(p);
|
|
}
|
|
if (c == '\'' || c == '"') {
|
|
int term = c;
|
|
if (c == '\'')
|
|
quote = TRUE;
|
|
newtok(p);
|
|
while ((c = nextc(p)) >= 0 && c != term) {
|
|
if (c == '\n') {
|
|
c = -1;
|
|
break;
|
|
}
|
|
tokadd(p, c);
|
|
}
|
|
if (c < 0) {
|
|
yyerror(NULL, p, "unterminated here document identifier");
|
|
return 0;
|
|
}
|
|
}
|
|
else {
|
|
if (c < 0) {
|
|
return 0; /* missing here document identifier */
|
|
}
|
|
if (! identchar(c)) {
|
|
pushback(p, c);
|
|
if (indent) pushback(p, '-');
|
|
if (squiggly) pushback(p, '~');
|
|
return 0;
|
|
}
|
|
newtok(p);
|
|
do {
|
|
tokadd(p, c);
|
|
} while ((c = nextc(p)) >= 0 && identchar(c));
|
|
pushback(p, c);
|
|
}
|
|
tokfix(p);
|
|
newnode = new_heredoc(p, &info);
|
|
info->term = strndup(tok(p), toklen(p));
|
|
info->term_len = toklen(p);
|
|
if (! quote)
|
|
type |= STR_FUNC_EXPAND;
|
|
info->type = (string_type)type;
|
|
info->allow_indent = indent || squiggly;
|
|
info->remove_indent = squiggly;
|
|
info->indent = ~0U;
|
|
info->indented = NULL;
|
|
info->line_head = TRUE;
|
|
info->doc = NULL;
|
|
p->heredocs_from_nextline = push(p->heredocs_from_nextline, newnode);
|
|
p->lstate = EXPR_END;
|
|
|
|
pylval.nd = newnode;
|
|
return tHEREDOC_BEG;
|
|
}
|
|
|
|
static int
|
|
arg_ambiguous(parser_state *p)
|
|
{
|
|
yywarning(p, "ambiguous first argument; put parentheses or even spaces");
|
|
return 1;
|
|
}
|
|
|
|
#include "lex.def"
|
|
|
|
static int
|
|
parser_yylex(parser_state *p)
|
|
{
|
|
int32_t c;
|
|
int nlines = 1;
|
|
int space_seen = 0;
|
|
int cmd_state;
|
|
enum mrb_lex_state_enum last_state;
|
|
int token_column;
|
|
|
|
if (p->lex_strterm) {
|
|
if (is_strterm_type(p, STR_FUNC_HEREDOC)) {
|
|
if (p->parsing_heredoc != NULL)
|
|
return parse_string(p);
|
|
}
|
|
else
|
|
return parse_string(p);
|
|
}
|
|
cmd_state = p->cmd_start;
|
|
p->cmd_start = FALSE;
|
|
retry:
|
|
last_state = p->lstate;
|
|
switch (c = nextc(p)) {
|
|
case '\004': /* ^D */
|
|
case '\032': /* ^Z */
|
|
case '\0': /* NUL */
|
|
case -1: /* end of script. */
|
|
if (p->heredocs_from_nextline)
|
|
goto maybe_heredoc;
|
|
return 0;
|
|
|
|
/* white spaces */
|
|
case ' ': case '\t': case '\f': case '\r':
|
|
case '\13': /* '\v' */
|
|
space_seen = 1;
|
|
goto retry;
|
|
|
|
case '#': /* it's a comment */
|
|
skip(p, '\n');
|
|
/* fall through */
|
|
case -2: /* end of a file */
|
|
case '\n':
|
|
maybe_heredoc:
|
|
heredoc_treat_nextline(p);
|
|
p->column = 0;
|
|
switch (p->lstate) {
|
|
case EXPR_BEG:
|
|
case EXPR_FNAME:
|
|
case EXPR_DOT:
|
|
case EXPR_CLASS:
|
|
case EXPR_VALUE:
|
|
p->lineno++;
|
|
if (p->parsing_heredoc != NULL) {
|
|
if (p->lex_strterm) {
|
|
return parse_string(p);
|
|
}
|
|
}
|
|
goto retry;
|
|
default:
|
|
break;
|
|
}
|
|
if (p->parsing_heredoc != NULL) {
|
|
pylval.num = nlines;
|
|
return '\n';
|
|
}
|
|
while ((c = nextc(p))) {
|
|
switch (c) {
|
|
case ' ': case '\t': case '\f': case '\r':
|
|
case '\13': /* '\v' */
|
|
space_seen = 1;
|
|
break;
|
|
case '#': /* comment as a whitespace */
|
|
skip(p, '\n');
|
|
nlines++;
|
|
break;
|
|
case '.':
|
|
if (!peek(p, '.')) {
|
|
pushback(p, '.');
|
|
p->lineno+=nlines; nlines=1;
|
|
goto retry;
|
|
}
|
|
pushback(p, c);
|
|
goto normal_newline;
|
|
case '&':
|
|
if (peek(p, '.')) {
|
|
pushback(p, '&');
|
|
p->lineno+=nlines; nlines=1;
|
|
goto retry;
|
|
}
|
|
pushback(p, c);
|
|
goto normal_newline;
|
|
case -1: /* EOF */
|
|
case -2: /* end of a file */
|
|
goto normal_newline;
|
|
default:
|
|
pushback(p, c);
|
|
goto normal_newline;
|
|
}
|
|
}
|
|
normal_newline:
|
|
p->cmd_start = TRUE;
|
|
p->lstate = EXPR_BEG;
|
|
pylval.num = nlines;
|
|
return '\n';
|
|
|
|
case '*':
|
|
if ((c = nextc(p)) == '*') {
|
|
if ((c = nextc(p)) == '=') {
|
|
pylval.id = intern_op(pow);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
pushback(p, c);
|
|
if (IS_SPCARG(c)) {
|
|
yywarning(p, "'**' interpreted as argument prefix");
|
|
c = tDSTAR;
|
|
}
|
|
else if (IS_BEG()) {
|
|
c = tDSTAR;
|
|
}
|
|
else {
|
|
c = tPOW; /* "**", "argument prefix" */
|
|
}
|
|
}
|
|
else {
|
|
if (c == '=') {
|
|
pylval.id = intern_op(mul);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
pushback(p, c);
|
|
if (IS_SPCARG(c)) {
|
|
yywarning(p, "'*' interpreted as argument prefix");
|
|
c = tSTAR;
|
|
}
|
|
else if (IS_BEG()) {
|
|
c = tSTAR;
|
|
}
|
|
else {
|
|
c = '*';
|
|
}
|
|
}
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_BEG;
|
|
}
|
|
return c;
|
|
|
|
case '!':
|
|
c = nextc(p);
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
if (c == '@') {
|
|
return '!';
|
|
}
|
|
}
|
|
else {
|
|
p->lstate = EXPR_BEG;
|
|
}
|
|
if (c == '=') {
|
|
return tNEQ;
|
|
}
|
|
if (c == '~') {
|
|
return tNMATCH;
|
|
}
|
|
pushback(p, c);
|
|
return '!';
|
|
|
|
case '=':
|
|
if (p->column == 1) {
|
|
static const char begin[] = "begin";
|
|
static const char end[] = "\n=end";
|
|
if (peeks(p, begin)) {
|
|
c = peekc_n(p, sizeof(begin)-1);
|
|
if (c < 0 || ISSPACE(c)) {
|
|
do {
|
|
if (!skips(p, end)) {
|
|
yyerror(NULL, p, "embedded document meets end of file");
|
|
return 0;
|
|
}
|
|
c = nextc(p);
|
|
} while (!(c < 0 || ISSPACE(c)));
|
|
if (c != '\n') skip(p, '\n');
|
|
p->lineno+=nlines; nlines=1;
|
|
p->column = 0;
|
|
goto retry;
|
|
}
|
|
}
|
|
}
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_BEG;
|
|
}
|
|
if ((c = nextc(p)) == '=') {
|
|
if ((c = nextc(p)) == '=') {
|
|
return tEQQ;
|
|
}
|
|
pushback(p, c);
|
|
return tEQ;
|
|
}
|
|
if (c == '~') {
|
|
return tMATCH;
|
|
}
|
|
else if (c == '>') {
|
|
return tASSOC;
|
|
}
|
|
pushback(p, c);
|
|
return '=';
|
|
|
|
case '<':
|
|
c = nextc(p);
|
|
if (c == '<' &&
|
|
p->lstate != EXPR_DOT &&
|
|
p->lstate != EXPR_CLASS &&
|
|
!IS_END() &&
|
|
(!IS_ARG() || space_seen)) {
|
|
int token = heredoc_identifier(p);
|
|
if (token)
|
|
return token;
|
|
}
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_BEG;
|
|
if (p->lstate == EXPR_CLASS) {
|
|
p->cmd_start = TRUE;
|
|
}
|
|
}
|
|
if (c == '=') {
|
|
if ((c = nextc(p)) == '>') {
|
|
return tCMP;
|
|
}
|
|
pushback(p, c);
|
|
return tLEQ;
|
|
}
|
|
if (c == '<') {
|
|
if ((c = nextc(p)) == '=') {
|
|
pylval.id = intern_op(lshift);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
pushback(p, c);
|
|
return tLSHFT;
|
|
}
|
|
pushback(p, c);
|
|
return '<';
|
|
|
|
case '>':
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_BEG;
|
|
}
|
|
if ((c = nextc(p)) == '=') {
|
|
return tGEQ;
|
|
}
|
|
if (c == '>') {
|
|
if ((c = nextc(p)) == '=') {
|
|
pylval.id = intern_op(rshift);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
pushback(p, c);
|
|
return tRSHFT;
|
|
}
|
|
pushback(p, c);
|
|
return '>';
|
|
|
|
case '"':
|
|
p->lex_strterm = new_strterm(p, str_dquote, '"', 0);
|
|
return tSTRING_BEG;
|
|
|
|
case '\'':
|
|
p->lex_strterm = new_strterm(p, str_squote, '\'', 0);
|
|
return parse_string(p);
|
|
|
|
case '`':
|
|
if (p->lstate == EXPR_FNAME) {
|
|
p->lstate = EXPR_ENDFN;
|
|
return '`';
|
|
}
|
|
if (p->lstate == EXPR_DOT) {
|
|
if (cmd_state)
|
|
p->lstate = EXPR_CMDARG;
|
|
else
|
|
p->lstate = EXPR_ARG;
|
|
return '`';
|
|
}
|
|
p->lex_strterm = new_strterm(p, str_xquote, '`', 0);
|
|
return tXSTRING_BEG;
|
|
|
|
case '?':
|
|
if (IS_END()) {
|
|
p->lstate = EXPR_VALUE;
|
|
return '?';
|
|
}
|
|
c = nextc(p);
|
|
if (c < 0) {
|
|
yyerror(NULL, p, "incomplete character syntax");
|
|
return 0;
|
|
}
|
|
if (ISSPACE(c)) {
|
|
if (!IS_ARG()) {
|
|
int c2;
|
|
switch (c) {
|
|
case ' ':
|
|
c2 = 's';
|
|
break;
|
|
case '\n':
|
|
c2 = 'n';
|
|
break;
|
|
case '\t':
|
|
c2 = 't';
|
|
break;
|
|
case '\v':
|
|
c2 = 'v';
|
|
break;
|
|
case '\r':
|
|
c2 = 'r';
|
|
break;
|
|
case '\f':
|
|
c2 = 'f';
|
|
break;
|
|
default:
|
|
c2 = 0;
|
|
break;
|
|
}
|
|
if (c2) {
|
|
char buf[256];
|
|
char cc[] = { (char)c2, '\0' };
|
|
|
|
strcpy(buf, "invalid character syntax; use ?\\");
|
|
strncat(buf, cc, 2);
|
|
yyerror(NULL, p, buf);
|
|
}
|
|
}
|
|
ternary:
|
|
pushback(p, c);
|
|
p->lstate = EXPR_VALUE;
|
|
return '?';
|
|
}
|
|
newtok(p);
|
|
/* need support UTF-8 if configured */
|
|
if ((ISALNUM(c) || c == '_')) {
|
|
int c2 = nextc(p);
|
|
pushback(p, c2);
|
|
if ((ISALNUM(c2) || c2 == '_')) {
|
|
goto ternary;
|
|
}
|
|
}
|
|
if (c == '\\') {
|
|
c = read_escape(p);
|
|
tokadd(p, c);
|
|
}
|
|
else {
|
|
tokadd(p, c);
|
|
}
|
|
tokfix(p);
|
|
pylval.nd = new_str_tok(p);
|
|
p->lstate = EXPR_END;
|
|
return tCHAR;
|
|
|
|
case '&':
|
|
if ((c = nextc(p)) == '&') {
|
|
p->lstate = EXPR_BEG;
|
|
if ((c = nextc(p)) == '=') {
|
|
pylval.id = intern_op(andand);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
pushback(p, c);
|
|
return tANDOP;
|
|
}
|
|
else if (c == '.') {
|
|
p->lstate = EXPR_DOT;
|
|
return tANDDOT;
|
|
}
|
|
else if (c == '=') {
|
|
pylval.id = intern_op(and);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
pushback(p, c);
|
|
if (IS_SPCARG(c)) {
|
|
yywarning(p, "'&' interpreted as argument prefix");
|
|
c = tAMPER;
|
|
}
|
|
else if (IS_BEG()) {
|
|
c = tAMPER;
|
|
}
|
|
else {
|
|
c = '&';
|
|
}
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_BEG;
|
|
}
|
|
return c;
|
|
|
|
case '|':
|
|
if ((c = nextc(p)) == '|') {
|
|
p->lstate = EXPR_BEG;
|
|
if ((c = nextc(p)) == '=') {
|
|
pylval.id = intern_op(oror);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
pushback(p, c);
|
|
return tOROP;
|
|
}
|
|
if (c == '=') {
|
|
pylval.id = intern_op(or);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_BEG;
|
|
}
|
|
pushback(p, c);
|
|
return '|';
|
|
|
|
case '+':
|
|
c = nextc(p);
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
if (c == '@') {
|
|
return tUPLUS;
|
|
}
|
|
pushback(p, c);
|
|
return '+';
|
|
}
|
|
if (c == '=') {
|
|
pylval.id = intern_op(add);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) {
|
|
p->lstate = EXPR_BEG;
|
|
pushback(p, c);
|
|
if (c >= 0 && ISDIGIT(c)) {
|
|
c = '+';
|
|
goto start_num;
|
|
}
|
|
return tUPLUS;
|
|
}
|
|
p->lstate = EXPR_BEG;
|
|
pushback(p, c);
|
|
return '+';
|
|
|
|
case '-':
|
|
c = nextc(p);
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
if (c == '@') {
|
|
return tUMINUS;
|
|
}
|
|
pushback(p, c);
|
|
return '-';
|
|
}
|
|
if (c == '=') {
|
|
pylval.id = intern_op(sub);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
if (c == '>') {
|
|
p->lstate = EXPR_ENDFN;
|
|
return tLAMBDA;
|
|
}
|
|
if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) {
|
|
p->lstate = EXPR_BEG;
|
|
pushback(p, c);
|
|
if (c >= 0 && ISDIGIT(c)) {
|
|
return tUMINUS_NUM;
|
|
}
|
|
return tUMINUS;
|
|
}
|
|
p->lstate = EXPR_BEG;
|
|
pushback(p, c);
|
|
return '-';
|
|
|
|
case '.':
|
|
{
|
|
int is_beg = IS_BEG();
|
|
p->lstate = EXPR_MID;
|
|
if ((c = nextc(p)) == '.') {
|
|
if ((c = nextc(p)) == '.') {
|
|
return is_beg ? tBDOT3 : tDOT3;
|
|
}
|
|
pushback(p, c);
|
|
return is_beg ? tBDOT2 : tDOT2;
|
|
}
|
|
pushback(p, c);
|
|
p->lstate = EXPR_BEG;
|
|
if (c >= 0 && ISDIGIT(c)) {
|
|
yyerror(NULL, p, "no .<digit> floating literal anymore; put 0 before dot");
|
|
}
|
|
p->lstate = EXPR_DOT;
|
|
return '.';
|
|
}
|
|
|
|
start_num:
|
|
case '0': case '1': case '2': case '3': case '4':
|
|
case '5': case '6': case '7': case '8': case '9':
|
|
{
|
|
int is_float, seen_point, seen_e, nondigit;
|
|
int suffix = 0;
|
|
|
|
is_float = seen_point = seen_e = nondigit = 0;
|
|
p->lstate = EXPR_END;
|
|
newtok(p);
|
|
if (c == '-') {
|
|
tokadd(p, c);
|
|
c = nextc(p);
|
|
}
|
|
else if (c == '+') {
|
|
c = nextc(p);
|
|
}
|
|
if (c == '0') {
|
|
#define no_digits() do {yyerror(NULL, p,"numeric literal without digits"); return 0;} while (0)
|
|
int start = toklen(p);
|
|
c = nextc(p);
|
|
if (c == 'x' || c == 'X') {
|
|
/* hexadecimal */
|
|
c = nextc(p);
|
|
if (c >= 0 && ISXDIGIT(c)) {
|
|
do {
|
|
if (c == '_') {
|
|
if (nondigit) break;
|
|
nondigit = c;
|
|
continue;
|
|
}
|
|
if (!ISXDIGIT(c)) break;
|
|
nondigit = 0;
|
|
tokadd(p, tolower(c));
|
|
} while ((c = nextc(p)) >= 0);
|
|
}
|
|
pushback(p, c);
|
|
tokfix(p);
|
|
if (toklen(p) == start) {
|
|
no_digits();
|
|
}
|
|
else if (nondigit) goto trailing_uc;
|
|
suffix = number_literal_suffix(p);
|
|
pylval.nd = new_int(p, tok(p), 16, suffix);
|
|
return tINTEGER;
|
|
}
|
|
if (c == 'b' || c == 'B') {
|
|
/* binary */
|
|
c = nextc(p);
|
|
if (c == '0' || c == '1') {
|
|
do {
|
|
if (c == '_') {
|
|
if (nondigit) break;
|
|
nondigit = c;
|
|
continue;
|
|
}
|
|
if (c != '0' && c != '1') break;
|
|
nondigit = 0;
|
|
tokadd(p, c);
|
|
} while ((c = nextc(p)) >= 0);
|
|
}
|
|
pushback(p, c);
|
|
tokfix(p);
|
|
if (toklen(p) == start) {
|
|
no_digits();
|
|
}
|
|
else if (nondigit) goto trailing_uc;
|
|
suffix = number_literal_suffix(p);
|
|
pylval.nd = new_int(p, tok(p), 2, suffix);
|
|
return tINTEGER;
|
|
}
|
|
if (c == 'd' || c == 'D') {
|
|
/* decimal */
|
|
c = nextc(p);
|
|
if (c >= 0 && ISDIGIT(c)) {
|
|
do {
|
|
if (c == '_') {
|
|
if (nondigit) break;
|
|
nondigit = c;
|
|
continue;
|
|
}
|
|
if (!ISDIGIT(c)) break;
|
|
nondigit = 0;
|
|
tokadd(p, c);
|
|
} while ((c = nextc(p)) >= 0);
|
|
}
|
|
pushback(p, c);
|
|
tokfix(p);
|
|
if (toklen(p) == start) {
|
|
no_digits();
|
|
}
|
|
else if (nondigit) goto trailing_uc;
|
|
suffix = number_literal_suffix(p);
|
|
pylval.nd = new_int(p, tok(p), 10, suffix);
|
|
return tINTEGER;
|
|
}
|
|
if (c == '_') {
|
|
/* 0_0 */
|
|
goto octal_number;
|
|
}
|
|
if (c == 'o' || c == 'O') {
|
|
/* prefixed octal */
|
|
c = nextc(p);
|
|
if (c < 0 || c == '_' || !ISDIGIT(c)) {
|
|
no_digits();
|
|
}
|
|
}
|
|
if (c >= '0' && c <= '7') {
|
|
/* octal */
|
|
octal_number:
|
|
do {
|
|
if (c == '_') {
|
|
if (nondigit) break;
|
|
nondigit = c;
|
|
continue;
|
|
}
|
|
if (c < '0' || c > '9') break;
|
|
if (c > '7') goto invalid_octal;
|
|
nondigit = 0;
|
|
tokadd(p, c);
|
|
} while ((c = nextc(p)) >= 0);
|
|
|
|
if (toklen(p) > start) {
|
|
pushback(p, c);
|
|
tokfix(p);
|
|
if (nondigit) goto trailing_uc;
|
|
suffix = number_literal_suffix(p);
|
|
pylval.nd = new_int(p, tok(p), 8, suffix);
|
|
return tINTEGER;
|
|
}
|
|
if (nondigit) {
|
|
pushback(p, c);
|
|
goto trailing_uc;
|
|
}
|
|
}
|
|
if (c > '7' && c <= '9') {
|
|
invalid_octal:
|
|
yyerror(NULL, p, "Invalid octal digit");
|
|
}
|
|
else if (c == '.' || c == 'e' || c == 'E') {
|
|
tokadd(p, '0');
|
|
}
|
|
else {
|
|
pushback(p, c);
|
|
suffix = number_literal_suffix(p);
|
|
pylval.nd = new_int(p, "0", 10, suffix);
|
|
return tINTEGER;
|
|
}
|
|
}
|
|
|
|
for (;;) {
|
|
switch (c) {
|
|
case '0': case '1': case '2': case '3': case '4':
|
|
case '5': case '6': case '7': case '8': case '9':
|
|
nondigit = 0;
|
|
tokadd(p, c);
|
|
break;
|
|
|
|
case '.':
|
|
if (nondigit) goto trailing_uc;
|
|
if (seen_point || seen_e) {
|
|
goto decode_num;
|
|
}
|
|
else {
|
|
int c0 = nextc(p);
|
|
if (c0 < 0 || !ISDIGIT(c0)) {
|
|
pushback(p, c0);
|
|
goto decode_num;
|
|
}
|
|
c = c0;
|
|
}
|
|
tokadd(p, '.');
|
|
tokadd(p, c);
|
|
is_float++;
|
|
seen_point++;
|
|
nondigit = 0;
|
|
break;
|
|
|
|
case 'e':
|
|
case 'E':
|
|
if (nondigit) {
|
|
pushback(p, c);
|
|
c = nondigit;
|
|
goto decode_num;
|
|
}
|
|
if (seen_e) {
|
|
goto decode_num;
|
|
}
|
|
tokadd(p, c);
|
|
seen_e++;
|
|
is_float++;
|
|
nondigit = c;
|
|
c = nextc(p);
|
|
if (c != '-' && c != '+') continue;
|
|
tokadd(p, c);
|
|
nondigit = c;
|
|
break;
|
|
|
|
case '_': /* '_' in number just ignored */
|
|
if (nondigit) goto decode_num;
|
|
nondigit = c;
|
|
break;
|
|
|
|
default:
|
|
goto decode_num;
|
|
}
|
|
c = nextc(p);
|
|
}
|
|
|
|
decode_num:
|
|
pushback(p, c);
|
|
if (nondigit) {
|
|
trailing_uc:
|
|
yyerror_c(p, "trailing non digit in number: ", (char)nondigit);
|
|
}
|
|
tokfix(p);
|
|
if (is_float) {
|
|
#ifdef MRB_NO_FLOAT
|
|
yywarning_s(p, "floating-point numbers are not supported", tok(p));
|
|
pylval.nd = new_int(p, "0", 10, 0);
|
|
return tINTEGER;
|
|
#else
|
|
double d;
|
|
|
|
if (!mrb_read_float(tok(p), NULL, &d)) {
|
|
yywarning_s(p, "corrupted float value", tok(p));
|
|
}
|
|
suffix = number_literal_suffix(p);
|
|
if (seen_e && (suffix & NUM_SUFFIX_R)) {
|
|
pushback(p, 'r');
|
|
suffix &= ~NUM_SUFFIX_R;
|
|
}
|
|
pylval.nd = new_float(p, tok(p), suffix);
|
|
return tFLOAT;
|
|
#endif
|
|
}
|
|
suffix = number_literal_suffix(p);
|
|
pylval.nd = new_int(p, tok(p), 10, suffix);
|
|
return tINTEGER;
|
|
}
|
|
|
|
case ')':
|
|
case ']':
|
|
p->paren_nest--;
|
|
/* fall through */
|
|
case '}':
|
|
COND_LEXPOP();
|
|
CMDARG_LEXPOP();
|
|
if (c == ')')
|
|
p->lstate = EXPR_ENDFN;
|
|
else
|
|
p->lstate = EXPR_END;
|
|
return c;
|
|
|
|
case ':':
|
|
c = nextc(p);
|
|
if (c == ':') {
|
|
if (IS_BEG() || p->lstate == EXPR_CLASS || IS_SPCARG(-1)) {
|
|
p->lstate = EXPR_BEG;
|
|
return tCOLON3;
|
|
}
|
|
p->lstate = EXPR_DOT;
|
|
return tCOLON2;
|
|
}
|
|
if (!space_seen && IS_END()) {
|
|
pushback(p, c);
|
|
p->lstate = EXPR_BEG;
|
|
return tLABEL_TAG;
|
|
}
|
|
if (IS_END() || ISSPACE(c) || c == '#') {
|
|
pushback(p, c);
|
|
p->lstate = EXPR_BEG;
|
|
return ':';
|
|
}
|
|
pushback(p, c);
|
|
p->lstate = EXPR_FNAME;
|
|
return tSYMBEG;
|
|
|
|
case '/':
|
|
if (IS_BEG()) {
|
|
p->lex_strterm = new_strterm(p, str_regexp, '/', 0);
|
|
return tREGEXP_BEG;
|
|
}
|
|
if ((c = nextc(p)) == '=') {
|
|
pylval.id = intern_op(div);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
pushback(p, c);
|
|
if (IS_SPCARG(c)) {
|
|
p->lex_strterm = new_strterm(p, str_regexp, '/', 0);
|
|
return tREGEXP_BEG;
|
|
}
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_BEG;
|
|
}
|
|
return '/';
|
|
|
|
case '^':
|
|
if ((c = nextc(p)) == '=') {
|
|
pylval.id = intern_op(xor);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_BEG;
|
|
}
|
|
pushback(p, c);
|
|
return '^';
|
|
|
|
case ';':
|
|
p->lstate = EXPR_BEG;
|
|
return ';';
|
|
|
|
case ',':
|
|
p->lstate = EXPR_BEG;
|
|
return ',';
|
|
|
|
case '~':
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
if ((c = nextc(p)) != '@') {
|
|
pushback(p, c);
|
|
}
|
|
p->lstate = EXPR_ARG;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_BEG;
|
|
}
|
|
return '~';
|
|
|
|
case '(':
|
|
if (IS_BEG()) {
|
|
c = tLPAREN;
|
|
}
|
|
else if (IS_SPCARG(-1)) {
|
|
c = tLPAREN_ARG;
|
|
}
|
|
else if (p->lstate == EXPR_END && space_seen) {
|
|
c = tLPAREN_ARG;
|
|
}
|
|
p->paren_nest++;
|
|
COND_PUSH(0);
|
|
CMDARG_PUSH(0);
|
|
p->lstate = EXPR_BEG;
|
|
return c;
|
|
|
|
case '[':
|
|
p->paren_nest++;
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
p->paren_nest--;
|
|
if ((c = nextc(p)) == ']') {
|
|
if ((c = nextc(p)) == '=') {
|
|
return tASET;
|
|
}
|
|
pushback(p, c);
|
|
return tAREF;
|
|
}
|
|
pushback(p, c);
|
|
return '[';
|
|
}
|
|
else if (IS_BEG()) {
|
|
c = tLBRACK;
|
|
}
|
|
else if (IS_ARG() && space_seen) {
|
|
c = tLBRACK;
|
|
}
|
|
p->lstate = EXPR_BEG;
|
|
COND_PUSH(0);
|
|
CMDARG_PUSH(0);
|
|
return c;
|
|
|
|
case '{':
|
|
if (p->lpar_beg && p->lpar_beg == p->paren_nest) {
|
|
p->lstate = EXPR_BEG;
|
|
p->lpar_beg = 0;
|
|
p->paren_nest--;
|
|
COND_PUSH(0);
|
|
CMDARG_PUSH(0);
|
|
return tLAMBEG;
|
|
}
|
|
if (IS_ARG() || p->lstate == EXPR_END || p->lstate == EXPR_ENDFN)
|
|
c = '{'; /* block (primary) */
|
|
else if (p->lstate == EXPR_ENDARG)
|
|
c = tLBRACE_ARG; /* block (expr) */
|
|
else
|
|
c = tLBRACE; /* hash */
|
|
COND_PUSH(0);
|
|
CMDARG_PUSH(0);
|
|
p->lstate = EXPR_BEG;
|
|
return c;
|
|
|
|
case '\\':
|
|
c = nextc(p);
|
|
if (c == '\n') {
|
|
p->lineno+=nlines; nlines=1;
|
|
p->column = 0;
|
|
space_seen = 1;
|
|
goto retry; /* skip \\n */
|
|
}
|
|
pushback(p, c);
|
|
return '\\';
|
|
|
|
case '%':
|
|
if (IS_BEG()) {
|
|
int term;
|
|
int paren;
|
|
|
|
c = nextc(p);
|
|
quotation:
|
|
if (c < 0 || !ISALNUM(c)) {
|
|
term = c;
|
|
c = 'Q';
|
|
}
|
|
else {
|
|
term = nextc(p);
|
|
if (ISALNUM(term)) {
|
|
yyerror(NULL, p, "unknown type of %string");
|
|
return 0;
|
|
}
|
|
}
|
|
if (c < 0 || term < 0) {
|
|
yyerror(NULL, p, "unterminated quoted string meets end of file");
|
|
return 0;
|
|
}
|
|
paren = term;
|
|
if (term == '(') term = ')';
|
|
else if (term == '[') term = ']';
|
|
else if (term == '{') term = '}';
|
|
else if (term == '<') term = '>';
|
|
else paren = 0;
|
|
|
|
switch (c) {
|
|
case 'Q':
|
|
p->lex_strterm = new_strterm(p, str_dquote, term, paren);
|
|
return tSTRING_BEG;
|
|
|
|
case 'q':
|
|
p->lex_strterm = new_strterm(p, str_squote, term, paren);
|
|
return parse_string(p);
|
|
|
|
case 'W':
|
|
p->lex_strterm = new_strterm(p, str_dword, term, paren);
|
|
return tWORDS_BEG;
|
|
|
|
case 'w':
|
|
p->lex_strterm = new_strterm(p, str_sword, term, paren);
|
|
return tWORDS_BEG;
|
|
|
|
case 'x':
|
|
p->lex_strterm = new_strterm(p, str_xquote, term, paren);
|
|
return tXSTRING_BEG;
|
|
|
|
case 'r':
|
|
p->lex_strterm = new_strterm(p, str_regexp, term, paren);
|
|
return tREGEXP_BEG;
|
|
|
|
case 's':
|
|
p->lex_strterm = new_strterm(p, str_ssym, term, paren);
|
|
return tSYMBEG;
|
|
|
|
case 'I':
|
|
p->lex_strterm = new_strterm(p, str_dsymbols, term, paren);
|
|
return tSYMBOLS_BEG;
|
|
|
|
case 'i':
|
|
p->lex_strterm = new_strterm(p, str_ssymbols, term, paren);
|
|
return tSYMBOLS_BEG;
|
|
|
|
default:
|
|
yyerror(NULL, p, "unknown type of %string");
|
|
return 0;
|
|
}
|
|
}
|
|
if ((c = nextc(p)) == '=') {
|
|
pylval.id = intern_op(mod);
|
|
p->lstate = EXPR_BEG;
|
|
return tOP_ASGN;
|
|
}
|
|
if (IS_SPCARG(c)) {
|
|
goto quotation;
|
|
}
|
|
if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
|
|
p->lstate = EXPR_ARG;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_BEG;
|
|
}
|
|
pushback(p, c);
|
|
return '%';
|
|
|
|
case '$':
|
|
p->lstate = EXPR_END;
|
|
token_column = newtok(p);
|
|
c = nextc(p);
|
|
if (c < 0) {
|
|
yyerror(NULL, p, "incomplete global variable syntax");
|
|
return 0;
|
|
}
|
|
switch (c) {
|
|
case '_': /* $_: last read line string */
|
|
c = nextc(p);
|
|
if (c >= 0 && identchar(c)) { /* if there is more after _ it is a variable */
|
|
tokadd(p, '$');
|
|
tokadd(p, c);
|
|
break;
|
|
}
|
|
pushback(p, c);
|
|
c = '_';
|
|
/* fall through */
|
|
case '~': /* $~: match-data */
|
|
case '*': /* $*: argv */
|
|
case '$': /* $$: pid */
|
|
case '?': /* $?: last status */
|
|
case '!': /* $!: error string */
|
|
case '@': /* $@: error position */
|
|
case '/': /* $/: input record separator */
|
|
case '\\': /* $\: output record separator */
|
|
case ';': /* $;: field separator */
|
|
case ',': /* $,: output field separator */
|
|
case '.': /* $.: last read line number */
|
|
case '=': /* $=: ignorecase */
|
|
case ':': /* $:: load path */
|
|
case '<': /* $<: reading filename */
|
|
case '>': /* $>: default output handle */
|
|
case '\"': /* $": already loaded files */
|
|
tokadd(p, '$');
|
|
tokadd(p, c);
|
|
tokfix(p);
|
|
pylval.id = intern(tok(p), toklen(p));
|
|
return tGVAR;
|
|
|
|
case '-':
|
|
tokadd(p, '$');
|
|
tokadd(p, c);
|
|
c = nextc(p);
|
|
pushback(p, c);
|
|
gvar:
|
|
tokfix(p);
|
|
pylval.id = intern(tok(p), toklen(p));
|
|
return tGVAR;
|
|
|
|
case '&': /* $&: last match */
|
|
case '`': /* $`: string before last match */
|
|
case '\'': /* $': string after last match */
|
|
case '+': /* $+: string matches last pattern */
|
|
if (last_state == EXPR_FNAME) {
|
|
tokadd(p, '$');
|
|
tokadd(p, c);
|
|
goto gvar;
|
|
}
|
|
pylval.nd = new_back_ref(p, c);
|
|
return tBACK_REF;
|
|
|
|
case '1': case '2': case '3':
|
|
case '4': case '5': case '6':
|
|
case '7': case '8': case '9':
|
|
do {
|
|
tokadd(p, c);
|
|
c = nextc(p);
|
|
} while (c >= 0 && ISDIGIT(c));
|
|
pushback(p, c);
|
|
if (last_state == EXPR_FNAME) goto gvar;
|
|
tokfix(p);
|
|
{
|
|
mrb_int n;
|
|
if (!mrb_read_int(tok(p), NULL, NULL, &n)) {
|
|
yywarning(p, "capture group index too big; always nil");
|
|
return keyword_nil;
|
|
}
|
|
pylval.nd = new_nth_ref(p, (int)n);
|
|
}
|
|
return tNTH_REF;
|
|
|
|
default:
|
|
if (!identchar(c)) {
|
|
pushback(p, c);
|
|
return '$';
|
|
}
|
|
/* fall through */
|
|
case '0':
|
|
tokadd(p, '$');
|
|
}
|
|
break;
|
|
|
|
case '@':
|
|
c = nextc(p);
|
|
token_column = newtok(p);
|
|
tokadd(p, '@');
|
|
if (c == '@') {
|
|
tokadd(p, '@');
|
|
c = nextc(p);
|
|
}
|
|
if (c < 0) {
|
|
if (p->tidx == 1) {
|
|
yyerror(NULL, p, "incomplete instance variable syntax");
|
|
}
|
|
else {
|
|
yyerror(NULL, p, "incomplete class variable syntax");
|
|
}
|
|
return 0;
|
|
}
|
|
else if (ISDIGIT(c)) {
|
|
if (p->tidx == 1) {
|
|
yyerror_c(p, "wrong instance variable name: @", c);
|
|
}
|
|
else {
|
|
yyerror_c(p, "wrong class variable name: @@", c);
|
|
}
|
|
return 0;
|
|
}
|
|
if (!identchar(c)) {
|
|
pushback(p, c);
|
|
return '@';
|
|
}
|
|
break;
|
|
|
|
case '_':
|
|
token_column = newtok(p);
|
|
break;
|
|
|
|
default:
|
|
if (!identchar(c)) {
|
|
char buf[36];
|
|
const char s[] = "Invalid char in expression: 0x";
|
|
const char hexdigits[] = "0123456789ABCDEF";
|
|
|
|
strcpy(buf, s);
|
|
buf[sizeof(s)-1] = hexdigits[(c & 0xf0) >> 4];
|
|
buf[sizeof(s)] = hexdigits[(c & 0x0f)];
|
|
buf[sizeof(s)+1] = 0;
|
|
yyerror(NULL, p, buf);
|
|
goto retry;
|
|
}
|
|
|
|
token_column = newtok(p);
|
|
break;
|
|
}
|
|
|
|
do {
|
|
tokadd(p, c);
|
|
c = nextc(p);
|
|
if (c < 0) break;
|
|
} while (identchar(c));
|
|
if (token_column == 0 && toklen(p) == 7 && (c < 0 || c == '\n') &&
|
|
strncmp(tok(p), "__END__", toklen(p)) == 0)
|
|
return -1;
|
|
|
|
switch (tok(p)[0]) {
|
|
case '@': case '$':
|
|
pushback(p, c);
|
|
break;
|
|
default:
|
|
if ((c == '!' || c == '?') && !peek(p, '=')) {
|
|
tokadd(p, c);
|
|
}
|
|
else {
|
|
pushback(p, c);
|
|
}
|
|
}
|
|
tokfix(p);
|
|
{
|
|
int result = 0;
|
|
|
|
switch (tok(p)[0]) {
|
|
case '$':
|
|
p->lstate = EXPR_END;
|
|
result = tGVAR;
|
|
break;
|
|
case '@':
|
|
p->lstate = EXPR_END;
|
|
if (tok(p)[1] == '@')
|
|
result = tCVAR;
|
|
else
|
|
result = tIVAR;
|
|
break;
|
|
|
|
case '_':
|
|
if (toklen(p) == 2 && ISDIGIT(tok(p)[1]) && p->nvars) {
|
|
int n = tok(p)[1] - '0';
|
|
int nvar;
|
|
|
|
if (n > 0) {
|
|
nvar = node_to_int(p->nvars->car);
|
|
if (nvar != -2) { /* numbered parameters never appear on toplevel */
|
|
pylval.num = n;
|
|
p->lstate = EXPR_END;
|
|
return tNUMPARAM;
|
|
}
|
|
}
|
|
}
|
|
/* fall through */
|
|
default:
|
|
if (toklast(p) == '!' || toklast(p) == '?') {
|
|
result = tFID;
|
|
}
|
|
else {
|
|
if (p->lstate == EXPR_FNAME) {
|
|
if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') &&
|
|
(!peek(p, '=') || (peek_n(p, '>', 1)))) {
|
|
result = tIDENTIFIER;
|
|
tokadd(p, c);
|
|
tokfix(p);
|
|
}
|
|
else {
|
|
pushback(p, c);
|
|
}
|
|
if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') &&
|
|
(!peek(p, '=') || (peek_n(p, '>', 1)))) {
|
|
result = tIDENTIFIER;
|
|
tokadd(p, c);
|
|
tokfix(p);
|
|
}
|
|
else {
|
|
pushback(p, c);
|
|
}
|
|
}
|
|
if (result == 0 && ISUPPER(tok(p)[0])) {
|
|
result = tCONSTANT;
|
|
}
|
|
else {
|
|
result = tIDENTIFIER;
|
|
}
|
|
}
|
|
|
|
if (IS_LABEL_POSSIBLE()) {
|
|
if (IS_LABEL_SUFFIX(0)) {
|
|
p->lstate = EXPR_END;
|
|
tokfix(p);
|
|
pylval.id = intern(tok(p), toklen(p));
|
|
return tIDENTIFIER;
|
|
}
|
|
}
|
|
if (p->lstate != EXPR_DOT) {
|
|
const struct kwtable *kw;
|
|
|
|
/* See if it is a reserved word. */
|
|
kw = mrb_reserved_word(tok(p), toklen(p));
|
|
if (kw) {
|
|
enum mrb_lex_state_enum state = p->lstate;
|
|
pylval.num = p->lineno;
|
|
p->lstate = kw->state;
|
|
if (state == EXPR_FNAME) {
|
|
pylval.id = intern_cstr(kw->name);
|
|
return kw->id[0];
|
|
}
|
|
if (p->lstate == EXPR_BEG) {
|
|
p->cmd_start = TRUE;
|
|
}
|
|
if (kw->id[0] == keyword_do) {
|
|
if (p->lpar_beg && p->lpar_beg == p->paren_nest) {
|
|
p->lpar_beg = 0;
|
|
p->paren_nest--;
|
|
return keyword_do_LAMBDA;
|
|
}
|
|
if (COND_P()) return keyword_do_cond;
|
|
if (CMDARG_P() && state != EXPR_CMDARG)
|
|
return keyword_do_block;
|
|
if (state == EXPR_ENDARG || state == EXPR_BEG)
|
|
return keyword_do_block;
|
|
return keyword_do;
|
|
}
|
|
if (state == EXPR_BEG || state == EXPR_VALUE || state == EXPR_CLASS)
|
|
return kw->id[0];
|
|
else {
|
|
if (kw->id[0] != kw->id[1])
|
|
p->lstate = EXPR_BEG;
|
|
return kw->id[1];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IS_BEG() || p->lstate == EXPR_DOT || IS_ARG()) {
|
|
if (cmd_state) {
|
|
p->lstate = EXPR_CMDARG;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_ARG;
|
|
}
|
|
}
|
|
else if (p->lstate == EXPR_FNAME) {
|
|
p->lstate = EXPR_ENDFN;
|
|
}
|
|
else {
|
|
p->lstate = EXPR_END;
|
|
}
|
|
}
|
|
{
|
|
mrb_sym ident = intern(tok(p), toklen(p));
|
|
|
|
pylval.id = ident;
|
|
if (last_state != EXPR_DOT && ISLOWER(tok(p)[0]) && local_var_p(p, ident)) {
|
|
p->lstate = EXPR_END;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
static int
|
|
yylex(void *lval, void *lp, parser_state *p)
|
|
{
|
|
p->ylval = lval;
|
|
return parser_yylex(p);
|
|
}
|
|
|
|
static void
|
|
parser_init_cxt(parser_state *p, mrb_ccontext *cxt)
|
|
{
|
|
if (!cxt) return;
|
|
if (cxt->filename) mrb_parser_set_filename(p, cxt->filename);
|
|
if (cxt->lineno) p->lineno = cxt->lineno;
|
|
if (cxt->syms) {
|
|
int i;
|
|
|
|
p->locals = cons(0,0);
|
|
for (i=0; i<cxt->slen; i++) {
|
|
local_add_f(p, cxt->syms[i]);
|
|
}
|
|
}
|
|
p->capture_errors = cxt->capture_errors;
|
|
p->no_optimize = cxt->no_optimize;
|
|
p->no_ext_ops = cxt->no_ext_ops;
|
|
p->upper = cxt->upper;
|
|
p->var_nodes_enabled = cxt->use_variable_nodes;
|
|
if (cxt->partial_hook) {
|
|
p->cxt = cxt;
|
|
}
|
|
}
|
|
|
|
static void
|
|
parser_update_cxt(parser_state *p, mrb_ccontext *cxt)
|
|
{
|
|
node *n, *n0;
|
|
int i = 0;
|
|
|
|
if (!cxt) return;
|
|
if (!p->tree) return;
|
|
if (!node_type_p(p->tree, NODE_SCOPE)) return;
|
|
|
|
/* Extract locals from variable-sized NODE_SCOPE */
|
|
struct mrb_ast_scope_node *scope = scope_node(p->tree->cdr);
|
|
n0 = n = scope->locals;
|
|
while (n) {
|
|
i++;
|
|
n = n->cdr;
|
|
}
|
|
cxt->syms = (mrb_sym*)mrbc_realloc(cxt->syms, i*sizeof(mrb_sym));
|
|
cxt->slen = i;
|
|
for (i=0, n=n0; n; i++,n=n->cdr) {
|
|
cxt->syms[i] = node_to_sym(n->car);
|
|
}
|
|
}
|
|
|
|
void mrb_parser_dump(mrb_state *mrb, node *tree, int offset);
|
|
|
|
MRB_API void
|
|
mrb_parser_parse(parser_state *p, mrb_ccontext *c)
|
|
{
|
|
struct mrb_jmpbuf buf1;
|
|
struct mrb_jmpbuf *prev = p->mrb->jmp;
|
|
p->mrb->jmp = &buf1;
|
|
|
|
MRB_TRY(p->mrb->jmp) {
|
|
int n = 1;
|
|
|
|
p->cmd_start = TRUE;
|
|
p->in_def = p->in_single = 0;
|
|
p->nerr = p->nwarn = 0;
|
|
p->lex_strterm = NULL;
|
|
parser_init_cxt(p, c);
|
|
|
|
n = yyparse(p);
|
|
if (n != 0 || p->nerr > 0) {
|
|
p->tree = 0;
|
|
p->mrb->jmp = prev;
|
|
return;
|
|
}
|
|
parser_update_cxt(p, c);
|
|
if (c && c->dump_result) {
|
|
mrb_parser_dump(p->mrb, p->tree, 0);
|
|
}
|
|
}
|
|
MRB_CATCH(p->mrb->jmp) {
|
|
p->nerr++;
|
|
if (p->mrb->exc == NULL) {
|
|
yyerror(NULL, p, "memory allocation error");
|
|
p->nerr++;
|
|
p->tree = 0;
|
|
}
|
|
}
|
|
MRB_END_EXC(p->jmp);
|
|
p->mrb->jmp = prev;
|
|
}
|
|
|
|
MRB_API parser_state*
|
|
mrb_parser_new(mrb_state *mrb)
|
|
{
|
|
mempool *pool;
|
|
parser_state *p;
|
|
static const parser_state parser_state_zero = { 0 };
|
|
|
|
pool = mempool_open();
|
|
if (!pool) return NULL;
|
|
p = (parser_state*)mempool_alloc(pool, sizeof(parser_state));
|
|
if (!p) return NULL;
|
|
|
|
*p = parser_state_zero;
|
|
p->mrb = mrb;
|
|
p->pool = pool;
|
|
|
|
p->s = p->send = NULL;
|
|
#ifndef MRB_NO_STDIO
|
|
p->f = NULL;
|
|
#endif
|
|
|
|
p->cmd_start = TRUE;
|
|
p->in_def = p->in_single = 0;
|
|
|
|
p->capture_errors = FALSE;
|
|
p->lineno = 1;
|
|
p->column = 0;
|
|
#if defined(PARSER_TEST) || defined(PARSER_DEBUG)
|
|
yydebug = 1;
|
|
#endif
|
|
p->tsiz = MRB_PARSER_TOKBUF_SIZE;
|
|
p->tokbuf = p->buf;
|
|
|
|
p->lex_strterm = NULL;
|
|
|
|
p->current_filename_index = -1;
|
|
p->filename_table = NULL;
|
|
p->filename_table_length = 0;
|
|
|
|
/* Initialize variable-sized node infrastructure */
|
|
for (int i = 0; i < SIZE_CLASS_COUNT; i++) {
|
|
p->var_free_lists[i] = NULL;
|
|
p->var_alloc_counts[i] = 0;
|
|
}
|
|
p->var_total_allocated = 0;
|
|
p->var_nodes_enabled = FALSE;
|
|
|
|
return p;
|
|
}
|
|
|
|
MRB_API void
|
|
mrb_parser_free(parser_state *p) {
|
|
if (p->tokbuf != p->buf) {
|
|
mrbc_free(p->tokbuf);
|
|
}
|
|
mempool_close(p->pool);
|
|
}
|
|
|
|
MRB_API mrb_ccontext*
|
|
mrb_ccontext_new(mrb_state *mrb)
|
|
{
|
|
static const mrb_ccontext cc_zero = { 0 };
|
|
mrb_ccontext *cc = (mrb_ccontext*)mrbc_malloc(sizeof(mrb_ccontext));
|
|
*cc = cc_zero;
|
|
return cc;
|
|
}
|
|
|
|
MRB_API void
|
|
mrb_ccontext_free(mrb_state *mrb, mrb_ccontext *cxt)
|
|
{
|
|
mrbc_free(cxt->filename);
|
|
mrbc_free(cxt->syms);
|
|
mrbc_free(cxt);
|
|
}
|
|
|
|
MRB_API const char*
|
|
mrb_ccontext_filename(mrb_state *mrb, mrb_ccontext *c, const char *s)
|
|
{
|
|
if (s) {
|
|
size_t len = strlen(s);
|
|
char *p = (char*)mrbc_malloc(len + 1);
|
|
|
|
if (p == NULL) return NULL;
|
|
memcpy(p, s, len + 1);
|
|
if (c->filename) {
|
|
mrbc_free(c->filename);
|
|
}
|
|
c->filename = p;
|
|
}
|
|
return c->filename;
|
|
}
|
|
|
|
MRB_API void
|
|
mrb_ccontext_partial_hook(mrb_ccontext *c, int (*func)(struct mrb_parser_state*), void *data)
|
|
{
|
|
c->partial_hook = func;
|
|
c->partial_data = data;
|
|
}
|
|
|
|
MRB_API void
|
|
mrb_ccontext_cleanup_local_variables(mrb_ccontext *c)
|
|
{
|
|
if (c->syms) {
|
|
mrbc_free(c->syms);
|
|
c->syms = NULL;
|
|
c->slen = 0;
|
|
}
|
|
c->keep_lv = FALSE;
|
|
}
|
|
|
|
MRB_API void
|
|
mrb_parser_set_filename(struct mrb_parser_state *p, const char *f)
|
|
{
|
|
mrb_sym sym;
|
|
uint16_t i;
|
|
mrb_sym* new_table;
|
|
|
|
sym = mrb_intern_cstr(p->mrb, f);
|
|
p->filename_sym = sym;
|
|
p->lineno = (p->filename_table_length > 0)? 0 : 1;
|
|
|
|
for (i = 0; i < p->filename_table_length; i++) {
|
|
if (p->filename_table[i] == sym) {
|
|
p->current_filename_index = i;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (p->filename_table_length == UINT16_MAX) {
|
|
yyerror(NULL, p, "too many files to compile");
|
|
return;
|
|
}
|
|
p->current_filename_index = p->filename_table_length++;
|
|
|
|
new_table = (mrb_sym*)parser_palloc(p, sizeof(mrb_sym) * p->filename_table_length);
|
|
if (p->filename_table) {
|
|
memmove(new_table, p->filename_table, sizeof(mrb_sym) * p->current_filename_index);
|
|
}
|
|
p->filename_table = new_table;
|
|
p->filename_table[p->filename_table_length - 1] = sym;
|
|
}
|
|
|
|
MRB_API mrb_sym
|
|
mrb_parser_get_filename(struct mrb_parser_state* p, uint16_t idx) {
|
|
if (idx >= p->filename_table_length) return 0;
|
|
else {
|
|
return p->filename_table[idx];
|
|
}
|
|
}
|
|
|
|
#ifndef MRB_NO_STDIO
|
|
static struct mrb_parser_state *
|
|
mrb_parse_file_continue(mrb_state *mrb, FILE *f, const void *prebuf, size_t prebufsize, mrb_ccontext *c)
|
|
{
|
|
parser_state *p;
|
|
|
|
p = mrb_parser_new(mrb);
|
|
if (!p) return NULL;
|
|
if (prebuf) {
|
|
p->s = (const char*)prebuf;
|
|
p->send = (const char*)prebuf + prebufsize;
|
|
}
|
|
else {
|
|
p->s = p->send = NULL;
|
|
}
|
|
p->f = f;
|
|
|
|
mrb_parser_parse(p, c);
|
|
return p;
|
|
}
|
|
|
|
MRB_API parser_state*
|
|
mrb_parse_file(mrb_state *mrb, FILE *f, mrb_ccontext *c)
|
|
{
|
|
return mrb_parse_file_continue(mrb, f, NULL, 0, c);
|
|
}
|
|
#endif
|
|
|
|
MRB_API parser_state*
|
|
mrb_parse_nstring(mrb_state *mrb, const char *s, size_t len, mrb_ccontext *c)
|
|
{
|
|
parser_state *p;
|
|
|
|
p = mrb_parser_new(mrb);
|
|
if (!p) return NULL;
|
|
p->s = s;
|
|
p->send = s + len;
|
|
|
|
mrb_parser_parse(p, c);
|
|
return p;
|
|
}
|
|
|
|
MRB_API parser_state*
|
|
mrb_parse_string(mrb_state *mrb, const char *s, mrb_ccontext *c)
|
|
{
|
|
return mrb_parse_nstring(mrb, s, strlen(s), c);
|
|
}
|
|
|
|
MRB_API mrb_value
|
|
mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrb_ccontext *c)
|
|
{
|
|
struct RClass *target = mrb->object_class;
|
|
struct RProc *proc;
|
|
mrb_value v;
|
|
mrb_int keep = 0;
|
|
|
|
if (!p) {
|
|
return mrb_undef_value();
|
|
}
|
|
if (!p->tree || p->nerr) {
|
|
if (c) c->parser_nerr = p->nerr;
|
|
if (p->capture_errors) {
|
|
char buf[256];
|
|
|
|
strcpy(buf, "line ");
|
|
dump_int(p->error_buffer[0].lineno, buf+5);
|
|
strcat(buf, ": ");
|
|
strncat(buf, p->error_buffer[0].message, sizeof(buf) - strlen(buf) - 1);
|
|
mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SYNTAX_ERROR, buf, strlen(buf)));
|
|
mrb_parser_free(p);
|
|
return mrb_undef_value();
|
|
}
|
|
else {
|
|
if (mrb->exc == NULL) {
|
|
mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SYNTAX_ERROR, "syntax error"));
|
|
}
|
|
mrb_parser_free(p);
|
|
return mrb_undef_value();
|
|
}
|
|
}
|
|
proc = mrb_generate_code(mrb, p);
|
|
mrb_parser_free(p);
|
|
if (proc == NULL) {
|
|
if (mrb->exc == NULL) {
|
|
mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SCRIPT_ERROR, "codegen error"));
|
|
}
|
|
return mrb_undef_value();
|
|
}
|
|
if (c) {
|
|
if (c->dump_result) mrb_codedump_all(mrb, proc);
|
|
if (c->no_exec) return mrb_obj_value(proc);
|
|
if (c->target_class) {
|
|
target = c->target_class;
|
|
}
|
|
if (c->keep_lv) {
|
|
keep = c->slen + 1;
|
|
}
|
|
else {
|
|
c->keep_lv = TRUE;
|
|
}
|
|
}
|
|
MRB_PROC_SET_TARGET_CLASS(proc, target);
|
|
if (mrb->c->ci) {
|
|
mrb_vm_ci_target_class_set(mrb->c->ci, target);
|
|
}
|
|
v = mrb_top_run(mrb, proc, mrb_top_self(mrb), keep);
|
|
if (mrb->exc) return mrb_nil_value();
|
|
return v;
|
|
}
|
|
|
|
#ifndef MRB_NO_STDIO
|
|
MRB_API mrb_value
|
|
mrb_load_file_cxt(mrb_state *mrb, FILE *f, mrb_ccontext *c)
|
|
{
|
|
return mrb_load_exec(mrb, mrb_parse_file(mrb, f, c), c);
|
|
}
|
|
|
|
MRB_API mrb_value
|
|
mrb_load_file(mrb_state *mrb, FILE *f)
|
|
{
|
|
return mrb_load_file_cxt(mrb, f, NULL);
|
|
}
|
|
|
|
#define DETECT_SIZE 64
|
|
|
|
/*
|
|
* In order to be recognized as a `.mrb` file, the following three points must be satisfied:
|
|
* - File starts with "RITE"
|
|
* - At least `sizeof(struct rite_binary_header)` bytes can be read
|
|
* - `NUL` is included in the first 64 bytes of the file
|
|
*/
|
|
MRB_API mrb_value
|
|
mrb_load_detect_file_cxt(mrb_state *mrb, FILE *fp, mrb_ccontext *c)
|
|
{
|
|
union {
|
|
char b[DETECT_SIZE];
|
|
struct rite_binary_header h;
|
|
} leading;
|
|
size_t bufsize;
|
|
|
|
if (mrb == NULL || fp == NULL) {
|
|
return mrb_nil_value();
|
|
}
|
|
|
|
bufsize = fread(leading.b, sizeof(char), sizeof(leading), fp);
|
|
if (bufsize < sizeof(leading.h) ||
|
|
memcmp(leading.h.binary_ident, RITE_BINARY_IDENT, sizeof(leading.h.binary_ident)) != 0 ||
|
|
memchr(leading.b, '\0', bufsize) == NULL) {
|
|
return mrb_load_exec(mrb, mrb_parse_file_continue(mrb, fp, leading.b, bufsize, c), c);
|
|
}
|
|
else {
|
|
mrb_int binsize;
|
|
uint8_t *bin;
|
|
mrb_value bin_obj = mrb_nil_value(); /* temporary string object */
|
|
mrb_value result;
|
|
|
|
binsize = bin_to_uint32(leading.h.binary_size);
|
|
bin_obj = mrb_str_new(mrb, NULL, binsize);
|
|
bin = (uint8_t*)RSTRING_PTR(bin_obj);
|
|
if ((size_t)binsize > bufsize) {
|
|
memcpy(bin, leading.b, bufsize);
|
|
if (fread(bin + bufsize, binsize - bufsize, 1, fp) == 0) {
|
|
binsize = bufsize;
|
|
/* The error is reported by mrb_load_irep_buf_cxt() */
|
|
}
|
|
}
|
|
|
|
result = mrb_load_irep_buf_cxt(mrb, bin, binsize, c);
|
|
if (mrb_string_p(bin_obj)) mrb_str_resize(mrb, bin_obj, 0);
|
|
return result;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
MRB_API mrb_value
|
|
mrb_load_nstring_cxt(mrb_state *mrb, const char *s, size_t len, mrb_ccontext *c)
|
|
{
|
|
return mrb_load_exec(mrb, mrb_parse_nstring(mrb, s, len, c), c);
|
|
}
|
|
|
|
MRB_API mrb_value
|
|
mrb_load_nstring(mrb_state *mrb, const char *s, size_t len)
|
|
{
|
|
return mrb_load_nstring_cxt(mrb, s, len, NULL);
|
|
}
|
|
|
|
MRB_API mrb_value
|
|
mrb_load_string_cxt(mrb_state *mrb, const char *s, mrb_ccontext *c)
|
|
{
|
|
return mrb_load_nstring_cxt(mrb, s, strlen(s), c);
|
|
}
|
|
|
|
MRB_API mrb_value
|
|
mrb_load_string(mrb_state *mrb, const char *s)
|
|
{
|
|
return mrb_load_string_cxt(mrb, s, NULL);
|
|
}
|
|
|
|
#ifndef MRB_NO_STDIO
|
|
|
|
static void
|
|
dump_prefix(node *tree, int offset)
|
|
{
|
|
printf("%05d ", 0); /* location info not available in this context */
|
|
while (offset--) {
|
|
putc(' ', stdout);
|
|
putc(' ', stdout);
|
|
}
|
|
}
|
|
|
|
static void
|
|
dump_recur(mrb_state *mrb, node *tree, int offset)
|
|
{
|
|
while (tree) {
|
|
mrb_parser_dump(mrb, tree->car, offset);
|
|
tree = tree->cdr;
|
|
}
|
|
}
|
|
|
|
static void
|
|
dump_args(mrb_state *mrb, node *n, int offset)
|
|
{
|
|
if (n->car) {
|
|
dump_prefix(n, offset+1);
|
|
printf("mandatory args:\n");
|
|
dump_recur(mrb, n->car, offset+2);
|
|
}
|
|
n = n->cdr;
|
|
if (n->car) {
|
|
dump_prefix(n, offset+1);
|
|
printf("optional args:\n");
|
|
{
|
|
node *n2 = n->car;
|
|
|
|
while (n2) {
|
|
dump_prefix(n2, offset+2);
|
|
printf("%s=\n", mrb_sym_name(mrb, node_to_sym(n2->car->car)));
|
|
mrb_parser_dump(mrb, n2->car->cdr, offset+3);
|
|
n2 = n2->cdr;
|
|
}
|
|
}
|
|
}
|
|
n = n->cdr;
|
|
if (n->car) {
|
|
mrb_sym rest = node_to_sym(n->car);
|
|
|
|
dump_prefix(n, offset+1);
|
|
if (rest == MRB_OPSYM(mul))
|
|
printf("rest=*\n");
|
|
else
|
|
printf("rest=*%s\n", mrb_sym_name(mrb, rest));
|
|
}
|
|
n = n->cdr;
|
|
if (n->car) {
|
|
dump_prefix(n, offset+1);
|
|
printf("post mandatory args:\n");
|
|
dump_recur(mrb, n->car, offset+2);
|
|
}
|
|
|
|
n = n->cdr;
|
|
if (n) {
|
|
mrb_assert(node_to_int(n->car) == NODE_ARGS_TAIL);
|
|
mrb_parser_dump(mrb, n, offset);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This function restores the GC arena on return.
|
|
* For this reason, if a process that further generates an object is
|
|
* performed at the caller, the string pointer returned as the return
|
|
* value may become invalid.
|
|
*/
|
|
#if 0
|
|
static const char*
|
|
str_dump(mrb_state *mrb, const char *str, int len)
|
|
{
|
|
int ai = mrb_gc_arena_save(mrb);
|
|
mrb_value s;
|
|
# if INT_MAX > MRB_INT_MAX / 4
|
|
/* check maximum length with "\xNN" character */
|
|
if (len > MRB_INT_MAX / 4) {
|
|
len = MRB_INT_MAX / 4;
|
|
}
|
|
# endif
|
|
s = mrb_str_new(mrb, str, (mrb_int)len);
|
|
s = mrb_str_dump(mrb, s);
|
|
mrb_gc_arena_restore(mrb, ai);
|
|
return RSTRING_PTR(s);
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
void
|
|
mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
|
|
{
|
|
#ifndef MRB_NO_STDIO
|
|
int nodetype;
|
|
|
|
if (!tree) return;
|
|
again:
|
|
dump_prefix(tree, offset);
|
|
nodetype = node_to_int(tree->car);
|
|
tree = tree->cdr;
|
|
switch (nodetype) {
|
|
case NODE_STMTS:
|
|
printf("NODE_STMTS:\n");
|
|
dump_recur(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_BEGIN:
|
|
printf("NODE_BEGIN:\n");
|
|
mrb_parser_dump(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_RESCUE:
|
|
printf("NODE_RESCUE:\n");
|
|
if (tree->car) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("body:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
}
|
|
tree = tree->cdr;
|
|
if (tree->car) {
|
|
node *n2 = tree->car;
|
|
|
|
dump_prefix(n2, offset+1);
|
|
printf("rescue:\n");
|
|
while (n2) {
|
|
node *n3 = n2->car;
|
|
if (n3->car) {
|
|
dump_prefix(n2, offset+2);
|
|
printf("handle classes:\n");
|
|
dump_recur(mrb, n3->car, offset+3);
|
|
}
|
|
if (n3->cdr->car) {
|
|
dump_prefix(n3, offset+2);
|
|
printf("exc_var:\n");
|
|
mrb_parser_dump(mrb, n3->cdr->car, offset+3);
|
|
}
|
|
if (n3->cdr->cdr->car) {
|
|
dump_prefix(n3, offset+2);
|
|
printf("rescue body:\n");
|
|
mrb_parser_dump(mrb, n3->cdr->cdr->car, offset+3);
|
|
}
|
|
n2 = n2->cdr;
|
|
}
|
|
}
|
|
tree = tree->cdr;
|
|
if (tree->car) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("else:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
}
|
|
break;
|
|
|
|
case NODE_ENSURE:
|
|
printf("NODE_ENSURE:\n");
|
|
dump_prefix(tree, offset+1);
|
|
printf("body:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
dump_prefix(tree, offset+1);
|
|
printf("ensure:\n");
|
|
mrb_parser_dump(mrb, tree->cdr->cdr, offset+2);
|
|
break;
|
|
|
|
case NODE_LAMBDA:
|
|
printf("NODE_LAMBDA:\n");
|
|
dump_prefix(tree, offset+1);
|
|
goto block;
|
|
|
|
case NODE_BLOCK:
|
|
block:
|
|
printf("NODE_BLOCK:\n");
|
|
tree = tree->cdr;
|
|
if (tree->car) {
|
|
dump_args(mrb, tree->car, offset+1);
|
|
}
|
|
dump_prefix(tree, offset+1);
|
|
printf("body:\n");
|
|
mrb_parser_dump(mrb, tree->cdr->car, offset+2);
|
|
break;
|
|
|
|
case NODE_IF:
|
|
printf("NODE_IF:\n");
|
|
dump_prefix(tree, offset+1);
|
|
printf("cond:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
dump_prefix(tree, offset+1);
|
|
printf("then:\n");
|
|
mrb_parser_dump(mrb, tree->cdr->car, offset+2);
|
|
if (tree->cdr->cdr->car) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("else:\n");
|
|
mrb_parser_dump(mrb, tree->cdr->cdr->car, offset+2);
|
|
}
|
|
break;
|
|
|
|
case NODE_AND:
|
|
printf("NODE_AND:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
mrb_parser_dump(mrb, tree->cdr, offset+1);
|
|
break;
|
|
|
|
case NODE_OR:
|
|
printf("NODE_OR:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
mrb_parser_dump(mrb, tree->cdr, offset+1);
|
|
break;
|
|
|
|
case NODE_CASE:
|
|
printf("NODE_CASE:\n");
|
|
if (tree->car) {
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
}
|
|
tree = tree->cdr;
|
|
while (tree) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("case:\n");
|
|
dump_recur(mrb, tree->car->car, offset+2);
|
|
dump_prefix(tree, offset+1);
|
|
printf("body:\n");
|
|
mrb_parser_dump(mrb, tree->car->cdr, offset+2);
|
|
tree = tree->cdr;
|
|
}
|
|
break;
|
|
|
|
case NODE_WHILE:
|
|
printf("NODE_WHILE:\n");
|
|
dump_prefix(tree, offset+1);
|
|
printf("cond:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
dump_prefix(tree, offset+1);
|
|
printf("body:\n");
|
|
mrb_parser_dump(mrb, tree->cdr, offset+2);
|
|
break;
|
|
|
|
case NODE_UNTIL:
|
|
printf("NODE_UNTIL:\n");
|
|
dump_prefix(tree, offset+1);
|
|
printf("cond:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
dump_prefix(tree, offset+1);
|
|
printf("body:\n");
|
|
mrb_parser_dump(mrb, tree->cdr, offset+2);
|
|
break;
|
|
|
|
case NODE_WHILE_MOD:
|
|
printf("NODE_WHILE_MOD:\n");
|
|
dump_prefix(tree, offset+1);
|
|
printf("cond:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
dump_prefix(tree, offset+1);
|
|
printf("body:\n");
|
|
mrb_parser_dump(mrb, tree->cdr, offset+2);
|
|
break;
|
|
|
|
case NODE_UNTIL_MOD:
|
|
printf("NODE_UNTIL_MOD:\n");
|
|
dump_prefix(tree, offset+1);
|
|
printf("cond:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
dump_prefix(tree, offset+1);
|
|
printf("body:\n");
|
|
mrb_parser_dump(mrb, tree->cdr, offset+2);
|
|
break;
|
|
|
|
case NODE_FOR:
|
|
printf("NODE_FOR:\n");
|
|
dump_prefix(tree, offset+1);
|
|
printf("var:\n");
|
|
{
|
|
node *n2 = tree->car;
|
|
|
|
if (n2->car) {
|
|
dump_prefix(n2, offset+2);
|
|
printf("pre:\n");
|
|
dump_recur(mrb, n2->car, offset+3);
|
|
}
|
|
n2 = n2->cdr;
|
|
if (n2) {
|
|
if (n2->car) {
|
|
dump_prefix(n2, offset+2);
|
|
printf("rest:\n");
|
|
mrb_parser_dump(mrb, n2->car, offset+3);
|
|
}
|
|
n2 = n2->cdr;
|
|
if (n2) {
|
|
if (n2->car) {
|
|
dump_prefix(n2, offset+2);
|
|
printf("post:\n");
|
|
dump_recur(mrb, n2->car, offset+3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tree = tree->cdr;
|
|
dump_prefix(tree, offset+1);
|
|
printf("in:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
tree = tree->cdr;
|
|
dump_prefix(tree, offset+1);
|
|
printf("do:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
break;
|
|
|
|
case NODE_SCOPE:
|
|
printf("NODE_SCOPE:\n");
|
|
{
|
|
node *n2 = tree->car;
|
|
mrb_bool first_lval = TRUE;
|
|
|
|
if (n2 && (n2->car || n2->cdr)) {
|
|
dump_prefix(n2, offset+1);
|
|
printf("local variables:\n");
|
|
dump_prefix(n2, offset+2);
|
|
while (n2) {
|
|
if (n2->car) {
|
|
if (!first_lval) printf(", ");
|
|
printf("%s", mrb_sym_name(mrb, node_to_sym(n2->car)));
|
|
first_lval = FALSE;
|
|
}
|
|
n2 = n2->cdr;
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
tree = tree->cdr;
|
|
offset++;
|
|
goto again;
|
|
|
|
case NODE_FCALL:
|
|
case NODE_CALL:
|
|
case NODE_SCALL:
|
|
switch (nodetype) {
|
|
case NODE_FCALL:
|
|
printf("NODE_FCALL:\n"); break;
|
|
case NODE_CALL:
|
|
printf("NODE_CALL(.):\n"); break;
|
|
case NODE_SCALL:
|
|
printf("NODE_SCALL(&.):\n"); break;
|
|
default:
|
|
break;
|
|
}
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
dump_prefix(tree, offset+1);
|
|
printf("method='%s' (%d)\n",
|
|
mrb_sym_dump(mrb, node_to_sym(tree->cdr->car)),
|
|
node_to_int(tree->cdr->car));
|
|
tree = tree->cdr->cdr->car;
|
|
if (tree) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("args:\n");
|
|
dump_recur(mrb, tree->car, offset+2);
|
|
if (tree->cdr) {
|
|
if (tree->cdr->car) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("kwargs:\n");
|
|
mrb_parser_dump(mrb, tree->cdr->car, offset+2);
|
|
}
|
|
if (tree->cdr->cdr) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("block:\n");
|
|
mrb_parser_dump(mrb, tree->cdr->cdr, offset+2);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case NODE_DOT2:
|
|
printf("NODE_DOT2:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
mrb_parser_dump(mrb, tree->cdr, offset+1);
|
|
break;
|
|
|
|
case NODE_DOT3:
|
|
printf("NODE_DOT3:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
mrb_parser_dump(mrb, tree->cdr, offset+1);
|
|
break;
|
|
|
|
case NODE_COLON2:
|
|
printf("NODE_COLON2:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
dump_prefix(tree, offset+1);
|
|
printf("::%s\n", mrb_sym_name(mrb, node_to_sym(tree->cdr)));
|
|
break;
|
|
|
|
case NODE_COLON3:
|
|
printf("NODE_COLON3: ::%s\n", mrb_sym_name(mrb, node_to_sym(tree)));
|
|
break;
|
|
|
|
case NODE_ARRAY:
|
|
printf("NODE_ARRAY:\n");
|
|
dump_recur(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_HASH:
|
|
printf("NODE_HASH:\n");
|
|
while (tree) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("key:\n");
|
|
mrb_parser_dump(mrb, tree->car->car, offset+2);
|
|
dump_prefix(tree, offset+1);
|
|
printf("value:\n");
|
|
mrb_parser_dump(mrb, tree->car->cdr, offset+2);
|
|
tree = tree->cdr;
|
|
}
|
|
break;
|
|
|
|
case NODE_KW_HASH:
|
|
printf("NODE_KW_HASH:\n");
|
|
while (tree) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("key:\n");
|
|
mrb_parser_dump(mrb, tree->car->car, offset+2);
|
|
dump_prefix(tree, offset+1);
|
|
printf("value:\n");
|
|
mrb_parser_dump(mrb, tree->car->cdr, offset+2);
|
|
tree = tree->cdr;
|
|
}
|
|
break;
|
|
|
|
case NODE_SPLAT:
|
|
printf("NODE_SPLAT:\n");
|
|
mrb_parser_dump(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_ASGN:
|
|
printf("NODE_ASGN:\n");
|
|
dump_prefix(tree, offset+1);
|
|
printf("lhs:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
dump_prefix(tree, offset+1);
|
|
printf("rhs:\n");
|
|
mrb_parser_dump(mrb, tree->cdr, offset+2);
|
|
break;
|
|
|
|
case NODE_MASGN:
|
|
printf("NODE_MASGN:\n");
|
|
dump_prefix(tree, offset+1);
|
|
printf("mlhs:\n");
|
|
{
|
|
node *n2 = tree->car;
|
|
|
|
if (n2->car) {
|
|
dump_prefix(tree, offset+2);
|
|
printf("pre:\n");
|
|
dump_recur(mrb, n2->car, offset+3);
|
|
}
|
|
n2 = n2->cdr;
|
|
if (n2) {
|
|
if (n2->car) {
|
|
dump_prefix(n2, offset+2);
|
|
printf("rest:\n");
|
|
if (n2->car == int_to_node(-1)) {
|
|
dump_prefix(n2, offset+2);
|
|
printf("(empty)\n");
|
|
}
|
|
else {
|
|
mrb_parser_dump(mrb, n2->car, offset+3);
|
|
}
|
|
}
|
|
n2 = n2->cdr;
|
|
if (n2 && n2->car) {
|
|
dump_prefix(n2, offset+2);
|
|
printf("post:\n");
|
|
dump_recur(mrb, n2->car, offset+3);
|
|
}
|
|
}
|
|
}
|
|
dump_prefix(tree, offset+1);
|
|
printf("rhs:\n");
|
|
mrb_parser_dump(mrb, tree->cdr, offset+2);
|
|
break;
|
|
|
|
case NODE_OP_ASGN:
|
|
printf("NODE_OP_ASGN:\n");
|
|
dump_prefix(tree, offset+1);
|
|
printf("lhs:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+2);
|
|
tree = tree->cdr;
|
|
dump_prefix(tree, offset+1);
|
|
printf("op='%s' (%d)\n", mrb_sym_name(mrb, node_to_sym(tree->car)), node_to_int(tree->car));
|
|
tree = tree->cdr;
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
break;
|
|
|
|
case NODE_SUPER:
|
|
printf("NODE_SUPER:\n");
|
|
if (tree) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("args:\n");
|
|
dump_recur(mrb, tree->car, offset+2);
|
|
if (tree->cdr) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("block:\n");
|
|
mrb_parser_dump(mrb, tree->cdr, offset+2);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case NODE_ZSUPER:
|
|
printf("NODE_ZSUPER:\n");
|
|
if (tree) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("args:\n");
|
|
dump_recur(mrb, tree->car, offset+2);
|
|
if (tree->cdr) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("block:\n");
|
|
mrb_parser_dump(mrb, tree->cdr, offset+2);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case NODE_RETURN:
|
|
printf("NODE_RETURN:\n");
|
|
mrb_parser_dump(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_YIELD:
|
|
printf("NODE_YIELD:\n");
|
|
dump_recur(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_BREAK:
|
|
printf("NODE_BREAK:\n");
|
|
mrb_parser_dump(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_NEXT:
|
|
printf("NODE_NEXT:\n");
|
|
mrb_parser_dump(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_REDO:
|
|
printf("NODE_REDO\n");
|
|
break;
|
|
|
|
case NODE_RETRY:
|
|
printf("NODE_RETRY\n");
|
|
break;
|
|
|
|
case NODE_LVAR:
|
|
printf("NODE_LVAR %s\n", mrb_sym_name(mrb, node_to_sym(tree)));
|
|
break;
|
|
|
|
case NODE_GVAR:
|
|
printf("NODE_GVAR %s\n", mrb_sym_name(mrb, node_to_sym(tree)));
|
|
break;
|
|
|
|
case NODE_IVAR:
|
|
printf("NODE_IVAR %s\n", mrb_sym_name(mrb, node_to_sym(tree)));
|
|
break;
|
|
|
|
case NODE_CVAR:
|
|
printf("NODE_CVAR %s\n", mrb_sym_name(mrb, node_to_sym(tree)));
|
|
break;
|
|
|
|
case NODE_NVAR:
|
|
printf("NODE_NVAR %d\n", node_to_int(tree));
|
|
break;
|
|
|
|
case NODE_CONST:
|
|
printf("NODE_CONST %s\n", mrb_sym_name(mrb, node_to_sym(tree)));
|
|
break;
|
|
|
|
case NODE_MATCH:
|
|
printf("NODE_MATCH:\n");
|
|
dump_prefix(tree, offset + 1);
|
|
printf("lhs:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset + 2);
|
|
dump_prefix(tree, offset + 1);
|
|
printf("rhs:\n");
|
|
mrb_parser_dump(mrb, tree->cdr, offset + 2);
|
|
break;
|
|
|
|
case NODE_BACK_REF:
|
|
printf("NODE_BACK_REF: $%c\n", node_to_int(tree));
|
|
break;
|
|
|
|
case NODE_NTH_REF:
|
|
printf("NODE_NTH_REF: $%d\n", node_to_int(tree));
|
|
break;
|
|
|
|
case NODE_ARG:
|
|
printf("NODE_ARG %s\n", mrb_sym_name(mrb, node_to_sym(tree)));
|
|
break;
|
|
|
|
case NODE_BLOCK_ARG:
|
|
printf("NODE_BLOCK_ARG:\n");
|
|
mrb_parser_dump(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_INT:
|
|
printf("NODE_INT %s base %d\n", (char*)tree->car, node_to_int(tree->cdr->car));
|
|
break;
|
|
|
|
case NODE_FLOAT:
|
|
printf("NODE_FLOAT %s\n", (char*)tree);
|
|
break;
|
|
|
|
case NODE_NEGATE:
|
|
printf("NODE_NEGATE:\n");
|
|
mrb_parser_dump(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_STR:
|
|
printf("NODE_STR:\n");
|
|
dump_recur(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_XSTR:
|
|
printf("NODE_XSTR:\n");
|
|
dump_recur(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_REGX:
|
|
printf("NODE_REGX /%s/\n", (char*)tree->car);
|
|
if (tree->cdr->car) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("opt: %s\n", (char*)tree->cdr->car);
|
|
}
|
|
if (tree->cdr->cdr) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("enc: %s\n", (char*)tree->cdr->cdr);
|
|
}
|
|
break;
|
|
|
|
case NODE_DREGX:
|
|
printf("NODE_DREGX:\n");
|
|
dump_recur(mrb, tree->car, offset+1);
|
|
dump_prefix(tree, offset+1);
|
|
printf("tail: %s\n", (char*)tree->cdr->cdr->car);
|
|
if (tree->cdr->cdr->cdr->car) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("opt: %s\n", (char*)tree->cdr->cdr->cdr->car);
|
|
}
|
|
if (tree->cdr->cdr->cdr->cdr) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("enc: %s\n", (char*)tree->cdr->cdr->cdr->cdr);
|
|
}
|
|
break;
|
|
|
|
case NODE_SYM:
|
|
printf("NODE_SYM :%s (%d)\n", mrb_sym_dump(mrb, node_to_sym(tree)),
|
|
node_to_int(tree));
|
|
break;
|
|
|
|
case NODE_DSYM:
|
|
printf("NODE_DSYM:\n");
|
|
mrb_parser_dump(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_WORDS:
|
|
printf("NODE_WORDS:\n");
|
|
dump_recur(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_SYMBOLS:
|
|
printf("NODE_SYMBOLS:\n");
|
|
dump_recur(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_SELF:
|
|
printf("NODE_SELF\n");
|
|
break;
|
|
|
|
case NODE_NIL:
|
|
printf("NODE_NIL\n");
|
|
break;
|
|
|
|
case NODE_TRUE:
|
|
printf("NODE_TRUE\n");
|
|
break;
|
|
|
|
case NODE_FALSE:
|
|
printf("NODE_FALSE\n");
|
|
break;
|
|
|
|
case NODE_ALIAS:
|
|
printf("NODE_ALIAS %s %s:\n",
|
|
mrb_sym_dump(mrb, node_to_sym(tree->car)),
|
|
mrb_sym_dump(mrb, node_to_sym(tree->cdr)));
|
|
break;
|
|
|
|
case NODE_UNDEF:
|
|
printf("NODE_UNDEF");
|
|
{
|
|
node *t = tree;
|
|
while (t) {
|
|
printf(" %s", mrb_sym_dump(mrb, node_to_sym(t->car)));
|
|
t = t->cdr;
|
|
}
|
|
}
|
|
printf(":\n");
|
|
break;
|
|
|
|
case NODE_CLASS:
|
|
printf("NODE_CLASS:\n");
|
|
if (tree->car->car == int_to_node(0)) {
|
|
dump_prefix(tree, offset+1);
|
|
printf(":%s\n", mrb_sym_name(mrb, node_to_sym(tree->car->cdr)));
|
|
}
|
|
else if (tree->car->car == int_to_node(1)) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("::%s\n", mrb_sym_name(mrb, node_to_sym(tree->car->cdr)));
|
|
}
|
|
else {
|
|
mrb_parser_dump(mrb, tree->car->car, offset+1);
|
|
dump_prefix(tree, offset+1);
|
|
printf("::%s\n", mrb_sym_name(mrb, node_to_sym(tree->car->cdr)));
|
|
}
|
|
if (tree->cdr->car) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("super:\n");
|
|
mrb_parser_dump(mrb, tree->cdr->car, offset+2);
|
|
}
|
|
dump_prefix(tree, offset+1);
|
|
printf("body:\n");
|
|
mrb_parser_dump(mrb, tree->cdr->cdr->car->cdr, offset+2);
|
|
break;
|
|
|
|
case NODE_MODULE:
|
|
printf("NODE_MODULE:\n");
|
|
if (tree->car->car == int_to_node(0)) {
|
|
dump_prefix(tree, offset+1);
|
|
printf(":%s\n", mrb_sym_name(mrb, node_to_sym(tree->car->cdr)));
|
|
}
|
|
else if (tree->car->car == int_to_node(1)) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("::%s\n", mrb_sym_name(mrb, node_to_sym(tree->car->cdr)));
|
|
}
|
|
else {
|
|
mrb_parser_dump(mrb, tree->car->car, offset+1);
|
|
dump_prefix(tree, offset+1);
|
|
printf("::%s\n", mrb_sym_name(mrb, node_to_sym(tree->car->cdr)));
|
|
}
|
|
dump_prefix(tree, offset+1);
|
|
printf("body:\n");
|
|
mrb_parser_dump(mrb, tree->cdr->car->cdr, offset+2);
|
|
break;
|
|
|
|
case NODE_SCLASS:
|
|
printf("NODE_SCLASS:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
dump_prefix(tree, offset+1);
|
|
printf("body:\n");
|
|
mrb_parser_dump(mrb, tree->cdr->car->cdr, offset+2);
|
|
break;
|
|
|
|
case NODE_DEF:
|
|
printf("NODE_DEF:\n");
|
|
dump_prefix(tree, offset+1);
|
|
printf("%s\n", mrb_sym_dump(mrb, node_to_sym(tree->car)));
|
|
tree = tree->cdr;
|
|
{
|
|
node *n2 = tree->car;
|
|
mrb_bool first_lval = TRUE;
|
|
|
|
if (n2 && (n2->car || n2->cdr)) {
|
|
dump_prefix(n2, offset+1);
|
|
printf("local variables:\n");
|
|
dump_prefix(n2, offset+2);
|
|
while (n2) {
|
|
if (n2->car) {
|
|
if (!first_lval) printf(", ");
|
|
printf("%s", mrb_sym_name(mrb, node_to_sym(n2->car)));
|
|
first_lval = FALSE;
|
|
}
|
|
n2 = n2->cdr;
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
tree = tree->cdr;
|
|
if (tree->car) {
|
|
dump_args(mrb, tree->car, offset);
|
|
}
|
|
mrb_parser_dump(mrb, tree->cdr->car, offset+1);
|
|
break;
|
|
|
|
case NODE_SDEF:
|
|
printf("NODE_SDEF:\n");
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
tree = tree->cdr;
|
|
dump_prefix(tree, offset+1);
|
|
printf(":%s\n", mrb_sym_dump(mrb, node_to_sym(tree->car)));
|
|
tree = tree->cdr->cdr;
|
|
if (tree->car) {
|
|
dump_args(mrb, tree->car, offset+1);
|
|
}
|
|
tree = tree->cdr;
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
break;
|
|
|
|
case NODE_POSTEXE:
|
|
printf("NODE_POSTEXE:\n");
|
|
mrb_parser_dump(mrb, tree, offset+1);
|
|
break;
|
|
|
|
case NODE_HEREDOC:
|
|
printf("NODE_HEREDOC (<<%s):\n", ((parser_heredoc_info*)tree)->term);
|
|
dump_recur(mrb, ((parser_heredoc_info*)tree)->doc, offset+1);
|
|
break;
|
|
|
|
case NODE_ARGS_TAIL:
|
|
printf("NODE_ARGS_TAIL:\n");
|
|
{
|
|
node *kws = tree->car;
|
|
|
|
while (kws) {
|
|
mrb_parser_dump(mrb, kws->car, offset+1);
|
|
kws = kws->cdr;
|
|
}
|
|
}
|
|
tree = tree->cdr;
|
|
if (tree->car) {
|
|
mrb_assert(node_to_int(tree->car->car) == NODE_KW_REST_ARGS);
|
|
mrb_parser_dump(mrb, tree->car, offset+1);
|
|
}
|
|
tree = tree->cdr;
|
|
if (tree->car) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("block='%s'\n", mrb_sym_name(mrb, node_to_sym(tree->car)));
|
|
}
|
|
break;
|
|
|
|
case NODE_KW_ARG:
|
|
printf("NODE_KW_ARG %s:\n", mrb_sym_name(mrb, node_to_sym(tree->car)));
|
|
mrb_parser_dump(mrb, tree->cdr->car, offset + 1);
|
|
break;
|
|
|
|
case NODE_KW_REST_ARGS:
|
|
if (tree)
|
|
printf("NODE_KW_REST_ARGS %s\n", mrb_sym_name(mrb, node_to_sym(tree)));
|
|
else
|
|
printf("NODE_KW_REST_ARGS\n");
|
|
break;
|
|
|
|
case NODE_VARIABLE:
|
|
/* Handle variable-sized nodes wrapped in NODE_VARIABLE */
|
|
{
|
|
enum node_type var_type = VAR_NODE_TYPE(tree);
|
|
switch (var_type) {
|
|
case NODE_SCOPE:
|
|
printf("NODE_SCOPE:\n");
|
|
{
|
|
struct mrb_ast_scope_node *scope = scope_node(tree);
|
|
node *n2 = scope->locals;
|
|
mrb_bool first_lval = TRUE;
|
|
|
|
if (n2 && (n2->car || n2->cdr)) {
|
|
dump_prefix(tree, offset+1);
|
|
printf("local variables:\n");
|
|
dump_prefix(tree, offset+2);
|
|
while (n2) {
|
|
if (n2->car) {
|
|
if (!first_lval) printf(", ");
|
|
printf("%s", mrb_sym_name(mrb, node_to_sym(n2->car)));
|
|
first_lval = FALSE;
|
|
}
|
|
n2 = n2->cdr;
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
tree = scope_node(tree)->body;
|
|
offset++;
|
|
goto again;
|
|
|
|
default:
|
|
printf("NODE_VARIABLE (unsupported type: %d)\n", var_type);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
printf("node type: %d (0x%x)\n", nodetype, (unsigned)nodetype);
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
typedef mrb_bool mrb_parser_foreach_top_variable_func(mrb_state *mrb, mrb_sym sym, void *user);
|
|
void mrb_parser_foreach_top_variable(mrb_state *mrb, struct mrb_parser_state *p, mrb_parser_foreach_top_variable_func *func, void *user);
|
|
|
|
void
|
|
mrb_parser_foreach_top_variable(mrb_state *mrb, struct mrb_parser_state *p, mrb_parser_foreach_top_variable_func *func, void *user)
|
|
{
|
|
const mrb_ast_node *n = p->tree;
|
|
if (node_type_p((node*)n, NODE_SCOPE)) {
|
|
/* Extract locals from variable-sized NODE_SCOPE */
|
|
struct mrb_ast_scope_node *scope = scope_node(n->cdr);
|
|
n = scope->locals;
|
|
for (; n; n = n->cdr) {
|
|
mrb_sym sym = node_to_sym(n->car);
|
|
if (sym != 0) {
|
|
if (!func(mrb, sym, user)) break;
|
|
}
|
|
}
|
|
}
|
|
}
|