/**********************************************************************

parse.y -

$Author$

created at: Fri May 28 18:02:42 JST 1993

Copyright (C) 1993-2007 Yukihiro Matsumoto

**********************************************************************/

%{

#ifndef PARSER_DEBUG

#define PARSER_DEBUG 0

#endif

#define YYDEBUG 1

#define YYERROR_VERBOSE 1

#define YYSTACK_USE_ALLOCA 0

#include "ruby/ruby.h"

#include "ruby/st.h"

#include "ruby/encoding.h"

#include "internal.h"

#include "node.h"

#include "parse.h"

#include "id.h"

#include "regenc.h"

#include <stdio.h>

#include <errno.h>

#include <ctype.h>

#include "probes.h"

#define YYMALLOC(size) rb_parser_malloc(parser, (size))

#define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))

#define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))

#define YYFREE(ptr) rb_parser_free(parser, (ptr))

#define malloc YYMALLOC

#define realloc YYREALLOC

#define calloc YYCALLOC

#define free YYFREE

#ifndef RIPPER

static ID register_symid(ID, const char *, long, rb_encoding *);

static ID register_symid_str(ID, VALUE);

#define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)

#include "id.c"

#endif

#define is_notop_id(id) ((id)>tLAST_OP_ID)

#define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)

#define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)

#define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)

#define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)

#define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)

#define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)

#define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)

#define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1)

#define is_asgn_or_id(id) ((is_notop_id(id)) && \

(((id)&ID_SCOPE_MASK) == ID_GLOBAL || \

((id)&ID_SCOPE_MASK) == ID_INSTANCE || \

((id)&ID_SCOPE_MASK) == ID_CLASS))

enum lex_state_bits {

EXPR_BEG_bit, /* ignore newline, +/- is a sign. */

EXPR_END_bit, /* newline significant, +/- is an operator. */

EXPR_ENDARG_bit, /* ditto, and unbound braces. */

EXPR_ENDFN_bit, /* ditto, and unbound braces. */

EXPR_ARG_bit, /* newline significant, +/- is an operator. */

EXPR_CMDARG_bit, /* newline significant, +/- is an operator. */

EXPR_MID_bit, /* newline significant, +/- is an operator. */

EXPR_FNAME_bit, /* ignore newline, no reserved words. */

EXPR_DOT_bit, /* right after `.' or `::', no reserved words. */

EXPR_CLASS_bit, /* immediate after `class', no here document. */

EXPR_VALUE_bit, /* alike EXPR_BEG but label is disallowed. */

EXPR_LABELARG_bit, /* ignore significant, +/- is a sign. */

EXPR_MAX_STATE

};

/* examine combinations */

enum lex_state_e {

#define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)

DEF_EXPR(BEG),

DEF_EXPR(END),

DEF_EXPR(ENDARG),

DEF_EXPR(ENDFN),

DEF_EXPR(ARG),

DEF_EXPR(CMDARG),

DEF_EXPR(MID),

DEF_EXPR(FNAME),

DEF_EXPR(DOT),

DEF_EXPR(CLASS),

DEF_EXPR(VALUE),

DEF_EXPR(LABELARG),

EXPR_BEG_ANY = (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS | EXPR_LABELARG),

EXPR_ARG_ANY = (EXPR_ARG | EXPR_CMDARG),

EXPR_END_ANY = (EXPR_END | EXPR_ENDARG | EXPR_ENDFN)

};

#define IS_lex_state_for(x, ls) ((x) & (ls))

#define IS_lex_state(ls) IS_lex_state_for(lex_state, (ls))

#if PARSER_DEBUG

static const char *lex_state_name(enum lex_state_e state);

#endif

typedef VALUE stack_type;

# define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))

# define BITSTACK_POP(stack) ((stack) = (stack) >> 1)

# define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))

# define BITSTACK_SET_P(stack) ((stack)&1)

#define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))

#define COND_POP() BITSTACK_POP(cond_stack)

#define COND_LEXPOP() BITSTACK_LEXPOP(cond_stack)

#define COND_P() BITSTACK_SET_P(cond_stack)

#define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))

#define CMDARG_POP() BITSTACK_POP(cmdarg_stack)

#define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)

#define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)

struct vtable {

ID *tbl;

int pos;

int capa;

struct vtable *prev;

};

struct local_vars {

struct vtable *args;

struct vtable *vars;

struct vtable *used;

struct local_vars *prev;

stack_type cmdargs;

};

#define DVARS_INHERIT ((void*)1)

#define DVARS_TOPSCOPE NULL

#define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))

#define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)

static int

vtable_size(const struct vtable *tbl)

{

if (POINTER_P(tbl)) {

return tbl->pos;

}

else {

return 0;

}

}

#define VTBL_DEBUG 0

static struct vtable *

vtable_alloc(struct vtable *prev)

{

struct vtable *tbl = ALLOC(struct vtable);

tbl->pos = 0;

tbl->capa = 8;

tbl->tbl = ALLOC_N(ID, tbl->capa);

tbl->prev = prev;

if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);

return tbl;

}

static void

vtable_free(struct vtable *tbl)

{

if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);

if (POINTER_P(tbl)) {

if (tbl->tbl) {

xfree(tbl->tbl);

}

xfree(tbl);

}

}

static void

vtable_add(struct vtable *tbl, ID id)

{

if (!POINTER_P(tbl)) {

rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);

}

if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));

if (tbl->pos == tbl->capa) {

tbl->capa = tbl->capa * 2;

REALLOC_N(tbl->tbl, ID, tbl->capa);

}

tbl->tbl[tbl->pos++] = id;

}

static int

vtable_included(const struct vtable * tbl, ID id)

{

int i;

if (POINTER_P(tbl)) {

for (i = 0; i < tbl->pos; i++) {

if (tbl->tbl[i] == id) {

return i+1;

}

}

}

return 0;

}

#ifndef RIPPER

typedef struct token_info {

const char *token;

int linenum;

int column;

int nonspc;

struct token_info *next;

} token_info;

#endif

/*

Structure of Lexer Buffer:

lex_pbeg tokp lex_p lex_pend

| | | |

|-----------+--------------+------------|

|<------------>|

token

*/

struct parser_params {

int is_ripper;

NODE *heap;

YYSTYPE *parser_yylval;

VALUE eofp;

NODE *parser_lex_strterm;

enum lex_state_e parser_lex_state;

stack_type parser_cond_stack;

stack_type parser_cmdarg_stack;

int parser_class_nest;

int parser_paren_nest;

int parser_lpar_beg;

int parser_in_single;

int parser_in_def;

int parser_brace_nest;

int parser_compile_for_eval;

VALUE parser_cur_mid;

int parser_in_kwarg;

int parser_in_defined;

char *parser_tokenbuf;

int parser_tokidx;

int parser_toksiz;

int parser_tokline;

VALUE parser_lex_input;

VALUE parser_lex_lastline;

VALUE parser_lex_nextline;

const char *parser_lex_pbeg;

const char *parser_lex_p;

const char *parser_lex_pend;

int parser_heredoc_end;

int parser_command_start;

NODE *parser_deferred_nodes;

long parser_lex_gets_ptr;

VALUE (*parser_lex_gets)(struct parser_params*,VALUE);

struct local_vars *parser_lvtbl;

int parser_ruby__end__seen;

int line_count;

int has_shebang;

char *parser_ruby_sourcefile; /* current source file */

int parser_ruby_sourceline; /* current line no. */

VALUE parser_ruby_sourcefile_string;

rb_encoding *enc;

int parser_yydebug;

int last_cr_line;

#ifndef RIPPER

/* Ruby core only */

NODE *parser_eval_tree_begin;

NODE *parser_eval_tree;

VALUE debug_lines;

VALUE coverage;

int nerr;

int parser_token_info_enabled;

token_info *parser_token_info;

#else

/* Ripper only */

const char *tokp;

VALUE delayed;

int delayed_line;

int delayed_col;

VALUE value;

VALUE result;

VALUE parsing_thread;

int toplevel_p;

#endif

};

#define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)

#define STR_NEW0() rb_enc_str_new(0,0,current_enc)

#define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)

#define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)

#define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)

#define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)

static int parser_yyerror(struct parser_params*, const char*);

#define yyerror(msg) parser_yyerror(parser, (msg))

#define lex_strterm (parser->parser_lex_strterm)

#define lex_state (parser->parser_lex_state)

#define cond_stack (parser->parser_cond_stack)

#define cmdarg_stack (parser->parser_cmdarg_stack)

#define class_nest (parser->parser_class_nest)

#define paren_nest (parser->parser_paren_nest)

#define lpar_beg (parser->parser_lpar_beg)

#define brace_nest (parser->parser_brace_nest)

#define in_single (parser->parser_in_single)

#define in_def (parser->parser_in_def)

#define compile_for_eval (parser->parser_compile_for_eval)

#define cur_mid (parser->parser_cur_mid)

#define in_defined (parser->parser_in_defined)

#define tokenbuf (parser->parser_tokenbuf)

#define tokidx (parser->parser_tokidx)

#define toksiz (parser->parser_toksiz)

#define tokline (parser->parser_tokline)

#define lex_input (parser->parser_lex_input)

#define lex_lastline (parser->parser_lex_lastline)

#define lex_nextline (parser->parser_lex_nextline)

#define lex_pbeg (parser->parser_lex_pbeg)

#define lex_p (parser->parser_lex_p)

#define lex_pend (parser->parser_lex_pend)

#define heredoc_end (parser->parser_heredoc_end)

#define command_start (parser->parser_command_start)

#define deferred_nodes (parser->parser_deferred_nodes)

#define lex_gets_ptr (parser->parser_lex_gets_ptr)

#define lex_gets (parser->parser_lex_gets)

#define lvtbl (parser->parser_lvtbl)

#define ruby__end__seen (parser->parser_ruby__end__seen)

#define ruby_sourceline (parser->parser_ruby_sourceline)

#define ruby_sourcefile (parser->parser_ruby_sourcefile)

#define ruby_sourcefile_string (parser->parser_ruby_sourcefile_string)

#define current_enc (parser->enc)

#define yydebug (parser->parser_yydebug)

#ifdef RIPPER

#else

#define ruby_eval_tree (parser->parser_eval_tree)

#define ruby_eval_tree_begin (parser->parser_eval_tree_begin)

#define ruby_debug_lines (parser->debug_lines)

#define ruby_coverage (parser->coverage)

#endif

#if YYPURE

static int yylex(void*, void*);

#else

static int yylex(void*);

#endif

#ifndef RIPPER

#define yyparse ruby_yyparse

static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);

#define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))

static NODE *cond_gen(struct parser_params*,NODE*);

#define cond(node) cond_gen(parser, (node))

static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);

#define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))

static NODE *newline_node(NODE*);

static void fixpos(NODE*,NODE*);

static int value_expr_gen(struct parser_params*,NODE*);

static void void_expr_gen(struct parser_params*,NODE*);

static NODE *remove_begin(NODE*);

static NODE *remove_begin_all(NODE*);

#define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))

#define void_expr0(node) void_expr_gen(parser, (node))

#define void_expr(node) void_expr0((node) = remove_begin(node))

static void void_stmts_gen(struct parser_params*,NODE*);

#define void_stmts(node) void_stmts_gen(parser, (node))

static void reduce_nodes_gen(struct parser_params*,NODE**);

#define reduce_nodes(n) reduce_nodes_gen(parser,(n))

static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);

#define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))

static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);

#define block_append(h,t) block_append_gen(parser,(h),(t))

static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);

#define list_append(l,i) list_append_gen(parser,(l),(i))

static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);

#define list_concat(h,t) list_concat_gen(parser,(h),(t))

static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);

#define arg_append(h,t) arg_append_gen(parser,(h),(t))

static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);

#define arg_concat(h,t) arg_concat_gen(parser,(h),(t))

static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);

#define literal_concat(h,t) literal_concat_gen(parser,(h),(t))

static int literal_concat0(struct parser_params *, VALUE, VALUE);

static NODE *new_evstr_gen(struct parser_params*,NODE*);

#define new_evstr(n) new_evstr_gen(parser,(n))

static NODE *evstr2dstr_gen(struct parser_params*,NODE*);

#define evstr2dstr(n) evstr2dstr_gen(parser,(n))

static NODE *splat_array(NODE*);

static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);

#define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))

static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);

#define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))

static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);

#define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))

static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);

#define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))

static NODE *negate_lit(NODE*);

static NODE *ret_args_gen(struct parser_params*,NODE*);

#define ret_args(node) ret_args_gen(parser, (node))

static NODE *arg_blk_pass(NODE*,NODE*);

static NODE *new_yield_gen(struct parser_params*,NODE*);

#define new_yield(node) new_yield_gen(parser, (node))

static NODE *dsym_node_gen(struct parser_params*,NODE*);

#define dsym_node(node) dsym_node_gen(parser, (node))

static NODE *gettable_gen(struct parser_params*,ID);

#define gettable(id) gettable_gen(parser,(id))

static NODE *assignable_gen(struct parser_params*,ID,NODE*);

#define assignable(id,node) assignable_gen(parser, (id), (node))

static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);

#define aryset(node1,node2) aryset_gen(parser, (node1), (node2))

static NODE *attrset_gen(struct parser_params*,NODE*,ID);

#define attrset(node,id) attrset_gen(parser, (node), (id))

static void rb_backref_error_gen(struct parser_params*,NODE*);

#define rb_backref_error(n) rb_backref_error_gen(parser,(n))

static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);

#define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))

static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);

static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);

#define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))

static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);

#define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))

#define new_defined(expr) NEW_DEFINED(remove_begin_all(expr))

static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);

#define match_op(node1,node2) match_op_gen(parser, (node1), (node2))

static ID *local_tbl_gen(struct parser_params*);

#define local_tbl() local_tbl_gen(parser)

static void fixup_nodes(NODE **);

static VALUE reg_compile_gen(struct parser_params*, VALUE, int);

#define reg_compile(str,options) reg_compile_gen(parser, (str), (options))

static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);

#define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))

static int reg_fragment_check_gen(struct parser_params*, VALUE, int);

#define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))

static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);

#define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))

#define get_id(id) (id)

#define get_value(val) (val)

#else

#define value_expr(node) ((void)(node))

#define remove_begin(node) (node)

#define rb_dvar_defined(id) 0

#define rb_local_defined(id) 0

static ID ripper_get_id(VALUE);

#define get_id(id) ripper_get_id(id)

static VALUE ripper_get_value(VALUE);

#define get_value(val) ripper_get_value(val)

static VALUE assignable_gen(struct parser_params*,VALUE);

#define assignable(lhs,node) assignable_gen(parser, (lhs))

static int id_is_var_gen(struct parser_params *parser, ID id);

#define id_is_var(id) id_is_var_gen(parser, (id))

#define node_assign(node1, node2) dispatch2(assign, (node1), (node2))

static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);

static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);

#define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))

#endif /* !RIPPER */

#define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))

static ID formal_argument_gen(struct parser_params*, ID);

#define formal_argument(id) formal_argument_gen(parser, (id))

static ID shadowing_lvar_gen(struct parser_params*,ID);

#define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))

static void new_bv_gen(struct parser_params*,ID);

#define new_bv(id) new_bv_gen(parser, (id))

static void local_push_gen(struct parser_params*,int);

#define local_push(top) local_push_gen(parser,(top))

static void local_pop_gen(struct parser_params*);

#define local_pop() local_pop_gen(parser)

static int local_var_gen(struct parser_params*, ID);

#define local_var(id) local_var_gen(parser, (id))

static int arg_var_gen(struct parser_params*, ID);

#define arg_var(id) arg_var_gen(parser, (id))

static int local_id_gen(struct parser_params*, ID);

#define local_id(id) local_id_gen(parser, (id))

static ID internal_id_gen(struct parser_params*);

#define internal_id() internal_id_gen(parser)

static const struct vtable *dyna_push_gen(struct parser_params *);

#define dyna_push() dyna_push_gen(parser)

static void dyna_pop_gen(struct parser_params*, const struct vtable *);

#define dyna_pop(node) dyna_pop_gen(parser, (node))

static int dyna_in_block_gen(struct parser_params*);

#define dyna_in_block() dyna_in_block_gen(parser)

#define dyna_var(id) local_var(id)

static int dvar_defined_gen(struct parser_params*,ID,int);

#define dvar_defined(id) dvar_defined_gen(parser, (id), 0)

#define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)

static int dvar_curr_gen(struct parser_params*,ID);

#define dvar_curr(id) dvar_curr_gen(parser, (id))

static int lvar_defined_gen(struct parser_params*, ID);

#define lvar_defined(id) lvar_defined_gen(parser, (id))

#define RE_OPTION_ONCE (1<<16)

#define RE_OPTION_ENCODING_SHIFT 8

#define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)

#define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)

#define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)

#define RE_OPTION_MASK 0xff

#define RE_OPTION_ARG_ENCODING_NONE 32

#define NODE_STRTERM NODE_ZARRAY /* nothing to gc */

#define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */

#define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))

#define nd_func u1.id

#if SIZEOF_SHORT == 2

#define nd_term(node) ((signed short)(node)->u2.id)

#else

#define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)

#endif

#define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)

#define nd_nest u3.cnt

/****** Ripper *******/

#ifdef RIPPER

#define RIPPER_VERSION "0.1.0"

#include "eventids1.c"

#include "eventids2.c"

static VALUE ripper_dispatch0(struct parser_params*,ID);

static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);

static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);

static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);

static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);

static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);

static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);

#define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))

#define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))

#define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))

#define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))

#define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))

#define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))

#define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e), (f), (g))

#define yyparse ripper_yyparse

#define ripper_intern(s) ID2SYM(rb_intern(s))

static VALUE ripper_id2sym(ID);

#ifdef __GNUC__

#define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \

ID2SYM(id) : ripper_id2sym(id))

#endif

#define arg_new() dispatch0(args_new)

#define arg_add(l,a) dispatch2(args_add, (l), (a))

#define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))

#define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))

#define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))

#define bare_assoc(v) dispatch1(bare_assoc_hash, (v))

#define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))

#define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))

#define mrhs_new() dispatch0(mrhs_new)

#define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))

#define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))

#define mlhs_new() dispatch0(mlhs_new)

#define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))

#define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))

#define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \

dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))

#define blockvar_new(p,v) dispatch2(block_var, (p), (v))

#define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))

#define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))

#define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))

#define method_arg(m,a) dispatch2(method_add_arg,(m),(a))

#define method_add_block(m,b) dispatch2(method_add_block, (m), (b))

#define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))

static inline VALUE

new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)

{

NODE *t = (NODE *)tail;

VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;

return params_new(f, o, r, p, k, kr, escape_Qundef(b));

}

#define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))

static inline VALUE

new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)

{

return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);

}

#define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))

#define new_defined(expr) dispatch1(defined, (expr))

#define FIXME 0

#endif /* RIPPER */

#ifndef RIPPER

# define Qnone 0

# define ifndef_ripper(x) (x)

#else

# define Qnone Qnil

# define ifndef_ripper(x)

#endif

#ifndef RIPPER

# define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))

# define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))

# define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))

# define rb_warn4S(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a))

# define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))

# define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))

#else

# define rb_warn0(fmt) ripper_warn0(parser, (fmt))

# define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))

# define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))

# define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a))

# define rb_warning0(fmt) ripper_warning0(parser, (fmt))

# define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))

static void ripper_warn0(struct parser_params*, const char*);

static void ripper_warnI(struct parser_params*, const char*, int);

static void ripper_warnS(struct parser_params*, const char*, const char*);

static void ripper_warning0(struct parser_params*, const char*);

static void ripper_warningS(struct parser_params*, const char*, const char*);

#endif

#ifdef RIPPER

static void ripper_compile_error(struct parser_params*, const char *fmt, ...);

# define rb_compile_error ripper_compile_error

# define compile_error ripper_compile_error

# define PARSER_ARG parser,

#else

# define rb_compile_error rb_compile_error_with_enc

# define compile_error parser->nerr++,rb_compile_error_with_enc

# define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,

#endif

/* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,

for instance). This is too low for Ruby to parse some files, such as

date/format.rb, therefore bump the value up to at least Bison's default. */

#ifdef OLD_YACC

#ifndef YYMAXDEPTH

#define YYMAXDEPTH 10000

#endif

#endif

#ifndef RIPPER

static void token_info_push(struct parser_params*, const char *token);

static void token_info_pop(struct parser_params*, const char *token);

#define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)

#define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)

#else

#define token_info_push(token) /* nothing */

#define token_info_pop(token) /* nothing */

#endif

%}

%pure-parser

%lex-param {struct parser_params *parser}

%parse-param {struct parser_params *parser}

%union {

VALUE val;

NODE *node;

ID id;

int num;

const struct vtable *vars;

}

/*%%%*/

%token

/*%

%token <val>

%*/

keyword_class

keyword_module

keyword_def

keyword_undef

keyword_begin

keyword_rescue

keyword_ensure

keyword_end

keyword_if

keyword_unless

keyword_then

keyword_elsif

keyword_else

keyword_case

keyword_when

keyword_while

keyword_until

keyword_for

keyword_break

keyword_next

keyword_redo

keyword_retry

keyword_in

keyword_do

keyword_do_cond

keyword_do_block

keyword_do_LAMBDA

keyword_return

keyword_yield

keyword_super

keyword_self

keyword_nil

keyword_true

keyword_false

keyword_and

keyword_or

keyword_not

modifier_if

modifier_unless

modifier_while

modifier_until

modifier_rescue

keyword_alias

keyword_defined

keyword_BEGIN

keyword_END

keyword__LINE__

keyword__FILE__

keyword__ENCODING__

%token <id> tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tLABEL

%token <node> tINTEGER tFLOAT tRATIONAL tIMAGINARY tSTRING_CONTENT tCHAR

%token <node> tNTH_REF tBACK_REF

%token <num> tREGEXP_END

%type <node> singleton strings string string1 xstring regexp

%type <node> string_contents xstring_contents regexp_contents string_content

%type <node> words symbols symbol_list qwords qsymbols word_list qword_list qsym_list word

%type <node> literal numeric simple_numeric dsym cpath

%type <node> top_compstmt top_stmts top_stmt

%type <node> bodystmt compstmt stmts stmt_or_begin stmt expr arg primary command command_call method_call

%type <node> expr_value arg_value primary_value fcall

%type <node> if_tail opt_else case_body cases opt_rescue exc_list exc_var opt_ensure

%type <node> args call_args opt_call_args

%type <node> paren_args opt_paren_args args_tail opt_args_tail block_args_tail opt_block_args_tail

%type <node> command_args aref_args opt_block_arg block_arg var_ref var_lhs

%type <node> command_asgn mrhs mrhs_arg superclass block_call block_command

%type <node> f_block_optarg f_block_opt

%type <node> f_arglist f_args f_arg f_arg_item f_optarg f_marg f_marg_list f_margs

%type <node> assoc_list assocs assoc undef_list backref string_dvar for_var

%type <node> block_param opt_block_param block_param_def f_opt

%type <node> f_kwarg f_kw f_block_kwarg f_block_kw

%type <node> bv_decls opt_bv_decl bvar

%type <node> lambda f_larglist lambda_body

%type <node> brace_block cmd_brace_block do_block lhs none fitem

%type <node> mlhs mlhs_head mlhs_basic mlhs_item mlhs_node mlhs_post mlhs_inner

%type <id> fsym keyword_variable user_variable sym symbol operation operation2 operation3

%type <id> cname fname op f_rest_arg f_block_arg opt_f_block_arg f_norm_arg f_bad_arg

%type <id> f_kwrest f_label

/*%%%*/

/*%

%type <val> program reswords then do dot_or_colon

%*/

%token END_OF_INPUT 0 "end-of-input"

%token tUPLUS RUBY_TOKEN(UPLUS) "unary+"

%token tUMINUS RUBY_TOKEN(UMINUS) "unary-"

%token tPOW RUBY_TOKEN(POW) "**"

%token tCMP RUBY_TOKEN(CMP) "<=>"

%token tEQ RUBY_TOKEN(EQ) "=="

%token tEQQ RUBY_TOKEN(EQQ) "==="

%token tNEQ RUBY_TOKEN(NEQ) "!="

%token tGEQ RUBY_TOKEN(GEQ) ">="

%token tLEQ RUBY_TOKEN(LEQ) "<="

%token tANDOP "&&"

%token tOROP "||"

%token tMATCH RUBY_TOKEN(MATCH) "=~"

%token tNMATCH RUBY_TOKEN(NMATCH) "!~"

%token tDOT2 RUBY_TOKEN(DOT2) ".."

%token tDOT3 RUBY_TOKEN(DOT3) "..."

%token tAREF RUBY_TOKEN(AREF) "[]"

%token tASET RUBY_TOKEN(ASET) "[]="

%token tLSHFT RUBY_TOKEN(LSHFT) "<<"

%token tRSHFT RUBY_TOKEN(RSHFT) ">>"

%token tCOLON2 "::"

%token tCOLON3 ":: at EXPR_BEG"

%token <id> tOP_ASGN /* +=, -= etc. */

%token tASSOC "=>"

%token tLPAREN "("

%token tLPAREN_ARG "( arg"

%token tRPAREN ")"

%token tLBRACK "["

%token tLBRACE "{"

%token tLBRACE_ARG "{ arg"

%token tSTAR "*"

%token tDSTAR "**arg"

%token tAMPER "&"

%token tLAMBDA "->"

%token tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tWORDS_BEG tQWORDS_BEG tSYMBOLS_BEG tQSYMBOLS_BEG

%token tSTRING_DBEG tSTRING_DEND tSTRING_DVAR tSTRING_END tLAMBEG

/*

* precedence table

*/

%nonassoc tLOWEST

%nonassoc tLBRACE_ARG

%nonassoc modifier_if modifier_unless modifier_while modifier_until

%left keyword_or keyword_and

%right keyword_not

%nonassoc keyword_defined

%right '=' tOP_ASGN

%left modifier_rescue

%right '?' ':'

%nonassoc tDOT2 tDOT3

%left tOROP

%left tANDOP

%nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH

%left '>' tGEQ '<' tLEQ

%left '|' '^'

%left '&'

%left tLSHFT tRSHFT

%left '+' '-'

%left '*' '/' '%'

%right tUMINUS_NUM tUMINUS

%right tPOW

%right '!' '~' tUPLUS

%token tLAST_TOKEN

%%

program : {

lex_state = EXPR_BEG;

/*%%%*/

local_push(compile_for_eval || rb_parse_in_main());

/*%

local_push(0);

%*/

}

top_compstmt

{

/*%%%*/

if ($2 && !compile_for_eval) {

/* last expression should not be void */

if (nd_type($2) != NODE_BLOCK) void_expr($2);

else {

NODE *node = $2;

while (node->nd_next) {

node = node->nd_next;

}

void_expr(node->nd_head);

}

}

ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, $2));

/*%

$$ = $2;

parser->result = dispatch1(program, $$);

%*/

local_pop();

}

;

top_compstmt : top_stmts opt_terms

{

/*%%%*/

void_stmts($1);

fixup_nodes(&deferred_nodes);

/*%

%*/

$$ = $1;

}

;

top_stmts : none

{

/*%%%*/

$$ = NEW_BEGIN(0);

/*%

$$ = dispatch2(stmts_add, dispatch0(stmts_new),

dispatch0(void_stmt));

%*/

}

| top_stmt

{

/*%%%*/

$$ = newline_node($1);

/*%

$$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);

%*/

}

| top_stmts terms top_stmt

{

/*%%%*/

$$ = block_append($1, newline_node($3));

/*%

$$ = dispatch2(stmts_add, $1, $3);

%*/

}

| error top_stmt

{

$$ = remove_begin($2);

}

;

top_stmt : stmt

| keyword_BEGIN

{

/*%%%*/

/* local_push(0); */

/*%

%*/

}

'{' top_compstmt '}'

{

/*%%%*/

ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,

$4);

/* NEW_PREEXE($4)); */

/* local_pop(); */

$$ = NEW_BEGIN(0);

/*%

$$ = dispatch1(BEGIN, $4);

%*/

}

;

bodystmt : compstmt

opt_rescue

opt_else

opt_ensure

{

/*%%%*/

$$ = $1;

if ($2) {

$$ = NEW_RESCUE($1, $2, $3);

}

else if ($3) {

rb_warn0("else without rescue is useless");

$$ = block_append($$, $3);

}

if ($4) {

if ($$) {

$$ = NEW_ENSURE($$, $4);

}

else {

$$ = block_append($4, NEW_NIL());

}

}

fixpos($$, $1);

/*%

$$ = dispatch4(bodystmt,

escape_Qundef($1),

escape_Qundef($2),

escape_Qundef($3),

escape_Qundef($4));

%*/

}

;

compstmt : stmts opt_terms

{

/*%%%*/

void_stmts($1);

fixup_nodes(&deferred_nodes);

/*%

%*/

$$ = $1;

}

;