52#define YYBISON_VERSION "3.8.2"
55#define YYSKELETON_NAME "yacc.c"
72# error needs pure parser
75#define YYERROR_VERBOSE 1
76#define YYSTACK_USE_ALLOCA 0
80# include RUBY_EXTCONF_H
83#include "ruby/internal/config.h"
87#ifdef UNIVERSAL_PARSER
89#include "internal/ruby_parser.h"
90#include "parser_node.h"
91#include "universal_parser.c"
94#define STATIC_ID2SYM p->config->static_id2sym
95#define rb_str_coderange_scan_restartable p->config->str_coderange_scan_restartable
101#include "internal/compile.h"
102#include "internal/compilers.h"
103#include "internal/complex.h"
104#include "internal/encoding.h"
105#include "internal/error.h"
106#include "internal/hash.h"
107#include "internal/io.h"
108#include "internal/numeric.h"
109#include "internal/parse.h"
110#include "internal/rational.h"
111#include "internal/re.h"
112#include "internal/ruby_parser.h"
113#include "internal/symbol.h"
114#include "internal/thread.h"
115#include "internal/variable.h"
117#include "parser_node.h"
121#include "ruby/regex.h"
130syntax_error_new(
void)
138#define compile_callback rb_suppress_tracing
141#define NODE_SPECIAL_EMPTY_ARGS ((NODE *)-1)
142#define NODE_EMPTY_ARGS_P(node) ((node) == NODE_SPECIAL_EMPTY_ARGS)
153 return (n1->minus != n2->minus ||
154 n1->base != n2->base ||
155 strcmp(n1->val, n2->val));
161 return (n1->minus != n2->minus ||
162 strcmp(n1->val, n2->val));
168 return (n1->minus != n2->minus ||
169 n1->base != n2->base ||
170 n1->seen_point != n2->seen_point ||
171 strcmp(n1->val, n2->val));
177 return (n1->minus != n2->minus ||
178 n1->base != n2->base ||
179 n1->seen_point != n2->seen_point ||
180 n1->type != n2->type ||
181 strcmp(n1->val, n2->val));
187 return (n1->options != n2->options ||
188 rb_parser_string_hash_cmp(n1->string, n2->string));
192static st_index_t rb_char_p_hash(
const char *c);
195literal_cmp(st_data_t val, st_data_t lit)
197 if (val == lit)
return 0;
199 NODE *node_val = RNODE(val);
200 NODE *node_lit = RNODE(lit);
201 enum node_type type_val = nd_type(node_val);
202 enum node_type type_lit = nd_type(node_lit);
204 if (type_val != type_lit) {
210 return node_integer_cmp(RNODE_INTEGER(node_val), RNODE_INTEGER(node_lit));
212 return node_float_cmp(RNODE_FLOAT(node_val), RNODE_FLOAT(node_lit));
214 return node_rational_cmp(RNODE_RATIONAL(node_val), RNODE_RATIONAL(node_lit));
216 return node_imaginary_cmp(RNODE_IMAGINARY(node_val), RNODE_IMAGINARY(node_lit));
218 return rb_parser_string_hash_cmp(RNODE_STR(node_val)->
string, RNODE_STR(node_lit)->
string);
220 return rb_parser_string_hash_cmp(RNODE_SYM(node_val)->
string, RNODE_SYM(node_lit)->
string);
222 return rb_parser_regx_hash_cmp(RNODE_REGX(node_val), RNODE_REGX(node_lit));
224 return node_val->nd_loc.beg_pos.lineno != node_lit->nd_loc.beg_pos.lineno;
226 return rb_parser_string_hash_cmp(RNODE_FILE(node_val)->path, RNODE_FILE(node_lit)->path);
228 return RNODE_ENCODING(node_val)->enc != RNODE_ENCODING(node_lit)->enc;
230#ifdef UNIVERSAL_PARSER
233 rb_bug(
"unexpected node: %s, %s", ruby_node_name(type_val), ruby_node_name(type_lit));
239literal_hash(st_data_t a)
242 enum node_type
type = nd_type(node);
246 return rb_char_p_hash(RNODE_INTEGER(node)->val);
248 return rb_char_p_hash(RNODE_FLOAT(node)->val);
250 return rb_char_p_hash(RNODE_RATIONAL(node)->val);
252 return rb_char_p_hash(RNODE_IMAGINARY(node)->val);
254 return rb_parser_str_hash(RNODE_STR(node)->
string);
256 return rb_parser_str_hash(RNODE_SYM(node)->
string);
258 return rb_parser_str_hash(RNODE_REGX(node)->
string);
260 return (st_index_t)node->nd_loc.beg_pos.lineno;
262 return rb_parser_str_hash(RNODE_FILE(node)->path);
264 return (st_index_t)RNODE_ENCODING(node)->enc;
266#ifdef UNIVERSAL_PARSER
269 rb_bug(
"unexpected node: %s", ruby_node_name(
type));
277 return '\0' <= c && c <=
'\x7f';
281#define ISASCII parse_isascii
286 return c ==
' ' || (
'\t' <= c && c <=
'\r');
290#define ISSPACE parse_isspace
295 return (
'\0' <= c && c <
' ') || c ==
'\x7f';
299#define ISCNTRL(c) parse_iscntrl(c)
304 return 'A' <= c && c <=
'Z';
310 return 'a' <= c && c <=
'z';
316 return parse_isupper(c) || parse_islower(c);
320#define ISALPHA(c) parse_isalpha(c)
325 return '0' <= c && c <=
'9';
329#define ISDIGIT(c) parse_isdigit(c)
338#define ISALNUM(c) parse_isalnum(c)
343 return ISDIGIT(c) || (
'A' <= c && c <=
'F') || (
'a' <= c && c <=
'f');
347#define ISXDIGIT(c) parse_isxdigit(c)
349#include "parser_st.h"
352#define STRCASECMP rb_parser_st_locale_insensitive_strcasecmp
355#define STRNCASECMP rb_parser_st_locale_insensitive_strncasecmp
358#include "ripper_init.h"
369 unsigned int in_defined: 1;
370 unsigned int in_kwarg: 1;
371 unsigned int in_argdef: 1;
372 unsigned int in_def: 1;
373 unsigned int in_class: 1;
374 unsigned int has_trailing_semicolon: 1;
375 BITFIELD(
enum rb_parser_shareability, shareable_constant_value, 2);
376 BITFIELD(
enum rescue_context, in_rescue, 2);
377 unsigned int cant_return: 1;
382#if defined(__GNUC__) && !defined(__clang__)
394#define NO_LEX_CTXT (struct lex_context){0}
396#ifndef WARN_PAST_SCOPE
397# define WARN_PAST_SCOPE 0
402#define yydebug (p->debug)
404#define YYFPRINTF(out, ...) rb_parser_printf(p, __VA_ARGS__)
405#define YY_LOCATION_PRINT(File, loc, p) \
406 rb_parser_printf(p, "%d.%d-%d.%d", \
407 (loc).beg_pos.lineno, (loc).beg_pos.column,\
408 (loc).end_pos.lineno, (loc).end_pos.column)
409#define YYLLOC_DEFAULT(Current, Rhs, N) \
413 (Current).beg_pos = YYRHSLOC(Rhs, 1).beg_pos; \
414 (Current).end_pos = YYRHSLOC(Rhs, N).end_pos; \
418 (Current).beg_pos = YYRHSLOC(Rhs, 0).end_pos; \
419 (Current).end_pos = YYRHSLOC(Rhs, 0).end_pos; \
423 (((Msgid)[0] == 'm') && (strcmp((Msgid), "memory exhausted") == 0) ? \
424 "nesting too deep" : (Msgid))
426#define RUBY_SET_YYLLOC_FROM_STRTERM_HEREDOC(Current) \
427 rb_parser_set_location_from_strterm_heredoc(p, &p->lex.strterm->u.heredoc, &(Current))
428#define RUBY_SET_YYLLOC_OF_DELAYED_TOKEN(Current) \
429 rb_parser_set_location_of_delayed_token(p, &(Current))
430#define RUBY_SET_YYLLOC_OF_HEREDOC_END(Current) \
431 rb_parser_set_location_of_heredoc_end(p, &(Current))
432#define RUBY_SET_YYLLOC_OF_DUMMY_END(Current) \
433 rb_parser_set_location_of_dummy_end(p, &(Current))
434#define RUBY_SET_YYLLOC_OF_NONE(Current) \
435 rb_parser_set_location_of_none(p, &(Current))
436#define RUBY_SET_YYLLOC(Current) \
437 rb_parser_set_location(p, &(Current))
438#define RUBY_INIT_YYLLOC() \
440 {p->ruby_sourceline, (int)(p->lex.ptok - p->lex.pbeg)}, \
441 {p->ruby_sourceline, (int)(p->lex.pcur - p->lex.pbeg)}, \
444#define IS_lex_state_for(x, ls) ((x) & (ls))
445#define IS_lex_state_all_for(x, ls) (((x) & (ls)) == (ls))
446#define IS_lex_state(ls) IS_lex_state_for(p->lex.state, (ls))
447#define IS_lex_state_all(ls) IS_lex_state_all_for(p->lex.state, (ls))
449# define SET_LEX_STATE(ls) \
450 parser_set_lex_state(p, ls, __LINE__)
451static inline enum lex_state_e parser_set_lex_state(
struct parser_params *p,
enum lex_state_e ls,
int line);
453typedef VALUE stack_type;
457# define SHOW_BITSTACK(stack, name) (p->debug ? rb_parser_show_bitstack(p, stack, name, __LINE__) : (void)0)
458# define BITSTACK_PUSH(stack, n) (((p->stack) = ((p->stack)<<1)|((n)&1)), SHOW_BITSTACK(p->stack, #stack"(push)"))
459# define BITSTACK_POP(stack) (((p->stack) = (p->stack) >> 1), SHOW_BITSTACK(p->stack, #stack"(pop)"))
460# define BITSTACK_SET_P(stack) (SHOW_BITSTACK(p->stack, #stack), (p->stack)&1)
461# define BITSTACK_SET(stack, n) ((p->stack)=(n), SHOW_BITSTACK(p->stack, #stack"(set)"))
465#define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))
466#define COND_POP() BITSTACK_POP(cond_stack)
467#define COND_P() BITSTACK_SET_P(cond_stack)
468#define COND_SET(n) BITSTACK_SET(cond_stack, (n))
472#define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))
473#define CMDARG_POP() BITSTACK_POP(cmdarg_stack)
474#define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)
475#define CMDARG_SET(n) BITSTACK_SET(cmdarg_stack, (n))
493 NODE *outer, *inner, *current;
510#define DVARS_INHERIT ((void*)1)
511#define DVARS_TOPSCOPE NULL
512#define DVARS_TERMINAL_P(tbl) ((tbl) == DVARS_INHERIT || (tbl) == DVARS_TOPSCOPE)
539#define AFTER_HEREDOC_WITHOUT_TERMINATOR ((rb_parser_string_t *)1)
556 rb_parser_lex_gets_func *gets;
557 rb_parser_input_data input;
565 enum lex_state_e state;
573 stack_type cond_stack;
574 stack_type cmdarg_stack;
579 int heredoc_line_indent;
586 const char *ruby_sourcefile;
587 VALUE ruby_sourcefile_string;
607 st_table *warn_duplicate_keys_table;
614 NODE *eval_tree_begin;
618#ifdef UNIVERSAL_PARSER
619 const rb_parser_config_t *config;
622 signed int frozen_string_literal:2;
624 unsigned int command_start:1;
625 unsigned int eofp: 1;
626 unsigned int ruby__end__seen: 1;
627 unsigned int debug: 1;
628 unsigned int has_shebang: 1;
629 unsigned int token_seen: 1;
630 unsigned int token_info_enabled: 1;
632 unsigned int past_scope_enabled: 1;
634 unsigned int error_p: 1;
635 unsigned int cr_seen: 1;
640 unsigned int do_print: 1;
641 unsigned int do_loop: 1;
642 unsigned int do_chomp: 1;
643 unsigned int do_split: 1;
644 unsigned int error_tolerant: 1;
645 unsigned int keep_tokens: 1;
663 VALUE parsing_thread;
670#define NUMPARAM_ID_P(id) numparam_id_p(p, id)
671#define NUMPARAM_ID_TO_IDX(id) (unsigned int)(((id) >> ID_SCOPE_SHIFT) - (tNUMPARAM_1 - 1))
672#define NUMPARAM_IDX_TO_ID(idx) TOKEN2LOCALID((tNUMPARAM_1 - 1 + (idx)))
676 if (!is_local_id(
id) ||
id < (tNUMPARAM_1 << ID_SCOPE_SHIFT))
return 0;
677 unsigned int idx = NUMPARAM_ID_TO_IDX(
id);
678 return idx > 0 && idx <= NUMPARAM_MAX;
687 rb_parser_printf(p,
"after-shift: %+"PRIsVALUE
"\n", p->s_value);
703 for (
int i = 0; i <
len; i++) {
706 rb_parser_printf(p,
"after-reduce pop: %+"PRIsVALUE
"\n", tos);
710 rb_parser_printf(p,
"after-reduce push: %+"PRIsVALUE
"\n", p->s_lvalue);
720 rb_parser_printf(p,
"after-shift-error-token:\n");
728 for (
int i = 0; i <
len; i++) {
731 rb_parser_printf(p,
"after-pop-stack pop: %+"PRIsVALUE
"\n", tos);
762#define intern_cstr(n,l,en) rb_intern3(n,l,en)
764#define STRING_NEW0() rb_parser_encoding_string_new(p,0,0,p->enc)
766#define STR_NEW(ptr,len) rb_enc_str_new((ptr),(len),p->enc)
767#define STR_NEW0() rb_enc_str_new(0,0,p->enc)
768#define STR_NEW2(ptr) rb_enc_str_new((ptr),strlen(ptr),p->enc)
769#define STR_NEW3(ptr,len,e,func) parser_str_new(p, (ptr),(len),(e),(func),p->enc)
770#define TOK_INTERN() intern_cstr(tok(p), toklen(p), p->enc)
771#define VALID_SYMNAME_P(s, l, enc, type) (rb_enc_symname_type(s, l, enc, (1U<<(type))) == (int)(type))
777 long len = RSTRING_LEN(str);
778 return len > 0 ? (
unsigned char)RSTRING_PTR(str)[
len-1] : when_empty;
785 st_free_table(p->pvtbl);
792 if (p->pktbl) st_free_table(p->pktbl);
796#define STRING_BUF_DEFAULT_LEN 16
804 buf->head = buf->last =
xmalloc(size);
805 buf->head->len = STRING_BUF_DEFAULT_LEN;
807 buf->head->next = NULL;
815 if (buf->head->used >= buf->head->len) {
817 long n = buf->head->len * 2;
824 buf->last->next = elem;
827 buf->last->buf[buf->last->used++] = str;
838 for (
long i = 0; i < elem->used; i++) {
839 rb_parser_string_free(p, elem->buf[i]);
851debug_end_expect_token_locations(
struct parser_params *p,
const char *name)
854 VALUE mesg = rb_sprintf(
"%s: [", name);
859 rb_str_catf(mesg,
"[%d, %d]", loc->pos->lineno, loc->pos->column);
863 flush_debug_buffer(p, p->debug_output, mesg);
870 if(!p->error_tolerant)
return;
874 locations->pos = pos;
875 locations->prev = p->end_expect_token_locations;
876 p->end_expect_token_locations = locations;
878 debug_end_expect_token_locations(p,
"push_end_expect_token_locations");
884 if(!p->end_expect_token_locations)
return;
888 p->end_expect_token_locations = locations;
890 debug_end_expect_token_locations(p,
"pop_end_expect_token_locations");
896 return p->end_expect_token_locations;
900parser_token2char(
struct parser_params *p,
enum yytokentype tok)
903#define TOKEN2CHAR(tok) case tok: return (#tok);
904#define TOKEN2CHAR2(tok, name) case tok: return (name);
905 TOKEN2CHAR2(
' ',
"word_sep");
906 TOKEN2CHAR2(
'!',
"!")
907 TOKEN2CHAR2('%', "%");
908 TOKEN2CHAR2('&', "&");
909 TOKEN2CHAR2('*', "*");
910 TOKEN2CHAR2('+', "+");
911 TOKEN2CHAR2('-', "-");
912 TOKEN2CHAR2('/', "/");
913 TOKEN2CHAR2('<', "<");
914 TOKEN2CHAR2('=', "=");
915 TOKEN2CHAR2('>', ">");
916 TOKEN2CHAR2('?', "?");
917 TOKEN2CHAR2('^', "^");
918 TOKEN2CHAR2('|', "|");
919 TOKEN2CHAR2('~', "~");
920 TOKEN2CHAR2(':', ":");
921 TOKEN2CHAR2(',', ",");
922 TOKEN2CHAR2('.', ".");
923 TOKEN2CHAR2(';', ";");
924 TOKEN2CHAR2('`', "`");
925 TOKEN2CHAR2('\n', "nl");
926 TOKEN2CHAR2('{
', "\"{\"");
927 TOKEN2CHAR2('}
', "\"}\"");
928 TOKEN2CHAR2('[
', "\"[\"");
929 TOKEN2CHAR2(']
', "\"]\"");
930 TOKEN2CHAR2('(
', "\"(\"");
931 TOKEN2CHAR2(')
', "\")\"");
932 TOKEN2CHAR2('\\
', "backslash");
933 TOKEN2CHAR(keyword_class);
934 TOKEN2CHAR(keyword_module);
935 TOKEN2CHAR(keyword_def);
936 TOKEN2CHAR(keyword_undef);
937 TOKEN2CHAR(keyword_begin);
938 TOKEN2CHAR(keyword_rescue);
939 TOKEN2CHAR(keyword_ensure);
940 TOKEN2CHAR(keyword_end);
941 TOKEN2CHAR(keyword_if);
942 TOKEN2CHAR(keyword_unless);
943 TOKEN2CHAR(keyword_then);
944 TOKEN2CHAR(keyword_elsif);
945 TOKEN2CHAR(keyword_else);
946 TOKEN2CHAR(keyword_case);
947 TOKEN2CHAR(keyword_when);
948 TOKEN2CHAR(keyword_while);
949 TOKEN2CHAR(keyword_until);
950 TOKEN2CHAR(keyword_for);
951 TOKEN2CHAR(keyword_break);
952 TOKEN2CHAR(keyword_next);
953 TOKEN2CHAR(keyword_redo);
954 TOKEN2CHAR(keyword_retry);
955 TOKEN2CHAR(keyword_in);
956 TOKEN2CHAR(keyword_do);
957 TOKEN2CHAR(keyword_do_cond);
958 TOKEN2CHAR(keyword_do_block);
959 TOKEN2CHAR(keyword_do_LAMBDA);
960 TOKEN2CHAR(keyword_return);
961 TOKEN2CHAR(keyword_yield);
962 TOKEN2CHAR(keyword_super);
963 TOKEN2CHAR(keyword_self);
964 TOKEN2CHAR(keyword_nil);
965 TOKEN2CHAR(keyword_true);
966 TOKEN2CHAR(keyword_false);
967 TOKEN2CHAR(keyword_and);
968 TOKEN2CHAR(keyword_or);
969 TOKEN2CHAR(keyword_not);
970 TOKEN2CHAR(modifier_if);
971 TOKEN2CHAR(modifier_unless);
972 TOKEN2CHAR(modifier_while);
973 TOKEN2CHAR(modifier_until);
974 TOKEN2CHAR(modifier_rescue);
975 TOKEN2CHAR(keyword_alias);
976 TOKEN2CHAR(keyword_defined);
977 TOKEN2CHAR(keyword_BEGIN);
978 TOKEN2CHAR(keyword_END);
979 TOKEN2CHAR(keyword__LINE__);
980 TOKEN2CHAR(keyword__FILE__);
981 TOKEN2CHAR(keyword__ENCODING__);
982 TOKEN2CHAR(tIDENTIFIER);
986 TOKEN2CHAR(tCONSTANT);
989 TOKEN2CHAR(tINTEGER);
991 TOKEN2CHAR(tRATIONAL);
992 TOKEN2CHAR(tIMAGINARY);
994 TOKEN2CHAR(tNTH_REF);
995 TOKEN2CHAR(tBACK_REF);
996 TOKEN2CHAR(tSTRING_CONTENT);
997 TOKEN2CHAR(tREGEXP_END);
998 TOKEN2CHAR(tDUMNY_END);
1001 TOKEN2CHAR(tUMINUS);
1012 TOKEN2CHAR(tNMATCH);
1021 TOKEN2CHAR(tANDDOT);
1022 TOKEN2CHAR(tCOLON2);
1023 TOKEN2CHAR(tCOLON3);
1024 TOKEN2CHAR(tOP_ASGN);
1026 TOKEN2CHAR(tLPAREN);
1027 TOKEN2CHAR(tLPAREN_ARG);
1028 TOKEN2CHAR(tLBRACK);
1029 TOKEN2CHAR(tLBRACE);
1030 TOKEN2CHAR(tLBRACE_ARG);
1034 TOKEN2CHAR(tLAMBDA);
1035 TOKEN2CHAR(tSYMBEG);
1036 TOKEN2CHAR(tSTRING_BEG);
1037 TOKEN2CHAR(tXSTRING_BEG);
1038 TOKEN2CHAR(tREGEXP_BEG);
1039 TOKEN2CHAR(tWORDS_BEG);
1040 TOKEN2CHAR(tQWORDS_BEG);
1041 TOKEN2CHAR(tSYMBOLS_BEG);
1042 TOKEN2CHAR(tQSYMBOLS_BEG);
1043 TOKEN2CHAR(tSTRING_END);
1044 TOKEN2CHAR(tSTRING_DEND);
1045 TOKEN2CHAR(tSTRING_DBEG);
1046 TOKEN2CHAR(tSTRING_DVAR);
1047 TOKEN2CHAR(tLAMBEG);
1048 TOKEN2CHAR(tLABEL_END);
1049 TOKEN2CHAR(tIGNORED_NL);
1050 TOKEN2CHAR(tCOMMENT);
1051 TOKEN2CHAR(tEMBDOC_BEG);
1052 TOKEN2CHAR(tEMBDOC);
1053 TOKEN2CHAR(tEMBDOC_END);
1054 TOKEN2CHAR(tHEREDOC_BEG);
1055 TOKEN2CHAR(tHEREDOC_END);
1056 TOKEN2CHAR(k__END__);
1057 TOKEN2CHAR(tLOWEST);
1058 TOKEN2CHAR(tUMINUS_NUM);
1059 TOKEN2CHAR(tLAST_TOKEN);
1064 rb_bug("parser_token2id: unknown token %d", tok);
1066 UNREACHABLE_RETURN(0);
1070push_end_expect_token_locations(struct parser_params *p, const rb_code_position_t *pos)
1075pop_end_expect_token_locations(struct parser_params *p)
1080RBIMPL_ATTR_NONNULL((1, 2, 3))
1081static int parser_yyerror(struct parser_params*, const YYLTYPE *yylloc, const char*);
1082RBIMPL_ATTR_NONNULL((1, 2))
1083static int parser_yyerror0(struct parser_params*, const char*);
1084#define yyerror0(msg) parser_yyerror0(p, (msg))
1085#define yyerror1(loc, msg) parser_yyerror(p, (loc), (msg))
1086#define yyerror(yylloc, p, msg) parser_yyerror(p, yylloc, msg)
1087#define token_flush(ptr) ((ptr)->lex.ptok = (ptr)->lex.pcur)
1088#define lex_goto_eol(p) ((p)->lex.pcur = (p)->lex.pend)
1089#define lex_eol_p(p) lex_eol_n_p(p, 0)
1090#define lex_eol_n_p(p,n) lex_eol_ptr_n_p(p, (p)->lex.pcur, n)
1091#define lex_eol_ptr_p(p,ptr) lex_eol_ptr_n_p(p,ptr,0)
1092#define lex_eol_ptr_n_p(p,ptr,n) ((ptr)+(n) >= (p)->lex.pend)
1094static void token_info_setup(token_info *ptinfo, const char *ptr, const rb_code_location_t *loc);
1095static void token_info_push(struct parser_params*, const char *token, const rb_code_location_t *loc);
1096static void token_info_pop(struct parser_params*, const char *token, const rb_code_location_t *loc);
1097static void token_info_warn(struct parser_params *p, const char *token, token_info *ptinfo_beg, int same, const rb_code_location_t *loc);
1098static void token_info_drop(struct parser_params *p, const char *token, rb_code_position_t beg_pos);
1101#define compile_for_eval (0)
1103#define compile_for_eval (p->parent_iseq != 0)
1106#define token_column ((int)(p->lex.ptok - p->lex.pbeg))
1108#define CALL_Q_P(q) ((q) == tANDDOT)
1109#define NEW_QCALL(q,r,m,a,loc) (CALL_Q_P(q) ? NEW_QCALL0(r,m,a,loc) : NEW_CALL(r,m,a,loc))
1111#define lambda_beginning_p() (p->lex.lpar_beg == p->lex.paren_nest)
1113static enum yytokentype yylex(YYSTYPE*, YYLTYPE*, struct parser_params*);
1116rb_discard_node(struct parser_params *p, NODE *n)
1118 rb_ast_delete_node(p->ast, n);
1121static rb_node_scope_t *rb_node_scope_new(struct parser_params *p, rb_node_args_t *nd_args, NODE *nd_body, const YYLTYPE *loc);
1122static rb_node_scope_t *rb_node_scope_new2(struct parser_params *p, rb_ast_id_table_t *nd_tbl, rb_node_args_t *nd_args, NODE *nd_body, const YYLTYPE *loc);
1123static rb_node_block_t *rb_node_block_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc);
1124static rb_node_if_t *rb_node_if_new(struct parser_params *p, NODE *nd_cond, NODE *nd_body, NODE *nd_else, const YYLTYPE *loc, const YYLTYPE* if_keyword_loc, const YYLTYPE* then_keyword_loc, const YYLTYPE* end_keyword_loc);
1125static rb_node_unless_t *rb_node_unless_new(struct parser_params *p, NODE *nd_cond, NODE *nd_body, NODE *nd_else, const YYLTYPE *loc, const YYLTYPE *keyword_loc, const YYLTYPE *then_keyword_loc, const YYLTYPE *end_keyword_loc);
1126static rb_node_case_t *rb_node_case_new(struct parser_params *p, NODE *nd_head, NODE *nd_body, const YYLTYPE *loc, const YYLTYPE *case_keyword_loc, const YYLTYPE *end_keyword_loc);
1127static rb_node_case2_t *rb_node_case2_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc, const YYLTYPE *case_keyword_loc, const YYLTYPE *end_keyword_loc);
1128static rb_node_case3_t *rb_node_case3_new(struct parser_params *p, NODE *nd_head, NODE *nd_body, const YYLTYPE *loc, const YYLTYPE *case_keyword_loc, const YYLTYPE *end_keyword_loc);
1129static rb_node_when_t *rb_node_when_new(struct parser_params *p, NODE *nd_head, NODE *nd_body, NODE *nd_next, const YYLTYPE *loc, const YYLTYPE *keyword_loc, const YYLTYPE *then_keyword_loc);
1130static rb_node_in_t *rb_node_in_new(struct parser_params *p, NODE *nd_head, NODE *nd_body, NODE *nd_next, const YYLTYPE *loc);
1131static rb_node_while_t *rb_node_while_new(struct parser_params *p, NODE *nd_cond, NODE *nd_body, long nd_state, const YYLTYPE *loc, const YYLTYPE *keyword_loc, const YYLTYPE *closing_loc);
1132static rb_node_until_t *rb_node_until_new(struct parser_params *p, NODE *nd_cond, NODE *nd_body, long nd_state, const YYLTYPE *loc, const YYLTYPE *keyword_loc, const YYLTYPE *closing_loc);
1133static rb_node_iter_t *rb_node_iter_new(struct parser_params *p, rb_node_args_t *nd_args, NODE *nd_body, const YYLTYPE *loc);
1134static rb_node_for_t *rb_node_for_new(struct parser_params *p, NODE *nd_iter, NODE *nd_body, const YYLTYPE *loc, const YYLTYPE *for_keyword_loc, const YYLTYPE *in_keyword_loc, const YYLTYPE *do_keyword_loc, const YYLTYPE *end_keyword_loc);
1135static rb_node_for_masgn_t *rb_node_for_masgn_new(struct parser_params *p, NODE *nd_var, const YYLTYPE *loc);
1136static rb_node_retry_t *rb_node_retry_new(struct parser_params *p, const YYLTYPE *loc);
1137static rb_node_begin_t *rb_node_begin_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc);
1138static rb_node_rescue_t *rb_node_rescue_new(struct parser_params *p, NODE *nd_head, NODE *nd_resq, NODE *nd_else, const YYLTYPE *loc);
1139static rb_node_resbody_t *rb_node_resbody_new(struct parser_params *p, NODE *nd_args, NODE *nd_exc_var, NODE *nd_body, NODE *nd_next, const YYLTYPE *loc);
1140static rb_node_ensure_t *rb_node_ensure_new(struct parser_params *p, NODE *nd_head, NODE *nd_ensr, const YYLTYPE *loc);
1141static rb_node_and_t *rb_node_and_new(struct parser_params *p, NODE *nd_1st, NODE *nd_2nd, const YYLTYPE *loc, const YYLTYPE *operator_loc);
1142static rb_node_or_t *rb_node_or_new(struct parser_params *p, NODE *nd_1st, NODE *nd_2nd, const YYLTYPE *loc, const YYLTYPE *operator_loc);
1143static rb_node_masgn_t *rb_node_masgn_new(struct parser_params *p, NODE *nd_head, NODE *nd_args, const YYLTYPE *loc);
1144static rb_node_lasgn_t *rb_node_lasgn_new(struct parser_params *p, ID nd_vid, NODE *nd_value, const YYLTYPE *loc);
1145static rb_node_dasgn_t *rb_node_dasgn_new(struct parser_params *p, ID nd_vid, NODE *nd_value, const YYLTYPE *loc);
1146static rb_node_gasgn_t *rb_node_gasgn_new(struct parser_params *p, ID nd_vid, NODE *nd_value, const YYLTYPE *loc);
1147static rb_node_iasgn_t *rb_node_iasgn_new(struct parser_params *p, ID nd_vid, NODE *nd_value, const YYLTYPE *loc);
1148static rb_node_cdecl_t *rb_node_cdecl_new(struct parser_params *p, ID nd_vid, NODE *nd_value, NODE *nd_else, enum rb_parser_shareability shareability, const YYLTYPE *loc);
1149static rb_node_cvasgn_t *rb_node_cvasgn_new(struct parser_params *p, ID nd_vid, NODE *nd_value, const YYLTYPE *loc);
1150static rb_node_op_asgn1_t *rb_node_op_asgn1_new(struct parser_params *p, NODE *nd_recv, ID nd_mid, NODE *index, NODE *rvalue, const YYLTYPE *loc, const YYLTYPE *call_operator_loc, const YYLTYPE *opening_loc, const YYLTYPE *closing_loc, const YYLTYPE *binary_operator_loc);
1151static rb_node_op_asgn2_t *rb_node_op_asgn2_new(struct parser_params *p, NODE *nd_recv, NODE *nd_value, ID nd_vid, ID nd_mid, bool nd_aid, const YYLTYPE *loc, const YYLTYPE *call_operator_loc, const YYLTYPE *message_loc, const YYLTYPE *binary_operator_loc);
1152static rb_node_op_asgn_or_t *rb_node_op_asgn_or_new(struct parser_params *p, NODE *nd_head, NODE *nd_value, const YYLTYPE *loc);
1153static rb_node_op_asgn_and_t *rb_node_op_asgn_and_new(struct parser_params *p, NODE *nd_head, NODE *nd_value, const YYLTYPE *loc);
1154static rb_node_op_cdecl_t *rb_node_op_cdecl_new(struct parser_params *p, NODE *nd_head, NODE *nd_value, ID nd_aid, enum rb_parser_shareability shareability, const YYLTYPE *loc);
1155static rb_node_call_t *rb_node_call_new(struct parser_params *p, NODE *nd_recv, ID nd_mid, NODE *nd_args, const YYLTYPE *loc);
1156static rb_node_opcall_t *rb_node_opcall_new(struct parser_params *p, NODE *nd_recv, ID nd_mid, NODE *nd_args, const YYLTYPE *loc);
1157static rb_node_fcall_t *rb_node_fcall_new(struct parser_params *p, ID nd_mid, NODE *nd_args, const YYLTYPE *loc);
1158static rb_node_vcall_t *rb_node_vcall_new(struct parser_params *p, ID nd_mid, const YYLTYPE *loc);
1159static rb_node_qcall_t *rb_node_qcall_new(struct parser_params *p, NODE *nd_recv, ID nd_mid, NODE *nd_args, const YYLTYPE *loc);
1160static rb_node_super_t *rb_node_super_new(struct parser_params *p, NODE *nd_args, const YYLTYPE *loc, const YYLTYPE *keyword_loc, const YYLTYPE *lparen_loc, const YYLTYPE *rparen_loc);
1161static rb_node_zsuper_t * rb_node_zsuper_new(struct parser_params *p, const YYLTYPE *loc);
1162static rb_node_list_t *rb_node_list_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc);
1163static rb_node_list_t *rb_node_list_new2(struct parser_params *p, NODE *nd_head, long nd_alen, NODE *nd_next, const YYLTYPE *loc);
1164static rb_node_zlist_t *rb_node_zlist_new(struct parser_params *p, const YYLTYPE *loc);
1165static rb_node_hash_t *rb_node_hash_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc);
1166static rb_node_return_t *rb_node_return_new(struct parser_params *p, NODE *nd_stts, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1167static rb_node_yield_t *rb_node_yield_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc, const YYLTYPE *keyword_loc, const YYLTYPE *lparen_loc, const YYLTYPE *rparen_loc);
1168static rb_node_lvar_t *rb_node_lvar_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1169static rb_node_dvar_t *rb_node_dvar_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1170static rb_node_gvar_t *rb_node_gvar_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1171static rb_node_ivar_t *rb_node_ivar_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1172static rb_node_const_t *rb_node_const_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1173static rb_node_cvar_t *rb_node_cvar_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1174static rb_node_nth_ref_t *rb_node_nth_ref_new(struct parser_params *p, long nd_nth, const YYLTYPE *loc);
1175static rb_node_back_ref_t *rb_node_back_ref_new(struct parser_params *p, long nd_nth, const YYLTYPE *loc);
1176static rb_node_match2_t *rb_node_match2_new(struct parser_params *p, NODE *nd_recv, NODE *nd_value, const YYLTYPE *loc);
1177static rb_node_match3_t *rb_node_match3_new(struct parser_params *p, NODE *nd_recv, NODE *nd_value, const YYLTYPE *loc);
1178static rb_node_integer_t * rb_node_integer_new(struct parser_params *p, char* val, int base, const YYLTYPE *loc);
1179static rb_node_float_t * rb_node_float_new(struct parser_params *p, char* val, const YYLTYPE *loc);
1180static rb_node_rational_t * rb_node_rational_new(struct parser_params *p, char* val, int base, int seen_point, const YYLTYPE *loc);
1181static rb_node_imaginary_t * rb_node_imaginary_new(struct parser_params *p, char* val, int base, int seen_point, enum rb_numeric_type, const YYLTYPE *loc);
1182static rb_node_str_t *rb_node_str_new(struct parser_params *p, rb_parser_string_t *string, const YYLTYPE *loc);
1183static rb_node_dstr_t *rb_node_dstr_new0(struct parser_params *p, rb_parser_string_t *string, long nd_alen, NODE *nd_next, const YYLTYPE *loc);
1184static rb_node_dstr_t *rb_node_dstr_new(struct parser_params *p, rb_parser_string_t *string, const YYLTYPE *loc);
1185static rb_node_xstr_t *rb_node_xstr_new(struct parser_params *p, rb_parser_string_t *string, const YYLTYPE *loc);
1186static rb_node_dxstr_t *rb_node_dxstr_new(struct parser_params *p, rb_parser_string_t *string, long nd_alen, NODE *nd_next, const YYLTYPE *loc);
1187static rb_node_evstr_t *rb_node_evstr_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc, const YYLTYPE *opening_loc, const YYLTYPE *closing_loc);
1188static rb_node_regx_t *rb_node_regx_new(struct parser_params *p, rb_parser_string_t *string, int options, const YYLTYPE *loc, const YYLTYPE *opening_loc, const YYLTYPE *content_loc, const YYLTYPE *closing_loc);
1189static rb_node_once_t *rb_node_once_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc);
1190static rb_node_args_t *rb_node_args_new(struct parser_params *p, const YYLTYPE *loc);
1191static rb_node_args_aux_t *rb_node_args_aux_new(struct parser_params *p, ID nd_pid, int nd_plen, const YYLTYPE *loc);
1192static rb_node_opt_arg_t *rb_node_opt_arg_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc);
1193static rb_node_kw_arg_t *rb_node_kw_arg_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc);
1194static rb_node_postarg_t *rb_node_postarg_new(struct parser_params *p, NODE *nd_1st, NODE *nd_2nd, const YYLTYPE *loc);
1195static rb_node_argscat_t *rb_node_argscat_new(struct parser_params *p, NODE *nd_head, NODE *nd_body, const YYLTYPE *loc);
1196static rb_node_argspush_t *rb_node_argspush_new(struct parser_params *p, NODE *nd_head, NODE *nd_body, const YYLTYPE *loc);
1197static rb_node_splat_t *rb_node_splat_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc, const YYLTYPE *operator_loc);
1198static rb_node_block_pass_t *rb_node_block_pass_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc, const YYLTYPE *operator_loc);
1199static rb_node_defn_t *rb_node_defn_new(struct parser_params *p, ID nd_mid, NODE *nd_defn, const YYLTYPE *loc);
1200static rb_node_defs_t *rb_node_defs_new(struct parser_params *p, NODE *nd_recv, ID nd_mid, NODE *nd_defn, const YYLTYPE *loc);
1201static rb_node_alias_t *rb_node_alias_new(struct parser_params *p, NODE *nd_1st, NODE *nd_2nd, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1202static rb_node_valias_t *rb_node_valias_new(struct parser_params *p, ID nd_alias, ID nd_orig, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1203static rb_node_undef_t *rb_node_undef_new(struct parser_params *p, NODE *nd_undef, const YYLTYPE *loc);
1204static rb_node_class_t *rb_node_class_new(struct parser_params *p, NODE *nd_cpath, NODE *nd_body, NODE *nd_super, const YYLTYPE *loc, const YYLTYPE *class_keyword_loc, const YYLTYPE *inheritance_operator_loc, const YYLTYPE *end_keyword_loc);
1205static rb_node_module_t *rb_node_module_new(struct parser_params *p, NODE *nd_cpath, NODE *nd_body, const YYLTYPE *loc);
1206static rb_node_sclass_t *rb_node_sclass_new(struct parser_params *p, NODE *nd_recv, NODE *nd_body, const YYLTYPE *loc);
1207static rb_node_colon2_t *rb_node_colon2_new(struct parser_params *p, NODE *nd_head, ID nd_mid, const YYLTYPE *loc, const YYLTYPE *delimiter_loc, const YYLTYPE *name_loc);
1208static rb_node_colon3_t *rb_node_colon3_new(struct parser_params *p, ID nd_mid, const YYLTYPE *loc, const YYLTYPE *delimiter_loc, const YYLTYPE *name_loc);
1209static rb_node_dot2_t *rb_node_dot2_new(struct parser_params *p, NODE *nd_beg, NODE *nd_end, const YYLTYPE *loc, const YYLTYPE *operator_loc);
1210static rb_node_dot3_t *rb_node_dot3_new(struct parser_params *p, NODE *nd_beg, NODE *nd_end, const YYLTYPE *loc, const YYLTYPE *operator_loc);
1211static rb_node_self_t *rb_node_self_new(struct parser_params *p, const YYLTYPE *loc);
1212static rb_node_nil_t *rb_node_nil_new(struct parser_params *p, const YYLTYPE *loc);
1213static rb_node_true_t *rb_node_true_new(struct parser_params *p, const YYLTYPE *loc);
1214static rb_node_false_t *rb_node_false_new(struct parser_params *p, const YYLTYPE *loc);
1215static rb_node_errinfo_t *rb_node_errinfo_new(struct parser_params *p, const YYLTYPE *loc);
1216static rb_node_defined_t *rb_node_defined_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1217static rb_node_postexe_t *rb_node_postexe_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc, const YYLTYPE *keyword_loc, const YYLTYPE *opening_loc, const YYLTYPE *closing_loc);
1218static rb_node_sym_t *rb_node_sym_new(struct parser_params *p, VALUE str, const YYLTYPE *loc);
1219static rb_node_dsym_t *rb_node_dsym_new(struct parser_params *p, rb_parser_string_t *string, long nd_alen, NODE *nd_next, const YYLTYPE *loc);
1220static rb_node_attrasgn_t *rb_node_attrasgn_new(struct parser_params *p, NODE *nd_recv, ID nd_mid, NODE *nd_args, const YYLTYPE *loc);
1221static rb_node_lambda_t *rb_node_lambda_new(struct parser_params *p, rb_node_args_t *nd_args, NODE *nd_body, const YYLTYPE *loc, const YYLTYPE *operator_loc, const YYLTYPE *opening_loc, const YYLTYPE *closing_loc);
1222static rb_node_aryptn_t *rb_node_aryptn_new(struct parser_params *p, NODE *pre_args, NODE *rest_arg, NODE *post_args, const YYLTYPE *loc);
1223static rb_node_hshptn_t *rb_node_hshptn_new(struct parser_params *p, NODE *nd_pconst, NODE *nd_pkwargs, NODE *nd_pkwrestarg, const YYLTYPE *loc);
1224static rb_node_fndptn_t *rb_node_fndptn_new(struct parser_params *p, NODE *pre_rest_arg, NODE *args, NODE *post_rest_arg, const YYLTYPE *loc);
1225static rb_node_line_t *rb_node_line_new(struct parser_params *p, const YYLTYPE *loc);
1226static rb_node_file_t *rb_node_file_new(struct parser_params *p, VALUE str, const YYLTYPE *loc);
1227static rb_node_error_t *rb_node_error_new(struct parser_params *p, const YYLTYPE *loc);
1229#define NEW_SCOPE(a,b,loc) (NODE *)rb_node_scope_new(p,a,b,loc)
1230#define NEW_SCOPE2(t,a,b,loc) (NODE *)rb_node_scope_new2(p,t,a,b,loc)
1231#define NEW_BLOCK(a,loc) (NODE *)rb_node_block_new(p,a,loc)
1232#define NEW_IF(c,t,e,loc,ik_loc,tk_loc,ek_loc) (NODE *)rb_node_if_new(p,c,t,e,loc,ik_loc,tk_loc,ek_loc)
1233#define NEW_UNLESS(c,t,e,loc,k_loc,t_loc,e_loc) (NODE *)rb_node_unless_new(p,c,t,e,loc,k_loc,t_loc,e_loc)
1234#define NEW_CASE(h,b,loc,ck_loc,ek_loc) (NODE *)rb_node_case_new(p,h,b,loc,ck_loc,ek_loc)
1235#define NEW_CASE2(b,loc,ck_loc,ek_loc) (NODE *)rb_node_case2_new(p,b,loc,ck_loc,ek_loc)
1236#define NEW_CASE3(h,b,loc,ck_loc,ek_loc) (NODE *)rb_node_case3_new(p,h,b,loc,ck_loc,ek_loc)
1237#define NEW_WHEN(c,t,e,loc,k_loc,t_loc) (NODE *)rb_node_when_new(p,c,t,e,loc,k_loc,t_loc)
1238#define NEW_IN(c,t,e,loc) (NODE *)rb_node_in_new(p,c,t,e,loc)
1239#define NEW_WHILE(c,b,n,loc,k_loc,c_loc) (NODE *)rb_node_while_new(p,c,b,n,loc,k_loc,c_loc)
1240#define NEW_UNTIL(c,b,n,loc,k_loc,c_loc) (NODE *)rb_node_until_new(p,c,b,n,loc,k_loc,c_loc)
1241#define NEW_ITER(a,b,loc) (NODE *)rb_node_iter_new(p,a,b,loc)
1242#define NEW_FOR(i,b,loc,f_loc,i_loc,d_loc,e_loc) (NODE *)rb_node_for_new(p,i,b,loc,f_loc,i_loc,d_loc,e_loc)
1243#define NEW_FOR_MASGN(v,loc) (NODE *)rb_node_for_masgn_new(p,v,loc)
1244#define NEW_RETRY(loc) (NODE *)rb_node_retry_new(p,loc)
1245#define NEW_BEGIN(b,loc) (NODE *)rb_node_begin_new(p,b,loc)
1246#define NEW_RESCUE(b,res,e,loc) (NODE *)rb_node_rescue_new(p,b,res,e,loc)
1247#define NEW_RESBODY(a,v,ex,n,loc) (NODE *)rb_node_resbody_new(p,a,v,ex,n,loc)
1248#define NEW_ENSURE(b,en,loc) (NODE *)rb_node_ensure_new(p,b,en,loc)
1249#define NEW_AND(f,s,loc,op_loc) (NODE *)rb_node_and_new(p,f,s,loc,op_loc)
1250#define NEW_OR(f,s,loc,op_loc) (NODE *)rb_node_or_new(p,f,s,loc,op_loc)
1251#define NEW_MASGN(l,r,loc) rb_node_masgn_new(p,l,r,loc)
1252#define NEW_LASGN(v,val,loc) (NODE *)rb_node_lasgn_new(p,v,val,loc)
1253#define NEW_DASGN(v,val,loc) (NODE *)rb_node_dasgn_new(p,v,val,loc)
1254#define NEW_GASGN(v,val,loc) (NODE *)rb_node_gasgn_new(p,v,val,loc)
1255#define NEW_IASGN(v,val,loc) (NODE *)rb_node_iasgn_new(p,v,val,loc)
1256#define NEW_CDECL(v,val,path,share,loc) (NODE *)rb_node_cdecl_new(p,v,val,path,share,loc)
1257#define NEW_CVASGN(v,val,loc) (NODE *)rb_node_cvasgn_new(p,v,val,loc)
1258#define NEW_OP_ASGN1(r,id,idx,rval,loc,c_op_loc,o_loc,c_loc,b_op_loc) (NODE *)rb_node_op_asgn1_new(p,r,id,idx,rval,loc,c_op_loc,o_loc,c_loc,b_op_loc)
1259#define NEW_OP_ASGN2(r,t,i,o,val,loc,c_op_loc,m_loc,b_op_loc) (NODE *)rb_node_op_asgn2_new(p,r,val,i,o,t,loc,c_op_loc,m_loc,b_op_loc)
1260#define NEW_OP_ASGN_OR(i,val,loc) (NODE *)rb_node_op_asgn_or_new(p,i,val,loc)
1261#define NEW_OP_ASGN_AND(i,val,loc) (NODE *)rb_node_op_asgn_and_new(p,i,val,loc)
1262#define NEW_OP_CDECL(v,op,val,share,loc) (NODE *)rb_node_op_cdecl_new(p,v,val,op,share,loc)
1263#define NEW_CALL(r,m,a,loc) (NODE *)rb_node_call_new(p,r,m,a,loc)
1264#define NEW_OPCALL(r,m,a,loc) (NODE *)rb_node_opcall_new(p,r,m,a,loc)
1265#define NEW_FCALL(m,a,loc) rb_node_fcall_new(p,m,a,loc)
1266#define NEW_VCALL(m,loc) (NODE *)rb_node_vcall_new(p,m,loc)
1267#define NEW_QCALL0(r,m,a,loc) (NODE *)rb_node_qcall_new(p,r,m,a,loc)
1268#define NEW_SUPER(a,loc,k_loc,l_loc,r_loc) (NODE *)rb_node_super_new(p,a,loc,k_loc,l_loc,r_loc)
1269#define NEW_ZSUPER(loc) (NODE *)rb_node_zsuper_new(p,loc)
1270#define NEW_LIST(a,loc) (NODE *)rb_node_list_new(p,a,loc)
1271#define NEW_LIST2(h,l,n,loc) (NODE *)rb_node_list_new2(p,h,l,n,loc)
1272#define NEW_ZLIST(loc) (NODE *)rb_node_zlist_new(p,loc)
1273#define NEW_HASH(a,loc) (NODE *)rb_node_hash_new(p,a,loc)
1274#define NEW_RETURN(s,loc,k_loc) (NODE *)rb_node_return_new(p,s,loc,k_loc)
1275#define NEW_YIELD(a,loc,k_loc,l_loc,r_loc) (NODE *)rb_node_yield_new(p,a,loc,k_loc,l_loc,r_loc)
1276#define NEW_LVAR(v,loc) (NODE *)rb_node_lvar_new(p,v,loc)
1277#define NEW_DVAR(v,loc) (NODE *)rb_node_dvar_new(p,v,loc)
1278#define NEW_GVAR(v,loc) (NODE *)rb_node_gvar_new(p,v,loc)
1279#define NEW_IVAR(v,loc) (NODE *)rb_node_ivar_new(p,v,loc)
1280#define NEW_CONST(v,loc) (NODE *)rb_node_const_new(p,v,loc)
1281#define NEW_CVAR(v,loc) (NODE *)rb_node_cvar_new(p,v,loc)
1282#define NEW_NTH_REF(n,loc) (NODE *)rb_node_nth_ref_new(p,n,loc)
1283#define NEW_BACK_REF(n,loc) (NODE *)rb_node_back_ref_new(p,n,loc)
1284#define NEW_MATCH2(n1,n2,loc) (NODE *)rb_node_match2_new(p,n1,n2,loc)
1285#define NEW_MATCH3(r,n2,loc) (NODE *)rb_node_match3_new(p,r,n2,loc)
1286#define NEW_INTEGER(val, base,loc) (NODE *)rb_node_integer_new(p,val,base,loc)
1287#define NEW_FLOAT(val,loc) (NODE *)rb_node_float_new(p,val,loc)
1288#define NEW_RATIONAL(val,base,seen_point,loc) (NODE *)rb_node_rational_new(p,val,base,seen_point,loc)
1289#define NEW_IMAGINARY(val,base,seen_point,numeric_type,loc) (NODE *)rb_node_imaginary_new(p,val,base,seen_point,numeric_type,loc)
1290#define NEW_STR(s,loc) (NODE *)rb_node_str_new(p,s,loc)
1291#define NEW_DSTR0(s,l,n,loc) (NODE *)rb_node_dstr_new0(p,s,l,n,loc)
1292#define NEW_DSTR(s,loc) (NODE *)rb_node_dstr_new(p,s,loc)
1293#define NEW_XSTR(s,loc) (NODE *)rb_node_xstr_new(p,s,loc)
1294#define NEW_DXSTR(s,l,n,loc) (NODE *)rb_node_dxstr_new(p,s,l,n,loc)
1295#define NEW_EVSTR(n,loc,o_loc,c_loc) (NODE *)rb_node_evstr_new(p,n,loc,o_loc,c_loc)
1296#define NEW_REGX(str,opts,loc,o_loc,ct_loc,c_loc) (NODE *)rb_node_regx_new(p,str,opts,loc,o_loc,ct_loc,c_loc)
1297#define NEW_ONCE(b,loc) (NODE *)rb_node_once_new(p,b,loc)
1298#define NEW_ARGS(loc) rb_node_args_new(p,loc)
1299#define NEW_ARGS_AUX(r,b,loc) rb_node_args_aux_new(p,r,b,loc)
1300#define NEW_OPT_ARG(v,loc) rb_node_opt_arg_new(p,v,loc)
1301#define NEW_KW_ARG(v,loc) rb_node_kw_arg_new(p,v,loc)
1302#define NEW_POSTARG(i,v,loc) (NODE *)rb_node_postarg_new(p,i,v,loc)
1303#define NEW_ARGSCAT(a,b,loc) (NODE *)rb_node_argscat_new(p,a,b,loc)
1304#define NEW_ARGSPUSH(a,b,loc) (NODE *)rb_node_argspush_new(p,a,b,loc)
1305#define NEW_SPLAT(a,loc,op_loc) (NODE *)rb_node_splat_new(p,a,loc,op_loc)
1306#define NEW_BLOCK_PASS(b,loc,o_loc) rb_node_block_pass_new(p,b,loc,o_loc)
1307#define NEW_DEFN(i,s,loc) (NODE *)rb_node_defn_new(p,i,s,loc)
1308#define NEW_DEFS(r,i,s,loc) (NODE *)rb_node_defs_new(p,r,i,s,loc)
1309#define NEW_ALIAS(n,o,loc,k_loc) (NODE *)rb_node_alias_new(p,n,o,loc,k_loc)
1310#define NEW_VALIAS(n,o,loc,k_loc) (NODE *)rb_node_valias_new(p,n,o,loc,k_loc)
1311#define NEW_UNDEF(i,loc) (NODE *)rb_node_undef_new(p,i,loc)
1312#define NEW_CLASS(n,b,s,loc,ck_loc,io_loc,ek_loc) (NODE *)rb_node_class_new(p,n,b,s,loc,ck_loc,io_loc,ek_loc)
1313#define NEW_MODULE(n,b,loc) (NODE *)rb_node_module_new(p,n,b,loc)
1314#define NEW_SCLASS(r,b,loc) (NODE *)rb_node_sclass_new(p,r,b,loc)
1315#define NEW_COLON2(c,i,loc,d_loc,n_loc) (NODE *)rb_node_colon2_new(p,c,i,loc,d_loc,n_loc)
1316#define NEW_COLON3(i,loc,d_loc,n_loc) (NODE *)rb_node_colon3_new(p,i,loc,d_loc,n_loc)
1317#define NEW_DOT2(b,e,loc,op_loc) (NODE *)rb_node_dot2_new(p,b,e,loc,op_loc)
1318#define NEW_DOT3(b,e,loc,op_loc) (NODE *)rb_node_dot3_new(p,b,e,loc,op_loc)
1319#define NEW_SELF(loc) (NODE *)rb_node_self_new(p,loc)
1320#define NEW_NIL(loc) (NODE *)rb_node_nil_new(p,loc)
1321#define NEW_TRUE(loc) (NODE *)rb_node_true_new(p,loc)
1322#define NEW_FALSE(loc) (NODE *)rb_node_false_new(p,loc)
1323#define NEW_ERRINFO(loc) (NODE *)rb_node_errinfo_new(p,loc)
1324#define NEW_DEFINED(e,loc,k_loc) (NODE *)rb_node_defined_new(p,e,loc, k_loc)
1325#define NEW_POSTEXE(b,loc,k_loc,o_loc,c_loc) (NODE *)rb_node_postexe_new(p,b,loc,k_loc,o_loc,c_loc)
1326#define NEW_SYM(str,loc) (NODE *)rb_node_sym_new(p,str,loc)
1327#define NEW_DSYM(s,l,n,loc) (NODE *)rb_node_dsym_new(p,s,l,n,loc)
1328#define NEW_ATTRASGN(r,m,a,loc) (NODE *)rb_node_attrasgn_new(p,r,m,a,loc)
1329#define NEW_LAMBDA(a,b,loc,op_loc,o_loc,c_loc) (NODE *)rb_node_lambda_new(p,a,b,loc,op_loc,o_loc,c_loc)
1330#define NEW_ARYPTN(pre,r,post,loc) (NODE *)rb_node_aryptn_new(p,pre,r,post,loc)
1331#define NEW_HSHPTN(c,kw,kwrest,loc) (NODE *)rb_node_hshptn_new(p,c,kw,kwrest,loc)
1332#define NEW_FNDPTN(pre,a,post,loc) (NODE *)rb_node_fndptn_new(p,pre,a,post,loc)
1333#define NEW_LINE(loc) (NODE *)rb_node_line_new(p,loc)
1334#define NEW_FILE(str,loc) (NODE *)rb_node_file_new(p,str,loc)
1335#define NEW_ENCODING(loc) (NODE *)rb_node_encoding_new(p,loc)
1336#define NEW_ERROR(loc) (NODE *)rb_node_error_new(p,loc)
1338enum internal_node_type {
1339 NODE_INTERNAL_ONLY = NODE_LAST,
1346parser_node_name(int node)
1350 return "NODE_DEF_TEMP";
1352 return "NODE_EXITS";
1354 return ruby_node_name(node);
1358/* This node is parse.y internal */
1359struct RNode_DEF_TEMP {
1362 /* for NODE_DEFN/NODE_DEFS */
1364 struct RNode *nd_def;
1369 NODE *numparam_save;
1370 struct lex_context ctxt;
1374#define RNODE_DEF_TEMP(node) ((struct RNode_DEF_TEMP *)(node))
1376static rb_node_break_t *rb_node_break_new(struct parser_params *p, NODE *nd_stts, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1377static rb_node_next_t *rb_node_next_new(struct parser_params *p, NODE *nd_stts, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1378static rb_node_redo_t *rb_node_redo_new(struct parser_params *p, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1379static rb_node_def_temp_t *rb_node_def_temp_new(struct parser_params *p, const YYLTYPE *loc);
1380static rb_node_def_temp_t *def_head_save(struct parser_params *p, rb_node_def_temp_t *n);
1382#define NEW_BREAK(s,loc,k_loc) (NODE *)rb_node_break_new(p,s,loc,k_loc)
1383#define NEW_NEXT(s,loc,k_loc) (NODE *)rb_node_next_new(p,s,loc,k_loc)
1384#define NEW_REDO(loc,k_loc) (NODE *)rb_node_redo_new(p,loc,k_loc)
1385#define NEW_DEF_TEMP(loc) rb_node_def_temp_new(p,loc)
1387/* Make a new internal node, which should not be appeared in the
1388 * result AST and does not have node_id and location. */
1389static NODE* node_new_internal(struct parser_params *p, enum node_type type, size_t size, size_t alignment);
1390#define NODE_NEW_INTERNAL(ndtype, type) (type *)node_new_internal(p, (enum node_type)(ndtype), sizeof(type), RUBY_ALIGNOF(type))
1392static NODE *nd_set_loc(NODE *nd, const YYLTYPE *loc);
1395parser_get_node_id(struct parser_params *p)
1397 int node_id = p->node_id;
1403anddot_multiple_assignment_check(struct parser_params* p, const YYLTYPE *loc, ID id)
1405 if (id == tANDDOT) {
1406 yyerror1(loc, "&. inside multiple assignment destination");
1411set_line_body(NODE *body, int line)
1414 switch (nd_type(body)) {
1417 nd_set_line(body, line);
1422set_embraced_location(NODE *node, const rb_code_location_t *beg, const rb_code_location_t *end)
1424 RNODE_ITER(node)->nd_body->nd_loc = code_loc_gen(beg, end);
1425 nd_set_line(node, beg->end_pos.lineno);
1429last_expr_node(NODE *expr)
1432 if (nd_type_p(expr, NODE_BLOCK)) {
1433 expr = RNODE_BLOCK(RNODE_BLOCK(expr)->nd_end)->nd_head;
1435 else if (nd_type_p(expr, NODE_BEGIN) && RNODE_BEGIN(expr)->nd_body) {
1436 expr = RNODE_BEGIN(expr)->nd_body;
1446#define yyparse ruby_yyparse
1449static NODE* cond(struct parser_params *p, NODE *node, const YYLTYPE *loc);
1450static NODE* method_cond(struct parser_params *p, NODE *node, const YYLTYPE *loc);
1451#define new_nil(loc) NEW_NIL(loc)
1452static NODE *new_nil_at(struct parser_params *p, const rb_code_position_t *pos);
1453static NODE *new_if(struct parser_params*,NODE*,NODE*,NODE*,const YYLTYPE*,const YYLTYPE*,const YYLTYPE*,const YYLTYPE*);
1454static NODE *new_unless(struct parser_params*,NODE*,NODE*,NODE*,const YYLTYPE*,const YYLTYPE*,const YYLTYPE*,const YYLTYPE*);
1455static NODE *logop(struct parser_params*,ID,NODE*,NODE*,const YYLTYPE*,const YYLTYPE*);
1457static NODE *newline_node(NODE*);
1458static void fixpos(NODE*,NODE*);
1460static int value_expr_gen(struct parser_params*,NODE*);
1461static void void_expr(struct parser_params*,NODE*);
1462static NODE *remove_begin(NODE*);
1463#define value_expr(node) value_expr_gen(p, (node))
1464static NODE *void_stmts(struct parser_params*,NODE*);
1465static void reduce_nodes(struct parser_params*,NODE**);
1466static void block_dup_check(struct parser_params*,NODE*,NODE*);
1468static NODE *block_append(struct parser_params*,NODE*,NODE*);
1469static NODE *list_append(struct parser_params*,NODE*,NODE*);
1470static NODE *list_concat(NODE*,NODE*);
1471static NODE *arg_append(struct parser_params*,NODE*,NODE*,const YYLTYPE*);
1472static NODE *last_arg_append(struct parser_params *p, NODE *args, NODE *last_arg, const YYLTYPE *loc);
1473static NODE *rest_arg_append(struct parser_params *p, NODE *args, NODE *rest_arg, const YYLTYPE *loc);
1474static NODE *literal_concat(struct parser_params*,NODE*,NODE*,const YYLTYPE*);
1475static NODE *new_evstr(struct parser_params*,NODE*,const YYLTYPE*,const YYLTYPE*,const YYLTYPE*);
1476static NODE *new_dstr(struct parser_params*,NODE*,const YYLTYPE*);
1477static NODE *str2dstr(struct parser_params*,NODE*);
1478static NODE *evstr2dstr(struct parser_params*,NODE*);
1479static NODE *splat_array(NODE*);
1480static void mark_lvar_used(struct parser_params *p, NODE *rhs);
1482static NODE *call_bin_op(struct parser_params*,NODE*,ID,NODE*,const YYLTYPE*,const YYLTYPE*);
1483static NODE *call_uni_op(struct parser_params*,NODE*,ID,const YYLTYPE*,const YYLTYPE*);
1484static NODE *new_qcall(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, const YYLTYPE *op_loc, const YYLTYPE *loc);
1485static NODE *new_command_qcall(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, NODE *block, const YYLTYPE *op_loc, const YYLTYPE *loc);
1486static NODE *method_add_block(struct parser_params*p, NODE *m, NODE *b, const YYLTYPE *loc) {RNODE_ITER(b)->nd_iter = m; b->nd_loc = *loc; return b;}
1488static bool args_info_empty_p(struct rb_args_info *args);
1489static rb_node_args_t *new_args(struct parser_params*,rb_node_args_aux_t*,rb_node_opt_arg_t*,ID,rb_node_args_aux_t*,rb_node_args_t*,const YYLTYPE*);
1490static rb_node_args_t *new_args_tail(struct parser_params*,rb_node_kw_arg_t*,ID,ID,const YYLTYPE*);
1491static NODE *new_array_pattern(struct parser_params *p, NODE *constant, NODE *pre_arg, NODE *aryptn, const YYLTYPE *loc);
1492static NODE *new_array_pattern_tail(struct parser_params *p, NODE *pre_args, int has_rest, NODE *rest_arg, NODE *post_args, const YYLTYPE *loc);
1493static NODE *new_find_pattern(struct parser_params *p, NODE *constant, NODE *fndptn, const YYLTYPE *loc);
1494static NODE *new_find_pattern_tail(struct parser_params *p, NODE *pre_rest_arg, NODE *args, NODE *post_rest_arg, const YYLTYPE *loc);
1495static NODE *new_hash_pattern(struct parser_params *p, NODE *constant, NODE *hshptn, const YYLTYPE *loc);
1496static NODE *new_hash_pattern_tail(struct parser_params *p, NODE *kw_args, ID kw_rest_arg, const YYLTYPE *loc);
1498static rb_node_kw_arg_t *new_kw_arg(struct parser_params *p, NODE *k, const YYLTYPE *loc);
1499static rb_node_args_t *args_with_numbered(struct parser_params*,rb_node_args_t*,int,ID);
1501static NODE* negate_lit(struct parser_params*, NODE*);
1502static void no_blockarg(struct parser_params*,NODE*);
1503static NODE *ret_args(struct parser_params*,NODE*);
1504static NODE *arg_blk_pass(NODE*,rb_node_block_pass_t*);
1505static NODE *dsym_node(struct parser_params*,NODE*,const YYLTYPE*);
1507static NODE *gettable(struct parser_params*,ID,const YYLTYPE*);
1508static NODE *assignable(struct parser_params*,ID,NODE*,const YYLTYPE*);
1510static NODE *aryset(struct parser_params*,NODE*,NODE*,const YYLTYPE*);
1511static NODE *attrset(struct parser_params*,NODE*,ID,ID,const YYLTYPE*);
1513static VALUE rb_backref_error(struct parser_params*,NODE*);
1514static NODE *node_assign(struct parser_params*,NODE*,NODE*,struct lex_context,const YYLTYPE*);
1516static NODE *new_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, struct lex_context, const YYLTYPE *loc);
1517static NODE *new_ary_op_assign(struct parser_params *p, NODE *ary, NODE *args, ID op, NODE *rhs, const YYLTYPE *args_loc, const YYLTYPE *loc, const YYLTYPE *call_operator_loc, const YYLTYPE *opening_loc, const YYLTYPE *closing_loc, const YYLTYPE *binary_operator_loc);
1518static NODE *new_attr_op_assign(struct parser_params *p, NODE *lhs, ID atype, ID attr, ID op, NODE *rhs, const YYLTYPE *loc, const YYLTYPE *call_operator_loc, const YYLTYPE *message_loc, const YYLTYPE *binary_operator_loc);
1519static NODE *new_const_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, struct lex_context, const YYLTYPE *loc);
1520static NODE *new_bodystmt(struct parser_params *p, NODE *head, NODE *rescue, NODE *rescue_else, NODE *ensure, const YYLTYPE *loc);
1522static NODE *const_decl(struct parser_params *p, NODE* path, const YYLTYPE *loc);
1524static rb_node_opt_arg_t *opt_arg_append(rb_node_opt_arg_t*, rb_node_opt_arg_t*);
1525static rb_node_kw_arg_t *kwd_append(rb_node_kw_arg_t*, rb_node_kw_arg_t*);
1527static NODE *new_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc);
1528static NODE *new_unique_key_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc);
1530static NODE *new_defined(struct parser_params *p, NODE *expr, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1532static NODE *new_regexp(struct parser_params *, NODE *, int, const YYLTYPE *, const YYLTYPE *, const YYLTYPE *, const YYLTYPE *);
1534#define make_list(list, loc) ((list) ? (nd_set_loc(list, loc), list) : NEW_ZLIST(loc))
1536static NODE *new_xstring(struct parser_params *, NODE *, const YYLTYPE *loc);
1538static NODE *symbol_append(struct parser_params *p, NODE *symbols, NODE *symbol);
1540static NODE *match_op(struct parser_params*,NODE*,NODE*,const YYLTYPE*,const YYLTYPE*);
1542static rb_ast_id_table_t *local_tbl(struct parser_params*);
1544static VALUE reg_compile(struct parser_params*, rb_parser_string_t*, int);
1545static void reg_fragment_setenc(struct parser_params*, rb_parser_string_t*, int);
1547static int literal_concat0(struct parser_params *p, rb_parser_string_t *head, rb_parser_string_t *tail);
1548static NODE *heredoc_dedent(struct parser_params*,NODE*);
1550static void check_literal_when(struct parser_params *p, NODE *args, const YYLTYPE *loc);
1552static rb_locations_lambda_body_t* new_locations_lambda_body(struct parser_params *p, NODE *node, const YYLTYPE *loc, const YYLTYPE *opening_loc, const YYLTYPE *closing_loc);
1555#define get_value(idx) (rb_ary_entry(p->s_value_stack, idx))
1556#define set_value(val) (p->s_lvalue = val)
1557static VALUE assign_error(struct parser_params *p, const char *mesg, VALUE a);
1558static int id_is_var(struct parser_params *p, ID id);
1561RUBY_SYMBOL_EXPORT_BEGIN
1562VALUE rb_parser_reg_compile(struct parser_params* p, VALUE str, int options);
1563int rb_reg_fragment_setenc(struct parser_params*, rb_parser_string_t *, int);
1564enum lex_state_e rb_parser_trace_lex_state(struct parser_params *, enum lex_state_e, enum lex_state_e, int);
1565VALUE rb_parser_lex_state_name(struct parser_params *p, enum lex_state_e state);
1566void rb_parser_show_bitstack(struct parser_params *, stack_type, const char *, int);
1567PRINTF_ARGS(void rb_parser_fatal(struct parser_params *p, const char *fmt, ...), 2, 3);
1568YYLTYPE *rb_parser_set_location_from_strterm_heredoc(struct parser_params *p, rb_strterm_heredoc_t *here, YYLTYPE *yylloc);
1569YYLTYPE *rb_parser_set_location_of_delayed_token(struct parser_params *p, YYLTYPE *yylloc);
1570YYLTYPE *rb_parser_set_location_of_heredoc_end(struct parser_params *p, YYLTYPE *yylloc);
1571YYLTYPE *rb_parser_set_location_of_dummy_end(struct parser_params *p, YYLTYPE *yylloc);
1572YYLTYPE *rb_parser_set_location_of_none(struct parser_params *p, YYLTYPE *yylloc);
1573YYLTYPE *rb_parser_set_location(struct parser_params *p, YYLTYPE *yylloc);
1574void ruby_show_error_line(struct parser_params *p, VALUE errbuf, const YYLTYPE *yylloc, int lineno, rb_parser_string_t *str);
1575RUBY_SYMBOL_EXPORT_END
1577static void flush_string_content(struct parser_params *p, rb_encoding *enc, size_t back);
1578static void error_duplicate_pattern_variable(struct parser_params *p, ID id, const YYLTYPE *loc);
1579static void error_duplicate_pattern_key(struct parser_params *p, ID id, const YYLTYPE *loc);
1580static VALUE formal_argument_error(struct parser_params*, ID);
1581static ID shadowing_lvar(struct parser_params*,ID);
1582static void new_bv(struct parser_params*,ID);
1584static void local_push(struct parser_params*,int);
1585static void local_pop(struct parser_params*);
1586static void local_var(struct parser_params*, ID);
1587static void arg_var(struct parser_params*, ID);
1588static int local_id(struct parser_params *p, ID id);
1589static int local_id_ref(struct parser_params*, ID, ID **);
1590#define internal_id rb_parser_internal_id
1591ID internal_id(struct parser_params*);
1592static NODE *new_args_forward_call(struct parser_params*, NODE*, const YYLTYPE*, const YYLTYPE*);
1593static int check_forwarding_args(struct parser_params*);
1594static void add_forwarding_args(struct parser_params *p);
1595static void forwarding_arg_check(struct parser_params *p, ID arg, ID all, const char *var);
1597static const struct vtable *dyna_push(struct parser_params *);
1598static void dyna_pop(struct parser_params*, const struct vtable *);
1599static int dyna_in_block(struct parser_params*);
1600#define dyna_var(p, id) local_var(p, id)
1601static int dvar_defined(struct parser_params*, ID);
1602#define dvar_defined_ref rb_parser_dvar_defined_ref
1603int dvar_defined_ref(struct parser_params*, ID, ID**);
1604static int dvar_curr(struct parser_params*,ID);
1606static int lvar_defined(struct parser_params*, ID);
1608static NODE *numparam_push(struct parser_params *p);
1609static void numparam_pop(struct parser_params *p, NODE *prev_inner);
1611#define METHOD_NOT '!
'
1613#define idFWD_REST '*
'
1614#define idFWD_KWREST idPow /* Use simple "**", as tDSTAR is "**arg" */
1615#define idFWD_BLOCK '&
'
1616#define idFWD_ALL idDot3
1617#define arg_FWD_BLOCK idFWD_BLOCK
1619#define RE_ONIG_OPTION_IGNORECASE 1
1620#define RE_ONIG_OPTION_EXTEND (RE_ONIG_OPTION_IGNORECASE<<1)
1621#define RE_ONIG_OPTION_MULTILINE (RE_ONIG_OPTION_EXTEND<<1)
1622#define RE_OPTION_ONCE (1<<16)
1623#define RE_OPTION_ENCODING_SHIFT 8
1624#define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
1625#define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
1626#define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
1627#define RE_OPTION_MASK 0xff
1628#define RE_OPTION_ARG_ENCODING_NONE 32
1630#define CHECK_LITERAL_WHEN (st_table *)1
1631#define CASE_LABELS_ENABLED_P(case_labels) (case_labels && case_labels != CHECK_LITERAL_WHEN)
1633#define yytnamerr(yyres, yystr) (YYSIZE_T)rb_yytnamerr(p, yyres, yystr)
1634RUBY_FUNC_EXPORTED size_t rb_yytnamerr(struct parser_params *p, char *yyres, const char *yystr);
1636#define TOKEN2ID(tok) ( \
1637 tTOKEN_LOCAL_BEGIN<(tok)&&(tok)<tTOKEN_LOCAL_END ? TOKEN2LOCALID(tok) : \
1638 tTOKEN_INSTANCE_BEGIN<(tok)&&(tok)<tTOKEN_INSTANCE_END ? TOKEN2INSTANCEID(tok) : \
1639 tTOKEN_GLOBAL_BEGIN<(tok)&&(tok)<tTOKEN_GLOBAL_END ? TOKEN2GLOBALID(tok) : \
1640 tTOKEN_CONST_BEGIN<(tok)&&(tok)<tTOKEN_CONST_END ? TOKEN2CONSTID(tok) : \
1641 tTOKEN_CLASS_BEGIN<(tok)&&(tok)<tTOKEN_CLASS_END ? TOKEN2CLASSID(tok) : \
1642 tTOKEN_ATTRSET_BEGIN<(tok)&&(tok)<tTOKEN_ATTRSET_END ? TOKEN2ATTRSETID(tok) : \
1643 ((tok) / ((tok)<tPRESERVED_ID_END && ((tok)>=128 || rb_ispunct(tok)))))
1645/****** Ripper *******/
1649#include "eventids1.h"
1650#include "eventids2.h"
1652extern const struct ripper_parser_ids ripper_parser_ids;
1654static VALUE ripper_dispatch0(struct parser_params*,ID);
1655static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
1656static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
1657static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
1658static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
1659static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
1660static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
1661void ripper_error(struct parser_params *p);
1663#define dispatch0(n) ripper_dispatch0(p, RIPPER_ID(n))
1664#define dispatch1(n,a) ripper_dispatch1(p, RIPPER_ID(n), (a))
1665#define dispatch2(n,a,b) ripper_dispatch2(p, RIPPER_ID(n), (a), (b))
1666#define dispatch3(n,a,b,c) ripper_dispatch3(p, RIPPER_ID(n), (a), (b), (c))
1667#define dispatch4(n,a,b,c,d) ripper_dispatch4(p, RIPPER_ID(n), (a), (b), (c), (d))
1668#define dispatch5(n,a,b,c,d,e) ripper_dispatch5(p, RIPPER_ID(n), (a), (b), (c), (d), (e))
1669#define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(p, RIPPER_ID(n), (a), (b), (c), (d), (e), (f), (g))
1671#define yyparse ripper_yyparse
1674aryptn_pre_args(struct parser_params *p, VALUE pre_arg, VALUE pre_args)
1676 if (!NIL_P(pre_arg)) {
1677 if (!NIL_P(pre_args)) {
1678 rb_ary_unshift(pre_args, pre_arg);
1681 pre_args = rb_ary_new_from_args(1, pre_arg);
1687#define ID2VAL(id) STATIC_ID2SYM(id)
1688#define TOKEN2VAL(t) ID2VAL(TOKEN2ID(t))
1691#define KWD2EID(t, v) keyword_##t
1694new_scope_body(struct parser_params *p, rb_node_args_t *args, NODE *body, const YYLTYPE *loc)
1696 body = remove_begin(body);
1697 reduce_nodes(p, &body);
1698 NODE *n = NEW_SCOPE(args, body, loc);
1699 nd_set_line(n, loc->end_pos.lineno);
1700 set_line_body(body, loc->beg_pos.lineno);
1705rescued_expr(struct parser_params *p, NODE *arg, NODE *rescue,
1706 const YYLTYPE *arg_loc, const YYLTYPE *mod_loc, const YYLTYPE *res_loc)
1708 YYLTYPE loc = code_loc_gen(mod_loc, res_loc);
1709 rescue = NEW_RESBODY(0, 0, remove_begin(rescue), 0, &loc);
1710 loc.beg_pos = arg_loc->beg_pos;
1711 return NEW_RESCUE(arg, rescue, 0, &loc);
1714static NODE *add_block_exit(struct parser_params *p, NODE *node);
1715static rb_node_exits_t *init_block_exit(struct parser_params *p);
1716static rb_node_exits_t *allow_block_exit(struct parser_params *p);
1717static void restore_block_exit(struct parser_params *p, rb_node_exits_t *exits);
1718static void clear_block_exit(struct parser_params *p, bool error);
1721next_rescue_context(struct lex_context *next, const struct lex_context *outer, enum rescue_context def)
1723 next->in_rescue = outer->in_rescue == after_rescue ? after_rescue : def;
1727restore_defun(struct parser_params *p, rb_node_def_temp_t *temp)
1729 /* See: def_name action */
1730 struct lex_context ctxt = temp->save.ctxt;
1731 p->ctxt.in_def = ctxt.in_def;
1732 p->ctxt.shareable_constant_value = ctxt.shareable_constant_value;
1733 p->ctxt.in_rescue = ctxt.in_rescue;
1734 p->max_numparam = temp->save.max_numparam;
1735 numparam_pop(p, temp->save.numparam_save);
1736 clear_block_exit(p, true);
1740endless_method_name(struct parser_params *p, ID mid, const YYLTYPE *loc)
1742 if (is_attrset_id(mid)) {
1743 yyerror1(loc, "setter method cannot be defined in an endless method definition");
1745 token_info_drop(p, "def", loc->beg_pos);
1748#define debug_token_line(p, name, line) do { \
1750 const char *const pcur = p->lex.pcur; \
1751 const char *const ptok = p->lex.ptok; \
1752 rb_parser_printf(p, name ":%d (%d: %"PRIdPTRDIFF"|%"PRIdPTRDIFF"|%"PRIdPTRDIFF")\n", \
1753 line, p->ruby_sourceline, \
1754 ptok - p->lex.pbeg, pcur - ptok, p->lex.pend - pcur); \
1758#define begin_definition(k, loc_beg, loc_end) \
1760 if (!(p->ctxt.in_class = (k)[0] != 0)) { \
1761 /* singleton class */ \
1762 p->ctxt.cant_return = !p->ctxt.in_def; \
1763 p->ctxt.in_def = 0; \
1765 else if (p->ctxt.in_def) { \
1766 YYLTYPE loc = code_loc_gen(loc_beg, loc_end); \
1767 yyerror1(&loc, k " definition in method body"); \
1770 p->ctxt.cant_return = 1; \
1776# define ifndef_ripper(x) (x)
1777# define ifdef_ripper(r,x) (x)
1779# define ifndef_ripper(x)
1780# define ifdef_ripper(r,x) (r)
1783# define rb_warn0(fmt) WARN_CALL(WARN_ARGS(fmt, 1))
1784# define rb_warn1(fmt,a) WARN_CALL(WARN_ARGS(fmt, 2), (a))
1785# define rb_warn2(fmt,a,b) WARN_CALL(WARN_ARGS(fmt, 3), (a), (b))
1786# define rb_warn3(fmt,a,b,c) WARN_CALL(WARN_ARGS(fmt, 4), (a), (b), (c))
1787# define rb_warn4(fmt,a,b,c,d) WARN_CALL(WARN_ARGS(fmt, 5), (a), (b), (c), (d))
1788# define rb_warning0(fmt) WARNING_CALL(WARNING_ARGS(fmt, 1))
1789# define rb_warning1(fmt,a) WARNING_CALL(WARNING_ARGS(fmt, 2), (a))
1790# define rb_warning2(fmt,a,b) WARNING_CALL(WARNING_ARGS(fmt, 3), (a), (b))
1791# define rb_warning3(fmt,a,b,c) WARNING_CALL(WARNING_ARGS(fmt, 4), (a), (b), (c))
1792# define rb_warning4(fmt,a,b,c,d) WARNING_CALL(WARNING_ARGS(fmt, 5), (a), (b), (c), (d))
1793# define rb_warn0L(l,fmt) WARN_CALL(WARN_ARGS_L(l, fmt, 1))
1794# define rb_warn1L(l,fmt,a) WARN_CALL(WARN_ARGS_L(l, fmt, 2), (a))
1795# define rb_warn2L(l,fmt,a,b) WARN_CALL(WARN_ARGS_L(l, fmt, 3), (a), (b))
1796# define rb_warn3L(l,fmt,a,b,c) WARN_CALL(WARN_ARGS_L(l, fmt, 4), (a), (b), (c))
1797# define rb_warn4L(l,fmt,a,b,c,d) WARN_CALL(WARN_ARGS_L(l, fmt, 5), (a), (b), (c), (d))
1798# define rb_warning0L(l,fmt) WARNING_CALL(WARNING_ARGS_L(l, fmt, 1))
1799# define rb_warning1L(l,fmt,a) WARNING_CALL(WARNING_ARGS_L(l, fmt, 2), (a))
1800# define rb_warning2L(l,fmt,a,b) WARNING_CALL(WARNING_ARGS_L(l, fmt, 3), (a), (b))
1801# define rb_warning3L(l,fmt,a,b,c) WARNING_CALL(WARNING_ARGS_L(l, fmt, 4), (a), (b), (c))
1802# define rb_warning4L(l,fmt,a,b,c,d) WARNING_CALL(WARNING_ARGS_L(l, fmt, 5), (a), (b), (c), (d))
1804extern const ID id_warn, id_warning, id_gets, id_assoc;
1805# define ERR_MESG() STR_NEW2(mesg) /* to bypass Ripper DSL */
1806# define WARN_S_L(s,l) STR_NEW(s,l)
1807# define WARN_S(s) STR_NEW2(s)
1808# define WARN_I(i) INT2NUM(i)
1809# define WARN_ID(i) rb_id2str(i)
1810# define PRIsWARN PRIsVALUE
1811# define WARN_ARGS(fmt,n) p->value, id_warn, n, rb_usascii_str_new_lit(fmt)
1812# define WARN_ARGS_L(l,fmt,n) WARN_ARGS(fmt,n)
1813# ifdef HAVE_VA_ARGS_MACRO
1814# define WARN_CALL(...) rb_funcall(__VA_ARGS__)
1816# define WARN_CALL rb_funcall
1818# define WARNING_ARGS(fmt,n) p->value, id_warning, n, rb_usascii_str_new_lit(fmt)
1819# define WARNING_ARGS_L(l, fmt,n) WARNING_ARGS(fmt,n)
1820# ifdef HAVE_VA_ARGS_MACRO
1821# define WARNING_CALL(...) rb_funcall(__VA_ARGS__)
1823# define WARNING_CALL rb_funcall
1825# define compile_error ripper_compile_error
1827# define WARN_S_L(s,l) s
1830# define WARN_ID(i) rb_id2name(i)
1831# define PRIsWARN PRIsVALUE
1832# define WARN_ARGS(fmt,n) WARN_ARGS_L(p->ruby_sourceline,fmt,n)
1833# define WARN_ARGS_L(l,fmt,n) p->ruby_sourcefile, (l), (fmt)
1834# define WARN_CALL rb_compile_warn
1835# define WARNING_ARGS(fmt,n) WARN_ARGS(fmt,n)
1836# define WARNING_ARGS_L(l,fmt,n) WARN_ARGS_L(l,fmt,n)
1837# define WARNING_CALL rb_compile_warning
1838PRINTF_ARGS(static void parser_compile_error(struct parser_params*, const rb_code_location_t *loc, const char *fmt, ...), 3, 4);
1839# define compile_error(p, ...) parser_compile_error(p, NULL, __VA_ARGS__)
1842#define RNODE_EXITS(node) ((rb_node_exits_t*)(node))
1845add_block_exit(struct parser_params *p, NODE *node)
1848 compile_error(p, "unexpected null node");
1851 switch (nd_type(node)) {
1852 case NODE_BREAK: case NODE_NEXT: case NODE_REDO: break;
1854 compile_error(p, "add_block_exit: unexpected node: %s", parser_node_name(nd_type(node)));
1857 if (!p->ctxt.in_defined) {
1858 rb_node_exits_t *exits = p->exits;
1860 RNODE_EXITS(exits->nd_stts)->nd_chain = node;
1861 exits->nd_stts = node;
1867static rb_node_exits_t *
1868init_block_exit(struct parser_params *p)
1870 rb_node_exits_t *old = p->exits;
1871 rb_node_exits_t *exits = NODE_NEW_INTERNAL(NODE_EXITS, rb_node_exits_t);
1872 exits->nd_chain = 0;
1873 exits->nd_stts = RNODE(exits);
1878static rb_node_exits_t *
1879allow_block_exit(struct parser_params *p)
1881 rb_node_exits_t *exits = p->exits;
1887restore_block_exit(struct parser_params *p, rb_node_exits_t *exits)
1893clear_block_exit(struct parser_params *p, bool error)
1895 rb_node_exits_t *exits = p->exits;
1898 for (NODE *e = RNODE(exits); (e = RNODE_EXITS(e)->nd_chain) != 0; ) {
1899 switch (nd_type(e)) {
1901 yyerror1(&e->nd_loc, "Invalid break");
1904 yyerror1(&e->nd_loc, "Invalid next");
1907 yyerror1(&e->nd_loc, "Invalid redo");
1910 yyerror1(&e->nd_loc, "unexpected node");
1911 goto end_checks; /* no nd_chain */
1916 exits->nd_stts = RNODE(exits);
1917 exits->nd_chain = 0;
1920#define WARN_EOL(tok) \
1921 (looking_at_eol_p(p) ? \
1922 (void)rb_warning0("'" tok "' at the end of line without an expression") : \
1924static int looking_at_eol_p(struct parser_params *p);
1927get_nd_value(struct parser_params *p, NODE *node)
1929 switch (nd_type(node)) {
1931 return RNODE_GASGN(node)->nd_value;
1933 return RNODE_IASGN(node)->nd_value;
1935 return RNODE_LASGN(node)->nd_value;
1937 return RNODE_DASGN(node)->nd_value;
1939 return RNODE_MASGN(node)->nd_value;
1941 return RNODE_CVASGN(node)->nd_value;
1943 return RNODE_CDECL(node)->nd_value;
1945 compile_error(p, "get_nd_value: unexpected node: %s", parser_node_name(nd_type(node)));
1951set_nd_value(struct parser_params *p, NODE *node, NODE *rhs)
1953 switch (nd_type(node)) {
1955 RNODE_CDECL(node)->nd_value = rhs;
1958 RNODE_GASGN(node)->nd_value = rhs;
1961 RNODE_IASGN(node)->nd_value = rhs;
1964 RNODE_LASGN(node)->nd_value = rhs;
1967 RNODE_DASGN(node)->nd_value = rhs;
1970 RNODE_MASGN(node)->nd_value = rhs;
1973 RNODE_CVASGN(node)->nd_value = rhs;
1976 compile_error(p, "set_nd_value: unexpected node: %s", parser_node_name(nd_type(node)));
1982get_nd_vid(struct parser_params *p, NODE *node)
1984 switch (nd_type(node)) {
1986 return RNODE_CDECL(node)->nd_vid;
1988 return RNODE_GASGN(node)->nd_vid;
1990 return RNODE_IASGN(node)->nd_vid;
1992 return RNODE_LASGN(node)->nd_vid;
1994 return RNODE_DASGN(node)->nd_vid;
1996 return RNODE_CVASGN(node)->nd_vid;
1998 compile_error(p, "get_nd_vid: unexpected node: %s", parser_node_name(nd_type(node)));
2004get_nd_args(struct parser_params *p, NODE *node)
2006 switch (nd_type(node)) {
2008 return RNODE_CALL(node)->nd_args;
2010 return RNODE_OPCALL(node)->nd_args;
2012 return RNODE_FCALL(node)->nd_args;
2014 return RNODE_QCALL(node)->nd_args;
2016 return RNODE_SUPER(node)->nd_args;
2025 compile_error(p, "get_nd_args: unexpected node: %s", parser_node_name(nd_type(node)));
2031djb2(const uint8_t *str, size_t len)
2033 st_index_t hash = 5381;
2035 for (size_t i = 0; i < len; i++) {
2036 hash = ((hash << 5) + hash) + str[i];
2043parser_memhash(const void *ptr, long len)
2045 return djb2(ptr, len);
2048#define PARSER_STRING_PTR(str) (str->ptr)
2049#define PARSER_STRING_LEN(str) (str->len)
2050#define PARSER_STRING_END(str) (&str->ptr[str->len])
2051#define STRING_SIZE(str) ((size_t)str->len + 1)
2052#define STRING_TERM_LEN(str) (1)
2053#define STRING_TERM_FILL(str) (str->ptr[str->len] = '\0
')
2054#define PARSER_STRING_RESIZE_CAPA_TERM(p,str,capacity,termlen) do {\
2055 SIZED_REALLOC_N(str->ptr, char, (size_t)total + termlen, STRING_SIZE(str)); \
2058#define STRING_SET_LEN(str, n) do { \
2061#define PARSER_STRING_GETMEM(str, ptrvar, lenvar) \
2062 ((ptrvar) = str->ptr, \
2063 (lenvar) = str->len)
2066parser_string_char_at_end(struct parser_params *p, rb_parser_string_t *str, int when_empty)
2068 return PARSER_STRING_LEN(str) > 0 ? (unsigned char)PARSER_STRING_END(str)[-1] : when_empty;
2071static rb_parser_string_t *
2072rb_parser_string_new(rb_parser_t *p, const char *ptr, long len)
2074 rb_parser_string_t *str;
2077 rb_bug("negative string size (or size too big): %ld", len);
2080 str = xcalloc(1, sizeof(rb_parser_string_t));
2081 str->ptr = xcalloc(len + 1, sizeof(char));
2084 memcpy(PARSER_STRING_PTR(str), ptr, len);
2086 STRING_SET_LEN(str, len);
2087 STRING_TERM_FILL(str);
2091static rb_parser_string_t *
2092rb_parser_encoding_string_new(rb_parser_t *p, const char *ptr, long len, rb_encoding *enc)
2094 rb_parser_string_t *str = rb_parser_string_new(p, ptr, len);
2095 str->coderange = RB_PARSER_ENC_CODERANGE_UNKNOWN;
2102rb_str_to_parser_string(rb_parser_t *p, VALUE str)
2105 rb_parser_string_t *ret = rb_parser_encoding_string_new(p, RSTRING_PTR(str), RSTRING_LEN(str), rb_enc_get(str));
2111rb_parser_string_free(rb_parser_t *p, rb_parser_string_t *str)
2114 xfree(PARSER_STRING_PTR(str));
2120rb_parser_str_hash(rb_parser_string_t *str)
2122 return parser_memhash((const void *)PARSER_STRING_PTR(str), PARSER_STRING_LEN(str));
2126rb_char_p_hash(const char *c)
2128 return parser_memhash((const void *)c, strlen(c));
2132rb_parser_str_capacity(rb_parser_string_t *str, const int termlen)
2134 return PARSER_STRING_LEN(str);
2139rb_parser_string_end(rb_parser_string_t *str)
2141 return &str->ptr[str->len];
2146rb_parser_string_set_encoding(rb_parser_string_t *str, rb_encoding *enc)
2152rb_parser_str_get_encoding(rb_parser_string_t *str)
2159PARSER_ENCODING_IS_ASCII8BIT(struct parser_params *p, rb_parser_string_t *str)
2161 return rb_parser_str_get_encoding(str) == rb_ascii8bit_encoding();
2166PARSER_ENC_CODERANGE(rb_parser_string_t *str)
2168 return str->coderange;
2172PARSER_ENC_CODERANGE_SET(rb_parser_string_t *str, int coderange)
2174 str->coderange = coderange;
2178PARSER_ENCODING_CODERANGE_SET(rb_parser_string_t *str, rb_encoding *enc, enum rb_parser_string_coderange_type cr)
2180 rb_parser_string_set_encoding(str, enc);
2181 PARSER_ENC_CODERANGE_SET(str, cr);
2185PARSER_ENC_CODERANGE_CLEAR(rb_parser_string_t *str)
2187 str->coderange = RB_PARSER_ENC_CODERANGE_UNKNOWN;
2191PARSER_ENC_CODERANGE_ASCIIONLY(rb_parser_string_t *str)
2193 return PARSER_ENC_CODERANGE(str) == RB_PARSER_ENC_CODERANGE_7BIT;
2197PARSER_ENC_CODERANGE_CLEAN_P(int cr)
2199 return cr == RB_PARSER_ENC_CODERANGE_7BIT || cr == RB_PARSER_ENC_CODERANGE_VALID;
2203rb_parser_search_nonascii(const char *p, const char *e)
2207 for (; s < e; s++) {
2208 if (*s & 0x80) return s;
2215rb_parser_coderange_scan(struct parser_params *p, const char *ptr, long len, rb_encoding *enc)
2217 const char *e = ptr + len;
2219 if (enc == rb_ascii8bit_encoding()) {
2220 /* enc is ASCII-8BIT. ASCII-8BIT string never be broken. */
2221 ptr = rb_parser_search_nonascii(ptr, e);
2222 return ptr ? RB_PARSER_ENC_CODERANGE_VALID : RB_PARSER_ENC_CODERANGE_7BIT;
2225 /* parser string encoding is always asciicompat */
2226 ptr = rb_parser_search_nonascii(ptr, e);
2227 if (!ptr) return RB_PARSER_ENC_CODERANGE_7BIT;
2229 int ret = rb_enc_precise_mbclen(ptr, e, enc);
2230 if (!MBCLEN_CHARFOUND_P(ret)) return RB_PARSER_ENC_CODERANGE_BROKEN;
2231 ptr += MBCLEN_CHARFOUND_LEN(ret);
2232 if (ptr == e) break;
2233 ptr = rb_parser_search_nonascii(ptr, e);
2237 return RB_PARSER_ENC_CODERANGE_VALID;
2241rb_parser_enc_coderange_scan(struct parser_params *p, rb_parser_string_t *str, rb_encoding *enc)
2243 return rb_parser_coderange_scan(p, PARSER_STRING_PTR(str), PARSER_STRING_LEN(str), enc);
2247rb_parser_enc_str_coderange(struct parser_params *p, rb_parser_string_t *str)
2249 int cr = PARSER_ENC_CODERANGE(str);
2251 if (cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2252 cr = rb_parser_enc_coderange_scan(p, str, rb_parser_str_get_encoding(str));
2253 PARSER_ENC_CODERANGE_SET(str, cr);
2259static rb_parser_string_t *
2260rb_parser_enc_associate(struct parser_params *p, rb_parser_string_t *str, rb_encoding *enc)
2262 if (rb_parser_str_get_encoding(str) == enc)
2264 if (!PARSER_ENC_CODERANGE_ASCIIONLY(str)) {
2265 PARSER_ENC_CODERANGE_CLEAR(str);
2267 rb_parser_string_set_encoding(str, enc);
2272rb_parser_is_ascii_string(struct parser_params *p, rb_parser_string_t *str)
2274 return rb_parser_enc_str_coderange(p, str) == RB_PARSER_ENC_CODERANGE_7BIT;
2278rb_parser_enc_compatible(struct parser_params *p, rb_parser_string_t *str1, rb_parser_string_t *str2)
2280 rb_encoding *enc1 = rb_parser_str_get_encoding(str1);
2281 rb_encoding *enc2 = rb_parser_str_get_encoding(str2);
2283 if (enc1 == NULL || enc2 == NULL)
2290 if (PARSER_STRING_LEN(str2) == 0)
2292 if (PARSER_STRING_LEN(str1) == 0)
2293 return rb_parser_is_ascii_string(p, str2) ? enc1 : enc2;
2297 cr1 = rb_parser_enc_str_coderange(p, str1);
2298 cr2 = rb_parser_enc_str_coderange(p, str2);
2301 if (cr1 == RB_PARSER_ENC_CODERANGE_7BIT) return enc2;
2302 if (cr2 == RB_PARSER_ENC_CODERANGE_7BIT) return enc1;
2305 if (cr2 == RB_PARSER_ENC_CODERANGE_7BIT) {
2309 if (cr1 == RB_PARSER_ENC_CODERANGE_7BIT) {
2317rb_parser_str_modify(rb_parser_string_t *str)
2319 PARSER_ENC_CODERANGE_CLEAR(str);
2323rb_parser_str_set_len(struct parser_params *p, rb_parser_string_t *str, long len)
2326 const int termlen = STRING_TERM_LEN(str);
2328 if (len > (capa = (long)(rb_parser_str_capacity(str, termlen))) || len < 0) {
2329 rb_bug("probable buffer overflow: %ld for %ld", len, capa);
2332 int cr = PARSER_ENC_CODERANGE(str);
2333 if (cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2334 /* Leave unknown. */
2336 else if (len > PARSER_STRING_LEN(str)) {
2337 PARSER_ENC_CODERANGE_SET(str, RB_PARSER_ENC_CODERANGE_UNKNOWN);
2339 else if (len < PARSER_STRING_LEN(str)) {
2340 if (cr != RB_PARSER_ENC_CODERANGE_7BIT) {
2341 /* ASCII-only string is keeping after truncated. Valid
2342 * and broken may be invalid or valid, leave unknown. */
2343 PARSER_ENC_CODERANGE_SET(str, RB_PARSER_ENC_CODERANGE_UNKNOWN);
2347 STRING_SET_LEN(str, len);
2348 STRING_TERM_FILL(str);
2351static rb_parser_string_t *
2352rb_parser_str_buf_cat(struct parser_params *p, rb_parser_string_t *str, const char *ptr, long len)
2354 rb_parser_str_modify(str);
2355 if (len == 0) return 0;
2357 long total, olen, off = -1;
2359 const int termlen = STRING_TERM_LEN(str);
2361 PARSER_STRING_GETMEM(str, sptr, olen);
2362 if (ptr >= sptr && ptr <= sptr + olen) {
2366 if (olen > LONG_MAX - len) {
2367 compile_error(p, "string sizes too big");
2371 PARSER_STRING_RESIZE_CAPA_TERM(p, str, total, termlen);
2372 sptr = PARSER_STRING_PTR(str);
2376 memcpy(sptr + olen, ptr, len);
2377 STRING_SET_LEN(str, total);
2378 STRING_TERM_FILL(str);
2383#define parser_str_cat(str, ptr, len) rb_parser_str_buf_cat(p, str, ptr, len)
2384#define parser_str_cat_cstr(str, lit) rb_parser_str_buf_cat(p, str, lit, strlen(lit))
2386static rb_parser_string_t *
2387rb_parser_enc_cr_str_buf_cat(struct parser_params *p, rb_parser_string_t *str, const char *ptr, long len,
2388 rb_encoding *ptr_enc, int ptr_cr, int *ptr_cr_ret)
2391 rb_encoding *str_enc, *res_enc;
2393 str_enc = rb_parser_str_get_encoding(str);
2394 str_cr = PARSER_STRING_LEN(str) ? PARSER_ENC_CODERANGE(str) : RB_PARSER_ENC_CODERANGE_7BIT;
2396 if (str_enc == ptr_enc) {
2397 if (str_cr != RB_PARSER_ENC_CODERANGE_UNKNOWN && ptr_cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2398 ptr_cr = rb_parser_coderange_scan(p, ptr, len, ptr_enc);
2402 /* parser string encoding is always asciicompat */
2403 if (ptr_cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2404 ptr_cr = rb_parser_coderange_scan(p, ptr, len, ptr_enc);
2406 if (str_cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2407 if (str_enc == rb_ascii8bit_encoding() || ptr_cr != RB_PARSER_ENC_CODERANGE_7BIT) {
2408 str_cr = rb_parser_enc_str_coderange(p, str);
2413 *ptr_cr_ret = ptr_cr;
2415 if (str_enc != ptr_enc &&
2416 str_cr != RB_PARSER_ENC_CODERANGE_7BIT &&
2417 ptr_cr != RB_PARSER_ENC_CODERANGE_7BIT) {
2421 if (str_cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2423 res_cr = RB_PARSER_ENC_CODERANGE_UNKNOWN;
2425 else if (str_cr == RB_PARSER_ENC_CODERANGE_7BIT) {
2426 if (ptr_cr == RB_PARSER_ENC_CODERANGE_7BIT) {
2428 res_cr = RB_PARSER_ENC_CODERANGE_7BIT;
2435 else if (str_cr == RB_PARSER_ENC_CODERANGE_VALID) {
2437 if (PARSER_ENC_CODERANGE_CLEAN_P(ptr_cr))
2442 else { /* str_cr == RB_PARSER_ENC_CODERANGE_BROKEN */
2445 if (0 < len) res_cr = RB_PARSER_ENC_CODERANGE_UNKNOWN;
2449 compile_error(p, "negative string size (or size too big)");
2451 parser_str_cat(str, ptr, len);
2452 PARSER_ENCODING_CODERANGE_SET(str, res_enc, res_cr);
2456 compile_error(p, "incompatible character encodings: %s and %s",
2457 rb_enc_name(str_enc), rb_enc_name(ptr_enc));
2458 UNREACHABLE_RETURN(0);
2462static rb_parser_string_t *
2463rb_parser_enc_str_buf_cat(struct parser_params *p, rb_parser_string_t *str, const char *ptr, long len,
2464 rb_encoding *ptr_enc)
2466 return rb_parser_enc_cr_str_buf_cat(p, str, ptr, len, ptr_enc, RB_PARSER_ENC_CODERANGE_UNKNOWN, NULL);
2469static rb_parser_string_t *
2470rb_parser_str_buf_append(struct parser_params *p, rb_parser_string_t *str, rb_parser_string_t *str2)
2472 int str2_cr = rb_parser_enc_str_coderange(p, str2);
2474 rb_parser_enc_cr_str_buf_cat(p, str, PARSER_STRING_PTR(str2), PARSER_STRING_LEN(str2),
2475 rb_parser_str_get_encoding(str2), str2_cr, &str2_cr);
2477 PARSER_ENC_CODERANGE_SET(str2, str2_cr);
2482static rb_parser_string_t *
2483rb_parser_str_resize(struct parser_params *p, rb_parser_string_t *str, long len)
2486 rb_bug("negative string size (or size too big)");
2489 long slen = PARSER_STRING_LEN(str);
2491 if (slen > len && PARSER_ENC_CODERANGE(str) != RB_PARSER_ENC_CODERANGE_7BIT) {
2492 PARSER_ENC_CODERANGE_CLEAR(str);
2497 const int termlen = STRING_TERM_LEN(str);
2499 if ((capa = slen) < len) {
2500 SIZED_REALLOC_N(str->ptr, char, (size_t)len + termlen, STRING_SIZE(str));
2502 else if (len == slen) return str;
2503 STRING_SET_LEN(str, len);
2504 STRING_TERM_FILL(str);
2509# define PARSER_ENC_STRING_GETMEM(str, ptrvar, lenvar, encvar) \
2510 ((ptrvar) = str->ptr, \
2511 (lenvar) = str->len, \
2512 (encvar) = str->enc)
2515rb_parser_string_hash_cmp(rb_parser_string_t *str1, rb_parser_string_t *str2)
2518 const char *ptr1, *ptr2;
2519 rb_encoding *enc1, *enc2;
2521 PARSER_ENC_STRING_GETMEM(str1, ptr1, len1, enc1);
2522 PARSER_ENC_STRING_GETMEM(str2, ptr2, len2, enc2);
2524 return (len1 != len2 ||
2526 memcmp(ptr1, ptr2, len1) != 0);
2530rb_parser_ary_extend(rb_parser_t *p, rb_parser_ary_t *ary, long len)
2533 if (ary->capa < len) {
2535 ary->data = (rb_parser_ary_data *)xrealloc(ary->data, sizeof(rb_parser_ary_data) * len);
2536 for (i = ary->len; i < len; i++) {
2543 * Do not call this directly.
2544 * Use rb_parser_ary_new_capa_for_XXX() instead.
2546static rb_parser_ary_t *
2547parser_ary_new_capa(rb_parser_t *p, long len)
2550 rb_bug("negative array size (or size too big): %ld", len);
2552 rb_parser_ary_t *ary = xcalloc(1, sizeof(rb_parser_ary_t));
2557 ary->data = (rb_parser_ary_data *)xcalloc(len, sizeof(rb_parser_ary_data));
2566static rb_parser_ary_t *
2567rb_parser_ary_new_capa_for_script_line(rb_parser_t *p, long len)
2569 rb_parser_ary_t *ary = parser_ary_new_capa(p, len);
2570 ary->data_type = PARSER_ARY_DATA_SCRIPT_LINE;
2574static rb_parser_ary_t *
2575rb_parser_ary_new_capa_for_ast_token(rb_parser_t *p, long len)
2577 rb_parser_ary_t *ary = parser_ary_new_capa(p, len);
2578 ary->data_type = PARSER_ARY_DATA_AST_TOKEN;
2583static rb_parser_ary_t *
2584rb_parser_ary_new_capa_for_node(rb_parser_t *p, long len)
2586 rb_parser_ary_t *ary = parser_ary_new_capa(p, len);
2587 ary->data_type = PARSER_ARY_DATA_NODE;
2592 * Do not call this directly.
2593 * Use rb_parser_ary_push_XXX() instead.
2595static rb_parser_ary_t *
2596parser_ary_push(rb_parser_t *p, rb_parser_ary_t *ary, rb_parser_ary_data val)
2598 if (ary->len == ary->capa) {
2599 rb_parser_ary_extend(p, ary, ary->len == 0 ? 1 : ary->len * 2);
2601 ary->data[ary->len++] = val;
2606static rb_parser_ary_t *
2607rb_parser_ary_push_ast_token(rb_parser_t *p, rb_parser_ary_t *ary, rb_parser_ast_token_t *val)
2609 if (ary->data_type != PARSER_ARY_DATA_AST_TOKEN) {
2610 rb_bug("unexpected rb_parser_ary_data_type: %d", ary->data_type);
2612 return parser_ary_push(p, ary, val);
2615static rb_parser_ary_t *
2616rb_parser_ary_push_script_line(rb_parser_t *p, rb_parser_ary_t *ary, rb_parser_string_t *val)
2618 if (ary->data_type != PARSER_ARY_DATA_SCRIPT_LINE) {
2619 rb_bug("unexpected rb_parser_ary_data_type: %d", ary->data_type);
2621 return parser_ary_push(p, ary, val);
2625static rb_parser_ary_t *
2626rb_parser_ary_push_node(rb_parser_t *p, rb_parser_ary_t *ary, NODE *val)
2628 if (ary->data_type != PARSER_ARY_DATA_NODE) {
2629 rb_bug("unexpected rb_parser_ary_data_type: %d", ary->data_type);
2631 return parser_ary_push(p, ary, val);
2636rb_parser_ast_token_free(rb_parser_t *p, rb_parser_ast_token_t *token)
2639 rb_parser_string_free(p, token->str);
2644rb_parser_ary_free(rb_parser_t *p, rb_parser_ary_t *ary)
2646# define foreach_ary(ptr) \
2647 for (rb_parser_ary_data *ptr = ary->data, *const end_ary_data = ptr + ary->len; \
2648 ptr < end_ary_data; ptr++)
2649 switch (ary->data_type) {
2650 case PARSER_ARY_DATA_AST_TOKEN:
2651 foreach_ary(data) {rb_parser_ast_token_free(p, *data);}
2653 case PARSER_ARY_DATA_SCRIPT_LINE:
2654 foreach_ary(data) {rb_parser_string_free(p, *data);}
2656 case PARSER_ARY_DATA_NODE:
2657 /* Do nothing because nodes are freed when rb_ast_t is freed */
2660 rb_bug("unexpected rb_parser_ary_data_type: %d", ary->data_type);
2674# define YY_CAST(Type, Val) static_cast<Type> (Val)
2675# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
2677# define YY_CAST(Type, Val) ((Type) (Val))
2678# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
2682# if defined __cplusplus
2683# if 201103L <= __cplusplus
2684# define YY_NULLPTR nullptr
2686# define YY_NULLPTR 0
2689# define YY_NULLPTR ((void*)0)
2697 YYSYMBOL_YYEMPTY = -2,
2698 YYSYMBOL_YYEOF = 0, /* "end-of-input" */
2699 YYSYMBOL_YYerror = 1, /* error */
2700 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
2701 YYSYMBOL_keyword_class = 3, /* "'class'" */
2702 YYSYMBOL_keyword_module = 4, /* "'module
'" */
2703 YYSYMBOL_keyword_def = 5, /* "'def
'" */
2704 YYSYMBOL_keyword_undef = 6, /* "'undef
'" */
2705 YYSYMBOL_keyword_begin = 7, /* "'begin
'" */
2706 YYSYMBOL_keyword_rescue = 8, /* "'rescue
'" */
2707 YYSYMBOL_keyword_ensure = 9, /* "'ensure
'" */
2708 YYSYMBOL_keyword_end = 10, /* "'end
'" */
2709 YYSYMBOL_keyword_if = 11, /* "'if'" */
2710 YYSYMBOL_keyword_unless = 12, /* "'unless
'" */
2711 YYSYMBOL_keyword_then = 13, /* "'then
'" */
2712 YYSYMBOL_keyword_elsif = 14, /* "'elsif
'" */
2713 YYSYMBOL_keyword_else = 15, /* "'else'" */
2714 YYSYMBOL_keyword_case = 16, /* "'case'" */
2715 YYSYMBOL_keyword_when = 17, /* "'when
'" */
2716 YYSYMBOL_keyword_while = 18, /* "'while'" */
2717 YYSYMBOL_keyword_until = 19, /* "'until
'" */
2718 YYSYMBOL_keyword_for = 20, /* "'for'" */
2719 YYSYMBOL_keyword_break = 21, /* "'break'" */
2720 YYSYMBOL_keyword_next = 22, /* "'next
'" */
2721 YYSYMBOL_keyword_redo = 23, /* "'redo
'" */
2722 YYSYMBOL_keyword_retry = 24, /* "'retry
'" */
2723 YYSYMBOL_keyword_in = 25, /* "'in
'" */
2724 YYSYMBOL_keyword_do = 26, /* "'do'" */
2725 YYSYMBOL_keyword_do_cond = 27, /* "'do' for condition" */
2726 YYSYMBOL_keyword_do_block = 28, /* "'do' for block" */
2727 YYSYMBOL_keyword_do_LAMBDA = 29, /* "'do' for lambda" */
2728 YYSYMBOL_keyword_return = 30, /* "'return'" */
2729 YYSYMBOL_keyword_yield = 31, /* "'yield
'" */
2730 YYSYMBOL_keyword_super = 32, /* "'super
'" */
2731 YYSYMBOL_keyword_self = 33, /* "'self
'" */
2732 YYSYMBOL_keyword_nil = 34, /* "'nil
'" */
2733 YYSYMBOL_keyword_true = 35, /* "'true'" */
2734 YYSYMBOL_keyword_false = 36, /* "'false'" */
2735 YYSYMBOL_keyword_and = 37, /* "'and
'" */
2736 YYSYMBOL_keyword_or = 38, /* "'or
'" */
2737 YYSYMBOL_keyword_not = 39, /* "'not
'" */
2738 YYSYMBOL_modifier_if = 40, /* "'if' modifier" */
2739 YYSYMBOL_modifier_unless = 41, /* "'unless
' modifier" */
2740 YYSYMBOL_modifier_while = 42, /* "'while' modifier" */
2741 YYSYMBOL_modifier_until = 43, /* "'until
' modifier" */
2742 YYSYMBOL_modifier_rescue = 44, /* "'rescue
' modifier" */
2743 YYSYMBOL_keyword_alias = 45, /* "'alias
'" */
2744 YYSYMBOL_keyword_defined = 46, /* "'defined?
'" */
2745 YYSYMBOL_keyword_BEGIN = 47, /* "'BEGIN
'" */
2746 YYSYMBOL_keyword_END = 48, /* "'END
'" */
2747 YYSYMBOL_keyword__LINE__ = 49, /* "'__LINE__
'" */
2748 YYSYMBOL_keyword__FILE__ = 50, /* "'__FILE__
'" */
2749 YYSYMBOL_keyword__ENCODING__ = 51, /* "'__ENCODING__
'" */
2750 YYSYMBOL_tIDENTIFIER = 52, /* "local variable or method" */
2751 YYSYMBOL_tFID = 53, /* "method" */
2752 YYSYMBOL_tGVAR = 54, /* "global variable" */
2753 YYSYMBOL_tIVAR = 55, /* "instance variable" */
2754 YYSYMBOL_tCONSTANT = 56, /* "constant" */
2755 YYSYMBOL_tCVAR = 57, /* "class variable" */
2756 YYSYMBOL_tLABEL = 58, /* "label" */
2757 YYSYMBOL_tINTEGER = 59, /* "integer literal" */
2758 YYSYMBOL_tFLOAT = 60, /* "float literal" */
2759 YYSYMBOL_tRATIONAL = 61, /* "rational literal" */
2760 YYSYMBOL_tIMAGINARY = 62, /* "imaginary literal" */
2761 YYSYMBOL_tCHAR = 63, /* "char literal" */
2762 YYSYMBOL_tNTH_REF = 64, /* "numbered reference" */
2763 YYSYMBOL_tBACK_REF = 65, /* "back reference" */
2764 YYSYMBOL_tSTRING_CONTENT = 66, /* "literal content" */
2765 YYSYMBOL_tREGEXP_END = 67, /* tREGEXP_END */
2766 YYSYMBOL_tDUMNY_END = 68, /* "dummy end" */
2767 YYSYMBOL_69_ = 69, /* '.
' */
2768 YYSYMBOL_70_backslash_ = 70, /* "backslash" */
2769 YYSYMBOL_tSP = 71, /* "escaped space" */
2770 YYSYMBOL_72_escaped_horizontal_tab_ = 72, /* "escaped horizontal tab" */
2771 YYSYMBOL_73_escaped_form_feed_ = 73, /* "escaped form feed" */
2772 YYSYMBOL_74_escaped_carriage_return_ = 74, /* "escaped carriage return" */
2773 YYSYMBOL_75_escaped_vertical_tab_ = 75, /* "escaped vertical tab" */
2774 YYSYMBOL_tUPLUS = 76, /* "unary+" */
2775 YYSYMBOL_tUMINUS = 77, /* "unary-" */
2776 YYSYMBOL_tPOW = 78, /* "**" */
2777 YYSYMBOL_tCMP = 79, /* "<=>" */
2778 YYSYMBOL_tEQ = 80, /* "==" */
2779 YYSYMBOL_tEQQ = 81, /* "===" */
2780 YYSYMBOL_tNEQ = 82, /* "!=" */
2781 YYSYMBOL_tGEQ = 83, /* ">=" */
2782 YYSYMBOL_tLEQ = 84, /* "<=" */
2783 YYSYMBOL_tANDOP = 85, /* "&&" */
2784 YYSYMBOL_tOROP = 86, /* "||" */
2785 YYSYMBOL_tMATCH = 87, /* "=~" */
2786 YYSYMBOL_tNMATCH = 88, /* "!~" */
2787 YYSYMBOL_tDOT2 = 89, /* ".." */
2788 YYSYMBOL_tDOT3 = 90, /* "..." */
2789 YYSYMBOL_tBDOT2 = 91, /* "(.." */
2790 YYSYMBOL_tBDOT3 = 92, /* "(..." */
2791 YYSYMBOL_tAREF = 93, /* "[]" */
2792 YYSYMBOL_tASET = 94, /* "[]=" */
2793 YYSYMBOL_tLSHFT = 95, /* "<<" */
2794 YYSYMBOL_tRSHFT = 96, /* ">>" */
2795 YYSYMBOL_tANDDOT = 97, /* "&." */
2796 YYSYMBOL_tCOLON2 = 98, /* "::" */
2797 YYSYMBOL_tCOLON3 = 99, /* ":: at EXPR_BEG" */
2798 YYSYMBOL_tOP_ASGN = 100, /* "operator-assignment" */
2799 YYSYMBOL_tASSOC = 101, /* "=>" */
2800 YYSYMBOL_tLPAREN = 102, /* "(" */
2801 YYSYMBOL_tLPAREN_ARG = 103, /* "( arg" */
2802 YYSYMBOL_tLBRACK = 104, /* "[" */
2803 YYSYMBOL_tLBRACE = 105, /* "{" */
2804 YYSYMBOL_tLBRACE_ARG = 106, /* "{ arg" */
2805 YYSYMBOL_tSTAR = 107, /* "*" */
2806 YYSYMBOL_tDSTAR = 108, /* "**arg" */
2807 YYSYMBOL_tAMPER = 109, /* "&" */
2808 YYSYMBOL_tLAMBDA = 110, /* "->" */
2809 YYSYMBOL_tSYMBEG = 111, /* "symbol literal" */
2810 YYSYMBOL_tSTRING_BEG = 112, /* "string literal" */
2811 YYSYMBOL_tXSTRING_BEG = 113, /* "backtick literal" */
2812 YYSYMBOL_tREGEXP_BEG = 114, /* "regexp literal" */
2813 YYSYMBOL_tWORDS_BEG = 115, /* "word list" */
2814 YYSYMBOL_tQWORDS_BEG = 116, /* "verbatim word list" */
2815 YYSYMBOL_tSYMBOLS_BEG = 117, /* "symbol list" */
2816 YYSYMBOL_tQSYMBOLS_BEG = 118, /* "verbatim symbol list" */
2817 YYSYMBOL_tSTRING_END = 119, /* "terminator" */
2818 YYSYMBOL_tSTRING_DEND = 120, /* "'}
'" */
2819 YYSYMBOL_tSTRING_DBEG = 121, /* "'#{
'" */
2820 YYSYMBOL_tSTRING_DVAR = 122, /* tSTRING_DVAR */
2821 YYSYMBOL_tLAMBEG = 123, /* tLAMBEG */
2822 YYSYMBOL_tLABEL_END = 124, /* tLABEL_END */
2823 YYSYMBOL_tIGNORED_NL = 125, /* tIGNORED_NL */
2824 YYSYMBOL_tCOMMENT = 126, /* tCOMMENT */
2825 YYSYMBOL_tEMBDOC_BEG = 127, /* tEMBDOC_BEG */
2826 YYSYMBOL_tEMBDOC = 128, /* tEMBDOC */
2827 YYSYMBOL_tEMBDOC_END = 129, /* tEMBDOC_END */
2828 YYSYMBOL_tHEREDOC_BEG = 130, /* tHEREDOC_BEG */
2829 YYSYMBOL_tHEREDOC_END = 131, /* tHEREDOC_END */
2830 YYSYMBOL_k__END__ = 132, /* k__END__ */
2831 YYSYMBOL_tLOWEST = 133, /* tLOWEST */
2832 YYSYMBOL_134_ = 134, /* '=
' */
2833 YYSYMBOL_135_ = 135, /* '?
' */
2834 YYSYMBOL_136_ = 136, /* ':
' */
2835 YYSYMBOL_137_ = 137, /* '>
' */
2836 YYSYMBOL_138_ = 138, /* '<
' */
2837 YYSYMBOL_139_ = 139, /* '|
' */
2838 YYSYMBOL_140_ = 140, /* '^
' */
2839 YYSYMBOL_141_ = 141, /* '&
' */
2840 YYSYMBOL_142_ = 142, /* '+
' */
2841 YYSYMBOL_143_ = 143, /* '-
' */
2842 YYSYMBOL_144_ = 144, /* '*
' */
2843 YYSYMBOL_145_ = 145, /* '/
' */
2844 YYSYMBOL_146_ = 146, /* '%
' */
2845 YYSYMBOL_tUMINUS_NUM = 147, /* tUMINUS_NUM */
2846 YYSYMBOL_148_ = 148, /* '!
' */
2847 YYSYMBOL_149_ = 149, /* '~
' */
2848 YYSYMBOL_tLAST_TOKEN = 150, /* tLAST_TOKEN */
2849 YYSYMBOL_151_ = 151, /* '{
' */
2850 YYSYMBOL_152_ = 152, /* '}
' */
2851 YYSYMBOL_153_ = 153, /* '[
' */
2852 YYSYMBOL_154_n_ = 154, /* '\n
' */
2853 YYSYMBOL_155_ = 155, /* ',
' */
2854 YYSYMBOL_156_ = 156, /* '`
' */
2855 YYSYMBOL_157_ = 157, /* '(
' */
2856 YYSYMBOL_158_ = 158, /* ')
' */
2857 YYSYMBOL_159_ = 159, /* ']
' */
2858 YYSYMBOL_160_ = 160, /* ';
' */
2859 YYSYMBOL_161_ = 161, /* ' ' */
2860 YYSYMBOL_YYACCEPT = 162, /* $accept */
2861 YYSYMBOL_option_terms = 163, /* option_terms */
2862 YYSYMBOL_compstmt_top_stmts = 164, /* compstmt_top_stmts */
2863 YYSYMBOL_165_1 = 165, /* $@1 */
2864 YYSYMBOL_program = 166, /* program */
2865 YYSYMBOL_top_stmts = 167, /* top_stmts */
2866 YYSYMBOL_top_stmt = 168, /* top_stmt */
2867 YYSYMBOL_block_open = 169, /* block_open */
2868 YYSYMBOL_begin_block = 170, /* begin_block */
2869 YYSYMBOL_compstmt_stmts = 171, /* compstmt_stmts */
2870 YYSYMBOL_172_2 = 172, /* $@2 */
2871 YYSYMBOL_173_3 = 173, /* $@3 */
2872 YYSYMBOL_bodystmt = 174, /* bodystmt */
2873 YYSYMBOL_175_4 = 175, /* $@4 */
2874 YYSYMBOL_stmts = 176, /* stmts */
2875 YYSYMBOL_stmt_or_begin = 177, /* stmt_or_begin */
2876 YYSYMBOL_178_5 = 178, /* $@5 */
2877 YYSYMBOL_allow_exits = 179, /* allow_exits */
2878 YYSYMBOL_k_END = 180, /* k_END */
2879 YYSYMBOL_181_6 = 181, /* $@6 */
2880 YYSYMBOL_stmt = 182, /* stmt */
2881 YYSYMBOL_asgn_mrhs = 183, /* asgn_mrhs */
2882 YYSYMBOL_asgn_command_rhs = 184, /* asgn_command_rhs */
2883 YYSYMBOL_command_asgn = 185, /* command_asgn */
2884 YYSYMBOL_op_asgn_command_rhs = 186, /* op_asgn_command_rhs */
2885 YYSYMBOL_def_endless_method_endless_command = 187, /* def_endless_method_endless_command */
2886 YYSYMBOL_endless_command = 188, /* endless_command */
2887 YYSYMBOL_option__n_ = 189, /* option_'\n
' */
2888 YYSYMBOL_command_rhs = 190, /* command_rhs */
2889 YYSYMBOL_expr = 191, /* expr */
2890 YYSYMBOL_192_7 = 192, /* $@7 */
2891 YYSYMBOL_193_8 = 193, /* $@8 */
2892 YYSYMBOL_def_name = 194, /* def_name */
2893 YYSYMBOL_defn_head = 195, /* defn_head */
2894 YYSYMBOL_196_9 = 196, /* $@9 */
2895 YYSYMBOL_defs_head = 197, /* defs_head */
2896 YYSYMBOL_value_expr_expr = 198, /* value_expr_expr */
2897 YYSYMBOL_expr_value = 199, /* expr_value */
2898 YYSYMBOL_200_10 = 200, /* $@10 */
2899 YYSYMBOL_201_11 = 201, /* $@11 */
2900 YYSYMBOL_expr_value_do = 202, /* expr_value_do */
2901 YYSYMBOL_command_call = 203, /* command_call */
2902 YYSYMBOL_value_expr_command_call = 204, /* value_expr_command_call */
2903 YYSYMBOL_command_call_value = 205, /* command_call_value */
2904 YYSYMBOL_block_command = 206, /* block_command */
2905 YYSYMBOL_cmd_brace_block = 207, /* cmd_brace_block */
2906 YYSYMBOL_fcall = 208, /* fcall */
2907 YYSYMBOL_command = 209, /* command */
2908 YYSYMBOL_mlhs = 210, /* mlhs */
2909 YYSYMBOL_mlhs_inner = 211, /* mlhs_inner */
2910 YYSYMBOL_mlhs_basic = 212, /* mlhs_basic */
2911 YYSYMBOL_mlhs_mlhs_item = 213, /* mlhs_mlhs_item */
2912 YYSYMBOL_mlhs_item = 214, /* mlhs_item */
2913 YYSYMBOL_mlhs_head = 215, /* mlhs_head */
2914 YYSYMBOL_mlhs_node = 216, /* mlhs_node */
2915 YYSYMBOL_lhs = 217, /* lhs */
2916 YYSYMBOL_cname = 218, /* cname */
2917 YYSYMBOL_cpath = 219, /* cpath */
2918 YYSYMBOL_fname = 220, /* fname */
2919 YYSYMBOL_fitem = 221, /* fitem */
2920 YYSYMBOL_undef_list = 222, /* undef_list */
2921 YYSYMBOL_223_12 = 223, /* $@12 */
2922 YYSYMBOL_op = 224, /* op */
2923 YYSYMBOL_reswords = 225, /* reswords */
2924 YYSYMBOL_asgn_arg_rhs = 226, /* asgn_arg_rhs */
2925 YYSYMBOL_arg = 227, /* arg */
2926 YYSYMBOL_op_asgn_arg_rhs = 228, /* op_asgn_arg_rhs */
2927 YYSYMBOL_range_expr_arg = 229, /* range_expr_arg */
2928 YYSYMBOL_def_endless_method_endless_arg = 230, /* def_endless_method_endless_arg */
2929 YYSYMBOL_ternary = 231, /* ternary */
2930 YYSYMBOL_endless_arg = 232, /* endless_arg */
2931 YYSYMBOL_relop = 233, /* relop */
2932 YYSYMBOL_rel_expr = 234, /* rel_expr */
2933 YYSYMBOL_lex_ctxt = 235, /* lex_ctxt */
2934 YYSYMBOL_begin_defined = 236, /* begin_defined */
2935 YYSYMBOL_after_rescue = 237, /* after_rescue */
2936 YYSYMBOL_value_expr_arg = 238, /* value_expr_arg */
2937 YYSYMBOL_arg_value = 239, /* arg_value */
2938 YYSYMBOL_aref_args = 240, /* aref_args */
2939 YYSYMBOL_arg_rhs = 241, /* arg_rhs */
2940 YYSYMBOL_paren_args = 242, /* paren_args */
2941 YYSYMBOL_opt_paren_args = 243, /* opt_paren_args */
2942 YYSYMBOL_opt_call_args = 244, /* opt_call_args */
2943 YYSYMBOL_value_expr_command = 245, /* value_expr_command */
2944 YYSYMBOL_call_args = 246, /* call_args */
2945 YYSYMBOL_247_13 = 247, /* $@13 */
2946 YYSYMBOL_command_args = 248, /* command_args */
2947 YYSYMBOL_block_arg = 249, /* block_arg */
2948 YYSYMBOL_opt_block_arg = 250, /* opt_block_arg */
2949 YYSYMBOL_args = 251, /* args */
2950 YYSYMBOL_arg_splat = 252, /* arg_splat */
2951 YYSYMBOL_mrhs_arg = 253, /* mrhs_arg */
2952 YYSYMBOL_mrhs = 254, /* mrhs */
2953 YYSYMBOL_primary = 255, /* primary */
2954 YYSYMBOL_256_14 = 256, /* $@14 */
2955 YYSYMBOL_257_15 = 257, /* $@15 */
2956 YYSYMBOL_258_16 = 258, /* @16 */
2957 YYSYMBOL_259_17 = 259, /* @17 */
2958 YYSYMBOL_260_18 = 260, /* $@18 */
2959 YYSYMBOL_261_19 = 261, /* $@19 */
2960 YYSYMBOL_262_20 = 262, /* $@20 */
2961 YYSYMBOL_263_21 = 263, /* $@21 */
2962 YYSYMBOL_264_22 = 264, /* $@22 */
2963 YYSYMBOL_265_23 = 265, /* $@23 */
2964 YYSYMBOL_266_24 = 266, /* $@24 */
2965 YYSYMBOL_value_expr_primary = 267, /* value_expr_primary */
2966 YYSYMBOL_primary_value = 268, /* primary_value */
2967 YYSYMBOL_k_begin = 269, /* k_begin */
2968 YYSYMBOL_k_if = 270, /* k_if */
2969 YYSYMBOL_k_unless = 271, /* k_unless */
2970 YYSYMBOL_k_while = 272, /* k_while */
2971 YYSYMBOL_k_until = 273, /* k_until */
2972 YYSYMBOL_k_case = 274, /* k_case */
2973 YYSYMBOL_k_for = 275, /* k_for */
2974 YYSYMBOL_k_class = 276, /* k_class */
2975 YYSYMBOL_k_module = 277, /* k_module */
2976 YYSYMBOL_k_def = 278, /* k_def */
2977 YYSYMBOL_k_do = 279, /* k_do */
2978 YYSYMBOL_k_do_block = 280, /* k_do_block */
2979 YYSYMBOL_k_rescue = 281, /* k_rescue */
2980 YYSYMBOL_k_ensure = 282, /* k_ensure */
2981 YYSYMBOL_k_when = 283, /* k_when */
2982 YYSYMBOL_k_else = 284, /* k_else */
2983 YYSYMBOL_k_elsif = 285, /* k_elsif */
2984 YYSYMBOL_k_end = 286, /* k_end */
2985 YYSYMBOL_k_return = 287, /* k_return */
2986 YYSYMBOL_k_yield = 288, /* k_yield */
2987 YYSYMBOL_then = 289, /* then */
2988 YYSYMBOL_do = 290, /* do */
2989 YYSYMBOL_if_tail = 291, /* if_tail */
2990 YYSYMBOL_opt_else = 292, /* opt_else */
2991 YYSYMBOL_for_var = 293, /* for_var */
2992 YYSYMBOL_f_marg = 294, /* f_marg */
2993 YYSYMBOL_mlhs_f_marg = 295, /* mlhs_f_marg */
2994 YYSYMBOL_f_margs = 296, /* f_margs */
2995 YYSYMBOL_f_rest_marg = 297, /* f_rest_marg */
2996 YYSYMBOL_f_any_kwrest = 298, /* f_any_kwrest */
2997 YYSYMBOL_299_25 = 299, /* $@25 */
2998 YYSYMBOL_f_eq = 300, /* f_eq */
2999 YYSYMBOL_f_kw_primary_value = 301, /* f_kw_primary_value */
3000 YYSYMBOL_f_kwarg_primary_value = 302, /* f_kwarg_primary_value */
3001 YYSYMBOL_args_tail_basic_primary_value = 303, /* args_tail_basic_primary_value */
3002 YYSYMBOL_block_args_tail = 304, /* block_args_tail */
3003 YYSYMBOL_excessed_comma = 305, /* excessed_comma */
3004 YYSYMBOL_f_opt_primary_value = 306, /* f_opt_primary_value */
3005 YYSYMBOL_f_opt_arg_primary_value = 307, /* f_opt_arg_primary_value */
3006 YYSYMBOL_opt_args_tail_block_args_tail = 308, /* opt_args_tail_block_args_tail */
3007 YYSYMBOL_block_param = 309, /* block_param */
3008 YYSYMBOL_opt_block_param_def = 310, /* opt_block_param_def */
3009 YYSYMBOL_block_param_def = 311, /* block_param_def */
3010 YYSYMBOL_opt_block_param = 312, /* opt_block_param */
3011 YYSYMBOL_opt_bv_decl = 313, /* opt_bv_decl */
3012 YYSYMBOL_bv_decls = 314, /* bv_decls */
3013 YYSYMBOL_bvar = 315, /* bvar */
3014 YYSYMBOL_max_numparam = 316, /* max_numparam */
3015 YYSYMBOL_numparam = 317, /* numparam */
3016 YYSYMBOL_it_id = 318, /* it_id */
3017 YYSYMBOL_319_26 = 319, /* @26 */
3018 YYSYMBOL_320_27 = 320, /* $@27 */
3019 YYSYMBOL_lambda = 321, /* lambda */
3020 YYSYMBOL_f_larglist = 322, /* f_larglist */
3021 YYSYMBOL_lambda_body = 323, /* lambda_body */
3022 YYSYMBOL_324_28 = 324, /* $@28 */
3023 YYSYMBOL_do_block = 325, /* do_block */
3024 YYSYMBOL_block_call = 326, /* block_call */
3025 YYSYMBOL_method_call = 327, /* method_call */
3026 YYSYMBOL_brace_block = 328, /* brace_block */
3027 YYSYMBOL_329_29 = 329, /* @29 */
3028 YYSYMBOL_brace_body = 330, /* brace_body */
3029 YYSYMBOL_331_30 = 331, /* @30 */
3030 YYSYMBOL_do_body = 332, /* do_body */
3031 YYSYMBOL_case_args = 333, /* case_args */
3032 YYSYMBOL_case_body = 334, /* case_body */
3033 YYSYMBOL_cases = 335, /* cases */
3034 YYSYMBOL_p_pvtbl = 336, /* p_pvtbl */
3035 YYSYMBOL_p_pktbl = 337, /* p_pktbl */
3036 YYSYMBOL_p_in_kwarg = 338, /* p_in_kwarg */
3037 YYSYMBOL_339_31 = 339, /* $@31 */
3038 YYSYMBOL_p_case_body = 340, /* p_case_body */
3039 YYSYMBOL_p_cases = 341, /* p_cases */
3040 YYSYMBOL_p_top_expr = 342, /* p_top_expr */
3041 YYSYMBOL_p_top_expr_body = 343, /* p_top_expr_body */
3042 YYSYMBOL_p_expr = 344, /* p_expr */
3043 YYSYMBOL_p_as = 345, /* p_as */
3044 YYSYMBOL_p_alt = 346, /* p_alt */
3045 YYSYMBOL_p_lparen = 347, /* p_lparen */
3046 YYSYMBOL_p_lbracket = 348, /* p_lbracket */
3047 YYSYMBOL_p_expr_basic = 349, /* p_expr_basic */
3048 YYSYMBOL_350_32 = 350, /* $@32 */
3049 YYSYMBOL_p_args = 351, /* p_args */
3050 YYSYMBOL_p_args_head = 352, /* p_args_head */
3051 YYSYMBOL_p_args_tail = 353, /* p_args_tail */
3052 YYSYMBOL_p_find = 354, /* p_find */
3053 YYSYMBOL_p_rest = 355, /* p_rest */
3054 YYSYMBOL_p_args_post = 356, /* p_args_post */
3055 YYSYMBOL_p_arg = 357, /* p_arg */
3056 YYSYMBOL_p_kwargs = 358, /* p_kwargs */
3057 YYSYMBOL_p_kwarg = 359, /* p_kwarg */
3058 YYSYMBOL_p_kw = 360, /* p_kw */
3059 YYSYMBOL_p_kw_label = 361, /* p_kw_label */
3060 YYSYMBOL_p_kwrest = 362, /* p_kwrest */
3061 YYSYMBOL_p_kwnorest = 363, /* p_kwnorest */
3062 YYSYMBOL_p_any_kwrest = 364, /* p_any_kwrest */
3063 YYSYMBOL_p_value = 365, /* p_value */
3064 YYSYMBOL_range_expr_p_primitive = 366, /* range_expr_p_primitive */
3065 YYSYMBOL_p_primitive = 367, /* p_primitive */
3066 YYSYMBOL_p_variable = 368, /* p_variable */
3067 YYSYMBOL_p_var_ref = 369, /* p_var_ref */
3068 YYSYMBOL_p_expr_ref = 370, /* p_expr_ref */
3069 YYSYMBOL_p_const = 371, /* p_const */
3070 YYSYMBOL_opt_rescue = 372, /* opt_rescue */
3071 YYSYMBOL_exc_list = 373, /* exc_list */
3072 YYSYMBOL_exc_var = 374, /* exc_var */
3073 YYSYMBOL_opt_ensure = 375, /* opt_ensure */
3074 YYSYMBOL_literal = 376, /* literal */
3075 YYSYMBOL_strings = 377, /* strings */
3076 YYSYMBOL_string = 378, /* string */
3077 YYSYMBOL_string1 = 379, /* string1 */
3078 YYSYMBOL_xstring = 380, /* xstring */
3079 YYSYMBOL_regexp = 381, /* regexp */
3080 YYSYMBOL_nonempty_list__ = 382, /* nonempty_list_' ' */
3081 YYSYMBOL_words_tWORDS_BEG_word_list = 383, /* words_tWORDS_BEG_word_list */
3082 YYSYMBOL_words = 384, /* words */
3083 YYSYMBOL_word_list = 385, /* word_list */
3084 YYSYMBOL_word = 386, /* word */
3085 YYSYMBOL_words_tSYMBOLS_BEG_symbol_list = 387, /* words_tSYMBOLS_BEG_symbol_list */
3086 YYSYMBOL_symbols = 388, /* symbols */
3087 YYSYMBOL_symbol_list = 389, /* symbol_list */
3088 YYSYMBOL_words_tQWORDS_BEG_qword_list = 390, /* words_tQWORDS_BEG_qword_list */
3089 YYSYMBOL_qwords = 391, /* qwords */
3090 YYSYMBOL_words_tQSYMBOLS_BEG_qsym_list = 392, /* words_tQSYMBOLS_BEG_qsym_list */
3091 YYSYMBOL_qsymbols = 393, /* qsymbols */
3092 YYSYMBOL_qword_list = 394, /* qword_list */
3093 YYSYMBOL_qsym_list = 395, /* qsym_list */
3094 YYSYMBOL_string_contents = 396, /* string_contents */
3095 YYSYMBOL_xstring_contents = 397, /* xstring_contents */
3096 YYSYMBOL_regexp_contents = 398, /* regexp_contents */
3097 YYSYMBOL_string_content = 399, /* string_content */
3098 YYSYMBOL_400_33 = 400, /* @33 */
3099 YYSYMBOL_401_34 = 401, /* @34 */
3100 YYSYMBOL_402_35 = 402, /* @35 */
3101 YYSYMBOL_403_36 = 403, /* @36 */
3102 YYSYMBOL_string_dend = 404, /* string_dend */
3103 YYSYMBOL_string_dvar = 405, /* string_dvar */
3104 YYSYMBOL_symbol = 406, /* symbol */
3105 YYSYMBOL_ssym = 407, /* ssym */
3106 YYSYMBOL_sym = 408, /* sym */
3107 YYSYMBOL_dsym = 409, /* dsym */
3108 YYSYMBOL_numeric = 410, /* numeric */
3109 YYSYMBOL_simple_numeric = 411, /* simple_numeric */
3110 YYSYMBOL_nonlocal_var = 412, /* nonlocal_var */
3111 YYSYMBOL_user_variable = 413, /* user_variable */
3112 YYSYMBOL_keyword_variable = 414, /* keyword_variable */
3113 YYSYMBOL_var_ref = 415, /* var_ref */
3114 YYSYMBOL_var_lhs = 416, /* var_lhs */
3115 YYSYMBOL_backref = 417, /* backref */
3116 YYSYMBOL_418_37 = 418, /* $@37 */
3117 YYSYMBOL_superclass = 419, /* superclass */
3118 YYSYMBOL_f_opt_paren_args = 420, /* f_opt_paren_args */
3119 YYSYMBOL_f_paren_args = 421, /* f_paren_args */
3120 YYSYMBOL_f_arglist = 422, /* f_arglist */
3121 YYSYMBOL_423_38 = 423, /* @38 */
3122 YYSYMBOL_f_kw_arg_value = 424, /* f_kw_arg_value */
3123 YYSYMBOL_f_kwarg_arg_value = 425, /* f_kwarg_arg_value */
3124 YYSYMBOL_args_tail_basic_arg_value = 426, /* args_tail_basic_arg_value */
3125 YYSYMBOL_args_tail = 427, /* args_tail */
3126 YYSYMBOL_f_opt_arg_value = 428, /* f_opt_arg_value */
3127 YYSYMBOL_f_opt_arg_arg_value = 429, /* f_opt_arg_arg_value */
3128 YYSYMBOL_opt_args_tail_args_tail = 430, /* opt_args_tail_args_tail */
3129 YYSYMBOL_f_args = 431, /* f_args */
3130 YYSYMBOL_args_forward = 432, /* args_forward */
3131 YYSYMBOL_f_bad_arg = 433, /* f_bad_arg */
3132 YYSYMBOL_f_norm_arg = 434, /* f_norm_arg */
3133 YYSYMBOL_f_arg_asgn = 435, /* f_arg_asgn */
3134 YYSYMBOL_f_arg_item = 436, /* f_arg_item */
3135 YYSYMBOL_f_arg = 437, /* f_arg */
3136 YYSYMBOL_f_label = 438, /* f_label */
3137 YYSYMBOL_kwrest_mark = 439, /* kwrest_mark */
3138 YYSYMBOL_f_no_kwarg = 440, /* f_no_kwarg */
3139 YYSYMBOL_f_kwrest = 441, /* f_kwrest */
3140 YYSYMBOL_restarg_mark = 442, /* restarg_mark */
3141 YYSYMBOL_f_rest_arg = 443, /* f_rest_arg */
3142 YYSYMBOL_blkarg_mark = 444, /* blkarg_mark */
3143 YYSYMBOL_f_block_arg = 445, /* f_block_arg */
3144 YYSYMBOL_opt_f_block_arg = 446, /* opt_f_block_arg */
3145 YYSYMBOL_value_expr_singleton_expr = 447, /* value_expr_singleton_expr */
3146 YYSYMBOL_singleton = 448, /* singleton */
3147 YYSYMBOL_singleton_expr = 449, /* singleton_expr */
3148 YYSYMBOL_450_39 = 450, /* $@39 */
3149 YYSYMBOL_assoc_list = 451, /* assoc_list */
3150 YYSYMBOL_assocs = 452, /* assocs */
3151 YYSYMBOL_assoc = 453, /* assoc */
3152 YYSYMBOL_operation2 = 454, /* operation2 */
3153 YYSYMBOL_operation3 = 455, /* operation3 */
3154 YYSYMBOL_dot_or_colon = 456, /* dot_or_colon */
3155 YYSYMBOL_call_op = 457, /* call_op */
3156 YYSYMBOL_call_op2 = 458, /* call_op2 */
3157 YYSYMBOL_rparen = 459, /* rparen */
3158 YYSYMBOL_rbracket = 460, /* rbracket */
3159 YYSYMBOL_rbrace = 461, /* rbrace */
3160 YYSYMBOL_trailer = 462, /* trailer */
3161 YYSYMBOL_term = 463, /* term */
3162 YYSYMBOL_terms = 464, /* terms */
3163 YYSYMBOL_none = 465 /* none */
3165typedef enum yysymbol_kind_t yysymbol_kind_t;
3174/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
3175 <limits.h> and (if available) <stdint.h> are included
3176 so that the code can choose integer types of a good width. */
3178#ifndef __PTRDIFF_MAX__
3179# include <limits.h> /* INFRINGES ON USER NAME SPACE */
3180# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
3181# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
3186/* Narrow types that promote to a signed type and that can represent a
3187 signed or unsigned integer of at least N bits. In tables they can
3188 save space and decrease cache pressure. Promoting to a signed type
3189 helps avoid bugs in integer arithmetic. */
3191#ifdef __INT_LEAST8_MAX__
3192typedef __INT_LEAST8_TYPE__ yytype_int8;
3193#elif defined YY_STDINT_H
3194typedef int_least8_t yytype_int8;
3196typedef signed char yytype_int8;
3199#ifdef __INT_LEAST16_MAX__
3200typedef __INT_LEAST16_TYPE__ yytype_int16;
3201#elif defined YY_STDINT_H
3202typedef int_least16_t yytype_int16;
3204typedef short yytype_int16;
3207/* Work around bug in HP-UX 11.23, which defines these macros
3208 incorrectly for preprocessor constants. This workaround can likely
3209 be removed in 2023, as HPE has promised support for HP-UX 11.23
3210 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
3211 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
3213# undef UINT_LEAST8_MAX
3214# undef UINT_LEAST16_MAX
3215# define UINT_LEAST8_MAX 255
3216# define UINT_LEAST16_MAX 65535
3219#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
3220typedef __UINT_LEAST8_TYPE__ yytype_uint8;
3221#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
3222 && UINT_LEAST8_MAX <= INT_MAX)
3223typedef uint_least8_t yytype_uint8;
3224#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
3225typedef unsigned char yytype_uint8;
3227typedef short yytype_uint8;
3230#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
3231typedef __UINT_LEAST16_TYPE__ yytype_uint16;
3232#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
3233 && UINT_LEAST16_MAX <= INT_MAX)
3234typedef uint_least16_t yytype_uint16;
3235#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
3236typedef unsigned short yytype_uint16;
3238typedef int yytype_uint16;
3242# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
3243# define YYPTRDIFF_T __PTRDIFF_TYPE__
3244# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
3245# elif defined PTRDIFF_MAX
3247# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
3249# define YYPTRDIFF_T ptrdiff_t
3250# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
3252# define YYPTRDIFF_T long
3253# define YYPTRDIFF_MAXIMUM LONG_MAX
3258# ifdef __SIZE_TYPE__
3259# define YYSIZE_T __SIZE_TYPE__
3260# elif defined size_t
3261# define YYSIZE_T size_t
3262# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
3263# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
3264# define YYSIZE_T size_t
3266# define YYSIZE_T unsigned
3270#define YYSIZE_MAXIMUM \
3271 YY_CAST (YYPTRDIFF_T, \
3272 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
3273 ? YYPTRDIFF_MAXIMUM \
3274 : YY_CAST (YYSIZE_T, -1)))
3276#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
3279/* Stored state numbers (used for stacks). */
3280typedef yytype_int16 yy_state_t;
3282/* State numbers in computations. */
3283typedef int yy_state_fast_t;
3286# if defined YYENABLE_NLS && YYENABLE_NLS
3288# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
3289# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
3293# define YY_(Msgid) Msgid
3298#ifndef YY_ATTRIBUTE_PURE
3299# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
3300# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
3302# define YY_ATTRIBUTE_PURE
3306#ifndef YY_ATTRIBUTE_UNUSED
3307# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
3308# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
3310# define YY_ATTRIBUTE_UNUSED
3314/* Suppress unused-variable warnings by "using" E. */
3315#if ! defined lint || defined __GNUC__
3316# define YY_USE(E) ((void) (E))
3318# define YY_USE(E) /* empty */
3321/* Suppress an incorrect diagnostic about yylval being uninitialized. */
3322#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
3323# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
3324# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
3325 _Pragma ("GCC diagnostic push") \
3326 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
3328# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
3329 _Pragma ("GCC diagnostic push") \
3330 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
3331 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
3333# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
3334 _Pragma ("GCC diagnostic pop")
3336# define YY_INITIAL_VALUE(Value) Value
3338#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3339# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3340# define YY_IGNORE_MAYBE_UNINITIALIZED_END
3342#ifndef YY_INITIAL_VALUE
3343# define YY_INITIAL_VALUE(Value) /* Nothing. */
3346#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
3347# define YY_IGNORE_USELESS_CAST_BEGIN \
3348 _Pragma ("GCC diagnostic push") \
3349 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
3350# define YY_IGNORE_USELESS_CAST_END \
3351 _Pragma ("GCC diagnostic pop")
3353#ifndef YY_IGNORE_USELESS_CAST_BEGIN
3354# define YY_IGNORE_USELESS_CAST_BEGIN
3355# define YY_IGNORE_USELESS_CAST_END
3359#define YY_ASSERT(E) ((void) (0 && (E)))
3363/* The parser invokes alloca or malloc; define the necessary symbols. */
3365# ifdef YYSTACK_USE_ALLOCA
3366# if YYSTACK_USE_ALLOCA
3368# define YYSTACK_ALLOC __builtin_alloca
3369# elif defined __BUILTIN_VA_ARG_INCR
3370# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
3372# define YYSTACK_ALLOC __alloca
3373# elif defined _MSC_VER
3374# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
3375# define alloca _alloca
3377# define YYSTACK_ALLOC alloca
3378# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
3379# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
3380 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
3381# ifndef EXIT_SUCCESS
3382# define EXIT_SUCCESS 0
3389# ifdef YYSTACK_ALLOC
3390 /* Pacify GCC's
'empty if-body' warning. */
3391# define YYSTACK_FREE(Ptr) do { ; } while (0)
3392# ifndef YYSTACK_ALLOC_MAXIMUM
3397# define YYSTACK_ALLOC_MAXIMUM 4032
3400# define YYSTACK_ALLOC YYMALLOC
3401# define YYSTACK_FREE YYFREE
3402# ifndef YYSTACK_ALLOC_MAXIMUM
3403# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
3405# if (defined __cplusplus && ! defined EXIT_SUCCESS \
3406 && ! ((defined YYMALLOC || defined malloc) \
3407 && (defined YYFREE || defined free)))
3409# ifndef EXIT_SUCCESS
3410# define EXIT_SUCCESS 0
3414# define YYMALLOC malloc
3415# if ! defined malloc && ! defined EXIT_SUCCESS
3416void *malloc (YYSIZE_T);
3421# if ! defined free && ! defined EXIT_SUCCESS
3428#if (! defined yyoverflow \
3429 && (! defined __cplusplus \
3430 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
3431 && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
3436 yy_state_t yyss_alloc;
3442# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
3446# define YYSTACK_BYTES(N) \
3447 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
3448 + YYSIZEOF (YYLTYPE)) \
3449 + 2 * YYSTACK_GAP_MAXIMUM)
3451# define YYCOPY_NEEDED 1
3458# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
3461 YYPTRDIFF_T yynewbytes; \
3462 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
3463 Stack = &yyptr->Stack_alloc; \
3464 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
3465 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
3471#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
3475# if defined __GNUC__ && 1 < __GNUC__
3476# define YYCOPY(Dst, Src, Count) \
3477 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
3479# define YYCOPY(Dst, Src, Count) \
3483 for (yyi = 0; yyi < (Count); yyi++) \
3484 (Dst)[yyi] = (Src)[yyi]; \
3497#define YYNTOKENS 162
3503#define YYNSTATES 1375
3506#define YYMAXUTOK 361
3511#define YYTRANSLATE(YYX) \
3512 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
3513 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
3518static const yytype_uint8 yytranslate[] =
3520 0, 2, 2, 2, 2, 2, 2, 2, 2, 72,
3521 154, 75, 73, 74, 2, 2, 2, 2, 2, 2,
3522 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3523 2, 2, 161, 148, 2, 2, 2, 146, 141, 2,
3524 157, 158, 144, 142, 155, 143, 69, 145, 2, 2,
3525 2, 2, 2, 2, 2, 2, 2, 2, 136, 160,
3526 138, 134, 137, 135, 2, 2, 2, 2, 2, 2,
3527 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3528 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3529 2, 153, 70, 159, 140, 2, 156, 2, 2, 2,
3530 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3531 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3532 2, 2, 2, 151, 139, 152, 149, 2, 89, 90,
3533 91, 92, 76, 77, 78, 79, 95, 96, 84, 83,
3534 80, 81, 82, 87, 88, 93, 94, 98, 85, 86,
3535 97, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3536 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3537 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3538 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3539 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3540 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3541 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3542 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3543 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3544 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3545 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
3546 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3547 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3548 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
3549 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
3550 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3551 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
3552 65, 66, 67, 68, 71, 99, 100, 101, 102, 103,
3553 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
3554 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
3555 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
3561static const yytype_int16 yyrline[] =
3563 0, 3165, 3159, 3165, 3165, 3165, 3165, 3185, 3190, 3195,
3564 3202, 3207, 3214, 3216, 3234, 3230, 3235, 3234, 3246, 3243,
3565 3256, 3261, 3266, 3273, 3275, 3274, 3284, 3286, 3293, 3293,
3566 3298, 3303, 3311, 3320, 3327, 3333, 3339, 3350, 3361, 3370,
3567 3383, 3384, 3389, 3389, 3390, 3401, 3406, 3407, 3414, 3414,
3568 3415, 3415, 3415, 3415, 3415, 3415, 3415, 3415, 3415, 3416,
3569 3416, 3416, 3419, 3420, 3426, 3426, 3426, 3433, 3434, 3441,
3570 3444, 3445, 3450, 3455, 3460, 3466, 3465, 3479, 3478, 3491,
3571 3494, 3505, 3515, 3514, 3528, 3528, 3529, 3535, 3535, 3535,
3572 3542, 3543, 3546, 3546, 3549, 3550, 3557, 3565, 3565, 3565,
3573 3572, 3579, 3588, 3593, 3598, 3603, 3608, 3614, 3620, 3626,
3574 3631, 3638, 3647, 3648, 3655, 3656, 3663, 3668, 3673, 3678,
3575 3678, 3678, 3683, 3688, 3693, 3698, 3703, 3708, 3715, 3716,
3576 3723, 3728, 3736, 3736, 3741, 3746, 3746, 3752, 3757, 3762,
3577 3767, 3775, 3775, 3780, 3785, 3785, 3790, 3795, 3800, 3805,
3578 3813, 3821, 3824, 3829, 3834, 3841, 3841, 3841, 3842, 3847,
3579 3850, 3855, 3858, 3863, 3863, 3871, 3872, 3873, 3874, 3875,
3580 3876, 3877, 3878, 3879, 3880, 3881, 3882, 3883, 3884, 3885,
3581 3886, 3887, 3888, 3889, 3890, 3891, 3892, 3893, 3894, 3895,
3582 3896, 3897, 3898, 3899, 3900, 3903, 3903, 3903, 3904, 3904,
3583 3905, 3905, 3905, 3906, 3906, 3906, 3906, 3907, 3907, 3907,
3584 3907, 3908, 3908, 3908, 3909, 3909, 3909, 3909, 3910, 3910,
3585 3910, 3910, 3911, 3911, 3911, 3911, 3912, 3912, 3912, 3912,
3586 3913, 3913, 3913, 3913, 3914, 3914, 3917, 3917, 3918, 3918,
3587 3918, 3918, 3918, 3918, 3918, 3918, 3918, 3919, 3919, 3919,
3588 3919, 3919, 3919, 3919, 3920, 3925, 3930, 3935, 3940, 3945,
3589 3950, 3955, 3960, 3965, 3970, 3975, 3980, 3985, 3986, 3991,
3590 3996, 4001, 4006, 4011, 4016, 4021, 4026, 4031, 4036, 4041,
3591 4048, 4048, 4048, 4049, 4050, 4053, 4062, 4063, 4069, 4076,
3592 4077, 4078, 4079, 4082, 4087, 4095, 4101, 4108, 4115, 4115,
3593 4118, 4119, 4120, 4125, 4132, 4137, 4146, 4151, 4161, 4173,
3594 4174, 4180, 4181, 4182, 4183, 4188, 4195, 4195, 4200, 4205,
3595 4211, 4217, 4221, 4221, 4259, 4264, 4272, 4277, 4285, 4290,
3596 4295, 4300, 4308, 4313, 4322, 4323, 4327, 4332, 4337, 4355,
3597 4355, 4355, 4355, 4355, 4355, 4355, 4355, 4356, 4357, 4358,
3598 4364, 4363, 4376, 4376, 4382, 4388, 4393, 4398, 4403, 4409,
3599 4414, 4419, 4424, 4429, 4436, 4441, 4446, 4451, 4452, 4458,
3600 4460, 4472, 4481, 4490, 4499, 4498, 4513, 4512, 4525, 4533,
3601 4533, 4534, 4577, 4576, 4599, 4598, 4618, 4617, 4636, 4634,
3602 4651, 4649, 4664, 4669, 4674, 4679, 4694, 4694, 4697, 4704,
3603 4722, 4729, 4737, 4745, 4752, 4760, 4769, 4778, 4786, 4793,
3604 4800, 4808, 4815, 4821, 4836, 4843, 4848, 4854, 4861, 4868,
3605 4869, 4870, 4873, 4874, 4877, 4879, 4888, 4889, 4896, 4897,
3606 4900, 4905, 4913, 4913, 4913, 4918, 4923, 4928, 4933, 4940,
3607 4946, 4953, 4954, 4961, 4961, 4963, 4963, 4963, 4963, 4963,
3608 4963, 4963, 4963, 4963, 4966, 4974, 4974, 4974, 4974, 4974,
3609 4974, 4979, 4984, 4989, 4994, 4999, 5005, 5010, 5015, 5020,
3610 5025, 5030, 5035, 5040, 5045, 5052, 5053, 5059, 5069, 5073,
3611 5076, 5081, 5088, 5090, 5094, 5099, 5102, 5108, 5113, 5120,
3612 5126, 5119, 5153, 5160, 5169, 5176, 5175, 5186, 5194, 5206,
3613 5216, 5225, 5232, 5239, 5250, 5256, 5261, 5267, 5277, 5282,
3614 5290, 5296, 5304, 5306, 5321, 5321, 5342, 5348, 5353, 5359,
3615 5367, 5376, 5377, 5380, 5381, 5383, 5394, 5399, 5407, 5408,
3616 5411, 5412, 5418, 5426, 5427, 5433, 5439, 5444, 5449, 5456,
3617 5459, 5466, 5469, 5474, 5477, 5484, 5491, 5492, 5493, 5500,
3618 5507, 5514, 5520, 5527, 5534, 5541, 5547, 5552, 5557, 5564,
3619 5563, 5574, 5580, 5588, 5594, 5599, 5604, 5609, 5614, 5617,
3620 5618, 5625, 5630, 5637, 5645, 5651, 5658, 5659, 5666, 5673,
3621 5678, 5683, 5688, 5695, 5697, 5704, 5710, 5722, 5723, 5738,
3622 5743, 5750, 5756, 5757, 5764, 5765, 5765, 5765, 5765, 5765,
3623 5765, 5765, 5766, 5767, 5768, 5771, 5771, 5771, 5771, 5771,
3624 5771, 5771, 5771, 5772, 5777, 5780, 5788, 5800, 5807, 5814,
3625 5819, 5824, 5832, 5852, 5855, 5860, 5864, 5867, 5872, 5875,
3626 5882, 5885, 5886, 5889, 5900, 5901, 5902, 5909, 5922, 5934,
3627 5941, 5941, 5941, 5941, 5945, 5949, 5956, 5958, 5965, 5965,
3628 5969, 5973, 5980, 5980, 5983, 5983, 5987, 5991, 5999, 6003,
3629 6011, 6015, 6023, 6027, 6035, 6039, 6065, 6068, 6067, 6082,
3630 6090, 6094, 6098, 6113, 6114, 6117, 6122, 6125, 6126, 6129,
3631 6145, 6146, 6149, 6157, 6158, 6166, 6167, 6168, 6169, 6172,
3632 6173, 6174, 6177, 6177, 6178, 6181, 6182, 6183, 6184, 6185,
3633 6186, 6187, 6190, 6200, 6207, 6207, 6214, 6215, 6219, 6218,
3634 6228, 6231, 6232, 6241, 6251, 6252, 6252, 6269, 6269, 6269,
3635 6269, 6269, 6269, 6269, 6269, 6269, 6270, 6287, 6287, 6287,
3636 6287, 6287, 6287, 6292, 6297, 6302, 6307, 6312, 6317, 6322,
3637 6327, 6332, 6337, 6342, 6347, 6352, 6358, 6365, 6376, 6385,
3638 6394, 6403, 6414, 6415, 6425, 6432, 6437, 6456, 6458, 6469,
3639 6489, 6490, 6493, 6499, 6505, 6513, 6514, 6517, 6523, 6531,
3640 6532, 6535, 6541, 6549, 6554, 6558, 6558, 6588, 6590, 6589,
3641 6602, 6603, 6610, 6612, 6637, 6642, 6647, 6654, 6660, 6665,
3642 6678, 6678, 6678, 6679, 6682, 6683, 6684, 6687, 6688, 6691,
3643 6692, 6695, 6696, 6699, 6702, 6705, 6708, 6709, 6712, 6720,
3649#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
3654static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
3658static const char *
const yytname[] =
3660 "\"end-of-input\"",
"error",
"\"invalid token\"",
"\"'class'\"",
3661 "\"'module'\"",
"\"'def'\"",
"\"'undef'\"",
"\"'begin'\"",
3662 "\"'rescue'\"",
"\"'ensure'\"",
"\"'end'\"",
"\"'if'\"",
"\"'unless'\"",
3663 "\"'then'\"",
"\"'elsif'\"",
"\"'else'\"",
"\"'case'\"",
"\"'when'\"",
3664 "\"'while'\"",
"\"'until'\"",
"\"'for'\"",
"\"'break'\"",
"\"'next'\"",
3665 "\"'redo'\"",
"\"'retry'\"",
"\"'in'\"",
"\"'do'\"",
3666 "\"'do' for condition\"",
"\"'do' for block\"",
"\"'do' for lambda\"",
3667 "\"'return'\"",
"\"'yield'\"",
"\"'super'\"",
"\"'self'\"",
"\"'nil'\"",
3668 "\"'true'\"",
"\"'false'\"",
"\"'and'\"",
"\"'or'\"",
"\"'not'\"",
3669 "\"'if' modifier\"",
"\"'unless' modifier\"",
"\"'while' modifier\"",
3670 "\"'until' modifier\"",
"\"'rescue' modifier\"",
"\"'alias'\"",
3671 "\"'defined?'\"",
"\"'BEGIN'\"",
"\"'END'\"",
"\"'__LINE__'\"",
3672 "\"'__FILE__'\"",
"\"'__ENCODING__'\"",
"\"local variable or method\"",
3673 "\"method\"",
"\"global variable\"",
"\"instance variable\"",
3674 "\"constant\"",
"\"class variable\"",
"\"label\"",
"\"integer literal\"",
3675 "\"float literal\"",
"\"rational literal\"",
"\"imaginary literal\"",
3676 "\"char literal\"",
"\"numbered reference\"",
"\"back reference\"",
3677 "\"literal content\"",
"tREGEXP_END",
"\"dummy end\"",
"'.'",
3678 "\"backslash\"",
"\"escaped space\"",
"\"escaped horizontal tab\"",
3679 "\"escaped form feed\"",
"\"escaped carriage return\"",
3680 "\"escaped vertical tab\"",
"\"unary+\"",
"\"unary-\"",
"\"**\"",
3681 "\"<=>\"",
"\"==\"",
"\"===\"",
"\"!=\"",
"\">=\"",
"\"<=\"",
"\"&&\"",
3682 "\"||\"",
"\"=~\"",
"\"!~\"",
"\"..\"",
"\"...\"",
"\"(..\"",
"\"(...\"",
3683 "\"[]\"",
"\"[]=\"",
"\"<<\"",
"\">>\"",
"\"&.\"",
"\"::\"",
3684 "\":: at EXPR_BEG\"",
"\"operator-assignment\"",
"\"=>\"",
"\"(\"",
3685 "\"( arg\"",
"\"[\"",
"\"{\"",
"\"{ arg\"",
"\"*\"",
"\"**arg\"",
3686 "\"&\"",
"\"->\"",
"\"symbol literal\"",
"\"string literal\"",
3687 "\"backtick literal\"",
"\"regexp literal\"",
"\"word list\"",
3688 "\"verbatim word list\"",
"\"symbol list\"",
"\"verbatim symbol list\"",
3689 "\"terminator\"",
"\"'}'\"",
"\"'#{'\"",
"tSTRING_DVAR",
"tLAMBEG",
3690 "tLABEL_END",
"tIGNORED_NL",
"tCOMMENT",
"tEMBDOC_BEG",
"tEMBDOC",
3691 "tEMBDOC_END",
"tHEREDOC_BEG",
"tHEREDOC_END",
"k__END__",
"tLOWEST",
3692 "'='",
"'?'",
"':'",
"'>'",
"'<'",
"'|'",
"'^'",
"'&'",
"'+'",
"'-'",
3693 "'*'",
"'/'",
"'%'",
"tUMINUS_NUM",
"'!'",
"'~'",
"tLAST_TOKEN",
"'{'",
3694 "'}'",
"'['",
"'\\n'",
"','",
"'`'",
"'('",
"')'",
"']'",
"';'",
"' '",
3695 "$accept",
"option_terms",
"compstmt_top_stmts",
"$@1",
"program",
3696 "top_stmts",
"top_stmt",
"block_open",
"begin_block",
"compstmt_stmts",
3697 "$@2",
"$@3",
"bodystmt",
"$@4",
"stmts",
"stmt_or_begin",
"$@5",
3698 "allow_exits",
"k_END",
"$@6",
"stmt",
"asgn_mrhs",
"asgn_command_rhs",
3699 "command_asgn",
"op_asgn_command_rhs",
3700 "def_endless_method_endless_command",
"endless_command",
"option_'\\n'",
3701 "command_rhs",
"expr",
"$@7",
"$@8",
"def_name",
"defn_head",
"$@9",
3702 "defs_head",
"value_expr_expr",
"expr_value",
"$@10",
"$@11",
3703 "expr_value_do",
"command_call",
"value_expr_command_call",
3704 "command_call_value",
"block_command",
"cmd_brace_block",
"fcall",
3705 "command",
"mlhs",
"mlhs_inner",
"mlhs_basic",
"mlhs_mlhs_item",
3706 "mlhs_item",
"mlhs_head",
"mlhs_node",
"lhs",
"cname",
"cpath",
"fname",
3707 "fitem",
"undef_list",
"$@12",
"op",
"reswords",
"asgn_arg_rhs",
"arg",
3708 "op_asgn_arg_rhs",
"range_expr_arg",
"def_endless_method_endless_arg",
3709 "ternary",
"endless_arg",
"relop",
"rel_expr",
"lex_ctxt",
3710 "begin_defined",
"after_rescue",
"value_expr_arg",
"arg_value",
3711 "aref_args",
"arg_rhs",
"paren_args",
"opt_paren_args",
"opt_call_args",
3712 "value_expr_command",
"call_args",
"$@13",
"command_args",
"block_arg",
3713 "opt_block_arg",
"args",
"arg_splat",
"mrhs_arg",
"mrhs",
"primary",
3714 "$@14",
"$@15",
"@16",
"@17",
"$@18",
"$@19",
"$@20",
"$@21",
"$@22",
3715 "$@23",
"$@24",
"value_expr_primary",
"primary_value",
"k_begin",
"k_if",
3716 "k_unless",
"k_while",
"k_until",
"k_case",
"k_for",
"k_class",
3717 "k_module",
"k_def",
"k_do",
"k_do_block",
"k_rescue",
"k_ensure",
3718 "k_when",
"k_else",
"k_elsif",
"k_end",
"k_return",
"k_yield",
"then",
3719 "do",
"if_tail",
"opt_else",
"for_var",
"f_marg",
"mlhs_f_marg",
3720 "f_margs",
"f_rest_marg",
"f_any_kwrest",
"$@25",
"f_eq",
3721 "f_kw_primary_value",
"f_kwarg_primary_value",
3722 "args_tail_basic_primary_value",
"block_args_tail",
"excessed_comma",
3723 "f_opt_primary_value",
"f_opt_arg_primary_value",
3724 "opt_args_tail_block_args_tail",
"block_param",
"opt_block_param_def",
3725 "block_param_def",
"opt_block_param",
"opt_bv_decl",
"bv_decls",
"bvar",
3726 "max_numparam",
"numparam",
"it_id",
"@26",
"$@27",
"lambda",
3727 "f_larglist",
"lambda_body",
"$@28",
"do_block",
"block_call",
3728 "method_call",
"brace_block",
"@29",
"brace_body",
"@30",
"do_body",
3729 "case_args",
"case_body",
"cases",
"p_pvtbl",
"p_pktbl",
"p_in_kwarg",
3730 "$@31",
"p_case_body",
"p_cases",
"p_top_expr",
"p_top_expr_body",
3731 "p_expr",
"p_as",
"p_alt",
"p_lparen",
"p_lbracket",
"p_expr_basic",
3732 "$@32",
"p_args",
"p_args_head",
"p_args_tail",
"p_find",
"p_rest",
3733 "p_args_post",
"p_arg",
"p_kwargs",
"p_kwarg",
"p_kw",
"p_kw_label",
3734 "p_kwrest",
"p_kwnorest",
"p_any_kwrest",
"p_value",
3735 "range_expr_p_primitive",
"p_primitive",
"p_variable",
"p_var_ref",
3736 "p_expr_ref",
"p_const",
"opt_rescue",
"exc_list",
"exc_var",
3737 "opt_ensure",
"literal",
"strings",
"string",
"string1",
"xstring",
3738 "regexp",
"nonempty_list_' '",
"words_tWORDS_BEG_word_list",
"words",
3739 "word_list",
"word",
"words_tSYMBOLS_BEG_symbol_list",
"symbols",
3740 "symbol_list",
"words_tQWORDS_BEG_qword_list",
"qwords",
3741 "words_tQSYMBOLS_BEG_qsym_list",
"qsymbols",
"qword_list",
"qsym_list",
3742 "string_contents",
"xstring_contents",
"regexp_contents",
3743 "string_content",
"@33",
"@34",
"@35",
"@36",
"string_dend",
3744 "string_dvar",
"symbol",
"ssym",
"sym",
"dsym",
"numeric",
3745 "simple_numeric",
"nonlocal_var",
"user_variable",
"keyword_variable",
3746 "var_ref",
"var_lhs",
"backref",
"$@37",
"superclass",
3747 "f_opt_paren_args",
"f_paren_args",
"f_arglist",
"@38",
"f_kw_arg_value",
3748 "f_kwarg_arg_value",
"args_tail_basic_arg_value",
"args_tail",
3749 "f_opt_arg_value",
"f_opt_arg_arg_value",
"opt_args_tail_args_tail",
3750 "f_args",
"args_forward",
"f_bad_arg",
"f_norm_arg",
"f_arg_asgn",
3751 "f_arg_item",
"f_arg",
"f_label",
"kwrest_mark",
"f_no_kwarg",
3752 "f_kwrest",
"restarg_mark",
"f_rest_arg",
"blkarg_mark",
"f_block_arg",
3753 "opt_f_block_arg",
"value_expr_singleton_expr",
"singleton",
3754 "singleton_expr",
"$@39",
"assoc_list",
"assocs",
"assoc",
"operation2",
3755 "operation3",
"dot_or_colon",
"call_op",
"call_op2",
"rparen",
3756 "rbracket",
"rbrace",
"trailer",
"term",
"terms",
"none", YY_NULLPTR
3760yysymbol_name (yysymbol_kind_t yysymbol)
3762 return yytname[yysymbol];
3766#define YYPACT_NINF (-1157)
3768#define yypact_value_is_default(Yyn) \
3769 ((Yyn) == YYPACT_NINF)
3771#define YYTABLE_NINF (-813)
3773#define yytable_value_is_error(Yyn) \
3774 ((Yyn) == YYTABLE_NINF)
3778static const yytype_int16 yypact[] =
3780 -1157, 5728, 173, -1157, -1157, -1157, -1157, 10499, -1157, -1157,
3781 -1157, -1157, -1157, -1157, -1157, 11554, 11554, -1157, -1157, -1157,
3782 -1157, 6788, -1157, -1157, -1157, -1157, 565, 10345, 36, 57,
3783 -1157, -1157, -1157, -1157, 6164, 6944, -1157, -1157, 6320, -1157,
3784 -1157, -1157, -1157, -1157, -1157, -1157, -1157, 13114, 13114, 13114,
3785 13114, 179, 9258, 9416, 12034, 12274, 10800, -1157, 10191, -1157,
3786 -1157, -1157, 181, 181, 181, 181, 1367, 13234, 13114, -1157,
3787 311, -1157, -1157, 1444, -1157, -1157, -1157, -1157, -1157, 601,
3788 460, 460, -1157, -1157, 242, 377, 301, -1157, 297, 13834,
3789 -1157, 353, -1157, 2423, -1157, -1157, -1157, -1157, 372, 376,
3790 -1157, 528, -1157, 11434, 11434, -1157, -1157, 9878, 13952, 14070,
3791 14188, 10036, 11554, 7412, -1157, 677, 134, -1157, -1157, 391,
3792 -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
3793 -1157, -1157, -1157, -1157, -1157, -1157, -1157, 350, 480, -1157,
3794 413, 512, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
3795 -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
3796 -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
3797 -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
3798 -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
3799 -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
3800 -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
3801 -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
3802 363, -1157, -1157, -1157, -1157, -1157, -1157, 381, 13114, 477,
3803 9416, 13114, 13114, 13114, -1157, 13114, 460, 460, -1157, 415,
3804 4858, -1157, 474, -1157, -1157, -1157, 427, -1157, 632, 45,
3805 51, 499, 59, 458, -1157, -1157, 11674, -1157, 11554, -1157,
3806 -1157, 11175, 13354, 872, -1157, 491, -1157, 9574, -1157, -1157,
3807 -1157, -1157, -1157, 538, 242, -1157, 646, -1157, 553, 681,
3808 5978, 5978, 686, -1157, 9258, 613, 311, -1157, 1444, 36,
3809 662, -1157, -1157, 621, 548, 811, -1157, 474, 651, 811,
3810 -1157, 36, 767, 1367, 14306, 669, 669, 674, -1157, 652,
3811 694, 703, 715, -1157, -1157, 889, -1157, -1157, 1023, 1113,
3812 744, -1157, 678, 678, 678, 678, 801, -1157, -1157, -1157,
3813 -1157, -1157, -1157, -1157, 5880, 761, 11434, 11434, 11434, 11434,
3814 -1157, 13354, 13354, 1652, 782, 787, -1157, 1652, -1157, 791,
3815 -1157, -1157, -1157, -1157, 826, -1157, -1157, -1157, -1157, -1157,
3816 -1157, -1157, 9258, 10918, 793, -1157, -1157, 13114, 13114, 13114,
3817 13114, 13114, -1157, -1157, 13114, 13114, 13114, 13114, 13114, 13114,
3818 13114, 13114, -1157, 13114, -1157, -1157, 13114, 13114, 13114, 13114,
3819 13114, 13114, 13114, 13114, 13114, 13114, -1157, -1157, 4752, 11554,
3820 5125, 538, 8194, -1157, 601, -1157, 119, 119, 11434, 9106,
3821 9106, -1157, 311, 796, 897, -1157, -1157, 721, 937, 102,
3822 110, 122, 710, 965, 11434, 365, -1157, 840, 737, -1157,
3823 -1157, -1157, -1157, 125, 397, 558, 581, 630, 735, 753,
3824 755, 771, -1157, -1157, -1157, -1157, -1157, 835, -1157, -1157,
3825 11036, -1157, -1157, -1157, 14687, -1157, -1157, -1157, -1157, -1157,
3826 -1157, 359, -1157, -1157, -1157, 798, 846, 880, -1157, 13114,
3827 11794, -1157, -1157, 14785, 11554, 14883, -1157, -1157, 12154, -1157,
3828 13114, 36, -1157, 851, 36, 867, -1157, -1157, 865, 167,
3829 -1157, -1157, -1157, -1157, -1157, 10499, -1157, -1157, 13114, 874,
3830 14981, 14883, -1157, 57, 36, -1157, -1157, 5335, 878, 877,
3831 -1157, 12034, -1157, -1157, 12274, -1157, -1157, -1157, 491, 740,
3832 -1157, 888, -1157, -1157, 14306, 15079, 11554, 15177, -1157, -1157,
3833 -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
3834 1140, 246, 1230, 315, 13114, -1157, -1157, 9726, -1157, -1157,
3835 -1157, -1157, -1157, 11314, -1157, -1157, -1157, -1157, -1157, -1157,
3836 -1157, -1157, -1157, -1157, 1145, -1157, -1157, -1157, -1157, -1157,
3837 890, -1157, -1157, 893, -1157, -1157, -1157, 895, 36, -1157,
3838 -1157, -1157, 918, -1157, 898, 13114, 112, -1157, -1157, 1003,
3839 902, 1008, -1157, 13474, 8194, 311, 13474, 8194, -1157, 909,
3840 -1157, -1157, -1157, 133, 133, 12394, 36, 14306, 913, -1157,
3841 12514, -1157, 681, 2991, 2991, 2991, 2991, 3190, 2205, 2991,
3842 2991, 5978, 5978, 966, 966, -1157, 3908, 1716, 1716, 1646,
3843 53, 53, 681, 681, 681, 1703, 1703, 7568, 6476, 7880,
3844 6632, 538, -1157, 36, 916, 775, -1157, 805, -1157, 7100,
3845 -1157, -1157, 133, -1157, 8346, 1059, 8802, 206, 133, 133,
3846 1058, 1057, 142, 15275, 11554, 15373, -1157, -1157, -1157, 740,
3847 -1157, -1157, -1157, -1157, 15471, 11554, 14687, 8194, 13354, -1157,
3848 -1157, -1157, 36, -1157, -1157, -1157, 4334, 13594, 13594, 10499,
3849 -1157, 13114, 13714, 13714, 13114, -1157, 474, -1157, -1157, 458,
3850 6008, 7256, 36, 464, 473, 13114, 13114, -1157, -1157, 11914,
3851 -1157, 12154, -1157, -1157, -1157, 13354, 4858, -1157, 50, 538,
3852 538, 13594, -1157, 364, -1157, -1157, 811, 14306, 888, 554,
3853 322, 36, 72, 405, -1157, -1157, 1012, -1157, 420, -1157,
3854 181, -1157, -1157, 420, 181, -1157, 681, 952, -1157, 1145,
3855 1348, -1157, 940, 36, 958, -1157, 335, -1157, -1157, 794,
3856 -1157, 1652, -1157, -1157, 981, 13114, 1652, -1157, -1157, -1157,
3857 -1157, -1157, 1661, -1157, -1157, 565, 1073, -1157, 4858, 1075,
3858 133, -1157, 1073, 1075, 133, -1157, -1157, 971, -1157, -1157,
3859 -1157, -1157, -1157, 13114, -1157, -1157, -1157, 970, 972, 1085,
3860 -1157, -1157, 888, 14306, 1074, -1157, -1157, 1089, 1000, 4329,
3861 -1157, -1157, -1157, 747, 476, -1157, -1157, 1005, -1157, -1157,
3862 -1157, -1157, 826, 980, 824, 11794, -1157, -1157, -1157, -1157,
3863 826, -1157, 1141, -1157, 954, -1157, 1133, -1157, -1157, -1157,
3864 -1157, -1157, -1157, 12634, 133, -1157, 1058, 133, 90, 184,
3865 36, 162, 200, 11434, 311, 11434, 8194, 1179, 322, -1157,
3866 36, 133, 167, 10653, -1157, 134, 377, -1157, 4040, -1157,
3867 -1157, -1157, -1157, 13114, -1157, 565, -1157, -1157, -1157, 502,
3868 -1157, -1157, 36, 998, 167, -1157, -1157, -1157, -1157, 639,
3869 -1157, -1157, -1157, -1157, -1157, 678, -1157, 678, 678, 678,
3870 -1157, 36, -1157, 1145, -1157, 1315, -1157, -1157, 1103, 890,
3871 -1157, -1157, 1001, 1009, -1157, -1157, 1010, -1157, 1013, -1157,
3872 1001, 13474, -1157, -1157, -1157, -1157, -1157, -1157, -1157, 1015,
3873 12754, -1157, 888, 543, -1157, -1157, -1157, 15569, 11554, 15667,
3874 -1157, -1157, 13114, 13594, 13594, 1011, -1157, -1157, -1157, 13594,
3875 13594, -1157, -1157, 12874, 1133, -1157, -1157, -1157, 9106, 11434,
3876 133, -1157, -1157, 133, -1157, 13114, -1157, 199, -1157, -1157,
3877 133, -1157, 203, 206, 8194, 311, 133, -1157, -1157, -1157,
3878 -1157, -1157, -1157, 13714, 13114, 13114, -1157, 13114, 13114, -1157,
3879 12154, -1157, 1543, 5576, -1157, -1157, 1025, 1028, -1157, 1661,
3880 -1157, 1661, -1157, 1652, -1157, 1661, -1157, -1157, 1073, 1075,
3881 13114, 13114, -1157, -1157, 13114, 1030, 11314, 11314, 13594, 13114,
3882 7724, 8036, 36, 549, 618, 4610, 4610, 4858, -1157, -1157,
3883 -1157, -1157, -1157, 13594, -1157, -1157, -1157, -1157, 970, -1157,
3884 1066, -1157, 1183, -1157, -1157, 119, -1157, -1157, -1157, 12994,
3885 8498, -1157, -1157, -1157, 133, -1157, -1157, 13114, 1652, -1157,
3886 -1157, 100, 1315, 1315, 1001, 1001, 1049, 1001, 4858, 4858,
3887 1068, 1068, 1015, -1157, -1157, 4858, 624, -1157, -1157, -1157,
3888 4762, 4762, 498, -1157, 3476, 635, 1159, -1157, 1333, -1157,
3889 -1157, 33, -1157, 1078, -1157, -1157, -1157, 1064, -1157, 1067,
3890 -1157, 14615, -1157, -1157, -1157, -1157, -1157, 885, -1157, -1157,
3891 -1157, 279, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
3892 -1157, 114, -1157, -1157, -1157, 14424, 119, -1157, -1157, 9106,
3893 -1157, -1157, 8954, 8346, 13114, -1157, 352, 4610, 9106, -1157,
3894 36, 91, -1157, -1157, -1157, 1028, -1157, -1157, 1661, -1157,
3895 -1157, 1323, 9726, -1157, -1157, 8194, -1157, -1157, -1157, -1157,
3896 14615, 55, 36, 5051, -1157, 36, 1070, -1157, 1060, -1157,
3897 -1157, -1157, 1072, -1157, 11434, -1157, 1169, 5051, 14615, 14615,
3898 105, 1125, 4762, 4762, 498, 358, 17, 4610, 4610, -1157,
3899 1174, -1157, 944, 139, 183, 230, 8194, 311, -1157, 954,
3900 -1157, -1157, -1157, -1157, 119, 943, 133, 1071, 1083, -1157,
3901 9726, -1157, 1001, 890, -1157, 1088, -1157, -1157, -1157, 1094,
3902 -1157, 36, 918, 1098, 14542, 1100, -1157, -1157, -1157, 347,
3903 -1157, 1125, 1108, 1109, -1157, -1157, -1157, -1157, -1157, 36,
3904 -1157, -1157, 1110, -1157, 1112, -1157, -1157, -1157, -1157, -1157,
3905 -1157, -1157, -1157, -1157, -1157, -1157, 36, 36, 36, 36,
3906 36, 36, 240, 15765, 11554, 15863, 1141, -1157, 1183, -1157,
3907 -1157, 11434, 11434, -1157, 1457, -1157, 8194, 1081, -1157, -1157,
3908 794, -1157, 1323, -1157, 1105, 14542, 1323, -1157, -1157, 1202,
3909 961, 1763, -1157, -1157, 14615, -1157, 105, -1157, 14615, 5051,
3910 500, -1157, -1157, -1157, -1157, -1157, -1157, 250, 258, 36,
3911 273, 307, -1157, -1157, 8650, -1157, -1157, -1157, 841, -1157,
3912 -1157, 133, -1157, -1157, 890, -1157, -1157, 1114, 1115, -1157,
3913 961, 1116, 1118, -1157, 15961, 1114, 1119, 36, 1119, -1157,
3914 -1157, 393, 196, 1457, -1157, -1157, -1157, 1763, -1157, 1763,
3915 -1157, 1323, -1157, 1763, -1157, 1124, 1126, -1157, 14615, -1157,
3916 -1157, -1157, -1157, -1157, 1114, 1114, 1132, 1114, -1157, -1157,
3917 1763, -1157, -1157, 1114, -1157
3923static const yytype_int16 yydefact[] =
3925 2, 0, 0, 47, 405, 406, 407, 0, 398, 399,
3926 400, 403, 26, 26, 26, 392, 393, 394, 395, 417,
3927 418, 322, 696, 695, 697, 698, 64, 0, 64, 0,
3928 812, 700, 699, 701, 97, 99, 690, 689, 98, 691,
3929 685, 686, 687, 688, 634, 706, 707, 0, 0, 0,
3930 0, 0, 0, 0, 812, 812, 126, 489, 660, 660,
3931 662, 664, 0, 0, 0, 0, 0, 0, 0, 6,
3932 3, 8, 26, 10, 43, 49, 40, 58, 61, 46,
3933 715, 715, 70, 91, 322, 90, 0, 112, 0, 116,
3934 128, 0, 237, 79, 246, 253, 282, 283, 267, 284,
3935 397, 0, 350, 0, 0, 87, 87, 0, 0, 0,
3936 0, 0, 359, 322, 369, 94, 367, 339, 340, 633,
3937 635, 341, 342, 643, 343, 649, 345, 653, 344, 655,
3938 346, 632, 677, 678, 631, 683, 694, 702, 703, 347,
3939 0, 348, 7, 1, 205, 216, 206, 229, 202, 222,
3940 212, 211, 232, 233, 227, 210, 209, 204, 230, 234,
3941 235, 214, 203, 217, 221, 223, 215, 208, 224, 231,
3942 226, 225, 218, 228, 213, 201, 220, 219, 200, 207,
3943 198, 199, 195, 196, 197, 155, 157, 156, 190, 191,
3944 186, 168, 169, 170, 177, 174, 176, 171, 172, 192,
3945 193, 178, 179, 183, 187, 173, 175, 165, 166, 167,
3946 180, 181, 182, 184, 185, 188, 189, 194, 160, 162,
3947 33, 158, 159, 161, 401, 402, 404, 0, 786, 0,
3948 0, 333, 789, 325, 660, 0, 715, 715, 316, 0,
3949 298, 299, 328, 317, 110, 321, 812, 329, 0, 702,
3950 703, 0, 348, 812, 782, 111, 812, 507, 0, 107,
3951 65, 64, 0, 0, 28, 812, 12, 0, 11, 27,
3952 295, 392, 393, 508, 0, 261, 0, 359, 362, 262,
3953 251, 252, 356, 24, 0, 0, 3, 21, 23, 64,
3954 114, 20, 352, 0, 64, 64, 300, 0, 0, 64,
3955 780, 64, 0, 0, 0, 715, 715, 124, 396, 0,
3956 132, 133, 140, 486, 680, 0, 679, 681, 0, 0,
3957 0, 640, 644, 656, 650, 658, 684, 74, 273, 274,
3958 809, 808, 5, 810, 0, 0, 0, 0, 0, 0,
3959 812, 0, 0, 746, 0, 714, 388, 746, 712, 0,
3960 390, 408, 512, 502, 100, 514, 366, 409, 514, 498,
3961 812, 130, 0, 122, 117, 812, 77, 0, 0, 0,
3962 0, 0, 291, 292, 0, 0, 0, 0, 249, 250,
3963 0, 0, 75, 0, 289, 290, 0, 0, 0, 0,
3964 0, 0, 0, 0, 0, 0, 799, 800, 802, 812,
3965 801, 0, 0, 86, 84, 85, 0, 0, 0, 0,
3966 0, 376, 3, 4, 0, 429, 428, 0, 0, 702,
3967 703, 348, 150, 151, 0, 0, 153, 812, 0, 702,
3968 703, 348, 386, 225, 218, 228, 213, 195, 196, 197,
3969 155, 156, 778, 81, 80, 777, 776, 0, 775, 109,
3970 64, 108, 802, 801, 0, 368, 636, 812, 812, 163,
3971 785, 356, 332, 788, 324, 0, 0, 0, 812, 0,
3972 0, 318, 327, 802, 812, 801, 812, 812, 0, 319,
3973 747, 64, 312, 812, 64, 812, 311, 323, 0, 64,
3974 365, 73, 30, 32, 31, 0, 812, 296, 0, 0,
3975 802, 801, 812, 0, 64, 354, 14, 0, 113, 0,
3976 357, 807, 806, 301, 807, 303, 358, 781, 0, 139,
3977 684, 127, 119, 714, 0, 802, 812, 801, 487, 666,
3978 682, 669, 667, 661, 637, 638, 663, 639, 665, 641,
3979 0, 0, 0, 0, 0, 811, 9, 0, 34, 35,
3980 36, 37, 297, 0, 71, 72, 753, 750, 749, 748,
3981 751, 759, 760, 747, 0, 766, 761, 770, 769, 765,
3982 812, 762, 719, 812, 725, 745, 728, 731, 64, 726,
3983 752, 754, 755, 757, 731, 718, 764, 442, 441, 768,
3984 731, 772, 724, 0, 0, 0, 0, 0, 486, 0,
3985 512, 101, 486, 0, 0, 0, 64, 0, 118, 131,
3986 0, 525, 259, 266, 268, 269, 270, 277, 278, 271,
3987 272, 247, 248, 275, 276, 525, 64, 263, 264, 265,
3988 254, 255, 256, 257, 258, 293, 294, 790, 792, 791,
3989 793, 322, 505, 64, 812, 790, 792, 791, 793, 322,
3990 506, 812, 0, 420, 0, 419, 0, 0, 0, 0,
3991 0, 374, 356, 802, 812, 801, 379, 384, 150, 151,
3992 152, 708, 382, 710, 802, 812, 801, 0, 0, 797,
3993 798, 82, 64, 361, 790, 791, 322, 0, 0, 0,
3994 812, 0, 0, 0, 0, 784, 330, 326, 331, 812,
3995 790, 791, 64, 790, 791, 0, 0, 783, 306, 313,
3996 308, 315, 803, 364, 29, 0, 279, 13, 355, 0,
3997 812, 0, 25, 115, 22, 353, 64, 0, 125, 794,
3998 138, 64, 790, 791, 488, 670, 0, 642, 0, 646,
3999 0, 652, 648, 0, 0, 654, 260, 0, 38, 0,
4000 440, 432, 434, 64, 437, 430, 0, 723, 774, 0,
4001 722, 0, 741, 713, 0, 0, 0, 738, 717, 591,
4002 763, 767, 0, 743, 771, 64, 59, 62, 286, 280,
4003 0, 716, 60, 281, 0, 487, 510, 0, 487, 415,
4004 416, 511, 497, 333, 92, 93, 41, 335, 0, 45,
4005 334, 129, 123, 0, 0, 69, 48, 67, 0, 304,
4006 328, 236, 42, 0, 348, 523, 523, 0, 812, 812,
4007 512, 504, 104, 0, 509, 313, 812, 812, 310, 503,
4008 102, 309, 812, 351, 812, 421, 812, 423, 88, 422,
4009 372, 373, 412, 0, 0, 525, 0, 0, 794, 355,
4010 64, 790, 791, 0, 0, 0, 0, 150, 151, 154,
4011 64, 0, 64, 0, 360, 499, 95, 50, 304, 238,
4012 57, 245, 164, 0, 787, 64, 320, 812, 812, 509,
4013 812, 812, 64, 812, 64, 56, 244, 302, 120, 509,
4014 26, 671, 668, 675, 676, 645, 647, 657, 651, 659,
4015 39, 64, 439, 0, 756, 0, 773, 720, 764, 812,
4016 730, 729, 731, 731, 444, 727, 731, 758, 731, 755,
4017 731, 0, 812, 812, 389, 391, 488, 96, 488, 338,
4018 0, 812, 121, 356, 812, 812, 812, 802, 812, 801,
4019 524, 524, 0, 0, 0, 0, 105, 804, 812, 0,
4020 0, 103, 410, 812, 18, 623, 414, 413, 0, 0,
4021 0, 424, 426, 0, 89, 0, 516, 0, 377, 523,
4022 0, 378, 509, 0, 0, 0, 0, 509, 387, 779,
4023 83, 500, 501, 0, 0, 0, 812, 0, 0, 307,
4024 314, 363, 746, 0, 431, 433, 435, 438, 721, 0,
4025 742, 0, 739, 0, 734, 0, 736, 744, 66, 288,
4026 0, 0, 26, 26, 333, 336, 0, 0, 0, 0,
4027 790, 791, 64, 790, 791, 0, 0, 285, 54, 242,
4028 55, 243, 106, 0, 52, 240, 53, 241, 624, 625,
4029 812, 626, 812, 15, 427, 0, 370, 371, 517, 0,
4030 0, 524, 375, 380, 0, 709, 383, 0, 746, 490,
4031 493, 0, 0, 0, 731, 731, 731, 731, 63, 287,
4032 812, 812, 337, 44, 68, 305, 509, 615, 621, 587,
4033 0, 0, 0, 524, 64, 524, 575, 660, 0, 614,
4034 78, 533, 539, 541, 543, 537, 536, 571, 538, 580,
4035 583, 586, 592, 593, 582, 546, 601, 594, 547, 602,
4036 603, 604, 605, 606, 607, 608, 609, 611, 610, 612,
4037 613, 590, 76, 51, 239, 0, 0, 628, 411, 0,
4038 19, 630, 0, 0, 0, 518, 812, 0, 0, 385,
4039 64, 0, 674, 673, 672, 436, 740, 735, 0, 732,
4040 737, 478, 0, 476, 475, 0, 599, 600, 151, 619,
4041 0, 563, 64, 564, 568, 64, 0, 558, 0, 812,
4042 561, 574, 0, 616, 0, 617, 0, 534, 0, 0,
4043 581, 585, 597, 598, 0, 524, 524, 0, 0, 589,
4044 0, 627, 0, 702, 703, 348, 0, 3, 16, 812,
4045 519, 521, 522, 520, 0, 530, 0, 480, 0, 495,
4046 0, 491, 731, 812, 447, 812, 453, 474, 456, 459,
4047 479, 64, 755, 459, 446, 459, 452, 513, 515, 64,
4048 556, 578, 566, 565, 557, 569, 805, 559, 588, 64,
4049 540, 535, 571, 542, 572, 576, 660, 584, 579, 595,
4050 596, 620, 545, 555, 544, 551, 64, 64, 64, 64,
4051 64, 64, 356, 802, 812, 801, 812, 629, 812, 425,
4052 526, 0, 0, 381, 0, 492, 0, 0, 733, 451,
4053 0, 450, 0, 470, 0, 0, 454, 465, 467, 0,
4054 445, 0, 472, 562, 0, 570, 0, 618, 0, 0,
4055 0, 548, 549, 550, 552, 553, 554, 794, 355, 64,
4056 790, 791, 622, 17, 0, 531, 532, 484, 64, 482,
4057 485, 0, 494, 448, 812, 458, 457, 459, 459, 477,
4058 455, 459, 459, 356, 802, 459, 567, 64, 572, 573,
4059 577, 509, 812, 0, 481, 496, 449, 0, 471, 0,
4060 468, 0, 462, 0, 464, 794, 355, 473, 0, 560,
4061 528, 529, 527, 483, 459, 459, 459, 459, 469, 463,
4062 0, 460, 466, 459, 461
4066static const yytype_int16 yypgoto[] =
4068 -1157, -94, 1022, -1157, -1157, -1157, 957, -1157, 792, -12,
4069 -1157, -1157, -537, -1157, 165, 797, -1157, 5, -1157, -1157,
4070 15, -1157, -1157, -429, -1157, -1157, -546, 152, -564, -100,
4071 -1157, -1157, 436, 2755, -1157, 3121, -1157, 34, -1157, -1157,
4072 1194, -36, -1157, 696, -1157, -245, 1467, -10, 1195, -162,
4073 30, -425, -52, -1157, 0, 3606, -396, 1197, -48, 9,
4074 -1157, -1157, -5, -1157, -1157, 4536, -1157, -1157, -1157, -1157,
4075 -557, 1210, -1157, 280, 813, 67, -1157, 56, -1157, 551,
4076 21, 625, -373, -1157, 77, -1157, 41, -400, -236, 18,
4077 -394, -1157, -566, -35, -1157, -1157, -1157, -1157, -1157, -1157,
4078 -1157, -1157, -1157, -1157, -1157, -1157, 984, -1157, -1157, -1157,
4079 -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157, -1157,
4080 -1157, -1157, 361, -1157, -256, 1929, 2367, -372, 343, 120,
4081 -798, -1157, -832, -807, 575, 424, -406, -1157, 107, 54,
4082 -1157, -1157, 180, -1157, -1156, 47, 87, -1157, 264, -1157,
4083 -1157, 118, -1157, 2, 286, 29, -66, -1157, -1157, 260,
4084 -1157, -1157, -1157, 482, -1157, -1157, -104, -1157, -515, -1157,
4085 985, -1157, -762, -1157, -735, -829, -529, -1157, 11, -1157,
4086 -1157, -897, -183, -1157, -1157, -1157, -1157, 164, -1157, -471,
4087 -1157, -922, -630, -1035, -388, -947, -805, -1157, 174, -1157,
4088 -1157, -857, 175, -1157, -1157, -652, 182, -1157, -1157, -1157,
4089 93, -1157, -1157, 92, 449, 589, -1157, 1243, 868, 906,
4090 26, -1157, 1198, -1157, 822, -1157, 1290, -1157, -1157, 1610,
4091 -1157, 1641, -1157, -1157, -58, -1157, -1157, -206, -1157, -1157,
4092 -1157, -1157, -1157, -1157, 16, -1157, -1157, -1157, -1157, -7,
4093 -49, 3405, -1, 1254, 3833, 2743, -1157, -1157, 89, 714,
4094 38, -1157, 609, -1157, -1157, -298, -703, 608, -435, -333,
4095 -229, -1141, -443, -323, -738, 215, -409, -680, -1157, -729,
4096 -1157, -589, -1157, -455, -541, -1157, -1157, -1157, -1157, -1157,
4097 32, -398, -336, -1157, -1157, -90, 1261, 597, -528, 52,
4102static const yytype_int16 yydefgoto[] =
4104 0, 332, 69, 1, 2, 70, 71, 267, 268, 651,
4105 1132, 1268, 652, 1042, 286, 287, 503, 224, 72, 495,
4106 288, 74, 75, 76, 77, 78, 776, 488, 806, 79,
4107 625, 611, 443, 236, 863, 237, 405, 406, 408, 964,
4108 409, 82, 795, 807, 83, 601, 274, 85, 86, 289,
4109 87, 521, 88, 89, 90, 239, 426, 427, 218, 219,
4110 220, 689, 640, 222, 92, 93, 94, 95, 96, 97,
4111 779, 394, 98, 552, 498, 553, 241, 242, 293, 811,
4112 828, 829, 481, 243, 482, 258, 259, 245, 471, 644,
4113 247, 799, 800, 99, 402, 509, 846, 660, 853, 1138,
4114 856, 854, 677, 594, 597, 100, 276, 102, 103, 104,
4115 105, 106, 107, 108, 109, 110, 111, 355, 358, 953,
4116 1129, 843, 958, 959, 791, 277, 278, 654, 838, 960,
4117 961, 418, 751, 752, 753, 754, 570, 764, 765, 1214,
4118 1215, 1216, 1325, 1287, 1218, 1219, 1283, 1220, 1152, 1153,
4119 1221, 1208, 1318, 1319, 528, 734, 890, 313, 1141, 114,
4120 1059, 1211, 1276, 359, 115, 116, 356, 598, 599, 602,
4121 603, 967, 844, 1203, 940, 1025, 815, 1314, 847, 1362,
4122 1204, 1090, 1231, 1092, 1093, 1187, 1188, 1094, 1296, 1162,
4123 1163, 1164, 1096, 1097, 1244, 1166, 1098, 1099, 1100, 1101,
4124 1102, 571, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111,
4125 954, 1040, 1126, 1130, 117, 118, 119, 120, 121, 122,
4126 322, 123, 124, 540, 738, 125, 126, 542, 127, 128,
4127 129, 130, 541, 543, 315, 319, 320, 533, 736, 735,
4128 891, 993, 1144, 892, 131, 132, 316, 133, 134, 135,
4129 136, 249, 250, 139, 251, 252, 855, 672, 344, 345,
4130 346, 347, 572, 573, 574, 910, 576, 577, 762, 578,
4131 579, 580, 581, 919, 583, 584, 585, 586, 587, 588,
4132 589, 590, 591, 592, 757, 446, 447, 448, 678, 298,
4133 485, 254, 719, 642, 681, 676, 401, 490, 824, 1170,
4140static const yytype_int16 yytable[] =
4142 138, 318, 221, 404, 404, 238, 238, 404, 334, 317,
4143 314, 400, 455, 411, 595, 142, 73, 479, 225, 226,
4144 582, 308, 221, 223, 582, 453, 643, 484, 917, 670,
4145 909, 327, 760, 246, 246, 656, 264, 364, 963, 783,
4146 285, 292, 257, 223, 812, 575, 333, 253, 253, 575,
4147 782, 138, 138, 221, 308, 311, 307, 780, 911, 326,
4148 784, 515, 641, 444, 649, 517, 291, 291, 296, 300,
4149 697, 995, 294, 308, 308, 308, 698, 335, 697, 908,
4150 707, 941, 290, 333, 970, 787, 295, 299, 311, 323,
4151 324, 325, 244, 255, 348, 348, 816, -135, 997, 728,
4152 1142, 702, 238, 1095, 1095, 353, 221, 420, 430, 430,
4153 430, 297, 1026, 536, 538, -146, 707, 698, 686, 350,
4154 1209, 755, 504, 867, 870, 354, 1326, -141, 1232, 1122,
4155 246, 367, 653, 1320, 1176, -142, 783, 641, 407, 649,
4156 861, 412, 1242, 789, 253, -704, 769, -149, 769, 767,
4157 878, -705, -141, 731, 451, 773, 1176, 885, 475, 477,
4158 351, 489, 491, 1079, 770, 720, 1189, -148, 1103, 1103,
4159 349, 260, 913, 143, 879, -64, 465, 918, 262, -141,
4160 265, 805, 802, 562, -147, -142, 501, -144, 1177, 449,
4161 260, 720, 506, -149, -696, 1326, -142, 391, 392, 393,
4162 606, 790, 1320, 889, 341, 342, -135, -791, 266, -147,
4163 -578, 957, 653, 566, 1210, 1095, 1233, 1246, 285, 527,
4164 1143, 845, 1137, -696, 507, -145, -135, -135, -143, 138,
4165 -135, 995, 1245, 837, 1051, 282, 404, 404, 404, 404,
4166 1205, 554, 555, -149, 291, -137, 238, -790, 238, 479,
4167 348, 348, 522, -148, 1160, 1145, 1169, -132, 805, 805,
4168 472, 917, 333, -146, 1339, -133, 138, 472, 351, 308,
4169 486, -147, 285, 330, 483, 350, 246, -140, 859, 331,
4170 1103, 142, 73, 138, 460, 352, -144, 462, 463, 464,
4171 253, 850, 805, -141, 257, 353, 520, -139, 291, -141,
4172 911, 906, 860, 311, 906, 945, 755, 902, 404, 697,
4173 269, 697, 740, 707, 290, 698, 969, -135, 661, 976,
4174 -145, 260, 972, 1103, 404, 466, 467, 665, 308, 720,
4175 1103, 1103, 977, 138, 739, 487, 739, -142, 1201, -138,
4176 720, -791, 321, -142, 350, 1121, 1121, 1245, 792, 73,
4177 285, 1245, 1340, 330, 1049, -136, 1252, 1254, -134, 331,
4178 330, 138, 311, 608, 1009, 741, 331, 957, 998, 842,
4179 548, 549, 550, 551, 1202, 1008, 291, 1184, 932, 1028,
4180 1030, 744, 1258, 1261, -149, 1034, 1036, 1039, 333, 238,
4181 -149, -355, 290, 352, -148, 648, 833, 658, 659, 256,
4182 -148, 138, 840, 841, -146, 357, -143, -790, 138, 138,
4183 -146, 1340, -147, 486, 1066, -791, 291, 668, -147, -355,
4184 -355, 669, 650, 291, 291, 697, 1009, -144, 1156, 1157,
4185 -136, 698, 1185, -144, 745, 360, 1186, 1054, 582, 1103,
4186 238, 673, 657, 582, 567, -396, 512, 512, 1176, 648,
4187 -704, 512, 361, 518, 1165, 372, 373, 1121, 667, 690,
4188 755, -145, 755, 876, 238, 330, -695, -145, 246, 1123,
4189 648, 331, 522, -396, -396, -355, 568, 1000, 1002, -791,
4190 882, 1004, 253, 1006, -141, 1007, 529, 365, 486, 308,
4191 221, 1337, 887, -148, 1076, -695, 648, 472, -113, 472,
4192 1121, 260, 699, 59, 714, -132, 138, 1121, 1121, 384,
4193 385, 223, 260, 457, 805, 805, 238, -64, 459, -129,
4194 805, 805, 648, 311, 924, 695, 696, 682, 925, -396,
4195 1249, 1250, 896, 461, 297, 747, 698, 896, 261, -136,
4196 486, 531, 532, 726, 1360, 497, 138, -143, 917, 468,
4197 668, 1324, 138, -143, 1158, 522, 1167, 1257, 1260, -136,
4198 -136, 291, 1225, -136, 880, 1022, 529, 696, 748, 794,
4199 297, 781, 308, 881, 794, 469, 458, 946, 862, -137,
4200 -705, 321, 470, 777, 758, 951, 777, 758, 968, 805,
4201 697, 971, 707, 138, -812, 1050, 138, 396, -144, 476,
4202 908, 641, 986, 649, 805, 978, 311, -145, 291, 917,
4203 -149, 291, 458, 478, -142, 884, 1121, 343, 1228, 755,
4204 755, 531, 532, 798, 1238, 397, 398, -697, 798, 1146,
4205 1147, 1149, 1150, 839, 1230, -133, -143, 1234, 341, 342,
4206 605, 768, 834, 502, 836, 610, -149, 876, 496, 826,
4207 -698, 794, 794, 138, 238, 138, -697, 1253, 472, 1060,
4208 648, 797, 821, 831, -134, 238, 810, -140, 291, 582,
4209 291, 648, 1279, 1133, 1281, 888, 138, -148, 486, -698,
4210 582, 399, 822, -144, 221, 794, 1159, 893, -137, 486,
4211 830, 291, 308, 1328, 575, 256, 1226, 1332, 872, -700,
4212 831, 396, 260, 511, 1046, 223, 1241, 1047, -137, -137,
4213 450, -790, -137, 472, 1052, 396, 1256, 1259, 827, 260,
4214 1056, 396, 261, 939, 948, 1140, 311, 866, -700, 397,
4215 473, 1304, 1305, 1306, 831, 582, -97, 687, 688, 1321,
4216 821, 883, 1224, 397, 500, 1213, 396, 874, 694, 397,
4217 525, 522, -145, 404, 1196, 404, 705, 706, -143, 367,
4218 575, 981, 1366, -702, 895, 696, 897, 297, 308, 898,
4219 899, 505, -703, -134, 397, 452, 497, 1278, 817, -692,
4220 510, 1341, 721, 1346, -348, 474, 502, -64, 1251, 260,
4221 396, -702, -702, -134, -134, 823, -112, -134, 1139, 474,
4222 -703, -703, 311, 516, -699, 526, 396, -692, -692, -356,
4223 529, 537, -348, -348, 926, 444, 396, 928, 397, 663,
4224 -148, 915, -701, 519, -692, 906, 343, 1226, 1222, 524,
4225 974, 1226, 1270, -699, 397, 674, 1226, -356, -356, 539,
4226 -693, -139, 1091, 1091, 397, 937, 955, -702, 962, 929,
4227 962, -701, 561, -692, 823, 138, -703, 883, 221, 404,
4228 1012, -97, 1013, -692, 529, 531, 532, -97, -348, -693,
4229 291, 1224, 562, 1224, 664, 826, 1213, 1224, 512, 544,
4230 1213, 696, 1224, 823, 785, 1213, 508, 973, 788, 975,
4231 675, 1309, 1226, -356, 1226, 992, 1226, 472, 1226, 966,
4232 938, 1161, 566, 567, 679, 827, 1336, 794, 794, -144,
4233 1338, 777, 547, 794, 794, 1226, 593, 534, 1181, 531,
4234 532, -711, 691, 758, 948, 596, 492, 921, 238, 720,
4235 -135, 832, 600, 680, 648, 568, 493, 494, 1224, -145,
4236 1224, 1213, 1224, 1213, 1224, 1213, 1044, 1213, 609, 839,
4237 1273, 1055, 486, 662, 1091, 529, 545, 138, -143, 1222,
4238 -136, 1224, 666, 1222, 1213, 260, 514, 1041, 956, 957,
4239 873, 798, 291, 138, 1182, 1183, 912, 1229, 671, -134,
4240 692, 1061, 794, 1271, 1272, 101, 1015, 920, 291, 1010,
4241 1011, -98, 138, 1045, 1161, 260, 1343, 794, 1016, 248,
4242 248, 1017, 823, 1019, 1161, 1161, 709, 291, 530, 1038,
4243 531, 532, 823, 396, 693, 138, 138, 1070, 1071, 523,
4244 523, 1048, 711, 712, 1120, 1120, 717, 983, 1222, 1172,
4245 396, 1073, 1074, -129, -693, 725, 101, 101, 1136, 1175,
4246 309, 397, 1263, 727, 367, 756, 297, 683, 759, 138,
4247 761, 248, -443, 766, 1127, 771, 1131, 772, 397, 1334,
4248 774, 786, -693, -693, 291, 1345, 36, 37, 803, 39,
4249 1072, 825, 835, 309, 404, 842, 45, 46, 708, 1120,
4250 1120, 710, 845, 1120, 1154, 1154, 713, 248, 248, 529,
4251 308, 248, 417, 428, 428, 903, 248, 1264, 943, 944,
4252 1120, 723, 1265, 1267, 900, 1135, 949, 950, 389, 390,
4253 391, 392, 393, 905, 675, 914, -98, 922, -693, 923,
4254 1198, 1199, -98, 927, 1194, -328, 1206, 930, 138, 931,
4255 933, 138, 138, 934, 935, 507, 1120, 138, 529, 947,
4256 1227, 942, 534, 291, 531, 532, 291, 291, 957, 952,
4257 962, 138, 291, 990, 138, 770, 999, 984, 985, 1120,
4258 987, 988, 1120, 1032, 1001, 1003, 291, 1125, 1005, 291,
4259 -332, 404, 404, 333, 823, 763, 1120, 1120, 1120, 529,
4260 1062, 1120, 1120, 1063, 1266, -330, 1120, 1120, 1300, 308,
4261 1200, 534, 1128, 531, 532, 138, 1238, 556, 1277, 557,
4262 558, 559, 560, 801, 1148, -794, 529, 1151, 1239, 138,
4263 291, 1171, 1236, 962, 101, 1018, 1064, 1178, 1065, 1179,
4264 1067, 1077, 1180, 430, 291, 1235, 1176, 758, 1033, 758,
4265 1262, 1274, 535, 1322, 531, 532, 823, 1168, 869, 871,
4266 248, 1275, 248, 1280, 1329, 248, 248, 749, -794, 1282,
4267 308, 101, 750, 1286, 238, 1291, 869, 871, 1333, 737,
4268 648, 531, 532, 1294, 1295, 1298, 1057, 1299, 101, 1347,
4269 1349, 1351, 886, 1353, 1358, 138, -794, -794, 486, 864,
4270 955, -790, 1131, -791, 430, 1089, 1089, 1370, 309, 499,
4271 291, 546, 1207, 1120, 1197, 722, 529, 1120, 1120, 980,
4272 410, 796, 1342, 415, 724, 1315, 1316, 432, 395, 715,
4273 1288, 865, 1292, 138, 823, 1043, 1053, 823, 101, 1269,
4274 248, 248, 248, 248, 901, 248, 248, 996, 291, 1285,
4275 -794, 1217, -794, 1331, 1323, 1155, -790, 823, 758, 1284,
4276 1089, 1089, 1243, 604, 1089, 1363, 101, 309, 982, 742,
4277 904, 531, 532, 1361, 1247, 1248, 962, 1120, 1240, 1312,
4278 1313, 1089, 456, 1212, 743, 445, 1223, 556, 907, 557,
4279 558, 559, 560, 1207, 916, 556, 454, 557, 558, 559,
4280 560, 561, 0, 248, 0, 1173, 101, 36, 37, 1359,
4281 39, 0, 248, 101, 101, 0, 0, 1089, 0, 0,
4282 556, 562, 557, 558, 559, 560, 0, 0, 248, 0,
4283 0, 823, 823, 823, 1348, 1350, 0, 749, 1352, 1354,
4284 1089, 0, 1357, 1089, 886, 564, 40, 41, 42, 43,
4285 565, 566, 567, 0, 248, 1174, 0, 1089, 1089, 1089,
4286 0, 0, 1089, 1089, 0, 0, 0, 1089, 1089, 1237,
4287 0, 1368, 1369, 1371, 1372, 0, 0, 0, 248, 979,
4288 1374, 823, 0, 0, 568, 0, 0, 569, 84, 0,
4289 1344, 0, 0, 0, 1112, 1112, 0, 0, 0, 989,
4290 0, 991, 84, 84, 336, 337, 338, 339, 340, 1168,
4291 0, 101, 0, 0, 1029, 1031, 0, 1327, 994, 0,
4292 1035, 1037, 0, 0, 0, 0, 1335, 0, 309, 1317,
4293 248, 557, 558, 559, 560, 0, 0, 0, 0, 84,
4294 84, 0, 0, 0, 0, 0, 0, 0, 0, 1112,
4295 1112, 101, 0, 1112, 84, 1029, 1031, 101, 1035, 1037,
4296 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4297 1112, 0, 0, 0, 1089, 0, 0, 0, 1089, 1089,
4298 0, 0, 0, 0, 1364, 0, 1365, 0, 1367, 0,
4299 84, 84, 0, 0, 84, 0, 0, 248, 101, 84,
4300 248, 101, 0, 0, 1124, 1373, 1112, 0, 0, 248,
4301 0, 309, 0, 0, 813, 556, 0, 557, 558, 559,
4302 560, 561, 0, 0, 0, 0, 0, 0, 1124, 1112,
4303 0, 0, 1112, 0, 1113, 1113, 0, 0, 1089, 0,
4304 0, 562, 0, 0, 0, 0, 1112, 1112, 1112, 0,
4305 0, 1112, 1112, 0, 0, 563, 1112, 1112, 101, 0,
4306 101, 0, 0, 0, 0, 564, 0, 0, 248, 0,
4307 565, 566, 567, 0, 0, 0, 0, 0, 0, 248,
4308 0, 101, 248, 0, 0, 0, 0, 0, 0, 1113,
4309 1113, 813, 813, 1113, 0, 0, 0, 0, 0, 0,
4310 0, 0, 0, 0, 568, 0, 0, 569, 0, 0,
4311 1113, 0, 0, 0, 0, 0, 0, 84, 0, 248,
4312 1058, 0, 0, 0, 556, 813, 557, 558, 559, 560,
4313 561, 309, 0, 556, 0, 557, 558, 559, 560, 561,
4314 0, 0, 0, 84, 367, 84, 1113, 0, 84, 84,
4315 562, 0, 0, 0, 84, 0, 0, 0, 0, 562,
4316 0, 380, 381, 1112, 563, 0, 0, 1112, 1112, 1113,
4317 0, 84, 1113, 563, 564, 0, 0, 0, 0, 565,
4318 566, 567, 0, 564, 0, 0, 1113, 1113, 1113, 566,
4319 567, 1113, 1113, 0, 0, 0, 1113, 1113, 0, 0,
4320 0, 367, 0, 1255, 0, 0, 0, 309, 389, 390,
4321 391, 392, 393, 568, 367, 0, 569, 0, 380, 381,
4322 0, 84, 568, 84, 84, 84, 84, 1112, 84, 84,
4323 0, 380, 381, 0, 0, 556, 0, 557, 558, 559,
4324 560, 561, 0, 0, 0, 0, 1293, 0, 0, 84,
4325 0, 0, 0, 0, 0, 0, 1297, 248, 0, 248,
4326 101, 562, 386, 387, 388, 389, 390, 391, 392, 393,
4327 0, 0, 0, 1301, 1302, 1303, 0, 388, 389, 390,
4328 391, 392, 393, 0, 0, 564, 84, 0, 0, 84,
4329 0, 566, 567, 0, 0, 84, 84, 84, 0, 0,
4330 0, 0, 0, 1113, 0, 0, 0, 1113, 1113, 0,
4331 0, 84, 0, 1114, 1114, 0, 0, 0, 0, 0,
4332 0, 0, 0, 0, 568, 248, 0, 0, 0, 0,
4333 0, 0, 0, 0, 0, 0, 0, 84, 0, 0,
4334 0, 0, 248, 0, 0, 0, 0, 813, 813, 0,
4335 112, 1115, 1115, 813, 813, 0, 0, 0, 0, 0,
4336 0, 84, 101, 248, 112, 112, 0, 1113, 1114, 1114,
4337 0, 0, 1114, 0, 0, 0, 0, 0, 101, 0,
4338 0, 0, 0, 0, 0, 0, 0, 0, 0, 1114,
4339 0, 0, 0, 0, 84, 0, 0, 101, 0, 0,
4340 0, 112, 112, 0, 0, 0, 1115, 1115, 0, 0,
4341 1115, 0, 0, 84, 0, 0, 112, 0, 0, 0,
4342 101, 101, 813, 0, 0, 1114, 0, 1115, 0, 0,
4343 0, 0, 0, 0, 84, 0, 0, 813, 0, 0,
4344 84, 0, 0, 0, 0, 0, 0, 0, 1114, 0,
4345 0, 1114, 112, 112, 101, 0, 112, 0, 0, 0,
4346 0, 112, 0, 1115, 0, 1114, 1114, 1114, 0, 0,
4347 1114, 1114, 0, 0, 0, 1114, 1114, 0, 0, 0,
4348 84, 84, 0, 84, 84, 0, 1115, 0, 0, 1115,
4349 0, 0, 84, 0, 0, 0, 0, 84, 0, 0,
4350 0, 0, 0, 1115, 1115, 1115, 0, 0, 1115, 1115,
4351 0, 0, 0, 1115, 1115, 0, 0, 0, 0, 0,
4352 0, 0, 0, 0, 0, 0, 0, 0, 0, 1192,
4353 0, 0, 0, 101, 0, 0, 101, 101, 0, 0,
4354 0, 84, 101, 84, 0, 0, 0, 0, 0, 0,
4355 0, 84, 0, 0, 0, 0, 101, 0, 0, 101,
4356 0, 0, 84, 0, 84, 84, 0, 0, 0, 0,
4357 0, 0, 0, 0, 84, 84, 0, 0, 248, 112,
4358 0, 0, 1114, 0, 0, 0, 1114, 1114, 0, 0,
4359 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4360 101, 0, 84, 0, 0, 112, 0, 112, 84, 0,
4361 112, 112, 0, 0, 101, 0, 112, 0, 0, 0,
4362 1115, 0, 0, 0, 1115, 1115, 0, 0, 1290, 0,
4363 0, 0, 0, 112, 0, 0, 0, 0, 0, 0,
4364 0, 0, 0, 1116, 1116, 0, 1114, 0, 0, 0,
4365 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4366 0, 0, 0, 0, 0, 0, 0, 0, 248, 0,
4367 0, 0, 0, 0, 0, 248, 248, 0, 0, 0,
4368 101, 0, 0, 112, 1115, 112, 112, 112, 112, 1330,
4369 112, 112, 0, 0, 0, 0, 0, 0, 1116, 1116,
4370 0, 0, 1116, 367, 368, 369, 370, 371, 372, 373,
4371 374, 112, 376, 377, 0, 0, 0, 0, 101, 1116,
4372 380, 381, 0, 0, 0, 0, 0, 0, 0, 0,
4373 0, 0, 0, 0, 0, 1117, 1117, 0, 0, 0,
4374 84, 0, 84, 84, 0, 0, 0, 0, 112, 0,
4375 0, 112, 0, 0, 0, 1116, 0, 112, 112, 112,
4376 0, 0, 384, 385, 386, 387, 388, 389, 390, 391,
4377 392, 393, 0, 112, 0, 0, 0, 0, 1116, 0,
4378 0, 1116, 0, 0, 0, 0, 0, 0, 113, 0,
4379 1117, 1117, 0, 0, 1117, 1116, 1116, 1116, 0, 112,
4380 1116, 1116, 113, 113, 0, 1116, 1116, 0, 84, 0,
4381 0, 1117, 0, 0, 0, 0, 0, 0, 0, 0,
4382 0, 0, 0, 112, 0, 84, 0, 0, 0, 0,
4383 84, 84, 0, 0, 0, 0, 84, 84, 0, 113,
4384 113, 0, 0, 0, 0, 84, 84, 1117, 0, 0,
4385 0, 0, 0, 0, 113, 0, 112, 0, 0, 0,
4386 0, 84, 0, 0, 0, 0, 0, 0, 366, 0,
4387 1117, 0, 0, 1117, 0, 112, 0, 0, 0, 0,
4388 84, 0, 0, 0, 0, 0, 0, 1117, 1117, 1117,
4389 113, 113, 1117, 1117, 113, 0, 112, 1117, 1117, 113,
4390 0, 0, 112, 84, 84, 84, 0, 0, 0, 0,
4391 0, 0, 1116, 0, 0, 0, 1116, 1116, 0, 0,
4392 84, 367, 368, 369, 370, 371, 372, 373, 374, 375,
4393 376, 377, 378, 379, 0, 0, 0, 84, 380, 381,
4394 0, 0, 112, 112, 382, 112, 112, 0, 0, 0,
4395 0, 0, 0, 0, 112, 0, 0, 0, 0, 112,
4396 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4397 0, 0, 0, 0, 0, 0, 1116, 0, 383, 0,
4398 384, 385, 386, 387, 388, 389, 390, 391, 392, 393,
4399 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4400 0, 0, 0, 112, 1117, 112, 0, 0, 1117, 1117,
4401 0, 0, 0, 112, 0, 0, 84, 113, 0, 84,
4402 84, 0, 0, 0, 112, 84, 112, 112, 0, 0,
4403 0, 0, 0, 0, 0, 0, 112, 112, 0, 84,
4404 0, 0, 84, 113, 0, 113, 0, 0, 113, 113,
4405 0, 0, 0, 0, 113, 1118, 1118, 0, 0, 0,
4406 0, 84, 0, 0, 112, 0, 0, 0, 1117, 0,
4407 112, 113, 0, 0, 0, 0, 0, 0, 0, 0,
4408 0, 0, 0, 84, 0, 0, 1119, 1119, 0, 0,
4409 0, 0, 0, 0, 0, 0, 0, 84, 0, 0,
4410 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4411 1118, 1118, 0, 0, 1118, 0, 0, 0, 0, 0,
4412 0, 113, 0, 113, 113, 113, 113, 0, 113, 113,
4413 0, 1118, 0, 0, 0, 0, 0, 0, 0, 0,
4414 0, 1119, 1119, 0, 0, 1119, 0, 0, 0, 113,
4415 0, 84, 0, 0, 0, 0, 0, 0, 84, 84,
4416 0, 0, 1119, 84, 141, 0, 0, 1118, 0, 0,
4417 0, 0, 0, 0, 0, 0, 80, 0, 0, 0,
4418 0, 0, 0, 0, 0, 0, 113, 0, 0, 113,
4419 1118, 0, 0, 1118, 0, 113, 113, 113, 1119, 0,
4420 0, 84, 112, 0, 112, 112, 0, 1118, 1118, 1118,
4421 0, 113, 1118, 1118, 0, 141, 141, 1118, 1118, 312,
4422 0, 1119, 0, 0, 1119, 0, 0, 80, 80, 0,
4423 0, 305, 0, 0, 0, 0, 0, 113, 1119, 1119,
4424 1119, 0, 0, 1119, 1119, 0, 0, 0, 1119, 1119,
4425 0, 0, 312, 0, 0, 0, 0, 0, 0, 0,
4426 0, 113, 0, 0, 305, 0, 0, 0, 0, 0,
4427 112, 421, 431, 431, 0, 0, 0, 0, 0, 0,
4428 0, 0, 0, 305, 305, 305, 0, 112, 0, 0,
4429 0, 0, 112, 112, 113, 0, 0, 0, 112, 112,
4430 0, 0, 0, 0, 0, 0, 0, 112, 112, 0,
4431 0, 0, 0, 113, 0, 0, 0, 0, 0, 0,
4432 0, 0, 0, 112, 1118, 0, 0, 0, 1118, 1118,
4433 0, 0, 0, 0, 113, 0, 0, 0, 0, 0,
4434 113, 0, 112, 0, 0, 0, 0, 0, 0, 0,
4435 0, 0, 0, 0, 0, 1119, 0, 0, 0, 1119,
4436 1119, 0, 0, 0, 0, 112, 112, 112, 0, 0,
4437 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4438 113, 113, 112, 113, 113, 0, 0, 0, 1118, 0,
4439 0, 0, 113, 141, 0, 0, 0, 113, 0, 112,
4440 0, 0, 0, 0, 0, 80, 0, 0, 0, 0,
4441 0, 0, 0, 0, 0, 0, 0, 0, 0, 1119,
4442 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4443 141, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4444 0, 113, 80, 113, 0, 0, 0, 141, 0, 0,
4445 0, 113, 0, 0, 0, 0, 0, 0, 0, 80,
4446 0, 0, 113, 0, 113, 113, 0, 312, 0, 0,
4447 0, 0, 0, 0, 113, 113, 0, 0, 112, 305,
4448 0, 112, 112, 0, 0, 0, 0, 112, 0, 367,
4449 -813, -813, -813, -813, 372, 373, 0, 141, -813, -813,
4450 0, 112, 113, 0, 112, 0, 380, 381, 113, 80,
4451 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4452 0, 0, 0, 112, 0, 141, 312, 0, 0, 0,
4453 0, 0, 0, 0, 0, 0, 0, 80, 305, 0,
4454 0, 0, 81, 0, 0, 112, 0, 0, 384, 385,
4455 386, 387, 388, 389, 390, 391, 392, 393, 0, 112,
4456 0, 0, 0, 0, 0, 141, 0, 0, 0, 0,
4457 0, 0, 141, 141, 0, 0, 0, 80, 0, 0,
4458 0, 0, 0, 0, 80, 80, 0, 0, 0, 0,
4459 0, 0, 0, 81, 81, 0, 0, 306, 0, 0,
4460 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4461 0, 0, 0, 112, 0, 0, 0, 0, 0, 0,
4462 112, 112, 0, 0, 0, 112, 0, 0, 0, 0,
4463 306, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4464 113, 0, 113, 113, 0, 0, 0, 0, 0, 306,
4465 306, 306, 0, 0, 0, 0, 0, 0, 0, 0,
4466 0, 0, 0, 112, 0, 0, 0, 0, 0, 0,
4467 141, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4468 0, 0, 80, 0, 0, 0, 0, 312, 367, 368,
4469 369, 370, 371, 372, 373, 0, 0, 376, 377, 305,
4470 0, 0, 0, 0, 0, 380, 381, 0, 113, 0,
4471 141, 0, 0, 0, 0, 0, 141, 0, 0, 0,
4472 0, 0, 80, 0, 0, 113, 0, 0, 80, 0,
4473 113, 113, 0, 0, 0, 0, 113, 113, 0, 0,
4474 0, 0, 0, 0, 0, 113, 113, 384, 385, 386,
4475 387, 388, 389, 390, 391, 392, 393, 141, 0, 0,
4476 141, 113, 0, 0, 0, 0, 0, 0, 0, 80,
4477 312, 81, 80, 814, 0, 0, 0, 0, 0, 0,
4478 113, 0, 305, 0, 0, 80, 0, 0, 0, 0,
4479 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4480 0, 0, 0, 113, 113, 113, 0, 0, 81, 0,
4481 0, 0, 0, 0, 0, 0, 0, 141, 0, 141,
4482 113, 0, 0, 0, 0, 81, 137, 0, 0, 80,
4483 0, 80, 0, 0, 0, 0, 0, 113, 0, 0,
4484 141, 0, 0, 0, 0, 306, 0, 0, 0, 0,
4485 814, 814, 80, 0, 0, 0, 0, 0, 0, 0,
4486 0, 0, 80, 80, 0, 0, 0, 0, 0, 0,
4487 0, 0, 0, 0, 0, 81, 0, 137, 137, 0,
4488 0, 310, 0, 0, 814, 0, 0, 0, 0, 0,
4489 312, 0, 0, 0, 0, 0, 80, 0, 0, 894,
4490 0, 0, 305, 81, 306, 0, 0, 0, 0, 0,
4491 0, 0, 0, 0, 310, 0, 113, 0, 0, 113,
4492 113, 0, 0, 0, 0, 113, 0, 0, 0, 22,
4493 23, 24, 25, 419, 429, 429, 429, 0, 0, 113,
4494 0, 0, 113, 81, 0, 31, 32, 33, 1077, 0,
4495 81, 81, 1078, 0, 0, 40, 41, 42, 43, 44,
4496 0, 113, 0, 0, 0, 0, 312, 0, 0, 0,
4497 0, 0, 0, 0, 0, 0, 0, 0, 305, 0,
4498 0, 0, 0, 113, 0, 0, 0, 1080, 1081, 0,
4499 0, 0, 0, 0, 0, 1082, 0, 113, 1083, 0,
4500 1084, 1085, 0, 1086, 0, 0, 57, 58, 59, 60,
4501 61, 62, 63, 64, 65, 0, 0, 0, 0, 141,
4502 0, 0, 0, 0, 0, 0, 0, 91, 0, 0,
4503 0, 80, 0, 0, 0, 0, 1088, 0, 0, 0,
4504 0, 0, 0, 303, 0, 0, 0, 0, 81, 0,
4505 260, 113, 0, 0, 0, 137, 0, 0, 113, 113,
4506 0, 0, 0, 113, 0, 306, 0, 0, 0, 0,
4507 0, 0, 0, 0, 0, 0, 0, 0, 91, 91,
4508 0, 0, 0, 0, 0, 0, 0, 0, 81, 0,
4509 0, 0, 137, 0, 81, 0, 0, 0, 0, 0,
4510 0, 113, 0, 0, 0, 0, 814, 814, 0, 137,
4511 0, 0, 814, 814, 0, 0, 0, 0, 80, 80,
4512 0, 141, 0, 0, 80, 80, 0, 0, 0, 310,
4513 0, 0, 0, 80, 416, 81, 0, 141, 81, 0,
4514 0, 0, 0, 0, 0, 0, 0, 0, 306, 80,
4515 0, 81, 0, 0, 0, 0, 141, 0, 0, 137,
4516 0, 0, 0, 0, 0, 0, 0, 0, 80, 0,
4517 0, 0, 0, 0, 0, 0, 0, 0, 0, 141,
4518 141, 814, 0, 0, 0, 0, 0, 137, 310, 0,
4519 0, 80, 80, 80, 0, 81, 814, 81, 0, 0,
4520 0, 0, 0, 0, 0, 0, 0, 0, 80, 0,
4521 0, 0, 0, 141, 0, 0, 0, 0, 81, 0,
4522 0, 0, 0, 0, 0, 80, 0, 137, 81, 81,
4523 0, 0, 0, 0, 137, 137, 0, 0, 0, 0,
4524 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4525 0, 0, 0, 0, 140, 0, 91, 0, 0, 0,
4526 0, 0, 81, 0, 0, 0, 0, 0, 306, 0,
4527 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4528 0, 0, 0, 0, 0, 0, 0, 0, 1195, 0,
4529 0, 0, 141, 91, 0, 141, 141, 0, 0, 0,
4530 305, 141, 0, 0, 80, 140, 140, 80, 80, 0,
4531 91, 0, 0, 80, 0, 141, 0, 0, 141, 0,
4532 0, 0, 0, 0, 0, 0, 0, 80, 0, 0,
4533 80, 0, 137, 0, 0, 0, 0, 0, 0, 0,
4534 0, 0, 0, 0, 306, 0, 0, 0, 0, 310,
4535 0, 0, 0, 0, 0, 0, 0, 0, 0, 141,
4536 91, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4537 0, 80, 137, 141, 0, 0, 0, 0, 137, 0,
4538 0, 0, 0, 0, 0, 80, 0, 431, 91, 0,
4539 0, 0, 0, 0, 0, 0, 0, 81, 0, 305,
4540 0, 0, 0, 0, 0, 0, 367, 368, 369, 370,
4541 371, 372, 373, 374, 375, 376, 377, 378, 379, 137,
4542 0, 0, 137, 380, 381, 0, 0, 0, 91, 0,
4543 0, 0, 310, 0, 0, 91, 91, 0, 0, 141,
4544 0, 0, 0, 0, 0, 0, 0, 0, 431, 0,
4545 0, 80, 0, 0, 0, 0, 0, 0, 0, 0,
4546 305, 0, 0, 383, 0, 384, 385, 386, 387, 388,
4547 389, 390, 391, 392, 393, 0, 0, 141, 0, 137,
4548 0, 137, 260, 140, 81, 81, 0, 0, 0, 80,
4549 81, 81, 0, 0, 0, 0, 0, 0, 0, 81,
4550 0, 0, 137, 0, 936, 0, 0, 0, 0, 0,
4551 0, 0, 0, 0, 0, 81, 0, 0, 0, 0,
4552 140, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4553 0, 0, 0, 91, 81, 0, 0, 140, 367, 368,
4554 369, 370, 371, 372, 373, 374, 375, 376, 377, 378,
4555 379, 0, 310, 0, 0, 380, 381, 81, 81, 81,
4556 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4557 0, 0, 0, 91, 81, 0, 0, 0, 0, 91,
4558 0, 0, 0, 0, 0, 0, 0, 140, 0, 0,
4559 0, 81, 0, 0, 0, 383, 0, 384, 385, 386,
4560 387, 388, 389, 390, 391, 392, 393, 0, 0, 0,
4561 0, 0, 0, 0, 0, 140, 0, 0, 0, 0,
4562 91, 0, 0, 91, 0, 0, 0, 0, 310, 0,
4563 0, 0, 0, 0, 0, 0, 808, 0, 0, 0,
4564 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4565 0, 0, 0, 0, 0, 140, 0, 0, 0, 0,
4566 0, 0, 140, 140, 0, 0, 306, 0, 0, 0,
4567 81, 0, 0, 81, 81, 0, 0, 0, 0, 81,
4568 91, 137, 91, 0, 0, 0, 0, 0, 0, 0,
4569 0, 0, 0, 81, 0, 0, 81, 0, 0, 0,
4570 0, 0, 0, 91, 0, 0, 0, 0, 0, 0,
4571 0, 0, 0, 808, 808, 0, 0, 0, 0, 0,
4572 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4573 0, 0, 0, 0, 0, 0, 0, 81, 0, 0,
4574 0, 0, 0, 0, 0, 0, 0, 808, 0, 0,
4575 0, 81, 0, 0, -812, 0, 0, 0, 0, 0,
4576 140, 0, -812, -812, -812, 306, 0, -812, -812, -812,
4577 0, -812, 0, 0, 0, 0, 0, 0, 0, -812,
4578 -812, -812, 0, 137, 0, 0, 0, 0, 0, 0,
4579 0, -812, -812, 936, -812, -812, -812, -812, -812, 137,
4580 140, 0, 0, 0, 0, 0, 140, 0, 0, 0,
4581 0, 0, 0, 0, 0, 0, 0, 81, 137, 0,
4582 0, 0, -812, -812, 0, 0, 306, 367, 368, 369,
4583 370, 371, 372, 373, 374, 375, 376, 377, 378, 379,
4584 0, 137, 137, 0, 380, 381, 0, 140, 0, 0,
4585 140, -812, -812, 0, 0, 81, 0, 0, 0, 0,
4586 0, 0, 0, 140, 0, 0, 0, 0, 0, 0,
4587 0, 0, 0, 0, -812, 137, 0, 0, 0, 0,
4588 0, 0, 91, 0, 383, 0, 384, 385, 386, 387,
4589 388, 389, 390, 391, 392, 393, 0, 0, 0, 0,
4590 0, 0, 0, 0, -298, -812, -812, 140, -812, 140,
4591 0, 256, -812, 0, -812, 0, 0, 0, 0, 0,
4592 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4593 140, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4594 140, 140, 0, 0, 0, 0, 0, 0, 0, 0,
4595 1193, 0, 0, 0, 137, 0, 0, 137, 137, 0,
4596 0, 0, 0, 137, 0, 0, 0, 0, 0, 808,
4597 808, 240, 240, 0, 140, 808, 808, 137, 0, 0,
4598 137, 0, 0, 0, 91, 0, 0, 0, 0, 0,
4599 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4600 91, 0, 0, 275, 279, 280, 281, 0, 0, 0,
4601 240, 240, 0, 0, 0, 0, 0, 0, 0, 91,
4602 0, 137, 0, 328, 329, 0, 0, 0, 0, 0,
4603 0, 0, 0, 0, 0, 137, 0, 0, 0, 0,
4604 0, 0, 91, 91, 808, 0, 0, 0, 0, 429,
4605 0, 0, 0, 0, 0, 0, 0, 0, 0, 808,
4606 0, 0, 0, 22, 23, 24, 25, 0, 240, 0,
4607 0, 0, 0, 0, 0, 0, 91, 0, 0, 31,
4608 32, 33, 1077, 0, 0, 0, 1078, 0, 1079, 40,
4609 41, 42, 43, 44, 0, 0, 0, 0, 0, 0,
4610 0, 137, 0, 0, 0, 0, 0, 0, 562, 140,
4611 429, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4612 0, 1080, 1081, 0, 0, 0, 0, 0, 0, 1082,
4613 0, 0, 1083, 0, 1084, 1085, 0, 1086, 566, 137,
4614 57, 58, 1087, 60, 61, 62, 63, 64, 65, 0,
4615 0, 1191, 0, 0, 0, 91, 0, 0, 91, 91,
4616 0, 0, 0, 0, 91, 0, 0, 0, 0, 0,
4617 1088, 0, 0, 0, 0, 0, 0, 303, 91, 0,
4618 0, 91, 0, 0, 240, 0, 0, 240, 240, 240,
4619 0, 328, 0, 0, 0, 0, 140, 140, 0, 0,
4620 0, 0, 140, 140, 0, 0, 0, 0, 0, 0,
4621 0, 140, 240, 0, 240, 22, 23, 24, 25, 0,
4622 0, 0, 91, 0, 637, 638, 0, 140, 639, 0,
4623 0, 31, 32, 33, 0, 0, 91, 0, 0, 0,
4624 0, 40, 41, 42, 43, 44, 140, 0, 188, 189,
4625 190, 191, 192, 193, 194, 195, 196, 0, 0, 197,
4626 198, 0, 0, 0, 0, 199, 200, 201, 202, 140,
4627 140, 140, 0, 0, 0, 0, 0, 0, 0, 203,
4628 204, 0, 0, 0, 0, 0, 140, 0, 0, 0,
4629 0, 0, 57, 58, 59, 60, 61, 62, 63, 64,
4630 65, 0, 91, 140, 0, 0, 0, 0, 0, 205,
4631 206, 207, 208, 209, 210, 211, 212, 213, 214, 0,
4632 215, 216, 0, 612, 613, 614, 615, 616, 217, 303,
4633 617, 618, 619, 620, 621, 622, 623, 624, 0, 626,
4634 91, 0, 627, 628, 629, 630, 631, 632, 633, 634,
4635 635, 636, 0, 0, 0, 240, 367, 368, 369, 370,
4636 371, 372, 373, 374, 375, 376, 377, 378, 379, 0,
4637 0, 0, 0, 380, 381, 0, 0, 0, 0, 0,
4638 0, 0, 140, 0, 0, 140, 140, 0, 0, 0,
4639 0, 140, 0, 0, 0, 0, 0, 0, 0, 0,
4640 0, 0, 0, 0, 0, 140, 240, 0, 140, 0,
4641 0, 0, 0, 383, 0, 384, 385, 386, 387, 388,
4642 389, 390, 391, 392, 393, 240, 240, 0, 0, 0,
4643 240, 0, 0, 0, 240, 0, 281, 0, 0, 0,
4644 0, 0, 0, 0, 0, 0, 0, 0, 0, 140,
4645 0, 0, 0, 0, 716, 0, 0, 0, 0, 0,
4646 0, 0, 0, 140, 0, 0, 0, 240, 0, 0,
4647 240, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4648 0, 0, 240, 0, 0, 0, 0, 0, 0, 0,
4649 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4650 746, 0, 0, 0, 22, 23, 24, 25, 0, 0,
4651 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4652 31, 32, 33, 1077, 0, 0, 0, 1078, 0, 140,
4653 40, 41, 42, 43, 44, 0, 0, 0, 0, 0,
4654 0, 240, 0, 0, 0, 0, 0, 0, 0, 778,
4655 0, 0, 778, 0, 0, 0, 0, 0, 0, 0,
4656 0, 240, 1080, 1081, 0, 0, 809, 140, 0, 0,
4657 1082, 0, 0, 1083, 0, 1084, 1085, 0, 1086, 0,
4658 0, 57, 58, 59, 60, 61, 62, 63, 64, 65,
4659 0, 0, 0, 0, 0, 0, 0, 645, 646, 0,
4660 0, 647, 0, 0, 0, 0, 0, 0, 0, 0,
4661 0, 1088, 0, 0, 0, 0, 0, 0, 303, 0,
4662 240, 188, 189, 190, 191, 192, 193, 194, 195, 196,
4663 0, 240, 197, 198, 0, 0, 0, 0, 199, 200,
4664 201, 202, 0, 868, 868, 0, 0, 240, 778, 778,
4665 868, 0, 203, 204, 0, 0, 0, 0, 0, 0,
4666 0, 868, 868, 0, 0, 240, 0, 240, 0, 0,
4667 0, 0, 0, 0, 0, 0, 0, 868, 0, 0,
4668 0, 0, 205, 206, 207, 208, 209, 210, 211, 212,
4669 213, 214, 0, 215, 216, 0, 0, 0, 0, 0,
4670 0, 217, 0, 0, 0, 0, 0, 0, 0, 0,
4671 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4672 0, 240, 0, 0, 0, 0, 0, 0, 0, 0,
4673 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4674 0, 0, 0, 0, 0, 0, 0, 0, 0, 240,
4675 0, 0, 0, 0, 0, -4, 3, 0, 4, 5,
4676 6, 7, 8, -4, -4, -4, 9, 10, 0, -4,
4677 -4, 11, -4, 12, 13, 14, 15, 16, 17, 18,
4678 -4, 240, 0, 0, 0, 19, 20, 21, 22, 23,
4679 24, 25, 0, 0, 26, 0, 0, 0, 0, 240,
4680 27, 28, 283, 30, 31, 32, 33, 34, 35, 36,
4681 37, 38, 39, 0, 40, 41, 42, 43, 44, 45,
4682 46, 0, 0, -4, 0, 0, 0, 0, 0, 868,
4683 0, 47, 48, 0, 0, 0, 0, 0, 0, 0,
4684 0, 0, 0, 0, 0, 0, 49, 50, 0, 0,
4685 0, 0, 0, 0, 51, 0, 0, 52, 53, 54,
4686 55, 0, 56, 0, 0, 57, 58, 59, 60, 61,
4687 62, 63, 64, 65, 0, -4, 0, 778, 0, 0,
4688 0, 0, 0, 0, 0, 0, 240, 0, 0, 0,
4689 0, 0, 0, 0, 240, 0, 0, 0, 1027, 868,
4690 868, 0, 66, 67, 68, 868, 868, -4, 0, 240,
4691 0, 0, 0, -4, 0, 545, 0, 0, 0, 0,
4692 0, 240, 0, 0, 0, 0, 0, 0, 0, 0,
4693 0, 0, 0, 0, 0, 0, 0, 0, 0, 778,
4694 868, 868, 0, 868, 868, 0, 240, 0, 0, 0,
4695 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4696 0, 0, 0, 0, 0, 0, 1068, 1069, 0, 0,
4697 240, 0, 0, 0, 868, 1075, 0, 0, 0, 0,
4698 0, 0, 0, 0, 0, 0, 0, 0, 0, 868,
4699 0, 0, 0, 0, 0, 0, -812, 3, 0, 4,
4700 5, 6, 7, 8, 0, 240, 0, 9, 10, 0,
4701 0, 0, 11, 868, 12, 13, 14, 15, 16, 17,
4702 18, 0, 0, 0, 0, 0, 19, 20, 21, 22,
4703 23, 24, 25, 0, 0, 26, 0, 0, 0, 0,
4704 0, 27, 28, 283, 30, 31, 32, 33, 34, 35,
4705 36, 37, 38, 39, 0, 40, 41, 42, 43, 44,
4706 45, 46, 0, 0, 0, 0, 0, 0, 0, 0,
4707 0, 0, 47, 48, 0, 0, 0, 0, 0, 0,
4708 0, 0, 0, 0, 0, 0, 0, 49, 50, 0,
4709 240, 0, 0, 0, 0, 51, 0, 0, 52, 53,
4710 54, 55, 0, 56, 0, 0, 57, 58, 59, 60,
4711 61, 62, 63, 64, 65, 0, -812, 0, 0, 0,
4712 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4713 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4714 0, 0, 0, 66, 67, 68, 0, 0, -812, 3,
4715 -812, 4, 5, 6, 7, 8, -812, 0, 0, 9,
4716 10, 0, 0, 0, 11, 0, 12, 13, 14, 15,
4717 16, 17, 18, 0, 0, 0, 0, 0, 19, 20,
4718 21, 22, 23, 24, 25, 0, 0, 26, 0, 0,
4719 0, 0, 0, 27, 28, 29, 30, 31, 32, 33,
4720 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
4721 43, 44, 45, 46, 0, 0, 0, 0, 0, 0,
4722 240, 0, 0, 0, 47, 48, 0, 0, 0, 0,
4723 0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
4724 50, 0, 0, 0, 0, 0, 0, 51, 0, 0,
4725 52, 53, 54, 55, 0, 56, 0, 0, 57, 58,
4726 59, 60, 61, 62, 63, 64, 65, 0, 0, 0,
4727 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4728 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4729 0, 0, 0, 0, 0, 66, 67, 68, 0, 0,
4730 -4, 3, -812, 4, 5, 6, 7, 8, -812, 0,
4731 0, 9, 10, 0, 0, 0, 11, 0, 12, 13,
4732 14, 15, 16, 17, 18, 0, 0, 0, 0, 0,
4733 19, 20, 21, 22, 23, 24, 25, 0, 0, 26,
4734 0, 0, 0, 0, 0, 27, 28, 29, 30, 31,
4735 32, 33, 34, 35, 36, 37, 38, 39, 0, 40,
4736 41, 42, 43, 44, 45, 46, 0, 0, 0, 0,
4737 0, 0, 0, 0, 0, 0, 47, 48, 0, 0,
4738 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4739 0, 49, 50, 0, 0, 0, 0, 0, 0, 51,
4740 0, 0, 52, 53, 54, 55, 0, 56, 0, 0,
4741 57, 58, 59, 60, 61, 62, 63, 64, 65, 0,
4742 0, 0, 0, 0, 0, 0, 0, 0, -794, 0,
4743 0, 0, 0, 0, 0, 0, -794, -794, -794, 0,
4744 0, -794, -794, -794, 0, -794, 0, 66, 67, 68,
4745 0, 0, -4, -794, -794, -794, -794, -794, 0, 0,
4746 545, 0, 0, 0, 0, -794, -794, 0, -794, -794,
4747 -794, -794, -794, 0, 0, 0, 367, 368, 369, 370,
4748 371, 372, 373, 374, 375, 376, 377, -813, -813, 0,
4749 0, 0, 0, 380, 381, 0, -794, -794, 0, 0,
4750 0, 0, 0, 0, 0, 0, -794, -794, -794, -794,
4751 -794, -794, -794, -794, -794, -794, -794, -794, -794, 0,
4752 0, 0, 0, -794, -794, -794, -794, 0, 877, -794,
4753 0, 0, 0, 0, -794, 384, 385, 386, 387, 388,
4754 389, 390, 391, 392, 393, 0, 0, 0, -794, 0,
4755 0, -794, 0, 0, 0, 0, 0, 0, 0, 0,
4756 0, 0, -146, -794, -794, -794, -794, -794, -794, -794,
4757 -794, -794, -794, -794, -794, 0, 0, 0, 0, -794,
4758 -794, -794, -794, -794, -692, 0, -794, -794, -794, 0,
4759 0, 0, -692, -692, -692, 0, 0, -692, -692, -692,
4760 0, -692, 0, 0, 0, 0, 0, 0, 0, -692,
4761 0, -692, -692, -692, 0, 0, 0, 0, 0, 0,
4762 0, -692, -692, 0, -692, -692, -692, -692, -692, 0,
4763 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4764 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4765 0, 0, -692, -692, 0, 0, 0, 0, 0, 0,
4766 0, 0, -692, -692, -692, -692, -692, -692, -692, -692,
4767 -692, -692, -692, -692, -692, 0, 0, 0, 0, -692,
4768 -692, -692, -692, 0, -692, -692, 0, 0, 0, 0,
4769 -692, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4770 0, 0, 0, 0, -692, 0, 0, -692, 0, 0,
4771 0, 0, 0, 0, 0, 0, 0, 0, -692, -692,
4772 -692, -692, -692, -692, -692, -692, -692, -692, -692, -692,
4773 -692, 0, 0, 0, 0, 0, -692, -692, -692, -692,
4774 -693, 0, -692, -692, -692, 0, 0, 0, -693, -693,
4775 -693, 0, 0, -693, -693, -693, 0, -693, 0, 0,
4776 0, 0, 0, 0, 0, -693, 0, -693, -693, -693,
4777 0, 0, 0, 0, 0, 0, 0, -693, -693, 0,
4778 -693, -693, -693, -693, -693, 0, 0, 0, 0, 0,
4779 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4780 0, 0, 0, 0, 0, 0, 0, 0, -693, -693,
4781 0, 0, 0, 0, 0, 0, 0, 0, -693, -693,
4782 -693, -693, -693, -693, -693, -693, -693, -693, -693, -693,
4783 -693, 0, 0, 0, 0, -693, -693, -693, -693, 0,
4784 -693, -693, 0, 0, 0, 0, -693, 0, 0, 0,
4785 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4786 -693, 0, 0, -693, 0, 0, 0, 0, 0, 0,
4787 0, 0, 0, 0, -693, -693, -693, -693, -693, -693,
4788 -693, -693, -693, -693, -693, -693, -693, 0, 0, 0,
4789 0, 0, -693, -693, -693, -693, -795, 0, -693, -693,
4790 -693, 0, 0, 0, -795, -795, -795, 0, 0, -795,
4791 -795, -795, 0, -795, 0, 0, 0, 0, 0, 0,
4792 0, -795, -795, -795, -795, -795, 0, 0, 0, 0,
4793 0, 0, 0, -795, -795, 0, -795, -795, -795, -795,
4794 -795, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4795 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4796 0, 0, 0, 0, -795, -795, 0, 0, 0, 0,
4797 0, 0, 0, 0, -795, -795, -795, -795, -795, -795,
4798 -795, -795, -795, -795, -795, -795, -795, 0, 0, 0,
4799 0, -795, -795, -795, -795, 0, 0, -795, 0, 0,
4800 0, 0, -795, 0, 0, 0, 0, 0, 0, 0,
4801 0, 0, 0, 0, 0, 0, -795, 0, 0, -795,
4802 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4803 0, -795, -795, -795, -795, -795, -795, -795, -795, -795,
4804 -795, -795, -795, 0, 0, 0, 0, -795, -795, -795,
4805 -795, -795, -796, 0, -795, -795, -795, 0, 0, 0,
4806 -796, -796, -796, 0, 0, -796, -796, -796, 0, -796,
4807 0, 0, 0, 0, 0, 0, 0, -796, -796, -796,
4808 -796, -796, 0, 0, 0, 0, 0, 0, 0, -796,
4809 -796, 0, -796, -796, -796, -796, -796, 0, 0, 0,
4810 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4811 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4812 -796, -796, 0, 0, 0, 0, 0, 0, 0, 0,
4813 -796, -796, -796, -796, -796, -796, -796, -796, -796, -796,
4814 -796, -796, -796, 0, 0, 0, 0, -796, -796, -796,
4815 -796, 0, 0, -796, 0, 0, 0, 0, -796, 0,
4816 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4817 0, 0, -796, 0, 0, -796, 0, 0, 0, 0,
4818 0, 0, 0, 0, 0, 0, 0, -796, -796, -796,
4819 -796, -796, -796, -796, -796, -796, -796, -796, -796, 0,
4820 0, 0, 0, -796, -796, -796, -796, -796, -508, 0,
4821 -796, -796, -796, 0, 0, 0, -508, -508, -508, 0,
4822 0, -508, -508, -508, 0, -508, 0, 0, 0, 0,
4823 0, 0, 0, -508, -508, -508, -508, 0, 0, 0,
4824 0, 0, 0, 0, 0, -508, -508, 0, -508, -508,
4825 -508, -508, -508, 0, 0, 0, 0, 0, 0, 0,
4826 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4827 0, 0, 0, 0, 0, 0, -508, -508, 0, 0,
4828 0, 0, 0, 0, 0, 0, -508, -508, -508, -508,
4829 -508, -508, -508, -508, -508, -508, -508, -508, -508, 0,
4830 0, 0, 0, -508, -508, -508, -508, 0, 0, -508,
4831 0, 0, 0, 0, -508, 0, 0, 0, 0, 0,
4832 0, 0, 0, 0, 0, 0, 0, 0, -508, 0,
4833 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4834 0, 0, 0, -508, 0, -508, -508, -508, -508, -508,
4835 -508, -508, -508, -508, -508, 0, 0, 0, 0, -508,
4836 -508, -508, -508, -508, -349, 256, -508, -508, -508, 0,
4837 0, 0, -349, -349, -349, 0, 0, -349, -349, -349,
4838 0, -349, 0, 0, 0, 0, 0, 0, 0, -349,
4839 0, -349, -349, -349, 0, 0, 0, 0, 0, 0,
4840 0, -349, -349, 0, -349, -349, -349, -349, -349, 0,
4841 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4842 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4843 0, 0, -349, -349, 0, 0, 0, 0, 0, 0,
4844 0, 0, -349, -349, -349, -349, -349, -349, -349, -349,
4845 -349, -349, -349, -349, -349, 0, 0, 0, 0, -349,
4846 -349, -349, -349, 0, 0, -349, 0, 0, 0, 0,
4847 -349, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4848 0, 0, 0, 0, -349, 0, 0, -349, 0, 0,
4849 0, 0, 0, 0, 0, 0, 0, 0, 0, -349,
4850 -349, -349, -349, -349, -349, -349, -349, -349, -349, -349,
4851 -349, 0, 0, 0, 0, 0, -349, -349, -349, -349,
4852 -812, 0, -349, -349, -349, 0, 0, 0, -812, -812,
4853 -812, 0, 0, -812, -812, -812, 0, -812, 0, 0,
4854 0, 0, 0, 0, 0, -812, -812, -812, -812, 0,
4855 0, 0, 0, 0, 0, 0, 0, -812, -812, 0,
4856 -812, -812, -812, -812, -812, 0, 0, 0, 0, 0,
4857 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4858 0, 0, 0, 0, 0, 0, 0, 0, -812, -812,
4859 0, 0, 0, 0, 0, 0, 0, 0, -812, -812,
4860 -812, -812, -812, -812, -812, -812, -812, -812, -812, -812,
4861 -812, 0, 0, 0, 0, -812, -812, -812, -812, 0,
4862 0, -812, 0, 0, 0, 0, -812, 0, 0, 0,
4863 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4864 -812, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4865 0, 0, 0, 0, 0, -812, 0, -812, -812, -812,
4866 -812, -812, -812, -812, -812, -812, -812, 0, 0, 0,
4867 0, -812, -812, -812, -812, -812, -355, 256, -812, -812,
4868 -812, 0, 0, 0, -355, -355, -355, 0, 0, -355,
4869 -355, -355, 0, -355, 0, 0, 0, 0, 0, 0,
4870 0, -355, 0, -355, -355, 0, 0, 0, 0, 0,
4871 0, 0, 0, -355, -355, 0, -355, -355, -355, -355,
4872 -355, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4873 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4874 0, 0, 0, 0, -355, -355, 0, 0, 0, 0,
4875 0, 0, 0, 0, -355, -355, -355, -355, -355, -355,
4876 -355, -355, -355, -355, -355, -355, -355, 0, 0, 0,
4877 0, -355, -355, -355, -355, 0, 878, -355, 0, 0,
4878 0, 0, -355, 0, 0, 0, 0, 0, 0, 0,
4879 0, 0, 0, 0, 0, 0, -355, 0, 0, 0,
4880 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4881 -147, -355, 0, -355, -355, -355, -355, -355, -355, -355,
4882 -355, -355, -355, 0, 0, 0, 0, 820, -355, -355,
4883 -355, -355, -362, 0, -355, -355, -355, 0, 0, 0,
4884 -362, -362, -362, 0, 0, -362, -362, -362, 0, -362,
4885 0, 0, 0, 0, 0, 0, 0, -362, 0, -362,
4886 -362, 0, 0, 0, 0, 0, 0, 0, 0, -362,
4887 -362, 0, -362, -362, -362, -362, -362, 0, 0, 0,
4888 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4889 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4890 -362, -362, 0, 0, 0, 0, 0, 0, 0, 0,
4891 -362, -362, -362, -362, -362, -362, -362, -362, -362, -362,
4892 -362, -362, -362, 0, 0, 0, 0, -362, -362, -362,
4893 -362, 0, 0, -362, 0, 0, 0, 0, -362, 0,
4894 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4895 0, 0, -362, 0, 0, 0, 0, 0, 0, 0,
4896 0, 0, 0, 0, 0, 0, 0, -362, 0, -362,
4897 -362, -362, -362, -362, -362, -362, -362, -362, -362, 0,
4898 0, 0, 0, 0, -362, -362, -362, -362, -794, 450,
4899 -362, -362, -362, 0, 0, 0, -794, -794, -794, 0,
4900 0, 0, -794, -794, 0, -794, 0, 0, 0, 0,
4901 0, 0, 0, -794, -794, 0, 0, 0, 0, 0,
4902 0, 0, 0, 0, 0, -794, -794, 0, -794, -794,
4903 -794, -794, -794, 0, 0, 0, 0, 0, 0, 0,
4904 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4905 0, 0, 0, 0, 0, 0, -794, -794, 0, 0,
4906 0, 0, 0, 0, 0, 0, -794, -794, -794, -794,
4907 -794, -794, -794, -794, -794, -794, -794, -794, -794, 0,
4908 0, 0, 0, -794, -794, -794, -794, 0, 818, -794,
4909 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4910 0, 0, 0, 0, 0, 0, 0, 0, -794, 0,
4911 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4912 0, 0, -146, -794, 0, -794, -794, -794, -794, -794,
4913 -794, -794, -794, -794, -794, 0, 0, 0, 0, -794,
4914 -794, -794, -794, -137, -794, 0, -794, 0, -794, 0,
4915 0, 0, -794, -794, -794, 0, 0, 0, -794, -794,
4916 0, -794, 0, 0, 0, 0, 0, 0, 0, -794,
4917 -794, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4918 0, -794, -794, 0, -794, -794, -794, -794, -794, 0,
4919 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4920 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4921 0, 0, -794, -794, 0, 0, 0, 0, 0, 0,
4922 0, 0, -794, -794, -794, -794, -794, -794, -794, -794,
4923 -794, -794, -794, -794, -794, 0, 0, 0, 0, -794,
4924 -794, -794, -794, 0, 818, -794, 0, 0, 0, 0,
4925 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4926 0, 0, 0, 0, -794, 0, 0, 0, 0, 0,
4927 0, 0, 0, 0, 0, 0, 0, 0, -146, -794,
4928 0, -794, -794, -794, -794, -794, -794, -794, -794, -794,
4929 -794, 0, 0, 0, 0, -794, -794, -794, -794, -794,
4930 -355, 0, -794, 0, -794, 0, 0, 0, -355, -355,
4931 -355, 0, 0, 0, -355, -355, 0, -355, 0, 0,
4932 0, 0, 0, 0, 0, -355, 0, 0, 0, 0,
4933 0, 0, 0, 0, 0, 0, 0, -355, -355, 0,
4934 -355, -355, -355, -355, -355, 0, 0, 0, 0, 0,
4935 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4936 0, 0, 0, 0, 0, 0, 0, 0, -355, -355,
4937 0, 0, 0, 0, 0, 0, 0, 0, -355, -355,
4938 -355, -355, -355, -355, -355, -355, -355, -355, -355, -355,
4939 -355, 0, 0, 0, 0, -355, -355, -355, -355, 0,
4940 819, -355, 0, 0, 0, 0, 0, 0, 0, 0,
4941 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4942 -355, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4943 0, 0, 0, 0, -147, -355, 0, -355, -355, -355,
4944 -355, -355, -355, -355, -355, -355, -355, 0, 0, 0,
4945 0, 820, -355, -355, -355, -138, -355, 0, -355, 0,
4946 -355, 0, 0, 0, -355, -355, -355, 0, 0, 0,
4947 -355, -355, 0, -355, 0, 0, 0, 0, 0, 0,
4948 0, -355, 0, 0, 0, 0, 0, 0, 0, 0,
4949 0, 0, 0, -355, -355, 0, -355, -355, -355, -355,
4950 -355, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4951 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4952 0, 0, 0, 0, -355, -355, 0, 0, 0, 0,
4953 0, 0, 0, 0, -355, -355, -355, -355, -355, -355,
4954 -355, -355, -355, -355, -355, -355, -355, 0, 0, 0,
4955 0, -355, -355, -355, -355, 0, 819, -355, 0, 0,
4956 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4957 0, 0, 0, 0, 0, 0, -355, 0, 0, 0,
4958 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4959 -147, -355, 0, -355, -355, -355, -355, -355, -355, -355,
4960 -355, -355, -355, 0, 0, 0, 0, 820, -355, -355,
4961 -355, -355, 0, 0, -355, 3, -355, 4, 5, 6,
4962 7, 8, -812, -812, -812, 9, 10, 0, 0, -812,
4963 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
4964 0, 0, 0, 0, 19, 20, 21, 22, 23, 24,
4965 25, 0, 0, 26, 0, 0, 0, 0, 0, 27,
4966 28, 283, 30, 31, 32, 33, 34, 35, 36, 37,
4967 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
4968 0, 0, -812, 0, 0, 0, 0, 0, 0, 0,
4969 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
4970 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
4971 0, 0, 0, 51, 0, 0, 52, 53, 54, 55,
4972 0, 56, 0, 0, 57, 58, 59, 60, 61, 62,
4973 63, 64, 65, 0, 0, 0, 0, 0, 0, 0,
4974 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4975 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4976 0, 66, 67, 68, 0, 0, 0, 3, -812, 4,
4977 5, 6, 7, 8, -812, 0, -812, 9, 10, 0,
4978 -812, -812, 11, 0, 12, 13, 14, 15, 16, 17,
4979 18, 0, 0, 0, 0, 0, 19, 20, 21, 22,
4980 23, 24, 25, 0, 0, 26, 0, 0, 0, 0,
4981 0, 27, 28, 283, 30, 31, 32, 33, 34, 35,
4982 36, 37, 38, 39, 0, 40, 41, 42, 43, 44,
4983 45, 46, 0, 0, -812, 0, 0, 0, 0, 0,
4984 0, 0, 47, 48, 0, 0, 0, 0, 0, 0,
4985 0, 0, 0, 0, 0, 0, 0, 49, 50, 0,
4986 0, 0, 0, 0, 0, 51, 0, 0, 52, 53,
4987 54, 55, 0, 56, 0, 0, 57, 58, 59, 60,
4988 61, 62, 63, 64, 65, 0, 0, 0, 0, 0,
4989 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4990 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4991 0, 0, 0, 66, 67, 68, 0, 0, 0, 3,
4992 -812, 4, 5, 6, 7, 8, -812, 0, -812, 9,
4993 10, 0, 0, -812, 11, -812, 12, 13, 14, 15,
4994 16, 17, 18, 0, 0, 0, 0, 0, 19, 20,
4995 21, 22, 23, 24, 25, 0, 0, 26, 0, 0,
4996 0, 0, 0, 27, 28, 283, 30, 31, 32, 33,
4997 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
4998 43, 44, 45, 46, 0, 0, -812, 0, 0, 0,
4999 0, 0, 0, 0, 47, 48, 0, 0, 0, 0,
5000 0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
5001 50, 0, 0, 0, 0, 0, 0, 51, 0, 0,
5002 52, 53, 54, 55, 0, 56, 0, 0, 57, 58,
5003 59, 60, 61, 62, 63, 64, 65, 0, 0, 0,
5004 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5005 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5006 0, 0, 0, 0, 0, 66, 67, 68, 0, 0,
5007 0, 3, -812, 4, 5, 6, 7, 8, -812, 0,
5008 -812, 9, 10, 0, 0, -812, 11, 0, 12, 13,
5009 14, 15, 16, 17, 18, -812, 0, 0, 0, 0,
5010 19, 20, 21, 22, 23, 24, 25, 0, 0, 26,
5011 0, 0, 0, 0, 0, 27, 28, 283, 30, 31,
5012 32, 33, 34, 35, 36, 37, 38, 39, 0, 40,
5013 41, 42, 43, 44, 45, 46, 0, 0, -812, 0,
5014 0, 0, 0, 0, 0, 0, 47, 48, 0, 0,
5015 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5016 0, 49, 50, 0, 0, 0, 0, 0, 0, 51,
5017 0, 0, 52, 53, 54, 55, 0, 56, 0, 0,
5018 57, 58, 59, 60, 61, 62, 63, 64, 65, 0,
5019 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5020 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5021 0, 0, 0, 0, 0, 0, 0, 66, 67, 68,
5022 0, 0, 0, 3, -812, 4, 5, 6, 7, 8,
5023 -812, 0, -812, 9, 10, 0, 0, -812, 11, 0,
5024 12, 13, 14, 15, 16, 17, 18, 0, 0, 0,
5025 0, 0, 19, 20, 21, 22, 23, 24, 25, 0,
5026 0, 26, 0, 0, 0, 0, 0, 27, 28, 283,
5027 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
5028 0, 40, 41, 42, 43, 44, 45, 46, 0, 0,
5029 -812, 0, 0, 0, 0, 0, 0, 0, 47, 48,
5030 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5031 0, 0, 0, 49, 50, 0, 0, 0, 0, 0,
5032 0, 51, 0, 0, 52, 53, 54, 55, 0, 56,
5033 0, 0, 57, 58, 59, 60, 61, 62, 63, 64,
5034 65, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5035 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5036 0, 0, 0, 0, 0, 0, 0, 0, 0, 66,
5037 67, 68, 0, 0, 0, 3, -812, 4, 5, 6,
5038 7, 8, -812, -812, -812, 9, 10, 0, 0, 0,
5039 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5040 0, 0, 0, 0, 19, 20, 21, 22, 23, 24,
5041 25, 0, 0, 26, 0, 0, 0, 0, 0, 27,
5042 28, 283, 30, 31, 32, 33, 34, 35, 36, 37,
5043 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5044 0, 0, -812, 0, 0, 0, 0, 0, 0, 0,
5045 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5046 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5047 0, 0, 0, 51, 0, 0, 52, 53, 54, 55,
5048 0, 56, 0, 0, 57, 58, 59, 60, 61, 62,
5049 63, 64, 65, 0, 0, 0, 0, 0, 0, 0,
5050 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5051 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5052 0, 66, 67, 68, 0, 0, 0, 3, -812, 4,
5053 5, 6, 7, 8, -812, 0, -812, 9, 10, 0,
5054 0, 0, 11, 0, 12, 13, 14, 15, 16, 17,
5055 18, 0, 0, 0, 0, 0, 19, 20, 21, 22,
5056 23, 24, 25, 0, 0, 26, 0, 0, 0, 0,
5057 0, 27, 28, 283, 30, 31, 32, 33, 34, 35,
5058 36, 37, 38, 39, 0, 40, 41, 42, 43, 44,
5059 45, 46, 0, 0, -812, 0, 0, 0, 0, 0,
5060 0, 0, 47, 48, 0, 0, 0, 0, 0, 0,
5061 0, 0, 0, 0, 0, 0, 0, 49, 50, 0,
5062 0, 0, 0, 0, 0, 51, 0, 0, 52, 53,
5063 54, 55, 0, 56, 0, 0, 57, 58, 59, 60,
5064 61, 62, 63, 64, 65, 0, 0, 0, 0, 0,
5065 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5066 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5067 0, 0, 0, 66, 67, 68, 0, 0, 0, 3,
5068 -812, 4, 5, 6, 7, 8, -812, 0, 0, 9,
5069 10, 0, 0, 0, 11, 0, 12, 13, 14, 15,
5070 16, 17, 18, 0, 0, 0, 0, 0, 19, 20,
5071 21, 22, 23, 24, 25, 0, 0, 26, 0, 0,
5072 0, 0, 0, 27, 28, 283, 30, 31, 32, 33,
5073 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
5074 43, 44, 45, 46, 0, 0, 0, 0, 0, 0,
5075 0, 0, 0, 0, 47, 48, 0, 0, 0, 0,
5076 0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
5077 50, 0, 0, 0, 0, 0, 0, 51, 0, 0,
5078 284, 53, 54, 55, 0, 56, 0, 0, 57, 58,
5079 59, 60, 61, 62, 63, 64, 65, 0, 0, 0,
5080 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5081 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5082 0, 0, 0, 0, 0, 66, 67, 68, 0, 0,
5083 0, 0, -812, 0, 0, 0, -812, 3, -812, 4,
5084 5, 6, 7, 8, 0, 0, 0, 9, 10, 0,
5085 0, 0, 11, 0, 12, 13, 14, 15, 16, 17,
5086 18, 0, 0, 0, 0, 0, 19, 20, 21, 22,
5087 23, 24, 25, 0, 0, 26, 0, 0, 0, 0,
5088 0, 27, 28, 283, 30, 31, 32, 33, 34, 35,
5089 36, 37, 38, 39, 0, 40, 41, 42, 43, 44,
5090 45, 46, 0, 0, 0, 0, 0, 0, 0, 0,
5091 0, 0, 47, 48, 0, 0, 0, 0, 0, 0,
5092 0, 0, 0, 0, 0, 0, 0, 49, 50, 0,
5093 0, 0, 0, 0, 0, 51, 0, 0, 52, 53,
5094 54, 55, 0, 56, 0, 0, 57, 58, 59, 60,
5095 61, 62, 63, 64, 65, 0, 0, 0, 0, 0,
5096 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5097 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5098 0, 0, 0, 66, 67, 68, 0, 0, 0, 0,
5099 -812, 0, 0, 0, -812, 3, -812, 4, 5, 6,
5100 7, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5101 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5102 0, 0, 0, 0, 19, 20, 21, 22, 23, 24,
5103 25, 0, 0, 26, 0, 0, 0, 0, 0, 27,
5104 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
5105 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5106 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5107 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5108 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5109 0, 0, 0, 51, 0, 0, 52, 53, 54, 55,
5110 0, 56, 0, 0, 57, 58, 59, 60, 61, 62,
5111 63, 64, 65, 0, 0, 0, 0, 0, 0, 0,
5112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5114 0, 66, 67, 68, 0, 0, -812, 3, -812, 4,
5115 5, 6, 7, 8, -812, 0, 0, 9, 10, 0,
5116 0, 0, 11, 0, 12, 13, 14, 15, 16, 17,
5117 18, 0, 0, 0, 0, 0, 19, 20, 21, 22,
5118 23, 24, 25, 0, 0, 26, 0, 0, 0, 0,
5119 0, 27, 28, 283, 30, 31, 32, 33, 34, 35,
5120 36, 37, 38, 39, 0, 40, 41, 42, 43, 44,
5121 45, 46, 0, 0, 0, 0, 0, 0, 0, 0,
5122 0, 0, 47, 48, 0, 0, 0, 0, 0, 0,
5123 0, 0, 0, 0, 0, 0, 0, 49, 50, 0,
5124 0, 0, 0, 0, 0, 51, 0, 0, 52, 53,
5125 54, 55, 0, 56, 0, 0, 57, 58, 59, 60,
5126 61, 62, 63, 64, 65, 0, 0, 0, 0, 0,
5127 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5128 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5129 0, 0, 0, 66, 67, 68, 0, 0, -812, 403,
5130 -812, 4, 5, 6, 0, 8, -812, 0, 0, 9,
5131 10, 0, 0, 0, 11, -3, 12, 13, 14, 15,
5132 16, 17, 18, 0, 0, 0, 0, 0, 19, 20,
5133 21, 22, 23, 24, 25, 0, 0, 26, 0, 0,
5134 0, 0, 0, 0, 28, 0, 0, 31, 32, 33,
5135 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
5136 43, 44, 45, 46, 0, 0, 0, 0, 0, 0,
5137 0, 0, 0, 0, 47, 48, 0, 0, 0, 0,
5138 0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
5139 50, 0, 0, 0, 0, 0, 0, 229, 0, 0,
5140 230, 53, 54, 55, 0, 0, 0, 0, 57, 58,
5141 59, 60, 61, 62, 63, 64, 65, 0, 0, 0,
5142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5144 0, 0, 0, 0, 0, 66, 67, 68, 0, 0,
5145 0, 0, 330, 0, 0, 0, 0, 0, 331, 144,
5146 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
5147 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
5148 165, 166, 167, 0, 0, 0, 168, 169, 170, 433,
5149 434, 435, 436, 175, 176, 177, 0, 0, 0, 0,
5150 0, 178, 179, 180, 181, 437, 438, 439, 440, 186,
5151 36, 37, 441, 39, 0, 0, 0, 0, 0, 0,
5152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5153 0, 0, 188, 189, 190, 191, 192, 193, 194, 195,
5154 196, 0, 0, 197, 198, 0, 0, 0, 0, 199,
5155 200, 201, 202, 0, 0, 0, 0, 0, 0, 0,
5156 0, 0, 0, 203, 204, 0, 0, 0, 0, 0,
5157 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5158 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5159 0, 0, 0, 205, 206, 207, 208, 209, 210, 211,
5160 212, 213, 214, 0, 215, 216, 0, 0, 0, 0,
5161 0, 0, 217, 442, 144, 145, 146, 147, 148, 149,
5162 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
5163 160, 161, 162, 163, 164, 165, 166, 167, 0, 0,
5164 0, 168, 169, 170, 171, 172, 173, 174, 175, 176,
5165 177, 0, 0, 0, 0, 0, 178, 179, 180, 181,
5166 182, 183, 184, 185, 186, 36, 37, 187, 39, 0,
5167 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5168 0, 0, 0, 0, 0, 0, 0, 188, 189, 190,
5169 191, 192, 193, 194, 195, 196, 0, 0, 197, 198,
5170 0, 0, 0, 0, 199, 200, 201, 202, 0, 0,
5171 0, 0, 0, 0, 0, 0, 0, 0, 203, 204,
5172 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5173 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5174 0, 0, 0, 0, 0, 0, 0, 0, 205, 206,
5175 207, 208, 209, 210, 211, 212, 213, 214, 0, 215,
5176 216, 0, 0, 0, 0, 0, 0, 217, 144, 145,
5177 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
5178 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
5179 166, 167, 0, 0, 0, 168, 169, 170, 171, 172,
5180 173, 174, 175, 176, 177, 0, 0, 0, 0, 0,
5181 178, 179, 180, 181, 182, 183, 184, 185, 186, 263,
5182 0, 187, 0, 0, 0, 0, 0, 0, 0, 0,
5183 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5184 0, 188, 189, 190, 191, 192, 193, 194, 195, 196,
5185 0, 0, 197, 198, 0, 0, 0, 0, 199, 200,
5186 201, 202, 0, 0, 0, 0, 0, 0, 0, 0,
5187 0, 0, 203, 204, 0, 0, 58, 0, 0, 0,
5188 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5189 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5190 0, 0, 205, 206, 207, 208, 209, 210, 211, 212,
5191 213, 214, 0, 215, 216, 0, 0, 0, 0, 0,
5192 0, 217, 144, 145, 146, 147, 148, 149, 150, 151,
5193 152, 153, 154, 155, 156, 157, 158, 159, 160, 161,
5194 162, 163, 164, 165, 166, 167, 0, 0, 0, 168,
5195 169, 170, 171, 172, 173, 174, 175, 176, 177, 0,
5196 0, 0, 0, 0, 178, 179, 180, 181, 182, 183,
5197 184, 185, 186, 0, 0, 187, 0, 0, 0, 0,
5198 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5199 0, 0, 0, 0, 0, 188, 189, 190, 191, 192,
5200 193, 194, 195, 196, 0, 0, 197, 198, 0, 0,
5201 0, 0, 199, 200, 201, 202, 0, 0, 0, 0,
5202 0, 0, 0, 0, 0, 0, 203, 204, 0, 0,
5203 58, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5204 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5205 0, 0, 0, 0, 0, 0, 205, 206, 207, 208,
5206 209, 210, 211, 212, 213, 214, 0, 215, 216, 0,
5207 0, 0, 0, 0, 0, 217, 144, 145, 146, 147,
5208 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
5209 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
5210 0, 0, 0, 168, 169, 170, 171, 172, 173, 174,
5211 175, 176, 177, 0, 0, 0, 0, 0, 178, 179,
5212 180, 181, 182, 183, 184, 185, 186, 0, 0, 187,
5213 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5214 0, 0, 0, 0, 0, 0, 0, 0, 0, 188,
5215 189, 190, 191, 192, 193, 194, 195, 196, 0, 0,
5216 197, 198, 0, 0, 0, 0, 199, 200, 201, 202,
5217 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5218 203, 204, 0, 0, 0, 0, 0, 0, 0, 0,
5219 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5221 205, 206, 207, 208, 209, 210, 211, 212, 213, 214,
5222 0, 215, 216, 4, 5, 6, 0, 8, 0, 217,
5223 0, 9, 10, 0, 0, 0, 11, 0, 12, 13,
5224 14, 271, 272, 17, 18, 0, 0, 0, 0, 0,
5225 19, 20, 273, 22, 23, 24, 25, 0, 0, 227,
5226 0, 0, 0, 0, 0, 0, 301, 0, 0, 31,
5227 32, 33, 34, 35, 36, 37, 38, 39, 0, 40,
5228 41, 42, 43, 44, 45, 46, 0, 0, 0, 0,
5229 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5230 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5231 0, 0, 0, 0, 0, 0, 0, 0, 0, 302,
5232 0, 0, 230, 53, 54, 55, 0, 0, 0, 0,
5233 57, 58, 59, 60, 61, 62, 63, 64, 65, 0,
5234 0, 4, 5, 6, 0, 8, 0, 0, 0, 9,
5235 10, 0, 0, 0, 11, 0, 12, 13, 14, 271,
5236 272, 17, 18, 0, 0, 0, 0, 303, 19, 20,
5237 273, 22, 23, 24, 25, 304, 0, 227, 0, 0,
5238 0, 0, 0, 0, 301, 0, 0, 31, 32, 33,
5239 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
5240 43, 44, 45, 46, 0, 0, 0, 0, 0, 0,
5241 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5242 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5243 0, 0, 0, 0, 0, 0, 0, 302, 0, 0,
5244 230, 53, 54, 55, 0, 0, 0, 0, 57, 58,
5245 59, 60, 61, 62, 63, 64, 65, 0, 0, 4,
5246 5, 6, 0, 8, 0, 0, 0, 9, 10, 0,
5247 0, 0, 11, 0, 12, 13, 14, 15, 16, 17,
5248 18, 0, 0, 0, 0, 303, 19, 20, 21, 22,
5249 23, 24, 25, 607, 0, 227, 0, 0, 0, 0,
5250 0, 0, 28, 0, 0, 31, 32, 33, 34, 35,
5251 36, 37, 38, 39, 228, 40, 41, 42, 43, 44,
5252 45, 46, 0, 0, 0, 0, 0, 0, 0, 0,
5253 0, 0, 47, 48, 0, 0, 0, 0, 0, 0,
5254 0, 0, 0, 0, 0, 0, 0, 49, 50, 0,
5255 0, 0, 0, 0, 0, 229, 0, 0, 230, 53,
5256 54, 55, 0, 231, 232, 233, 57, 58, 234, 60,
5257 61, 62, 63, 64, 65, 0, 0, 0, 0, 0,
5258 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5259 0, 0, 0, 0, 0, 0, 0, 0, 4, 5,
5260 6, 0, 8, 66, 235, 68, 9, 10, 0, 0,
5261 260, 11, 0, 12, 13, 14, 15, 16, 17, 18,
5262 0, 0, 0, 0, 0, 19, 20, 21, 22, 23,
5263 24, 25, 0, 0, 26, 0, 0, 0, 0, 0,
5264 0, 28, 0, 0, 31, 32, 33, 34, 35, 36,
5265 37, 38, 39, 0, 40, 41, 42, 43, 44, 45,
5266 46, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5267 0, 47, 48, 0, 0, 0, 0, 0, 0, 0,
5268 0, 0, 0, 0, 0, 0, 49, 50, 0, 0,
5269 0, 0, 0, 0, 229, 0, 0, 230, 53, 54,
5270 55, 0, 0, 0, 0, 57, 58, 59, 60, 61,
5271 62, 63, 64, 65, 0, 0, 0, 0, 0, 0,
5272 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5273 0, 0, 0, 0, 0, 3, 0, 4, 5, 6,
5274 7, 8, 66, 67, 68, 9, 10, 0, 0, 260,
5275 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5276 0, 0, 0, 0, 19, 20, 21, 22, 23, 24,
5277 25, 0, 0, 26, 0, 0, 0, 0, 0, 27,
5278 28, 0, 30, 31, 32, 33, 34, 35, 36, 37,
5279 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5280 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5281 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5282 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5283 0, 0, 0, 51, 0, 0, 52, 53, 54, 55,
5284 0, 56, 0, 0, 57, 58, 59, 60, 61, 62,
5285 63, 64, 65, 0, 0, 403, 0, 4, 5, 6,
5286 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5287 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5288 0, 66, 67, 68, 19, 20, 21, 22, 23, 24,
5289 25, 0, 0, 26, 0, 0, 0, 0, 0, 0,
5290 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5291 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5292 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5293 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5294 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5295 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5296 0, 0, 0, 0, 57, 58, 59, 60, 61, 62,
5297 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5298 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5299 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5300 0, 66, 67, 68, 19, 20, 21, 22, 23, 24,
5301 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5302 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5303 38, 39, 228, 40, 41, 42, 43, 44, 45, 46,
5304 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5305 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5306 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5307 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5308 0, 231, 232, 233, 57, 58, 234, 60, 61, 62,
5309 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5310 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5311 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5312 0, 66, 235, 68, 19, 20, 21, 22, 23, 24,
5313 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5314 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5315 38, 39, 228, 40, 41, 42, 43, 44, 45, 46,
5316 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5317 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5318 0, 0, 0, 0, 0, 49, 480, 0, 0, 0,
5319 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5320 0, 231, 232, 233, 57, 58, 234, 60, 61, 62,
5321 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5322 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5323 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5324 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5325 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5326 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5327 38, 39, 228, 40, 41, 42, 43, 44, 45, 46,
5328 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5329 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5330 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5331 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5332 0, 231, 232, 233, 57, 58, 234, 60, 61, 62,
5333 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5334 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5335 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5336 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5337 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5338 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5339 38, 39, 228, 40, 41, 42, 43, 44, 45, 46,
5340 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5341 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5342 0, 0, 0, 0, 0, 49, 480, 0, 0, 0,
5343 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5344 0, 231, 232, 233, 57, 58, 234, 60, 61, 62,
5345 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5346 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5347 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5348 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5349 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5350 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5351 38, 39, 228, 40, 41, 42, 43, 44, 45, 46,
5352 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5353 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5354 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5355 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5356 0, 231, 232, 0, 57, 58, 234, 60, 61, 62,
5357 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5358 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5359 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5360 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5361 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5362 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5363 38, 39, 228, 40, 41, 42, 43, 44, 45, 46,
5364 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5365 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5366 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5367 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5368 0, 0, 232, 233, 57, 58, 234, 60, 61, 62,
5369 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5370 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5371 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5372 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5373 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5374 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5375 38, 39, 228, 40, 41, 42, 43, 44, 45, 46,
5376 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5377 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5378 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5379 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5380 0, 0, 232, 0, 57, 58, 234, 60, 61, 62,
5381 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5382 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5383 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5384 0, 66, 235, 68, 19, 20, 21, 22, 23, 24,
5385 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5386 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5387 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5388 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5389 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5390 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5391 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5392 0, 793, 0, 0, 57, 58, 59, 60, 61, 62,
5393 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5394 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5395 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5396 0, 66, 235, 68, 19, 20, 21, 22, 23, 24,
5397 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5398 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5399 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5400 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5401 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5402 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5403 0, 0, 0, 804, 0, 0, 230, 53, 54, 55,
5404 0, 793, 0, 0, 57, 58, 59, 60, 61, 62,
5405 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5406 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5407 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5408 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5409 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5410 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5411 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5412 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5413 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5414 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5415 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5416 0, 965, 0, 0, 57, 58, 59, 60, 61, 62,
5417 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5418 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5419 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5420 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5421 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5422 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5423 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5424 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5425 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5426 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5427 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5428 0, 1014, 0, 0, 57, 58, 59, 60, 61, 62,
5429 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5430 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5431 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5432 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5433 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5434 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5435 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5436 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5437 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5438 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5439 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5440 0, 793, 0, 0, 57, 58, 59, 60, 61, 62,
5441 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5442 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5443 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5444 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5445 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5446 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5447 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5448 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5449 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5450 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5451 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5452 0, 1134, 0, 0, 57, 58, 59, 60, 61, 62,
5453 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5454 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5455 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5456 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5457 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5458 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5459 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5460 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5461 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5462 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5463 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5464 0, 0, 0, 0, 57, 58, 59, 60, 61, 62,
5465 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5466 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5467 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5468 0, 66, 235, 68, 19, 20, 21, 22, 23, 24,
5469 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5470 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5471 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5472 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5473 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5474 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5475 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5476 0, 0, 0, 0, 57, 58, 59, 60, 61, 62,
5477 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5478 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5479 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5480 0, 66, 235, 68, 19, 20, 21, 22, 23, 24,
5481 25, 0, 0, 26, 0, 0, 0, 0, 0, 0,
5482 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5483 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5484 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5485 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5486 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5487 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5488 0, 0, 0, 0, 57, 58, 59, 60, 61, 62,
5489 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5490 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5491 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5492 0, 66, 67, 68, 19, 20, 21, 22, 23, 24,
5493 25, 0, 0, 775, 0, 0, 0, 0, 0, 0,
5494 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5495 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5496 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5497 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5498 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5499 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5500 0, 0, 0, 0, 57, 58, 59, 60, 61, 62,
5501 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5502 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5503 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5504 0, 66, 235, 68, 19, 20, 21, 22, 23, 24,
5505 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5506 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5507 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5508 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5509 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5510 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5511 0, 0, 0, 804, 0, 0, 230, 53, 54, 55,
5512 0, 0, 0, 0, 57, 58, 59, 60, 61, 62,
5513 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5514 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5515 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5516 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5517 25, 0, 0, 875, 0, 0, 0, 0, 0, 0,
5518 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5519 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5520 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5521 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5522 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5523 0, 0, 0, 229, 0, 0, 230, 53, 54, 55,
5524 0, 0, 0, 0, 57, 58, 59, 60, 61, 62,
5525 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5526 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5527 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5528 0, 66, 235, 68, 19, 20, 273, 22, 23, 24,
5529 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5530 301, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5531 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5532 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5533 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5534 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5535 0, 0, 0, 302, 0, 0, 362, 53, 54, 55,
5536 0, 363, 0, 0, 57, 58, 59, 60, 61, 62,
5537 63, 64, 65, 0, 0, 4, 5, 6, 0, 8,
5538 0, 0, 0, 9, 10, 0, 0, 0, 11, 0,
5539 12, 13, 14, 271, 272, 17, 18, 0, 0, 0,
5540 0, 303, 19, 20, 273, 22, 23, 24, 25, 0,
5541 0, 227, 0, 0, 0, 0, 0, 0, 301, 0,
5542 0, 31, 32, 33, 34, 35, 36, 37, 38, 39,
5543 0, 40, 41, 42, 43, 44, 45, 46, 0, 0,
5544 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5545 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5546 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5547 0, 414, 0, 0, 52, 53, 54, 55, 0, 56,
5548 0, 0, 57, 58, 59, 60, 61, 62, 63, 64,
5549 65, 0, 0, 4, 5, 6, 0, 8, 0, 0,
5550 0, 9, 10, 0, 0, 0, 11, 0, 12, 13,
5551 14, 271, 272, 17, 18, 0, 0, 0, 0, 303,
5552 19, 20, 273, 22, 23, 24, 25, 0, 0, 227,
5553 0, 0, 0, 0, 0, 0, 301, 0, 0, 31,
5554 32, 33, 422, 35, 36, 37, 423, 39, 0, 40,
5555 41, 42, 43, 44, 45, 46, 0, 0, 0, 0,
5556 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5557 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5558 0, 0, 0, 0, 0, 424, 0, 0, 0, 425,
5559 0, 0, 230, 53, 54, 55, 0, 0, 0, 0,
5560 57, 58, 59, 60, 61, 62, 63, 64, 65, 0,
5561 0, 4, 5, 6, 0, 8, 0, 0, 0, 9,
5562 10, 0, 0, 0, 11, 0, 12, 13, 14, 271,
5563 272, 17, 18, 0, 0, 0, 0, 303, 19, 20,
5564 273, 22, 23, 24, 25, 0, 0, 227, 0, 0,
5565 0, 0, 0, 0, 301, 0, 0, 31, 32, 33,
5566 422, 35, 36, 37, 423, 39, 0, 40, 41, 42,
5567 43, 44, 45, 46, 0, 0, 0, 0, 0, 0,
5568 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5569 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5570 0, 0, 0, 0, 0, 0, 0, 425, 0, 0,
5571 230, 53, 54, 55, 0, 0, 0, 0, 57, 58,
5572 59, 60, 61, 62, 63, 64, 65, 0, 0, 4,
5573 5, 6, 0, 8, 0, 0, 0, 9, 10, 0,
5574 0, 0, 11, 0, 12, 13, 14, 271, 272, 17,
5575 18, 0, 0, 0, 0, 303, 19, 20, 273, 22,
5576 23, 24, 25, 0, 0, 227, 0, 0, 0, 0,
5577 0, 0, 301, 0, 0, 31, 32, 33, 34, 35,
5578 36, 37, 38, 39, 0, 40, 41, 42, 43, 44,
5579 45, 46, 0, 0, 0, 0, 0, 0, 0, 0,
5580 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5581 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5582 0, 0, 0, 0, 0, 302, 0, 0, 362, 53,
5583 54, 55, 0, 0, 0, 0, 57, 58, 59, 60,
5584 61, 62, 63, 64, 65, 0, 0, 4, 5, 6,
5585 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5586 11, 0, 12, 13, 14, 271, 272, 17, 18, 0,
5587 0, 0, 0, 303, 19, 20, 273, 22, 23, 24,
5588 25, 0, 0, 227, 0, 0, 0, 0, 0, 0,
5589 301, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5590 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5591 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5592 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5593 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5594 0, 0, 0, 1190, 0, 0, 230, 53, 54, 55,
5595 0, 0, 0, 0, 57, 58, 59, 60, 61, 62,
5596 63, 64, 65, 0, 0, 4, 5, 6, 0, 8,
5597 0, 0, 0, 9, 10, 0, 0, 0, 11, 0,
5598 12, 13, 14, 271, 272, 17, 18, 0, 0, 0,
5599 0, 303, 19, 20, 273, 22, 23, 24, 25, 0,
5600 0, 227, 0, 0, 0, 0, 0, 0, 301, 0,
5601 0, 31, 32, 33, 34, 35, 36, 37, 38, 39,
5602 0, 40, 41, 42, 43, 44, 45, 46, 0, 0,
5603 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5604 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5605 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5606 0, 1289, 0, 0, 230, 53, 54, 55, 22, 23,
5607 24, 25, 57, 58, 59, 60, 61, 62, 63, 64,
5608 65, 0, 0, 0, 31, 32, 33, 1077, 0, 0,
5609 0, 1078, 0, 0, 40, 41, 42, 43, 44, 0,
5610 0, 0, 0, 0, 0, 0, 0, 0, 0, 303,
5611 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5612 0, 0, 0, 0, 0, 0, 1080, 1081, 0, 0,
5613 0, 0, 0, 0, 1082, 0, 0, 1083, 0, 1084,
5614 1085, 0, 0, 0, 0, 57, 58, 59, 60, 61,
5615 62, 63, 64, 65, 0, 0, 0, 0, 0, 684,
5616 646, 0, 0, 685, 0, 0, 0, 0, 0, 0,
5617 0, 0, 0, 0, 0, 1088, 0, 0, 0, 0,
5618 0, 0, 303, 188, 189, 190, 191, 192, 193, 194,
5619 195, 196, 0, 0, 197, 198, 0, 0, 0, 0,
5620 199, 200, 201, 202, 0, 0, 0, 0, 0, 0,
5621 0, 0, 0, 0, 203, 204, 0, 0, 0, 0,
5622 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5623 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5624 0, 0, 0, 0, 205, 206, 207, 208, 209, 210,
5625 211, 212, 213, 214, 0, 215, 216, 700, 638, 0,
5626 0, 701, 0, 217, 0, 0, 0, 0, 0, 0,
5627 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5628 0, 188, 189, 190, 191, 192, 193, 194, 195, 196,
5629 0, 0, 197, 198, 0, 0, 0, 0, 199, 200,
5630 201, 202, 0, 0, 0, 0, 0, 0, 0, 0,
5631 0, 0, 203, 204, 0, 0, 0, 0, 0, 0,
5632 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5633 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5634 0, 0, 205, 206, 207, 208, 209, 210, 211, 212,
5635 213, 214, 0, 215, 216, 703, 646, 0, 0, 704,
5636 0, 217, 0, 0, 0, 0, 0, 0, 0, 0,
5637 0, 0, 0, 0, 0, 0, 0, 0, 0, 188,
5638 189, 190, 191, 192, 193, 194, 195, 196, 0, 0,
5639 197, 198, 0, 0, 0, 0, 199, 200, 201, 202,
5640 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5641 203, 204, 0, 0, 0, 0, 0, 0, 0, 0,
5642 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5643 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5644 205, 206, 207, 208, 209, 210, 211, 212, 213, 214,
5645 0, 215, 216, 700, 638, 0, 0, 718, 0, 217,
5646 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5647 0, 0, 0, 0, 0, 0, 0, 188, 189, 190,
5648 191, 192, 193, 194, 195, 196, 0, 0, 197, 198,
5649 0, 0, 0, 0, 199, 200, 201, 202, 0, 0,
5650 0, 0, 0, 0, 0, 0, 0, 0, 203, 204,
5651 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5652 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5653 0, 0, 0, 0, 0, 0, 0, 0, 205, 206,
5654 207, 208, 209, 210, 211, 212, 213, 214, 0, 215,
5655 216, 729, 638, 0, 0, 730, 0, 217, 0, 0,
5656 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5657 0, 0, 0, 0, 0, 188, 189, 190, 191, 192,
5658 193, 194, 195, 196, 0, 0, 197, 198, 0, 0,
5659 0, 0, 199, 200, 201, 202, 0, 0, 0, 0,
5660 0, 0, 0, 0, 0, 0, 203, 204, 0, 0,
5661 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5662 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5663 0, 0, 0, 0, 0, 0, 205, 206, 207, 208,
5664 209, 210, 211, 212, 213, 214, 0, 215, 216, 732,
5665 646, 0, 0, 733, 0, 217, 0, 0, 0, 0,
5666 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5667 0, 0, 0, 188, 189, 190, 191, 192, 193, 194,
5668 195, 196, 0, 0, 197, 198, 0, 0, 0, 0,
5669 199, 200, 201, 202, 0, 0, 0, 0, 0, 0,
5670 0, 0, 0, 0, 203, 204, 0, 0, 0, 0,
5671 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5672 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5673 0, 0, 0, 0, 205, 206, 207, 208, 209, 210,
5674 211, 212, 213, 214, 0, 215, 216, 848, 638, 0,
5675 0, 849, 0, 217, 0, 0, 0, 0, 0, 0,
5676 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5677 0, 188, 189, 190, 191, 192, 193, 194, 195, 196,
5678 0, 0, 197, 198, 0, 0, 0, 0, 199, 200,
5679 201, 202, 0, 0, 0, 0, 0, 0, 0, 0,
5680 0, 0, 203, 204, 0, 0, 0, 0, 0, 0,
5681 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5682 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5683 0, 0, 205, 206, 207, 208, 209, 210, 211, 212,
5684 213, 214, 0, 215, 216, 851, 646, 0, 0, 852,
5685 0, 217, 0, 0, 0, 0, 0, 0, 0, 0,
5686 0, 0, 0, 0, 0, 0, 0, 0, 0, 188,
5687 189, 190, 191, 192, 193, 194, 195, 196, 0, 0,
5688 197, 198, 0, 0, 0, 0, 199, 200, 201, 202,
5689 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5690 203, 204, 0, 0, 0, 0, 0, 0, 0, 0,
5691 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5692 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5693 205, 206, 207, 208, 209, 210, 211, 212, 213, 214,
5694 0, 215, 216, 857, 638, 0, 0, 858, 0, 217,
5695 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5696 0, 0, 0, 0, 0, 0, 0, 188, 189, 190,
5697 191, 192, 193, 194, 195, 196, 0, 0, 197, 198,
5698 0, 0, 0, 0, 199, 200, 201, 202, 0, 0,
5699 0, 0, 0, 0, 0, 0, 0, 0, 203, 204,
5700 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5701 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5702 0, 0, 0, 0, 0, 0, 0, 0, 205, 206,
5703 207, 208, 209, 210, 211, 212, 213, 214, 0, 215,
5704 216, 1020, 638, 0, 0, 1021, 0, 217, 0, 0,
5705 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5706 0, 0, 0, 0, 0, 188, 189, 190, 191, 192,
5707 193, 194, 195, 196, 0, 0, 197, 198, 0, 0,
5708 0, 0, 199, 200, 201, 202, 0, 0, 0, 0,
5709 0, 0, 0, 0, 0, 0, 203, 204, 0, 0,
5710 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5711 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5712 0, 0, 0, 0, 0, 0, 205, 206, 207, 208,
5713 209, 210, 211, 212, 213, 214, 0, 215, 216, 1023,
5714 646, 0, 0, 1024, 0, 217, 0, 0, 0, 0,
5715 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5716 0, 0, 0, 188, 189, 190, 191, 192, 193, 194,
5717 195, 196, 0, 0, 197, 198, 0, 0, 0, 0,
5718 199, 200, 201, 202, 0, 0, 0, 0, 0, 0,
5719 0, 0, 0, 0, 203, 204, 0, 0, 0, 0,
5720 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5721 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5722 0, 0, 0, 0, 205, 206, 207, 208, 209, 210,
5723 211, 212, 213, 214, 0, 215, 216, 1307, 638, 0,
5724 0, 1308, 0, 217, 0, 0, 0, 0, 0, 0,
5725 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5726 0, 188, 189, 190, 191, 192, 193, 194, 195, 196,
5727 0, 0, 197, 198, 0, 0, 0, 0, 199, 200,
5728 201, 202, 0, 0, 0, 0, 0, 0, 0, 0,
5729 0, 0, 203, 204, 0, 0, 0, 0, 0, 0,
5730 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5731 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5732 0, 0, 205, 206, 207, 208, 209, 210, 211, 212,
5733 213, 214, 0, 215, 216, 1310, 646, 0, 0, 1311,
5734 0, 217, 0, 0, 0, 0, 0, 0, 0, 0,
5735 0, 0, 0, 0, 0, 0, 0, 0, 0, 188,
5736 189, 190, 191, 192, 193, 194, 195, 196, 0, 0,
5737 197, 198, 0, 0, 0, 0, 199, 200, 201, 202,
5738 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5739 203, 204, 0, 0, 0, 0, 0, 0, 0, 0,
5740 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5741 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5742 205, 206, 207, 208, 209, 210, 211, 212, 213, 214,
5743 0, 215, 216, 1355, 638, 0, 0, 1356, 0, 217,
5744 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5745 0, 0, 0, 0, 0, 0, 0, 188, 189, 190,
5746 191, 192, 193, 194, 195, 196, 0, 0, 197, 198,
5747 0, 0, 0, 0, 199, 200, 201, 202, 0, 0,
5748 0, 0, 0, 0, 0, 0, 0, 0, 203, 204,
5749 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5750 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5751 0, 0, 0, 0, 0, 0, 0, 0, 205, 206,
5752 207, 208, 209, 210, 211, 212, 213, 214, 0, 215,
5753 216, 0, 0, 0, 0, 0, 0, 217
5756static const yytype_int16 yycheck[] =
5758 1, 59, 7, 103, 104, 15, 16, 107, 70, 58,
5759 58, 101, 116, 107, 347, 1, 1, 253, 13, 14,
5760 343, 56, 27, 7, 347, 115, 399, 256, 766, 425,
5761 759, 67, 573, 15, 16, 407, 27, 89, 836, 596,
5762 52, 53, 21, 27, 610, 343, 70, 15, 16, 347,
5763 596, 52, 53, 58, 89, 56, 56, 594, 761, 66,
5764 597, 295, 398, 111, 400, 299, 52, 53, 54, 55,
5765 470, 903, 54, 108, 109, 110, 470, 72, 478, 759,
5766 478, 816, 52, 107, 846, 600, 54, 55, 89, 63,
5767 64, 65, 15, 16, 80, 81, 625, 25, 905, 524,
5768 0, 474, 112, 1025, 1026, 84, 111, 108, 109, 110,
5769 111, 55, 941, 319, 320, 25, 514, 511, 454, 81,
5770 29, 564, 284, 687, 688, 84, 1282, 25, 1163, 1026,
5771 112, 78, 13, 1274, 101, 25, 693, 473, 104, 475,
5772 677, 107, 1177, 10, 112, 100, 34, 25, 34, 584,
5773 100, 100, 13, 526, 113, 590, 101, 721, 248, 100,
5774 26, 261, 262, 58, 52, 501, 52, 25, 1025, 1026,
5775 81, 154, 761, 0, 702, 158, 234, 766, 26, 134,
5776 28, 610, 607, 78, 134, 134, 276, 25, 155, 112,
5777 154, 527, 286, 134, 69, 1351, 13, 144, 145, 146,
5778 362, 68, 1343, 731, 37, 38, 134, 157, 151, 25,
5779 155, 15, 13, 108, 123, 1137, 1163, 112, 230, 309,
5780 120, 25, 1051, 98, 286, 25, 154, 155, 25, 230,
5781 158, 1063, 1179, 27, 969, 56, 336, 337, 338, 339,
5782 1137, 341, 342, 13, 230, 155, 256, 157, 258, 485,
5783 236, 237, 304, 13, 1083, 1062, 1085, 155, 687, 688,
5784 246, 999, 286, 13, 1299, 155, 267, 253, 26, 304,
5785 256, 13, 284, 154, 256, 237, 258, 155, 674, 160,
5786 1137, 267, 267, 284, 228, 151, 13, 231, 232, 233,
5787 258, 664, 721, 154, 273, 274, 303, 155, 284, 160,
5788 1003, 756, 675, 304, 759, 820, 749, 750, 408, 709,
5789 30, 711, 66, 711, 284, 709, 845, 155, 412, 856,
5790 13, 154, 850, 1180, 424, 236, 237, 417, 363, 665,
5791 1187, 1188, 860, 334, 540, 258, 542, 154, 1136, 155,
5792 676, 157, 161, 160, 306, 1025, 1026, 1294, 604, 334,
5793 362, 1298, 1299, 154, 155, 155, 1185, 1186, 155, 160,
5794 154, 362, 363, 363, 921, 119, 160, 15, 909, 17,
5795 336, 337, 338, 339, 1136, 921, 362, 98, 803, 943,
5796 944, 66, 1187, 1188, 154, 949, 950, 953, 412, 399,
5797 160, 69, 362, 151, 154, 400, 652, 409, 410, 157,
5798 160, 402, 658, 659, 154, 28, 13, 157, 409, 410,
5799 160, 1358, 154, 399, 1003, 157, 402, 52, 160, 97,
5800 98, 56, 401, 409, 410, 825, 983, 154, 1080, 1081,
5801 25, 825, 153, 160, 119, 134, 157, 974, 761, 1296,
5802 450, 427, 408, 766, 109, 69, 294, 295, 101, 454,
5803 100, 299, 155, 301, 1084, 83, 84, 1137, 424, 100,
5804 903, 154, 905, 699, 474, 154, 69, 160, 450, 1033,
5805 475, 160, 524, 97, 98, 153, 141, 912, 913, 157,
5806 709, 916, 450, 918, 134, 920, 66, 134, 474, 524,
5807 495, 1296, 726, 134, 1022, 98, 501, 483, 134, 485,
5808 1180, 154, 470, 112, 495, 155, 507, 1187, 1188, 137,
5809 138, 495, 154, 100, 943, 944, 526, 159, 155, 155,
5810 949, 950, 527, 524, 780, 469, 470, 450, 784, 153,
5811 1182, 1183, 738, 56, 478, 547, 930, 743, 157, 134,
5812 526, 121, 122, 511, 1342, 265, 547, 154, 1286, 134,
5813 52, 1280, 553, 160, 56, 607, 1084, 1187, 1188, 154,
5814 155, 547, 1151, 158, 100, 938, 66, 511, 553, 605,
5815 514, 595, 607, 100, 610, 101, 100, 822, 678, 25,
5816 100, 161, 155, 593, 570, 830, 596, 573, 844, 1018,
5817 990, 847, 990, 594, 134, 967, 597, 69, 134, 100,
5818 1280, 937, 100, 939, 1033, 861, 607, 134, 594, 1347,
5819 134, 597, 100, 155, 134, 715, 1296, 157, 1155, 1062,
5820 1063, 121, 122, 605, 124, 97, 98, 69, 610, 1064,
5821 1065, 1066, 1067, 657, 1162, 155, 134, 1165, 37, 38,
5822 360, 585, 654, 100, 656, 365, 134, 883, 157, 100,
5823 69, 687, 688, 654, 664, 656, 98, 1185, 644, 992,
5824 665, 605, 641, 649, 25, 675, 610, 155, 654, 992,
5825 656, 676, 1213, 1045, 1215, 727, 677, 134, 664, 98,
5826 1003, 153, 641, 134, 689, 721, 1082, 736, 134, 675,
5827 649, 677, 727, 1282, 992, 157, 1151, 1286, 689, 69,
5828 686, 69, 154, 155, 960, 689, 1177, 963, 154, 155,
5829 157, 157, 158, 699, 970, 69, 1187, 1188, 100, 154,
5830 976, 69, 157, 813, 100, 1058, 727, 686, 98, 97,
5831 98, 1259, 1260, 1261, 720, 1058, 26, 457, 458, 1276,
5832 719, 709, 1151, 97, 98, 1151, 69, 691, 468, 97,
5833 98, 803, 134, 853, 1126, 855, 476, 477, 134, 78,
5834 1058, 865, 1351, 69, 738, 709, 740, 711, 803, 743,
5835 744, 158, 69, 134, 97, 98, 496, 1212, 626, 69,
5836 159, 1309, 502, 1324, 69, 153, 100, 152, 1184, 154,
5837 69, 97, 98, 154, 155, 643, 134, 158, 1054, 153,
5838 97, 98, 803, 152, 69, 153, 69, 97, 98, 69,
5839 66, 67, 97, 98, 785, 863, 69, 788, 97, 98,
5840 134, 765, 69, 56, 69, 1280, 157, 1282, 1151, 155,
5841 854, 1286, 1204, 98, 97, 98, 1291, 97, 98, 161,
5842 69, 155, 1025, 1026, 97, 98, 832, 153, 834, 793,
5843 836, 98, 58, 98, 702, 856, 153, 825, 863, 959,
5844 926, 151, 928, 153, 66, 121, 122, 157, 153, 98,
5845 856, 1280, 78, 1282, 153, 100, 1282, 1286, 726, 78,
5846 1286, 825, 1291, 731, 598, 1291, 289, 853, 602, 855,
5847 153, 1264, 1347, 153, 1349, 890, 1351, 883, 1353, 843,
5848 153, 1084, 108, 109, 69, 100, 1294, 943, 944, 134,
5849 1298, 921, 151, 949, 950, 1370, 134, 119, 1101, 121,
5850 122, 134, 124, 909, 100, 134, 54, 775, 938, 1265,
5851 155, 651, 106, 98, 939, 141, 64, 65, 1347, 134,
5852 1349, 1347, 1351, 1349, 1353, 1351, 958, 1353, 155, 973,
5853 1206, 975, 938, 56, 1137, 66, 160, 958, 134, 1282,
5854 155, 1370, 25, 1286, 1370, 154, 155, 953, 14, 15,
5855 690, 953, 958, 974, 89, 90, 761, 1160, 138, 155,
5856 134, 993, 1018, 40, 41, 1, 930, 772, 974, 922,
5857 923, 26, 993, 959, 1177, 154, 155, 1033, 931, 15,
5858 16, 934, 850, 936, 1187, 1188, 155, 993, 119, 953,
5859 121, 122, 860, 69, 134, 1016, 1017, 1012, 1013, 305,
5860 306, 965, 155, 158, 1025, 1026, 152, 875, 1351, 1087,
5861 69, 1016, 1017, 155, 69, 158, 52, 53, 1050, 1088,
5862 56, 97, 98, 155, 78, 155, 990, 450, 155, 1050,
5863 155, 67, 134, 155, 1040, 52, 1042, 155, 97, 98,
5864 52, 152, 97, 98, 1050, 1321, 54, 55, 155, 57,
5865 1014, 155, 13, 89, 1174, 17, 64, 65, 481, 1080,
5866 1081, 484, 25, 1084, 1070, 1071, 489, 103, 104, 66,
5867 1125, 107, 108, 109, 110, 155, 112, 153, 818, 819,
5868 1101, 504, 1192, 1197, 152, 1049, 826, 827, 142, 143,
5869 144, 145, 146, 155, 153, 134, 151, 44, 153, 44,
5870 1132, 1133, 157, 152, 1125, 155, 1138, 155, 1129, 44,
5871 56, 1132, 1133, 44, 134, 1197, 1137, 1138, 66, 159,
5872 1152, 136, 119, 1129, 121, 122, 1132, 1133, 15, 8,
5873 1136, 1152, 1138, 155, 1155, 52, 155, 877, 878, 1160,
5874 880, 881, 1163, 152, 155, 155, 1152, 101, 155, 1155,
5875 155, 1271, 1272, 1197, 1022, 578, 1177, 1178, 1179, 66,
5876 155, 1182, 1183, 155, 1196, 155, 1187, 1188, 1246, 1224,
5877 1134, 119, 9, 121, 122, 1196, 124, 52, 1210, 54,
5878 55, 56, 57, 606, 155, 26, 66, 139, 1174, 1210,
5879 1196, 52, 152, 1199, 230, 935, 1001, 139, 1003, 155,
5880 1005, 52, 155, 1224, 1210, 155, 101, 1213, 948, 1215,
5881 56, 160, 119, 152, 121, 122, 1084, 1085, 687, 688,
5882 256, 158, 258, 155, 139, 261, 262, 102, 69, 155,
5883 1285, 267, 107, 155, 1264, 155, 705, 706, 56, 119,
5884 1265, 121, 122, 155, 155, 155, 986, 155, 284, 155,
5885 155, 155, 721, 155, 155, 1276, 97, 98, 1264, 682,
5886 1266, 157, 1268, 157, 1285, 1025, 1026, 155, 304, 267,
5887 1276, 334, 1140, 1294, 1129, 503, 66, 1298, 1299, 863,
5888 106, 605, 1314, 108, 507, 1271, 1272, 110, 98, 496,
5889 1223, 686, 1225, 1314, 1162, 954, 973, 1165, 334, 1199,
5890 336, 337, 338, 339, 749, 341, 342, 903, 1314, 1222,
5891 151, 1151, 153, 1286, 1280, 1071, 157, 1185, 1324, 1221,
5892 1080, 1081, 1178, 358, 1084, 1343, 362, 363, 866, 119,
5893 753, 121, 122, 1342, 1180, 1180, 1342, 1358, 1176, 1266,
5894 1268, 1101, 119, 1148, 542, 111, 1151, 52, 759, 54,
5895 55, 56, 57, 1221, 766, 52, 115, 54, 55, 56,
5896 57, 58, -1, 399, -1, 52, 402, 54, 55, 1337,
5897 57, -1, 408, 409, 410, -1, -1, 1137, -1, -1,
5898 52, 78, 54, 55, 56, 57, -1, -1, 424, -1,
5899 -1, 1259, 1260, 1261, 1327, 1328, -1, 102, 1331, 1332,
5900 1160, -1, 1335, 1163, 873, 102, 59, 60, 61, 62,
5901 107, 108, 109, -1, 450, 102, -1, 1177, 1178, 1179,
5902 -1, -1, 1182, 1183, -1, -1, -1, 1187, 1188, 1169,
5903 -1, 1364, 1365, 1366, 1367, -1, -1, -1, 474, 862,
5904 1373, 1309, -1, -1, 141, -1, -1, 144, 1, -1,
5905 1318, -1, -1, -1, 1025, 1026, -1, -1, -1, 882,
5906 -1, 884, 15, 16, 40, 41, 42, 43, 44, 1337,
5907 -1, 507, -1, -1, 943, 944, -1, 1282, 901, -1,
5908 949, 950, -1, -1, -1, -1, 1291, -1, 524, 52,
5909 526, 54, 55, 56, 57, -1, -1, -1, -1, 52,
5910 53, -1, -1, -1, -1, -1, -1, -1, -1, 1080,
5911 1081, 547, -1, 1084, 67, 984, 985, 553, 987, 988,
5912 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5913 1101, -1, -1, -1, 1294, -1, -1, -1, 1298, 1299,
5914 -1, -1, -1, -1, 1349, -1, 1351, -1, 1353, -1,
5915 103, 104, -1, -1, 107, -1, -1, 593, 594, 112,
5916 596, 597, -1, -1, 1033, 1370, 1137, -1, -1, 605,
5917 -1, 607, -1, -1, 610, 52, -1, 54, 55, 56,
5918 57, 58, -1, -1, -1, -1, -1, -1, 1057, 1160,
5919 -1, -1, 1163, -1, 1025, 1026, -1, -1, 1358, -1,
5920 -1, 78, -1, -1, -1, -1, 1177, 1178, 1179, -1,
5921 -1, 1182, 1183, -1, -1, 92, 1187, 1188, 654, -1,
5922 656, -1, -1, -1, -1, 102, -1, -1, 664, -1,
5923 107, 108, 109, -1, -1, -1, -1, -1, -1, 675,
5924 -1, 677, 678, -1, -1, -1, -1, -1, -1, 1080,
5925 1081, 687, 688, 1084, -1, -1, -1, -1, -1, -1,
5926 -1, -1, -1, -1, 141, -1, -1, 144, -1, -1,
5927 1101, -1, -1, -1, -1, -1, -1, 230, -1, 715,
5928 157, -1, -1, -1, 52, 721, 54, 55, 56, 57,
5929 58, 727, -1, 52, -1, 54, 55, 56, 57, 58,
5930 -1, -1, -1, 256, 78, 258, 1137, -1, 261, 262,
5931 78, -1, -1, -1, 267, -1, -1, -1, -1, 78,
5932 -1, 95, 96, 1294, 92, -1, -1, 1298, 1299, 1160,
5933 -1, 284, 1163, 92, 102, -1, -1, -1, -1, 107,
5934 108, 109, -1, 102, -1, -1, 1177, 1178, 1179, 108,
5935 109, 1182, 1183, -1, -1, -1, 1187, 1188, -1, -1,
5936 -1, 78, -1, 1186, -1, -1, -1, 803, 142, 143,
5937 144, 145, 146, 141, 78, -1, 144, -1, 95, 96,
5938 -1, 334, 141, 336, 337, 338, 339, 1358, 341, 342,
5939 -1, 95, 96, -1, -1, 52, -1, 54, 55, 56,
5940 57, 58, -1, -1, -1, -1, 1229, -1, -1, 362,
5941 -1, -1, -1, -1, -1, -1, 1239, 853, -1, 855,
5942 856, 78, 139, 140, 141, 142, 143, 144, 145, 146,
5943 -1, -1, -1, 1256, 1257, 1258, -1, 141, 142, 143,
5944 144, 145, 146, -1, -1, 102, 399, -1, -1, 402,
5945 -1, 108, 109, -1, -1, 408, 409, 410, -1, -1,
5946 -1, -1, -1, 1294, -1, -1, -1, 1298, 1299, -1,
5947 -1, 424, -1, 1025, 1026, -1, -1, -1, -1, -1,
5948 -1, -1, -1, -1, 141, 921, -1, -1, -1, -1,
5949 -1, -1, -1, -1, -1, -1, -1, 450, -1, -1,
5950 -1, -1, 938, -1, -1, -1, -1, 943, 944, -1,
5951 1, 1025, 1026, 949, 950, -1, -1, -1, -1, -1,
5952 -1, 474, 958, 959, 15, 16, -1, 1358, 1080, 1081,
5953 -1, -1, 1084, -1, -1, -1, -1, -1, 974, -1,
5954 -1, -1, -1, -1, -1, -1, -1, -1, -1, 1101,
5955 -1, -1, -1, -1, 507, -1, -1, 993, -1, -1,
5956 -1, 52, 53, -1, -1, -1, 1080, 1081, -1, -1,
5957 1084, -1, -1, 526, -1, -1, 67, -1, -1, -1,
5958 1016, 1017, 1018, -1, -1, 1137, -1, 1101, -1, -1,
5959 -1, -1, -1, -1, 547, -1, -1, 1033, -1, -1,
5960 553, -1, -1, -1, -1, -1, -1, -1, 1160, -1,
5961 -1, 1163, 103, 104, 1050, -1, 107, -1, -1, -1,
5962 -1, 112, -1, 1137, -1, 1177, 1178, 1179, -1, -1,
5963 1182, 1183, -1, -1, -1, 1187, 1188, -1, -1, -1,
5964 593, 594, -1, 596, 597, -1, 1160, -1, -1, 1163,
5965 -1, -1, 605, -1, -1, -1, -1, 610, -1, -1,
5966 -1, -1, -1, 1177, 1178, 1179, -1, -1, 1182, 1183,
5967 -1, -1, -1, 1187, 1188, -1, -1, -1, -1, -1,
5968 -1, -1, -1, -1, -1, -1, -1, -1, -1, 1125,
5969 -1, -1, -1, 1129, -1, -1, 1132, 1133, -1, -1,
5970 -1, 654, 1138, 656, -1, -1, -1, -1, -1, -1,
5971 -1, 664, -1, -1, -1, -1, 1152, -1, -1, 1155,
5972 -1, -1, 675, -1, 677, 678, -1, -1, -1, -1,
5973 -1, -1, -1, -1, 687, 688, -1, -1, 1174, 230,
5974 -1, -1, 1294, -1, -1, -1, 1298, 1299, -1, -1,
5975 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5976 1196, -1, 715, -1, -1, 256, -1, 258, 721, -1,
5977 261, 262, -1, -1, 1210, -1, 267, -1, -1, -1,
5978 1294, -1, -1, -1, 1298, 1299, -1, -1, 1224, -1,
5979 -1, -1, -1, 284, -1, -1, -1, -1, -1, -1,
5980 -1, -1, -1, 1025, 1026, -1, 1358, -1, -1, -1,
5981 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5982 -1, -1, -1, -1, -1, -1, -1, -1, 1264, -1,
5983 -1, -1, -1, -1, -1, 1271, 1272, -1, -1, -1,
5984 1276, -1, -1, 334, 1358, 336, 337, 338, 339, 1285,
5985 341, 342, -1, -1, -1, -1, -1, -1, 1080, 1081,
5986 -1, -1, 1084, 78, 79, 80, 81, 82, 83, 84,
5987 85, 362, 87, 88, -1, -1, -1, -1, 1314, 1101,
5988 95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
5989 -1, -1, -1, -1, -1, 1025, 1026, -1, -1, -1,
5990 853, -1, 855, 856, -1, -1, -1, -1, 399, -1,
5991 -1, 402, -1, -1, -1, 1137, -1, 408, 409, 410,
5992 -1, -1, 137, 138, 139, 140, 141, 142, 143, 144,
5993 145, 146, -1, 424, -1, -1, -1, -1, 1160, -1,
5994 -1, 1163, -1, -1, -1, -1, -1, -1, 1, -1,
5995 1080, 1081, -1, -1, 1084, 1177, 1178, 1179, -1, 450,
5996 1182, 1183, 15, 16, -1, 1187, 1188, -1, 921, -1,
5997 -1, 1101, -1, -1, -1, -1, -1, -1, -1, -1,
5998 -1, -1, -1, 474, -1, 938, -1, -1, -1, -1,
5999 943, 944, -1, -1, -1, -1, 949, 950, -1, 52,
6000 53, -1, -1, -1, -1, 958, 959, 1137, -1, -1,
6001 -1, -1, -1, -1, 67, -1, 507, -1, -1, -1,
6002 -1, 974, -1, -1, -1, -1, -1, -1, 25, -1,
6003 1160, -1, -1, 1163, -1, 526, -1, -1, -1, -1,
6004 993, -1, -1, -1, -1, -1, -1, 1177, 1178, 1179,
6005 103, 104, 1182, 1183, 107, -1, 547, 1187, 1188, 112,
6006 -1, -1, 553, 1016, 1017, 1018, -1, -1, -1, -1,
6007 -1, -1, 1294, -1, -1, -1, 1298, 1299, -1, -1,
6008 1033, 78, 79, 80, 81, 82, 83, 84, 85, 86,
6009 87, 88, 89, 90, -1, -1, -1, 1050, 95, 96,
6010 -1, -1, 593, 594, 101, 596, 597, -1, -1, -1,
6011 -1, -1, -1, -1, 605, -1, -1, -1, -1, 610,
6012 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6013 -1, -1, -1, -1, -1, -1, 1358, -1, 135, -1,
6014 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
6015 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6016 -1, -1, -1, 654, 1294, 656, -1, -1, 1298, 1299,
6017 -1, -1, -1, 664, -1, -1, 1129, 230, -1, 1132,
6018 1133, -1, -1, -1, 675, 1138, 677, 678, -1, -1,
6019 -1, -1, -1, -1, -1, -1, 687, 688, -1, 1152,
6020 -1, -1, 1155, 256, -1, 258, -1, -1, 261, 262,
6021 -1, -1, -1, -1, 267, 1025, 1026, -1, -1, -1,
6022 -1, 1174, -1, -1, 715, -1, -1, -1, 1358, -1,
6023 721, 284, -1, -1, -1, -1, -1, -1, -1, -1,
6024 -1, -1, -1, 1196, -1, -1, 1025, 1026, -1, -1,
6025 -1, -1, -1, -1, -1, -1, -1, 1210, -1, -1,
6026 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6027 1080, 1081, -1, -1, 1084, -1, -1, -1, -1, -1,
6028 -1, 334, -1, 336, 337, 338, 339, -1, 341, 342,
6029 -1, 1101, -1, -1, -1, -1, -1, -1, -1, -1,
6030 -1, 1080, 1081, -1, -1, 1084, -1, -1, -1, 362,
6031 -1, 1264, -1, -1, -1, -1, -1, -1, 1271, 1272,
6032 -1, -1, 1101, 1276, 1, -1, -1, 1137, -1, -1,
6033 -1, -1, -1, -1, -1, -1, 1, -1, -1, -1,
6034 -1, -1, -1, -1, -1, -1, 399, -1, -1, 402,
6035 1160, -1, -1, 1163, -1, 408, 409, 410, 1137, -1,
6036 -1, 1314, 853, -1, 855, 856, -1, 1177, 1178, 1179,
6037 -1, 424, 1182, 1183, -1, 52, 53, 1187, 1188, 56,
6038 -1, 1160, -1, -1, 1163, -1, -1, 52, 53, -1,
6039 -1, 56, -1, -1, -1, -1, -1, 450, 1177, 1178,
6040 1179, -1, -1, 1182, 1183, -1, -1, -1, 1187, 1188,
6041 -1, -1, 89, -1, -1, -1, -1, -1, -1, -1,
6042 -1, 474, -1, -1, 89, -1, -1, -1, -1, -1,
6043 921, 108, 109, 110, -1, -1, -1, -1, -1, -1,
6044 -1, -1, -1, 108, 109, 110, -1, 938, -1, -1,
6045 -1, -1, 943, 944, 507, -1, -1, -1, 949, 950,
6046 -1, -1, -1, -1, -1, -1, -1, 958, 959, -1,
6047 -1, -1, -1, 526, -1, -1, -1, -1, -1, -1,
6048 -1, -1, -1, 974, 1294, -1, -1, -1, 1298, 1299,
6049 -1, -1, -1, -1, 547, -1, -1, -1, -1, -1,
6050 553, -1, 993, -1, -1, -1, -1, -1, -1, -1,
6051 -1, -1, -1, -1, -1, 1294, -1, -1, -1, 1298,
6052 1299, -1, -1, -1, -1, 1016, 1017, 1018, -1, -1,
6053 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6054 593, 594, 1033, 596, 597, -1, -1, -1, 1358, -1,
6055 -1, -1, 605, 230, -1, -1, -1, 610, -1, 1050,
6056 -1, -1, -1, -1, -1, 230, -1, -1, -1, -1,
6057 -1, -1, -1, -1, -1, -1, -1, -1, -1, 1358,
6058 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6059 267, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6060 -1, 654, 267, 656, -1, -1, -1, 284, -1, -1,
6061 -1, 664, -1, -1, -1, -1, -1, -1, -1, 284,
6062 -1, -1, 675, -1, 677, 678, -1, 304, -1, -1,
6063 -1, -1, -1, -1, 687, 688, -1, -1, 1129, 304,
6064 -1, 1132, 1133, -1, -1, -1, -1, 1138, -1, 78,
6065 79, 80, 81, 82, 83, 84, -1, 334, 87, 88,
6066 -1, 1152, 715, -1, 1155, -1, 95, 96, 721, 334,
6067 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6068 -1, -1, -1, 1174, -1, 362, 363, -1, -1, -1,
6069 -1, -1, -1, -1, -1, -1, -1, 362, 363, -1,
6070 -1, -1, 1, -1, -1, 1196, -1, -1, 137, 138,
6071 139, 140, 141, 142, 143, 144, 145, 146, -1, 1210,
6072 -1, -1, -1, -1, -1, 402, -1, -1, -1, -1,
6073 -1, -1, 409, 410, -1, -1, -1, 402, -1, -1,
6074 -1, -1, -1, -1, 409, 410, -1, -1, -1, -1,
6075 -1, -1, -1, 52, 53, -1, -1, 56, -1, -1,
6076 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6077 -1, -1, -1, 1264, -1, -1, -1, -1, -1, -1,
6078 1271, 1272, -1, -1, -1, 1276, -1, -1, -1, -1,
6079 89, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6080 853, -1, 855, 856, -1, -1, -1, -1, -1, 108,
6081 109, 110, -1, -1, -1, -1, -1, -1, -1, -1,
6082 -1, -1, -1, 1314, -1, -1, -1, -1, -1, -1,
6083 507, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6084 -1, -1, 507, -1, -1, -1, -1, 524, 78, 79,
6085 80, 81, 82, 83, 84, -1, -1, 87, 88, 524,
6086 -1, -1, -1, -1, -1, 95, 96, -1, 921, -1,
6087 547, -1, -1, -1, -1, -1, 553, -1, -1, -1,
6088 -1, -1, 547, -1, -1, 938, -1, -1, 553, -1,
6089 943, 944, -1, -1, -1, -1, 949, 950, -1, -1,
6090 -1, -1, -1, -1, -1, 958, 959, 137, 138, 139,
6091 140, 141, 142, 143, 144, 145, 146, 594, -1, -1,
6092 597, 974, -1, -1, -1, -1, -1, -1, -1, 594,
6093 607, 230, 597, 610, -1, -1, -1, -1, -1, -1,
6094 993, -1, 607, -1, -1, 610, -1, -1, -1, -1,
6095 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6096 -1, -1, -1, 1016, 1017, 1018, -1, -1, 267, -1,
6097 -1, -1, -1, -1, -1, -1, -1, 654, -1, 656,
6098 1033, -1, -1, -1, -1, 284, 1, -1, -1, 654,
6099 -1, 656, -1, -1, -1, -1, -1, 1050, -1, -1,
6100 677, -1, -1, -1, -1, 304, -1, -1, -1, -1,
6101 687, 688, 677, -1, -1, -1, -1, -1, -1, -1,
6102 -1, -1, 687, 688, -1, -1, -1, -1, -1, -1,
6103 -1, -1, -1, -1, -1, 334, -1, 52, 53, -1,
6104 -1, 56, -1, -1, 721, -1, -1, -1, -1, -1,
6105 727, -1, -1, -1, -1, -1, 721, -1, -1, 736,
6106 -1, -1, 727, 362, 363, -1, -1, -1, -1, -1,
6107 -1, -1, -1, -1, 89, -1, 1129, -1, -1, 1132,
6108 1133, -1, -1, -1, -1, 1138, -1, -1, -1, 33,
6109 34, 35, 36, 108, 109, 110, 111, -1, -1, 1152,
6110 -1, -1, 1155, 402, -1, 49, 50, 51, 52, -1,
6111 409, 410, 56, -1, -1, 59, 60, 61, 62, 63,
6112 -1, 1174, -1, -1, -1, -1, 803, -1, -1, -1,
6113 -1, -1, -1, -1, -1, -1, -1, -1, 803, -1,
6114 -1, -1, -1, 1196, -1, -1, -1, 91, 92, -1,
6115 -1, -1, -1, -1, -1, 99, -1, 1210, 102, -1,
6116 104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
6117 114, 115, 116, 117, 118, -1, -1, -1, -1, 856,
6118 -1, -1, -1, -1, -1, -1, -1, 1, -1, -1,
6119 -1, 856, -1, -1, -1, -1, 140, -1, -1, -1,
6120 -1, -1, -1, 147, -1, -1, -1, -1, 507, -1,
6121 154, 1264, -1, -1, -1, 230, -1, -1, 1271, 1272,
6122 -1, -1, -1, 1276, -1, 524, -1, -1, -1, -1,
6123 -1, -1, -1, -1, -1, -1, -1, -1, 52, 53,
6124 -1, -1, -1, -1, -1, -1, -1, -1, 547, -1,
6125 -1, -1, 267, -1, 553, -1, -1, -1, -1, -1,
6126 -1, 1314, -1, -1, -1, -1, 943, 944, -1, 284,
6127 -1, -1, 949, 950, -1, -1, -1, -1, 943, 944,
6128 -1, 958, -1, -1, 949, 950, -1, -1, -1, 304,
6129 -1, -1, -1, 958, 108, 594, -1, 974, 597, -1,
6130 -1, -1, -1, -1, -1, -1, -1, -1, 607, 974,
6131 -1, 610, -1, -1, -1, -1, 993, -1, -1, 334,
6132 -1, -1, -1, -1, -1, -1, -1, -1, 993, -1,
6133 -1, -1, -1, -1, -1, -1, -1, -1, -1, 1016,
6134 1017, 1018, -1, -1, -1, -1, -1, 362, 363, -1,
6135 -1, 1016, 1017, 1018, -1, 654, 1033, 656, -1, -1,
6136 -1, -1, -1, -1, -1, -1, -1, -1, 1033, -1,
6137 -1, -1, -1, 1050, -1, -1, -1, -1, 677, -1,
6138 -1, -1, -1, -1, -1, 1050, -1, 402, 687, 688,
6139 -1, -1, -1, -1, 409, 410, -1, -1, -1, -1,
6140 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6141 -1, -1, -1, -1, 1, -1, 230, -1, -1, -1,
6142 -1, -1, 721, -1, -1, -1, -1, -1, 727, -1,
6143 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6144 -1, -1, -1, -1, -1, -1, -1, -1, 1125, -1,
6145 -1, -1, 1129, 267, -1, 1132, 1133, -1, -1, -1,
6146 1125, 1138, -1, -1, 1129, 52, 53, 1132, 1133, -1,
6147 284, -1, -1, 1138, -1, 1152, -1, -1, 1155, -1,
6148 -1, -1, -1, -1, -1, -1, -1, 1152, -1, -1,
6149 1155, -1, 507, -1, -1, -1, -1, -1, -1, -1,
6150 -1, -1, -1, -1, 803, -1, -1, -1, -1, 524,
6151 -1, -1, -1, -1, -1, -1, -1, -1, -1, 1196,
6152 334, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6153 -1, 1196, 547, 1210, -1, -1, -1, -1, 553, -1,
6154 -1, -1, -1, -1, -1, 1210, -1, 1224, 362, -1,
6155 -1, -1, -1, -1, -1, -1, -1, 856, -1, 1224,
6156 -1, -1, -1, -1, -1, -1, 78, 79, 80, 81,
6157 82, 83, 84, 85, 86, 87, 88, 89, 90, 594,
6158 -1, -1, 597, 95, 96, -1, -1, -1, 402, -1,
6159 -1, -1, 607, -1, -1, 409, 410, -1, -1, 1276,
6160 -1, -1, -1, -1, -1, -1, -1, -1, 1285, -1,
6161 -1, 1276, -1, -1, -1, -1, -1, -1, -1, -1,
6162 1285, -1, -1, 135, -1, 137, 138, 139, 140, 141,
6163 142, 143, 144, 145, 146, -1, -1, 1314, -1, 654,
6164 -1, 656, 154, 230, 943, 944, -1, -1, -1, 1314,
6165 949, 950, -1, -1, -1, -1, -1, -1, -1, 958,
6166 -1, -1, 677, -1, 44, -1, -1, -1, -1, -1,
6167 -1, -1, -1, -1, -1, 974, -1, -1, -1, -1,
6168 267, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6169 -1, -1, -1, 507, 993, -1, -1, 284, 78, 79,
6170 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6171 90, -1, 727, -1, -1, 95, 96, 1016, 1017, 1018,
6172 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6173 -1, -1, -1, 547, 1033, -1, -1, -1, -1, 553,
6174 -1, -1, -1, -1, -1, -1, -1, 334, -1, -1,
6175 -1, 1050, -1, -1, -1, 135, -1, 137, 138, 139,
6176 140, 141, 142, 143, 144, 145, 146, -1, -1, -1,
6177 -1, -1, -1, -1, -1, 362, -1, -1, -1, -1,
6178 594, -1, -1, 597, -1, -1, -1, -1, 803, -1,
6179 -1, -1, -1, -1, -1, -1, 610, -1, -1, -1,
6180 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6181 -1, -1, -1, -1, -1, 402, -1, -1, -1, -1,
6182 -1, -1, 409, 410, -1, -1, 1125, -1, -1, -1,
6183 1129, -1, -1, 1132, 1133, -1, -1, -1, -1, 1138,
6184 654, 856, 656, -1, -1, -1, -1, -1, -1, -1,
6185 -1, -1, -1, 1152, -1, -1, 1155, -1, -1, -1,
6186 -1, -1, -1, 677, -1, -1, -1, -1, -1, -1,
6187 -1, -1, -1, 687, 688, -1, -1, -1, -1, -1,
6188 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6189 -1, -1, -1, -1, -1, -1, -1, 1196, -1, -1,
6190 -1, -1, -1, -1, -1, -1, -1, 721, -1, -1,
6191 -1, 1210, -1, -1, 0, -1, -1, -1, -1, -1,
6192 507, -1, 8, 9, 10, 1224, -1, 13, 14, 15,
6193 -1, 17, -1, -1, -1, -1, -1, -1, -1, 25,
6194 26, 27, -1, 958, -1, -1, -1, -1, -1, -1,
6195 -1, 37, 38, 44, 40, 41, 42, 43, 44, 974,
6196 547, -1, -1, -1, -1, -1, 553, -1, -1, -1,
6197 -1, -1, -1, -1, -1, -1, -1, 1276, 993, -1,
6198 -1, -1, 68, 69, -1, -1, 1285, 78, 79, 80,
6199 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
6200 -1, 1016, 1017, -1, 95, 96, -1, 594, -1, -1,
6201 597, 97, 98, -1, -1, 1314, -1, -1, -1, -1,
6202 -1, -1, -1, 610, -1, -1, -1, -1, -1, -1,
6203 -1, -1, -1, -1, 120, 1050, -1, -1, -1, -1,
6204 -1, -1, 856, -1, 135, -1, 137, 138, 139, 140,
6205 141, 142, 143, 144, 145, 146, -1, -1, -1, -1,
6206 -1, -1, -1, -1, 155, 151, 152, 654, 154, 656,
6207 -1, 157, 158, -1, 160, -1, -1, -1, -1, -1,
6208 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6209 677, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6210 687, 688, -1, -1, -1, -1, -1, -1, -1, -1,
6211 1125, -1, -1, -1, 1129, -1, -1, 1132, 1133, -1,
6212 -1, -1, -1, 1138, -1, -1, -1, -1, -1, 943,
6213 944, 15, 16, -1, 721, 949, 950, 1152, -1, -1,
6214 1155, -1, -1, -1, 958, -1, -1, -1, -1, -1,
6215 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6216 974, -1, -1, 47, 48, 49, 50, -1, -1, -1,
6217 54, 55, -1, -1, -1, -1, -1, -1, -1, 993,
6218 -1, 1196, -1, 67, 68, -1, -1, -1, -1, -1,
6219 -1, -1, -1, -1, -1, 1210, -1, -1, -1, -1,
6220 -1, -1, 1016, 1017, 1018, -1, -1, -1, -1, 1224,
6221 -1, -1, -1, -1, -1, -1, -1, -1, -1, 1033,
6222 -1, -1, -1, 33, 34, 35, 36, -1, 112, -1,
6223 -1, -1, -1, -1, -1, -1, 1050, -1, -1, 49,
6224 50, 51, 52, -1, -1, -1, 56, -1, 58, 59,
6225 60, 61, 62, 63, -1, -1, -1, -1, -1, -1,
6226 -1, 1276, -1, -1, -1, -1, -1, -1, 78, 856,
6227 1285, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6228 -1, 91, 92, -1, -1, -1, -1, -1, -1, 99,
6229 -1, -1, 102, -1, 104, 105, -1, 107, 108, 1314,
6230 110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
6231 -1, 1125, -1, -1, -1, 1129, -1, -1, 1132, 1133,
6232 -1, -1, -1, -1, 1138, -1, -1, -1, -1, -1,
6233 140, -1, -1, -1, -1, -1, -1, 147, 1152, -1,
6234 -1, 1155, -1, -1, 228, -1, -1, 231, 232, 233,
6235 -1, 235, -1, -1, -1, -1, 943, 944, -1, -1,
6236 -1, -1, 949, 950, -1, -1, -1, -1, -1, -1,
6237 -1, 958, 256, -1, 258, 33, 34, 35, 36, -1,
6238 -1, -1, 1196, -1, 52, 53, -1, 974, 56, -1,
6239 -1, 49, 50, 51, -1, -1, 1210, -1, -1, -1,
6240 -1, 59, 60, 61, 62, 63, 993, -1, 76, 77,
6241 78, 79, 80, 81, 82, 83, 84, -1, -1, 87,
6242 88, -1, -1, -1, -1, 93, 94, 95, 96, 1016,
6243 1017, 1018, -1, -1, -1, -1, -1, -1, -1, 107,
6244 108, -1, -1, -1, -1, -1, 1033, -1, -1, -1,
6245 -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
6246 118, -1, 1276, 1050, -1, -1, -1, -1, -1, 137,
6247 138, 139, 140, 141, 142, 143, 144, 145, 146, -1,
6248 148, 149, -1, 367, 368, 369, 370, 371, 156, 147,
6249 374, 375, 376, 377, 378, 379, 380, 381, -1, 383,
6250 1314, -1, 386, 387, 388, 389, 390, 391, 392, 393,
6251 394, 395, -1, -1, -1, 399, 78, 79, 80, 81,
6252 82, 83, 84, 85, 86, 87, 88, 89, 90, -1,
6253 -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
6254 -1, -1, 1129, -1, -1, 1132, 1133, -1, -1, -1,
6255 -1, 1138, -1, -1, -1, -1, -1, -1, -1, -1,
6256 -1, -1, -1, -1, -1, 1152, 450, -1, 1155, -1,
6257 -1, -1, -1, 135, -1, 137, 138, 139, 140, 141,
6258 142, 143, 144, 145, 146, 469, 470, -1, -1, -1,
6259 474, -1, -1, -1, 478, -1, 480, -1, -1, -1,
6260 -1, -1, -1, -1, -1, -1, -1, -1, -1, 1196,
6261 -1, -1, -1, -1, 498, -1, -1, -1, -1, -1,
6262 -1, -1, -1, 1210, -1, -1, -1, 511, -1, -1,
6263 514, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6264 -1, -1, 526, -1, -1, -1, -1, -1, -1, -1,
6265 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6266 544, -1, -1, -1, 33, 34, 35, 36, -1, -1,
6267 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6268 49, 50, 51, 52, -1, -1, -1, 56, -1, 1276,
6269 59, 60, 61, 62, 63, -1, -1, -1, -1, -1,
6270 -1, 585, -1, -1, -1, -1, -1, -1, -1, 593,
6271 -1, -1, 596, -1, -1, -1, -1, -1, -1, -1,
6272 -1, 605, 91, 92, -1, -1, 610, 1314, -1, -1,
6273 99, -1, -1, 102, -1, 104, 105, -1, 107, -1,
6274 -1, 110, 111, 112, 113, 114, 115, 116, 117, 118,
6275 -1, -1, -1, -1, -1, -1, -1, 52, 53, -1,
6276 -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
6277 -1, 140, -1, -1, -1, -1, -1, -1, 147, -1,
6278 664, 76, 77, 78, 79, 80, 81, 82, 83, 84,
6279 -1, 675, 87, 88, -1, -1, -1, -1, 93, 94,
6280 95, 96, -1, 687, 688, -1, -1, 691, 692, 693,
6281 694, -1, 107, 108, -1, -1, -1, -1, -1, -1,
6282 -1, 705, 706, -1, -1, 709, -1, 711, -1, -1,
6283 -1, -1, -1, -1, -1, -1, -1, 721, -1, -1,
6284 -1, -1, 137, 138, 139, 140, 141, 142, 143, 144,
6285 145, 146, -1, 148, 149, -1, -1, -1, -1, -1,
6286 -1, 156, -1, -1, -1, -1, -1, -1, -1, -1,
6287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6288 -1, 765, -1, -1, -1, -1, -1, -1, -1, -1,
6289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6290 -1, -1, -1, -1, -1, -1, -1, -1, -1, 793,
6291 -1, -1, -1, -1, -1, 0, 1, -1, 3, 4,
6292 5, 6, 7, 8, 9, 10, 11, 12, -1, 14,
6293 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
6294 25, 825, -1, -1, -1, 30, 31, 32, 33, 34,
6295 35, 36, -1, -1, 39, -1, -1, -1, -1, 843,
6296 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
6297 55, 56, 57, -1, 59, 60, 61, 62, 63, 64,
6298 65, -1, -1, 68, -1, -1, -1, -1, -1, 873,
6299 -1, 76, 77, -1, -1, -1, -1, -1, -1, -1,
6300 -1, -1, -1, -1, -1, -1, 91, 92, -1, -1,
6301 -1, -1, -1, -1, 99, -1, -1, 102, 103, 104,
6302 105, -1, 107, -1, -1, 110, 111, 112, 113, 114,
6303 115, 116, 117, 118, -1, 120, -1, 921, -1, -1,
6304 -1, -1, -1, -1, -1, -1, 930, -1, -1, -1,
6305 -1, -1, -1, -1, 938, -1, -1, -1, 942, 943,
6306 944, -1, 147, 148, 149, 949, 950, 152, -1, 953,
6307 -1, -1, -1, 158, -1, 160, -1, -1, -1, -1,
6308 -1, 965, -1, -1, -1, -1, -1, -1, -1, -1,
6309 -1, -1, -1, -1, -1, -1, -1, -1, -1, 983,
6310 984, 985, -1, 987, 988, -1, 990, -1, -1, -1,
6311 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6312 -1, -1, -1, -1, -1, -1, 1010, 1011, -1, -1,
6313 1014, -1, -1, -1, 1018, 1019, -1, -1, -1, -1,
6314 -1, -1, -1, -1, -1, -1, -1, -1, -1, 1033,
6315 -1, -1, -1, -1, -1, -1, 0, 1, -1, 3,
6316 4, 5, 6, 7, -1, 1049, -1, 11, 12, -1,
6317 -1, -1, 16, 1057, 18, 19, 20, 21, 22, 23,
6318 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
6319 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
6320 -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6321 54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
6322 64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
6323 -1, -1, 76, 77, -1, -1, -1, -1, -1, -1,
6324 -1, -1, -1, -1, -1, -1, -1, 91, 92, -1,
6325 1134, -1, -1, -1, -1, 99, -1, -1, 102, 103,
6326 104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
6327 114, 115, 116, 117, 118, -1, 120, -1, -1, -1,
6328 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6329 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6330 -1, -1, -1, 147, 148, 149, -1, -1, 0, 1,
6331 154, 3, 4, 5, 6, 7, 160, -1, -1, 11,
6332 12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
6333 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
6334 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
6335 -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
6336 52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
6337 62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
6338 1264, -1, -1, -1, 76, 77, -1, -1, -1, -1,
6339 -1, -1, -1, -1, -1, -1, -1, -1, -1, 91,
6340 92, -1, -1, -1, -1, -1, -1, 99, -1, -1,
6341 102, 103, 104, 105, -1, 107, -1, -1, 110, 111,
6342 112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
6343 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6344 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6345 -1, -1, -1, -1, -1, 147, 148, 149, -1, -1,
6346 0, 1, 154, 3, 4, 5, 6, 7, 160, -1,
6347 -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
6348 20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
6349 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
6350 -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
6351 50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
6352 60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
6353 -1, -1, -1, -1, -1, -1, 76, 77, -1, -1,
6354 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6355 -1, 91, 92, -1, -1, -1, -1, -1, -1, 99,
6356 -1, -1, 102, 103, 104, 105, -1, 107, -1, -1,
6357 110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
6358 -1, -1, -1, -1, -1, -1, -1, -1, 0, -1,
6359 -1, -1, -1, -1, -1, -1, 8, 9, 10, -1,
6360 -1, 13, 14, 15, -1, 17, -1, 147, 148, 149,
6361 -1, -1, 152, 25, 26, 27, 28, 29, -1, -1,
6362 160, -1, -1, -1, -1, 37, 38, -1, 40, 41,
6363 42, 43, 44, -1, -1, -1, 78, 79, 80, 81,
6364 82, 83, 84, 85, 86, 87, 88, 89, 90, -1,
6365 -1, -1, -1, 95, 96, -1, 68, 69, -1, -1,
6366 -1, -1, -1, -1, -1, -1, 78, 79, 80, 81,
6367 82, 83, 84, 85, 86, 87, 88, 89, 90, -1,
6368 -1, -1, -1, 95, 96, 97, 98, -1, 100, 101,
6369 -1, -1, -1, -1, 106, 137, 138, 139, 140, 141,
6370 142, 143, 144, 145, 146, -1, -1, -1, 120, -1,
6371 -1, 123, -1, -1, -1, -1, -1, -1, -1, -1,
6372 -1, -1, 134, 135, 136, 137, 138, 139, 140, 141,
6373 142, 143, 144, 145, 146, -1, -1, -1, -1, 151,
6374 152, 153, 154, 155, 0, -1, 158, 159, 160, -1,
6375 -1, -1, 8, 9, 10, -1, -1, 13, 14, 15,
6376 -1, 17, -1, -1, -1, -1, -1, -1, -1, 25,
6377 -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
6378 -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
6379 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6380 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6381 -1, -1, 68, 69, -1, -1, -1, -1, -1, -1,
6382 -1, -1, 78, 79, 80, 81, 82, 83, 84, 85,
6383 86, 87, 88, 89, 90, -1, -1, -1, -1, 95,
6384 96, 97, 98, -1, 100, 101, -1, -1, -1, -1,
6385 106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6386 -1, -1, -1, -1, 120, -1, -1, 123, -1, -1,
6387 -1, -1, -1, -1, -1, -1, -1, -1, 134, 135,
6388 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
6389 146, -1, -1, -1, -1, -1, 152, 153, 154, 155,
6390 0, -1, 158, 159, 160, -1, -1, -1, 8, 9,
6391 10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
6392 -1, -1, -1, -1, -1, 25, -1, 27, 28, 29,
6393 -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
6394 40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
6395 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6396 -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
6397 -1, -1, -1, -1, -1, -1, -1, -1, 78, 79,
6398 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6399 90, -1, -1, -1, -1, 95, 96, 97, 98, -1,
6400 100, 101, -1, -1, -1, -1, 106, -1, -1, -1,
6401 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6402 120, -1, -1, 123, -1, -1, -1, -1, -1, -1,
6403 -1, -1, -1, -1, 134, 135, 136, 137, 138, 139,
6404 140, 141, 142, 143, 144, 145, 146, -1, -1, -1,
6405 -1, -1, 152, 153, 154, 155, 0, -1, 158, 159,
6406 160, -1, -1, -1, 8, 9, 10, -1, -1, 13,
6407 14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
6408 -1, 25, 26, 27, 28, 29, -1, -1, -1, -1,
6409 -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
6410 44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6411 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6412 -1, -1, -1, -1, 68, 69, -1, -1, -1, -1,
6413 -1, -1, -1, -1, 78, 79, 80, 81, 82, 83,
6414 84, 85, 86, 87, 88, 89, 90, -1, -1, -1,
6415 -1, 95, 96, 97, 98, -1, -1, 101, -1, -1,
6416 -1, -1, 106, -1, -1, -1, -1, -1, -1, -1,
6417 -1, -1, -1, -1, -1, -1, 120, -1, -1, 123,
6418 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6419 -1, 135, 136, 137, 138, 139, 140, 141, 142, 143,
6420 144, 145, 146, -1, -1, -1, -1, 151, 152, 153,
6421 154, 155, 0, -1, 158, 159, 160, -1, -1, -1,
6422 8, 9, 10, -1, -1, 13, 14, 15, -1, 17,
6423 -1, -1, -1, -1, -1, -1, -1, 25, 26, 27,
6424 28, 29, -1, -1, -1, -1, -1, -1, -1, 37,
6425 38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
6426 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6427 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6428 68, 69, -1, -1, -1, -1, -1, -1, -1, -1,
6429 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
6430 88, 89, 90, -1, -1, -1, -1, 95, 96, 97,
6431 98, -1, -1, 101, -1, -1, -1, -1, 106, -1,
6432 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6433 -1, -1, 120, -1, -1, 123, -1, -1, -1, -1,
6434 -1, -1, -1, -1, -1, -1, -1, 135, 136, 137,
6435 138, 139, 140, 141, 142, 143, 144, 145, 146, -1,
6436 -1, -1, -1, 151, 152, 153, 154, 155, 0, -1,
6437 158, 159, 160, -1, -1, -1, 8, 9, 10, -1,
6438 -1, 13, 14, 15, -1, 17, -1, -1, -1, -1,
6439 -1, -1, -1, 25, 26, 27, 28, -1, -1, -1,
6440 -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
6441 42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
6442 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6443 -1, -1, -1, -1, -1, -1, 68, 69, -1, -1,
6444 -1, -1, -1, -1, -1, -1, 78, 79, 80, 81,
6445 82, 83, 84, 85, 86, 87, 88, 89, 90, -1,
6446 -1, -1, -1, 95, 96, 97, 98, -1, -1, 101,
6447 -1, -1, -1, -1, 106, -1, -1, -1, -1, -1,
6448 -1, -1, -1, -1, -1, -1, -1, -1, 120, -1,
6449 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6450 -1, -1, -1, 135, -1, 137, 138, 139, 140, 141,
6451 142, 143, 144, 145, 146, -1, -1, -1, -1, 151,
6452 152, 153, 154, 155, 0, 157, 158, 159, 160, -1,
6453 -1, -1, 8, 9, 10, -1, -1, 13, 14, 15,
6454 -1, 17, -1, -1, -1, -1, -1, -1, -1, 25,
6455 -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
6456 -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
6457 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6458 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6459 -1, -1, 68, 69, -1, -1, -1, -1, -1, -1,
6460 -1, -1, 78, 79, 80, 81, 82, 83, 84, 85,
6461 86, 87, 88, 89, 90, -1, -1, -1, -1, 95,
6462 96, 97, 98, -1, -1, 101, -1, -1, -1, -1,
6463 106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6464 -1, -1, -1, -1, 120, -1, -1, 123, -1, -1,
6465 -1, -1, -1, -1, -1, -1, -1, -1, -1, 135,
6466 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
6467 146, -1, -1, -1, -1, -1, 152, 153, 154, 155,
6468 0, -1, 158, 159, 160, -1, -1, -1, 8, 9,
6469 10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
6470 -1, -1, -1, -1, -1, 25, 26, 27, 28, -1,
6471 -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
6472 40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
6473 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6474 -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
6475 -1, -1, -1, -1, -1, -1, -1, -1, 78, 79,
6476 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6477 90, -1, -1, -1, -1, 95, 96, 97, 98, -1,
6478 -1, 101, -1, -1, -1, -1, 106, -1, -1, -1,
6479 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6480 120, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6481 -1, -1, -1, -1, -1, 135, -1, 137, 138, 139,
6482 140, 141, 142, 143, 144, 145, 146, -1, -1, -1,
6483 -1, 151, 152, 153, 154, 155, 0, 157, 158, 159,
6484 160, -1, -1, -1, 8, 9, 10, -1, -1, 13,
6485 14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
6486 -1, 25, -1, 27, 28, -1, -1, -1, -1, -1,
6487 -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
6488 44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6489 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6490 -1, -1, -1, -1, 68, 69, -1, -1, -1, -1,
6491 -1, -1, -1, -1, 78, 79, 80, 81, 82, 83,
6492 84, 85, 86, 87, 88, 89, 90, -1, -1, -1,
6493 -1, 95, 96, 97, 98, -1, 100, 101, -1, -1,
6494 -1, -1, 106, -1, -1, -1, -1, -1, -1, -1,
6495 -1, -1, -1, -1, -1, -1, 120, -1, -1, -1,
6496 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6497 134, 135, -1, 137, 138, 139, 140, 141, 142, 143,
6498 144, 145, 146, -1, -1, -1, -1, 151, 152, 153,
6499 154, 155, 0, -1, 158, 159, 160, -1, -1, -1,
6500 8, 9, 10, -1, -1, 13, 14, 15, -1, 17,
6501 -1, -1, -1, -1, -1, -1, -1, 25, -1, 27,
6502 28, -1, -1, -1, -1, -1, -1, -1, -1, 37,
6503 38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
6504 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6505 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6506 68, 69, -1, -1, -1, -1, -1, -1, -1, -1,
6507 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
6508 88, 89, 90, -1, -1, -1, -1, 95, 96, 97,
6509 98, -1, -1, 101, -1, -1, -1, -1, 106, -1,
6510 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6511 -1, -1, 120, -1, -1, -1, -1, -1, -1, -1,
6512 -1, -1, -1, -1, -1, -1, -1, 135, -1, 137,
6513 138, 139, 140, 141, 142, 143, 144, 145, 146, -1,
6514 -1, -1, -1, -1, 152, 153, 154, 155, 0, 157,
6515 158, 159, 160, -1, -1, -1, 8, 9, 10, -1,
6516 -1, -1, 14, 15, -1, 17, -1, -1, -1, -1,
6517 -1, -1, -1, 25, 26, -1, -1, -1, -1, -1,
6518 -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
6519 42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
6520 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6521 -1, -1, -1, -1, -1, -1, 68, 69, -1, -1,
6522 -1, -1, -1, -1, -1, -1, 78, 79, 80, 81,
6523 82, 83, 84, 85, 86, 87, 88, 89, 90, -1,
6524 -1, -1, -1, 95, 96, 97, 98, -1, 100, 101,
6525 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6526 -1, -1, -1, -1, -1, -1, -1, -1, 120, -1,
6527 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6528 -1, -1, 134, 135, -1, 137, 138, 139, 140, 141,
6529 142, 143, 144, 145, 146, -1, -1, -1, -1, 151,
6530 152, 153, 154, 155, 0, -1, 158, -1, 160, -1,
6531 -1, -1, 8, 9, 10, -1, -1, -1, 14, 15,
6532 -1, 17, -1, -1, -1, -1, -1, -1, -1, 25,
6533 26, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6534 -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
6535 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6536 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6537 -1, -1, 68, 69, -1, -1, -1, -1, -1, -1,
6538 -1, -1, 78, 79, 80, 81, 82, 83, 84, 85,
6539 86, 87, 88, 89, 90, -1, -1, -1, -1, 95,
6540 96, 97, 98, -1, 100, 101, -1, -1, -1, -1,
6541 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6542 -1, -1, -1, -1, 120, -1, -1, -1, -1, -1,
6543 -1, -1, -1, -1, -1, -1, -1, -1, 134, 135,
6544 -1, 137, 138, 139, 140, 141, 142, 143, 144, 145,
6545 146, -1, -1, -1, -1, 151, 152, 153, 154, 155,
6546 0, -1, 158, -1, 160, -1, -1, -1, 8, 9,
6547 10, -1, -1, -1, 14, 15, -1, 17, -1, -1,
6548 -1, -1, -1, -1, -1, 25, -1, -1, -1, -1,
6549 -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
6550 40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
6551 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6552 -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
6553 -1, -1, -1, -1, -1, -1, -1, -1, 78, 79,
6554 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6555 90, -1, -1, -1, -1, 95, 96, 97, 98, -1,
6556 100, 101, -1, -1, -1, -1, -1, -1, -1, -1,
6557 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6558 120, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6559 -1, -1, -1, -1, 134, 135, -1, 137, 138, 139,
6560 140, 141, 142, 143, 144, 145, 146, -1, -1, -1,
6561 -1, 151, 152, 153, 154, 155, 0, -1, 158, -1,
6562 160, -1, -1, -1, 8, 9, 10, -1, -1, -1,
6563 14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
6564 -1, 25, -1, -1, -1, -1, -1, -1, -1, -1,
6565 -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
6566 44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6567 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6568 -1, -1, -1, -1, 68, 69, -1, -1, -1, -1,
6569 -1, -1, -1, -1, 78, 79, 80, 81, 82, 83,
6570 84, 85, 86, 87, 88, 89, 90, -1, -1, -1,
6571 -1, 95, 96, 97, 98, -1, 100, 101, -1, -1,
6572 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6573 -1, -1, -1, -1, -1, -1, 120, -1, -1, -1,
6574 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6575 134, 135, -1, 137, 138, 139, 140, 141, 142, 143,
6576 144, 145, 146, -1, -1, -1, -1, 151, 152, 153,
6577 154, 155, -1, -1, 158, 1, 160, 3, 4, 5,
6578 6, 7, 8, 9, 10, 11, 12, -1, -1, 15,
6579 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6580 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
6581 36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
6582 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
6583 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
6584 -1, -1, 68, -1, -1, -1, -1, -1, -1, -1,
6585 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6586 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6587 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6588 -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
6589 116, 117, 118, -1, -1, -1, -1, -1, -1, -1,
6590 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6591 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6592 -1, 147, 148, 149, -1, -1, -1, 1, 154, 3,
6593 4, 5, 6, 7, 160, -1, 10, 11, 12, -1,
6594 14, 15, 16, -1, 18, 19, 20, 21, 22, 23,
6595 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
6596 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
6597 -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6598 54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
6599 64, 65, -1, -1, 68, -1, -1, -1, -1, -1,
6600 -1, -1, 76, 77, -1, -1, -1, -1, -1, -1,
6601 -1, -1, -1, -1, -1, -1, -1, 91, 92, -1,
6602 -1, -1, -1, -1, -1, 99, -1, -1, 102, 103,
6603 104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
6604 114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
6605 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6606 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6607 -1, -1, -1, 147, 148, 149, -1, -1, -1, 1,
6608 154, 3, 4, 5, 6, 7, 160, -1, 10, 11,
6609 12, -1, -1, 15, 16, 17, 18, 19, 20, 21,
6610 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
6611 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
6612 -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
6613 52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
6614 62, 63, 64, 65, -1, -1, 68, -1, -1, -1,
6615 -1, -1, -1, -1, 76, 77, -1, -1, -1, -1,
6616 -1, -1, -1, -1, -1, -1, -1, -1, -1, 91,
6617 92, -1, -1, -1, -1, -1, -1, 99, -1, -1,
6618 102, 103, 104, 105, -1, 107, -1, -1, 110, 111,
6619 112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
6620 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6621 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6622 -1, -1, -1, -1, -1, 147, 148, 149, -1, -1,
6623 -1, 1, 154, 3, 4, 5, 6, 7, 160, -1,
6624 10, 11, 12, -1, -1, 15, 16, -1, 18, 19,
6625 20, 21, 22, 23, 24, 25, -1, -1, -1, -1,
6626 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
6627 -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
6628 50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
6629 60, 61, 62, 63, 64, 65, -1, -1, 68, -1,
6630 -1, -1, -1, -1, -1, -1, 76, 77, -1, -1,
6631 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6632 -1, 91, 92, -1, -1, -1, -1, -1, -1, 99,
6633 -1, -1, 102, 103, 104, 105, -1, 107, -1, -1,
6634 110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
6635 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6636 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6637 -1, -1, -1, -1, -1, -1, -1, 147, 148, 149,
6638 -1, -1, -1, 1, 154, 3, 4, 5, 6, 7,
6639 160, -1, 10, 11, 12, -1, -1, 15, 16, -1,
6640 18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
6641 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
6642 -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
6643 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6644 -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
6645 68, -1, -1, -1, -1, -1, -1, -1, 76, 77,
6646 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6647 -1, -1, -1, 91, 92, -1, -1, -1, -1, -1,
6648 -1, 99, -1, -1, 102, 103, 104, 105, -1, 107,
6649 -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
6650 118, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6651 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6652 -1, -1, -1, -1, -1, -1, -1, -1, -1, 147,
6653 148, 149, -1, -1, -1, 1, 154, 3, 4, 5,
6654 6, 7, 160, 9, 10, 11, 12, -1, -1, -1,
6655 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6656 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
6657 36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
6658 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
6659 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
6660 -1, -1, 68, -1, -1, -1, -1, -1, -1, -1,
6661 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6662 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6663 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6664 -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
6665 116, 117, 118, -1, -1, -1, -1, -1, -1, -1,
6666 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6667 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6668 -1, 147, 148, 149, -1, -1, -1, 1, 154, 3,
6669 4, 5, 6, 7, 160, -1, 10, 11, 12, -1,
6670 -1, -1, 16, -1, 18, 19, 20, 21, 22, 23,
6671 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
6672 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
6673 -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6674 54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
6675 64, 65, -1, -1, 68, -1, -1, -1, -1, -1,
6676 -1, -1, 76, 77, -1, -1, -1, -1, -1, -1,
6677 -1, -1, -1, -1, -1, -1, -1, 91, 92, -1,
6678 -1, -1, -1, -1, -1, 99, -1, -1, 102, 103,
6679 104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
6680 114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
6681 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6682 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6683 -1, -1, -1, 147, 148, 149, -1, -1, -1, 1,
6684 154, 3, 4, 5, 6, 7, 160, -1, -1, 11,
6685 12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
6686 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
6687 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
6688 -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
6689 52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
6690 62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
6691 -1, -1, -1, -1, 76, 77, -1, -1, -1, -1,
6692 -1, -1, -1, -1, -1, -1, -1, -1, -1, 91,
6693 92, -1, -1, -1, -1, -1, -1, 99, -1, -1,
6694 102, 103, 104, 105, -1, 107, -1, -1, 110, 111,
6695 112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
6696 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6697 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6698 -1, -1, -1, -1, -1, 147, 148, 149, -1, -1,
6699 -1, -1, 154, -1, -1, -1, 158, 1, 160, 3,
6700 4, 5, 6, 7, -1, -1, -1, 11, 12, -1,
6701 -1, -1, 16, -1, 18, 19, 20, 21, 22, 23,
6702 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
6703 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
6704 -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6705 54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
6706 64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
6707 -1, -1, 76, 77, -1, -1, -1, -1, -1, -1,
6708 -1, -1, -1, -1, -1, -1, -1, 91, 92, -1,
6709 -1, -1, -1, -1, -1, 99, -1, -1, 102, 103,
6710 104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
6711 114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
6712 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6713 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6714 -1, -1, -1, 147, 148, 149, -1, -1, -1, -1,
6715 154, -1, -1, -1, 158, 1, 160, 3, 4, 5,
6716 6, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6717 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6718 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
6719 36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
6720 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
6721 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
6722 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6723 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6724 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6725 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6726 -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
6727 116, 117, 118, -1, -1, -1, -1, -1, -1, -1,
6728 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6729 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6730 -1, 147, 148, 149, -1, -1, 152, 1, 154, 3,
6731 4, 5, 6, 7, 160, -1, -1, 11, 12, -1,
6732 -1, -1, 16, -1, 18, 19, 20, 21, 22, 23,
6733 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
6734 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
6735 -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6736 54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
6737 64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
6738 -1, -1, 76, 77, -1, -1, -1, -1, -1, -1,
6739 -1, -1, -1, -1, -1, -1, -1, 91, 92, -1,
6740 -1, -1, -1, -1, -1, 99, -1, -1, 102, 103,
6741 104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
6742 114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
6743 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6744 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6745 -1, -1, -1, 147, 148, 149, -1, -1, 152, 1,
6746 154, 3, 4, 5, -1, 7, 160, -1, -1, 11,
6747 12, -1, -1, -1, 16, 17, 18, 19, 20, 21,
6748 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
6749 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
6750 -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
6751 52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
6752 62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
6753 -1, -1, -1, -1, 76, 77, -1, -1, -1, -1,
6754 -1, -1, -1, -1, -1, -1, -1, -1, -1, 91,
6755 92, -1, -1, -1, -1, -1, -1, 99, -1, -1,
6756 102, 103, 104, 105, -1, -1, -1, -1, 110, 111,
6757 112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
6758 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6759 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6760 -1, -1, -1, -1, -1, 147, 148, 149, -1, -1,
6761 -1, -1, 154, -1, -1, -1, -1, -1, 160, 3,
6762 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
6763 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
6764 24, 25, 26, -1, -1, -1, 30, 31, 32, 33,
6765 34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
6766 -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6767 54, 55, 56, 57, -1, -1, -1, -1, -1, -1,
6768 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6769 -1, -1, 76, 77, 78, 79, 80, 81, 82, 83,
6770 84, -1, -1, 87, 88, -1, -1, -1, -1, 93,
6771 94, 95, 96, -1, -1, -1, -1, -1, -1, -1,
6772 -1, -1, -1, 107, 108, -1, -1, -1, -1, -1,
6773 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6774 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6775 -1, -1, -1, 137, 138, 139, 140, 141, 142, 143,
6776 144, 145, 146, -1, 148, 149, -1, -1, -1, -1,
6777 -1, -1, 156, 157, 3, 4, 5, 6, 7, 8,
6778 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
6779 19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
6780 -1, 30, 31, 32, 33, 34, 35, 36, 37, 38,
6781 39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
6782 49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
6783 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6784 -1, -1, -1, -1, -1, -1, -1, 76, 77, 78,
6785 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
6786 -1, -1, -1, -1, 93, 94, 95, 96, -1, -1,
6787 -1, -1, -1, -1, -1, -1, -1, -1, 107, 108,
6788 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6789 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6790 -1, -1, -1, -1, -1, -1, -1, -1, 137, 138,
6791 139, 140, 141, 142, 143, 144, 145, 146, -1, 148,
6792 149, -1, -1, -1, -1, -1, -1, 156, 3, 4,
6793 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
6794 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
6795 25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
6796 35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
6797 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
6798 -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
6799 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6800 -1, 76, 77, 78, 79, 80, 81, 82, 83, 84,
6801 -1, -1, 87, 88, -1, -1, -1, -1, 93, 94,
6802 95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
6803 -1, -1, 107, 108, -1, -1, 111, -1, -1, -1,
6804 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6805 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6806 -1, -1, 137, 138, 139, 140, 141, 142, 143, 144,
6807 145, 146, -1, 148, 149, -1, -1, -1, -1, -1,
6808 -1, 156, 3, 4, 5, 6, 7, 8, 9, 10,
6809 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
6810 21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
6811 31, 32, 33, 34, 35, 36, 37, 38, 39, -1,
6812 -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
6813 51, 52, 53, -1, -1, 56, -1, -1, -1, -1,
6814 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6815 -1, -1, -1, -1, -1, 76, 77, 78, 79, 80,
6816 81, 82, 83, 84, -1, -1, 87, 88, -1, -1,
6817 -1, -1, 93, 94, 95, 96, -1, -1, -1, -1,
6818 -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
6819 111, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6820 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6821 -1, -1, -1, -1, -1, -1, 137, 138, 139, 140,
6822 141, 142, 143, 144, 145, 146, -1, 148, 149, -1,
6823 -1, -1, -1, -1, -1, 156, 3, 4, 5, 6,
6824 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
6825 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
6826 -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
6827 37, 38, 39, -1, -1, -1, -1, -1, 45, 46,
6828 47, 48, 49, 50, 51, 52, 53, -1, -1, 56,
6829 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6830 -1, -1, -1, -1, -1, -1, -1, -1, -1, 76,
6831 77, 78, 79, 80, 81, 82, 83, 84, -1, -1,
6832 87, 88, -1, -1, -1, -1, 93, 94, 95, 96,
6833 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6834 107, 108, -1, -1, -1, -1, -1, -1, -1, -1,
6835 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6836 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6837 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
6838 -1, 148, 149, 3, 4, 5, -1, 7, -1, 156,
6839 -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
6840 20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
6841 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
6842 -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
6843 50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
6844 60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
6845 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6846 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6847 -1, -1, -1, -1, -1, -1, -1, -1, -1, 99,
6848 -1, -1, 102, 103, 104, 105, -1, -1, -1, -1,
6849 110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
6850 -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
6851 12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
6852 22, 23, 24, -1, -1, -1, -1, 147, 30, 31,
6853 32, 33, 34, 35, 36, 155, -1, 39, -1, -1,
6854 -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
6855 52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
6856 62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
6857 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6858 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6859 -1, -1, -1, -1, -1, -1, -1, 99, -1, -1,
6860 102, 103, 104, 105, -1, -1, -1, -1, 110, 111,
6861 112, 113, 114, 115, 116, 117, 118, -1, -1, 3,
6862 4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
6863 -1, -1, 16, -1, 18, 19, 20, 21, 22, 23,
6864 24, -1, -1, -1, -1, 147, 30, 31, 32, 33,
6865 34, 35, 36, 155, -1, 39, -1, -1, -1, -1,
6866 -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
6867 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
6868 64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
6869 -1, -1, 76, 77, -1, -1, -1, -1, -1, -1,
6870 -1, -1, -1, -1, -1, -1, -1, 91, 92, -1,
6871 -1, -1, -1, -1, -1, 99, -1, -1, 102, 103,
6872 104, 105, -1, 107, 108, 109, 110, 111, 112, 113,
6873 114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
6874 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6875 -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
6876 5, -1, 7, 147, 148, 149, 11, 12, -1, -1,
6877 154, 16, -1, 18, 19, 20, 21, 22, 23, 24,
6878 -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
6879 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
6880 -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
6881 55, 56, 57, -1, 59, 60, 61, 62, 63, 64,
6882 65, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6883 -1, 76, 77, -1, -1, -1, -1, -1, -1, -1,
6884 -1, -1, -1, -1, -1, -1, 91, 92, -1, -1,
6885 -1, -1, -1, -1, 99, -1, -1, 102, 103, 104,
6886 105, -1, -1, -1, -1, 110, 111, 112, 113, 114,
6887 115, 116, 117, 118, -1, -1, -1, -1, -1, -1,
6888 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6889 -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
6890 6, 7, 147, 148, 149, 11, 12, -1, -1, 154,
6891 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6892 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
6893 36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
6894 46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
6895 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
6896 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6897 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6898 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6899 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6900 -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
6901 116, 117, 118, -1, -1, 1, -1, 3, 4, 5,
6902 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6903 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6904 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
6905 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
6906 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
6907 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
6908 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6909 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6910 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6911 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6912 -1, -1, -1, -1, 110, 111, 112, 113, 114, 115,
6913 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
6914 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6915 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6916 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
6917 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
6918 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
6919 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
6920 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6921 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6922 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6923 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6924 -1, 107, 108, 109, 110, 111, 112, 113, 114, 115,
6925 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
6926 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6927 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6928 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
6929 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
6930 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
6931 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
6932 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6933 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6934 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6935 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6936 -1, 107, 108, 109, 110, 111, 112, 113, 114, 115,
6937 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
6938 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6939 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6940 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
6941 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
6942 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
6943 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
6944 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6945 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6946 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6947 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6948 -1, 107, 108, 109, 110, 111, 112, 113, 114, 115,
6949 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
6950 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6951 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6952 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
6953 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
6954 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
6955 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
6956 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6957 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6958 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6959 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6960 -1, 107, 108, 109, 110, 111, 112, 113, 114, 115,
6961 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
6962 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6963 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6964 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
6965 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
6966 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
6967 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
6968 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6969 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6970 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6971 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6972 -1, 107, 108, -1, 110, 111, 112, 113, 114, 115,
6973 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
6974 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6975 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6976 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
6977 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
6978 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
6979 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
6980 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6981 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6982 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6983 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6984 -1, -1, 108, 109, 110, 111, 112, 113, 114, 115,
6985 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
6986 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6987 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6988 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
6989 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
6990 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
6991 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
6992 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6993 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6994 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6995 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
6996 -1, -1, 108, -1, 110, 111, 112, 113, 114, 115,
6997 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
6998 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6999 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7000 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7001 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7002 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7003 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7004 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7005 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7006 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7007 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7008 -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
7009 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7010 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7011 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7012 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7013 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7014 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7015 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7016 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7017 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7018 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7019 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7020 -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
7021 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7022 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7023 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7024 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7025 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7026 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7027 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7028 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7029 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7030 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7031 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7032 -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
7033 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7034 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7035 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7036 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7037 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7038 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7039 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7040 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7041 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7042 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7043 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7044 -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
7045 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7046 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7047 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7048 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7049 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7050 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7051 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7052 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7053 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7054 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7055 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7056 -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
7057 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7058 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7059 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7060 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7061 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7062 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7063 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7064 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7065 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7066 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7067 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7068 -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
7069 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7070 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7071 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7072 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7073 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7074 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7075 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7076 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7077 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7078 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7079 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7080 -1, -1, -1, -1, 110, 111, 112, 113, 114, 115,
7081 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7082 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7083 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7084 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7085 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7086 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7087 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7088 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7089 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7090 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7091 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7092 -1, -1, -1, -1, 110, 111, 112, 113, 114, 115,
7093 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7094 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7095 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7096 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7097 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7098 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7099 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7100 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7101 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7102 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7103 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7104 -1, -1, -1, -1, 110, 111, 112, 113, 114, 115,
7105 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7106 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7107 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7108 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7109 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7110 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7111 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7112 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7113 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7114 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7115 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7116 -1, -1, -1, -1, 110, 111, 112, 113, 114, 115,
7117 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7118 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7119 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7120 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7121 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7122 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7123 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7124 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7125 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7126 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7127 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7128 -1, -1, -1, -1, 110, 111, 112, 113, 114, 115,
7129 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7130 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7131 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7132 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7133 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7134 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7135 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7136 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7137 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
7138 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
7139 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7140 -1, -1, -1, -1, 110, 111, 112, 113, 114, 115,
7141 116, 117, 118, -1, -1, -1, -1, 3, 4, 5,
7142 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7143 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7144 -1, 147, 148, 149, 30, 31, 32, 33, 34, 35,
7145 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7146 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7147 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7148 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7149 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7150 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7151 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7152 -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
7153 116, 117, 118, -1, -1, 3, 4, 5, -1, 7,
7154 -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
7155 18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
7156 -1, 147, 30, 31, 32, 33, 34, 35, 36, -1,
7157 -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
7158 -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
7159 -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
7160 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7161 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7162 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7163 -1, 99, -1, -1, 102, 103, 104, 105, -1, 107,
7164 -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
7165 118, -1, -1, 3, 4, 5, -1, 7, -1, -1,
7166 -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
7167 20, 21, 22, 23, 24, -1, -1, -1, -1, 147,
7168 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
7169 -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
7170 50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
7171 60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
7172 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7173 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7174 -1, -1, -1, -1, -1, 95, -1, -1, -1, 99,
7175 -1, -1, 102, 103, 104, 105, -1, -1, -1, -1,
7176 110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
7177 -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
7178 12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
7179 22, 23, 24, -1, -1, -1, -1, 147, 30, 31,
7180 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
7181 -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
7182 52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
7183 62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
7184 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7185 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7186 -1, -1, -1, -1, -1, -1, -1, 99, -1, -1,
7187 102, 103, 104, 105, -1, -1, -1, -1, 110, 111,
7188 112, 113, 114, 115, 116, 117, 118, -1, -1, 3,
7189 4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
7190 -1, -1, 16, -1, 18, 19, 20, 21, 22, 23,
7191 24, -1, -1, -1, -1, 147, 30, 31, 32, 33,
7192 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
7193 -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
7194 54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
7195 64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
7196 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7197 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7198 -1, -1, -1, -1, -1, 99, -1, -1, 102, 103,
7199 104, 105, -1, -1, -1, -1, 110, 111, 112, 113,
7200 114, 115, 116, 117, 118, -1, -1, 3, 4, 5,
7201 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
7202 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
7203 -1, -1, -1, 147, 30, 31, 32, 33, 34, 35,
7204 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
7205 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
7206 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
7207 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7208 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7209 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7210 -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
7211 -1, -1, -1, -1, 110, 111, 112, 113, 114, 115,
7212 116, 117, 118, -1, -1, 3, 4, 5, -1, 7,
7213 -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
7214 18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
7215 -1, 147, 30, 31, 32, 33, 34, 35, 36, -1,
7216 -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
7217 -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
7218 -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
7219 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7220 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7221 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7222 -1, 99, -1, -1, 102, 103, 104, 105, 33, 34,
7223 35, 36, 110, 111, 112, 113, 114, 115, 116, 117,
7224 118, -1, -1, -1, 49, 50, 51, 52, -1, -1,
7225 -1, 56, -1, -1, 59, 60, 61, 62, 63, -1,
7226 -1, -1, -1, -1, -1, -1, -1, -1, -1, 147,
7227 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7228 -1, -1, -1, -1, -1, -1, 91, 92, -1, -1,
7229 -1, -1, -1, -1, 99, -1, -1, 102, -1, 104,
7230 105, -1, -1, -1, -1, 110, 111, 112, 113, 114,
7231 115, 116, 117, 118, -1, -1, -1, -1, -1, 52,
7232 53, -1, -1, 56, -1, -1, -1, -1, -1, -1,
7233 -1, -1, -1, -1, -1, 140, -1, -1, -1, -1,
7234 -1, -1, 147, 76, 77, 78, 79, 80, 81, 82,
7235 83, 84, -1, -1, 87, 88, -1, -1, -1, -1,
7236 93, 94, 95, 96, -1, -1, -1, -1, -1, -1,
7237 -1, -1, -1, -1, 107, 108, -1, -1, -1, -1,
7238 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7239 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7240 -1, -1, -1, -1, 137, 138, 139, 140, 141, 142,
7241 143, 144, 145, 146, -1, 148, 149, 52, 53, -1,
7242 -1, 56, -1, 156, -1, -1, -1, -1, -1, -1,
7243 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7244 -1, 76, 77, 78, 79, 80, 81, 82, 83, 84,
7245 -1, -1, 87, 88, -1, -1, -1, -1, 93, 94,
7246 95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
7247 -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
7248 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7249 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7250 -1, -1, 137, 138, 139, 140, 141, 142, 143, 144,
7251 145, 146, -1, 148, 149, 52, 53, -1, -1, 56,
7252 -1, 156, -1, -1, -1, -1, -1, -1, -1, -1,
7253 -1, -1, -1, -1, -1, -1, -1, -1, -1, 76,
7254 77, 78, 79, 80, 81, 82, 83, 84, -1, -1,
7255 87, 88, -1, -1, -1, -1, 93, 94, 95, 96,
7256 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7257 107, 108, -1, -1, -1, -1, -1, -1, -1, -1,
7258 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7259 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7260 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
7261 -1, 148, 149, 52, 53, -1, -1, 56, -1, 156,
7262 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7263 -1, -1, -1, -1, -1, -1, -1, 76, 77, 78,
7264 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
7265 -1, -1, -1, -1, 93, 94, 95, 96, -1, -1,
7266 -1, -1, -1, -1, -1, -1, -1, -1, 107, 108,
7267 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7268 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7269 -1, -1, -1, -1, -1, -1, -1, -1, 137, 138,
7270 139, 140, 141, 142, 143, 144, 145, 146, -1, 148,
7271 149, 52, 53, -1, -1, 56, -1, 156, -1, -1,
7272 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7273 -1, -1, -1, -1, -1, 76, 77, 78, 79, 80,
7274 81, 82, 83, 84, -1, -1, 87, 88, -1, -1,
7275 -1, -1, 93, 94, 95, 96, -1, -1, -1, -1,
7276 -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
7277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7279 -1, -1, -1, -1, -1, -1, 137, 138, 139, 140,
7280 141, 142, 143, 144, 145, 146, -1, 148, 149, 52,
7281 53, -1, -1, 56, -1, 156, -1, -1, -1, -1,
7282 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7283 -1, -1, -1, 76, 77, 78, 79, 80, 81, 82,
7284 83, 84, -1, -1, 87, 88, -1, -1, -1, -1,
7285 93, 94, 95, 96, -1, -1, -1, -1, -1, -1,
7286 -1, -1, -1, -1, 107, 108, -1, -1, -1, -1,
7287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7288 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7289 -1, -1, -1, -1, 137, 138, 139, 140, 141, 142,
7290 143, 144, 145, 146, -1, 148, 149, 52, 53, -1,
7291 -1, 56, -1, 156, -1, -1, -1, -1, -1, -1,
7292 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7293 -1, 76, 77, 78, 79, 80, 81, 82, 83, 84,
7294 -1, -1, 87, 88, -1, -1, -1, -1, 93, 94,
7295 95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
7296 -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
7297 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7298 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7299 -1, -1, 137, 138, 139, 140, 141, 142, 143, 144,
7300 145, 146, -1, 148, 149, 52, 53, -1, -1, 56,
7301 -1, 156, -1, -1, -1, -1, -1, -1, -1, -1,
7302 -1, -1, -1, -1, -1, -1, -1, -1, -1, 76,
7303 77, 78, 79, 80, 81, 82, 83, 84, -1, -1,
7304 87, 88, -1, -1, -1, -1, 93, 94, 95, 96,
7305 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7306 107, 108, -1, -1, -1, -1, -1, -1, -1, -1,
7307 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7308 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7309 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
7310 -1, 148, 149, 52, 53, -1, -1, 56, -1, 156,
7311 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7312 -1, -1, -1, -1, -1, -1, -1, 76, 77, 78,
7313 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
7314 -1, -1, -1, -1, 93, 94, 95, 96, -1, -1,
7315 -1, -1, -1, -1, -1, -1, -1, -1, 107, 108,
7316 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7317 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7318 -1, -1, -1, -1, -1, -1, -1, -1, 137, 138,
7319 139, 140, 141, 142, 143, 144, 145, 146, -1, 148,
7320 149, 52, 53, -1, -1, 56, -1, 156, -1, -1,
7321 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7322 -1, -1, -1, -1, -1, 76, 77, 78, 79, 80,
7323 81, 82, 83, 84, -1, -1, 87, 88, -1, -1,
7324 -1, -1, 93, 94, 95, 96, -1, -1, -1, -1,
7325 -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
7326 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7327 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7328 -1, -1, -1, -1, -1, -1, 137, 138, 139, 140,
7329 141, 142, 143, 144, 145, 146, -1, 148, 149, 52,
7330 53, -1, -1, 56, -1, 156, -1, -1, -1, -1,
7331 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7332 -1, -1, -1, 76, 77, 78, 79, 80, 81, 82,
7333 83, 84, -1, -1, 87, 88, -1, -1, -1, -1,
7334 93, 94, 95, 96, -1, -1, -1, -1, -1, -1,
7335 -1, -1, -1, -1, 107, 108, -1, -1, -1, -1,
7336 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7337 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7338 -1, -1, -1, -1, 137, 138, 139, 140, 141, 142,
7339 143, 144, 145, 146, -1, 148, 149, 52, 53, -1,
7340 -1, 56, -1, 156, -1, -1, -1, -1, -1, -1,
7341 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7342 -1, 76, 77, 78, 79, 80, 81, 82, 83, 84,
7343 -1, -1, 87, 88, -1, -1, -1, -1, 93, 94,
7344 95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
7345 -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
7346 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7347 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7348 -1, -1, 137, 138, 139, 140, 141, 142, 143, 144,
7349 145, 146, -1, 148, 149, 52, 53, -1, -1, 56,
7350 -1, 156, -1, -1, -1, -1, -1, -1, -1, -1,
7351 -1, -1, -1, -1, -1, -1, -1, -1, -1, 76,
7352 77, 78, 79, 80, 81, 82, 83, 84, -1, -1,
7353 87, 88, -1, -1, -1, -1, 93, 94, 95, 96,
7354 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7355 107, 108, -1, -1, -1, -1, -1, -1, -1, -1,
7356 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7357 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7358 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
7359 -1, 148, 149, 52, 53, -1, -1, 56, -1, 156,
7360 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7361 -1, -1, -1, -1, -1, -1, -1, 76, 77, 78,
7362 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
7363 -1, -1, -1, -1, 93, 94, 95, 96, -1, -1,
7364 -1, -1, -1, -1, -1, -1, -1, -1, 107, 108,
7365 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7366 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7367 -1, -1, -1, -1, -1, -1, -1, -1, 137, 138,
7368 139, 140, 141, 142, 143, 144, 145, 146, -1, 148,
7369 149, -1, -1, -1, -1, -1, -1, 156
7374static const yytype_int16 yystos[] =
7376 0, 165, 166, 1, 3, 4, 5, 6, 7, 11,
7377 12, 16, 18, 19, 20, 21, 22, 23, 24, 30,
7378 31, 32, 33, 34, 35, 36, 39, 45, 46, 47,
7379 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
7380 59, 60, 61, 62, 63, 64, 65, 76, 77, 91,
7381 92, 99, 102, 103, 104, 105, 107, 110, 111, 112,
7382 113, 114, 115, 116, 117, 118, 147, 148, 149, 164,
7383 167, 168, 180, 182, 183, 184, 185, 186, 187, 191,
7384 195, 197, 203, 206, 208, 209, 210, 212, 214, 215,
7385 216, 217, 226, 227, 228, 229, 230, 231, 234, 255,
7386 267, 268, 269, 270, 271, 272, 273, 274, 275, 276,
7387 277, 278, 287, 288, 321, 326, 327, 376, 377, 378,
7388 379, 380, 381, 383, 384, 387, 388, 390, 391, 392,
7389 393, 406, 407, 409, 410, 411, 412, 413, 414, 415,
7390 416, 417, 465, 0, 3, 4, 5, 6, 7, 8,
7391 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
7392 19, 20, 21, 22, 23, 24, 25, 26, 30, 31,
7393 32, 33, 34, 35, 36, 37, 38, 39, 45, 46,
7394 47, 48, 49, 50, 51, 52, 53, 56, 76, 77,
7395 78, 79, 80, 81, 82, 83, 84, 87, 88, 93,
7396 94, 95, 96, 107, 108, 137, 138, 139, 140, 141,
7397 142, 143, 144, 145, 146, 148, 149, 156, 220, 221,
7398 222, 224, 225, 406, 179, 179, 179, 39, 58, 99,
7399 102, 107, 108, 109, 112, 148, 195, 197, 209, 217,
7400 227, 238, 239, 245, 246, 249, 251, 252, 268, 413,
7401 414, 416, 417, 452, 453, 246, 157, 242, 247, 248,
7402 154, 157, 189, 54, 221, 189, 151, 169, 170, 235,
7403 465, 21, 22, 32, 208, 227, 268, 287, 288, 227,
7404 227, 227, 56, 47, 102, 171, 176, 177, 182, 211,
7405 212, 465, 171, 240, 251, 452, 465, 239, 451, 452,
7406 465, 46, 99, 147, 155, 195, 197, 216, 255, 268,
7407 413, 414, 417, 319, 220, 396, 408, 412, 396, 397,
7408 398, 161, 382, 382, 382, 382, 411, 203, 227, 227,
7409 154, 160, 163, 463, 464, 179, 40, 41, 42, 43,
7410 44, 37, 38, 157, 420, 421, 422, 423, 465, 420,
7411 422, 26, 151, 242, 248, 279, 328, 28, 280, 325,
7412 134, 155, 102, 107, 214, 134, 25, 78, 79, 80,
7413 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
7414 95, 96, 101, 135, 137, 138, 139, 140, 141, 142,
7415 143, 144, 145, 146, 233, 233, 69, 97, 98, 153,
7416 457, 458, 256, 1, 191, 198, 199, 199, 200, 202,
7417 202, 163, 199, 464, 99, 210, 217, 268, 293, 413,
7418 414, 417, 52, 56, 95, 99, 218, 219, 268, 413,
7419 414, 417, 219, 33, 34, 35, 36, 49, 50, 51,
7420 52, 56, 157, 194, 220, 415, 447, 448, 449, 246,
7421 157, 248, 98, 457, 458, 328, 379, 100, 100, 155,
7422 239, 56, 239, 239, 239, 396, 420, 420, 134, 101,
7423 155, 250, 465, 98, 153, 457, 100, 100, 155, 250,
7424 92, 244, 246, 251, 432, 452, 465, 246, 189, 191,
7425 459, 191, 54, 64, 65, 181, 157, 235, 236, 164,
7426 98, 457, 100, 178, 211, 158, 163, 464, 459, 257,
7427 159, 155, 189, 462, 155, 462, 152, 462, 189, 56,
7428 411, 213, 214, 421, 155, 98, 153, 457, 316, 66,
7429 119, 121, 122, 399, 119, 119, 399, 67, 399, 161,
7430 385, 394, 389, 395, 78, 160, 168, 151, 199, 199,
7431 199, 199, 235, 237, 191, 191, 52, 54, 55, 56,
7432 57, 58, 78, 92, 102, 107, 108, 109, 141, 144,
7433 298, 363, 424, 425, 426, 427, 428, 429, 431, 432,
7434 433, 434, 435, 436, 437, 438, 439, 440, 441, 442,
7435 443, 444, 445, 134, 265, 431, 134, 266, 329, 330,
7436 106, 207, 331, 332, 332, 235, 211, 155, 216, 155,
7437 235, 193, 227, 227, 227, 227, 227, 227, 227, 227,
7438 227, 227, 227, 227, 227, 192, 227, 227, 227, 227,
7439 227, 227, 227, 227, 227, 227, 227, 52, 53, 56,
7440 224, 454, 455, 244, 251, 52, 53, 56, 224, 454,
7441 242, 171, 174, 13, 289, 463, 289, 199, 171, 171,
7442 259, 163, 56, 98, 153, 457, 25, 199, 52, 56,
7443 218, 138, 419, 465, 98, 153, 457, 264, 450, 69,
7444 98, 456, 246, 459, 52, 56, 454, 235, 235, 223,
7445 100, 124, 134, 134, 235, 239, 239, 249, 252, 452,
7446 52, 56, 244, 52, 56, 235, 235, 453, 459, 155,
7447 459, 155, 158, 459, 221, 236, 227, 152, 56, 454,
7448 454, 235, 170, 459, 177, 158, 452, 155, 213, 52,
7449 56, 244, 52, 56, 317, 401, 400, 119, 386, 399,
7450 66, 119, 119, 386, 66, 119, 227, 171, 182, 102,
7451 107, 294, 295, 296, 297, 434, 155, 446, 465, 155,
7452 446, 155, 430, 459, 299, 300, 155, 430, 239, 34,
7453 52, 52, 155, 430, 52, 39, 188, 209, 227, 232,
7454 174, 463, 188, 232, 174, 316, 152, 330, 316, 10,
7455 68, 286, 286, 107, 203, 204, 205, 239, 251, 253,
7456 254, 459, 213, 155, 99, 185, 190, 205, 217, 227,
7457 239, 241, 254, 268, 417, 338, 338, 189, 100, 100,
7458 151, 242, 248, 189, 460, 155, 100, 100, 242, 243,
7459 248, 465, 235, 286, 171, 13, 171, 27, 290, 463,
7460 286, 286, 17, 283, 334, 25, 258, 340, 52, 56,
7461 244, 52, 56, 260, 263, 418, 262, 52, 56, 218,
7462 244, 174, 191, 196, 459, 243, 248, 190, 227, 241,
7463 190, 241, 221, 235, 239, 39, 250, 100, 100, 460,
7464 100, 100, 432, 452, 191, 190, 241, 462, 214, 460,
7465 318, 402, 405, 412, 417, 382, 399, 382, 382, 382,
7466 152, 296, 434, 155, 459, 155, 445, 424, 439, 441,
7467 427, 428, 437, 443, 134, 239, 429, 436, 443, 435,
7468 437, 189, 44, 44, 286, 286, 317, 152, 317, 239,
7469 155, 44, 213, 56, 44, 134, 44, 98, 153, 457,
7470 336, 336, 136, 235, 235, 330, 207, 159, 100, 235,
7471 235, 207, 8, 281, 372, 465, 14, 15, 284, 285,
7472 291, 292, 465, 292, 201, 107, 239, 333, 286, 338,
7473 334, 286, 460, 199, 463, 199, 174, 460, 286, 459,
7474 194, 328, 325, 189, 235, 235, 100, 235, 235, 459,
7475 155, 459, 179, 403, 459, 294, 297, 295, 446, 155,
7476 430, 155, 430, 155, 430, 155, 430, 430, 188, 232,
7477 237, 237, 318, 318, 107, 239, 237, 237, 235, 237,
7478 52, 56, 244, 52, 56, 337, 337, 227, 190, 241,
7479 190, 241, 152, 235, 190, 241, 190, 241, 239, 254,
7480 373, 465, 175, 284, 171, 199, 286, 286, 239, 155,
7481 289, 336, 286, 290, 174, 463, 286, 235, 157, 322,
7482 431, 171, 155, 155, 437, 437, 443, 437, 227, 227,
7483 179, 179, 239, 182, 182, 227, 460, 52, 56, 58,
7484 91, 92, 99, 102, 104, 105, 107, 112, 140, 321,
7485 343, 344, 345, 346, 349, 353, 354, 355, 358, 359,
7486 360, 361, 362, 363, 364, 365, 366, 367, 368, 369,
7487 370, 371, 376, 377, 380, 381, 384, 388, 391, 393,
7488 414, 439, 343, 190, 241, 101, 374, 465, 9, 282,
7489 375, 465, 172, 289, 107, 239, 171, 337, 261, 286,
7490 431, 320, 0, 120, 404, 295, 430, 430, 155, 430,
7491 430, 139, 310, 311, 465, 310, 367, 367, 56, 218,
7492 337, 344, 351, 352, 353, 354, 357, 460, 189, 337,
7493 461, 52, 396, 52, 102, 412, 101, 155, 139, 155,
7494 155, 344, 89, 90, 98, 153, 157, 347, 348, 52,
7495 99, 217, 268, 413, 414, 417, 289, 176, 171, 171,
7496 239, 292, 334, 335, 342, 343, 171, 189, 313, 29,
7497 123, 323, 437, 298, 301, 302, 303, 304, 306, 307,
7498 309, 312, 435, 437, 438, 443, 445, 171, 174, 344,
7499 460, 344, 355, 357, 460, 155, 152, 235, 124, 199,
7500 368, 351, 355, 349, 356, 357, 112, 360, 364, 367,
7501 367, 218, 337, 460, 337, 459, 351, 354, 358, 351,
7502 354, 358, 56, 98, 153, 457, 171, 163, 173, 291,
7503 289, 40, 41, 286, 160, 158, 324, 171, 430, 446,
7504 155, 446, 155, 308, 313, 300, 155, 305, 308, 99,
7505 268, 155, 308, 459, 155, 155, 350, 459, 155, 155,
7506 396, 459, 459, 459, 460, 460, 460, 52, 56, 244,
7507 52, 56, 372, 375, 339, 199, 199, 52, 314, 315,
7508 433, 174, 152, 301, 441, 304, 306, 437, 443, 139,
7509 268, 307, 443, 56, 98, 437, 356, 358, 356, 355,
7510 357, 460, 171, 155, 189, 286, 446, 155, 308, 155,
7511 308, 155, 308, 155, 308, 52, 56, 308, 155, 461,
7512 292, 340, 341, 315, 437, 437, 443, 437, 308, 308,
7513 155, 308, 308, 437, 308
7517static const yytype_int16 yyr1[] =
7519 0, 162, 165, 163, 163, 164, 166, 167, 167, 167,
7520 168, 168, 169, 170, 171, 172, 173, 174, 175, 174,
7521 176, 176, 176, 177, 178, 177, 179, 180, 181, 182,
7522 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
7523 182, 182, 183, 182, 182, 182, 182, 182, 184, 185,
7524 186, 186, 186, 186, 186, 186, 186, 186, 185, 187,
7525 187, 185, 188, 188, 189, 189, 188, 190, 190, 190,
7526 191, 191, 191, 191, 191, 192, 191, 193, 191, 191,
7527 194, 195, 196, 197, 198, 199, 199, 200, 201, 202,
7528 203, 203, 204, 205, 206, 206, 207, 208, 208, 208,
7529 209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
7530 209, 209, 210, 210, 211, 211, 212, 212, 212, 213,
7531 213, 212, 212, 212, 212, 212, 212, 212, 214, 214,
7532 215, 215, 216, 216, 216, 216, 216, 216, 216, 216,
7533 216, 217, 217, 217, 217, 217, 217, 217, 217, 217,
7534 218, 218, 219, 219, 219, 220, 220, 220, 220, 220,
7535 221, 221, 222, 223, 222, 224, 224, 224, 224, 224,
7536 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
7537 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
7538 224, 224, 224, 224, 224, 225, 225, 225, 225, 225,
7539 225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
7540 225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
7541 225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
7542 225, 225, 225, 225, 225, 225, 226, 227, 228, 228,
7543 228, 228, 228, 228, 228, 228, 227, 229, 229, 229,
7544 229, 229, 229, 227, 227, 227, 227, 227, 227, 227,
7545 227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
7546 227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
7547 230, 230, 227, 227, 227, 231, 232, 232, 232, 233,
7548 233, 233, 233, 234, 234, 235, 236, 237, 238, 239,
7549 240, 240, 240, 240, 241, 241, 242, 242, 242, 243,
7550 243, 244, 244, 244, 244, 244, 245, 246, 246, 246,
7551 246, 246, 247, 248, 249, 249, 250, 250, 251, 251,
7552 251, 251, 252, 252, 253, 253, 254, 254, 254, 255,
7553 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
7554 256, 255, 257, 255, 255, 255, 255, 255, 255, 255,
7555 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
7556 255, 255, 255, 255, 258, 255, 259, 255, 255, 260,
7557 261, 255, 262, 255, 263, 255, 264, 255, 265, 255,
7558 266, 255, 255, 255, 255, 255, 267, 268, 269, 270,
7559 271, 272, 273, 274, 275, 276, 277, 278, 279, 280,
7560 281, 282, 283, 284, 285, 286, 286, 287, 288, 289,
7561 289, 289, 290, 290, 291, 291, 292, 292, 293, 293,
7562 294, 294, 295, 295, 296, 296, 296, 296, 296, 297,
7563 297, 298, 298, 299, 300, 301, 301, 302, 302, 303,
7564 303, 303, 303, 304, 305, 306, 307, 307, 308, 308,
7565 309, 309, 309, 309, 309, 309, 309, 309, 309, 309,
7566 309, 309, 309, 309, 309, 310, 310, 311, 312, 312,
7567 313, 313, 314, 314, 315, 315, 316, 317, 318, 319,
7568 320, 321, 322, 322, 323, 324, 323, 325, 326, 326,
7569 326, 326, 327, 327, 327, 327, 327, 327, 327, 327,
7570 328, 328, 329, 330, 331, 332, 333, 333, 333, 333,
7571 334, 335, 335, 336, 337, 338, 339, 340, 341, 341,
7572 342, 342, 342, 343, 343, 343, 343, 343, 343, 344,
7573 345, 345, 346, 346, 347, 348, 349, 349, 349, 349,
7574 349, 349, 349, 349, 349, 349, 349, 349, 349, 350,
7575 349, 349, 349, 351, 351, 351, 351, 351, 351, 352,
7576 352, 353, 353, 354, 355, 355, 356, 356, 357, 358,
7577 358, 358, 358, 359, 359, 360, 360, 361, 361, 362,
7578 362, 363, 364, 364, 365, 366, 366, 366, 366, 366,
7579 366, 365, 365, 365, 365, 367, 367, 367, 367, 367,
7580 367, 367, 367, 367, 367, 368, 369, 369, 370, 371,
7581 371, 371, 372, 372, 373, 373, 373, 374, 374, 375,
7582 375, 376, 376, 377, 378, 378, 378, 379, 380, 381,
7583 382, 382, 383, 384, 385, 385, 386, 386, 387, 388,
7584 389, 389, 390, 391, 392, 393, 394, 394, 395, 395,
7585 396, 396, 397, 397, 398, 398, 399, 400, 399, 401,
7586 402, 403, 399, 404, 404, 405, 405, 406, 406, 407,
7587 408, 408, 409, 410, 410, 411, 411, 411, 411, 412,
7588 412, 412, 413, 413, 413, 414, 414, 414, 414, 414,
7589 414, 414, 415, 415, 416, 416, 417, 417, 418, 419,
7590 419, 420, 420, 421, 422, 423, 422, 424, 424, 425,
7591 425, 426, 426, 426, 426, 427, 427, 428, 429, 429,
7592 430, 430, 431, 431, 431, 431, 431, 431, 431, 431,
7593 431, 431, 431, 431, 431, 431, 431, 432, 433, 433,
7594 433, 433, 434, 434, 435, 436, 436, 437, 437, 438,
7595 439, 439, 440, 441, 441, 442, 442, 443, 443, 444,
7596 444, 445, 445, 446, 446, 447, 448, 449, 450, 449,
7597 451, 451, 452, 452, 453, 453, 453, 453, 453, 453,
7598 454, 454, 454, 454, 455, 455, 455, 456, 456, 457,
7599 457, 458, 458, 459, 460, 461, 462, 462, 463, 463,
7604static const yytype_int8 yyr2[] =
7606 0, 2, 0, 0, 1, 2, 2, 1, 1, 3,
7607 1, 2, 1, 3, 2, 0, 0, 8, 0, 5,
7608 1, 1, 3, 1, 0, 3, 0, 2, 0, 4,
7609 3, 3, 3, 2, 3, 3, 3, 3, 4, 5,
7610 1, 4, 4, 1, 7, 4, 1, 1, 4, 1,
7611 4, 7, 6, 6, 6, 6, 5, 4, 1, 4,
7612 4, 1, 1, 4, 0, 1, 3, 1, 4, 1,
7613 1, 3, 3, 3, 2, 0, 7, 0, 7, 1,
7614 1, 2, 0, 5, 1, 1, 1, 0, 0, 4,
7615 1, 1, 1, 1, 1, 4, 3, 1, 1, 1,
7616 2, 3, 4, 5, 4, 5, 6, 2, 2, 2,
7617 2, 2, 1, 3, 1, 3, 1, 2, 3, 1,
7618 3, 5, 2, 4, 2, 4, 1, 3, 1, 3,
7619 2, 3, 1, 1, 4, 3, 3, 3, 3, 2,
7620 1, 1, 1, 4, 3, 3, 3, 3, 2, 1,
7621 1, 1, 2, 1, 3, 1, 1, 1, 1, 1,
7622 1, 1, 1, 0, 4, 1, 1, 1, 1, 1,
7623 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7624 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7625 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7626 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7627 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7628 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7629 1, 1, 1, 1, 1, 1, 4, 1, 4, 7,
7630 6, 6, 6, 6, 5, 4, 1, 3, 3, 2,
7631 2, 2, 2, 1, 3, 3, 3, 3, 3, 3,
7632 4, 2, 2, 3, 3, 3, 3, 1, 3, 3,
7633 3, 3, 3, 2, 2, 3, 3, 3, 3, 4,
7634 4, 4, 1, 1, 1, 6, 1, 4, 3, 1,
7635 1, 1, 1, 3, 3, 1, 1, 1, 1, 1,
7636 1, 2, 4, 2, 1, 4, 3, 5, 3, 1,
7637 1, 1, 1, 2, 4, 2, 1, 1, 2, 2,
7638 4, 1, 0, 2, 2, 1, 2, 1, 1, 1,
7639 3, 3, 2, 1, 1, 1, 3, 4, 2, 1,
7640 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7641 0, 4, 0, 4, 3, 3, 2, 3, 3, 1,
7642 4, 3, 1, 6, 4, 3, 2, 1, 2, 1,
7643 6, 6, 4, 4, 0, 6, 0, 5, 5, 0,
7644 0, 9, 0, 6, 0, 7, 0, 5, 0, 5,
7645 0, 5, 1, 1, 1, 1, 1, 1, 1, 1,
7646 1, 2, 2, 1, 2, 1, 1, 1, 1, 1,
7647 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7648 1, 2, 1, 1, 1, 5, 1, 2, 1, 1,
7649 1, 3, 1, 3, 1, 3, 5, 1, 3, 2,
7650 1, 1, 1, 0, 2, 2, 1, 1, 3, 4,
7651 2, 2, 1, 1, 1, 3, 1, 3, 2, 0,
7652 6, 8, 4, 6, 4, 2, 6, 2, 4, 6,
7653 2, 4, 2, 4, 1, 1, 1, 4, 0, 1,
7654 1, 4, 1, 3, 1, 1, 0, 0, 0, 0,
7655 0, 9, 4, 1, 3, 0, 4, 3, 2, 4,
7656 5, 5, 2, 4, 4, 3, 3, 2, 1, 4,
7657 3, 3, 0, 7, 0, 7, 1, 2, 3, 4,
7658 5, 1, 1, 0, 0, 0, 0, 9, 1, 1,
7659 1, 3, 3, 1, 2, 3, 1, 1, 1, 1,
7660 3, 1, 3, 1, 2, 2, 1, 1, 4, 4,
7661 4, 3, 4, 4, 4, 3, 3, 3, 2, 0,
7662 6, 2, 4, 1, 1, 2, 2, 4, 1, 2,
7663 3, 1, 3, 5, 2, 1, 1, 3, 1, 3,
7664 1, 2, 1, 1, 3, 2, 1, 1, 3, 2,
7665 1, 2, 1, 1, 1, 3, 3, 2, 2, 2,
7666 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7667 1, 1, 1, 1, 1, 1, 2, 2, 4, 2,
7668 3, 1, 6, 1, 1, 1, 1, 2, 1, 3,
7669 1, 1, 1, 1, 1, 1, 2, 3, 3, 3,
7670 1, 2, 4, 1, 0, 3, 1, 2, 4, 1,
7671 0, 3, 4, 1, 4, 1, 0, 3, 0, 3,
7672 0, 2, 0, 2, 0, 2, 1, 0, 3, 0,
7673 0, 0, 6, 1, 1, 1, 1, 1, 1, 2,
7674 1, 1, 3, 1, 2, 1, 1, 1, 1, 1,
7675 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7676 1, 1, 1, 1, 1, 1, 1, 1, 0, 4,
7677 1, 1, 1, 3, 1, 0, 3, 2, 1, 1,
7678 3, 4, 2, 2, 1, 1, 1, 3, 1, 3,
7679 2, 0, 6, 8, 4, 6, 4, 6, 2, 4,
7680 6, 2, 4, 2, 4, 1, 0, 1, 1, 1,
7681 1, 1, 1, 1, 1, 1, 3, 1, 3, 1,
7682 1, 1, 1, 2, 1, 1, 1, 2, 1, 1,
7683 1, 2, 1, 2, 1, 1, 1, 1, 0, 4,
7684 1, 2, 1, 3, 3, 2, 1, 4, 2, 1,
7685 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7686 1, 1, 1, 2, 2, 2, 1, 1, 1, 1,
7691enum { YYENOMEM = -2 };
7693#define yyerrok (yyerrstatus = 0)
7694#define yyclearin (yychar = YYEMPTY)
7696#define YYACCEPT goto yyacceptlab
7697#define YYABORT goto yyabortlab
7698#define YYERROR goto yyerrorlab
7699#define YYNOMEM goto yyexhaustedlab
7702#define YYRECOVERING() (!!yyerrstatus)
7704#define YYBACKUP(Token, Value) \
7706 if (yychar == YYEMPTY) \
7710 YYPOPSTACK (yylen); \
7716 yyerror (&yylloc, p, YY_("syntax error: cannot back up")); \
7723#define YYERRCODE YYUNDEF
7729#ifndef YYLLOC_DEFAULT
7730# define YYLLOC_DEFAULT(Current, Rhs, N) \
7734 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
7735 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
7736 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
7737 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
7741 (Current).first_line = (Current).last_line = \
7742 YYRHSLOC (Rhs, 0).last_line; \
7743 (Current).first_column = (Current).last_column = \
7744 YYRHSLOC (Rhs, 0).last_column; \
7749#define YYRHSLOC(Rhs, K) ((Rhs)[K])
7757# define YYFPRINTF fprintf
7760# define YYDPRINTF(Args) \
7771# ifndef YYLOCATION_PRINT
7773# if defined YY_LOCATION_PRINT
7777# define YYLOCATION_PRINT(File, Loc, p) YY_LOCATION_PRINT(File, *(Loc), p)
7779# elif defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
7785yy_location_print_ (
FILE *yyo,
YYLTYPE const *
const yylocp)
7788 int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
7789 if (0 <= yylocp->first_line)
7791 res += YYFPRINTF (yyo,
"%d", yylocp->first_line);
7792 if (0 <= yylocp->first_column)
7793 res += YYFPRINTF (yyo,
".%d", yylocp->first_column);
7795 if (0 <= yylocp->last_line)
7797 if (yylocp->first_line < yylocp->last_line)
7799 res += YYFPRINTF (yyo,
"-%d", yylocp->last_line);
7801 res += YYFPRINTF (yyo,
".%d", end_col);
7803 else if (0 <= end_col && yylocp->first_column < end_col)
7804 res += YYFPRINTF (yyo,
"-%d", end_col);
7809# define YYLOCATION_PRINT yy_location_print_
7813# define YY_LOCATION_PRINT(File, Loc, p) YYLOCATION_PRINT(File, &(Loc), p)
7817# define YYLOCATION_PRINT(File, Loc, p) ((void) 0)
7820# define YY_LOCATION_PRINT YYLOCATION_PRINT
7826# define YY_SYMBOL_PRINT(Title, Kind, Value, Location, p) \
7830 YYFPRINTF (stderr, "%s ", Title); \
7831 yy_symbol_print (stderr, \
7832 Kind, Value, Location, p); \
7833 YYFPRINTF (stderr, "\n"); \
7843yy_symbol_value_print (
FILE *yyo,
7846 FILE *yyoutput = yyo;
7848 YY_USE (yylocationp);
7852 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
7855 case YYSYMBOL_keyword_class:
7858 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7863 case YYSYMBOL_keyword_module:
7866 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7871 case YYSYMBOL_keyword_def:
7874 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7879 case YYSYMBOL_keyword_undef:
7882 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7887 case YYSYMBOL_keyword_begin:
7890 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7895 case YYSYMBOL_keyword_rescue:
7898 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7903 case YYSYMBOL_keyword_ensure:
7906 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7911 case YYSYMBOL_keyword_end:
7914 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7919 case YYSYMBOL_keyword_if:
7922 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7927 case YYSYMBOL_keyword_unless:
7930 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7935 case YYSYMBOL_keyword_then:
7938 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7943 case YYSYMBOL_keyword_elsif:
7946 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7951 case YYSYMBOL_keyword_else:
7954 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7959 case YYSYMBOL_keyword_case:
7962 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7967 case YYSYMBOL_keyword_when:
7970 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7975 case YYSYMBOL_keyword_while:
7978 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7983 case YYSYMBOL_keyword_until:
7986 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7991 case YYSYMBOL_keyword_for:
7994 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
7999 case YYSYMBOL_keyword_break:
8002 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8007 case YYSYMBOL_keyword_next:
8010 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8015 case YYSYMBOL_keyword_redo:
8018 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8023 case YYSYMBOL_keyword_retry:
8026 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8031 case YYSYMBOL_keyword_in:
8034 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8039 case YYSYMBOL_keyword_do:
8042 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8047 case YYSYMBOL_keyword_do_cond:
8050 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8055 case YYSYMBOL_keyword_do_block:
8058 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8063 case YYSYMBOL_keyword_do_LAMBDA:
8066 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8071 case YYSYMBOL_keyword_return:
8074 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8079 case YYSYMBOL_keyword_yield:
8082 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8087 case YYSYMBOL_keyword_super:
8090 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8095 case YYSYMBOL_keyword_self:
8098 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8103 case YYSYMBOL_keyword_nil:
8106 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8111 case YYSYMBOL_keyword_true:
8114 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8119 case YYSYMBOL_keyword_false:
8122 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8127 case YYSYMBOL_keyword_and:
8130 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8135 case YYSYMBOL_keyword_or:
8138 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8143 case YYSYMBOL_keyword_not:
8146 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8151 case YYSYMBOL_modifier_if:
8154 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8159 case YYSYMBOL_modifier_unless:
8162 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8167 case YYSYMBOL_modifier_while:
8170 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8175 case YYSYMBOL_modifier_until:
8178 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8183 case YYSYMBOL_modifier_rescue:
8186 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8191 case YYSYMBOL_keyword_alias:
8194 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8199 case YYSYMBOL_keyword_defined:
8202 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8207 case YYSYMBOL_keyword_BEGIN:
8210 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8215 case YYSYMBOL_keyword_END:
8218 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8223 case YYSYMBOL_keyword__LINE__:
8226 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8231 case YYSYMBOL_keyword__FILE__:
8234 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8239 case YYSYMBOL_keyword__ENCODING__:
8242 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8247 case YYSYMBOL_tIDENTIFIER:
8250 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8258 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8263 case YYSYMBOL_tGVAR:
8266 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8271 case YYSYMBOL_tIVAR:
8274 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8279 case YYSYMBOL_tCONSTANT:
8282 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8287 case YYSYMBOL_tCVAR:
8290 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8295 case YYSYMBOL_tLABEL:
8298 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8303 case YYSYMBOL_tINTEGER:
8306 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8308 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8311 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8314 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8316 case NODE_IMAGINARY:
8317 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8326 case YYSYMBOL_tFLOAT:
8329 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8331 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8334 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8337 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8339 case NODE_IMAGINARY:
8340 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8349 case YYSYMBOL_tRATIONAL:
8352 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8354 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8357 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8360 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8362 case NODE_IMAGINARY:
8363 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8372 case YYSYMBOL_tIMAGINARY:
8375 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8377 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8380 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8383 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8385 case NODE_IMAGINARY:
8386 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8395 case YYSYMBOL_tCHAR:
8398 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8400 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8403 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8406 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8408 case NODE_IMAGINARY:
8409 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8418 case YYSYMBOL_tNTH_REF:
8421 rb_parser_printf(p,
"$%ld", RNODE_NTH_REF(((*yyvaluep).node))->nd_nth);
8426 case YYSYMBOL_tBACK_REF:
8429 rb_parser_printf(p,
"$%c", (
int)RNODE_BACK_REF(((*yyvaluep).node))->nd_nth);
8434 case YYSYMBOL_tSTRING_CONTENT:
8437 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8439 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8442 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8445 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8447 case NODE_IMAGINARY:
8448 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8460 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8465 case YYSYMBOL_70_backslash_:
8468 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8473 case YYSYMBOL_72_escaped_horizontal_tab_:
8476 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8481 case YYSYMBOL_73_escaped_form_feed_:
8484 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8489 case YYSYMBOL_74_escaped_carriage_return_:
8492 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8497 case YYSYMBOL_75_escaped_vertical_tab_:
8500 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8505 case YYSYMBOL_tANDDOT:
8508 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8513 case YYSYMBOL_tCOLON2:
8516 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8521 case YYSYMBOL_tOP_ASGN:
8524 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8529 case YYSYMBOL_compstmt_top_stmts:
8532 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8533 rb_parser_printf(p,
"NODE_SPECIAL");
8535 else if (((*yyvaluep).node)) {
8536 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8542 case YYSYMBOL_top_stmts:
8545 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8546 rb_parser_printf(p,
"NODE_SPECIAL");
8548 else if (((*yyvaluep).node)) {
8549 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8555 case YYSYMBOL_top_stmt:
8558 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8559 rb_parser_printf(p,
"NODE_SPECIAL");
8561 else if (((*yyvaluep).node)) {
8562 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8568 case YYSYMBOL_block_open:
8571 if ((
NODE *)((*yyvaluep).node_exits) == (
NODE *)-1) {
8572 rb_parser_printf(p,
"NODE_SPECIAL");
8574 else if (((*yyvaluep).node_exits)) {
8575 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_exits)))));
8581 case YYSYMBOL_begin_block:
8584 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8585 rb_parser_printf(p,
"NODE_SPECIAL");
8587 else if (((*yyvaluep).node)) {
8588 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8594 case YYSYMBOL_compstmt_stmts:
8597 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8598 rb_parser_printf(p,
"NODE_SPECIAL");
8600 else if (((*yyvaluep).node)) {
8601 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8607 case YYSYMBOL_bodystmt:
8610 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8611 rb_parser_printf(p,
"NODE_SPECIAL");
8613 else if (((*yyvaluep).node)) {
8614 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8620 case YYSYMBOL_stmts:
8623 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8624 rb_parser_printf(p,
"NODE_SPECIAL");
8626 else if (((*yyvaluep).node)) {
8627 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8633 case YYSYMBOL_stmt_or_begin:
8636 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8637 rb_parser_printf(p,
"NODE_SPECIAL");
8639 else if (((*yyvaluep).node)) {
8640 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8646 case YYSYMBOL_allow_exits:
8649 if ((
NODE *)((*yyvaluep).node_exits) == (
NODE *)-1) {
8650 rb_parser_printf(p,
"NODE_SPECIAL");
8652 else if (((*yyvaluep).node_exits)) {
8653 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_exits)))));
8662 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8663 rb_parser_printf(p,
"NODE_SPECIAL");
8665 else if (((*yyvaluep).node)) {
8666 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8672 case YYSYMBOL_asgn_mrhs:
8675 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8676 rb_parser_printf(p,
"NODE_SPECIAL");
8678 else if (((*yyvaluep).node)) {
8679 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8685 case YYSYMBOL_asgn_command_rhs:
8688 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8689 rb_parser_printf(p,
"NODE_SPECIAL");
8691 else if (((*yyvaluep).node)) {
8692 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8698 case YYSYMBOL_command_asgn:
8701 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8702 rb_parser_printf(p,
"NODE_SPECIAL");
8704 else if (((*yyvaluep).node)) {
8705 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8711 case YYSYMBOL_op_asgn_command_rhs:
8714 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8715 rb_parser_printf(p,
"NODE_SPECIAL");
8717 else if (((*yyvaluep).node)) {
8718 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8724 case YYSYMBOL_def_endless_method_endless_command:
8727 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8728 rb_parser_printf(p,
"NODE_SPECIAL");
8730 else if (((*yyvaluep).node)) {
8731 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8737 case YYSYMBOL_endless_command:
8740 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8741 rb_parser_printf(p,
"NODE_SPECIAL");
8743 else if (((*yyvaluep).node)) {
8744 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8750 case YYSYMBOL_command_rhs:
8753 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8754 rb_parser_printf(p,
"NODE_SPECIAL");
8756 else if (((*yyvaluep).node)) {
8757 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8766 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8767 rb_parser_printf(p,
"NODE_SPECIAL");
8769 else if (((*yyvaluep).node)) {
8770 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8776 case YYSYMBOL_def_name:
8779 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
8784 case YYSYMBOL_defn_head:
8787 if ((
NODE *)((*yyvaluep).node_def_temp) == (
NODE *)-1) {
8788 rb_parser_printf(p,
"NODE_SPECIAL");
8790 else if (((*yyvaluep).node_def_temp)) {
8791 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_def_temp)))));
8797 case YYSYMBOL_defs_head:
8800 if ((
NODE *)((*yyvaluep).node_def_temp) == (
NODE *)-1) {
8801 rb_parser_printf(p,
"NODE_SPECIAL");
8803 else if (((*yyvaluep).node_def_temp)) {
8804 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_def_temp)))));
8810 case YYSYMBOL_value_expr_expr:
8813 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8814 rb_parser_printf(p,
"NODE_SPECIAL");
8816 else if (((*yyvaluep).node)) {
8817 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8823 case YYSYMBOL_expr_value:
8826 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8827 rb_parser_printf(p,
"NODE_SPECIAL");
8829 else if (((*yyvaluep).node)) {
8830 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8836 case YYSYMBOL_expr_value_do:
8839 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8840 rb_parser_printf(p,
"NODE_SPECIAL");
8842 else if (((*yyvaluep).node)) {
8843 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8849 case YYSYMBOL_command_call:
8852 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8853 rb_parser_printf(p,
"NODE_SPECIAL");
8855 else if (((*yyvaluep).node)) {
8856 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8862 case YYSYMBOL_value_expr_command_call:
8865 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8866 rb_parser_printf(p,
"NODE_SPECIAL");
8868 else if (((*yyvaluep).node)) {
8869 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8875 case YYSYMBOL_command_call_value:
8878 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8879 rb_parser_printf(p,
"NODE_SPECIAL");
8881 else if (((*yyvaluep).node)) {
8882 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8888 case YYSYMBOL_block_command:
8891 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8892 rb_parser_printf(p,
"NODE_SPECIAL");
8894 else if (((*yyvaluep).node)) {
8895 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8901 case YYSYMBOL_cmd_brace_block:
8904 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8905 rb_parser_printf(p,
"NODE_SPECIAL");
8907 else if (((*yyvaluep).node)) {
8908 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8914 case YYSYMBOL_fcall:
8917 if ((
NODE *)((*yyvaluep).node_fcall) == (
NODE *)-1) {
8918 rb_parser_printf(p,
"NODE_SPECIAL");
8920 else if (((*yyvaluep).node_fcall)) {
8921 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_fcall)))));
8927 case YYSYMBOL_command:
8930 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8931 rb_parser_printf(p,
"NODE_SPECIAL");
8933 else if (((*yyvaluep).node)) {
8934 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8943 if ((
NODE *)((*yyvaluep).node_masgn) == (
NODE *)-1) {
8944 rb_parser_printf(p,
"NODE_SPECIAL");
8946 else if (((*yyvaluep).node_masgn)) {
8947 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_masgn)))));
8953 case YYSYMBOL_mlhs_inner:
8956 if ((
NODE *)((*yyvaluep).node_masgn) == (
NODE *)-1) {
8957 rb_parser_printf(p,
"NODE_SPECIAL");
8959 else if (((*yyvaluep).node_masgn)) {
8960 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_masgn)))));
8966 case YYSYMBOL_mlhs_basic:
8969 if ((
NODE *)((*yyvaluep).node_masgn) == (
NODE *)-1) {
8970 rb_parser_printf(p,
"NODE_SPECIAL");
8972 else if (((*yyvaluep).node_masgn)) {
8973 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_masgn)))));
8979 case YYSYMBOL_mlhs_mlhs_item:
8982 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8983 rb_parser_printf(p,
"NODE_SPECIAL");
8985 else if (((*yyvaluep).node)) {
8986 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8992 case YYSYMBOL_mlhs_item:
8995 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8996 rb_parser_printf(p,
"NODE_SPECIAL");
8998 else if (((*yyvaluep).node)) {
8999 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9005 case YYSYMBOL_mlhs_head:
9008 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9009 rb_parser_printf(p,
"NODE_SPECIAL");
9011 else if (((*yyvaluep).node)) {
9012 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9018 case YYSYMBOL_mlhs_node:
9021 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9022 rb_parser_printf(p,
"NODE_SPECIAL");
9024 else if (((*yyvaluep).node)) {
9025 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9034 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9035 rb_parser_printf(p,
"NODE_SPECIAL");
9037 else if (((*yyvaluep).node)) {
9038 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9044 case YYSYMBOL_cname:
9047 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9052 case YYSYMBOL_cpath:
9055 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9056 rb_parser_printf(p,
"NODE_SPECIAL");
9058 else if (((*yyvaluep).node)) {
9059 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9065 case YYSYMBOL_fname:
9068 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9073 case YYSYMBOL_fitem:
9076 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9077 rb_parser_printf(p,
"NODE_SPECIAL");
9079 else if (((*yyvaluep).node)) {
9080 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9086 case YYSYMBOL_undef_list:
9089 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9090 rb_parser_printf(p,
"NODE_SPECIAL");
9092 else if (((*yyvaluep).node)) {
9093 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9102 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9107 case YYSYMBOL_reswords:
9110 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9115 case YYSYMBOL_asgn_arg_rhs:
9118 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9119 rb_parser_printf(p,
"NODE_SPECIAL");
9121 else if (((*yyvaluep).node)) {
9122 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9131 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9132 rb_parser_printf(p,
"NODE_SPECIAL");
9134 else if (((*yyvaluep).node)) {
9135 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9141 case YYSYMBOL_op_asgn_arg_rhs:
9144 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9145 rb_parser_printf(p,
"NODE_SPECIAL");
9147 else if (((*yyvaluep).node)) {
9148 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9154 case YYSYMBOL_range_expr_arg:
9157 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9158 rb_parser_printf(p,
"NODE_SPECIAL");
9160 else if (((*yyvaluep).node)) {
9161 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9167 case YYSYMBOL_def_endless_method_endless_arg:
9170 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9171 rb_parser_printf(p,
"NODE_SPECIAL");
9173 else if (((*yyvaluep).node)) {
9174 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9180 case YYSYMBOL_ternary:
9183 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9184 rb_parser_printf(p,
"NODE_SPECIAL");
9186 else if (((*yyvaluep).node)) {
9187 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9193 case YYSYMBOL_endless_arg:
9196 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9197 rb_parser_printf(p,
"NODE_SPECIAL");
9199 else if (((*yyvaluep).node)) {
9200 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9206 case YYSYMBOL_relop:
9209 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9214 case YYSYMBOL_rel_expr:
9217 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9218 rb_parser_printf(p,
"NODE_SPECIAL");
9220 else if (((*yyvaluep).node)) {
9221 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9227 case YYSYMBOL_value_expr_arg:
9230 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9231 rb_parser_printf(p,
"NODE_SPECIAL");
9233 else if (((*yyvaluep).node)) {
9234 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9240 case YYSYMBOL_arg_value:
9243 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9244 rb_parser_printf(p,
"NODE_SPECIAL");
9246 else if (((*yyvaluep).node)) {
9247 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9253 case YYSYMBOL_aref_args:
9256 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9257 rb_parser_printf(p,
"NODE_SPECIAL");
9259 else if (((*yyvaluep).node)) {
9260 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9266 case YYSYMBOL_arg_rhs:
9269 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9270 rb_parser_printf(p,
"NODE_SPECIAL");
9272 else if (((*yyvaluep).node)) {
9273 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9279 case YYSYMBOL_paren_args:
9282 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9283 rb_parser_printf(p,
"NODE_SPECIAL");
9285 else if (((*yyvaluep).node)) {
9286 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9292 case YYSYMBOL_opt_paren_args:
9295 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9296 rb_parser_printf(p,
"NODE_SPECIAL");
9298 else if (((*yyvaluep).node)) {
9299 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9305 case YYSYMBOL_opt_call_args:
9308 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9309 rb_parser_printf(p,
"NODE_SPECIAL");
9311 else if (((*yyvaluep).node)) {
9312 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9318 case YYSYMBOL_value_expr_command:
9321 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9322 rb_parser_printf(p,
"NODE_SPECIAL");
9324 else if (((*yyvaluep).node)) {
9325 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9331 case YYSYMBOL_call_args:
9334 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9335 rb_parser_printf(p,
"NODE_SPECIAL");
9337 else if (((*yyvaluep).node)) {
9338 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9344 case YYSYMBOL_command_args:
9347 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9348 rb_parser_printf(p,
"NODE_SPECIAL");
9350 else if (((*yyvaluep).node)) {
9351 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9357 case YYSYMBOL_block_arg:
9360 if ((
NODE *)((*yyvaluep).node_block_pass) == (
NODE *)-1) {
9361 rb_parser_printf(p,
"NODE_SPECIAL");
9363 else if (((*yyvaluep).node_block_pass)) {
9364 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_block_pass)))));
9370 case YYSYMBOL_opt_block_arg:
9373 if ((
NODE *)((*yyvaluep).node_block_pass) == (
NODE *)-1) {
9374 rb_parser_printf(p,
"NODE_SPECIAL");
9376 else if (((*yyvaluep).node_block_pass)) {
9377 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_block_pass)))));
9386 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9387 rb_parser_printf(p,
"NODE_SPECIAL");
9389 else if (((*yyvaluep).node)) {
9390 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9396 case YYSYMBOL_arg_splat:
9399 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9400 rb_parser_printf(p,
"NODE_SPECIAL");
9402 else if (((*yyvaluep).node)) {
9403 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9409 case YYSYMBOL_mrhs_arg:
9412 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9413 rb_parser_printf(p,
"NODE_SPECIAL");
9415 else if (((*yyvaluep).node)) {
9416 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9425 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9426 rb_parser_printf(p,
"NODE_SPECIAL");
9428 else if (((*yyvaluep).node)) {
9429 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9435 case YYSYMBOL_primary:
9438 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9439 rb_parser_printf(p,
"NODE_SPECIAL");
9441 else if (((*yyvaluep).node)) {
9442 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9448 case YYSYMBOL_value_expr_primary:
9451 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9452 rb_parser_printf(p,
"NODE_SPECIAL");
9454 else if (((*yyvaluep).node)) {
9455 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9461 case YYSYMBOL_primary_value:
9464 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9465 rb_parser_printf(p,
"NODE_SPECIAL");
9467 else if (((*yyvaluep).node)) {
9468 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9474 case YYSYMBOL_k_while:
9477 if ((
NODE *)((*yyvaluep).node_exits) == (
NODE *)-1) {
9478 rb_parser_printf(p,
"NODE_SPECIAL");
9480 else if (((*yyvaluep).node_exits)) {
9481 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_exits)))));
9487 case YYSYMBOL_k_until:
9490 if ((
NODE *)((*yyvaluep).node_exits) == (
NODE *)-1) {
9491 rb_parser_printf(p,
"NODE_SPECIAL");
9493 else if (((*yyvaluep).node_exits)) {
9494 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_exits)))));
9500 case YYSYMBOL_k_for:
9503 if ((
NODE *)((*yyvaluep).node_exits) == (
NODE *)-1) {
9504 rb_parser_printf(p,
"NODE_SPECIAL");
9506 else if (((*yyvaluep).node_exits)) {
9507 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_exits)))));
9513 case YYSYMBOL_k_def:
9516 if ((
NODE *)((*yyvaluep).node_def_temp) == (
NODE *)-1) {
9517 rb_parser_printf(p,
"NODE_SPECIAL");
9519 else if (((*yyvaluep).node_def_temp)) {
9520 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_def_temp)))));
9529 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9534 case YYSYMBOL_if_tail:
9537 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9538 rb_parser_printf(p,
"NODE_SPECIAL");
9540 else if (((*yyvaluep).node)) {
9541 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9547 case YYSYMBOL_opt_else:
9550 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9551 rb_parser_printf(p,
"NODE_SPECIAL");
9553 else if (((*yyvaluep).node)) {
9554 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9560 case YYSYMBOL_for_var:
9563 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9564 rb_parser_printf(p,
"NODE_SPECIAL");
9566 else if (((*yyvaluep).node)) {
9567 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9573 case YYSYMBOL_f_marg:
9576 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9577 rb_parser_printf(p,
"NODE_SPECIAL");
9579 else if (((*yyvaluep).node)) {
9580 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9586 case YYSYMBOL_mlhs_f_marg:
9589 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9590 rb_parser_printf(p,
"NODE_SPECIAL");
9592 else if (((*yyvaluep).node)) {
9593 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9599 case YYSYMBOL_f_margs:
9602 if ((
NODE *)((*yyvaluep).node_masgn) == (
NODE *)-1) {
9603 rb_parser_printf(p,
"NODE_SPECIAL");
9605 else if (((*yyvaluep).node_masgn)) {
9606 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_masgn)))));
9612 case YYSYMBOL_f_rest_marg:
9615 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9616 rb_parser_printf(p,
"NODE_SPECIAL");
9618 else if (((*yyvaluep).node)) {
9619 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9625 case YYSYMBOL_f_any_kwrest:
9628 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9633 case YYSYMBOL_f_kw_primary_value:
9636 if ((
NODE *)((*yyvaluep).node_kw_arg) == (
NODE *)-1) {
9637 rb_parser_printf(p,
"NODE_SPECIAL");
9639 else if (((*yyvaluep).node_kw_arg)) {
9640 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_kw_arg)))));
9646 case YYSYMBOL_f_kwarg_primary_value:
9649 if ((
NODE *)((*yyvaluep).node_kw_arg) == (
NODE *)-1) {
9650 rb_parser_printf(p,
"NODE_SPECIAL");
9652 else if (((*yyvaluep).node_kw_arg)) {
9653 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_kw_arg)))));
9659 case YYSYMBOL_args_tail_basic_primary_value:
9662 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9663 rb_parser_printf(p,
"NODE_SPECIAL");
9665 else if (((*yyvaluep).node_args)) {
9666 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9672 case YYSYMBOL_block_args_tail:
9675 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9676 rb_parser_printf(p,
"NODE_SPECIAL");
9678 else if (((*yyvaluep).node_args)) {
9679 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9685 case YYSYMBOL_excessed_comma:
9688 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9693 case YYSYMBOL_f_opt_primary_value:
9696 if ((
NODE *)((*yyvaluep).node_opt_arg) == (
NODE *)-1) {
9697 rb_parser_printf(p,
"NODE_SPECIAL");
9699 else if (((*yyvaluep).node_opt_arg)) {
9700 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_opt_arg)))));
9706 case YYSYMBOL_f_opt_arg_primary_value:
9709 if ((
NODE *)((*yyvaluep).node_opt_arg) == (
NODE *)-1) {
9710 rb_parser_printf(p,
"NODE_SPECIAL");
9712 else if (((*yyvaluep).node_opt_arg)) {
9713 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_opt_arg)))));
9719 case YYSYMBOL_opt_args_tail_block_args_tail:
9722 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9723 rb_parser_printf(p,
"NODE_SPECIAL");
9725 else if (((*yyvaluep).node_args)) {
9726 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9732 case YYSYMBOL_block_param:
9735 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9736 rb_parser_printf(p,
"NODE_SPECIAL");
9738 else if (((*yyvaluep).node_args)) {
9739 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9745 case YYSYMBOL_opt_block_param_def:
9748 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9749 rb_parser_printf(p,
"NODE_SPECIAL");
9751 else if (((*yyvaluep).node_args)) {
9752 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9758 case YYSYMBOL_block_param_def:
9761 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9762 rb_parser_printf(p,
"NODE_SPECIAL");
9764 else if (((*yyvaluep).node_args)) {
9765 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9771 case YYSYMBOL_opt_block_param:
9774 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9775 rb_parser_printf(p,
"NODE_SPECIAL");
9777 else if (((*yyvaluep).node_args)) {
9778 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9784 case YYSYMBOL_opt_bv_decl:
9787 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9792 case YYSYMBOL_bv_decls:
9795 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9803 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9808 case YYSYMBOL_numparam:
9811 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9812 rb_parser_printf(p,
"NODE_SPECIAL");
9814 else if (((*yyvaluep).node)) {
9815 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9821 case YYSYMBOL_it_id:
9824 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
9829 case YYSYMBOL_lambda:
9832 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9833 rb_parser_printf(p,
"NODE_SPECIAL");
9835 else if (((*yyvaluep).node)) {
9836 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9842 case YYSYMBOL_f_larglist:
9845 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9846 rb_parser_printf(p,
"NODE_SPECIAL");
9848 else if (((*yyvaluep).node_args)) {
9849 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9855 case YYSYMBOL_do_block:
9858 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9859 rb_parser_printf(p,
"NODE_SPECIAL");
9861 else if (((*yyvaluep).node)) {
9862 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9868 case YYSYMBOL_block_call:
9871 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9872 rb_parser_printf(p,
"NODE_SPECIAL");
9874 else if (((*yyvaluep).node)) {
9875 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9881 case YYSYMBOL_method_call:
9884 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9885 rb_parser_printf(p,
"NODE_SPECIAL");
9887 else if (((*yyvaluep).node)) {
9888 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9894 case YYSYMBOL_brace_block:
9897 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9898 rb_parser_printf(p,
"NODE_SPECIAL");
9900 else if (((*yyvaluep).node)) {
9901 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9907 case YYSYMBOL_brace_body:
9910 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9911 rb_parser_printf(p,
"NODE_SPECIAL");
9913 else if (((*yyvaluep).node)) {
9914 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9920 case YYSYMBOL_do_body:
9923 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9924 rb_parser_printf(p,
"NODE_SPECIAL");
9926 else if (((*yyvaluep).node)) {
9927 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9933 case YYSYMBOL_case_args:
9936 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9937 rb_parser_printf(p,
"NODE_SPECIAL");
9939 else if (((*yyvaluep).node)) {
9940 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9946 case YYSYMBOL_case_body:
9949 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9950 rb_parser_printf(p,
"NODE_SPECIAL");
9952 else if (((*yyvaluep).node)) {
9953 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9959 case YYSYMBOL_cases:
9962 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9963 rb_parser_printf(p,
"NODE_SPECIAL");
9965 else if (((*yyvaluep).node)) {
9966 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9972 case YYSYMBOL_p_case_body:
9975 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9976 rb_parser_printf(p,
"NODE_SPECIAL");
9978 else if (((*yyvaluep).node)) {
9979 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9985 case YYSYMBOL_p_cases:
9988 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9989 rb_parser_printf(p,
"NODE_SPECIAL");
9991 else if (((*yyvaluep).node)) {
9992 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9998 case YYSYMBOL_p_top_expr:
10001 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10002 rb_parser_printf(p,
"NODE_SPECIAL");
10004 else if (((*yyvaluep).node)) {
10005 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10008#line 10009 "parse.c"
10011 case YYSYMBOL_p_top_expr_body:
10012#line 2617 "parse.y"
10014 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10015 rb_parser_printf(p,
"NODE_SPECIAL");
10017 else if (((*yyvaluep).node)) {
10018 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10021#line 10022 "parse.c"
10024 case YYSYMBOL_p_expr:
10025#line 2617 "parse.y"
10027 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10028 rb_parser_printf(p,
"NODE_SPECIAL");
10030 else if (((*yyvaluep).node)) {
10031 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10034#line 10035 "parse.c"
10037 case YYSYMBOL_p_as:
10038#line 2617 "parse.y"
10040 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10041 rb_parser_printf(p,
"NODE_SPECIAL");
10043 else if (((*yyvaluep).node)) {
10044 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10047#line 10048 "parse.c"
10050 case YYSYMBOL_p_alt:
10051#line 2617 "parse.y"
10053 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10054 rb_parser_printf(p,
"NODE_SPECIAL");
10056 else if (((*yyvaluep).node)) {
10057 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10060#line 10061 "parse.c"
10063 case YYSYMBOL_p_expr_basic:
10064#line 2617 "parse.y"
10066 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10067 rb_parser_printf(p,
"NODE_SPECIAL");
10069 else if (((*yyvaluep).node)) {
10070 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10073#line 10074 "parse.c"
10076 case YYSYMBOL_p_args:
10077#line 2617 "parse.y"
10079 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10080 rb_parser_printf(p,
"NODE_SPECIAL");
10082 else if (((*yyvaluep).node)) {
10083 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10086#line 10087 "parse.c"
10089 case YYSYMBOL_p_args_head:
10090#line 2617 "parse.y"
10092 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10093 rb_parser_printf(p,
"NODE_SPECIAL");
10095 else if (((*yyvaluep).node)) {
10096 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10099#line 10100 "parse.c"
10102 case YYSYMBOL_p_args_tail:
10103#line 2617 "parse.y"
10105 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10106 rb_parser_printf(p,
"NODE_SPECIAL");
10108 else if (((*yyvaluep).node)) {
10109 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10112#line 10113 "parse.c"
10115 case YYSYMBOL_p_find:
10116#line 2617 "parse.y"
10118 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10119 rb_parser_printf(p,
"NODE_SPECIAL");
10121 else if (((*yyvaluep).node)) {
10122 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10125#line 10126 "parse.c"
10128 case YYSYMBOL_p_rest:
10129#line 2617 "parse.y"
10131 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10132 rb_parser_printf(p,
"NODE_SPECIAL");
10134 else if (((*yyvaluep).node)) {
10135 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10138#line 10139 "parse.c"
10141 case YYSYMBOL_p_args_post:
10142#line 2617 "parse.y"
10144 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10145 rb_parser_printf(p,
"NODE_SPECIAL");
10147 else if (((*yyvaluep).node)) {
10148 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10151#line 10152 "parse.c"
10154 case YYSYMBOL_p_arg:
10155#line 2617 "parse.y"
10157 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10158 rb_parser_printf(p,
"NODE_SPECIAL");
10160 else if (((*yyvaluep).node)) {
10161 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10164#line 10165 "parse.c"
10167 case YYSYMBOL_p_kwargs:
10168#line 2617 "parse.y"
10170 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10171 rb_parser_printf(p,
"NODE_SPECIAL");
10173 else if (((*yyvaluep).node)) {
10174 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10177#line 10178 "parse.c"
10180 case YYSYMBOL_p_kwarg:
10181#line 2617 "parse.y"
10183 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10184 rb_parser_printf(p,
"NODE_SPECIAL");
10186 else if (((*yyvaluep).node)) {
10187 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10190#line 10191 "parse.c"
10193 case YYSYMBOL_p_kw:
10194#line 2617 "parse.y"
10196 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10197 rb_parser_printf(p,
"NODE_SPECIAL");
10199 else if (((*yyvaluep).node)) {
10200 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10203#line 10204 "parse.c"
10206 case YYSYMBOL_p_kw_label:
10207#line 2626 "parse.y"
10209 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
10211#line 10212 "parse.c"
10214 case YYSYMBOL_p_kwrest:
10215#line 2626 "parse.y"
10217 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
10219#line 10220 "parse.c"
10222 case YYSYMBOL_p_kwnorest:
10223#line 2626 "parse.y"
10225 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
10227#line 10228 "parse.c"
10230 case YYSYMBOL_p_any_kwrest:
10231#line 2626 "parse.y"
10233 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
10235#line 10236 "parse.c"
10238 case YYSYMBOL_p_value:
10239#line 2617 "parse.y"
10241 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10242 rb_parser_printf(p,
"NODE_SPECIAL");
10244 else if (((*yyvaluep).node)) {
10245 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10248#line 10249 "parse.c"
10251 case YYSYMBOL_range_expr_p_primitive:
10252#line 2617 "parse.y"
10254 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10255 rb_parser_printf(p,
"NODE_SPECIAL");
10257 else if (((*yyvaluep).node)) {
10258 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10261#line 10262 "parse.c"
10264 case YYSYMBOL_p_primitive:
10265#line 2617 "parse.y"
10267 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10268 rb_parser_printf(p,
"NODE_SPECIAL");
10270 else if (((*yyvaluep).node)) {
10271 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10274#line 10275 "parse.c"
10277 case YYSYMBOL_p_variable:
10278#line 2617 "parse.y"
10280 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10281 rb_parser_printf(p,
"NODE_SPECIAL");
10283 else if (((*yyvaluep).node)) {
10284 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10287#line 10288 "parse.c"
10290 case YYSYMBOL_p_var_ref:
10291#line 2617 "parse.y"
10293 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10294 rb_parser_printf(p,
"NODE_SPECIAL");
10296 else if (((*yyvaluep).node)) {
10297 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10300#line 10301 "parse.c"
10303 case YYSYMBOL_p_expr_ref:
10304#line 2617 "parse.y"
10306 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10307 rb_parser_printf(p,
"NODE_SPECIAL");
10309 else if (((*yyvaluep).node)) {
10310 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10313#line 10314 "parse.c"
10316 case YYSYMBOL_p_const:
10317#line 2617 "parse.y"
10319 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10320 rb_parser_printf(p,
"NODE_SPECIAL");
10322 else if (((*yyvaluep).node)) {
10323 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10326#line 10327 "parse.c"
10329 case YYSYMBOL_opt_rescue:
10330#line 2617 "parse.y"
10332 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10333 rb_parser_printf(p,
"NODE_SPECIAL");
10335 else if (((*yyvaluep).node)) {
10336 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10339#line 10340 "parse.c"
10342 case YYSYMBOL_exc_list:
10343#line 2617 "parse.y"
10345 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10346 rb_parser_printf(p,
"NODE_SPECIAL");
10348 else if (((*yyvaluep).node)) {
10349 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10352#line 10353 "parse.c"
10355 case YYSYMBOL_exc_var:
10356#line 2617 "parse.y"
10358 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10359 rb_parser_printf(p,
"NODE_SPECIAL");
10361 else if (((*yyvaluep).node)) {
10362 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10365#line 10366 "parse.c"
10368 case YYSYMBOL_opt_ensure:
10369#line 2617 "parse.y"
10371 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10372 rb_parser_printf(p,
"NODE_SPECIAL");
10374 else if (((*yyvaluep).node)) {
10375 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10378#line 10379 "parse.c"
10381 case YYSYMBOL_literal:
10382#line 2617 "parse.y"
10384 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10385 rb_parser_printf(p,
"NODE_SPECIAL");
10387 else if (((*yyvaluep).node)) {
10388 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10391#line 10392 "parse.c"
10394 case YYSYMBOL_strings:
10395#line 2617 "parse.y"
10397 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10398 rb_parser_printf(p,
"NODE_SPECIAL");
10400 else if (((*yyvaluep).node)) {
10401 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10404#line 10405 "parse.c"
10407 case YYSYMBOL_string:
10408#line 2617 "parse.y"
10410 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10411 rb_parser_printf(p,
"NODE_SPECIAL");
10413 else if (((*yyvaluep).node)) {
10414 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10417#line 10418 "parse.c"
10420 case YYSYMBOL_string1:
10421#line 2617 "parse.y"
10423 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10424 rb_parser_printf(p,
"NODE_SPECIAL");
10426 else if (((*yyvaluep).node)) {
10427 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10430#line 10431 "parse.c"
10433 case YYSYMBOL_xstring:
10434#line 2617 "parse.y"
10436 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10437 rb_parser_printf(p,
"NODE_SPECIAL");
10439 else if (((*yyvaluep).node)) {
10440 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10443#line 10444 "parse.c"
10446 case YYSYMBOL_regexp:
10447#line 2617 "parse.y"
10449 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10450 rb_parser_printf(p,
"NODE_SPECIAL");
10452 else if (((*yyvaluep).node)) {
10453 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10456#line 10457 "parse.c"
10459 case YYSYMBOL_words_tWORDS_BEG_word_list:
10460#line 2617 "parse.y"
10462 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10463 rb_parser_printf(p,
"NODE_SPECIAL");
10465 else if (((*yyvaluep).node)) {
10466 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10469#line 10470 "parse.c"
10472 case YYSYMBOL_words:
10473#line 2617 "parse.y"
10475 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10476 rb_parser_printf(p,
"NODE_SPECIAL");
10478 else if (((*yyvaluep).node)) {
10479 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10482#line 10483 "parse.c"
10485 case YYSYMBOL_word_list:
10486#line 2617 "parse.y"
10488 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10489 rb_parser_printf(p,
"NODE_SPECIAL");
10491 else if (((*yyvaluep).node)) {
10492 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10495#line 10496 "parse.c"
10498 case YYSYMBOL_word:
10499#line 2617 "parse.y"
10501 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10502 rb_parser_printf(p,
"NODE_SPECIAL");
10504 else if (((*yyvaluep).node)) {
10505 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10508#line 10509 "parse.c"
10511 case YYSYMBOL_words_tSYMBOLS_BEG_symbol_list:
10512#line 2617 "parse.y"
10514 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10515 rb_parser_printf(p,
"NODE_SPECIAL");
10517 else if (((*yyvaluep).node)) {
10518 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10521#line 10522 "parse.c"
10524 case YYSYMBOL_symbols:
10525#line 2617 "parse.y"
10527 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10528 rb_parser_printf(p,
"NODE_SPECIAL");
10530 else if (((*yyvaluep).node)) {
10531 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10534#line 10535 "parse.c"
10537 case YYSYMBOL_symbol_list:
10538#line 2617 "parse.y"
10540 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10541 rb_parser_printf(p,
"NODE_SPECIAL");
10543 else if (((*yyvaluep).node)) {
10544 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10547#line 10548 "parse.c"
10550 case YYSYMBOL_words_tQWORDS_BEG_qword_list:
10551#line 2617 "parse.y"
10553 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10554 rb_parser_printf(p,
"NODE_SPECIAL");
10556 else if (((*yyvaluep).node)) {
10557 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10560#line 10561 "parse.c"
10563 case YYSYMBOL_qwords:
10564#line 2617 "parse.y"
10566 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10567 rb_parser_printf(p,
"NODE_SPECIAL");
10569 else if (((*yyvaluep).node)) {
10570 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10573#line 10574 "parse.c"
10576 case YYSYMBOL_words_tQSYMBOLS_BEG_qsym_list:
10577#line 2617 "parse.y"
10579 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10580 rb_parser_printf(p,
"NODE_SPECIAL");
10582 else if (((*yyvaluep).node)) {
10583 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10586#line 10587 "parse.c"
10589 case YYSYMBOL_qsymbols:
10590#line 2617 "parse.y"
10592 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10593 rb_parser_printf(p,
"NODE_SPECIAL");
10595 else if (((*yyvaluep).node)) {
10596 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10599#line 10600 "parse.c"
10602 case YYSYMBOL_qword_list:
10603#line 2617 "parse.y"
10605 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10606 rb_parser_printf(p,
"NODE_SPECIAL");
10608 else if (((*yyvaluep).node)) {
10609 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10612#line 10613 "parse.c"
10615 case YYSYMBOL_qsym_list:
10616#line 2617 "parse.y"
10618 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10619 rb_parser_printf(p,
"NODE_SPECIAL");
10621 else if (((*yyvaluep).node)) {
10622 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10625#line 10626 "parse.c"
10628 case YYSYMBOL_string_contents:
10629#line 2617 "parse.y"
10631 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10632 rb_parser_printf(p,
"NODE_SPECIAL");
10634 else if (((*yyvaluep).node)) {
10635 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10638#line 10639 "parse.c"
10641 case YYSYMBOL_xstring_contents:
10642#line 2617 "parse.y"
10644 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10645 rb_parser_printf(p,
"NODE_SPECIAL");
10647 else if (((*yyvaluep).node)) {
10648 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10651#line 10652 "parse.c"
10654 case YYSYMBOL_regexp_contents:
10655#line 2617 "parse.y"
10657 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10658 rb_parser_printf(p,
"NODE_SPECIAL");
10660 else if (((*yyvaluep).node)) {
10661 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10664#line 10665 "parse.c"
10667 case YYSYMBOL_string_content:
10668#line 2617 "parse.y"
10670 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10671 rb_parser_printf(p,
"NODE_SPECIAL");
10673 else if (((*yyvaluep).node)) {
10674 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10677#line 10678 "parse.c"
10680 case YYSYMBOL_string_dvar:
10681#line 2617 "parse.y"
10683 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10684 rb_parser_printf(p,
"NODE_SPECIAL");
10686 else if (((*yyvaluep).node)) {
10687 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10690#line 10691 "parse.c"
10693 case YYSYMBOL_symbol:
10694#line 2617 "parse.y"
10696 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10697 rb_parser_printf(p,
"NODE_SPECIAL");
10699 else if (((*yyvaluep).node)) {
10700 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10703#line 10704 "parse.c"
10706 case YYSYMBOL_ssym:
10707#line 2617 "parse.y"
10709 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10710 rb_parser_printf(p,
"NODE_SPECIAL");
10712 else if (((*yyvaluep).node)) {
10713 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10716#line 10717 "parse.c"
10720#line 2626 "parse.y"
10722 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
10724#line 10725 "parse.c"
10727 case YYSYMBOL_dsym:
10728#line 2617 "parse.y"
10730 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10731 rb_parser_printf(p,
"NODE_SPECIAL");
10733 else if (((*yyvaluep).node)) {
10734 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10737#line 10738 "parse.c"
10740 case YYSYMBOL_numeric:
10741#line 2617 "parse.y"
10743 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10744 rb_parser_printf(p,
"NODE_SPECIAL");
10746 else if (((*yyvaluep).node)) {
10747 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10750#line 10751 "parse.c"
10753 case YYSYMBOL_simple_numeric:
10754#line 2617 "parse.y"
10756 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10757 rb_parser_printf(p,
"NODE_SPECIAL");
10759 else if (((*yyvaluep).node)) {
10760 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10763#line 10764 "parse.c"
10766 case YYSYMBOL_nonlocal_var:
10767#line 2626 "parse.y"
10769 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
10771#line 10772 "parse.c"
10774 case YYSYMBOL_user_variable:
10775#line 2626 "parse.y"
10777 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
10779#line 10780 "parse.c"
10782 case YYSYMBOL_keyword_variable:
10783#line 2626 "parse.y"
10785 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
10787#line 10788 "parse.c"
10790 case YYSYMBOL_var_ref:
10791#line 2617 "parse.y"
10793 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10794 rb_parser_printf(p,
"NODE_SPECIAL");
10796 else if (((*yyvaluep).node)) {
10797 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10800#line 10801 "parse.c"
10803 case YYSYMBOL_var_lhs:
10804#line 2617 "parse.y"
10806 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10807 rb_parser_printf(p,
"NODE_SPECIAL");
10809 else if (((*yyvaluep).node)) {
10810 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10813#line 10814 "parse.c"
10816 case YYSYMBOL_backref:
10817#line 2617 "parse.y"
10819 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10820 rb_parser_printf(p,
"NODE_SPECIAL");
10822 else if (((*yyvaluep).node)) {
10823 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10826#line 10827 "parse.c"
10829 case YYSYMBOL_superclass:
10830#line 2617 "parse.y"
10832 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10833 rb_parser_printf(p,
"NODE_SPECIAL");
10835 else if (((*yyvaluep).node)) {
10836 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10839#line 10840 "parse.c"
10842 case YYSYMBOL_f_opt_paren_args:
10843#line 2617 "parse.y"
10845 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10846 rb_parser_printf(p,
"NODE_SPECIAL");
10848 else if (((*yyvaluep).node_args)) {
10849 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10852#line 10853 "parse.c"
10855 case YYSYMBOL_f_paren_args:
10856#line 2617 "parse.y"
10858 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10859 rb_parser_printf(p,
"NODE_SPECIAL");
10861 else if (((*yyvaluep).node_args)) {
10862 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10865#line 10866 "parse.c"
10868 case YYSYMBOL_f_arglist:
10869#line 2617 "parse.y"
10871 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10872 rb_parser_printf(p,
"NODE_SPECIAL");
10874 else if (((*yyvaluep).node_args)) {
10875 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10878#line 10879 "parse.c"
10881 case YYSYMBOL_f_kw_arg_value:
10882#line 2617 "parse.y"
10884 if ((
NODE *)((*yyvaluep).node_kw_arg) == (
NODE *)-1) {
10885 rb_parser_printf(p,
"NODE_SPECIAL");
10887 else if (((*yyvaluep).node_kw_arg)) {
10888 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_kw_arg)))));
10891#line 10892 "parse.c"
10894 case YYSYMBOL_f_kwarg_arg_value:
10895#line 2617 "parse.y"
10897 if ((
NODE *)((*yyvaluep).node_kw_arg) == (
NODE *)-1) {
10898 rb_parser_printf(p,
"NODE_SPECIAL");
10900 else if (((*yyvaluep).node_kw_arg)) {
10901 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_kw_arg)))));
10904#line 10905 "parse.c"
10907 case YYSYMBOL_args_tail_basic_arg_value:
10908#line 2617 "parse.y"
10910 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10911 rb_parser_printf(p,
"NODE_SPECIAL");
10913 else if (((*yyvaluep).node_args)) {
10914 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10917#line 10918 "parse.c"
10920 case YYSYMBOL_args_tail:
10921#line 2617 "parse.y"
10923 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10924 rb_parser_printf(p,
"NODE_SPECIAL");
10926 else if (((*yyvaluep).node_args)) {
10927 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10930#line 10931 "parse.c"
10933 case YYSYMBOL_f_opt_arg_value:
10934#line 2617 "parse.y"
10936 if ((
NODE *)((*yyvaluep).node_opt_arg) == (
NODE *)-1) {
10937 rb_parser_printf(p,
"NODE_SPECIAL");
10939 else if (((*yyvaluep).node_opt_arg)) {
10940 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_opt_arg)))));
10943#line 10944 "parse.c"
10946 case YYSYMBOL_f_opt_arg_arg_value:
10947#line 2617 "parse.y"
10949 if ((
NODE *)((*yyvaluep).node_opt_arg) == (
NODE *)-1) {
10950 rb_parser_printf(p,
"NODE_SPECIAL");
10952 else if (((*yyvaluep).node_opt_arg)) {
10953 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_opt_arg)))));
10956#line 10957 "parse.c"
10959 case YYSYMBOL_opt_args_tail_args_tail:
10960#line 2617 "parse.y"
10962 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10963 rb_parser_printf(p,
"NODE_SPECIAL");
10965 else if (((*yyvaluep).node_args)) {
10966 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10969#line 10970 "parse.c"
10972 case YYSYMBOL_f_args:
10973#line 2617 "parse.y"
10975 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10976 rb_parser_printf(p,
"NODE_SPECIAL");
10978 else if (((*yyvaluep).node_args)) {
10979 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10982#line 10983 "parse.c"
10985 case YYSYMBOL_args_forward:
10986#line 2626 "parse.y"
10988 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
10990#line 10991 "parse.c"
10993 case YYSYMBOL_f_bad_arg:
10994#line 2626 "parse.y"
10996 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
10998#line 10999 "parse.c"
11001 case YYSYMBOL_f_norm_arg:
11002#line 2626 "parse.y"
11004 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11006#line 11007 "parse.c"
11009 case YYSYMBOL_f_arg_asgn:
11010#line 2626 "parse.y"
11012 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11014#line 11015 "parse.c"
11017 case YYSYMBOL_f_arg_item:
11018#line 2617 "parse.y"
11020 if ((
NODE *)((*yyvaluep).node_args_aux) == (
NODE *)-1) {
11021 rb_parser_printf(p,
"NODE_SPECIAL");
11023 else if (((*yyvaluep).node_args_aux)) {
11024 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args_aux)))));
11027#line 11028 "parse.c"
11030 case YYSYMBOL_f_arg:
11031#line 2617 "parse.y"
11033 if ((
NODE *)((*yyvaluep).node_args_aux) == (
NODE *)-1) {
11034 rb_parser_printf(p,
"NODE_SPECIAL");
11036 else if (((*yyvaluep).node_args_aux)) {
11037 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args_aux)))));
11040#line 11041 "parse.c"
11043 case YYSYMBOL_f_label:
11044#line 2626 "parse.y"
11046 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11048#line 11049 "parse.c"
11051 case YYSYMBOL_f_no_kwarg:
11052#line 2626 "parse.y"
11054 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11056#line 11057 "parse.c"
11059 case YYSYMBOL_f_kwrest:
11060#line 2626 "parse.y"
11062 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11064#line 11065 "parse.c"
11067 case YYSYMBOL_f_rest_arg:
11068#line 2626 "parse.y"
11070 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11072#line 11073 "parse.c"
11075 case YYSYMBOL_f_block_arg:
11076#line 2626 "parse.y"
11078 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11080#line 11081 "parse.c"
11083 case YYSYMBOL_opt_f_block_arg:
11084#line 2626 "parse.y"
11086 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11088#line 11089 "parse.c"
11091 case YYSYMBOL_value_expr_singleton_expr:
11092#line 2617 "parse.y"
11094 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
11095 rb_parser_printf(p,
"NODE_SPECIAL");
11097 else if (((*yyvaluep).node)) {
11098 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
11101#line 11102 "parse.c"
11104 case YYSYMBOL_singleton:
11105#line 2617 "parse.y"
11107 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
11108 rb_parser_printf(p,
"NODE_SPECIAL");
11110 else if (((*yyvaluep).node)) {
11111 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
11114#line 11115 "parse.c"
11117 case YYSYMBOL_singleton_expr:
11118#line 2617 "parse.y"
11120 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
11121 rb_parser_printf(p,
"NODE_SPECIAL");
11123 else if (((*yyvaluep).node)) {
11124 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
11127#line 11128 "parse.c"
11130 case YYSYMBOL_assoc_list:
11131#line 2617 "parse.y"
11133 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
11134 rb_parser_printf(p,
"NODE_SPECIAL");
11136 else if (((*yyvaluep).node)) {
11137 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
11140#line 11141 "parse.c"
11143 case YYSYMBOL_assocs:
11144#line 2617 "parse.y"
11146 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
11147 rb_parser_printf(p,
"NODE_SPECIAL");
11149 else if (((*yyvaluep).node)) {
11150 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
11153#line 11154 "parse.c"
11156 case YYSYMBOL_assoc:
11157#line 2617 "parse.y"
11159 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
11160 rb_parser_printf(p,
"NODE_SPECIAL");
11162 else if (((*yyvaluep).node)) {
11163 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
11166#line 11167 "parse.c"
11169 case YYSYMBOL_operation2:
11170#line 2626 "parse.y"
11172 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11174#line 11175 "parse.c"
11177 case YYSYMBOL_operation3:
11178#line 2626 "parse.y"
11180 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11182#line 11183 "parse.c"
11185 case YYSYMBOL_dot_or_colon:
11186#line 2626 "parse.y"
11188 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11190#line 11191 "parse.c"
11193 case YYSYMBOL_call_op:
11194#line 2626 "parse.y"
11196 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11198#line 11199 "parse.c"
11201 case YYSYMBOL_call_op2:
11202#line 2626 "parse.y"
11204 rb_parser_printf(p,
"%"PRIsVALUE, rb_id2str(((*yyvaluep).id)));
11206#line 11207 "parse.c"
11209 case YYSYMBOL_none:
11210#line 2617 "parse.y"
11212 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
11213 rb_parser_printf(p,
"NODE_SPECIAL");
11215 else if (((*yyvaluep).node)) {
11216 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
11219#line 11220 "parse.c"
11225 YY_IGNORE_MAYBE_UNINITIALIZED_END
11234yy_symbol_print (
FILE *yyo,
11237 YYFPRINTF (yyo,
"%s %s (",
11238 yykind < YYNTOKENS ?
"token" :
"nterm", yysymbol_name (yykind));
11240 YYLOCATION_PRINT (yyo, yylocationp, p);
11241 YYFPRINTF (yyo,
": ");
11242 yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp, p);
11243 YYFPRINTF (yyo,
")");
11252yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop,
struct parser_params *p)
11254 YYFPRINTF (stderr,
"Stack now");
11255 for (; yybottom <= yytop; yybottom++)
11257 int yybot = *yybottom;
11258 YYFPRINTF (stderr,
" %d", yybot);
11260 YYFPRINTF (stderr,
"\n");
11263# define YY_STACK_PRINT(Bottom, Top, p) \
11266 yy_stack_print ((Bottom), (Top), p); \
11275yy_reduce_print (yy_state_t *yyssp,
YYSTYPE *yyvsp,
YYLTYPE *yylsp,
11278 int yylno = yyrline[yyrule];
11279 int yynrhs = yyr2[yyrule];
11281 YYFPRINTF (stderr,
"Reducing stack by rule %d (line %d):\n",
11282 yyrule - 1, yylno);
11284 for (yyi = 0; yyi < yynrhs; yyi++)
11286 YYFPRINTF (stderr,
" $%d = ", yyi + 1);
11287 yy_symbol_print (stderr,
11288 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
11289 &yyvsp[(yyi + 1) - (yynrhs)],
11290 &(yylsp[(yyi + 1) - (yynrhs)]), p);
11291 YYFPRINTF (stderr,
"\n");
11295# define YY_REDUCE_PRINT(Rule, p) \
11298 yy_reduce_print (yyssp, yyvsp, yylsp, Rule, p); \
11307# define YYDPRINTF(Args) ((void) 0)
11308# define YY_SYMBOL_PRINT(Title, Kind, Value, Location, p)
11309# define YY_STACK_PRINT(Bottom, Top, p)
11310# define YY_REDUCE_PRINT(Rule, p)
11316# define YYINITDEPTH 200
11327# define YYMAXDEPTH 10000
11335 yysymbol_kind_t yytoken;
11347 yysymbol_kind_t yyarg[],
int yyargn)
11351 int yyn = yypact[+*yyctx->yyssp];
11352 if (!yypact_value_is_default (yyn))
11357 int yyxbegin = yyn < 0 ? -yyn : 0;
11359 int yychecklim = YYLAST - yyn + 1;
11360 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
11362 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
11363 if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror
11364 && !yytable_value_is_error (yytable[yyx + yyn]))
11368 else if (yycount == yyargn)
11371 yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx);
11374 if (yyarg && yycount == 0 && 0 < yyargn)
11375 yyarg[0] = YYSYMBOL_YYEMPTY;
11383# if defined __GLIBC__ && defined _STRING_H
11384# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
11388yystrlen (
const char *yystr)
11391 for (yylen = 0; yystr[yylen]; yylen++)
11399# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
11400# define yystpcpy stpcpy
11405yystpcpy (
char *yydest,
const char *yysrc)
11407 char *yyd = yydest;
11408 const char *yys = yysrc;
11410 while ((*yyd++ = *yys++) !=
'\0')
11427yytnamerr (
char *yyres,
const char *yystr)
11431 YYPTRDIFF_T yyn = 0;
11432 char const *yyp = yystr;
11438 goto do_not_strip_quotes;
11441 if (*++yyp !=
'\\')
11442 goto do_not_strip_quotes;
11458 do_not_strip_quotes: ;
11462 return yystpcpy (yyres, yystr) - yyres;
11464 return yystrlen (yystr);
11471 yysymbol_kind_t yyarg[],
int yyargn)
11498 if (yyctx->yytoken != YYSYMBOL_YYEMPTY)
11502 yyarg[yycount] = yyctx->yytoken;
11504 yyn = yypcontext_expected_tokens (yyctx,
11505 yyarg ? yyarg + 1 : yyarg, yyargn - 1);
11506 if (yyn == YYENOMEM)
11523yysyntax_error (YYPTRDIFF_T *yymsg_alloc,
char **yymsg,
11526 enum { YYARGS_MAX = 5 };
11528 const char *yyformat = YY_NULLPTR;
11531 yysymbol_kind_t yyarg[YYARGS_MAX];
11533 YYPTRDIFF_T yysize = 0;
11536 int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX);
11537 if (yycount == YYENOMEM)
11542#define YYCASE_(N, S) \
11547 YYCASE_(0, YY_(
"syntax error"));
11548 YYCASE_(1, YY_(
"syntax error, unexpected %s"));
11549 YYCASE_(2, YY_(
"syntax error, unexpected %s, expecting %s"));
11550 YYCASE_(3, YY_(
"syntax error, unexpected %s, expecting %s or %s"));
11551 YYCASE_(4, YY_(
"syntax error, unexpected %s, expecting %s or %s or %s"));
11552 YYCASE_(5, YY_(
"syntax error, unexpected %s, expecting %s or %s or %s or %s"));
11558 yysize = yystrlen (yyformat) - 2 * yycount + 1;
11561 for (yyi = 0; yyi < yycount; ++yyi)
11563 YYPTRDIFF_T yysize1
11564 = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]);
11565 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
11572 if (*yymsg_alloc < yysize)
11574 *yymsg_alloc = 2 * yysize;
11575 if (! (yysize <= *yymsg_alloc
11576 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
11577 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
11585 char *yyp = *yymsg;
11587 while ((*yyp = *yyformat) !=
'\0')
11588 if (*yyp ==
'%' && yyformat[1] ==
's' && yyi < yycount)
11590 yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]);
11608yydestruct (
const char *yymsg,
11612 YY_USE (yylocationp);
11615 yymsg =
"Deleting";
11616 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp, p);
11618 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
11621 case YYSYMBOL_258_16:
11622#line 2654 "parse.y"
11624 if (CASE_LABELS_ENABLED_P(((*yyvaluep).labels))) st_free_table(((*yyvaluep).labels));
11626#line 11627 "parse.c"
11629 case YYSYMBOL_259_17:
11630#line 2654 "parse.y"
11632 if (CASE_LABELS_ENABLED_P(((*yyvaluep).labels))) st_free_table(((*yyvaluep).labels));
11634#line 11635 "parse.c"
11640 YY_IGNORE_MAYBE_UNINITIALIZED_END
11663static const YYSTYPE yyval_default = {};
11664(void) yyval_default;
11666YY_INITIAL_VALUE (
static const YYSTYPE yyval_default;)
11668YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
11671static const YYLTYPE yyloc_default
11672# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
11676YYLTYPE yylloc = yyloc_default;
11682 yy_state_fast_t yystate = 0;
11684 int yyerrstatus = 0;
11690 YYPTRDIFF_T yystacksize = YYINITDEPTH;
11693 yy_state_t yyssa[YYINITDEPTH];
11694 yy_state_t *yyss = yyssa;
11695 yy_state_t *yyssp = yyss;
11711 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
11721 char yymsgbuf[128];
11722 char *yymsg = yymsgbuf;
11723 YYPTRDIFF_T yymsg_alloc =
sizeof yymsgbuf;
11725#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
11731 YYDPRINTF ((stderr,
"Starting parse\n"));
11737#line 2661 "parse.y"
11739 RUBY_SET_YYLLOC_OF_NONE(yylloc);
11742#line 11743 "parse.c"
11761 YYDPRINTF ((stderr,
"Entering state %d\n", yystate));
11762 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
11763 YY_IGNORE_USELESS_CAST_BEGIN
11764 *yyssp = YY_CAST (yy_state_t, yystate);
11765 YY_IGNORE_USELESS_CAST_END
11766 YY_STACK_PRINT (yyss, yyssp, p);
11768 if (yyss + yystacksize - 1 <= yyssp)
11769#if !defined yyoverflow && !defined YYSTACK_RELOCATE
11774 YYPTRDIFF_T yysize = yyssp - yyss + 1;
11776# if defined yyoverflow
11781 yy_state_t *yyss1 = yyss;
11789 yyoverflow (YY_(
"memory exhausted"),
11790 &yyss1, yysize * YYSIZEOF (*yyssp),
11791 &yyvs1, yysize * YYSIZEOF (*yyvsp),
11792 &yyls1, yysize * YYSIZEOF (*yylsp),
11800 if (YYMAXDEPTH <= yystacksize)
11803 if (YYMAXDEPTH < yystacksize)
11804 yystacksize = YYMAXDEPTH;
11807 yy_state_t *yyss1 = yyss;
11808 union yyalloc *yyptr =
11809 YY_CAST (
union yyalloc *,
11810 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
11813 YYSTACK_RELOCATE (yyss_alloc, yyss);
11814 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
11815 YYSTACK_RELOCATE (yyls_alloc, yyls);
11816# undef YYSTACK_RELOCATE
11817 if (yyss1 != yyssa)
11818 YYSTACK_FREE (yyss1);
11822 yyssp = yyss + yysize - 1;
11823 yyvsp = yyvs + yysize - 1;
11824 yylsp = yyls + yysize - 1;
11826 YY_IGNORE_USELESS_CAST_BEGIN
11827 YYDPRINTF ((stderr,
"Stack size increased to %ld\n",
11828 YY_CAST (
long, yystacksize)));
11829 YY_IGNORE_USELESS_CAST_END
11831 if (yyss + yystacksize - 1 <= yyssp)
11837 if (yystate == YYFINAL)
11851 yyn = yypact[yystate];
11852 if (yypact_value_is_default (yyn))
11858 if (yychar == YYEMPTY)
11860 YYDPRINTF ((stderr,
"Reading a token\n"));
11861 yychar = yylex (&yylval, &yylloc, p);
11864 if (yychar <= END_OF_INPUT)
11866 yychar = END_OF_INPUT;
11867 yytoken = YYSYMBOL_YYEOF;
11868 YYDPRINTF ((stderr,
"Now at end of input.\n"));
11870 else if (yychar == YYerror)
11877 yytoken = YYSYMBOL_YYerror;
11878 yyerror_range[1] = yylloc;
11883 yytoken = YYTRANSLATE (yychar);
11884 YY_SYMBOL_PRINT (
"Next token is", yytoken, &yylval, &yylloc, p);
11890 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
11892 yyn = yytable[yyn];
11895 if (yytable_value_is_error (yyn))
11907 YY_SYMBOL_PRINT (
"Shifting", yytoken, &yylval, &yylloc, p);
11909 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
11911 YY_IGNORE_MAYBE_UNINITIALIZED_END
11914#line 2664 "parse.y"
11916#line 11917 "parse.c"
11928 yyn = yydefact[yystate];
11949 yyval = yyvsp[1-yylen];
11951#line 2665 "parse.y"
11952 {before_reduce(yylen, p);}
11953#line 11954 "parse.c"
11957 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
11958 yyerror_range[1] = yyloc;
11959 YY_REDUCE_PRINT (yyn, p);
11963#line 3159 "parse.y"
11965 SET_LEX_STATE(EXPR_BEG);
11966 local_push(p, ifndef_ripper(1)+0);
11968 if (!ifndef_ripper(p->do_loop) + 0) init_block_exit(p);
11970#line 11971 "parse.c"
11974#line 2974 "parse.y"
11976 void_stmts(p, (yyval.node) = (yyvsp[-1].node));
11978#line 11979 "parse.c"
11982#line 3166 "parse.y"
11984 if ((yyvsp[0].node) && !compile_for_eval) {
11985 NODE *node = (yyvsp[0].node);
11987 if (nd_type_p(node, NODE_BLOCK)) {
11988 while (RNODE_BLOCK(node)->nd_next) {
11989 node = RNODE_BLOCK(node)->nd_next;
11991 node = RNODE_BLOCK(node)->nd_head;
11993 node = remove_begin(node);
11994 void_expr(p, node);
11996 p->eval_tree = NEW_SCOPE(0, block_append(p, p->eval_tree, (yyvsp[0].node)), &(yyloc));
12000#line 12001 "parse.c"
12004#line 3186 "parse.y"
12006 (yyval.node) = NEW_BEGIN(0, &(yyloc));
12009#line 12010 "parse.c"
12013#line 3191 "parse.y"
12015 (yyval.node) = newline_node((yyvsp[0].node));
12018#line 12019 "parse.c"
12022#line 3196 "parse.y"
12024 (yyval.node) = block_append(p, (yyvsp[-2].node), newline_node((yyvsp[0].node)));
12027#line 12028 "parse.c"
12031#line 3203 "parse.y"
12033 clear_block_exit(p,
true);
12034 (yyval.node) = (yyvsp[0].node);
12036#line 12037 "parse.c"
12040#line 3208 "parse.y"
12042 (yyval.node) = (yyvsp[0].node);
12045#line 12046 "parse.c"
12049#line 3214 "parse.y"
12050 {(yyval.node_exits) = init_block_exit(p);}
12051#line 12052 "parse.c"
12055#line 3217 "parse.y"
12057 restore_block_exit(p, (yyvsp[-2].node_exits));
12058 p->eval_tree_begin = block_append(p, p->eval_tree_begin,
12059 NEW_BEGIN((yyvsp[-1].node), &(yyloc)));
12060 (yyval.node) = NEW_BEGIN(0, &(yyloc));
12063#line 12064 "parse.c"
12067#line 2974 "parse.y"
12069 void_stmts(p, (yyval.node) = (yyvsp[-1].node));
12071#line 12072 "parse.c"
12075#line 3230 "parse.y"
12077 if (!(yyvsp[-1].node)) yyerror1(&(yylsp[0]),
"else without rescue is useless");
12078 next_rescue_context(&p->ctxt, &(yyvsp[-2].ctxt), after_else);
12080#line 12081 "parse.c"
12084#line 3235 "parse.y"
12086 next_rescue_context(&p->ctxt, &(yyvsp[-4].ctxt), after_ensure);
12088#line 12089 "parse.c"
12092#line 3239 "parse.y"
12094 (yyval.node) = new_bodystmt(p, (yyvsp[-7].node), (yyvsp[-5].node), (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
12097#line 12098 "parse.c"
12101#line 3246 "parse.y"
12103 next_rescue_context(&p->ctxt, &(yyvsp[-1].ctxt), after_ensure);
12105#line 12106 "parse.c"
12109#line 3250 "parse.y"
12111 (yyval.node) = new_bodystmt(p, (yyvsp[-4].node), (yyvsp[-2].node), 0, (yyvsp[0].node), &(yyloc));
12114#line 12115 "parse.c"
12118#line 3257 "parse.y"
12120 (yyval.node) = NEW_BEGIN(0, &(yyloc));
12123#line 12124 "parse.c"
12127#line 3262 "parse.y"
12129 (yyval.node) = newline_node((yyvsp[0].node));
12132#line 12133 "parse.c"
12136#line 3267 "parse.y"
12138 (yyval.node) = block_append(p, (yyvsp[-2].node), newline_node((yyvsp[0].node)));
12141#line 12142 "parse.c"
12145#line 3275 "parse.y"
12147 yyerror1(&(yylsp[0]),
"BEGIN is permitted only at toplevel");
12149#line 12150 "parse.c"
12153#line 3279 "parse.y"
12155 (yyval.node) = (yyvsp[0].node);
12157#line 12158 "parse.c"
12161#line 3284 "parse.y"
12162 {(yyval.node_exits) = allow_block_exit(p);}
12163#line 12164 "parse.c"
12167#line 3287 "parse.y"
12169 (yyval.ctxt) = (yyvsp[0].ctxt);
12170 p->ctxt.in_rescue = before_rescue;
12173#line 12174 "parse.c"
12177#line 3293 "parse.y"
12178 {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);}
12179#line 12180 "parse.c"
12183#line 3294 "parse.y"
12185 (yyval.node) = NEW_ALIAS((yyvsp[-2].node), (yyvsp[0].node), &(yyloc), &(yylsp[-3]));
12188#line 12189 "parse.c"
12192#line 3299 "parse.y"
12194 (yyval.node) = NEW_VALIAS((yyvsp[-1].
id), (yyvsp[0].id), &(yyloc), &(yylsp[-2]));
12197#line 12198 "parse.c"
12201#line 3304 "parse.y"
12205 buf[1] = (char)RNODE_BACK_REF((yyvsp[0].node))->nd_nth;
12206 (yyval.node) = NEW_VALIAS((yyvsp[-1].
id), rb_intern2(buf, 2), &(yyloc), &(yylsp[-2]));
12209#line 12210 "parse.c"
12213#line 3312 "parse.y"
12215 static const char mesg[] =
"can't make alias for the number variables";
12217 yyerror1(&(yylsp[0]), mesg);
12219 (yyval.node) = NEW_ERROR(&(yyloc));
12222#line 12223 "parse.c"
12226#line 3321 "parse.y"
12228 nd_set_first_loc((yyvsp[0].node), (yylsp[-1]).beg_pos);
12229 RNODE_UNDEF((yyvsp[0].node))->keyword_loc = (yylsp[-1]);
12230 (yyval.node) = (yyvsp[0].node);
12233#line 12234 "parse.c"
12237#line 3328 "parse.y"
12239 (yyval.node) = new_if(p, (yyvsp[0].node), remove_begin((yyvsp[-2].node)), 0, &(yyloc), &(yylsp[-1]), &NULL_LOC, &NULL_LOC);
12240 fixpos((yyval.node), (yyvsp[0].node));
12243#line 12244 "parse.c"
12247#line 3334 "parse.y"
12249 (yyval.node) = new_unless(p, (yyvsp[0].node), remove_begin((yyvsp[-2].node)), 0, &(yyloc), &(yylsp[-1]), &NULL_LOC, &NULL_LOC);
12250 fixpos((yyval.node), (yyvsp[0].node));
12253#line 12254 "parse.c"
12257#line 3340 "parse.y"
12259 clear_block_exit(p,
false);
12260 if ((yyvsp[-2].node) && nd_type_p((yyvsp[-2].node), NODE_BEGIN)) {
12261 (yyval.node) = NEW_WHILE(cond(p, (yyvsp[0].node), &(yylsp[0])), RNODE_BEGIN((yyvsp[-2].node))->nd_body, 0, &(yyloc), &(yylsp[-1]), &NULL_LOC);
12264 (yyval.node) = NEW_WHILE(cond(p, (yyvsp[0].node), &(yylsp[0])), (yyvsp[-2].node), 1, &(yyloc), &(yylsp[-1]), &NULL_LOC);
12268#line 12269 "parse.c"
12272#line 3351 "parse.y"
12274 clear_block_exit(p,
false);
12275 if ((yyvsp[-2].node) && nd_type_p((yyvsp[-2].node), NODE_BEGIN)) {
12276 (yyval.node) = NEW_UNTIL(cond(p, (yyvsp[0].node), &(yylsp[0])), RNODE_BEGIN((yyvsp[-2].node))->nd_body, 0, &(yyloc), &(yylsp[-1]), &NULL_LOC);
12279 (yyval.node) = NEW_UNTIL(cond(p, (yyvsp[0].node), &(yylsp[0])), (yyvsp[-2].node), 1, &(yyloc), &(yylsp[-1]), &NULL_LOC);
12283#line 12284 "parse.c"
12287#line 3362 "parse.y"
12289 p->ctxt.in_rescue = (yyvsp[-1].ctxt).in_rescue;
12291 YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
12292 resq = NEW_RESBODY(0, 0, remove_begin((yyvsp[0].node)), 0, &loc);
12293 (yyval.node) = NEW_RESCUE(remove_begin((yyvsp[-3].node)), resq, 0, &(yyloc));
12296#line 12297 "parse.c"
12300#line 3371 "parse.y"
12302 if (p->ctxt.in_def) {
12303 rb_warn0(
"END in method; use at_exit");
12305 restore_block_exit(p, (yyvsp[-3].node_exits));
12306 p->ctxt = (yyvsp[-4].ctxt);
12308 NODE *scope = NEW_SCOPE2(0 , 0 , (yyvsp[-1].node) , &(yyloc));
12309 (yyval.node) = NEW_POSTEXE(scope, &(yyloc), &(yylsp[-4]), &(yylsp[-2]), &(yylsp[0]));
12313#line 12314 "parse.c"
12317#line 3385 "parse.y"
12319 (yyval.node) = node_assign(p, (
NODE *)(yyvsp[-3].node_masgn), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
12322#line 12323 "parse.c"
12326#line 2919 "parse.y"
12328 (yyval.node) = node_assign(p, (
NODE *)(yyvsp[-3].node), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
12331#line 12332 "parse.c"
12335#line 3392 "parse.y"
12337 p->ctxt.in_rescue = (yyvsp[-4].ctxt).in_rescue;
12338 YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
12339 (yyvsp[0].node) = NEW_RESBODY(0, 0, remove_begin((yyvsp[0].node)), 0, &loc);
12340 loc.beg_pos = (yylsp[-3]).beg_pos;
12341 (yyvsp[-3].node) = NEW_RESCUE((yyvsp[-3].node), (yyvsp[0].node), 0, &loc);
12342 (yyval.node) = node_assign(p, (
NODE *)(yyvsp[-6].node_masgn), (yyvsp[-3].node), (yyvsp[-4].ctxt), &(yyloc));
12345#line 12346 "parse.c"
12349#line 3402 "parse.y"
12351 (yyval.node) = node_assign(p, (
NODE *)(yyvsp[-3].node_masgn), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
12354#line 12355 "parse.c"
12358#line 3408 "parse.y"
12361 (yyval.node) = NEW_ERROR(&(yyloc));
12363#line 12364 "parse.c"
12367#line 2919 "parse.y"
12369 (yyval.node) = node_assign(p, (
NODE *)(yyvsp[-3].node), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
12372#line 12373 "parse.c"
12376#line 3044 "parse.y"
12378 (yyval.node) = new_op_assign(p, (yyvsp[-3].node), (yyvsp[-2].id), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
12381#line 12382 "parse.c"
12385#line 3049 "parse.y"
12387 (yyval.node) = new_ary_op_assign(p, (yyvsp[-6].node), (yyvsp[-4].node), (yyvsp[-2].
id), (yyvsp[0].node), &(yylsp[-4]), &(yyloc), &NULL_LOC, &(yylsp[-5]), &(yylsp[-3]), &(yylsp[-2]));
12390#line 12391 "parse.c"
12394#line 3054 "parse.y"
12396 (yyval.node) = new_attr_op_assign(p, (yyvsp[-5].node), (yyvsp[-4].id), (yyvsp[-3].
id), (yyvsp[-2].id), (yyvsp[0].node), &(yyloc), &(yylsp[-4]), &(yylsp[-3]), &(yylsp[-2]));
12399#line 12400 "parse.c"
12403#line 3059 "parse.y"
12405 (yyval.node) = new_attr_op_assign(p, (yyvsp[-5].node), (yyvsp[-4].id), (yyvsp[-3].
id), (yyvsp[-2].id), (yyvsp[0].node), &(yyloc), &(yylsp[-4]), &(yylsp[-3]), &(yylsp[-2]));
12408#line 12409 "parse.c"
12412#line 3064 "parse.y"
12414 (yyval.node) = new_attr_op_assign(p, (yyvsp[-5].node), idCOLON2, (yyvsp[-3].id), (yyvsp[-2].
id), (yyvsp[0].node), &(yyloc), &(yylsp[-4]), &(yylsp[-3]), &(yylsp[-2]));
12417#line 12418 "parse.c"
12421#line 3069 "parse.y"
12423 YYLTYPE loc = code_loc_gen(&(yylsp[-5]), &(yylsp[-3]));
12424 (yyval.node) = new_const_op_assign(p, NEW_COLON2((yyvsp[-5].node), (yyvsp[-3].
id), &loc, &(yylsp[-4]), &(yylsp[-3])), (yyvsp[-2].id), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
12427#line 12428 "parse.c"
12431#line 3075 "parse.y"
12433 YYLTYPE loc = code_loc_gen(&(yylsp[-4]), &(yylsp[-3]));
12434 (yyval.node) = new_const_op_assign(p, NEW_COLON3((yyvsp[-3].
id), &loc, &(yylsp[-4]), &(yylsp[-3])), (yyvsp[-2].id), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
12437#line 12438 "parse.c"
12441#line 3081 "parse.y"
12443 VALUE MAYBE_UNUSED(e) = rb_backref_error(p, (yyvsp[-3].node));
12444 (yyval.node) = NEW_ERROR(&(yyloc));
12447#line 12448 "parse.c"
12451#line 2949 "parse.y"
12453 endless_method_name(p, (yyvsp[-3].node_def_temp)->nd_mid, &(yylsp[-3]));
12454 restore_defun(p, (yyvsp[-3].node_def_temp));
12455 (yyvsp[0].node) = new_scope_body(p, (yyvsp[-2].node_args), (yyvsp[0].node), &(yyloc));
12456 ((yyval.node) = (yyvsp[-3].node_def_temp)->nd_def)->nd_loc = (yyloc);
12457 RNODE_DEFN((yyval.node))->nd_defn = (yyvsp[0].node);
12462#line 12463 "parse.c"
12466#line 2960 "parse.y"
12468 endless_method_name(p, (yyvsp[-3].node_def_temp)->nd_mid, &(yylsp[-3]));
12469 restore_defun(p, (yyvsp[-3].node_def_temp));
12470 (yyvsp[0].node) = new_scope_body(p, (yyvsp[-2].node_args), (yyvsp[0].node), &(yyloc));
12471 ((yyval.node) = (yyvsp[-3].node_def_temp)->nd_def)->nd_loc = (yyloc);
12472 RNODE_DEFS((yyval.node))->nd_defn = (yyvsp[0].node);
12477#line 12478 "parse.c"
12481#line 3421 "parse.y"
12483 p->ctxt.in_rescue = (yyvsp[-1].ctxt).in_rescue;
12484 (yyval.node) = rescued_expr(p, (yyvsp[-3].node), (yyvsp[0].node), &(yylsp[-3]), &(yylsp[-2]), &(yylsp[0]));
12487#line 12488 "parse.c"
12491#line 3427 "parse.y"
12493 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[0].node), &(yylsp[0])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
12496#line 12497 "parse.c"
12500#line 3435 "parse.y"
12502 p->ctxt.in_rescue = (yyvsp[-1].ctxt).in_rescue;
12503 YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
12504 (yyval.node) = NEW_RESCUE((yyvsp[-3].node), NEW_RESBODY(0, 0, remove_begin((yyvsp[0].node)), 0, &loc), 0, &(yyloc));
12507#line 12508 "parse.c"
12511#line 3446 "parse.y"
12513 (yyval.node) = logop(p, idAND, (yyvsp[-2].node), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
12516#line 12517 "parse.c"
12520#line 3451 "parse.y"
12522 (yyval.node) = logop(p, idOR, (yyvsp[-2].node), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
12525#line 12526 "parse.c"
12529#line 3456 "parse.y"
12531 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[0].node), &(yylsp[0])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
12534#line 12535 "parse.c"
12538#line 3461 "parse.y"
12540 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[0].node), &(yylsp[0])),
'!', &(yylsp[-1]), &(yyloc));
12543#line 12544 "parse.c"
12547#line 3466 "parse.y"
12549 value_expr((yyvsp[-1].node));
12551#line 12552 "parse.c"
12555#line 3471 "parse.y"
12557 pop_pktbl(p, (yyvsp[-1].tbl));
12558 pop_pvtbl(p, (yyvsp[-2].tbl));
12559 p->ctxt.in_kwarg = (yyvsp[-3].ctxt).in_kwarg;
12560 (yyval.node) = NEW_CASE3((yyvsp[-6].node), NEW_IN((yyvsp[0].node), 0, 0, &(yylsp[0])), &(yyloc), &NULL_LOC, &NULL_LOC);
12563#line 12564 "parse.c"
12567#line 3479 "parse.y"
12569 value_expr((yyvsp[-1].node));
12571#line 12572 "parse.c"
12575#line 3484 "parse.y"
12577 pop_pktbl(p, (yyvsp[-1].tbl));
12578 pop_pvtbl(p, (yyvsp[-2].tbl));
12579 p->ctxt.in_kwarg = (yyvsp[-3].ctxt).in_kwarg;
12580 (yyval.node) = NEW_CASE3((yyvsp[-6].node), NEW_IN((yyvsp[0].node), NEW_TRUE(&(yylsp[0])), NEW_FALSE(&(yylsp[0])), &(yylsp[0])), &(yyloc), &NULL_LOC, &NULL_LOC);
12583#line 12584 "parse.c"
12587#line 3495 "parse.y"
12589 numparam_name(p, (yyvsp[0].
id));
12591 p->ctxt.in_def = 1;
12592 p->ctxt.in_rescue = before_rescue;
12593 p->ctxt.cant_return = 0;
12594 (yyval.id) = (yyvsp[0].
id);
12596#line 12597 "parse.c"
12600#line 3506 "parse.y"
12602 (yyval.node_def_temp) = def_head_save(p, (yyvsp[-1].node_def_temp));
12603 (yyval.node_def_temp)->nd_mid = (yyvsp[0].
id);
12604 (yyval.node_def_temp)->nd_def = NEW_DEFN((yyvsp[0].
id), 0, &(yyloc));
12607#line 12608 "parse.c"
12611#line 3515 "parse.y"
12613 SET_LEX_STATE(EXPR_FNAME);
12615#line 12616 "parse.c"
12619#line 3519 "parse.y"
12621 SET_LEX_STATE(EXPR_ENDFN|EXPR_LABEL);
12622 (yyval.node_def_temp) = def_head_save(p, (yyvsp[-4].node_def_temp));
12623 (yyval.node_def_temp)->nd_mid = (yyvsp[0].
id);
12624 (yyval.node_def_temp)->nd_def = NEW_DEFS((yyvsp[-3].node), (yyvsp[0].id), 0, &(yyloc));
12627#line 12628 "parse.c"
12631#line 3144 "parse.y"
12633 value_expr((yyvsp[0].node));
12634 (yyval.node) = (yyvsp[0].node);
12636#line 12637 "parse.c"
12640#line 3530 "parse.y"
12642 (yyval.node) = NEW_ERROR(&(yyloc));
12644#line 12645 "parse.c"
12648#line 3535 "parse.y"
12650#line 12651 "parse.c"
12654#line 3535 "parse.y"
12656#line 12657 "parse.c"
12660#line 3536 "parse.y"
12662 (yyval.node) = (yyvsp[-2].node);
12665#line 12666 "parse.c"
12669#line 3144 "parse.y"
12671 value_expr((yyvsp[0].node));
12672 (yyval.node) = (yyvsp[0].node);
12674#line 12675 "parse.c"
12678#line 3551 "parse.y"
12680 (yyval.node) = new_qcall(p, (yyvsp[-2].
id), (yyvsp[-3].node), (yyvsp[-1].
id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
12683#line 12684 "parse.c"
12687#line 3558 "parse.y"
12689 (yyval.node) = (yyvsp[-1].node);
12690 set_embraced_location((yyval.node), &(yylsp[-2]), &(yylsp[0]));
12693#line 12694 "parse.c"
12697#line 3566 "parse.y"
12699 (yyval.node_fcall) = NEW_FCALL((yyvsp[0].
id), 0, &(yyloc));
12702#line 12703 "parse.c"
12706#line 3566 "parse.y"
12708 (yyval.node_fcall) = NEW_FCALL((yyvsp[0].
id), 0, &(yyloc));
12711#line 12712 "parse.c"
12715#line 3566 "parse.y"
12717 (yyval.node_fcall) = NEW_FCALL((yyvsp[0].
id), 0, &(yyloc));
12720#line 12721 "parse.c"
12724#line 3573 "parse.y"
12726 (yyvsp[-1].node_fcall)->nd_args = (yyvsp[0].node);
12727 nd_set_last_loc((yyvsp[-1].node_fcall), (yylsp[0]).end_pos);
12728 (yyval.node) = (
NODE *)(yyvsp[-1].node_fcall);
12731#line 12732 "parse.c"
12735#line 3580 "parse.y"
12737 block_dup_check(p, (yyvsp[-1].node), (yyvsp[0].node));
12738 (yyvsp[-2].node_fcall)->nd_args = (yyvsp[-1].node);
12739 (yyval.node) = method_add_block(p, (
NODE *)(yyvsp[-2].node_fcall), (yyvsp[0].node), &(yyloc));
12740 fixpos((yyval.node), RNODE((yyvsp[-2].node_fcall)));
12741 nd_set_last_loc((yyvsp[-2].node_fcall), (yylsp[-1]).end_pos);
12744#line 12745 "parse.c"
12748#line 3589 "parse.y"
12750 (yyval.node) = new_command_qcall(p, (yyvsp[-2].
id), (yyvsp[-3].node), (yyvsp[-1].
id), (yyvsp[0].node), 0, &(yylsp[-1]), &(yyloc));
12753#line 12754 "parse.c"
12757#line 3594 "parse.y"
12759 (yyval.node) = new_command_qcall(p, (yyvsp[-3].
id), (yyvsp[-4].node), (yyvsp[-2].
id), (yyvsp[-1].node), (yyvsp[0].node), &(yylsp[-2]), &(yyloc));
12762#line 12763 "parse.c"
12766#line 3599 "parse.y"
12768 (yyval.node) = new_command_qcall(p, idCOLON2, (yyvsp[-3].node), (yyvsp[-1].id), (yyvsp[0].node), 0, &(yylsp[-1]), &(yyloc));
12771#line 12772 "parse.c"
12775#line 3604 "parse.y"
12777 (yyval.node) = new_command_qcall(p, idCOLON2, (yyvsp[-4].node), (yyvsp[-2].id), (yyvsp[-1].node), (yyvsp[0].node), &(yylsp[-2]), &(yyloc));
12780#line 12781 "parse.c"
12784#line 3609 "parse.y"
12786 set_embraced_location((yyvsp[-1].node), &(yylsp[-2]), &(yylsp[0]));
12787 (yyval.node) = new_command_qcall(p, idCOLON2, (yyvsp[-5].node), (yyvsp[-3].id), 0, (yyvsp[-1].node), &(yylsp[-3]), &(yyloc));
12790#line 12791 "parse.c"
12794#line 3615 "parse.y"
12796 (yyval.node) = NEW_SUPER((yyvsp[0].node), &(yyloc), &(yylsp[-1]), &NULL_LOC, &NULL_LOC);
12797 fixpos((yyval.node), (yyvsp[0].node));
12800#line 12801 "parse.c"
12804#line 3621 "parse.y"
12806 (yyval.node) = NEW_YIELD((yyvsp[0].node), &(yyloc), &(yylsp[-1]), &NULL_LOC, &NULL_LOC);
12807 fixpos((yyval.node), (yyvsp[0].node));
12810#line 12811 "parse.c"
12814#line 3627 "parse.y"
12816 (yyval.node) = NEW_RETURN(ret_args(p, (yyvsp[0].node)), &(yyloc), &(yylsp[-1]));
12819#line 12820 "parse.c"
12823#line 3632 "parse.y"
12826 args = ret_args(p, (yyvsp[0].node));
12827 (yyval.node) = add_block_exit(p, NEW_BREAK(args, &(yyloc), &(yylsp[-1])));
12830#line 12831 "parse.c"
12834#line 3639 "parse.y"
12837 args = ret_args(p, (yyvsp[0].node));
12838 (yyval.node) = add_block_exit(p, NEW_NEXT(args, &(yyloc), &(yylsp[-1])));
12841#line 12842 "parse.c"
12845#line 3649 "parse.y"
12847 (yyval.node_masgn) = (yyvsp[-1].node_masgn);
12850#line 12851 "parse.c"
12854#line 3657 "parse.y"
12856 (yyval.node_masgn) = NEW_MASGN(NEW_LIST((
NODE *)(yyvsp[-1].node_masgn), &(yyloc)), 0, &(yyloc));
12859#line 12860 "parse.c"
12863#line 3664 "parse.y"
12865 (yyval.node_masgn) = NEW_MASGN((yyvsp[0].node), 0, &(yyloc));
12868#line 12869 "parse.c"
12872#line 3669 "parse.y"
12874 (yyval.node_masgn) = NEW_MASGN(list_append(p, (yyvsp[-1].node), (yyvsp[0].node)), 0, &(yyloc));
12877#line 12878 "parse.c"
12881#line 3674 "parse.y"
12883 (yyval.node_masgn) = NEW_MASGN((yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
12886#line 12887 "parse.c"
12890#line 3031 "parse.y"
12892 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
12895#line 12896 "parse.c"
12899#line 3036 "parse.y"
12901 (yyval.node) = list_append(p, (yyvsp[-2].node), (yyvsp[0].node));
12904#line 12905 "parse.c"
12908#line 3679 "parse.y"
12910 (yyval.node_masgn) = NEW_MASGN((yyvsp[-4].node), NEW_POSTARG((yyvsp[-2].node),(yyvsp[0].node),&(yyloc)), &(yyloc));
12913#line 12914 "parse.c"
12917#line 3684 "parse.y"
12919 (yyval.node_masgn) = NEW_MASGN((yyvsp[-1].node), NODE_SPECIAL_NO_NAME_REST, &(yyloc));
12922#line 12923 "parse.c"
12926#line 3689 "parse.y"
12928 (yyval.node_masgn) = NEW_MASGN((yyvsp[-3].node), NEW_POSTARG(NODE_SPECIAL_NO_NAME_REST, (yyvsp[0].node), &(yyloc)), &(yyloc));
12931#line 12932 "parse.c"
12935#line 3694 "parse.y"
12937 (yyval.node_masgn) = NEW_MASGN(0, (yyvsp[0].node), &(yyloc));
12940#line 12941 "parse.c"
12944#line 3699 "parse.y"
12946 (yyval.node_masgn) = NEW_MASGN(0, NEW_POSTARG((yyvsp[-2].node),(yyvsp[0].node),&(yyloc)), &(yyloc));
12949#line 12950 "parse.c"
12953#line 3704 "parse.y"
12955 (yyval.node_masgn) = NEW_MASGN(0, NODE_SPECIAL_NO_NAME_REST, &(yyloc));
12958#line 12959 "parse.c"
12962#line 3709 "parse.y"
12964 (yyval.node_masgn) = NEW_MASGN(0, NEW_POSTARG(NODE_SPECIAL_NO_NAME_REST, (yyvsp[0].node), &(yyloc)), &(yyloc));
12967#line 12968 "parse.c"
12971#line 3717 "parse.y"
12973 (yyval.node) = (
NODE *)(yyvsp[-1].node_masgn);
12976#line 12977 "parse.c"
12980#line 3724 "parse.y"
12982 (yyval.node) = NEW_LIST((yyvsp[-1].node), &(yylsp[-1]));
12985#line 12986 "parse.c"
12989#line 3729 "parse.y"
12991 (yyval.node) = list_append(p, (yyvsp[-2].node), (yyvsp[-1].node));
12994#line 12995 "parse.c"
12998#line 3737 "parse.y"
13001 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
13003#line 13004 "parse.c"
13007#line 3737 "parse.y"
13010 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
13012#line 13013 "parse.c"
13016#line 3742 "parse.y"
13018 (yyval.node) = aryset(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
13021#line 13022 "parse.c"
13025#line 3747 "parse.y"
13027 anddot_multiple_assignment_check(p, &(yylsp[-1]), (yyvsp[-1].
id));
13028 (yyval.node) = attrset(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].
id), &(yyloc));
13031#line 13032 "parse.c"
13035#line 3747 "parse.y"
13037 anddot_multiple_assignment_check(p, &(yylsp[-1]), (yyvsp[-1].
id));
13038 (yyval.node) = attrset(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].
id), &(yyloc));
13041#line 13042 "parse.c"
13045#line 3753 "parse.y"
13047 (yyval.node) = attrset(p, (yyvsp[-2].node), idCOLON2, (yyvsp[0].id), &(yyloc));
13050#line 13051 "parse.c"
13054#line 3758 "parse.y"
13057 (yyval.node) = const_decl(p, NEW_COLON2((yyvsp[-2].node), (yyvsp[0].id), &(yyloc), &(yylsp[-1]), &(yylsp[0])), &(yyloc));
13059#line 13060 "parse.c"
13063#line 3763 "parse.y"
13066 (yyval.node) = const_decl(p, NEW_COLON3((yyvsp[0].
id), &(yyloc), &(yylsp[-1]), &(yylsp[0])), &(yyloc));
13068#line 13069 "parse.c"
13072#line 3768 "parse.y"
13074 VALUE MAYBE_UNUSED(e) = rb_backref_error(p, (yyvsp[0].node));
13075 (yyval.node) = NEW_ERROR(&(yyloc));
13078#line 13079 "parse.c"
13082#line 3776 "parse.y"
13085 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
13087#line 13088 "parse.c"
13091#line 3776 "parse.y"
13094 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
13096#line 13097 "parse.c"
13100#line 3781 "parse.y"
13102 (yyval.node) = aryset(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
13105#line 13106 "parse.c"
13109#line 3786 "parse.y"
13111 (yyval.node) = attrset(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].
id), &(yyloc));
13114#line 13115 "parse.c"
13118#line 3786 "parse.y"
13120 (yyval.node) = attrset(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].
id), &(yyloc));
13123#line 13124 "parse.c"
13127#line 3791 "parse.y"
13129 (yyval.node) = attrset(p, (yyvsp[-2].node), idCOLON2, (yyvsp[0].id), &(yyloc));
13132#line 13133 "parse.c"
13136#line 3796 "parse.y"
13139 (yyval.node) = const_decl(p, NEW_COLON2((yyvsp[-2].node), (yyvsp[0].id), &(yyloc), &(yylsp[-1]), &(yylsp[0])), &(yyloc));
13141#line 13142 "parse.c"
13145#line 3801 "parse.y"
13148 (yyval.node) = const_decl(p, NEW_COLON3((yyvsp[0].
id), &(yyloc), &(yylsp[-1]), &(yylsp[0])), &(yyloc));
13150#line 13151 "parse.c"
13154#line 3806 "parse.y"
13156 VALUE MAYBE_UNUSED(e) = rb_backref_error(p, (yyvsp[0].node));
13157 (yyval.node) = NEW_ERROR(&(yyloc));
13160#line 13161 "parse.c"
13164#line 3814 "parse.y"
13166 static const char mesg[] =
"class/module name must be CONSTANT";
13168 yyerror1(&(yylsp[0]), mesg);
13172#line 13173 "parse.c"
13176#line 3825 "parse.y"
13178 (yyval.node) = NEW_COLON3((yyvsp[0].
id), &(yyloc), &(yylsp[-1]), &(yylsp[0]));
13181#line 13182 "parse.c"
13185#line 3830 "parse.y"
13187 (yyval.node) = NEW_COLON2(0, (yyvsp[0].
id), &(yyloc), &NULL_LOC, &(yylsp[0]));
13190#line 13191 "parse.c"
13194#line 3835 "parse.y"
13196 (yyval.node) = NEW_COLON2((yyvsp[-2].node), (yyvsp[0].id), &(yyloc), &(yylsp[-1]), &(yylsp[0]));
13199#line 13200 "parse.c"
13203#line 3843 "parse.y"
13205 SET_LEX_STATE(EXPR_ENDFN);
13206 (yyval.id) = (yyvsp[0].
id);
13208#line 13209 "parse.c"
13212#line 3851 "parse.y"
13214 (yyval.node) = NEW_SYM(rb_id2str((yyvsp[0].
id)), &(yyloc));
13217#line 13218 "parse.c"
13221#line 3859 "parse.y"
13223 (yyval.node) = NEW_UNDEF((yyvsp[0].node), &(yyloc));
13226#line 13227 "parse.c"
13230#line 3863 "parse.y"
13231 {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);}
13232#line 13233 "parse.c"
13236#line 3864 "parse.y"
13238 nd_set_last_loc((yyvsp[-3].node), (yylsp[0]).end_pos);
13239 rb_parser_ary_push_node(p, RNODE_UNDEF((yyvsp[-3].node))->nd_undefs, (yyvsp[0].node));
13242#line 13243 "parse.c"
13246#line 3871 "parse.y"
13247 { (yyval.id) =
'|'; }
13248#line 13249 "parse.c"
13252#line 3872 "parse.y"
13253 { (yyval.id) =
'^'; }
13254#line 13255 "parse.c"
13258#line 3873 "parse.y"
13259 { (yyval.id) =
'&'; }
13260#line 13261 "parse.c"
13264#line 3874 "parse.y"
13265 { (yyval.id) = tCMP; }
13266#line 13267 "parse.c"
13270#line 3875 "parse.y"
13271 { (yyval.id) = tEQ; }
13272#line 13273 "parse.c"
13276#line 3876 "parse.y"
13277 { (yyval.id) = tEQQ; }
13278#line 13279 "parse.c"
13282#line 3877 "parse.y"
13283 { (yyval.id) = tMATCH; }
13284#line 13285 "parse.c"
13288#line 3878 "parse.y"
13289 { (yyval.id) = tNMATCH; }
13290#line 13291 "parse.c"
13294#line 3879 "parse.y"
13295 { (yyval.id) =
'>'; }
13296#line 13297 "parse.c"
13300#line 3880 "parse.y"
13301 { (yyval.id) = tGEQ; }
13302#line 13303 "parse.c"
13306#line 3881 "parse.y"
13307 { (yyval.id) =
'<'; }
13308#line 13309 "parse.c"
13312#line 3882 "parse.y"
13313 { (yyval.id) = tLEQ; }
13314#line 13315 "parse.c"
13318#line 3883 "parse.y"
13319 { (yyval.id) = tNEQ; }
13320#line 13321 "parse.c"
13324#line 3884 "parse.y"
13325 { (yyval.id) = tLSHFT; }
13326#line 13327 "parse.c"
13330#line 3885 "parse.y"
13331 { (yyval.id) = tRSHFT; }
13332#line 13333 "parse.c"
13336#line 3886 "parse.y"
13337 { (yyval.id) =
'+'; }
13338#line 13339 "parse.c"
13342#line 3887 "parse.y"
13343 { (yyval.id) =
'-'; }
13344#line 13345 "parse.c"
13348#line 3888 "parse.y"
13349 { (yyval.id) =
'*'; }
13350#line 13351 "parse.c"
13354#line 3889 "parse.y"
13355 { (yyval.id) =
'*'; }
13356#line 13357 "parse.c"
13360#line 3890 "parse.y"
13361 { (yyval.id) =
'/'; }
13362#line 13363 "parse.c"
13366#line 3891 "parse.y"
13367 { (yyval.id) =
'%'; }
13368#line 13369 "parse.c"
13372#line 3892 "parse.y"
13373 { (yyval.id) = tPOW; }
13374#line 13375 "parse.c"
13378#line 3893 "parse.y"
13379 { (yyval.id) = tDSTAR; }
13380#line 13381 "parse.c"
13384#line 3894 "parse.y"
13385 { (yyval.id) =
'!'; }
13386#line 13387 "parse.c"
13390#line 3895 "parse.y"
13391 { (yyval.id) =
'~'; }
13392#line 13393 "parse.c"
13396#line 3896 "parse.y"
13397 { (yyval.id) = tUPLUS; }
13398#line 13399 "parse.c"
13402#line 3897 "parse.y"
13403 { (yyval.id) = tUMINUS; }
13404#line 13405 "parse.c"
13408#line 3898 "parse.y"
13409 { (yyval.id) = tAREF; }
13410#line 13411 "parse.c"
13414#line 3899 "parse.y"
13415 { (yyval.id) = tASET; }
13416#line 13417 "parse.c"
13420#line 3900 "parse.y"
13421 { (yyval.id) =
'`'; }
13422#line 13423 "parse.c"
13426#line 2919 "parse.y"
13428 (yyval.node) = node_assign(p, (
NODE *)(yyvsp[-3].node), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
13431#line 13432 "parse.c"
13435#line 3044 "parse.y"
13437 (yyval.node) = new_op_assign(p, (yyvsp[-3].node), (yyvsp[-2].id), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
13440#line 13441 "parse.c"
13444#line 3049 "parse.y"
13446 (yyval.node) = new_ary_op_assign(p, (yyvsp[-6].node), (yyvsp[-4].node), (yyvsp[-2].
id), (yyvsp[0].node), &(yylsp[-4]), &(yyloc), &NULL_LOC, &(yylsp[-5]), &(yylsp[-3]), &(yylsp[-2]));
13449#line 13450 "parse.c"
13453#line 3054 "parse.y"
13455 (yyval.node) = new_attr_op_assign(p, (yyvsp[-5].node), (yyvsp[-4].id), (yyvsp[-3].
id), (yyvsp[-2].id), (yyvsp[0].node), &(yyloc), &(yylsp[-4]), &(yylsp[-3]), &(yylsp[-2]));
13458#line 13459 "parse.c"
13462#line 3059 "parse.y"
13464 (yyval.node) = new_attr_op_assign(p, (yyvsp[-5].node), (yyvsp[-4].id), (yyvsp[-3].
id), (yyvsp[-2].id), (yyvsp[0].node), &(yyloc), &(yylsp[-4]), &(yylsp[-3]), &(yylsp[-2]));
13467#line 13468 "parse.c"
13471#line 3064 "parse.y"
13473 (yyval.node) = new_attr_op_assign(p, (yyvsp[-5].node), idCOLON2, (yyvsp[-3].id), (yyvsp[-2].
id), (yyvsp[0].node), &(yyloc), &(yylsp[-4]), &(yylsp[-3]), &(yylsp[-2]));
13476#line 13477 "parse.c"
13480#line 3069 "parse.y"
13482 YYLTYPE loc = code_loc_gen(&(yylsp[-5]), &(yylsp[-3]));
13483 (yyval.node) = new_const_op_assign(p, NEW_COLON2((yyvsp[-5].node), (yyvsp[-3].
id), &loc, &(yylsp[-4]), &(yylsp[-3])), (yyvsp[-2].id), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
13486#line 13487 "parse.c"
13490#line 3075 "parse.y"
13492 YYLTYPE loc = code_loc_gen(&(yylsp[-4]), &(yylsp[-3]));
13493 (yyval.node) = new_const_op_assign(p, NEW_COLON3((yyvsp[-3].
id), &loc, &(yylsp[-4]), &(yylsp[-3])), (yyvsp[-2].id), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
13496#line 13497 "parse.c"
13500#line 3081 "parse.y"
13502 VALUE MAYBE_UNUSED(e) = rb_backref_error(p, (yyvsp[-3].node));
13503 (yyval.node) = NEW_ERROR(&(yyloc));
13506#line 13507 "parse.c"
13510#line 3103 "parse.y"
13512 value_expr((yyvsp[-2].node));
13513 value_expr((yyvsp[0].node));
13514 (yyval.node) = NEW_DOT2((yyvsp[-2].node), (yyvsp[0].node), &(yyloc), &(yylsp[-1]));
13517#line 13518 "parse.c"
13521#line 3110 "parse.y"
13523 value_expr((yyvsp[-2].node));
13524 value_expr((yyvsp[0].node));
13525 (yyval.node) = NEW_DOT3((yyvsp[-2].node), (yyvsp[0].node), &(yyloc), &(yylsp[-1]));
13528#line 13529 "parse.c"
13532#line 3117 "parse.y"
13534 value_expr((yyvsp[-1].node));
13535 (yyval.node) = NEW_DOT2((yyvsp[-1].node), new_nil_at(p, &(yylsp[0]).end_pos), &(yyloc), &(yylsp[0]));
13538#line 13539 "parse.c"
13542#line 3123 "parse.y"
13544 value_expr((yyvsp[-1].node));
13545 (yyval.node) = NEW_DOT3((yyvsp[-1].node), new_nil_at(p, &(yylsp[0]).end_pos), &(yyloc), &(yylsp[0]));
13548#line 13549 "parse.c"
13552#line 3129 "parse.y"
13554 value_expr((yyvsp[0].node));
13555 (yyval.node) = NEW_DOT2(new_nil_at(p, &(yylsp[-1]).beg_pos), (yyvsp[0].node), &(yyloc), &(yylsp[-1]));
13558#line 13559 "parse.c"
13562#line 3135 "parse.y"
13564 value_expr((yyvsp[0].node));
13565 (yyval.node) = NEW_DOT3(new_nil_at(p, &(yylsp[-1]).beg_pos), (yyvsp[0].node), &(yyloc), &(yylsp[-1]));
13568#line 13569 "parse.c"
13572#line 3921 "parse.y"
13574 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'+', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13577#line 13578 "parse.c"
13581#line 3926 "parse.y"
13583 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'-', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13586#line 13587 "parse.c"
13590#line 3931 "parse.y"
13592 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'*', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13595#line 13596 "parse.c"
13599#line 3936 "parse.y"
13601 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'/', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13604#line 13605 "parse.c"
13608#line 3941 "parse.y"
13610 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'%', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13613#line 13614 "parse.c"
13617#line 3946 "parse.y"
13619 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idPow, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13622#line 13623 "parse.c"
13626#line 3951 "parse.y"
13628 (yyval.node) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].node), idPow, (yyvsp[0].node), &(yylsp[-2]), &(yyloc)), idUMinus, &(yylsp[-3]), &(yyloc));
13631#line 13632 "parse.c"
13635#line 3956 "parse.y"
13637 (yyval.node) = call_uni_op(p, (yyvsp[0].node), idUPlus, &(yylsp[-1]), &(yyloc));
13640#line 13641 "parse.c"
13644#line 3961 "parse.y"
13646 (yyval.node) = call_uni_op(p, (yyvsp[0].node), idUMinus, &(yylsp[-1]), &(yyloc));
13649#line 13650 "parse.c"
13653#line 3966 "parse.y"
13655 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'|', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13658#line 13659 "parse.c"
13662#line 3971 "parse.y"
13664 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'^', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13667#line 13668 "parse.c"
13671#line 3976 "parse.y"
13673 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'&', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13676#line 13677 "parse.c"
13680#line 3981 "parse.y"
13682 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idCmp, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13685#line 13686 "parse.c"
13689#line 3987 "parse.y"
13691 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idEq, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13694#line 13695 "parse.c"
13698#line 3992 "parse.y"
13700 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idEqq, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13703#line 13704 "parse.c"
13707#line 3997 "parse.y"
13709 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idNeq, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13712#line 13713 "parse.c"
13716#line 4002 "parse.y"
13718 (yyval.node) = match_op(p, (yyvsp[-2].node), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13721#line 13722 "parse.c"
13725#line 4007 "parse.y"
13727 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idNeqTilde, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13730#line 13731 "parse.c"
13734#line 4012 "parse.y"
13736 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[0].node), &(yylsp[0])),
'!', &(yylsp[-1]), &(yyloc));
13739#line 13740 "parse.c"
13743#line 4017 "parse.y"
13745 (yyval.node) = call_uni_op(p, (yyvsp[0].node),
'~', &(yylsp[-1]), &(yyloc));
13748#line 13749 "parse.c"
13752#line 4022 "parse.y"
13754 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idLTLT, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13757#line 13758 "parse.c"
13761#line 4027 "parse.y"
13763 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idGTGT, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13766#line 13767 "parse.c"
13770#line 4032 "parse.y"
13772 (yyval.node) = logop(p, idANDOP, (yyvsp[-2].node), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13775#line 13776 "parse.c"
13779#line 4037 "parse.y"
13781 (yyval.node) = logop(p, idOROP, (yyvsp[-2].node), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13784#line 13785 "parse.c"
13788#line 4042 "parse.y"
13790 p->ctxt.in_defined = (yyvsp[-1].ctxt).in_defined;
13791 (yyval.node) = new_defined(p, (yyvsp[0].node), &(yyloc), &(yylsp[-3]));
13792 p->ctxt.has_trailing_semicolon = (yyvsp[-1].ctxt).has_trailing_semicolon;
13795#line 13796 "parse.c"
13799#line 2949 "parse.y"
13801 endless_method_name(p, (yyvsp[-3].node_def_temp)->nd_mid, &(yylsp[-3]));
13802 restore_defun(p, (yyvsp[-3].node_def_temp));
13803 (yyvsp[0].node) = new_scope_body(p, (yyvsp[-2].node_args), (yyvsp[0].node), &(yyloc));
13804 ((yyval.node) = (yyvsp[-3].node_def_temp)->nd_def)->nd_loc = (yyloc);
13805 RNODE_DEFN((yyval.node))->nd_defn = (yyvsp[0].node);
13810#line 13811 "parse.c"
13814#line 2960 "parse.y"
13816 endless_method_name(p, (yyvsp[-3].node_def_temp)->nd_mid, &(yylsp[-3]));
13817 restore_defun(p, (yyvsp[-3].node_def_temp));
13818 (yyvsp[0].node) = new_scope_body(p, (yyvsp[-2].node_args), (yyvsp[0].node), &(yyloc));
13819 ((yyval.node) = (yyvsp[-3].node_def_temp)->nd_def)->nd_loc = (yyloc);
13820 RNODE_DEFS((yyval.node))->nd_defn = (yyvsp[0].node);
13825#line 13826 "parse.c"
13829#line 4054 "parse.y"
13831 value_expr((yyvsp[-5].node));
13832 (yyval.node) = new_if(p, (yyvsp[-5].node), (yyvsp[-3].node), (yyvsp[0].node), &(yyloc), &NULL_LOC, &(yylsp[-1]), &NULL_LOC);
13833 fixpos((yyval.node), (yyvsp[-5].node));
13836#line 13837 "parse.c"
13840#line 4064 "parse.y"
13842 p->ctxt.in_rescue = (yyvsp[-1].ctxt).in_rescue;
13843 (yyval.node) = rescued_expr(p, (yyvsp[-3].node), (yyvsp[0].node), &(yylsp[-3]), &(yylsp[-2]), &(yylsp[0]));
13846#line 13847 "parse.c"
13850#line 4070 "parse.y"
13852 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[0].node), &(yylsp[0])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
13855#line 13856 "parse.c"
13859#line 4076 "parse.y"
13860 {(yyval.id) =
'>';}
13861#line 13862 "parse.c"
13865#line 4077 "parse.y"
13866 {(yyval.id) =
'<';}
13867#line 13868 "parse.c"
13871#line 4078 "parse.y"
13872 {(yyval.id) = idGE;}
13873#line 13874 "parse.c"
13877#line 4079 "parse.y"
13878 {(yyval.id) = idLE;}
13879#line 13880 "parse.c"
13883#line 4083 "parse.y"
13885 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13888#line 13889 "parse.c"
13892#line 4088 "parse.y"
13894 rb_warning1(
"comparison '%s' after comparison", WARN_ID((yyvsp[-1].
id)));
13895 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13898#line 13899 "parse.c"
13902#line 4096 "parse.y"
13904 (yyval.ctxt) = p->ctxt;
13906#line 13907 "parse.c"
13910#line 4102 "parse.y"
13912 p->ctxt.in_defined = 1;
13913 (yyval.ctxt) = (yyvsp[0].ctxt);
13915#line 13916 "parse.c"
13919#line 4109 "parse.y"
13921 p->ctxt.in_rescue = after_rescue;
13922 (yyval.ctxt) = (yyvsp[0].ctxt);
13924#line 13925 "parse.c"
13928#line 3144 "parse.y"
13930 value_expr((yyvsp[0].node));
13931 (yyval.node) = (yyvsp[0].node);
13933#line 13934 "parse.c"
13937#line 4121 "parse.y"
13939 (yyval.node) = (yyvsp[-1].node) ? arg_append(p, (yyvsp[-3].node), new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].node);
13942#line 13943 "parse.c"
13946#line 4126 "parse.y"
13948 (yyval.node) = (yyvsp[-1].node) ? NEW_LIST(new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yyloc)) : 0;
13951#line 13952 "parse.c"
13955#line 4133 "parse.y"
13957 value_expr((yyvsp[0].node));
13958 (yyval.node) = (yyvsp[0].node);
13960#line 13961 "parse.c"
13964#line 4138 "parse.y"
13966 p->ctxt.in_rescue = (yyvsp[-1].ctxt).in_rescue;
13967 value_expr((yyvsp[-3].node));
13968 (yyval.node) = rescued_expr(p, (yyvsp[-3].node), (yyvsp[0].node), &(yylsp[-3]), &(yylsp[-2]), &(yylsp[0]));
13971#line 13972 "parse.c"
13975#line 4147 "parse.y"
13977 (yyval.node) = (yyvsp[-1].node);
13980#line 13981 "parse.c"
13984#line 4152 "parse.y"
13986 if (!check_forwarding_args(p)) {
13990 (yyval.node) = new_args_forward_call(p, (yyvsp[-3].node), &(yylsp[-1]), &(yyloc));
13994#line 13995 "parse.c"
13998#line 4162 "parse.y"
14000 if (!check_forwarding_args(p)) {
14004 (yyval.node) = new_args_forward_call(p, 0, &(yylsp[-1]), &(yyloc));
14008#line 14009 "parse.c"
14012#line 4175 "parse.y"
14014 (yyval.node) = (yyvsp[0].node) ? (yyvsp[0].node) : NODE_SPECIAL_EMPTY_ARGS;
14016#line 14017 "parse.c"
14020#line 4184 "parse.y"
14022 (yyval.node) = (yyvsp[-1].node) ? arg_append(p, (yyvsp[-3].node), new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].node);
14025#line 14026 "parse.c"
14029#line 4189 "parse.y"
14031 (yyval.node) = (yyvsp[-1].node) ? NEW_LIST(new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yylsp[-1])) : 0;
14034#line 14035 "parse.c"
14038#line 3144 "parse.y"
14040 value_expr((yyvsp[0].node));
14041 (yyval.node) = (yyvsp[0].node);
14043#line 14044 "parse.c"
14047#line 4196 "parse.y"
14049 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
14052#line 14053 "parse.c"
14056#line 4201 "parse.y"
14058 (yyval.node) = arg_blk_pass((yyvsp[-1].node), (yyvsp[0].node_block_pass));
14061#line 14062 "parse.c"
14065#line 4206 "parse.y"
14067 (yyval.node) = (yyvsp[-1].node) ? NEW_LIST(new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yylsp[-1])) : 0;
14068 (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[0].node_block_pass));
14071#line 14072 "parse.c"
14075#line 4212 "parse.y"
14077 (yyval.node) = (yyvsp[-1].node) ? arg_append(p, (yyvsp[-3].node), new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].node);
14078 (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[0].node_block_pass));
14081#line 14082 "parse.c"
14085#line 4221 "parse.y"
14096 case '(':
case tLPAREN:
case tLPAREN_ARG:
case '[':
case tLBRACK:
14099 if (lookahead) CMDARG_POP();
14101 if (lookahead) CMDARG_PUSH(0);
14103#line 14104 "parse.c"
14107#line 4239 "parse.y"
14120 if (lookahead) CMDARG_POP();
14122 if (lookahead) CMDARG_PUSH(0);
14123 (yyval.node) = (yyvsp[0].node);
14126#line 14127 "parse.c"
14130#line 4260 "parse.y"
14132 (yyval.node_block_pass) = NEW_BLOCK_PASS((yyvsp[0].node), &(yyloc), &(yylsp[-1]));
14135#line 14136 "parse.c"
14139#line 4265 "parse.y"
14141 forwarding_arg_check(p, idFWD_BLOCK, idFWD_ALL,
"block");
14142 (yyval.node_block_pass) = NEW_BLOCK_PASS(NEW_LVAR(idFWD_BLOCK, &(yylsp[0])), &(yyloc), &(yylsp[0]));
14145#line 14146 "parse.c"
14149#line 4273 "parse.y"
14151 (yyval.node_block_pass) = (yyvsp[0].node_block_pass);
14154#line 14155 "parse.c"
14158#line 4278 "parse.y"
14160 (yyval.node_block_pass) = 0;
14163#line 14164 "parse.c"
14167#line 4286 "parse.y"
14169 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
14172#line 14173 "parse.c"
14176#line 4291 "parse.y"
14178 (yyval.node) = (yyvsp[0].node);
14181#line 14182 "parse.c"
14185#line 4296 "parse.y"
14187 (yyval.node) = last_arg_append(p, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
14190#line 14191 "parse.c"
14194#line 4301 "parse.y"
14196 (yyval.node) = rest_arg_append(p, (yyvsp[-2].node), RNODE_SPLAT((yyvsp[0].node))->nd_head, &(yyloc));
14199#line 14200 "parse.c"
14203#line 4309 "parse.y"
14205 (yyval.node) = NEW_SPLAT((yyvsp[0].node), &(yyloc), &(yylsp[-1]));
14208#line 14209 "parse.c"
14212#line 4314 "parse.y"
14214 forwarding_arg_check(p, idFWD_REST, idFWD_ALL,
"rest");
14215 (yyval.node) = NEW_SPLAT(NEW_LVAR(idFWD_REST, &(yylsp[0])), &(yyloc), &(yylsp[0]));
14218#line 14219 "parse.c"
14222#line 4328 "parse.y"
14224 (yyval.node) = last_arg_append(p, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
14227#line 14228 "parse.c"
14231#line 4333 "parse.y"
14233 (yyval.node) = rest_arg_append(p, (yyvsp[-3].node), (yyvsp[0].node), &(yyloc));
14236#line 14237 "parse.c"
14240#line 4338 "parse.y"
14242 (yyval.node) = NEW_SPLAT((yyvsp[0].node), &(yyloc), &(yylsp[-1]));
14245#line 14246 "parse.c"
14249#line 4359 "parse.y"
14251 (yyval.node) = (
NODE *)NEW_FCALL((yyvsp[0].
id), 0, &(yyloc));
14254#line 14255 "parse.c"
14258#line 4364 "parse.y"
14262#line 14263 "parse.c"
14266#line 4369 "parse.y"
14269 set_line_body((yyvsp[-1].node), (yylsp[-3]).end_pos.lineno);
14270 (yyval.node) = NEW_BEGIN((yyvsp[-1].node), &(yyloc));
14271 nd_set_line((yyval.node), (yylsp[-3]).end_pos.lineno);
14274#line 14275 "parse.c"
14278#line 4376 "parse.y"
14279 {SET_LEX_STATE(EXPR_ENDARG);}
14280#line 14281 "parse.c"
14284#line 4377 "parse.y"
14286 if (nd_type_p((yyvsp[-2].node), NODE_SELF)) RNODE_SELF((yyvsp[-2].node))->nd_state = 0;
14287 (yyval.node) = (yyvsp[-2].node);
14290#line 14291 "parse.c"
14294#line 4383 "parse.y"
14296 if (nd_type_p((yyvsp[-1].node), NODE_SELF)) RNODE_SELF((yyvsp[-1].node))->nd_state = 0;
14297 (yyval.node) = NEW_BLOCK((yyvsp[-1].node), &(yyloc));
14300#line 14301 "parse.c"
14304#line 4389 "parse.y"
14306 (yyval.node) = NEW_COLON2((yyvsp[-2].node), (yyvsp[0].id), &(yyloc), &(yylsp[-1]), &(yylsp[0]));
14309#line 14310 "parse.c"
14313#line 4394 "parse.y"
14315 (yyval.node) = NEW_COLON3((yyvsp[0].
id), &(yyloc), &(yylsp[-1]), &(yylsp[0]));
14318#line 14319 "parse.c"
14322#line 4399 "parse.y"
14324 (yyval.node) = make_list((yyvsp[-1].node), &(yyloc));
14327#line 14328 "parse.c"
14331#line 4404 "parse.y"
14333 (yyval.node) = new_hash(p, (yyvsp[-1].node), &(yyloc));
14334 RNODE_HASH((yyval.node))->nd_brace = TRUE;
14337#line 14338 "parse.c"
14341#line 4410 "parse.y"
14343 (yyval.node) = NEW_RETURN(0, &(yyloc), &(yylsp[0]));
14346#line 14347 "parse.c"
14350#line 4415 "parse.y"
14352 (yyval.node) = NEW_YIELD((yyvsp[-1].node), &(yyloc), &(yylsp[-3]), &(yylsp[-2]), &(yylsp[0]));
14355#line 14356 "parse.c"
14359#line 4420 "parse.y"
14361 (yyval.node) = NEW_YIELD(0, &(yyloc), &(yylsp[-2]), &(yylsp[-1]), &(yylsp[0]));
14364#line 14365 "parse.c"
14368#line 4425 "parse.y"
14370 (yyval.node) = NEW_YIELD(0, &(yyloc), &(yylsp[0]), &NULL_LOC, &NULL_LOC);
14373#line 14374 "parse.c"
14377#line 4430 "parse.y"
14379 p->ctxt.in_defined = (yyvsp[-2].ctxt).in_defined;
14380 (yyval.node) = new_defined(p, (yyvsp[-1].node), &(yyloc), &(yylsp[-5]));
14381 p->ctxt.has_trailing_semicolon = (yyvsp[-2].ctxt).has_trailing_semicolon;
14384#line 14385 "parse.c"
14388#line 4437 "parse.y"
14390 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[-1].node), &(yylsp[-1])), METHOD_NOT, &(yylsp[-3]), &(yyloc));
14393#line 14394 "parse.c"
14397#line 4442 "parse.y"
14399 (yyval.node) = call_uni_op(p, method_cond(p, new_nil(&(yylsp[-1])), &(yylsp[-1])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
14402#line 14403 "parse.c"
14406#line 4447 "parse.y"
14408 (yyval.node) = method_add_block(p, (
NODE *)(yyvsp[-1].node_fcall), (yyvsp[0].node), &(yyloc));
14411#line 14412 "parse.c"
14415#line 4453 "parse.y"
14417 block_dup_check(p, get_nd_args(p, (yyvsp[-1].node)), (yyvsp[0].node));
14418 (yyval.node) = method_add_block(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
14421#line 14422 "parse.c"
14425#line 4463 "parse.y"
14427 if ((yyvsp[-1].node) && nd_type_p((yyvsp[-1].node), NODE_IF))
14428 RNODE_IF((yyvsp[-1].node))->end_keyword_loc = (yylsp[0]);
14430 (yyval.node) = new_if(p, (yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[-1].node), &(yyloc), &(yylsp[-5]), &(yylsp[-3]), &(yylsp[0]));
14431 fixpos((yyval.node), (yyvsp[-4].node));
14434#line 14435 "parse.c"
14438#line 4475 "parse.y"
14440 (yyval.node) = new_unless(p, (yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[-1].node), &(yyloc), &(yylsp[-5]), &(yylsp[-3]), &(yylsp[0]));
14441 fixpos((yyval.node), (yyvsp[-4].node));
14444#line 14445 "parse.c"
14448#line 4483 "parse.y"
14450 restore_block_exit(p, (yyvsp[-3].node_exits));
14451 (yyval.node) = NEW_WHILE(cond(p, (yyvsp[-2].node), &(yylsp[-2])), (yyvsp[-1].node), 1, &(yyloc), &(yylsp[-3]), &(yylsp[0]));
14452 fixpos((yyval.node), (yyvsp[-2].node));
14455#line 14456 "parse.c"
14459#line 4492 "parse.y"
14461 restore_block_exit(p, (yyvsp[-3].node_exits));
14462 (yyval.node) = NEW_UNTIL(cond(p, (yyvsp[-2].node), &(yylsp[-2])), (yyvsp[-1].node), 1, &(yyloc), &(yylsp[-3]), &(yylsp[0]));
14463 fixpos((yyval.node), (yyvsp[-2].node));
14466#line 14467 "parse.c"
14470#line 4499 "parse.y"
14472 (yyval.labels) = p->case_labels;
14473 p->case_labels = CHECK_LITERAL_WHEN;
14475#line 14476 "parse.c"
14479#line 4505 "parse.y"
14481 if (CASE_LABELS_ENABLED_P(p->case_labels)) st_free_table(p->case_labels);
14482 p->case_labels = (yyvsp[-2].labels);
14483 (yyval.node) = NEW_CASE((yyvsp[-4].node), (yyvsp[-1].node), &(yyloc), &(yylsp[-5]), &(yylsp[0]));
14484 fixpos((yyval.node), (yyvsp[-4].node));
14487#line 14488 "parse.c"
14491#line 4513 "parse.y"
14493 (yyval.labels) = p->case_labels;
14494 p->case_labels = 0;
14496#line 14497 "parse.c"
14500#line 4519 "parse.y"
14502 if (p->case_labels) st_free_table(p->case_labels);
14503 p->case_labels = (yyvsp[-2].labels);
14504 (yyval.node) = NEW_CASE2((yyvsp[-1].node), &(yyloc), &(yylsp[-4]), &(yylsp[0]));
14507#line 14508 "parse.c"
14511#line 4528 "parse.y"
14513 (yyval.node) = NEW_CASE3((yyvsp[-3].node), (yyvsp[-1].node), &(yyloc), &(yylsp[-4]), &(yylsp[0]));
14516#line 14517 "parse.c"
14520#line 4533 "parse.y"
14522#line 14523 "parse.c"
14526#line 4533 "parse.y"
14528#line 14529 "parse.c"
14532#line 4536 "parse.y"
14534 restore_block_exit(p, (yyvsp[-8].node_exits));
14544 ID id = internal_id(p);
14547 NODE *scope, *internal_var = NEW_DVAR(
id, &(yylsp[-7]));
14551 switch (nd_type((yyvsp[-7].node))) {
14554 set_nd_value(p, (yyvsp[-7].node), internal_var);
14557 m->nd_next = (yyvsp[-7].node);
14560 m->nd_next = node_assign(p, (yyvsp[-7].node), NEW_FOR_MASGN(internal_var, &(yylsp[-7])), NO_LEX_CTXT, &(yylsp[-7]));
14563 m->nd_next = node_assign(p, (
NODE *)NEW_MASGN(NEW_LIST((yyvsp[-7].node), &(yylsp[-7])), 0, &(yylsp[-7])), internal_var, NO_LEX_CTXT, &(yylsp[-7]));
14566 args = new_args(p, m, 0,
id, 0, new_args_tail(p, 0, 0, 0, &(yylsp[-7])), &(yylsp[-7]));
14567 scope = NEW_SCOPE2(tbl, args, (yyvsp[-1].node), &(yyloc));
14568 YYLTYPE do_keyword_loc = (yyvsp[-3].id) == keyword_do_cond ? (yylsp[-3]) : NULL_LOC;
14569 (yyval.node) = NEW_FOR((yyvsp[-4].node), scope, &(yyloc), &(yylsp[-8]), &(yylsp[-6]), &do_keyword_loc, &(yylsp[0]));
14570 fixpos((yyval.node), (yyvsp[-7].node));
14573#line 14574 "parse.c"
14577#line 4577 "parse.y"
14579 begin_definition(
"class", &(yylsp[-2]), &(yylsp[-1]));
14581#line 14582 "parse.c"
14585#line 4582 "parse.y"
14587 YYLTYPE inheritance_operator_loc = NULL_LOC;
14588 if ((yyvsp[-3].node)) {
14589 inheritance_operator_loc = (yylsp[-3]);
14590 inheritance_operator_loc.end_pos.column = inheritance_operator_loc.beg_pos.column + 1;
14592 (yyval.node) = NEW_CLASS((yyvsp[-4].node), (yyvsp[-1].node), (yyvsp[-3].node), &(yyloc), &(yylsp[-5]), &inheritance_operator_loc, &(yylsp[0]));
14593 nd_set_line(RNODE_CLASS((yyval.node))->nd_body, (yylsp[0]).end_pos.lineno);
14594 set_line_body((yyvsp[-1].node), (yylsp[-3]).end_pos.lineno);
14595 nd_set_line((yyval.node), (yylsp[-3]).end_pos.lineno);
14598 p->ctxt.in_class = (yyvsp[-5].ctxt).in_class;
14599 p->ctxt.cant_return = (yyvsp[-5].ctxt).cant_return;
14600 p->ctxt.shareable_constant_value = (yyvsp[-5].ctxt).shareable_constant_value;
14602#line 14603 "parse.c"
14606#line 4599 "parse.y"
14608 begin_definition(
"", &(yylsp[-2]), &(yylsp[-1]));
14610#line 14611 "parse.c"
14614#line 4605 "parse.y"
14616 (yyval.node) = NEW_SCLASS((yyvsp[-4].node), (yyvsp[-1].node), &(yyloc));
14617 nd_set_line(RNODE_SCLASS((yyval.node))->nd_body, (yylsp[0]).end_pos.lineno);
14618 set_line_body((yyvsp[-1].node), nd_line((yyvsp[-4].node)));
14619 fixpos((yyval.node), (yyvsp[-4].node));
14622 p->ctxt.in_def = (yyvsp[-6].ctxt).in_def;
14623 p->ctxt.in_class = (yyvsp[-6].ctxt).in_class;
14624 p->ctxt.cant_return = (yyvsp[-6].ctxt).cant_return;
14625 p->ctxt.shareable_constant_value = (yyvsp[-6].ctxt).shareable_constant_value;
14627#line 14628 "parse.c"
14631#line 4618 "parse.y"
14633 begin_definition(
"module", &(yylsp[-1]), &(yylsp[0]));
14635#line 14636 "parse.c"
14639#line 4623 "parse.y"
14641 (yyval.node) = NEW_MODULE((yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
14642 nd_set_line(RNODE_MODULE((yyval.node))->nd_body, (yylsp[0]).end_pos.lineno);
14643 set_line_body((yyvsp[-1].node), (yylsp[-3]).end_pos.lineno);
14644 nd_set_line((yyval.node), (yylsp[-3]).end_pos.lineno);
14647 p->ctxt.in_class = (yyvsp[-4].ctxt).in_class;
14648 p->ctxt.cant_return = (yyvsp[-4].ctxt).cant_return;
14649 p->ctxt.shareable_constant_value = (yyvsp[-4].ctxt).shareable_constant_value;
14651#line 14652 "parse.c"
14655#line 4636 "parse.y"
14657 push_end_expect_token_locations(p, &(yylsp[-1]).beg_pos);
14659#line 14660 "parse.c"
14663#line 4641 "parse.y"
14665 restore_defun(p, (yyvsp[-4].node_def_temp));
14666 (yyvsp[-1].node) = new_scope_body(p, (yyvsp[-3].node_args), (yyvsp[-1].node), &(yyloc));
14667 ((yyval.node) = (yyvsp[-4].node_def_temp)->nd_def)->nd_loc = (yyloc);
14668 RNODE_DEFN((yyval.node))->nd_defn = (yyvsp[-1].node);
14672#line 14673 "parse.c"
14676#line 4651 "parse.y"
14678 push_end_expect_token_locations(p, &(yylsp[-1]).beg_pos);
14680#line 14681 "parse.c"
14684#line 4656 "parse.y"
14686 restore_defun(p, (yyvsp[-4].node_def_temp));
14687 (yyvsp[-1].node) = new_scope_body(p, (yyvsp[-3].node_args), (yyvsp[-1].node), &(yyloc));
14688 ((yyval.node) = (yyvsp[-4].node_def_temp)->nd_def)->nd_loc = (yyloc);
14689 RNODE_DEFS((yyval.node))->nd_defn = (yyvsp[-1].node);
14693#line 14694 "parse.c"
14697#line 4665 "parse.y"
14699 (yyval.node) = add_block_exit(p, NEW_BREAK(0, &(yyloc), &(yylsp[0])));
14702#line 14703 "parse.c"
14706#line 4670 "parse.y"
14708 (yyval.node) = add_block_exit(p, NEW_NEXT(0, &(yyloc), &(yylsp[0])));
14711#line 14712 "parse.c"
14715#line 4675 "parse.y"
14717 (yyval.node) = add_block_exit(p, NEW_REDO(&(yyloc), &(yylsp[0])));
14720#line 14721 "parse.c"
14724#line 4680 "parse.y"
14726 if (!p->ctxt.in_defined) {
14727 switch (p->ctxt.in_rescue) {
14728 case before_rescue: yyerror1(&(yylsp[0]),
"Invalid retry without rescue");
break;
14729 case after_rescue:
break;
14730 case after_else: yyerror1(&(yylsp[0]),
"Invalid retry after else");
break;
14731 case after_ensure: yyerror1(&(yylsp[0]),
"Invalid retry after ensure");
break;
14734 (yyval.node) = NEW_RETRY(&(yyloc));
14737#line 14738 "parse.c"
14741#line 3144 "parse.y"
14743 value_expr((yyvsp[0].node));
14744 (yyval.node) = (yyvsp[0].node);
14746#line 14747 "parse.c"
14750#line 4698 "parse.y"
14752 token_info_push(p,
"begin", &(yyloc));
14753 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14755#line 14756 "parse.c"
14759#line 4705 "parse.y"
14762 token_info_push(p,
"if", &(yyloc));
14763 if (p->token_info && p->token_info->nonspc &&
14764 p->token_info->next && !strcmp(p->token_info->next->token,
"else")) {
14766 const char *beg = p->lex.pbeg + p->token_info->next->beg.column;
14768 while (beg < tok &&
ISSPACE(*beg)) beg++;
14770 p->token_info->nonspc = 0;
14773 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14775#line 14776 "parse.c"
14779#line 4723 "parse.y"
14781 token_info_push(p,
"unless", &(yyloc));
14782 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14784#line 14785 "parse.c"
14788#line 4730 "parse.y"
14790 (yyval.node_exits) = (yyvsp[0].node_exits);
14791 token_info_push(p,
"while", &(yyloc));
14792 push_end_expect_token_locations(p, &(yylsp[-1]).beg_pos);
14794#line 14795 "parse.c"
14798#line 4738 "parse.y"
14800 (yyval.node_exits) = (yyvsp[0].node_exits);
14801 token_info_push(p,
"until", &(yyloc));
14802 push_end_expect_token_locations(p, &(yylsp[-1]).beg_pos);
14804#line 14805 "parse.c"
14808#line 4746 "parse.y"
14810 token_info_push(p,
"case", &(yyloc));
14811 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14813#line 14814 "parse.c"
14817#line 4753 "parse.y"
14819 (yyval.node_exits) = (yyvsp[0].node_exits);
14820 token_info_push(p,
"for", &(yyloc));
14821 push_end_expect_token_locations(p, &(yylsp[-1]).beg_pos);
14823#line 14824 "parse.c"
14827#line 4761 "parse.y"
14829 token_info_push(p,
"class", &(yyloc));
14830 (yyval.ctxt) = p->ctxt;
14831 p->ctxt.in_rescue = before_rescue;
14832 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14834#line 14835 "parse.c"
14838#line 4770 "parse.y"
14840 token_info_push(p,
"module", &(yyloc));
14841 (yyval.ctxt) = p->ctxt;
14842 p->ctxt.in_rescue = before_rescue;
14843 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14845#line 14846 "parse.c"
14849#line 4779 "parse.y"
14851 token_info_push(p,
"def", &(yyloc));
14852 (yyval.node_def_temp) = NEW_DEF_TEMP(&(yyloc));
14853 p->ctxt.in_argdef = 1;
14855#line 14856 "parse.c"
14859#line 4787 "parse.y"
14861 token_info_push(p,
"do", &(yyloc));
14862 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14864#line 14865 "parse.c"
14868#line 4794 "parse.y"
14870 token_info_push(p,
"do", &(yyloc));
14871 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14873#line 14874 "parse.c"
14877#line 4801 "parse.y"
14879 token_info_warn(p,
"rescue", p->token_info, 1, &(yyloc));
14880 (yyval.ctxt) = p->ctxt;
14881 p->ctxt.in_rescue = after_rescue;
14883#line 14884 "parse.c"
14887#line 4809 "parse.y"
14889 token_info_warn(p,
"ensure", p->token_info, 1, &(yyloc));
14890 (yyval.ctxt) = p->ctxt;
14892#line 14893 "parse.c"
14896#line 4816 "parse.y"
14898 token_info_warn(p,
"when", p->token_info, 0, &(yyloc));
14900#line 14901 "parse.c"
14904#line 4822 "parse.y"
14907 int same = ptinfo_beg && strcmp(ptinfo_beg->token,
"case") != 0;
14908 token_info_warn(p,
"else", p->token_info, same, &(yyloc));
14911 e.next = ptinfo_beg->next;
14913 token_info_setup(&e, p->lex.pbeg, &(yyloc));
14914 if (!e.nonspc) *ptinfo_beg = e;
14917#line 14918 "parse.c"
14921#line 4837 "parse.y"
14924 token_info_warn(p,
"elsif", p->token_info, 1, &(yyloc));
14926#line 14927 "parse.c"
14930#line 4844 "parse.y"
14932 token_info_pop(p,
"end", &(yyloc));
14933 pop_end_expect_token_locations(p);
14935#line 14936 "parse.c"
14939#line 4849 "parse.y"
14941 compile_error(p,
"syntax error, unexpected end-of-input");
14943#line 14944 "parse.c"
14947#line 4855 "parse.y"
14949 if (p->ctxt.cant_return && !dyna_in_block(p))
14950 yyerror1(&(yylsp[0]),
"Invalid return in class/module body");
14952#line 14953 "parse.c"
14956#line 4862 "parse.y"
14958 if (!p->ctxt.in_defined && !p->ctxt.in_def && !compile_for_eval)
14959 yyerror1(&(yylsp[0]),
"Invalid yield");
14961#line 14962 "parse.c"
14965#line 4874 "parse.y"
14966 { (yyval.id) = keyword_do_cond; }
14967#line 14968 "parse.c"
14971#line 4881 "parse.y"
14973 (yyval.node) = new_if(p, (yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node), &(yyloc), &(yylsp[-4]), &(yylsp[-2]), &NULL_LOC);
14974 fixpos((yyval.node), (yyvsp[-3].node));
14977#line 14978 "parse.c"
14981#line 4890 "parse.y"
14983 (yyval.node) = (yyvsp[0].node);
14986#line 14987 "parse.c"
14990#line 4901 "parse.y"
14992 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
14993 mark_lvar_used(p, (yyval.node));
14995#line 14996 "parse.c"
14999#line 4906 "parse.y"
15001 (yyval.node) = (
NODE *)(yyvsp[-1].node_masgn);
15004#line 15005 "parse.c"
15008#line 3031 "parse.y"
15010 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
15013#line 15014 "parse.c"
15017#line 3036 "parse.y"
15019 (yyval.node) = list_append(p, (yyvsp[-2].node), (yyvsp[0].node));
15022#line 15023 "parse.c"
15026#line 4914 "parse.y"
15028 (yyval.node_masgn) = NEW_MASGN((yyvsp[0].node), 0, &(yyloc));
15031#line 15032 "parse.c"
15035#line 4919 "parse.y"
15037 (yyval.node_masgn) = NEW_MASGN((yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
15040#line 15041 "parse.c"
15044#line 4924 "parse.y"
15046 (yyval.node_masgn) = NEW_MASGN((yyvsp[-4].node), NEW_POSTARG((yyvsp[-2].node), (yyvsp[0].node), &(yyloc)), &(yyloc));
15049#line 15050 "parse.c"
15053#line 4929 "parse.y"
15055 (yyval.node_masgn) = NEW_MASGN(0, (yyvsp[0].node), &(yyloc));
15058#line 15059 "parse.c"
15062#line 4934 "parse.y"
15064 (yyval.node_masgn) = NEW_MASGN(0, NEW_POSTARG((yyvsp[-2].node), (yyvsp[0].node), &(yyloc)), &(yyloc));
15067#line 15068 "parse.c"
15071#line 4941 "parse.y"
15074 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
15075 mark_lvar_used(p, (yyval.node));
15077#line 15078 "parse.c"
15081#line 4947 "parse.y"
15083 (yyval.node) = NODE_SPECIAL_NO_NAME_REST;
15086#line 15087 "parse.c"
15090#line 4955 "parse.y"
15092 (yyval.id) = idNil;
15095#line 15096 "parse.c"
15099#line 4961 "parse.y"
15100 {p->ctxt.in_argdef = 0;}
15101#line 15102 "parse.c"
15105#line 3003 "parse.y"
15107 p->ctxt.in_argdef = 1;
15108 (yyval.node_kw_arg) = new_kw_arg(p, assignable(p, (yyvsp[-1].
id), (yyvsp[0].node), &(yyloc)), &(yyloc));
15111#line 15112 "parse.c"
15115#line 3009 "parse.y"
15117 p->ctxt.in_argdef = 1;
15118 (yyval.node_kw_arg) = new_kw_arg(p, assignable(p, (yyvsp[0].
id), NODE_SPECIAL_REQUIRED_KEYWORD, &(yyloc)), &(yyloc));
15121#line 15122 "parse.c"
15125#line 3018 "parse.y"
15127 (yyval.node_kw_arg) = (yyvsp[0].node_kw_arg);
15130#line 15131 "parse.c"
15134#line 3023 "parse.y"
15136 (yyval.node_kw_arg) = kwd_append((yyvsp[-2].node_kw_arg), (yyvsp[0].node_kw_arg));
15139#line 15140 "parse.c"
15143#line 2927 "parse.y"
15145 (yyval.node_args) = new_args_tail(p, (yyvsp[-3].node_kw_arg), (yyvsp[-1].id), (yyvsp[0].
id), &(yylsp[-1]));
15148#line 15149 "parse.c"
15152#line 2932 "parse.y"
15154 (yyval.node_args) = new_args_tail(p, (yyvsp[-1].node_kw_arg), 0, (yyvsp[0].id), &(yylsp[-1]));
15157#line 15158 "parse.c"
15161#line 2937 "parse.y"
15163 (yyval.node_args) = new_args_tail(p, 0, (yyvsp[-1].
id), (yyvsp[0].id), &(yylsp[-1]));
15166#line 15167 "parse.c"
15170#line 2942 "parse.y"
15172 (yyval.node_args) = new_args_tail(p, 0, 0, (yyvsp[0].
id), &(yylsp[0]));
15175#line 15176 "parse.c"
15179#line 4967 "parse.y"
15182 (yyval.id) = NODE_SPECIAL_EXCESSIVE_COMMA;
15185#line 15186 "parse.c"
15189#line 2981 "parse.y"
15191 p->ctxt.in_argdef = 1;
15192 (yyval.node_opt_arg) = NEW_OPT_ARG(assignable(p, (yyvsp[-2].
id), (yyvsp[0].node), &(yyloc)), &(yyloc));
15195#line 15196 "parse.c"
15199#line 2990 "parse.y"
15201 (yyval.node_opt_arg) = (yyvsp[0].node_opt_arg);
15204#line 15205 "parse.c"
15208#line 2995 "parse.y"
15210 (yyval.node_opt_arg) = opt_arg_append((yyvsp[-2].node_opt_arg), (yyvsp[0].node_opt_arg));
15213#line 15214 "parse.c"
15217#line 3090 "parse.y"
15219 (yyval.node_args) = (yyvsp[0].node_args);
15222#line 15223 "parse.c"
15226#line 3095 "parse.y"
15228 (yyval.node_args) = new_args_tail(p, 0, 0, 0, &(yylsp[0]));
15231#line 15232 "parse.c"
15235#line 4975 "parse.y"
15237 (yyval.node_args) = new_args(p, (yyvsp[-5].node_args_aux), (yyvsp[-3].node_opt_arg), (yyvsp[-1].
id), 0, (yyvsp[0].node_args), &(yyloc));
15240#line 15241 "parse.c"
15244#line 4980 "parse.y"
15246 (yyval.node_args) = new_args(p, (yyvsp[-7].node_args_aux), (yyvsp[-5].node_opt_arg), (yyvsp[-3].
id), (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
15249#line 15250 "parse.c"
15253#line 4985 "parse.y"
15255 (yyval.node_args) = new_args(p, (yyvsp[-3].node_args_aux), (yyvsp[-1].node_opt_arg), 0, 0, (yyvsp[0].node_args), &(yyloc));
15258#line 15259 "parse.c"
15262#line 4990 "parse.y"
15264 (yyval.node_args) = new_args(p, (yyvsp[-5].node_args_aux), (yyvsp[-3].node_opt_arg), 0, (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
15267#line 15268 "parse.c"
15271#line 4995 "parse.y"
15273 (yyval.node_args) = new_args(p, (yyvsp[-3].node_args_aux), 0, (yyvsp[-1].id), 0, (yyvsp[0].node_args), &(yyloc));
15276#line 15277 "parse.c"
15280#line 5000 "parse.y"
15282 (yyval.node_args) = new_args_tail(p, 0, 0, 0, &(yylsp[0]));
15283 (yyval.node_args) = new_args(p, (yyvsp[-1].node_args_aux), 0, (yyvsp[0].id), 0, (yyval.node_args), &(yyloc));
15286#line 15287 "parse.c"
15290#line 5006 "parse.y"
15292 (yyval.node_args) = new_args(p, (yyvsp[-5].node_args_aux), 0, (yyvsp[-3].id), (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
15295#line 15296 "parse.c"
15299#line 5011 "parse.y"
15301 (yyval.node_args) = new_args(p, (yyvsp[-1].node_args_aux), 0, 0, 0, (yyvsp[0].node_args), &(yyloc));
15304#line 15305 "parse.c"
15308#line 5016 "parse.y"
15310 (yyval.node_args) = new_args(p, 0, (yyvsp[-3].node_opt_arg), (yyvsp[-1].id), 0, (yyvsp[0].node_args), &(yyloc));
15313#line 15314 "parse.c"
15317#line 5021 "parse.y"
15319 (yyval.node_args) = new_args(p, 0, (yyvsp[-5].node_opt_arg), (yyvsp[-3].id), (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
15322#line 15323 "parse.c"
15326#line 5026 "parse.y"
15328 (yyval.node_args) = new_args(p, 0, (yyvsp[-1].node_opt_arg), 0, 0, (yyvsp[0].node_args), &(yyloc));
15331#line 15332 "parse.c"
15335#line 5031 "parse.y"
15337 (yyval.node_args) = new_args(p, 0, (yyvsp[-3].node_opt_arg), 0, (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
15340#line 15341 "parse.c"
15344#line 5036 "parse.y"
15346 (yyval.node_args) = new_args(p, 0, 0, (yyvsp[-1].
id), 0, (yyvsp[0].node_args), &(yyloc));
15349#line 15350 "parse.c"
15353#line 5041 "parse.y"
15355 (yyval.node_args) = new_args(p, 0, 0, (yyvsp[-3].
id), (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
15358#line 15359 "parse.c"
15362#line 5046 "parse.y"
15364 (yyval.node_args) = new_args(p, 0, 0, 0, 0, (yyvsp[0].node_args), &(yyloc));
15367#line 15368 "parse.c"
15371#line 5054 "parse.y"
15373 p->command_start = TRUE;
15375#line 15376 "parse.c"
15379#line 5060 "parse.y"
15381 p->max_numparam = ORDINAL_PARAM;
15382 p->ctxt.in_argdef = 0;
15383 (yyval.node_args) = (yyvsp[-2].node_args);
15386#line 15387 "parse.c"
15390#line 5069 "parse.y"
15392 (yyval.node_args) = 0;
15395#line 15396 "parse.c"
15399#line 5077 "parse.y"
15404#line 15405 "parse.c"
15408#line 5082 "parse.y"
15413#line 15414 "parse.c"
15417#line 5095 "parse.y"
15419 new_bv(p, (yyvsp[0].
id));
15422#line 15423 "parse.c"
15426#line 5102 "parse.y"
15428 (yyval.num) = p->max_numparam;
15429 p->max_numparam = 0;
15431#line 15432 "parse.c"
15435#line 5108 "parse.y"
15437 (yyval.node) = numparam_push(p);
15439#line 15440 "parse.c"
15443#line 5113 "parse.y"
15445 (yyval.id) = p->it_id;
15448#line 15449 "parse.c"
15452#line 5120 "parse.y"
15454 token_info_push(p,
"->", &(yylsp[0]));
15455 (yyval.vars) = dyna_push(p);
15457#line 15458 "parse.c"
15461#line 5126 "parse.y"
15465#line 15466 "parse.c"
15469#line 5130 "parse.y"
15471 int max_numparam = p->max_numparam;
15472 ID it_id = p->it_id;
15473 p->lex.lpar_beg = (yyvsp[-8].num);
15474 p->max_numparam = (yyvsp[-6].num);
15475 p->it_id = (yyvsp[-4].id);
15476 restore_block_exit(p, (yyvsp[-3].node_exits));
15478 (yyvsp[-2].node_args) = args_with_numbered(p, (yyvsp[-2].node_args), max_numparam, it_id);
15480 YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
15481 (yyval.node) = NEW_LAMBDA((yyvsp[-2].node_args), (yyvsp[0].locations_lambda_body)->node, &loc, &(yylsp[-8]), &(yyvsp[0].locations_lambda_body)->opening_loc, &(yyvsp[0].locations_lambda_body)->closing_loc);
15482 nd_set_line(RNODE_LAMBDA((yyval.node))->nd_body, (yylsp[0]).end_pos.lineno);
15483 nd_set_line((yyval.node), (yylsp[-2]).end_pos.lineno);
15484 nd_set_first_loc((yyval.node), (yylsp[-8]).beg_pos);
15485 xfree((yyvsp[0].locations_lambda_body));
15488 numparam_pop(p, (yyvsp[-5].node));
15489 dyna_pop(p, (yyvsp[-7].vars));
15491#line 15492 "parse.c"
15495#line 5154 "parse.y"
15497 p->ctxt.in_argdef = 0;
15498 (yyval.node_args) = (yyvsp[-2].node_args);
15499 p->max_numparam = ORDINAL_PARAM;
15502#line 15503 "parse.c"
15506#line 5161 "parse.y"
15508 p->ctxt.in_argdef = 0;
15509 if (!args_info_empty_p(&(yyvsp[0].node_args)->nd_ainfo))
15510 p->max_numparam = ORDINAL_PARAM;
15511 (yyval.node_args) = (yyvsp[0].node_args);
15513#line 15514 "parse.c"
15517#line 5170 "parse.y"
15519 token_info_pop(p,
"}", &(yylsp[0]));
15520 (yyval.locations_lambda_body) = new_locations_lambda_body(p, (yyvsp[-1].node), &(yylsp[-1]), &(yylsp[-2]), &(yylsp[0]));
15523#line 15524 "parse.c"
15527#line 5176 "parse.y"
15529 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
15531#line 15532 "parse.c"
15535#line 5180 "parse.y"
15537 (yyval.locations_lambda_body) = new_locations_lambda_body(p, (yyvsp[-1].node), &(yylsp[-1]), &(yylsp[-3]), &(yylsp[0]));
15540#line 15541 "parse.c"
15544#line 5187 "parse.y"
15546 (yyval.node) = (yyvsp[-1].node);
15547 set_embraced_location((yyval.node), &(yylsp[-2]), &(yylsp[0]));
15550#line 15551 "parse.c"
15554#line 5195 "parse.y"
15556 if (nd_type_p((yyvsp[-1].node), NODE_YIELD)) {
15557 compile_error(p,
"block given to yield");
15560 block_dup_check(p, get_nd_args(p, (yyvsp[-1].node)), (yyvsp[0].node));
15562 (yyval.node) = method_add_block(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
15563 fixpos((yyval.node), (yyvsp[-1].node));
15566#line 15567 "parse.c"
15570#line 5207 "parse.y"
15572 bool has_args = (yyvsp[0].node) != 0;
15573 if (NODE_EMPTY_ARGS_P((yyvsp[0].node))) (yyvsp[0].node) = 0;
15574 (yyval.node) = new_qcall(p, (yyvsp[-2].
id), (yyvsp[-3].node), (yyvsp[-1].
id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
15580#line 15581 "parse.c"
15584#line 5217 "parse.y"
15586 if (NODE_EMPTY_ARGS_P((yyvsp[-1].node))) (yyvsp[-1].node) = 0;
15587 (yyval.node) = new_command_qcall(p, (yyvsp[-3].
id), (yyvsp[-4].node), (yyvsp[-2].
id), (yyvsp[-1].node), (yyvsp[0].node), &(yylsp[-2]), &(yyloc));
15589 if ((yyvsp[0].node)) {
15593#line 15594 "parse.c"
15597#line 5226 "parse.y"
15599 (yyval.node) = new_command_qcall(p, (yyvsp[-3].
id), (yyvsp[-4].node), (yyvsp[-2].
id), (yyvsp[-1].node), (yyvsp[0].node), &(yylsp[-2]), &(yyloc));
15602#line 15603 "parse.c"
15606#line 5233 "parse.y"
15608 (yyvsp[-1].node_fcall)->nd_args = (yyvsp[0].node);
15609 (yyval.node) = (
NODE *)(yyvsp[-1].node_fcall);
15610 nd_set_last_loc((yyvsp[-1].node_fcall), (yylsp[0]).end_pos);
15613#line 15614 "parse.c"
15617#line 5240 "parse.y"
15619 bool has_args = (yyvsp[0].node) != 0;
15620 if (NODE_EMPTY_ARGS_P((yyvsp[0].node))) (yyvsp[0].node) = 0;
15621 (yyval.node) = new_qcall(p, (yyvsp[-2].
id), (yyvsp[-3].node), (yyvsp[-1].
id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
15622 nd_set_line((yyval.node), (yylsp[-1]).end_pos.lineno);
15628#line 15629 "parse.c"
15632#line 5251 "parse.y"
15634 (yyval.node) = new_qcall(p, idCOLON2, (yyvsp[-3].node), (yyvsp[-1].id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
15635 nd_set_line((yyval.node), (yylsp[-1]).end_pos.lineno);
15638#line 15639 "parse.c"
15642#line 5257 "parse.y"
15644 (yyval.node) = new_qcall(p, idCOLON2, (yyvsp[-2].node), (yyvsp[0].id), 0, &(yylsp[0]), &(yyloc));
15647#line 15648 "parse.c"
15651#line 5262 "parse.y"
15653 (yyval.node) = new_qcall(p, (yyvsp[-1].
id), (yyvsp[-2].node), idCall, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
15654 nd_set_line((yyval.node), (yylsp[-1]).end_pos.lineno);
15657#line 15658 "parse.c"
15661#line 5268 "parse.y"
15665 lparen_loc.end_pos.column = lparen_loc.beg_pos.column + 1;
15666 rparen_loc.beg_pos.column = rparen_loc.end_pos.column - 1;
15668 (yyval.node) = NEW_SUPER((yyvsp[0].node), &(yyloc), &(yylsp[-1]), &lparen_loc, &rparen_loc);
15671#line 15672 "parse.c"
15675#line 5278 "parse.y"
15677 (yyval.node) = NEW_ZSUPER(&(yyloc));
15680#line 15681 "parse.c"
15684#line 5283 "parse.y"
15686 (yyval.node) = NEW_CALL((yyvsp[-3].node), tAREF, (yyvsp[-1].node), &(yyloc));
15687 fixpos((yyval.node), (yyvsp[-3].node));
15690#line 15691 "parse.c"
15694#line 5291 "parse.y"
15696 (yyval.node) = (yyvsp[-1].node);
15697 set_embraced_location((yyval.node), &(yylsp[-2]), &(yylsp[0]));
15700#line 15701 "parse.c"
15704#line 5297 "parse.y"
15706 (yyval.node) = (yyvsp[-1].node);
15707 set_embraced_location((yyval.node), &(yylsp[-2]), &(yylsp[0]));
15710#line 15711 "parse.c"
15714#line 5304 "parse.y"
15715 {(yyval.vars) = dyna_push(p);}
15716#line 15717 "parse.c"
15720#line 5307 "parse.y"
15722 int max_numparam = p->max_numparam;
15723 ID it_id = p->it_id;
15724 p->max_numparam = (yyvsp[-5].num);
15725 p->it_id = (yyvsp[-3].id);
15726 (yyvsp[-1].node_args) = args_with_numbered(p, (yyvsp[-1].node_args), max_numparam, it_id);
15727 (yyval.node) = NEW_ITER((yyvsp[-1].node_args), (yyvsp[0].node), &(yyloc));
15729 restore_block_exit(p, (yyvsp[-2].node_exits));
15730 numparam_pop(p, (yyvsp[-4].node));
15731 dyna_pop(p, (yyvsp[-6].vars));
15733#line 15734 "parse.c"
15737#line 5321 "parse.y"
15739 (yyval.vars) = dyna_push(p);
15742#line 15743 "parse.c"
15746#line 5327 "parse.y"
15748 int max_numparam = p->max_numparam;
15749 ID it_id = p->it_id;
15750 p->max_numparam = (yyvsp[-5].num);
15751 p->it_id = (yyvsp[-3].id);
15752 (yyvsp[-1].node_args) = args_with_numbered(p, (yyvsp[-1].node_args), max_numparam, it_id);
15753 (yyval.node) = NEW_ITER((yyvsp[-1].node_args), (yyvsp[0].node), &(yyloc));
15756 restore_block_exit(p, (yyvsp[-2].node_exits));
15757 numparam_pop(p, (yyvsp[-4].node));
15758 dyna_pop(p, (yyvsp[-6].vars));
15760#line 15761 "parse.c"
15764#line 5343 "parse.y"
15766 check_literal_when(p, (yyvsp[0].node), &(yylsp[0]));
15767 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
15770#line 15771 "parse.c"
15774#line 5349 "parse.y"
15776 (yyval.node) = NEW_SPLAT((yyvsp[0].node), &(yyloc), &(yylsp[-1]));
15779#line 15780 "parse.c"
15783#line 5354 "parse.y"
15785 check_literal_when(p, (yyvsp[0].node), &(yylsp[0]));
15786 (yyval.node) = last_arg_append(p, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
15789#line 15790 "parse.c"
15793#line 5360 "parse.y"
15795 (yyval.node) = rest_arg_append(p, (yyvsp[-3].node), (yyvsp[0].node), &(yyloc));
15798#line 15799 "parse.c"
15802#line 5369 "parse.y"
15804 (yyval.node) = NEW_WHEN((yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node), &(yyloc), &(yylsp[-4]), &(yylsp[-2]));
15805 fixpos((yyval.node), (yyvsp[-3].node));
15808#line 15809 "parse.c"
15812#line 5380 "parse.y"
15813 {(yyval.tbl) = p->pvtbl; p->pvtbl = st_init_numtable();}
15814#line 15815 "parse.c"
15818#line 5381 "parse.y"
15819 {(yyval.tbl) = p->pktbl; p->pktbl = 0;}
15820#line 15821 "parse.c"
15824#line 5383 "parse.y"
15826 (yyval.ctxt) = p->ctxt;
15827 SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
15828 p->command_start = FALSE;
15829 p->ctxt.in_kwarg = 1;
15831#line 15832 "parse.c"
15835#line 5394 "parse.y"
15837 pop_pktbl(p, (yyvsp[-2].tbl));
15838 pop_pvtbl(p, (yyvsp[-3].tbl));
15839 p->ctxt.in_kwarg = (yyvsp[-4].ctxt).in_kwarg;
15841#line 15842 "parse.c"
15845#line 5401 "parse.y"
15847 (yyval.node) = NEW_IN((yyvsp[-4].node), (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
15850#line 15851 "parse.c"
15854#line 5413 "parse.y"
15856 (yyval.node) = new_if(p, (yyvsp[0].node), (yyvsp[-2].node), 0, &(yyloc), &(yylsp[-1]), &NULL_LOC, &NULL_LOC);
15857 fixpos((yyval.node), (yyvsp[0].node));
15860#line 15861 "parse.c"
15864#line 5419 "parse.y"
15866 (yyval.node) = new_unless(p, (yyvsp[0].node), (yyvsp[-2].node), 0, &(yyloc), &(yylsp[-1]), &NULL_LOC, &NULL_LOC);
15867 fixpos((yyval.node), (yyvsp[0].node));
15870#line 15871 "parse.c"
15874#line 5428 "parse.y"
15876 (yyval.node) = new_array_pattern_tail(p, 0, 1, 0, 0, &(yyloc));
15877 (yyval.node) = new_array_pattern(p, 0, (yyvsp[-1].node), (yyval.node), &(yyloc));
15880#line 15881 "parse.c"
15884#line 5434 "parse.y"
15886 (yyval.node) = new_array_pattern(p, 0, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
15887 nd_set_first_loc((yyval.node), (yylsp[-2]).beg_pos);
15890#line 15891 "parse.c"
15894#line 5440 "parse.y"
15896 (yyval.node) = new_find_pattern(p, 0, (yyvsp[0].node), &(yyloc));
15899#line 15900 "parse.c"
15903#line 5445 "parse.y"
15905 (yyval.node) = new_array_pattern(p, 0, 0, (yyvsp[0].node), &(yyloc));
15908#line 15909 "parse.c"
15912#line 5450 "parse.y"
15914 (yyval.node) = new_hash_pattern(p, 0, (yyvsp[0].node), &(yyloc));
15917#line 15918 "parse.c"
15921#line 5460 "parse.y"
15923 NODE *n = NEW_LIST((yyvsp[-2].node), &(yyloc));
15924 n = list_append(p, n, (yyvsp[0].node));
15925 (yyval.node) = new_hash(p, n, &(yyloc));
15928#line 15929 "parse.c"
15932#line 5470 "parse.y"
15934 (yyval.node) = NEW_OR((yyvsp[-2].node), (yyvsp[0].node), &(yyloc), &(yylsp[-1]));
15937#line 15938 "parse.c"
15941#line 5478 "parse.y"
15943 (yyval.tbl) = (yyvsp[0].tbl);
15946#line 15947 "parse.c"
15950#line 5485 "parse.y"
15952 (yyval.tbl) = (yyvsp[0].tbl);
15955#line 15956 "parse.c"
15959#line 5494 "parse.y"
15961 pop_pktbl(p, (yyvsp[-2].tbl));
15962 (yyval.node) = new_array_pattern(p, (yyvsp[-3].node), 0, (yyvsp[-1].node), &(yyloc));
15963 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
15966#line 15967 "parse.c"
15970#line 5501 "parse.y"
15972 pop_pktbl(p, (yyvsp[-2].tbl));
15973 (yyval.node) = new_find_pattern(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
15974 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
15977#line 15978 "parse.c"
15981#line 5508 "parse.y"
15983 pop_pktbl(p, (yyvsp[-2].tbl));
15984 (yyval.node) = new_hash_pattern(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
15985 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
15988#line 15989 "parse.c"
15992#line 5515 "parse.y"
15994 (yyval.node) = new_array_pattern_tail(p, 0, 0, 0, 0, &(yyloc));
15995 (yyval.node) = new_array_pattern(p, (yyvsp[-2].node), 0, (yyval.node), &(yyloc));
15998#line 15999 "parse.c"
16002#line 5521 "parse.y"
16004 pop_pktbl(p, (yyvsp[-2].tbl));
16005 (yyval.node) = new_array_pattern(p, (yyvsp[-3].node), 0, (yyvsp[-1].node), &(yyloc));
16006 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
16009#line 16010 "parse.c"
16013#line 5528 "parse.y"
16015 pop_pktbl(p, (yyvsp[-2].tbl));
16016 (yyval.node) = new_find_pattern(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
16017 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
16020#line 16021 "parse.c"
16024#line 5535 "parse.y"
16026 pop_pktbl(p, (yyvsp[-2].tbl));
16027 (yyval.node) = new_hash_pattern(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
16028 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
16031#line 16032 "parse.c"
16035#line 5542 "parse.y"
16037 (yyval.node) = new_array_pattern_tail(p, 0, 0, 0, 0, &(yyloc));
16038 (yyval.node) = new_array_pattern(p, (yyvsp[-2].node), 0, (yyval.node), &(yyloc));
16041#line 16042 "parse.c"
16045#line 5548 "parse.y"
16047 (yyval.node) = new_array_pattern(p, 0, 0, (yyvsp[-1].node), &(yyloc));
16050#line 16051 "parse.c"
16054#line 5553 "parse.y"
16056 (yyval.node) = new_find_pattern(p, 0, (yyvsp[-1].node), &(yyloc));
16059#line 16060 "parse.c"
16063#line 5558 "parse.y"
16065 (yyval.node) = new_array_pattern_tail(p, 0, 0, 0, 0, &(yyloc));
16066 (yyval.node) = new_array_pattern(p, 0, 0, (yyval.node), &(yyloc));
16069#line 16070 "parse.c"
16073#line 5564 "parse.y"
16075 p->ctxt.in_kwarg = 0;
16077#line 16078 "parse.c"
16081#line 5568 "parse.y"
16083 pop_pktbl(p, (yyvsp[-4].tbl));
16084 p->ctxt.in_kwarg = (yyvsp[-3].ctxt).in_kwarg;
16085 (yyval.node) = new_hash_pattern(p, 0, (yyvsp[-1].node), &(yyloc));
16088#line 16089 "parse.c"
16092#line 5575 "parse.y"
16094 (yyval.node) = new_hash_pattern_tail(p, 0, 0, &(yyloc));
16095 (yyval.node) = new_hash_pattern(p, 0, (yyval.node), &(yyloc));
16098#line 16099 "parse.c"
16102#line 5581 "parse.y"
16104 pop_pktbl(p, (yyvsp[-2].tbl));
16105 (yyval.node) = (yyvsp[-1].node);
16108#line 16109 "parse.c"
16112#line 5589 "parse.y"
16114 NODE *pre_args = NEW_LIST((yyvsp[0].node), &(yyloc));
16115 (yyval.node) = new_array_pattern_tail(p, pre_args, 0, 0, 0, &(yyloc));
16118#line 16119 "parse.c"
16122#line 5595 "parse.y"
16124 (yyval.node) = new_array_pattern_tail(p, (yyvsp[0].node), 1, 0, 0, &(yyloc));
16127#line 16128 "parse.c"
16131#line 5600 "parse.y"
16133 (yyval.node) = new_array_pattern_tail(p, list_concat((yyvsp[-1].node), (yyvsp[0].node)), 0, 0, 0, &(yyloc));
16136#line 16137 "parse.c"
16140#line 5605 "parse.y"
16142 (yyval.node) = new_array_pattern_tail(p, (yyvsp[-1].node), 1, (yyvsp[0].node), 0, &(yyloc));
16145#line 16146 "parse.c"
16149#line 5610 "parse.y"
16151 (yyval.node) = new_array_pattern_tail(p, (yyvsp[-3].node), 1, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
16154#line 16155 "parse.c"
16158#line 5619 "parse.y"
16160 (yyval.node) = list_concat((yyvsp[-2].node), (yyvsp[-1].node));
16163#line 16164 "parse.c"
16167#line 5626 "parse.y"
16169 (yyval.node) = new_array_pattern_tail(p, 0, 1, (yyvsp[0].node), 0, &(yyloc));
16172#line 16173 "parse.c"
16176#line 5631 "parse.y"
16178 (yyval.node) = new_array_pattern_tail(p, 0, 1, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
16181#line 16182 "parse.c"
16185#line 5638 "parse.y"
16187 (yyval.node) = new_find_pattern_tail(p, (yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
16190#line 16191 "parse.c"
16194#line 5646 "parse.y"
16196 error_duplicate_pattern_variable(p, (yyvsp[0].
id), &(yylsp[0]));
16198 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
16200#line 16201 "parse.c"
16204#line 5652 "parse.y"
16209#line 16210 "parse.c"
16213#line 5660 "parse.y"
16215 (yyval.node) = list_concat((yyvsp[-2].node), (yyvsp[0].node));
16218#line 16219 "parse.c"
16222#line 5667 "parse.y"
16224 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
16227#line 16228 "parse.c"
16231#line 5674 "parse.y"
16233 (yyval.node) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-2].node), &(yyloc)), (yyvsp[0].id), &(yyloc));
16236#line 16237 "parse.c"
16240#line 5679 "parse.y"
16242 (yyval.node) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[0].node), &(yyloc)), 0, &(yyloc));
16245#line 16246 "parse.c"
16249#line 5684 "parse.y"
16251 (yyval.node) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-1].node), &(yyloc)), 0, &(yyloc));
16254#line 16255 "parse.c"
16258#line 5689 "parse.y"
16260 (yyval.node) = new_hash_pattern_tail(p, new_hash(p, 0, &(yyloc)), (yyvsp[0].
id), &(yyloc));
16263#line 16264 "parse.c"
16267#line 5698 "parse.y"
16269 (yyval.node) = list_concat((yyvsp[-2].node), (yyvsp[0].node));
16272#line 16273 "parse.c"
16276#line 5705 "parse.y"
16278 error_duplicate_pattern_key(p, (yyvsp[-1].
id), &(yylsp[-1]));
16279 (yyval.node) = list_append(p, NEW_LIST(NEW_SYM(rb_id2str((yyvsp[-1].
id)), &(yylsp[-1])), &(yyloc)), (yyvsp[0].node));
16282#line 16283 "parse.c"
16286#line 5711 "parse.y"
16288 error_duplicate_pattern_key(p, (yyvsp[0].
id), &(yylsp[0]));
16289 if ((yyvsp[0].
id) && !is_local_id((yyvsp[0].
id))) {
16290 yyerror1(&(yylsp[0]),
"key must be valid as local variables");
16292 error_duplicate_pattern_variable(p, (yyvsp[0].
id), &(yylsp[0]));
16293 (yyval.node) = list_append(p, NEW_LIST(NEW_SYM(rb_id2str((yyvsp[0].
id)), &(yyloc)), &(yyloc)), assignable(p, (yyvsp[0].
id), 0, &(yyloc)));
16296#line 16297 "parse.c"
16300#line 5724 "parse.y"
16302 YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
16303 if (!(yyvsp[-1].node) || nd_type_p((yyvsp[-1].node), NODE_STR)) {
16304 NODE *node = dsym_node(p, (yyvsp[-1].node), &loc);
16305 (yyval.id) =
rb_sym2id(rb_node_sym_string_val(node));
16308 yyerror1(&loc,
"symbol literal with interpolation is not allowed");
16309 (yyval.id) = rb_intern_str(STR_NEW0());
16313#line 16314 "parse.c"
16317#line 5739 "parse.y"
16319 (yyval.id) = (yyvsp[0].
id);
16322#line 16323 "parse.c"
16326#line 5744 "parse.y"
16331#line 16332 "parse.c"
16335#line 5751 "parse.y"
16339#line 16340 "parse.c"
16343#line 5758 "parse.y"
16345 (yyval.id) = idNil;
16348#line 16349 "parse.c"
16352#line 3103 "parse.y"
16354 value_expr((yyvsp[-2].node));
16355 value_expr((yyvsp[0].node));
16356 (yyval.node) = NEW_DOT2((yyvsp[-2].node), (yyvsp[0].node), &(yyloc), &(yylsp[-1]));
16359#line 16360 "parse.c"
16363#line 3110 "parse.y"
16365 value_expr((yyvsp[-2].node));
16366 value_expr((yyvsp[0].node));
16367 (yyval.node) = NEW_DOT3((yyvsp[-2].node), (yyvsp[0].node), &(yyloc), &(yylsp[-1]));
16370#line 16371 "parse.c"
16374#line 3117 "parse.y"
16376 value_expr((yyvsp[-1].node));
16377 (yyval.node) = NEW_DOT2((yyvsp[-1].node), new_nil_at(p, &(yylsp[0]).end_pos), &(yyloc), &(yylsp[0]));
16380#line 16381 "parse.c"
16384#line 3123 "parse.y"
16386 value_expr((yyvsp[-1].node));
16387 (yyval.node) = NEW_DOT3((yyvsp[-1].node), new_nil_at(p, &(yylsp[0]).end_pos), &(yyloc), &(yylsp[0]));
16390#line 16391 "parse.c"
16394#line 3129 "parse.y"
16396 value_expr((yyvsp[0].node));
16397 (yyval.node) = NEW_DOT2(new_nil_at(p, &(yylsp[-1]).beg_pos), (yyvsp[0].node), &(yyloc), &(yylsp[-1]));
16400#line 16401 "parse.c"
16404#line 3135 "parse.y"
16406 value_expr((yyvsp[0].node));
16407 (yyval.node) = NEW_DOT3(new_nil_at(p, &(yylsp[-1]).beg_pos), (yyvsp[0].node), &(yyloc), &(yylsp[-1]));
16410#line 16411 "parse.c"
16414#line 5773 "parse.y"
16416 if (!((yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc)))) (yyval.node) = NEW_ERROR(&(yyloc));
16419#line 16420 "parse.c"
16423#line 5781 "parse.y"
16425 error_duplicate_pattern_variable(p, (yyvsp[0].
id), &(yylsp[0]));
16427 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
16429#line 16430 "parse.c"
16433#line 5789 "parse.y"
16435 NODE *n = gettable(p, (yyvsp[0].
id), &(yyloc));
16437 n = NEW_ERROR(&(yyloc));
16439 else if (!(nd_type_p(n, NODE_LVAR) || nd_type_p(n, NODE_DVAR))) {
16440 compile_error(p,
"%"PRIsVALUE
": no such local variable", rb_id2str((yyvsp[0].
id)));
16445#line 16446 "parse.c"
16449#line 5801 "parse.y"
16451 if (!((yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc)))) (yyval.node) = NEW_ERROR(&(yyloc));
16454#line 16455 "parse.c"
16458#line 5808 "parse.y"
16460 (yyval.node) = NEW_BLOCK((yyvsp[-1].node), &(yyloc));
16463#line 16464 "parse.c"
16467#line 5815 "parse.y"
16469 (yyval.node) = NEW_COLON3((yyvsp[0].
id), &(yyloc), &(yylsp[-1]), &(yylsp[0]));
16472#line 16473 "parse.c"
16476#line 5820 "parse.y"
16478 (yyval.node) = NEW_COLON2((yyvsp[-2].node), (yyvsp[0].id), &(yyloc), &(yylsp[-1]), &(yylsp[0]));
16481#line 16482 "parse.c"
16485#line 5825 "parse.y"
16487 (yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc));
16490#line 16491 "parse.c"
16494#line 5834 "parse.y"
16496 NODE *err = (yyvsp[-3].node);
16497 if ((yyvsp[-3].node)) {
16498 err = NEW_ERRINFO(&(yylsp[-3]));
16499 err = node_assign(p, (yyvsp[-3].node), err, NO_LEX_CTXT, &(yylsp[-3]));
16501 (yyval.node) = NEW_RESBODY((yyvsp[-4].node), (yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
16502 if ((yyvsp[-4].node)) {
16503 fixpos((yyval.node), (yyvsp[-4].node));
16505 else if ((yyvsp[-3].node)) {
16506 fixpos((yyval.node), (yyvsp[-3].node));
16509 fixpos((yyval.node), (yyvsp[-1].node));
16513#line 16514 "parse.c"
16517#line 5856 "parse.y"
16519 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
16522#line 16523 "parse.c"
16526#line 5861 "parse.y"
16528 if (!((yyval.node) = splat_array((yyvsp[0].node)))) (yyval.node) = (yyvsp[0].node);
16530#line 16531 "parse.c"
16534#line 5868 "parse.y"
16536 (yyval.node) = (yyvsp[0].node);
16539#line 16540 "parse.c"
16543#line 5876 "parse.y"
16545 p->ctxt.in_rescue = (yyvsp[-2].ctxt).in_rescue;
16546 (yyval.node) = (yyvsp[-1].node);
16547 void_expr(p, void_stmts(p, (yyval.node)));
16550#line 16551 "parse.c"
16554#line 5890 "parse.y"
16556 if (!(yyvsp[0].node)) {
16557 (yyval.node) = NEW_STR(STRING_NEW0(), &(yyloc));
16559 (yyval.node) = evstr2dstr(p, (yyvsp[0].node));
16563#line 16564 "parse.c"
16567#line 5903 "parse.y"
16569 (yyval.node) = literal_concat(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
16572#line 16573 "parse.c"
16576#line 5910 "parse.y"
16578 (yyval.node) = heredoc_dedent(p, (yyvsp[-1].node));
16579 if ((yyval.node)) nd_set_loc((yyval.node), &(yyloc));
16581 if (p->heredoc_indent > 0) {
16583 p->heredoc_indent = 0;
16587#line 16588 "parse.c"
16591#line 5923 "parse.y"
16593 (yyval.node) = new_xstring(p, heredoc_dedent(p, (yyvsp[-1].node)), &(yyloc));
16595 if (p->heredoc_indent > 0) {
16597 p->heredoc_indent = 0;
16601#line 16602 "parse.c"
16605#line 5935 "parse.y"
16607 (yyval.node) = new_regexp(p, (yyvsp[-1].node), (yyvsp[0].num), &(yyloc), &(yylsp[-2]), &(yylsp[-1]), &(yylsp[0]));
16610#line 16611 "parse.c"
16614#line 3152 "parse.y"
16616 (yyval.node) = make_list((yyvsp[-1].node), &(yyloc));
16619#line 16620 "parse.c"
16623#line 5945 "parse.y"
16628#line 16629 "parse.c"
16632#line 5950 "parse.y"
16634 (yyval.node) = list_append(p, (yyvsp[-2].node), evstr2dstr(p, (yyvsp[-1].node)));
16637#line 16638 "parse.c"
16641#line 5959 "parse.y"
16643 (yyval.node) = literal_concat(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
16646#line 16647 "parse.c"
16650#line 3152 "parse.y"
16652 (yyval.node) = make_list((yyvsp[-1].node), &(yyloc));
16655#line 16656 "parse.c"
16659#line 5969 "parse.y"
16664#line 16665 "parse.c"
16668#line 5974 "parse.y"
16670 (yyval.node) = symbol_append(p, (yyvsp[-2].node), evstr2dstr(p, (yyvsp[-1].node)));
16673#line 16674 "parse.c"
16677#line 3152 "parse.y"
16679 (yyval.node) = make_list((yyvsp[-1].node), &(yyloc));
16682#line 16683 "parse.c"
16686#line 3152 "parse.y"
16688 (yyval.node) = make_list((yyvsp[-1].node), &(yyloc));
16691#line 16692 "parse.c"
16695#line 5987 "parse.y"
16700#line 16701 "parse.c"
16704#line 5992 "parse.y"
16706 (yyval.node) = list_append(p, (yyvsp[-2].node), (yyvsp[-1].node));
16709#line 16710 "parse.c"
16713#line 5999 "parse.y"
16718#line 16719 "parse.c"
16722#line 6004 "parse.y"
16724 (yyval.node) = symbol_append(p, (yyvsp[-2].node), (yyvsp[-1].node));
16727#line 16728 "parse.c"
16731#line 6011 "parse.y"
16736#line 16737 "parse.c"
16740#line 6016 "parse.y"
16742 (yyval.node) = literal_concat(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
16745#line 16746 "parse.c"
16749#line 6023 "parse.y"
16754#line 16755 "parse.c"
16758#line 6028 "parse.y"
16760 (yyval.node) = literal_concat(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
16763#line 16764 "parse.c"
16767#line 6035 "parse.y"
16772#line 16773 "parse.c"
16776#line 6040 "parse.y"
16778 NODE *head = (yyvsp[-1].node), *tail = (yyvsp[0].node);
16780 (yyval.node) = tail;
16783 (yyval.node) = head;
16786 switch (nd_type(head)) {
16788 head = str2dstr(p, head);
16793 head = list_append(p, NEW_DSTR(0, &(yyloc)), head);
16796 (yyval.node) = list_append(p, head, tail);
16800#line 16801 "parse.c"
16804#line 6068 "parse.y"
16807 (yyval.strterm) = p->lex.strterm;
16808 p->lex.strterm = 0;
16809 SET_LEX_STATE(EXPR_BEG);
16811#line 16812 "parse.c"
16815#line 6075 "parse.y"
16817 p->lex.strterm = (yyvsp[-1].strterm);
16818 (yyval.node) = NEW_EVSTR((yyvsp[0].node), &(yyloc), &(yylsp[-2]), &NULL_LOC);
16819 nd_set_line((yyval.node), (yylsp[0]).end_pos.lineno);
16822#line 16823 "parse.c"
16826#line 6082 "parse.y"
16831 (yyval.strterm) = p->lex.strterm;
16832 p->lex.strterm = 0;
16833 SET_LEX_STATE(EXPR_BEG);
16835#line 16836 "parse.c"
16839#line 6090 "parse.y"
16841 (yyval.num) = p->lex.brace_nest;
16842 p->lex.brace_nest = 0;
16844#line 16845 "parse.c"
16848#line 6094 "parse.y"
16850 (yyval.num) = p->heredoc_indent;
16851 p->heredoc_indent = 0;
16853#line 16854 "parse.c"
16857#line 6099 "parse.y"
16861 p->lex.strterm = (yyvsp[-4].strterm);
16862 SET_LEX_STATE((yyvsp[-5].state));
16863 p->lex.brace_nest = (yyvsp[-3].num);
16864 p->heredoc_indent = (yyvsp[-2].num);
16865 p->heredoc_line_indent = -1;
16866 if ((yyvsp[-1].node)) nd_unset_fl_newline((yyvsp[-1].node));
16867 (yyval.node) = new_evstr(p, (yyvsp[-1].node), &(yyloc), &(yylsp[-5]), &(yylsp[0]));
16870#line 16871 "parse.c"
16874#line 6118 "parse.y"
16876 if (!((yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc)))) (yyval.node) = NEW_ERROR(&(yyloc));
16879#line 16880 "parse.c"
16883#line 6130 "parse.y"
16885 SET_LEX_STATE(EXPR_END);
16886 VALUE str = rb_id2str((yyvsp[0].
id));
16893 if (!str) str = STR_NEW0();
16894 (yyval.node) = NEW_SYM(str, &(yyloc));
16897#line 16898 "parse.c"
16901#line 6150 "parse.y"
16903 SET_LEX_STATE(EXPR_END);
16904 (yyval.node) = dsym_node(p, (yyvsp[-1].node), &(yyloc));
16907#line 16908 "parse.c"
16911#line 6159 "parse.y"
16913 (yyval.node) = (yyvsp[0].node);
16914 negate_lit(p, (yyval.node));
16917#line 16918 "parse.c"
16921#line 6181 "parse.y"
16922 {(yyval.id) = KWD2EID(nil, (yyvsp[0].
id));}
16923#line 16924 "parse.c"
16927#line 6182 "parse.y"
16928 {(yyval.id) = KWD2EID(self, (yyvsp[0].
id));}
16929#line 16930 "parse.c"
16933#line 6183 "parse.y"
16934 {(yyval.id) = KWD2EID(
true, (yyvsp[0].
id));}
16935#line 16936 "parse.c"
16939#line 6184 "parse.y"
16940 {(yyval.id) = KWD2EID(
false, (yyvsp[0].
id));}
16941#line 16942 "parse.c"
16945#line 6185 "parse.y"
16946 {(yyval.id) = KWD2EID(_FILE__, (yyvsp[0].
id));}
16947#line 16948 "parse.c"
16951#line 6186 "parse.y"
16952 {(yyval.id) = KWD2EID(_LINE__, (yyvsp[0].
id));}
16953#line 16954 "parse.c"
16957#line 6187 "parse.y"
16958 {(yyval.id) = KWD2EID(_ENCODING__, (yyvsp[0].
id));}
16959#line 16960 "parse.c"
16963#line 6191 "parse.y"
16965 if (!((yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc)))) (yyval.node) = NEW_ERROR(&(yyloc));
16966 if (ifdef_ripper(id_is_var(p, (yyvsp[0].
id)),
false)) {
16973#line 16974 "parse.c"
16977#line 6201 "parse.y"
16979 if (!((yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc)))) (yyval.node) = NEW_ERROR(&(yyloc));
16982#line 16983 "parse.c"
16986#line 6208 "parse.y"
16989 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
16991#line 16992 "parse.c"
16995#line 6208 "parse.y"
16998 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
17000#line 17001 "parse.c"
17004#line 6219 "parse.y"
17006 SET_LEX_STATE(EXPR_BEG);
17007 p->command_start = TRUE;
17009#line 17010 "parse.c"
17013#line 6224 "parse.y"
17015 (yyval.node) = (yyvsp[-1].node);
17018#line 17019 "parse.c"
17022#line 6233 "parse.y"
17024 p->ctxt.in_argdef = 0;
17025 (yyval.node_args) = new_args_tail(p, 0, 0, 0, &(yylsp[-1]));
17026 (yyval.node_args) = new_args(p, 0, 0, 0, 0, (yyval.node_args), &(yylsp[-1]));
17029#line 17030 "parse.c"
17033#line 6242 "parse.y"
17035 (yyval.node_args) = (yyvsp[-1].node_args);
17037 SET_LEX_STATE(EXPR_BEG);
17038 p->command_start = TRUE;
17039 p->ctxt.in_argdef = 0;
17041#line 17042 "parse.c"
17045#line 6252 "parse.y"
17047 (yyval.ctxt) = p->ctxt;
17048 p->ctxt.in_kwarg = 1;
17049 p->ctxt.in_argdef = 1;
17050 SET_LEX_STATE(p->lex.state|EXPR_LABEL);
17052#line 17053 "parse.c"
17056#line 6259 "parse.y"
17058 p->ctxt.in_kwarg = (yyvsp[-2].ctxt).in_kwarg;
17059 p->ctxt.in_argdef = 0;
17060 (yyval.node_args) = (yyvsp[-1].node_args);
17061 SET_LEX_STATE(EXPR_BEG);
17062 p->command_start = TRUE;
17065#line 17066 "parse.c"
17069#line 3003 "parse.y"
17071 p->ctxt.in_argdef = 1;
17072 (yyval.node_kw_arg) = new_kw_arg(p, assignable(p, (yyvsp[-1].
id), (yyvsp[0].node), &(yyloc)), &(yyloc));
17075#line 17076 "parse.c"
17079#line 3009 "parse.y"
17081 p->ctxt.in_argdef = 1;
17082 (yyval.node_kw_arg) = new_kw_arg(p, assignable(p, (yyvsp[0].
id), NODE_SPECIAL_REQUIRED_KEYWORD, &(yyloc)), &(yyloc));
17085#line 17086 "parse.c"
17089#line 3018 "parse.y"
17091 (yyval.node_kw_arg) = (yyvsp[0].node_kw_arg);
17094#line 17095 "parse.c"
17098#line 3023 "parse.y"
17100 (yyval.node_kw_arg) = kwd_append((yyvsp[-2].node_kw_arg), (yyvsp[0].node_kw_arg));
17103#line 17104 "parse.c"
17107#line 2927 "parse.y"
17109 (yyval.node_args) = new_args_tail(p, (yyvsp[-3].node_kw_arg), (yyvsp[-1].id), (yyvsp[0].
id), &(yylsp[-1]));
17112#line 17113 "parse.c"
17116#line 2932 "parse.y"
17118 (yyval.node_args) = new_args_tail(p, (yyvsp[-1].node_kw_arg), 0, (yyvsp[0].id), &(yylsp[-1]));
17121#line 17122 "parse.c"
17125#line 2937 "parse.y"
17127 (yyval.node_args) = new_args_tail(p, 0, (yyvsp[-1].
id), (yyvsp[0].id), &(yylsp[-1]));
17130#line 17131 "parse.c"
17134#line 2942 "parse.y"
17136 (yyval.node_args) = new_args_tail(p, 0, 0, (yyvsp[0].
id), &(yylsp[0]));
17139#line 17140 "parse.c"
17143#line 6271 "parse.y"
17145 ID fwd = (yyvsp[0].id);
17146 if (lambda_beginning_p() ||
17147 (p->lex.lpar_beg >= 0 && p->lex.lpar_beg+1 == p->lex.paren_nest)) {
17148 yyerror0(
"unexpected ... in lambda argument");
17152 add_forwarding_args(p);
17154 (yyval.node_args) = new_args_tail(p, 0, fwd, arg_FWD_BLOCK, &(yylsp[0]));
17155 (yyval.node_args)->nd_ainfo.forwarding = 1;
17158#line 17159 "parse.c"
17162#line 2981 "parse.y"
17164 p->ctxt.in_argdef = 1;
17165 (yyval.node_opt_arg) = NEW_OPT_ARG(assignable(p, (yyvsp[-2].
id), (yyvsp[0].node), &(yyloc)), &(yyloc));
17168#line 17169 "parse.c"
17172#line 2990 "parse.y"
17174 (yyval.node_opt_arg) = (yyvsp[0].node_opt_arg);
17177#line 17178 "parse.c"
17181#line 2995 "parse.y"
17183 (yyval.node_opt_arg) = opt_arg_append((yyvsp[-2].node_opt_arg), (yyvsp[0].node_opt_arg));
17186#line 17187 "parse.c"
17190#line 3090 "parse.y"
17192 (yyval.node_args) = (yyvsp[0].node_args);
17195#line 17196 "parse.c"
17199#line 3095 "parse.y"
17201 (yyval.node_args) = new_args_tail(p, 0, 0, 0, &(yylsp[0]));
17204#line 17205 "parse.c"
17208#line 6288 "parse.y"
17210 (yyval.node_args) = new_args(p, (yyvsp[-5].node_args_aux), (yyvsp[-3].node_opt_arg), (yyvsp[-1].
id), 0, (yyvsp[0].node_args), &(yyloc));
17213#line 17214 "parse.c"
17217#line 6293 "parse.y"
17219 (yyval.node_args) = new_args(p, (yyvsp[-7].node_args_aux), (yyvsp[-5].node_opt_arg), (yyvsp[-3].
id), (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
17222#line 17223 "parse.c"
17226#line 6298 "parse.y"
17228 (yyval.node_args) = new_args(p, (yyvsp[-3].node_args_aux), (yyvsp[-1].node_opt_arg), 0, 0, (yyvsp[0].node_args), &(yyloc));
17231#line 17232 "parse.c"
17235#line 6303 "parse.y"
17237 (yyval.node_args) = new_args(p, (yyvsp[-5].node_args_aux), (yyvsp[-3].node_opt_arg), 0, (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
17240#line 17241 "parse.c"
17244#line 6308 "parse.y"
17246 (yyval.node_args) = new_args(p, (yyvsp[-3].node_args_aux), 0, (yyvsp[-1].id), 0, (yyvsp[0].node_args), &(yyloc));
17249#line 17250 "parse.c"
17253#line 6313 "parse.y"
17255 (yyval.node_args) = new_args(p, (yyvsp[-5].node_args_aux), 0, (yyvsp[-3].id), (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
17258#line 17259 "parse.c"
17262#line 6318 "parse.y"
17264 (yyval.node_args) = new_args(p, (yyvsp[-1].node_args_aux), 0, 0, 0, (yyvsp[0].node_args), &(yyloc));
17267#line 17268 "parse.c"
17271#line 6323 "parse.y"
17273 (yyval.node_args) = new_args(p, 0, (yyvsp[-3].node_opt_arg), (yyvsp[-1].id), 0, (yyvsp[0].node_args), &(yyloc));
17276#line 17277 "parse.c"
17280#line 6328 "parse.y"
17282 (yyval.node_args) = new_args(p, 0, (yyvsp[-5].node_opt_arg), (yyvsp[-3].id), (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
17285#line 17286 "parse.c"
17289#line 6333 "parse.y"
17291 (yyval.node_args) = new_args(p, 0, (yyvsp[-1].node_opt_arg), 0, 0, (yyvsp[0].node_args), &(yyloc));
17294#line 17295 "parse.c"
17298#line 6338 "parse.y"
17300 (yyval.node_args) = new_args(p, 0, (yyvsp[-3].node_opt_arg), 0, (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
17303#line 17304 "parse.c"
17307#line 6343 "parse.y"
17309 (yyval.node_args) = new_args(p, 0, 0, (yyvsp[-1].
id), 0, (yyvsp[0].node_args), &(yyloc));
17312#line 17313 "parse.c"
17316#line 6348 "parse.y"
17318 (yyval.node_args) = new_args(p, 0, 0, (yyvsp[-3].
id), (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
17321#line 17322 "parse.c"
17325#line 6353 "parse.y"
17327 (yyval.node_args) = new_args(p, 0, 0, 0, 0, (yyvsp[0].node_args), &(yyloc));
17330#line 17331 "parse.c"
17334#line 6358 "parse.y"
17336 (yyval.node_args) = new_args_tail(p, 0, 0, 0, &(yylsp[0]));
17337 (yyval.node_args) = new_args(p, 0, 0, 0, 0, (yyval.node_args), &(yylsp[0]));
17340#line 17341 "parse.c"
17344#line 6366 "parse.y"
17346#ifdef FORWARD_ARGS_WITH_RUBY2_KEYWORDS
17349 (yyval.id) = idFWD_KWREST;
17353#line 17354 "parse.c"
17357#line 6377 "parse.y"
17359 static const char mesg[] =
"formal argument cannot be a constant";
17361 yyerror1(&(yylsp[0]), mesg);
17366#line 17367 "parse.c"
17370#line 6386 "parse.y"
17372 static const char mesg[] =
"formal argument cannot be an instance variable";
17374 yyerror1(&(yylsp[0]), mesg);
17379#line 17380 "parse.c"
17383#line 6395 "parse.y"
17385 static const char mesg[] =
"formal argument cannot be a global variable";
17387 yyerror1(&(yylsp[0]), mesg);
17392#line 17393 "parse.c"
17396#line 6404 "parse.y"
17398 static const char mesg[] =
"formal argument cannot be a class variable";
17400 yyerror1(&(yylsp[0]), mesg);
17405#line 17406 "parse.c"
17409#line 6416 "parse.y"
17411 VALUE e = formal_argument_error(p, (yyval.id) = (yyvsp[0].id));
17415 p->max_numparam = ORDINAL_PARAM;
17417#line 17418 "parse.c"
17421#line 6426 "parse.y"
17423 arg_var(p, (yyvsp[0].
id));
17424 (yyval.id) = (yyvsp[0].
id);
17426#line 17427 "parse.c"
17430#line 6433 "parse.y"
17432 (yyval.node_args_aux) = NEW_ARGS_AUX((yyvsp[0].
id), 1, &NULL_LOC);
17435#line 17436 "parse.c"
17439#line 6438 "parse.y"
17441 ID tid = internal_id(p);
17443 loc.beg_pos = (yylsp[-1]).beg_pos;
17444 loc.end_pos = (yylsp[-1]).beg_pos;
17446 if (dyna_in_block(p)) {
17447 (yyvsp[-1].node_masgn)->nd_value = NEW_DVAR(tid, &loc);
17450 (yyvsp[-1].node_masgn)->nd_value = NEW_LVAR(tid, &loc);
17452 (yyval.node_args_aux) = NEW_ARGS_AUX(tid, 1, &NULL_LOC);
17453 (yyval.node_args_aux)->nd_next = (
NODE *)(yyvsp[-1].node_masgn);
17456#line 17457 "parse.c"
17460#line 6459 "parse.y"
17462 (yyval.node_args_aux) = (yyvsp[-2].node_args_aux);
17463 (yyval.node_args_aux)->nd_plen++;
17464 (yyval.node_args_aux)->nd_next = block_append(p, (yyval.node_args_aux)->nd_next, (yyvsp[0].node_args_aux)->nd_next);
17465 rb_discard_node(p, (
NODE *)(yyvsp[0].node_args_aux));
17468#line 17469 "parse.c"
17472#line 6470 "parse.y"
17474 VALUE e = formal_argument_error(p, (yyval.id) = (yyvsp[0].id));
17485 arg_var(p, ifdef_ripper(0, (yyvsp[0].
id)));
17487 p->max_numparam = ORDINAL_PARAM;
17488 p->ctxt.in_argdef = 0;
17490#line 17491 "parse.c"
17494#line 6494 "parse.y"
17498#line 17499 "parse.c"
17502#line 6500 "parse.y"
17504 arg_var(p, shadowing_lvar(p, (yyvsp[0].
id)));
17505 (yyval.id) = (yyvsp[0].
id);
17508#line 17509 "parse.c"
17512#line 6506 "parse.y"
17514 arg_var(p, idFWD_KWREST);
17515 (yyval.id) = idFWD_KWREST;
17518#line 17519 "parse.c"
17522#line 6518 "parse.y"
17524 arg_var(p, shadowing_lvar(p, (yyvsp[0].
id)));
17525 (yyval.id) = (yyvsp[0].
id);
17528#line 17529 "parse.c"
17532#line 6524 "parse.y"
17534 arg_var(p, idFWD_REST);
17535 (yyval.id) = idFWD_REST;
17538#line 17539 "parse.c"
17542#line 6536 "parse.y"
17544 arg_var(p, shadowing_lvar(p, (yyvsp[0].
id)));
17545 (yyval.id) = (yyvsp[0].
id);
17548#line 17549 "parse.c"
17552#line 6542 "parse.y"
17554 arg_var(p, idFWD_BLOCK);
17555 (yyval.id) = idFWD_BLOCK;
17558#line 17559 "parse.c"
17562#line 6550 "parse.y"
17564 (yyval.id) = (yyvsp[0].
id);
17567#line 17568 "parse.c"
17571#line 3144 "parse.y"
17573 value_expr((yyvsp[0].node));
17574 (yyval.node) = (yyvsp[0].node);
17576#line 17577 "parse.c"
17580#line 6559 "parse.y"
17582 NODE *expr = last_expr_node((yyvsp[0].node));
17583 switch (nd_type(expr)) {
17593 case NODE_ENCODING:
17596 case NODE_RATIONAL:
17597 case NODE_IMAGINARY:
17601 yyerror1(&expr->nd_loc,
"can't define singleton method for literals");
17606 (yyval.node) = (yyvsp[0].node);
17608#line 17609 "parse.c"
17612#line 6590 "parse.y"
17614 SET_LEX_STATE(EXPR_BEG);
17615 p->ctxt.in_argdef = 0;
17617#line 17618 "parse.c"
17621#line 6595 "parse.y"
17623 p->ctxt.in_argdef = 1;
17624 (yyval.node) = (yyvsp[-1].node);
17627#line 17628 "parse.c"
17631#line 6604 "parse.y"
17633 (yyval.node) = (yyvsp[-1].node);
17636#line 17637 "parse.c"
17640#line 6613 "parse.y"
17642 NODE *assocs = (yyvsp[-2].node);
17643 NODE *tail = (yyvsp[0].node);
17648 if (RNODE_LIST(assocs)->nd_head) {
17649 NODE *n = RNODE_LIST(tail)->nd_next;
17650 if (!RNODE_LIST(tail)->nd_head && nd_type_p(n, NODE_LIST) &&
17651 nd_type_p((n = RNODE_LIST(n)->nd_head), NODE_HASH)) {
17653 tail = RNODE_HASH(n)->nd_head;
17657 assocs = list_concat(assocs, tail);
17660 (yyval.node) = assocs;
17663#line 17664 "parse.c"
17667#line 6638 "parse.y"
17669 (yyval.node) = list_append(p, NEW_LIST((yyvsp[-2].node), &(yyloc)), (yyvsp[0].node));
17672#line 17673 "parse.c"
17676#line 6643 "parse.y"
17678 (yyval.node) = list_append(p, NEW_LIST(NEW_SYM(rb_id2str((yyvsp[-1].
id)), &(yylsp[-1])), &(yyloc)), (yyvsp[0].node));
17681#line 17682 "parse.c"
17685#line 6648 "parse.y"
17687 NODE *val = gettable(p, (yyvsp[0].
id), &(yyloc));
17688 if (!val) val = NEW_ERROR(&(yyloc));
17689 (yyval.node) = list_append(p, NEW_LIST(NEW_SYM(rb_id2str((yyvsp[0].
id)), &(yylsp[0])), &(yyloc)), val);
17692#line 17693 "parse.c"
17696#line 6655 "parse.y"
17698 YYLTYPE loc = code_loc_gen(&(yylsp[-3]), &(yylsp[-1]));
17699 (yyval.node) = list_append(p, NEW_LIST(dsym_node(p, (yyvsp[-2].node), &loc), &loc), (yyvsp[0].node));
17702#line 17703 "parse.c"
17706#line 6661 "parse.y"
17708 (yyval.node) = list_append(p, NEW_LIST(0, &(yyloc)), (yyvsp[0].node));
17711#line 17712 "parse.c"
17715#line 6666 "parse.y"
17717 forwarding_arg_check(p, idFWD_KWREST, idFWD_ALL,
"keyword rest");
17718 (yyval.node) = list_append(p, NEW_LIST(0, &(yyloc)),
17719 NEW_LVAR(idFWD_KWREST, &(yyloc)));
17722#line 17723 "parse.c"
17726#line 6713 "parse.y"
17730 if (p->ctxt.in_defined) {
17731 p->ctxt.has_trailing_semicolon = 1;
17734#line 17735 "parse.c"
17738#line 6721 "parse.y"
17740 (yyloc).end_pos = (yyloc).beg_pos;
17743#line 17744 "parse.c"
17747#line 6728 "parse.y"
17749#line 17750 "parse.c"
17753#line 6732 "parse.y"
17758#line 17759 "parse.c"
17762#line 17763 "parse.c"
17777 YY_SYMBOL_PRINT (
"-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc, p);
17779 YYPOPSTACK (yylen);
17781#line 2666 "parse.y"
17782 {after_reduce(yylen, p);}
17783#line 17784 "parse.c"
17794 const int yylhs = yyr1[yyn] - YYNTOKENS;
17795 const int yyi = yypgoto[yylhs] + *yyssp;
17796 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
17798 : yydefgoto[yylhs]);
17810 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
17817 = {yyssp, yytoken, &yylloc};
17818 char const *yymsgp = YY_(
"syntax error");
17819 int yysyntax_error_status;
17820 yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx, p);
17821 if (yysyntax_error_status == 0)
17823 else if (yysyntax_error_status == -1)
17825 if (yymsg != yymsgbuf)
17826 YYSTACK_FREE (yymsg);
17827 yymsg = YY_CAST (
char *,
17828 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
17831 yysyntax_error_status
17832 = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx, p);
17838 yymsg_alloc =
sizeof yymsgbuf;
17839 yysyntax_error_status = YYENOMEM;
17842 yyerror (&yylloc, p, yymsgp);
17843 if (yysyntax_error_status == YYENOMEM)
17848 yyerror_range[1] = yylloc;
17849 if (yyerrstatus == 3)
17854 if (yychar <= END_OF_INPUT)
17857 if (yychar == END_OF_INPUT)
17862 yydestruct (
"Error: discarding",
17863 yytoken, &yylval, &yylloc, p);
17885 YYPOPSTACK (yylen);
17887#line 2668 "parse.y"
17888 {after_pop_stack(yylen, p);}
17889#line 17890 "parse.c"
17892 YY_STACK_PRINT (yyss, yyssp, p);
17906 yyn = yypact[yystate];
17907 if (!yypact_value_is_default (yyn))
17909 yyn += YYSYMBOL_YYerror;
17910 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
17912 yyn = yytable[yyn];
17922 yyerror_range[1] = *yylsp;
17923 yydestruct (
"Error: popping",
17924 YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, p);
17927#line 2668 "parse.y"
17928 {after_pop_stack(1, p);}
17929#line 17930 "parse.c"
17932 YY_STACK_PRINT (yyss, yyssp, p);
17935 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
17937 YY_IGNORE_MAYBE_UNINITIALIZED_END
17939 yyerror_range[2] = yylloc;
17941 YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);
17944 YY_SYMBOL_PRINT (
"Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp, p);
17946#line 2667 "parse.y"
17947 {after_shift_error_token(p);}
17948#line 17949 "parse.c"
17975 yyerror (&yylloc, p, YY_(
"memory exhausted"));
17984 if (yychar != YYEMPTY)
17988 yytoken = YYTRANSLATE (yychar);
17989 yydestruct (
"Cleanup: discarding lookahead",
17990 yytoken, &yylval, &yylloc, p);
17994 YYPOPSTACK (yylen);
17995 YY_STACK_PRINT (yyss, yyssp, p);
17996 while (yyssp != yyss)
17998 yydestruct (
"Cleanup: popping",
17999 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, p);
18004 YYSTACK_FREE (yyss);
18006 if (yymsg != yymsgbuf)
18007 YYSTACK_FREE (yymsg);
18011#line 6737 "parse.y"
18016# define yylval (*p->lval)
18024#define set_parser_s_value(x) (ifdef_ripper(p->s_value = (x), (void)0))
18026# define set_yylval_node(x) { \
18027 YYLTYPE _cur_loc; \
18028 rb_parser_set_location(p, &_cur_loc); \
18029 yylval.node = (x); \
18030 set_parser_s_value(STR_NEW(p->lex.ptok, p->lex.pcur-p->lex.ptok)); \
18032# define set_yylval_str(x) \
18034 set_yylval_node(NEW_STR(x, &_cur_loc)); \
18035 set_parser_s_value(rb_str_new_mutable_parser_string(x)); \
18037# define set_yylval_num(x) { \
18038 yylval.num = (x); \
18039 set_parser_s_value(x); \
18041# define set_yylval_id(x) (yylval.id = (x))
18042# define set_yylval_name(x) { \
18043 (yylval.id = (x)); \
18044 set_parser_s_value(ID2SYM(x)); \
18046# define yylval_id() (yylval.id)
18048#define set_yylval_noname() set_yylval_id(keyword_nil)
18049#define has_delayed_token(p) (p->delayed.token != NULL)
18052#define literal_flush(p, ptr) ((p)->lex.ptok = (ptr))
18053#define dispatch_scan_event(p, t) parser_dispatch_scan_event(p, t, __LINE__)
18058 const char *
const pcur = p->lex.pcur;
18059 const char *
const ptok = p->lex.ptok;
18060 if (p->keep_tokens && (pcur < ptok)) {
18061 rb_bug(
"lex.pcur < lex.ptok. (line: %d) %"PRIdPTRDIFF
"|%"PRIdPTRDIFF
"|%"PRIdPTRDIFF
"",
18062 p->ruby_sourceline, ptok - p->lex.pbeg, pcur - ptok, p->lex.pend - pcur);
18064 return pcur > ptok;
18071 case '"':
return "\\\"";
18072 case '\\':
return "\\\\";
18073 case '\0':
return "\\0";
18074 case '\n':
return "\\n";
18075 case '\r':
return "\\r";
18076 case '\t':
return "\\t";
18077 case '\f':
return "\\f";
18078 case '\013':
return "\\v";
18079 case '\010':
return "\\b";
18080 case '\007':
return "\\a";
18081 case '\033':
return "\\e";
18082 case '\x7f':
return "\\c?";
18091 const char *ptr = str->ptr;
18092 const char *pend = ptr + str->len;
18093 const char *prev = ptr;
18094 char charbuf[5] = {
'\\',
'x', 0, 0, 0};
18097 while (ptr < pend) {
18100 int n = rb_enc_precise_mbclen(ptr, pend, enc);
18102 if (ptr > prev) parser_str_cat(result, prev, ptr - prev);
18103 n = rb_enc_mbminlen(enc);
18104 if (pend < ptr + n)
18105 n = (int)(pend - ptr);
18107 c = *ptr & 0xf0 >> 4;
18108 charbuf[2] = (c < 10) ?
'0' + c :
'A' + c - 10;
18110 charbuf[3] = (c < 10) ?
'0' + c :
'A' + c - 10;
18111 parser_str_cat(result, charbuf, 4);
18117 c = rb_enc_mbc_to_codepoint(ptr, pend, enc);
18119 cc = escaped_char(c);
18121 if (ptr - n > prev) parser_str_cat(result, prev, ptr - n - prev);
18122 parser_str_cat_cstr(result, cc);
18125 else if (rb_enc_isascii(c, enc) &&
ISPRINT(c)) {
18128 if (ptr - n > prev) {
18129 parser_str_cat(result, prev, ptr - n - prev);
18132 parser_str_cat(result, prev, ptr - prev);
18136 if (ptr > prev) parser_str_cat(result, prev, ptr - prev);
18145 token->id = p->token_id;
18146 token->type_name = parser_token2char(p, t);
18148 token->loc.beg_pos = p->yylloc->beg_pos;
18149 token->loc.end_pos = p->yylloc->end_pos;
18150 rb_parser_ary_push_ast_token(p, p->tokens, token);
18155 rb_parser_printf(p,
"Append tokens (line: %d) [%d, :%s, \"%s\", [%d, %d, %d, %d]]\n",
18156 line, token->id, token->type_name, str_escaped->ptr,
18157 token->loc.beg_pos.lineno, token->loc.beg_pos.column,
18158 token->loc.end_pos.lineno, token->loc.end_pos.column);
18159 rb_parser_string_free(p, str_escaped);
18164parser_dispatch_scan_event(
struct parser_params *p,
enum yytokentype t,
int line)
18166 debug_token_line(p,
"parser_dispatch_scan_event", line);
18168 if (!parser_has_token(p))
return;
18170 RUBY_SET_YYLLOC(*p->yylloc);
18172 if (p->keep_tokens) {
18173 rb_parser_string_t *str = rb_parser_encoding_string_new(p, p->lex.ptok, p->lex.pcur - p->lex.ptok, p->enc);
18174 parser_append_tokens(p, str, t, line);
18180#define dispatch_delayed_token(p, t) parser_dispatch_delayed_token(p, t, __LINE__)
18182parser_dispatch_delayed_token(
struct parser_params *p,
enum yytokentype t,
int line)
18184 debug_token_line(p,
"parser_dispatch_delayed_token", line);
18186 if (!has_delayed_token(p))
return;
18188 RUBY_SET_YYLLOC_OF_DELAYED_TOKEN(*p->yylloc);
18190 if (p->keep_tokens) {
18192 parser_append_tokens(p, p->delayed.token, t, line);
18194 rb_parser_string_free(p, p->delayed.token);
18197 p->delayed.token = NULL;
18200#define literal_flush(p, ptr) ((void)(ptr))
18205 if (p->lex.pcur < p->lex.ptok) rb_raise(
rb_eRuntimeError,
"lex.pcur < lex.ptok");
18206 return p->lex.pcur > p->lex.ptok;
18210ripper_scan_event_val(
struct parser_params *p,
enum yytokentype t)
18212 VALUE str = STR_NEW(p->lex.ptok, p->lex.pcur - p->lex.ptok);
18213 VALUE rval = ripper_dispatch1(p, ripper_token2eventid(t), str);
18214 RUBY_SET_YYLLOC(*p->yylloc);
18220ripper_dispatch_scan_event(
struct parser_params *p,
enum yytokentype t)
18222 if (!ripper_has_scan_event(p))
return;
18224 set_parser_s_value(ripper_scan_event_val(p, t));
18226#define dispatch_scan_event(p, t) ripper_dispatch_scan_event(p, t)
18229ripper_dispatch_delayed_token(
struct parser_params *p,
enum yytokentype t)
18232 int saved_line = p->ruby_sourceline;
18233 const char *saved_tokp = p->lex.ptok;
18234 VALUE s_value, str;
18236 if (!has_delayed_token(p))
return;
18237 p->ruby_sourceline = p->delayed.beg_line;
18238 p->lex.ptok = p->lex.pbeg + p->delayed.beg_col;
18239 str = rb_str_new_mutable_parser_string(p->delayed.token);
18240 rb_parser_string_free(p, p->delayed.token);
18241 s_value = ripper_dispatch1(p, ripper_token2eventid(t), str);
18242 set_parser_s_value(s_value);
18243 p->delayed.token = NULL;
18244 p->ruby_sourceline = saved_line;
18245 p->lex.ptok = saved_tokp;
18247#define dispatch_delayed_token(p, t) ripper_dispatch_delayed_token(p, t)
18253 return rb_enc_isalnum((
unsigned char)*ptr, enc) || *ptr ==
'_' || !
ISASCII(*ptr);
18259 return !(p)->eofp && is_identchar(p, p->lex.pcur-1, p->lex.pend, p->enc);
18265 return ISASCII(*(p->lex.pcur-1));
18271 int column = 1, nonspc = 0, i;
18272 for (i = 0; i < loc->beg_pos.column; i++, ptr++) {
18273 if (*ptr ==
'\t') {
18274 column = (((column - 1) / TAB_WIDTH) + 1) * TAB_WIDTH;
18277 if (*ptr !=
' ' && *ptr !=
'\t') {
18282 ptinfo->beg = loc->beg_pos;
18283 ptinfo->indent = column;
18284 ptinfo->nonspc = nonspc;
18292 if (!p->token_info_enabled)
return;
18294 ptinfo->token = token;
18295 ptinfo->next = p->token_info;
18296 token_info_setup(ptinfo, p->lex.pbeg, loc);
18298 p->token_info = ptinfo;
18306 if (!ptinfo_beg)
return;
18309 token_info_warn(p, token, ptinfo_beg, 1, loc);
18311 p->token_info = ptinfo_beg->next;
18312 ruby_sized_xfree(ptinfo_beg,
sizeof(*ptinfo_beg));
18320 if (!ptinfo_beg)
return;
18321 p->token_info = ptinfo_beg->next;
18323 if (ptinfo_beg->beg.lineno != beg_pos.lineno ||
18324 ptinfo_beg->beg.column != beg_pos.column ||
18325 strcmp(ptinfo_beg->token, token)) {
18326 compile_error(p,
"token position mismatch: %d:%d:%s expected but %d:%d:%s",
18327 beg_pos.lineno, beg_pos.column, token,
18328 ptinfo_beg->beg.lineno, ptinfo_beg->beg.column,
18329 ptinfo_beg->token);
18332 ruby_sized_xfree(ptinfo_beg,
sizeof(*ptinfo_beg));
18338 token_info ptinfo_end_body, *ptinfo_end = &ptinfo_end_body;
18339 if (!p->token_info_enabled)
return;
18340 if (!ptinfo_beg)
return;
18341 token_info_setup(ptinfo_end, p->lex.pbeg, loc);
18342 if (ptinfo_beg->beg.lineno == ptinfo_end->beg.lineno)
return;
18343 if (ptinfo_beg->nonspc || ptinfo_end->nonspc)
return;
18344 if (ptinfo_beg->indent == ptinfo_end->indent)
return;
18345 if (!same && ptinfo_beg->indent < ptinfo_end->indent)
return;
18346 rb_warn3L(ptinfo_end->beg.lineno,
18347 "mismatched indentations at '%s' with '%s' at %d",
18348 WARN_S(token), WARN_S(ptinfo_beg->token), WARN_I(ptinfo_beg->beg.lineno));
18352parser_precise_mbclen(
struct parser_params *p,
const char *ptr)
18354 int len = rb_enc_precise_mbclen(ptr, p->lex.pend, p->enc);
18356 compile_error(p,
"invalid multibyte char (%s)", rb_enc_name(p->enc));
18367 int lineno = p->ruby_sourceline;
18371 else if (yylloc->beg_pos.lineno == lineno) {
18372 str = p->lex.lastline;
18377 ruby_show_error_line(p, p->error_buffer, yylloc, lineno, str);
18387 yylloc = RUBY_SET_YYLLOC(current);
18389 else if ((p->ruby_sourceline != yylloc->beg_pos.lineno &&
18390 p->ruby_sourceline != yylloc->end_pos.lineno)) {
18394 parser_compile_error(p, yylloc,
"%s", msg);
18395 parser_show_error_line(p, yylloc);
18403 return parser_yyerror(p, RUBY_SET_YYLLOC(current), msg);
18410 const int max_line_margin = 30;
18411 const char *ptr, *ptr_end, *pt, *pb;
18412 const char *pre =
"", *post =
"", *pend;
18413 const char *code =
"", *caret =
"";
18415 const char *
const pbeg = PARSER_STRING_PTR(str);
18420 if (!yylloc)
return;
18421 pend = rb_parser_string_end(str);
18422 if (pend > pbeg && pend[-1] ==
'\n') {
18423 if (--pend > pbeg && pend[-1] ==
'\r') --pend;
18427 if (lineno == yylloc->end_pos.lineno &&
18428 (pend - pbeg) > yylloc->end_pos.column) {
18429 pt = pbeg + yylloc->end_pos.column;
18432 ptr = ptr_end = pt;
18433 lim = ptr - pbeg > max_line_margin ? ptr - max_line_margin : pbeg;
18434 while ((lim < ptr) && (*(ptr-1) !=
'\n')) ptr--;
18436 lim = pend - ptr_end > max_line_margin ? ptr_end + max_line_margin : pend;
18437 while ((ptr_end < lim) && (*ptr_end !=
'\n') && (*ptr_end !=
'\r')) ptr_end++;
18439 len = ptr_end - ptr;
18442 ptr = rb_enc_prev_char(pbeg, ptr, pt, rb_parser_str_get_encoding(str));
18443 if (ptr > pbeg) pre =
"...";
18445 if (ptr_end < pend) {
18446 ptr_end = rb_enc_prev_char(pt, ptr_end, pend, rb_parser_str_get_encoding(str));
18447 if (ptr_end < pend) post =
"...";
18451 if (lineno == yylloc->beg_pos.lineno) {
18452 pb += yylloc->beg_pos.column;
18453 if (pb > pt) pb = pt;
18455 if (pb < ptr) pb = ptr;
18456 if (len <= 4 && yylloc->beg_pos.lineno == yylloc->end_pos.lineno) {
18459 if (
RTEST(errbuf)) {
18460 mesg = rb_attr_get(errbuf, idMesg);
18461 if (char_at_end(p, mesg,
'\n') !=
'\n')
18465 mesg = rb_enc_str_new(0, 0, rb_parser_str_get_encoding(str));
18467 if (!errbuf && rb_stderr_tty_p()) {
18468#define CSI_BEGIN "\033["
18471 CSI_BEGIN
""CSI_SGR
"%s"
18472 CSI_BEGIN
"1"CSI_SGR
"%.*s"
18473 CSI_BEGIN
"1;4"CSI_SGR
"%.*s"
18474 CSI_BEGIN
";1"CSI_SGR
"%.*s"
18475 CSI_BEGIN
""CSI_SGR
"%s"
18478 (
int)(pb - ptr), ptr,
18479 (
int)(pt - pb), pb,
18480 (
int)(ptr_end - pt), pt,
18486 len = ptr_end - ptr;
18487 lim = pt < pend ? pt : pend;
18488 i = (int)(lim - ptr);
18494 *p2++ = *ptr++ ==
'\t' ?
'\t' :
' ';
18500 memset(p2,
'~', (lim - ptr));
18504 rb_str_catf(mesg,
"%s%.*s%s\n""%s%s\n",
18505 pre, (
int)
len, code, post,
18508 if (!errbuf) rb_write_error_str(mesg);
18515 const char *pcur = 0, *ptok = 0;
18516 if (p->ruby_sourceline == yylloc->beg_pos.lineno &&
18517 p->ruby_sourceline == yylloc->end_pos.lineno) {
18518 pcur = p->lex.pcur;
18519 ptok = p->lex.ptok;
18520 p->lex.ptok = p->lex.pbeg + yylloc->beg_pos.column;
18521 p->lex.pcur = p->lex.pbeg + yylloc->end_pos.column;
18523 parser_yyerror0(p, msg);
18525 p->lex.ptok = ptok;
18526 p->lex.pcur = pcur;
18534 dispatch1(parse_error, STR_NEW2(msg));
18546vtable_size(
const struct vtable *tbl)
18548 if (!DVARS_TERMINAL_P(tbl)) {
18566 rb_parser_printf(p,
"vtable_alloc:%d: %p\n", line, (
void *)tbl);
18571#define vtable_alloc(prev) vtable_alloc_gen(p, __LINE__, prev)
18574vtable_free_gen(
struct parser_params *p,
int line,
const char *name,
18579 rb_parser_printf(p,
"vtable_free:%d: %s(%p)\n", line, name, (
void *)tbl);
18582 if (!DVARS_TERMINAL_P(tbl)) {
18584 ruby_sized_xfree(tbl->tbl, tbl->capa *
sizeof(
ID));
18586 ruby_sized_xfree(tbl,
sizeof(*tbl));
18589#define vtable_free(tbl) vtable_free_gen(p, __LINE__, #tbl, tbl)
18592vtable_add_gen(
struct parser_params *p,
int line,
const char *name,
18597 rb_parser_printf(p,
"vtable_add:%d: %s(%p), %s\n",
18598 line, name, (
void *)tbl, rb_id2name(
id));
18601 if (DVARS_TERMINAL_P(tbl)) {
18602 rb_parser_fatal(p,
"vtable_add: vtable is not allocated (%p)", (
void *)tbl);
18605 if (tbl->pos == tbl->capa) {
18606 tbl->capa = tbl->capa * 2;
18607 SIZED_REALLOC_N(tbl->tbl,
ID, tbl->capa, tbl->pos);
18609 tbl->tbl[tbl->pos++] = id;
18611#define vtable_add(tbl, id) vtable_add_gen(p, __LINE__, #tbl, tbl, id)
18614vtable_pop_gen(
struct parser_params *p,
int line,
const char *name,
18615 struct vtable *tbl,
int n)
18618 rb_parser_printf(p,
"vtable_pop:%d: %s(%p), %d\n",
18619 line, name, (
void *)tbl, n);
18621 if (tbl->pos < n) {
18622 rb_parser_fatal(p,
"vtable_pop: unreachable (%d < %d)", tbl->pos, n);
18627#define vtable_pop(tbl, n) vtable_pop_gen(p, __LINE__, #tbl, tbl, n)
18630vtable_included(
const struct vtable * tbl,
ID id)
18634 if (!DVARS_TERMINAL_P(tbl)) {
18635 for (i = 0; i < tbl->pos; i++) {
18636 if (tbl->tbl[i] ==
id) {
18649 return strcmp(p->ruby_sourcefile,
"-e") == 0;
18656yycompile0(
VALUE arg)
18663 if (!compile_for_eval && !
NIL_P(p->ruby_sourcefile_string) && !e_option_supplied(p)) {
18667 if (p->debug_lines) {
18668 p->ast->body.script_lines = p->debug_lines;
18672#define RUBY_DTRACE_PARSE_HOOK(name) \
18673 if (RUBY_DTRACE_PARSE_##name##_ENABLED()) { \
18674 RUBY_DTRACE_PARSE_##name(p->ruby_sourcefile, p->ruby_sourceline); \
18676 RUBY_DTRACE_PARSE_HOOK(BEGIN);
18678 RUBY_DTRACE_PARSE_HOOK(END);
18680 p->debug_lines = 0;
18682 xfree(p->lex.strterm);
18683 p->lex.strterm = 0;
18684 p->lex.pcur = p->lex.pbeg = p->lex.pend = 0;
18685 if (n || p->error_p) {
18686 VALUE mesg = p->error_buffer;
18688 mesg = syntax_error_new();
18690 if (!p->error_tolerant) {
18691 rb_set_errinfo(mesg);
18695 tree = p->eval_tree;
18697 tree = NEW_NIL(&NULL_LOC);
18702 NODE *body = parser_append_options(p, RNODE_SCOPE(tree)->nd_body);
18703 prelude = block_append(p, p->eval_tree_begin, body);
18704 RNODE_SCOPE(tree)->nd_body = prelude;
18705 p->ast->body.frozen_string_literal = p->frozen_string_literal;
18706 p->ast->body.coverage_enabled = cov;
18707 if (p->keep_tokens) {
18708 p->ast->node_buffer->tokens = tokens;
18712 p->ast->body.root = tree;
18713 p->ast->body.line_count = p->line_count;
18721 if (
NIL_P(fname)) {
18722 p->ruby_sourcefile_string =
Qnil;
18723 p->ruby_sourcefile =
"(none)";
18726 p->ruby_sourcefile_string = rb_str_to_interned_str(fname);
18729 p->ruby_sourceline = line - 1;
18733 p->ast = ast = rb_ast_new();
18734 compile_callback(yycompile0, (
VALUE)p);
18748 rb_encoding *enc = rb_parser_str_get_encoding(s);
18749 if (!rb_enc_asciicompat(enc)) {
18750 rb_raise(rb_eArgError,
"invalid source encoding");
18759 if (!line)
return 0;
18761 string_buffer_append(p, line);
18762 must_be_ascii_compatible(p, line);
18768rb_parser_compile(
rb_parser_t *p, rb_parser_lex_gets_func *gets,
VALUE fname, rb_parser_input_data input,
int line)
18770 p->lex.gets = gets;
18771 p->lex.input = input;
18772 p->lex.pbeg = p->lex.pcur = p->lex.pend = 0;
18774 return yycompile(p, fname, line);
18778#define STR_FUNC_ESCAPE 0x01
18779#define STR_FUNC_EXPAND 0x02
18780#define STR_FUNC_REGEXP 0x04
18781#define STR_FUNC_QWORDS 0x08
18782#define STR_FUNC_SYMBOL 0x10
18783#define STR_FUNC_INDENT 0x20
18784#define STR_FUNC_LABEL 0x40
18785#define STR_FUNC_LIST 0x4000
18786#define STR_FUNC_TERM 0x8000
18789 str_label = STR_FUNC_LABEL,
18791 str_dquote = (STR_FUNC_EXPAND),
18792 str_xquote = (STR_FUNC_EXPAND),
18793 str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
18794 str_sword = (STR_FUNC_QWORDS|STR_FUNC_LIST),
18795 str_dword = (STR_FUNC_QWORDS|STR_FUNC_EXPAND|STR_FUNC_LIST),
18796 str_ssym = (STR_FUNC_SYMBOL),
18797 str_dsym = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
18805 pstr = rb_parser_encoding_string_new(p, ptr,
len, enc);
18807 if (!(func & STR_FUNC_REGEXP)) {
18808 if (rb_parser_is_ascii_string(p, pstr)) {
18810 else if (rb_is_usascii_enc((
void *)enc0) && enc != rb_utf8_encoding()) {
18812 enc = rb_ascii8bit_encoding();
18813 PARSER_ENCODING_CODERANGE_SET(pstr, enc, RB_PARSER_ENC_CODERANGE_VALID);
18823 return strterm->heredoc;
18827new_strterm(
struct parser_params *p,
int func,
int term,
int paren)
18830 strterm->u.literal.func = func;
18831 strterm->u.literal.term = term;
18832 strterm->u.literal.paren = paren;
18840 strterm->heredoc =
true;
18844#define peek(p,c) peek_n(p, (c), 0)
18845#define peek_n(p,c,n) (!lex_eol_n_p(p, n) && (c) == (unsigned char)(p)->lex.pcur[n])
18846#define peekc(p) peekc_n(p, 0)
18847#define peekc_n(p,n) (lex_eol_n_p(p, n) ? -1 : (unsigned char)(p)->lex.pcur[n])
18849#define add_delayed_token(p, tok, end) parser_add_delayed_token(p, tok, end, __LINE__)
18851parser_add_delayed_token(
struct parser_params *p,
const char *tok,
const char *end,
int line)
18853 debug_token_line(p,
"add_delayed_token", line);
18856 if (has_delayed_token(p)) {
18857 bool next_line = parser_string_char_at_end(p, p->delayed.token, 0) ==
'\n';
18858 int end_line = (next_line ? 1 : 0) + p->delayed.end_line;
18859 int end_col = (next_line ? 0 : p->delayed.end_col);
18860 if (end_line != p->ruby_sourceline || end_col != tok - p->lex.pbeg) {
18861 dispatch_delayed_token(p, tSTRING_CONTENT);
18864 if (!has_delayed_token(p)) {
18865 p->delayed.token = rb_parser_string_new(p, 0, 0);
18866 rb_parser_enc_associate(p, p->delayed.token, p->enc);
18867 p->delayed.beg_line = p->ruby_sourceline;
18868 p->delayed.beg_col =
rb_long2int(tok - p->lex.pbeg);
18870 parser_str_cat(p->delayed.token, tok, end - tok);
18871 p->delayed.end_line = p->ruby_sourceline;
18872 p->delayed.end_col =
rb_long2int(end - p->lex.pbeg);
18880 p->lex.pbeg = p->lex.pcur = PARSER_STRING_PTR(str);
18881 p->lex.pend = p->lex.pcur + PARSER_STRING_LEN(str);
18882 p->lex.lastline = str;
18889 p->lex.nextline = 0;
18894 if (!lex_eol_ptr_p(p, p->lex.pbeg) && *(p->lex.pend-1) !=
'\n') {
18898 if (!p->lex.input || !(str = lex_getline(p))) {
18905 if (p->debug_lines) {
18906 if (set_encoding) rb_parser_enc_associate(p, str, p->enc);
18908 rb_parser_ary_push_script_line(p, p->debug_lines, copy);
18911 p->cr_seen = FALSE;
18913 else if (str == AFTER_HEREDOC_WITHOUT_TERMINATOR) {
18917 add_delayed_token(p, p->lex.ptok, p->lex.pend);
18918 if (p->heredoc_end > 0) {
18919 p->ruby_sourceline = p->heredoc_end;
18920 p->heredoc_end = 0;
18922 p->ruby_sourceline++;
18923 set_lastline(p, str);
18931 if (peek(p,
'\n')) {
18943 if (UNLIKELY(lex_eol_p(p) || p->eofp || p->lex.nextline > AFTER_HEREDOC_WITHOUT_TERMINATOR)) {
18944 if (nextline(p, set_encoding))
return -1;
18946 c = (
unsigned char)*p->lex.pcur++;
18947 if (UNLIKELY(c ==
'\r')) {
18948 c = parser_cr(p, c);
18953#define nextc(p) nextc0(p, TRUE)
18958 if (c == -1)
return;
18961 if (p->lex.pcur > p->lex.pbeg && p->lex.pcur[0] ==
'\n' && p->lex.pcur[-1] ==
'\r') {
18966#define was_bol(p) ((p)->lex.pcur == (p)->lex.pbeg + 1)
18968#define tokfix(p) ((p)->tokenbuf[(p)->tokidx]='\0')
18969#define tok(p) (p)->tokenbuf
18970#define toklen(p) (p)->tokidx
18975 const char *ptr = p->lex.pcur;
18976 while (!lex_eol_ptr_p(p, ptr)) {
18977 int c = (
unsigned char)*ptr++;
18978 int eol = (c ==
'\n' || c ==
'#');
18990 if (!p->tokenbuf) {
18992 p->tokenbuf =
ALLOC_N(
char, 60);
18994 if (p->toksiz > 4096) {
18998 return p->tokenbuf;
19006 if (p->tokidx >= p->toksiz) {
19007 do {p->toksiz *= 2;}
while (p->toksiz < p->tokidx);
19008 REALLOC_N(p->tokenbuf,
char, p->toksiz);
19010 return &p->tokenbuf[p->tokidx-n];
19016 p->tokenbuf[p->tokidx++] = (char)c;
19017 if (p->tokidx >= p->toksiz) {
19019 REALLOC_N(p->tokenbuf,
char, p->toksiz);
19028 c = (int)ruby_scan_hex(p->lex.pcur, 2, numlen);
19031 yyerror0(
"invalid hex escape");
19032 dispatch_scan_event(p, tSTRING_CONTENT);
19035 p->lex.pcur += *numlen;
19039#define tokcopy(p, n) memcpy(tokspace(p, n), (p)->lex.pcur - (n), (n))
19042escaped_control_code(
int c)
19068#define WARN_SPACE_CHAR(c, prefix) \
19069 rb_warn1("invalid character syntax; use "prefix"\\%c", WARN_I(c))
19073 int regexp_literal,
const char *begin)
19075 const int wide = !begin;
19077 int codepoint = (int)ruby_scan_hex(p->lex.pcur, wide ? p->lex.pend - p->lex.pcur : 4, &numlen);
19079 p->lex.pcur += numlen;
19080 if (p->lex.strterm == NULL ||
19081 strterm_is_heredoc(p->lex.strterm) ||
19082 (p->lex.strterm->u.literal.func != str_regexp)) {
19083 if (!begin) begin = p->lex.pcur;
19084 if (wide ? (numlen == 0 || numlen > 6) : (numlen < 4)) {
19085 flush_string_content(p, rb_utf8_encoding(), p->lex.pcur - begin);
19086 yyerror0(
"invalid Unicode escape");
19087 dispatch_scan_event(p, tSTRING_CONTENT);
19088 return wide && numlen > 0;
19090 if (codepoint > 0x10ffff) {
19091 flush_string_content(p, rb_utf8_encoding(), p->lex.pcur - begin);
19092 yyerror0(
"invalid Unicode codepoint (too large)");
19093 dispatch_scan_event(p, tSTRING_CONTENT);
19096 if ((codepoint & 0xfffff800) == 0xd800) {
19097 flush_string_content(p, rb_utf8_encoding(), p->lex.pcur - begin);
19098 yyerror0(
"invalid Unicode codepoint");
19099 dispatch_scan_event(p, tSTRING_CONTENT);
19103 if (regexp_literal) {
19104 tokcopy(p, (
int)numlen);
19106 else if (codepoint >= 0x80) {
19108 if (*encp && utf8 != *encp) {
19109 YYLTYPE loc = RUBY_INIT_YYLLOC();
19110 compile_error(p,
"UTF-8 mixed within %s source", rb_enc_name(*encp));
19111 parser_show_error_line(p, &loc);
19115 tokaddmbc(p, codepoint, *encp);
19118 tokadd(p, codepoint);
19128 int len = parser_precise_mbclen(p, p->lex.pcur-1);
19130 p->lex.pcur +=
len - 1;
19138 int term,
int symbol_literal,
int regexp_literal)
19145 static const char multiple_codepoints[] =
"Multiple codepoints at single character literal";
19147 const int open_brace =
'{', close_brace =
'}';
19149 if (regexp_literal) { tokadd(p,
'\\'); tokadd(p,
'u'); }
19151 if (peek(p, open_brace)) {
19152 if (regexp_literal && p->lex.strterm->u.literal.func == str_regexp) {
19159 tokadd(p, open_brace);
19160 while (!lex_eol_ptr_p(p, ++p->lex.pcur)) {
19162 if (c == close_brace) {
19167 else if (c == term) {
19170 if (c ==
'\\' && !lex_eol_n_p(p, 1)) {
19172 c = *++p->lex.pcur;
19174 tokadd_mbchar(p, c);
19178 const char *second = NULL;
19179 int c, last = nextc(p);
19180 if (lex_eol_p(p))
goto unterminated;
19181 while (
ISSPACE(c = peekc(p)) && !lex_eol_ptr_p(p, ++p->lex.pcur));
19182 while (c != close_brace) {
19183 if (c == term)
goto unterminated;
19184 if (second == multiple_codepoints)
19185 second = p->lex.pcur;
19186 if (regexp_literal) tokadd(p, last);
19187 if (!tokadd_codepoint(p, encp, regexp_literal, NULL)) {
19190 while (
ISSPACE(c = peekc(p))) {
19191 if (lex_eol_ptr_p(p, ++p->lex.pcur))
goto unterminated;
19194 if (term == -1 && !second)
19195 second = multiple_codepoints;
19198 if (c != close_brace) {
19200 flush_string_content(p, rb_utf8_encoding(), 0);
19201 yyerror0(
"unterminated Unicode escape");
19202 dispatch_scan_event(p, tSTRING_CONTENT);
19205 if (second && second != multiple_codepoints) {
19206 const char *pcur = p->lex.pcur;
19207 p->lex.pcur = second;
19208 dispatch_scan_event(p, tSTRING_CONTENT);
19210 p->lex.pcur = pcur;
19211 yyerror0(multiple_codepoints);
19215 if (regexp_literal) tokadd(p, close_brace);
19220 if (!tokadd_codepoint(p, encp, regexp_literal, p->lex.pcur -
rb_strlen_lit(
"\\u"))) {
19227#define ESCAPE_CONTROL 1
19228#define ESCAPE_META 2
19231read_escape(
struct parser_params *p,
int flags,
const char *begin)
19236 switch (c = nextc(p)) {
19261 case '0':
case '1':
case '2':
case '3':
19262 case '4':
case '5':
case '6':
case '7':
19264 c = (int)ruby_scan_oct(p->lex.pcur, 3, &numlen);
19265 p->lex.pcur += numlen;
19269 c = tok_hex(p, &numlen);
19270 if (numlen == 0)
return 0;
19280 if (flags & ESCAPE_META)
goto eof;
19281 if ((c = nextc(p)) !=
'-') {
19284 if ((c = nextc(p)) ==
'\\') {
19285 switch (peekc(p)) {
19286 case 'u':
case 'U':
19290 return read_escape(p, flags|ESCAPE_META, begin) | 0x80;
19292 else if (c == -1)
goto eof;
19298 int c2 = escaped_control_code(c);
19300 if (
ISCNTRL(c) || !(flags & ESCAPE_CONTROL)) {
19301 WARN_SPACE_CHAR(c2,
"\\M-");
19304 WARN_SPACE_CHAR(c2,
"\\C-\\M-");
19307 else if (
ISCNTRL(c))
goto eof;
19308 return ((c & 0xff) | 0x80);
19312 if ((c = nextc(p)) !=
'-') {
19316 if (flags & ESCAPE_CONTROL)
goto eof;
19317 if ((c = nextc(p))==
'\\') {
19318 switch (peekc(p)) {
19319 case 'u':
case 'U':
19323 c = read_escape(p, flags|ESCAPE_CONTROL, begin);
19327 else if (c == -1)
goto eof;
19333 int c2 = escaped_control_code(c);
19336 if (flags & ESCAPE_META) {
19337 WARN_SPACE_CHAR(c2,
"\\M-");
19340 WARN_SPACE_CHAR(c2,
"");
19344 if (flags & ESCAPE_META) {
19345 WARN_SPACE_CHAR(c2,
"\\M-\\C-");
19348 WARN_SPACE_CHAR(c2,
"\\C-");
19352 else if (
ISCNTRL(c))
goto eof;
19358 flush_string_content(p, p->enc, p->lex.pcur - begin);
19359 yyerror0(
"Invalid escape character syntax");
19360 dispatch_scan_event(p, tSTRING_CONTENT);
19375 int len = rb_enc_codelen(c, enc);
19376 rb_enc_mbcput(c, tokspace(p,
len), enc);
19384 const char *begin = p->lex.pcur;
19386 switch (c = nextc(p)) {
19390 case '0':
case '1':
case '2':
case '3':
19391 case '4':
case '5':
case '6':
case '7':
19393 ruby_scan_oct(--p->lex.pcur, 3, &numlen);
19394 if (numlen == 0)
goto eof;
19395 p->lex.pcur += numlen;
19396 tokcopy(p, (
int)numlen + 1);
19402 tok_hex(p, &numlen);
19403 if (numlen == 0)
return -1;
19404 tokcopy(p, (
int)numlen + 2);
19410 flush_string_content(p, p->enc, p->lex.pcur - begin);
19411 yyerror0(
"Invalid escape character syntax");
19423char_to_option(
int c)
19429 val = RE_ONIG_OPTION_IGNORECASE;
19432 val = RE_ONIG_OPTION_EXTEND;
19435 val = RE_ONIG_OPTION_MULTILINE;
19444#define ARG_ENCODING_FIXED 16
19445#define ARG_ENCODING_NONE 32
19446#define ENC_ASCII8BIT 1
19447#define ENC_EUC_JP 2
19448#define ENC_Windows_31J 3
19452char_to_option_kcode(
int c,
int *option,
int *kcode)
19458 *kcode = ENC_ASCII8BIT;
19459 return (*option = ARG_ENCODING_NONE);
19461 *kcode = ENC_EUC_JP;
19464 *kcode = ENC_Windows_31J;
19471 return (*option = char_to_option(c));
19473 *option = ARG_ENCODING_FIXED;
19486 while (c = nextc(p),
ISALPHA(c)) {
19488 options |= RE_OPTION_ONCE;
19490 else if (char_to_option_kcode(c, &opt, &kc)) {
19492 if (kc != ENC_ASCII8BIT) kcode = c;
19506 YYLTYPE loc = RUBY_INIT_YYLLOC();
19508 compile_error(p,
"unknown regexp option%s - %*s",
19509 toklen(p) > 1 ?
"s" :
"", toklen(p), tok(p));
19510 parser_show_error_line(p, &loc);
19512 return options | RE_OPTION_ENCODING(kcode);
19518 int len = parser_precise_mbclen(p, p->lex.pcur-1);
19519 if (
len < 0)
return -1;
19521 p->lex.pcur += --
len;
19522 if (
len > 0) tokcopy(p,
len);
19527simple_re_meta(
int c)
19530 case '$':
case '*':
case '+':
case '.':
19531 case '?':
case '^':
case '|':
19532 case ')':
case ']':
case '}':
case '>':
19540parser_update_heredoc_indent(
struct parser_params *p,
int c)
19542 if (p->heredoc_line_indent == -1) {
19543 if (c ==
'\n') p->heredoc_line_indent = 0;
19547 p->heredoc_line_indent++;
19550 else if (c ==
'\t') {
19551 int w = (p->heredoc_line_indent / TAB_WIDTH) + 1;
19552 p->heredoc_line_indent = w * TAB_WIDTH;
19555 else if (c !=
'\n') {
19556 if (p->heredoc_indent > p->heredoc_line_indent) {
19557 p->heredoc_indent = p->heredoc_line_indent;
19559 p->heredoc_line_indent = -1;
19563 p->heredoc_line_indent = 0;
19572 YYLTYPE loc = RUBY_INIT_YYLLOC();
19573 const char *n1 = rb_enc_name(enc1), *n2 = rb_enc_name(enc2);
19574 compile_error(p,
"%s mixed within %s source", n1, n2);
19575 parser_show_error_line(p, &loc);
19581 const char *pos = p->lex.pcur;
19583 parser_mixed_error(p, enc1, enc2);
19588nibble_char_upper(
unsigned int c)
19591 return c + (c < 10 ?
'0' :
'A' - 10);
19596 int func,
int term,
int paren,
long *nest,
19600 bool erred =
false;
19602 const int heredoc_end = (p->heredoc_end ? p->heredoc_end + 1 : 0);
19603 int top_of_line = FALSE;
19606#define mixed_error(enc1, enc2) \
19607 (void)(erred || (parser_mixed_error(p, enc1, enc2), erred = true))
19608#define mixed_escape(beg, enc1, enc2) \
19609 (void)(erred || (parser_mixed_escape(p, beg, enc1, enc2), erred = true))
19611 while ((c = nextc(p)) != -1) {
19612 if (p->heredoc_indent > 0) {
19613 parser_update_heredoc_indent(p, c);
19616 if (top_of_line && heredoc_end == p->ruby_sourceline) {
19622 if (paren && c == paren) {
19625 else if (c == term) {
19626 if (!nest || !*nest) {
19632 else if ((func & STR_FUNC_EXPAND) && c ==
'#' && !lex_eol_p(p)) {
19633 unsigned char c2 = *p->lex.pcur;
19634 if (c2 ==
'$' || c2 ==
'@' || c2 ==
'{') {
19639 else if (c ==
'\\') {
19643 if (func & STR_FUNC_QWORDS)
break;
19644 if (func & STR_FUNC_EXPAND) {
19645 if (!(func & STR_FUNC_INDENT) || (p->heredoc_indent < 0))
19656 if (func & STR_FUNC_ESCAPE) tokadd(p, c);
19660 if ((func & STR_FUNC_EXPAND) == 0) {
19664 tokadd_utf8(p, enc, term,
19665 func & STR_FUNC_SYMBOL,
19666 func & STR_FUNC_REGEXP);
19670 if (c == -1)
return -1;
19672 if ((func & STR_FUNC_EXPAND) == 0) tokadd(p,
'\\');
19675 if (func & STR_FUNC_REGEXP) {
19681 c = read_escape(p, 0, p->lex.pcur - 1);
19686 *t++ = nibble_char_upper(c >> 4);
19687 *t++ = nibble_char_upper(c);
19692 if (c == term && !simple_re_meta(c)) {
19697 if ((c = tokadd_escape(p)) < 0)
19699 if (*enc && *enc != *encp) {
19700 mixed_escape(p->lex.ptok+2, *enc, *encp);
19704 else if (func & STR_FUNC_EXPAND) {
19706 if (func & STR_FUNC_ESCAPE) tokadd(p,
'\\');
19707 c = read_escape(p, 0, p->lex.pcur - 1);
19709 else if ((func & STR_FUNC_QWORDS) &&
ISSPACE(c)) {
19712 else if (c != term && !(paren && c == paren)) {
19719 else if (!parser_isascii(p)) {
19724 else if (*enc != *encp) {
19725 mixed_error(*enc, *encp);
19728 if (tokadd_mbchar(p, c) == -1)
return -1;
19731 else if ((func & STR_FUNC_QWORDS) &&
ISSPACE(c)) {
19739 else if (*enc != *encp) {
19740 mixed_error(*enc, *encp);
19746 top_of_line = (c ==
'\n');
19750 if (*enc) *encp = *enc;
19754#define NEW_STRTERM(func, term, paren) new_strterm(p, func, term, paren)
19759 p->lex.pcur -= back;
19760 if (has_delayed_token(p)) {
19761 ptrdiff_t
len = p->lex.pcur - p->lex.ptok;
19763 rb_parser_enc_str_buf_cat(p, p->delayed.token, p->lex.ptok,
len, enc);
19764 p->delayed.end_line = p->ruby_sourceline;
19765 p->delayed.end_col =
rb_long2int(p->lex.pcur - p->lex.pbeg);
19767 dispatch_delayed_token(p, tSTRING_CONTENT);
19768 p->lex.ptok = p->lex.pcur;
19770 dispatch_scan_event(p, tSTRING_CONTENT);
19771 p->lex.pcur += back;
19777#define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
19778#define SPECIAL_PUNCT(idx) ( \
19779 BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
19780 BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
19781 BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
19782 BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
19783 BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
19785const uint_least32_t ruby_global_name_punct_bits[] = {
19791#undef SPECIAL_PUNCT
19794static enum yytokentype
19795parser_peek_variable_name(struct parser_params *p)
19798 const char *ptr = p->lex.pcur;
19800 if (lex_eol_ptr_n_p(p, ptr, 1)) return 0;
19804 if ((c = *ptr) == '-') {
19805 if (lex_eol_ptr_p(p, ++ptr)) return 0;
19808 else if (is_global_name_punct(c) || ISDIGIT(c)) {
19809 return tSTRING_DVAR;
19813 if ((c = *ptr) == '@') {
19814 if (lex_eol_ptr_p(p, ++ptr)) return 0;
19820 p->command_start = TRUE;
19821 yylval.state = p->lex.state;
19822 return tSTRING_DBEG;
19826 if (!ISASCII(c) || c == '_' || ISALPHA(c))
19827 return tSTRING_DVAR;
19831#define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
19832#define IS_END() IS_lex_state(EXPR_END_ANY)
19833#define IS_BEG() (IS_lex_state(EXPR_BEG_ANY) || IS_lex_state_all(EXPR_ARG|EXPR_LABELED))
19834#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
19835#define IS_LABEL_POSSIBLE() (\
19836 (IS_lex_state(EXPR_LABEL|EXPR_ENDFN) && !cmd_state) || \
19838#define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1))
19839#define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
19841static inline enum yytokentype
19842parser_string_term(struct parser_params *p, int func)
19844 xfree(p->lex.strterm);
19845 p->lex.strterm = 0;
19846 if (func & STR_FUNC_REGEXP) {
19847 set_yylval_num(regx_options(p));
19848 dispatch_scan_event(p, tREGEXP_END);
19849 SET_LEX_STATE(EXPR_END);
19850 return tREGEXP_END;
19852 if ((func & STR_FUNC_LABEL) && IS_LABEL_SUFFIX(0)) {
19854 SET_LEX_STATE(EXPR_ARG|EXPR_LABELED);
19857 SET_LEX_STATE(EXPR_END);
19858 return tSTRING_END;
19861static enum yytokentype
19862parse_string(struct parser_params *p, rb_strterm_literal_t *quote)
19864 int func = quote->func;
19865 int term = quote->term;
19866 int paren = quote->paren;
19868 rb_encoding *enc = p->enc;
19869 rb_encoding *base_enc = 0;
19870 rb_parser_string_t *lit;
19872 if (func & STR_FUNC_TERM) {
19873 if (func & STR_FUNC_QWORDS) nextc(p); /* delayed term */
19874 SET_LEX_STATE(EXPR_END);
19875 xfree(p->lex.strterm);
19876 p->lex.strterm = 0;
19877 return func & STR_FUNC_REGEXP ? tREGEXP_END : tSTRING_END;
19880 if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
19881 while (c != '\n' && ISSPACE(c = nextc(p)));
19884 if (func & STR_FUNC_LIST) {
19885 quote->func &= ~STR_FUNC_LIST;
19888 if (c == term && !quote->nest) {
19889 if (func & STR_FUNC_QWORDS) {
19890 quote->func |= STR_FUNC_TERM;
19891 pushback(p, c); /* dispatch the term at tSTRING_END */
19892 add_delayed_token(p, p->lex.ptok, p->lex.pcur);
19895 return parser_string_term(p, func);
19898 if (!ISSPACE(c)) pushback(p, c);
19899 add_delayed_token(p, p->lex.ptok, p->lex.pcur);
19903 if ((func & STR_FUNC_EXPAND) && c == '#') {
19904 enum yytokentype t = parser_peek_variable_name(p);
19910 if (tokadd_string(p, func, term, paren, "e->nest,
19911 &enc, &base_enc) == -1) {
19914# define unterminated_literal(mesg) yyerror0(mesg)
19916# define unterminated_literal(mesg) compile_error(p, mesg)
19918 literal_flush(p, p->lex.pcur);
19919 if (func & STR_FUNC_QWORDS) {
19920 /* no content to add, bailing out here */
19921 unterminated_literal("unterminated list meets end of file");
19922 xfree(p->lex.strterm);
19923 p->lex.strterm = 0;
19924 return tSTRING_END;
19926 if (func & STR_FUNC_REGEXP) {
19927 unterminated_literal("unterminated regexp meets end of file");
19930 unterminated_literal("unterminated string meets end of file");
19932 quote->func |= STR_FUNC_TERM;
19937 lit = STR_NEW3(tok(p), toklen(p), enc, func);
19938 set_yylval_str(lit);
19939 flush_string_content(p, enc, 0);
19941 return tSTRING_CONTENT;
19944static enum yytokentype
19945heredoc_identifier(struct parser_params *p)
19948 * term_len is length of `<<"END"` except `END`,
19949 * in this case term_len is 4 (<, <, " and ").
19951 long len, offset = p->lex.pcur - p->lex.pbeg;
19952 int c = nextc(p), term, func = 0, quote = 0;
19953 enum yytokentype token = tSTRING_BEG;
19958 func = STR_FUNC_INDENT;
19961 else if (c == '~') {
19963 func = STR_FUNC_INDENT;
19969 func |= str_squote; goto quoted;
19971 func |= str_dquote;
goto quoted;
19973 token = tXSTRING_BEG;
19974 func |= str_xquote;
goto quoted;
19981 while ((c = nextc(p)) != term) {
19982 if (c == -1 || c ==
'\r' || c ==
'\n') {
19983 yyerror0(
"unterminated here document identifier");
19990 if (!parser_is_identchar(p)) {
19992 if (func & STR_FUNC_INDENT) {
19993 pushback(p, indent > 0 ?
'~' :
'-');
19997 func |= str_dquote;
19999 int n = parser_precise_mbclen(p, p->lex.pcur-1);
20000 if (n < 0)
return 0;
20001 p->lex.pcur += --n;
20002 }
while ((c = nextc(p)) != -1 && parser_is_identchar(p));
20007 len = p->lex.pcur - (p->lex.pbeg + offset) - quote;
20008 if ((
unsigned long)
len >= HERETERM_LENGTH_MAX)
20009 yyerror0(
"too long here document identifier");
20010 dispatch_scan_event(p, tHEREDOC_BEG);
20013 p->lex.strterm = new_heredoc(p);
20015 here->offset = offset;
20016 here->sourceline = p->ruby_sourceline;
20017 here->length = (unsigned)
len;
20018 here->quote = quote;
20020 here->lastline = p->lex.lastline;
20023 p->heredoc_indent = indent;
20024 p->heredoc_line_indent = 0;
20034 p->lex.strterm = 0;
20035 line = here->lastline;
20036 p->lex.lastline = line;
20037 p->lex.pbeg = PARSER_STRING_PTR(line);
20038 p->lex.pend = p->lex.pbeg + PARSER_STRING_LEN(line);
20039 p->lex.pcur = p->lex.pbeg + here->offset + here->length + here->quote;
20040 p->lex.ptok = p->lex.pbeg + here->offset - here->quote;
20041 p->heredoc_end = p->ruby_sourceline;
20042 p->ruby_sourceline = (int)here->sourceline;
20043 if (p->eofp) p->lex.nextline = AFTER_HEREDOC_WITHOUT_TERMINATOR;
20049dedent_string_column(
const char *str,
long len,
int width)
20053 for (i = 0; i <
len && col < width; i++) {
20054 if (str[i] ==
' ') {
20057 else if (str[i] ==
'\t') {
20058 int n = TAB_WIDTH * (col / TAB_WIDTH + 1);
20059 if (n > width)
break;
20077 len = PARSER_STRING_LEN(
string);
20078 str = PARSER_STRING_PTR(
string);
20080 i = dedent_string_column(str,
len, width);
20083 rb_parser_str_modify(
string);
20084 str = PARSER_STRING_PTR(
string);
20085 if (PARSER_STRING_LEN(
string) !=
len)
20086 rb_fatal(
"literal string changed: %s", PARSER_STRING_PTR(
string));
20088 rb_parser_str_set_len(p,
string,
len - i);
20095 NODE *node, *str_node, *prev_node;
20096 int indent = p->heredoc_indent;
20099 if (indent <= 0)
return root;
20100 if (!root)
return root;
20102 prev_node = node = str_node = root;
20103 if (nd_type_p(root, NODE_LIST)) str_node = RNODE_LIST(root)->nd_head;
20107 if (nd_fl_newline(str_node)) {
20108 dedent_string(p, lit, indent);
20113 else if (!literal_concat0(p, prev_lit, lit)) {
20117 NODE *end = RNODE_LIST(node)->as.nd_end;
20118 node = RNODE_LIST(prev_node)->nd_next = RNODE_LIST(node)->nd_next;
20120 if (nd_type_p(prev_node, NODE_DSTR))
20121 nd_set_type(prev_node, NODE_STR);
20124 RNODE_LIST(node)->as.nd_end = end;
20129 while ((nd_type_p(node, NODE_LIST) || nd_type_p(node, NODE_DSTR)) && (node = RNODE_LIST(prev_node = node)->nd_next) != 0) {
20131 if (!nd_type_p(node, NODE_LIST))
break;
20132 if ((str_node = RNODE_LIST(node)->nd_head) != 0) {
20133 enum node_type
type = nd_type(str_node);
20134 if (
type == NODE_STR ||
type == NODE_DSTR)
break;
20144whole_match_p(
struct parser_params *p,
const char *eos,
long len,
int indent)
20146 const char *beg = p->lex.pbeg;
20147 const char *ptr = p->lex.pend;
20149 if (ptr - beg <
len)
return FALSE;
20150 if (ptr > beg && ptr[-1] ==
'\n') {
20151 if (--ptr > beg && ptr[-1] ==
'\r') --ptr;
20152 if (ptr - beg <
len)
return FALSE;
20154 if (strncmp(eos, ptr -=
len,
len))
return FALSE;
20156 while (beg < ptr &&
ISSPACE(*beg)) beg++;
20164 if (strncmp(p->lex.pcur, word,
len))
return 0;
20165 if (lex_eol_n_p(p,
len))
return 1;
20166 int c = (
unsigned char)p->lex.pcur[
len];
20169 case '\0':
case '\004':
case '\032':
return 1;
20174#define NUM_SUFFIX_R (1<<0)
20175#define NUM_SUFFIX_I (1<<1)
20176#define NUM_SUFFIX_ALL 3
20182 const char *lastp = p->lex.pcur;
20184 while ((c = nextc(p)) != -1) {
20185 if ((mask & NUM_SUFFIX_I) && c ==
'i') {
20186 result |= (mask & NUM_SUFFIX_I);
20187 mask &= ~NUM_SUFFIX_I;
20189 mask &= ~NUM_SUFFIX_R;
20192 if ((mask & NUM_SUFFIX_R) && c ==
'r') {
20193 result |= (mask & NUM_SUFFIX_R);
20194 mask &= ~NUM_SUFFIX_R;
20198 p->lex.pcur = lastp;
20199 literal_flush(p, p->lex.pcur);
20208static enum yytokentype
20209set_number_literal(
struct parser_params *p,
enum yytokentype
type,
int suffix,
int base,
int seen_point)
20211 enum rb_numeric_type numeric_type = integer_literal;
20213 if (
type == tFLOAT) {
20214 numeric_type = float_literal;
20217 if (suffix & NUM_SUFFIX_R) {
20219 numeric_type = rational_literal;
20221 if (suffix & NUM_SUFFIX_I) {
20227 set_yylval_node(NEW_INTEGER(
strdup(tok(p)), base, &_cur_loc));
20230 set_yylval_node(NEW_FLOAT(
strdup(tok(p)), &_cur_loc));
20233 set_yylval_node(NEW_RATIONAL(
strdup(tok(p)), base, seen_point, &_cur_loc));
20236 set_yylval_node(NEW_IMAGINARY(
strdup(tok(p)), base, seen_point, numeric_type, &_cur_loc));
20237 (void)numeric_type;
20240 rb_bug(
"unexpected token: %d",
type);
20242 SET_LEX_STATE(EXPR_END);
20246#define dispatch_heredoc_end(p) parser_dispatch_heredoc_end(p, __LINE__)
20248parser_dispatch_heredoc_end(
struct parser_params *p,
int line)
20250 if (has_delayed_token(p))
20251 dispatch_delayed_token(p, tSTRING_CONTENT);
20254 VALUE str = STR_NEW(p->lex.ptok, p->lex.pend - p->lex.ptok);
20255 ripper_dispatch1(p, ripper_token2eventid(tHEREDOC_END), str);
20257 if (p->keep_tokens) {
20258 rb_parser_string_t *str = rb_parser_encoding_string_new(p, p->lex.ptok, p->lex.pend - p->lex.ptok, p->enc);
20259 RUBY_SET_YYLLOC_OF_HEREDOC_END(*p->yylloc);
20260 parser_append_tokens(p, str, tHEREDOC_END, line);
20264 RUBY_SET_YYLLOC_FROM_STRTERM_HEREDOC(*p->yylloc);
20269static enum yytokentype
20272 int c, func, indent = 0;
20273 const char *eos, *ptr, *ptr_end;
20283 eos = PARSER_STRING_PTR(here->lastline) + here->offset;
20284 len = here->length;
20285 indent = (func = here->func) & STR_FUNC_INDENT;
20287 if ((c = nextc(p)) == -1) {
20290 if (!has_delayed_token(p)) {
20291 dispatch_scan_event(p, tSTRING_CONTENT);
20293 else if (p->delayed.end_line + 1 == p->ruby_sourceline) {
20294 if ((
len = p->lex.pcur - p->lex.ptok) > 0) {
20295 if (!(func & STR_FUNC_REGEXP)) {
20299 rb_is_usascii_enc(p->enc) &&
20300 enc != rb_utf8_encoding()) {
20301 enc = rb_ascii8bit_encoding();
20304 rb_parser_enc_str_buf_cat(p, p->delayed.token, p->lex.ptok,
len, enc);
20306 dispatch_delayed_token(p, tSTRING_CONTENT);
20309 dispatch_delayed_token(p, tSTRING_CONTENT);
20310 dispatch_scan_event(p, tSTRING_CONTENT);
20314 heredoc_restore(p, &p->lex.strterm->u.heredoc);
20315 compile_error(p,
"can't find string \"%.*s\" anywhere before EOF",
20318 SET_LEX_STATE(EXPR_END);
20319 return tSTRING_END;
20325 else if (p->heredoc_line_indent == -1) {
20330 p->heredoc_line_indent = 0;
20332 else if (whole_match_p(p, eos,
len, indent)) {
20333 dispatch_heredoc_end(p);
20335 heredoc_restore(p, &p->lex.strterm->u.heredoc);
20337 SET_LEX_STATE(EXPR_END);
20338 return tSTRING_END;
20341 if (!(func & STR_FUNC_EXPAND)) {
20343 ptr = PARSER_STRING_PTR(p->lex.lastline);
20344 ptr_end = p->lex.pend;
20345 if (ptr_end > ptr) {
20346 switch (ptr_end[-1]) {
20348 if (--ptr_end == ptr || ptr_end[-1] !=
'\r') {
20357 if (p->heredoc_indent > 0) {
20359 while (ptr + i < ptr_end && parser_update_heredoc_indent(p, ptr[i]))
20361 p->heredoc_line_indent = 0;
20365 parser_str_cat(str, ptr, ptr_end - ptr);
20367 str = rb_parser_encoding_string_new(p, ptr, ptr_end - ptr, enc);
20368 if (!lex_eol_ptr_p(p, ptr_end)) parser_str_cat_cstr(str,
"\n");
20370 if (p->heredoc_indent > 0) {
20373 if (nextc(p) == -1) {
20375 rb_parser_string_free(p, str);
20380 }
while (!whole_match_p(p, eos,
len, indent));
20386 enum yytokentype t = parser_peek_variable_name(p);
20387 if (p->heredoc_line_indent != -1) {
20388 if (p->heredoc_indent > p->heredoc_line_indent) {
20389 p->heredoc_indent = p->heredoc_line_indent;
20391 p->heredoc_line_indent = -1;
20400 if ((c = tokadd_string(p, func,
'\n', 0, NULL, &enc, &base_enc)) == -1) {
20401 if (p->eofp)
goto error;
20405 if (c ==
'\\') p->heredoc_line_indent = -1;
20407 str = STR_NEW3(tok(p), toklen(p), enc, func);
20409 set_yylval_str(str);
20411 if (bol) nd_set_fl_newline(yylval.node);
20413 flush_string_content(p, enc, 0);
20414 return tSTRING_CONTENT;
20416 tokadd(p, nextc(p));
20417 if (p->heredoc_indent > 0) {
20422 if ((c = nextc(p)) == -1)
goto error;
20423 }
while (!whole_match_p(p, eos,
len, indent));
20424 str = STR_NEW3(tok(p), toklen(p), enc, func);
20426 dispatch_heredoc_end(p);
20427 heredoc_restore(p, &p->lex.strterm->u.heredoc);
20429 p->lex.strterm = NEW_STRTERM(func | STR_FUNC_TERM, 0, 0);
20432 s_value = p->s_value;
20434 set_yylval_str(str);
20436 set_parser_s_value(s_value);
20440 if (bol) nd_set_fl_newline(yylval.node);
20442 return tSTRING_CONTENT;
20452 rb_warning1(
"ambiguity between regexp and two divisions: wrap regexp in parentheses or add a space after '%c' operator", WARN_I(c));
20455 rb_warning1(
"ambiguous first argument; put parentheses or a space even after '%c' operator", WARN_I(c));
20468 switch (id_type(
id)) {
20472# define ERR(mesg) (yyerror0(mesg), Qtrue)
20474# define ERR(mesg) WARN_S(mesg)
20477 return ERR(
"formal argument cannot be a constant");
20479 return ERR(
"formal argument cannot be an instance variable");
20481 return ERR(
"formal argument cannot be a global variable");
20483 return ERR(
"formal argument cannot be a class variable");
20485 return ERR(
"formal argument must be local variable");
20488 shadowing_lvar(p,
id);
20496 return (dyna_in_block(p) && dvar_defined(p,
id)) || local_id(p,
id);
20505 if (
len > 5 && name[nlen =
len - 5] ==
'-') {
20506 if (rb_memcicmp(name + nlen + 1,
"unix", 4) == 0)
20509 if (
len > 4 && name[nlen =
len - 4] ==
'-') {
20510 if (rb_memcicmp(name + nlen + 1,
"dos", 3) == 0)
20512 if (rb_memcicmp(name + nlen + 1,
"mac", 3) == 0 &&
20513 !(
len == 8 && rb_memcicmp(name,
"utf8-mac",
len) == 0))
20521parser_set_encode(
struct parser_params *p,
const char *name)
20527 const char *wrong = 0;
20529 case 'e':
case 'E': wrong =
"external";
break;
20530 case 'i':
case 'I': wrong =
"internal";
break;
20531 case 'f':
case 'F': wrong =
"filesystem";
break;
20532 case 'l':
case 'L': wrong =
"locale";
break;
20534 if (wrong &&
STRCASECMP(name, wrong) == 0)
goto unknown;
20535 idx = rb_enc_find_index(name);
20538 excargs[1] = rb_sprintf(
"unknown encoding name: %s", name);
20540 excargs[0] = rb_eArgError;
20541 excargs[2] = rb_make_backtrace();
20542 rb_ary_unshift(excargs[2], rb_sprintf(
"%"PRIsVALUE
":%d", p->ruby_sourcefile_string, p->ruby_sourceline));
20543 VALUE exc = rb_make_exception(3, excargs);
20544 ruby_show_error_line(p, exc, &(
YYLTYPE)RUBY_INIT_YYLLOC(), p->ruby_sourceline, p->lex.lastline);
20546 rb_ast_free(p->ast);
20551 enc = rb_enc_from_index(idx);
20552 if (!rb_enc_asciicompat(enc)) {
20553 excargs[1] = rb_sprintf(
"%s is not ASCII compatible", rb_enc_name(enc));
20558 if (p->debug_lines) {
20560 for (i = 0; i < p->debug_lines->len; i++) {
20561 rb_parser_enc_associate(p, p->debug_lines->data[i], enc);
20570 if (p->token_seen)
return false;
20571 return (p->line_count == (p->has_shebang ? 2 : 1));
20574typedef long (*rb_magic_comment_length_t)(
struct parser_params *p,
const char *name,
long len);
20575typedef void (*rb_magic_comment_setter_t)(
struct parser_params *p,
const char *name,
const char *val);
20577static int parser_invalid_pragma_value(
struct parser_params *p,
const char *name,
const char *val);
20580magic_comment_encoding(
struct parser_params *p,
const char *name,
const char *val)
20582 if (!comment_at_top(p)) {
20585 parser_set_encode(p, val);
20589parser_get_bool(
struct parser_params *p,
const char *name,
const char *val)
20592 case 't':
case 'T':
20597 case 'f':
case 'F':
20603 return parser_invalid_pragma_value(p, name, val);
20607parser_invalid_pragma_value(
struct parser_params *p,
const char *name,
const char *val)
20609 rb_warning2(
"invalid value for %s: %s", WARN_S(name), WARN_S(val));
20614parser_set_token_info(
struct parser_params *p,
const char *name,
const char *val)
20616 int b = parser_get_bool(p, name, val);
20617 if (b >= 0) p->token_info_enabled = b;
20621parser_set_frozen_string_literal(
struct parser_params *p,
const char *name,
const char *val)
20625 if (p->token_seen) {
20626 rb_warning1(
"'%s' is ignored after any tokens", WARN_S(name));
20630 b = parser_get_bool(p, name, val);
20633 p->frozen_string_literal = b;
20637parser_set_shareable_constant_value(
struct parser_params *p,
const char *name,
const char *val)
20639 for (
const char *s = p->lex.pbeg, *e = p->lex.pcur; s < e; ++s) {
20640 if (*s ==
' ' || *s ==
'\t')
continue;
20641 if (*s ==
'#')
break;
20642 rb_warning1(
"'%s' is ignored unless in comment-only line", WARN_S(name));
20647 case 'n':
case 'N':
20649 p->ctxt.shareable_constant_value = rb_parser_shareable_none;
20653 case 'l':
case 'L':
20655 p->ctxt.shareable_constant_value = rb_parser_shareable_literal;
20659 case 'e':
case 'E':
20660 if (
STRCASECMP(val,
"experimental_copy") == 0) {
20661 p->ctxt.shareable_constant_value = rb_parser_shareable_copy;
20664 if (
STRCASECMP(val,
"experimental_everything") == 0) {
20665 p->ctxt.shareable_constant_value = rb_parser_shareable_everything;
20670 parser_invalid_pragma_value(p, name, val);
20673# if WARN_PAST_SCOPE
20675parser_set_past_scope(
struct parser_params *p,
const char *name,
const char *val)
20677 int b = parser_get_bool(p, name, val);
20678 if (b >= 0) p->past_scope_enabled = b;
20684 rb_magic_comment_setter_t func;
20685 rb_magic_comment_length_t length;
20689 {
"coding", magic_comment_encoding, parser_encode_length},
20690 {
"encoding", magic_comment_encoding, parser_encode_length},
20691 {
"frozen_string_literal", parser_set_frozen_string_literal},
20692 {
"shareable_constant_value", parser_set_shareable_constant_value},
20693 {
"warn_indent", parser_set_token_info},
20694# if WARN_PAST_SCOPE
20695 {
"warn_past_scope", parser_set_past_scope},
20700magic_comment_marker(
const char *str,
long len)
20707 if (str[i-1] ==
'*' && str[i-2] ==
'-') {
20708 return str + i + 1;
20713 if (i + 1 >=
len)
return 0;
20714 if (str[i+1] !=
'-') {
20717 else if (str[i-1] !=
'-') {
20721 return str + i + 2;
20736 VALUE name = 0, val = 0;
20737 const char *beg, *end, *vbeg, *vend;
20738#define str_copy(_s, _p, _n) ((_s) \
20739 ? (void)(rb_str_resize((_s), (_n)), \
20740 MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
20741 : (void)((_s) = STR_NEW((_p), (_n))))
20743 if (
len <= 7)
return FALSE;
20744 if (!!(beg = magic_comment_marker(str,
len))) {
20745 if (!(end = magic_comment_marker(beg, str +
len - beg)))
20749 len = end - beg - 3;
20759 for (;
len > 0 && *str; str++, --
len) {
20761 case '\'':
case '"':
case ':':
case ';':
20766 for (beg = str;
len > 0; str++, --
len) {
20768 case '\'':
case '"':
case ':':
case ';':
20779 if (!indicator)
return FALSE;
20783 do str++;
while (--
len > 0 &&
ISSPACE(*str));
20785 const char *tok_beg = str;
20787 for (vbeg = ++str; --
len > 0 && *str !=
'"'; str++) {
20788 if (*str ==
'\\') {
20800 for (vbeg = str;
len > 0 && *str !=
'"' && *str !=
';' && !
ISSPACE(*str); --
len, str++);
20803 const char *tok_end = str;
20805 while (
len > 0 && (*str ==
';' ||
ISSPACE(*str))) --
len, str++;
20809 if (
len)
return FALSE;
20813 str_copy(name, beg, n);
20814 s = RSTRING_PTR(name);
20815 for (i = 0; i < n; ++i) {
20816 if (s[i] ==
'-') s[i] =
'_';
20819 if (
STRNCASECMP(mc->name, s, n) == 0 && !mc->name[n]) {
20822 n = (*mc->length)(p, vbeg, n);
20824 str_copy(val, vbeg, n);
20825 p->lex.ptok = tok_beg;
20826 p->lex.pcur = tok_end;
20827 (*mc->func)(p, mc->name, RSTRING_PTR(val));
20830 }
while (++mc < magic_comments + numberof(magic_comments));
20832 str_copy(val, vbeg, vend - vbeg);
20841set_file_encoding(
struct parser_params *p,
const char *str,
const char *send)
20844 const char *beg = str;
20848 if (send - str <= 6)
return;
20850 case 'C':
case 'c': str += 6;
continue;
20851 case 'O':
case 'o': str += 5;
continue;
20852 case 'D':
case 'd': str += 4;
continue;
20853 case 'I':
case 'i': str += 3;
continue;
20854 case 'N':
case 'n': str += 2;
continue;
20855 case 'G':
case 'g': str += 1;
continue;
20856 case '=':
case ':':
20870 if (++str >= send)
return;
20873 if (*str !=
'=' && *str !=
':')
return;
20878 while ((*str ==
'-' || *str ==
'_' ||
ISALNUM(*str)) && ++str < send);
20879 s =
rb_str_new(beg, parser_encode_length(p, beg, str - beg));
20882 parser_set_encode(p, RSTRING_PTR(s));
20883 rb_str_resize(s, 0);
20889 int c = nextc0(p, FALSE);
20893 if (peek(p,
'!')) p->has_shebang = 1;
20896 if (!lex_eol_n_p(p, 2) &&
20897 (
unsigned char)p->lex.pcur[0] == 0xbb &&
20898 (
unsigned char)p->lex.pcur[1] == 0xbf) {
20899 p->enc = rb_utf8_encoding();
20902 if (p->debug_lines) {
20903 rb_parser_string_set_encoding(p->lex.lastline, p->enc);
20906 p->lex.pbeg = p->lex.pcur;
20915 p->enc = rb_parser_str_get_encoding(p->lex.lastline);
20919#define ambiguous_operator(tok, op, syn) ( \
20920 rb_warning0("'"op"' after local variable or literal is interpreted as binary operator"), \
20921 rb_warning0("even though it seems like "syn""))
20923#define ambiguous_operator(tok, op, syn) \
20924 dispatch2(operator_ambiguous, TOKEN2VAL(tok), rb_str_new_cstr(syn))
20926#define warn_balanced(tok, op, syn) ((void) \
20927 (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN) && \
20928 space_seen && !ISSPACE(c) && \
20929 (ambiguous_operator(tok, op, syn), 0)), \
20930 (enum yytokentype)(tok))
20932static enum yytokentype
20935 yyerror0(
"numeric literal without digits");
20936 if (peek(p,
'_')) nextc(p);
20938 return set_number_literal(p, tINTEGER, 0, 10, 0);
20941static enum yytokentype
20944 int is_float, seen_point, seen_e, nondigit;
20947 is_float = seen_point = seen_e = nondigit = 0;
20948 SET_LEX_STATE(EXPR_END);
20950 if (c ==
'-' || c ==
'+') {
20955 int start = toklen(p);
20957 if (c ==
'x' || c ==
'X') {
20963 if (nondigit)
break;
20970 }
while ((c = nextc(p)) != -1);
20974 if (toklen(p) == start) {
20975 return no_digits(p);
20977 else if (nondigit)
goto trailing_uc;
20978 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
20979 return set_number_literal(p, tINTEGER, suffix, 16, 0);
20981 if (c ==
'b' || c ==
'B') {
20984 if (c ==
'0' || c ==
'1') {
20987 if (nondigit)
break;
20991 if (c !=
'0' && c !=
'1')
break;
20994 }
while ((c = nextc(p)) != -1);
20998 if (toklen(p) == start) {
20999 return no_digits(p);
21001 else if (nondigit)
goto trailing_uc;
21002 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
21003 return set_number_literal(p, tINTEGER, suffix, 2, 0);
21005 if (c ==
'd' || c ==
'D') {
21011 if (nondigit)
break;
21018 }
while ((c = nextc(p)) != -1);
21022 if (toklen(p) == start) {
21023 return no_digits(p);
21025 else if (nondigit)
goto trailing_uc;
21026 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
21027 return set_number_literal(p, tINTEGER, suffix, 10, 0);
21033 if (c ==
'o' || c ==
'O') {
21036 if (c == -1 || c ==
'_' || !
ISDIGIT(c)) {
21038 return no_digits(p);
21041 if (c >=
'0' && c <=
'7') {
21046 if (nondigit)
break;
21050 if (c <
'0' || c >
'9')
break;
21051 if (c >
'7')
goto invalid_octal;
21054 }
while ((c = nextc(p)) != -1);
21055 if (toklen(p) > start) {
21058 if (nondigit)
goto trailing_uc;
21059 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
21060 return set_number_literal(p, tINTEGER, suffix, 8, 0);
21067 if (c >
'7' && c <=
'9') {
21069 yyerror0(
"Invalid octal digit");
21071 else if (c ==
'.' || c ==
'e' || c ==
'E') {
21077 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
21078 return set_number_literal(p, tINTEGER, suffix, 10, 0);
21084 case '0':
case '1':
case '2':
case '3':
case '4':
21085 case '5':
case '6':
case '7':
case '8':
case '9':
21091 if (nondigit)
goto trailing_uc;
21092 if (seen_point || seen_e) {
21097 if (c0 == -1 || !
ISDIGIT(c0)) {
21103 seen_point = toklen(p);
21122 if (c !=
'-' && c !=
'+' && !
ISDIGIT(c)) {
21128 tokadd(p, nondigit);
21132 nondigit = (c ==
'-' || c ==
'+') ? c : 0;
21136 if (nondigit)
goto decode_num;
21150 literal_flush(p, p->lex.pcur - 1);
21151 YYLTYPE loc = RUBY_INIT_YYLLOC();
21152 compile_error(p,
"trailing '%c' in number", nondigit);
21153 parser_show_error_line(p, &loc);
21157 enum yytokentype
type = tFLOAT;
21159 suffix = number_literal_suffix(p, seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
21160 if (suffix & NUM_SUFFIX_R) {
21165 if (
errno == ERANGE) {
21166 rb_warning1(
"Float %s out of range", WARN_S(tok(p)));
21170 return set_number_literal(p,
type, suffix, 0, seen_point);
21172 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
21173 return set_number_literal(p, tINTEGER, suffix, 10, 0);
21176static enum yytokentype
21182 const char *start = p->lex.pcur;
21185 SET_LEX_STATE(EXPR_VALUE);
21190 compile_error(p,
"incomplete character syntax");
21193 if (rb_enc_isspace(c, p->enc)) {
21195 int c2 = escaped_control_code(c);
21197 WARN_SPACE_CHAR(c2,
"?");
21202 SET_LEX_STATE(EXPR_VALUE);
21207 int w = parser_precise_mbclen(p, start);
21208 if (is_identchar(p, start, p->lex.pend, p->enc) &&
21209 !(lex_eol_ptr_n_p(p, start, w) || !is_identchar(p, start + w, p->lex.pend, p->enc))) {
21211 const char *ptr = start;
21213 int n = parser_precise_mbclen(p, ptr);
21214 if (n < 0)
return -1;
21216 }
while (!lex_eol_ptr_p(p, ptr) && is_identchar(p, ptr, p->lex.pend, p->enc));
21217 rb_warn2(
"'?' just followed by '%.*s' is interpreted as" \
21218 " a conditional operator, put a space after '?'",
21219 WARN_I((
int)(ptr - start)), WARN_S_L(start, (ptr - start)));
21223 else if (c ==
'\\') {
21224 if (peek(p,
'u')) {
21226 enc = rb_utf8_encoding();
21227 tokadd_utf8(p, &enc, -1, 0, 0);
21229 else if (!
ISASCII(c = peekc(p)) && c != -1) {
21231 if (tokadd_mbchar(p, c) == -1)
return 0;
21239 if (tokadd_mbchar(p, c) == -1)
return 0;
21242 lit = STR_NEW3(tok(p), toklen(p), enc, 0);
21243 set_yylval_str(lit);
21244 SET_LEX_STATE(EXPR_END);
21248static enum yytokentype
21249parse_percent(
struct parser_params *p,
const int space_seen,
const enum lex_state_e last_state)
21252 const char *ptok = p->lex.pcur;
21260 if (c == -1)
goto unterminated;
21263 if (!
ISASCII(c))
goto unknown;
21268 if (rb_enc_isalnum(term, p->enc) || !parser_isascii(p)) {
21271 c = parser_precise_mbclen(p, p->lex.pcur);
21272 if (c < 0)
return 0;
21274 yyerror0(
"unknown type of %string");
21280 compile_error(p,
"unterminated quoted string meets end of file");
21284 if (term ==
'(') term =
')';
21285 else if (term ==
'[') term =
']';
21286 else if (term ==
'{') term =
'}';
21287 else if (term ==
'<') term =
'>';
21290 p->lex.ptok = ptok-1;
21293 p->lex.strterm = NEW_STRTERM(str_dquote, term, paren);
21294 return tSTRING_BEG;
21297 p->lex.strterm = NEW_STRTERM(str_squote, term, paren);
21298 return tSTRING_BEG;
21301 p->lex.strterm = NEW_STRTERM(str_dword, term, paren);
21305 p->lex.strterm = NEW_STRTERM(str_sword, term, paren);
21306 return tQWORDS_BEG;
21309 p->lex.strterm = NEW_STRTERM(str_dword, term, paren);
21310 return tSYMBOLS_BEG;
21313 p->lex.strterm = NEW_STRTERM(str_sword, term, paren);
21314 return tQSYMBOLS_BEG;
21317 p->lex.strterm = NEW_STRTERM(str_xquote, term, paren);
21318 return tXSTRING_BEG;
21321 p->lex.strterm = NEW_STRTERM(str_regexp, term, paren);
21322 return tREGEXP_BEG;
21325 p->lex.strterm = NEW_STRTERM(str_ssym, term, paren);
21326 SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);
21330 yyerror0(
"unknown type of %string");
21334 if ((c = nextc(p)) ==
'=') {
21335 set_yylval_id(
'%');
21336 SET_LEX_STATE(EXPR_BEG);
21339 if (IS_SPCARG(c) || (IS_lex_state(EXPR_FITEM) && c ==
's')) {
21342 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
21344 return warn_balanced(
'%',
"%%",
"string literal");
21351 if (tokadd_mbchar(p, c) == -1)
return -1;
21353 }
while (parser_is_identchar(p));
21361 ID ident = TOK_INTERN();
21363 set_yylval_name(ident);
21373 unsigned long n = ruby_scan_digits(tok(p)+1, toklen(p)-1, 10, &
len, &overflow);
21374 const unsigned long nth_ref_max =
21375 ((FIXNUM_MAX < INT_MAX) ? FIXNUM_MAX : INT_MAX) >> 1;
21379 if (overflow || n > nth_ref_max) {
21381 rb_warn1(
"'%s' is too big for a number variable, always nil", WARN_S(tok(p)));
21389static enum yytokentype
21390parse_gvar(
struct parser_params *p,
const enum lex_state_e last_state)
21392 const char *ptr = p->lex.pcur;
21395 SET_LEX_STATE(EXPR_END);
21396 p->lex.ptok = ptr - 1;
21402 if (parser_is_identchar(p)) {
21434 if (parser_is_identchar(p)) {
21435 if (tokadd_mbchar(p, c) == -1)
return 0;
21450 if (IS_lex_state_for(last_state, EXPR_FNAME)) {
21455 set_yylval_node(NEW_BACK_REF(c, &_cur_loc));
21458 case '1':
case '2':
case '3':
21459 case '4':
case '5':
case '6':
21460 case '7':
case '8':
case '9':
21465 }
while (c != -1 &&
ISDIGIT(c));
21467 if (IS_lex_state_for(last_state, EXPR_FNAME))
goto gvar;
21469 c = parse_numvar(p);
21470 set_yylval_node(NEW_NTH_REF(c, &_cur_loc));
21474 if (!parser_is_identchar(p)) {
21475 YYLTYPE loc = RUBY_INIT_YYLLOC();
21477 compile_error(p,
"'$' without identifiers is not allowed as a global variable name");
21481 compile_error(p,
"'$%c' is not allowed as a global variable name", c);
21483 parser_show_error_line(p, &loc);
21484 set_yylval_noname();
21492 if (tokadd_ident(p, c))
return 0;
21493 SET_LEX_STATE(EXPR_END);
21494 if (VALID_SYMNAME_P(tok(p), toklen(p), p->enc, ID_GLOBAL)) {
21498 compile_error(p,
"'%.*s' is not allowed as a global variable name", toklen(p), tok(p));
21499 set_yylval_noname();
21507 if (n < 0)
return false;
21509 if (DVARS_TERMINAL_P(p->lvtbl->args) || DVARS_TERMINAL_P(p->lvtbl->args->prev)) {
21512 if (p->max_numparam == ORDINAL_PARAM) {
21513 compile_error(p,
"ordinary parameter is defined");
21516 struct vtable *args = p->lvtbl->args;
21517 if (p->max_numparam < n) {
21518 p->max_numparam = n;
21520 while (n > args->pos) {
21521 vtable_add(args, NUMPARAM_IDX_TO_ID(args->pos+1));
21526static enum yytokentype
21527parse_atmark(
struct parser_params *p,
const enum lex_state_e last_state)
21529 const char *ptr = p->lex.pcur;
21530 enum yytokentype result = tIVAR;
21531 register int c = nextc(p);
21534 p->lex.ptok = ptr - 1;
21542 SET_LEX_STATE(IS_lex_state_for(last_state, EXPR_FNAME) ? EXPR_ENDFN : EXPR_END);
21543 if (c == -1 || !parser_is_identchar(p)) {
21545 RUBY_SET_YYLLOC(loc);
21546 if (result == tIVAR) {
21547 compile_error(p,
"'@' without identifiers is not allowed as an instance variable name");
21550 compile_error(p,
"'@@' without identifiers is not allowed as a class variable name");
21552 parser_show_error_line(p, &loc);
21553 set_yylval_noname();
21554 SET_LEX_STATE(EXPR_END);
21559 RUBY_SET_YYLLOC(loc);
21560 if (result == tIVAR) {
21561 compile_error(p,
"'@%c' is not allowed as an instance variable name", c);
21564 compile_error(p,
"'@@%c' is not allowed as a class variable name", c);
21566 parser_show_error_line(p, &loc);
21567 set_yylval_noname();
21568 SET_LEX_STATE(EXPR_END);
21572 if (tokadd_ident(p, c))
return 0;
21577static enum yytokentype
21580 enum yytokentype result;
21581 bool is_ascii =
true;
21582 const enum lex_state_e last_state = p->lex.state;
21584 int enforce_keyword_end = 0;
21587 if (!
ISASCII(c)) is_ascii =
false;
21588 if (tokadd_mbchar(p, c) == -1)
return 0;
21590 }
while (parser_is_identchar(p));
21591 if ((c ==
'!' || c ==
'?') && !peek(p,
'=')) {
21595 else if (c ==
'=' && IS_lex_state(EXPR_FNAME) &&
21596 (!peek(p,
'~') && !peek(p,
'>') && (!peek(p,
'=') || (peek_n(p,
'>', 1))))) {
21597 result = tIDENTIFIER;
21601 result = tCONSTANT;
21606 if (IS_LABEL_POSSIBLE()) {
21607 if (IS_LABEL_SUFFIX(0)) {
21608 SET_LEX_STATE(EXPR_ARG|EXPR_LABELED);
21616 if (peek_end_expect_token_locations(p)) {
21618 int lineno, column;
21619 int beg_pos = (int)(p->lex.ptok - p->lex.pbeg);
21621 end_pos = peek_end_expect_token_locations(p)->pos;
21622 lineno = end_pos->lineno;
21623 column = end_pos->column;
21626 rb_parser_printf(p,
"enforce_keyword_end check. current: (%d, %d), peek: (%d, %d)\n",
21627 p->ruby_sourceline, beg_pos, lineno, column);
21630 if ((p->ruby_sourceline > lineno) && (beg_pos <= column)) {
21633 if ((IS_lex_state(EXPR_DOT)) && (kw = rb_reserved_word(tok(p), toklen(p))) && (kw && kw->id[0] == keyword_end)) {
21634 if (p->debug) rb_parser_printf(p,
"enforce_keyword_end is enabled\n");
21635 enforce_keyword_end = 1;
21641 if (is_ascii && (!IS_lex_state(EXPR_DOT) || enforce_keyword_end)) {
21645 kw = rb_reserved_word(tok(p), toklen(p));
21647 enum lex_state_e state = p->lex.state;
21648 if (IS_lex_state_for(state, EXPR_FNAME)) {
21649 SET_LEX_STATE(EXPR_ENDFN);
21650 set_yylval_name(rb_intern2(tok(p), toklen(p)));
21653 SET_LEX_STATE(kw->state);
21654 if (IS_lex_state(EXPR_BEG)) {
21655 p->command_start = TRUE;
21657 if (kw->id[0] == keyword_do) {
21658 if (lambda_beginning_p()) {
21659 p->lex.lpar_beg = -1;
21660 return keyword_do_LAMBDA;
21662 if (COND_P())
return keyword_do_cond;
21663 if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
21664 return keyword_do_block;
21667 if (IS_lex_state_for(state, (EXPR_BEG | EXPR_LABELED | EXPR_CLASS)))
21670 if (kw->id[0] != kw->id[1])
21671 SET_LEX_STATE(EXPR_BEG | EXPR_LABEL);
21677 if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
21679 SET_LEX_STATE(EXPR_CMDARG);
21682 SET_LEX_STATE(EXPR_ARG);
21685 else if (p->lex.state == EXPR_FNAME) {
21686 SET_LEX_STATE(EXPR_ENDFN);
21689 SET_LEX_STATE(EXPR_END);
21692 ident = tokenize_ident(p);
21693 if (result == tCONSTANT && is_local_id(ident)) result = tIDENTIFIER;
21694 if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
21695 (result == tIDENTIFIER) &&
21696 (lvar_defined(p, ident) || NUMPARAM_ID_P(ident))) {
21697 SET_LEX_STATE(EXPR_END|EXPR_LABEL);
21708 rb_warn0(
"encountered \\r in middle of line, treated as a mere space");
21712static enum yytokentype
21716 int space_seen = 0;
21719 enum lex_state_e last_state;
21720 int fallthru = FALSE;
21721 int token_seen = p->token_seen;
21723 if (p->lex.strterm) {
21724 if (strterm_is_heredoc(p->lex.strterm)) {
21726 return here_document(p, &p->lex.strterm->u.heredoc);
21730 return parse_string(p, &p->lex.strterm->u.literal);
21733 cmd_state = p->command_start;
21734 p->command_start = FALSE;
21735 p->token_seen = TRUE;
21740 last_state = p->lex.state;
21741 switch (c = nextc(p)) {
21748 if (p->end_expect_token_locations) {
21749 pop_end_expect_token_locations(p);
21750 RUBY_SET_YYLLOC_OF_DUMMY_END(*p->yylloc);
21755 RUBY_SET_YYLLOC(*p->yylloc);
21756 return END_OF_INPUT;
21762 case ' ':
case '\t':
case '\f':
21765 while ((c = nextc(p))) {
21770 case ' ':
case '\t':
case '\f':
21779 dispatch_scan_event(p, tSP);
21786 p->token_seen = token_seen;
21787 const char *
const pcur = p->lex.pcur, *
const ptok = p->lex.ptok;
21789 if (!parser_magic_comment(p, p->lex.pcur, p->lex.pend - p->lex.pcur)) {
21790 if (comment_at_top(p)) {
21791 set_file_encoding(p, p->lex.pcur, p->lex.pend);
21794 p->lex.pcur = pcur, p->lex.ptok = ptok;
21796 dispatch_scan_event(p, tCOMMENT);
21800 p->token_seen = token_seen;
21802 c = (IS_lex_state(EXPR_BEG|EXPR_CLASS|EXPR_FNAME|EXPR_DOT) &&
21803 !IS_lex_state(EXPR_LABELED));
21804 if (c || IS_lex_state_all(EXPR_ARG|EXPR_LABELED)) {
21806 dispatch_scan_event(p, tIGNORED_NL);
21809 if (!c && p->ctxt.in_kwarg) {
21810 goto normal_newline;
21815 switch (c = nextc(p)) {
21816 case ' ':
case '\t':
case '\f':
case '\r':
21823 dispatch_scan_event(p, tSP);
21829 dispatch_delayed_token(p, tIGNORED_NL);
21830 if (peek(p,
'.') == (c ==
'&')) {
21832 dispatch_scan_event(p, tSP);
21837 p->ruby_sourceline--;
21838 p->lex.nextline = p->lex.lastline;
21839 set_lastline(p, prevline);
21841 if (c == -1 && space_seen) {
21842 dispatch_scan_event(p, tSP);
21847 RUBY_SET_YYLLOC(*p->yylloc);
21849 goto normal_newline;
21853 p->command_start = TRUE;
21854 SET_LEX_STATE(EXPR_BEG);
21858 if ((c = nextc(p)) ==
'*') {
21859 if ((c = nextc(p)) ==
'=') {
21860 set_yylval_id(idPow);
21861 SET_LEX_STATE(EXPR_BEG);
21865 if (IS_SPCARG(c)) {
21866 rb_warning0(
"'**' interpreted as argument prefix");
21869 else if (IS_BEG()) {
21873 c = warn_balanced((
enum ruby_method_ids)tPOW,
"**",
"argument prefix");
21878 set_yylval_id(
'*');
21879 SET_LEX_STATE(EXPR_BEG);
21883 if (IS_SPCARG(c)) {
21884 rb_warning0(
"'*' interpreted as argument prefix");
21887 else if (IS_BEG()) {
21891 c = warn_balanced(
'*',
"*",
"argument prefix");
21894 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
21899 if (IS_AFTER_OPERATOR()) {
21900 SET_LEX_STATE(EXPR_ARG);
21906 SET_LEX_STATE(EXPR_BEG);
21920 if (word_match_p(p,
"begin", 5)) {
21921 int first_p = TRUE;
21924 dispatch_scan_event(p, tEMBDOC_BEG);
21928 dispatch_scan_event(p, tEMBDOC);
21933 compile_error(p,
"embedded document meets end of file");
21934 return END_OF_INPUT;
21936 if (c ==
'=' && word_match_p(p,
"end", 3)) {
21942 dispatch_scan_event(p, tEMBDOC_END);
21947 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
21948 if ((c = nextc(p)) ==
'=') {
21949 if ((c = nextc(p)) ==
'=') {
21958 else if (c ==
'>') {
21967 !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
21969 (!IS_ARG() || IS_lex_state(EXPR_LABELED) || space_seen)) {
21970 enum yytokentype token = heredoc_identifier(p);
21971 if (token)
return token < 0 ? 0 : token;
21973 if (IS_AFTER_OPERATOR()) {
21974 SET_LEX_STATE(EXPR_ARG);
21977 if (IS_lex_state(EXPR_CLASS))
21978 p->command_start = TRUE;
21979 SET_LEX_STATE(EXPR_BEG);
21982 if ((c = nextc(p)) ==
'>') {
21989 if ((c = nextc(p)) ==
'=') {
21990 set_yylval_id(idLTLT);
21991 SET_LEX_STATE(EXPR_BEG);
21995 return warn_balanced((
enum ruby_method_ids)tLSHFT,
"<<",
"here document");
22001 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
22002 if ((c = nextc(p)) ==
'=') {
22006 if ((c = nextc(p)) ==
'=') {
22007 set_yylval_id(idGTGT);
22008 SET_LEX_STATE(EXPR_BEG);
22018 label = (IS_LABEL_POSSIBLE() ? str_label : 0);
22019 p->lex.strterm = NEW_STRTERM(str_dquote | label,
'"', 0);
22020 p->lex.ptok = p->lex.pcur-1;
22021 return tSTRING_BEG;
22024 if (IS_lex_state(EXPR_FNAME)) {
22025 SET_LEX_STATE(EXPR_ENDFN);
22028 if (IS_lex_state(EXPR_DOT)) {
22030 SET_LEX_STATE(EXPR_CMDARG);
22032 SET_LEX_STATE(EXPR_ARG);
22035 p->lex.strterm = NEW_STRTERM(str_xquote,
'`', 0);
22036 return tXSTRING_BEG;
22039 label = (IS_LABEL_POSSIBLE() ? str_label : 0);
22040 p->lex.strterm = NEW_STRTERM(str_squote | label,
'\'', 0);
22041 p->lex.ptok = p->lex.pcur-1;
22042 return tSTRING_BEG;
22045 return parse_qmark(p, space_seen);
22048 if ((c = nextc(p)) ==
'&') {
22049 SET_LEX_STATE(EXPR_BEG);
22050 if ((c = nextc(p)) ==
'=') {
22051 set_yylval_id(idANDOP);
22052 SET_LEX_STATE(EXPR_BEG);
22058 else if (c ==
'=') {
22059 set_yylval_id(
'&');
22060 SET_LEX_STATE(EXPR_BEG);
22063 else if (c ==
'.') {
22064 set_yylval_id(idANDDOT);
22065 SET_LEX_STATE(EXPR_DOT);
22069 if (IS_SPCARG(c)) {
22071 (c = peekc_n(p, 1)) == -1 ||
22072 !(c ==
'\'' || c ==
'"' ||
22073 is_identchar(p, (p->lex.pcur+1), p->lex.pend, p->enc))) {
22074 rb_warning0(
"'&' interpreted as argument prefix");
22078 else if (IS_BEG()) {
22082 c = warn_balanced(
'&',
"&",
"argument prefix");
22084 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
22088 if ((c = nextc(p)) ==
'|') {
22089 SET_LEX_STATE(EXPR_BEG);
22090 if ((c = nextc(p)) ==
'=') {
22091 set_yylval_id(idOROP);
22092 SET_LEX_STATE(EXPR_BEG);
22096 if (IS_lex_state_for(last_state, EXPR_BEG)) {
22104 set_yylval_id(
'|');
22105 SET_LEX_STATE(EXPR_BEG);
22108 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG|EXPR_LABEL);
22114 if (IS_AFTER_OPERATOR()) {
22115 SET_LEX_STATE(EXPR_ARG);
22123 set_yylval_id(
'+');
22124 SET_LEX_STATE(EXPR_BEG);
22127 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p,
'+'))) {
22128 SET_LEX_STATE(EXPR_BEG);
22131 return parse_numeric(p,
'+');
22135 SET_LEX_STATE(EXPR_BEG);
22137 return warn_balanced(
'+',
"+",
"unary operator");
22141 if (IS_AFTER_OPERATOR()) {
22142 SET_LEX_STATE(EXPR_ARG);
22150 set_yylval_id(
'-');
22151 SET_LEX_STATE(EXPR_BEG);
22155 SET_LEX_STATE(EXPR_ENDFN);
22156 yylval.num = p->lex.lpar_beg;
22157 p->lex.lpar_beg = p->lex.paren_nest;
22160 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p,
'-'))) {
22161 SET_LEX_STATE(EXPR_BEG);
22164 return tUMINUS_NUM;
22168 SET_LEX_STATE(EXPR_BEG);
22170 return warn_balanced(
'-',
"-",
"unary operator");
22173 int is_beg = IS_BEG();
22174 SET_LEX_STATE(EXPR_BEG);
22175 if ((c = nextc(p)) ==
'.') {
22176 if ((c = nextc(p)) ==
'.') {
22177 if (p->ctxt.in_argdef || IS_LABEL_POSSIBLE()) {
22178 SET_LEX_STATE(EXPR_ENDARG);
22181 if (p->lex.paren_nest == 0 && looking_at_eol_p(p)) {
22182 rb_warn0(
"... at EOL, should be parenthesized?");
22184 return is_beg ? tBDOT3 : tDOT3;
22187 return is_beg ? tBDOT2 : tDOT2;
22191 char prev = p->lex.pcur-1 > p->lex.pbeg ? *(p->lex.pcur-2) : 0;
22192 parse_numeric(p,
'.');
22194 yyerror0(
"unexpected fraction part after numeric literal");
22197 yyerror0(
"no .<digit> floating literal anymore; put 0 before dot");
22199 SET_LEX_STATE(EXPR_END);
22200 p->lex.ptok = p->lex.pcur;
22203 set_yylval_id(
'.');
22204 SET_LEX_STATE(EXPR_DOT);
22208 case '0':
case '1':
case '2':
case '3':
case '4':
22209 case '5':
case '6':
case '7':
case '8':
case '9':
22210 return parse_numeric(p, c);
22215 SET_LEX_STATE(EXPR_ENDFN);
22216 p->lex.paren_nest--;
22222 SET_LEX_STATE(EXPR_END);
22223 p->lex.paren_nest--;
22228 if (!p->lex.brace_nest--)
return tSTRING_DEND;
22231 SET_LEX_STATE(EXPR_END);
22232 p->lex.paren_nest--;
22238 if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
22239 SET_LEX_STATE(EXPR_BEG);
22242 set_yylval_id(idCOLON2);
22243 SET_LEX_STATE(EXPR_DOT);
22246 if (IS_END() ||
ISSPACE(c) || c ==
'#') {
22248 c = warn_balanced(
':',
":",
"symbol literal");
22249 SET_LEX_STATE(EXPR_BEG);
22254 p->lex.strterm = NEW_STRTERM(str_ssym, c, 0);
22257 p->lex.strterm = NEW_STRTERM(str_dsym, c, 0);
22263 SET_LEX_STATE(EXPR_FNAME);
22268 p->lex.strterm = NEW_STRTERM(str_regexp,
'/', 0);
22269 return tREGEXP_BEG;
22271 if ((c = nextc(p)) ==
'=') {
22272 set_yylval_id(
'/');
22273 SET_LEX_STATE(EXPR_BEG);
22277 if (IS_SPCARG(c)) {
22278 arg_ambiguous(p,
'/');
22279 p->lex.strterm = NEW_STRTERM(str_regexp,
'/', 0);
22280 return tREGEXP_BEG;
22282 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
22283 return warn_balanced(
'/',
"/",
"regexp literal");
22286 if ((c = nextc(p)) ==
'=') {
22287 set_yylval_id(
'^');
22288 SET_LEX_STATE(EXPR_BEG);
22291 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
22296 SET_LEX_STATE(EXPR_BEG);
22297 p->command_start = TRUE;
22301 SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
22305 if (IS_AFTER_OPERATOR()) {
22306 if ((c = nextc(p)) !=
'@') {
22309 SET_LEX_STATE(EXPR_ARG);
22312 SET_LEX_STATE(EXPR_BEG);
22320 else if (!space_seen) {
22323 else if (IS_ARG() || IS_lex_state_all(EXPR_END|EXPR_LABEL)) {
22326 else if (IS_lex_state(EXPR_ENDFN) && !lambda_beginning_p()) {
22327 rb_warning0(
"parentheses after method name is interpreted as "
22328 "an argument list, not a decomposed argument");
22330 p->lex.paren_nest++;
22333 SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
22337 p->lex.paren_nest++;
22338 if (IS_AFTER_OPERATOR()) {
22339 if ((c = nextc(p)) ==
']') {
22340 p->lex.paren_nest--;
22341 SET_LEX_STATE(EXPR_ARG);
22342 if ((c = nextc(p)) ==
'=') {
22349 SET_LEX_STATE(EXPR_ARG|EXPR_LABEL);
22352 else if (IS_BEG()) {
22355 else if (IS_ARG() && (space_seen || IS_lex_state(EXPR_LABELED))) {
22358 SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
22364 ++p->lex.brace_nest;
22365 if (lambda_beginning_p())
22367 else if (IS_lex_state(EXPR_LABELED))
22369 else if (IS_lex_state(EXPR_ARG_ANY | EXPR_END | EXPR_ENDFN))
22371 else if (IS_lex_state(EXPR_ENDARG))
22375 if (c != tLBRACE) {
22376 p->command_start = TRUE;
22377 SET_LEX_STATE(EXPR_BEG);
22380 SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
22382 ++p->lex.paren_nest;
22391 dispatch_scan_event(p, tSP);
22394 if (c ==
' ')
return tSP;
22400 return parse_percent(p, space_seen, last_state);
22403 return parse_gvar(p, last_state);
22406 return parse_atmark(p, last_state);
22409 if (was_bol(p) && whole_match_p(p,
"__END__", 7, 0)) {
22410 p->ruby__end__seen = 1;
22414 dispatch_scan_event(p, k__END__);
22416 return END_OF_INPUT;
22422 if (!parser_is_identchar(p)) {
22423 compile_error(p,
"Invalid char '\\x%02X' in expression", c);
22432 return parse_ident(p, c, cmd_state);
22435static enum yytokentype
22438 enum yytokentype t;
22442 p->yylloc = yylloc;
22444 t = parser_yylex(p);
22446 if (has_delayed_token(p))
22447 dispatch_delayed_token(p, t);
22448 else if (t != END_OF_INPUT)
22449 dispatch_scan_event(p, t);
22454#define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
22457node_new_internal(
struct parser_params *p,
enum node_type
type,
size_t size,
size_t alignment)
22459 NODE *n = rb_ast_newnode(p->ast,
type, size, alignment);
22461 rb_node_init(n,
type);
22469 nd_set_line(nd, loc->beg_pos.lineno);
22476 NODE *n = node_new_internal(p,
type, size, alignment);
22478 nd_set_loc(n, loc);
22479 nd_set_node_id(n, parser_get_node_id(p));
22483#define NODE_NEWNODE(node_type, type, loc) (type *)(node_newnode(p, node_type, sizeof(type), RUBY_ALIGNOF(type), loc))
22489 nd_tbl = local_tbl(p);
22491 n->nd_tbl = nd_tbl;
22492 n->nd_body = nd_body;
22493 n->nd_args = nd_args;
22502 n->nd_tbl = nd_tbl;
22503 n->nd_body = nd_body;
22504 n->nd_args = nd_args;
22513 n->nd_mid = nd_mid;
22514 n->nd_defn = nd_defn;
22523 n->nd_recv = nd_recv;
22524 n->nd_mid = nd_mid;
22525 n->nd_defn = nd_defn;
22534 n->nd_head = nd_head;
22535 n->nd_end = (
NODE *)n;
22545 n->nd_body = nd_body;
22546 n->nd_iter = nd_iter;
22547 n->for_keyword_loc = *for_keyword_loc;
22548 n->in_keyword_loc = *in_keyword_loc;
22549 n->do_keyword_loc = *do_keyword_loc;
22550 n->end_keyword_loc = *end_keyword_loc;
22559 n->nd_var = nd_var;
22576 n->nd_body = nd_body;
22585 n->nd_head = nd_head;
22586 n->nd_resq = nd_resq;
22587 n->nd_else = nd_else;
22596 n->nd_args = nd_args;
22597 n->nd_exc_var = nd_exc_var;
22598 n->nd_body = nd_body;
22599 n->nd_next = nd_next;
22608 n->nd_head = nd_head;
22609 n->nd_ensr = nd_ensr;
22618 n->nd_1st = nd_1st;
22619 n->nd_2nd = nd_2nd;
22620 n->operator_loc = *operator_loc;
22629 n->nd_1st = nd_1st;
22630 n->nd_2nd = nd_2nd;
22631 n->operator_loc = *operator_loc;
22640 n->nd_stts = nd_stts;
22641 n->keyword_loc = *keyword_loc;
22648 if (nd_head) no_blockarg(p, nd_head);
22651 n->nd_head = nd_head;
22652 n->keyword_loc = *keyword_loc;
22653 n->lparen_loc = *lparen_loc;
22654 n->rparen_loc = *rparen_loc;
22663 n->nd_cond = nd_cond;
22664 n->nd_body = nd_body;
22665 n->nd_else = nd_else;
22666 n->if_keyword_loc = *if_keyword_loc;
22667 n->then_keyword_loc = *then_keyword_loc;
22668 n->end_keyword_loc = *end_keyword_loc;
22677 n->nd_cond = nd_cond;
22678 n->nd_body = nd_body;
22679 n->nd_else = nd_else;
22680 n->keyword_loc = *keyword_loc;
22681 n->then_keyword_loc = *then_keyword_loc;
22682 n->end_keyword_loc = *end_keyword_loc;
22691 NODE *scope = NEW_SCOPE(0, nd_body, loc);
22693 n->nd_cpath = nd_cpath;
22694 n->nd_body = scope;
22695 n->nd_super = nd_super;
22696 n->class_keyword_loc = *class_keyword_loc;
22697 n->inheritance_operator_loc = *inheritance_operator_loc;
22698 n->end_keyword_loc = *end_keyword_loc;
22707 NODE *scope = NEW_SCOPE(0, nd_body, loc);
22709 n->nd_recv = nd_recv;
22710 n->nd_body = scope;
22719 NODE *scope = NEW_SCOPE(0, nd_body, loc);
22721 n->nd_cpath = nd_cpath;
22722 n->nd_body = scope;
22731 NODE *scope = NEW_SCOPE(nd_args, nd_body, loc);
22733 n->nd_body = scope;
22743 NODE *scope = NEW_SCOPE(nd_args, nd_body, loc);
22744 YYLTYPE lambda_loc = code_loc_gen(operator_loc, closing_loc);
22746 n->nd_body = scope;
22747 n->operator_loc = *operator_loc;
22748 n->opening_loc = *opening_loc;
22749 n->closing_loc = *closing_loc;
22758 n->nd_head = nd_head;
22759 n->nd_body = nd_body;
22760 n->case_keyword_loc = *case_keyword_loc;
22761 n->end_keyword_loc = *end_keyword_loc;
22771 n->nd_body = nd_body;
22772 n->case_keyword_loc = *case_keyword_loc;
22773 n->end_keyword_loc = *end_keyword_loc;
22782 n->nd_head = nd_head;
22783 n->nd_body = nd_body;
22784 n->case_keyword_loc = *case_keyword_loc;
22785 n->end_keyword_loc = *end_keyword_loc;
22794 n->nd_head = nd_head;
22795 n->nd_body = nd_body;
22796 n->nd_next = nd_next;
22797 n->keyword_loc = *keyword_loc;
22798 n->then_keyword_loc = *then_keyword_loc;
22807 n->nd_head = nd_head;
22808 n->nd_body = nd_body;
22809 n->nd_next = nd_next;
22818 n->nd_cond = nd_cond;
22819 n->nd_body = nd_body;
22820 n->nd_state = nd_state;
22821 n->keyword_loc = *keyword_loc;
22822 n->closing_loc = *closing_loc;
22831 n->nd_cond = nd_cond;
22832 n->nd_body = nd_body;
22833 n->nd_state = nd_state;
22834 n->keyword_loc = *keyword_loc;
22835 n->closing_loc = *closing_loc;
22844 n->nd_head = nd_head;
22845 n->nd_mid = nd_mid;
22846 n->delimiter_loc = *delimiter_loc;
22847 n->name_loc = *name_loc;
22856 n->nd_mid = nd_mid;
22857 n->delimiter_loc = *delimiter_loc;
22858 n->name_loc = *name_loc;
22867 n->nd_beg = nd_beg;
22868 n->nd_end = nd_end;
22869 n->operator_loc = *operator_loc;
22878 n->nd_beg = nd_beg;
22879 n->nd_end = nd_end;
22880 n->operator_loc = *operator_loc;
22923 n->nd_args = nd_args;
22924 n->keyword_loc = *keyword_loc;
22925 n->lparen_loc = *lparen_loc;
22926 n->rparen_loc = *rparen_loc;
22943 n->nd_recv = nd_recv;
22944 n->nd_value = nd_value;
22954 n->nd_recv = nd_recv;
22955 n->nd_value = nd_value;
22965 n->nd_head = nd_head;
22976 n->nd_head = nd_head;
22977 n->as.nd_alen = nd_alen;
22978 n->nd_next = nd_next;
22995 n->nd_head = nd_head;
23005 n->nd_head = nd_head;
23007 n->nd_args = nd_args;
23016 n->nd_vid = nd_vid;
23017 n->nd_value = nd_value;
23026 n->nd_vid = nd_vid;
23027 n->nd_value = nd_value;
23036 n->nd_vid = nd_vid;
23037 n->nd_value = nd_value;
23046 n->nd_vid = nd_vid;
23047 n->nd_value = nd_value;
23056 n->nd_vid = nd_vid;
23057 n->nd_value = nd_value;
23066 n->nd_recv = nd_recv;
23067 n->nd_mid = nd_mid;
23068 n->nd_index = index;
23069 n->nd_rvalue = rvalue;
23070 n->call_operator_loc = *call_operator_loc;
23071 n->opening_loc = *opening_loc;
23072 n->closing_loc = *closing_loc;
23073 n->binary_operator_loc = *binary_operator_loc;
23082 n->nd_recv = nd_recv;
23083 n->nd_value = nd_value;
23084 n->nd_vid = nd_vid;
23085 n->nd_mid = nd_mid;
23086 n->nd_aid = nd_aid;
23087 n->call_operator_loc = *call_operator_loc;
23088 n->message_loc = *message_loc;
23089 n->binary_operator_loc = *binary_operator_loc;
23098 n->nd_head = nd_head;
23099 n->nd_value = nd_value;
23108 n->nd_head = nd_head;
23109 n->nd_value = nd_value;
23118 n->nd_vid = nd_vid;
23127 n->nd_vid = nd_vid;
23136 n->nd_vid = nd_vid;
23145 n->nd_vid = nd_vid;
23154 n->nd_vid = nd_vid;
23163 n->nd_vid = nd_vid;
23172 n->nd_nth = nd_nth;
23181 n->nd_nth = nd_nth;
23208rb_node_rational_new(
struct parser_params *p,
char* val,
int base,
int seen_point,
const YYLTYPE *loc)
23214 n->seen_point = seen_point;
23220rb_node_imaginary_new(
struct parser_params *p,
char* val,
int base,
int seen_point,
enum rb_numeric_type numeric_type,
const YYLTYPE *loc)
23226 n->seen_point = seen_point;
23227 n->type = numeric_type;
23236 n->string = string;
23246 n->string = string;
23247 n->as.nd_alen = nd_alen;
23256 return rb_node_dstr_new0(p,
string, 1, 0, loc);
23263 n->string = string;
23272 n->string = string;
23273 n->as.nd_alen = nd_alen;
23283 n->string = rb_str_to_parser_string(p, str);
23292 n->string = string;
23293 n->as.nd_alen = nd_alen;
23303 n->nd_body = nd_body;
23304 n->opening_loc = *opening_loc;
23305 n->closing_loc = *closing_loc;
23314 n->string = string;
23315 n->options = options & RE_OPTION_MASK;
23316 n->opening_loc = *opening_loc;
23317 n->content_loc = *content_loc;
23318 n->closing_loc = *closing_loc;
23327 n->nd_recv = nd_recv;
23328 n->nd_mid = nd_mid;
23329 n->nd_args = nd_args;
23338 n->nd_recv = nd_recv;
23339 n->nd_mid = nd_mid;
23340 n->nd_args = nd_args;
23349 n->nd_mid = nd_mid;
23350 n->nd_args = nd_args;
23359 n->nd_recv = nd_recv;
23360 n->nd_mid = nd_mid;
23361 n->nd_args = nd_args;
23370 n->nd_mid = nd_mid;
23379 n->nd_body = nd_body;
23397 n->nd_pid = nd_pid;
23398 n->nd_plen = nd_plen;
23408 n->nd_body = nd_body;
23418 n->nd_body = nd_body;
23428 n->nd_1st = nd_1st;
23429 n->nd_2nd = nd_2nd;
23438 n->nd_head = nd_head;
23439 n->nd_body = nd_body;
23448 n->nd_head = nd_head;
23449 n->nd_body = nd_body;
23458 n->nd_head = nd_head;
23459 n->operator_loc = *operator_loc;
23470 n->nd_body = nd_body;
23471 n->operator_loc = *operator_loc;
23480 n->nd_1st = nd_1st;
23481 n->nd_2nd = nd_2nd;
23482 n->keyword_loc = *keyword_loc;
23491 n->nd_alias = nd_alias;
23492 n->nd_orig = nd_orig;
23493 n->keyword_loc = *keyword_loc;
23502 n->nd_undefs = rb_parser_ary_new_capa_for_node(p, 1);
23503 n->keyword_loc = NULL_LOC;
23504 rb_parser_ary_push_node(p, n->nd_undefs, nd_undef);
23521 n->nd_head = nd_head;
23522 n->keyword_loc = *keyword_loc;
23531 n->nd_body = nd_body;
23532 n->keyword_loc = *keyword_loc;
23533 n->opening_loc = *opening_loc;
23534 n->closing_loc = *closing_loc;
23543 n->nd_recv = nd_recv;
23544 n->nd_mid = nd_mid;
23545 n->nd_args = nd_args;
23555 n->pre_args = pre_args;
23556 n->rest_arg = rest_arg;
23557 n->post_args = post_args;
23566 n->nd_pconst = nd_pconst;
23567 n->nd_pkwargs = nd_pkwargs;
23568 n->nd_pkwrestarg = nd_pkwrestarg;
23578 n->pre_rest_arg = pre_rest_arg;
23580 n->post_rest_arg = post_rest_arg;
23597 n->path = rb_str_to_parser_string(p, str);
23612rb_node_cdecl_new(
struct parser_params *p,
ID nd_vid,
NODE *nd_value,
NODE *nd_else,
enum rb_parser_shareability shareability,
const YYLTYPE *loc)
23615 n->nd_vid = nd_vid;
23616 n->nd_value = nd_value;
23617 n->nd_else = nd_else;
23618 n->shareability = shareability;
23624rb_node_op_cdecl_new(
struct parser_params *p,
NODE *nd_head,
NODE *nd_value,
ID nd_aid,
enum rb_parser_shareability shareability,
const YYLTYPE *loc)
23627 n->nd_head = nd_head;
23628 n->nd_value = nd_value;
23629 n->nd_aid = nd_aid;
23630 n->shareability = shareability;
23647 n->nd_stts = nd_stts;
23649 n->keyword_loc = *keyword_loc;
23658 n->nd_stts = nd_stts;
23660 n->keyword_loc = *keyword_loc;
23670 n->keyword_loc = *keyword_loc;
23679 n->save.numparam_save = 0;
23680 n->save.max_numparam = 0;
23681 n->save.ctxt = p->ctxt;
23691 n->save.numparam_save = numparam_push(p);
23692 n->save.max_numparam = p->max_numparam;
23697static enum node_type
23698nodetype(
NODE *node)
23700 return (
enum node_type)nd_type(node);
23704nodeline(
NODE *node)
23706 return nd_line(node);
23711newline_node(
NODE *node)
23714 node = remove_begin(node);
23715 nd_set_fl_newline(node);
23725 nd_set_line(node, nd_line(orig));
23731 NODE *end, *h = head, *nd;
23733 if (tail == 0)
return head;
23735 if (h == 0)
return tail;
23736 switch (nd_type(h)) {
23738 h = end = NEW_BLOCK(head, &head->nd_loc);
23742 end = RNODE_BLOCK(h)->nd_end;
23746 nd = RNODE_BLOCK(end)->nd_head;
23747 switch (nd_type(nd)) {
23753 rb_warning0L(nd_line(tail),
"statement not reached");
23760 if (!nd_type_p(tail, NODE_BLOCK)) {
23761 tail = NEW_BLOCK(tail, &tail->nd_loc);
23763 RNODE_BLOCK(end)->nd_next = tail;
23764 RNODE_BLOCK(h)->nd_end = RNODE_BLOCK(tail)->nd_end;
23765 nd_set_last_loc(head, nd_last_loc(tail));
23775 if (list == 0)
return NEW_LIST(item, &item->nd_loc);
23776 if (RNODE_LIST(list)->nd_next) {
23777 last = RNODE_LIST(RNODE_LIST(list)->nd_next)->as.nd_end;
23783 RNODE_LIST(list)->as.nd_alen += 1;
23784 RNODE_LIST(last)->nd_next = NEW_LIST(item, &item->nd_loc);
23785 RNODE_LIST(RNODE_LIST(list)->nd_next)->as.nd_end = RNODE_LIST(last)->nd_next;
23787 nd_set_last_loc(list, nd_last_loc(item));
23794list_concat(
NODE *head,
NODE *tail)
23798 if (RNODE_LIST(head)->nd_next) {
23799 last = RNODE_LIST(RNODE_LIST(head)->nd_next)->as.nd_end;
23805 RNODE_LIST(head)->as.nd_alen += RNODE_LIST(tail)->as.nd_alen;
23806 RNODE_LIST(last)->nd_next = tail;
23807 if (RNODE_LIST(tail)->nd_next) {
23808 RNODE_LIST(RNODE_LIST(head)->nd_next)->as.nd_end = RNODE_LIST(RNODE_LIST(tail)->nd_next)->as.nd_end;
23811 RNODE_LIST(RNODE_LIST(head)->nd_next)->as.nd_end = tail;
23814 nd_set_last_loc(head, nd_last_loc(tail));
23822 if (!tail)
return 1;
23823 if (!rb_parser_enc_compatible(p, head, tail)) {
23824 compile_error(p,
"string literal encodings differ (%s / %s)",
23825 rb_enc_name(rb_parser_str_get_encoding(head)),
23826 rb_enc_name(rb_parser_str_get_encoding(tail)));
23827 rb_parser_str_resize(p, head, 0);
23828 rb_parser_str_resize(p, tail, 0);
23831 rb_parser_str_buf_append(p, head, tail);
23838 if (htype != NODE_DSTR)
return NULL;
23839 if (RNODE_DSTR(head)->nd_next) {
23840 head = RNODE_LIST(RNODE_LIST(RNODE_DSTR(head)->nd_next)->as.nd_end)->nd_head;
23841 if (!head || !nd_type_p(head, NODE_STR))
return NULL;
23853 if (!orig)
return NULL;
23854 copy = rb_parser_string_new(p, PARSER_STRING_PTR(orig), PARSER_STRING_LEN(orig));
23855 copy->coderange = orig->coderange;
23856 copy->enc = orig->enc;
23865 enum node_type htype;
23868 if (!head)
return tail;
23869 if (!tail)
return head;
23871 htype = nd_type(head);
23872 if (htype == NODE_EVSTR) {
23873 head = new_dstr(p, head, loc);
23876 if (p->heredoc_indent > 0) {
23879 head = str2dstr(p, head);
23881 return list_append(p, head, tail);
23886 switch (nd_type(tail)) {
23888 if ((lit = string_literal_head(p, htype, head)) !=
false) {
23892 lit = RNODE_DSTR(head)->string;
23894 if (htype == NODE_STR) {
23895 if (!literal_concat0(p, lit, RNODE_STR(tail)->
string)) {
23897 rb_discard_node(p, head);
23898 rb_discard_node(p, tail);
23901 rb_discard_node(p, tail);
23904 list_append(p, head, tail);
23909 if (htype == NODE_STR) {
23910 if (!literal_concat0(p, RNODE_STR(head)->
string, RNODE_DSTR(tail)->
string))
23912 rb_parser_string_free(p, RNODE_DSTR(tail)->
string);
23913 RNODE_DSTR(tail)->string = RNODE_STR(head)->string;
23914 RNODE_STR(head)->string = NULL;
23915 rb_discard_node(p, head);
23918 else if (!RNODE_DSTR(tail)->
string) {
23920 RNODE_DSTR(head)->as.nd_alen += RNODE_DSTR(tail)->as.nd_alen - 1;
23921 if (!RNODE_DSTR(head)->nd_next) {
23922 RNODE_DSTR(head)->nd_next = RNODE_DSTR(tail)->nd_next;
23924 else if (RNODE_DSTR(tail)->nd_next) {
23925 RNODE_DSTR(RNODE_DSTR(RNODE_DSTR(head)->nd_next)->as.nd_end)->nd_next = RNODE_DSTR(tail)->nd_next;
23926 RNODE_DSTR(RNODE_DSTR(head)->nd_next)->as.nd_end = RNODE_DSTR(RNODE_DSTR(tail)->nd_next)->as.nd_end;
23928 rb_discard_node(p, tail);
23930 else if ((lit = string_literal_head(p, htype, head)) !=
false) {
23931 if (!literal_concat0(p, lit, RNODE_DSTR(tail)->
string))
23933 rb_parser_string_free(p, RNODE_DSTR(tail)->
string);
23934 RNODE_DSTR(tail)->string = 0;
23938 list_concat(head, NEW_LIST2(NEW_STR(RNODE_DSTR(tail)->
string, loc), RNODE_DSTR(tail)->as.nd_alen, (
NODE *)RNODE_DSTR(tail)->nd_next, loc));
23939 RNODE_DSTR(tail)->string = 0;
23944 if (htype == NODE_STR) {
23945 head = str2dstr(p, head);
23946 RNODE_DSTR(head)->as.nd_alen = 1;
23948 list_append(p, head, tail);
23955nd_copy_flag(
NODE *new_node,
NODE *old_node)
23957 if (nd_fl_newline(old_node)) nd_set_fl_newline(new_node);
23958 nd_set_line(new_node, nd_line(old_node));
23959 new_node->nd_loc = old_node->nd_loc;
23960 new_node->node_id = old_node->node_id;
23967 nd_copy_flag(new_node, node);
23968 RNODE_DSTR(new_node)->string = RNODE_STR(node)->string;
23969 RNODE_DSTR(new_node)->as.nd_alen = 0;
23970 RNODE_DSTR(new_node)->nd_next = 0;
23971 RNODE_STR(node)->string = 0;
23980 nd_copy_flag(new_node, node);
23981 RNODE_REGX(new_node)->string = RNODE_STR(node)->string;
23982 RNODE_REGX(new_node)->options = options;
23983 nd_set_loc(new_node, loc);
23984 RNODE_REGX(new_node)->opening_loc = *opening_loc;
23985 RNODE_REGX(new_node)->content_loc = *content_loc;
23986 RNODE_REGX(new_node)->closing_loc = *closing_loc;
23987 RNODE_STR(node)->string = 0;
23995 if (nd_type_p(node, NODE_EVSTR)) {
23996 node = new_dstr(p, node, &node->nd_loc);
24007 switch (nd_type(node)) {
24009 return str2dstr(p, node);
24016 return NEW_EVSTR(head, loc, opening_loc, closing_loc);
24022 NODE *dstr = NEW_DSTR(STRING_NEW0(), loc);
24023 return list_append(p, dstr, node);
24033 expr = NEW_OPCALL(recv,
id, NEW_LIST(arg1, &arg1->nd_loc), loc);
24034 nd_set_line(expr, op_loc->beg_pos.lineno);
24043 opcall = NEW_OPCALL(recv,
id, 0, loc);
24044 nd_set_line(opcall, op_loc->beg_pos.lineno);
24051 NODE *qcall = NEW_QCALL(atype, recv, mid, args, loc);
24052 nd_set_line(qcall, op_loc->beg_pos.lineno);
24060 if (block) block_dup_check(p, args, block);
24061 ret = new_qcall(p, atype, recv, mid, args, op_loc, loc);
24062 if (block) ret = method_add_block(p, ret, block, loc);
24072 body->opening_loc = *opening_loc;
24073 body->closing_loc = *closing_loc;
24077#define nd_once_body(node) (nd_type_p((node), NODE_ONCE) ? RNODE_ONCE(node)->nd_body : node)
24080last_expr_once_body(
NODE *node)
24082 if (!node)
return 0;
24083 return nd_once_body(node);
24090 int line = op_loc->beg_pos.lineno;
24095 if ((n = last_expr_once_body(node1)) != 0) {
24096 switch (nd_type(n)) {
24099 NODE *match = NEW_MATCH2(node1, node2, loc);
24100 nd_set_line(match, line);
24106 const VALUE lit = rb_node_regx_string_val(n);
24108 NODE *match = NEW_MATCH2(node1, node2, loc);
24109 RNODE_MATCH2(match)->nd_args = reg_named_capture_assign(p, lit, loc, assignable);
24110 nd_set_line(match, line);
24117 if ((n = last_expr_once_body(node2)) != 0) {
24120 switch (nd_type(n)) {
24122 match3 = NEW_MATCH3(node2, node1, loc);
24127 n = NEW_CALL(node1, tMATCH, NEW_LIST(node2, &node2->nd_loc), loc);
24128 nd_set_line(n, line);
24132# if WARN_PAST_SCOPE
24136 struct vtable *past = p->lvtbl->past;
24138 if (vtable_included(past,
id))
return 1;
24149 NODE *outer = local->numparam.outer;
24150 NODE *inner = local->numparam.inner;
24151 if (outer || inner) {
24152 NODE *used = outer ? outer : inner;
24153 compile_error(p,
"numbered parameter is already used in %s block\n"
24154 "%s:%d: numbered parameter is already used here",
24155 outer ?
"outer" :
"inner",
24156 p->ruby_sourcefile, nd_line(used));
24157 parser_show_error_line(p, &used->nd_loc);
24166 NODE *numparam = p->lvtbl->numparam.current;
24168 compile_error(p,
"'it' is not allowed when a numbered parameter is already used\n"
24169 "%s:%d: numbered parameter is already used here",
24170 p->ruby_sourcefile, nd_line(numparam));
24171 parser_show_error_line(p, &numparam->nd_loc);
24180 NODE *it = p->lvtbl->it;
24182 compile_error(p,
"numbered parameters are not allowed when 'it' is already used\n"
24183 "%s:%d: 'it' is already used here",
24184 p->ruby_sourcefile, nd_line(it));
24185 parser_show_error_line(p, &it->nd_loc);
24198 return NEW_SELF(loc);
24200 return NEW_NIL(loc);
24202 return NEW_TRUE(loc);
24203 case keyword_false:
24204 return NEW_FALSE(loc);
24205 case keyword__FILE__:
24207 VALUE file = p->ruby_sourcefile_string;
24210 node = NEW_FILE(file, loc);
24213 case keyword__LINE__:
24214 return NEW_LINE(loc);
24215 case keyword__ENCODING__:
24216 return NEW_ENCODING(loc);
24219 switch (id_type(
id)) {
24221 if (dyna_in_block(p) && dvar_defined_ref(p,
id, &vidp)) {
24222 if (NUMPARAM_ID_P(
id) && (numparam_nested_p(p) || it_used_p(p)))
return 0;
24223 if (vidp) *vidp |= LVAR_USED;
24224 node = NEW_DVAR(
id, loc);
24227 if (local_id_ref(p,
id, &vidp)) {
24228 if (vidp) *vidp |= LVAR_USED;
24229 node = NEW_LVAR(
id, loc);
24232 if (dyna_in_block(p) && NUMPARAM_ID_P(
id) &&
24233 parser_numbered_param(p, NUMPARAM_ID_TO_IDX(
id))) {
24234 if (numparam_nested_p(p) || it_used_p(p))
return 0;
24235 node = NEW_DVAR(
id, loc);
24237 if (!local->numparam.current) local->numparam.current = node;
24240# if WARN_PAST_SCOPE
24242 rb_warning1(
"possible reference to past scope - %"PRIsWARN, rb_id2str(
id));
24246 if (dyna_in_block(p) &&
id == rb_intern(
"it") && !(DVARS_TERMINAL_P(p->lvtbl->args) || DVARS_TERMINAL_P(p->lvtbl->args->prev))) {
24247 if (numparam_used_p(p))
return 0;
24248 if (p->max_numparam == ORDINAL_PARAM) {
24249 compile_error(p,
"ordinary parameter is defined");
24253 p->it_id = internal_id(p);
24254 vtable_add(p->lvtbl->args, p->it_id);
24256 NODE *node = NEW_DVAR(p->it_id, loc);
24257 if (!p->lvtbl->it) p->lvtbl->it = node;
24260 return NEW_VCALL(
id, loc);
24262 return NEW_GVAR(
id, loc);
24264 return NEW_IVAR(
id, loc);
24266 return NEW_CONST(
id, loc);
24268 return NEW_CVAR(
id, loc);
24270 compile_error(p,
"identifier %"PRIsVALUE
" is not valid to get", rb_id2str(
id));
24278 RNODE(opts)->nd_loc.end_pos = RNODE(opt)->nd_loc.end_pos;
24280 while (opts->nd_next) {
24281 opts = opts->nd_next;
24282 RNODE(opts)->nd_loc.end_pos = RNODE(opt)->nd_loc.end_pos;
24284 opts->nd_next = opt;
24294 opt_arg_append(RNODE_OPT_ARG(kwlist), RNODE_OPT_ARG(kw));
24302 int had_trailing_semicolon = p->ctxt.has_trailing_semicolon;
24303 p->ctxt.has_trailing_semicolon = 0;
24307 if (nd_type_p(n, NODE_BEGIN)) {
24308 n = RNODE_BEGIN(n)->nd_body;
24310 else if (nd_type_p(n, NODE_BLOCK) && RNODE_BLOCK(n)->nd_end == n) {
24311 n = RNODE_BLOCK(n)->nd_head;
24318 if (had_trailing_semicolon && !nd_type_p(expr, NODE_BLOCK)) {
24319 NODE *block = NEW_BLOCK(expr, loc);
24320 return NEW_DEFINED(block, loc, keyword_loc);
24323 return NEW_DEFINED(n, loc, keyword_loc);
24331 if (rb_parser_enc_str_coderange(p, str) == RB_PARSER_ENC_CODERANGE_BROKEN) {
24332 yyerror1(loc,
"invalid symbol");
24336 lit = rb_str_new_parser_string(str);
24338 return NEW_SYM(lit, loc);
24344 enum node_type
type = nd_type(symbol);
24347 nd_set_type(symbol, NODE_DSYM);
24350 symbol = str_to_sym_node(p, symbol, &RNODE(symbol)->nd_loc);
24353 compile_error(p,
"unexpected node as symbol: %s", parser_node_name(
type));
24355 return list_append(p, symbols, symbol);
24361 if (dreg->string) {
24362 reg_fragment_setenc(p, dreg->string, options);
24364 for (
struct RNode_LIST *list = dreg->nd_next; list; list = RNODE_LIST(list->nd_next)) {
24365 NODE *frag = list->nd_head;
24366 if (nd_type_p(frag, NODE_STR)) {
24367 reg_fragment_setenc(p, RNODE_STR(frag)->
string, options);
24369 else if (nd_type_p(frag, NODE_DSTR)) {
24370 dregex_fragment_setenc(p, RNODE_DSTR(frag), options);
24381 reg_compile(p, str, options);
24382 node = NEW_REGX(str, options, loc, opening_loc, content_loc, closing_loc);
24385 switch (nd_type(node)) {
24389 reg_compile(p, RNODE_STR(node)->
string, options);
24390 node = str2regx(p, node, options, loc, opening_loc, content_loc, closing_loc);
24394 node = NEW_DSTR0(STRING_NEW0(), 1, NEW_LIST(node, loc), loc);
24397 nd_set_type(node, NODE_DREGX);
24398 nd_set_loc(node, loc);
24400 dreg->as.nd_cflag = options & RE_OPTION_MASK;
24401 if (dreg->nd_next) {
24402 dregex_fragment_setenc(p, dreg, options);
24404 if (options & RE_OPTION_ONCE) {
24405 node = NEW_ONCE(node, loc);
24416 return NEW_KW_ARG((k), loc);
24423 NODE *xstr = NEW_XSTR(STRING_NEW0(), loc);
24426 switch (nd_type(node)) {
24428 nd_set_type(node, NODE_XSTR);
24429 nd_set_loc(node, loc);
24432 nd_set_type(node, NODE_DXSTR);
24433 nd_set_loc(node, loc);
24436 node = NEW_DXSTR(0, 1, NEW_LIST(node, loc), loc);
24448static int nd_type_st_key_enable_p(
NODE *node);
24454 if (!arg || !p->case_labels)
return;
24455 if (!nd_type_st_key_enable_p(arg))
return;
24457 if (p->case_labels == CHECK_LITERAL_WHEN) {
24458 p->case_labels = st_init_table(&literal_type);
24462 if (st_lookup(p->case_labels, (st_data_t)arg, &line)) {
24463 rb_warning2(
"'when' clause on line %d duplicates 'when' clause on line %d and is ignored",
24464 WARN_I((
int)nd_line(arg)), WARN_I((
int)line));
24468 st_insert(p->case_labels, (st_data_t)arg, (st_data_t)p->ruby_sourceline);
24475 if (is_notop_id(
id)) {
24476 switch (
id & ID_SCOPE_MASK) {
24477 case ID_GLOBAL:
case ID_INSTANCE:
case ID_CONST:
case ID_CLASS:
24480 if (dyna_in_block(p)) {
24481 if (NUMPARAM_ID_P(
id) || dvar_defined(p,
id))
return 1;
24483 if (local_id(p,
id))
return 1;
24488 compile_error(p,
"identifier %"PRIsVALUE
" is not valid to get", rb_id2str(
id));
24493static inline enum lex_state_e
24494parser_set_lex_state(
struct parser_params *p,
enum lex_state_e ls,
int line)
24497 ls = rb_parser_trace_lex_state(p, p->lex.state, ls, line);
24499 return p->lex.state = ls;
24506 VALUE mesg = p->debug_buffer;
24508 if (!
NIL_P(mesg) && RSTRING_LEN(mesg)) {
24509 p->debug_buffer =
Qnil;
24510 rb_io_puts(1, &mesg, out);
24512 if (!
NIL_P(str) && RSTRING_LEN(str)) {
24513 rb_io_write(p->debug_output, str);
24517static const char rb_parser_lex_state_names[][8] = {
24518 "BEG",
"END",
"ENDARG",
"ENDFN",
"ARG",
24519 "CMDARG",
"MID",
"FNAME",
"DOT",
"CLASS",
24520 "LABEL",
"LABELED",
"FITEM",
24527 unsigned int mask = 1;
24528 static const char none[] =
"NONE";
24530 for (i = 0; i < EXPR_MAX_STATE; ++i, mask <<= 1) {
24531 if ((
unsigned)state & mask) {
24546rb_parser_trace_lex_state(
struct parser_params *p,
enum lex_state_e from,
24547 enum lex_state_e to,
int line)
24551 append_lex_state_name(p, from, mesg);
24553 append_lex_state_name(p, to, mesg);
24554 rb_str_catf(mesg,
" at line %d\n", line);
24555 flush_debug_buffer(p, p->debug_output, mesg);
24560rb_parser_lex_state_name(
struct parser_params *p,
enum lex_state_e state)
24562 return rb_str_to_interned_str(append_lex_state_name(p, state,
rb_str_new(0, 0)));
24572 stack_type mask = (stack_type)1U << (CHAR_BIT *
sizeof(stack_type) - 1);
24573 for (; mask && !(stack & mask); mask >>= 1)
continue;
24574 for (; mask; mask >>= 1)
rb_str_cat(mesg, stack & mask ?
"1" :
"0", 1);
24579rb_parser_show_bitstack(
struct parser_params *p, stack_type stack,
24580 const char *name,
int line)
24582 VALUE mesg = rb_sprintf(
"%s: ", name);
24583 append_bitstack_value(p, stack, mesg);
24584 rb_str_catf(mesg,
" at line %d\n", line);
24585 flush_debug_buffer(p, p->debug_output, mesg);
24589rb_parser_fatal(
struct parser_params *p,
const char *fmt, ...)
24595 rb_str_vcatf(mesg, fmt, ap);
24597 yyerror0(RSTRING_PTR(mesg));
24601 append_lex_state_name(p, p->lex.state, mesg);
24602 compile_error(p,
"lex.state: %"PRIsVALUE, mesg);
24603 rb_str_resize(mesg, 0);
24604 append_bitstack_value(p, p->cond_stack, mesg);
24605 compile_error(p,
"cond_stack: %"PRIsVALUE, mesg);
24606 rb_str_resize(mesg, 0);
24607 append_bitstack_value(p, p->cmdarg_stack, mesg);
24608 compile_error(p,
"cmdarg_stack: %"PRIsVALUE, mesg);
24609 if (p->debug_output == rb_ractor_stdout())
24610 p->debug_output = rb_ractor_stderr();
24615rb_parser_set_pos(
YYLTYPE *yylloc,
int sourceline,
int beg_pos,
int end_pos)
24617 yylloc->beg_pos.lineno = sourceline;
24618 yylloc->beg_pos.column = beg_pos;
24619 yylloc->end_pos.lineno = sourceline;
24620 yylloc->end_pos.column = end_pos;
24627 int sourceline = here->sourceline;
24628 int beg_pos = (int)here->offset - here->quote
24629 - (
rb_strlen_lit(
"<<-") - !(here->func & STR_FUNC_INDENT));
24630 int end_pos = (int)here->offset + here->length + here->quote;
24632 return rb_parser_set_pos(yylloc, sourceline, beg_pos, end_pos);
24638 yylloc->beg_pos.lineno = p->delayed.beg_line;
24639 yylloc->beg_pos.column = p->delayed.beg_col;
24640 yylloc->end_pos.lineno = p->delayed.end_line;
24641 yylloc->end_pos.column = p->delayed.end_col;
24649 int sourceline = p->ruby_sourceline;
24650 int beg_pos = (int)(p->lex.ptok - p->lex.pbeg);
24651 int end_pos = (int)(p->lex.pend - p->lex.pbeg);
24652 return rb_parser_set_pos(yylloc, sourceline, beg_pos, end_pos);
24658 yylloc->end_pos = yylloc->beg_pos;
24666 int sourceline = p->ruby_sourceline;
24667 int beg_pos = (int)(p->lex.ptok - p->lex.pbeg);
24668 int end_pos = (int)(p->lex.ptok - p->lex.pbeg);
24669 return rb_parser_set_pos(yylloc, sourceline, beg_pos, end_pos);
24675 int sourceline = p->ruby_sourceline;
24676 int beg_pos = (int)(p->lex.ptok - p->lex.pbeg);
24677 int end_pos = (int)(p->lex.pcur - p->lex.pbeg);
24678 return rb_parser_set_pos(yylloc, sourceline, beg_pos, end_pos);
24685 if (!
id)
return -1;
24688 *err =
"Can't change the value of self";
24691 *err =
"Can't assign to nil";
24694 *err =
"Can't assign to true";
24696 case keyword_false:
24697 *err =
"Can't assign to false";
24699 case keyword__FILE__:
24700 *err =
"Can't assign to __FILE__";
24702 case keyword__LINE__:
24703 *err =
"Can't assign to __LINE__";
24705 case keyword__ENCODING__:
24706 *err =
"Can't assign to __ENCODING__";
24709 switch (id_type(
id)) {
24711 if (dyna_in_block(p)) {
24712 if (p->max_numparam > NO_PARAM && NUMPARAM_ID_P(
id)) {
24713 compile_error(p,
"Can't assign to numbered parameter _%d",
24714 NUMPARAM_ID_TO_IDX(
id));
24717 if (dvar_curr(p,
id))
return NODE_DASGN;
24718 if (dvar_defined(p,
id))
return NODE_DASGN;
24719 if (local_id(p,
id))
return NODE_LASGN;
24724 if (!local_id(p,
id)) local_var(p,
id);
24728 case ID_GLOBAL:
return NODE_GASGN;
24729 case ID_INSTANCE:
return NODE_IASGN;
24731 if (!p->ctxt.in_def)
return NODE_CDECL;
24732 *err =
"dynamic constant assignment";
24734 case ID_CLASS:
return NODE_CVASGN;
24736 compile_error(p,
"identifier %"PRIsVALUE
" is not valid to set", rb_id2str(
id));
24744 const char *err = 0;
24745 int node_type = assignable0(p,
id, &err);
24746 switch (node_type) {
24747 case NODE_DASGN:
return NEW_DASGN(
id, val, loc);
24748 case NODE_LASGN:
return NEW_LASGN(
id, val, loc);
24749 case NODE_GASGN:
return NEW_GASGN(
id, val, loc);
24750 case NODE_IASGN:
return NEW_IASGN(
id, val, loc);
24751 case NODE_CDECL:
return NEW_CDECL(
id, val, 0, p->ctxt.shareable_constant_value, loc);
24752 case NODE_CVASGN:
return NEW_CVASGN(
id, val, loc);
24756 if (err) yyerror1(loc, err);
24758 if (err) set_value(assign_error(p, err, p->s_lvalue));
24760 return NEW_ERROR(loc);
24767 if (name == idUScore)
return 1;
24768 if (!is_local_id(name))
return 0;
24769 s = rb_id2str(name);
24771 return RSTRING_PTR(s)[0] ==
'_';
24777 if (dyna_in_block(p)) {
24778 if (dvar_curr(p, name)) {
24779 if (is_private_local_id(p, name))
return 1;
24780 yyerror0(
"duplicated argument name");
24782 else if (dvar_defined(p, name) || local_id(p, name)) {
24783 vtable_add(p->lvtbl->vars, name);
24784 if (p->lvtbl->used) {
24785 vtable_add(p->lvtbl->used, (
ID)p->ruby_sourceline | LVAR_USED);
24791 if (local_id(p, name)) {
24792 if (is_private_local_id(p, name))
return 1;
24793 yyerror0(
"duplicated argument name");
24802 shadowing_lvar_0(p, name);
24810 if (!is_local_id(name)) {
24811 compile_error(p,
"invalid local variable - %"PRIsVALUE,
24815 if (!shadowing_lvar_0(p, name))
return;
24818 if (dvar_defined_ref(p, name, &vidp)) {
24819 if (vidp) *vidp |= LVAR_USED;
24826 NODE *block = 0, *kwds = 0;
24827 if (args && nd_type_p(args, NODE_BLOCK_PASS)) {
24828 block = RNODE_BLOCK_PASS(args)->nd_body;
24829 args = RNODE_BLOCK_PASS(args)->nd_head;
24831 if (args && nd_type_p(args, NODE_ARGSCAT)) {
24832 args = RNODE_ARGSCAT(args)->nd_body;
24834 if (args && nd_type_p(args, NODE_ARGSPUSH)) {
24835 kwds = RNODE_ARGSPUSH(args)->nd_body;
24838 for (
NODE *next = args; next && nd_type_p(next, NODE_LIST);
24839 next = RNODE_LIST(next)->nd_next) {
24840 kwds = RNODE_LIST(next)->nd_head;
24843 if (kwds && nd_type_p(kwds, NODE_HASH) && !RNODE_HASH(kwds)->nd_brace) {
24844 yyerror1(&kwds->nd_loc,
"keyword arg given in index assignment");
24847 yyerror1(&block->nd_loc,
"block arg given in index assignment");
24854 aryset_check(p, idx);
24855 return NEW_ATTRASGN(recv, tASET, idx, loc);
24861 if (node2 && node1 && nd_type_p(node1, NODE_BLOCK_PASS)) {
24862 compile_error(p,
"both block arg and actual block given");
24869 if (!CALL_Q_P(atype))
id = rb_id_attrset(
id);
24870 return NEW_ATTRASGN(recv,
id, 0, loc);
24877# define ERR(...) (compile_error(p, __VA_ARGS__), Qtrue)
24879# define ERR(...) rb_sprintf(__VA_ARGS__)
24881 switch (nd_type(node)) {
24883 return ERR(
"Can't set variable $%ld", RNODE_NTH_REF(node)->nd_nth);
24884 case NODE_BACK_REF:
24885 return ERR(
"Can't set variable $%c", (
int)RNODE_BACK_REF(node)->nd_nth);
24894 if (!node1)
return NEW_LIST(node2, &node2->nd_loc);
24895 switch (nd_type(node1)) {
24897 return list_append(p, node1, node2);
24898 case NODE_BLOCK_PASS:
24899 RNODE_BLOCK_PASS(node1)->nd_head = arg_append(p, RNODE_BLOCK_PASS(node1)->nd_head, node2, loc);
24900 node1->nd_loc.end_pos = RNODE_BLOCK_PASS(node1)->nd_head->nd_loc.end_pos;
24902 case NODE_ARGSPUSH:
24903 RNODE_ARGSPUSH(node1)->nd_body = list_append(p, NEW_LIST(RNODE_ARGSPUSH(node1)->nd_body, &RNODE_ARGSPUSH(node1)->nd_body->nd_loc), node2);
24904 node1->nd_loc.end_pos = RNODE_ARGSPUSH(node1)->nd_body->nd_loc.end_pos;
24905 nd_set_type(node1, NODE_ARGSCAT);
24908 if (!nd_type_p(RNODE_ARGSCAT(node1)->nd_body, NODE_LIST))
break;
24909 RNODE_ARGSCAT(node1)->nd_body = list_append(p, RNODE_ARGSCAT(node1)->nd_body, node2);
24910 node1->nd_loc.end_pos = RNODE_ARGSCAT(node1)->nd_body->nd_loc.end_pos;
24913 return NEW_ARGSPUSH(node1, node2, loc);
24919 if (!node2)
return node1;
24920 switch (nd_type(node1)) {
24921 case NODE_BLOCK_PASS:
24922 if (RNODE_BLOCK_PASS(node1)->nd_head)
24923 RNODE_BLOCK_PASS(node1)->nd_head = arg_concat(p, RNODE_BLOCK_PASS(node1)->nd_head, node2, loc);
24925 RNODE_LIST(node1)->nd_head = NEW_LIST(node2, loc);
24927 case NODE_ARGSPUSH:
24928 if (!nd_type_p(node2, NODE_LIST))
break;
24929 RNODE_ARGSPUSH(node1)->nd_body = list_concat(NEW_LIST(RNODE_ARGSPUSH(node1)->nd_body, loc), node2);
24930 nd_set_type(node1, NODE_ARGSCAT);
24933 if (!nd_type_p(node2, NODE_LIST) ||
24934 !nd_type_p(RNODE_ARGSCAT(node1)->nd_body, NODE_LIST))
break;
24935 RNODE_ARGSCAT(node1)->nd_body = list_concat(RNODE_ARGSCAT(node1)->nd_body, node2);
24938 return NEW_ARGSCAT(node1, node2, loc);
24945 if ((n1 = splat_array(args)) != 0) {
24946 return list_append(p, n1, last_arg);
24948 return arg_append(p, args, last_arg, loc);
24955 if ((nd_type_p(rest_arg, NODE_LIST)) && (n1 = splat_array(args)) != 0) {
24956 return list_concat(n1, rest_arg);
24958 return arg_concat(p, args, rest_arg, loc);
24962splat_array(
NODE* node)
24964 if (nd_type_p(node, NODE_SPLAT)) node = RNODE_SPLAT(node)->nd_head;
24965 if (nd_type_p(node, NODE_LIST))
return node;
24974 switch (nd_type(rhs)) {
24976 if (local_id_ref(p, RNODE_LASGN(rhs)->nd_vid, &vidp)) {
24977 if (vidp) *vidp |= LVAR_USED;
24981 if (dvar_defined_ref(p, RNODE_DASGN(rhs)->nd_vid, &vidp)) {
24982 if (vidp) *vidp |= LVAR_USED;
24987 for (rhs = rhs->nd_head; rhs; rhs = rhs->nd_next) {
24988 mark_lvar_used(p, rhs->nd_head);
24995static int is_static_content(
NODE *node);
25000 if (!lhs)
return 0;
25002 switch (nd_type(lhs)) {
25010 set_nd_value(p, lhs, rhs);
25011 nd_set_loc(lhs, loc);
25014 case NODE_ATTRASGN:
25015 RNODE_ATTRASGN(lhs)->nd_args = arg_append(p, RNODE_ATTRASGN(lhs)->nd_args, rhs, loc);
25016 nd_set_loc(lhs, loc);
25030 NODE *void_node = 0, *vn;
25033 rb_warning0(
"empty expression");
25036 switch (nd_type(node)) {
25038 vn = RNODE_ENSURE(node)->nd_head;
25039 node = RNODE_ENSURE(node)->nd_ensr;
25041 if (vn && (vn = value_expr_check(p, vn))) {
25048 vn = RNODE_RESCUE(node)->nd_head;
25049 if (!vn || !(vn = value_expr_check(p, vn)))
return NULL;
25050 if (!void_node) void_node = vn;
25051 for (
NODE *r = RNODE_RESCUE(node)->nd_resq; r; r = RNODE_RESBODY(r)->nd_next) {
25052 if (!nd_type_p(r, NODE_RESBODY)) {
25053 compile_error(p,
"unexpected node");
25056 if (!(vn = value_expr_check(p, RNODE_RESBODY(r)->nd_body))) {
25060 if (!void_node) void_node = vn;
25062 node = RNODE_RESCUE(node)->nd_else;
25063 if (!node)
return void_node;
25074 if (!RNODE_CASE3(node)->nd_body || !nd_type_p(RNODE_CASE3(node)->nd_body, NODE_IN)) {
25075 compile_error(p,
"unexpected node");
25078 if (RNODE_IN(RNODE_CASE3(node)->nd_body)->nd_body) {
25085 while (RNODE_BLOCK(node)->nd_next) {
25086 node = RNODE_BLOCK(node)->nd_next;
25088 node = RNODE_BLOCK(node)->nd_head;
25092 node = RNODE_BEGIN(node)->nd_body;
25097 if (!RNODE_IF(node)->nd_body) {
25100 else if (!RNODE_IF(node)->nd_else) {
25103 vn = value_expr_check(p, RNODE_IF(node)->nd_body);
25104 if (!vn)
return NULL;
25105 if (!void_node) void_node = vn;
25106 node = RNODE_IF(node)->nd_else;
25111 node = RNODE_AND(node)->nd_1st;
25117 mark_lvar_used(p, node);
25129 return void_node ? void_node : node;
25135 NODE *void_node = value_expr_check(p, node);
25137 yyerror1(&void_node->nd_loc,
"void value expression");
25147 const char *useless = 0;
25151 if (!node || !(node = nd_once_body(node)))
return;
25152 switch (nd_type(node)) {
25154 switch (RNODE_OPCALL(node)->nd_mid) {
25173 useless = rb_id2name(RNODE_OPCALL(node)->nd_mid);
25184 case NODE_BACK_REF:
25185 useless =
"a variable";
25188 useless =
"a constant";
25193 case NODE_ENCODING:
25196 case NODE_RATIONAL:
25197 case NODE_IMAGINARY:
25202 useless =
"a literal";
25227 useless =
"defined?";
25232 rb_warn1L(nd_line(node),
"possibly useless use of %s in void context", WARN_S(useless));
25240 NODE *
const n = node;
25242 if (!node)
return n;
25243 if (!nd_type_p(node, NODE_BLOCK))
return n;
25245 while (RNODE_BLOCK(node)->nd_next) {
25246 void_expr(p, RNODE_BLOCK(node)->nd_head);
25247 node = RNODE_BLOCK(node)->nd_next;
25249 return RNODE_BLOCK(node)->nd_head;
25253remove_begin(
NODE *node)
25255 NODE **n = &node, *n1 = node;
25256 while (n1 && nd_type_p(n1, NODE_BEGIN) && RNODE_BEGIN(n1)->nd_body) {
25257 *n = n1 = RNODE_BEGIN(n1)->nd_body;
25265 NODE *node = *body;
25268 *body = NEW_NIL(&NULL_LOC);
25271#define subnodes(type, n1, n2) \
25272 ((!type(node)->n1) ? (type(node)->n2 ? (body = &type(node)->n2, 1) : 0) : \
25273 (!type(node)->n2) ? (body = &type(node)->n1, 1) : \
25274 (reduce_nodes(p, &type(node)->n1), body = &type(node)->n2, 1))
25277 int newline = (int)nd_fl_newline(node);
25278 switch (nd_type(node)) {
25284 *body = node = RNODE_BEGIN(node)->nd_body;
25285 if (newline && node) nd_set_fl_newline(node);
25288 body = &RNODE_BLOCK(RNODE_BLOCK(node)->nd_end)->nd_head;
25292 if (subnodes(RNODE_IF, nd_body, nd_else))
break;
25295 body = &RNODE_CASE(node)->nd_body;
25298 if (!subnodes(RNODE_WHEN, nd_body, nd_next))
goto end;
25301 body = &RNODE_ENSURE(node)->nd_head;
25305 if (RNODE_RESCUE(node)->nd_else) {
25306 body = &RNODE_RESCUE(node)->nd_resq;
25309 if (!subnodes(RNODE_RESCUE, nd_head, nd_resq))
goto end;
25315 if (newline && node) nd_set_fl_newline(node);
25322is_static_content(
NODE *node)
25324 if (!node)
return 1;
25325 switch (nd_type(node)) {
25327 if (!(node = RNODE_HASH(node)->nd_head))
break;
25330 if (!is_static_content(RNODE_LIST(node)->nd_head))
return 0;
25331 }
while ((node = RNODE_LIST(node)->nd_next) != 0);
25336 case NODE_ENCODING:
25339 case NODE_RATIONAL:
25340 case NODE_IMAGINARY:
25356 switch (nd_type(node)) {
25370 if (!get_nd_value(p, node))
return 1;
25371 if (is_static_content(get_nd_value(p, node))) {
25373 rb_warn0L(nd_line(get_nd_value(p, node)),
"found '= literal' in conditional, should be ==");
25384#define SWITCH_BY_COND_TYPE(t, w, arg) do { \
25386 case COND_IN_OP: break; \
25387 case COND_IN_COND: rb_##w##0(arg "literal in condition"); break; \
25388 case COND_IN_FF: rb_##w##0(arg "literal in flip-flop"); break; \
25397 enum node_type
type;
25399 if (node == 0)
return 0;
25401 type = nd_type(node);
25403 if (
type == NODE_INTEGER) {
25404 if (!e_option_supplied(p)) rb_warn0L(nd_line(node),
"integer literal in flip-flop");
25405 ID lineno = rb_intern(
"$.");
25406 return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(lineno, loc), loc), loc);
25408 return cond0(p, node, COND_IN_FF, loc,
true);
25414 if (node == 0)
return 0;
25415 if (!(node = nd_once_body(node)))
return 0;
25416 assign_in_cond(p, node);
25418 switch (nd_type(node)) {
25420 RNODE_BEGIN(node)->nd_body = cond0(p, RNODE_BEGIN(node)->nd_body,
type, loc, top);
25427 SWITCH_BY_COND_TYPE(
type, warn,
"string ");
25431 if (!e_option_supplied(p)) SWITCH_BY_COND_TYPE(
type, warn,
"regex ");
25432 nd_set_type(node, NODE_MATCH);
25436 if (!e_option_supplied(p)) SWITCH_BY_COND_TYPE(
type, warning,
"regex ");
25438 return NEW_MATCH2(node, NEW_GVAR(idLASTLINE, loc), loc);
25442 NODE *end = RNODE_BLOCK(node)->nd_end;
25443 NODE **expr = &RNODE_BLOCK(end)->nd_head;
25444 if (top) top = node == end;
25445 *expr = cond0(p, *expr,
type, loc, top);
25451 RNODE_AND(node)->nd_1st = cond0(p, RNODE_AND(node)->nd_1st, COND_IN_COND, loc,
true);
25452 RNODE_AND(node)->nd_2nd = cond0(p, RNODE_AND(node)->nd_2nd, COND_IN_COND, loc,
true);
25458 RNODE_DOT2(node)->nd_beg = range_op(p, RNODE_DOT2(node)->nd_beg, loc);
25459 RNODE_DOT2(node)->nd_end = range_op(p, RNODE_DOT2(node)->nd_end, loc);
25460 switch (nd_type(node)) {
25462 nd_set_type(node,NODE_FLIP2);
25467 nd_set_type(node, NODE_FLIP3);
25476 SWITCH_BY_COND_TYPE(
type, warning,
"symbol ");
25480 case NODE_ENCODING:
25483 case NODE_RATIONAL:
25484 case NODE_IMAGINARY:
25485 SWITCH_BY_COND_TYPE(
type, warning,
"");
25497 if (node == 0)
return 0;
25498 return cond0(p, node, COND_IN_COND, loc,
true);
25504 if (node == 0)
return 0;
25505 return cond0(p, node, COND_IN_OP, loc,
true);
25512 return NEW_NIL(&loc);
25518 if (!cc)
return right;
25519 cc = cond0(p, cc, COND_IN_COND, loc,
true);
25520 return newline_node(NEW_IF(cc, left, right, loc, if_keyword_loc, then_keyword_loc, end_keyword_loc));
25526 if (!cc)
return right;
25527 cc = cond0(p, cc, COND_IN_COND, loc,
true);
25528 return newline_node(NEW_UNLESS(cc, left, right, loc, keyword_loc, then_keyword_loc, end_keyword_loc));
25531#define NEW_AND_OR(type, f, s, loc, op_loc) (type == NODE_AND ? NEW_AND(f,s,loc,op_loc) : NEW_OR(f,s,loc,op_loc))
25537 enum node_type
type =
id == idAND ||
id == idANDOP ? NODE_AND : NODE_OR;
25540 if (left && nd_type_p(left,
type)) {
25541 NODE *node = left, *second;
25542 while ((second = RNODE_AND(node)->nd_2nd) != 0 && nd_type_p(second,
type)) {
25545 RNODE_AND(node)->nd_2nd = NEW_AND_OR(
type, second, right, loc, op_loc);
25546 nd_set_line(RNODE_AND(node)->nd_2nd, op_loc->beg_pos.lineno);
25547 left->nd_loc.end_pos = loc->end_pos;
25550 op = NEW_AND_OR(
type, left, right, loc, op_loc);
25551 nd_set_line(op, op_loc->beg_pos.lineno);
25560 if (nd_type_p(node, NODE_BLOCK_PASS)) {
25561 compile_error(p,
"block argument should not be given");
25569 no_blockarg(p, node);
25570 if (nd_type_p(node, NODE_LIST) && !RNODE_LIST(node)->nd_next) {
25571 node = RNODE_LIST(node)->nd_head;
25580 switch (nd_type(node)) {
25582 RNODE_INTEGER(node)->minus = TRUE;
25585 RNODE_FLOAT(node)->minus = TRUE;
25587 case NODE_RATIONAL:
25588 RNODE_RATIONAL(node)->minus = TRUE;
25590 case NODE_IMAGINARY:
25591 RNODE_IMAGINARY(node)->minus = TRUE;
25601 if (!node1)
return (
NODE *)node2;
25602 node2->nd_head = node1;
25603 nd_set_first_lineno(node2, nd_first_lineno(node1));
25604 nd_set_first_column(node2, nd_first_column(node1));
25605 return (
NODE *)node2;
25613 if (args->pre_args_num)
return false;
25614 if (args->post_args_num)
return false;
25615 if (args->rest_arg)
return false;
25616 if (args->opt_args)
return false;
25617 if (args->block_arg)
return false;
25618 if (args->kw_args)
return false;
25619 if (args->kw_rest_arg)
return false;
25628 if (args->forwarding) {
25630 yyerror1(&RNODE(tail)->nd_loc,
"... after rest argument");
25633 rest_arg = idFWD_REST;
25636 args->pre_args_num = pre_args ? pre_args->nd_plen : 0;
25637 args->pre_init = pre_args ? pre_args->nd_next : 0;
25639 args->post_args_num = post_args ? post_args->nd_plen : 0;
25640 args->post_init = post_args ? post_args->nd_next : 0;
25641 args->first_post_arg = post_args ? post_args->nd_pid : 0;
25643 args->rest_arg = rest_arg;
25645 args->opt_args = opt_args;
25647#ifdef FORWARD_ARGS_WITH_RUBY2_KEYWORDS
25648 args->ruby2_keywords = args->forwarding;
25650 args->ruby2_keywords = 0;
25653 nd_set_loc(RNODE(tail), loc);
25663 if (p->error_p)
return node;
25665 args->block_arg = block;
25666 args->kw_args = kw_args;
25675 ID kw_bits = internal_id(p), *required_kw_vars, *kw_vars;
25676 struct vtable *vtargs = p->lvtbl->args;
25679 if (block) block = vtargs->tbl[vtargs->pos-1];
25680 vtable_pop(vtargs, !!block + !!kw_rest_arg);
25681 required_kw_vars = kw_vars = &vtargs->tbl[vtargs->pos];
25683 if (!NODE_REQUIRED_KEYWORD_P(get_nd_value(p, kwn->nd_body)))
25685 --required_kw_vars;
25686 kwn = kwn->nd_next;
25689 for (kwn = kw_args; kwn; kwn = kwn->nd_next) {
25690 ID vid = get_nd_vid(p, kwn->nd_body);
25691 if (NODE_REQUIRED_KEYWORD_P(get_nd_value(p, kwn->nd_body))) {
25692 *required_kw_vars++ = vid;
25699 arg_var(p, kw_bits);
25700 if (kw_rest_arg) arg_var(p, kw_rest_arg);
25701 if (block) arg_var(p, block);
25703 args->kw_rest_arg = NEW_DVAR(kw_rest_arg, kw_rest_loc);
25705 else if (kw_rest_arg == idNil) {
25706 args->no_kwarg = 1;
25708 else if (kw_rest_arg) {
25709 args->kw_rest_arg = NEW_DVAR(kw_rest_arg, kw_rest_loc);
25718 if (max_numparam > NO_PARAM || it_id) {
25720 YYLTYPE loc = RUBY_INIT_YYLLOC();
25721 args = new_args_tail(p, 0, 0, 0, 0);
25722 nd_set_loc(RNODE(args), &loc);
25724 args->nd_ainfo.pre_args_num = it_id ? 1 : max_numparam;
25732 RNODE_ARYPTN(aryptn)->nd_pconst = constant;
25735 NODE *pre_args = NEW_LIST(pre_arg, loc);
25736 if (RNODE_ARYPTN(aryptn)->pre_args) {
25737 RNODE_ARYPTN(aryptn)->pre_args = list_concat(pre_args, RNODE_ARYPTN(aryptn)->pre_args);
25740 RNODE_ARYPTN(aryptn)->pre_args = pre_args;
25750 rest_arg = rest_arg ? rest_arg : NODE_SPECIAL_NO_NAME_REST;
25755 NODE *node = NEW_ARYPTN(pre_args, rest_arg, post_args, loc);
25763 RNODE_FNDPTN(fndptn)->nd_pconst = constant;
25771 pre_rest_arg = pre_rest_arg ? pre_rest_arg : NODE_SPECIAL_NO_NAME_REST;
25772 post_rest_arg = post_rest_arg ? post_rest_arg : NODE_SPECIAL_NO_NAME_REST;
25773 NODE *node = NEW_FNDPTN(pre_rest_arg, args, post_rest_arg, loc);
25781 RNODE_HSHPTN(hshptn)->nd_pconst = constant;
25788 NODE *node, *kw_rest_arg_node;
25790 if (kw_rest_arg == idNil) {
25791 kw_rest_arg_node = NODE_SPECIAL_NO_REST_KEYWORD;
25793 else if (kw_rest_arg) {
25794 kw_rest_arg_node = assignable(p, kw_rest_arg, 0, loc);
25797 kw_rest_arg_node = NULL;
25800 node = NEW_HSHPTN(0, kw_args, kw_rest_arg_node, loc);
25809 return NEW_SYM(STR_NEW0(), loc);
25812 switch (nd_type(node)) {
25814 nd_set_type(node, NODE_DSYM);
25815 nd_set_loc(node, loc);
25818 node = str_to_sym_node(p, node, loc);
25821 node = NEW_DSYM(0, 1, NEW_LIST(node, loc), loc);
25828nd_type_st_key_enable_p(
NODE *node)
25830 switch (nd_type(node)) {
25833 case NODE_RATIONAL:
25834 case NODE_IMAGINARY:
25840 case NODE_ENCODING:
25850 switch (nd_type(node)) {
25852 return rb_node_str_string_val(node);
25854 return rb_node_integer_literal_val(node);
25856 return rb_node_float_literal_val(node);
25857 case NODE_RATIONAL:
25858 return rb_node_rational_literal_val(node);
25859 case NODE_IMAGINARY:
25860 return rb_node_imaginary_literal_val(node);
25862 return rb_node_sym_string_val(node);
25864 return rb_node_regx_string_val(node);
25866 return rb_node_line_lineno_val(node);
25867 case NODE_ENCODING:
25868 return rb_node_encoding_val(node);
25870 return rb_node_file_path_val(node);
25872 rb_bug(
"unexpected node: %s", ruby_node_name(nd_type(node)));
25881 p->warn_duplicate_keys_table = st_init_table_with_size(&literal_type, RNODE_LIST(hash)->as.nd_alen / 2);
25882 while (hash && RNODE_LIST(hash)->nd_next) {
25883 NODE *head = RNODE_LIST(hash)->nd_head;
25884 NODE *value = RNODE_LIST(hash)->nd_next;
25885 NODE *next = RNODE_LIST(value)->nd_next;
25894 if (nd_type_st_key_enable_p(head)) {
25895 key = (st_data_t)head;
25897 if (st_delete(p->warn_duplicate_keys_table, &key, &data)) {
25898 rb_warn2L(nd_line((
NODE *)data),
25899 "key %+"PRIsWARN
" is duplicated and overwritten on line %d",
25900 nd_value(p, head), WARN_I(nd_line(head)));
25902 st_insert(p->warn_duplicate_keys_table, (st_data_t)key, (st_data_t)hash);
25906 st_free_table(p->warn_duplicate_keys_table);
25907 p->warn_duplicate_keys_table = NULL;
25913 if (hash) warn_duplicate_keys(p, hash);
25914 return NEW_HASH(hash, loc);
25920 if (is_private_local_id(p,
id)) {
25923 if (st_is_member(p->pvtbl,
id)) {
25924 yyerror1(loc,
"duplicated variable name");
25927 st_insert(p->pvtbl, (st_data_t)
id, 0);
25935 p->pktbl = st_init_numtable();
25937 else if (st_is_member(p->pktbl, key)) {
25938 yyerror1(loc,
"duplicated key name");
25941 st_insert(p->pktbl, (st_data_t)key, 0);
25947 return NEW_HASH(hash, loc);
25956 ID vid = get_nd_vid(p, lhs);
25957 YYLTYPE lhs_loc = lhs->nd_loc;
25959 set_nd_value(p, lhs, rhs);
25960 nd_set_loc(lhs, loc);
25961 asgn = NEW_OP_ASGN_OR(gettable(p, vid, &lhs_loc), lhs, loc);
25963 else if (op == tANDOP) {
25964 set_nd_value(p, lhs, rhs);
25965 nd_set_loc(lhs, loc);
25966 asgn = NEW_OP_ASGN_AND(gettable(p, vid, &lhs_loc), lhs, loc);
25970 rhs = NEW_CALL(gettable(p, vid, &lhs_loc), op, NEW_LIST(rhs, &rhs->nd_loc), loc);
25971 set_nd_value(p, asgn, rhs);
25972 nd_set_loc(asgn, loc);
25976 asgn = NEW_ERROR(loc);
25988 aryset_check(p, args);
25989 args = make_list(args, args_loc);
25990 asgn = NEW_OP_ASGN1(ary, op, args, rhs, loc, call_operator_loc, opening_loc, closing_loc, binary_operator_loc);
26002 asgn = NEW_OP_ASGN2(lhs, CALL_Q_P(atype), attr, op, rhs, loc, call_operator_loc, message_loc, binary_operator_loc);
26013 asgn = NEW_OP_CDECL(lhs, op, rhs, ctxt.shareable_constant_value, loc);
26016 asgn = NEW_ERROR(loc);
26025 if (p->ctxt.in_def) {
26027 yyerror1(loc,
"dynamic constant assignment");
26029 set_value(assign_error(p,
"dynamic constant assignment", p->s_lvalue));
26032 return NEW_CDECL(0, 0, (path), p->ctxt.shareable_constant_value, loc);
26039 a = dispatch2(assign_error, ERR_MESG(), a);
26048 NODE *result = head;
26050 NODE *tmp = rescue_else ? rescue_else : rescue;
26051 YYLTYPE rescue_loc = code_loc_gen(&head->nd_loc, &tmp->nd_loc);
26053 result = NEW_RESCUE(head, rescue, rescue_else, &rescue_loc);
26054 nd_set_line(result, rescue->nd_loc.beg_pos.lineno);
26057 result = NEW_ENSURE(result, ensure, loc);
26059 fixpos(result, head);
26068 if (!local->used)
return;
26069 cnt = local->used->pos;
26070 if (cnt != local->vars->pos) {
26071 rb_parser_fatal(p,
"local->used->pos != local->vars->pos");
26074 ID *v = local->vars->tbl;
26075 ID *u = local->used->tbl;
26076 for (
int i = 0; i < cnt; ++i) {
26077 if (!v[i] || (u[i] & LVAR_USED))
continue;
26078 if (is_private_local_id(p, v[i]))
continue;
26079 rb_warn1L((
int)u[i],
"assigned but unused variable - %"PRIsWARN, rb_id2str(v[i]));
26088 int inherits_dvars = toplevel_scope && compile_for_eval;
26092 local->prev = p->lvtbl;
26093 local->args = vtable_alloc(0);
26094 local->vars = vtable_alloc(inherits_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
26096 if (toplevel_scope && compile_for_eval) warn_unused_vars = 0;
26097 if (toplevel_scope && e_option_supplied(p)) warn_unused_vars = 0;
26099 local->numparam.outer = 0;
26100 local->numparam.inner = 0;
26101 local->numparam.current = 0;
26103 local->used = warn_unused_vars ? vtable_alloc(0) : 0;
26105# if WARN_PAST_SCOPE
26116 while (!DVARS_TERMINAL_P(table)) {
26117 struct vtable *cur_table = table;
26118 table = cur_table->prev;
26119 vtable_free(cur_table);
26126 vtable_chain_free(p, local->used);
26128# if WARN_PAST_SCOPE
26129 vtable_chain_free(p, local->past);
26132 vtable_chain_free(p, local->args);
26133 vtable_chain_free(p, local->vars);
26135 ruby_sized_xfree(local,
sizeof(
struct local_vars));
26142 if (p->lvtbl->used) {
26143 warn_unused_var(p, p->lvtbl);
26146 local_free(p, p->lvtbl);
26156 int cnt_args = vtable_size(p->lvtbl->args);
26157 int cnt_vars = vtable_size(p->lvtbl->vars);
26158 int cnt = cnt_args + cnt_vars;
26162 if (cnt <= 0)
return 0;
26163 tbl = rb_ast_new_local_table(p->ast, cnt);
26164 MEMCPY(tbl->ids, p->lvtbl->args->tbl,
ID, cnt_args);
26166 for (i = 0, j = cnt_args; i < cnt_vars; ++i) {
26167 ID id = p->lvtbl->vars->tbl[i];
26168 if (!vtable_included(p->lvtbl->args,
id)) {
26169 tbl->ids[j++] = id;
26173 tbl = rb_ast_resize_latest_local_table(p->ast, j);
26182 if (!NUMPARAM_ID_P(
id))
return;
26183 compile_error(p,
"_%d is reserved for numbered parameter",
26184 NUMPARAM_ID_TO_IDX(
id));
26190 numparam_name(p,
id);
26191 vtable_add(p->lvtbl->args,
id);
26197 numparam_name(p,
id);
26198 vtable_add(p->lvtbl->vars,
id);
26199 if (p->lvtbl->used) {
26200 vtable_add(p->lvtbl->used, (
ID)p->ruby_sourceline);
26208 return rb_local_defined(
id, iseq);
26215 struct vtable *vars, *args, *used;
26217 vars = p->lvtbl->vars;
26218 args = p->lvtbl->args;
26219 used = p->lvtbl->used;
26221 while (vars && !DVARS_TERMINAL_P(vars->prev)) {
26224 if (used) used = used->prev;
26227 if (vars && vars->prev == DVARS_INHERIT) {
26228 return rb_parser_local_defined(p,
id, p->parent_iseq);
26230 else if (vtable_included(args,
id)) {
26234 int i = vtable_included(vars,
id);
26235 if (i && used && vidrefp) *vidrefp = &used->tbl[i-1];
26243 return local_id_ref(p,
id, NULL);
26249 if (local_id(p, idFWD_ALL))
return TRUE;
26250 compile_error(p,
"unexpected ...");
26257 arg_var(p, idFWD_REST);
26258#ifndef FORWARD_ARGS_WITH_RUBY2_KEYWORDS
26259 arg_var(p, idFWD_KWREST);
26261 arg_var(p, idFWD_BLOCK);
26262 arg_var(p, idFWD_ALL);
26268 bool conflict =
false;
26270 struct vtable *vars, *args;
26272 vars = p->lvtbl->vars;
26273 args = p->lvtbl->args;
26275 while (vars && !DVARS_TERMINAL_P(vars->prev)) {
26276 conflict |= (vtable_included(args, arg) && !(all && vtable_included(args, all)));
26281 bool found =
false;
26282 if (vars && vars->prev == DVARS_INHERIT && !found) {
26283 found = (rb_parser_local_defined(p, arg, p->parent_iseq) &&
26284 !(all && rb_parser_local_defined(p, all, p->parent_iseq)));
26287 found = (vtable_included(args, arg) &&
26288 !(all && vtable_included(args, all)));
26292 compile_error(p,
"no anonymous %s parameter", var);
26294 else if (conflict) {
26295 compile_error(p,
"anonymous %s parameter is also used within block", var);
26302 NODE *rest = NEW_LVAR(idFWD_REST, loc);
26303#ifndef FORWARD_ARGS_WITH_RUBY2_KEYWORDS
26304 NODE *kwrest = list_append(p, NEW_LIST(0, loc), NEW_LVAR(idFWD_KWREST, loc));
26307 NODE *args = leading ? rest_arg_append(p, leading, rest, argsloc) : NEW_SPLAT(rest, loc, &NULL_LOC);
26308 block->forwarding = TRUE;
26309#ifndef FORWARD_ARGS_WITH_RUBY2_KEYWORDS
26310 args = arg_append(p, args, new_hash(p, kwrest, loc), argsloc);
26312 return arg_blk_pass(args, block);
26319 NODE *inner = local->numparam.inner;
26320 if (!local->numparam.outer) {
26321 local->numparam.outer = local->numparam.current;
26323 local->numparam.inner = 0;
26324 local->numparam.current = 0;
26335 local->numparam.inner = prev_inner;
26337 else if (local->numparam.current) {
26339 local->numparam.inner = local->numparam.current;
26341 if (p->max_numparam > NO_PARAM) {
26343 local->numparam.current = local->numparam.outer;
26344 local->numparam.outer = 0;
26348 local->numparam.current = 0;
26353static const struct vtable *
26356 p->lvtbl->args = vtable_alloc(p->lvtbl->args);
26357 p->lvtbl->vars = vtable_alloc(p->lvtbl->vars);
26358 if (p->lvtbl->used) {
26359 p->lvtbl->used = vtable_alloc(p->lvtbl->used);
26361 return p->lvtbl->args;
26367 struct vtable *tmp = *vtblp;
26368 *vtblp = tmp->prev;
26369# if WARN_PAST_SCOPE
26370 if (p->past_scope_enabled) {
26371 tmp->prev = p->lvtbl->past;
26372 p->lvtbl->past = tmp;
26384 if ((tmp = p->lvtbl->used) != 0) {
26385 warn_unused_var(p, p->lvtbl);
26386 p->lvtbl->used = p->lvtbl->used->prev;
26389 dyna_pop_vtable(p, &p->lvtbl->args);
26390 dyna_pop_vtable(p, &p->lvtbl->vars);
26396 while (p->lvtbl->args != lvargs) {
26398 if (!p->lvtbl->args) {
26400 ruby_sized_xfree(p->lvtbl,
sizeof(*p->lvtbl));
26410 return !DVARS_TERMINAL_P(p->lvtbl->vars) && p->lvtbl->vars->prev != DVARS_TOPSCOPE;
26417 struct vtable *vars, *args, *used;
26420 args = p->lvtbl->args;
26421 vars = p->lvtbl->vars;
26422 used = p->lvtbl->used;
26424 while (!DVARS_TERMINAL_P(vars)) {
26425 if (vtable_included(args,
id)) {
26428 if ((i = vtable_included(vars,
id)) != 0) {
26429 if (used && vidrefp) *vidrefp = &used->tbl[i-1];
26434 if (!vidrefp) used = 0;
26435 if (used) used = used->prev;
26438 if (vars == DVARS_INHERIT && !NUMPARAM_ID_P(
id)) {
26439 return rb_dvar_defined(
id, p->parent_iseq);
26449 return dvar_defined_ref(p,
id, NULL);
26455 return (vtable_included(p->lvtbl->args,
id) ||
26456 vtable_included(p->lvtbl->vars,
id));
26463 "regexp encoding option '%c' differs from source encoding '%s'",
26464 c, rb_enc_name(rb_parser_str_get_encoding(str)));
26471 int idx = rb_enc_find_index(name);
26473 rb_bug(
"unknown encoding name: %s", name);
26476 return rb_enc_from_index(idx);
26485 case ENC_ASCII8BIT:
26486 enc = rb_ascii8bit_encoding();
26489 enc = find_enc(p,
"EUC-JP");
26491 case ENC_Windows_31J:
26492 enc = find_enc(p,
"Windows-31J");
26495 enc = rb_utf8_encoding();
26508 int c = RE_OPTION_ENCODING_IDX(options);
26514 char_to_option_kcode(c, &opt, &idx);
26515 enc = kcode_to_enc(p, idx);
26516 if (enc != rb_parser_str_get_encoding(str) &&
26517 !rb_parser_is_ascii_string(p, str)) {
26520 rb_parser_string_set_encoding(str, enc);
26522 else if (RE_OPTION_ENCODING_NONE(options)) {
26523 if (!PARSER_ENCODING_IS_ASCII8BIT(p, str) &&
26524 !rb_parser_is_ascii_string(p, str)) {
26528 rb_parser_enc_associate(p, str, rb_ascii8bit_encoding());
26530 else if (rb_is_usascii_enc(p->enc)) {
26531 rb_parser_enc_associate(p, str, rb_ascii8bit_encoding());
26543 int c = rb_reg_fragment_setenc(p, str, options);
26544 if (c) reg_fragment_enc_error(p, str, c);
26547#ifndef UNIVERSAL_PARSER
26553 rb_parser_assignable_func assignable;
26557reg_named_capture_assign_iter(
const OnigUChar *name,
const OnigUChar *name_end,
26558 int back_num,
int *back_refs,
OnigRegex regex,
void *arg0)
26563 long len = name_end - name;
26564 const char *s = (
const char *)name;
26566 return rb_reg_named_capture_assign_iter_impl(p, s,
len, enc, &arg->succ_block, arg->loc, arg->assignable);
26570reg_named_capture_assign(
struct parser_params* p,
VALUE regexp,
const YYLTYPE *loc, rb_parser_assignable_func assignable)
26575 arg.enc = rb_enc_get(regexp);
26576 arg.succ_block = 0;
26578 arg.assignable = assignable;
26579 onig_foreach_name(
RREGEXP_PTR(regexp), reg_named_capture_assign_iter, &arg);
26581 if (!arg.succ_block)
return 0;
26582 return RNODE_BLOCK(arg.succ_block)->nd_next;
26590 return assignable(p,
id, val, loc);
26594rb_reg_named_capture_assign_iter_impl(
struct parser_params *p,
const char *s,
long len,
26600 if (!
len)
return ST_CONTINUE;
26601 if (!VALID_SYMNAME_P(s,
len, enc, ID_LOCAL))
26602 return ST_CONTINUE;
26604 var = intern_cstr(s,
len, enc);
26605 if (
len < MAX_WORD_LENGTH && rb_reserved_word(s, (
int)
len)) {
26606 if (!lvar_defined(p, var))
return ST_CONTINUE;
26608 node = node_assign(p, assignable(p, var, 0, loc), NEW_SYM(rb_id2str(var), loc), NO_LEX_CTXT, loc);
26609 succ = *succ_block;
26610 if (!succ) succ = NEW_ERROR(loc);
26611 succ = block_append(p, succ, node);
26612 *succ_block = succ;
26613 return ST_CONTINUE;
26621 reg_fragment_setenc(p, str, options);
26622 str2 = rb_str_new_parser_string(str);
26623 return rb_parser_reg_compile(p, str2, options);
26630 return rb_reg_compile(str, options & RE_OPTION_MASK, p->ruby_sourcefile, p->ruby_sourceline);
26640 err = rb_errinfo();
26641 re = parser_reg_compile(p, str, options);
26643 VALUE m = rb_attr_get(rb_errinfo(), idMesg);
26644 rb_set_errinfo(err);
26645 compile_error(p,
"%"PRIsVALUE, m);
26653rb_ruby_parser_set_options(
struct parser_params *p,
int print,
int loop,
int chomp,
int split)
26655 p->do_print = print;
26657 p->do_chomp = chomp;
26658 p->do_split = split;
26664 static const YYLTYPE default_location = {{1, 0}, {1, 0}};
26665 const YYLTYPE *
const LOC = &default_location;
26668 NODE *print = (
NODE *)NEW_FCALL(rb_intern(
"print"),
26669 NEW_LIST(NEW_GVAR(idLASTLINE, LOC), LOC),
26671 node = block_append(p, node, print);
26675 NODE *irs = NEW_LIST(NEW_GVAR(rb_intern(
"$/"), LOC), LOC);
26678 ID ifs = rb_intern(
"$;");
26679 ID fields = rb_intern(
"$F");
26680 NODE *args = NEW_LIST(NEW_GVAR(ifs, LOC), LOC);
26681 NODE *split = NEW_GASGN(fields,
26682 NEW_CALL(NEW_GVAR(idLASTLINE, LOC),
26683 rb_intern(
"split"), args, LOC),
26685 node = block_append(p, split, node);
26689 chomp = list_append(p, NEW_LIST(chomp, LOC), NEW_TRUE(LOC));
26690 irs = list_append(p, irs, NEW_HASH(chomp, LOC));
26693 node = NEW_WHILE((
NODE *)NEW_FCALL(idGets, irs, LOC), node, 1, LOC, &NULL_LOC, &NULL_LOC);
26710 return rb_make_temporary_id(vtable_size(p->lvtbl->args) + vtable_size(p->lvtbl->vars));
26718 p->command_start = TRUE;
26719 p->ruby_sourcefile_string =
Qnil;
26720 p->lex.lpar_beg = -1;
26721 string_buffer_init(p);
26723 p->delayed.token = NULL;
26724 p->frozen_string_literal = -1;
26726 p->error_buffer =
Qfalse;
26727 p->end_expect_token_locations = NULL;
26732 p->parsing_thread =
Qnil;
26734 p->s_lvalue =
Qnil;
26737 p->debug_buffer =
Qnil;
26738 p->debug_output = rb_ractor_stdout();
26739 p->enc = rb_utf8_encoding();
26744#define rb_ruby_parser_mark ripper_parser_mark
26745#define rb_ruby_parser_free ripper_parser_free
26746#define rb_ruby_parser_memsize ripper_parser_memsize
26750rb_ruby_parser_mark(
void *ptr)
26754 rb_gc_mark(p->ruby_sourcefile_string);
26756 rb_gc_mark(p->error_buffer);
26758 rb_gc_mark(p->value);
26759 rb_gc_mark(p->result);
26760 rb_gc_mark(p->parsing_thread);
26761 rb_gc_mark(p->s_value);
26762 rb_gc_mark(p->s_lvalue);
26763 rb_gc_mark(p->s_value_stack);
26765 rb_gc_mark(p->debug_buffer);
26766 rb_gc_mark(p->debug_output);
26770rb_ruby_parser_free(
void *ptr)
26776 rb_ast_free(p->ast);
26779 if (p->warn_duplicate_keys_table) {
26780 st_free_table(p->warn_duplicate_keys_table);
26785 rb_parser_ary_free(p, p->tokens);
26790 ruby_sized_xfree(p->tokenbuf, p->toksiz);
26793 for (local = p->lvtbl; local; local = prev) {
26794 prev = local->prev;
26795 local_free(p, local);
26800 while ((ptinfo = p->token_info) != 0) {
26801 p->token_info = ptinfo->next;
26805 string_buffer_free(p);
26808 st_free_table(p->pvtbl);
26811 if (CASE_LABELS_ENABLED_P(p->case_labels)) {
26812 st_free_table(p->case_labels);
26815 xfree(p->lex.strterm);
26816 p->lex.strterm = 0;
26822rb_ruby_parser_memsize(
const void *ptr)
26826 size_t size =
sizeof(*p);
26829 for (local = p->lvtbl; local; local = local->prev) {
26830 size +=
sizeof(*local);
26831 if (local->vars) size += local->vars->capa *
sizeof(
ID);
26837#undef rb_reserved_word
26840rb_reserved_word(
const char *str,
unsigned int len)
26842 return reserved_word(str,
len);
26845#ifdef UNIVERSAL_PARSER
26847rb_ruby_parser_allocate(
const rb_parser_config_t *config)
26851 p->config = config;
26856rb_ruby_parser_new(
const rb_parser_config_t *config)
26859 rb_parser_t *p = rb_ruby_parser_allocate(config);
26860 parser_initialize(p);
26865rb_ruby_parser_allocate(
void)
26873rb_ruby_parser_new(
void)
26877 parser_initialize(p);
26886 p->parent_iseq = base;
26893 p->debug_lines = rb_parser_ary_new_capa_for_script_line(p, 10);
26899 p->error_tolerant = 1;
26905 p->keep_tokens = 1;
26906 p->tokens = rb_parser_ary_new_capa_for_ast_token(p, 10);
26918 return p->ruby__end__seen;
26922rb_ruby_parser_set_yydebug(
rb_parser_t *p,
int flag)
26951 return p->debug_output;
26957 p->debug_output = output;
26963 return p->parsing_thread;
26969 p->parsing_thread = parsing_thread;
26973rb_ruby_parser_ripper_initialize(
rb_parser_t *p, rb_parser_lex_gets_func *gets, rb_parser_input_data input,
VALUE sourcefile_string,
const char *sourcefile,
int sourceline)
26975 p->lex.gets = gets;
26976 p->lex.input = input;
26978 p->ruby_sourcefile_string = sourcefile_string;
26979 p->ruby_sourcefile = sourcefile;
26980 p->ruby_sourceline = sourceline;
26996rb_ruby_parser_ruby_sourcefile_string(
rb_parser_t *p)
26998 return p->ruby_sourcefile_string;
27004 return p->ruby_sourceline;
27010 return p->lex.state;
27017 p->ast = rb_ast_new();
27018 ripper_yyparse((
void*)p);
27019 rb_ast_free(p->ast);
27022 p->eval_tree_begin = 0;
27028 return dedent_string(p,
string, width);
27034 return p->lex.input != 0;
27040 parser_initialize(p);
27046 return p->lex.ptok - p->lex.pbeg;
27052 return p->lex.pcur - p->lex.ptok;
27058 return p->lex.lastline;
27062rb_ruby_ripper_lex_state_name(
struct parser_params *p,
int state)
27064 return rb_parser_lex_state_name(p, (
enum lex_state_e)state);
27067#ifdef UNIVERSAL_PARSER
27069rb_ripper_parser_params_allocate(
const rb_parser_config_t *config)
27072 p->config = config;
27078rb_ruby_ripper_parser_allocate(
void)
27086rb_parser_printf(
struct parser_params *p,
const char *fmt, ...)
27089 VALUE mesg = p->debug_buffer;
27093 rb_str_vcatf(mesg, fmt, ap);
27095 if (char_at_end(p, mesg, 0) ==
'\n') {
27096 rb_io_write(p->debug_output, mesg);
27097 p->debug_buffer =
Qnil;
27105 int lineno, column;
27108 lineno = loc->end_pos.lineno;
27109 column = loc->end_pos.column;
27112 lineno = p->ruby_sourceline;
27116 rb_io_flush(p->debug_output);
27120 rb_syntax_error_append(p->error_buffer,
27121 p->ruby_sourcefile_string,
27128count_char(
const char *str,
int c)
27131 while (str[n] == c) ++n;
27142rb_yytnamerr(
struct parser_params *p,
char *yyres,
const char *yystr)
27144 if (*yystr ==
'"') {
27145 size_t yyn = 0, bquote = 0;
27146 const char *yyp = yystr;
27152 bquote = count_char(yyp+1,
'\'') + 1;
27153 if (yyres) memcpy(&yyres[yyn], yyp, bquote);
27159 if (bquote && count_char(yyp+1,
'\'') + 1 == bquote) {
27160 if (yyres) memcpy(yyres + yyn, yyp, bquote);
27166 if (yyp[1] && yyp[1] !=
'\'' && yyp[2] ==
'\'') {
27167 if (yyres) memcpy(yyres + yyn, yyp, 3);
27172 goto do_not_strip_quotes;
27176 goto do_not_strip_quotes;
27179 if (*++yyp !=
'\\')
27180 goto do_not_strip_quotes;
27195 do_not_strip_quotes: ;
27198 if (!yyres)
return strlen(yystr);
27200 return (YYSIZE_T)(yystpcpy(yyres, yystr) - yyres);
27205#define validate(x) (void)(x)
27234 return rb_funcall(p->value, mid, 3, a, b, c);
27244 return rb_funcall(p->value, mid, 4, a, b, c, d);
27255 return rb_funcall(p->value, mid, 5, a, b, c, d, e);
27268 return rb_funcall(p->value, mid, 7, a, b, c, d, e, f, g);
#define ENC_CODERANGE_7BIT
Old name of RUBY_ENC_CODERANGE_7BIT.
#define REALLOC_N
Old name of RB_REALLOC_N.
#define ISSPACE
Old name of rb_isspace.
#define ALLOC
Old name of RB_ALLOC.
#define xfree
Old name of ruby_xfree.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define ZALLOC
Old name of RB_ZALLOC.
#define ENC_CODERANGE_UNKNOWN
Old name of RUBY_ENC_CODERANGE_UNKNOWN.
#define xmalloc
Old name of ruby_xmalloc.
#define ISDIGIT
Old name of rb_isdigit.
#define ASSUME
Old name of RBIMPL_ASSUME.
#define ALLOC_N
Old name of RB_ALLOC_N.
#define MBCLEN_CHARFOUND_LEN(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_LEN.
#define STRCASECMP
Old name of st_locale_insensitive_strcasecmp.
#define ISALPHA
Old name of rb_isalpha.
#define STRNCASECMP
Old name of st_locale_insensitive_strncasecmp.
#define ISASCII
Old name of rb_isascii.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define NIL_P
Old name of RB_NIL_P.
#define MBCLEN_CHARFOUND_P(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_P.
#define ISPRINT
Old name of rb_isprint.
#define xcalloc
Old name of ruby_xcalloc.
#define ISXDIGIT
Old name of rb_isxdigit.
#define ISCNTRL
Old name of rb_iscntrl.
#define ISALNUM
Old name of rb_isalnum.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
VALUE rb_eRuntimeError
RuntimeError exception.
VALUE rb_eSyntaxError
SyntaxError exception.
VALUE rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
Allocates, then initialises an instance of the given class.
long rb_str_coderange_scan_restartable(const char *str, const char *end, rb_encoding *enc, int *cr)
Scans the passed string until it finds something odd.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_pop(VALUE ary)
Destructively deletes an element from the end of the passed array and returns what was deleted.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
#define rb_usascii_str_new(str, len)
Identical to rb_str_new, except it generates a string of "US ASCII" encoding.
VALUE rb_str_cat(VALUE dst, const char *src, long srclen)
Destructively appends the passed contents to the string.
#define rb_strlen_lit(str)
Length of a string literal.
#define rb_str_cat_cstr(buf, str)
Identical to rb_str_cat(), except it assumes the passed pointer is a pointer to a C string.
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
ID rb_sym2id(VALUE obj)
Converts an instance of rb_cSymbol into an ID.
int len
Length of the buffer.
#define strtod(s, e)
Just another name of ruby_strtod.
#define strdup(s)
Just another name of ruby_strdup.
#define rb_long2int
Just another name of rb_long2int_inline.
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define ALLOCA_N(type, n)
#define MEMZERO(p, type, n)
Handy macro to erase a region of memory.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
#define MEMMOVE(p1, p2, type, n)
Handy macro to call memmove.
VALUE type(ANYARGS)
ANYARGS-ed function type.
Functions related to nodes in the AST.
#define RREGEXP_PTR(obj)
Convenient accessor macro.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
#define errno
Ractor-aware version of errno.
#define RTEST
This is an old name of RB_TEST.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
#define RBIMPL_WARNING_IGNORED(flag)
Suppresses a warning.
#define RBIMPL_WARNING_PUSH()
Pushes compiler warning state.
#define RBIMPL_WARNING_POP()
Pops compiler warning state.