rhodes 3.1.1 → 3.2.0.beta.1

data/platform/shared/ruby/parse.y

@@ -2,7 +2,7 @@
 
   parse.y -
 
-  $Author: mame $
+  $Author: yugui $
   created at: Fri May 28 18:02:42 JST 1993
 
   Copyright (C) 1993-2007 Yukihiro Matsumoto
@@ -26,6 +26,8 @@
 #include <errno.h>
 #include <ctype.h>
 
+#define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
+
 #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)
@@ -59,20 +61,18 @@ enum lex_state_e {
     EXPR_BEG,			/* ignore newline, +/- is a sign. */
     EXPR_END,			/* newline significant, +/- is an operator. */
     EXPR_ENDARG,		/* ditto, and unbound braces. */
+    EXPR_ENDFN, 		/* ditto, and unbound braces. */
     EXPR_ARG,			/* newline significant, +/- is an operator. */
     EXPR_CMDARG,		/* newline significant, +/- is an operator. */
     EXPR_MID,			/* newline significant, +/- is an operator. */
     EXPR_FNAME,			/* ignore newline, no reserved words. */
     EXPR_DOT,			/* right after `.' or `::', no reserved words. */
     EXPR_CLASS,			/* immediate after `class', no here document. */
-    EXPR_VALUE			/* alike EXPR_BEG but label is disallowed. */
+    EXPR_VALUE,			/* alike EXPR_BEG but label is disallowed. */
+    EXPR_MAX_STATE
 };
 
-# ifdef HAVE_LONG_LONG
-typedef unsigned LONG_LONG stack_type;
-# else
-typedef unsigned long stack_type;
-# endif
+typedef VALUE stack_type;
 
 # define BITSTACK_PUSH(stack, n)	(stack = (stack<<1)|((n)&1))
 # define BITSTACK_POP(stack)	(stack = stack >> 1)
@@ -107,7 +107,6 @@ struct local_vars {
 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
 
-#ifndef RIPPER
 static int
 vtable_size(const struct vtable *tbl)
 {
@@ -176,6 +175,7 @@ vtable_included(const struct vtable * tbl, ID id)
 }
 
 
+#ifndef RIPPER
 typedef struct token_info {
     const char *token;
     int linenum;
@@ -225,7 +225,7 @@ struct parser_params {
     int parser_heredoc_end;
     int parser_command_start;
     NODE *parser_deferred_nodes;
-    int parser_lex_gets_ptr;
+    long parser_lex_gets_ptr;
     VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
     struct local_vars *parser_lvtbl;
     int parser_ruby__end__seen;
@@ -363,6 +363,7 @@ 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*);
@@ -376,8 +377,6 @@ static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
 
 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,ID);
 #define new_args(f,o,r,p,b) new_args_gen(parser, f,o,r,p,b)
-static void shadowing_lvar_gen(struct parser_params*,ID);
-#define shadowing_lvar(name) shadowing_lvar_gen(parser, name)
 
 static NODE *negate_lit(NODE*);
 static NODE *ret_args_gen(struct parser_params*,NODE*);
@@ -390,8 +389,7 @@ 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 void new_bv_gen(struct parser_params*,ID);
-#define new_bv(id) new_bv_gen(parser, id)
+
 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);
@@ -405,6 +403,46 @@ static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
 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 **);
+
+extern int rb_dvar_defined(ID);
+extern int rb_local_defined(ID);
+extern int rb_parse_in_eval(void);
+extern int rb_parse_in_main(void);
+
+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 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)
+#endif /* !RIPPER */
+
+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*);
@@ -415,15 +453,13 @@ 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  *local_tbl_gen(struct parser_params*);
-#define local_tbl() local_tbl_gen(parser)
 static ID   internal_id_gen(struct parser_params*);
 #define internal_id() internal_id_gen(parser)
 
-static void dyna_push_gen(struct parser_params*);
+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*);
-#define dyna_pop() dyna_pop_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)
@@ -432,25 +468,6 @@ static int dvar_defined_gen(struct parser_params*,ID);
 static int dvar_curr_gen(struct parser_params*,ID);
 #define dvar_curr(id) dvar_curr_gen(parser, id)
 
-static void fixup_nodes(NODE **);
-
-extern int rb_dvar_defined(ID);
-extern int rb_local_defined(ID);
-extern int rb_parse_in_eval(void);
-extern int rb_parse_in_main(void);
-
-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 void 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)
-int rb_enc_symname2_p(const char *, int, rb_encoding *);
-#else
-#define remove_begin(node) (node)
-#endif /* !RIPPER */
 static int lvar_defined_gen(struct parser_params*, ID);
 #define lvar_defined(id) lvar_defined_gen(parser, id)
 
@@ -499,7 +516,7 @@ static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,V
 
 #define yyparse ripper_yyparse
 
-static VALUE ripper_intern(const char*);
+#define ripper_intern(s) ID2SYM(rb_intern(s))
 static VALUE ripper_id2sym(ID);
 #ifdef __GNUC__
 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
@@ -508,7 +525,6 @@ static VALUE ripper_id2sym(ID);
 
 #define arg_new() dispatch0(args_new)
 #define arg_add(l,a) dispatch2(args_add, l, a)
-#define arg_prepend(l,a) dispatch2(args_prepend, 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))
@@ -590,6 +606,11 @@ static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
 #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
 %}
 
@@ -601,6 +622,7 @@ static void token_info_pop(struct parser_params*, const char *token);
     NODE *node;
     ID id;
     int num;
+    const struct vtable *vars;
 }
 
 /*%%%*/
@@ -664,7 +686,7 @@ static void token_info_pop(struct parser_params*, const char *token);
 %token <num>  tREGEXP_END
 
 %type <node> singleton strings string string1 xstring regexp
-%type <node> string_contents xstring_contents string_content
+%type <node> string_contents xstring_contents regexp_contents string_content
 %type <node> words qwords word_list qword_list word
 %type <node> literal numeric dsym cpath
 %type <node> top_compstmt top_stmts top_stmt
@@ -751,7 +773,6 @@ static void token_info_pop(struct parser_params*, const char *token);
 %nonassoc idRespond_to
 %nonassoc idIFUNC
 %nonassoc idCFUNC
-%nonassoc idThrowState
 %nonassoc id_core_set_method_alias
 %nonassoc id_core_set_variable_alias
 %nonassoc id_core_undef_method
@@ -765,8 +786,9 @@ static void token_info_pop(struct parser_params*, const char *token);
 program		:  {
 			lex_state = EXPR_BEG;
 		    /*%%%*/
-			local_push(compile_for_eval);
+			local_push(compile_for_eval || rb_parse_in_main());
 		    /*%
+			local_push(0);
 		    %*/
 		    }
 		  top_compstmt
@@ -784,11 +806,11 @@ program		:  {
 			    }
 			}
 			ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, $2));
-			local_pop();
 		    /*%
 			$$ = $2;
 			parser->result = dispatch1(program, $$);
 		    %*/
+			local_pop();
 		    }
 		;
 
@@ -883,7 +905,7 @@ bodystmt	: compstmt
 			}
 			fixpos($$, $1);
 		    /*%
-			$$ = dispatch4(body_stmt,
+			$$ = dispatch4(bodystmt,
 				       escape_Qundef($1),
 				       escape_Qundef($2),
 				       escape_Qundef($3),
@@ -953,10 +975,10 @@ stmt		: keyword_alias fitem {lex_state = EXPR_FNAME;} fitem
 		| keyword_alias tGVAR tBACK_REF
 		    {
 		    /*%%%*/
-			char buf[3];
-
-			sprintf(buf, "$%c", (char)$3->nd_nth);
-			$$ = NEW_VALIAS($2, rb_intern(buf));
+			char buf[2];
+			buf[0] = '$';
+			buf[1] = (char)$3->nd_nth;
+			$$ = NEW_VALIAS($2, rb_intern2(buf, 2));
 		    /*%
 			$$ = dispatch2(var_alias, $2, $3);
 		    %*/
@@ -1099,7 +1121,7 @@ stmt		: keyword_alias fitem {lex_state = EXPR_FNAME;} fitem
 
 			value_expr($6);
 			if (!$3) $3 = NEW_ZARRAY();
-			args = arg_concat($6, $3);
+			args = arg_concat($3, $6);
 			if ($5 == tOROP) {
 			    $5 = 0;
 			}
@@ -1147,6 +1169,17 @@ stmt		: keyword_alias fitem {lex_state = EXPR_FNAME;} fitem
 			$$ = dispatch3(opassign, $$, $4, $5);
 		    %*/
 		    }
+		| primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
+		    {
+		    /*%%%*/
+			yyerror("constant re-assignment");
+			$$ = 0;
+		    /*%
+			$$ = dispatch2(const_path_field, $1, $3);
+			$$ = dispatch3(opassign, $$, $4, $5);
+			$$ = dispatch1(assign_error, $$);
+		    %*/
+		    }
 		| primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
 		    {
 		    /*%%%*/
@@ -1254,30 +1287,6 @@ expr_value	: expr
 
 command_call	: command
 		| block_command
-		| keyword_return call_args
-		    {
-		    /*%%%*/
-			$$ = NEW_RETURN(ret_args($2));
-		    /*%
-			$$ = dispatch1(return, $2);
-		    %*/
-		    }
-		| keyword_break call_args
-		    {
-		    /*%%%*/
-			$$ = NEW_BREAK(ret_args($2));
-		    /*%
-			$$ = dispatch1(break, $2);
-		    %*/
-		    }
-		| keyword_next call_args
-		    {
-		    /*%%%*/
-			$$ = NEW_NEXT(ret_args($2));
-		    /*%
-			$$ = dispatch1(next, $2);
-		    %*/
-		    }
 		;
 
 block_command	: block_call
@@ -1303,8 +1312,8 @@ block_command	: block_call
 
 cmd_brace_block	: tLBRACE_ARG
 		    {
+			$<vars>1 = dyna_push();
 		    /*%%%*/
-			dyna_push();
 			$<num>$ = ruby_sourceline;
 		    /*%
 		    %*/
@@ -1316,10 +1325,10 @@ cmd_brace_block	: tLBRACE_ARG
 		    /*%%%*/
 			$$ = NEW_ITER($3,$4);
 			nd_set_line($$, $<num>2);
-			dyna_pop();
 		    /*%
 			$$ = dispatch2(brace_block, escape_Qundef($3), $4);
 		    %*/
+			dyna_pop($<vars>1);
 		    }
 		;
 
@@ -1404,6 +1413,30 @@ command		: operation command_args       %prec tLOWEST
 			$$ = dispatch1(yield, $2);
 		    %*/
 		    }
+		| keyword_return call_args
+		    {
+		    /*%%%*/
+			$$ = NEW_RETURN(ret_args($2));
+		    /*%
+			$$ = dispatch1(return, $2);
+		    %*/
+		    }
+		| keyword_break call_args
+		    {
+		    /*%%%*/
+			$$ = NEW_BREAK(ret_args($2));
+		    /*%
+			$$ = dispatch1(break, $2);
+		    %*/
+		    }
+		| keyword_next call_args
+		    {
+		    /*%%%*/
+			$$ = NEW_NEXT(ret_args($2));
+		    /*%
+			$$ = dispatch1(next, $2);
+		    %*/
+		    }
 		;
 
 mlhs		: mlhs_basic
@@ -1457,7 +1490,8 @@ mlhs_basic	: mlhs_head
 		    /*%%%*/
 			$$ = NEW_MASGN($1, NEW_POSTARG($3,$5));
 		    /*%
-			$$ = mlhs_add_star($1, $3);
+			$1 = mlhs_add_star($1, $3);
+			$$ = mlhs_add($1, $5);
 		    %*/
 		    }
 		| mlhs_head tSTAR
@@ -1473,7 +1507,8 @@ mlhs_basic	: mlhs_head
 		    /*%%%*/
 			$$ = NEW_MASGN($1, NEW_POSTARG(-1, $4));
 		    /*%
-			$$ = mlhs_add_star($1, Qnil);
+			$1 = mlhs_add_star($1, Qnil);
+			$$ = mlhs_add($1, $4);
 		    %*/
 		    }
 		| tSTAR mlhs_node
@@ -1489,7 +1524,8 @@ mlhs_basic	: mlhs_head
 		    /*%%%*/
 			$$ = NEW_MASGN(0, NEW_POSTARG($2,$4));
 		    /*%
-			$$ = mlhs_add_star(mlhs_new(), $2);
+			$2 = mlhs_add_star(mlhs_new(), $2);
+			$$ = mlhs_add($2, $4);
 		    %*/
 		    }
 		| tSTAR
@@ -1506,6 +1542,7 @@ mlhs_basic	: mlhs_head
 			$$ = NEW_MASGN(0, NEW_POSTARG(-1, $3));
 		    /*%
 			$$ = mlhs_add_star(mlhs_new(), Qnil);
+			$$ = mlhs_add($$, $3);
 		    %*/
 		    }
 		;
@@ -1559,11 +1596,7 @@ mlhs_post	: mlhs_item
 
 mlhs_node	: variable
 		    {
-		    /*%%%*/
 			$$ = assignable($1, 0);
-		    /*%
-			$$ = $1;
-		    %*/
 		    }
 		| primary_value '[' opt_call_args rbracket
 		    {
@@ -1633,10 +1666,11 @@ mlhs_node	: variable
 
 lhs		: variable
 		    {
+			$$ = assignable($1, 0);
 		    /*%%%*/
-			if (!($$ = assignable($1, 0))) $$ = NEW_BEGIN(0);
+			if (!$$) $$ = NEW_BEGIN(0);
 		    /*%
-			$$ = dispatch1(var_field, $1);
+			$$ = dispatch1(var_field, $$);
 		    %*/
 		    }
 		| primary_value '[' opt_call_args rbracket
@@ -1750,21 +1784,15 @@ fname		: tIDENTIFIER
 		| tFID
 		| op
 		    {
-		    /*%%%*/
-			lex_state = EXPR_END;
+			lex_state = EXPR_ENDFN;
 			$$ = $1;
-		    /*%
-			lex_state = EXPR_END;
-			$$ = $1;
-		    %*/
 		    }
 		| reswords
 		    {
+			lex_state = EXPR_ENDFN;
 		    /*%%%*/
-			lex_state = EXPR_END;
 			$$ = $<id>1;
 		    /*%
-			lex_state = EXPR_END;
 			$$ = $1;
 		    %*/
 		    }
@@ -1934,7 +1962,12 @@ arg		: lhs '=' arg
 
 			value_expr($6);
 			if (!$3) $3 = NEW_ZARRAY();
-			args = arg_concat($6, $3);
+			if (nd_type($3) == NODE_BLOCK_PASS) {
+			    args = NEW_ARGSCAT($3, $6);
+			}
+		        else {
+			    args = arg_concat($3, $6);
+		        }
 			if ($5 == tOROP) {
 			    $5 = 0;
 			}
@@ -2379,6 +2412,7 @@ opt_call_args	: none
 call_args	: command
 		    {
 		    /*%%%*/
+			value_expr($1);
 			$$ = NEW_LIST($1);
 		    /*%
 			$$ = arg_add(arg_new(), $1);
@@ -2421,13 +2455,13 @@ call_args	: command
 		;
 
 command_args	:  {
-			$<num>$ = cmdarg_stack;
+			$<val>$ = cmdarg_stack;
 			CMDARG_PUSH(1);
 		    }
 		  call_args
 		    {
 			/* CMDARG_POP() */
-			cmdarg_stack = $<num>1;
+			cmdarg_stack = $<val>1;
 			$$ = $2;
 		    }
 		;
@@ -2856,8 +2890,8 @@ primary		: literal
 		    {
 			if (in_def || in_single)
 			    yyerror("class definition in method body");
-		    /*%%%*/
 			local_push(0);
+		    /*%%%*/
 			$<num>$ = ruby_sourceline;
 		    /*%
 		    %*/
@@ -2868,10 +2902,10 @@ primary		: literal
 		    /*%%%*/
 			$$ = NEW_CLASS($2, $5, $3);
 			nd_set_line($$, $<num>4);
-			local_pop();
 		    /*%
 			$$ = dispatch3(class, $2, $3, $5);
 		    %*/
+			local_pop();
 		    }
 		| k_class tLSHFT expr
 		    {
@@ -2882,10 +2916,7 @@ primary		: literal
 		    {
 			$<num>$ = in_single;
 			in_single = 0;
-		    /*%%%*/
 			local_push(0);
-		    /*%
-		    %*/
 		    }
 		  bodystmt
 		  k_end
@@ -2893,10 +2924,10 @@ primary		: literal
 		    /*%%%*/
 			$$ = NEW_SCLASS($3, $7);
 			fixpos($$, $3);
-			local_pop();
 		    /*%
 			$$ = dispatch2(sclass, $3, $7);
 		    %*/
+			local_pop();
 			in_def = $<num>4;
 			in_single = $<num>6;
 		    }
@@ -2904,8 +2935,8 @@ primary		: literal
 		    {
 			if (in_def || in_single)
 			    yyerror("module definition in method body");
-		    /*%%%*/
 			local_push(0);
+		    /*%%%*/
 			$<num>$ = ruby_sourceline;
 		    /*%
 		    %*/
@@ -2916,20 +2947,17 @@ primary		: literal
 		    /*%%%*/
 			$$ = NEW_MODULE($2, $4);
 			nd_set_line($$, $<num>3);
-			local_pop();
 		    /*%
 			$$ = dispatch2(module, $2, $4);
 		    %*/
+			local_pop();
 		    }
 		| k_def fname
 		    {
 			$<id>$ = cur_mid;
 			cur_mid = $2;
 			in_def++;
-		    /*%%%*/
 			local_push(0);
-		    /*%
-		    %*/
 		    }
 		  f_arglist
 		  bodystmt
@@ -2939,23 +2967,19 @@ primary		: literal
 			NODE *body = remove_begin($5);
 			reduce_nodes(&body);
 			$$ = NEW_DEFN($2, $4, body, NOEX_PRIVATE);
-			fixpos($$, $4);
-			fixpos($$->nd_defn, $4);
-			local_pop();
+			nd_set_line($$, $<num>1);
 		    /*%
 			$$ = dispatch3(def, $2, $4, $5);
 		    %*/
+			local_pop();
 			in_def--;
 			cur_mid = $<id>3;
 		    }
 		| k_def singleton dot_or_colon {lex_state = EXPR_FNAME;} fname
 		    {
 			in_single++;
-			lex_state = EXPR_END; /* force for args */
-		    /*%%%*/
+			lex_state = EXPR_ENDFN; /* force for args */
 			local_push(0);
-		    /*%
-		    %*/
 		    }
 		  f_arglist
 		  bodystmt
@@ -2965,12 +2989,11 @@ primary		: literal
 			NODE *body = remove_begin($8);
 			reduce_nodes(&body);
 			$$ = NEW_DEFS($2, $5, $7, body);
-			fixpos($$, $2);
-			fixpos($$->nd_defn, $2);
-			local_pop();
+			nd_set_line($$, $<num>1);
 		    /*%
 			$$ = dispatch5(defs, $2, $3, $5, $7, $8);
 		    %*/
+			local_pop();
 			in_single--;
 		    }
 		| keyword_break
@@ -3021,80 +3044,73 @@ primary_value	: primary
 
 k_begin		: keyword_begin
 		    {
-#ifndef RIPPER
-			if (RTEST(ruby_verbose)) token_info_push(parser, "begin");
-#endif
+			token_info_push("begin");
 		    }
+		;
 
 k_if		: keyword_if
 		    {
-#ifndef RIPPER
-			if (RTEST(ruby_verbose)) token_info_push(parser, "if");
-#endif
+			token_info_push("if");
 		    }
+		;
 
 k_unless	: keyword_unless
 		    {
-#ifndef RIPPER
-			if (RTEST(ruby_verbose)) token_info_push(parser, "unless");
-#endif
+			token_info_push("unless");
 		    }
+		;
 
 k_while		: keyword_while
 		    {
-#ifndef RIPPER
-			if (RTEST(ruby_verbose)) token_info_push(parser, "while");
-#endif
+			token_info_push("while");
 		    }
+		;
 
 k_until		: keyword_until
 		    {
-#ifndef RIPPER
-			if (RTEST(ruby_verbose)) token_info_push(parser, "until");
-#endif
+			token_info_push("until");
 		    }
+		;
 
 k_case		: keyword_case
 		    {
-#ifndef RIPPER
-			if (RTEST(ruby_verbose)) token_info_push(parser, "case");
-#endif
+			token_info_push("case");
 		    }
+		;
 
 k_for		: keyword_for
 		    {
-#ifndef RIPPER
-			if (RTEST(ruby_verbose)) token_info_push(parser, "for");
-#endif
+			token_info_push("for");
 		    }
+		;
 
 k_class		: keyword_class
 		    {
-#ifndef RIPPER
-			if (RTEST(ruby_verbose)) token_info_push(parser, "class");
-#endif
+			token_info_push("class");
 		    }
+		;
 
 k_module	: keyword_module
 		    {
-#ifndef RIPPER
-			if (RTEST(ruby_verbose)) token_info_push(parser, "module");
-#endif
+			token_info_push("module");
 		    }
+		;
 
 k_def		: keyword_def
 		    {
-#ifndef RIPPER
-			if (RTEST(ruby_verbose)) token_info_push(parser, "def");
-#endif
+			token_info_push("def");
+		    /*%%%*/
+			$<num>$ = ruby_sourceline;
+		    /*%
+		    %*/
 		    }
+		;
 
 k_end		: keyword_end
 		    {
-#ifndef RIPPER
-			if (RTEST(ruby_verbose)) token_info_pop(parser, "end");  /* POP */
-#endif
+			token_info_pop("end");
 		    }
+		;
 
 then		: term
 		    /*%c%*/
@@ -3148,10 +3164,10 @@ for_var		: lhs
 
 f_marg		: f_norm_arg
 		    {
-		    /*%%%*/
 			$$ = assignable($1, 0);
+		    /*%%%*/
 		    /*%
-			$$ = dispatch1(mlhs_paren, $1);
+			$$ = dispatch1(mlhs_paren, $$);
 		    %*/
 		    }
 		| tLPAREN f_margs rparen
@@ -3192,18 +3208,20 @@ f_margs		: f_marg_list
 		    }
 		| f_marg_list ',' tSTAR f_norm_arg
 		    {
+			$$ = assignable($4, 0);
 		    /*%%%*/
-			$$ = NEW_MASGN($1, assignable($4, 0));
+			$$ = NEW_MASGN($1, $$);
 		    /*%
-			$$ = mlhs_add_star($1, $4);
+			$$ = mlhs_add_star($1, $$);
 		    %*/
 		    }
 		| f_marg_list ',' tSTAR f_norm_arg ',' f_marg_list
 		    {
+			$$ = assignable($4, 0);
 		    /*%%%*/
-			$$ = NEW_MASGN($1, NEW_POSTARG(assignable($4, 0), $6));
+			$$ = NEW_MASGN($1, NEW_POSTARG($$, $6));
 		    /*%
-			$$ = mlhs_add_star($1, $4);
+			$$ = mlhs_add_star($1, $$);
 		    %*/
 		    }
 		| f_marg_list ',' tSTAR
@@ -3224,21 +3242,23 @@ f_margs		: f_marg_list
 		    }
 		| tSTAR f_norm_arg
 		    {
+			$$ = assignable($2, 0);
 		    /*%%%*/
-			$$ = NEW_MASGN(0, assignable($2, 0));
+			$$ = NEW_MASGN(0, $$);
 		    /*%
-			$$ = mlhs_add_star(mlhs_new(), $2);
+			$$ = mlhs_add_star(mlhs_new(), $$);
 		    %*/
 		    }
 		| tSTAR f_norm_arg ',' f_marg_list
 		    {
+			$$ = assignable($2, 0);
 		    /*%%%*/
-			$$ = NEW_MASGN(0, NEW_POSTARG(assignable($2, 0), $4));
+			$$ = NEW_MASGN(0, NEW_POSTARG($$, $4));
 		    /*%
 		      #if 0
 		      TODO: Check me
 		      #endif
-			$$ = mlhs_add_star($2, $4);
+			$$ = mlhs_add_star($$, $4);
 		    %*/
 		    }
 		| tSTAR
@@ -3385,7 +3405,7 @@ block_param	: f_arg ',' f_block_optarg ',' f_rest_arg opt_f_block_arg
 opt_block_param	: none
 		| block_param_def
 		    {
-			command_start = Qtrue;
+			command_start = TRUE;
 		    }
 		;
 
@@ -3433,7 +3453,7 @@ bv_decls	: bvar
 		    /*%c%*/
 		    /*%c
 		    {
-			$$ = rb_ary_new2($1);
+			$$ = rb_ary_new3(1, $1);
 		    }
 		    %*/
 		| bv_decls ',' bvar
@@ -3447,10 +3467,10 @@ bv_decls	: bvar
 
 bvar		: tIDENTIFIER
 		    {
+			new_bv(get_id($1));
 		    /*%%%*/
-			new_bv($1);
 		    /*%
-			$$ = $1;
+			$$ = get_value($1);
 		    %*/
 		    }
 		| f_bad_arg
@@ -3460,24 +3480,23 @@ bvar		: tIDENTIFIER
 		;
 
 lambda		:   {
-		    /*%%%*/
-			dyna_push();
-		    /*%
-		    %*/
+			$<vars>$ = dyna_push();
+		    }
+		    {
 			$<num>$ = lpar_beg;
 			lpar_beg = ++paren_nest;
 		    }
 		  f_larglist
 		  lambda_body
 		    {
-			lpar_beg = $<num>1;
+			lpar_beg = $<num>2;
 		    /*%%%*/
-			$$ = $2;
-			$$->nd_body = NEW_SCOPE($2->nd_head, $3);
-			dyna_pop();
+			$$ = $3;
+			$$->nd_body = NEW_SCOPE($3->nd_head, $4);
 		    /*%
-			$$ = dispatch2(lambda, $2, $3);
+			$$ = dispatch2(lambda, $3, $4);
 		    %*/
+			dyna_pop($<vars>1);
 		    }
 		;
 
@@ -3511,8 +3530,8 @@ lambda_body	: tLAMBEG compstmt '}'
 
 do_block	: keyword_do_block
 		    {
+			$<vars>1 = dyna_push();
 		    /*%%%*/
-			dyna_push();
 			$<num>$ = ruby_sourceline;
 		    /*% %*/
 		    }
@@ -3523,10 +3542,10 @@ do_block	: keyword_do_block
 		    /*%%%*/
 			$$ = NEW_ITER($3,$4);
 			nd_set_line($$, $<num>2);
-			dyna_pop();
 		    /*%
 			$$ = dispatch2(do_block, escape_Qundef($3), $4);
 		    %*/
+			dyna_pop($<vars>1);
 		    }
 		;
 
@@ -3538,7 +3557,7 @@ block_call	: command do_block
 			}
 			else {
 			    block_dup_check($1->nd_args, $2);
-			}    
+			}
 			$2->nd_iter = $1;
 			$$ = $2;
 			fixpos($$, $1);
@@ -3609,8 +3628,8 @@ method_call	: operation paren_args
 			$$ = NEW_CALL($1, rb_intern("call"), $3);
 			fixpos($$, $1);
 		    /*%
-			$$ = dispatch3(call, dispatch1(paren, $1),
-				       ripper_id2sym('.'), rb_intern("call"));
+			$$ = dispatch3(call, $1, ripper_id2sym('.'),
+				       ripper_intern("call"));
 			$$ = method_optarg($$, $3);
 		    %*/
 		    }
@@ -3620,8 +3639,8 @@ method_call	: operation paren_args
 			$$ = NEW_CALL($1, rb_intern("call"), $3);
 			fixpos($$, $1);
 		    /*%
-			$$ = dispatch3(call, dispatch1(paren, $1),
-				       ripper_id2sym('.'), rb_intern("call"));
+			$$ = dispatch3(call, $1, ripper_intern("::"),
+				       ripper_intern("call"));
 			$$ = method_optarg($$, $3);
 		    %*/
 		    }
@@ -3657,8 +3676,8 @@ method_call	: operation paren_args
 
 brace_block	: '{'
 		    {
+			$<vars>1 = dyna_push();
 		    /*%%%*/
-			dyna_push();
 			$<num>$ = ruby_sourceline;
 		    /*%
                     %*/
@@ -3669,17 +3688,15 @@ brace_block	: '{'
 		    /*%%%*/
 			$$ = NEW_ITER($3,$4);
 			nd_set_line($$, $<num>2);
-			nd_set_line($$->nd_body, $<num>2);
-			nd_set_line($$->nd_body->nd_body, $<num>2);
-			dyna_pop();
 		    /*%
 			$$ = dispatch2(brace_block, escape_Qundef($3), $4);
 		    %*/
+			dyna_pop($<vars>1);
 		    }
 		| keyword_do
 		    {
+			$<vars>1 = dyna_push();
 		    /*%%%*/
-			dyna_push();
 			$<num>$ = ruby_sourceline;
 		    /*%
                     %*/
@@ -3690,10 +3707,10 @@ brace_block	: '{'
 		    /*%%%*/
 			$$ = NEW_ITER($3,$4);
 			nd_set_line($$, $<num>2);
-			dyna_pop();
 		    /*%
 			$$ = dispatch2(do_block, escape_Qundef($3), $4);
 		    %*/
+			dyna_pop($<vars>1);
 		    }
 		;
 
@@ -3839,7 +3856,7 @@ xstring		: tXSTRING_BEG xstring_contents tSTRING_END
 				nd_set_type(node, NODE_DXSTR);
 				break;
 			      default:
-				node = NEW_NODE(NODE_DXSTR, STR_NEW0(), 1, NEW_LIST(node));
+				node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
 				break;
 			    }
 			}
@@ -3850,12 +3867,12 @@ xstring		: tXSTRING_BEG xstring_contents tSTRING_END
 		    }
 		;
 
-regexp		: tREGEXP_BEG xstring_contents tREGEXP_END
+regexp		: tREGEXP_BEG regexp_contents tREGEXP_END
 		    {
 		    /*%%%*/
 			int options = $3;
 			NODE *node = $2;
-                        NODE *list;
+			NODE *list, *prev;
 			if (!node) {
 			    node = NEW_LIT(reg_compile(STR_NEW0(), options));
 			}
@@ -3877,12 +3894,35 @@ regexp		: tREGEXP_BEG xstring_contents tREGEXP_END
 				nd_set_type(node, NODE_DREGX);
 			    }
 			    node->nd_cflag = options & RE_OPTION_MASK;
-                            reg_fragment_check(node->nd_lit, options);
-                            for (list = node->nd_next; list; list = list->nd_next) {
-                                if (nd_type(list->nd_head) == NODE_STR) {
-                                    reg_fragment_check(list->nd_head->nd_lit, options);
+			    if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
+			    for (list = (prev = node)->nd_next; list; list = list->nd_next) {
+				if (nd_type(list->nd_head) == NODE_STR) {
+				    VALUE tail = list->nd_head->nd_lit;
+				    if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
+					VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
+					if (!literal_concat0(parser, lit, tail)) {
+					    node = 0;
+					    break;
+					}
+					rb_str_resize(tail, 0);
+					prev->nd_next = list->nd_next;
+					rb_gc_force_recycle((VALUE)list->nd_head);
+					rb_gc_force_recycle((VALUE)list);
+					list = prev;
+				    }
+				    else {
+					prev = list;
+				    }
                                 }
+				else {
+				    prev = 0;
+				}
                             }
+			    if (!node->nd_next) {
+				VALUE src = node->nd_lit;
+				nd_set_type(node, NODE_LIT);
+				node->nd_lit = reg_compile(src, options);
+			    }
 			    break;
 			}
 			$$ = node;
@@ -3898,11 +3938,16 @@ words		: tWORDS_BEG ' ' tSTRING_END
 			$$ = NEW_ZARRAY();
 		    /*%
 			$$ = dispatch0(words_new);
+			$$ = dispatch1(array, $$);
 		    %*/
 		    }
 		| tWORDS_BEG word_list tSTRING_END
 		    {
+		    /*%%%*/
 			$$ = $2;
+		    /*%
+			$$ = dispatch1(array, $2);
+		    %*/
 		    }
 		;
 
@@ -3948,11 +3993,16 @@ qwords		: tQWORDS_BEG ' ' tSTRING_END
 			$$ = NEW_ZARRAY();
 		    /*%
 			$$ = dispatch0(qwords_new);
+			$$ = dispatch1(array, $$);
 		    %*/
 		    }
 		| tQWORDS_BEG qword_list tSTRING_END
 		    {
+		    /*%%%*/
 			$$ = $2;
+		    /*%
+			$$ = dispatch1(array, $2);
+		    %*/
 		    }
 		;
 
@@ -4010,6 +4060,43 @@ xstring_contents: /* none */
 		    }
 		;
 
+regexp_contents: /* none */
+		    {
+		    /*%%%*/
+			$$ = 0;
+		    /*%
+			$$ = dispatch0(regexp_new);
+		    %*/
+		    }
+		| regexp_contents string_content
+		    {
+		    /*%%%*/
+			NODE *head = $1, *tail = $2;
+			if (!head) {
+			    $$ = tail;
+			}
+			else if (!tail) {
+			    $$ = head;
+			}
+			else {
+			    switch (nd_type(head)) {
+			      case NODE_STR:
+				nd_set_type(head, NODE_DSTR);
+				break;
+			      case NODE_DSTR:
+				break;
+			      default:
+				head = list_append(NEW_DSTR(Qnil), head);
+				break;
+			    }
+			    $$ = list_append(head, tail);
+			}
+		    /*%
+			$$ = dispatch2(regexp_add, $1, $2);
+		    %*/
+		    }
+		;
+
 string_content	: tSTRING_CONTENT
 		| tSTRING_DVAR
 		    {
@@ -4028,23 +4115,27 @@ string_content	: tSTRING_CONTENT
 		    %*/
 		    }
 		| tSTRING_DBEG
+		    {
+			$<val>1 = cond_stack;
+			$<val>$ = cmdarg_stack;
+			cond_stack = 0;
+			cmdarg_stack = 0;
+		    }
 		    {
 			$<node>$ = lex_strterm;
 			lex_strterm = 0;
 			lex_state = EXPR_BEG;
-			COND_PUSH(0);
-			CMDARG_PUSH(0);
 		    }
 		  compstmt '}'
 		    {
-			lex_strterm = $<node>2;
-			COND_LEXPOP();
-			CMDARG_LEXPOP();
+			cond_stack = $<val>1;
+			cmdarg_stack = $<val>2;
+			lex_strterm = $<node>3;
 		    /*%%%*/
-			if ($3) $3->flags &= ~NODE_FL_NEWLINE;
-			$$ = new_evstr($3);
+			if ($4) $4->flags &= ~NODE_FL_NEWLINE;
+			$$ = new_evstr($4);
 		    /*%
-			$$ = dispatch1(string_embexpr, $3);
+			$$ = dispatch1(string_embexpr, $4);
 		    %*/
 		    }
 		;
@@ -4078,11 +4169,10 @@ string_dvar	: tGVAR
 
 symbol		: tSYMBEG sym
 		    {
-		    /*%%%*/
 			lex_state = EXPR_END;
+		    /*%%%*/
 			$$ = $2;
 		    /*%
-			lex_state = EXPR_END;
 			$$ = dispatch1(symbol, $2);
 		    %*/
 		    }
@@ -4096,8 +4186,8 @@ sym		: fname
 
 dsym		: tSYMBEG xstring_contents tSTRING_END
 		    {
-		    /*%%%*/
 			lex_state = EXPR_END;
+		    /*%%%*/
 			if (!($$ = $2)) {
 			    $$ = NEW_LIT(ID2SYM(rb_intern("")));
 			}
@@ -4114,12 +4204,11 @@ dsym		: tSYMBEG xstring_contents tSTRING_END
 				nd_set_type($$, NODE_LIT);
 				break;
 			      default:
-				$$ = NEW_NODE(NODE_DSYM, STR_NEW0(), 1, NEW_LIST($$));
+				$$ = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST($$));
 				break;
 			    }
 			}
 		    /*%
-			lex_state = EXPR_END;
 			$$ = dispatch1(dyna_symbol, $2);
 		    %*/
 		    }
@@ -4171,10 +4260,10 @@ var_ref		: variable
 
 var_lhs		: variable
 		    {
-		    /*%%%*/
 			$$ = assignable($1, 0);
+		    /*%%%*/
 		    /*%
-			$$ = dispatch1(var_field, $1);
+			$$ = dispatch1(var_field, $$);
 		    %*/
 		    }
 		;
@@ -4215,13 +4304,11 @@ f_arglist	: '(' f_args rparen
 		    {
 		    /*%%%*/
 			$$ = $2;
-			lex_state = EXPR_BEG;
-			command_start = Qtrue;
 		    /*%
 			$$ = dispatch1(paren, $2);
-			lex_state = EXPR_BEG;
-			command_start = Qtrue;
 		    %*/
+			lex_state = EXPR_BEG;
+			command_start = TRUE;
 		    }
 		| f_args term
 		    {
@@ -4392,29 +4479,25 @@ f_bad_arg	: tCONSTANT
 f_norm_arg	: f_bad_arg
 		| tIDENTIFIER
 		    {
-		    /*%%%*/
-			if (!is_local_id($1))
-			    yyerror("formal argument must be local variable");
-			shadowing_lvar($1);
-		    /*%
-		    %*/
+			formal_argument(get_id($1));
 			$$ = $1;
 		    }
 		;
 
 f_arg_item	: f_norm_arg
 		    {
+			arg_var(get_id($1));
 		    /*%%%*/
-			arg_var($1);
 			$$ = NEW_ARGS_AUX($1, 1);
 		    /*%
+			$$ = get_value($1);
 		    %*/
 		    }
 		| tLPAREN f_margs rparen
 		    {
-		    /*%%%*/
 			ID tid = internal_id();
 			arg_var(tid);
+		    /*%%%*/
 			if (dyna_in_block()) {
 			    $2->nd_value = NEW_DVAR(tid);
 			}
@@ -4451,28 +4534,24 @@ f_arg		: f_arg_item
 
 f_opt		: tIDENTIFIER '=' arg_value
 		    {
+			arg_var(formal_argument(get_id($1)));
+			$$ = assignable($1, $3);
 		    /*%%%*/
-			if (!is_local_id($1))
-			    yyerror("formal argument must be local variable");
-			shadowing_lvar($1);
-			arg_var($1);
-			$$ = NEW_OPT_ARG(0, assignable($1, $3));
+			$$ = NEW_OPT_ARG(0, $$);
 		    /*%
-			$$ = rb_assoc_new($1, $3);
+			$$ = rb_assoc_new($$, $3);
 		    %*/
 		    }
 		;
 
 f_block_opt	: tIDENTIFIER '=' primary_value
 		    {
+			arg_var(formal_argument(get_id($1)));
+			$$ = assignable($1, $3);
 		    /*%%%*/
-			if (!is_local_id($1))
-			    yyerror("formal argument must be local variable");
-			shadowing_lvar($1);
-			arg_var($1);
-			$$ = NEW_OPT_ARG(0, assignable($1, $3));
+			$$ = NEW_OPT_ARG(0, $$);
 		    /*%
-			$$ = rb_assoc_new($1, $3);
+			$$ = rb_assoc_new($$, $3);
 		    %*/
 		    }
 		;
@@ -4534,8 +4613,9 @@ f_rest_arg	: restarg_mark tIDENTIFIER
 		    /*%%%*/
 			if (!is_local_id($2))
 			    yyerror("rest argument must be local variable");
-			shadowing_lvar($2);
-			arg_var($2);
+		    /*% %*/
+			arg_var(shadowing_lvar(get_id($2)));
+		    /*%%%*/
 			$$ = $2;
 		    /*%
 			$$ = dispatch1(rest_param, $2);
@@ -4563,8 +4643,9 @@ f_block_arg	: blkarg_mark tIDENTIFIER
 			    yyerror("block argument must be local variable");
 			else if (!dyna_in_block() && local_id($2))
 			    yyerror("duplicated block argument name");
-			shadowing_lvar($2);
-			arg_var($2);
+		    /*% %*/
+			arg_var(shadowing_lvar(get_id($2)));
+		    /*%%%*/
 			$$ = $2;
 		    /*%
 			$$ = dispatch1(blockarg, $2);
@@ -4765,41 +4846,65 @@ static int parser_here_document(struct parser_params*,NODE*);
 # define heredoc_restore(n)        parser_heredoc_restore(parser,n)
 # define whole_match_p(e,l,i)      parser_whole_match_p(parser,e,l,i)
 
-#ifdef RIPPER
-/* FIXME */
-# define local_id(x)       1
-# define dyna_in_block()   1
-#endif /* RIPPER */
-
 #ifndef RIPPER
 # define set_yylval_str(x) yylval.node = NEW_STR(x)
 # define set_yylval_num(x) yylval.num = x
 # define set_yylval_id(x)  yylval.id = x
+# define set_yylval_name(x)  yylval.id = x
 # define set_yylval_literal(x) yylval.node = NEW_LIT(x)
 # define set_yylval_node(x) yylval.node = x
 # define yylval_id() yylval.id
 #else
+static inline VALUE
+ripper_yylval_id(ID x)
+{
+    return (VALUE)NEW_LASGN(x, ID2SYM(x));
+}
 # define set_yylval_str(x) (void)(x)
 # define set_yylval_num(x) (void)(x)
-# define set_yylval_id(x) (void)(x)
+# define set_yylval_id(x)  (void)(x)
+# define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
 # define set_yylval_literal(x) (void)(x)
 # define set_yylval_node(x) (void)(x)
-# define yylval_id() SYM2ID(yylval.val)
+# define yylval_id() yylval.id
 #endif
 
-#ifdef RIPPER
+#ifndef RIPPER
+#define ripper_flush(p) (void)(p)
+#else
 #define ripper_flush(p) (p->tokp = p->parser_lex_p)
 
-static void
-ripper_dispatch_scan_event(struct parser_params *parser, int t)
+#define yylval_rval *(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val)
+
+static int
+ripper_has_scan_event(struct parser_params *parser)
 {
-    VALUE str;
 
     if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
-    if (lex_p == parser->tokp) return;
-    str = STR_NEW(parser->tokp, lex_p - parser->tokp);
-    yylval.val = ripper_dispatch1(parser, ripper_token2eventid(t), str);
+    return lex_p > parser->tokp;
+}
+
+static VALUE
+ripper_scan_event_val(struct parser_params *parser, int t)
+{
+    VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
+    VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
     ripper_flush(parser);
+    return rval;
+}
+
+static void
+ripper_dispatch_scan_event(struct parser_params *parser, int t)
+{
+    if (!ripper_has_scan_event(parser)) return;
+    yylval_rval = ripper_scan_event_val(parser, t);
+}
+
+static void
+ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
+{
+    if (!ripper_has_scan_event(parser)) return;
+    (void)ripper_scan_event_val(parser, t);
 }
 
 static void
@@ -4810,7 +4915,7 @@ ripper_dispatch_delayed_token(struct parser_params *parser, int t)
 
     ruby_sourceline = parser->delayed_line;
     parser->tokp = lex_pbeg + parser->delayed_col;
-    yylval.val = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
+    yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
     parser->delayed = Qnil;
     ruby_sourceline = saved_line;
     parser->tokp = saved_tokp;
@@ -4867,6 +4972,7 @@ token_info_has_nonspaces(struct parser_params *parser, const char *token)
     return 0;
 }
 
+#undef token_info_push
 static void
 token_info_push(struct parser_params *parser, const char *token)
 {
@@ -4883,6 +4989,7 @@ token_info_push(struct parser_params *parser, const char *token)
     parser->parser_token_info = ptinfo;
 }
 
+#undef token_info_pop
 static void
 token_info_pop(struct parser_params *parser, const char *token)
 {
@@ -4917,7 +5024,8 @@ parser_yyerror(struct parser_params *parser, const char *msg)
     const int max_line_margin = 30;
     const char *p, *pe;
     char *buf;
-    int len, i;
+    long len;
+    int i;
 
     compile_error(PARSER_ARG "%s", msg);
     p = lex_p;
@@ -4954,7 +5062,7 @@ parser_yyerror(struct parser_params *parser, const char *msg)
 	buf[len] = '\0';
 	rb_compile_error_append("%s%s%s", pre, buf, post);
 
-	i = lex_p - p;
+	i = (int)(lex_p - p);
 	p2 = buf; pe = buf + len;
 
 	while (p2 < pe) {
@@ -4979,8 +5087,10 @@ VALUE ruby_suppress_tracing(VALUE (*func)(VALUE, int), VALUE arg, int always);
 static VALUE
 debug_lines(const char *f)
 {
-    if (rb_const_defined_at(rb_cObject, rb_intern("SCRIPT_LINES__"))) {
-	VALUE hash = rb_const_get_at(rb_cObject, rb_intern("SCRIPT_LINES__"));
+    ID script_lines;
+    CONST_ID(script_lines, "SCRIPT_LINES__");
+    if (rb_const_defined_at(rb_cObject, script_lines)) {
+	VALUE hash = rb_const_get_at(rb_cObject, script_lines);
 	if (TYPE(hash) == T_HASH) {
 	    VALUE fname = rb_str_new2(f);
 	    VALUE lines = rb_ary_new();
@@ -5012,9 +5122,7 @@ coverage(const char *f, int n)
 static int
 e_option_supplied(struct parser_params *parser)
 {
-    if (strcmp(ruby_sourcefile, "-e") == 0)
-	return Qtrue;
-    return Qfalse;
+    return strcmp(ruby_sourcefile, "-e") == 0;
 }
 
 static VALUE
@@ -5024,7 +5132,7 @@ yycompile0(VALUE arg, int tracing)
     NODE *tree;
     struct parser_params *parser = (struct parser_params *)arg;
 
-    if ((!compile_for_eval || rb_parse_in_main()) && rb_safe_level() == 0) {
+    if (!compile_for_eval && rb_safe_level() == 0) {
 	ruby_debug_lines = debug_lines(ruby_sourcefile);
 	if (ruby_debug_lines && ruby_sourceline > 0) {
 	    VALUE str = STR_NEW0();
@@ -5056,16 +5164,8 @@ yycompile0(VALUE arg, int tracing)
     if (!tree) {
 	tree = NEW_NIL();
     }
-    if (ruby_eval_tree_begin) {
-	NODE *scope = ruby_eval_tree;
-
-        if (scope) {
-	    scope->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, scope->nd_body);
-	}
-	tree = scope;
-    }
-    else {
-	tree = ruby_eval_tree;
+    else if (ruby_eval_tree_begin) {
+	tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
     }
     return (VALUE)tree;
 }
@@ -5075,14 +5175,25 @@ yycompile(struct parser_params *parser, const char *f, int line)
 {
     ruby_sourcefile = ruby_strdup(f);
     ruby_sourceline = line - 1;
-    return (NODE *)ruby_suppress_tracing(yycompile0, (VALUE)parser, Qtrue);
+    return (NODE *)ruby_suppress_tracing(yycompile0, (VALUE)parser, TRUE);
 }
 #endif /* !RIPPER */
 
+static rb_encoding *
+must_be_ascii_compatible(VALUE s)
+{
+    rb_encoding *enc = rb_enc_get(s);
+    if (!rb_enc_asciicompat(enc)) {
+	rb_raise(rb_eArgError, "invalid source encoding");
+    }
+    return enc;
+}
+
 static VALUE
 lex_get_str(struct parser_params *parser, VALUE s)
 {
     char *beg, *end, *pend;
+    rb_encoding *enc = must_be_ascii_compatible(s);
 
     beg = RSTRING_PTR(s);
     if (lex_gets_ptr) {
@@ -5095,41 +5206,38 @@ lex_get_str(struct parser_params *parser, VALUE s)
 	if (*end++ == '\n') break;
     }
     lex_gets_ptr = end - RSTRING_PTR(s);
-    return rb_enc_str_new(beg, end - beg, rb_enc_get(s));
+    return rb_enc_str_new(beg, end - beg, enc);
 }
 
 static VALUE
 lex_getline(struct parser_params *parser)
 {
     VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
+    if (NIL_P(line)) return line;
+    must_be_ascii_compatible(line);
 #ifndef RIPPER
-    if (ruby_debug_lines && !NIL_P(line)) {
+    if (ruby_debug_lines) {
+	rb_enc_associate(line, parser->enc);
 	rb_ary_push(ruby_debug_lines, line);
     }
-    if (ruby_coverage && !NIL_P(line)) {
+    if (ruby_coverage) {
 	rb_ary_push(ruby_coverage, Qnil);
     }
 #endif
     return line;
 }
 
-#ifndef RIPPER
-NODE*
-rb_compile_string(const char *f, VALUE s, int line)
-{
-    VALUE volatile vparser = rb_parser_new();
-
-    return rb_parser_compile_string(vparser, f, s, line);
-}
+static const rb_data_type_t parser_data_type;
 
-NODE*
-rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
+#ifndef RIPPER
+static NODE*
+parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
 {
     struct parser_params *parser;
     NODE *node;
     volatile VALUE tmp;
 
-    Data_Get_Struct(vparser, struct parser_params, parser);
+    TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
     lex_gets = lex_get_str;
     lex_gets_ptr = 0;
     lex_input = s;
@@ -5142,16 +5250,32 @@ rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int lin
     return node;
 }
 
+NODE*
+rb_compile_string(const char *f, VALUE s, int line)
+{
+    must_be_ascii_compatible(s);
+    return parser_compile_string(rb_parser_new(), f, s, line);
+}
+
+NODE*
+rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
+{
+    must_be_ascii_compatible(s);
+    return parser_compile_string(vparser, f, s, line);
+}
+
 NODE*
 rb_compile_cstr(const char *f, const char *s, int len, int line)
 {
-    return rb_compile_string(f, rb_str_new(s, len), line);
+    VALUE str = rb_str_new(s, len);
+    return parser_compile_string(rb_parser_new(), f, str, line);
 }
 
 NODE*
 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
 {
-    return rb_parser_compile_string(vparser, f, rb_str_new(s, len), line);
+    VALUE str = rb_str_new(s, len);
+    return parser_compile_string(vparser, f, str, line);
 }
 
 static VALUE
@@ -5175,7 +5299,7 @@ rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int st
     volatile VALUE tmp;
     NODE *node;
 
-    Data_Get_Struct(vparser, struct parser_params, parser);
+    TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
     lex_gets = lex_io_gets;
     lex_input = file;
     lex_pbeg = lex_p = lex_pend = 0;
@@ -5252,7 +5376,7 @@ parser_nextc(struct parser_params *parser)
 		    rb_str_buf_cat(parser->delayed,
 				   parser->tokp, lex_pend - parser->tokp);
 		    parser->delayed_line = ruby_sourceline;
-		    parser->delayed_col = parser->tokp - lex_pbeg;
+		    parser->delayed_col = (int)(parser->tokp - lex_pbeg);
 		}
 		else {
 		    rb_str_buf_cat(parser->delayed,
@@ -5268,9 +5392,7 @@ parser_nextc(struct parser_params *parser)
 	    parser->line_count++;
 	    lex_pbeg = lex_p = RSTRING_PTR(v);
 	    lex_pend = lex_p + RSTRING_LEN(v);
-#ifdef RIPPER
 	    ripper_flush(parser);
-#endif
 	    lex_lastline = v;
 	}
     }
@@ -5338,7 +5460,7 @@ parser_tokadd(struct parser_params *parser, int c)
 }
 
 static int
-parser_tok_hex(struct parser_params *parser, int *numlen)
+parser_tok_hex(struct parser_params *parser, size_t *numlen)
 {
     int c;
 
@@ -5365,7 +5487,7 @@ parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
      */
 
     int codepoint;
-    int numlen;
+    size_t numlen;
 
     if (regexp_literal) { tokadd('\\'); tokadd('u'); }
 
@@ -5384,18 +5506,13 @@ parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
 	    }
 	    lex_p += numlen;
             if (regexp_literal) {
-                tokcopy(numlen);
+                tokcopy((int)numlen);
             }
             else if (codepoint >= 0x80) {
 		*encp = UTF8_ENC();
 		if (string_literal) tokaddmbc(codepoint, *encp);
 	    }
 	    else if (string_literal) {
-		if (codepoint == 0 && symbol_literal) {
-		    yyerror("symbol cannot contain '\\u{0}'");
-		    return 0;
-		}
-
 		tokadd(codepoint);
 	    }
 	} while (string_literal && (peek(' ') || peek('\t')));
@@ -5423,11 +5540,6 @@ parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
 	    if (string_literal) tokaddmbc(codepoint, *encp);
 	}
 	else if (string_literal) {
-	    if (codepoint == 0 && symbol_literal) {
-		yyerror("symbol cannot contain '\\u0000'");
-		return 0;
-	    }
-
 	    tokadd(codepoint);
 	}
     }
@@ -5443,7 +5555,7 @@ parser_read_escape(struct parser_params *parser, int flags,
 		   rb_encoding **encp)
 {
     int c;
-    int numlen;
+    size_t numlen;
 
     switch (c = nextc()) {
       case '\\':	/* Backslash */
@@ -5473,13 +5585,9 @@ parser_read_escape(struct parser_params *parser, int flags,
       case '0': case '1': case '2': case '3': /* octal constant */
       case '4': case '5': case '6': case '7':
 	if (flags & (ESCAPE_CONTROL|ESCAPE_META)) goto eof;
-	{
-	    int numlen;
-
-	    pushback(c);
-	    c = scan_oct(lex_p, 3, &numlen);
-	    lex_p += numlen;
-	}
+	pushback(c);
+	c = scan_oct(lex_p, 3, &numlen);
+	lex_p += numlen;
 	return c;
 
       case 'x':	/* hex constant */
@@ -5501,6 +5609,7 @@ parser_read_escape(struct parser_params *parser, int flags,
 	    goto eof;
 	}
 	if ((c = nextc()) == '\\') {
+	    if (peek('u')) goto eof;
 	    return read_escape(flags|ESCAPE_META, encp) | 0x80;
 	}
 	else if (c == -1 || !ISASCII(c)) goto eof;
@@ -5516,6 +5625,7 @@ parser_read_escape(struct parser_params *parser, int flags,
       case 'c':
 	if (flags & ESCAPE_CONTROL) goto eof;
 	if ((c = nextc())== '\\') {
+	    if (peek('u')) goto eof;
 	    c = read_escape(flags|ESCAPE_CONTROL, encp);
 	}
 	else if (c == '?')
@@ -5545,6 +5655,7 @@ parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
 {
     int c;
     int flags = 0;
+    size_t numlen;
 
   first:
     switch (c = nextc()) {
@@ -5555,25 +5666,19 @@ parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
       case '4': case '5': case '6': case '7':
 	if (flags & (ESCAPE_CONTROL|ESCAPE_META)) goto eof;
 	{
-	    int numlen;
-	    int oct;
-
-	    oct = scan_oct(--lex_p, 3, &numlen);
+	    ruby_scan_oct(--lex_p, 3, &numlen);
 	    if (numlen == 0) goto eof;
 	    lex_p += numlen;
-	    tokcopy(numlen + 1);
+	    tokcopy((int)numlen + 1);
 	}
 	return 0;
 
       case 'x':	/* hex constant */
 	if (flags & (ESCAPE_CONTROL|ESCAPE_META)) goto eof;
 	{
-	    int numlen;
-	    int hex;
-
-	    hex = tok_hex(&numlen);
+	    tok_hex(&numlen);
 	    if (numlen == 0) goto eof;
-	    tokcopy(numlen + 2);
+	    tokcopy((int)numlen + 2);
 	}
 	return 0;
 
@@ -5626,6 +5731,7 @@ static int
 parser_regx_options(struct parser_params *parser)
 {
     int kcode = 0;
+    int kopt = 0;
     int options = 0;
     int c, opt, kc;
 
@@ -5635,13 +5741,19 @@ parser_regx_options(struct parser_params *parser)
             options |= RE_OPTION_ONCE;
         }
         else if (rb_char_to_option_kcode(c, &opt, &kc)) {
-            options |= opt;
-	    if (kc >= 0) kcode = c;
+	    if (kc >= 0) {
+		if (kc != rb_ascii8bit_encindex()) kcode = c;
+		kopt = opt;
+	    }
+	    else {
+		options |= opt;
+	    }
         }
         else {
 	    tokadd(c);
         }
     }
+    options |= kopt;
     pushback(c);
     if (toklen()) {
 	tokfix();
@@ -5688,7 +5800,7 @@ parser_tokadd_string(struct parser_params *parser,
     static const char mixed_msg[] = "%s mixed within %s source";
 
 #define mixed_error(enc1, enc2) if (!errbuf) {	\
-	int len = sizeof(mixed_msg) - 4;	\
+	size_t len = sizeof(mixed_msg) - 4;	\
 	len += strlen(rb_enc_name(enc1));	\
 	len += strlen(rb_enc_name(enc2));	\
 	errbuf = ALLOCA_N(char, len);		\
@@ -5769,6 +5881,8 @@ parser_tokadd_string(struct parser_params *parser,
 		}
 		else if (c != term && !(paren && c == paren)) {
 		    tokadd('\\');
+		    pushback(c);
+		    continue;
 		}
 	    }
 	}
@@ -5785,11 +5899,6 @@ parser_tokadd_string(struct parser_params *parser,
 	    pushback(c);
 	    break;
 	}
-	if (!c && (func & STR_FUNC_SYMBOL)) {
-	    func &= ~STR_FUNC_SYMBOL;
-	    compile_error(PARSER_ARG "symbol cannot contain '\\0'");
-	    continue;
-	}
         if (c & 0x80) {
             has_nonascii = 1;
 	    if (enc != *encp) {
@@ -5809,7 +5918,7 @@ parser_tokadd_string(struct parser_params *parser,
 static int
 parser_parse_string(struct parser_params *parser, NODE *quote)
 {
-    int func = quote->nd_func;
+    int func = (int)quote->nd_func;
     int term = nd_term(quote);
     int paren = nd_paren(quote);
     int c, space = 0;
@@ -5864,13 +5973,26 @@ parser_parse_string(struct parser_params *parser, NODE *quote)
 
     tokfix();
     set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
+
+#ifdef RIPPER
+    if (!NIL_P(parser->delayed)){
+	ptrdiff_t len = lex_p - parser->tokp;
+	if (len > 0) {
+	    rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
+	}
+	ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
+	parser->tokp = lex_p;
+    }
+#endif
+
     return tSTRING_CONTENT;
 }
 
 static int
 parser_heredoc_identifier(struct parser_params *parser)
 {
-    int c = nextc(), term, func = 0, len;
+    int c = nextc(), term, func = 0;
+    long len;
 
     if (c == '-') {
 	c = nextc();
@@ -5925,9 +6047,7 @@ parser_heredoc_identifier(struct parser_params *parser)
 				  len,				/* nd_nth */
 				  lex_lastline);		/* nd_orig */
     nd_set_line(lex_strterm, ruby_sourceline);
-#ifdef RIPPER
     ripper_flush(parser);
-#endif
     return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
 }
 
@@ -5936,12 +6056,6 @@ parser_heredoc_restore(struct parser_params *parser, NODE *here)
 {
     VALUE line;
 
-#ifdef RIPPER
-    if (!NIL_P(parser->delayed))
-	ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
-    lex_goto_eol(parser);
-    ripper_dispatch_scan_event(parser, tHEREDOC_END);
-#endif
     line = here->nd_orig;
     lex_lastline = line;
     lex_pbeg = RSTRING_PTR(line);
@@ -5951,25 +6065,22 @@ parser_heredoc_restore(struct parser_params *parser, NODE *here)
     ruby_sourceline = nd_line(here);
     dispose_string(here->nd_lit);
     rb_gc_force_recycle((VALUE)here);
-#ifdef RIPPER
     ripper_flush(parser);
-#endif
 }
 
 static int
 parser_whole_match_p(struct parser_params *parser,
-    const char *eos, int len, int indent)
+    const char *eos, long len, int indent)
 {
     const char *p = lex_pbeg;
-    int n;
+    long n;
 
     if (indent) {
 	while (*p && ISSPACE(*p)) p++;
     }
-    n= lex_pend - (p + len);
-    if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return Qfalse;
-    if (strncmp(eos, p, len) == 0) return Qtrue;
-    return Qfalse;
+    n = lex_pend - (p + len);
+    if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
+    return strncmp(eos, p, len) == 0;
 }
 
 static int
@@ -5979,6 +6090,7 @@ parser_here_document(struct parser_params *parser, NODE *here)
     const char *eos, *p, *pend;
     long len;
     VALUE str = 0;
+    rb_encoding *enc = parser->enc;
 
     eos = RSTRING_PTR(here->nd_lit);
     len = RSTRING_LEN(here->nd_lit) - 1;
@@ -5987,6 +6099,20 @@ parser_here_document(struct parser_params *parser, NODE *here)
     if ((c = nextc()) == -1) {
       error:
 	compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
+#ifdef RIPPER
+	if (NIL_P(parser->delayed)) {
+	    ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
+	}
+	else {
+	    if (str ||
+		((len = lex_p - parser->tokp) > 0 &&
+		 (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
+		rb_str_append(parser->delayed, str);
+	    }
+	    ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
+	}
+	lex_goto_eol(parser);
+#endif
       restore:
 	heredoc_restore(lex_strterm);
 	lex_strterm = 0;
@@ -6026,7 +6152,6 @@ parser_here_document(struct parser_params *parser, NODE *here)
     }
     else {
 	/*	int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
-	rb_encoding *enc = parser->enc;
 	newtok();
 	if (c == '#') {
 	    switch (c = nextc()) {
@@ -6055,6 +6180,12 @@ parser_here_document(struct parser_params *parser, NODE *here)
 	} while (!whole_match_p(eos, len, indent));
 	str = STR_NEW3(tok(), toklen(), enc, func);
     }
+#ifdef RIPPER
+    if (!NIL_P(parser->delayed))
+	ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
+    lex_goto_eol(parser);
+    ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
+#endif
     heredoc_restore(lex_strterm);
     lex_strterm = NEW_STRTERM(-1, 0, 0);
     set_yylval_str(str);
@@ -6063,45 +6194,50 @@ parser_here_document(struct parser_params *parser, NODE *here)
 
 #include "lex.c"
 
-#ifndef RIPPER
 static void
 arg_ambiguous_gen(struct parser_params *parser)
 {
+#ifndef RIPPER
     rb_warning0("ambiguous first argument; put parentheses or even spaces");
-}
 #else
-static void
-arg_ambiguous_gen(struct parser_params *parser)
-{
     dispatch0(arg_ambiguous);
+#endif
 }
+#define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
+
+static ID
+formal_argument_gen(struct parser_params *parser, ID lhs)
+{
+#ifndef RIPPER
+    if (!is_local_id(lhs))
+	yyerror("formal argument must be local variable");
 #endif
-#define arg_ambiguous() arg_ambiguous_gen(parser)
+    shadowing_lvar(lhs);
+    return lhs;
+}
 
 static int
 lvar_defined_gen(struct parser_params *parser, ID id)
 {
-#ifndef RIPPER
     return (dyna_in_block() && dvar_defined(id)) || local_id(id);
-#else
-    return 0;
-#endif
 }
 
 /* emacsen -*- hack */
-static int
-parser_encode_length(struct parser_params *parser, const char *name, int len)
+static long
+parser_encode_length(struct parser_params *parser, const char *name, long len)
 {
-    int nlen;
+    long nlen;
 
     if (len > 5 && name[nlen = len - 5] == '-') {
 	if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
 	    return nlen;
     }
-    if (len > 4 && name[nlen = len - 5] == '-') {
+    if (len > 4 && name[nlen = len - 4] == '-') {
 	if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
 	    return nlen;
-	if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0)
+	if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
+	    !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
+	    /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
 	    return nlen;
     }
     return len;
@@ -6112,15 +6248,34 @@ parser_set_encode(struct parser_params *parser, const char *name)
 {
     int idx = rb_enc_find_index(name);
     rb_encoding *enc;
+    VALUE excargs[3];
 
     if (idx < 0) {
-	rb_raise(rb_eArgError, "unknown encoding name: %s", name);
+	VALUE rb_make_backtrace(void);
+	VALUE rb_make_exception(int, VALUE*);
+
+	excargs[1] = rb_sprintf("unknown encoding name: %s", name);
+      error:
+	excargs[0] = rb_eArgError;
+	excargs[2] = rb_make_backtrace();
+	rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
+	rb_exc_raise(rb_make_exception(3, excargs));
     }
     enc = rb_enc_from_index(idx);
     if (!rb_enc_asciicompat(enc)) {
-	rb_raise(rb_eArgError, "%s is not ASCII compatible", rb_enc_name(enc));
+	excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
+	goto error;
     }
     parser->enc = enc;
+#ifndef RIPPER
+    if (ruby_debug_lines) {
+	long i, n = RARRAY_LEN(ruby_debug_lines);
+	const VALUE *p = RARRAY_PTR(ruby_debug_lines);
+	for (i = 0; i < n; ++i) {
+	    rb_enc_associate_index(*p, idx);
+	}
+    }
+#endif
 }
 
 static int
@@ -6136,15 +6291,13 @@ comment_at_top(struct parser_params *parser)
 }
 
 #ifndef RIPPER
-typedef int (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, int len);
+typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
 
 static void
 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
 {
     if (!comment_at_top(parser)) {
-	rb_warning("encoding '%s' is ignored, valid only in the first line except for shebang line.",
-		   val);
 	return;
     }
     parser_set_encode(parser, val);
@@ -6163,9 +6316,9 @@ static const struct magic_comment magic_comments[] = {
 #endif
 
 static const char *
-magic_comment_marker(const char *str, int len)
+magic_comment_marker(const char *str, long len)
 {
-    int i = 2;
+    long i = 2;
 
     while (i < len) {
 	switch (str[i]) {
@@ -6196,7 +6349,7 @@ magic_comment_marker(const char *str, int len)
 }
 
 static int
-parser_magic_comment(struct parser_params *parser, const char *str, int len)
+parser_magic_comment(struct parser_params *parser, const char *str, long len)
 {
     VALUE name = 0, val = 0;
     const char *beg, *end, *vbeg, *vend;
@@ -6205,9 +6358,9 @@ parser_magic_comment(struct parser_params *parser, const char *str, int len)
 	   MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
 	: ((_s) = STR_NEW((_p), (_n))))
 
-    if (len <= 7) return Qfalse;
-    if (!(beg = magic_comment_marker(str, len))) return Qfalse;
-    if (!(end = magic_comment_marker(beg, str + len - beg))) return Qfalse;
+    if (len <= 7) return FALSE;
+    if (!(beg = magic_comment_marker(str, len))) return FALSE;
+    if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
     str = beg;
     len = end - beg - 3;
 
@@ -6217,7 +6370,8 @@ parser_magic_comment(struct parser_params *parser, const char *str, int len)
 	const struct magic_comment *p = magic_comments;
 #endif
 	char *s;
-	int i, n = 0;
+	int i;
+	long n = 0;
 
 	for (; len > 0 && *str; str++, --len) {
 	    switch (*str) {
@@ -6265,7 +6419,7 @@ parser_magic_comment(struct parser_params *parser, const char *str, int len)
 	str_copy(name, beg, n);
 	s = RSTRING_PTR(name);
 	for (i = 0; i < n; ++i) {
-	    if (*s == '-') *s = '_';
+	    if (s[i] == '-') s[i] = '_';
 	}
 #ifndef RIPPER
 	do {
@@ -6278,13 +6432,13 @@ parser_magic_comment(struct parser_params *parser, const char *str, int len)
 		(*p->func)(parser, s, RSTRING_PTR(val));
 		break;
 	    }
-	} while (++p < magic_comments + sizeof(magic_comments) / sizeof(*p));
+	} while (++p < magic_comments + numberof(magic_comments));
 #else
 	dispatch2(magic_comment, name, val);
 #endif
     }
 
-    return Qtrue;
+    return TRUE;
 }
 
 static void
@@ -6356,7 +6510,23 @@ parser_prepare(struct parser_params *parser)
 }
 
 #define IS_ARG() (lex_state == EXPR_ARG || lex_state == EXPR_CMDARG)
+#define IS_END() (lex_state == EXPR_END || lex_state == EXPR_ENDARG || lex_state == EXPR_ENDFN)
 #define IS_BEG() (lex_state == EXPR_BEG || lex_state == EXPR_MID || lex_state == EXPR_VALUE || lex_state == EXPR_CLASS)
+#define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
+
+#ifndef RIPPER
+#define ambiguous_operator(op, syn) ( \
+    rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
+    rb_warning0("even though it seems like "syn""))
+#else
+#define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
+#endif
+#define warn_balanced(op, syn) \
+    (last_state != EXPR_CLASS && last_state != EXPR_DOT && \
+     last_state != EXPR_FNAME && last_state != EXPR_ENDFN && \
+     last_state != EXPR_ENDARG && \
+     space_seen && !ISSPACE(c) && \
+     (ambiguous_operator(op, syn), 0))
 
 static int
 parser_yylex(struct parser_params *parser)
@@ -6368,7 +6538,7 @@ parser_yylex(struct parser_params *parser)
     rb_encoding *enc;
     int mb;
 #ifdef RIPPER
-    int fallthru = Qfalse;
+    int fallthru = FALSE;
 #endif
 
     if (lex_strterm) {
@@ -6391,8 +6561,9 @@ parser_yylex(struct parser_params *parser)
 	return token;
     }
     cmd_state = command_start;
-    command_start = Qfalse;
+    command_start = FALSE;
   retry:
+    last_state = lex_state;
     switch (c = nextc()) {
       case '\0':		/* NUL */
       case '\004':		/* ^D */
@@ -6403,7 +6574,7 @@ parser_yylex(struct parser_params *parser)
 	/* white spaces */
       case ' ': case '\t': case '\f': case '\r':
       case '\13': /* '\v' */
-	space_seen++;
+	space_seen = 1;
 #ifdef RIPPER
 	while ((c = nextc())) {
 	    switch (c) {
@@ -6430,7 +6601,7 @@ parser_yylex(struct parser_params *parser)
 	lex_p = lex_pend;
 #ifdef RIPPER
         ripper_dispatch_scan_event(parser, tCOMMENT);
-        fallthru = Qtrue;
+        fallthru = TRUE;
 #endif
 	/* fall through */
       case '\n':
@@ -6444,7 +6615,7 @@ parser_yylex(struct parser_params *parser)
             if (!fallthru) {
                 ripper_dispatch_scan_event(parser, tIGNORED_NL);
             }
-            fallthru = Qfalse;
+            fallthru = FALSE;
 #endif
 	    goto retry;
 	  default:
@@ -6454,7 +6625,7 @@ parser_yylex(struct parser_params *parser)
 	    switch (c) {
 	      case ' ': case '\t': case '\f': case '\r':
 	      case '\13': /* '\v' */
-		space_seen++;
+		space_seen = 1;
 		break;
 	      case '.': {
 		  if ((c = nextc()) != '.') {
@@ -6477,7 +6648,7 @@ parser_yylex(struct parser_params *parser)
 	    }
 	}
       normal_newline:
-	command_start = Qtrue;
+	command_start = TRUE;
 	lex_state = EXPR_BEG;
 	return '\n';
 
@@ -6498,7 +6669,7 @@ parser_yylex(struct parser_params *parser)
 		return tOP_ASGN;
 	    }
 	    pushback(c);
-	    if (IS_ARG() && space_seen && !ISSPACE(c)) {
+	    if (IS_SPCARG(c)) {
 		rb_warning0("`*' interpreted as argument prefix");
 		c = tSTAR;
 	    }
@@ -6506,6 +6677,7 @@ parser_yylex(struct parser_params *parser)
 		c = tSTAR;
 	    }
 	    else {
+		warn_balanced("*", "argument prefix");
 		c = '*';
 	    }
 	}
@@ -6542,7 +6714,7 @@ parser_yylex(struct parser_params *parser)
 	    /* skip embedded rd document */
 	    if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
 #ifdef RIPPER
-                int first_p = Qtrue;
+                int first_p = TRUE;
 
                 lex_goto_eol(parser);
                 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
@@ -6553,7 +6725,7 @@ parser_yylex(struct parser_params *parser)
                     if (!first_p) {
                         ripper_dispatch_scan_event(parser, tEMBDOC);
                     }
-                    first_p = Qfalse;
+                    first_p = FALSE;
 #endif
 		    c = nextc();
 		    if (c == -1) {
@@ -6597,12 +6769,12 @@ parser_yylex(struct parser_params *parser)
 	return '=';
 
       case '<':
+	last_state = lex_state;
 	c = nextc();
 	if (c == '<' &&
-	    lex_state != EXPR_END &&
 	    lex_state != EXPR_DOT &&
-	    lex_state != EXPR_ENDARG &&
 	    lex_state != EXPR_CLASS &&
+	    !IS_END() &&
 	    (!IS_ARG() || space_seen)) {
 	    int token = heredoc_identifier();
 	    if (token) return token;
@@ -6627,6 +6799,7 @@ parser_yylex(struct parser_params *parser)
 		return tOP_ASGN;
 	    }
 	    pushback(c);
+	    warn_balanced("<<", "here document");
 	    return tLSHFT;
 	}
 	pushback(c);
@@ -6660,7 +6833,7 @@ parser_yylex(struct parser_params *parser)
 
       case '`':
 	if (lex_state == EXPR_FNAME) {
-	    lex_state = EXPR_END;
+	    lex_state = EXPR_ENDFN;
 	    return c;
 	}
 	if (lex_state == EXPR_DOT) {
@@ -6678,7 +6851,7 @@ parser_yylex(struct parser_params *parser)
 	return tSTRING_BEG;
 
       case '?':
-	if (lex_state == EXPR_END || lex_state == EXPR_ENDARG) {
+	if (IS_END()) {
 	    lex_state = EXPR_VALUE;
 	    return '?';
 	}
@@ -6769,7 +6942,7 @@ parser_yylex(struct parser_params *parser)
 	    return tOP_ASGN;
 	}
 	pushback(c);
-	if (IS_ARG() && space_seen && !ISSPACE(c)) {
+	if (IS_SPCARG(c)) {
 	    rb_warning0("`&' interpreted as argument prefix");
 	    c = tAMPER;
 	}
@@ -6777,6 +6950,7 @@ parser_yylex(struct parser_params *parser)
 	    c = tAMPER;
 	}
 	else {
+	    warn_balanced("&", "argument prefix");
 	    c = '&';
 	}
 	switch (lex_state) {
@@ -6827,9 +7001,7 @@ parser_yylex(struct parser_params *parser)
 	    lex_state = EXPR_BEG;
 	    return tOP_ASGN;
 	}
-	if (IS_BEG() ||
-	    (IS_ARG() && space_seen && !ISSPACE(c))) {
-	    if (IS_ARG()) arg_ambiguous();
+	if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
 	    lex_state = EXPR_BEG;
 	    pushback(c);
 	    if (c != -1 && ISDIGIT(c)) {
@@ -6840,6 +7012,7 @@ parser_yylex(struct parser_params *parser)
 	}
 	lex_state = EXPR_BEG;
 	pushback(c);
+	warn_balanced("+", "unary operator");
 	return '+';
 
       case '-':
@@ -6861,9 +7034,7 @@ parser_yylex(struct parser_params *parser)
 	    lex_state = EXPR_ARG;
 	    return tLAMBDA;
 	}
-	if (IS_BEG() ||
-	    (IS_ARG() && space_seen && !ISSPACE(c))) {
-	    if (IS_ARG()) arg_ambiguous();
+	if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
 	    lex_state = EXPR_BEG;
 	    pushback(c);
 	    if (c != -1 && ISDIGIT(c)) {
@@ -6873,6 +7044,7 @@ parser_yylex(struct parser_params *parser)
 	}
 	lex_state = EXPR_BEG;
 	pushback(c);
+	warn_balanced("-", "unary operator");
 	return '-';
 
       case '.':
@@ -6905,6 +7077,7 @@ parser_yylex(struct parser_params *parser)
 		c = nextc();
 	    }
 	    if (c == '0') {
+#define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
 		int start = toklen();
 		c = nextc();
 		if (c == 'x' || c == 'X') {
@@ -6925,10 +7098,10 @@ parser_yylex(struct parser_params *parser)
 		    pushback(c);
 		    tokfix();
 		    if (toklen() == start) {
-			yyerror("numeric literal without digits");
+			no_digits();
 		    }
 		    else if (nondigit) goto trailing_uc;
-                    set_yylval_literal(rb_cstr_to_inum(tok(), 16, Qfalse));
+		    set_yylval_literal(rb_cstr_to_inum(tok(), 16, FALSE));
 		    return tINTEGER;
 		}
 		if (c == 'b' || c == 'B') {
@@ -6949,10 +7122,10 @@ parser_yylex(struct parser_params *parser)
 		    pushback(c);
 		    tokfix();
 		    if (toklen() == start) {
-			yyerror("numeric literal without digits");
+			no_digits();
 		    }
 		    else if (nondigit) goto trailing_uc;
-                    set_yylval_literal(rb_cstr_to_inum(tok(), 2, Qfalse));
+		    set_yylval_literal(rb_cstr_to_inum(tok(), 2, FALSE));
 		    return tINTEGER;
 		}
 		if (c == 'd' || c == 'D') {
@@ -6973,10 +7146,10 @@ parser_yylex(struct parser_params *parser)
 		    pushback(c);
 		    tokfix();
 		    if (toklen() == start) {
-			yyerror("numeric literal without digits");
+			no_digits();
 		    }
 		    else if (nondigit) goto trailing_uc;
-                    set_yylval_literal(rb_cstr_to_inum(tok(), 10, Qfalse));
+		    set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
 		    return tINTEGER;
 		}
 		if (c == '_') {
@@ -6987,7 +7160,7 @@ parser_yylex(struct parser_params *parser)
 		    /* prefixed octal */
 		    c = nextc();
 		    if (c == -1 || c == '_' || !ISDIGIT(c)) {
-			yyerror("numeric literal without digits");
+			no_digits();
 		    }
 		}
 		if (c >= '0' && c <= '7') {
@@ -7008,7 +7181,7 @@ parser_yylex(struct parser_params *parser)
 			pushback(c);
 			tokfix();
 			if (nondigit) goto trailing_uc;
-                        set_yylval_literal(rb_cstr_to_inum(tok(), 8, Qfalse));
+			set_yylval_literal(rb_cstr_to_inum(tok(), 8, FALSE));
 			return tINTEGER;
 		    }
 		    if (nondigit) {
@@ -7045,7 +7218,7 @@ parser_yylex(struct parser_params *parser)
 		    }
 		    else {
 			int c0 = nextc();
-			if (c == -1 || !ISDIGIT(c0)) {
+			if (c0 == -1 || !ISDIGIT(c0)) {
 			    pushback(c0);
 			    goto decode_num;
 			}
@@ -7091,13 +7264,13 @@ parser_yylex(struct parser_params *parser)
 
 	  decode_num:
 	    pushback(c);
-	    tokfix();
 	    if (nondigit) {
 		char tmp[30];
 	      trailing_uc:
-		sprintf(tmp, "trailing `%c' in number", nondigit);
+		snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
 		yyerror(tmp);
 	    }
+	    tokfix();
 	    if (is_float) {
 		double d = strtod(tok(), 0);
 		if (errno == ERANGE) {
@@ -7107,7 +7280,7 @@ parser_yylex(struct parser_params *parser)
                 set_yylval_literal(DBL2NUM(d));
 		return tFLOAT;
 	    }
-            set_yylval_literal(rb_cstr_to_inum(tok(), 10, Qfalse));
+	    set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
 	    return tINTEGER;
 	}
 
@@ -7118,7 +7291,7 @@ parser_yylex(struct parser_params *parser)
 	COND_LEXPOP();
 	CMDARG_LEXPOP();
 	if (c == ')')
-	    lex_state = EXPR_END;
+	    lex_state = EXPR_ENDFN;
 	else
 	    lex_state = EXPR_ENDARG;
 	return c;
@@ -7126,16 +7299,16 @@ parser_yylex(struct parser_params *parser)
       case ':':
 	c = nextc();
 	if (c == ':') {
-	    if (IS_BEG() ||
-		lex_state == EXPR_CLASS || (IS_ARG() && space_seen)) {
+	    if (IS_BEG() || lex_state == EXPR_CLASS || IS_SPCARG(-1)) {
 		lex_state = EXPR_BEG;
 		return tCOLON3;
 	    }
 	    lex_state = EXPR_DOT;
 	    return tCOLON2;
 	}
-	if (lex_state == EXPR_END || lex_state == EXPR_ENDARG || (c != -1 && ISSPACE(c))) {
+	if (IS_END() || ISSPACE(c)) {
 	    pushback(c);
+	    warn_balanced(":", "symbol literal");
 	    lex_state = EXPR_BEG;
 	    return ':';
 	}
@@ -7164,12 +7337,10 @@ parser_yylex(struct parser_params *parser)
 	    return tOP_ASGN;
 	}
 	pushback(c);
-	if (IS_ARG() && space_seen) {
-	    if (!ISSPACE(c)) {
-		arg_ambiguous();
-		lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
-		return tREGEXP_BEG;
-	    }
+	if (IS_SPCARG(c)) {
+	    arg_ambiguous();
+	    lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
+	    return tREGEXP_BEG;
 	}
 	switch (lex_state) {
 	  case EXPR_FNAME: case EXPR_DOT:
@@ -7177,6 +7348,7 @@ parser_yylex(struct parser_params *parser)
 	  default:
 	    lex_state = EXPR_BEG; break;
 	}
+	warn_balanced("/", "regexp literal");
 	return '/';
 
       case '^':
@@ -7196,7 +7368,7 @@ parser_yylex(struct parser_params *parser)
 
       case ';':
 	lex_state = EXPR_BEG;
-	command_start = Qtrue;
+	command_start = TRUE;
 	return ';';
 
       case ',':
@@ -7219,10 +7391,8 @@ parser_yylex(struct parser_params *parser)
 	if (IS_BEG()) {
 	    c = tLPAREN;
 	}
-	else if (space_seen) {
-	    if (IS_ARG()) {
-		c = tLPAREN_ARG;
-	    }
+	else if (IS_SPCARG(-1)) {
+	    c = tLPAREN_ARG;
 	}
 	paren_nest++;
 	COND_PUSH(0);
@@ -7260,9 +7430,11 @@ parser_yylex(struct parser_params *parser)
 	    lex_state = EXPR_BEG;
 	    lpar_beg = 0;
 	    --paren_nest;
+	    COND_PUSH(0);
+	    CMDARG_PUSH(0);
 	    return tLAMBEG;
 	}
-	if (IS_ARG() || lex_state == EXPR_END)
+	if (IS_ARG() || lex_state == EXPR_END || lex_state == EXPR_ENDFN)
 	    c = '{';          /* block (primary) */
 	else if (lex_state == EXPR_ENDARG)
 	    c = tLBRACE_ARG;  /* block (expr) */
@@ -7271,7 +7443,7 @@ parser_yylex(struct parser_params *parser)
 	COND_PUSH(0);
 	CMDARG_PUSH(0);
 	lex_state = EXPR_BEG;
-	if (c != tLBRACE) command_start = Qtrue;
+	if (c != tLBRACE) command_start = TRUE;
 	return c;
 
       case '\\':
@@ -7359,7 +7531,7 @@ parser_yylex(struct parser_params *parser)
 	    lex_state = EXPR_BEG;
 	    return tOP_ASGN;
 	}
-	if (IS_ARG() && space_seen && !ISSPACE(c)) {
+	if (IS_SPCARG(c)) {
 	    goto quotation;
 	}
 	switch (lex_state) {
@@ -7369,10 +7541,10 @@ parser_yylex(struct parser_params *parser)
 	    lex_state = EXPR_BEG; break;
 	}
 	pushback(c);
+	warn_balanced("%%", "string literal");
 	return '%';
 
       case '$':
-	last_state = lex_state;
 	lex_state = EXPR_END;
 	newtok();
 	c = nextc();
@@ -7406,7 +7578,7 @@ parser_yylex(struct parser_params *parser)
 	    tokadd('$');
 	    tokadd(c);
 	    tokfix();
-            set_yylval_id(rb_intern(tok()));
+	    set_yylval_name(rb_intern(tok()));
 	    return tGVAR;
 
 	  case '-':
@@ -7421,7 +7593,7 @@ parser_yylex(struct parser_params *parser)
 	    }
 	  gvar:
 	    tokfix();
-            set_yylval_id(rb_intern(tok()));
+	    set_yylval_name(rb_intern(tok()));
 	    return tGVAR;
 
 	  case '&':		/* $&: last match */
@@ -7570,12 +7742,11 @@ parser_yylex(struct parser_params *parser)
 	    }
 
 	    if ((lex_state == EXPR_BEG && !cmd_state) ||
-		lex_state == EXPR_ARG ||
-		lex_state == EXPR_CMDARG) {
+		IS_ARG()) {
 		if (peek(':') && !(lex_p + 1 < lex_pend && lex_p[1] == ':')) {
 		    lex_state = EXPR_BEG;
 		    nextc();
-		    set_yylval_id(TOK_INTERN(!ENC_SINGLE(mb)));
+		    set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
 		    return tLABEL;
 		}
 	    }
@@ -7588,11 +7759,11 @@ parser_yylex(struct parser_params *parser)
 		    enum lex_state_e state = lex_state;
 		    lex_state = kw->state;
 		    if (state == EXPR_FNAME) {
-                        set_yylval_id(rb_intern(kw->name));
+			set_yylval_name(rb_intern(kw->name));
 			return kw->id[0];
 		    }
 		    if (kw->id[0] == keyword_do) {
-			command_start = Qtrue;
+			command_start = TRUE;
 			if (lpar_beg && lpar_beg == paren_nest) {
 			    lpar_beg = 0;
 			    --paren_nest;
@@ -7625,6 +7796,9 @@ parser_yylex(struct parser_params *parser)
 		    lex_state = EXPR_ARG;
 		}
 	    }
+	    else if (lex_state == EXPR_FNAME) {
+		lex_state = EXPR_ENDFN;
+	    }
 	    else {
 		lex_state = EXPR_END;
 	    }
@@ -7632,7 +7806,7 @@ parser_yylex(struct parser_params *parser)
         {
             ID ident = TOK_INTERN(!ENC_SINGLE(mb));
 
-            set_yylval_id(ident);
+            set_yylval_name(ident);
             if (last_state != EXPR_DOT && is_local_id(ident) && lvar_defined(ident)) {
                 lex_state = EXPR_END;
             }
@@ -7823,6 +7997,7 @@ list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
 static int
 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
 {
+    if (NIL_P(tail)) return 1;
     if (!rb_enc_compatible(head, tail)) {
 	compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
 		      rb_enc_name(rb_enc_get(head)),
@@ -7846,7 +8021,7 @@ literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
 
     htype = nd_type(head);
     if (htype == NODE_EVSTR) {
-	NODE *node = NEW_DSTR(STR_NEW0());
+	NODE *node = NEW_DSTR(Qnil);
 	head = list_append(node, head);
     }
     switch (nd_type(tail)) {
@@ -7873,6 +8048,12 @@ literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
 	    rb_gc_force_recycle((VALUE)head);
 	    head = tail;
 	}
+	else if (NIL_P(tail->nd_lit)) {
+	    head->nd_alen += tail->nd_alen - 1;
+	    head->nd_next->nd_end->nd_next = tail->nd_next;
+	    head->nd_next->nd_end = tail->nd_next->nd_end;
+	    rb_gc_force_recycle((VALUE)tail);
+	}
 	else {
 	    nd_set_type(tail, NODE_ARRAY);
 	    tail->nd_head = NEW_STR(tail->nd_lit);
@@ -7895,7 +8076,7 @@ static NODE *
 evstr2dstr_gen(struct parser_params *parser, NODE *node)
 {
     if (nd_type(node) == NODE_EVSTR) {
-	node = list_append(NEW_DSTR(STR_NEW0()), node);
+	node = list_append(NEW_DSTR(Qnil), node);
     }
     return node;
 }
@@ -8009,11 +8190,24 @@ gettable_gen(struct parser_params *parser, ID id)
     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
     return 0;
 }
+#endif /* !RIPPER */
 
+#ifdef RIPPER
+static VALUE
+assignable_gen(struct parser_params *parser, VALUE lhs)
+#else
 static NODE*
 assignable_gen(struct parser_params *parser, ID id, NODE *val)
+#endif
 {
-    if (!id) return 0;
+#ifdef RIPPER
+    ID id = get_id(lhs);
+# define assignable_result(x) get_value(lhs)
+# define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
+#else
+# define assignable_result(x) x
+#endif
+    if (!id) return assignable_result(0);
     if (id == keyword_self) {
 	yyerror("Can't change the value of self");
     }
@@ -8038,53 +8232,55 @@ assignable_gen(struct parser_params *parser, ID id, NODE *val)
     else if (is_local_id(id)) {
 	if (dyna_in_block()) {
 	    if (dvar_curr(id)) {
-		return NEW_DASGN_CURR(id, val);
+		return assignable_result(NEW_DASGN_CURR(id, val));
 	    }
 	    else if (dvar_defined(id)) {
-		return NEW_DASGN(id, val);
+		return assignable_result(NEW_DASGN(id, val));
 	    }
 	    else if (local_id(id)) {
-		return NEW_LASGN(id, val);
+		return assignable_result(NEW_LASGN(id, val));
 	    }
-	    else{
+	    else {
 		dyna_var(id);
-		return NEW_DASGN_CURR(id, val);
+		return assignable_result(NEW_DASGN_CURR(id, val));
 	    }
 	}
 	else {
 	    if (!local_id(id)) {
 		local_var(id);
 	    }
-	    return NEW_LASGN(id, val);
+	    return assignable_result(NEW_LASGN(id, val));
 	}
     }
     else if (is_global_id(id)) {
-	return NEW_GASGN(id, val);
+	return assignable_result(NEW_GASGN(id, val));
     }
     else if (is_instance_id(id)) {
-	return NEW_IASGN(id, val);
+	return assignable_result(NEW_IASGN(id, val));
     }
     else if (is_const_id(id)) {
-	if (in_def || in_single)
-	    yyerror("dynamic constant assignment");
-	return NEW_CDECL(id, val, 0);
+	if (!in_def && !in_single)
+	    return assignable_result(NEW_CDECL(id, val, 0));
+	yyerror("dynamic constant assignment");
     }
     else if (is_class_id(id)) {
-	return NEW_CVASGN(id, val);
+	return assignable_result(NEW_CVASGN(id, val));
     }
     else {
 	compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
     }
-    return 0;
+    return assignable_result(0);
+#undef assignable_result
+#undef parser_yyerror
 }
 
-static void
+static ID
 shadowing_lvar_gen(struct parser_params *parser, ID name)
 {
     ID uscore;
 
     CONST_ID(uscore, "_");
-    if (uscore == name) return;
+    if (uscore == name) return name;
     if (dyna_in_block()) {
 	if (dvar_curr(name)) {
 	    yyerror("duplicated argument name");
@@ -8099,6 +8295,7 @@ shadowing_lvar_gen(struct parser_params *parser, ID name)
 	    yyerror("duplicated argument name");
 	}
     }
+    return name;
 }
 
 static void
@@ -8114,6 +8311,7 @@ new_bv_gen(struct parser_params *parser, ID name)
     dyna_var(name);
 }
 
+#ifndef RIPPER
 static NODE *
 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
 {
@@ -8165,7 +8363,10 @@ arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
     if (!node2) return node1;
     switch (nd_type(node1)) {
       case NODE_BLOCK_PASS:
-	node1->nd_iter = arg_concat(node1->nd_iter, node2);
+	if (node1->nd_head)
+	    node1->nd_head = arg_concat(node1->nd_head, node2);
+	else
+	    node1->nd_head = NEW_LIST(node2);
 	return node1;
       case NODE_ARGSPUSH:
 	if (nd_type(node2) != NODE_ARRAY) break;
@@ -8251,7 +8452,7 @@ value_expr_gen(struct parser_params *parser, NODE *node)
 	  case NODE_DEFN:
 	  case NODE_DEFS:
 	    parser_warning(node, "void value expression");
-	    return Qfalse;
+	    return FALSE;
 
 	  case NODE_RETURN:
 	  case NODE_BREAK:
@@ -8260,7 +8461,7 @@ value_expr_gen(struct parser_params *parser, NODE *node)
 	  case NODE_RETRY:
 	    if (!cond) yyerror("void value expression");
 	    /* or "control never reach"? */
-	    return Qfalse;
+	    return FALSE;
 
 	  case NODE_BLOCK:
 	    while (node->nd_next) {
@@ -8282,7 +8483,7 @@ value_expr_gen(struct parser_params *parser, NODE *node)
 		node = node->nd_body;
 		break;
 	    }
-	    if (!value_expr(node->nd_body)) return Qfalse;
+	    if (!value_expr(node->nd_body)) return FALSE;
 	    node = node->nd_else;
 	    break;
 
@@ -8293,11 +8494,11 @@ value_expr_gen(struct parser_params *parser, NODE *node)
 	    break;
 
 	  default:
-	    return Qtrue;
+	    return TRUE;
 	}
     }
 
-    return Qtrue;
+    return TRUE;
 }
 
 static void
@@ -8428,6 +8629,7 @@ reduce_nodes_gen(struct parser_params *parser, NODE **body)
      (reduce_nodes(&node->n1), body = &node->n2, 1))
 
     while (node) {
+	int newline = (int)(node->flags & NODE_FL_NEWLINE);
 	switch (nd_type(node)) {
 	  end:
 	  case NODE_NIL:
@@ -8435,9 +8637,11 @@ reduce_nodes_gen(struct parser_params *parser, NODE **body)
 	    return;
 	  case NODE_RETURN:
 	    *body = node = node->nd_stts;
+	    if (newline && node) node->flags |= NODE_FL_NEWLINE;
 	    continue;
 	  case NODE_BEGIN:
 	    *body = node = node->nd_body;
+	    if (newline && node) node->flags |= NODE_FL_NEWLINE;
 	    continue;
 	  case NODE_BLOCK:
 	    body = &node->nd_end->nd_head;
@@ -8461,6 +8665,7 @@ reduce_nodes_gen(struct parser_params *parser, NODE **body)
 	    return;
 	}
 	node = *body;
+	if (newline && node) node->flags |= NODE_FL_NEWLINE;
     }
 
 #undef subnodes
@@ -8476,6 +8681,7 @@ assign_in_cond(struct parser_params *parser, NODE *node)
 
       case NODE_LASGN:
       case NODE_DASGN:
+      case NODE_DASGN_CURR:
       case NODE_GASGN:
       case NODE_IASGN:
 	break;
@@ -8484,6 +8690,7 @@ assign_in_cond(struct parser_params *parser, NODE *node)
 	return 0;
     }
 
+    if (!node->nd_value) return 1;
     switch (nd_type(node->nd_value)) {
       case NODE_LIT:
       case NODE_STR:
@@ -8534,7 +8741,7 @@ fixup_nodes(NODE **rootnode)
 	  case NODE_DOT2:
 	  case NODE_DOT3:
 	    val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
-			       type == NODE_DOT3 ? Qtrue : Qfalse);
+			       type == NODE_DOT3);
 	    rb_gc_force_recycle((VALUE)head->nd_beg);
 	    rb_gc_force_recycle((VALUE)head->nd_end);
 	    nd_set_type(head, NODE_LIT);
@@ -8653,9 +8860,9 @@ static NODE*
 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
 {
     value_expr(left);
-    if (left && nd_type(left) == type) {
+    if (left && (enum node_type)nd_type(left) == type) {
 	NODE *node = left, *second;
-	while ((second = node->nd_2nd) != 0 && nd_type(second) == type) {
+	while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
 	    node = second;
 	}
 	node->nd_2nd = NEW_NODE(type, second, right, 0);
@@ -8759,6 +8966,7 @@ new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, ID b
     ruby_sourceline = saved_line;
     return node;
 }
+#endif /* !RIPPER */
 
 static void
 local_push_gen(struct parser_params *parser, int inherit_dvars)
@@ -8782,6 +8990,7 @@ local_pop_gen(struct parser_params *parser)
     lvtbl = local;
 }
 
+#ifndef RIPPER
 static ID*
 vtable_tblcpy(ID *buf, const struct vtable *src)
 {
@@ -8810,6 +9019,7 @@ local_tbl_gen(struct parser_params *parser)
     buf[0] = cnt;
     return buf;
 }
+#endif
 
 static int
 arg_var_gen(struct parser_params *parser, ID id)
@@ -8847,15 +9057,16 @@ local_id_gen(struct parser_params *parser, ID id)
     }
 }
 
-static void
+static const struct vtable *
 dyna_push_gen(struct parser_params *parser)
 {
     lvtbl->args = vtable_alloc(lvtbl->args);
     lvtbl->vars = vtable_alloc(lvtbl->vars);
+    return lvtbl->args;
 }
 
 static void
-dyna_pop_gen(struct parser_params *parser)
+dyna_pop_1(struct parser_params *parser)
 {
     struct vtable *tmp;
 
@@ -8867,6 +9078,20 @@ dyna_pop_gen(struct parser_params *parser)
     vtable_free(tmp);
 }
 
+static void
+dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
+{
+    while (lvtbl->args != lvargs) {
+	dyna_pop_1(parser);
+	if (!lvtbl->args) {
+	    struct local_vars *local = lvtbl->prev;
+	    xfree(lvtbl);
+	    lvtbl = local;
+	}
+    }
+    dyna_pop_1(parser);
+}
+
 static int
 dyna_in_block_gen(struct parser_params *parser)
 {
@@ -8906,7 +9131,8 @@ dvar_curr_gen(struct parser_params *parser, ID id)
 	    vtable_included(lvtbl->vars, id));
 }
 
-VALUE rb_reg_compile(VALUE str, int options);
+#ifndef RIPPER
+VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
 VALUE rb_reg_check_preprocess(VALUE);
 
 static void
@@ -8948,17 +9174,19 @@ reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
         c, rb_enc_name(rb_enc_get(str)));
 }
 
-static void
+static int
 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
 {
     VALUE err;
-    reg_fragment_setenc_gen(parser, str, options);
+    reg_fragment_setenc(str, options);
     err = rb_reg_check_preprocess(str);
     if (err != Qnil) {
         err = rb_obj_as_string(err);
         compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
 	RB_GC_GUARD(err);
+	return 0;
     }
+    return 1;
 }
 
 typedef struct {
@@ -8976,7 +9204,7 @@ reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
     reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
     struct parser_params* parser = arg->parser;
     rb_encoding *enc = arg->enc;
-    int len = name_end - name;
+    long len = name_end - name;
     const char *s = (const char *)name;
     ID var;
 
@@ -8988,7 +9216,8 @@ reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
     }
 
     if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
-	rb_reserved_word(s, len) || !rb_enc_symname2_p(s, len, enc)) {
+	(len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
+	!rb_enc_symname2_p(s, len, enc)) {
         return ST_CONTINUE;
     }
     var = rb_intern3(s, len, enc);
@@ -9048,7 +9277,7 @@ reg_compile_gen(struct parser_params* parser, VALUE str, int options)
 
     reg_fragment_setenc(str, options);
     err = rb_errinfo();
-    re = rb_reg_compile(str, options & RE_OPTION_MASK);
+    re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
     if (NIL_P(re)) {
 	ID mesg = rb_intern("mesg");
 	VALUE m = rb_attr_get(rb_errinfo(), mesg);
@@ -9078,7 +9307,7 @@ rb_parser_append_print(VALUE vparser, NODE *node)
 
     if (!node) return node;
 
-    Data_Get_Struct(vparser, struct parser_params, parser);
+    TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
 
     node = node->nd_body;
 
@@ -9110,7 +9339,7 @@ rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
 
     if (!node) return node;
 
-    Data_Get_Struct(vparser, struct parser_params, parser);
+    TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
 
     node = node->nd_body;
 
@@ -9168,14 +9397,20 @@ static const struct {
     {tCOLON2,	"::"},
 };
 
-#define op_tbl_count (sizeof(op_tbl) / sizeof(op_tbl[0]))
+#define op_tbl_count numberof(op_tbl)
+
+#ifndef ENABLE_SELECTOR_NAMESPACE
+#define ENABLE_SELECTOR_NAMESPACE 0
+#endif
 
 static struct symbols {
     ID last_id;
     st_table *sym_id;
     st_table *id_str;
+#if ENABLE_SELECTOR_NAMESPACE
     st_table *ivar2_id;
     st_table *id_ivar2;
+#endif
     VALUE op_sym[tLAST_TOKEN];
 } global_symbols = {tLAST_ID};
 
@@ -9184,6 +9419,7 @@ static const struct st_hash_type symhash = {
     rb_str_hash,
 };
 
+#if ENABLE_SELECTOR_NAMESPACE
 struct ivar2_key {
     ID id;
     VALUE klass;
@@ -9208,14 +9444,17 @@ static const struct st_hash_type ivar2_hash_type = {
     ivar2_cmp,
     ivar2_hash,
 };
+#endif
 
 void
 Init_sym(void)
 {
     global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
     global_symbols.id_str = st_init_numtable_with_size(1000);
+#if ENABLE_SELECTOR_NAMESPACE
     global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
     global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
+#endif
 
     Init_id();
 }
@@ -9227,6 +9466,7 @@ rb_gc_mark_symbols(void)
     rb_gc_mark_locations(global_symbols.op_sym,
 			 global_symbols.op_sym + tLAST_TOKEN);
 }
+#endif /* !RIPPER */
 
 static ID
 internal_id_gen(struct parser_params *parser)
@@ -9236,6 +9476,7 @@ internal_id_gen(struct parser_params *parser)
     return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
 }
 
+#ifndef RIPPER
 static int
 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
 {
@@ -9262,7 +9503,7 @@ is_special_global_name(const char *m, const char *e, rb_encoding *enc)
 	do {
 	    if (!ISASCII(*m)) mb = 1;
 	    ++m;
-	} while (rb_enc_isdigit(*m, enc));
+	} while (m < e && rb_enc_isdigit(*m, enc));
     }
     return m == e ? mb + 1 : 0;
 }
@@ -9280,19 +9521,19 @@ rb_enc_symname_p(const char *name, rb_encoding *enc)
 }
 
 int
-rb_enc_symname2_p(const char *name, int len, rb_encoding *enc)
+rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
 {
     const char *m = name;
     const char *e = m + len;
-    int localid = Qfalse;
+    int localid = FALSE;
 
-    if (!m) return Qfalse;
+    if (!m) return FALSE;
     switch (*m) {
       case '\0':
-	return Qfalse;
+	return FALSE;
 
       case '$':
-	if (is_special_global_name(++m, e, enc)) return Qtrue;
+	if (is_special_global_name(++m, e, enc)) return TRUE;
 	goto id;
 
       case '@':
@@ -9317,7 +9558,7 @@ rb_enc_symname2_p(const char *name, int len, rb_encoding *enc)
 	switch (*++m) {
 	  case '~': ++m; break;
 	  case '=': if (*++m == '=') ++m; break;
-	  default: return Qfalse;
+	  default: return FALSE;
 	}
 	break;
 
@@ -9334,15 +9575,15 @@ rb_enc_symname2_p(const char *name, int len, rb_encoding *enc)
 	break;
 
       case '[':
-	if (*++m != ']') return Qfalse;
+	if (*++m != ']') return FALSE;
 	if (*++m == '=') ++m;
 	break;
 
       case '!':
 	switch (*++m) {
-	  case '\0': return Qtrue;
+	  case '\0': return TRUE;
 	  case '=': case '~': ++m; break;
-	  default: return Qfalse;
+	  default: return FALSE;
 	}
 	break;
 
@@ -9350,7 +9591,7 @@ rb_enc_symname2_p(const char *name, int len, rb_encoding *enc)
 	localid = !rb_enc_isupper(*m, enc);
       id:
 	if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
-	    return Qfalse;
+	    return FALSE;
 	while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
 	if (localid) {
 	    switch (*m) {
@@ -9359,7 +9600,7 @@ rb_enc_symname2_p(const char *name, int len, rb_encoding *enc)
 	}
 	break;
     }
-    return *m ? Qfalse : Qtrue;
+    return m == e;
 }
 
 static ID
@@ -9380,8 +9621,9 @@ rb_intern3(const char *name, long len, rb_encoding *enc)
     unsigned char c;
     VALUE str;
     ID id;
-    int last;
+    long last;
     int mb;
+    st_data_t data;
     struct RString fake_str;
     fake_str.basic.flags = T_STRING|RSTRING_NOEMBED|FL_FREEZE;
     fake_str.basic.klass = rb_cString;
@@ -9391,8 +9633,12 @@ rb_intern3(const char *name, long len, rb_encoding *enc)
     str = (VALUE)&fake_str;
     rb_enc_associate(str, enc);
 
-    if (st_lookup(global_symbols.sym_id, str, (st_data_t *)&id))
-	return id;
+    if (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN) {
+    	rb_raise(rb_eEncodingError, "invalid encoding symbol");
+    }
+
+    if (st_lookup(global_symbols.sym_id, str, &data))
+	return (ID)data;
 
     if (rb_cString && !rb_enc_asciicompat(enc)) {
 	id = ID_JUNK;
@@ -9482,6 +9728,16 @@ rb_intern3(const char *name, long len, rb_encoding *enc)
       mbstr:;
     }
   new_id:
+    if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
+	if (len > 20) {
+	    rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
+		     name);
+	}
+	else {
+	    rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
+		     (int)len, name);
+	}
+    }
     id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
   id_register:
     return register_symid(id, name, len, enc);
@@ -9525,7 +9781,7 @@ rb_id2str(ID id)
     if (id < tLAST_TOKEN) {
 	int i = 0;
 
-	if (rb_ispunct(id)) {
+	if (id < INT_MAX && rb_ispunct((int)id)) {
 	    VALUE str = global_symbols.op_sym[i = (int)id];
 	    if (!str) {
 		char name[2];
@@ -9622,36 +9878,31 @@ rb_sym_all_symbols(void)
 int
 rb_is_const_id(ID id)
 {
-    if (is_const_id(id)) return Qtrue;
-    return Qfalse;
+    return is_const_id(id);
 }
 
 int
 rb_is_class_id(ID id)
 {
-    if (is_class_id(id)) return Qtrue;
-    return Qfalse;
+    return is_class_id(id);
 }
 
 int
 rb_is_instance_id(ID id)
 {
-    if (is_instance_id(id)) return Qtrue;
-    return Qfalse;
+    return is_instance_id(id);
 }
 
 int
 rb_is_local_id(ID id)
 {
-    if (is_local_id(id)) return Qtrue;
-    return Qfalse;
+    return is_local_id(id);
 }
 
 int
 rb_is_junk_id(ID id)
 {
-    if (is_junk_id(id)) return Qtrue;
-    return Qfalse;
+    return is_junk_id(id);
 }
 
 #endif /* !RIPPER */
@@ -9676,7 +9927,7 @@ parser_initialize(struct parser_params *parser)
     parser->parser_tokidx = 0;
     parser->parser_toksiz = 0;
     parser->parser_heredoc_end = 0;
-    parser->parser_command_start = Qtrue;
+    parser->parser_command_start = TRUE;
     parser->parser_deferred_nodes = 0;
     parser->parser_lex_pbeg = 0;
     parser->parser_lex_p = 0;
@@ -9695,7 +9946,7 @@ parser_initialize(struct parser_params *parser)
 
     parser->result = Qnil;
     parser->parsing_thread = Qnil;
-    parser->toplevel_p = Qtrue;
+    parser->toplevel_p = TRUE;
 #endif
 #ifdef YYMALLOC
     parser->heap = NULL;
@@ -9754,10 +10005,46 @@ parser_free(void *ptr)
     xfree(p);
 }
 
+static size_t
+parser_memsize(const void *ptr)
+{
+    struct parser_params *p = (struct parser_params*)ptr;
+    struct local_vars *local;
+    size_t size = sizeof(*p);
+
+    if (!ptr) return 0;
+    size += p->parser_toksiz;
+    for (local = p->parser_lvtbl; local; local = local->prev) {
+	size += sizeof(*local);
+	if (local->vars) size += local->vars->capa * sizeof(ID);
+    }
+#ifndef RIPPER
+    if (p->parser_ruby_sourcefile) {
+	size += strlen(p->parser_ruby_sourcefile) + 1;
+    }
+#endif
+    return size;
+}
+
+static const rb_data_type_t parser_data_type = {
+    "parser",
+    parser_mark,
+    parser_free,
+    parser_memsize,
+};
+
 VALUE rb_parser_get_yydebug(VALUE);
 VALUE rb_parser_set_yydebug(VALUE, VALUE);
 
 #ifndef RIPPER
+#undef rb_reserved_word
+
+const struct kwtable *
+rb_reserved_word(const char *str, unsigned int len)
+{
+    return reserved_word(str, len);
+}
+
 static struct parser_params *
 parser_new(void)
 {
@@ -9774,7 +10061,7 @@ rb_parser_new(void)
 {
     struct parser_params *p = parser_new();
 
-    return Data_Wrap_Struct(0, parser_mark, parser_free, p);
+    return TypedData_Wrap_Struct(0, &parser_data_type, p);
 }
 
 /*
@@ -9789,7 +10076,7 @@ rb_parser_end_seen_p(VALUE vparser)
 {
     struct parser_params *parser;
 
-    Data_Get_Struct(vparser, struct parser_params, parser);
+    TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
     return ruby__end__seen ? Qtrue : Qfalse;
 }
 
@@ -9804,7 +10091,7 @@ rb_parser_encoding(VALUE vparser)
 {
     struct parser_params *parser;
 
-    Data_Get_Struct(vparser, struct parser_params, parser);
+    TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
     return rb_enc_from_encoding(parser->enc);
 }
 
@@ -9819,7 +10106,7 @@ rb_parser_get_yydebug(VALUE self)
 {
     struct parser_params *parser;
 
-    Data_Get_Struct(self, struct parser_params, parser);
+    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
     return yydebug ? Qtrue : Qfalse;
 }
 
@@ -9834,7 +10121,7 @@ rb_parser_set_yydebug(VALUE self, VALUE flag)
 {
     struct parser_params *parser;
 
-    Data_Get_Struct(self, struct parser_params, parser);
+    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
     yydebug = RTEST(flag);
     return flag;
 }
@@ -9928,7 +10215,10 @@ ripper_validate_object(VALUE self, VALUE x)
       case T_FLOAT:
         return x;
       case T_NODE:
-        rb_raise(rb_eArgError, "NODE given: %p", x);
+	if (nd_type(x) != NODE_LASGN) {
+	    rb_raise(rb_eArgError, "NODE given: %p", x);
+	}
+	return ((NODE *)x)->nd_rval;
       default:
         rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
                  x, rb_obj_classname(x));
@@ -9937,7 +10227,7 @@ ripper_validate_object(VALUE self, VALUE x)
 }
 #endif
 
-#define validate(x)
+#define validate(x) (x = get_value(x))
 
 static VALUE
 ripper_dispatch0(struct parser_params *parser, ID mid)
@@ -10065,9 +10355,9 @@ ripper_id2sym(ID id)
     char buf[8];
 
     if (id <= 256) {
-        buf[0] = id;
+        buf[0] = (char)id;
         buf[1] = '\0';
-        return ID2SYM(rb_intern(buf));
+        return ID2SYM(rb_intern2(buf, 1));
     }
     if ((name = keyword_id_to_str(id))) {
         return ID2SYM(rb_intern(name));
@@ -10084,15 +10374,30 @@ ripper_id2sym(ID id)
         if (!name) {
             rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
         }
-        break;
+        return ID2SYM(id);
     }
     return ID2SYM(rb_intern(name));
 }
 
+static ID
+ripper_get_id(VALUE v)
+{
+    NODE *nd;
+    if (!RB_TYPE_P(v, T_NODE)) return 0;
+    nd = (NODE *)v;
+    if (nd_type(nd) != NODE_LASGN) return 0;
+    return nd->nd_vid;
+}
+
 static VALUE
-ripper_intern(const char *s)
+ripper_get_value(VALUE v)
 {
-    return ID2SYM(rb_intern(s));
+    NODE *nd;
+    if (v == Qundef) return Qnil;
+    if (!RB_TYPE_P(v, T_NODE)) return v;
+    nd = (NODE *)v;
+    if (nd_type(nd) != NODE_LASGN) return Qnil;
+    return nd->nd_rval;
 }
 
 static void
@@ -10156,7 +10461,7 @@ ripper_s_allocate(VALUE klass)
 
     p = ALLOC_N(struct parser_params, 1);
     MEMZERO(p, struct parser_params, 1);
-    self = Data_Wrap_Struct(klass, parser_mark, parser_free, p);
+    self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
     p->value = self;
     return self;
 }
@@ -10179,7 +10484,7 @@ ripper_initialize(int argc, VALUE *argv, VALUE self)
     struct parser_params *parser;
     VALUE src, fname, lineno;
 
-    Data_Get_Struct(self, struct parser_params, parser);
+    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
     rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
     if (rb_obj_respond_to(src, ripper_id_gets, 0)) {
         parser->parser_lex_gets = ripper_lex_get_generic;
@@ -10218,7 +10523,7 @@ ripper_parse0(VALUE parser_v)
 {
     struct parser_params *parser;
 
-    Data_Get_Struct(parser_v, struct parser_params, parser);
+    TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
     parser_prepare(parser);
     ripper_yyparse((void*)parser);
     return parser->result;
@@ -10229,7 +10534,7 @@ ripper_ensure(VALUE parser_v)
 {
     struct parser_params *parser;
 
-    Data_Get_Struct(parser_v, struct parser_params, parser);
+    TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
     parser->parsing_thread = Qnil;
     return Qnil;
 }
@@ -10245,7 +10550,7 @@ ripper_parse(VALUE self)
 {
     struct parser_params *parser;
 
-    Data_Get_Struct(self, struct parser_params, parser);
+    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
     if (!ripper_initialized_p(parser)) {
         rb_raise(rb_eArgError, "method called for uninitialized object");
     }
@@ -10274,7 +10579,7 @@ ripper_column(VALUE self)
     struct parser_params *parser;
     long col;
 
-    Data_Get_Struct(self, struct parser_params, parser);
+    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
     if (!ripper_initialized_p(parser)) {
         rb_raise(rb_eArgError, "method called for uninitialized object");
     }
@@ -10283,6 +10588,24 @@ ripper_column(VALUE self)
     return LONG2NUM(col);
 }
 
+/*
+ *  call-seq:
+ *    ripper#filename   -> String
+ *
+ *  Return current parsing filename.
+ */
+static VALUE
+ripper_filename(VALUE self)
+{
+    struct parser_params *parser;
+
+    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
+    if (!ripper_initialized_p(parser)) {
+        rb_raise(rb_eArgError, "method called for uninitialized object");
+    }
+    return parser->parser_ruby_sourcefile_string;
+}
+
 /*
  *  call-seq:
  *    ripper#lineno   -> Integer
@@ -10295,7 +10618,7 @@ ripper_lineno(VALUE self)
 {
     struct parser_params *parser;
 
-    Data_Get_Struct(self, struct parser_params, parser);
+    TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
     if (!ripper_initialized_p(parser)) {
         rb_raise(rb_eArgError, "method called for uninitialized object");
     }
@@ -10334,6 +10657,7 @@ Init_ripper(void)
     rb_define_method(Ripper, "initialize", ripper_initialize, -1);
     rb_define_method(Ripper, "parse", ripper_parse, 0);
     rb_define_method(Ripper, "column", ripper_column, 0);
+    rb_define_method(Ripper, "filename", ripper_filename, 0);
     rb_define_method(Ripper, "lineno", ripper_lineno, 0);
     rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
     rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);