NEW_CHILD(ast, RNODE_HSHPTN(node)->nd_pkwargs),

kwrest);

}

case NODE_ERROR:

return rb_ary_new_from_node_args(ast, 0);

case NODE_ARGS_AUX:

compile.$(OBJEXT): $(top_srcdir)/internal/object.h

compile.$(OBJEXT): $(top_srcdir)/internal/rational.h

compile.$(OBJEXT): $(top_srcdir)/internal/re.h

compile.$(OBJEXT): $(top_srcdir)/internal/serial.h

compile.$(OBJEXT): $(top_srcdir)/internal/static_assert.h

compile.$(OBJEXT): $(top_srcdir)/internal/string.h

ruby.$(OBJEXT): {$(VPATH)}vm_core.h

ruby.$(OBJEXT): {$(VPATH)}vm_opts.h

ruby.$(OBJEXT): {$(VPATH)}yjit.h

ruby_parser.$(OBJEXT): {$(VPATH)}ruby_parser.c

scheduler.$(OBJEXT): $(CCAN_DIR)/check_type/check_type.h

scheduler.$(OBJEXT): $(CCAN_DIR)/container_of/container_of.h

scheduler.$(OBJEXT): $(CCAN_DIR)/list/list.h

#include "internal/object.h"

#include "internal/rational.h"

#include "internal/re.h"

#include "internal/symbol.h"

#include "internal/thread.h"

#include "internal/variable.h"

case NODE_LIT:

dv = RNODE_LIT(val_node)->nd_lit;

break;

case NODE_NIL:

dv = Qnil;

break;

}

goto again;

case NODE_LIT: /* NODE_LIT is always true */

case NODE_TRUE:

case NODE_STR:

case NODE_ZLIST:

{

switch (nd_type(node)) {

case NODE_LIT:

case NODE_NIL:

case NODE_TRUE:

case NODE_FALSE:

return Qtrue;

case NODE_FALSE:

return Qfalse;

case NODE_STR:

if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal || RTEST(ruby_debug)) {

VALUE lit;

return Qtrue;

case NODE_FALSE:

return Qfalse;

case NODE_STR:

return rb_fstring(RNODE_STR(node)->nd_lit);

}

/* fall through */

case NODE_STR:

case NODE_LIT:

case NODE_ZLIST:

case NODE_AND:

case NODE_OR:

switch (nd_type(n)) {

case NODE_LIT:

return RB_INTEGER_TYPE_P(RNODE_LIT(n)->nd_lit);

case NODE_NIL:

return TRUE;

default:

}

}

static int

compile_if(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const NODE *const node, int popped, const enum node_type type)

{

break;

}

case NODE_LIT:

case NODE_STR:

case NODE_XSTR:

case NODE_DSTR:

if (optimizable_range_item_p(b) && optimizable_range_item_p(e)) {

if (!popped) {

VALUE val = rb_range_new(bv, ev, excl);

ADD_INSN1(ret, node, putobject, val);

RB_OBJ_WRITTEN(iseq, Qundef, val);

return COMPILE_NG;

}

else if (nd_type_p(default_value, NODE_LIT) ||

nd_type_p(default_value, NODE_NIL) ||

nd_type_p(default_value, NODE_TRUE) ||

nd_type_p(default_value, NODE_FALSE)) {

}

break;

}

case NODE_STR:{

debugp_param("nd_lit", RNODE_STR(node)->nd_lit);

if (!popped) {

EXPR_END_ANY = (EXPR_END | EXPR_ENDARG | EXPR_ENDFN),

EXPR_NONE = 0

};

#endif /* INTERNAL_RUBY_PARSE_H */

F_NODE(nd_pkwrestarg, RNODE_HSHPTN, "keyword rest argument");

}

return;

case NODE_ERROR:

ANN("Broken input recovered by Error Tolerant mode");

return;

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);

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);

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);

static rb_node_error_t *rb_node_error_new(struct parser_params *p, const YYLTYPE *loc);

#define NEW_SCOPE(a,b,loc) (NODE *)rb_node_scope_new(p,a,b,loc)

#define NEW_ARYPTN(pre,r,post,loc) (NODE *)rb_node_aryptn_new(p,pre,r,post,loc)

#define NEW_HSHPTN(c,kw,kwrest,loc) (NODE *)rb_node_hshptn_new(p,c,kw,kwrest,loc)

#define NEW_FNDPTN(pre,a,post,loc) (NODE *)rb_node_fndptn_new(p,pre,a,post,loc)

#define NEW_ERROR(loc) (NODE *)rb_node_error_new(p,loc)

#endif

case NODE_DXSTR:

case NODE_DREGX:

case NODE_LIT:

case NODE_DSYM:

case NODE_LIST:

case NODE_ZLIST:

return n;

}

static rb_node_cdecl_t *

rb_node_cdecl_new(struct parser_params *p, ID nd_vid, NODE *nd_value, NODE *nd_else, const YYLTYPE *loc)

{

}

return node;

case keyword__LINE__:

case keyword__ENCODING__:

node = NEW_LIT(rb_enc_from_encoding(p->enc), loc);

RB_OBJ_WRITTEN(p->ast, Qnil, RNODE_LIT(node)->nd_lit);

return Qfalse;

case NODE_NIL:

return Qnil;

case NODE_LIT:

return RNODE_LIT(node)->nd_lit;

default:

case NODE_FALSE:

case NODE_NIL:

case NODE_LIT:

return value;

case NODE_DSTR:

useless = "a constant";

break;

case NODE_LIT:

case NODE_STR:

case NODE_DSTR:

case NODE_DREGX:

if (!is_static_content(RNODE_LIST(node)->nd_head)) return 0;

} while ((node = RNODE_LIST(node)->nd_next) != 0);

case NODE_LIT:

case NODE_STR:

case NODE_NIL:

case NODE_TRUE:

/* This is a wrapper for parse.y */

#ifdef UNIVERSAL_PARSER

#include "internal.h"

#include "internal/parse.h"

#include "internal/rational.h"

#include "internal/re.h"

#include "internal/string.h"

#include "internal/symbol.h"

#include "internal/thread.h"

rb_ruby_parser_set_yydebug(parser->parser_params, RTEST(flag));

return flag;

}

#endif

NODE_HSHPTN,

NODE_FNDPTN,

NODE_ERROR,

NODE_RIPPER,

NODE_RIPPER_VALUES,

NODE_LAST

NODE *post_rest_arg;

} rb_node_fndptn_t;

typedef struct RNode_ERROR {

NODE node;

} rb_node_error_t;

#define RNODE_ARYPTN(node) ((struct RNode_ARYPTN *)(node))

#define RNODE_HSHPTN(node) ((struct RNode_HSHPTN *)(node))

#define RNODE_FNDPTN(node) ((struct RNode_FNDPTN *)(node))

#ifdef RIPPER

typedef struct RNode_RIPPER {