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
100 #include "internal.h"
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"
130 syntax_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));
192 static st_index_t rb_char_p_hash(
const char *c);
195 literal_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));
239 literal_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)
334 return parse_isalpha(c) || parse_isdigit(c);
338 #define ISALNUM(c) parse_isalnum(c)
341 parse_isxdigit(
int c)
343 return parse_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"
361 enum rescue_context {
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 BITFIELD(
enum rb_parser_shareability, shareable_constant_value, 2);
375 BITFIELD(
enum rescue_context, in_rescue, 2);
376 unsigned int cant_return: 1;
381 #if defined(__GNUC__) && !defined(__clang__)
393 #define NO_LEX_CTXT (struct lex_context){0}
395 #ifndef WARN_PAST_SCOPE
396 # define WARN_PAST_SCOPE 0
401 #define yydebug (p->debug)
403 #define YYFPRINTF(out, ...) rb_parser_printf(p, __VA_ARGS__)
404 #define YY_LOCATION_PRINT(File, loc, p) \
405 rb_parser_printf(p, "%d.%d-%d.%d", \
406 (loc).beg_pos.lineno, (loc).beg_pos.column,\
407 (loc).end_pos.lineno, (loc).end_pos.column)
408 #define YYLLOC_DEFAULT(Current, Rhs, N) \
412 (Current).beg_pos = YYRHSLOC(Rhs, 1).beg_pos; \
413 (Current).end_pos = YYRHSLOC(Rhs, N).end_pos; \
417 (Current).beg_pos = YYRHSLOC(Rhs, 0).end_pos; \
418 (Current).end_pos = YYRHSLOC(Rhs, 0).end_pos; \
422 (((Msgid)[0] == 'm') && (strcmp((Msgid), "memory exhausted") == 0) ? \
423 "nesting too deep" : (Msgid))
425 #define RUBY_SET_YYLLOC_FROM_STRTERM_HEREDOC(Current) \
426 rb_parser_set_location_from_strterm_heredoc(p, &p->lex.strterm->u.heredoc, &(Current))
427 #define RUBY_SET_YYLLOC_OF_DELAYED_TOKEN(Current) \
428 rb_parser_set_location_of_delayed_token(p, &(Current))
429 #define RUBY_SET_YYLLOC_OF_HEREDOC_END(Current) \
430 rb_parser_set_location_of_heredoc_end(p, &(Current))
431 #define RUBY_SET_YYLLOC_OF_DUMMY_END(Current) \
432 rb_parser_set_location_of_dummy_end(p, &(Current))
433 #define RUBY_SET_YYLLOC_OF_NONE(Current) \
434 rb_parser_set_location_of_none(p, &(Current))
435 #define RUBY_SET_YYLLOC(Current) \
436 rb_parser_set_location(p, &(Current))
437 #define RUBY_INIT_YYLLOC() \
439 {p->ruby_sourceline, (int)(p->lex.ptok - p->lex.pbeg)}, \
440 {p->ruby_sourceline, (int)(p->lex.pcur - p->lex.pbeg)}, \
443 #define IS_lex_state_for(x, ls) ((x) & (ls))
444 #define IS_lex_state_all_for(x, ls) (((x) & (ls)) == (ls))
445 #define IS_lex_state(ls) IS_lex_state_for(p->lex.state, (ls))
446 #define IS_lex_state_all(ls) IS_lex_state_all_for(p->lex.state, (ls))
448 # define SET_LEX_STATE(ls) \
449 parser_set_lex_state(p, ls, __LINE__)
450 static inline enum lex_state_e parser_set_lex_state(
struct parser_params *p,
enum lex_state_e ls,
int line);
452 typedef VALUE stack_type;
456 # define SHOW_BITSTACK(stack, name) (p->debug ? rb_parser_show_bitstack(p, stack, name, __LINE__) : (void)0)
457 # define BITSTACK_PUSH(stack, n) (((p->stack) = ((p->stack)<<1)|((n)&1)), SHOW_BITSTACK(p->stack, #stack"(push)"))
458 # define BITSTACK_POP(stack) (((p->stack) = (p->stack) >> 1), SHOW_BITSTACK(p->stack, #stack"(pop)"))
459 # define BITSTACK_SET_P(stack) (SHOW_BITSTACK(p->stack, #stack), (p->stack)&1)
460 # define BITSTACK_SET(stack, n) ((p->stack)=(n), SHOW_BITSTACK(p->stack, #stack"(set)"))
464 #define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))
465 #define COND_POP() BITSTACK_POP(cond_stack)
466 #define COND_P() BITSTACK_SET_P(cond_stack)
467 #define COND_SET(n) BITSTACK_SET(cond_stack, (n))
471 #define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))
472 #define CMDARG_POP() BITSTACK_POP(cmdarg_stack)
473 #define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)
474 #define CMDARG_SET(n) BITSTACK_SET(cmdarg_stack, (n))
492 NODE *outer, *inner, *current;
503 #define DVARS_INHERIT ((void*)1)
504 #define DVARS_TOPSCOPE NULL
505 #define DVARS_TERMINAL_P(tbl) ((tbl) == DVARS_INHERIT || (tbl) == DVARS_TOPSCOPE)
532 #define AFTER_HEREDOC_WITHOUT_TERMINTOR ((rb_parser_string_t *)1)
549 rb_parser_lex_gets_func *gets;
550 rb_parser_input_data input;
558 enum lex_state_e state;
566 stack_type cond_stack;
567 stack_type cmdarg_stack;
572 int heredoc_line_indent;
579 const char *ruby_sourcefile;
580 VALUE ruby_sourcefile_string;
600 st_table *warn_duplicate_keys_table;
607 NODE *eval_tree_begin;
611 #ifdef UNIVERSAL_PARSER
612 const rb_parser_config_t *config;
615 signed int frozen_string_literal:2;
617 unsigned int command_start:1;
618 unsigned int eofp: 1;
619 unsigned int ruby__end__seen: 1;
620 unsigned int debug: 1;
621 unsigned int has_shebang: 1;
622 unsigned int token_seen: 1;
623 unsigned int token_info_enabled: 1;
625 unsigned int past_scope_enabled: 1;
627 unsigned int error_p: 1;
628 unsigned int cr_seen: 1;
633 unsigned int do_print: 1;
634 unsigned int do_loop: 1;
635 unsigned int do_chomp: 1;
636 unsigned int do_split: 1;
637 unsigned int error_tolerant: 1;
638 unsigned int keep_tokens: 1;
656 VALUE parsing_thread;
663 #define NUMPARAM_ID_P(id) numparam_id_p(p, id)
664 #define NUMPARAM_ID_TO_IDX(id) (unsigned int)(((id) >> ID_SCOPE_SHIFT) - (tNUMPARAM_1 - 1))
665 #define NUMPARAM_IDX_TO_ID(idx) TOKEN2LOCALID((tNUMPARAM_1 - 1 + (idx)))
669 if (!is_local_id(
id) ||
id < (tNUMPARAM_1 << ID_SCOPE_SHIFT))
return 0;
670 unsigned int idx = NUMPARAM_ID_TO_IDX(
id);
671 return idx > 0 && idx <= NUMPARAM_MAX;
680 rb_parser_printf(p,
"after-shift: %+"PRIsVALUE
"\n", p->s_value);
696 for (
int i = 0; i <
len; i++) {
699 rb_parser_printf(p,
"after-reduce pop: %+"PRIsVALUE
"\n", tos);
703 rb_parser_printf(p,
"after-reduce push: %+"PRIsVALUE
"\n", p->s_lvalue);
713 rb_parser_printf(p,
"after-shift-error-token:\n");
721 for (
int i = 0; i <
len; i++) {
724 rb_parser_printf(p,
"after-pop-stack pop: %+"PRIsVALUE
"\n", tos);
755 #define intern_cstr(n,l,en) rb_intern3(n,l,en)
757 #define STRING_NEW0() rb_parser_encoding_string_new(p,0,0,p->enc)
759 #define STR_NEW(ptr,len) rb_enc_str_new((ptr),(len),p->enc)
760 #define STR_NEW0() rb_enc_str_new(0,0,p->enc)
761 #define STR_NEW2(ptr) rb_enc_str_new((ptr),strlen(ptr),p->enc)
762 #define STR_NEW3(ptr,len,e,func) parser_str_new(p, (ptr),(len),(e),(func),p->enc)
763 #define TOK_INTERN() intern_cstr(tok(p), toklen(p), p->enc)
764 #define VALID_SYMNAME_P(s, l, enc, type) (rb_enc_symname_type(s, l, enc, (1U<<(type))) == (int)(type))
778 st_free_table(p->pvtbl);
785 if (p->pktbl) st_free_table(p->pktbl);
789 #define STRING_BUF_DEFAULT_LEN 16
797 buf->head = buf->last =
xmalloc(size);
798 buf->head->len = STRING_BUF_DEFAULT_LEN;
800 buf->head->next = NULL;
808 if (buf->head->used >= buf->head->len) {
810 long n = buf->head->len * 2;
817 buf->last->next = elem;
820 buf->last->buf[buf->last->used++] = str;
831 for (
long i = 0; i < elem->used; i++) {
832 rb_parser_string_free(p, elem->buf[i]);
844 debug_end_expect_token_locations(
struct parser_params *p,
const char *name)
852 rb_str_catf(mesg,
"[%d, %d]", loc->pos->lineno, loc->pos->column);
856 flush_debug_buffer(p, p->debug_output, mesg);
863 if(!p->error_tolerant)
return;
867 locations->pos = pos;
868 locations->prev = p->end_expect_token_locations;
869 p->end_expect_token_locations = locations;
871 debug_end_expect_token_locations(p,
"push_end_expect_token_locations");
877 if(!p->end_expect_token_locations)
return;
881 p->end_expect_token_locations = locations;
883 debug_end_expect_token_locations(p,
"pop_end_expect_token_locations");
889 return p->end_expect_token_locations;
893 parser_token2char(
struct parser_params *p,
enum yytokentype tok)
896 #define TOKEN2CHAR(tok) case tok: return (#tok);
897 #define TOKEN2CHAR2(tok, name) case tok: return (name);
898 TOKEN2CHAR2(
' ',
"word_sep");
899 TOKEN2CHAR2(
'!',
"!")
900 TOKEN2CHAR2('%', "%");
901 TOKEN2CHAR2('&', "&");
902 TOKEN2CHAR2('*', "*");
903 TOKEN2CHAR2('+', "+");
904 TOKEN2CHAR2('-', "-");
905 TOKEN2CHAR2('/', "/");
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('\n', "nl");
919 TOKEN2CHAR2('{
', "\"{\"");
920 TOKEN2CHAR2('}
', "\"}\"");
921 TOKEN2CHAR2('[
', "\"[\"");
922 TOKEN2CHAR2(']
', "\"]\"");
923 TOKEN2CHAR2('(
', "\"(\"");
924 TOKEN2CHAR2(')
', "\")\"");
925 TOKEN2CHAR2('\\
', "backslash");
926 TOKEN2CHAR(keyword_class);
927 TOKEN2CHAR(keyword_module);
928 TOKEN2CHAR(keyword_def);
929 TOKEN2CHAR(keyword_undef);
930 TOKEN2CHAR(keyword_begin);
931 TOKEN2CHAR(keyword_rescue);
932 TOKEN2CHAR(keyword_ensure);
933 TOKEN2CHAR(keyword_end);
934 TOKEN2CHAR(keyword_if);
935 TOKEN2CHAR(keyword_unless);
936 TOKEN2CHAR(keyword_then);
937 TOKEN2CHAR(keyword_elsif);
938 TOKEN2CHAR(keyword_else);
939 TOKEN2CHAR(keyword_case);
940 TOKEN2CHAR(keyword_when);
941 TOKEN2CHAR(keyword_while);
942 TOKEN2CHAR(keyword_until);
943 TOKEN2CHAR(keyword_for);
944 TOKEN2CHAR(keyword_break);
945 TOKEN2CHAR(keyword_next);
946 TOKEN2CHAR(keyword_redo);
947 TOKEN2CHAR(keyword_retry);
948 TOKEN2CHAR(keyword_in);
949 TOKEN2CHAR(keyword_do);
950 TOKEN2CHAR(keyword_do_cond);
951 TOKEN2CHAR(keyword_do_block);
952 TOKEN2CHAR(keyword_do_LAMBDA);
953 TOKEN2CHAR(keyword_return);
954 TOKEN2CHAR(keyword_yield);
955 TOKEN2CHAR(keyword_super);
956 TOKEN2CHAR(keyword_self);
957 TOKEN2CHAR(keyword_nil);
958 TOKEN2CHAR(keyword_true);
959 TOKEN2CHAR(keyword_false);
960 TOKEN2CHAR(keyword_and);
961 TOKEN2CHAR(keyword_or);
962 TOKEN2CHAR(keyword_not);
963 TOKEN2CHAR(modifier_if);
964 TOKEN2CHAR(modifier_unless);
965 TOKEN2CHAR(modifier_while);
966 TOKEN2CHAR(modifier_until);
967 TOKEN2CHAR(modifier_rescue);
968 TOKEN2CHAR(keyword_alias);
969 TOKEN2CHAR(keyword_defined);
970 TOKEN2CHAR(keyword_BEGIN);
971 TOKEN2CHAR(keyword_END);
972 TOKEN2CHAR(keyword__LINE__);
973 TOKEN2CHAR(keyword__FILE__);
974 TOKEN2CHAR(keyword__ENCODING__);
975 TOKEN2CHAR(tIDENTIFIER);
979 TOKEN2CHAR(tCONSTANT);
982 TOKEN2CHAR(tINTEGER);
984 TOKEN2CHAR(tRATIONAL);
985 TOKEN2CHAR(tIMAGINARY);
987 TOKEN2CHAR(tNTH_REF);
988 TOKEN2CHAR(tBACK_REF);
989 TOKEN2CHAR(tSTRING_CONTENT);
990 TOKEN2CHAR(tREGEXP_END);
991 TOKEN2CHAR(tDUMNY_END);
1005 TOKEN2CHAR(tNMATCH);
1014 TOKEN2CHAR(tANDDOT);
1015 TOKEN2CHAR(tCOLON2);
1016 TOKEN2CHAR(tCOLON3);
1017 TOKEN2CHAR(tOP_ASGN);
1019 TOKEN2CHAR(tLPAREN);
1020 TOKEN2CHAR(tLPAREN_ARG);
1021 TOKEN2CHAR(tRPAREN);
1022 TOKEN2CHAR(tLBRACK);
1023 TOKEN2CHAR(tLBRACE);
1024 TOKEN2CHAR(tLBRACE_ARG);
1028 TOKEN2CHAR(tLAMBDA);
1029 TOKEN2CHAR(tSYMBEG);
1030 TOKEN2CHAR(tSTRING_BEG);
1031 TOKEN2CHAR(tXSTRING_BEG);
1032 TOKEN2CHAR(tREGEXP_BEG);
1033 TOKEN2CHAR(tWORDS_BEG);
1034 TOKEN2CHAR(tQWORDS_BEG);
1035 TOKEN2CHAR(tSYMBOLS_BEG);
1036 TOKEN2CHAR(tQSYMBOLS_BEG);
1037 TOKEN2CHAR(tSTRING_END);
1038 TOKEN2CHAR(tSTRING_DEND);
1039 TOKEN2CHAR(tSTRING_DBEG);
1040 TOKEN2CHAR(tSTRING_DVAR);
1041 TOKEN2CHAR(tLAMBEG);
1042 TOKEN2CHAR(tLABEL_END);
1043 TOKEN2CHAR(tIGNORED_NL);
1044 TOKEN2CHAR(tCOMMENT);
1045 TOKEN2CHAR(tEMBDOC_BEG);
1046 TOKEN2CHAR(tEMBDOC);
1047 TOKEN2CHAR(tEMBDOC_END);
1048 TOKEN2CHAR(tHEREDOC_BEG);
1049 TOKEN2CHAR(tHEREDOC_END);
1050 TOKEN2CHAR(k__END__);
1051 TOKEN2CHAR(tLOWEST);
1052 TOKEN2CHAR(tUMINUS_NUM);
1053 TOKEN2CHAR(tLAST_TOKEN);
1058 rb_bug("parser_token2id: unknown token %d", tok);
1060 UNREACHABLE_RETURN(0);
1064 push_end_expect_token_locations(struct parser_params *p, const rb_code_position_t *pos)
1069 pop_end_expect_token_locations(struct parser_params *p)
1074 RBIMPL_ATTR_NONNULL((1, 2, 3))
1075 static int parser_yyerror(struct parser_params*, const YYLTYPE *yylloc, const char*);
1076 RBIMPL_ATTR_NONNULL((1, 2))
1077 static int parser_yyerror0(struct parser_params*, const char*);
1078 #define yyerror0(msg) parser_yyerror0(p, (msg))
1079 #define yyerror1(loc, msg) parser_yyerror(p, (loc), (msg))
1080 #define yyerror(yylloc, p, msg) parser_yyerror(p, yylloc, msg)
1081 #define token_flush(ptr) ((ptr)->lex.ptok = (ptr)->lex.pcur)
1082 #define lex_goto_eol(p) ((p)->lex.pcur = (p)->lex.pend)
1083 #define lex_eol_p(p) lex_eol_n_p(p, 0)
1084 #define lex_eol_n_p(p,n) lex_eol_ptr_n_p(p, (p)->lex.pcur, n)
1085 #define lex_eol_ptr_p(p,ptr) lex_eol_ptr_n_p(p,ptr,0)
1086 #define lex_eol_ptr_n_p(p,ptr,n) ((ptr)+(n) >= (p)->lex.pend)
1088 static void token_info_setup(token_info *ptinfo, const char *ptr, const rb_code_location_t *loc);
1089 static void token_info_push(struct parser_params*, const char *token, const rb_code_location_t *loc);
1090 static void token_info_pop(struct parser_params*, const char *token, const rb_code_location_t *loc);
1091 static void token_info_warn(struct parser_params *p, const char *token, token_info *ptinfo_beg, int same, const rb_code_location_t *loc);
1092 static void token_info_drop(struct parser_params *p, const char *token, rb_code_position_t beg_pos);
1095 #define compile_for_eval (0)
1097 #define compile_for_eval (p->parent_iseq != 0)
1100 #define token_column ((int)(p->lex.ptok - p->lex.pbeg))
1102 #define CALL_Q_P(q) ((q) == tANDDOT)
1103 #define NEW_QCALL(q,r,m,a,loc) (CALL_Q_P(q) ? NEW_QCALL0(r,m,a,loc) : NEW_CALL(r,m,a,loc))
1105 #define lambda_beginning_p() (p->lex.lpar_beg == p->lex.paren_nest)
1107 static enum yytokentype yylex(YYSTYPE*, YYLTYPE*, struct parser_params*);
1110 rb_discard_node(struct parser_params *p, NODE *n)
1112 rb_ast_delete_node(p->ast, n);
1115 static rb_node_scope_t *rb_node_scope_new(struct parser_params *p, rb_node_args_t *nd_args, NODE *nd_body, const YYLTYPE *loc);
1116 static 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);
1117 static rb_node_block_t *rb_node_block_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc);
1118 static rb_node_if_t *rb_node_if_new(struct parser_params *p, NODE *nd_cond, NODE *nd_body, NODE *nd_else, const YYLTYPE *loc);
1119 static 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);
1120 static 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);
1121 static 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);
1122 static 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);
1123 static 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);
1124 static rb_node_in_t *rb_node_in_new(struct parser_params *p, NODE *nd_head, NODE *nd_body, NODE *nd_next, const YYLTYPE *loc);
1125 static 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);
1126 static 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);
1127 static rb_node_iter_t *rb_node_iter_new(struct parser_params *p, rb_node_args_t *nd_args, NODE *nd_body, const YYLTYPE *loc);
1128 static rb_node_for_t *rb_node_for_new(struct parser_params *p, NODE *nd_iter, NODE *nd_body, const YYLTYPE *loc);
1129 static rb_node_for_masgn_t *rb_node_for_masgn_new(struct parser_params *p, NODE *nd_var, const YYLTYPE *loc);
1130 static rb_node_retry_t *rb_node_retry_new(struct parser_params *p, const YYLTYPE *loc);
1131 static rb_node_begin_t *rb_node_begin_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc);
1132 static rb_node_rescue_t *rb_node_rescue_new(struct parser_params *p, NODE *nd_head, NODE *nd_resq, NODE *nd_else, const YYLTYPE *loc);
1133 static 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);
1134 static rb_node_ensure_t *rb_node_ensure_new(struct parser_params *p, NODE *nd_head, NODE *nd_ensr, const YYLTYPE *loc);
1135 static 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);
1136 static 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);
1137 static rb_node_masgn_t *rb_node_masgn_new(struct parser_params *p, NODE *nd_head, NODE *nd_args, const YYLTYPE *loc);
1138 static rb_node_lasgn_t *rb_node_lasgn_new(struct parser_params *p, ID nd_vid, NODE *nd_value, const YYLTYPE *loc);
1139 static rb_node_dasgn_t *rb_node_dasgn_new(struct parser_params *p, ID nd_vid, NODE *nd_value, const YYLTYPE *loc);
1140 static rb_node_gasgn_t *rb_node_gasgn_new(struct parser_params *p, ID nd_vid, NODE *nd_value, const YYLTYPE *loc);
1141 static rb_node_iasgn_t *rb_node_iasgn_new(struct parser_params *p, ID nd_vid, NODE *nd_value, const YYLTYPE *loc);
1142 static 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);
1143 static rb_node_cvasgn_t *rb_node_cvasgn_new(struct parser_params *p, ID nd_vid, NODE *nd_value, const YYLTYPE *loc);
1144 static 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);
1145 static 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);
1146 static 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);
1147 static 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);
1148 static 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);
1149 static rb_node_call_t *rb_node_call_new(struct parser_params *p, NODE *nd_recv, ID nd_mid, NODE *nd_args, const YYLTYPE *loc);
1150 static rb_node_opcall_t *rb_node_opcall_new(struct parser_params *p, NODE *nd_recv, ID nd_mid, NODE *nd_args, const YYLTYPE *loc);
1151 static rb_node_fcall_t *rb_node_fcall_new(struct parser_params *p, ID nd_mid, NODE *nd_args, const YYLTYPE *loc);
1152 static rb_node_vcall_t *rb_node_vcall_new(struct parser_params *p, ID nd_mid, const YYLTYPE *loc);
1153 static rb_node_qcall_t *rb_node_qcall_new(struct parser_params *p, NODE *nd_recv, ID nd_mid, NODE *nd_args, const YYLTYPE *loc);
1154 static rb_node_super_t *rb_node_super_new(struct parser_params *p, NODE *nd_args, const YYLTYPE *loc);
1155 static rb_node_zsuper_t * rb_node_zsuper_new(struct parser_params *p, const YYLTYPE *loc);
1156 static rb_node_list_t *rb_node_list_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc);
1157 static rb_node_list_t *rb_node_list_new2(struct parser_params *p, NODE *nd_head, long nd_alen, NODE *nd_next, const YYLTYPE *loc);
1158 static rb_node_zlist_t *rb_node_zlist_new(struct parser_params *p, const YYLTYPE *loc);
1159 static rb_node_hash_t *rb_node_hash_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc);
1160 static rb_node_return_t *rb_node_return_new(struct parser_params *p, NODE *nd_stts, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1161 static rb_node_yield_t *rb_node_yield_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc);
1162 static rb_node_lvar_t *rb_node_lvar_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1163 static rb_node_dvar_t *rb_node_dvar_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1164 static rb_node_gvar_t *rb_node_gvar_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1165 static rb_node_ivar_t *rb_node_ivar_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1166 static rb_node_const_t *rb_node_const_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1167 static rb_node_cvar_t *rb_node_cvar_new(struct parser_params *p, ID nd_vid, const YYLTYPE *loc);
1168 static rb_node_nth_ref_t *rb_node_nth_ref_new(struct parser_params *p, long nd_nth, const YYLTYPE *loc);
1169 static rb_node_back_ref_t *rb_node_back_ref_new(struct parser_params *p, long nd_nth, const YYLTYPE *loc);
1170 static rb_node_match2_t *rb_node_match2_new(struct parser_params *p, NODE *nd_recv, NODE *nd_value, const YYLTYPE *loc);
1171 static rb_node_match3_t *rb_node_match3_new(struct parser_params *p, NODE *nd_recv, NODE *nd_value, const YYLTYPE *loc);
1172 static rb_node_integer_t * rb_node_integer_new(struct parser_params *p, char* val, int base, const YYLTYPE *loc);
1173 static rb_node_float_t * rb_node_float_new(struct parser_params *p, char* val, const YYLTYPE *loc);
1174 static rb_node_rational_t * rb_node_rational_new(struct parser_params *p, char* val, int base, int seen_point, const YYLTYPE *loc);
1175 static 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);
1176 static rb_node_str_t *rb_node_str_new(struct parser_params *p, rb_parser_string_t *string, const YYLTYPE *loc);
1177 static 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);
1178 static rb_node_dstr_t *rb_node_dstr_new(struct parser_params *p, rb_parser_string_t *string, const YYLTYPE *loc);
1179 static rb_node_xstr_t *rb_node_xstr_new(struct parser_params *p, rb_parser_string_t *string, const YYLTYPE *loc);
1180 static 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);
1181 static rb_node_evstr_t *rb_node_evstr_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc);
1182 static rb_node_regx_t *rb_node_regx_new(struct parser_params *p, rb_parser_string_t *string, int options, const YYLTYPE *loc);
1183 static rb_node_once_t *rb_node_once_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc);
1184 static rb_node_args_t *rb_node_args_new(struct parser_params *p, const YYLTYPE *loc);
1185 static rb_node_args_aux_t *rb_node_args_aux_new(struct parser_params *p, ID nd_pid, int nd_plen, const YYLTYPE *loc);
1186 static rb_node_opt_arg_t *rb_node_opt_arg_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc);
1187 static rb_node_kw_arg_t *rb_node_kw_arg_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc);
1188 static rb_node_postarg_t *rb_node_postarg_new(struct parser_params *p, NODE *nd_1st, NODE *nd_2nd, const YYLTYPE *loc);
1189 static rb_node_argscat_t *rb_node_argscat_new(struct parser_params *p, NODE *nd_head, NODE *nd_body, const YYLTYPE *loc);
1190 static rb_node_argspush_t *rb_node_argspush_new(struct parser_params *p, NODE *nd_head, NODE *nd_body, const YYLTYPE *loc);
1191 static rb_node_splat_t *rb_node_splat_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc, const YYLTYPE *operator_loc);
1192 static rb_node_block_pass_t *rb_node_block_pass_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc, const YYLTYPE *operator_loc);
1193 static rb_node_defn_t *rb_node_defn_new(struct parser_params *p, ID nd_mid, NODE *nd_defn, const YYLTYPE *loc);
1194 static rb_node_defs_t *rb_node_defs_new(struct parser_params *p, NODE *nd_recv, ID nd_mid, NODE *nd_defn, const YYLTYPE *loc);
1195 static 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);
1196 static 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);
1197 static rb_node_undef_t *rb_node_undef_new(struct parser_params *p, NODE *nd_undef, const YYLTYPE *loc);
1198 static rb_node_class_t *rb_node_class_new(struct parser_params *p, NODE *nd_cpath, NODE *nd_body, NODE *nd_super, const YYLTYPE *loc);
1199 static rb_node_module_t *rb_node_module_new(struct parser_params *p, NODE *nd_cpath, NODE *nd_body, const YYLTYPE *loc);
1200 static rb_node_sclass_t *rb_node_sclass_new(struct parser_params *p, NODE *nd_recv, NODE *nd_body, const YYLTYPE *loc);
1201 static rb_node_colon2_t *rb_node_colon2_new(struct parser_params *p, NODE *nd_head, ID nd_mid, const YYLTYPE *loc);
1202 static rb_node_colon3_t *rb_node_colon3_new(struct parser_params *p, ID nd_mid, const YYLTYPE *loc);
1203 static rb_node_dot2_t *rb_node_dot2_new(struct parser_params *p, NODE *nd_beg, NODE *nd_end, const YYLTYPE *loc);
1204 static rb_node_dot3_t *rb_node_dot3_new(struct parser_params *p, NODE *nd_beg, NODE *nd_end, const YYLTYPE *loc);
1205 static rb_node_self_t *rb_node_self_new(struct parser_params *p, const YYLTYPE *loc);
1206 static rb_node_nil_t *rb_node_nil_new(struct parser_params *p, const YYLTYPE *loc);
1207 static rb_node_true_t *rb_node_true_new(struct parser_params *p, const YYLTYPE *loc);
1208 static rb_node_false_t *rb_node_false_new(struct parser_params *p, const YYLTYPE *loc);
1209 static rb_node_errinfo_t *rb_node_errinfo_new(struct parser_params *p, const YYLTYPE *loc);
1210 static rb_node_defined_t *rb_node_defined_new(struct parser_params *p, NODE *nd_head, const YYLTYPE *loc);
1211 static rb_node_postexe_t *rb_node_postexe_new(struct parser_params *p, NODE *nd_body, const YYLTYPE *loc);
1212 static rb_node_sym_t *rb_node_sym_new(struct parser_params *p, VALUE str, const YYLTYPE *loc);
1213 static 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);
1214 static rb_node_attrasgn_t *rb_node_attrasgn_new(struct parser_params *p, NODE *nd_recv, ID nd_mid, NODE *nd_args, const YYLTYPE *loc);
1215 static rb_node_lambda_t *rb_node_lambda_new(struct parser_params *p, rb_node_args_t *nd_args, NODE *nd_body, const YYLTYPE *loc);
1216 static rb_node_aryptn_t *rb_node_aryptn_new(struct parser_params *p, NODE *pre_args, NODE *rest_arg, NODE *post_args, const YYLTYPE *loc);
1217 static rb_node_hshptn_t *rb_node_hshptn_new(struct parser_params *p, NODE *nd_pconst, NODE *nd_pkwargs, NODE *nd_pkwrestarg, const YYLTYPE *loc);
1218 static 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);
1219 static rb_node_line_t *rb_node_line_new(struct parser_params *p, const YYLTYPE *loc);
1220 static rb_node_file_t *rb_node_file_new(struct parser_params *p, VALUE str, const YYLTYPE *loc);
1221 static rb_node_error_t *rb_node_error_new(struct parser_params *p, const YYLTYPE *loc);
1223 #define NEW_SCOPE(a,b,loc) (NODE *)rb_node_scope_new(p,a,b,loc)
1224 #define NEW_SCOPE2(t,a,b,loc) (NODE *)rb_node_scope_new2(p,t,a,b,loc)
1225 #define NEW_BLOCK(a,loc) (NODE *)rb_node_block_new(p,a,loc)
1226 #define NEW_IF(c,t,e,loc) (NODE *)rb_node_if_new(p,c,t,e,loc)
1227 #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)
1228 #define NEW_CASE(h,b,loc,ck_loc,ek_loc) (NODE *)rb_node_case_new(p,h,b,loc,ck_loc,ek_loc)
1229 #define NEW_CASE2(b,loc,ck_loc,ek_loc) (NODE *)rb_node_case2_new(p,b,loc,ck_loc,ek_loc)
1230 #define NEW_CASE3(h,b,loc,ck_loc,ek_loc) (NODE *)rb_node_case3_new(p,h,b,loc,ck_loc,ek_loc)
1231 #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)
1232 #define NEW_IN(c,t,e,loc) (NODE *)rb_node_in_new(p,c,t,e,loc)
1233 #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)
1234 #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)
1235 #define NEW_ITER(a,b,loc) (NODE *)rb_node_iter_new(p,a,b,loc)
1236 #define NEW_FOR(i,b,loc) (NODE *)rb_node_for_new(p,i,b,loc)
1237 #define NEW_FOR_MASGN(v,loc) (NODE *)rb_node_for_masgn_new(p,v,loc)
1238 #define NEW_RETRY(loc) (NODE *)rb_node_retry_new(p,loc)
1239 #define NEW_BEGIN(b,loc) (NODE *)rb_node_begin_new(p,b,loc)
1240 #define NEW_RESCUE(b,res,e,loc) (NODE *)rb_node_rescue_new(p,b,res,e,loc)
1241 #define NEW_RESBODY(a,v,ex,n,loc) (NODE *)rb_node_resbody_new(p,a,v,ex,n,loc)
1242 #define NEW_ENSURE(b,en,loc) (NODE *)rb_node_ensure_new(p,b,en,loc)
1243 #define NEW_AND(f,s,loc,op_loc) (NODE *)rb_node_and_new(p,f,s,loc,op_loc)
1244 #define NEW_OR(f,s,loc,op_loc) (NODE *)rb_node_or_new(p,f,s,loc,op_loc)
1245 #define NEW_MASGN(l,r,loc) rb_node_masgn_new(p,l,r,loc)
1246 #define NEW_LASGN(v,val,loc) (NODE *)rb_node_lasgn_new(p,v,val,loc)
1247 #define NEW_DASGN(v,val,loc) (NODE *)rb_node_dasgn_new(p,v,val,loc)
1248 #define NEW_GASGN(v,val,loc) (NODE *)rb_node_gasgn_new(p,v,val,loc)
1249 #define NEW_IASGN(v,val,loc) (NODE *)rb_node_iasgn_new(p,v,val,loc)
1250 #define NEW_CDECL(v,val,path,share,loc) (NODE *)rb_node_cdecl_new(p,v,val,path,share,loc)
1251 #define NEW_CVASGN(v,val,loc) (NODE *)rb_node_cvasgn_new(p,v,val,loc)
1252 #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)
1253 #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)
1254 #define NEW_OP_ASGN_OR(i,val,loc) (NODE *)rb_node_op_asgn_or_new(p,i,val,loc)
1255 #define NEW_OP_ASGN_AND(i,val,loc) (NODE *)rb_node_op_asgn_and_new(p,i,val,loc)
1256 #define NEW_OP_CDECL(v,op,val,share,loc) (NODE *)rb_node_op_cdecl_new(p,v,val,op,share,loc)
1257 #define NEW_CALL(r,m,a,loc) (NODE *)rb_node_call_new(p,r,m,a,loc)
1258 #define NEW_OPCALL(r,m,a,loc) (NODE *)rb_node_opcall_new(p,r,m,a,loc)
1259 #define NEW_FCALL(m,a,loc) rb_node_fcall_new(p,m,a,loc)
1260 #define NEW_VCALL(m,loc) (NODE *)rb_node_vcall_new(p,m,loc)
1261 #define NEW_QCALL0(r,m,a,loc) (NODE *)rb_node_qcall_new(p,r,m,a,loc)
1262 #define NEW_SUPER(a,loc) (NODE *)rb_node_super_new(p,a,loc)
1263 #define NEW_ZSUPER(loc) (NODE *)rb_node_zsuper_new(p,loc)
1264 #define NEW_LIST(a,loc) (NODE *)rb_node_list_new(p,a,loc)
1265 #define NEW_LIST2(h,l,n,loc) (NODE *)rb_node_list_new2(p,h,l,n,loc)
1266 #define NEW_ZLIST(loc) (NODE *)rb_node_zlist_new(p,loc)
1267 #define NEW_HASH(a,loc) (NODE *)rb_node_hash_new(p,a,loc)
1268 #define NEW_RETURN(s,loc,k_loc) (NODE *)rb_node_return_new(p,s,loc,k_loc)
1269 #define NEW_YIELD(a,loc) (NODE *)rb_node_yield_new(p,a,loc)
1270 #define NEW_LVAR(v,loc) (NODE *)rb_node_lvar_new(p,v,loc)
1271 #define NEW_DVAR(v,loc) (NODE *)rb_node_dvar_new(p,v,loc)
1272 #define NEW_GVAR(v,loc) (NODE *)rb_node_gvar_new(p,v,loc)
1273 #define NEW_IVAR(v,loc) (NODE *)rb_node_ivar_new(p,v,loc)
1274 #define NEW_CONST(v,loc) (NODE *)rb_node_const_new(p,v,loc)
1275 #define NEW_CVAR(v,loc) (NODE *)rb_node_cvar_new(p,v,loc)
1276 #define NEW_NTH_REF(n,loc) (NODE *)rb_node_nth_ref_new(p,n,loc)
1277 #define NEW_BACK_REF(n,loc) (NODE *)rb_node_back_ref_new(p,n,loc)
1278 #define NEW_MATCH2(n1,n2,loc) (NODE *)rb_node_match2_new(p,n1,n2,loc)
1279 #define NEW_MATCH3(r,n2,loc) (NODE *)rb_node_match3_new(p,r,n2,loc)
1280 #define NEW_INTEGER(val, base,loc) (NODE *)rb_node_integer_new(p,val,base,loc)
1281 #define NEW_FLOAT(val,loc) (NODE *)rb_node_float_new(p,val,loc)
1282 #define NEW_RATIONAL(val,base,seen_point,loc) (NODE *)rb_node_rational_new(p,val,base,seen_point,loc)
1283 #define NEW_IMAGINARY(val,base,seen_point,numeric_type,loc) (NODE *)rb_node_imaginary_new(p,val,base,seen_point,numeric_type,loc)
1284 #define NEW_STR(s,loc) (NODE *)rb_node_str_new(p,s,loc)
1285 #define NEW_DSTR0(s,l,n,loc) (NODE *)rb_node_dstr_new0(p,s,l,n,loc)
1286 #define NEW_DSTR(s,loc) (NODE *)rb_node_dstr_new(p,s,loc)
1287 #define NEW_XSTR(s,loc) (NODE *)rb_node_xstr_new(p,s,loc)
1288 #define NEW_DXSTR(s,l,n,loc) (NODE *)rb_node_dxstr_new(p,s,l,n,loc)
1289 #define NEW_EVSTR(n,loc) (NODE *)rb_node_evstr_new(p,n,loc)
1290 #define NEW_REGX(str,opts,loc) (NODE *)rb_node_regx_new(p,str,opts,loc)
1291 #define NEW_ONCE(b,loc) (NODE *)rb_node_once_new(p,b,loc)
1292 #define NEW_ARGS(loc) rb_node_args_new(p,loc)
1293 #define NEW_ARGS_AUX(r,b,loc) rb_node_args_aux_new(p,r,b,loc)
1294 #define NEW_OPT_ARG(v,loc) rb_node_opt_arg_new(p,v,loc)
1295 #define NEW_KW_ARG(v,loc) rb_node_kw_arg_new(p,v,loc)
1296 #define NEW_POSTARG(i,v,loc) (NODE *)rb_node_postarg_new(p,i,v,loc)
1297 #define NEW_ARGSCAT(a,b,loc) (NODE *)rb_node_argscat_new(p,a,b,loc)
1298 #define NEW_ARGSPUSH(a,b,loc) (NODE *)rb_node_argspush_new(p,a,b,loc)
1299 #define NEW_SPLAT(a,loc,op_loc) (NODE *)rb_node_splat_new(p,a,loc,op_loc)
1300 #define NEW_BLOCK_PASS(b,loc,o_loc) rb_node_block_pass_new(p,b,loc,o_loc)
1301 #define NEW_DEFN(i,s,loc) (NODE *)rb_node_defn_new(p,i,s,loc)
1302 #define NEW_DEFS(r,i,s,loc) (NODE *)rb_node_defs_new(p,r,i,s,loc)
1303 #define NEW_ALIAS(n,o,loc,k_loc) (NODE *)rb_node_alias_new(p,n,o,loc,k_loc)
1304 #define NEW_VALIAS(n,o,loc,k_loc) (NODE *)rb_node_valias_new(p,n,o,loc,k_loc)
1305 #define NEW_UNDEF(i,loc) (NODE *)rb_node_undef_new(p,i,loc)
1306 #define NEW_CLASS(n,b,s,loc) (NODE *)rb_node_class_new(p,n,b,s,loc)
1307 #define NEW_MODULE(n,b,loc) (NODE *)rb_node_module_new(p,n,b,loc)
1308 #define NEW_SCLASS(r,b,loc) (NODE *)rb_node_sclass_new(p,r,b,loc)
1309 #define NEW_COLON2(c,i,loc) (NODE *)rb_node_colon2_new(p,c,i,loc)
1310 #define NEW_COLON3(i,loc) (NODE *)rb_node_colon3_new(p,i,loc)
1311 #define NEW_DOT2(b,e,loc) (NODE *)rb_node_dot2_new(p,b,e,loc)
1312 #define NEW_DOT3(b,e,loc) (NODE *)rb_node_dot3_new(p,b,e,loc)
1313 #define NEW_SELF(loc) (NODE *)rb_node_self_new(p,loc)
1314 #define NEW_NIL(loc) (NODE *)rb_node_nil_new(p,loc)
1315 #define NEW_TRUE(loc) (NODE *)rb_node_true_new(p,loc)
1316 #define NEW_FALSE(loc) (NODE *)rb_node_false_new(p,loc)
1317 #define NEW_ERRINFO(loc) (NODE *)rb_node_errinfo_new(p,loc)
1318 #define NEW_DEFINED(e,loc) (NODE *)rb_node_defined_new(p,e,loc)
1319 #define NEW_POSTEXE(b,loc) (NODE *)rb_node_postexe_new(p,b,loc)
1320 #define NEW_SYM(str,loc) (NODE *)rb_node_sym_new(p,str,loc)
1321 #define NEW_DSYM(s,l,n,loc) (NODE *)rb_node_dsym_new(p,s,l,n,loc)
1322 #define NEW_ATTRASGN(r,m,a,loc) (NODE *)rb_node_attrasgn_new(p,r,m,a,loc)
1323 #define NEW_LAMBDA(a,b,loc) (NODE *)rb_node_lambda_new(p,a,b,loc)
1324 #define NEW_ARYPTN(pre,r,post,loc) (NODE *)rb_node_aryptn_new(p,pre,r,post,loc)
1325 #define NEW_HSHPTN(c,kw,kwrest,loc) (NODE *)rb_node_hshptn_new(p,c,kw,kwrest,loc)
1326 #define NEW_FNDPTN(pre,a,post,loc) (NODE *)rb_node_fndptn_new(p,pre,a,post,loc)
1327 #define NEW_LINE(loc) (NODE *)rb_node_line_new(p,loc)
1328 #define NEW_FILE(str,loc) (NODE *)rb_node_file_new(p,str,loc)
1329 #define NEW_ENCODING(loc) (NODE *)rb_node_encoding_new(p,loc)
1330 #define NEW_ERROR(loc) (NODE *)rb_node_error_new(p,loc)
1332 enum internal_node_type {
1333 NODE_INTERNAL_ONLY = NODE_LAST,
1340 parser_node_name(int node)
1344 return "NODE_DEF_TEMP";
1346 return "NODE_EXITS";
1348 return ruby_node_name(node);
1352 /* This node is parse.y internal */
1353 struct RNode_DEF_TEMP {
1356 /* for NODE_DEFN/NODE_DEFS */
1358 struct RNode *nd_def;
1363 NODE *numparam_save;
1364 struct lex_context ctxt;
1368 #define RNODE_DEF_TEMP(node) ((struct RNode_DEF_TEMP *)(node))
1370 static rb_node_break_t *rb_node_break_new(struct parser_params *p, NODE *nd_stts, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1371 static rb_node_next_t *rb_node_next_new(struct parser_params *p, NODE *nd_stts, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1372 static rb_node_redo_t *rb_node_redo_new(struct parser_params *p, const YYLTYPE *loc, const YYLTYPE *keyword_loc);
1373 static rb_node_def_temp_t *rb_node_def_temp_new(struct parser_params *p, const YYLTYPE *loc);
1374 static rb_node_def_temp_t *def_head_save(struct parser_params *p, rb_node_def_temp_t *n);
1376 #define NEW_BREAK(s,loc,k_loc) (NODE *)rb_node_break_new(p,s,loc,k_loc)
1377 #define NEW_NEXT(s,loc,k_loc) (NODE *)rb_node_next_new(p,s,loc,k_loc)
1378 #define NEW_REDO(loc,k_loc) (NODE *)rb_node_redo_new(p,loc,k_loc)
1379 #define NEW_DEF_TEMP(loc) rb_node_def_temp_new(p,loc)
1381 /* Make a new internal node, which should not be appeared in the
1382 * result AST and does not have node_id and location. */
1383 static NODE* node_new_internal(struct parser_params *p, enum node_type type, size_t size, size_t alignment);
1384 #define NODE_NEW_INTERNAL(ndtype, type) (type *)node_new_internal(p, (enum node_type)(ndtype), sizeof(type), RUBY_ALIGNOF(type))
1386 static NODE *nd_set_loc(NODE *nd, const YYLTYPE *loc);
1389 parser_get_node_id(struct parser_params *p)
1391 int node_id = p->node_id;
1397 anddot_multiple_assignment_check(struct parser_params* p, const YYLTYPE *loc, ID id)
1399 if (id == tANDDOT) {
1400 yyerror1(loc, "&. inside multiple assignment destination");
1405 set_line_body(NODE *body, int line)
1408 switch (nd_type(body)) {
1411 nd_set_line(body, line);
1416 set_embraced_location(NODE *node, const rb_code_location_t *beg, const rb_code_location_t *end)
1418 RNODE_ITER(node)->nd_body->nd_loc = code_loc_gen(beg, end);
1419 nd_set_line(node, beg->end_pos.lineno);
1423 last_expr_node(NODE *expr)
1426 if (nd_type_p(expr, NODE_BLOCK)) {
1427 expr = RNODE_BLOCK(RNODE_BLOCK(expr)->nd_end)->nd_head;
1429 else if (nd_type_p(expr, NODE_BEGIN) && RNODE_BEGIN(expr)->nd_body) {
1430 expr = RNODE_BEGIN(expr)->nd_body;
1440 #define yyparse ruby_yyparse
1443 static NODE* cond(struct parser_params *p, NODE *node, const YYLTYPE *loc);
1444 static NODE* method_cond(struct parser_params *p, NODE *node, const YYLTYPE *loc);
1445 #define new_nil(loc) NEW_NIL(loc)
1446 static NODE *new_nil_at(struct parser_params *p, const rb_code_position_t *pos);
1447 static NODE *new_if(struct parser_params*,NODE*,NODE*,NODE*,const YYLTYPE*);
1448 static NODE *new_unless(struct parser_params*,NODE*,NODE*,NODE*,const YYLTYPE*,const YYLTYPE*,const YYLTYPE*,const YYLTYPE*);
1449 static NODE *logop(struct parser_params*,ID,NODE*,NODE*,const YYLTYPE*,const YYLTYPE*);
1451 static NODE *newline_node(NODE*);
1452 static void fixpos(NODE*,NODE*);
1454 static int value_expr_gen(struct parser_params*,NODE*);
1455 static void void_expr(struct parser_params*,NODE*);
1456 static NODE *remove_begin(NODE*);
1457 #define value_expr(node) value_expr_gen(p, (node))
1458 static NODE *void_stmts(struct parser_params*,NODE*);
1459 static void reduce_nodes(struct parser_params*,NODE**);
1460 static void block_dup_check(struct parser_params*,NODE*,NODE*);
1462 static NODE *block_append(struct parser_params*,NODE*,NODE*);
1463 static NODE *list_append(struct parser_params*,NODE*,NODE*);
1464 static NODE *list_concat(NODE*,NODE*);
1465 static NODE *arg_append(struct parser_params*,NODE*,NODE*,const YYLTYPE*);
1466 static NODE *last_arg_append(struct parser_params *p, NODE *args, NODE *last_arg, const YYLTYPE *loc);
1467 static NODE *rest_arg_append(struct parser_params *p, NODE *args, NODE *rest_arg, const YYLTYPE *loc);
1468 static NODE *literal_concat(struct parser_params*,NODE*,NODE*,const YYLTYPE*);
1469 static NODE *new_evstr(struct parser_params*,NODE*,const YYLTYPE*);
1470 static NODE *new_dstr(struct parser_params*,NODE*,const YYLTYPE*);
1471 static NODE *str2dstr(struct parser_params*,NODE*);
1472 static NODE *evstr2dstr(struct parser_params*,NODE*);
1473 static NODE *splat_array(NODE*);
1474 static void mark_lvar_used(struct parser_params *p, NODE *rhs);
1476 static NODE *call_bin_op(struct parser_params*,NODE*,ID,NODE*,const YYLTYPE*,const YYLTYPE*);
1477 static NODE *call_uni_op(struct parser_params*,NODE*,ID,const YYLTYPE*,const YYLTYPE*);
1478 static NODE *new_qcall(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, const YYLTYPE *op_loc, const YYLTYPE *loc);
1479 static 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);
1480 static 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;}
1482 static bool args_info_empty_p(struct rb_args_info *args);
1483 static 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*);
1484 static rb_node_args_t *new_args_tail(struct parser_params*,rb_node_kw_arg_t*,ID,ID,const YYLTYPE*);
1485 static NODE *new_array_pattern(struct parser_params *p, NODE *constant, NODE *pre_arg, NODE *aryptn, const YYLTYPE *loc);
1486 static NODE *new_array_pattern_tail(struct parser_params *p, NODE *pre_args, int has_rest, NODE *rest_arg, NODE *post_args, const YYLTYPE *loc);
1487 static NODE *new_find_pattern(struct parser_params *p, NODE *constant, NODE *fndptn, const YYLTYPE *loc);
1488 static NODE *new_find_pattern_tail(struct parser_params *p, NODE *pre_rest_arg, NODE *args, NODE *post_rest_arg, const YYLTYPE *loc);
1489 static NODE *new_hash_pattern(struct parser_params *p, NODE *constant, NODE *hshptn, const YYLTYPE *loc);
1490 static NODE *new_hash_pattern_tail(struct parser_params *p, NODE *kw_args, ID kw_rest_arg, const YYLTYPE *loc);
1492 static rb_node_kw_arg_t *new_kw_arg(struct parser_params *p, NODE *k, const YYLTYPE *loc);
1493 static rb_node_args_t *args_with_numbered(struct parser_params*,rb_node_args_t*,int,ID);
1495 static NODE* negate_lit(struct parser_params*, NODE*);
1496 static NODE *ret_args(struct parser_params*,NODE*);
1497 static NODE *arg_blk_pass(NODE*,rb_node_block_pass_t*);
1498 static NODE *new_yield(struct parser_params*,NODE*,const YYLTYPE*);
1499 static NODE *dsym_node(struct parser_params*,NODE*,const YYLTYPE*);
1501 static NODE *gettable(struct parser_params*,ID,const YYLTYPE*);
1502 static NODE *assignable(struct parser_params*,ID,NODE*,const YYLTYPE*);
1504 static NODE *aryset(struct parser_params*,NODE*,NODE*,const YYLTYPE*);
1505 static NODE *attrset(struct parser_params*,NODE*,ID,ID,const YYLTYPE*);
1507 static VALUE rb_backref_error(struct parser_params*,NODE*);
1508 static NODE *node_assign(struct parser_params*,NODE*,NODE*,struct lex_context,const YYLTYPE*);
1510 static NODE *new_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, struct lex_context, const YYLTYPE *loc);
1511 static 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);
1512 static 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);
1513 static NODE *new_const_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, struct lex_context, const YYLTYPE *loc);
1514 static NODE *new_bodystmt(struct parser_params *p, NODE *head, NODE *rescue, NODE *rescue_else, NODE *ensure, const YYLTYPE *loc);
1516 static NODE *const_decl(struct parser_params *p, NODE* path, const YYLTYPE *loc);
1518 static rb_node_opt_arg_t *opt_arg_append(rb_node_opt_arg_t*, rb_node_opt_arg_t*);
1519 static rb_node_kw_arg_t *kwd_append(rb_node_kw_arg_t*, rb_node_kw_arg_t*);
1521 static NODE *new_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc);
1522 static NODE *new_unique_key_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc);
1524 static NODE *new_defined(struct parser_params *p, NODE *expr, const YYLTYPE *loc);
1526 static NODE *new_regexp(struct parser_params *, NODE *, int, const YYLTYPE *);
1528 #define make_list(list, loc) ((list) ? (nd_set_loc(list, loc), list) : NEW_ZLIST(loc))
1530 static NODE *new_xstring(struct parser_params *, NODE *, const YYLTYPE *loc);
1532 static NODE *symbol_append(struct parser_params *p, NODE *symbols, NODE *symbol);
1534 static NODE *match_op(struct parser_params*,NODE*,NODE*,const YYLTYPE*,const YYLTYPE*);
1536 static rb_ast_id_table_t *local_tbl(struct parser_params*);
1538 static VALUE reg_compile(struct parser_params*, rb_parser_string_t*, int);
1539 static void reg_fragment_setenc(struct parser_params*, rb_parser_string_t*, int);
1540 #define reg_fragment_check rb_parser_reg_fragment_check
1541 int reg_fragment_check(struct parser_params*, rb_parser_string_t*, int);
1543 static int literal_concat0(struct parser_params *p, rb_parser_string_t *head, rb_parser_string_t *tail);
1544 static NODE *heredoc_dedent(struct parser_params*,NODE*);
1546 static void check_literal_when(struct parser_params *p, NODE *args, const YYLTYPE *loc);
1549 #define get_value(idx) (rb_ary_entry(p->s_value_stack, idx))
1550 #define set_value(val) (p->s_lvalue = val)
1551 static VALUE assign_error(struct parser_params *p, const char *mesg, VALUE a);
1552 static int id_is_var(struct parser_params *p, ID id);
1555 RUBY_SYMBOL_EXPORT_BEGIN
1556 VALUE rb_parser_reg_compile(struct parser_params* p, VALUE str, int options);
1557 int rb_reg_fragment_setenc(struct parser_params*, rb_parser_string_t *, int);
1558 enum lex_state_e rb_parser_trace_lex_state(struct parser_params *, enum lex_state_e, enum lex_state_e, int);
1559 VALUE rb_parser_lex_state_name(struct parser_params *p, enum lex_state_e state);
1560 void rb_parser_show_bitstack(struct parser_params *, stack_type, const char *, int);
1561 PRINTF_ARGS(void rb_parser_fatal(struct parser_params *p, const char *fmt, ...), 2, 3);
1562 YYLTYPE *rb_parser_set_location_from_strterm_heredoc(struct parser_params *p, rb_strterm_heredoc_t *here, YYLTYPE *yylloc);
1563 YYLTYPE *rb_parser_set_location_of_delayed_token(struct parser_params *p, YYLTYPE *yylloc);
1564 YYLTYPE *rb_parser_set_location_of_heredoc_end(struct parser_params *p, YYLTYPE *yylloc);
1565 YYLTYPE *rb_parser_set_location_of_dummy_end(struct parser_params *p, YYLTYPE *yylloc);
1566 YYLTYPE *rb_parser_set_location_of_none(struct parser_params *p, YYLTYPE *yylloc);
1567 YYLTYPE *rb_parser_set_location(struct parser_params *p, YYLTYPE *yylloc);
1568 void ruby_show_error_line(struct parser_params *p, VALUE errbuf, const YYLTYPE *yylloc, int lineno, rb_parser_string_t *str);
1569 RUBY_SYMBOL_EXPORT_END
1571 static void flush_string_content(struct parser_params *p, rb_encoding *enc, size_t back);
1572 static void error_duplicate_pattern_variable(struct parser_params *p, ID id, const YYLTYPE *loc);
1573 static void error_duplicate_pattern_key(struct parser_params *p, ID id, const YYLTYPE *loc);
1574 static VALUE formal_argument_error(struct parser_params*, ID);
1575 static ID shadowing_lvar(struct parser_params*,ID);
1576 static void new_bv(struct parser_params*,ID);
1578 static void local_push(struct parser_params*,int);
1579 static void local_pop(struct parser_params*);
1580 static void local_var(struct parser_params*, ID);
1581 static void arg_var(struct parser_params*, ID);
1582 static int local_id(struct parser_params *p, ID id);
1583 static int local_id_ref(struct parser_params*, ID, ID **);
1584 #define internal_id rb_parser_internal_id
1585 ID internal_id(struct parser_params*);
1586 static NODE *new_args_forward_call(struct parser_params*, NODE*, const YYLTYPE*, const YYLTYPE*);
1587 static int check_forwarding_args(struct parser_params*);
1588 static void add_forwarding_args(struct parser_params *p);
1589 static void forwarding_arg_check(struct parser_params *p, ID arg, ID all, const char *var);
1591 static const struct vtable *dyna_push(struct parser_params *);
1592 static void dyna_pop(struct parser_params*, const struct vtable *);
1593 static int dyna_in_block(struct parser_params*);
1594 #define dyna_var(p, id) local_var(p, id)
1595 static int dvar_defined(struct parser_params*, ID);
1596 #define dvar_defined_ref rb_parser_dvar_defined_ref
1597 int dvar_defined_ref(struct parser_params*, ID, ID**);
1598 static int dvar_curr(struct parser_params*,ID);
1600 static int lvar_defined(struct parser_params*, ID);
1602 static NODE *numparam_push(struct parser_params *p);
1603 static void numparam_pop(struct parser_params *p, NODE *prev_inner);
1605 #define METHOD_NOT '!
'
1607 #define idFWD_REST '*
'
1608 #define idFWD_KWREST idPow /* Use simple "**", as tDSTAR is "**arg" */
1609 #define idFWD_BLOCK '&
'
1610 #define idFWD_ALL idDot3
1611 #define arg_FWD_BLOCK idFWD_BLOCK
1613 #define RE_ONIG_OPTION_IGNORECASE 1
1614 #define RE_ONIG_OPTION_EXTEND (RE_ONIG_OPTION_IGNORECASE<<1)
1615 #define RE_ONIG_OPTION_MULTILINE (RE_ONIG_OPTION_EXTEND<<1)
1616 #define RE_OPTION_ONCE (1<<16)
1617 #define RE_OPTION_ENCODING_SHIFT 8
1618 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
1619 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
1620 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
1621 #define RE_OPTION_MASK 0xff
1622 #define RE_OPTION_ARG_ENCODING_NONE 32
1624 #define CHECK_LITERAL_WHEN (st_table *)1
1625 #define CASE_LABELS_ENABLED_P(case_labels) (case_labels && case_labels != CHECK_LITERAL_WHEN)
1627 #define yytnamerr(yyres, yystr) (YYSIZE_T)rb_yytnamerr(p, yyres, yystr)
1628 RUBY_FUNC_EXPORTED size_t rb_yytnamerr(struct parser_params *p, char *yyres, const char *yystr);
1630 #define TOKEN2ID(tok) ( \
1631 tTOKEN_LOCAL_BEGIN<(tok)&&(tok)<tTOKEN_LOCAL_END ? TOKEN2LOCALID(tok) : \
1632 tTOKEN_INSTANCE_BEGIN<(tok)&&(tok)<tTOKEN_INSTANCE_END ? TOKEN2INSTANCEID(tok) : \
1633 tTOKEN_GLOBAL_BEGIN<(tok)&&(tok)<tTOKEN_GLOBAL_END ? TOKEN2GLOBALID(tok) : \
1634 tTOKEN_CONST_BEGIN<(tok)&&(tok)<tTOKEN_CONST_END ? TOKEN2CONSTID(tok) : \
1635 tTOKEN_CLASS_BEGIN<(tok)&&(tok)<tTOKEN_CLASS_END ? TOKEN2CLASSID(tok) : \
1636 tTOKEN_ATTRSET_BEGIN<(tok)&&(tok)<tTOKEN_ATTRSET_END ? TOKEN2ATTRSETID(tok) : \
1637 ((tok) / ((tok)<tPRESERVED_ID_END && ((tok)>=128 || rb_ispunct(tok)))))
1639 /****** Ripper *******/
1643 #include "eventids1.h"
1644 #include "eventids2.h"
1646 extern const struct ripper_parser_ids ripper_parser_ids;
1648 static VALUE ripper_dispatch0(struct parser_params*,ID);
1649 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
1650 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
1651 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
1652 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
1653 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
1654 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
1655 void ripper_error(struct parser_params *p);
1657 #define dispatch0(n) ripper_dispatch0(p, RIPPER_ID(n))
1658 #define dispatch1(n,a) ripper_dispatch1(p, RIPPER_ID(n), (a))
1659 #define dispatch2(n,a,b) ripper_dispatch2(p, RIPPER_ID(n), (a), (b))
1660 #define dispatch3(n,a,b,c) ripper_dispatch3(p, RIPPER_ID(n), (a), (b), (c))
1661 #define dispatch4(n,a,b,c,d) ripper_dispatch4(p, RIPPER_ID(n), (a), (b), (c), (d))
1662 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(p, RIPPER_ID(n), (a), (b), (c), (d), (e))
1663 #define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(p, RIPPER_ID(n), (a), (b), (c), (d), (e), (f), (g))
1665 #define yyparse ripper_yyparse
1668 aryptn_pre_args(struct parser_params *p, VALUE pre_arg, VALUE pre_args)
1670 if (!NIL_P(pre_arg)) {
1671 if (!NIL_P(pre_args)) {
1672 rb_ary_unshift(pre_args, pre_arg);
1675 pre_args = rb_ary_new_from_args(1, pre_arg);
1681 #define ID2VAL(id) STATIC_ID2SYM(id)
1682 #define TOKEN2VAL(t) ID2VAL(TOKEN2ID(t))
1685 #define KWD2EID(t, v) keyword_##t
1688 new_scope_body(struct parser_params *p, rb_node_args_t *args, NODE *body, const YYLTYPE *loc)
1690 body = remove_begin(body);
1691 reduce_nodes(p, &body);
1692 NODE *n = NEW_SCOPE(args, body, loc);
1693 nd_set_line(n, loc->end_pos.lineno);
1694 set_line_body(body, loc->beg_pos.lineno);
1699 rescued_expr(struct parser_params *p, NODE *arg, NODE *rescue,
1700 const YYLTYPE *arg_loc, const YYLTYPE *mod_loc, const YYLTYPE *res_loc)
1702 YYLTYPE loc = code_loc_gen(mod_loc, res_loc);
1703 rescue = NEW_RESBODY(0, 0, remove_begin(rescue), 0, &loc);
1704 loc.beg_pos = arg_loc->beg_pos;
1705 return NEW_RESCUE(arg, rescue, 0, &loc);
1708 static NODE *add_block_exit(struct parser_params *p, NODE *node);
1709 static rb_node_exits_t *init_block_exit(struct parser_params *p);
1710 static rb_node_exits_t *allow_block_exit(struct parser_params *p);
1711 static void restore_block_exit(struct parser_params *p, rb_node_exits_t *exits);
1712 static void clear_block_exit(struct parser_params *p, bool error);
1715 next_rescue_context(struct lex_context *next, const struct lex_context *outer, enum rescue_context def)
1717 next->in_rescue = outer->in_rescue == after_rescue ? after_rescue : def;
1721 restore_defun(struct parser_params *p, rb_node_def_temp_t *temp)
1723 /* See: def_name action */
1724 struct lex_context ctxt = temp->save.ctxt;
1725 p->ctxt.in_def = ctxt.in_def;
1726 p->ctxt.shareable_constant_value = ctxt.shareable_constant_value;
1727 p->ctxt.in_rescue = ctxt.in_rescue;
1728 p->max_numparam = temp->save.max_numparam;
1729 numparam_pop(p, temp->save.numparam_save);
1730 clear_block_exit(p, true);
1734 endless_method_name(struct parser_params *p, ID mid, const YYLTYPE *loc)
1736 if (is_attrset_id(mid)) {
1737 yyerror1(loc, "setter method cannot be defined in an endless method definition");
1739 token_info_drop(p, "def", loc->beg_pos);
1742 #define debug_token_line(p, name, line) do { \
1744 const char *const pcur = p->lex.pcur; \
1745 const char *const ptok = p->lex.ptok; \
1746 rb_parser_printf(p, name ":%d (%d: %"PRIdPTRDIFF"|%"PRIdPTRDIFF"|%"PRIdPTRDIFF")\n", \
1747 line, p->ruby_sourceline, \
1748 ptok - p->lex.pbeg, pcur - ptok, p->lex.pend - pcur); \
1752 #define begin_definition(k, loc_beg, loc_end) \
1754 if (!(p->ctxt.in_class = (k)[0] != 0)) { \
1755 /* singleton class */ \
1756 p->ctxt.cant_return = !p->ctxt.in_def; \
1757 p->ctxt.in_def = 0; \
1759 else if (p->ctxt.in_def) { \
1760 YYLTYPE loc = code_loc_gen(loc_beg, loc_end); \
1761 yyerror1(&loc, k " definition in method body"); \
1764 p->ctxt.cant_return = 1; \
1770 # define ifndef_ripper(x) (x)
1771 # define ifdef_ripper(r,x) (x)
1773 # define ifndef_ripper(x)
1774 # define ifdef_ripper(r,x) (r)
1777 # define rb_warn0(fmt) WARN_CALL(WARN_ARGS(fmt, 1))
1778 # define rb_warn1(fmt,a) WARN_CALL(WARN_ARGS(fmt, 2), (a))
1779 # define rb_warn2(fmt,a,b) WARN_CALL(WARN_ARGS(fmt, 3), (a), (b))
1780 # define rb_warn3(fmt,a,b,c) WARN_CALL(WARN_ARGS(fmt, 4), (a), (b), (c))
1781 # define rb_warn4(fmt,a,b,c,d) WARN_CALL(WARN_ARGS(fmt, 5), (a), (b), (c), (d))
1782 # define rb_warning0(fmt) WARNING_CALL(WARNING_ARGS(fmt, 1))
1783 # define rb_warning1(fmt,a) WARNING_CALL(WARNING_ARGS(fmt, 2), (a))
1784 # define rb_warning2(fmt,a,b) WARNING_CALL(WARNING_ARGS(fmt, 3), (a), (b))
1785 # define rb_warning3(fmt,a,b,c) WARNING_CALL(WARNING_ARGS(fmt, 4), (a), (b), (c))
1786 # define rb_warning4(fmt,a,b,c,d) WARNING_CALL(WARNING_ARGS(fmt, 5), (a), (b), (c), (d))
1787 # define rb_warn0L(l,fmt) WARN_CALL(WARN_ARGS_L(l, fmt, 1))
1788 # define rb_warn1L(l,fmt,a) WARN_CALL(WARN_ARGS_L(l, fmt, 2), (a))
1789 # define rb_warn2L(l,fmt,a,b) WARN_CALL(WARN_ARGS_L(l, fmt, 3), (a), (b))
1790 # define rb_warn3L(l,fmt,a,b,c) WARN_CALL(WARN_ARGS_L(l, fmt, 4), (a), (b), (c))
1791 # define rb_warn4L(l,fmt,a,b,c,d) WARN_CALL(WARN_ARGS_L(l, fmt, 5), (a), (b), (c), (d))
1792 # define rb_warning0L(l,fmt) WARNING_CALL(WARNING_ARGS_L(l, fmt, 1))
1793 # define rb_warning1L(l,fmt,a) WARNING_CALL(WARNING_ARGS_L(l, fmt, 2), (a))
1794 # define rb_warning2L(l,fmt,a,b) WARNING_CALL(WARNING_ARGS_L(l, fmt, 3), (a), (b))
1795 # define rb_warning3L(l,fmt,a,b,c) WARNING_CALL(WARNING_ARGS_L(l, fmt, 4), (a), (b), (c))
1796 # define rb_warning4L(l,fmt,a,b,c,d) WARNING_CALL(WARNING_ARGS_L(l, fmt, 5), (a), (b), (c), (d))
1798 extern const ID id_warn, id_warning, id_gets, id_assoc;
1799 # define ERR_MESG() STR_NEW2(mesg) /* to bypass Ripper DSL */
1800 # define WARN_S_L(s,l) STR_NEW(s,l)
1801 # define WARN_S(s) STR_NEW2(s)
1802 # define WARN_I(i) INT2NUM(i)
1803 # define WARN_ID(i) rb_id2str(i)
1804 # define PRIsWARN PRIsVALUE
1805 # define rb_warn0L_experimental(l,fmt) WARN_CALL(WARN_ARGS_L(l, fmt, 1))
1806 # define WARN_ARGS(fmt,n) p->value, id_warn, n, rb_usascii_str_new_lit(fmt)
1807 # define WARN_ARGS_L(l,fmt,n) WARN_ARGS(fmt,n)
1808 # ifdef HAVE_VA_ARGS_MACRO
1809 # define WARN_CALL(...) rb_funcall(__VA_ARGS__)
1811 # define WARN_CALL rb_funcall
1813 # define WARNING_ARGS(fmt,n) p->value, id_warning, n, rb_usascii_str_new_lit(fmt)
1814 # define WARNING_ARGS_L(l, fmt,n) WARNING_ARGS(fmt,n)
1815 # ifdef HAVE_VA_ARGS_MACRO
1816 # define WARNING_CALL(...) rb_funcall(__VA_ARGS__)
1818 # define WARNING_CALL rb_funcall
1820 # define compile_error ripper_compile_error
1822 # define WARN_S_L(s,l) s
1823 # define WARN_S(s) s
1824 # define WARN_I(i) i
1825 # define WARN_ID(i) rb_id2name(i)
1826 # define PRIsWARN PRIsVALUE
1827 # define WARN_ARGS(fmt,n) WARN_ARGS_L(p->ruby_sourceline,fmt,n)
1828 # define WARN_ARGS_L(l,fmt,n) p->ruby_sourcefile, (l), (fmt)
1829 # define WARN_CALL rb_compile_warn
1830 # define rb_warn0L_experimental(l,fmt) rb_category_compile_warn(RB_WARN_CATEGORY_EXPERIMENTAL, WARN_ARGS_L(l, fmt, 1))
1831 # define WARNING_ARGS(fmt,n) WARN_ARGS(fmt,n)
1832 # define WARNING_ARGS_L(l,fmt,n) WARN_ARGS_L(l,fmt,n)
1833 # define WARNING_CALL rb_compile_warning
1834 PRINTF_ARGS(static void parser_compile_error(struct parser_params*, const rb_code_location_t *loc, const char *fmt, ...), 3, 4);
1835 # define compile_error(p, ...) parser_compile_error(p, NULL, __VA_ARGS__)
1838 #define RNODE_EXITS(node) ((rb_node_exits_t*)(node))
1841 add_block_exit(struct parser_params *p, NODE *node)
1844 compile_error(p, "unexpected null node");
1847 switch (nd_type(node)) {
1848 case NODE_BREAK: case NODE_NEXT: case NODE_REDO: break;
1850 compile_error(p, "add_block_exit: unexpected node: %s", parser_node_name(nd_type(node)));
1853 if (!p->ctxt.in_defined) {
1854 rb_node_exits_t *exits = p->exits;
1856 RNODE_EXITS(exits->nd_stts)->nd_chain = node;
1857 exits->nd_stts = node;
1863 static rb_node_exits_t *
1864 init_block_exit(struct parser_params *p)
1866 rb_node_exits_t *old = p->exits;
1867 rb_node_exits_t *exits = NODE_NEW_INTERNAL(NODE_EXITS, rb_node_exits_t);
1868 exits->nd_chain = 0;
1869 exits->nd_stts = RNODE(exits);
1874 static rb_node_exits_t *
1875 allow_block_exit(struct parser_params *p)
1877 rb_node_exits_t *exits = p->exits;
1883 restore_block_exit(struct parser_params *p, rb_node_exits_t *exits)
1889 clear_block_exit(struct parser_params *p, bool error)
1891 rb_node_exits_t *exits = p->exits;
1894 for (NODE *e = RNODE(exits); (e = RNODE_EXITS(e)->nd_chain) != 0; ) {
1895 switch (nd_type(e)) {
1897 yyerror1(&e->nd_loc, "Invalid break");
1900 yyerror1(&e->nd_loc, "Invalid next");
1903 yyerror1(&e->nd_loc, "Invalid redo");
1906 yyerror1(&e->nd_loc, "unexpected node");
1907 goto end_checks; /* no nd_chain */
1912 exits->nd_stts = RNODE(exits);
1913 exits->nd_chain = 0;
1916 #define WARN_EOL(tok) \
1917 (looking_at_eol_p(p) ? \
1918 (void)rb_warning0("'" tok "' at the end of line without an expression") : \
1920 static int looking_at_eol_p(struct parser_params *p);
1923 get_nd_value(struct parser_params *p, NODE *node)
1925 switch (nd_type(node)) {
1927 return RNODE_GASGN(node)->nd_value;
1929 return RNODE_IASGN(node)->nd_value;
1931 return RNODE_LASGN(node)->nd_value;
1933 return RNODE_DASGN(node)->nd_value;
1935 return RNODE_MASGN(node)->nd_value;
1937 return RNODE_CVASGN(node)->nd_value;
1939 return RNODE_CDECL(node)->nd_value;
1941 compile_error(p, "get_nd_value: unexpected node: %s", parser_node_name(nd_type(node)));
1947 set_nd_value(struct parser_params *p, NODE *node, NODE *rhs)
1949 switch (nd_type(node)) {
1951 RNODE_CDECL(node)->nd_value = rhs;
1954 RNODE_GASGN(node)->nd_value = rhs;
1957 RNODE_IASGN(node)->nd_value = rhs;
1960 RNODE_LASGN(node)->nd_value = rhs;
1963 RNODE_DASGN(node)->nd_value = rhs;
1966 RNODE_MASGN(node)->nd_value = rhs;
1969 RNODE_CVASGN(node)->nd_value = rhs;
1972 compile_error(p, "set_nd_value: unexpected node: %s", parser_node_name(nd_type(node)));
1978 get_nd_vid(struct parser_params *p, NODE *node)
1980 switch (nd_type(node)) {
1982 return RNODE_CDECL(node)->nd_vid;
1984 return RNODE_GASGN(node)->nd_vid;
1986 return RNODE_IASGN(node)->nd_vid;
1988 return RNODE_LASGN(node)->nd_vid;
1990 return RNODE_DASGN(node)->nd_vid;
1992 return RNODE_CVASGN(node)->nd_vid;
1994 compile_error(p, "get_nd_vid: unexpected node: %s", parser_node_name(nd_type(node)));
2000 get_nd_args(struct parser_params *p, NODE *node)
2002 switch (nd_type(node)) {
2004 return RNODE_CALL(node)->nd_args;
2006 return RNODE_OPCALL(node)->nd_args;
2008 return RNODE_FCALL(node)->nd_args;
2010 return RNODE_QCALL(node)->nd_args;
2012 return RNODE_SUPER(node)->nd_args;
2021 compile_error(p, "get_nd_args: unexpected node: %s", parser_node_name(nd_type(node)));
2027 djb2(const uint8_t *str, size_t len)
2029 st_index_t hash = 5381;
2031 for (size_t i = 0; i < len; i++) {
2032 hash = ((hash << 5) + hash) + str[i];
2039 parser_memhash(const void *ptr, long len)
2041 return djb2(ptr, len);
2044 #define PARSER_STRING_PTR(str) (str->ptr)
2045 #define PARSER_STRING_LEN(str) (str->len)
2046 #define PARSER_STRING_END(str) (&str->ptr[str->len])
2047 #define STRING_SIZE(str) ((size_t)str->len + 1)
2048 #define STRING_TERM_LEN(str) (1)
2049 #define STRING_TERM_FILL(str) (str->ptr[str->len] = '\0
')
2050 #define PARSER_STRING_RESIZE_CAPA_TERM(p,str,capacity,termlen) do {\
2051 SIZED_REALLOC_N(str->ptr, char, (size_t)total + termlen, STRING_SIZE(str)); \
2054 #define STRING_SET_LEN(str, n) do { \
2057 #define PARSER_STRING_GETMEM(str, ptrvar, lenvar) \
2058 ((ptrvar) = str->ptr, \
2059 (lenvar) = str->len)
2062 parser_string_char_at_end(struct parser_params *p, rb_parser_string_t *str, int when_empty)
2064 return PARSER_STRING_LEN(str) > 0 ? (unsigned char)PARSER_STRING_END(str)[-1] : when_empty;
2067 static rb_parser_string_t *
2068 rb_parser_string_new(rb_parser_t *p, const char *ptr, long len)
2070 rb_parser_string_t *str;
2073 rb_bug("negative string size (or size too big): %ld", len);
2076 str = xcalloc(1, sizeof(rb_parser_string_t));
2077 str->ptr = xcalloc(len + 1, sizeof(char));
2080 memcpy(PARSER_STRING_PTR(str), ptr, len);
2082 STRING_SET_LEN(str, len);
2083 STRING_TERM_FILL(str);
2087 static rb_parser_string_t *
2088 rb_parser_encoding_string_new(rb_parser_t *p, const char *ptr, long len, rb_encoding *enc)
2090 rb_parser_string_t *str = rb_parser_string_new(p, ptr, len);
2091 str->coderange = RB_PARSER_ENC_CODERANGE_UNKNOWN;
2097 rb_parser_string_t *
2098 rb_str_to_parser_string(rb_parser_t *p, VALUE str)
2101 rb_parser_string_t *ret = rb_parser_encoding_string_new(p, RSTRING_PTR(str), RSTRING_LEN(str), rb_enc_get(str));
2107 rb_parser_string_free(rb_parser_t *p, rb_parser_string_t *str)
2110 xfree(PARSER_STRING_PTR(str));
2116 rb_parser_str_hash(rb_parser_string_t *str)
2118 return parser_memhash((const void *)PARSER_STRING_PTR(str), PARSER_STRING_LEN(str));
2122 rb_char_p_hash(const char *c)
2124 return parser_memhash((const void *)c, strlen(c));
2128 rb_parser_str_capacity(rb_parser_string_t *str, const int termlen)
2130 return PARSER_STRING_LEN(str);
2135 rb_parser_string_end(rb_parser_string_t *str)
2137 return &str->ptr[str->len];
2142 rb_parser_string_set_encoding(rb_parser_string_t *str, rb_encoding *enc)
2147 static rb_encoding *
2148 rb_parser_str_get_encoding(rb_parser_string_t *str)
2155 PARSER_ENCODING_IS_ASCII8BIT(struct parser_params *p, rb_parser_string_t *str)
2157 return rb_parser_str_get_encoding(str) == rb_ascii8bit_encoding();
2162 PARSER_ENC_CODERANGE(rb_parser_string_t *str)
2164 return str->coderange;
2168 PARSER_ENC_CODERANGE_SET(rb_parser_string_t *str, int coderange)
2170 str->coderange = coderange;
2174 PARSER_ENCODING_CODERANGE_SET(rb_parser_string_t *str, rb_encoding *enc, enum rb_parser_string_coderange_type cr)
2176 rb_parser_string_set_encoding(str, enc);
2177 PARSER_ENC_CODERANGE_SET(str, cr);
2181 PARSER_ENC_CODERANGE_CLEAR(rb_parser_string_t *str)
2183 str->coderange = RB_PARSER_ENC_CODERANGE_UNKNOWN;
2187 PARSER_ENC_CODERANGE_ASCIIONLY(rb_parser_string_t *str)
2189 return PARSER_ENC_CODERANGE(str) == RB_PARSER_ENC_CODERANGE_7BIT;
2193 PARSER_ENC_CODERANGE_CLEAN_P(int cr)
2195 return cr == RB_PARSER_ENC_CODERANGE_7BIT || cr == RB_PARSER_ENC_CODERANGE_VALID;
2199 rb_parser_search_nonascii(const char *p, const char *e)
2203 for (; s < e; s++) {
2204 if (*s & 0x80) return s;
2211 rb_parser_coderange_scan(struct parser_params *p, const char *ptr, long len, rb_encoding *enc)
2213 const char *e = ptr + len;
2215 if (enc == rb_ascii8bit_encoding()) {
2216 /* enc is ASCII-8BIT. ASCII-8BIT string never be broken. */
2217 ptr = rb_parser_search_nonascii(ptr, e);
2218 return ptr ? RB_PARSER_ENC_CODERANGE_VALID : RB_PARSER_ENC_CODERANGE_7BIT;
2221 /* parser string encoding is always asciicompat */
2222 ptr = rb_parser_search_nonascii(ptr, e);
2223 if (!ptr) return RB_PARSER_ENC_CODERANGE_7BIT;
2225 int ret = rb_enc_precise_mbclen(ptr, e, enc);
2226 if (!MBCLEN_CHARFOUND_P(ret)) return RB_PARSER_ENC_CODERANGE_BROKEN;
2227 ptr += MBCLEN_CHARFOUND_LEN(ret);
2228 if (ptr == e) break;
2229 ptr = rb_parser_search_nonascii(ptr, e);
2233 return RB_PARSER_ENC_CODERANGE_VALID;
2237 rb_parser_enc_coderange_scan(struct parser_params *p, rb_parser_string_t *str, rb_encoding *enc)
2239 return rb_parser_coderange_scan(p, PARSER_STRING_PTR(str), PARSER_STRING_LEN(str), enc);
2243 rb_parser_enc_str_coderange(struct parser_params *p, rb_parser_string_t *str)
2245 int cr = PARSER_ENC_CODERANGE(str);
2247 if (cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2248 cr = rb_parser_enc_coderange_scan(p, str, rb_parser_str_get_encoding(str));
2249 PARSER_ENC_CODERANGE_SET(str, cr);
2255 static rb_parser_string_t *
2256 rb_parser_enc_associate(struct parser_params *p, rb_parser_string_t *str, rb_encoding *enc)
2258 if (rb_parser_str_get_encoding(str) == enc)
2260 if (!PARSER_ENC_CODERANGE_ASCIIONLY(str)) {
2261 PARSER_ENC_CODERANGE_CLEAR(str);
2263 rb_parser_string_set_encoding(str, enc);
2268 rb_parser_is_ascii_string(struct parser_params *p, rb_parser_string_t *str)
2270 return rb_parser_enc_str_coderange(p, str) == RB_PARSER_ENC_CODERANGE_7BIT;
2273 static rb_encoding *
2274 rb_parser_enc_compatible(struct parser_params *p, rb_parser_string_t *str1, rb_parser_string_t *str2)
2276 rb_encoding *enc1 = rb_parser_str_get_encoding(str1);
2277 rb_encoding *enc2 = rb_parser_str_get_encoding(str2);
2279 if (enc1 == NULL || enc2 == NULL)
2286 if (PARSER_STRING_LEN(str2) == 0)
2288 if (PARSER_STRING_LEN(str1) == 0)
2289 return rb_parser_is_ascii_string(p, str2) ? enc1 : enc2;
2293 cr1 = rb_parser_enc_str_coderange(p, str1);
2294 cr2 = rb_parser_enc_str_coderange(p, str2);
2297 if (cr1 == RB_PARSER_ENC_CODERANGE_7BIT) return enc2;
2298 if (cr2 == RB_PARSER_ENC_CODERANGE_7BIT) return enc1;
2301 if (cr2 == RB_PARSER_ENC_CODERANGE_7BIT) {
2305 if (cr1 == RB_PARSER_ENC_CODERANGE_7BIT) {
2313 rb_parser_str_modify(rb_parser_string_t *str)
2315 PARSER_ENC_CODERANGE_CLEAR(str);
2319 rb_parser_str_set_len(struct parser_params *p, rb_parser_string_t *str, long len)
2322 const int termlen = STRING_TERM_LEN(str);
2324 if (len > (capa = (long)(rb_parser_str_capacity(str, termlen))) || len < 0) {
2325 rb_bug("probable buffer overflow: %ld for %ld", len, capa);
2328 int cr = PARSER_ENC_CODERANGE(str);
2329 if (cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2330 /* Leave unknown. */
2332 else if (len > PARSER_STRING_LEN(str)) {
2333 PARSER_ENC_CODERANGE_SET(str, RB_PARSER_ENC_CODERANGE_UNKNOWN);
2335 else if (len < PARSER_STRING_LEN(str)) {
2336 if (cr != RB_PARSER_ENC_CODERANGE_7BIT) {
2337 /* ASCII-only string is keeping after truncated. Valid
2338 * and broken may be invalid or valid, leave unknown. */
2339 PARSER_ENC_CODERANGE_SET(str, RB_PARSER_ENC_CODERANGE_UNKNOWN);
2343 STRING_SET_LEN(str, len);
2344 STRING_TERM_FILL(str);
2347 static rb_parser_string_t *
2348 rb_parser_str_buf_cat(struct parser_params *p, rb_parser_string_t *str, const char *ptr, long len)
2350 rb_parser_str_modify(str);
2351 if (len == 0) return 0;
2353 long total, olen, off = -1;
2355 const int termlen = STRING_TERM_LEN(str);
2357 PARSER_STRING_GETMEM(str, sptr, olen);
2358 if (ptr >= sptr && ptr <= sptr + olen) {
2362 if (olen > LONG_MAX - len) {
2363 compile_error(p, "string sizes too big");
2367 PARSER_STRING_RESIZE_CAPA_TERM(p, str, total, termlen);
2368 sptr = PARSER_STRING_PTR(str);
2372 memcpy(sptr + olen, ptr, len);
2373 STRING_SET_LEN(str, total);
2374 STRING_TERM_FILL(str);
2379 #define parser_str_cat(str, ptr, len) rb_parser_str_buf_cat(p, str, ptr, len)
2380 #define parser_str_cat_cstr(str, lit) rb_parser_str_buf_cat(p, str, lit, strlen(lit))
2382 static rb_parser_string_t *
2383 rb_parser_enc_cr_str_buf_cat(struct parser_params *p, rb_parser_string_t *str, const char *ptr, long len,
2384 rb_encoding *ptr_enc, int ptr_cr, int *ptr_cr_ret)
2387 rb_encoding *str_enc, *res_enc;
2389 str_enc = rb_parser_str_get_encoding(str);
2390 str_cr = PARSER_STRING_LEN(str) ? PARSER_ENC_CODERANGE(str) : RB_PARSER_ENC_CODERANGE_7BIT;
2392 if (str_enc == ptr_enc) {
2393 if (str_cr != RB_PARSER_ENC_CODERANGE_UNKNOWN && ptr_cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2394 ptr_cr = rb_parser_coderange_scan(p, ptr, len, ptr_enc);
2398 /* parser string encoding is always asciicompat */
2399 if (ptr_cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2400 ptr_cr = rb_parser_coderange_scan(p, ptr, len, ptr_enc);
2402 if (str_cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2403 if (str_enc == rb_ascii8bit_encoding() || ptr_cr != RB_PARSER_ENC_CODERANGE_7BIT) {
2404 str_cr = rb_parser_enc_str_coderange(p, str);
2409 *ptr_cr_ret = ptr_cr;
2411 if (str_enc != ptr_enc &&
2412 str_cr != RB_PARSER_ENC_CODERANGE_7BIT &&
2413 ptr_cr != RB_PARSER_ENC_CODERANGE_7BIT) {
2417 if (str_cr == RB_PARSER_ENC_CODERANGE_UNKNOWN) {
2419 res_cr = RB_PARSER_ENC_CODERANGE_UNKNOWN;
2421 else if (str_cr == RB_PARSER_ENC_CODERANGE_7BIT) {
2422 if (ptr_cr == RB_PARSER_ENC_CODERANGE_7BIT) {
2424 res_cr = RB_PARSER_ENC_CODERANGE_7BIT;
2431 else if (str_cr == RB_PARSER_ENC_CODERANGE_VALID) {
2433 if (PARSER_ENC_CODERANGE_CLEAN_P(ptr_cr))
2438 else { /* str_cr == RB_PARSER_ENC_CODERANGE_BROKEN */
2441 if (0 < len) res_cr = RB_PARSER_ENC_CODERANGE_UNKNOWN;
2445 compile_error(p, "negative string size (or size too big)");
2447 parser_str_cat(str, ptr, len);
2448 PARSER_ENCODING_CODERANGE_SET(str, res_enc, res_cr);
2452 compile_error(p, "incompatible character encodings: %s and %s",
2453 rb_enc_name(str_enc), rb_enc_name(ptr_enc));
2454 UNREACHABLE_RETURN(0);
2458 static rb_parser_string_t *
2459 rb_parser_enc_str_buf_cat(struct parser_params *p, rb_parser_string_t *str, const char *ptr, long len,
2460 rb_encoding *ptr_enc)
2462 return rb_parser_enc_cr_str_buf_cat(p, str, ptr, len, ptr_enc, RB_PARSER_ENC_CODERANGE_UNKNOWN, NULL);
2465 static rb_parser_string_t *
2466 rb_parser_str_buf_append(struct parser_params *p, rb_parser_string_t *str, rb_parser_string_t *str2)
2468 int str2_cr = rb_parser_enc_str_coderange(p, str2);
2470 rb_parser_enc_cr_str_buf_cat(p, str, PARSER_STRING_PTR(str2), PARSER_STRING_LEN(str2),
2471 rb_parser_str_get_encoding(str2), str2_cr, &str2_cr);
2473 PARSER_ENC_CODERANGE_SET(str2, str2_cr);
2478 static rb_parser_string_t *
2479 rb_parser_str_resize(struct parser_params *p, rb_parser_string_t *str, long len)
2482 rb_bug("negative string size (or size too big)");
2485 long slen = PARSER_STRING_LEN(str);
2487 if (slen > len && PARSER_ENC_CODERANGE(str) != RB_PARSER_ENC_CODERANGE_7BIT) {
2488 PARSER_ENC_CODERANGE_CLEAR(str);
2493 const int termlen = STRING_TERM_LEN(str);
2495 if ((capa = slen) < len) {
2496 SIZED_REALLOC_N(str->ptr, char, (size_t)len + termlen, STRING_SIZE(str));
2498 else if (len == slen) return str;
2499 STRING_SET_LEN(str, len);
2500 STRING_TERM_FILL(str);
2505 # define PARSER_ENC_STRING_GETMEM(str, ptrvar, lenvar, encvar) \
2506 ((ptrvar) = str->ptr, \
2507 (lenvar) = str->len, \
2508 (encvar) = str->enc)
2511 rb_parser_string_hash_cmp(rb_parser_string_t *str1, rb_parser_string_t *str2)
2514 const char *ptr1, *ptr2;
2515 rb_encoding *enc1, *enc2;
2517 PARSER_ENC_STRING_GETMEM(str1, ptr1, len1, enc1);
2518 PARSER_ENC_STRING_GETMEM(str2, ptr2, len2, enc2);
2520 return (len1 != len2 ||
2522 memcmp(ptr1, ptr2, len1) != 0);
2526 rb_parser_ary_extend(rb_parser_t *p, rb_parser_ary_t *ary, long len)
2529 if (ary->capa < len) {
2531 ary->data = (rb_parser_ary_data *)xrealloc(ary->data, sizeof(rb_parser_ary_data) * len);
2532 for (i = ary->len; i < len; i++) {
2539 * Do not call this directly.
2540 * Use rb_parser_ary_new_capa_for_XXX() instead.
2542 static rb_parser_ary_t *
2543 parser_ary_new_capa(rb_parser_t *p, long len)
2546 rb_bug("negative array size (or size too big): %ld", len);
2548 rb_parser_ary_t *ary = xcalloc(1, sizeof(rb_parser_ary_t));
2553 ary->data = (rb_parser_ary_data *)xcalloc(len, sizeof(rb_parser_ary_data));
2562 static rb_parser_ary_t *
2563 rb_parser_ary_new_capa_for_script_line(rb_parser_t *p, long len)
2565 rb_parser_ary_t *ary = parser_ary_new_capa(p, len);
2566 ary->data_type = PARSER_ARY_DATA_SCRIPT_LINE;
2570 static rb_parser_ary_t *
2571 rb_parser_ary_new_capa_for_ast_token(rb_parser_t *p, long len)
2573 rb_parser_ary_t *ary = parser_ary_new_capa(p, len);
2574 ary->data_type = PARSER_ARY_DATA_AST_TOKEN;
2579 static rb_parser_ary_t *
2580 rb_parser_ary_new_capa_for_node(rb_parser_t *p, long len)
2582 rb_parser_ary_t *ary = parser_ary_new_capa(p, len);
2583 ary->data_type = PARSER_ARY_DATA_NODE;
2588 * Do not call this directly.
2589 * Use rb_parser_ary_push_XXX() instead.
2591 static rb_parser_ary_t *
2592 parser_ary_push(rb_parser_t *p, rb_parser_ary_t *ary, rb_parser_ary_data val)
2594 if (ary->len == ary->capa) {
2595 rb_parser_ary_extend(p, ary, ary->len == 0 ? 1 : ary->len * 2);
2597 ary->data[ary->len++] = val;
2602 static rb_parser_ary_t *
2603 rb_parser_ary_push_ast_token(rb_parser_t *p, rb_parser_ary_t *ary, rb_parser_ast_token_t *val)
2605 if (ary->data_type != PARSER_ARY_DATA_AST_TOKEN) {
2606 rb_bug("unexpected rb_parser_ary_data_type: %d", ary->data_type);
2608 return parser_ary_push(p, ary, val);
2611 static rb_parser_ary_t *
2612 rb_parser_ary_push_script_line(rb_parser_t *p, rb_parser_ary_t *ary, rb_parser_string_t *val)
2614 if (ary->data_type != PARSER_ARY_DATA_SCRIPT_LINE) {
2615 rb_bug("unexpected rb_parser_ary_data_type: %d", ary->data_type);
2617 return parser_ary_push(p, ary, val);
2621 static rb_parser_ary_t *
2622 rb_parser_ary_push_node(rb_parser_t *p, rb_parser_ary_t *ary, NODE *val)
2624 if (ary->data_type != PARSER_ARY_DATA_NODE) {
2625 rb_bug("unexpected rb_parser_ary_data_type: %d", ary->data_type);
2627 return parser_ary_push(p, ary, val);
2632 rb_parser_ast_token_free(rb_parser_t *p, rb_parser_ast_token_t *token)
2635 rb_parser_string_free(p, token->str);
2640 rb_parser_ary_free(rb_parser_t *p, rb_parser_ary_t *ary)
2642 # define foreach_ary(ptr) \
2643 for (rb_parser_ary_data *ptr = ary->data, *const end_ary_data = ptr + ary->len; \
2644 ptr < end_ary_data; ptr++)
2645 switch (ary->data_type) {
2646 case PARSER_ARY_DATA_AST_TOKEN:
2647 foreach_ary(data) {rb_parser_ast_token_free(p, *data);}
2649 case PARSER_ARY_DATA_SCRIPT_LINE:
2650 foreach_ary(data) {rb_parser_string_free(p, *data);}
2652 case PARSER_ARY_DATA_NODE:
2653 /* Do nothing because nodes are freed when rb_ast_t is freed */
2656 rb_bug("unexpected rb_parser_ary_data_type: %d", ary->data_type);
2664 #endif /* !RIPPER */
2666 #line 2667 "parse.c"
2670 # define YY_CAST(Type, Val) static_cast<Type> (Val)
2671 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
2673 # define YY_CAST(Type, Val) ((Type) (Val))
2674 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
2678 # if defined __cplusplus
2679 # if 201103L <= __cplusplus
2680 # define YY_NULLPTR nullptr
2682 # define YY_NULLPTR 0
2685 # define YY_NULLPTR ((void*)0)
2691 enum yysymbol_kind_t
2693 YYSYMBOL_YYEMPTY = -2,
2694 YYSYMBOL_YYEOF = 0, /* "end-of-input" */
2695 YYSYMBOL_YYerror = 1, /* error */
2696 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
2697 YYSYMBOL_keyword_class = 3, /* "'class'" */
2698 YYSYMBOL_keyword_module = 4, /* "'module
'" */
2699 YYSYMBOL_keyword_def = 5, /* "'def
'" */
2700 YYSYMBOL_keyword_undef = 6, /* "'undef
'" */
2701 YYSYMBOL_keyword_begin = 7, /* "'begin
'" */
2702 YYSYMBOL_keyword_rescue = 8, /* "'rescue
'" */
2703 YYSYMBOL_keyword_ensure = 9, /* "'ensure
'" */
2704 YYSYMBOL_keyword_end = 10, /* "'end
'" */
2705 YYSYMBOL_keyword_if = 11, /* "'if'" */
2706 YYSYMBOL_keyword_unless = 12, /* "'unless
'" */
2707 YYSYMBOL_keyword_then = 13, /* "'then
'" */
2708 YYSYMBOL_keyword_elsif = 14, /* "'elsif
'" */
2709 YYSYMBOL_keyword_else = 15, /* "'else'" */
2710 YYSYMBOL_keyword_case = 16, /* "'case'" */
2711 YYSYMBOL_keyword_when = 17, /* "'when
'" */
2712 YYSYMBOL_keyword_while = 18, /* "'while'" */
2713 YYSYMBOL_keyword_until = 19, /* "'until
'" */
2714 YYSYMBOL_keyword_for = 20, /* "'for'" */
2715 YYSYMBOL_keyword_break = 21, /* "'break'" */
2716 YYSYMBOL_keyword_next = 22, /* "'next
'" */
2717 YYSYMBOL_keyword_redo = 23, /* "'redo
'" */
2718 YYSYMBOL_keyword_retry = 24, /* "'retry
'" */
2719 YYSYMBOL_keyword_in = 25, /* "'in
'" */
2720 YYSYMBOL_keyword_do = 26, /* "'do'" */
2721 YYSYMBOL_keyword_do_cond = 27, /* "'do' for condition" */
2722 YYSYMBOL_keyword_do_block = 28, /* "'do' for block" */
2723 YYSYMBOL_keyword_do_LAMBDA = 29, /* "'do' for lambda" */
2724 YYSYMBOL_keyword_return = 30, /* "'return'" */
2725 YYSYMBOL_keyword_yield = 31, /* "'yield
'" */
2726 YYSYMBOL_keyword_super = 32, /* "'super
'" */
2727 YYSYMBOL_keyword_self = 33, /* "'self'" */
2728 YYSYMBOL_keyword_nil = 34, /* "'nil
'" */
2729 YYSYMBOL_keyword_true = 35, /* "'true'" */
2730 YYSYMBOL_keyword_false = 36, /* "'false'" */
2731 YYSYMBOL_keyword_and = 37, /* "'and
'" */
2732 YYSYMBOL_keyword_or = 38, /* "'or
'" */
2733 YYSYMBOL_keyword_not = 39, /* "'not
'" */
2734 YYSYMBOL_modifier_if = 40, /* "'if' modifier" */
2735 YYSYMBOL_modifier_unless = 41, /* "'unless
' modifier" */
2736 YYSYMBOL_modifier_while = 42, /* "'while' modifier" */
2737 YYSYMBOL_modifier_until = 43, /* "'until
' modifier" */
2738 YYSYMBOL_modifier_rescue = 44, /* "'rescue
' modifier" */
2739 YYSYMBOL_keyword_alias = 45, /* "'alias
'" */
2740 YYSYMBOL_keyword_defined = 46, /* "'defined?
'" */
2741 YYSYMBOL_keyword_BEGIN = 47, /* "'BEGIN
'" */
2742 YYSYMBOL_keyword_END = 48, /* "'END
'" */
2743 YYSYMBOL_keyword__LINE__ = 49, /* "'__LINE__
'" */
2744 YYSYMBOL_keyword__FILE__ = 50, /* "'__FILE__
'" */
2745 YYSYMBOL_keyword__ENCODING__ = 51, /* "'__ENCODING__
'" */
2746 YYSYMBOL_tIDENTIFIER = 52, /* "local variable or method" */
2747 YYSYMBOL_tFID = 53, /* "method" */
2748 YYSYMBOL_tGVAR = 54, /* "global variable" */
2749 YYSYMBOL_tIVAR = 55, /* "instance variable" */
2750 YYSYMBOL_tCONSTANT = 56, /* "constant" */
2751 YYSYMBOL_tCVAR = 57, /* "class variable" */
2752 YYSYMBOL_tLABEL = 58, /* "label" */
2753 YYSYMBOL_tINTEGER = 59, /* "integer literal" */
2754 YYSYMBOL_tFLOAT = 60, /* "float literal" */
2755 YYSYMBOL_tRATIONAL = 61, /* "rational literal" */
2756 YYSYMBOL_tIMAGINARY = 62, /* "imaginary literal" */
2757 YYSYMBOL_tCHAR = 63, /* "char literal" */
2758 YYSYMBOL_tNTH_REF = 64, /* "numbered reference" */
2759 YYSYMBOL_tBACK_REF = 65, /* "back reference" */
2760 YYSYMBOL_tSTRING_CONTENT = 66, /* "literal content" */
2761 YYSYMBOL_tREGEXP_END = 67, /* tREGEXP_END */
2762 YYSYMBOL_tDUMNY_END = 68, /* "dummy end" */
2763 YYSYMBOL_69_ = 69, /* '.
' */
2764 YYSYMBOL_70_backslash_ = 70, /* "backslash" */
2765 YYSYMBOL_tSP = 71, /* "escaped space" */
2766 YYSYMBOL_72_escaped_horizontal_tab_ = 72, /* "escaped horizontal tab" */
2767 YYSYMBOL_73_escaped_form_feed_ = 73, /* "escaped form feed" */
2768 YYSYMBOL_74_escaped_carriage_return_ = 74, /* "escaped carriage return" */
2769 YYSYMBOL_75_escaped_vertical_tab_ = 75, /* "escaped vertical tab" */
2770 YYSYMBOL_tUPLUS = 76, /* "unary+" */
2771 YYSYMBOL_tUMINUS = 77, /* "unary-" */
2772 YYSYMBOL_tPOW = 78, /* "**" */
2773 YYSYMBOL_tCMP = 79, /* "<=>" */
2774 YYSYMBOL_tEQ = 80, /* "==" */
2775 YYSYMBOL_tEQQ = 81, /* "===" */
2776 YYSYMBOL_tNEQ = 82, /* "!=" */
2777 YYSYMBOL_tGEQ = 83, /* ">=" */
2778 YYSYMBOL_tLEQ = 84, /* "<=" */
2779 YYSYMBOL_tANDOP = 85, /* "&&" */
2780 YYSYMBOL_tOROP = 86, /* "||" */
2781 YYSYMBOL_tMATCH = 87, /* "=~" */
2782 YYSYMBOL_tNMATCH = 88, /* "!~" */
2783 YYSYMBOL_tDOT2 = 89, /* ".." */
2784 YYSYMBOL_tDOT3 = 90, /* "..." */
2785 YYSYMBOL_tBDOT2 = 91, /* "(.." */
2786 YYSYMBOL_tBDOT3 = 92, /* "(..." */
2787 YYSYMBOL_tAREF = 93, /* "[]" */
2788 YYSYMBOL_tASET = 94, /* "[]=" */
2789 YYSYMBOL_tLSHFT = 95, /* "<<" */
2790 YYSYMBOL_tRSHFT = 96, /* ">>" */
2791 YYSYMBOL_tANDDOT = 97, /* "&." */
2792 YYSYMBOL_tCOLON2 = 98, /* "::" */
2793 YYSYMBOL_tCOLON3 = 99, /* ":: at EXPR_BEG" */
2794 YYSYMBOL_tOP_ASGN = 100, /* "operator-assignment" */
2795 YYSYMBOL_tASSOC = 101, /* "=>" */
2796 YYSYMBOL_tLPAREN = 102, /* "(" */
2797 YYSYMBOL_tLPAREN_ARG = 103, /* "( arg" */
2798 YYSYMBOL_tRPAREN = 104, /* ")" */
2799 YYSYMBOL_tLBRACK = 105, /* "[" */
2800 YYSYMBOL_tLBRACE = 106, /* "{" */
2801 YYSYMBOL_tLBRACE_ARG = 107, /* "{ arg" */
2802 YYSYMBOL_tSTAR = 108, /* "*" */
2803 YYSYMBOL_tDSTAR = 109, /* "**arg" */
2804 YYSYMBOL_tAMPER = 110, /* "&" */
2805 YYSYMBOL_tLAMBDA = 111, /* "->" */
2806 YYSYMBOL_tSYMBEG = 112, /* "symbol literal" */
2807 YYSYMBOL_tSTRING_BEG = 113, /* "string literal" */
2808 YYSYMBOL_tXSTRING_BEG = 114, /* "backtick literal" */
2809 YYSYMBOL_tREGEXP_BEG = 115, /* "regexp literal" */
2810 YYSYMBOL_tWORDS_BEG = 116, /* "word list" */
2811 YYSYMBOL_tQWORDS_BEG = 117, /* "verbatim word list" */
2812 YYSYMBOL_tSYMBOLS_BEG = 118, /* "symbol list" */
2813 YYSYMBOL_tQSYMBOLS_BEG = 119, /* "verbatim symbol list" */
2814 YYSYMBOL_tSTRING_END = 120, /* "terminator" */
2815 YYSYMBOL_tSTRING_DEND = 121, /* "'}
'" */
2816 YYSYMBOL_tSTRING_DBEG = 122, /* "'#{
'" */
2817 YYSYMBOL_tSTRING_DVAR = 123, /* tSTRING_DVAR */
2818 YYSYMBOL_tLAMBEG = 124, /* tLAMBEG */
2819 YYSYMBOL_tLABEL_END = 125, /* tLABEL_END */
2820 YYSYMBOL_tIGNORED_NL = 126, /* tIGNORED_NL */
2821 YYSYMBOL_tCOMMENT = 127, /* tCOMMENT */
2822 YYSYMBOL_tEMBDOC_BEG = 128, /* tEMBDOC_BEG */
2823 YYSYMBOL_tEMBDOC = 129, /* tEMBDOC */
2824 YYSYMBOL_tEMBDOC_END = 130, /* tEMBDOC_END */
2825 YYSYMBOL_tHEREDOC_BEG = 131, /* tHEREDOC_BEG */
2826 YYSYMBOL_tHEREDOC_END = 132, /* tHEREDOC_END */
2827 YYSYMBOL_k__END__ = 133, /* k__END__ */
2828 YYSYMBOL_tLOWEST = 134, /* tLOWEST */
2829 YYSYMBOL_135_ = 135, /* '=
' */
2830 YYSYMBOL_136_ = 136, /* '?
' */
2831 YYSYMBOL_137_ = 137, /* ':
' */
2832 YYSYMBOL_138_ = 138, /* '>
' */
2833 YYSYMBOL_139_ = 139, /* '<
' */
2834 YYSYMBOL_140_ = 140, /* '|
' */
2835 YYSYMBOL_141_ = 141, /* '^
' */
2836 YYSYMBOL_142_ = 142, /* '&
' */
2837 YYSYMBOL_143_ = 143, /* '+
' */
2838 YYSYMBOL_144_ = 144, /* '-
' */
2839 YYSYMBOL_145_ = 145, /* '*
' */
2840 YYSYMBOL_146_ = 146, /* '/
' */
2841 YYSYMBOL_147_ = 147, /* '%
' */
2842 YYSYMBOL_tUMINUS_NUM = 148, /* tUMINUS_NUM */
2843 YYSYMBOL_149_ = 149, /* '!
' */
2844 YYSYMBOL_150_ = 150, /* '~
' */
2845 YYSYMBOL_tLAST_TOKEN = 151, /* tLAST_TOKEN */
2846 YYSYMBOL_152_ = 152, /* '{
' */
2847 YYSYMBOL_153_ = 153, /* '}
' */
2848 YYSYMBOL_154_ = 154, /* '[
' */
2849 YYSYMBOL_155_n_ = 155, /* '\n
' */
2850 YYSYMBOL_156_ = 156, /* ',
' */
2851 YYSYMBOL_157_ = 157, /* '`
' */
2852 YYSYMBOL_158_ = 158, /* '(
' */
2853 YYSYMBOL_159_ = 159, /* ')
' */
2854 YYSYMBOL_160_ = 160, /* ']
' */
2855 YYSYMBOL_161_ = 161, /* ';
' */
2856 YYSYMBOL_162_ = 162, /* ' ' */
2857 YYSYMBOL_YYACCEPT = 163, /* $accept */
2858 YYSYMBOL_164_1 = 164, /* $@1 */
2859 YYSYMBOL_program = 165, /* program */
2860 YYSYMBOL_option_terms = 166, /* option_terms */
2861 YYSYMBOL_top_compstmt = 167, /* top_compstmt */
2862 YYSYMBOL_top_stmts = 168, /* top_stmts */
2863 YYSYMBOL_top_stmt = 169, /* top_stmt */
2864 YYSYMBOL_block_open = 170, /* block_open */
2865 YYSYMBOL_begin_block = 171, /* begin_block */
2866 YYSYMBOL_172_2 = 172, /* $@2 */
2867 YYSYMBOL_173_3 = 173, /* $@3 */
2868 YYSYMBOL_bodystmt = 174, /* bodystmt */
2869 YYSYMBOL_175_4 = 175, /* $@4 */
2870 YYSYMBOL_compstmt = 176, /* compstmt */
2871 YYSYMBOL_stmts = 177, /* stmts */
2872 YYSYMBOL_stmt_or_begin = 178, /* stmt_or_begin */
2873 YYSYMBOL_179_5 = 179, /* $@5 */
2874 YYSYMBOL_allow_exits = 180, /* allow_exits */
2875 YYSYMBOL_k_END = 181, /* k_END */
2876 YYSYMBOL_182_6 = 182, /* $@6 */
2877 YYSYMBOL_stmt = 183, /* stmt */
2878 YYSYMBOL_command_asgn = 184, /* command_asgn */
2879 YYSYMBOL_endless_command = 185, /* endless_command */
2880 YYSYMBOL_option__n_ = 186, /* option_'\n
' */
2881 YYSYMBOL_command_rhs = 187, /* command_rhs */
2882 YYSYMBOL_expr = 188, /* expr */
2883 YYSYMBOL_189_7 = 189, /* $@7 */
2884 YYSYMBOL_190_8 = 190, /* $@8 */
2885 YYSYMBOL_def_name = 191, /* def_name */
2886 YYSYMBOL_defn_head = 192, /* defn_head */
2887 YYSYMBOL_193_9 = 193, /* $@9 */
2888 YYSYMBOL_defs_head = 194, /* defs_head */
2889 YYSYMBOL_expr_value = 195, /* expr_value */
2890 YYSYMBOL_196_10 = 196, /* $@10 */
2891 YYSYMBOL_197_11 = 197, /* $@11 */
2892 YYSYMBOL_expr_value_do = 198, /* expr_value_do */
2893 YYSYMBOL_command_call = 199, /* command_call */
2894 YYSYMBOL_block_command = 200, /* block_command */
2895 YYSYMBOL_cmd_brace_block = 201, /* cmd_brace_block */
2896 YYSYMBOL_fcall = 202, /* fcall */
2897 YYSYMBOL_command = 203, /* command */
2898 YYSYMBOL_mlhs = 204, /* mlhs */
2899 YYSYMBOL_mlhs_inner = 205, /* mlhs_inner */
2900 YYSYMBOL_mlhs_basic = 206, /* mlhs_basic */
2901 YYSYMBOL_mlhs_item = 207, /* mlhs_item */
2902 YYSYMBOL_mlhs_head = 208, /* mlhs_head */
2903 YYSYMBOL_mlhs_post = 209, /* mlhs_post */
2904 YYSYMBOL_mlhs_node = 210, /* mlhs_node */
2905 YYSYMBOL_lhs = 211, /* lhs */
2906 YYSYMBOL_cname = 212, /* cname */
2907 YYSYMBOL_cpath = 213, /* cpath */
2908 YYSYMBOL_fname = 214, /* fname */
2909 YYSYMBOL_fitem = 215, /* fitem */
2910 YYSYMBOL_undef_list = 216, /* undef_list */
2911 YYSYMBOL_217_12 = 217, /* $@12 */
2912 YYSYMBOL_op = 218, /* op */
2913 YYSYMBOL_reswords = 219, /* reswords */
2914 YYSYMBOL_arg = 220, /* arg */
2915 YYSYMBOL_endless_arg = 221, /* endless_arg */
2916 YYSYMBOL_relop = 222, /* relop */
2917 YYSYMBOL_rel_expr = 223, /* rel_expr */
2918 YYSYMBOL_lex_ctxt = 224, /* lex_ctxt */
2919 YYSYMBOL_begin_defined = 225, /* begin_defined */
2920 YYSYMBOL_after_rescue = 226, /* after_rescue */
2921 YYSYMBOL_arg_value = 227, /* arg_value */
2922 YYSYMBOL_aref_args = 228, /* aref_args */
2923 YYSYMBOL_arg_rhs = 229, /* arg_rhs */
2924 YYSYMBOL_paren_args = 230, /* paren_args */
2925 YYSYMBOL_opt_paren_args = 231, /* opt_paren_args */
2926 YYSYMBOL_opt_call_args = 232, /* opt_call_args */
2927 YYSYMBOL_call_args = 233, /* call_args */
2928 YYSYMBOL_234_13 = 234, /* $@13 */
2929 YYSYMBOL_command_args = 235, /* command_args */
2930 YYSYMBOL_block_arg = 236, /* block_arg */
2931 YYSYMBOL_opt_block_arg = 237, /* opt_block_arg */
2932 YYSYMBOL_args = 238, /* args */
2933 YYSYMBOL_arg_splat = 239, /* arg_splat */
2934 YYSYMBOL_mrhs_arg = 240, /* mrhs_arg */
2935 YYSYMBOL_mrhs = 241, /* mrhs */
2936 YYSYMBOL_primary = 242, /* primary */
2937 YYSYMBOL_243_14 = 243, /* $@14 */
2938 YYSYMBOL_244_15 = 244, /* $@15 */
2939 YYSYMBOL_245_16 = 245, /* @16 */
2940 YYSYMBOL_246_17 = 246, /* @17 */
2941 YYSYMBOL_247_18 = 247, /* $@18 */
2942 YYSYMBOL_248_19 = 248, /* $@19 */
2943 YYSYMBOL_249_20 = 249, /* $@20 */
2944 YYSYMBOL_250_21 = 250, /* $@21 */
2945 YYSYMBOL_251_22 = 251, /* $@22 */
2946 YYSYMBOL_primary_value = 252, /* primary_value */
2947 YYSYMBOL_k_begin = 253, /* k_begin */
2948 YYSYMBOL_k_if = 254, /* k_if */
2949 YYSYMBOL_k_unless = 255, /* k_unless */
2950 YYSYMBOL_k_while = 256, /* k_while */
2951 YYSYMBOL_k_until = 257, /* k_until */
2952 YYSYMBOL_k_case = 258, /* k_case */
2953 YYSYMBOL_k_for = 259, /* k_for */
2954 YYSYMBOL_k_class = 260, /* k_class */
2955 YYSYMBOL_k_module = 261, /* k_module */
2956 YYSYMBOL_k_def = 262, /* k_def */
2957 YYSYMBOL_k_do = 263, /* k_do */
2958 YYSYMBOL_k_do_block = 264, /* k_do_block */
2959 YYSYMBOL_k_rescue = 265, /* k_rescue */
2960 YYSYMBOL_k_ensure = 266, /* k_ensure */
2961 YYSYMBOL_k_when = 267, /* k_when */
2962 YYSYMBOL_k_else = 268, /* k_else */
2963 YYSYMBOL_k_elsif = 269, /* k_elsif */
2964 YYSYMBOL_k_end = 270, /* k_end */
2965 YYSYMBOL_k_return = 271, /* k_return */
2966 YYSYMBOL_k_yield = 272, /* k_yield */
2967 YYSYMBOL_then = 273, /* then */
2968 YYSYMBOL_do = 274, /* do */
2969 YYSYMBOL_if_tail = 275, /* if_tail */
2970 YYSYMBOL_opt_else = 276, /* opt_else */
2971 YYSYMBOL_for_var = 277, /* for_var */
2972 YYSYMBOL_f_marg = 278, /* f_marg */
2973 YYSYMBOL_f_marg_list = 279, /* f_marg_list */
2974 YYSYMBOL_f_margs = 280, /* f_margs */
2975 YYSYMBOL_f_rest_marg = 281, /* f_rest_marg */
2976 YYSYMBOL_f_any_kwrest = 282, /* f_any_kwrest */
2977 YYSYMBOL_283_23 = 283, /* $@23 */
2978 YYSYMBOL_f_eq = 284, /* f_eq */
2979 YYSYMBOL_f_kwarg_f_block_kw = 285, /* f_kwarg_f_block_kw */
2980 YYSYMBOL_block_args_tail = 286, /* block_args_tail */
2981 YYSYMBOL_excessed_comma = 287, /* excessed_comma */
2982 YYSYMBOL_f_opt_primary_value = 288, /* f_opt_primary_value */
2983 YYSYMBOL_f_optarg_primary_value = 289, /* f_optarg_primary_value */
2984 YYSYMBOL_opt_args_tail_block_args_tail = 290, /* opt_args_tail_block_args_tail */
2985 YYSYMBOL_block_param = 291, /* block_param */
2986 YYSYMBOL_opt_block_param = 292, /* opt_block_param */
2987 YYSYMBOL_block_param_def = 293, /* block_param_def */
2988 YYSYMBOL_opt_bv_decl = 294, /* opt_bv_decl */
2989 YYSYMBOL_bv_decls = 295, /* bv_decls */
2990 YYSYMBOL_bvar = 296, /* bvar */
2991 YYSYMBOL_max_numparam = 297, /* max_numparam */
2992 YYSYMBOL_numparam = 298, /* numparam */
2993 YYSYMBOL_it_id = 299, /* it_id */
2994 YYSYMBOL_300_24 = 300, /* @24 */
2995 YYSYMBOL_301_25 = 301, /* $@25 */
2996 YYSYMBOL_lambda = 302, /* lambda */
2997 YYSYMBOL_f_larglist = 303, /* f_larglist */
2998 YYSYMBOL_lambda_body = 304, /* lambda_body */
2999 YYSYMBOL_305_26 = 305, /* $@26 */
3000 YYSYMBOL_do_block = 306, /* do_block */
3001 YYSYMBOL_block_call = 307, /* block_call */
3002 YYSYMBOL_method_call = 308, /* method_call */
3003 YYSYMBOL_brace_block = 309, /* brace_block */
3004 YYSYMBOL_310_27 = 310, /* @27 */
3005 YYSYMBOL_brace_body = 311, /* brace_body */
3006 YYSYMBOL_312_28 = 312, /* @28 */
3007 YYSYMBOL_do_body = 313, /* do_body */
3008 YYSYMBOL_case_args = 314, /* case_args */
3009 YYSYMBOL_case_body = 315, /* case_body */
3010 YYSYMBOL_cases = 316, /* cases */
3011 YYSYMBOL_p_pvtbl = 317, /* p_pvtbl */
3012 YYSYMBOL_p_pktbl = 318, /* p_pktbl */
3013 YYSYMBOL_p_in_kwarg = 319, /* p_in_kwarg */
3014 YYSYMBOL_320_29 = 320, /* $@29 */
3015 YYSYMBOL_p_case_body = 321, /* p_case_body */
3016 YYSYMBOL_p_cases = 322, /* p_cases */
3017 YYSYMBOL_p_top_expr = 323, /* p_top_expr */
3018 YYSYMBOL_p_top_expr_body = 324, /* p_top_expr_body */
3019 YYSYMBOL_p_expr = 325, /* p_expr */
3020 YYSYMBOL_p_as = 326, /* p_as */
3021 YYSYMBOL_p_alt = 327, /* p_alt */
3022 YYSYMBOL_p_lparen = 328, /* p_lparen */
3023 YYSYMBOL_p_lbracket = 329, /* p_lbracket */
3024 YYSYMBOL_p_expr_basic = 330, /* p_expr_basic */
3025 YYSYMBOL_331_30 = 331, /* $@30 */
3026 YYSYMBOL_p_args = 332, /* p_args */
3027 YYSYMBOL_p_args_head = 333, /* p_args_head */
3028 YYSYMBOL_p_args_tail = 334, /* p_args_tail */
3029 YYSYMBOL_p_find = 335, /* p_find */
3030 YYSYMBOL_p_rest = 336, /* p_rest */
3031 YYSYMBOL_p_args_post = 337, /* p_args_post */
3032 YYSYMBOL_p_arg = 338, /* p_arg */
3033 YYSYMBOL_p_kwargs = 339, /* p_kwargs */
3034 YYSYMBOL_p_kwarg = 340, /* p_kwarg */
3035 YYSYMBOL_p_kw = 341, /* p_kw */
3036 YYSYMBOL_p_kw_label = 342, /* p_kw_label */
3037 YYSYMBOL_p_kwrest = 343, /* p_kwrest */
3038 YYSYMBOL_p_kwnorest = 344, /* p_kwnorest */
3039 YYSYMBOL_p_any_kwrest = 345, /* p_any_kwrest */
3040 YYSYMBOL_p_value = 346, /* p_value */
3041 YYSYMBOL_p_primitive = 347, /* p_primitive */
3042 YYSYMBOL_p_variable = 348, /* p_variable */
3043 YYSYMBOL_p_var_ref = 349, /* p_var_ref */
3044 YYSYMBOL_p_expr_ref = 350, /* p_expr_ref */
3045 YYSYMBOL_p_const = 351, /* p_const */
3046 YYSYMBOL_opt_rescue = 352, /* opt_rescue */
3047 YYSYMBOL_exc_list = 353, /* exc_list */
3048 YYSYMBOL_exc_var = 354, /* exc_var */
3049 YYSYMBOL_opt_ensure = 355, /* opt_ensure */
3050 YYSYMBOL_literal = 356, /* literal */
3051 YYSYMBOL_strings = 357, /* strings */
3052 YYSYMBOL_string = 358, /* string */
3053 YYSYMBOL_string1 = 359, /* string1 */
3054 YYSYMBOL_xstring = 360, /* xstring */
3055 YYSYMBOL_regexp = 361, /* regexp */
3056 YYSYMBOL_nonempty_list__ = 362, /* nonempty_list_' ' */
3057 YYSYMBOL_words_tWORDS_BEG_word_list = 363, /* words_tWORDS_BEG_word_list */
3058 YYSYMBOL_words = 364, /* words */
3059 YYSYMBOL_word_list = 365, /* word_list */
3060 YYSYMBOL_word = 366, /* word */
3061 YYSYMBOL_words_tSYMBOLS_BEG_symbol_list = 367, /* words_tSYMBOLS_BEG_symbol_list */
3062 YYSYMBOL_symbols = 368, /* symbols */
3063 YYSYMBOL_symbol_list = 369, /* symbol_list */
3064 YYSYMBOL_words_tQWORDS_BEG_qword_list = 370, /* words_tQWORDS_BEG_qword_list */
3065 YYSYMBOL_qwords = 371, /* qwords */
3066 YYSYMBOL_words_tQSYMBOLS_BEG_qsym_list = 372, /* words_tQSYMBOLS_BEG_qsym_list */
3067 YYSYMBOL_qsymbols = 373, /* qsymbols */
3068 YYSYMBOL_qword_list = 374, /* qword_list */
3069 YYSYMBOL_qsym_list = 375, /* qsym_list */
3070 YYSYMBOL_string_contents = 376, /* string_contents */
3071 YYSYMBOL_xstring_contents = 377, /* xstring_contents */
3072 YYSYMBOL_regexp_contents = 378, /* regexp_contents */
3073 YYSYMBOL_string_content = 379, /* string_content */
3074 YYSYMBOL_380_31 = 380, /* @31 */
3075 YYSYMBOL_381_32 = 381, /* @32 */
3076 YYSYMBOL_382_33 = 382, /* @33 */
3077 YYSYMBOL_383_34 = 383, /* @34 */
3078 YYSYMBOL_string_dend = 384, /* string_dend */
3079 YYSYMBOL_string_dvar = 385, /* string_dvar */
3080 YYSYMBOL_symbol = 386, /* symbol */
3081 YYSYMBOL_ssym = 387, /* ssym */
3082 YYSYMBOL_sym = 388, /* sym */
3083 YYSYMBOL_dsym = 389, /* dsym */
3084 YYSYMBOL_numeric = 390, /* numeric */
3085 YYSYMBOL_simple_numeric = 391, /* simple_numeric */
3086 YYSYMBOL_nonlocal_var = 392, /* nonlocal_var */
3087 YYSYMBOL_user_variable = 393, /* user_variable */
3088 YYSYMBOL_keyword_variable = 394, /* keyword_variable */
3089 YYSYMBOL_var_ref = 395, /* var_ref */
3090 YYSYMBOL_var_lhs = 396, /* var_lhs */
3091 YYSYMBOL_backref = 397, /* backref */
3092 YYSYMBOL_398_35 = 398, /* $@35 */
3093 YYSYMBOL_superclass = 399, /* superclass */
3094 YYSYMBOL_f_opt_paren_args = 400, /* f_opt_paren_args */
3095 YYSYMBOL_f_paren_args = 401, /* f_paren_args */
3096 YYSYMBOL_f_arglist = 402, /* f_arglist */
3097 YYSYMBOL_403_36 = 403, /* @36 */
3098 YYSYMBOL_f_kwarg_f_kw = 404, /* f_kwarg_f_kw */
3099 YYSYMBOL_args_tail = 405, /* args_tail */
3100 YYSYMBOL_f_opt_arg_value = 406, /* f_opt_arg_value */
3101 YYSYMBOL_f_optarg_arg_value = 407, /* f_optarg_arg_value */
3102 YYSYMBOL_opt_args_tail_args_tail = 408, /* opt_args_tail_args_tail */
3103 YYSYMBOL_f_args = 409, /* f_args */
3104 YYSYMBOL_args_forward = 410, /* args_forward */
3105 YYSYMBOL_f_bad_arg = 411, /* f_bad_arg */
3106 YYSYMBOL_f_norm_arg = 412, /* f_norm_arg */
3107 YYSYMBOL_f_arg_asgn = 413, /* f_arg_asgn */
3108 YYSYMBOL_f_arg_item = 414, /* f_arg_item */
3109 YYSYMBOL_f_arg = 415, /* f_arg */
3110 YYSYMBOL_f_label = 416, /* f_label */
3111 YYSYMBOL_f_kw = 417, /* f_kw */
3112 YYSYMBOL_f_block_kw = 418, /* f_block_kw */
3113 YYSYMBOL_kwrest_mark = 419, /* kwrest_mark */
3114 YYSYMBOL_f_no_kwarg = 420, /* f_no_kwarg */
3115 YYSYMBOL_f_kwrest = 421, /* f_kwrest */
3116 YYSYMBOL_restarg_mark = 422, /* restarg_mark */
3117 YYSYMBOL_f_rest_arg = 423, /* f_rest_arg */
3118 YYSYMBOL_blkarg_mark = 424, /* blkarg_mark */
3119 YYSYMBOL_f_block_arg = 425, /* f_block_arg */
3120 YYSYMBOL_opt_f_block_arg = 426, /* opt_f_block_arg */
3121 YYSYMBOL_singleton = 427, /* singleton */
3122 YYSYMBOL_428_37 = 428, /* $@37 */
3123 YYSYMBOL_assoc_list = 429, /* assoc_list */
3124 YYSYMBOL_assocs = 430, /* assocs */
3125 YYSYMBOL_assoc = 431, /* assoc */
3126 YYSYMBOL_operation = 432, /* operation */
3127 YYSYMBOL_operation2 = 433, /* operation2 */
3128 YYSYMBOL_operation3 = 434, /* operation3 */
3129 YYSYMBOL_dot_or_colon = 435, /* dot_or_colon */
3130 YYSYMBOL_call_op = 436, /* call_op */
3131 YYSYMBOL_call_op2 = 437, /* call_op2 */
3132 YYSYMBOL_rparen = 438, /* rparen */
3133 YYSYMBOL_rbracket = 439, /* rbracket */
3134 YYSYMBOL_rbrace = 440, /* rbrace */
3135 YYSYMBOL_trailer = 441, /* trailer */
3136 YYSYMBOL_term = 442, /* term */
3137 YYSYMBOL_terms = 443, /* terms */
3138 YYSYMBOL_none = 444 /* none */
3140 typedef enum yysymbol_kind_t yysymbol_kind_t;
3149 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
3150 <limits.h> and (if available) <stdint.h> are included
3151 so that the code can choose integer types of a good width. */
3153 #ifndef __PTRDIFF_MAX__
3154 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
3155 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
3156 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
3157 # define YY_STDINT_H
3161 /* Narrow types that promote to a signed type and that can represent a
3162 signed or unsigned integer of at least N bits. In tables they can
3163 save space and decrease cache pressure. Promoting to a signed type
3164 helps avoid bugs in integer arithmetic. */
3166 #ifdef __INT_LEAST8_MAX__
3167 typedef __INT_LEAST8_TYPE__ yytype_int8;
3168 #elif defined YY_STDINT_H
3169 typedef int_least8_t yytype_int8;
3171 typedef signed char yytype_int8;
3174 #ifdef __INT_LEAST16_MAX__
3175 typedef __INT_LEAST16_TYPE__ yytype_int16;
3176 #elif defined YY_STDINT_H
3177 typedef int_least16_t yytype_int16;
3179 typedef short yytype_int16;
3182 /* Work around bug in HP-UX 11.23, which defines these macros
3183 incorrectly for preprocessor constants. This workaround can likely
3184 be removed in 2023, as HPE has promised support for HP-UX 11.23
3185 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
3186 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
3188 # undef UINT_LEAST8_MAX
3189 # undef UINT_LEAST16_MAX
3190 # define UINT_LEAST8_MAX 255
3191 # define UINT_LEAST16_MAX 65535
3194 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
3195 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
3196 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
3197 && UINT_LEAST8_MAX <= INT_MAX)
3198 typedef uint_least8_t yytype_uint8;
3199 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
3200 typedef unsigned char yytype_uint8;
3202 typedef short yytype_uint8;
3205 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
3206 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
3207 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
3208 && UINT_LEAST16_MAX <= INT_MAX)
3209 typedef uint_least16_t yytype_uint16;
3210 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
3211 typedef unsigned short yytype_uint16;
3213 typedef int yytype_uint16;
3217 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
3218 # define YYPTRDIFF_T __PTRDIFF_TYPE__
3219 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
3220 # elif defined PTRDIFF_MAX
3222 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
3224 # define YYPTRDIFF_T ptrdiff_t
3225 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
3227 # define YYPTRDIFF_T long
3228 # define YYPTRDIFF_MAXIMUM LONG_MAX
3233 # ifdef __SIZE_TYPE__
3234 # define YYSIZE_T __SIZE_TYPE__
3235 # elif defined size_t
3236 # define YYSIZE_T size_t
3237 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
3238 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
3239 # define YYSIZE_T size_t
3241 # define YYSIZE_T unsigned
3245 #define YYSIZE_MAXIMUM \
3246 YY_CAST (YYPTRDIFF_T, \
3247 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
3248 ? YYPTRDIFF_MAXIMUM \
3249 : YY_CAST (YYSIZE_T, -1)))
3251 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
3254 /* Stored state numbers (used for stacks). */
3255 typedef yytype_int16 yy_state_t;
3257 /* State numbers in computations. */
3258 typedef int yy_state_fast_t;
3261 # if defined YYENABLE_NLS && YYENABLE_NLS
3263 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
3264 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
3268 # define YY_(Msgid) Msgid
3273 #ifndef YY_ATTRIBUTE_PURE
3274 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
3275 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
3277 # define YY_ATTRIBUTE_PURE
3281 #ifndef YY_ATTRIBUTE_UNUSED
3282 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
3283 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
3285 # define YY_ATTRIBUTE_UNUSED
3289 /* Suppress unused-variable warnings by "using" E. */
3290 #if ! defined lint || defined __GNUC__
3291 # define YY_USE(E) ((void) (E))
3293 # define YY_USE(E) /* empty */
3296 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
3297 #if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
3298 # if __GNUC__ * 100 + __GNUC_MINOR__ < 407
3299 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
3300 _Pragma ("GCC diagnostic push") \
3301 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
3303 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
3304 _Pragma ("GCC diagnostic push") \
3305 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
3306 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
3308 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
3309 _Pragma ("GCC diagnostic pop")
3311 # define YY_INITIAL_VALUE(Value) Value
3313 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3314 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3315 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
3317 #ifndef YY_INITIAL_VALUE
3318 # define YY_INITIAL_VALUE(Value) /* Nothing. */
3321 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
3322 # define YY_IGNORE_USELESS_CAST_BEGIN \
3323 _Pragma ("GCC diagnostic push") \
3324 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
3325 # define YY_IGNORE_USELESS_CAST_END \
3326 _Pragma ("GCC diagnostic pop")
3328 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
3329 # define YY_IGNORE_USELESS_CAST_BEGIN
3330 # define YY_IGNORE_USELESS_CAST_END
3334 #define YY_ASSERT(E) ((void) (0 && (E)))
3338 /* The parser invokes alloca or malloc; define the necessary symbols. */
3340 # ifdef YYSTACK_USE_ALLOCA
3341 # if YYSTACK_USE_ALLOCA
3343 # define YYSTACK_ALLOC __builtin_alloca
3344 # elif defined __BUILTIN_VA_ARG_INCR
3345 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
3347 # define YYSTACK_ALLOC __alloca
3348 # elif defined _MSC_VER
3349 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
3350 # define alloca _alloca
3352 # define YYSTACK_ALLOC alloca
3353 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
3354 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
3355 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
3356 # ifndef EXIT_SUCCESS
3357 # define EXIT_SUCCESS 0
3364 # ifdef YYSTACK_ALLOC
3365 /* Pacify GCC's
'empty if-body' warning. */
3366 # define YYSTACK_FREE(Ptr) do { ; } while (0)
3367 # ifndef YYSTACK_ALLOC_MAXIMUM
3372 # define YYSTACK_ALLOC_MAXIMUM 4032
3375 # define YYSTACK_ALLOC YYMALLOC
3376 # define YYSTACK_FREE YYFREE
3377 # ifndef YYSTACK_ALLOC_MAXIMUM
3378 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
3380 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
3381 && ! ((defined YYMALLOC || defined malloc) \
3382 && (defined YYFREE || defined free)))
3383 # include <stdlib.h>
3384 # ifndef EXIT_SUCCESS
3385 # define EXIT_SUCCESS 0
3389 # define YYMALLOC malloc
3390 # if ! defined malloc && ! defined EXIT_SUCCESS
3391 void *malloc (YYSIZE_T);
3395 # define YYFREE free
3396 # if ! defined free && ! defined EXIT_SUCCESS
3403 #if (! defined yyoverflow \
3404 && (! defined __cplusplus \
3405 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
3406 && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
3411 yy_state_t yyss_alloc;
3417 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
3421 # define YYSTACK_BYTES(N) \
3422 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
3423 + YYSIZEOF (YYLTYPE)) \
3424 + 2 * YYSTACK_GAP_MAXIMUM)
3426 # define YYCOPY_NEEDED 1
3433 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
3436 YYPTRDIFF_T yynewbytes; \
3437 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
3438 Stack = &yyptr->Stack_alloc; \
3439 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
3440 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
3446 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
3450 # if defined __GNUC__ && 1 < __GNUC__
3451 # define YYCOPY(Dst, Src, Count) \
3452 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
3454 # define YYCOPY(Dst, Src, Count) \
3458 for (yyi = 0; yyi < (Count); yyi++) \
3459 (Dst)[yyi] = (Src)[yyi]; \
3469 #define YYLAST 15506
3472 #define YYNTOKENS 163
3476 #define YYNRULES 788
3478 #define YYNSTATES 1349
3481 #define YYMAXUTOK 362
3486 #define YYTRANSLATE(YYX) \
3487 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
3488 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
3493 static const yytype_uint8 yytranslate[] =
3495 0, 2, 2, 2, 2, 2, 2, 2, 2, 72,
3496 155, 75, 73, 74, 2, 2, 2, 2, 2, 2,
3497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3498 2, 2, 162, 149, 2, 2, 2, 147, 142, 2,
3499 158, 159, 145, 143, 156, 144, 69, 146, 2, 2,
3500 2, 2, 2, 2, 2, 2, 2, 2, 137, 161,
3501 139, 135, 138, 136, 2, 2, 2, 2, 2, 2,
3502 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3503 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3504 2, 154, 70, 160, 141, 2, 157, 2, 2, 2,
3505 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3506 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3507 2, 2, 2, 152, 140, 153, 150, 2, 89, 90,
3508 91, 92, 76, 77, 78, 79, 95, 96, 84, 83,
3509 80, 81, 82, 87, 88, 93, 94, 98, 85, 86,
3510 97, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3511 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3512 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3513 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3514 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3515 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3516 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3517 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3518 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3519 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3520 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
3521 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3522 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3523 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
3524 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
3525 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3526 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
3527 65, 66, 67, 68, 71, 99, 100, 101, 102, 103,
3528 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
3529 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
3530 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
3536 static const yytype_int16 yyrline[] =
3538 0, 2971, 2971, 2971, 2997, 2997, 2997, 3003, 3008, 3013,
3539 3020, 3025, 3032, 3034, 3048, 3053, 3044, 3064, 3061, 3074,
3540 3080, 3085, 3090, 3097, 3102, 3101, 3111, 3113, 3120, 3120,
3541 3125, 3130, 3138, 3147, 3154, 3160, 3166, 3177, 3188, 3197,
3542 3210, 3211, 3217, 3222, 3233, 3238, 3239, 3246, 3251, 3256,
3543 3262, 3262, 3267, 3273, 3278, 3289, 3300, 3308, 3309, 3315,
3544 3315, 3315, 3322, 3327, 3335, 3338, 3339, 3344, 3349, 3354,
3545 3360, 3359, 3373, 3372, 3385, 3388, 3400, 3410, 3409, 3423,
3546 3428, 3434, 3434, 3434, 3441, 3442, 3445, 3446, 3453, 3461,
3547 3468, 3475, 3484, 3489, 3494, 3499, 3504, 3510, 3516, 3522,
3548 3527, 3534, 3543, 3544, 3551, 3552, 3559, 3564, 3569, 3574,
3549 3579, 3584, 3589, 3594, 3599, 3604, 3611, 3612, 3619, 3624,
3550 3631, 3636, 3643, 3643, 3648, 3653, 3659, 3664, 3670, 3675,
3551 3680, 3688, 3688, 3693, 3698, 3703, 3708, 3713, 3718, 3723,
3552 3731, 3739, 3742, 3747, 3752, 3759, 3759, 3760, 3761, 3766,
3553 3769, 3774, 3777, 3782, 3782, 3790, 3791, 3792, 3793, 3794,
3554 3795, 3796, 3797, 3798, 3799, 3800, 3801, 3802, 3803, 3804,
3555 3805, 3806, 3807, 3808, 3809, 3810, 3811, 3812, 3813, 3814,
3556 3815, 3816, 3817, 3818, 3819, 3822, 3822, 3822, 3823, 3823,
3557 3824, 3824, 3824, 3825, 3825, 3825, 3825, 3826, 3826, 3826,
3558 3826, 3827, 3827, 3827, 3828, 3828, 3828, 3828, 3829, 3829,
3559 3829, 3829, 3830, 3830, 3830, 3830, 3831, 3831, 3831, 3831,
3560 3832, 3832, 3832, 3832, 3833, 3833, 3836, 3841, 3846, 3851,
3561 3856, 3861, 3866, 3872, 3878, 3884, 3891, 3898, 3904, 3910,
3562 3916, 3922, 3927, 3932, 3937, 3942, 3947, 3952, 3957, 3962,
3563 3967, 3972, 3977, 3982, 3987, 3988, 3993, 3998, 4003, 4008,
3564 4013, 4018, 4023, 4028, 4033, 4038, 4043, 4049, 4056, 4067,
3565 4078, 4084, 4085, 4091, 4098, 4099, 4100, 4101, 4104, 4109,
3566 4117, 4123, 4130, 4137, 4144, 4145, 4149, 4154, 4161, 4166,
3567 4175, 4180, 4190, 4202, 4203, 4209, 4210, 4211, 4215, 4220,
3568 4227, 4233, 4238, 4244, 4250, 4254, 4254, 4292, 4297, 4305,
3569 4310, 4318, 4323, 4328, 4333, 4341, 4346, 4355, 4356, 4360,
3570 4365, 4370, 4388, 4388, 4388, 4388, 4388, 4388, 4388, 4388,
3571 4389, 4390, 4391, 4397, 4396, 4409, 4409, 4415, 4421, 4426,
3572 4431, 4436, 4442, 4447, 4452, 4457, 4462, 4468, 4473, 4478,
3573 4483, 4484, 4490, 4491, 4500, 4509, 4518, 4528, 4527, 4542,
3574 4541, 4554, 4561, 4604, 4603, 4621, 4620, 4640, 4639, 4658,
3575 4656, 4673, 4671, 4686, 4691, 4696, 4701, 4716, 4723, 4730,
3576 4748, 4755, 4763, 4771, 4778, 4786, 4795, 4804, 4812, 4819,
3577 4826, 4834, 4841, 4847, 4862, 4869, 4874, 4880, 4887, 4894,
3578 4895, 4896, 4899, 4900, 4903, 4904, 4914, 4915, 4922, 4923,
3579 4926, 4931, 4938, 4943, 4950, 4955, 4960, 4965, 4970, 4977,
3580 4983, 4990, 4991, 4998, 4998, 5000, 5000, 5000, 5005, 5010,
3581 5015, 5022, 5030, 5030, 5030, 5030, 5030, 5030, 5035, 5040,
3582 5045, 5050, 5055, 5061, 5066, 5071, 5076, 5081, 5086, 5091,
3583 5096, 5101, 5108, 5109, 5115, 5122, 5132, 5137, 5144, 5146,
3584 5150, 5155, 5161, 5167, 5172, 5179, 5185, 5178, 5211, 5218,
3585 5227, 5234, 5233, 5244, 5252, 5264, 5274, 5283, 5290, 5297,
3586 5308, 5314, 5319, 5325, 5331, 5336, 5341, 5349, 5355, 5363,
3587 5363, 5380, 5380, 5401, 5407, 5412, 5418, 5425, 5435, 5436,
3588 5439, 5440, 5442, 5453, 5450, 5466, 5467, 5470, 5471, 5477,
3589 5485, 5486, 5492, 5498, 5503, 5508, 5515, 5518, 5525, 5528,
3590 5533, 5536, 5543, 5550, 5551, 5552, 5559, 5566, 5573, 5579,
3591 5586, 5593, 5600, 5606, 5611, 5616, 5623, 5622, 5633, 5639,
3592 5647, 5653, 5658, 5663, 5668, 5673, 5676, 5680, 5687, 5692,
3593 5699, 5707, 5713, 5720, 5721, 5728, 5735, 5740, 5745, 5750,
3594 5757, 5759, 5766, 5772, 5784, 5785, 5800, 5805, 5812, 5818,
3595 5819, 5826, 5827, 5834, 5841, 5847, 5853, 5854, 5855, 5856,
3596 5862, 5870, 5870, 5870, 5870, 5870, 5870, 5870, 5870, 5871,
3597 5876, 5879, 5887, 5899, 5906, 5913, 5918, 5923, 5930, 5951,
3598 5954, 5959, 5963, 5966, 5971, 5974, 5981, 5984, 5985, 5988,
3599 6002, 6003, 6004, 6011, 6024, 6036, 6043, 6043, 6043, 6043,
3600 6047, 6051, 6058, 6060, 6067, 6067, 6071, 6075, 6082, 6082,
3601 6085, 6085, 6089, 6093, 6101, 6105, 6113, 6117, 6125, 6129,
3602 6137, 6141, 6167, 6170, 6169, 6184, 6192, 6196, 6183, 6215,
3603 6216, 6219, 6224, 6227, 6228, 6231, 6247, 6248, 6251, 6259,
3604 6260, 6268, 6269, 6270, 6271, 6274, 6275, 6276, 6279, 6279,
3605 6280, 6283, 6284, 6285, 6286, 6287, 6288, 6289, 6292, 6302,
3606 6309, 6309, 6316, 6317, 6321, 6320, 6331, 6337, 6338, 6347,
3607 6357, 6358, 6358, 6375, 6375, 6375, 6380, 6385, 6390, 6395,
3608 6412, 6412, 6412, 6412, 6412, 6412, 6417, 6422, 6427, 6432,
3609 6437, 6442, 6447, 6452, 6457, 6462, 6467, 6472, 6477, 6483,
3610 6490, 6501, 6510, 6519, 6528, 6539, 6540, 6550, 6558, 6563,
3611 6582, 6584, 6595, 6615, 6621, 6629, 6635, 6643, 6644, 6647,
3612 6653, 6659, 6667, 6668, 6671, 6677, 6685, 6686, 6689, 6695,
3613 6703, 6708, 6715, 6721, 6720, 6758, 6759, 6766, 6768, 6793,
3614 6798, 6803, 6810, 6816, 6821, 6830, 6830, 6831, 6834, 6835,
3615 6838, 6839, 6840, 6843, 6844, 6847, 6848, 6851, 6852, 6855,
3616 6858, 6861, 6864, 6865, 6868, 6869, 6876, 6877, 6881
3621 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
3626 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
3630 static const char *
const yytname[] =
3632 "\"end-of-input\"",
"error",
"\"invalid token\"",
"\"'class'\"",
3633 "\"'module'\"",
"\"'def'\"",
"\"'undef'\"",
"\"'begin'\"",
3634 "\"'rescue'\"",
"\"'ensure'\"",
"\"'end'\"",
"\"'if'\"",
"\"'unless'\"",
3635 "\"'then'\"",
"\"'elsif'\"",
"\"'else'\"",
"\"'case'\"",
"\"'when'\"",
3636 "\"'while'\"",
"\"'until'\"",
"\"'for'\"",
"\"'break'\"",
"\"'next'\"",
3637 "\"'redo'\"",
"\"'retry'\"",
"\"'in'\"",
"\"'do'\"",
3638 "\"'do' for condition\"",
"\"'do' for block\"",
"\"'do' for lambda\"",
3639 "\"'return'\"",
"\"'yield'\"",
"\"'super'\"",
"\"'self'\"",
"\"'nil'\"",
3640 "\"'true'\"",
"\"'false'\"",
"\"'and'\"",
"\"'or'\"",
"\"'not'\"",
3641 "\"'if' modifier\"",
"\"'unless' modifier\"",
"\"'while' modifier\"",
3642 "\"'until' modifier\"",
"\"'rescue' modifier\"",
"\"'alias'\"",
3643 "\"'defined?'\"",
"\"'BEGIN'\"",
"\"'END'\"",
"\"'__LINE__'\"",
3644 "\"'__FILE__'\"",
"\"'__ENCODING__'\"",
"\"local variable or method\"",
3645 "\"method\"",
"\"global variable\"",
"\"instance variable\"",
3646 "\"constant\"",
"\"class variable\"",
"\"label\"",
"\"integer literal\"",
3647 "\"float literal\"",
"\"rational literal\"",
"\"imaginary literal\"",
3648 "\"char literal\"",
"\"numbered reference\"",
"\"back reference\"",
3649 "\"literal content\"",
"tREGEXP_END",
"\"dummy end\"",
"'.'",
3650 "\"backslash\"",
"\"escaped space\"",
"\"escaped horizontal tab\"",
3651 "\"escaped form feed\"",
"\"escaped carriage return\"",
3652 "\"escaped vertical tab\"",
"\"unary+\"",
"\"unary-\"",
"\"**\"",
3653 "\"<=>\"",
"\"==\"",
"\"===\"",
"\"!=\"",
"\">=\"",
"\"<=\"",
"\"&&\"",
3654 "\"||\"",
"\"=~\"",
"\"!~\"",
"\"..\"",
"\"...\"",
"\"(..\"",
"\"(...\"",
3655 "\"[]\"",
"\"[]=\"",
"\"<<\"",
"\">>\"",
"\"&.\"",
"\"::\"",
3656 "\":: at EXPR_BEG\"",
"\"operator-assignment\"",
"\"=>\"",
"\"(\"",
3657 "\"( arg\"",
"\")\"",
"\"[\"",
"\"{\"",
"\"{ arg\"",
"\"*\"",
3658 "\"**arg\"",
"\"&\"",
"\"->\"",
"\"symbol literal\"",
3659 "\"string literal\"",
"\"backtick literal\"",
"\"regexp literal\"",
3660 "\"word list\"",
"\"verbatim word list\"",
"\"symbol list\"",
3661 "\"verbatim symbol list\"",
"\"terminator\"",
"\"'}'\"",
"\"'#{'\"",
3662 "tSTRING_DVAR",
"tLAMBEG",
"tLABEL_END",
"tIGNORED_NL",
"tCOMMENT",
3663 "tEMBDOC_BEG",
"tEMBDOC",
"tEMBDOC_END",
"tHEREDOC_BEG",
"tHEREDOC_END",
3664 "k__END__",
"tLOWEST",
"'='",
"'?'",
"':'",
"'>'",
"'<'",
"'|'",
"'^'",
3665 "'&'",
"'+'",
"'-'",
"'*'",
"'/'",
"'%'",
"tUMINUS_NUM",
"'!'",
"'~'",
3666 "tLAST_TOKEN",
"'{'",
"'}'",
"'['",
"'\\n'",
"','",
"'`'",
"'('",
"')'",
3667 "']'",
"';'",
"' '",
"$accept",
"$@1",
"program",
"option_terms",
3668 "top_compstmt",
"top_stmts",
"top_stmt",
"block_open",
"begin_block",
3669 "$@2",
"$@3",
"bodystmt",
"$@4",
"compstmt",
"stmts",
"stmt_or_begin",
3670 "$@5",
"allow_exits",
"k_END",
"$@6",
"stmt",
"command_asgn",
3671 "endless_command",
"option_'\\n'",
"command_rhs",
"expr",
"$@7",
"$@8",
3672 "def_name",
"defn_head",
"$@9",
"defs_head",
"expr_value",
"$@10",
3673 "$@11",
"expr_value_do",
"command_call",
"block_command",
3674 "cmd_brace_block",
"fcall",
"command",
"mlhs",
"mlhs_inner",
3675 "mlhs_basic",
"mlhs_item",
"mlhs_head",
"mlhs_post",
"mlhs_node",
"lhs",
3676 "cname",
"cpath",
"fname",
"fitem",
"undef_list",
"$@12",
"op",
3677 "reswords",
"arg",
"endless_arg",
"relop",
"rel_expr",
"lex_ctxt",
3678 "begin_defined",
"after_rescue",
"arg_value",
"aref_args",
"arg_rhs",
3679 "paren_args",
"opt_paren_args",
"opt_call_args",
"call_args",
"$@13",
3680 "command_args",
"block_arg",
"opt_block_arg",
"args",
"arg_splat",
3681 "mrhs_arg",
"mrhs",
"primary",
"$@14",
"$@15",
"@16",
"@17",
"$@18",
3682 "$@19",
"$@20",
"$@21",
"$@22",
"primary_value",
"k_begin",
"k_if",
3683 "k_unless",
"k_while",
"k_until",
"k_case",
"k_for",
"k_class",
3684 "k_module",
"k_def",
"k_do",
"k_do_block",
"k_rescue",
"k_ensure",
3685 "k_when",
"k_else",
"k_elsif",
"k_end",
"k_return",
"k_yield",
"then",
3686 "do",
"if_tail",
"opt_else",
"for_var",
"f_marg",
"f_marg_list",
3687 "f_margs",
"f_rest_marg",
"f_any_kwrest",
"$@23",
"f_eq",
3688 "f_kwarg_f_block_kw",
"block_args_tail",
"excessed_comma",
3689 "f_opt_primary_value",
"f_optarg_primary_value",
3690 "opt_args_tail_block_args_tail",
"block_param",
"opt_block_param",
3691 "block_param_def",
"opt_bv_decl",
"bv_decls",
"bvar",
"max_numparam",
3692 "numparam",
"it_id",
"@24",
"$@25",
"lambda",
"f_larglist",
3693 "lambda_body",
"$@26",
"do_block",
"block_call",
"method_call",
3694 "brace_block",
"@27",
"brace_body",
"@28",
"do_body",
"case_args",
3695 "case_body",
"cases",
"p_pvtbl",
"p_pktbl",
"p_in_kwarg",
"$@29",
3696 "p_case_body",
"p_cases",
"p_top_expr",
"p_top_expr_body",
"p_expr",
3697 "p_as",
"p_alt",
"p_lparen",
"p_lbracket",
"p_expr_basic",
"$@30",
3698 "p_args",
"p_args_head",
"p_args_tail",
"p_find",
"p_rest",
3699 "p_args_post",
"p_arg",
"p_kwargs",
"p_kwarg",
"p_kw",
"p_kw_label",
3700 "p_kwrest",
"p_kwnorest",
"p_any_kwrest",
"p_value",
"p_primitive",
3701 "p_variable",
"p_var_ref",
"p_expr_ref",
"p_const",
"opt_rescue",
3702 "exc_list",
"exc_var",
"opt_ensure",
"literal",
"strings",
"string",
3703 "string1",
"xstring",
"regexp",
"nonempty_list_' '",
3704 "words_tWORDS_BEG_word_list",
"words",
"word_list",
"word",
3705 "words_tSYMBOLS_BEG_symbol_list",
"symbols",
"symbol_list",
3706 "words_tQWORDS_BEG_qword_list",
"qwords",
3707 "words_tQSYMBOLS_BEG_qsym_list",
"qsymbols",
"qword_list",
"qsym_list",
3708 "string_contents",
"xstring_contents",
"regexp_contents",
3709 "string_content",
"@31",
"@32",
"@33",
"@34",
"string_dend",
3710 "string_dvar",
"symbol",
"ssym",
"sym",
"dsym",
"numeric",
3711 "simple_numeric",
"nonlocal_var",
"user_variable",
"keyword_variable",
3712 "var_ref",
"var_lhs",
"backref",
"$@35",
"superclass",
3713 "f_opt_paren_args",
"f_paren_args",
"f_arglist",
"@36",
"f_kwarg_f_kw",
3714 "args_tail",
"f_opt_arg_value",
"f_optarg_arg_value",
3715 "opt_args_tail_args_tail",
"f_args",
"args_forward",
"f_bad_arg",
3716 "f_norm_arg",
"f_arg_asgn",
"f_arg_item",
"f_arg",
"f_label",
"f_kw",
3717 "f_block_kw",
"kwrest_mark",
"f_no_kwarg",
"f_kwrest",
"restarg_mark",
3718 "f_rest_arg",
"blkarg_mark",
"f_block_arg",
"opt_f_block_arg",
3719 "singleton",
"$@37",
"assoc_list",
"assocs",
"assoc",
"operation",
3720 "operation2",
"operation3",
"dot_or_colon",
"call_op",
"call_op2",
3721 "rparen",
"rbracket",
"rbrace",
"trailer",
"term",
"terms",
"none", YY_NULLPTR
3725 yysymbol_name (yysymbol_kind_t yysymbol)
3727 return yytname[yysymbol];
3731 #define YYPACT_NINF (-1105)
3733 #define yypact_value_is_default(Yyn) \
3734 ((Yyn) == YYPACT_NINF)
3736 #define YYTABLE_NINF (-789)
3738 #define yytable_value_is_error(Yyn) \
3739 ((Yyn) == YYTABLE_NINF)
3743 static const yytype_int16 yypact[] =
3745 -1105, 5137, 116, -1105, -1105, -1105, -1105, 9782, -1105, -1105,
3746 -1105, -1105, -1105, -1105, -1105, 10845, 10845, -1105, -1105, -1105,
3747 -1105, 6047, -1105, -1105, -1105, -1105, 577, 9627, 14, 2,
3748 -1105, -1105, -1105, -1105, 4430, 6204, -1105, -1105, 5576, -1105,
3749 -1105, -1105, -1105, -1105, -1105, -1105, -1105, 12297, 12297, 12297,
3750 12297, 176, 8533, 8692, 11329, 11571, 10085, -1105, 9472, -1105,
3751 -1105, -1105, 117, 117, 117, 117, 1370, 12418, 12297, -1105,
3752 646, -1105, -1105, 1384, -1105, 776, 314, 314, -1105, -1105,
3753 260, 148, 160, -1105, 186, 12902, -1105, 268, 2773, 925,
3754 370, 385, -1105, 10724, 10724, -1105, -1105, 9157, 13021, 13140,
3755 13259, 9316, 10845, 6675, -1105, 683, 78, -1105, -1105, 366,
3756 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
3757 -1105, -1105, -1105, -1105, -1105, -1105, -1105, 320, 420, -1105,
3758 308, 427, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
3759 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
3760 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
3761 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
3762 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
3763 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
3764 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
3765 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
3766 -1105, 333, -1105, -1105, -1105, -1105, -1105, -1105, 336, 12297,
3767 448, 8692, 12297, 12297, 12297, -1105, 12297, 314, 314, -1105,
3768 393, 5546, 480, -1105, -1105, 435, -1105, 432, 52, 53,
3769 500, 70, 465, -1105, -1105, 10966, -1105, 10845, -1105, -1105,
3770 10463, 12539, 614, -1105, 474, -1105, 8851, -1105, -1105, -1105,
3771 -1105, -1105, 519, 260, -1105, 546, -1105, 572, 621, 5703,
3772 5703, 611, -1105, 8533, 561, 646, -1105, 1384, 14, 602,
3773 -1105, -1105, 590, 720, 819, -1105, 480, 616, 819, -1105,
3774 14, 704, 1370, 13378, 613, 613, 627, -1105, 658, 731,
3775 741, 746, -1105, -1105, 818, -1105, -1105, 972, 1002, 547,
3776 -1105, 630, 630, 630, 630, 716, -1105, -1105, -1105, -1105,
3777 -1105, -1105, -1105, 5290, 672, 10724, 10724, 10724, 10724, -1105,
3778 12539, 12539, 2275, 691, 710, -1105, 2275, -1105, 752, -1105,
3779 -1105, -1105, -1105, 747, -1105, -1105, -1105, -1105, -1105, -1105,
3780 -1105, 8533, 10204, 743, -1105, -1105, 12297, 12297, 12297, 12297,
3781 12297, -1105, -1105, 12297, 12297, 12297, 12297, 12297, 12297, 12297,
3782 12297, -1105, 12297, -1105, -1105, 12297, 12297, 12297, 12297, 12297,
3783 12297, 12297, 12297, 12297, 12297, -1105, -1105, 4541, 10845, 13864,
3784 7462, -1105, 776, 88, 88, 10724, 8380, 8380, -1105, 646,
3785 733, 854, -1105, -1105, 749, 883, 81, 135, 140, 879,
3786 887, 10724, 634, -1105, 778, 793, -1105, -1105, -1105, -1105,
3787 59, 92, 526, 584, 624, 649, 719, 724, 742, -1105,
3788 -1105, -1105, -1105, 788, -1105, 10323, -1105, -1105, -1105, 15349,
3789 -1105, -1105, -1105, -1105, -1105, -1105, 410, -1105, -1105, -1105,
3790 730, 804, 807, -1105, 12297, 11087, -1105, -1105, 13963, 10845,
3791 14062, -1105, -1105, 11450, -1105, 12297, 14, -1105, 789, 14,
3792 797, -1105, -1105, 799, 177, -1105, -1105, -1105, -1105, -1105,
3793 9782, -1105, -1105, 12297, 815, 14161, 14062, -1105, 2, 14,
3794 -1105, -1105, 4702, 834, 841, -1105, 11329, -1105, -1105, 11571,
3795 -1105, -1105, -1105, 474, 809, -1105, -1105, 869, -1105, 13378,
3796 14260, 10845, 14359, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
3797 -1105, -1105, -1105, -1105, -1105, 1050, 297, 1081, 326, 12297,
3798 -1105, -1105, 9004, -1105, -1105, -1105, -1105, -1105, 10603, -1105,
3799 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, 1300,
3800 -1105, -1105, -1105, -1105, -1105, 876, -1105, 880, -1105, -1105,
3801 886, 14, -1105, -1105, -1105, 913, -1105, 900, 12297, -1105,
3802 115, -1105, -1105, 1007, 904, 1010, -1105, 12660, 7462, 646,
3803 12660, 7462, -1105, 914, -1105, -1105, -1105, 134, 134, 11692,
3804 14, 13378, 916, -1105, 11692, -1105, 621, 4975, 4975, 4975,
3805 4975, 5128, 4761, 4975, 4975, 5703, 5703, 529, 529, -1105,
3806 5389, 1270, 1270, 1294, 406, 406, 621, 621, 621, 1457,
3807 1457, 6832, 5733, 7146, 5890, -1105, -1105, 519, -1105, 14,
3808 920, 643, -1105, 685, -1105, -1105, 6361, 134, -1105, -1105,
3809 7615, 1056, 8074, 170, 134, 134, 1062, 1057, 164, 14458,
3810 10845, 14557, -1105, -1105, -1105, 809, -1105, -1105, -1105, 14656,
3811 10845, 14755, 7462, 12539, -1105, -1105, -1105, 14, -1105, -1105,
3812 -1105, 3926, 12418, 12418, 9782, 12297, 12781, 12781, 12297, -1105,
3813 480, -1105, -1105, 465, 5419, 6518, 14, 413, 422, 12297,
3814 12297, -1105, -1105, 11208, -1105, 11450, -1105, -1105, -1105, 12539,
3815 5546, -1105, 50, 519, 519, 12297, -1105, 259, -1105, -1105,
3816 819, 13378, 869, 305, 344, 14, 391, 423, -1105, -1105,
3817 1151, -1105, 315, -1105, 117, -1105, -1105, 315, 117, -1105,
3818 621, 931, -1105, 1300, 1251, -1105, 929, 14, 930, -1105,
3819 291, -1105, -1105, 68, -1105, 2275, -1105, -1105, 955, 12297,
3820 2275, -1105, -1105, -1105, -1105, -1105, 1777, -1105, -1105, 577,
3821 1047, -1105, 5546, 1053, 134, -1105, 1047, 1053, 134, -1105,
3822 -1105, 946, -1105, -1105, -1105, -1105, -1105, 12297, -1105, 950,
3823 951, 1071, -1105, -1105, 869, 13378, -1105, -1105, 1076, 991,
3824 4088, -1105, -1105, -1105, 852, 461, -1105, -1105, 994, -1105,
3825 -1105, -1105, -1105, 747, 968, 878, 11087, -1105, -1105, -1105,
3826 -1105, 747, -1105, -1105, 1124, 965, -1105, 1122, -1105, -1105,
3827 -1105, -1105, -1105, -1105, 11813, 134, -1105, 1062, 134, 349,
3828 359, 14, 171, 178, 8380, 646, 10724, 7462, 1242, 344,
3829 -1105, 14, 134, 177, 9937, -1105, 78, 148, -1105, 4172,
3830 -1105, -1105, -1105, -1105, -1105, 577, -1105, -1105, -1105, 527,
3831 -1105, -1105, 14, 983, 177, -1105, -1105, -1105, 467, -1105,
3832 -1105, -1105, -1105, -1105, 630, -1105, 630, 630, 630, -1105,
3833 14, -1105, 1300, -1105, 1261, -1105, -1105, 1090, 876, -1105,
3834 -1105, 987, 988, -1105, -1105, 992, -1105, 993, -1105, 987,
3835 12660, -1105, -1105, -1105, -1105, -1105, -1105, -1105, 999, 11934,
3836 -1105, 869, -1105, -1105, -1105, 14854, 10845, 14953, -1105, -1105,
3837 12297, 12418, 12418, 997, -1105, -1105, -1105, 12418, 12418, -1105,
3838 -1105, 12055, 1122, -1105, -1105, -1105, 8380, 10724, 134, -1105,
3839 -1105, 134, -1105, 12297, -1105, 98, -1105, -1105, 134, -1105,
3840 191, 134, 7462, 646, 134, -1105, -1105, -1105, -1105, -1105,
3841 -1105, 12781, 12297, 12297, -1105, 12297, 12297, -1105, 11450, -1105,
3842 1672, 4984, -1105, -1105, 1018, 1021, -1105, 1777, -1105, 1777,
3843 -1105, 2275, -1105, 1777, -1105, -1105, 1047, 1053, 12297, 12297,
3844 -1105, -1105, 12297, 1029, 10603, 10603, 12418, 12297, 6989, 7303,
3845 14, 549, 589, 13690, 13690, 5546, -1105, -1105, -1105, -1105,
3846 -1105, 12418, -1105, -1105, -1105, -1105, 950, -1105, 1065, -1105,
3847 1178, -1105, -1105, 88, -1105, -1105, -1105, 12176, 7768, -1105,
3848 -1105, -1105, 134, -1105, -1105, 12297, 2275, -1105, -1105, 137,
3849 1261, 1261, 987, 987, 1035, 987, 5546, 5546, 1059, 1059,
3850 999, -1105, -1105, 5546, 607, -1105, -1105, -1105, 3518, 3518,
3851 779, -1105, 4010, 272, 1150, -1105, 1225, -1105, -1105, 35,
3852 -1105, 1067, -1105, -1105, -1105, 1054, -1105, 1058, -1105, 13876,
3853 -1105, -1105, -1105, -1105, 908, -1105, -1105, -1105, 41, -1105,
3854 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, 469, -1105,
3855 -1105, -1105, 13497, 88, -1105, -1105, 8380, -1105, -1105, 8227,
3856 7615, 12297, -1105, 494, 13690, -1105, 14, 89, -1105, -1105,
3857 -1105, 1021, -1105, -1105, 1777, -1105, -1105, 1993, 9004, -1105,
3858 -1105, 7462, -1105, -1105, -1105, -1105, 13876, 251, 14, 13783,
3859 -1105, 14, 1064, -1105, 1068, -1105, -1105, -1105, 738, -1105,
3860 10724, -1105, 1157, 13783, 13876, 13876, 696, 1111, 3518, 3518,
3861 779, -13, 712, 13690, 13690, -1105, 1166, -1105, 875, 106,
3862 120, 188, 7462, 646, -1105, 965, -1105, -1105, -1105, -1105,
3863 88, 979, 1063, 1066, -1105, 9004, -1105, 987, 876, 1072,
3864 -1105, -1105, 1073, 14, 1093, 913, 1079, 13616, -1105, 1082,
3865 -1105, -1105, -1105, 74, -1105, 1111, 1083, 1085, -1105, -1105,
3866 -1105, -1105, -1105, 14, -1105, -1105, 1086, -1105, 1089, -1105,
3867 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
3868 14, 14, 14, 14, 14, 14, 209, 15052, 10845, 15151,
3869 1124, -1105, 1178, -1105, -1105, 10724, 10724, 1290, -1105, 7462,
3870 1101, -1105, -1105, 68, -1105, 1854, -1105, 1116, -1105, 13616,
3871 1854, -1105, -1105, 1204, 890, 1697, -1105, -1105, 13876, -1105,
3872 696, -1105, 13876, 13783, 832, -1105, -1105, -1105, -1105, -1105,
3873 -1105, 227, 232, 14, 243, 244, -1105, -1105, 7921, -1105,
3874 -1105, -1105, 895, -1105, -1105, 134, -1105, -1105, 876, -1105,
3875 -1105, 1105, 1114, -1105, 890, 1119, 1120, -1105, 15250, 1105,
3876 1129, 14, 1129, -1105, -1105, 267, 409, 1290, -1105, -1105,
3877 -1105, 1697, -1105, 1697, -1105, 1854, -1105, 1697, -1105, 1130,
3878 1132, -1105, 13876, -1105, -1105, -1105, -1105, -1105, 1105, 1105,
3879 1135, 1105, -1105, -1105, 1697, -1105, -1105, 1105, -1105
3885 static const yytype_int16 yydefact[] =
3887 2, 0, 0, 46, 385, 386, 387, 0, 378, 379,
3888 380, 383, 26, 26, 26, 373, 374, 375, 376, 397,
3889 398, 305, 672, 671, 673, 674, 59, 0, 59, 0,
3890 788, 676, 675, 677, 765, 767, 666, 665, 766, 667,
3891 661, 662, 663, 664, 610, 682, 683, 0, 0, 0,
3892 0, 0, 0, 0, 788, 788, 114, 465, 636, 636,
3893 638, 640, 0, 0, 0, 0, 0, 0, 0, 3,
3894 4, 8, 26, 10, 40, 45, 691, 691, 65, 85,
3895 305, 84, 0, 102, 0, 106, 116, 0, 74, 254,
3896 270, 0, 333, 0, 0, 81, 81, 0, 0, 0,
3897 0, 0, 342, 305, 352, 86, 350, 322, 323, 609,
3898 611, 324, 325, 619, 326, 625, 328, 629, 327, 631,
3899 329, 608, 653, 654, 607, 659, 670, 678, 679, 330,
3900 0, 331, 89, 7, 1, 195, 206, 196, 219, 192,
3901 212, 202, 201, 222, 223, 217, 200, 199, 194, 220,
3902 224, 225, 204, 193, 207, 211, 213, 205, 198, 214,
3903 221, 216, 215, 208, 218, 203, 191, 210, 209, 190,
3904 197, 188, 189, 185, 186, 187, 145, 147, 146, 180,
3905 181, 176, 158, 159, 160, 167, 164, 166, 161, 162,
3906 182, 183, 168, 169, 173, 177, 163, 165, 155, 156,
3907 157, 170, 171, 172, 174, 175, 178, 179, 184, 150,
3908 152, 33, 148, 149, 151, 381, 382, 384, 0, 761,
3909 0, 0, 316, 764, 308, 636, 0, 691, 691, 300,
3910 0, 283, 311, 100, 304, 788, 312, 0, 678, 679,
3911 0, 331, 788, 757, 101, 788, 484, 0, 97, 60,
3912 59, 0, 0, 28, 788, 12, 0, 11, 27, 280,
3913 373, 374, 485, 0, 248, 0, 342, 345, 249, 239,
3914 240, 339, 24, 0, 0, 4, 21, 23, 59, 104,
3915 20, 335, 0, 59, 59, 284, 0, 0, 59, 755,
3916 59, 0, 0, 0, 691, 691, 112, 377, 0, 122,
3917 123, 130, 462, 656, 0, 655, 657, 0, 0, 0,
3918 616, 620, 632, 626, 634, 660, 69, 260, 261, 785,
3919 784, 6, 786, 0, 0, 0, 0, 0, 0, 788,
3920 0, 0, 719, 0, 690, 369, 719, 688, 0, 371,
3921 388, 489, 478, 90, 491, 349, 389, 491, 474, 788,
3922 118, 0, 110, 107, 788, 72, 0, 0, 0, 0,
3923 0, 276, 277, 0, 0, 0, 0, 237, 238, 0,
3924 0, 70, 0, 274, 275, 0, 0, 0, 0, 0,
3925 0, 0, 0, 0, 0, 775, 776, 0, 788, 0,
3926 0, 80, 79, 0, 0, 0, 0, 0, 359, 4,
3927 5, 0, 409, 408, 0, 0, 678, 679, 331, 140,
3928 141, 0, 0, 143, 686, 0, 678, 679, 331, 367,
3929 215, 208, 218, 203, 185, 186, 187, 145, 146, 753,
3930 76, 75, 752, 0, 99, 59, 98, 778, 777, 0,
3931 351, 612, 788, 788, 153, 760, 339, 315, 763, 307,
3932 0, 0, 0, 788, 0, 0, 301, 310, 0, 788,
3933 0, 788, 788, 0, 302, 720, 59, 296, 788, 59,
3934 788, 295, 306, 0, 59, 348, 68, 30, 32, 31,
3935 0, 788, 281, 0, 0, 0, 0, 788, 0, 59,
3936 337, 19, 0, 103, 0, 340, 783, 782, 285, 783,
3937 287, 341, 756, 0, 129, 660, 120, 115, 690, 0,
3938 0, 788, 0, 463, 642, 658, 645, 643, 637, 613,
3939 614, 639, 615, 641, 617, 0, 0, 0, 0, 0,
3940 787, 9, 0, 34, 35, 36, 37, 282, 0, 66,
3941 67, 726, 723, 722, 721, 724, 732, 737, 720, 0,
3942 743, 738, 747, 746, 742, 788, 739, 788, 718, 701,
3943 704, 59, 699, 725, 727, 728, 730, 704, 734, 693,
3944 741, 422, 421, 745, 704, 749, 698, 0, 0, 0,
3945 0, 0, 462, 0, 489, 91, 462, 0, 0, 0,
3946 59, 0, 108, 119, 0, 502, 246, 253, 255, 256,
3947 257, 264, 265, 258, 259, 235, 236, 262, 263, 502,
3948 59, 250, 251, 252, 241, 242, 243, 244, 245, 278,
3949 279, 765, 767, 766, 769, 483, 768, 305, 481, 59,
3950 788, 765, 767, 766, 769, 482, 305, 0, 788, 400,
3951 0, 399, 0, 0, 0, 0, 0, 357, 339, 0,
3952 788, 0, 81, 365, 140, 141, 142, 684, 363, 0,
3953 788, 0, 0, 0, 773, 774, 77, 59, 344, 765,
3954 766, 305, 0, 0, 0, 0, 0, 0, 0, 759,
3955 313, 309, 314, 788, 765, 766, 59, 765, 766, 0,
3956 0, 758, 290, 297, 292, 299, 779, 347, 29, 0,
3957 266, 13, 338, 0, 788, 0, 25, 105, 22, 336,
3958 59, 0, 113, 770, 128, 59, 765, 766, 464, 646,
3959 0, 618, 0, 622, 0, 628, 624, 0, 0, 630,
3960 247, 0, 38, 0, 420, 412, 414, 59, 417, 410,
3961 0, 697, 751, 0, 696, 0, 714, 689, 0, 0,
3962 0, 711, 733, 568, 740, 744, 0, 716, 748, 59,
3963 54, 57, 271, 268, 0, 692, 55, 269, 0, 463,
3964 487, 0, 463, 395, 396, 488, 473, 316, 41, 318,
3965 0, 44, 317, 117, 111, 0, 64, 47, 62, 0,
3966 288, 311, 226, 42, 0, 331, 500, 500, 0, 788,
3967 788, 489, 480, 94, 0, 486, 297, 788, 788, 294,
3968 479, 92, 293, 334, 788, 788, 401, 788, 403, 82,
3969 402, 355, 356, 392, 0, 0, 502, 0, 0, 770,
3970 338, 59, 765, 766, 0, 0, 0, 0, 140, 141,
3971 144, 59, 0, 59, 0, 343, 475, 87, 48, 288,
3972 227, 56, 234, 154, 762, 59, 303, 788, 788, 486,
3973 788, 788, 59, 788, 59, 233, 286, 121, 486, 26,
3974 647, 644, 651, 652, 621, 623, 633, 627, 635, 39,
3975 59, 419, 0, 729, 0, 750, 694, 741, 788, 703,
3976 702, 704, 704, 424, 700, 704, 731, 704, 728, 704,
3977 0, 788, 788, 370, 372, 464, 88, 464, 321, 0,
3978 788, 109, 788, 788, 788, 0, 788, 0, 501, 501,
3979 0, 0, 0, 0, 95, 780, 788, 0, 0, 93,
3980 390, 788, 17, 599, 394, 393, 0, 0, 0, 404,
3981 406, 0, 83, 0, 493, 0, 360, 500, 0, 361,
3982 486, 0, 0, 0, 0, 486, 368, 754, 78, 476,
3983 477, 0, 0, 0, 788, 0, 0, 291, 298, 346,
3984 719, 0, 411, 413, 415, 418, 695, 0, 715, 0,
3985 712, 0, 707, 0, 709, 717, 61, 273, 0, 0,
3986 26, 26, 316, 319, 0, 0, 0, 0, 765, 766,
3987 59, 765, 766, 0, 0, 267, 53, 231, 52, 232,
3988 96, 0, 50, 229, 51, 230, 600, 601, 788, 602,
3989 788, 14, 407, 0, 353, 354, 494, 0, 0, 501,
3990 358, 362, 0, 685, 364, 0, 719, 466, 469, 0,
3991 0, 0, 704, 704, 704, 704, 58, 272, 788, 788,
3992 320, 43, 63, 289, 486, 591, 597, 564, 0, 0,
3993 0, 501, 59, 501, 552, 636, 0, 590, 73, 510,
3994 516, 518, 520, 514, 513, 548, 515, 557, 560, 563,
3995 569, 570, 559, 523, 571, 524, 576, 577, 578, 581,
3996 582, 583, 584, 585, 587, 586, 588, 589, 567, 71,
3997 49, 228, 0, 0, 604, 391, 0, 18, 606, 0,
3998 0, 0, 495, 788, 0, 366, 59, 0, 650, 649,
3999 648, 416, 713, 708, 0, 705, 710, 59, 0, 453,
4000 452, 0, 579, 580, 141, 595, 0, 540, 59, 541,
4001 545, 59, 0, 535, 0, 788, 538, 551, 0, 592,
4002 0, 593, 0, 511, 0, 0, 558, 562, 574, 575,
4003 0, 501, 501, 0, 0, 566, 0, 603, 0, 678,
4004 679, 331, 0, 4, 15, 788, 496, 498, 499, 497,
4005 0, 507, 456, 0, 471, 0, 467, 704, 788, 788,
4006 451, 433, 436, 59, 0, 728, 436, 736, 425, 436,
4007 430, 490, 492, 59, 533, 555, 543, 542, 534, 546,
4008 781, 536, 565, 59, 517, 512, 548, 519, 549, 553,
4009 636, 561, 556, 572, 573, 596, 522, 532, 521, 528,
4010 59, 59, 59, 59, 59, 59, 339, 0, 788, 0,
4011 788, 605, 788, 405, 503, 0, 0, 0, 468, 0,
4012 0, 706, 429, 0, 428, 0, 447, 0, 454, 0,
4013 431, 442, 444, 0, 735, 0, 449, 539, 0, 547,
4014 0, 594, 0, 0, 0, 525, 526, 527, 529, 530,
4015 531, 770, 338, 59, 765, 766, 598, 16, 0, 508,
4016 509, 460, 59, 458, 461, 0, 470, 426, 788, 435,
4017 434, 436, 436, 455, 432, 436, 436, 339, 0, 436,
4018 544, 59, 549, 550, 554, 486, 788, 0, 457, 472,
4019 427, 0, 448, 0, 445, 0, 439, 0, 441, 770,
4020 338, 450, 0, 537, 505, 506, 504, 459, 436, 436,
4021 436, 436, 446, 440, 0, 437, 443, 436, 438
4025 static const yytype_int16 yypgoto[] =
4027 -1105, -1105, -1105, -96, 1038, -1105, 973, -1105, 811, -1105,
4028 -1105, -533, -1105, -39, 194, 817, -1105, 5, -1105, -1105,
4029 22, 254, -520, 18, -492, -57, -1105, -1105, 470, 2485,
4030 -1105, 2614, -9, -1105, -1105, -58, 125, -1105, -244, 1231,
4031 -12, 1221, -153, 21, -51, -1105, -417, 10, 1013, -395,
4032 1220, -38, -18, -1105, -1105, 20, -1105, 3966, -547, 1232,
4033 -1105, 562, 842, 541, 2850, -1105, 702, -16, 659, -373,
4034 60, -1105, 65, -328, -226, 15, -353, -1105, -540, -28,
4035 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, 867,
4036 -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105, -1105,
4037 -1105, -1105, -1105, -1105, -1105, 402, -1105, 629, 1595, 2113,
4038 -372, -1105, 162, -767, -1105, -793, -801, 605, 453, -502,
4039 -1105, 146, -1105, 231, -1105, -1104, 100, 184, -1105, 318,
4040 -1105, -993, -1105, 51, 295, 161, -389, -1105, -1105, 581,
4041 -1105, -1105, -1105, 530, -1105, -1105, -95, -1105, -516, -1105,
4042 1026, -1105, -769, -1105, -706, -825, -513, -1105, 63, -1105,
4043 -1105, -891, -753, -1105, -1105, -1105, -1105, 228, -1105, -142,
4044 -1105, -779, -957, -980, -343, -984, -732, -1105, 225, -1105,
4045 -1105, -785, 239, -1105, -584, 235, -1105, -1105, -1105, 158,
4046 -1105, -1105, 159, 1133, 1320, -1105, 1279, 1660, 1842, 17,
4047 -1105, 2023, -1105, 877, -1105, 2256, -1105, -1105, 2643, -1105,
4048 2725, -1105, -1105, -53, -1105, -1105, -186, -1105, -1105, -1105,
4049 -1105, -1105, -1105, 32, -1105, -1105, -1105, -1105, 29, -56,
4050 3112, -1, 1305, 3168, 1958, -1105, -1105, 132, 760, 38,
4051 -1105, -1105, -311, -683, 661, -426, -307, -196, -1089, -507,
4052 -324, -663, -493, -225, 675, 168, -374, -1105, -711, -1105,
4053 -671, -1105, -557, -522, -1105, -1105, -1105, 109, -396, 263,
4054 -346, -1105, -1105, -81, -1105, 119, 151, 122, -223, -44,
4059 static const yytype_int16 yydefgoto[] =
4061 0, 1, 2, 321, 69, 70, 71, 256, 257, 1109,
4062 1242, 637, 1020, 638, 275, 276, 488, 215, 72, 480,
4063 277, 74, 760, 473, 787, 75, 609, 595, 430, 227,
4064 844, 228, 393, 395, 942, 396, 78, 79, 585, 263,
4065 81, 82, 278, 83, 84, 85, 507, 86, 230, 413,
4066 414, 209, 210, 211, 674, 624, 213, 88, 763, 383,
4067 89, 537, 483, 538, 232, 282, 792, 625, 810, 466,
4068 467, 247, 248, 234, 456, 630, 236, 781, 782, 90,
4069 390, 494, 827, 646, 837, 835, 662, 578, 581, 265,
4070 92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
4071 344, 347, 931, 1106, 824, 936, 937, 775, 266, 267,
4072 640, 819, 938, 939, 405, 735, 736, 737, 738, 555,
4073 748, 749, 1189, 1299, 1261, 1191, 1192, 1256, 1193, 1128,
4074 1129, 1183, 1292, 1293, 513, 718, 869, 302, 1117, 104,
4075 1037, 1186, 1249, 348, 105, 106, 345, 582, 583, 586,
4076 587, 945, 825, 1179, 918, 1003, 796, 1288, 828, 1336,
4077 1180, 1068, 1205, 1070, 1071, 1163, 1164, 1072, 1270, 1138,
4078 1139, 1140, 1074, 1075, 1218, 1142, 1076, 1077, 1078, 1079,
4079 1080, 556, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 932,
4080 1018, 1103, 1107, 107, 108, 109, 110, 111, 112, 311,
4081 113, 114, 525, 722, 115, 116, 527, 117, 118, 119,
4082 120, 526, 528, 304, 308, 309, 518, 720, 719, 870,
4083 971, 1120, 871, 121, 122, 305, 123, 124, 125, 126,
4084 238, 239, 129, 240, 241, 836, 658, 333, 334, 335,
4085 336, 557, 889, 559, 560, 746, 561, 562, 563, 564,
4086 898, 566, 567, 568, 569, 1198, 570, 571, 572, 573,
4087 574, 575, 576, 741, 433, 663, 287, 470, 243, 132,
4088 703, 628, 666, 661, 439, 475, 805, 1146, 498, 641,
4095 static const yytype_int16 yytable[] =
4097 128, 398, 306, 229, 229, 246, 307, 323, 565, 253,
4098 389, 440, 565, 274, 281, 629, 464, 656, 216, 217,
4099 303, 558, 642, 73, 438, 558, 322, 212, 297, 579,
4100 235, 235, 888, 767, 353, 744, 392, 392, 397, 214,
4101 392, 627, 739, 636, 251, 764, 254, 212, 768, 469,
4102 941, 128, 128, 322, 793, 300, 133, 297, 948, 214,
4103 766, 500, 890, 431, 342, 502, 296, 691, 771, 283,
4104 297, 297, 297, 279, 892, 233, 244, 324, 212, 897,
4105 312, 313, 314, 975, 300, 394, 686, 896, 399, 973,
4106 229, 919, 712, 671, 1004, 315, 797, 407, 417, 417,
4107 417, 639, 682, 691, 340, 1141, -131, 280, 280, 285,
4108 289, 639, 627, 1099, 636, 339, 134, 235, 1184, -131,
4109 489, 212, 521, 523, 242, 242, 546, 681, -672, 842,
4110 767, 337, 337, -132, 1194, 681, 1152, 1118, 715, 1160,
4111 704, 751, 249, 682, 773, 343, 547, -59, 757, 753,
4112 858, 1300, -680, -681, 255, 1207, 460, -672, 1294, 1206,
4113 -132, -671, 434, 284, 288, -139, 704, 754, 436, 249,
4114 462, 1219, 450, 1216, 784, 1152, 346, 551, 552, 491,
4115 848, 851, 274, 885, 486, -137, 885, -131, -132, -138,
4116 -671, 1153, 316, 474, 476, 1161, -134, 818, 590, 1162,
4117 1257, -139, 774, -136, 1114, -139, 1231, 1234, -766, 338,
4118 553, 242, 492, 1185, 330, 331, -133, 512, 1081, 1081,
4119 128, 1300, -138, 1181, 1073, 1073, 739, 881, 1294, 249,
4120 341, 322, 271, 229, 274, 229, 1136, -122, 1145, 1121,
4121 -135, 1029, 506, 319, 464, -137, 246, 342, 973, 320,
4122 1069, 1069, 891, 319, 1027, 128, -134, -136, 1119, 320,
4123 468, -131, 235, 899, 840, 297, 339, -131, 392, 392,
4124 392, 392, 128, 539, 540, -132, 280, 831, 73, 310,
4125 -133, -132, 337, 337, 1219, 923, 340, 841, 1219, 1314,
4126 457, -123, 300, 1313, 279, 349, -130, 457, 890, 691,
4127 471, 497, 497, 647, 954, 704, 497, 472, 503, 1137,
4128 1044, 133, 274, 947, 896, 704, 533, 534, 535, 536,
4129 -129, 505, 128, 651, 297, 319, 1157, -125, 280, 1081,
4130 -126, 320, 249, 339, -127, 1073, 1226, 1228, 392, 723,
4131 682, 723, 350, -139, 1178, 73, 1177, -124, 1314, -139,
4132 128, 300, 1152, 987, 392, 322, 242, 644, 645, 451,
4133 452, 1069, 592, 724, -138, 681, 976, 681, 911, 887,
4134 -138, 1081, 279, 635, -135, 739, 229, 739, 1081, 1081,
4135 986, 514, -135, 1203, -137, -765, 643, -137, -135, 128,
4136 -766, 1017, 728, -137, -103, 128, 128, 493, -134, -136,
4137 1137, 552, 653, 354, -134, -136, 280, -555, 442, 634,
4138 1137, 1137, 341, -338, 987, -117, -125, 725, 245, 1032,
4139 -680, 565, -133, 229, 935, -59, 565, 249, -133, 1006,
4140 1008, 1232, 1235, 553, 826, 1012, 1014, 516, 517, -377,
4141 -126, -338, -338, 471, 635, 280, 729, 229, -127, -788,
4142 235, 280, 280, 682, 385, -131, 1199, 856, 506, 634,
4143 -126, -126, 698, -765, -126, 978, 980, -377, -377, 982,
4144 635, 984, 332, 985, 1132, 1133, -122, 310, 681, 59,
4145 634, 297, 386, 387, 356, 1081, 1042, 866, 1043, 444,
4146 1045, 128, -124, 731, 250, 667, 635, 862, -338, 229,
4147 212, 385, -766, 753, 446, -126, 634, -765, 300, 935,
4148 487, 823, 214, 860, 471, -128, 990, -766, 991, 1100,
4149 -681, 1165, 861, 457, -377, 457, -125, 443, 453, 386,
4150 458, 128, 634, 739, 739, 765, 875, 128, 1311, 388,
4151 506, 875, 1298, 1000, 242, -138, -125, -125, -134, 1334,
4152 -125, 380, 381, 382, 668, -132, 682, -136, -127, 924,
4153 732, 443, -139, 297, 683, 761, 471, 929, 761, 627,
4154 1200, 636, 691, 1028, 1223, 1224, -123, 128, -127, -127,
4155 128, 454, -127, -130, 1302, 692, 459, 280, 694, 1306,
4156 300, 455, 258, 697, 834, -673, -139, 896, 1202, 820,
4157 461, 815, -124, 817, 780, 710, 843, 356, 707, 780,
4158 742, 802, 742, 514, 522, 385, 1122, 1123, 1125, 1126,
4159 809, 463, -124, -124, -673, 1188, -124, 964, 798, 1098,
4160 1098, 1187, 481, 280, 1196, 635, 280, 856, 229, 128,
4161 681, 128, 864, 386, 485, 635, 565, 804, 229, 807,
4162 626, 1110, 626, -674, 1340, 809, 853, 565, 896, 558,
4163 867, 128, -133, 1038, 872, 1135, 1252, 1254, 477, 516,
4164 517, 634, 378, 379, 380, 381, 382, 245, 478, 479,
4165 747, 634, -674, 297, -134, 457, 654, 802, 809, 808,
4166 655, 812, 803, -676, 212, 280, 885, 280, 1200, 356,
4167 459, 811, 626, 1200, 804, 471, 214, 926, 1200, 783,
4168 300, 487, 565, 917, 778, 471, 1295, 280, -675, 788,
4169 490, 626, -676, 626, -136, 558, 812, 385, 497, 1116,
4170 435, 1172, 249, 804, 506, 250, 847, -102, 457, 874,
4171 1098, 876, -133, 807, 877, 878, -138, -675, 626, 626,
4172 495, 959, 385, 1188, 1057, 386, 510, 297, 1188, 812,
4173 504, 1251, 1301, 1188, 1200, 1225, 1200, -129, 1200, 501,
4174 1200, 332, 1309, 626, 547, 626, 1320, 900, -134, 392,
4175 386, 437, 1098, 509, 300, 808, 845, 1200, -677, 1098,
4176 1098, 952, 524, -668, 529, 951, 514, 788, 788, -125,
4177 -678, 319, 863, 1195, 514, 551, 431, 320, 1244, 1220,
4178 -679, -669, 511, 330, 331, -331, 482, -677, 385, 1188,
4179 -136, 1188, -668, 1188, 532, 1188, 577, 953, -678, -678,
4180 1338, 654, 1339, 128, 1341, 1134, 128, 859, -679, -679,
4181 -669, -127, 1188, -331, -331, -687, 386, 649, 786, 804,
4182 519, 1347, 516, 517, 584, 675, 883, 664, 519, 804,
4183 516, 517, 385, 1212, 212, 1283, 868, 249, 91, 933,
4184 940, -59, 940, 961, 970, 249, 496, 769, -339, 887,
4185 392, 772, 237, 237, 514, -678, 665, 580, 761, 280,
4186 386, 659, 280, 704, 530, -679, 1098, 1022, 514, 593,
4187 -331, 635, 1197, 650, 229, -765, -339, -339, 652, 1033,
4188 648, 589, 626, -766, 626, 863, 594, 657, 457, 91,
4189 91, 385, 626, 298, 626, 1310, 786, 786, 1023, 1312,
4190 905, 1195, 1039, 907, 237, 128, 1195, 634, 515, 676,
4191 516, 517, 677, 742, 385, 693, 780, 660, -668, 386,
4192 915, 128, 298, 695, 516, 517, -669, 1212, 696, 385,
4193 237, 237, 957, -339, 237, 404, 415, 415, 701, 237,
4194 128, 471, 386, 1237, 249, 499, -668, -668, 926, 934,
4195 935, 967, 950, 969, -669, -669, 1019, 386, 1308, 1113,
4196 -117, 280, 955, 128, 128, 1048, 1049, 1158, 1159, 972,
4197 709, 1195, 1097, 1097, 672, 673, 916, 280, 361, 362,
4198 1151, 1215, 1148, -133, 87, 678, 1051, 1052, 804, 1245,
4199 1246, 1230, 1233, 689, 690, 711, 280, 128, 1197, 1238,
4200 1197, -765, 740, -668, -124, 1197, 743, -765, 514, -766,
4201 1197, -669, 745, 482, 660, -766, 788, 788, -423, 705,
4202 249, 1317, 788, 788, 508, 508, 750, 1097, 1097, 755,
4203 756, 1097, 758, 373, 374, 87, 87, 770, 514, 816,
4204 1174, 1175, 785, 1104, 297, 1108, 806, 1241, 1097, 823,
4205 804, 1144, 826, 280, 879, 882, 884, 1239, 91, 1201,
4206 893, 901, 519, 392, 516, 517, 1197, 902, 1197, 906,
4207 1197, 1170, 1197, 1130, 1130, 128, -311, 909, 128, 128,
4208 492, 403, 237, 1097, 237, 910, 514, 237, 237, 1197,
4209 912, 788, 520, 91, 516, 517, 913, 128, 925, 322,
4210 128, 920, 930, 1240, 1182, 1097, 788, 935, 1097, 968,
4211 91, 1213, 754, 977, 979, 1182, 1250, 514, 981, 983,
4212 1010, 1054, 1097, 1097, 1097, -315, 804, 1097, 1097, 804,
4213 298, 280, 1097, 1097, 280, 280, 1102, 1274, 940, 297,
4214 721, 128, 516, 517, 1040, 786, 786, 1041, 626, 804,
4215 626, 786, 786, 280, 128, -313, 280, 1105, 392, 392,
4216 91, 1124, 237, 237, 237, 237, 417, 237, 237, 1127,
4217 814, 726, 1147, 516, 517, 36, 37, 1154, 39, 1055,
4218 1155, 1182, 1152, 1143, 1156, 45, 46, 776, 91, 298,
4219 1209, 1210, 1236, 635, 1247, 1248, 229, 280, 1253, 1255,
4220 940, 297, 80, 1258, 87, 1260, 1289, 1290, 1265, 1268,
4221 280, 1269, 1272, 742, 742, 1273, 80, 80, 128, 1316,
4222 786, 804, 804, 804, 1296, 237, 1303, 91, 417, 634,
4223 1307, 1321, 237, 91, 91, 786, 813, 1097, -770, 87,
4224 1323, 1097, 1097, 821, 822, 1325, 1327, 1149, 237, 36,
4225 37, 1229, 39, 80, 80, 1332, 87, 128, -765, 1204,
4226 -766, 1344, 1208, 471, 484, 933, 531, 1108, 80, 706,
4227 1173, 804, 237, 541, 280, 542, 543, 544, 545, 708,
4228 1318, -770, 1227, 541, 958, 542, 543, 544, 545, 402,
4229 419, 384, 1267, 699, 80, 80, 237, 1150, 80, 1144,
4230 846, 1097, 1271, 80, 1021, 974, 87, 1243, 880, -770,
4231 -770, 1259, 1291, 280, 542, 543, 544, 545, 356, 1275,
4232 1276, 1277, 541, 742, 542, 543, 544, 545, 1190, 91,
4233 1305, 921, 922, 733, 87, 369, 370, 1131, 1337, 927,
4234 928, 940, 356, 588, 850, 852, 298, 960, 237, 1335,
4235 1262, 1221, 1217, 1266, 1278, 1279, 1280, 1214, 441, 369,
4236 370, 850, 852, 903, -770, 1222, -770, 904, 1286, 91,
4237 -765, 1287, 733, 87, 727, 91, 432, 865, 734, 87,
4238 87, 895, 377, 378, 379, 380, 381, 382, 886, 962,
4239 963, 1297, 965, 966, 325, 326, 327, 328, 329, 40,
4240 41, 42, 43, 1333, 1315, 0, 0, 378, 379, 380,
4241 381, 382, 988, 989, 237, 91, 0, 237, 91, 0,
4242 0, 994, 80, 995, 946, 997, 237, 949, 298, 0,
4243 0, 794, 0, 0, 0, 0, 0, 0, 0, 0,
4244 0, 956, 0, 0, 0, 996, 80, 0, 80, 0,
4245 0, 80, 80, 0, 0, 1322, 1324, 80, 1011, 1326,
4246 1328, 0, 0, 1331, 0, 0, 0, 0, 0, 0,
4247 626, 0, 626, 0, 80, 87, 0, 91, 0, 91,
4248 0, 0, 0, 0, 0, 0, 0, 237, 0, 0,
4249 0, 0, 1342, 1343, 1345, 1346, 1035, 237, 0, 91,
4250 237, 1348, 0, 0, 0, 356, 0, 0, 0, 794,
4251 794, 0, 0, 0, 0, 87, 0, 0, 0, 0,
4252 0, 87, 369, 370, 80, 0, 80, 80, 80, 80,
4253 0, 80, 80, 0, 0, 0, 237, 1024, 0, 0,
4254 1025, 626, 0, 0, 0, 0, 0, 1030, 298, 0,
4255 1031, 0, 80, 1034, 1067, 1067, 0, 0, 0, 0,
4256 0, 87, 0, 0, 87, 0, 102, 375, 376, 377,
4257 378, 379, 380, 381, 382, 0, 0, 789, 0, 0,
4258 102, 102, 0, 0, 0, 0, 0, 0, 0, 80,
4259 0, 80, 0, 1007, 1009, 0, 80, 80, 80, 1013,
4260 1015, 0, 0, 0, 0, 0, 0, 0, 0, 1067,
4261 1067, 0, 80, 1067, 0, 0, 0, 102, 102, 0,
4262 0, 0, 298, 87, 0, 87, 0, 0, 0, 0,
4263 1067, 1115, 102, 0, 1007, 1009, 80, 1013, 1015, 0,
4264 0, 0, 0, 0, 0, 87, 0, 0, 0, 0,
4265 0, 0, 0, 0, 0, 789, 789, 0, 102, 102,
4266 80, 0, 102, 0, 0, 1067, 0, 102, 0, 0,
4267 0, 91, 0, 237, 91, 0, 0, 1211, 0, 0,
4268 0, 0, 0, 1101, 0, 0, 0, 1067, 0, 0,
4269 1067, 0, 0, 80, 541, 0, 542, 543, 544, 545,
4270 546, 0, 0, 0, 1067, 1067, 1067, 1101, 0, 1067,
4271 1067, 0, 80, 0, 1067, 1067, 0, 0, 0, 541,
4272 547, 542, 543, 544, 545, 546, 0, 0, 0, 0,
4273 0, 0, 0, 80, 548, 0, 0, 237, 0, 80,
4274 0, 0, 0, 0, 549, 547, 0, 0, 0, 0,
4275 550, 551, 552, 237, 0, 0, 0, 0, 794, 794,
4276 0, 0, 0, 0, 794, 794, 0, 0, 0, 549,
4277 0, 0, 0, 91, 237, 0, 551, 552, 80, 80,
4278 0, 80, 80, 0, 553, 0, 102, 554, 0, 91,
4279 80, 0, 0, 0, 0, 80, 0, 0, 0, 541,
4280 1036, 542, 543, 544, 545, 546, 0, 0, 91, 553,
4281 102, 0, 102, 0, 0, 102, 102, 87, 0, 1067,
4282 87, 102, 0, 1067, 1067, 547, 0, 0, 0, 0,
4283 0, 91, 91, 794, 0, 0, 0, 0, 102, 548,
4284 0, 80, 0, 80, 0, 0, 0, 0, 794, 549,
4285 0, 80, 0, 0, 0, 0, 551, 552, 0, 0,
4286 0, 80, 0, 80, 80, 91, 0, 0, 0, 0,
4287 0, 0, 0, 80, 80, 0, 541, 0, 542, 543,
4288 544, 545, 546, 1067, 0, 0, 0, 0, 102, 553,
4289 102, 102, 102, 102, 1319, 102, 102, 0, 0, 0,
4290 80, 0, 547, 0, 789, 789, 0, 0, 0, 0,
4291 789, 789, 0, 0, 0, 0, 102, 0, 0, 87,
4292 0, 0, 0, 0, 0, 0, 549, 0, 0, 131,
4293 0, 0, 550, 551, 552, 87, 0, 0, 0, 1168,
4294 0, 0, 0, 91, 0, 0, 91, 91, 0, 0,
4295 0, 0, 0, 102, 87, 102, 0, 0, 0, 0,
4296 102, 102, 102, 0, 0, 91, 553, 0, 91, 554,
4297 0, 0, 0, 0, 0, 0, 102, 87, 87, 789,
4298 131, 131, 0, 0, 301, 0, 0, 237, 0, 0,
4299 0, 0, 0, 0, 789, 0, 0, 0, 0, 0,
4300 102, 0, 0, 0, 0, 0, 0, 0, 0, 91,
4301 0, 87, 0, 301, 0, 541, 0, 542, 543, 544,
4302 545, 546, 91, 0, 102, 0, 408, 418, 418, 0,
4303 0, 0, 0, 0, 1264, 80, 0, 80, 80, 0,
4304 0, 547, 0, 0, 0, 0, 0, 0, 0, 0,
4305 0, 0, 0, 0, 0, 0, 0, 102, 0, 0,
4306 0, 0, 0, 0, 0, 549, 0, 0, 0, 0,
4307 0, 550, 551, 552, 0, 237, 102, 0, 0, 0,
4308 0, 0, 237, 237, 103, 1167, 91, 0, 0, 87,
4309 0, 0, 87, 87, 0, 0, 1304, 102, 103, 103,
4310 0, 80, 0, 102, 0, 553, 1089, 1089, 554, 0,
4311 0, 87, 0, 0, 87, 0, 0, 80, 249, 0,
4312 0, 0, 80, 80, 0, 91, 0, 0, 80, 80,
4313 0, 0, 0, 0, 0, 103, 103, 80, 80, 0,
4314 0, 0, 102, 102, 0, 102, 102, 0, 0, 131,
4315 103, 0, 0, 80, 102, 87, 0, 0, 0, 102,
4316 0, 1089, 1089, 0, 0, 1089, 0, 0, 87, 0,
4317 0, 0, 80, 0, 0, 0, 103, 103, 0, 0,
4318 103, 0, 1089, 0, 131, 103, 0, 0, 0, 0,
4319 0, 0, 0, 0, 0, 80, 80, 80, 0, 0,
4320 0, 131, 0, 0, 0, 102, 0, 102, 0, 0,
4321 0, 0, 80, 0, 0, 102, 0, 1089, 0, 0,
4322 0, 301, 0, 0, 0, 102, 0, 102, 102, 80,
4323 0, 0, 87, 0, 0, 0, 0, 102, 102, 1089,
4324 0, 0, 1089, 0, 0, 0, 0, 0, 0, 0,
4325 0, 131, 0, 0, 0, 0, 1089, 1089, 1089, 0,
4326 0, 1089, 1089, 0, 102, 0, 1089, 1089, 0, 0,
4327 0, 87, 0, 0, 0, 0, 0, 0, 0, 131,
4328 301, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4329 0, 0, 0, 1090, 1090, 0, 0, 541, 0, 542,
4330 543, 544, 545, 546, 103, 0, 0, 80, 0, 0,
4331 80, 80, 0, 0, 0, 0, 0, 0, 131, 0,
4332 0, 0, 0, 547, 131, 131, 0, 0, 103, 80,
4333 103, 0, 80, 103, 103, 0, 0, 548, 0, 103,
4334 0, 0, 0, 0, 0, 0, 0, 549, 1090, 1090,
4335 0, 80, 1090, 550, 551, 552, 103, 0, 0, 0,
4336 0, 0, 0, 0, 0, 0, 0, 0, 0, 1090,
4337 0, 1089, 0, 80, 0, 1089, 1089, 0, 0, 0,
4338 0, 0, 0, 0, 0, 0, 80, 553, 0, 0,
4339 554, 0, 0, 0, 0, 0, 0, 0, 0, 102,
4340 0, 102, 102, 0, 1090, 0, 103, 0, 103, 103,
4341 103, 103, 0, 103, 103, 0, 0, 0, 0, 0,
4342 131, 0, 0, 0, 0, 0, 1090, 0, 0, 1090,
4343 0, 0, 0, 0, 103, 1089, 0, 301, 0, 80,
4344 0, 0, 0, 1090, 1090, 1090, 80, 80, 1090, 1090,
4345 80, 0, 0, 1090, 1090, 0, 76, 0, 0, 0,
4346 131, 0, 0, 0, 0, 102, 131, 0, 0, 0,
4347 0, 103, 0, 103, 0, 0, 0, 0, 103, 103,
4348 103, 102, 0, 0, 0, 0, 102, 102, 0, 80,
4349 0, 0, 102, 102, 103, 0, 0, 0, 0, 0,
4350 0, 102, 102, 0, 0, 0, 131, 76, 76, 131,
4351 0, 294, 0, 0, 0, 0, 0, 102, 103, 301,
4352 0, 0, 795, 0, 0, 0, 0, 0, 0, 0,
4353 0, 0, 0, 0, 0, 0, 102, 0, 0, 0,
4354 294, 0, 103, 0, 0, 0, 0, 0, 0, 0,
4355 0, 0, 0, 294, 294, 294, 0, 0, 1090, 102,
4356 102, 102, 1090, 1090, 0, 0, 0, 0, 131, 0,
4357 131, 0, 0, 0, 0, 103, 102, 0, 0, 0,
4358 0, 0, 0, 0, 0, 77, 0, 0, 0, 0,
4359 131, 0, 0, 102, 103, 0, 0, 0, 0, 0,
4360 795, 795, 0, 0, 0, 0, 0, 0, 0, 0,
4361 0, 0, 0, 0, 0, 103, 0, 0, 0, 0,
4362 0, 103, 1090, 0, 0, 0, 0, 0, 0, 0,
4363 0, 0, 0, 1091, 1091, 0, 77, 77, 0, 301,
4364 295, 0, 0, 0, 0, 0, 0, 0, 873, 0,
4365 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4366 103, 103, 0, 103, 103, 0, 0, 0, 0, 295,
4367 0, 102, 103, 0, 102, 102, 76, 103, 0, 0,
4368 0, 0, 295, 295, 295, 0, 0, 0, 1091, 1091,
4369 0, 0, 1091, 102, 0, 0, 102, 0, 0, 0,
4370 0, 0, 0, 0, 0, 0, 0, 0, 0, 1091,
4371 0, 76, 0, 301, 0, 102, 0, 0, 0, 0,
4372 0, 0, 0, 103, 0, 103, 0, 0, 76, 0,
4373 0, 0, 0, 103, 0, 0, 0, 102, 0, 0,
4374 0, 0, 0, 103, 1091, 103, 103, 0, 294, 0,
4375 102, 0, 0, 0, 0, 103, 103, 0, 0, 0,
4376 0, 0, 131, 0, 0, 131, 1091, 0, 355, 1091,
4377 0, 0, 0, 0, 0, 0, 0, 0, 76, 0,
4378 0, 0, 103, 1091, 1091, 1091, 0, 0, 1091, 1091,
4379 0, 0, 0, 1091, 1091, 0, 0, 0, 0, 0,
4380 0, 0, 0, 102, 0, 77, 76, 294, 0, 0,
4381 102, 102, 0, 0, 102, 1092, 1092, 0, 0, 0,
4382 0, 356, 357, 358, 359, 360, 361, 362, 363, 364,
4383 365, 366, 367, 368, 0, 0, 0, 0, 369, 370,
4384 77, 0, 0, 0, 371, 76, 0, 0, 0, 795,
4385 795, 76, 76, 102, 0, 795, 795, 77, 0, 0,
4386 0, 0, 0, 0, 131, 0, 0, 0, 0, 0,
4387 1092, 1092, 0, 0, 1092, 286, 0, 295, 0, 372,
4388 131, 373, 374, 375, 376, 377, 378, 379, 380, 381,
4389 382, 1092, 0, 0, 0, 0, 0, 0, 1091, 131,
4390 0, 0, 1091, 1091, 0, 0, 0, 77, 0, 0,
4391 0, 0, 0, 0, 0, 0, 0, 103, 0, 103,
4392 103, 0, 131, 131, 795, 0, 1092, 0, 0, 0,
4393 0, 0, 0, 0, 0, 77, 295, 0, 0, 795,
4394 0, 0, 0, 0, 0, 0, 0, 76, 1092, 0,
4395 0, 1092, 0, 0, 0, 0, 131, 0, 0, 0,
4396 0, 0, 1091, 0, 294, 1092, 1092, 1092, 0, 0,
4397 1092, 1092, 0, 0, 77, 1092, 1092, 0, 0, 0,
4398 77, 77, 0, 103, 0, 0, 0, 76, 0, 0,
4399 0, 0, 0, 76, 0, 0, 1093, 1093, 0, 103,
4400 0, 0, 0, 0, 103, 103, 0, 0, 0, 0,
4401 103, 103, 0, 0, 0, 0, 0, 0, 0, 103,
4402 103, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4403 1171, 0, 0, 76, 131, 103, 76, 131, 131, 445,
4404 0, 0, 447, 448, 449, 0, 294, 0, 0, 76,
4405 0, 1093, 1093, 0, 103, 1093, 131, 0, 0, 131,
4406 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4407 0, 0, 1093, 0, 0, 0, 77, 103, 103, 103,
4408 1092, 0, 0, 127, 1092, 1092, 0, 0, 0, 0,
4409 0, 0, 0, 295, 103, 76, 0, 76, 0, 0,
4410 131, 0, 0, 0, 0, 0, 0, 1093, 0, 0,
4411 0, 103, 0, 131, 0, 0, 77, 76, 0, 0,
4412 0, 0, 77, 0, 0, 418, 0, 76, 76, 1093,
4413 0, 0, 1093, 0, 127, 127, 0, 0, 299, 130,
4414 0, 0, 0, 0, 1092, 0, 1093, 1093, 1093, 0,
4415 0, 1093, 1093, 0, 0, 0, 1093, 1093, 0, 0,
4416 0, 0, 77, 0, 0, 77, 294, 299, 0, 0,
4417 0, 0, 0, 0, 0, 295, 0, 131, 77, 0,
4418 406, 416, 416, 416, 0, 0, 0, 418, 0, 103,
4419 130, 130, 103, 103, 0, 0, 0, 0, 0, 0,
4420 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4421 0, 103, 0, 0, 103, 0, 131, 0, 0, 0,
4422 0, 0, 0, 0, 77, 0, 77, 0, 0, 1094,
4423 1094, 0, 0, 103, 0, 0, 0, 0, 0, 0,
4424 294, 0, 0, 0, 0, 0, 77, 0, 0, 0,
4425 0, 0, 0, 0, 0, 103, 77, 77, 0, 0,
4426 0, 1093, 0, 0, 0, 1093, 1093, 0, 103, 0,
4427 0, 0, 0, 0, 679, 680, 0, 0, 0, 0,
4428 0, 0, 0, 286, 1094, 1094, 0, 0, 1094, 76,
4429 0, 0, 76, 0, 0, 295, 0, 0, 0, 0,
4430 0, 0, 0, 127, 0, 1094, 0, 0, 0, 0,
4431 0, 0, 0, 0, 0, 0, 680, 0, 0, 286,
4432 0, 103, 0, 0, 0, 1093, 0, 0, 103, 103,
4433 0, 0, 103, 0, 0, 0, 0, 0, 127, 0,
4434 1094, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4435 0, 0, 0, 0, 0, 127, 0, 0, 0, 130,
4436 0, 0, 1094, 0, 0, 1094, 0, 0, 0, 295,
4437 0, 103, 0, 0, 0, 299, 76, 76, 0, 1094,
4438 1094, 1094, 76, 76, 1094, 1094, 0, 0, 752, 1094,
4439 1094, 76, 0, 0, 130, 0, 0, 0, 0, 0,
4440 0, 0, 0, 0, 0, 127, 0, 76, 0, 779,
4441 0, 130, 0, 0, 791, 0, 0, 0, 77, 0,
4442 0, 77, 0, 0, 0, 0, 76, 0, 0, 0,
4443 0, 0, 0, 127, 299, 0, 0, 0, 0, 0,
4444 0, 0, 0, 0, 0, 0, 0, 0, 0, 76,
4445 76, 76, 0, 0, 0, 0, 0, 0, 0, 0,
4446 0, 130, 0, 0, 0, 0, 76, 0, 0, 0,
4447 0, 0, 127, 0, 0, 0, 0, 0, 127, 127,
4448 0, 0, 0, 76, 0, 0, 0, 0, 0, 130,
4449 0, 0, 0, 0, 1094, 854, 0, 0, 1094, 1094,
4450 0, 0, 0, 0, 0, 77, 77, 0, 0, 0,
4451 0, 77, 77, 680, 0, 286, 0, 0, 0, 0,
4452 77, 22, 23, 24, 25, 0, 0, 0, 130, 0,
4453 0, 0, 0, 0, 130, 130, 77, 31, 32, 33,
4454 0, 0, 0, 0, 0, 0, 0, 40, 41, 42,
4455 43, 44, 0, 0, 0, 77, 0, 294, 1094, 0,
4456 0, 76, 0, 0, 76, 76, 0, 0, 0, 894,
4457 0, 0, 0, 0, 127, 0, 0, 0, 77, 77,
4458 77, 0, 0, 76, 0, 0, 76, 0, 0, 0,
4459 0, 299, 0, 0, 0, 77, 0, 908, 0, 57,
4460 58, 59, 60, 61, 62, 63, 64, 65, 0, 0,
4461 0, 0, 77, 0, 127, 0, 1095, 1095, 0, 0,
4462 127, 0, 0, 0, 0, 0, 680, 76, 0, 0,
4463 130, 0, 0, 0, 0, 0, 292, 0, 0, 0,
4464 76, 0, 0, 0, 944, 0, 0, 0, 0, 0,
4465 0, 0, 294, 0, 0, 0, 0, 0, 0, 0,
4466 127, 0, 0, 127, 0, 0, 0, 0, 0, 0,
4467 130, 1095, 1095, 299, 0, 1095, 130, 0, 0, 0,
4468 0, 0, 0, 0, 0, 0, 295, 0, 0, 0,
4469 77, 0, 1095, 77, 77, 0, 0, 0, 1096, 1096,
4470 0, 0, 0, 0, 76, 0, 0, 0, 0, 0,
4471 0, 0, 77, 0, 294, 77, 130, 0, 0, 130,
4472 0, 0, 127, 0, 127, 0, 0, 1095, 0, 993,
4473 0, 0, 130, 0, 0, 0, 0, 0, 0, 0,
4474 0, 0, 0, 76, 127, 0, 0, 0, 0, 1095,
4475 0, 1016, 1095, 1096, 1096, 0, 77, 1096, 0, 0,
4476 0, 0, 0, 1026, 0, 0, 1095, 1095, 1095, 77,
4477 0, 1095, 1095, 0, 1096, 0, 1095, 1095, 130, 0,
4478 130, 295, 0, 0, 0, 0, 0, 0, 286, 0,
4479 0, 0, 0, 299, 0, 0, 0, 0, 0, 0,
4480 130, 0, 0, 0, 0, 0, 0, 0, 0, 1096,
4481 130, 130, 1050, 0, 0, 0, 0, 0, 0, 0,
4482 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4483 0, 1096, 0, 77, 1096, 0, 0, 0, 0, 0,
4484 0, 0, 0, 295, 0, 0, 0, 1112, 1096, 1096,
4485 1096, 0, 0, 1096, 1096, 0, 0, 0, 1096, 1096,
4486 0, 0, 0, 0, 0, 0, 0, 299, 0, 0,
4487 0, 0, 77, 0, 0, 0, 0, 0, 0, 0,
4488 0, 1095, 0, 0, 0, 1095, 1095, 0, 0, 0,
4489 0, 0, 0, 0, 0, 0, -788, 0, 0, 0,
4490 0, 0, 0, 0, -788, -788, -788, 0, 0, -788,
4491 -788, -788, 0, -788, 0, 0, 127, 0, 0, 127,
4492 0, -788, -788, -788, 0, 0, 0, 0, 0, 0,
4493 0, 1176, 0, -788, -788, 0, -788, -788, -788, -788,
4494 -788, 0, 0, 0, 0, 1095, 0, 0, 0, 0,
4495 0, 231, 231, 0, 0, 0, 0, 0, 0, 0,
4496 0, 0, 0, 1096, -788, -788, 0, 1096, 1096, 0,
4497 0, 0, 130, 0, 0, 130, 0, 0, 0, 0,
4498 0, 0, 0, 264, 268, 269, 270, 0, 0, 0,
4499 231, 231, 0, -788, -788, 0, 0, 0, 0, 0,
4500 0, 0, 0, 317, 318, 0, 0, 0, 0, 0,
4501 0, 0, 0, 22, 23, 24, 25, -788, 127, 0,
4502 0, 0, 0, 0, 0, 0, 0, 1096, 0, 31,
4503 32, 33, 1055, 0, 127, 0, 1056, 0, 231, 40,
4504 41, 42, 43, 44, 0, 0, 0, 0, -788, -788,
4505 0, -788, 0, 127, 245, -788, 0, -788, 0, 130,
4506 130, 0, 0, 0, 0, 130, 130, 0, 0, 0,
4507 0, 1058, 1059, 0, 130, 0, 127, 127, 0, 1060,
4508 0, 0, 1061, 0, 0, 1062, 1063, 0, 1064, 0,
4509 130, 57, 58, 59, 60, 61, 62, 63, 64, 65,
4510 0, 0, 914, 0, 0, 0, 0, 0, 0, 130,
4511 127, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4512 0, 1066, 0, 0, 0, 0, 0, 0, 292, 0,
4513 0, 0, 130, 130, 130, 249, 356, 357, 358, 359,
4514 360, 361, 362, 363, 364, 365, 366, 367, 368, 130,
4515 0, 0, 0, 369, 370, 231, 0, 0, 231, 231,
4516 231, 0, 317, 0, 0, 0, 130, 0, 0, 0,
4517 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4518 0, 231, 0, 231, 1169, 0, 914, 0, 127, 0,
4519 0, 127, 127, 0, 372, 0, 373, 374, 375, 376,
4520 377, 378, 379, 380, 381, 382, 0, 0, 0, 0,
4521 127, 0, 0, 127, -283, 0, 0, 0, 0, 0,
4522 356, 357, 358, 359, 360, 361, 362, 363, 364, 365,
4523 366, 367, 368, 0, 0, 0, 0, 369, 370, 0,
4524 0, 0, 0, 0, 130, 0, 0, 130, 130, 0,
4525 0, 0, 0, 0, 127, 0, 0, 0, 0, 0,
4526 0, 0, 0, 0, 0, 0, 130, 127, 0, 130,
4527 0, 0, 0, 0, 0, 0, 0, 0, 372, 416,
4528 373, 374, 375, 376, 377, 378, 379, 380, 381, 382,
4529 0, 0, 596, 597, 598, 599, 600, 0, 0, 601,
4530 602, 603, 604, 605, 606, 607, 608, 0, 610, 0,
4531 130, 611, 612, 613, 614, 615, 616, 617, 618, 619,
4532 620, 0, 0, 130, 231, 0, 0, 0, 0, 0,
4533 0, 127, 0, 0, 0, 0, 0, 0, 0, 0,
4534 0, 416, 0, 0, 0, 0, 0, 0, 0, 0,
4535 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4536 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4537 127, 231, 0, 0, 0, 0, 0, 0, 0, 0,
4538 0, 0, 0, 0, 0, 0, 0, 130, 0, 0,
4539 231, 231, 0, 0, 0, 231, 0, 0, 0, 231,
4540 -668, 270, 0, 0, 0, 0, 0, 0, -668, -668,
4541 -668, 0, 0, -668, -668, -668, 0, -668, 0, 700,
4542 0, 0, 0, 0, 0, -668, 130, -668, -668, -668,
4543 0, 0, 231, 0, 0, 231, 0, -668, -668, 0,
4544 -668, -668, -668, -668, -668, 0, 0, 231, 0, 0,
4545 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4546 0, 0, 0, 0, 0, 730, 0, 0, -668, -668,
4547 0, 0, 0, 0, 0, 0, 0, 0, -668, -668,
4548 -668, -668, -668, -668, -668, -668, -668, -668, -668, -668,
4549 -668, 0, 0, 0, 0, -668, -668, -668, -668, 0,
4550 -668, -668, 0, 0, 231, 0, 0, -668, 0, 0,
4551 0, 0, 0, 762, 0, 0, 762, 0, 0, 0,
4552 0, -668, 0, 0, -668, 231, 0, 0, 0, 0,
4553 790, 0, 0, 0, 0, -668, -668, -668, -668, -668,
4554 -668, -668, -668, -668, -668, -668, -668, -668, 0, 0,
4555 0, 0, 0, -668, -668, -668, -668, 0, 0, -668,
4556 -668, -668, 0, 621, 622, 0, 0, 623, 0, 0,
4557 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4558 0, 0, 0, 0, 0, 0, 231, 179, 180, 181,
4559 182, 183, 184, 185, 186, 187, 231, 0, 188, 189,
4560 0, 0, 0, 0, 190, 191, 192, 193, 849, 849,
4561 0, 231, 762, 762, 849, 0, 0, 0, 0, 194,
4562 195, 0, 0, 0, 0, 849, 849, 0, 0, 231,
4563 0, 231, 0, 0, 0, 0, 0, 0, 0, 0,
4564 0, 849, 0, 0, 0, 0, 0, 0, 0, 196,
4565 197, 198, 199, 200, 201, 202, 203, 204, 205, 0,
4566 206, 207, 0, 0, 0, 0, 0, 0, 208, 245,
4567 0, 0, -5, 3, 0, 4, 5, 6, 7, 8,
4568 -5, -5, -5, 9, 10, 231, -5, -5, 11, -5,
4569 12, 13, 14, 15, 16, 17, 18, -5, 0, 0,
4570 0, 0, 19, 20, 21, 22, 23, 24, 25, 0,
4571 0, 26, 0, 231, 0, 0, 0, 27, 28, 272,
4572 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
4573 0, 40, 41, 42, 43, 44, 45, 46, 0, 0,
4574 -5, 0, 231, 0, 0, 0, 0, 0, 47, 48,
4575 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4576 231, 0, 0, 49, 50, 0, 0, 0, 0, 0,
4577 0, 51, 0, 0, 52, 53, 0, 54, 55, 0,
4578 56, 0, 0, 57, 58, 59, 60, 61, 62, 63,
4579 64, 65, 0, -5, 0, 0, 0, 0, 0, 0,
4580 0, 0, 0, 0, 0, 0, 0, 0, 0, 356,
4581 357, 358, 359, 360, 361, 362, 363, 0, 365, 366,
4582 66, 67, 68, 0, 0, -5, 369, 370, 0, 0,
4583 0, -5, 0, 530, 0, 0, 762, 0, 0, 0,
4584 0, 0, 0, 0, 0, 231, 0, 0, 0, 0,
4585 0, 0, 231, 0, 0, 0, 1005, 849, 849, 0,
4586 0, 0, 0, 849, 849, 0, 0, 231, 0, 373,
4587 374, 375, 376, 377, 378, 379, 380, 381, 382, 231,
4588 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4589 0, 0, 0, 0, 0, 0, 0, 762, 849, 849,
4590 0, 849, 849, 0, 231, 0, 0, 0, 0, 0,
4591 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4592 0, 0, 0, 0, 1046, 1047, 0, 0, 231, 0,
4593 0, 0, 849, 1053, 0, 0, 0, 0, 0, 0,
4594 0, 0, 0, 0, 0, 0, 0, 849, 0, 0,
4595 0, 0, 0, 0, -788, 3, 0, 4, 5, 6,
4596 7, 8, 0, 231, 0, 9, 10, 0, 0, 0,
4597 11, 849, 12, 13, 14, 15, 16, 17, 18, 0,
4598 0, 0, 0, 0, 19, 20, 21, 22, 23, 24,
4599 25, 0, 0, 26, 0, 0, 0, 0, 0, 27,
4600 28, 272, 30, 31, 32, 33, 34, 35, 36, 37,
4601 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
4602 0, 0, 0, 356, -789, -789, -789, -789, 361, 362,
4603 47, 48, -789, -789, 0, 0, 0, 0, 0, 0,
4604 369, 370, 0, 0, 0, 49, 50, 231, 0, 0,
4605 0, 0, 0, 51, 0, 0, 52, 53, 0, 54,
4606 55, 0, 56, 0, 0, 57, 58, 59, 60, 61,
4607 62, 63, 64, 65, 0, -788, 0, 0, 0, 0,
4608 0, 0, 0, 373, 374, 375, 376, 377, 378, 379,
4609 380, 381, 382, 0, 0, 0, 0, 0, 0, 0,
4610 0, 0, 66, 67, 68, 0, 0, -788, 3, -788,
4611 4, 5, 6, 7, 8, -788, 0, 0, 9, 10,
4612 0, 0, 0, 11, 0, 12, 13, 14, 15, 16,
4613 17, 18, 0, 0, 0, 0, 0, 19, 20, 21,
4614 22, 23, 24, 25, 0, 0, 26, 0, 0, 0,
4615 0, 0, 27, 28, 29, 30, 31, 32, 33, 34,
4616 35, 36, 37, 38, 39, 0, 40, 41, 42, 43,
4617 44, 45, 46, 0, 231, 0, 356, 357, 358, 359,
4618 360, 361, 362, 47, 48, 365, 366, 0, 0, 0,
4619 0, 0, 0, 369, 370, 0, 0, 0, 49, 50,
4620 0, 0, 0, 0, 0, 0, 51, 0, 0, 52,
4621 53, 0, 54, 55, 0, 56, 0, 0, 57, 58,
4622 59, 60, 61, 62, 63, 64, 65, 0, 0, 0,
4623 0, 0, 0, 0, 0, 0, 373, 374, 375, 376,
4624 377, 378, 379, 380, 381, 382, 0, 0, 0, 0,
4625 0, 0, 0, 0, 0, 66, 67, 68, 0, 0,
4626 -5, 3, -788, 4, 5, 6, 7, 8, -788, 0,
4627 0, 9, 10, 0, 0, 0, 11, 0, 12, 13,
4628 14, 15, 16, 17, 18, 0, 0, 0, 0, 0,
4629 19, 20, 21, 22, 23, 24, 25, 0, 0, 26,
4630 0, 0, 0, 0, 0, 27, 28, 29, 30, 31,
4631 32, 33, 34, 35, 36, 37, 38, 39, 0, 40,
4632 41, 42, 43, 44, 45, 46, 0, 0, 0, 0,
4633 0, 0, 0, 0, 0, 0, 47, 48, 0, 0,
4634 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4635 0, 49, 50, 0, 0, 0, 0, 0, 0, 51,
4636 0, 0, 52, 53, 0, 54, 55, 0, 56, 0,
4637 0, 57, 58, 59, 60, 61, 62, 63, 64, 65,
4638 0, 0, 0, 0, 0, 0, 0, 0, 0, -770,
4639 0, 0, 0, 0, 0, 0, 0, -770, -770, -770,
4640 0, 0, -770, -770, -770, 0, -770, 0, 66, 67,
4641 68, 0, 0, -5, -770, -770, -770, -770, -770, 0,
4642 0, 530, 0, 0, 0, 0, -770, -770, 0, -770,
4643 -770, -770, -770, -770, 0, 0, 0, 356, 357, 358,
4644 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
4645 0, 0, 0, 0, 369, 370, 0, -770, -770, 0,
4646 0, 0, 0, 0, 0, 0, 0, -770, -770, -770,
4647 -770, -770, -770, -770, -770, -770, -770, -770, -770, -770,
4648 0, 0, 0, 0, -770, -770, -770, -770, 0, 857,
4649 -770, 0, 0, 0, 0, 372, -770, 373, 374, 375,
4650 376, 377, 378, 379, 380, 381, 382, 0, 0, 0,
4651 -770, 0, 0, -770, 249, 0, 0, 0, 0, 0,
4652 0, 0, 0, 0, -135, -770, -770, -770, -770, -770,
4653 -770, -770, -770, -770, -770, -770, -770, 0, 0, 0,
4654 0, -770, -770, -770, -770, -770, -669, 0, -770, -770,
4655 -770, 0, 0, 0, -669, -669, -669, 0, 0, -669,
4656 -669, -669, 0, -669, 0, 0, 0, 0, 0, 0,
4657 0, -669, 0, -669, -669, -669, 0, 0, 0, 0,
4658 0, 0, 0, -669, -669, 0, -669, -669, -669, -669,
4659 -669, 0, 0, 0, 356, 357, 358, 359, 360, 361,
4660 362, 363, 364, 365, 366, 367, 368, 0, 0, 0,
4661 0, 369, 370, 0, -669, -669, 0, 0, 0, 0,
4662 0, 0, 0, 0, -669, -669, -669, -669, -669, -669,
4663 -669, -669, -669, -669, -669, -669, -669, 0, 0, 0,
4664 0, -669, -669, -669, -669, 0, -669, -669, 0, 0,
4665 0, 0, 372, -669, 373, 374, 375, 376, 377, 378,
4666 379, 380, 381, 382, 0, 0, 0, -669, 0, 0,
4667 -669, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4668 0, -669, -669, -669, -669, -669, -669, -669, -669, -669,
4669 -669, -669, -669, -669, 0, 0, 0, 0, 0, -669,
4670 -669, -669, -669, -771, 0, -669, -669, -669, 0, 0,
4671 0, -771, -771, -771, 0, 0, -771, -771, -771, 0,
4672 -771, 0, 0, 0, 0, 0, 0, 0, -771, -771,
4673 -771, -771, -771, 0, 0, 0, 0, 0, 0, 0,
4674 -771, -771, 0, -771, -771, -771, -771, -771, 0, 0,
4675 0, 356, 357, 358, 359, 360, 361, 362, 363, 364,
4676 365, 366, -789, -789, 0, 0, 0, 0, 369, 370,
4677 0, -771, -771, 0, 0, 0, 0, 0, 0, 0,
4678 0, -771, -771, -771, -771, -771, -771, -771, -771, -771,
4679 -771, -771, -771, -771, 0, 0, 0, 0, -771, -771,
4680 -771, -771, 0, 0, -771, 0, 0, 0, 0, 0,
4681 -771, 373, 374, 375, 376, 377, 378, 379, 380, 381,
4682 382, 0, 0, 0, -771, 0, 0, -771, 0, 0,
4683 0, 0, 0, 0, 0, 0, 0, 0, 0, -771,
4684 -771, -771, -771, -771, -771, -771, -771, -771, -771, -771,
4685 -771, 0, 0, 0, 0, -771, -771, -771, -771, -771,
4686 -772, 0, -771, -771, -771, 0, 0, 0, -772, -772,
4687 -772, 0, 0, -772, -772, -772, 0, -772, 0, 0,
4688 0, 0, 0, 0, 0, -772, -772, -772, -772, -772,
4689 0, 0, 0, 0, 0, 0, 0, -772, -772, 0,
4690 -772, -772, -772, -772, -772, 0, 0, 0, 0, 0,
4691 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4692 0, 0, 0, 0, 0, 0, 0, 0, -772, -772,
4693 0, 0, 0, 0, 0, 0, 0, 0, -772, -772,
4694 -772, -772, -772, -772, -772, -772, -772, -772, -772, -772,
4695 -772, 0, 0, 0, 0, -772, -772, -772, -772, 0,
4696 0, -772, 0, 0, 0, 0, 0, -772, 0, 0,
4697 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4698 0, -772, 0, 0, -772, 0, 0, 0, 0, 0,
4699 0, 0, 0, 0, 0, 0, -772, -772, -772, -772,
4700 -772, -772, -772, -772, -772, -772, -772, -772, 0, 0,
4701 0, 0, -772, -772, -772, -772, -772, -485, 0, -772,
4702 -772, -772, 0, 0, 0, -485, -485, -485, 0, 0,
4703 -485, -485, -485, 0, -485, 0, 0, 0, 0, 0,
4704 0, 0, -485, -485, -485, -485, 0, 0, 0, 0,
4705 0, 0, 0, 0, -485, -485, 0, -485, -485, -485,
4706 -485, -485, 0, 0, 0, 0, 0, 0, 0, 0,
4707 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4708 0, 0, 0, 0, 0, -485, -485, 0, 0, 0,
4709 0, 0, 0, 0, 0, -485, -485, -485, -485, -485,
4710 -485, -485, -485, -485, -485, -485, -485, -485, 0, 0,
4711 0, 0, -485, -485, -485, -485, 0, 0, -485, 0,
4712 0, 0, 0, 0, -485, 0, 0, 0, 0, 0,
4713 0, 0, 0, 0, 0, 0, 0, 0, -485, 0,
4714 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4715 0, 0, 0, -485, 0, -485, -485, -485, -485, -485,
4716 -485, -485, -485, -485, -485, 0, 0, 0, 0, -485,
4717 -485, -485, -485, -485, -332, 245, -485, -485, -485, 0,
4718 0, 0, -332, -332, -332, 0, 0, -332, -332, -332,
4719 0, -332, 0, 0, 0, 0, 0, 0, 0, -332,
4720 0, -332, -332, -332, 0, 0, 0, 0, 0, 0,
4721 0, -332, -332, 0, -332, -332, -332, -332, -332, 0,
4722 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4723 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4724 0, 0, -332, -332, 0, 0, 0, 0, 0, 0,
4725 0, 0, -332, -332, -332, -332, -332, -332, -332, -332,
4726 -332, -332, -332, -332, -332, 0, 0, 0, 0, -332,
4727 -332, -332, -332, 0, 0, -332, 0, 0, 0, 0,
4728 0, -332, 0, 0, 0, 0, 0, 0, 0, 0,
4729 0, 0, 0, 0, 0, -332, 0, 0, -332, 0,
4730 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4731 -332, -332, -332, -332, -332, -332, -332, -332, -332, -332,
4732 -332, -332, 0, 0, 0, 0, 0, -332, -332, -332,
4733 -332, -788, 0, -332, -332, -332, 0, 0, 0, -788,
4734 -788, -788, 0, 0, -788, -788, -788, 0, -788, 0,
4735 0, 0, 0, 0, 0, 0, -788, -788, -788, -788,
4736 0, 0, 0, 0, 0, 0, 0, 0, -788, -788,
4737 0, -788, -788, -788, -788, -788, 0, 0, 0, 0,
4738 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4739 0, 0, 0, 0, 0, 0, 0, 0, 0, -788,
4740 -788, 0, 0, 0, 0, 0, 0, 0, 0, -788,
4741 -788, -788, -788, -788, -788, -788, -788, -788, -788, -788,
4742 -788, -788, 0, 0, 0, 0, -788, -788, -788, -788,
4743 0, 0, -788, 0, 0, 0, 0, 0, -788, 0,
4744 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4745 0, 0, -788, 0, 0, 0, 0, 0, 0, 0,
4746 0, 0, 0, 0, 0, 0, 0, -788, 0, -788,
4747 -788, -788, -788, -788, -788, -788, -788, -788, -788, 0,
4748 0, 0, 0, -788, -788, -788, -788, -788, -338, 245,
4749 -788, -788, -788, 0, 0, 0, -338, -338, -338, 0,
4750 0, -338, -338, -338, 0, -338, 0, 0, 0, 0,
4751 0, 0, 0, -338, 0, -338, -338, 0, 0, 0,
4752 0, 0, 0, 0, 0, -338, -338, 0, -338, -338,
4753 -338, -338, -338, 0, 0, 0, 0, 0, 0, 0,
4754 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4755 0, 0, 0, 0, 0, 0, -338, -338, 0, 0,
4756 0, 0, 0, 0, 0, 0, -338, -338, -338, -338,
4757 -338, -338, -338, -338, -338, -338, -338, -338, -338, 0,
4758 0, 0, 0, -338, -338, -338, -338, 0, 858, -338,
4759 0, 0, 0, 0, 0, -338, 0, 0, 0, 0,
4760 0, 0, 0, 0, 0, 0, 0, 0, 0, -338,
4761 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4762 0, 0, 0, -137, -338, 0, -338, -338, -338, -338,
4763 -338, -338, -338, -338, -338, -338, 0, 0, 0, 0,
4764 801, -338, -338, -338, -338, -345, 0, -338, -338, -338,
4765 0, 0, 0, -345, -345, -345, 0, 0, -345, -345,
4766 -345, 0, -345, 0, 0, 0, 0, 0, 0, 0,
4767 -345, 0, -345, -345, 0, 0, 0, 0, 0, 0,
4768 0, 0, -345, -345, 0, -345, -345, -345, -345, -345,
4769 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4770 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4771 0, 0, 0, -345, -345, 0, 0, 0, 0, 0,
4772 0, 0, 0, -345, -345, -345, -345, -345, -345, -345,
4773 -345, -345, -345, -345, -345, -345, 0, 0, 0, 0,
4774 -345, -345, -345, -345, 0, 0, -345, 0, 0, 0,
4775 0, 0, -345, 0, 0, 0, 0, 0, 0, 0,
4776 0, 0, 0, 0, 0, 0, -345, 0, 0, 0,
4777 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4778 0, -345, 0, -345, -345, -345, -345, -345, -345, -345,
4779 -345, -345, -345, 0, 0, 0, 0, 0, -345, -345,
4780 -345, -345, -770, 435, -345, -345, -345, 0, 0, 0,
4781 -770, -770, -770, 0, 0, 0, -770, -770, 0, -770,
4782 0, 0, 0, 0, 0, 0, 0, -770, -770, 0,
4783 0, 0, 0, 0, 0, 0, 0, 0, 0, -770,
4784 -770, 0, -770, -770, -770, -770, -770, 0, 0, 0,
4785 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4786 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4787 -770, -770, 0, 0, 0, 0, 0, 0, 0, 0,
4788 -770, -770, -770, -770, -770, -770, -770, -770, -770, -770,
4789 -770, -770, -770, 0, 0, 0, 0, -770, -770, -770,
4790 -770, 0, 799, -770, 0, 0, 0, 0, 0, 0,
4791 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4792 0, 0, 0, -770, 0, 0, 0, 0, 0, 0,
4793 0, 0, 0, 0, 0, 0, 0, -135, -770, 0,
4794 -770, -770, -770, -770, -770, -770, -770, -770, -770, -770,
4795 0, 0, 0, 0, -770, -770, -770, -770, -126, -770,
4796 0, -770, 0, -770, 0, 0, 0, -770, -770, -770,
4797 0, 0, 0, -770, -770, 0, -770, 0, 0, 0,
4798 0, 0, 0, 0, -770, -770, 0, 0, 0, 0,
4799 0, 0, 0, 0, 0, 0, -770, -770, 0, -770,
4800 -770, -770, -770, -770, 0, 0, 0, 0, 0, 0,
4801 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4802 0, 0, 0, 0, 0, 0, 0, -770, -770, 0,
4803 0, 0, 0, 0, 0, 0, 0, -770, -770, -770,
4804 -770, -770, -770, -770, -770, -770, -770, -770, -770, -770,
4805 0, 0, 0, 0, -770, -770, -770, -770, 0, 799,
4806 -770, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4807 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4808 -770, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4809 0, 0, 0, 0, -135, -770, 0, -770, -770, -770,
4810 -770, -770, -770, -770, -770, -770, -770, 0, 0, 0,
4811 0, -770, -770, -770, -770, -770, -338, 0, -770, 0,
4812 -770, 0, 0, 0, -338, -338, -338, 0, 0, 0,
4813 -338, -338, 0, -338, 0, 0, 0, 0, 0, 0,
4814 0, -338, 0, 0, 0, 0, 0, 0, 0, 0,
4815 0, 0, 0, -338, -338, 0, -338, -338, -338, -338,
4816 -338, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4817 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4818 0, 0, 0, 0, -338, -338, 0, 0, 0, 0,
4819 0, 0, 0, 0, -338, -338, -338, -338, -338, -338,
4820 -338, -338, -338, -338, -338, -338, -338, 0, 0, 0,
4821 0, -338, -338, -338, -338, 0, 800, -338, 0, 0,
4822 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4823 0, 0, 0, 0, 0, 0, 0, -338, 0, 0,
4824 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4825 0, -137, -338, 0, -338, -338, -338, -338, -338, -338,
4826 -338, -338, -338, -338, 0, 0, 0, 0, 801, -338,
4827 -338, -338, -128, -338, 0, -338, 0, -338, 0, 0,
4828 0, -338, -338, -338, 0, 0, 0, -338, -338, 0,
4829 -338, 0, 0, 0, 0, 0, 0, 0, -338, 0,
4830 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4831 -338, -338, 0, -338, -338, -338, -338, -338, 0, 0,
4832 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4833 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4834 0, -338, -338, 0, 0, 0, 0, 0, 0, 0,
4835 0, -338, -338, -338, -338, -338, -338, -338, -338, -338,
4836 -338, -338, -338, -338, 0, 0, 0, 0, -338, -338,
4837 -338, -338, 0, 800, -338, 0, 0, 0, 0, 0,
4838 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4839 0, 0, 0, 0, -338, 0, 0, 0, 0, 0,
4840 0, 0, 0, 0, 0, 0, 0, 0, -137, -338,
4841 0, -338, -338, -338, -338, -338, -338, -338, -338, -338,
4842 -338, 0, 0, 0, 0, 801, -338, -338, -338, -338,
4843 0, 0, -338, 3, -338, 4, 5, 6, 7, 8,
4844 -788, -788, -788, 9, 10, 0, 0, -788, 11, 0,
4845 12, 13, 14, 15, 16, 17, 18, 0, 0, 0,
4846 0, 0, 19, 20, 21, 22, 23, 24, 25, 0,
4847 0, 26, 0, 0, 0, 0, 0, 27, 28, 272,
4848 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
4849 0, 40, 41, 42, 43, 44, 45, 46, 0, 0,
4850 -788, 0, 0, 0, 0, 0, 0, 0, 47, 48,
4851 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4852 0, 0, 0, 49, 50, 0, 0, 0, 0, 0,
4853 0, 51, 0, 0, 52, 53, 0, 54, 55, 0,
4854 56, 0, 0, 57, 58, 59, 60, 61, 62, 63,
4855 64, 65, 0, 0, 0, 0, 0, 0, 0, 0,
4856 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4857 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4858 66, 67, 68, 0, 0, 0, 3, -788, 4, 5,
4859 6, 7, 8, -788, 0, -788, 9, 10, 0, -788,
4860 -788, 11, 0, 12, 13, 14, 15, 16, 17, 18,
4861 0, 0, 0, 0, 0, 19, 20, 21, 22, 23,
4862 24, 25, 0, 0, 26, 0, 0, 0, 0, 0,
4863 27, 28, 272, 30, 31, 32, 33, 34, 35, 36,
4864 37, 38, 39, 0, 40, 41, 42, 43, 44, 45,
4865 46, 0, 0, -788, 0, 0, 0, 0, 0, 0,
4866 0, 47, 48, 0, 0, 0, 0, 0, 0, 0,
4867 0, 0, 0, 0, 0, 0, 49, 50, 0, 0,
4868 0, 0, 0, 0, 51, 0, 0, 52, 53, 0,
4869 54, 55, 0, 56, 0, 0, 57, 58, 59, 60,
4870 61, 62, 63, 64, 65, 0, 0, 0, 0, 0,
4871 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4872 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4873 0, 0, 0, 66, 67, 68, 0, 0, 0, 3,
4874 -788, 4, 5, 6, 7, 8, -788, 0, -788, 9,
4875 10, 0, 0, -788, 11, -788, 12, 13, 14, 15,
4876 16, 17, 18, 0, 0, 0, 0, 0, 19, 20,
4877 21, 22, 23, 24, 25, 0, 0, 26, 0, 0,
4878 0, 0, 0, 27, 28, 272, 30, 31, 32, 33,
4879 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
4880 43, 44, 45, 46, 0, 0, -788, 0, 0, 0,
4881 0, 0, 0, 0, 47, 48, 0, 0, 0, 0,
4882 0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
4883 50, 0, 0, 0, 0, 0, 0, 51, 0, 0,
4884 52, 53, 0, 54, 55, 0, 56, 0, 0, 57,
4885 58, 59, 60, 61, 62, 63, 64, 65, 0, 0,
4886 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4887 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4888 0, 0, 0, 0, 0, 0, 66, 67, 68, 0,
4889 0, 0, 3, -788, 4, 5, 6, 7, 8, -788,
4890 0, -788, 9, 10, 0, 0, -788, 11, 0, 12,
4891 13, 14, 15, 16, 17, 18, -788, 0, 0, 0,
4892 0, 19, 20, 21, 22, 23, 24, 25, 0, 0,
4893 26, 0, 0, 0, 0, 0, 27, 28, 272, 30,
4894 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
4895 40, 41, 42, 43, 44, 45, 46, 0, 0, -788,
4896 0, 0, 0, 0, 0, 0, 0, 47, 48, 0,
4897 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4898 0, 0, 49, 50, 0, 0, 0, 0, 0, 0,
4899 51, 0, 0, 52, 53, 0, 54, 55, 0, 56,
4900 0, 0, 57, 58, 59, 60, 61, 62, 63, 64,
4901 65, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4902 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4903 0, 0, 0, 0, 0, 0, 0, 0, 0, 66,
4904 67, 68, 0, 0, 0, 3, -788, 4, 5, 6,
4905 7, 8, -788, 0, -788, 9, 10, 0, 0, -788,
4906 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
4907 0, 0, 0, 0, 19, 20, 21, 22, 23, 24,
4908 25, 0, 0, 26, 0, 0, 0, 0, 0, 27,
4909 28, 272, 30, 31, 32, 33, 34, 35, 36, 37,
4910 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
4911 0, 0, -788, 0, 0, 0, 0, 0, 0, 0,
4912 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
4913 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
4914 0, 0, 0, 51, 0, 0, 52, 53, 0, 54,
4915 55, 0, 56, 0, 0, 57, 58, 59, 60, 61,
4916 62, 63, 64, 65, 0, 0, 0, 0, 0, 0,
4917 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4918 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4919 0, 0, 66, 67, 68, 0, 0, 0, 3, -788,
4920 4, 5, 6, 7, 8, -788, -788, -788, 9, 10,
4921 0, 0, 0, 11, 0, 12, 13, 14, 15, 16,
4922 17, 18, 0, 0, 0, 0, 0, 19, 20, 21,
4923 22, 23, 24, 25, 0, 0, 26, 0, 0, 0,
4924 0, 0, 27, 28, 272, 30, 31, 32, 33, 34,
4925 35, 36, 37, 38, 39, 0, 40, 41, 42, 43,
4926 44, 45, 46, 0, 0, -788, 0, 0, 0, 0,
4927 0, 0, 0, 47, 48, 0, 0, 0, 0, 0,
4928 0, 0, 0, 0, 0, 0, 0, 0, 49, 50,
4929 0, 0, 0, 0, 0, 0, 51, 0, 0, 52,
4930 53, 0, 54, 55, 0, 56, 0, 0, 57, 58,
4931 59, 60, 61, 62, 63, 64, 65, 0, 0, 0,
4932 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4933 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4934 0, 0, 0, 0, 0, 66, 67, 68, 0, 0,
4935 0, 3, -788, 4, 5, 6, 7, 8, -788, 0,
4936 -788, 9, 10, 0, 0, 0, 11, 0, 12, 13,
4937 14, 15, 16, 17, 18, 0, 0, 0, 0, 0,
4938 19, 20, 21, 22, 23, 24, 25, 0, 0, 26,
4939 0, 0, 0, 0, 0, 27, 28, 272, 30, 31,
4940 32, 33, 34, 35, 36, 37, 38, 39, 0, 40,
4941 41, 42, 43, 44, 45, 46, 0, 0, -788, 0,
4942 0, 0, 0, 0, 0, 0, 47, 48, 0, 0,
4943 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4944 0, 49, 50, 0, 0, 0, 0, 0, 0, 51,
4945 0, 0, 52, 53, 0, 54, 55, 0, 56, 0,
4946 0, 57, 58, 59, 60, 61, 62, 63, 64, 65,
4947 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4948 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4949 0, 0, 0, 0, 0, 0, 0, 0, 66, 67,
4950 68, 0, 0, 0, 3, -788, 4, 5, 6, 7,
4951 8, -788, 0, 0, 9, 10, 0, 0, 0, 11,
4952 0, 12, 13, 14, 15, 16, 17, 18, 0, 0,
4953 0, 0, 0, 19, 20, 21, 22, 23, 24, 25,
4954 0, 0, 26, 0, 0, 0, 0, 0, 27, 28,
4955 272, 30, 31, 32, 33, 34, 35, 36, 37, 38,
4956 39, 0, 40, 41, 42, 43, 44, 45, 46, 0,
4957 0, 0, 0, 0, 0, 0, 0, 0, 0, 47,
4958 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4959 0, 0, 0, 0, 49, 50, 0, 0, 0, 0,
4960 0, 0, 51, 0, 0, 273, 53, 0, 54, 55,
4961 0, 56, 0, 0, 57, 58, 59, 60, 61, 62,
4962 63, 64, 65, 0, 0, 0, 0, 0, 0, 0,
4963 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4964 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4965 0, 66, 67, 68, 0, 0, 0, 0, -788, 0,
4966 0, 0, -788, 3, -788, 4, 5, 6, 7, 8,
4967 0, 0, 0, 9, 10, 0, 0, 0, 11, 0,
4968 12, 13, 14, 15, 16, 17, 18, 0, 0, 0,
4969 0, 0, 19, 20, 21, 22, 23, 24, 25, 0,
4970 0, 26, 0, 0, 0, 0, 0, 27, 28, 272,
4971 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
4972 0, 40, 41, 42, 43, 44, 45, 46, 0, 0,
4973 0, 0, 0, 0, 0, 0, 0, 0, 47, 48,
4974 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4975 0, 0, 0, 49, 50, 0, 0, 0, 0, 0,
4976 0, 51, 0, 0, 52, 53, 0, 54, 55, 0,
4977 56, 0, 0, 57, 58, 59, 60, 61, 62, 63,
4978 64, 65, 0, 0, 0, 0, 0, 0, 0, 0,
4979 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4980 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4981 66, 67, 68, 0, 0, 0, 0, -788, 0, 0,
4982 0, -788, 3, -788, 4, 5, 6, 7, 8, 0,
4983 0, 0, 9, 10, 0, 0, 0, 11, 0, 12,
4984 13, 14, 15, 16, 17, 18, 0, 0, 0, 0,
4985 0, 19, 20, 21, 22, 23, 24, 25, 0, 0,
4986 26, 0, 0, 0, 0, 0, 27, 28, 29, 30,
4987 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
4988 40, 41, 42, 43, 44, 45, 46, 0, 0, 0,
4989 0, 0, 0, 0, 0, 0, 0, 47, 48, 0,
4990 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4991 0, 0, 49, 50, 0, 0, 0, 0, 0, 0,
4992 51, 0, 0, 52, 53, 0, 54, 55, 0, 56,
4993 0, 0, 57, 58, 59, 60, 61, 62, 63, 64,
4994 65, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4995 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4996 0, 0, 0, 0, 0, 0, 0, 0, 0, 66,
4997 67, 68, 0, 0, -788, 3, -788, 4, 5, 6,
4998 7, 8, -788, 0, 0, 9, 10, 0, 0, 0,
4999 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5000 0, 0, 0, 0, 19, 20, 21, 22, 23, 24,
5001 25, 0, 0, 26, 0, 0, 0, 0, 0, 27,
5002 28, 272, 30, 31, 32, 33, 34, 35, 36, 37,
5003 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5004 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5005 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5006 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5007 0, 0, 0, 51, 0, 0, 52, 53, 0, 54,
5008 55, 0, 56, 0, 0, 57, 58, 59, 60, 61,
5009 62, 63, 64, 65, 0, 0, 0, 0, 0, 0,
5010 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5011 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5012 0, 0, 66, 67, 68, 0, 0, -788, 391, -788,
5013 4, 5, 6, 0, 8, -788, 0, 0, 9, 10,
5014 0, 0, 0, 11, -4, 12, 13, 14, 15, 16,
5015 17, 18, 0, 0, 0, 0, 0, 19, 20, 21,
5016 22, 23, 24, 25, 0, 0, 26, 0, 0, 0,
5017 0, 0, 0, 28, 0, 0, 31, 32, 33, 34,
5018 35, 36, 37, 38, 39, 0, 40, 41, 42, 43,
5019 44, 45, 46, 0, 0, 0, 0, 0, 0, 0,
5020 0, 0, 0, 47, 48, 0, 0, 0, 0, 0,
5021 0, 0, 0, 0, 0, 0, 0, 0, 49, 50,
5022 0, 0, 0, 0, 0, 0, 220, 0, 0, 221,
5023 53, 0, 54, 55, 0, 0, 0, 0, 57, 58,
5024 59, 60, 61, 62, 63, 64, 65, 0, 0, 0,
5025 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5026 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5027 0, 0, 0, 0, 0, 66, 67, 68, 0, 0,
5028 0, 0, 319, 0, 0, 0, 0, 0, 320, 135,
5029 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
5030 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
5031 156, 157, 158, 0, 0, 0, 159, 160, 161, 420,
5032 421, 422, 423, 166, 167, 168, 0, 0, 0, 0,
5033 0, 169, 170, 171, 172, 424, 425, 426, 427, 177,
5034 36, 37, 428, 39, 0, 0, 0, 0, 0, 0,
5035 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5036 0, 0, 179, 180, 181, 182, 183, 184, 185, 186,
5037 187, 0, 0, 188, 189, 0, 0, 0, 0, 190,
5038 191, 192, 193, 0, 0, 0, 0, 0, 0, 0,
5039 0, 0, 0, 0, 194, 195, 0, 0, 0, 0,
5040 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5041 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5042 0, 0, 0, 0, 196, 197, 198, 199, 200, 201,
5043 202, 203, 204, 205, 0, 206, 207, 0, 0, 0,
5044 0, 0, 0, 208, 429, 135, 136, 137, 138, 139,
5045 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
5046 150, 151, 152, 153, 154, 155, 156, 157, 158, 0,
5047 0, 0, 159, 160, 161, 162, 163, 164, 165, 166,
5048 167, 168, 0, 0, 0, 0, 0, 169, 170, 171,
5049 172, 173, 174, 175, 176, 177, 36, 37, 178, 39,
5050 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5051 0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
5052 181, 182, 183, 184, 185, 186, 187, 0, 0, 188,
5053 189, 0, 0, 0, 0, 190, 191, 192, 193, 0,
5054 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5055 194, 195, 0, 0, 0, 0, 0, 0, 0, 0,
5056 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5057 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5058 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
5059 0, 206, 207, 0, 0, 0, 0, 0, 0, 208,
5060 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
5061 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
5062 155, 156, 157, 158, 0, 0, 0, 159, 160, 161,
5063 162, 163, 164, 165, 166, 167, 168, 0, 0, 0,
5064 0, 0, 169, 170, 171, 172, 173, 174, 175, 176,
5065 177, 252, 0, 178, 0, 0, 0, 0, 0, 0,
5066 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5067 0, 0, 0, 179, 180, 181, 182, 183, 184, 185,
5068 186, 187, 0, 0, 188, 189, 0, 0, 0, 0,
5069 190, 191, 192, 193, 0, 0, 0, 0, 0, 0,
5070 0, 0, 0, 0, 0, 194, 195, 0, 0, 58,
5071 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5072 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5073 0, 0, 0, 0, 0, 196, 197, 198, 199, 200,
5074 201, 202, 203, 204, 205, 0, 206, 207, 0, 0,
5075 0, 0, 0, 0, 208, 135, 136, 137, 138, 139,
5076 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
5077 150, 151, 152, 153, 154, 155, 156, 157, 158, 0,
5078 0, 0, 159, 160, 161, 162, 163, 164, 165, 166,
5079 167, 168, 0, 0, 0, 0, 0, 169, 170, 171,
5080 172, 173, 174, 175, 176, 177, 0, 0, 178, 0,
5081 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5082 0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
5083 181, 182, 183, 184, 185, 186, 187, 0, 0, 188,
5084 189, 0, 0, 0, 0, 190, 191, 192, 193, 0,
5085 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5086 194, 195, 0, 0, 58, 0, 0, 0, 0, 0,
5087 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5088 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5089 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
5090 0, 206, 207, 0, 0, 0, 0, 0, 0, 208,
5091 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
5092 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
5093 155, 156, 157, 158, 0, 0, 0, 159, 160, 161,
5094 162, 163, 164, 165, 166, 167, 168, 0, 0, 0,
5095 0, 0, 169, 170, 171, 172, 173, 174, 175, 176,
5096 177, 0, 0, 178, 0, 0, 0, 0, 0, 0,
5097 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5098 0, 0, 0, 179, 180, 181, 182, 183, 184, 185,
5099 186, 187, 0, 0, 188, 189, 0, 0, 0, 0,
5100 190, 191, 192, 193, 0, 0, 0, 0, 0, 0,
5101 0, 0, 0, 0, 0, 194, 195, 0, 0, 0,
5102 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5103 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5104 0, 0, 0, 0, 0, 196, 197, 198, 199, 200,
5105 201, 202, 203, 204, 205, 0, 206, 207, 4, 5,
5106 6, 0, 8, 0, 208, 0, 9, 10, 0, 0,
5107 0, 11, 0, 12, 13, 14, 260, 261, 17, 18,
5108 0, 0, 0, 0, 0, 19, 20, 262, 22, 23,
5109 24, 25, 0, 0, 218, 0, 0, 0, 0, 0,
5110 0, 290, 0, 0, 31, 32, 33, 34, 35, 36,
5111 37, 38, 39, 0, 40, 41, 42, 43, 44, 45,
5112 46, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5115 0, 0, 0, 0, 291, 0, 0, 221, 53, 0,
5116 54, 55, 0, 0, 0, 0, 57, 58, 59, 60,
5117 61, 62, 63, 64, 65, 0, 0, 4, 5, 6,
5118 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5119 11, 0, 12, 13, 14, 260, 261, 17, 18, 0,
5120 0, 0, 0, 292, 19, 20, 262, 22, 23, 24,
5121 25, 293, 0, 218, 0, 0, 0, 0, 0, 0,
5122 290, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5123 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5124 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5125 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5126 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5127 0, 0, 0, 291, 0, 0, 221, 53, 0, 54,
5128 55, 0, 0, 0, 0, 57, 58, 59, 60, 61,
5129 62, 63, 64, 65, 0, 0, 4, 5, 6, 0,
5130 8, 0, 0, 0, 9, 10, 0, 0, 0, 11,
5131 0, 12, 13, 14, 15, 16, 17, 18, 0, 0,
5132 0, 0, 292, 19, 20, 21, 22, 23, 24, 25,
5133 591, 0, 218, 0, 0, 0, 0, 0, 0, 28,
5134 0, 0, 31, 32, 33, 34, 35, 36, 37, 38,
5135 39, 219, 40, 41, 42, 43, 44, 45, 46, 0,
5136 0, 0, 0, 0, 0, 0, 0, 0, 0, 47,
5137 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5138 0, 0, 0, 0, 49, 50, 0, 0, 0, 0,
5139 0, 0, 220, 0, 0, 221, 53, 0, 54, 55,
5140 0, 222, 223, 224, 57, 58, 225, 60, 61, 62,
5141 63, 64, 65, 0, 0, 0, 0, 0, 0, 0,
5142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5143 0, 0, 0, 0, 0, 0, 4, 5, 6, 0,
5144 8, 66, 226, 68, 9, 10, 0, 0, 249, 11,
5145 0, 12, 13, 14, 15, 16, 17, 18, 0, 0,
5146 0, 0, 0, 19, 20, 21, 22, 23, 24, 25,
5147 0, 0, 26, 0, 0, 0, 0, 0, 0, 28,
5148 0, 0, 31, 32, 33, 34, 35, 36, 37, 38,
5149 39, 0, 40, 41, 42, 43, 44, 45, 46, 0,
5150 0, 0, 0, 0, 0, 0, 0, 0, 0, 47,
5151 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5152 0, 0, 0, 0, 49, 50, 0, 0, 0, 0,
5153 0, 0, 220, 0, 0, 221, 53, 0, 54, 55,
5154 0, 0, 0, 0, 57, 58, 59, 60, 61, 62,
5155 63, 64, 65, 0, 0, 0, 0, 0, 0, 0,
5156 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5157 0, 0, 0, 0, 3, 0, 4, 5, 6, 7,
5158 8, 66, 67, 68, 9, 10, 0, 0, 249, 11,
5159 0, 12, 13, 14, 15, 16, 17, 18, 0, 0,
5160 0, 0, 0, 19, 20, 21, 22, 23, 24, 25,
5161 0, 0, 26, 0, 0, 0, 0, 0, 27, 28,
5162 0, 30, 31, 32, 33, 34, 35, 36, 37, 38,
5163 39, 0, 40, 41, 42, 43, 44, 45, 46, 0,
5164 0, 0, 0, 0, 0, 0, 0, 0, 0, 47,
5165 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5166 0, 0, 0, 0, 49, 50, 0, 0, 0, 0,
5167 0, 0, 51, 0, 0, 52, 53, 0, 54, 55,
5168 0, 56, 0, 0, 57, 58, 59, 60, 61, 62,
5169 63, 64, 65, 0, 0, 391, 0, 4, 5, 6,
5170 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5171 11, 0, 12, 13, 14, 15, 16, 17, 18, 0,
5172 0, 66, 67, 68, 19, 20, 21, 22, 23, 24,
5173 25, 0, 0, 26, 0, 0, 0, 0, 0, 0,
5174 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5175 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5176 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5177 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5178 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5179 0, 0, 0, 220, 0, 0, 221, 53, 0, 54,
5180 55, 0, 0, 0, 0, 57, 58, 59, 60, 61,
5181 62, 63, 64, 65, 0, 0, 0, 0, 4, 5,
5182 6, 0, 8, 0, 0, 0, 9, 10, 0, 0,
5183 0, 11, 0, 12, 13, 14, 15, 16, 17, 18,
5184 0, 0, 66, 67, 68, 19, 20, 21, 22, 23,
5185 24, 25, 0, 0, 218, 0, 0, 0, 0, 0,
5186 0, 28, 0, 0, 31, 32, 33, 34, 35, 36,
5187 37, 38, 39, 219, 40, 41, 42, 43, 44, 45,
5188 46, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5189 0, 47, 48, 0, 0, 0, 0, 0, 0, 0,
5190 0, 0, 0, 0, 0, 0, 49, 50, 0, 0,
5191 0, 0, 0, 0, 220, 0, 0, 221, 53, 0,
5192 54, 55, 0, 222, 223, 224, 57, 58, 225, 60,
5193 61, 62, 63, 64, 65, 0, 0, 0, 0, 4,
5194 5, 6, 0, 8, 0, 0, 0, 9, 10, 0,
5195 0, 0, 11, 0, 12, 13, 14, 15, 16, 17,
5196 18, 0, 0, 66, 226, 68, 19, 20, 21, 22,
5197 23, 24, 25, 0, 0, 218, 0, 0, 0, 0,
5198 0, 0, 28, 0, 0, 31, 32, 33, 34, 35,
5199 36, 37, 38, 39, 219, 40, 41, 42, 43, 44,
5200 45, 46, 0, 0, 0, 0, 0, 0, 0, 0,
5201 0, 0, 47, 48, 0, 0, 0, 0, 0, 0,
5202 0, 0, 0, 0, 0, 0, 0, 49, 465, 0,
5203 0, 0, 0, 0, 0, 220, 0, 0, 221, 53,
5204 0, 54, 55, 0, 222, 223, 224, 57, 58, 225,
5205 60, 61, 62, 63, 64, 65, 0, 0, 0, 0,
5206 4, 5, 6, 0, 8, 0, 0, 0, 9, 10,
5207 0, 0, 0, 11, 0, 12, 13, 14, 260, 261,
5208 17, 18, 0, 0, 66, 226, 68, 19, 20, 262,
5209 22, 23, 24, 25, 0, 0, 218, 0, 0, 0,
5210 0, 0, 0, 28, 0, 0, 31, 32, 33, 34,
5211 35, 36, 37, 38, 39, 219, 40, 41, 42, 43,
5212 44, 45, 46, 0, 0, 0, 0, 0, 0, 0,
5213 0, 0, 0, 47, 48, 0, 0, 0, 0, 0,
5214 0, 0, 0, 0, 0, 0, 0, 0, 49, 50,
5215 0, 0, 0, 0, 0, 0, 220, 0, 0, 221,
5216 53, 0, 54, 55, 0, 222, 223, 224, 57, 58,
5217 225, 60, 61, 62, 63, 64, 65, 0, 0, 0,
5218 0, 4, 5, 6, 0, 8, 0, 0, 0, 9,
5219 10, 0, 0, 0, 11, 0, 12, 13, 14, 260,
5220 261, 17, 18, 0, 0, 66, 226, 68, 19, 20,
5221 262, 22, 23, 24, 25, 0, 0, 218, 0, 0,
5222 0, 0, 0, 0, 28, 0, 0, 31, 32, 33,
5223 34, 35, 36, 37, 38, 39, 219, 40, 41, 42,
5224 43, 44, 45, 46, 0, 0, 0, 0, 0, 0,
5225 0, 0, 0, 0, 47, 48, 0, 0, 0, 0,
5226 0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
5227 465, 0, 0, 0, 0, 0, 0, 220, 0, 0,
5228 221, 53, 0, 54, 55, 0, 222, 223, 224, 57,
5229 58, 225, 60, 61, 62, 63, 64, 65, 0, 0,
5230 0, 0, 4, 5, 6, 0, 8, 0, 0, 0,
5231 9, 10, 0, 0, 0, 11, 0, 12, 13, 14,
5232 260, 261, 17, 18, 0, 0, 66, 226, 68, 19,
5233 20, 262, 22, 23, 24, 25, 0, 0, 218, 0,
5234 0, 0, 0, 0, 0, 28, 0, 0, 31, 32,
5235 33, 34, 35, 36, 37, 38, 39, 219, 40, 41,
5236 42, 43, 44, 45, 46, 0, 0, 0, 0, 0,
5237 0, 0, 0, 0, 0, 47, 48, 0, 0, 0,
5238 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5239 49, 50, 0, 0, 0, 0, 0, 0, 220, 0,
5240 0, 221, 53, 0, 54, 55, 0, 222, 223, 0,
5241 57, 58, 225, 60, 61, 62, 63, 64, 65, 0,
5242 0, 0, 0, 4, 5, 6, 0, 8, 0, 0,
5243 0, 9, 10, 0, 0, 0, 11, 0, 12, 13,
5244 14, 260, 261, 17, 18, 0, 0, 66, 226, 68,
5245 19, 20, 262, 22, 23, 24, 25, 0, 0, 218,
5246 0, 0, 0, 0, 0, 0, 28, 0, 0, 31,
5247 32, 33, 34, 35, 36, 37, 38, 39, 219, 40,
5248 41, 42, 43, 44, 45, 46, 0, 0, 0, 0,
5249 0, 0, 0, 0, 0, 0, 47, 48, 0, 0,
5250 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5251 0, 49, 50, 0, 0, 0, 0, 0, 0, 220,
5252 0, 0, 221, 53, 0, 54, 55, 0, 0, 223,
5253 224, 57, 58, 225, 60, 61, 62, 63, 64, 65,
5254 0, 0, 0, 0, 4, 5, 6, 0, 8, 0,
5255 0, 0, 9, 10, 0, 0, 0, 11, 0, 12,
5256 13, 14, 260, 261, 17, 18, 0, 0, 66, 226,
5257 68, 19, 20, 262, 22, 23, 24, 25, 0, 0,
5258 218, 0, 0, 0, 0, 0, 0, 28, 0, 0,
5259 31, 32, 33, 34, 35, 36, 37, 38, 39, 219,
5260 40, 41, 42, 43, 44, 45, 46, 0, 0, 0,
5261 0, 0, 0, 0, 0, 0, 0, 47, 48, 0,
5262 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5263 0, 0, 49, 50, 0, 0, 0, 0, 0, 0,
5264 220, 0, 0, 221, 53, 0, 54, 55, 0, 0,
5265 223, 0, 57, 58, 225, 60, 61, 62, 63, 64,
5266 65, 0, 0, 0, 0, 4, 5, 6, 0, 8,
5267 0, 0, 0, 9, 10, 0, 0, 0, 11, 0,
5268 12, 13, 14, 15, 16, 17, 18, 0, 0, 66,
5269 226, 68, 19, 20, 21, 22, 23, 24, 25, 0,
5270 0, 218, 0, 0, 0, 0, 0, 0, 28, 0,
5271 0, 31, 32, 33, 34, 35, 36, 37, 38, 39,
5272 0, 40, 41, 42, 43, 44, 45, 46, 0, 0,
5273 0, 0, 0, 0, 0, 0, 0, 0, 47, 48,
5274 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5275 0, 0, 0, 49, 50, 0, 0, 0, 0, 0,
5276 0, 220, 0, 0, 221, 53, 0, 54, 55, 0,
5277 777, 0, 0, 57, 58, 59, 60, 61, 62, 63,
5278 64, 65, 0, 0, 0, 0, 4, 5, 6, 0,
5279 8, 0, 0, 0, 9, 10, 0, 0, 0, 11,
5280 0, 12, 13, 14, 260, 261, 17, 18, 0, 0,
5281 66, 226, 68, 19, 20, 262, 22, 23, 24, 25,
5282 0, 0, 218, 0, 0, 0, 0, 0, 0, 28,
5283 0, 0, 31, 32, 33, 34, 35, 36, 37, 38,
5284 39, 0, 40, 41, 42, 43, 44, 45, 46, 0,
5285 0, 0, 0, 0, 0, 0, 0, 0, 0, 47,
5286 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5287 0, 0, 0, 0, 49, 50, 0, 0, 0, 0,
5288 0, 0, 220, 0, 0, 221, 53, 0, 54, 55,
5289 0, 943, 0, 0, 57, 58, 59, 60, 61, 62,
5290 63, 64, 65, 0, 0, 0, 0, 4, 5, 6,
5291 0, 8, 0, 0, 0, 9, 10, 0, 0, 0,
5292 11, 0, 12, 13, 14, 260, 261, 17, 18, 0,
5293 0, 66, 226, 68, 19, 20, 262, 22, 23, 24,
5294 25, 0, 0, 218, 0, 0, 0, 0, 0, 0,
5295 28, 0, 0, 31, 32, 33, 34, 35, 36, 37,
5296 38, 39, 0, 40, 41, 42, 43, 44, 45, 46,
5297 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5298 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
5299 0, 0, 0, 0, 0, 49, 50, 0, 0, 0,
5300 0, 0, 0, 220, 0, 0, 221, 53, 0, 54,
5301 55, 0, 992, 0, 0, 57, 58, 59, 60, 61,
5302 62, 63, 64, 65, 0, 0, 0, 0, 4, 5,
5303 6, 0, 8, 0, 0, 0, 9, 10, 0, 0,
5304 0, 11, 0, 12, 13, 14, 260, 261, 17, 18,
5305 0, 0, 66, 226, 68, 19, 20, 262, 22, 23,
5306 24, 25, 0, 0, 218, 0, 0, 0, 0, 0,
5307 0, 28, 0, 0, 31, 32, 33, 34, 35, 36,
5308 37, 38, 39, 0, 40, 41, 42, 43, 44, 45,
5309 46, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5310 0, 47, 48, 0, 0, 0, 0, 0, 0, 0,
5311 0, 0, 0, 0, 0, 0, 49, 50, 0, 0,
5312 0, 0, 0, 0, 220, 0, 0, 221, 53, 0,
5313 54, 55, 0, 777, 0, 0, 57, 58, 59, 60,
5314 61, 62, 63, 64, 65, 0, 0, 0, 0, 4,
5315 5, 6, 0, 8, 0, 0, 0, 9, 10, 0,
5316 0, 0, 11, 0, 12, 13, 14, 260, 261, 17,
5317 18, 0, 0, 66, 226, 68, 19, 20, 262, 22,
5318 23, 24, 25, 0, 0, 218, 0, 0, 0, 0,
5319 0, 0, 28, 0, 0, 31, 32, 33, 34, 35,
5320 36, 37, 38, 39, 0, 40, 41, 42, 43, 44,
5321 45, 46, 0, 0, 0, 0, 0, 0, 0, 0,
5322 0, 0, 47, 48, 0, 0, 0, 0, 0, 0,
5323 0, 0, 0, 0, 0, 0, 0, 49, 50, 0,
5324 0, 0, 0, 0, 0, 220, 0, 0, 221, 53,
5325 0, 54, 55, 0, 1111, 0, 0, 57, 58, 59,
5326 60, 61, 62, 63, 64, 65, 0, 0, 0, 0,
5327 4, 5, 6, 0, 8, 0, 0, 0, 9, 10,
5328 0, 0, 0, 11, 0, 12, 13, 14, 260, 261,
5329 17, 18, 0, 0, 66, 226, 68, 19, 20, 262,
5330 22, 23, 24, 25, 0, 0, 218, 0, 0, 0,
5331 0, 0, 0, 28, 0, 0, 31, 32, 33, 34,
5332 35, 36, 37, 38, 39, 0, 40, 41, 42, 43,
5333 44, 45, 46, 0, 0, 0, 0, 0, 0, 0,
5334 0, 0, 0, 47, 48, 0, 0, 0, 0, 0,
5335 0, 0, 0, 0, 0, 0, 0, 0, 49, 50,
5336 0, 0, 0, 0, 0, 0, 220, 0, 0, 221,
5337 53, 0, 54, 55, 0, 0, 0, 0, 57, 58,
5338 59, 60, 61, 62, 63, 64, 65, 0, 0, 0,
5339 0, 4, 5, 6, 0, 8, 0, 0, 0, 9,
5340 10, 0, 0, 0, 11, 0, 12, 13, 14, 15,
5341 16, 17, 18, 0, 0, 66, 226, 68, 19, 20,
5342 21, 22, 23, 24, 25, 0, 0, 218, 0, 0,
5343 0, 0, 0, 0, 28, 0, 0, 31, 32, 33,
5344 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
5345 43, 44, 45, 46, 0, 0, 0, 0, 0, 0,
5346 0, 0, 0, 0, 47, 48, 0, 0, 0, 0,
5347 0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
5348 50, 0, 0, 0, 0, 0, 0, 220, 0, 0,
5349 221, 53, 0, 54, 55, 0, 0, 0, 0, 57,
5350 58, 59, 60, 61, 62, 63, 64, 65, 0, 0,
5351 0, 0, 4, 5, 6, 0, 8, 0, 0, 0,
5352 9, 10, 0, 0, 0, 11, 0, 12, 13, 14,
5353 15, 16, 17, 18, 0, 0, 66, 226, 68, 19,
5354 20, 21, 22, 23, 24, 25, 0, 0, 26, 0,
5355 0, 0, 0, 0, 0, 28, 0, 0, 31, 32,
5356 33, 34, 35, 36, 37, 38, 39, 0, 40, 41,
5357 42, 43, 44, 45, 46, 0, 0, 0, 0, 0,
5358 0, 0, 0, 0, 0, 47, 48, 0, 0, 0,
5359 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5360 49, 50, 0, 0, 0, 0, 0, 0, 220, 0,
5361 0, 221, 53, 0, 54, 55, 0, 0, 0, 0,
5362 57, 58, 59, 60, 61, 62, 63, 64, 65, 0,
5363 0, 0, 0, 4, 5, 6, 0, 8, 0, 0,
5364 0, 9, 10, 0, 0, 0, 11, 0, 12, 13,
5365 14, 15, 16, 17, 18, 0, 0, 66, 67, 68,
5366 19, 20, 21, 22, 23, 24, 25, 0, 0, 759,
5367 0, 0, 0, 0, 0, 0, 28, 0, 0, 31,
5368 32, 33, 34, 35, 36, 37, 38, 39, 0, 40,
5369 41, 42, 43, 44, 45, 46, 0, 0, 0, 0,
5370 0, 0, 0, 0, 0, 0, 47, 48, 0, 0,
5371 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5372 0, 49, 50, 0, 0, 0, 0, 0, 0, 220,
5373 0, 0, 221, 53, 0, 54, 55, 0, 0, 0,
5374 0, 57, 58, 59, 60, 61, 62, 63, 64, 65,
5375 0, 0, 0, 0, 4, 5, 6, 0, 8, 0,
5376 0, 0, 9, 10, 0, 0, 0, 11, 0, 12,
5377 13, 14, 260, 261, 17, 18, 0, 0, 66, 226,
5378 68, 19, 20, 262, 22, 23, 24, 25, 0, 0,
5379 855, 0, 0, 0, 0, 0, 0, 28, 0, 0,
5380 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
5381 40, 41, 42, 43, 44, 45, 46, 0, 0, 0,
5382 0, 0, 0, 0, 0, 0, 0, 47, 48, 0,
5383 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5384 0, 0, 49, 50, 0, 0, 0, 0, 0, 0,
5385 220, 0, 0, 221, 53, 0, 54, 55, 0, 0,
5386 0, 0, 57, 58, 59, 60, 61, 62, 63, 64,
5387 65, 0, 0, 0, 0, 4, 5, 6, 0, 8,
5388 0, 0, 0, 9, 10, 0, 0, 0, 11, 0,
5389 12, 13, 14, 260, 261, 17, 18, 0, 0, 66,
5390 226, 68, 19, 20, 262, 22, 23, 24, 25, 0,
5391 0, 218, 0, 0, 0, 0, 0, 0, 290, 0,
5392 0, 31, 32, 33, 34, 35, 36, 37, 38, 39,
5393 0, 40, 41, 42, 43, 44, 45, 46, 0, 0,
5394 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5395 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5396 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5397 0, 291, 0, 0, 351, 53, 0, 54, 55, 0,
5398 352, 0, 0, 57, 58, 59, 60, 61, 62, 63,
5399 64, 65, 0, 0, 4, 5, 6, 0, 8, 0,
5400 0, 0, 9, 10, 0, 0, 0, 11, 0, 12,
5401 13, 14, 260, 261, 17, 18, 0, 0, 0, 0,
5402 292, 19, 20, 262, 22, 23, 24, 25, 0, 0,
5403 218, 0, 0, 0, 0, 0, 0, 290, 0, 0,
5404 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
5405 40, 41, 42, 43, 44, 45, 46, 0, 0, 0,
5406 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5407 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5408 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5409 401, 0, 0, 52, 53, 0, 54, 55, 0, 56,
5410 0, 0, 57, 58, 59, 60, 61, 62, 63, 64,
5411 65, 0, 0, 4, 5, 6, 0, 8, 0, 0,
5412 0, 9, 10, 0, 0, 0, 11, 0, 12, 13,
5413 14, 260, 261, 17, 18, 0, 0, 0, 0, 292,
5414 19, 20, 262, 22, 23, 24, 25, 0, 0, 218,
5415 0, 0, 0, 0, 0, 0, 290, 0, 0, 31,
5416 32, 33, 409, 35, 36, 37, 410, 39, 0, 40,
5417 41, 42, 43, 44, 45, 46, 0, 0, 0, 0,
5418 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5419 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5420 0, 0, 0, 0, 0, 411, 0, 0, 0, 412,
5421 0, 0, 221, 53, 0, 54, 55, 0, 0, 0,
5422 0, 57, 58, 59, 60, 61, 62, 63, 64, 65,
5423 0, 0, 4, 5, 6, 0, 8, 0, 0, 0,
5424 9, 10, 0, 0, 0, 11, 0, 12, 13, 14,
5425 260, 261, 17, 18, 0, 0, 0, 0, 292, 19,
5426 20, 262, 22, 23, 24, 25, 0, 0, 218, 0,
5427 0, 0, 0, 0, 0, 290, 0, 0, 31, 32,
5428 33, 409, 35, 36, 37, 410, 39, 0, 40, 41,
5429 42, 43, 44, 45, 46, 0, 0, 0, 0, 0,
5430 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5431 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5432 0, 0, 0, 0, 0, 0, 0, 0, 412, 0,
5433 0, 221, 53, 0, 54, 55, 0, 0, 0, 0,
5434 57, 58, 59, 60, 61, 62, 63, 64, 65, 0,
5435 0, 4, 5, 6, 0, 8, 0, 0, 0, 9,
5436 10, 0, 0, 0, 11, 0, 12, 13, 14, 260,
5437 261, 17, 18, 0, 0, 0, 0, 292, 19, 20,
5438 262, 22, 23, 24, 25, 0, 0, 218, 0, 0,
5439 0, 0, 0, 0, 290, 0, 0, 31, 32, 33,
5440 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
5441 43, 44, 45, 46, 0, 0, 0, 0, 0, 0,
5442 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5443 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5444 0, 0, 0, 0, 0, 0, 0, 291, 0, 0,
5445 351, 53, 0, 54, 55, 0, 0, 0, 0, 57,
5446 58, 59, 60, 61, 62, 63, 64, 65, 0, 0,
5447 4, 5, 6, 0, 8, 0, 0, 0, 9, 10,
5448 0, 0, 0, 11, 0, 12, 13, 14, 260, 261,
5449 17, 18, 0, 0, 0, 0, 292, 19, 20, 262,
5450 22, 23, 24, 25, 0, 0, 218, 0, 0, 0,
5451 0, 0, 0, 290, 0, 0, 31, 32, 33, 34,
5452 35, 36, 37, 38, 39, 0, 40, 41, 42, 43,
5453 44, 45, 46, 0, 0, 0, 0, 0, 0, 0,
5454 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5455 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5456 0, 0, 0, 0, 0, 0, 1166, 0, 0, 221,
5457 53, 0, 54, 55, 0, 0, 0, 0, 57, 58,
5458 59, 60, 61, 62, 63, 64, 65, 0, 0, 4,
5459 5, 6, 0, 8, 0, 0, 0, 9, 10, 0,
5460 0, 0, 11, 0, 12, 13, 14, 260, 261, 17,
5461 18, 0, 0, 0, 0, 292, 19, 20, 262, 22,
5462 23, 24, 25, 0, 0, 218, 0, 0, 0, 0,
5463 0, 0, 290, 0, 0, 31, 32, 33, 34, 35,
5464 36, 37, 38, 39, 0, 40, 41, 42, 43, 44,
5465 45, 46, 0, 0, 0, 0, 0, 0, 0, 0,
5466 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5467 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5468 0, 0, 0, 0, 0, 1263, 0, 0, 221, 53,
5469 0, 54, 55, 22, 23, 24, 25, 57, 58, 59,
5470 60, 61, 62, 63, 64, 65, 0, 0, 0, 31,
5471 32, 33, 1055, 0, 0, 0, 1056, 0, 1057, 40,
5472 41, 42, 43, 44, 0, 0, 0, 0, 0, 0,
5473 0, 0, 0, 0, 292, 0, 0, 0, 547, 0,
5474 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5475 0, 1058, 1059, 0, 0, 0, 0, 0, 0, 1060,
5476 0, 0, 1061, 0, 0, 1062, 1063, 0, 1064, 551,
5477 0, 57, 58, 1065, 60, 61, 62, 63, 64, 65,
5478 0, 0, 0, 0, 0, 0, 22, 23, 24, 25,
5479 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5480 0, 1066, 31, 32, 33, 1055, 0, 0, 292, 1056,
5481 0, 0, 40, 41, 42, 43, 44, 0, 0, 0,
5482 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5483 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5484 0, 0, 0, 0, 1058, 1059, 0, 0, 0, 0,
5485 0, 0, 1060, 0, 0, 1061, 0, 0, 1062, 1063,
5486 0, 1064, 0, 0, 57, 58, 59, 60, 61, 62,
5487 63, 64, 65, 0, 0, 0, 0, 0, 0, 22,
5488 23, 24, 25, 0, 0, 0, 631, 632, 0, 0,
5489 633, 0, 0, 0, 1066, 31, 32, 33, 1055, 0,
5490 0, 292, 1056, 0, 0, 40, 41, 42, 43, 44,
5491 179, 180, 181, 182, 183, 184, 185, 186, 187, 0,
5492 0, 188, 189, 0, 0, 0, 0, 190, 191, 192,
5493 193, 0, 0, 0, 0, 0, 0, 1058, 1059, 0,
5494 0, 0, 194, 195, 0, 1060, 0, 0, 1061, 0,
5495 0, 1062, 1063, 0, 0, 0, 0, 57, 58, 59,
5496 60, 61, 62, 63, 64, 65, 0, 0, 0, 0,
5497 0, 0, 196, 197, 198, 199, 200, 201, 202, 203,
5498 204, 205, 0, 206, 207, 684, 622, 1066, 0, 685,
5499 0, 208, 245, 0, 292, 0, 0, 0, 0, 0,
5500 0, 0, 0, 0, 0, 0, 0, 0, 0, 179,
5501 180, 181, 182, 183, 184, 185, 186, 187, 0, 0,
5502 188, 189, 0, 0, 0, 0, 190, 191, 192, 193,
5503 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5504 0, 194, 195, 0, 0, 0, 0, 0, 0, 0,
5505 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5506 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5507 0, 196, 197, 198, 199, 200, 201, 202, 203, 204,
5508 205, 0, 206, 207, 687, 632, 0, 0, 688, 0,
5509 208, 245, 0, 0, 0, 0, 0, 0, 0, 0,
5510 0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
5511 181, 182, 183, 184, 185, 186, 187, 0, 0, 188,
5512 189, 0, 0, 0, 0, 190, 191, 192, 193, 0,
5513 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5514 194, 195, 0, 0, 0, 0, 0, 0, 0, 0,
5515 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5516 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5517 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
5518 0, 206, 207, 684, 622, 0, 0, 702, 0, 208,
5519 245, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5520 0, 0, 0, 0, 0, 0, 0, 179, 180, 181,
5521 182, 183, 184, 185, 186, 187, 0, 0, 188, 189,
5522 0, 0, 0, 0, 190, 191, 192, 193, 0, 0,
5523 0, 0, 0, 0, 0, 0, 0, 0, 0, 194,
5524 195, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5525 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5526 0, 0, 0, 0, 0, 0, 0, 0, 0, 196,
5527 197, 198, 199, 200, 201, 202, 203, 204, 205, 0,
5528 206, 207, 713, 622, 0, 0, 714, 0, 208, 245,
5529 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5530 0, 0, 0, 0, 0, 0, 179, 180, 181, 182,
5531 183, 184, 185, 186, 187, 0, 0, 188, 189, 0,
5532 0, 0, 0, 190, 191, 192, 193, 0, 0, 0,
5533 0, 0, 0, 0, 0, 0, 0, 0, 194, 195,
5534 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5535 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5536 0, 0, 0, 0, 0, 0, 0, 0, 196, 197,
5537 198, 199, 200, 201, 202, 203, 204, 205, 0, 206,
5538 207, 716, 632, 0, 0, 717, 0, 208, 245, 0,
5539 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5540 0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
5541 184, 185, 186, 187, 0, 0, 188, 189, 0, 0,
5542 0, 0, 190, 191, 192, 193, 0, 0, 0, 0,
5543 0, 0, 0, 0, 0, 0, 0, 194, 195, 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, 196, 197, 198,
5547 199, 200, 201, 202, 203, 204, 205, 0, 206, 207,
5548 829, 622, 0, 0, 830, 0, 208, 245, 0, 0,
5549 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5550 0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
5551 185, 186, 187, 0, 0, 188, 189, 0, 0, 0,
5552 0, 190, 191, 192, 193, 0, 0, 0, 0, 0,
5553 0, 0, 0, 0, 0, 0, 194, 195, 0, 0,
5554 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5555 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5556 0, 0, 0, 0, 0, 0, 196, 197, 198, 199,
5557 200, 201, 202, 203, 204, 205, 0, 206, 207, 832,
5558 632, 0, 0, 833, 0, 208, 245, 0, 0, 0,
5559 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5560 0, 0, 0, 179, 180, 181, 182, 183, 184, 185,
5561 186, 187, 0, 0, 188, 189, 0, 0, 0, 0,
5562 190, 191, 192, 193, 0, 0, 0, 0, 0, 0,
5563 0, 0, 0, 0, 0, 194, 195, 0, 0, 0,
5564 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5565 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5566 0, 0, 0, 0, 0, 196, 197, 198, 199, 200,
5567 201, 202, 203, 204, 205, 0, 206, 207, 838, 622,
5568 0, 0, 839, 0, 208, 245, 0, 0, 0, 0,
5569 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5570 0, 0, 179, 180, 181, 182, 183, 184, 185, 186,
5571 187, 0, 0, 188, 189, 0, 0, 0, 0, 190,
5572 191, 192, 193, 0, 0, 0, 0, 0, 0, 0,
5573 0, 0, 0, 0, 194, 195, 0, 0, 0, 0,
5574 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5575 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5576 0, 0, 0, 0, 196, 197, 198, 199, 200, 201,
5577 202, 203, 204, 205, 0, 206, 207, 669, 632, 0,
5578 0, 670, 0, 208, 245, 0, 0, 0, 0, 0,
5579 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5580 0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
5581 0, 0, 188, 189, 0, 0, 0, 0, 190, 191,
5582 192, 193, 0, 0, 0, 0, 0, 0, 0, 0,
5583 0, 0, 0, 194, 195, 0, 0, 0, 0, 0,
5584 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5585 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5586 0, 0, 0, 196, 197, 198, 199, 200, 201, 202,
5587 203, 204, 205, 0, 206, 207, 998, 622, 0, 0,
5588 999, 0, 208, 245, 0, 0, 0, 0, 0, 0,
5589 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5590 179, 180, 181, 182, 183, 184, 185, 186, 187, 0,
5591 0, 188, 189, 0, 0, 0, 0, 190, 191, 192,
5592 193, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5593 0, 0, 194, 195, 0, 0, 0, 0, 0, 0,
5594 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5595 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5596 0, 0, 196, 197, 198, 199, 200, 201, 202, 203,
5597 204, 205, 0, 206, 207, 1001, 632, 0, 0, 1002,
5598 0, 208, 245, 0, 0, 0, 0, 0, 0, 0,
5599 0, 0, 0, 0, 0, 0, 0, 0, 0, 179,
5600 180, 181, 182, 183, 184, 185, 186, 187, 0, 0,
5601 188, 189, 0, 0, 0, 0, 190, 191, 192, 193,
5602 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5603 0, 194, 195, 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, 196, 197, 198, 199, 200, 201, 202, 203, 204,
5607 205, 0, 206, 207, 1281, 622, 0, 0, 1282, 0,
5608 208, 245, 0, 0, 0, 0, 0, 0, 0, 0,
5609 0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
5610 181, 182, 183, 184, 185, 186, 187, 0, 0, 188,
5611 189, 0, 0, 0, 0, 190, 191, 192, 193, 0,
5612 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5613 194, 195, 0, 0, 0, 0, 0, 0, 0, 0,
5614 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5615 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5616 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
5617 0, 206, 207, 1284, 632, 0, 0, 1285, 0, 208,
5618 245, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5619 0, 0, 0, 0, 0, 0, 0, 179, 180, 181,
5620 182, 183, 184, 185, 186, 187, 0, 0, 188, 189,
5621 0, 0, 0, 0, 190, 191, 192, 193, 0, 0,
5622 0, 0, 0, 0, 0, 0, 0, 0, 0, 194,
5623 195, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5624 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5625 0, 0, 0, 0, 0, 0, 0, 0, 0, 196,
5626 197, 198, 199, 200, 201, 202, 203, 204, 205, 0,
5627 206, 207, 1329, 622, 0, 0, 1330, 0, 208, 245,
5628 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5629 0, 0, 0, 0, 0, 0, 179, 180, 181, 182,
5630 183, 184, 185, 186, 187, 0, 0, 188, 189, 0,
5631 0, 0, 0, 190, 191, 192, 193, 0, 0, 0,
5632 0, 0, 0, 0, 0, 0, 0, 0, 194, 195,
5633 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5634 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5635 0, 0, 0, 0, 0, 0, 0, 0, 196, 197,
5636 198, 199, 200, 201, 202, 203, 204, 205, 0, 206,
5637 207, 669, 632, 0, 0, 670, 0, 208, 245, 0,
5638 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5639 0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
5640 184, 185, 186, 187, 0, 0, 188, 189, 0, 0,
5641 0, 0, 190, 191, 192, 193, 0, 0, 0, 0,
5642 0, 0, 0, 0, 0, 0, 0, 194, 195, 0,
5643 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5644 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5645 0, 0, 0, 0, 0, 0, 0, 196, 197, 198,
5646 199, 200, 201, 202, 203, 204, 205, 0, 206, 207,
5647 0, 0, 0, 0, 0, 0, 208
5650 static const yytype_int16 yycheck[] =
5652 1, 97, 58, 15, 16, 21, 59, 70, 332, 27,
5653 91, 106, 336, 52, 53, 388, 242, 412, 13, 14,
5654 58, 332, 394, 1, 105, 336, 70, 7, 56, 336,
5655 15, 16, 743, 580, 85, 557, 93, 94, 96, 7,
5656 97, 387, 549, 389, 26, 578, 28, 27, 581, 245,
5657 817, 52, 53, 97, 594, 56, 1, 85, 827, 27,
5658 580, 284, 745, 101, 80, 288, 56, 463, 584, 54,
5659 98, 99, 100, 52, 745, 15, 16, 72, 58, 750,
5660 63, 64, 65, 884, 85, 94, 459, 750, 97, 882,
5661 102, 797, 509, 439, 919, 66, 609, 98, 99, 100,
5662 101, 13, 455, 499, 26, 1062, 25, 52, 53, 54,
5663 55, 13, 458, 1004, 460, 77, 0, 102, 29, 13,
5664 273, 101, 308, 309, 15, 16, 58, 455, 69, 662,
5665 677, 76, 77, 13, 1127, 463, 101, 0, 511, 98,
5666 486, 567, 155, 496, 10, 80, 78, 160, 574, 34,
5667 100, 1255, 100, 100, 152, 1139, 237, 98, 1247, 1139,
5668 25, 69, 102, 54, 55, 25, 512, 52, 103, 155,
5669 100, 1155, 225, 1153, 591, 101, 28, 109, 110, 275,
5670 672, 673, 221, 740, 265, 135, 743, 135, 135, 25,
5671 98, 156, 67, 250, 251, 154, 25, 27, 351, 158,
5672 1193, 13, 68, 25, 1029, 135, 1163, 1164, 158, 77,
5673 142, 102, 275, 124, 37, 38, 25, 298, 1003, 1004,
5674 221, 1325, 13, 1114, 1003, 1004, 733, 734, 1317, 155,
5675 152, 275, 56, 245, 273, 247, 1061, 156, 1063, 1040,
5676 13, 947, 293, 155, 470, 13, 262, 263, 1041, 161,
5677 1003, 1004, 745, 155, 156, 256, 13, 13, 121, 161,
5678 245, 155, 247, 756, 659, 293, 228, 161, 325, 326,
5679 327, 328, 273, 330, 331, 155, 221, 650, 256, 162,
5680 13, 161, 227, 228, 1268, 801, 26, 660, 1272, 1273,
5681 235, 156, 293, 1273, 273, 135, 156, 242, 981, 695,
5682 245, 283, 284, 399, 837, 651, 288, 247, 290, 1062,
5683 981, 256, 351, 826, 977, 661, 325, 326, 327, 328,
5684 156, 292, 323, 404, 352, 155, 1079, 156, 273, 1114,
5685 25, 161, 155, 295, 156, 1114, 1161, 1162, 395, 525,
5686 693, 527, 156, 155, 1113, 323, 1113, 156, 1332, 161,
5687 351, 352, 101, 900, 411, 399, 247, 396, 397, 227,
5688 228, 1114, 352, 66, 155, 693, 888, 695, 785, 743,
5689 161, 1156, 351, 389, 25, 882, 388, 884, 1163, 1164,
5690 900, 66, 155, 1136, 25, 158, 395, 155, 161, 390,
5691 158, 931, 66, 161, 135, 396, 397, 278, 155, 155,
5692 1153, 110, 411, 135, 161, 161, 351, 156, 100, 389,
5693 1163, 1164, 152, 69, 961, 156, 25, 120, 158, 952,
5694 100, 745, 155, 435, 15, 153, 750, 155, 161, 921,
5695 922, 1163, 1164, 142, 25, 927, 928, 122, 123, 69,
5696 135, 97, 98, 388, 460, 390, 120, 459, 25, 135,
5697 435, 396, 397, 806, 69, 135, 1127, 683, 509, 439,
5698 155, 156, 480, 158, 159, 891, 892, 97, 98, 895,
5699 486, 897, 158, 899, 1058, 1059, 156, 162, 806, 113,
5700 460, 509, 97, 98, 78, 1270, 979, 710, 981, 156,
5701 983, 492, 25, 532, 158, 435, 512, 693, 154, 511,
5702 480, 69, 158, 34, 56, 156, 486, 158, 509, 15,
5703 100, 17, 480, 100, 459, 156, 905, 158, 907, 1011,
5704 100, 52, 100, 468, 154, 470, 135, 100, 135, 97,
5705 98, 532, 512, 1040, 1041, 579, 722, 538, 1270, 154,
5706 591, 727, 1253, 916, 435, 135, 155, 156, 135, 1316,
5707 159, 145, 146, 147, 435, 135, 909, 135, 135, 803,
5708 538, 100, 135, 591, 455, 577, 511, 811, 580, 915,
5709 1127, 917, 968, 945, 1158, 1159, 156, 578, 155, 156,
5710 581, 101, 159, 156, 1255, 466, 154, 532, 469, 1260,
5711 591, 156, 30, 474, 652, 69, 135, 1260, 1131, 643,
5712 100, 640, 135, 642, 589, 496, 663, 78, 489, 594,
5713 555, 627, 557, 66, 67, 69, 1042, 1043, 1044, 1045,
5714 636, 156, 155, 156, 98, 1127, 159, 100, 610, 1003,
5715 1004, 1124, 158, 578, 1127, 651, 581, 863, 650, 640,
5716 968, 642, 699, 97, 98, 661, 970, 629, 660, 100,
5717 387, 1023, 389, 69, 1325, 671, 674, 981, 1321, 970,
5718 711, 662, 135, 970, 720, 1060, 1188, 1189, 54, 122,
5719 123, 651, 143, 144, 145, 146, 147, 158, 64, 65,
5720 561, 661, 98, 711, 135, 630, 52, 703, 704, 100,
5721 56, 636, 627, 69, 674, 640, 1253, 642, 1255, 78,
5722 154, 636, 439, 1260, 686, 650, 674, 100, 1265, 590,
5723 711, 100, 1036, 794, 589, 660, 1249, 662, 69, 594,
5724 159, 458, 98, 460, 135, 1036, 671, 69, 710, 1036,
5725 158, 1103, 155, 715, 785, 158, 671, 135, 683, 722,
5726 1114, 724, 135, 100, 727, 728, 135, 98, 485, 486,
5727 160, 846, 69, 1255, 58, 97, 98, 785, 1260, 704,
5728 56, 1187, 1255, 1265, 1321, 1160, 1323, 156, 1325, 153,
5729 1327, 158, 1265, 510, 78, 512, 1298, 759, 135, 836,
5730 97, 98, 1156, 156, 785, 100, 667, 1344, 69, 1163,
5731 1164, 835, 162, 69, 78, 834, 66, 672, 673, 156,
5732 69, 155, 693, 1127, 66, 109, 844, 161, 1180, 113,
5733 69, 69, 154, 37, 38, 69, 254, 98, 69, 1321,
5734 135, 1323, 98, 1325, 152, 1327, 135, 836, 97, 98,
5735 1323, 52, 1325, 834, 1327, 56, 837, 686, 97, 98,
5736 98, 156, 1344, 97, 98, 135, 97, 98, 594, 831,
5737 120, 1344, 122, 123, 107, 125, 737, 69, 120, 841,
5738 122, 123, 69, 125, 844, 1238, 715, 155, 1, 814,
5739 815, 159, 817, 855, 869, 155, 156, 582, 69, 1253,
5740 937, 586, 15, 16, 66, 154, 98, 135, 900, 834,
5741 97, 98, 837, 1239, 161, 154, 1270, 936, 66, 156,
5742 154, 917, 1127, 154, 916, 26, 97, 98, 25, 953,
5743 56, 349, 649, 26, 651, 806, 354, 139, 863, 52,
5744 53, 69, 659, 56, 661, 1268, 672, 673, 937, 1272,
5745 769, 1255, 971, 772, 67, 936, 1260, 917, 120, 135,
5746 122, 123, 135, 888, 69, 156, 931, 154, 69, 97,
5747 98, 952, 85, 156, 122, 123, 69, 125, 159, 69,
5748 93, 94, 843, 154, 97, 98, 99, 100, 153, 102,
5749 971, 916, 97, 98, 155, 156, 97, 98, 100, 14,
5750 15, 862, 831, 864, 97, 98, 931, 97, 98, 1028,
5751 156, 936, 841, 994, 995, 990, 991, 89, 90, 880,
5752 159, 1325, 1003, 1004, 442, 443, 154, 952, 83, 84,
5753 1066, 1153, 1065, 135, 1, 453, 994, 995, 1000, 40,
5754 41, 1163, 1164, 461, 462, 156, 971, 1028, 1253, 154,
5755 1255, 152, 156, 154, 156, 1260, 156, 158, 66, 152,
5756 1265, 154, 156, 481, 154, 158, 921, 922, 135, 487,
5757 155, 156, 927, 928, 294, 295, 156, 1058, 1059, 52,
5758 156, 1062, 52, 138, 139, 52, 53, 153, 66, 13,
5759 1109, 1110, 156, 1018, 1102, 1020, 156, 1173, 1079, 17,
5760 1062, 1063, 25, 1028, 153, 156, 156, 1168, 221, 1128,
5761 135, 44, 120, 1150, 122, 123, 1321, 44, 1323, 153,
5762 1325, 1102, 1327, 1048, 1049, 1106, 156, 156, 1109, 1110,
5763 1173, 98, 245, 1114, 247, 44, 66, 250, 251, 1344,
5764 44, 996, 120, 256, 122, 123, 135, 1128, 160, 1173,
5765 1131, 137, 8, 1172, 1116, 1136, 1011, 15, 1139, 156,
5766 273, 1150, 52, 156, 156, 1127, 1185, 66, 156, 156,
5767 153, 1000, 1153, 1154, 1155, 156, 1138, 1158, 1159, 1141,
5768 293, 1106, 1163, 1164, 1109, 1110, 101, 1220, 1113, 1197,
5769 120, 1172, 122, 123, 156, 921, 922, 156, 915, 1161,
5770 917, 927, 928, 1128, 1185, 156, 1131, 9, 1245, 1246,
5771 323, 156, 325, 326, 327, 328, 1197, 330, 331, 140,
5772 638, 120, 52, 122, 123, 54, 55, 140, 57, 52,
5773 156, 1193, 101, 1062, 156, 64, 65, 588, 351, 352,
5774 156, 153, 56, 1239, 161, 159, 1238, 1172, 156, 156,
5775 1175, 1259, 1, 140, 221, 156, 1245, 1246, 156, 156,
5776 1185, 156, 156, 1188, 1189, 156, 15, 16, 1249, 1288,
5777 996, 1233, 1234, 1235, 153, 388, 140, 390, 1259, 1239,
5778 56, 156, 395, 396, 397, 1011, 637, 1268, 26, 256,
5779 156, 1272, 1273, 644, 645, 156, 156, 52, 411, 54,
5780 55, 1162, 57, 52, 53, 156, 273, 1288, 158, 1138,
5781 158, 156, 1141, 1238, 256, 1240, 323, 1242, 67, 488,
5782 1106, 1283, 435, 52, 1249, 54, 55, 56, 57, 492,
5783 1292, 69, 1161, 52, 844, 54, 55, 56, 57, 98,
5784 100, 89, 1203, 481, 93, 94, 459, 102, 97, 1311,
5785 671, 1332, 1213, 102, 932, 882, 323, 1175, 733, 97,
5786 98, 1195, 52, 1288, 54, 55, 56, 57, 78, 1230,
5787 1231, 1232, 52, 1298, 54, 55, 56, 57, 1127, 492,
5788 1260, 799, 800, 102, 351, 95, 96, 1049, 1317, 807,
5789 808, 1316, 78, 347, 672, 673, 509, 847, 511, 1316,
5790 1196, 1156, 1154, 1199, 1233, 1234, 1235, 1152, 109, 95,
5791 96, 689, 690, 764, 152, 1156, 154, 768, 1240, 532,
5792 158, 1242, 102, 390, 527, 538, 101, 705, 108, 396,
5793 397, 750, 142, 143, 144, 145, 146, 147, 743, 857,
5794 858, 1253, 860, 861, 40, 41, 42, 43, 44, 59,
5795 60, 61, 62, 1311, 1283, -1, -1, 143, 144, 145,
5796 146, 147, 901, 902, 577, 578, -1, 580, 581, -1,
5797 -1, 910, 221, 912, 825, 914, 589, 828, 591, -1,
5798 -1, 594, -1, -1, -1, -1, -1, -1, -1, -1,
5799 -1, 842, -1, -1, -1, 913, 245, -1, 247, -1,
5800 -1, 250, 251, -1, -1, 1301, 1302, 256, 926, 1305,
5801 1306, -1, -1, 1309, -1, -1, -1, -1, -1, -1,
5802 1237, -1, 1239, -1, 273, 492, -1, 640, -1, 642,
5803 -1, -1, -1, -1, -1, -1, -1, 650, -1, -1,
5804 -1, -1, 1338, 1339, 1340, 1341, 964, 660, -1, 662,
5805 663, 1347, -1, -1, -1, 78, -1, -1, -1, 672,
5806 673, -1, -1, -1, -1, 532, -1, -1, -1, -1,
5807 -1, 538, 95, 96, 323, -1, 325, 326, 327, 328,
5808 -1, 330, 331, -1, -1, -1, 699, 938, -1, -1,
5809 941, 1308, -1, -1, -1, -1, -1, 948, 711, -1,
5810 951, -1, 351, 954, 1003, 1004, -1, -1, -1, -1,
5811 -1, 578, -1, -1, 581, -1, 1, 140, 141, 142,
5812 143, 144, 145, 146, 147, -1, -1, 594, -1, -1,
5813 15, 16, -1, -1, -1, -1, -1, -1, -1, 388,
5814 -1, 390, -1, 921, 922, -1, 395, 396, 397, 927,
5815 928, -1, -1, -1, -1, -1, -1, -1, -1, 1058,
5816 1059, -1, 411, 1062, -1, -1, -1, 52, 53, -1,
5817 -1, -1, 785, 640, -1, 642, -1, -1, -1, -1,
5818 1079, 1032, 67, -1, 962, 963, 435, 965, 966, -1,
5819 -1, -1, -1, -1, -1, 662, -1, -1, -1, -1,
5820 -1, -1, -1, -1, -1, 672, 673, -1, 93, 94,
5821 459, -1, 97, -1, -1, 1114, -1, 102, -1, -1,
5822 -1, 834, -1, 836, 837, -1, -1, 1145, -1, -1,
5823 -1, -1, -1, 1011, -1, -1, -1, 1136, -1, -1,
5824 1139, -1, -1, 492, 52, -1, 54, 55, 56, 57,
5825 58, -1, -1, -1, 1153, 1154, 1155, 1035, -1, 1158,
5826 1159, -1, 511, -1, 1163, 1164, -1, -1, -1, 52,
5827 78, 54, 55, 56, 57, 58, -1, -1, -1, -1,
5828 -1, -1, -1, 532, 92, -1, -1, 900, -1, 538,
5829 -1, -1, -1, -1, 102, 78, -1, -1, -1, -1,
5830 108, 109, 110, 916, -1, -1, -1, -1, 921, 922,
5831 -1, -1, -1, -1, 927, 928, -1, -1, -1, 102,
5832 -1, -1, -1, 936, 937, -1, 109, 110, 577, 578,
5833 -1, 580, 581, -1, 142, -1, 221, 145, -1, 952,
5834 589, -1, -1, -1, -1, 594, -1, -1, -1, 52,
5835 158, 54, 55, 56, 57, 58, -1, -1, 971, 142,
5836 245, -1, 247, -1, -1, 250, 251, 834, -1, 1268,
5837 837, 256, -1, 1272, 1273, 78, -1, -1, -1, -1,
5838 -1, 994, 995, 996, -1, -1, -1, -1, 273, 92,
5839 -1, 640, -1, 642, -1, -1, -1, -1, 1011, 102,
5840 -1, 650, -1, -1, -1, -1, 109, 110, -1, -1,
5841 -1, 660, -1, 662, 663, 1028, -1, -1, -1, -1,
5842 -1, -1, -1, 672, 673, -1, 52, -1, 54, 55,
5843 56, 57, 58, 1332, -1, -1, -1, -1, 323, 142,
5844 325, 326, 327, 328, 1295, 330, 331, -1, -1, -1,
5845 699, -1, 78, -1, 921, 922, -1, -1, -1, -1,
5846 927, 928, -1, -1, -1, -1, 351, -1, -1, 936,
5847 -1, -1, -1, -1, -1, -1, 102, -1, -1, 1,
5848 -1, -1, 108, 109, 110, 952, -1, -1, -1, 1102,
5849 -1, -1, -1, 1106, -1, -1, 1109, 1110, -1, -1,
5850 -1, -1, -1, 388, 971, 390, -1, -1, -1, -1,
5851 395, 396, 397, -1, -1, 1128, 142, -1, 1131, 145,
5852 -1, -1, -1, -1, -1, -1, 411, 994, 995, 996,
5853 52, 53, -1, -1, 56, -1, -1, 1150, -1, -1,
5854 -1, -1, -1, -1, 1011, -1, -1, -1, -1, -1,
5855 435, -1, -1, -1, -1, -1, -1, -1, -1, 1172,
5856 -1, 1028, -1, 85, -1, 52, -1, 54, 55, 56,
5857 57, 58, 1185, -1, 459, -1, 98, 99, 100, -1,
5858 -1, -1, -1, -1, 1197, 834, -1, 836, 837, -1,
5859 -1, 78, -1, -1, -1, -1, -1, -1, -1, -1,
5860 -1, -1, -1, -1, -1, -1, -1, 492, -1, -1,
5861 -1, -1, -1, -1, -1, 102, -1, -1, -1, -1,
5862 -1, 108, 109, 110, -1, 1238, 511, -1, -1, -1,
5863 -1, -1, 1245, 1246, 1, 1102, 1249, -1, -1, 1106,
5864 -1, -1, 1109, 1110, -1, -1, 1259, 532, 15, 16,
5865 -1, 900, -1, 538, -1, 142, 1003, 1004, 145, -1,
5866 -1, 1128, -1, -1, 1131, -1, -1, 916, 155, -1,
5867 -1, -1, 921, 922, -1, 1288, -1, -1, 927, 928,
5868 -1, -1, -1, -1, -1, 52, 53, 936, 937, -1,
5869 -1, -1, 577, 578, -1, 580, 581, -1, -1, 221,
5870 67, -1, -1, 952, 589, 1172, -1, -1, -1, 594,
5871 -1, 1058, 1059, -1, -1, 1062, -1, -1, 1185, -1,
5872 -1, -1, 971, -1, -1, -1, 93, 94, -1, -1,
5873 97, -1, 1079, -1, 256, 102, -1, -1, -1, -1,
5874 -1, -1, -1, -1, -1, 994, 995, 996, -1, -1,
5875 -1, 273, -1, -1, -1, 640, -1, 642, -1, -1,
5876 -1, -1, 1011, -1, -1, 650, -1, 1114, -1, -1,
5877 -1, 293, -1, -1, -1, 660, -1, 662, 663, 1028,
5878 -1, -1, 1249, -1, -1, -1, -1, 672, 673, 1136,
5879 -1, -1, 1139, -1, -1, -1, -1, -1, -1, -1,
5880 -1, 323, -1, -1, -1, -1, 1153, 1154, 1155, -1,
5881 -1, 1158, 1159, -1, 699, -1, 1163, 1164, -1, -1,
5882 -1, 1288, -1, -1, -1, -1, -1, -1, -1, 351,
5883 352, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5884 -1, -1, -1, 1003, 1004, -1, -1, 52, -1, 54,
5885 55, 56, 57, 58, 221, -1, -1, 1106, -1, -1,
5886 1109, 1110, -1, -1, -1, -1, -1, -1, 390, -1,
5887 -1, -1, -1, 78, 396, 397, -1, -1, 245, 1128,
5888 247, -1, 1131, 250, 251, -1, -1, 92, -1, 256,
5889 -1, -1, -1, -1, -1, -1, -1, 102, 1058, 1059,
5890 -1, 1150, 1062, 108, 109, 110, 273, -1, -1, -1,
5891 -1, -1, -1, -1, -1, -1, -1, -1, -1, 1079,
5892 -1, 1268, -1, 1172, -1, 1272, 1273, -1, -1, -1,
5893 -1, -1, -1, -1, -1, -1, 1185, 142, -1, -1,
5894 145, -1, -1, -1, -1, -1, -1, -1, -1, 834,
5895 -1, 836, 837, -1, 1114, -1, 323, -1, 325, 326,
5896 327, 328, -1, 330, 331, -1, -1, -1, -1, -1,
5897 492, -1, -1, -1, -1, -1, 1136, -1, -1, 1139,
5898 -1, -1, -1, -1, 351, 1332, -1, 509, -1, 1238,
5899 -1, -1, -1, 1153, 1154, 1155, 1245, 1246, 1158, 1159,
5900 1249, -1, -1, 1163, 1164, -1, 1, -1, -1, -1,
5901 532, -1, -1, -1, -1, 900, 538, -1, -1, -1,
5902 -1, 388, -1, 390, -1, -1, -1, -1, 395, 396,
5903 397, 916, -1, -1, -1, -1, 921, 922, -1, 1288,
5904 -1, -1, 927, 928, 411, -1, -1, -1, -1, -1,
5905 -1, 936, 937, -1, -1, -1, 578, 52, 53, 581,
5906 -1, 56, -1, -1, -1, -1, -1, 952, 435, 591,
5907 -1, -1, 594, -1, -1, -1, -1, -1, -1, -1,
5908 -1, -1, -1, -1, -1, -1, 971, -1, -1, -1,
5909 85, -1, 459, -1, -1, -1, -1, -1, -1, -1,
5910 -1, -1, -1, 98, 99, 100, -1, -1, 1268, 994,
5911 995, 996, 1272, 1273, -1, -1, -1, -1, 640, -1,
5912 642, -1, -1, -1, -1, 492, 1011, -1, -1, -1,
5913 -1, -1, -1, -1, -1, 1, -1, -1, -1, -1,
5914 662, -1, -1, 1028, 511, -1, -1, -1, -1, -1,
5915 672, 673, -1, -1, -1, -1, -1, -1, -1, -1,
5916 -1, -1, -1, -1, -1, 532, -1, -1, -1, -1,
5917 -1, 538, 1332, -1, -1, -1, -1, -1, -1, -1,
5918 -1, -1, -1, 1003, 1004, -1, 52, 53, -1, 711,
5919 56, -1, -1, -1, -1, -1, -1, -1, 720, -1,
5920 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5921 577, 578, -1, 580, 581, -1, -1, -1, -1, 85,
5922 -1, 1106, 589, -1, 1109, 1110, 221, 594, -1, -1,
5923 -1, -1, 98, 99, 100, -1, -1, -1, 1058, 1059,
5924 -1, -1, 1062, 1128, -1, -1, 1131, -1, -1, -1,
5925 -1, -1, -1, -1, -1, -1, -1, -1, -1, 1079,
5926 -1, 256, -1, 785, -1, 1150, -1, -1, -1, -1,
5927 -1, -1, -1, 640, -1, 642, -1, -1, 273, -1,
5928 -1, -1, -1, 650, -1, -1, -1, 1172, -1, -1,
5929 -1, -1, -1, 660, 1114, 662, 663, -1, 293, -1,
5930 1185, -1, -1, -1, -1, 672, 673, -1, -1, -1,
5931 -1, -1, 834, -1, -1, 837, 1136, -1, 25, 1139,
5932 -1, -1, -1, -1, -1, -1, -1, -1, 323, -1,
5933 -1, -1, 699, 1153, 1154, 1155, -1, -1, 1158, 1159,
5934 -1, -1, -1, 1163, 1164, -1, -1, -1, -1, -1,
5935 -1, -1, -1, 1238, -1, 221, 351, 352, -1, -1,
5936 1245, 1246, -1, -1, 1249, 1003, 1004, -1, -1, -1,
5937 -1, 78, 79, 80, 81, 82, 83, 84, 85, 86,
5938 87, 88, 89, 90, -1, -1, -1, -1, 95, 96,
5939 256, -1, -1, -1, 101, 390, -1, -1, -1, 921,
5940 922, 396, 397, 1288, -1, 927, 928, 273, -1, -1,
5941 -1, -1, -1, -1, 936, -1, -1, -1, -1, -1,
5942 1058, 1059, -1, -1, 1062, 55, -1, 293, -1, 136,
5943 952, 138, 139, 140, 141, 142, 143, 144, 145, 146,
5944 147, 1079, -1, -1, -1, -1, -1, -1, 1268, 971,
5945 -1, -1, 1272, 1273, -1, -1, -1, 323, -1, -1,
5946 -1, -1, -1, -1, -1, -1, -1, 834, -1, 836,
5947 837, -1, 994, 995, 996, -1, 1114, -1, -1, -1,
5948 -1, -1, -1, -1, -1, 351, 352, -1, -1, 1011,
5949 -1, -1, -1, -1, -1, -1, -1, 492, 1136, -1,
5950 -1, 1139, -1, -1, -1, -1, 1028, -1, -1, -1,
5951 -1, -1, 1332, -1, 509, 1153, 1154, 1155, -1, -1,
5952 1158, 1159, -1, -1, 390, 1163, 1164, -1, -1, -1,
5953 396, 397, -1, 900, -1, -1, -1, 532, -1, -1,
5954 -1, -1, -1, 538, -1, -1, 1003, 1004, -1, 916,
5955 -1, -1, -1, -1, 921, 922, -1, -1, -1, -1,
5956 927, 928, -1, -1, -1, -1, -1, -1, -1, 936,
5957 937, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5958 1102, -1, -1, 578, 1106, 952, 581, 1109, 1110, 219,
5959 -1, -1, 222, 223, 224, -1, 591, -1, -1, 594,
5960 -1, 1058, 1059, -1, 971, 1062, 1128, -1, -1, 1131,
5961 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5962 -1, -1, 1079, -1, -1, -1, 492, 994, 995, 996,
5963 1268, -1, -1, 1, 1272, 1273, -1, -1, -1, -1,
5964 -1, -1, -1, 509, 1011, 640, -1, 642, -1, -1,
5965 1172, -1, -1, -1, -1, -1, -1, 1114, -1, -1,
5966 -1, 1028, -1, 1185, -1, -1, 532, 662, -1, -1,
5967 -1, -1, 538, -1, -1, 1197, -1, 672, 673, 1136,
5968 -1, -1, 1139, -1, 52, 53, -1, -1, 56, 1,
5969 -1, -1, -1, -1, 1332, -1, 1153, 1154, 1155, -1,
5970 -1, 1158, 1159, -1, -1, -1, 1163, 1164, -1, -1,
5971 -1, -1, 578, -1, -1, 581, 711, 85, -1, -1,
5972 -1, -1, -1, -1, -1, 591, -1, 1249, 594, -1,
5973 98, 99, 100, 101, -1, -1, -1, 1259, -1, 1106,
5974 52, 53, 1109, 1110, -1, -1, -1, -1, -1, -1,
5975 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5976 -1, 1128, -1, -1, 1131, -1, 1288, -1, -1, -1,
5977 -1, -1, -1, -1, 640, -1, 642, -1, -1, 1003,
5978 1004, -1, -1, 1150, -1, -1, -1, -1, -1, -1,
5979 785, -1, -1, -1, -1, -1, 662, -1, -1, -1,
5980 -1, -1, -1, -1, -1, 1172, 672, 673, -1, -1,
5981 -1, 1268, -1, -1, -1, 1272, 1273, -1, 1185, -1,
5982 -1, -1, -1, -1, 454, 455, -1, -1, -1, -1,
5983 -1, -1, -1, 463, 1058, 1059, -1, -1, 1062, 834,
5984 -1, -1, 837, -1, -1, 711, -1, -1, -1, -1,
5985 -1, -1, -1, 221, -1, 1079, -1, -1, -1, -1,
5986 -1, -1, -1, -1, -1, -1, 496, -1, -1, 499,
5987 -1, 1238, -1, -1, -1, 1332, -1, -1, 1245, 1246,
5988 -1, -1, 1249, -1, -1, -1, -1, -1, 256, -1,
5989 1114, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5990 -1, -1, -1, -1, -1, 273, -1, -1, -1, 221,
5991 -1, -1, 1136, -1, -1, 1139, -1, -1, -1, 785,
5992 -1, 1288, -1, -1, -1, 293, 921, 922, -1, 1153,
5993 1154, 1155, 927, 928, 1158, 1159, -1, -1, 568, 1163,
5994 1164, 936, -1, -1, 256, -1, -1, -1, -1, -1,
5995 -1, -1, -1, -1, -1, 323, -1, 952, -1, 589,
5996 -1, 273, -1, -1, 594, -1, -1, -1, 834, -1,
5997 -1, 837, -1, -1, -1, -1, 971, -1, -1, -1,
5998 -1, -1, -1, 351, 352, -1, -1, -1, -1, -1,
5999 -1, -1, -1, -1, -1, -1, -1, -1, -1, 994,
6000 995, 996, -1, -1, -1, -1, -1, -1, -1, -1,
6001 -1, 323, -1, -1, -1, -1, 1011, -1, -1, -1,
6002 -1, -1, 390, -1, -1, -1, -1, -1, 396, 397,
6003 -1, -1, -1, 1028, -1, -1, -1, -1, -1, 351,
6004 -1, -1, -1, -1, 1268, 675, -1, -1, 1272, 1273,
6005 -1, -1, -1, -1, -1, 921, 922, -1, -1, -1,
6006 -1, 927, 928, 693, -1, 695, -1, -1, -1, -1,
6007 936, 33, 34, 35, 36, -1, -1, -1, 390, -1,
6008 -1, -1, -1, -1, 396, 397, 952, 49, 50, 51,
6009 -1, -1, -1, -1, -1, -1, -1, 59, 60, 61,
6010 62, 63, -1, -1, -1, 971, -1, 1102, 1332, -1,
6011 -1, 1106, -1, -1, 1109, 1110, -1, -1, -1, 749,
6012 -1, -1, -1, -1, 492, -1, -1, -1, 994, 995,
6013 996, -1, -1, 1128, -1, -1, 1131, -1, -1, -1,
6014 -1, 509, -1, -1, -1, 1011, -1, 777, -1, 111,
6015 112, 113, 114, 115, 116, 117, 118, 119, -1, -1,
6016 -1, -1, 1028, -1, 532, -1, 1003, 1004, -1, -1,
6017 538, -1, -1, -1, -1, -1, 806, 1172, -1, -1,
6018 492, -1, -1, -1, -1, -1, 148, -1, -1, -1,
6019 1185, -1, -1, -1, 824, -1, -1, -1, -1, -1,
6020 -1, -1, 1197, -1, -1, -1, -1, -1, -1, -1,
6021 578, -1, -1, 581, -1, -1, -1, -1, -1, -1,
6022 532, 1058, 1059, 591, -1, 1062, 538, -1, -1, -1,
6023 -1, -1, -1, -1, -1, -1, 1102, -1, -1, -1,
6024 1106, -1, 1079, 1109, 1110, -1, -1, -1, 1003, 1004,
6025 -1, -1, -1, -1, 1249, -1, -1, -1, -1, -1,
6026 -1, -1, 1128, -1, 1259, 1131, 578, -1, -1, 581,
6027 -1, -1, 640, -1, 642, -1, -1, 1114, -1, 909,
6028 -1, -1, 594, -1, -1, -1, -1, -1, -1, -1,
6029 -1, -1, -1, 1288, 662, -1, -1, -1, -1, 1136,
6030 -1, 931, 1139, 1058, 1059, -1, 1172, 1062, -1, -1,
6031 -1, -1, -1, 943, -1, -1, 1153, 1154, 1155, 1185,
6032 -1, 1158, 1159, -1, 1079, -1, 1163, 1164, 640, -1,
6033 642, 1197, -1, -1, -1, -1, -1, -1, 968, -1,
6034 -1, -1, -1, 711, -1, -1, -1, -1, -1, -1,
6035 662, -1, -1, -1, -1, -1, -1, -1, -1, 1114,
6036 672, 673, 992, -1, -1, -1, -1, -1, -1, -1,
6037 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6038 -1, 1136, -1, 1249, 1139, -1, -1, -1, -1, -1,
6039 -1, -1, -1, 1259, -1, -1, -1, 1027, 1153, 1154,
6040 1155, -1, -1, 1158, 1159, -1, -1, -1, 1163, 1164,
6041 -1, -1, -1, -1, -1, -1, -1, 785, -1, -1,
6042 -1, -1, 1288, -1, -1, -1, -1, -1, -1, -1,
6043 -1, 1268, -1, -1, -1, 1272, 1273, -1, -1, -1,
6044 -1, -1, -1, -1, -1, -1, 0, -1, -1, -1,
6045 -1, -1, -1, -1, 8, 9, 10, -1, -1, 13,
6046 14, 15, -1, 17, -1, -1, 834, -1, -1, 837,
6047 -1, 25, 26, 27, -1, -1, -1, -1, -1, -1,
6048 -1, 1111, -1, 37, 38, -1, 40, 41, 42, 43,
6049 44, -1, -1, -1, -1, 1332, -1, -1, -1, -1,
6050 -1, 15, 16, -1, -1, -1, -1, -1, -1, -1,
6051 -1, -1, -1, 1268, 68, 69, -1, 1272, 1273, -1,
6052 -1, -1, 834, -1, -1, 837, -1, -1, -1, -1,
6053 -1, -1, -1, 47, 48, 49, 50, -1, -1, -1,
6054 54, 55, -1, 97, 98, -1, -1, -1, -1, -1,
6055 -1, -1, -1, 67, 68, -1, -1, -1, -1, -1,
6056 -1, -1, -1, 33, 34, 35, 36, 121, 936, -1,
6057 -1, -1, -1, -1, -1, -1, -1, 1332, -1, 49,
6058 50, 51, 52, -1, 952, -1, 56, -1, 102, 59,
6059 60, 61, 62, 63, -1, -1, -1, -1, 152, 153,
6060 -1, 155, -1, 971, 158, 159, -1, 161, -1, 921,
6061 922, -1, -1, -1, -1, 927, 928, -1, -1, -1,
6062 -1, 91, 92, -1, 936, -1, 994, 995, -1, 99,
6063 -1, -1, 102, -1, -1, 105, 106, -1, 108, -1,
6064 952, 111, 112, 113, 114, 115, 116, 117, 118, 119,
6065 -1, -1, 44, -1, -1, -1, -1, -1, -1, 971,
6066 1028, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6067 -1, 141, -1, -1, -1, -1, -1, -1, 148, -1,
6068 -1, -1, 994, 995, 996, 155, 78, 79, 80, 81,
6069 82, 83, 84, 85, 86, 87, 88, 89, 90, 1011,
6070 -1, -1, -1, 95, 96, 219, -1, -1, 222, 223,
6071 224, -1, 226, -1, -1, -1, 1028, -1, -1, -1,
6072 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6073 -1, 245, -1, 247, 1102, -1, 44, -1, 1106, -1,
6074 -1, 1109, 1110, -1, 136, -1, 138, 139, 140, 141,
6075 142, 143, 144, 145, 146, 147, -1, -1, -1, -1,
6076 1128, -1, -1, 1131, 156, -1, -1, -1, -1, -1,
6077 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
6078 88, 89, 90, -1, -1, -1, -1, 95, 96, -1,
6079 -1, -1, -1, -1, 1106, -1, -1, 1109, 1110, -1,
6080 -1, -1, -1, -1, 1172, -1, -1, -1, -1, -1,
6081 -1, -1, -1, -1, -1, -1, 1128, 1185, -1, 1131,
6082 -1, -1, -1, -1, -1, -1, -1, -1, 136, 1197,
6083 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
6084 -1, -1, 356, 357, 358, 359, 360, -1, -1, 363,
6085 364, 365, 366, 367, 368, 369, 370, -1, 372, -1,
6086 1172, 375, 376, 377, 378, 379, 380, 381, 382, 383,
6087 384, -1, -1, 1185, 388, -1, -1, -1, -1, -1,
6088 -1, 1249, -1, -1, -1, -1, -1, -1, -1, -1,
6089 -1, 1259, -1, -1, -1, -1, -1, -1, -1, -1,
6090 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6091 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6092 1288, 435, -1, -1, -1, -1, -1, -1, -1, -1,
6093 -1, -1, -1, -1, -1, -1, -1, 1249, -1, -1,
6094 454, 455, -1, -1, -1, 459, -1, -1, -1, 463,
6095 0, 465, -1, -1, -1, -1, -1, -1, 8, 9,
6096 10, -1, -1, 13, 14, 15, -1, 17, -1, 483,
6097 -1, -1, -1, -1, -1, 25, 1288, 27, 28, 29,
6098 -1, -1, 496, -1, -1, 499, -1, 37, 38, -1,
6099 40, 41, 42, 43, 44, -1, -1, 511, -1, -1,
6100 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6101 -1, -1, -1, -1, -1, 529, -1, -1, 68, 69,
6102 -1, -1, -1, -1, -1, -1, -1, -1, 78, 79,
6103 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6104 90, -1, -1, -1, -1, 95, 96, 97, 98, -1,
6105 100, 101, -1, -1, 568, -1, -1, 107, -1, -1,
6106 -1, -1, -1, 577, -1, -1, 580, -1, -1, -1,
6107 -1, 121, -1, -1, 124, 589, -1, -1, -1, -1,
6108 594, -1, -1, -1, -1, 135, 136, 137, 138, 139,
6109 140, 141, 142, 143, 144, 145, 146, 147, -1, -1,
6110 -1, -1, -1, 153, 154, 155, 156, -1, -1, 159,
6111 160, 161, -1, 52, 53, -1, -1, 56, -1, -1,
6112 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6113 -1, -1, -1, -1, -1, -1, 650, 76, 77, 78,
6114 79, 80, 81, 82, 83, 84, 660, -1, 87, 88,
6115 -1, -1, -1, -1, 93, 94, 95, 96, 672, 673,
6116 -1, 675, 676, 677, 678, -1, -1, -1, -1, 108,
6117 109, -1, -1, -1, -1, 689, 690, -1, -1, 693,
6118 -1, 695, -1, -1, -1, -1, -1, -1, -1, -1,
6119 -1, 705, -1, -1, -1, -1, -1, -1, -1, 138,
6120 139, 140, 141, 142, 143, 144, 145, 146, 147, -1,
6121 149, 150, -1, -1, -1, -1, -1, -1, 157, 158,
6122 -1, -1, 0, 1, -1, 3, 4, 5, 6, 7,
6123 8, 9, 10, 11, 12, 749, 14, 15, 16, 17,
6124 18, 19, 20, 21, 22, 23, 24, 25, -1, -1,
6125 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
6126 -1, 39, -1, 777, -1, -1, -1, 45, 46, 47,
6127 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6128 -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
6129 68, -1, 806, -1, -1, -1, -1, -1, 76, 77,
6130 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6131 824, -1, -1, 91, 92, -1, -1, -1, -1, -1,
6132 -1, 99, -1, -1, 102, 103, -1, 105, 106, -1,
6133 108, -1, -1, 111, 112, 113, 114, 115, 116, 117,
6134 118, 119, -1, 121, -1, -1, -1, -1, -1, -1,
6135 -1, -1, -1, -1, -1, -1, -1, -1, -1, 78,
6136 79, 80, 81, 82, 83, 84, 85, -1, 87, 88,
6137 148, 149, 150, -1, -1, 153, 95, 96, -1, -1,
6138 -1, 159, -1, 161, -1, -1, 900, -1, -1, -1,
6139 -1, -1, -1, -1, -1, 909, -1, -1, -1, -1,
6140 -1, -1, 916, -1, -1, -1, 920, 921, 922, -1,
6141 -1, -1, -1, 927, 928, -1, -1, 931, -1, 138,
6142 139, 140, 141, 142, 143, 144, 145, 146, 147, 943,
6143 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6144 -1, -1, -1, -1, -1, -1, -1, 961, 962, 963,
6145 -1, 965, 966, -1, 968, -1, -1, -1, -1, -1,
6146 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6147 -1, -1, -1, -1, 988, 989, -1, -1, 992, -1,
6148 -1, -1, 996, 997, -1, -1, -1, -1, -1, -1,
6149 -1, -1, -1, -1, -1, -1, -1, 1011, -1, -1,
6150 -1, -1, -1, -1, 0, 1, -1, 3, 4, 5,
6151 6, 7, -1, 1027, -1, 11, 12, -1, -1, -1,
6152 16, 1035, 18, 19, 20, 21, 22, 23, 24, -1,
6153 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
6154 36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
6155 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
6156 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
6157 -1, -1, -1, 78, 79, 80, 81, 82, 83, 84,
6158 76, 77, 87, 88, -1, -1, -1, -1, -1, -1,
6159 95, 96, -1, -1, -1, 91, 92, 1111, -1, -1,
6160 -1, -1, -1, 99, -1, -1, 102, 103, -1, 105,
6161 106, -1, 108, -1, -1, 111, 112, 113, 114, 115,
6162 116, 117, 118, 119, -1, 121, -1, -1, -1, -1,
6163 -1, -1, -1, 138, 139, 140, 141, 142, 143, 144,
6164 145, 146, 147, -1, -1, -1, -1, -1, -1, -1,
6165 -1, -1, 148, 149, 150, -1, -1, 0, 1, 155,
6166 3, 4, 5, 6, 7, 161, -1, -1, 11, 12,
6167 -1, -1, -1, 16, -1, 18, 19, 20, 21, 22,
6168 23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
6169 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
6170 -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
6171 53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
6172 63, 64, 65, -1, 1238, -1, 78, 79, 80, 81,
6173 82, 83, 84, 76, 77, 87, 88, -1, -1, -1,
6174 -1, -1, -1, 95, 96, -1, -1, -1, 91, 92,
6175 -1, -1, -1, -1, -1, -1, 99, -1, -1, 102,
6176 103, -1, 105, 106, -1, 108, -1, -1, 111, 112,
6177 113, 114, 115, 116, 117, 118, 119, -1, -1, -1,
6178 -1, -1, -1, -1, -1, -1, 138, 139, 140, 141,
6179 142, 143, 144, 145, 146, 147, -1, -1, -1, -1,
6180 -1, -1, -1, -1, -1, 148, 149, 150, -1, -1,
6181 0, 1, 155, 3, 4, 5, 6, 7, 161, -1,
6182 -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
6183 20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
6184 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
6185 -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
6186 50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
6187 60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
6188 -1, -1, -1, -1, -1, -1, 76, 77, -1, -1,
6189 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6190 -1, 91, 92, -1, -1, -1, -1, -1, -1, 99,
6191 -1, -1, 102, 103, -1, 105, 106, -1, 108, -1,
6192 -1, 111, 112, 113, 114, 115, 116, 117, 118, 119,
6193 -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,
6194 -1, -1, -1, -1, -1, -1, -1, 8, 9, 10,
6195 -1, -1, 13, 14, 15, -1, 17, -1, 148, 149,
6196 150, -1, -1, 153, 25, 26, 27, 28, 29, -1,
6197 -1, 161, -1, -1, -1, -1, 37, 38, -1, 40,
6198 41, 42, 43, 44, -1, -1, -1, 78, 79, 80,
6199 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
6200 -1, -1, -1, -1, 95, 96, -1, 68, 69, -1,
6201 -1, -1, -1, -1, -1, -1, -1, 78, 79, 80,
6202 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
6203 -1, -1, -1, -1, 95, 96, 97, 98, -1, 100,
6204 101, -1, -1, -1, -1, 136, 107, 138, 139, 140,
6205 141, 142, 143, 144, 145, 146, 147, -1, -1, -1,
6206 121, -1, -1, 124, 155, -1, -1, -1, -1, -1,
6207 -1, -1, -1, -1, 135, 136, 137, 138, 139, 140,
6208 141, 142, 143, 144, 145, 146, 147, -1, -1, -1,
6209 -1, 152, 153, 154, 155, 156, 0, -1, 159, 160,
6210 161, -1, -1, -1, 8, 9, 10, -1, -1, 13,
6211 14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
6212 -1, 25, -1, 27, 28, 29, -1, -1, -1, -1,
6213 -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
6214 44, -1, -1, -1, 78, 79, 80, 81, 82, 83,
6215 84, 85, 86, 87, 88, 89, 90, -1, -1, -1,
6216 -1, 95, 96, -1, 68, 69, -1, -1, -1, -1,
6217 -1, -1, -1, -1, 78, 79, 80, 81, 82, 83,
6218 84, 85, 86, 87, 88, 89, 90, -1, -1, -1,
6219 -1, 95, 96, 97, 98, -1, 100, 101, -1, -1,
6220 -1, -1, 136, 107, 138, 139, 140, 141, 142, 143,
6221 144, 145, 146, 147, -1, -1, -1, 121, -1, -1,
6222 124, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6223 -1, 135, 136, 137, 138, 139, 140, 141, 142, 143,
6224 144, 145, 146, 147, -1, -1, -1, -1, -1, 153,
6225 154, 155, 156, 0, -1, 159, 160, 161, -1, -1,
6226 -1, 8, 9, 10, -1, -1, 13, 14, 15, -1,
6227 17, -1, -1, -1, -1, -1, -1, -1, 25, 26,
6228 27, 28, 29, -1, -1, -1, -1, -1, -1, -1,
6229 37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
6230 -1, 78, 79, 80, 81, 82, 83, 84, 85, 86,
6231 87, 88, 89, 90, -1, -1, -1, -1, 95, 96,
6232 -1, 68, 69, -1, -1, -1, -1, -1, -1, -1,
6233 -1, 78, 79, 80, 81, 82, 83, 84, 85, 86,
6234 87, 88, 89, 90, -1, -1, -1, -1, 95, 96,
6235 97, 98, -1, -1, 101, -1, -1, -1, -1, -1,
6236 107, 138, 139, 140, 141, 142, 143, 144, 145, 146,
6237 147, -1, -1, -1, 121, -1, -1, 124, -1, -1,
6238 -1, -1, -1, -1, -1, -1, -1, -1, -1, 136,
6239 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
6240 147, -1, -1, -1, -1, 152, 153, 154, 155, 156,
6241 0, -1, 159, 160, 161, -1, -1, -1, 8, 9,
6242 10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
6243 -1, -1, -1, -1, -1, 25, 26, 27, 28, 29,
6244 -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
6245 40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
6246 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6247 -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
6248 -1, -1, -1, -1, -1, -1, -1, -1, 78, 79,
6249 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6250 90, -1, -1, -1, -1, 95, 96, 97, 98, -1,
6251 -1, 101, -1, -1, -1, -1, -1, 107, -1, -1,
6252 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6253 -1, 121, -1, -1, 124, -1, -1, -1, -1, -1,
6254 -1, -1, -1, -1, -1, -1, 136, 137, 138, 139,
6255 140, 141, 142, 143, 144, 145, 146, 147, -1, -1,
6256 -1, -1, 152, 153, 154, 155, 156, 0, -1, 159,
6257 160, 161, -1, -1, -1, 8, 9, 10, -1, -1,
6258 13, 14, 15, -1, 17, -1, -1, -1, -1, -1,
6259 -1, -1, 25, 26, 27, 28, -1, -1, -1, -1,
6260 -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
6261 43, 44, -1, -1, -1, -1, -1, -1, -1, -1,
6262 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6263 -1, -1, -1, -1, -1, 68, 69, -1, -1, -1,
6264 -1, -1, -1, -1, -1, 78, 79, 80, 81, 82,
6265 83, 84, 85, 86, 87, 88, 89, 90, -1, -1,
6266 -1, -1, 95, 96, 97, 98, -1, -1, 101, -1,
6267 -1, -1, -1, -1, 107, -1, -1, -1, -1, -1,
6268 -1, -1, -1, -1, -1, -1, -1, -1, 121, -1,
6269 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6270 -1, -1, -1, 136, -1, 138, 139, 140, 141, 142,
6271 143, 144, 145, 146, 147, -1, -1, -1, -1, 152,
6272 153, 154, 155, 156, 0, 158, 159, 160, 161, -1,
6273 -1, -1, 8, 9, 10, -1, -1, 13, 14, 15,
6274 -1, 17, -1, -1, -1, -1, -1, -1, -1, 25,
6275 -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
6276 -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
6277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6279 -1, -1, 68, 69, -1, -1, -1, -1, -1, -1,
6280 -1, -1, 78, 79, 80, 81, 82, 83, 84, 85,
6281 86, 87, 88, 89, 90, -1, -1, -1, -1, 95,
6282 96, 97, 98, -1, -1, 101, -1, -1, -1, -1,
6283 -1, 107, -1, -1, -1, -1, -1, -1, -1, -1,
6284 -1, -1, -1, -1, -1, 121, -1, -1, 124, -1,
6285 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6286 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
6287 146, 147, -1, -1, -1, -1, -1, 153, 154, 155,
6288 156, 0, -1, 159, 160, 161, -1, -1, -1, 8,
6289 9, 10, -1, -1, 13, 14, 15, -1, 17, -1,
6290 -1, -1, -1, -1, -1, -1, 25, 26, 27, 28,
6291 -1, -1, -1, -1, -1, -1, -1, -1, 37, 38,
6292 -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
6293 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6294 -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
6295 69, -1, -1, -1, -1, -1, -1, -1, -1, 78,
6296 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
6297 89, 90, -1, -1, -1, -1, 95, 96, 97, 98,
6298 -1, -1, 101, -1, -1, -1, -1, -1, 107, -1,
6299 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6300 -1, -1, 121, -1, -1, -1, -1, -1, -1, -1,
6301 -1, -1, -1, -1, -1, -1, -1, 136, -1, 138,
6302 139, 140, 141, 142, 143, 144, 145, 146, 147, -1,
6303 -1, -1, -1, 152, 153, 154, 155, 156, 0, 158,
6304 159, 160, 161, -1, -1, -1, 8, 9, 10, -1,
6305 -1, 13, 14, 15, -1, 17, -1, -1, -1, -1,
6306 -1, -1, -1, 25, -1, 27, 28, -1, -1, -1,
6307 -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
6308 42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
6309 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6310 -1, -1, -1, -1, -1, -1, 68, 69, -1, -1,
6311 -1, -1, -1, -1, -1, -1, 78, 79, 80, 81,
6312 82, 83, 84, 85, 86, 87, 88, 89, 90, -1,
6313 -1, -1, -1, 95, 96, 97, 98, -1, 100, 101,
6314 -1, -1, -1, -1, -1, 107, -1, -1, -1, -1,
6315 -1, -1, -1, -1, -1, -1, -1, -1, -1, 121,
6316 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6317 -1, -1, -1, 135, 136, -1, 138, 139, 140, 141,
6318 142, 143, 144, 145, 146, 147, -1, -1, -1, -1,
6319 152, 153, 154, 155, 156, 0, -1, 159, 160, 161,
6320 -1, -1, -1, 8, 9, 10, -1, -1, 13, 14,
6321 15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
6322 25, -1, 27, 28, -1, -1, -1, -1, -1, -1,
6323 -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
6324 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6325 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6326 -1, -1, -1, 68, 69, -1, -1, -1, -1, -1,
6327 -1, -1, -1, 78, 79, 80, 81, 82, 83, 84,
6328 85, 86, 87, 88, 89, 90, -1, -1, -1, -1,
6329 95, 96, 97, 98, -1, -1, 101, -1, -1, -1,
6330 -1, -1, 107, -1, -1, -1, -1, -1, -1, -1,
6331 -1, -1, -1, -1, -1, -1, 121, -1, -1, -1,
6332 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6333 -1, 136, -1, 138, 139, 140, 141, 142, 143, 144,
6334 145, 146, 147, -1, -1, -1, -1, -1, 153, 154,
6335 155, 156, 0, 158, 159, 160, 161, -1, -1, -1,
6336 8, 9, 10, -1, -1, -1, 14, 15, -1, 17,
6337 -1, -1, -1, -1, -1, -1, -1, 25, 26, -1,
6338 -1, -1, -1, -1, -1, -1, -1, -1, -1, 37,
6339 38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
6340 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6341 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6342 68, 69, -1, -1, -1, -1, -1, -1, -1, -1,
6343 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
6344 88, 89, 90, -1, -1, -1, -1, 95, 96, 97,
6345 98, -1, 100, 101, -1, -1, -1, -1, -1, -1,
6346 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6347 -1, -1, -1, 121, -1, -1, -1, -1, -1, -1,
6348 -1, -1, -1, -1, -1, -1, -1, 135, 136, -1,
6349 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
6350 -1, -1, -1, -1, 152, 153, 154, 155, 156, 0,
6351 -1, 159, -1, 161, -1, -1, -1, 8, 9, 10,
6352 -1, -1, -1, 14, 15, -1, 17, -1, -1, -1,
6353 -1, -1, -1, -1, 25, 26, -1, -1, -1, -1,
6354 -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
6355 41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
6356 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6357 -1, -1, -1, -1, -1, -1, -1, 68, 69, -1,
6358 -1, -1, -1, -1, -1, -1, -1, 78, 79, 80,
6359 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
6360 -1, -1, -1, -1, 95, 96, 97, 98, -1, 100,
6361 101, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6362 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6363 121, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6364 -1, -1, -1, -1, 135, 136, -1, 138, 139, 140,
6365 141, 142, 143, 144, 145, 146, 147, -1, -1, -1,
6366 -1, 152, 153, 154, 155, 156, 0, -1, 159, -1,
6367 161, -1, -1, -1, 8, 9, 10, -1, -1, -1,
6368 14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
6369 -1, 25, -1, -1, -1, -1, -1, -1, -1, -1,
6370 -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
6371 44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6372 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6373 -1, -1, -1, -1, 68, 69, -1, -1, -1, -1,
6374 -1, -1, -1, -1, 78, 79, 80, 81, 82, 83,
6375 84, 85, 86, 87, 88, 89, 90, -1, -1, -1,
6376 -1, 95, 96, 97, 98, -1, 100, 101, -1, -1,
6377 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6378 -1, -1, -1, -1, -1, -1, -1, 121, -1, -1,
6379 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6380 -1, 135, 136, -1, 138, 139, 140, 141, 142, 143,
6381 144, 145, 146, 147, -1, -1, -1, -1, 152, 153,
6382 154, 155, 156, 0, -1, 159, -1, 161, -1, -1,
6383 -1, 8, 9, 10, -1, -1, -1, 14, 15, -1,
6384 17, -1, -1, -1, -1, -1, -1, -1, 25, -1,
6385 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6386 37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
6387 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6388 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6389 -1, 68, 69, -1, -1, -1, -1, -1, -1, -1,
6390 -1, 78, 79, 80, 81, 82, 83, 84, 85, 86,
6391 87, 88, 89, 90, -1, -1, -1, -1, 95, 96,
6392 97, 98, -1, 100, 101, -1, -1, -1, -1, -1,
6393 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6394 -1, -1, -1, -1, 121, -1, -1, -1, -1, -1,
6395 -1, -1, -1, -1, -1, -1, -1, -1, 135, 136,
6396 -1, 138, 139, 140, 141, 142, 143, 144, 145, 146,
6397 147, -1, -1, -1, -1, 152, 153, 154, 155, 156,
6398 -1, -1, 159, 1, 161, 3, 4, 5, 6, 7,
6399 8, 9, 10, 11, 12, -1, -1, 15, 16, -1,
6400 18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
6401 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
6402 -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
6403 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6404 -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
6405 68, -1, -1, -1, -1, -1, -1, -1, 76, 77,
6406 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6407 -1, -1, -1, 91, 92, -1, -1, -1, -1, -1,
6408 -1, 99, -1, -1, 102, 103, -1, 105, 106, -1,
6409 108, -1, -1, 111, 112, 113, 114, 115, 116, 117,
6410 118, 119, -1, -1, -1, -1, -1, -1, -1, -1,
6411 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6412 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6413 148, 149, 150, -1, -1, -1, 1, 155, 3, 4,
6414 5, 6, 7, 161, -1, 10, 11, 12, -1, 14,
6415 15, 16, -1, 18, 19, 20, 21, 22, 23, 24,
6416 -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
6417 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
6418 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
6419 55, 56, 57, -1, 59, 60, 61, 62, 63, 64,
6420 65, -1, -1, 68, -1, -1, -1, -1, -1, -1,
6421 -1, 76, 77, -1, -1, -1, -1, -1, -1, -1,
6422 -1, -1, -1, -1, -1, -1, 91, 92, -1, -1,
6423 -1, -1, -1, -1, 99, -1, -1, 102, 103, -1,
6424 105, 106, -1, 108, -1, -1, 111, 112, 113, 114,
6425 115, 116, 117, 118, 119, -1, -1, -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 -1, -1, -1, 148, 149, 150, -1, -1, -1, 1,
6429 155, 3, 4, 5, 6, 7, 161, -1, 10, 11,
6430 12, -1, -1, 15, 16, 17, 18, 19, 20, 21,
6431 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
6432 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
6433 -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
6434 52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
6435 62, 63, 64, 65, -1, -1, 68, -1, -1, -1,
6436 -1, -1, -1, -1, 76, 77, -1, -1, -1, -1,
6437 -1, -1, -1, -1, -1, -1, -1, -1, -1, 91,
6438 92, -1, -1, -1, -1, -1, -1, 99, -1, -1,
6439 102, 103, -1, 105, 106, -1, 108, -1, -1, 111,
6440 112, 113, 114, 115, 116, 117, 118, 119, -1, -1,
6441 -1, -1, -1, -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, 148, 149, 150, -1,
6444 -1, -1, 1, 155, 3, 4, 5, 6, 7, 161,
6445 -1, 10, 11, 12, -1, -1, 15, 16, -1, 18,
6446 19, 20, 21, 22, 23, 24, 25, -1, -1, -1,
6447 -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
6448 39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
6449 49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
6450 59, 60, 61, 62, 63, 64, 65, -1, -1, 68,
6451 -1, -1, -1, -1, -1, -1, -1, 76, 77, -1,
6452 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6453 -1, -1, 91, 92, -1, -1, -1, -1, -1, -1,
6454 99, -1, -1, 102, 103, -1, 105, 106, -1, 108,
6455 -1, -1, 111, 112, 113, 114, 115, 116, 117, 118,
6456 119, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6457 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6458 -1, -1, -1, -1, -1, -1, -1, -1, -1, 148,
6459 149, 150, -1, -1, -1, 1, 155, 3, 4, 5,
6460 6, 7, 161, -1, 10, 11, 12, -1, -1, 15,
6461 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6462 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
6463 36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
6464 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
6465 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
6466 -1, -1, 68, -1, -1, -1, -1, -1, -1, -1,
6467 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6468 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6469 -1, -1, -1, 99, -1, -1, 102, 103, -1, 105,
6470 106, -1, 108, -1, -1, 111, 112, 113, 114, 115,
6471 116, 117, 118, 119, -1, -1, -1, -1, -1, -1,
6472 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6473 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6474 -1, -1, 148, 149, 150, -1, -1, -1, 1, 155,
6475 3, 4, 5, 6, 7, 161, 9, 10, 11, 12,
6476 -1, -1, -1, 16, -1, 18, 19, 20, 21, 22,
6477 23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
6478 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
6479 -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
6480 53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
6481 63, 64, 65, -1, -1, 68, -1, -1, -1, -1,
6482 -1, -1, -1, 76, 77, -1, -1, -1, -1, -1,
6483 -1, -1, -1, -1, -1, -1, -1, -1, 91, 92,
6484 -1, -1, -1, -1, -1, -1, 99, -1, -1, 102,
6485 103, -1, 105, 106, -1, 108, -1, -1, 111, 112,
6486 113, 114, 115, 116, 117, 118, 119, -1, -1, -1,
6487 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6488 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6489 -1, -1, -1, -1, -1, 148, 149, 150, -1, -1,
6490 -1, 1, 155, 3, 4, 5, 6, 7, 161, -1,
6491 10, 11, 12, -1, -1, -1, 16, -1, 18, 19,
6492 20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
6493 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
6494 -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
6495 50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
6496 60, 61, 62, 63, 64, 65, -1, -1, 68, -1,
6497 -1, -1, -1, -1, -1, -1, 76, 77, -1, -1,
6498 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6499 -1, 91, 92, -1, -1, -1, -1, -1, -1, 99,
6500 -1, -1, 102, 103, -1, 105, 106, -1, 108, -1,
6501 -1, 111, 112, 113, 114, 115, 116, 117, 118, 119,
6502 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6503 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6504 -1, -1, -1, -1, -1, -1, -1, -1, 148, 149,
6505 150, -1, -1, -1, 1, 155, 3, 4, 5, 6,
6506 7, 161, -1, -1, 11, 12, -1, -1, -1, 16,
6507 -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
6508 -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
6509 -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
6510 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
6511 57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
6512 -1, -1, -1, -1, -1, -1, -1, -1, -1, 76,
6513 77, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6514 -1, -1, -1, -1, 91, 92, -1, -1, -1, -1,
6515 -1, -1, 99, -1, -1, 102, 103, -1, 105, 106,
6516 -1, 108, -1, -1, 111, 112, 113, 114, 115, 116,
6517 117, 118, 119, -1, -1, -1, -1, -1, -1, -1,
6518 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6519 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6520 -1, 148, 149, 150, -1, -1, -1, -1, 155, -1,
6521 -1, -1, 159, 1, 161, 3, 4, 5, 6, 7,
6522 -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
6523 18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
6524 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
6525 -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
6526 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6527 -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
6528 -1, -1, -1, -1, -1, -1, -1, -1, 76, 77,
6529 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6530 -1, -1, -1, 91, 92, -1, -1, -1, -1, -1,
6531 -1, 99, -1, -1, 102, 103, -1, 105, 106, -1,
6532 108, -1, -1, 111, 112, 113, 114, 115, 116, 117,
6533 118, 119, -1, -1, -1, -1, -1, -1, -1, -1,
6534 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6535 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6536 148, 149, 150, -1, -1, -1, -1, 155, -1, -1,
6537 -1, 159, 1, 161, 3, 4, 5, 6, 7, -1,
6538 -1, -1, 11, 12, -1, -1, -1, 16, -1, 18,
6539 19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
6540 -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
6541 39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
6542 49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
6543 59, 60, 61, 62, 63, 64, 65, -1, -1, -1,
6544 -1, -1, -1, -1, -1, -1, -1, 76, 77, -1,
6545 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6546 -1, -1, 91, 92, -1, -1, -1, -1, -1, -1,
6547 99, -1, -1, 102, 103, -1, 105, 106, -1, 108,
6548 -1, -1, 111, 112, 113, 114, 115, 116, 117, 118,
6549 119, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6550 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6551 -1, -1, -1, -1, -1, -1, -1, -1, -1, 148,
6552 149, 150, -1, -1, 153, 1, 155, 3, 4, 5,
6553 6, 7, 161, -1, -1, 11, 12, -1, -1, -1,
6554 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6555 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
6556 36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
6557 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
6558 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
6559 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6560 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6561 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6562 -1, -1, -1, 99, -1, -1, 102, 103, -1, 105,
6563 106, -1, 108, -1, -1, 111, 112, 113, 114, 115,
6564 116, 117, 118, 119, -1, -1, -1, -1, -1, -1,
6565 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6566 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6567 -1, -1, 148, 149, 150, -1, -1, 153, 1, 155,
6568 3, 4, 5, -1, 7, 161, -1, -1, 11, 12,
6569 -1, -1, -1, 16, 17, 18, 19, 20, 21, 22,
6570 23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
6571 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
6572 -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
6573 53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
6574 63, 64, 65, -1, -1, -1, -1, -1, -1, -1,
6575 -1, -1, -1, 76, 77, -1, -1, -1, -1, -1,
6576 -1, -1, -1, -1, -1, -1, -1, -1, 91, 92,
6577 -1, -1, -1, -1, -1, -1, 99, -1, -1, 102,
6578 103, -1, 105, 106, -1, -1, -1, -1, 111, 112,
6579 113, 114, 115, 116, 117, 118, 119, -1, -1, -1,
6580 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6581 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6582 -1, -1, -1, -1, -1, 148, 149, 150, -1, -1,
6583 -1, -1, 155, -1, -1, -1, -1, -1, 161, 3,
6584 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
6585 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
6586 24, 25, 26, -1, -1, -1, 30, 31, 32, 33,
6587 34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
6588 -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6589 54, 55, 56, 57, -1, -1, -1, -1, -1, -1,
6590 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6591 -1, -1, 76, 77, 78, 79, 80, 81, 82, 83,
6592 84, -1, -1, 87, 88, -1, -1, -1, -1, 93,
6593 94, 95, 96, -1, -1, -1, -1, -1, -1, -1,
6594 -1, -1, -1, -1, 108, 109, -1, -1, -1, -1,
6595 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6596 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6597 -1, -1, -1, -1, 138, 139, 140, 141, 142, 143,
6598 144, 145, 146, 147, -1, 149, 150, -1, -1, -1,
6599 -1, -1, -1, 157, 158, 3, 4, 5, 6, 7,
6600 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
6601 18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
6602 -1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
6603 38, 39, -1, -1, -1, -1, -1, 45, 46, 47,
6604 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6605 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6606 -1, -1, -1, -1, -1, -1, -1, -1, 76, 77,
6607 78, 79, 80, 81, 82, 83, 84, -1, -1, 87,
6608 88, -1, -1, -1, -1, 93, 94, 95, 96, -1,
6609 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6610 108, 109, -1, -1, -1, -1, -1, -1, -1, -1,
6611 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6612 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6613 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
6614 -1, 149, 150, -1, -1, -1, -1, -1, -1, 157,
6615 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
6616 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
6617 23, 24, 25, 26, -1, -1, -1, 30, 31, 32,
6618 33, 34, 35, 36, 37, 38, 39, -1, -1, -1,
6619 -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
6620 53, 54, -1, 56, -1, -1, -1, -1, -1, -1,
6621 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6622 -1, -1, -1, 76, 77, 78, 79, 80, 81, 82,
6623 83, 84, -1, -1, 87, 88, -1, -1, -1, -1,
6624 93, 94, 95, 96, -1, -1, -1, -1, -1, -1,
6625 -1, -1, -1, -1, -1, 108, 109, -1, -1, 112,
6626 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6627 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6628 -1, -1, -1, -1, -1, 138, 139, 140, 141, 142,
6629 143, 144, 145, 146, 147, -1, 149, 150, -1, -1,
6630 -1, -1, -1, -1, 157, 3, 4, 5, 6, 7,
6631 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
6632 18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
6633 -1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
6634 38, 39, -1, -1, -1, -1, -1, 45, 46, 47,
6635 48, 49, 50, 51, 52, 53, -1, -1, 56, -1,
6636 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6637 -1, -1, -1, -1, -1, -1, -1, -1, 76, 77,
6638 78, 79, 80, 81, 82, 83, 84, -1, -1, 87,
6639 88, -1, -1, -1, -1, 93, 94, 95, 96, -1,
6640 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6641 108, 109, -1, -1, 112, -1, -1, -1, -1, -1,
6642 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6643 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6644 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
6645 -1, 149, 150, -1, -1, -1, -1, -1, -1, 157,
6646 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
6647 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
6648 23, 24, 25, 26, -1, -1, -1, 30, 31, 32,
6649 33, 34, 35, 36, 37, 38, 39, -1, -1, -1,
6650 -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
6651 53, -1, -1, 56, -1, -1, -1, -1, -1, -1,
6652 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6653 -1, -1, -1, 76, 77, 78, 79, 80, 81, 82,
6654 83, 84, -1, -1, 87, 88, -1, -1, -1, -1,
6655 93, 94, 95, 96, -1, -1, -1, -1, -1, -1,
6656 -1, -1, -1, -1, -1, 108, 109, -1, -1, -1,
6657 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6658 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6659 -1, -1, -1, -1, -1, 138, 139, 140, 141, 142,
6660 143, 144, 145, 146, 147, -1, 149, 150, 3, 4,
6661 5, -1, 7, -1, 157, -1, 11, 12, -1, -1,
6662 -1, 16, -1, 18, 19, 20, 21, 22, 23, 24,
6663 -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
6664 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
6665 -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
6666 55, 56, 57, -1, 59, 60, 61, 62, 63, 64,
6667 65, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6668 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6669 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6670 -1, -1, -1, -1, 99, -1, -1, 102, 103, -1,
6671 105, 106, -1, -1, -1, -1, 111, 112, 113, 114,
6672 115, 116, 117, 118, 119, -1, -1, 3, 4, 5,
6673 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6674 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6675 -1, -1, -1, 148, 30, 31, 32, 33, 34, 35,
6676 36, 156, -1, 39, -1, -1, -1, -1, -1, -1,
6677 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
6678 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
6679 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6680 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6681 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6682 -1, -1, -1, 99, -1, -1, 102, 103, -1, 105,
6683 106, -1, -1, -1, -1, 111, 112, 113, 114, 115,
6684 116, 117, 118, 119, -1, -1, 3, 4, 5, -1,
6685 7, -1, -1, -1, 11, 12, -1, -1, -1, 16,
6686 -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
6687 -1, -1, 148, 30, 31, 32, 33, 34, 35, 36,
6688 156, -1, 39, -1, -1, -1, -1, -1, -1, 46,
6689 -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
6690 57, 58, 59, 60, 61, 62, 63, 64, 65, -1,
6691 -1, -1, -1, -1, -1, -1, -1, -1, -1, 76,
6692 77, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6693 -1, -1, -1, -1, 91, 92, -1, -1, -1, -1,
6694 -1, -1, 99, -1, -1, 102, 103, -1, 105, 106,
6695 -1, 108, 109, 110, 111, 112, 113, 114, 115, 116,
6696 117, 118, 119, -1, -1, -1, -1, -1, -1, -1,
6697 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6698 -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
6699 7, 148, 149, 150, 11, 12, -1, -1, 155, 16,
6700 -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
6701 -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
6702 -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
6703 -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
6704 57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
6705 -1, -1, -1, -1, -1, -1, -1, -1, -1, 76,
6706 77, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6707 -1, -1, -1, -1, 91, 92, -1, -1, -1, -1,
6708 -1, -1, 99, -1, -1, 102, 103, -1, 105, 106,
6709 -1, -1, -1, -1, 111, 112, 113, 114, 115, 116,
6710 117, 118, 119, -1, -1, -1, -1, -1, -1, -1,
6711 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6712 -1, -1, -1, -1, 1, -1, 3, 4, 5, 6,
6713 7, 148, 149, 150, 11, 12, -1, -1, 155, 16,
6714 -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
6715 -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
6716 -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
6717 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
6718 57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
6719 -1, -1, -1, -1, -1, -1, -1, -1, -1, 76,
6720 77, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6721 -1, -1, -1, -1, 91, 92, -1, -1, -1, -1,
6722 -1, -1, 99, -1, -1, 102, 103, -1, 105, 106,
6723 -1, 108, -1, -1, 111, 112, 113, 114, 115, 116,
6724 117, 118, 119, -1, -1, 1, -1, 3, 4, 5,
6725 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6726 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6727 -1, 148, 149, 150, 30, 31, 32, 33, 34, 35,
6728 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
6729 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
6730 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
6731 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6732 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6733 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6734 -1, -1, -1, 99, -1, -1, 102, 103, -1, 105,
6735 106, -1, -1, -1, -1, 111, 112, 113, 114, 115,
6736 116, 117, 118, 119, -1, -1, -1, -1, 3, 4,
6737 5, -1, 7, -1, -1, -1, 11, 12, -1, -1,
6738 -1, 16, -1, 18, 19, 20, 21, 22, 23, 24,
6739 -1, -1, 148, 149, 150, 30, 31, 32, 33, 34,
6740 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
6741 -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
6742 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
6743 65, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6744 -1, 76, 77, -1, -1, -1, -1, -1, -1, -1,
6745 -1, -1, -1, -1, -1, -1, 91, 92, -1, -1,
6746 -1, -1, -1, -1, 99, -1, -1, 102, 103, -1,
6747 105, 106, -1, 108, 109, 110, 111, 112, 113, 114,
6748 115, 116, 117, 118, 119, -1, -1, -1, -1, 3,
6749 4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
6750 -1, -1, 16, -1, 18, 19, 20, 21, 22, 23,
6751 24, -1, -1, 148, 149, 150, 30, 31, 32, 33,
6752 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
6753 -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
6754 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
6755 64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
6756 -1, -1, 76, 77, -1, -1, -1, -1, -1, -1,
6757 -1, -1, -1, -1, -1, -1, -1, 91, 92, -1,
6758 -1, -1, -1, -1, -1, 99, -1, -1, 102, 103,
6759 -1, 105, 106, -1, 108, 109, 110, 111, 112, 113,
6760 114, 115, 116, 117, 118, 119, -1, -1, -1, -1,
6761 3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
6762 -1, -1, -1, 16, -1, 18, 19, 20, 21, 22,
6763 23, 24, -1, -1, 148, 149, 150, 30, 31, 32,
6764 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
6765 -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
6766 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
6767 63, 64, 65, -1, -1, -1, -1, -1, -1, -1,
6768 -1, -1, -1, 76, 77, -1, -1, -1, -1, -1,
6769 -1, -1, -1, -1, -1, -1, -1, -1, 91, 92,
6770 -1, -1, -1, -1, -1, -1, 99, -1, -1, 102,
6771 103, -1, 105, 106, -1, 108, 109, 110, 111, 112,
6772 113, 114, 115, 116, 117, 118, 119, -1, -1, -1,
6773 -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
6774 12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
6775 22, 23, 24, -1, -1, 148, 149, 150, 30, 31,
6776 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
6777 -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
6778 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
6779 62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
6780 -1, -1, -1, -1, 76, 77, -1, -1, -1, -1,
6781 -1, -1, -1, -1, -1, -1, -1, -1, -1, 91,
6782 92, -1, -1, -1, -1, -1, -1, 99, -1, -1,
6783 102, 103, -1, 105, 106, -1, 108, 109, 110, 111,
6784 112, 113, 114, 115, 116, 117, 118, 119, -1, -1,
6785 -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
6786 11, 12, -1, -1, -1, 16, -1, 18, 19, 20,
6787 21, 22, 23, 24, -1, -1, 148, 149, 150, 30,
6788 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
6789 -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
6790 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
6791 61, 62, 63, 64, 65, -1, -1, -1, -1, -1,
6792 -1, -1, -1, -1, -1, 76, 77, -1, -1, -1,
6793 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6794 91, 92, -1, -1, -1, -1, -1, -1, 99, -1,
6795 -1, 102, 103, -1, 105, 106, -1, 108, 109, -1,
6796 111, 112, 113, 114, 115, 116, 117, 118, 119, -1,
6797 -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
6798 -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
6799 20, 21, 22, 23, 24, -1, -1, 148, 149, 150,
6800 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
6801 -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
6802 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
6803 60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
6804 -1, -1, -1, -1, -1, -1, 76, 77, -1, -1,
6805 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6806 -1, 91, 92, -1, -1, -1, -1, -1, -1, 99,
6807 -1, -1, 102, 103, -1, 105, 106, -1, -1, 109,
6808 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
6809 -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
6810 -1, -1, 11, 12, -1, -1, -1, 16, -1, 18,
6811 19, 20, 21, 22, 23, 24, -1, -1, 148, 149,
6812 150, 30, 31, 32, 33, 34, 35, 36, -1, -1,
6813 39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
6814 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
6815 59, 60, 61, 62, 63, 64, 65, -1, -1, -1,
6816 -1, -1, -1, -1, -1, -1, -1, 76, 77, -1,
6817 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6818 -1, -1, 91, 92, -1, -1, -1, -1, -1, -1,
6819 99, -1, -1, 102, 103, -1, 105, 106, -1, -1,
6820 109, -1, 111, 112, 113, 114, 115, 116, 117, 118,
6821 119, -1, -1, -1, -1, 3, 4, 5, -1, 7,
6822 -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
6823 18, 19, 20, 21, 22, 23, 24, -1, -1, 148,
6824 149, 150, 30, 31, 32, 33, 34, 35, 36, -1,
6825 -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
6826 -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6827 -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
6828 -1, -1, -1, -1, -1, -1, -1, -1, 76, 77,
6829 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6830 -1, -1, -1, 91, 92, -1, -1, -1, -1, -1,
6831 -1, 99, -1, -1, 102, 103, -1, 105, 106, -1,
6832 108, -1, -1, 111, 112, 113, 114, 115, 116, 117,
6833 118, 119, -1, -1, -1, -1, 3, 4, 5, -1,
6834 7, -1, -1, -1, 11, 12, -1, -1, -1, 16,
6835 -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
6836 148, 149, 150, 30, 31, 32, 33, 34, 35, 36,
6837 -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
6838 -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
6839 57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
6840 -1, -1, -1, -1, -1, -1, -1, -1, -1, 76,
6841 77, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6842 -1, -1, -1, -1, 91, 92, -1, -1, -1, -1,
6843 -1, -1, 99, -1, -1, 102, 103, -1, 105, 106,
6844 -1, 108, -1, -1, 111, 112, 113, 114, 115, 116,
6845 117, 118, 119, -1, -1, -1, -1, 3, 4, 5,
6846 -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
6847 16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
6848 -1, 148, 149, 150, 30, 31, 32, 33, 34, 35,
6849 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
6850 46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
6851 56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
6852 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6853 76, 77, -1, -1, -1, -1, -1, -1, -1, -1,
6854 -1, -1, -1, -1, -1, 91, 92, -1, -1, -1,
6855 -1, -1, -1, 99, -1, -1, 102, 103, -1, 105,
6856 106, -1, 108, -1, -1, 111, 112, 113, 114, 115,
6857 116, 117, 118, 119, -1, -1, -1, -1, 3, 4,
6858 5, -1, 7, -1, -1, -1, 11, 12, -1, -1,
6859 -1, 16, -1, 18, 19, 20, 21, 22, 23, 24,
6860 -1, -1, 148, 149, 150, 30, 31, 32, 33, 34,
6861 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
6862 -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
6863 55, 56, 57, -1, 59, 60, 61, 62, 63, 64,
6864 65, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6865 -1, 76, 77, -1, -1, -1, -1, -1, -1, -1,
6866 -1, -1, -1, -1, -1, -1, 91, 92, -1, -1,
6867 -1, -1, -1, -1, 99, -1, -1, 102, 103, -1,
6868 105, 106, -1, 108, -1, -1, 111, 112, 113, 114,
6869 115, 116, 117, 118, 119, -1, -1, -1, -1, 3,
6870 4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
6871 -1, -1, 16, -1, 18, 19, 20, 21, 22, 23,
6872 24, -1, -1, 148, 149, 150, 30, 31, 32, 33,
6873 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
6874 -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
6875 54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
6876 64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
6877 -1, -1, 76, 77, -1, -1, -1, -1, -1, -1,
6878 -1, -1, -1, -1, -1, -1, -1, 91, 92, -1,
6879 -1, -1, -1, -1, -1, 99, -1, -1, 102, 103,
6880 -1, 105, 106, -1, 108, -1, -1, 111, 112, 113,
6881 114, 115, 116, 117, 118, 119, -1, -1, -1, -1,
6882 3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
6883 -1, -1, -1, 16, -1, 18, 19, 20, 21, 22,
6884 23, 24, -1, -1, 148, 149, 150, 30, 31, 32,
6885 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
6886 -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
6887 53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
6888 63, 64, 65, -1, -1, -1, -1, -1, -1, -1,
6889 -1, -1, -1, 76, 77, -1, -1, -1, -1, -1,
6890 -1, -1, -1, -1, -1, -1, -1, -1, 91, 92,
6891 -1, -1, -1, -1, -1, -1, 99, -1, -1, 102,
6892 103, -1, 105, 106, -1, -1, -1, -1, 111, 112,
6893 113, 114, 115, 116, 117, 118, 119, -1, -1, -1,
6894 -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
6895 12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
6896 22, 23, 24, -1, -1, 148, 149, 150, 30, 31,
6897 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
6898 -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
6899 52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
6900 62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
6901 -1, -1, -1, -1, 76, 77, -1, -1, -1, -1,
6902 -1, -1, -1, -1, -1, -1, -1, -1, -1, 91,
6903 92, -1, -1, -1, -1, -1, -1, 99, -1, -1,
6904 102, 103, -1, 105, 106, -1, -1, -1, -1, 111,
6905 112, 113, 114, 115, 116, 117, 118, 119, -1, -1,
6906 -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
6907 11, 12, -1, -1, -1, 16, -1, 18, 19, 20,
6908 21, 22, 23, 24, -1, -1, 148, 149, 150, 30,
6909 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
6910 -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
6911 51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
6912 61, 62, 63, 64, 65, -1, -1, -1, -1, -1,
6913 -1, -1, -1, -1, -1, 76, 77, -1, -1, -1,
6914 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6915 91, 92, -1, -1, -1, -1, -1, -1, 99, -1,
6916 -1, 102, 103, -1, 105, 106, -1, -1, -1, -1,
6917 111, 112, 113, 114, 115, 116, 117, 118, 119, -1,
6918 -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
6919 -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
6920 20, 21, 22, 23, 24, -1, -1, 148, 149, 150,
6921 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
6922 -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
6923 50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
6924 60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
6925 -1, -1, -1, -1, -1, -1, 76, 77, -1, -1,
6926 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6927 -1, 91, 92, -1, -1, -1, -1, -1, -1, 99,
6928 -1, -1, 102, 103, -1, 105, 106, -1, -1, -1,
6929 -1, 111, 112, 113, 114, 115, 116, 117, 118, 119,
6930 -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
6931 -1, -1, 11, 12, -1, -1, -1, 16, -1, 18,
6932 19, 20, 21, 22, 23, 24, -1, -1, 148, 149,
6933 150, 30, 31, 32, 33, 34, 35, 36, -1, -1,
6934 39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
6935 49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
6936 59, 60, 61, 62, 63, 64, 65, -1, -1, -1,
6937 -1, -1, -1, -1, -1, -1, -1, 76, 77, -1,
6938 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6939 -1, -1, 91, 92, -1, -1, -1, -1, -1, -1,
6940 99, -1, -1, 102, 103, -1, 105, 106, -1, -1,
6941 -1, -1, 111, 112, 113, 114, 115, 116, 117, 118,
6942 119, -1, -1, -1, -1, 3, 4, 5, -1, 7,
6943 -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
6944 18, 19, 20, 21, 22, 23, 24, -1, -1, 148,
6945 149, 150, 30, 31, 32, 33, 34, 35, 36, -1,
6946 -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
6947 -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6948 -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
6949 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6950 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6951 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6952 -1, 99, -1, -1, 102, 103, -1, 105, 106, -1,
6953 108, -1, -1, 111, 112, 113, 114, 115, 116, 117,
6954 118, 119, -1, -1, 3, 4, 5, -1, 7, -1,
6955 -1, -1, 11, 12, -1, -1, -1, 16, -1, 18,
6956 19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
6957 148, 30, 31, 32, 33, 34, 35, 36, -1, -1,
6958 39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
6959 49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
6960 59, 60, 61, 62, 63, 64, 65, -1, -1, -1,
6961 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6962 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6963 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6964 99, -1, -1, 102, 103, -1, 105, 106, -1, 108,
6965 -1, -1, 111, 112, 113, 114, 115, 116, 117, 118,
6966 119, -1, -1, 3, 4, 5, -1, 7, -1, -1,
6967 -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
6968 20, 21, 22, 23, 24, -1, -1, -1, -1, 148,
6969 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
6970 -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
6971 50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
6972 60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
6973 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6974 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6975 -1, -1, -1, -1, -1, 95, -1, -1, -1, 99,
6976 -1, -1, 102, 103, -1, 105, 106, -1, -1, -1,
6977 -1, 111, 112, 113, 114, 115, 116, 117, 118, 119,
6978 -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
6979 11, 12, -1, -1, -1, 16, -1, 18, 19, 20,
6980 21, 22, 23, 24, -1, -1, -1, -1, 148, 30,
6981 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
6982 -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
6983 51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
6984 61, 62, 63, 64, 65, -1, -1, -1, -1, -1,
6985 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6986 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6987 -1, -1, -1, -1, -1, -1, -1, -1, 99, -1,
6988 -1, 102, 103, -1, 105, 106, -1, -1, -1, -1,
6989 111, 112, 113, 114, 115, 116, 117, 118, 119, -1,
6990 -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
6991 12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
6992 22, 23, 24, -1, -1, -1, -1, 148, 30, 31,
6993 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
6994 -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
6995 52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
6996 62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
6997 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6998 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
6999 -1, -1, -1, -1, -1, -1, -1, 99, -1, -1,
7000 102, 103, -1, 105, 106, -1, -1, -1, -1, 111,
7001 112, 113, 114, 115, 116, 117, 118, 119, -1, -1,
7002 3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
7003 -1, -1, -1, 16, -1, 18, 19, 20, 21, 22,
7004 23, 24, -1, -1, -1, -1, 148, 30, 31, 32,
7005 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
7006 -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
7007 53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
7008 63, 64, 65, -1, -1, -1, -1, -1, -1, -1,
7009 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7010 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7011 -1, -1, -1, -1, -1, -1, 99, -1, -1, 102,
7012 103, -1, 105, 106, -1, -1, -1, -1, 111, 112,
7013 113, 114, 115, 116, 117, 118, 119, -1, -1, 3,
7014 4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
7015 -1, -1, 16, -1, 18, 19, 20, 21, 22, 23,
7016 24, -1, -1, -1, -1, 148, 30, 31, 32, 33,
7017 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
7018 -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
7019 54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
7020 64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
7021 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7022 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7023 -1, -1, -1, -1, -1, 99, -1, -1, 102, 103,
7024 -1, 105, 106, 33, 34, 35, 36, 111, 112, 113,
7025 114, 115, 116, 117, 118, 119, -1, -1, -1, 49,
7026 50, 51, 52, -1, -1, -1, 56, -1, 58, 59,
7027 60, 61, 62, 63, -1, -1, -1, -1, -1, -1,
7028 -1, -1, -1, -1, 148, -1, -1, -1, 78, -1,
7029 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7030 -1, 91, 92, -1, -1, -1, -1, -1, -1, 99,
7031 -1, -1, 102, -1, -1, 105, 106, -1, 108, 109,
7032 -1, 111, 112, 113, 114, 115, 116, 117, 118, 119,
7033 -1, -1, -1, -1, -1, -1, 33, 34, 35, 36,
7034 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7035 -1, 141, 49, 50, 51, 52, -1, -1, 148, 56,
7036 -1, -1, 59, 60, 61, 62, 63, -1, -1, -1,
7037 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7038 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7039 -1, -1, -1, -1, 91, 92, -1, -1, -1, -1,
7040 -1, -1, 99, -1, -1, 102, -1, -1, 105, 106,
7041 -1, 108, -1, -1, 111, 112, 113, 114, 115, 116,
7042 117, 118, 119, -1, -1, -1, -1, -1, -1, 33,
7043 34, 35, 36, -1, -1, -1, 52, 53, -1, -1,
7044 56, -1, -1, -1, 141, 49, 50, 51, 52, -1,
7045 -1, 148, 56, -1, -1, 59, 60, 61, 62, 63,
7046 76, 77, 78, 79, 80, 81, 82, 83, 84, -1,
7047 -1, 87, 88, -1, -1, -1, -1, 93, 94, 95,
7048 96, -1, -1, -1, -1, -1, -1, 91, 92, -1,
7049 -1, -1, 108, 109, -1, 99, -1, -1, 102, -1,
7050 -1, 105, 106, -1, -1, -1, -1, 111, 112, 113,
7051 114, 115, 116, 117, 118, 119, -1, -1, -1, -1,
7052 -1, -1, 138, 139, 140, 141, 142, 143, 144, 145,
7053 146, 147, -1, 149, 150, 52, 53, 141, -1, 56,
7054 -1, 157, 158, -1, 148, -1, -1, -1, -1, -1,
7055 -1, -1, -1, -1, -1, -1, -1, -1, -1, 76,
7056 77, 78, 79, 80, 81, 82, 83, 84, -1, -1,
7057 87, 88, -1, -1, -1, -1, 93, 94, 95, 96,
7058 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7059 -1, 108, 109, -1, -1, -1, -1, -1, -1, -1,
7060 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7061 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7062 -1, 138, 139, 140, 141, 142, 143, 144, 145, 146,
7063 147, -1, 149, 150, 52, 53, -1, -1, 56, -1,
7064 157, 158, -1, -1, -1, -1, -1, -1, -1, -1,
7065 -1, -1, -1, -1, -1, -1, -1, -1, 76, 77,
7066 78, 79, 80, 81, 82, 83, 84, -1, -1, 87,
7067 88, -1, -1, -1, -1, 93, 94, 95, 96, -1,
7068 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7069 108, 109, -1, -1, -1, -1, -1, -1, -1, -1,
7070 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7071 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7072 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
7073 -1, 149, 150, 52, 53, -1, -1, 56, -1, 157,
7074 158, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7075 -1, -1, -1, -1, -1, -1, -1, 76, 77, 78,
7076 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
7077 -1, -1, -1, -1, 93, 94, 95, 96, -1, -1,
7078 -1, -1, -1, -1, -1, -1, -1, -1, -1, 108,
7079 109, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7080 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7081 -1, -1, -1, -1, -1, -1, -1, -1, -1, 138,
7082 139, 140, 141, 142, 143, 144, 145, 146, 147, -1,
7083 149, 150, 52, 53, -1, -1, 56, -1, 157, 158,
7084 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7085 -1, -1, -1, -1, -1, -1, 76, 77, 78, 79,
7086 80, 81, 82, 83, 84, -1, -1, 87, 88, -1,
7087 -1, -1, -1, 93, 94, 95, 96, -1, -1, -1,
7088 -1, -1, -1, -1, -1, -1, -1, -1, 108, 109,
7089 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7090 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7091 -1, -1, -1, -1, -1, -1, -1, -1, 138, 139,
7092 140, 141, 142, 143, 144, 145, 146, 147, -1, 149,
7093 150, 52, 53, -1, -1, 56, -1, 157, 158, -1,
7094 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7095 -1, -1, -1, -1, -1, 76, 77, 78, 79, 80,
7096 81, 82, 83, 84, -1, -1, 87, 88, -1, -1,
7097 -1, -1, 93, 94, 95, 96, -1, -1, -1, -1,
7098 -1, -1, -1, -1, -1, -1, -1, 108, 109, -1,
7099 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7100 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7101 -1, -1, -1, -1, -1, -1, -1, 138, 139, 140,
7102 141, 142, 143, 144, 145, 146, 147, -1, 149, 150,
7103 52, 53, -1, -1, 56, -1, 157, 158, -1, -1,
7104 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7105 -1, -1, -1, -1, 76, 77, 78, 79, 80, 81,
7106 82, 83, 84, -1, -1, 87, 88, -1, -1, -1,
7107 -1, 93, 94, 95, 96, -1, -1, -1, -1, -1,
7108 -1, -1, -1, -1, -1, -1, 108, 109, -1, -1,
7109 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7110 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7111 -1, -1, -1, -1, -1, -1, 138, 139, 140, 141,
7112 142, 143, 144, 145, 146, 147, -1, 149, 150, 52,
7113 53, -1, -1, 56, -1, 157, 158, -1, -1, -1,
7114 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7115 -1, -1, -1, 76, 77, 78, 79, 80, 81, 82,
7116 83, 84, -1, -1, 87, 88, -1, -1, -1, -1,
7117 93, 94, 95, 96, -1, -1, -1, -1, -1, -1,
7118 -1, -1, -1, -1, -1, 108, 109, -1, -1, -1,
7119 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7120 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7121 -1, -1, -1, -1, -1, 138, 139, 140, 141, 142,
7122 143, 144, 145, 146, 147, -1, 149, 150, 52, 53,
7123 -1, -1, 56, -1, 157, 158, -1, -1, -1, -1,
7124 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7125 -1, -1, 76, 77, 78, 79, 80, 81, 82, 83,
7126 84, -1, -1, 87, 88, -1, -1, -1, -1, 93,
7127 94, 95, 96, -1, -1, -1, -1, -1, -1, -1,
7128 -1, -1, -1, -1, 108, 109, -1, -1, -1, -1,
7129 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7130 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7131 -1, -1, -1, -1, 138, 139, 140, 141, 142, 143,
7132 144, 145, 146, 147, -1, 149, 150, 52, 53, -1,
7133 -1, 56, -1, 157, 158, -1, -1, -1, -1, -1,
7134 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7135 -1, 76, 77, 78, 79, 80, 81, 82, 83, 84,
7136 -1, -1, 87, 88, -1, -1, -1, -1, 93, 94,
7137 95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
7138 -1, -1, -1, 108, 109, -1, -1, -1, -1, -1,
7139 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7140 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7141 -1, -1, -1, 138, 139, 140, 141, 142, 143, 144,
7142 145, 146, 147, -1, 149, 150, 52, 53, -1, -1,
7143 56, -1, 157, 158, -1, -1, -1, -1, -1, -1,
7144 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7145 76, 77, 78, 79, 80, 81, 82, 83, 84, -1,
7146 -1, 87, 88, -1, -1, -1, -1, 93, 94, 95,
7147 96, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7148 -1, -1, 108, 109, -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, 138, 139, 140, 141, 142, 143, 144, 145,
7152 146, 147, -1, 149, 150, 52, 53, -1, -1, 56,
7153 -1, 157, 158, -1, -1, -1, -1, -1, -1, -1,
7154 -1, -1, -1, -1, -1, -1, -1, -1, -1, 76,
7155 77, 78, 79, 80, 81, 82, 83, 84, -1, -1,
7156 87, 88, -1, -1, -1, -1, 93, 94, 95, 96,
7157 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7158 -1, 108, 109, -1, -1, -1, -1, -1, -1, -1,
7159 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7160 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7161 -1, 138, 139, 140, 141, 142, 143, 144, 145, 146,
7162 147, -1, 149, 150, 52, 53, -1, -1, 56, -1,
7163 157, 158, -1, -1, -1, -1, -1, -1, -1, -1,
7164 -1, -1, -1, -1, -1, -1, -1, -1, 76, 77,
7165 78, 79, 80, 81, 82, 83, 84, -1, -1, 87,
7166 88, -1, -1, -1, -1, 93, 94, 95, 96, -1,
7167 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7168 108, 109, -1, -1, -1, -1, -1, -1, -1, -1,
7169 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7170 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7171 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
7172 -1, 149, 150, 52, 53, -1, -1, 56, -1, 157,
7173 158, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7174 -1, -1, -1, -1, -1, -1, -1, 76, 77, 78,
7175 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
7176 -1, -1, -1, -1, 93, 94, 95, 96, -1, -1,
7177 -1, -1, -1, -1, -1, -1, -1, -1, -1, 108,
7178 109, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7179 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7180 -1, -1, -1, -1, -1, -1, -1, -1, -1, 138,
7181 139, 140, 141, 142, 143, 144, 145, 146, 147, -1,
7182 149, 150, 52, 53, -1, -1, 56, -1, 157, 158,
7183 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7184 -1, -1, -1, -1, -1, -1, 76, 77, 78, 79,
7185 80, 81, 82, 83, 84, -1, -1, 87, 88, -1,
7186 -1, -1, -1, 93, 94, 95, 96, -1, -1, -1,
7187 -1, -1, -1, -1, -1, -1, -1, -1, 108, 109,
7188 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7189 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7190 -1, -1, -1, -1, -1, -1, -1, -1, 138, 139,
7191 140, 141, 142, 143, 144, 145, 146, 147, -1, 149,
7192 150, 52, 53, -1, -1, 56, -1, 157, 158, -1,
7193 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7194 -1, -1, -1, -1, -1, 76, 77, 78, 79, 80,
7195 81, 82, 83, 84, -1, -1, 87, 88, -1, -1,
7196 -1, -1, 93, 94, 95, 96, -1, -1, -1, -1,
7197 -1, -1, -1, -1, -1, -1, -1, 108, 109, -1,
7198 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7199 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
7200 -1, -1, -1, -1, -1, -1, -1, 138, 139, 140,
7201 141, 142, 143, 144, 145, 146, 147, -1, 149, 150,
7202 -1, -1, -1, -1, -1, -1, 157
7207 static const yytype_int16 yystos[] =
7209 0, 164, 165, 1, 3, 4, 5, 6, 7, 11,
7210 12, 16, 18, 19, 20, 21, 22, 23, 24, 30,
7211 31, 32, 33, 34, 35, 36, 39, 45, 46, 47,
7212 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
7213 59, 60, 61, 62, 63, 64, 65, 76, 77, 91,
7214 92, 99, 102, 103, 105, 106, 108, 111, 112, 113,
7215 114, 115, 116, 117, 118, 119, 148, 149, 150, 167,
7216 168, 169, 181, 183, 184, 188, 192, 194, 199, 200,
7217 202, 203, 204, 206, 207, 208, 210, 211, 220, 223,
7218 242, 252, 253, 254, 255, 256, 257, 258, 259, 260,
7219 261, 262, 271, 272, 302, 307, 308, 356, 357, 358,
7220 359, 360, 361, 363, 364, 367, 368, 370, 371, 372,
7221 373, 386, 387, 389, 390, 391, 392, 393, 394, 395,
7222 396, 397, 432, 444, 0, 3, 4, 5, 6, 7,
7223 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
7224 18, 19, 20, 21, 22, 23, 24, 25, 26, 30,
7225 31, 32, 33, 34, 35, 36, 37, 38, 39, 45,
7226 46, 47, 48, 49, 50, 51, 52, 53, 56, 76,
7227 77, 78, 79, 80, 81, 82, 83, 84, 87, 88,
7228 93, 94, 95, 96, 108, 109, 138, 139, 140, 141,
7229 142, 143, 144, 145, 146, 147, 149, 150, 157, 214,
7230 215, 216, 218, 219, 386, 180, 180, 180, 39, 58,
7231 99, 102, 108, 109, 110, 113, 149, 192, 194, 203,
7232 211, 220, 227, 233, 236, 238, 239, 252, 393, 394,
7233 396, 397, 430, 431, 233, 158, 230, 234, 235, 155,
7234 158, 186, 54, 215, 186, 152, 170, 171, 224, 444,
7235 21, 22, 32, 202, 220, 252, 271, 272, 220, 220,
7236 220, 56, 47, 102, 176, 177, 178, 183, 205, 206,
7237 444, 176, 228, 238, 430, 444, 227, 429, 430, 444,
7238 46, 99, 148, 156, 192, 194, 210, 242, 252, 393,
7239 394, 397, 300, 214, 376, 388, 392, 376, 377, 378,
7240 162, 362, 362, 362, 362, 391, 199, 220, 220, 155,
7241 161, 166, 442, 443, 180, 40, 41, 42, 43, 44,
7242 37, 38, 158, 400, 401, 402, 403, 444, 400, 402,
7243 26, 152, 230, 235, 263, 309, 28, 264, 306, 135,
7244 156, 102, 108, 207, 135, 25, 78, 79, 80, 81,
7245 82, 83, 84, 85, 86, 87, 88, 89, 90, 95,
7246 96, 101, 136, 138, 139, 140, 141, 142, 143, 144,
7247 145, 146, 147, 222, 222, 69, 97, 98, 154, 436,
7248 243, 1, 188, 195, 195, 196, 198, 198, 166, 195,
7249 443, 99, 204, 211, 252, 277, 393, 394, 397, 52,
7250 56, 95, 99, 212, 213, 252, 393, 394, 397, 213,
7251 33, 34, 35, 36, 49, 50, 51, 52, 56, 158,
7252 191, 214, 395, 427, 233, 158, 235, 98, 436, 437,
7253 309, 359, 100, 100, 156, 227, 56, 227, 227, 227,
7254 376, 400, 400, 135, 101, 156, 237, 444, 98, 154,
7255 436, 100, 100, 156, 237, 92, 232, 233, 238, 410,
7256 430, 444, 233, 186, 188, 438, 188, 54, 64, 65,
7257 182, 158, 224, 225, 167, 98, 436, 100, 179, 205,
7258 159, 166, 443, 438, 244, 160, 156, 186, 441, 156,
7259 441, 153, 441, 186, 56, 391, 207, 209, 401, 156,
7260 98, 154, 436, 297, 66, 120, 122, 123, 379, 120,
7261 120, 379, 67, 379, 162, 365, 374, 369, 375, 78,
7262 161, 169, 152, 195, 195, 195, 195, 224, 226, 188,
7263 188, 52, 54, 55, 56, 57, 58, 78, 92, 102,
7264 108, 109, 110, 142, 145, 282, 344, 404, 405, 406,
7265 407, 409, 410, 411, 412, 413, 414, 415, 416, 417,
7266 419, 420, 421, 422, 423, 424, 425, 135, 250, 409,
7267 135, 251, 310, 311, 107, 201, 312, 313, 313, 224,
7268 205, 156, 210, 156, 224, 190, 220, 220, 220, 220,
7269 220, 220, 220, 220, 220, 220, 220, 220, 220, 189,
7270 220, 220, 220, 220, 220, 220, 220, 220, 220, 220,
7271 220, 52, 53, 56, 218, 230, 432, 433, 434, 232,
7272 238, 52, 53, 56, 218, 230, 433, 174, 176, 13,
7273 273, 442, 273, 195, 176, 176, 246, 166, 56, 98,
7274 154, 436, 25, 195, 52, 56, 212, 139, 399, 98,
7275 154, 436, 249, 428, 69, 98, 435, 233, 438, 52,
7276 56, 433, 224, 224, 217, 125, 135, 135, 224, 227,
7277 227, 236, 239, 430, 52, 56, 232, 52, 56, 224,
7278 224, 431, 438, 156, 438, 156, 159, 438, 215, 225,
7279 220, 153, 56, 433, 433, 224, 171, 438, 178, 159,
7280 430, 156, 209, 52, 56, 232, 52, 56, 298, 381,
7281 380, 120, 366, 379, 66, 120, 120, 366, 66, 120,
7282 220, 176, 183, 102, 108, 278, 279, 280, 281, 412,
7283 156, 426, 444, 156, 426, 156, 408, 438, 283, 284,
7284 156, 408, 227, 34, 52, 52, 156, 408, 52, 39,
7285 185, 203, 220, 221, 174, 442, 185, 221, 174, 297,
7286 153, 311, 297, 10, 68, 270, 270, 108, 199, 227,
7287 238, 240, 241, 438, 209, 156, 184, 187, 199, 211,
7288 220, 227, 229, 241, 252, 397, 319, 319, 186, 100,
7289 100, 152, 230, 235, 186, 439, 156, 100, 100, 230,
7290 231, 235, 444, 270, 224, 176, 13, 176, 27, 274,
7291 442, 270, 270, 17, 267, 315, 25, 245, 321, 52,
7292 56, 232, 52, 56, 198, 248, 398, 247, 52, 56,
7293 212, 232, 174, 188, 193, 438, 231, 235, 187, 220,
7294 229, 187, 229, 215, 227, 39, 237, 100, 100, 439,
7295 100, 100, 410, 430, 188, 229, 441, 207, 439, 299,
7296 382, 385, 392, 397, 362, 379, 362, 362, 362, 153,
7297 280, 412, 156, 438, 156, 425, 417, 419, 421, 405,
7298 406, 415, 423, 135, 227, 407, 414, 423, 413, 415,
7299 186, 44, 44, 270, 270, 298, 153, 298, 227, 156,
7300 44, 209, 44, 135, 44, 98, 154, 436, 317, 317,
7301 137, 224, 224, 311, 201, 160, 100, 224, 224, 201,
7302 8, 265, 352, 444, 14, 15, 268, 269, 275, 276,
7303 444, 276, 197, 108, 227, 314, 270, 319, 315, 270,
7304 439, 176, 442, 195, 174, 439, 270, 438, 191, 309,
7305 306, 186, 224, 224, 100, 224, 224, 438, 156, 438,
7306 180, 383, 438, 278, 281, 279, 426, 156, 408, 156,
7307 408, 156, 408, 156, 408, 408, 185, 221, 226, 226,
7308 299, 299, 108, 227, 226, 226, 224, 226, 52, 56,
7309 232, 52, 56, 318, 318, 220, 187, 229, 187, 229,
7310 153, 224, 187, 229, 187, 229, 227, 241, 353, 444,
7311 175, 268, 176, 195, 270, 270, 227, 156, 273, 317,
7312 270, 270, 174, 442, 270, 224, 158, 303, 409, 176,
7313 156, 156, 415, 415, 423, 415, 220, 220, 180, 180,
7314 227, 183, 183, 220, 439, 52, 56, 58, 91, 92,
7315 99, 102, 105, 106, 108, 113, 141, 302, 324, 325,
7316 326, 327, 330, 334, 335, 336, 339, 340, 341, 342,
7317 343, 344, 345, 346, 347, 348, 349, 350, 351, 356,
7318 357, 360, 361, 364, 368, 371, 373, 394, 419, 324,
7319 187, 229, 101, 354, 444, 9, 266, 355, 444, 172,
7320 273, 108, 227, 176, 318, 270, 409, 301, 0, 121,
7321 384, 279, 408, 408, 156, 408, 408, 140, 292, 293,
7322 444, 292, 347, 347, 56, 212, 318, 325, 332, 333,
7323 334, 335, 338, 439, 186, 318, 440, 52, 376, 52,
7324 102, 392, 101, 156, 140, 156, 156, 325, 89, 90,
7325 98, 154, 158, 328, 329, 52, 99, 211, 252, 393,
7326 394, 397, 273, 177, 176, 176, 227, 276, 315, 316,
7327 323, 324, 186, 294, 29, 124, 304, 415, 282, 285,
7328 286, 288, 289, 291, 294, 413, 415, 416, 418, 423,
7329 425, 176, 174, 325, 439, 325, 336, 338, 439, 156,
7330 153, 224, 125, 195, 348, 332, 336, 330, 337, 338,
7331 113, 341, 345, 347, 347, 212, 318, 439, 318, 438,
7332 332, 335, 339, 332, 335, 339, 56, 98, 154, 436,
7333 176, 166, 173, 275, 273, 40, 41, 161, 159, 305,
7334 176, 408, 426, 156, 426, 156, 290, 294, 140, 284,
7335 156, 287, 290, 99, 252, 156, 290, 438, 156, 156,
7336 331, 438, 156, 156, 376, 438, 438, 438, 439, 439,
7337 439, 52, 56, 232, 52, 56, 352, 355, 320, 195,
7338 195, 52, 295, 296, 411, 174, 153, 418, 421, 286,
7339 288, 415, 423, 140, 252, 289, 423, 56, 98, 415,
7340 337, 339, 337, 336, 338, 439, 176, 156, 186, 270,
7341 426, 156, 290, 156, 290, 156, 290, 156, 290, 52,
7342 56, 290, 156, 440, 276, 321, 322, 296, 415, 415,
7343 423, 415, 290, 290, 156, 290, 290, 415, 290
7347 static const yytype_int16 yyr1[] =
7349 0, 163, 164, 165, 166, 166, 167, 168, 168, 168,
7350 169, 169, 170, 171, 172, 173, 174, 175, 174, 176,
7351 177, 177, 177, 178, 179, 178, 180, 181, 182, 183,
7352 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
7353 183, 183, 183, 183, 183, 183, 183, 184, 184, 184,
7354 184, 184, 184, 184, 184, 184, 184, 185, 185, 186,
7355 186, 185, 187, 187, 187, 188, 188, 188, 188, 188,
7356 189, 188, 190, 188, 188, 191, 192, 193, 194, 195,
7357 195, 196, 197, 198, 199, 199, 200, 200, 201, 202,
7358 203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
7359 203, 203, 204, 204, 205, 205, 206, 206, 206, 206,
7360 206, 206, 206, 206, 206, 206, 207, 207, 208, 208,
7361 209, 209, 210, 210, 210, 210, 210, 210, 210, 210,
7362 210, 211, 211, 211, 211, 211, 211, 211, 211, 211,
7363 212, 212, 213, 213, 213, 214, 214, 214, 214, 214,
7364 215, 215, 216, 217, 216, 218, 218, 218, 218, 218,
7365 218, 218, 218, 218, 218, 218, 218, 218, 218, 218,
7366 218, 218, 218, 218, 218, 218, 218, 218, 218, 218,
7367 218, 218, 218, 218, 218, 219, 219, 219, 219, 219,
7368 219, 219, 219, 219, 219, 219, 219, 219, 219, 219,
7369 219, 219, 219, 219, 219, 219, 219, 219, 219, 219,
7370 219, 219, 219, 219, 219, 219, 219, 219, 219, 219,
7371 219, 219, 219, 219, 219, 219, 220, 220, 220, 220,
7372 220, 220, 220, 220, 220, 220, 220, 220, 220, 220,
7373 220, 220, 220, 220, 220, 220, 220, 220, 220, 220,
7374 220, 220, 220, 220, 220, 220, 220, 220, 220, 220,
7375 220, 220, 220, 220, 220, 220, 220, 220, 220, 220,
7376 220, 221, 221, 221, 222, 222, 222, 222, 223, 223,
7377 224, 225, 226, 227, 228, 228, 228, 228, 229, 229,
7378 230, 230, 230, 231, 231, 232, 232, 232, 232, 232,
7379 233, 233, 233, 233, 233, 234, 235, 236, 236, 237,
7380 237, 238, 238, 238, 238, 239, 239, 240, 240, 241,
7381 241, 241, 242, 242, 242, 242, 242, 242, 242, 242,
7382 242, 242, 242, 243, 242, 244, 242, 242, 242, 242,
7383 242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
7384 242, 242, 242, 242, 242, 242, 242, 245, 242, 246,
7385 242, 242, 242, 247, 242, 248, 242, 249, 242, 250,
7386 242, 251, 242, 242, 242, 242, 242, 252, 253, 254,
7387 255, 256, 257, 258, 259, 260, 261, 262, 263, 264,
7388 265, 266, 267, 268, 269, 270, 270, 271, 272, 273,
7389 273, 273, 274, 274, 275, 275, 276, 276, 277, 277,
7390 278, 278, 279, 279, 280, 280, 280, 280, 280, 281,
7391 281, 282, 282, 283, 284, 285, 285, 286, 286, 286,
7392 286, 287, 288, 289, 289, 290, 290, 291, 291, 291,
7393 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
7394 291, 291, 292, 292, 293, 293, 294, 294, 295, 295,
7395 296, 296, 297, 298, 299, 300, 301, 302, 303, 303,
7396 304, 305, 304, 306, 307, 307, 307, 307, 308, 308,
7397 308, 308, 308, 308, 308, 308, 308, 309, 309, 310,
7398 311, 312, 313, 314, 314, 314, 314, 315, 316, 316,
7399 317, 318, 319, 320, 321, 322, 322, 323, 323, 323,
7400 324, 324, 324, 324, 324, 324, 325, 326, 326, 327,
7401 327, 328, 329, 330, 330, 330, 330, 330, 330, 330,
7402 330, 330, 330, 330, 330, 330, 331, 330, 330, 330,
7403 332, 332, 332, 332, 332, 332, 333, 333, 334, 334,
7404 335, 336, 336, 337, 337, 338, 339, 339, 339, 339,
7405 340, 340, 341, 341, 342, 342, 343, 343, 344, 345,
7406 345, 346, 346, 346, 346, 346, 346, 346, 346, 346,
7407 346, 347, 347, 347, 347, 347, 347, 347, 347, 347,
7408 347, 348, 349, 349, 350, 351, 351, 351, 352, 352,
7409 353, 353, 353, 354, 354, 355, 355, 356, 356, 357,
7410 358, 358, 358, 359, 360, 361, 362, 362, 363, 364,
7411 365, 365, 366, 366, 367, 368, 369, 369, 370, 371,
7412 372, 373, 374, 374, 375, 375, 376, 376, 377, 377,
7413 378, 378, 379, 380, 379, 381, 382, 383, 379, 384,
7414 384, 385, 385, 386, 386, 387, 388, 388, 389, 390,
7415 390, 391, 391, 391, 391, 392, 392, 392, 393, 393,
7416 393, 394, 394, 394, 394, 394, 394, 394, 395, 395,
7417 396, 396, 397, 397, 398, 399, 399, 400, 400, 401,
7418 402, 403, 402, 404, 404, 405, 405, 405, 405, 405,
7419 406, 407, 407, 408, 408, 409, 409, 409, 409, 409,
7420 409, 409, 409, 409, 409, 409, 409, 409, 409, 409,
7421 410, 411, 411, 411, 411, 412, 412, 413, 414, 414,
7422 415, 415, 416, 417, 417, 418, 418, 419, 419, 420,
7423 421, 421, 422, 422, 423, 423, 424, 424, 425, 425,
7424 426, 426, 427, 428, 427, 429, 429, 430, 430, 431,
7425 431, 431, 431, 431, 431, 432, 432, 432, 433, 433,
7426 434, 434, 434, 435, 435, 436, 436, 437, 437, 438,
7427 439, 440, 441, 441, 442, 442, 443, 443, 444
7431 static const yytype_int8 yyr2[] =
7433 0, 2, 0, 2, 0, 1, 2, 1, 1, 3,
7434 1, 2, 1, 3, 0, 0, 8, 0, 5, 2,
7435 1, 1, 3, 1, 0, 3, 0, 2, 0, 4,
7436 3, 3, 3, 2, 3, 3, 3, 3, 4, 5,
7437 1, 4, 4, 7, 4, 1, 1, 4, 4, 7,
7438 6, 6, 6, 6, 4, 4, 4, 1, 4, 0,
7439 1, 3, 1, 4, 1, 1, 3, 3, 3, 2,
7440 0, 7, 0, 7, 1, 1, 2, 0, 5, 1,
7441 1, 0, 0, 4, 1, 1, 1, 4, 3, 1,
7442 2, 3, 4, 5, 4, 5, 6, 2, 2, 2,
7443 2, 2, 1, 3, 1, 3, 1, 2, 3, 5,
7444 2, 4, 2, 4, 1, 3, 1, 3, 2, 3,
7445 1, 3, 1, 1, 4, 3, 3, 3, 3, 2,
7446 1, 1, 1, 4, 3, 3, 3, 3, 2, 1,
7447 1, 1, 2, 1, 3, 1, 1, 1, 1, 1,
7448 1, 1, 1, 0, 4, 1, 1, 1, 1, 1,
7449 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7450 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7451 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7452 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7453 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7454 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7455 1, 1, 1, 1, 1, 1, 4, 4, 7, 6,
7456 6, 6, 6, 5, 4, 3, 3, 2, 2, 2,
7457 2, 3, 3, 3, 3, 3, 3, 4, 2, 2,
7458 3, 3, 3, 3, 1, 3, 3, 3, 3, 3,
7459 2, 2, 3, 3, 3, 3, 4, 6, 4, 4,
7460 1, 1, 4, 3, 1, 1, 1, 1, 3, 3,
7461 1, 1, 1, 1, 1, 2, 4, 2, 1, 4,
7462 3, 5, 3, 1, 1, 1, 1, 2, 4, 2,
7463 1, 2, 2, 4, 1, 0, 2, 2, 1, 2,
7464 1, 1, 1, 3, 3, 2, 1, 1, 1, 3,
7465 4, 2, 1, 1, 1, 1, 1, 1, 1, 1,
7466 1, 1, 1, 0, 4, 0, 4, 3, 3, 2,
7467 3, 3, 1, 4, 3, 1, 6, 4, 3, 2,
7468 1, 2, 1, 6, 6, 4, 4, 0, 6, 0,
7469 5, 5, 6, 0, 6, 0, 7, 0, 5, 0,
7470 5, 0, 5, 1, 1, 1, 1, 1, 1, 1,
7471 1, 2, 2, 1, 2, 1, 1, 1, 1, 1,
7472 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7473 1, 2, 1, 1, 1, 5, 1, 2, 1, 1,
7474 1, 3, 1, 3, 1, 3, 5, 1, 3, 2,
7475 1, 1, 1, 0, 2, 1, 3, 4, 2, 2,
7476 1, 1, 3, 1, 3, 2, 0, 6, 8, 4,
7477 6, 4, 2, 6, 2, 4, 6, 2, 4, 2,
7478 4, 1, 1, 1, 3, 4, 1, 4, 1, 3,
7479 1, 1, 0, 0, 0, 0, 0, 9, 4, 1,
7480 3, 0, 4, 3, 2, 4, 5, 5, 2, 4,
7481 4, 3, 3, 3, 2, 1, 4, 3, 3, 0,
7482 7, 0, 7, 1, 2, 3, 4, 5, 1, 1,
7483 0, 0, 0, 0, 9, 1, 1, 1, 3, 3,
7484 1, 2, 3, 1, 1, 1, 1, 3, 1, 3,
7485 1, 2, 2, 1, 1, 4, 4, 4, 3, 4,
7486 4, 4, 3, 3, 3, 2, 0, 6, 2, 4,
7487 1, 1, 2, 2, 4, 1, 2, 3, 1, 3,
7488 5, 2, 1, 1, 3, 1, 3, 1, 2, 1,
7489 1, 3, 2, 1, 1, 3, 2, 1, 2, 1,
7490 1, 1, 3, 3, 2, 2, 1, 1, 1, 2,
7491 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7492 1, 1, 2, 2, 4, 2, 3, 1, 6, 1,
7493 1, 1, 1, 2, 1, 3, 1, 1, 1, 1,
7494 1, 1, 2, 3, 3, 3, 1, 2, 4, 1,
7495 0, 3, 1, 2, 4, 1, 0, 3, 4, 1,
7496 4, 1, 0, 3, 0, 3, 0, 2, 0, 2,
7497 0, 2, 1, 0, 3, 0, 0, 0, 6, 1,
7498 1, 1, 1, 1, 1, 2, 1, 1, 3, 1,
7499 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7500 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7501 1, 1, 1, 1, 0, 4, 0, 1, 1, 3,
7502 1, 0, 3, 1, 3, 4, 2, 2, 1, 1,
7503 3, 1, 3, 2, 0, 6, 8, 4, 6, 4,
7504 6, 2, 4, 6, 2, 4, 2, 4, 1, 0,
7505 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
7506 1, 3, 1, 2, 1, 2, 1, 1, 1, 1,
7507 2, 1, 1, 1, 2, 1, 1, 1, 2, 1,
7508 2, 1, 1, 0, 4, 1, 2, 1, 3, 3,
7509 2, 1, 4, 2, 1, 1, 1, 1, 1, 1,
7510 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
7511 2, 2, 1, 1, 1, 1, 1, 2, 0
7515 enum { YYENOMEM = -2 };
7517 #define yyerrok (yyerrstatus = 0)
7518 #define yyclearin (yychar = YYEMPTY)
7520 #define YYACCEPT goto yyacceptlab
7521 #define YYABORT goto yyabortlab
7522 #define YYERROR goto yyerrorlab
7523 #define YYNOMEM goto yyexhaustedlab
7526 #define YYRECOVERING() (!!yyerrstatus)
7528 #define YYBACKUP(Token, Value) \
7530 if (yychar == YYEMPTY) \
7534 YYPOPSTACK (yylen); \
7540 yyerror (&yylloc, p, YY_("syntax error: cannot back up")); \
7547 #define YYERRCODE YYUNDEF
7553 #ifndef YYLLOC_DEFAULT
7554 # define YYLLOC_DEFAULT(Current, Rhs, N) \
7558 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
7559 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
7560 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
7561 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
7565 (Current).first_line = (Current).last_line = \
7566 YYRHSLOC (Rhs, 0).last_line; \
7567 (Current).first_column = (Current).last_column = \
7568 YYRHSLOC (Rhs, 0).last_column; \
7573 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
7581 # define YYFPRINTF fprintf
7584 # define YYDPRINTF(Args) \
7595 # ifndef YYLOCATION_PRINT
7597 # if defined YY_LOCATION_PRINT
7601 # define YYLOCATION_PRINT(File, Loc, p) YY_LOCATION_PRINT(File, *(Loc), p)
7603 # elif defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
7609 yy_location_print_ (
FILE *yyo,
YYLTYPE const *
const yylocp)
7612 int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
7613 if (0 <= yylocp->first_line)
7615 res += YYFPRINTF (yyo,
"%d", yylocp->first_line);
7616 if (0 <= yylocp->first_column)
7617 res += YYFPRINTF (yyo,
".%d", yylocp->first_column);
7619 if (0 <= yylocp->last_line)
7621 if (yylocp->first_line < yylocp->last_line)
7623 res += YYFPRINTF (yyo,
"-%d", yylocp->last_line);
7625 res += YYFPRINTF (yyo,
".%d", end_col);
7627 else if (0 <= end_col && yylocp->first_column < end_col)
7628 res += YYFPRINTF (yyo,
"-%d", end_col);
7633 # define YYLOCATION_PRINT yy_location_print_
7637 # define YY_LOCATION_PRINT(File, Loc, p) YYLOCATION_PRINT(File, &(Loc), p)
7641 # define YYLOCATION_PRINT(File, Loc, p) ((void) 0)
7644 # define YY_LOCATION_PRINT YYLOCATION_PRINT
7650 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location, p) \
7654 YYFPRINTF (stderr, "%s ", Title); \
7655 yy_symbol_print (stderr, \
7656 Kind, Value, Location, p); \
7657 YYFPRINTF (stderr, "\n"); \
7667 yy_symbol_value_print (
FILE *yyo,
7670 FILE *yyoutput = yyo;
7672 YY_USE (yylocationp);
7676 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
7679 case YYSYMBOL_keyword_class:
7680 #line 2624 "parse.y"
7682 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7684 #line 7685 "parse.c"
7687 case YYSYMBOL_keyword_module:
7688 #line 2624 "parse.y"
7690 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7692 #line 7693 "parse.c"
7695 case YYSYMBOL_keyword_def:
7696 #line 2624 "parse.y"
7698 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7700 #line 7701 "parse.c"
7703 case YYSYMBOL_keyword_undef:
7704 #line 2624 "parse.y"
7706 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7708 #line 7709 "parse.c"
7711 case YYSYMBOL_keyword_begin:
7712 #line 2624 "parse.y"
7714 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7716 #line 7717 "parse.c"
7719 case YYSYMBOL_keyword_rescue:
7720 #line 2624 "parse.y"
7722 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7724 #line 7725 "parse.c"
7727 case YYSYMBOL_keyword_ensure:
7728 #line 2624 "parse.y"
7730 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7732 #line 7733 "parse.c"
7735 case YYSYMBOL_keyword_end:
7736 #line 2624 "parse.y"
7738 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7740 #line 7741 "parse.c"
7743 case YYSYMBOL_keyword_if:
7744 #line 2624 "parse.y"
7746 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7748 #line 7749 "parse.c"
7751 case YYSYMBOL_keyword_unless:
7752 #line 2624 "parse.y"
7754 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7756 #line 7757 "parse.c"
7759 case YYSYMBOL_keyword_then:
7760 #line 2624 "parse.y"
7762 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7764 #line 7765 "parse.c"
7767 case YYSYMBOL_keyword_elsif:
7768 #line 2624 "parse.y"
7770 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7772 #line 7773 "parse.c"
7775 case YYSYMBOL_keyword_else:
7776 #line 2624 "parse.y"
7778 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7780 #line 7781 "parse.c"
7783 case YYSYMBOL_keyword_case:
7784 #line 2624 "parse.y"
7786 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7788 #line 7789 "parse.c"
7791 case YYSYMBOL_keyword_when:
7792 #line 2624 "parse.y"
7794 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7796 #line 7797 "parse.c"
7799 case YYSYMBOL_keyword_while:
7800 #line 2624 "parse.y"
7802 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7804 #line 7805 "parse.c"
7807 case YYSYMBOL_keyword_until:
7808 #line 2624 "parse.y"
7810 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7812 #line 7813 "parse.c"
7815 case YYSYMBOL_keyword_for:
7816 #line 2624 "parse.y"
7818 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7820 #line 7821 "parse.c"
7823 case YYSYMBOL_keyword_break:
7824 #line 2624 "parse.y"
7826 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7828 #line 7829 "parse.c"
7831 case YYSYMBOL_keyword_next:
7832 #line 2624 "parse.y"
7834 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7836 #line 7837 "parse.c"
7839 case YYSYMBOL_keyword_redo:
7840 #line 2624 "parse.y"
7842 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7844 #line 7845 "parse.c"
7847 case YYSYMBOL_keyword_retry:
7848 #line 2624 "parse.y"
7850 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7852 #line 7853 "parse.c"
7855 case YYSYMBOL_keyword_in:
7856 #line 2624 "parse.y"
7858 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7860 #line 7861 "parse.c"
7863 case YYSYMBOL_keyword_do:
7864 #line 2624 "parse.y"
7866 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7868 #line 7869 "parse.c"
7871 case YYSYMBOL_keyword_do_cond:
7872 #line 2624 "parse.y"
7874 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7876 #line 7877 "parse.c"
7879 case YYSYMBOL_keyword_do_block:
7880 #line 2624 "parse.y"
7882 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7884 #line 7885 "parse.c"
7887 case YYSYMBOL_keyword_do_LAMBDA:
7888 #line 2624 "parse.y"
7890 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7892 #line 7893 "parse.c"
7895 case YYSYMBOL_keyword_return:
7896 #line 2624 "parse.y"
7898 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7900 #line 7901 "parse.c"
7903 case YYSYMBOL_keyword_yield:
7904 #line 2624 "parse.y"
7906 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7908 #line 7909 "parse.c"
7911 case YYSYMBOL_keyword_super:
7912 #line 2624 "parse.y"
7914 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7916 #line 7917 "parse.c"
7919 case YYSYMBOL_keyword_self:
7920 #line 2624 "parse.y"
7922 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7924 #line 7925 "parse.c"
7927 case YYSYMBOL_keyword_nil:
7928 #line 2624 "parse.y"
7930 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7932 #line 7933 "parse.c"
7935 case YYSYMBOL_keyword_true:
7936 #line 2624 "parse.y"
7938 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7940 #line 7941 "parse.c"
7943 case YYSYMBOL_keyword_false:
7944 #line 2624 "parse.y"
7946 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7948 #line 7949 "parse.c"
7951 case YYSYMBOL_keyword_and:
7952 #line 2624 "parse.y"
7954 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7956 #line 7957 "parse.c"
7959 case YYSYMBOL_keyword_or:
7960 #line 2624 "parse.y"
7962 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7964 #line 7965 "parse.c"
7967 case YYSYMBOL_keyword_not:
7968 #line 2624 "parse.y"
7970 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7972 #line 7973 "parse.c"
7975 case YYSYMBOL_modifier_if:
7976 #line 2624 "parse.y"
7978 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7980 #line 7981 "parse.c"
7983 case YYSYMBOL_modifier_unless:
7984 #line 2624 "parse.y"
7986 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7988 #line 7989 "parse.c"
7991 case YYSYMBOL_modifier_while:
7992 #line 2624 "parse.y"
7994 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
7996 #line 7997 "parse.c"
7999 case YYSYMBOL_modifier_until:
8000 #line 2624 "parse.y"
8002 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8004 #line 8005 "parse.c"
8007 case YYSYMBOL_modifier_rescue:
8008 #line 2624 "parse.y"
8010 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8012 #line 8013 "parse.c"
8015 case YYSYMBOL_keyword_alias:
8016 #line 2624 "parse.y"
8018 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8020 #line 8021 "parse.c"
8023 case YYSYMBOL_keyword_defined:
8024 #line 2624 "parse.y"
8026 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8028 #line 8029 "parse.c"
8031 case YYSYMBOL_keyword_BEGIN:
8032 #line 2624 "parse.y"
8034 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8036 #line 8037 "parse.c"
8039 case YYSYMBOL_keyword_END:
8040 #line 2624 "parse.y"
8042 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8044 #line 8045 "parse.c"
8047 case YYSYMBOL_keyword__LINE__:
8048 #line 2624 "parse.y"
8050 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8052 #line 8053 "parse.c"
8055 case YYSYMBOL_keyword__FILE__:
8056 #line 2624 "parse.y"
8058 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8060 #line 8061 "parse.c"
8063 case YYSYMBOL_keyword__ENCODING__:
8064 #line 2624 "parse.y"
8066 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8068 #line 8069 "parse.c"
8071 case YYSYMBOL_tIDENTIFIER:
8072 #line 2624 "parse.y"
8074 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8076 #line 8077 "parse.c"
8080 #line 2624 "parse.y"
8082 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8084 #line 8085 "parse.c"
8087 case YYSYMBOL_tGVAR:
8088 #line 2624 "parse.y"
8090 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8092 #line 8093 "parse.c"
8095 case YYSYMBOL_tIVAR:
8096 #line 2624 "parse.y"
8098 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8100 #line 8101 "parse.c"
8103 case YYSYMBOL_tCONSTANT:
8104 #line 2624 "parse.y"
8106 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8108 #line 8109 "parse.c"
8111 case YYSYMBOL_tCVAR:
8112 #line 2624 "parse.y"
8114 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8116 #line 8117 "parse.c"
8119 case YYSYMBOL_tLABEL:
8120 #line 2624 "parse.y"
8122 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8124 #line 8125 "parse.c"
8127 case YYSYMBOL_tINTEGER:
8128 #line 2627 "parse.y"
8130 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8132 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8135 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8138 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8140 case NODE_IMAGINARY:
8141 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8147 #line 8148 "parse.c"
8150 case YYSYMBOL_tFLOAT:
8151 #line 2627 "parse.y"
8153 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8155 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8158 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8161 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8163 case NODE_IMAGINARY:
8164 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8170 #line 8171 "parse.c"
8173 case YYSYMBOL_tRATIONAL:
8174 #line 2627 "parse.y"
8176 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8178 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8181 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8184 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8186 case NODE_IMAGINARY:
8187 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8193 #line 8194 "parse.c"
8196 case YYSYMBOL_tIMAGINARY:
8197 #line 2627 "parse.y"
8199 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8201 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8204 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8207 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8209 case NODE_IMAGINARY:
8210 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8216 #line 8217 "parse.c"
8219 case YYSYMBOL_tCHAR:
8220 #line 2627 "parse.y"
8222 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8224 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8227 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8230 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8232 case NODE_IMAGINARY:
8233 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8239 #line 8240 "parse.c"
8242 case YYSYMBOL_tNTH_REF:
8243 #line 2645 "parse.y"
8245 rb_parser_printf(p,
"$%ld", RNODE_NTH_REF(((*yyvaluep).node))->nd_nth);
8247 #line 8248 "parse.c"
8250 case YYSYMBOL_tBACK_REF:
8251 #line 2648 "parse.y"
8253 rb_parser_printf(p,
"$%c", (
int)RNODE_BACK_REF(((*yyvaluep).node))->nd_nth);
8255 #line 8256 "parse.c"
8258 case YYSYMBOL_tSTRING_CONTENT:
8259 #line 2627 "parse.y"
8261 switch (nd_type(RNODE(((*yyvaluep).node)))) {
8263 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_integer_literal_val(((*yyvaluep).node)));
8266 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_float_literal_val(((*yyvaluep).node)));
8269 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_rational_literal_val(((*yyvaluep).node)));
8271 case NODE_IMAGINARY:
8272 rb_parser_printf(p,
"%+"PRIsVALUE, rb_node_imaginary_literal_val(((*yyvaluep).node)));
8278 #line 8279 "parse.c"
8282 #line 2624 "parse.y"
8284 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8286 #line 8287 "parse.c"
8289 case YYSYMBOL_70_backslash_:
8290 #line 2624 "parse.y"
8292 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8294 #line 8295 "parse.c"
8297 case YYSYMBOL_72_escaped_horizontal_tab_:
8298 #line 2624 "parse.y"
8300 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8302 #line 8303 "parse.c"
8305 case YYSYMBOL_73_escaped_form_feed_:
8306 #line 2624 "parse.y"
8308 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8310 #line 8311 "parse.c"
8313 case YYSYMBOL_74_escaped_carriage_return_:
8314 #line 2624 "parse.y"
8316 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8318 #line 8319 "parse.c"
8321 case YYSYMBOL_75_escaped_vertical_tab_:
8322 #line 2624 "parse.y"
8324 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8326 #line 8327 "parse.c"
8329 case YYSYMBOL_tANDDOT:
8330 #line 2624 "parse.y"
8332 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8334 #line 8335 "parse.c"
8337 case YYSYMBOL_tCOLON2:
8338 #line 2624 "parse.y"
8340 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8342 #line 8343 "parse.c"
8345 case YYSYMBOL_tOP_ASGN:
8346 #line 2624 "parse.y"
8348 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8350 #line 8351 "parse.c"
8353 case YYSYMBOL_top_compstmt:
8354 #line 2615 "parse.y"
8356 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8357 rb_parser_printf(p,
"NODE_SPECIAL");
8359 else if (((*yyvaluep).node)) {
8360 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8363 #line 8364 "parse.c"
8366 case YYSYMBOL_top_stmts:
8367 #line 2615 "parse.y"
8369 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8370 rb_parser_printf(p,
"NODE_SPECIAL");
8372 else if (((*yyvaluep).node)) {
8373 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8376 #line 8377 "parse.c"
8379 case YYSYMBOL_top_stmt:
8380 #line 2615 "parse.y"
8382 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8383 rb_parser_printf(p,
"NODE_SPECIAL");
8385 else if (((*yyvaluep).node)) {
8386 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8389 #line 8390 "parse.c"
8392 case YYSYMBOL_block_open:
8393 #line 2615 "parse.y"
8395 if ((
NODE *)((*yyvaluep).node_exits) == (
NODE *)-1) {
8396 rb_parser_printf(p,
"NODE_SPECIAL");
8398 else if (((*yyvaluep).node_exits)) {
8399 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_exits)))));
8402 #line 8403 "parse.c"
8405 case YYSYMBOL_begin_block:
8406 #line 2615 "parse.y"
8408 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8409 rb_parser_printf(p,
"NODE_SPECIAL");
8411 else if (((*yyvaluep).node)) {
8412 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8415 #line 8416 "parse.c"
8418 case YYSYMBOL_bodystmt:
8419 #line 2615 "parse.y"
8421 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8422 rb_parser_printf(p,
"NODE_SPECIAL");
8424 else if (((*yyvaluep).node)) {
8425 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8428 #line 8429 "parse.c"
8431 case YYSYMBOL_compstmt:
8432 #line 2615 "parse.y"
8434 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8435 rb_parser_printf(p,
"NODE_SPECIAL");
8437 else if (((*yyvaluep).node)) {
8438 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8441 #line 8442 "parse.c"
8444 case YYSYMBOL_stmts:
8445 #line 2615 "parse.y"
8447 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8448 rb_parser_printf(p,
"NODE_SPECIAL");
8450 else if (((*yyvaluep).node)) {
8451 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8454 #line 8455 "parse.c"
8457 case YYSYMBOL_stmt_or_begin:
8458 #line 2615 "parse.y"
8460 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8461 rb_parser_printf(p,
"NODE_SPECIAL");
8463 else if (((*yyvaluep).node)) {
8464 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8467 #line 8468 "parse.c"
8470 case YYSYMBOL_allow_exits:
8471 #line 2615 "parse.y"
8473 if ((
NODE *)((*yyvaluep).node_exits) == (
NODE *)-1) {
8474 rb_parser_printf(p,
"NODE_SPECIAL");
8476 else if (((*yyvaluep).node_exits)) {
8477 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_exits)))));
8480 #line 8481 "parse.c"
8484 #line 2615 "parse.y"
8486 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8487 rb_parser_printf(p,
"NODE_SPECIAL");
8489 else if (((*yyvaluep).node)) {
8490 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8493 #line 8494 "parse.c"
8496 case YYSYMBOL_command_asgn:
8497 #line 2615 "parse.y"
8499 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8500 rb_parser_printf(p,
"NODE_SPECIAL");
8502 else if (((*yyvaluep).node)) {
8503 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8506 #line 8507 "parse.c"
8509 case YYSYMBOL_endless_command:
8510 #line 2615 "parse.y"
8512 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8513 rb_parser_printf(p,
"NODE_SPECIAL");
8515 else if (((*yyvaluep).node)) {
8516 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8519 #line 8520 "parse.c"
8522 case YYSYMBOL_command_rhs:
8523 #line 2615 "parse.y"
8525 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8526 rb_parser_printf(p,
"NODE_SPECIAL");
8528 else if (((*yyvaluep).node)) {
8529 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8532 #line 8533 "parse.c"
8536 #line 2615 "parse.y"
8538 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8539 rb_parser_printf(p,
"NODE_SPECIAL");
8541 else if (((*yyvaluep).node)) {
8542 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8545 #line 8546 "parse.c"
8548 case YYSYMBOL_def_name:
8549 #line 2624 "parse.y"
8551 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8553 #line 8554 "parse.c"
8556 case YYSYMBOL_defn_head:
8557 #line 2615 "parse.y"
8559 if ((
NODE *)((*yyvaluep).node_def_temp) == (
NODE *)-1) {
8560 rb_parser_printf(p,
"NODE_SPECIAL");
8562 else if (((*yyvaluep).node_def_temp)) {
8563 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_def_temp)))));
8566 #line 8567 "parse.c"
8569 case YYSYMBOL_defs_head:
8570 #line 2615 "parse.y"
8572 if ((
NODE *)((*yyvaluep).node_def_temp) == (
NODE *)-1) {
8573 rb_parser_printf(p,
"NODE_SPECIAL");
8575 else if (((*yyvaluep).node_def_temp)) {
8576 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_def_temp)))));
8579 #line 8580 "parse.c"
8582 case YYSYMBOL_expr_value:
8583 #line 2615 "parse.y"
8585 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8586 rb_parser_printf(p,
"NODE_SPECIAL");
8588 else if (((*yyvaluep).node)) {
8589 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8592 #line 8593 "parse.c"
8595 case YYSYMBOL_expr_value_do:
8596 #line 2615 "parse.y"
8598 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8599 rb_parser_printf(p,
"NODE_SPECIAL");
8601 else if (((*yyvaluep).node)) {
8602 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8605 #line 8606 "parse.c"
8608 case YYSYMBOL_command_call:
8609 #line 2615 "parse.y"
8611 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8612 rb_parser_printf(p,
"NODE_SPECIAL");
8614 else if (((*yyvaluep).node)) {
8615 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8618 #line 8619 "parse.c"
8621 case YYSYMBOL_block_command:
8622 #line 2615 "parse.y"
8624 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8625 rb_parser_printf(p,
"NODE_SPECIAL");
8627 else if (((*yyvaluep).node)) {
8628 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8631 #line 8632 "parse.c"
8634 case YYSYMBOL_cmd_brace_block:
8635 #line 2615 "parse.y"
8637 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8638 rb_parser_printf(p,
"NODE_SPECIAL");
8640 else if (((*yyvaluep).node)) {
8641 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8644 #line 8645 "parse.c"
8647 case YYSYMBOL_fcall:
8648 #line 2615 "parse.y"
8650 if ((
NODE *)((*yyvaluep).node_fcall) == (
NODE *)-1) {
8651 rb_parser_printf(p,
"NODE_SPECIAL");
8653 else if (((*yyvaluep).node_fcall)) {
8654 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_fcall)))));
8657 #line 8658 "parse.c"
8660 case YYSYMBOL_command:
8661 #line 2615 "parse.y"
8663 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8664 rb_parser_printf(p,
"NODE_SPECIAL");
8666 else if (((*yyvaluep).node)) {
8667 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8670 #line 8671 "parse.c"
8674 #line 2615 "parse.y"
8676 if ((
NODE *)((*yyvaluep).node_masgn) == (
NODE *)-1) {
8677 rb_parser_printf(p,
"NODE_SPECIAL");
8679 else if (((*yyvaluep).node_masgn)) {
8680 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_masgn)))));
8683 #line 8684 "parse.c"
8686 case YYSYMBOL_mlhs_inner:
8687 #line 2615 "parse.y"
8689 if ((
NODE *)((*yyvaluep).node_masgn) == (
NODE *)-1) {
8690 rb_parser_printf(p,
"NODE_SPECIAL");
8692 else if (((*yyvaluep).node_masgn)) {
8693 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_masgn)))));
8696 #line 8697 "parse.c"
8699 case YYSYMBOL_mlhs_basic:
8700 #line 2615 "parse.y"
8702 if ((
NODE *)((*yyvaluep).node_masgn) == (
NODE *)-1) {
8703 rb_parser_printf(p,
"NODE_SPECIAL");
8705 else if (((*yyvaluep).node_masgn)) {
8706 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_masgn)))));
8709 #line 8710 "parse.c"
8712 case YYSYMBOL_mlhs_item:
8713 #line 2615 "parse.y"
8715 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8716 rb_parser_printf(p,
"NODE_SPECIAL");
8718 else if (((*yyvaluep).node)) {
8719 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8722 #line 8723 "parse.c"
8725 case YYSYMBOL_mlhs_head:
8726 #line 2615 "parse.y"
8728 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8729 rb_parser_printf(p,
"NODE_SPECIAL");
8731 else if (((*yyvaluep).node)) {
8732 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8735 #line 8736 "parse.c"
8738 case YYSYMBOL_mlhs_post:
8739 #line 2615 "parse.y"
8741 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8742 rb_parser_printf(p,
"NODE_SPECIAL");
8744 else if (((*yyvaluep).node)) {
8745 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8748 #line 8749 "parse.c"
8751 case YYSYMBOL_mlhs_node:
8752 #line 2615 "parse.y"
8754 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8755 rb_parser_printf(p,
"NODE_SPECIAL");
8757 else if (((*yyvaluep).node)) {
8758 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8761 #line 8762 "parse.c"
8765 #line 2615 "parse.y"
8767 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8768 rb_parser_printf(p,
"NODE_SPECIAL");
8770 else if (((*yyvaluep).node)) {
8771 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8774 #line 8775 "parse.c"
8777 case YYSYMBOL_cname:
8778 #line 2624 "parse.y"
8780 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8782 #line 8783 "parse.c"
8785 case YYSYMBOL_cpath:
8786 #line 2615 "parse.y"
8788 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8789 rb_parser_printf(p,
"NODE_SPECIAL");
8791 else if (((*yyvaluep).node)) {
8792 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8795 #line 8796 "parse.c"
8798 case YYSYMBOL_fname:
8799 #line 2624 "parse.y"
8801 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8803 #line 8804 "parse.c"
8806 case YYSYMBOL_fitem:
8807 #line 2615 "parse.y"
8809 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8810 rb_parser_printf(p,
"NODE_SPECIAL");
8812 else if (((*yyvaluep).node)) {
8813 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8816 #line 8817 "parse.c"
8819 case YYSYMBOL_undef_list:
8820 #line 2615 "parse.y"
8822 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8823 rb_parser_printf(p,
"NODE_SPECIAL");
8825 else if (((*yyvaluep).node)) {
8826 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8829 #line 8830 "parse.c"
8833 #line 2624 "parse.y"
8835 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8837 #line 8838 "parse.c"
8840 case YYSYMBOL_reswords:
8841 #line 2624 "parse.y"
8843 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8845 #line 8846 "parse.c"
8849 #line 2615 "parse.y"
8851 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8852 rb_parser_printf(p,
"NODE_SPECIAL");
8854 else if (((*yyvaluep).node)) {
8855 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8858 #line 8859 "parse.c"
8861 case YYSYMBOL_endless_arg:
8862 #line 2615 "parse.y"
8864 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8865 rb_parser_printf(p,
"NODE_SPECIAL");
8867 else if (((*yyvaluep).node)) {
8868 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8871 #line 8872 "parse.c"
8874 case YYSYMBOL_relop:
8875 #line 2624 "parse.y"
8877 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
8879 #line 8880 "parse.c"
8882 case YYSYMBOL_rel_expr:
8883 #line 2615 "parse.y"
8885 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8886 rb_parser_printf(p,
"NODE_SPECIAL");
8888 else if (((*yyvaluep).node)) {
8889 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8892 #line 8893 "parse.c"
8895 case YYSYMBOL_arg_value:
8896 #line 2615 "parse.y"
8898 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8899 rb_parser_printf(p,
"NODE_SPECIAL");
8901 else if (((*yyvaluep).node)) {
8902 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8905 #line 8906 "parse.c"
8908 case YYSYMBOL_aref_args:
8909 #line 2615 "parse.y"
8911 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8912 rb_parser_printf(p,
"NODE_SPECIAL");
8914 else if (((*yyvaluep).node)) {
8915 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8918 #line 8919 "parse.c"
8921 case YYSYMBOL_arg_rhs:
8922 #line 2615 "parse.y"
8924 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8925 rb_parser_printf(p,
"NODE_SPECIAL");
8927 else if (((*yyvaluep).node)) {
8928 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8931 #line 8932 "parse.c"
8934 case YYSYMBOL_paren_args:
8935 #line 2615 "parse.y"
8937 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8938 rb_parser_printf(p,
"NODE_SPECIAL");
8940 else if (((*yyvaluep).node)) {
8941 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8944 #line 8945 "parse.c"
8947 case YYSYMBOL_opt_paren_args:
8948 #line 2615 "parse.y"
8950 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8951 rb_parser_printf(p,
"NODE_SPECIAL");
8953 else if (((*yyvaluep).node)) {
8954 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8957 #line 8958 "parse.c"
8960 case YYSYMBOL_opt_call_args:
8961 #line 2615 "parse.y"
8963 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8964 rb_parser_printf(p,
"NODE_SPECIAL");
8966 else if (((*yyvaluep).node)) {
8967 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8970 #line 8971 "parse.c"
8973 case YYSYMBOL_call_args:
8974 #line 2615 "parse.y"
8976 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8977 rb_parser_printf(p,
"NODE_SPECIAL");
8979 else if (((*yyvaluep).node)) {
8980 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8983 #line 8984 "parse.c"
8986 case YYSYMBOL_command_args:
8987 #line 2615 "parse.y"
8989 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
8990 rb_parser_printf(p,
"NODE_SPECIAL");
8992 else if (((*yyvaluep).node)) {
8993 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
8996 #line 8997 "parse.c"
8999 case YYSYMBOL_block_arg:
9000 #line 2615 "parse.y"
9002 if ((
NODE *)((*yyvaluep).node_block_pass) == (
NODE *)-1) {
9003 rb_parser_printf(p,
"NODE_SPECIAL");
9005 else if (((*yyvaluep).node_block_pass)) {
9006 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_block_pass)))));
9009 #line 9010 "parse.c"
9012 case YYSYMBOL_opt_block_arg:
9013 #line 2615 "parse.y"
9015 if ((
NODE *)((*yyvaluep).node_block_pass) == (
NODE *)-1) {
9016 rb_parser_printf(p,
"NODE_SPECIAL");
9018 else if (((*yyvaluep).node_block_pass)) {
9019 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_block_pass)))));
9022 #line 9023 "parse.c"
9026 #line 2615 "parse.y"
9028 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9029 rb_parser_printf(p,
"NODE_SPECIAL");
9031 else if (((*yyvaluep).node)) {
9032 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9035 #line 9036 "parse.c"
9038 case YYSYMBOL_arg_splat:
9039 #line 2615 "parse.y"
9041 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9042 rb_parser_printf(p,
"NODE_SPECIAL");
9044 else if (((*yyvaluep).node)) {
9045 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9048 #line 9049 "parse.c"
9051 case YYSYMBOL_mrhs_arg:
9052 #line 2615 "parse.y"
9054 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9055 rb_parser_printf(p,
"NODE_SPECIAL");
9057 else if (((*yyvaluep).node)) {
9058 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9061 #line 9062 "parse.c"
9065 #line 2615 "parse.y"
9067 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9068 rb_parser_printf(p,
"NODE_SPECIAL");
9070 else if (((*yyvaluep).node)) {
9071 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9074 #line 9075 "parse.c"
9077 case YYSYMBOL_primary:
9078 #line 2615 "parse.y"
9080 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9081 rb_parser_printf(p,
"NODE_SPECIAL");
9083 else if (((*yyvaluep).node)) {
9084 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9087 #line 9088 "parse.c"
9090 case YYSYMBOL_primary_value:
9091 #line 2615 "parse.y"
9093 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9094 rb_parser_printf(p,
"NODE_SPECIAL");
9096 else if (((*yyvaluep).node)) {
9097 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9100 #line 9101 "parse.c"
9103 case YYSYMBOL_k_while:
9104 #line 2615 "parse.y"
9106 if ((
NODE *)((*yyvaluep).node_exits) == (
NODE *)-1) {
9107 rb_parser_printf(p,
"NODE_SPECIAL");
9109 else if (((*yyvaluep).node_exits)) {
9110 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_exits)))));
9113 #line 9114 "parse.c"
9116 case YYSYMBOL_k_until:
9117 #line 2615 "parse.y"
9119 if ((
NODE *)((*yyvaluep).node_exits) == (
NODE *)-1) {
9120 rb_parser_printf(p,
"NODE_SPECIAL");
9122 else if (((*yyvaluep).node_exits)) {
9123 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_exits)))));
9126 #line 9127 "parse.c"
9129 case YYSYMBOL_k_for:
9130 #line 2615 "parse.y"
9132 if ((
NODE *)((*yyvaluep).node_exits) == (
NODE *)-1) {
9133 rb_parser_printf(p,
"NODE_SPECIAL");
9135 else if (((*yyvaluep).node_exits)) {
9136 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_exits)))));
9139 #line 9140 "parse.c"
9142 case YYSYMBOL_k_def:
9143 #line 2615 "parse.y"
9145 if ((
NODE *)((*yyvaluep).node_def_temp) == (
NODE *)-1) {
9146 rb_parser_printf(p,
"NODE_SPECIAL");
9148 else if (((*yyvaluep).node_def_temp)) {
9149 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_def_temp)))));
9152 #line 9153 "parse.c"
9155 case YYSYMBOL_if_tail:
9156 #line 2615 "parse.y"
9158 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9159 rb_parser_printf(p,
"NODE_SPECIAL");
9161 else if (((*yyvaluep).node)) {
9162 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9165 #line 9166 "parse.c"
9168 case YYSYMBOL_opt_else:
9169 #line 2615 "parse.y"
9171 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9172 rb_parser_printf(p,
"NODE_SPECIAL");
9174 else if (((*yyvaluep).node)) {
9175 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9178 #line 9179 "parse.c"
9181 case YYSYMBOL_for_var:
9182 #line 2615 "parse.y"
9184 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9185 rb_parser_printf(p,
"NODE_SPECIAL");
9187 else if (((*yyvaluep).node)) {
9188 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9191 #line 9192 "parse.c"
9194 case YYSYMBOL_f_marg:
9195 #line 2615 "parse.y"
9197 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9198 rb_parser_printf(p,
"NODE_SPECIAL");
9200 else if (((*yyvaluep).node)) {
9201 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9204 #line 9205 "parse.c"
9207 case YYSYMBOL_f_marg_list:
9208 #line 2615 "parse.y"
9210 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9211 rb_parser_printf(p,
"NODE_SPECIAL");
9213 else if (((*yyvaluep).node)) {
9214 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9217 #line 9218 "parse.c"
9220 case YYSYMBOL_f_margs:
9221 #line 2615 "parse.y"
9223 if ((
NODE *)((*yyvaluep).node_masgn) == (
NODE *)-1) {
9224 rb_parser_printf(p,
"NODE_SPECIAL");
9226 else if (((*yyvaluep).node_masgn)) {
9227 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_masgn)))));
9230 #line 9231 "parse.c"
9233 case YYSYMBOL_f_rest_marg:
9234 #line 2615 "parse.y"
9236 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9237 rb_parser_printf(p,
"NODE_SPECIAL");
9239 else if (((*yyvaluep).node)) {
9240 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9243 #line 9244 "parse.c"
9246 case YYSYMBOL_f_any_kwrest:
9247 #line 2624 "parse.y"
9249 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
9251 #line 9252 "parse.c"
9254 case YYSYMBOL_f_kwarg_f_block_kw:
9255 #line 2615 "parse.y"
9257 if ((
NODE *)((*yyvaluep).node_kw_arg) == (
NODE *)-1) {
9258 rb_parser_printf(p,
"NODE_SPECIAL");
9260 else if (((*yyvaluep).node_kw_arg)) {
9261 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_kw_arg)))));
9264 #line 9265 "parse.c"
9267 case YYSYMBOL_block_args_tail:
9268 #line 2615 "parse.y"
9270 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9271 rb_parser_printf(p,
"NODE_SPECIAL");
9273 else if (((*yyvaluep).node_args)) {
9274 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9277 #line 9278 "parse.c"
9280 case YYSYMBOL_excessed_comma:
9281 #line 2624 "parse.y"
9283 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
9285 #line 9286 "parse.c"
9288 case YYSYMBOL_f_opt_primary_value:
9289 #line 2615 "parse.y"
9291 if ((
NODE *)((*yyvaluep).node_opt_arg) == (
NODE *)-1) {
9292 rb_parser_printf(p,
"NODE_SPECIAL");
9294 else if (((*yyvaluep).node_opt_arg)) {
9295 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_opt_arg)))));
9298 #line 9299 "parse.c"
9301 case YYSYMBOL_f_optarg_primary_value:
9302 #line 2615 "parse.y"
9304 if ((
NODE *)((*yyvaluep).node_opt_arg) == (
NODE *)-1) {
9305 rb_parser_printf(p,
"NODE_SPECIAL");
9307 else if (((*yyvaluep).node_opt_arg)) {
9308 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_opt_arg)))));
9311 #line 9312 "parse.c"
9314 case YYSYMBOL_opt_args_tail_block_args_tail:
9315 #line 2615 "parse.y"
9317 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9318 rb_parser_printf(p,
"NODE_SPECIAL");
9320 else if (((*yyvaluep).node_args)) {
9321 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9324 #line 9325 "parse.c"
9327 case YYSYMBOL_block_param:
9328 #line 2615 "parse.y"
9330 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9331 rb_parser_printf(p,
"NODE_SPECIAL");
9333 else if (((*yyvaluep).node_args)) {
9334 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9337 #line 9338 "parse.c"
9340 case YYSYMBOL_opt_block_param:
9341 #line 2615 "parse.y"
9343 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9344 rb_parser_printf(p,
"NODE_SPECIAL");
9346 else if (((*yyvaluep).node_args)) {
9347 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9350 #line 9351 "parse.c"
9353 case YYSYMBOL_block_param_def:
9354 #line 2615 "parse.y"
9356 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9357 rb_parser_printf(p,
"NODE_SPECIAL");
9359 else if (((*yyvaluep).node_args)) {
9360 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9363 #line 9364 "parse.c"
9366 case YYSYMBOL_opt_bv_decl:
9367 #line 2624 "parse.y"
9369 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
9371 #line 9372 "parse.c"
9374 case YYSYMBOL_bv_decls:
9375 #line 2624 "parse.y"
9377 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
9379 #line 9380 "parse.c"
9383 #line 2624 "parse.y"
9385 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
9387 #line 9388 "parse.c"
9390 case YYSYMBOL_numparam:
9391 #line 2615 "parse.y"
9393 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9394 rb_parser_printf(p,
"NODE_SPECIAL");
9396 else if (((*yyvaluep).node)) {
9397 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9400 #line 9401 "parse.c"
9403 case YYSYMBOL_it_id:
9404 #line 2624 "parse.y"
9406 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
9408 #line 9409 "parse.c"
9411 case YYSYMBOL_lambda:
9412 #line 2615 "parse.y"
9414 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9415 rb_parser_printf(p,
"NODE_SPECIAL");
9417 else if (((*yyvaluep).node)) {
9418 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9421 #line 9422 "parse.c"
9424 case YYSYMBOL_f_larglist:
9425 #line 2615 "parse.y"
9427 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
9428 rb_parser_printf(p,
"NODE_SPECIAL");
9430 else if (((*yyvaluep).node_args)) {
9431 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
9434 #line 9435 "parse.c"
9437 case YYSYMBOL_lambda_body:
9438 #line 2615 "parse.y"
9440 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9441 rb_parser_printf(p,
"NODE_SPECIAL");
9443 else if (((*yyvaluep).node)) {
9444 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9447 #line 9448 "parse.c"
9450 case YYSYMBOL_do_block:
9451 #line 2615 "parse.y"
9453 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9454 rb_parser_printf(p,
"NODE_SPECIAL");
9456 else if (((*yyvaluep).node)) {
9457 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9460 #line 9461 "parse.c"
9463 case YYSYMBOL_block_call:
9464 #line 2615 "parse.y"
9466 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9467 rb_parser_printf(p,
"NODE_SPECIAL");
9469 else if (((*yyvaluep).node)) {
9470 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9473 #line 9474 "parse.c"
9476 case YYSYMBOL_method_call:
9477 #line 2615 "parse.y"
9479 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9480 rb_parser_printf(p,
"NODE_SPECIAL");
9482 else if (((*yyvaluep).node)) {
9483 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9486 #line 9487 "parse.c"
9489 case YYSYMBOL_brace_block:
9490 #line 2615 "parse.y"
9492 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9493 rb_parser_printf(p,
"NODE_SPECIAL");
9495 else if (((*yyvaluep).node)) {
9496 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9499 #line 9500 "parse.c"
9502 case YYSYMBOL_brace_body:
9503 #line 2615 "parse.y"
9505 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9506 rb_parser_printf(p,
"NODE_SPECIAL");
9508 else if (((*yyvaluep).node)) {
9509 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9512 #line 9513 "parse.c"
9515 case YYSYMBOL_do_body:
9516 #line 2615 "parse.y"
9518 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9519 rb_parser_printf(p,
"NODE_SPECIAL");
9521 else if (((*yyvaluep).node)) {
9522 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9525 #line 9526 "parse.c"
9528 case YYSYMBOL_case_args:
9529 #line 2615 "parse.y"
9531 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9532 rb_parser_printf(p,
"NODE_SPECIAL");
9534 else if (((*yyvaluep).node)) {
9535 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9538 #line 9539 "parse.c"
9541 case YYSYMBOL_case_body:
9542 #line 2615 "parse.y"
9544 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9545 rb_parser_printf(p,
"NODE_SPECIAL");
9547 else if (((*yyvaluep).node)) {
9548 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9551 #line 9552 "parse.c"
9554 case YYSYMBOL_cases:
9555 #line 2615 "parse.y"
9557 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9558 rb_parser_printf(p,
"NODE_SPECIAL");
9560 else if (((*yyvaluep).node)) {
9561 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9564 #line 9565 "parse.c"
9567 case YYSYMBOL_p_case_body:
9568 #line 2615 "parse.y"
9570 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9571 rb_parser_printf(p,
"NODE_SPECIAL");
9573 else if (((*yyvaluep).node)) {
9574 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9577 #line 9578 "parse.c"
9580 case YYSYMBOL_p_cases:
9581 #line 2615 "parse.y"
9583 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9584 rb_parser_printf(p,
"NODE_SPECIAL");
9586 else if (((*yyvaluep).node)) {
9587 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9590 #line 9591 "parse.c"
9593 case YYSYMBOL_p_top_expr:
9594 #line 2615 "parse.y"
9596 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9597 rb_parser_printf(p,
"NODE_SPECIAL");
9599 else if (((*yyvaluep).node)) {
9600 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9603 #line 9604 "parse.c"
9606 case YYSYMBOL_p_top_expr_body:
9607 #line 2615 "parse.y"
9609 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9610 rb_parser_printf(p,
"NODE_SPECIAL");
9612 else if (((*yyvaluep).node)) {
9613 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9616 #line 9617 "parse.c"
9619 case YYSYMBOL_p_expr:
9620 #line 2615 "parse.y"
9622 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9623 rb_parser_printf(p,
"NODE_SPECIAL");
9625 else if (((*yyvaluep).node)) {
9626 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9629 #line 9630 "parse.c"
9633 #line 2615 "parse.y"
9635 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9636 rb_parser_printf(p,
"NODE_SPECIAL");
9638 else if (((*yyvaluep).node)) {
9639 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9642 #line 9643 "parse.c"
9645 case YYSYMBOL_p_alt:
9646 #line 2615 "parse.y"
9648 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9649 rb_parser_printf(p,
"NODE_SPECIAL");
9651 else if (((*yyvaluep).node)) {
9652 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9655 #line 9656 "parse.c"
9658 case YYSYMBOL_p_expr_basic:
9659 #line 2615 "parse.y"
9661 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9662 rb_parser_printf(p,
"NODE_SPECIAL");
9664 else if (((*yyvaluep).node)) {
9665 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9668 #line 9669 "parse.c"
9671 case YYSYMBOL_p_args:
9672 #line 2615 "parse.y"
9674 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9675 rb_parser_printf(p,
"NODE_SPECIAL");
9677 else if (((*yyvaluep).node)) {
9678 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9681 #line 9682 "parse.c"
9684 case YYSYMBOL_p_args_head:
9685 #line 2615 "parse.y"
9687 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9688 rb_parser_printf(p,
"NODE_SPECIAL");
9690 else if (((*yyvaluep).node)) {
9691 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9694 #line 9695 "parse.c"
9697 case YYSYMBOL_p_args_tail:
9698 #line 2615 "parse.y"
9700 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9701 rb_parser_printf(p,
"NODE_SPECIAL");
9703 else if (((*yyvaluep).node)) {
9704 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9707 #line 9708 "parse.c"
9710 case YYSYMBOL_p_find:
9711 #line 2615 "parse.y"
9713 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9714 rb_parser_printf(p,
"NODE_SPECIAL");
9716 else if (((*yyvaluep).node)) {
9717 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9720 #line 9721 "parse.c"
9723 case YYSYMBOL_p_rest:
9724 #line 2615 "parse.y"
9726 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9727 rb_parser_printf(p,
"NODE_SPECIAL");
9729 else if (((*yyvaluep).node)) {
9730 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9733 #line 9734 "parse.c"
9736 case YYSYMBOL_p_args_post:
9737 #line 2615 "parse.y"
9739 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9740 rb_parser_printf(p,
"NODE_SPECIAL");
9742 else if (((*yyvaluep).node)) {
9743 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9746 #line 9747 "parse.c"
9749 case YYSYMBOL_p_arg:
9750 #line 2615 "parse.y"
9752 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9753 rb_parser_printf(p,
"NODE_SPECIAL");
9755 else if (((*yyvaluep).node)) {
9756 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9759 #line 9760 "parse.c"
9762 case YYSYMBOL_p_kwargs:
9763 #line 2615 "parse.y"
9765 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9766 rb_parser_printf(p,
"NODE_SPECIAL");
9768 else if (((*yyvaluep).node)) {
9769 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9772 #line 9773 "parse.c"
9775 case YYSYMBOL_p_kwarg:
9776 #line 2615 "parse.y"
9778 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9779 rb_parser_printf(p,
"NODE_SPECIAL");
9781 else if (((*yyvaluep).node)) {
9782 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9785 #line 9786 "parse.c"
9789 #line 2615 "parse.y"
9791 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9792 rb_parser_printf(p,
"NODE_SPECIAL");
9794 else if (((*yyvaluep).node)) {
9795 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9798 #line 9799 "parse.c"
9801 case YYSYMBOL_p_kw_label:
9802 #line 2624 "parse.y"
9804 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
9806 #line 9807 "parse.c"
9809 case YYSYMBOL_p_kwrest:
9810 #line 2624 "parse.y"
9812 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
9814 #line 9815 "parse.c"
9817 case YYSYMBOL_p_kwnorest:
9818 #line 2624 "parse.y"
9820 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
9822 #line 9823 "parse.c"
9825 case YYSYMBOL_p_any_kwrest:
9826 #line 2624 "parse.y"
9828 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
9830 #line 9831 "parse.c"
9833 case YYSYMBOL_p_value:
9834 #line 2615 "parse.y"
9836 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9837 rb_parser_printf(p,
"NODE_SPECIAL");
9839 else if (((*yyvaluep).node)) {
9840 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9843 #line 9844 "parse.c"
9846 case YYSYMBOL_p_primitive:
9847 #line 2615 "parse.y"
9849 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9850 rb_parser_printf(p,
"NODE_SPECIAL");
9852 else if (((*yyvaluep).node)) {
9853 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9856 #line 9857 "parse.c"
9859 case YYSYMBOL_p_variable:
9860 #line 2615 "parse.y"
9862 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9863 rb_parser_printf(p,
"NODE_SPECIAL");
9865 else if (((*yyvaluep).node)) {
9866 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9869 #line 9870 "parse.c"
9872 case YYSYMBOL_p_var_ref:
9873 #line 2615 "parse.y"
9875 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9876 rb_parser_printf(p,
"NODE_SPECIAL");
9878 else if (((*yyvaluep).node)) {
9879 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9882 #line 9883 "parse.c"
9885 case YYSYMBOL_p_expr_ref:
9886 #line 2615 "parse.y"
9888 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9889 rb_parser_printf(p,
"NODE_SPECIAL");
9891 else if (((*yyvaluep).node)) {
9892 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9895 #line 9896 "parse.c"
9898 case YYSYMBOL_p_const:
9899 #line 2615 "parse.y"
9901 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9902 rb_parser_printf(p,
"NODE_SPECIAL");
9904 else if (((*yyvaluep).node)) {
9905 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9908 #line 9909 "parse.c"
9911 case YYSYMBOL_opt_rescue:
9912 #line 2615 "parse.y"
9914 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9915 rb_parser_printf(p,
"NODE_SPECIAL");
9917 else if (((*yyvaluep).node)) {
9918 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9921 #line 9922 "parse.c"
9924 case YYSYMBOL_exc_list:
9925 #line 2615 "parse.y"
9927 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9928 rb_parser_printf(p,
"NODE_SPECIAL");
9930 else if (((*yyvaluep).node)) {
9931 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9934 #line 9935 "parse.c"
9937 case YYSYMBOL_exc_var:
9938 #line 2615 "parse.y"
9940 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9941 rb_parser_printf(p,
"NODE_SPECIAL");
9943 else if (((*yyvaluep).node)) {
9944 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9947 #line 9948 "parse.c"
9950 case YYSYMBOL_opt_ensure:
9951 #line 2615 "parse.y"
9953 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9954 rb_parser_printf(p,
"NODE_SPECIAL");
9956 else if (((*yyvaluep).node)) {
9957 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9960 #line 9961 "parse.c"
9963 case YYSYMBOL_literal:
9964 #line 2615 "parse.y"
9966 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9967 rb_parser_printf(p,
"NODE_SPECIAL");
9969 else if (((*yyvaluep).node)) {
9970 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9973 #line 9974 "parse.c"
9976 case YYSYMBOL_strings:
9977 #line 2615 "parse.y"
9979 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9980 rb_parser_printf(p,
"NODE_SPECIAL");
9982 else if (((*yyvaluep).node)) {
9983 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9986 #line 9987 "parse.c"
9989 case YYSYMBOL_string:
9990 #line 2615 "parse.y"
9992 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
9993 rb_parser_printf(p,
"NODE_SPECIAL");
9995 else if (((*yyvaluep).node)) {
9996 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
9999 #line 10000 "parse.c"
10002 case YYSYMBOL_string1:
10003 #line 2615 "parse.y"
10005 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10006 rb_parser_printf(p,
"NODE_SPECIAL");
10008 else if (((*yyvaluep).node)) {
10009 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10012 #line 10013 "parse.c"
10015 case YYSYMBOL_xstring:
10016 #line 2615 "parse.y"
10018 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10019 rb_parser_printf(p,
"NODE_SPECIAL");
10021 else if (((*yyvaluep).node)) {
10022 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10025 #line 10026 "parse.c"
10028 case YYSYMBOL_regexp:
10029 #line 2615 "parse.y"
10031 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10032 rb_parser_printf(p,
"NODE_SPECIAL");
10034 else if (((*yyvaluep).node)) {
10035 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10038 #line 10039 "parse.c"
10041 case YYSYMBOL_words_tWORDS_BEG_word_list:
10042 #line 2615 "parse.y"
10044 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10045 rb_parser_printf(p,
"NODE_SPECIAL");
10047 else if (((*yyvaluep).node)) {
10048 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10051 #line 10052 "parse.c"
10054 case YYSYMBOL_words:
10055 #line 2615 "parse.y"
10057 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10058 rb_parser_printf(p,
"NODE_SPECIAL");
10060 else if (((*yyvaluep).node)) {
10061 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10064 #line 10065 "parse.c"
10067 case YYSYMBOL_word_list:
10068 #line 2615 "parse.y"
10070 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10071 rb_parser_printf(p,
"NODE_SPECIAL");
10073 else if (((*yyvaluep).node)) {
10074 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10077 #line 10078 "parse.c"
10080 case YYSYMBOL_word:
10081 #line 2615 "parse.y"
10083 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10084 rb_parser_printf(p,
"NODE_SPECIAL");
10086 else if (((*yyvaluep).node)) {
10087 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10090 #line 10091 "parse.c"
10093 case YYSYMBOL_words_tSYMBOLS_BEG_symbol_list:
10094 #line 2615 "parse.y"
10096 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10097 rb_parser_printf(p,
"NODE_SPECIAL");
10099 else if (((*yyvaluep).node)) {
10100 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10103 #line 10104 "parse.c"
10106 case YYSYMBOL_symbols:
10107 #line 2615 "parse.y"
10109 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10110 rb_parser_printf(p,
"NODE_SPECIAL");
10112 else if (((*yyvaluep).node)) {
10113 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10116 #line 10117 "parse.c"
10119 case YYSYMBOL_symbol_list:
10120 #line 2615 "parse.y"
10122 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10123 rb_parser_printf(p,
"NODE_SPECIAL");
10125 else if (((*yyvaluep).node)) {
10126 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10129 #line 10130 "parse.c"
10132 case YYSYMBOL_words_tQWORDS_BEG_qword_list:
10133 #line 2615 "parse.y"
10135 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10136 rb_parser_printf(p,
"NODE_SPECIAL");
10138 else if (((*yyvaluep).node)) {
10139 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10142 #line 10143 "parse.c"
10145 case YYSYMBOL_qwords:
10146 #line 2615 "parse.y"
10148 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10149 rb_parser_printf(p,
"NODE_SPECIAL");
10151 else if (((*yyvaluep).node)) {
10152 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10155 #line 10156 "parse.c"
10158 case YYSYMBOL_words_tQSYMBOLS_BEG_qsym_list:
10159 #line 2615 "parse.y"
10161 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10162 rb_parser_printf(p,
"NODE_SPECIAL");
10164 else if (((*yyvaluep).node)) {
10165 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10168 #line 10169 "parse.c"
10171 case YYSYMBOL_qsymbols:
10172 #line 2615 "parse.y"
10174 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10175 rb_parser_printf(p,
"NODE_SPECIAL");
10177 else if (((*yyvaluep).node)) {
10178 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10181 #line 10182 "parse.c"
10184 case YYSYMBOL_qword_list:
10185 #line 2615 "parse.y"
10187 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10188 rb_parser_printf(p,
"NODE_SPECIAL");
10190 else if (((*yyvaluep).node)) {
10191 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10194 #line 10195 "parse.c"
10197 case YYSYMBOL_qsym_list:
10198 #line 2615 "parse.y"
10200 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10201 rb_parser_printf(p,
"NODE_SPECIAL");
10203 else if (((*yyvaluep).node)) {
10204 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10207 #line 10208 "parse.c"
10210 case YYSYMBOL_string_contents:
10211 #line 2615 "parse.y"
10213 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10214 rb_parser_printf(p,
"NODE_SPECIAL");
10216 else if (((*yyvaluep).node)) {
10217 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10220 #line 10221 "parse.c"
10223 case YYSYMBOL_xstring_contents:
10224 #line 2615 "parse.y"
10226 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10227 rb_parser_printf(p,
"NODE_SPECIAL");
10229 else if (((*yyvaluep).node)) {
10230 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10233 #line 10234 "parse.c"
10236 case YYSYMBOL_regexp_contents:
10237 #line 2615 "parse.y"
10239 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10240 rb_parser_printf(p,
"NODE_SPECIAL");
10242 else if (((*yyvaluep).node)) {
10243 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10246 #line 10247 "parse.c"
10249 case YYSYMBOL_string_content:
10250 #line 2615 "parse.y"
10252 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10253 rb_parser_printf(p,
"NODE_SPECIAL");
10255 else if (((*yyvaluep).node)) {
10256 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10259 #line 10260 "parse.c"
10262 case YYSYMBOL_string_dvar:
10263 #line 2615 "parse.y"
10265 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10266 rb_parser_printf(p,
"NODE_SPECIAL");
10268 else if (((*yyvaluep).node)) {
10269 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10272 #line 10273 "parse.c"
10275 case YYSYMBOL_symbol:
10276 #line 2615 "parse.y"
10278 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10279 rb_parser_printf(p,
"NODE_SPECIAL");
10281 else if (((*yyvaluep).node)) {
10282 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10285 #line 10286 "parse.c"
10288 case YYSYMBOL_ssym:
10289 #line 2615 "parse.y"
10291 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10292 rb_parser_printf(p,
"NODE_SPECIAL");
10294 else if (((*yyvaluep).node)) {
10295 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10298 #line 10299 "parse.c"
10302 #line 2624 "parse.y"
10304 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10306 #line 10307 "parse.c"
10309 case YYSYMBOL_dsym:
10310 #line 2615 "parse.y"
10312 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10313 rb_parser_printf(p,
"NODE_SPECIAL");
10315 else if (((*yyvaluep).node)) {
10316 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10319 #line 10320 "parse.c"
10322 case YYSYMBOL_numeric:
10323 #line 2615 "parse.y"
10325 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10326 rb_parser_printf(p,
"NODE_SPECIAL");
10328 else if (((*yyvaluep).node)) {
10329 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10332 #line 10333 "parse.c"
10335 case YYSYMBOL_simple_numeric:
10336 #line 2615 "parse.y"
10338 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10339 rb_parser_printf(p,
"NODE_SPECIAL");
10341 else if (((*yyvaluep).node)) {
10342 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10345 #line 10346 "parse.c"
10348 case YYSYMBOL_nonlocal_var:
10349 #line 2624 "parse.y"
10351 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10353 #line 10354 "parse.c"
10356 case YYSYMBOL_user_variable:
10357 #line 2624 "parse.y"
10359 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10361 #line 10362 "parse.c"
10364 case YYSYMBOL_keyword_variable:
10365 #line 2624 "parse.y"
10367 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10369 #line 10370 "parse.c"
10372 case YYSYMBOL_var_ref:
10373 #line 2615 "parse.y"
10375 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10376 rb_parser_printf(p,
"NODE_SPECIAL");
10378 else if (((*yyvaluep).node)) {
10379 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10382 #line 10383 "parse.c"
10385 case YYSYMBOL_var_lhs:
10386 #line 2615 "parse.y"
10388 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10389 rb_parser_printf(p,
"NODE_SPECIAL");
10391 else if (((*yyvaluep).node)) {
10392 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10395 #line 10396 "parse.c"
10398 case YYSYMBOL_backref:
10399 #line 2615 "parse.y"
10401 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10402 rb_parser_printf(p,
"NODE_SPECIAL");
10404 else if (((*yyvaluep).node)) {
10405 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10408 #line 10409 "parse.c"
10411 case YYSYMBOL_superclass:
10412 #line 2615 "parse.y"
10414 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10415 rb_parser_printf(p,
"NODE_SPECIAL");
10417 else if (((*yyvaluep).node)) {
10418 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10421 #line 10422 "parse.c"
10424 case YYSYMBOL_f_opt_paren_args:
10425 #line 2615 "parse.y"
10427 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10428 rb_parser_printf(p,
"NODE_SPECIAL");
10430 else if (((*yyvaluep).node_args)) {
10431 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10434 #line 10435 "parse.c"
10437 case YYSYMBOL_f_paren_args:
10438 #line 2615 "parse.y"
10440 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10441 rb_parser_printf(p,
"NODE_SPECIAL");
10443 else if (((*yyvaluep).node_args)) {
10444 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10447 #line 10448 "parse.c"
10450 case YYSYMBOL_f_arglist:
10451 #line 2615 "parse.y"
10453 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10454 rb_parser_printf(p,
"NODE_SPECIAL");
10456 else if (((*yyvaluep).node_args)) {
10457 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10460 #line 10461 "parse.c"
10463 case YYSYMBOL_f_kwarg_f_kw:
10464 #line 2615 "parse.y"
10466 if ((
NODE *)((*yyvaluep).node_kw_arg) == (
NODE *)-1) {
10467 rb_parser_printf(p,
"NODE_SPECIAL");
10469 else if (((*yyvaluep).node_kw_arg)) {
10470 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_kw_arg)))));
10473 #line 10474 "parse.c"
10476 case YYSYMBOL_args_tail:
10477 #line 2615 "parse.y"
10479 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10480 rb_parser_printf(p,
"NODE_SPECIAL");
10482 else if (((*yyvaluep).node_args)) {
10483 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10486 #line 10487 "parse.c"
10489 case YYSYMBOL_f_opt_arg_value:
10490 #line 2615 "parse.y"
10492 if ((
NODE *)((*yyvaluep).node_opt_arg) == (
NODE *)-1) {
10493 rb_parser_printf(p,
"NODE_SPECIAL");
10495 else if (((*yyvaluep).node_opt_arg)) {
10496 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_opt_arg)))));
10499 #line 10500 "parse.c"
10502 case YYSYMBOL_f_optarg_arg_value:
10503 #line 2615 "parse.y"
10505 if ((
NODE *)((*yyvaluep).node_opt_arg) == (
NODE *)-1) {
10506 rb_parser_printf(p,
"NODE_SPECIAL");
10508 else if (((*yyvaluep).node_opt_arg)) {
10509 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_opt_arg)))));
10512 #line 10513 "parse.c"
10515 case YYSYMBOL_opt_args_tail_args_tail:
10516 #line 2615 "parse.y"
10518 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10519 rb_parser_printf(p,
"NODE_SPECIAL");
10521 else if (((*yyvaluep).node_args)) {
10522 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10525 #line 10526 "parse.c"
10528 case YYSYMBOL_f_args:
10529 #line 2615 "parse.y"
10531 if ((
NODE *)((*yyvaluep).node_args) == (
NODE *)-1) {
10532 rb_parser_printf(p,
"NODE_SPECIAL");
10534 else if (((*yyvaluep).node_args)) {
10535 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args)))));
10538 #line 10539 "parse.c"
10541 case YYSYMBOL_args_forward:
10542 #line 2624 "parse.y"
10544 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10546 #line 10547 "parse.c"
10549 case YYSYMBOL_f_bad_arg:
10550 #line 2624 "parse.y"
10552 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10554 #line 10555 "parse.c"
10557 case YYSYMBOL_f_norm_arg:
10558 #line 2624 "parse.y"
10560 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10562 #line 10563 "parse.c"
10565 case YYSYMBOL_f_arg_asgn:
10566 #line 2624 "parse.y"
10568 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10570 #line 10571 "parse.c"
10573 case YYSYMBOL_f_arg_item:
10574 #line 2615 "parse.y"
10576 if ((
NODE *)((*yyvaluep).node_args_aux) == (
NODE *)-1) {
10577 rb_parser_printf(p,
"NODE_SPECIAL");
10579 else if (((*yyvaluep).node_args_aux)) {
10580 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args_aux)))));
10583 #line 10584 "parse.c"
10586 case YYSYMBOL_f_arg:
10587 #line 2615 "parse.y"
10589 if ((
NODE *)((*yyvaluep).node_args_aux) == (
NODE *)-1) {
10590 rb_parser_printf(p,
"NODE_SPECIAL");
10592 else if (((*yyvaluep).node_args_aux)) {
10593 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_args_aux)))));
10596 #line 10597 "parse.c"
10599 case YYSYMBOL_f_label:
10600 #line 2624 "parse.y"
10602 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10604 #line 10605 "parse.c"
10607 case YYSYMBOL_f_kw:
10608 #line 2615 "parse.y"
10610 if ((
NODE *)((*yyvaluep).node_kw_arg) == (
NODE *)-1) {
10611 rb_parser_printf(p,
"NODE_SPECIAL");
10613 else if (((*yyvaluep).node_kw_arg)) {
10614 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_kw_arg)))));
10617 #line 10618 "parse.c"
10620 case YYSYMBOL_f_block_kw:
10621 #line 2615 "parse.y"
10623 if ((
NODE *)((*yyvaluep).node_kw_arg) == (
NODE *)-1) {
10624 rb_parser_printf(p,
"NODE_SPECIAL");
10626 else if (((*yyvaluep).node_kw_arg)) {
10627 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node_kw_arg)))));
10630 #line 10631 "parse.c"
10633 case YYSYMBOL_f_no_kwarg:
10634 #line 2624 "parse.y"
10636 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10638 #line 10639 "parse.c"
10641 case YYSYMBOL_f_kwrest:
10642 #line 2624 "parse.y"
10644 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10646 #line 10647 "parse.c"
10649 case YYSYMBOL_f_rest_arg:
10650 #line 2624 "parse.y"
10652 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10654 #line 10655 "parse.c"
10657 case YYSYMBOL_f_block_arg:
10658 #line 2624 "parse.y"
10660 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10662 #line 10663 "parse.c"
10665 case YYSYMBOL_opt_f_block_arg:
10666 #line 2624 "parse.y"
10668 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10670 #line 10671 "parse.c"
10673 case YYSYMBOL_singleton:
10674 #line 2615 "parse.y"
10676 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10677 rb_parser_printf(p,
"NODE_SPECIAL");
10679 else if (((*yyvaluep).node)) {
10680 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10683 #line 10684 "parse.c"
10686 case YYSYMBOL_assoc_list:
10687 #line 2615 "parse.y"
10689 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10690 rb_parser_printf(p,
"NODE_SPECIAL");
10692 else if (((*yyvaluep).node)) {
10693 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10696 #line 10697 "parse.c"
10699 case YYSYMBOL_assocs:
10700 #line 2615 "parse.y"
10702 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10703 rb_parser_printf(p,
"NODE_SPECIAL");
10705 else if (((*yyvaluep).node)) {
10706 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10709 #line 10710 "parse.c"
10712 case YYSYMBOL_assoc:
10713 #line 2615 "parse.y"
10715 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10716 rb_parser_printf(p,
"NODE_SPECIAL");
10718 else if (((*yyvaluep).node)) {
10719 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10722 #line 10723 "parse.c"
10725 case YYSYMBOL_operation:
10726 #line 2624 "parse.y"
10728 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10730 #line 10731 "parse.c"
10733 case YYSYMBOL_operation2:
10734 #line 2624 "parse.y"
10736 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10738 #line 10739 "parse.c"
10741 case YYSYMBOL_operation3:
10742 #line 2624 "parse.y"
10744 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10746 #line 10747 "parse.c"
10749 case YYSYMBOL_dot_or_colon:
10750 #line 2624 "parse.y"
10752 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10754 #line 10755 "parse.c"
10757 case YYSYMBOL_call_op:
10758 #line 2624 "parse.y"
10760 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10762 #line 10763 "parse.c"
10765 case YYSYMBOL_call_op2:
10766 #line 2624 "parse.y"
10768 rb_parser_printf(p,
"%"PRIsVALUE,
rb_id2str(((*yyvaluep).id)));
10770 #line 10771 "parse.c"
10773 case YYSYMBOL_none:
10774 #line 2615 "parse.y"
10776 if ((
NODE *)((*yyvaluep).node) == (
NODE *)-1) {
10777 rb_parser_printf(p,
"NODE_SPECIAL");
10779 else if (((*yyvaluep).node)) {
10780 rb_parser_printf(p,
"%s", parser_node_name(nd_type(RNODE(((*yyvaluep).node)))));
10783 #line 10784 "parse.c"
10789 YY_IGNORE_MAYBE_UNINITIALIZED_END
10798 yy_symbol_print (
FILE *yyo,
10801 YYFPRINTF (yyo,
"%s %s (",
10802 yykind < YYNTOKENS ?
"token" :
"nterm", yysymbol_name (yykind));
10804 YYLOCATION_PRINT (yyo, yylocationp, p);
10805 YYFPRINTF (yyo,
": ");
10806 yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp, p);
10807 YYFPRINTF (yyo,
")");
10816 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop,
struct parser_params *p)
10818 YYFPRINTF (stderr,
"Stack now");
10819 for (; yybottom <= yytop; yybottom++)
10821 int yybot = *yybottom;
10822 YYFPRINTF (stderr,
" %d", yybot);
10824 YYFPRINTF (stderr,
"\n");
10827 # define YY_STACK_PRINT(Bottom, Top, p) \
10830 yy_stack_print ((Bottom), (Top), p); \
10839 yy_reduce_print (yy_state_t *yyssp,
YYSTYPE *yyvsp,
YYLTYPE *yylsp,
10842 int yylno = yyrline[yyrule];
10843 int yynrhs = yyr2[yyrule];
10845 YYFPRINTF (stderr,
"Reducing stack by rule %d (line %d):\n",
10846 yyrule - 1, yylno);
10848 for (yyi = 0; yyi < yynrhs; yyi++)
10850 YYFPRINTF (stderr,
" $%d = ", yyi + 1);
10851 yy_symbol_print (stderr,
10852 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
10853 &yyvsp[(yyi + 1) - (yynrhs)],
10854 &(yylsp[(yyi + 1) - (yynrhs)]), p);
10855 YYFPRINTF (stderr,
"\n");
10859 # define YY_REDUCE_PRINT(Rule, p) \
10862 yy_reduce_print (yyssp, yyvsp, yylsp, Rule, p); \
10871 # define YYDPRINTF(Args) ((void) 0)
10872 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location, p)
10873 # define YY_STACK_PRINT(Bottom, Top, p)
10874 # define YY_REDUCE_PRINT(Rule, p)
10879 #ifndef YYINITDEPTH
10880 # define YYINITDEPTH 200
10891 # define YYMAXDEPTH 10000
10899 yysymbol_kind_t yytoken;
10910 yypcontext_expected_tokens (
const yypcontext_t *yyctx,
10911 yysymbol_kind_t yyarg[],
int yyargn)
10915 int yyn = yypact[+*yyctx->yyssp];
10916 if (!yypact_value_is_default (yyn))
10921 int yyxbegin = yyn < 0 ? -yyn : 0;
10923 int yychecklim = YYLAST - yyn + 1;
10924 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
10926 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
10927 if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror
10928 && !yytable_value_is_error (yytable[yyx + yyn]))
10932 else if (yycount == yyargn)
10935 yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx);
10938 if (yyarg && yycount == 0 && 0 < yyargn)
10939 yyarg[0] = YYSYMBOL_YYEMPTY;
10947 # if defined __GLIBC__ && defined _STRING_H
10948 # define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
10952 yystrlen (
const char *yystr)
10955 for (yylen = 0; yystr[yylen]; yylen++)
10963 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
10964 # define yystpcpy stpcpy
10969 yystpcpy (
char *yydest,
const char *yysrc)
10971 char *yyd = yydest;
10972 const char *yys = yysrc;
10974 while ((*yyd++ = *yys++) !=
'\0')
10991 yytnamerr (
char *yyres,
const char *yystr)
10995 YYPTRDIFF_T yyn = 0;
10996 char const *yyp = yystr;
11002 goto do_not_strip_quotes;
11005 if (*++yyp !=
'\\')
11006 goto do_not_strip_quotes;
11022 do_not_strip_quotes: ;
11026 return yystpcpy (yyres, yystr) - yyres;
11028 return yystrlen (yystr);
11035 yysymbol_kind_t yyarg[],
int yyargn)
11062 if (yyctx->yytoken != YYSYMBOL_YYEMPTY)
11066 yyarg[yycount] = yyctx->yytoken;
11068 yyn = yypcontext_expected_tokens (yyctx,
11069 yyarg ? yyarg + 1 : yyarg, yyargn - 1);
11070 if (yyn == YYENOMEM)
11087 yysyntax_error (YYPTRDIFF_T *yymsg_alloc,
char **yymsg,
11090 enum { YYARGS_MAX = 5 };
11092 const char *yyformat = YY_NULLPTR;
11095 yysymbol_kind_t yyarg[YYARGS_MAX];
11097 YYPTRDIFF_T yysize = 0;
11100 int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX);
11101 if (yycount == YYENOMEM)
11106 #define YYCASE_(N, S) \
11111 YYCASE_(0, YY_(
"syntax error"));
11112 YYCASE_(1, YY_(
"syntax error, unexpected %s"));
11113 YYCASE_(2, YY_(
"syntax error, unexpected %s, expecting %s"));
11114 YYCASE_(3, YY_(
"syntax error, unexpected %s, expecting %s or %s"));
11115 YYCASE_(4, YY_(
"syntax error, unexpected %s, expecting %s or %s or %s"));
11116 YYCASE_(5, YY_(
"syntax error, unexpected %s, expecting %s or %s or %s or %s"));
11122 yysize = yystrlen (yyformat) - 2 * yycount + 1;
11125 for (yyi = 0; yyi < yycount; ++yyi)
11127 YYPTRDIFF_T yysize1
11128 = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]);
11129 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
11136 if (*yymsg_alloc < yysize)
11138 *yymsg_alloc = 2 * yysize;
11139 if (! (yysize <= *yymsg_alloc
11140 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
11141 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
11149 char *yyp = *yymsg;
11151 while ((*yyp = *yyformat) !=
'\0')
11152 if (*yyp ==
'%' && yyformat[1] ==
's' && yyi < yycount)
11154 yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]);
11172 yydestruct (
const char *yymsg,
11176 YY_USE (yylocationp);
11179 yymsg =
"Deleting";
11180 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp, p);
11182 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
11185 case YYSYMBOL_245_16:
11186 #line 2652 "parse.y"
11188 if (CASE_LABELS_ENABLED_P(((*yyvaluep).labels))) st_free_table(((*yyvaluep).labels));
11190 #line 11191 "parse.c"
11193 case YYSYMBOL_246_17:
11194 #line 2652 "parse.y"
11196 if (CASE_LABELS_ENABLED_P(((*yyvaluep).labels))) st_free_table(((*yyvaluep).labels));
11198 #line 11199 "parse.c"
11204 YY_IGNORE_MAYBE_UNINITIALIZED_END
11227 static const YYSTYPE yyval_default = {};
11228 (void) yyval_default;
11230 YY_INITIAL_VALUE (
static const YYSTYPE yyval_default;)
11232 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
11235 static const YYLTYPE yyloc_default
11236 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
11240 YYLTYPE yylloc = yyloc_default;
11246 yy_state_fast_t yystate = 0;
11248 int yyerrstatus = 0;
11254 YYPTRDIFF_T yystacksize = YYINITDEPTH;
11257 yy_state_t yyssa[YYINITDEPTH];
11258 yy_state_t *yyss = yyssa;
11259 yy_state_t *yyssp = yyss;
11275 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
11285 char yymsgbuf[128];
11286 char *yymsg = yymsgbuf;
11287 YYPTRDIFF_T yymsg_alloc =
sizeof yymsgbuf;
11289 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
11295 YYDPRINTF ((stderr,
"Starting parse\n"));
11301 #line 2659 "parse.y"
11303 RUBY_SET_YYLLOC_OF_NONE(yylloc);
11306 #line 11307 "parse.c"
11325 YYDPRINTF ((stderr,
"Entering state %d\n", yystate));
11326 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
11327 YY_IGNORE_USELESS_CAST_BEGIN
11328 *yyssp = YY_CAST (yy_state_t, yystate);
11329 YY_IGNORE_USELESS_CAST_END
11330 YY_STACK_PRINT (yyss, yyssp, p);
11332 if (yyss + yystacksize - 1 <= yyssp)
11333 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
11338 YYPTRDIFF_T yysize = yyssp - yyss + 1;
11340 # if defined yyoverflow
11345 yy_state_t *yyss1 = yyss;
11353 yyoverflow (YY_(
"memory exhausted"),
11354 &yyss1, yysize * YYSIZEOF (*yyssp),
11355 &yyvs1, yysize * YYSIZEOF (*yyvsp),
11356 &yyls1, yysize * YYSIZEOF (*yylsp),
11364 if (YYMAXDEPTH <= yystacksize)
11367 if (YYMAXDEPTH < yystacksize)
11368 yystacksize = YYMAXDEPTH;
11371 yy_state_t *yyss1 = yyss;
11372 union yyalloc *yyptr =
11373 YY_CAST (
union yyalloc *,
11374 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
11377 YYSTACK_RELOCATE (yyss_alloc, yyss);
11378 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
11379 YYSTACK_RELOCATE (yyls_alloc, yyls);
11380 # undef YYSTACK_RELOCATE
11381 if (yyss1 != yyssa)
11382 YYSTACK_FREE (yyss1);
11386 yyssp = yyss + yysize - 1;
11387 yyvsp = yyvs + yysize - 1;
11388 yylsp = yyls + yysize - 1;
11390 YY_IGNORE_USELESS_CAST_BEGIN
11391 YYDPRINTF ((stderr,
"Stack size increased to %ld\n",
11392 YY_CAST (
long, yystacksize)));
11393 YY_IGNORE_USELESS_CAST_END
11395 if (yyss + yystacksize - 1 <= yyssp)
11401 if (yystate == YYFINAL)
11415 yyn = yypact[yystate];
11416 if (yypact_value_is_default (yyn))
11422 if (yychar == YYEMPTY)
11424 YYDPRINTF ((stderr,
"Reading a token\n"));
11425 yychar = yylex (&yylval, &yylloc, p);
11428 if (yychar <= END_OF_INPUT)
11430 yychar = END_OF_INPUT;
11431 yytoken = YYSYMBOL_YYEOF;
11432 YYDPRINTF ((stderr,
"Now at end of input.\n"));
11434 else if (yychar == YYerror)
11441 yytoken = YYSYMBOL_YYerror;
11442 yyerror_range[1] = yylloc;
11447 yytoken = YYTRANSLATE (yychar);
11448 YY_SYMBOL_PRINT (
"Next token is", yytoken, &yylval, &yylloc, p);
11454 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
11456 yyn = yytable[yyn];
11459 if (yytable_value_is_error (yyn))
11471 YY_SYMBOL_PRINT (
"Shifting", yytoken, &yylval, &yylloc, p);
11473 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
11475 YY_IGNORE_MAYBE_UNINITIALIZED_END
11478 #line 2662 "parse.y"
11480 #line 11481 "parse.c"
11492 yyn = yydefact[yystate];
11513 yyval = yyvsp[1-yylen];
11515 #line 2663 "parse.y"
11516 {before_reduce(yylen, p);}
11517 #line 11518 "parse.c"
11521 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
11522 yyerror_range[1] = yyloc;
11523 YY_REDUCE_PRINT (yyn, p);
11527 #line 2971 "parse.y"
11529 SET_LEX_STATE(EXPR_BEG);
11530 local_push(p, ifndef_ripper(1)+0);
11532 if (!ifndef_ripper(p->do_loop) + 0) init_block_exit(p);
11534 #line 11535 "parse.c"
11538 #line 2978 "parse.y"
11540 if ((yyvsp[0].node) && !compile_for_eval) {
11541 NODE *node = (yyvsp[0].node);
11543 if (nd_type_p(node, NODE_BLOCK)) {
11544 while (RNODE_BLOCK(node)->nd_next) {
11545 node = RNODE_BLOCK(node)->nd_next;
11547 node = RNODE_BLOCK(node)->nd_head;
11549 node = remove_begin(node);
11550 void_expr(p, node);
11552 p->eval_tree = NEW_SCOPE(0, block_append(p, p->eval_tree, (yyvsp[0].node)), &(yyloc));
11556 #line 11557 "parse.c"
11560 #line 2998 "parse.y"
11562 void_stmts(p, (yyval.node) = (yyvsp[-1].node));
11564 #line 11565 "parse.c"
11568 #line 3004 "parse.y"
11570 (yyval.node) = NEW_BEGIN(0, &(yyloc));
11573 #line 11574 "parse.c"
11577 #line 3009 "parse.y"
11579 (yyval.node) = newline_node((yyvsp[0].node));
11582 #line 11583 "parse.c"
11586 #line 3014 "parse.y"
11588 (yyval.node) = block_append(p, (yyvsp[-2].node), newline_node((yyvsp[0].node)));
11591 #line 11592 "parse.c"
11595 #line 3021 "parse.y"
11597 clear_block_exit(p,
true);
11598 (yyval.node) = (yyvsp[0].node);
11600 #line 11601 "parse.c"
11604 #line 3026 "parse.y"
11606 (yyval.node) = (yyvsp[0].node);
11609 #line 11610 "parse.c"
11613 #line 3032 "parse.y"
11614 {(yyval.node_exits) = init_block_exit(p);}
11615 #line 11616 "parse.c"
11619 #line 3035 "parse.y"
11621 restore_block_exit(p, (yyvsp[-2].node_exits));
11622 p->eval_tree_begin = block_append(p, p->eval_tree_begin,
11623 NEW_BEGIN((yyvsp[-1].node), &(yyloc)));
11624 (yyval.node) = NEW_BEGIN(0, &(yyloc));
11627 #line 11628 "parse.c"
11631 #line 3048 "parse.y"
11633 if (!(yyvsp[-1].node)) yyerror1(&(yylsp[0]),
"else without rescue is useless");
11634 next_rescue_context(&p->ctxt, &(yyvsp[-2].ctxt), after_else);
11636 #line 11637 "parse.c"
11640 #line 3053 "parse.y"
11642 next_rescue_context(&p->ctxt, &(yyvsp[-4].ctxt), after_ensure);
11644 #line 11645 "parse.c"
11648 #line 3057 "parse.y"
11650 (yyval.node) = new_bodystmt(p, (yyvsp[-7].node), (yyvsp[-5].node), (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
11653 #line 11654 "parse.c"
11657 #line 3064 "parse.y"
11659 next_rescue_context(&p->ctxt, &(yyvsp[-1].ctxt), after_ensure);
11661 #line 11662 "parse.c"
11665 #line 3068 "parse.y"
11667 (yyval.node) = new_bodystmt(p, (yyvsp[-4].node), (yyvsp[-2].node), 0, (yyvsp[0].node), &(yyloc));
11670 #line 11671 "parse.c"
11674 #line 3075 "parse.y"
11676 void_stmts(p, (yyval.node) = (yyvsp[-1].node));
11678 #line 11679 "parse.c"
11682 #line 3081 "parse.y"
11684 (yyval.node) = NEW_BEGIN(0, &(yyloc));
11687 #line 11688 "parse.c"
11691 #line 3086 "parse.y"
11693 (yyval.node) = newline_node((yyvsp[0].node));
11696 #line 11697 "parse.c"
11700 #line 3091 "parse.y"
11702 (yyval.node) = block_append(p, (yyvsp[-2].node), newline_node((yyvsp[0].node)));
11705 #line 11706 "parse.c"
11709 #line 3098 "parse.y"
11711 (yyval.node) = (yyvsp[0].node);
11713 #line 11714 "parse.c"
11717 #line 3102 "parse.y"
11719 yyerror1(&(yylsp[0]),
"BEGIN is permitted only at toplevel");
11721 #line 11722 "parse.c"
11725 #line 3106 "parse.y"
11727 (yyval.node) = (yyvsp[0].node);
11729 #line 11730 "parse.c"
11733 #line 3111 "parse.y"
11734 {(yyval.node_exits) = allow_block_exit(p);}
11735 #line 11736 "parse.c"
11739 #line 3114 "parse.y"
11741 (yyval.ctxt) = (yyvsp[0].ctxt);
11742 p->ctxt.in_rescue = before_rescue;
11745 #line 11746 "parse.c"
11749 #line 3120 "parse.y"
11750 {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);}
11751 #line 11752 "parse.c"
11755 #line 3121 "parse.y"
11757 (yyval.node) = NEW_ALIAS((yyvsp[-2].node), (yyvsp[0].node), &(yyloc), &(yylsp[-3]));
11760 #line 11761 "parse.c"
11764 #line 3126 "parse.y"
11766 (yyval.node) = NEW_VALIAS((yyvsp[-1].
id), (yyvsp[0].id), &(yyloc), &(yylsp[-2]));
11769 #line 11770 "parse.c"
11773 #line 3131 "parse.y"
11777 buf[1] = (char)RNODE_BACK_REF((yyvsp[0].node))->nd_nth;
11778 (yyval.node) = NEW_VALIAS((yyvsp[-1].
id),
rb_intern2(buf, 2), &(yyloc), &(yylsp[-2]));
11781 #line 11782 "parse.c"
11785 #line 3139 "parse.y"
11787 static const char mesg[] =
"can't make alias for the number variables";
11789 yyerror1(&(yylsp[0]), mesg);
11791 (yyval.node) = NEW_ERROR(&(yyloc));
11794 #line 11795 "parse.c"
11798 #line 3148 "parse.y"
11800 nd_set_first_loc((yyvsp[0].node), (yylsp[-1]).beg_pos);
11801 RNODE_UNDEF((yyvsp[0].node))->keyword_loc = (yylsp[-1]);
11802 (yyval.node) = (yyvsp[0].node);
11805 #line 11806 "parse.c"
11809 #line 3155 "parse.y"
11811 (yyval.node) = new_if(p, (yyvsp[0].node), remove_begin((yyvsp[-2].node)), 0, &(yyloc));
11812 fixpos((yyval.node), (yyvsp[0].node));
11815 #line 11816 "parse.c"
11819 #line 3161 "parse.y"
11821 (yyval.node) = new_unless(p, (yyvsp[0].node), remove_begin((yyvsp[-2].node)), 0, &(yyloc), &(yylsp[-1]), &NULL_LOC, &NULL_LOC);
11822 fixpos((yyval.node), (yyvsp[0].node));
11825 #line 11826 "parse.c"
11829 #line 3167 "parse.y"
11831 clear_block_exit(p,
false);
11832 if ((yyvsp[-2].node) && nd_type_p((yyvsp[-2].node), NODE_BEGIN)) {
11833 (yyval.node) = NEW_WHILE(cond(p, (yyvsp[0].node), &(yylsp[0])), RNODE_BEGIN((yyvsp[-2].node))->nd_body, 0, &(yyloc), &(yylsp[-1]), &NULL_LOC);
11836 (yyval.node) = NEW_WHILE(cond(p, (yyvsp[0].node), &(yylsp[0])), (yyvsp[-2].node), 1, &(yyloc), &(yylsp[-1]), &NULL_LOC);
11840 #line 11841 "parse.c"
11844 #line 3178 "parse.y"
11846 clear_block_exit(p,
false);
11847 if ((yyvsp[-2].node) && nd_type_p((yyvsp[-2].node), NODE_BEGIN)) {
11848 (yyval.node) = NEW_UNTIL(cond(p, (yyvsp[0].node), &(yylsp[0])), RNODE_BEGIN((yyvsp[-2].node))->nd_body, 0, &(yyloc), &(yylsp[-1]), &NULL_LOC);
11851 (yyval.node) = NEW_UNTIL(cond(p, (yyvsp[0].node), &(yylsp[0])), (yyvsp[-2].node), 1, &(yyloc), &(yylsp[-1]), &NULL_LOC);
11855 #line 11856 "parse.c"
11859 #line 3189 "parse.y"
11861 p->ctxt.in_rescue = (yyvsp[-1].ctxt).in_rescue;
11863 YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
11864 resq = NEW_RESBODY(0, 0, remove_begin((yyvsp[0].node)), 0, &loc);
11865 (yyval.node) = NEW_RESCUE(remove_begin((yyvsp[-3].node)), resq, 0, &(yyloc));
11868 #line 11869 "parse.c"
11872 #line 3198 "parse.y"
11874 if (p->ctxt.in_def) {
11875 rb_warn0(
"END in method; use at_exit");
11877 restore_block_exit(p, (yyvsp[-3].node_exits));
11878 p->ctxt = (yyvsp[-4].ctxt);
11880 NODE *scope = NEW_SCOPE2(0 , 0 , (yyvsp[-1].node) , &(yyloc));
11881 (yyval.node) = NEW_POSTEXE(scope, &(yyloc));
11885 #line 11886 "parse.c"
11889 #line 3212 "parse.y"
11891 value_expr((yyvsp[0].node));
11892 (yyval.node) = node_assign(p, (
NODE *)(yyvsp[-3].node_masgn), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
11895 #line 11896 "parse.c"
11899 #line 3218 "parse.y"
11901 (yyval.node) = node_assign(p, (yyvsp[-3].node), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
11904 #line 11905 "parse.c"
11908 #line 3224 "parse.y"
11910 p->ctxt.in_rescue = (yyvsp[-4].ctxt).in_rescue;
11911 YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
11912 (yyvsp[0].node) = NEW_RESBODY(0, 0, remove_begin((yyvsp[0].node)), 0, &loc);
11913 loc.beg_pos = (yylsp[-3]).beg_pos;
11914 (yyvsp[-3].node) = NEW_RESCUE((yyvsp[-3].node), (yyvsp[0].node), 0, &loc);
11915 (yyval.node) = node_assign(p, (
NODE *)(yyvsp[-6].node_masgn), (yyvsp[-3].node), (yyvsp[-4].ctxt), &(yyloc));
11918 #line 11919 "parse.c"
11922 #line 3234 "parse.y"
11924 (yyval.node) = node_assign(p, (
NODE *)(yyvsp[-3].node_masgn), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
11927 #line 11928 "parse.c"
11931 #line 3240 "parse.y"
11934 (yyval.node) = NEW_ERROR(&(yyloc));
11936 #line 11937 "parse.c"
11940 #line 3247 "parse.y"
11942 (yyval.node) = node_assign(p, (yyvsp[-3].node), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
11945 #line 11946 "parse.c"
11949 #line 3252 "parse.y"
11951 (yyval.node) = new_op_assign(p, (yyvsp[-3].node), (yyvsp[-2].id), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
11954 #line 11955 "parse.c"
11958 #line 3257 "parse.y"
11960 (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]));
11964 #line 11965 "parse.c"
11968 #line 3263 "parse.y"
11970 (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]));
11973 #line 11974 "parse.c"
11977 #line 3263 "parse.y"
11979 (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]));
11982 #line 11983 "parse.c"
11986 #line 3268 "parse.y"
11988 YYLTYPE loc = code_loc_gen(&(yylsp[-5]), &(yylsp[-3]));
11989 (yyval.node) = new_const_op_assign(p, NEW_COLON2((yyvsp[-5].node), (yyvsp[-3].
id), &loc), (yyvsp[-2].id), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
11992 #line 11993 "parse.c"
11996 #line 3274 "parse.y"
11998 (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]));
12001 #line 12002 "parse.c"
12005 #line 3279 "parse.y"
12007 endless_method_name(p, (yyvsp[-3].node_def_temp)->nd_mid, &(yylsp[-3]));
12008 restore_defun(p, (yyvsp[-3].node_def_temp));
12009 (yyvsp[0].node) = new_scope_body(p, (yyvsp[-2].node_args), (yyvsp[0].node), &(yyloc));
12010 ((yyval.node) = (yyvsp[-3].node_def_temp)->nd_def)->nd_loc = (yyloc);
12011 RNODE_DEFN((yyval.node))->nd_defn = (yyvsp[0].node);
12016 #line 12017 "parse.c"
12020 #line 3290 "parse.y"
12022 endless_method_name(p, (yyvsp[-3].node_def_temp)->nd_mid, &(yylsp[-3]));
12023 restore_defun(p, (yyvsp[-3].node_def_temp));
12024 (yyvsp[0].node) = new_scope_body(p, (yyvsp[-2].node_args), (yyvsp[0].node), &(yyloc));
12025 ((yyval.node) = (yyvsp[-3].node_def_temp)->nd_def)->nd_loc = (yyloc);
12026 RNODE_DEFS((yyval.node))->nd_defn = (yyvsp[0].node);
12031 #line 12032 "parse.c"
12035 #line 3301 "parse.y"
12037 VALUE MAYBE_UNUSED(e) = rb_backref_error(p, (yyvsp[-3].node));
12038 (yyval.node) = NEW_ERROR(&(yyloc));
12041 #line 12042 "parse.c"
12045 #line 3310 "parse.y"
12047 p->ctxt.in_rescue = (yyvsp[-1].ctxt).in_rescue;
12048 (yyval.node) = rescued_expr(p, (yyvsp[-3].node), (yyvsp[0].node), &(yylsp[-3]), &(yylsp[-2]), &(yylsp[0]));
12051 #line 12052 "parse.c"
12055 #line 3316 "parse.y"
12057 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[0].node), &(yylsp[0])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
12060 #line 12061 "parse.c"
12064 #line 3323 "parse.y"
12066 value_expr((yyvsp[0].node));
12067 (yyval.node) = (yyvsp[0].node);
12069 #line 12070 "parse.c"
12073 #line 3328 "parse.y"
12075 p->ctxt.in_rescue = (yyvsp[-1].ctxt).in_rescue;
12076 YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
12077 value_expr((yyvsp[-3].node));
12078 (yyval.node) = NEW_RESCUE((yyvsp[-3].node), NEW_RESBODY(0, 0, remove_begin((yyvsp[0].node)), 0, &loc), 0, &(yyloc));
12081 #line 12082 "parse.c"
12085 #line 3340 "parse.y"
12087 (yyval.node) = logop(p, idAND, (yyvsp[-2].node), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
12090 #line 12091 "parse.c"
12094 #line 3345 "parse.y"
12096 (yyval.node) = logop(p, idOR, (yyvsp[-2].node), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
12099 #line 12100 "parse.c"
12103 #line 3350 "parse.y"
12105 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[0].node), &(yylsp[0])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
12108 #line 12109 "parse.c"
12112 #line 3355 "parse.y"
12114 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[0].node), &(yylsp[0])),
'!', &(yylsp[-1]), &(yyloc));
12117 #line 12118 "parse.c"
12121 #line 3360 "parse.y"
12123 value_expr((yyvsp[-1].node));
12125 #line 12126 "parse.c"
12129 #line 3365 "parse.y"
12131 pop_pktbl(p, (yyvsp[-1].tbl));
12132 pop_pvtbl(p, (yyvsp[-2].tbl));
12133 p->ctxt.in_kwarg = (yyvsp[-3].ctxt).in_kwarg;
12134 (yyval.node) = NEW_CASE3((yyvsp[-6].node), NEW_IN((yyvsp[0].node), 0, 0, &(yylsp[0])), &(yyloc), &NULL_LOC, &NULL_LOC);
12137 #line 12138 "parse.c"
12141 #line 3373 "parse.y"
12143 value_expr((yyvsp[-1].node));
12145 #line 12146 "parse.c"
12149 #line 3378 "parse.y"
12151 pop_pktbl(p, (yyvsp[-1].tbl));
12152 pop_pvtbl(p, (yyvsp[-2].tbl));
12153 p->ctxt.in_kwarg = (yyvsp[-3].ctxt).in_kwarg;
12154 (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);
12157 #line 12158 "parse.c"
12161 #line 3389 "parse.y"
12163 ID fname = (yyvsp[0].id);
12164 numparam_name(p, fname);
12166 p->ctxt.in_def = 1;
12167 p->ctxt.in_rescue = before_rescue;
12168 p->ctxt.cant_return = 0;
12169 (yyval.id) = (yyvsp[0].
id);
12171 #line 12172 "parse.c"
12175 #line 3401 "parse.y"
12177 (yyval.node_def_temp) = def_head_save(p, (yyvsp[-1].node_def_temp));
12178 (yyval.node_def_temp)->nd_mid = (yyvsp[0].
id);
12179 (yyval.node_def_temp)->nd_def = NEW_DEFN((yyvsp[0].
id), 0, &(yyloc));
12182 #line 12183 "parse.c"
12186 #line 3410 "parse.y"
12188 SET_LEX_STATE(EXPR_FNAME);
12190 #line 12191 "parse.c"
12194 #line 3414 "parse.y"
12196 SET_LEX_STATE(EXPR_ENDFN|EXPR_LABEL);
12197 (yyval.node_def_temp) = def_head_save(p, (yyvsp[-4].node_def_temp));
12198 (yyval.node_def_temp)->nd_mid = (yyvsp[0].
id);
12199 (yyval.node_def_temp)->nd_def = NEW_DEFS((yyvsp[-3].node), (yyvsp[0].id), 0, &(yyloc));
12202 #line 12203 "parse.c"
12206 #line 3424 "parse.y"
12208 value_expr((yyvsp[0].node));
12209 (yyval.node) = (yyvsp[0].node);
12211 #line 12212 "parse.c"
12215 #line 3429 "parse.y"
12217 (yyval.node) = NEW_ERROR(&(yyloc));
12219 #line 12220 "parse.c"
12223 #line 3434 "parse.y"
12225 #line 12226 "parse.c"
12229 #line 3434 "parse.y"
12231 #line 12232 "parse.c"
12235 #line 3435 "parse.y"
12237 (yyval.node) = (yyvsp[-2].node);
12240 #line 12241 "parse.c"
12244 #line 3447 "parse.y"
12246 (yyval.node) = new_qcall(p, (yyvsp[-2].
id), (yyvsp[-3].node), (yyvsp[-1].
id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
12249 #line 12250 "parse.c"
12253 #line 3454 "parse.y"
12255 (yyval.node) = (yyvsp[-1].node);
12256 set_embraced_location((yyval.node), &(yylsp[-2]), &(yylsp[0]));
12259 #line 12260 "parse.c"
12263 #line 3462 "parse.y"
12265 (yyval.node_fcall) = NEW_FCALL((yyvsp[0].
id), 0, &(yyloc));
12268 #line 12269 "parse.c"
12272 #line 3469 "parse.y"
12274 (yyvsp[-1].node_fcall)->nd_args = (yyvsp[0].node);
12275 nd_set_last_loc((yyvsp[-1].node_fcall), (yylsp[0]).end_pos);
12276 (yyval.node) = (
NODE *)(yyvsp[-1].node_fcall);
12279 #line 12280 "parse.c"
12283 #line 3476 "parse.y"
12285 block_dup_check(p, (yyvsp[-1].node), (yyvsp[0].node));
12286 (yyvsp[-2].node_fcall)->nd_args = (yyvsp[-1].node);
12287 (yyval.node) = method_add_block(p, (
NODE *)(yyvsp[-2].node_fcall), (yyvsp[0].node), &(yyloc));
12288 fixpos((yyval.node), RNODE((yyvsp[-2].node_fcall)));
12289 nd_set_last_loc((yyvsp[-2].node_fcall), (yylsp[-1]).end_pos);
12292 #line 12293 "parse.c"
12296 #line 3485 "parse.y"
12298 (yyval.node) = new_command_qcall(p, (yyvsp[-2].
id), (yyvsp[-3].node), (yyvsp[-1].
id), (yyvsp[0].node), 0, &(yylsp[-1]), &(yyloc));
12301 #line 12302 "parse.c"
12305 #line 3490 "parse.y"
12307 (yyval.node) = new_command_qcall(p, (yyvsp[-3].
id), (yyvsp[-4].node), (yyvsp[-2].
id), (yyvsp[-1].node), (yyvsp[0].node), &(yylsp[-2]), &(yyloc));
12310 #line 12311 "parse.c"
12314 #line 3495 "parse.y"
12316 (yyval.node) = new_command_qcall(p, idCOLON2, (yyvsp[-3].node), (yyvsp[-1].id), (yyvsp[0].node), 0, &(yylsp[-1]), &(yyloc));
12319 #line 12320 "parse.c"
12323 #line 3500 "parse.y"
12325 (yyval.node) = new_command_qcall(p, idCOLON2, (yyvsp[-4].node), (yyvsp[-2].id), (yyvsp[-1].node), (yyvsp[0].node), &(yylsp[-2]), &(yyloc));
12328 #line 12329 "parse.c"
12332 #line 3505 "parse.y"
12334 set_embraced_location((yyvsp[-1].node), &(yylsp[-2]), &(yylsp[0]));
12335 (yyval.node) = new_command_qcall(p, idCOLON2, (yyvsp[-5].node), (yyvsp[-3].id), 0, (yyvsp[-1].node), &(yylsp[-3]), &(yyloc));
12338 #line 12339 "parse.c"
12342 #line 3511 "parse.y"
12344 (yyval.node) = NEW_SUPER((yyvsp[0].node), &(yyloc));
12345 fixpos((yyval.node), (yyvsp[0].node));
12348 #line 12349 "parse.c"
12352 #line 3517 "parse.y"
12354 (yyval.node) = new_yield(p, (yyvsp[0].node), &(yyloc));
12355 fixpos((yyval.node), (yyvsp[0].node));
12358 #line 12359 "parse.c"
12362 #line 3523 "parse.y"
12364 (yyval.node) = NEW_RETURN(ret_args(p, (yyvsp[0].node)), &(yyloc), &(yylsp[-1]));
12367 #line 12368 "parse.c"
12371 #line 3528 "parse.y"
12374 args = ret_args(p, (yyvsp[0].node));
12375 (yyval.node) = add_block_exit(p, NEW_BREAK(args, &(yyloc), &(yylsp[-1])));
12378 #line 12379 "parse.c"
12382 #line 3535 "parse.y"
12385 args = ret_args(p, (yyvsp[0].node));
12386 (yyval.node) = add_block_exit(p, NEW_NEXT(args, &(yyloc), &(yylsp[-1])));
12389 #line 12390 "parse.c"
12393 #line 3545 "parse.y"
12395 (yyval.node_masgn) = (yyvsp[-1].node_masgn);
12398 #line 12399 "parse.c"
12402 #line 3553 "parse.y"
12404 (yyval.node_masgn) = NEW_MASGN(NEW_LIST((
NODE *)(yyvsp[-1].node_masgn), &(yyloc)), 0, &(yyloc));
12407 #line 12408 "parse.c"
12411 #line 3560 "parse.y"
12413 (yyval.node_masgn) = NEW_MASGN((yyvsp[0].node), 0, &(yyloc));
12416 #line 12417 "parse.c"
12420 #line 3565 "parse.y"
12422 (yyval.node_masgn) = NEW_MASGN(list_append(p, (yyvsp[-1].node), (yyvsp[0].node)), 0, &(yyloc));
12425 #line 12426 "parse.c"
12429 #line 3570 "parse.y"
12431 (yyval.node_masgn) = NEW_MASGN((yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
12434 #line 12435 "parse.c"
12438 #line 3575 "parse.y"
12440 (yyval.node_masgn) = NEW_MASGN((yyvsp[-4].node), NEW_POSTARG((yyvsp[-2].node),(yyvsp[0].node),&(yyloc)), &(yyloc));
12443 #line 12444 "parse.c"
12447 #line 3580 "parse.y"
12449 (yyval.node_masgn) = NEW_MASGN((yyvsp[-1].node), NODE_SPECIAL_NO_NAME_REST, &(yyloc));
12452 #line 12453 "parse.c"
12456 #line 3585 "parse.y"
12458 (yyval.node_masgn) = NEW_MASGN((yyvsp[-3].node), NEW_POSTARG(NODE_SPECIAL_NO_NAME_REST, (yyvsp[0].node), &(yyloc)), &(yyloc));
12461 #line 12462 "parse.c"
12465 #line 3590 "parse.y"
12467 (yyval.node_masgn) = NEW_MASGN(0, (yyvsp[0].node), &(yyloc));
12470 #line 12471 "parse.c"
12474 #line 3595 "parse.y"
12476 (yyval.node_masgn) = NEW_MASGN(0, NEW_POSTARG((yyvsp[-2].node),(yyvsp[0].node),&(yyloc)), &(yyloc));
12479 #line 12480 "parse.c"
12483 #line 3600 "parse.y"
12485 (yyval.node_masgn) = NEW_MASGN(0, NODE_SPECIAL_NO_NAME_REST, &(yyloc));
12488 #line 12489 "parse.c"
12492 #line 3605 "parse.y"
12494 (yyval.node_masgn) = NEW_MASGN(0, NEW_POSTARG(NODE_SPECIAL_NO_NAME_REST, (yyvsp[0].node), &(yyloc)), &(yyloc));
12497 #line 12498 "parse.c"
12501 #line 3613 "parse.y"
12503 (yyval.node) = (
NODE *)(yyvsp[-1].node_masgn);
12506 #line 12507 "parse.c"
12510 #line 3620 "parse.y"
12512 (yyval.node) = NEW_LIST((yyvsp[-1].node), &(yylsp[-1]));
12515 #line 12516 "parse.c"
12519 #line 3625 "parse.y"
12521 (yyval.node) = list_append(p, (yyvsp[-2].node), (yyvsp[-1].node));
12524 #line 12525 "parse.c"
12528 #line 3632 "parse.y"
12530 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
12533 #line 12534 "parse.c"
12537 #line 3637 "parse.y"
12539 (yyval.node) = list_append(p, (yyvsp[-2].node), (yyvsp[0].node));
12542 #line 12543 "parse.c"
12546 #line 3644 "parse.y"
12549 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
12551 #line 12552 "parse.c"
12555 #line 3644 "parse.y"
12558 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
12560 #line 12561 "parse.c"
12564 #line 3649 "parse.y"
12566 (yyval.node) = aryset(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
12569 #line 12570 "parse.c"
12573 #line 3654 "parse.y"
12575 anddot_multiple_assignment_check(p, &(yylsp[-1]), (yyvsp[-1].
id));
12576 (yyval.node) = attrset(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].
id), &(yyloc));
12579 #line 12580 "parse.c"
12583 #line 3660 "parse.y"
12585 (yyval.node) = attrset(p, (yyvsp[-2].node), idCOLON2, (yyvsp[0].id), &(yyloc));
12588 #line 12589 "parse.c"
12592 #line 3665 "parse.y"
12594 anddot_multiple_assignment_check(p, &(yylsp[-1]), (yyvsp[-1].
id));
12595 (yyval.node) = attrset(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].
id), &(yyloc));
12598 #line 12599 "parse.c"
12602 #line 3671 "parse.y"
12605 (yyval.node) = const_decl(p, NEW_COLON2((yyvsp[-2].node), (yyvsp[0].id), &(yyloc)), &(yyloc));
12607 #line 12608 "parse.c"
12611 #line 3676 "parse.y"
12614 (yyval.node) = const_decl(p, NEW_COLON3((yyvsp[0].
id), &(yyloc)), &(yyloc));
12616 #line 12617 "parse.c"
12620 #line 3681 "parse.y"
12622 VALUE MAYBE_UNUSED(e) = rb_backref_error(p, (yyvsp[0].node));
12623 (yyval.node) = NEW_ERROR(&(yyloc));
12626 #line 12627 "parse.c"
12630 #line 3689 "parse.y"
12633 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
12635 #line 12636 "parse.c"
12639 #line 3689 "parse.y"
12642 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
12644 #line 12645 "parse.c"
12648 #line 3694 "parse.y"
12650 (yyval.node) = aryset(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
12653 #line 12654 "parse.c"
12657 #line 3699 "parse.y"
12659 (yyval.node) = attrset(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].
id), &(yyloc));
12662 #line 12663 "parse.c"
12666 #line 3704 "parse.y"
12668 (yyval.node) = attrset(p, (yyvsp[-2].node), idCOLON2, (yyvsp[0].id), &(yyloc));
12671 #line 12672 "parse.c"
12675 #line 3709 "parse.y"
12677 (yyval.node) = attrset(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].
id), &(yyloc));
12680 #line 12681 "parse.c"
12684 #line 3714 "parse.y"
12687 (yyval.node) = const_decl(p, NEW_COLON2((yyvsp[-2].node), (yyvsp[0].id), &(yyloc)), &(yyloc));
12689 #line 12690 "parse.c"
12693 #line 3719 "parse.y"
12696 (yyval.node) = const_decl(p, NEW_COLON3((yyvsp[0].
id), &(yyloc)), &(yyloc));
12698 #line 12699 "parse.c"
12702 #line 3724 "parse.y"
12704 VALUE MAYBE_UNUSED(e) = rb_backref_error(p, (yyvsp[0].node));
12705 (yyval.node) = NEW_ERROR(&(yyloc));
12708 #line 12709 "parse.c"
12712 #line 3732 "parse.y"
12714 static const char mesg[] =
"class/module name must be CONSTANT";
12716 yyerror1(&(yylsp[0]), mesg);
12720 #line 12721 "parse.c"
12724 #line 3743 "parse.y"
12726 (yyval.node) = NEW_COLON3((yyvsp[0].
id), &(yyloc));
12729 #line 12730 "parse.c"
12733 #line 3748 "parse.y"
12735 (yyval.node) = NEW_COLON2(0, (yyvsp[0].
id), &(yyloc));
12738 #line 12739 "parse.c"
12742 #line 3753 "parse.y"
12744 (yyval.node) = NEW_COLON2((yyvsp[-2].node), (yyvsp[0].id), &(yyloc));
12747 #line 12748 "parse.c"
12751 #line 3762 "parse.y"
12753 SET_LEX_STATE(EXPR_ENDFN);
12754 (yyval.id) = (yyvsp[0].
id);
12756 #line 12757 "parse.c"
12760 #line 3770 "parse.y"
12762 (yyval.node) = NEW_SYM(
rb_id2str((yyvsp[0].
id)), &(yyloc));
12765 #line 12766 "parse.c"
12769 #line 3778 "parse.y"
12771 (yyval.node) = NEW_UNDEF((yyvsp[0].node), &(yyloc));
12774 #line 12775 "parse.c"
12778 #line 3782 "parse.y"
12779 {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);}
12780 #line 12781 "parse.c"
12784 #line 3783 "parse.y"
12786 nd_set_last_loc((yyvsp[-3].node), (yylsp[0]).end_pos);
12787 rb_parser_ary_push_node(p, RNODE_UNDEF((yyvsp[-3].node))->nd_undefs, (yyvsp[0].node));
12790 #line 12791 "parse.c"
12794 #line 3790 "parse.y"
12795 { (yyval.id) =
'|'; }
12796 #line 12797 "parse.c"
12800 #line 3791 "parse.y"
12801 { (yyval.id) =
'^'; }
12802 #line 12803 "parse.c"
12806 #line 3792 "parse.y"
12807 { (yyval.id) =
'&'; }
12808 #line 12809 "parse.c"
12812 #line 3793 "parse.y"
12813 { (yyval.id) = tCMP; }
12814 #line 12815 "parse.c"
12818 #line 3794 "parse.y"
12819 { (yyval.id) = tEQ; }
12820 #line 12821 "parse.c"
12824 #line 3795 "parse.y"
12825 { (yyval.id) = tEQQ; }
12826 #line 12827 "parse.c"
12830 #line 3796 "parse.y"
12831 { (yyval.id) = tMATCH; }
12832 #line 12833 "parse.c"
12836 #line 3797 "parse.y"
12837 { (yyval.id) = tNMATCH; }
12838 #line 12839 "parse.c"
12842 #line 3798 "parse.y"
12843 { (yyval.id) =
'>'; }
12844 #line 12845 "parse.c"
12848 #line 3799 "parse.y"
12849 { (yyval.id) = tGEQ; }
12850 #line 12851 "parse.c"
12854 #line 3800 "parse.y"
12855 { (yyval.id) =
'<'; }
12856 #line 12857 "parse.c"
12860 #line 3801 "parse.y"
12861 { (yyval.id) = tLEQ; }
12862 #line 12863 "parse.c"
12866 #line 3802 "parse.y"
12867 { (yyval.id) = tNEQ; }
12868 #line 12869 "parse.c"
12872 #line 3803 "parse.y"
12873 { (yyval.id) = tLSHFT; }
12874 #line 12875 "parse.c"
12878 #line 3804 "parse.y"
12879 { (yyval.id) = tRSHFT; }
12880 #line 12881 "parse.c"
12884 #line 3805 "parse.y"
12885 { (yyval.id) =
'+'; }
12886 #line 12887 "parse.c"
12890 #line 3806 "parse.y"
12891 { (yyval.id) =
'-'; }
12892 #line 12893 "parse.c"
12896 #line 3807 "parse.y"
12897 { (yyval.id) =
'*'; }
12898 #line 12899 "parse.c"
12902 #line 3808 "parse.y"
12903 { (yyval.id) =
'*'; }
12904 #line 12905 "parse.c"
12908 #line 3809 "parse.y"
12909 { (yyval.id) =
'/'; }
12910 #line 12911 "parse.c"
12914 #line 3810 "parse.y"
12915 { (yyval.id) =
'%'; }
12916 #line 12917 "parse.c"
12920 #line 3811 "parse.y"
12921 { (yyval.id) = tPOW; }
12922 #line 12923 "parse.c"
12926 #line 3812 "parse.y"
12927 { (yyval.id) = tDSTAR; }
12928 #line 12929 "parse.c"
12932 #line 3813 "parse.y"
12933 { (yyval.id) =
'!'; }
12934 #line 12935 "parse.c"
12938 #line 3814 "parse.y"
12939 { (yyval.id) =
'~'; }
12940 #line 12941 "parse.c"
12944 #line 3815 "parse.y"
12945 { (yyval.id) = tUPLUS; }
12946 #line 12947 "parse.c"
12950 #line 3816 "parse.y"
12951 { (yyval.id) = tUMINUS; }
12952 #line 12953 "parse.c"
12956 #line 3817 "parse.y"
12957 { (yyval.id) = tAREF; }
12958 #line 12959 "parse.c"
12962 #line 3818 "parse.y"
12963 { (yyval.id) = tASET; }
12964 #line 12965 "parse.c"
12968 #line 3819 "parse.y"
12969 { (yyval.id) =
'`'; }
12970 #line 12971 "parse.c"
12974 #line 3837 "parse.y"
12976 (yyval.node) = node_assign(p, (yyvsp[-3].node), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
12979 #line 12980 "parse.c"
12983 #line 3842 "parse.y"
12985 (yyval.node) = new_op_assign(p, (yyvsp[-3].node), (yyvsp[-2].id), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
12988 #line 12989 "parse.c"
12992 #line 3847 "parse.y"
12994 (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]));
12997 #line 12998 "parse.c"
13001 #line 3852 "parse.y"
13003 (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]));
13006 #line 13007 "parse.c"
13010 #line 3857 "parse.y"
13012 (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]));
13015 #line 13016 "parse.c"
13019 #line 3862 "parse.y"
13021 (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]));
13024 #line 13025 "parse.c"
13028 #line 3867 "parse.y"
13030 YYLTYPE loc = code_loc_gen(&(yylsp[-5]), &(yylsp[-3]));
13031 (yyval.node) = new_const_op_assign(p, NEW_COLON2((yyvsp[-5].node), (yyvsp[-3].
id), &loc), (yyvsp[-2].id), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
13034 #line 13035 "parse.c"
13038 #line 3873 "parse.y"
13040 YYLTYPE loc = code_loc_gen(&(yylsp[-4]), &(yylsp[-3]));
13041 (yyval.node) = new_const_op_assign(p, NEW_COLON3((yyvsp[-3].
id), &loc), (yyvsp[-2].id), (yyvsp[0].node), (yyvsp[-1].ctxt), &(yyloc));
13044 #line 13045 "parse.c"
13048 #line 3879 "parse.y"
13050 VALUE MAYBE_UNUSED(e) = rb_backref_error(p, (yyvsp[-3].node));
13051 (yyval.node) = NEW_ERROR(&(yyloc));
13054 #line 13055 "parse.c"
13058 #line 3885 "parse.y"
13060 value_expr((yyvsp[-2].node));
13061 value_expr((yyvsp[0].node));
13062 (yyval.node) = NEW_DOT2((yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
13065 #line 13066 "parse.c"
13069 #line 3892 "parse.y"
13071 value_expr((yyvsp[-2].node));
13072 value_expr((yyvsp[0].node));
13073 (yyval.node) = NEW_DOT3((yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
13076 #line 13077 "parse.c"
13080 #line 3899 "parse.y"
13082 value_expr((yyvsp[-1].node));
13083 (yyval.node) = NEW_DOT2((yyvsp[-1].node), new_nil_at(p, &(yylsp[0]).end_pos), &(yyloc));
13086 #line 13087 "parse.c"
13090 #line 3905 "parse.y"
13092 value_expr((yyvsp[-1].node));
13093 (yyval.node) = NEW_DOT3((yyvsp[-1].node), new_nil_at(p, &(yylsp[0]).end_pos), &(yyloc));
13096 #line 13097 "parse.c"
13100 #line 3911 "parse.y"
13102 value_expr((yyvsp[0].node));
13103 (yyval.node) = NEW_DOT2(new_nil_at(p, &(yylsp[-1]).beg_pos), (yyvsp[0].node), &(yyloc));
13106 #line 13107 "parse.c"
13110 #line 3917 "parse.y"
13112 value_expr((yyvsp[0].node));
13113 (yyval.node) = NEW_DOT3(new_nil_at(p, &(yylsp[-1]).beg_pos), (yyvsp[0].node), &(yyloc));
13116 #line 13117 "parse.c"
13120 #line 3923 "parse.y"
13122 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'+', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13125 #line 13126 "parse.c"
13129 #line 3928 "parse.y"
13131 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'-', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13134 #line 13135 "parse.c"
13138 #line 3933 "parse.y"
13140 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'*', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13143 #line 13144 "parse.c"
13147 #line 3938 "parse.y"
13149 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'/', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13152 #line 13153 "parse.c"
13156 #line 3943 "parse.y"
13158 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'%', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13161 #line 13162 "parse.c"
13165 #line 3948 "parse.y"
13167 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idPow, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13170 #line 13171 "parse.c"
13174 #line 3953 "parse.y"
13176 (yyval.node) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].node), idPow, (yyvsp[0].node), &(yylsp[-2]), &(yyloc)), idUMinus, &(yylsp[-3]), &(yyloc));
13179 #line 13180 "parse.c"
13183 #line 3958 "parse.y"
13185 (yyval.node) = call_uni_op(p, (yyvsp[0].node), idUPlus, &(yylsp[-1]), &(yyloc));
13188 #line 13189 "parse.c"
13192 #line 3963 "parse.y"
13194 (yyval.node) = call_uni_op(p, (yyvsp[0].node), idUMinus, &(yylsp[-1]), &(yyloc));
13197 #line 13198 "parse.c"
13201 #line 3968 "parse.y"
13203 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'|', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13206 #line 13207 "parse.c"
13210 #line 3973 "parse.y"
13212 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'^', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13215 #line 13216 "parse.c"
13219 #line 3978 "parse.y"
13221 (yyval.node) = call_bin_op(p, (yyvsp[-2].node),
'&', (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13224 #line 13225 "parse.c"
13228 #line 3983 "parse.y"
13230 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idCmp, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13233 #line 13234 "parse.c"
13237 #line 3989 "parse.y"
13239 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idEq, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13242 #line 13243 "parse.c"
13246 #line 3994 "parse.y"
13248 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idEqq, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13251 #line 13252 "parse.c"
13255 #line 3999 "parse.y"
13257 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idNeq, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13260 #line 13261 "parse.c"
13264 #line 4004 "parse.y"
13266 (yyval.node) = match_op(p, (yyvsp[-2].node), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13269 #line 13270 "parse.c"
13273 #line 4009 "parse.y"
13275 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idNeqTilde, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13278 #line 13279 "parse.c"
13282 #line 4014 "parse.y"
13284 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[0].node), &(yylsp[0])),
'!', &(yylsp[-1]), &(yyloc));
13287 #line 13288 "parse.c"
13291 #line 4019 "parse.y"
13293 (yyval.node) = call_uni_op(p, (yyvsp[0].node),
'~', &(yylsp[-1]), &(yyloc));
13296 #line 13297 "parse.c"
13300 #line 4024 "parse.y"
13302 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idLTLT, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13305 #line 13306 "parse.c"
13309 #line 4029 "parse.y"
13311 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), idGTGT, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13314 #line 13315 "parse.c"
13318 #line 4034 "parse.y"
13320 (yyval.node) = logop(p, idANDOP, (yyvsp[-2].node), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13323 #line 13324 "parse.c"
13327 #line 4039 "parse.y"
13329 (yyval.node) = logop(p, idOROP, (yyvsp[-2].node), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13332 #line 13333 "parse.c"
13336 #line 4044 "parse.y"
13338 p->ctxt.in_defined = (yyvsp[-1].ctxt).in_defined;
13339 (yyval.node) = new_defined(p, (yyvsp[0].node), &(yyloc));
13342 #line 13343 "parse.c"
13346 #line 4050 "parse.y"
13348 value_expr((yyvsp[-5].node));
13349 (yyval.node) = new_if(p, (yyvsp[-5].node), (yyvsp[-3].node), (yyvsp[0].node), &(yyloc));
13350 fixpos((yyval.node), (yyvsp[-5].node));
13353 #line 13354 "parse.c"
13357 #line 4057 "parse.y"
13359 endless_method_name(p, (yyvsp[-3].node_def_temp)->nd_mid, &(yylsp[-3]));
13360 restore_defun(p, (yyvsp[-3].node_def_temp));
13361 (yyvsp[0].node) = new_scope_body(p, (yyvsp[-2].node_args), (yyvsp[0].node), &(yyloc));
13362 ((yyval.node) = (yyvsp[-3].node_def_temp)->nd_def)->nd_loc = (yyloc);
13363 RNODE_DEFN((yyval.node))->nd_defn = (yyvsp[0].node);
13368 #line 13369 "parse.c"
13372 #line 4068 "parse.y"
13374 endless_method_name(p, (yyvsp[-3].node_def_temp)->nd_mid, &(yylsp[-3]));
13375 restore_defun(p, (yyvsp[-3].node_def_temp));
13376 (yyvsp[0].node) = new_scope_body(p, (yyvsp[-2].node_args), (yyvsp[0].node), &(yyloc));
13377 ((yyval.node) = (yyvsp[-3].node_def_temp)->nd_def)->nd_loc = (yyloc);
13378 RNODE_DEFS((yyval.node))->nd_defn = (yyvsp[0].node);
13383 #line 13384 "parse.c"
13387 #line 4079 "parse.y"
13389 (yyval.node) = (yyvsp[0].node);
13391 #line 13392 "parse.c"
13395 #line 4086 "parse.y"
13397 p->ctxt.in_rescue = (yyvsp[-1].ctxt).in_rescue;
13398 (yyval.node) = rescued_expr(p, (yyvsp[-3].node), (yyvsp[0].node), &(yylsp[-3]), &(yylsp[-2]), &(yylsp[0]));
13401 #line 13402 "parse.c"
13405 #line 4092 "parse.y"
13407 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[0].node), &(yylsp[0])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
13410 #line 13411 "parse.c"
13414 #line 4098 "parse.y"
13415 {(yyval.id) =
'>';}
13416 #line 13417 "parse.c"
13420 #line 4099 "parse.y"
13421 {(yyval.id) =
'<';}
13422 #line 13423 "parse.c"
13426 #line 4100 "parse.y"
13427 {(yyval.id) = idGE;}
13428 #line 13429 "parse.c"
13432 #line 4101 "parse.y"
13433 {(yyval.id) = idLE;}
13434 #line 13435 "parse.c"
13438 #line 4105 "parse.y"
13440 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13443 #line 13444 "parse.c"
13447 #line 4110 "parse.y"
13449 rb_warning1(
"comparison '%s' after comparison", WARN_ID((yyvsp[-1].
id)));
13450 (yyval.node) = call_bin_op(p, (yyvsp[-2].node), (yyvsp[-1].id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
13453 #line 13454 "parse.c"
13457 #line 4118 "parse.y"
13459 (yyval.ctxt) = p->ctxt;
13461 #line 13462 "parse.c"
13465 #line 4124 "parse.y"
13467 p->ctxt.in_defined = 1;
13468 (yyval.ctxt) = (yyvsp[0].ctxt);
13470 #line 13471 "parse.c"
13474 #line 4131 "parse.y"
13476 p->ctxt.in_rescue = after_rescue;
13477 (yyval.ctxt) = (yyvsp[0].ctxt);
13479 #line 13480 "parse.c"
13483 #line 4138 "parse.y"
13485 value_expr((yyvsp[0].node));
13486 (yyval.node) = (yyvsp[0].node);
13488 #line 13489 "parse.c"
13492 #line 4146 "parse.y"
13494 (yyval.node) = (yyvsp[-1].node);
13496 #line 13497 "parse.c"
13500 #line 4150 "parse.y"
13502 (yyval.node) = (yyvsp[-1].node) ? arg_append(p, (yyvsp[-3].node), new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].node);
13505 #line 13506 "parse.c"
13509 #line 4155 "parse.y"
13511 (yyval.node) = (yyvsp[-1].node) ? NEW_LIST(new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yyloc)) : 0;
13514 #line 13515 "parse.c"
13518 #line 4162 "parse.y"
13520 value_expr((yyvsp[0].node));
13521 (yyval.node) = (yyvsp[0].node);
13523 #line 13524 "parse.c"
13527 #line 4167 "parse.y"
13529 p->ctxt.in_rescue = (yyvsp[-1].ctxt).in_rescue;
13530 value_expr((yyvsp[-3].node));
13531 (yyval.node) = rescued_expr(p, (yyvsp[-3].node), (yyvsp[0].node), &(yylsp[-3]), &(yylsp[-2]), &(yylsp[0]));
13534 #line 13535 "parse.c"
13538 #line 4176 "parse.y"
13540 (yyval.node) = (yyvsp[-1].node);
13543 #line 13544 "parse.c"
13547 #line 4181 "parse.y"
13549 if (!check_forwarding_args(p)) {
13553 (yyval.node) = new_args_forward_call(p, (yyvsp[-3].node), &(yylsp[-1]), &(yyloc));
13557 #line 13558 "parse.c"
13561 #line 4191 "parse.y"
13563 if (!check_forwarding_args(p)) {
13567 (yyval.node) = new_args_forward_call(p, 0, &(yylsp[-1]), &(yyloc));
13571 #line 13572 "parse.c"
13575 #line 4204 "parse.y"
13577 (yyval.node) = (yyvsp[0].node) ? (yyvsp[0].node) : NODE_SPECIAL_EMPTY_ARGS;
13579 #line 13580 "parse.c"
13583 #line 4212 "parse.y"
13585 (yyval.node) = (yyvsp[-1].node);
13587 #line 13588 "parse.c"
13591 #line 4216 "parse.y"
13593 (yyval.node) = (yyvsp[-1].node) ? arg_append(p, (yyvsp[-3].node), new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].node);
13596 #line 13597 "parse.c"
13600 #line 4221 "parse.y"
13602 (yyval.node) = (yyvsp[-1].node) ? NEW_LIST(new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yylsp[-1])) : 0;
13605 #line 13606 "parse.c"
13609 #line 4228 "parse.y"
13611 value_expr((yyvsp[0].node));
13612 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
13615 #line 13616 "parse.c"
13619 #line 4234 "parse.y"
13621 (yyval.node) = arg_blk_pass((yyvsp[-1].node), (yyvsp[0].node_block_pass));
13624 #line 13625 "parse.c"
13628 #line 4239 "parse.y"
13630 (yyval.node) = (yyvsp[-1].node) ? NEW_LIST(new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yylsp[-1])) : 0;
13631 (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[0].node_block_pass));
13634 #line 13635 "parse.c"
13638 #line 4245 "parse.y"
13640 (yyval.node) = (yyvsp[-1].node) ? arg_append(p, (yyvsp[-3].node), new_hash(p, (yyvsp[-1].node), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].node);
13641 (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[0].node_block_pass));
13644 #line 13645 "parse.c"
13648 #line 4254 "parse.y"
13659 case '(':
case tLPAREN:
case tLPAREN_ARG:
case '[':
case tLBRACK:
13662 if (lookahead) CMDARG_POP();
13664 if (lookahead) CMDARG_PUSH(0);
13666 #line 13667 "parse.c"
13670 #line 4272 "parse.y"
13683 if (lookahead) CMDARG_POP();
13685 if (lookahead) CMDARG_PUSH(0);
13686 (yyval.node) = (yyvsp[0].node);
13689 #line 13690 "parse.c"
13693 #line 4293 "parse.y"
13695 (yyval.node_block_pass) = NEW_BLOCK_PASS((yyvsp[0].node), &(yyloc), &(yylsp[-1]));
13698 #line 13699 "parse.c"
13702 #line 4298 "parse.y"
13704 forwarding_arg_check(p, idFWD_BLOCK, idFWD_ALL,
"block");
13705 (yyval.node_block_pass) = NEW_BLOCK_PASS(NEW_LVAR(idFWD_BLOCK, &(yylsp[0])), &(yyloc), &(yylsp[0]));
13708 #line 13709 "parse.c"
13712 #line 4306 "parse.y"
13714 (yyval.node_block_pass) = (yyvsp[0].node_block_pass);
13717 #line 13718 "parse.c"
13721 #line 4311 "parse.y"
13723 (yyval.node_block_pass) = 0;
13726 #line 13727 "parse.c"
13730 #line 4319 "parse.y"
13732 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
13735 #line 13736 "parse.c"
13739 #line 4324 "parse.y"
13741 (yyval.node) = (yyvsp[0].node);
13744 #line 13745 "parse.c"
13748 #line 4329 "parse.y"
13750 (yyval.node) = last_arg_append(p, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
13753 #line 13754 "parse.c"
13757 #line 4334 "parse.y"
13759 (yyval.node) = rest_arg_append(p, (yyvsp[-2].node), RNODE_SPLAT((yyvsp[0].node))->nd_head, &(yyloc));
13762 #line 13763 "parse.c"
13766 #line 4342 "parse.y"
13768 (yyval.node) = NEW_SPLAT((yyvsp[0].node), &(yyloc), &(yylsp[-1]));
13771 #line 13772 "parse.c"
13775 #line 4347 "parse.y"
13777 forwarding_arg_check(p, idFWD_REST, idFWD_ALL,
"rest");
13778 (yyval.node) = NEW_SPLAT(NEW_LVAR(idFWD_REST, &(yylsp[0])), &(yyloc), &(yylsp[0]));
13781 #line 13782 "parse.c"
13785 #line 4361 "parse.y"
13787 (yyval.node) = last_arg_append(p, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
13790 #line 13791 "parse.c"
13794 #line 4366 "parse.y"
13796 (yyval.node) = rest_arg_append(p, (yyvsp[-3].node), (yyvsp[0].node), &(yyloc));
13799 #line 13800 "parse.c"
13803 #line 4371 "parse.y"
13805 (yyval.node) = NEW_SPLAT((yyvsp[0].node), &(yyloc), &(yylsp[-1]));
13808 #line 13809 "parse.c"
13812 #line 4392 "parse.y"
13814 (yyval.node) = (
NODE *)NEW_FCALL((yyvsp[0].
id), 0, &(yyloc));
13817 #line 13818 "parse.c"
13821 #line 4397 "parse.y"
13825 #line 13826 "parse.c"
13829 #line 4402 "parse.y"
13832 set_line_body((yyvsp[-1].node), (yylsp[-3]).end_pos.lineno);
13833 (yyval.node) = NEW_BEGIN((yyvsp[-1].node), &(yyloc));
13834 nd_set_line((yyval.node), (yylsp[-3]).end_pos.lineno);
13837 #line 13838 "parse.c"
13841 #line 4409 "parse.y"
13842 {SET_LEX_STATE(EXPR_ENDARG);}
13843 #line 13844 "parse.c"
13847 #line 4410 "parse.y"
13849 if (nd_type_p((yyvsp[-2].node), NODE_SELF)) RNODE_SELF((yyvsp[-2].node))->nd_state = 0;
13850 (yyval.node) = (yyvsp[-2].node);
13853 #line 13854 "parse.c"
13857 #line 4416 "parse.y"
13859 if (nd_type_p((yyvsp[-1].node), NODE_SELF)) RNODE_SELF((yyvsp[-1].node))->nd_state = 0;
13860 (yyval.node) = NEW_BLOCK((yyvsp[-1].node), &(yyloc));
13863 #line 13864 "parse.c"
13867 #line 4422 "parse.y"
13869 (yyval.node) = NEW_COLON2((yyvsp[-2].node), (yyvsp[0].id), &(yyloc));
13872 #line 13873 "parse.c"
13876 #line 4427 "parse.y"
13878 (yyval.node) = NEW_COLON3((yyvsp[0].
id), &(yyloc));
13881 #line 13882 "parse.c"
13885 #line 4432 "parse.y"
13887 (yyval.node) = make_list((yyvsp[-1].node), &(yyloc));
13890 #line 13891 "parse.c"
13894 #line 4437 "parse.y"
13896 (yyval.node) = new_hash(p, (yyvsp[-1].node), &(yyloc));
13897 RNODE_HASH((yyval.node))->nd_brace = TRUE;
13900 #line 13901 "parse.c"
13904 #line 4443 "parse.y"
13906 (yyval.node) = NEW_RETURN(0, &(yyloc), &(yylsp[0]));
13909 #line 13910 "parse.c"
13913 #line 4448 "parse.y"
13915 (yyval.node) = new_yield(p, (yyvsp[-1].node), &(yyloc));
13918 #line 13919 "parse.c"
13922 #line 4453 "parse.y"
13924 (yyval.node) = NEW_YIELD(0, &(yyloc));
13927 #line 13928 "parse.c"
13931 #line 4458 "parse.y"
13933 (yyval.node) = NEW_YIELD(0, &(yyloc));
13936 #line 13937 "parse.c"
13940 #line 4463 "parse.y"
13942 p->ctxt.in_defined = (yyvsp[-2].ctxt).in_defined;
13943 (yyval.node) = new_defined(p, (yyvsp[-1].node), &(yyloc));
13946 #line 13947 "parse.c"
13950 #line 4469 "parse.y"
13952 (yyval.node) = call_uni_op(p, method_cond(p, (yyvsp[-1].node), &(yylsp[-1])), METHOD_NOT, &(yylsp[-3]), &(yyloc));
13955 #line 13956 "parse.c"
13959 #line 4474 "parse.y"
13961 (yyval.node) = call_uni_op(p, method_cond(p, new_nil(&(yylsp[-1])), &(yylsp[-1])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
13964 #line 13965 "parse.c"
13968 #line 4479 "parse.y"
13970 (yyval.node) = method_add_block(p, (
NODE *)(yyvsp[-1].node_fcall), (yyvsp[0].node), &(yyloc));
13973 #line 13974 "parse.c"
13977 #line 4485 "parse.y"
13979 block_dup_check(p, get_nd_args(p, (yyvsp[-1].node)), (yyvsp[0].node));
13980 (yyval.node) = method_add_block(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
13983 #line 13984 "parse.c"
13987 #line 4495 "parse.y"
13989 (yyval.node) = new_if(p, (yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[-1].node), &(yyloc));
13990 fixpos((yyval.node), (yyvsp[-4].node));
13993 #line 13994 "parse.c"
13997 #line 4504 "parse.y"
13999 (yyval.node) = new_unless(p, (yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[-1].node), &(yyloc), &(yylsp[-5]), &(yylsp[-3]), &(yylsp[0]));
14000 fixpos((yyval.node), (yyvsp[-4].node));
14003 #line 14004 "parse.c"
14007 #line 4512 "parse.y"
14009 restore_block_exit(p, (yyvsp[-3].node_exits));
14010 (yyval.node) = NEW_WHILE(cond(p, (yyvsp[-2].node), &(yylsp[-2])), (yyvsp[-1].node), 1, &(yyloc), &(yylsp[-3]), &(yylsp[0]));
14011 fixpos((yyval.node), (yyvsp[-2].node));
14014 #line 14015 "parse.c"
14018 #line 4521 "parse.y"
14020 restore_block_exit(p, (yyvsp[-3].node_exits));
14021 (yyval.node) = NEW_UNTIL(cond(p, (yyvsp[-2].node), &(yylsp[-2])), (yyvsp[-1].node), 1, &(yyloc), &(yylsp[-3]), &(yylsp[0]));
14022 fixpos((yyval.node), (yyvsp[-2].node));
14025 #line 14026 "parse.c"
14029 #line 4528 "parse.y"
14031 (yyval.labels) = p->case_labels;
14032 p->case_labels = CHECK_LITERAL_WHEN;
14034 #line 14035 "parse.c"
14038 #line 4534 "parse.y"
14040 if (CASE_LABELS_ENABLED_P(p->case_labels)) st_free_table(p->case_labels);
14041 p->case_labels = (yyvsp[-2].labels);
14042 (yyval.node) = NEW_CASE((yyvsp[-4].node), (yyvsp[-1].node), &(yyloc), &(yylsp[-5]), &(yylsp[0]));
14043 fixpos((yyval.node), (yyvsp[-4].node));
14046 #line 14047 "parse.c"
14050 #line 4542 "parse.y"
14052 (yyval.labels) = p->case_labels;
14053 p->case_labels = 0;
14055 #line 14056 "parse.c"
14059 #line 4548 "parse.y"
14061 if (p->case_labels) st_free_table(p->case_labels);
14062 p->case_labels = (yyvsp[-2].labels);
14063 (yyval.node) = NEW_CASE2((yyvsp[-1].node), &(yyloc), &(yylsp[-4]), &(yylsp[0]));
14066 #line 14067 "parse.c"
14070 #line 4557 "parse.y"
14072 (yyval.node) = NEW_CASE3((yyvsp[-3].node), (yyvsp[-1].node), &(yyloc), &(yylsp[-4]), &(yylsp[0]));
14075 #line 14076 "parse.c"
14079 #line 4564 "parse.y"
14081 restore_block_exit(p, (yyvsp[-5].node_exits));
14091 ID id = internal_id(p);
14094 NODE *scope, *internal_var = NEW_DVAR(
id, &(yylsp[-4]));
14098 switch (nd_type((yyvsp[-4].node))) {
14101 set_nd_value(p, (yyvsp[-4].node), internal_var);
14104 m->nd_next = (yyvsp[-4].node);
14107 m->nd_next = node_assign(p, (yyvsp[-4].node), NEW_FOR_MASGN(internal_var, &(yylsp[-4])), NO_LEX_CTXT, &(yylsp[-4]));
14110 m->nd_next = node_assign(p, (
NODE *)NEW_MASGN(NEW_LIST((yyvsp[-4].node), &(yylsp[-4])), 0, &(yylsp[-4])), internal_var, NO_LEX_CTXT, &(yylsp[-4]));
14113 args = new_args(p, m, 0,
id, 0, new_args_tail(p, 0, 0, 0, &(yylsp[-4])), &(yylsp[-4]));
14114 scope = NEW_SCOPE2(tbl, args, (yyvsp[-1].node), &(yyloc));
14115 (yyval.node) = NEW_FOR((yyvsp[-2].node), scope, &(yyloc));
14116 fixpos((yyval.node), (yyvsp[-4].node));
14119 #line 14120 "parse.c"
14123 #line 4604 "parse.y"
14125 begin_definition(
"class", &(yylsp[-2]), &(yylsp[-1]));
14127 #line 14128 "parse.c"
14131 #line 4609 "parse.y"
14133 (yyval.node) = NEW_CLASS((yyvsp[-4].node), (yyvsp[-1].node), (yyvsp[-3].node), &(yyloc));
14134 nd_set_line(RNODE_CLASS((yyval.node))->nd_body, (yylsp[0]).end_pos.lineno);
14135 set_line_body((yyvsp[-1].node), (yylsp[-3]).end_pos.lineno);
14136 nd_set_line((yyval.node), (yylsp[-3]).end_pos.lineno);
14139 p->ctxt.in_class = (yyvsp[-5].ctxt).in_class;
14140 p->ctxt.cant_return = (yyvsp[-5].ctxt).cant_return;
14141 p->ctxt.shareable_constant_value = (yyvsp[-5].ctxt).shareable_constant_value;
14143 #line 14144 "parse.c"
14147 #line 4621 "parse.y"
14149 begin_definition(
"", &(yylsp[-2]), &(yylsp[-1]));
14151 #line 14152 "parse.c"
14155 #line 4627 "parse.y"
14157 (yyval.node) = NEW_SCLASS((yyvsp[-4].node), (yyvsp[-1].node), &(yyloc));
14158 nd_set_line(RNODE_SCLASS((yyval.node))->nd_body, (yylsp[0]).end_pos.lineno);
14159 set_line_body((yyvsp[-1].node), nd_line((yyvsp[-4].node)));
14160 fixpos((yyval.node), (yyvsp[-4].node));
14163 p->ctxt.in_def = (yyvsp[-6].ctxt).in_def;
14164 p->ctxt.in_class = (yyvsp[-6].ctxt).in_class;
14165 p->ctxt.cant_return = (yyvsp[-6].ctxt).cant_return;
14166 p->ctxt.shareable_constant_value = (yyvsp[-6].ctxt).shareable_constant_value;
14168 #line 14169 "parse.c"
14172 #line 4640 "parse.y"
14174 begin_definition(
"module", &(yylsp[-1]), &(yylsp[0]));
14176 #line 14177 "parse.c"
14180 #line 4645 "parse.y"
14182 (yyval.node) = NEW_MODULE((yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
14183 nd_set_line(RNODE_MODULE((yyval.node))->nd_body, (yylsp[0]).end_pos.lineno);
14184 set_line_body((yyvsp[-1].node), (yylsp[-3]).end_pos.lineno);
14185 nd_set_line((yyval.node), (yylsp[-3]).end_pos.lineno);
14188 p->ctxt.in_class = (yyvsp[-4].ctxt).in_class;
14189 p->ctxt.cant_return = (yyvsp[-4].ctxt).cant_return;
14190 p->ctxt.shareable_constant_value = (yyvsp[-4].ctxt).shareable_constant_value;
14192 #line 14193 "parse.c"
14196 #line 4658 "parse.y"
14198 push_end_expect_token_locations(p, &(yylsp[-1]).beg_pos);
14200 #line 14201 "parse.c"
14204 #line 4663 "parse.y"
14206 restore_defun(p, (yyvsp[-4].node_def_temp));
14207 (yyvsp[-1].node) = new_scope_body(p, (yyvsp[-3].node_args), (yyvsp[-1].node), &(yyloc));
14208 ((yyval.node) = (yyvsp[-4].node_def_temp)->nd_def)->nd_loc = (yyloc);
14209 RNODE_DEFN((yyval.node))->nd_defn = (yyvsp[-1].node);
14213 #line 14214 "parse.c"
14217 #line 4673 "parse.y"
14219 push_end_expect_token_locations(p, &(yylsp[-1]).beg_pos);
14221 #line 14222 "parse.c"
14225 #line 4678 "parse.y"
14227 restore_defun(p, (yyvsp[-4].node_def_temp));
14228 (yyvsp[-1].node) = new_scope_body(p, (yyvsp[-3].node_args), (yyvsp[-1].node), &(yyloc));
14229 ((yyval.node) = (yyvsp[-4].node_def_temp)->nd_def)->nd_loc = (yyloc);
14230 RNODE_DEFS((yyval.node))->nd_defn = (yyvsp[-1].node);
14234 #line 14235 "parse.c"
14238 #line 4687 "parse.y"
14240 (yyval.node) = add_block_exit(p, NEW_BREAK(0, &(yyloc), &(yylsp[0])));
14243 #line 14244 "parse.c"
14247 #line 4692 "parse.y"
14249 (yyval.node) = add_block_exit(p, NEW_NEXT(0, &(yyloc), &(yylsp[0])));
14252 #line 14253 "parse.c"
14256 #line 4697 "parse.y"
14258 (yyval.node) = add_block_exit(p, NEW_REDO(&(yyloc), &(yylsp[0])));
14261 #line 14262 "parse.c"
14265 #line 4702 "parse.y"
14267 if (!p->ctxt.in_defined) {
14268 switch (p->ctxt.in_rescue) {
14269 case before_rescue: yyerror1(&(yylsp[0]),
"Invalid retry without rescue");
break;
14270 case after_rescue:
break;
14271 case after_else: yyerror1(&(yylsp[0]),
"Invalid retry after else");
break;
14272 case after_ensure: yyerror1(&(yylsp[0]),
"Invalid retry after ensure");
break;
14275 (yyval.node) = NEW_RETRY(&(yyloc));
14278 #line 14279 "parse.c"
14282 #line 4717 "parse.y"
14284 value_expr((yyvsp[0].node));
14285 (yyval.node) = (yyvsp[0].node);
14287 #line 14288 "parse.c"
14291 #line 4724 "parse.y"
14293 token_info_push(p,
"begin", &(yyloc));
14294 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14296 #line 14297 "parse.c"
14300 #line 4731 "parse.y"
14303 token_info_push(p,
"if", &(yyloc));
14304 if (p->token_info && p->token_info->nonspc &&
14305 p->token_info->next && !strcmp(p->token_info->next->token,
"else")) {
14307 const char *beg = p->lex.pbeg + p->token_info->next->beg.column;
14309 while (beg < tok &&
ISSPACE(*beg)) beg++;
14311 p->token_info->nonspc = 0;
14314 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14316 #line 14317 "parse.c"
14320 #line 4749 "parse.y"
14322 token_info_push(p,
"unless", &(yyloc));
14323 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14325 #line 14326 "parse.c"
14329 #line 4756 "parse.y"
14331 (yyval.node_exits) = (yyvsp[0].node_exits);
14332 token_info_push(p,
"while", &(yyloc));
14333 push_end_expect_token_locations(p, &(yylsp[-1]).beg_pos);
14335 #line 14336 "parse.c"
14339 #line 4764 "parse.y"
14341 (yyval.node_exits) = (yyvsp[0].node_exits);
14342 token_info_push(p,
"until", &(yyloc));
14343 push_end_expect_token_locations(p, &(yylsp[-1]).beg_pos);
14345 #line 14346 "parse.c"
14349 #line 4772 "parse.y"
14351 token_info_push(p,
"case", &(yyloc));
14352 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14354 #line 14355 "parse.c"
14358 #line 4779 "parse.y"
14360 (yyval.node_exits) = (yyvsp[0].node_exits);
14361 token_info_push(p,
"for", &(yyloc));
14362 push_end_expect_token_locations(p, &(yylsp[-1]).beg_pos);
14364 #line 14365 "parse.c"
14368 #line 4787 "parse.y"
14370 token_info_push(p,
"class", &(yyloc));
14371 (yyval.ctxt) = p->ctxt;
14372 p->ctxt.in_rescue = before_rescue;
14373 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14375 #line 14376 "parse.c"
14379 #line 4796 "parse.y"
14381 token_info_push(p,
"module", &(yyloc));
14382 (yyval.ctxt) = p->ctxt;
14383 p->ctxt.in_rescue = before_rescue;
14384 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14386 #line 14387 "parse.c"
14390 #line 4805 "parse.y"
14392 token_info_push(p,
"def", &(yyloc));
14393 (yyval.node_def_temp) = NEW_DEF_TEMP(&(yyloc));
14394 p->ctxt.in_argdef = 1;
14396 #line 14397 "parse.c"
14400 #line 4813 "parse.y"
14402 token_info_push(p,
"do", &(yyloc));
14403 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14405 #line 14406 "parse.c"
14409 #line 4820 "parse.y"
14411 token_info_push(p,
"do", &(yyloc));
14412 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
14414 #line 14415 "parse.c"
14418 #line 4827 "parse.y"
14420 token_info_warn(p,
"rescue", p->token_info, 1, &(yyloc));
14421 (yyval.ctxt) = p->ctxt;
14422 p->ctxt.in_rescue = after_rescue;
14424 #line 14425 "parse.c"
14428 #line 4835 "parse.y"
14430 token_info_warn(p,
"ensure", p->token_info, 1, &(yyloc));
14431 (yyval.ctxt) = p->ctxt;
14433 #line 14434 "parse.c"
14437 #line 4842 "parse.y"
14439 token_info_warn(p,
"when", p->token_info, 0, &(yyloc));
14441 #line 14442 "parse.c"
14445 #line 4848 "parse.y"
14448 int same = ptinfo_beg && strcmp(ptinfo_beg->token,
"case") != 0;
14449 token_info_warn(p,
"else", p->token_info, same, &(yyloc));
14452 e.next = ptinfo_beg->next;
14454 token_info_setup(&e, p->lex.pbeg, &(yyloc));
14455 if (!e.nonspc) *ptinfo_beg = e;
14458 #line 14459 "parse.c"
14462 #line 4863 "parse.y"
14465 token_info_warn(p,
"elsif", p->token_info, 1, &(yyloc));
14467 #line 14468 "parse.c"
14471 #line 4870 "parse.y"
14473 token_info_pop(p,
"end", &(yyloc));
14474 pop_end_expect_token_locations(p);
14476 #line 14477 "parse.c"
14480 #line 4875 "parse.y"
14482 compile_error(p,
"syntax error, unexpected end-of-input");
14484 #line 14485 "parse.c"
14488 #line 4881 "parse.y"
14490 if (p->ctxt.cant_return && !dyna_in_block(p))
14491 yyerror1(&(yylsp[0]),
"Invalid return in class/module body");
14493 #line 14494 "parse.c"
14497 #line 4888 "parse.y"
14499 if (!p->ctxt.in_defined && !p->ctxt.in_def && !compile_for_eval)
14500 yyerror1(&(yylsp[0]),
"Invalid yield");
14502 #line 14503 "parse.c"
14506 #line 4907 "parse.y"
14508 (yyval.node) = new_if(p, (yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
14509 fixpos((yyval.node), (yyvsp[-3].node));
14512 #line 14513 "parse.c"
14516 #line 4916 "parse.y"
14518 (yyval.node) = (yyvsp[0].node);
14521 #line 14522 "parse.c"
14525 #line 4927 "parse.y"
14527 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
14528 mark_lvar_used(p, (yyval.node));
14530 #line 14531 "parse.c"
14534 #line 4932 "parse.y"
14536 (yyval.node) = (
NODE *)(yyvsp[-1].node_masgn);
14539 #line 14540 "parse.c"
14543 #line 4939 "parse.y"
14545 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
14548 #line 14549 "parse.c"
14552 #line 4944 "parse.y"
14554 (yyval.node) = list_append(p, (yyvsp[-2].node), (yyvsp[0].node));
14557 #line 14558 "parse.c"
14561 #line 4951 "parse.y"
14563 (yyval.node_masgn) = NEW_MASGN((yyvsp[0].node), 0, &(yyloc));
14566 #line 14567 "parse.c"
14570 #line 4956 "parse.y"
14572 (yyval.node_masgn) = NEW_MASGN((yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
14575 #line 14576 "parse.c"
14579 #line 4961 "parse.y"
14581 (yyval.node_masgn) = NEW_MASGN((yyvsp[-4].node), NEW_POSTARG((yyvsp[-2].node), (yyvsp[0].node), &(yyloc)), &(yyloc));
14584 #line 14585 "parse.c"
14588 #line 4966 "parse.y"
14590 (yyval.node_masgn) = NEW_MASGN(0, (yyvsp[0].node), &(yyloc));
14593 #line 14594 "parse.c"
14597 #line 4971 "parse.y"
14599 (yyval.node_masgn) = NEW_MASGN(0, NEW_POSTARG((yyvsp[-2].node), (yyvsp[0].node), &(yyloc)), &(yyloc));
14602 #line 14603 "parse.c"
14606 #line 4978 "parse.y"
14609 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
14610 mark_lvar_used(p, (yyval.node));
14612 #line 14613 "parse.c"
14616 #line 4984 "parse.y"
14618 (yyval.node) = NODE_SPECIAL_NO_NAME_REST;
14621 #line 14622 "parse.c"
14625 #line 4992 "parse.y"
14627 (yyval.id) = idNil;
14630 #line 14631 "parse.c"
14634 #line 4998 "parse.y"
14635 {p->ctxt.in_argdef = 0;}
14636 #line 14637 "parse.c"
14640 #line 2938 "parse.y"
14642 (yyval.node_kw_arg) = (yyvsp[0].node_kw_arg);
14645 #line 14646 "parse.c"
14649 #line 2943 "parse.y"
14651 (yyval.node_kw_arg) = kwd_append((yyvsp[-2].node_kw_arg), (yyvsp[0].node_kw_arg));
14654 #line 14655 "parse.c"
14658 #line 5001 "parse.y"
14660 (yyval.node_args) = new_args_tail(p, (yyvsp[-3].node_kw_arg), (yyvsp[-1].id), (yyvsp[0].
id), &(yylsp[-1]));
14663 #line 14664 "parse.c"
14667 #line 5006 "parse.y"
14669 (yyval.node_args) = new_args_tail(p, (yyvsp[-1].node_kw_arg), 0, (yyvsp[0].id), &(yylsp[-1]));
14672 #line 14673 "parse.c"
14676 #line 5011 "parse.y"
14678 (yyval.node_args) = new_args_tail(p, 0, (yyvsp[-1].
id), (yyvsp[0].id), &(yylsp[-1]));
14681 #line 14682 "parse.c"
14685 #line 5016 "parse.y"
14687 (yyval.node_args) = new_args_tail(p, 0, 0, (yyvsp[0].
id), &(yylsp[0]));
14690 #line 14691 "parse.c"
14694 #line 5023 "parse.y"
14697 (yyval.id) = NODE_SPECIAL_EXCESSIVE_COMMA;
14700 #line 14701 "parse.c"
14704 #line 2916 "parse.y"
14706 p->ctxt.in_argdef = 1;
14707 (yyval.node_opt_arg) = NEW_OPT_ARG(assignable(p, (yyvsp[-2].
id), (yyvsp[0].node), &(yyloc)), &(yyloc));
14710 #line 14711 "parse.c"
14714 #line 2925 "parse.y"
14716 (yyval.node_opt_arg) = (yyvsp[0].node_opt_arg);
14719 #line 14720 "parse.c"
14723 #line 2930 "parse.y"
14725 (yyval.node_opt_arg) = opt_arg_append((yyvsp[-2].node_opt_arg), (yyvsp[0].node_opt_arg));
14728 #line 14729 "parse.c"
14732 #line 2951 "parse.y"
14734 (yyval.node_args) = (yyvsp[0].node_args);
14737 #line 14738 "parse.c"
14741 #line 2956 "parse.y"
14743 (yyval.node_args) = new_args_tail(p, 0, 0, 0, &(yylsp[0]));
14746 #line 14747 "parse.c"
14750 #line 5031 "parse.y"
14752 (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));
14755 #line 14756 "parse.c"
14759 #line 5036 "parse.y"
14761 (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));
14764 #line 14765 "parse.c"
14768 #line 5041 "parse.y"
14770 (yyval.node_args) = new_args(p, (yyvsp[-3].node_args_aux), (yyvsp[-1].node_opt_arg), 0, 0, (yyvsp[0].node_args), &(yyloc));
14773 #line 14774 "parse.c"
14777 #line 5046 "parse.y"
14779 (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));
14782 #line 14783 "parse.c"
14786 #line 5051 "parse.y"
14788 (yyval.node_args) = new_args(p, (yyvsp[-3].node_args_aux), 0, (yyvsp[-1].id), 0, (yyvsp[0].node_args), &(yyloc));
14791 #line 14792 "parse.c"
14795 #line 5056 "parse.y"
14797 (yyval.node_args) = new_args_tail(p, 0, 0, 0, &(yylsp[0]));
14798 (yyval.node_args) = new_args(p, (yyvsp[-1].node_args_aux), 0, (yyvsp[0].id), 0, (yyval.node_args), &(yyloc));
14801 #line 14802 "parse.c"
14805 #line 5062 "parse.y"
14807 (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));
14810 #line 14811 "parse.c"
14814 #line 5067 "parse.y"
14816 (yyval.node_args) = new_args(p, (yyvsp[-1].node_args_aux), 0, 0, 0, (yyvsp[0].node_args), &(yyloc));
14819 #line 14820 "parse.c"
14823 #line 5072 "parse.y"
14825 (yyval.node_args) = new_args(p, 0, (yyvsp[-3].node_opt_arg), (yyvsp[-1].id), 0, (yyvsp[0].node_args), &(yyloc));
14828 #line 14829 "parse.c"
14832 #line 5077 "parse.y"
14834 (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));
14837 #line 14838 "parse.c"
14841 #line 5082 "parse.y"
14843 (yyval.node_args) = new_args(p, 0, (yyvsp[-1].node_opt_arg), 0, 0, (yyvsp[0].node_args), &(yyloc));
14846 #line 14847 "parse.c"
14850 #line 5087 "parse.y"
14852 (yyval.node_args) = new_args(p, 0, (yyvsp[-3].node_opt_arg), 0, (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
14855 #line 14856 "parse.c"
14859 #line 5092 "parse.y"
14861 (yyval.node_args) = new_args(p, 0, 0, (yyvsp[-1].
id), 0, (yyvsp[0].node_args), &(yyloc));
14864 #line 14865 "parse.c"
14868 #line 5097 "parse.y"
14870 (yyval.node_args) = new_args(p, 0, 0, (yyvsp[-3].
id), (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
14873 #line 14874 "parse.c"
14877 #line 5102 "parse.y"
14879 (yyval.node_args) = new_args(p, 0, 0, 0, 0, (yyvsp[0].node_args), &(yyloc));
14882 #line 14883 "parse.c"
14886 #line 5110 "parse.y"
14888 p->command_start = TRUE;
14890 #line 14891 "parse.c"
14894 #line 5116 "parse.y"
14896 p->max_numparam = ORDINAL_PARAM;
14897 p->ctxt.in_argdef = 0;
14898 (yyval.node_args) = 0;
14901 #line 14902 "parse.c"
14905 #line 5123 "parse.y"
14907 p->max_numparam = ORDINAL_PARAM;
14908 p->ctxt.in_argdef = 0;
14909 (yyval.node_args) = (yyvsp[-2].node_args);
14912 #line 14913 "parse.c"
14916 #line 5133 "parse.y"
14921 #line 14922 "parse.c"
14925 #line 5138 "parse.y"
14930 #line 14931 "parse.c"
14934 #line 5151 "parse.y"
14936 new_bv(p, (yyvsp[0].
id));
14939 #line 14940 "parse.c"
14943 #line 5156 "parse.y"
14947 #line 14948 "parse.c"
14951 #line 5161 "parse.y"
14953 (yyval.num) = p->max_numparam;
14954 p->max_numparam = 0;
14956 #line 14957 "parse.c"
14960 #line 5167 "parse.y"
14962 (yyval.node) = numparam_push(p);
14964 #line 14965 "parse.c"
14968 #line 5172 "parse.y"
14970 (yyval.id) = p->it_id;
14973 #line 14974 "parse.c"
14977 #line 5179 "parse.y"
14979 token_info_push(p,
"->", &(yylsp[0]));
14980 (yyval.vars) = dyna_push(p);
14982 #line 14983 "parse.c"
14986 #line 5185 "parse.y"
14990 #line 14991 "parse.c"
14994 #line 5189 "parse.y"
14996 int max_numparam = p->max_numparam;
14997 ID it_id = p->it_id;
14998 p->lex.lpar_beg = (yyvsp[-8].num);
14999 p->max_numparam = (yyvsp[-6].num);
15000 p->it_id = (yyvsp[-4].id);
15001 restore_block_exit(p, (yyvsp[-3].node_exits));
15003 (yyvsp[-2].node_args) = args_with_numbered(p, (yyvsp[-2].node_args), max_numparam, it_id);
15005 YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
15006 (yyval.node) = NEW_LAMBDA((yyvsp[-2].node_args), (yyvsp[0].node), &loc);
15007 nd_set_line(RNODE_LAMBDA((yyval.node))->nd_body, (yylsp[0]).end_pos.lineno);
15008 nd_set_line((yyval.node), (yylsp[-2]).end_pos.lineno);
15009 nd_set_first_loc((yyval.node), (yylsp[-8]).beg_pos);
15012 numparam_pop(p, (yyvsp[-5].node));
15013 dyna_pop(p, (yyvsp[-7].vars));
15015 #line 15016 "parse.c"
15019 #line 5212 "parse.y"
15021 p->ctxt.in_argdef = 0;
15022 (yyval.node_args) = (yyvsp[-2].node_args);
15023 p->max_numparam = ORDINAL_PARAM;
15026 #line 15027 "parse.c"
15030 #line 5219 "parse.y"
15032 p->ctxt.in_argdef = 0;
15033 if (!args_info_empty_p(&(yyvsp[0].node_args)->nd_ainfo))
15034 p->max_numparam = ORDINAL_PARAM;
15035 (yyval.node_args) = (yyvsp[0].node_args);
15037 #line 15038 "parse.c"
15041 #line 5228 "parse.y"
15043 token_info_pop(p,
"}", &(yylsp[0]));
15044 (yyval.node) = (yyvsp[-1].node);
15047 #line 15048 "parse.c"
15051 #line 5234 "parse.y"
15053 push_end_expect_token_locations(p, &(yylsp[0]).beg_pos);
15055 #line 15056 "parse.c"
15059 #line 5238 "parse.y"
15061 (yyval.node) = (yyvsp[-1].node);
15064 #line 15065 "parse.c"
15068 #line 5245 "parse.y"
15070 (yyval.node) = (yyvsp[-1].node);
15071 set_embraced_location((yyval.node), &(yylsp[-2]), &(yylsp[0]));
15074 #line 15075 "parse.c"
15078 #line 5253 "parse.y"
15080 if (nd_type_p((yyvsp[-1].node), NODE_YIELD)) {
15081 compile_error(p,
"block given to yield");
15084 block_dup_check(p, get_nd_args(p, (yyvsp[-1].node)), (yyvsp[0].node));
15086 (yyval.node) = method_add_block(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
15087 fixpos((yyval.node), (yyvsp[-1].node));
15090 #line 15091 "parse.c"
15094 #line 5265 "parse.y"
15096 bool has_args = (yyvsp[0].node) != 0;
15097 if (NODE_EMPTY_ARGS_P((yyvsp[0].node))) (yyvsp[0].node) = 0;
15098 (yyval.node) = new_qcall(p, (yyvsp[-2].
id), (yyvsp[-3].node), (yyvsp[-1].
id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
15104 #line 15105 "parse.c"
15108 #line 5275 "parse.y"
15110 if (NODE_EMPTY_ARGS_P((yyvsp[-1].node))) (yyvsp[-1].node) = 0;
15111 (yyval.node) = new_command_qcall(p, (yyvsp[-3].
id), (yyvsp[-4].node), (yyvsp[-2].
id), (yyvsp[-1].node), (yyvsp[0].node), &(yylsp[-2]), &(yyloc));
15113 if ((yyvsp[0].node)) {
15117 #line 15118 "parse.c"
15121 #line 5284 "parse.y"
15123 (yyval.node) = new_command_qcall(p, (yyvsp[-3].
id), (yyvsp[-4].node), (yyvsp[-2].
id), (yyvsp[-1].node), (yyvsp[0].node), &(yylsp[-2]), &(yyloc));
15126 #line 15127 "parse.c"
15130 #line 5291 "parse.y"
15132 (yyvsp[-1].node_fcall)->nd_args = (yyvsp[0].node);
15133 (yyval.node) = (
NODE *)(yyvsp[-1].node_fcall);
15134 nd_set_last_loc((yyvsp[-1].node_fcall), (yylsp[0]).end_pos);
15137 #line 15138 "parse.c"
15141 #line 5298 "parse.y"
15143 bool has_args = (yyvsp[0].node) != 0;
15144 if (NODE_EMPTY_ARGS_P((yyvsp[0].node))) (yyvsp[0].node) = 0;
15145 (yyval.node) = new_qcall(p, (yyvsp[-2].
id), (yyvsp[-3].node), (yyvsp[-1].
id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
15146 nd_set_line((yyval.node), (yylsp[-1]).end_pos.lineno);
15152 #line 15153 "parse.c"
15156 #line 5309 "parse.y"
15158 (yyval.node) = new_qcall(p, idCOLON2, (yyvsp[-3].node), (yyvsp[-1].id), (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
15159 nd_set_line((yyval.node), (yylsp[-1]).end_pos.lineno);
15162 #line 15163 "parse.c"
15166 #line 5315 "parse.y"
15168 (yyval.node) = new_qcall(p, idCOLON2, (yyvsp[-2].node), (yyvsp[0].id), 0, &(yylsp[0]), &(yyloc));
15171 #line 15172 "parse.c"
15175 #line 5320 "parse.y"
15177 (yyval.node) = new_qcall(p, (yyvsp[-1].
id), (yyvsp[-2].node), idCall, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
15178 nd_set_line((yyval.node), (yylsp[-1]).end_pos.lineno);
15181 #line 15182 "parse.c"
15185 #line 5326 "parse.y"
15187 (yyval.node) = new_qcall(p, idCOLON2, (yyvsp[-2].node), idCall, (yyvsp[0].node), &(yylsp[-1]), &(yyloc));
15188 nd_set_line((yyval.node), (yylsp[-1]).end_pos.lineno);
15191 #line 15192 "parse.c"
15195 #line 5332 "parse.y"
15197 (yyval.node) = NEW_SUPER((yyvsp[0].node), &(yyloc));
15200 #line 15201 "parse.c"
15204 #line 5337 "parse.y"
15206 (yyval.node) = NEW_ZSUPER(&(yyloc));
15209 #line 15210 "parse.c"
15213 #line 5342 "parse.y"
15215 (yyval.node) = NEW_CALL((yyvsp[-3].node), tAREF, (yyvsp[-1].node), &(yyloc));
15216 fixpos((yyval.node), (yyvsp[-3].node));
15219 #line 15220 "parse.c"
15223 #line 5350 "parse.y"
15225 (yyval.node) = (yyvsp[-1].node);
15226 set_embraced_location((yyval.node), &(yylsp[-2]), &(yylsp[0]));
15229 #line 15230 "parse.c"
15233 #line 5356 "parse.y"
15235 (yyval.node) = (yyvsp[-1].node);
15236 set_embraced_location((yyval.node), &(yylsp[-2]), &(yylsp[0]));
15239 #line 15240 "parse.c"
15243 #line 5363 "parse.y"
15244 {(yyval.vars) = dyna_push(p);}
15245 #line 15246 "parse.c"
15249 #line 5366 "parse.y"
15251 int max_numparam = p->max_numparam;
15252 ID it_id = p->it_id;
15253 p->max_numparam = (yyvsp[-5].num);
15254 p->it_id = (yyvsp[-3].id);
15255 (yyvsp[-1].node_args) = args_with_numbered(p, (yyvsp[-1].node_args), max_numparam, it_id);
15256 (yyval.node) = NEW_ITER((yyvsp[-1].node_args), (yyvsp[0].node), &(yyloc));
15258 restore_block_exit(p, (yyvsp[-2].node_exits));
15259 numparam_pop(p, (yyvsp[-4].node));
15260 dyna_pop(p, (yyvsp[-6].vars));
15262 #line 15263 "parse.c"
15266 #line 5380 "parse.y"
15268 (yyval.vars) = dyna_push(p);
15271 #line 15272 "parse.c"
15275 #line 5386 "parse.y"
15277 int max_numparam = p->max_numparam;
15278 ID it_id = p->it_id;
15279 p->max_numparam = (yyvsp[-5].num);
15280 p->it_id = (yyvsp[-3].id);
15281 (yyvsp[-1].node_args) = args_with_numbered(p, (yyvsp[-1].node_args), max_numparam, it_id);
15282 (yyval.node) = NEW_ITER((yyvsp[-1].node_args), (yyvsp[0].node), &(yyloc));
15285 restore_block_exit(p, (yyvsp[-2].node_exits));
15286 numparam_pop(p, (yyvsp[-4].node));
15287 dyna_pop(p, (yyvsp[-6].vars));
15289 #line 15290 "parse.c"
15293 #line 5402 "parse.y"
15295 check_literal_when(p, (yyvsp[0].node), &(yylsp[0]));
15296 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
15299 #line 15300 "parse.c"
15303 #line 5408 "parse.y"
15305 (yyval.node) = NEW_SPLAT((yyvsp[0].node), &(yyloc), &(yylsp[-1]));
15308 #line 15309 "parse.c"
15312 #line 5413 "parse.y"
15314 check_literal_when(p, (yyvsp[0].node), &(yylsp[0]));
15315 (yyval.node) = last_arg_append(p, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
15318 #line 15319 "parse.c"
15322 #line 5419 "parse.y"
15324 (yyval.node) = rest_arg_append(p, (yyvsp[-3].node), (yyvsp[0].node), &(yyloc));
15327 #line 15328 "parse.c"
15331 #line 5428 "parse.y"
15333 (yyval.node) = NEW_WHEN((yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node), &(yyloc), &(yylsp[-4]), &(yylsp[-2]));
15334 fixpos((yyval.node), (yyvsp[-3].node));
15337 #line 15338 "parse.c"
15341 #line 5439 "parse.y"
15342 {(yyval.tbl) = p->pvtbl; p->pvtbl = st_init_numtable();}
15343 #line 15344 "parse.c"
15347 #line 5440 "parse.y"
15348 {(yyval.tbl) = p->pktbl; p->pktbl = 0;}
15349 #line 15350 "parse.c"
15353 #line 5442 "parse.y"
15355 (yyval.ctxt) = p->ctxt;
15356 SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
15357 p->command_start = FALSE;
15358 p->ctxt.in_kwarg = 1;
15360 #line 15361 "parse.c"
15364 #line 5453 "parse.y"
15366 pop_pktbl(p, (yyvsp[-2].tbl));
15367 pop_pvtbl(p, (yyvsp[-3].tbl));
15368 p->ctxt.in_kwarg = (yyvsp[-4].ctxt).in_kwarg;
15370 #line 15371 "parse.c"
15374 #line 5460 "parse.y"
15376 (yyval.node) = NEW_IN((yyvsp[-4].node), (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
15379 #line 15380 "parse.c"
15383 #line 5472 "parse.y"
15385 (yyval.node) = new_if(p, (yyvsp[0].node), (yyvsp[-2].node), 0, &(yyloc));
15386 fixpos((yyval.node), (yyvsp[0].node));
15389 #line 15390 "parse.c"
15393 #line 5478 "parse.y"
15395 (yyval.node) = new_unless(p, (yyvsp[0].node), (yyvsp[-2].node), 0, &(yyloc), &(yylsp[-1]), &NULL_LOC, &NULL_LOC);
15396 fixpos((yyval.node), (yyvsp[0].node));
15399 #line 15400 "parse.c"
15403 #line 5487 "parse.y"
15405 (yyval.node) = new_array_pattern_tail(p, 0, 1, 0, 0, &(yyloc));
15406 (yyval.node) = new_array_pattern(p, 0, (yyvsp[-1].node), (yyval.node), &(yyloc));
15409 #line 15410 "parse.c"
15413 #line 5493 "parse.y"
15415 (yyval.node) = new_array_pattern(p, 0, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
15416 nd_set_first_loc((yyval.node), (yylsp[-2]).beg_pos);
15419 #line 15420 "parse.c"
15423 #line 5499 "parse.y"
15425 (yyval.node) = new_find_pattern(p, 0, (yyvsp[0].node), &(yyloc));
15428 #line 15429 "parse.c"
15432 #line 5504 "parse.y"
15434 (yyval.node) = new_array_pattern(p, 0, 0, (yyvsp[0].node), &(yyloc));
15437 #line 15438 "parse.c"
15441 #line 5509 "parse.y"
15443 (yyval.node) = new_hash_pattern(p, 0, (yyvsp[0].node), &(yyloc));
15446 #line 15447 "parse.c"
15450 #line 5519 "parse.y"
15452 NODE *n = NEW_LIST((yyvsp[-2].node), &(yyloc));
15453 n = list_append(p, n, (yyvsp[0].node));
15454 (yyval.node) = new_hash(p, n, &(yyloc));
15457 #line 15458 "parse.c"
15461 #line 5529 "parse.y"
15463 (yyval.node) = NEW_OR((yyvsp[-2].node), (yyvsp[0].node), &(yyloc), &(yylsp[-1]));
15466 #line 15467 "parse.c"
15470 #line 5537 "parse.y"
15472 (yyval.tbl) = (yyvsp[0].tbl);
15475 #line 15476 "parse.c"
15479 #line 5544 "parse.y"
15481 (yyval.tbl) = (yyvsp[0].tbl);
15484 #line 15485 "parse.c"
15488 #line 5553 "parse.y"
15490 pop_pktbl(p, (yyvsp[-2].tbl));
15491 (yyval.node) = new_array_pattern(p, (yyvsp[-3].node), 0, (yyvsp[-1].node), &(yyloc));
15492 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
15495 #line 15496 "parse.c"
15499 #line 5560 "parse.y"
15501 pop_pktbl(p, (yyvsp[-2].tbl));
15502 (yyval.node) = new_find_pattern(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
15503 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
15506 #line 15507 "parse.c"
15510 #line 5567 "parse.y"
15512 pop_pktbl(p, (yyvsp[-2].tbl));
15513 (yyval.node) = new_hash_pattern(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
15514 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
15517 #line 15518 "parse.c"
15521 #line 5574 "parse.y"
15523 (yyval.node) = new_array_pattern_tail(p, 0, 0, 0, 0, &(yyloc));
15524 (yyval.node) = new_array_pattern(p, (yyvsp[-2].node), 0, (yyval.node), &(yyloc));
15527 #line 15528 "parse.c"
15531 #line 5580 "parse.y"
15533 pop_pktbl(p, (yyvsp[-2].tbl));
15534 (yyval.node) = new_array_pattern(p, (yyvsp[-3].node), 0, (yyvsp[-1].node), &(yyloc));
15535 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
15538 #line 15539 "parse.c"
15542 #line 5587 "parse.y"
15544 pop_pktbl(p, (yyvsp[-2].tbl));
15545 (yyval.node) = new_find_pattern(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
15546 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
15549 #line 15550 "parse.c"
15553 #line 5594 "parse.y"
15555 pop_pktbl(p, (yyvsp[-2].tbl));
15556 (yyval.node) = new_hash_pattern(p, (yyvsp[-3].node), (yyvsp[-1].node), &(yyloc));
15557 nd_set_first_loc((yyval.node), (yylsp[-3]).beg_pos);
15560 #line 15561 "parse.c"
15564 #line 5601 "parse.y"
15566 (yyval.node) = new_array_pattern_tail(p, 0, 0, 0, 0, &(yyloc));
15567 (yyval.node) = new_array_pattern(p, (yyvsp[-2].node), 0, (yyval.node), &(yyloc));
15570 #line 15571 "parse.c"
15574 #line 5607 "parse.y"
15576 (yyval.node) = new_array_pattern(p, 0, 0, (yyvsp[-1].node), &(yyloc));
15579 #line 15580 "parse.c"
15583 #line 5612 "parse.y"
15585 (yyval.node) = new_find_pattern(p, 0, (yyvsp[-1].node), &(yyloc));
15588 #line 15589 "parse.c"
15592 #line 5617 "parse.y"
15594 (yyval.node) = new_array_pattern_tail(p, 0, 0, 0, 0, &(yyloc));
15595 (yyval.node) = new_array_pattern(p, 0, 0, (yyval.node), &(yyloc));
15598 #line 15599 "parse.c"
15602 #line 5623 "parse.y"
15604 p->ctxt.in_kwarg = 0;
15606 #line 15607 "parse.c"
15610 #line 5627 "parse.y"
15612 pop_pktbl(p, (yyvsp[-4].tbl));
15613 p->ctxt.in_kwarg = (yyvsp[-3].ctxt).in_kwarg;
15614 (yyval.node) = new_hash_pattern(p, 0, (yyvsp[-1].node), &(yyloc));
15617 #line 15618 "parse.c"
15621 #line 5634 "parse.y"
15623 (yyval.node) = new_hash_pattern_tail(p, 0, 0, &(yyloc));
15624 (yyval.node) = new_hash_pattern(p, 0, (yyval.node), &(yyloc));
15627 #line 15628 "parse.c"
15631 #line 5640 "parse.y"
15633 pop_pktbl(p, (yyvsp[-2].tbl));
15634 (yyval.node) = (yyvsp[-1].node);
15637 #line 15638 "parse.c"
15641 #line 5648 "parse.y"
15643 NODE *pre_args = NEW_LIST((yyvsp[0].node), &(yyloc));
15644 (yyval.node) = new_array_pattern_tail(p, pre_args, 0, 0, 0, &(yyloc));
15647 #line 15648 "parse.c"
15651 #line 5654 "parse.y"
15653 (yyval.node) = new_array_pattern_tail(p, (yyvsp[0].node), 1, 0, 0, &(yyloc));
15656 #line 15657 "parse.c"
15660 #line 5659 "parse.y"
15662 (yyval.node) = new_array_pattern_tail(p, list_concat((yyvsp[-1].node), (yyvsp[0].node)), 0, 0, 0, &(yyloc));
15665 #line 15666 "parse.c"
15669 #line 5664 "parse.y"
15671 (yyval.node) = new_array_pattern_tail(p, (yyvsp[-1].node), 1, (yyvsp[0].node), 0, &(yyloc));
15674 #line 15675 "parse.c"
15678 #line 5669 "parse.y"
15680 (yyval.node) = new_array_pattern_tail(p, (yyvsp[-3].node), 1, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
15683 #line 15684 "parse.c"
15687 #line 5677 "parse.y"
15689 (yyval.node) = (yyvsp[-1].node);
15691 #line 15692 "parse.c"
15695 #line 5681 "parse.y"
15697 (yyval.node) = list_concat((yyvsp[-2].node), (yyvsp[-1].node));
15700 #line 15701 "parse.c"
15704 #line 5688 "parse.y"
15706 (yyval.node) = new_array_pattern_tail(p, 0, 1, (yyvsp[0].node), 0, &(yyloc));
15709 #line 15710 "parse.c"
15713 #line 5693 "parse.y"
15715 (yyval.node) = new_array_pattern_tail(p, 0, 1, (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
15718 #line 15719 "parse.c"
15722 #line 5700 "parse.y"
15724 (yyval.node) = new_find_pattern_tail(p, (yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
15727 #line 15728 "parse.c"
15731 #line 5708 "parse.y"
15733 error_duplicate_pattern_variable(p, (yyvsp[0].
id), &(yylsp[0]));
15735 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
15737 #line 15738 "parse.c"
15741 #line 5714 "parse.y"
15746 #line 15747 "parse.c"
15750 #line 5722 "parse.y"
15752 (yyval.node) = list_concat((yyvsp[-2].node), (yyvsp[0].node));
15755 #line 15756 "parse.c"
15759 #line 5729 "parse.y"
15761 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
15764 #line 15765 "parse.c"
15768 #line 5736 "parse.y"
15770 (yyval.node) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-2].node), &(yyloc)), (yyvsp[0].id), &(yyloc));
15773 #line 15774 "parse.c"
15777 #line 5741 "parse.y"
15779 (yyval.node) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[0].node), &(yyloc)), 0, &(yyloc));
15782 #line 15783 "parse.c"
15786 #line 5746 "parse.y"
15788 (yyval.node) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-1].node), &(yyloc)), 0, &(yyloc));
15791 #line 15792 "parse.c"
15795 #line 5751 "parse.y"
15797 (yyval.node) = new_hash_pattern_tail(p, new_hash(p, 0, &(yyloc)), (yyvsp[0].
id), &(yyloc));
15800 #line 15801 "parse.c"
15804 #line 5760 "parse.y"
15806 (yyval.node) = list_concat((yyvsp[-2].node), (yyvsp[0].node));
15809 #line 15810 "parse.c"
15813 #line 5767 "parse.y"
15815 error_duplicate_pattern_key(p, (yyvsp[-1].
id), &(yylsp[-1]));
15816 (yyval.node) = list_append(p, NEW_LIST(NEW_SYM(
rb_id2str((yyvsp[-1].
id)), &(yylsp[-1])), &(yyloc)), (yyvsp[0].node));
15819 #line 15820 "parse.c"
15823 #line 5773 "parse.y"
15825 error_duplicate_pattern_key(p, (yyvsp[0].
id), &(yylsp[0]));
15826 if ((yyvsp[0].
id) && !is_local_id((yyvsp[0].
id))) {
15827 yyerror1(&(yylsp[0]),
"key must be valid as local variables");
15829 error_duplicate_pattern_variable(p, (yyvsp[0].
id), &(yylsp[0]));
15830 (yyval.node) = list_append(p, NEW_LIST(NEW_SYM(
rb_id2str((yyvsp[0].
id)), &(yyloc)), &(yyloc)), assignable(p, (yyvsp[0].
id), 0, &(yyloc)));
15833 #line 15834 "parse.c"
15837 #line 5786 "parse.y"
15839 YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
15840 if (!(yyvsp[-1].node) || nd_type_p((yyvsp[-1].node), NODE_STR)) {
15841 NODE *node = dsym_node(p, (yyvsp[-1].node), &loc);
15842 (yyval.id) =
rb_sym2id(rb_node_sym_string_val(node));
15845 yyerror1(&loc,
"symbol literal with interpolation is not allowed");
15850 #line 15851 "parse.c"
15854 #line 5801 "parse.y"
15856 (yyval.id) = (yyvsp[0].
id);
15859 #line 15860 "parse.c"
15863 #line 5806 "parse.y"
15868 #line 15869 "parse.c"
15872 #line 5813 "parse.y"
15876 #line 15877 "parse.c"
15880 #line 5820 "parse.y"
15882 (yyval.id) = idNil;
15885 #line 15886 "parse.c"
15889 #line 5828 "parse.y"
15891 value_expr((yyvsp[-2].node));
15892 value_expr((yyvsp[0].node));
15893 (yyval.node) = NEW_DOT2((yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
15896 #line 15897 "parse.c"
15900 #line 5835 "parse.y"
15902 value_expr((yyvsp[-2].node));
15903 value_expr((yyvsp[0].node));
15904 (yyval.node) = NEW_DOT3((yyvsp[-2].node), (yyvsp[0].node), &(yyloc));
15907 #line 15908 "parse.c"
15911 #line 5842 "parse.y"
15913 value_expr((yyvsp[-1].node));
15914 (yyval.node) = NEW_DOT2((yyvsp[-1].node), new_nil_at(p, &(yylsp[0]).end_pos), &(yyloc));
15917 #line 15918 "parse.c"
15921 #line 5848 "parse.y"
15923 value_expr((yyvsp[-1].node));
15924 (yyval.node) = NEW_DOT3((yyvsp[-1].node), new_nil_at(p, &(yylsp[0]).end_pos), &(yyloc));
15927 #line 15928 "parse.c"
15931 #line 5857 "parse.y"
15933 value_expr((yyvsp[0].node));
15934 (yyval.node) = NEW_DOT2(new_nil_at(p, &(yylsp[-1]).beg_pos), (yyvsp[0].node), &(yyloc));
15937 #line 15938 "parse.c"
15941 #line 5863 "parse.y"
15943 value_expr((yyvsp[0].node));
15944 (yyval.node) = NEW_DOT3(new_nil_at(p, &(yylsp[-1]).beg_pos), (yyvsp[0].node), &(yyloc));
15947 #line 15948 "parse.c"
15951 #line 5872 "parse.y"
15953 if (!((yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc)))) (yyval.node) = NEW_ERROR(&(yyloc));
15956 #line 15957 "parse.c"
15960 #line 5880 "parse.y"
15962 error_duplicate_pattern_variable(p, (yyvsp[0].
id), &(yylsp[0]));
15964 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
15966 #line 15967 "parse.c"
15970 #line 5888 "parse.y"
15972 NODE *n = gettable(p, (yyvsp[0].
id), &(yyloc));
15974 n = NEW_ERROR(&(yyloc));
15976 else if (!(nd_type_p(n, NODE_LVAR) || nd_type_p(n, NODE_DVAR))) {
15977 compile_error(p,
"%"PRIsVALUE
": no such local variable",
rb_id2str((yyvsp[0].
id)));
15982 #line 15983 "parse.c"
15986 #line 5900 "parse.y"
15988 if (!((yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc)))) (yyval.node) = NEW_ERROR(&(yyloc));
15991 #line 15992 "parse.c"
15995 #line 5907 "parse.y"
15997 (yyval.node) = NEW_BLOCK((yyvsp[-1].node), &(yyloc));
16000 #line 16001 "parse.c"
16004 #line 5914 "parse.y"
16006 (yyval.node) = NEW_COLON3((yyvsp[0].
id), &(yyloc));
16009 #line 16010 "parse.c"
16013 #line 5919 "parse.y"
16015 (yyval.node) = NEW_COLON2((yyvsp[-2].node), (yyvsp[0].id), &(yyloc));
16018 #line 16019 "parse.c"
16022 #line 5924 "parse.y"
16024 (yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc));
16027 #line 16028 "parse.c"
16031 #line 5933 "parse.y"
16033 NODE *err = (yyvsp[-3].node);
16034 if ((yyvsp[-3].node)) {
16035 err = NEW_ERRINFO(&(yylsp[-3]));
16036 err = node_assign(p, (yyvsp[-3].node), err, NO_LEX_CTXT, &(yylsp[-3]));
16038 (yyval.node) = NEW_RESBODY((yyvsp[-4].node), (yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
16039 if ((yyvsp[-4].node)) {
16040 fixpos((yyval.node), (yyvsp[-4].node));
16042 else if ((yyvsp[-3].node)) {
16043 fixpos((yyval.node), (yyvsp[-3].node));
16046 fixpos((yyval.node), (yyvsp[-1].node));
16050 #line 16051 "parse.c"
16054 #line 5955 "parse.y"
16056 (yyval.node) = NEW_LIST((yyvsp[0].node), &(yyloc));
16059 #line 16060 "parse.c"
16063 #line 5960 "parse.y"
16065 if (!((yyval.node) = splat_array((yyvsp[0].node)))) (yyval.node) = (yyvsp[0].node);
16067 #line 16068 "parse.c"
16071 #line 5967 "parse.y"
16073 (yyval.node) = (yyvsp[0].node);
16076 #line 16077 "parse.c"
16080 #line 5975 "parse.y"
16082 p->ctxt.in_rescue = (yyvsp[-2].ctxt).in_rescue;
16083 (yyval.node) = (yyvsp[-1].node);
16084 void_expr(p, void_stmts(p, (yyval.node)));
16087 #line 16088 "parse.c"
16091 #line 5989 "parse.y"
16093 NODE *node = (yyvsp[0].node);
16095 node = NEW_STR(STRING_NEW0(), &(yyloc));
16098 node = evstr2dstr(p, node);
16100 (yyval.node) = node;
16103 #line 16104 "parse.c"
16107 #line 6005 "parse.y"
16109 (yyval.node) = literal_concat(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
16112 #line 16113 "parse.c"
16116 #line 6012 "parse.y"
16118 (yyval.node) = heredoc_dedent(p, (yyvsp[-1].node));
16119 if ((yyval.node)) nd_set_loc((yyval.node), &(yyloc));
16121 if (p->heredoc_indent > 0) {
16123 p->heredoc_indent = 0;
16127 #line 16128 "parse.c"
16131 #line 6025 "parse.y"
16133 (yyval.node) = new_xstring(p, heredoc_dedent(p, (yyvsp[-1].node)), &(yyloc));
16135 if (p->heredoc_indent > 0) {
16137 p->heredoc_indent = 0;
16141 #line 16142 "parse.c"
16145 #line 6037 "parse.y"
16147 (yyval.node) = new_regexp(p, (yyvsp[-1].node), (yyvsp[0].num), &(yyloc));
16150 #line 16151 "parse.c"
16154 #line 2964 "parse.y"
16156 (yyval.node) = make_list((yyvsp[-1].node), &(yyloc));
16159 #line 16160 "parse.c"
16163 #line 6047 "parse.y"
16168 #line 16169 "parse.c"
16172 #line 6052 "parse.y"
16174 (yyval.node) = list_append(p, (yyvsp[-2].node), evstr2dstr(p, (yyvsp[-1].node)));
16177 #line 16178 "parse.c"
16181 #line 6061 "parse.y"
16183 (yyval.node) = literal_concat(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
16186 #line 16187 "parse.c"
16190 #line 2964 "parse.y"
16192 (yyval.node) = make_list((yyvsp[-1].node), &(yyloc));
16195 #line 16196 "parse.c"
16199 #line 6071 "parse.y"
16204 #line 16205 "parse.c"
16208 #line 6076 "parse.y"
16210 (yyval.node) = symbol_append(p, (yyvsp[-2].node), evstr2dstr(p, (yyvsp[-1].node)));
16213 #line 16214 "parse.c"
16217 #line 2964 "parse.y"
16219 (yyval.node) = make_list((yyvsp[-1].node), &(yyloc));
16222 #line 16223 "parse.c"
16226 #line 2964 "parse.y"
16228 (yyval.node) = make_list((yyvsp[-1].node), &(yyloc));
16231 #line 16232 "parse.c"
16235 #line 6089 "parse.y"
16240 #line 16241 "parse.c"
16244 #line 6094 "parse.y"
16246 (yyval.node) = list_append(p, (yyvsp[-2].node), (yyvsp[-1].node));
16249 #line 16250 "parse.c"
16253 #line 6101 "parse.y"
16258 #line 16259 "parse.c"
16262 #line 6106 "parse.y"
16264 (yyval.node) = symbol_append(p, (yyvsp[-2].node), (yyvsp[-1].node));
16267 #line 16268 "parse.c"
16271 #line 6113 "parse.y"
16276 #line 16277 "parse.c"
16280 #line 6118 "parse.y"
16282 (yyval.node) = literal_concat(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
16285 #line 16286 "parse.c"
16289 #line 6125 "parse.y"
16294 #line 16295 "parse.c"
16298 #line 6130 "parse.y"
16300 (yyval.node) = literal_concat(p, (yyvsp[-1].node), (yyvsp[0].node), &(yyloc));
16303 #line 16304 "parse.c"
16307 #line 6137 "parse.y"
16312 #line 16313 "parse.c"
16316 #line 6142 "parse.y"
16318 NODE *head = (yyvsp[-1].node), *tail = (yyvsp[0].node);
16320 (yyval.node) = tail;
16323 (yyval.node) = head;
16326 switch (nd_type(head)) {
16328 head = str2dstr(p, head);
16333 head = list_append(p, NEW_DSTR(0, &(yyloc)), head);
16336 (yyval.node) = list_append(p, head, tail);
16340 #line 16341 "parse.c"
16344 #line 6170 "parse.y"
16347 (yyval.strterm) = p->lex.strterm;
16348 p->lex.strterm = 0;
16349 SET_LEX_STATE(EXPR_BEG);
16351 #line 16352 "parse.c"
16355 #line 6177 "parse.y"
16357 p->lex.strterm = (yyvsp[-1].strterm);
16358 (yyval.node) = NEW_EVSTR((yyvsp[0].node), &(yyloc));
16359 nd_set_line((yyval.node), (yylsp[0]).end_pos.lineno);
16362 #line 16363 "parse.c"
16366 #line 6184 "parse.y"
16371 (yyval.strterm) = p->lex.strterm;
16372 p->lex.strterm = 0;
16373 SET_LEX_STATE(EXPR_BEG);
16375 #line 16376 "parse.c"
16379 #line 6192 "parse.y"
16381 (yyval.num) = p->lex.brace_nest;
16382 p->lex.brace_nest = 0;
16384 #line 16385 "parse.c"
16388 #line 6196 "parse.y"
16390 (yyval.num) = p->heredoc_indent;
16391 p->heredoc_indent = 0;
16393 #line 16394 "parse.c"
16397 #line 6201 "parse.y"
16401 p->lex.strterm = (yyvsp[-4].strterm);
16402 SET_LEX_STATE((yyvsp[-5].state));
16403 p->lex.brace_nest = (yyvsp[-3].num);
16404 p->heredoc_indent = (yyvsp[-2].num);
16405 p->heredoc_line_indent = -1;
16406 if ((yyvsp[-1].node)) nd_unset_fl_newline((yyvsp[-1].node));
16407 (yyval.node) = new_evstr(p, (yyvsp[-1].node), &(yyloc));
16410 #line 16411 "parse.c"
16414 #line 6220 "parse.y"
16416 if (!((yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc)))) (yyval.node) = NEW_ERROR(&(yyloc));
16419 #line 16420 "parse.c"
16423 #line 6232 "parse.y"
16425 SET_LEX_STATE(EXPR_END);
16433 if (!str) str = STR_NEW0();
16434 (yyval.node) = NEW_SYM(str, &(yyloc));
16437 #line 16438 "parse.c"
16441 #line 6252 "parse.y"
16443 SET_LEX_STATE(EXPR_END);
16444 (yyval.node) = dsym_node(p, (yyvsp[-1].node), &(yyloc));
16447 #line 16448 "parse.c"
16451 #line 6261 "parse.y"
16453 (yyval.node) = (yyvsp[0].node);
16454 negate_lit(p, (yyval.node));
16457 #line 16458 "parse.c"
16461 #line 6283 "parse.y"
16462 {(yyval.id) = KWD2EID(nil, (yyvsp[0].
id));}
16463 #line 16464 "parse.c"
16467 #line 6284 "parse.y"
16468 {(yyval.id) = KWD2EID(
self, (yyvsp[0].
id));}
16469 #line 16470 "parse.c"
16473 #line 6285 "parse.y"
16474 {(yyval.id) = KWD2EID(
true, (yyvsp[0].
id));}
16475 #line 16476 "parse.c"
16479 #line 6286 "parse.y"
16480 {(yyval.id) = KWD2EID(
false, (yyvsp[0].
id));}
16481 #line 16482 "parse.c"
16485 #line 6287 "parse.y"
16486 {(yyval.id) = KWD2EID(_FILE__, (yyvsp[0].
id));}
16487 #line 16488 "parse.c"
16491 #line 6288 "parse.y"
16492 {(yyval.id) = KWD2EID(_LINE__, (yyvsp[0].
id));}
16493 #line 16494 "parse.c"
16497 #line 6289 "parse.y"
16498 {(yyval.id) = KWD2EID(_ENCODING__, (yyvsp[0].
id));}
16499 #line 16500 "parse.c"
16503 #line 6293 "parse.y"
16505 if (!((yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc)))) (yyval.node) = NEW_ERROR(&(yyloc));
16506 if (ifdef_ripper(id_is_var(p, (yyvsp[0].
id)),
false)) {
16513 #line 16514 "parse.c"
16517 #line 6303 "parse.y"
16519 if (!((yyval.node) = gettable(p, (yyvsp[0].
id), &(yyloc)))) (yyval.node) = NEW_ERROR(&(yyloc));
16522 #line 16523 "parse.c"
16526 #line 6310 "parse.y"
16529 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
16531 #line 16532 "parse.c"
16535 #line 6310 "parse.y"
16538 (yyval.node) = assignable(p, (yyvsp[0].
id), 0, &(yyloc));
16540 #line 16541 "parse.c"
16544 #line 6321 "parse.y"
16546 SET_LEX_STATE(EXPR_BEG);
16547 p->command_start = TRUE;
16549 #line 16550 "parse.c"
16553 #line 6326 "parse.y"
16555 (yyval.node) = (yyvsp[-1].node);
16558 #line 16559 "parse.c"
16562 #line 6331 "parse.y"
16567 #line 16568 "parse.c"
16571 #line 6339 "parse.y"
16573 p->ctxt.in_argdef = 0;
16574 (yyval.node_args) = new_args_tail(p, 0, 0, 0, &(yylsp[-1]));
16575 (yyval.node_args) = new_args(p, 0, 0, 0, 0, (yyval.node_args), &(yylsp[-1]));
16578 #line 16579 "parse.c"
16582 #line 6348 "parse.y"
16584 (yyval.node_args) = (yyvsp[-1].node_args);
16586 SET_LEX_STATE(EXPR_BEG);
16587 p->command_start = TRUE;
16588 p->ctxt.in_argdef = 0;
16590 #line 16591 "parse.c"
16594 #line 6358 "parse.y"
16596 (yyval.ctxt) = p->ctxt;
16597 p->ctxt.in_kwarg = 1;
16598 p->ctxt.in_argdef = 1;
16599 SET_LEX_STATE(p->lex.state|EXPR_LABEL);
16601 #line 16602 "parse.c"
16605 #line 6365 "parse.y"
16607 p->ctxt.in_kwarg = (yyvsp[-2].ctxt).in_kwarg;
16608 p->ctxt.in_argdef = 0;
16609 (yyval.node_args) = (yyvsp[-1].node_args);
16610 SET_LEX_STATE(EXPR_BEG);
16611 p->command_start = TRUE;
16614 #line 16615 "parse.c"
16618 #line 2938 "parse.y"
16620 (yyval.node_kw_arg) = (yyvsp[0].node_kw_arg);
16623 #line 16624 "parse.c"
16627 #line 2943 "parse.y"
16629 (yyval.node_kw_arg) = kwd_append((yyvsp[-2].node_kw_arg), (yyvsp[0].node_kw_arg));
16632 #line 16633 "parse.c"
16636 #line 6376 "parse.y"
16638 (yyval.node_args) = new_args_tail(p, (yyvsp[-3].node_kw_arg), (yyvsp[-1].id), (yyvsp[0].
id), &(yylsp[-1]));
16641 #line 16642 "parse.c"
16645 #line 6381 "parse.y"
16647 (yyval.node_args) = new_args_tail(p, (yyvsp[-1].node_kw_arg), 0, (yyvsp[0].id), &(yylsp[-1]));
16650 #line 16651 "parse.c"
16654 #line 6386 "parse.y"
16656 (yyval.node_args) = new_args_tail(p, 0, (yyvsp[-1].
id), (yyvsp[0].id), &(yylsp[-1]));
16659 #line 16660 "parse.c"
16663 #line 6391 "parse.y"
16665 (yyval.node_args) = new_args_tail(p, 0, 0, (yyvsp[0].
id), &(yylsp[0]));
16668 #line 16669 "parse.c"
16672 #line 6396 "parse.y"
16674 ID fwd = (yyvsp[0].id);
16675 if (lambda_beginning_p() ||
16676 (p->lex.lpar_beg >= 0 && p->lex.lpar_beg+1 == p->lex.paren_nest)) {
16677 yyerror0(
"unexpected ... in lambda argument");
16681 add_forwarding_args(p);
16683 (yyval.node_args) = new_args_tail(p, 0, fwd, arg_FWD_BLOCK, &(yylsp[0]));
16684 (yyval.node_args)->nd_ainfo.forwarding = 1;
16687 #line 16688 "parse.c"
16691 #line 2916 "parse.y"
16693 p->ctxt.in_argdef = 1;
16694 (yyval.node_opt_arg) = NEW_OPT_ARG(assignable(p, (yyvsp[-2].
id), (yyvsp[0].node), &(yyloc)), &(yyloc));
16697 #line 16698 "parse.c"
16701 #line 2925 "parse.y"
16703 (yyval.node_opt_arg) = (yyvsp[0].node_opt_arg);
16706 #line 16707 "parse.c"
16710 #line 2930 "parse.y"
16712 (yyval.node_opt_arg) = opt_arg_append((yyvsp[-2].node_opt_arg), (yyvsp[0].node_opt_arg));
16715 #line 16716 "parse.c"
16719 #line 2951 "parse.y"
16721 (yyval.node_args) = (yyvsp[0].node_args);
16724 #line 16725 "parse.c"
16728 #line 2956 "parse.y"
16730 (yyval.node_args) = new_args_tail(p, 0, 0, 0, &(yylsp[0]));
16733 #line 16734 "parse.c"
16737 #line 6413 "parse.y"
16739 (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));
16742 #line 16743 "parse.c"
16746 #line 6418 "parse.y"
16748 (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));
16751 #line 16752 "parse.c"
16755 #line 6423 "parse.y"
16757 (yyval.node_args) = new_args(p, (yyvsp[-3].node_args_aux), (yyvsp[-1].node_opt_arg), 0, 0, (yyvsp[0].node_args), &(yyloc));
16760 #line 16761 "parse.c"
16764 #line 6428 "parse.y"
16766 (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));
16769 #line 16770 "parse.c"
16773 #line 6433 "parse.y"
16775 (yyval.node_args) = new_args(p, (yyvsp[-3].node_args_aux), 0, (yyvsp[-1].id), 0, (yyvsp[0].node_args), &(yyloc));
16778 #line 16779 "parse.c"
16782 #line 6438 "parse.y"
16784 (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));
16787 #line 16788 "parse.c"
16791 #line 6443 "parse.y"
16793 (yyval.node_args) = new_args(p, (yyvsp[-1].node_args_aux), 0, 0, 0, (yyvsp[0].node_args), &(yyloc));
16796 #line 16797 "parse.c"
16800 #line 6448 "parse.y"
16802 (yyval.node_args) = new_args(p, 0, (yyvsp[-3].node_opt_arg), (yyvsp[-1].id), 0, (yyvsp[0].node_args), &(yyloc));
16805 #line 16806 "parse.c"
16809 #line 6453 "parse.y"
16811 (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));
16814 #line 16815 "parse.c"
16818 #line 6458 "parse.y"
16820 (yyval.node_args) = new_args(p, 0, (yyvsp[-1].node_opt_arg), 0, 0, (yyvsp[0].node_args), &(yyloc));
16823 #line 16824 "parse.c"
16827 #line 6463 "parse.y"
16829 (yyval.node_args) = new_args(p, 0, (yyvsp[-3].node_opt_arg), 0, (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
16832 #line 16833 "parse.c"
16836 #line 6468 "parse.y"
16838 (yyval.node_args) = new_args(p, 0, 0, (yyvsp[-1].
id), 0, (yyvsp[0].node_args), &(yyloc));
16841 #line 16842 "parse.c"
16845 #line 6473 "parse.y"
16847 (yyval.node_args) = new_args(p, 0, 0, (yyvsp[-3].
id), (yyvsp[-1].node_args_aux), (yyvsp[0].node_args), &(yyloc));
16850 #line 16851 "parse.c"
16854 #line 6478 "parse.y"
16856 (yyval.node_args) = new_args(p, 0, 0, 0, 0, (yyvsp[0].node_args), &(yyloc));
16859 #line 16860 "parse.c"
16863 #line 6483 "parse.y"
16865 (yyval.node_args) = new_args_tail(p, 0, 0, 0, &(yylsp[0]));
16866 (yyval.node_args) = new_args(p, 0, 0, 0, 0, (yyval.node_args), &(yylsp[0]));
16869 #line 16870 "parse.c"
16873 #line 6491 "parse.y"
16875 #ifdef FORWARD_ARGS_WITH_RUBY2_KEYWORDS
16878 (yyval.id) = idFWD_KWREST;
16882 #line 16883 "parse.c"
16886 #line 6502 "parse.y"
16888 static const char mesg[] =
"formal argument cannot be a constant";
16890 yyerror1(&(yylsp[0]), mesg);
16895 #line 16896 "parse.c"
16899 #line 6511 "parse.y"
16901 static const char mesg[] =
"formal argument cannot be an instance variable";
16903 yyerror1(&(yylsp[0]), mesg);
16908 #line 16909 "parse.c"
16912 #line 6520 "parse.y"
16914 static const char mesg[] =
"formal argument cannot be a global variable";
16916 yyerror1(&(yylsp[0]), mesg);
16921 #line 16922 "parse.c"
16925 #line 6529 "parse.y"
16927 static const char mesg[] =
"formal argument cannot be a class variable";
16929 yyerror1(&(yylsp[0]), mesg);
16934 #line 16935 "parse.c"
16938 #line 6541 "parse.y"
16940 VALUE e = formal_argument_error(p, (yyval.id) = (yyvsp[0].id));
16944 p->max_numparam = ORDINAL_PARAM;
16946 #line 16947 "parse.c"
16950 #line 6551 "parse.y"
16952 ID id = (yyvsp[0].id);
16954 (yyval.id) = (yyvsp[0].
id);
16956 #line 16957 "parse.c"
16960 #line 6559 "parse.y"
16962 (yyval.node_args_aux) = NEW_ARGS_AUX((yyvsp[0].
id), 1, &NULL_LOC);
16965 #line 16966 "parse.c"
16969 #line 6564 "parse.y"
16971 ID tid = internal_id(p);
16973 loc.beg_pos = (yylsp[-1]).beg_pos;
16974 loc.end_pos = (yylsp[-1]).beg_pos;
16976 if (dyna_in_block(p)) {
16977 (yyvsp[-1].node_masgn)->nd_value = NEW_DVAR(tid, &loc);
16980 (yyvsp[-1].node_masgn)->nd_value = NEW_LVAR(tid, &loc);
16982 (yyval.node_args_aux) = NEW_ARGS_AUX(tid, 1, &NULL_LOC);
16983 (yyval.node_args_aux)->nd_next = (
NODE *)(yyvsp[-1].node_masgn);
16986 #line 16987 "parse.c"
16990 #line 6585 "parse.y"
16992 (yyval.node_args_aux) = (yyvsp[-2].node_args_aux);
16993 (yyval.node_args_aux)->nd_plen++;
16994 (yyval.node_args_aux)->nd_next = block_append(p, (yyval.node_args_aux)->nd_next, (yyvsp[0].node_args_aux)->nd_next);
16995 rb_discard_node(p, (
NODE *)(yyvsp[0].node_args_aux));
16998 #line 16999 "parse.c"
17002 #line 6596 "parse.y"
17004 VALUE e = formal_argument_error(p, (yyval.id) = (yyvsp[0].id));
17015 arg_var(p, ifdef_ripper(0, (yyvsp[0].
id)));
17017 p->max_numparam = ORDINAL_PARAM;
17018 p->ctxt.in_argdef = 0;
17020 #line 17021 "parse.c"
17024 #line 6616 "parse.y"
17026 p->ctxt.in_argdef = 1;
17027 (yyval.node_kw_arg) = new_kw_arg(p, assignable(p, (yyvsp[-1].
id), (yyvsp[0].node), &(yyloc)), &(yyloc));
17030 #line 17031 "parse.c"
17034 #line 6622 "parse.y"
17036 p->ctxt.in_argdef = 1;
17037 (yyval.node_kw_arg) = new_kw_arg(p, assignable(p, (yyvsp[0].
id), NODE_SPECIAL_REQUIRED_KEYWORD, &(yyloc)), &(yyloc));
17040 #line 17041 "parse.c"
17044 #line 6630 "parse.y"
17046 p->ctxt.in_argdef = 1;
17047 (yyval.node_kw_arg) = new_kw_arg(p, assignable(p, (yyvsp[-1].
id), (yyvsp[0].node), &(yyloc)), &(yyloc));
17050 #line 17051 "parse.c"
17054 #line 6636 "parse.y"
17056 p->ctxt.in_argdef = 1;
17057 (yyval.node_kw_arg) = new_kw_arg(p, assignable(p, (yyvsp[0].
id), NODE_SPECIAL_REQUIRED_KEYWORD, &(yyloc)), &(yyloc));
17060 #line 17061 "parse.c"
17064 #line 6648 "parse.y"
17068 #line 17069 "parse.c"
17072 #line 6654 "parse.y"
17074 arg_var(p, shadowing_lvar(p, (yyvsp[0].
id)));
17075 (yyval.id) = (yyvsp[0].
id);
17078 #line 17079 "parse.c"
17082 #line 6660 "parse.y"
17084 arg_var(p, idFWD_KWREST);
17085 (yyval.id) = idFWD_KWREST;
17088 #line 17089 "parse.c"
17092 #line 6672 "parse.y"
17094 arg_var(p, shadowing_lvar(p, (yyvsp[0].
id)));
17095 (yyval.id) = (yyvsp[0].
id);
17098 #line 17099 "parse.c"
17102 #line 6678 "parse.y"
17104 arg_var(p, idFWD_REST);
17105 (yyval.id) = idFWD_REST;
17108 #line 17109 "parse.c"
17112 #line 6690 "parse.y"
17114 arg_var(p, shadowing_lvar(p, (yyvsp[0].
id)));
17115 (yyval.id) = (yyvsp[0].
id);
17118 #line 17119 "parse.c"
17122 #line 6696 "parse.y"
17124 arg_var(p, idFWD_BLOCK);
17125 (yyval.id) = idFWD_BLOCK;
17128 #line 17129 "parse.c"
17132 #line 6704 "parse.y"
17134 (yyval.id) = (yyvsp[0].
id);
17137 #line 17138 "parse.c"
17141 #line 6709 "parse.y"
17146 #line 17147 "parse.c"
17150 #line 6716 "parse.y"
17152 value_expr((yyvsp[0].node));
17153 (yyval.node) = (yyvsp[0].node);
17155 #line 17156 "parse.c"
17159 #line 6721 "parse.y"
17161 SET_LEX_STATE(EXPR_BEG);
17162 p->ctxt.in_argdef = 0;
17164 #line 17165 "parse.c"
17168 #line 6726 "parse.y"
17170 p->ctxt.in_argdef = 1;
17171 NODE *expr = last_expr_node((yyvsp[-1].node));
17172 switch (nd_type(expr)) {
17182 case NODE_ENCODING:
17185 case NODE_RATIONAL:
17186 case NODE_IMAGINARY:
17190 yyerror1(&expr->nd_loc,
"can't define singleton method for literals");
17193 value_expr((yyvsp[-1].node));
17196 (yyval.node) = (yyvsp[-1].node);
17199 #line 17200 "parse.c"
17203 #line 6760 "parse.y"
17205 (yyval.node) = (yyvsp[-1].node);
17208 #line 17209 "parse.c"
17212 #line 6769 "parse.y"
17214 NODE *assocs = (yyvsp[-2].node);
17215 NODE *tail = (yyvsp[0].node);
17220 if (RNODE_LIST(assocs)->nd_head) {
17221 NODE *n = RNODE_LIST(tail)->nd_next;
17222 if (!RNODE_LIST(tail)->nd_head && nd_type_p(n, NODE_LIST) &&
17223 nd_type_p((n = RNODE_LIST(n)->nd_head), NODE_HASH)) {
17225 tail = RNODE_HASH(n)->nd_head;
17229 assocs = list_concat(assocs, tail);
17232 (yyval.node) = assocs;
17235 #line 17236 "parse.c"
17239 #line 6794 "parse.y"
17241 (yyval.node) = list_append(p, NEW_LIST((yyvsp[-2].node), &(yyloc)), (yyvsp[0].node));
17244 #line 17245 "parse.c"
17248 #line 6799 "parse.y"
17250 (yyval.node) = list_append(p, NEW_LIST(NEW_SYM(
rb_id2str((yyvsp[-1].
id)), &(yylsp[-1])), &(yyloc)), (yyvsp[0].node));
17253 #line 17254 "parse.c"
17257 #line 6804 "parse.y"
17259 NODE *val = gettable(p, (yyvsp[0].
id), &(yyloc));
17260 if (!val) val = NEW_ERROR(&(yyloc));
17261 (yyval.node) = list_append(p, NEW_LIST(NEW_SYM(
rb_id2str((yyvsp[0].
id)), &(yylsp[0])), &(yyloc)), val);
17264 #line 17265 "parse.c"
17268 #line 6811 "parse.y"
17270 YYLTYPE loc = code_loc_gen(&(yylsp[-3]), &(yylsp[-1]));
17271 (yyval.node) = list_append(p, NEW_LIST(dsym_node(p, (yyvsp[-2].node), &loc), &loc), (yyvsp[0].node));
17274 #line 17275 "parse.c"
17278 #line 6817 "parse.y"
17280 (yyval.node) = list_append(p, NEW_LIST(0, &(yyloc)), (yyvsp[0].node));
17283 #line 17284 "parse.c"
17287 #line 6822 "parse.y"
17289 forwarding_arg_check(p, idFWD_KWREST, idFWD_ALL,
"keyword rest");
17290 (yyval.node) = list_append(p, NEW_LIST(0, &(yyloc)),
17291 NEW_LVAR(idFWD_KWREST, &(yyloc)));
17294 #line 17295 "parse.c"
17298 #line 6868 "parse.y"
17299 {yyerrok;token_flush(p);}
17300 #line 17301 "parse.c"
17304 #line 6870 "parse.y"
17306 (yyloc).end_pos = (yyloc).beg_pos;
17309 #line 17310 "parse.c"
17313 #line 6877 "parse.y"
17315 #line 17316 "parse.c"
17319 #line 6881 "parse.y"
17323 #line 17324 "parse.c"
17327 #line 17328 "parse.c"
17342 YY_SYMBOL_PRINT (
"-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc, p);
17344 YYPOPSTACK (yylen);
17346 #line 2664 "parse.y"
17347 {after_reduce(yylen, p);}
17348 #line 17349 "parse.c"
17359 const int yylhs = yyr1[yyn] - YYNTOKENS;
17360 const int yyi = yypgoto[yylhs] + *yyssp;
17361 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
17363 : yydefgoto[yylhs]);
17375 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
17382 = {yyssp, yytoken, &yylloc};
17383 char const *yymsgp = YY_(
"syntax error");
17384 int yysyntax_error_status;
17385 yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx, p);
17386 if (yysyntax_error_status == 0)
17388 else if (yysyntax_error_status == -1)
17390 if (yymsg != yymsgbuf)
17391 YYSTACK_FREE (yymsg);
17392 yymsg = YY_CAST (
char *,
17393 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
17396 yysyntax_error_status
17397 = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx, p);
17403 yymsg_alloc =
sizeof yymsgbuf;
17404 yysyntax_error_status = YYENOMEM;
17407 yyerror (&yylloc, p, yymsgp);
17408 if (yysyntax_error_status == YYENOMEM)
17413 yyerror_range[1] = yylloc;
17414 if (yyerrstatus == 3)
17419 if (yychar <= END_OF_INPUT)
17422 if (yychar == END_OF_INPUT)
17427 yydestruct (
"Error: discarding",
17428 yytoken, &yylval, &yylloc, p);
17450 YYPOPSTACK (yylen);
17452 #line 2666 "parse.y"
17453 {after_pop_stack(yylen, p);}
17454 #line 17455 "parse.c"
17457 YY_STACK_PRINT (yyss, yyssp, p);
17471 yyn = yypact[yystate];
17472 if (!yypact_value_is_default (yyn))
17474 yyn += YYSYMBOL_YYerror;
17475 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
17477 yyn = yytable[yyn];
17487 yyerror_range[1] = *yylsp;
17488 yydestruct (
"Error: popping",
17489 YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, p);
17492 #line 2666 "parse.y"
17493 {after_pop_stack(1, p);}
17494 #line 17495 "parse.c"
17497 YY_STACK_PRINT (yyss, yyssp, p);
17500 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
17502 YY_IGNORE_MAYBE_UNINITIALIZED_END
17504 yyerror_range[2] = yylloc;
17506 YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);
17509 YY_SYMBOL_PRINT (
"Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp, p);
17511 #line 2665 "parse.y"
17512 {after_shift_error_token(p);}
17513 #line 17514 "parse.c"
17540 yyerror (&yylloc, p, YY_(
"memory exhausted"));
17549 if (yychar != YYEMPTY)
17553 yytoken = YYTRANSLATE (yychar);
17554 yydestruct (
"Cleanup: discarding lookahead",
17555 yytoken, &yylval, &yylloc, p);
17559 YYPOPSTACK (yylen);
17560 YY_STACK_PRINT (yyss, yyssp, p);
17561 while (yyssp != yyss)
17563 yydestruct (
"Cleanup: popping",
17564 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, p);
17569 YYSTACK_FREE (yyss);
17571 if (yymsg != yymsgbuf)
17572 YYSTACK_FREE (yymsg);
17576 #line 6885 "parse.y"
17581 # define yylval (*p->lval)
17589 #define set_parser_s_value(x) (ifdef_ripper(p->s_value = (x), (void)0))
17591 # define set_yylval_node(x) { \
17592 YYLTYPE _cur_loc; \
17593 rb_parser_set_location(p, &_cur_loc); \
17594 yylval.node = (x); \
17595 set_parser_s_value(STR_NEW(p->lex.ptok, p->lex.pcur-p->lex.ptok)); \
17597 # define set_yylval_str(x) \
17599 set_yylval_node(NEW_STR(x, &_cur_loc)); \
17600 set_parser_s_value(rb_str_new_mutable_parser_string(x)); \
17602 # define set_yylval_num(x) { \
17603 yylval.num = (x); \
17604 set_parser_s_value(x); \
17606 # define set_yylval_id(x) (yylval.id = (x))
17607 # define set_yylval_name(x) { \
17608 (yylval.id = (x)); \
17609 set_parser_s_value(ID2SYM(x)); \
17611 # define yylval_id() (yylval.id)
17613 #define set_yylval_noname() set_yylval_id(keyword_nil)
17614 #define has_delayed_token(p) (p->delayed.token != NULL)
17617 #define literal_flush(p, ptr) ((p)->lex.ptok = (ptr))
17618 #define dispatch_scan_event(p, t) parser_dispatch_scan_event(p, t, __LINE__)
17623 const char *
const pcur = p->lex.pcur;
17624 const char *
const ptok = p->lex.ptok;
17625 if (p->keep_tokens && (pcur < ptok)) {
17626 rb_bug(
"lex.pcur < lex.ptok. (line: %d) %"PRIdPTRDIFF
"|%"PRIdPTRDIFF
"|%"PRIdPTRDIFF
"",
17627 p->ruby_sourceline, ptok - p->lex.pbeg, pcur - ptok, p->lex.pend - pcur);
17629 return pcur > ptok;
17632 static const char *
17633 escaped_char(
int c)
17636 case '"':
return "\\\"";
17637 case '\\':
return "\\\\";
17638 case '\0':
return "\\0";
17639 case '\n':
return "\\n";
17640 case '\r':
return "\\r";
17641 case '\t':
return "\\t";
17642 case '\f':
return "\\f";
17643 case '\013':
return "\\v";
17644 case '\010':
return "\\b";
17645 case '\007':
return "\\a";
17646 case '\033':
return "\\e";
17647 case '\x7f':
return "\\c?";
17656 const char *
ptr = str->ptr;
17657 const char *pend =
ptr + str->len;
17658 const char *prev =
ptr;
17659 char charbuf[5] = {
'\\',
'x', 0, 0, 0};
17662 while (
ptr < pend) {
17667 if (
ptr > prev) parser_str_cat(result, prev,
ptr - prev);
17669 if (pend <
ptr + n)
17670 n = (int)(pend -
ptr);
17672 c = *
ptr & 0xf0 >> 4;
17673 charbuf[2] = (c < 10) ?
'0' + c :
'A' + c - 10;
17675 charbuf[3] = (c < 10) ?
'0' + c :
'A' + c - 10;
17676 parser_str_cat(result, charbuf, 4);
17684 cc = escaped_char(c);
17686 if (
ptr - n > prev) parser_str_cat(result, prev,
ptr - n - prev);
17687 parser_str_cat_cstr(result, cc);
17693 if (
ptr - n > prev) {
17694 parser_str_cat(result, prev,
ptr - n - prev);
17697 parser_str_cat(result, prev,
ptr - prev);
17701 if (
ptr > prev) parser_str_cat(result, prev,
ptr - prev);
17710 token->id = p->token_id;
17711 token->type_name = parser_token2char(p, t);
17713 token->loc.beg_pos = p->yylloc->beg_pos;
17714 token->loc.end_pos = p->yylloc->end_pos;
17715 rb_parser_ary_push_ast_token(p, p->tokens, token);
17720 rb_parser_printf(p,
"Append tokens (line: %d) [%d, :%s, \"%s\", [%d, %d, %d, %d]]\n",
17721 line, token->id, token->type_name, str_escaped->ptr,
17722 token->loc.beg_pos.lineno, token->loc.beg_pos.column,
17723 token->loc.end_pos.lineno, token->loc.end_pos.column);
17724 rb_parser_string_free(p, str_escaped);
17729 parser_dispatch_scan_event(
struct parser_params *p,
enum yytokentype t,
int line)
17731 debug_token_line(p,
"parser_dispatch_scan_event", line);
17733 if (!parser_has_token(p))
return;
17735 RUBY_SET_YYLLOC(*p->yylloc);
17737 if (p->keep_tokens) {
17738 rb_parser_string_t *str = rb_parser_encoding_string_new(p, p->lex.ptok, p->lex.pcur - p->lex.ptok, p->enc);
17739 parser_append_tokens(p, str, t, line);
17745 #define dispatch_delayed_token(p, t) parser_dispatch_delayed_token(p, t, __LINE__)
17747 parser_dispatch_delayed_token(
struct parser_params *p,
enum yytokentype t,
int line)
17749 debug_token_line(p,
"parser_dispatch_delayed_token", line);
17751 if (!has_delayed_token(p))
return;
17753 RUBY_SET_YYLLOC_OF_DELAYED_TOKEN(*p->yylloc);
17755 if (p->keep_tokens) {
17757 parser_append_tokens(p, p->delayed.token, t, line);
17759 rb_parser_string_free(p, p->delayed.token);
17762 p->delayed.token = NULL;
17765 #define literal_flush(p, ptr) ((void)(ptr))
17771 return p->lex.pcur > p->lex.ptok;
17775 ripper_scan_event_val(
struct parser_params *p,
enum yytokentype t)
17777 VALUE str = STR_NEW(p->lex.ptok, p->lex.pcur - p->lex.ptok);
17778 VALUE rval = ripper_dispatch1(p, ripper_token2eventid(t), str);
17779 RUBY_SET_YYLLOC(*p->yylloc);
17785 ripper_dispatch_scan_event(
struct parser_params *p,
enum yytokentype t)
17787 if (!ripper_has_scan_event(p))
return;
17789 set_parser_s_value(ripper_scan_event_val(p, t));
17791 #define dispatch_scan_event(p, t) ripper_dispatch_scan_event(p, t)
17794 ripper_dispatch_delayed_token(
struct parser_params *p,
enum yytokentype t)
17797 int saved_line = p->ruby_sourceline;
17798 const char *saved_tokp = p->lex.ptok;
17799 VALUE s_value, str;
17801 if (!has_delayed_token(p))
return;
17802 p->ruby_sourceline = p->delayed.beg_line;
17803 p->lex.ptok = p->lex.pbeg + p->delayed.beg_col;
17804 str = rb_str_new_mutable_parser_string(p->delayed.token);
17805 rb_parser_string_free(p, p->delayed.token);
17806 s_value = ripper_dispatch1(p, ripper_token2eventid(t), str);
17807 set_parser_s_value(s_value);
17808 p->delayed.token = NULL;
17809 p->ruby_sourceline = saved_line;
17810 p->lex.ptok = saved_tokp;
17812 #define dispatch_delayed_token(p, t) ripper_dispatch_delayed_token(p, t)
17824 return !(p)->eofp && is_identchar(p, p->lex.pcur-1, p->lex.pend, p->enc);
17830 return ISASCII(*(p->lex.pcur-1));
17836 int column = 1, nonspc = 0, i;
17837 for (i = 0; i < loc->beg_pos.column; i++,
ptr++) {
17838 if (*
ptr ==
'\t') {
17839 column = (((column - 1) / TAB_WIDTH) + 1) * TAB_WIDTH;
17842 if (*
ptr !=
' ' && *
ptr !=
'\t') {
17847 ptinfo->beg = loc->beg_pos;
17848 ptinfo->indent = column;
17849 ptinfo->nonspc = nonspc;
17857 if (!p->token_info_enabled)
return;
17859 ptinfo->token = token;
17860 ptinfo->next = p->token_info;
17861 token_info_setup(ptinfo, p->lex.pbeg, loc);
17863 p->token_info = ptinfo;
17871 if (!ptinfo_beg)
return;
17874 token_info_warn(p, token, ptinfo_beg, 1, loc);
17876 p->token_info = ptinfo_beg->next;
17877 ruby_sized_xfree(ptinfo_beg,
sizeof(*ptinfo_beg));
17885 if (!ptinfo_beg)
return;
17886 p->token_info = ptinfo_beg->next;
17888 if (ptinfo_beg->beg.lineno != beg_pos.lineno ||
17889 ptinfo_beg->beg.column != beg_pos.column ||
17890 strcmp(ptinfo_beg->token, token)) {
17891 compile_error(p,
"token position mismatch: %d:%d:%s expected but %d:%d:%s",
17892 beg_pos.lineno, beg_pos.column, token,
17893 ptinfo_beg->beg.lineno, ptinfo_beg->beg.column,
17894 ptinfo_beg->token);
17897 ruby_sized_xfree(ptinfo_beg,
sizeof(*ptinfo_beg));
17903 token_info ptinfo_end_body, *ptinfo_end = &ptinfo_end_body;
17904 if (!p->token_info_enabled)
return;
17905 if (!ptinfo_beg)
return;
17906 token_info_setup(ptinfo_end, p->lex.pbeg, loc);
17907 if (ptinfo_beg->beg.lineno == ptinfo_end->beg.lineno)
return;
17908 if (ptinfo_beg->nonspc || ptinfo_end->nonspc)
return;
17909 if (ptinfo_beg->indent == ptinfo_end->indent)
return;
17910 if (!same && ptinfo_beg->indent < ptinfo_end->indent)
return;
17911 rb_warn3L(ptinfo_end->beg.lineno,
17912 "mismatched indentations at '%s' with '%s' at %d",
17913 WARN_S(token), WARN_S(ptinfo_beg->token), WARN_I(ptinfo_beg->beg.lineno));
17921 compile_error(p,
"invalid multibyte char (%s)",
rb_enc_name(p->enc));
17932 int lineno = p->ruby_sourceline;
17936 else if (yylloc->beg_pos.lineno == lineno) {
17937 str = p->lex.lastline;
17942 ruby_show_error_line(p, p->error_buffer, yylloc, lineno, str);
17952 yylloc = RUBY_SET_YYLLOC(current);
17954 else if ((p->ruby_sourceline != yylloc->beg_pos.lineno &&
17955 p->ruby_sourceline != yylloc->end_pos.lineno)) {
17959 parser_compile_error(p, yylloc,
"%s", msg);
17960 parser_show_error_line(p, yylloc);
17968 return parser_yyerror(p, RUBY_SET_YYLLOC(current), msg);
17975 const int max_line_margin = 30;
17976 const char *
ptr, *ptr_end, *pt, *pb;
17977 const char *pre =
"", *post =
"", *pend;
17978 const char *code =
"", *caret =
"";
17980 const char *
const pbeg = PARSER_STRING_PTR(str);
17985 if (!yylloc)
return;
17986 pend = rb_parser_string_end(str);
17987 if (pend > pbeg && pend[-1] ==
'\n') {
17988 if (--pend > pbeg && pend[-1] ==
'\r') --pend;
17992 if (lineno == yylloc->end_pos.lineno &&
17993 (pend - pbeg) > yylloc->end_pos.column) {
17994 pt = pbeg + yylloc->end_pos.column;
17997 ptr = ptr_end = pt;
17998 lim =
ptr - pbeg > max_line_margin ?
ptr - max_line_margin : pbeg;
17999 while ((lim <
ptr) && (*(
ptr-1) !=
'\n'))
ptr--;
18001 lim = pend - ptr_end > max_line_margin ? ptr_end + max_line_margin : pend;
18002 while ((ptr_end < lim) && (*ptr_end !=
'\n') && (*ptr_end !=
'\r')) ptr_end++;
18008 if (
ptr > pbeg) pre =
"...";
18010 if (ptr_end < pend) {
18011 ptr_end =
rb_enc_prev_char(pt, ptr_end, pend, rb_parser_str_get_encoding(str));
18012 if (ptr_end < pend) post =
"...";
18016 if (lineno == yylloc->beg_pos.lineno) {
18017 pb += yylloc->beg_pos.column;
18018 if (pb > pt) pb = pt;
18021 if (len <= 4 && yylloc->beg_pos.lineno == yylloc->end_pos.lineno) {
18024 if (
RTEST(errbuf)) {
18026 if (char_at_end(p, mesg,
'\n') !=
'\n')
18032 if (!errbuf && rb_stderr_tty_p()) {
18033 #define CSI_BEGIN "\033["
18034 #define CSI_SGR "m"
18036 CSI_BEGIN
""CSI_SGR
"%s"
18037 CSI_BEGIN
"1"CSI_SGR
"%.*s"
18038 CSI_BEGIN
"1;4"CSI_SGR
"%.*s"
18039 CSI_BEGIN
";1"CSI_SGR
"%.*s"
18040 CSI_BEGIN
""CSI_SGR
"%s"
18044 (
int)(pt - pb), pb,
18045 (
int)(ptr_end - pt), pt,
18052 lim = pt < pend ? pt : pend;
18053 i = (int)(lim -
ptr);
18059 *p2++ = *
ptr++ ==
'\t' ?
'\t' :
' ';
18065 memset(p2,
'~', (lim -
ptr));
18070 pre, (
int)
len, code, post,
18073 if (!errbuf) rb_write_error_str(mesg);
18080 const char *pcur = 0, *ptok = 0;
18081 if (p->ruby_sourceline == yylloc->beg_pos.lineno &&
18082 p->ruby_sourceline == yylloc->end_pos.lineno) {
18083 pcur = p->lex.pcur;
18084 ptok = p->lex.ptok;
18085 p->lex.ptok = p->lex.pbeg + yylloc->beg_pos.column;
18086 p->lex.pcur = p->lex.pbeg + yylloc->end_pos.column;
18088 parser_yyerror0(p, msg);
18090 p->lex.ptok = ptok;
18091 p->lex.pcur = pcur;
18099 dispatch1(parse_error, STR_NEW2(msg));
18111 vtable_size(
const struct vtable *tbl)
18113 if (!DVARS_TERMINAL_P(tbl)) {
18131 rb_parser_printf(p,
"vtable_alloc:%d: %p\n", line, (
void *)tbl);
18136 #define vtable_alloc(prev) vtable_alloc_gen(p, __LINE__, prev)
18139 vtable_free_gen(
struct parser_params *p,
int line,
const char *name,
18144 rb_parser_printf(p,
"vtable_free:%d: %s(%p)\n", line, name, (
void *)tbl);
18147 if (!DVARS_TERMINAL_P(tbl)) {
18149 ruby_sized_xfree(tbl->tbl, tbl->capa *
sizeof(
ID));
18151 ruby_sized_xfree(tbl,
sizeof(*tbl));
18154 #define vtable_free(tbl) vtable_free_gen(p, __LINE__, #tbl, tbl)
18157 vtable_add_gen(
struct parser_params *p,
int line,
const char *name,
18162 rb_parser_printf(p,
"vtable_add:%d: %s(%p), %s\n",
18166 if (DVARS_TERMINAL_P(tbl)) {
18167 rb_parser_fatal(p,
"vtable_add: vtable is not allocated (%p)", (
void *)tbl);
18170 if (tbl->pos == tbl->capa) {
18171 tbl->capa = tbl->capa * 2;
18172 SIZED_REALLOC_N(tbl->tbl,
ID, tbl->capa, tbl->pos);
18174 tbl->tbl[tbl->pos++] = id;
18176 #define vtable_add(tbl, id) vtable_add_gen(p, __LINE__, #tbl, tbl, id)
18179 vtable_pop_gen(
struct parser_params *p,
int line,
const char *name,
18180 struct vtable *tbl,
int n)
18183 rb_parser_printf(p,
"vtable_pop:%d: %s(%p), %d\n",
18184 line, name, (
void *)tbl, n);
18186 if (tbl->pos < n) {
18187 rb_parser_fatal(p,
"vtable_pop: unreachable (%d < %d)", tbl->pos, n);
18192 #define vtable_pop(tbl, n) vtable_pop_gen(p, __LINE__, #tbl, tbl, n)
18195 vtable_included(
const struct vtable * tbl,
ID id)
18199 if (!DVARS_TERMINAL_P(tbl)) {
18200 for (i = 0; i < tbl->pos; i++) {
18201 if (tbl->tbl[i] ==
id) {
18214 return strcmp(p->ruby_sourcefile,
"-e") == 0;
18221 yycompile0(
VALUE arg)
18228 if (!compile_for_eval && !
NIL_P(p->ruby_sourcefile_string) && !e_option_supplied(p)) {
18232 if (p->debug_lines) {
18233 p->ast->body.script_lines = p->debug_lines;
18237 #define RUBY_DTRACE_PARSE_HOOK(name) \
18238 if (RUBY_DTRACE_PARSE_##name##_ENABLED()) { \
18239 RUBY_DTRACE_PARSE_##name(p->ruby_sourcefile, p->ruby_sourceline); \
18241 RUBY_DTRACE_PARSE_HOOK(BEGIN);
18243 RUBY_DTRACE_PARSE_HOOK(END);
18245 p->debug_lines = 0;
18247 xfree(p->lex.strterm);
18248 p->lex.strterm = 0;
18249 p->lex.pcur = p->lex.pbeg = p->lex.pend = 0;
18250 if (n || p->error_p) {
18251 VALUE mesg = p->error_buffer;
18253 mesg = syntax_error_new();
18255 if (!p->error_tolerant) {
18260 tree = p->eval_tree;
18262 tree = NEW_NIL(&NULL_LOC);
18267 NODE *body = parser_append_options(p, RNODE_SCOPE(tree)->nd_body);
18268 prelude = block_append(p, p->eval_tree_begin, body);
18269 RNODE_SCOPE(tree)->nd_body = prelude;
18270 p->ast->body.frozen_string_literal = p->frozen_string_literal;
18271 p->ast->body.coverage_enabled = cov;
18272 if (p->keep_tokens) {
18273 p->ast->node_buffer->tokens = tokens;
18277 p->ast->body.root = tree;
18278 p->ast->body.line_count = p->line_count;
18286 if (
NIL_P(fname)) {
18287 p->ruby_sourcefile_string =
Qnil;
18288 p->ruby_sourcefile =
"(none)";
18294 p->ruby_sourceline = line - 1;
18298 p->ast = ast = rb_ast_new();
18299 compile_callback(yycompile0, (
VALUE)p);
18313 rb_encoding *enc = rb_parser_str_get_encoding(s);
18324 if (!line)
return 0;
18326 string_buffer_append(p, line);
18327 must_be_ascii_compatible(p, line);
18333 rb_parser_compile(
rb_parser_t *p, rb_parser_lex_gets_func *gets,
VALUE fname, rb_parser_input_data input,
int line)
18335 p->lex.gets = gets;
18336 p->lex.input = input;
18337 p->lex.pbeg = p->lex.pcur = p->lex.pend = 0;
18339 return yycompile(p, fname, line);
18343 #define STR_FUNC_ESCAPE 0x01
18344 #define STR_FUNC_EXPAND 0x02
18345 #define STR_FUNC_REGEXP 0x04
18346 #define STR_FUNC_QWORDS 0x08
18347 #define STR_FUNC_SYMBOL 0x10
18348 #define STR_FUNC_INDENT 0x20
18349 #define STR_FUNC_LABEL 0x40
18350 #define STR_FUNC_LIST 0x4000
18351 #define STR_FUNC_TERM 0x8000
18354 str_label = STR_FUNC_LABEL,
18356 str_dquote = (STR_FUNC_EXPAND),
18357 str_xquote = (STR_FUNC_EXPAND),
18358 str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
18359 str_sword = (STR_FUNC_QWORDS|STR_FUNC_LIST),
18360 str_dword = (STR_FUNC_QWORDS|STR_FUNC_EXPAND|STR_FUNC_LIST),
18361 str_ssym = (STR_FUNC_SYMBOL),
18362 str_dsym = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
18370 pstr = rb_parser_encoding_string_new(p,
ptr,
len, enc);
18372 if (!(func & STR_FUNC_REGEXP)) {
18373 if (rb_parser_is_ascii_string(p, pstr)) {
18378 PARSER_ENCODING_CODERANGE_SET(pstr, enc, RB_PARSER_ENC_CODERANGE_VALID);
18388 return strterm->heredoc;
18392 new_strterm(
struct parser_params *p,
int func,
int term,
int paren)
18395 strterm->u.literal.func = func;
18396 strterm->u.literal.term = term;
18397 strterm->u.literal.paren = paren;
18405 strterm->heredoc =
true;
18409 #define peek(p,c) peek_n(p, (c), 0)
18410 #define peek_n(p,c,n) (!lex_eol_n_p(p, n) && (c) == (unsigned char)(p)->lex.pcur[n])
18411 #define peekc(p) peekc_n(p, 0)
18412 #define peekc_n(p,n) (lex_eol_n_p(p, n) ? -1 : (unsigned char)(p)->lex.pcur[n])
18414 #define add_delayed_token(p, tok, end) parser_add_delayed_token(p, tok, end, __LINE__)
18416 parser_add_delayed_token(
struct parser_params *p,
const char *tok,
const char *end,
int line)
18418 debug_token_line(p,
"add_delayed_token", line);
18421 if (has_delayed_token(p)) {
18422 bool next_line = parser_string_char_at_end(p, p->delayed.token, 0) ==
'\n';
18423 int end_line = (next_line ? 1 : 0) + p->delayed.end_line;
18424 int end_col = (next_line ? 0 : p->delayed.end_col);
18425 if (end_line != p->ruby_sourceline || end_col != tok - p->lex.pbeg) {
18426 dispatch_delayed_token(p, tSTRING_CONTENT);
18429 if (!has_delayed_token(p)) {
18430 p->delayed.token = rb_parser_string_new(p, 0, 0);
18431 rb_parser_enc_associate(p, p->delayed.token, p->enc);
18432 p->delayed.beg_line = p->ruby_sourceline;
18433 p->delayed.beg_col =
rb_long2int(tok - p->lex.pbeg);
18435 parser_str_cat(p->delayed.token, tok, end - tok);
18436 p->delayed.end_line = p->ruby_sourceline;
18437 p->delayed.end_col =
rb_long2int(end - p->lex.pbeg);
18445 p->lex.pbeg = p->lex.pcur = PARSER_STRING_PTR(str);
18446 p->lex.pend = p->lex.pcur + PARSER_STRING_LEN(str);
18447 p->lex.lastline = str;
18454 p->lex.nextline = 0;
18459 if (!lex_eol_ptr_p(p, p->lex.pbeg) && *(p->lex.pend-1) !=
'\n') {
18463 if (!p->lex.input || !(str = lex_getline(p))) {
18470 if (p->debug_lines) {
18471 if (set_encoding) rb_parser_enc_associate(p, str, p->enc);
18473 rb_parser_ary_push_script_line(p, p->debug_lines, copy);
18476 p->cr_seen = FALSE;
18478 else if (str == AFTER_HEREDOC_WITHOUT_TERMINTOR) {
18482 add_delayed_token(p, p->lex.ptok, p->lex.pend);
18483 if (p->heredoc_end > 0) {
18484 p->ruby_sourceline = p->heredoc_end;
18485 p->heredoc_end = 0;
18487 p->ruby_sourceline++;
18488 set_lastline(p, str);
18496 if (peek(p,
'\n')) {
18508 if (UNLIKELY(lex_eol_p(p) || p->eofp || p->lex.nextline > AFTER_HEREDOC_WITHOUT_TERMINTOR)) {
18509 if (nextline(p, set_encoding))
return -1;
18511 c = (
unsigned char)*p->lex.pcur++;
18512 if (UNLIKELY(c ==
'\r')) {
18513 c = parser_cr(p, c);
18518 #define nextc(p) nextc0(p, TRUE)
18523 if (c == -1)
return;
18526 if (p->lex.pcur > p->lex.pbeg && p->lex.pcur[0] ==
'\n' && p->lex.pcur[-1] ==
'\r') {
18531 #define was_bol(p) ((p)->lex.pcur == (p)->lex.pbeg + 1)
18533 #define tokfix(p) ((p)->tokenbuf[(p)->tokidx]='\0')
18534 #define tok(p) (p)->tokenbuf
18535 #define toklen(p) (p)->tokidx
18540 const char *
ptr = p->lex.pcur;
18541 while (!lex_eol_ptr_p(p,
ptr)) {
18542 int c = (
unsigned char)*
ptr++;
18543 int eol = (c ==
'\n' || c ==
'#');
18555 if (!p->tokenbuf) {
18557 p->tokenbuf =
ALLOC_N(
char, 60);
18559 if (p->toksiz > 4096) {
18563 return p->tokenbuf;
18571 if (p->tokidx >= p->toksiz) {
18572 do {p->toksiz *= 2;}
while (p->toksiz < p->tokidx);
18573 REALLOC_N(p->tokenbuf,
char, p->toksiz);
18575 return &p->tokenbuf[p->tokidx-n];
18581 p->tokenbuf[p->tokidx++] = (char)c;
18582 if (p->tokidx >= p->toksiz) {
18584 REALLOC_N(p->tokenbuf,
char, p->toksiz);
18596 yyerror0(
"invalid hex escape");
18597 dispatch_scan_event(p, tSTRING_CONTENT);
18600 p->lex.pcur += *numlen;
18604 #define tokcopy(p, n) memcpy(tokspace(p, n), (p)->lex.pcur - (n), (n))
18607 escaped_control_code(
int c)
18633 #define WARN_SPACE_CHAR(c, prefix) \
18634 rb_warn1("invalid character syntax; use "prefix"\\%c", WARN_I(c))
18638 int regexp_literal,
const char *begin)
18640 const int wide = !begin;
18642 int codepoint = (int)
ruby_scan_hex(p->lex.pcur, wide ? p->lex.pend - p->lex.pcur : 4, &numlen);
18644 p->lex.pcur += numlen;
18645 if (p->lex.strterm == NULL ||
18646 strterm_is_heredoc(p->lex.strterm) ||
18647 (p->lex.strterm->u.literal.func != str_regexp)) {
18648 if (!begin) begin = p->lex.pcur;
18649 if (wide ? (numlen == 0 || numlen > 6) : (numlen < 4)) {
18651 yyerror0(
"invalid Unicode escape");
18652 dispatch_scan_event(p, tSTRING_CONTENT);
18653 return wide && numlen > 0;
18655 if (codepoint > 0x10ffff) {
18657 yyerror0(
"invalid Unicode codepoint (too large)");
18658 dispatch_scan_event(p, tSTRING_CONTENT);
18661 if ((codepoint & 0xfffff800) == 0xd800) {
18663 yyerror0(
"invalid Unicode codepoint");
18664 dispatch_scan_event(p, tSTRING_CONTENT);
18668 if (regexp_literal) {
18669 tokcopy(p, (
int)numlen);
18671 else if (codepoint >= 0x80) {
18673 if (*encp && utf8 != *encp) {
18674 YYLTYPE loc = RUBY_INIT_YYLLOC();
18675 compile_error(p,
"UTF-8 mixed within %s source",
rb_enc_name(*encp));
18676 parser_show_error_line(p, &loc);
18680 tokaddmbc(p, codepoint, *encp);
18683 tokadd(p, codepoint);
18693 int len = parser_precise_mbclen(p, p->lex.pcur-1);
18695 p->lex.pcur +=
len - 1;
18703 int term,
int symbol_literal,
int regexp_literal)
18710 static const char multiple_codepoints[] =
"Multiple codepoints at single character literal";
18712 const int open_brace =
'{', close_brace =
'}';
18714 if (regexp_literal) { tokadd(p,
'\\'); tokadd(p,
'u'); }
18716 if (peek(p, open_brace)) {
18717 if (regexp_literal && p->lex.strterm->u.literal.func == str_regexp) {
18724 tokadd(p, open_brace);
18725 while (!lex_eol_ptr_p(p, ++p->lex.pcur)) {
18727 if (c == close_brace) {
18732 else if (c == term) {
18735 if (c ==
'\\' && !lex_eol_n_p(p, 1)) {
18737 c = *++p->lex.pcur;
18739 tokadd_mbchar(p, c);
18743 const char *second = NULL;
18744 int c, last = nextc(p);
18745 if (lex_eol_p(p))
goto unterminated;
18746 while (
ISSPACE(c = peekc(p)) && !lex_eol_ptr_p(p, ++p->lex.pcur));
18747 while (c != close_brace) {
18748 if (c == term)
goto unterminated;
18749 if (second == multiple_codepoints)
18750 second = p->lex.pcur;
18751 if (regexp_literal) tokadd(p, last);
18752 if (!tokadd_codepoint(p, encp, regexp_literal, NULL)) {
18755 while (
ISSPACE(c = peekc(p))) {
18756 if (lex_eol_ptr_p(p, ++p->lex.pcur))
goto unterminated;
18759 if (term == -1 && !second)
18760 second = multiple_codepoints;
18763 if (c != close_brace) {
18766 yyerror0(
"unterminated Unicode escape");
18767 dispatch_scan_event(p, tSTRING_CONTENT);
18770 if (second && second != multiple_codepoints) {
18771 const char *pcur = p->lex.pcur;
18772 p->lex.pcur = second;
18773 dispatch_scan_event(p, tSTRING_CONTENT);
18775 p->lex.pcur = pcur;
18776 yyerror0(multiple_codepoints);
18780 if (regexp_literal) tokadd(p, close_brace);
18785 if (!tokadd_codepoint(p, encp, regexp_literal, p->lex.pcur -
rb_strlen_lit(
"\\u"))) {
18792 #define ESCAPE_CONTROL 1
18793 #define ESCAPE_META 2
18796 read_escape(
struct parser_params *p,
int flags,
const char *begin)
18801 switch (c = nextc(p)) {
18826 case '0':
case '1':
case '2':
case '3':
18827 case '4':
case '5':
case '6':
case '7':
18830 p->lex.pcur += numlen;
18834 c = tok_hex(p, &numlen);
18835 if (numlen == 0)
return 0;
18845 if (flags & ESCAPE_META)
goto eof;
18846 if ((c = nextc(p)) !=
'-') {
18849 if ((c = nextc(p)) ==
'\\') {
18850 switch (peekc(p)) {
18851 case 'u':
case 'U':
18855 return read_escape(p, flags|ESCAPE_META, begin) | 0x80;
18857 else if (c == -1)
goto eof;
18863 int c2 = escaped_control_code(c);
18865 if (
ISCNTRL(c) || !(flags & ESCAPE_CONTROL)) {
18866 WARN_SPACE_CHAR(c2,
"\\M-");
18869 WARN_SPACE_CHAR(c2,
"\\C-\\M-");
18872 else if (
ISCNTRL(c))
goto eof;
18873 return ((c & 0xff) | 0x80);
18877 if ((c = nextc(p)) !=
'-') {
18881 if (flags & ESCAPE_CONTROL)
goto eof;
18882 if ((c = nextc(p))==
'\\') {
18883 switch (peekc(p)) {
18884 case 'u':
case 'U':
18888 c = read_escape(p, flags|ESCAPE_CONTROL, begin);
18892 else if (c == -1)
goto eof;
18898 int c2 = escaped_control_code(c);
18901 if (flags & ESCAPE_META) {
18902 WARN_SPACE_CHAR(c2,
"\\M-");
18905 WARN_SPACE_CHAR(c2,
"");
18909 if (flags & ESCAPE_META) {
18910 WARN_SPACE_CHAR(c2,
"\\M-\\C-");
18913 WARN_SPACE_CHAR(c2,
"\\C-");
18917 else if (
ISCNTRL(c))
goto eof;
18923 flush_string_content(p, p->enc, p->lex.pcur - begin);
18924 yyerror0(
"Invalid escape character syntax");
18925 dispatch_scan_event(p, tSTRING_CONTENT);
18945 const char *begin = p->lex.pcur;
18947 switch (c = nextc(p)) {
18951 case '0':
case '1':
case '2':
case '3':
18952 case '4':
case '5':
case '6':
case '7':
18955 if (numlen == 0)
goto eof;
18956 p->lex.pcur += numlen;
18957 tokcopy(p, (
int)numlen + 1);
18963 tok_hex(p, &numlen);
18964 if (numlen == 0)
return -1;
18965 tokcopy(p, (
int)numlen + 2);
18971 flush_string_content(p, p->enc, p->lex.pcur - begin);
18972 yyerror0(
"Invalid escape character syntax");
18984 char_to_option(
int c)
18990 val = RE_ONIG_OPTION_IGNORECASE;
18993 val = RE_ONIG_OPTION_EXTEND;
18996 val = RE_ONIG_OPTION_MULTILINE;
19005 #define ARG_ENCODING_FIXED 16
19006 #define ARG_ENCODING_NONE 32
19007 #define ENC_ASCII8BIT 1
19008 #define ENC_EUC_JP 2
19009 #define ENC_Windows_31J 3
19013 char_to_option_kcode(
int c,
int *option,
int *kcode)
19019 *kcode = ENC_ASCII8BIT;
19020 return (*option = ARG_ENCODING_NONE);
19022 *kcode = ENC_EUC_JP;
19025 *kcode = ENC_Windows_31J;
19032 return (*option = char_to_option(c));
19034 *option = ARG_ENCODING_FIXED;
19047 while (c = nextc(p),
ISALPHA(c)) {
19049 options |= RE_OPTION_ONCE;
19051 else if (char_to_option_kcode(c, &opt, &kc)) {
19053 if (kc != ENC_ASCII8BIT) kcode = c;
19067 YYLTYPE loc = RUBY_INIT_YYLLOC();
19069 compile_error(p,
"unknown regexp option%s - %*s",
19070 toklen(p) > 1 ?
"s" :
"", toklen(p), tok(p));
19071 parser_show_error_line(p, &loc);
19073 return options | RE_OPTION_ENCODING(kcode);
19079 int len = parser_precise_mbclen(p, p->lex.pcur-1);
19080 if (
len < 0)
return -1;
19082 p->lex.pcur += --
len;
19083 if (
len > 0) tokcopy(p,
len);
19088 simple_re_meta(
int c)
19091 case '$':
case '*':
case '+':
case '.':
19092 case '?':
case '^':
case '|':
19093 case ')':
case ']':
case '}':
case '>':
19101 parser_update_heredoc_indent(
struct parser_params *p,
int c)
19103 if (p->heredoc_line_indent == -1) {
19104 if (c ==
'\n') p->heredoc_line_indent = 0;
19108 p->heredoc_line_indent++;
19111 else if (c ==
'\t') {
19112 int w = (p->heredoc_line_indent / TAB_WIDTH) + 1;
19113 p->heredoc_line_indent = w * TAB_WIDTH;
19116 else if (c !=
'\n') {
19117 if (p->heredoc_indent > p->heredoc_line_indent) {
19118 p->heredoc_indent = p->heredoc_line_indent;
19120 p->heredoc_line_indent = -1;
19124 p->heredoc_line_indent = 0;
19133 YYLTYPE loc = RUBY_INIT_YYLLOC();
19135 compile_error(p,
"%s mixed within %s source", n1, n2);
19136 parser_show_error_line(p, &loc);
19142 const char *pos = p->lex.pcur;
19144 parser_mixed_error(p, enc1, enc2);
19149 nibble_char_upper(
unsigned int c)
19152 return c + (c < 10 ?
'0' :
'A' - 10);
19157 int func,
int term,
int paren,
long *nest,
19161 bool erred =
false;
19163 const int heredoc_end = (p->heredoc_end ? p->heredoc_end + 1 : 0);
19164 int top_of_line = FALSE;
19167 #define mixed_error(enc1, enc2) \
19168 (void)(erred || (parser_mixed_error(p, enc1, enc2), erred = true))
19169 #define mixed_escape(beg, enc1, enc2) \
19170 (void)(erred || (parser_mixed_escape(p, beg, enc1, enc2), erred = true))
19172 while ((c = nextc(p)) != -1) {
19173 if (p->heredoc_indent > 0) {
19174 parser_update_heredoc_indent(p, c);
19177 if (top_of_line && heredoc_end == p->ruby_sourceline) {
19183 if (paren && c == paren) {
19186 else if (c == term) {
19187 if (!nest || !*nest) {
19193 else if ((func & STR_FUNC_EXPAND) && c ==
'#' && !lex_eol_p(p)) {
19194 unsigned char c2 = *p->lex.pcur;
19195 if (c2 ==
'$' || c2 ==
'@' || c2 ==
'{') {
19200 else if (c ==
'\\') {
19204 if (func & STR_FUNC_QWORDS)
break;
19205 if (func & STR_FUNC_EXPAND) {
19206 if (!(func & STR_FUNC_INDENT) || (p->heredoc_indent < 0))
19217 if (func & STR_FUNC_ESCAPE) tokadd(p, c);
19221 if ((func & STR_FUNC_EXPAND) == 0) {
19225 tokadd_utf8(p, enc, term,
19226 func & STR_FUNC_SYMBOL,
19227 func & STR_FUNC_REGEXP);
19231 if (c == -1)
return -1;
19233 if ((func & STR_FUNC_EXPAND) == 0) tokadd(p,
'\\');
19236 if (func & STR_FUNC_REGEXP) {
19242 c = read_escape(p, 0, p->lex.pcur - 1);
19247 *t++ = nibble_char_upper(c >> 4);
19248 *t++ = nibble_char_upper(c);
19253 if (c == term && !simple_re_meta(c)) {
19258 if ((c = tokadd_escape(p)) < 0)
19260 if (*enc && *enc != *encp) {
19261 mixed_escape(p->lex.ptok+2, *enc, *encp);
19265 else if (func & STR_FUNC_EXPAND) {
19267 if (func & STR_FUNC_ESCAPE) tokadd(p,
'\\');
19268 c = read_escape(p, 0, p->lex.pcur - 1);
19270 else if ((func & STR_FUNC_QWORDS) &&
ISSPACE(c)) {
19273 else if (c != term && !(paren && c == paren)) {
19280 else if (!parser_isascii(p)) {
19285 else if (*enc != *encp) {
19286 mixed_error(*enc, *encp);
19289 if (tokadd_mbchar(p, c) == -1)
return -1;
19292 else if ((func & STR_FUNC_QWORDS) &&
ISSPACE(c)) {
19300 else if (*enc != *encp) {
19301 mixed_error(*enc, *encp);
19307 top_of_line = (c ==
'\n');
19311 if (*enc) *encp = *enc;
19315 #define NEW_STRTERM(func, term, paren) new_strterm(p, func, term, paren)
19320 p->lex.pcur -= back;
19321 if (has_delayed_token(p)) {
19322 ptrdiff_t
len = p->lex.pcur - p->lex.ptok;
19324 rb_parser_enc_str_buf_cat(p, p->delayed.token, p->lex.ptok,
len, enc);
19325 p->delayed.end_line = p->ruby_sourceline;
19326 p->delayed.end_col =
rb_long2int(p->lex.pcur - p->lex.pbeg);
19328 dispatch_delayed_token(p, tSTRING_CONTENT);
19329 p->lex.ptok = p->lex.pcur;
19331 dispatch_scan_event(p, tSTRING_CONTENT);
19332 p->lex.pcur += back;
19338 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
19339 #define SPECIAL_PUNCT(idx) ( \
19340 BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
19341 BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
19342 BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
19343 BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
19344 BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
19346 const uint_least32_t ruby_global_name_punct_bits[] = {
19352 #undef SPECIAL_PUNCT
19355 static enum yytokentype
19356 parser_peek_variable_name(struct parser_params *p)
19359 const char *ptr = p->lex.pcur;
19361 if (lex_eol_ptr_n_p(p, ptr, 1)) return 0;
19365 if ((c = *ptr) == '-') {
19366 if (lex_eol_ptr_p(p, ++ptr)) return 0;
19369 else if (is_global_name_punct(c) || ISDIGIT(c)) {
19370 return tSTRING_DVAR;
19374 if ((c = *ptr) == '@') {
19375 if (lex_eol_ptr_p(p, ++ptr)) return 0;
19381 p->command_start = TRUE;
19382 yylval.state = p->lex.state;
19383 return tSTRING_DBEG;
19387 if (!ISASCII(c) || c == '_' || ISALPHA(c))
19388 return tSTRING_DVAR;
19392 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
19393 #define IS_END() IS_lex_state(EXPR_END_ANY)
19394 #define IS_BEG() (IS_lex_state(EXPR_BEG_ANY) || IS_lex_state_all(EXPR_ARG|EXPR_LABELED))
19395 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
19396 #define IS_LABEL_POSSIBLE() (\
19397 (IS_lex_state(EXPR_LABEL|EXPR_ENDFN) && !cmd_state) || \
19399 #define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1))
19400 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
19402 static inline enum yytokentype
19403 parser_string_term(struct parser_params *p, int func)
19405 xfree(p->lex.strterm);
19406 p->lex.strterm = 0;
19407 if (func & STR_FUNC_REGEXP) {
19408 set_yylval_num(regx_options(p));
19409 dispatch_scan_event(p, tREGEXP_END);
19410 SET_LEX_STATE(EXPR_END);
19411 return tREGEXP_END;
19413 if ((func & STR_FUNC_LABEL) && IS_LABEL_SUFFIX(0)) {
19415 SET_LEX_STATE(EXPR_ARG|EXPR_LABELED);
19418 SET_LEX_STATE(EXPR_END);
19419 return tSTRING_END;
19422 static enum yytokentype
19423 parse_string(struct parser_params *p, rb_strterm_literal_t *quote)
19425 int func = quote->func;
19426 int term = quote->term;
19427 int paren = quote->paren;
19429 rb_encoding *enc = p->enc;
19430 rb_encoding *base_enc = 0;
19431 rb_parser_string_t *lit;
19433 if (func & STR_FUNC_TERM) {
19434 if (func & STR_FUNC_QWORDS) nextc(p); /* delayed term */
19435 SET_LEX_STATE(EXPR_END);
19436 xfree(p->lex.strterm);
19437 p->lex.strterm = 0;
19438 return func & STR_FUNC_REGEXP ? tREGEXP_END : tSTRING_END;
19441 if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
19442 while (c != '\n' && ISSPACE(c = nextc(p)));
19445 if (func & STR_FUNC_LIST) {
19446 quote->func &= ~STR_FUNC_LIST;
19449 if (c == term && !quote->nest) {
19450 if (func & STR_FUNC_QWORDS) {
19451 quote->func |= STR_FUNC_TERM;
19452 pushback(p, c); /* dispatch the term at tSTRING_END */
19453 add_delayed_token(p, p->lex.ptok, p->lex.pcur);
19456 return parser_string_term(p, func);
19459 if (!ISSPACE(c)) pushback(p, c);
19460 add_delayed_token(p, p->lex.ptok, p->lex.pcur);
19464 if ((func & STR_FUNC_EXPAND) && c == '#') {
19465 enum yytokentype t = parser_peek_variable_name(p);
19471 if (tokadd_string(p, func, term, paren, "e->nest,
19472 &enc, &base_enc) == -1) {
19475 # define unterminated_literal(mesg) yyerror0(mesg)
19477 # define unterminated_literal(mesg) compile_error(p, mesg)
19479 literal_flush(p, p->lex.pcur);
19480 if (func & STR_FUNC_QWORDS) {
19481 /* no content to add, bailing out here */
19482 unterminated_literal("unterminated list meets end of file");
19483 xfree(p->lex.strterm);
19484 p->lex.strterm = 0;
19485 return tSTRING_END;
19487 if (func & STR_FUNC_REGEXP) {
19488 unterminated_literal("unterminated regexp meets end of file");
19491 unterminated_literal("unterminated string meets end of file");
19493 quote->func |= STR_FUNC_TERM;
19498 lit = STR_NEW3(tok(p), toklen(p), enc, func);
19499 set_yylval_str(lit);
19500 flush_string_content(p, enc, 0);
19502 return tSTRING_CONTENT;
19505 static enum yytokentype
19506 heredoc_identifier(struct parser_params *p)
19509 * term_len is length of `<<"END"` except `END`,
19510 * in this case term_len is 4 (<, <, " and ").
19512 long len, offset = p->lex.pcur - p->lex.pbeg;
19513 int c = nextc(p), term, func = 0, quote = 0;
19514 enum yytokentype token = tSTRING_BEG;
19519 func = STR_FUNC_INDENT;
19522 else if (c == '~') {
19524 func = STR_FUNC_INDENT;
19530 func |= str_squote; goto quoted;
19532 func |= str_dquote;
goto quoted;
19534 token = tXSTRING_BEG;
19535 func |= str_xquote;
goto quoted;
19542 while ((c = nextc(p)) != term) {
19543 if (c == -1 || c ==
'\r' || c ==
'\n') {
19544 yyerror0(
"unterminated here document identifier");
19551 if (!parser_is_identchar(p)) {
19553 if (func & STR_FUNC_INDENT) {
19554 pushback(p, indent > 0 ?
'~' :
'-');
19558 func |= str_dquote;
19560 int n = parser_precise_mbclen(p, p->lex.pcur-1);
19561 if (n < 0)
return 0;
19562 p->lex.pcur += --n;
19563 }
while ((c = nextc(p)) != -1 && parser_is_identchar(p));
19568 len = p->lex.pcur - (p->lex.pbeg + offset) - quote;
19569 if ((
unsigned long)
len >= HERETERM_LENGTH_MAX)
19570 yyerror0(
"too long here document identifier");
19571 dispatch_scan_event(p, tHEREDOC_BEG);
19574 p->lex.strterm = new_heredoc(p);
19576 here->offset = offset;
19577 here->sourceline = p->ruby_sourceline;
19578 here->length = (unsigned)
len;
19579 here->quote = quote;
19581 here->lastline = p->lex.lastline;
19584 p->heredoc_indent = indent;
19585 p->heredoc_line_indent = 0;
19595 p->lex.strterm = 0;
19596 line = here->lastline;
19597 p->lex.lastline = line;
19598 p->lex.pbeg = PARSER_STRING_PTR(line);
19599 p->lex.pend = p->lex.pbeg + PARSER_STRING_LEN(line);
19600 p->lex.pcur = p->lex.pbeg + here->offset + here->length + here->quote;
19601 p->lex.ptok = p->lex.pbeg + here->offset - here->quote;
19602 p->heredoc_end = p->ruby_sourceline;
19603 p->ruby_sourceline = (int)here->sourceline;
19604 if (p->eofp) p->lex.nextline = AFTER_HEREDOC_WITHOUT_TERMINTOR;
19610 dedent_string_column(
const char *str,
long len,
int width)
19614 for (i = 0; i <
len && col < width; i++) {
19615 if (str[i] ==
' ') {
19618 else if (str[i] ==
'\t') {
19619 int n = TAB_WIDTH * (col / TAB_WIDTH + 1);
19620 if (n > width)
break;
19638 len = PARSER_STRING_LEN(
string);
19639 str = PARSER_STRING_PTR(
string);
19641 i = dedent_string_column(str,
len, width);
19644 rb_parser_str_modify(
string);
19645 str = PARSER_STRING_PTR(
string);
19646 if (PARSER_STRING_LEN(
string) !=
len)
19647 rb_fatal(
"literal string changed: %s", PARSER_STRING_PTR(
string));
19649 rb_parser_str_set_len(p,
string,
len - i);
19656 NODE *node, *str_node, *prev_node;
19657 int indent = p->heredoc_indent;
19660 if (indent <= 0)
return root;
19661 if (!root)
return root;
19663 prev_node = node = str_node = root;
19664 if (nd_type_p(root, NODE_LIST)) str_node = RNODE_LIST(root)->nd_head;
19668 if (nd_fl_newline(str_node)) {
19669 dedent_string(p, lit, indent);
19674 else if (!literal_concat0(p, prev_lit, lit)) {
19678 NODE *end = RNODE_LIST(node)->as.nd_end;
19679 node = RNODE_LIST(prev_node)->nd_next = RNODE_LIST(node)->nd_next;
19681 if (nd_type_p(prev_node, NODE_DSTR))
19682 nd_set_type(prev_node, NODE_STR);
19685 RNODE_LIST(node)->as.nd_end = end;
19690 while ((nd_type_p(node, NODE_LIST) || nd_type_p(node, NODE_DSTR)) && (node = RNODE_LIST(prev_node = node)->nd_next) != 0) {
19692 if (!nd_type_p(node, NODE_LIST))
break;
19693 if ((str_node = RNODE_LIST(node)->nd_head) != 0) {
19694 enum node_type
type = nd_type(str_node);
19695 if (
type == NODE_STR ||
type == NODE_DSTR)
break;
19705 whole_match_p(
struct parser_params *p,
const char *eos,
long len,
int indent)
19707 const char *beg = p->lex.pbeg;
19708 const char *
ptr = p->lex.pend;
19710 if (
ptr - beg <
len)
return FALSE;
19711 if (
ptr > beg &&
ptr[-1] ==
'\n') {
19712 if (--
ptr > beg &&
ptr[-1] ==
'\r') --
ptr;
19713 if (
ptr - beg <
len)
return FALSE;
19715 if (strncmp(eos,
ptr -=
len,
len))
return FALSE;
19725 if (strncmp(p->lex.pcur, word,
len))
return 0;
19726 if (lex_eol_n_p(p,
len))
return 1;
19727 int c = (
unsigned char)p->lex.pcur[
len];
19730 case '\0':
case '\004':
case '\032':
return 1;
19735 #define NUM_SUFFIX_R (1<<0)
19736 #define NUM_SUFFIX_I (1<<1)
19737 #define NUM_SUFFIX_ALL 3
19743 const char *lastp = p->lex.pcur;
19745 while ((c = nextc(p)) != -1) {
19746 if ((mask & NUM_SUFFIX_I) && c ==
'i') {
19747 result |= (mask & NUM_SUFFIX_I);
19748 mask &= ~NUM_SUFFIX_I;
19750 mask &= ~NUM_SUFFIX_R;
19753 if ((mask & NUM_SUFFIX_R) && c ==
'r') {
19754 result |= (mask & NUM_SUFFIX_R);
19755 mask &= ~NUM_SUFFIX_R;
19759 p->lex.pcur = lastp;
19760 literal_flush(p, p->lex.pcur);
19769 static enum yytokentype
19770 set_number_literal(
struct parser_params *p,
enum yytokentype
type,
int suffix,
int base,
int seen_point)
19772 enum rb_numeric_type numeric_type = integer_literal;
19774 if (
type == tFLOAT) {
19775 numeric_type = float_literal;
19778 if (suffix & NUM_SUFFIX_R) {
19780 numeric_type = rational_literal;
19782 if (suffix & NUM_SUFFIX_I) {
19788 set_yylval_node(NEW_INTEGER(
strdup(tok(p)), base, &_cur_loc));
19791 set_yylval_node(NEW_FLOAT(
strdup(tok(p)), &_cur_loc));
19794 set_yylval_node(NEW_RATIONAL(
strdup(tok(p)), base, seen_point, &_cur_loc));
19797 set_yylval_node(NEW_IMAGINARY(
strdup(tok(p)), base, seen_point, numeric_type, &_cur_loc));
19798 (void)numeric_type;
19803 SET_LEX_STATE(EXPR_END);
19807 #define dispatch_heredoc_end(p) parser_dispatch_heredoc_end(p, __LINE__)
19809 parser_dispatch_heredoc_end(
struct parser_params *p,
int line)
19811 if (has_delayed_token(p))
19812 dispatch_delayed_token(p, tSTRING_CONTENT);
19815 VALUE str = STR_NEW(p->lex.ptok, p->lex.pend - p->lex.ptok);
19816 ripper_dispatch1(p, ripper_token2eventid(tHEREDOC_END), str);
19818 if (p->keep_tokens) {
19819 rb_parser_string_t *str = rb_parser_encoding_string_new(p, p->lex.ptok, p->lex.pend - p->lex.ptok, p->enc);
19820 RUBY_SET_YYLLOC_OF_HEREDOC_END(*p->yylloc);
19821 parser_append_tokens(p, str, tHEREDOC_END, line);
19825 RUBY_SET_YYLLOC_FROM_STRTERM_HEREDOC(*p->yylloc);
19830 static enum yytokentype
19833 int c, func, indent = 0;
19834 const char *eos, *
ptr, *ptr_end;
19844 eos = PARSER_STRING_PTR(here->lastline) + here->offset;
19845 len = here->length;
19846 indent = (func = here->func) & STR_FUNC_INDENT;
19848 if ((c = nextc(p)) == -1) {
19851 if (!has_delayed_token(p)) {
19852 dispatch_scan_event(p, tSTRING_CONTENT);
19855 if ((
len = p->lex.pcur - p->lex.ptok) > 0) {
19856 if (!(func & STR_FUNC_REGEXP)) {
19860 rb_is_usascii_enc(p->enc) &&
19865 rb_parser_enc_str_buf_cat(p, p->delayed.token, p->lex.ptok,
len, enc);
19867 dispatch_delayed_token(p, tSTRING_CONTENT);
19871 heredoc_restore(p, &p->lex.strterm->u.heredoc);
19872 compile_error(p,
"can't find string \"%.*s\" anywhere before EOF",
19875 SET_LEX_STATE(EXPR_END);
19876 return tSTRING_END;
19882 else if (p->heredoc_line_indent == -1) {
19887 p->heredoc_line_indent = 0;
19889 else if (whole_match_p(p, eos,
len, indent)) {
19890 dispatch_heredoc_end(p);
19892 heredoc_restore(p, &p->lex.strterm->u.heredoc);
19894 SET_LEX_STATE(EXPR_END);
19895 return tSTRING_END;
19898 if (!(func & STR_FUNC_EXPAND)) {
19900 ptr = PARSER_STRING_PTR(p->lex.lastline);
19901 ptr_end = p->lex.pend;
19902 if (ptr_end >
ptr) {
19903 switch (ptr_end[-1]) {
19905 if (--ptr_end ==
ptr || ptr_end[-1] !=
'\r') {
19914 if (p->heredoc_indent > 0) {
19916 while (
ptr + i < ptr_end && parser_update_heredoc_indent(p,
ptr[i]))
19918 p->heredoc_line_indent = 0;
19922 parser_str_cat(str,
ptr, ptr_end -
ptr);
19924 str = rb_parser_encoding_string_new(p,
ptr, ptr_end -
ptr, enc);
19925 if (!lex_eol_ptr_p(p, ptr_end)) parser_str_cat_cstr(str,
"\n");
19927 if (p->heredoc_indent > 0) {
19930 if (nextc(p) == -1) {
19932 rb_parser_string_free(p, str);
19937 }
while (!whole_match_p(p, eos,
len, indent));
19943 enum yytokentype t = parser_peek_variable_name(p);
19944 if (p->heredoc_line_indent != -1) {
19945 if (p->heredoc_indent > p->heredoc_line_indent) {
19946 p->heredoc_indent = p->heredoc_line_indent;
19948 p->heredoc_line_indent = -1;
19957 if ((c = tokadd_string(p, func,
'\n', 0, NULL, &enc, &base_enc)) == -1) {
19958 if (p->eofp)
goto error;
19962 if (c ==
'\\') p->heredoc_line_indent = -1;
19964 str = STR_NEW3(tok(p), toklen(p), enc, func);
19966 set_yylval_str(str);
19968 if (bol) nd_set_fl_newline(yylval.node);
19970 flush_string_content(p, enc, 0);
19971 return tSTRING_CONTENT;
19973 tokadd(p, nextc(p));
19974 if (p->heredoc_indent > 0) {
19979 if ((c = nextc(p)) == -1)
goto error;
19980 }
while (!whole_match_p(p, eos,
len, indent));
19981 str = STR_NEW3(tok(p), toklen(p), enc, func);
19983 dispatch_heredoc_end(p);
19984 heredoc_restore(p, &p->lex.strterm->u.heredoc);
19986 p->lex.strterm = NEW_STRTERM(func | STR_FUNC_TERM, 0, 0);
19989 s_value = p->s_value;
19991 set_yylval_str(str);
19993 set_parser_s_value(s_value);
19997 if (bol) nd_set_fl_newline(yylval.node);
19999 return tSTRING_CONTENT;
20009 rb_warning1(
"ambiguity between regexp and two divisions: wrap regexp in parentheses or add a space after '%c' operator", WARN_I(c));
20012 rb_warning1(
"ambiguous first argument; put parentheses or a space even after '%c' operator", WARN_I(c));
20025 switch (id_type(
id)) {
20029 # define ERR(mesg) (yyerror0(mesg), Qtrue)
20031 # define ERR(mesg) WARN_S(mesg)
20034 return ERR(
"formal argument cannot be a constant");
20036 return ERR(
"formal argument cannot be an instance variable");
20038 return ERR(
"formal argument cannot be a global variable");
20040 return ERR(
"formal argument cannot be a class variable");
20042 return ERR(
"formal argument must be local variable");
20045 shadowing_lvar(p,
id);
20053 return (dyna_in_block(p) && dvar_defined(p,
id)) || local_id(p,
id);
20062 if (
len > 5 && name[nlen =
len - 5] ==
'-') {
20063 if (
rb_memcicmp(name + nlen + 1,
"unix", 4) == 0)
20066 if (
len > 4 && name[nlen =
len - 4] ==
'-') {
20069 if (
rb_memcicmp(name + nlen + 1,
"mac", 3) == 0 &&
20078 parser_set_encode(
struct parser_params *p,
const char *name)
20084 const char *wrong = 0;
20086 case 'e':
case 'E': wrong =
"external";
break;
20087 case 'i':
case 'I': wrong =
"internal";
break;
20088 case 'f':
case 'F': wrong =
"filesystem";
break;
20089 case 'l':
case 'L': wrong =
"locale";
break;
20091 if (wrong &&
STRCASECMP(name, wrong) == 0)
goto unknown;
20095 excargs[1] =
rb_sprintf(
"unknown encoding name: %s", name);
20101 ruby_show_error_line(p, exc, &(
YYLTYPE)RUBY_INIT_YYLLOC(), p->ruby_sourceline, p->lex.lastline);
20103 rb_ast_free(p->ast);
20115 if (p->debug_lines) {
20117 for (i = 0; i < p->debug_lines->len; i++) {
20118 rb_parser_enc_associate(p, p->debug_lines->data[i], enc);
20127 if (p->token_seen)
return false;
20128 return (p->line_count == (p->has_shebang ? 2 : 1));
20131 typedef long (*rb_magic_comment_length_t)(
struct parser_params *p,
const char *name,
long len);
20132 typedef void (*rb_magic_comment_setter_t)(
struct parser_params *p,
const char *name,
const char *val);
20134 static int parser_invalid_pragma_value(
struct parser_params *p,
const char *name,
const char *val);
20137 magic_comment_encoding(
struct parser_params *p,
const char *name,
const char *val)
20139 if (!comment_at_top(p)) {
20142 parser_set_encode(p, val);
20146 parser_get_bool(
struct parser_params *p,
const char *name,
const char *val)
20149 case 't':
case 'T':
20154 case 'f':
case 'F':
20160 return parser_invalid_pragma_value(p, name, val);
20164 parser_invalid_pragma_value(
struct parser_params *p,
const char *name,
const char *val)
20166 rb_warning2(
"invalid value for %s: %s", WARN_S(name), WARN_S(val));
20171 parser_set_token_info(
struct parser_params *p,
const char *name,
const char *val)
20173 int b = parser_get_bool(p, name, val);
20174 if (b >= 0) p->token_info_enabled = b;
20178 parser_set_frozen_string_literal(
struct parser_params *p,
const char *name,
const char *val)
20182 if (p->token_seen) {
20183 rb_warning1(
"'%s' is ignored after any tokens", WARN_S(name));
20187 b = parser_get_bool(p, name, val);
20190 p->frozen_string_literal = b;
20194 parser_set_shareable_constant_value(
struct parser_params *p,
const char *name,
const char *val)
20196 for (
const char *s = p->lex.pbeg, *e = p->lex.pcur; s < e; ++s) {
20197 if (*s ==
' ' || *s ==
'\t')
continue;
20198 if (*s ==
'#')
break;
20199 rb_warning1(
"'%s' is ignored unless in comment-only line", WARN_S(name));
20204 case 'n':
case 'N':
20206 p->ctxt.shareable_constant_value = rb_parser_shareable_none;
20210 case 'l':
case 'L':
20212 p->ctxt.shareable_constant_value = rb_parser_shareable_literal;
20216 case 'e':
case 'E':
20217 if (
STRCASECMP(val,
"experimental_copy") == 0) {
20218 p->ctxt.shareable_constant_value = rb_parser_shareable_copy;
20221 if (
STRCASECMP(val,
"experimental_everything") == 0) {
20222 p->ctxt.shareable_constant_value = rb_parser_shareable_everything;
20227 parser_invalid_pragma_value(p, name, val);
20230 # if WARN_PAST_SCOPE
20232 parser_set_past_scope(
struct parser_params *p,
const char *name,
const char *val)
20234 int b = parser_get_bool(p, name, val);
20235 if (b >= 0) p->past_scope_enabled = b;
20241 rb_magic_comment_setter_t func;
20242 rb_magic_comment_length_t length;
20246 {
"coding", magic_comment_encoding, parser_encode_length},
20247 {
"encoding", magic_comment_encoding, parser_encode_length},
20248 {
"frozen_string_literal", parser_set_frozen_string_literal},
20249 {
"shareable_constant_value", parser_set_shareable_constant_value},
20250 {
"warn_indent", parser_set_token_info},
20251 # if WARN_PAST_SCOPE
20252 {
"warn_past_scope", parser_set_past_scope},
20256 static const char *
20257 magic_comment_marker(
const char *str,
long len)
20264 if (str[i-1] ==
'*' && str[i-2] ==
'-') {
20265 return str + i + 1;
20270 if (i + 1 >=
len)
return 0;
20271 if (str[i+1] !=
'-') {
20274 else if (str[i-1] !=
'-') {
20278 return str + i + 2;
20293 VALUE name = 0, val = 0;
20294 const char *beg, *end, *vbeg, *vend;
20295 #define str_copy(_s, _p, _n) ((_s) \
20296 ? (void)(rb_str_resize((_s), (_n)), \
20297 MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
20298 : (void)((_s) = STR_NEW((_p), (_n))))
20300 if (
len <= 7)
return FALSE;
20301 if (!!(beg = magic_comment_marker(str,
len))) {
20302 if (!(end = magic_comment_marker(beg, str +
len - beg)))
20306 len = end - beg - 3;
20316 for (;
len > 0 && *str; str++, --
len) {
20318 case '\'':
case '"':
case ':':
case ';':
20323 for (beg = str;
len > 0; str++, --
len) {
20325 case '\'':
case '"':
case ':':
case ';':
20336 if (!indicator)
return FALSE;
20340 do str++;
while (--
len > 0 &&
ISSPACE(*str));
20342 const char *tok_beg = str;
20344 for (vbeg = ++str; --
len > 0 && *str !=
'"'; str++) {
20345 if (*str ==
'\\') {
20357 for (vbeg = str;
len > 0 && *str !=
'"' && *str !=
';' && !
ISSPACE(*str); --
len, str++);
20360 const char *tok_end = str;
20362 while (
len > 0 && (*str ==
';' ||
ISSPACE(*str))) --
len, str++;
20366 if (
len)
return FALSE;
20370 str_copy(name, beg, n);
20372 for (i = 0; i < n; ++i) {
20373 if (s[i] ==
'-') s[i] =
'_';
20376 if (
STRNCASECMP(mc->name, s, n) == 0 && !mc->name[n]) {
20379 n = (*mc->length)(p, vbeg, n);
20381 str_copy(val, vbeg, n);
20382 p->lex.ptok = tok_beg;
20383 p->lex.pcur = tok_end;
20387 }
while (++mc < magic_comments + numberof(magic_comments));
20389 str_copy(val, vbeg, vend - vbeg);
20398 set_file_encoding(
struct parser_params *p,
const char *str,
const char *send)
20401 const char *beg = str;
20405 if (send - str <= 6)
return;
20407 case 'C':
case 'c': str += 6;
continue;
20408 case 'O':
case 'o': str += 5;
continue;
20409 case 'D':
case 'd': str += 4;
continue;
20410 case 'I':
case 'i': str += 3;
continue;
20411 case 'N':
case 'n': str += 2;
continue;
20412 case 'G':
case 'g': str += 1;
continue;
20413 case '=':
case ':':
20427 if (++str >= send)
return;
20430 if (*str !=
'=' && *str !=
':')
return;
20435 while ((*str ==
'-' || *str ==
'_' ||
ISALNUM(*str)) && ++str < send);
20436 s =
rb_str_new(beg, parser_encode_length(p, beg, str - beg));
20446 int c = nextc0(p, FALSE);
20450 if (peek(p,
'!')) p->has_shebang = 1;
20453 if (!lex_eol_n_p(p, 2) &&
20454 (
unsigned char)p->lex.pcur[0] == 0xbb &&
20455 (
unsigned char)p->lex.pcur[1] == 0xbf) {
20459 if (p->debug_lines) {
20460 rb_parser_string_set_encoding(p->lex.lastline, p->enc);
20463 p->lex.pbeg = p->lex.pcur;
20472 p->enc = rb_parser_str_get_encoding(p->lex.lastline);
20476 #define ambiguous_operator(tok, op, syn) ( \
20477 rb_warning0("'"op"' after local variable or literal is interpreted as binary operator"), \
20478 rb_warning0("even though it seems like "syn""))
20480 #define ambiguous_operator(tok, op, syn) \
20481 dispatch2(operator_ambiguous, TOKEN2VAL(tok), rb_str_new_cstr(syn))
20483 #define warn_balanced(tok, op, syn) ((void) \
20484 (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN) && \
20485 space_seen && !ISSPACE(c) && \
20486 (ambiguous_operator(tok, op, syn), 0)), \
20487 (enum yytokentype)(tok))
20489 static enum yytokentype
20492 yyerror0(
"numeric literal without digits");
20493 if (peek(p,
'_')) nextc(p);
20495 return set_number_literal(p, tINTEGER, 0, 10, 0);
20498 static enum yytokentype
20501 int is_float, seen_point, seen_e, nondigit;
20504 is_float = seen_point = seen_e = nondigit = 0;
20505 SET_LEX_STATE(EXPR_END);
20507 if (c ==
'-' || c ==
'+') {
20512 int start = toklen(p);
20514 if (c ==
'x' || c ==
'X') {
20520 if (nondigit)
break;
20527 }
while ((c = nextc(p)) != -1);
20531 if (toklen(p) == start) {
20532 return no_digits(p);
20534 else if (nondigit)
goto trailing_uc;
20535 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
20536 return set_number_literal(p, tINTEGER, suffix, 16, 0);
20538 if (c ==
'b' || c ==
'B') {
20541 if (c ==
'0' || c ==
'1') {
20544 if (nondigit)
break;
20548 if (c !=
'0' && c !=
'1')
break;
20551 }
while ((c = nextc(p)) != -1);
20555 if (toklen(p) == start) {
20556 return no_digits(p);
20558 else if (nondigit)
goto trailing_uc;
20559 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
20560 return set_number_literal(p, tINTEGER, suffix, 2, 0);
20562 if (c ==
'd' || c ==
'D') {
20568 if (nondigit)
break;
20575 }
while ((c = nextc(p)) != -1);
20579 if (toklen(p) == start) {
20580 return no_digits(p);
20582 else if (nondigit)
goto trailing_uc;
20583 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
20584 return set_number_literal(p, tINTEGER, suffix, 10, 0);
20590 if (c ==
'o' || c ==
'O') {
20593 if (c == -1 || c ==
'_' || !
ISDIGIT(c)) {
20595 return no_digits(p);
20598 if (c >=
'0' && c <=
'7') {
20603 if (nondigit)
break;
20607 if (c < '0' || c >
'9')
break;
20608 if (c >
'7')
goto invalid_octal;
20611 }
while ((c = nextc(p)) != -1);
20612 if (toklen(p) > start) {
20615 if (nondigit)
goto trailing_uc;
20616 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
20617 return set_number_literal(p, tINTEGER, suffix, 8, 0);
20624 if (c >
'7' && c <=
'9') {
20626 yyerror0(
"Invalid octal digit");
20628 else if (c ==
'.' || c ==
'e' || c ==
'E') {
20634 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
20635 return set_number_literal(p, tINTEGER, suffix, 10, 0);
20641 case '0':
case '1':
case '2':
case '3':
case '4':
20642 case '5':
case '6':
case '7':
case '8':
case '9':
20648 if (nondigit)
goto trailing_uc;
20649 if (seen_point || seen_e) {
20654 if (c0 == -1 || !
ISDIGIT(c0)) {
20660 seen_point = toklen(p);
20679 if (c !=
'-' && c !=
'+' && !
ISDIGIT(c)) {
20685 tokadd(p, nondigit);
20689 nondigit = (c ==
'-' || c ==
'+') ? c : 0;
20693 if (nondigit)
goto decode_num;
20707 literal_flush(p, p->lex.pcur - 1);
20708 YYLTYPE loc = RUBY_INIT_YYLLOC();
20709 compile_error(p,
"trailing '%c' in number", nondigit);
20710 parser_show_error_line(p, &loc);
20714 enum yytokentype
type = tFLOAT;
20716 suffix = number_literal_suffix(p, seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
20717 if (suffix & NUM_SUFFIX_R) {
20722 if (
errno == ERANGE) {
20723 rb_warning1(
"Float %s out of range", WARN_S(tok(p)));
20727 return set_number_literal(p,
type, suffix, 0, seen_point);
20729 suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
20730 return set_number_literal(p, tINTEGER, suffix, 10, 0);
20733 static enum yytokentype
20741 SET_LEX_STATE(EXPR_VALUE);
20746 compile_error(p,
"incomplete character syntax");
20751 int c2 = escaped_control_code(c);
20753 WARN_SPACE_CHAR(c2,
"?");
20758 SET_LEX_STATE(EXPR_VALUE);
20763 if (!parser_isascii(p)) {
20764 if (tokadd_mbchar(p, c) == -1)
return 0;
20767 !lex_eol_p(p) && is_identchar(p, p->lex.pcur, p->lex.pend, p->enc)) {
20769 const char *start = p->lex.pcur - 1, *
ptr = start;
20771 int n = parser_precise_mbclen(p,
ptr);
20772 if (n < 0)
return -1;
20774 }
while (!lex_eol_ptr_p(p,
ptr) && is_identchar(p,
ptr, p->lex.pend, p->enc));
20775 rb_warn2(
"'?' just followed by '%.*s' is interpreted as" \
20776 " a conditional operator, put a space after '?'",
20777 WARN_I((
int)(
ptr - start)), WARN_S_L(start, (
ptr - start)));
20781 else if (c ==
'\\') {
20782 if (peek(p,
'u')) {
20785 tokadd_utf8(p, &enc, -1, 0, 0);
20787 else if (!
ISASCII(c = peekc(p)) && c != -1) {
20789 if (tokadd_mbchar(p, c) == -1)
return 0;
20800 lit = STR_NEW3(tok(p), toklen(p), enc, 0);
20801 set_yylval_str(lit);
20802 SET_LEX_STATE(EXPR_END);
20806 static enum yytokentype
20807 parse_percent(
struct parser_params *p,
const int space_seen,
const enum lex_state_e last_state)
20810 const char *ptok = p->lex.pcur;
20818 if (c == -1)
goto unterminated;
20821 if (!
ISASCII(c))
goto unknown;
20829 c = parser_precise_mbclen(p, p->lex.pcur);
20830 if (c < 0)
return 0;
20832 yyerror0(
"unknown type of %string");
20838 compile_error(p,
"unterminated quoted string meets end of file");
20842 if (term ==
'(') term =
')';
20843 else if (term ==
'[') term =
']';
20844 else if (term ==
'{') term =
'}';
20845 else if (term ==
'<') term =
'>';
20848 p->lex.ptok = ptok-1;
20851 p->lex.strterm = NEW_STRTERM(str_dquote, term, paren);
20852 return tSTRING_BEG;
20855 p->lex.strterm = NEW_STRTERM(str_squote, term, paren);
20856 return tSTRING_BEG;
20859 p->lex.strterm = NEW_STRTERM(str_dword, term, paren);
20863 p->lex.strterm = NEW_STRTERM(str_sword, term, paren);
20864 return tQWORDS_BEG;
20867 p->lex.strterm = NEW_STRTERM(str_dword, term, paren);
20868 return tSYMBOLS_BEG;
20871 p->lex.strterm = NEW_STRTERM(str_sword, term, paren);
20872 return tQSYMBOLS_BEG;
20875 p->lex.strterm = NEW_STRTERM(str_xquote, term, paren);
20876 return tXSTRING_BEG;
20879 p->lex.strterm = NEW_STRTERM(str_regexp, term, paren);
20880 return tREGEXP_BEG;
20883 p->lex.strterm = NEW_STRTERM(str_ssym, term, paren);
20884 SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);
20888 yyerror0(
"unknown type of %string");
20892 if ((c = nextc(p)) ==
'=') {
20893 set_yylval_id(
'%');
20894 SET_LEX_STATE(EXPR_BEG);
20897 if (IS_SPCARG(c) || (IS_lex_state(EXPR_FITEM) && c ==
's')) {
20900 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
20902 return warn_balanced(
'%',
"%%",
"string literal");
20909 if (tokadd_mbchar(p, c) == -1)
return -1;
20911 }
while (parser_is_identchar(p));
20919 ID ident = TOK_INTERN();
20921 set_yylval_name(ident);
20932 const unsigned long nth_ref_max =
20933 ((FIXNUM_MAX < INT_MAX) ? FIXNUM_MAX : INT_MAX) >> 1;
20937 if (overflow || n > nth_ref_max) {
20939 rb_warn1(
"'%s' is too big for a number variable, always nil", WARN_S(tok(p)));
20947 static enum yytokentype
20948 parse_gvar(
struct parser_params *p,
const enum lex_state_e last_state)
20950 const char *
ptr = p->lex.pcur;
20953 SET_LEX_STATE(EXPR_END);
20954 p->lex.ptok =
ptr - 1;
20960 if (parser_is_identchar(p)) {
20992 if (parser_is_identchar(p)) {
20993 if (tokadd_mbchar(p, c) == -1)
return 0;
21008 if (IS_lex_state_for(last_state, EXPR_FNAME)) {
21013 set_yylval_node(NEW_BACK_REF(c, &_cur_loc));
21016 case '1':
case '2':
case '3':
21017 case '4':
case '5':
case '6':
21018 case '7':
case '8':
case '9':
21023 }
while (c != -1 &&
ISDIGIT(c));
21025 if (IS_lex_state_for(last_state, EXPR_FNAME))
goto gvar;
21027 c = parse_numvar(p);
21028 set_yylval_node(NEW_NTH_REF(c, &_cur_loc));
21032 if (!parser_is_identchar(p)) {
21033 YYLTYPE loc = RUBY_INIT_YYLLOC();
21035 compile_error(p,
"'$' without identifiers is not allowed as a global variable name");
21039 compile_error(p,
"'$%c' is not allowed as a global variable name", c);
21041 parser_show_error_line(p, &loc);
21042 set_yylval_noname();
21050 if (tokadd_ident(p, c))
return 0;
21051 SET_LEX_STATE(EXPR_END);
21052 if (VALID_SYMNAME_P(tok(p), toklen(p), p->enc, ID_GLOBAL)) {
21056 compile_error(p,
"'%.*s' is not allowed as a global variable name", toklen(p), tok(p));
21057 set_yylval_noname();
21065 if (n < 0)
return false;
21067 if (DVARS_TERMINAL_P(p->lvtbl->args) || DVARS_TERMINAL_P(p->lvtbl->args->prev)) {
21070 if (p->max_numparam == ORDINAL_PARAM) {
21071 compile_error(p,
"ordinary parameter is defined");
21074 struct vtable *args = p->lvtbl->args;
21075 if (p->max_numparam < n) {
21076 p->max_numparam = n;
21078 while (n > args->pos) {
21079 vtable_add(args, NUMPARAM_IDX_TO_ID(args->pos+1));
21084 static enum yytokentype
21085 parse_atmark(
struct parser_params *p,
const enum lex_state_e last_state)
21087 const char *
ptr = p->lex.pcur;
21088 enum yytokentype result = tIVAR;
21089 register int c = nextc(p);
21092 p->lex.ptok =
ptr - 1;
21100 SET_LEX_STATE(IS_lex_state_for(last_state, EXPR_FNAME) ? EXPR_ENDFN : EXPR_END);
21101 if (c == -1 || !parser_is_identchar(p)) {
21103 RUBY_SET_YYLLOC(loc);
21104 if (result == tIVAR) {
21105 compile_error(p,
"'@' without identifiers is not allowed as an instance variable name");
21108 compile_error(p,
"'@@' without identifiers is not allowed as a class variable name");
21110 parser_show_error_line(p, &loc);
21111 set_yylval_noname();
21112 SET_LEX_STATE(EXPR_END);
21117 RUBY_SET_YYLLOC(loc);
21118 if (result == tIVAR) {
21119 compile_error(p,
"'@%c' is not allowed as an instance variable name", c);
21122 compile_error(p,
"'@@%c' is not allowed as a class variable name", c);
21124 parser_show_error_line(p, &loc);
21125 set_yylval_noname();
21126 SET_LEX_STATE(EXPR_END);
21130 if (tokadd_ident(p, c))
return 0;
21135 static enum yytokentype
21138 enum yytokentype result;
21139 bool is_ascii =
true;
21140 const enum lex_state_e last_state = p->lex.state;
21142 int enforce_keyword_end = 0;
21145 if (!
ISASCII(c)) is_ascii =
false;
21146 if (tokadd_mbchar(p, c) == -1)
return 0;
21148 }
while (parser_is_identchar(p));
21149 if ((c ==
'!' || c ==
'?') && !peek(p,
'=')) {
21153 else if (c ==
'=' && IS_lex_state(EXPR_FNAME) &&
21154 (!peek(p,
'~') && !peek(p,
'>') && (!peek(p,
'=') || (peek_n(p,
'>', 1))))) {
21155 result = tIDENTIFIER;
21159 result = tCONSTANT;
21164 if (IS_LABEL_POSSIBLE()) {
21165 if (IS_LABEL_SUFFIX(0)) {
21166 SET_LEX_STATE(EXPR_ARG|EXPR_LABELED);
21174 if (peek_end_expect_token_locations(p)) {
21176 int lineno, column;
21177 int beg_pos = (int)(p->lex.ptok - p->lex.pbeg);
21179 end_pos = peek_end_expect_token_locations(p)->pos;
21180 lineno = end_pos->lineno;
21181 column = end_pos->column;
21184 rb_parser_printf(p,
"enforce_keyword_end check. current: (%d, %d), peek: (%d, %d)\n",
21185 p->ruby_sourceline, beg_pos, lineno, column);
21188 if ((p->ruby_sourceline > lineno) && (beg_pos <= column)) {
21191 if ((IS_lex_state(EXPR_DOT)) && (kw = rb_reserved_word(tok(p), toklen(p))) && (kw && kw->id[0] == keyword_end)) {
21192 if (p->debug) rb_parser_printf(p,
"enforce_keyword_end is enabled\n");
21193 enforce_keyword_end = 1;
21199 if (is_ascii && (!IS_lex_state(EXPR_DOT) || enforce_keyword_end)) {
21203 kw = rb_reserved_word(tok(p), toklen(p));
21205 enum lex_state_e state = p->lex.state;
21206 if (IS_lex_state_for(state, EXPR_FNAME)) {
21207 SET_LEX_STATE(EXPR_ENDFN);
21208 set_yylval_name(
rb_intern2(tok(p), toklen(p)));
21211 SET_LEX_STATE(kw->state);
21212 if (IS_lex_state(EXPR_BEG)) {
21213 p->command_start = TRUE;
21215 if (kw->id[0] == keyword_do) {
21216 if (lambda_beginning_p()) {
21217 p->lex.lpar_beg = -1;
21218 return keyword_do_LAMBDA;
21220 if (COND_P())
return keyword_do_cond;
21221 if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
21222 return keyword_do_block;
21225 if (IS_lex_state_for(state, (EXPR_BEG | EXPR_LABELED | EXPR_CLASS)))
21228 if (kw->id[0] != kw->id[1])
21229 SET_LEX_STATE(EXPR_BEG | EXPR_LABEL);
21235 if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
21237 SET_LEX_STATE(EXPR_CMDARG);
21240 SET_LEX_STATE(EXPR_ARG);
21243 else if (p->lex.state == EXPR_FNAME) {
21244 SET_LEX_STATE(EXPR_ENDFN);
21247 SET_LEX_STATE(EXPR_END);
21250 ident = tokenize_ident(p);
21251 if (result == tCONSTANT && is_local_id(ident)) result = tIDENTIFIER;
21252 if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
21253 (result == tIDENTIFIER) &&
21254 (lvar_defined(p, ident) || NUMPARAM_ID_P(ident))) {
21255 SET_LEX_STATE(EXPR_END|EXPR_LABEL);
21266 rb_warn0(
"encountered \\r in middle of line, treated as a mere space");
21270 static enum yytokentype
21274 int space_seen = 0;
21277 enum lex_state_e last_state;
21278 int fallthru = FALSE;
21279 int token_seen = p->token_seen;
21281 if (p->lex.strterm) {
21282 if (strterm_is_heredoc(p->lex.strterm)) {
21284 return here_document(p, &p->lex.strterm->u.heredoc);
21288 return parse_string(p, &p->lex.strterm->u.literal);
21291 cmd_state = p->command_start;
21292 p->command_start = FALSE;
21293 p->token_seen = TRUE;
21298 last_state = p->lex.state;
21299 switch (c = nextc(p)) {
21306 if (p->end_expect_token_locations) {
21307 pop_end_expect_token_locations(p);
21308 RUBY_SET_YYLLOC_OF_DUMMY_END(*p->yylloc);
21313 RUBY_SET_YYLLOC(*p->yylloc);
21314 return END_OF_INPUT;
21320 case ' ':
case '\t':
case '\f':
21323 while ((c = nextc(p))) {
21328 case ' ':
case '\t':
case '\f':
21337 dispatch_scan_event(p, tSP);
21344 p->token_seen = token_seen;
21345 const char *
const pcur = p->lex.pcur, *
const ptok = p->lex.ptok;
21347 if (!parser_magic_comment(p, p->lex.pcur, p->lex.pend - p->lex.pcur)) {
21348 if (comment_at_top(p)) {
21349 set_file_encoding(p, p->lex.pcur, p->lex.pend);
21352 p->lex.pcur = pcur, p->lex.ptok = ptok;
21354 dispatch_scan_event(p, tCOMMENT);
21358 p->token_seen = token_seen;
21360 c = (IS_lex_state(EXPR_BEG|EXPR_CLASS|EXPR_FNAME|EXPR_DOT) &&
21361 !IS_lex_state(EXPR_LABELED));
21362 if (c || IS_lex_state_all(EXPR_ARG|EXPR_LABELED)) {
21364 dispatch_scan_event(p, tIGNORED_NL);
21367 if (!c && p->ctxt.in_kwarg) {
21368 goto normal_newline;
21373 switch (c = nextc(p)) {
21374 case ' ':
case '\t':
case '\f':
case '\r':
21381 dispatch_scan_event(p, tSP);
21387 dispatch_delayed_token(p, tIGNORED_NL);
21388 if (peek(p,
'.') == (c ==
'&')) {
21390 dispatch_scan_event(p, tSP);
21395 p->ruby_sourceline--;
21396 p->lex.nextline = p->lex.lastline;
21397 set_lastline(p, prevline);
21399 if (c == -1 && space_seen) {
21400 dispatch_scan_event(p, tSP);
21405 RUBY_SET_YYLLOC(*p->yylloc);
21407 goto normal_newline;
21411 p->command_start = TRUE;
21412 SET_LEX_STATE(EXPR_BEG);
21416 if ((c = nextc(p)) ==
'*') {
21417 if ((c = nextc(p)) ==
'=') {
21418 set_yylval_id(idPow);
21419 SET_LEX_STATE(EXPR_BEG);
21423 if (IS_SPCARG(c)) {
21424 rb_warning0(
"'**' interpreted as argument prefix");
21427 else if (IS_BEG()) {
21431 c = warn_balanced((
enum ruby_method_ids)tPOW,
"**",
"argument prefix");
21436 set_yylval_id(
'*');
21437 SET_LEX_STATE(EXPR_BEG);
21441 if (IS_SPCARG(c)) {
21442 rb_warning0(
"'*' interpreted as argument prefix");
21445 else if (IS_BEG()) {
21449 c = warn_balanced(
'*',
"*",
"argument prefix");
21452 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
21457 if (IS_AFTER_OPERATOR()) {
21458 SET_LEX_STATE(EXPR_ARG);
21464 SET_LEX_STATE(EXPR_BEG);
21478 if (word_match_p(p,
"begin", 5)) {
21479 int first_p = TRUE;
21482 dispatch_scan_event(p, tEMBDOC_BEG);
21486 dispatch_scan_event(p, tEMBDOC);
21491 compile_error(p,
"embedded document meets end of file");
21492 return END_OF_INPUT;
21494 if (c ==
'=' && word_match_p(p,
"end", 3)) {
21500 dispatch_scan_event(p, tEMBDOC_END);
21505 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
21506 if ((c = nextc(p)) ==
'=') {
21507 if ((c = nextc(p)) ==
'=') {
21516 else if (c ==
'>') {
21525 !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
21527 (!IS_ARG() || IS_lex_state(EXPR_LABELED) || space_seen)) {
21528 enum yytokentype token = heredoc_identifier(p);
21529 if (token)
return token < 0 ? 0 : token;
21531 if (IS_AFTER_OPERATOR()) {
21532 SET_LEX_STATE(EXPR_ARG);
21535 if (IS_lex_state(EXPR_CLASS))
21536 p->command_start = TRUE;
21537 SET_LEX_STATE(EXPR_BEG);
21540 if ((c = nextc(p)) ==
'>') {
21547 if ((c = nextc(p)) ==
'=') {
21548 set_yylval_id(idLTLT);
21549 SET_LEX_STATE(EXPR_BEG);
21553 return warn_balanced((
enum ruby_method_ids)tLSHFT,
"<<",
"here document");
21559 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
21560 if ((c = nextc(p)) ==
'=') {
21564 if ((c = nextc(p)) ==
'=') {
21565 set_yylval_id(idGTGT);
21566 SET_LEX_STATE(EXPR_BEG);
21576 label = (IS_LABEL_POSSIBLE() ? str_label : 0);
21577 p->lex.strterm = NEW_STRTERM(str_dquote | label,
'"', 0);
21578 p->lex.ptok = p->lex.pcur-1;
21579 return tSTRING_BEG;
21582 if (IS_lex_state(EXPR_FNAME)) {
21583 SET_LEX_STATE(EXPR_ENDFN);
21586 if (IS_lex_state(EXPR_DOT)) {
21588 SET_LEX_STATE(EXPR_CMDARG);
21590 SET_LEX_STATE(EXPR_ARG);
21593 p->lex.strterm = NEW_STRTERM(str_xquote,
'`', 0);
21594 return tXSTRING_BEG;
21597 label = (IS_LABEL_POSSIBLE() ? str_label : 0);
21598 p->lex.strterm = NEW_STRTERM(str_squote | label,
'\'', 0);
21599 p->lex.ptok = p->lex.pcur-1;
21600 return tSTRING_BEG;
21603 return parse_qmark(p, space_seen);
21606 if ((c = nextc(p)) ==
'&') {
21607 SET_LEX_STATE(EXPR_BEG);
21608 if ((c = nextc(p)) ==
'=') {
21609 set_yylval_id(idANDOP);
21610 SET_LEX_STATE(EXPR_BEG);
21616 else if (c ==
'=') {
21617 set_yylval_id(
'&');
21618 SET_LEX_STATE(EXPR_BEG);
21621 else if (c ==
'.') {
21622 set_yylval_id(idANDDOT);
21623 SET_LEX_STATE(EXPR_DOT);
21627 if (IS_SPCARG(c)) {
21629 (c = peekc_n(p, 1)) == -1 ||
21630 !(c ==
'\'' || c ==
'"' ||
21631 is_identchar(p, (p->lex.pcur+1), p->lex.pend, p->enc))) {
21632 rb_warning0(
"'&' interpreted as argument prefix");
21636 else if (IS_BEG()) {
21640 c = warn_balanced(
'&',
"&",
"argument prefix");
21642 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
21646 if ((c = nextc(p)) ==
'|') {
21647 SET_LEX_STATE(EXPR_BEG);
21648 if ((c = nextc(p)) ==
'=') {
21649 set_yylval_id(idOROP);
21650 SET_LEX_STATE(EXPR_BEG);
21654 if (IS_lex_state_for(last_state, EXPR_BEG)) {
21662 set_yylval_id(
'|');
21663 SET_LEX_STATE(EXPR_BEG);
21666 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG|EXPR_LABEL);
21672 if (IS_AFTER_OPERATOR()) {
21673 SET_LEX_STATE(EXPR_ARG);
21681 set_yylval_id(
'+');
21682 SET_LEX_STATE(EXPR_BEG);
21685 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p,
'+'))) {
21686 SET_LEX_STATE(EXPR_BEG);
21689 return parse_numeric(p,
'+');
21693 SET_LEX_STATE(EXPR_BEG);
21695 return warn_balanced(
'+',
"+",
"unary operator");
21699 if (IS_AFTER_OPERATOR()) {
21700 SET_LEX_STATE(EXPR_ARG);
21708 set_yylval_id(
'-');
21709 SET_LEX_STATE(EXPR_BEG);
21713 SET_LEX_STATE(EXPR_ENDFN);
21714 yylval.num = p->lex.lpar_beg;
21715 p->lex.lpar_beg = p->lex.paren_nest;
21718 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p,
'-'))) {
21719 SET_LEX_STATE(EXPR_BEG);
21722 return tUMINUS_NUM;
21726 SET_LEX_STATE(EXPR_BEG);
21728 return warn_balanced(
'-',
"-",
"unary operator");
21731 int is_beg = IS_BEG();
21732 SET_LEX_STATE(EXPR_BEG);
21733 if ((c = nextc(p)) ==
'.') {
21734 if ((c = nextc(p)) ==
'.') {
21735 if (p->ctxt.in_argdef || IS_LABEL_POSSIBLE()) {
21736 SET_LEX_STATE(EXPR_ENDARG);
21739 if (p->lex.paren_nest == 0 && looking_at_eol_p(p)) {
21740 rb_warn0(
"... at EOL, should be parenthesized?");
21742 return is_beg ? tBDOT3 : tDOT3;
21745 return is_beg ? tBDOT2 : tDOT2;
21749 char prev = p->lex.pcur-1 > p->lex.pbeg ? *(p->lex.pcur-2) : 0;
21750 parse_numeric(p,
'.');
21752 yyerror0(
"unexpected fraction part after numeric literal");
21755 yyerror0(
"no .<digit> floating literal anymore; put 0 before dot");
21757 SET_LEX_STATE(EXPR_END);
21758 p->lex.ptok = p->lex.pcur;
21761 set_yylval_id(
'.');
21762 SET_LEX_STATE(EXPR_DOT);
21766 case '0':
case '1':
case '2':
case '3':
case '4':
21767 case '5':
case '6':
case '7':
case '8':
case '9':
21768 return parse_numeric(p, c);
21773 SET_LEX_STATE(EXPR_ENDFN);
21774 p->lex.paren_nest--;
21780 SET_LEX_STATE(EXPR_END);
21781 p->lex.paren_nest--;
21786 if (!p->lex.brace_nest--)
return tSTRING_DEND;
21789 SET_LEX_STATE(EXPR_END);
21790 p->lex.paren_nest--;
21796 if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
21797 SET_LEX_STATE(EXPR_BEG);
21800 set_yylval_id(idCOLON2);
21801 SET_LEX_STATE(EXPR_DOT);
21804 if (IS_END() ||
ISSPACE(c) || c ==
'#') {
21806 c = warn_balanced(
':',
":",
"symbol literal");
21807 SET_LEX_STATE(EXPR_BEG);
21812 p->lex.strterm = NEW_STRTERM(str_ssym, c, 0);
21815 p->lex.strterm = NEW_STRTERM(str_dsym, c, 0);
21821 SET_LEX_STATE(EXPR_FNAME);
21826 p->lex.strterm = NEW_STRTERM(str_regexp,
'/', 0);
21827 return tREGEXP_BEG;
21829 if ((c = nextc(p)) ==
'=') {
21830 set_yylval_id(
'/');
21831 SET_LEX_STATE(EXPR_BEG);
21835 if (IS_SPCARG(c)) {
21836 arg_ambiguous(p,
'/');
21837 p->lex.strterm = NEW_STRTERM(str_regexp,
'/', 0);
21838 return tREGEXP_BEG;
21840 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
21841 return warn_balanced(
'/',
"/",
"regexp literal");
21844 if ((c = nextc(p)) ==
'=') {
21845 set_yylval_id(
'^');
21846 SET_LEX_STATE(EXPR_BEG);
21849 SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
21854 SET_LEX_STATE(EXPR_BEG);
21855 p->command_start = TRUE;
21859 SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
21863 if (IS_AFTER_OPERATOR()) {
21864 if ((c = nextc(p)) !=
'@') {
21867 SET_LEX_STATE(EXPR_ARG);
21870 SET_LEX_STATE(EXPR_BEG);
21878 else if (!space_seen) {
21881 else if (IS_ARG() || IS_lex_state_all(EXPR_END|EXPR_LABEL)) {
21884 else if (IS_lex_state(EXPR_ENDFN) && !lambda_beginning_p()) {
21885 rb_warning0(
"parentheses after method name is interpreted as "
21886 "an argument list, not a decomposed argument");
21888 p->lex.paren_nest++;
21891 SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
21895 p->lex.paren_nest++;
21896 if (IS_AFTER_OPERATOR()) {
21897 if ((c = nextc(p)) ==
']') {
21898 p->lex.paren_nest--;
21899 SET_LEX_STATE(EXPR_ARG);
21900 if ((c = nextc(p)) ==
'=') {
21907 SET_LEX_STATE(EXPR_ARG|EXPR_LABEL);
21910 else if (IS_BEG()) {
21913 else if (IS_ARG() && (space_seen || IS_lex_state(EXPR_LABELED))) {
21916 SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
21922 ++p->lex.brace_nest;
21923 if (lambda_beginning_p())
21925 else if (IS_lex_state(EXPR_LABELED))
21927 else if (IS_lex_state(EXPR_ARG_ANY | EXPR_END | EXPR_ENDFN))
21929 else if (IS_lex_state(EXPR_ENDARG))
21933 if (c != tLBRACE) {
21934 p->command_start = TRUE;
21935 SET_LEX_STATE(EXPR_BEG);
21938 SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
21940 ++p->lex.paren_nest;
21949 dispatch_scan_event(p, tSP);
21952 if (c ==
' ')
return tSP;
21958 return parse_percent(p, space_seen, last_state);
21961 return parse_gvar(p, last_state);
21964 return parse_atmark(p, last_state);
21967 if (was_bol(p) && whole_match_p(p,
"__END__", 7, 0)) {
21968 p->ruby__end__seen = 1;
21972 dispatch_scan_event(p, k__END__);
21974 return END_OF_INPUT;
21980 if (!parser_is_identchar(p)) {
21981 compile_error(p,
"Invalid char '\\x%02X' in expression", c);
21990 return parse_ident(p, c, cmd_state);
21993 static enum yytokentype
21996 enum yytokentype t;
22000 p->yylloc = yylloc;
22002 t = parser_yylex(p);
22004 if (has_delayed_token(p))
22005 dispatch_delayed_token(p, t);
22006 else if (t != END_OF_INPUT)
22007 dispatch_scan_event(p, t);
22012 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
22015 node_new_internal(
struct parser_params *p,
enum node_type
type,
size_t size,
size_t alignment)
22017 NODE *n = rb_ast_newnode(p->ast,
type, size, alignment);
22019 rb_node_init(n,
type);
22027 nd_set_line(nd, loc->beg_pos.lineno);
22034 NODE *n = node_new_internal(p,
type, size, alignment);
22036 nd_set_loc(n, loc);
22037 nd_set_node_id(n, parser_get_node_id(p));
22041 #define NODE_NEWNODE(node_type, type, loc) (type *)(node_newnode(p, node_type, sizeof(type), RUBY_ALIGNOF(type), loc))
22047 nd_tbl = local_tbl(p);
22049 n->nd_tbl = nd_tbl;
22050 n->nd_body = nd_body;
22051 n->nd_args = nd_args;
22060 n->nd_tbl = nd_tbl;
22061 n->nd_body = nd_body;
22062 n->nd_args = nd_args;
22071 n->nd_mid = nd_mid;
22072 n->nd_defn = nd_defn;
22081 n->nd_recv = nd_recv;
22082 n->nd_mid = nd_mid;
22083 n->nd_defn = nd_defn;
22092 n->nd_head = nd_head;
22093 n->nd_end = (
NODE *)n;
22103 n->nd_body = nd_body;
22104 n->nd_iter = nd_iter;
22113 n->nd_var = nd_var;
22130 n->nd_body = nd_body;
22139 n->nd_head = nd_head;
22140 n->nd_resq = nd_resq;
22141 n->nd_else = nd_else;
22150 n->nd_args = nd_args;
22151 n->nd_exc_var = nd_exc_var;
22152 n->nd_body = nd_body;
22153 n->nd_next = nd_next;
22162 n->nd_head = nd_head;
22163 n->nd_ensr = nd_ensr;
22172 n->nd_1st = nd_1st;
22173 n->nd_2nd = nd_2nd;
22174 n->operator_loc = *operator_loc;
22183 n->nd_1st = nd_1st;
22184 n->nd_2nd = nd_2nd;
22185 n->operator_loc = *operator_loc;
22194 n->nd_stts = nd_stts;
22195 n->keyword_loc = *keyword_loc;
22203 n->nd_head = nd_head;
22212 n->nd_cond = nd_cond;
22213 n->nd_body = nd_body;
22214 n->nd_else = nd_else;
22223 n->nd_cond = nd_cond;
22224 n->nd_body = nd_body;
22225 n->nd_else = nd_else;
22226 n->keyword_loc = *keyword_loc;
22227 n->then_keyword_loc = *then_keyword_loc;
22228 n->end_keyword_loc = *end_keyword_loc;
22237 NODE *scope = NEW_SCOPE(0, nd_body, loc);
22239 n->nd_cpath = nd_cpath;
22240 n->nd_body = scope;
22241 n->nd_super = nd_super;
22250 NODE *scope = NEW_SCOPE(0, nd_body, loc);
22252 n->nd_recv = nd_recv;
22253 n->nd_body = scope;
22262 NODE *scope = NEW_SCOPE(0, nd_body, loc);
22264 n->nd_cpath = nd_cpath;
22265 n->nd_body = scope;
22274 NODE *scope = NEW_SCOPE(nd_args, nd_body, loc);
22276 n->nd_body = scope;
22286 NODE *scope = NEW_SCOPE(nd_args, nd_body, loc);
22288 n->nd_body = scope;
22297 n->nd_head = nd_head;
22298 n->nd_body = nd_body;
22299 n->case_keyword_loc = *case_keyword_loc;
22300 n->end_keyword_loc = *end_keyword_loc;
22310 n->nd_body = nd_body;
22311 n->case_keyword_loc = *case_keyword_loc;
22312 n->end_keyword_loc = *end_keyword_loc;
22321 n->nd_head = nd_head;
22322 n->nd_body = nd_body;
22323 n->case_keyword_loc = *case_keyword_loc;
22324 n->end_keyword_loc = *end_keyword_loc;
22333 n->nd_head = nd_head;
22334 n->nd_body = nd_body;
22335 n->nd_next = nd_next;
22336 n->keyword_loc = *keyword_loc;
22337 n->then_keyword_loc = *then_keyword_loc;
22346 n->nd_head = nd_head;
22347 n->nd_body = nd_body;
22348 n->nd_next = nd_next;
22357 n->nd_cond = nd_cond;
22358 n->nd_body = nd_body;
22359 n->nd_state = nd_state;
22360 n->keyword_loc = *keyword_loc;
22361 n->closing_loc = *closing_loc;
22370 n->nd_cond = nd_cond;
22371 n->nd_body = nd_body;
22372 n->nd_state = nd_state;
22373 n->keyword_loc = *keyword_loc;
22374 n->closing_loc = *closing_loc;
22383 n->nd_head = nd_head;
22384 n->nd_mid = nd_mid;
22393 n->nd_mid = nd_mid;
22402 n->nd_beg = nd_beg;
22403 n->nd_end = nd_end;
22412 n->nd_beg = nd_beg;
22413 n->nd_end = nd_end;
22455 n->nd_args = nd_args;
22472 n->nd_recv = nd_recv;
22473 n->nd_value = nd_value;
22483 n->nd_recv = nd_recv;
22484 n->nd_value = nd_value;
22494 n->nd_head = nd_head;
22505 n->nd_head = nd_head;
22506 n->as.nd_alen = nd_alen;
22507 n->nd_next = nd_next;
22524 n->nd_head = nd_head;
22534 n->nd_head = nd_head;
22536 n->nd_args = nd_args;
22545 n->nd_vid = nd_vid;
22546 n->nd_value = nd_value;
22555 n->nd_vid = nd_vid;
22556 n->nd_value = nd_value;
22565 n->nd_vid = nd_vid;
22566 n->nd_value = nd_value;
22575 n->nd_vid = nd_vid;
22576 n->nd_value = nd_value;
22585 n->nd_vid = nd_vid;
22586 n->nd_value = nd_value;
22595 n->nd_recv = nd_recv;
22596 n->nd_mid = nd_mid;
22597 n->nd_index = index;
22598 n->nd_rvalue = rvalue;
22599 n->call_operator_loc = *call_operator_loc;
22600 n->opening_loc = *opening_loc;
22601 n->closing_loc = *closing_loc;
22602 n->binary_operator_loc = *binary_operator_loc;
22611 n->nd_recv = nd_recv;
22612 n->nd_value = nd_value;
22613 n->nd_vid = nd_vid;
22614 n->nd_mid = nd_mid;
22615 n->nd_aid = nd_aid;
22616 n->call_operator_loc = *call_operator_loc;
22617 n->message_loc = *message_loc;
22618 n->binary_operator_loc = *binary_operator_loc;
22627 n->nd_head = nd_head;
22628 n->nd_value = nd_value;
22637 n->nd_head = nd_head;
22638 n->nd_value = nd_value;
22647 n->nd_vid = nd_vid;
22656 n->nd_vid = nd_vid;
22665 n->nd_vid = nd_vid;
22674 n->nd_vid = nd_vid;
22683 n->nd_vid = nd_vid;
22692 n->nd_vid = nd_vid;
22701 n->nd_nth = nd_nth;
22710 n->nd_nth = nd_nth;
22737 rb_node_rational_new(
struct parser_params *p,
char* val,
int base,
int seen_point,
const YYLTYPE *loc)
22743 n->seen_point = seen_point;
22749 rb_node_imaginary_new(
struct parser_params *p,
char* val,
int base,
int seen_point,
enum rb_numeric_type numeric_type,
const YYLTYPE *loc)
22755 n->seen_point = seen_point;
22756 n->type = numeric_type;
22765 n->string = string;
22775 n->string = string;
22776 n->as.nd_alen = nd_alen;
22785 return rb_node_dstr_new0(p,
string, 1, 0, loc);
22792 n->string = string;
22801 n->string = string;
22802 n->as.nd_alen = nd_alen;
22812 n->string = rb_str_to_parser_string(p, str);
22821 n->string = string;
22822 n->as.nd_alen = nd_alen;
22832 n->nd_body = nd_body;
22841 n->string = string;
22842 n->options = options & RE_OPTION_MASK;
22851 n->nd_recv = nd_recv;
22852 n->nd_mid = nd_mid;
22853 n->nd_args = nd_args;
22862 n->nd_recv = nd_recv;
22863 n->nd_mid = nd_mid;
22864 n->nd_args = nd_args;
22873 n->nd_mid = nd_mid;
22874 n->nd_args = nd_args;
22883 n->nd_recv = nd_recv;
22884 n->nd_mid = nd_mid;
22885 n->nd_args = nd_args;
22894 n->nd_mid = nd_mid;
22903 n->nd_body = nd_body;
22921 n->nd_pid = nd_pid;
22922 n->nd_plen = nd_plen;
22932 n->nd_body = nd_body;
22942 n->nd_body = nd_body;
22952 n->nd_1st = nd_1st;
22953 n->nd_2nd = nd_2nd;
22962 n->nd_head = nd_head;
22963 n->nd_body = nd_body;
22972 n->nd_head = nd_head;
22973 n->nd_body = nd_body;
22982 n->nd_head = nd_head;
22983 n->operator_loc = *operator_loc;
22994 n->nd_body = nd_body;
22995 n->operator_loc = *operator_loc;
23004 n->nd_1st = nd_1st;
23005 n->nd_2nd = nd_2nd;
23006 n->keyword_loc = *keyword_loc;
23015 n->nd_alias = nd_alias;
23016 n->nd_orig = nd_orig;
23017 n->keyword_loc = *keyword_loc;
23026 n->nd_undefs = rb_parser_ary_new_capa_for_node(p, 1);
23027 n->keyword_loc = NULL_LOC;
23028 rb_parser_ary_push_node(p, n->nd_undefs, nd_undef);
23045 n->nd_head = nd_head;
23054 n->nd_body = nd_body;
23063 n->nd_recv = nd_recv;
23064 n->nd_mid = nd_mid;
23065 n->nd_args = nd_args;
23075 n->pre_args = pre_args;
23076 n->rest_arg = rest_arg;
23077 n->post_args = post_args;
23086 n->nd_pconst = nd_pconst;
23087 n->nd_pkwargs = nd_pkwargs;
23088 n->nd_pkwrestarg = nd_pkwrestarg;
23098 n->pre_rest_arg = pre_rest_arg;
23100 n->post_rest_arg = post_rest_arg;
23117 n->path = rb_str_to_parser_string(p, str);
23132 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)
23135 n->nd_vid = nd_vid;
23136 n->nd_value = nd_value;
23137 n->nd_else = nd_else;
23138 n->shareability = shareability;
23144 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)
23147 n->nd_head = nd_head;
23148 n->nd_value = nd_value;
23149 n->nd_aid = nd_aid;
23150 n->shareability = shareability;
23167 n->nd_stts = nd_stts;
23169 n->keyword_loc = *keyword_loc;
23178 n->nd_stts = nd_stts;
23180 n->keyword_loc = *keyword_loc;
23190 n->keyword_loc = *keyword_loc;
23199 n->save.numparam_save = 0;
23200 n->save.max_numparam = 0;
23201 n->save.ctxt = p->ctxt;
23211 n->save.numparam_save = numparam_push(p);
23212 n->save.max_numparam = p->max_numparam;
23217 static enum node_type
23218 nodetype(
NODE *node)
23220 return (
enum node_type)nd_type(node);
23224 nodeline(
NODE *node)
23226 return nd_line(node);
23231 newline_node(
NODE *node)
23234 node = remove_begin(node);
23235 nd_set_fl_newline(node);
23245 nd_set_line(node, nd_line(orig));
23251 NODE *end, *h = head, *nd;
23253 if (tail == 0)
return head;
23255 if (h == 0)
return tail;
23256 switch (nd_type(h)) {
23258 h = end = NEW_BLOCK(head, &head->nd_loc);
23262 end = RNODE_BLOCK(h)->nd_end;
23266 nd = RNODE_BLOCK(end)->nd_head;
23267 switch (nd_type(nd)) {
23273 rb_warning0L(nd_line(tail),
"statement not reached");
23280 if (!nd_type_p(tail, NODE_BLOCK)) {
23281 tail = NEW_BLOCK(tail, &tail->nd_loc);
23283 RNODE_BLOCK(end)->nd_next = tail;
23284 RNODE_BLOCK(h)->nd_end = RNODE_BLOCK(tail)->nd_end;
23285 nd_set_last_loc(head, nd_last_loc(tail));
23295 if (list == 0)
return NEW_LIST(item, &item->nd_loc);
23296 if (RNODE_LIST(list)->nd_next) {
23297 last = RNODE_LIST(RNODE_LIST(list)->nd_next)->as.nd_end;
23303 RNODE_LIST(list)->as.nd_alen += 1;
23304 RNODE_LIST(last)->nd_next = NEW_LIST(item, &item->nd_loc);
23305 RNODE_LIST(RNODE_LIST(list)->nd_next)->as.nd_end = RNODE_LIST(last)->nd_next;
23307 nd_set_last_loc(list, nd_last_loc(item));
23314 list_concat(
NODE *head,
NODE *tail)
23318 if (RNODE_LIST(head)->nd_next) {
23319 last = RNODE_LIST(RNODE_LIST(head)->nd_next)->as.nd_end;
23325 RNODE_LIST(head)->as.nd_alen += RNODE_LIST(tail)->as.nd_alen;
23326 RNODE_LIST(last)->nd_next = tail;
23327 if (RNODE_LIST(tail)->nd_next) {
23328 RNODE_LIST(RNODE_LIST(head)->nd_next)->as.nd_end = RNODE_LIST(RNODE_LIST(tail)->nd_next)->as.nd_end;
23331 RNODE_LIST(RNODE_LIST(head)->nd_next)->as.nd_end = tail;
23334 nd_set_last_loc(head, nd_last_loc(tail));
23342 if (!tail)
return 1;
23343 if (!rb_parser_enc_compatible(p, head, tail)) {
23344 compile_error(p,
"string literal encodings differ (%s / %s)",
23347 rb_parser_str_resize(p, head, 0);
23348 rb_parser_str_resize(p, tail, 0);
23351 rb_parser_str_buf_append(p, head, tail);
23358 if (htype != NODE_DSTR)
return NULL;
23359 if (RNODE_DSTR(head)->nd_next) {
23360 head = RNODE_LIST(RNODE_LIST(RNODE_DSTR(head)->nd_next)->as.nd_end)->nd_head;
23361 if (!head || !nd_type_p(head, NODE_STR))
return NULL;
23373 if (!orig)
return NULL;
23374 copy = rb_parser_string_new(p, PARSER_STRING_PTR(orig), PARSER_STRING_LEN(orig));
23375 copy->coderange = orig->coderange;
23376 copy->enc = orig->enc;
23385 enum node_type htype;
23388 if (!head)
return tail;
23389 if (!tail)
return head;
23391 htype = nd_type(head);
23392 if (htype == NODE_EVSTR) {
23393 head = new_dstr(p, head, loc);
23396 if (p->heredoc_indent > 0) {
23399 head = str2dstr(p, head);
23401 return list_append(p, head, tail);
23406 switch (nd_type(tail)) {
23408 if ((lit = string_literal_head(p, htype, head)) !=
false) {
23412 lit = RNODE_DSTR(head)->string;
23414 if (htype == NODE_STR) {
23415 if (!literal_concat0(p, lit, RNODE_STR(tail)->
string)) {
23417 rb_discard_node(p, head);
23418 rb_discard_node(p, tail);
23421 rb_discard_node(p, tail);
23424 list_append(p, head, tail);
23429 if (htype == NODE_STR) {
23430 if (!literal_concat0(p, RNODE_STR(head)->
string, RNODE_DSTR(tail)->
string))
23432 rb_parser_string_free(p, RNODE_DSTR(tail)->
string);
23433 RNODE_DSTR(tail)->string = RNODE_STR(head)->string;
23434 RNODE_STR(head)->string = NULL;
23435 rb_discard_node(p, head);
23438 else if (!RNODE_DSTR(tail)->
string) {
23440 RNODE_DSTR(head)->as.nd_alen += RNODE_DSTR(tail)->as.nd_alen - 1;
23441 if (!RNODE_DSTR(head)->nd_next) {
23442 RNODE_DSTR(head)->nd_next = RNODE_DSTR(tail)->nd_next;
23444 else if (RNODE_DSTR(tail)->nd_next) {
23445 RNODE_DSTR(RNODE_DSTR(RNODE_DSTR(head)->nd_next)->as.nd_end)->nd_next = RNODE_DSTR(tail)->nd_next;
23446 RNODE_DSTR(RNODE_DSTR(head)->nd_next)->as.nd_end = RNODE_DSTR(RNODE_DSTR(tail)->nd_next)->as.nd_end;
23448 rb_discard_node(p, tail);
23450 else if ((lit = string_literal_head(p, htype, head)) !=
false) {
23451 if (!literal_concat0(p, lit, RNODE_DSTR(tail)->
string))
23453 rb_parser_string_free(p, RNODE_DSTR(tail)->
string);
23454 RNODE_DSTR(tail)->string = 0;
23458 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));
23459 RNODE_DSTR(tail)->string = 0;
23464 if (htype == NODE_STR) {
23465 head = str2dstr(p, head);
23466 RNODE_DSTR(head)->as.nd_alen = 1;
23468 list_append(p, head, tail);
23475 nd_copy_flag(
NODE *new_node,
NODE *old_node)
23477 if (nd_fl_newline(old_node)) nd_set_fl_newline(new_node);
23478 nd_set_line(new_node, nd_line(old_node));
23479 new_node->nd_loc = old_node->nd_loc;
23480 new_node->node_id = old_node->node_id;
23487 nd_copy_flag(new_node, node);
23488 RNODE_DSTR(new_node)->string = RNODE_STR(node)->string;
23489 RNODE_DSTR(new_node)->as.nd_alen = 0;
23490 RNODE_DSTR(new_node)->nd_next = 0;
23491 RNODE_STR(node)->string = 0;
23500 nd_copy_flag(new_node, node);
23501 RNODE_REGX(new_node)->string = RNODE_STR(node)->string;
23502 RNODE_REGX(new_node)->options = options;
23503 RNODE_STR(node)->string = 0;
23511 if (nd_type_p(node, NODE_EVSTR)) {
23512 node = new_dstr(p, node, &node->nd_loc);
23523 switch (nd_type(node)) {
23525 return str2dstr(p, node);
23532 return NEW_EVSTR(head, loc);
23538 NODE *dstr = NEW_DSTR(STRING_NEW0(), loc);
23539 return list_append(p, dstr, node);
23549 expr = NEW_OPCALL(recv,
id, NEW_LIST(arg1, &arg1->nd_loc), loc);
23550 nd_set_line(expr, op_loc->beg_pos.lineno);
23559 opcall = NEW_OPCALL(recv,
id, 0, loc);
23560 nd_set_line(opcall, op_loc->beg_pos.lineno);
23567 NODE *qcall = NEW_QCALL(atype, recv, mid, args, loc);
23568 nd_set_line(qcall, op_loc->beg_pos.lineno);
23576 if (block) block_dup_check(p, args, block);
23577 ret = new_qcall(p, atype, recv, mid, args, op_loc, loc);
23578 if (block) ret = method_add_block(p, ret, block, loc);
23583 #define nd_once_body(node) (nd_type_p((node), NODE_ONCE) ? RNODE_ONCE(node)->nd_body : node)
23586 last_expr_once_body(
NODE *node)
23588 if (!node)
return 0;
23589 return nd_once_body(node);
23596 int line = op_loc->beg_pos.lineno;
23601 if ((n = last_expr_once_body(node1)) != 0) {
23602 switch (nd_type(n)) {
23605 NODE *match = NEW_MATCH2(node1, node2, loc);
23606 nd_set_line(match, line);
23612 const VALUE lit = rb_node_regx_string_val(n);
23614 NODE *match = NEW_MATCH2(node1, node2, loc);
23615 RNODE_MATCH2(match)->nd_args = reg_named_capture_assign(p, lit, loc);
23616 nd_set_line(match, line);
23623 if ((n = last_expr_once_body(node2)) != 0) {
23626 switch (nd_type(n)) {
23628 match3 = NEW_MATCH3(node2, node1, loc);
23633 n = NEW_CALL(node1, tMATCH, NEW_LIST(node2, &node2->nd_loc), loc);
23634 nd_set_line(n, line);
23638 # if WARN_PAST_SCOPE
23642 struct vtable *past = p->lvtbl->past;
23644 if (vtable_included(past,
id))
return 1;
23655 NODE *outer = local->numparam.outer;
23656 NODE *inner = local->numparam.inner;
23657 if (outer || inner) {
23658 NODE *used = outer ? outer : inner;
23659 compile_error(p,
"numbered parameter is already used in\n"
23660 "%s:%d: %s block here",
23661 p->ruby_sourcefile, nd_line(used),
23662 outer ?
"outer" :
"inner");
23663 parser_show_error_line(p, &used->nd_loc);
23672 NODE *numparam = p->lvtbl->numparam.current;
23674 compile_error(p,
"numbered parameter is already used in\n"
23675 "%s:%d: current block here",
23676 p->ruby_sourcefile, nd_line(numparam));
23677 parser_show_error_line(p, &numparam->nd_loc);
23686 NODE *it = p->lvtbl->it;
23688 compile_error(p,
"'it' is already used in\n"
23689 "%s:%d: current block here",
23690 p->ruby_sourcefile, nd_line(it));
23691 parser_show_error_line(p, &it->nd_loc);
23704 return NEW_SELF(loc);
23706 return NEW_NIL(loc);
23708 return NEW_TRUE(loc);
23709 case keyword_false:
23710 return NEW_FALSE(loc);
23711 case keyword__FILE__:
23713 VALUE file = p->ruby_sourcefile_string;
23716 node = NEW_FILE(file, loc);
23719 case keyword__LINE__:
23720 return NEW_LINE(loc);
23721 case keyword__ENCODING__:
23722 return NEW_ENCODING(loc);
23725 switch (id_type(
id)) {
23727 if (dyna_in_block(p) && dvar_defined_ref(p,
id, &vidp)) {
23728 if (NUMPARAM_ID_P(
id) && (numparam_nested_p(p) || it_used_p(p)))
return 0;
23729 if (vidp) *vidp |= LVAR_USED;
23730 node = NEW_DVAR(
id, loc);
23733 if (local_id_ref(p,
id, &vidp)) {
23734 if (vidp) *vidp |= LVAR_USED;
23735 node = NEW_LVAR(
id, loc);
23738 if (dyna_in_block(p) && NUMPARAM_ID_P(
id) &&
23739 parser_numbered_param(p, NUMPARAM_ID_TO_IDX(
id))) {
23740 if (numparam_nested_p(p) || it_used_p(p))
return 0;
23741 node = NEW_DVAR(
id, loc);
23743 if (!local->numparam.current) local->numparam.current = node;
23746 # if WARN_PAST_SCOPE
23748 rb_warning1(
"possible reference to past scope - %"PRIsWARN,
rb_id2str(
id));
23752 if (dyna_in_block(p) &&
id ==
rb_intern(
"it") && !(DVARS_TERMINAL_P(p->lvtbl->args) || DVARS_TERMINAL_P(p->lvtbl->args->prev))) {
23753 if (numparam_used_p(p))
return 0;
23754 if (p->max_numparam == ORDINAL_PARAM) {
23755 compile_error(p,
"ordinary parameter is defined");
23759 p->it_id = internal_id(p);
23760 vtable_add(p->lvtbl->args, p->it_id);
23762 NODE *node = NEW_DVAR(p->it_id, loc);
23763 if (!p->lvtbl->it) p->lvtbl->it = node;
23766 return NEW_VCALL(
id, loc);
23768 return NEW_GVAR(
id, loc);
23770 return NEW_IVAR(
id, loc);
23772 return NEW_CONST(
id, loc);
23774 return NEW_CVAR(
id, loc);
23776 compile_error(p,
"identifier %"PRIsVALUE
" is not valid to get",
rb_id2str(
id));
23784 RNODE(opts)->nd_loc.end_pos = RNODE(opt)->nd_loc.end_pos;
23786 while (opts->nd_next) {
23787 opts = opts->nd_next;
23788 RNODE(opts)->nd_loc.end_pos = RNODE(opt)->nd_loc.end_pos;
23790 opts->nd_next = opt;
23800 opt_arg_append(RNODE_OPT_ARG(kwlist), RNODE_OPT_ARG(kw));
23810 if (nd_type_p(n, NODE_BEGIN)) {
23811 n = RNODE_BEGIN(n)->nd_body;
23813 else if (nd_type_p(n, NODE_BLOCK) && RNODE_BLOCK(n)->nd_end == n) {
23814 n = RNODE_BLOCK(n)->nd_head;
23820 return NEW_DEFINED(n, loc);
23828 if (rb_parser_enc_str_coderange(p, str) == RB_PARSER_ENC_CODERANGE_BROKEN) {
23829 yyerror1(loc,
"invalid symbol");
23833 lit = rb_str_new_parser_string(str);
23835 return NEW_SYM(lit, loc);
23841 enum node_type
type = nd_type(symbol);
23844 nd_set_type(symbol, NODE_DSYM);
23847 symbol = str_to_sym_node(p, symbol, &RNODE(symbol)->nd_loc);
23850 compile_error(p,
"unexpected node as symbol: %s", parser_node_name(
type));
23852 return list_append(p, symbols, symbol);
23864 reg_compile(p, str, options);
23865 node = NEW_REGX(str, options, loc);
23868 switch (nd_type(node)) {
23872 reg_compile(p, RNODE_STR(node)->
string, options);
23873 node = str2regx(p, node, options);
23877 node = NEW_DSTR0(STRING_NEW0(), 1, NEW_LIST(node, loc), loc);
23880 nd_set_type(node, NODE_DREGX);
23881 nd_set_loc(node, loc);
23883 dreg->as.nd_cflag = options & RE_OPTION_MASK;
23884 if (dreg->string) reg_fragment_check(p, dreg->string, options);
23886 for (list = dreg->nd_next; list; list = RNODE_LIST(list->nd_next)) {
23887 NODE *frag = list->nd_head;
23888 enum node_type
type = nd_type(frag);
23889 if (
type == NODE_STR || (
type == NODE_DSTR && !RNODE_DSTR(frag)->nd_next)) {
23891 if (reg_fragment_check(p, tail, options) && prev && RNODE_DREGX(prev)->
string) {
23892 rb_parser_string_t *lit = prev == node ? dreg->string : RNODE_STR(RNODE_LIST(prev)->nd_head)->string;
23893 if (!literal_concat0(p, lit, tail)) {
23894 return NEW_NIL(loc);
23896 rb_parser_str_resize(p, tail, 0);
23897 RNODE_LIST(prev)->nd_next = list->nd_next;
23898 rb_discard_node(p, list->nd_head);
23899 rb_discard_node(p, (
NODE *)list);
23900 list = RNODE_LIST(prev);
23903 prev = (
NODE *)list;
23910 if (!dreg->nd_next) {
23912 reg_compile(p, dreg->string, options);
23914 if (options & RE_OPTION_ONCE) {
23915 node = NEW_ONCE(node, loc);
23926 return NEW_KW_ARG((k), loc);
23933 NODE *xstr = NEW_XSTR(STRING_NEW0(), loc);
23936 switch (nd_type(node)) {
23938 nd_set_type(node, NODE_XSTR);
23939 nd_set_loc(node, loc);
23942 nd_set_type(node, NODE_DXSTR);
23943 nd_set_loc(node, loc);
23946 node = NEW_DXSTR(0, 1, NEW_LIST(node, loc), loc);
23958 static int nd_type_st_key_enable_p(
NODE *node);
23964 if (!arg || !p->case_labels)
return;
23965 if (!nd_type_st_key_enable_p(arg))
return;
23967 if (p->case_labels == CHECK_LITERAL_WHEN) {
23968 p->case_labels = st_init_table(&literal_type);
23972 if (st_lookup(p->case_labels, (st_data_t)arg, &line)) {
23973 rb_warning2(
"'when' clause on line %d duplicates 'when' clause on line %d and is ignored",
23974 WARN_I((
int)nd_line(arg)), WARN_I((
int)line));
23978 st_insert(p->case_labels, (st_data_t)arg, (st_data_t)p->ruby_sourceline);
23985 if (is_notop_id(
id)) {
23986 switch (
id & ID_SCOPE_MASK) {
23987 case ID_GLOBAL:
case ID_INSTANCE:
case ID_CONST:
case ID_CLASS:
23990 if (dyna_in_block(p)) {
23991 if (NUMPARAM_ID_P(
id) || dvar_defined(p,
id))
return 1;
23993 if (local_id(p,
id))
return 1;
23998 compile_error(p,
"identifier %"PRIsVALUE
" is not valid to get",
rb_id2str(
id));
24003 static inline enum lex_state_e
24004 parser_set_lex_state(
struct parser_params *p,
enum lex_state_e ls,
int line)
24007 ls = rb_parser_trace_lex_state(p, p->lex.state, ls, line);
24009 return p->lex.state = ls;
24016 VALUE mesg = p->debug_buffer;
24019 p->debug_buffer =
Qnil;
24027 static const char rb_parser_lex_state_names[][8] = {
24028 "BEG",
"END",
"ENDARG",
"ENDFN",
"ARG",
24029 "CMDARG",
"MID",
"FNAME",
"DOT",
"CLASS",
24030 "LABEL",
"LABELED",
"FITEM",
24037 unsigned int mask = 1;
24038 static const char none[] =
"NONE";
24040 for (i = 0; i < EXPR_MAX_STATE; ++i, mask <<= 1) {
24041 if ((
unsigned)state & mask) {
24056 rb_parser_trace_lex_state(
struct parser_params *p,
enum lex_state_e from,
24057 enum lex_state_e to,
int line)
24061 append_lex_state_name(p, from, mesg);
24063 append_lex_state_name(p, to, mesg);
24065 flush_debug_buffer(p, p->debug_output, mesg);
24070 rb_parser_lex_state_name(
struct parser_params *p,
enum lex_state_e state)
24082 stack_type mask = (stack_type)1U << (CHAR_BIT *
sizeof(stack_type) - 1);
24083 for (; mask && !(stack & mask); mask >>= 1)
continue;
24084 for (; mask; mask >>= 1)
rb_str_cat(mesg, stack & mask ?
"1" :
"0", 1);
24089 rb_parser_show_bitstack(
struct parser_params *p, stack_type stack,
24090 const char *name,
int line)
24093 append_bitstack_value(p, stack, mesg);
24095 flush_debug_buffer(p, p->debug_output, mesg);
24099 rb_parser_fatal(
struct parser_params *p,
const char *fmt, ...)
24111 append_lex_state_name(p, p->lex.state, mesg);
24112 compile_error(p,
"lex.state: %"PRIsVALUE, mesg);
24114 append_bitstack_value(p, p->cond_stack, mesg);
24115 compile_error(p,
"cond_stack: %"PRIsVALUE, mesg);
24117 append_bitstack_value(p, p->cmdarg_stack, mesg);
24118 compile_error(p,
"cmdarg_stack: %"PRIsVALUE, mesg);
24125 rb_parser_set_pos(
YYLTYPE *yylloc,
int sourceline,
int beg_pos,
int end_pos)
24127 yylloc->beg_pos.lineno = sourceline;
24128 yylloc->beg_pos.column = beg_pos;
24129 yylloc->end_pos.lineno = sourceline;
24130 yylloc->end_pos.column = end_pos;
24137 int sourceline = here->sourceline;
24138 int beg_pos = (int)here->offset - here->quote
24139 - (
rb_strlen_lit(
"<<-") - !(here->func & STR_FUNC_INDENT));
24140 int end_pos = (int)here->offset + here->length + here->quote;
24142 return rb_parser_set_pos(yylloc, sourceline, beg_pos, end_pos);
24148 yylloc->beg_pos.lineno = p->delayed.beg_line;
24149 yylloc->beg_pos.column = p->delayed.beg_col;
24150 yylloc->end_pos.lineno = p->delayed.end_line;
24151 yylloc->end_pos.column = p->delayed.end_col;
24159 int sourceline = p->ruby_sourceline;
24160 int beg_pos = (int)(p->lex.ptok - p->lex.pbeg);
24161 int end_pos = (int)(p->lex.pend - p->lex.pbeg);
24162 return rb_parser_set_pos(yylloc, sourceline, beg_pos, end_pos);
24168 yylloc->end_pos = yylloc->beg_pos;
24176 int sourceline = p->ruby_sourceline;
24177 int beg_pos = (int)(p->lex.ptok - p->lex.pbeg);
24178 int end_pos = (int)(p->lex.ptok - p->lex.pbeg);
24179 return rb_parser_set_pos(yylloc, sourceline, beg_pos, end_pos);
24185 int sourceline = p->ruby_sourceline;
24186 int beg_pos = (int)(p->lex.ptok - p->lex.pbeg);
24187 int end_pos = (int)(p->lex.pcur - p->lex.pbeg);
24188 return rb_parser_set_pos(yylloc, sourceline, beg_pos, end_pos);
24195 if (!
id)
return -1;
24198 *err =
"Can't change the value of self";
24201 *err =
"Can't assign to nil";
24204 *err =
"Can't assign to true";
24206 case keyword_false:
24207 *err =
"Can't assign to false";
24209 case keyword__FILE__:
24210 *err =
"Can't assign to __FILE__";
24212 case keyword__LINE__:
24213 *err =
"Can't assign to __LINE__";
24215 case keyword__ENCODING__:
24216 *err =
"Can't assign to __ENCODING__";
24219 switch (id_type(
id)) {
24221 if (dyna_in_block(p)) {
24222 if (p->max_numparam > NO_PARAM && NUMPARAM_ID_P(
id)) {
24223 compile_error(p,
"Can't assign to numbered parameter _%d",
24224 NUMPARAM_ID_TO_IDX(
id));
24227 if (dvar_curr(p,
id))
return NODE_DASGN;
24228 if (dvar_defined(p,
id))
return NODE_DASGN;
24229 if (local_id(p,
id))
return NODE_LASGN;
24234 if (!local_id(p,
id)) local_var(p,
id);
24238 case ID_GLOBAL:
return NODE_GASGN;
24239 case ID_INSTANCE:
return NODE_IASGN;
24241 if (!p->ctxt.in_def)
return NODE_CDECL;
24242 *err =
"dynamic constant assignment";
24244 case ID_CLASS:
return NODE_CVASGN;
24246 compile_error(p,
"identifier %"PRIsVALUE
" is not valid to set",
rb_id2str(
id));
24254 const char *err = 0;
24255 int node_type = assignable0(p,
id, &err);
24256 switch (node_type) {
24257 case NODE_DASGN:
return NEW_DASGN(
id, val, loc);
24258 case NODE_LASGN:
return NEW_LASGN(
id, val, loc);
24259 case NODE_GASGN:
return NEW_GASGN(
id, val, loc);
24260 case NODE_IASGN:
return NEW_IASGN(
id, val, loc);
24261 case NODE_CDECL:
return NEW_CDECL(
id, val, 0, p->ctxt.shareable_constant_value, loc);
24262 case NODE_CVASGN:
return NEW_CVASGN(
id, val, loc);
24266 if (err) yyerror1(loc, err);
24268 if (err) set_value(assign_error(p, err, p->s_lvalue));
24270 return NEW_ERROR(loc);
24277 if (name == idUScore)
return 1;
24278 if (!is_local_id(name))
return 0;
24287 if (dyna_in_block(p)) {
24288 if (dvar_curr(p, name)) {
24289 if (is_private_local_id(p, name))
return 1;
24290 yyerror0(
"duplicated argument name");
24292 else if (dvar_defined(p, name) || local_id(p, name)) {
24293 vtable_add(p->lvtbl->vars, name);
24294 if (p->lvtbl->used) {
24295 vtable_add(p->lvtbl->used, (
ID)p->ruby_sourceline | LVAR_USED);
24301 if (local_id(p, name)) {
24302 if (is_private_local_id(p, name))
return 1;
24303 yyerror0(
"duplicated argument name");
24312 shadowing_lvar_0(p, name);
24320 if (!is_local_id(name)) {
24321 compile_error(p,
"invalid local variable - %"PRIsVALUE,
24325 if (!shadowing_lvar_0(p, name))
return;
24328 if (dvar_defined_ref(p, name, &vidp)) {
24329 if (vidp) *vidp |= LVAR_USED;
24336 NODE *block = 0, *kwds = 0;
24337 if (args && nd_type_p(args, NODE_BLOCK_PASS)) {
24338 block = RNODE_BLOCK_PASS(args)->nd_body;
24339 args = RNODE_BLOCK_PASS(args)->nd_head;
24341 if (args && nd_type_p(args, NODE_ARGSCAT)) {
24342 args = RNODE_ARGSCAT(args)->nd_body;
24344 if (args && nd_type_p(args, NODE_ARGSPUSH)) {
24345 kwds = RNODE_ARGSPUSH(args)->nd_body;
24348 for (
NODE *next = args; next && nd_type_p(next, NODE_LIST);
24349 next = RNODE_LIST(next)->nd_next) {
24350 kwds = RNODE_LIST(next)->nd_head;
24353 if (kwds && nd_type_p(kwds, NODE_HASH) && !RNODE_HASH(kwds)->nd_brace) {
24354 yyerror1(&kwds->nd_loc,
"keyword arg given in index assignment");
24357 yyerror1(&block->nd_loc,
"block arg given in index assignment");
24364 aryset_check(p, idx);
24365 return NEW_ATTRASGN(recv, tASET, idx, loc);
24371 if (node2 && node1 && nd_type_p(node1, NODE_BLOCK_PASS)) {
24372 compile_error(p,
"both block arg and actual block given");
24380 return NEW_ATTRASGN(recv,
id, 0, loc);
24387 # define ERR(...) (compile_error(p, __VA_ARGS__), Qtrue)
24389 # define ERR(...) rb_sprintf(__VA_ARGS__)
24391 switch (nd_type(node)) {
24393 return ERR(
"Can't set variable $%ld", RNODE_NTH_REF(node)->nd_nth);
24394 case NODE_BACK_REF:
24395 return ERR(
"Can't set variable $%c", (
int)RNODE_BACK_REF(node)->nd_nth);
24404 if (!node1)
return NEW_LIST(node2, &node2->nd_loc);
24405 switch (nd_type(node1)) {
24407 return list_append(p, node1, node2);
24408 case NODE_BLOCK_PASS:
24409 RNODE_BLOCK_PASS(node1)->nd_head = arg_append(p, RNODE_BLOCK_PASS(node1)->nd_head, node2, loc);
24410 node1->nd_loc.end_pos = RNODE_BLOCK_PASS(node1)->nd_head->nd_loc.end_pos;
24412 case NODE_ARGSPUSH:
24413 RNODE_ARGSPUSH(node1)->nd_body = list_append(p, NEW_LIST(RNODE_ARGSPUSH(node1)->nd_body, &RNODE_ARGSPUSH(node1)->nd_body->nd_loc), node2);
24414 node1->nd_loc.end_pos = RNODE_ARGSPUSH(node1)->nd_body->nd_loc.end_pos;
24415 nd_set_type(node1, NODE_ARGSCAT);
24418 if (!nd_type_p(RNODE_ARGSCAT(node1)->nd_body, NODE_LIST))
break;
24419 RNODE_ARGSCAT(node1)->nd_body = list_append(p, RNODE_ARGSCAT(node1)->nd_body, node2);
24420 node1->nd_loc.end_pos = RNODE_ARGSCAT(node1)->nd_body->nd_loc.end_pos;
24423 return NEW_ARGSPUSH(node1, node2, loc);
24429 if (!node2)
return node1;
24430 switch (nd_type(node1)) {
24431 case NODE_BLOCK_PASS:
24432 if (RNODE_BLOCK_PASS(node1)->nd_head)
24433 RNODE_BLOCK_PASS(node1)->nd_head = arg_concat(p, RNODE_BLOCK_PASS(node1)->nd_head, node2, loc);
24435 RNODE_LIST(node1)->nd_head = NEW_LIST(node2, loc);
24437 case NODE_ARGSPUSH:
24438 if (!nd_type_p(node2, NODE_LIST))
break;
24439 RNODE_ARGSPUSH(node1)->nd_body = list_concat(NEW_LIST(RNODE_ARGSPUSH(node1)->nd_body, loc), node2);
24440 nd_set_type(node1, NODE_ARGSCAT);
24443 if (!nd_type_p(node2, NODE_LIST) ||
24444 !nd_type_p(RNODE_ARGSCAT(node1)->nd_body, NODE_LIST))
break;
24445 RNODE_ARGSCAT(node1)->nd_body = list_concat(RNODE_ARGSCAT(node1)->nd_body, node2);
24448 return NEW_ARGSCAT(node1, node2, loc);
24455 if ((n1 = splat_array(args)) != 0) {
24456 return list_append(p, n1, last_arg);
24458 return arg_append(p, args, last_arg, loc);
24465 if ((nd_type_p(rest_arg, NODE_LIST)) && (n1 = splat_array(args)) != 0) {
24466 return list_concat(n1, rest_arg);
24468 return arg_concat(p, args, rest_arg, loc);
24472 splat_array(
NODE* node)
24474 if (nd_type_p(node, NODE_SPLAT)) node = RNODE_SPLAT(node)->nd_head;
24475 if (nd_type_p(node, NODE_LIST))
return node;
24484 switch (nd_type(rhs)) {
24486 if (local_id_ref(p, RNODE_LASGN(rhs)->nd_vid, &vidp)) {
24487 if (vidp) *vidp |= LVAR_USED;
24491 if (dvar_defined_ref(p, RNODE_DASGN(rhs)->nd_vid, &vidp)) {
24492 if (vidp) *vidp |= LVAR_USED;
24497 for (rhs = rhs->nd_head; rhs; rhs = rhs->nd_next) {
24498 mark_lvar_used(p, rhs->nd_head);
24505 static int is_static_content(
NODE *node);
24510 if (!lhs)
return 0;
24512 switch (nd_type(lhs)) {
24520 set_nd_value(p, lhs, rhs);
24521 nd_set_loc(lhs, loc);
24524 case NODE_ATTRASGN:
24525 RNODE_ATTRASGN(lhs)->nd_args = arg_append(p, RNODE_ATTRASGN(lhs)->nd_args, rhs, loc);
24526 nd_set_loc(lhs, loc);
24540 NODE *void_node = 0, *vn;
24543 rb_warning0(
"empty expression");
24546 switch (nd_type(node)) {
24548 vn = RNODE_ENSURE(node)->nd_head;
24549 node = RNODE_ENSURE(node)->nd_ensr;
24551 if (vn && (vn = value_expr_check(p, vn))) {
24558 vn = RNODE_RESCUE(node)->nd_head;
24559 if (!vn || !(vn = value_expr_check(p, vn)))
return NULL;
24560 if (!void_node) void_node = vn;
24561 for (
NODE *r = RNODE_RESCUE(node)->nd_resq; r; r = RNODE_RESBODY(r)->nd_next) {
24562 if (!nd_type_p(r, NODE_RESBODY)) {
24563 compile_error(p,
"unexpected node");
24566 if (!(vn = value_expr_check(p, RNODE_RESBODY(r)->nd_body))) {
24570 if (!void_node) void_node = vn;
24572 node = RNODE_RESCUE(node)->nd_else;
24573 if (!node)
return void_node;
24584 if (!RNODE_CASE3(node)->nd_body || !nd_type_p(RNODE_CASE3(node)->nd_body, NODE_IN)) {
24585 compile_error(p,
"unexpected node");
24588 if (RNODE_IN(RNODE_CASE3(node)->nd_body)->nd_body) {
24595 while (RNODE_BLOCK(node)->nd_next) {
24596 node = RNODE_BLOCK(node)->nd_next;
24598 node = RNODE_BLOCK(node)->nd_head;
24602 node = RNODE_BEGIN(node)->nd_body;
24607 if (!RNODE_IF(node)->nd_body) {
24610 else if (!RNODE_IF(node)->nd_else) {
24613 vn = value_expr_check(p, RNODE_IF(node)->nd_body);
24614 if (!vn)
return NULL;
24615 if (!void_node) void_node = vn;
24616 node = RNODE_IF(node)->nd_else;
24621 node = RNODE_AND(node)->nd_1st;
24627 mark_lvar_used(p, node);
24639 return void_node ? void_node : node;
24645 NODE *void_node = value_expr_check(p, node);
24647 yyerror1(&void_node->nd_loc,
"void value expression");
24657 const char *useless = 0;
24661 if (!node || !(node = nd_once_body(node)))
return;
24662 switch (nd_type(node)) {
24664 switch (RNODE_OPCALL(node)->nd_mid) {
24683 useless =
rb_id2name(RNODE_OPCALL(node)->nd_mid);
24694 case NODE_BACK_REF:
24695 useless =
"a variable";
24698 useless =
"a constant";
24703 case NODE_ENCODING:
24706 case NODE_RATIONAL:
24707 case NODE_IMAGINARY:
24712 useless =
"a literal";
24737 useless =
"defined?";
24742 rb_warn1L(nd_line(node),
"possibly useless use of %s in void context", WARN_S(useless));
24750 NODE *
const n = node;
24752 if (!node)
return n;
24753 if (!nd_type_p(node, NODE_BLOCK))
return n;
24755 while (RNODE_BLOCK(node)->nd_next) {
24756 void_expr(p, RNODE_BLOCK(node)->nd_head);
24757 node = RNODE_BLOCK(node)->nd_next;
24759 return RNODE_BLOCK(node)->nd_head;
24763 remove_begin(
NODE *node)
24765 NODE **n = &node, *n1 = node;
24766 while (n1 && nd_type_p(n1, NODE_BEGIN) && RNODE_BEGIN(n1)->nd_body) {
24767 *n = n1 = RNODE_BEGIN(n1)->nd_body;
24775 NODE *node = *body;
24778 *body = NEW_NIL(&NULL_LOC);
24781 #define subnodes(type, n1, n2) \
24782 ((!type(node)->n1) ? (type(node)->n2 ? (body = &type(node)->n2, 1) : 0) : \
24783 (!type(node)->n2) ? (body = &type(node)->n1, 1) : \
24784 (reduce_nodes(p, &type(node)->n1), body = &type(node)->n2, 1))
24787 int newline = (int)nd_fl_newline(node);
24788 switch (nd_type(node)) {
24794 *body = node = RNODE_BEGIN(node)->nd_body;
24795 if (newline && node) nd_set_fl_newline(node);
24798 body = &RNODE_BLOCK(RNODE_BLOCK(node)->nd_end)->nd_head;
24802 if (subnodes(RNODE_IF, nd_body, nd_else))
break;
24805 body = &RNODE_CASE(node)->nd_body;
24808 if (!subnodes(RNODE_WHEN, nd_body, nd_next))
goto end;
24811 body = &RNODE_ENSURE(node)->nd_head;
24815 if (RNODE_RESCUE(node)->nd_else) {
24816 body = &RNODE_RESCUE(node)->nd_resq;
24819 if (!subnodes(RNODE_RESCUE, nd_head, nd_resq))
goto end;
24825 if (newline && node) nd_set_fl_newline(node);
24832 is_static_content(
NODE *node)
24834 if (!node)
return 1;
24835 switch (nd_type(node)) {
24837 if (!(node = RNODE_HASH(node)->nd_head))
break;
24840 if (!is_static_content(RNODE_LIST(node)->nd_head))
return 0;
24841 }
while ((node = RNODE_LIST(node)->nd_next) != 0);
24846 case NODE_ENCODING:
24849 case NODE_RATIONAL:
24850 case NODE_IMAGINARY:
24866 switch (nd_type(node)) {
24880 if (!get_nd_value(p, node))
return 1;
24881 if (is_static_content(get_nd_value(p, node))) {
24883 rb_warn0L(nd_line(get_nd_value(p, node)),
"found '= literal' in conditional, should be ==");
24894 #define SWITCH_BY_COND_TYPE(t, w, arg) do { \
24896 case COND_IN_OP: break; \
24897 case COND_IN_COND: rb_##w##0(arg "literal in condition"); break; \
24898 case COND_IN_FF: rb_##w##0(arg "literal in flip-flop"); break; \
24907 enum node_type
type;
24909 if (node == 0)
return 0;
24911 type = nd_type(node);
24913 if (
type == NODE_INTEGER) {
24914 if (!e_option_supplied(p)) rb_warn0L(nd_line(node),
"integer literal in flip-flop");
24916 return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(lineno, loc), loc), loc);
24918 return cond0(p, node, COND_IN_FF, loc,
true);
24924 if (node == 0)
return 0;
24925 if (!(node = nd_once_body(node)))
return 0;
24926 assign_in_cond(p, node);
24928 switch (nd_type(node)) {
24930 RNODE_BEGIN(node)->nd_body = cond0(p, RNODE_BEGIN(node)->nd_body,
type, loc, top);
24937 SWITCH_BY_COND_TYPE(
type, warn,
"string ");
24941 if (!e_option_supplied(p)) SWITCH_BY_COND_TYPE(
type, warn,
"regex ");
24942 nd_set_type(node, NODE_MATCH);
24946 if (!e_option_supplied(p)) SWITCH_BY_COND_TYPE(
type, warning,
"regex ");
24948 return NEW_MATCH2(node, NEW_GVAR(idLASTLINE, loc), loc);
24952 NODE *end = RNODE_BLOCK(node)->nd_end;
24953 NODE **expr = &RNODE_BLOCK(end)->nd_head;
24954 if (top) top = node == end;
24955 *expr = cond0(p, *expr,
type, loc, top);
24961 RNODE_AND(node)->nd_1st = cond0(p, RNODE_AND(node)->nd_1st, COND_IN_COND, loc,
true);
24962 RNODE_AND(node)->nd_2nd = cond0(p, RNODE_AND(node)->nd_2nd, COND_IN_COND, loc,
true);
24968 RNODE_DOT2(node)->nd_beg = range_op(p, RNODE_DOT2(node)->nd_beg, loc);
24969 RNODE_DOT2(node)->nd_end = range_op(p, RNODE_DOT2(node)->nd_end, loc);
24970 switch (nd_type(node)) {
24972 nd_set_type(node,NODE_FLIP2);
24977 nd_set_type(node, NODE_FLIP3);
24986 SWITCH_BY_COND_TYPE(
type, warning,
"symbol ");
24990 SWITCH_BY_COND_TYPE(
type, warning,
"");
24993 case NODE_ENCODING:
24994 SWITCH_BY_COND_TYPE(
type, warning,
"");
24999 case NODE_RATIONAL:
25000 case NODE_IMAGINARY:
25001 SWITCH_BY_COND_TYPE(
type, warning,
"");
25013 if (node == 0)
return 0;
25014 return cond0(p, node, COND_IN_COND, loc,
true);
25020 if (node == 0)
return 0;
25021 return cond0(p, node, COND_IN_OP, loc,
true);
25028 return NEW_NIL(&loc);
25034 if (!cc)
return right;
25035 cc = cond0(p, cc, COND_IN_COND, loc,
true);
25036 return newline_node(NEW_IF(cc, left, right, loc));
25042 if (!cc)
return right;
25043 cc = cond0(p, cc, COND_IN_COND, loc,
true);
25044 return newline_node(NEW_UNLESS(cc, left, right, loc, keyword_loc, then_keyword_loc, end_keyword_loc));
25047 #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))
25053 enum node_type
type =
id == idAND ||
id == idANDOP ? NODE_AND : NODE_OR;
25056 if (left && nd_type_p(left,
type)) {
25057 NODE *node = left, *second;
25058 while ((second = RNODE_AND(node)->nd_2nd) != 0 && nd_type_p(second,
type)) {
25061 RNODE_AND(node)->nd_2nd = NEW_AND_OR(
type, second, right, loc, op_loc);
25062 nd_set_line(RNODE_AND(node)->nd_2nd, op_loc->beg_pos.lineno);
25063 left->nd_loc.end_pos = loc->end_pos;
25066 op = NEW_AND_OR(
type, left, right, loc, op_loc);
25067 nd_set_line(op, op_loc->beg_pos.lineno);
25076 if (nd_type_p(node, NODE_BLOCK_PASS)) {
25077 compile_error(p,
"block argument should not be given");
25085 no_blockarg(p, node);
25086 if (nd_type_p(node, NODE_LIST) && !RNODE_LIST(node)->nd_next) {
25087 node = RNODE_LIST(node)->nd_head;
25096 if (node) no_blockarg(p, node);
25098 return NEW_YIELD(node, loc);
25104 switch (nd_type(node)) {
25106 RNODE_INTEGER(node)->minus = TRUE;
25109 RNODE_FLOAT(node)->minus = TRUE;
25111 case NODE_RATIONAL:
25112 RNODE_RATIONAL(node)->minus = TRUE;
25114 case NODE_IMAGINARY:
25115 RNODE_IMAGINARY(node)->minus = TRUE;
25125 if (!node1)
return (
NODE *)node2;
25126 node2->nd_head = node1;
25127 nd_set_first_lineno(node2, nd_first_lineno(node1));
25128 nd_set_first_column(node2, nd_first_column(node1));
25129 return (
NODE *)node2;
25137 if (args->pre_args_num)
return false;
25138 if (args->post_args_num)
return false;
25139 if (args->rest_arg)
return false;
25140 if (args->opt_args)
return false;
25141 if (args->block_arg)
return false;
25142 if (args->kw_args)
return false;
25143 if (args->kw_rest_arg)
return false;
25152 if (args->forwarding) {
25154 yyerror1(&RNODE(tail)->nd_loc,
"... after rest argument");
25157 rest_arg = idFWD_REST;
25160 args->pre_args_num = pre_args ? pre_args->nd_plen : 0;
25161 args->pre_init = pre_args ? pre_args->nd_next : 0;
25163 args->post_args_num = post_args ? post_args->nd_plen : 0;
25164 args->post_init = post_args ? post_args->nd_next : 0;
25165 args->first_post_arg = post_args ? post_args->nd_pid : 0;
25167 args->rest_arg = rest_arg;
25169 args->opt_args = opt_args;
25171 #ifdef FORWARD_ARGS_WITH_RUBY2_KEYWORDS
25172 args->ruby2_keywords = args->forwarding;
25174 args->ruby2_keywords = 0;
25177 nd_set_loc(RNODE(tail), loc);
25187 if (p->error_p)
return node;
25189 args->block_arg = block;
25190 args->kw_args = kw_args;
25199 ID kw_bits = internal_id(p), *required_kw_vars, *kw_vars;
25200 struct vtable *vtargs = p->lvtbl->args;
25203 if (block) block = vtargs->tbl[vtargs->pos-1];
25204 vtable_pop(vtargs, !!block + !!kw_rest_arg);
25205 required_kw_vars = kw_vars = &vtargs->tbl[vtargs->pos];
25207 if (!NODE_REQUIRED_KEYWORD_P(get_nd_value(p, kwn->nd_body)))
25209 --required_kw_vars;
25210 kwn = kwn->nd_next;
25213 for (kwn = kw_args; kwn; kwn = kwn->nd_next) {
25214 ID vid = get_nd_vid(p, kwn->nd_body);
25215 if (NODE_REQUIRED_KEYWORD_P(get_nd_value(p, kwn->nd_body))) {
25216 *required_kw_vars++ = vid;
25223 arg_var(p, kw_bits);
25224 if (kw_rest_arg) arg_var(p, kw_rest_arg);
25225 if (block) arg_var(p, block);
25227 args->kw_rest_arg = NEW_DVAR(kw_rest_arg, kw_rest_loc);
25229 else if (kw_rest_arg == idNil) {
25230 args->no_kwarg = 1;
25232 else if (kw_rest_arg) {
25233 args->kw_rest_arg = NEW_DVAR(kw_rest_arg, kw_rest_loc);
25242 if (max_numparam > NO_PARAM || it_id) {
25244 YYLTYPE loc = RUBY_INIT_YYLLOC();
25245 args = new_args_tail(p, 0, 0, 0, 0);
25246 nd_set_loc(RNODE(args), &loc);
25248 args->nd_ainfo.pre_args_num = it_id ? 1 : max_numparam;
25256 RNODE_ARYPTN(aryptn)->nd_pconst = constant;
25259 NODE *pre_args = NEW_LIST(pre_arg, loc);
25260 if (RNODE_ARYPTN(aryptn)->pre_args) {
25261 RNODE_ARYPTN(aryptn)->pre_args = list_concat(pre_args, RNODE_ARYPTN(aryptn)->pre_args);
25264 RNODE_ARYPTN(aryptn)->pre_args = pre_args;
25274 rest_arg = rest_arg ? rest_arg : NODE_SPECIAL_NO_NAME_REST;
25279 NODE *node = NEW_ARYPTN(pre_args, rest_arg, post_args, loc);
25287 RNODE_FNDPTN(fndptn)->nd_pconst = constant;
25295 pre_rest_arg = pre_rest_arg ? pre_rest_arg : NODE_SPECIAL_NO_NAME_REST;
25296 post_rest_arg = post_rest_arg ? post_rest_arg : NODE_SPECIAL_NO_NAME_REST;
25297 NODE *node = NEW_FNDPTN(pre_rest_arg, args, post_rest_arg, loc);
25305 RNODE_HSHPTN(hshptn)->nd_pconst = constant;
25312 NODE *node, *kw_rest_arg_node;
25314 if (kw_rest_arg == idNil) {
25315 kw_rest_arg_node = NODE_SPECIAL_NO_REST_KEYWORD;
25317 else if (kw_rest_arg) {
25318 kw_rest_arg_node = assignable(p, kw_rest_arg, 0, loc);
25321 kw_rest_arg_node = NULL;
25324 node = NEW_HSHPTN(0, kw_args, kw_rest_arg_node, loc);
25333 return NEW_SYM(STR_NEW0(), loc);
25336 switch (nd_type(node)) {
25338 nd_set_type(node, NODE_DSYM);
25339 nd_set_loc(node, loc);
25342 node = str_to_sym_node(p, node, loc);
25345 node = NEW_DSYM(0, 1, NEW_LIST(node, loc), loc);
25352 nd_type_st_key_enable_p(
NODE *node)
25354 switch (nd_type(node)) {
25357 case NODE_RATIONAL:
25358 case NODE_IMAGINARY:
25364 case NODE_ENCODING:
25374 switch (nd_type(node)) {
25376 return rb_node_str_string_val(node);
25378 return rb_node_integer_literal_val(node);
25380 return rb_node_float_literal_val(node);
25381 case NODE_RATIONAL:
25382 return rb_node_rational_literal_val(node);
25383 case NODE_IMAGINARY:
25384 return rb_node_imaginary_literal_val(node);
25386 return rb_node_sym_string_val(node);
25388 return rb_node_regx_string_val(node);
25390 return rb_node_line_lineno_val(node);
25391 case NODE_ENCODING:
25392 return rb_node_encoding_val(node);
25394 return rb_node_file_path_val(node);
25396 rb_bug(
"unexpected node: %s", ruby_node_name(nd_type(node)));
25405 p->warn_duplicate_keys_table = st_init_table_with_size(&literal_type, RNODE_LIST(hash)->as.nd_alen / 2);
25406 while (hash && RNODE_LIST(hash)->nd_next) {
25407 NODE *head = RNODE_LIST(hash)->nd_head;
25408 NODE *value = RNODE_LIST(hash)->nd_next;
25409 NODE *next = RNODE_LIST(value)->nd_next;
25418 if (nd_type_st_key_enable_p(head)) {
25419 key = (st_data_t)head;
25421 if (st_delete(p->warn_duplicate_keys_table, &key, &data)) {
25422 rb_warn2L(nd_line((
NODE *)data),
25423 "key %+"PRIsWARN
" is duplicated and overwritten on line %d",
25424 nd_value(p, head), WARN_I(nd_line(head)));
25426 st_insert(p->warn_duplicate_keys_table, (st_data_t)key, (st_data_t)hash);
25430 st_free_table(p->warn_duplicate_keys_table);
25431 p->warn_duplicate_keys_table = NULL;
25437 if (hash) warn_duplicate_keys(p, hash);
25438 return NEW_HASH(hash, loc);
25444 if (is_private_local_id(p,
id)) {
25447 if (st_is_member(p->pvtbl,
id)) {
25448 yyerror1(loc,
"duplicated variable name");
25451 st_insert(p->pvtbl, (st_data_t)
id, 0);
25459 p->pktbl = st_init_numtable();
25461 else if (st_is_member(p->pktbl, key)) {
25462 yyerror1(loc,
"duplicated key name");
25465 st_insert(p->pktbl, (st_data_t)key, 0);
25471 return NEW_HASH(hash, loc);
25480 ID vid = get_nd_vid(p, lhs);
25481 YYLTYPE lhs_loc = lhs->nd_loc;
25483 set_nd_value(p, lhs, rhs);
25484 nd_set_loc(lhs, loc);
25485 asgn = NEW_OP_ASGN_OR(gettable(p, vid, &lhs_loc), lhs, loc);
25487 else if (op == tANDOP) {
25488 set_nd_value(p, lhs, rhs);
25489 nd_set_loc(lhs, loc);
25490 asgn = NEW_OP_ASGN_AND(gettable(p, vid, &lhs_loc), lhs, loc);
25494 rhs = NEW_CALL(gettable(p, vid, &lhs_loc), op, NEW_LIST(rhs, &rhs->nd_loc), loc);
25495 set_nd_value(p, asgn, rhs);
25496 nd_set_loc(asgn, loc);
25500 asgn = NEW_ERROR(loc);
25512 aryset_check(p, args);
25513 args = make_list(args, args_loc);
25514 asgn = NEW_OP_ASGN1(ary, op, args, rhs, loc, call_operator_loc, opening_loc, closing_loc, binary_operator_loc);
25526 asgn = NEW_OP_ASGN2(lhs, CALL_Q_P(atype), attr, op, rhs, loc, call_operator_loc, message_loc, binary_operator_loc);
25537 asgn = NEW_OP_CDECL(lhs, op, rhs, ctxt.shareable_constant_value, loc);
25540 asgn = NEW_ERROR(loc);
25549 if (p->ctxt.in_def) {
25551 yyerror1(loc,
"dynamic constant assignment");
25553 set_value(assign_error(p,
"dynamic constant assignment", p->s_lvalue));
25556 return NEW_CDECL(0, 0, (path), p->ctxt.shareable_constant_value, loc);
25563 a = dispatch2(assign_error, ERR_MESG(), a);
25572 NODE *result = head;
25574 NODE *tmp = rescue_else ? rescue_else : rescue;
25575 YYLTYPE rescue_loc = code_loc_gen(&head->nd_loc, &tmp->nd_loc);
25577 result = NEW_RESCUE(head, rescue, rescue_else, &rescue_loc);
25578 nd_set_line(result, rescue->nd_loc.beg_pos.lineno);
25581 result = NEW_ENSURE(result, ensure, loc);
25583 fixpos(result, head);
25592 if (!local->used)
return;
25593 cnt = local->used->pos;
25594 if (cnt != local->vars->pos) {
25595 rb_parser_fatal(p,
"local->used->pos != local->vars->pos");
25598 ID *v = local->vars->tbl;
25599 ID *u = local->used->tbl;
25600 for (
int i = 0; i < cnt; ++i) {
25601 if (!v[i] || (u[i] & LVAR_USED))
continue;
25602 if (is_private_local_id(p, v[i]))
continue;
25603 rb_warn1L((
int)u[i],
"assigned but unused variable - %"PRIsWARN,
rb_id2str(v[i]));
25612 int inherits_dvars = toplevel_scope && compile_for_eval;
25616 local->prev = p->lvtbl;
25617 local->args = vtable_alloc(0);
25618 local->vars = vtable_alloc(inherits_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
25620 if (toplevel_scope && compile_for_eval) warn_unused_vars = 0;
25621 if (toplevel_scope && e_option_supplied(p)) warn_unused_vars = 0;
25623 local->numparam.outer = 0;
25624 local->numparam.inner = 0;
25625 local->numparam.current = 0;
25627 local->used = warn_unused_vars ? vtable_alloc(0) : 0;
25629 # if WARN_PAST_SCOPE
25640 while (!DVARS_TERMINAL_P(table)) {
25641 struct vtable *cur_table = table;
25642 table = cur_table->prev;
25643 vtable_free(cur_table);
25650 vtable_chain_free(p, local->used);
25652 # if WARN_PAST_SCOPE
25653 vtable_chain_free(p, local->past);
25656 vtable_chain_free(p, local->args);
25657 vtable_chain_free(p, local->vars);
25659 ruby_sized_xfree(local,
sizeof(
struct local_vars));
25666 if (p->lvtbl->used) {
25667 warn_unused_var(p, p->lvtbl);
25670 local_free(p, p->lvtbl);
25680 int cnt_args = vtable_size(p->lvtbl->args);
25681 int cnt_vars = vtable_size(p->lvtbl->vars);
25682 int cnt = cnt_args + cnt_vars;
25686 if (cnt <= 0)
return 0;
25687 tbl = rb_ast_new_local_table(p->ast, cnt);
25688 MEMCPY(tbl->ids, p->lvtbl->args->tbl,
ID, cnt_args);
25690 for (i = 0, j = cnt_args; i < cnt_vars; ++i) {
25691 ID id = p->lvtbl->vars->tbl[i];
25692 if (!vtable_included(p->lvtbl->args,
id)) {
25693 tbl->ids[j++] = id;
25697 tbl = rb_ast_resize_latest_local_table(p->ast, j);
25706 if (!NUMPARAM_ID_P(
id))
return;
25707 compile_error(p,
"_%d is reserved for numbered parameter",
25708 NUMPARAM_ID_TO_IDX(
id));
25714 numparam_name(p,
id);
25715 vtable_add(p->lvtbl->args,
id);
25721 numparam_name(p,
id);
25722 vtable_add(p->lvtbl->vars,
id);
25723 if (p->lvtbl->used) {
25724 vtable_add(p->lvtbl->used, (
ID)p->ruby_sourceline);
25732 return rb_local_defined(
id, iseq);
25739 struct vtable *vars, *args, *used;
25741 vars = p->lvtbl->vars;
25742 args = p->lvtbl->args;
25743 used = p->lvtbl->used;
25745 while (vars && !DVARS_TERMINAL_P(vars->prev)) {
25748 if (used) used = used->prev;
25751 if (vars && vars->prev == DVARS_INHERIT) {
25752 return rb_parser_local_defined(p,
id, p->parent_iseq);
25754 else if (vtable_included(args,
id)) {
25758 int i = vtable_included(vars,
id);
25759 if (i && used && vidrefp) *vidrefp = &used->tbl[i-1];
25767 return local_id_ref(p,
id, NULL);
25773 if (local_id(p, idFWD_ALL))
return TRUE;
25774 compile_error(p,
"unexpected ...");
25781 arg_var(p, idFWD_REST);
25782 #ifndef FORWARD_ARGS_WITH_RUBY2_KEYWORDS
25783 arg_var(p, idFWD_KWREST);
25785 arg_var(p, idFWD_BLOCK);
25786 arg_var(p, idFWD_ALL);
25792 bool conflict =
false;
25794 struct vtable *vars, *args;
25796 vars = p->lvtbl->vars;
25797 args = p->lvtbl->args;
25799 while (vars && !DVARS_TERMINAL_P(vars->prev)) {
25800 conflict |= (vtable_included(args, arg) && !(all && vtable_included(args, all)));
25805 bool found =
false;
25806 if (vars && vars->prev == DVARS_INHERIT && !found) {
25807 found = (rb_parser_local_defined(p, arg, p->parent_iseq) &&
25808 !(all && rb_parser_local_defined(p, all, p->parent_iseq)));
25811 found = (vtable_included(args, arg) &&
25812 !(all && vtable_included(args, all)));
25816 compile_error(p,
"no anonymous %s parameter", var);
25818 else if (conflict) {
25819 compile_error(p,
"anonymous %s parameter is also used within block", var);
25826 NODE *rest = NEW_LVAR(idFWD_REST, loc);
25827 #ifndef FORWARD_ARGS_WITH_RUBY2_KEYWORDS
25828 NODE *kwrest = list_append(p, NEW_LIST(0, loc), NEW_LVAR(idFWD_KWREST, loc));
25831 NODE *args = leading ? rest_arg_append(p, leading, rest, argsloc) : NEW_SPLAT(rest, loc, &NULL_LOC);
25832 block->forwarding = TRUE;
25833 #ifndef FORWARD_ARGS_WITH_RUBY2_KEYWORDS
25834 args = arg_append(p, args, new_hash(p, kwrest, loc), argsloc);
25836 return arg_blk_pass(args, block);
25843 NODE *inner = local->numparam.inner;
25844 if (!local->numparam.outer) {
25845 local->numparam.outer = local->numparam.current;
25847 local->numparam.inner = 0;
25848 local->numparam.current = 0;
25859 local->numparam.inner = prev_inner;
25861 else if (local->numparam.current) {
25863 local->numparam.inner = local->numparam.current;
25865 if (p->max_numparam > NO_PARAM) {
25867 local->numparam.current = local->numparam.outer;
25868 local->numparam.outer = 0;
25872 local->numparam.current = 0;
25877 static const struct vtable *
25880 p->lvtbl->args = vtable_alloc(p->lvtbl->args);
25881 p->lvtbl->vars = vtable_alloc(p->lvtbl->vars);
25882 if (p->lvtbl->used) {
25883 p->lvtbl->used = vtable_alloc(p->lvtbl->used);
25885 return p->lvtbl->args;
25891 struct vtable *tmp = *vtblp;
25892 *vtblp = tmp->prev;
25893 # if WARN_PAST_SCOPE
25894 if (p->past_scope_enabled) {
25895 tmp->prev = p->lvtbl->past;
25896 p->lvtbl->past = tmp;
25908 if ((tmp = p->lvtbl->used) != 0) {
25909 warn_unused_var(p, p->lvtbl);
25910 p->lvtbl->used = p->lvtbl->used->prev;
25913 dyna_pop_vtable(p, &p->lvtbl->args);
25914 dyna_pop_vtable(p, &p->lvtbl->vars);
25920 while (p->lvtbl->args != lvargs) {
25922 if (!p->lvtbl->args) {
25924 ruby_sized_xfree(p->lvtbl,
sizeof(*p->lvtbl));
25934 return !DVARS_TERMINAL_P(p->lvtbl->vars) && p->lvtbl->vars->prev != DVARS_TOPSCOPE;
25941 struct vtable *vars, *args, *used;
25944 args = p->lvtbl->args;
25945 vars = p->lvtbl->vars;
25946 used = p->lvtbl->used;
25948 while (!DVARS_TERMINAL_P(vars)) {
25949 if (vtable_included(args,
id)) {
25952 if ((i = vtable_included(vars,
id)) != 0) {
25953 if (used && vidrefp) *vidrefp = &used->tbl[i-1];
25958 if (!vidrefp) used = 0;
25959 if (used) used = used->prev;
25962 if (vars == DVARS_INHERIT && !NUMPARAM_ID_P(
id)) {
25963 return rb_dvar_defined(
id, p->parent_iseq);
25973 return dvar_defined_ref(p,
id, NULL);
25979 return (vtable_included(p->lvtbl->args,
id) ||
25980 vtable_included(p->lvtbl->vars,
id));
25987 "regexp encoding option '%c' differs from source encoding '%s'",
25988 c,
rb_enc_name(rb_parser_str_get_encoding(str)));
25997 rb_bug(
"unknown encoding name: %s", name);
26009 case ENC_ASCII8BIT:
26013 enc = find_enc(p,
"EUC-JP");
26015 case ENC_Windows_31J:
26016 enc = find_enc(p,
"Windows-31J");
26032 int c = RE_OPTION_ENCODING_IDX(options);
26038 char_to_option_kcode(c, &opt, &idx);
26039 enc = kcode_to_enc(p, idx);
26040 if (enc != rb_parser_str_get_encoding(str) &&
26041 !rb_parser_is_ascii_string(p, str)) {
26044 rb_parser_string_set_encoding(str, enc);
26046 else if (RE_OPTION_ENCODING_NONE(options)) {
26047 if (!PARSER_ENCODING_IS_ASCII8BIT(p, str) &&
26048 !rb_parser_is_ascii_string(p, str)) {
26054 else if (rb_is_usascii_enc(p->enc)) {
26055 if (!rb_parser_is_ascii_string(p, str)) {
26073 int c = rb_reg_fragment_setenc(p, str, options);
26074 if (c) reg_fragment_enc_error(p, str, c);
26082 reg_fragment_setenc(p, str, options);
26084 str2 = rb_str_new_parser_string(str);
26085 err = rb_reg_check_preprocess(str2);
26088 compile_error(p,
"%"PRIsVALUE, err);
26095 #ifndef UNIVERSAL_PARSER
26104 reg_named_capture_assign_iter(
const OnigUChar *name,
const OnigUChar *name_end,
26105 int back_num,
int *back_refs,
OnigRegex regex,
void *arg0)
26110 long len = name_end - name;
26111 const char *s = (
const char *)name;
26113 return rb_reg_named_capture_assign_iter_impl(p, s,
len, enc, &arg->succ_block, arg->loc);
26123 arg.succ_block = 0;
26125 onig_foreach_name(
RREGEXP_PTR(regexp), reg_named_capture_assign_iter, &arg);
26127 if (!arg.succ_block)
return 0;
26128 return RNODE_BLOCK(arg.succ_block)->nd_next;
26134 rb_reg_named_capture_assign_iter_impl(
struct parser_params *p,
const char *s,
long len,
26140 if (!
len)
return ST_CONTINUE;
26141 if (!VALID_SYMNAME_P(s,
len, enc, ID_LOCAL))
26142 return ST_CONTINUE;
26144 var = intern_cstr(s,
len, enc);
26145 if (
len < MAX_WORD_LENGTH && rb_reserved_word(s, (
int)
len)) {
26146 if (!lvar_defined(p, var))
return ST_CONTINUE;
26148 node = node_assign(p, assignable(p, var, 0, loc), NEW_SYM(
rb_id2str(var), loc), NO_LEX_CTXT, loc);
26149 succ = *succ_block;
26150 if (!succ) succ = NEW_ERROR(loc);
26151 succ = block_append(p, succ, node);
26152 *succ_block = succ;
26153 return ST_CONTINUE;
26161 reg_fragment_setenc(p, str, options);
26162 str2 = rb_str_new_parser_string(str);
26163 return rb_parser_reg_compile(p, str2, options);
26170 return rb_reg_compile(str, options & RE_OPTION_MASK, p->ruby_sourcefile, p->ruby_sourceline);
26181 re = parser_reg_compile(p, str, options);
26185 compile_error(p,
"%"PRIsVALUE, m);
26193 rb_ruby_parser_set_options(
struct parser_params *p,
int print,
int loop,
int chomp,
int split)
26195 p->do_print = print;
26197 p->do_chomp = chomp;
26198 p->do_split = split;
26204 static const YYLTYPE default_location = {{1, 0}, {1, 0}};
26205 const YYLTYPE *
const LOC = &default_location;
26209 NEW_LIST(NEW_GVAR(idLASTLINE, LOC), LOC),
26211 node = block_append(p, node, print);
26220 NODE *args = NEW_LIST(NEW_GVAR(ifs, LOC), LOC);
26221 NODE *split = NEW_GASGN(fields,
26222 NEW_CALL(NEW_GVAR(idLASTLINE, LOC),
26225 node = block_append(p, split, node);
26229 chomp = list_append(p, NEW_LIST(chomp, LOC), NEW_TRUE(LOC));
26230 irs = list_append(p, irs, NEW_HASH(chomp, LOC));
26233 node = NEW_WHILE((
NODE *)NEW_FCALL(idGets, irs, LOC), node, 1, LOC, &NULL_LOC, &NULL_LOC);
26240 rb_init_parse(
void)
26250 return rb_make_temporary_id(vtable_size(p->lvtbl->args) + vtable_size(p->lvtbl->vars));
26258 p->command_start = TRUE;
26259 p->ruby_sourcefile_string =
Qnil;
26260 p->lex.lpar_beg = -1;
26261 string_buffer_init(p);
26263 p->delayed.token = NULL;
26264 p->frozen_string_literal = -1;
26266 p->error_buffer =
Qfalse;
26267 p->end_expect_token_locations = NULL;
26272 p->parsing_thread =
Qnil;
26274 p->s_lvalue =
Qnil;
26277 p->debug_buffer =
Qnil;
26284 #define rb_ruby_parser_mark ripper_parser_mark
26285 #define rb_ruby_parser_free ripper_parser_free
26286 #define rb_ruby_parser_memsize ripper_parser_memsize
26290 rb_ruby_parser_mark(
void *
ptr)
26310 rb_ruby_parser_free(
void *
ptr)
26316 rb_ast_free(p->ast);
26319 if (p->warn_duplicate_keys_table) {
26320 st_free_table(p->warn_duplicate_keys_table);
26325 rb_parser_ary_free(p, p->tokens);
26330 ruby_sized_xfree(p->tokenbuf, p->toksiz);
26333 for (local = p->lvtbl; local; local = prev) {
26334 prev = local->prev;
26335 local_free(p, local);
26340 while ((ptinfo = p->token_info) != 0) {
26341 p->token_info = ptinfo->next;
26345 string_buffer_free(p);
26348 st_free_table(p->pvtbl);
26351 if (CASE_LABELS_ENABLED_P(p->case_labels)) {
26352 st_free_table(p->case_labels);
26355 xfree(p->lex.strterm);
26356 p->lex.strterm = 0;
26362 rb_ruby_parser_memsize(
const void *
ptr)
26366 size_t size =
sizeof(*p);
26369 for (local = p->lvtbl; local; local = local->prev) {
26370 size +=
sizeof(*local);
26371 if (local->vars) size += local->vars->capa *
sizeof(
ID);
26377 #undef rb_reserved_word
26380 rb_reserved_word(
const char *str,
unsigned int len)
26382 return reserved_word(str,
len);
26385 #ifdef UNIVERSAL_PARSER
26387 rb_ruby_parser_allocate(
const rb_parser_config_t *config)
26391 p->config = config;
26396 rb_ruby_parser_new(
const rb_parser_config_t *config)
26399 rb_parser_t *p = rb_ruby_parser_allocate(config);
26400 parser_initialize(p);
26405 rb_ruby_parser_allocate(
void)
26413 rb_ruby_parser_new(
void)
26417 parser_initialize(p);
26426 p->parent_iseq = base;
26433 p->debug_lines = rb_parser_ary_new_capa_for_script_line(p, 10);
26439 p->error_tolerant = 1;
26445 p->keep_tokens = 1;
26446 p->tokens = rb_parser_ary_new_capa_for_ast_token(p, 10);
26458 return p->ruby__end__seen;
26462 rb_ruby_parser_set_yydebug(
rb_parser_t *p,
int flag)
26491 return p->debug_output;
26497 p->debug_output = output;
26503 return p->parsing_thread;
26509 p->parsing_thread = parsing_thread;
26513 rb_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)
26515 p->lex.gets = gets;
26516 p->lex.input = input;
26518 p->ruby_sourcefile_string = sourcefile_string;
26519 p->ruby_sourcefile = sourcefile;
26520 p->ruby_sourceline = sourceline;
26536 rb_ruby_parser_ruby_sourcefile_string(
rb_parser_t *p)
26538 return p->ruby_sourcefile_string;
26544 return p->ruby_sourceline;
26550 return p->lex.state;
26557 p->ast = rb_ast_new();
26558 ripper_yyparse((
void*)p);
26559 rb_ast_free(p->ast);
26562 p->eval_tree_begin = 0;
26568 return dedent_string(p,
string, width);
26574 return p->lex.input != 0;
26580 parser_initialize(p);
26586 return p->lex.ptok - p->lex.pbeg;
26592 return p->lex.pcur - p->lex.ptok;
26598 return p->lex.lastline;
26602 rb_ruby_ripper_lex_state_name(
struct parser_params *p,
int state)
26604 return rb_parser_lex_state_name(p, (
enum lex_state_e)state);
26607 #ifdef UNIVERSAL_PARSER
26609 rb_ripper_parser_params_allocate(
const rb_parser_config_t *config)
26612 p->config = config;
26618 rb_ruby_ripper_parser_allocate(
void)
26626 rb_parser_printf(
struct parser_params *p,
const char *fmt, ...)
26629 VALUE mesg = p->debug_buffer;
26635 if (char_at_end(p, mesg, 0) ==
'\n') {
26637 p->debug_buffer =
Qnil;
26645 int lineno, column;
26648 lineno = loc->end_pos.lineno;
26649 column = loc->end_pos.column;
26652 lineno = p->ruby_sourceline;
26660 rb_syntax_error_append(p->error_buffer,
26661 p->ruby_sourcefile_string,
26668 count_char(
const char *str,
int c)
26671 while (str[n] == c) ++n;
26682 rb_yytnamerr(
struct parser_params *p,
char *yyres,
const char *yystr)
26684 if (*yystr ==
'"') {
26685 size_t yyn = 0, bquote = 0;
26686 const char *yyp = yystr;
26692 bquote = count_char(yyp+1,
'\'') + 1;
26693 if (yyres) memcpy(&yyres[yyn], yyp, bquote);
26699 if (bquote && count_char(yyp+1,
'\'') + 1 == bquote) {
26700 if (yyres) memcpy(yyres + yyn, yyp, bquote);
26706 if (yyp[1] && yyp[1] !=
'\'' && yyp[2] ==
'\'') {
26707 if (yyres) memcpy(yyres + yyn, yyp, 3);
26712 goto do_not_strip_quotes;
26716 goto do_not_strip_quotes;
26719 if (*++yyp !=
'\\')
26720 goto do_not_strip_quotes;
26735 do_not_strip_quotes: ;
26738 if (!yyres)
return strlen(yystr);
26740 return (YYSIZE_T)(yystpcpy(yyres, yystr) - yyres);
26745 #define validate(x) (void)(x)
26774 return rb_funcall(p->value, mid, 3, a, b, c);
26784 return rb_funcall(p->value, mid, 4, a, b, c, d);
26795 return rb_funcall(p->value, mid, 5, a, b, c, d, e);
26808 return rb_funcall(p->value, mid, 7, a, b, c, d, e, f, g);
static bool rb_enc_isascii(OnigCodePoint c, rb_encoding *enc)
Identical to rb_isascii(), except it additionally takes an encoding.
static bool rb_enc_isspace(OnigCodePoint c, rb_encoding *enc)
Identical to rb_isspace(), except it additionally takes an encoding.
static bool rb_enc_isalnum(OnigCodePoint c, rb_encoding *enc)
Identical to rb_isalnum(), except it additionally takes an encoding.
#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_raise(VALUE exc, const char *fmt,...)
Exception entry point.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
void rb_bug(const char *fmt,...)
Interpreter panic switch.
void rb_set_errinfo(VALUE err)
Sets the current exception ($!) to the given value.
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
void rb_fatal(const char *fmt,...)
Raises the unsung "fatal" exception.
VALUE rb_eRuntimeError
RuntimeError exception.
VALUE rb_eArgError
ArgumentError exception.
VALUE rb_errinfo(void)
This is the same as $! in Ruby.
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.
int rb_enc_precise_mbclen(const char *p, const char *e, rb_encoding *enc)
Queries the number of bytes of the character at the passed pointer.
rb_encoding * rb_usascii_encoding(void)
Queries the encoding that represents US-ASCII.
int rb_enc_codelen(int code, rb_encoding *enc)
Queries the number of bytes requested to represent the passed code point using the passed encoding.
rb_encoding * rb_ascii8bit_encoding(void)
Queries the encoding that represents ASCII-8BIT a.k.a.
static bool rb_enc_asciicompat(rb_encoding *enc)
Queries if the passed encoding is in some sense compatible with ASCII.
rb_encoding * rb_utf8_encoding(void)
Queries the encoding that represents UTF-8.
static char * rb_enc_prev_char(const char *s, const char *p, const char *e, rb_encoding *enc)
Queries the previous (left) character.
static int rb_enc_mbcput(unsigned int c, void *buf, rb_encoding *enc)
Identical to rb_enc_uint_chr(), except it writes back to the passed buffer instead of allocating one.
rb_encoding * rb_enc_from_index(int idx)
Identical to rb_find_encoding(), except it takes an encoding index instead of a Ruby object.
rb_encoding * rb_enc_get(VALUE obj)
Identical to rb_enc_get_index(), except the return type.
static OnigCodePoint rb_enc_mbc_to_codepoint(const char *p, const char *e, rb_encoding *enc)
Identical to rb_enc_codepoint(), except it assumes the passed character is not broken.
static const char * rb_enc_name(rb_encoding *enc)
Queries the (canonical) name of the passed encoding.
int rb_enc_find_index(const char *name)
Queries the index of the encoding.
static int rb_enc_mbminlen(rb_encoding *enc)
Queries the minimum number of bytes that the passed encoding needs to represent a character.
VALUE rb_enc_str_new(const char *ptr, long len, rb_encoding *enc)
Identical to rb_str_new(), except it additionally takes an encoding.
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.
void rb_gc_mark(VALUE obj)
Marks an object.
VALUE rb_ary_unshift(VALUE ary, VALUE elem)
Destructively prepends the passed item at the beginning of the passed array.
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.
VALUE rb_make_exception(int argc, const VALUE *argv)
Constructs an exception object from the list of arguments, in a manner similar to Ruby's raise.
VALUE rb_io_puts(int argc, const VALUE *argv, VALUE io)
Iterates over the passed array to apply rb_io_write() individually.
VALUE rb_io_write(VALUE io, VALUE str)
Writes the given string to the given IO.
VALUE rb_io_flush(VALUE io)
Flushes any buffered data within the passed IO to the underlying operating system.
ID rb_id_attrset(ID id)
Calculates an ID of attribute writer.
int rb_memcicmp(const void *s1, const void *s2, long n)
Identical to st_locale_insensitive_strcasecmp(), except it is timing safe and returns something diffe...
VALUE rb_str_to_interned_str(VALUE str)
Identical to rb_interned_str(), except it takes a Ruby's string instead of C's.
VALUE rb_str_cat(VALUE dst, const char *src, long srclen)
Destructively appends the passed contents to the string.
VALUE rb_usascii_str_new(const char *ptr, long len)
Identical to rb_str_new(), except it generates a string of "US ASCII" encoding.
#define rb_strlen_lit(str)
Length of a string literal.
VALUE rb_str_new(const char *ptr, long len)
Allocates an instance of rb_cString.
VALUE rb_str_new_cstr(const char *ptr)
Identical to rb_str_new(), except it assumes the passed pointer is a pointer to a C string.
VALUE rb_str_resize(VALUE str, long len)
Overwrites the length of the string.
VALUE rb_str_cat_cstr(VALUE dst, const char *src)
Identical to rb_str_cat(), except it assumes the passed pointer is a pointer to a C string.
VALUE rb_obj_as_string(VALUE obj)
Try converting an object to its stringised representation using its to_s method, if any.
VALUE rb_attr_get(VALUE obj, ID name)
Identical to rb_ivar_get()
VALUE rb_make_backtrace(void)
Creates the good old fashioned array-of-strings style backtrace info.
ID rb_intern2(const char *name, long len)
Identical to rb_intern(), except it additionally takes the length of the string.
const char * rb_id2name(ID id)
Retrieves the name mapped to the given id.
ID rb_intern(const char *name)
Finds or creates a symbol of the given name.
ID rb_sym2id(VALUE obj)
Converts an instance of rb_cSymbol into an ID.
ID rb_intern_str(VALUE str)
Identical to rb_intern(), except it takes an instance of rb_cString.
VALUE rb_id2str(ID id)
Identical to rb_id2name(), except it returns a Ruby's String instead of C's.
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
int len
Length of the buffer.
VALUE rb_ractor_stderr(void)
Queries the standard error of the current Ractor that is calling this function.
VALUE rb_ractor_stdout(void)
Queries the standard output of the current Ractor that is calling this function.
unsigned long ruby_scan_hex(const char *str, size_t len, size_t *ret)
Interprets the passed string a hexadecimal unsigned integer.
#define strtod(s, e)
Just another name of ruby_strtod.
unsigned long ruby_scan_oct(const char *str, size_t len, size_t *consumed)
Interprets the passed string as an octal unsigned integer.
unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow)
Scans the passed string, assuming the string is a textual representation of an integer.
#define strdup(s)
Just another name of ruby_strdup.
VALUE rb_sprintf(const char *fmt,...)
Ruby's extended sprintf(3).
VALUE rb_str_vcatf(VALUE dst, const char *fmt, va_list ap)
Identical to rb_str_catf(), except it takes a va_list.
VALUE rb_str_catf(VALUE dst, const char *fmt,...)
Identical to rb_sprintf(), except it renders the output to the specified object rather than creating ...
#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.
static char * RSTRING_PTR(VALUE str)
Queries the contents pointer of the string.
static long RSTRING_LEN(VALUE str)
Queries the length of the string.
#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.
void * ruby_xcalloc(size_t nelems, size_t elemsiz)
Identical to ruby_xmalloc2(), except it returns a zero-filled storage instance.